├── figures
    ├── scheme.png
    ├── scheme_thumb.png
    ├── parallel_model.png
    ├── single_qubit_model.png
    └── expressivity_thumbnail.png
├── README.md
└── tutorial_expressivity_fourier_series.ipynb


/figures/scheme.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XanaduAI/expressive_power_of_quantum_models/HEAD/figures/scheme.png


--------------------------------------------------------------------------------
/figures/scheme_thumb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XanaduAI/expressive_power_of_quantum_models/HEAD/figures/scheme_thumb.png


--------------------------------------------------------------------------------
/figures/parallel_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XanaduAI/expressive_power_of_quantum_models/HEAD/figures/parallel_model.png


--------------------------------------------------------------------------------
/figures/single_qubit_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XanaduAI/expressive_power_of_quantum_models/HEAD/figures/single_qubit_model.png


--------------------------------------------------------------------------------
/figures/expressivity_thumbnail.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XanaduAI/expressive_power_of_quantum_models/HEAD/figures/expressivity_thumbnail.png


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # The effect of data encoding on the expressive power of variational quantum models
2 | 
3 | This repository contains code necessary to reproduce the figures and simulation results of the [paper](https://arxiv.org/abs/2008.08605) "The effect of data encoding on the expressive power of variational quantum machine learning models" by Maria Schuld, Ryan Sweke and Johannes Jakob Meyer. 
4 | 
5 | The code is presented as a jupyter notebook (called ``tutorial_expressivity_fourier_series.ipynb``), which allows you to play around with different settings and explore the relashionship of typical quantum machine learning models and Fourier series. 
6 | 
7 | The notebook can also be found as a [PennyLane tutorial](https://pennylane.ai/qml/demos/tutorial_expressivity_fourier_series.html).
8 | 


--------------------------------------------------------------------------------
/tutorial_expressivity_fourier_series.ipynb:
--------------------------------------------------------------------------------
   1 | {
   2 |  "cells": [
   3 |   {
   4 |    "cell_type": "code",
   5 |    "execution_count": 1,
   6 |    "metadata": {},
   7 |    "outputs": [],
   8 |    "source": [
   9 |     "# This cell is added by sphinx-gallery\n",
  10 |     "# It can be customized to whatever you like\n",
  11 |     "%matplotlib inline"
  12 |    ]
  13 |   },
  14 |   {
  15 |    "cell_type": "markdown",
  16 |    "metadata": {},
  17 |    "source": [
  18 |     "\n",
  19 |     "Quantum models as Fourier series\n",
  20 |     "============================\n",
  21 |     "\n",
  22 |     "\n"
  23 |    ]
  24 |   },
  25 |   {
  26 |    "cell_type": "markdown",
  27 |    "metadata": {},
  28 |    "source": [
  29 |     "This demonstration is based on the paper *The effect of data encoding on\n",
  30 |     "the expressive power of variational quantum machine learning models* by\n",
  31 |     "[Schuld, Sweke and Meyer\n",
  32 |     "(2020)](https://arxiv.org/abs/2008.08605) [1].\n",
  33 |     "\n",
  34 |     "<img src=\"figures/scheme_thumb.png\" alt=\"scheme\" width=\"500\" />"
  35 |    ]
  36 |   },
  37 |   {
  38 |    "cell_type": "markdown",
  39 |    "metadata": {},
  40 |    "source": [
  41 |     "The paper links common quantum machine learning models designed for\n",
  42 |     "near-term quantum computers to Fourier series (and, in more general, to\n",
  43 |     "Fourier-type sums). With this link, the class of functions a quantum\n",
  44 |     "model can learn (i.e., its \"expressivity\") can be characterised by the\n",
  45 |     "model's control of the Fourier series' frequencies and coefficients.\n",
  46 |     "\n",
  47 |     "\n"
  48 |    ]
  49 |   },
  50 |   {
  51 |    "cell_type": "markdown",
  52 |    "metadata": {},
  53 |    "source": [
  54 |     "## Background\n"
  55 |    ]
  56 |   },
  57 |   {
  58 |    "cell_type": "markdown",
  59 |    "metadata": {},
  60 |    "source": [
  61 |     "Ref. [1] considers quantum machine\n",
  62 |     "learning models of the form\n",
  63 |     "\n",
  64 |     "\\begin{align}f_{\\boldsymbol \\theta}(x) = \\langle 0| U^{\\dagger}(x,\\boldsymbol \\theta) M U(x, \\boldsymbol \\theta) | 0 \\rangle\\end{align}\n",
  65 |     "\n",
  66 |     "where $M$ is a measurement observable and\n",
  67 |     "$U(x, \\boldsymbol \\theta)$ is a variational quantum circuit that\n",
  68 |     "encodes a data input $x$ and depends on a\n",
  69 |     "set of parameters $\\boldsymbol \\theta$. Here we will restrict ourselves\n",
  70 |     "to one-dimensional data inputs, but the paper motivates that higher-dimensional\n",
  71 |     "features simply generalise to multi-dimensional Fourier series.\n",
  72 |     "\n",
  73 |     "The circuit itself repeats $L$ layers, each consisting of a data encoding circuit\n",
  74 |     "block $S(x)$ and a trainable circuit block\n",
  75 |     "$W(\\boldsymbol \\theta)$ that is controlled by the parameters\n",
  76 |     "$\\boldsymbol \\theta$. The data encoding block consists of gates of\n",
  77 |     "the form $\\mathcal{G}(x) = e^{-ix H}$, where $H$ is a\n",
  78 |     "Hamiltonian. A prominent example of such gates are Pauli rotations.\n",
  79 |     "\n",
  80 |     "\n"
  81 |    ]
  82 |   },
  83 |   {
  84 |    "cell_type": "markdown",
  85 |    "metadata": {},
  86 |    "source": [
  87 |     "The paper shows how such a quantum model can be written as a\n",
  88 |     "Fourier-type sum of the form\n",
  89 |     "\n",
  90 |     "\\begin{align}f_{ \\boldsymbol \\theta}(x) = \\sum_{\\omega \\in \\Omega} c_{\\omega}( \\boldsymbol \\theta) \\; e^{i  \\omega x}.\\end{align}\n",
  91 |     "\n",
  92 |     "As illustrated in the picture below (which is Figure 1 from the paper),\n",
  93 |     "the \"encoding Hamiltonians\" in $S(x)$ determine the set\n",
  94 |     "$\\Omega$ of available \"frequencies\", and the remainder of the\n",
  95 |     "circuit, including the trainable parameters, determine the coefficients\n",
  96 |     "$c_{\\omega}$.\n",
  97 |     "\n",
  98 |     "\n"
  99 |    ]
 100 |   },
 101 |   {
 102 |    "cell_type": "markdown",
 103 |    "metadata": {},
 104 |    "source": [
 105 |     "<img src=\"figures/scheme.png\" alt=\"scheme\" width=\"500\" />\n",
 106 |     "\n",
 107 |     "\n"
 108 |    ]
 109 |   },
 110 |   {
 111 |    "cell_type": "markdown",
 112 |    "metadata": {},
 113 |    "source": [
 114 |     "The paper demonstrates many of its findings for circuits in which\n",
 115 |     "$\\mathcal{G}(x)$ is a single-qubit Pauli rotation gate. For\n",
 116 |     "example, it shows that $r$ repetitions of a Pauli rotation\n",
 117 |     "encoding gate in \"sequence\" (on the same qubit, but with multiple layers $r=L$) or\n",
 118 |     "in \"parallel\" (on $r$ different qubits, with $L=1$) creates a quantum\n",
 119 |     "model that can be expressed as a *Fourier series* of the form\n",
 120 |     "\n",
 121 |     "\\begin{align}f_{ \\boldsymbol \\theta}(x) = \\sum_{n \\in \\Omega} c_{n}(\\boldsymbol \\theta) e^{i  n x},\\end{align}\n",
 122 |     "\n",
 123 |     "where $\\Omega = \\{ -r, \\dots, -1, 0, 1, \\dots, r\\}$ is a spectrum\n",
 124 |     "of consecutive integer-valued frequencies up to degree $r$.\n",
 125 |     "\n",
 126 |     "As a result, we expect quantum models that encode an input $x$ by\n",
 127 |     "$r$ Pauli rotations to only be able to fit Fourier series of at\n",
 128 |     "most degree $r$.\n",
 129 |     "\n",
 130 |     "\n"
 131 |    ]
 132 |   },
 133 |   {
 134 |    "cell_type": "markdown",
 135 |    "metadata": {},
 136 |    "source": [
 137 |     "## Goal of this demonstration\n",
 138 |     "\n",
 139 |     "\n",
 140 |     "\n"
 141 |    ]
 142 |   },
 143 |   {
 144 |    "cell_type": "markdown",
 145 |    "metadata": {},
 146 |    "source": [
 147 |     "The experiments below investigate this \"Fourier-series\"-like nature of\n",
 148 |     "quantum models by showing how to reproduce the simulations underlying\n",
 149 |     "Figures 3, 4 and 5 in Section II of the paper:\n",
 150 |     "\n",
 151 |     "-  **Figures 3 and 4** are function fitting experiments, where quantum\n",
 152 |     "   models with different encoding strategies have the task to fit\n",
 153 |     "   Fourier series up to a certain degree. As in the paper, we will use\n",
 154 |     "   examples of qubit-based quantum circuits where a single data feature\n",
 155 |     "   is encoded via Pauli rotations.\n",
 156 |     "\n",
 157 |     "-  **Figure 5** plots the Fourier coefficients of randomly sampled\n",
 158 |     "   instances from a family of quantum models which is defined by some\n",
 159 |     "   parametrised ansatz.\n",
 160 |     "\n",
 161 |     "The code is presented so you can easily modify it in order to play\n",
 162 |     "around with other settings and models. The settings used in the paper \n",
 163 |     "are given in the various subsections.\n",
 164 |     "\n",
 165 |     "\n"
 166 |    ]
 167 |   },
 168 |   {
 169 |    "cell_type": "markdown",
 170 |    "metadata": {},
 171 |    "source": [
 172 |     "## Imports and global functions\n",
 173 |     "\n",
 174 |     "\n",
 175 |     "\n"
 176 |    ]
 177 |   },
 178 |   {
 179 |    "cell_type": "markdown",
 180 |    "metadata": {},
 181 |    "source": [
 182 |     "First of all, let's make some imports and define a standard loss\n",
 183 |     "function for the training.\n",
 184 |     "\n",
 185 |     "\n"
 186 |    ]
 187 |   },
 188 |   {
 189 |    "cell_type": "code",
 190 |    "execution_count": 2,
 191 |    "metadata": {},
 192 |    "outputs": [],
 193 |    "source": [
 194 |     "import matplotlib.pyplot as plt\n",
 195 |     "import pennylane as qml\n",
 196 |     "from pennylane import numpy as np\n",
 197 |     "\n",
 198 |     "np.random.seed(42)\n",
 199 |     "\n",
 200 |     "def square_loss(targets, predictions):\n",
 201 |     "    loss = 0\n",
 202 |     "    for t, p in zip(targets, predictions):\n",
 203 |     "        loss = loss + (t - p) ** 2\n",
 204 |     "    loss = loss / len(targets)\n",
 205 |     "    return 0.5*loss"
 206 |    ]
 207 |   },
 208 |   {
 209 |    "cell_type": "markdown",
 210 |    "metadata": {},
 211 |    "source": [
 212 |     "# Part I: Fitting Fourier series with serial Pauli-rotation encoding\n",
 213 |     "\n",
 214 |     "\n",
 215 |     "\n"
 216 |    ]
 217 |   },
 218 |   {
 219 |    "cell_type": "markdown",
 220 |    "metadata": {},
 221 |    "source": [
 222 |     "First we will reproduce Figures 3 and 4 from the paper. These\n",
 223 |     "show how quantum models that use Pauli rotations as data\n",
 224 |     "encoding gates can only fit Fourier series up to a certain degree. The\n",
 225 |     "degree corresponds to the number of times that the Pauli gate gets\n",
 226 |     "repeated in the quantum model.\n",
 227 |     "\n",
 228 |     "First, let us consider circuits where a the encoding gate gets repeated\n",
 229 |     "sequentially (as in Figure 2a of the paper). For simplicity we will only\n",
 230 |     "look at single qubit circuits:\n",
 231 |     "\n",
 232 |     "<img src=\"figures/single_qubit_model.png\" alt=\"single_qubit_model\" width=\"500\" />\n",
 233 |     "\n",
 234 |     "\n"
 235 |    ]
 236 |   },
 237 |   {
 238 |    "cell_type": "markdown",
 239 |    "metadata": {},
 240 |    "source": [
 241 |     "## Define a target function"
 242 |    ]
 243 |   },
 244 |   {
 245 |    "cell_type": "markdown",
 246 |    "metadata": {},
 247 |    "source": [
 248 |     "We first define a (classical) target function which will be used as a \n",
 249 |     "\"ground truth\" that the quantum model has to fit. The target function is \n",
 250 |     "constructed as a Fourier series of a specific degree. \n",
 251 |     "\n",
 252 |     "We also allow for a rescaling of the data by a hyperparameter ``scaling``, \n",
 253 |     "which we will do in the quantum model as well. As shown in [1], for the quantum model to \n",
 254 |     "learn the classical model in the experiment below,\n",
 255 |     "the scaling of the quantum model and the target function have to match, \n",
 256 |     "which is an important observation for \n",
 257 |     "the design of quantum machine learning models.\n",
 258 |     "\n",
 259 |     "\n",
 260 |     "\n"
 261 |    ]
 262 |   },
 263 |   {
 264 |    "cell_type": "code",
 265 |    "execution_count": 3,
 266 |    "metadata": {},
 267 |    "outputs": [],
 268 |    "source": [
 269 |     "degree = 1 # degree of the target function\n",
 270 |     "scaling = 1 # scaling of the data\n",
 271 |     "coeffs = [0.15 + 0.15j]*degree # coefficients of non-zero frequencies\n",
 272 |     "coeff0 = 0.1 # coefficient of zero frequency\n",
 273 |     "\n",
 274 |     "def target_function(x):\n",
 275 |     "    \"\"\"Generate a truncated Fourier series of degree, where the data gets re-scaled.\"\"\"\n",
 276 |     "    res = coeff0\n",
 277 |     "    for idx, coeff in enumerate(coeffs):\n",
 278 |     "        exponent = np.complex(0, scaling*(idx+1)*x)\n",
 279 |     "        conj_coeff = np.conjugate(coeff)\n",
 280 |     "        res += coeff * np.exp(exponent) + conj_coeff * np.exp(-exponent)\n",
 281 |     "    return np.real(res)"
 282 |    ]
 283 |   },
 284 |   {
 285 |    "cell_type": "markdown",
 286 |    "metadata": {},
 287 |    "source": [
 288 |     "Let's have a look at it.\n",
 289 |     "\n",
 290 |     "\n"
 291 |    ]
 292 |   },
 293 |   {
 294 |    "cell_type": "code",
 295 |    "execution_count": 4,
 296 |    "metadata": {},
 297 |    "outputs": [
 298 |     {
 299 |      "data": {
 300 |       "image/png": "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\n",
 301 |       "text/plain": [
 302 |        "<Figure size 432x288 with 1 Axes>"
 303 |       ]
 304 |      },
 305 |      "metadata": {
 306 |       "needs_background": "light"
 307 |      },
 308 |      "output_type": "display_data"
 309 |     }
 310 |    ],
 311 |    "source": [
 312 |     "x = np.linspace(-6, 6, 70)\n",
 313 |     "target_y = np.array([target_function(x_) for x_ in x])\n",
 314 |     "\n",
 315 |     "plt.plot(x, target_y, c='black')\n",
 316 |     "plt.scatter(x, target_y, facecolor='white', edgecolor='black')\n",
 317 |     "plt.ylim(-1, 1)\n",
 318 |     "plt.show()"
 319 |    ]
 320 |   },
 321 |   {
 322 |    "cell_type": "markdown",
 323 |    "metadata": {},
 324 |    "source": [
 325 |     "<div class=\"alert alert-info\"><h4>Note</h4><p>To reproduce the figures in the paper, you can use the following\n",
 326 |     "    settings in the cells above:\n",
 327 |     "\n",
 328 |     "-  For the settings\n",
 329 |     "\n",
 330 |     "       degree = 1\n",
 331 |     "       coeffs = [0.15 + 0.15j]*degree \n",
 332 |     "       coeff0 = 0.1\n",
 333 |     "\n",
 334 |     "   this function is the ground truth\n",
 335 |     "   $g(x) = \\sum_{n=-1}^1 c_{n} e^{-nix}$ from Figure 3 in the\n",
 336 |     "   paper.\n",
 337 |     "\n",
 338 |     "-  To get the ground truth $g'(x) = \\sum_{n=-2}^2 c_{n} e^{-nix}$\n",
 339 |     "   with $c_0=0.1$ $c_1 = c_2 = 0.15 - 0.15i$ from Figure 3,\n",
 340 |     "   you need to increase the degree to two:\n",
 341 |     "\n",
 342 |     "       degree = 2\n",
 343 |     "\n",
 344 |     "-  The ground truth from Figure 4 can be reproduced by changing the\n",
 345 |     "   settings to:\n",
 346 |     "\n",
 347 |     "       degree = 5 \n",
 348 |     "       coeffs = [0.05 + 0.05j]*degree \n",
 349 |     "       coeff0 = 0.0\n",
 350 |     "</p>\n",
 351 |     "</div>\n",
 352 |     "\n",
 353 |     "\n"
 354 |    ]
 355 |   },
 356 |   {
 357 |    "cell_type": "markdown",
 358 |    "metadata": {},
 359 |    "source": [
 360 |     "## Define the serial quantum model\n",
 361 |     "\n",
 362 |     "\n",
 363 |     "\n"
 364 |    ]
 365 |   },
 366 |   {
 367 |    "cell_type": "markdown",
 368 |    "metadata": {},
 369 |    "source": [
 370 |     "We now define the quantum model itself.\n",
 371 |     "\n",
 372 |     "\n"
 373 |    ]
 374 |   },
 375 |   {
 376 |    "cell_type": "code",
 377 |    "execution_count": 5,
 378 |    "metadata": {},
 379 |    "outputs": [],
 380 |    "source": [
 381 |     "scaling = 1\n",
 382 |     "\n",
 383 |     "dev = qml.device('default.qubit', wires=1)\n",
 384 |     "\n",
 385 |     "def S(x):\n",
 386 |     "    \"\"\"Data encoding circuit block.\"\"\"\n",
 387 |     "    qml.RX(scaling*x, wires=0)\n",
 388 |     "\n",
 389 |     "def W(theta):\n",
 390 |     "    \"\"\"Trainable circuit block.\"\"\"\n",
 391 |     "    qml.Rot(theta[0], theta[1], theta[2], wires=0)\n",
 392 |     "\n",
 393 |     "    \n",
 394 |     "@qml.qnode(dev)\n",
 395 |     "def serial_quantum_model(weights, x=None):\n",
 396 |     "    \n",
 397 |     "    for theta in weights[:-1]:\n",
 398 |     "        W(theta)\n",
 399 |     "        S(x)\n",
 400 |     "        \n",
 401 |     "    # L+1'th unitary\n",
 402 |     "    W(weights[-1])\n",
 403 |     "    \n",
 404 |     "    return qml.expval(qml.PauliZ(wires=0))"
 405 |    ]
 406 |   },
 407 |   {
 408 |    "cell_type": "markdown",
 409 |    "metadata": {},
 410 |    "source": [
 411 |     "You can run the following cell multiple times, each time sampling\n",
 412 |     "different weights, and therefore different quantum models.\n",
 413 |     "\n",
 414 |     "\n"
 415 |    ]
 416 |   },
 417 |   {
 418 |    "cell_type": "code",
 419 |    "execution_count": 6,
 420 |    "metadata": {},
 421 |    "outputs": [
 422 |     {
 423 |      "data": {
 424 |       "image/png": "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\n",
 425 |       "text/plain": [
 426 |        "<Figure size 432x288 with 1 Axes>"
 427 |       ]
 428 |      },
 429 |      "metadata": {
 430 |       "needs_background": "light"
 431 |      },
 432 |      "output_type": "display_data"
 433 |     }
 434 |    ],
 435 |    "source": [
 436 |     "r = 1 # number of times the encoding gets repeated (here equal to the number of layers)\n",
 437 |     "weights = 2*np.pi*np.random.random(size=(r+1, 3)) # some random initial weights\n",
 438 |     "\n",
 439 |     "x = np.linspace(-6, 6, 70)\n",
 440 |     "random_quantum_model_y = [serial_quantum_model(weights, x=x_) for x_ in x]\n",
 441 |     "\n",
 442 |     "plt.plot(x, random_quantum_model_y, c='blue')\n",
 443 |     "plt.ylim(-1,1)\n",
 444 |     "plt.show()"
 445 |    ]
 446 |   },
 447 |   {
 448 |    "cell_type": "markdown",
 449 |    "metadata": {},
 450 |    "source": [
 451 |     "No matter what weights are picked, the single qubit model for `L=1` will always be a sine function \n",
 452 |     "of a fixed frequency. The weights merely influence the amplitude, y-shift and phase of the sine.\n",
 453 |     "\n",
 454 |     "This observation is formally derived in Section II.A of the paper.\n",
 455 |     "\n",
 456 |     "\n"
 457 |    ]
 458 |   },
 459 |   {
 460 |    "cell_type": "markdown",
 461 |    "metadata": {},
 462 |    "source": [
 463 |     "<div class=\"alert alert-info\"><h4>Note</h4><p>You can increase the number of layers. Figure 4 from the paper, for\n",
 464 |     "    example, uses the settings <code>L=1</code>, <code>L=3</code> and <code>L=5</code>.\n",
 465 |     "</p></div>\n",
 466 |     "\n",
 467 |     "\n"
 468 |    ]
 469 |   },
 470 |   {
 471 |    "cell_type": "markdown",
 472 |    "metadata": {},
 473 |    "source": [
 474 |     "Finally, let's look at the circuit we just created:\n",
 475 |     "\n",
 476 |     "\n"
 477 |    ]
 478 |   },
 479 |   {
 480 |    "cell_type": "code",
 481 |    "execution_count": 7,
 482 |    "metadata": {},
 483 |    "outputs": [
 484 |     {
 485 |      "name": "stdout",
 486 |      "output_type": "stream",
 487 |      "text": [
 488 |       " 0: ──Rot(2.353, 5.974, 4.599)──RX(6.0)──Rot(3.761, 0.98, 0.98)──┤ ⟨Z⟩ \n",
 489 |       "\n"
 490 |      ]
 491 |     }
 492 |    ],
 493 |    "source": [
 494 |     "print(serial_quantum_model.draw())"
 495 |    ]
 496 |   },
 497 |   {
 498 |    "cell_type": "markdown",
 499 |    "metadata": {},
 500 |    "source": [
 501 |     "## Fit the model to the target\n",
 502 |     "\n"
 503 |    ]
 504 |   },
 505 |   {
 506 |    "cell_type": "markdown",
 507 |    "metadata": {},
 508 |    "source": [
 509 |     "The next step is to optimise the weights in order to fit the ground\n",
 510 |     "truth.\n",
 511 |     "\n",
 512 |     "\n"
 513 |    ]
 514 |   },
 515 |   {
 516 |    "cell_type": "code",
 517 |    "execution_count": 8,
 518 |    "metadata": {},
 519 |    "outputs": [
 520 |     {
 521 |      "name": "stdout",
 522 |      "output_type": "stream",
 523 |      "text": [
 524 |       "Cost at step  10: 0.04735694890119539\n",
 525 |       "Cost at step  20: 0.04193426710325411\n",
 526 |       "Cost at step  30: 0.005607479361325099\n",
 527 |       "Cost at step  40: 0.004608455923986264\n",
 528 |       "Cost at step  50: 0.0016064517040624462\n",
 529 |       "Cost at step  60: 0.00026294046873734974\n"
 530 |      ]
 531 |     }
 532 |    ],
 533 |    "source": [
 534 |     "def cost(weights, x, y):\n",
 535 |     "    predictions = [serial_quantum_model(weights, x=x_) for x_ in x]\n",
 536 |     "    return square_loss(y, predictions)\n",
 537 |     "\n",
 538 |     "max_steps = 60\n",
 539 |     "opt = qml.AdamOptimizer(0.3)\n",
 540 |     "batch_size = 25\n",
 541 |     "cst = [cost(weights, x, target_y)]  # initial cost\n",
 542 |     "\n",
 543 |     "for step in range(max_steps):\n",
 544 |     "\n",
 545 |     "    # Select batch of data\n",
 546 |     "    batch_index = np.random.randint(0, len(x), (batch_size,))\n",
 547 |     "    x_batch = x[batch_index]\n",
 548 |     "    y_batch = target_y[batch_index]\n",
 549 |     "\n",
 550 |     "    # Update the weights by one optimizer step\n",
 551 |     "    weights = opt.step(lambda w: cost(w, x_batch, y_batch), weights)\n",
 552 |     "\n",
 553 |     "    # Save, and possibly print, the current cost\n",
 554 |     "    c = cost(weights, x, target_y)\n",
 555 |     "    cst.append(c)\n",
 556 |     "    if (step + 1) % 10 == 0:\n",
 557 |     "        print(\"Cost at step {0:3}: {1}\".format(step + 1, c))"
 558 |    ]
 559 |   },
 560 |   {
 561 |    "cell_type": "markdown",
 562 |    "metadata": {},
 563 |    "source": [
 564 |     "To continue training, you may just run the above cell again. Once you\n",
 565 |     "are happy, you can use the trained model to predict function values, and\n",
 566 |     "compare them with the ground truth.\n",
 567 |     "\n",
 568 |     "\n"
 569 |    ]
 570 |   },
 571 |   {
 572 |    "cell_type": "code",
 573 |    "execution_count": 9,
 574 |    "metadata": {},
 575 |    "outputs": [
 576 |     {
 577 |      "data": {
 578 |       "image/png": "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\n",
 579 |       "text/plain": [
 580 |        "<Figure size 432x288 with 1 Axes>"
 581 |       ]
 582 |      },
 583 |      "metadata": {
 584 |       "needs_background": "light"
 585 |      },
 586 |      "output_type": "display_data"
 587 |     }
 588 |    ],
 589 |    "source": [
 590 |     "predictions = [serial_quantum_model(weights, x=x_) for x_ in x]\n",
 591 |     "\n",
 592 |     "plt.plot(x, target_y, c='black')\n",
 593 |     "plt.scatter(x, target_y, facecolor='white', edgecolor='black')\n",
 594 |     "plt.plot(x, predictions, c='blue')\n",
 595 |     "plt.ylim(-1,1)\n",
 596 |     "plt.show()"
 597 |    ]
 598 |   },
 599 |   {
 600 |    "cell_type": "markdown",
 601 |    "metadata": {},
 602 |    "source": [
 603 |     "Let's also have a look at the cost during training.\n",
 604 |     "\n",
 605 |     "\n"
 606 |    ]
 607 |   },
 608 |   {
 609 |    "cell_type": "code",
 610 |    "execution_count": 10,
 611 |    "metadata": {},
 612 |    "outputs": [
 613 |     {
 614 |      "data": {
 615 |       "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deZRcZ33m8e+vtu6q3lvq1tJaWrIkS7JkS1ZLtjEYjMGxM8QmxIBNIDYYPCT2DDmESUxIYDA5QxImEAgeBwdEBgi2iU2Cj+PEEd5gvKrlRbIkW5u1dFtSd0vqfa2qd/64t+VSqyT1dru6up/POXWq6t5bVb8rlerRfd/3vtecc4iIiAwVynUBIiIyOSkgREQkKwWEiIhkpYAQEZGsFBAiIpJVJNcFjJeZM2e62traXJchIpJXtmzZ0uKcq8q2bsoERG1tLfX19bkuQ0Qkr5jZgTOtm/ZNTG09A9z50Fae3duS61JERCaVaR8Qzjnu33yI1w935LoUEZFJZdoHRGE0DEDPQCrHlYiITC7TPiAKIiFCBj39CggRkUzTPiDMjEQsQrcCQkTkFNM+IADisTA9A8lclyEiMqkoIIB4NKwjCBGRIRQQQCIWVh+EiMgQCggGm5gUECIimRQQqIlJRCQbBQRqYhIRyUYBAcRjETUxiYgMoYAA4tEQ3f0a5ioikkkBASRiETUxiYgMoYBAo5hERLJRQACJaJiBlGMglc51KSIik4YCAu8IAtBQVxGRDAoI3g6IXjUziYicpIDAOw8CdAQhIpJJAYF3JjWgoa4iIhkUEHgnyoGamEREMikgUBOTiEg2Cggym5gUECIigxQQaBSTiEg2gQaEmV1jZm+Y2R4zuzPL+s+b2Q4z22pmj5vZwox1N5vZbv92c5B1qolJROR0gQWEmYWBu4FrgZXATWa2cshmLwN1zrkLgQeBv/ZfWwl8BbgE2AB8xcwqgqo1EfU6qRUQIiJvC/IIYgOwxzm3zznXD9wPXJ+5gXPuSedct//0eWCe//g3gE3OuePOuRPAJuCaoAotjHl/DD0a5ioiclKQAVEDHMp43uAvO5NbgX8fyWvN7DYzqzez+ubm5lEXGguHCIdME/aJiGSYFJ3UZvZxoA74xkhe55y71zlX55yrq6qqGsvnk9BlR0VEThFkQDQC8zOez/OXncLM3gd8CbjOOdc3kteOp0JddlRE5BRBBsRmYKmZLTKzGHAj8HDmBma2FvgeXjg0Zax6DLjazCr8zumr/WWBSeiaECIip4gE9cbOuaSZ3YH3wx4GNjrntpvZXUC9c+5hvCalYuCfzQzgoHPuOufccTP7Gl7IANzlnDseVK3gnSynJiYRkbcFFhAAzrlHgUeHLPtyxuP3neW1G4GNwVV3qriamERETjEpOqknAzUxiYicSgHhi0cjamISEcmggPAlYmGdKCcikkEB4VMntYjIqRQQvrj6IERETqGA8CU0iklE5BQKCF88GiaZdvQn07kuRURkUlBA+AYvGqRmJhERjwLCl4h55wyqmUlExKOA8L19VTkNdRURAQXESYVRNTGJiGRSQPgGjyDUxCQi4lFA+N5uYlJAiIiAAuKkwSYmBYSIiEcB4Rs8guhVH4SICKCAOGlwmKuOIEREPAoIXzyqYa4iIpkUEL64mphERE6hgPDFIiEiIVMTk4iITwGRIR7TNSFERAYpIDLEo2E1MYmI+BQQGRI6ghAROUkBkSEeiyggRER8CogM8WiIngENcxURAQXEKRKxiCbrExHxKSAyaBSTiMjbFBAZ4tGwrgchIuJTQGRIxMJqYhIR8SkgMsQVECIiJykgMiRiYboHUjjncl2KiEjOKSAyxKNhUmnHQEoBISKigMgQ968JoWYmEREFxClOXpdaJ8uJiCggMsV1XWoRkZMUEBkGLxqkJiYREQXEKQabmHSynIiIAuIUJ/sgdAQhIqKAyFQYVROTiMigQAPCzK4xszfMbI+Z3Zll/RVm9pKZJc3shiHrUmb2in97OMg6ByUGh7lqFJOICJGg3tjMwsDdwPuBBmCzmT3snNuRsdlB4BbgC1neosc5tyao+rJRE5OIyNsCCwhgA7DHObcPwMzuB64HTgaEc26/vy4dYB3DpiYmEZG3BdnEVAMcynje4C8brkIzqzez583sg9k2MLPb/G3qm5ubx1IrkDGKSQEhIjKpO6kXOufqgI8Bf2tm5w3dwDl3r3OuzjlXV1VVNeYPjIZDRMNGt4a5iogEGhCNwPyM5/P8ZcPinGv07/cBTwFrx7O4MymMaspvEREINiA2A0vNbJGZxYAbgWGNRjKzCjMr8B/PBC4no+8iSLpokIiIJ7CAcM4lgTuAx4CdwM+cc9vN7C4zuw7AzNabWQPwYeB7Zrbdf/kKoN7MXgWeBP5yyOinwCRiETUxiYgQ7CgmnHOPAo8OWfbljMeb8Zqehr7uWWB1kLWdSTwapqdf50GIiEzmTuqciMfCmotJRAQFxGkSsbBOlBMRQQFxmrhGMYmIAAqI06iJSUTEo4AYQk1MIiIeBcQQ8WhETUwiIiggThOPhejuT+KcG9f33dvcycFj3eP6niIiQQr0PIh8lIhFSDvoT6UpiITH/H4HjnXxrU27+MWrbzGvIs7TX7iSUMjGoVIRkWApIIaIZ0z5PZaAONrey3ce380Dmw8RCRtXnl/NE6838f/2tHDFsrFPLCgiEjQFxBCZFw0qT4zuPX7y/AG+9sgO0s7xsUsWcMeVSyiNR7ns649z/+aDCggRyQsKiCHig9eEGMNQ1+88vpsVc0r5u5vWMr/y7ZT50MXz+NFz+2np7GNmccFYSxURCZQ6qYeIj/Gqckfbe2nq6OP6NXNPCQeAmzbMZyDleGhLw5jrFBEJmgJiiETMO6ga7bkQWxvaALhwXtlp65ZUl1C3sIIHNh8a91FSIiLjTQExRDzm/ZGMtolpW0Mr4ZCxcs7pAQFw44YF7Gvp4oU3j4+6RhGRiaCAGCIe9Y4gRjvl99bGNpZWF5/syxjqv6yeQ0lhhPtfPDjqGkVEJoICYojMUUwj5Zxja0Nb1ualQfFYmA+uqeHR147Q2t0/6jpFRIKmgBhiLAHR2NrD8a5+Vs8rP+t2N26YT38yzc9fGvYlukVEJpwCYohCPyB6R9EHsW2wg7rmzEcQABfMLeOieWXcv/mgOqtFZNJSQAyRiI7+CGJrYxvRsLF8Tsk5t71xwwJ2He3kpYOtI/4cEZGJMKyAMLMfD2fZVBAJh4iFQ6MKiG0NbZw/u2RYU3T81kVzScTC6qwWkUlruEcQF2Q+MbMwsG78y5kcCqOhETcxeR3UrayuOXv/w6DiggjXXDCbTTuPqplJRCalswaEmX3RzDqAC82s3b91AE3ALyakwhxIxCJ0j3CY68Hj3bT3Js86gmmo9Ysqae0e4ICmAReRSeisAeGc+7pzrgT4hnOu1L+VOOdmOOe+OEE1TrjRXFXu1bOcQX0ma+Z7RxsvHzoxos8SEZkIw21iesTMigDM7ONm9k0zWxhgXTlVGA2PeC6mbQ2txCIhls06dwf1oGWzSkjEwryijmoRmYSGGxD3AN1mdhHwR8Be4EeBVZVjiVh4xFNtbG1oY+WcUqLh4Q8MC4eM1TVlvHJIASEik89wf82SzutJvR74rnPubmD4/1XOM/ERNjGl047XGs9+BvWZrF1QwY7D7aM670JEJEjDDYgOM/si8Ang38wsBESDKyu3ErGRNTHta+miqz/F6nOcIJfNmvnlDKQc299qH/FrRUSCNNyA+CjQB3zKOXcEmAd8I7CqciweHVkT07ZGr4nownNMsZHN2gXea9TMJCKTzbACwg+FfwLKzOwDQK9zbsr2QcRjkRE1MW1taCMeDXNeVdGIP2tWaSFzywoVECIy6Qz3TOqPAC8CHwY+ArxgZjcEWVgueU1Mwz8PYmtDG6tqSomMoIM605oF5bx8UENdRWRyGe4v2peA9c65m51zvwdsAP48uLJya7CJaThnOCdTaba/1TbsM6izWTO/nIYTPbR09o36PURExttwAyLknGvKeH5sBK/NO/FYmLSDvmT6nNvuae6kdyA9qhFMg9YuqADQ+RAiMqkM90f+P8zsMTO7xcxuAf4NeDS4snJr8JoQwxnJNHgN6tVjCIhVc8sIh0xnVIvIpBI520ozWwLMcs79DzP7EPBOf9VzeJ3WU1J8cMrvgRQV59h2W0MbxQURFs0YeQf1yc+LhVk+u0Qd1SIyqZzrCOJvgXYA59zPnXOfd859HvgXf92UFB/JEUSj10EdCtmYPnPN/HJePdRGKq2ZXUVkcjhXQMxyzm0butBfVhtIRZNAIuYdWJ0rINJpx64jHSyfXTrmz1y7oILOviR7mzvH/F4iIuPhXAFxtqE58fEsZDJ5+7rUZx/qeqS9l56BFOdVF4/5MwdndlVHtYhMFucKiHoz+8zQhWb2aWBLMCXlXqHfB3Gus6n3NXcBjOoEuaEWzyyipDDCy+qHEJFJ4lwB8YfAJ83sKTP7G//2NHAr8LlzvbmZXWNmb5jZHjO7M8v6K8zsJTNLDj3xzsxuNrPd/u3mkezUWA13FNO+Fq856LyqsR9BhELGmvk6YU5EJo9zXTDoqHPuHcBXgf3+7avOucv86TfOyL8s6d3AtcBK4CYzWzlks4PALcBPh7y2EvgKcAneSXlfMbNzDSgaN283MZ09IPY2dVJcEKG6pGBcPnft/HJ2He2gq29kV7MTEQnCWYe5DnLOPQk8OcL33gDscc7tAzCz+/GmC9+R8b77/XVDz0j7DWCTc+64v34TcA1w3whrGJX4cJuYWrpYXFWE2dhGMA1as6CctINtjW1cunjGuLyniMhoBXk2dA1wKON5g79s3F5rZreZWb2Z1Tc3N4+60KGGO8x1X3MXi2eOvf9h0Jr53kHSy+qoFpFJIK+ny3DO3eucq3PO1VVVVY3b+yZiEUIGrT39Z9ymuz9JY2vPuPQ/DKosirFwRoJXdEa1iEwCQQZEIzA/4/k8f1nQrx2zcMhYUl3MjrNcxOfNFm8E0+JxDAjA76huHdZEgSIiQQoyIDYDS81skZnFgBuBh4f52seAq82swu+cvtpfNmFW1ZSxrbH9jD/UeweHuFaPXxMTQN3CCpo6+mg40TOu7ysiMlKBBYRzLgncgffDvhP4mXNuu5ndZWbXAZjZejNrwLvOxPfMbLv/2uPA1/BCZjNw12CH9URZXVNGS2cfR9uzT8G9r7kTM6gdwxxM2dTVVgKwef+E7q6IyGmGNYpptJxzjzJk1lfn3JczHm/Gaz7K9tqNwMYg6zubwetLb2tsY3ZZ4Wnr9zV3UVMeP3lS3XhZNquEksIIm/ef4EMXZ/2jERGZEHndSR2klXNLCZkXENnsbe4c1w7qQeGQsW5hBfU6ghCRHFNAnEEiFuG8qmJeyxIQ6bTzhriOwxQb2ayvrWR3Uycnus48ikpEJGgKiLNYXVOW9Qji5CR9ARxBgNdRDVB/QMNdRSR3FBBnsaqmjOaOPo62956yfHCSvqCOIC6aX04sHFIzk4jklALiLAYvI7qt4dSjiPGcpC+bwmiY1fPKNJJJRHJKAXEWK+eUYlk6qsd7kr5s6mor2NbYRu855oMSEQmKAuIsigqyd1SP9yR92axfWMlAyvGqrg8hIjmigDiHC7N0VO9tCmaIa6Z1fke1mplEJFcUEOewqqaMpo4+mvyO6u7+JG+19Y7rLK7ZVBTFWFpdzOb9GskkIrmhgDiHkx3V/lFEUJP0ZbN+USUvHThBKq2J+0Rk4ikgzmFoR3VQk/Rls762go6+JG8c6Qj8s0REhlJAnMPQjuqgJunLpm6hN3Ff/QH1Q4jIxFNADMPqmjK2NgwGRBfzKsZ/kr5s5lXEmV1ayItvKiBEZOIpIIYhs6N6b3Mni2cG3/8AYGbU1Vawef9xXUBIRCacAmIYBqf+3trQFugkfdlsWFTJ0XZdQEhEJp4CYhgumOt1VP9y59FAJ+nLRv0QIpIrCohhKCqIsHhmEY9uOwwEN0lfNufPLqGkIKLzIURkwikghml1TRntvUkguEn6sgmHjIt1ASERyQEFxDCt8vshgp6kL5sNiyrZdbTztGnHRUSCpIAYpsGO6qAn6cvmvcurAXji9aYJ/VwRmd4UEMN0QU0ZZhPbvDRo+ewSasrjPL7z6IR/tohMX5FcF5Avigsi/Om1K7jYn2V1IpkZ71tRzQP1h+jpTxGPBX+SnoiIjiBG4DNXLD45DfdEu2rFLHoH0jyzpyUnny8i048CIk9csriS4oIIj7+uZiYRmRgKiDxREAlzxbKZPL6zibSm/xaRCaCAyCNXLZ9FU0cfr73Vdu6NRUTGSAGRR65cXk3I4Jc71MwkIsFTQOSRyqIY6xZW8MudOh9CRIKngMgzV62YxY7D7bzVqtldRSRYCog8874V3lnVj+usahEJmAIiz5xXVUztjIT6IUQkcAqIPGNmXLViFs/tPUZXXzLX5YjIFKaAyENXraimP5Xm17t1VrWIBEcBkYfW11ZSWhjR5H0iEigFRB6KhkO85/xqnni9iWQqnetyRGSKUkDkqevXzOVYVz/3bz6U61JEZIpSQOSp9y6v5pJFlXxz0y7aewdyXY6ITEEKiDxlZvz5B1Zyoruf7z6xJ9fliMgUFGhAmNk1ZvaGme0xszuzrC8wswf89S+YWa2/vNbMeszsFf/290HWma9W1ZTx4XXz+OEzb7K/pSvX5YjIFBNYQJhZGLgbuBZYCdxkZiuHbHYrcMI5twT4FvBXGev2OufW+LfPBlVnvvvC1ecTDYf4+r/vzHUpIjLFBHkEsQHY45zb55zrB+4Hrh+yzfXA//UfPwhcZWYWYE1TTnVpIbdfuYTHth/l2b06L0JExk+QAVEDZA6xafCXZd3GOZcE2oAZ/rpFZvaymT1tZu8KsM68d+s7F1FTHucvHtlJShcTEpFxMlk7qQ8DC5xza4HPAz81s9KhG5nZbWZWb2b1zc3NE17kZFEYDXPntcvZcbidB7do2KuIjI8gA6IRmJ/xfJ6/LOs2ZhYByoBjzrk+59wxAOfcFmAvsGzoBzjn7nXO1Tnn6qqqqgLYhfzxgQvnsG5hBd94bBdH2npzXY6ITAFBBsRmYKmZLTKzGHAj8PCQbR4GbvYf3wA84ZxzZlbld3JjZouBpcC+AGvNe2bGV6+7gJ7+JL9zz7Psbe7MdUkikucCCwi/T+EO4DFgJ/Az59x2M7vLzK7zN/sBMMPM9uA1JQ0Ohb0C2Gpmr+B1Xn/WOXc8qFqnilU1ZTzwXy+jL5nihnue5ZVDrbkuSUTymDk3NTo16+rqXH19fa7LmBT2t3TxextfpKWzj3s+vo53L8t981sq7XhmTwsPbmlgX0sn/cn027eUY0FlnFvfuZhrVs0mHNJANpGJYmZbnHN1WdcpIKampo5ebt64md1HO/ibj1zE9WuGDiCbGAeOdfHglgYe3NLA4bZeyhNR1s4vpyASJhYJEYuEiIaN5/YeY/+xbhZUJvj0uxbx4XXzicfCOalZZDpRQExT7b0D3Pajep7fd5yrllfzB1eex7qFlYF+ZjKVZmtjG7/e1cLTu5p46WArIYMrllXxkbr5XLWimoLI6T/8qbRj044j/P3T+3jlUCsViSi//57z+My7FqNTY0SCo4CYxnoHUvzDr/ax8Zk3OdE9wCWLKrn9yiW8a+nMcfvhbWzt4Ve7mvnVrmae2dNCe28SM7iwpoyrL5jN71w8j9llhcN6L+ccm/ef4O4n9/D0rmY+tLaGv/ydC4lFJuuIbJH8poAQuvuT3PfiIf7hV/s40t7LBXNLef/KWdQtrGTtgnKKCiLDfq/egRT1+0/w1BtNPL2rmd1N3oipOWWFXLG0inctm8nl582koig26nqdc3z3iT38zaZdXLZ4Bn//iXWUxaOjfj8RyU4BISf1JVP868uN/Pj5A2x/qx3nIBwyVswpYd2CCmYWF5AoiJCIhUnEwhREwhxt7+XNli72H+tif0sXh070kEo7YuEQlyyu5N3Lqnj3siqWVBePe3PQQ1sa+JOHtrK4qoh//OQG5pbHx/X9RaY7BYRk1d47wMsHW9my/zib959ga0MrXf2prNsmYmFqZxSxaGYRtTMTrFtYwaWLZ5CIDf/IY7Se2dPCZ3+8hURBmI23rOeCuWWBf6bIdKGAkGEbSKXp7k/R3Z+kuz9FT3+K6pICqkoKctpZ/PqRdj75w8109ib5p89cwoXzynNWi8hUcraAUM+fnCIaDlEWjzKnLM55VcWsqimjurQw5yOJls8u5aHffwdliSi/t/FFXj/SntN6RKYDBYTkjbnlcX766UspjIT5+Pdf0HQiIgFTQEheWTAjwU8+fQkAv/sPL3DwWHeOKxKZuhQQkneWVBfz41svoTeZ4mPff563WntyXZLIlKSAkLy0Yk4pP/rUBtq6B/j491/gWGdfrksSmXIUEJK3LpxXzg8/uZ7G1h4+9Y+b6epL5rokkSlFASF5ra62ku9+7GK2NbZx+09fYiCVznVJIlOGAkLy3vtXzuJ//fZqnnqjmTsf2sZUObdHJNeCPw1WZALcuGEBTR19fHPTLqpLC/iTa5bnuiSRvKeAkCnjv713CUfbe7nnqb1UlxTwycsX5bokkbymgJApw8y46/pVtHT2cdcjO6idUcSVy6tzXZZI3lIfhEwp4ZDx7RvXsmJ2KZ+7/2X2t3TluiSRvKWAkCmnMBrme59YRyhkfPYnW+ju1/BXkdFQQMiUNL8ywXduXMuuox388YNbNbJJZBQUEDJlXbGsii/8xvk8svUw3//1m7kuRyTvKCBkSvv9d5/Htatm8/V/38mze1pyXY5IXlFAyJRmZnzjwxexuKqYO+57mQPH1GktMlwKCJnyigsi3PuJdaSd4+aNL9Kiif1EhkUBIdPC4qpifnDzeo609/LJH2piP5HhUEDItLFuYQV3f+xidhxu57M/2UJ/UhP7iZyNAkKmlatWzOLrv72aX+9u4Y8ffJV0WsNfRc5EU23ItPOR9fNp6ujlf//nLqpLC/nT31yR65JEJiUFhExLt1+5hKaOPu791T76k2n+/AMrCYcs12WJTCoKCJmWzIyv/NYFREIhNj7zJgePd/Odm9ZSXKB/EiKD1Ach01Y4ZHz5t1byFx9cxdO7mrnhnmdpbO3JdVkik4YCQqa9j1+6kB/esp7GEz188O5nePVQa65LEpkUFBAiePM2/fwP3kFBJMRH732Ob23aRVvPQK7LEskpBYSIb+msEv719st5z7Jqvv34bt75V08oKGRas6kyDXJdXZ2rr6/PdRkyRWx/q43vPL6bx7YfpaQwwqcuX8SVy6tZWl1M0TA7svuSKZra+2jq6ON4Vz+t3f209Qxworuf1m4vdIoKIiRiYYoLIiRiEeaUF7K6poyZxQVB7p7ISWa2xTlXl3WdAkLkzDKDYlBNeZyls4pZUlVMOGR09iXp6kvS1Z+iqy9JS6cXCoMhMFTIoDwRw4Cu/iS9A6ef0T23rJBVNWVcOK+Mi+aXc/GCimEH03hzznG8q5/Dbb00dfTSn3Q453BA2v/9qC4pZEFlguqSAkIaLpxXFBAiY3ToeDc7Drez+2gHu5s62XW0k33NnZhBUSxyypFAZVGMWaWFVJcUUF1aQHVJITOKY5THY5QXRSmORU75EU2lHd39Sbr6Uuw/1sVrjW1sbWjjtcY29vmXTA2HjAvmlrK+tpL1tZXU1VaM+1FGS2cfu452sKepk11HO9jb1MVbbT0cbusd9rQksUiI+RVxFlQmOH92Kav9kJtXEcdMwTEZKSBE8lR77wCvHGxl8/7jvPjmcV4+1Hryx3puWSGr55Vx4bxyVtWUsXx2CZVFMaLh7F2L6bSjtWeAI2297D/WxZst3m1/Sxf7Wro43tV/ctuSwghLq4uZV5FgTlkhc8oKmV0WZ1ZpAQWRMGYQMiNkkHZwpL2Xg8e7OeTf9h/rZk9TBwMp7/elPBFldU0ZK+aUsrS6mGWzSlg6q5hEbHyPigZSafqSaSIhIxIywiFTMJ1DzgLCzK4Bvg2Ege875/5yyPoC4EfAOuAY8FHn3H5/3ReBW4EU8N+dc4+d7bMUEDId9CVTbGto4+WDrWxrbGNbYxtvtpx6jYuSwggzimJUFMWIR8Mc7+qnpbOf4119DJ16qrqkgEUzi1hcVcSS6hKWzfJ+vKtLCsb8w9qXTPHGkQ62NbadPCra3dR5ytHIvIo48yrizCguYGZRjBnFBcwojlEQCZNOO1LOkUo70s7RO5CirWeAtp4B2nuS3n3vAB29Sdp7vPuegdRpdUTDRmE0TFVJAVXFBVT7R3ezSwtZMCPBoplFLKhMUBgNj2l/81VOAsLMwsAu4P1AA7AZuMk5tyNjmz8ALnTOfdbMbgR+2zn3UTNbCdwHbADmAr8EljnnTv/b9ykgZLpq7x3wmqOavaOAzFvPQIrKohgzi2PMKPJ+fKtKCqidUUTtzKIJP3M8lXYcONbFrqNeM9auox0cbe/lWGc/LZ19tPeefRr2cMgoLYxQFo9SFo9SUhilNB6htDBKSaF3XxANkUw7UinHQNqRTKXp7k/R3NFHU0cvTR19NLX3nRYmc8q8fpTBo6XZpQXMLotTXVpAIhamIBKmIBKiMBomGjaSKUd/Kk1/0jtq6Uum6OxN0t6bpCMjuLr6U/T0J+nuT9E9kKK3P8VA2pFKp73wS0MynSYaDhGPhYlHwxT6t0QsTFEsTKIg4t3HIhRGw8QiIQoioZP3pfEo51UVj+rv5GwBEeS3YwOwxzm3zy/ifuB6YEfGNtcD/9N//CDwXfP+23I9cL9zrg9408z2+O/3XID1iuSl0sIo7zhvJu84b2auSzmncMhYXFXM4qpirlk1+7T1fckUx7v6GUg6QiFve68py4j7P5bj0WTknKOtZ4ADx7rZf6zr5P3BY93UHzjB0fbDJ5vHxioaNuJR78c9EQsTj4WJhENeE5gZoRDEI2EGUt5ggJ7+FL3JFD393q17IMW5/h9/0fxyfnH75eNSb6YgA6IGOJTxvAG45EzbOOeSZtYGzPCXPz/ktTVDP8DMbgNu8592mtkbY6h3JjAVLlo8VfYDtC+T1VTZl6myH7BmcPMAAAXMSURBVByAmXbHqPdl4ZlW5PXMZM65e4F7x+O9zKz+TIdZ+WSq7AdoXyarqbIvU2U/ILh9CfJM6kZgfsbzef6yrNuYWQQow+usHs5rRUQkQEEGxGZgqZktMrMYcCPw8JBtHgZu9h/fADzhvF7zh4EbzazAzBYBS4EXA6xVRESGCKyJye9TuAN4DG+Y60bn3HYzuwuod849DPwA+LHfCX0cL0Twt/sZXod2Erj9bCOYxsm4NFVNAlNlP0D7MllNlX2ZKvsBAe3LlDlRTkRExpdmcxURkawUECIiktW0Dwgzu8bM3jCzPWZ2Z67rGQkz22hmTWb2WsaySjPbZGa7/fuKXNY4XGY238yeNLMdZrbdzD7nL8+r/TGzQjN70cxe9ffjq/7yRWb2gv89e8AfuJEXzCxsZi+b2SP+87zcFzPbb2bbzOwVM6v3l+XV9wvAzMrN7EEze93MdprZZUHtx7QOCH86kLuBa4GVwE3+NB/54h+Ba4YsuxN43Dm3FHjcf54PksAfOedWApcCt/t/F/m2P33Ae51zFwFrgGvM7FLgr4BvOeeWACfw5hnLF58DdmY8z+d9udI5tybjnIF8+36BN7/dfzjnlgMX4f3dBLMfzrlpewMuAx7LeP5F4Iu5rmuE+1ALvJbx/A1gjv94DvBGrmsc5X79Am8er7zdHyABvIQ3g0ALEPGXn/K9m8w3vHOQHgfeCzwCWB7vy35g5pBlefX9wjtX7E38AUZB78e0PoIg+3Qgp03pkWdmOecO+4+PALNyWcxomFktsBZ4gTzcH79J5hWgCdgE7AVanXODM9Hl0/fsb4E/BganYJ1B/u6LA/7TzLb40/RA/n2/FgHNwA/9Zr/vm1kRAe3HdA+IKc15/53Iq3HMZlYMPAT8oXOuPXNdvuyPcy7lnFuD97/vDcDyHJc0Kmb2AaDJObcl17WMk3c65y7Ga1K+3cyuyFyZJ9+vCHAxcI9zbi3QxZDmpPHcj+keEFNxSo+jZjYHwL9vynE9w2ZmUbxw+Cfn3M/9xXm7P865VuBJvGaYcn86Gcif79nlwHVmth+4H6+Z6dvk577gnGv075uAf8EL73z7fjUADc65F/znD+IFRiD7Md0DYjjTgeSbzOlLbsZry5/0/GnefwDsdM59M2NVXu2PmVWZWbn/OI7Xj7ITLyhu8Deb9PsB4Jz7onNunnOuFu/fxhPOud8lD/fFzIrMrGTwMXA18Bp59v1yzh0BDpnZ+f6iq/BmnAhmP3Ld6ZLrG/CbeBc22gt8Kdf1jLD2+4DDwADe/yxuxWsjfhzYjXehpcpc1znMfXkn3mHxVuAV//ab+bY/wIXAy/5+vAZ82V++GG8+sT3APwMFua51hPv1HuCRfN0Xv+ZX/dv2wX/r+fb98mteA9T737F/BSqC2g9NtSEiIllN9yYmERE5AwWEiIhkpYAQEZGsFBAiIpKVAkJERLJSQIiMgZl9yZ+1das/S+glZvaHZpbIdW0iY6VhriKjZGaXAd8E3uOc6zOzmUAMeBaoc8615LRAkTHSEYTI6M0BWpxzfQB+INwAzAWeNLMnAczsajN7zsxeMrN/9uebGrw+wV/71yh40cyW5GpHRLJRQIiM3n8C881sl5n9HzN7t3PuO8BbeNcduNI/qvgz4H3OmyiuHvh8xnu0OedWA9/FmzlVZNKInHsTEcnGOddpZuuAdwFXAg9kuSrhpXgXo3rGm26KGPBcxvr7Mu6/FWzFIiOjgBAZA+dcCngKeMrMtvH2hGmDDNjknLvpTG9xhsciOacmJpFRMrPzzWxpxqI1wAGgAyjxlz0PXD7Yv+DPKros4zUfzbjPPLIQyTkdQYiMXjHwd/703km82U1vA24C/sPM3vL7IW4B7jOzAv91f4Y3gzBAhZltxbuW9ZmOMkRyQsNcRXLEvxCPhsPKpKUmJhERyUpHECIikpWOIEREJCsFhIiIZKWAEBGRrBQQIiKSlQJCRESy+v9Vyn9PrAwXmAAAAABJRU5ErkJggg==\n",
 616 |       "text/plain": [
 617 |        "<Figure size 432x288 with 1 Axes>"
 618 |       ]
 619 |      },
 620 |      "metadata": {
 621 |       "needs_background": "light"
 622 |      },
 623 |      "output_type": "display_data"
 624 |     }
 625 |    ],
 626 |    "source": [
 627 |     "plt.plot(range(len(cst)), cst)\n",
 628 |     "plt.ylabel(\"Cost\")\n",
 629 |     "plt.xlabel(\"Step\")\n",
 630 |     "plt.ylim(0, 0.23)\n",
 631 |     "plt.show()"
 632 |    ]
 633 |   },
 634 |   {
 635 |    "cell_type": "markdown",
 636 |    "metadata": {},
 637 |    "source": [
 638 |     "With the initial settings and enough training steps, the quantum model \n",
 639 |     "learns to fit the ground truth perfectly. This is expected, since \n",
 640 |     "the number of Pauli rotation encoding gates and the degree of the \n",
 641 |     "ground truth Fourier series are both one.\n",
 642 |     "\n",
 643 |     "If the ground truth's degree is larger than the number of layers in the\n",
 644 |     "quantum model, the fit will look much less accurate. And finally, we\n",
 645 |     "also need to have the correct scaling of the data: if one of the models\n",
 646 |     "changes the ``scaling`` parameter (which effectively scales the\n",
 647 |     "frequencies), fitting does not work even with enough encoding\n",
 648 |     "repetitions.\n",
 649 |     "\n",
 650 |     "\n"
 651 |    ]
 652 |   },
 653 |   {
 654 |    "cell_type": "markdown",
 655 |    "metadata": {},
 656 |    "source": [
 657 |     "<div class=\"alert alert-info\"><h4>Note</h4>\n",
 658 |     "    <p>\n",
 659 |     "    You will find that the training takes much longer, and needs a lot more steps to converge for \n",
 660 |     "    larger L. Some initial weights may not even converge to a good solution at all, the training \n",
 661 |     "    seems to get stuck in a minimum. It is an open research question whether for asymptotically large L, \n",
 662 |     "    the single qubit model can fit <i>any</i> function by constructing arbitrary Fourier coefficients.\n",
 663 |     "    \n",
 664 |     "</p>\n",
 665 |     "</div>\n",
 666 |     "\n",
 667 |     "\n"
 668 |    ]
 669 |   },
 670 |   {
 671 |    "cell_type": "markdown",
 672 |    "metadata": {},
 673 |    "source": [
 674 |     "# Part II: Fitting Fourier series with parallel Pauli-rotation encoding\n",
 675 |     "\n",
 676 |     "\n",
 677 |     "\n"
 678 |    ]
 679 |   },
 680 |   {
 681 |    "cell_type": "markdown",
 682 |    "metadata": {},
 683 |    "source": [
 684 |     "Our next task is to repeat the function fitting experiment for a circuit\n",
 685 |     "where the Pauli rotation gate gets repeated $r$ times on\n",
 686 |     "*different* qubits, using a single layer $L=1$.\n",
 687 |     "\n",
 688 |     "As shown in the paper, we expect similar results to the serial model: a\n",
 689 |     "Fourier series of degree $r$ can only be fitted if there are at\n",
 690 |     "least $r$ repetitions of the encoding gate in the quantum model.\n",
 691 |     "However, in practice this experiment is a bit harder, since the dimension of the\n",
 692 |     "trainable unitaries $W$ grows quickly with the number of qubits.\n",
 693 |     "\n",
 694 |     "In the paper, the investigations are made with the assumption that the\n",
 695 |     "purple trainable blocks $W$ are arbitrary unitaries. We could use\n",
 696 |     "the ``pennylane.templates.ArbitraryUnitary`` template, but since this\n",
 697 |     "template requires a number of parameters that grows exponentially with\n",
 698 |     "the number of qubits ($4^L-1$ to be precise), this quickly becomes\n",
 699 |     "cumbersome to train.\n",
 700 |     "\n",
 701 |     "We therefore follow Figure 4 in the paper and use an ansatz for\n",
 702 |     "$W$. \n",
 703 |     "\n",
 704 |     "\n"
 705 |    ]
 706 |   },
 707 |   {
 708 |    "cell_type": "markdown",
 709 |    "metadata": {},
 710 |    "source": [
 711 |     "\n",
 712 |     "<img src=\"figures/parallel_model.png\" alt=\"parallel_model\" width=\"600\" />\n",
 713 |     "\n",
 714 |     "\n",
 715 |     "\n"
 716 |    ]
 717 |   },
 718 |   {
 719 |    "cell_type": "markdown",
 720 |    "metadata": {},
 721 |    "source": [
 722 |     "## Define the parallel quantum model\n",
 723 |     "\n",
 724 |     "\n",
 725 |     "\n"
 726 |    ]
 727 |   },
 728 |   {
 729 |    "cell_type": "markdown",
 730 |    "metadata": {},
 731 |    "source": [
 732 |     "The ansatz is PennyLane's layer structure called\n",
 733 |     "``StronglyEntanglingLayers``, and as the name suggests, it has itself a\n",
 734 |     "user-defined number of layers (which we will call \"ansatz layers\" to\n",
 735 |     "avoid confusion).\n",
 736 |     "\n",
 737 |     "\n"
 738 |    ]
 739 |   },
 740 |   {
 741 |    "cell_type": "code",
 742 |    "execution_count": 11,
 743 |    "metadata": {},
 744 |    "outputs": [],
 745 |    "source": [
 746 |     "from pennylane.templates import StronglyEntanglingLayers"
 747 |    ]
 748 |   },
 749 |   {
 750 |    "cell_type": "markdown",
 751 |    "metadata": {},
 752 |    "source": [
 753 |     "Let's have a quick look at the ansatz itself for 3 qubits by making a\n",
 754 |     "dummy circuit of 2 ansatz layers:\n",
 755 |     "\n",
 756 |     "\n"
 757 |    ]
 758 |   },
 759 |   {
 760 |    "cell_type": "code",
 761 |    "execution_count": 12,
 762 |    "metadata": {},
 763 |    "outputs": [
 764 |     {
 765 |      "name": "stdout",
 766 |      "output_type": "stream",
 767 |      "text": [
 768 |       " 0: ──Rot(2.65, 1.739, 3.722)───╭C────────────────────────────────╭X──Rot(4.498, 5.712, 1.129)──╭C──╭X──────┤ ⟨I⟩ \n",
 769 |       " 1: ──Rot(5.733, 1.324, 3.914)──╰X──╭C──Rot(1.493, 6.103, 1.137)──│─────────────────────────────│───╰C──╭X──┤     \n",
 770 |       " 2: ──Rot(3.968, 4.606, 0.827)──────╰X────────────────────────────╰C──Rot(5.368, 3.093, 1.553)──╰X──────╰C──┤     \n",
 771 |       "\n"
 772 |      ]
 773 |     }
 774 |    ],
 775 |    "source": [
 776 |     "n_ansatz_layers = 2\n",
 777 |     "n_qubits = 3\n",
 778 |     "\n",
 779 |     "dev = qml.device('default.qubit', wires=4)\n",
 780 |     "\n",
 781 |     "@qml.qnode(dev)\n",
 782 |     "def ansatz(weights):\n",
 783 |     "    StronglyEntanglingLayers(weights, wires=range(n_qubits))\n",
 784 |     "    return qml.expval(qml.Identity(wires=0))\n",
 785 |     "\n",
 786 |     "weights_ansatz = 2*np.pi*np.random.random(size=(n_ansatz_layers, n_qubits, 3))\n",
 787 |     "\n",
 788 |     "ansatz(weights_ansatz)\n",
 789 |     "print(ansatz.draw())"
 790 |    ]
 791 |   },
 792 |   {
 793 |    "cell_type": "markdown",
 794 |    "metadata": {},
 795 |    "source": [
 796 |     "Now we define the actual quantum model.\n",
 797 |     "\n",
 798 |     "\n"
 799 |    ]
 800 |   },
 801 |   {
 802 |    "cell_type": "code",
 803 |    "execution_count": 13,
 804 |    "metadata": {},
 805 |    "outputs": [],
 806 |    "source": [
 807 |     "scaling = 1\n",
 808 |     "r = 3\n",
 809 |     "\n",
 810 |     "dev = qml.device('default.qubit', wires=r)\n",
 811 |     "\n",
 812 |     "def S(x):\n",
 813 |     "    \"\"\"Data encoding circuit block.\"\"\"\n",
 814 |     "    for w in range(r):\n",
 815 |     "        qml.RX(scaling*x, wires=w)\n",
 816 |     "\n",
 817 |     "def W(theta):\n",
 818 |     "    \"\"\"Trainable circuit block.\"\"\"\n",
 819 |     "    StronglyEntanglingLayers(theta, wires=range(r))\n",
 820 |     "\n",
 821 |     "    \n",
 822 |     "@qml.qnode(dev)\n",
 823 |     "def parallel_quantum_model(weights, x=None):\n",
 824 |     "    \n",
 825 |     "    W(weights[0])\n",
 826 |     "    S(x)        \n",
 827 |     "    W(weights[1])\n",
 828 |     "    \n",
 829 |     "    return qml.expval(qml.PauliZ(wires=0))"
 830 |    ]
 831 |   },
 832 |   {
 833 |    "cell_type": "markdown",
 834 |    "metadata": {},
 835 |    "source": [
 836 |     "Again, you can sample random weights and plot the model function:\n",
 837 |     "\n",
 838 |     "\n"
 839 |    ]
 840 |   },
 841 |   {
 842 |    "cell_type": "code",
 843 |    "execution_count": 14,
 844 |    "metadata": {},
 845 |    "outputs": [
 846 |     {
 847 |      "data": {
 848 |       "image/png": "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\n",
 849 |       "text/plain": [
 850 |        "<Figure size 432x288 with 1 Axes>"
 851 |       ]
 852 |      },
 853 |      "metadata": {
 854 |       "needs_background": "light"
 855 |      },
 856 |      "output_type": "display_data"
 857 |     }
 858 |    ],
 859 |    "source": [
 860 |     "trainable_block_layers = 3\n",
 861 |     "weights = 2*np.pi*np.random.random(size=(2, trainable_block_layers, r, 3))\n",
 862 |     "\n",
 863 |     "x = np.linspace(-6, 6, 70)\n",
 864 |     "random_quantum_model_y = [parallel_quantum_model(weights, x=x_) for x_ in x]\n",
 865 |     "\n",
 866 |     "plt.plot(x, random_quantum_model_y, c='blue')\n",
 867 |     "plt.ylim(-1,1)\n",
 868 |     "plt.show()"
 869 |    ]
 870 |   },
 871 |   {
 872 |    "cell_type": "markdown",
 873 |    "metadata": {},
 874 |    "source": [
 875 |     "## Training the model\n",
 876 |     "\n",
 877 |     "\n"
 878 |    ]
 879 |   },
 880 |   {
 881 |    "cell_type": "markdown",
 882 |    "metadata": {},
 883 |    "source": [
 884 |     "Training the model is done exactly as before, but it may take a lot\n",
 885 |     "longer this time. We set a default of 25 steps, which you should\n",
 886 |     "increase if necessary. Small models of <6 qubits\n",
 887 |     "usually converge after a few hundred steps at most -- but this\n",
 888 |     "depends on your settings.\n",
 889 |     "\n",
 890 |     "\n"
 891 |    ]
 892 |   },
 893 |   {
 894 |    "cell_type": "code",
 895 |    "execution_count": 15,
 896 |    "metadata": {},
 897 |    "outputs": [
 898 |     {
 899 |      "name": "stdout",
 900 |      "output_type": "stream",
 901 |      "text": [
 902 |       "Cost at step  10: 0.011102362525177415\n",
 903 |       "Cost at step  20: 0.0021477788868291474\n",
 904 |       "Cost at step  30: 0.002351294917690166\n",
 905 |       "Cost at step  40: 0.001760629315356983\n",
 906 |       "Cost at step  50: 0.00021352860242113969\n",
 907 |       "Cost at step  60: 0.0005118439365507868\n"
 908 |      ]
 909 |     }
 910 |    ],
 911 |    "source": [
 912 |     "def cost(weights, x, y):\n",
 913 |     "    predictions = [parallel_quantum_model(weights, x=x_) for x_ in x]\n",
 914 |     "    return square_loss(y, predictions)\n",
 915 |     "\n",
 916 |     "max_steps = 60\n",
 917 |     "opt = qml.AdamOptimizer(0.3)\n",
 918 |     "batch_size = 25\n",
 919 |     "cst = [cost(weights, x, target_y)]  # initial cost\n",
 920 |     "\n",
 921 |     "for step in range(max_steps):\n",
 922 |     "\n",
 923 |     "    # select batch of data\n",
 924 |     "    batch_index = np.random.randint(0, len(x), (batch_size,))\n",
 925 |     "    x_batch = x[batch_index]\n",
 926 |     "    y_batch = target_y[batch_index]\n",
 927 |     "\n",
 928 |     "    # update the weights by one optimizer step\n",
 929 |     "    weights = opt.step(lambda w: cost(w, x_batch, y_batch), weights)\n",
 930 |     "    \n",
 931 |     "    # save, and possibly print, the current cost\n",
 932 |     "    c = cost(weights, x, target_y)\n",
 933 |     "    cst.append(c)\n",
 934 |     "    if (step + 1) % 10 == 0:\n",
 935 |     "        print(\"Cost at step {0:3}: {1}\".format(step + 1, c))"
 936 |    ]
 937 |   },
 938 |   {
 939 |    "cell_type": "code",
 940 |    "execution_count": 16,
 941 |    "metadata": {},
 942 |    "outputs": [
 943 |     {
 944 |      "data": {
 945 |       "image/png": "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\n",
 946 |       "text/plain": [
 947 |        "<Figure size 432x288 with 1 Axes>"
 948 |       ]
 949 |      },
 950 |      "metadata": {
 951 |       "needs_background": "light"
 952 |      },
 953 |      "output_type": "display_data"
 954 |     }
 955 |    ],
 956 |    "source": [
 957 |     "predictions = [parallel_quantum_model(weights, x=x_) for x_ in x]\n",
 958 |     "\n",
 959 |     "plt.plot(x, target_y, c='black')\n",
 960 |     "plt.scatter(x, target_y, facecolor='white', edgecolor='black')\n",
 961 |     "plt.plot(x, predictions, c='blue')\n",
 962 |     "plt.ylim(-1,1)\n",
 963 |     "plt.show()"
 964 |    ]
 965 |   },
 966 |   {
 967 |    "cell_type": "code",
 968 |    "execution_count": 17,
 969 |    "metadata": {},
 970 |    "outputs": [
 971 |     {
 972 |      "data": {
 973 |       "image/png": "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\n",
 974 |       "text/plain": [
 975 |        "<Figure size 432x288 with 1 Axes>"
 976 |       ]
 977 |      },
 978 |      "metadata": {
 979 |       "needs_background": "light"
 980 |      },
 981 |      "output_type": "display_data"
 982 |     }
 983 |    ],
 984 |    "source": [
 985 |     "plt.plot(range(len(cst)), cst)\n",
 986 |     "plt.ylabel(\"Cost\")\n",
 987 |     "plt.xlabel(\"Step\")\n",
 988 |     "plt.show()"
 989 |    ]
 990 |   },
 991 |   {
 992 |    "cell_type": "markdown",
 993 |    "metadata": {},
 994 |    "source": [
 995 |     "<div class=\"alert alert-info\"><h4>Note</h4><p>To reproduce the right column in Figure 4 from the paper, use the \n",
 996 |     "    correct ground truth, $r=3$ and <code>trainable_block_layers=3</code>,\n",
 997 |     "    as well as sufficiently many training steps. The amount of steps \n",
 998 |     "    depends on the initial weights and other hyperparameters, and \n",
 999 |     "    in some settings training may not converge to zero error at all.</p></div>\n",
1000 |     "\n",
1001 |     "\n"
1002 |    ]
1003 |   },
1004 |   {
1005 |    "cell_type": "markdown",
1006 |    "metadata": {},
1007 |    "source": [
1008 |     "# Part III: Sampling Fourier coefficients\n",
1009 |     "\n",
1010 |     "\n",
1011 |     "\n"
1012 |    ]
1013 |   },
1014 |   {
1015 |    "cell_type": "markdown",
1016 |    "metadata": {},
1017 |    "source": [
1018 |     "When we use a trainable ansatz above, it is possible that even with\n",
1019 |     "enough repetitions of the data-encoding Pauli rotation, the quantum\n",
1020 |     "model cannot fit the circuit, since the expressivity of quantum models\n",
1021 |     "also depends on the Fourier coefficients the model can create.\n",
1022 |     "\n",
1023 |     "Figure 5 in [1] shows Fourier coefficients\n",
1024 |     "from quantum models sampled from a model family defined by an \n",
1025 |     "ansatz for the trainable circuit block. For this we need a\n",
1026 |     "function that numerically computes the Fourier coefficients of a\n",
1027 |     "periodic function f with period $2 \\pi$.\n",
1028 |     "\n",
1029 |     "\n"
1030 |    ]
1031 |   },
1032 |   {
1033 |    "cell_type": "code",
1034 |    "execution_count": 18,
1035 |    "metadata": {},
1036 |    "outputs": [],
1037 |    "source": [
1038 |     "def fourier_coefficients(f, K):\n",
1039 |     "    \"\"\"\n",
1040 |     "    Computes the first 2*K+1 Fourier coefficients of a 2*pi periodic function.\n",
1041 |     "    \"\"\"\n",
1042 |     "    n_coeffs = 2*K+1\n",
1043 |     "    t = np.linspace(0, 2*np.pi, n_coeffs, endpoint=False)\n",
1044 |     "    y = np.fft.rfft(f(t)) / t.size\n",
1045 |     "    return y"
1046 |    ]
1047 |   },
1048 |   {
1049 |    "cell_type": "markdown",
1050 |    "metadata": {},
1051 |    "source": [
1052 |     "## Define your quantum model\n"
1053 |    ]
1054 |   },
1055 |   {
1056 |    "cell_type": "markdown",
1057 |    "metadata": {},
1058 |    "source": [
1059 |     "Now we need to define a quantum model. This could be any model, for example one of the quantum models from\n",
1060 |     "above. We will use a slight derivation of the ``parallel_qubit_model()``\n",
1061 |     "from above, this time using the ``BasicEntanglerLayers`` ansatz:\n",
1062 |     "\n",
1063 |     "\n"
1064 |    ]
1065 |   },
1066 |   {
1067 |    "cell_type": "code",
1068 |    "execution_count": 19,
1069 |    "metadata": {},
1070 |    "outputs": [],
1071 |    "source": [
1072 |     "from pennylane.templates import BasicEntanglerLayers\n",
1073 |     "\n",
1074 |     "scaling = 1\n",
1075 |     "n_qubits = 4\n",
1076 |     "\n",
1077 |     "dev = qml.device('default.qubit', wires=n_qubits)\n",
1078 |     "\n",
1079 |     "def S(x):\n",
1080 |     "    \"\"\"Data encoding circuit block.\"\"\"\n",
1081 |     "    for w in range(n_qubits):\n",
1082 |     "        qml.RX(scaling*x, wires=w)\n",
1083 |     "\n",
1084 |     "def W(theta):\n",
1085 |     "    \"\"\"Trainable circuit block.\"\"\"\n",
1086 |     "    BasicEntanglerLayers(theta, wires=range(n_qubits))\n",
1087 |     "\n",
1088 |     "    \n",
1089 |     "@qml.qnode(dev)\n",
1090 |     "def quantum_model(weights, x=None):\n",
1091 |     "    \n",
1092 |     "    W(weights[0])\n",
1093 |     "    S(x)\n",
1094 |     "    W(weights[1])\n",
1095 |     "    \n",
1096 |     "    return qml.expval(qml.PauliZ(wires=0))"
1097 |    ]
1098 |   },
1099 |   {
1100 |    "cell_type": "markdown",
1101 |    "metadata": {},
1102 |    "source": [
1103 |     "It will also be handy to define a function that samples different random\n",
1104 |     "weights of the correct size for the model.\n",
1105 |     "\n",
1106 |     "\n"
1107 |    ]
1108 |   },
1109 |   {
1110 |    "cell_type": "code",
1111 |    "execution_count": 20,
1112 |    "metadata": {},
1113 |    "outputs": [],
1114 |    "source": [
1115 |     "n_ansatz_layers = 1\n",
1116 |     "\n",
1117 |     "def random_weights():\n",
1118 |     "    return 2 * np.pi * np.random.random(size=(2, n_ansatz_layers, n_qubits))"
1119 |    ]
1120 |   },
1121 |   {
1122 |    "cell_type": "markdown",
1123 |    "metadata": {},
1124 |    "source": [
1125 |     "Now we can compute the first few Fourier coefficients for samples from\n",
1126 |     "this model. The samples are created by randomly sampling different\n",
1127 |     "parameters using the ``random_weights()`` function.\n",
1128 |     "\n",
1129 |     "\n"
1130 |    ]
1131 |   },
1132 |   {
1133 |    "cell_type": "code",
1134 |    "execution_count": 21,
1135 |    "metadata": {},
1136 |    "outputs": [],
1137 |    "source": [
1138 |     "n_coeffs = 5\n",
1139 |     "n_samples = 100\n",
1140 |     "\n",
1141 |     "\n",
1142 |     "coeffs = []\n",
1143 |     "for i in range(n_samples):\n",
1144 |     "\n",
1145 |     "    weights = random_weights()\n",
1146 |     "\n",
1147 |     "    def f(x):\n",
1148 |     "        return np.array([quantum_model(weights, x=x_) for x_ in x])\n",
1149 |     "\n",
1150 |     "    coeffs_sample = fourier_coefficients(f, n_coeffs)\n",
1151 |     "    coeffs.append(coeffs_sample)\n",
1152 |     "\n",
1153 |     "coeffs = np.array(coeffs)\n",
1154 |     "coeffs_real = np.real(coeffs)\n",
1155 |     "coeffs_imag = np.imag(coeffs)"
1156 |    ]
1157 |   },
1158 |   {
1159 |    "cell_type": "markdown",
1160 |    "metadata": {},
1161 |    "source": [
1162 |     "Let's plot the real vs. the imaginary part of the coefficients. As a\n",
1163 |     "sanity check, the $c_0$ coefficient should be real, and therefore\n",
1164 |     "have no contribution on the y-axis.\n",
1165 |     "\n",
1166 |     "\n"
1167 |    ]
1168 |   },
1169 |   {
1170 |    "cell_type": "code",
1171 |    "execution_count": 25,
1172 |    "metadata": {},
1173 |    "outputs": [
1174 |     {
1175 |      "data": {
1176 |       "image/png": "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\n",
1177 |       "text/plain": [
1178 |        "<Figure size 1080x288 with 6 Axes>"
1179 |       ]
1180 |      },
1181 |      "metadata": {
1182 |       "needs_background": "light"
1183 |      },
1184 |      "output_type": "display_data"
1185 |     }
1186 |    ],
1187 |    "source": [
1188 |     "n_coeffs = len(coeffs_real[0])\n",
1189 |     "\n",
1190 |     "fig, ax = plt.subplots(1, n_coeffs, figsize=(15,4))\n",
1191 |     "\n",
1192 |     "for idx, ax_ in enumerate(ax):\n",
1193 |     "    ax_.set_title(r\"$c_{}$\".format(idx))\n",
1194 |     "    ax_.scatter(coeffs_real[:, idx], coeffs_imag[:, idx], s=35, facecolor='white', edgecolor='red')\n",
1195 |     "    ax_.set_aspect(\"equal\")\n",
1196 |     "    ax_.set_ylim(-1, 1)\n",
1197 |     "    ax_.set_xlim(-1, 1)\n",
1198 |     "\n",
1199 |     "\n",
1200 |     "plt.tight_layout(pad=0.5)\n",
1201 |     "plt.show()"
1202 |    ]
1203 |   },
1204 |   {
1205 |    "cell_type": "markdown",
1206 |    "metadata": {},
1207 |    "source": [
1208 |     "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 \n",
1209 |     "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",
1210 |     "\n",
1211 |     "Note also how the variance of the distribution decreases for growing\n",
1212 |     "orders of the coefficients - an effect linked to the convergence of a\n",
1213 |     "Fourier series.\n",
1214 |     "\n",
1215 |     "\n"
1216 |    ]
1217 |   },
1218 |   {
1219 |    "cell_type": "markdown",
1220 |    "metadata": {},
1221 |    "source": [
1222 |     "<div class=\"alert alert-info\"><h4>Note</h4><p>To reproduce the results from Figure 5 you have to change the ansatz (no\n",
1223 |     "    unitary, <code>BasicEntanglerLayers</code> or <code>StronglyEntanglingLayers</code>, and\n",
1224 |     "    set <code>n_ansatz_layers</code> either to $1$ or $5$. The\n",
1225 |     "    <code>StronglyEntanglingLayers</code> requires weights of shape\n",
1226 |     "    <code>size=(2, n_ansatz_layers, n_qubits, 3)</code>.</p></div>\n",
1227 |     "\n",
1228 |     "\n"
1229 |    ]
1230 |   },
1231 |   {
1232 |    "cell_type": "markdown",
1233 |    "metadata": {},
1234 |    "source": [
1235 |     "## Continuous-variable model\n",
1236 |     "\n",
1237 |     "\n",
1238 |     "Ref. [1] mentions that a phase rotation in\n",
1239 |     "continuous-variable quantum computing has a spectrum that supports *all*\n",
1240 |     "Fourier frequecies. To play with this model, we finally show you the\n",
1241 |     "code for a continuous-variable circuit. For example, to see its Fourier\n",
1242 |     "coefficients run the cell below, and then re-run the two cells above.\n",
1243 |     "\n",
1244 |     "\n"
1245 |    ]
1246 |   },
1247 |   {
1248 |    "cell_type": "code",
1249 |    "execution_count": 26,
1250 |    "metadata": {},
1251 |    "outputs": [],
1252 |    "source": [
1253 |     "var = 2\n",
1254 |     "n_ansatz_layers = 1\n",
1255 |     "dev_cv = qml.device('default.gaussian', wires=1)\n",
1256 |     "\n",
1257 |     "def S(x):\n",
1258 |     "    qml.Rotation(x, wires=0)\n",
1259 |     "\n",
1260 |     "def W(theta):\n",
1261 |     "    \"\"\"Trainable circuit block.\"\"\"\n",
1262 |     "    for r_ in range(n_ansatz_layers):\n",
1263 |     "        qml.Displacement(theta[0], theta[1], wires=0)\n",
1264 |     "        qml.Squeezing(theta[2], theta[3], wires=0)\n",
1265 |     "\n",
1266 |     "@qml.qnode(dev_cv)\n",
1267 |     "def quantum_model(weights, x=None):\n",
1268 |     "    W(weights[0])\n",
1269 |     "    S(x)\n",
1270 |     "    W(weights[1])\n",
1271 |     "    return qml.expval(qml.X(wires=0))\n",
1272 |     "\n",
1273 |     "def random_weights():\n",
1274 |     "    return np.random.normal(size=(2, 5*n_ansatz_layers), loc=0, scale=var)"
1275 |    ]
1276 |   },
1277 |   {
1278 |    "cell_type": "markdown",
1279 |    "metadata": {},
1280 |    "source": [
1281 |     "<div class=\"alert alert-info\"><h4>Note</h4>\n",
1282 |     "    <p>To find out what effect so-called \"non-Gaussian\" gates like the \n",
1283 |     "    <code>Kerr</code> gate have, you need to install the \n",
1284 |     "    <a href=\"https://pennylane-sf.readthedocs.io/en/latest/\">strawberryfields plugin</a>\n",
1285 |     "    and change the device to \n",
1286 |     "    <code>dev_cv = qml.device('strawberryfields.fock', wires=1, cutoff_dim=50)</code>.\n",
1287 |     "   </p>\n",
1288 |     " </div>\n",
1289 |     "\n",
1290 |     "\n"
1291 |    ]
1292 |   },
1293 |   {
1294 |    "cell_type": "markdown",
1295 |    "metadata": {},
1296 |    "source": [
1297 |     "References\n",
1298 |     "---------------\n",
1299 |     "\n",
1300 |     "[1] Maria Schuld, Ryan Sweke and Johannes Jakob Meyer, *The effect of data encoding on\n",
1301 |     "the expressive power of variational quantum machine learning models*, arxiv preprint arxiv:2008.08605.\n",
1302 |     "\n"
1303 |    ]
1304 |   }
1305 |  ],
1306 |  "metadata": {
1307 |   "kernelspec": {
1308 |    "display_name": "Python 3",
1309 |    "language": "python",
1310 |    "name": "python3"
1311 |   },
1312 |   "language_info": {
1313 |    "codemirror_mode": {
1314 |     "name": "ipython",
1315 |     "version": 3
1316 |    },
1317 |    "file_extension": ".py",
1318 |    "mimetype": "text/x-python",
1319 |    "name": "python",
1320 |    "nbconvert_exporter": "python",
1321 |    "pygments_lexer": "ipython3",
1322 |    "version": "3.6.9"
1323 |   }
1324 |  },
1325 |  "nbformat": 4,
1326 |  "nbformat_minor": 1
1327 | }
1328 | 


--------------------------------------------------------------------------------