qaoa/QAOA_for_PortOpt.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a753749f",
   "metadata": {},
   "source": [
    "#### Portfolio Optimization\n",
    "What is the best way to choose the subset of the set of all stocks, which optimizes financial objectives i.e., \n",
    "maximizing returns/minimizing the investment risks for an asset manager? This is what portfolio-optimization \n",
    "is about. The optimal portfolio allocation is the one that produces the maximum ratio between the return and risk. \n",
    "This problem can be stated as an optimization problem where the objective is to minimize a quadratic objective function. \\ \n",
    "\n",
    "$C(\\vec{x}) = \\lambda \\vec{x}^{\\text{T}} \\cdot \\Sigma \\cdot \\vec{x} - (1 - \\lambda) \\hspace{1mm} \\vec{u} \\cdot \\vec{x} $ \n",
    "\n",
    "where $\\Sigma$ is the covariance matrix of the stocks (capturing the risk part of the cost function), $\\vec{x}$ represents the percentage of invested capital in a given asset (normalised meaning $\\Sigma_{i=1}^{N} x_{i} = 1$), $\\vec{u}$ is the vector representing the expected returns of the stocks and $0 \\leq \\lambda \\leq 1$ is the asset manager control parameter. The quadratic term represents the volatility of the chosen portfolio, while the linear one represents the expected returns. Therefore, a low value of $\\lambda$ favors the expected returns of the portfolio, and high value of $\\lambda$ favors low volatility; The latter is because we are minimizing the cost function and the larger positive quadratic term means larger penalties for risky portfolios. \\\n",
    "\n",
    "After mapping this problem onto an Ising model, the cost function is coded in the interaction\n",
    "Hamiltonian (including zz gates in terms of spin model) whilst and the mixing unitary is there to explore the state space for minimization. This approach is often accompanied by classical optimizers to pick the best move in the state-space. \\\n",
    "\n",
    "Here, we implement and evaluate a portfolio rebalancing instance (including only 7 assests)\n",
    "using a noisy quantum machine (IBM-nairobi). The most probable bit-string encodes the solution. \\\n",
    "\n",
    "Note: We are not imposing a soft or hard constraint (like having equally valued investment in each stock) which makes this solution, non-realistic, but the fact that one can impose, at least for the soft constraint, the constraint in quadratic form means that modifying the situation would be easy. \\\n",
    "\n",
    "Refs:  \n",
    "(1) Hodson, M., Ruck, B., Ong, H., Garvin, D., and Dulman, S., \n",
    "    Portfolio rebalancing experiments using the Quantum Alternating Operator Ansatz, arXiv:1911.05296 \\\n",
    "(2) https://www.zorc-finance.com/post/optimal-portfolios-with-qaoa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e28161d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, IBMQ, execute, transpile, Aer, assemble\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4ef0b307",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import networkx as nx\n",
    "\n",
    "# The graph \n",
    "G = nx.Graph()\n",
    "G.add_nodes_from([0, 1, 2, 3, 4, 5, 6])\n",
    "G.add_edges_from([(0, 1), (0, 2), (1, 2), (1, 4), (2, 3), (2, 4), (3, 4),\n",
    "                  (4, 2), (4, 5), (4, 6), (5, 1), (5, 2), (5, 4), (6, 1), (6,3), (6,5)])\n",
    "nx.draw(G, with_labels=True, alpha=0.8, node_size=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "508f4c16",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister\n",
    "from qiskit import Aer, execute\n",
    "from qiskit.circuit import Parameter\n",
    "\n",
    "# Adjacency is essentially a matrix which tells you which nodes are\n",
    "# connected. This matrix is given as a sparse matrix, so we need to\n",
    "# convert it to a dense matrix\n",
    "adjacency = nx.adjacency_matrix(G).todense()\n",
    "\n",
    "nqubits = 7\n",
    "\n",
    "\n",
    "## Mixing Unitary i.e. rotations about X \n",
    "beta = Parameter(\"$\\\\beta$\")\n",
    "qc_mix = QuantumCircuit(nqubits)\n",
    "for i in range(0, nqubits):\n",
    "    qc_mix.rx(2 * beta, i)\n",
    "    \n",
    "# qc_mix.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c623c139",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The problem Unitary including zz gates\n",
    "gamma = Parameter(\"$\\\\gamma$\")\n",
    "qc_p = QuantumCircuit(nqubits)\n",
    "for pair in list(G.edges()):  # pairs of nodes\n",
    "    qc_p.rzz(2 * gamma, pair[0], pair[1])\n",
    "    qc_p.barrier()\n",
    "    \n",
    "# qc_p.decompose().draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "6493ac44",
   "metadata": {},
   "outputs": [],
   "source": [
    "## initial State i.e. all in | + \\rangle state\n",
    "qc_0 = QuantumCircuit(nqubits)\n",
    "for i in range(0, nqubits):\n",
    "    qc_0.h(i)\n",
    "    \n",
    "# qc_0.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b90888c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x7f845bfce5c0>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qc_qaoa = QuantumCircuit(nqubits)\n",
    "\n",
    "qc_qaoa.append(qc_0, [i for i in range(0, nqubits)])\n",
    "qc_qaoa.append(qc_p, [i for i in range(0, nqubits)])\n",
    "qc_qaoa.append(qc_mix, [i for i in range(0, nqubits)])\n",
    "\n",
    "# qc_qaoa.decompose().decompose().draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a2768352",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "ibmqfactory.load_account:WARNING:2022-07-26 00:16:23,693: Credentials are already in use. The existing account in the session will be replaced.\n"
     ]
    }
   ],
   "source": [
    "# replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)\n",
    "IBMQ.save_account(\"*******\", overwrite=True) \n",
    "provider = IBMQ.load_account()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "119112df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def maxcut_obj(x, G):\n",
    "    \"\"\"\n",
    "    Given a bitstring as a solution, this function returns\n",
    "    the number of edges shared between the two partitions\n",
    "    of the graph.\n",
    "    \n",
    "    Args:\n",
    "        x: str\n",
    "           solution bitstring\n",
    "           \n",
    "        G: networkx graph\n",
    "        \n",
    "    Returns:\n",
    "        obj: float\n",
    "             Objective\n",
    "    \"\"\"\n",
    "    obj = 0\n",
    "    for i, j in G.edges():\n",
    "        if x[i] != x[j]:\n",
    "            obj -= 1\n",
    "            \n",
    "    return obj\n",
    "\n",
    "\n",
    "def compute_expectation(counts, G):\n",
    "    \n",
    "    \"\"\"\n",
    "    Computes expectation value based on measurement results\n",
    "    \n",
    "    Args:\n",
    "        counts: dict\n",
    "                key as bitstring, val as count\n",
    "           \n",
    "        G: networkx graph\n",
    "        \n",
    "    Returns:\n",
    "        avg: float\n",
    "             expectation value\n",
    "    \"\"\"\n",
    "    \n",
    "    avg = 0\n",
    "    sum_count = 0\n",
    "    for bitstring, count in counts.items():\n",
    "        \n",
    "        obj = maxcut_obj(bitstring, G)\n",
    "        avg += obj * count\n",
    "        sum_count += count\n",
    "        \n",
    "    return avg/sum_count\n",
    "\n",
    "\n",
    "# We will also bring the different circuit components that\n",
    "# build the qaoa circuit under a single function\n",
    "def create_qaoa_circ(G, theta):\n",
    "    \n",
    "    \"\"\"\n",
    "    Creates a parametrized qaoa circuit\n",
    "    \n",
    "    Args:  \n",
    "        G: networkx graph\n",
    "        theta: list\n",
    "               unitary parameters\n",
    "                     \n",
    "    Returns:\n",
    "        qc: qiskit circuit\n",
    "    \"\"\"\n",
    "    \n",
    "    nqubits = len(G.nodes())\n",
    "    p = len(theta)//2  # number of alternating unitaries\n",
    "    qc = QuantumCircuit(nqubits)\n",
    "    \n",
    "    beta = theta[:p]\n",
    "    gamma = theta[p:]\n",
    "    \n",
    "    # initial_state\n",
    "    for i in range(0, nqubits):\n",
    "        qc.h(i)\n",
    "    \n",
    "    for irep in range(0, p):\n",
    "        \n",
    "        # problem unitary\n",
    "        for pair in list(G.edges()):\n",
    "            qc.rzz(2 * gamma[irep], pair[0], pair[1])\n",
    "\n",
    "        # mixer unitary\n",
    "        for i in range(0, nqubits):\n",
    "            qc.rx(2 * beta[irep], i)\n",
    "            \n",
    "    qc.measure_all()\n",
    "        \n",
    "    return qc\n",
    "\n",
    "# Finally we write a function that executes the circuit on the chosen backend\n",
    "def get_expectation(G, p, shots=512):\n",
    "    \n",
    "    \"\"\"\n",
    "    Runs parametrized circuit\n",
    "    \n",
    "    Args:\n",
    "        G: networkx graph\n",
    "        p: int,\n",
    "           Number of repetitions of unitaries\n",
    "    \"\"\"\n",
    "    \n",
    "    # Get backend for experiment\n",
    "    provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n",
    "    backend = provider.get_backend('ibmq_quito')\n",
    "\n",
    "\n",
    "    backend = Aer.get_backend('qasm_simulator')\n",
    "    backend.shots = shots\n",
    "    \n",
    "    def execute_circ(theta):\n",
    "        \n",
    "        qc = create_qaoa_circ(G, theta)\n",
    "        counts = backend.run(qc, seed_simulator=10, \n",
    "                             nshots=512).result().get_counts()\n",
    "        \n",
    "        return compute_expectation(counts, G)\n",
    "    \n",
    "    return execute_circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9645ee9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -8.203125\n",
       "   maxcv: 0.0\n",
       " message: 'Optimization terminated successfully.'\n",
       "    nfev: 28\n",
       "  status: 1\n",
       " success: True\n",
       "       x: array([2.85633335, 0.18625827])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.optimize import minimize\n",
    "\n",
    "\n",
    "expectation = get_expectation(G, p=1)\n",
    "\n",
    "res = minimize(expectation,[1.0, 1.0], method='COBYLA')\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cc318012",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/ky/942xxmk108g0y_mh6s451qxc0000gn/T/ipykernel_23585/1036274317.py:11: DeprecationWarning: Passing a Qobj to Backend.run is deprecated and will be removed in a future release. Please pass in circuits or pulse schedules instead.\n",
      "  job = backend.run(qobj)\n"
     ]
    }
   ],
   "source": [
    "# Get backend for experiment\n",
    "provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')\n",
    "backend = provider.get_backend('ibm_nairobi')\n",
    "\n",
    "# prepare the circuit for the backend\n",
    "qc_res = create_qaoa_circ(G, res.x)\n",
    "mapped_circuit = transpile(qc_res, backend=backend)\n",
    "qobj = assemble(mapped_circuit, backend=backend, shots=2048)\n",
    "\n",
    "# execute the circuit\n",
    "job = backend.run(qobj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "906f36f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.DONE: 'job has successfully run'>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e26ae2b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'62df94ce656a4579ae693b8a'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.job_id()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "f57cc67c",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = job.result()\n",
    "counts = result.get_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "f3705083",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1008 with 1 Axes>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.visualization import plot_histogram\n",
    "plot_histogram(counts, figsize=(20,14))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da553781",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.7"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}