참고

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

Run interactively in the IBM Quantum lab.

포트폴리오 다양화¶

소개¶

자산 관리에서는 능동적이고 수동적인 투자 관리에 대한 두 가지 접근 방식이 있다. 소극적인 투자관리 분야에서는 인덱스추적 펀드가 있고 포트폴리오 다각화에 기반을 둔 접근방법이 있는데, 이는 많은 자산을 소수의 주식으로 포토폴리오를 만드는 것이 목적이다. 이 글에서는 최근 두 가지 이유로 유명해진 포트폴리오 다변화 문제를 설명합니다. 1. 제한된 수수료와 제한된 예산으로 인덱스 (또는 유사한 대규모 자산 세트) 의 성능을 모방할 수 있다.. 즉, 전통적인 인덱스 추적은 인덱스에 있는 모든 자산을 구매하며 이상적으로 인덱스에서와 동일한 가중치를 사용한다. 이것은 많은 이유로 불가능 하다: 자산 당 단일 라운드 로트의 총 수는 관리 하에 있는 자산보다 많은 양일 수 있고, 적분기 제약조건을 갖는 인덱스 추적 문제의 큰 스케일은 최적화 문제를 어렵게 할 수 있고, 인덱스 내의 가중치에 대한 위치를 조정하기 위해 빈번한 리밸런싱의 수수료는 비싸다. 따라서 :math:’n’ 자산을 나타내는 :math:’q’ 자산 포트폴리오를 선택하는 것이 일반적인 접근법이지만, :math:’q’ 가 :math:’n’ 보다 현저히 작지만, 포트폴리오가 기본 시장의 흐름을 따른다. :math:의 q 클러스터에 자산을 그룹화하는 방법 및 :math:’q’ 자산이 :math:’q’ 클러스터를 표시하는 방법을 판별하는 방법은 대규모 최적화 문제점을 해결하는 방법이다. 여기서 도입된 포트폴리오 다변화 문제에 대한 수학적 모델을 설명한다 [Cornuejols & Tutuncu, 2006]. 이것은 공분산 매트릭스를 넘어서 시계열 (time-series) 사이의 유사성 측정을 가능하게 한다. 전통적으로, 현대적인 포트폴리오 이론은 공분산 행렬을 자산 사이의 유사성 측정으로 간주한다. 그러나, 공분산 매트릭스는 불완전하다. 예를 들어 런던과 뉴욕에 모두 상장된 회사를 생각해 보라. 두 목록 모두 매우 유사해야 하지만, 시장이 열리는 시간의 부분적인 겹침 때문에 두 목록 가격의 시계열 부분만 겹칠 수 있습니다. 공분산 대신에, 예를 들어, 2개의 시계열 사이의 유사성 측정으로서, [Berndt and Clifford, 1994] 의 동적 시간 왜곡을 고려할 수 있는데, 이는 일정 기간 동안 데이터가 시계열 중 단지 하나에 의해 포착되는 반면, 다른 경우에는, 두 시계열이 모두 주가의 평행한 전개로 인해 유사성을 나타낸다.

본 전체 워크플로우(workflow) 는 다음과 같다.

기초 세트 자산을 선택합니다. 우리의 경우, 이것은 적은 수의 미국 주식이다.
자산 가격의 진화를 포착하는 시계열을 로드합니다. 우리의 경우, 이는 Wikipedia 또는 나스닥 또는 LSE 또는 유로넥스트로부터의 조정된 일별 종가 데이터를 단순히 조정하는 것이지만, 실제 자산 관리에서는 훨씬 더높은 수로 고려될 수 있다.
시계열 사이에 쌍별 유사성을 계산합니다. 우리의 경우, 우리는 여전히 고전적인 컴퓨터에 있는 동적인 시간 관리인의 선형 시간 근사를 실행한다.
이러한 유사성 측정에 기초하여 :math:의 실제 자산의 실제 포트폴리오를 계산한다. 이 단계는 실제로 두 번 실행됩니다. 먼저, 고전적인 컴퓨터에서 IBM solver (IBM ILOG CPLEX 또는 Exact Eigensolver) 를 실행하여 참조 값을 얻는다. 두 번째로, 우리는 양자컴퓨터에 부분적으로 하이브리드 알고리즘을 실행합니다.
결과를 시각화합니다. 우리의 경우, 이것은 단순한 도표이다.

다음에는 전제조건 및 데이터 로드 설치를 진행하기 전에 위의 (4) 에서 사용된 모델을 먼저 설명한다.

모델¶

[Cornuejols & Tutuncu, 2006] 에서 논의된 바와 같이, 우리는 애셋들을 유사한 그룹들의 그룹들로 분류하고, 인덱스 펀드 포트폴리오에 포함될 각 그룹으로부터 하나의 대표적인 애셋을 선택하는 수학적 모델을 기술한다. 모델은 다음 데이터를 기반으로 합니다. 나중에 자세히 설명하겠습니다.

\[\rho_{ij} = \textrm{similarity}\, \textrm{between}\, \textrm{stock}\, i \, \textrm{and}\, \textrm{stock}\, j.\]

For example, \(\rho_{ii} = 1\), \(\rho_{ij} \leq 1\) for \(i \neq j\) and \(\rho_{ij}\) is larger for more similar stocks. An example of this is the correlation between the returns of stocks \(i\) and \(j\). But one could choose other similarity indices \(\rho_{ij}\).

우리가 해결에 관심이 있는 문제는 다음과 같습니다.

\[(M) \quad f = \max_{x_{ij}, y_{j}} \,\, \sum_{i=1}^n \sum_{j=1}^n \rho_{ij} x_{ij}\]

다음과 같이 클러스터링 제한조건에 적용됩니다.

\[\sum_{j=1}^n y_j = q,\]

일관성 제한 조건:

\[\sum_{j=1}^n x_{ij} = 1, \,\textrm{ for }\, i = 1,\ldots, n, \quad x_{ij} \leq y_j,\,\textrm{ for }\, i = 1,\ldots, n; \, j = 1,\ldots, n, \quad x_{jj} = y_j,\,\textrm{ for }\, j = 1,\ldots, n,\]

및 필수 제약 사항:

\[\quad x_{ij}, y_j \in\{0,1\}, \,\textrm{ for }\, i = 1,\ldots, n; \, j = 1,\ldots, n.\]

변수 \(y_j\) 는 인덱스 펀드에있는 주식 \(j\) 가 선택된 경우:math:y_j = 1 , 아닐경우 \(0\) ). 각 주식 \(i = 1, \dots,n\) 가 인덱스 펀드에서 가장 유사한 주식이면:math:x_{ij} = 1 , 아닐경우 \(0\) ).

첫 번째 제약은 펀드에서 \(q\) 주식을 선택합니다. 두 번째 제약은 각 주식 \(i\) 주식과 펀드의 대표자 간의 유사성을 극대화한다. 다른 비용 함수도 고려할 수 있다.

한 벡터에서 결정 변수를 연결하도록 합니다.

\[{\bf z} = [x_{11},x_{12},\ldots,x_{11}, x_{22},\ldots,x_{nn}, y_{1},\ldots,y_{n}],\]

그의 치수는 :math:’{bf z} in{0 ,1} ^ N’, :math:’N = n (n+1)’ 이고, 최적의 솔루션을 :math:’{bf z} *’ 로 표시하고 최적의 비용은 :math:’f’ 이다.

하이브리드 접근법¶

Here, we demonstrate an approach that combines classical and quantum computing steps, following the quantum approximate optimization approach of Farhi, Goldstone, and Gutmann (2014).

2진 다항식 최적화를 구성하기¶

\((M)\) 로부터, 동등한 동등한 동등 제약 조건 \(x_{ij} (1- y_j) = 0\) 부등식을 치환함으로써, 등식 제약만으로 2진 다항식 최적화를 구성할 수 있다.

\[(BPO) \quad f = \max_{x_{ij}, y_{j}} \,\, \sum_{i=1}^n \sum_{j=1}^n \rho_{ij} x_{ij}\]

클러스터링(clustering) 제한조건, 통합(integral) 제한조건 및 다음 수정된 일관성 제한조건에 종속됩니다.

\[\sum_{j=1}^n x_{ij} = 1, \,\textrm{ for }\, i = 1,\ldots, n,\]

\[\quad x_{ij} (1- y_j) = 0,\,\textrm{ for }\, i = 1,\ldots, n; \, j = 1,\ldots, n,\]

\[\quad x_{jj} = y_j,\,\textrm{ for }\, j = 1,\ldots, n.\]

이징 해밀턴 (Ising Hamiltonian)을 구성하다.¶

이제 다음과 같이 페널티 방법 (각각의 평등 제약에 대한 페널티 계수 :math:`A`를 도입함) 에 의해 이징 해밀토니언 (QUBO) 을 구성할 수 있다.

\[(IH) \quad H = \sum_{i=1}^n \sum_{j=1}^n \rho_{ij} x_{ij} + A\Big( \sum_{j=1}^n y_j - q\Big)^2 + \sum_{i=1}^n A\Big( \sum_{j=1}^n x_{ij} - 1\Big)^2 + \sum_{j=1}^n A (x_{jj}-y_j)^2 +\sum_{i=1}^n \sum_{j=1}^n A \left(x_{ij} (1- y_j)\right).\]

해밀토니언에서 이차의 프로그래밍 (QP) 형성¶

벡터 \({\bf z}\) 에서, 이징 해밀토니언 요소는 다음과 같이 재기록될 수 있다.

첫 번째 용어:

\[\sum_{i=1}^n \sum_{j=1}^n \rho_{ij} x_{ij} = [\rho_{11},\rho_{12},\ldots,\rho_{11}, \rho_{22},\ldots,\rho_{nn}|{\bf 0}_n ]{\bf z} =: {\bf c}_0^T {\bf z}\]

두 번째 용어:

\[\begin{split}A\Big( \sum_{j=1}^n y_j - q\Big)^2 = A \Big(\sum_{j=1}^n y_j\Big)^2 - 2 A \sum_{j=1}^n y_j + A q^2 = A {\bf z}^T \left[\begin{array}{c}{\bf 0}_{n^2} \\ \hline {\bf 1}_n \end{array}\right]\left[\begin{array}{cc}{\bf 0}_{n^2} | {\bf 1}_n \end{array}\right]{\bf z} - 2 A q [{\bf 0}_{n^2}|{\bf 1}_n]{\bf z} + A q^2 =: {\bf z}^T {\bf Q}_0 {\bf z} + {\bf c}_1^T {\bf z} + r_0\end{split}\]

세번째 용어:

\[\sum_{i=1}^n A\Big( \sum_{j=1}^n x_{ij} - 1\Big)^2 = A\sum_{i=1}^n \Big(\sum_{j=1}^n x_{ij}\Big)^2 - 2 A \sum_{i=1}^n\sum_{j=1}^n x_{ij} + n A = \qquad\qquad\qquad\qquad\qquad\qquad\qquad\]

이는 다음과 같습니다:

\[\begin{split}\qquad\qquad\qquad\qquad\qquad\qquad\qquad = A {\bf z}^T \left(\sum_{i=1}^n \left[\begin{array}{c}{\bf 0}_{n(i-1)} \\ {\bf 1}_n \\ {\bf 0}_{n(n-i)} \\ \hline {\bf 0}_{n} \end{array}\right]\left[\begin{array}{cccc}{\bf 0}_{n(i-1)} & {\bf 1}_n & {\bf 0}_{n(n-i)} & | {\bf 0}_{n} \end{array}\right]\right){\bf z} - 2 A [{\bf 1}_{n^2}|{\bf 0}_n]{\bf z} + n A =: {\bf z}^T {\bf Q}_1 {\bf z} + {\bf c}_2^T {\bf z} + r_1\end{split}\]

네번째 용어:

\[\begin{split}A \sum_{j=1}^n (x_{jj}-y_j)^2 = A {\bf z}^T \left(\sum_{j=0}^{n-1} \left[\begin{array}{c}{\bf 0}_{nj + j} \\ 1 \\ {\bf 0}_{n^2-(nj+j+1)} \\ \hline {\bf 0}_{j} \\ -1 \\ {\bf 0}_{n-j-1} \end{array}\right]\left[\begin{array}{cccccc}{\bf 0}_{nj + j} & 1 & {\bf 0}_{n^2-(nj+j+1)} & | {\bf 0}_{j} & -1 & {\bf 0}_{n-j-1} \end{array}\right]\right){\bf z} = A {\bf z}^T {\bf Q}_2 {\bf z}\end{split}\]

다섯번째 용어:

\[\begin{split}\sum_{i=1}^n \sum_{j=1}^n A \left(x_{ij} (1- y_j)\right) = A [{\bf 1}_{n^2}|{\bf 0}_n]{\bf z} + A {\bf z}^T \left( \sum_{i=1}^n \sum_{j=1}^n \left[\begin{array}{ccc|c} & & & \\ & {\bf 0}_{n^2\times n^2} & & -1/2_{(ij,j)} \\ & & & \\ \hline & -1/2_{(j, ij)} & & {\bf 0}_{n} \end{array}\right] \right) {\bf z} =: {\bf z}^T {\bf Q}_3 {\bf z} + {\bf c}_3^T {\bf z}\end{split}\]

따라서, 형태는 다음과 같이 된다:

\[(IH-QP)\quad \max_{{\bf z}\in\{0,1\}^{n(n+1)}} \, {\bf z}^T ({\bf Q}_0+{\bf Q}_1+ {\bf Q}_2 + {\bf Q}_3 ){\bf z} + ({\bf c}_0+{\bf c}_1+{\bf c}_2+{\bf c}_3)^T {\bf z} +r_0+r_1+r_2\]

이는 variational quantum eigensolver에 전달될 수 있다.

참조¶

[1] G. Cornuejols, M. L. Fisher, and G. L. Nemhauser, Location of bank accounts to optimize float: an analytical study of exact and approximate algorithms, Management Science, vol. 23(8), 1997

[2] E. Farhi, J. Goldstone, S. Gutmann e-print arXiv 1411.4028, 2014

[3] G. Cornuejols and R. Tutuncu, Optimization methods in finance, 2006

[4] DJ. Berndt and J. Clifford, Using dynamic time warping to find patterns in time series. In KDD workshop 1994 (Vol. 10, No. 16, pp. 359-370).

[5] 6_examples_max_cut_and_tsp.ipynb

구현¶

먼저 필요한 모듈을 가져온다.

[1]:

# Import requisite modules
import math
import operator
import logging
import traceback
import datetime
import sys
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

# Import Qiskit packages
import qiskit
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
# setup aqua logging
from qiskit.aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG))  # choose INFO, DEBUG to see the log

# The data providers of stock-market data
from qiskit.finance.data_providers import *
from qiskit.finance.applications.ising import portfolio_diversification

Next, we download price data for two stocks and compute their pair-wise similarity matrix (dynamic time warping distance normalized to (0,1] by taking the reciprocal). If this fails, e.g., due to you being offline or exceeding the daily limit for accesses to the stock-market data, we consider a constant matrix instead.

[2]:

# Generate a pairwise time-series similarity matrix
stocks = ["TICKER1", "TICKER2"]
n = len(stocks)
rho = np.ones((n,n))
rho[0,1] = 0.8
rho[1,0] = 0.8

data = RandomDataProvider(tickers = stocks,
                 start = datetime.datetime(2016,1,1),
                 end = datetime.datetime(2016,1,30))
data.run()
rho = data.get_similarity_matrix()

# Actually, we consider the additive inverse to invert the direction of optimisation.
rho = -1 * rho

이제 군집 수를 결정합니다. 이는 우리가 보유한 주식 수보다 적어야 한다.

[3]:

q = 1  # q less or equal than n

IBM ILOG CPLEX를 사용한 고전적 솔루션¶

For a classical solution, we use IBM CPLEX. CPLEX is able to find the exact solution of this problem. We first define a ClassicalOptimizer class that encodes the problem in a way that CPLEX can solve, and then instantiate the class and solve it.

[4]:

class ClassicalOptimizer:
    def __init__(self, rho, n, q):

        self.rho = rho
        self.n = n  # number of inner variables
        self.q = q  # number of required selection

    def compute_allowed_combinations(self):
        f = math.factorial
        return int(f(self.n) / f(self.q) / f(self.n - self.q))

    def cplex_solution(self):

        # refactoring
        rho = self.rho
        n = self.n
        q = self.q

        my_obj = list(rho.reshape(1, n ** 2)[0]) + [0. for x in range(0, n)]
        my_ub = [1 for x in range(0, n ** 2 + n)]
        my_lb = [0 for x in range(0, n ** 2 + n)]
        my_ctype = "".join(['I' for x in range(0, n ** 2 + n)])

        my_rhs = [q] + [1 for x in range (0, n)] +[0 for x in range (0, n)] + [0.1 for x in range(0, n ** 2)]
        my_sense = "".join(['E' for x in range(0, 1+n)]) + "".join(['E' for x in range(0, n)]) + "".join(
            ['L' for x in range(0, n ** 2)])

        try:
            my_prob = cplex.Cplex()
            self.populatebyrow(my_prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs)

            my_prob.solve()

        except CplexError as exc:
            print(exc)
            return

        x = my_prob.solution.get_values()
        x = np.array(x)
        cost = my_prob.solution.get_objective_value()

        return x, cost

    def populatebyrow(self, prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs):

        n = self.n

        prob.objective.set_sense(prob.objective.sense.minimize)
        prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub, types=my_ctype)

        prob.set_log_stream(None)
        prob.set_error_stream(None)
        prob.set_warning_stream(None)
        prob.set_results_stream(None)

        rows = []
        col = [x for x in range(n**2, n**2+n)]
        coef = [1 for x in range(0, n)]
        rows.append([col, coef])

        for ii in range(0, n):
            col = [x for x in range(0+n*ii, n+n*ii)]
            coef = [1 for x in range(0, n)]

            rows.append([col, coef])

        for ii in range(0, n):
            col = [ii * n + ii, n ** 2 + ii]
            coef = [1, -1]
            rows.append([col, coef])

        for ii in range(0, n):
            for jj in range(0, n):
                col = [ii*n + jj, n ** 2 + jj]
                coef = [1, -1]

                rows.append([col, coef])

        prob.linear_constraints.add(lin_expr=rows, senses=my_sense, rhs=my_rhs)

[5]:

# Instantiate the classical optimizer class
classical_optimizer = ClassicalOptimizer(rho, n, q)

# Compute the number of feasible solutions:
print('Number of feasible combinations= ' + str(classical_optimizer.compute_allowed_combinations()))

# Compute the total number of possible combinations (feasible + unfeasible)
print('Total number of combinations= ' + str(2 ** (n*(n+1))))

Number of feasible combinations= 2
Total number of combinations= 64

[6]:

# Visualize the solution
def visualize_solution(xc, yc, x, C, n, K, title_str):
    plt.figure()
    plt.scatter(xc, yc, s=200)
    for i in range(len(xc)):
        plt.annotate(i, (xc[i] + 0.015, yc[i]), size=16, color='r')

    plt.grid()

    for ii in range(n ** 2, n **2 + n):

        if x[ii] > 0:
            plt.plot(xc[ii-n**2], yc[ii-n**2], 'r*', ms=20)

    for ii in range(0, n ** 2):

        if x[ii] > 0:
            iy = ii // n
            ix = ii % n
            plt.plot([xc[ix], xc[iy]], [yc[ix], yc[iy]], 'C2')

    plt.title(title_str +' cost = ' + str(int(C * 100) / 100.))
    plt.show()

Solution shows the selected stocks via the stars and in green the links (via similarities) with other stocks that are represented in the fund by the linked stock.

IBM Q를 이용한 양자 컴퓨팅¶

For the quantum solution, we use Qiskit. We first define a class QuantumOptimizer that encodes the quantum approach to solve the problem and then we instantiate it and solve it. We define the following methods inside the class:

exact_solution: Ising Hamiltonian이 \(Z\) 기반으로 올바르게 인코딩되었는지 확인하기 위해 고유 분해를 고전적으로 계산할 수 있다. 즉, 차원의 대칭 행렬을 고려한다. \(2^N \times 2^N\). 당면한 문제의 경우:math:n=3, 즉 :math:`N = 12`는 많은 랩톱의 한계이다.
vqe_solution : solves the problem \((M)\) via the variational quantum eigensolver (VQE);
qaoa_solution : solves the problem \((M)\) via a Quantum Approximate Optimization Algorithm (QAOA).

[7]:

from qiskit.aqua.operators import StateFn

class QuantumOptimizer:

    def __init__(self, rho, n, q):

        self.rho = rho
        self.n = n
        self.q = q

    # Obtains the least eigenvalue of the Hamiltonian classically
    def exact_solution(self):
        qubitOp = portfolio_diversification.get_operator(self.rho, self.n, self.q)
        result = NumPyMinimumEigensolver(qubitOp).run()
        return self.decode_result(result)

    def vqe_solution(self):
        qubitOp = portfolio_diversification.get_operator(self.rho, self.n, self.q)
        backend = Aer.get_backend('statevector_simulator')
        seed = 50
        cobyla = COBYLA()
        cobyla.set_options(maxiter=250)
        ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=5, 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)
        return self.decode_result(result)

    def qaoa_solution(self):
        qubitOp = portfolio_diversification.get_operator(self.rho, self.n, self.q)
        backend = Aer.get_backend('statevector_simulator')
        seed = 50
        cobyla = COBYLA()
        cobyla.set_options(maxiter=250)
        qaoa = QAOA(qubitOp, cobyla, 3, 'matrix')
        qaoa.random_seed = seed
        quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
        result = qaoa.run(quantum_instance)
        return self.decode_result(result)

    def get_portfoliodiversification_solution(self, n, result):
        v = result.eigenstate
        if isinstance(v, StateFn):
            v = v.to_matrix()

        N = n ** 2 + n

        index_value = [x for x in range(len(v)) if v[x] == max(v)][0]
        string_value = "{0:b}".format(index_value)

        while len(string_value) < N:
            string_value = '0' + string_value

        x_state = list()
        for elements in string_value:
            if elements == '0':
                x_state.append(0)
            else:
                x_state.append(1)

        x_state = np.flip(x_state, axis=0)

        return x_state

    def decode_result(self, result, offset = 0):
        quantum_solution = self.get_portfoliodiversification_solution(self.n, result)
        ground_level = portfolio_diversification.get_portfoliodiversification_value(self.rho, self.n, self.q, quantum_solution)
        return quantum_solution, ground_level

단계 1¶

Instantiate the quantum optimizer class with parameters: - the similarity matrix rho; - the number of assets and clusters n and q;

[8]:

# Instantiate the quantum optimizer class with parameters:
quantum_optimizer = QuantumOptimizer(rho, n, q)

단계 2¶

문제를 이원 제형 (IH-QP) 으로 코딩한다.

정상 검사: 양자 최적화 프로그램의 2진 공식화가 정확한지 확인한다 (즉, 동일한 솔루션에서 동일한 비용을 산출함).

[9]:

# Check if the binary representation is correct. This requires CPLEX
try:
    import cplex
    #warnings.filterwarnings('ignore')
    quantum_solution, quantum_cost = quantum_optimizer.exact_solution()
    classical_solution, classical_cost = classical_optimizer.cplex_solution()
    print(quantum_cost, classical_cost)
    if np.abs(quantum_cost - classical_cost) < 0.01:
        print('Binary formulation is correct')
    else: print('Error in the formulation of the Hamiltonian')
except Exception as ex:
    print(ex)

-1.0008499151717842 -1.0008499151721015
Binary formulation is correct

단계 3¶

Encode the problem as an Ising Hamiltonian in the Z basis.

Sanity check: make sure that the formulation is correct (i.e., yields the same cost given the same solution)

[10]:

ground_state, ground_level = quantum_optimizer.exact_solution()
print(ground_state)

try:
    if np.abs(ground_level - classical_cost)<0.01:
        print('Ising Hamiltonian in Z basis is correct')
    else: print('Error in the Ising Hamiltonian formulation')
except Exception as ex:
    print(ex)

[0 1 0 1 0 1]
Ising Hamiltonian in Z basis is correct

단계 4¶

Solve the problem via VQE. Notice that depending on the number of qubits, this can take a while: for 6 qubits it takes 15 minutes on a 2015 Macbook Pro, for 12 qubits it takes more than 12 hours. For longer runs, logging may be useful to observe the workings; otherwise, you just have to wait until the solution is printed.

[11]:

vqe_state, vqe_level = quantum_optimizer.vqe_solution()
print(vqe_state)

try:
    if np.linalg.norm(ground_state - vqe_state)<0.01:
        print('VQE produces the same solution as the exact eigensolver.')
    else: print('VQE does not produce the same solution as the exact eigensolver, but that is to be expected.')
except Exception as ex:
    print(ex)

[0 1 0 1 0 1]
VQE produces the same solution as the exact eigensolver.

단계 5¶

솔루션 시각화

[12]:

xc, yc = data.get_coordinates()

[13]:

visualize_solution(xc, yc, ground_state, ground_level, n, q, 'Classical')

../../_images/tutorials_finance_02_portfolio_diversification_24_0.png

[14]:

visualize_solution(xc, yc, vqe_state, vqe_level, n, q, 'VQE')

../../_images/tutorials_finance_02_portfolio_diversification_25_0.png

솔루션은 링크된 주식에 의해 펀드에 표시되는 다른 주식과 함께 별표를 통해 선택된 주식을 표시하고 링크 (유사성을 통해) 를 녹색으로 표시합니다. VQE는 Ising Hamiltonian (Ising Hamiltonian) 의 QP 제제에 대한 휴리스틱스 (heuristic) 이다는 점에 유의하라. A의 적합한 선택을 위해, QP 제형의 국소 최적화는 ILP에 대한 가능한 용액일 것이다. 일부 작은 경우들에 대하여, 상술한 바와 같이, ILP의 최적화와 일치하는 QP 제제의 최적의 용액을 찾을 수 있고, ILP의 최적의 용액을 찾는 것은 일반적으로 QP 제제의 국소 최적화를 발견하는 것보다 어렵다. VQE내에서도, 특정 다양한 형태 (시험 파형 기능) 에 대해 보다 강력한 보증을 제공할 수 있다.

[15]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.19.1
Terra	0.14.1
Aer	0.5.1
Ignis	0.3.0
Aqua	0.7.0
IBM Q Provider	0.7.0
System information
Python	3.7.4 (default, Aug 13 2019, 15:17:50) [Clang 4.0.1 (tags/RELEASE_401/final)]
OS	Darwin
CPUs	6
Memory (Gb)	16.0
Fri Jul 17 17:38:32 2020 CEST

This code is a part of Qiskit

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.

[ ]: