content/challenge-1/challenge-1-ko.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## IBM Quantum Challenge Fall 2021\n",
    "# Challenge 1: 양자컴퓨터로 포트폴리오 최적화 하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    \n",
    "최고의 경험을 위해 오른쪽 상단의 계정 메뉴에서 **light** 워크스페이스 테마로 전환하는 것을 추천합니다.",
	"</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 소개: 포트폴리오 최적화란?\n",
    "포트폴리오 최적화는 투자 수익을 극대화하고자 하는 모두에게 피할 수 없는 과정입니다.\n",
    "투자는 일반적으로 자산(주식, 신용, 채권, 파생상품, 콜, 풋 등)의 집합이며, 이러한 자산의 모음을 **포트폴리오** 라고 합니다.  \n",
    "<center><img src=\"resources/ex1-01.png\" width=\"270\"></center>\n",
    "포트폴리오 최적화의 목표는 위험(재무적 손실)을 최소화하고 수익(재무적 이익)을 극대화하는 것입니다. 하지만 이 과정은 생각만큼 간단하지 않습니다. 위험 부담이 적으면서 높은 수익을 얻는 것은 몹시 이상적인 상황이기 때문입니다. 위험과 수익은 일반적으로 포트폴리오 최적화를 조금 더 복잡하게 만드는 상충 관계를 가지고 있습니다.  해리 마코위츠(Harry Markowitz) 박사는 1952년에 만든 현대 포트폴리오 이론(Modern Portfolio Theory)에서 \"위험은 더 높은 보상에 내재되어 있다.\"라고 언급했습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**현대 포트폴리오 이론 (MPT)** <br> \n",
    "투자자은 위험 회피적일 것일 것이라는, 즉, 동일한 기대 수익을 제공하는 두 개의 포트폴리오가 주어졌을 때 덜 위험한 것을 선호할 것이라는 아이디어에 기반한 투자이론입니다. 투자자는 더 높은 보상에 내재된 위험을 주시하면서 시장의 리스크 수준을 기반으로 기대 수익을 극대화할 수 있는 포트폴리오를 구성할 수 있습니다. 이 이론은 금융과 투자를 다루는 가장 중요하고 영향력 있는 경제 이론 중 하나로 해리 마코위츠 박사는 1952년에 현대 포트폴리오 이론(MPT)을 만들었고 1990년에 노벨 경제학상을 수상했습니다.<br><br>\n",
    "\n",
    "**참고 자료:** [<b>Modern Portfolio Theory<i>](https://en.wikipedia.org/wiki/Modern_portfolio_theory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전 과제\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "<b>목표</b> \n",
    "포트폴리오 최적화는 투자 수익을 극대화하기 위해 반드시 필요한 과정입니다. 이 첫번째 도전에서, 여러분은 포트폴리오 최적화와 관련된 기반 이론에 대해 배우게 될 것이며 어떻게 이 문제를 양자컴퓨터가 풀도록 수식화 할 수 있는 지를 배우게 될것입니다. 문제 풀이의 과정에서 여러분은 문제를 효율적으로 풀기위해 Qiskit의 금융 어플리케이션 클래스들과 메소드들을 사용하는 방법을 배우게 될 것입니다.\n",
    "\n",
    "1. **도전 1a**: Qiskit 금융 모듈의 PortfolioOptimization() 메서드를 사용하여 포트폴리오 최적화를 2차 프로그램(Quadratic Program)으로 변환하는 방법을 배워봅시다. \n",
    "    \n",
    "2. **도전 1b**: VQE를 작성하여 도전 1a에서 생성된 인스턴스를 기반으로 4종목 포트폴리오 최적화 문제를 해결합니다.\n",
    "    \n",
    "    \n",
    "3. **도전 1c**: 세 가지 예산과 포트폴리오의 모든 자산에 대한 두 배의 가중치로 QAOA를 사용하여 동일한 문제를 해결합니다.\n",
    "\n",
    "</div>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "시작하기에 앞서, [<b>Julien Gacon의 Qiskit 금융 데모 세션<i>](https://youtu.be/UtMVoGXlz04)을 시청하고 이 강의의  [<b>데모 노트북<i>](https://github.com/qiskit-community/qiskit-application-modules-demo-sessions/blob/main/qiskit-finance/Introduction%20to%20Qiskit%20Finance.ipynb)을 살펴봄으로서 Qiskit 금융 모듈과 포트폴리오 최적화에 응용되는 방법을 배워보시기 바랍니다.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 1. 효율적 경계선(The efficient frontier) 찾기\n",
    "\n",
    "현대 포트폴리오 이론(MPT)은 투자자가 이상적인 포트폴리오를 결정하기 위한 일반적인 프레임워크 역할을 합니다. MPT는 모든 투자자가 포트폴리오에서 다음의 조건들로 최적의 포트폴리오를 선택할 것이라고 가정하기 때문에 평균 분산 포트폴리오 이론이라고도 불리며 선택의 조건들은:\n",
    "- 주어진 시장의 위험 수준 안에서 기대 수익을 최대화 한다, 그리고\n",
    "- 주어진 기대 수익의 수준 안에서 위험을 최소화 한다.\n",
    "\n",
    "\n",
    "입니다. 아래의 그림은 현대 포트폴리오 이론의 최소 분산 경계선을 보여주며 가로축은 위험을, 세로축은 기대 수익을 나타냅니다.\n",
    "\n",
    "<center><img src=\"resources/ex1-02.png\" width=\"600\"></center>\n",
    "\n",
    "A와 B의 두 가지 주식 중에서 선택하는 경우를 생각해 봅시다. 여러분은 이 두 주식 중 하나에 전 재산을 투자할 수 있습니다. 또는 A에 10%, B에 90%, A에 20%, B에 80%, A에 70%, B에 30%를 투자할 수도 있습니다. 두 가지 주식만을 대상으로 하는 간단한 상황이지만 가능한 조합의 숫자는 상당히 많습니다. 그렇다면 수천 개의 주식들이 있을 때 생각해 보아야하는 엄청난 양의 주식들의 조합을 상상해 보십시오.\n",
    "\n",
    "최소 분산 경계선은 주어진 기대 수익 수준에서 달성할 수 있는 최소 분산을 나타냅니다. 포트폴리오의 최소 분산 경계선을 얻으려면:\n",
    "\n",
    "- 1단계: 과거의 데이터를 사용하여 포트폴리오에 포함된 개별 주식의 평균, 분산 및 각 주식의 상관관계를 추정합니다.\n",
    "- 2단계: 컴퓨터 프로그램을 사용하여 미리 지정된 각 기대 수익에 대한 포트폴리오 변동을 최소화하는 모든 주식의 가중치를 파악합니다.\n",
    "- 3단계: 2단계에서 결정된 모든 최소 분산 포트폴리오에 대한 기대 수익과 분산을 계산한 다음 두 변수를 그래프로 표시합니다.\n",
    "\n",
    "투자자들은 최소 분산점 이하로는 절대로 포트폴리오를 보유하지 않을 것입니다. 투자자들은 최소 분산 경계선의 양(Positive)의 경사 부분을 따라가며 항상 더 높은 수익을 얻고자 합니다. 이때, 최소 분산 경계선의 양(Positive)의 경사 부분을 **효율적 경계선**이라고 합니다.\n",
    "\n",
    "**효율적 경계선**에 최적의 포트폴리오가 존재합니다. 그리고 이 효율적 경계선을 사용해서 투자자는 다양한 포트폴리오의 선택지를 좁힐 수 있습니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 2. 연습의 목표\n",
    "이 연습의 목표는 양자적 접근법을 사용하여 내재한 위험에 대한 효율적 경계선을 찾는 것입니다. Qiskit의 금융 애플리케이션 모듈을 사용하여 포트폴리오 최적화 문제를 2차 프로그램(Quadratic Program)으로 변환한 다음 VQE 및 QAOA와 같은 변분 양자 알고리즘을 사용하여 최적화 문제를 해결해 봅시다. 먼저 주어진 챌린지 문제를 살펴보는 것으로 도전을 시작해 봅시다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## 3. 4종목 포트폴리오 최적화 문제\n",
    "\n",
    "총 4개의 자산(예: STOCK0, STOCK1, STOCK2, STOCK3) 중에서 선택할 수 있는 포트폴리오 최적화 문제를 생각해 봅시다. 여러분의 목표는 위험과 수익 사이의 트레이드-오프를 최소화하는 두 자산의 조합을 찾는 것인데, 이는 주어진 위험에 대한 효율적 경계선을 찾는 것과 같습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 4. 수식화\n",
    "\n",
    "이 문제를 어떻게 수식화할 수 있을까요?<br>\n",
    "효율적 경계선을 표현하는 함수는 다음와 같이 선형 제약 조건이 있는 2차 프로그램으로 수식화할 수 있습니다.<br>\n",
    "빨간색으로 표시된 항은 위험과 관련이 있으며 파란색 항은 기대 수익과 관련이 있습니다. \n",
    "우리의 목표는 위험과 수익 사이의 트레이드-오프를 최소화하는 것이며, 최적화 문제에서 최소화 대상인 함수는 일반적으로 목적 함수라고 부릅니다.\n",
    "<br> <br>\n",
    "\n",
    "<div align=\"center\"> <font size=5em >$\\min_{x \\in \\{0, 1\\}^n}: $</font> <font color='red', size=5em >$q x^n\\Sigma x$</font> - <font color='blue', size=5em>$\\mu^n x$</font> </div>\n",
    "\n",
    "<div align=\"center\"> <font size=5em >$subject$</font> <font size=5em >$to: 1^n x = B$</font> </div>\n",
    "\n",
    "\n",
    "- <font size=4em >$x$</font>는 자산 분배를 나타냅니다.\n",
    "- <font size=4em >$Σ$</font>(시그마)는 공분산 행렬을 나타냅니다. \n",
    "공분산 행렬은 금융 공학에 널리 사용되는 유용한 수학 개념입니다. 이것은 두 자산의 가격이 서로에 대해 어떻게 변동하는지 보여주는 통계적인 척도입니다. 두 종목의 공분산이 높다는 것은 한 종목의 가격에 변동이 생길때 다른 종목의 가격이 크게 변하고 변동성이 크다는 것을 의미합니다.\n",
    "\n",
    "- <font size=4em >$q$</font>는 위험인자(risk tolerance)라고 하며, 위험을 감수하려는 개인의 의지나 능력에 대한 평가입니다. \n",
    "예를 들어, 자동화된 재무 자문 서비스인 로보 어드바이징(robo-advising)을 사용할 때 다양한 위험 허용 수준을 볼 수 있습니다. q 값은 이 값과 동일하며 0과 1 사이의 값을 갖습니다.\n",
    "- <font size=4em >$𝝁$</font>(뮤)는 기대수익률로서, 극대화 하고자 하는 값입니다.\n",
    "- <font size=4em >$n$</font>은 선택할 수 있는 다양한 자산의 수입니다.\n",
    "- <font size=4em >$B$</font>는 예산을 뜻합니다. \n",
    "문제의 맥락에서 예산은 포트폴리오 안에 넣을 수 있는 자산의 숫자를 의미합니다.\n",
    "\n",
    "#### 목표:\n",
    "우리의 목표는 **x** 값을 찾는 것입니다. 여기서 x 값은 선택할 자산(𝑥[𝑖]=1)과 선택하지 않을 자산(𝑥[𝑖]=0)을 표현합니다.\n",
    "\n",
    "\n",
    "#### 가정:\n",
    "다음과 같은 단순화를 가정합니다:\n",
    "- 모든 자산은 1로 정규화 된, 동일한 가격을 갖습니다.\n",
    "- 전체 예산 $B$는 모두 사용되어야 합니다. 즉 정확히 $B$ 어치의 자산을 선택해야 합니다.\n",
    "- 매개 변수에 의해 조정되는 등식 제약 조건(The equality constraint) $1^n x = B$ 은 패널티 항 $(1^n x - B)^2$에 매핑되며 목적함수에서 차감합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Step 1. 필수 라이브러리 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:35:05.710593Z",
     "start_time": "2020-07-13T20:34:57.647535Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#Let us begin by importing necessary libraries.\n",
    "from qiskit import Aer\n",
    "from qiskit.algorithms import VQE, QAOA, NumPyMinimumEigensolver\n",
    "from qiskit.algorithms.optimizers import *\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "from qiskit.utils import QuantumInstance\n",
    "from qiskit.utils import algorithm_globals\n",
    "from qiskit_finance import QiskitFinanceError\n",
    "from qiskit_finance.applications.optimization import PortfolioOptimization\n",
    "from qiskit_finance.data_providers import *\n",
    "from qiskit_optimization.algorithms import MinimumEigenOptimizer \n",
    "from qiskit_optimization.applications import OptimizationApplication\n",
    "from qiskit_optimization.converters import QuadraticProgramToQubo\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import datetime\n",
    "import warnings\n",
    "from sympy.utilities.exceptions import SymPyDeprecationWarning\n",
    "warnings.simplefilter(\"ignore\", SymPyDeprecationWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Step 2. 시계열 데이터 생성 (금융 데이터)\n",
    "\n",
    "우선 총 자산 수 n=4에 대한 무작위 시계열 금융 데이터를 RandomDataProvider를 사용하여 생성해 봅시다. 시간을 거슬러 올라가 1955년 11월 5일부터 1985년 10월 26일까지의 재무 데이터를 가져옵시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:35:15.224327Z",
     "start_time": "2020-07-13T20:35:15.213892Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Set parameters for assets and risk factor\n",
    "num_assets = 4     # set number of assets to 4\n",
    "q = 0.5                   # set risk factor to 0.5\n",
    "budget = 2           # set budget as defined in the problem\n",
    "seed = 132     #set random seed\n",
    "\n",
    "# Generate time series data\n",
    "stocks = [(\"STOCK%s\" % i) for i in range(num_assets)]\n",
    "data = RandomDataProvider(tickers=stocks,\n",
    "                 start=datetime.datetime(1955,11,5),   \n",
    "                 end=datetime.datetime(1985,10,26),  \n",
    "                 seed=seed)\n",
    "data.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's plot our finanical data\n",
    "for (cnt, s) in enumerate(data._tickers):\n",
    "    plt.plot(data._data[cnt], label=s)\n",
    "plt.legend()\n",
    "plt.xticks(rotation=90)\n",
    "plt.xlabel('days')\n",
    "plt.ylabel('stock value')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-danger\">\n",
    "<b>주의</b> 이 도전 문제에서 RandomDataProvider에 주어진 시작/종료 날짜를 변경하지 마십시오. 만약 주어진 기간을 변경한다면 채점이 되지 않습니다.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Step 3. 2차 프로그램(Quadratic Program) 수식화\n",
    "\n",
    "가장 먼저 기대 수익을 생성하고 이어서 포트폴리오를 구성하는 데 필요한 공분산 행렬을 생성해 보겠습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### 기대 수익 μ\n",
    "\n",
    "포트폴리오의 기대 수익은 포트폴리오가 창출해 낼 것으로 기대되는 예상 수익으로, 포트폴리오의 가능한 수익 분배의 평균(평균)이 됩니다.\n",
    "예를 들어, 증권 A, B, C가 포트폴리오에서 각각 50%, 20%, 30%의 가중치를 지녔다고 가정할 경우, 각 주식의 기대수익률이 각각 15%, 6%, 9%라면 포트폴리오의 기대수익률은 다음과 같습니다.\n",
    "\n",
    "\n",
    "<div align=\"center\"> μ = (50% x 15%) + (20% x 6%) + (30% x 9%) = 11.4% </div>\n",
    "\n",
    "앞서 생성산 문제의 데이터에 대하여, Qiskit의 RandomDataProvider가 제공하는 `get_period_return_mean_vector()` 함수를 사용하여 30년 동안의 기대 수익을 쉽게 계산할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#Let's calculate the expected return for our problem data\n",
    "\n",
    "mu = data.get_period_return_mean_vector()   # Returns a vector containing the mean value of each asset's expected return.\n",
    "\n",
    "print(mu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 공분산 행렬 Σ\n",
    "\n",
    "공분산 Σ는 두 자산의 평균 수익률이 서로에 대하여 어떻게 달라지는지에 대한 통계적 척도로 투자 포트폴리오의 관점에서 위험의 양을 파악하여 주식 매수 또는 매도 결정을 내릴 수 있도록 도와주는 지표입니다.\n",
    "\n",
    "다변량 행렬에 'n'개의 주식이 있는 경우 공분산 행렬의 크기는 n x n이 됩니다. 4x4 매트릭스가 될 우리의 4가지 주식 포트폴리오에 대한 공분산 행렬을 그려보겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's plot our covariance matrix Σ（sigma）\n",
    "sigma = data.get_period_return_covariance_matrix() #Returns the covariance matrix of the four assets\n",
    "print(sigma)\n",
    "fig, ax = plt.subplots(1,1)\n",
    "im = plt.imshow(sigma, extent=[-1,1,-1,1])\n",
    "x_label_list = ['stock3', 'stock2', 'stock1', 'stock0']\n",
    "y_label_list = ['stock3', 'stock2', 'stock1', 'stock0']\n",
    "ax.set_xticks([-0.75,-0.25,0.25,0.75])\n",
    "ax.set_yticks([0.75,0.25,-0.25,-0.75])\n",
    "ax.set_xticklabels(x_label_list)\n",
    "ax.set_yticklabels(y_label_list)\n",
    "plt.colorbar()\n",
    "plt.clim(-0.000002, 0.00001)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "왼쪽에서 오른쪽으로 대각선 값(아래 그림의 노란색 상자)은 각각의 주식의 자기 자신과의 관계를 보여줍니다. 대각선이 아닌 행렬의 값은 주식과 주식이 서로에 대해 반환될 것으로 예상되는 평균 수익의 편차를 나타냅니다. 공분산 행렬을 보는 간단한 방법은 다음과 같습니다. \n",
    " - 두 주식이 동시에 증가하고 감소하면 공분산 값은 양수가 됩니다.\n",
    " - 만약 한쪽이 증가할때 다른 한쪽이 감소하면 공분산은 음수가 됩니다.\n",
    "\n",
    "<center><img src= \"resources/ex1-05.png\" width=\"370\"></center>\n",
    "\n",
    "여러분은 아마 \"계란을 한 바구니에 담지 말라\"라는 말을 들어봤을 것입니다. 항상 같은 방향으로 움직이는 자산들에 투자하면 동시에 모든 돈을 잃을 위험이 있습니다. 공분산 행렬은 투자자들이 이와 같은 위험을 줄이기 위해 자산을 다각화할 수 있도록 돕는 좋은 도구입니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "최적화된 포트폴리오를 구성하는 데 필요한 모든 값들이 준비되었으므로 문제의 2차 프로그램을 구성하는데 필요한 Qiskit의 금융 응용 프로그램 클래스들을 살펴보도록 하겠습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Qiskit 금융 어플리케이션 클래스\n",
    "\n",
    "Qiskit의 [`PortfolioOptimization`](https://qiskit.org/documentation/finance/stubs/qiskit_finance.applications.PortfolioOptimization.html#qiskit_finance.applications.PortfolioOptimization) 클래스를 사용해서 포트폴리오 최적화 문제를 풀기 위한 2차 프로그램을 작성해 봅시다.\n",
    "\n",
    "PortfolioOptimization 클래스는 다음 **5개의 인수**를 사용하여 porfolio 인스턴스를 생성한 다음 인스턴스를 2차 프로그램으로 변환합니다.\n",
    "\n",
    "PortfolioOptimization 클래스의 인수들:\n",
    "- expected_returns (기대 수익)\n",
    "- covariances (공분산)\n",
    "- risk_factor (위험 요소)\n",
    "- budget (예산) \n",
    "- bounds (제약 조건)\n",
    "\n",
    "포트폴리오 인스턴스가 2차 프로그램으로 변환되면 VQE(Variational Quantum Eigensolver) 또는 QAOA(Quantum Approximate Optimization Algorithm)와 같은 양자 변분 알고리즘을 사용하여 최적의 솔루션을 찾을 수 있습니다.<br>\n",
    "\n",
    "우리는 이미 3단계에서 기대 수익과 공분산을 얻었으며 미리 정의된 위험 요소와 예산 값을 가지고 있습니다.\n",
    "이제 [`PortfolioOptimization`](https://qiskit.org/documentation/finance/stubs/qiskit_finance.applications.PortfolioOptimization.html#qiskit_finance.applications.PortfolioOptimization) 클래스를 사용해 최적의 포트폴리오를 구성해 봅시다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 도전 1a: PortfolioOptimization 클래스를 사용해 포트폴리오 인스턴스 생성\n",
    "<div id='u-definition'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**도전 1a** <br>\n",
    "[<b>PortfolioOptimization<i>](https://qiskit.org/documentation/finance/stubs/qiskit_finance.applications.PortfolioOptimization.html#qiskit_finance.applications.PortfolioOptimization)를 사용해 포트폴리오 인스턴스를 생성하는 코드를 완성합시다. 반드시 위에서 얻은 **5개의 인수들**과 그 값을 사용해야 하며, 생성한 포트폴리오 인스턴스를 2차 프로그램 **qp**로 변환합니다. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>노트:</b> 바이너리 목록 [1.0.0.1]은 포트폴리오가 STOCK0과 STOCK3으로 구성됨을 의미합니다. 모든 변수가 바이너리 변수인 경우 'bounds = None'으로 설정할 수 있습니다.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:35:15.231767Z",
     "start_time": "2020-07-13T20:35:15.226490Z"
    },
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "##############################\n",
    "# Provide your code here\n",
    "\n",
    "portfolio =\n",
    "qp = \n",
    "\n",
    "##############################b\n",
    "print(qp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 코드를 성공적으로 작성했다면, 우리 문제의 2차 프로그램의 표준 표현을 볼 수 있을 것입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Check your answer using the following code\n",
    "from qc_grader import grade_ex1a\n",
    "grade_ex1a(qp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 최소 고유 최적화 도구(Minimum Eigen Optimizer)\n",
    "\n",
    "흥미롭게도 우리의 포트폴리오 최적화 문제는 해밀토니안의 바닥 상태를 찾는 것으로 풀 수 있습니다. 해밀토니안은 분자나 자석과 같이 시뮬레이션하려는 물리적 시스템의 총 에너지를 나타내는 에너지 함수로 생각할 수 있습니다. 물리적 시스템은 [<b>Ising 모델<i>](https://en.wikipedia.org/wiki/Ising_model)이라는 수학적 모델로 표현할 수 있으며 문제의 바이너리 변수들은 스핀업(+1) 또는 스핀다운(-1) 상태로 변환될 수 있습니다.\n",
    "    \n",
    "최적화 알고리즘을 적용할 때 보통 문제가 만족해야 하는 조건을 함께 알고리즘에 전달해야 합니다. 예를 들어 VQE 및 QAOA와 같은 변분 알고리즘은 [<b>QUBO(비제약 이진 이차 계획법-Quadratic unconstrained binary optimization)<i>](https://en.wikipedia.org/wiki/Quadratic_unconstrained_binary_optimization) 문제에만 적용할 수 있으므로 Qiskit은 가능한 한 최적화 문제를 이러한 다른 형식으로 자동 매핑할 수 있는 컨버터를 제공합니다.\n",
    "\n",
    "\n",
    "<center><img src= \"resources/ex1-04.png\" width=\"700\"></center>\n",
    "\n",
    "QUBO를 푸는 것은 해밀토니안의 바닥 상태를 찾는 것과 같습니다. 그리고 최소 고유 최적화 도구는 2차 프로그램을 해밀토니안으로 변환한 후 VQE 또는 QAOA와 같은 주어진 최소 고유치 계산기(Minimum Eigen Solver)를 호출하여 바닥 상태를 계산하고 최적화 결과를 반환합니다.    \n",
    "\n",
    "이 접근 방식을 통해 바닥 상태를 계산하는 방법론을 도전 과제의 다음 단계에서 시연할 최적화 문제를 해결하는 맥락으로 사용하는 과정을 익히게 됩니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5. 고전적 최적화 도구를 사용하여 기준값 준비\n",
    "먼저 고전적인 방법으로 문제를 풀어봅시다.\n",
    "\n",
    "이제 만들어진 과정은 고려할 것 없이 위에서 만든 연산자(Operator)를 사용합니다. NumPy MinimumEigensolver을 사용해 고전적인 방식으로 기준값을 얻습니다. 문제는 'ising' 타입으로 설정되었습니다. 양자 계산이 아닌 고전적인 계산을 수행할 것이기 때문에 백엔드는 필요하지 않습니다. 계산 결과는 사전(dictionary) 형식으로 얻습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:35:15.264319Z",
     "start_time": "2020-07-13T20:35:15.245811Z"
    }
   },
   "outputs": [],
   "source": [
    "exact_mes = NumPyMinimumEigensolver()\n",
    "exact_eigensolver = MinimumEigenOptimizer(exact_mes)\n",
    "result = exact_eigensolver.solve(qp)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "계산된 최적값은 자산의 배분을 나타냅니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전: VQE를 사용한 문제 해결\n",
    "\n",
    "**VQE(Variational Quantum Eigensolver)**는 [<b>Hamiltonian<i>](https://en.wikipedia.org/wiki/Hamiltonian_(quantum_mechanics))의 바닥 상태 에너지(최저 에너지)를 효율적으로 계산하기 위해 처리 작업량의 일부를 고전 컴퓨터에 할당하여 처리하는 고전-양자 하이브리드 알고리즘입니다. 앞서 논의한 바와 같이, 2차 프로그램은 [<b>VQE<i>](https://qiskit.org/documentation/stubs/qiskit.algorithms.VQE.html)에 의해 계산될 수 있는 바닥 상태 에너지 탐색 문제로 재 공식화 될 수 있으며 이때 계산되는 바닥 상태는 우리가 찾고 있는 최적의 솔루션에 해당합니다. 이 도전 과제에서는 VQE를 사용하여 최적의 솔루션을 찾아야 합니다. <br>\n",
    "\n",
    "<div id='u-definition'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**도전 1b** <br>\n",
    "VQE(Variational Quantum Eigensolver)를 사용하여 문제를 해결하여 앞에서 계산한 것과 같은 답을 얻으십시오. 사용할 옵티마이저와 변분 형태를 설정해 봅시다.\n",
    "</div>\n",
    "    \n",
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "\n",
    "힌트: 잘 모르다면, 다음 Qiskit 튜토리얼을 문제에 맞게 수정해 보십시오: https://qiskit.org/documentation/finance/tutorials/01_portfolio_optimization.html\n",
    "\n",
    "</div>\n",
    "\n",
    "다음의 코드에서 시작해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-13T20:35:28.570970Z",
     "start_time": "2020-07-13T20:35:26.539093Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "optimizer = SLSQP(maxiter=1000)  \n",
    "algorithm_globals.random_seed = 1234\n",
    "backend = Aer.get_backend('statevector_simulator')\n",
    "\n",
    "\n",
    "##############################\n",
    "# Provide your code here\n",
    "\n",
    "\n",
    "vqe = \n",
    "\n",
    "\n",
    "##############################\n",
    "\n",
    "vqe_meo = MinimumEigenOptimizer(vqe)  #please do not change this code\n",
    "\n",
    "result = vqe_meo.solve(qp)  #please do not change this code\n",
    "\n",
    "print(result)    #please do not change this code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check your answer and submit using the following code\n",
    "from qc_grader import grade_ex1b\n",
    "grade_ex1b(vqe, qp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "VQE 결과는 고전적으로 얻은 최적값과 같아야 합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전 1c: B=3, n=4 종목에 대한 포트폴리오 최적화\n",
    "\n",
    "\n",
    "이번 도전문제에서는 같은 문제를 해결하되, 각각의 자산에 대해 두 배의 가중치(두 배를 배치할 수 있음)를 부여할 수 있게 해 봅시다.(예: A를 두 번 할당하고 B를 한 번 할당하면 포트폴리오는 [2, 1, 0, 0]로 표시됩니다. 가중치 하나씩을 B, C, D에 할당하면 포트폴리오는 [0, 1, 1, 1]이 됨)<br> \n",
    "추가적으로, 제약 조건을 B=3으로 설정합니다. 새로운 제약조건 안에서 리스크와 수익 사이의 트레이드-오프을 최소화하는 최적의 포트폴리오를 찾으십시오.\n",
    "\n",
    "<div id='u-definition'></div>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "\n",
    "**도전 1c** <br>\n",
    "PortfolioOptimization 클래스를 사용하여 포트폴리오 인스턴스를 생성하는 코드를 완료합니다. <br>\n",
    "각 자산에 두배의 가중치를 할당하여 Budget=3일때 최적의 포트폴리오를 찾아보십시오.<br>\n",
    "QAOA를 사용하여 최적의 솔루션을 찾고 답변을 제출하십시오.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id='problem'></div>\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>힌트:</b> STOCK0, STOCK1, STOCK2, STOCK3 중 어느 것이라도 포트폴리오에서 두 배의 가중치를 가질 수 있습니다. 변수들을 담을 수 있도록 코드를 어떻게 변경할 수 있을까요? <br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: 필수 라이브러리 호출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Step 1: Let us begin by importing necessary libraries\n",
    "import qiskit\n",
    "from qiskit import Aer\n",
    "from qiskit.algorithms import VQE, QAOA, NumPyMinimumEigensolver\n",
    "from qiskit.algorithms.optimizers import *\n",
    "from qiskit.circuit.library import TwoLocal\n",
    "from qiskit.utils import QuantumInstance\n",
    "from qiskit.utils import algorithm_globals\n",
    "from qiskit_finance import QiskitFinanceError\n",
    "from qiskit_finance.applications.optimization import *\n",
    "from qiskit_finance.data_providers import *\n",
    "from qiskit_optimization.algorithms import MinimumEigenOptimizer\n",
    "from qiskit_optimization.applications import OptimizationApplication\n",
    "from qiskit_optimization.converters import QuadraticProgramToQubo\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import datetime\n",
    "import warnings\n",
    "from sympy.utilities.exceptions import SymPyDeprecationWarning\n",
    "warnings.simplefilter(\"ignore\",SymPyDeprecationWarning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: 시계열 데이터 생성 (금융 데이터)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 2. Generate time series data for four assets. \n",
    "# Do not change start/end dates specified to generate problem data.\n",
    "seed = 132 \n",
    "num_assets = 4\n",
    "stocks = [(\"STOCK%s\" % i) for i in range(num_assets)]\n",
    "data = RandomDataProvider(tickers=stocks,\n",
    "                 start=datetime.datetime(1955,11,5),   \n",
    "                 end=datetime.datetime(1985,10,26),  \n",
    "                 seed=seed)\n",
    "data.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's plot our finanical data (We are generating the same time series data as in the previous example.)\n",
    "for (cnt, s) in enumerate(data._tickers):\n",
    "    plt.plot(data._data[cnt], label=s)\n",
    "plt.legend()\n",
    "plt.xticks(rotation=90)\n",
    "plt.xlabel('days')\n",
    "plt.ylabel('stock value')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: 기대 수익과 공분산 행렬 얻기 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 3. Calculate mu and sigma for this problem\n",
    "\n",
    "mu = data.get_period_return_mean_vector()   #Returns a vector containing the mean value of each asset.\n",
    "sigma = data.get_period_return_covariance_matrix() #Returns the covariance matrix associated with the assets.\n",
    "print(mu, sigma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: 도전1c에 해당하는 변수와 제한 조건 설정하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 4. Set parameters and constraints based on this challenge 1c\n",
    "\n",
    "##############################\n",
    "# Provide your code here\n",
    "\n",
    "q2 =      #Set risk factor to 0.5\n",
    "budget2 =      #Set budget to 3\n",
    "\n",
    "##############################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: 포트폴리오 인스턴스를 생성해내는 코드 완성하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 5. Complete code to generate the portfolio instance\n",
    "\n",
    "\n",
    "##############################\n",
    "# Provide your code here\n",
    "\n",
    "portfolio2 =\n",
    "qp2 = \n",
    "\n",
    "\n",
    "##############################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6: QAOA를 사용해 문제 풀기 \n",
    "**QAOA(Quantum Approximate Optimization Algorithm)** 는 근자의 양자 시스템에서 조합 최적화 문제를 해결하기 위해 사용될 수 있는 또 다른 변형 알고리즘입니다. 이 알고리즘은 해밀토니안의 바닥 상태를 계산하는 데에도 사용할 수 있으며 Qiskit의 [QAOA](https://qiskit.org/documentation/stubs/qiskit.algorithms.QAOA.html) 어플리케이션을 사용하여 쉽게 구현할 수 있습니다. (QAOA에 대한 자세한 내용은 챌린지 4에서 배우게 됩니다. 이 연습에서는 Qiskit을 사용해 QAOA를 기본적으로 구현하는 것에 집중합시다.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step 6. Now let's use QAOA to solve this problem. \n",
    "\n",
    "optimizer = SLSQP(maxiter=1000)  \n",
    "algorithm_globals.random_seed = 1234\n",
    "backend = Aer.get_backend('statevector_simulator')\n",
    "\n",
    "##############################\n",
    "# Provide your code here \n",
    "\n",
    "qaoa = \n",
    "\n",
    "\n",
    "##############################\n",
    "\n",
    "qaoa_meo = MinimumEigenOptimizer(qaoa) #please do not change this code\n",
    "\n",
    "result2 = qaoa_meo.solve(qp2)  #please do not change this code\n",
    "\n",
    "print(result2) #please do not change this code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "노트: QAOA 실행이 완료되는 데 몇 분이 소요될 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 답안 제출"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check your answer and submit using the following code\n",
    "from qc_grader import grade_ex1c\n",
    "grade_ex1c(qaoa, qp2)  #please do not change the grader code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 더 읽을 거리:\n",
    "첫 입문 레벨 챌린지를 성공적으로 해결하신 모든 분들을 **축하합니다!** <br>\n",
    "포트폴리오 최적화와 Qiskit의 금융 모듈을 사용하여 예제 문제를 해결하는 방법에 대해 배울 수 있는 기회가 되었기를 바랍니다 <br> 더 많은 정보를 알고 싶다면 조합 최적화 문제에 대한 실제 양자 하드웨어에 대한 실험이 담긴 다음의 논문을 참고하십시오:\n",
    "<br>\n",
    "1. [<b>Quantum optimization using variational algorithms on near-term quantum devices. Moll et al. 2017<i>](https://arxiv.org/abs/1710.01022)<br>\n",
    "2. [<b>Improving Variational Quantum Optimization using CVaR. Barkoutsos et al. 2019.<i>](https://arxiv.org/abs/1907.04769)<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 행운을 빌어요 그리고 즐거운 도전이 되시길!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import qiskit.tools.jupyter\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 추가 정보\n",
    "\n",
    "**제작자:** Yuri Kobayashi\n",
    "\n",
    "**한글 번역:** 신소영, 김정원\n",
    "\n",
    "**Version:** 1.0.0"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}