1278 lines (1278 with data), 141.8 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 134,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "U9bYOT8V3fHC",
        "outputId": "e407df54-96d0-4dd9-b48f-f652f13472f1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1699852862.1547282\n",
            "Mon Nov 13 05:21:02 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",
        "![](../demonstrations/kernel_based_training/scaling.png){.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",
        "![](../demonstrations/kernel_based_training/quantum_model.png){.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": 135,
      "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": 136,
      "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": 137,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "_PetxK4z3fHI",
        "outputId": "2a400603-7e63-475f-e086-26014e29e73c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 137
        }
      ],
      "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",
        "![](../demonstrations/kernel_based_training/kernel_circuit.png){.align-center}\n",
        "\n",
        "To verify that this gives us the kernel:\n",
        "\n",
        "$$\\begin{aligned}\n",
        "\\begin{align*}\n",
        "    \\langle 0..0 |S(x') S(x)^{\\dagger} \\mathcal{M} S(x')^{\\dagger} S(x)  | 0..0\\rangle &= \\langle 0..0 |S(x') S(x)^{\\dagger} |0..0\\rangle \\langle 0..0| S(x')^{\\dagger} S(x)  | 0..0\\rangle  \\\\\n",
        "    &= |\\langle 0..0| S(x')^{\\dagger} S(x)  | 0..0\\rangle |^2\\\\\n",
        "    &= | \\langle \\phi(x') | \\phi(x)\\rangle|^2 \\\\\n",
        "    &= \\kappa(x, x').\n",
        "\\end{align*}\n",
        "\\end{aligned}$$\n",
        "\n",
        "Note that a projector $|0..0 \\rangle \\langle 0..0|$ can be constructed\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": 138,
      "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": 139,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "q9TzLmmP3fHI",
        "outputId": "46d050bf-a7fd-4712-e3b4-b464f835d89b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(1.)"
            ]
          },
          "metadata": {},
          "execution_count": 139
        }
      ],
      "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": 140,
      "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": 141,
      "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": 142,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "TiO_t3bQ3fHJ",
        "outputId": "0645913e-b8e6-479b-e94c-a202f6e07d9a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 142
        }
      ],
      "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": 143,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "4TWrXNDn3fHJ",
        "outputId": "a2bac1b7-c7f0-4fc5-f8c6-d84bd69a37fb"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7501"
            ]
          },
          "metadata": {},
          "execution_count": 143
        }
      ],
      "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": 144,
      "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": 145,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "0aoJPwOj3fHJ",
        "outputId": "b2f44bbc-5a8d-40d5-b175-490809038991"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7500"
            ]
          },
          "metadata": {},
          "execution_count": 145
        }
      ],
      "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": 146,
      "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": 147,
      "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": 148,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 657
        },
        "id": "4Orrciwd3fHK",
        "outputId": "4eefae12-a007-445f-d137-b5fcaf6337c3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "step 0 , loss 1.3547392919650094\n",
            "step 10 , loss 1.0209324378514466\n",
            "step 20 , loss 0.8176998781152148\n",
            "step 30 , loss 1.0499274403547592\n",
            "step 40 , loss 0.23589116465100085\n",
            "step 50 , loss 0.6382196906075436\n",
            "step 60 , loss 0.41711670459079053\n",
            "step 70 , loss 0.5656856288046087\n",
            "step 80 , loss 0.39649505455630607\n",
            "step 90 , loss 0.39167067944088285\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 = 1\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": 149,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "VGhHTCTP3fHK",
        "outputId": "eb647c9b-ebf2-4656-b8b7-a65030992e06"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2025"
            ]
          },
          "metadata": {},
          "execution_count": 149
        }
      ],
      "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": 150,
      "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": 151,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "esATEcjo3fHR",
        "outputId": "e2bbe492-8a9c-46a5-b559-d7fd2b5ef1dd"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "48025"
            ]
          },
          "metadata": {},
          "execution_count": 151
        }
      ],
      "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": 152,
      "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": 153,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "PhQiOZWj3fHR",
        "outputId": "054a5d05-538e-4370-c8ef-89b519ee76cd"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2025"
            ]
          },
          "metadata": {},
          "execution_count": 153
        }
      ],
      "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": 154,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "Neg50ctN3fHS",
        "outputId": "8af23cb2-dd35-4f3d-e738-249f7b82a291"
      },
      "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": "9b9a44ea-8585-4e95-d13e-1ef0bb40889a"
      },
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1699852898.705154\n",
            "Mon Nov 13 05:21:38 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
}