{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# This cell is added by sphinx-gallery\n", "# It can be customized to whatever you like\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Training and evaluating quantum kernels\n", "\n", "\n", "Kernel methods are one of the cornerstones of classical machine learning. Here we are concerned with kernels that can be evaluated on quantum computers, *quantum kernels* for short. In this tutorial you will learn how to evaluate kernels, use them for classification and train them with gradient-based optimization, and all that using the functionality of PennyLane\\'s [kernels module](https://pennylane.readthedocs.io/en/latest/code/qml_kernels.html).\n", "\n", "## What are kernel methods?\n", "\n", "\n", "To understand what a kernel method does, let\\'s first revisit one of the simplest methods to assign binary labels to datapoints: linear classification.\n", "\n", "Imagine we want to discern two different classes of points that lie in different corners of the plane. A linear classifier corresponds to drawing a line and assigning different labels to the regions on opposing\n", "sides of the line:\n", "\n", "![](images/linear_classification.png)\n", "\n", "We can mathematically formalize this by assigning the label $y$ via\n", "\n", "$$y(\\boldsymbol{x}) = \\operatorname{sgn}(\\langle \\boldsymbol{w}, \\boldsymbol{x}\\rangle + b).$$\n", "\n", "The vector $\\boldsymbol{w}$ points perpendicular to the line and thus determine its slope. The independent term $b$ specifies the position on the plane. In this form, linear classification can also be extended to higher dimensional vectors $\\boldsymbol{x}$, where a line does not divide the entire space into two regions anymore. Instead one needs a *hyperplane*. It is immediately clear that this method is not very powerful, as datasets that are not separable by a hyperplane can\\'t be classified without error.\n", "\n", "We can actually sneak around this limitation by performing a neat trick: if we define some map $\\phi(\\boldsymbol{x})$ that *embeds* our datapoints into a larger *feature space* and then perform linear\n", "classification there, we could actually realise non-linear classification in our original space!\n", "\n", "![](images/embedding_nonlinear_classification.png)\n", "\n", "If we go back to the expression for our prediction and include the embedding, we get\n", "\n", "$$y(\\boldsymbol{x}) = \\operatorname{sgn}(\\langle \\boldsymbol{w}, \\phi(\\boldsymbol{x})\\rangle + b).$$\n", "\n", "We will forgo one tiny step, but it can be shown that for the purpose of optimal classification, we can choose the vector defining the decision boundary as a linear combination of the embedded datapoints\n", "$\\boldsymbol{w} = \\sum_i \\alpha_i \\phi(\\boldsymbol{x}_i)$. Putting this into the formula yields\n", "\n", "$$y(\\boldsymbol{x}) = \\operatorname{sgn}\\left(\\sum_i \\alpha_i \\langle \\phi(\\boldsymbol{x}_i), \\phi(\\boldsymbol{x})\\rangle + b\\right).$$\n", "\n", "This rewriting might not seem useful at first, but notice the above formula only contains inner products between vectors in the embedding space:\n", "\n", "$$k(\\boldsymbol{x}_i, \\boldsymbol{x}_j) = \\langle \\phi(\\boldsymbol{x}_i), \\phi(\\boldsymbol{x}_j)\\rangle.$$\n", "\n", "We call this function the *kernel*. It provides the advantage that we can often find an explicit formula for the kernel $k$ that makes it superfluous to actually perform the (potentially expensive) embedding $\\phi$. Consider for example the following embedding and the associated kernel:\n", "\n", "$$\\begin{aligned}\n", "\\phi((x_1, x_2)) &= (x_1^2, \\sqrt{2} x_1 x_2, x_2^2) \\\\\n", "k(\\boldsymbol{x}, \\boldsymbol{y}) &= x_1^2 y_1^2 + 2 x_1 x_2 y_1 y_2 + x_2^2 y_2^2 = \\langle \\boldsymbol{x}, \\boldsymbol{y} \\rangle^2.\n", "\\end{aligned}$$\n", "\n", "This means by just replacing the regular scalar product in our linear classification with the map $k$, we can actually express much more intricate decision boundaries!\n", "\n", "This is very important, because in many interesting cases the embedding $\\phi$ will be much costlier to compute than the kernel $k$.\n", "\n", "In this demo, we will explore one particular kind of kernel that can be realized on near-term quantum computers, namely *Quantum Embedding Kernels (QEKs)*. These are kernels that arise from embedding data into\n", "the space of quantum states. We formalize this by considering a parameterised quantum circuit $U(\\boldsymbol{x})$ that maps a datapoint $\\boldsymbol{x}$ to the state\n", "\n", "$$|\\psi(\\boldsymbol{x})\\rangle = U(\\boldsymbol{x}) |0 \\rangle.$$\n", "\n", "The kernel value is then given by the *overlap* of the associated embedded quantum states\n", "\n", "$$k(\\boldsymbol{x}_i, \\boldsymbol{x}_j) = | \\langle\\psi(\\boldsymbol{x}_i)|\\psi(\\boldsymbol{x}_j)\\rangle|^2.$$\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A toy problem\n", "\n", "\n", "In this demo, we will treat a toy problem that showcases the inner workings of classification with quantum embedding kernels, training variational embedding kernels and the available functionalities to do both in PennyLane. We of course need to start with some imports:\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from pennylane import numpy as np\n", "import matplotlib as mpl\n", "\n", "np.random.seed(1359)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And we proceed right away to create a dataset to work with, the `DoubleCake` dataset. Firstly, we define two functions to enable us to generate the data. The details of these functions are not essential for understanding the demo, so don\\'t mind them if they are confusing.\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def _make_circular_data(num_sectors):\n", " \"\"\"Generate datapoints arranged in an even circle.\"\"\"\n", " center_indices = np.array(range(0, num_sectors))\n", " sector_angle = 2 * np.pi / num_sectors\n", " angles = (center_indices + 0.5) * sector_angle\n", " x = 0.7 * np.cos(angles)\n", " y = 0.7 * np.sin(angles)\n", " labels = 2 * np.remainder(np.floor_divide(angles, sector_angle), 2) - 1\n", "\n", " return x, y, labels\n", "\n", "\n", "def make_double_cake_data(num_sectors):\n", " x1, y1, labels1 = _make_circular_data(num_sectors)\n", " x2, y2, labels2 = _make_circular_data(num_sectors)\n", "\n", " # x and y coordinates of the datapoints\n", " x = np.hstack([x1, 0.5 * x2])\n", " y = np.hstack([y1, 0.5 * y2])\n", "\n", " # Canonical form of dataset\n", " X = np.vstack([x, y]).T\n", "\n", " labels = np.hstack([labels1, -1 * labels2])\n", "\n", " # Canonical form of labels\n", " Y = labels.astype(int)\n", "\n", " return X, Y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we define a function to help plot the `DoubleCake` data:\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def plot_double_cake_data(X, Y, ax, num_sectors=None):\n", " \"\"\"Plot double cake data and corresponding sectors.\"\"\"\n", " x, y = X.T\n", " cmap = mpl.colors.ListedColormap([\"#FF0000\", \"#0000FF\"])\n", " ax.scatter(x, y, c=Y, cmap=cmap, s=25, marker=\"s\")\n", "\n", " if num_sectors is not None:\n", " sector_angle = 360 / num_sectors\n", " for i in range(num_sectors):\n", " color = [\"#FF0000\", \"#0000FF\"][(i % 2)]\n", " other_color = [\"#FF0000\", \"#0000FF\"][((i + 1) % 2)]\n", " ax.add_artist(\n", " mpl.patches.Wedge(\n", " (0, 0),\n", " 1,\n", " i * sector_angle,\n", " (i + 1) * sector_angle,\n", " lw=0,\n", " color=color,\n", " alpha=0.1,\n", " width=0.5,\n", " )\n", " )\n", " ax.add_artist(\n", " mpl.patches.Wedge(\n", " (0, 0),\n", " 0.5,\n", " i * sector_angle,\n", " (i + 1) * sector_angle,\n", " lw=0,\n", " color=other_color,\n", " alpha=0.1,\n", " )\n", " )\n", " ax.set_xlim(-1, 1)\n", "\n", " ax.set_ylim(-1, 1)\n", " ax.set_aspect(\"equal\")\n", " ax.axis(\"off\")\n", "\n", " return ax" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let\\'s now have a look at our dataset. In our example, we will work with\n", "3 sectors:\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "num_sectors = 3\n", "X, Y = make_double_cake_data(num_sectors)\n", "\n", "ax = plot_double_cake_data(X, Y, plt.gca(), num_sectors=num_sectors)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Defining a Quantum Embedding Kernel\n", "\n", "\n", "PennyLane\\'s [kernels module](https://pennylane.readthedocs.io/en/latest/code/qml_kernels.html) allows for a particularly simple implementation of Quantum Embedding Kernels. The first ingredient we need for this is an *ansatz*, which we will construct by repeating a layer as building block. Let\\'s start by defining this layer:\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import pennylane as qml\n", "\n", "\n", "def layer(x, params, wires, i0=0, inc=1):\n", " \"\"\"Building block of the embedding ansatz\"\"\"\n", " i = i0\n", " for j, wire in enumerate(wires):\n", " qml.Hadamard(wires=[wire])\n", " qml.RZ(x[i % len(x)], wires=[wire])\n", " i += inc\n", " qml.RY(params[0, j], wires=[wire])\n", "\n", " qml.broadcast(unitary=qml.CRZ, pattern=\"ring\", wires=wires, parameters=params[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To construct the ansatz, this layer is repeated multiple times, reusing the datapoint `x` but feeding different variational parameters `params` into each of them. Together, the datapoint and the variational\n", "parameters fully determine the embedding ansatz $U(\\boldsymbol{x})$. In order to construct the full kernel circuit, we also require its adjoint $U(\\boldsymbol{x})^\\dagger$, which we can obtain via `qml.adjoint`.\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def ansatz(x, params, wires):\n", " \"\"\"The embedding ansatz\"\"\"\n", " for j, layer_params in enumerate(params):\n", " layer(x, layer_params, wires, i0=j * len(wires))\n", "\n", "\n", "adjoint_ansatz = qml.adjoint(ansatz)\n", "\n", "\n", "def random_params(num_wires, num_layers):\n", " \"\"\"Generate random variational parameters in the shape for the ansatz.\"\"\"\n", " return np.random.uniform(0, 2 * np.pi, (num_layers, 2, num_wires), requires_grad=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Together with the ansatz we only need a device to run the quantum circuit on. For the purpose of this tutorial we will use PennyLane\\'s `default.qubit` device with 5 wires in analytic mode.\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [], "source": [ "dev = qml.device(\"default.qubit\", wires=5, shots=None)\n", "wires = dev.wires.tolist()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us now define the quantum circuit that realizes the kernel. We will compute the overlap of the quantum states by first applying the embedding of the first datapoint and then the adjoint of the embedding\n", "of the second datapoint. We finally extract the probabilities of observing each basis state.\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [], "source": [ "@qml.qnode(dev)\n", "def kernel_circuit(x1, x2, params):\n", " ansatz(x1, params, wires=wires)\n", " adjoint_ansatz(x2, params, wires=wires)\n", " return qml.probs(wires=wires)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The kernel function itself is now obtained by looking at the probability of observing the all-zero state at the end of the kernel circuit \\-- because of the ordering in `qml.probs`, this is the first entry:\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def kernel(x1, x2, params):\n", " return kernel_circuit(x1, x2, params)[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note\n", "\n", "An alternative way to set up the kernel circuit in PennyLane would be to use the observable type [Projector](https://pennylane.readthedocs.io/en/latest/code/api/pennylane.Projector.html).\n", "This is shown in the [demo on kernel-based training of quantum models](https://pennylane.ai/qml/demos/tutorial_kernel_based_training.html), where you will also find more background information on the kernel circuit structure itself.\n", "\n", "Before focusing on the kernel values we have to provide values for the\n", "variational parameters. At this point we fix the number of layers in the\n", "ansatz circuit to $6$.\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [], "source": [ "init_params = random_params(num_wires=5, num_layers=6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we can have a look at the kernel value between the first and the\n", "second datapoint:\n" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The kernel value between the first and second datapoint is 0.093\n" ] } ], "source": [ "kernel_value = kernel(X[0], X[1], init_params)\n", "print(f\"The kernel value between the first and second datapoint is {kernel_value:.3f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The mutual kernel values between all elements of the dataset form the\n", "*kernel matrix*. We can inspect it via the\n", "`qml.kernels.square_kernel_matrix` method, which makes use of symmetry\n", "of the kernel,\n", "$k(\\boldsymbol{x}_i,\\boldsymbol{x}_j) = k(\\boldsymbol{x}_j, \\boldsymbol{x}_i)$.\n", "In addition, the option `assume_normalized_kernel=True` ensures that we\n", "do not calculate the entries between the same datapoints, as we know\n", "them to be 1 for our noiseless simulation. Overall this means that we\n", "compute $\\frac{1}{2}(N^2-N)$ kernel values for $N$ datapoints. To\n", "include the variational parameters, we construct a `lambda` function\n", "that fixes them to the values we sampled above.\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1. 0.093 0.012 0.721 0.149 0.055]\n", " [0.093 1. 0.056 0.218 0.73 0.213]\n", " [0.012 0.056 1. 0.032 0.191 0.648]\n", " [0.721 0.218 0.032 1. 0.391 0.226]\n", " [0.149 0.73 0.191 0.391 1. 0.509]\n", " [0.055 0.213 0.648 0.226 0.509 1. ]]\n" ] } ], "source": [ "init_kernel = lambda x1, x2: kernel(x1, x2, init_params)\n", "K_init = qml.kernels.square_kernel_matrix(X, init_kernel, assume_normalized_kernel=True)\n", "\n", "with np.printoptions(precision=3, suppress=True):\n", " print(K_init)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Using the Quantum Embedding Kernel for predictions\n", "\n", "The quantum kernel alone can not be used to make predictions on a\n", "dataset, becaues it is essentially just a tool to measure the similarity\n", "between two datapoints. To perform an actual prediction we will make use\n", "of scikit-learn\\'s Support Vector Classifier (SVC).\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from sklearn.svm import SVC" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To construct the SVM, we need to supply `sklearn.svm.SVC` with a function that takes two sets of datapoints and returns the associated kernel matrix. We can make use of the function `qml.kernels.kernel_matrix` that provides this functionality. It expects the kernel to not have additional parameters besides the datapoints, which is why we again supply the variational parameters via the `lambda` function from above. Once we have this, we can let scikit-learn adjust the SVM from our Quantum Embedding Kernel.\n", "\n", "Note:\n", "This step does *not* modify the variational parameters in our circuit ansatz. What it does is solving a different optimization task for the $\\alpha$ and $b$ vectors we introduced in the beginning.\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [], "source": [ "svm = SVC(kernel=lambda X1, X2: qml.kernels.kernel_matrix(X1, X2, init_kernel)).fit(X, Y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To see how well our classifier performs we will measure which percentage of the dataset it classifies correctly.\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The accuracy of the kernel with random parameters is 0.833\n" ] } ], "source": [ "def accuracy(classifier, X, Y_target):\n", " return 1 - np.count_nonzero(classifier.predict(X) - Y_target) / len(Y_target)\n", "\n", "\n", "accuracy_init = accuracy(svm, X, Y)\n", "print(f\"The accuracy of the kernel with random parameters is {accuracy_init:.3f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We are also interested in seeing what the decision boundaries in this classification look like. This could help us spotting overfitting issues visually in more complex data sets. To this end we will introduce a second helper method.\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def plot_decision_boundaries(classifier, ax, N_gridpoints=14):\n", " _xx, _yy = np.meshgrid(np.linspace(-1, 1, N_gridpoints), np.linspace(-1, 1, N_gridpoints))\n", "\n", " _zz = np.zeros_like(_xx)\n", " for idx in np.ndindex(*_xx.shape):\n", " _zz[idx] = classifier.predict(np.array([_xx[idx], _yy[idx]])[np.newaxis, :])\n", "\n", " plot_data = {\"_xx\": _xx, \"_yy\": _yy, \"_zz\": _zz}\n", " ax.contourf(\n", " _xx,\n", " _yy,\n", " _zz,\n", " cmap=mpl.colors.ListedColormap([\"#FF0000\", \"#0000FF\"]),\n", " alpha=0.2,\n", " levels=[-1, 0, 1],\n", " )\n", " plot_double_cake_data(X, Y, ax)\n", "\n", " return plot_data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With that done, let\\'s have a look at the decision boundaries for our initial classifier:\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "init_plot_data = plot_decision_boundaries(svm, plt.gca())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see the outer points in the dataset can be correctly classified, but we still struggle with the inner circle. But remember we have a circuit\n", "with many free parameters! It is reasonable to believe we can give values to those variational parameters which improve the overall accuracy of our SVC.\n", "\n", "## Training the Quantum Embedding Kernel\n", "\n", "\n", "To be able to train the Quantum Embedding Kernel we need some measure of how well it fits the dataset in question. Performing an exhaustive search in parameter space is not a good solution because it is very\n", "resource intensive, and since the accuracy is a discrete quantity we would not be able to detect small improvements.\n", "\n", "We can, however, resort to a more specialized measure, the *kernel-target alignment*. The kernel-target alignment compares the similarity predicted by the quantum kernel to the actual labels of the training data. It is based on *kernel alignment*, a similiarity measure between two kernels with given kernel matrices $K_1$ and $K_2$:\n", "\n", "$$\\operatorname{KA}(K_1, K_2) = \\frac{\\operatorname{Tr}(K_1 K_2)}{\\sqrt{\\operatorname{Tr}(K_1^2)\\operatorname{Tr}(K_2^2)}}.$$\n", "\n", "Note\n", "\n", "Seen from a more theoretical side, $\\operatorname{KA}$ is nothing else than the cosine of the angle between the kernel matrices $K_1$ and $K_2$\n", "if we see them as vectors in the space of matrices with the Hilbert-Schmidt (or Frobenius) scalar product $\\langle A, B \\rangle = \\operatorname{Tr}(A^T B)$. This reinforces the\n", "geometric picture of how this measure relates to objects, namely two kernels, being aligned in a vector space.\n", "\n", "The training data enters the picture by defining an *ideal* kernel function that expresses the original labelling in the vector $\\boldsymbol{y}$ by assigning to two datapoints the product of the\n", "corresponding labels:\n", "\n", "$$k_{\\boldsymbol{y}}(\\boldsymbol{x}_i, \\boldsymbol{x}_j) = y_i y_j.$$\n", "\n", "The assigned kernel is thus $+1$ if both datapoints lie in the same\n", "class and $-1$ otherwise and its kernel matrix is simply given by the\n", "outer product $\\boldsymbol{y}\\boldsymbol{y}^T$. The kernel-target\n", "alignment is then defined as the kernel alignment of the kernel matrix\n", "$K$ generated by the quantum kernel and\n", "$\\boldsymbol{y}\\boldsymbol{y}^T$:\n", "\n", "$$\\operatorname{KTA}_{\\boldsymbol{y}}(K)\n", "= \\frac{\\operatorname{Tr}(K \\boldsymbol{y}\\boldsymbol{y}^T)}{\\sqrt{\\operatorname{Tr}(K^2)\\operatorname{Tr}((\\boldsymbol{y}\\boldsymbol{y}^T)^2)}}\n", "= \\frac{\\boldsymbol{y}^T K \\boldsymbol{y}}{\\sqrt{\\operatorname{Tr}(K^2)} N}$$\n", "\n", "where $N$ is the number of elements in $\\boldsymbol{y}$, that is the\n", "number of datapoints in the dataset.\n", "\n", "In summary, the kernel-target alignment effectively captures how well\n", "the kernel you chose reproduces the actual similarities of the data. It\n", "does have one drawback, however: having a high kernel-target alignment\n", "is only a necessary but not a sufficient condition for a good\n", "performance of the kernel. This means having good alignment is\n", "guaranteed for good performance, but optimal alignment will not always\n", "bring optimal training accuracy with it.\n", "\n", "Let\\'s now come back to the actual implementation. PennyLane\\'s\n", "`kernels` module allows you to easily evaluate the kernel target\n", "alignment:\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The kernel-target alignment for our dataset and random parameters is 0.081\n" ] } ], "source": [ "kta_init = qml.kernels.target_alignment(X, Y, init_kernel, assume_normalized_kernel=True)\n", "\n", "print(f\"The kernel-target alignment for our dataset and random parameters is {kta_init:.3f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let\\'s code up an optimization loop and improve the kernel-target\n", "alignment!\n", "\n", "We will make use of regular gradient descent optimization. To speed up\n", "the optimization we will not use the entire training set to compute\n", "$\\operatorname{KTA}$ but rather sample smaller subsets of the data at\n", "each step, we choose $4$ datapoints at random. Remember that\n", "PennyLane\\'s built-in optimizer works to *minimize* the cost function\n", "that is given to it, which is why we have to multiply the kernel target\n", "alignment by $-1$ to actually *maximize* it in the process.\n", "\n", "\n", "Note\n", "\n", "Currently, the function `qml.kernels.target_alignment` is not\n", "differentiable yet, making it unfit for gradient descent optimization.\n", "We therefore first define a differentiable version of this function.\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Step 50 - Alignment = 0.098\n", "Step 100 - Alignment = 0.121\n", "Step 150 - Alignment = 0.141\n", "Step 200 - Alignment = 0.173\n", "Step 250 - Alignment = 0.196\n", "Step 300 - Alignment = 0.224\n", "Step 350 - Alignment = 0.245\n", "Step 400 - Alignment = 0.261\n", "Step 450 - Alignment = 0.276\n", "Step 500 - Alignment = 0.289\n" ] } ], "source": [ "def target_alignment(\n", " X,\n", " Y,\n", " kernel,\n", " assume_normalized_kernel=False,\n", " rescale_class_labels=True,\n", "):\n", " \"\"\"Kernel-target alignment between kernel and labels.\"\"\"\n", "\n", " K = qml.kernels.square_kernel_matrix(\n", " X,\n", " kernel,\n", " assume_normalized_kernel=assume_normalized_kernel,\n", " )\n", "\n", " if rescale_class_labels:\n", " nplus = np.count_nonzero(np.array(Y) == 1)\n", " nminus = len(Y) - nplus\n", " _Y = np.array([y / nplus if y == 1 else y / nminus for y in Y])\n", " else:\n", " _Y = np.array(Y)\n", "\n", " T = np.outer(_Y, _Y)\n", " inner_product = np.sum(K * T)\n", " norm = np.sqrt(np.sum(K * K) * np.sum(T * T))\n", " inner_product = inner_product / norm\n", "\n", " return inner_product\n", "\n", "\n", "params = init_params\n", "opt = qml.GradientDescentOptimizer(0.2)\n", "\n", "for i in range(500):\n", " # Choose subset of datapoints to compute the KTA on.\n", " subset = np.random.choice(list(range(len(X))), 4)\n", " # Define the cost function for optimization\n", " cost = lambda _params: -target_alignment(\n", " X[subset],\n", " Y[subset],\n", " lambda x1, x2: kernel(x1, x2, _params),\n", " assume_normalized_kernel=True,\n", " )\n", " # Optimization step\n", " params = opt.step(cost, params)\n", "\n", " # Report the alignment on the full dataset every 50 steps.\n", " if (i + 1) % 50 == 0:\n", " current_alignment = target_alignment(\n", " X,\n", " Y,\n", " lambda x1, x2: kernel(x1, x2, params),\n", " assume_normalized_kernel=True,\n", " )\n", " print(f\"Step {i+1} - Alignment = {current_alignment:.3f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We want to assess the impact of training the parameters of the quantum\n", "kernel. Thus, let\\'s build a second support vector classifier with the\n", "trained kernel:\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# First create a kernel with the trained parameter baked into it.\n", "trained_kernel = lambda x1, x2: kernel(x1, x2, params)\n", "\n", "# Second create a kernel matrix function using the trained kernel.\n", "trained_kernel_matrix = lambda X1, X2: qml.kernels.kernel_matrix(X1, X2, trained_kernel)\n", "\n", "# Note that SVC expects the kernel argument to be a kernel matrix function.\n", "svm_trained = SVC(kernel=trained_kernel_matrix).fit(X, Y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We expect to see an accuracy improvement vs. the SVM with random\n", "parameters:\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The accuracy of a kernel with trained parameters is 1.000\n" ] } ], "source": [ "accuracy_trained = accuracy(svm_trained, X, Y)\n", "print(f\"The accuracy of a kernel with trained parameters is {accuracy_trained:.3f}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We have now achieved perfect classification!\n", "\n", "Following on the results that SVM\\'s have proven good generalisation\n", "behavior, it will be interesting to inspect the decision boundaries of\n", "our classifier:\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "trained_plot_data = plot_decision_boundaries(svm_trained, plt.gca())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Indeed, we see that now not only every data instance falls within the\n", "correct class, but also that there are no strong artifacts that would\n", "make us distrust the model. In this sense, our approach benefits from\n", "both: on one hand it can adjust itself to the dataset, and on the other\n", "hand is not expected to suffer from bad generalisation.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# How to approximate a classical kernel with a quantum computer\n", "\n", "\n", "Forget about advantages, supremacies, or speed-ups. Let us understand better what we can and cannot do with a quantum computer. More specifically, in this demo, we want to look into quantum kernels and ask whether we can replicate classical kernel functions with a quantum computer. Lots of researchers have lengthily stared at the opposite question, namely that of classical simulation of quantum algorithms. Yet, by studying what classes of functions we can realize with quantum kernels, we can gain some insight into their inner workings.\n", "\n", "Usually, in quantum machine learning (QML), we use parametrized quantum circuits (PQCs) to find good functions, whatever *good* means here. Since kernels are just one specific kind of well-defined functions, the task of finding a quantum kernel (QK) that approximates a given classical one could be posed as an optimization problem. One way to attack this task is to define a loss function quantifying the distance between both functions (the classical kernel function and the PQC-based hypothesis). This sort of approach does not help us much to gain theoretical insights about the structure of kernel-emulating quantum circuits, though.\n", "\n", "In order to build intuition, we will instead study the link between classical and quantum kernels through the lens of the Fourier representation of a kernel, which is a common tool in classical machine learning. Two functions can only have the same Fourier spectrum if they are the same function. It turns out that, for certain classes of quantum circuits, [we can theoretically describe the Fourier spectrum rather well](https://pennylane.ai/qml/demos/tutorial_expressivity_fourier_series.html).\n", "\n", "Using this theory, together with some good old-fashioned convex optimization, we will derive a quantum circuit that approximates the famous Gaussian kernel.\n", "\n", "In order to keep the demo short and sweet, we focus on one simple example. The same ideas apply to more general scenarios. So tag along if you\\'d like to see how we build\n", "a quantum kernel that approximates the well-known Gaussian kernel function!\n", "\n", "| \n", "\n", "![Schematic of the steps covered in this\n", "demo.](images/classical_kernels_flowchart.PNG)\n", "\n", "## Kernel-based Machine Learning\n", "\n", "\n", "For the purposes of this demo, a *kernel* is a real-valued function of two variables $k(x_1,x_2)$ from a given data domain $x_1, x_2\\in\\mathcal{X}$. In this demo, we\\'ll deal with real vector spaces as the data domain $\\mathcal{X}\\subseteq\\mathbb{R}^d$, of some dimension $d$. A kernel has to be symmetric with respect to exchanging both variables $k(x_1,x_2) = k(x_2,x_1)$. We also enforce kernels to be positive semi-definite, but let\\'s avoid getting lost in mathematical lingo. You can trust that all kernels featured in this demo are positive semi-definite.\n", "\n", "## Shift-invariant kernels\n", "\n", "Some kernels fulfill another important restriction, called *shift-invariance*. Shift-invariant kernels are those whose value doesn\\'t change if we add a shift to both inputs. Explicitly, for any suitable shift vector $\\zeta\\in\\mathcal{X}$, shift-invariant kernels are those for which $k(x_1+\\zeta,x_2+\\zeta)=k(x_1,x_2)$ holds. Having this property means the function can be written in terms of only one variable, which we call the *lag vector* $\\delta:=x_1-x_2\\in\\mathcal{X}$. Abusing notation a bit:\n", "\n", "$$k(x_1,x_2)=k(x_1-x_2,0) = k(\\delta).$$\n", "\n", "For shift-invariant kernels, the exchange symmetry property $k(x_1,x_2)=k(x_2,x_1)$ translates into reflection symmetry$k(\\delta)=k(-\\delta)$. Accordingly, we say $k$ is an *even function*.\n", "\n", "## Warm up: Implementing the Gaussian kernel\n", "\n", "First, let\\'s introduce a simple classical kernel that we will approximate on the quantum computer. Start importing the usual suspects:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import pennylane as qml\n", "from pennylane import numpy as np\n", "import matplotlib.pyplot as plt\n", "import math\n", "np.random.seed(53173)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We\\'ll look at the Gaussian kernel:\n", "$k_\\sigma(x_1,x_2):=e^{-\\lVert x_1-x_2\\rVert^2/2\\sigma^2}$. This\n", "function is clearly shift-invariant:\n", "\n", "$$\\begin{aligned}\n", "k_\\sigma(x_1+\\zeta,x_2+\\zeta) &= e^{-\\lVert(x_1+\\zeta)-(x_2+\\zeta)\\rVert^2/2\\sigma^2} \\\\\n", "& = e^{-\\lVert x_1-x_2\\rVert^2/2\\sigma^2} \\\\\n", "& = k_\\sigma(x_1,x_2).\n", "\\end{aligned}$$\n", "\n", "The object of our study will be a simple version of the Gaussian kernel, where we consider $1$-dimensional data, so $\\lVert x_1-x_2\\rVert^2=(x_1-x_2)^2$. Also, we take $\\sigma=1/\\sqrt{2}$ so that we further simplify the exponent. We can always re-introduce it later by rescaling the data. Again, we can write the function in terms of the lag vector only:\n", "\n", "$$k(\\delta)=e^{-\\delta^2}.$$\n", "\n", "Now let\\'s write a few lines to plot the Gaussian kernel:\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def gaussian_kernel(delta):\n", " return math.exp(-delta ** 2)\n", "\n", "def make_data(n_samples, lower=-np.pi, higher=np.pi):\n", " x = np.linspace(lower, higher, n_samples)\n", " y = np.array([gaussian_kernel(x_) for x_ in x])\n", " return x,y\n", "\n", "X, Y_gaussian = make_data(100)\n", "\n", "plt.plot(X, Y_gaussian)\n", "plt.suptitle(\"The Gaussian kernel with $\\sigma=1/\\sqrt{2}$\")\n", "plt.xlabel(\"$\\delta$\")\n", "plt.ylabel(\"$k(\\delta)$\")\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this demo, we will consider only this one example. However, the\n", "arguments we make and the code we use are also amenable to any kernel\n", "with the following mild restrictions:\n", "\n", "1. Shift-invariance\n", "2. Normalization $k(0)=1$.\n", "3. Smoothness (in the sense of a quickly decaying Fourier spectrum).\n", "\n", "Note that is a very large class of kernels! And also an important one\n", "for practical applications.\n", "\n", "## Fourier analysis of the Gaussian kernel\n", "\n", "The next step will be to find the Fourier spectrum of the Gaussian kernel, which is an easy problem for classical computers. Once we\\'ve found it, we\\'ll build a QK that produces a finite Fourier series approximation to that spectrum.\n", "\n", "Let\\'s briefly recall that a Fourier series is the representation of a periodic function using the sine and cosine functions. Fourier analysis tells us that we can write any given periodic function as\n", "\n", "$$f(x) = a_0 + \\sum_{n=1}^\\infty a_n\\cos(n\\omega_0x) + b_n\\sin(n\\omega_0x).$$\n", "\n", "For that, we only need to find the suitable base frequency $\\omega_0$ and coefficients $a_0, a_1, \\ldots, b_0, b_1,\\ldots$.\n", "\n", "But the Gaussian kernel is an aperiodic function, whereas the Fourier series only makes sense for periodic functions!\n", "\n", "*What can we do?!*\n", "\n", "We can cook up a periodic extension to the Gaussian kernel, for a given period $2L$ (we take $L=\\pi$ as default):\n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def Gauss_p(x, L=np.pi):\n", " # Send x to x_mod in the period around 0\n", " x_mod = np.mod(x+L, 2*L) - L\n", " return gaussian_kernel(x_mod)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "which we can now plot\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x_func = np.linspace(-10, 10, 321)\n", "y_func = [Gauss_p(x) for x in x_func]\n", "\n", "plt.plot(x_func, y_func)\n", "plt.xlabel(\"$\\delta$\")\n", "plt.suptitle(\"Periodic extension to the Gaussian kernel\")\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In practice, we would construct several periodic extensions of the aperiodic function, with increasing periods. This way, we can study the behaviour when the period approaches infinity, i.e. the regime where the function stops being periodic.\n", "\n", "Next up, how does the Fourier spectrum of such an object look like? We can find out using PennyLane\\'s `fourier` module!\n" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from pennylane.fourier import coefficients" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The function `coefficients` computes for us the coefficients of the Fourier series up to a fixed term. One tiny detail here: `coefficients` returns one complex number $c_n$ for each frequency $n$. The real part corresponds to the $a_n$ coefficient, and the imaginary part to the $b_n$ coefficient: $c_n=a_n+ib_n$. Because the Gaussian kernel is an even function, we know that the imaginary part of every coefficient will be zero, so $c_n=a_n$.\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def fourier_p(d):\n", " \"\"\"\n", " We only take the first d coefficients [:d]\n", " because coefficients() treats the negative frequencies\n", " as different from the positive ones.\n", " For real functions, they are the same.\n", " \"\"\"\n", " return np.real(coefficients(Gauss_p, 1, d-1)[:d])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We are restricted to considering only a finite number of Fourier terms. But isn\\'t that problematic, one may say? Well, maybe. Since we know the Gaussian kernel is a smooth function, we expect that the coefficients\n", "converge to $0$ at some point, and we will only need to consider terms up to this point. Let\\'s look at the coefficients we obtain by setting a low value for the number of coefficients and then slowly letting it grow:\n" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "N = [0]\n", "for n in range(2,7):\n", " N.append(n)\n", " F = fourier_p(n)\n", " plt.plot(N, F, 'x', label='{}'.format(n))\n", "\n", "plt.legend()\n", "plt.xlabel(\"frequency $n$\")\n", "plt.ylabel(\"Fourier coefficient $c_n$\")\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What do we see? For very small coefficient counts, like $2$ and $3$, we see that the last allowed coefficient is still far from $0$. That\\'s a very clear indicator that we need to consider more frequencies. At the same time, it seems like starting at $5$ or $6$ all the non-zero contributions have already been well captured. This is important for us, since it tells us the minimum number of qubits we should use. One can see that every new qubit doubles the number of frequencies we can use, so for $n$ qubits, we will have $2^n$. At minimum of $6$ frequencies means at least $3$ qubits, corresponding to $2^3=8$ frequencies. As we\\'ll see later, we\\'ll work with $5$ qubits, so $32$ frequencies. That means the spectrum we will be trying to replicate will be the following:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(range(32), fourier_p(32), 'x')\n", "plt.xlabel(\"frequency $n$\")\n", "plt.ylabel(\"Fourier coefficient $c_n$\")\n", "plt.suptitle(\"Fourier spectrum of the Gaussian kernel\")\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We just need a QK with the same Fourier spectrum!\n", "\n", "## Designing a suitable QK\n", "\n", "\n", "Designing a suitable QK amounts to designing a suitable parametrized quantum circuit. Let\\'s take a moment to refresh the big scheme of things with the following picture:\n", "\n", "![The quantum kernel considered in this demo.](images/QEK.jpg)\n", "\n", "We construct the quantum kernel from a quantum embedding. The quantum embedding circuit will consist of two parts. The first one, trainable, will be a parametrized general state preparation scheme $W_a$, with parameters $a$. In the second one, we input the data, denoted by $S(x)$.\n", "\n", "Start with the non-trainable gate we\\'ll use to encode the data $S(x)$. It consists of applying one Pauli-$Z$ rotation to each qubit with rotation parameter $x$ times some constant $\\vartheta_i$, for the $i^\\text{th}$ qubit.\n" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def S(x, thetas, wires):\n", " for (i, wire) in enumerate(wires):\n", " qml.RZ(thetas[i] * x, wires = [wire])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By setting the `thetas` properly, we achieve the integer-valued spectrum, as required by the Fourier series expansion of a function of period $2\\pi$: $\\{0, 1, \\ldots, 2^n-2, 2^n-1\\}$, for $n$ qubits. Some math shows that setting $\\vartheta_i=2^{n-i}$, for $\\{1,\\ldots,n\\}$ produces the desired outcome.\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def make_thetas(n_wires):\n", " return [2 ** i for i in range(n_wires-1, -1, -1)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we introduce the only trainable gate we need to make use of. Contrary to the usual Ansätze used in supervised and unsupervised learning, we use a state preparation template called `MottonenStatePreparation`. This is one option for amplitude encoding already implemented in PennyLane, so we don\\'t need to code it ourselves. Amplitude encoding is a common way of embedding classical data into a quantum system in QML. The unitary associated to this\n", "template transforms the $\\lvert0\\rangle$ state into a state with amplitudes $a=(a_0,a_1,\\ldots,a_{2^n-1})$, namely $\\lvert a\\rangle=\\sum_j a_j\\lvert j\\rangle$, provided $\\lVert a\\rVert^2=1$.\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def W(features, wires):\n", " qml.templates.state_preparations.MottonenStatePreparation(features, wires)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With that, we have the feature map onto the Hilbert space of the quantum computer:\n", "\n", "$$\\lvert x_a\\rangle = S(x)W_a\\lvert0\\rangle,$$\n", "\n", "for a given $a$, which we will specify later.\n", "\n", "Accordingly, we can build the QK corresponding to this feature map as\n", "\n", "$$\\begin{aligned}\n", "k_a(x_1,x_2) &= \\lvert\\langle0\\rvert W_a^\\dagger S^\\dagger(x_1)\n", "S(x_2)W_a\\lvert0\\rangle\\rvert^2 \\\\\n", "&= \\lvert\\langle0\\rvert W_a^\\dagger S(x_2-x_1) W_a\\lvert0\\rangle\\rvert^2.\n", "\\end{aligned}$$\n", "\n", "In the code below, the variable `amplitudes` corresponds to our set $a$.\n" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def ansatz(x1, x2, thetas, amplitudes, wires):\n", " W(amplitudes, wires)\n", " S(x1 - x2, thetas, wires)\n", " qml.adjoint(W)(amplitudes, wires)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since this kernel is by construction real-valued, we also have\n", "\n", "$$\\begin{aligned}\n", "(k_a(x_1,x_2))^\\ast &= k_a(x_1,x_2) \\\\\n", "&= \\lvert\\langle0\\rvert W_a^\\dagger S(x_1-x_2) W_a\\lvert0\\rangle\\rvert^2 \\\\\n", "&= k_a(x_2,x_1).\n", "\\end{aligned}$$\n", "\n", "Further, this QK is also shift-invariant $k_a(x_1,x_2) = k_a(x_1+\\zeta,\n", "x_2+\\zeta)$ for any $\\zeta\\in\\mathbb{R}$. So we can also write it in\n", "terms of the lag $\\delta=x_1-x_2$:\n", "\n", "$$k_a(\\delta) = \\lvert\\langle0\\rvert W_a^\\dagger\n", "S(\\delta)W_a\\lvert0\\rangle\\rvert^2.$$\n", "\n", "So far, we only wrote the gate layout for the quantum circuit, no measurement! We need a few more functions for that!\n", "\n", "## Computing the QK function on a quantum device\n", "\n", "\n", "Also, at this point, we need to set the number of qubits of our computer. For this example, we\\'ll use the variable `n_wires`, and set it to $5$.\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false }, "outputs": [], "source": [ "n_wires = 5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We initialize the quantum simulator:\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [], "source": [ "dev = qml.device(\"default.qubit\", wires = n_wires, shots = None)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we construct the quantum node:\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [], "source": [ "@qml.qnode(dev)\n", "def QK_circuit(x1, x2, thetas, amplitudes):\n", " ansatz(x1, x2, thetas, amplitudes, wires = range(n_wires))\n", " return qml.probs(wires = range(n_wires))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Recall that the output of a QK is defined as the probability of\n", "obtaining the outcome $\\lvert0\\rangle$ when measuring in the\n", "computational basis. That corresponds to the $0^\\text{th}$ entry of\n", "`qml.probs`:\n" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def QK_2(x1, x2, thetas, amplitudes):\n", " return QK_circuit(x1, x2, thetas, amplitudes)[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a couple of quality-of-life improvements, we write a function that\n", "implements the QK with the lag $\\delta$ as its argument, and one that\n", "implements it on a given set of data:\n" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def QK(delta, thetas, amplitudes):\n", " return QK_2(delta, 0, thetas, amplitudes)\n", "\n", "def QK_on_dataset(deltas, thetas, amplitudes):\n", " y = np.array([QK(delta, thetas, amplitudes) for delta in deltas])\n", " return y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is also a good place to fix the `thetas` array, so that we don\\'t\n", "forget later.\n" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [], "source": [ "thetas = make_thetas(n_wires)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let\\'s see how this looks like for one particular choice of\n", "`amplitudes`. We need to make sure the array fulfills the normalization\n", "conditions.\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAHgCAYAAAB3vm02AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbpElEQVR4nO3deVhU9f4H8PfMwMywDiCbAgqC+wKJS1ruJJZZtpjVNY3U0rRr8WujRbPNum2WmZqZlS2aZnpvmmnkmqYp4oq77LvADAzLMDPn9wfOKLHIIHBmeb+eZ54uh3POfGbwMm++q0QQBAFEREREIpGKXQARERE5NoYRIiIiEhXDCBEREYmKYYSIiIhExTBCREREomIYISIiIlExjBAREZGoGEaIiIhIVAwjREREJCqGESIr8OijjyI0NLTJ57q7u7duQVTvz0QikeC1115rk+d/7bXXIJFI2uS5iMTGMEJ27+TJk5g8eTKCgoKgUCjQoUMHTJ48GadOnapz7ldffQWJRIJDhw7VOq5WqzFw4EAolUps3bq11WsuLy/Ha6+9hp07d7b4vT/77DN89dVXLX7fa506dQqvvfYaUlNTW/V5xLZv3z689tprKCkpEbsUIpvGMEJ2bcOGDejXrx8SExMRFxeHzz77DNOmTcMff/yBfv36YdOmTde9h0ajwZgxY3Ds2DH8/PPPGDt2bIvXuWLFCpw5c8b8dXl5ORYsWGDTYWTBggV2F0YqKirwyiuvmL/et28fFixYwDBCdIOcxC6AqLVcuHABjzzyCDp37ozdu3fDz8/P/L25c+di6NChmDx5Mo4dO4awsLB671FaWorY2FgkJydjw4YNuP3221ulVmdn51a5L7UspVIpdglEdoktI2S33nvvPZSXl+Pzzz+vFUQAwNfXF8uXL0dZWRnee++9eq8vKyvD2LFjkZSUhJ9++gnjxo1r9PlKSkogk8nwySefmI8VFhZCKpWiXbt2uHaD7FmzZiEwMND89bXjE1JTU831LliwABKJpN6xCllZWZgwYQLc3d3h5+eHZ599FgaDodEaQ0NDcfLkSezatct83xEjRtR6DU8//TRCQkKgUCgQERGBd999F0ajsdZ91qxZg+joaHh4eMDT0xN9+vTBxx9/DKCmq2vixIkAgJEjR5qfp7FWnmPHjuHRRx9F586doVQqERgYiMceewyXL1+udZ5pHMXZs2cxefJkqFQq+Pn54dVXX4UgCMjIyMDdd98NT09PBAYG4oMPPqh1/c6dOyGRSLB27Vq89NJLCAwMhJubG+666y5kZGQ0+t4BtceMvPbaa3juuecAAGFhYebXmZqaitTUVEgkknpboOr7We7duxcDBgyAUqlEeHg4li9f3mAN3377LaKjo+Hi4gIfHx88+OCDdWo/d+4c7rvvPgQGBkKpVCI4OBgPPvgg1Gr1dV8jkRjYMkJ263//+x9CQ0MxdOjQer8/bNgwhIaG4n//+x8+++yzWt/TarW4/fbb8ffff2P9+vW48847r/t8Xl5e6N27N3bv3o1///vfAGo+ZCQSCYqKinDq1Cn06tULALBnz54G6/Lz88PSpUsxa9Ys3HPPPbj33nsBAH379jWfYzAYEBsbi0GDBuH999/H77//jg8++ADh4eGYNWtWgzUuWrQITz31FNzd3fHyyy8DAAICAgDUdA0NHz4cWVlZeOKJJ9CxY0fs27cPCQkJyMnJwaJFiwAA27dvx0MPPYTRo0fj3XffBQCkpKTgzz//xNy5czFs2DD8+9//xieffIKXXnoJPXr0AADzf+uzfft2XLx4EXFxcQgMDMTJkyfx+eef4+TJk/jrr7/qDOScNGkSevTogXfeeQebN2/Gm2++CR8fHyxfvhyjRo3Cu+++i++++w7PPvssBgwYgGHDhtW6/q233oJEIsELL7yA/Px8LFq0CDExMUhOToaLi0uDdV7r3nvvxdmzZ/HDDz/go48+gq+vL4Can19BQUGT7gEAx48fx5gxY+Dn54fXXnsNer0e8+fPN/9c/ln3q6++igceeADTp09HQUEBFi9ejGHDhuHIkSPw8vKCTqdDbGwsqqqq8NRTTyEwMBBZWVn45ZdfUFJSApVK1eTaiNqMQGSHSkpKBADC3Xff3eh5d911lwBA0Gg0giAIwqpVqwQAQqdOnQRnZ2dh48aNFj3v7NmzhYCAAPPX8fHxwrBhwwR/f39h6dKlgiAIwuXLlwWJRCJ8/PHH5vOmTp0qdOrUyfx1QUGBAECYP39+neeYOnWqAEB4/fXXax2/6aabhOjo6OvW2KtXL2H48OF1jr/xxhuCm5ubcPbs2VrHX3zxRUEmkwnp6emCIAjC3LlzBU9PT0Gv1zf4HOvWrRMACDt27LhuPYIgCOXl5XWO/fDDDwIAYffu3eZj8+fPFwAIjz/+uPmYXq8XgoODBYlEIrzzzjvm48XFxYKLi4swdepU87EdO3YIAISgoCDzz1wQBOHHH38UADT6MxEEoc7P5L333hMACJcuXap13qVLlwQAwqpVq+q8rn/eY8KECYJSqRTS0tLMx06dOiXIZDLh2l/RqampgkwmE956661a9zt+/Ljg5ORkPn7kyBEBgLBu3bo6z01krdhNQ3aptLQUAODh4dHoeabvm843ycvLg1KpREhIiEXPO3ToUOTl5ZkHo+7ZswfDhg3D0KFDsWfPHgA1rSWCIDTYMtJUM2fOrPPcFy9ebPb91q1bh6FDh8Lb2xuFhYXmR0xMDAwGA3bv3g2gpgVIq9Vi+/btN1T/ta5tjaisrERhYSFuvvlmAEBSUlKd86dPn27+3zKZDP3794cgCJg2bZr5uJeXF7p161bvezJlypRa/zbuv/9+tG/fHlu2bGmR19NUBoMBv/32GyZMmICOHTuaj/fo0QOxsbG1zt2wYQOMRiMeeOCBWj+fwMBAdOnSBTt27AAAc8vHb7/9hvLy8rZ7MUQ3gGGE7FJDIeOfSktLIZFIzE3sJsuXL4dcLsfYsWNrzXK5HlPA2LNnD7RaLY4cOYKhQ4di2LBh5jCyZ88eeHp6IjIy0pKXVItSqawzDsbb2xvFxcXNvue5c+ewdetW+Pn51XrExMQAAPLz8wEATz75JLp27Yrbb78dwcHBeOyxx254unNRURHmzp2LgIAAuLi4wM/PzzyouL5xDtd+cAM1H8BKpbLOz1GlUtX7nnTp0qXW1xKJBBEREW0++6egoAAVFRV16gGAbt261fr63LlzEAQBXbp0qfMzSklJMf98wsLCEB8fjy+++AK+vr6IjY3FkiVLOF6ErBrHjJBdUqlU6NChA44dO9boeceOHUNwcDDkcnmt4z179sSWLVswevRo3Hbbbfjzzz+b1ErSoUMHhIWFYffu3QgNDYUgCBg8eDD8/Pwwd+5cpKWlYc+ePRgyZAik0ub/LSCTyZp9bUOMRiNuu+02PP/88/V+v2vXrgAAf39/JCcn47fffsOvv/6KX3/9FatWrcKUKVPw9ddfN+u5H3jgAezbtw/PPfccoqKi4O7uDqPRiLFjx9YZPAvU//obek+EawYOt5WGFiu73gDjxhiNRkgkEvz666/1vtZrF8L74IMP8Oijj2LTpk3Ytm0b/v3vf2PhwoX466+/EBwc3OwaiFoLwwjZrfHjx2P58uXYu3cvbr311jrf37NnD1JTUxEfH1/v9QMHDsTGjRsxbtw43HbbbdizZ0+d1oj6DB06FLt370ZYWBiioqLg4eGByMhIqFQqbN26FUlJSViwYEGj92jNlTcbund4eDjKysrMLSGNkcvlGD9+PMaPHw+j0Ygnn3wSy5cvx6uvvoqIiAiL6i8uLkZiYiIWLFiAefPmmY+fO3euyfew1D/vLQgCzp8/X2uQcFM09Dq9vb0BoM76I2lpabW+9vPzg4uLS72v9Z8tcuHh4RAEAWFhYeZg2Jg+ffqgT58+eOWVV7Bv3z7ccsstWLZsGd58883rXkvU1thNQ3br2WefhaurK5544ok6U0SLioowc+ZMeHp6Ys6cOQ3eY/To0fjhhx9w/vx5jB07FhqN5rrPO3ToUKSmpmLt2rXmbhupVIohQ4bgww8/RHV19XXHi7i6ugKo+2HWEtzc3Oq97wMPPID9+/fjt99+q/O9kpIS6PV6AKjzXkqlUvOHeFVVlfk5TNddj+mv/H+2YJhm77SGb775plYX3vr165GTk2PxOjINvU5PT0/4+vqax9mY/HPWlkwmQ2xsLDZu3Ij09HTz8ZSUlDo/h3vvvRcymQwLFiyo814JgmD+uWg0GvPPyqRPnz6QSqXmnw+RtWHLCNmtiIgIfPPNN3jooYfQp08fTJs2DWFhYUhNTcXKlStRXFyMNWvWNLjgmck999yDFStW4LHHHsNdd92FrVu3Nrr4lSlonDlzBm+//bb5+LBhw/Drr79CoVBgwIABjT6ni4sLevbsibVr16Jr167w8fFB79690bt3bwvegfpFR0dj6dKlePPNNxEREQF/f3+MGjUKzz33HP773//izjvvxKOPPoro6GhotVocP34c69evR2pqKnx9fTF9+nQUFRVh1KhRCA4ORlpaGhYvXoyoqCjz9N2oqCjIZDK8++67UKvVUCgUGDVqFPz9/evU4+npiWHDhuE///kPqqurERQUhG3btuHSpUs3/Fob4uPjg1tvvRVxcXHIy8vDokWLEBERgRkzZlh0n+joaADAyy+/jAcffBDOzs4YP3483NzcMH36dLzzzjuYPn06+vfvj927d+Ps2bN17rFgwQJs3boVQ4cOxZNPPgm9Xo/FixejV69etboZw8PD8eabbyIhIQGpqamYMGECPDw8cOnSJfz88894/PHH8eyzz+KPP/7AnDlzMHHiRHTt2hV6vR6rV6+GTCbDfffdd2NvHFFrEWsaD1FbOX78uPDwww8LgYGBglQqFQAISqVSOHnyZJ1zTVN7//777zrfe//99wUAwp133ilUV1c3+pz+/v4CACEvL898bO/evQIAYejQoXXOr28a6b59+4To6GhBLpfXmg46depUwc3Nrc49TNNeryc3N1cYN26c4OHhIQCoNc23tLRUSEhIECIiIgS5XC74+voKQ4YMEd5//31Bp9MJgiAI69evF8aMGSP4+/sLcrlc6Nixo/DEE08IOTk5tZ5nxYoVQufOnc1TVBub5puZmSncc889gpeXl6BSqYSJEycK2dnZdabBml5jQUFBnfevvvdk+PDhQq9evcxfm6b2/vDDD0JCQoLg7+8vuLi4COPGjas1tdZ0z+tN7RWEminRQUFB5n9bpmm+5eXlwrRp0wSVSiV4eHgIDzzwgJCfn1/vPXbt2mX+WXfu3FlYtmxZgz/Pn376Sbj11lsFNzc3wc3NTejevbswe/Zs4cyZM4IgCMLFixeFxx57TAgPDxeUSqXg4+MjjBw5Uvj999/re+uJrIJEEEQY3UUkom+++QaPPvooJk+ejG+++UbscqgN7dy5EyNHjsS6detw//33i10OEV3BbhpyOFOmTEFOTg5efPFFBAcH1+pKISKitscwQg7phRdewAsvvCB2GUREBM6mISIiIpFxzAgRERGJii0jREREJCqGESIiIhIVwwgRERGJimGEiIiIRMUwQkRERKJiGCEiIiJRMYwQERGRqBhGiIiISFQMI0RERCQqhhEiIiISFcMIERERiYphhIiIiETFMEJERESiYhghIiIiUTGMEBERkagYRoiIiEhUDCNEREQkKoYRIiIiEhXDCBEREYmKYYSIiIhExTBCREREomIYISIiIlExjBAREZGoGEaIiIhIVAwjREREJCqGESIiIhIVwwgRERGJyknsAprCaDQiOzsbHh4ekEgkYpdDRERETSAIAkpLS9GhQwdIpQ23f9hEGMnOzkZISIjYZRAREVEzZGRkIDg4uMHv20QY8fDwAFDzYjw9PUWuhoiIiJpCo9EgJCTE/DneEJsII6auGU9PT4YRIiIiG3O9IRYcwEpERESiYhghIiIiUTGMEBERkagYRoiIiEhUFoeR3bt3Y/z48ejQoQMkEgk2btx43Wt27tyJfv36QaFQICIiAl999VUzSiUiIiJ7ZHEY0Wq1iIyMxJIlS5p0/qVLlzBu3DiMHDkSycnJePrppzF9+nT89ttvFhdLRERE9sfiqb233347br/99iafv2zZMoSFheGDDz4AAPTo0QN79+7FRx99hNjYWEufnoiIiOxMq48Z2b9/P2JiYmodi42Nxf79+xu8pqqqChqNptaDiIiI7FOrh5Hc3FwEBATUOhYQEACNRoOKiop6r1m4cCFUKpX5waXgiYiI7JdVzqZJSEiAWq02PzIyMsQuiYiIiFpJqy8HHxgYiLy8vFrH8vLy4OnpCRcXl3qvUSgUUCgUrV0aERERWYFWbxkZPHgwEhMTax3bvn07Bg8e3NpPTURERDbA4paRsrIynD9/3vz1pUuXkJycDB8fH3Ts2BEJCQnIysrCN998AwCYOXMmPv30Uzz//PN47LHH8Mcff+DHH3/E5s2bW+5VEJHNKSitQpXeUOtYgKcSzjKr7D0molZkcRg5dOgQRo4caf46Pj4eADB16lR89dVXyMnJQXp6uvn7YWFh2Lx5M5555hl8/PHHCA4OxhdffMFpvUQObPVfaXh144k6x8P93LDtmeGQSRvf4ZOI7ItEEARB7CKuR6PRQKVSQa1Ww9PTU+xyiOgGPbH6EH47mQcnqcQcPKr0RgDA3hdGItjbVczyiKiFNPXzu9UHsBIR/VNWSc20/mWToxHTs2bq//D3diDtcjmyiisYRogcDDtniajNZRbXhJEg76sz6oK8XGp9j4gcB8MIEbUpbZUeJeXVAGqHkeAr/9vUakJEjoNhhIjalClseCqd4Kl0Nh8P8qrpmsliywiRw2EYIaI2lVlcDgAI+se4EFMrSWZJeZvXRETiYhghojZlavkI9q69ArO5m4YtI0QOh2GEiNpU5pVuGtOAVRPT19kllTAarX7FASJqQQwjRNSmMhtoGQlUKSGVADqDEQVlVWKURkQiYRghojbVUDeNs0yK9ipO7yVyRAwjRNSmsszdNHUXNjN11XB6L5FjYRghojZTWW1AQWlNF0zQP1pGrj1mmnFDRI6BYYSI2kz2lRYPV7kM3q7Odb7PGTVEjolhhIjaTNY1M2kkkro787KbhsgxMYwQUZupb0+aa13tpmEYIXIkDCNE1GYamkljYtqtN6u4AoLAtUaIHAXDCBG1mcZm0gBAe5USAFBRbUDxlc30iMj+MYwQUZu5ui9N/S0jSmcZ/DwUtc4lIvvHMEJEbeZ63TTXfo8zaogcB8MIEbWJaoMRuZpKAECwV8NhhDNqiBwPwwgRtYlcdSWMAiCXSeHrrmjwPM6oIXI8DCNE1CaundYrldZdY8TENKOGYYTIcTCMEFGbMA9ebaSLBrjahcMBrESOg2GEiNrEtauvNsbUTcMxI0SOg2GEiNpEU2bSAFfDSmmlHuoKrjVC5AgYRoioTVxvKXgTN4WTeRM9Tu8lcgwMI0TUJpraTQOwq4bI0TCMEFGrMxgF5KivdNP41L8U/LWCvUx71HAQK5EjYBgholaXX1qJaoMAmVSCAI+G1xgx4VojRI6FYYSIWp1p7EegpxJOsuv/2uEqrESOhWGEiFqdKVRcbyaNSTDHjBA5FIYRImp1TZ1JY8JuGiLHwjBCRK3OFCoa2yDvWqYBrEVaHcp1+lari4isA8MIEbW6q900159JAwCeLk7wUDgBALLZVUNk9xhGiKjVmfelaWI3jUQiMZ+bwa4aIrvHMEJErUoQBHPrRlMWPDMxz6hhGCGye80KI0uWLEFoaCiUSiUGDRqEgwcPNnhudXU1Xn/9dYSHh0OpVCIyMhJbt25tdsFEZFsua3WorDZCIgHaeymbfF0wB7ESOQyLw8jatWsRHx+P+fPnIykpCZGRkYiNjUV+fn6957/yyitYvnw5Fi9ejFOnTmHmzJm45557cOTIkRsunoisnylM+HsooHCSNfk6LglP5DgsDiMffvghZsyYgbi4OPTs2RPLli2Dq6srvvzyy3rPX716NV566SXccccd6Ny5M2bNmoU77rgDH3zwwQ0XT0TW7+puvU0bvGpiOp9LwhPZP4vCiE6nw+HDhxETE3P1BlIpYmJisH///nqvqaqqglJZu2nWxcUFe/fubfB5qqqqoNFoaj2IyDaZBq82dcEzE3bTEDkOi8JIYWEhDAYDAgICah0PCAhAbm5uvdfExsbiww8/xLlz52A0GrF9+3Zs2LABOTk5DT7PwoULoVKpzI+QkBBLyiQiK2Je8MyCwavXnp9fWoXKakOL10VE1qPVZ9N8/PHH6NKlC7p37w65XI45c+YgLi4OUmnDT52QkAC1Wm1+ZGRktHaZRNRKLF1jxMTHTQ4X55oxJjnqyhavi4ish0VhxNfXFzKZDHl5ebWO5+XlITAwsN5r/Pz8sHHjRmi1WqSlpeH06dNwd3dH586dG3wehUIBT0/PWg8isk3N7aa5dq2RTI4bIbJrFoURuVyO6OhoJCYmmo8ZjUYkJiZi8ODBjV6rVCoRFBQEvV6Pn376CXfffXfzKiYimyEIgnkAa1MXPLuWecM8jhshsmtOll4QHx+PqVOnon///hg4cCAWLVoErVaLuLg4AMCUKVMQFBSEhQsXAgAOHDiArKwsREVFISsrC6+99hqMRiOef/75ln0lRGR1SsqrodXVjPewdMwIwEGsRI7C4jAyadIkFBQUYN68ecjNzUVUVBS2bt1qHtSanp5eazxIZWUlXnnlFVy8eBHu7u644447sHr1anh5ebXYiyAi62QKEb7uCiidm77GiEnQlQ3z2E1DZN8sDiMAMGfOHMyZM6fe7+3cubPW18OHD8epU6ea8zREZOOySpo3XsQkmAufETkE7k1DRK0m07zgWfPCSBC7aYgcAsMIEbWazBsYvApcDTF5mkro9MYWq4uIrAvDCBG1msxmLgVv4ueugMJJCqMA5HKtESK7xTBCRK2muWuMmEgkEvMsnMwSDmIlslcMI0TUasyrrzZjWq8Jx40Q2T+GESJqFeqKapRW6gE0f8wIwLVGiBwBwwgRtQpTF007Nzlc5c1aRQDA1fEmXIWVyH4xjBBRq7iRZeCvFcz9aYjsHsMIEbWKG11jxMQ0gJULnxHZL4YRImoV5jVGbmDwKnC1myZHXQm9gWuNENkjhhEiahVXl4Jv3hojJv4eCjjLJDAYBeRquNYIkT1iGCGiVtFS3TRSqQQdTF01HMRKZJcYRoioVZjGeNzoAFaA03uJ7B3DCBG1uNLKapSUVwO48TEj196Dg1iJ7BPDCBG1OFNo8HJ1hofS+YbvZxp3wum9RPaJYYSIWlxWC82kMWE3DZF9YxghohbXUoNXTdhNQ2TfGEaIqMVd3a33xqb1mgT71Nwnu6QCRqPQIvckIuvBMEJELc48k6aFumkCPBSQSSWoNgjIL61qkXsSkfVgGCGiFtfS3TROMinaq5RX7s1BrET2hmGEiFpcS22Sdy0OYiWyXwwjRNSiynV6XNbqALTcmBEACPKquRcHsRLZH4YRImpRplYRD6UTVC43vsaIydWWEXbTENkbhhEialGZLTx41SSI3TREdothhIha1NXBqy3XRVNzP26WR2SvGEaIqEVdXWOkZVtGQkxLwnOtESK7wzBCRC0qq4Wn9ZoEqpSQSgCd3ojCMq41QmRPGEaIqEWdyS0FAIT5urXofZ1lUnS8shLrmbzSFr03EYmLYYSIWky5To8LBWUAgD5Bqha/f68r9zyepW7xexOReBhGiKjFnMrWwCgAAZ4K+HsqW/z+fa+EkRMMI0R2hWGEiFqMqcWiNVpFrr3vsUyGESJ7wjBCRC3GFEZ6t1IYMXXTZBZXoPjKKq9EZPsYRoioxRzPbN2WEZWLMzq1qxnEeiKbrSNE9oJhhIhaRGsPXjXpzUGsRHaHYYSIWoRp8Kq/R+sMXjXpw0GsRHaHYYSIWkRrD1416cuWESK706wwsmTJEoSGhkKpVGLQoEE4ePBgo+cvWrQI3bp1g4uLC0JCQvDMM8+gsrKyWQUTkXVq7cGrJqZBrBlFFSgp5yBWIntgcRhZu3Yt4uPjMX/+fCQlJSEyMhKxsbHIz8+v9/zvv/8eL774IubPn4+UlBSsXLkSa9euxUsvvXTDxROR9TB1m/QNbt0wcu0gVraOENkHi8PIhx9+iBkzZiAuLg49e/bEsmXL4Orqii+//LLe8/ft24dbbrkFDz/8MEJDQzFmzBg89NBDjbamVFVVQaPR1HoQkfUq1+lxPr/1B6+acBArkX2xKIzodDocPnwYMTExV28glSImJgb79++v95ohQ4bg8OHD5vBx8eJFbNmyBXfccUeDz7Nw4UKoVCrzIyQkxJIyiaiNpeS0zeBVEw5iJbIvTpacXFhYCIPBgICAgFrHAwICcPr06Xqvefjhh1FYWIhbb70VgiBAr9dj5syZjXbTJCQkID4+3vy1RqNhICGyYq29vsg/cRArkX1p9dk0O3fuxNtvv43PPvsMSUlJ2LBhAzZv3ow33nijwWsUCgU8PT1rPYjIeh1ro8GrJhzESmRfLGoZ8fX1hUwmQ15eXq3jeXl5CAwMrPeaV199FY888gimT58OAOjTpw+0Wi0ef/xxvPzyy5BKObuYyNadaKNpvSamQaxpl8txIkuDW7v4tsnzElHrsCgJyOVyREdHIzEx0XzMaDQiMTERgwcPrvea8vLyOoFDJpMBAARBsLReIrIytQavtvJMmmtxECuR/bC4WSI+Ph4rVqzA119/jZSUFMyaNQtarRZxcXEAgClTpiAhIcF8/vjx47F06VKsWbMGly5dwvbt2/Hqq69i/Pjx5lBCRLbLNHjVz0OBgDYYvGrSxxxGStrsOYmodVjUTQMAkyZNQkFBAebNm4fc3FxERUVh69at5kGt6enptVpCXnnlFUgkErzyyivIysqCn58fxo8fj7feeqvlXgURicY0eLVvG3XRmPRhywiR3ZAINtBXotFooFKpoFarOZiVyMr8349H8VNSJuaO7oJnbuvaZs+rLq9G5OvbAADJ826Dl6u8zZ6biJqmqZ/fHD1KRDekrQevmqhcr67EeiKLCyMS2TKGESJqtgqdAefySwG07eBVEw5iJbIPDCNE1GynRBq8asJBrET2gWGEiJrtWGYJgLYfvGpiet5jmWwZIbJlDCNE1GxHM0oAAJEhXqI8f+9gFSQSILO4ApfLqkSpgYhuHMMIETWbqUWirwjjRQDAU+mMzr5utWohItvDMEJEzaKuqMbFQi0AoG+wl2h1RF557qNXuoyIyPYwjBBRs5gWO+vo4wofN/HW+DB1EZm6jIjI9jCMEFGzmFoixOqiMTE9/7FMNfe7IrJRDCNE1CymlogokQavmvRo7wlnmQSXtTpkFleIWgsRNQ/DCBE1y9XBq16i1qF0lqF7YM0y0xzESmSbGEaIyGJ5mkrkaiohlQC9g8TfL+pqV02JuIUQUbMwjBCRxUxdNF0DPOAqt3jz7xZnGsSazEGsRDaJYYSILCb2+iL/ZJreeyJLDYORg1iJbA3DCBFZ7OpMGi9R6zCJ8HeHq1wGrc6AiwVlYpdDRBZiGCEiiwiCYG4ZEXsmjYlMKjHv4MuuGiLbwzBCRBZJu1wOdUU15E5SdAv0ELscs8hgbppHZKsYRojIIqYump7tPeEss55fIX25LDyRzbKe3yREZBOOZlhXF42JqZ6UHA2q9AZxiyEiizCMEJFFjlnJMvD/FOztAm9XZ1QbBJzOKRW7HCKyAMMIETWZ3mDEiWzrWHn1nyQSCbtqiGwUwwgRNdnZvDJUVhvhoXBCZ183scup4+oOvhzESmRLGEaIqMlMXTR9glWQSiXiFlOPSC4LT2STGEaIqMmsbbGzfzLVdb6gDGVVenGLIaImYxghoiYzdX9EWtngVRM/DwWCvFwgCMBxrjdCZDMYRoioSSqrDTiTVzNLJdLKpvVeizv4EtkehhEiapKT2TWb0Pm6K9BepRS7nAZxRg2R7WEYIaImubrYmQoSifUNXjWJDKlpGeGMGiLbwTBCRE1yzMoHr5r0CVJBIgGySipQWFYldjlE1AQMI0TUJEczTYudWefgVRMPpbN5DRSOGyGyDQwjRHRd6opqXCrUArD+lhEAiDSNG2FXDZFNYBghousyTZPt6OMKHze5yNVcn2m2D1tGiGwDwwgRXddRK90cryFXp/eqIQiCyNUQ0fUwjBDRdR3NKAFwtfvD2vVo7wknqQSXtTpkFleIXQ4RXQfDCBFd17Er3TTWvNjZtZTOMvRo7wngau1EZL2aFUaWLFmC0NBQKJVKDBo0CAcPHmzw3BEjRkAikdR5jBs3rtlFE1HbyddUIldTCakE6B3kKXY5TcaVWIlsh8VhZO3atYiPj8f8+fORlJSEyMhIxMbGIj8/v97zN2zYgJycHPPjxIkTkMlkmDhx4g0XT0StzzSlt4u/B1zlTiJX03SRXImVyGZYHEY+/PBDzJgxA3FxcejZsyeWLVsGV1dXfPnll/We7+Pjg8DAQPNj+/btcHV1bTSMVFVVQaPR1HoQkThM40VsZfCqSd8rK7Eez6xZxp6IrJdFYUSn0+Hw4cOIiYm5egOpFDExMdi/f3+T7rFy5Uo8+OCDcHNza/CchQsXQqVSmR8hISGWlElELcjUsmAr40VMalpyZNDqDLhYUCZ2OUTUCIvCSGFhIQwGAwICAmodDwgIQG5u7nWvP3jwIE6cOIHp06c3el5CQgLUarX5kZGRYUmZRNRCBEHA8awrg1dtZCaNiUwqQe8OV/ap4SBWIqvWprNpVq5ciT59+mDgwIGNnqdQKODp6VnrQURtL72oHCXl1ZDLpOgW6CF2ORbjIFYi22BRGPH19YVMJkNeXl6t43l5eQgMDGz0Wq1WizVr1mDatGmWV0lEoki+Ml6kZwdPyJ1sbyUAU9eSadwLEVkni367yOVyREdHIzEx0XzMaDQiMTERgwcPbvTadevWoaqqCpMnT25epUTU5szri9jY4FUTU9dSSk4pdHqjuMUQUYMs/lMnPj4eK1aswNdff42UlBTMmjULWq0WcXFxAIApU6YgISGhznUrV67EhAkT0K5duxuvmojaxDHzMvBeotbRXCE+LvB2dYbOYMTpXM7KI7JWFi8aMGnSJBQUFGDevHnIzc1FVFQUtm7dah7Ump6eDqm0dsY5c+YM9u7di23btrVM1UTU6vQG49XBqyG22TIikUjQJ9gLu88W4GhGic2GKiJ716wVjObMmYM5c+bU+72dO3fWOdatWzduVkVkY87ll6Gy2gh3hRM6+7qLXU6zRQWrasJIphqPiF0MEdXL9kakEVGbOJxWDADoE6SCVCoRuZrmMw1iTbryeojI+jCMEFG9dp0tAADcEmHb47wGhPnASSrBxUItMorKxS6HiOrBMEJEdej0Ruw7XwgAGNHNX+Rqboyn0hn9OnkDAHZeCVhEZF0YRoiojkNpRdDqDPB1l6Nne9tfdHB4Vz8AwK4z9W/oSUTiYhghojp2nalpQRjW1c+mx4uYjOhWE0b2XbiMKr1B5GqI6J8YRoioDtN4EVOLgq3r2d4Tfh4KlOsMOJTKgaxE1oZhhIhqyVFX4HRuKaQSYFgX+wgjEonEHKx2squGyOowjBBRLaYumsgQL3i7yUWupuWYump2cRArkdVhGCGiWuyti8bk1ghfSCXA2bwyZJdUiF0OEV2DYYSIzKoNRuw9Zx9Tev/Jy1WOmzrWTPFl6wiRdWEYISKzpLRilFbp4e3qjD5BtrkfTWM4boTIOjGMEJGZqcVgWFc/yOxgSu8/mcaN/Hn+MnR6o8jVEJEJwwgRme28MnjV9KFtb3p3UKGdmxxlVXokpXOKL5G1YBghIgBAvqYSp3I0AIChdjKl95+kUgmGmbtqOG6EyFowjBARgKtdNH2DVfB1V4hcTevhFF8i68MwQkQArm4iZ29Tev9paBc/SCRASo4GeZpKscshIjCMEBFqpvTucZAw4uMmR99gLwDAjtOcVUNkDRhGiAh/XyqCplIPH7era3HYs5juNWuo/J6SJ3IlRAQwjBARgG2naj6UR3f3t8spvf90W68AAMDuc4XQVulFroaIGEaIHJwgCNh+JYyM6RUocjVto1uABzr6uEKnN2LPOQ5kJRIbwwiRgzuZrUFWSQWUzlLcGuErdjltQiKR4LaeNa0jplYhIhIPwwiRgzO1igzr4gcXuUzkatrOmCth5I/T+dAbuBorkZgYRogcnKllwNRS4CiiO3nD29UZJeXV+DuVq7ESiYlhhMiBZRSVIyVHA6kEGN3DscKIk0xqfs3bTuWKXA2RY2MYIXJgpi6aAaE+8HGTi1xN2zN11Ww/lQdBEESuhshxMYwQObDtDtpFYzK0ix+UzlJkFlcgJadU7HKIHBbDCJGDKinX4WBqEQBgTE/HmNL7Ty5ymXlTwO2cVUMkGoYRIgf1x+l8GIwCugd6oGM7V7HLEc3VKb4cN0IkFoYRIge17eSVhc4ctIvGZHR3f0glNeutZBaXi10OkUNiGCFyQJXVBuy+svLobQ7aRWPSzl2B/p18AAC/s6uGSBQMI0QO6M/zhSjXGdBepUTvIE+xyxHdmF5cjZVITAwjRA7ItFvtbT0DIJHY/8Z412MaN3LwUhHUFdUiV0PkeBhGiByM0SggMSUfgOMtdNaQTu3cEOHvDr1RwO6z3DiPqK0xjBA5mJPZGuSXVsFVLsPNnX3ELsdqjO7hDwBITGFXDVFbYxghcjCmLpqhXXyhcHKcjfGuZ3T3mlaiHWcKuHEeURtrVhhZsmQJQkNDoVQqMWjQIBw8eLDR80tKSjB79my0b98eCoUCXbt2xZYtW5pVMBHdmMTTNWGEXTS19evoBS9XZ6grqpGUXiJ2OUQOxeIwsnbtWsTHx2P+/PlISkpCZGQkYmNjkZ+fX+/5Op0Ot912G1JTU7F+/XqcOXMGK1asQFBQ0A0XT0SWyVVX4kSWBhIJMKq7v9jlWBUnmRQju7GrhkgMFoeRDz/8EDNmzEBcXBx69uyJZcuWwdXVFV9++WW953/55ZcoKirCxo0bccsttyA0NBTDhw9HZGTkDRdPRJb543TNHw1RIV7wdVeIXI31MY0b+Z1hhKhNWRRGdDodDh8+jJiYmKs3kEoRExOD/fv313vNf//7XwwePBizZ89GQEAAevfujbfffhsGg6HB56mqqoJGo6n1IKIbZ/qLfzRbReo1rKsfnKQSXCjQIrVQK3Y5RA7DojBSWFgIg8GAgIDafc0BAQHIza1/X4eLFy9i/fr1MBgM2LJlC1599VV88MEHePPNNxt8noULF0KlUpkfISEhlpRJRPWo0Bmw93whAI4XaYin0hkDw2pmGCWerr/rmYhaXqvPpjEajfD398fnn3+O6OhoTJo0CS+//DKWLVvW4DUJCQlQq9XmR0ZGRmuXSWT3/jxfiCq9EUFeLuge6CF2OVbLFNQ4boSo7VgURnx9fSGTyZCXV/v/pHl5eQgMrH9/i/bt26Nr166Qya5OIezRowdyc3Oh0+nqvUahUMDT07PWg4hujOkv/VHd/bnqaiNMXVgHLxVBU8nVWInagkVhRC6XIzo6GomJieZjRqMRiYmJGDx4cL3X3HLLLTh//jyMxqvz9s+ePYv27dtDLpc3s2wisoQgCPjDPKWX40UaE+rrhnA/N67GStSGLO6miY+Px4oVK/D1118jJSUFs2bNglarRVxcHABgypQpSEhIMJ8/a9YsFBUVYe7cuTh79iw2b96Mt99+G7Nnz265V0FEjTqRpUGexrTqajuxy7F6MeauGo4bIWoLTpZeMGnSJBQUFGDevHnIzc1FVFQUtm7dah7Ump6eDqn0asYJCQnBb7/9hmeeeQZ9+/ZFUFAQ5s6dixdeeKHlXgURNcq00NnQLr5QOnPV1esZ3SMAy3dfxI4z+dAbjHCScbFqotYkEQRBELuI69FoNFCpVFCr1Rw/QtQM4xfvxfEsNf5zX188MICz065HbzAi+s3foa6oxrqZgzEglHv4EDVHUz+/GfeJ7Fz65XIcz1JDIgFGcn2RJnGSSc0r1G4+liNyNUT2j2GEyM6tP1wzNf7WCF/4eXDV1aa6K6oDAGBTchZ0em6cR9SaGEaI7JjBKGD94UwAwMT+7J6xxLAufgj0VKK4vJprjhC1MoYRIju270IhstWV8FQ6YUxPrrpqCZlUgnv71Wzo+eMhLrxI1JoYRojs2LpDNa0id0cFcRZNM5hak3adLUCeplLkaojsF8MIkZ1Sl1dj68maPaMm9g8WuRrbFObrhgGh3jAKwE9JmWKXQ2S3GEaI7NR/j2VDpzeiW4AH+gSpxC7HZk2MrmkdWX8oEzawEgKRTWIYIbJT66+Mc5jYP5h70dyAO/q2h6tchouFWiSlF4tdDpFdYhghskNn80pxNFMNJ6kE99wUJHY5Ns1d4YQ7+rQHAPz4N7tqiFoDwwiRHVp3pVVkVHd/tHPn2iI3amJ0zZibX45lo1ynF7kaIvvDMEJkZ6oNRvx8JAsA8ADXFmkRA8N8ENrOFVqdAVuO54pdDpHdYRghsjM7TuejsEwHX3cFRnTzE7scuyCRSHD/ldaRdVxzhKjFMYwQ2ZnvD6YDAO7tF8TdZlvQfdHBkEqAA5eKcD6/VOxyiOwKf1MR2ZELBWXYeaYAEgnwr0EdxS7HrrRXuSCmR80qtl/tSxW3GCI7wzBCZEe+ufIhObq7Pzq1cxO3GDv06C2hAICfDmdBXVEtbjFEdoRhhMhOaCqrzZvixd0SJnI19mlw53boHuiBimoDx44QtSCGESI7se5QJrQ6A7r4u2NIeDuxy7FLEokEjw4JBVDTVWMwckVWopbAMEJkBwxGAV9f6aJ59JZQrrjaiu6OCoKXqzMyiyuQmJIndjlEdoFhhMgO7DyTj/SicqhcnLniaitzkcvw0MCawcEcyErUMhhGiOzAqj9TAQAPDgiBq9xJ3GIcwOSbO0EmlWDfhcs4nasRuxwim8cwQmTjzuWVYu/5QkglNR+S1PqCvFwQ26tmmu/XbB0humEMI0Q2btWVD8PbegYgxMdV3GIcyKNDamYsbUjKQrFWJ3I1RLaNYYTIhqnLq/FzUs0+NJzO27YGhHqjVwdPVOmNWPM3p/kS3QiGESIb9lNSJiqqDege6IFBYT5il+NQJBIJpl6Z5vv9wTQYOc2XqNkYRohslCAI+O5AGgDgXzd34nReEYzv2wGeSidkFFVg97kCscshslkMI0Q26sClIlwo0MJVLsOEqA5il+OQXOQy3HdlN9/vDqSLXA2R7WIYIbJRpg+/u6OC4KF0Frkax2XakDAxJQ856gqRqyGyTQwjRDaosKwKW0/kAODuvGKL8K8Zr2MUgDUHOZCVqDkYRohs0LpDmag2CIgM8ULvIJXY5Ti8f11Z32XN3+nQG4wiV0NkexhGiGyM0Sjg+4NXBq6yVcQqxPYKQDs3OfI0VUg8nS92OUQ2h2GEyMbsOV+IjKIKeCqdML4vB65aA4WTDA8MCAHAgaxEzcEwQmRjvv2rplXkvuhguMhlIldDJg8N6AiJBNh9tgBpl7Vil0NkUxhGiGxIjvrqtvXsorEuHdu5YlgXPwDA9wfZOkJkCYYRIhvyw8EMGAVgUJgPIvw9xC6H/sEUENcdykRltUHkaohsB8MIkY0oq9Ljm/2pALg7r7Ua1d0fHVRKFGl1WHc4U+xyiGxGs8LIkiVLEBoaCqVSiUGDBuHgwYMNnvvVV19BIpHUeiiVymYXTOSovv0rDSXl1QjzdcMdfdqLXQ7Vw0kmxRPDwwEAy3ZegE7Pab5ETWFxGFm7di3i4+Mxf/58JCUlITIyErGxscjPb3g6m6enJ3JycsyPtLS0GyqayNFU6AxYsfsiAGD2yAjIpNyHxlpNGhACfw8FskoqsCGJrSNETWFxGPnwww8xY8YMxMXFoWfPnli2bBlcXV3x5ZdfNniNRCJBYGCg+REQEHBDRRM5mu8OpOGyVocQHxfczX1orJrSWYbHh3UGACzZeR7VXASN6LosCiM6nQ6HDx9GTEzM1RtIpYiJicH+/fsbvK6srAydOnVCSEgI7r77bpw8ebLR56mqqoJGo6n1IHJUldUGLDe1ioyIgLOMQ72s3b8GdYKvuxwZRRXYlJwtdjlEVs+i32qFhYUwGAx1WjYCAgKQm5tb7zXdunXDl19+iU2bNuHbb7+F0WjEkCFDkJnZcPPlwoULoVKpzI+QkBBLyiSyK2v/zkBBaRWCvFxwb79gscuhJnCRyzB96JXWkR3nYTAKIldEZN1a/U+swYMHY8qUKYiKisLw4cOxYcMG+Pn5Yfny5Q1ek5CQALVabX5kZHDzKXJMVXoDlu68AACYOSIccie2itiKR27uBG9XZ1wq1OKXY2wdIWqMRb/ZfH19IZPJkJeXV+t4Xl4eAgMDm3QPZ2dn3HTTTTh//nyD5ygUCnh6etZ6EDmidYcykaupRICnAhOj2SpiS9wUTph2axgAYPEf52Fk6whRgywKI3K5HNHR0UhMTDQfMxqNSExMxODBg5t0D4PBgOPHj6N9e05NJGqMTm+82ioyPBxKZy79bmumDAmFp9IJ5/PLsOVEjtjlEFkti9t84+PjsWLFCnz99ddISUnBrFmzoNVqERcXBwCYMmUKEhISzOe//vrr2LZtGy5evIikpCRMnjwZaWlpmD59esu9CiI79N2BNGSVVMDXXYGHBnLpd1vkqXRG3C01rSMfbjvLdUeIGuBk6QWTJk1CQUEB5s2bh9zcXERFRWHr1q3mQa3p6emQSq9mnOLiYsyYMQO5ubnw9vZGdHQ09u3bh549e7bcqyCyM8VaHRb9fg4A8HRMF7aK2LDpQ8Pw3YE0XCzU4pv9qeaBrUR0lUQQBKvvyNRoNFCpVFCr1Rw/Qg5h3qYT+GZ/GroHeuCXp26FE6fz2rQ1B9Px4obj8FA6YeezI9DOXSF2SURtoqmf3/wNR2RlzuaV4rsDNbu+zruzJ4OIHZjYPwQ923uitFKPD7efFbscIqvD33JEVkQQBLzxyykYjALG9AzAkAhfsUuiFiCTSjB/fE3X9A8H05GSw4Ucia7FMEJkRf44nY895wohl0nx8rgeYpdDLWhQ53a4o08gjALwxi+nYAM95ERthmGEyEro9Ea8uTkFABB3ayg6tXMTuSJqaQm394DcSYp9Fy5j26m8619A5CAYRoisxDf7U3GpUAtfdwXmjIwQuxxqBSE+rpgxtGaq79tbUlClN4hcEZF1YBghsgLq8mp8klgzlfe52K7wUDqLXBG1lidHRMDfQ4G0y+X49q90scshsgoMI0RWYOmuC9BU6tEtwAP3R3NjSHvmpnDCM7d1BVCziV5pZbXIFRGJj2GESGS56kqs+vMSAOD5sd0gk0pEroha28ToYHT2c0ORVocVuy+KXQ6R6BhGiET2ceJZVOmNGBDqjVHd/cUuh9qAk0yK58Z0AwB8sfcSCkqrRK6ISFwMI0QiulBQhh8PZQIAXry9OyQStoo4irG9AxEZ4oVynQGL/zgndjlEomIYIRLR+7+dgcEoIKZHAKI7+YhdDrUhiUSCF8bWtI58fyAdaZe1IldEJB6GESKRJGeU4NcTuZBKasaKkOMZEu6LYV39oDcK+GAbl4knx8UwQiQCQRDw7q+nAQD39gtG1wAPkSsisTwfWxNE/3s0Gyey1CJXQyQOhhEiEew4k4/9Fy9D7iQ1T/Mkx9Q7SIW7IjsAABb+msJl4skhMYwQtbEKnQHz/3sSABA3JBRBXi4iV0Rie3ZMN8idpPjz/GX871iO2OUQtTmGEaI29umOc8goqkAHlRL/Ht1F7HLICnRs52reAuCNX05BXcGF0MixMIwQtaFzeaX4/MoiV/Pv6gU3hZPIFZG1eGJ4Z3T2dUNBaRU+2HZG7HKI2hTDCFEbEQQBL288gWqDgJge/hjTM0DsksiKKJxkeHNCbwDA6r/ScDSjRNyCiNoQwwhRG/kpKQsHLxXBxVmG1+7qxQXOqI4hEb6456YgCALw8sbjMBg5mJUcA8MIURsoKdfh7S0pAIC5MV0Q7O0qckVkrV66owc8lU44kaXB6v2pYpdD1CYYRojawMItp1Gk1aFrgDum3Romdjlkxfw8FHjh9u4AgPe3nUWOukLkiohaH8MIUSvbeiIHaw9lAADeuqcPnGX8vx017qEBHXFTRy+UVenx9JpkdteQ3eNvRaJWlFFUjufWHwNQM1tiQCj3n6Hrk0ol+GBiJNzkMhy4VIRPErmRHtk3hhGiVqLTGzHnhyMordSjX0cvPDuG+89Q03X2c8fb9/YBAHzyxznsO18ockVErYdhhKiVvPfbaRzNKIHKxRmfPHQTu2fIYndHBeHBASEQBGDu2mQUllWJXRJRq+BvR6JWkJiShxV7LgEA3ru/L2fPULPNH98LXQPcUVBahWfWJsPI8SNkhxhGiFpYjroC/7fuKAAg7pZQjOkVKHJFZMtc5DIsebgflM5S7DlXiKW7LohdElGLYxghakFGo4D/+/EoSsqr0SdIhRevTNEkuhFdAjzw+t01q7N+tP0sjmeqRa6IqGUxjBC1oK/2pWLfhctwcZbhk4dugsJJJnZJZCcmRgdjXN/20BsFPL32CCqrDWKXRNRiGEaIWsj5/FK8u/U0AOClcT0Q5usmckVkTyQSCd6a0Bv+HgpcKNDinV9Pi10SUYthGCFqAdUGI55ZexRVeiOGd/XD5EEdxS6J7JCXqxz/ub8vgJpWuL3nON2X7APDCFELWJx4Dsez1PBydcZ/7u/LTfCo1Yzo5o/JN9eE3efWH4W6olrkiohuHMMI0Q06kl6MJTtrZji8OaE3AjyVIldE9u6lO2q6AXPUlZi/6YTY5RDdMIYRohtQVqVH/I9HYTAKuDuqA+7s20HsksgBuMqd8MEDkZBKgI3J2diUnCV2SUQ3hGGEqJkEQcALPx3DpUIt2quUeP2u3mKXRA6kX0dvzBkZAQB4acNxXCgoE7kiouZrVhhZsmQJQkNDoVQqMWjQIBw8eLBJ161ZswYSiQQTJkxoztMSWZVv9qdh87EcOEkl+PThflC5OotdEjmYf4/ugps7+0CrM+DJb5NQoeN0X7JNFoeRtWvXIj4+HvPnz0dSUhIiIyMRGxuL/Pz8Rq9LTU3Fs88+i6FDhza7WCJrkZxRgjc3nwIAJNzRA9GdvEWuiByRk0yKTx66CX4eCpzJK8UrG09AELhcPNkei8PIhx9+iBkzZiAuLg49e/bEsmXL4Orqii+//LLBawwGA/71r39hwYIF6Ny58w0VTCS2knIdZn+XhGqDgNt7B+KxW0LFLokcmL+HEp88eBOkEuCnpEz8eChD7JKILGZRGNHpdDh8+DBiYmKu3kAqRUxMDPbv39/gda+//jr8/f0xbdq0Jj1PVVUVNBpNrQeRNTAaBcT/eBRZJRUIbeeKdzmNl6zA4PB2+L8x3QAA8zadxKls/s4k22JRGCksLITBYEBAQECt4wEBAcjNza33mr1792LlypVYsWJFk59n4cKFUKlU5kdISIglZRK1mkW/n8Ufp/Mhd5Jiyb/6wVPJcSJkHWYND8fIbn6o0hsx89vDKCitErskoiZr1dk0paWleOSRR7BixQr4+vo2+bqEhASo1WrzIyODzY4kvi/2XMQnf5wHALx5d2/06qASuSKiq6RSCT6aFIUQHxekF5XjkZUHoC7ngmhkG5wsOdnX1xcymQx5eXm1jufl5SEwsO426RcuXEBqairGjx9vPmY0Gmue2MkJZ86cQXh4eJ3rFAoFFAqFJaURtao1B9Px5uYUAMBzsd3wwAC21pH18XKV49tpgzBx2X6czi3F1FUH8e30QXBXWPSrnqjNWdQyIpfLER0djcTERPMxo9GIxMREDB48uM753bt3x/Hjx5GcnGx+3HXXXRg5ciSSk5PZ/UI24X9Hs5Hw83EAwBPDO+PJEXUDNJG16NTODd9OHwQvV2ckZ5Tg8W8OcYdfsnoWd9PEx8djxYoV+Prrr5GSkoJZs2ZBq9UiLi4OADBlyhQkJCQAAJRKJXr37l3r4eXlBQ8PD/Tu3RtyubxlXw1RC/vjdB6eWZsMQQD+NagjXhzbnQNWyep1DfDA13ED4a5wwr4LlzHn+yRUG4xil0XUIIvDyKRJk/D+++9j3rx5iIqKQnJyMrZu3Woe1Jqeno6cnJwWL5SorR1OK8Ksb5Ogv7LU+xt392YQIZsRGeKFL6b2h8JJit9T8vHC+mNcg4SslkSwgX+dGo0GKpUKarUanp6eYpdDDuBCQRnuW7oPJeXVGN3dH8seiYazjLsnkO3ZcTof0785BINRwJyREXg2tpvYJZEDaernN3+7Ev1Dfmklpn55ECXl1YgM8cKnD/djECGbNbK7Pxbe0wcA8OmO8/juQJrIFRHVxd+wRNfQVukx7atDyCyuQKd2rlg5tT9c5DKxyyK6IQ8MCMHc0V0AAK9uPIHElLzrXEHUthhGiK7QG4yY/X0Sjmep4eMmx9dxA+HrzinmZB+ejumCidHBMArAnO+PIDmjROySiMwYRogACIKAhA3HsfNMAZTOUqyc2h+hvm5il0XUYiQSCd6+tw+GdfVDRbUB0776GxcLysQuiwgAwwgRBEHAW5tTsO5wJqQS4JMHb8JNHbkLL9kfZ5kUn/2rH3oHeeKyVodHVh5EdkmF2GURMYwQLdlxHl/svQQAePe+vhjTq+5qwkT2wl3hhK/iBqKzrxuySioweeUBXC7jPjYkLoYRcmir96fi/W1nAQCv3tkTE/tzVWCyf77uCqyePggdVEpcLNBi6qqDKK3kPjYkHoYRclibkrMw778nAQD/HhWBabeGiVwRUdsJ8nLB6umD0M5NjhNZGkz7msvGk3gYRsghrTmYjvgfj0IQgEeHhOKZ27qKXRJRmwv3c8fXjw2Eh8IJBy8V4dFVB1FSrhO7LHJADCPkUAxGAW9vScGLG47DYBRwf3Qw5t3Zk8u8k8PqHaTCykcHwE0uw18Xi3DvZ/twqVArdlnkYBhGyGGU6/SY+e1hfL77IoCadRfeu78vpFIGEXJsA8N88NOTQxDk5YKLhVrc89mf+OviZbHLIgfCMEIOIVddiYnL9mP7qTzInaT4+MEoPB3TlS0iRFd0D/TEz7OHIDLECyXl1Xhk5QGsO5QhdlnkIBhGyO6dyS3FPZ/9iZPZGrRzk+OHGYNwd1SQ2GURWR1/DyXWPn4zxvVpj2qDgOfWH8Oi389yt19qdQwjZNf+ungZ9y/bhxx1JcL93LBx9i2I7uQjdllEVkvpLMPih27CkyPCAQCLfj+HhA3HoTcYRa6M7BnDCNmtX45lY8rKgyit1KN/J2/8NGsIQnxcxS6LyOpJpRI8P7Y73pzQG1IJsObvDDy++jDKdXqxSyM7xTBCdmnl3kt46ocj0BmMiO0VgG+nD4KXq1zssohsyuSbO2HZ5GgonKT443Q+HlrB1VqpdTCMkF0xGgW8+cspvPHLKQgCMGVwJ3z2r2gonWVil0Zkk8b0CsT3M26Gt6szjmaU4N6l+5DKqb/UwhhGyG5UVhvw1Joj5n1mnh/bDQvu6gUZp+4S3ZDoTt5YP2sIgr1dkHa5HPcu3Ycj6cVil0V2hGGE7IK6vBpTvjyIzcdy4CyTYNGkKDw5IoJTd4laSLifOzY8OQR9glQo0urw0Iq/sP1UnthlkZ1gGCGbl1VSgfuW7cPBS0XwUDjh67iBmHATp+4StTR/DyXWPH4zRnTzQ2W1EU+sPoRv/0oTuyyyAwwjZNO2HM/BnZ/swfn8MgR6KvHjzMEYEuErdllEdstN4YQVU/pjUv8QGAXglY0nEP9jMtQV3PWXmo9hhGySurwaT685gie/S0JxeTV6dfDEhieHoEd7T7FLI7J7zjIp3rmvD54d0xVSCbAhKQtjF+3G3nOFYpdGNkoi2MDSehqNBiqVCmq1Gp6e/LBxdLvPFuD59ceQq6mEVALMHhmBp0Z1gdyJ2ZqorR1OK0L8j0eRdrkcQM0u2C+M7Q4XOWewUdM/vxlGyGZU6AxY+GsKvtlf00cd5uuGDx6IRL+O3iJXRuTYynV6LNxyGquvjB/p7OuGjyZFITLES9zCSHQMI2RXjmWW4Om1ybhYULO+wZTBnZBwew/+9UVkRXadLcDz648iT1MFmVSCuaO74MkR4XCSsdXSUTGMkF3QG4xYuvMCPk48B71RQICnAu/dH4lhXf3ELo2I6lFSrsMrG0/gl2M5AICbOnrhoweiEOrrJnJlJAaGEbJ5GUXleHptMg6n1SyuNK5Pe7x1T28u605k5QRBwH+PZuOVjSdQWqmHq1yG18b3wsT+wVz7x8EwjJBN+9/RbLz083GUVurhoXDC6xN6YUJUEH+REdmQrJIKPPvjUey/eBkAcGff9nj73j7wVDqLXBm1FYYRsknlOj0W/PcU1h7KAAD06+iFjx+8ibvtEtkoo1HA8t0X8cG2M9AbBQR7u+CTh27iwHMHwTBCNudwWhGeW38MFwu0kEiAOSMjMHd0Fw5+I7IDR9KL8e81R5BRVAGZVIKnRkVg5vBwbmJp5xhGyGakXdbi3a2nseV4LgAgwFOBjyZFYUg4V1Ilsieaymq88vMJ/PdoNgAgyMsFz8V2w12RHSDlhpZ2iWGErJ66vBqL/ziHr/enotogQCoBHugfgufHdoePGwepEtkjQRDwv2M5eGdLCrLVlQCAvsEqvHxHDwzq3E7k6qilMYyQ1aqsNmD1/jR8uuO8eT+LoV188fK4HugeyJ8vkSOorDZg5d5L+GzHeWh1BgBATI8AvHh7N0T4e4hcHbUUhhGyOkajgI3JWfhg21lklVQAALoGuOOlO3pgRDd/kasjIjEUlFbho9/PYs3BdBgFQCoBJg0IwdMxXRHgqRS7PLpBDCNkVf48X4g3N6cgJUcDAAj0VCL+tq64LzoYMvYVEzm88/mleHfrGWw/lQcAUDpLMWNoZ8waEQ5XuZPI1VFzMYyQVcguqcBbm1Ow+XjNaoweSifMGhGOuCFhXMqdiOo4lFqEhb+eNi922F6lxCvjeuKOPoFcZ8gGNfXzu1lzJpcsWYLQ0FAolUoMGjQIBw8ebPDcDRs2oH///vDy8oKbmxuioqKwevXq5jwt2ZAqvQFLdpzH6A92YfPxHEglwNTBnbD7uZF4ckQEgwgR1at/qA/WzxyMZZP7IdjbBTnqSsz+Pgn/+uIAzuWVil0etRKLW0bWrl2LKVOmYNmyZRg0aBAWLVqEdevW4cyZM/D3r9vvv3PnThQXF6N79+6Qy+X45Zdf8H//93/YvHkzYmNjm/ScbBmxHZXVBvyUlInluy4ivahmS/GBoT547a5e6NmBPzsiarrKagOW7bqApTsvoEpvhJNUgvujgzF9aGdE+LuLXR41Qat10wwaNAgDBgzAp59+CgAwGo0ICQnBU089hRdffLFJ9+jXrx/GjRuHN954o97vV1VVoaqqyvy1RqNBSEgIw4gVK9LqsHp/Gr7Zn4rLWh0AwN9DgZfH9cBdkR3YvEpEzZZRVI7XfzllHk8C1My8eXxYZwwI9ebvFyvW1DBi0aggnU6Hw4cPIyEhwXxMKpUiJiYG+/fvv+71giDgjz/+wJkzZ/Duu+82eN7ChQuxYMECS0ojkaTkaLD6rzRsSMpEZbURQM1CRo/dGoYHB4TATcGBZ0R0Y0J8XLFiSn/8nVqE5bsu4veUPPMjMsQLUwd3wh192nM1VxtmUctIdnY2goKCsG/fPgwePNh8/Pnnn8euXbtw4MCBeq9Tq9UICgpCVVUVZDIZPvvsMzz22GMNPg9bRqxbld6ArSdysXp/Gg5dGWQGAL2DPPH4sHDc0TuQS7gTUau5UFCGL/Zcwk9JmdDpa/4I8nGT44H+IfjXoI7cy8qKtErLSHN5eHggOTkZZWVlSExMRHx8PDp37owRI0bUe75CoYBCoWiL0sgCmspqfPtXGr7cm4rCspqw6CSVILZ3IB65uRMGhfmwuZSIWl24nzsW3tsH/zemK9b+nYHv/kpDtroSy3ZdwPLdFzCmZwBmj4xA32AvsUulJrIojPj6+kImkyEvL6/W8by8PAQGBjZ4nVQqRUREBAAgKioKKSkpWLhwYYNhhKxLkVaHVX9ewlf7UlFaqQdQs3/MwwM74cGBIVyYiIhE4euuwOyREXhiWGf8cTofq/9Kw55zhfjtZB5+O5mHoV18MWdkBJeZtwEWhRG5XI7o6GgkJiZiwoQJAGoGsCYmJmLOnDlNvo/RaKzVDUPWRxAEHMtUY/3hTKw/nImK6prlmiP83fHkiHCMj+wAZ3bFEJEVcJJJMaZXIMb0CsT5/FJ8tuMCNh3Nxp5zhdhzrhD9O3njwYEdcXvvQI5js1IW/1Ti4+MxdepU9O/fHwMHDsSiRYug1WoRFxcHAJgyZQqCgoKwcOFCADWDUfv374/w8HBUVVVhy5YtWL16NZYuXdqyr4RaRI66Aj8fycKGpCyczy8zH+/VwRNzRkYgtlcgd9ckIqsV4e+BDydF4emYrli2+wLWH8rEobRiHEorxqsbT+D23oG4LzoYN3dux9WfrYjFYWTSpEkoKCjAvHnzkJubi6ioKGzduhUBAQEAgPT0dEilV/9i1mq1ePLJJ5GZmQkXFxd0794d3377LSZNmtRyr4KaTRAEXCgow7ZTedh+Kg/JGSUwDWlWOksR2ysQ90cH49YIX44HISKb0bGdK96+pw/+PaoL1h3KwIYjWbhUqMWGI1nYcCQLvu4KxPTwx209A3BLhC9n4oiMy8E7qAsFZfjpcCZ+PZGLS4XaWt8bGOaD+/sF4/Y+gfBQOotUIRFRyxEEAUnpJdiQlIn/Hc2G5sr4NwBwcZZheFc/TLgpCKO6+0PuxC7olsK9aaiO0spq/HIsB+sOZSApvcR8XC6TYnB4O9zWMwAxPQIQqOKAVCKyXzq9EQcuXca2kzVrleSoK83f83GTY0JUEO6PDuaq0S2AYYQAALnqSuw4k4/ElHzsPV9gXphMKgFGdPPHPTcFYUQ3P7aAEJFDEgQBJ7I0+OV4NjYkZaGg9Orkim4BHhjVwx+ju/vjpo7eHGPSDAwjDqqgtArJGSVISi/G7rMFOJmtqfX9CH93TIwOxj03BcGfU3KJiMz0BiN2nyvAukOZ+D0lD9WGqx+P3q7OGN7VDwPD2uGmjl7oGuDBcNIEDCMOIkddgV1nCrDvwmUcyShGRlFFre9LJEBUiBdGdfPHqB7+6NnekwNRiYiuo6Rch11nC5CYko+dZ/JrjTEBAFe5DH2DVRgQ6oPhXf0QFeLFlafrwTBip8p1eiSnl2DXuQLsOlOA07m1t9SWSIAIP3fc1NELA8PaYUQ3P/i6czVbIqLm0huMSEovwe6zBTiSUYyjGWqUVdUOJ55KJwzt6ocRXf1wc+d2CPZ24R9+YBixC1V6AzKLK3A6pxSH0opwOK0YJ7M1MBiv/sgkEiAy2AvDu/phQKgP+oao4MnxH0RErcZgFHA+vwxJ6cX483zNwmrqiupa5wR4KtC/kw+iO3kjMsQLnX3d4OXq7HABhWHEhuj0RpzJLcWJbDVOZqtxqVCL1MJyZKsrUN9PJ9BTicHhNa0eQ7v4wcdN3vZFExERgJqWk6OZJdh1pgC7zhXiZJYaemPdX94eSieEtnNDp3au6Bbggd7BKvQJUtl16zXDiBUSBAF5miqczSs1P1JySnE6V1NroNS13OQyhPm5oV9Hb0R38kb/UB90UCkdLl0TEdmKCp0BRzNLcDitGIdSi5CSU4pcTWWD57dXKdGrgwrdAt3RNcADXQM80NnPDQon21+IjWGkDRmNAi5rdcguqUB2SQWySiqQXVKJwrIqlFRUQ12uQ0lFNS6X6er0M5qoXJzRJ0iFXkGe6OrvgU7tXNGpnRt83eUMHkRENq6y2oD0onKkFmqRelmLk9kaHM+qaQmv71NYJpXAz10BL1dnqFyc4eXqDG9XOdqrXNDBS4kgLxd08HJBoEpp1avHNvXz26F3DCrW6qCprEZppR7aKj3KrjzKdQZU6AyoqDagstqAKr0RRqMAowAYr/yrKS7XIUddiRx1BfLUVdAZjE16TplUYm6i6xLggW4BHugTpEKIDwc7ERHZK6WzzNzqca2yKj1OZqlxKkeDs3ll5lbz0ko9cjWVjbaomLRzkyNQpUR7lQsCPBVwlkkhkQBSiQQSAM5OUrg4y+DiLINSXvNfd4UM7gpnuClk8FA6wV3hjHbuctE2QHXolpE7F+/BiSzN9U9sAokE8PdQmNNqkJcL/DwU8HaVw8vV+Uq6lSPEx8Uumt6IiKh1mLr0C8uqUFJejZIKHUrKa1rXc9Sm1vea/5oWsmwJax+/GYM6t2ux+wFsGWkSD4UzXOUyuCuc4K50gofCCW5XHqYU6SKXQe4krUmYEkCCmuDhqXRGey8XtFcp0V6lhL+HkvsZEBHRDZNIJAhUKa+7NYcgCCgprza30ueoK5FfWgWD0QhBAIwCIEBAtV5Apd6Ayist/uU6A8p1epRWXu0RKK3Uw10pXiRw6JYRQRDYNUJERA7PFAVa+jORLSNNwCBCREQk/uch+xWIiIhIVAwjREREJCqGESIiIhIVwwgRERGJimGEiIiIRMUwQkRERKJiGCEiIiJRMYwQERGRqBhGiIiISFQMI0RERCQqhhEiIiISFcMIERERiYphhIiIiERlE7v2mrY21mg0IldCRERETWX63DZ9jjfEJsJIaWkpACAkJETkSoiIiMhSpaWlUKlUDX5fIlwvrlgBo9GI7OxseHh4QCKRtPnzazQahISEICMjA56enm3+/NaO70/j+P40ju9Pw/jeNI7vT+Os4f0RBAGlpaXo0KEDpNKGR4bYRMuIVCpFcHCw2GXA09OT/+AbwfencXx/Gsf3p2F8bxrH96dxYr8/jbWImHAAKxEREYmKYYSIiIhExTDSBAqFAvPnz4dCoRC7FKvE96dxfH8ax/enYXxvGsf3p3G29P7YxABWIiIisl9sGSEiIiJRMYwQERGRqBhGiIiISFQMI0RERCQqhpFmuOuuu9CxY0colUq0b98ejzzyCLKzs8UuS3SpqamYNm0awsLC4OLigvDwcMyfPx86nU7s0qzGW2+9hSFDhsDV1RVeXl5ilyO6JUuWIDQ0FEqlEoMGDcLBgwfFLslq7N69G+PHj0eHDh0gkUiwceNGsUuyGgsXLsSAAQPg4eEBf39/TJgwAWfOnBG7LKuxdOlS9O3b17zY2eDBg/Hrr7+KXVajGEaaYeTIkfjxxx9x5swZ/PTTT7hw4QLuv/9+scsS3enTp2E0GrF8+XKcPHkSH330EZYtW4aXXnpJ7NKshk6nw8SJEzFr1iyxSxHd2rVrER8fj/nz5yMpKQmRkZGIjY1Ffn6+2KVZBa1Wi8jISCxZskTsUqzOrl27MHv2bPz111/Yvn07qqurMWbMGGi1WrFLswrBwcF45513cPjwYRw6dAijRo3C3XffjZMnT4pdWsMEumGbNm0SJBKJoNPpxC7F6vznP/8RwsLCxC7D6qxatUpQqVRilyGqgQMHCrNnzzZ/bTAYhA4dOggLFy4UsSrrBED4+eefxS7DauXn5wsAhF27dolditXy9vYWvvjiC7HLaBBbRm5QUVERvvvuOwwZMgTOzs5il2N11Go1fHx8xC6DrIxOp8Phw4cRExNjPiaVShETE4P9+/eLWBnZIrVaDQD8XVMPg8GANWvWQKvVYvDgwWKX0yCGkWZ64YUX4Obmhnbt2iE9PR2bNm0SuySrc/78eSxevBhPPPGE2KWQlSksLITBYEBAQECt4wEBAcjNzRWpKrJFRqMRTz/9NG655Rb07t1b7HKsxvHjx+Hu7g6FQoGZM2fi559/Rs+ePcUuq0EMI1e8+OKLkEgkjT5Onz5tPv+5557DkSNHsG3bNshkMkyZMgWCnS5ma+l7AwBZWVkYO3YsJk6ciBkzZohUedtozvtDRC1j9uzZOHHiBNasWSN2KValW7duSE5OxoEDBzBr1ixMnToVp06dErusBnE5+CsKCgpw+fLlRs/p3Lkz5HJ5neOZmZkICQnBvn37rLoZrLksfW+ys7MxYsQI3Hzzzfjqq68gldp35m3Ov52vvvoKTz/9NEpKSlq5Ouuk0+ng6uqK9evXY8KECebjU6dORUlJCVsa/0EikeDnn3+u9V4RMGfOHGzatAm7d+9GWFiY2OVYtZiYGISHh2P58uVil1IvJ7ELsBZ+fn7w8/Nr1rVGoxEAUFVV1ZIlWQ1L3pusrCyMHDkS0dHRWLVqld0HEeDG/u04KrlcjujoaCQmJpo/YI1GIxITEzFnzhxxiyOrJwgCnnrqKfz888/YuXMng0gTGI1Gq/6MYhix0IEDB/D333/j1ltvhbe3Ny5cuIBXX30V4eHhdtkqYomsrCyMGDECnTp1wvvvv4+CggLz9wIDA0WszHqkp6ejqKgI6enpMBgMSE5OBgBERETA3d1d3OLaWHx8PKZOnYr+/ftj4MCBWLRoEbRaLeLi4sQuzSqUlZXh/Pnz5q8vXbqE5ORk+Pj4oGPHjiJWJr7Zs2fj+++/x6ZNm+Dh4WEeZ6RSqeDi4iJydeJLSEjA7bffjo4dO6K0tBTff/89du7cid9++03s0hom7mQe23Ps2DFh5MiRgo+Pj6BQKITQ0FBh5syZQmZmptiliW7VqlUCgHofVGPq1Kn1vj87duwQuzRRLF68WOjYsaMgl8uFgQMHCn/99ZfYJVmNHTt21PtvZerUqWKXJrqGfs+sWrVK7NKswmOPPSZ06tRJkMvlgp+fnzB69Ghh27ZtYpfVKI4ZISIiIlHZf4c+ERERWTWGESIiIhIVwwgRERGJimGEiIiIRMUwQkRERKJiGCEiIiJRMYwQERGRqBhGiIiISFQMI0RERCQqhhEiEk1ubi4efvhhBAYGQi6Xo0OHDnj//ffFLouI2hg3yiMi0TzxxBOorq7G77//Dm9vb+Tl5aGkpETssoiojTGMEJFoqqqqkJaWhv379yMmJgb9+vUTuyQiEgHDCBGJQq/XY+zYsRg5ciRUKhU+/fRTnD17Ft9//z3c3d3FLo+I2hDHjBCRKObOnYuQkBBERkYiNDQU77//Po4dO4alS5eKXRoRtTGGESJqc8nJyfj2229x11131TquUqmQk5MjUlVEJBaGESJqcz/99BO6du0KZ2dn8zGtVouzZ8+iV69eIlZGRGJgGCGiNldcXAytVlvr2Oeffw4AuPfee8UoiYhExDBCRG1u0KBBSElJwUcffYRz585h8eLFSEhIwJIlS+Dt7S12eUTUxiSCIAhiF0FEjkUQBLz99tv44osvcPnyZfTp0wcvv/wy7rjjDrFLIyIRMIwQERGRqNhNQ0RERKJiGCEiIiJRMYwQERGRqBhGiIiISFQMI0RERCQqhhEiIiISFcMIERERiYphhIiIiETFMEJERESiYhghIiIiUTGMEBERkaj+H+ZSz+tbfpnMAAAAAElFTkSuQmCC\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "test_features = np.asarray([1./(1+i) for i in range(2 ** n_wires)])\n", "test_amplitudes = test_features / np.sqrt(np.sum(test_features ** 2))\n", "\n", "Y_test = QK_on_dataset(X, thetas, test_amplitudes)\n", "\n", "plt.plot(X, Y_test)\n", "plt.xlabel(\"$\\delta$\")\n", "plt.suptitle(\"QK with test amplitudes\")\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One can see that the stationary kernel with this particular initial state has a decaying spectrum that looks similar to $1/\\lvert x\\rvert$ --- but not yet like a Gaussian.\n", "\n", "## How to find the amplitudes emulating a Gaussian kernel\n", "\n", "\n", "If we knew exactly which amplitudes to choose in order to build a given Fourier spectrum, our job would be done here. However, the equations derived in the literature are not trivial to solve.\n", "\n", "As mentioned in the introduction, one could just \\\"learn\\\" this relation, that is, tune the parameters of the quantum kernel in a gradient-based manner until it matches the classical one.\n", "\n", "We want to take an intermediate route between analytical solution and black-box optimization. For that, we derive an equation that links the amplitudes to the spectrum we want to construct and then use\n", "old-fashioned convex optimization to find the solution. If you are not interested in the details, you can just jump to the last plots of this demo and confirm that we can to emulate the Gaussian kernel using the ansatz for our QK constructed above.\n", "\n", "In order to simplify the formulas, we introduce new variables, which we call `probabilities` $(p_0, p_1, p_2, \\ldots, p_{2^n-1})$, and we define as $p_j=\\lvert a_j\\rvert^2$. Following the normalization property above, we have $\\sum_j p_j=1$. Don\\'t get too fond of them, we only need them for this step! Remember we introduced the vector $a$ for the `MottonenStatePreparation` as the *amplitudes* of a quantum state? Then it makes sense that we call its squares *probabilities*, doesn\\'t it?\n", "\n", "There is a crazy formula that matches the entries of *probabilities* with the Fourier series of the resulting QK function:\n", "\n", "$$\\begin{aligned}\n", "\\text{probabilities} &\\longrightarrow \\text{Fourier coefficients} \\\\\n", "\\begin{pmatrix} p_0 \\\\ p_1 \\\\ p_2 \\\\ \\vdots \\\\ p_{2^n-1} \\end{pmatrix}\n", "&\\longmapsto \\begin{pmatrix} \\sum_{j=0}^{2^n-1} p_j^2 \\\\ \\sum_{j=1}^{2^n-1}\n", "p_j p_{j-1} \\\\ \\sum_{j=2}^{2^n-1} p_j p_{j-2} \\\\ \\vdots \\\\ p_{2^n-1} p_0\n", "\\end{pmatrix}\n", "\\end{aligned}$$\n", "\n", "This looks a bit scary, it follows from expanding the matrix product $W_a^\\dagger S(\\delta)W_a$, and then collecting terms according to Fourier basis monomials. In this sense, the formula is general and it applies to any shift-invariant kernel we might want to approximate, not only the Gaussian kernel.\n", "\n", "Our goal is to find the set of $p_j$\\'s that produces the Fourier coefficients of a given kernel function (in our case, the Gaussian kernel), namely its spectrum $(s_0, s_1, s_2, \\ldots, s_{2^n-1})$. We consider now a slightly different map $F_s$, for a given spectrum $(s_0, s_1, \\ldots, s_{2^n-1})$:\n", "\n", "$$\\begin{aligned}\n", "F_s: \\text{probabilities} &\\longrightarrow \\text{Difference between Fourier\n", "coefficients} \\\\\n", "\\begin{pmatrix} p_0 \\\\ p_1 \\\\ p_2 \\\\ \\vdots \\\\ p_{2^n-1} \\end{pmatrix}\n", "&\\longmapsto \\begin{pmatrix} \\sum_{j=0}^{2^n-1} p_j^2 - s_0 \\\\\n", "\\sum_{j=1}^{2^n-1} p_j p_{j-1} - s_1 \\\\ \\sum_{j=2}^{2^n-1} p_j\n", "p_{j-2} - s_2 \\\\ \\vdots \\\\ p_{2^n-1}p_0 - s_{2^n-1} \\end{pmatrix}.\n", "\\end{aligned}$$\n", "\n", "If you look at it again, you\\'ll see that the zero (or solution) of this second map $F_s$ is precisely the array of *probabilities* we are looking for. We can write down the first map as:\n" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def predict_spectrum(probabilities):\n", " d = len(probabilities)\n", " spectrum = []\n", " for s in range(d):\n", " s_ = 0\n", "\n", " for j in range(s, d):\n", " s_ += probabilities[j] * probabilities[j - s]\n", "\n", " spectrum.append(s_)\n", "\n", " # This is to make the output have the same format as\n", " # the output of pennylane.fourier.coefficients\n", " for s in range(1,d):\n", " spectrum.append(spectrum[d - s])\n", "\n", " return spectrum" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And then $F_s$ is just `predict_spectrum` minus the spectrum we want to predict:\n" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def F(probabilities, spectrum):\n", " d = len(probabilities)\n", " return predict_spectrum(probabilities)[:d] - spectrum[:d]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These closed-form equations allow us to find the solution numerically, using Newton\\'s method! Newton\\'s method is a classical one from convex optimization theory. For our case, since the formula is quadratic, we rest assured that we are within the realm of convex functions.\n", "\n", "## Finding the solution\n", "\n", "In order to use Newton\\'s method we need the Jacobian of $F_s$.\n" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def J_F(probabilities):\n", " d = len(probabilities)\n", " J = np.zeros(shape=(d,d))\n", " for i in range(d):\n", " for j in range(d):\n", " if (i + j < d):\n", " J[i][j] += probabilities[i + j]\n", " if(i - j <= 0):\n", " J[i][j] += probabilities[j - i]\n", " return J" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Showing that this is indeed $\\nabla F_s$ is left as an exercise for the reader. For Newton\\'s method, we also need an initial guess. Finding a\n", "good initial guess requires some tinkering; different problems will benefit from different ones. Here is a tame one that works for the Gaussian kernel.\n" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def make_initial_probabilities(d):\n", " probabilities = np.ones(d)\n", " deg = np.array(range(1, d + 1))\n", " probabilities = probabilities / deg\n", " return probabilities\n", "\n", "probabilities = make_initial_probabilities(2 ** n_wires)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Recall the `spectrum` we want to match is that of the periodic extension of the Gaussian kernel.\n" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "collapsed": false }, "outputs": [], "source": [ "spectrum = fourier_p(2 ** n_wires)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We fix the hyperparameters for Newton\\'s method:\n" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [], "source": [ "d = 2 ** n_wires\n", "max_steps = 100\n", "tol = 1.e-20" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And we\\'re good to go!\n" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Error norm at step 10: 7.231526379770506e-14\n", "Error norm at step 20: 5.551115536294438e-17\n", "Error norm at step 30: 9.2815769223824e-21\n", "Tolerance trespassed! This is the end.\n" ] } ], "source": [ "for step in range(max_steps):\n", " inc = np.linalg.solve(J_F(probabilities), -F(probabilities, spectrum))\n", " probabilities = probabilities + inc\n", " if (step+1) % 10 == 0:\n", " print(\"Error norm at step {0:3}: {1}\".format(step + 1,\n", " np.linalg.norm(F(probabilities,\n", " spectrum))))\n", " if np.linalg.norm(F(probabilities, spectrum)) < tol:\n", " print(\"Tolerance trespassed! This is the end.\")\n", " break" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The tolerance we set was fairly low, one should expect good things to\n", "come out of this. Let\\'s have a look at the solution:\n" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(range(d), probabilities, 'x')\n", "plt.xlabel(\"array entry $j$\")\n", "plt.ylabel(\"probabilities $p_j$\")\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Would you be able to tell whether this is correct? Me neither! But all those probabilities being close to $0$ should make us fear some of them must\\'ve turned negative. That would be fatal for us. For `MottonenStatePreparation`, we\\'ll need to give `amplitudes` as one of the arguments, which is the component-wise square root of `probabilities`. And hence the problem! Even if they are very small values, if any entry of `probabilities` is negative, the square root will give `nan`. In order to avoid that, we use a simple thresholding where we replace very small entries by $0$.\n" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def probabilities_threshold_normalize(probabilities, thresh = 1.e-10):\n", " d = len(probabilities)\n", " p_t = probabilities.copy()\n", " for i in range(d):\n", " if np.abs(probabilities[i] < thresh):\n", " p_t[i] = 0.0\n", "\n", " p_t = p_t / np.sum(p_t)\n", "\n", " return p_t" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Then, we need to take the square root:\n" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [], "source": [ "probabilities = probabilities_threshold_normalize(probabilities)\n", "amplitudes = np.sqrt(probabilities)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A little plotting never killed nobody\n" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(range(d), probabilities, '+', label = \"probability $p_j = |a_j|^2$\")\n", "plt.plot(range(d), amplitudes, 'x', label = \"amplitude $a_j$\")\n", "plt.xlabel(\"array entry $j$\")\n", "plt.legend()\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Visualizing the solution\n", "\n", "And the moment of truth! Does the solution really match the spectrum? We try it first using `predict_spectrum` only\n" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHkCAYAAADW/5BTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAABe1UlEQVR4nO3deVhUZf8/8PcAMiC7siuborikoKhELmiiaOmjablkj6CmpmnuC48pLhmK+27L1/VnaVrak5apCOSKhaLlgksoZmxaMAICwty/P3g4ObLI4MCA5/26rrlk7nPPfT5zODpvz7nPGYUQQoCIiIhIRgz0XQARERFRdWMAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQCiF45CocD8+fP1XQZVoYKCAsycORMuLi4wMDBA//79tR5j27ZtUCgU+OWXX3Rf4AsqOjoaCoUC0dHR1b5ud3d39OnTp9rXqwv8N6lmYgCi51L8IVLaY/bs2fouT7ZOnz6N+fPnIyMjQ9+lVIktW7Zg2bJlePPNN7F9+3ZMmTKlzL4bN27Etm3bqq+4MqSlpWH27Nlo1aoVzM3NYWJiAk9PT4wYMQInT57Ud3lEsmOk7wLoxbBw4UJ4eHhotL300kt6qeXRo0cwMpL3rn369GksWLAAISEhsLa21nc5Onf8+HE0aNAAq1atembfjRs3wtbWFiEhIVVfWBnOnTuH119/HQ8fPsSQIUPw3nvvQalUIjExEQcOHMC2bdsQExODLl266K3GiujSpQsePXoEY2NjfZdC9Nzk/SlBOtO7d2+0a9dOb+tXq9XIz8+HiYkJTExMdDZubm4ujI2NYWDw4h4sfXLb1RZpaWm1Jtj9/fff6N+/P4yMjBAfH49mzZppLP/oo4+we/dumJqa6qnCijMwMKhV+4k2srOzYWZmpu8yqBq9uP+qU41y/PhxdO7cGWZmZrC2tka/fv1w9epVjT4hISFwd3cv8dr58+dDoVBotCkUCkyYMAG7du1Cy5YtoVQqcfjwYWnZ0+fb7927h5EjR8LBwQFKpRItW7bEli1bNPoUz2/YvXs3PvzwQzRo0AB169aFSqUq833t3r0bvr6+sLCwgKWlJVq1aoU1a9ZIy4tPEf70008YO3Ys6tevD0tLSwwfPhx///13ifF++OEHaTtZWFjg9ddfx+XLl0v0u3btGgYNGgQ7OzuYmprCy8sLc+bMkbbXjBkzAAAeHh7SKcnbt2+Xu+3Kmt9x+/ZtKBQKjdNIISEhMDc3R1JSEvr06QNzc3M0aNAAGzZsAAD8+uuvePXVV2FmZgY3Nzd88cUXZW7DJ2VnZ2PatGlwcXGBUqmEl5cXli9fDiGERi1RUVG4fPmy9N7KmpPi7u6Oy5cvIyYmRurbtWtXjT55eXmYOnUq7OzsYGZmhjfeeAPp6eklxqro7+ZpmzdvRnJyMlavXl0i/ABFv4+hQ4eiffv2UtudO3cwfvx4eHl5wdTUFPXr18dbb70l/Q6LlfZ3A/hnv3uy/y+//IKgoCDY2trC1NQUHh4eGDlypMbrnrU/l7aPnDhxAm+99RZcXV2hVCrh4uKCKVOm4NGjRxpjF+8z9+7dQ//+/WFubg47OztMnz4dhYWFz9yOpdm+fTuMjIyk/R0AYmNj0atXL1hZWaFu3boICAjAqVOnNF5XvN2uXLmCt99+GzY2NujUqROAf+YanTx5Eh06dICJiQkaNWqEHTt2lFh/RkYGJk+eLO2vnp6eWLp0KdRqdaXeD1UvHgEincjMzMT9+/c12mxtbQEAx44dQ+/evdGoUSPMnz8fjx49wrp169CxY0ecP3++1NBTEcePH8dXX32FCRMmwNbWtsxxUlNT8fLLL0sf/HZ2dvjhhx8watQoqFQqTJ48WaP/okWLYGxsjOnTpyMvL6/Mw/1Hjx7F0KFD0b17dyxduhQAcPXqVZw6dQqTJk3S6DthwgRYW1tj/vz5SEhIwKZNm3Dnzh3pAwUAdu7cieDgYAQFBWHp0qXIycnBpk2b0KlTJ1y4cEF6f5cuXULnzp1Rp04djBkzBu7u7rh16xa+++47LF68GAMGDMD169fx5ZdfYtWqVdLvwc7Ortxtp+18ocLCQvTu3RtdunRBREQEdu3ahQkTJsDMzAxz5szBsGHDMGDAAGzevBnDhw+Hv79/idOkTxJC4F//+heioqIwatQo+Pj44Mcff8SMGTNw7949rFq1CnZ2dti5cycWL16MrKwshIeHAwCaN29e6pirV6/GxIkTYW5uLgVEBwcHjT4TJ06EjY0NwsLCcPv2baxevRoTJkzAnj17pD4V/d2U5rvvvoOpqSkGDBhQ0U2Ln3/+GadPn8aQIUPQsGFD3L59G5s2bULXrl1x5coV1K1bt8JjAUVHzHr27Ak7OzvMnj0b1tbWuH37Nr755hupjzb785P27t2LnJwcjBs3DvXr18e5c+ewbt06/PHHH9i7d69G38LCQgQFBcHPzw/Lly/HsWPHsGLFCjRu3Bjjxo3T6j19+umneO+99/Cf//wHH330EYCi/bp3797w9fVFWFgYDAwMsHXrVrz66qs4ceIEOnTooDHGW2+9hSZNmuDjjz+WQjYA3Lx5E2+++SZGjRqF4OBgbNmyBSEhIfD19UXLli0BADk5OQgICMC9e/cwduxYuLq64vTp0wgNDZUCL9Vwgug5bN26VQAo9VHMx8dH2NvbiwcPHkhtFy9eFAYGBmL48OFSW3BwsHBzcyuxjrCwMPH0rgpAGBgYiMuXL5foD0CEhYVJz0eNGiWcnJzE/fv3NfoNGTJEWFlZiZycHCGEEFFRUQKAaNSokdRWnkmTJglLS0tRUFBQZp/i7ePr6yvy8/Ol9oiICAFAfPvtt0IIIR4+fCisra3F6NGjNV6fkpIirKysNNq7dOkiLCwsxJ07dzT6qtVq6edly5YJACIxMbFETWVtu+L3HxUVpdGemJgoAIitW7dKbcHBwQKA+Pjjj6W2v//+W5iamgqFQiF2794ttV+7dq3E76Q0Bw4cEADERx99pNH+5ptvCoVCIW7evCm1BQQEiJYtW5Y7XrGWLVuKgICAEu3Fv5vAwECNbTdlyhRhaGgoMjIyhBDa/W5KY2NjI3x8fEq0q1QqkZ6eLj2ysrKkZaXtf2fOnBEAxI4dO6S20v5uPPnein//+/fvFwDEzz//XGadFdmfS9tHSqs1PDxcKBQKjX20eJ9ZuHChRt82bdoIX1/fMtdZzM3NTbz++utCCCHWrFkjFAqFWLRokbRcrVaLJk2aiKCgII3fZ05OjvDw8BA9evSQ2oq329ChQ0tdDwDx008/SW1paWlCqVSKadOmSW2LFi0SZmZm4vr16xqvnz17tjA0NBRJSUlSW0X2f6p+PAVGOrFhwwYcPXpU4wEAycnJiI+PR0hICOrVqyf1b926NXr06IHvv/++0usMCAhAixYtyu0jhMDXX3+Nvn37QgiB+/fvS4+goCBkZmbi/PnzGq8JDg6u0HwMa2trZGdnS++1PGPGjEGdOnWk5+PGjYORkZH0/o8ePYqMjAwMHTpUo0ZDQ0P4+fkhKioKAJCeno6ffvoJI0eOhKurq8Y6SjsVUpaKbLuKePfdd6Wfra2t4eXlBTMzMwwaNEhq9/LygrW1NX7//fdyx/r+++9haGiIDz74QKN92rRpEELghx9+eO56SzNmzBiNbde5c2cUFhbizp07ACr+uymLSqWCubl5ifZ///vfsLOzkx6zZs2Slj25/z1+/BgPHjyAp6cnrK2tS+yvFVE8X+rgwYN4/PhxmX0quj8/6clas7Ozcf/+fbzyyisQQuDChQsl+r/33nsazzt37vzMfeNJERERmDRpEpYuXYoPP/xQao+Pj8eNGzfw9ttv48GDB9LvKTs7G927d8dPP/1U4tTU07UUa9GiBTp37iw9t7Ozg5eXl0ade/fuRefOnWFjY6OxXwQGBqKwsBA//fRThd8T6QdPgZFOdOjQodRJ0MUfIl5eXiWWNW/eHD/++GOlJx+WdzqlWHp6OjIyMvDpp5/i008/LbVPWlqa1uMCwPjx4/HVV1+hd+/eaNCgAXr27IlBgwahV69eJfo2adJE47m5uTmcnJykORo3btwAALz66qulrsvS0hIApH+An/cKu4q+x/KYmJhonFYDACsrKzRs2LBEGLOysip1ztOT7ty5A2dnZ1hYWGi0F5/eKt6XdO3pIGljYwMAUr0V/d2UxcLCAllZWSXaFy5ciAkTJgAAevToobHs0aNHCA8Px9atW3Hv3j2N0zOZmZnlrq80AQEBGDhwIBYsWIBVq1aha9eu6N+/P95++20olUoA2u3PT0pKSsK8efPw3//+t8Tv+OlaS9tnbGxsnrlvFIuJicGhQ4cwa9YsjXk/wD+/p+Dg4DJfn5mZKf1+gbL/Hjy9T5RW540bN3Dp0qUS76fY0/+uUM3DAEQ1RllHMMqaIFmRozTF/+N75513yvyHsXXr1lqPCwD29vaIj4/Hjz/+iB9++AE//PADtm7diuHDh2P79u0VGuPpOnfu3AlHR8cSy3V9WX9p71Hb7W9oaKhV+5Mf4jXJs+p93t9Ns2bNcPHiRTx+/FjjKODT+92TJk6ciK1bt2Ly5Mnw9/eHlZUVFAoFhgwZonEUo6K/M4VCgX379uHs2bP47rvv8OOPP2LkyJFYsWIFzp49C3Nz80rtz4WFhejRowf++usvzJo1C82aNYOZmRnu3buHkJCQEkdcytrWFdWyZUtkZGRg586dGDt2rEaAKV7XsmXL4OPjU+rrnz4SV9bf9Yrsw2q1Gj169MDMmTNL7du0adMy3wfVDAxAVKXc3NwAAAkJCSWWXbt2Dba2ttLRHxsbm1In4j7P//zt7OxgYWGBwsJCBAYGVnqcshgbG6Nv377o27cv1Go1xo8fj08++QRz586Fp6en1O/GjRvo1q2b9DwrKwvJycl47bXXAACNGzcGUBSqyquzUaNGAIDffvut3Lq0OR1WrPh/xk//DqrqyMvT3NzccOzYMTx8+FDjKNC1a9ek5ZVRmW3xpIr+bsrSp08fnD17Fvv379c4NVieffv2ITg4GCtWrJDacnNzS/xunvydPXlbgLJ+Zy+//DJefvllLF68GF988QWGDRuG3bt3S6cyK7o/F/v1119x/fp1bN++HcOHD5fatT2NVlG2trbYt28fOnXqhO7du+PkyZNwdnYG8M/vydLSskr+rj+tcePGyMrKqpZ1UdXgHCCqUk5OTvDx8cH27ds1/vH+7bffcOTIESkAAEX/oGRmZuLSpUtSW3JyMvbv31/p9RsaGmLgwIH4+uuvSw0NpV3uXFEPHjzQeG5gYCD9rz4vL09j2aeffqox92LTpk0oKChA7969AQBBQUGwtLTExx9/XOocjeI67ezs0KVLF2zZsgVJSUkafZ7832lxqNTmyi43NzcYGhqWmLuwcePGCo/xPF577TUUFhZi/fr1Gu2rVq2CQqGQtpW2zMzMnuuO2BX93ZRl3LhxcHBwwJQpU3D9+vUSy0s7MmZoaFiifd26dSWO7BR/6D/5O8vOzi5xxObvv/8uMV7xUZLifVWb/fnJOp9+D0IIjUvnda1hw4Y4duwYHj16hB49ekh1+/r6onHjxli+fHmppxyf5+96aQYNGoQzZ87gxx9/LLEsIyMDBQUFOl0f6R6PAFGVW7ZsGXr37g1/f3+MGjVKugzeyspK4349Q4YMwaxZs/DGG2/ggw8+kC41btq0aaUmfhZbsmQJoqKi4Ofnh9GjR6NFixb466+/cP78eRw7dgx//fVXpcZ999138ddff+HVV19Fw4YNcefOHaxbtw4+Pj4lLsvOz89H9+7dMWjQICQkJGDjxo3o1KkT/vWvfwEo+l/rpk2b8O9//xtt27bFkCFDYGdnh6SkJBw6dAgdO3aUgsHatWvRqVMntG3bFmPGjIGHhwdu376NQ4cOIT4+HkDRhwEAzJkzB0OGDEGdOnXQt2/fcudaWVlZ4a233sK6deugUCjQuHFjHDx4sNrmMvTt2xfdunXDnDlzcPv2bXh7e+PIkSP49ttvMXnyZOnDXlu+vr7YtGkTPvroI3h6esLe3r7M+Tyl0eZ3U5p69eph//796Nu3L7y9vTFkyBC0b98ederUwd27d6VLxZ+cd9KnTx/s3LkTVlZWaNGiBc6cOYNjx46hfv36GmP37NkTrq6uGDVqFGbMmAFDQ0Ns2bJFqq/Y9u3bsXHjRrzxxhto3LgxHj58iM8++wyWlpbSf0K02Z+LNWvWDI0bN8b06dNx7949WFpa4uuvv67wnJ7K8vT0xJEjR9C1a1cEBQXh+PHjsLS0xOeff47evXujZcuWGDFiBBo0aIB79+4hKioKlpaW+O6773RWw4wZM/Df//4Xffr0kS6Rz87Oxq+//op9+/bh9u3b0i0oqIbSx6Vn9OIovty2vMtrhRDi2LFjomPHjsLU1FRYWlqKvn37iitXrpTod+TIEfHSSy8JY2Nj4eXlJf7f//t/ZV4G//7775e6LpRyyWlqaqp4//33hYuLi6hTp45wdHQU3bt3F59++qnUp/gS371791bove/bt0/07NlT2NvbC2NjY+Hq6irGjh0rkpOTpT7F2ycmJkaMGTNG2NjYCHNzczFs2DCN2wI8WUNQUJCwsrISJiYmonHjxiIkJET88ssvGv1+++038cYbbwhra2thYmIivLy8xNy5czX6LFq0SDRo0EAYGBhoXBJd3rZLT08XAwcOFHXr1hU2NjZi7Nix4rfffiv1MngzM7MSry/r8vQnL2Euz8OHD8WUKVOEs7OzqFOnjmjSpIlYtmyZxmXN5a2nNCkpKeL1118XFhYWAoB0SXxZ+25ZtwOo6O+mLMnJyWLGjBmiRYsWwtTUVCiVStGoUSMxfPhwjUuuhSi6pcCIESOEra2tMDc3F0FBQeLatWvCzc1NBAcHa/SNi4sTfn5+0j64cuXKEpfBnz9/XgwdOlS4uroKpVIp7O3tRZ8+fTRqr8j+XNq2uXLliggMDBTm5ubC1tZWjB49Wly8eLHC+0xZl/I/rbR9KDY2VlhYWIguXbpIl+NfuHBBDBgwQNSvX18olUrh5uYmBg0aJCIjI0usMz09vULrEaJon3v6dgoPHz4UoaGhwtPTUxgbGwtbW1vxyiuviOXLl2vc9qK0f5NI/xRC1NCZiUQvgG3btmHEiBH4+eef9fpVIUREpIlzgIiIiEh2GICIiIhIdhiAiIiISHY4B4iIiIhkh0eAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdoz0XUBNpFar8eeff8LCwgIKhULf5RAREVEFCCHw8OFDODs7w8Cg/GM8DECl+PPPP+Hi4qLvMoiIiKgS7t69i4YNG5bbhwGoFBYWFgCKNqClpaWeqyEiIqKKUKlUcHFxkT7Hy8MAVIri016WlpYMQERERLVMRaavcBI0ERERyQ4DEBEREckOAxARERHJDucAERFRpRQWFuLx48f6LoNkpE6dOjA0NNTJWAxARESkFSEEUlJSkJGRoe9SSIasra3h6Oj43PfpYwAiIiKtFIcfe3t71K1blzeMpWohhEBOTg7S0tIAAE5OTs81HgMQERFVWGFhoRR+6tevr+9ySGZMTU0BAGlpabC3t3+u02GcBE1ERBVWPOenbt26eq6E5Kp433ve+WcMQEREpDWe9iJ90dW+xwBEREREssMAVB2iwoGYCABAmioXq45eR5oqt2hZTETRciIiIqo2DEDVwcAQiFoMxEQg7WEe1kTeQNrDvP+Fn8VFy4mIiABs27YN1tbWVb6erl27YvLkyVW+nspwd3fH6tWrq3QdDEDVIWAm0G0OELUYdufXAEDRn1GLi9oDZuq5QCIi/ShxVLyKpaSkYNKkSfD09ISJiQkcHBzQsWNHbNq0CTk5OdVSw7MMHjwY169f13cZLzxeBl8N0lS5SPMcCztVLhziViBBaQRlXAFSfach3XMs7FW5sLc00XeZRETVrvioeI8WDlX+7+Dvv/+Ojh07wtraGh9//DFatWoFpVKJX3/9FZ9++ikaNGiAf/3rX1VaQ0WYmppKl3vXJvn5+TA2NtZ3GRXGI0DVYFdsEvqsOwm/U77IE0ZQKgqQJ4zgd8oXfdadxK7YJH2XSET0whs/fjyMjIzwyy+/YNCgQWjevDkaNWqEfv364dChQ+jbt6/Ud+XKlWjVqhXMzMzg4uKC8ePHIysrS1o+f/58+Pj4aIy/evVquLu7S8+jo6PRoUMHmJmZwdraGh07dsSdO3cAABcvXkS3bt1gYWEBS0tL+Pr64pdffgFQ8hTYrVu30K9fPzg4OMDc3Bzt27fHsWPHNNbt7u6Ojz/+GCNHjoSFhQVcXV3x6aefarV9Dh06BCsrK+zatQsAcPfuXQwaNAjW1taoV68e+vXrh9u3b0v9Q0JC0L9/fyxevBjOzs7w8vLC7du3oVAo8M0336Bbt26oW7cuvL29cebMGY11nTx5Ep07d4apqSlcXFzwwQcfIDs7W6t6nxcDUDUY5ueKgxM7IbZjnBR+lIoCxHaMw8GJnTDMz1XfJRIRVZs0VS5+u5cpPQBoPK+K02EPHjzAkSNH8P7778PMzKzUPk9eXm1gYIC1a9fi8uXL2L59O44fP46ZMys+XaGgoAD9+/dHQEAALl26hDNnzmDMmDHSOoYNG4aGDRvi559/RlxcHGbPno06deqUOlZWVhZee+01REZG4sKFC+jVqxf69u2LpCTN/zyvWLEC7dq1w4ULFzB+/HiMGzcOCQkJFar3iy++wNChQ7Fr1y4MGzYMjx8/RlBQECwsLHDixAmcOnUK5ubm6NWrF/Lz86XXRUZGIiEhAUePHsXBgwel9jlz5mD69OmIj49H06ZNMXToUBQUFAAoCnS9evXCwIEDcenSJezZswcnT57EhAkTKrx9dUJQCZmZmQKAyMzM1N2g0UuFCLMUKf9dINxmHRQp/10gRJhlUTsRUS3x6NEjceXKFfHo0aNKj7HySIJwm3WwzMfKIwk6rLjI2bNnBQDxzTffaLTXr19fmJmZCTMzMzFz5swyX793715Rv3596XlYWJjw9vbW6LNq1Srh5uYmhBDiwYMHAoCIjo4udTwLCwuxbdu2Updt3bpVWFlZlft+WrZsKdatWyc9d3NzE++88470XK1WC3t7e7Fp06YyxwgICBCTJk0S69evF1ZWVhq17ty5U3h5eQm1Wi215eXlCVNTU/Hjjz8KIYQIDg4WDg4OIi8vT+qTmJgoAIjPP/9cart8+bIAIK5evSqEEGLUqFFizJgxGrWcOHFCGBgYSPuVm5ubWLVqVal1l7cPavP5zTlA1aH4aq9uc5DuORY4dRLpbSfBwdKkqB3gRGgiko1hfq7o0cIBQNGRn9nf/IolA1rhpQZWAAB7C2W11XLu3Dmo1WoMGzYMeXl5UvuxY8cQHh6Oa9euQaVSoaCgALm5ucjJyanQXbDr1auHkJAQBAUFoUePHggMDMSgQYOk76+aOnUq3n33XezcuROBgYF466230Lhx41LHysrKwvz583Ho0CEkJyejoKAAjx49KnEEqHXr1tLPCoUCjo6O0vdmlWXfvn1IS0vDqVOn0L59e6n94sWLuHnzJiwsLDT65+bm4tatW9LzVq1alTrv58lait9zWloamjVrhosXL+LSpUvSqTag6Hu+1Go1EhMT0bx583Jr1hWeAqsO6kLpai97CyUmdW9S9Be8+OowdaG+KyQiqjb2liZ4qYGV9ACg8bwqJkN7enpCoVCUOCXUqFEjeHp6akw6vn37Nvr06YPWrVvj66+/RlxcHDZs2AAA0ukfAwMDCCE0xnr6qxm2bt2KM2fO4JVXXsGePXvQtGlTnD17FkDRHKLLly/j9ddfx/Hjx9GiRQvs37+/1NqnT5+O/fv34+OPP8aJEycQHx+PVq1aaZyKAlDiFJpCoYBarS53u7Rp0wZ2dnbYsmWLxvvJysqCr68v4uPjNR7Xr1/H22+/LfUr63Tik7UUn/YrriUrKwtjx47VGPfixYu4ceNGmSGwKvAIUHXoFir9aG9pgik9mv6zjEd+iIiqXP369dGjRw+sX78eEydOLPODGwDi4uKgVquxYsUKGBgUHSf46quvNPrY2dkhJSUFQgjpAz4+Pr7EWG3atEGbNm0QGhoKf39/fPHFF3j55ZcBAE2bNkXTpk0xZcoUDB06FFu3bsUbb7xRYoxTp04hJCREWpaVlaUxGfl5NG7cGCtWrEDXrl1haGiI9evXAwDatm2LPXv2wN7eHpaWljpZV7G2bdviypUr8PT01Om42uIRICIi0huNo+JVbOPGjSgoKEC7du2wZ88eXL16FQkJCfh//+//4dq1a9I3i3t6euLx48dYt24dfv/9d+zcuRObN2/WGKtr165IT09HREQEbt26hQ0bNuCHH36QlicmJiI0NBRnzpzBnTt3cOTIEdy4cQPNmzfHo0ePMGHCBERHR+POnTs4deoUfv755zJP/TRp0gTffPONdKTk7bfffuaRHW00bdoUUVFR+Prrr6UbIw4bNgy2trbo168fTpw4gcTERERHR+ODDz7AH3/88VzrmzVrFk6fPo0JEyYgPj4eN27cwLffflvtk6AZgIiISG+Kj4pXx73QGjdujAsXLiAwMBChoaHw9vZGu3btsG7dOkyfPh2LFi0CAHh7e2PlypVYunQpXnrpJezatQvh4ZpfWdS8eXNs3LgRGzZsgLe3N86dO4fp06dLy+vWrYtr165h4MCBaNq0KcaMGYP3338fY8eOhaGhIR48eIDhw4ejadOmGDRoEHr37o0FCxaUWvfKlSthY2ODV155BX379kVQUBDatm2r023j5eWF48eP48svv8S0adNQt25d/PTTT3B1dcWAAQPQvHlzjBo1Crm5uc99RKh169aIiYnB9evX0blzZ7Rp0wbz5s2Ds7Ozjt5NxSjE0ycxCSqVClZWVsjMzNT5oT8iotosNzcXiYmJ8PDwgIkJb+BK1a+8fVCbz28eASIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiqoVCQkLQv39/6XnXrl2lr7KoTtHR0VAoFMjIyKj2dT8PBiAiIpKNu3fvYuTIkXB2doaxsTHc3NwwadIkPHjwQKNfaWFizZo1UCqV2L17dzVWXHHffPON9HUez1JbQ4suMQAREVH1igoHYiJKXxYTUbS8Cvz+++9o164dbty4gS+//BI3b97E5s2bERkZCX9/f/z1119lvjYsLAz/+c9/8O2332LIkCE6qyk/P19nY9WrVw8WFhY6G+9FxwBERETVy8AQiFpcMgTFRBS1GxhWyWrff/99GBsb48iRIwgICICrqyt69+6NY8eO4d69e5gzZ06J1wghMHHiRKxduxZHjx5Fr169yhx//vz58PHxwSeffAIXFxfUrVsXgwYNQmZmptSn+LTV4sWL4ezsDC8vLwBFR6YGDRoEa2tr1KtXD/369cPt27el1xUWFmLq1KmwtrZG/fr1MXPmTDz9VZ5PH7XKy8vDrFmz4OLiAqVSCU9PT/zf//0fbt++jW7dugEAbGxsoFAoEBISAgBQq9UIDw+Hh4cHTE1N4e3tjX379mms5/vvv0fTpk1hamqKbt26adRZmzAAERFR9QqYCXSboxmCisNPtzlFy3Xsr7/+wo8//ojx48fD1NRUY5mjoyOGDRuGPXv2aISKgoICvPPOO9i3bx9iYmLwyiuvPHM9N2/exFdffYXvvvsOhw8fxoULFzB+/HiNPpGRkUhISMDRo0dx8OBBPH78GEFBQbCwsMCJEydw6tQpmJubo1evXtIRohUrVmDbtm3YsmULTp48ib/++gv79+8vt5bhw4fjyy+/xNq1a3H16lV88sknMDc3h4uLC77++msAQEJCApKTk7FmzRoAQHh4OHbs2IHNmzfj8uXLmDJlCt555x3ExMQAKApqAwYMQN++fREfH493330Xs2fPfuZ2qZEElZCZmSkAiMzMTH2XQkRUozx69EhcuXJFPHr06PkHi14qRJilEAtti/6MXvr8Y5bh7NmzAoDYv39/qctXrlwpAIjU1FQhhBABAQHC2NhYGBsbi6tXr1ZoHWFhYcLQ0FD88ccfUtsPP/wgDAwMRHJyshBCiODgYOHg4CDy8vKkPjt37hReXl5CrVZLbXl5ecLU1FT8+OOPQgghnJycREREhLT88ePHomHDhqJfv35SW0BAgJg0aZIQQoiEhAQBQBw9erTUWqOiogQA8ffff0ttubm5om7duuL06dMafUeNGiWGDh0qhBAiNDRUtGjRQmP5rFmzSoxVlcrbB7X5/OYRICIi0o+AmYChMVCYX/RnFRz5eZp46rTR04yNjaWfO3XqBHNzc8ydOxcFBQUVGt/V1RUNGjSQnvv7+0OtViMhIUFqa9WqlcZ6Ll68iJs3b8LCwgLm5uYwNzdHvXr1kJubi1u3biEzMxPJycnw8/OTXmNkZIR27dqVWUd8fDwMDQ0REBBQobqBoqNXOTk56NGjh1SHubk5duzYgVu3bgEArl69qlFH8XusjYz0XQAREclUTMQ/4acwv+h5FYUgT09PKBQKXL16FW+88UaJ5VevXoWdnR2sra2ltlatWmHFihUIDAzE4MGDsWfPHhgZPf/HppmZmcbzrKws+Pr6YteuXSX62tnZVWodT5/mq4isrCwAwKFDhzRCHAAolcpK1VGT8QgQERFVvyfn/MxNLzknSMfq16+PHj16YOPGjXj06JHGspSUFOzatUuaCPwkHx8fREZG4qeffsKgQYPw+PHjcteTlJSEP//8U3p+9uxZGBgYSJOdS9O2bVvcuHED9vb28PT01HhYWVnBysoKTk5OiI2NlV5TUFCAuLi4Msds1aoV1Gq1NHfnacVHoAoLC6W2Fi1aQKlUIikpqUQdLi4uAIDmzZvj3LlzGmOdPXu2nC1SczEAERFR9SptwnNpE6N1bP369cjLy0NQUBB++ukn3L17F4cPH0aPHj3QtGlTzJs3r9TXeXt74/jx4zh58uQzQ5CJiQmCg4Nx8eJFnDhxAh988AEGDRoER0fHMl8zbNgw2Nraol+/fjhx4gQSExMRHR2NDz74AH/88QcAYNKkSViyZAkOHDiAa9euYfz48eXew8fd3R3BwcEYOXIkDhw4II351VdfAQDc3NygUChw8OBBpKenIysrCxYWFpg+fTqmTJmC7du349atWzh//jzWrVuH7du3AwDee+893LhxAzNmzEBCQgK++OILbNu27RlbvmZiACIiouqlLiz9aq/iEKQuLP11z6lJkyb4+eef0ahRIwwaNAhubm7o3bs3mjZtKl15VZZWrVrh+PHjOH36NN56660y79/j6emJAQMG4LXXXkPPnj3RunVrbNy4sdy66tati59++gmurq4YMGAAmjdvjlGjRiE3NxeWlpYAgGnTpuHf//43goOD4e/vDwsLi1JP5T1p06ZNePPNNzF+/Hg0a9YMo0ePRnZ2NgCgQYMGWLBgAWbPng0HBwdMmDABALBo0SLMnTsX4eHhaN68OXr16oVDhw7Bw8MDQNEcp6+//hoHDhyAt7c3Nm/ejI8//rjcOmoqhXjWjDAZUqlUsLKyQmZmprTzERERkJubi8TERHh4eMDExETf5Ty3sLAwrFy5EkePHsXLL7/8XGPNnz8fBw4cQHx8vG6Ko1KVtw9q8/nNSdBERCRbCxYsgLu7O86ePYsOHTrAwIAnRuSCAYiIiGRtxIgR+i6B9IBRl4iISAfmz5/P01+1CAMQERERyQ4DEBERaY3Xz5C+6GrfYwAiIqIKq1OnDgAgJydHz5WQXBXve8X7YmXViEnQGzZswLJly5CSkgJvb2+sW7cOHTp0KLXvZ599hh07duC3334DAPj6+uLjjz/W6B8SEiLdtKlYUFAQDh8+XHVvgohIBgwNDWFtbY20tDQARfewUSgUeq6K5EAIgZycHKSlpcHa2hqGhobPNZ7eA9CePXswdepUbN68GX5+fli9ejWCgoKQkJAAe3v7Ev2jo6MxdOhQvPLKKzAxMcHSpUvRs2dPXL58WeO7S3r16oWtW7dKz1/E7zEhItKH4rsaF4cgoupkbW1d7p21K0rvN0L08/ND+/btsX79egCAWq2Gi4sLJk6ciNmzZz/z9YWFhbCxscH69esxfPhwAEVHgDIyMnDgwIEK1ZCXl4e8vDzpuUqlgouLC2+ESERUjsLCwmd+NxaRLtWpU6fcIz+15kaI+fn5iIuLQ2hoqNRmYGCAwMBAnDlzpkJj5OTk4PHjx6hXr55Ge3R0NOzt7WFjY4NXX30VH330EerXr1/qGOHh4ViwYEHl3wgRkQwZGho+92kIIn3R6yTo+/fvo7CwEA4ODhrtDg4OSElJqdAYs2bNgrOzMwIDA6W2Xr16YceOHYiMjMTSpUsRExOD3r17a3zr7ZNCQ0ORmZkpPe7evVv5N0VEREQ1nt7nAD2PJUuWYPfu3YiOjtb4PpAhQ4ZIP7dq1QqtW7dG48aNER0dje7du5cYR6lUco4QERGRjOj1CJCtrS0MDQ2Rmpqq0Z6amvrMCU7Lly/HkiVLcOTIEbRu3brcvo0aNYKtrS1u3rz53DUTERFR7afXAGRsbAxfX19ERkZKbWq1GpGRkfD39y/zdREREVi0aBEOHz6Mdu3aPXM9f/zxBx48eAAnJyed1E1ERES1m95vhDh16lR89tln2L59O65evYpx48YhOztb+nK64cOHa0ySXrp0KebOnYstW7bA3d0dKSkpSElJQVZWFgAgKysLM2bMwNmzZ3H79m1ERkaiX79+8PT0RFBQkF7eIxEREdUsep8DNHjwYKSnp2PevHlISUmBj48PDh8+LE2MTkpKgoHBPzlt06ZNyM/Px5tvvqkxTlhYGObPnw9DQ0NcunQJ27dvR0ZGBpydndGzZ08sWrSI83yIiIgIQA24D1BNpM19BIiIiKhm0ObzW++nwIiIiIiqGwMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOA1BNFhUOxEQAANJUuVh19DrSVLlFy2IiipYTERGR1hiAajIDQyBqMRATgbSHeVgTeQNpD/P+F34WFy0nIiIirRnpuwAqR8DMoj+jFsNOlQvAF3bn1wBxK4Buc/5ZTkRERFphAKrB0lS5SPMcCztVLhziViBBaQRlXAFSfach3XMs7FW5sLc00XeZREREtQ5PgdVgu2KT0GfdSfid8kWeMIJSUYA8YQS/U77os+4kdsUm6btEIiKiWolHgGqwYX6u6NHCAXbn10AZVyCFoNiOcUhvOwn2Fkp9l0hERFQrMQDVYPaWJrC/sBaIW4FU32nwO+WL2I5xcIhbAQdLE84BIiIiqiQGoJqs+GqvbnOQ7jkWOHUS6W0nFYWfqMVFfRiCiIiItMYAVJOpC6WrvexVuZjUvUnRaa/i0KMu1G99REREtZRCCCH0XURNo1KpYGVlhczMTFhaWuq7HCIiIqoAbT6/eRUYERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREclOjQhAGzZsgLu7O0xMTODn54dz586V2fezzz5D586dYWNjAxsbGwQGBpboL4TAvHnz4OTkBFNTUwQGBuLGjRtV/TaIiIioltB7ANqzZw+mTp2KsLAwnD9/Ht7e3ggKCkJaWlqp/aOjozF06FBERUXhzJkzcHFxQc+ePXHv3j2pT0REBNauXYvNmzcjNjYWZmZmCAoKQm5ubnW9LSIiIqrBFEIIoc8C/Pz80L59e6xfvx4AoFar4eLigokTJ2L27NnPfH1hYSFsbGywfv16DB8+HEIIODs7Y9q0aZg+fToAIDMzEw4ODti2bRuGDBnyzDFVKhWsrKyQmZkJS0vL53uDREREVC20+fzW6xGg/Px8xMXFITAwUGozMDBAYGAgzpw5U6ExcnJy8PjxY9SrVw8AkJiYiJSUFI0xrays4OfnV+aYeXl5UKlUGg8iIiJ6cek1AN2/fx+FhYVwcHDQaHdwcEBKSkqFxpg1axacnZ2lwFP8Om3GDA8Ph5WVlfRwcXHR9q0QERFRLaL3OUDPY8mSJdi9ezf2798PExOTSo8TGhqKzMxM6XH37l0dVklEREQ1jZE+V25rawtDQ0OkpqZqtKempsLR0bHc1y5fvhxLlizBsWPH0Lp1a6m9+HWpqalwcnLSGNPHx6fUsZRKJZRKZSXfBREREdU2ej0CZGxsDF9fX0RGRkptarUakZGR8Pf3L/N1ERERWLRoEQ4fPox27dppLPPw8ICjo6PGmCqVCrGxseWOSURERPKh1yNAADB16lQEBwejXbt26NChA1avXo3s7GyMGDECADB8+HA0aNAA4eHhAIClS5di3rx5+OKLL+Du7i7N6zE3N4e5uTkUCgUmT56Mjz76CE2aNIGHhwfmzp0LZ2dn9O/fX19vk4iIiGoQvQegwYMHIz09HfPmzUNKSgp8fHxw+PBhaRJzUlISDAz+OVC1adMm5Ofn480339QYJywsDPPnzwcAzJw5E9nZ2RgzZgwyMjLQqVMnHD58+LnmCREREdGLQ+/3AaqJeB8gIiKi2qfW3AeIiIiISB8YgIiIiEh2tA5AO3bsQF5eXon2/Px87NixQydFEREREVUlrecAGRoaIjk5Gfb29hrtDx48gL29PQoLC3VaoD5wDhAREVHtU6VzgIQQUCgUJdr/+OMPWFlZaTscERERUbWr8GXwbdq0gUKhgEKhQPfu3WFk9M9LCwsLkZiYiF69elVJkURERES6VOEAVHwTwfj4eAQFBcHc3FxaZmxsDHd3dwwcOFDnBRIRERHpWoUDUFhYGADA3d0dgwcP5k0FiYiIqNbS+k7QwcHBAIqu+kpLS4NardZY7urqqpvKiIiIiKqI1gHoxo0bGDlyJE6fPq3RXjw5+kW4CoyIiIhebFoHoJCQEBgZGeHgwYNwcnIq9YowIiIioppM6wAUHx+PuLg4NGvWrCrqISIiIqpyWt8HqEWLFrh//35V1EJERERULbQOQEuXLsXMmTMRHR2NBw8eQKVSaTyIiIiIajqtvwrDwKAoMz099+dFmgTNr8IgIiKqfbT5/NZ6DlBUVFSlCyMiIiKqCbQOQAEBAVVRBxEREVG10XoOEACcOHEC77zzDl555RXcu3cPALBz506cPHlSp8URERERVQWtA9DXX3+NoKAgmJqa4vz588jLywMAZGZm4uOPP9Z5gURERES6pnUA+uijj7B582Z89tlnqFOnjtTesWNHnD9/XqfFEREREVUFrQNQQkICunTpUqLdysoKGRkZuqiJiIiIqEppHYAcHR1x8+bNEu0nT55Eo0aNdFIUERERUVXSOgCNHj0akyZNQmxsLBQKBf7880/s2rUL06dPx7hx46qiRiIiIiKd0voy+NmzZ0OtVqN79+7IyclBly5doFQqMX36dEycOLEqaiQiIiLSKa3vBF0sPz8fN2/eRFZWFlq0aAFzc3Nd16Y3vBM0ERFR7VOld4IuZmxsjBYtWlT25URERER6U6EANGDAAGzbtg2WlpYYMGBAuX2/+eYbnRRGREREVFUqFICsrKykLz+1srKq0oKIiIiIqlql5wC9yDgHiIiIqPbR5vNb68vgExMTcePGjRLtN27cwO3bt7UdjoiIiKjaaR2AQkJCcPr06RLtsbGxCAkJ0UVNRERERFVK6wB04cIFdOzYsUT7yy+/jPj4eF3URERERFSltA5ACoUCDx8+LNGemZmJwsJCnRRFREREVJW0DkBdunRBeHi4RtgpLCxEeHg4OnXqpNPiiIiIiKqC1jdCXLp0Kbp06QIvLy907twZAHDixAmoVCocP35c5wUSERER6ZrWR4BatGiBS5cuYdCgQUhLS8PDhw8xfPhwXLt2DS+99FJV1EhERESkU7wPUCl4HyAiIqLaR+ffBXbp0iW89NJLMDAwwKVLl8rt27p164pXSkRERKQHFQpAPj4+SElJgb29PXx8fKBQKFDagSOFQsErwYiIiKjGq1AASkxMhJ2dnfQzERERUW1WoQD0xhtvIDIyEjY2Nti+fTumT5+OunXrVnVtRERERFWiQleBXb16FdnZ2QCABQsWICsrq0qLIiIiIqpKFZ4DNGLECHTq1AlCCCxfvhzm5ual9p03b55OCyQiIiLStQpdBp+QkICwsDDcunUL58+fR4sWLWBkVDI7KRQKnD9/vkoKrU68DJ6IiKj20ebzW+v7ABkYGEhXhL2oGICIiIhqH20+vys0B6ht27b4+++/AQBhYWFlnv4iIiIiqg20ngS9cOFCToImIiKiWo2ToImIiEh2OAm6FJwDREREVPvofA6Ql5cXdu/ejZ9//hlCCERGRuLChQslHpUJPxs2bIC7uztMTEzg5+eHc+fOldn38uXLGDhwINzd3aFQKLB69eoSfebPnw+FQqHxaNasmdZ1ERER0YurQgHoSWq1WmdXgO3ZswdTp05FWFgYzp8/D29vbwQFBSEtLa3U/jk5OWjUqBGWLFkCR0fHMsdt2bIlkpOTpcfJkyd1Ui8RERG9GLQOQACwc+dOdOzYEc7Ozrhz5w4AYNWqVfj222+1GmflypUYPXo0RowYgRYtWmDz5s2oW7cutmzZUmr/9u3bY9myZRgyZAiUSmWZ4xoZGcHR0VF62NralltHXl4eVCqVxoOIiIheXFoHoE2bNmHq1Kl47bXXkJGRIX37u42NTamnpMqSn5+PuLg4BAYG/lOMgQECAwNx5swZbcvScOPGDTg7O6NRo0YYNmwYkpKSyu0fHh4OKysr6eHi4vJc6yciIqKaTesAtG7dOnz22WeYM2cODA0NpfZ27drh119/rfA49+/fR2FhIRwcHDTaHRwckJKSom1ZEj8/P2zbtg2HDx/Gpk2bkJiYiM6dO+Phw4dlviY0NBSZmZnS4+7du5VePxEREdV8FboM/kmJiYlo06ZNiXalUindK0ifevfuLf3cunVr+Pn5wc3NDV999RVGjRpV6muUSmW5p9SIiIjoxaL1ESAPDw/Ex8eXaD98+DCaN29e4XFsbW1haGiI1NRUjfbU1NRyJzhry9raGk2bNsXNmzd1NiYRERHVbloHoKlTp+L999/Hnj17IITAuXPnsHjxYoSGhmLmzJkVHsfY2Bi+vr6IjIyU2tRqNSIjI+Hv769tWWXKysrCrVu34OTkpLMxiYiIqHbT+hTYu+++C1NTU3z44YfIycnB22+/DWdnZ6xZswZDhgzRaqypU6ciODgY7dq1Q4cOHbB69WpkZ2djxIgRAIDhw4ejQYMGCA8PB1A0cfrKlSvSz/fu3UN8fDzMzc3h6ekJAJg+fTr69u0LNzc3/PnnnwgLC4OhoSGGDh2q7VslIiKiF5TWAQgAhg0bhmHDhiEnJwdZWVmVvi/Q4MGDkZ6ejnnz5iElJQU+Pj44fPiwNDE6KSkJBgb/HKT6888/NeYfLV++HMuXL0dAQACio6MBAH/88QeGDh2KBw8ewM7ODp06dcLZs2dhZ2dXqRqJiIjoxVOhr8IoTXp6OhISEgAAzZo1e+a9dmoTfhUGERFR7aPzr8J4UnZ2NkaOHAknJyd06dIFXbp0gZOTE0aNGoWcnJxKF01ERERUXSo1CTomJgbfffcdMjIykJGRgW+//RYxMTGYNm1aVdRIREREpFNanwKztbXFvn370LVrV432qKgoDBo0COnp6bqsTy94CoyIiKj2qdJTYDk5OSXu3gwA9vb2PAVGREREtYLWAcjf3x9hYWHIzc2V2h49eoQFCxbo9P49RERERFVF68vg16xZg6CgIDRs2BDe3t4AgIsXL8LExAQ//vijzgskIiIi0rVKXQafk5ODXbt24dq1awCA5s2bY9iwYTA1NdV5gfrAOUBERES1jzaf35W6EWLdunUxevToShVHREREpG9azwEKDw/Hli1bSrRv2bIFS5cu1UlRRERERFVJ6wD0ySefoFmzZiXaW7Zsic2bN+ukKCIiIqKqpHUASklJKfWb1e3s7JCcnKyTooiIiIiqktYByMXFBadOnSrRfurUKTg7O+ukKCIiIqKqpPUk6NGjR2Py5Ml4/PgxXn31VQBAZGQkZs6cya/CICIiolpB6wA0Y8YMPHjwAOPHj0d+fj4AwMTEBLNmzUJoaKjOCyQiIiLStUrdBwgAsrKycPXqVZiamqJJkyZQKpW6rk1veB8gIiKi2qfK7wMEAObm5mjfvn1lX05ERESkN1pPgiYiIiKq7RiAiIiISHYYgIiIiEh2tApAjx8/xsiRI5GYmFhV9RARERFVOa0CUJ06dfD1119XVS1ERERE1ULrU2D9+/fHgQMHqqAUIiIiouqh9WXwTZo0wcKFC3Hq1Cn4+vrCzMxMY/kHH3ygs+KIiIiIqoLWN0L08PAoezCFAr///vtzF6VvvBEiERFR7VOlN0LkBGgiIiKq7Sp9GXx+fj4SEhJQUFCgy3qIiIiIqpzWASgnJwejRo1C3bp10bJlSyQlJQEAJk6ciCVLlui8QCIiIiJd0zoAhYaG4uLFi4iOjoaJiYnUHhgYiD179ui0OCIiIqKqoPUcoAMHDmDPnj14+eWXoVAopPaWLVvi1q1bOi2OiIiIqCpofQQoPT0d9vb2Jdqzs7M1AhERERFRTaV1AGrXrh0OHTokPS8OPZ9//jn8/f11VxkRERFRFdH6FNjHH3+M3r1748qVKygoKMCaNWtw5coVnD59GjExMVVRIxEREZFOaX0EqFOnToiPj0dBQQFatWqFI0eOwN7eHmfOnIGvr29V1EhERESkU1rfCVoOeCdoIiKi2kfnd4JWqVTSQCqVqty+DAxERERU01UoANnY2CA5ORn29vawtrYu9WovIQQUCgUKCwt1XiQRERGRLlUoAB0/fhz16tUDAERFRVVpQURERERVrUIBKCAgAABQUFCAmJgYjBw5Eg0bNqzSwoiIiIiqilZXgRkZGWHZsmX8AlQiIiKq1bS+DP7VV1/l/X6IiIioVtP6Roi9e/fG7Nmz8euvv8LX1xdmZmYay//1r3/prDgiIiKiqqD1fYAMDMo+aPSiXAXG+wARERHVPjq/D9CT1Gp1pQsjIiIiqgm0ngNEtURUOBATAQBIU+Vi1dHrSFPlFi2LiShaTkREJFNaHwFauHBhucvnzZtX6WJIhwwMgajFAIA0z7FYE3kDPVo4wP7C2qL2bnP0XCAREZH+aB2A9u/fr/H88ePHSExMhJGRERo3bswAVFMEzCz6M2ox7FS5AHxhd34NELeiKPwULyciIpIhrQPQhQsXSrSpVCqEhITgjTfe0ElR9PzSVLlI8xwLO1UuHOJWIEFpBGVcAVJ9pyHdcyzsVbmwtzTRd5lERER6obNvg//111/Rt29f3L59WxfD6dWLcBXYqqPXsSbyBgAgQTkcSkUB8oQRvPJ2AAAmdW+CKT2a6rNEIiIindLm81tnk6AzMzORmZmp9es2bNgAd3d3mJiYwM/PD+fOnSuz7+XLlzFw4EC4u7tDoVBg9erVzz3mi2qYnysOTuyE2I5xUvhRKgoQ2zEOByd2wjA/V32XSEREpDdanwJbu3atxnMhBJKTk7Fz50707t1bq7H27NmDqVOnYvPmzfDz88Pq1asRFBSEhIQE2Nvbl+ifk5ODRo0a4a233sKUKVN0MuaLyt7SpGjCc9wKpPpOg98pX8R2jIND3Ao4WJpwDhAREcma1qfAPDw8NJ4bGBjAzs4Or776KkJDQ2FhYVHhsfz8/NC+fXusX78eQNE9hlxcXDBx4kTMnj273Ne6u7tj8uTJmDx5ss7GLPYinAIrutS96Gqv3zzHos+6kzg4sRNeuvnJP1eBMQQREdELpEpvhJiYmFjpwp6Un5+PuLg4hIaGSm0GBgYIDAzEmTNnqnXMvLw85OXlSc9VKlWl1l+jqAulkGOvysWk7k1gb6H8J/Soa/8du4mIiCpL6wD0pD/++AMA0LBhQ61fe//+fRQWFsLBwUGj3cHBAdeuXatUPZUdMzw8HAsWLKjUOmusbv+EQHtLE80JzzzyQ0REMqf1JGi1Wo2FCxfCysoKbm5ucHNzg7W1NRYtWlRrvyYjNDRUmsSdmZmJu3fv6rskIiIiqkJaHwGaM2cO/u///g9LlixBx44dAQAnT57E/PnzkZubi8WLF1doHFtbWxgaGiI1NVWjPTU1FY6OjtqW9VxjKpVKKJXKSq2TiIiIah+tjwBt374dn3/+OcaNG4fWrVujdevWGD9+PD777DNs27atwuMYGxvD19cXkZGRUptarUZkZCT8/f21LavKxiQiIqIXj9ZHgP766y80a9asRHuzZs3w119/aTXW1KlTERwcjHbt2qFDhw5YvXo1srOzMWLECADA8OHD0aBBA4SHF31xZ35+Pq5cuSL9fO/ePcTHx8Pc3Byenp4VGpOIiIhI6wDk7e2N9evXl7gf0Pr16+Ht7a3VWIMHD0Z6ejrmzZuHlJQU+Pj44PDhw9Ik5qSkJBgY/HOQ6s8//0SbNm2k58uXL8fy5csREBCA6OjoCo1JREREpPV9gGJiYvD666/D1dVVOq105swZ3L17F99//z06d+5cJYVWpxfiPkBEREQyU6VfhREQEIDr16/jjTfeQEZGBjIyMjBgwAAkJCS8EOGHiIiIXnwVPgL0+++/w8PDAwqFoqpr0jseASIiIqp9quQIUJMmTZCeni49Hzx4cInLzYmIiIhqgwoHoKcPFH3//ffIzs7WeUFEREREVU3rOUBEREREtV2FA5BCoSgx/0cO84GIiIjoxVPh+wAJIRASEiJ9ZURubi7ee+89mJmZafT75ptvdFshERERkY5VOAAFBwdrPH/nnXd0XgwRERFRdahwANq6dWtV1kFERERUbTgJmoiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSnRgSgDRs2wN3dHSYmJvDz88O5c+fK7b937140a9YMJiYmaNWqFb7//nuN5SEhIVAoFBqPXr16VeVbICIiolpE7wFoz549mDp1KsLCwnD+/Hl4e3sjKCgIaWlppfY/ffo0hg4dilGjRuHChQvo378/+vfvj99++02jX69evZCcnCw9vvzyy+p4O0RERFQLKIQQQp8F+Pn5oX379li/fj0AQK1Ww8XFBRMnTsTs2bNL9B88eDCys7Nx8OBBqe3ll1+Gj48PNm/eDKDoCFBGRgYOHDhQoRry8vKQl5cnPVepVHBxcUFmZiYsLS2f490RERFRdVGpVLCysqrQ57dejwDl5+cjLi4OgYGBUpuBgQECAwNx5syZUl9z5swZjf4AEBQUVKJ/dHQ07O3t4eXlhXHjxuHBgwdl1hEeHg4rKyvp4eLi8hzvioiIiGo6vQag+/fvo7CwEA4ODhrtDg4OSElJKfU1KSkpz+zfq1cv7NixA5GRkVi6dCliYmLQu3dvFBYWljpmaGgoMjMzpcfdu3ef850RERFRTWak7wKqwpAhQ6SfW7VqhdatW6Nx48aIjo5G9+7dS/RXKpVQKpXVWSIRERHpkV6PANna2sLQ0BCpqaka7ampqXB0dCz1NY6Ojlr1B4BGjRrB1tYWN2/efP6iiYiIqNbTawAyNjaGr68vIiMjpTa1Wo3IyEj4+/uX+hp/f3+N/gBw9OjRMvsDwB9//IEHDx7AyclJN4UTERFRrab3y+CnTp2Kzz77DNu3b8fVq1cxbtw4ZGdnY8SIEQCA4cOHIzQ0VOo/adIkHD58GCtWrMC1a9cwf/58/PLLL5gwYQIAICsrCzNmzMDZs2dx+/ZtREZGol+/fvD09ERQUJBe3iMRERHVLHqfAzR48GCkp6dj3rx5SElJgY+PDw4fPixNdE5KSoKBwT857ZVXXsEXX3yBDz/8EP/5z3/QpEkTHDhwAC+99BIAwNDQEJcuXcL27duRkZEBZ2dn9OzZE4sWLeI8HyIiIgJQA+4DVBNpcx8BIiIiqhlqzX2AiIiIiPSBAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYiIiIhkhwGIiIiIZIcBiIiIiGSHAYg0RYUDMREAgDRVLlYdvY40VW7RspiIouVERES1HAMQaTIwBKIWAzERSHuYhzWRN5D2MO9/4Wdx0XIiIqJazkjfBVANEzCz6M+oxbBT5QLwhd35NUDcCqDbnH+WExER1WIMQKQhTZWLNM+xsFPlwiFuBRKURlDGFSDVdxrSPcfCXpULe0sTfZdJRET0XHgKjDTsik1Cn3Un4XfKF3nCCEpFAfKEEfxO+aLPupPYFZuk7xKJiIieG48AkYZhfq7o0cIBdufXQBlXIIWg2I5xSG87CfYWSn2XSERE9NwYgEiDvaUJ7C+sBeJWINV3GvxO+SK2Yxwc4lbAwdKEc4CIiOiFwABEmoqv9uo2B+meY4FTJ5HedlJR+IlaXNSHIYiIiGo5BiDSpC6UrvayV+ViUvcmRae9ikOPulC/9REREemAQggh9F1ETaNSqWBlZYXMzExYWlrquxwiIiKqAG0+v3kVGBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxARERHJDgMQERERyQ4DEBEREckOAxDpTlQ4EBMBAEhT5WLV0etIU+UWLYuJKFpORERUAzAAke4YGAJRi4GYCKQ9zMOayBtIe5j3v/CzuGg5ERFRDWCk7wLoBRIws+jPqMWwU+UC8IXd+TVA3Aqg25x/lhMREekZAxDpTJoqF2meY2GnyoVD3AokKI2gjCtAqu80pHuOhb0qF/aWJvouk4iIiKfASHd2xSahz7qT8DvlizxhBKWiAHnCCH6nfNFn3Unsik3Sd4lEREQAeASIdGiYnyt6tHCA3fk1UMYVSCEotmMc0ttOgr2FsvQXRoUXzQ8KmIk0VS52xSZhmJ9r0dGimAhAXQh0C63eN0NERC+0GnEEaMOGDXB3d4eJiQn8/Pxw7ty5cvvv3bsXzZo1g4mJCVq1aoXvv/9eY7kQAvPmzYOTkxNMTU0RGBiIGzduVOVbIAD2liZ46eYncIhbgVTfafDK24FU32lwiFuBl25+Uvbpr+eZPF3ZK8+e54q12rTO2lYv1/lirbO21ct11sx1VhG9B6A9e/Zg6tSpCAsLw/nz5+Ht7Y2goCCkpaWV2v/06dMYOnQoRo0ahQsXLqB///7o378/fvvtN6lPREQE1q5di82bNyM2NhZmZmYICgpCbm5udb0teSoOLN3mIL3tJAAo+rPbHCnglCpgptTH7vwaACj6839jlTt5urLh6XlCV21aZ22rl+t8sdZZ2+rlOmvmOquI3k+BrVy5EqNHj8aIESMAAJs3b8ahQ4ewZcsWzJ49u0T/NWvWoFevXpgxYwYAYNGiRTh69CjWr1+PzZs3QwiB1atX48MPP0S/fv0AADt27ICDgwMOHDiAIUOGVN+bkxt1oRRY7FW5mNS9SdFpr+IAoy4s9WXPNXm6sleePc8Va7VpnbWtXq7zxVpnbauX66yZ66wiCiGEqPa1/k9+fj7q1q2Lffv2oX///lJ7cHAwMjIy8O2335Z4jaurK6ZOnYrJkydLbWFhYThw4AAuXryI33//HY0bN8aFCxfg4+Mj9QkICICPjw/WrFlTYsy8vDzk5eVJz1UqFVxcXJCZmQlLS0udvFcq26qj17EmsugUZYJyuDR52itvBwBgUvcmmNKjaamvTVPlIu1hHuzOr4FD3App3lGq7zRp3lFp4amyr6tt66xt9XKdL9Y6a1u9XGfNXKc2VCoVrKysKvT5rddTYPfv30dhYSEcHBw02h0cHJCSklLqa1JSUsrtX/ynNmOGh4fDyspKeri4uFTq/VDlDPNzxcGJnRDbMU4KP8WTpw9O7IRhfq5lvrayV549zxVrtWmdta1ervPFWmdtq5frrJnrrCp6PwVWE4SGhmLq1KnS8+IjQFQ97C1NYH9hLfC/ydN+p3wR2zEODnEr4GBpUu6h0cpeeVbpK9Zq2TprW71c54u1ztpWL9dZM9dZVfQagGxtbWFoaIjU1FSN9tTUVDg6Opb6GkdHx3L7F/+ZmpoKJycnjT5PnhJ7klKphFJZ/Ruf/ufJydOeY4FTJ5HedlJR+IlaXNSnjBBU2fD0PKGrNq2zttXLdb5Y66xt9XKdNXOdVUWvAcjY2Bi+vr6IjIyU5gCp1WpERkZiwoQJpb7G398fkZGRGnOAjh49Cn9/fwCAh4cHHB0dERkZKQUelUqF2NhYjBs3rirfDlVWJSdPA6h8eHqO0FWr1lnb6uU6X6x11rZ6uc6auc4qovdTYFOnTkVwcDDatWuHDh06YPXq1cjOzpauChs+fDgaNGiA8PCiewRMmjQJAQEBWLFiBV5//XXs3r0bv/zyCz799FMAgEKhwOTJk/HRRx+hSZMm8PDwwNy5c+Hs7Kwx0ZpqkCducmhvaaI54flZfyEqG56eJ3TVpnXWtnq5zhdrnbWtXq6zZq6ziuj1KrBi69evx7Jly5CSkgIfHx+sXbsWfn5+AICuXbvC3d0d27Ztk/rv3bsXH374IW7fvo0mTZogIiICr732mrRcCIGwsDB8+umnyMjIQKdOnbBx40Y0bVr6lURP02YWOREREdUM2nx+14gAVNMwABEREdU+teYyeCIiIiJ9YAAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItlhACIiIiLZYQAiIiIi2WEAIiIiItnR+3eB1UTFN8dWqVR6roSIiIgqqvhzuyJfcsEAVIqHDx8CAFxcXPRcCREREWnr4cOHsLKyKrcPvwusFGq1Gn/++ScsLCygUCh0OrZKpYKLiwvu3r3L7xkrBbfPs3EbPRu3Ufm4fZ6N2+jZauI2EkLg4cOHcHZ2hoFB+bN8eASoFAYGBmjYsGGVrsPS0rLG7DA1EbfPs3EbPRu3Ufm4fZ6N2+jZato2etaRn2KcBE1ERESywwBEREREssMAVM2USiXCwsKgVCr1XUqNxO3zbNxGz8ZtVD5un2fjNnq22r6NOAmaiIiIZIdHgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICq0YYNG+Du7g4TExP4+fnh3Llz+i6pxpg/fz4UCoXGo1mzZvouS69++ukn9O3bF87OzlAoFDhw4IDGciEE5s2bBycnJ5iamiIwMBA3btzQT7F68qxtFBISUmK/6tWrl36K1YPw8HC0b98eFhYWsLe3R//+/ZGQkKDRJzc3F++//z7q168Pc3NzDBw4EKmpqXqquHpVZPt07dq1xD703nvv6ani6rdp0ya0bt1autmhv78/fvjhB2l5bd5/GICqyZ49ezB16lSEhYXh/Pnz8Pb2RlBQENLS0vRdWo3RsmVLJCcnS4+TJ0/quyS9ys7Ohre3NzZs2FDq8oiICKxduxabN29GbGwszMzMEBQUhNzc3GquVH+etY0AoFevXhr71ZdfflmNFepXTEwM3n//fZw9exZHjx7F48eP0bNnT2RnZ0t9pkyZgu+++w579+5FTEwM/vzzTwwYMECPVVefimwfABg9erTGPhQREaGniqtfw4YNsWTJEsTFxeGXX37Bq6++in79+uHy5csAavn+I6hadOjQQbz//vvS88LCQuHs7CzCw8P1WFXNERYWJry9vfVdRo0FQOzfv196rlarhaOjo1i2bJnUlpGRIZRKpfjyyy/1UKH+Pb2NhBAiODhY9OvXTy/11ERpaWkCgIiJiRFCFO0zderUEXv37pX6XL16VQAQZ86c0VeZevP09hFCiICAADFp0iT9FVUD2djYiM8//7zW7z88AlQN8vPzERcXh8DAQKnNwMAAgYGBOHPmjB4rq1lu3LgBZ2dnNGrUCMOGDUNSUpK+S6qxEhMTkZKSorFPWVlZwc/Pj/vUU6Kjo2Fvbw8vLy+MGzcODx480HdJepOZmQkAqFevHgAgLi4Ojx8/1tiPmjVrBldXV1nuR09vn2K7du2Cra0tXnrpJYSGhiInJ0cf5eldYWEhdu/ejezsbPj7+9f6/YdfhloN7t+/j8LCQjg4OGi0Ozg44Nq1a3qqqmbx8/PDtm3b4OXlheTkZCxYsACdO3fGb7/9BgsLC32XV+OkpKQAQKn7VPEyKjr9NWDAAHh4eODWrVv4z3/+g969e+PMmTMwNDTUd3nVSq1WY/LkyejYsSNeeuklAEX7kbGxMaytrTX6ynE/Km37AMDbb78NNzc3ODs749KlS5g1axYSEhLwzTff6LHa6vXrr7/C398fubm5MDc3x/79+9GiRQvEx8fX6v2HAYhqhN69e0s/t27dGn5+fnBzc8NXX32FUaNG6bEyqs2GDBki/dyqVSu0bt0ajRs3RnR0NLp3767Hyqrf+++/j99++032c+vKUtb2GTNmjPRzq1at4OTkhO7du+PWrVto3LhxdZepF15eXoiPj0dmZib27duH4OBgxMTE6Lus58ZTYNXA1tYWhoaGJWbGp6amwtHRUU9V1WzW1tZo2rQpbt68qe9SaqTi/Yb7lHYaNWoEW1tb2e1XEyZMwMGDBxEVFYWGDRtK7Y6OjsjPz0dGRoZGf7ntR2Vtn9L4+fkBgKz2IWNjY3h6esLX1xfh4eHw9vbGmjVrav3+wwBUDYyNjeHr64vIyEipTa1WIzIyEv7+/nqsrObKysrCrVu34OTkpO9SaiQPDw84Ojpq7FMqlQqxsbHcp8rxxx9/4MGDB7LZr4QQmDBhAvbv34/jx4/Dw8NDY7mvry/q1KmjsR8lJCQgKSlJFvvRs7ZPaeLj4wFANvtQadRqNfLy8mr//qPvWdhysXv3bqFUKsW2bdvElStXxJgxY4S1tbVISUnRd2k1wrRp00R0dLRITEwUp06dEoGBgcLW1lakpaXpuzS9efjwobhw4YK4cOGCACBWrlwpLly4IO7cuSOEEGLJkiXC2tpafPvtt+LSpUuiX79+wsPDQzx69EjPlVef8rbRw4cPxfTp08WZM2dEYmKiOHbsmGjbtq1o0qSJyM3N1Xfp1WLcuHHCyspKREdHi+TkZOmRk5Mj9XnvvfeEq6urOH78uPjll1+Ev7+/8Pf312PV1edZ2+fmzZti4cKF4pdffhGJiYni22+/FY0aNRJdunTRc+XVZ/bs2SImJkYkJiaKS5cuidmzZwuFQiGOHDkihKjd+w8DUDVat26dcHV1FcbGxqJDhw7i7Nmz+i6pxhg8eLBwcnISxsbGokGDBmLw4MHi5s2b+i5Lr6KiogSAEo/g4GAhRNGl8HPnzhUODg5CqVSK7t27i4SEBP0WXc3K20Y5OTmiZ8+ews7OTtSpU0e4ubmJ0aNHy+o/HaVtGwBi69atUp9Hjx6J8ePHCxsbG1G3bl3xxhtviOTkZP0VXY2etX2SkpJEly5dRL169YRSqRSenp5ixowZIjMzU7+FV6ORI0cKNzc3YWxsLOzs7ET37t2l8CNE7d5/FEIIUX3Hm4iIiIj0j3OAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIiIiEh2GICIiIhIdhiAiIiISHYYgIhI54QQGDNmDOrVqweFQiF9gzYRUU3B7wIjIp374Ycf0K9fP0RHR6NRo0awtbWFkZGRvssiIpLwXyQi0rlbt27ByckJr7zySqnL8/PzYWxsXM1VERH9g6fAiEinQkJCMHHiRCQlJUGhUMDd3R1du3bFhAkTMHnyZNja2iIoKAgAoFarER4eDg8PD5iamsLb2xv79u3TGC87OxvDhw+Hubk5nJycsGLFCnTt2hWTJ08GALi7u2P16tUar/Hx8cH8+fOl5xVZT9euXfHBBx9g5syZqFevHhwdHTXGKB4nIiICnp6eUCqVcHV1xeLFi7Fjxw7Ur18feXl5Gv379++Pf//732Vuq1u3bkGhUODgwYPo3r076tatCy8vL8TGxlZgSxPR82AAIiKdWrNmDRYuXIiGDRsiOTkZP//8MwBg+/btMDY2xqlTp7B582YAQHh4OHbs2IHNmzfj8uXLmDJlCt555x3ExMRI482YMQMxMTH49ttvceTIEURHR+P8+fNa1VSR9RTXaGZmhtjYWERERGDhwoU4evSotDw0NBRLlizB3LlzceXKFXzxxRdwcHDAW2+9hcLCQvz3v/+V+qalpeHQoUMYOXJkmXVdvHgRCoUCK1euxNy5c3Hx4kW4urpi9uzZWr0/IqoEQUSkY6tWrRJubm7S84CAANGmTRuNPrm5uaJu3bri9OnTGu2jRo0SQ4cOFUII8fDhQ2FsbCy++uorafmDBw+EqampmDRpkhBCCDc3N7Fq1SqNMby9vUVYWFiF11NcY6dOnTT6tG/fXsyaNUsIIYRKpRJKpVJ89tlnpb7ncePGid69e0vPV6xYIRo1aiTUanWp/YUQYt68ecLGxkakpaVJbWvXrhUtW7Ys8zVEpBucA0RE1cLX11fj+c2bN5GTk4MePXpotOfn56NNmzYAik4R5efnw8/PT1per149eHl5VXi9FVlPsdatW2s8d3JyQlpaGgDg6tWryMvLQ/fu3Utdz+jRo9G+fXvcu3cPDRo0wLZt2xASEgKFQlFmbRcvXkS/fv1gZ2cntSUmJsLT07PC74+IKocBiIiqhZmZmcbzrKwsAMChQ4fQoEEDjWVKpbLC4xoYGEA8dTHr48ePK7WeOnXqaDxXKBRQq9UAAFNT03LraNOmDby9vbFjxw707NkTly9fxqFDh8p9zcWLFxEaGqrRFh8fjy5dupT7OiJ6fgxARKQXLVq0gFKpRFJSEgICAkrt07hxY9SpUwexsbFwdXUFAPz999+4fv269Bo7OzskJydLr1GpVEhMTNRqPRXRpEkTmJqaIjIyEu+++26pfd59912sXr0a9+7dQ2BgIFxcXMocLzMzE7dv3y5xFCo+Ph4ffPBBpeskoophACIivbCwsMD06dMxZcoUqNVqdOrUCZmZmTh16hQsLS0RHBwMc3NzjBo1CjNmzED9+vVhb2+POXPmwMDgn+s3Xn31VWzbtg19+/aFtbU15s2bB0NDQ63WUxEmJiaYNWsWZs6cCWNjY3Ts2BHp6em4fPkyRo0aBQB4++23MX36dHz22WfYsWNHueNdunQJRkZGaNWqldR2584d/P333/Dx8dFiSxJRZTAAEZHeLFq0CHZ2dggPD8fvv/8Oa2trtG3bFv/5z3+kPsuWLUNWVhb69u0LCwsLTJs2DZmZmdLy0NBQJCYmok+fPrCyssKiRYs0jgBVdD0VMXfuXBgZGWHevHn4888/4eTkhPfee09abmVlhYEDB+LQoUPo379/uWNdvHgRXl5eMDExkdouXLgAa2truLu7a1UXEWmPd4Imolqna9eu8PHxKXH/n5qge/fuaNmyJdauXavvUoioHDwCRESkA3///Teio6MRHR2NjRs36rscInoGBiAiIh1o06YN/v77byxdulSry/SJSD94CoyIiIhkh1+FQURERLLDAERERESywwBEREREssMARERERLLDAERERESywwBEREREssMARERERLLDAERERESywwBEREREssMARERERLLz/wGrZ2N2uVY50gAAAABJRU5ErkJggg==\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(range(d), fourier_p(d)[:d], '+', label = \"Gaussian kernel\")\n", "plt.plot(range(d), predict_spectrum(probabilities)[:d], 'x', label = \"QK predicted\")\n", "plt.xlabel(\"frequency $n$\")\n", "plt.ylabel(\"Fourier coefficient\")\n", "plt.suptitle(\"Fourier spectrum of the Gaussian kernel\")\n", "plt.legend()\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It seems like it does! But as we just said, this is still only the predicted spectrum. We haven\\'t called the quantum computer at all yet!\n", "\n", "Let\\'s see what happens when we call the function `coefficients` on the QK function we defined earlier. Good coding practice tells us we should probably turn this step into a function itself, in case it is of use later:\n" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def fourier_q(d, thetas, amplitudes):\n", " return np.real(coefficients(lambda x: QK(x, thetas, amplitudes), 1, d-1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And with this, we can finally visualize how the Fourier spectrum of the QK function compares to that of the Gaussian kernel:\n" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(range(d), fourier_p(d)[:d], '+', label = \"Gaussian kernel\")\n", "plt.plot(range(d), predict_spectrum(probabilities)[:d], 'x', label=\"QK predicted\")\n", "plt.plot(range(d), fourier_q(d, thetas, amplitudes)[:d], '.', label = \"QK computer\")\n", "plt.xlabel(\"frequency $n$\")\n", "plt.ylabel(\"Fourier coefficient\")\n", "plt.suptitle(\"Fourier spectrum of the Gaussian kernel\")\n", "plt.legend()\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It seems it went well! Matching spectra should mean matching kernel functions, right?\n" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "Y_learned = QK_on_dataset(X, thetas, amplitudes)\n", "Y_truth = [Gauss_p(x_) for x_ in X]\n", "\n", "plt.plot(X, Y_learned, '-.', label = \"QK\")\n", "plt.plot(X, Y_truth, '--', label = \"Gaussian kernel\")\n", "plt.xlabel(\"$\\delta$\")\n", "plt.ylabel(\"$k(\\delta)$\")\n", "plt.legend()\n", "plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Yeah! We did it!\n", "\n", "![](images/salesman.PNG)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Kernel-based training of quantum models with scikit-learn\n", "\n", "\n", "Over the last few years, quantum machine learning research has provided a lot of insights on how we can understand and train quantum circuits as machine learning models. While many connections to neural networks have been made, it becomes increasingly clear that their mathematical foundation is intimately related to so-called *kernel methods*, the most famous of which is the [support vector machine (SVM)](https://en.wikipedia.org/wiki/Support-vector_machine) (see for example [Schuld and Killoran (2018)](https://arxiv.org/abs/1803.07128), [Havlicek et al. (2018)](https://arxiv.org/abs/1804.11326), [Liu et al. (2020)](https://arxiv.org/abs/2010.02174), [Huang et al. (2020)](https://arxiv.org/pdf/2011.01938), and, for a systematic summary which we will follow here, [Schuld (2021)](https://arxiv.org/abs/2101.11020)).\n", "\n", "The link between quantum models and kernel methods has important practical implications: we can replace the common [variational approach](https://pennylane.ai/qml/glossary/variational_circuit.html) to quantum machine learning with a classical kernel method where the kernel---a small building block of the overall algorithm---is computed by a quantum device. In many situations there are guarantees that we get better or at least equally good results.\n", "\n", "This demonstration explores how kernel-based training compares with [variational training](https://pennylane.ai/qml/demos/tutorial_variational_classifier.html) in terms of the number of quantum circuits that have to be evaluated.\n", "For this we train a quantum machine learning model with a kernel-based approach using a combination of PennyLane and the [scikit-learn](https://scikit-learn.org/) machine learning library. We compare this strategy with a variational quantum circuit trained via stochastic gradient descent using [PyTorch](https://pennylane.readthedocs.io/en/stable/introduction/interfaces/torch.html).\n", "\n", "We will see that in a typical small-scale example, kernel-based training requires only a fraction of the number of quantum circuit evaluations used by variational circuit training, while each evaluation runs a much shorter circuit. In general, the relative efficiency of kernel-based methods compared to variational circuits depends on the number of parameters used in the variational model.\n", "\n", "![](images/scaling1.png)\n", "\n", "If the number of variational parameters remains small, e.g., there is a square-root-like scaling with the number of data samples (green line), variational circuits are almost as efficient as neural networks (blue line), and require much fewer circuit evaluations than the quadratic scaling of kernel methods (red line). However, with current hardware-compatible training strategies, kernel methods scale much better than variational circuits that require a number of parameters of the order of the training set size (orange line).\n", "\n", "In conclusion, **for quantum machine learning applications with many parameters, kernel-based training can be a great alternative to the variational approach to quantum machine learning**.\n", "\n", "After working through this demo, you will:\n", "\n", "- be able to use a support vector machine with a quantum kernel\n", " computed with PennyLane, and\n", "- be able to compare the scaling of quantum circuit evaluations\n", " required in kernel-based versus variational training.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Background\n", "\n", "\n", "Let us consider a *quantum model* of the form\n", "\n", "$$f(x) = \\langle \\phi(x) | \\mathcal{M} | \\phi(x)\\rangle,$$\n", "\n", "where $| \\phi(x)\\rangle$ is prepared by a fixed [embedding circuit](https://pennylane.ai/qml/glossary/quantum_embedding.html) that encodes data inputs $x$, and $\\mathcal{M}$ is an arbitrary observable.\n", "This model includes variational quantum machine learning models, since the observable can effectively be implemented by a simple measurement that is preceded by a variational circuit:\n", "\n", "![](images/quantum_model.png)\n", "\n", "For example, applying a circuit $G(\\theta)$ and then measuring the Pauli-Z observable $\\sigma^0_z$ of the first qubit implements the trainable measurement $\\mathcal{M}(\\theta) = G^{\\dagger}(\\theta) \\sigma^0_z G(\\theta)$.\n", "\n", "The main practical consequence of approaching quantum machine learning with a kernel approach is that instead of training $f$ variationally, we can often train an equivalent classical kernel method with a kernel\n", "executed on a quantum device. This *quantum kernel* is given by the mutual overlap of two data-encoding quantum states,\n", "\n", "$$\\kappa(x, x') = | \\langle \\phi(x') | \\phi(x)\\rangle|^2.$$\n", "\n", "Kernel-based training therefore bypasses the processing and measurement parts of common variational circuits, and only depends on the data encoding.\n", "\n", "If the loss function $L$ is the [hinge loss](https://en.wikipedia.org/wiki/Hinge_loss), the kernel method corresponds to a standard [support vector machine](https://en.wikipedia.org/wiki/Support-vector_machine) (SVM) in\n", "the sense of a maximum-margin classifier. Other convex loss functions lead to more general variations of support vector machines.\n", "\n", "Note:\n", "\n", "More precisely, we can replace variational with kernel-based training if\n", "the optimisation problem can be written as minimizing a cost of the form\n", "\n", "$$\\min_f \\lambda\\; \\mathrm{tr}\\{\\mathcal{M}^2\\} + \\frac{1}{M}\\sum_{m=1}^M L(f(x^m), y^m),$$\n", "\n", "which is a regularized empirical risk with training data samples\n", "$(x^m, y^m)_{m=1\\dots M}$, regularization strength\n", "$\\lambda \\in \\mathbb{R}$, and loss function $L$.\n", "\n", "Theory predicts that kernel-based training will always find better or\n", "equally good minima of this risk. However, to show this here we would\n", "have to either regularize the variational training by the trace of the\n", "squared observable, or switch off regularization in the classical SVM,\n", "which removes a lot of its strength. The kernel-based and the\n", "variational training in this demonstration therefore optimize slightly\n", "different cost functions, and it is out of our scope to establish\n", "whether one training method finds a better minimum than the other.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Kernel-based training\n", "\n", "\n", "First, we will turn to kernel-based training of quantum models. As stated above, an example implementation is a standard support vector machine with a kernel computed by a quantum circuit.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We begin by importing all sorts of useful methods:\n" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false }, "outputs": [ { "ename": "ModuleNotFoundError", "evalue": "No module named 'torch'", "output_type": "error", "traceback": [ "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", "\u001B[0;31mModuleNotFoundError\u001B[0m Traceback (most recent call last)", "Input \u001B[0;32mIn [58]\u001B[0m, in \u001B[0;36m\u001B[0;34m()\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mnumpy\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01mnp\u001B[39;00m\n\u001B[0;32m----> 2\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mtorch\u001B[39;00m\n\u001B[1;32m 3\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mtorch\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mnn\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mfunctional\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m relu\n\u001B[1;32m 5\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01msklearn\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01msvm\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m SVC\n", "\u001B[0;31mModuleNotFoundError\u001B[0m: No module named 'torch'" ] } ], "source": [ "import numpy as np\n", "import torch\n", "from torch.nn.functional import relu\n", "\n", "from sklearn.svm import SVC\n", "from sklearn.datasets import load_iris\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import accuracy_score\n", "\n", "import pennylane as qml\n", "from pennylane.templates import AngleEmbedding, StronglyEntanglingLayers\n", "from pennylane.operation import Tensor\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "np.random.seed(42)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The second step is to define a data set. Since the performance of the models is not the focus of this demo, we can just use the first two classes of the famous [Iris data set](https://en.wikipedia.org/wiki/Iris_flower_data_set). Dating back to as far as 1936, this toy data set consists of 100 samples of four features each, and gives rise to a very simple classification problem.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "X, y = load_iris(return_X_y=True)\n", "\n", "# pick inputs and labels from the first two classes only,\n", "# corresponding to the first 100 samples\n", "X = X[:100]\n", "y = y[:100]\n", "\n", "# scaling the inputs is important since the embedding we use is periodic\n", "scaler = StandardScaler().fit(X)\n", "X_scaled = scaler.transform(X)\n", "\n", "# scaling the labels to -1, 1 is important for the SVM and the\n", "# definition of a hinge loss\n", "y_scaled = 2 * (y - 0.5)\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We use the [angle-embedding template](https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.embeddings.AngleEmbedding.html) which needs as many qubits as there are features:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "n_qubits = len(X_train[0])\n", "n_qubits" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To implement the kernel we could prepare the two states $| \\phi(x) \\rangle$, $| \\phi(x') \\rangle$ on different sets of qubits with angle-embedding routines $S(x), S(x')$, and measure their overlap\n", "with a small routine called a [SWAP test](https://en.wikipedia.org/wiki/Swap_test).\n", "\n", "However, we need only half the number of qubits if we prepare $| \\phi(x)\\rangle$ and then apply the inverse embedding with $x'$ on the same qubits. We then measure the projector onto the initial state\n", "$|0..0\\rangle \\langle 0..0|$.\n", "\n", "![](images/kernel_circuit.png){.align-center}\n", "\n", "To verify that this gives us the kernel:\n", "\n", "$$\\begin{aligned}\n", "\\begin{align*}\n", " \\langle 0..0 |S(x') S(x)^{\\dagger} \\mathcal{M} S(x')^{\\dagger} S(x) | 0..0\\rangle &= \\langle 0..0 |S(x') S(x)^{\\dagger} |0..0\\rangle \\langle 0..0| S(x')^{\\dagger} S(x) | 0..0\\rangle \\\\\n", " &= |\\langle 0..0| S(x')^{\\dagger} S(x) | 0..0\\rangle |^2\\\\\n", " &= | \\langle \\phi(x') | \\phi(x)\\rangle|^2 \\\\\n", " &= \\kappa(x, x').\n", "\\end{align*}\n", "\\end{aligned}$$\n", "\n", "Note that a projector $|0..0 \\rangle \\langle 0..0|$ can be constructed using the `qml.Hermitian` observable in PennyLane.\n", "\n", "Altogether, we use the following quantum node as a *quantum kernel evaluator*:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "dev_kernel = qml.device(\"default.qubit\", wires=n_qubits)\n", "\n", "projector = np.zeros((2**n_qubits, 2**n_qubits))\n", "projector[0, 0] = 1\n", "\n", "@qml.qnode(dev_kernel)\n", "def kernel(x1, x2):\n", " \"\"\"The quantum kernel.\"\"\"\n", " AngleEmbedding(x1, wires=range(n_qubits))\n", " qml.adjoint(AngleEmbedding)(x2, wires=range(n_qubits))\n", " return qml.expval(qml.Hermitian(projector, wires=range(n_qubits)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A good sanity check is whether evaluating the kernel of a data point and itself returns 1:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "kernel(X_train[0], X_train[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The way an SVM with a custom kernel is implemented in scikit-learn requires us to pass a function that computes a matrix of kernel evaluations for samples in two different datasets A, B. If A=B, this is the [Gram matrix](https://en.wikipedia.org/wiki/Gramian_matrix).\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def kernel_matrix(A, B):\n", " \"\"\"Compute the matrix whose entries are the kernel\n", " evaluated on pairwise data from sets A and B.\"\"\"\n", " return np.array([[kernel(a, b) for b in B] for a in A])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Training the SVM optimizes internal parameters that basically weigh kernel functions. It is a breeze in scikit-learn, which is designed as a high-level machine learning library:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "svm = SVC(kernel=kernel_matrix).fit(X_train, y_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's compute the accuracy on the test set.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "predictions = svm.predict(X_test)\n", "accuracy_score(predictions, y_test)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The SVM predicted all test points correctly. How many times was the quantum device evaluated?\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "dev_kernel.num_executions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This number can be derived as follows: For $M$ training samples, the SVM must construct the $M \\times M$ dimensional kernel gram matrix for training. To classify $M_{\\rm pred}$ new samples, the SVM needs to evaluate the kernel at most $M_{\\rm pred}M$ times to get the pairwise distances between training vectors and test samples.\n", "\n", "Note\n", "\n", "Depending on the implementation of the SVM, only $S \\leq M_{\\rm pred}$ *support vectors* are needed.\n", "\n", "Let us formulate this as a function, which can be used at the end of the demo to construct the scaling plot shown in the introduction.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def circuit_evals_kernel(n_data, split):\n", " \"\"\"Compute how many circuit evaluations one needs for kernel-based\n", " training and prediction.\"\"\"\n", "\n", " M = int(np.ceil(split * n_data))\n", " Mpred = n_data - M\n", "\n", " n_training = M * M\n", " n_prediction = M * Mpred\n", "\n", " return n_training + n_prediction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With $M = 75$ and $M_{\\rm pred} = 25$, the number of kernel evaluations can therefore be estimated as:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "circuit_evals_kernel(n_data=len(X), split=len(X_train) /(len(X_train) + len(X_test)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The single additional evaluation can be attributed to evaluating the kernel once above as a sanity check.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A similar example using variational training\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Using the variational principle of training, we can propose an *ansatz* for the variational circuit and train it directly. By increasing the number of layers of the ansatz, its expressivity increases. Depending on\n", "the ansatz, we may only search through a subspace of all measurements for the best candidate.\n", "\n", "Remember from above, the variational training does not optimize *exactly* the same cost as the SVM, but we try to match them as closely as possible. For this we use a bias term in the quantum model, and train on the hinge loss.\n", "\n", "We also explicitly use the [parameter-shift](https://pennylane.ai/qml/glossary/parameter_shift.html) differentiation method in the quantum node, since this is a method which works on hardware as well. While `diff_method='backprop'` or `diff_method='adjoint'` would reduce the number of circuit evaluations significantly, they are based on tricks that are only suitable for simulators, and can therefore not scale to more than a few dozen qubits.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "dev_var = qml.device(\"default.qubit\", wires=n_qubits)\n", "\n", "@qml.qnode(dev_var, interface=\"torch\", diff_method=\"parameter-shift\")\n", "def quantum_model(x, params):\n", " \"\"\"A variational quantum model.\"\"\"\n", "\n", " # embedding\n", " AngleEmbedding(x, wires=range(n_qubits))\n", "\n", " # trainable measurement\n", " StronglyEntanglingLayers(params, wires=range(n_qubits))\n", " return qml.expval(qml.PauliZ(0))\n", "\n", "def quantum_model_plus_bias(x, params, bias):\n", " \"\"\"Adding a bias.\"\"\"\n", " return quantum_model(x, params) + bias\n", "\n", "def hinge_loss(predictions, targets):\n", " \"\"\"Implements the hinge loss.\"\"\"\n", " all_ones = torch.ones_like(targets)\n", " hinge_loss = all_ones - predictions * targets\n", " # trick: since the max(0,x) function is not differentiable,\n", " # use the mathematically equivalent relu instead\n", " hinge_loss = relu(hinge_loss)\n", " return hinge_loss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now summarize the usual training and prediction steps into two functions similar to scikit-learn\\'s `fit()` and `predict()`. While it feels cumbersome compared to the one-liner used to train the kernel method, PennyLane---like other differentiable programming libraries---provides a lot more control over the particulars of training.\n", "\n", "In our case, most of the work is to convert between numpy and torch, which we need for the differentiable `relu` function used in the hinge loss.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def quantum_model_train(n_layers, steps, batch_size):\n", " \"\"\"Train the quantum model defined above.\"\"\"\n", "\n", " params = np.random.random((n_layers, n_qubits, 3))\n", " params_torch = torch.tensor(params, requires_grad=True)\n", " bias_torch = torch.tensor(0.0)\n", "\n", " opt = torch.optim.Adam([params_torch, bias_torch], lr=0.1)\n", "\n", " loss_history = []\n", " for i in range(steps):\n", "\n", " batch_ids = np.random.choice(len(X_train), batch_size)\n", "\n", " X_batch = X_train[batch_ids]\n", " y_batch = y_train[batch_ids]\n", "\n", " X_batch_torch = torch.tensor(X_batch, requires_grad=False)\n", " y_batch_torch = torch.tensor(y_batch, requires_grad=False)\n", "\n", " def closure():\n", " opt.zero_grad()\n", " preds = torch.stack(\n", " [quantum_model_plus_bias(x, params_torch, bias_torch) for x in X_batch_torch]\n", " )\n", " loss = torch.mean(hinge_loss(preds, y_batch_torch))\n", "\n", " # bookkeeping\n", " current_loss = loss.detach().numpy().item()\n", " loss_history.append(current_loss)\n", " if i % 10 == 0:\n", " print(\"step\", i, \", loss\", current_loss)\n", "\n", " loss.backward()\n", " return loss\n", "\n", " opt.step(closure)\n", "\n", " return params_torch, bias_torch, loss_history\n", "\n", "\n", "def quantum_model_predict(X_pred, trained_params, trained_bias):\n", " \"\"\"Predict using the quantum model defined above.\"\"\"\n", "\n", " p = []\n", " for x in X_pred:\n", "\n", " x_torch = torch.tensor(x)\n", " pred_torch = quantum_model_plus_bias(x_torch, trained_params, trained_bias)\n", " pred = pred_torch.detach().numpy().item()\n", " if pred > 0:\n", " pred = 1\n", " else:\n", " pred = -1\n", "\n", " p.append(pred)\n", " return p" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's train the variational model and see how well we are doing on the test set.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "n_layers = 2\n", "batch_size = 20\n", "steps = 100\n", "trained_params, trained_bias, loss_history = quantum_model_train(n_layers, steps, batch_size)\n", "\n", "pred_test = quantum_model_predict(X_test, trained_params, trained_bias)\n", "print(\"accuracy on test set:\", accuracy_score(pred_test, y_test))\n", "\n", "plt.plot(loss_history)\n", "plt.ylim((0, 1))\n", "plt.xlabel(\"steps\")\n", "plt.ylabel(\"cost\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The variational circuit has a slightly lower accuracy than the SVM---but this depends very much on the training settings we used. Different random parameter initializations, more layers, or more steps may indeed get perfect test accuracy.\n", "\n", "How often was the device executed?\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "dev_var.num_executions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "That is a lot more than the kernel method took!\n", "\n", "Let's try to understand this value. In each optimization step, the variational circuit needs to compute the partial derivative of all trainable parameters for each sample in a batch. Using parameter-shift\n", "rules, we require roughly two circuit evaluations per partial derivative. Prediction uses only one circuit evaluation per sample.\n", "\n", "We can formulate this as another function that will be used in the scaling plot below.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def circuit_evals_variational(n_data, n_params, n_steps, shift_terms, split, batch_size):\n", " \"\"\"Compute how many circuit evaluations are needed for\n", " variational training and prediction.\"\"\"\n", "\n", " M = int(np.ceil(split * n_data))\n", " Mpred = n_data - M\n", "\n", " n_training = n_params * n_steps * batch_size * shift_terms\n", " n_prediction = Mpred\n", "\n", " return n_training + n_prediction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This estimates the circuit evaluations in variational training as:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "circuit_evals_variational(\n", " n_data=len(X),\n", " n_params=len(trained_params.flatten()),\n", " n_steps=steps,\n", " shift_terms=2,\n", " split=len(X_train) /(len(X_train) + len(X_test)),\n", " batch_size=batch_size,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The estimate is a bit higher because it does not account for some optimizations that PennyLane performs under the hood.\n", "\n", "It is important to note that while they are trained in a similar manner, the number of variational circuit evaluations differs from the number of neural network model evaluations in classical machine learning, which would be given by:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "def model_evals_nn(n_data, n_params, n_steps, split, batch_size):\n", " \"\"\"Compute how many model evaluations are needed for neural\n", " network training and prediction.\"\"\"\n", "\n", " M = int(np.ceil(split * n_data))\n", " Mpred = n_data - M\n", "\n", " n_training = n_steps * batch_size\n", " n_prediction = Mpred\n", "\n", " return n_training + n_prediction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In each step of neural network training, and due to the clever implementations of automatic differentiation, the backpropagation algorithm can compute a gradient for all parameters in (more-or-less) a single run. For all we know at this stage, the no-cloning principle prevents variational circuits from using these tricks, which leads to `n_training` in `circuit_evals_variational` depending on the number of parameters, but not in `model_evals_nn`.\n", "\n", "For the same example as used here, a neural network would therefore have far fewer model evaluations than both variational and kernel-based training:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "model_evals_nn(\n", " n_data=len(X),\n", " n_params=len(trained_params.flatten()),\n", " n_steps=steps,\n", " split=len(X_train) /(len(X_train) + len(X_test)),\n", " batch_size=batch_size,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Which method scales best?\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The answer to this question depends on how the variational model is set up, and we need to make a few assumptions:\n", "\n", "1. Even if we use single-batch stochastic gradient descent, in which\n", " every training step uses exactly one training sample, we would want\n", " to see every training sample at least once on average. Therefore,\n", " the number of steps should scale at least linearly with the number\n", " of training data samples.\n", "\n", "2. Modern neural networks often have many more parameters than training\n", " samples. But we do not know yet whether variational circuits really\n", " need that many parameters as well. We will therefore use two cases\n", " for comparison:\n", "\n", " 2a) the number of parameters grows linearly with the training data,\n", " or `n_params = M`,\n", "\n", " 2b) the number of parameters saturates at some point, which we model\n", " by setting `n_params = sqrt(M)`.\n", "\n", "Note that compared to the example above with 75 training samples and 24 parameters, a) overestimates the number of evaluations, while b) underestimates it.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is how the three methods compare:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false }, "outputs": [], "source": [ "variational_training1 = []\n", "variational_training2 = []\n", "kernelbased_training = []\n", "nn_training = []\n", "x_axis = range(0, 2000, 100)\n", "\n", "for M in x_axis:\n", "\n", " var1 = circuit_evals_variational(\n", " n_data=M, n_params=M, n_steps=M, shift_terms=2, split=0.75, batch_size=1\n", " )\n", " variational_training1.append(var1)\n", "\n", " var2 = circuit_evals_variational(\n", " n_data=M, n_params=round(np.sqrt(M)), n_steps=M,\n", " shift_terms=2, split=0.75, batch_size=1\n", " )\n", " variational_training2.append(var2)\n", "\n", " kernel = circuit_evals_kernel(n_data=M, split=0.75)\n", " kernelbased_training.append(kernel)\n", "\n", " nn = model_evals_nn(\n", " n_data=M, n_params=M, n_steps=M, split=0.75, batch_size=1\n", " )\n", " nn_training.append(nn)\n", "\n", "\n", "plt.plot(x_axis, nn_training, linestyle='--', label=\"neural net\")\n", "plt.plot(x_axis, variational_training1, label=\"var. circuit (linear param scaling)\")\n", "plt.plot(x_axis, variational_training2, label=\"var. circuit (srqt param scaling)\")\n", "plt.plot(x_axis, kernelbased_training, label=\"(quantum) kernel\")\n", "plt.xlabel(\"size of data set\")\n", "plt.ylabel(\"number of evaluations\")\n", "plt.legend()\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is the plot we saw at the beginning. With current hardware-compatible training methods, whether kernel-based training requires more or fewer quantum circuit evaluations than variational training depends on how many parameters the latter needs. If variational circuits turn out to be as parameter-hungry as neural networks, kernel-based training will outperform them for common machine learning tasks. However, if variational learning only turns out to require few parameters (or if more efficient training methods are found), variational circuits could in principle match the linear scaling of neural networks trained with backpropagation.\n", "\n", "The practical take-away from this demo is that unless your variational circuit has significantly fewer parameters than training data, kernel methods could be a much faster alternative!\n", "\n", "Finally, it is important to note that fault-tolerant quantum computers may change the picture for both quantum and classical machine learning. As mentioned in [Schuld (2021)](https://arxiv.org/abs/2101.11020), early results from the quantum machine learning literature show that larger quantum computers will most likely enable us to reduce the quadratic scaling of kernel methods to linear scaling, which may make classical as well as quantum kernel methods a strong alternative to neural networks for big data processing one day.\n", "\n" ] }, { "cell_type": "markdown", "source": [ "# Send it after class\n", "\n", " Create a dataset which is nonlinear and then apply the kernel method you have just seen to classify the data.\n", "\n" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 59, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "from sklearn.datasets import make_moons\n", "\n", "X, y = make_moons(n_samples = 500, noise = 0.02, random_state = 417)\n", "\n", "plt.scatter(X[:, 0], X[:, 1], c = y)\n", "plt.show()" ], "metadata": { "collapsed": false } } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.15" } }, "nbformat": 4, "nbformat_minor": 0 }