docs/notebooks/qnlp-experiment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# qnlp-experiment\n",
    "In this mini-experiment, we will use the SPSA optimiser to learn the the parameters of a simple DisCoCat model. \n",
    "\n",
    "First, we generate some sentences using the vocabulary \"Alice\", \"loves\", \"Bob\", \"who\" and \"is rich\". By assigning the correct grammatical types to each word, DisCoPy will only generate grammatically correct sentences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from discopy import Ty, Word\n",
    "\n",
    "s, n = Ty('s'), Ty('n')\n",
    "Alice = Word('Alice', n)\n",
    "loves = Word('loves', n.r @ s @ n.l)\n",
    "Bob =  Word('Bob', n)\n",
    "who = Word('who', n.r @ n @ s.l @ n)\n",
    "is_rich = Word('is rich', n.r @ s)\n",
    "\n",
    "vocab = [Alice, loves, Bob, who, is_rich]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Brute force search for grammatical sentences:\n",
      "Alice is rich.\n",
      "Bob is rich.\n",
      "Alice loves Alice.\n",
      "Alice loves Bob.\n",
      "Bob loves Alice.\n",
      "Bob loves Bob.\n",
      "Alice who is rich is rich.\n",
      "Bob who is rich is rich.\n",
      "Alice who loves Alice is rich.\n",
      "Alice who loves Bob is rich.\n",
      "\n",
      "2.42 seconds to generate 10 sentences.\n"
     ]
    }
   ],
   "source": [
    "from time import time\n",
    "from discopy.grammar import brute_force\n",
    "\n",
    "gen, n_sentences = brute_force(*vocab), 10\n",
    "sentences, parsing = list(), dict()\n",
    "\n",
    "print(\"Brute force search for grammatical sentences:\")\n",
    "\n",
    "start = time()\n",
    "for i in range(n_sentences):\n",
    "    diagram = next(gen)\n",
    "    sentence = ' '.join(str(w)\n",
    "        for w in diagram.boxes if isinstance(w, Word)) + '.'\n",
    "    sentences.append(sentence)\n",
    "    parsing.update({sentence: diagram})\n",
    "    print(sentence)\n",
    "\n",
    "print(\"\\n{:.2f} seconds to generate {} sentences.\".format(time() - start, n_sentences))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Diagram for 'Alice who loves Bob is rich.':\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from discopy.grammar import draw\n",
    "print(\"Diagram for 'Alice who loves Bob is rich.':\")\n",
    "draw(parsing['Alice who loves Bob is rich.'], draw_type_labels=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we construct a `CircuitFunctor` which transforms the diagrams into quantum circuits. This involves providing a mapping from each grammatical type (e.g. `Ty('n')`, or `Ty('s')`) to the number of qubits, and a mapping from each DisCoPy box to a quantum circuit. For larger models, one can provide a function to `ob` and `ar` for the `Functor` constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circuit for the GHZ state, used as ansatz for \"who\":\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from discopy.quantum import Circuit, sqrt, Ket, H, Rx, CX, SWAP\n",
    "\n",
    "# Ansatz for words with type `n`, e.g. 'Alice', 'Bob'\n",
    "def intransitive_ansatz(phase):\n",
    "    return Ket(0) >> Rx(phase)\n",
    "\n",
    "# Ansatz for words with type `n.r @ s @ n.l`, e.g. 'loves'\n",
    "def transitive_ansatz(phase):\n",
    "    return sqrt(2) @ Ket(0, 0) >> H @ Rx(phase) >> CX\n",
    "\n",
    "GHZ = sqrt(2) @ Ket(0, 0, 0)\\\n",
    "    >> Circuit.id(1) @ H @ Circuit.id(1)\\\n",
    "    >> Circuit.id(1) @ CX\\\n",
    "    >> (SWAP >>  CX) @ Circuit.id(1)\n",
    "\n",
    "print(\"Circuit for the GHZ state, used as ansatz for \\\"who\\\":\")\n",
    "GHZ.draw(aspect='auto', draw_type_labels=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once we have defined the circuits for each box, we can define `F`, a function that takes a list of two parameters, and returns a `CircuitFunctor` which transforms a diagram into a circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circuit for 'Alice who loves Bob is rich.':\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from discopy import CircuitFunctor, qubit\n",
    "\n",
    "F = lambda params: CircuitFunctor(\n",
    "    ob={s: qubit ** 0, n: qubit ** 1},\n",
    "    ar={Alice: Ket(0),\n",
    "        loves: transitive_ansatz(params[0]),\n",
    "        Bob: Ket(1),\n",
    "        who: GHZ,\n",
    "        is_rich: intransitive_ansatz(params[1])})\n",
    "\n",
    "params0 = np.array([0.5, 1.0])\n",
    "print(\"Circuit for 'Alice who loves Bob is rich.':\")\n",
    "circuit = F(params0)(parsing['Alice who loves Bob is rich.'])\n",
    "circuit.draw(figsize=(10, 8), aspect='auto', draw_type_labels=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This circuit diagram can be exported to `pytket`, which can be used to compile circuits for many backends such as IBM's `qiskit`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<tket::Circuit, qubits=8, gates=24>:\n",
      "H q[1];\n",
      "H q[4];\n",
      "Rx(1) q[5];\n",
      "X q[6];\n",
      "Rx(2) q[7];\n",
      "CX q[1], q[3];\n",
      "CX q[4], q[5];\n",
      "CX q[1], q[2];\n",
      "CX q[3], q[4];\n",
      "CX q[5], q[6];\n",
      "Measure q[4] --> c[3];\n",
      "Measure q[6] --> c[5];\n",
      "CX q[0], q[1];\n",
      "CX q[2], q[7];\n",
      "H q[3];\n",
      "H q[5];\n",
      "Measure q[1] --> c[1];\n",
      "Measure q[3] --> c[2];\n",
      "Measure q[5] --> c[4];\n",
      "Measure q[7] --> c[7];\n",
      "H q[0];\n",
      "H q[2];\n",
      "Measure q[0] --> c[0];\n",
      "Measure q[2] --> c[6];\n",
      "\n",
      "post selection:\n",
      "{0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0}\n",
      "\n",
      "scalar:\n",
      "64.00000000000009\n",
      "\n",
      "qiskit circuit:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">                              ┌───┐                   ┌─┐   \n",
       "q_0: ──────────────────────■──┤ H ├───────────────────┤M├───\n",
       "       ┌───┐             ┌─┴─┐└───┘     ┌─┐           └╥┘   \n",
       "q_1: ──┤ H ├─────■────■──┤ X ├──────────┤M├────────────╫────\n",
       "       └───┘     │  ┌─┴─┐└───┘          └╥┘┌───┐       ║ ┌─┐\n",
       "q_2: ────────────┼──┤ X ├────────────■───╫─┤ H ├───────╫─┤M├\n",
       "               ┌─┴─┐└───┘┌───┐       │   ║ └┬─┬┘       ║ └╥┘\n",
       "q_3: ──────────┤ X ├──■──┤ H ├───────┼───╫──┤M├────────╫──╫─\n",
       "       ┌───┐   └───┘┌─┴─┐└┬─┬┘       │   ║  └╥┘        ║  ║ \n",
       "q_4: ──┤ H ├─────■──┤ X ├─┤M├────────┼───╫───╫─────────╫──╫─\n",
       "     ┌─┴───┴─┐ ┌─┴─┐└───┘ └╥┘ ┌───┐  │   ║   ║  ┌─┐    ║  ║ \n",
       "q_5: ┤ Rx(π) ├─┤ X ├──■────╫──┤ H ├──┼───╫───╫──┤M├────╫──╫─\n",
       "     └─┬───┬─┘ └───┘┌─┴─┐  ║  └┬─┬┘  │   ║   ║  └╥┘    ║  ║ \n",
       "q_6: ──┤ X ├────────┤ X ├──╫───┤M├───┼───╫───╫───╫─────╫──╫─\n",
       "     ┌─┴───┴──┐     └───┘  ║   └╥┘ ┌─┴─┐ ║   ║   ║ ┌─┐ ║  ║ \n",
       "q_7: ┤ Rx(2π) ├────────────╫────╫──┤ X ├─╫───╫───╫─┤M├─╫──╫─\n",
       "     └────────┘            ║    ║  └───┘ ║   ║   ║ └╥┘ ║  ║ \n",
       "c: 8/══════════════════════╩════╩════════╩═══╩═══╩══╩══╩══╩═\n",
       "                           3    5        1   2   4  7  0  6 </pre>"
      ],
      "text/plain": [
       "                              ┌───┐                   ┌─┐   \n",
       "q_0: ──────────────────────■──┤ H ├───────────────────┤M├───\n",
       "       ┌───┐             ┌─┴─┐└───┘     ┌─┐           └╥┘   \n",
       "q_1: ──┤ H ├─────■────■──┤ X ├──────────┤M├────────────╫────\n",
       "       └───┘     │  ┌─┴─┐└───┘          └╥┘┌───┐       ║ ┌─┐\n",
       "q_2: ────────────┼──┤ X ├────────────■───╫─┤ H ├───────╫─┤M├\n",
       "               ┌─┴─┐└───┘┌───┐       │   ║ └┬─┬┘       ║ └╥┘\n",
       "q_3: ──────────┤ X ├──■──┤ H ├───────┼───╫──┤M├────────╫──╫─\n",
       "       ┌───┐   └───┘┌─┴─┐└┬─┬┘       │   ║  └╥┘        ║  ║ \n",
       "q_4: ──┤ H ├─────■──┤ X ├─┤M├────────┼───╫───╫─────────╫──╫─\n",
       "     ┌─┴───┴─┐ ┌─┴─┐└───┘ └╥┘ ┌───┐  │   ║   ║  ┌─┐    ║  ║ \n",
       "q_5: ┤ Rx(π) ├─┤ X ├──■────╫──┤ H ├──┼───╫───╫──┤M├────╫──╫─\n",
       "     └─┬───┬─┘ └───┘┌─┴─┐  ║  └┬─┬┘  │   ║   ║  └╥┘    ║  ║ \n",
       "q_6: ──┤ X ├────────┤ X ├──╫───┤M├───┼───╫───╫───╫─────╫──╫─\n",
       "     ┌─┴───┴──┐     └───┘  ║   └╥┘ ┌─┴─┐ ║   ║   ║ ┌─┐ ║  ║ \n",
       "q_7: ┤ Rx(2π) ├────────────╫────╫──┤ X ├─╫───╫───╫─┤M├─╫──╫─\n",
       "     └────────┘            ║    ║  └───┘ ║   ║   ║ └╥┘ ║  ║ \n",
       "c: 8/══════════════════════╩════╩════════╩═══╩═══╩══╩══╩══╩═\n",
       "                           3    5        1   2   4  7  0  6 "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pytket.extensions.qiskit import tk_to_qiskit\n",
    "\n",
    "tk_circ = circuit.to_tk()\n",
    "print(\"{}:\\n{}\\n\".format(tk_circ, '\\n'.join(map(str, tk_circ))))\n",
    "print(\"post selection:\\n{}\\n\".format(tk_circ.post_selection))\n",
    "print(\"scalar:\\n{}\\n\".format(tk_circ.scalar))\n",
    "print(\"qiskit circuit:\")\n",
    "tk_to_qiskit(tk_circ).draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rest of this code follows a typical machine learning setup:\n",
    "1) Define an evaluation function to predict labels based on input\n",
    "2) Define a loss function to compare the predicted label with the actual label\n",
    "3) Use an optimiser to minimise the loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pytket.extensions.qiskit import AerBackend\n",
    "\n",
    "def evaluate(params, sentences, backend=AerBackend(), n_shots=2**10, seed=0):\n",
    "    circuits = [F(params)(parsing[s]) for s in sentences]\n",
    "    results = [Circuit.eval(\n",
    "                circuit,\n",
    "                backend=backend,\n",
    "                n_shots=n_shots,\n",
    "                seed=seed,\n",
    "                compilation=backend.default_compilation_pass(2)) for circuit in circuits]\n",
    "    tensors = [np.abs(result.array)[0] for result in results]\n",
    "    return tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.651 seconds to compute the corpus.\n",
      "\n",
      "True sentences:\n",
      "Alice is rich. (1.035)\n",
      "Alice loves Bob. (1.125)\n",
      "Bob loves Alice. (1.125)\n",
      "Alice who is rich is rich. (1.188)\n",
      "Alice who loves Bob is rich. (1.000)\n",
      "\n",
      "False sentences:\n",
      "Bob is rich. (0.000)\n",
      "Alice loves Alice. (0.000)\n",
      "Bob loves Bob. (0.000)\n",
      "Bob who is rich is rich. (0.000)\n",
      "Alice who loves Alice is rich. (0.000)\n",
      "\n",
      "Maybe sentences:\n",
      "\n"
     ]
    }
   ],
   "source": [
    "start = time()\n",
    "corpus = dict(zip(sentences, evaluate(params0, sentences, backend=AerBackend())))\n",
    "print(\"{:.3f} seconds to compute the corpus.\\n\".format(time() - start))\n",
    "\n",
    "delta = .01\n",
    "\n",
    "print(\"True sentences:\\n{}\\n\".format('\\n'.join(\"{} ({:.3f})\".format(sentence, scalar)\n",
    "    for sentence, scalar in corpus.items() if scalar > .5 + delta)))\n",
    "print(\"False sentences:\\n{}\\n\".format('\\n'.join(\"{} ({:.3f})\".format(sentence, scalar)\n",
    "    for sentence, scalar in corpus.items() if scalar < .5 - delta)))\n",
    "print(\"Maybe sentences:\\n{}\".format('\\n'.join(\"{} ({:.3f})\".format(sentence, scalar)\n",
    "    for sentence, scalar in corpus.items() if .5 - delta <= scalar <= .5 + delta)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set:\n",
      "Alice who is rich is rich.\n",
      "Bob is rich.\n",
      "Alice is rich.\n",
      "Alice loves Bob.\n",
      "Alice loves Alice.\n",
      "\n",
      "Testing set:\n",
      "Bob loves Bob.\n",
      "Alice who loves Alice is rich.\n",
      "Bob loves Alice.\n",
      "Alice who loves Bob is rich.\n",
      "Bob who is rich is rich.\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "sentence_train, sentence_test = train_test_split(sentences, test_size=0.5, random_state=237)\n",
    "\n",
    "print(\"Training set:\\n{}\\n\".format('\\n'.join(sentence_train)))\n",
    "print(\"Testing set:\\n{}\".format('\\n'.join(sentence_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss(params, sentences=sentence_train):\n",
    "    return - np.mean(np.array([\n",
    "        (corpus[sentence] - scalar) ** 2\n",
    "        for sentence, scalar in zip(sentences, evaluate(params, sentences))]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random initialisation: [0.2018591  0.83909858]\n",
      "\n",
      "Is Alice who loves Bob rich?\n",
      "No, she isn't.\n"
     ]
    }
   ],
   "source": [
    "from random import random, seed; seed(337)\n",
    "\n",
    "params = np.array([random(), random()])\n",
    "\n",
    "print(\"Random initialisation: {}\".format(params))\n",
    "\n",
    "print(\"\\nIs Alice who loves Bob rich?\")\n",
    "print(\"Yes, she is.\"\n",
    "      if evaluate(params, ['Alice who loves Bob is rich.'])[0] > .5 + delta\n",
    "      else \"No, she isn't.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 (1 seconds since start): [0.2018591  0.83909858]\n",
      "Epoch 2 (2 seconds since start): [0.23054751 0.81041017]\n",
      "Epoch 3 (3 seconds since start): [0.20449746 0.83646022]\n",
      "Epoch 4 (4 seconds since start): [0.22560398 0.8153537 ]\n",
      "Epoch 5 (5 seconds since start): [0.64483091 1.23458063]\n",
      "Epoch 6 (6 seconds since start): [0.80291994 1.07649159]\n",
      "Epoch 7 (7 seconds since start): [0.51403123 0.78760287]\n",
      "Epoch 8 (8 seconds since start): [0.28197057 1.01966353]\n",
      "Epoch 9 (9 seconds since start): [0.4553998 0.8462343]\n",
      "Epoch 10 (11 seconds since start): [0.30994817 0.99168593]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "     fun: -0.05175857543945319\n",
       " message: 'terminated after reaching max number of iterations'\n",
       "    nfev: 20\n",
       "     nit: 10\n",
       " success: True\n",
       "       x: array([0.30994817, 0.99168593])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import noisyopt\n",
    "\n",
    "i, start = 0, time()\n",
    "\n",
    "def callback(params):\n",
    "    global i\n",
    "    i += 1\n",
    "    print(\"Epoch {} ({:.0f} seconds since start): {}\".format(i, time() - start, params))\n",
    "\n",
    "result = noisyopt.minimizeSPSA(\n",
    "    loss, params, paired=False, callback=callback, niter=10, a=2)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing loss: -0.09707031250000017\n"
     ]
    }
   ],
   "source": [
    "print(\"Testing loss: {}\".format(loss(result.x, sentences=sentence_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is Alice who loves Bob rich?\n",
      "Yes, she is.\n"
     ]
    }
   ],
   "source": [
    "print(\"Is Alice who loves Bob rich?\")\n",
    "print(\"Yes, she is.\"\n",
    "      if evaluate(result.x, ['Alice who loves Bob is rich.'])[0] > .5 + delta\n",
    "      else \"No, she isn't.\")"
   ]
  }
 ],
 "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.8.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}