--- a +++ b/Code/All PennyLane QML Demos/16 Generalization QML 80% kkawchak.ipynb @@ -0,0 +1,885 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "id": "BYEH7VMOLDID" + }, + "outputs": [], + "source": [ + "# This cell is added by sphinx-gallery\n", + "# It can be customized to whatever you like\n", + "%matplotlib inline\n", + "# !pip install pennylane" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tfR_BtWaLDIE" + }, + "source": [ + "Generalization in QML from few training data {#learning_few_data}\n", + "============================================\n", + "\n", + "::: {.meta}\n", + ":property=\\\"og:description\\\": Generalization of quantum machine learning\n", + "models. :property=\\\"og:image\\\":\n", + "<https://pennylane.ai/qml/_images/few_data_thumbnail.png>\n", + ":::\n", + "\n", + "::: {.related}\n", + "tutorial\\_local\\_cost\\_functions Alleviating barren plateaus with local\n", + "cost functions\n", + ":::\n", + "\n", + "*Authors: Korbinian Kottmann, Luis Mantilla Calderon, Maurice Weber ---\n", + "Posted: 29 August 2022*\n", + "\n", + "In this tutorial, we dive into the generalization capabilities of\n", + "quantum machine learning models. For the example of a [Quantum\n", + "Convolutional Neural Network\n", + "(QCNN)](https://pennylane.ai/qml/glossary/qcnn.html), we show how its\n", + "generalization error behaves as a function of the number of training\n", + "samples. This demo is based on the paper *\\\"Generalization in quantum\n", + "machine learning from few training data\\\"*. by Caro et al..\n", + "\n", + "What is generalization in (Q)ML?\n", + "--------------------------------\n", + "\n", + "When optimizing a machine learning model, be it classical or quantum, we\n", + "aim to maximize its performance over the data distribution of interest\n", + "(e.g., images of cats and dogs). However, in practice, we are limited to\n", + "a finite amount of data, which is why it is necessary to reason about\n", + "how our model performs on new, previously unseen data. The difference\n", + "between the model\\'s performance on the true data distribution and the\n", + "performance estimated from our training data is called the\n", + "*generalization error*, and it indicates how well the model has learned\n", + "to generalize to unseen data. Generalization can be seen as a\n", + "manifestation of the bias-variance trade-off; models that perfectly fit\n", + "the training data admit a low bias at the cost of a higher variance, and\n", + "hence typically perform poorly on unseen test data. In the classical\n", + "machine learning community, this trade-off has been extensively studied\n", + "and has led to optimization techniques that favour generalization, for\n", + "example, by regularizing models via their variance. Below, we see a\n", + "canoncial example of this trade-off, with a model having low bias, but\n", + "high variance and therefore high generalization error. The low variance\n", + "model, on the other hand, has a higher bias but generalizes better.\n", + "\n", + "{.align-center\n", + "width=\"65.0%\"}\n", + "\n", + "Let us now dive deeper into generalization properties of quantum machine\n", + "learning (QML) models. We start by describing the typical data\n", + "processing pipeline of a QML model. A classical data input $x$ is first\n", + "encoded in a quantum state via a mapping $x \\mapsto \\rho(x)$. This\n", + "encoded state is then processed through a quantum channel\n", + "$\\rho(x) \\mapsto \\mathcal{E}_\\alpha(\\rho(x))$ with learnable parameters\n", + "$\\alpha$. Finally, a measurement is performed on the resulting state to\n", + "get the final prediction. Now, the goal is to minimize the expected loss\n", + "over the data-generating distribution $P$, indicating how well our model\n", + "performs on new data. Mathematically, for a loss function $\\ell$, the\n", + "expected loss, denoted by $R$, is given by\n", + "\n", + "$$R(\\alpha) = \\mathbb{E}_{(x,y)\\sim P}[\\ell(\\alpha;\\,x,\\,y)]$$\n", + "\n", + "where $x$ are the features, $y$ are the labels, and $P$ is their joint\n", + "distribution. In practice, as the joint distribution $P$ is generally\n", + "unknown, this quantity has to be estimated from a finite amount of data.\n", + "Given a training set $S = \\{(x_i,\\,y_i)\\}_{i=1}^N$ with $N$ samples, we\n", + "estimate the performance of our QML model by calculating the average\n", + "loss over the training set\n", + "\n", + "$$R_S(\\alpha) = \\frac{1}{N}\\sum_{i=1}^N \\ell(\\alpha;\\,x_i,\\,y_i),$$\n", + "\n", + "which is referred to as the training loss and is an unbiased estimate of\n", + "$R(\\alpha)$. This is only a proxy to the true quantity of interest\n", + "$R(\\alpha)$, and their difference is called the generalization error\n", + "\n", + "$$\\mathrm{gen}(\\alpha) = R(\\alpha) - \\hat{R}_S(\\alpha),$$\n", + "\n", + "which is the quantity that we explore in this tutorial. Keeping in mind\n", + "the bias-variance trade-off, one would expect that more complex models,\n", + "i.e. models with a larger number of parameters, achieve a lower error on\n", + "the training data but a higher generalization error. Having more\n", + "training data, on the other hand, leads to a better approximation of the\n", + "true expected loss and hence a lower generalization error. This\n", + "intuition is made precise in Ref., where it is shown that\n", + "$\\mathrm{gen}(\\alpha)$ roughly scales as $\\mathcal{O}(\\sqrt{T / N})$,\n", + "where $T$ is the number of parametrized gates and $N$ is the number of\n", + "training samples.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "76al4ZQNLDIF" + }, + "source": [ + "Generalization bounds for QML models\n", + "====================================\n", + "\n", + "As hinted at earlier, we expect the generalization error to depend both\n", + "on the richness of the model class, as well as on the amount of training\n", + "data available. As a first result, the authors of Ref. found that for a\n", + "QML model with at most $T$ parametrized local quantum channels, the\n", + "generalization error depends on $T$ and $N$ according to\n", + "\n", + "$$\\mathrm{gen}(\\alpha) \\sim \\mathcal{O}\\left(\\sqrt{\\frac{T\\log T}{N}}\\right).$$\n", + "\n", + "We see that this scaling is in line with our intuition that the\n", + "generalization error scales inversely with the number of training\n", + "samples and increases with the number of parametrized gates. However, as\n", + "is the case for [quantum convolutional neural networks\n", + "(QCNNs)](https://pennylane.ai/qml/glossary/qcnn.html), it is possible to\n", + "get a more fine-grained bound by including knowledge on the number of\n", + "gates $M$ which have been reused (i.e. whose parameters are shared\n", + "across wires). Naively, one could suspect that the generalization error\n", + "scales as $\\tilde{\\mathcal{O}}(\\sqrt{MT/N})$ by directly applying the\n", + "above result (and where $\\tilde{\\mathcal{O}}$ includes logarithmic\n", + "factors). However, the authors of Ref. found that such models actually\n", + "adhere to the better scaling\n", + "\n", + "$$\\mathrm{gen}(\\alpha) \\sim \\mathcal{O}\\left(\\sqrt{\\frac{T\\log MT}{N}}\\right).$$\n", + "\n", + "With this, we see that for QCNNs to have a generalization error\n", + "$\\mathrm{gen}(\\alpha)\\leq\\epsilon$, we need a training set of size\n", + "$N \\sim T \\log MT / \\epsilon^2$. For the special case of QCNNs, we can\n", + "explicitly connect the number of samples needed for good generalization\n", + "to the system size $n$ since these models use $\\mathcal{O}(\\log(n))$\n", + "independently parametrized gates, each of which is used at most $n$\n", + "times. Putting the pieces together, we find that a training set of size\n", + "\n", + "$$N \\sim \\mathcal{O}(\\mathrm{poly}(\\log n))$$\n", + "\n", + "is sufficient for the generalization error to be bounded by\n", + "$\\mathrm{gen}(\\alpha) \\leq \\epsilon$. In the next part of this tutorial,\n", + "we will illustrate this result by implementing a QCNN to classify\n", + "different digits in the classical `digits` dataset. Before that, we set\n", + "up our QCNN.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UFCGuJ_CLDIF" + }, + "source": [ + "Quantum convolutional neural networks\n", + "\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\-\\--Before\n", + "we start building a QCNN, let us briefly review the idea of classical\n", + "CNNs, which have shown tremendous success in tasks like image\n", + "recognition, recommender systems, and sound classification, to name a\n", + "few. For a more in-depth explanation of CNNs, we highly recommend\n", + "[chapter 9](https://www.deeplearningbook.org/contents/convnets.html) in.\n", + "Classical CNNs are a family of neural networks which make use of\n", + "convolutions and pooling operations to insert an inductive bias,\n", + "favouring invariances to spatial transformations like translations,\n", + "rotations, and scaling. A *convolutional layer* consists of a small\n", + "kernel (a window) that sweeps over a 2D array representation of an image\n", + "and extracts local information while sharing parameters across the\n", + "spatial dimensions. In addition to the convolutional layers, one\n", + "typically uses pooling layers to reduce the size of the input and to\n", + "provide a mechanism for summarizing information from a neighbourhood of\n", + "values in the input. On top of reducing dimensionality, these types of\n", + "layers have the advantage of making the model more agnostic to certain\n", + "transformations like scaling and rotations. These two types of layers\n", + "are applied repeatedly in an alternating manner as shown in the figure\n", + "below.\n", + "\n", + "{.align-center\n", + "width=\"75.0%\"}\n", + "\n", + "We want to build something similar for a quantum circuit. First, we\n", + "import the necessary libraries we will need in this demo and set a\n", + "random seed for reproducibility:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "ftmhRXA9LDIF" + }, + "outputs": [], + "source": [ + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn import datasets\n", + "import seaborn as sns\n", + "import jax;\n", + "\n", + "jax.config.update('jax_platform_name', 'cpu')\n", + "jax.config.update(\"jax_enable_x64\", True)\n", + "import jax.numpy as jnp\n", + "\n", + "import optax # optimization using jax\n", + "\n", + "import pennylane as qml\n", + "import pennylane.numpy as pnp\n", + "\n", + "sns.set()\n", + "\n", + "seed = 0\n", + "rng = np.random.default_rng(seed=seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H0DTTMNeLDIF" + }, + "source": [ + "To construct a convolutional and pooling layer in a quantum circuit, we\n", + "will follow the QCNN construction proposed in. The former layer will\n", + "extract local correlations, while the latter allows reducing the\n", + "dimensionality of the feature vector. In a quantum circuit, the\n", + "convolutional layer, consisting of a kernel swept along the entire\n", + "image, is a two-qubit unitary that correlates neighbouring qubits. As\n", + "for the pooling layer, we will use a conditioned single-qubit unitary\n", + "that depends on the measurement of a neighboring qubit. Finally, we use\n", + "a *dense layer* that entangles all qubits of the final state using an\n", + "all-to-all unitary gate as shown in the figure below.\n", + "\n", + "{.align-center\n", + "width=\"75.0%\"}\n", + "\n", + "Breaking down the layers\n", + "========================\n", + "\n", + "The convolutional layer should have the weights of the two-qubit unitary\n", + "as an input, which are updated at every training step. In PennyLane, we\n", + "model this arbitrary two-qubit unitary with a particular sequence of\n", + "gates: two single-qubit `~.pennylane.U3`{.interpreted-text role=\"class\"}\n", + "gates (parametrized by three parameters, each), three Ising interactions\n", + "between both qubits (each interaction is parametrized by one parameter),\n", + "and two additional `~.pennylane.U3`{.interpreted-text role=\"class\"}\n", + "gates on each of the two qubits.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "id": "6eI2w54HLDIG" + }, + "outputs": [], + "source": [ + "def convolutional_layer(weights, wires, skip_first_layer=True):\n", + " \"\"\"Adds a convolutional layer to a circuit.\n", + " Args:\n", + " weights (np.array): 1D array with 15 weights of the parametrized gates.\n", + " wires (list[int]): Wires where the convolutional layer acts on.\n", + " skip_first_layer (bool): Skips the first two U3 gates of a layer.\n", + " \"\"\"\n", + " n_wires = len(wires)\n", + " assert n_wires >= 3, \"this circuit is too small!\"\n", + "\n", + " for p in [0, 1]:\n", + " for indx, w in enumerate(wires):\n", + " if indx % 2 == p and indx < n_wires - 1:\n", + " if indx % 2 == 0 and not skip_first_layer:\n", + " qml.U3(*weights[:3], wires=[w])\n", + " qml.U3(*weights[3:6], wires=[wires[indx + 1]])\n", + " #qml.IsingXX(weights[6], wires=[w, wires[indx + 1]])\n", + " #qml.IsingYY(weights[7], wires=[w, wires[indx + 1]])\n", + " #qml.IsingZZ(weights[8], wires=[w, wires[indx + 1]])\n", + " qml.U3(*weights[9:12], wires=[w])\n", + " qml.U3(*weights[12:], wires=[wires[indx + 1]])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vFPqYGMvLDIG" + }, + "source": [ + "The pooling layer\\'s inputs are the weights of the single-qubit\n", + "conditional unitaries, which in this case are\n", + "`~.pennylane.U3`{.interpreted-text role=\"class\"} gates. Then, we apply\n", + "these conditional measurements to half of the unmeasured wires, reducing\n", + "our system size by a factor of 2.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "id": "J1FHoMIaLDIG" + }, + "outputs": [], + "source": [ + "def pooling_layer(weights, wires):\n", + " \"\"\"Adds a pooling layer to a circuit.\n", + " Args:\n", + " weights (np.array): Array with the weights of the conditional U3 gate.\n", + " wires (list[int]): List of wires to apply the pooling layer on.\n", + " \"\"\"\n", + " n_wires = len(wires)\n", + " assert len(wires) >= 2, \"this circuit is too small!\"\n", + "\n", + " for indx, w in enumerate(wires):\n", + " if indx % 2 == 1 and indx < n_wires:\n", + " m_outcome = qml.measure(w)\n", + " qml.cond(m_outcome, qml.U3)(*weights, wires=wires[indx - 1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YEYQ0uyBLDIG" + }, + "source": [ + "We can construct a QCNN by combining both layers and using an arbitrary\n", + "unitary to model a dense layer. It will take a set of features --- the\n", + "image --- as input, encode these features using an embedding map, apply\n", + "rounds of convolutional and pooling layers, and eventually output the\n", + "desired measurement statistics of the circuit.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 663 + }, + "id": "cCdVbZ8hLDIG", + "outputId": "810067a7-3629-45e7-d56d-573d7101c9d8" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1500x700 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "def conv_and_pooling(kernel_weights, n_wires, skip_first_layer=True):\n", + " \"\"\"Apply both the convolutional and pooling layer.\"\"\"\n", + " convolutional_layer(kernel_weights[:15], n_wires, skip_first_layer=skip_first_layer)\n", + " pooling_layer(kernel_weights[15:], n_wires)\n", + "\n", + "\n", + "def dense_layer(weights, wires):\n", + " \"\"\"Apply an arbitrary unitary gate to a specified set of wires.\"\"\"\n", + " qml.ArbitraryUnitary(weights, wires)\n", + "\n", + "\n", + "num_wires = 6\n", + "device = qml.device(\"default.qubit\", wires=num_wires)\n", + "\n", + "\n", + "@qml.qnode(device, interface=\"jax\")\n", + "def conv_net(weights, last_layer_weights, features):\n", + " \"\"\"Define the QCNN circuit\n", + " Args:\n", + " weights (np.array): Parameters of the convolution and pool layers.\n", + " last_layer_weights (np.array): Parameters of the last dense layer.\n", + " features (np.array): Input data to be embedded using AmplitudEmbedding.\"\"\"\n", + "\n", + " layers = weights.shape[1]\n", + " wires = list(range(num_wires))\n", + "\n", + " # inputs the state input_state\n", + " qml.AmplitudeEmbedding(features=features, wires=wires, pad_with=0.5)\n", + " qml.Barrier(wires=wires, only_visual=True)\n", + "\n", + " # adds convolutional and pooling layers\n", + " for j in range(layers):\n", + " conv_and_pooling(weights[:, j], wires, skip_first_layer=(not j == 0))\n", + " wires = wires[::2]\n", + " qml.Barrier(wires=wires, only_visual=True)\n", + "\n", + " assert last_layer_weights.size == 4 ** (len(wires)) - 1, (\n", + " \"The size of the last layer weights vector is incorrect!\"\n", + " f\" \\n Expected {4 ** (len(wires)) - 1}, Given {last_layer_weights.size}\"\n", + " )\n", + " dense_layer(last_layer_weights, wires)\n", + " return qml.probs(wires=(0))\n", + "\n", + "\n", + "fig, ax = qml.draw_mpl(conv_net)(\n", + " np.random.rand(18, 2), np.random.rand(4 ** 2 - 1), np.random.rand(2 ** num_wires)\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7v7vT3DMLDIG" + }, + "source": [ + "In the problem we will address, we need to encode 64 features in our\n", + "quantum state. Thus, we require six qubits ($2^6 = 64$) to encode each\n", + "feature value in the amplitude of each computational basis state.\n", + "\n", + "Training the QCNN on the digits dataset\n", + "=======================================\n", + "\n", + "In this demo, we are going to classify the digits `0` and `1` from the\n", + "classical `digits` dataset. Each hand-written digit image is represented\n", + "as an $8 \\times 8$ array of pixels as shown below:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 59 + }, + "id": "irGiN1UHLDIG", + "outputId": "3f233a66-e168-493e-8960-c9e7aa4b5b33" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 300x100 with 12 Axes>" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARwAAAAqCAYAAABhoOTkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAeP0lEQVR4nO1dW28b17X+OBxehtcZ3nWhLpZkSZHkyI6bNEhgJEEKJwFaoGhT9Ln5C33qP2mBvhd9SYsWBVwXSdDWgWPHdmI7kRRdTFuyJF5EzgxnyCFnSJ4HY+2OZIqkFB+dg3PmAwTJirhnz569v7XWt9aauDqdTgcOHDhwcAbg/qcn4MCBg/8/cAjHgQMHZwaHcBw4cHBmcAjHgQMHZwaHcBw4cHBmcAjHgQMHZwaHcBw4cHBmcAjHgQMHZwaHcBw4cHBm4Af9Q5fLdfiDPI/Z2VmcP38eyWQSV69exfLyMmRZxvr6OmRZxr1793Dt2jXIsgzDMGAYxokml8lk8NFHH+Hdd98Fz/MQBAFutxv379/HJ598goODA6yvr2NjYwOtVqvveH6/Hz6fD5Ik4e2338aFCxeQTqdx+fJlJJNJ5PN5PHr0CLIs4+OPP8af//xnNBqNE82ZcPnyZfzmN7/BxYsXYZom6vU6dF3HH/7wB/zxj3+EruswDAOmaXb9PMdxSKVSSCQSyGQy+NnPfoYf/vCHaDQaqFQqMAyDzVdVVdy9exd37tyBZVkDz5HneYiiiGAwiB/84AdsvoRarYbf/va3+N3vfodqtQpZlqHretexfD4fPvjgA7z33nuIRqOYnJxEKpWCpmnY29uDruvsuVUqFeTzeRSLRbTb7b5zXFxcxMLCApLJJN555x0sLS1BVVVsbm5CUZRD4yqKAlVVcdoC+mAwiF/84hf4+c9/DgC4desWHj58CFVVsbKygp2dnYHH4jgOfr8fHo8HMzMz+OUvf4mpqSlomgZZllGr1fDJJ5/g008/RbPZ7DteKBSCKIoIBAL48MMP8atf/QqSJLF7rlQq+Otf/4rPPvsMmqYhn8+jUqn0HZfORTabxa9//Wv85Cc/QbPZRKVSQb1ex/Xr1/H73/8e+XwehmF0PRODrvfAhNMLdjI6+jPHcXC5XOzrf7qTguZH8yIcnRfN90Vdz74G9t/3A8d1d0Lt49HfnHa+3+c+fT4fAoEAAoEAMpkMstksgsEgfD4fTNOEYRgolUqQZRk8z2NpaQm6ruPBgwdQVRWmaaLVavXdF/3meHR9Twqe5+HxeBAIBBCNRhGPx8FxHLLZLGq1GkqlEra3t0+1h487HydFJBLBuXPnEIlEkEqlwPM8Op0OM2itVgtjY2N4/fXXUalUcOvWLciy/L3me/R33/dMnJpwOI7D0NAQlpeXEYvFMDw8jFAoBMuyGGNOTU3hxz/+MWq1Gra2tvDo0SM0Go2eltKOTqeDVquFZrMJnucRCoXg9/sRi8WQSqXAcRz29vYGWgS3243R0VFMTU1BkiRcuHABs7Oz4Hke+XwepVIJrVYLwWAQHMdheHgYExMTqNVqKJfL0DRtoGtEo1EEg0EMDQ2xn/1+P7N0gUAAXq8Xpmn29J44jkMmk8H8/DxSqRRGR0chSRIsy4IgCLAsC5FIBKIoQtM0lEolrK+vwzAMNJvNgTwdl8sFv9+PYDAIQRCOJbdeCIVCGBkZQSQSwfz8PJaXl+HxeKAoCmq1GmRZxubmJorFIsbGxvDBBx+A4zjwPI9cLod6vY5Go3HsfN1uN0ZGRnDp0iWIooh0Og2v1wu/349oNAq3243Z2Vm43W5Uq1WsrKxgZWUFzWYT9Xp9IM8BeEac5EFkMhlMTEzA4/HA5XIhFovh6dOn2NzcxNra2sBrw/M8UqkUYrEYpqamMD4+jmw2C1VV4ff7oWkaAoHAQPvX5XJhaGgIr7/+OpLJJGZmZuDxeNDpdGAYBiOWixcv4o033sDOzg6LAHqB4zhIkoR0Oo2RkRGIosiIzOPxwLIsxONxTE9PIxqNYnd3F7u7u30902PX5FSfwrONMD09jXfffReRSASZTAaiKKLT6SAYDKLRaOCVV17BT3/6UwDA3//+d1y/fh2yLGNtbW1gwmk0GjAMA4IgIBaLIRqNQpZlTExMIBQK4cmTJwM9MJ7nsbCwgKtXr0KSJCwuLmJ8fBz5fB43b95EoVDA6Ogo5ubmIEkSZmZmsL+/D1mW8c033wxEOB6PB8PDwxgeHsbU1BRSqRQkSUKn00Gn04Gu65AkiRFGvV7vub6Tk5N4++23EYvFMDs7i6GhIQBAu91mZGxZFjRNw+7uLu7cuQNN06Cq6kCEw3EcAoEARFFEKBSC2+3u+5mj4HkegUAA4XAY0WgUkiSB4zhomgbLsmAYBjRNg6IocLlcGB4ehsfjQSwWY8R7XFhJ6zAzM4OrV68y8vZ6vQCAZDKJcDiMsbExXLlyBY1GA3/605+gqio0TUOxWByIcFwuF3ieh8/ng9/vRyAQQDAYhNfrhSiKqNVqqNfr8Pl8J1obr9eLiYkJTE9P49y5c1hYWMDExAQqlQoikQgURUEsFhuYcARBQDKZRDqdRigUgsvlQrvdZsaL4ziIoojh4WG4XC6Ew+G+Hhk5DiQvpNNpBAIBNBoNCILAntnly5dRLpdx+/Zt7O/vny3hkIUSBAGSJCEUCoHjODSbTTSbTWZlPR4PUqkUXC4X4vE4wuEwTNOEx+PpOb49VHC73ezfPM/D6/WyL4/H81xodNx4brcboVAIqVQKoigiEokwq16tVlEqlRhhut1u+P1+RCIRWJYFnh9smTiOY1YyEonA5/PB7XYzwnG73X3na7/XYDCIWCwGURTh8/nY5mm322i328xjokPP8zxbr0HWl+d5dsD8fj8jHJpvq9ViG4t+NwgMw8DKygpWV1dxcHCAlZUVlMtlxGIxlEoldr2JiQmoqord3V2Uy+Wu83S73WyfBQIBNqd2uw3LspjHF4/HYVkW24/tdrsvgdL+Iu93fn4ekiRhdHSUPXPLstBsNmGa5sCHjNbX4/Gw/UDeriAIqNfr8Hg8bP/2gsfjgSAI8Hq9zPNKp9OwLAsPHz5Es9nE1tYWtra24PV6GdGTbtbv3r1eLwsjyeiQIWs0GozIIpEI2u0201EHCYO74cSEIwgCwuEwIpEIEokEotEo2u02/v3vf+PRo0dQFAW5XA6apuHixYvMWliWhWQyyQ7zcXC5XAgGgwgGg8zNy2azCIVCzMKQLlAsFlGr1XreOD2wYDDIPA+/3w9FUVAul7G1tYUvvvgCuVwOqqoiFAoxhk8kEkz4G3Rt5ufn8dprryGTySAajQIAdF2HLMtQVRWFQoGFlN0seyAQYIdmcnIS09PT8Hq9KJVK2N3dhaIoWF9fh6ZpOH/+PF599VVwHNdX3OY4jm1wWt9wOIzl5WWcO3cOY2NjCIfDJ55vN+i6jps3b+LatWvQdZ2JjeFwGBcvXoQoigiHw1haWoIsy6jX688RDj23cDjMQmmO47C/v49KpYJCoYDbt2+jWCxicXERV65cYWHWSy+9xMLgbkRGcLvd8Pl88Hq9OH/+PN5//33E43GcP38ePM+zg0dC6SCJCZfLhWg0yry9xcVFLC8vI5FIIBgMsvXZ29tDuVyGoig996/P50MikUAgEMDExASWlpaQSqVw+/Zt/Otf/4IsyyyMFAQBmqah0+mgVCr1HDuZTGJychLhcBhzc3OYnp5GMBhEqVTCnTt3UKlUsLq6CkVREI1GWQJja2sL0WgUhmGgXq8PvCcIJyYcv9+PZDKJaDSKRCIBURRRLpdx48YN/O1vf0O9XkepVEKj0YCmaZiamkIsFkOr1UIymex7gIlwEokEUqkUhoeHkc1m4fF44PV6Wcx6cHCAUqkEXdd7PjCv14twOIxwOIyhoSFMT0+j3W7j/v37yOVy2NjYwBdffIGtrS00Gg2k02lIkoRWq4V4PM50jkHXZmFhAW+99RYCgQAikQiAZ9me3d1dyLKMQqEARVFgGEbXeRMxiqKIyclJTE1NwbIs3Lp1CxsbG9je3sY//vEP7O3t4b333kM2m0UkEulLOGTNeJ5HLBZDMpmEJElYXl7GwsICJElihHOS+ZInavfcWq0WZFlGPp9HvV6HoihM2CTvl8I50ud6PTcSodvtNorFIntuH3/8MR49eoSrV6+ybGk0GsXc3ByKxSI2NjaOXQ/ynkgPEkURyWQS8XgcwWCQ3Qt5UxTG9gMRzsjICNLpNBYWFnDp0iVm9IBnhLO7u4tSqdQ3o0aGwufzQRAEhEIhhEIhAGBGs1gsolAoQBAElMtlqKrKzgXP813nn0wmcfnyZUiShLGxMYyNjbH13dzcxP7+Pm7cuIH9/X28+eab+PDDDxEIBDA0NMR0Q8uy/vsJh8IpEpboorquQ1XVQ8xHPxuGAcuyntuYdtCi8jyPRCKB4eFhZDIZhEIheDwe8DzPPkf6R61Wg2maPR+YPRQgN7LT6aBerzMrbhdaTdMcWGgk11kQBPj9fsTjcUQiEXZAyF2mMIjCgV7hiT2UdLvd4HkelmWhWq2yVDJpFEQyg4SVHo+H6RK0vpIkIRaLsTnbQ6pB5+v3+5FOpxGLxQ5pBoZhoFqtotlsMs+A1rfRaKBer0PTNGia1nXTHr3m0XE1TYOu60wYpvCKvo7zRkir4Xkeo6OjOH/+PERRxKVLlzA2NoZIJIJwOAyO4w4lLez30Q2UrfN6vcwzj8fj8Pv9z90LnRvLsvqGaUQ4dAYI9DwbjQbz/C3Lwu7uLh48eADLsiCKIl555RVomoadnR3IsnxoXNpjdi1IURQcHBzg4OCAERetNe0xv9+PVqs1kK753Pqf9APkhvp8PtTrdezt7aFYLKJYLKJSqbCFpEO9v7/PhN9exEDKeyQSweLiIi5cuMAyH+RO0wHWNA3b29vMCvcat9VqsevTvJrNJnK5HO7evYtCocBiXXKf7fVChmF03WhkHT0eD1566SVWJzI3N8eU/kG1n36o1+usponqKwzDgMvlYpkqQRB6jhGLxTA3N4doNIpLly7h0qVLLJUtiiIj/JOCslQUXnMch3a7zTJURF5EGPQsSEiuVqtdCafbczNNE0+fPsXKygp2d3fZc6K/rdfrKBaLrJaq24EgXcXn82F+fh7vv/8+kskkxsbGMDU1xXQ3OlxkOJvNZk9yyGazeO211yCKIqtPI01tf3+fPSc6rLTP+hlMOm+U5aR5+Xw+RKNRWJYFr9cLl8sF0zTx+PFjJviOjY1hfn4ehUKBPQ/7+pJDUKlU4Ha7oWka7ty5g42NDZaIqNVqyOVyuH37NgKBADRNQzabZWSvqupA+4RwKsIh15yKg8hToPiR0Gw2D91kL1CNQSKRwGuvvYbXX3+dpZMpKwGAEVmpVEKhUHjumkdBzE31HsCzTZTP55HL5VCpVJinQEKk/QAcZy3J8pD4+eqrryIWi2FkZIS5vC8KjUYDuVwOd+7cYfdKG49c9X5CfCgUQjabRTKZxCuvvIK33nrrVARzFOTxer3eQx6d3Tsi2MMvIpDjxMduz82yLJTLZezs7KBYLB56buQ5qarK9ItuhaYcx7Gkg12P9Hq9TLOhuZKXR/M4jnBcLhdSqRQuXryIdDqNxcVFLC4uotlssmJBl8vFxqZ91o/EaGxaX3sCotv6kudUr9eZd0xC9VHjZ/fcdF2H2+2GqqrY2NjAN998c6i2h8JTCgkTicRz53JQnJhwKPYlwiGy6cbUtFj2OPI41Ot1FAoFGIaBtbU1VhcxPT2NTCZz6G9p0/I831flp2waHcpexX7dfnccmdnjfzsxttttpuxTGGiaJmq12kAhoGmaqFarcLvd7MDYwyz7OpqmCVVVWYiQSqXg8/lgGMZzGQpa32azifX1dcRiMZaJEwQBHo8H4XCYWWXyYk+TKj8OpAFIkoSdnR2WCelG6N3CDiKpo56BfU/S/I/L1lEISGn8druNer2O7777Dvfv32flHtPT02g0GiiVStjZ2UGpVEKtVut6X51OB6qqssRDq9Vi358+fYpKpQLTNDEzMwPgee+tFwRBQCaTQSwWQygUgmEYUBQF+XweW1tbODg4QKVSYV4khYxEUMeBSNowDEYkRGZHDQGVXgDPNMZAIIB2u302hENZJp/PxxhRlmUoitL1b0nsIjY9DoVCAbdu3YLH48GDBw+QSCQwNDSEjz766DnCoVSp3+/vG7bYwwbSGF4EqEYjGAxCkiSWWTJNE+VyGV6vF5FIBB6PB/V6Hfl8HgcHB6hWqz0Jh3SPcrn83Eai+p1Go4FOp4NqtYrt7W3UajUIgoDl5WVUKhXouo6Dg4ND49L6+nw+5HI53Lx5E5FIBEtLS8hms4jH45ifn4coivB6vSzDNmhh2iAgwonH40wwPs7K06Gk4jPg2SHRdR2VSgXVapX9nuM4ts/8fj8EQYBhGF0PHB1gSZIQjUbRarVQr9exsbGBlZUVAMCPfvQjDA0NwTRNHBwc4OnTpyiXyz0TFI8fP8Zf/vIXVqpAXkUgEIDP58NLL72EpaUlZDIZNBoNKIrCMnS99oMgCKw+JhwOs6wstbUcHBygXC6zMgDyhuwaYjdQAW6r1UIgEGBkQ0RoN2y1Wo1JD+fOncPQ0BBUVe0bxnfDqUVjt9uNZrPJBLyjTE1WmaxOPyav1+usEK5cLmN7exvlchnlchmdTue58nCqaSHB9LiHRgeVahl6wV4a3y8jQR4OeQIUZlJsDIA9MNrU5OH0gr0QrtFosDHsQj3dL3lDdrH9uKwarS/HcbAsC4qisPoQqq2g61LY8aI8nKN1VORp9qpvobDBXndj93CazSZ7RnTQ7N+PmzdZ9mazyXQN0jFkWQbHcYdCMXvLRC/irVarqFarh35HtTOSJCGRSDBD0W632T30S7XTfO2hPa1No9F4bgxaEyIQWreja9xut1nN3NHPHz2rFKbR/QcCgRPVp9lx4k/YYz+v18sqJUkPIDJwu92HrD+p3oPErf1AglmtVuurlNt1JCK0bkWEFNNT0V6hUGAZoW4VwTSuYRh4+PAhsxSU/UkkEnj55ZdZaDg+Po5wOAxJkgb2GEhTcLlcGB0dxYULF6AoCjY3N6FpGtORiOh0XUetVutJ7qSBkUeqKAo0TWOFXcCzDVar1aDr+sAZu+NAc3S73axUgAoqi8UiqtVq1/WlEJK0KTpwXq8XoVCIETzVdxEZK4qCnZ2dY5+bqqpYW1uD3+/H5uYmvvnmG9YWQVZb13VGjJIkseJVv9//vfsBae+FQiHout5Xe9N1HU+ePIGqqqyK2+fzodVqoVqtPleyQIkPCsmJlI7OmVLzoVAI586dw8TEBBRFQSKRQCgUYoTWbrdZqUY4HGZlI1TYeFKcinAajQY7oJlMhv0M/Me99Xg8iEQiGBoaQiwWg67rzF0bpICqFwRBQCqVQqfTQblc7nmAa7UaisUiy4xQiEL6C7nhpmkiGo0inU4jGAziyZMn+O6771g25SioB4jjOJRKJXzxxRcIBAKYnZ3F8PAwZmZmMDY2hlgshng8joWFBaiqis8//3ygniW7NXe5XJibmwMA5HI5lEolaJp2KINBXgvpab3GrVarqNVqMAwD5XIZsiyzKnDgGZmSy98vu9gPtDGpkC8UCrFC0EqlAk3TupKa/d6AZ96eaZrw+/1sw4+MjIDneUxMTDD9rFgsYnV1FbVa7TmPA3iW4SQtxu65UJ1XNBpFvV5n+ls4HEY8Hker1XohIjsAFm43Gg1GYsehVqvh6dOnUBQFMzMzzPuk8JLWjzwae+lBs9lk63b0zFGvWzAYxFtvvYULFy5AlmXcuHEDkiSxc9psNhGNRjE9PQ1JkjA+Ps7aU84kpKKbarVaTM8hwZTcfvo3facms24u4GlAoRpZzl4PjFxHct/JRae5G4bBCIeI0uv1wrIs6LoOXde7egz2GJcOjCAITMG3awxk3e0pzEFAc+90OqyXTFVVpguQd8NxHDMEg1TE0txpXY5r9qTwjb66EY89JW3P8FDI6/P5EIvFIAgCIpEIG4fCJXv7xFF0C3EpM0g6HtWjAP9pQ6Dw8ThPr9v1jnbc2yUB2tun0bK6hWT22pp+ISsdenuTK+2HeDwOAGyfUlidTqfZ/rCXqRwdl85wp9Nh55Uq0Omz5I1R9TS1A51W1zsx4TSbTZZ7p8yI3+/H5OQkZmdnEQqFMDo6ilAohLm5OVZ3sLOzgy+//JKlLc8KdvGRUqqtVgvpdJoVRdErCEZHR+FyuVjIUSgUWOHioCDrQvE6AJa5ImsziMfQbreRz+fx7bffMks/MzODYDCIcrmMqakpLC0tMWGaQi1VVbta9m6g8IoKvOiAkrhr7z2juouj3hPVRJEeQh4kEUMmk8Ebb7zBGgTtrj597yUak+5GafexsTHous7ea0RiMVl6CjEGbUUgUHaH9DDgGTEIgsDC95N6OPbP2wsrqYp6EA+HMmUej4e9n8Y0TWSzWbz//vtQFAX7+/vY29uD1+vF8vIyZmdn0Ww2WcVwr2Ze+z5zuVy4cOECRkZGYBgGKxmhlgq/3498Po/V1VVWenBSnJhwSKgEnj2kZDKJYDCIyclJFAoFxONxLC0tsaZDQRBYwdaXX37JcvtnBbs4RilOn8/HekMorKC41+VysXoOqvUYNKSgokKyRHZNZFDvwz5v2giiKGJmZobpQ+12G+VyGePj46x9QlVVbG1tHQoZBrlGrVaDoijQdZ3NjVKfuq6zdgGqIzlKOLSupCHRWpEHKkkSlpaWMDU1hUwmw/q+7F7ncXOjtQTAdLbx8XHWFjE8PIxAIIBisYjt7W2oqnqocvwkoFDF7nVQ6E3rcVKR1OVyscZIO+FQCUKz2exLYpREIJ2J9lY6ncalS5dQr9exubnJGmKpqFOWZZRKJWxubvZMv9v3GT2rbDbLXvTWaDTY62cA4Pr161hdXWV9YCfFqTQcWoRarQZVVRlTp1IpRKNR5vI3m01WW6MoysDvabGX1jcaDSauUfOhPZQbdBNQzLu/v8/SllSrQClM6v8ir2bQ/hn7vO3Nfva0rz2D0i+zRmORlQHAQisS46lVhFKblE4fpFzefg17CGLXpYh8ad7HdTZTjQbP81BVFYqisJ60xcVFjI6OMhe9VquxSlhK5Q4yR2pDofWjTnwqIKTxSJc4qeZkL0i0h052He202iOdFyJru8ZyEgPU6Tx7vcnTp08ZGRMhiqLI9KxOp4NisQhZlpk+Zw/vu41LOieNSxIInQu3282ITlVVVnt3moTCqUIqEhPv37/P3u+STCaRzWaZeNXpdLC2toa7d+9CURRsbW0N/PpLSpVWq1U8efIEq6urCIfDrIo3GAxibGwMgiAgl8sNFE+apomvv/4auq4jEong4sWL7CVL1Iqwvr6Or776CrIsY3t7+8QbrNVqQVEUljnZ29tDLBZjmSq3241wOAxBENjDPe4arVYL29vbuHnzJmsbiEQiaLVa7D07+Xwe169fR7VaxYMHD1hYMSjhmKbJNhq9EIte4yGKImusFEWRvcbjKKrVKlqtFiqVCtbX17G6ugqPx4N33nkHb7755iHt4vHjx3j48CGq1Sru3bs30H6wLAtra2u4du0ae3Xp/Pw8a+Atl8t4+PAhPv30U5TLZTx+/PhEr1kl2OvLyIi1222oqor9/X0WXp8E1MRKr2eh2iqqcqd/D0KQnU4HuVwO165dgyiKGB8fx9TUFEKhEKvxsSwLjx8/xj//+U9UKhXcvXsXa2trME3z2GyuZVn47rvvoCgKMpkM04Ds2eaDgwN8++230DQNn3/+Oe7du8fqoU6KExMOiVCmaWJ7extff/01EokErly5gvn5eei6jp2dHdaL8dlnn51YsyFR0x4GxeNxpFIpAP8RZ6mzfBDCabVaePz4MfL5PGKxGBKJBJLJJCMwKqrL5XIoFosolUontpTkRZmmiUqlwr6oSZJSq16vl1mM4win3W6jVCrBNE3IsoyXX36ZCYPUs0TrXywWsbOzw7yyk8xXURS0Wi1Eo1Hk83mWrSLtjTwq0zS7epP2dyAVi0Xs7+8jFothfn4eo6OjzNhQZ/NXX33Feu8GmWu73cbe3h7u3buHdDqNyclJjIyMoFKpYHd3F5VKBdvb27h//z57S8Fpyi7snhyFPrQHSeM6aWc07QeXy8V6u3Rdh6IoKJVKA73tgNDpdFCpVPDtt98iHA6zN2qSPJBMJqHrOra2trC5uYmDgwNsb29jf3+/7xz39vawt7eH4eFhXLlyhe0zqs+qVqtYW1tDuVzG2toaNjc3T7wWhFP/Xxu6dRDbFf6zwkmvZS+M6oZ+LRgnucaLQK+ucvt//z7XfJHzPYqjz+dFXKtbe8qLWIf/Lpz1nP43rgHB1fnfPDsHDhz8n4Lz/6Vy4MDBmcEhHAcOHJwZHMJx4MDBmcEhHAcOHJwZHMJx4MDBmcEhHAcOHJwZHMJx4MDBmcEhHAcOHJwZHMJx4MDBmeG/AHft4B+lY7AuAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ], + "source": [ + "digits = datasets.load_digits()\n", + "images, labels = digits.data, digits.target\n", + "\n", + "images = images[np.where((labels == 0) | (labels == 1))]\n", + "labels = labels[np.where((labels == 0) | (labels == 1))]\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=12, figsize=(3, 1))\n", + "\n", + "for i, ax in enumerate(axes.flatten()):\n", + " ax.imshow(images[i].reshape((8, 8)), cmap=\"gray\")\n", + " ax.axis(\"off\")\n", + "\n", + "plt.tight_layout()\n", + "plt.subplots_adjust(wspace=0, hspace=0)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ktE3yYFPLDIG" + }, + "source": [ + "For convenience, we create a `load_digits_data` function that will make\n", + "random training and testing sets from the `digits` dataset from\n", + "`sklearn.dataset`:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": { + "id": "dHhMKGlqLDIH" + }, + "outputs": [], + "source": [ + "def load_digits_data(num_train, num_test, rng):\n", + " \"\"\"Return training and testing data of digits dataset.\"\"\"\n", + " digits = datasets.load_digits()\n", + " features, labels = digits.data, digits.target\n", + "\n", + " # only use first two classes\n", + " features = features[np.where((labels == 0) | (labels == 1))]\n", + " labels = labels[np.where((labels == 0) | (labels == 1))]\n", + "\n", + " # normalize data\n", + " features = features / np.linalg.norm(features, axis=1).reshape((-1, 1))\n", + "\n", + " # subsample train and test split\n", + " train_indices = rng.choice(len(labels), num_train, replace=False)\n", + " test_indices = rng.choice(\n", + " np.setdiff1d(range(len(labels)), train_indices), num_test, replace=False\n", + " )\n", + "\n", + " x_train, y_train = features[train_indices], labels[train_indices]\n", + " x_test, y_test = features[test_indices], labels[test_indices]\n", + "\n", + " return (\n", + " jnp.asarray(x_train),\n", + " jnp.asarray(y_train),\n", + " jnp.asarray(x_test),\n", + " jnp.asarray(y_test),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E348WVjiLDIH" + }, + "source": [ + "To optimize the weights of our variational model, we define the cost and\n", + "accuracy functions to train and quantify the performance on the\n", + "classification task of the previously described QCNN:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "id": "N-MmpJZbLDIH" + }, + "outputs": [], + "source": [ + "@jax.jit\n", + "def compute_out(weights, weights_last, features, labels):\n", + " \"\"\"Computes the output of the corresponding label in the qcnn\"\"\"\n", + " cost = lambda weights, weights_last, feature, label: conv_net(weights, weights_last, feature)[\n", + " label\n", + " ]\n", + " return jax.vmap(cost, in_axes=(None, None, 0, 0), out_axes=0)(\n", + " weights, weights_last, features, labels\n", + " )\n", + "\n", + "\n", + "def compute_accuracy(weights, weights_last, features, labels):\n", + " \"\"\"Computes the accuracy over the provided features and labels\"\"\"\n", + " out = compute_out(weights, weights_last, features, labels)\n", + " return jnp.sum(out > 0.5) / len(out)\n", + "\n", + "\n", + "def compute_cost(weights, weights_last, features, labels):\n", + " \"\"\"Computes the cost over the provided features and labels\"\"\"\n", + " out = compute_out(weights, weights_last, features, labels)\n", + " return 1.0 - jnp.sum(out) / len(labels)\n", + "\n", + "\n", + "def init_weights():\n", + " \"\"\"Initializes random weights for the QCNN model.\"\"\"\n", + " weights = pnp.random.normal(loc=0, scale=1, size=(18, 2), requires_grad=True)\n", + " weights_last = pnp.random.normal(loc=0, scale=1, size=4 ** 2 - 1, requires_grad=True)\n", + " return jnp.array(weights), jnp.array(weights_last)\n", + "\n", + "\n", + "value_and_grad = jax.jit(jax.value_and_grad(compute_cost, argnums=[0, 1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xl7p4Hz_LDIH" + }, + "source": [ + "We are going to perform the classification for training sets with\n", + "different values of $N$. Therefore, we define the classification\n", + "procedure once and then perform it for different datasets. Finally, we\n", + "update the weights using the `pennylane.AdamOptimizer`{.interpreted-text\n", + "role=\"class\"} and use these updated weights to calculate the cost and\n", + "accuracy on the testing and training set:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "id": "_08Zw5jALDIH" + }, + "outputs": [], + "source": [ + "def train_qcnn(n_train, n_test, n_epochs):\n", + " \"\"\"\n", + " Args:\n", + " n_train (int): number of training examples\n", + " n_test (int): number of test examples\n", + " n_epochs (int): number of training epochs\n", + " desc (string): displayed string during optimization\n", + "\n", + " Returns:\n", + " dict: n_train,\n", + " steps,\n", + " train_cost_epochs,\n", + " train_acc_epochs,\n", + " test_cost_epochs,\n", + " test_acc_epochs\n", + "\n", + " \"\"\"\n", + " # load data\n", + " x_train, y_train, x_test, y_test = load_digits_data(n_train, n_test, rng)\n", + "\n", + " # init weights and optimizer\n", + " weights, weights_last = init_weights()\n", + "\n", + " # learning rate decay\n", + " cosine_decay_scheduler = optax.cosine_decay_schedule(0.1, decay_steps=n_epochs, alpha=0.95)\n", + " optimizer = optax.adam(learning_rate=cosine_decay_scheduler)\n", + " opt_state = optimizer.init((weights, weights_last))\n", + "\n", + " # data containers\n", + " train_cost_epochs, test_cost_epochs, train_acc_epochs, test_acc_epochs = [], [], [], []\n", + "\n", + " for step in range(n_epochs):\n", + " # Training step with (adam) optimizer\n", + " train_cost, grad_circuit = value_and_grad(weights, weights_last, x_train, y_train)\n", + " updates, opt_state = optimizer.update(grad_circuit, opt_state)\n", + " weights, weights_last = optax.apply_updates((weights, weights_last), updates)\n", + "\n", + " train_cost_epochs.append(train_cost)\n", + "\n", + " # compute accuracy on training data\n", + " train_acc = compute_accuracy(weights, weights_last, x_train, y_train)\n", + " train_acc_epochs.append(train_acc)\n", + "\n", + " # compute accuracy and cost on testing data\n", + " test_out = compute_out(weights, weights_last, x_test, y_test)\n", + " test_acc = jnp.sum(test_out > 0.5) / len(test_out)\n", + " test_acc_epochs.append(test_acc)\n", + " test_cost = 1.0 - jnp.sum(test_out) / len(test_out)\n", + " test_cost_epochs.append(test_cost)\n", + "\n", + " return dict(\n", + " n_train=[n_train] * n_epochs,\n", + " step=np.arange(1, n_epochs + 1, dtype=int),\n", + " train_cost=train_cost_epochs,\n", + " train_acc=train_acc_epochs,\n", + " test_cost=test_cost_epochs,\n", + " test_acc=test_acc_epochs,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Jupsq2nDLDIH" + }, + "source": [ + "::: {.note}\n", + "::: {.title}\n", + "Note\n", + ":::\n", + "\n", + "There are some small intricacies for speeding up this code that are\n", + "worth mentioning. We are using `jax` for our training because it allows\n", + "for\n", + "[just-in-time](https://jax.readthedocs.io/en/latest/jax-101/02-jitting.html)\n", + "(`jit`) compilation. A function decorated with `@jax.jit` will be\n", + "compiled upon its first execution and cached for future executions. This\n", + "means the first execution will take longer, but all subsequent\n", + "executions are substantially faster. Further, we use `jax.vmap` to\n", + "vectorize the execution of the QCNN over all input states, as opposed to\n", + "looping through the training and test set at every execution.\n", + ":::\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "szuIyWDTLDIH" + }, + "source": [ + "Training for different training set sizes yields different accuracies,\n", + "as seen below. As we increase the training data size, the overall test\n", + "accuracy, a proxy for the models\\' generalization capabilities,\n", + "increases:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "id": "BqiDPAv0LDIH" + }, + "outputs": [], + "source": [ + "n_test = 100\n", + "n_epochs = 100\n", + "n_reps = 100\n", + "\n", + "\n", + "def run_iterations(n_train):\n", + " results_df = pd.DataFrame(\n", + " columns=[\"train_acc\", \"train_cost\", \"test_acc\", \"test_cost\", \"step\", \"n_train\"]\n", + " )\n", + "\n", + " for _ in range(n_reps):\n", + " results = train_qcnn(n_train=n_train, n_test=n_test, n_epochs=n_epochs)\n", + " results_df = pd.concat(\n", + " [results_df, pd.DataFrame.from_dict(results)], axis=0, ignore_index=True\n", + " )\n", + "\n", + " return results_df\n", + "\n", + "\n", + "# run training for multiple sizes\n", + "train_sizes = [2, 5, 10, 20, 40, 80]\n", + "results_df = run_iterations(n_train=2)\n", + "for n_train in train_sizes[1:]:\n", + " results_df = pd.concat([results_df, run_iterations(n_train=n_train)])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sLca_WTyLDIH" + }, + "source": [ + "Finally, we plot the loss and accuracy for both the training and testing\n", + "set for all training epochs, and compare the test and train accuracy of\n", + "the model:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 504 + }, + "id": "Qr1cGcVXLDIH", + "outputId": "10c313e9-809f-4aaa-c91f-7896d065e13a" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1650x500 with 3 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# aggregate dataframe\n", + "df_agg = results_df.groupby([\"n_train\", \"step\"]).agg([\"mean\", \"std\"])\n", + "df_agg = df_agg.reset_index()\n", + "\n", + "sns.set_style('whitegrid')\n", + "colors = sns.color_palette()\n", + "fig, axes = plt.subplots(ncols=3, figsize=(16.5, 5))\n", + "\n", + "generalization_errors = []\n", + "\n", + "# plot losses and accuracies\n", + "for i, n_train in enumerate(train_sizes):\n", + " df = df_agg[df_agg.n_train == n_train]\n", + "\n", + " dfs = [df.train_cost[\"mean\"], df.test_cost[\"mean\"], df.train_acc[\"mean\"], df.test_acc[\"mean\"]]\n", + " lines = [\"o-\", \"x--\", \"o-\", \"x--\"]\n", + " labels = [fr\"$N={n_train}$\", None, fr\"$N={n_train}$\", None]\n", + " axs = [0,0,2,2]\n", + "\n", + " for k in range(4):\n", + " ax = axes[axs[k]]\n", + " ax.plot(df.step, dfs[k], lines[k], label=labels[k], markevery=10, color=colors[i], alpha=0.8)\n", + "\n", + "\n", + " # plot final loss difference\n", + " dif = df[df.step == 100].test_cost[\"mean\"] - df[df.step == 100].train_cost[\"mean\"]\n", + " generalization_errors.append(dif)\n", + "\n", + "# format loss plot\n", + "ax = axes[0]\n", + "ax.set_title('Train and Test Losses', fontsize=14)\n", + "ax.set_xlabel('Epoch')\n", + "ax.set_ylabel('Loss')\n", + "\n", + "# format generalization error plot\n", + "ax = axes[1]\n", + "ax.plot(train_sizes, generalization_errors, \"o-\", label=r\"$gen(\\alpha)$\")\n", + "ax.set_xscale('log')\n", + "ax.set_xticks(train_sizes)\n", + "ax.set_xticklabels(train_sizes)\n", + "ax.set_title(r'Generalization Error $gen(\\alpha) = R(\\alpha) - \\hat{R}_N(\\alpha)$', fontsize=14)\n", + "ax.set_xlabel('Training Set Size')\n", + "\n", + "# format loss plot\n", + "ax = axes[2]\n", + "ax.set_title('Train and Test Accuracies', fontsize=14)\n", + "ax.set_xlabel('Epoch')\n", + "ax.set_ylabel('Accuracy')\n", + "ax.set_ylim(0.5, 1.05)\n", + "\n", + "legend_elements = [\n", + " mpl.lines.Line2D([0], [0], label=f'N={n}', color=colors[i]) for i, n in enumerate(train_sizes)\n", + " ] + [\n", + " mpl.lines.Line2D([0], [0], marker='o', ls='-', label='Train', color='Black'),\n", + " mpl.lines.Line2D([0], [0], marker='x', ls='--', label='Test', color='Black')\n", + " ]\n", + "\n", + "axes[0].legend(handles=legend_elements, ncol=3)\n", + "axes[2].legend(handles=legend_elements, ncol=3)\n", + "\n", + "axes[1].set_yscale('log', base=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3Jp181qLLDIH" + }, + "source": [ + "------------------------------------------------------------------------\n", + "\n", + "The key takeaway of this work is that some quantum learning models can\n", + "achieve high-fidelity predictions using a few training data points. We\n", + "implemented a model known as the quantum convolutional neural network\n", + "(QCNN) using PennyLane for a binary classification task. Using six\n", + "qubits, we have trained the QCNN to distinguish between handwritten\n", + "digits of $0$\\'s and $1$\\'s. With $80$ samples, we have achieved a model\n", + "with accuracy greater than $97\\%$ in $100$ training epochs. Furthermore,\n", + "we have compared the test and train accuracy of this model for a\n", + "different number of training samples and found the scaling of the\n", + "generalization error agrees with the theoretical bounds obtained in[^1].\n", + "\n", + "References\n", + "==========\n", + "\n", + "About the authors\n", + "=================\n", + "\n", + "[^1]: Matthias C. Caro, Hsin-Yuan Huang, M. Cerezo, Kunal Sharma, Andrew\n", + " Sornborger, Lukasz Cincio, Patrick J. Coles. \\\"Generalization in\n", + " quantum machine learning from few training data\\\"\n", + " [arxiv:2111.05292](https://arxiv.org/abs/2111.05292), 2021.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.17" + }, + "colab": { + "provenance": [] + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}