VQE for portfolio optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing my own version of Variational Quantum Eigensolver\n",
    "\n",
    "#### Why VQE is important?\n",
    "\n",
    "Many problems require to find minimum eigenvalue of a matrix. We can use quantum phase estimation for this but due to the hardware limits it remains a fundamental challenge in the current NISQ scenario. VQE presents us a quantum-classical approach to overcome this issue.\n",
    "\n",
    "### Some important definitions\n",
    "\n",
    "#### Hamiltonian of the system\n",
    "\n",
    "Hamiltonian of the system gives the total energy (sum of kinetic energy and potential energy) of the system. It basically describes the energy of the system. It can be derived from the Schrodinger equation.\n",
    "\n",
    "#### Eigenvalue\n",
    "\n",
    "## Qunatum Expectation Estimation\n",
    "\n",
    "The quantum expectation estimation algorithm finds the expectation value of any Hamiltonian ($H$) for any input state $\\Psi$\n",
    "\n",
    "Any Hamiltonian might be written as,\n",
    "\n",
    "$$ \\langle H\\rangle = \\sum\\limits_{i\\alpha} h_{\\alpha}^i \\langle\\sigma_{\\alpha}^i\\rangle + \\sum\\limits_{ij\\alpha\\beta} h_{\\alpha\\beta}^{ij} \\langle\\sigma_{\\alpha}^{i}\\sigma_{\\beta}^{j}\\rangle + \\dots$$\n",
    "\n",
    "where, $i$,$j$... identify the subsystem on Hamiltonian act and $\\alpha$, $\\beta$... are Pauli operator, hence, it can be $x$, $y$, $z$ and $i$\n",
    "\n",
    "For example, for one qubit system,\n",
    "\n",
    "\n",
    "$$\\langle H\\rangle=\\langle \\psi|H|\\psi\\rangle=a\\cdot\\langle\\psi|I|\\psi\\rangle+b\\cdot\\langle\\psi|Z|\\psi\\rangle +c\\cdot\\langle\\psi|Y|\\psi\\rangle + +d\\cdot\\langle\\psi|X|\\psi\\rangle$$\n",
    "\n",
    "Thus, the evaluation of $\\langle H \\rangle$reduces to the sum of a polynomial number of expectation values of simple Pauli operators for a quantum state $\\psi$, multiplied by some real constants. A quantum device can efficiently evaluate the expectation value of a tensor product of an arbitrary number of simple Pauli operators. Therefore, with an n-qubit state we can efficiently evaluate the expectation value of this $2^n \\times 2^n$\n",
    "Hamiltonian.\n",
    "\n",
    "The coherence time for measurement of each state in VQE is $O(1)$ (an advantage over QPE) where as the disadvantage is number state preparation is increased and the precision is also affected.\n",
    "\n",
    "In essence, QEE dramatically reduce the coherence time requirement while maintaining an exponential advantage over\n",
    "the classical case, by adding a polynomial number of repetitions with respect to QPE. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### VQE\n",
    "\n",
    "#### Mathematics associated\n",
    "\n",
    "Relation between eigenvectors $|\\psi\\rangle$ and eigenvalues $\\lambda$ can be given by,\n",
    "\n",
    "$$H|\\psi\\rangle = \\lambda \\psi$$\n",
    "\n",
    "The eigenvector $|\\psi\\rangle$ corresponding to the lowest eigenvalue is the $|\\psi\\rangle$ that minimizes,\n",
    "\n",
    "$$\\frac{\\langle \\psi|H|\\psi\\rangle}{\\langle \\psi|\\psi\\rangle}$$\n",
    "\n",
    "Or we can also say,\n",
    "\n",
    "$$\\langle \\psi|H|\\psi\\rangle>=E_0$$\n",
    "\n",
    "This simply means that $E_{0}$ is the lowest energy eigenstate (ground state) of $H$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variational form\n",
    "\n",
    "The algorithm basically goes over every state $|\\psi\\rangle$ and checks which one of them has the minimum expectation value so that we can find out our lowest eigenvalue. For checking every state we have to create a parametrized circuit (anstanz) that covers each and every possible state. Picking a 'good' anstanz from all possible is an art. The circuit should be created such that it doesn't have many parameters and gates (should be shallow).\n",
    "\n",
    "#### Parameter optimization\n",
    "\n",
    "Now the easy classical work where you have to optimize your parameters for giving you the minimum expectation value. You can use any prebuilt classical optimizer for it or even create your own. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let us dive into implementing Portfolio optimization from scratch\n",
    "\n",
    "### What is Portfolio Optimization?\n",
    "We are using mean-variance portfolio optimization technique.\n",
    "\n",
    "#### Mean-Variance Analysis\n",
    "\n",
    "According to the [Investopedia](https://www.investopedia.com/terms/m/meanvariance-analysis.asp):\n",
    "\n",
    "Mean-variance analysis is the process of weighing risk, expressed as variance, against expected return. Investors use mean-variance analysis to make decisions about which financial instruments to invest in, based on how much risk they are willing to take on in exchange for different levels of reward. Mean-variance analysis allows investors to find the biggest reward at a given level of risk.\n",
    "\n",
    "## Let us dive into implementing Portfolio optimization from scratch\n",
    "\n",
    "### The first thing we will do is create a cost function which we want to minimize, we will map it into an Ising Hamiltonian. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import the libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.finance.data_providers import RandomDataProvider\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "import pandas as pd\n",
    "from nsepy import get_history\n",
    "\n",
    "from docplex.mp.model import Model\n",
    "from qiskit.optimization import QuadraticProgram\n",
    "from qiskit.optimization.converters import LinearEqualityToPenalty\n",
    "from qiskit.aqua.algorithms import NumPyMinimumEigensolver\n",
    "\n",
    "import pennylane as qml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I picked three random assets from Indian Stock Market NSE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "assets = [ 'INFY', 'TCS', 'YESBANK']\n",
    "stockStartDate = datetime.date(2018,8,20)\n",
    "stockEndDate = datetime.date(2019,8,20)\n",
    "\n",
    "df = pd.DataFrame()\n",
    "\n",
    "for stock in assets:\n",
    "    df[stock] = get_history(symbol=stock, start=stockStartDate, end=stockEndDate)['Close']\n",
    "    \n",
    "returns = df.pct_change()\n",
    "cov_matrix_annual = returns.cov() * 249\n",
    "\n",
    "mu = returns.mean().to_numpy()     #expected returns\n",
    "sigma = cov_matrix_annual.to_numpy()  #covariance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating the Quadratic program for the following equation\n",
    "\n",
    "max: $  \\mu^T x - qx^T \\sum x$\n",
    "\n",
    "Subject to: $ 1^T x= B$\n",
    "\n",
    "#### where we use the following notation:\n",
    "\n",
    "* x∈{0,1}$^n$  denotes the vector of binary decision variables, which indicate which assets to pick (x[i]=1) and which not to pick (x[i]=0),\n",
    "\n",
    "* $\\mu ∈ R^n$ defines the expected returns for the assets,\n",
    "\n",
    "* $\\sum ∈ R^{n×n}$ specifies the covariances between the assets,\n",
    "\n",
    "* $q>0$ controls the risk appetite of the decision maker,\n",
    "\n",
    "* and $B$ denotes the budget, i.e. the number of assets to be selected out of $n$.\n",
    "\n",
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = 0.1                  # set risk factor\n",
    "budget = 2       # set budget\n",
    "penalty = num_assets      # set parameter to scale the budget penalty term\n",
    "\n",
    "mdl = Model('docplex model')\n",
    "x = mdl.binary_var_list(num_assets)\n",
    "\n",
    "# set objective function: \n",
    "#\n",
    "#     maximize { mu^T * x - q * x^T * sigma * x }\n",
    "#\n",
    "\n",
    "objective = mdl.sum([mu[i] * x[i] for i in range(num_assets)])  # mu^T * x\n",
    "objective -= q * mdl.sum([sigma[i][j]*x[i]*x[j] for i in range(num_assets) for j in range(num_assets)])\n",
    "mdl.maximize(objective)\n",
    "\n",
    "# add budget constraint: \n",
    "#\n",
    "#     1^T * x == budget\n",
    "#\n",
    "cost = mdl.sum([x[i] for i in range(num_assets)])\n",
    "mdl.add_constraint(cost == budget, ctname='budget')\n",
    "    \n",
    "\n",
    "# converting to Quadratic Program\n",
    "mod = QuadraticProgram()        \n",
    "mod.from_docplex(mdl)\n",
    "\n",
    "#removing the constraint to create the QUBO\n",
    "lineq2penalty = LinearEqualityToPenalty(penalty) \n",
    "qubo = lineq2penalty.convert(mod)\n",
    "\n",
    "#converting QUBO to an Ising Hamiltonian\n",
    "H, offset = qubo.to_ising()\n",
    "H.num_qubits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = H.to_legacy_op()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'IIZ\\t(1.4836080159591571+0j)\\nIZI\\t(1.4967393480408977+0j)\\nZII\\t(1.4641348464434452+0j)\\nIZZ\\t(1.5009745648914863+0j)\\nZIZ\\t(1.4998570244690541+0j)\\nZZI\\t(1.4995262792878843+0j)\\n'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.print_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining a 2 layer `ansatz` with 9 parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ansatz(theta):\n",
    "    \n",
    "    qml.RX(theta[0], wires=0)\n",
    "    qml.RX(theta[1], wires=1)\n",
    "    qml.RX(theta[2], wires=2)\n",
    "    qml.CNOT(wires=[0,1])\n",
    "    qml.CNOT(wires=[0,2])\n",
    "    qml.CNOT(wires=[1,2])\n",
    "    qml.RX(theta[3], wires=0)\n",
    "    qml.RX(theta[4], wires=1)\n",
    "    qml.RX(theta[5], wires=2)\n",
    "    qml.CNOT(wires=[0,1])\n",
    "    qml.CNOT(wires=[0,2])\n",
    "    qml.CNOT(wires=[1,2])\n",
    "    qml.RX(theta[6], wires=0)\n",
    "    qml.RX(theta[7], wires=1)\n",
    "    qml.RX(theta[8], wires=2)\n",
    "    \n",
    "    return ansatz\n",
    "\n",
    "dev1 = qml.device(\"qiskit.aer\", wires=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions for returning the `expectation value` in a `particular basis`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev1)\n",
    "def circuit_IIZ(params):\n",
    "    ansatz(params)\n",
    "    return qml.expval(qml.Identity(0)@qml.Identity(1)@qml.PauliZ(2))\n",
    "\n",
    "@qml.qnode(dev1)\n",
    "def circuit_IZI(params):\n",
    "    ansatz(params)\n",
    "    return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.Identity(2))\n",
    "\n",
    "@qml.qnode(dev1)\n",
    "def circuit_ZII(params):\n",
    "    ansatz(params)\n",
    "    return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.Identity(2))\n",
    "\n",
    "@qml.qnode(dev1)\n",
    "def circuit_IZZ(params):\n",
    "    ansatz(params)\n",
    "    return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.PauliZ(2))\n",
    "\n",
    "@qml.qnode(dev1)\n",
    "def circuit_ZIZ(params):\n",
    "    ansatz(params)\n",
    "    return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.PauliZ(2))\n",
    "\n",
    "@qml.qnode(dev1)\n",
    "def circuit_ZZI(params):\n",
    "    ansatz(params)\n",
    "    return qml.expval(qml.PauliZ(0)@qml.PauliZ(1)@qml.Identity(2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Change the `Hamiltonian` into a `dictionary` form just for the ease"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pauli_operator_to_dict(pauli_operator):\n",
    "    \n",
    "    d = pauli_operator.to_dict()\n",
    "    paulis = d['paulis']\n",
    "    paulis_dict = {}\n",
    "\n",
    "    for x in paulis:\n",
    "        label = x['label']\n",
    "        coeff = x['coeff']['real']\n",
    "        paulis_dict[label] = coeff\n",
    "\n",
    "    return paulis_dict\n",
    "\n",
    "pauli_dict = pauli_operator_to_dict(H)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we define our final function `VQE` (our objective function). We want to maximize this function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vqe(parameters):\n",
    "    \n",
    "    expval_ZII = pauli_dict['ZII'] * circuit_ZII(parameters)  \n",
    "    expval_IIZ = pauli_dict['IIZ'] * circuit_IIZ(parameters)\n",
    "    expval_IZI = pauli_dict['IZI'] * circuit_IZI(parameters)\n",
    "    expval_ZZI = pauli_dict['ZZI'] * circuit_ZZI(parameters)\n",
    "    expval_ZIZ = pauli_dict['ZIZ'] * circuit_ZIZ(parameters)\n",
    "    expval_IZZ = pauli_dict['IZZ'] * circuit_IZZ(parameters)\n",
    "    \n",
    "    # summing the measurement results\n",
    "    classical_adder = expval_ZII + expval_IIZ + expval_ZIZ +  expval_ZZI + expval_ZIZ + expval_IZZ\n",
    "    \n",
    "    return classical_adder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run optimization using `Gradient Descent` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "opt = qml.GradientDescentOptimizer(stepsize=0.5)\n",
    "value = []\n",
    "    # optimize parameters in objective\n",
    "params = np.random.rand(9)*2\n",
    "init_params = params\n",
    "steps = 100\n",
    "for i in range(steps):\n",
    "    params = opt.step(vqe, params)\n",
    "    value.append(vqe(params))\n",
    "    \n",
    "plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the final circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev1)\n",
    "def final_circ(params):\n",
    "    ansatz(params)\n",
    "    return qml.probs(wires=[0,1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.14159265e+00, -1.33407091e-01, -6.60037790e-01, -6.19521602e-17,\n",
       "       -7.50574652e-17, -1.83896694e+00, -5.72904050e-18,  1.33407091e-01,\n",
       "        7.13382634e-01])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 8 artists>"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params), color='midnightblue')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Result from classical eigensolver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voila! We have successfully implemented VQE for portfolio optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'IIZ': 1.4836080159591571,\n",
       " 'IZI': 1.4967393480408977,\n",
       " 'ZII': 1.4641348464434452,\n",
       " 'IZZ': 1.5009745648914863,\n",
       " 'ZIZ': 1.4998570244690541,\n",
       " 'ZZI': 1.4995262792878843}"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " pauli_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'IIZ\\t(1.4836080159591571+0j)\\nIZI\\t(1.4967393480408977+0j)\\nZII\\t(1.4641348464434452+0j)\\nIZZ\\t(1.5009745648914863+0j)\\nZIZ\\t(1.4998570244690541+0j)\\nZZI\\t(1.4995262792878843+0j)\\n'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "H.print_details()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 742.777x204.68 with 1 Axes>"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import QuantumCircuit\n",
    "\n",
    "circ = QuantumCircuit(3)\n",
    "circ.rx(params[0], 0)\n",
    "circ.rx(params[1], 1)\n",
    "circ.rx(params[2], 2)\n",
    "circ.cx(0,1)\n",
    "circ.cx(0,2)\n",
    "circ.cx(1,2)\n",
    "circ.rx(params[3], 0)\n",
    "circ.rx(params[4], 1)\n",
    "circ.rx(params[5], 2)\n",
    "circ.cx(0,1)\n",
    "circ.cx(0,2)\n",
    "circ.cx(1,2)\n",
    "circ.rx(params[6], 0)\n",
    "circ.rx(params[7], 1)\n",
    "circ.rx(params[8], 2)\n",
    "\n",
    "circ.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('quantum': conda)",
   "language": "python",
   "name": "python38564bitquantumcondac6d49497be9f46f4a52c048f3dd968a0"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}