Datasets
Models
Downloads: 1
[404218]:
/
Code /
PennyLane /
Quantum Parameters II /
CZ 3Layers DiffAdjoint A100 Lightning.gpu Kernel 51.65s kkawchak.ipynb
1278 lines (1278 with data), 141.6 kB
{
"cells": [
{
"cell_type": "code",
"execution_count": 156,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "U9bYOT8V3fHC",
"outputId": "fe4a62a6-f0fa-4a02-ab6d-5387c125743d"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Time in seconds since beginning of run: 1699853069.113393\n",
"Mon Nov 13 05:24:29 2023\n"
]
}
],
"source": [
"# This cell is added by sphinx-gallery\n",
"# It can be customized to whatever you like\n",
"%matplotlib inline\n",
"# !pip install pennylane custatevec-cu11 pennylane-lightning-gpu\n",
"import time\n",
"seconds = time.time()\n",
"print(\"Time in seconds since beginning of run:\", seconds)\n",
"local_time = time.ctime(seconds)\n",
"print(local_time)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "1wO15tC53fHE"
},
"source": [
"::: {#kernel_based_training}\n",
":::\n",
"\n",
"Kernel-based training of quantum models with scikit-learn\n",
"=========================================================\n",
"\n",
"::: {.meta}\n",
":property=\\\"og:description\\\": Train a quantum machine learning model\n",
"based on the idea of quantum kernels. :property=\\\"og:image\\\":\n",
"<https://pennylane.ai/qml/_images/kernel_based_scaling.png>\n",
":::\n",
"\n",
"::: {.related}\n",
"tutorial\\_variational\\_classifier Variational classifier\n",
":::\n",
"\n",
"*Author: Maria Schuld --- Posted: 03 February 2021. Last updated: 3\n",
"February 2021.*\n",
"\n",
"Over the last few years, quantum machine learning research has provided\n",
"a lot of insights on how we can understand and train quantum circuits as\n",
"machine learning models. While many connections to neural networks have\n",
"been made, it becomes increasingly clear that their mathematical\n",
"foundation is intimately related to so-called *kernel methods*, the most\n",
"famous of which is the [support vector machine\n",
"(SVM)](https://en.wikipedia.org/wiki/Support-vector_machine) (see for\n",
"example [Schuld and Killoran (2018)](https://arxiv.org/abs/1803.07128),\n",
"[Havlicek et al. (2018)](https://arxiv.org/abs/1804.11326), [Liu et al.\n",
"(2020)](https://arxiv.org/abs/2010.02174), [Huang et al.\n",
"(2020)](https://arxiv.org/pdf/2011.01938), and, for a systematic summary\n",
"which we will follow here, [Schuld\n",
"(2021)](https://arxiv.org/abs/2101.11020)).\n",
"\n",
"The link between quantum models and kernel methods has important\n",
"practical implications: we can replace the common [variational\n",
"approach](https://pennylane.ai/qml/glossary/variational_circuit.html) to\n",
"quantum machine learning with a classical kernel method where the\n",
"kernel---a small building block of the overall algorithm---is computed\n",
"by a quantum device. In many situations there are guarantees that we get\n",
"better or at least equally good results.\n",
"\n",
"This demonstration explores how kernel-based training compares with\n",
"[variational\n",
"training](https://pennylane.ai/qml/demos/tutorial_variational_classifier.html)\n",
"in terms of the number of quantum circuits that have to be evaluated.\n",
"For this we train a quantum machine learning model with a kernel-based\n",
"approach using a combination of PennyLane and the\n",
"[scikit-learn](https://scikit-learn.org/) machine learning library. We\n",
"compare this strategy with a variational quantum circuit trained via\n",
"stochastic gradient descent using\n",
"[PyTorch](https://pennylane.readthedocs.io/en/stable/introduction/interfaces/torch.html).\n",
"\n",
"We will see that in a typical small-scale example, kernel-based training\n",
"requires only a fraction of the number of quantum circuit evaluations\n",
"used by variational circuit training, while each evaluation runs a much\n",
"shorter circuit. In general, the relative efficiency of kernel-based\n",
"methods compared to variational circuits depends on the number of\n",
"parameters used in the variational model.\n",
"\n",
"{.align-center}\n",
"\n",
"If the number of variational parameters remains small, e.g., there is a\n",
"square-root-like scaling with the number of data samples (green line),\n",
"variational circuits are almost as efficient as neural networks (blue\n",
"line), and require much fewer circuit evaluations than the quadratic\n",
"scaling of kernel methods (red line). However, with current\n",
"hardware-compatible training strategies, kernel methods scale much\n",
"better than variational circuits that require a number of parameters of\n",
"the order of the training set size (orange line).\n",
"\n",
"In conclusion, **for quantum machine learning applications with many\n",
"parameters, kernel-based training can be a great alternative to the\n",
"variational approach to quantum machine learning**.\n",
"\n",
"After working through this demo, you will:\n",
"\n",
"- be able to use a support vector machine with a quantum kernel\n",
" computed with PennyLane, and\n",
"- be able to compare the scaling of quantum circuit evaluations\n",
" required in kernel-based versus variational training.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "e-EHd-BN3fHG"
},
"source": [
"Background\n",
"==========\n",
"\n",
"Let us consider a *quantum model* of the form\n",
"\n",
"$$f(x) = \\langle \\phi(x) | \\mathcal{M} | \\phi(x)\\rangle,$$\n",
"\n",
"where $| \\phi(x)\\rangle$ is prepared by a fixed [embedding\n",
"circuit](https://pennylane.ai/qml/glossary/quantum_embedding.html) that\n",
"encodes data inputs $x$, and $\\mathcal{M}$ is an arbitrary observable.\n",
"This model includes variational quantum machine learning models, since\n",
"the observable can effectively be implemented by a simple measurement\n",
"that is preceded by a variational circuit:\n",
"\n",
"{.align-center}\n",
"\n",
"|\n",
"\n",
"For example, applying a circuit $G(\\theta)$ and then measuring the\n",
"Pauli-Z observable $\\sigma^0_z$ of the first qubit implements the\n",
"trainable measurement\n",
"$\\mathcal{M}(\\theta) = G^{\\dagger}(\\theta) \\sigma^0_z G(\\theta)$.\n",
"\n",
"The main practical consequence of approaching quantum machine learning\n",
"with a kernel approach is that instead of training $f$ variationally, we\n",
"can often train an equivalent classical kernel method with a kernel\n",
"executed on a quantum device. This *quantum kernel* is given by the\n",
"mutual overlap of two data-encoding quantum states,\n",
"\n",
"$$\\kappa(x, x') = | \\langle \\phi(x') | \\phi(x)\\rangle|^2.$$\n",
"\n",
"Kernel-based training therefore bypasses the processing and measurement\n",
"parts of common variational circuits, and only depends on the data\n",
"encoding.\n",
"\n",
"If the loss function $L$ is the [hinge\n",
"loss](https://en.wikipedia.org/wiki/Hinge_loss), the kernel method\n",
"corresponds to a standard [support vector\n",
"machine](https://en.wikipedia.org/wiki/Support-vector_machine) (SVM) in\n",
"the sense of a maximum-margin classifier. Other convex loss functions\n",
"lead to more general variations of support vector machines.\n",
"\n",
"::: {.note}\n",
"::: {.title}\n",
"Note\n",
":::\n",
"\n",
"More precisely, we can replace variational with kernel-based training if\n",
"the optimisation problem can be written as minimizing a cost of the form\n",
"\n",
"$$\\min_f \\lambda\\; \\mathrm{tr}\\{\\mathcal{M}^2\\} + \\frac{1}{M}\\sum_{m=1}^M L(f(x^m), y^m),$$\n",
"\n",
"which is a regularized empirical risk with training data samples\n",
"$(x^m, y^m)_{m=1\\dots M}$, regularization strength\n",
"$\\lambda \\in \\mathbb{R}$, and loss function $L$.\n",
"\n",
"Theory predicts that kernel-based training will always find better or\n",
"equally good minima of this risk. However, to show this here we would\n",
"have to either regularize the variational training by the trace of the\n",
"squared observable, or switch off regularization in the classical SVM,\n",
"which removes a lot of its strength. The kernel-based and the\n",
"variational training in this demonstration therefore optimize slightly\n",
"different cost functions, and it is out of our scope to establish\n",
"whether one training method finds a better minimum than the other.\n",
":::\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "a9S8DPih3fHG"
},
"source": [
"Kernel-based training\n",
"=====================\n",
"\n",
"First, we will turn to kernel-based training of quantum models. As\n",
"stated above, an example implementation is a standard support vector\n",
"machine with a kernel computed by a quantum circuit.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "-EVcxqDw3fHH"
},
"source": [
"We begin by importing all sorts of useful methods:\n"
]
},
{
"cell_type": "code",
"execution_count": 157,
"metadata": {
"id": "NM4EoXYV3fHH"
},
"outputs": [],
"source": [
"import numpy as np\n",
"import torch\n",
"from torch.nn.functional import relu\n",
"\n",
"from sklearn.svm import SVC\n",
"from sklearn.datasets import load_iris\n",
"from sklearn.preprocessing import StandardScaler\n",
"from sklearn.model_selection import train_test_split\n",
"from sklearn.metrics import accuracy_score\n",
"\n",
"import pennylane as qml\n",
"from pennylane.templates import AngleEmbedding, StronglyEntanglingLayers\n",
"from pennylane.operation import Tensor\n",
"\n",
"import matplotlib.pyplot as plt\n",
"\n",
"np.random.seed(42)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "uPSsNb3A3fHH"
},
"source": [
"The second step is to define a data set. Since the performance of the\n",
"models is not the focus of this demo, we can just use the first two\n",
"classes of the famous [Iris data\n",
"set](https://en.wikipedia.org/wiki/Iris_flower_data_set). Dating back to\n",
"as far as 1936, this toy data set consists of 100 samples of four\n",
"features each, and gives rise to a very simple classification problem.\n"
]
},
{
"cell_type": "code",
"execution_count": 158,
"metadata": {
"id": "RxclQl753fHH"
},
"outputs": [],
"source": [
"X, y = load_iris(return_X_y=True)\n",
"\n",
"# pick inputs and labels from the first two classes only,\n",
"# corresponding to the first 100 samples\n",
"X = X[:100]\n",
"y = y[:100]\n",
"\n",
"# scaling the inputs is important since the embedding we use is periodic\n",
"scaler = StandardScaler().fit(X)\n",
"X_scaled = scaler.transform(X)\n",
"\n",
"# scaling the labels to -1, 1 is important for the SVM and the\n",
"# definition of a hinge loss\n",
"y_scaled = 2 * (y - 0.5)\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_scaled)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "4ir_h10o3fHI"
},
"source": [
"We use the [angle-embedding\n",
"template](https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.embeddings.AngleEmbedding.html)\n",
"which needs as many qubits as there are features:\n"
]
},
{
"cell_type": "code",
"execution_count": 159,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "_PetxK4z3fHI",
"outputId": "cfe15be1-8043-4c25-b22c-dec1259fe7fe"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"4"
]
},
"metadata": {},
"execution_count": 159
}
],
"source": [
"n_qubits = len(X_train[0])\n",
"n_qubits"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lyB-seGk3fHI"
},
"source": [
"To implement the kernel we could prepare the two states\n",
"$| \\phi(x) \\rangle$, $| \\phi(x') \\rangle$ on different sets of qubits\n",
"with angle-embedding routines $S(x), S(x')$, and measure their overlap\n",
"with a small routine called a [SWAP\n",
"test](https://en.wikipedia.org/wiki/Swap_test).\n",
"\n",
"However, we need only half the number of qubits if we prepare\n",
"$| \\phi(x)\\rangle$ and then apply the inverse embedding with $x'$ on the\n",
"same qubits. We then measure the projector onto the initial state\n",
"$|0..0\\rangle \\langle 0..0|$.\n",
"\n",
"{.align-center}\n",
"\n",
"To verify that this gives us the kernel:\n",
"\n",
"$$\\begin{aligned}\n",
"\\begin{align*}\n",
" \\langle 0..0 |S(x') S(x)^{\\dagger} \\mathcal{M} S(x')^{\\dagger} S(x) | 0..0\\rangle &= \\langle 0..0 |S(x') S(x)^{\\dagger} |0..0\\rangle \\langle 0..0| S(x')^{\\dagger} S(x) | 0..0\\rangle \\\\\n",
" &= |\\langle 0..0| S(x')^{\\dagger} S(x) | 0..0\\rangle |^2\\\\\n",
" &= | \\langle \\phi(x') | \\phi(x)\\rangle|^2 \\\\\n",
" &= \\kappa(x, x').\n",
"\\end{align*}\n",
"\\end{aligned}$$\n",
"\n",
"Note that a projector $|0..0 \\rangle \\langle 0..0|$ can be constructed\n",
"using the `qml.Hermitian` observable in PennyLane.\n",
"\n",
"Altogether, we use the following quantum node as a *quantum kernel\n",
"evaluator*:\n"
]
},
{
"cell_type": "code",
"execution_count": 160,
"metadata": {
"id": "mIbEaOoy3fHI"
},
"outputs": [],
"source": [
"dev_kernel = qml.device(\"lightning.gpu\", wires=n_qubits)\n",
"\n",
"projector = np.zeros((2**n_qubits, 2**n_qubits))\n",
"projector[0, 0] = 1\n",
"\n",
"@qml.qnode(dev_kernel, interface=\"autograd\", diff_method=\"adjoint\")\n",
"def kernel(x1, x2):\n",
" \"\"\"The quantum kernel.\"\"\"\n",
" AngleEmbedding(x1, wires=range(n_qubits))\n",
" qml.adjoint(AngleEmbedding)(x2, wires=range(n_qubits))\n",
" return qml.expval(qml.Hermitian(projector, wires=range(n_qubits)))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "U6aPSXgH3fHI"
},
"source": [
"A good sanity check is whether evaluating the kernel of a data point and\n",
"itself returns 1:\n"
]
},
{
"cell_type": "code",
"execution_count": 161,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "q9TzLmmP3fHI",
"outputId": "18ef2ea4-e587-4094-c7d2-bd27ec82f462"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"array(1.)"
]
},
"metadata": {},
"execution_count": 161
}
],
"source": [
"kernel(X_train[0], X_train[0])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "XsItzCZ73fHI"
},
"source": [
"The way an SVM with a custom kernel is implemented in scikit-learn\n",
"requires us to pass a function that computes a matrix of kernel\n",
"evaluations for samples in two different datasets A, B. If A=B, this is\n",
"the [Gram matrix](https://en.wikipedia.org/wiki/Gramian_matrix).\n"
]
},
{
"cell_type": "code",
"execution_count": 162,
"metadata": {
"id": "ktqS-uFf3fHI"
},
"outputs": [],
"source": [
"def kernel_matrix(A, B):\n",
" \"\"\"Compute the matrix whose entries are the kernel\n",
" evaluated on pairwise data from sets A and B.\"\"\"\n",
" return np.array([[kernel(a, b) for b in B] for a in A])"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "z2q2cVnO3fHJ"
},
"source": [
"Training the SVM optimizes internal parameters that basically weigh\n",
"kernel functions. It is a breeze in scikit-learn, which is designed as a\n",
"high-level machine learning library:\n"
]
},
{
"cell_type": "code",
"execution_count": 163,
"metadata": {
"id": "c-28Bjs33fHJ"
},
"outputs": [],
"source": [
"svm = SVC(kernel=kernel_matrix).fit(X_train, y_train)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LdqczWbW3fHJ"
},
"source": [
"Let's compute the accuracy on the test set.\n"
]
},
{
"cell_type": "code",
"execution_count": 164,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "TiO_t3bQ3fHJ",
"outputId": "531a9010-53b5-4084-af6a-369a4fe09b52"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"1.0"
]
},
"metadata": {},
"execution_count": 164
}
],
"source": [
"predictions = svm.predict(X_test)\n",
"accuracy_score(predictions, y_test)"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "oKR_CF363fHJ"
},
"source": [
"The SVM predicted all test points correctly. How many times was the\n",
"quantum device evaluated?\n"
]
},
{
"cell_type": "code",
"execution_count": 165,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "4TWrXNDn3fHJ",
"outputId": "c31d3aa4-ba57-4b98-8662-4b2c3f5e835d"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"7501"
]
},
"metadata": {},
"execution_count": 165
}
],
"source": [
"dev_kernel.num_executions"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Pp30o1Sl3fHJ"
},
"source": [
"This number can be derived as follows: For $M$ training samples, the SVM\n",
"must construct the $M \\times M$ dimensional kernel gram matrix for\n",
"training. To classify $M_{\\rm pred}$ new samples, the SVM needs to\n",
"evaluate the kernel at most $M_{\\rm pred}M$ times to get the pairwise\n",
"distances between training vectors and test samples.\n",
"\n",
"::: {.note}\n",
"::: {.title}\n",
"Note\n",
":::\n",
"\n",
"Depending on the implementation of the SVM, only $S \\leq M_{\\rm pred}$\n",
"*support vectors* are needed.\n",
":::\n",
"\n",
"Let us formulate this as a function, which can be used at the end of the\n",
"demo to construct the scaling plot shown in the introduction.\n"
]
},
{
"cell_type": "code",
"execution_count": 166,
"metadata": {
"id": "zI2lIUTV3fHJ"
},
"outputs": [],
"source": [
"def circuit_evals_kernel(n_data, split):\n",
" \"\"\"Compute how many circuit evaluations one needs for kernel-based\n",
" training and prediction.\"\"\"\n",
"\n",
" M = int(np.ceil(split * n_data))\n",
" Mpred = n_data - M\n",
"\n",
" n_training = M * M\n",
" n_prediction = M * Mpred\n",
"\n",
" return n_training + n_prediction"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "x0ayC5We3fHJ"
},
"source": [
"With $M = 75$ and $M_{\\rm pred} = 25$, the number of kernel evaluations\n",
"can therefore be estimated as:\n"
]
},
{
"cell_type": "code",
"execution_count": 167,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "0aoJPwOj3fHJ",
"outputId": "9fb47cee-4e1b-435f-e21e-c69e0b6c77c4"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"7500"
]
},
"metadata": {},
"execution_count": 167
}
],
"source": [
"circuit_evals_kernel(n_data=len(X), split=len(X_train) /(len(X_train) + len(X_test)))"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "dRDQOR7K3fHJ"
},
"source": [
"The single additional evaluation can be attributed to evaluating the\n",
"kernel once above as a sanity check.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "b8IBcump3fHJ"
},
"source": [
"A similar example using variational training\n",
"============================================\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "rl4V3vyC3fHJ"
},
"source": [
"Using the variational principle of training, we can propose an *ansatz*\n",
"for the variational circuit and train it directly. By increasing the\n",
"number of layers of the ansatz, its expressivity increases. Depending on\n",
"the ansatz, we may only search through a subspace of all measurements\n",
"for the best candidate.\n",
"\n",
"Remember from above, the variational training does not optimize\n",
"*exactly* the same cost as the SVM, but we try to match them as closely\n",
"as possible. For this we use a bias term in the quantum model, and train\n",
"on the hinge loss.\n",
"\n",
"We also explicitly use the\n",
"[parameter-shift](https://pennylane.ai/qml/glossary/parameter_shift.html)\n",
"differentiation method in the quantum node, since this is a method which\n",
"works on hardware as well. While `diff_method='backprop'` or\n",
"`diff_method='adjoint'` would reduce the number of circuit evaluations\n",
"significantly, they are based on tricks that are only suitable for\n",
"simulators, and can therefore not scale to more than a few dozen qubits.\n"
]
},
{
"cell_type": "code",
"execution_count": 168,
"metadata": {
"id": "3Givezqc3fHJ"
},
"outputs": [],
"source": [
"dev_var = qml.device(\"lightning.gpu\", wires=n_qubits)\n",
"\n",
"@qml.qnode(dev_var, interface=\"torch\", diff_method=\"adjoint\")\n",
"def quantum_model(x, params):\n",
" \"\"\"A variational quantum model.\"\"\"\n",
"\n",
" # embedding\n",
" AngleEmbedding(x, wires=range(n_qubits))\n",
"\n",
" # trainable measurement\n",
" StronglyEntanglingLayers(params, wires=range(n_qubits), imprimitive=qml.ops.CZ)\n",
" return qml.expval(qml.PauliZ(0))\n",
"\n",
"def quantum_model_plus_bias(x, params, bias):\n",
" \"\"\"Adding a bias.\"\"\"\n",
" return quantum_model(x, params) + bias\n",
"\n",
"def hinge_loss(predictions, targets):\n",
" \"\"\"Implements the hinge loss.\"\"\"\n",
" all_ones = torch.ones_like(targets)\n",
" hinge_loss = all_ones - predictions * targets\n",
" # trick: since the max(0,x) function is not differentiable,\n",
" # use the mathematically equivalent relu instead\n",
" hinge_loss = relu(hinge_loss)\n",
" return hinge_loss"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mIsEpYgJ3fHJ"
},
"source": [
"We now summarize the usual training and prediction steps into two\n",
"functions similar to scikit-learn\\'s `fit()` and `predict()`. While it\n",
"feels cumbersome compared to the one-liner used to train the kernel\n",
"method, PennyLane---like other differentiable programming\n",
"libraries---provides a lot more control over the particulars of\n",
"training.\n",
"\n",
"In our case, most of the work is to convert between numpy and torch,\n",
"which we need for the differentiable `relu` function used in the hinge\n",
"loss.\n"
]
},
{
"cell_type": "code",
"execution_count": 169,
"metadata": {
"id": "EFIiA8SW3fHK"
},
"outputs": [],
"source": [
"def quantum_model_train(n_layers, steps, batch_size):\n",
" \"\"\"Train the quantum model defined above.\"\"\"\n",
"\n",
" params = np.random.random((n_layers, n_qubits, 3))\n",
" params_torch = torch.tensor(params, requires_grad=True)\n",
" bias_torch = torch.tensor(0.0)\n",
"\n",
" opt = torch.optim.Adam([params_torch, bias_torch], lr=0.1)\n",
"\n",
" loss_history = []\n",
" for i in range(steps):\n",
"\n",
" batch_ids = np.random.choice(len(X_train), batch_size)\n",
"\n",
" X_batch = X_train[batch_ids]\n",
" y_batch = y_train[batch_ids]\n",
"\n",
" X_batch_torch = torch.tensor(X_batch, requires_grad=False)\n",
" y_batch_torch = torch.tensor(y_batch, requires_grad=False)\n",
"\n",
" def closure():\n",
" opt.zero_grad()\n",
" preds = torch.stack(\n",
" [quantum_model_plus_bias(x, params_torch, bias_torch) for x in X_batch_torch]\n",
" )\n",
" loss = torch.mean(hinge_loss(preds, y_batch_torch))\n",
"\n",
" # bookkeeping\n",
" current_loss = loss.detach().numpy().item()\n",
" loss_history.append(current_loss)\n",
" if i % 10 == 0:\n",
" print(\"step\", i, \", loss\", current_loss)\n",
"\n",
" loss.backward()\n",
" return loss\n",
"\n",
" opt.step(closure)\n",
"\n",
" return params_torch, bias_torch, loss_history\n",
"\n",
"\n",
"def quantum_model_predict(X_pred, trained_params, trained_bias):\n",
" \"\"\"Predict using the quantum model defined above.\"\"\"\n",
"\n",
" p = []\n",
" for x in X_pred:\n",
"\n",
" x_torch = torch.tensor(x)\n",
" pred_torch = quantum_model_plus_bias(x_torch, trained_params, trained_bias)\n",
" pred = pred_torch.detach().numpy().item()\n",
" if pred > 0:\n",
" pred = 1\n",
" else:\n",
" pred = -1\n",
"\n",
" p.append(pred)\n",
" return p"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HZ4ANAAf3fHK"
},
"source": [
"Let's train the variational model and see how well we are doing on the\n",
"test set.\n"
]
},
{
"cell_type": "code",
"execution_count": 170,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 657
},
"id": "4Orrciwd3fHK",
"outputId": "de8e56ee-1518-40c9-cee3-f2ebaf0fe5b3"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"step 0 , loss 1.454843148177316\n",
"step 10 , loss 0.907641409217336\n",
"step 20 , loss 0.32660914131572305\n",
"step 30 , loss 0.3851974090466026\n",
"step 40 , loss 0.3258326667282687\n",
"step 50 , loss 0.47861940695150196\n",
"step 60 , loss 0.22954276207568633\n",
"step 70 , loss 0.37317601756260155\n",
"step 80 , loss 0.5233110108158373\n",
"step 90 , loss 0.3757801857189079\n",
"accuracy on test set: 0.84\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"n_layers = 3\n",
"batch_size = 20\n",
"steps = 100\n",
"trained_params, trained_bias, loss_history = quantum_model_train(n_layers, steps, batch_size)\n",
"\n",
"pred_test = quantum_model_predict(X_test, trained_params, trained_bias)\n",
"print(\"accuracy on test set:\", accuracy_score(pred_test, y_test))\n",
"\n",
"plt.plot(loss_history)\n",
"plt.ylim((0, 1))\n",
"plt.xlabel(\"steps\")\n",
"plt.ylabel(\"cost\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "0kRgFZwr3fHK"
},
"source": [
"The variational circuit has a slightly lower accuracy than the SVM---but\n",
"this depends very much on the training settings we used. Different\n",
"random parameter initializations, more layers, or more steps may indeed\n",
"get perfect test accuracy.\n",
"\n",
"How often was the device executed?\n"
]
},
{
"cell_type": "code",
"execution_count": 171,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "VGhHTCTP3fHK",
"outputId": "01b80ac4-dd0f-4acc-ed8e-aec0f28f9af2"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"2025"
]
},
"metadata": {},
"execution_count": 171
}
],
"source": [
"dev_var.num_executions"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mJyxRIhl3fHK"
},
"source": [
"That is a lot more than the kernel method took!\n",
"\n",
"Let's try to understand this value. In each optimization step, the\n",
"variational circuit needs to compute the partial derivative of all\n",
"trainable parameters for each sample in a batch. Using parameter-shift\n",
"rules, we require roughly two circuit evaluations per partial\n",
"derivative. Prediction uses only one circuit evaluation per sample.\n",
"\n",
"We can formulate this as another function that will be used in the\n",
"scaling plot below.\n"
]
},
{
"cell_type": "code",
"execution_count": 172,
"metadata": {
"id": "FMFvt86o3fHK"
},
"outputs": [],
"source": [
"def circuit_evals_variational(n_data, n_params, n_steps, shift_terms, split, batch_size):\n",
" \"\"\"Compute how many circuit evaluations are needed for\n",
" variational training and prediction.\"\"\"\n",
"\n",
" M = int(np.ceil(split * n_data))\n",
" Mpred = n_data - M\n",
"\n",
" n_training = n_params * n_steps * batch_size * shift_terms\n",
" n_prediction = Mpred\n",
"\n",
" return n_training + n_prediction"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "c8coagmG3fHK"
},
"source": [
"This estimates the circuit evaluations in variational training as:\n"
]
},
{
"cell_type": "code",
"execution_count": 173,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "esATEcjo3fHR",
"outputId": "84ac495f-b2f0-41f9-d308-9e56fe46efeb"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"144025"
]
},
"metadata": {},
"execution_count": 173
}
],
"source": [
"circuit_evals_variational(\n",
" n_data=len(X),\n",
" n_params=len(trained_params.flatten()),\n",
" n_steps=steps,\n",
" shift_terms=2,\n",
" split=len(X_train) /(len(X_train) + len(X_test)),\n",
" batch_size=batch_size,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "nfqqOSzb3fHR"
},
"source": [
"The estimate is a bit higher because it does not account for some\n",
"optimizations that PennyLane performs under the hood.\n",
"\n",
"It is important to note that while they are trained in a similar manner,\n",
"the number of variational circuit evaluations differs from the number of\n",
"neural network model evaluations in classical machine learning, which\n",
"would be given by:\n"
]
},
{
"cell_type": "code",
"execution_count": 174,
"metadata": {
"id": "uumnwm6l3fHR"
},
"outputs": [],
"source": [
"def model_evals_nn(n_data, n_params, n_steps, split, batch_size):\n",
" \"\"\"Compute how many model evaluations are needed for neural\n",
" network training and prediction.\"\"\"\n",
"\n",
" M = int(np.ceil(split * n_data))\n",
" Mpred = n_data - M\n",
"\n",
" n_training = n_steps * batch_size\n",
" n_prediction = Mpred\n",
"\n",
" return n_training + n_prediction"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "JnHDNbRt3fHR"
},
"source": [
"In each step of neural network training, and due to the clever\n",
"implementations of automatic differentiation, the backpropagation\n",
"algorithm can compute a gradient for all parameters in (more-or-less) a\n",
"single run. For all we know at this stage, the no-cloning principle\n",
"prevents variational circuits from using these tricks, which leads to\n",
"`n_training` in `circuit_evals_variational` depending on the number of\n",
"parameters, but not in `model_evals_nn`.\n",
"\n",
"For the same example as used here, a neural network would therefore have\n",
"far fewer model evaluations than both variational and kernel-based\n",
"training:\n"
]
},
{
"cell_type": "code",
"execution_count": 175,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "PhQiOZWj3fHR",
"outputId": "1f1cc557-8c4e-44b1-ea65-1b9f53aaddbb"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"2025"
]
},
"metadata": {},
"execution_count": 175
}
],
"source": [
"model_evals_nn(\n",
" n_data=len(X),\n",
" n_params=len(trained_params.flatten()),\n",
" n_steps=steps,\n",
" split=len(X_train) /(len(X_train) + len(X_test)),\n",
" batch_size=batch_size,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "lW-D9kig3fHR"
},
"source": [
"Which method scales best?\n",
"=========================\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "mICU026f3fHR"
},
"source": [
"The answer to this question depends on how the variational model is set\n",
"up, and we need to make a few assumptions:\n",
"\n",
"1. Even if we use single-batch stochastic gradient descent, in which\n",
" every training step uses exactly one training sample, we would want\n",
" to see every training sample at least once on average. Therefore,\n",
" the number of steps should scale at least linearly with the number\n",
" of training data samples.\n",
"\n",
"2. Modern neural networks often have many more parameters than training\n",
" samples. But we do not know yet whether variational circuits really\n",
" need that many parameters as well. We will therefore use two cases\n",
" for comparison:\n",
"\n",
" 2a) the number of parameters grows linearly with the training data,\n",
" or `n_params = M`,\n",
"\n",
" 2b) the number of parameters saturates at some point, which we model\n",
" by setting `n_params = sqrt(M)`.\n",
"\n",
"Note that compared to the example above with 75 training samples and 24\n",
"parameters, a) overestimates the number of evaluations, while b)\n",
"underestimates it.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "9j20OPV03fHS"
},
"source": [
"This is how the three methods compare:\n"
]
},
{
"cell_type": "code",
"execution_count": 176,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 487
},
"id": "Neg50ctN3fHS",
"outputId": "f4e2355d-382c-4e80-d997-b30c8a165f87"
},
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
],
"source": [
"variational_training1 = []\n",
"variational_training2 = []\n",
"kernelbased_training = []\n",
"nn_training = []\n",
"x_axis = range(0, 2000, 100)\n",
"\n",
"for M in x_axis:\n",
"\n",
" var1 = circuit_evals_variational(\n",
" n_data=M, n_params=M, n_steps=M, shift_terms=2, split=0.75, batch_size=1\n",
" )\n",
" variational_training1.append(var1)\n",
"\n",
" var2 = circuit_evals_variational(\n",
" n_data=M, n_params=round(np.sqrt(M)), n_steps=M,\n",
" shift_terms=2, split=0.75, batch_size=1\n",
" )\n",
" variational_training2.append(var2)\n",
"\n",
" kernel = circuit_evals_kernel(n_data=M, split=0.75)\n",
" kernelbased_training.append(kernel)\n",
"\n",
" nn = model_evals_nn(\n",
" n_data=M, n_params=M, n_steps=M, split=0.75, batch_size=1\n",
" )\n",
" nn_training.append(nn)\n",
"\n",
"\n",
"plt.plot(x_axis, nn_training, linestyle='--', label=\"neural net\")\n",
"plt.plot(x_axis, variational_training1, label=\"var. circuit (linear param scaling)\")\n",
"plt.plot(x_axis, variational_training2, label=\"var. circuit (srqt param scaling)\")\n",
"plt.plot(x_axis, kernelbased_training, label=\"(quantum) kernel\")\n",
"plt.xlabel(\"size of data set\")\n",
"plt.ylabel(\"number of evaluations\")\n",
"plt.legend()\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "q5iOsnGW3fHS"
},
"source": [
"This is the plot we saw at the beginning. With current\n",
"hardware-compatible training methods, whether kernel-based training\n",
"requires more or fewer quantum circuit evaluations than variational\n",
"training depends on how many parameters the latter needs. If variational\n",
"circuits turn out to be as parameter-hungry as neural networks,\n",
"kernel-based training will outperform them for common machine learning\n",
"tasks. However, if variational learning only turns out to require few\n",
"parameters (or if more efficient training methods are found),\n",
"variational circuits could in principle match the linear scaling of\n",
"neural networks trained with backpropagation.\n",
"\n",
"The practical take-away from this demo is that unless your variational\n",
"circuit has significantly fewer parameters than training data, kernel\n",
"methods could be a much faster alternative!\n",
"\n",
"Finally, it is important to note that fault-tolerant quantum computers\n",
"may change the picture for both quantum and classical machine learning.\n",
"As mentioned in [Schuld (2021)](https://arxiv.org/abs/2101.11020), early\n",
"results from the quantum machine learning literature show that larger\n",
"quantum computers will most likely enable us to reduce the quadratic\n",
"scaling of kernel methods to linear scaling, which may make classical as\n",
"well as quantum kernel methods a strong alternative to neural networks\n",
"for big data processing one day.\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "obtp3eCY3fHS"
},
"source": [
"About the author\n",
"================\n"
]
},
{
"cell_type": "code",
"source": [
"seconds = time.time()\n",
"print(\"Time in seconds since end of run:\", seconds)\n",
"local_time = time.ctime(seconds)\n",
"print(local_time)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 0
},
"id": "SOIzdbnn30P-",
"outputId": "34a84fa0-3a76-4382-c5ad-9d7d7d12a2e5"
},
"execution_count": 177,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Time in seconds since end of run: 1699853120.7660635\n",
"Mon Nov 13 05:25:20 2023\n"
]
}
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.18"
},
"colab": {
"provenance": [],
"machine_shape": "hm",
"gpuType": "A100"
},
"accelerator": "GPU"
},
"nbformat": 4,
"nbformat_minor": 0
}