Quantum_Models_as_Fourier_Series.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPuJGCKy67v5kEG6p2uZMpf",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MonitSharma/Learn-Quantum-Machine-Learning/blob/main/Quantum_Models_as_Fourier_Series.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Quantum Models as Fourier Series"
      ],
      "metadata": {
        "id": "Npd8h7M96kmt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "This tutorial is based on the paper **The effect of data encoding on the expressive power of variational quantum machine learning models** by [Schuld, Sweke, and Meyer (2020)](https://arxiv.org/abs/2008.08605)"
      ],
      "metadata": {
        "id": "BJxNTmO26ova"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![](https://pennylane.ai/qml/_images/scheme_thumb.png)"
      ],
      "metadata": {
        "id": "IcTQxVUm63Rn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The paper talks about common quantum machine learning models designed for near-term quantum computers to Fourier Series. \n"
      ],
      "metadata": {
        "id": "PsDbJrE07xT0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Background\n",
        "\n",
        "Let's consider a quantum machine learning model of the form:\n",
        "$$ f_{\\boldsymbol \\theta}(x) = \\langle 0| U^{\\dagger}(x,\\boldsymbol \\theta) M U(x, \\boldsymbol \\theta) | 0 \\rangle $$\n",
        "\n",
        "Where $M$ is the measurement observable and $U(x, \\theta)$ is a variational quantum circuit that enocdes the data input $x$ and depends on a set of parameters $\\theta$. We will currently work on $1-$D data.\n",
        "\n",
        "------------\n",
        "---------------\n",
        "\n",
        "\n",
        "The circuit repeats itself $L$ layers, each consisting of a data-encoding block $S(x)$ and a trainable block $W(\\theta)$ that is controlled by the parameters $\\theta$. The data encoding block consists of gates of the form $\\mathcal{G}(x) = e^{-\\iota x H}$ where $H$ is the Hamiltonian. A prominent example are Pauli Rotations.\n",
        "\n",
        "\n",
        "\n",
        "-------------------------------\n",
        "------------------------------\n",
        "\n",
        "The paper shows that this quantum model can be written as a Fourier-type sum of the form\n",
        "\n",
        "$$ f_{ \\boldsymbol \\theta}(x) = \\sum_{\\omega \\in \\Omega} c_{\\omega}( \\boldsymbol \\theta) \\; e^{i  \\omega x}. $$\n",
        "\n",
        "As illustrated in the picture below, the \"encoding Hamiltonians\" in $S(x)$ determine the set of $\\Omega$ of available \"frequencies\" and the remainder of the cirucit, including the trainable parameters, determines the coefficients $c_{\\omega}$.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ohpH_d9g7_4I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![](https://pennylane.ai/qml/_images/scheme.png)"
      ],
      "metadata": {
        "id": "Wdix3pNy_dSx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The paper demonstrates many of its findings for a circuits in which $\\mathcal{G}(x)$ is a single-qubit Pauli rotation gate.\n",
        "\n",
        "\n",
        "For example, it shows that $r$ repetitions of a Pauli rotation-encoding gate in \"sequence\" (on the same qubit, but with multiple layers $r=L$) or in \"parallel\" (on $r$ different qubits with $L=1$) creates a quantum model that can be expessed as a *Fourier series* of the form:\n",
        "\n",
        "\n",
        "$$ f_{ \\boldsymbol \\theta}(x) = \\sum_{n \\in \\Omega} c_{n}(\\boldsymbol \\theta) e^{i  n x}, $$\n",
        "\n",
        "where $\\Omega = \\{ -r, \\dots, -1, 0, 1, \\dots, r\\}$ is a spectrun of consercutive integer-valued frequencies up to degree $r$."
      ],
      "metadata": {
        "id": "2mJ_Q3S___dQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import pennylane as qml\n",
        "from pennylane import numpy as np"
      ],
      "metadata": {
        "id": "W4OXMlmh_caU"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "DtDRUDxz6dwO"
      },
      "outputs": [],
      "source": [
        "np.random.seed(135)\n",
        "\n",
        "\n",
        "def square_loss(targets, predictions):\n",
        "  loss = 0\n",
        "  for t, p in zip(targets, predictions):\n",
        "    loss += (t - p) ** 2\n",
        "  loss = loss / len(targets)\n",
        "  return 0.5*loss\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Part 1: Fitting Fourier Series with serial Pauli-rotation encoding\n",
        "\n",
        "Let us consider circuits where the encoding gate gates repeated sequentially.\n",
        "\n",
        "For simplicity we will only look at single-qubit circuits:\n",
        "\n",
        "![](https://pennylane.ai/qml/_images/single_qubit_model.png)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "b4tF4UkDCGNP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define a target function\n",
        "\n",
        "We first define a taget function which will be used as a \"ground truth\" that the quantum model has to fit. It is a Fourier series of a specific degree.\n",
        "\n",
        "\n",
        "We also work with a rescaling factor for data by a hyperparameter `scaling`, which we will do in the quantum model as well "
      ],
      "metadata": {
        "id": "7K7CM1FVCbXC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "degree = 1 # since we are using a single qubit model it would be better to keep it to 1\n",
        "scaling = 1 # scaling factor for the data\n",
        "\n",
        "coeffs = [0.15 + 0.15j]*degree # coefficient of the non-zero frequencies\n",
        "\n",
        "coeff0 = 0.1 # coefficient of zero frequency\n",
        "\n",
        "\n",
        "def target_function(x):\n",
        "  \"\"\"\n",
        "  Generate a truncated Fourier series, where the data gets re-scaled\n",
        "  \"\"\"\n",
        "  res = coeff0\n",
        "  for idx, coeff in enumerate(coeffs):\n",
        "    exponent = np.complex128(scaling * (idx + 1) * x * 1j)\n",
        "    conj_coeff = np.conjugate(coeff)\n",
        "    res += coeff * np.exp(exponent) + conj_coeff * np.exp(-exponent)\n",
        "  return np.real(res)"
      ],
      "metadata": {
        "id": "CtNRTC1SCE6l"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's see how it looks"
      ],
      "metadata": {
        "id": "lO8jTFVHDvJT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.linspace(-6, 6, 70, requires_grad=False)\n",
        "target_y = np.array([target_function(x_) for x_ in x], requires_grad=False)\n",
        "\n",
        "plt.plot(x, target_y, c='black')\n",
        "plt.scatter(x, target_y, facecolor='white', edgecolor='black')\n",
        "plt.ylim(-1, 1)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "bmZUJPOxDt4J",
        "outputId": "7c18ea14-bd0c-429a-cf6b-6a12a2ceaf6a"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define the serial quantum model\n",
        "\n",
        "We now define the quantum model itself:"
      ],
      "metadata": {
        "id": "7Wk7nhnbEw0k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scaling = 1\n",
        "\n",
        "\n",
        "dev = qml.device('default.qubit', wires =1)\n",
        "\n",
        "def S(x):\n",
        "  \"\"\"Data encodng circuit block\"\"\"\n",
        "  qml.RX(scaling * x, wires = 0)\n",
        "\n",
        "def W(theta):\n",
        "  \"\"\"Trainable circuit block\"\"\"\n",
        "  qml.Rot(theta[0], theta[1], theta[2], wires=0)\n",
        "\n",
        "@qml.qnode(dev)\n",
        "\n",
        "def serial_quantum_model(weights,x):\n",
        "\n",
        "  for theta in weights[:-1]:\n",
        "    W(theta)\n",
        "    S(x)\n",
        "\n",
        "  # (L+1)'th unitary\n",
        "  W(weights[-1])\n",
        "\n",
        "  return qml.expval(qml.PauliZ(wires=0))"
      ],
      "metadata": {
        "id": "Nby8LTLVDyRz"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can run the following cell multiple times, each time sampling different weights, and therefore different quantum models."
      ],
      "metadata": {
        "id": "8U8fDFlGFpoz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "r = 1 # number of times the encoding gets repeated (here equal to the number of layers)\n",
        "weights = 2 * np.pi * np.random.random(size=(r+1, 3), requires_grad=True) # some random initial weights\n",
        "\n",
        "x = np.linspace(-6, 6, 70, requires_grad=False)\n",
        "random_quantum_model_y = [serial_quantum_model(weights, x_) for x_ in x]\n",
        "\n",
        "plt.plot(x, random_quantum_model_y, c='blue')\n",
        "plt.ylim(-1,1)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "UX-8mzCdFdKu",
        "outputId": "0514482e-cf81-458b-c472-d78adb8e942f"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "No matter what weights are picked, the single qubit model for L=1 will always be a sine function of a fixed frequency. The weights merely influence the amplitude, y-shift, and phase of the sine.\n",
        "\n",
        "This observation is formally derived in Section II.A of the paper."
      ],
      "metadata": {
        "id": "pRiQ8hZIN6Pf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's look at the circuit we just made"
      ],
      "metadata": {
        "id": "L8ZVTJ__N8rZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(qml.draw(serial_quantum_model)(weights, x[-1]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zuYFgydOFsLQ",
        "outputId": "fca5671b-dc77-4318-a09c-b005c950893a"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0: ──Rot(4.16,2.06,1.23)──RX(6.00)──Rot(5.42,4.91,0.99)─┤  <Z>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Fit the model to the targer\n",
        "\n",
        "The next step is to optimize the weights in order to fit the ground truth"
      ],
      "metadata": {
        "id": "EXm8oBHUOCEw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cost(weights, x, y):\n",
        "    predictions = [serial_quantum_model(weights, x_) for x_ in x]\n",
        "    return square_loss(y, predictions)\n",
        "\n",
        "max_steps = 50\n",
        "opt = qml.AdamOptimizer(0.3)\n",
        "batch_size = 25\n",
        "cst = [cost(weights, x, target_y)]  # initial cost\n",
        "\n",
        "for step in range(max_steps):\n",
        "\n",
        "    # Select batch of data\n",
        "    batch_index = np.random.randint(0, len(x), (batch_size,))\n",
        "    x_batch = x[batch_index]\n",
        "    y_batch = target_y[batch_index]\n",
        "\n",
        "    # Update the weights by one optimizer step\n",
        "    weights, _, _ = opt.step(cost, weights, x_batch, y_batch)\n",
        "\n",
        "    # Save, and possibly print, the current cost\n",
        "    c = cost(weights, x, target_y)\n",
        "    cst.append(c)\n",
        "    if (step + 1) % 10 == 0:\n",
        "        print(\"Cost at step {0:3}: {1}\".format(step + 1, c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MzciLrhoJF5O",
        "outputId": "5894dce1-1bf1-4165-c172-bb08cbf832c5"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost at step  10: 0.012118291191329796\n",
            "Cost at step  20: 0.013705000385948182\n",
            "Cost at step  30: 0.0019061116574147416\n",
            "Cost at step  40: 0.0032765567424896704\n",
            "Cost at step  50: 0.0006326300599443154\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To continue training, you may just run the above cell again. Once you are happy, you can use the trained model to predict function values, and compare them with the ground truth."
      ],
      "metadata": {
        "id": "o4mag-X3OMq5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = [serial_quantum_model(weights, x_) for x_ in x]\n",
        "\n",
        "plt.plot(x, target_y, c='black')\n",
        "plt.scatter(x, target_y, facecolor='white', edgecolor='black')\n",
        "plt.plot(x, predictions, c='blue')\n",
        "plt.ylim(-1,1)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "_yDrdh4GOLD2",
        "outputId": "42f6a79b-8c39-4cf3-f226-a2b528a4bcd0"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let’s also have a look at the cost during training."
      ],
      "metadata": {
        "id": "G1PVUoBUORWE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(range(len(cst)), cst)\n",
        "plt.ylabel(\"Cost\")\n",
        "plt.xlabel(\"Step\")\n",
        "plt.ylim(0, 0.23)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "xXCXlkZIOPqf",
        "outputId": "9597299e-5623-41df-98fb-f8ac234d7855"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "With the initial settings and enough training steps, the quantum model learns to fit the ground truth perfectly. This is expected, since the number of Pauli-rotation-encoding gates and the degree of the ground truth Fourier series are both one.\n",
        "\n",
        "If the ground truth’s degree is larger than the number of layers in the quantum model, the fit will look much less accurate. And finally, we also need to have the correct scaling of the data: if one of the models changes the scaling parameter (which effectively scales the frequencies), fitting does not work even with enough encoding repetitions."
      ],
      "metadata": {
        "id": "jNpbsTzHOWDh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part II: Fitting the Fourier series with parallel Pauli-rotation encoding\n",
        "\n",
        "Our next task is to repeat the function-fitting experiment for a circuit where the Pauli rotation gate gets repeated $r$ times on different qubits, using a single layer $L=1$.\n",
        "\n",
        "As shown in the paper, we expect similar results to the serial model: a Fourier series of degree $r$ can only be fitted if there are at least r repetitions of the encoding gate in the quantum model. However, in practice this experiment is a bit harder, since the dimension of the trainable unitaries $W$ grows quickly with the number of qubits.\n",
        "\n",
        "In the paper, the investigations are made with the assumption that the purple trainable blocks $W$ are arbitrary unitaries. We could use the ArbitraryUnitary template, but since this template requires a number of parameters that grows exponentially with the number of qubits ($4^L−1$ to be precise), this quickly becomes cumbersome to train.\n",
        "\n",
        "We therefore follow Figure 4 in the paper and use an ansatz for $W$.\n",
        "\n"
      ],
      "metadata": {
        "id": "l07bIlXkOXj2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![](https://pennylane.ai/qml/_images/parallel_model.png)"
      ],
      "metadata": {
        "id": "i9AmyCzeOvlj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define the parallel quantum model\n",
        "\n",
        "The ansatz is PennyLane’s layer structure called `StronglyEntanglingLayers`, and as the name suggests, it has itself a user-defined number of layers (which we will call “ansatz layers” to avoid confusion)."
      ],
      "metadata": {
        "id": "I_UEaqVVOyhR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pennylane.templates import StronglyEntanglingLayers"
      ],
      "metadata": {
        "id": "LOO2eqOOOUcf"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let’s have a quick look at the ansatz itself for 3 qubits by making a dummy circuit of 2 ansatz layers:"
      ],
      "metadata": {
        "id": "-D9NYqDGO7k9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_ansatz_layers = 2\n",
        "n_qubits = 3\n",
        "\n",
        "dev = qml.device('default.qubit', wires=4)\n",
        "\n",
        "@qml.qnode(dev)\n",
        "def ansatz(weights):\n",
        "    StronglyEntanglingLayers(weights, wires=range(n_qubits))\n",
        "    return qml.expval(qml.Identity(wires=0))\n",
        "\n",
        "weights_ansatz = 2 * np.pi * np.random.random(size=(n_ansatz_layers, n_qubits, 3))\n",
        "print(qml.draw(ansatz, expansion_strategy=\"device\")(weights_ansatz))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yJIBuf91O6Qm",
        "outputId": "e6a2cde0-0177-4a27-b935-0b3741643c51"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0: ──Rot(3.42,4.06,5.87)─╭●────╭X──Rot(2.65,0.88,3.56)─╭●─╭X────┤  <I>\n",
            "1: ──Rot(3.20,3.56,4.62)─╰X─╭●─│───Rot(0.70,2.86,0.89)─│──╰●─╭X─┤     \n",
            "2: ──Rot(6.19,1.50,2.51)────╰X─╰●──Rot(4.89,0.55,6.19)─╰X────╰●─┤     \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we define the actual quantum model\n"
      ],
      "metadata": {
        "id": "8vlbhtkwO_cX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scaling = 1\n",
        "r = 3\n",
        "\n",
        "dev = qml.device('default.qubit', wires=r)\n",
        "\n",
        "def S(x):\n",
        "    \"\"\"Data-encoding circuit block.\"\"\"\n",
        "    for w in range(r):\n",
        "        qml.RX(scaling * x, wires=w)\n",
        "\n",
        "def W(theta):\n",
        "    \"\"\"Trainable circuit block.\"\"\"\n",
        "    StronglyEntanglingLayers(theta, wires=range(r))\n",
        "\n",
        "\n",
        "@qml.qnode(dev)\n",
        "def parallel_quantum_model(weights, x):\n",
        "\n",
        "    W(weights[0])\n",
        "    S(x)\n",
        "    W(weights[1])\n",
        "\n",
        "    return qml.expval(qml.PauliZ(wires=0))"
      ],
      "metadata": {
        "id": "vlkySOdKO-ZD"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Again, you can sample random weights and plot the model function:"
      ],
      "metadata": {
        "id": "1GPvn8iVPEkP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "trainable_block_layers = 3\n",
        "weights = 2 * np.pi * np.random.random(size=(2, trainable_block_layers, r, 3), requires_grad=True)\n",
        "\n",
        "x = np.linspace(-6, 6, 70, requires_grad=False)\n",
        "random_quantum_model_y = [parallel_quantum_model(weights, x_) for x_ in x]\n",
        "\n",
        "plt.plot(x, random_quantum_model_y, c='blue')\n",
        "plt.ylim(-1,1)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "cxqKeti1PDJP",
        "outputId": "b091140c-7e1d-49f8-de56-8cd6bf098c20"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training the model\n",
        "\n",
        "Training the model is done exactly as before, but it may take a lot longer this time. We set a default of 25 steps, which you should increase if necessary. Small models of <6 qubits usually converge after a few hundred steps at most—but this depends on your settings."
      ],
      "metadata": {
        "id": "_05tBpj1PIDv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def cost(weights, x, y):\n",
        "    predictions = [parallel_quantum_model(weights, x_) for x_ in x]\n",
        "    return square_loss(y, predictions)\n",
        "\n",
        "max_steps = 50\n",
        "opt = qml.AdamOptimizer(0.3)\n",
        "batch_size = 25\n",
        "cst = [cost(weights, x, target_y)]  # initial cost\n",
        "\n",
        "for step in range(max_steps):\n",
        "\n",
        "    # select batch of data\n",
        "    batch_index = np.random.randint(0, len(x), (batch_size,))\n",
        "    x_batch = x[batch_index]\n",
        "    y_batch = target_y[batch_index]\n",
        "\n",
        "    # update the weights by one optimizer step\n",
        "    weights, _, _ = opt.step(cost, weights, x_batch, y_batch)\n",
        "\n",
        "    # save, and possibly print, the current cost\n",
        "    c = cost(weights, x, target_y)\n",
        "    cst.append(c)\n",
        "    if (step + 1) % 10 == 0:\n",
        "        print(\"Cost at step {0:3}: {1}\".format(step + 1, c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mPHszjIkPGx0",
        "outputId": "d4db7d94-e9e4-4d28-89a4-ad0c41481f9a"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cost at step  10: 0.009506917011675093\n",
            "Cost at step  20: 0.0034526368411951923\n",
            "Cost at step  30: 0.0005179711491547088\n",
            "Cost at step  40: 0.00043014691439516637\n",
            "Cost at step  50: 0.00041654998322869947\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "predictions = [parallel_quantum_model(weights, x_) for x_ in x]\n",
        "\n",
        "plt.plot(x, target_y, c='black')\n",
        "plt.scatter(x, target_y, facecolor='white', edgecolor='black')\n",
        "plt.plot(x, predictions, c='blue')\n",
        "plt.ylim(-1,1)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 269
        },
        "id": "dc6qgjQNPN_U",
        "outputId": "5e7b3873-e96b-4a03-8287-1bd5d2775c14"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(range(len(cst)), cst)\n",
        "plt.ylabel(\"Cost\")\n",
        "plt.xlabel(\"Step\")\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "svNpBDFHPPxy",
        "outputId": "6dbe7a4e-7a59-466a-a72a-a07d4be85acb"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEJCAYAAACOr7BbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfXzT9bn4/1eST9L0/paipFUsEYRyUyUFmWdTqliHnjhnJ/BTxhlsPW6wTdzXcXa+/tAxHWxT1B30uG5sY+qo0m3WzdGJiAoq1OIQtSqtttgWBm2h921uP98/0oSWJm2KTdKW6/l48GiTvD/N+4M1F9f75nprVFVVEUIIIc6ijXQHhBBCjE4SIIQQQvglAUIIIYRfEiCEEEL4JQFCCCGEXxIghBBC+BXSAFFWVsa0adMwm81s2rRpwOs2m40lS5ZgNpuZP38+tbW1ADgcDlasWMGsWbOYPn06GzduDGU3hRBC+BGyAOFyuVi9ejU7d+6ksrKS7du3U1lZ2a/N1q1bSU5Oprq6mrVr17Ju3ToAduzYgc1m47333uPgwYP86le/8gUPIYQQ4aGE6geXl5djNpvJysoCYOnSpZSWljJjxgxfm9LSUu6//34ACgoKWLNmDaqqotFo6OzsxOl00t3djcFgICEhYdD3S0tLY/LkyaG6HSGEGJdqa2tpamry+1rIAkRDQwOZmZm+xxkZGRw4cCBgG0VRSExMpLm5mYKCAkpLS7nwwgvp6urikUceISUlZcB7FBUVUVRUBEBsbCwVFRWhuh0hhBiXLBZLwNdG5SR1eXk5Op2OY8eOUVNTw8MPP8ynn346oF1hYSEVFRVUVFQwYcKECPRUCCHGr5AFCJPJRF1dne9xfX09JpMpYBun00lrayupqan88Y9/5IYbbkCv15Oens5VV10l2YEQQoRZyAJEbm4uVVVV1NTUYLfbKS4uxmq19mtjtVrZtm0bACUlJeTl5aHRaLjooot45ZVXAOjs7GT//v1cdtlloeqqEEIIP0IWIBRFYcuWLeTn5zN9+nRuu+02srOzWb9+PS+88AIAq1atorm5GbPZzObNm31LYVevXk1HRwfZ2dnk5ubyjW98g9mzZ4eqq0IIIfzQjJdy3xaLRYahhBBimAb77ByVk9RCCCEiTwKEEEIIvyRAjKA9H52k7lRXpLshhBAjQgLECFFVle888w5b99VEuitCCDEiJECMkB6Hm26Hi+ZOe6S7IoQQI0ICxAg53eUJDC1dEiCEEOODBIgR4g0QpyVACCHGCQkQI6SlywHA6U5HhHsihBAjQwLECPEGCBliEkKMFxIgRoh3aKnT7sLmdEW4N0II8flJgBjEh8fbcLrcQbXtmzl4swkhhBjLJEAE8K/WHm785V5efO94UO1P9wkKMlEthBgPJEAE0NDShVuFhpbuoNr3zRpkoloIMR5IgAigsd0GwKmO4LKBli47ep3G970QQox1EiACOOkNEEHujD7dZeeilJje7yWDEEKMfRIgAvBmEMGWzmjpcnBJWiwgcxBCiPFBAkQA3gAR7Id9S7eDCxKNGPVaGWISQowLIQ0QZWVlTJs2DbPZ7DtOtC+bzcaSJUswm83Mnz+f2tpaAJ555hlycnJ8f7RaLYcOHQplVwfwDjE1BzEH4XartHTZSY4xkBxjkCEmIcS4ELIA4XK5WL16NTt37qSyspLt27dTWVnZr83WrVtJTk6murqatWvXsm7dOgBuv/12Dh06xKFDh3jqqae45JJLyMnJCVVX/WocxhxEe48TtwqJ0XqSYgySQQghxoWQBYjy8nLMZjNZWVkYDAaWLl1KaWlpvzalpaWsWLECgIKCAnbv3s3ZR2Rv376dpUuXhqqbAXkDRLfDRbd98J3RLd2egODJIPRBT2wLIcRoFrIA0dDQQGZmpu9xRkYGDQ0NAdsoikJiYiLNzc392jz77LMsW7bM73sUFRVhsViwWCw0NjaOWN/dbpWmDhtpcQYATg2REXiHlJJj9STHGGQntRBiXBjVk9QHDhwgJiaGmTNn+n29sLCQiooKKioqmDBhwoi97+kuO063yrQL4oGh90J4J7ITow0kxehlFZMQYlwIWYAwmUzU1dX5HtfX12MymQK2cTqdtLa2kpqa6nu9uLg4YPYQSo0dnuGlaRMTAGjutA3a3jvnkByjJyXWQGu3A7dbHfQaIYQY7UIWIHJzc6mqqqKmpga73U5xcTFWq7VfG6vVyrZt2wAoKSkhLy8PjcazG9ntdvPcc89FZP7hZJsnIFzmzSCGmFPwDiklxxhIijHgVqGtR4aZhBBjmxKyH6wobNmyhfz8fFwuFytXriQ7O5v169djsViwWq2sWrWK5cuXYzabSUlJobi42Hf966+/TmZmJllZWaHqYkDeCeppQQaI010ONBpIiNaTHKP3PZcUYwhtR4UQIoRCFiAAFi9ezOLFi/s9t2HDBt/3RqORHTt2+L32mmuuYf/+/aHsXkDeIaYp6XHotJogMgg7CUY9Oq2G5N6gcLrLziXEhryvQggRKqN6kjpSGtttxBp0xEUpJMcYgsogvJlDUu9X2QshhBjrJED4cbLdxoT4KABSYw1D1mNq6bL7hpN8GYSU/BZCjHESIPxobO/xBYiU2KEziJY+GUTfISYhhBjLJED40dhuIz3eCEBKnIHTQw4xnckg4o0KWo0ECCHE2CcBwo/hDzE5fHMPWq2GJCnYJ4QYByRAnKXH4aK9x+kLEMkxno1vDpfbb3uHy02HzekbWvJco5dJaiHEmCcB4izePRAT4noziLjB5xTObJLT+55LjjHIJLUQYsyTAHEW7zkQExLOTFJD4FVJ3kwhsU8G4RlikgxCCDG2SYA4y9kZhDdABKrH1NLtL4PQS0VXIcSYJwHiLN5d1Onx/QNEoKWu3hVO/eYgYiWDEEKMfRIgztLYbkOrgdS44AKEN1NIjD6TQSTF6LE53UMeNCSEEKOZBIizNLb3kBIbhU7rqSrrzQwCnU3tzRSSY/uuYpLNckKIsU8CxFka++yBANDrtCRGBz4EqKXbgV6nIdag8z13pqKrBAghxNglAeIsnl3UUf2eSxlks5y3DpP3HAvAt6talroKIcYyCRBnOXlWBgG99ZgCDTF1OkjqM//gbQ+SQQghxjYJEH243SpNHQECRKBVTF32fiuYQEp+CyHGBwkQfXhKaqi+PRBeqbEGTgX4sG/tPlOHySsp2ptByBCTEGLsCmmAKCsrY9q0aZjNZjZt2jTgdZvNxpIlSzCbzcyfP5/a2lrfa4cPH2bBggVkZ2cza9Ysenp6QtlV4Mwu6vSEgRnE6U47qqoOuMZfBmFQtMRFKTLEJIQY00IWIFwuF6tXr2bnzp1UVlayfft2Kisr+7XZunUrycnJVFdXs3btWtatWweA0+nkjjvu4Mknn+SDDz7g1VdfRa/X+3ubEXX2LmqvlFgDTrdKW7ez3/OqqvaePT2wb0mym1oIMcaFLECUl5djNpvJysrCYDCwdOlSSktL+7UpLS1lxYoVABQUFLB7925UVeWll15i9uzZzJkzB4DU1FR0Ot2A9xhpjR2eLMXfHAQMLLfR43Bjd7p9q5b6SpZ6TEKIMS5kAaKhoYHMzEzf44yMDBoaGgK2URSFxMREmpubOXLkCBqNhvz8fK644gp+/vOf+32PoqIiLBYLFouFxsbGz93nRt8Qk7Hf84F2U/s2yQXIIGQOQggxlimR7oA/TqeTffv28fbbbxMTE8O1117L3Llzufbaa/u1KywspLCwEACLxfK53/dkm41ova7fpjeA1FhPRhEoQATKID471fW5+ySEEJESsgzCZDJRV1fne1xfX4/JZArYxul00traSmpqKhkZGXzpS18iLS2NmJgYFi9ezDvvvBOqrvo09i5x7bvpDSA51pMhnB0gvHMM/uYgkmP0Qx5VKoQQo1nIAkRubi5VVVXU1NRgt9spLi7GarX2a2O1Wtm2bRsAJSUl5OXl+YaW3nvvPbq6unA6nbz22mvMmDEjVF318beLGs5kEGfvpj5zWNDADCIpxkBbjxNngJPohBBitAvZEJOiKGzZsoX8/HxcLhcrV64kOzub9evXY7FYsFqtrFq1iuXLl2M2m0lJSaG4uBiA5ORk7r77bnJzc9FoNCxevJgbb7wxVF31Odlu49L0uAHPRxt0ROt1w5qD8M5btHQ7SIsbGHSEEGK0C+kcxOLFi1m8eHG/5zZs2OD73mg0smPHDr/X3nHHHdxxxx2h7N4Aje02vjAl1e9r3r0QfZ05Tc7/JLW3jQQIIcRYJDupe9mcLlq7HQP2QHilxg0s2He6y0GMQUeUMnAJ7pmS37KSSQgxNkmA6NUYYBe1V3LMwHpMLV0Ov/MP3vaATFQLIcYsCRC9fLuo/UxSQ289Jj9DTP5WMEHfISbJIIQQY5MEiF5nymwY/b7uOROi/07q04MEiGQp+S2EGOMkQPQKVKjPKyXOQI+j/znTLV0Ov5vkAGINOvQ6jcxBCCHGLAkQvRrbbWg0Z5anni0lZmA9ppZuh98lrgAajYakGIOcCSGEGLMkQPRq7LCREmNAr/P/V3J2PSa3W6XFT6nvvpJjAp9lLYQQo50EiF6Nfo4a7Ss1zptBeD7w23ucuFVIjA5chjw5xiDnUgshxiwJEL38nUXdV0pvuQ3vstWWbu8u6sEyCCn5LYQYuyRA9GoaMkD0H2LyTj57C/n5kxwrJb+FEGOXBAg8J8N5CvX5X+IKkGBUULQa3xDTYKW+vbyT1P6OKhVCiNFOAgTQ2u3A7nIPmkFoNBqSYw2c6ugdYvIGiEHnIPQ43SodNmfANkIIMVpJgGDoXdReqbFn6jENVurby5tdyG5qIcRYJAGCvruoBw8QKbFnJp1PdznQaCBhiFVMnrYyUS2EGHskQDD0Lmqv5D71mFq67CQY9ei0msDtezfRyUS1EGIskgDBMIeYOjxtT3cF3kXtdWaISTIIIcTYIwECzy7qKEVLfNTg5yelxHqOEXW43L2VXAPPP3jbg5T8FkKMTSENEGVlZUybNg2z2cymTZsGvG6z2ViyZAlms5n58+dTW1sLQG1tLdHR0eTk5JCTk8Odd94Zym56lrgmRKHRBB4uAk8GAZ45hZYgMojEaD0aDZySISYhxBgUsiNHXS4Xq1evZteuXWRkZJCbm4vVamXGjBm+Nlu3biU5OZnq6mqKi4tZt24dzz77LABTpkzh0KFDoepePyfbe4acoIYzu6lPddo53WXH7Of86r50Wg0JRr0MMQkhxqSQZRDl5eWYzWaysrIwGAwsXbqU0tLSfm1KS0tZsWIFAAUFBezevTsim8qGqsPk5d01farD3lvqe/AMArwF+ySDEEKMPSELEA0NDWRmZvoeZ2Rk0NDQELCNoigkJibS3NwMQE1NDZdffjlXX301e/fu9fseRUVFWCwWLBYLjY2N59zXoXZRe6X2ZhAn2nvosDkH3QPhJSW/hRBjVciGmD6PCy+8kM8++4zU1FQOHjzIV77yFT744AMSEhL6tSssLKSwsBAAi8VyTu9ld7o53eUIKoPwTjrXNHYCDDkH4W3T2GEbsp0QQow2IcsgTCYTdXV1vsf19fWYTKaAbZxOJ62traSmphIVFUVqaioAc+fOZcqUKRw5ciQk/WzqCG6JK5wJCJ/0BojEIDIIKfkthBirQhYgcnNzqaqqoqamBrvdTnFxMVartV8bq9XKtm3bACgpKSEvLw+NRkNjYyMul+doz08//ZSqqiqysrJC0s9gd1EDKDotidF6PmnsAILLIGSISQgxVoVsiElRFLZs2UJ+fj4ul4uVK1eSnZ3N+vXrsVgsWK1WVq1axfLlyzGbzaSkpFBcXAzA66+/zvr169Hr9Wi1Wp588klSUlJC0s/JabH87j9ymZ2RGFT71FgDNU3eIaZgMgg9nXYXdqcbgyLbToQQY4dGHSe1qC0WCxUVFSF/n4L/fZOKo6cB2LduIRnJMYO2f3r/Ue59/n3K//ta0hOGnggXQohwGuyzU/5JO0zeiWoY/CwIrzMF+2QeQggxtkiAGCbv2dR6nYZYg27I9t55ilNSbkMIMcZIgBgmb0aQFGMYsjSHtx1IwT4hxNgjAWKYvENMg50k15d397UMMQkhxhoJEMPkHWIKZgVT33ZyaJAQYqyRADFM3oJ9wdRhAjDqdRj12mENMdU0dfJ+Q+s59U8IIUaKBIhhSokZXgbhbTucIaZNOz/knpLDw+6bEEKMJAkQw5QS552kDi6DAM+5EG3dwQeI050OOWRICBFxEiCGKTXWQLxRYXJabNDXxBsV2nucQbdv63HQ1iOT2kKIyBqV1VxHM6Nex94fLiTeGHwGEW/Uc7K9J+j27T1OuuwunC43ik5iuBAiMuTT5xwkxRjQaYfeA+E13AyivTd7GM41Qggx0iRAhMFwAoSqqnTYPG0lQAghIkkCRBjEG/W09ziCOk610+7C3dtM5iGEEJEkASIM4o0KDpeKzekesm17n6AwnJVPQggx0iRAhIF3QjuYjKDvsFKbDDEJISJIAkQYJBg9i8WCmVPol0HIEJMQIoKCChDLly8P6jnhX/wwAkTfrEEmqYUQkRRUgPjggw/6PXa5XBw8eHDI68rKypg2bRpms5lNmzYNeN1ms7FkyRLMZjPz58+ntra23+ufffYZcXFxPPTQQ8F0c9TyDjG1D3eISeYghBARNGiA2LhxI/Hx8Rw+fJiEhAQSEhKIj48nPT2dm2++edAf7HK5WL16NTt37qSyspLt27dTWVnZr83WrVtJTk6murqatWvXsm7dun6v33333Xz5y18+x1sbPYaTQfQNIpJBCCEiadAA8aMf/Yj29nbuuece2traaGtro729nebmZjZu3DjoDy4vL8dsNpOVlYXBYGDp0qWUlpb2a1NaWsqKFSsAKCgoYPfu3b6loM8//zyXXHIJ2dnZn+f+RoVzySASo/UyByGEiKighphuuukmOjs7AXj66ae5++67OXr06KDXNDQ0kJmZ6XuckZFBQ0NDwDaKopCYmEhzczMdHR387Gc/47777hv0PYqKirBYLFgsFhobG4O5lYgYbgah02qYmBAlQ0xCiIgKKkB8+9vfJiYmhnfffZeHH36YKVOm8PWvfz1knbr//vtZu3YtcXFxg7YrLCykoqKCiooKJkyYELL+fF5xBgWNJrhlq+09TuKiFBKj9TLEJISIqKCK9SmKgkajobS0lDVr1rBq1Sq2bt066DUmk4m6ujrf4/r6ekwmk982GRkZOJ1OWltbSU1N5cCBA5SUlPDDH/6QlpYWtFotRqORNWvWnMMtRp5WqyHOoAQ9xBRvVIg36jnRFnyBPyGEGGlBBYj4+Hg2btzIU089xd69e3G73Tgcg3/Y5ebmUlVVRU1NDSaTieLiYv74xz/2a2O1Wtm2bRsLFiygpKSEvLw8NBoNe/fu9bW5//77iYuLG7PBwSvYekztPQ7ijXoSjArVJyWDEEJETlBDTM8++yxRUVH89re/5YILLqC+vp577rln0GsURWHLli3k5+czffp0brvtNrKzs1m/fj0vvPACAKtWraK5uRmz2czmzZv9LoUdL7z1mIbizSASZJJaCBFhGjWYCnLAiRMnePvttwGYN28e6enpIe3YcFksFioqKiLdjYAK/vdNDIqWP37rykHbLX5sL5OSjEy7IJ4nX/uU6ge/jEYTfGlxIYQYjsE+O4PKIJ577jnmzZvHjh07eO6555g/fz4lJSUj2snxLughJpt3iEmPy63SZXeFoXdCCDFQUHMQDz74IG+//bYva2hsbOS6666joKAgpJ0bT+KNemqaOods513F1LfAX2yUHPwnhAi/oDIIt9vdb0gpNTUVt3vo0tXijGAyCFVV+8xBBL93QgghQiGof5recMMN5Ofns2zZMsAzab148eKQdmy88UxSD/5h3+1w4XKrxBv1ZzII2SwnhIiQQQNEdXU1J06c4Be/+AV//vOf2bdvHwALFizg9ttvD0sHx4t4o4Ld5abH4cKo1/lt4w0g8UZlWCXChRAiFAYdYrrrrrtISEgA4Ktf/SqbN29m8+bN3HLLLdx1111h6eB4EcwHvncZrHeZK8iZEEKIyBk0QJw4cYJZs2YNeH7WrFkDSnOLwQVzqpy3FEeCUe+r3yRDTEKISBk0QLS0tAR8rbu7e8Q7M54FU7Cv/xCTN6DIEJMQIjIGDRAWi4Vf//rXA57/zW9+w9y5c0PWqfEomJLfZ4aY9Bj1Ogw6rQwxCSEiZtBJ6kcffZRbbrmFZ555xhcQKioqsNvt/OUvfwlLB8eL4WYQAAnRwW2uE0KIUBg0QEycOJE333yTPXv28P777wNw4403kpeXF5bOjSdnAkQwGURvgDDqZQ5CCBExQe2DWLhwIQsXLgx1X8a1M0NMg2cQGg3EGpTeaxSZgxBCRExQO6nF5xfXWy5jsA98b5kNrdZTnC8hOrgKsEIIEQoSIMJEp9UQFzX4oUFtPQ7f6iXozSBkiEkIESESIMJoqHpM3jpMXglBlOcQQohQkQARRp4AMfgkdb8AIYcGCSEiKKQBoqysjGnTpmE2m/2eFmez2ViyZAlms5n58+f7dmeXl5eTk5NDTk4Oc+bMGTdLaocq2Ndhc/omswHioxR6HG7sTqmcK4QIv5AFCJfLxerVq9m5cyeVlZVs376dysrKfm22bt1KcnIy1dXVrF27lnXr1gEwc+ZMKioqOHToEGVlZfznf/4nTufYH2oZ9hBT9NCb64QQIlRCFiDKy8sxm81kZWVhMBhYunQppaWl/dqUlpayYsUKAAoKCti9ezeqqhITE4OieD4oe3p6xs2Rm0OdS312gPDVY5J5CCFEBIQsQDQ0NJCZmel7nJGRQUNDQ8A2iqKQmJhIc3MzAAcOHCA7O5tZs2bx5JNP+gLGWDZYBuE5LMjRb4gpIYjyHEIIESqjdpJ6/vz5fPDBB7z99tts3LiRnp6eAW2KioqwWCxYLBYaGxsj0MvhGSxA2JxuHC7Vt18CzgwxtXVLBiGECL+QBQiTyURdXZ3vcX19PSaTKWAbp9NJa2srqamp/dpMnz6duLg4X6mPvgoLC6moqKCiooIJEyaE4C5GVoJR7zs06Gze1UoJfoaYJIMQQkRCyAJEbm4uVVVV1NTUYLfbKS4uxmq19mtjtVrZtm0bACUlJeTl5aHRaKipqfFNSh89epSPPvqIyZMnh6qrYTNYwb4zhfr6DDHJoUFCiAgK2cC+oihs2bKF/Px8XC4XK1euJDs7m/Xr12OxWLBaraxatYrly5djNptJSUmhuLgYgH379rFp0yb0ej1arZYnnniCtLS0UHU1bPpmBBPio/q9dnYl177fyxCTECISQjrzu3jxYhYvXtzvuQ0bNvi+NxqN7NixY8B1y5cvZ/ny5aHsWkTERwUu2Nf3LAivOIOCRiNDTEKIyBi1k9TjUXBDTGditra3fpMscxVCRIIEiDAa7FS5s8+C8EowSrkNIURkSIAIo+FOUkNvPSaZgxBCRIAEiDDybnzzlxF4h5H67oOAoQv8CSFEqEiACKO4QTMIB3FRCjpt/7IiniEmySCEEOEnASKMdFoNsQZdwCGms+cfwLNxTg4NEkJEggSIMAtUsO/ssyC85NhRIUSkSIAIs0D1mDwZhH7A8wlGhXabE7dbDUf3hBDCRwJEmMUbFdptAzMCz2FBAzOIeKMeVYVOu8xDCCHCSwJEmAU6VS5gBhEtZ0IIISJDAkSYBR5i8j8H4Q0aMlEthAg3CRBhFmiSui3gKqbA9ZuEECKUJECEWYJxYG0lm9OF3en2BYN+7b1DTJJBCCHCTAJEmMUbFexONzbnmUOD/BXqO9O+N4PwM7EthBChJAEizOL9DBm1ByizAWdOmJN6TEKIcJMAEWbeIaP+AWLgWRBeMkkthIgUCRBhdubQoDMf+IMNMRkULUa9lnabZBBCiPAKaYAoKytj2rRpmM1mNm3aNOB1m83GkiVLMJvNzJ8/n9raWgB27drF3LlzmTVrFnPnzuWVV14JZTfDyl/J70BnQXglGPWSQQghwi5kAcLlcrF69Wp27txJZWUl27dvp7Kysl+brVu3kpycTHV1NWvXrmXdunUApKWl8de//pX33nuPbdu2javjR/0dGuRd1eRvFZPnGv97J4QQIpRCFiDKy8sxm81kZWVhMBhYunQppaWl/dqUlpayYsUKAAoKCti9ezeqqnL55ZczadIkALKzs+nu7sZms4Wqq2HlzRLa/ExSB8wgouVUOSFE+IUsQDQ0NJCZmel7nJGRQUNDQ8A2iqKQmJhIc3NzvzZ/+tOfuOKKK4iKihrwHkVFRVgsFiwWC42NjSG4i5Hnb+ObN5vwt4oJPFmHlNoQQoTbqJ6k/uCDD1i3bh2/+tWv/L5eWFhIRUUFFRUVTJgwIcy9OzdnDg3qP0kdY9Ch6Pz/50gwKrTLHIQQIsxCFiBMJhN1dXW+x/X19ZhMpoBtnE4nra2tpKam+trfcsst/OEPf2DKlCmh6mbY+Ts0KFAdJi8ZYhJCRELIAkRubi5VVVXU1NRgt9spLi7GarX2a2O1Wtm2bRsAJSUl5OXlodFoaGlp4cYbb2TTpk1cddVVoepixJxdjylQJdcz7QeW5xBCiFALWYBQFIUtW7aQn5/P9OnTue2228jOzmb9+vW88MILAKxatYrm5mbMZjObN2/2LYXdsmUL1dXVbNiwgZycHHJycjh58mSouhp2Z69KCnTcqFeCUY/d6abH4QrYRgghRlrgT6URsHjxYhYvXtzvuQ0bNvi+NxqN7NixY8B19957L/fee28ouxZRAwOEg8QYQ8D2CX32Thj1upD3TwghYJRPUo9XA4aYApwm55UQ3VtuQ+YhhBBhJAEiAvwNMSUMEiB8eydkJZMQIowkQETA2fsaPKuYAk9Sy6FBQohIkAARAQlGxTfE5HC56XG4iQ+wSQ5kiEkIERkhnaQW/sUbFWxON3anmw7b4GU2+r4mGYQQIpwkQERA34J9ZwLE0ENMMgchhAgnCRAR0DcjCCaDiDHo0Gk1kkEIIcJKAkQE9D121HvWdNwgAUKj0fTuppYMQggRPhIgIiC+T8E+70lxgc6C8JJDg4QQ4SYBInSTGxkAABjgSURBVAL6ngkRzBCT93UZYhJChJMEiAhIGOYktfcaGWISQoST7IOIgL6T1EOdJtf3GskghBDhJAEiArwnx3kChAOjXos+wGFBXgnR4ZmD8GY0QgghASICFJ2WGIPOM0k9xFkQXglhOHb0+X82MPv+f/DOZ6dD+j5CiLFBAkSEeIeMhjoLom/7DpsTl1sNSX+OnGjnR39+D7cKLx4+HpL3EEKMLRIgIiTeqKfd5qBtiEJ9Xt56TB0hyCI6bE7ufPogsVE6Lr8oiV2VJ1DV0AQiIcTYIQEiQvpmEIOV+u7bHvwX7Ks/3cXv3qhhz8cnaWjpHtaHu6qq/OjP71Hb1Mkvl13O1+Zm8tmpLqpOdgR/M0KIcSmkAaKsrIxp06ZhNpt9x4n2ZbPZWLJkCWazmfnz51NbWwtAc3MzCxcuJC4ujjVr1oSyixHjLfndMcRhQV6+ekx+AsR//+V9fvzXSr7xu7e5atMrzLzvH9y8ZR8/eO5dtr1ZS+cgE89P7z/KX989xg+un8YXpqRx7fR0AHZVnjjHOxNCjBchCxAul4vVq1ezc+dOKisr2b59O5WVlf3abN26leTkZKqrq1m7di3r1q0DPEeR/uQnP+Ghhx4KVfciLr635Hd7j4P4qGCGmPxXdD149BSvH2nkrusuZcedC3jwlpl8zZJJnFFhb1Uj973wAVf/4lWe3n8Uh8vd79pDdS1s+FslC6dN4NtXTwFgYoKROZlJvCQBQojzXsg2ypWXl2M2m8nKygJg6dKllJaWMmPGDF+b0tJS7r//fgAKCgpYs2YNqqoSGxvLv/3bv1FdXR2q7kVcQu8QU+dwM4izlro+squKtDgDhV/KIsagkDs5pd/rB4+eYuPfP+Le59/nt/tquCd/GjfMvICWLgern3mH9HgjjyzJQavV+K65fsZEfvGPjznZ1kN6gnEE7lYIMRaFLINoaGggMzPT9zgjI4OGhoaAbRRFITExkebm5qDfo6ioCIvFgsViobGxcWQ6HibxRj2tXQ667K6gl7kC/Za6Hvi0mX3VTdx59RRiDP6DzNyLU9hx5wJ+/XULWq2Gbz/zDrc88SbffuYgJ9t7eOL2K0iKMfS75rrpEwF4+cOT53p7QohxYExPUhcWFlJRUUFFRQUTJkyIdHeGJT5Kwd475BPsMlfAdxIdwCMvH2FCfBR3XHnxoNdqNBoWzZhI2fe/yM9uncXx1m72f3qK9TfNYE5m0oD2UyfGcVFKDC9/KMNMQpzPQjbEZDKZqKur8z2ur6/HZDL5bZORkYHT6aS1tZXU1NRQdWlU6RsUhhMg2ro9GcSbnzSx/9NT3PfvMzDqdUG9p6LTsiT3IqxzTFQeb+OKiwYGB/AElOumT+TpA0fptDmJHeQ4VCHE+BWyDCI3N5eqqipqamqw2+0UFxdjtVr7tbFarWzbtg2AkpIS8vLy0Gg0/n7cuNN3WCmYIaa+u69VVeWRXUeYmBDFsnkXDfu9ow065l6cPOjf9aIZE7E73eytahr2zxdCjA8h+6ehoihs2bKF/Px8XC4XK1euJDs7m/Xr12OxWLBaraxatYrly5djNptJSUmhuLjYd/3kyZNpa2vDbrfz/PPP89JLL/Wb4B7r+mYNweyD8LTzVHR9o7qZt2tP85Obs4POHoYrd3IyidF6dlWe4IaZF4TkPYQQo1tIxw4WL17M4sWL+z23YcMG3/dGo5EdO3b4vda7J2K8Gm4GAZ6lrm3dTjbv+phJiUZuy80c+qJzpOi05F2WzisfncDpcqMMUUxQCDH+yP/1EdI3gxjsuNH+1+h545Mm3vmshdV5ZqKU0GQPXtdNn8jpLgfvfNYS0vcRQoxOEiAiJKFfBhHsEJNn74QpKZqvzQ1d9uB19bQJGHRadlX+a1jXOVxu/s+Odyl6/ROcZ23OE0KMHRIgImS4q5g87TxB5bt5ZgxK6P/TxUUpXDklddjF+x7fU03JwXp++vePsG55g8P1koEIMRZJgIgQ77CSQdEGPVQ005TATFMCt87NCGXX+lk0YyK1zV180hhc8b4PjrWy5ZVqbs6ZxJN3zKWpw8ZXHn+DDX+tHLQmlBBi9JEAESF6nZZovS7oFUwAhV+awl/X/NuQp8+NpOt8xfuG3lXtGVo6TFKMgfv/PZsbZl7Ayz+4mtvnX8zv3qzh+kde55WPxsbmu5PtPWx+6WM5B1yc1yRARFC8UQl6BZNXuPeJXJgYzSxTYlDzEI/vqebD4208eMtMkmM95TsSjHp+8pWZlNy5gNgoHSt/X8FN/7OXn/ytkn988C9Oddr9/ixVVWlst3Hw6CmOtXSP6D0NRVVVflhymF++Us1D//g4rO8txGgiW2QjKN6ojIldyotmTOSRl49wsr2H9Hj/xfv6Di3lZw/cNzH34hT+9t0v8oe3ann5wxM8vf8oW/fVAHBpehzzLkkhxqDjaHMXn53y/OmyuwC4MNHIy3dfHba/q+cq6nj140amTIjlqf1H+drcTGZlJIblvYUYTSSDiKD0eCPp8VGR7saQvBvllvxqP68dGVgU8eyhpUAMipZvfjGL4sIFHL7/ekruXMA9+dMwJUdTeugYf3jrKDVNnWQkR7M09yLu//cZPHjLTI639vDIriMhu7++6k938ZO/fciCrFT+/J2rSIuL4t7n3wvZUa9CjGaj/5+v49jDt81Bpx39pUWmToxn2zfmcd8LH7Dit+XkZ0/k/79pBhnJMcCZoaWi5XN9Q0tDiVJ0WCanYOktT+7u/QDW+vn7eL+hjd+9WcstV5jInhS6f8m73Srr/nQYVVX5ecFsEqP13HvjdL5ffIg/ln/G8iGKIgox3kgGEUGTkqKZOEbOW/jS1AmU3fVF7smfxutHmrhu82v8z+4q/vnZaba8Us1XciZxvZ+hpWBptRq/wQHgv264jKRoPf/3L++H9F/yzxw4yhvVzfzfG2eQmeIJftY5k/jClFR+XvYRje22kL23EKORBAgRtChFx+qFZl7+wdXkXZbOw7uO8NX/fZOkGAP3DTK09Hklxui596bpHKprYXv5Z8O+/lSnndJDDfz69U9p6vD/IX+0uZOf/v0jvjR1AsvmndmEqNFo2HDzTHocLjbu/PCc70GIsUiGmMSwmZKieeL2ueytauSJPZ/w7WumBD20dK6+kmNiR0U9Pyv7iOuzJwacLAdwuVUO1bXw2pFGXvv4JIcbWvHu83vopY9ZNu8ivvWlLExJ0YBnaOmeHYdRdBp+duusASvFzOlxFH4pi8f3fMJtlkyuzDo/StILoVGHs0V2FLNYLFRUVES6GyKEPmns4MuP7uXLsy7gsaWXD3i9tcvB469W8+zbdbR2O9BqICcziaunpnPNtAnERul48rVPef6fnpMNv3qFiTuvnsIrH53kgRc/5KGvzaEgwCbEbruLRY+8RrRex4vf+6JvJ7uqqrzf0EbJwTr2VTdxx5UX842rLgndX4IQI2ywz07JIMSYMWVCHN++ZgqP7a6iYG4GX7zUc4qgzeniqbeO8j+vVNPW4+Cm2ZPIz57Iv5nTBhyn+tDX5nDXdZfy69c/pfjtOnYcrEfRarhuejq3XmHy97aA5wyNH1uzWbWtgt++UcNXrzBR+s9jlBys5+MT7RgULVlpsfz4r5V8dqqLe2+cMSYWIAgxGMkgxJjS43Bxw6OvA1B215fY/eFJflb2EZ+d6uKLl6bxoy9PZ8akhKB+VmO7jd++UUNF7Skev/2KQYetvL71hwpe/fgkbtUzlHX5RUkUzM3gplmTiDMqPPjih/z2jRrysyfy2NLLBz2v42R7D3qt9nMNz6mqytHmLqL0Wi5MjD7nnyPOX4N9dkqAEGPOvqom7th6gPT4KE6225g2MZ7/vnE6V08N/bnkDS3d/OC5Q1x+UTK3XpGBOT1uQJut+2p44MVKcjKT+M3XLaTGndnr4nar7K1u4qm3atn90UlUFSYlGpkxKYEZFyb0fk3kgkQjep1mwHyI0+Xmw+PtvF17qvfPaZo6bOi0GpbNy+R7114aVKATwksChBh31pUc5rUjjdy9aCq3zs0YdcM5Ze8f5/vFh7gg0cjvvzGP1DgDfzpYz1NvHeXTpk7S4gwszb2IeKNC5fE2Ko+18UljB31X8eq0GoyKFqNe1/tHy79ae+js3WFuSopm3iUpzL04mY//1c728s/Q67R864uXUHj1FOLGwC59EXkRCxBlZWV8//vfx+Vy8c1vfpP/+q//6ve6zWbj61//OgcPHiQ1NZVnn32WyZMnA7Bx40a2bt2KTqfjl7/8Jfn5+YO+lwSI84v313Y0n2F+8OhpvrntbVxuFadbpcvu4oqLkljxhcncMPOCAVV8exwuPv5XO5XH22jusNHjcNPtcNHjcPm+psZGYZmcTO7kFCYl9R9Sqmnq5KGXPubFw8dJjTXw3Twz/9/8i3G63bT3OGnvcdDW46S9x0lHj5NOu5Nuu4suu4suu5Muu+d93G4Vl1vFpaqe71Vwud3YnW5sTs9Xu8vz1a1CenwUGcnRmJKjMSVFk5Ecw6QkIzqNBpeq4nSpuFXP34HbrWJzuulxuOhxuLE5PV/tLheTU2OZZUoM6vTC1m4H3XYXCdEK0XrdoL8HbrdKh91zz33vtcvupNPmwul2Y1Q8QThK7wnI0XodCdF6JiUaR/Xv2EiISIBwuVxMnTqVXbt2kZGRQW5uLtu3b+93rvQTTzzB4cOHefLJJykuLuYvf/kLzz77LJWVlSxbtozy8nKOHTvGddddx5EjR9DpAo/nSoAQo1FNUyf/Z8e7XJIWy4oFk8NS0+nduhY27vyQ/Z+eCvoarQZiDApGvRadVoNO49m4qNNq0Go0aDVgUHSe8vQ6LQbF80ergX+19dBwupvTXZ+/8m1clELu5GSuzEplwZRUZlyYgFuFD4+3caiuhUN1Lbxb18KnTZ2+aww6LQnRCgnRehKj9Wg1Gtp7HL1B0UnH5ygzn2BUmDEpgexJiWT3fp2cFkNrt4OmdjtNHTbfn5YuB1GKjhiDjpio3q8GTwBzq6rvHwpOl4rT7cbpUumyO2m3Oem0eQKY93udVkOUoiNK0Xr+6HUYdFrcquoLrN5Aa3O6mXtxMndePeWc7jEiq5jKy8sxm81kZWUBsHTpUkpLS/sFiNLSUu6//34ACgoKWLNmDaqqUlpaytKlS4mKiuKSSy7BbDZTXl7OggULQtVdIULikrRY/vTtL4T1PedkJrH9W1fyelUTFbWniI1SfJWD440KCUaFuCg9MQYdsVEKMQbPB9Hn/Zdyp83JsZZu6k93c7y1B7eqovTukFf6BJuo3mGzqD7DZzqtho/+1cZbnzTz1qfN7PnYU/MrLkrxZSsAE+KjyMlM4ta5GSTHGGjtdvj+tPV+dasqaWmxvvuNN+p771khJkohRu/9AFeINehQdNrejMaTzfQ4XdgcLpo67FQeb+ODY208vf8oNufgpyMqWg3Oc9zpr9NqiIvy9DE2SodbpTdj8wQAW29Q8AYOo95zjkxU79dL/cyFjYSQBYiGhgYyM8/sSM3IyODAgQMB2yiKQmJiIs3NzTQ0NHDllVf2u7ahoWHAexQVFVFUVARAY+PAInJCnK80Gg1XT50Qlol7r9gohUsnxnPpxPhzut6cHsdNsycBcLKth7c+baa85hQxBh05mcnkXJQUsSEfp8vNp02dvN/QSt2pbpJj9UyIiyItPoq0uCjS4gzERSm4VfoMYbnotDnpcbjQaDTodZ4gqWg9WZpepyHG4AkKRv3nD9ChMKZnsQoLCyksLAQ8aZIQYnxITzByc46Jm3MC700JJ0WnZerEeKYOEfx0Gnozl+Gd8zJahawWk8lkoq6uzve4vr4ek8kUsI3T6aS1tZXU1NSgrhVCCBFaIQsQubm5VFVVUVNTg91up7i4GKvV2q+N1Wpl27ZtAJSUlJCXl4dGo8FqtVJcXIzNZqOmpoaqqirmzZsXqq4KIYTwI2RDTIqisGXLFvLz83G5XKxcuZLs7GzWr1+PxWLBarWyatUqli9fjtlsJiUlheLiYgCys7O57bbbmDFjBoqi8Pjjjw+6gkkIIcTIk41yQghxHhvss1POgxBCCOGXBAghhBB+SYAQQgjhlwQIIYQQfo2bSeq0tDRfob9z0djYyIQJ4dt1Gmnn2/2C3PP5Qu55eGpra2lqavL72rgJEJ/X+bYK6ny7X5B7Pl/IPY8cGWISQgjhlwQIIYQQfunu99bbFsydOzfSXQir8+1+Qe75fCH3PDJkDkIIIYRfMsQkhBDCLwkQQggh/DrvA0RZWRnTpk3DbDazadOmSHcnJFauXEl6ejozZ870PXfq1CkWLVrEpZdeyqJFizh9+nQEezjy6urqWLhwITNmzCA7O5vHHnsMGN/33dPTw7x585gzZw7Z2dncd999ANTU1DB//nzMZjNLlizBbrdHuKcjy+Vycfnll3PTTTcB4/9+J0+ezKxZs8jJyfEdlBaq3+vzOkC4XC5Wr17Nzp07qaysZPv27VRWVka6WyPuP/7jPygrK+v33KZNm7j22mupqqri2muvHXfBUVEUHn74YSorK9m/fz+PP/44lZWV4/q+o6KieOWVV3j33Xc5dOgQZWVl7N+/n3Xr1rF27Vqqq6tJTk5m69atke7qiHrssceYPn267/F4v1+APXv2cOjQId/eh5D9XqvnsTfffFO9/vrrfY9/+tOfqj/96U8j2KPQqampUbOzs32Pp06dqh47dkxVVVU9duyYOnXq1Eh1LSysVqv60ksvnTf33dnZqV5++eXq/v371dTUVNXhcKiqOvB3fqyrq6tT8/Ly1N27d6s33nij6na7x/X9qqqqXnzxxWpjY2O/50L1e31eZxANDQ1kZmb6HmdkZNDQ0BDBHoXPiRMnuPDCCwG44IILOHHiRIR7FDq1tbX885//ZP78+eP+vl0uFzk5OaSnp7No0SKmTJlCUlISiuI5G2y8/Y7fdddd/PznP0er9XyUNTc3j+v7BdBoNFx//fXMnTuXoqIiIHT/P4fsRDkxdmg0GjQaTaS7ERIdHR3ceuutPProoyQkJPR7bTzet06n49ChQ7S0tHDLLbfw0UcfRbpLIfO3v/2N9PR05s6dy6uvvhrp7oTNvn37MJlMnDx5kkWLFnHZZZf1e30kf6/P6wBhMpmoq6vzPa6vr8dkMkWwR+EzceJEjh8/zoUXXsjx48dJT0+PdJdGnMPh4NZbb+X222/nq1/9KnB+3DdAUlISCxcu5K233qKlpQWn04miKOPqd/yNN97ghRde4O9//zs9PT20tbXx/e9/f9zer5f3ftLT07nlllsoLy8P2e/1eT3ElJubS1VVFTU1NdjtdoqLi7FarZHuVlhYrVa2bdsGwLZt27j55psj3KORpaoqq1atYvr06dx9992+58fzfTc2NtLS0gJAd3c3u3btYvr06SxcuJCSkhJgfN3zxo0bqa+vp7a2luLiYvLy8njmmWfG7f0CdHZ20t7e7vv+pZdeYubMmaH7vR6RmYwx7MUXX1QvvfRSNSsrS33ggQci3Z2QWLp0qXrBBReoiqKoJpNJ/c1vfqM2NTWpeXl5qtlsVq+99lq1ubk50t0cUXv37lUBddasWeqcOXPUOXPmqC+++OK4vu93331XzcnJUWfNmqVmZ2erP/7xj1VVVdVPPvlEzc3NVadMmaIWFBSoPT09Ee7pyNuzZ4964403qqo6vu/3k08+UWfPnq3Onj1bnTFjhu8zK1S/11JqQwghhF/n9RCTEEKIwCRACCGE8EsChBBCCL8kQAghhPBLAoQQQgi/JEAI8Tk8+OCDZGdnM3v2bHJycjhw4ACPPvooXV1dke6aEJ+bLHMV4hy99dZb3H333bz66qtERUXR1NSE3W7nC1/4AhUVFaSlpUW6i0J8LpJBCHGOjh8/TlpaGlFRUQCkpaVRUlLCsWPHWLhwIQsXLgTgpZdeYsGCBVxxxRV87Wtfo6OjA/DU9f/hD3/IrFmzmDdvHtXV1RG7FyH8kQAhxDm6/vrrqaurY+rUqXznO9/htdde43vf+x6TJk1iz5497Nmzh6amJh544AFefvll3nnnHSwWC5s3b/b9jMTERN577z3WrFnDXXfdFcG7EWKg87pYnxCfR1xcHAcPHmTv3r3s2bOHJUuWDDioZf/+/VRWVnLVVVcBYLfbWbBgge/1ZcuW+b6uXbs2fJ0XIggSIIT4HHQ6Hddccw3XXHMNs2bN8hVM81JVlUWLFrF9+3a/1/ctyzzeSo+LsU+GmIQ4Rx9//DFVVVW+x4cOHeLiiy8mPj7eV3Hzyiuv5I033vDNL3R2dnLkyBHfNc8++6zva9/MQojRQDIIIc5RR0cH3/3ud2lpaUFRFMxmM0VFRWzfvp0bbrjBNxfx+9//nmXLlmGz2QB44IEHmDp1KgCnT59m9uzZREVFBcwyhIgUWeYqRIRMnjxZlsOKUU2GmIQQQvglGYQQQgi/JIMQQgjhlwQIIYQQfkmAEEII4ZcECCGEEH5JgBBCCOHX/wM1o6Qu7toecAAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Part III: Sampling Fourier coefficients\n",
        "\n",
        "When we use a trainable ansatz above, it is possible that even with enough repetitions of the data-encoding Pauli rotation, the quantum model cannot fit the circuit, since the expressivity of quantum models also depends on the Fourier coefficients the model can create.\n",
        "\n",
        "Figure 5 in the paper shows Fourier coefficients from quantum models sampled from a model family defined by an ansatz for the trainable circuit block. For this we need a function that numerically computes the Fourier coefficients of a periodic function $f$ with period $2π$."
      ],
      "metadata": {
        "id": "UUYfIMqnPSrK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fourier_coefficients(f, K):\n",
        "    \"\"\"\n",
        "    Computes the first 2*K+1 Fourier coefficients of a 2*pi periodic function.\n",
        "    \"\"\"\n",
        "    n_coeffs = 2 * K + 1\n",
        "    t = np.linspace(0, 2 * np.pi, n_coeffs, endpoint=False)\n",
        "    y = np.fft.rfft(f(t)) / t.size\n",
        "    return y\n"
      ],
      "metadata": {
        "id": "nDAVxmTBPRhZ"
      },
      "execution_count": 39,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define your quantum model\n",
        "\n",
        "Now we need to define a quantum model. This could be any model, using a qubit or continuous-variable circuit, or one of the quantum models from above. We will use a slight derivation of the `parallel_qubit_model()` from above, this time using the `BasicEntanglerLayers` ansatz:"
      ],
      "metadata": {
        "id": "fa9vmsnnPfML"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pennylane.templates import BasicEntanglerLayers\n",
        "\n",
        "scaling = 1\n",
        "n_qubits = 4\n",
        "\n",
        "dev = qml.device('default.qubit', wires=n_qubits)\n",
        "\n",
        "def S(x):\n",
        "    \"\"\"Data encoding circuit block.\"\"\"\n",
        "    for w in range(n_qubits):\n",
        "        qml.RX(scaling * x, wires=w)\n",
        "\n",
        "def W(theta):\n",
        "    \"\"\"Trainable circuit block.\"\"\"\n",
        "    BasicEntanglerLayers(theta, wires=range(n_qubits))\n",
        "\n",
        "\n",
        "@qml.qnode(dev)\n",
        "def quantum_model(weights, x):\n",
        "\n",
        "    W(weights[0])\n",
        "    S(x)\n",
        "    W(weights[1])\n",
        "\n",
        "    return qml.expval(qml.PauliZ(wires=0))"
      ],
      "metadata": {
        "id": "FD-wd68zPeVx"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It will also be handy to define a function that samples different random weights of the correct size for the model."
      ],
      "metadata": {
        "id": "E5jw7zn5PucW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_ansatz_layers = 1\n",
        "\n",
        "def random_weights():\n",
        "    return 2 * np.pi * np.random.random(size=(2, n_ansatz_layers, n_qubits))"
      ],
      "metadata": {
        "id": "dVmglKlbPtK4"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can compute the first few Fourier coefficients for samples from this model. The samples are created by randomly sampling different parameters using the `random_weights()` function."
      ],
      "metadata": {
        "id": "_1F3eTIlPx8W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_coeffs = 5\n",
        "n_samples = 100\n",
        "\n",
        "\n",
        "coeffs = []\n",
        "for i in range(n_samples):\n",
        "\n",
        "    weights = random_weights()\n",
        "\n",
        "    def f(x):\n",
        "        return np.array([quantum_model(weights, x_) for x_ in x])\n",
        "\n",
        "    coeffs_sample = fourier_coefficients(f, n_coeffs)\n",
        "    coeffs.append(coeffs_sample)\n",
        "\n",
        "coeffs = np.array(coeffs)\n",
        "coeffs_real = np.real(coeffs)\n",
        "coeffs_imag = np.imag(coeffs)"
      ],
      "metadata": {
        "id": "cJkv-u5hPwe5"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let’s plot the real vs. the imaginary part of the coefficients. As a sanity check, the c0 coefficient should be real, and therefore have no contribution on the y-axis."
      ],
      "metadata": {
        "id": "fKbybgSXP3pv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "n_coeffs = len(coeffs_real[0])\n",
        "\n",
        "fig, ax = plt.subplots(1, n_coeffs, figsize=(15, 4))\n",
        "\n",
        "for idx, ax_ in enumerate(ax):\n",
        "    ax_.set_title(r\"$c_{}$\".format(idx))\n",
        "    ax_.scatter(coeffs_real[:, idx], coeffs_imag[:, idx], s=20,\n",
        "                facecolor='white', edgecolor='red')\n",
        "    ax_.set_aspect(\"equal\")\n",
        "    ax_.set_ylim(-1, 1)\n",
        "    ax_.set_xlim(-1, 1)\n",
        "\n",
        "\n",
        "plt.tight_layout(pad=0.5)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "YAmFqK2VP2XL",
        "outputId": "be838ed5-3db9-4ed1-f6f9-c14a41d8939e"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x288 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Playing around with different quantum models, you will find that some quantum models create different distributions over the coefficients than others. For example BasicEntanglingLayers (with the default Pauli-X rotation) seems to have a structure that forces the even Fourier coefficients to zero, while StronglyEntanglingLayers will have a non-zero variance for all supported coefficients.\n",
        "\n",
        "Note also how the variance of the distribution decreases for growing orders of the coefficients—an effect linked to the convergence of a Fourier series.\n"
      ],
      "metadata": {
        "id": "TBmZtwPrP8O8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Continuous-variable model\n",
        "\n",
        "The paper mentions that a phase rotation in continuous-variable quantum computing has a spectrum that supports all Fourier frequecies. To play with this model, we finally show you the code for a continuous-variable circuit. For example, to see its Fourier coefficients run the cell below, and then re-run the two cells above."
      ],
      "metadata": {
        "id": "r1RRolqdQAaP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "var = 2\n",
        "n_ansatz_layers = 1\n",
        "dev_cv = qml.device('default.gaussian', wires=1)\n",
        "\n",
        "def S(x):\n",
        "    qml.Rotation(x, wires=0)\n",
        "\n",
        "def W(theta):\n",
        "    \"\"\"Trainable circuit block.\"\"\"\n",
        "    for r_ in range(n_ansatz_layers):\n",
        "        qml.Displacement(theta[0], theta[1], wires=0)\n",
        "        qml.Squeezing(theta[2], theta[3], wires=0)\n",
        "\n",
        "@qml.qnode(dev_cv)\n",
        "def quantum_model(weights, x):\n",
        "    W(weights[0])\n",
        "    S(x)\n",
        "    W(weights[1])\n",
        "    return qml.expval(qml.X(wires=0))\n",
        "\n",
        "def random_weights():\n",
        "    return np.random.normal(size=(2, 5 * n_ansatz_layers), loc=0, scale=var)"
      ],
      "metadata": {
        "id": "I_RUYLmSP6qx"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n_coeffs = 5\n",
        "n_samples = 100\n",
        "\n",
        "\n",
        "coeffs = []\n",
        "for i in range(n_samples):\n",
        "\n",
        "    weights = random_weights()\n",
        "\n",
        "    def f(x):\n",
        "        return np.array([quantum_model(weights, x_) for x_ in x])\n",
        "\n",
        "    coeffs_sample = fourier_coefficients(f, n_coeffs)\n",
        "    coeffs.append(coeffs_sample)\n",
        "\n",
        "coeffs = np.array(coeffs)\n",
        "coeffs_real = np.real(coeffs)\n",
        "coeffs_imag = np.imag(coeffs)"
      ],
      "metadata": {
        "id": "XNBR89dGQTif"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "n_coeffs = len(coeffs_real[0])\n",
        "\n",
        "fig, ax = plt.subplots(1, n_coeffs, figsize=(15, 4))\n",
        "\n",
        "for idx, ax_ in enumerate(ax):\n",
        "    ax_.set_title(r\"$c_{}$\".format(idx))\n",
        "    ax_.scatter(coeffs_real[:, idx], coeffs_imag[:, idx], s=20,\n",
        "                facecolor='white', edgecolor='red')\n",
        "    ax_.set_aspect(\"equal\")\n",
        "    ax_.set_ylim(-1, 1)\n",
        "    ax_.set_xlim(-1, 1)\n",
        "\n",
        "\n",
        "plt.tight_layout(pad=0.5)\n",
        "plt.show();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 203
        },
        "id": "TECR70_9QT9Y",
        "outputId": "955ad359-09c1-4f1e-ad6f-48105b2f4690"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x288 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}