qiskit/terra/terra_parallel_tools.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trust Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the Qiskit Terra parallel tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this tutorial we will see how to leverage the `parallel_map` routine in Qiskit Terra to execute functions in parallel, and track the progress of these parallel tasks using progress bars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-18T18:59:57.469931Z",
     "start_time": "2018-12-18T18:59:57.465314Z"
    }
   },
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "from qiskit.tools.parallel import parallel_map\n",
    "from qiskit.tools.events import TextProgressBar\n",
    "from qiskit.tools.jupyter import *  # Needed to load the Jupyter HTMLProgressBar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define a function that builds a single Quantum Volume circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we will construct a set of 1000 Quantum Volume circuits of width and depth 4.  For a technical discussion of Quantum Volume see: https://arxiv.org/abs/1811.12926."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-18T18:59:58.031719Z",
     "start_time": "2018-12-18T18:59:58.028761Z"
    }
   },
   "outputs": [],
   "source": [
    "num_circuits = 1000\n",
    "width = 4\n",
    "depth = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-18T18:59:58.194568Z",
     "start_time": "2018-12-18T18:59:58.190192Z"
    }
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "import math\n",
    "import numpy as np\n",
    "from qiskit.quantum_info.random import random_unitary \n",
    "from qiskit.quantum_info.synthesis import two_qubit_kak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In preparation for executing in parallel, the code below takes an index value, an array of random number seeds, and the width and depth of the circuit as inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-18T18:59:58.369775Z",
     "start_time": "2018-12-18T18:59:58.352565Z"
    }
   },
   "outputs": [],
   "source": [
    "def build_qv_circuit(idx, seeds, width, depth):\n",
    "    \"\"\"Builds a single Quantum Volume circuit.  Two circuits,\n",
    "    one with measurements, and one widthout, are returned.\n",
    "\n",
    "    The model circuits consist of layers of Haar random\n",
    "    elements of SU(4) applied between corresponding pairs\n",
    "    of qubits in a random bipartition.\n",
    "    \n",
    "    See: https://arxiv.org/abs/1811.12926\n",
    "    \"\"\"\n",
    "    np.random.seed(seeds[idx])\n",
    "    q = QuantumRegister(width, \"q\")\n",
    "    c = ClassicalRegister(width, \"c\")\n",
    "    # Create measurement subcircuit\n",
    "    qc = QuantumCircuit(q,c)\n",
    "    # For each layer\n",
    "    for j in range(depth):\n",
    "        # Generate uniformly random permutation Pj of [0...n-1]\n",
    "        perm = np.random.permutation(width)\n",
    "        # For each pair p in Pj, generate Haar random SU(4)\n",
    "        # Decompose each SU(4) into CNOT + SU(2) and add to Ci\n",
    "        for k in range(math.floor(width/2)):\n",
    "            qubits = [int(perm[2*k]), int(perm[2*k+1])]\n",
    "            U = random_unitary(4)            \n",
    "            for gate in two_qubit_kak(U):\n",
    "                gate_name = gate[0].name\n",
    "                gate_params = gate[0].params\n",
    "                # The first qubit argument used in gate\n",
    "                i0 = qubits[gate[1][0][1]]\n",
    "                if gate_name == \"cx\":\n",
    "                    # The second qubit argument used in gate\n",
    "                    i1 = qubits[gate[1][1][1]]\n",
    "                    qc.cx(q[i0], q[i1])\n",
    "                elif gate_name == \"u1\":\n",
    "                    qc.u1(gate_params[2], q[i0])\n",
    "                elif gate_name == \"u2\":\n",
    "                    qc.u2(gate_params[1], gate_params[2], q[i0])\n",
    "                elif gate_name == \"u3\":\n",
    "                    qc.u3(gate_params[0], gate_params[1], gate_params[2], q[i0])\n",
    "                elif gate_name == \"id\":\n",
    "                    pass  # do nothing\n",
    "    qc_no_meas = copy.deepcopy(qc)\n",
    "    # Create circuit with final measurement\n",
    "    qc.measure(q,c)\n",
    "    return qc, qc_no_meas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate 1000 circuits in parallel and track progress"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Becuase Quantum Volume circuits are generated randomly for the NumPy random number generator, we must be careful when running in parallel.  If the random number generator is not explicitly seeded, the computer uses the current time as a seed value.  When running in parallel, this can result in each process starting with the saem seed value, and thus not giving random results.  Here we generate all the random seed values needed, and pass this into `parallel_map` as a extra argument in `task_args`, along with `width` and `depth`.  The main function argument passed in `parallel_map` is just an array that indexes the processes and seed value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-18T19:09:08.823589Z",
     "start_time": "2018-12-18T19:08:50.977782Z"
    }
   },
   "outputs": [],
   "source": [
    "num_circuits = 1000\n",
    "seeds = np.random.randint(np.iinfo(np.int32).max, size=num_circuits)\n",
    "TextProgressBar()\n",
    "parallel_map(build_qv_circuit, np.arange(num_circuits), task_args=(seeds, width, depth));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use a Jupyter progress bar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-12-18T19:09:28.110746Z",
     "start_time": "2018-12-18T19:09:08.827393Z"
    }
   },
   "outputs": [],
   "source": [
    "seeds = np.random.randint(np.iinfo(np.int32).max, size=num_circuits)\n",
    "HTMLProgressBar()\n",
    "parallel_map(build_qv_circuit, np.arange(num_circuits), task_args=(seeds, width, depth));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.3"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "1713c602e9ef425da2cf15400606e746": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.4.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "17df8f5e122145149490b60b1f0dc669": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.1.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "19694dbcc4134bb7b2c6315d4e7a140c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.4.0",
      "model_name": "IntProgressModel",
      "state": {
       "bar_style": "success",
       "layout": "IPY_MODEL_17df8f5e122145149490b60b1f0dc669",
       "max": 1000,
       "style": "IPY_MODEL_3cf47c49236a4c57bb51ceadc9d61015",
       "value": 1000
      }
     },
     "3cf47c49236a4c57bb51ceadc9d61015": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.4.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "description_width": ""
      }
     },
     "a418fa8abae941139ad7c3284645d384": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.4.0",
      "model_name": "HTMLModel",
      "state": {
       "layout": "IPY_MODEL_fc49458f75e44afdafa273ff6454b4f2",
       "style": "IPY_MODEL_1713c602e9ef425da2cf15400606e746",
       "value": "Elapsed time:  19.27s"
      }
     },
     "b2c604af5610454081145422d0a0c8c0": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.1.0",
      "model_name": "LayoutModel",
      "state": {}
     },
     "bae2486dfd2f4ca4bbf84d185b6263c0": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.4.0",
      "model_name": "VBoxModel",
      "state": {
       "children": [
        "IPY_MODEL_a418fa8abae941139ad7c3284645d384",
        "IPY_MODEL_19694dbcc4134bb7b2c6315d4e7a140c"
       ],
       "layout": "IPY_MODEL_b2c604af5610454081145422d0a0c8c0"
      }
     },
     "fc49458f75e44afdafa273ff6454b4f2": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.1.0",
      "model_name": "LayoutModel",
      "state": {}
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}