Quantum_GRNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.2"
    },
    "colab": {
      "name": "Quantum GRNN.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/abhilash1910/EuroPython-21-QuantumDeepLearning/blob/master/Quantum_GRNN.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TFMD1nlwsJdf"
      },
      "source": [
        "# This cell is added by sphinx-gallery\n",
        "# It can be customized to whatever you like\n",
        "%matplotlib inline\n",
        "!pip install pennylane"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1JEoP1mpsJdh"
      },
      "source": [
        "The Quantum Graph Recurrent Neural Network\n",
        "==========================================\n",
        "\n",
        "This demonstration has been taken from [Pennylane](https://pennylane.ai/qml/demos/tutorial_qgrnn.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aHMUX6VOsJdi"
      },
      "source": [
        "This demonstration investigates quantum graph recurrent neural networks\n",
        "(QGRNN), which are the quantum analogue of a classical graph recurrent\n",
        "neural network, and a subclass of the more general quantum graph neural\n",
        "network ansatz. Both the QGNN and QGRNN were introduced in [this paper\n",
        "(2019)](https://arxiv.org/abs/1909.12264).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvqWKV7NsJdi"
      },
      "source": [
        "The Idea\n",
        "========\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJZb0i8xsJdj"
      },
      "source": [
        "A graph is defined as a set of *nodes* along with a set of **edges**,\n",
        "which represent connections between nodes. Information can be encoded\n",
        "into graphs by assigning numbers to nodes and edges, which we call\n",
        "**weights**. It is usually convenient to think of a graph visually:\n",
        "\n",
        "![image](../demonstrations/qgrnn/graph.png){width=\"70%\"}\n",
        "\n",
        "In recent years, the concept of a [graph neural\n",
        "network](https://arxiv.org/abs/1812.08434) (GNN) has been receiving a\n",
        "lot of attention from the machine learning community. A GNN seeks to\n",
        "learn a representation (a mapping of data into a low-dimensional vector\n",
        "space) of a given graph with feature vectors assigned to nodes and\n",
        "edges. Each of the vectors in the learned representation preserves not\n",
        "only the features, but also the overall topology of the graph, i.e.,\n",
        "which nodes are connected by edges. The quantum graph neural network\n",
        "attempts to do something similar, but for features that are\n",
        "quantum-mechanical; for instance, a collection of quantum states.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l2GUQ_2hsJdj"
      },
      "source": [
        "Consider the class of qubit Hamiltonians that are *quadratic*, meaning\n",
        "that the terms of the Hamiltonian represent either interactions between\n",
        "two qubits, or the energy of individual qubits. This class of\n",
        "Hamiltonians is naturally described by graphs, with second-order terms\n",
        "between qubits corresponding to weighted edges between nodes, and\n",
        "first-order terms corresponding to node weights.\n",
        "\n",
        "A well known example of a quadratic Hamiltonian is the transverse-field\n",
        "Ising model, which is defined as\n",
        "\n",
        "$$\\hat{H}_{\\text{Ising}}(\\boldsymbol\\theta) \\ = \\ \\displaystyle\\sum_{(i, j) \\in E}\n",
        "\\theta_{ij}^{(1)} Z_{i} Z_{j} \\ + \\ \\displaystyle\\sum_{i} \\theta_{i}^{(2)} Z_{i} \\ + \\\n",
        "\\displaystyle\\sum_{i} X_{i},$$\n",
        "\n",
        "where $\\boldsymbol\\theta \\ = \\ \\{\\theta^{(1)}, \\ \\theta^{(2)}\\}$. In\n",
        "this Hamiltonian, the set $E$ that determines which pairs of qubits have\n",
        "$ZZ$ interactions can be represented by the set of edges for some graph.\n",
        "With the qubits as nodes, this graph is called the *interaction graph*.\n",
        "The $\\theta^{(1)}$ parameters correspond to the edge weights and the\n",
        "$\\theta^{(2)}$ parameters correspond to weights on the nodes.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HgbD3VyvsJdk"
      },
      "source": [
        "This result implies that we can think about *quantum circuits* with\n",
        "graph-theoretic properties. Recall that the time-evolution operator with\n",
        "respect to some Hamiltonian $H$ is defined as:\n",
        "\n",
        "$$U \\ = \\ e^{-it H}.$$\n",
        "\n",
        "Thus, we have a clean way of taking quadratic Hamiltonians and turning\n",
        "them into unitaries (quantum circuits) that preserve the same\n",
        "correspondance to a graph. In the case of the Ising Hamiltonian, we\n",
        "have:\n",
        "\n",
        "$$U_{\\text{Ising}} \\ = \\ e^{-it \\hat{H}_{\\text{Ising}} (\\boldsymbol\\theta)} \\ = \\ \\exp \\Big[ -it\n",
        "\\Big( \\displaystyle\\sum_{(i, j) \\in E} \\theta_{ij}^{(1)} Z_{i} Z_{j} \\ + \\\n",
        "\\displaystyle\\sum_{i} \\theta_{i}^{(2)} Z_{i} \\ + \\ \\displaystyle\\sum_{i} X_{i} \\Big) \\Big]$$\n",
        "\n",
        "In general, this kind of unitary is very difficult to implement on a\n",
        "quantum computer. However, we can approximate it using the\n",
        "[Trotter-Suzuki\n",
        "decomposition](https://en.wikipedia.org/wiki/Time-evolving_block_decimation#The_Suzuki-Trotter_expansion):\n",
        "\n",
        "$$\\exp \\Big[ -it \\Big( \\displaystyle\\sum_{(i, j) \\in E} \\theta_{ij}^{(1)} Z_{i} Z_{j} \\ + \\\n",
        "\\displaystyle\\sum_{i} \\theta_{i}^{(2)} Z_{i} \\ + \\ \\displaystyle\\sum_{i} X_{i} \\Big) \\Big]\n",
        "\\ \\approx \\ \\displaystyle\\prod_{k \\ = \\ 1}^{t / \\Delta} \\Bigg[ \\displaystyle\\prod_{j \\ = \\\n",
        "1}^{Q} e^{-i \\Delta \\hat{H}_{\\text{Ising}}^{j}(\\boldsymbol\\theta)} \\Bigg]$$\n",
        "\n",
        "where $\\hat{H}_{\\text{Ising}}^{j}(\\boldsymbol\\theta)$ is the $j$-th term\n",
        "of the Ising Hamiltonian and $\\Delta$ is some small number.\n",
        "\n",
        "This circuit is a specific instance of the **Quantum Graph Recurrent\n",
        "Neural Network**, which in general is defined as a variational ansatz of\n",
        "the form\n",
        "\n",
        "$$U_{H}(\\boldsymbol\\mu, \\ \\boldsymbol\\gamma) \\ = \\ \\displaystyle\\prod_{i \\ = \\ 1}^{P} \\Bigg[\n",
        "\\displaystyle\\prod_{j \\ = \\ 1}^{Q} e^{-i \\gamma_j H^{j}(\\boldsymbol\\mu)} \\Bigg],$$\n",
        "\n",
        "for some parametrized quadratic Hamiltonian, $H(\\boldsymbol\\mu)$.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RuETMrm6sJdk"
      },
      "source": [
        "Using the QGRNN\n",
        "===============\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e1Rh9GsysJdl"
      },
      "source": [
        "Since the QGRNN ansatz is equivalent to the approximate time evolution\n",
        "of some quadratic Hamiltonian, we can use it to learn the dynamics of a\n",
        "quantum system.\n",
        "\n",
        "Continuing with the Ising model example, let's imagine we have some\n",
        "system governed by $\\hat{H}_{\\text{Ising}}(\\boldsymbol\\alpha)$ for an\n",
        "unknown set of target parameters, $\\boldsymbol\\alpha$ and an unknown\n",
        "interaction graph $G$. Let's also suppose we have access to copies of\n",
        "some low-energy, non-ground state of the target Hamiltonian,\n",
        "$|\\psi_0\\rangle$. In addition, we have access to a collection of\n",
        "time-evolved states,\n",
        "$\\{ |\\psi(t_1)\\rangle, \\ |\\psi(t_2)\\rangle, \\ ..., \\ |\\psi(t_N)\\rangle \\}$,\n",
        "defined by:\n",
        "\n",
        "$$|\\psi(t_k)\\rangle \\ = \\ e^{-i t_k \\hat{H}_{\\text{Ising}}(\\boldsymbol\\alpha)} |\\psi_0\\rangle.$$\n",
        "\n",
        "We call the low-energy states and the collection of time-evolved states\n",
        "*quantum data*. From here, we randomly pick a number of time-evolved\n",
        "states from our collection. For any state that we choose, which is\n",
        "evolved to some time $t_k$, we compare it to\n",
        "\n",
        "$$U_{\\hat{H}_{\\text{Ising}}}(\\boldsymbol\\mu, \\ \\Delta) |\\psi_0\\rangle \\ \\approx \\ e^{-i t_k\n",
        "\\hat{H}_{\\text{Ising}}(\\boldsymbol\\mu)} |\\psi_0\\rangle.$$\n",
        "\n",
        "This is done by feeding one of the copies of $|\\psi_0\\rangle$ into a\n",
        "quantum circuit with the QGRNN ansatz, with some guessed set of\n",
        "parameters $\\boldsymbol\\mu$ and a guessed interaction graph, $G'$. We\n",
        "then use a classical optimizer to maximize the average \"similarity\"\n",
        "between the time-evolved states and the states prepared with the QGRNN.\n",
        "\n",
        "As the QGRNN states becomes more similar to each time-evolved state for\n",
        "each sampled time, it follows that\n",
        "$\\boldsymbol\\mu \\ \\rightarrow \\ \\boldsymbol\\alpha$ and we are able to\n",
        "learn the unknown parameters of the Hamiltonian.\n",
        "\n",
        "![A visual representation of one execution of the QGRNN for one piece of\n",
        "quantum data.](../demonstrations/qgrnn/qgrnn3.png){width=\"90%\"}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IBbatsCBsJdm"
      },
      "source": [
        "Learning an Ising Model with the QGRNN\n",
        "======================================\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xENcMoBjsJdm"
      },
      "source": [
        "We now attempt to use the QGRNN to learn the parameters corresponding to\n",
        "an arbitrary transverse-field Ising model Hamiltonian.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yxbmKL-tsJdm"
      },
      "source": [
        "Getting Started\n",
        "===============\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CnbPsFyasJdn"
      },
      "source": [
        "We begin by importing the necessary dependencies:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uuehIbfOsJdn"
      },
      "source": [
        "import pennylane as qml\n",
        "from matplotlib import pyplot as plt\n",
        "import numpy as np\n",
        "import scipy\n",
        "import networkx as nx\n",
        "import copy"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MypxeU_XsJdn"
      },
      "source": [
        "We also define some fixed values that are used throughout the\n",
        "simulation.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Si69i3OvsJdn"
      },
      "source": [
        "qubit_number = 4\n",
        "qubits = range(qubit_number)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vx94ua-JsJdn"
      },
      "source": [
        "In this simulation, we don't have quantum data readily available to pass\n",
        "into the QGRNN, so we have to generate it ourselves. To do this, we must\n",
        "have knowledge of the target interaction graph and the target\n",
        "Hamiltonian.\n",
        "\n",
        "Let us use the following cyclic graph as the target interaction graph of\n",
        "the Ising Hamiltonian:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "S3VZ5xiisJdo",
        "outputId": "1958ced1-feb5-43aa-fe10-a636ece1097e"
      },
      "source": [
        "ising_graph = nx.cycle_graph(qubit_number)\n",
        "\n",
        "print(f\"Edges: {ising_graph.edges}\")\n",
        "nx.draw(ising_graph)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Edges: [(0, 1), (0, 3), (1, 2), (2, 3)]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VhnOmGyrsJdo"
      },
      "source": [
        "We can then initialize the “unknown” target parameters that describe the\n",
        "target Hamiltonian,\n",
        "$\\boldsymbol\\alpha \\ = \\ \\{\\alpha^{(1)}, \\ \\alpha^{(2)}\\}$. Recall from\n",
        "the introduction that we have defined our parametrized Ising Hamiltonian\n",
        "to be of the form:\n",
        "\n",
        "$$\\hat{H}_{\\text{Ising}}(\\boldsymbol\\theta) \\ = \\ \\displaystyle\\sum_{(i, j) \\in E}\n",
        "\\theta_{ij}^{(1)} Z_{i} Z_{j} \\ + \\ \\displaystyle\\sum_{i} \\theta_{i}^{(2)} Z_{i} \\ + \\\n",
        "\\displaystyle\\sum_{i} X_{i},$$\n",
        "\n",
        "where $E$ is the set of edges in the interaction graph, and $X_i$ and\n",
        "$Z_i$ are the Pauli-X and Pauli-Z on the $i$-th qubit.\n",
        "\n",
        "For this tutorial, we choose the target parameters by sampling from a\n",
        "uniform probability distribution ranging from $-2$ to $2$, with\n",
        "two-decimal precision.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RAUYVp-isJdo"
      },
      "source": [
        "target_weights = [0.56, 1.24, 1.67, -0.79]\n",
        "target_bias = [-1.44, -1.43, 1.18, -0.93]"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZpiiuvqMsJdo"
      },
      "source": [
        "In theory, these parameters can be any value we want, provided they are\n",
        "reasonably small enough that the QGRNN can reach them in a tractable\n",
        "number of optimization steps. In `matrix_params`, the first list\n",
        "represents the $ZZ$ interaction parameters and the second list\n",
        "represents the single-qubit $Z$ parameters.\n",
        "\n",
        "Finally, we use this information to generate the matrix form of the\n",
        "Ising model Hamiltonian in the computational basis:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 275
        },
        "id": "huHp1MtGsJdo",
        "outputId": "244f7398-9172-4701-8541-5a274a34813b"
      },
      "source": [
        "def create_hamiltonian_matrix(n_qubits, graph, weights, bias):\n",
        "\n",
        "    full_matrix = np.zeros((2 ** n_qubits, 2 ** n_qubits))\n",
        "\n",
        "    # Creates the interaction component of the Hamiltonian\n",
        "    for i, edge in enumerate(graph.edges):\n",
        "        interaction_term = 1\n",
        "        for qubit in range(0, n_qubits):\n",
        "            if qubit in edge:\n",
        "                interaction_term = np.kron(interaction_term, qml.PauliZ.matrix)\n",
        "            else:\n",
        "                interaction_term = np.kron(interaction_term, np.identity(2))\n",
        "        full_matrix += weights[i] * interaction_term\n",
        "\n",
        "    # Creates the bias components of the matrix\n",
        "    for i in range(0, n_qubits):\n",
        "        z_term = x_term = 1\n",
        "        for j in range(0, n_qubits):\n",
        "            if j == i:\n",
        "                z_term = np.kron(z_term, qml.PauliZ.matrix)\n",
        "                x_term = np.kron(x_term, qml.PauliX.matrix)\n",
        "            else:\n",
        "                z_term = np.kron(z_term, np.identity(2))\n",
        "                x_term = np.kron(x_term, np.identity(2))\n",
        "        full_matrix += bias[i] * z_term + x_term\n",
        "\n",
        "    return full_matrix\n",
        "\n",
        "\n",
        "# Prints a visual representation of the Hamiltonian matrix\n",
        "ham_matrix = create_hamiltonian_matrix(qubit_number, ising_graph, target_weights, target_bias)\n",
        "plt.matshow(ham_matrix, cmap=\"hot\")\n",
        "plt.show()"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z5_wGwRPsJdp"
      },
      "source": [
        "Preparing Quantum Data\n",
        "======================\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5wssKChVsJdp"
      },
      "source": [
        "The collection of quantum data needed to run the QGRNN has two\n",
        "components: (i) copies of a low-energy state, and (ii) a collection of\n",
        "time-evolved states, each of which are simply the low-energy state\n",
        "evolved to different times. The following is a low-energy state of the\n",
        "target Hamiltonian:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZnFwudbTsJdp"
      },
      "source": [
        "low_energy_state = [\n",
        "    (-0.054661080280306085 + 0.016713907320174026j),\n",
        "    (0.12290003656489545 - 0.03758500591109822j),\n",
        "    (0.3649337966440005 - 0.11158863596657455j),\n",
        "    (-0.8205175732627094 + 0.25093231967092877j),\n",
        "    (0.010369790825776609 - 0.0031706387262686003j),\n",
        "    (-0.02331544978544721 + 0.007129899300113728j),\n",
        "    (-0.06923183949694546 + 0.0211684344103713j),\n",
        "    (0.15566094863283836 - 0.04760201916285508j),\n",
        "    (0.014520590919500158 - 0.004441887836078486j),\n",
        "    (-0.032648113364535575 + 0.009988590222879195j),\n",
        "    (-0.09694382811137187 + 0.02965579457620536j),\n",
        "    (0.21796861485652747 - 0.06668776658411019j),\n",
        "    (-0.0027547112135013247 + 0.0008426289322652901j),\n",
        "    (0.006193695872468649 - 0.0018948418969390599j),\n",
        "    (0.018391279795405405 - 0.005625722994009138j),\n",
        "    (-0.041350974715649635 + 0.012650711602265649j),\n",
        "]"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2jJTk87-sJdp"
      },
      "source": [
        "This state can be obtained by using a decoupled version of the\n",
        "Variational Quantum Eigensolver &lt;/demos/tutorial\\_vqe&gt; algorithm\n",
        "(VQE). Essentially, we choose a VQE ansatz such that the circuit cannot\n",
        "learn the exact ground state, but it can get fairly close. Another way\n",
        "to arrive at the same result is to perform VQE with a reasonable ansatz,\n",
        "but to terminate the algorithm before it converges to the ground state.\n",
        "If we used the exact ground state $|\\psi_0\\rangle$, the time-dependence\n",
        "would be trivial and the data would not provide enough information about\n",
        "the Hamiltonian parameters.\n",
        "\n",
        "We can verify that this is a low-energy state by numerically finding the\n",
        "lowest eigenvalue of the Hamiltonian and comparing it to the energy\n",
        "expectation of this low-energy state:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9qMphnvjsJdq",
        "outputId": "84c9438c-5823-483c-cf6c-85e97fbfcc00"
      },
      "source": [
        "res = np.vdot(low_energy_state, (ham_matrix @ low_energy_state))\n",
        "energy_exp = np.real_if_close(res)\n",
        "print(f\"Energy Expectation: {energy_exp}\")\n",
        "\n",
        "\n",
        "ground_state_energy = np.real_if_close(min(np.linalg.eig(ham_matrix)[0]))\n",
        "print(f\"Ground State Energy: {ground_state_energy}\")"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Energy Expectation: -7.244508985189116\n",
            "Ground State Energy: -7.330689661291249\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r1ZhzMx1sJdq"
      },
      "source": [
        "We have in fact found a low-energy, non-ground state, as the energy\n",
        "expectation is slightly greater than the energy of the true ground\n",
        "state. This, however, is only half of the information we need. We also\n",
        "require a collection of time-evolved, low-energy states. Evolving the\n",
        "low-energy state forward in time is fairly straightforward: all we have\n",
        "to do is multiply the initial state by a time-evolution unitary. This\n",
        "operation can be defined as a custom gate in PennyLane:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wVhvM3absJdq"
      },
      "source": [
        "def state_evolve(hamiltonian, qubits, time):\n",
        "\n",
        "    U = scipy.linalg.expm(-1j * hamiltonian * time)\n",
        "    qml.QubitUnitary(U, wires=qubits)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "so0VYnBbsJdq"
      },
      "source": [
        "We don't actually generate time-evolved quantum data quite yet, but we\n",
        "now have all the pieces required for its preparation.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GXC3wsuVsJdq"
      },
      "source": [
        "Learning the Hamiltonian\n",
        "========================\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pn0HF22vsJdr"
      },
      "source": [
        "With the quantum data defined, we are able to construct the QGRNN and\n",
        "learn the target Hamiltonian. Each of the exponentiated Hamiltonians in\n",
        "the QGRNN ansatz, $\\hat{H}^{j}_{\\text{Ising}}(\\boldsymbol\\mu)$, are the\n",
        "$ZZ$, $Z$, and $X$ terms from the Ising Hamiltonian. This gives:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3dnfWW6dsJdr"
      },
      "source": [
        "def qgrnn_layer(weights, bias, qubits, graph, trotter_step):\n",
        "\n",
        "    # Applies a layer of RZZ gates (based on a graph)\n",
        "    for i, edge in enumerate(graph.edges):\n",
        "        qml.MultiRZ(2 * weights[i] * trotter_step, wires=(edge[0], edge[1]))\n",
        "\n",
        "    # Applies a layer of RZ gates\n",
        "    for i, qubit in enumerate(qubits):\n",
        "        qml.RZ(2 * bias[i] * trotter_step, wires=qubit)\n",
        "\n",
        "    # Applies a layer of RX gates\n",
        "    for qubit in qubits:\n",
        "        qml.RX(2 * trotter_step, wires=qubit)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OvATwkbGsJdr"
      },
      "source": [
        "As was mentioned in the first section, the QGRNN has two registers. In\n",
        "one register, some piece of quantum data $|\\psi(t)\\rangle$ is prepared\n",
        "and in the other we have\n",
        "$U_{H}(\\boldsymbol\\mu, \\ \\Delta) |\\psi_0\\rangle$. We need a way to\n",
        "measure the similarity between these states. This can be done by using\n",
        "the fidelity, which is simply the modulus squared of the inner product\n",
        "between the states,\n",
        "$| \\langle \\psi(t) | U_{H}(\\Delta, \\ \\boldsymbol\\mu) |\\psi_0\\rangle |^2$.\n",
        "To calculate this value, we use a [SWAP\n",
        "test](https://en.wikipedia.org/wiki/Swap_test) between the registers:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bXXYIcZWsJdr"
      },
      "source": [
        "def swap_test(control, register1, register2):\n",
        "\n",
        "    qml.Hadamard(wires=control)\n",
        "    for reg1_qubit, reg2_qubit in zip(register1, register2):\n",
        "        qml.CSWAP(wires=(control, reg1_qubit, reg2_qubit))\n",
        "    qml.Hadamard(wires=control)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GfE6kBdLsJdr"
      },
      "source": [
        "After performing this procedure, the value returned from a measurement\n",
        "of the circuit is $\\langle Z \\rangle$, with respect to the `control`\n",
        "qubit. The probability of measuring the $|0\\rangle$ state in this\n",
        "control qubit is related to both the fidelity between registers and\n",
        "$\\langle Z \\rangle$. Thus, with a bit of algebra, we find that\n",
        "$\\langle Z \\rangle$ is equal to the fidelity.\n",
        "\n",
        "Before creating the full QGRNN and the cost function, we define a few\n",
        "more fixed values. Among these is a \"guessed\" interaction graph, which\n",
        "we set to be a [complete\n",
        "graph](https://en.wikipedia.org/wiki/Complete_graph). This choice is\n",
        "motivated by the fact that any target interaction graph will be a\n",
        "subgraph of this initial guess. Part of the idea behind the QGRNN is\n",
        "that we don’t know the interaction graph, and it has to be learned. In\n",
        "this case, the graph is learned *automatically* as the target parameters\n",
        "are optimized. The $\\boldsymbol\\mu$ parameters that correspond to edges\n",
        "that don't exist in the target graph will simply approach $0$.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 336
        },
        "id": "SezqTy8lsJds",
        "outputId": "3d5e9180-13cd-4c76-f34b-718ddefb32e3"
      },
      "source": [
        "# Defines some fixed values\n",
        "\n",
        "reg1 = tuple(range(qubit_number))  # First qubit register\n",
        "reg2 = tuple(range(qubit_number, 2 * qubit_number))  # Second qubit register\n",
        "\n",
        "control = 2 * qubit_number  # Index of control qubit\n",
        "trotter_step = 0.01  # Trotter step size\n",
        "\n",
        "# Defines the interaction graph for the new qubit system\n",
        "\n",
        "new_ising_graph = nx.complete_graph(reg2)\n",
        "\n",
        "print(f\"Edges: {new_ising_graph.edges}\")\n",
        "nx.draw(new_ising_graph)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Edges: [(4, 5), (4, 6), (4, 7), (5, 6), (5, 7), (6, 7)]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XbhsgNensJds"
      },
      "source": [
        "With this done, we implement the QGRNN circuit for some given time\n",
        "value:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SsiujZu5sJdt"
      },
      "source": [
        "def qgrnn(weights, bias, time=None):\n",
        "\n",
        "    # Prepares the low energy state in the two registers\n",
        "    qml.QubitStateVector(np.kron(low_energy_state, low_energy_state), wires=reg1 + reg2)\n",
        "\n",
        "    # Evolves the first qubit register with the time-evolution circuit to\n",
        "    # prepare a piece of quantum data\n",
        "    state_evolve(ham_matrix, reg1, time)\n",
        "\n",
        "    # Applies the QGRNN layers to the second qubit register\n",
        "    depth = time / trotter_step  # P = t/Delta\n",
        "    for _ in range(0, int(depth)):\n",
        "        qgrnn_layer(weights, bias, reg2, new_ising_graph, trotter_step)\n",
        "\n",
        "    # Applies the SWAP test between the registers\n",
        "    swap_test(control, reg1, reg2)\n",
        "\n",
        "    # Returns the results of the SWAP test\n",
        "    return qml.expval(qml.PauliZ(control))"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wq7ufE4YsJdt"
      },
      "source": [
        "We have the full QGRNN circuit, but we still need to define a cost\n",
        "function. We know that\n",
        "$| \\langle \\psi(t) | U_{H}(\\boldsymbol\\mu, \\ \\Delta) |\\psi_0\\rangle |^2$\n",
        "approaches $1$ as the states become more similar and approaches $0$ as\n",
        "the states become orthogonal. Thus, we choose to minimize the quantity\n",
        "$-| \\langle \\psi(t) | U_{H}(\\boldsymbol\\mu, \\ \\Delta) |\\psi_0\\rangle |^2$.\n",
        "Since we are interested in calculating this value for many different\n",
        "pieces of quantum data, the final cost function is the average negative\n",
        "fidelity\\* between registers:\n",
        "\n",
        "$$\\mathcal{L}(\\boldsymbol\\mu, \\ \\Delta) \\ = \\ - \\frac{1}{N} \\displaystyle\\sum_{i \\ = \\ 1}^{N} |\n",
        "\\langle \\psi(t_i) | \\ U_{H}(\\boldsymbol\\mu, \\ \\Delta) \\ |\\psi_0\\rangle |^2,$$\n",
        "\n",
        "where we use $N$ pieces of quantum data.\n",
        "\n",
        "Before creating the cost function, we must define a few more fixed\n",
        "variables:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IaHaXkqwsJdt"
      },
      "source": [
        "N = 15  # The number of pieces of quantum data that are used for each step\n",
        "max_time = 0.1  # The maximum value of time that can be used for quantum data"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHpjC6pSsJdt"
      },
      "source": [
        "We then define the negative fidelity cost function:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "01-VUtLBsJdt"
      },
      "source": [
        "rng = np.random.default_rng(seed=42)\n",
        "\n",
        "def cost_function(weight_params, bias_params):\n",
        "\n",
        "    # Randomly samples times at which the QGRNN runs\n",
        "    times_sampled = rng.random(size=N) * max_time\n",
        "\n",
        "    # Cycles through each of the sampled times and calculates the cost\n",
        "    total_cost = 0\n",
        "    for dt in times_sampled:\n",
        "        result = qgrnn_qnode(weight_params, bias_params, time=dt)\n",
        "        total_cost += -1 * result\n",
        "\n",
        "    return total_cost / N"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4J9D1_7-sJdu"
      },
      "source": [
        "Next we set up for optimization.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "grUTHEphsJdu"
      },
      "source": [
        "# Defines the new device\n",
        "qgrnn_dev = qml.device(\"default.qubit\", wires=2 * qubit_number + 1)\n",
        "\n",
        "# Defines the new QNode\n",
        "qgrnn_qnode = qml.QNode(qgrnn, qgrnn_dev)\n",
        "\n",
        "steps = 20\n",
        "\n",
        "optimizer = qml.AdamOptimizer(stepsize=0.5)\n",
        "\n",
        "weights = rng.random(size=len(new_ising_graph.edges)) - 0.5\n",
        "bias = rng.random(size=qubit_number) - 0.5\n",
        "\n",
        "initial_weights = copy.copy(weights)\n",
        "initial_bias = copy.copy(bias)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EbAXkSQusJdu"
      },
      "source": [
        "All that remains is executing the optimization loop.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nooMWNa0sJdu",
        "outputId": "e2b9c061-d5ae-4476-fb14-1824eca750b4"
      },
      "source": [
        "for i in range(0, steps):\n",
        "    (weights, bias), cost = optimizer.step_and_cost(cost_function, weights, bias)\n",
        "\n",
        "    # Prints the value of the cost function\n",
        "    if i % 5 == 0:\n",
        "        print(f\"Cost at Step {i}: {cost}\")\n",
        "        print(f\"Weights at Step {i}: {weights}\")\n",
        "        print(f\"Bias at Step {i}: {bias}\")\n",
        "        print(\"---------------------------------------------\")"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cost at Step 0: -0.9878160824442112\n",
            "Weights at Step 0: [-0.53067194  0.15067181  0.18092597  0.90710214  0.04464822 -0.76714681]\n",
            "Bias at Step 0: [-0.70793903 -0.5097999   0.58644189  0.49328887]\n",
            "---------------------------------------------\n",
            "Cost at Step 5: -0.9731403777752663\n",
            "Weights at Step 5: [-1.46275781  1.13121595  0.99289961  1.97546053  0.73787194 -1.46121159]\n",
            "Bias at Step 5: [-1.63439182 -1.53308094  1.69979884  1.08358904]\n",
            "---------------------------------------------\n",
            "Cost at Step 10: -0.9814725413928108\n",
            "Weights at Step 10: [-1.28486173  1.05285223  0.68208756  2.07867694  0.23000248 -0.96240487]\n",
            "Bias at Step 10: [-1.44887645 -1.54165821  1.89895953  0.43017646]\n",
            "---------------------------------------------\n",
            "Cost at Step 15: -0.9980014360540701\n",
            "Weights at Step 15: [-0.77952561  0.64711382  0.24146788  1.84577111 -0.36777906 -0.38417659]\n",
            "Bias at Step 15: [-0.94747881 -1.21805771  1.75659503 -0.24571435]\n",
            "---------------------------------------------\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D1vn5ZzpsJdu"
      },
      "source": [
        "With the learned parameters, we construct a visual representation of the\n",
        "Hamiltonian to which they correspond and compare it to the target\n",
        "Hamiltonian, and the initial guessed Hamiltonian:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 155
        },
        "id": "8IMiyn4_sJdu",
        "outputId": "97c6ac24-b10f-498f-d0b7-a9569784f8e4"
      },
      "source": [
        "new_ham_matrix = create_hamiltonian_matrix(\n",
        "    qubit_number, nx.complete_graph(qubit_number), weights, bias\n",
        ")\n",
        "\n",
        "init_ham = create_hamiltonian_matrix(\n",
        "    qubit_number, nx.complete_graph(qubit_number), initial_weights, initial_bias\n",
        ")\n",
        "\n",
        "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(6, 6))\n",
        "\n",
        "axes[0].matshow(ham_matrix, vmin=-7, vmax=7, cmap=\"hot\")\n",
        "axes[0].set_title(\"Target\", y=1.13)\n",
        "\n",
        "axes[1].matshow(init_ham, vmin=-7, vmax=7, cmap=\"hot\")\n",
        "axes[1].set_title(\"Initial\", y=1.13)\n",
        "\n",
        "axes[2].matshow(new_ham_matrix, vmin=-7, vmax=7, cmap=\"hot\")\n",
        "axes[2].set_title(\"Learned\", y=1.13)\n",
        "\n",
        "plt.subplots_adjust(wspace=0.3, hspace=0.3)\n",
        "plt.show()"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x432 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DB3eA_TasJdu"
      },
      "source": [
        "These images look very similar, indicating that the QGRNN has done a\n",
        "good job learning the target Hamiltonian.\n",
        "\n",
        "We can also look at the exact values of the target and learned\n",
        "parameters. Recall how the target interaction graph has $4$ edges while\n",
        "the complete graph has $6$. Thus, as the QGRNN converges to the optimal\n",
        "solution, the weights corresponding to edges $(1, 3)$ and $(2, 0)$ in\n",
        "the complete graph should go to $0$, as this indicates that they have no\n",
        "effect, and effectively do not exist in the learned Hamiltonian.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "snPz0lW3sJdu"
      },
      "source": [
        "# We first pick out the weights of edges (1, 3) and (2, 0)\n",
        "# and then remove them from the list of target parameters\n",
        "\n",
        "weights_noedge = []\n",
        "weights_edge = []\n",
        "for ii, edge in enumerate(new_ising_graph.edges):\n",
        "    if (edge[0] - qubit_number, edge[1] - qubit_number) in ising_graph.edges:\n",
        "        weights_edge.append(weights[ii])\n",
        "    else:\n",
        "        weights_noedge.append(weights[ii])"
      ],
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E5J_zTS-sJdv"
      },
      "source": [
        "Then, we print all of the weights:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HhwxOyoYsJdv",
        "outputId": "a06b9812-5777-4b7f-c8f0-5693e25053ce"
      },
      "source": [
        "print(\"Target parameters     Learned parameters\")\n",
        "print(\"Weights\")\n",
        "print(\"-\" * 41)\n",
        "for ii_target, ii_learned in zip(target_weights, weights_edge):\n",
        "    print(f\"{ii_target : <20}|{ii_learned : >20}\")\n",
        "\n",
        "print(\"\\nBias\")\n",
        "print(\"-\"*41)\n",
        "for ii_target, ii_learned in zip(target_bias, bias):\n",
        "    print(f\"{ii_target : <20}|{ii_learned : >20}\")\n",
        "\n",
        "print(f\"\\nNon-Existing Edge Parameters: {[val.unwrap() for val in weights_noedge]}\")"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Target parameters     Learned parameters\n",
            "Weights\n",
            "-----------------------------------------\n",
            "0.56                |-0.38023365735527587\n",
            "1.24                | 0.12428409466769798\n",
            "1.67                |  1.6078168211647699\n",
            "-0.79               |-0.21904696625614384\n",
            "\n",
            "Bias\n",
            "-----------------------------------------\n",
            "-1.44               | -0.5730914533643356\n",
            "-1.43               | -0.9289601058811661\n",
            "1.18                |  1.5641113347176148\n",
            "-0.93               |-0.41551711546688064\n",
            "\n",
            "Non-Existing Edge Parameters: [0.3161936262494266, -0.5577718696039904]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sn8qlY0isJdv"
      },
      "source": [
        "The weights of edges $(1, 3)$ and $(2, 0)$ are very close to $0$,\n",
        "indicating we have learned the cycle graph from the complete graph. In\n",
        "addition, the remaining learned weights are fairly close to those of the\n",
        "target Hamiltonian. Thus, the QGRNN is functioning properly, and has\n",
        "learned the target Ising Hamiltonian to a high degree of accuracy!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zzJvpW9RsJdv"
      },
      "source": [
        "References\n",
        "==========\n",
        "\n",
        "1.  Verdon, G., McCourt, T., Luzhnica, E., Singh, V., Leichenauer, S., &\n",
        "    Hidary, J. (2019). Quantum Graph Neural Networks. arXiv preprint\n",
        "    [arXiv:1909.12264](https://arxiv.org/abs/1909.12264).\n",
        "\n"
      ]
    }
  ]
}