notebooks/GateSynthesis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img align=\"right\" src=\"https://i.imgur.com/WeHlFmr.gif\">\n",
    "\n",
    "# Quantum gate synthesis\n",
    "\n",
    "\n",
    "\n",
    "This notebook works through the process used to produce the gate synthesis results presented in [*\"Machine learning method for state preparation and gate synthesis on photonic quantum computers\"*](https://iopscience.iop.org/article/10.1088/2058-9565/aaf59e/pdf).\n",
    "\n",
    "We use the continuous-variable (CV) quantum optical circuit package [Strawberry Fields](https://github.com/XanaduAI/strawberryfields), and in particular its TensorFlow backend, to perform quantum circuit optimization. By leveraging Tensorflow, we have access to a number of additional funtionalities, including GPU integration, automatic gradient computation, built-in optimization algorithms, and other machine learning tools."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variational quantum circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A key element of machine learning is optimization. We can use Tensorflow’s automatic differentiation tools to optimize the parameters of variational quantum circuits constructed using Strawberry Fields. In this approach, we fix a circuit architecture where the states, gates, and/or measurements may have learnable parameters $\\vec{\\theta}$ associated with them. We then define a loss function based on the output state of this circuit. In this case, we define a loss function such that the action of the variational quantum circuit is close to some specified target unitary. For more details on the TensorFlow backend in Strawberry Fields, please see the [Strawberry Fields documentation](http://strawberryfields.readthedocs.io/en/stable/tutorials/tutorial_machine_learning.html).\n",
    "\n",
    "For arbitrary gate synthesis using optimization, we need to make use of a quantum circuit with a layer structure that is **universal** - that is, by 'stacking' the layers, we can guarantee that we can produce *any* CV state with at-most polynomial overhead. Therefore, the architecture we choose must consist of layers with each layer containing parameterized Gaussian *and* non-Gaussian gates. **The non-Gaussian gates provide both the nonlinearity and the universality of the model.** To this end, we employ the CV quantum neural network architecture described below:\n",
    "\n",
    "![layer](https://i.imgur.com/NEsaVIX.png)\n",
    "\n",
    "Here,\n",
    "\n",
    "\n",
    "* $\\mathcal{U}_i(\\theta_i,\\phi_i)$ is an N-mode linear optical interferometer composed of two-mode beamsplitters $BS(\\theta,\\phi)$ and single-mode rotation gates $R(\\phi)=e^{i\\phi\\hat{n}}$,\n",
    "\n",
    "* $\\mathcal{D}(\\alpha_i)$ are single mode displacements in the phase space by complex value $\\alpha_i$,\n",
    "\n",
    "* $\\mathcal{S}(r_i, \\phi_i)$ are single mode squeezing operations of magnitude $r_i$ and phase $\\phi_i$, and\n",
    "\n",
    "* $\\Phi(\\lambda_i)$ is a single mode non-Gaussian operation, in this case chosen to be the Kerr interaction $\\mathcal{K}(\\kappa_i)=e^{i\\kappa_i\\hat{n}^2}$ of strength $\\kappa_i$.\n",
    "\n",
    "<br/>\n",
    "\n",
    "<div class=\"alert alert-success\" style=\"border: 0px; border-left: 3px solid #119a68; color: black; background-color: #daf0e9\">\n",
    "<p style=\"color: #119a68;\"><strong>Reference</strong></p>Killoran, N., Bromley, T. R., Arrazola, J. M., Schuld, M., Quesada, N., & Lloyd, S. (2018). \"Continuous-variable quantum neural networks.\" <a href=https://arxiv.org/abs/1806.06871>arXiv:1806.06871</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters\n",
    "\n",
    "\n",
    "First, we must define the **hyperparameters** of our layer structure:\n",
    "\n",
    "* `cutoff`: the simulation Fock space truncation we will use in the optimization. The TensorFlow backend will perform numerical operations in this truncated Fock space when performing the optimization.\n",
    "\n",
    "\n",
    "* `depth`: The number of layer ansatz in our variational quantum circuit. As a general rule, increasing the number of layers (and thus, the number of parameters we are optimizing over) increases the optimizers chance of finding a reasonable local minimum in the optimization landscape.\n",
    "\n",
    "\n",
    "* `reps`: the number of steps in the optimization routine performing gradient descent\n",
    "\n",
    "Some other optional hyperparameters include:\n",
    "\n",
    "* The standard deviation of initial parameters. Note that we make a distinction between the standard deviation of *passive* parameters (those that preserve photon number when changed, such as phase parameters), and *active* parameters (those that introduce or remove energy from the system when changed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cutoff dimension\n",
    "cutoff = 10\n",
    "\n",
    "# gate cutoff\n",
    "gate_cutoff = 4\n",
    "\n",
    "# Number of layers\n",
    "depth = 25\n",
    "\n",
    "# Number of steps in optimization routine performing gradient descent\n",
    "reps = 1000\n",
    "\n",
    "# Standard deviation of initial parameters\n",
    "passive_sd = 0.1\n",
    "active_sd = 0.001"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, unlike in state learning, we must also specify a *gate cutoff* $d$. This restricts the target unitary to its action on a $d$-dimensional subspace of the truncated Fock space, where $d\\leq D$, where $D$ is the overall simulation Fock basis cutoff. As a result, we restrict the gate synthesis optimization to only $d$ input-output relations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The layer parameters $\\vec{\\theta}$\n",
    "\n",
    "We use TensorFlow to create the variables corresponding to the gate parameters. Note that each variable has shape `[depth]`, with each individual element representing the gate parameter in layer $i$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# squeeze gate\n",
    "sq_r = tf.Variable(tf.random_normal(shape=[depth], stddev=active_sd))\n",
    "sq_phi = tf.Variable(tf.random_normal(shape=[depth], stddev=passive_sd))\n",
    "\n",
    "# displacement gate\n",
    "d_r = tf.Variable(tf.random_normal(shape=[depth], stddev=active_sd))\n",
    "d_phi = tf.Variable(tf.random_normal(shape=[depth], stddev=passive_sd))\n",
    "\n",
    "# rotation gates\n",
    "r1 = tf.Variable(tf.random_normal(shape=[depth], stddev=passive_sd))\n",
    "r2 = tf.Variable(tf.random_normal(shape=[depth], stddev=passive_sd))\n",
    "\n",
    "# kerr gate\n",
    "kappa = tf.Variable(tf.random_normal(shape=[depth], stddev=active_sd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, we store the TensorFlow variables representing the parameters in a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = [r1, sq_r, sq_phi, r2, d_r, d_phi, kappa]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can create a function to define the $i$th layer, acting on qumode `q`. This allows us to simply call this function in a loop later on when we build our circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# layer architecture\n",
    "def layer(i, q):\n",
    "    Rgate(r1[i]) | q\n",
    "    Sgate(sq_r[i], sq_phi[i]) | q\n",
    "    Rgate(r2[i]) | q\n",
    "    Dgate(d_r[i], d_phi[i]) | q\n",
    "    Kgate(kappa[i]) | q\n",
    "    \n",
    "    return q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constructing the circuit\n",
    "\n",
    "Now that we have defined our gate parameters and our layer structure, we can import Strawberry Fields and construct our variational quantum circuit. Note that, to ensure the TensorFlow backend computes the circuit symbolically, we specify `eval=False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import strawberryfields as sf\n",
    "from strawberryfields.ops import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We must also specify the input states to the variational quantum circuit - these are the Fock state $\\ket{i}$, $i=0,\\dots,d$, allowing us to optimize the circuit parameters to learn the target unitary acting on all input Fock states within the $d$-dimensional subspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_ket = np.zeros([gate_cutoff, cutoff])\n",
    "np.fill_diagonal(in_ket, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start SF Program\n",
    "prog = sf.Program(1)\n",
    "\n",
    "# Apply circuit of layers with corresponding depth\n",
    "with prog.context as q:\n",
    "    Ket(in_ket) | q\n",
    "    for k in range(depth):\n",
    "        layer(k, q[0])\n",
    "\n",
    "# Run engine\n",
    "eng = sf.Engine(\"tf\", backend_options={\"cutoff_dim\": cutoff, \"batch_size\": gate_cutoff})\n",
    "state = eng.run(prog, run_options={\"eval\": False}).state\n",
    "ket = state.ket()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we use the `batch_size` argument to perform the optimization in parallel - each batch calculates the variational quantum circuit acting on a different input Fock state: $U(\\vec{\\theta})\\left|{n}\\right\\rangle$. \n",
    "\n",
    "Note that the output state vector is an unevaluated tensor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'ket:0' shape=(4, 10) dtype=complex64>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performing the optimization\n",
    "\n",
    "$\\newcommand{ket}[1]{\\left|#1\\right\\rangle}$ With the Strawberry Fields TensorFlow backend calculating the resulting state of the circuit symbolically, we can use TensorFlow to optimize the gate parameters to minimize the cost function we specify. With gate synthesis, we minimize the overlaps in the Fock basis between the target and learnt unitaries via the following cost function:\n",
    "\n",
    "$$C(\\vec{\\theta}) = \\frac{1}{d}\\sum_{i=0}^{d-1} \\left| \\langle i \\mid V^\\dagger U(\\vec{\\theta})\\mid 0\\rangle - 1\\right|$$\n",
    "\n",
    "where $V$ is the target unitary, $U(\\vec{\\theta})$ is the learnt unitary, and $d$ is the gate cutoff. Note that this is a generalization of state preparation to more than one input-output relation.\n",
    "\n",
    "For our target unitary, lets use Strawberry Fields to generate a 4x4 random unitary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from strawberryfields.utils import random_interferometer\n",
    "target_unitary = np.identity(cutoff, dtype=np.complex128)\n",
    "target_unitary[:gate_cutoff, :gate_cutoff] = random_interferometer(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This matches the gate cutoff of $d=4$ that we chose above when defining our hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using this target state, we calculate the cost function we would like to minimize. We must use TensorFlow functions to manipulate this data, as were are working with symbolic variables!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_state = np.arange(gate_cutoff)\n",
    "\n",
    "# extract action of the target unitary acting on\n",
    "# the allowed input fock states.\n",
    "target_kets = np.array([target_unitary[:, i] for i in in_state])\n",
    "target_kets = tf.constant(target_kets, dtype=tf.complex64)\n",
    "\n",
    "# overlaps\n",
    "overlaps = tf.real(tf.einsum('bi,bi->b', tf.conj(target_kets), ket))\n",
    "mean_overlap = tf.reduce_mean(overlaps)\n",
    "\n",
    "# cost\n",
    "cost = tf.reduce_sum(tf.abs(overlaps - 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the cost function is defined, we can define and run the optimization. Below, we choose the Adam optimizer that is built into TensorFlow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using Adam algorithm for optimization\n",
    "optimiser = tf.train.AdamOptimizer()\n",
    "min_cost = optimiser.minimize(cost)\n",
    "\n",
    "# Begin Tensorflow session\n",
    "session = tf.Session()\n",
    "session.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then loop over all repetitions, storing the best predicted fidelity value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rep: 0 Cost: 2.5749 Mean overlap: 0.3563\n",
      "Rep: 100 Cost: 0.5427 Mean overlap: 0.8643\n",
      "Rep: 200 Cost: 0.1412 Mean overlap: 0.9647\n",
      "Rep: 300 Cost: 0.0594 Mean overlap: 0.9851\n",
      "Rep: 400 Cost: 0.0360 Mean overlap: 0.9910\n",
      "Rep: 500 Cost: 0.0235 Mean overlap: 0.9941\n",
      "Rep: 600 Cost: 0.0168 Mean overlap: 0.9958\n",
      "Rep: 700 Cost: 0.0117 Mean overlap: 0.9971\n",
      "Rep: 800 Cost: 0.0079 Mean overlap: 0.9980\n",
      "Rep: 900 Cost: 0.0050 Mean overlap: 0.9988\n"
     ]
    }
   ],
   "source": [
    "overlap_progress = []\n",
    "cost_progress = []\n",
    "\n",
    "# Run optimization\n",
    "for i in range(reps):\n",
    "\n",
    "    # one repitition of the optimization\n",
    "    _, cost_val, overlaps_val, ket_val, params_val = session.run(\n",
    "        [min_cost, cost, overlaps, ket, params])\n",
    "    \n",
    "    # calculate the mean overlap\n",
    "    # This gives us an idea of how the optimization is progressing\n",
    "    mean_overlap_val = np.mean(overlaps_val)\n",
    "\n",
    "    # store cost at each step\n",
    "    cost_progress.append(cost_val)\n",
    "    overlap_progress.append(overlaps_val)\n",
    "\n",
    "    # Prints progress at every 100 reps\n",
    "    if i % 100 == 0:\n",
    "        # print progress\n",
    "        print(\"Rep: {} Cost: {:.4f} Mean overlap: {:.4f}\".format(i, cost_val, mean_overlap_val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results and visualisation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plotting the cost vs. optimization step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.rcParams['font.family'] = 'serif'\n",
    "plt.rcParams['font.sans-serif'] = ['Computer Modern Roman']\n",
    "plt.style.use('default')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f56e1bd6240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(cost_progress)\n",
    "plt.ylabel('Cost')\n",
    "plt.xlabel('Step');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use matrix plots to plot the real and imaginary components of the target and learnt unitary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "learnt_unitary = ket_val.T[:gate_cutoff, :gate_cutoff]\n",
    "target_unitary = target_unitary[:gate_cutoff, :gate_cutoff]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f56d973d780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 4, figsize=(7, 4))\n",
    "ax[0].matshow(target_unitary.real, cmap=plt.get_cmap('Reds'))\n",
    "ax[1].matshow(target_unitary.imag, cmap=plt.get_cmap('Greens'))\n",
    "ax[2].matshow(learnt_unitary.real, cmap=plt.get_cmap('Reds'))\n",
    "ax[3].matshow(learnt_unitary.imag, cmap=plt.get_cmap('Greens'))\n",
    "\n",
    "ax[0].set_xlabel(r'$\\mathrm{Re}(V)$')\n",
    "ax[1].set_xlabel(r'$\\mathrm{Im}(V)$')\n",
    "ax[2].set_xlabel(r'$\\mathrm{Re}(U)$')\n",
    "ax[3].set_xlabel(r'$\\mathrm{Im}(U)$');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Process fidelity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The process fidelity between the two unitaries is defined by\n",
    "\n",
    "$$F_e  = \\left| \\left\\langle \\Psi(V) \\mid \\Psi(U)\\right\\rangle\\right|^2$$\n",
    "\n",
    "where:\n",
    "\n",
    "* $\\left|\\Psi(V)\\right\\rangle$ is the action of $V$ on one\n",
    "half of a maximally entangled state $\\left|\\phi\\right\\rangle$:\n",
    "\n",
    "$$\\left|\\Psi(V)\\right\\rangle = (I\\otimes V)\\left|\\phi\\right\\rangle,$$\n",
    "\n",
    "\n",
    "* $V$ is the target unitary,\n",
    "* $U$ the learnt unitary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "I = np.identity(gate_cutoff)\n",
    "phi = I.flatten()/np.sqrt(gate_cutoff)\n",
    "psiV = np.kron(I, target_unitary) @ phi\n",
    "psiU = np.kron(I, learnt_unitary) @ phi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9983509433338348"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(np.vdot(psiV, psiU))**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, after 1000 repetitions, the learnt unitary synthesized via a variational quantum circuit has a process fidelity of 99.84% to the target unitary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1] Juan Miguel Arrazola, Thomas R. Bromley, Josh Izaac, Casey R. Myers, Kamil Brádler, and Nathan Killoran. *Machine learning method for state preparation and gate synthesis on photonic quantum computers.* [Quantum Science and Technology. 4 024004](https://iopscience.iop.org/article/10.1088/2058-9565/aaf59e/pdf), 2019.\n",
    "\n",
    "[2] Killoran, N., Bromley, T. R., Arrazola, J. M., Schuld, M., Quesada, N., & Lloyd, S. *Continuous-variable quantum neural networks.* <a href=https://arxiv.org/abs/1806.06871>arXiv:1806.06871</a>, 2018."
   ]
  }
 ],
 "metadata": {
  "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.6.0"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}