--- a
+++ b/Code/All PennyLane QML Demos/26 Learn QNNs 210.2s kkawchak.ipynb
@@ -0,0 +1,1947 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "2eG4NG-MW7k4",
+        "outputId": "a21ced57-ae5d-4584-abb4-283c047eb428"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since beginning of run: 1701021597.313174\n",
+            "Sun Nov 26 17:59:57 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": 28,
+      "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": 29,
+      "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": 30,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 516
+        },
+        "id": "sT8W61vWW7k7",
+        "outputId": "b5ef7fa4-e75a-47eb-82d8-6254ed445ff2"
+      },
+      "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 = 7\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": 31,
+      "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": 32,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "_M3VTQRpW7k7",
+        "outputId": "1f47ab70-5a9e-4f05-99fc-4774ba27a4cf"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tf.Tensor(-3.1932679572555784, 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": 33,
+      "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": 34,
+      "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": 35,
+      "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": 36,
+      "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": 37,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "U3LB5fBVW7k8",
+        "outputId": "278fd59f-7039-44e0-982a-b2e0d597a4c8"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1\n",
+            " > Graph 1/20 - Loss: -1.6641689538955688\n",
+            " > Graph 6/20 - Loss: -1.4287620782852173\n",
+            " > Graph 11/20 - Loss: -1.3801934719085693\n",
+            " > Graph 16/20 - Loss: -1.2876912355422974\n",
+            " >> Mean Loss during epoch: -1.7656798183917999\n",
+            "Epoch 2\n",
+            " > Graph 1/20 - Loss: -2.0880496501922607\n",
+            " > Graph 6/20 - Loss: -1.502755880355835\n",
+            " > Graph 11/20 - Loss: -1.3986393213272095\n",
+            " > Graph 16/20 - Loss: -1.3164150714874268\n",
+            " >> Mean Loss during epoch: -1.830520111322403\n",
+            "Epoch 3\n",
+            " > Graph 1/20 - Loss: -2.1370296478271484\n",
+            " > Graph 6/20 - Loss: -1.4908565282821655\n",
+            " > Graph 11/20 - Loss: -1.3993809223175049\n",
+            " > Graph 16/20 - Loss: -1.32102370262146\n",
+            " >> Mean Loss during epoch: -1.8355653047561646\n",
+            "Epoch 4\n",
+            " > Graph 1/20 - Loss: -2.1322379112243652\n",
+            " > Graph 6/20 - Loss: -1.4994161128997803\n",
+            " > Graph 11/20 - Loss: -1.3980844020843506\n",
+            " > Graph 16/20 - Loss: -1.3252378702163696\n",
+            " >> Mean Loss during epoch: -1.8335859596729278\n",
+            "Epoch 5\n",
+            " > Graph 1/20 - Loss: -2.1243948936462402\n",
+            " > Graph 6/20 - Loss: -1.5013129711151123\n",
+            " > Graph 11/20 - Loss: -1.3975803852081299\n",
+            " > Graph 16/20 - Loss: -1.325676679611206\n",
+            " >> Mean Loss during epoch: -1.8336702287197113\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": 38,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 516
+        },
+        "id": "iBlg7nwWW7k8",
+        "outputId": "02683683-299d-4e3a-84fc-cc6e277a66b6"
+      },
+      "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": 39,
+      "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": 40,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 453
+        },
+        "id": "XlrZtF4aW7k9",
+        "outputId": "8fa0780d-9f7c-4ba0-bd86-554d3af648da"
+      },
+      "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": 41,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "JUa6RL_JW7k9",
+        "outputId": "99477710-7a48-4ba7-8785-1f499e89dde4"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Step 1 - Loss = -4.170080496283098\n",
+            "Step 2 - Loss = -4.675035876642076\n",
+            "Step 3 - Loss = -5.099499088193464\n",
+            "Step 4 - Loss = -5.403885327056364\n",
+            "Step 5 - Loss = -5.595292031792333\n",
+            "Step 6 - Loss = -5.704951974646541\n",
+            "Step 7 - Loss = -5.764256097617734\n",
+            "Step 8 - Loss = -5.795331977029804\n",
+            "Step 9 - Loss = -5.811387524394411\n",
+            "Step 10 - Loss = -5.819665291205046\n",
+            "Step 11 - Loss = -5.8239672171224806\n",
+            "Step 12 - Loss = -5.8262453708807325\n",
+            "Step 13 - Loss = -5.827491260066166\n",
+            "Step 14 - Loss = -5.828206256116937\n",
+            "Step 15 - Loss = -5.828643789480292\n",
+            "Final cost function: -5.828932361904981\n",
+            "Optimized angles: [[ 0.5865477 ]\n",
+            " [-0.32288585]]\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": 42,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 453
+        },
+        "id": "h1101um-W7k9",
+        "outputId": "6234e57f-0166-4eb1-a758-27e0f9a1b0b5"
+      },
+      "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": 43,
+      "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": 44,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "vy_D1kNyW7k-",
+        "outputId": "f18c8edb-f4db-497c-c9f0-a7cb50ab48a0"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1\n",
+            " > Graph 1/15 - Loss: [[-1.4876363]]\n",
+            " > Graph 6/15 - Loss: [[-1.5198656]]\n",
+            " > Graph 11/15 - Loss: [[-1.6226677]]\n",
+            " >> Mean Loss during epoch: -1.7711441119511921\n",
+            "Epoch 2\n",
+            " > Graph 1/15 - Loss: [[-1.8782666]]\n",
+            " > Graph 6/15 - Loss: [[-1.9808252]]\n",
+            " > Graph 11/15 - Loss: [[-1.8801485]]\n",
+            " >> Mean Loss during epoch: -2.116814629236857\n",
+            "Epoch 3\n",
+            " > Graph 1/15 - Loss: [[-1.8955324]]\n",
+            " > Graph 6/15 - Loss: [[-1.9727923]]\n",
+            " > Graph 11/15 - Loss: [[-1.8892248]]\n",
+            " >> Mean Loss during epoch: -2.1195581912994386\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": 45,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 516
+        },
+        "id": "yeKySIaCW7k-",
+        "outputId": "3ee22c49-6793-45ae-a5aa-f07bd94977e2"
+      },
+      "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": 46,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 453
+        },
+        "id": "3IAC8P0ZW7k-",
+        "outputId": "eb9622c0-c532-4d8f-9c23-5c9ddb4f80cd"
+      },
+      "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": 47,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 476
+        },
+        "id": "c26_87lAW7k-",
+        "outputId": "5da41d92-28e4-4986-f1ec-885991b07c50"
+      },
+      "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": 48,
+      "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": 49,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "fGqHsQ33W7k_",
+        "outputId": "357100ac-d664-4df7-a3e3-1fbffcdc79dc"
+      },
+      "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": 50,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "yEVE26ZhW7k_",
+        "outputId": "c945f4e6-5fa5-47bd-dddb-48f7111bfcd9"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Step 1 - Loss = [[-1.5563084]] - Cost = -4.762684301954698\n",
+            "Step 2 - Loss = [[-1.5649065]] - Cost = -4.799981173473759\n",
+            "Step 3 - Loss = [[-1.5741502]] - Cost = -4.840036354736864\n",
+            "Step 4 - Loss = [[-1.5841404]] - Cost = -4.883246618039306\n",
+            "Step 5 - Loss = [[-1.5948243]] - Cost = -4.929228955313207\n",
+            "Final Loss: [[-1.5948243]]\n",
+            "Final Outs:\n",
+            " >out0: [[-0.01041588  0.01016874]]\n",
+            " >out1: [[-0.04530389  0.38148248]]\n",
+            " >out2: [[-0.10258181  0.41341168]]\n",
+            " >Loss: [[-1.5948243]]\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.01)\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": "fd61e113-a0ba-4b8b-fc0f-b710a8ebdd74"
+      },
+      "execution_count": 51,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since end of run: 1701021807.473456\n",
+            "Sun Nov 26 18:03:27 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
+}
\ No newline at end of file