├── README.md ├── noisy_sine.png ├── noisy_sine_trained.png ├── quantum_neural_network_tutorial_cos.ipynb ├── quantum_neural_network_tutorial_sine.ipynb ├── quantum_neural_network_tutorial_time_series-ModelB.ipynb └── quantum_neural_network_tutorial_time_series.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # FinTech-Time-Series 2 | Quantum Machine Learning for [FinTech](https://towardsdatascience.com/ten-applications-of-ai-to-fintech-22d626c2fdac) and Time Series Data 3 | 4 | ## [Quantum Neural Networks for FinTech](https://eandt.theiet.org/content/articles/2019/04/quantum-on-the-money-fintech-is-banking-on-the-future-of-computing/) Time Series Function Fitting 5 | This repository is for developing quantum neural network models for fitting one-dimensional time series data and noisy signals. It is modified from the model presented in PennyLane [Function fitting with a quantum neural network](https://pennylane.ai/qml/app/quantum_neural_net.html). We modify the code presented in the default notebook downloaded from PennyLane so that it works using synthetic data created by the user, and we train a model on several years worth of drug sales data. 6 | 7 | ![alt text](noisy_sine.png) 8 | 9 | ## Training Data 10 | In this very basic setup, there were only 4-layers in the quantum neural network, initialized with random weights. The model went through 50 iterations and had the following training data: 11 | 12 | ``` 13 | Iter: 1 | Cost: 0.4366430 14 | Iter: 2 | Cost: 0.4130995 15 | Iter: 3 | Cost: 0.4401763 16 | Iter: 4 | Cost: 0.4843044 17 | Iter: 5 | Cost: 0.5272264 18 | Iter: 6 | Cost: 0.5590949 19 | Iter: 7 | Cost: 0.5756194 20 | Iter: 8 | Cost: 0.5762956 21 | Iter: 9 | Cost: 0.5631025 22 | Iter: 10 | Cost: 0.5394853 23 | Iter: 11 | Cost: 0.5095363 24 | Iter: 12 | Cost: 0.4773198 25 | Iter: 13 | Cost: 0.4463337 26 | Iter: 14 | Cost: 0.4191397 27 | Iter: 15 | Cost: 0.3972019 28 | Iter: 16 | Cost: 0.3809405 29 | Iter: 17 | Cost: 0.3699549 30 | Iter: 18 | Cost: 0.3633300 31 | Iter: 19 | Cost: 0.3599337 32 | Iter: 20 | Cost: 0.3586456 33 | Iter: 21 | Cost: 0.3584964 34 | Iter: 22 | Cost: 0.3587285 35 | Iter: 23 | Cost: 0.3588033 36 | Iter: 24 | Cost: 0.3583769 37 | Iter: 25 | Cost: 0.3572647 38 | Iter: 26 | Cost: 0.3554029 39 | Iter: 27 | Cost: 0.3528146 40 | Iter: 28 | Cost: 0.3495813 41 | Iter: 29 | Cost: 0.3458197 42 | Iter: 30 | Cost: 0.3416648 43 | Iter: 31 | Cost: 0.3372562 44 | Iter: 32 | Cost: 0.3327294 45 | Iter: 33 | Cost: 0.3282081 46 | Iter: 34 | Cost: 0.3238007 47 | Iter: 35 | Cost: 0.3195972 48 | Iter: 36 | Cost: 0.3156676 49 | Iter: 37 | Cost: 0.3120615 50 | Iter: 38 | Cost: 0.3088088 51 | Iter: 39 | Cost: 0.3059200 52 | Iter: 40 | Cost: 0.3033888 53 | Iter: 41 | Cost: 0.3011936 54 | Iter: 42 | Cost: 0.2993004 55 | Iter: 43 | Cost: 0.2976666 56 | Iter: 44 | Cost: 0.2962437 57 | Iter: 45 | Cost: 0.2949811 58 | Iter: 46 | Cost: 0.2938298 59 | Iter: 47 | Cost: 0.2927447 60 | Iter: 48 | Cost: 0.2916878 61 | Iter: 49 | Cost: 0.2906292 62 | Iter: 50 | Cost: 0.2895481 63 | Iter: 51 | Cost: 0.2884328 64 | Iter: 52 | Cost: 0.2872799 65 | Iter: 53 | Cost: 0.2860931 66 | Iter: 54 | Cost: 0.2848812 67 | Iter: 55 | Cost: 0.2836566 68 | Iter: 56 | Cost: 0.2824333 69 | Iter: 57 | Cost: 0.2812253 70 | Iter: 58 | Cost: 0.2800452 71 | Iter: 59 | Cost: 0.2789039 72 | Iter: 60 | Cost: 0.2778094 73 | Iter: 61 | Cost: 0.2767668 74 | Iter: 62 | Cost: 0.2757787 75 | Iter: 63 | Cost: 0.2748451 76 | Iter: 64 | Cost: 0.2739643 77 | Iter: 65 | Cost: 0.2731328 78 | Iter: 66 | Cost: 0.2723465 79 | Iter: 67 | Cost: 0.2716004 80 | Iter: 68 | Cost: 0.2708895 81 | Iter: 69 | Cost: 0.2702092 82 | Iter: 70 | Cost: 0.2695549 83 | Iter: 71 | Cost: 0.2689228 84 | Iter: 72 | Cost: 0.2683099 85 | Iter: 73 | Cost: 0.2677134 86 | Iter: 74 | Cost: 0.2671316 87 | Iter: 75 | Cost: 0.2665631 88 | Iter: 76 | Cost: 0.2660070 89 | Iter: 77 | Cost: 0.2654630 90 | Iter: 78 | Cost: 0.2649310 91 | Iter: 79 | Cost: 0.2644110 92 | Iter: 80 | Cost: 0.2639034 93 | Iter: 81 | Cost: 0.2634083 94 | Iter: 82 | Cost: 0.2629260 95 | Iter: 83 | Cost: 0.2624569 96 | Iter: 84 | Cost: 0.2620009 97 | Iter: 85 | Cost: 0.2615582 98 | Iter: 86 | Cost: 0.2611285 99 | Iter: 87 | Cost: 0.2607117 100 | Iter: 88 | Cost: 0.2603074 101 | Iter: 89 | Cost: 0.2599152 102 | Iter: 90 | Cost: 0.2595346 103 | Iter: 91 | Cost: 0.2591651 104 | Iter: 92 | Cost: 0.2588059 105 | Iter: 93 | Cost: 0.2584567 106 | Iter: 94 | Cost: 0.2581168 107 | Iter: 95 | Cost: 0.2577857 108 | Iter: 96 | Cost: 0.2574629 109 | Iter: 97 | Cost: 0.2571479 110 | Iter: 98 | Cost: 0.2568405 111 | Iter: 99 | Cost: 0.2565402 112 | Iter: 100 | Cost: 0.2562468 113 | ``` 114 | 115 | ## Prediction Plots 116 | After training the quantum neural network learns to smooth the noisy sine function as can be seen in the red plots: 117 | 118 | ![alt text](noisy_sine_trained.png) 119 | 120 | ## Strawberry Fields and Optical Quantum Computing 121 | This example illustrates an implementation of optical quantum computing and training an optical based quantum neural network. For more information on photonic quantum computing see the [Strawberry Fields documentation](https://arxiv.org/abs/1804.03159). Strawberry Fields is a full-stack library for design, simulation, optimization, and 122 | quantum machine learning of continuous-variable circuits that is fully integrated into PennyLane. For more information on more general quantum nodes, see the [PennyLane documentation](https://pennylane.ai/qml/concepts/quantum_nodes.html). 123 | 124 | In later examples of applications of quantum machine learning to FinTech, we will also be investigating [quantum walks](https://link.medium.com/ZsbIWYMAL2). [Quantum walks](https://fintechcircle.com/insights/quantum-machine-learning/) are a quantum analogue to random walks and have substantially reduced the time-consumption in Monte Carlo simulations for mixing of Markov chains as reported by Ashley Montanaro (2015). [These quantum algorithms](https://advances.sciencemag.org/content/4/5/eaat3174.full) are applied for investment strategies in wealth management and trading. 125 | -------------------------------------------------------------------------------- /noisy_sine.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/The-Singularity-Research/FinTech-Time-Series/f798751cc5f2169f60c9f6d72cb58f3e5651fbe0/noisy_sine.png -------------------------------------------------------------------------------- /noisy_sine_trained.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/The-Singularity-Research/FinTech-Time-Series/f798751cc5f2169f60c9f6d72cb58f3e5651fbe0/noisy_sine_trained.png -------------------------------------------------------------------------------- /quantum_neural_network_tutorial_cos.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Noisy Cosine Function Fitting with a Quantum Neural Network" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Using the example from Penny Lane of a variational circuit that learns a\n", 15 | "fit for a noisy cosine function. \n", 16 | "\n", 17 | "The variational circuit used is the continuous-variable quantum neural\n", 18 | "network model described in:\n", 19 | "\n", 20 | "`Killoran et al. (2018) `\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 1, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "# Import PennyLane, the wrapped version of NumPy provided by PennyLane,and an optimizer.\n", 30 | "import pennylane as qml\n", 31 | "from pennylane import numpy as np\n", 32 | "from pennylane.optimize import AdamOptimizer" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 2, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "# Other imports:\n", 42 | "# matplotlib.pyplot to plot and visualize the data\n", 43 | "# numpy to generate the mathematical function\n", 44 | "# pylab to help with interactive plots\n", 45 | "# pickle to dump the data into a file for future use\n", 46 | "import matplotlib.pyplot as plt\n", 47 | "import numpy as np\n", 48 | "import pylab\n", 49 | "import pickle" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "## Creating a Noisy Cosine Function for Sampling" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 3, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [ 65 | "Xlim = 2\n", 66 | "noise = np.random.normal(0,0.2,40) # generate noise to add to the function values (Y-values)\n", 67 | "# define functions\n", 68 | "X = np.arange(-Xlim, Xlim, 0.1)\n", 69 | "Y = (np.cos(3*X)+noise)/2" 70 | ] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "This will generate two lists 'X' and 'Y' with our X-axis and Y-axis data. We'll now dump the Y-axis data into our file for future use." 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 4, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [ 85 | "# write the data out to a file\n", 86 | "cosdata = open('cosdata.md', 'wb')\n", 87 | "pickle.dump(Y, cosdata)\n", 88 | "cosdata.close()" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "The above snippet writes the data of y into a file named sinedata.md. Pickle is specific to Python and it can be used to load the data into another Python script later. Now we plot some of the data:" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": 5, 101 | "metadata": {}, 102 | "outputs": [ 103 | { 104 | "data": { 105 | "text/plain": [ 106 | "[]" 107 | ] 108 | }, 109 | "execution_count": 5, 110 | "metadata": {}, 111 | "output_type": "execute_result" 112 | }, 113 | { 114 | "data": { 115 | "image/png": "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\n", 116 | "text/plain": [ 117 | "
" 118 | ] 119 | }, 120 | "metadata": { 121 | "needs_background": "light" 122 | }, 123 | "output_type": "display_data" 124 | } 125 | ], 126 | "source": [ 127 | "plt.plot(X[0:200], Y[0:200])" 128 | ] 129 | }, 130 | { 131 | "cell_type": "markdown", 132 | "metadata": {}, 133 | "source": [ 134 | "So we have some noisy sine data to train our quantum neural network on. The device we use is the Strawberry Fields simulator, this time with only one quantum mode (or ``wire``). You will need to have the Strawberry Fields plugin for PennyLane installed." 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 6, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [ 143 | "dev = qml.device(\"strawberryfields.fock\", wires=1, cutoff_dim=10)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "### Quantum node\n", 151 | "For a single quantum mode, each layer of the variational circuit is defined as:" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 7, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [ 160 | "def layer(v):\n", 161 | " # Matrix multiplication of input layer\n", 162 | " qml.Rotation(v[0], wires=0)\n", 163 | " qml.Squeezing(v[1], 0.0, wires=0)\n", 164 | " qml.Rotation(v[2], wires=0)\n", 165 | "\n", 166 | " # Bias\n", 167 | " qml.Displacement(v[3], 0.0, wires=0)\n", 168 | "\n", 169 | " # Element-wise nonlinear transformation\n", 170 | " qml.Kerr(v[4], wires=0)" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "The variational circuit in the quantum node first encodes the input into\n", 178 | "the displacement of the mode, and then executes the layers. The output\n", 179 | "is the expectation of the x-quadrature." 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 8, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [ 188 | "@qml.qnode(dev)\n", 189 | "def quantum_neural_net(var, x=None):\n", 190 | " # Encode input x into quantum state\n", 191 | " qml.Displacement(x, 0.0, wires=0)\n", 192 | "\n", 193 | " # \"layer\" subcircuits\n", 194 | " for v in var:\n", 195 | " layer(v)\n", 196 | "\n", 197 | " return qml.expval(qml.X(0))" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "### Objective\n", 205 | "As an objective we take the square loss between target labels and model\n", 206 | "predictions." 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": 9, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [ 215 | "def square_loss(labels, predictions):\n", 216 | " loss = 0\n", 217 | " for l, p in zip(labels, predictions):\n", 218 | " loss = loss + (l - p) ** 2\n", 219 | "\n", 220 | " loss = loss / len(labels)\n", 221 | " return loss" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "In the cost function, we compute the outputs from the variational\n", 229 | "circuit. Function fitting is a regression problem, and we interpret the\n", 230 | "expectations from the quantum node as predictions (i.e., without\n", 231 | "applying postprocessing such as thresholding).\n" 232 | ] 233 | }, 234 | { 235 | "cell_type": "code", 236 | "execution_count": 10, 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [ 240 | "def cost(var, features, labels):\n", 241 | " preds = [quantum_neural_net(var, x=x) for x in features]\n", 242 | " return square_loss(labels, preds)" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "### Optimization\n", 250 | "We load noisy data samples of a sine function." 251 | ] 252 | }, 253 | { 254 | "cell_type": "markdown", 255 | "metadata": {}, 256 | "source": [ 257 | "Before training a model, let’s examine the data.\n", 258 | "\n", 259 | "*Note: For the next cell to work you need the matplotlib library.*\n" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": 11, 265 | "metadata": {}, 266 | "outputs": [ 267 | { 268 | "data": { 269 | "image/png": "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\n", 270 | "text/plain": [ 271 | "
" 272 | ] 273 | }, 274 | "metadata": { 275 | "needs_background": "light" 276 | }, 277 | "output_type": "display_data" 278 | } 279 | ], 280 | "source": [ 281 | "plt.figure()\n", 282 | "plt.scatter(X, Y)\n", 283 | "plt.xlabel(\"x\", fontsize=18)\n", 284 | "plt.ylabel(\"f(x)\", fontsize=18)\n", 285 | "plt.tick_params(axis=\"both\", which=\"major\", labelsize=16)\n", 286 | "plt.tick_params(axis=\"both\", which=\"minor\", labelsize=16)\n", 287 | "plt.show()" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "The network’s weights (called ``var`` here) are initialized with values\n", 295 | "sampled from a normal distribution. We use 4 layers; performance has\n", 296 | "been found to plateau at around 6 layers." 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 12, 302 | "metadata": {}, 303 | "outputs": [ 304 | { 305 | "name": "stdout", 306 | "output_type": "stream", 307 | "text": [ 308 | "[[ 0.08820262 0.02000786 0.0489369 0.11204466 0.0933779 ]\n", 309 | " [-0.04886389 0.04750442 -0.00756786 -0.00516094 0.02052993]\n", 310 | " [ 0.00720218 0.07271368 0.03805189 0.00608375 0.02219316]\n", 311 | " [ 0.01668372 0.07470395 -0.01025791 0.01565339 -0.04270479]]\n" 312 | ] 313 | } 314 | ], 315 | "source": [ 316 | "np.random.seed(0)\n", 317 | "num_layers = 4\n", 318 | "var_init = 0.05 * np.random.randn(num_layers, 5)\n", 319 | "print(var_init)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 13, 325 | "metadata": {}, 326 | "outputs": [ 327 | { 328 | "name": "stdout", 329 | "output_type": "stream", 330 | "text": [ 331 | "Iter: 1 | Cost: 0.8007706 \n", 332 | "Iter: 2 | Cost: 0.4914594 \n", 333 | "Iter: 3 | Cost: 0.6969488 \n", 334 | "Iter: 4 | Cost: 0.9452574 \n", 335 | "Iter: 5 | Cost: 1.1168969 \n", 336 | "Iter: 6 | Cost: 1.2109571 \n", 337 | "Iter: 7 | Cost: 1.2476765 \n", 338 | "Iter: 8 | Cost: 1.2450811 \n", 339 | "Iter: 9 | Cost: 1.2163145 \n", 340 | "Iter: 10 | Cost: 1.1705946 \n", 341 | "Iter: 11 | Cost: 1.1142030 \n", 342 | "Iter: 12 | Cost: 1.0512289 \n", 343 | "Iter: 13 | Cost: 0.9842209 \n", 344 | "Iter: 14 | Cost: 0.9147676 \n", 345 | "Iter: 15 | Cost: 0.8439298 \n", 346 | "Iter: 16 | Cost: 0.7724923 \n", 347 | "Iter: 17 | Cost: 0.7010800 \n", 348 | "Iter: 18 | Cost: 0.6302264 \n", 349 | "Iter: 19 | Cost: 0.5604551 \n", 350 | "Iter: 20 | Cost: 0.4923870 \n", 351 | "Iter: 21 | Cost: 0.4268471 \n", 352 | "Iter: 22 | Cost: 0.3649378 \n", 353 | "Iter: 23 | Cost: 0.3080507 \n", 354 | "Iter: 24 | Cost: 0.2577916 \n", 355 | "Iter: 25 | Cost: 0.2157890 \n", 356 | "Iter: 26 | Cost: 0.1833700 \n", 357 | "Iter: 27 | Cost: 0.1611441 \n", 358 | "Iter: 28 | Cost: 0.1486269 \n", 359 | "Iter: 29 | Cost: 0.1441018 \n", 360 | "Iter: 30 | Cost: 0.1448548 \n", 361 | "Iter: 31 | Cost: 0.1477444 \n", 362 | "Iter: 32 | Cost: 0.1498896 \n", 363 | "Iter: 33 | Cost: 0.1492221 \n", 364 | "Iter: 34 | Cost: 0.1447509 \n", 365 | "Iter: 35 | Cost: 0.1365335 \n", 366 | "Iter: 36 | Cost: 0.1254319 \n", 367 | "Iter: 37 | Cost: 0.1127618 \n", 368 | "Iter: 38 | Cost: 0.0999304 \n", 369 | "Iter: 39 | Cost: 0.0881402 \n", 370 | "Iter: 40 | Cost: 0.0782057 \n", 371 | "Iter: 41 | Cost: 0.0704979 \n", 372 | "Iter: 42 | Cost: 0.0649953 \n", 373 | "Iter: 43 | Cost: 0.0613973 \n", 374 | "Iter: 44 | Cost: 0.0592543 \n", 375 | "Iter: 45 | Cost: 0.0580798 \n", 376 | "Iter: 46 | Cost: 0.0574284 \n", 377 | "Iter: 47 | Cost: 0.0569391 \n", 378 | "Iter: 48 | Cost: 0.0563508 \n", 379 | "Iter: 49 | Cost: 0.0555004 \n", 380 | "Iter: 50 | Cost: 0.0543112 \n", 381 | "Iter: 51 | Cost: 0.0527778 \n", 382 | "Iter: 52 | Cost: 0.0509506 \n", 383 | "Iter: 53 | Cost: 0.0489198 \n", 384 | "Iter: 54 | Cost: 0.0468010 \n", 385 | "Iter: 55 | Cost: 0.0447204 \n", 386 | "Iter: 56 | Cost: 0.0428008 \n", 387 | "Iter: 57 | Cost: 0.0411470 \n", 388 | "Iter: 58 | Cost: 0.0398345 \n", 389 | "Iter: 59 | Cost: 0.0388999 \n", 390 | "Iter: 60 | Cost: 0.0383369 \n", 391 | "Iter: 61 | Cost: 0.0380990 \n", 392 | "Iter: 62 | Cost: 0.0381071 \n", 393 | "Iter: 63 | Cost: 0.0382639 \n", 394 | "Iter: 64 | Cost: 0.0384697 \n", 395 | "Iter: 65 | Cost: 0.0386380 \n", 396 | "Iter: 66 | Cost: 0.0387077 \n", 397 | "Iter: 67 | Cost: 0.0386493 \n", 398 | "Iter: 68 | Cost: 0.0384641 \n", 399 | "Iter: 69 | Cost: 0.0381787 \n", 400 | "Iter: 70 | Cost: 0.0378348 \n", 401 | "Iter: 71 | Cost: 0.0374784 \n", 402 | "Iter: 72 | Cost: 0.0371507 \n", 403 | "Iter: 73 | Cost: 0.0368808 \n", 404 | "Iter: 74 | Cost: 0.0366829 \n", 405 | "Iter: 75 | Cost: 0.0365567 \n", 406 | "Iter: 76 | Cost: 0.0364902 \n", 407 | "Iter: 77 | Cost: 0.0364635 \n", 408 | "Iter: 78 | Cost: 0.0364545 \n", 409 | "Iter: 79 | Cost: 0.0364419 \n", 410 | "Iter: 80 | Cost: 0.0364093 \n", 411 | "Iter: 81 | Cost: 0.0363462 \n", 412 | "Iter: 82 | Cost: 0.0362488 \n", 413 | "Iter: 83 | Cost: 0.0361197 \n", 414 | "Iter: 84 | Cost: 0.0359658 \n", 415 | "Iter: 85 | Cost: 0.0357969 \n", 416 | "Iter: 86 | Cost: 0.0356235 \n", 417 | "Iter: 87 | Cost: 0.0354549 \n", 418 | "Iter: 88 | Cost: 0.0352980 \n", 419 | "Iter: 89 | Cost: 0.0351565 \n", 420 | "Iter: 90 | Cost: 0.0350306 \n", 421 | "Iter: 91 | Cost: 0.0349178 \n", 422 | "Iter: 92 | Cost: 0.0348135 \n", 423 | "Iter: 93 | Cost: 0.0347126 \n", 424 | "Iter: 94 | Cost: 0.0346103 \n", 425 | "Iter: 95 | Cost: 0.0345030 \n", 426 | "Iter: 96 | Cost: 0.0343890 \n", 427 | "Iter: 97 | Cost: 0.0342684 \n", 428 | "Iter: 98 | Cost: 0.0341428 \n", 429 | "Iter: 99 | Cost: 0.0340147 \n", 430 | "Iter: 100 | Cost: 0.0338870 \n" 431 | ] 432 | } 433 | ], 434 | "source": [ 435 | "opt = AdamOptimizer(0.05, beta1=0.9, beta2=0.999)\n", 436 | "\n", 437 | "var = var_init\n", 438 | "for it in range(100):\n", 439 | " var = opt.step(lambda v: cost(v, X, Y), var)\n", 440 | " print(\"Iter: {:5d} | Cost: {:0.7f} \".format(it + 1, cost(var, X, Y)))" 441 | ] 442 | }, 443 | { 444 | "cell_type": "markdown", 445 | "metadata": {}, 446 | "source": [ 447 | "Finally, we collect the predictions of the trained model for 50 values\n", 448 | "in the range $[-1,1]$:" 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": 14, 454 | "metadata": {}, 455 | "outputs": [], 456 | "source": [ 457 | "x_pred = np.linspace(-1, 1, 50)\n", 458 | "predictions = [quantum_neural_net(var, x=x_) for x_ in x_pred]" 459 | ] 460 | }, 461 | { 462 | "cell_type": "markdown", 463 | "metadata": {}, 464 | "source": [ 465 | "and plot the shape of the function that the model has “learned” from\n", 466 | "the noisy data (red dots)." 467 | ] 468 | }, 469 | { 470 | "cell_type": "code", 471 | "execution_count": 15, 472 | "metadata": {}, 473 | "outputs": [ 474 | { 475 | "data": { 476 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEICAYAAABBBrPDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAf2klEQVR4nO3dfZBcV3nn8e9P47fRgpFtybY09kgmKxQcnEUwcUFEUsY2K8dF2YoDWbOyEYsdFWFdtVu7KMilFJUiKyxQZZPKwlZQeLOFwmuMUIJBGBtvdtmY9RgBwnKEhdcvGnkt2SAD5QnY0rN/dLfUat2+/X7v7b6/T9XU9MvVzKM7t/vpc85zzlFEYGZm1sycvAMwM7Nic6IwM7NUThRmZpbKicLMzFI5UZiZWSonCjMzS5VropB0laS9kvZJWt/kmN+XtEfSQ5L+JusYzczKTnnNo5A0BvwQeBOwH3gAeFtE7Kk7ZinweeDyiPiJpHMj4mDaz50/f34sWbJkcIGbmY2gBx988JmIWJD03ClZB1PnUmBfRDwKIOmzwLXAnrpj/gD4SET8BKBVkgBYsmQJ09PTAwjXzGx0SXq82XN5dj1NAE/W3d9ffazeK4BXSPqWpPslXZVZdGZmBuTbolDCY439YKcAS4HLgAuA/ynpVRFx+IQfJK0F1gJMTk72P1IzsxLLs0WxH7iw7v4FwIGEY74cES9ExP8F9lJJHCeIiC0RMRURUwsWJHaxmZlZl/JMFA8ASyVdJOk04HpgR8Mx24E3AkiaT6Ur6tFMozQzK7ncEkVEvAjcAuwEHgY+HxEPSXq/pGuqh+0EnpW0B/gmsC4ins0nYjOzcsqtPHZQpqamwlVPZmadkfRgREwlPeeZ2WZmlsqJwszMUuVZHmtmXdi+a4bNO/dy4PAsi+aNs27lMlYtb5yCZNY/ThRmQ2T7rhluvXM3sy8cAWDm8Cy33rkbwMnCBsZdT2ZDZPPOvceSRM3sC0fYvHNvThFZGbhFYTZEDhye7ehxG31ZdEW6RWE2RBbNG+/ocRttta7ImcOzBMe7Irfvmunr73GiMBsi61YuY/zUsRMeGz91jHUrl+UUkeUpq65Idz2ZDZFal4Krngyy64p0ojAbMquWTzgxGFDpcpxJSAr97op015OZ2ZDKqivSLYoqT2KyIvH1aO3IqivSiQJPYrJi8fVonciiK9JdT3gSkxWLr0crGicKPInJisXXoxWNEwWexGTF4uvRisaJAk9ismLx9WhF48FsPInJisXXoxWNt0I160Kr8lWXt1o/ZXE9pW2F6haFWYdala+6vNX6qQjXk8cozDrUqnzV5a3WT0W4npwozDrUqnzV5a3WT0W4npwozDrUqnzV5a3WT0W4npwozDrUqnzV5a3WT0W4nnJNFJKukrRX0j5J61OOe4ukkJQ4Im+WpVXLJ7jtukuYmDeOgIl549x23SXHBhZbPW/WiSJcT7mVx0oaA34IvAnYDzwAvC0i9jQc91LgK8BpwC0RkVr76vJYM7POFbU89lJgX0Q8CiDps8C1wJ6G4/4U+BDwnmzDMxscz7OwYZJn19ME8GTd/f3Vx46RtBy4MCL+PsvAzAapVhc/c3iW4Hhd/PZdM3mHZpYoz0ShhMeO9YNJmgP8OfCfW/4gaa2kaUnThw4d6mOIZv1XhLp4s07kmSj2AxfW3b8AOFB3/6XAq4D7JD0GvA7YkTSgHRFbImIqIqYWLFgwwJDNeleEunizTuSZKB4Alkq6SNJpwPXAjtqTEfFcRMyPiCURsQS4H7im1WC2WdEVoS7erBO5DWZHxIuSbgF2AmPAJyLiIUnvB6YjYkf6TygWD05au9atXHbC2j3geRZlV/T3j1wXBYyIu4C7Gh57X5NjL8sipmbS/pBFWLTLOpfXi9PLiFu9YXj/8DLjbWj8Q0LlE2Bt0suKTfcyk9C/PDFvnG+tv7yvsVh/tPqbmmWlKO8fafMovIRHG1pVqXhwcvi48siKYhjeP5wo2tDqD+nByeEzDC9OK4dheP9womhDqz9kERbtss4Mw4vTymEY3j+cKNrQ6g9ZhEW7rDPD8OK0chiG9w8PZrep6OVr1jn/Tc2OSxvMdqIwM7PCrh5rVf5ka2ZF5kSRs2GYbGNm5ebB7Jy5nt/Mis4tipy5nt/6zV2Z1m9OFBlp9uJdNG88cfq+6/mtG+7KtEFw11MG0nY0cz2/9VM7XZnbd82wYtO9XLT+K6zYdK931rOWnCgykPbiHYbJNpaDbdtgyRKYMwfmz698zZlTeWzbtqb/rFVXprdhtW646ykDrV68q5ZPODGU3bZtsGEDPPEEnH02/Oxn8MtfVp579tnjxz3+ONx4I9xwAyxeDBs3wurVx55u1ZXZ6kOLWRK3KDLgdYUsUa3VIFXe/B9/HCIqiaGWJJLUJsnWkoZ0rKXRqivTxRPWDSeKDHgcwo5JSg5w/M2/U/VJY+1aVu25L7Ur0x9arBvuesqAdzQzoJIk1q6F55+v3O/38jnPPw833MCqxYtZtXEjrF990iHehtW64bWezLKyZMnxFsSgzZ0LW7acMH5R43kWlsSLApp1qK9vprWB6k6SxKmnwplnwo9/XBnchsrYhdR+S2TxYnjssY7DtXLyVqhmHehrCWmtu6mdJCFVvi9eDJ/8JDzzDBw9Wvn+zDOVBLF1a+X5+uObefzxtkpqzVpxojBr0Jf1t2qD1jfccHxMIkl9cti6tZIMHnssscsIqDz+2GMnJ41mIo4NdDtZWLecKMwa9FxC2m4rot3k0EwtaXz605UxiTTPP1/p/jLrgquezBr0vP7Whg3prQjo7/hBLcHUJuw1G8N44on+/D4rnVxbFJKukrRX0j5J6xOe/0+S9kj6vqR7JLVoZ5v1rut5L7XuplYtiblzKzOq+6nWujh6tHl3VITHK6wruSUKSWPAR4DfAS4G3ibp4obDdgFTEfHrwBeBD2UbpZVRV+tvddLd1KRstW82bmzeFeXxCutCbuWxkl4P/ElErKzevxUgIm5rcvxy4MMRsSLt57o81nLRqiWRMq9hIFqV5Lp01hoUtTx2Aniy7v7+6mPN3AR8daARmXUrrf8/i1ZEo1pXVLMSWo9XWAfyTBRJV3Bi80bSDcAUsLnJ82slTUuaPnToUB9DNEtRvxT4nCYvpdon9yyTRL3JyeTHPV5hHcgzUewHLqy7fwFwoPEgSVcCG4BrIuIXST8oIrZExFRETC1YsGAgwZqdoH5MIgKOHDn5mEEMWnfK4xXWB3kmigeApZIuknQacD2wo/6A6rjER6kkiYM5xGhDbKA7uTUrgR0bq3T35NHdlGT16koczSqhPL/C2pBbooiIF4FbgJ3Aw8DnI+IhSe+XdE31sM3AS4AvSPqupB1NfpzZCQa2k1urEtijRytfeXY3NfJ4hfUo13kUEXFXRLwiIn4lIjZWH3tfROyo3r4yIs6LiFdXv65J/4lmFX1ZhqNROyWwzcYEisDjFdYlL+FhI2kgO7m1mnFdhDGJNB6vsC45UdhIGshObkUrge2UxyusS04UNpL6uv1sbVyi2eTUvEtgO+HxCuuCFwW0kdS37Wcbty9tVPTupmYmJ5PHWoo8xmK5caKwkbVq+UTvW3ymjUssXlxJEsPQkmi0cePJCXBYk54NnLuezNI064qRhqe7KUn9eIUE55wD4+Nw442ugLKTOFGYJWk1LjEKXTS18YqtW2F2trInt3fEswROFGaNWs2XGLUumqTuNVdAWR0nCrNGrcYlil4G26lm3WuugLIqD2abNWo1LjFqXAFlLbhFYVZThnGJJEkztkete8164kRhBuUbl6jnCihrwYnCDMo3LtHIFVCWIrc9swfFe2ZbV+bMSe5ykirLhpdFsyXUvcf2yCvqntlmxdFs/GFUxyWacQWUJXCisHKr34iocaG8UR6XaMYJ0xI4UVh5NQ5gRxxPFmUYl0jiCihL4ERh5ZU0gB0xXMuG91tjBdTixbBmTeVczZnjKqiS8mC2lZcHsFtLWmZ97txytrZGnAezzWpqYxJz5lS+krg//jivA2V4CQ8rk8ZPx0eOnHyM++NP5Coowy0KK5Nmk+rGxo73x7tL5USugjLcorAyafYp+OhRj0k0453wDLcorAzKuthfPyRVQbnVVTq5JgpJV0naK2mfpPUJz58u6XPV578taUn2UdpQK/Nif/1SWwfq6NHKuXKpbOnkligkjQEfAX4HuBh4m6SLGw67CfhJRPxL4M+BD2YbpQ29si/210/1SdcLBpZKni2KS4F9EfFoRPwS+CxwbcMx1wK3V29/EbhCalxnwSxFq02InCTa51LZ0sozUUwAT9bd3199LPGYiHgReA44p/EHSVoraVrS9KFDhwYUrg0lV+30j0tlSyvPRJHUMmgcbWznGCJiS0RMRcTUggUL+hKcDTkv9td/Trql1VaikHSupN+V9O8lvVPSpZJ6TTL7gQvr7l8AHGh2jKRTgJcBP+7x99qo82J/g+EFA0srdR6FpDcC64GzgV3AQeAMYBXwK5K+CPxZRPy0i9/9ALBU0kXADHA98G8bjtkBrAH+EXgLcG+M2uJU1n+tFvuz7tSS64YNle6myclKknDSHXmpiwJK2gz8t4g4qROy+gn/zcBYRPxtV79cuhr4C2AM+EREbJT0fmA6InZIOgPYCiyn0pK4PiIeTfuZo7go4PZdM2zeuZcDh2dZNG+cdSuXsWp543COHePF/nrS9vW2bZuTxghJWxTQq8cW3PZdM9x6525mXzi+LtH4qWPcdt0lThaNam9czeZMuEXRUtvXm1eVHTk9rx4raaukl9XdXyLpnn4FaM1t3rn3hBctwOwLR9i8c29OERWUJ9b1RdvXm0tlS6XdAen/BXxb0tWS/gD4OpUuIxuwA4dnO3q8tDyxri/avt5cKlsqbS0KGBEflfQQ8E3gGWB5RPy/gUZmACyaN85Mwot30bzxHKIpsFYT66wtbV9vk5PJrTeXyo6kdruebgQ+Abwd+BRwl6R/NcC4rGrdymWMnzp2wmPjp46xbuWynCIqGC/411dtX28ulS2VdpcZ/z3gDRFxEPiMpC9RSRjLBxWYVdQGEF31lCBpQLWe37g61vb15lLZUum66knSadU1mgpl1KqeLEVt5nWSxYv9xmWZGYUS9q6rniT9saSzk56LiF9KulzSm/sRpFmnwgv+FUf9XuQlW368VlI8c3iWAGYOz3LrnbvZvmsm79D6plXX027g7yT9M/Ad4BCVmdlLgVcD3wA+MNAIzRpt28bz697LuMcliqGxC7C2/DiUIlmnlRTXWhXD3uJolSjeEhErJP0RleU7FgI/BT4NrI0I12hatqpvSnObjEvMnno64x6XGJjEN7y0ORUlSBStSoobJzHWWhzA0CSLVlVPr5W0GFhNZd2ljwJ3UFmnyfWZlr0m8yUC2H/mAtavvKUUb055aNbF0rQLsCRzKpqVqtceH4VJs60SxV8BXwN+FZiu+3qw+t0sW03efALxhj/8JNMrrs44oPJo9ob39MuaLO1fki7AViXFozBpNjVRRMRfRsQrqSzY9/K6r4si4uUZxWhlVz9QOif5kj1w5nzPLxmwZm9st73hxlLPqVi1fILbrruEiXnjCJiYN37C2litWhzDoN2Z2X846EDMEjUOlB45ctIhz59yOh+76mYvlDhgzWZtT6+4Gq5fXuo5FauWTzS99tatXJa40OIwfajJc4c7s9aareE0NlYpg128mLmf+jh/8rkPOEkMWGoXy+rVlZLko0crSWLDhlKWyiZp1eIYBu3OzDbLVqslw48e9d4SGWtr1nbJS2WbSWtxDAPvR2HF02ppDvDeEkXVbLa8/16F1/N+FGaZSlsyHEo1UDp0Sl4qO6qcKKx40t5UvLdEsTUriS1JqeyocqKw4mi1ZHit+8JJori8/PhIcqKwYvBWpqNh9epKi2/x4mNVaW4BDj8PZlsxeMlws1x5MNuKq9bd1CxJeMnw4Vbi5cdHiedRWH7aKYP1IOjw8pyKkeEWheXHZbCjLW35cRsquSQKSWdLulvSI9XvZyUc82pJ/yjpIUnfl/Rv8ojVBqBVdxN4EHQUeE7FyMirRbEeuCcilgL3VO83eh54e0T8GnAV8BeS5mUYow1Cq+omcBnsqPCcipGRV6K4Fri9evt2YFXjARHxw4h4pHr7AJUd9posfG9Dw91N5eE5FSMjr0RxXkQ8BVD9fm7awZIuBU4DftTk+bWSpiVNHzp0qO/BWh+4u6l8PKdiZAwsUUj6hqQfJHxd2+HPWQhsBf5dRCQuFxoRWyJiKiKmFixwo6Nw3N1UXvXLj9cWBXS57NAZWHlsRFzZ7DlJT0taGBFPVRPBwSbHnQl8BfjjiLh/QKHaINSWCX/iicqbQsKGQ8e4O6IcXC47tPLqetoBrKneXgN8ufEASacBXwLuiIgvZBib9aq+BRGRniTcHVEeLpcdWnlNuNsEfF7STcATwFsBJE0B74qIm4HfB34bOEfSO6r/7h0R8d0c4rV2tNpsqJH3KCgXl8sOrVwSRUQ8C1yR8Pg0cHP19qeBT2ccmnWqPjlIzVd+beTupvKZnEz+EOFy2cLzzGzrXuMgdaskUbfPtbubSsjlskPLicK612pORL25c+H2249XvzhJlI/LZYeWE4V1r92+Zb8hWE19uezGjZUPGy6VLTyvHmvda9bnXDN3rhOEJXOp7FBxi8K6l9TnLFW+uxVhaYasVHb7rhlWbLqXi9Z/hRWb7mX7rpm8Q8qUWxTWvVoSqE2sm5zs605023fNsHnnXg4cnmXRvHHWrVzGquUTffnZlrMhKpXdvmuGW+/czewLlflAM4dnufXO3QCluR7dorDeNC7R0Mckceudu5k5PEtw/MVZtk9yI2uIVpbdvHPvsSRRM/vCETbv3JtTRNlzohgBo9gs9otzxA1RqeyBw7MdPT6KnCiG3Kh+8vaLc8QNUansonnjHT0+ipwohtyofvL2i7MEhqRUdt3KZYyfOnbCY+OnjrFu5bKcIsqeB7OH3Kh+8l63ctkJA4hQvhdnaRSkVLZZ8URtwLrMhRVOFENu0bxxZhKSwrB/8vaLs0TSSmUzShStKpvqE0YZOVEMuVH+5F32F2dpFKBUNq0L19egxyiG3qrlE9x23SVMzBtHwMS8cW677hJf3DY8ClAqO6pduP3iFsUI8CdvG2obN544RgGZl8qOahduv7hFYWb5aiyVPeccGB+HG2/MrALKlU3pnCjMLH+1UtmtW2F2Fp59trK/Sa0CasDJwl246RTt7kg2JKampmJ6ejrvMMwsQcv1u5YsSV6R2NvmDpykByNiKuk5j1GYWSbaWlyvABVQdjJ3PZlZJtpaRaAAFVB2MicKM8tEWyWoKYsFjuLil8PCicLMMtHW+l1NKqDixhv5jTe+htd+666RWvxyWDhRmFkm2i5BTaiAUgQTzx1k09c+zDUPfRMYjcUvh0UuiULS2ZLulvRI9ftZKceeKWlG0oezjNHM+qvjEtSENaDmvvgL/ugf7jh23zOns5FX1dN64J6I2CRpffX+e5sc+6fA/8gsMjMbmI5WEWhS6bTop88cv93BzGlvrdu9vBLFtcBl1du3A/eRkCgkvRY4D/gakFjfa635BWJDaXIycU7FgTPnA53NnPa+173Ja4zivIh4CqD6/dzGAyTNAf4MWJdxbCNlVHfAsxJIqIA6Ckz89BD3f/Sd3HHGvrbf5Ed1g6+sDKxFIekbwPkJT21o80e8G7grIp6U1Op3rQXWAky63voEvS6f7NaIdaKv10ttL4oNGyotC4k51ZUkzj98kPM/8F5YclZbe1Z4ddjeDCxRRMSVzZ6T9LSkhRHxlKSFwMGEw14P/JakdwMvAU6T9POIWJ/wu7YAW6CyhEd//gejoZcXiJvr1omBXC+rV1e+kpb26GBzI68O25u8up52AGuqt9cAX248ICJWR8RkRCwB3gPckZQkLF0ve0+7uW6dGOj10uPSHl4dtjd5JYpNwJskPQK8qXofSVOSPpZTTCOplxeIm+vWiYFeLz0u7eHVYXuTS9VTRDwLXJHw+DRwc8LjnwI+NfDARlAve0+7uW6dGOj10ofNjbzBV/e8emwJdPsCGeX9uK3/+nG9NB0Mrx/YfuKJSkti48YTxidceDE43o/CUl9gfvFZJ3q5XhoHw6GSaNrpIurl31pF2n4UThQl5xeYFcWKTfcmdl1NzBvnW+svH9i/tYq0ROFFAUvOlU1WFL0MhrvwYrCcKErOLzAril5KuXv5t9aaE0XJ+QVmRdFLKbfnSQyWE0XJ+QVmRdHLXAfPkxgsD2abK5vMLHUw2/MozBORzCyVu57MzCyVE4WZmaVyojAzs1ROFGZmlsqJwszMUjlRmJlZKicKMzNL5XkU1hNP1jMbfU4U1rXGJcpnDs9y6527AZwszEaIu56sa16i3Kwc3KKwrvVjiXJ3XZkVn1sU1rVelyivdV3NHJ4lON51tX3XTB+jNLNeOVFY13pdotxdV2bDwV1P1rVaF1G3XUfeXc9sODhRWE96WaJ80bxxZhKSgnfXMyuWXLqeJJ0t6W5Jj1S/n9XkuElJX5f0sKQ9kpZkG6kNknfXMxsOeY1RrAfuiYilwD3V+0nuADZHxCuBS4GDGcVnGfD2lWbDIa+up2uBy6q3bwfuA95bf4Cki4FTIuJugIj4eYbxWUa8u55Z8eXVojgvIp4CqH4/N+GYVwCHJd0paZekzZLGEo4zM7MBGliLQtI3gPMTntrQ5o84BfgtYDnwBPA54B3AxxN+11pgLcDk5GQX0ZqZWTMDSxQRcWWz5yQ9LWlhRDwlaSHJYw/7gV0R8Wj132wHXkdCooiILcAWgKmpqehH/GZmVpFX19MOYE319hrgywnHPACcJWlB9f7lwJ4MYjMzszp5DWZvAj4v6SYq3UpvBZA0BbwrIm6OiCOS3gPcI0nAg8Bf5xSvdclrOZkNv1wSRUQ8C1yR8Pg0cHPd/buBX88wNOsjL0NuNhq81pMNjNdyMhsNThQ2MF7LyWw0OFHYwPS6DLmZFYMThQ2M13IyGw1ePdYGptdlyM2sGJwobKC8lpPZ8HPXk5mZpXKiMDOzVE4UZmaWyonCzMxSOVGYmVkqJwozM0vlRGFmZqkUMVr7/Eg6BDzew4+YDzzTp3D6zbF1x7F1p6ixFTUuGO7YFkfEgqQnRi5R9ErSdERM5R1HEsfWHcfWnaLGVtS4YHRjc9eTmZmlcqIwM7NUThQn25J3ACkcW3ccW3eKGltR44IRjc1jFGZmlsotCjMzS1X6RCFps6R/kvR9SV+SNK/JcVdJ2itpn6T1GcX2VkkPSToqqWm1gqTHJO2W9F1J0wWLLY/zdrakuyU9Uv1+VpPjjlTP2Xcl7RhgPKnnQNLpkj5Xff7bkpYMKpYuYnuHpEN15+nmDGP7hKSDkn7Q5HlJ+stq7N+X9JqCxHWZpOfqztn7soir+rsvlPRNSQ9XX5//IeGYzs9bRJT6C/jXwCnV2x8EPphwzBjwI+DlwGnA94CLM4jtlcAy4D5gKuW4x4D5GZ+3lrHleN4+BKyv3l6f9DetPvfzDGJpeQ6AdwN/Vb19PfC5jP6G7cT2DuDDWV5bdb/7t4HXAD9o8vzVwFcBAa8Dvl2QuC4D/j6nc7YQeE319kuBHyb8TTs+b6VvUUTE1yPixerd+4ELEg67FNgXEY9GxC+BzwLXZhDbwxGxd9C/pxttxpbLeav+jturt28HVmXwO5tp5xzUx/tF4ApJKkhsuYmIfwB+nHLItcAdUXE/ME/SwgLElZuIeCoivlO9/TPgYaBx57COz1vpE0WDd1LJtI0mgCfr7u/n5JOfpwC+LulBSWvzDqZOXuftvIh4CiovHODcJsedIWla0v2SBpVM2jkHx46pfmh5DjhnQPF0GhvA71W7KL4o6cIM4mpXkV+Xr5f0PUlflfRreQRQ7cJcDny74amOz1sptkKV9A3g/ISnNkTEl6vHbABeBLYl/YiEx/pSLtZObG1YEREHJJ0L3C3pn6qfevKOLZfz1sGPmayet5cD90raHRE/6kd8ddo5BwM7Ty2083v/DvhMRPxC0ruotHwuH3hk7cnrvLXyHSrLYfxc0tXAdmBplgFIegnwt8B/jIifNj6d8E9Sz1spEkVEXJn2vKQ1wJuBK6LaiddgP1D/SeoC4EAWsbX5Mw5Uvx+U9CUqXQo9J4o+xJbLeZP0tKSFEfFUtUl9sMnPqJ23RyXdR+XTV78TRTvnoHbMfkmnAC8jm66NlrFFxLN1d/+ayjheUQzs+upF/RtzRNwl6b9Lmh8RmawBJelUKkliW0TcmXBIx+et9F1Pkq4C3gtcExHPNznsAWCppIsknUZlwHFgVTKdkPQvJL20dpvK4HxiNUYO8jpvO4A11dtrgJNaP5LOknR69fZ8YAWwZwCxtHMO6uN9C3Bvkw8smcfW0Hd9DZU+76LYAby9WsXzOuC5WpdjniSdXxtjknQplffZZ9P/Vd9+t4CPAw9HxH9tcljn5y2PkfkifQH7qPTXfbf6Vas+WQTcVXfc1VQqCH5Epesli9h+l0r2/wXwNLCzMTYqFSvfq349VKTYcjxv5wD3AI9Uv59dfXwK+Fj19m8Cu6vnbTdw0wDjOekcAO+n8uEE4AzgC9Vr8f8AL8/iPLUZ223V6+p7wDeBX80wts8ATwEvVK+1m4B3Ae+qPi/gI9XYd5NSGZhxXLfUnbP7gd/M8Jy9gUo30vfr3tOu7vW8eWa2mZmlKn3Xk5mZpXOiMDOzVE4UZmaWyonCzMxSOVGYmVkqJwozM0vlRGFmZqmcKMwGTNJvVBfVO6M6k/4hSa/KOy6zdnnCnVkGJP0XKjOwx4H9EXFbziGZtc2JwiwD1bWUHgD+mcqSDkdyDsmsbe56MsvG2cBLqOw6dkbOsZh1xC0Kswyosif3Z4GLgIURcUvOIZm1rRT7UZjlSdLbgRcj4m8kjQH/W9LlEXFv3rGZtcMtCjMzS+UxCjMzS+VEYWZmqZwozMwslROFmZmlcqIwM7NUThRmZpbKicLMzFI5UZiZWar/D4RxwP7KcOgJAAAAAElFTkSuQmCC\n", 477 | "text/plain": [ 478 | "
" 479 | ] 480 | }, 481 | "metadata": { 482 | "needs_background": "light" 483 | }, 484 | "output_type": "display_data" 485 | } 486 | ], 487 | "source": [ 488 | "plt.figure()\n", 489 | "plt.scatter(X, Y)\n", 490 | "plt.scatter(x_pred, predictions, color=\"red\")\n", 491 | "plt.xlabel(\"x\")\n", 492 | "plt.ylabel(\"f(x)\")\n", 493 | "plt.tick_params(axis=\"both\", which=\"major\")\n", 494 | "plt.tick_params(axis=\"both\", which=\"minor\")\n", 495 | "plt.show()" 496 | ] 497 | }, 498 | { 499 | "cell_type": "markdown", 500 | "metadata": {}, 501 | "source": [ 502 | "Now we plot the shape of the function that the model has “learned” from\n", 503 | "the noisy data (red dots) for 100 values betw" 504 | ] 505 | }, 506 | { 507 | "cell_type": "code", 508 | "execution_count": 19, 509 | "metadata": {}, 510 | "outputs": [], 511 | "source": [ 512 | "x_pred = np.linspace(-2, 2, 100)\n", 513 | "predictions = [quantum_neural_net(var, x=x_) for x_ in x_pred]" 514 | ] 515 | }, 516 | { 517 | "cell_type": "code", 518 | "execution_count": 20, 519 | "metadata": {}, 520 | "outputs": [ 521 | { 522 | "data": { 523 | "image/png": "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\n", 524 | "text/plain": [ 525 | "
" 526 | ] 527 | }, 528 | "metadata": { 529 | "needs_background": "light" 530 | }, 531 | "output_type": "display_data" 532 | } 533 | ], 534 | "source": [ 535 | "plt.figure()\n", 536 | "plt.scatter(X, Y)\n", 537 | "plt.scatter(x_pred, predictions, color=\"red\")\n", 538 | "plt.xlabel(\"x\")\n", 539 | "plt.ylabel(\"f(x)\")\n", 540 | "plt.tick_params(axis=\"both\", which=\"major\")\n", 541 | "plt.tick_params(axis=\"both\", which=\"minor\")\n", 542 | "plt.show()" 543 | ] 544 | }, 545 | { 546 | "cell_type": "markdown", 547 | "metadata": {}, 548 | "source": [ 549 | "The model has learned to smooth the noisy cosine function.\n", 550 | "\n", 551 | "In fact, we can use PennyLane to look at typical functions that the\n", 552 | "model produces without being trained at all. The shape of these\n", 553 | "functions varies significantly with the variance hyperparameter for the\n", 554 | "weight initialization.\n", 555 | "\n", 556 | "Setting this hyperparameter to a small value produces almost linear\n", 557 | "functions, since all quantum gates in the variational circuit\n", 558 | "approximately perform the identity transformation in that case. Larger\n", 559 | "values produce smoothly oscillating functions with a period that depends\n", 560 | "on the number of layers used (generically, the more layers, the smaller\n", 561 | "the period)." 562 | ] 563 | }, 564 | { 565 | "cell_type": "code", 566 | "execution_count": 16, 567 | "metadata": {}, 568 | "outputs": [ 569 | { 570 | "data": { 571 | "image/png": "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\n", 572 | "text/plain": [ 573 | "
" 574 | ] 575 | }, 576 | "metadata": { 577 | "needs_background": "light" 578 | }, 579 | "output_type": "display_data" 580 | } 581 | ], 582 | "source": [ 583 | "variance = 1.0\n", 584 | "\n", 585 | "plt.figure()\n", 586 | "x_pred = np.linspace(-2, 2, 50)\n", 587 | "for i in range(7):\n", 588 | " rnd_var = variance * np.random.randn(num_layers, 7)\n", 589 | " predictions = [quantum_neural_net(rnd_var, x=x_) for x_ in x_pred]\n", 590 | " plt.plot(x_pred, predictions, color=\"black\")\n", 591 | "plt.xlabel(\"x\")\n", 592 | "plt.ylabel(\"f(x)\")\n", 593 | "plt.tick_params(axis=\"both\", which=\"major\")\n", 594 | "plt.tick_params(axis=\"both\", which=\"minor\")\n", 595 | "plt.show()" 596 | ] 597 | }, 598 | { 599 | "cell_type": "markdown", 600 | "metadata": {}, 601 | "source": [ 602 | "## References\n", 603 | "PennyLane \"Function Fitting with a Quantum Neural Network\" ```https://pennylane.ai/qml/app/quantum_neural_net.html```\n", 604 | "\n", 605 | "\"Generating and visualizing data from a sine wave in Python\" ```https://goelhardik.github.io/2016/05/25/sampling-sine-wave/```\n", 606 | "\n", 607 | "`Killoran et al. (2018) `\n", 608 | "\n", 609 | "\"adding noise to a signal in python\" ```https://stackoverflow.com/questions/14058340/adding-noise-to-a-signal-in-python```" 610 | ] 611 | }, 612 | { 613 | "cell_type": "code", 614 | "execution_count": null, 615 | "metadata": {}, 616 | "outputs": [], 617 | "source": [] 618 | } 619 | ], 620 | "metadata": { 621 | "kernelspec": { 622 | "display_name": "Python 3", 623 | "language": "python", 624 | "name": "python3" 625 | }, 626 | "language_info": { 627 | "codemirror_mode": { 628 | "name": "ipython", 629 | "version": 3 630 | }, 631 | "file_extension": ".py", 632 | "mimetype": "text/x-python", 633 | "name": "python", 634 | "nbconvert_exporter": "python", 635 | "pygments_lexer": "ipython3", 636 | "version": "3.7.3" 637 | } 638 | }, 639 | "nbformat": 4, 640 | "nbformat_minor": 4 641 | } 642 | -------------------------------------------------------------------------------- /quantum_neural_network_tutorial_sine.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Function Fitting with a Quantum Neural Network" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Using the example from Penny Lane of a variational circuit that learns a\n", 15 | "fit for a one-dimensional function, we generate several examples of functions with noise\n", 16 | "and train the quantum neural network to fit them. \n", 17 | "\n", 18 | "The variational circuit used is the continuous-variable quantum neural\n", 19 | "network model described in:\n", 20 | "\n", 21 | "`Killoran et al. (2018) `\n" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "# Import PennyLane, the wrapped version of NumPy provided by PennyLane,and an optimizer.\n", 31 | "import pennylane as qml\n", 32 | "from pennylane import numpy as np\n", 33 | "from pennylane.optimize import AdamOptimizer" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 2, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "# Other imports:\n", 43 | "# matplotlib.pyplot to plot and visualize the data\n", 44 | "# numpy to generate the mathematical function\n", 45 | "# pylab to help with interactive plots\n", 46 | "# pickle to dump the data into a file for future use\n", 47 | "import matplotlib.pyplot as plt\n", 48 | "import numpy as np\n", 49 | "import pylab\n", 50 | "import pickle" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "## Creating a Noisy Function for Sampling" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 3, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "Xlim = 5\n", 67 | "noise = np.random.normal(0,0.1,100) # generate noise to add to the function values (Y-values)\n", 68 | "# define functions\n", 69 | "X = np.arange(-Xlim, Xlim, 0.1)\n", 70 | "Y = np.sin(X)+noise" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "This will generate two lists 'X' and 'Y' with our X-axis and Y-axis data. We'll now dump the Y-axis data into our file for future use." 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 4, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [ 86 | "# write the data out to a file\n", 87 | "sinedata = open('sinedata.md', 'wb')\n", 88 | "pickle.dump(Y, sinedata)\n", 89 | "sinedata.close()" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "The above snippet writes the data of y into a file named sinedata.md. Pickle is specific to Python and it can be used to load the data into another Python script later. Now we plot some of the data:" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 5, 102 | "metadata": {}, 103 | "outputs": [ 104 | { 105 | "data": { 106 | "text/plain": [ 107 | "[]" 108 | ] 109 | }, 110 | "execution_count": 5, 111 | "metadata": {}, 112 | "output_type": "execute_result" 113 | }, 114 | { 115 | "data": { 116 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dd3zb13no/88BQIAYXCC4p0jJkqhhSZYlr8jbkZPUzmxsN8NpEydNkzTj3rycm/7a/nrT3jS+bZImznCcNs6oHaeNEyex4yVva1iyJFtbJCVxiHuTIAgCOPcPDJHiJgFiPe/XSy+RwBfEgQ08OnzOc56jtNYIIYRIfYZ4D0AIIcTykIAvhBBpQgK+EEKkCQn4QgiRJiTgCyFEmjDFewAzcblcurq6Ot7DEEKIpHLgwIFurXXBdPclbMCvrq5m//798R6GEEIkFaXUuZnuk5SOEEKkCQn4QgiRJiTgCyFEmpCAL4QQaUICvhBCpAkJ+EIIkSYk4AshRJqQgC9EGhn3B3h4XxNeXyDeQxFxIAFfiDSyu6GHr/z6LR472BLvoYg4kIAvRBppGxgF4LGDrXEeiYgHCfhCpJH2gTEA9jT20to/GufRiOUmAV+INNI+6MFiCn7sHz90Ps6jEctNAr4QaaRj0MPKQgdbKnN57GALcqZ1epGAL0QaaR/wUJydyXs2l3GqY5jjbUPxHpJYRhLwhUgjHYMeinIyeefGUkwGxW8OyeJtOpGAL0SaGPP56RnxUpydidNu5rrVBfz2UCv+gKR10oUEfCHSROdgsEKnODsTgHdvLqNjcIzXz/bGc1hiGUnAFyJNdAx6ACjKCQb8bSucAJxslzx+upCAL0SaaA8F/PAMv8BhITPDQHOvO57DEstIAr4QaaJ9YHLAV0pRnmejuU8CfrqQgC9EmugY9JCZYSDbaorcVpFnpblXdtymi5QP+Of7R/GM++M9DCHirn1wjOLsTJRSkdsqnTaae92yAStNpHTAHx7zcdO/vsit336ZQ8398R6OEHHVPjBKUSidE1bhtDE05mNgdHzWx3p9AX6x9xzX3fc83911OpbDFDGU0gF//9le3F4/XUNjvO/7r/HtZ0/j80sfcJGe2gc9FOdMDvjleTaAGdM6LX1u/v2VM1x33/N89bEjnO/38Phh6cGTrExzXzI3pdS/A+8COrXW66e5XwHfBt4BuIG7tdZvROO5Z7P3TC8mg+LZL17L1588zjefPcVPd5/llnVF7FxfQm2BHX9A4w9oSnOtZGYYYz0kIeJCa01HKKUzUYXTCkBzn5sN5TmR2+9/vp7fHmrlVMcwAJsrc/k/79vIkdYB7nvqJL0jXpx28/K9ABEVUQn4wE+A7wI/neH+W4FVoT/bge+H/o6pvY09XFqRS3FOJt+6YzO3bSrl12+08vih8zy8r3nStTfXFfGjj2yN9ZCEWDKvL4AvEMBmnv/Ht889jtcXmDalA0wqzWwf8HDfUydZX5bNV9+xluvXFFJbYEcphcMSnBTtO9PDzvUlUXg1YjlFJeBrrV9SSlXPcsntwE91cGVoj1IqVylVorVui8bzT8ft9fFmywD37KiJ3HbDmiJuWFOEZ9zPaw3ddA95MRoUTx1t54VTXYx6/VjNMssXie3//91RHjvYyhdvvoS7r6rGZJw7MxspybwopZOdmUGONWNSaeZbrQPB57ltHZdVOSddv6Esl8wMA3saeyXgJ6FozfDnUgZMnFK3hG6bFPCVUvcA9wBUVlYu6QkPnOvDF9Bsr8mfcl9mhpEb1hRFvi/MtvD0sQ52N3ZPul2IRDPuD/C7w+cxGhRf+8NxfnOola+9ewObKnJnfVxkl+1FM3wIV+pcyOG/1TqAQUFdSc6Ua80mA5dV5bHvjLRjSEbLtWirprltSh2Y1voBrfVWrfXWgoKCJT3h3sZejAbF1qq8Oa/dtsKJNcPICye7lvScQsTansYeBj0+/uUDl3L/XVvoGBzj3fe/yh0P7Obpo+0zNkKL7LLNmRrwK5zWSSmdt1r6WVWYNeNvu9uq8znePsiAe/bKHpF4livgtwAVE74vB2K61L+nsYcNZTnYLXP/EmMxGbl6ZT67TnROqkf++8eP8v7vvzbrYw829fHpXxxgzCe1/iL2/nikHZvZyI5LCnjnxhKe+9K13HvrGpp63NzzswPc/M0Xp+2N0z7gQSkozLJMua8iz0ZL3yiBgEZrzVutg6wvmzq7D9te40RrpOlaElqugP848BEVdAUwEMv8/ajXz+GWfrbXOOe+OOS61YW09I3S0DUCBDds/WLvOfaf66O+c3jax2it+cc/HOeJt9rZ0yhvfhFb/oDmqaMdXL+6MFJRlp2ZwaeureWlL1/P/XdtYcjj473fe5XnjndMemzHoId8u4WMafL95U4bXn+AzqExOgbH6B4eY0NZ9ozj2FSRi9lkYO+Znui+QBFzUQn4SqmHgd3AaqVUi1LqL5RSn1JKfSp0yRNAI1AP/Aj4dDSedyYHm/oY92uumCZ/P5PrVgdTSC+c7ATgx6+cIfzb8VNH26d9zN4zvew/1zfpcULEysGmPrqHx3j7+uIp95mMBt65sYTHP3M1NQUOPv7T/TzwUkPk/mAN/tTZPQTbK0CwNPPNluAGxQ3lM68JZGYY2VSRy17J4yedqAR8rfWdWusSrXWG1rpca/1jrfUPtNY/CN2vtdZ/pbWu1Vpv0Frvj8bzzmRPYw8Gxbzy92HleTZWFTp44WQX/W4vD+9r4rZLS7m0IpenZwj49z9fj8th5sqafMn/i5j745F2zEYD16+eeX2rJMfKo5+8knesL+GfnjjBM8eCM/3w0YbTmViaeSSyYDvzDB9g+wonR1oHGB7zLfLViHhIyZ22e870sr4sh6zMjAU97rrVBew708sPXmzE7fXzyWtr2LmumMMtA7T2T96JeLi5n5dPd/MX19Rw64ZiznSPcKZ7JJovQ4gIrTV/PNrONatcc76vrWYj37pjE5cUOfi73x5hZMwXPNpwhoBflmtFKWjqdfNW68CsC7Zh21fkE9DB3ewieaRcwPeM+znU3L+gdE7Y9asL8foD/PClBm5YU8ia4mzevi5YpnnxLP+7z9eTY83gQ1dUct0lhYCkdUTsHD0/SEvfKDvXTU3nTCfDaOCf3rOB8wMevvHHE/S5x2ec4WdmGCnKyqS5d5S3WgdmXbAN21KVi8mgJK2TZFIu4A96xrmlrojrLll4WefWaid2sxGt4S+vqwWgpsDBJUUO/njkQsA/0T7IM8c6uPuqarIyM6jMt1FbYOd5SeuIGHnqaDsGBTfVzX+fyNZqJ3dcXsFDu88BF066mk6F08rrZ3vpHvaysXzugG8zm9hQnsPrEvCTSsoF/MKsTL571xauWula8GPNJgN/cmkpOy4p4PLqCxU+O9cV8/rZXnqGx2jtH+WTPztAVqaJj11dHbnm+tWF7Gnswe2VnKaIvoNN/awrzVlw/5p7b11DfugxM83wIVia2RSqxZ/PDB9gS2Ueb7YO4PVJQ8JkkXIBf6m+/r6NPPSxyyfddsu6YgIafvLaWT74w930jnj56Z9vI9d24cN3/ZpCvL4AuxukVE1EX9fQ2LSbpuaSazPzd7etw2wysLLQMeN15aGF2/ks2IZtqczD6wtwrG1wweMS8SEBfxoTD4gAWFeaTXmele/sqmfI4+M/P34FmysnVwBtrc7DbjbyvOTxRQx0D49RMM2mqfm47dJSjvz92ynNtc54Tbg0cz4LtmFbqoKlm2+ESpNF4pOAPw9KKT64tYKCLAsPf+KKSW1kwywmI1etdPH8iS45PUhE1bg/QK/bS4FjcQEfgunK2VSGZvjTvbdnUpJjpSQnkzeaJOAnCwn48/SZG1ay5ys3Ulc686+7115SQGv/aCQXKkQ09I540Rpci5zhz8eKAjtGg+KyBexdgWBa52DTzKfJnWwf4g9vxmxTvVggCfjzpJTCaJiuB9wFVfnBWVLn0NhyDEmkia7Q+2kpM/y5FGZl8tTn38afbq2Y++IJNlfm0to/GunGebF/fOI4X/jlIVnYTRAS8KMoL7SI2zvinXS72+vjC788NKkjoRDz1TUcCvgxnOEDrCzMmnNSc7Etod8IpsvjD4yO81p9N15/gFMdUxu6ieUnAT+KwiVzFwf8I62DPHawlX995lQ8hiWSXHiGP12ny3hbV5qN2WjgYPPUtM6uEx34Qg2pjoQOVRHxJQE/imYK+L0jwQ/sbw+1clbaL4hZjPsDjPsnpz/CAd8Vw5TOYllMRtaXZU87w3/yrXaKszPJspg4cl4CfiKQgB9FmRlGbGYjfRcF/O7hC99/74X65R6WSBLPn+jk8n98lq/9/tik27uHx3BYTAl7/OZ0G7DcXh8vnuri7euKWFeWzVutUqufCCTgR1mezUyve3LA7wkF/Du3VfLrN1olly8mGfcH+PqTJ/jYT16n3z3O4ZbJs+GuocXX4C+HLVVTN2C9cLKLMV+AnetLWF+aw/G2wSm/uYjlJwE/ypx287QpnRxrBp+5YSUGpfjBiw0zPFqko0/97AA/eLGBu7ZX8p7NZbT0TZ4QdA2NxbRCZ6kum2bh9o9H2nHazVxenceG8hy8vsCMBwmJ5SMBP8qcdvPUlM6Il3y7mZIcK+/fWs6v9rfQNjA6w08Q6aRj0MNzJzr59HW1/NN7NrCy0EH3sHdST6au4TFcWQvrobOcirIzKcu18syxDoY844z5/Ow60cktdUWYjAbWlQY3c8nCbfxJwI8yp31qSqd32Eu+I/iB/dSOWrz+gGxGEUDwsB6AnaFTrMrDp0/1XpgQdCf4DB/gzm0V7G7s4dr7XuCrjx1heMwXOZmrxmXHbjZKwE8AEvCjLM9mpm9kfNJtPSNjkQqeynwbZblWDk1TxibSz+6GHrIyTZFZ8MTTpyB4vsOgx5fQOXyAz9ywit/+1dWsKc7ivw60kGUxcXVtsGOtwaCoK83myHlZuI03U7wHkGqc9gyGx3yM+fxYTMGqit4RL1sntFveVJErAV8AsLuxh+0r8iMbniryQgE/lMfvXqZNV9FwaUUu//mJK3itoRuFmtS/Z31ZDo/sa8Yf0Ave3CWiR2b4Uea0Bz+Y4Vl+IKDpDeXwwzZV5NLSNxr5MIv01No/yrkeN1fWXjidzeUwY80wRlI6iVyDP5Oral2TXhPA+tIcRsf9NHbJwm08ScCPMqc9eN5ouFKnf3ScgGZSwL+0IthW9rDM8tNa+OyEqyYER6UUFU7rhBl+8H2UDDP82YS7cL4lefy4koAfZRf30+kJzeKdE2ZoG8pyMBqUpHXS3O6GHvJsGawuypp0e0WeLZLDjzROS/KAX+Oyk5lh4IhswIorCfhRFmmvEKrUCc/QXBNm+FazkdVFWRLw05jWmj2NPVxRk4/hopx2hTMY8LXWkYCfb0/ugG8yGqgryZZKnTiTgB9leaHAHq7FD8/08y/KwV4aWrgNBOSwlHTU3DtKa//opHROWHmelRGvnz73OF3DHnJtGXMeYJIMNpTlcOT8ACNjcu5zvCT/uyjB5FozUGpCSifUOO3iw6c3V+Qy5PHRKM3U0tJrDd0AUxY34cLpU829brqHlnbSVSK5bVMZbq+fH79yJt5DSVsS8KPMZDSQY82YkMP3ohTk2TImXbepUhZu09nuxh4KsizUFkw9WDxSi9/npmsJZ9kmmsuq8rilrogfvtggFWpxIgE/BpwTGqj1jIyRa83AZJz8n7q2wIHDYpI8fhrxjPvZ3dDDN585xfMnOrmyJh+lptakX9h8NZrwjdMW6ss71+DxBfjuLukaGw+y8SoG8ib00+kd8U7J3wMYDYoNZTkS8NOEZ9zPNf+8i+5hLwYFdaXZ3LOjZtprHRYTebYMmnrddA+PJVUN/lxWFjr4060V/GLvOT52dTVV+fZ4DymtyAw/BiZ2zOwe9k7J34dtqszleNsgnnH/cg5PxEHX0Bjdw14+fV0tB//2Fn7/2bexvixnxusrnDZOtg/i9vpTaoYP8IWbVmEyGLjvqZPxHkrakYAfA06beVIdvssxQ8CvyMUX0ByVHiMpry+U4ttSmUeONWOOq4MBP1yzniqLtmGF2ZncfXU1v3+zbUorcRFbEvBjIM9ups/tRetwW4XpP7CbQjtuJa2T+vrcwVYbefa5gz0EN195QweGpNoMH+Dy6mAP/bM9UqW2nCTgx4DTnsG4XzMwOk6fe3zGlE5RdiYuh4VjMsNPeeE1nVzb/PraVzitka9TKYcfVukM5u7PScBfVlEJ+EqpnUqpk0qpeqXUvdPcf7dSqkspdSj05+PReN5EFW6g1tAVfDPPlNIBWFuSxfE2CfipLpzSyZtvwA91zYTUnOFXOK0oBed65LjP5bTkgK+UMgL3A7cCdcCdSqm6aS79pdZ6U+jPg0t93kQWbqBW3zkU+n7mD2xdaTb1ncNy3meK63OPoxTzyt/DhdJMg5q6aS8VWExGSnOsEvCXWTRm+NuAeq11o9baCzwC3B6Fn5u0wrO40x3BVrD5s8zw60qy8foDNEjb2JTW7/aSY82Ydy/4stzgDDjfYUnZ/vGVTpukdJZZNAJ+GdA84fuW0G0Xe59S6k2l1H8ppSqm+0FKqXuUUvuVUvu7urqiMLT4CM/ITocObc6fZYa2tiQbQPL4Ka53xDvvdA6A2WSgJLTGk6qqXTaZ4S+zaAT86aYfF3cE+x1QrbXeCDwLPDTdD9JaP6C13qq13lpQUBCFocVHOODXhwP+LB/aGpcds8kgefwU1+8eJ9c2v3RO2NZqJxtnqdVPdpVOOz0jXoalmdqyicZO2xZg4oy9HDg/8QKtdc+Eb38E/HMUnjdhOSwmMoyK1v5RDCrYUG0mJqOB1UVZHG8bWsYRiuXW5/ZSnJ25oMf8252bYzSaxFCdH1ynONczEjnTV8RWNGb4rwOrlFIrlFJm4A7g8YkXKKVKJnx7G3A8Cs+bsJRSkV/fnXbzlH7nF1tbksWxtkG0llbJqSo4w0+9xdelqIwEfEnrLJclB3yttQ/4DPAUwUD+qNb6qFLqH5RSt4Uu+5xS6qhS6jDwOeDupT5vogundeZzcEVdSTa9I146h6SDYKoK5vAXltJJdeE+OhLwl09UmqdprZ8Anrjotr+d8PVXgK9E47mSxcQZ/lwiC7dtgxQt8Nd+kfg8435Gx/2Rw3FEkMNiwuUwS6XOMpKdtjHiDJVizlaSGbYmFPBl4TY19YfbKkhKZ4pgaabM8JeLBPwYcdrCKZ25P+Q51gzK86xSmpmiLuyylZTOxary7TLDX0YS8GMk/Ov7bCWZE60tyZYZfopaaB+ddFKVb6Nt0MOYT1qELwcJ+DHiDM3m5pPSgWDAP9M9Ir3xU9BCO2Wmk6p8G1oHT/cSsScBP0acoZn9fFI6EKzUCWg42S71+KkmnNJxygx/iguVOpLWWQ4S8GMkvKlkvke41U2o1BGppd8tKZ2ZVDmlFn85ScCPkY3luez9XzdGSi7nUp5nJdeWwetnemM8MrHcekfGsZuNmE3ycbuY027GYTHJDH+ZyDswhhZSU28wKG5cU8SzxzukVXKK6Xd7ZXY/A6UUVfk2zvUGZ/ha68git4g+CfgJZOf6YgY9PvY09sx9sUgafe6ZD7IXwYXbcz1ueobH+Mufv8FlX3uGt1oG4j2slCQBP4G8bZULm9nIk0fa4z0UEUW9i+iUmU6q8u0097p5+7deZteJTpRSPHmkLd7DSkkS8BNIZoaR69cU8vTRDvwBaaSWKvrdC+uFn25qXHZ8AU1BloXHP3s1l1fnsetEZ7yHlZIk4CeYneuK6R4e48C5vngPRURJnzROm9Vtm0r5wYe28Ju/uoo1xdncuKaIE+1DtPZLbX60ScBPMNevKcRsMvBHSeukBJ8/wKDHJ43TZmExGdm5vgSLyQgEPwOAzPJjQAJ+gnFYTOxY5eKpo+3SHz8F9I9K47SFqi2wU5VvY9fxjngPJeVIwE9Ab19XTGv/KG+1SqVCsruw6UpSOvOllOL61YW81tDDqFdajUSTBPwEdNPaIowGxV/+/A3u/o993Pvfb/L6WdmQlQxGxnzc+99v0j0cPMymT1ojL8qNawsZ8wV4raE73kNJKRLwE1Ce3czfvquOtSVZdA+P8ZtDrfzfp07Ge1hiHvad7eWR15t5/FDwWOfwJiIJ+AuzbYUTu9nIc5LHjyoJ+Anqo1dV8+BHL+f3n30b791SznE58zYptIR2jL5aH5yZRnrhS6fMBbGYjFyzysXzJzrlfR9FEvCTwNqSbAY9Ps4PeOI9FDGHplDA39PYw7g/ICmdJbhxTRFtAx4Oy67bqJGAnwTWFmcBcEI6aSa8cF/3Ea+fw8399Lm9mI0GbGZjnEeWfG5ZV0SeLYO/+c1beH3SXyoaJOAnATnzNnk09bq5rCoPpeCV+m76R4JtFZRS8R5a0sm1mfk/793AkdZBvrPrdLyHkxIk4CcBh8VEpdPG8TY5HCWRaa1p7nWzvjSbjWU5vFrfTa80TluSnetLeN+Wcu5/vl52n0eBBPwksbYkS2b4CW5gdJyhMR8VThtXr3RxsKmf1r5RqcFfor+7rY6SHCtffPQQI2O+eA8nqUnATxJrirM50zMiG1ESWHjBtsJp45qVLnwBzbG2QVmwXaLszAy+8f6NnOtx84c3pYvmUkjATxJrS7LRGk52SFonUYUXbCudNrZU5WEJnXAlh58s3RU1+VhMBk53yvt/KSTgJ4k6WbhNeBNn+JkZRratcALglBr8JTMaFCtcdhq65CjEpZCAnyTK86w4LCYpzUxgzX3uyBmtAFevdAFSgx8ttYUOGrqG4z2MpCYBP0kYDIrVxVlSqZPAmnvdVDhtke93rCoAFna2sZhZbYGD5l43Yz5Zx1osCfhJZG1JFsfbpcVCvHjG/Rxq7p/x/uZeNxV51sj3daXZ/PrTV7FzffFyDC/l1RbYCWg41+OO91CSlgT8JLK2JJshj4+WPjkJKB4efLmR937v1UhDtIn8AU1r/yiVE2b4AFsq88gwyscsGmoLHAA0dEpaZ7HknZhE1oYWbk+0z57W8Yz7OS/Hw0Xdi6e6gjPM3qkzzPZBD+N+PSmlI6KrpsAOIHn8JZCAn0RWF2Wh1NyVOt9/oYFbv/0yATkIPWqGx3wcbAqmc1r6pgb8plCa4eIZvogem9lEWa5VKnWWQAJ+ErFbTFQ5bRw41zdrHv+Npj4GRscZCB2vJ5Zub2MPvtA/oNOl1JrDJZl5EvBjqabALjP8JYhKwFdK7VRKnVRK1Sul7p3mfotS6peh+/cqpaqj8bzp6E8uLeXFU118d1f9jNeEK3l6RsaWa1gp75X6biwmA1mZpkhwn6i5z43RoCjJlYqcWKotcNDQOSyFC4u05ICvlDIC9wO3AnXAnUqpuosu+wugT2u9Evgm8M9Lfd509YWbLuG9W8r4l2dO8eNXzky5v3PIEzler2to6uKiWJxX67vZtsJJdb592hl+U6+b0txMWaCNsdpCByNePx2DMplZjGi8O7cB9VrrRq21F3gEuP2ia24HHgp9/V/AjUr6xS6KwaD4xvs2snNdMf/798f41f7mSfdPrNMPB36xNB2DHk51DHPNShfleVaap8nhB0syJZ0Ta7WycLsk0Qj4ZcDEqNMSum3aa7TWPmAAyL/4Byml7lFK7VdK7e/q6orC0FKTyWjg23duYlu1k68/eWLSr7cTF3Ql4EdH+LjCq1e6qHDaaO0bnZJSaOqdWpIpom9luDRTAv6iRCPgTzdTvzjBNp9r0Fo/oLXeqrXeWlBQEIWhpS6Lycj7t5bTM+Kd1FDt2PlBirMzMRmUBPwoeeV0N067mbqSbMrzrIz5AnQNXfhvO+r10z08JiWZy6Agy0KWxTSpFv+1+m55r89TNAJ+C1Ax4fty4PxM1yilTEAO0BuF505rV9UGf0l6rb4nctvxtkHWlWbjtJvplhz+kmmteaW+m6tq8zEYVCRt0zwhjx9O8UjAjz2lVKhSJ1iaubexh7se3MuPXmqM88iSQzQC/uvAKqXUCqWUGbgDePyiax4HPhr6+v3ALi3L7EtWnmejKt/Gaw3BgO8Z99PYPUJdaTYuh0VmPVFwunOYzqExrgk1QisPtU6YWIvfGAo+VRLwl0VtQbCJmmfcz1d+/RYAjd1Smz8fSw74oZz8Z4CngOPAo1rro0qpf1BK3Ra67MdAvlKqHvgiMKV0UyzOVbX5wRpxf4BTHUP4A5q1Jdm4siTgR8Pjh4K/rF6zKhzwg0F9YqXO4ZZ+MozB5nYi9moLHbQNePj6kydo7B6hNCczsvFNzM4UjR+itX4CeOKi2/52wtce4APReC4x2ZW1Lh7e18yR84OcbA8u2K4tycblMEvPkSV6ZF8T332+nndsKI4EeqvZiMthnlSLf7Cpj7qSbDIzjPEaaloJV+r85LWzvP+ycrIzM3h4XxNaazksfg5SNJzkrqwJ5fEbujneNoTNbKTKaaPAYaFreEw2qCzSYwdb+Mpjb3HtJQV884ObJt1XnmeLzPD9Ac2bLQNsrsyLxzDTUriJmsth4W/euZaqfBuj4/5JC+lielGZ4Yv4KciysLooi90NPYyNB1hTnIXBoHA5LHh9AYbHfGRlyolLC/HiqS6+9OhhrliRzw8/fBkW0+SZe3melbdaBwA41TGE2+tnU0VuPIaalqpddnZcUsDHrqom12amKj/429e5XjeFcvbArGSGnwKuWpnP62d7Od42GOmo6coKnrLUPSyVOgv1u8PnybFm8OBHt06bpqlw2jjfP4o/oCMN1TZXSsBfLhlGAz/9821cv6YQgKr8YIrnrCzczkkCfgq4qtaFZzzA0JgvEvDz7RZANl8txsDoOEXZmdgt0/8CXJ5nZdyv6Rj0cLCpD6fdLJuu4qgs14pBXThTWMxMAn4K2LbCiSG0VhWZ4TtCAV/ymgs24B4nxzpzGqxiQqXOoeZ+NlXkymJhHJlNBkpzrXIS1jxIwE8BOdYMNpTnohSsCZUGXkjpSMBfqIHR2QN+uBb/2PkBTncOs1ny93FXlW+b9mAaMZkE/BTxoe2VvG9LeSQN4bSZUQq6JIe/YP2jXnJtMwf8slDAf+KtdgA2Sf4+7iqddpp6JJ0lGVkAABlMSURBVIc/F6nSSREf2FrBB7Ze6HBhMhpw2swyw1+EuWb4FpORomwL+872ohRcKjP8uKvOt9HnHp/z/126kxl+CnM5LJLDXyDPuB/PeIBcm3nW68J5/JUFDrKl7DXuwqWZsuN2dhLwU5grS2b4CzUYOhYye45ZYjiPL/X3iaHSGSzNPNcraZ3ZSMBPYcEGapLDX4j+UMDPnSPghztjyg7bxFAZ3nwlM/xZScBPYdIxc+HCB7/PlQde4QrOKC+rkoCfCBwWEy6HWVI6c5BF2xTmclhwe/24vT5sZvlfPR/97tAMf5YqHYB3bSylNNcqHTITSFW+XVI6c5AZfgpzOYILjz2S1pm3+c7wzSYDV9RMOaVTxFGV0yYpnTlIwE9hrqzgbtsuSevMW787+I9jrnX2Kh2ReCrzbbQPevCM++M9lIQlAT+FuezSXmGhBkfHUQqyMiUFlmyq8m1oPfk0MjGZBPwUJh0zF65/dJzszAwMBumNk2wipZmS1pmRBPwUJh0zF052aiavKinNnJME/BRmNhnIsWZIwF+Afvf4nBU6IjHl281kWUwcbxuM91ASlgT8FOdyyG7bhZAZfvJSSrFzfTG/e/M8vSOSxpyOBPwUF+ynI2/++ZKAn9zu2VGDZzzAz3afi/dQEpIE/BTnypLdtgshAT+5rSrK4oY1hfx091kpz5yGBPwUVyDtFeZNa83AqOTwk909O2roGfHyXwda4j2UhCMBP8W5HGYGPT5GxnzxHkrCGx7z4Q9omeEnue0rnFxansODLzfiD+h4DyehSMBPceHt/789dD7OI0l8A5FOmbLLNpkppbhnRy1ne9w8dbQ93sNJKBLwU9xlVXnUlWTz0Gtn0VpmO7MJN06bqxe+SHw71xdT47Lz+UcO8S9Pn2TUK/l8kICf8pRS3H1VNSc7htjT2Bvv4SS08OEnksNPfkaD4pF7ruCdG0v4zq56bvrXF3nldHe8hxV3EvDTwG2bSsmzZfDQa2fjPZSE1j/PTpkiORRmZ/LND27i0U9eiSXDwGcffoMhz3i8hxVXEvDTQGaGkTu2VfL0sXZa+0fjPZyENd/WyCK5bFvh5Fsf3ESfe5wfv3Im3sOJKwn4aeJDV1QB8PM96b0hpW/Ey/AMFUvzPfxEJJ+N5bnsXFfMgy+fSetduBLw00RZrpVb6op5ZF9TWm9Iufsnr/NnP9ozbbnewOg4GUaFNcMYh5GJWPvSLZfg9vr4wYsN8R5K3EjATyN3X11Nn3ucx9O0RNPrC3C0dYDDLQM8vK9pyv0Do15yrGaUktbIqWhVURbv2VzOQ6+dpX3AE+/hxMWSAr5SyqmUekYpdTr097QnOiul/EqpQ6E/jy/lOcXibV/hZE1xFv+RBiWa7/rOy/x099lJtzV0DeMLaBwWE/c9dZKei3YgB9sqyMEnqezzN60ioDXffu50vIcSF0ud4d8LPKe1XgU8F/p+OqNa602hP7ct8TnFIiml+NjV1RxvG2TvmZlLNL2+wDKOKvqGPOMcaR3k2eOdk24/0R5sm/uN929kZMzH1588Men+YGtk2XSVyiqcNu64vJJf7W+mKQ375i814N8OPBT6+iHg3Uv8eSLGbt9URp4tg5+8enba+zuHPGz4+6eSuma5LfTr+pst/ZN+kznRNoTZaODmuiI+/rYafnWghf1nL/zDJ43T0sNfXb8Sg0HxnV3pN8tfasAv0lq3AYT+Lpzhukyl1H6l1B6l1Iz/KCil7gldt7+rq2uJQxPTycwwcmeoRHO6sz9Pdwwz5gtw4FxfHEYXHeGA3+8ep7n3Qhnq8fYhVhY6yDAa+NyNKynNyeT/Pn0ycn+/e5xcCfgprzgnkw9tr+LXB1s50z0Suf1gUx+Pvt4cx5HF3pwBXyn1rFLqyDR/bl/A81RqrbcCdwHfUkrVTneR1voBrfVWrfXWgoKCBfx4sRAfuqIKpRQ/m6ZEs7UvGCAbuoaXe1hR0zZhr8Hhlv7I1yfaBllTkgWAzWzi3ZvL2H+2L1KmOTg6Lm0V0sRfXldLhlHxb6Fc/kunurjjgT18+b/fnLK2k0rmDPha65u01uun+fNboEMpVQIQ+rtzhp9xPvR3I/ACsDlqr0AsWGmulZ3rinlkX/OUHiMtoWDZ2J28Af/8gAelgkc8vhkK+D3DY3QOjbG2ODty3TWrXPgCmr2NPfj8AYbGfFKDnyYKsix89MpqfnOolQdfbuTjD+0nL7R+k8otSJaa0nkc+Gjo648Cv734AqVUnlLKEvraBVwNHFvi84olev/WcgZGxznYPDl1E57hN3aNJG0lT1v/KAUOC3Ul2bzZMgDAyfYhANaWXAj4l1XlkZlh4OXT3Qx6grN8yeGnj09eW4stw8jX/nCc1cVZ/P5z1+CwmHitIXnXr+ay1ID/deBmpdRp4ObQ9yiltiqlHgxdsxbYr5Q6DDwPfF1rLQE/zlYVOgA4d1GlQjiv7/b6aR9MzlrltgEPJblWNpbncKR1AH9AczwU8MMpHQCLyci2Ffm8Ut9Nvzu4+1Jm+OnDaTdz7zvWcktdEb/4xHZcDguXV+exu7En3kOLmSUFfK11j9b6Rq31qtDfvaHb92utPx76+jWt9Qat9aWhv38cjYGLpSnNsWI2GTjbMzLp9tb+UQqzLEBwlp+Mzg+MUpqTycbyXEa8fhq7hjnRNojLYcHlsEy69m0rXdR3DnOqI/gPgszw08uHr6jigY9sJTsz+P/9ytp8GrtG6EjSyc5cZKdtmjIYFJVOG2cnVCn4A5r2AQ87LgkumDcm4cKt1sHXUJJj5dLyHAAOtwxwon2ItRNm92FXr3QB8Ie3ggdl5MjhJ2ntyprg+2FPis7yJeCnsep826SUTsegB19As7kyF7vZSEMSzvAHR324vX5KcjKpKXBgNxs52NTHqY4h1hRPDfhrirNwOcw8d7wDkBl+uqsrzSY708TuBgn4IsVU5ds523NhcTbcOrk8z0ZNgSMpSzPPDwRfQ0luJkaDYn1ZDk8eaWfMF2DNhAqdMINBcfVKF+5QtZLk8NOb0aDYXpPPaxLwRaqpdtnxjAfoGAzWHYcXbMtyrdQU2JMyh98WDvg5VgA2ludE2uGumSalAxfSOiAzfAFX1uTT1OtOybMjJOCnsep8G0Bk4TZcklmWa6XG5aC1fzTpzgI93x9cbCvNzQSCfdAhOHNbGapMutg1oYBvNxvJMMpHIt1dWZsPkJJpHXl3p7HqfDtAZOG2tX8Ul8OM1WykpiB438St58mgfcCDQUFBqBrn0lDAry2wYzFN3+e+NPQbjczuBcDqoizybBkpGfClF2waK821kmFUnA0t3Lb0jVKWG0yF1BYEZ8ON3cPUlU7NfSeq8wOjFGVnYgrN1CucVlwOC+tLc2Z93Cd31ER+wxHpzWBQXFGTz+6GbrTWKXU+ggT8NGY0KCqcNs71XJjhhytZVriCM/yGzuSa4bf1eyjJyYx8r5TiPz+xPbJtfiYfvLwy1kMTSeSWdUU8eaSdH77UyKeunbb1V1KSlE6aq863c6Y7WKnTOmGGbzUbKcu1Jl1PnbaBUUpCryHskqIsCrIsMzxCiKnevamMd2wo5ht/PJFSrRYk4Ke56nw753rcdA2PMeYLRAI+QE2BPalKM7XWtA14KJ0wwxdiMZRSfOP9l7LCZedzDx9MmSMRJeCnuWqXjdFxP4eagl0ly/NskftqCxycSaIman3uccZ8AYpzrHNfLMQcHBYTP/zwZYx6/Xz6FwcITHPwfbKRgJ/mqkKVOq/WB39tLcubPMMf8fojdfqJ7nyoblpm+CJaVhZmce871vJGUz/HQ0dkJjMJ+GluRSjgvzJNwA9X6pzuHIrc1jnk4UcvNfLe773Kbw62LuNI5xY+6eriHL4QS3FVqC7/eNvQHFcmPqnSSXOluZmYDIqGrhGyMk2RroFAZKPSR/59HwUOC/kOC6c6hvAHNEaD4o9H2nn35rJ4DX2K8C5bmeGLaKrOt2PNMHLs/CBcFu/RLI0E/DRnMhqocNo40z0yacEWoCg7kx99ZCtHzw9wvn+U9sExrltdwPu2lPP1J08k3Kas8/0eTAZFvkMqckT0GA2KNSVZHGsbiPdQlkwCvqA6PxjwJy7Yht1cV8TNdUVTbq8psPPS6a7IbD8aPON+Djb1R7a2L1R7aNNVtMYjRFhdSTa/O3w+6TdiSQ5fRBZuy/Pmn/te4bLj9QUiC6XR8PM957jzR3to7nXPffE0zg94Ij10hIimutJsBj2+pG+oJgFfRJqoXZzSmU2NK/q9dvaeCR4effT84qoh2gZGI10yhYimutBZyMcW+d5MFBLwBdWh4F22kBl+lJuraa05cC54oPrxtoV/qPwBTcfAGCUywxcxsKY4G4OCY4t4byYSyeELrqzN54s3X8J1qwvm/ZgChwWHxRS1gN/YPRLpW39xwNdas/9cH009bjqGPAyO+rhnRw1O+4X+OM8ca8frD0S6YwoRTVazkRUue9LP8CXgCywmI5+7cdWCHqOUYoUreq0X9p8NpnPWlmRPmUW91tDDnz24d9JtvSNjfOP9lwLBfxC+/0IDVfk2bplmgVmIaKgrzeFgU1+8h7EkktIRi7bCZY/aDH//2T7ybBm8a2MJLX2jDHrGI/e9Ut+NyaB45gs7OPYPb+fj16zgVwdaONIaLJPb3dDD4ZYB7tlRE2mLLES01ZVk09I3ysDo+NwXJyj5dIhFqymw09o/imf8wqlYpzqGFjXrP3Cuj8uqnJHFsRMTdjXubexhY3kOq4qysJlNfPbGVeRaM/jaH44FZ/cvNlCQZeF9W8qX/qKEmMHa0BGZi1ljShQS8MWirXDZ0RqaQmWUWmvu+el+/uevDi/o53QPj9HYPcLl1XmsDQX88IfK7fXxZssA21ZcqM3PsWbwhZsvYU9jL9985hQvn+7mL65ZQWbG9CdaCREN4YOAkjmPLwFfLFqNK3QqVmhGX985zNkeN0daBxnzzf8s3HB1ztbqPIqyLTjt5siH6mBTP76AZnuNc9Jj7tpWycpCB/+2q56sTBN/tl0OMBGxVZiVicthSepKHQn4YtGqXcH6/cZQHv+Z4x0AeP0BjrTO/0Ox/2wvZpOB9WU5KKVYW5IV6Uy4t7EHg4KtVXmTHmMyGvjqO9cC8OErqsjKlPNoRezVlWbLDF+kp6zMDAqzLJzpCgb8Z491UOEM1vIvpJph/7k+Li3PiRwyvrY4m5PtQ/j8Afac6WV9Wc60Af361YU8/IkrFlxhJMRi1ZVkc7pzCK8vMOn2kTEfX/jlIVr6FrdLfLlIwBdLEq7U6Roa42BzPx+4rIKyXCsHQweqzMUz7udI6wCXVV1I2awtyWbMF+BE+xCHmvvZVu2c8fFX1uZL7l4sm3Wl2Yz79ZSF2+dOdPLYwVaeP9EZp5HNjwR8sSQ1BcGA//yJTrSGG9cWsqUqjzfmOcM/3NzPuF9zefWFlE144fbhfU14fQG21yyumZoQ0XZVbT5Kwa6LAvsLJ4Pfn+uRGb5IYStcdnpGvPzXGy2U5mRSV5LN5opc2gY8kf70s9kX6p+zpfJCwF9Z6CDDqPj1G60oxawzfCGWU77DwpbKPJ470RG5LRDQvHSqC4CzEvBFKlsRqtTZd6aXm+qKUEqxJbTAOp+0zvMnO7m0PIe8CW0SzCYDKwuzGB33s6Y4mxybLMiKxHHj2kKOtA5GDjY/en6Q7mEvZpOBcz2JdUbExSTgiyWpCTVRA7hpbbCtQV1JNhaTgTfOzZ7W6R3xcrC5n+vXFE65L7zJZfsKmd2LxBJ+n4dn+S+eCqZz3rWxhHO97oQ+7FwCvliSijwbRoPCYTFFauXNJgMbynLmzOO/cDKU918ztf9NeMetBHyRaFYVOqhwWnnueDDQv3Cyiw1lOVxWlYfXF6B90BPnEc5sSQFfKfUBpdRRpVRAKbV1lut2KqVOKqXqlVL3LuU5RWIxmwysKc7ilrqiSFklwObK3Dk3YO060UlBloV1oR2ME719XTHv3FDC2y6ZfwdPIZaDUoob1xTxan037QMe3mjq47rVBVSHDhI6m8BpnaXO8I8A7wVemukCpZQRuB+4FagD7lRK1S3xeUUCefieK/in926YdNuWyjy8/sCMm1TG/QFePNXF9asLMExzJGGF08b9f7YFh0UauorEc9PaIsZ8Af75jycIaLhudQFVoYOEErlSZ0kBX2t9XGt9co7LtgH1WutGrbUXeAS4fSnPKxJLdmbGlFr48MLtGzMs3B4418eQx8cN06RzhEh021Y4ybKYeOxgKznWDDZV5FGSY8VsNMxrht82MMqnfnaAbz97Gq2XL+e/HDn8MqB5wvctodumUErdo5Tar5Ta39XVtQxDE7FSlJ1JWa6VvY09096/60QnGUbFNatcyzwyIZbObDKwI5RufNsqF0aDwmhQVDitnOuefYb/+OHzvP2bL/H0sXa++ewpvvHUyWUL+nMGfKXUs0qpI9P8me8sfboj3qd9dVrrB7TWW7XWWwsKJHeb7G6uK+LpYx185ddvTsnlP3e8gytq8iVlI5LWTXXB6rJrJ6wzVefbOdc7c8D/m9+8xecePkhNgYPnvnQdd22v5PsvNHDfMgX9OT9tWuublvgcLUDFhO/LgfNL/JkiCfx/76rDZjbyvRcaONY2xHfu2EyF00pTr5uGrhH+bHtVvIcoxKK9Y0MJA+5x/uTS0shtVfl2djf2oLVGqclz3db+UX6+p4k7t1Xwv29fj8lo4Gu3r0dr+N4LDWRlZvCX19XGdMzLMb16HVillFoBtAJ3AHctw/OKODMaFF/euYaN5Tl86dHD7LjvebIsJhyZwbfdjWun1t8LkSwsJiN3X71i0m3VLhtur5+u4TEKszIn3ff00XYA7tlRGzmZzWBQ/OO719M1NMZ3d53mru2V5Fhjt9FwqWWZ71FKtQBXAn9QSj0Vur1UKfUEgNbaB3wGeAo4DjyqtT66tGGLZLJzfQlP/PXb+Jt3ruW9W8pYW5LNndsqqcq3z/1gIZJI+D09XaXO00c7WFXoYIVr8vveYFB8/qZVjHj9PLKvKabjW9IMX2v9GPDYNLefB94x4fsngCeW8lwiuVXl2/n422riPQwhYqrKGSzNPNs9wuUTekD1jXjZd7aXT107/WdgfVkOV9Xm8x+vnuVjV6/AbIpNPY3stBVCiCgpy7NiNKgpM/xdJzrxBzS31BXP+NhP7KihfdDD79+M3RKnBHwhhIiSDKOB8jzrlFr8p4+1U5ydycbynBkfe90lBawqdPDAS40xq9iRgC+EEFFUlW+fNMMf9fp58VQXt6wrmlK5M5FSik/sqOFE+xCv1HfHZGwS8IUQIoqq822c7RmJzNJfqe/GMx6YNZ0TdvumUgqyLDzwUmNMxia7XoQQIoqq8u0MeXz0ucdx2s08fbSdrMwL3WRnYzEZ+Z+3rMYX0NPW8i+VBHwhhIii6lATtRdOdtLSN8qTR9q5aW0hGcb5JVT+9PKKuS9aJAn4QggRReFa/C8+ehilYGtVHp+5YWWcRxUkAV8IIaKoxmXnU9fWUpxt4dYNJRRlZ879oGUiAV8IIaLIYFDce+uaeA9jWlKlI4QQaUICvhBCpAkJ+EIIkSYk4AshRJqQgC+EEGlCAr4QQqQJCfhCCJEmJOALIUSaUMtxUvpiKKW6gHPxHsciuIDY9DZNbOn4utPxNUN6vu5kes1VWuuC6e5I2ICfrJRS+7XWW+M9juWWjq87HV8zpOfrTpXXLCkdIYRIExLwhRAiTUjAj74H4j2AOEnH152OrxnS83WnxGuWHL4QQqQJmeELIUSakIAvhBBpQgJ+DCml/odSSiulXPEey3JQSt2nlDqhlHpTKfWYUio33mOKFaXUTqXUSaVUvVLq3niPJ9aUUhVKqeeVUseVUkeVUn8d7zEtJ6WUUSl1UCn1+3iPZSkk4MeIUqoCuBloivdYltEzwHqt9UbgFPCVOI8nJpRSRuB+4FagDrhTKVUX31HFnA/4ktZ6LXAF8Fdp8Jon+mvgeLwHsVQS8GPnm8CXgbRZFddaP6219oW+3QOUx3M8MbQNqNdaN2qtvcAjwO1xHlNMaa3btNZvhL4eIhj8yuI7quWhlCoH3gk8GO+xLJUE/BhQSt0GtGqtD8d7LHH058CT8R5EjJQBzRO+byFNgh+AUqoa2Azsje9Ils23CE7eAvEeyFLJIeaLpJR6Fiie5q6vAv8LuGV5R7Q8ZnvdWuvfhq75KsEUwC+Wc2zLSE1zW1r8JqeUcgD/DXxeaz0Y7/HEmlLqXUCn1vqAUuq6eI9nqSTgL5LW+qbpbldKbQBWAIeVUhBMa7yhlNqmtW5fxiHGxEyvO0wp9VHgXcCNOnU3ebQAFRO+LwfOx2ksy0YplUEw2P9Ca/3reI9nmVwN3KaUegeQCWQrpX6utf5QnMe1KLLxKsaUUmeBrVrrZOm0t2hKqZ3AvwLXaq274j2eWFFKmQguSt8ItAKvA3dprY/GdWAxpIKzl4eAXq315+M9nngIzfD/h9b6XfEey2JJDl9E03eBLOAZpdQhpdQP4j2gWAgtTH8GeIrg4uWjqRzsQ64GPgzcEPp/eyg06xVJRGb4QgiRJmSGL4QQaUICvhBCpAkJ+EIIkSYk4AshRJqQgC+EEGlCAr4QQqQJCfhCCJEm/h/VRYiupA15sgAAAABJRU5ErkJggg==\n", 117 | "text/plain": [ 118 | "
" 119 | ] 120 | }, 121 | "metadata": { 122 | "needs_background": "light" 123 | }, 124 | "output_type": "display_data" 125 | } 126 | ], 127 | "source": [ 128 | "plt.plot(X[0:200], Y[0:200])" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "So we have some noisy sine data to train our quantum neural network on. The device we use is the Strawberry Fields simulator, this time with only one quantum mode (or ``wire``). You will need to have the Strawberry Fields plugin for PennyLane installed." 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 6, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "dev = qml.device(\"strawberryfields.fock\", wires=1, cutoff_dim=10)" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "### Quantum node\n", 152 | "For a single quantum mode, each layer of the variational circuit is defined as:" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 7, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [ 161 | "def layer(v):\n", 162 | " # Matrix multiplication of input layer\n", 163 | " qml.Rotation(v[0], wires=0)\n", 164 | " qml.Squeezing(v[1], 0.0, wires=0)\n", 165 | " qml.Rotation(v[2], wires=0)\n", 166 | "\n", 167 | " # Bias\n", 168 | " qml.Displacement(v[3], 0.0, wires=0)\n", 169 | "\n", 170 | " # Element-wise nonlinear transformation\n", 171 | " qml.Kerr(v[4], wires=0)" 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "The variational circuit in the quantum node first encodes the input into\n", 179 | "the displacement of the mode, and then executes the layers. The output\n", 180 | "is the expectation of the x-quadrature." 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "execution_count": 8, 186 | "metadata": {}, 187 | "outputs": [], 188 | "source": [ 189 | "@qml.qnode(dev)\n", 190 | "def quantum_neural_net(var, x=None):\n", 191 | " # Encode input x into quantum state\n", 192 | " qml.Displacement(x, 0.0, wires=0)\n", 193 | "\n", 194 | " # \"layer\" subcircuits\n", 195 | " for v in var:\n", 196 | " layer(v)\n", 197 | "\n", 198 | " return qml.expval(qml.X(0))" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "### Objective\n", 206 | "As an objective we take the square loss between target labels and model\n", 207 | "predictions." 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 9, 213 | "metadata": {}, 214 | "outputs": [], 215 | "source": [ 216 | "def square_loss(labels, predictions):\n", 217 | " loss = 0\n", 218 | " for l, p in zip(labels, predictions):\n", 219 | " loss = loss + (l - p) ** 2\n", 220 | "\n", 221 | " loss = loss / len(labels)\n", 222 | " return loss" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "In the cost function, we compute the outputs from the variational\n", 230 | "circuit. Function fitting is a regression problem, and we interpret the\n", 231 | "expectations from the quantum node as predictions (i.e., without\n", 232 | "applying postprocessing such as thresholding).\n" 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": 10, 238 | "metadata": {}, 239 | "outputs": [], 240 | "source": [ 241 | "def cost(var, features, labels):\n", 242 | " preds = [quantum_neural_net(var, x=x) for x in features]\n", 243 | " return square_loss(labels, preds)" 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "metadata": {}, 249 | "source": [ 250 | "### Optimization\n", 251 | "We load noisy data samples of a sine function." 252 | ] 253 | }, 254 | { 255 | "cell_type": "markdown", 256 | "metadata": {}, 257 | "source": [ 258 | "Before training a model, let’s examine the data.\n", 259 | "\n", 260 | "*Note: For the next cell to work you need the matplotlib library.*\n" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 11, 266 | "metadata": {}, 267 | "outputs": [ 268 | { 269 | "data": { 270 | "image/png": "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\n", 271 | "text/plain": [ 272 | "
" 273 | ] 274 | }, 275 | "metadata": { 276 | "needs_background": "light" 277 | }, 278 | "output_type": "display_data" 279 | } 280 | ], 281 | "source": [ 282 | "plt.figure()\n", 283 | "plt.scatter(X, Y)\n", 284 | "plt.xlabel(\"x\", fontsize=18)\n", 285 | "plt.ylabel(\"f(x)\", fontsize=18)\n", 286 | "plt.tick_params(axis=\"both\", which=\"major\", labelsize=16)\n", 287 | "plt.tick_params(axis=\"both\", which=\"minor\", labelsize=16)\n", 288 | "plt.show()" 289 | ] 290 | }, 291 | { 292 | "cell_type": "markdown", 293 | "metadata": {}, 294 | "source": [ 295 | "The network’s weights (called ``var`` here) are initialized with values\n", 296 | "sampled from a normal distribution. We use 4 layers; performance has\n", 297 | "been found to plateau at around 6 layers." 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": 12, 303 | "metadata": {}, 304 | "outputs": [ 305 | { 306 | "name": "stdout", 307 | "output_type": "stream", 308 | "text": [ 309 | "[[ 0.08820262 0.02000786 0.0489369 0.11204466 0.0933779 ]\n", 310 | " [-0.04886389 0.04750442 -0.00756786 -0.00516094 0.02052993]\n", 311 | " [ 0.00720218 0.07271368 0.03805189 0.00608375 0.02219316]\n", 312 | " [ 0.01668372 0.07470395 -0.01025791 0.01565339 -0.04270479]]\n" 313 | ] 314 | } 315 | ], 316 | "source": [ 317 | "np.random.seed(0)\n", 318 | "num_layers = 4\n", 319 | "var_init = 0.05 * np.random.randn(num_layers, 5)\n", 320 | "print(var_init)" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": 13, 326 | "metadata": {}, 327 | "outputs": [ 328 | { 329 | "name": "stdout", 330 | "output_type": "stream", 331 | "text": [ 332 | "Iter: 1 | Cost: 0.4366430 \n", 333 | "Iter: 2 | Cost: 0.4130995 \n", 334 | "Iter: 3 | Cost: 0.4401763 \n", 335 | "Iter: 4 | Cost: 0.4843044 \n", 336 | "Iter: 5 | Cost: 0.5272264 \n", 337 | "Iter: 6 | Cost: 0.5590949 \n", 338 | "Iter: 7 | Cost: 0.5756194 \n", 339 | "Iter: 8 | Cost: 0.5762956 \n", 340 | "Iter: 9 | Cost: 0.5631025 \n", 341 | "Iter: 10 | Cost: 0.5394853 \n", 342 | "Iter: 11 | Cost: 0.5095363 \n", 343 | "Iter: 12 | Cost: 0.4773198 \n", 344 | "Iter: 13 | Cost: 0.4463337 \n", 345 | "Iter: 14 | Cost: 0.4191397 \n", 346 | "Iter: 15 | Cost: 0.3972019 \n", 347 | "Iter: 16 | Cost: 0.3809405 \n", 348 | "Iter: 17 | Cost: 0.3699549 \n", 349 | "Iter: 18 | Cost: 0.3633300 \n", 350 | "Iter: 19 | Cost: 0.3599337 \n", 351 | "Iter: 20 | Cost: 0.3586456 \n", 352 | "Iter: 21 | Cost: 0.3584964 \n", 353 | "Iter: 22 | Cost: 0.3587285 \n", 354 | "Iter: 23 | Cost: 0.3588033 \n", 355 | "Iter: 24 | Cost: 0.3583769 \n", 356 | "Iter: 25 | Cost: 0.3572647 \n", 357 | "Iter: 26 | Cost: 0.3554029 \n", 358 | "Iter: 27 | Cost: 0.3528146 \n", 359 | "Iter: 28 | Cost: 0.3495813 \n", 360 | "Iter: 29 | Cost: 0.3458197 \n", 361 | "Iter: 30 | Cost: 0.3416648 \n", 362 | "Iter: 31 | Cost: 0.3372562 \n", 363 | "Iter: 32 | Cost: 0.3327294 \n", 364 | "Iter: 33 | Cost: 0.3282081 \n", 365 | "Iter: 34 | Cost: 0.3238007 \n", 366 | "Iter: 35 | Cost: 0.3195972 \n", 367 | "Iter: 36 | Cost: 0.3156676 \n", 368 | "Iter: 37 | Cost: 0.3120615 \n", 369 | "Iter: 38 | Cost: 0.3088088 \n", 370 | "Iter: 39 | Cost: 0.3059200 \n", 371 | "Iter: 40 | Cost: 0.3033888 \n", 372 | "Iter: 41 | Cost: 0.3011936 \n", 373 | "Iter: 42 | Cost: 0.2993004 \n", 374 | "Iter: 43 | Cost: 0.2976666 \n", 375 | "Iter: 44 | Cost: 0.2962437 \n", 376 | "Iter: 45 | Cost: 0.2949811 \n", 377 | "Iter: 46 | Cost: 0.2938298 \n", 378 | "Iter: 47 | Cost: 0.2927447 \n", 379 | "Iter: 48 | Cost: 0.2916878 \n", 380 | "Iter: 49 | Cost: 0.2906292 \n", 381 | "Iter: 50 | Cost: 0.2895481 \n", 382 | "Iter: 51 | Cost: 0.2884328 \n", 383 | "Iter: 52 | Cost: 0.2872799 \n", 384 | "Iter: 53 | Cost: 0.2860931 \n", 385 | "Iter: 54 | Cost: 0.2848812 \n", 386 | "Iter: 55 | Cost: 0.2836566 \n", 387 | "Iter: 56 | Cost: 0.2824333 \n", 388 | "Iter: 57 | Cost: 0.2812253 \n", 389 | "Iter: 58 | Cost: 0.2800452 \n", 390 | "Iter: 59 | Cost: 0.2789039 \n", 391 | "Iter: 60 | Cost: 0.2778094 \n", 392 | "Iter: 61 | Cost: 0.2767668 \n", 393 | "Iter: 62 | Cost: 0.2757787 \n", 394 | "Iter: 63 | Cost: 0.2748451 \n", 395 | "Iter: 64 | Cost: 0.2739643 \n", 396 | "Iter: 65 | Cost: 0.2731328 \n", 397 | "Iter: 66 | Cost: 0.2723465 \n", 398 | "Iter: 67 | Cost: 0.2716004 \n", 399 | "Iter: 68 | Cost: 0.2708895 \n", 400 | "Iter: 69 | Cost: 0.2702092 \n", 401 | "Iter: 70 | Cost: 0.2695549 \n", 402 | "Iter: 71 | Cost: 0.2689228 \n", 403 | "Iter: 72 | Cost: 0.2683099 \n", 404 | "Iter: 73 | Cost: 0.2677134 \n", 405 | "Iter: 74 | Cost: 0.2671316 \n", 406 | "Iter: 75 | Cost: 0.2665631 \n", 407 | "Iter: 76 | Cost: 0.2660070 \n", 408 | "Iter: 77 | Cost: 0.2654630 \n", 409 | "Iter: 78 | Cost: 0.2649310 \n", 410 | "Iter: 79 | Cost: 0.2644110 \n", 411 | "Iter: 80 | Cost: 0.2639034 \n", 412 | "Iter: 81 | Cost: 0.2634083 \n", 413 | "Iter: 82 | Cost: 0.2629260 \n", 414 | "Iter: 83 | Cost: 0.2624569 \n", 415 | "Iter: 84 | Cost: 0.2620009 \n", 416 | "Iter: 85 | Cost: 0.2615582 \n", 417 | "Iter: 86 | Cost: 0.2611285 \n", 418 | "Iter: 87 | Cost: 0.2607117 \n", 419 | "Iter: 88 | Cost: 0.2603074 \n", 420 | "Iter: 89 | Cost: 0.2599152 \n", 421 | "Iter: 90 | Cost: 0.2595346 \n", 422 | "Iter: 91 | Cost: 0.2591651 \n", 423 | "Iter: 92 | Cost: 0.2588059 \n", 424 | "Iter: 93 | Cost: 0.2584567 \n", 425 | "Iter: 94 | Cost: 0.2581168 \n", 426 | "Iter: 95 | Cost: 0.2577857 \n", 427 | "Iter: 96 | Cost: 0.2574629 \n", 428 | "Iter: 97 | Cost: 0.2571479 \n", 429 | "Iter: 98 | Cost: 0.2568405 \n", 430 | "Iter: 99 | Cost: 0.2565402 \n", 431 | "Iter: 100 | Cost: 0.2562468 \n" 432 | ] 433 | } 434 | ], 435 | "source": [ 436 | "opt = AdamOptimizer(0.01, beta1=0.9, beta2=0.999)\n", 437 | "\n", 438 | "var = var_init\n", 439 | "for it in range(100):\n", 440 | " var = opt.step(lambda v: cost(v, X, Y), var)\n", 441 | " print(\"Iter: {:5d} | Cost: {:0.7f} \".format(it + 1, cost(var, X, Y)))" 442 | ] 443 | }, 444 | { 445 | "cell_type": "markdown", 446 | "metadata": {}, 447 | "source": [ 448 | "Finally, we collect the predictions of the trained model for 75 values\n", 449 | "in the range $[0,30]$:" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": 14, 455 | "metadata": {}, 456 | "outputs": [], 457 | "source": [ 458 | "x_pred = np.linspace(-3, 3, 50)\n", 459 | "predictions = [quantum_neural_net(var, x=x_) for x_ in x_pred]" 460 | ] 461 | }, 462 | { 463 | "cell_type": "markdown", 464 | "metadata": {}, 465 | "source": [ 466 | "and plot the shape of the function that the model has “learned” from\n", 467 | "the noisy data (green dots)." 468 | ] 469 | }, 470 | { 471 | "cell_type": "code", 472 | "execution_count": 15, 473 | "metadata": {}, 474 | "outputs": [ 475 | { 476 | "data": { 477 | "image/png": "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\n", 478 | "text/plain": [ 479 | "
" 480 | ] 481 | }, 482 | "metadata": { 483 | "needs_background": "light" 484 | }, 485 | "output_type": "display_data" 486 | } 487 | ], 488 | "source": [ 489 | "plt.figure()\n", 490 | "plt.scatter(X, Y)\n", 491 | "plt.scatter(x_pred, predictions, color=\"red\")\n", 492 | "plt.xlabel(\"x\")\n", 493 | "plt.ylabel(\"f(x)\")\n", 494 | "plt.tick_params(axis=\"both\", which=\"major\")\n", 495 | "plt.tick_params(axis=\"both\", which=\"minor\")\n", 496 | "plt.show()" 497 | ] 498 | }, 499 | { 500 | "cell_type": "markdown", 501 | "metadata": {}, 502 | "source": [ 503 | "The model has learned to smooth the noisy data.\n", 504 | "\n", 505 | "In fact, we can use PennyLane to look at typical functions that the\n", 506 | "model produces without being trained at all. The shape of these\n", 507 | "functions varies significantly with the variance hyperparameter for the\n", 508 | "weight initialization.\n", 509 | "\n", 510 | "Setting this hyperparameter to a small value produces almost linear\n", 511 | "functions, since all quantum gates in the variational circuit\n", 512 | "approximately perform the identity transformation in that case. Larger\n", 513 | "values produce smoothly oscillating functions with a period that depends\n", 514 | "on the number of layers used (generically, the more layers, the smaller\n", 515 | "the period)." 516 | ] 517 | }, 518 | { 519 | "cell_type": "code", 520 | "execution_count": 16, 521 | "metadata": {}, 522 | "outputs": [ 523 | { 524 | "data": { 525 | "image/png": "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\n", 526 | "text/plain": [ 527 | "
" 528 | ] 529 | }, 530 | "metadata": { 531 | "needs_background": "light" 532 | }, 533 | "output_type": "display_data" 534 | } 535 | ], 536 | "source": [ 537 | "variance = 1.0\n", 538 | "\n", 539 | "plt.figure()\n", 540 | "x_pred = np.linspace(-5, 5, 50)\n", 541 | "for i in range(7):\n", 542 | " rnd_var = variance * np.random.randn(num_layers, 7)\n", 543 | " predictions = [quantum_neural_net(rnd_var, x=x_) for x_ in x_pred]\n", 544 | " plt.plot(x_pred, predictions, color=\"black\")\n", 545 | "plt.xlabel(\"x\")\n", 546 | "plt.ylabel(\"f(x)\")\n", 547 | "plt.tick_params(axis=\"both\", which=\"major\")\n", 548 | "plt.tick_params(axis=\"both\", which=\"minor\")\n", 549 | "plt.show()" 550 | ] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "metadata": {}, 555 | "source": [ 556 | "## References\n", 557 | "PennyLane \"Function Fitting with a Quantum Neural Network\" ```https://pennylane.ai/qml/app/quantum_neural_net.html```\n", 558 | "\n", 559 | "\"Generating and visualizing data from a sine wave in Python\" ```https://goelhardik.github.io/2016/05/25/sampling-sine-wave/```\n", 560 | "\n", 561 | "`Killoran et al. (2018) `\n", 562 | "\n", 563 | "\"adding noise to a signal in python\" ```https://stackoverflow.com/questions/14058340/adding-noise-to-a-signal-in-python```" 564 | ] 565 | }, 566 | { 567 | "cell_type": "code", 568 | "execution_count": null, 569 | "metadata": {}, 570 | "outputs": [], 571 | "source": [] 572 | } 573 | ], 574 | "metadata": { 575 | "kernelspec": { 576 | "display_name": "Python 3", 577 | "language": "python", 578 | "name": "python3" 579 | }, 580 | "language_info": { 581 | "codemirror_mode": { 582 | "name": "ipython", 583 | "version": 3 584 | }, 585 | "file_extension": ".py", 586 | "mimetype": "text/x-python", 587 | "name": "python", 588 | "nbconvert_exporter": "python", 589 | "pygments_lexer": "ipython3", 590 | "version": "3.7.3" 591 | } 592 | }, 593 | "nbformat": 4, 594 | "nbformat_minor": 4 595 | } 596 | --------------------------------------------------------------------------------