1947 lines (1947 with data), 329.7 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "2eG4NG-MW7k4",
        "outputId": "bbaa58bd-cbc5-49ca-bcdf-1fa70f4b3cd0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1701023195.9357715\n",
            "Sun Nov 26 18:26:35 2023\n"
          ]
        }
      ],
      "source": [
        "# This cell is added by sphinx-gallery\n",
        "# It can be customized to whatever you like\n",
        "%matplotlib inline\n",
        "# !pip install pennylane\n",
        "# !pip install tensorflow==2.8.1\n",
        "import time\n",
        "seconds = time.time()\n",
        "print(\"Time in seconds since beginning of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rytAL-cWW7k5"
      },
      "source": [
        "Learning to learn with quantum neural networks\n",
        "==============================================\n",
        "\n",
        "::: {.meta}\n",
        ":property=\\\"og:description\\\": Use a classical recurrent neural network\n",
        "to initilize the parameters of a variational quatum algorithm.\n",
        ":property=\\\"og:image\\\": ../demonstrations/learning2learn/thumbnail.png\n",
        ":::\n",
        "\n",
        "::: {.related}\n",
        "tutorial\\_qaoa\\_intro Intro to QAOA tutorial\\_qaoa\\_maxcut QAOA for\n",
        "MaxCut problem\n",
        ":::\n",
        "\n",
        "*Author: Stefano Mangini --- Posted: 02 March 2021. Last updated: 15\n",
        "September 2021.*\n",
        "\n",
        "In this demo we recreate the architecture proposed in *Learning to learn\n",
        "with quantum neural networks via classical neural networks*, using\n",
        "**PennyLane** and **TensorFlow**. We use classical recurrent neural\n",
        "networks to assist the optimization of variational quantum algorithms.\n",
        "\n",
        "We start with a brief theoretical overview explaining the problem and\n",
        "the setup used to solve it. After that, we deep dive into the code to\n",
        "build a fully functioning model, ready to be further developed or\n",
        "customized for your own needs. Without further ado, let's begin!\n",
        "\n",
        "Problem: Optimization of Variational Quantum Algorithms\n",
        "-------------------------------------------------------\n",
        "\n",
        "Recently, a big effort by the quantum computing community has been\n",
        "devoted to the study of variational quantum algorithms (VQAs) which\n",
        "leverage quantum circuits with fixed shape and tunable parameters. The\n",
        "idea is similar to classical neural networks, where the weights of the\n",
        "network are optimized during training. Similarly, once the shape of the\n",
        "variational quantum circuit is chosen --- something that is very\n",
        "difficult and sensitive to the particular task at hand --- its tunable\n",
        "parameters are optimized iteratively by minimizing a cost (or loss)\n",
        "function, which measures how good the quantum algorithm is performing\n",
        "(see for a thorough overview on VQAs).\n",
        "\n",
        "A major challenge for VQAs relates to the optimization of tunable\n",
        "parameters, which was shown to be a very hard task, . Parameter\n",
        "initialization plays a key role in this scenario, since initializing the\n",
        "parameters in the proximity of an optimal solution leads to faster\n",
        "convergence and better results. Thus, a good initialization strategy is\n",
        "crucial to promote the convergence of local optimizers to local extrema\n",
        "and to select reasonably good local minima. By local optimizer, we mean\n",
        "a procedure that moves from one solution to another by small (local)\n",
        "changes in parameter space. These are opposed to global search methods,\n",
        "which take into account large sections of parameter space to propose a\n",
        "new solution.\n",
        "\n",
        "One such strategy could come from the classical machine learning\n",
        "literature.\n",
        "\n",
        "Solution: Classical Recurrent Neural Networks\n",
        "---------------------------------------------\n",
        "\n",
        "By building on results from the *meta-learning* literature in machine\n",
        "learning, authors in propose to use a Recurrent Neural Network (RNN) as\n",
        "a black-box controller to optimize the parameters of variational quantum\n",
        "algorithms, as shown in the figure below. The cost function used is the\n",
        "expectation value\n",
        "$\\langle H \\rangle_{\\boldsymbol{\\theta}} = \\langle \\psi_{\\boldsymbol{\\theta}} | H | \\psi_{\\boldsymbol{\\theta}}\\rangle$\n",
        "of a Hamiltonian $H$ with respect to the parametrized state\n",
        "$|\\psi_\\boldsymbol{\\theta}\\rangle$ evolved by applying the variational\n",
        "quantum circuit to the zero state $|00\\cdots0\\rangle$.\n",
        "\n",
        "![](../demonstrations/learning2learn/HybridLSTM.png){.align-center\n",
        "width=\"100.0%\"}\n",
        "\n",
        "Given parameters $\\boldsymbol{\\theta}_{t-1}$ of the variational quantum\n",
        "circuit, the cost function $y_{t-1}$, and the hidden state of the\n",
        "classical network $\\boldsymbol{h}_{t-1}$ at the previous time step, the\n",
        "recurrent neural network proposes a new guess for the parameters\n",
        "$\\boldsymbol{\\theta}_t$, which are then fed into the quantum computer to\n",
        "evaluate the cost function $y_t$. By repeating this cycle a few times,\n",
        "and by training the weights of the recurrent neural network to minimize\n",
        "the loss function $y_t$, a good initialization heuristic is found for\n",
        "the parameters $\\boldsymbol{\\theta}$ of the variational quantum circuit.\n",
        "\n",
        "At a given iteration, the RNN receives as input the previous cost\n",
        "function $y_t$ evaluated on the quantum computer, where $y_t$ is the\n",
        "estimate of $\\langle H\\rangle_{t}$, as well as the parameters\n",
        "$\\boldsymbol{\\theta}_t$ for which the variational circuit was evaluated.\n",
        "The RNN at this time step also receives information stored in its\n",
        "internal hidden state from the previous time step $\\boldsymbol{h}_t$.\n",
        "The RNN itself has trainable parameters $\\phi$, and hence it applies the\n",
        "parametrized mapping:\n",
        "\n",
        "$$\\boldsymbol{h}_{t+1}, \\boldsymbol{\\theta}_{t+1} = \\text{RNN}_{\\phi}(\\boldsymbol{h}_{t}, \\boldsymbol{\\theta}_{t}, y_{t}),$$\n",
        "\n",
        "which generates a new suggestion for the variational parameters as well\n",
        "as a new internal state. Upon training the weights $\\phi$, the RNN\n",
        "eventually learns a good heuristic to suggest optimal parameters for the\n",
        "quantum circuit.\n",
        "\n",
        "Thus, by training on a dataset of graphs, the RNN can subsequently be\n",
        "used to provide suggestions for starting points on new graphs! We are\n",
        "not directly optimizing the variational parameters of the quantum\n",
        "circuit, but instead, we let the RNN figure out how to do that. In this\n",
        "sense, we are learning (training the RNN) how to learn (how to optimize\n",
        "a variational quantum circuit).\n",
        "\n",
        "**VQAs in focus: QAOA for MaxCut**\n",
        "\n",
        "There are multiple VQAs for which this hybrid training routine could be\n",
        "used, some of them directly analyzed in. In the following, we focus on\n",
        "one such example, the Quantum Approximate Optimization Algorithm (QAOA)\n",
        "for solving the MaxCut problem. Thus, referring to the picture above,\n",
        "the shape of the variational circuit is the one dictated by the QAOA\n",
        "ansatz, and such a quantum circuit is used to evaluate the cost\n",
        "Hamiltonian $H$ of the MaxCut problem. Check out this great tutorial on\n",
        "how to use QAOA for solving graph problems:\n",
        "<https://pennylane.ai/qml/demos/tutorial_qaoa_intro.html>\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "Running the tutorial (excluding the Appendix) requires approx. \\~13m.\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eu3eqTZIW7k6"
      },
      "source": [
        "**Importing the required packages**\n",
        "\n",
        "During this tutorial, we will use **PennyLane** for executing quantum\n",
        "circuits and for integrating seamlessly with **TensorFlow**, which will\n",
        "be used for creating the RNN.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "VZImhkcGW7k6"
      },
      "outputs": [],
      "source": [
        "# Quantum Machine Learning\n",
        "import pennylane as qml\n",
        "from pennylane import qaoa\n",
        "\n",
        "# Classical Machine Learning\n",
        "import tensorflow as tf\n",
        "\n",
        "# Generation of graphs\n",
        "import networkx as nx\n",
        "\n",
        "# Standard Python libraries\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import random\n",
        "\n",
        "# Fix the seed for reproducibility, which affects all random functions in this demo\n",
        "random.seed(42)\n",
        "np.random.seed(42)\n",
        "tf.random.set_seed(42)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fiDUxW0HW7k6"
      },
      "source": [
        "Generation of training data: graphs\n",
        "===================================\n",
        "\n",
        "The first step is to gather or create a good dataset that will be used\n",
        "to train the model and test its performance. In our case, we are\n",
        "analyzing MaxCut, which deals with the problem of finding a good binary\n",
        "partition of nodes in a graph such that the number of edges *cut* by\n",
        "such a separation is maximized. We start by generating some random\n",
        "graphs $G_{n,p}$ where:\n",
        "\n",
        "-   $n$ is the number of nodes in each graph,\n",
        "-   $p$ is the probability of having an edge between two nodes.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "id": "c_rJNPLlW7k7"
      },
      "outputs": [],
      "source": [
        "def generate_graphs(n_graphs, n_nodes, p_edge):\n",
        "    \"\"\"Generate a list containing random graphs generated by Networkx.\"\"\"\n",
        "\n",
        "    datapoints = []\n",
        "    for _ in range(n_graphs):\n",
        "        random_graph = nx.gnp_random_graph(n_nodes, p=p_edge)\n",
        "        datapoints.append(random_graph)\n",
        "    return datapoints"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N6Lj3XcbW7k7"
      },
      "source": [
        "An example of a random graph generated using the function\n",
        "`generate_graphs` just defined:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "sT8W61vWW7k7",
        "outputId": "1d1d2704-baa5-4b31-cbd4-899efd34067e"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Define parameters of the graphs\n",
        "n_graphs = 20\n",
        "n_nodes = 14\n",
        "p_edge = 3.0 / n_nodes\n",
        "graphs = generate_graphs(n_graphs, n_nodes, p_edge)\n",
        "\n",
        "nx.draw(graphs[0])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "syFn_GVnW7k7"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_Graph0.png){.align-center\n",
        "width=\"70.0%\"}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A-yzL4ASW7k7"
      },
      "source": [
        "Variational Quantum Circuit: QAOA\n",
        "=================================\n",
        "\n",
        "Now that we have a dataset, we move on by creating the QAOA quantum\n",
        "circuits using PennyLane's built-in sub-packages. In particular, using\n",
        "PennyLane's `qaoa` module, we will able to create fully functioning\n",
        "quantum circuits for the MaxCut problem, with very few lines of code.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "TSE2tqZnW7k7"
      },
      "outputs": [],
      "source": [
        "def qaoa_from_graph(graph, n_layers=1):\n",
        "    \"\"\"Uses QAOA to create a cost Hamiltonian for the MaxCut problem.\"\"\"\n",
        "\n",
        "    # Number of qubits (wires) equal to the number of nodes in the graph\n",
        "    wires = range(len(graph.nodes))\n",
        "\n",
        "    # Define the structure of the cost and mixer subcircuits for the MaxCut problem\n",
        "    cost_h, mixer_h = qaoa.maxcut(graph)\n",
        "\n",
        "    # Defines a layer of the QAOA ansatz from the cost and mixer Hamiltonians\n",
        "    def qaoa_layer(gamma, alpha):\n",
        "        qaoa.cost_layer(gamma, cost_h)\n",
        "        qaoa.mixer_layer(alpha, mixer_h)\n",
        "\n",
        "    # Creates the actual quantum circuit for the QAOA algorithm\n",
        "    def circuit(params, **kwargs):\n",
        "        for w in wires:\n",
        "            qml.Hadamard(wires=w)\n",
        "        qml.layer(qaoa_layer, n_layers, params[0], params[1])\n",
        "        return qml.expval(cost_h)\n",
        "\n",
        "    # Evaluates the cost Hamiltonian\n",
        "    def hamiltonian(params, **kwargs):\n",
        "        \"\"\"Evaluate the cost Hamiltonian, given the angles and the graph.\"\"\"\n",
        "\n",
        "        # We set the default.qubit.tf device for seamless integration with TensorFlow\n",
        "        dev = qml.device(\"default.qubit.tf\", wires=len(graph.nodes))\n",
        "\n",
        "        # This qnode evaluates the expectation value of the cost hamiltonian operator\n",
        "        cost = qml.QNode(circuit, dev, interface=\"tf\", diff_method=\"backprop\")\n",
        "\n",
        "        return cost(params)\n",
        "\n",
        "    return hamiltonian"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OghYe4TIW7k7"
      },
      "source": [
        "Before continuing, let's see how to use these functions.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "_M3VTQRpW7k7",
        "outputId": "06dc4c71-0904-4821-c1de-0890100be5a9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tf.Tensor(-6.357351131852882, shape=(), dtype=float64)\n"
          ]
        }
      ],
      "source": [
        "# Create an instance of a QAOA circuit given a graph.\n",
        "cost = qaoa_from_graph(graph=graphs[0], n_layers=1)\n",
        "\n",
        "# Since we use only one layer in QAOA, params have the shape 1 x 2,\n",
        "# in the form [[alpha, gamma]].\n",
        "x = tf.Variable([[0.5], [0.5]], dtype=tf.float32)\n",
        "\n",
        "# Evaluate th QAOA instance just created with some angles.\n",
        "print(cost(x))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "thDyEL3MW7k7"
      },
      "source": [
        "::: {.rst-class}\n",
        "sphx-glr-script-out\n",
        "\n",
        "Out:\n",
        "\n",
        "``` {.none}\n",
        "tf.Tensor(-3.193267957255582, shape=(), dtype=float64)\n",
        "```\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SdSJTG_LW7k7"
      },
      "source": [
        "Recurrent Neural Network: LSTM\n",
        "==============================\n",
        "\n",
        "So far, we have defined the machinery which lets us build the QAOA\n",
        "algorithm for solving the MaxCut problem. Now we wish to implement the\n",
        "Recurrent Neural Network architecture explained previously. As proposed\n",
        "in the original paper, we will build a custom model of a Long-Short Term\n",
        "Memory (LSTM) network, capable of handling the hybrid data passing\n",
        "between classical and quantum procedures. For this task, we will use\n",
        "`Keras` and `TensorFlow`.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ka7S-aTmW7k7"
      },
      "source": [
        "First of all, let's define the elemental building block of the model, an\n",
        "LSTM cell (see [TensorFlow\n",
        "documentation](https://www.tensorflow.org/api_docs/python/tf/keras/layers/LSTMCell)\n",
        "for further details).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "qlZAWZSIW7k8"
      },
      "outputs": [],
      "source": [
        "# Set the number of layers in the QAOA ansatz.\n",
        "# The higher the better in terms of performance, but it also gets more\n",
        "# computationally expensive. For simplicity, we stick to the single layer case.\n",
        "n_layers = 1\n",
        "\n",
        "# Define a single LSTM cell.\n",
        "# The cell has two units per layer since each layer in the QAOA ansatz\n",
        "# makes use of two parameters.\n",
        "cell = tf.keras.layers.LSTMCell(2 * n_layers)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XrSz5XhlW7k8"
      },
      "source": [
        "Using the `qaoa_from_graph` function, we create a list `graph_cost_list`\n",
        "containing the cost functions of a set of graphs. You can see this as a\n",
        "preprocessing step of the data.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "id": "YLfLPV0SW7k8"
      },
      "outputs": [],
      "source": [
        "# We create the QAOA MaxCut cost functions of some graphs\n",
        "graph_cost_list = [qaoa_from_graph(g) for g in graphs]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e-EDV2h3W7k8"
      },
      "source": [
        "At this stage, we seek to reproduce the recurrent behavior depicted in\n",
        "the picture above, outlining the functioning of an RNN as a black-box\n",
        "optimizer. We do so by defining two functions:\n",
        "\n",
        "-   `rnn_iteration`: accounts for the computations happening on a single\n",
        "    time step in the figure. It performs the calculation inside the CPU\n",
        "    and evaluates the quantum circuit on the QPU to obtain the loss\n",
        "    function for the current parameters.\n",
        "-   `recurrent_loop`: as the name suggests, it accounts for the creation\n",
        "    of the recurrent loop of the model. In particular, it makes\n",
        "    consecutive calls to the `rnn_iteration` function, where the outputs\n",
        "    of a previous call are fed as inputs of the next call.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "yIdzr_qAW7k8"
      },
      "outputs": [],
      "source": [
        "def rnn_iteration(inputs, graph_cost, n_layers=1):\n",
        "    \"\"\"Perform a single time step in the computational graph of the custom RNN.\"\"\"\n",
        "\n",
        "    # Unpack the input list containing the previous cost, parameters,\n",
        "    # and hidden states (denoted as 'h' and 'c').\n",
        "    prev_cost = inputs[0]\n",
        "    prev_params = inputs[1]\n",
        "    prev_h = inputs[2]\n",
        "    prev_c = inputs[3]\n",
        "\n",
        "    # Concatenate the previous parameters and previous cost to create new input\n",
        "    new_input = tf.keras.layers.concatenate([prev_cost, prev_params])\n",
        "\n",
        "    # Call the LSTM cell, which outputs new values for the parameters along\n",
        "    # with new internal states h and c\n",
        "    new_params, [new_h, new_c] = cell(new_input, states=[prev_h, prev_c])\n",
        "\n",
        "    # Reshape the parameters to correctly match those expected by PennyLane\n",
        "    _params = tf.reshape(new_params, shape=(2, n_layers))\n",
        "\n",
        "    # Evaluate the cost using new angles\n",
        "    _cost = graph_cost(_params)\n",
        "\n",
        "    # Reshape to be consistent with other tensors\n",
        "    new_cost = tf.reshape(tf.cast(_cost, dtype=tf.float32), shape=(1, 1))\n",
        "\n",
        "    return [new_cost, new_params, new_h, new_c]\n",
        "\n",
        "\n",
        "def recurrent_loop(graph_cost, n_layers=1, intermediate_steps=False):\n",
        "    \"\"\"Creates the recurrent loop for the Recurrent Neural Network.\"\"\"\n",
        "\n",
        "    # Initialize starting all inputs (cost, parameters, hidden states) as zeros.\n",
        "    initial_cost = tf.zeros(shape=(1, 1))\n",
        "    initial_params = tf.zeros(shape=(1, 2 * n_layers))\n",
        "    initial_h = tf.zeros(shape=(1, 2 * n_layers))\n",
        "    initial_c = tf.zeros(shape=(1, 2 * n_layers))\n",
        "\n",
        "    # We perform five consecutive calls to 'rnn_iteration', thus creating the\n",
        "    # recurrent loop. More iterations lead to better results, at the cost of\n",
        "    # more computationally intensive simulations.\n",
        "    out0 = rnn_iteration([initial_cost, initial_params, initial_h, initial_c], graph_cost)\n",
        "    out1 = rnn_iteration(out0, graph_cost)\n",
        "    out2 = rnn_iteration(out1, graph_cost)\n",
        "    out3 = rnn_iteration(out2, graph_cost)\n",
        "    out4 = rnn_iteration(out3, graph_cost)\n",
        "\n",
        "    # This cost function takes into account the cost from all iterations,\n",
        "    # but using different weights.\n",
        "    loss = tf.keras.layers.average(\n",
        "        [0.1 * out0[0], 0.2 * out1[0], 0.3 * out2[0], 0.4 * out3[0], 0.5 * out4[0]]\n",
        "    )\n",
        "\n",
        "    if intermediate_steps:\n",
        "        return [out0[1], out1[1], out2[1], out3[1], out4[1], loss]\n",
        "    else:\n",
        "        return loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AOu2R88QW7k8"
      },
      "source": [
        "**The cost function**\n",
        "\n",
        "A key part in the `recurrent_loop` function is given by the definition\n",
        "of the variable `loss`. In order to drive the learning procedure of the\n",
        "weights in the LSTM cell, a cost function is needed. While in the\n",
        "original paper the authors suggest using a measure called *observed\n",
        "improvement*, for simplicity here we use an easier cost function\n",
        "$\\cal{L}(\\phi)$ defined as:\n",
        "\n",
        "$$\\cal{L}(\\phi) = {\\bf w} \\cdot {\\bf y}_t(\\phi),$$\n",
        "\n",
        "where ${\\bf y}_t(\\phi) = (y_1, \\cdots, y_5)$ contains the Hamiltonian\n",
        "cost functions from all iterations, and ${\\bf w}$ are just some\n",
        "coefficients weighting the different steps in the recurrent loop. In\n",
        "this case, we used ${\\bf w}=\\frac{1}{5} (0.1, 0.2, 0.3, 0.4, 0.5)$, to\n",
        "give more importance to the last steps rather than the initial steps.\n",
        "Intuitively in this way the RNN is more free (low coefficient) to\n",
        "explore a larger portion of parameter space during the first steps of\n",
        "optimization, while it is constrained (high coefficient) to select an\n",
        "optimal solution towards the end of the procedure. Note that one could\n",
        "also use just the final cost function from the last iteration to drive\n",
        "the training procedure of the RNN. However, using values also from\n",
        "intermediate steps allows for a smoother suggestion routine, since even\n",
        "non-optimal parameter suggestions from early steps are penalized using\n",
        "$\\cal{L}(\\phi)$.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yhl1qlXuW7k8"
      },
      "source": [
        "**Training**\n",
        "\n",
        "Now all the cards are on the table and we just need to prepare a\n",
        "training routine and then run it!\n",
        "\n",
        "First of all, let's wrap a single gradient descent step inside a custom\n",
        "function `train_step`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "3sjfCmA8W7k8"
      },
      "outputs": [],
      "source": [
        "def train_step(graph_cost):\n",
        "    \"\"\"Single optimization step in the training procedure.\"\"\"\n",
        "\n",
        "    with tf.GradientTape() as tape:\n",
        "        # Evaluates the cost function\n",
        "        loss = recurrent_loop(graph_cost)\n",
        "\n",
        "    # Evaluates gradients, cell is the LSTM cell defined previously\n",
        "    grads = tape.gradient(loss, cell.trainable_weights)\n",
        "\n",
        "    # Apply gradients and update the weights of the LSTM cell\n",
        "    opt.apply_gradients(zip(grads, cell.trainable_weights))\n",
        "    return loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uw0zIpuPW7k8"
      },
      "source": [
        "We are now ready to start the training. In particular, we will perform a\n",
        "stochastic gradient descent in the parameter space of the weights of the\n",
        "LSTM cell. For each graph in the training set, we evaluate gradients and\n",
        "update the weights accordingly. Then, we repeat this procedure for\n",
        "multiple times (epochs).\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "Be careful when using bigger datasets or training for larger epochs,\n",
        "this may take a while to execute.\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "U3LB5fBVW7k8",
        "outputId": "d783b598-3f85-4467-a7b8-0399a7e235e0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1\n",
            " > Graph 1/20 - Loss: -3.000255584716797\n",
            " > Graph 6/20 - Loss: -3.963111162185669\n",
            " > Graph 11/20 - Loss: -3.1351478099823\n",
            " > Graph 16/20 - Loss: -3.925734281539917\n",
            " >> Mean Loss during epoch: -3.2966054320335387\n",
            "Epoch 2\n",
            " > Graph 1/20 - Loss: -3.9570693969726562\n",
            " > Graph 6/20 - Loss: -4.408625602722168\n",
            " > Graph 11/20 - Loss: -3.2588531970977783\n",
            " > Graph 16/20 - Loss: -4.118922233581543\n",
            " >> Mean Loss during epoch: -3.5769235372543333\n",
            "Epoch 3\n",
            " > Graph 1/20 - Loss: -3.857039213180542\n",
            " > Graph 6/20 - Loss: -4.447664260864258\n",
            " > Graph 11/20 - Loss: -3.273247480392456\n",
            " > Graph 16/20 - Loss: -4.229281425476074\n",
            " >> Mean Loss during epoch: -3.5589744329452513\n",
            "Epoch 4\n",
            " > Graph 1/20 - Loss: -4.028074741363525\n",
            " > Graph 6/20 - Loss: -4.5083794593811035\n",
            " > Graph 11/20 - Loss: -3.294462203979492\n",
            " > Graph 16/20 - Loss: -4.212204456329346\n",
            " >> Mean Loss during epoch: -3.6069520235061647\n",
            "Epoch 5\n",
            " > Graph 1/20 - Loss: -3.964874744415283\n",
            " > Graph 6/20 - Loss: -4.504437446594238\n",
            " > Graph 11/20 - Loss: -3.285264253616333\n",
            " > Graph 16/20 - Loss: -4.2220587730407715\n",
            " >> Mean Loss during epoch: -3.5956637024879456\n"
          ]
        }
      ],
      "source": [
        "# Select an optimizer\n",
        "opt = tf.keras.optimizers.Adam(learning_rate=0.2)\n",
        "\n",
        "# Set the number of training epochs\n",
        "epochs = 5\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    print(f\"Epoch {epoch+1}\")\n",
        "    total_loss = np.array([])\n",
        "    for i, graph_cost in enumerate(graph_cost_list):\n",
        "        loss = train_step(graph_cost)\n",
        "        total_loss = np.append(total_loss, loss.numpy())\n",
        "        # Log every 5 batches.\n",
        "        if i % 5 == 0:\n",
        "            print(f\" > Graph {i+1}/{len(graph_cost_list)} - Loss: {loss[0][0]}\")\n",
        "    print(f\" >> Mean Loss during epoch: {np.mean(total_loss)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x0rSiW_BW7k8"
      },
      "source": [
        "::: {.rst-class}\n",
        "sphx-glr-script-out\n",
        "\n",
        "Out:\n",
        "\n",
        "``` {.none}\n",
        "Epoch 1\n",
        " > Graph 1/20 - Loss: -1.6641689538955688\n",
        " > Graph 6/20 - Loss: -1.4186843633651733\n",
        " > Graph 11/20 - Loss: -1.3757232427597046\n",
        " > Graph 16/20 - Loss: -1.294339656829834\n",
        " >> Mean Loss during epoch: -1.7352586269378663\n",
        "Epoch 2\n",
        " > Graph 1/20 - Loss: -2.119091749191284\n",
        " > Graph 6/20 - Loss: -1.4789190292358398\n",
        " > Graph 11/20 - Loss: -1.3779840469360352\n",
        " > Graph 16/20 - Loss: -1.2963457107543945\n",
        " >> Mean Loss during epoch: -1.8252217948436738\n",
        "Epoch 3\n",
        " > Graph 1/20 - Loss: -2.1322619915008545\n",
        " > Graph 6/20 - Loss: -1.459418535232544\n",
        " > Graph 11/20 - Loss: -1.390620470046997\n",
        " > Graph 16/20 - Loss: -1.3165746927261353\n",
        " >> Mean Loss during epoch: -1.8328069806098939\n",
        "Epoch 4\n",
        " > Graph 1/20 - Loss: -2.1432175636291504\n",
        " > Graph 6/20 - Loss: -1.476362943649292\n",
        " > Graph 11/20 - Loss: -1.3938289880752563\n",
        " > Graph 16/20 - Loss: -1.3140206336975098\n",
        " >> Mean Loss during epoch: -1.8369774043560028\n",
        "Epoch 5\n",
        " > Graph 1/20 - Loss: -2.1429405212402344\n",
        " > Graph 6/20 - Loss: -1.477513074874878\n",
        " > Graph 11/20 - Loss: -1.3909202814102173\n",
        " > Graph 16/20 - Loss: -1.315887689590454\n",
        " >> Mean Loss during epoch: -1.8371947884559632\n",
        "```\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OKnOYDO7W7k8"
      },
      "source": [
        "As you can see, the Loss for each graph keeps decreasing across epochs,\n",
        "indicating that the training routine is working correctly.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6deUvXWKW7k8"
      },
      "source": [
        "Results\n",
        "=======\n",
        "\n",
        "Let's see how to use the optimized RNN as an initializer for the angles\n",
        "in the QAOA algorithm.\n",
        "\n",
        "First, we pick a new graph, not present in the training dataset:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "iBlg7nwWW7k8",
        "outputId": "7a5e9f48-51fc-4dd0-dfec-f0573ac04157"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "new_graph = nx.gnp_random_graph(7, p=3 / 7)\n",
        "new_cost = qaoa_from_graph(new_graph)\n",
        "\n",
        "nx.draw(new_graph)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWa0Nw6rW7k8"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_Graph1.png){.align-center\n",
        "width=\"70.0%\"}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aI5XYFUoW7k8"
      },
      "source": [
        "Then we apply the trained RNN to this new graph, saving intermediate\n",
        "results coming from all the recurrent iterations in the network.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "id": "iI7WAs2TW7k8"
      },
      "outputs": [],
      "source": [
        "# Apply the RNN (be sure that training was performed)\n",
        "res = recurrent_loop(new_cost, intermediate_steps=True)\n",
        "\n",
        "# Extract all angle suggestions\n",
        "start_zeros = tf.zeros(shape=(2 * n_layers, 1))\n",
        "guess_0 = res[0]\n",
        "guess_1 = res[1]\n",
        "guess_2 = res[2]\n",
        "guess_3 = res[3]\n",
        "guess_4 = res[4]\n",
        "final_loss = res[5]\n",
        "\n",
        "# Wrap them into a list\n",
        "guesses = [start_zeros, guess_0, guess_1, guess_2, guess_3, guess_4]\n",
        "\n",
        "# Losses from the hybrid LSTM model\n",
        "lstm_losses = [new_cost(tf.reshape(guess, shape=(2, n_layers))) for guess in guesses]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gqyCdBCDW7k9"
      },
      "source": [
        "**Plot of the loss function**\n",
        "\n",
        "We can plot these losses to see how well the RNN proposes new guesses\n",
        "for the parameters.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "id": "XlrZtF4aW7k9",
        "outputId": "73efc6ce-a2d6-4587-8776-20e4e940f656"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots()\n",
        "\n",
        "plt.plot(lstm_losses, color=\"blue\", lw=3, ls=\"-.\", label=\"LSTM\")\n",
        "\n",
        "plt.grid(ls=\"--\", lw=2, alpha=0.25)\n",
        "plt.ylabel(\"Cost function\", fontsize=12)\n",
        "plt.xlabel(\"Iteration\", fontsize=12)\n",
        "plt.legend()\n",
        "ax.set_xticks([0, 5, 10, 15, 20]);\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KN_QEBswW7k9"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_LossLSTM.png){.align-center\n",
        "width=\"70.0%\"}\n",
        "\n",
        "That's remarkable! The RNN learned to propose new parameters such that\n",
        "the MaxCut cost is minimized very rapidly: in just a few iterations the\n",
        "loss reaches a minimum. Actually, it takes just a single step for the\n",
        "LSTM to find a very good minimum. In fact, due to the recurrent loop,\n",
        "the loss in each time step is directly dependent on the previous ones,\n",
        "with the first iteration thus having a lot of influence on the loss\n",
        "function defined above. Changing the loss function, for example giving\n",
        "less importance to initial steps and just focusing on the last one,\n",
        "leads to different optimization behaviors, but with the same final\n",
        "results.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q7SfpqYGW7k9"
      },
      "source": [
        "**Comparison with standard Stochastic Gradient Descent (SGD)**\n",
        "\n",
        "How well does this method compare with standard optimization techniques,\n",
        "for example, leveraging Stochastic Gradient Descent (SGD) to optimize\n",
        "the parameters in the QAOA?\n",
        "\n",
        "Let's check it out.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "JUa6RL_JW7k9",
        "outputId": "7d7d3bd1-bd16-4dc2-c5f8-bddf810f5cbe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Step 1 - Loss = -3.0490211051432903\n",
            "Step 2 - Loss = -3.0710835300368453\n",
            "Step 3 - Loss = -3.095584131255778\n",
            "Step 4 - Loss = -3.1233194348215156\n",
            "Step 5 - Loss = -3.155045523561159\n",
            "Step 6 - Loss = -3.1914415933012887\n",
            "Step 7 - Loss = -3.233056006590561\n",
            "Step 8 - Loss = -3.2802369265291826\n",
            "Step 9 - Loss = -3.3330550456400725\n",
            "Step 10 - Loss = -3.3912324868965875\n",
            "Step 11 - Loss = -3.45409756695605\n",
            "Step 12 - Loss = -3.5205864320713225\n",
            "Step 13 - Loss = -3.589306301208537\n",
            "Step 14 - Loss = -3.6586603591900233\n",
            "Step 15 - Loss = -3.727015083727788\n",
            "Final cost function: -3.7928750587009974\n",
            "Optimized angles: [[0.31029558]\n",
            " [1.07954708]]\n"
          ]
        }
      ],
      "source": [
        "# Parameters are randomly initialized\n",
        "x = tf.Variable(np.random.rand(2, 1))\n",
        "\n",
        "# We set the optimizer to be a Stochastic Gradient Descent\n",
        "opt = tf.keras.optimizers.SGD(learning_rate=0.01)\n",
        "step = 15\n",
        "\n",
        "# Training process\n",
        "steps = []\n",
        "sdg_losses = []\n",
        "for _ in range(step):\n",
        "    with tf.GradientTape() as tape:\n",
        "        loss = new_cost(x)\n",
        "\n",
        "    steps.append(x)\n",
        "    sdg_losses.append(loss)\n",
        "\n",
        "    gradients = tape.gradient(loss, [x])\n",
        "    opt.apply_gradients(zip(gradients, [x]))\n",
        "    print(f\"Step {_+1} - Loss = {loss}\")\n",
        "\n",
        "print(f\"Final cost function: {new_cost(x).numpy()}\\nOptimized angles: {x.numpy()}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rqAjFUZsW7k9"
      },
      "source": [
        "::: {.rst-class}\n",
        "sphx-glr-script-out\n",
        "\n",
        "Out:\n",
        "\n",
        "``` {.none}\n",
        "Step 1 - Loss = -4.1700805\n",
        "Step 2 - Loss = -4.67503588\n",
        "Step 3 - Loss = -5.09949909\n",
        "Step 4 - Loss = -5.40388533\n",
        "Step 5 - Loss = -5.59529203\n",
        "Step 6 - Loss = -5.70495197\n",
        "Step 7 - Loss = -5.7642561\n",
        "Step 8 - Loss = -5.79533198\n",
        "Step 9 - Loss = -5.81138752\n",
        "Step 10 - Loss = -5.81966529\n",
        "Step 11 - Loss = -5.82396722\n",
        "Step 12 - Loss = -5.82624537\n",
        "Step 13 - Loss = -5.82749126\n",
        "Step 14 - Loss = -5.82820626\n",
        "Step 15 - Loss = -5.82864379\n",
        "Final cost function: -5.828932361904984\n",
        "Optimized angles: [[ 0.5865477 ]\n",
        " [-0.3228858]]\n",
        "```\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "id": "h1101um-W7k9",
        "outputId": "e99d840f-441e-4a91-b80e-84e9f74d7b63"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots()\n",
        "\n",
        "plt.plot(sdg_losses, color=\"orange\", lw=3, label=\"SGD\")\n",
        "\n",
        "plt.plot(lstm_losses, color=\"blue\", lw=3, ls=\"-.\", label=\"LSTM\")\n",
        "\n",
        "plt.grid(ls=\"--\", lw=2, alpha=0.25)\n",
        "plt.legend()\n",
        "plt.ylabel(\"Cost function\", fontsize=12)\n",
        "plt.xlabel(\"Iteration\", fontsize=12)\n",
        "ax.set_xticks([0, 5, 10, 15, 20]);\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5R_GawivW7k9"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_LossConfrontation.png){.align-center\n",
        "width=\"70.0%\"}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r0n7g1ZqW7k9"
      },
      "source": [
        "*Hurray!* 🎉🎉\n",
        "\n",
        "As is clear from the picture, the RNN reaches a better minimum in fewer\n",
        "iterations than the standard SGD. Thus, as the authors suggest, the\n",
        "trained RNN can be used for a few iterations at the start of the\n",
        "training procedure to initialize the parameters of the quantum circuit\n",
        "close to an optimal solution. Then, a standard optimizer like the SGD\n",
        "can be used to fine-tune the proposed parameters and reach even better\n",
        "solutions. While on this small scale example the benefits of using an\n",
        "LSTM to initialize parameters may seem modest, on more complicated\n",
        "instances and problems it can make a big difference, since, on random\n",
        "initialization of the parameters, standard local optimizer may encounter\n",
        "problems finding a good minimization direction (for further details,\n",
        "see,).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P8A3iSfEW7k9"
      },
      "source": [
        "Final remarks\n",
        "=============\n",
        "\n",
        "In this demo, we saw how to use a recurrent neural network as a\n",
        "black-box optimizer to initialize the parameters in a variational\n",
        "quantum circuit close to an optimal solution. We connected MaxCut QAOA\n",
        "quantum circuits in PennyLane with an LSTM built with TensorFlow, and we\n",
        "used a custom hybrid training routine to optimize the whole network.\n",
        "\n",
        "Such architecture proved itself to be a good candidate for the\n",
        "initialization problem of Variational Quantum Algorithms, since it\n",
        "reaches good optimal solutions in very few iterations. Besides, the\n",
        "architecture is quite general since the same machinery can be used for\n",
        "graphs having a generic number of nodes (see \\\"Generalization\n",
        "Performances\\\" in the Appendix).\n",
        "\n",
        "**What's next?**\n",
        "\n",
        "But the story does not end here. There are multiple ways this work could\n",
        "be improved. Here are a few:\n",
        "\n",
        "-   Use the proposed architecture for VQAs other than QAOA for MaxCut.\n",
        "    You can check the paper to get some inspiration.\n",
        "-   Scale up the simulation, using bigger graphs and longer recurrent\n",
        "    loops.\n",
        "-   While working correctly, the training routine is quite basic and it\n",
        "    could be improved for example by implementing batch learning or a\n",
        "    stopping criterion. Also, one could implement the *observed\n",
        "    improvement* loss function, as used in the original paper .\n",
        "-   Depending on the problem, you may wish to transform the functions\n",
        "    `rnn_iteration` and `recurrent_loop` to actual `Keras Layers` and\n",
        "    `Models`. This way, by compiling the model before the training takes\n",
        "    place, `TensorFlow` can create the computational graph of the model\n",
        "    and train more efficiently. You can find some ideas below to start\n",
        "    working on it.\n",
        "\n",
        "If you\\'re interested, in the Appendix below you can find some more\n",
        "details and insights about this model. Go check it out!\n",
        "\n",
        "If you have any doubt, or wish to discuss about the project don't\n",
        "hesitate to contact me, I'll be very happy to help you as much as I can\n",
        "😁\n",
        "\n",
        "Have a great quantum day!\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YL7cEoMeW7k-"
      },
      "source": [
        "References\n",
        "==========\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HCTB3zQaW7k-"
      },
      "source": [
        "Appendix\n",
        "========\n",
        "\n",
        "In this appendix you can find further details about the Learning to\n",
        "Learn approach introduced in this tutorial.\n",
        "\n",
        "Generalization performances\n",
        "---------------------------\n",
        "\n",
        "A very interesting feature of this model, is that it can be\n",
        "straightforwardly applied to graphs having a different number of nodes.\n",
        "In fact, until now our analysis focused only on graphs with the same\n",
        "number of nodes for ease of explanation, and there is no actual\n",
        "restriction in this respect. The same machinery works fine for any\n",
        "graph, since the number of QAOA parameters are only dependent on the\n",
        "number of layers in the ansatz, and not on the number of qubits (equal\n",
        "to the number of nodes in the graph) in the quantum circuit.\n",
        "\n",
        "Thus, we might want to challenge our model to learn a good\n",
        "initialization heuristic for a non-specific graph, with an arbitrary\n",
        "number of nodes. For this purpose, let's create a training dataset\n",
        "containing graphs with a different number of nodes $n$, taken in the\n",
        "interval $n \\in [7,9]$ (that is, our dataset now contains graphs having\n",
        "either 7, 8 and 9 nodes).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "_BI5C3FoW7k-"
      },
      "outputs": [],
      "source": [
        "cell = tf.keras.layers.LSTMCell(2 * n_layers)\n",
        "\n",
        "g7 = generate_graphs(5, 7, 3 / 7)\n",
        "g8 = generate_graphs(5, 8, 3 / 7)\n",
        "g9 = generate_graphs(5, 9, 3 / 7)\n",
        "\n",
        "gs = g7 + g8 + g9\n",
        "gs_cost_list = [qaoa_from_graph(g) for g in gs]\n",
        "\n",
        "# Shuffle the dataset\n",
        "import random\n",
        "random.seed(1234)\n",
        "random.shuffle(gs_cost_list)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5y3LsBcW7k-"
      },
      "source": [
        "So far, we have created an equally balanced dataset that contains graphs\n",
        "with a different number of nodes. We now use this dataset to train the\n",
        "LSTM.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "vy_D1kNyW7k-",
        "outputId": "1bd9cd2e-4968-44c5-e1f1-8e831729940d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1\n",
            " > Graph 1/15 - Loss: [[-1.1799023]]\n",
            " > Graph 6/15 - Loss: [[-1.5014255]]\n",
            " > Graph 11/15 - Loss: [[-3.4516182]]\n",
            " >> Mean Loss during epoch: -1.8746575673421224\n",
            "Epoch 2\n",
            " > Graph 1/15 - Loss: [[-1.2009614]]\n",
            " > Graph 6/15 - Loss: [[-1.5017128]]\n",
            " > Graph 11/15 - Loss: [[-3.4569225]]\n",
            " >> Mean Loss during epoch: -1.883303201198578\n",
            "Epoch 3\n",
            " > Graph 1/15 - Loss: [[-1.2054526]]\n",
            " > Graph 6/15 - Loss: [[-1.5126619]]\n",
            " > Graph 11/15 - Loss: [[-3.4888186]]\n",
            " >> Mean Loss during epoch: -1.9002029101053874\n"
          ]
        }
      ],
      "source": [
        "# Select an optimizer\n",
        "opt = tf.keras.optimizers.Adam(learning_rate=0.2)\n",
        "\n",
        "# Set the number of training epochs\n",
        "epochs = 3\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    print(f\"Epoch {epoch+1}\")\n",
        "    total_loss = np.array([])\n",
        "    for i, graph_cost in enumerate(gs_cost_list):\n",
        "        loss = train_step(graph_cost)\n",
        "        total_loss = np.append(total_loss, loss.numpy())\n",
        "        # Log every 5 batches.\n",
        "        if i % 5 == 0:\n",
        "            print(f\" > Graph {i+1}/{len(gs_cost_list)} - Loss: {loss}\")\n",
        "    print(f\" >> Mean Loss during epoch: {np.mean(total_loss)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wMFKWM26W7k-"
      },
      "source": [
        "::: {.rst-class}\n",
        "sphx-glr-script-out\n",
        "\n",
        "Out:\n",
        "\n",
        "``` {.none}\n",
        "Epoch 1\n",
        "> Graph 1/15 - Loss: [[-1.4876363]]\n",
        "> Graph 6/15 - Loss: [[-1.8590403]]\n",
        "> Graph 11/15 - Loss: [[-1.7644017]]\n",
        ">> Mean Loss during epoch: -1.9704322338104248\n",
        "Epoch 2\n",
        "> Graph 1/15 - Loss: [[-1.8650053]]\n",
        "> Graph 6/15 - Loss: [[-1.9578737]]\n",
        "> Graph 11/15 - Loss: [[-1.8377447]]\n",
        ">> Mean Loss during epoch: -2.092947308222453\n",
        "Epoch 3\n",
        "> Graph 1/15 - Loss: [[-1.9009062]]\n",
        "> Graph 6/15 - Loss: [[-1.9726204]]\n",
        "> Graph 11/15 - Loss: [[-1.8668792]]\n",
        ">> Mean Loss during epoch: -2.1162660201390584\n",
        "```\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F0FTu2fLW7k-"
      },
      "source": [
        "Let's check if this hybrid model eventually learned a good heuristic to\n",
        "propose new updates for the parameters in the QAOA ansatz of the MaxCut\n",
        "problem.\n",
        "\n",
        "For this reason, we consider a new graph. In particular, we can take a\n",
        "graph with 10 nodes, which is something that the recurrent network has\n",
        "not seen before.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "yeKySIaCW7k-",
        "outputId": "4347a87e-6188-483a-c3d7-b5a07c8b2c09"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "new_graph = nx.gnp_random_graph(10, p=3 / 7)\n",
        "new_cost = qaoa_from_graph(new_graph)\n",
        "\n",
        "nx.draw(new_graph)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9T88hSRW7k-"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_Graph10.png){.align-center\n",
        "width=\"70.0%\"}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWLRpXx6W7k-"
      },
      "source": [
        "We call the trained recurrent LSTM on this graph, saving not only the\n",
        "last, but all intermediate guesses for the parameters.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "id": "3IAC8P0ZW7k-",
        "outputId": "7838934d-46df-4b67-879b-c9dec193c456"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "res = recurrent_loop(new_cost, intermediate_steps=True)\n",
        "\n",
        "# Extract all angle suggestions\n",
        "start_zeros = tf.zeros(shape=(2 * n_layers, 1))\n",
        "guess_0 = res[0]\n",
        "guess_1 = res[1]\n",
        "guess_2 = res[2]\n",
        "guess_3 = res[3]\n",
        "guess_4 = res[4]\n",
        "final_loss = res[5]\n",
        "\n",
        "# Wrap them into a list\n",
        "guesses = [start_zeros, guess_0, guess_1, guess_2, guess_3, guess_4]\n",
        "\n",
        "# Losses from the hybrid LSTM model\n",
        "lstm_losses = [new_cost(tf.reshape(guess, shape=(2, n_layers))) for guess in guesses]\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "plt.plot(lstm_losses, color=\"blue\", lw=3, ls=\"-.\", label=\"LSTM\")\n",
        "\n",
        "plt.grid(ls=\"--\", lw=2, alpha=0.25)\n",
        "plt.legend()\n",
        "plt.ylabel(\"Cost function\", fontsize=12)\n",
        "plt.xlabel(\"Iteration\", fontsize=12)\n",
        "ax.set_xticks([0, 5, 10, 15, 20]);\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_91cxwU4W7k-"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_LossGeneralization.png){.align-center\n",
        "width=\"70.0%\"}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3gJmVDHnW7k-"
      },
      "source": [
        "Again, we can confirm that the custom optimizer based on the LSTM\n",
        "quickly reaches a good value of the loss function, and also achieve good\n",
        "generalization performances, since it is able to initialize parameters\n",
        "also for graphs not present in the training set.\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "To get the optimized weights of the LSTM use:\n",
        "`optimized_weights = cell.get_weights()`. To set initial weights for the\n",
        "LSTM cell, use instead: `cell.set_weights(optimized_weights)`.\n",
        ":::\n",
        "\n",
        "Loss landscape in parameter space\n",
        "=================================\n",
        "\n",
        "It may be interesting to plot the path suggested by the RNN in the space\n",
        "of the parameters. Note that this is possible only if one layer is used\n",
        "in the QAOA ansatz since in this case only two angles are needed and\n",
        "they can be plotted on a 2D plane. Of course, if more layers are used,\n",
        "you can always select a pair of them to reproduce a similar plot.\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "This cell takes approx. \\~1m to run with an 11 by 11 grid\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 476
        },
        "id": "c26_87lAW7k-",
        "outputId": "ff317e6a-2d6f-4854-f115-fc015b85d27c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Evaluate the cost function on a grid in parameter space\n",
        "dx = dy = np.linspace(-1.0, 1.0, 11)\n",
        "dz = np.array([new_cost([[xx], [yy]]).numpy() for yy in dy for xx in dx])\n",
        "Z = dz.reshape((11, 11))\n",
        "\n",
        "# Plot cost landscape\n",
        "plt.contourf(dx, dy, Z)\n",
        "plt.colorbar()\n",
        "\n",
        "# Extract optimizer steps\n",
        "params_x = [0.0] + [res[i].numpy()[0, 0] for i in range(len(res[:-1]))]\n",
        "params_y = [0.0] + [res[i].numpy()[0, 1] for i in range(len(res[:-1]))]\n",
        "\n",
        "# Plot steps\n",
        "plt.plot(params_x, params_y, linestyle=\"--\", color=\"red\", marker=\"x\")\n",
        "\n",
        "plt.yticks(np.linspace(-1, 1, 5))\n",
        "plt.xticks(np.linspace(-1, 1, 5))\n",
        "plt.xlabel(r\"$\\alpha$\", fontsize=12)\n",
        "plt.ylabel(r\"$\\gamma$\", fontsize=12)\n",
        "plt.title(\"Loss Landscape\", fontsize=12)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pfz2iKc4W7k-"
      },
      "source": [
        "![](../demonstrations/learning2learn/rendered_LossLandscape.png){.align-center\n",
        "width=\"70.0%\"}\n",
        "\n",
        "Ideas for creating a Keras Layer and Keras Model\n",
        "================================================\n",
        "\n",
        "Definition of a `Keras Layer` containing a single pass through the LSTM\n",
        "and the Quantum Circuit. That's equivalent to the function\n",
        "`rnn_iteration` from before.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "zpCBWKxfW7k-"
      },
      "outputs": [],
      "source": [
        "class QRNN(tf.keras.layers.Layer):\n",
        "    def __init__(self, p=1, graph=None):\n",
        "        super(QRNN, self).__init__()\n",
        "        # p is the number of layers in the QAOA ansatz\n",
        "        self.cell = tf.keras.layers.LSTMCell(2 * p)\n",
        "        self.expectation = qaoa_from_graph(graph, n_layers=p)\n",
        "        self.qaoa_p = p\n",
        "\n",
        "    def call(self, inputs):\n",
        "        prev_cost = inputs[0]\n",
        "        prev_params = inputs[1]\n",
        "        prev_h = inputs[2]\n",
        "        prev_c = inputs[3]\n",
        "\n",
        "        # Concatenate the previous parameters and previous cost to create new input\n",
        "        new_input = tf.keras.layers.concatenate([prev_cost, prev_params])\n",
        "\n",
        "        # New parameters obtained by the LSTM cell, along with new internal states h and c\n",
        "        new_params, [new_h, new_c] = self.cell(new_input, states=[prev_h, prev_c])\n",
        "\n",
        "        # This part is used to feed the parameters to the PennyLane function\n",
        "        _params = tf.reshape(new_params, shape=(2, self.qaoa_p))\n",
        "\n",
        "        # Cost evaluation, and reshaping to be consistent with other Keras tensors\n",
        "        new_cost = tf.reshape(tf.cast(self.expectation(_params), dtype=tf.float32), shape=(1, 1))\n",
        "\n",
        "        return [new_cost, new_params, new_h, new_c]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmjxo5wkW7k_"
      },
      "source": [
        "Code for creating an actual `Keras Model` starting from the previous\n",
        "layer definition.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "fGqHsQ33W7k_",
        "outputId": "4be7b403-f2d1-4dbf-cf5e-14c5c3d7114d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model_1\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_5 (InputLayer)           [(None, 1)]          0           []                               \n",
            "                                                                                                  \n",
            " input_6 (InputLayer)           [(None, 2)]          0           []                               \n",
            "                                                                                                  \n",
            " input_7 (InputLayer)           [(None, 2)]          0           []                               \n",
            "                                                                                                  \n",
            " input_8 (InputLayer)           [(None, 2)]          0           []                               \n",
            "                                                                                                  \n",
            " qrnn_1 (QRNN)                  [(1, 1),             48          ['input_5[0][0]',                \n",
            "                                 (None, 2),                       'input_6[0][0]',                \n",
            "                                 (None, 2),                       'input_7[0][0]',                \n",
            "                                 (None, 2)]                       'input_8[0][0]',                \n",
            "                                                                  'qrnn_1[0][0]',                 \n",
            "                                                                  'qrnn_1[0][1]',                 \n",
            "                                                                  'qrnn_1[0][2]',                 \n",
            "                                                                  'qrnn_1[0][3]',                 \n",
            "                                                                  'qrnn_1[1][0]',                 \n",
            "                                                                  'qrnn_1[1][1]',                 \n",
            "                                                                  'qrnn_1[1][2]',                 \n",
            "                                                                  'qrnn_1[1][3]']                 \n",
            "                                                                                                  \n",
            " tf.math.multiply_3 (TFOpLambda  (1, 1)              0           ['qrnn_1[0][0]']                 \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " tf.math.multiply_4 (TFOpLambda  (1, 1)              0           ['qrnn_1[1][0]']                 \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " tf.math.multiply_5 (TFOpLambda  (1, 1)              0           ['qrnn_1[2][0]']                 \n",
            " )                                                                                                \n",
            "                                                                                                  \n",
            " average_295 (Average)          (1, 1)               0           ['tf.math.multiply_3[0][0]',     \n",
            "                                                                  'tf.math.multiply_4[0][0]',     \n",
            "                                                                  'tf.math.multiply_5[0][0]']     \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 48\n",
            "Trainable params: 48\n",
            "Non-trainable params: 0\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ],
      "source": [
        "_graph = nx.gnp_random_graph(7, p=3 / 7)\n",
        "\n",
        "# Instantiate the LSTM cells\n",
        "rnn0 = QRNN(graph=_graph)\n",
        "\n",
        "# Create some input layers to feed the data\n",
        "inp_cost = tf.keras.layers.Input(shape=(1,))\n",
        "inp_params = tf.keras.layers.Input(shape=(2,))\n",
        "inp_h = tf.keras.layers.Input(shape=(2,))\n",
        "inp_c = tf.keras.layers.Input(shape=(2,))\n",
        "\n",
        "# Manually creating the recurrent loops. In this case just three iterations are used.\n",
        "out0 = rnn0([inp_cost, inp_params, inp_h, inp_c])\n",
        "out1 = rnn0(out0)\n",
        "out2 = rnn0(out1)\n",
        "\n",
        "# Definition of a loss function driving the training of the LSTM\n",
        "loss = tf.keras.layers.average([0.15 * out0[0], 0.35 * out1[0], 0.5 * out2[0]])\n",
        "\n",
        "# Definition of a Keras Model\n",
        "model = tf.keras.Model(\n",
        "    inputs=[inp_cost, inp_params, inp_h, inp_c], outputs=[out0[1], out1[1], out2[1], loss]\n",
        ")\n",
        "\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-2ZZ3ng5W7k_"
      },
      "source": [
        "::: {.rst-class}\n",
        "sphx-glr-script-out\n",
        "\n",
        "Out:\n",
        "\n",
        "``` {.none}\n",
        "Model: \"functional_1\"\n",
        "__________________________________________________________________________________________________\n",
        "Layer (type)                    Output Shape         Param #     Connected to                     \n",
        "==================================================================================================\n",
        "input_1 (InputLayer)            [(None, 1)]          0                                            \n",
        "__________________________________________________________________________________________________\n",
        "input_2 (InputLayer)            [(None, 2)]          0                                            \n",
        "__________________________________________________________________________________________________\n",
        "input_3 (InputLayer)            [(None, 2)]          0                                            \n",
        "__________________________________________________________________________________________________\n",
        "input_4 (InputLayer)            [(None, 2)]          0                                            \n",
        "__________________________________________________________________________________________________\n",
        "qrnn (QRNN)                     [(1, 1),             48         input_1[0][0]                    \n",
        "                                 (None, 2),                     input_2[0][0]                    \n",
        "                                 (None, 2),                     input_3[0][0]                    \n",
        "                                 (None, 2)]                     input_4[0][0]                    \n",
        "                                                                qrnn[0][0]                       \n",
        "                                                                qrnn[0][1]                       \n",
        "                                                                qrnn[0][2]                       \n",
        "                                                                qrnn[0][3]                       \n",
        "                                                                qrnn[1][0]                       \n",
        "                                                                qrnn[1][1]                       \n",
        "                                                                qrnn[1][2]                       \n",
        "                                                                qrnn[1][3]                       \n",
        "__________________________________________________________________________________________________\n",
        "tf.math.multiply (TFOpLambda)   (1, 1)               0           qrnn[0][0]                       \n",
        "__________________________________________________________________________________________________\n",
        "tf.math.multiply_1 (TFOpLambda) (1, 1)               0           qrnn[1][0]                       \n",
        "__________________________________________________________________________________________________\n",
        "tf.math.multiply_2 (TFOpLambda) (1, 1)               0           qrnn[2][0]                       \n",
        "__________________________________________________________________________________________________\n",
        "average_147 (Average)           (1, 1)               0           tf.math.multiply[0][0]           \n",
        "                                                                tf.math.multiply_1[0][0]         \n",
        "                                                                tf.math.multiply_2[0][0]         \n",
        "==================================================================================================\n",
        "Total params: 48\n",
        "Trainable params: 48\n",
        "Non-trainable params: 0\n",
        "```\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "luGzuKmdW7k_"
      },
      "source": [
        "A basic training routine for the `Keras Model` just created:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "yEVE26ZhW7k_",
        "outputId": "cd4bf069-61ba-4143-bfc4-14445747121c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Step 1 - Loss = [[-1.5563084]] - Cost = -4.762684301954698\n",
            "Step 2 - Loss = [[-1.6817842]] - Cost = -5.2186746079577375\n",
            "Step 3 - Loss = [[-1.852343]] - Cost = -5.619320227132842\n",
            "Step 4 - Loss = [[-1.7650172]] - Cost = -5.087988561321112\n",
            "Step 5 - Loss = [[-1.8075794]] - Cost = -5.27081311956832\n",
            "Final Loss: [[-1.8075794]]\n",
            "Final Outs:\n",
            " >out0: [[-0.20591183  0.15651065]]\n",
            " >out1: [[-0.69982886  0.28272453]]\n",
            " >out2: [[-0.9001374   0.14570975]]\n",
            " >Loss: [[-1.8075794]]\n"
          ]
        }
      ],
      "source": [
        "p = 1\n",
        "\n",
        "inp_costA = tf.zeros(shape=(1, 1))\n",
        "inp_paramsA = tf.zeros(shape=(1, 2 * p))\n",
        "inp_hA = tf.zeros(shape=(1, 2 * p))\n",
        "inp_cA = tf.zeros(shape=(1, 2 * p))\n",
        "\n",
        "inputs = [inp_costA, inp_paramsA, inp_hA, inp_cA]\n",
        "\n",
        "opt = tf.keras.optimizers.Adam(learning_rate=0.2)\n",
        "step = 5\n",
        "\n",
        "for _ in range(step):\n",
        "    with tf.GradientTape() as tape:\n",
        "        pred = model(inputs)\n",
        "        loss = pred[3]\n",
        "\n",
        "    gradients = tape.gradient(loss, model.trainable_variables)\n",
        "    opt.apply_gradients(zip(gradients, model.trainable_variables))\n",
        "    print(\n",
        "        f\"Step {_+1} - Loss = {loss} - Cost = {qaoa_from_graph(_graph, n_layers=p)(np.reshape(pred[2].numpy(),(2, p)))}\"\n",
        "    )\n",
        "\n",
        "print(\"Final Loss:\", loss.numpy())\n",
        "print(\"Final Outs:\")\n",
        "for t, s in zip(pred, [\"out0\", \"out1\", \"out2\", \"Loss\"]):\n",
        "    print(f\" >{s}: {t.numpy()}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JyN1UGdTW7k_"
      },
      "source": [
        "::: {.rst-class}\n",
        "sphx-glr-script-out\n",
        "\n",
        "Out:\n",
        "\n",
        "``` {.none}\n",
        "Step 1 - Loss = [[-1.5563084]] - Cost = -4.762684301954701\n",
        "Step 2 - Loss = [[-1.5649065]] - Cost = -4.799981173473755\n",
        "Step 3 - Loss = [[-1.5741502]] - Cost = -4.840036354736862\n",
        "Step 4 - Loss = [[-1.5841404]] - Cost = -4.883246647056216\n",
        "Step 5 - Loss = [[-1.5948243]] - Cost = -4.929228976649736\n",
        "Final Loss: [[-1.5948243]]\n",
        "Final Outs:\n",
        ">out0: [[-0.01041588  0.01016874]]\n",
        ">out1: [[-0.04530389  0.38148248]]\n",
        ">out2: [[-0.10258182  0.4134117 ]]\n",
        ">Loss: [[-1.5948243]]\n",
        "```\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dQcZkqAcW7k_"
      },
      "source": [
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "This code works only for a single graph at a time, since a graph was\n",
        "needed to create the `QRNN` `Keras Layer` named `rnn0`. Thus, in order\n",
        "to actually train the RNN network for multiple graphs, the above\n",
        "training routine must be modified. Otherwise, you could find a way to\n",
        "define the model to accept as input a whole dataset of graphs, and not\n",
        "just a single one. Still, this might prove particularly hard, since\n",
        "TensorFlow deals with tensors, and is not able to directly manage other\n",
        "data structures, like graphs or functions taking graphs as input, like\n",
        "`qaoa_from_graph`.\n",
        ":::\n",
        "\n",
        "About the author\n",
        "================\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since end of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "q47oDQ0JXZSS",
        "outputId": "ed81c4d3-fbd4-478c-feb8-2e3853683d60"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1701023950.165454\n",
            "Sun Nov 26 18:39:10 2023\n"
          ]
        }
      ]
    }
  ],
  "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.9.17"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}