Korean
언어
English
Japanese
German
Korean
Portuguese, Brazilian
French
Table of Contents
  • Docs >
  • 포트폴리오 최적화
Shortcuts

참고

이 페이지는 “tutorials/finance/01_portfolio_optimization.ipynb” __ 에서 생성되었다.

“BM 퀀텀 랩 <https://quantum-computing.ibm.com/jupyter/tutorial/finance/01_portfolio_optimization.ipynb>” 에서 대화식으로 실행하십시오.

포트폴리오 최적화

소개

이 학습서는 :math:의 “n” 자산에 대한 평균 분산 포트폴리오 최적화 문제점을 해결하는 방법을 보인다.

\(\begin{aligned} \min_{x \in \{0, 1\}^n} q x^T \Sigma x - \mu^T x\\ \text{subject to: } 1^T x = B \end{aligned}\)

여기서 다음과 같은 표기법을 사용한다.

  • :math:” x in{0, 1} ^ n은 어떤 자산을 선택하거나(:math:) x[i] = 1) 선택하지 않는(:math:) x[i] = 0)것을 이진 결정 변수 벡터로 표기한다.

  • :math:’mu mathbb{R}^n’은 자산에 대한 예상 수익을 정의한다.

  • :math:’ Sigma in mathbb{R}^ {n times n}’는 자산들 사이의 공변량을 나타낸다.

  • :math:’ q> 0은 의사 결정자의 리스크 선호를 제어한다.

  • 그리고 :math:의 B는 예산, 즉 :math:에서 선택할 수 있는 자산의 수를 의미한다.

We assume the following simplifications: - all assets have the same price (normalized to 1), - the full budget \(B\) has to be spent, i.e. one has to select exactly \(B\) assets.

같음 제약 조건 :math: ‘1 ^ T x = B’ 는 매개변수에의해 스케일링되고 대상 함수로부터 차감되는 벌점항 :math:’(1 ^ T x-B)^2’ 에 매핑된다. 여기서 도출되는 문제는 바닥 상태가 최적의 솔루션에 해당하는 해밀토니안에 매핑 될 수 있습니다. 이 튜토리얼은 VQE (Variational Quantum Eigensolver) 또는 QAOA (Quantum Approximate Optimization Algorithm)를 사용하여 지정된 매개 변수 세트에 대한 최적의 솔루션을 찾는 방법을 보여준다.

Experiments on real quantum hardware for this problem are reported for instance in the following paper: Improving Variational Quantum Optimization using CVaR. Barkoutsos et al. 2019.

[1]:

from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.finance.applications.ising import portfolio
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.finance.data_providers import RandomDataProvider
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
import numpy as np
import matplotlib.pyplot as plt
import datetime

[Optional] 실제 기기에서 실험을 실행하기위한 설정 토큰

실제 장치에서 실험을 실행하려면 먼저 계정을 설정해야 한다.

참고사항: 아직 토큰을 저장하지 않은 경우``IBMQ.save_account ( ‘MY_API_TOKEN’)``을 사용하여 저장한다.

문제 인스턴스 정의

여기에 해밀토니안을 위한 Operator 인스턴스가 생성되었다. 이 경우, 파울리스(paulis )는 포트폴리오 문제에서 치환 된 이징 해밀토니안에서부터 나왔다. 우리는이 노트북에 무작위 포트폴리오를 사용한다. 다음과 같이 실제 재무 데이터를 사용하여 이를 확장하는 것은 `Loading and Processing Stock-Market Time-Series Data <11_time_series.ipynb>`__서 볼수 있다.

[2]:

# set number of assets (= number of qubits)
num_assets = 4

# Generate expected return and covariance matrix from (random) time-series
stocks = [("TICKER%s" % i) for i in range(num_assets)]
data = RandomDataProvider(tickers=stocks,
                 start=datetime.datetime(2016,1,1),
                 end=datetime.datetime(2016,1,30))
data.run()
mu = data.get_period_return_mean_vector()
sigma = data.get_period_return_covariance_matrix()

[3]:

# plot sigma
plt.imshow(sigma, interpolation='nearest')
plt.show()
../../_images/tutorials_finance_01_portfolio_optimization_6_0.png 
[4]:

q = 0.5                   # set risk factor
budget = num_assets // 2  # set budget
penalty = num_assets      # set parameter to scale the budget penalty term

qubitOp, offset = portfolio.get_operator(mu, sigma, q, budget, penalty)

결과를 적절한 포맷으로 인쇄하기 위한 몇 가지 유틸리티 방법을 정의한다.

[5]:

def index_to_selection(i, num_assets):
    s = "{0:b}".format(i).rjust(num_assets)
    x = np.array([1 if s[i]=='1' else 0 for i in reversed(range(num_assets))])
    return x

def print_result(result):
    selection = sample_most_likely(result.eigenstate)
    value = portfolio.portfolio_value(selection, mu, sigma, q, budget, penalty)
    print('Optimal: selection {}, value {:.4f}'.format(selection, value))

    eigenvector = result.eigenstate if isinstance(result.eigenstate, np.ndarray) else result.eigenstate.to_matrix()
    probabilities = np.abs(eigenvector)**2
    i_sorted = reversed(np.argsort(probabilities))
    print('\n----------------- Full result ---------------------')
    print('selection\tvalue\t\tprobability')
    print('---------------------------------------------------')
    for i in i_sorted:
        x = index_to_selection(i, num_assets)
        value = portfolio.portfolio_value(x, mu, sigma, q, budget, penalty)
        probability = probabilities[i]
        print('%10s\t%.4f\t\t%.4f' %(x, value, probability))

NumPyMinimumEigensolver (고전적인 참고자)

기존의 방식을 이용하여 문제를 풀어보자.

We can now use the Operator we built above without regard to the specifics of how it was created. We set the algorithm for the NumPyMinimumEigensolver so we can have a classical reference. The problem is set for ‘ising’. Backend is not required since this is computed classically not using quantum computation. The result is returned as a dictionary.

[6]:

exact_eigensolver = NumPyMinimumEigensolver(qubitOp)
result = exact_eigensolver.run()

print_result(result)

Optimal: selection [0 1 0 1], value -0.0005

----------------- Full result ---------------------
selection       value           probability
---------------------------------------------------
 [0 1 0 1]      -0.0005         1.0000
 [1 1 1 1]      16.0040         0.0000
 [0 1 1 1]      4.0013          0.0000
 [1 0 1 1]      4.0052          0.0000
 [0 0 1 1]      0.0025          0.0000
 [1 1 0 1]      4.0023          0.0000
 [1 0 0 1]      0.0034          0.0000
 [0 0 0 1]      4.0007          0.0000
 [1 1 1 0]      4.0033          0.0000
 [0 1 1 0]      0.0007          0.0000
 [1 0 1 0]      0.0045          0.0000
 [0 0 1 0]      4.0018          0.0000
 [1 1 0 0]      0.0016          0.0000
 [0 1 0 0]      3.9988          0.0000
 [1 0 0 0]      4.0027          0.0000
 [0 0 0 0]      16.0000         0.0000

VQE를 사용한 솔루션

이제 변분법적 양자 알고리즘 (VQE) 를 사용하여 문제를 해결할 수 있다. 사용할 최적화 프로그램 및 분산 양식을 지정 한다.

노트: 백엔드의 이름을 설정하여 다른 백엔드로 전환할 수 있다.

[7]:

backend = Aer.get_backend('statevector_simulator')
seed = 50

cobyla = COBYLA()
cobyla.set_options(maxiter=500)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=3, entanglement='full')
vqe = VQE(qubitOp, ry, cobyla)
vqe.random_seed = seed

quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)

result = vqe.run(quantum_instance)

print_result(result)

Optimal: selection [0. 0. 1. 1.], value 0.0025

----------------- Full result ---------------------
selection       value           probability
---------------------------------------------------
 [0 0 1 1]      0.0025          0.7519
 [0 1 1 0]      0.0007          0.2480
 [1 1 0 1]      4.0023          0.0000
 [1 1 0 0]      0.0016          0.0000
 [1 0 0 1]      0.0034          0.0000
 [0 1 0 1]      -0.0005         0.0000
 [1 1 1 0]      4.0033          0.0000
 [1 0 0 0]      4.0027          0.0000
 [1 0 1 1]      4.0052          0.0000
 [1 0 1 0]      0.0045          0.0000
 [0 0 1 0]      4.0018          0.0000
 [0 1 0 0]      3.9988          0.0000
 [0 0 0 1]      4.0007          0.0000
 [0 1 1 1]      4.0013          0.0000
 [0 0 0 0]      16.0000         0.0000
 [1 1 1 1]      16.0040         0.0000

QAOA를 사용한 솔루션

또한 양자 근사 최적화 알고리즘(QAOA) 을 사용한 결과를 보여 준다. 이는 다른 분산 알고리즘이며 문제를 기반으로 만들어지는 내부 변수 양식을 사용합니다.

[8]:

backend = Aer.get_backend('statevector_simulator')
seed = 50

cobyla = COBYLA()
cobyla.set_options(maxiter=250)
qaoa = QAOA(qubitOp, cobyla, 3)

qaoa.random_seed = seed

quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)

result = qaoa.run(quantum_instance)

print_result(result)

Optimal: selection [0. 1. 0. 1.], value -0.0005

----------------- Full result ---------------------
selection       value           probability
---------------------------------------------------
 [0 1 0 1]      -0.0005         0.1673
 [0 1 1 0]      0.0007          0.1670
 [1 1 0 0]      0.0016          0.1668
 [0 0 1 1]      0.0025          0.1666
 [1 0 0 1]      0.0034          0.1663
 [1 0 1 0]      0.0045          0.1661
 [1 1 1 1]      16.0040         0.0000
 [0 0 0 0]      16.0000         0.0000
 [0 1 1 1]      4.0013          0.0000
 [0 1 0 0]      3.9988          0.0000
 [1 1 0 1]      4.0023          0.0000
 [1 0 1 1]      4.0052          0.0000
 [1 0 0 0]      4.0027          0.0000
 [1 1 1 0]      4.0033          0.0000
 [0 0 0 1]      4.0007          0.0000
 [0 0 1 0]      4.0018          0.0000

[9]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
Qiskit0.19.1
Terra0.14.1
Aer0.5.1
Ignis0.3.0
Aqua0.7.0
IBM Q Provider0.7.0
System information
Python3.7.4 (default, Aug 13 2019, 15:17:50) [Clang 4.0.1 (tags/RELEASE_401/final)]
OSDarwin
CPUs6
Memory (Gb)16.0
Fri Jul 17 17:36:55 2020 CEST

This code is a part of Qiskit

© Copyright IBM 2017, 2020.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

[ ]:

© Copyright 2021, Qiskit Development Team. 최종 업데이트: 2021/06/04

Built with Sphinx using a theme provided by Read the Docs.