Zohim Chandani Task 1 QOSF .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "if (!(\"Notification\" in window)) {\n",
       "    alert(\"This browser does not support desktop notifications, so the %%notify magic will not work.\");\n",
       "} else if (Notification.permission !== 'granted' && Notification.permission !== 'denied') {\n",
       "    Notification.requestPermission(function (permission) {\n",
       "        if(!('permission' in Notification)) {\n",
       "            Notification.permission = permission;\n",
       "        }\n",
       "    })\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%load_ext jupyternotify\n",
    "import pennylane as qml \n",
    "from pennylane import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_wires = 4 #4 qubits \n",
    "\n",
    "dev = qml.device('default.qubit.tf', wires= n_wires)\n",
    "dev1 = qml.device('default.qubit.tf', wires= n_wires)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#geneate the random 4 qubit statevector phi \n",
    "@qml.qnode(dev, interface=\"tf\")\n",
    "def phi_circ(weights): \n",
    "    \n",
    "    for i in range(4):\n",
    "        \n",
    "        qml.RX(weights[i], wires=i)\n",
    "        qml.RY(weights[4+i], wires=i)\n",
    "        qml.RZ(weights[8+i], wires=i)\n",
    "    \n",
    "    return [qml.expval(qml.Identity(wires=i)) for i in range(n_wires)]\n",
    "\n",
    "\n",
    "random  = tf.constant( np.random.uniform(0, 2*np.pi, 12)  )\n",
    "phi_circ(random)\n",
    "phi = tf.dtypes.cast(dev.state, tf.complex128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#defined layer of odd and even blocks \n",
    "@qml.template\n",
    "def layer(weights, wires):\n",
    "    \n",
    "    for i in range(4):   \n",
    "        qml.RX(weights[i], wires=i)\n",
    "        \n",
    "    for i in range(4):    \n",
    "        qml.RZ(weights[4+i], wires=i)\n",
    "    \n",
    "    qml.CZ(wires=[0,1])\n",
    "    qml.CZ(wires=[0,2])\n",
    "    qml.CZ(wires=[0,3])\n",
    "    qml.CZ(wires=[1,2])\n",
    "    qml.CZ(wires=[1,3])\n",
    "    qml.CZ(wires=[2,3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#make a qnode with the number of layers as a varying parameter \n",
    "#this generates the 4 qubit statevector psi \n",
    "\n",
    "@qml.qnode(dev1, interface=\"tf\")    \n",
    "def psi_circ(thetas): \n",
    "\n",
    "    for i in range(n_layers):\n",
    "        layer(weights = thetas, wires= range(n_wires) )\n",
    "\n",
    "    return [qml.expval(qml.Identity(wires=i)) for i in range(n_wires)]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define the loss function which is to be minimised \n",
    "def eplison(thetas):\n",
    "    \n",
    "    psi_circ(thetas)\n",
    "    psi = dev1.state\n",
    "    \n",
    "    e = tf.math.sqrt(tf.tensordot(tf.math.conj(psi - phi), psi - phi, axes=1))\n",
    "    \n",
    "    return tf.math.real(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Eplison')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "$(document).ready(\n",
       "    function() {\n",
       "        function appendUniqueDiv(){\n",
       "            // append a div with our uuid so we can check that it's already\n",
       "            // been sent and avoid duplicates on page reload\n",
       "            var notifiedDiv = document.createElement(\"div\")\n",
       "            notifiedDiv.id = \"ccff2c66-1c1c-4fee-a4fc-1461fd7b32e2\"\n",
       "            element.append(notifiedDiv)\n",
       "        }\n",
       "\n",
       "        // only send notifications if the pageload is complete; this will\n",
       "        // help stop extra notifications when a saved notebook is loaded,\n",
       "        // which during testing gives us state \"interactive\", not \"complete\"\n",
       "        if (document.readyState === 'complete') {\n",
       "            // check for the div that signifies that the notification\n",
       "            // was already sent\n",
       "            if (document.getElementById(\"ccff2c66-1c1c-4fee-a4fc-1461fd7b32e2\") === null) {\n",
       "                var notificationPayload = {\"requireInteraction\": false, \"icon\": \"/static/base/images/favicon.ico\", \"body\": \"Cell execution has finished!\"};\n",
       "                if (Notification.permission !== 'denied') {\n",
       "                    if (Notification.permission !== 'granted') { \n",
       "                        Notification.requestPermission(function (permission) {\n",
       "                            if(!('permission' in Notification)) {\n",
       "                                Notification.permission = permission\n",
       "                            }\n",
       "                        })\n",
       "                    }\n",
       "                    if (Notification.permission === 'granted') {\n",
       "                    var notification = new Notification(\"Jupyter Notebook\", notificationPayload)\n",
       "                    appendUniqueDiv()\n",
       "                    notification.onclick = function () {\n",
       "                        window.focus();\n",
       "                        this.close();\n",
       "                        };\n",
       "                    } \n",
       "                }     \n",
       "            }\n",
       "        }\n",
       "    }\n",
       ")\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 10min 4s, sys: 214 ms, total: 10min 5s\n",
      "Wall time: 10min 4s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%notify\n",
    "\n",
    "#answer to task 1\n",
    "\n",
    "opt = tf.keras.optimizers.Adam(learning_rate=0.001)\n",
    "\n",
    "e = [] #minimum eplison \n",
    "\n",
    "#change the number of layers in each iteration \n",
    "for k in range(10):\n",
    "    n_layers = k+1\n",
    "\n",
    "    init_thetas = np.random.uniform(0, 2*np.pi, 8*n_layers)\n",
    "    thetas = tf.Variable(init_thetas)\n",
    "\n",
    "    eplison(thetas)\n",
    "\n",
    "    diff_in_cost = [0,1] #initialise array with dummy values to start while loop \n",
    "\n",
    "    i = 0 \n",
    "    while abs(diff_in_cost[i+1] - diff_in_cost[i]) > 1e-4: #continue to minimise the loss until the difference between successive values is > 10^(-4)\n",
    "\n",
    "        cost = lambda: eplison(thetas)\n",
    "        opt.minimize(cost, thetas)\n",
    "        diff_in_cost.append(cost().numpy())\n",
    "        i += 1\n",
    "\n",
    "    e.append(diff_in_cost[-1])\n",
    "     \n",
    "        \n",
    "\n",
    "fig, (ax1) = plt.subplots(1, 1, figsize=(10,5))\n",
    "\n",
    "y = e\n",
    "x =list(range(1, len(y)+1))\n",
    "\n",
    "ax1.plot(x,y)\n",
    "\n",
    "ax1.set_xlabel('Number of layers')\n",
    "ax1.set_ylabel('Eplison')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#bonus task - one could also define a layer with other gates to compare results \n",
    "#below is a layer with different gates\n",
    "\n",
    "@qml.template\n",
    "def bonus_layer(weights, wires):\n",
    "    \n",
    "    for i in range(4):   \n",
    "        qml.RY(weights[i], wires=i)\n",
    "        \n",
    "    for i in range(4):    \n",
    "        qml.RX(weights[4+i], wires=i)\n",
    "    \n",
    "    qml.CNOT(wires=[0,1])\n",
    "    qml.CNOT(wires=[0,2])\n",
    "    qml.CNOT(wires=[0,3])\n",
    "    qml.CNOT(wires=[1,2])\n",
    "    qml.CNOT(wires=[1,3])\n",
    "    qml.CNOT(wires=[2,3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "%%notify\n",
    "\n",
    "#code to check which optimiser to use\n",
    "#I used a hard search method by cycling over all optimisers to check for one which outputs sensible results \n",
    "\n",
    "opt_list = [ tf.keras.optimizers.Adadelta(learning_rate=0.001), \n",
    "            tf.keras.optimizers.Adagrad(learning_rate=0.001), \n",
    "            tf.keras.optimizers.Adam(learning_rate=0.001), \n",
    "            tf.keras.optimizers.Adamax(learning_rate=0.001), \n",
    "            tf.keras.optimizers.Ftrl(learning_rate=0.001), \n",
    "            tf.keras.optimizers.Nadam(learning_rate=0.001), \n",
    "            tf.keras.optimizers.SGD(learning_rate=0.001), \n",
    "            tf.keras.optimizers.RMSprop(learning_rate=0.001)]\n",
    "\n",
    "for opt in opt_list:\n",
    "   \n",
    "\n",
    "    e = [] #minimum eplison \n",
    "\n",
    "    #iteratively change the number of layers \n",
    "    for k in range(5):\n",
    "        n_layers = k+1\n",
    "\n",
    "        init_thetas = np.random.uniform(0, 2*np.pi, 8*n_layers)\n",
    "        thetas = tf.Variable(init_thetas)\n",
    "\n",
    "        eplison(thetas)\n",
    "\n",
    "        diff_in_cost = [0,1]\n",
    "\n",
    "        i = 0 \n",
    "        while abs(diff_in_cost[i+1] - diff_in_cost[i]) > 1e-4: #continue to minimise the loss until the difference between successive values is > 10^(-4)\n",
    "\n",
    "            cost = lambda: eplison(thetas)\n",
    "            opt.minimize(cost, thetas)\n",
    "            diff_in_cost.append(cost().numpy())\n",
    "            i += 1\n",
    "\n",
    "        e.append(diff_in_cost[-1])\n",
    "\n",
    "\n",
    "    fig, (ax1) = plt.subplots(1, 1, figsize=(10,5))\n",
    "\n",
    "    y = e\n",
    "    x =list(range(1, len(y)+1))\n",
    "\n",
    "\n",
    "    ax1.plot(x,y)\n",
    "\n",
    "    ax1.set_xlabel('Number of layers')\n",
    "    ax1.set_ylabel('Eplison')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}