benchmark_circuits.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Benchmarking circuits for Qiskit\n",
    "\n",
    "![Qiskit logo](img/qiskit-heading.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This work provides a collection of quantum circuits that can be used to benchmark Qiskit, to keep track of the impact of the changes on its performance as codebase evolves or simply assert it at a given point in time.\n",
    "\n",
    "The quantum circuits provided both span useful building blocks for larger quantum circuits, as well as application-related circuits. A few examples of the currently available ones are:\n",
    "\n",
    "- random circuits\n",
    "- QFT\n",
    "- n-Toffoli gate\n",
    "- Adders\n",
    "- variational circuits for quantum chemistry (UCCSD)\n",
    "- Bravyi-Haah distillation protocols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Users can compute various metrics on these `QuantumCircuit` objects by accesing for example their width, depth, gate count, or runtime on either a simulator or QPU, before or after optimizations are performed. These metrics can then be used to assert the performance of various modules of Qiskit, or the feasibility of an approach on a backend with limited capabilities such as memory or coherence time.\n",
    "\n",
    "These circuits have parameters, so that one can observe how the desired metrics scale with input size.\n",
    "\n",
    "This list can be expanded to various other types of circuits such as adders, Grover for a random oracle, magic state factory, quantum error-correcting code and many others."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Motivation\n",
    "\n",
    "Users can compute various metrics from the benchmarking circuits, e.g\n",
    "- Compare results\n",
    "    - Accross papers\n",
    "    - Qiskit version\n",
    "    - Backends\n",
    "- Specificaly, compare transpilers (size, depth, ...)\n",
    "- Get performance metrics\n",
    "    - simulators\n",
    "    - Qiskit itself"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## General-purpose quantum circuits\n",
    "\n",
    "These circuits are building blocks that are used in a wide array or larger circuits. They are formulated at the highest-level of abstraction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from circuit_benchmarks.toffoli import toffoli\n",
    "toffoli(4).draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from circuit_benchmarks.ripple_adder import ripple_adder\n",
    "ripple_adder(10).draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##  Using QFT circuits to benchmark\n",
    "Quantum Fourier Transform is a very important subcircuit for many applications. We can use it to benchmark transpilers.\n",
    "For example see how they perform on diferent chip layouts, square, hexagonal or triangular lattices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.circuit import QuantumCircuit\n",
    "from qiskit.mapper import CouplingMap, swap_mapper\n",
    "from qiskit.tools.parallel import parallel_map\n",
    "from qiskit.converters import circuit_to_dag\n",
    "from qiskit.converters import dag_to_circuit\n",
    "from qiskit.extensions.standard import SwapGate\n",
    "from qiskit.mapper import Layout\n",
    "from qiskit.transpiler.passes.unroller import Unroller\n",
    "import copy\n",
    "\n",
    "from qiskit.transpiler.passes.cx_cancellation import CXCancellation\n",
    "from qiskit.transpiler.passes.decompose import Decompose\n",
    "from qiskit.transpiler.passes.optimize_1q_gates import Optimize1qGates\n",
    "from qiskit.transpiler.passes.mapping.barrier_before_final_measurements import BarrierBeforeFinalMeasurements\n",
    "from qiskit.transpiler.passes.mapping.check_cnot_direction import CheckCnotDirection\n",
    "from qiskit.transpiler.passes.mapping.cx_direction import CXDirection\n",
    "from qiskit.transpiler.passes.mapping.dense_layout import DenseLayout\n",
    "from qiskit.transpiler.passes.mapping.trivial_layout import TrivialLayout\n",
    "from qiskit.dagcircuit import DAGCircuit\n",
    "from qiskit.transpiler.passes import StochasticSwap\n",
    "from qiskit.transpiler import PassManager\n",
    "from qiskit.transpiler.passes import LookaheadSwap\n",
    "from circuit_benchmarks.qft import qft_circuit\n",
    "from qiskit.transpiler import transpile\n",
    "from qiskit import BasicAer\n",
    "from qiskit.transpiler.passes import BasicSwap\n",
    "\n",
    "\n",
    "basis_gates = ['u1','u2','u3','cx','id']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from networkx import grid_2d_graph, hexagonal_lattice_graph, triangular_lattice_graph, to_edgelist, draw, kamada_kawai_layout, convert_node_labels_to_integers\n",
    "\n",
    "def square_grid_adj(n, m):\n",
    "    nxgraph = grid_2d_graph(n, m)\n",
    "    nodelist = list(nxgraph.nodes)\n",
    "    return [[nodelist.index(n1),nodelist.index(n2)] for n1, n2, _ in to_edgelist(nxgraph)]\n",
    "def hex_grid_adj(n, m):\n",
    "    nxgraph = hexagonal_lattice_graph(n, m)\n",
    "    nodelist = list(nxgraph.nodes)\n",
    "    return [[nodelist.index(n1),nodelist.index(n2)] for n1, n2, _ in to_edgelist(nxgraph)]\n",
    "def tri_grid_adj(n, m):\n",
    "    nxgraph = triangular_lattice_graph(n, m)\n",
    "    nodelist = list(nxgraph.nodes)\n",
    "    return [[nodelist.index(n1),nodelist.index(n2)] for n1, n2, _ in to_edgelist(nxgraph)]\n",
    "\n",
    "upper_bound = 4\n",
    "grid_graphs = [square_grid_adj(n,n) for n in range(2,upper_bound)]\n",
    "hex_graphs = [hex_grid_adj(n,n) for n in range(2,upper_bound)]\n",
    "tri_graphs = [tri_grid_adj(n,n) for n in range(2,upper_bound)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit.mapper import CouplingMap\n",
    "\n",
    "grid_couplm = [CouplingMap(l) for l in grid_graphs]\n",
    "hex_couplm =  [CouplingMap(l) for l in hex_graphs]\n",
    "tri_couplm =  [CouplingMap(l) for l in tri_graphs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "g = grid_2d_graph(3,3)\n",
    "pos = kamada_kawai_layout(g)\n",
    "draw(g, pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For each grid we transpile a QFT circuit to that grid."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "simulator = BasicAer.get_backend('qasm_simulator')\n",
    "xs = [grid.size() for grid in grid_couplm]\n",
    "stoch_circs = []\n",
    "la_circs = []\n",
    "grid = grid_couplm[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for grid in grid_couplm:\n",
    "    circuit = qft_circuit(grid.size())\n",
    "    # Use Qiskit's Stochasit swap mapper\n",
    "    stoch_qft = transpile(circuit, simulator, pass_manager=PassManager(StochasticSwap(grid)))\n",
    "    stoch_circs.append(stoch_qft)\n",
    "    # Use Sven's Lookahead swap mapper\n",
    "    la_qft = transpile(circuit, simulator, pass_manager=PassManager(LookaheadSwap(grid)))\n",
    "    la_circs.append(la_qft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "stoch_circs[0].draw(output='mpl', scale=0.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "la_circs[0].draw(output='mpl', scale=0.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "stoch_depth = [circ.depth() for circ in stoch_circs]\n",
    "la_depth = [circ.depth() for circ in la_circs]\n",
    "xs = [grid.size() for grid in grid_couplm]\n",
    "\n",
    "plt.plot(xs, stoch_depth, xs, la_depth)\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "stoch_size = [circ.size() for circ in stoch_circs]\n",
    "la_size = [circ.size() for circ in la_circs]\n",
    "xs = [grid.size() for grid in grid_couplm]\n",
    "\n",
    "plt.plot(xs, stoch_size, xs, la_size)\n",
    "plt.draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "g = hexagonal_lattice_graph(3,3)\n",
    "pos = kamada_kawai_layout(g)\n",
    "draw(g, pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Application-specific quantum circuits\n",
    "\n",
    "These circuits directly provide a way for users to benchmark the performance of Qiskit over particular applications of interest, and evaluate the feasibility of an approach on a target hardware, for example (runtime, hardware constraints on quantum volume...)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Varitonal circuits in quantum chemistry\n",
    "\n",
    "Some of these circuits are tied to a given problem, defined for example by a molecule and a basis set. The number of qubits required by these circuits, as well as the number of parameters used for the variational search is then determined accordingly. That is, these circuits cannot be simply fully-defined by a number of qubits provided as input; this is the case of the UCCSD variational form, for example. However, one can still observe how different metrics scale for these circuits by varying problem size (e.g the molecule or basis set), which makes sense for users that are focused on concrete applications in the field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# A list of molecules to use in benchmarking (can be grown larger by Qiskit users)\n",
    "H2 = 'H .0 .0 .0; H .0 .0 0.735'\n",
    "LiH = 'Li .0 .0 .0; H .0 .0 1.6'\n",
    "NaH = 'Na .0 .0 .0; H .0 .0 1.9'\n",
    "molecules = [H2, LiH, NaH]\n",
    "\n",
    "# A list of bases to use in benchmarking (can be grown larger by Qiskit users)\n",
    "bases = ['sto3g', '631g', 'ccpVDZ']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit_chemistry.drivers import PySCFDriver, UnitsType\n",
    "from circuit_benchmarks.UCCSD import UCCSD_qc\n",
    "\n",
    "#from qiskit import BasicAer, execute\n",
    "import time\n",
    "\n",
    "# How the q.c width, depth and performance scale with molecule size, for a given basis\n",
    "widths, depths, runtimes = [], [], []\n",
    "for m in molecules:\n",
    "    qc = UCCSD_qc((m, 'sto3g', UnitsType.ANGSTROM), active_occupied=[], active_unoccupied=[],\n",
    "                   map_type='parity', two_qubit_reduction=False,\n",
    "                   depth=1)\n",
    "    widths.append(qc.width())\n",
    "    depths.append(qc.depth())\n",
    "\n",
    "    #t_start=time.time()\n",
    "    #job = execute(qc, BasicAer.get_backend('statevector_simulator'))\n",
    "    #t_elapsed = time.time() - t_start\n",
    "    #runtimes.append(t_elapsed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The code provides functions allowing to generate these UCCSD circuits for various molecules, basis sets and active spaces. The benchmark can be enriched by users, inputing their own problem and adding the corresponding circuit to the benchmark.\n",
    "\n",
    "This approach can be generalized easily to different ansatz, or active spaces, allowing the user to determine what is the best approach to running for example VQE. They could then identiify the feasible approaches on the target hardware, and the parameters yielding the most appealing performance-accuracy trade-off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt; plt.rcdefaults()\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "    \n",
    "labels = ('H2', 'LiH', 'NaH')\n",
    "y_pos = np.arange(len(labels))\n",
    "\n",
    "plt.bar(y_pos, widths, align='center', alpha=1.0, color = \"blue\")\n",
    "plt.xticks(y_pos, labels)\n",
    "plt.yticks(widths)\n",
    "plt.ylabel('Number of qubits')\n",
    "plt.title('# qubits with problem size')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![blue](img/blue.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plt.bar(y_pos, depths, align='center', alpha=1.0, color = \"red\")\n",
    "plt.xticks(y_pos, labels)\n",
    "plt.yticks(depths)\n",
    "plt.ylabel('Circuit depth')\n",
    "plt.title('Circuit depth with problem size')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![orange](img/orange.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plt.bar(y_pos, runtimes, align='center', alpha=1.0, color = \"orange\")\n",
    "plt.xticks(y_pos, labels)\n",
    "plt.yticks(runtimes)\n",
    "plt.ylabel('Runtime (s)')\n",
    "plt.title('Simulation time with problem size (wavefunction simulator)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![red](img/red.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Magic State Factory\n",
    "Circuits for magic state distillation are also interesting since they will be a big part of any error-corrected quantum computation.\n",
    "Several families of distillation protocols exist, we implemented the protocol by Bravyi and Haah,\n",
    "distilling 2k magic states from 6k+8 initial noisier magic states.\n",
    "Here is the smallest example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "from circuit_benchmarks.distillation_protocols import reed_muller_15, bravyi_haah_distillation\n",
    "\n",
    "upper_bound_bravyi_haah = 15\n",
    "\n",
    "circ_reed_muller_15 = reed_muller_15()\n",
    "nq_reed_muller_15 = sum([len(reg) for reg in circ_reed_muller_15.qregs])\n",
    "\n",
    "circs_bravyi_haah = [bravyi_haah_distillation(k) for k in range(1, upper_bound_bravyi_haah+1)]\n",
    "nqs_bravyi_haah = [sum([len(reg) for reg in circ.qregs]) for circ in circs_bravyi_haah]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "nqs_bravyi_haah"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "circs_bravyi_haah[0].draw(output='mpl', scale=.2, style={'fold':150})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}