--- a
+++ b/Code/All Qiskit, PennyLane QML Nov 23/38a2 CPU 0.24 Cost 278.03s kkawchak.ipynb
@@ -0,0 +1,1258 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 28,
+      "metadata": {
+        "id": "2l9DnvglyqMl",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "outputId": "e1dc9086-d86c-4996-aa99-f1a4cb8c4484"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since beginning of run: 1700615511.4967494\n",
+            "Wed Nov 22 01:11:51 2023\n"
+          ]
+        }
+      ],
+      "source": [
+        "# This cell is added by sphinx-gallery\n",
+        "# It can be customized to whatever you like\n",
+        "%matplotlib inline\n",
+        "# from google.colab import drive\n",
+        "# drive.mount('/content/drive')\n",
+        "# !pip install pennylane\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": "5uiLxJB3yqMm"
+      },
+      "source": [
+        "Variational classifier {#variational_classifier}\n",
+        "======================\n",
+        "\n",
+        "::: {.meta}\n",
+        ":property=\\\"og:description\\\": Using PennyLane to implement quantum\n",
+        "circuits that can be trained from labelled data to classify new data\n",
+        "samples. :property=\\\"og:image\\\":\n",
+        "<https://pennylane.ai/qml/_images/classifier_output_59_0.png>\n",
+        ":::\n",
+        "\n",
+        "::: {.related}\n",
+        "tutorial\\_data\\_reuploading\\_classifier Data-reuploading classifier\n",
+        "tutorial\\_multiclass\\_classification Multiclass margin classifier\n",
+        "ensemble\\_multi\\_qpu Ensemble classification with Rigetti and Qiskit\n",
+        "devices\n",
+        ":::\n",
+        "\n",
+        "*Author: Maria Schuld --- Posted: 11 October 2019. Last updated: 19\n",
+        "January 2021.*\n",
+        "\n",
+        "In this tutorial, we show how to use PennyLane to implement variational\n",
+        "quantum classifiers - quantum circuits that can be trained from labelled\n",
+        "data to classify new data samples. The architecture is inspired by\n",
+        "[Farhi and Neven (2018)](https://arxiv.org/abs/1802.06002) as well as\n",
+        "[Schuld et al. (2018)](https://arxiv.org/abs/1804.00633).\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ue7hv7qSyqMn"
+      },
+      "source": [
+        "We will first show that the variational quantum classifier can reproduce\n",
+        "the parity function\n",
+        "\n",
+        "$$\\begin{aligned}\n",
+        "f: x \\in \\{0,1\\}^{\\otimes n} \\rightarrow y =\n",
+        "\\begin{cases} 1 \\text{  if uneven number of ones in } x \\\\ 0\n",
+        "\\text{ otherwise} \\end{cases}.\n",
+        "\\end{aligned}$$\n",
+        "\n",
+        "This optimization example demonstrates how to encode binary inputs into\n",
+        "the initial state of the variational circuit, which is simply a\n",
+        "computational basis state.\n",
+        "\n",
+        "We then show how to encode real vectors as amplitude vectors (*amplitude\n",
+        "encoding*) and train the model to recognize the first two classes of\n",
+        "flowers in the Iris dataset.\n",
+        "\n",
+        "1. Fitting the parity function\n",
+        "==============================\n",
+        "\n",
+        "Imports\n",
+        "-------\n",
+        "\n",
+        "As before, we import PennyLane, the PennyLane-provided version of NumPy,\n",
+        "and an optimizer.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 29,
+      "metadata": {
+        "id": "S4C7r4lhyqMn"
+      },
+      "outputs": [],
+      "source": [
+        "import pennylane as qml\n",
+        "from pennylane import numpy as np\n",
+        "from pennylane.optimize import NesterovMomentumOptimizer"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "KBtbLq8NyqMn"
+      },
+      "source": [
+        "Quantum and classical nodes\n",
+        "===========================\n",
+        "\n",
+        "We create a quantum device with four \"wires\" (or qubits).\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "id": "_siB9XyLyqMn"
+      },
+      "outputs": [],
+      "source": [
+        "dev = qml.device(\"lightning.qubit\", wires=4)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fKNBHNQRyqMn"
+      },
+      "source": [
+        "Variational classifiers usually define a \"layer\" or \"block\", which is an\n",
+        "elementary circuit architecture that gets repeated to build the\n",
+        "variational circuit.\n",
+        "\n",
+        "Our circuit layer consists of an arbitrary rotation on every qubit, as\n",
+        "well as CNOTs that entangle each qubit with its neighbour.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 31,
+      "metadata": {
+        "id": "8EteJ3M1yqMn"
+      },
+      "outputs": [],
+      "source": [
+        "def layer(W):\n",
+        "\n",
+        "    qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)\n",
+        "    qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)\n",
+        "    qml.Rot(W[2, 0], W[2, 1], W[2, 2], wires=2)\n",
+        "    qml.Rot(W[3, 0], W[3, 1], W[3, 2], wires=3)\n",
+        "\n",
+        "    qml.CNOT(wires=[0, 1])\n",
+        "    qml.CNOT(wires=[1, 2])\n",
+        "    qml.CNOT(wires=[2, 3])\n",
+        "    qml.CNOT(wires=[3, 0])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "O_uRpKLoyqMn"
+      },
+      "source": [
+        "We also need a way to encode data inputs $x$ into the circuit, so that\n",
+        "the measured output depends on the inputs. In this first example, the\n",
+        "inputs are bitstrings, which we encode into the state of the qubits. The\n",
+        "quantum state $\\psi$ after state preparation is a computational basis\n",
+        "state that has 1s where $x$ has 1s, for example\n",
+        "\n",
+        "$$x = 0101 \\rightarrow |\\psi \\rangle = |0101 \\rangle .$$\n",
+        "\n",
+        "We use the `~pennylane.BasisState`{.interpreted-text role=\"class\"}\n",
+        "function provided by PennyLane, which expects `x` to be a list of zeros\n",
+        "and ones, i.e. `[0,1,0,1]`.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 32,
+      "metadata": {
+        "id": "KHPeGH3DyqMn"
+      },
+      "outputs": [],
+      "source": [
+        "def statepreparation(x):\n",
+        "    qml.BasisState(x, wires=[0, 1, 2, 3])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Pk3ofHMEyqMo"
+      },
+      "source": [
+        "Now we define the quantum node as a state preparation routine, followed\n",
+        "by a repetition of the layer structure. Borrowing from machine learning,\n",
+        "we call the parameters `weights`.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 33,
+      "metadata": {
+        "id": "JRXd4rFwyqMo"
+      },
+      "outputs": [],
+      "source": [
+        "@qml.qnode(dev, interface=\"autograd\")\n",
+        "def circuit(weights, x):\n",
+        "\n",
+        "    statepreparation(x)\n",
+        "\n",
+        "    for W in weights:\n",
+        "        layer(W)\n",
+        "\n",
+        "    return qml.expval(qml.PauliZ(0))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "he4KqfSnyqMo"
+      },
+      "source": [
+        "Different from previous examples, the quantum node takes the data as a\n",
+        "keyword argument `x` (with the default value `None`). Keyword arguments\n",
+        "of a quantum node are considered as fixed when calculating a gradient;\n",
+        "they are never trained.\n",
+        "\n",
+        "If we want to add a \"classical\" bias parameter, the variational quantum\n",
+        "classifier also needs some post-processing. We define the final model by\n",
+        "a classical node that uses the first variable, and feeds the remainder\n",
+        "into the quantum node. Before this, we reshape the list of remaining\n",
+        "variables for easy use in the quantum node.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 34,
+      "metadata": {
+        "id": "XvhxkBOoyqMo"
+      },
+      "outputs": [],
+      "source": [
+        "def variational_classifier(weights, bias, x):\n",
+        "    return circuit(weights, x) + bias"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Sco3rPabyqMo"
+      },
+      "source": [
+        "Cost\n",
+        "====\n",
+        "\n",
+        "In supervised learning, the cost function is usually the sum of a loss\n",
+        "function and a regularizer. We use the standard square loss that\n",
+        "measures the distance between target labels and model predictions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 35,
+      "metadata": {
+        "id": "NnlX2dBPyqMo"
+      },
+      "outputs": [],
+      "source": [
+        "def square_loss(labels, predictions):\n",
+        "    loss = 0\n",
+        "    for l, p in zip(labels, predictions):\n",
+        "        loss = loss + (l - p) ** 2\n",
+        "\n",
+        "    loss = loss / len(labels)\n",
+        "    return loss"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "qs39RtaayqMo"
+      },
+      "source": [
+        "To monitor how many inputs the current classifier predicted correctly,\n",
+        "we also define the accuracy given target labels and model predictions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 36,
+      "metadata": {
+        "id": "WwPgFt7pyqMo"
+      },
+      "outputs": [],
+      "source": [
+        "def accuracy(labels, predictions):\n",
+        "\n",
+        "    loss = 0\n",
+        "    for l, p in zip(labels, predictions):\n",
+        "        if abs(l - p) < 1e-5:\n",
+        "            loss = loss + 1\n",
+        "    loss = loss / len(labels)\n",
+        "\n",
+        "    return loss"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "DZQFl81vyqMo"
+      },
+      "source": [
+        "For learning tasks, the cost depends on the data - here the features and\n",
+        "labels considered in the iteration of the optimization routine.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 37,
+      "metadata": {
+        "id": "OPzeeAKayqMo"
+      },
+      "outputs": [],
+      "source": [
+        "def cost(weights, bias, X, Y):\n",
+        "    predictions = [variational_classifier(weights, bias, x) for x in X]\n",
+        "    return square_loss(Y, predictions)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uo3I0i-gyqMo"
+      },
+      "source": [
+        "Optimization\n",
+        "============\n",
+        "\n",
+        "Let's now load and preprocess some data.\n",
+        "\n",
+        "::: {.note}\n",
+        "::: {.title}\n",
+        "Note\n",
+        ":::\n",
+        "\n",
+        "The parity dataset can be downloaded\n",
+        "`<a href=\"https://raw.githubusercontent.com/XanaduAI/qml/master/demonstrations/variational_classifier/data/parity.txt\"\n",
+        "download=parity.txt target=\"_blank\">here</a>`{.interpreted-text\n",
+        "role=\"html\"} and should be placed in the subfolder\n",
+        "`variational_classifier/data`.\n",
+        ":::\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 38,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "yiXUCgY2yqMo",
+        "outputId": "56ab9f2b-2aec-45d5-ce95-d04686da1965"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "X = [0. 0. 0. 0.], Y = -1\n",
+            "X = [0. 0. 0. 1.], Y =  1\n",
+            "X = [0. 0. 1. 0.], Y =  1\n",
+            "X = [0. 0. 1. 1.], Y = -1\n",
+            "X = [0. 1. 0. 0.], Y =  1\n",
+            "...\n"
+          ]
+        }
+      ],
+      "source": [
+        "data = np.loadtxt(\"/content/drive/MyDrive/Colab Notebooks/data/parity.txt\")\n",
+        "X = np.array(data[:, :-1], requires_grad=False)\n",
+        "Y = np.array(data[:, -1], requires_grad=False)\n",
+        "Y = Y * 2 - np.ones(len(Y))  # shift label from {0, 1} to {-1, 1}\n",
+        "\n",
+        "for i in range(5):\n",
+        "    print(\"X = {}, Y = {: d}\".format(X[i], int(Y[i])))\n",
+        "\n",
+        "print(\"...\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xaXn9xmwyqMo"
+      },
+      "source": [
+        "We initialize the variables randomly (but fix a seed for\n",
+        "reproducibility). The first variable in the list is used as a bias,\n",
+        "while the rest is fed into the gates of the variational circuit.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 39,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "OOnioR90yqMo",
+        "outputId": "07f34cf0-3976-413b-9184-e2b2a29b42ef"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[[[ 0.01764052  0.00400157  0.00978738]\n",
+            "  [ 0.02240893  0.01867558 -0.00977278]\n",
+            "  [ 0.00950088 -0.00151357 -0.00103219]\n",
+            "  [ 0.00410599  0.00144044  0.01454274]]\n",
+            "\n",
+            " [[ 0.00761038  0.00121675  0.00443863]\n",
+            "  [ 0.00333674  0.01494079 -0.00205158]\n",
+            "  [ 0.00313068 -0.00854096 -0.0255299 ]\n",
+            "  [ 0.00653619  0.00864436 -0.00742165]]] 0.0\n"
+          ]
+        }
+      ],
+      "source": [
+        "np.random.seed(0)\n",
+        "num_qubits = 4\n",
+        "num_layers = 2\n",
+        "weights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)\n",
+        "bias_init = np.array(0.0, requires_grad=True)\n",
+        "\n",
+        "print(weights_init, bias_init)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "j623eUSUyqMp"
+      },
+      "source": [
+        "Next we create an optimizer and choose a batch size...\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 40,
+      "metadata": {
+        "id": "s36xsyg9yqMp"
+      },
+      "outputs": [],
+      "source": [
+        "opt = NesterovMomentumOptimizer(0.5)\n",
+        "batch_size = 5"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ENjwgp7ryqMp"
+      },
+      "source": [
+        "...and train the optimizer. We track the accuracy - the share of\n",
+        "correctly classified data samples. For this we compute the outputs of\n",
+        "the variational classifier and turn them into predictions in $\\{-1,1\\}$\n",
+        "by taking the sign of the output.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 41,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "Q4mKVvUbyqMp",
+        "outputId": "8cc1bedb-fcfc-40a2-b1e4-9ac9aacd63b0"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iter:     1 | Cost: 3.4355534 | Accuracy: 0.5000000 \n",
+            "Iter:     2 | Cost: 1.9717733 | Accuracy: 0.5000000 \n",
+            "Iter:     3 | Cost: 1.8182812 | Accuracy: 0.5000000 \n",
+            "Iter:     4 | Cost: 1.5042404 | Accuracy: 0.5000000 \n",
+            "Iter:     5 | Cost: 1.1477739 | Accuracy: 0.5000000 \n",
+            "Iter:     6 | Cost: 1.2734990 | Accuracy: 0.6250000 \n",
+            "Iter:     7 | Cost: 0.8290628 | Accuracy: 0.5000000 \n",
+            "Iter:     8 | Cost: 0.3226183 | Accuracy: 1.0000000 \n",
+            "Iter:     9 | Cost: 0.1436206 | Accuracy: 1.0000000 \n",
+            "Iter:    10 | Cost: 0.2982810 | Accuracy: 1.0000000 \n",
+            "Iter:    11 | Cost: 0.3064355 | Accuracy: 1.0000000 \n",
+            "Iter:    12 | Cost: 0.1682335 | Accuracy: 1.0000000 \n",
+            "Iter:    13 | Cost: 0.0892512 | Accuracy: 1.0000000 \n",
+            "Iter:    14 | Cost: 0.0381562 | Accuracy: 1.0000000 \n",
+            "Iter:    15 | Cost: 0.0170359 | Accuracy: 1.0000000 \n",
+            "Iter:    16 | Cost: 0.0109353 | Accuracy: 1.0000000 \n",
+            "Iter:    17 | Cost: 0.0108388 | Accuracy: 1.0000000 \n",
+            "Iter:    18 | Cost: 0.0139196 | Accuracy: 1.0000000 \n",
+            "Iter:    19 | Cost: 0.0123980 | Accuracy: 1.0000000 \n",
+            "Iter:    20 | Cost: 0.0085416 | Accuracy: 1.0000000 \n",
+            "Iter:    21 | Cost: 0.0053549 | Accuracy: 1.0000000 \n",
+            "Iter:    22 | Cost: 0.0065759 | Accuracy: 1.0000000 \n",
+            "Iter:    23 | Cost: 0.0024883 | Accuracy: 1.0000000 \n",
+            "Iter:    24 | Cost: 0.0029102 | Accuracy: 1.0000000 \n",
+            "Iter:    25 | Cost: 0.0023471 | Accuracy: 1.0000000 \n"
+          ]
+        }
+      ],
+      "source": [
+        "weights = weights_init\n",
+        "bias = bias_init\n",
+        "for it in range(25):\n",
+        "\n",
+        "    # Update the weights by one optimizer step\n",
+        "    batch_index = np.random.randint(0, len(X), (batch_size,))\n",
+        "    X_batch = X[batch_index]\n",
+        "    Y_batch = Y[batch_index]\n",
+        "    weights, bias, _, _ = opt.step(cost, weights, bias, X_batch, Y_batch)\n",
+        "\n",
+        "    # Compute accuracy\n",
+        "    predictions = [np.sign(variational_classifier(weights, bias, x)) for x in X]\n",
+        "    acc = accuracy(Y, predictions)\n",
+        "\n",
+        "    print(\n",
+        "        \"Iter: {:5d} | Cost: {:0.7f} | Accuracy: {:0.7f} \".format(\n",
+        "            it + 1, cost(weights, bias, X, Y), acc\n",
+        "        )\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0RaIFiaJyqMp"
+      },
+      "source": [
+        "2. Iris classification\n",
+        "======================\n",
+        "\n",
+        "Quantum and classical nodes\n",
+        "---------------------------\n",
+        "\n",
+        "To encode real-valued vectors into the amplitudes of a quantum state, we\n",
+        "use a 2-qubit simulator.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 42,
+      "metadata": {
+        "id": "dgMVATiZyqMp"
+      },
+      "outputs": [],
+      "source": [
+        "dev = qml.device(\"lightning.qubit\", wires=2)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1eU6RuHayqMp"
+      },
+      "source": [
+        "State preparation is not as simple as when we represent a bitstring with\n",
+        "a basis state. Every input x has to be translated into a set of angles\n",
+        "which can get fed into a small routine for state preparation. To\n",
+        "simplify things a bit, we will work with data from the positive\n",
+        "subspace, so that we can ignore signs (which would require another\n",
+        "cascade of rotations around the z axis).\n",
+        "\n",
+        "The circuit is coded according to the scheme in [Möttönen, et al.\n",
+        "(2004)](https://arxiv.org/abs/quant-ph/0407010), or---as presented for\n",
+        "positive vectors only---in [Schuld and Petruccione\n",
+        "(2018)](https://link.springer.com/book/10.1007/978-3-319-96424-9). We\n",
+        "had to also decompose controlled Y-axis rotations into more basic\n",
+        "circuits following [Nielsen and Chuang\n",
+        "(2010)](http://www.michaelnielsen.org/qcqi/).\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 43,
+      "metadata": {
+        "id": "NrZqQA9ayqMp"
+      },
+      "outputs": [],
+      "source": [
+        "def get_angles(x):\n",
+        "\n",
+        "    beta0 = 2 * np.arcsin(np.sqrt(x[1] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12))\n",
+        "    beta1 = 2 * np.arcsin(np.sqrt(x[3] ** 2) / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12))\n",
+        "    beta2 = 2 * np.arcsin(\n",
+        "        np.sqrt(x[2] ** 2 + x[3] ** 2)\n",
+        "        / np.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2)\n",
+        "    )\n",
+        "\n",
+        "    return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])\n",
+        "\n",
+        "\n",
+        "def statepreparation(a):\n",
+        "    qml.RY(a[0], wires=0)\n",
+        "\n",
+        "    qml.CNOT(wires=[0, 1])\n",
+        "    qml.RY(a[1], wires=1)\n",
+        "    qml.CNOT(wires=[0, 1])\n",
+        "    qml.RY(a[2], wires=1)\n",
+        "\n",
+        "    qml.PauliX(wires=0)\n",
+        "    qml.CNOT(wires=[0, 1])\n",
+        "    qml.RY(a[3], wires=1)\n",
+        "    qml.CNOT(wires=[0, 1])\n",
+        "    qml.RY(a[4], wires=1)\n",
+        "    qml.PauliX(wires=0)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "C5WihgOGyqMp"
+      },
+      "source": [
+        "Let's test if this routine actually works.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 44,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "YtpiSIgbyqMp",
+        "outputId": "b9c54780-71b4-4560-d0f4-35a60656ac6e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "x               :  [0.53896774 0.79503606 0.27826503 0.        ]\n",
+            "angles          :  [ 0.56397465 -0.          0.         -0.97504604  0.97504604]\n",
+            "amplitude vector:  [ 5.38967743e-01  7.95036065e-01  2.78265032e-01 -2.77555756e-17]\n"
+          ]
+        }
+      ],
+      "source": [
+        "x = np.array([0.53896774, 0.79503606, 0.27826503, 0.0], requires_grad=False)\n",
+        "ang = get_angles(x)\n",
+        "\n",
+        "\n",
+        "@qml.qnode(dev, interface=\"autograd\")\n",
+        "def test(angles):\n",
+        "\n",
+        "    statepreparation(angles)\n",
+        "\n",
+        "    return qml.expval(qml.PauliZ(0))\n",
+        "\n",
+        "\n",
+        "test(ang)\n",
+        "\n",
+        "print(\"x               : \", x)\n",
+        "print(\"angles          : \", ang)\n",
+        "print(\"amplitude vector: \", np.real(dev.state))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-um7c47nyqMp"
+      },
+      "source": [
+        "Note that the `default.qubit` simulator provides a shortcut to\n",
+        "`statepreparation` with the command\n",
+        "`qml.QubitStateVector(x, wires=[0, 1])`. However, some devices may not\n",
+        "support an arbitrary state-preparation routine.\n",
+        "\n",
+        "Since we are working with only 2 qubits now, we need to update the layer\n",
+        "function as well.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 45,
+      "metadata": {
+        "id": "Qvk9iYkPyqMp"
+      },
+      "outputs": [],
+      "source": [
+        "def layer(W):\n",
+        "    qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)\n",
+        "    qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)\n",
+        "    qml.CNOT(wires=[0, 1])"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "917eTFwLyqMp"
+      },
+      "source": [
+        "The variational classifier model and its cost remain essentially the\n",
+        "same, but we have to reload them with the new state preparation and\n",
+        "layer functions.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 46,
+      "metadata": {
+        "id": "_77ORtToyqMp"
+      },
+      "outputs": [],
+      "source": [
+        "@qml.qnode(dev, interface=\"autograd\")\n",
+        "def circuit(weights, angles):\n",
+        "    statepreparation(angles)\n",
+        "\n",
+        "    for W in weights:\n",
+        "        layer(W)\n",
+        "\n",
+        "    return qml.expval(qml.PauliZ(0))\n",
+        "\n",
+        "\n",
+        "def variational_classifier(weights, bias, angles):\n",
+        "    return circuit(weights, angles) + bias\n",
+        "\n",
+        "\n",
+        "def cost(weights, bias, features, labels):\n",
+        "    predictions = [variational_classifier(weights, bias, f) for f in features]\n",
+        "    return square_loss(labels, predictions)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "wvWcoKcUyqMp"
+      },
+      "source": [
+        "Data\n",
+        "====\n",
+        "\n",
+        "We then load the Iris data set. There is a bit of preprocessing to do in\n",
+        "order to encode the inputs into the amplitudes of a quantum state. In\n",
+        "the last preprocessing step, we translate the inputs x to rotation\n",
+        "angles using the `get_angles` function we defined above.\n",
+        "\n",
+        "::: {.note}\n",
+        "::: {.title}\n",
+        "Note\n",
+        ":::\n",
+        "\n",
+        "The Iris dataset can be downloaded\n",
+        "`<a href=\"https://raw.githubusercontent.com/XanaduAI/qml/master/demonstrations/variational_classifier/data/iris_classes1and2_scaled.txt\"\n",
+        "download=parity.txt target=\"_blank\">here</a>`{.interpreted-text\n",
+        "role=\"html\"} and should be placed in the subfolder\n",
+        "`variational_classifer/data`.\n",
+        ":::\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 47,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "et3_Zr0NyqM3",
+        "outputId": "2c21383a-e595-402c-e724-8ca03702b01e"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "First X sample (original)  : [0.4  0.75]\n",
+            "First X sample (padded)    : [0.4  0.75 0.3  0.  ]\n",
+            "First X sample (normalized): [0.44376016 0.83205029 0.33282012 0.        ]\n",
+            "First features sample      : [ 0.67858523 -0.          0.         -1.080839    1.080839  ]\n"
+          ]
+        }
+      ],
+      "source": [
+        "data = np.loadtxt(\"/content/drive/MyDrive/Colab Notebooks/data/iris_classes1and2_scaled.txt\")\n",
+        "X = data[:, 0:2]\n",
+        "print(\"First X sample (original)  :\", X[0])\n",
+        "\n",
+        "# pad the vectors to size 2^2 with constant values\n",
+        "padding = 0.3 * np.ones((len(X), 1))\n",
+        "X_pad = np.c_[np.c_[X, padding], np.zeros((len(X), 1))]\n",
+        "print(\"First X sample (padded)    :\", X_pad[0])\n",
+        "\n",
+        "# normalize each input\n",
+        "normalization = np.sqrt(np.sum(X_pad ** 2, -1))\n",
+        "X_norm = (X_pad.T / normalization).T\n",
+        "print(\"First X sample (normalized):\", X_norm[0])\n",
+        "\n",
+        "# angles for state preparation are new features\n",
+        "features = np.array([get_angles(x) for x in X_norm], requires_grad=False)\n",
+        "print(\"First features sample      :\", features[0])\n",
+        "\n",
+        "Y = data[:, -1]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "zMijswcpyqM3"
+      },
+      "source": [
+        "These angles are our new features, which is why we have renamed X to\n",
+        "\"features\" above. Let's plot the stages of preprocessing and play around\n",
+        "with the dimensions (dim1, dim2). Some of them still separate the\n",
+        "classes well, while others are less informative.\n",
+        "\n",
+        "*Note: To run the following code you need the matplotlib library.*\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 48,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1322
+        },
+        "id": "QgntUWEUyqM3",
+        "outputId": "31d7d199-f715-44a4-ce8d-f53c2ae86b8b"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "plt.figure()\n",
+        "plt.scatter(X[:, 0][Y == 1], X[:, 1][Y == 1], c=\"b\", marker=\"o\", edgecolors=\"k\")\n",
+        "plt.scatter(X[:, 0][Y == -1], X[:, 1][Y == -1], c=\"r\", marker=\"o\", edgecolors=\"k\")\n",
+        "plt.title(\"Original data\")\n",
+        "plt.show()\n",
+        "\n",
+        "plt.figure()\n",
+        "dim1 = 0\n",
+        "dim2 = 1\n",
+        "plt.scatter(\n",
+        "    X_norm[:, dim1][Y == 1], X_norm[:, dim2][Y == 1], c=\"b\", marker=\"o\", edgecolors=\"k\"\n",
+        ")\n",
+        "plt.scatter(\n",
+        "    X_norm[:, dim1][Y == -1], X_norm[:, dim2][Y == -1], c=\"r\", marker=\"o\", edgecolors=\"k\"\n",
+        ")\n",
+        "plt.title(\"Padded and normalised data (dims {} and {})\".format(dim1, dim2))\n",
+        "plt.show()\n",
+        "\n",
+        "plt.figure()\n",
+        "dim1 = 0\n",
+        "dim2 = 3\n",
+        "plt.scatter(\n",
+        "    features[:, dim1][Y == 1], features[:, dim2][Y == 1], c=\"b\", marker=\"o\", edgecolors=\"k\"\n",
+        ")\n",
+        "plt.scatter(\n",
+        "    features[:, dim1][Y == -1], features[:, dim2][Y == -1], c=\"r\", marker=\"o\", edgecolors=\"k\"\n",
+        ")\n",
+        "plt.title(\"Feature vectors (dims {} and {})\".format(dim1, dim2))\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "TxCo27TgyqM3"
+      },
+      "source": [
+        "This time we want to generalize from the data samples. To monitor the\n",
+        "generalization performance, the data is split into training and\n",
+        "validation set.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 49,
+      "metadata": {
+        "id": "UcsJlhOpyqM4"
+      },
+      "outputs": [],
+      "source": [
+        "np.random.seed(0)\n",
+        "num_data = len(Y)\n",
+        "num_train = int(0.75 * num_data)\n",
+        "index = np.random.permutation(range(num_data))\n",
+        "feats_train = features[index[:num_train]]\n",
+        "Y_train = Y[index[:num_train]]\n",
+        "feats_val = features[index[num_train:]]\n",
+        "Y_val = Y[index[num_train:]]\n",
+        "\n",
+        "# We need these later for plotting\n",
+        "X_train = X[index[:num_train]]\n",
+        "X_val = X[index[num_train:]]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xjGPKWISyqM4"
+      },
+      "source": [
+        "Optimization\n",
+        "============\n",
+        "\n",
+        "First we initialize the variables.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 50,
+      "metadata": {
+        "id": "MklsrHJcyqM4"
+      },
+      "outputs": [],
+      "source": [
+        "num_qubits = 2\n",
+        "num_layers = 10\n",
+        "\n",
+        "weights_init = 0.01 * np.random.randn(num_layers, num_qubits, 3, requires_grad=True)\n",
+        "bias_init = np.array(0.0, requires_grad=True)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "VQtBYXZgyqM4"
+      },
+      "source": [
+        "Again we optimize the cost. This may take a little patience.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 51,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "je5m-mNCyqM4",
+        "outputId": "687f3d0f-3e08-4730-93b9-493a4dadb0dc"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iter:     1 | Cost: 1.4910696 | Acc train: 0.4933333 | Acc validation: 0.5600000 \n",
+            "Iter:     2 | Cost: 1.4240094 | Acc train: 0.4933333 | Acc validation: 0.5600000 \n",
+            "Iter:     3 | Cost: 1.3471094 | Acc train: 0.4933333 | Acc validation: 0.5600000 \n",
+            "Iter:     4 | Cost: 1.1653896 | Acc train: 0.4800000 | Acc validation: 0.5600000 \n",
+            "Iter:     5 | Cost: 1.0317758 | Acc train: 0.4666667 | Acc validation: 0.5600000 \n",
+            "Iter:     6 | Cost: 0.9468824 | Acc train: 0.5066667 | Acc validation: 0.6000000 \n",
+            "Iter:     7 | Cost: 0.9264683 | Acc train: 0.5333333 | Acc validation: 0.6000000 \n",
+            "Iter:     8 | Cost: 0.8678832 | Acc train: 0.5866667 | Acc validation: 0.6400000 \n",
+            "Iter:     9 | Cost: 0.8347700 | Acc train: 0.6000000 | Acc validation: 0.7200000 \n",
+            "Iter:    10 | Cost: 0.7828497 | Acc train: 0.6666667 | Acc validation: 0.7600000 \n",
+            "Iter:    11 | Cost: 0.7461693 | Acc train: 0.7466667 | Acc validation: 0.8000000 \n",
+            "Iter:    12 | Cost: 0.7255578 | Acc train: 0.8666667 | Acc validation: 1.0000000 \n",
+            "Iter:    13 | Cost: 0.7383022 | Acc train: 0.7733333 | Acc validation: 0.6800000 \n",
+            "Iter:    14 | Cost: 0.7608089 | Acc train: 0.6400000 | Acc validation: 0.6400000 \n",
+            "Iter:    15 | Cost: 0.7611822 | Acc train: 0.6266667 | Acc validation: 0.6400000 \n",
+            "Iter:    16 | Cost: 0.8070921 | Acc train: 0.5333333 | Acc validation: 0.4400000 \n",
+            "Iter:    17 | Cost: 0.8065847 | Acc train: 0.5333333 | Acc validation: 0.4400000 \n",
+            "Iter:    18 | Cost: 0.7618987 | Acc train: 0.5600000 | Acc validation: 0.4800000 \n",
+            "Iter:    19 | Cost: 0.7286008 | Acc train: 0.6666667 | Acc validation: 0.6400000 \n",
+            "Iter:    20 | Cost: 0.7076309 | Acc train: 0.9333333 | Acc validation: 1.0000000 \n",
+            "Iter:    21 | Cost: 0.7079070 | Acc train: 0.9333333 | Acc validation: 0.9600000 \n",
+            "Iter:    22 | Cost: 0.7030350 | Acc train: 0.9466667 | Acc validation: 0.9600000 \n",
+            "Iter:    23 | Cost: 0.6902755 | Acc train: 0.9333333 | Acc validation: 0.9600000 \n",
+            "Iter:    24 | Cost: 0.6868425 | Acc train: 0.8133333 | Acc validation: 0.8000000 \n",
+            "Iter:    25 | Cost: 0.6738455 | Acc train: 0.7866667 | Acc validation: 0.8000000 \n",
+            "Iter:    26 | Cost: 0.6606205 | Acc train: 0.7333333 | Acc validation: 0.7600000 \n",
+            "Iter:    27 | Cost: 0.6318160 | Acc train: 0.8266667 | Acc validation: 0.8400000 \n",
+            "Iter:    28 | Cost: 0.6061572 | Acc train: 0.8666667 | Acc validation: 0.8400000 \n",
+            "Iter:    29 | Cost: 0.5911872 | Acc train: 0.8266667 | Acc validation: 0.8400000 \n",
+            "Iter:    30 | Cost: 0.5850482 | Acc train: 0.8133333 | Acc validation: 0.8000000 \n",
+            "Iter:    31 | Cost: 0.5870153 | Acc train: 0.7466667 | Acc validation: 0.7600000 \n",
+            "Iter:    32 | Cost: 0.5428523 | Acc train: 0.8133333 | Acc validation: 0.8400000 \n",
+            "Iter:    33 | Cost: 0.5103184 | Acc train: 0.8266667 | Acc validation: 0.8400000 \n",
+            "Iter:    34 | Cost: 0.4850358 | Acc train: 0.8666667 | Acc validation: 0.8400000 \n",
+            "Iter:    35 | Cost: 0.4625864 | Acc train: 0.8800000 | Acc validation: 0.8400000 \n",
+            "Iter:    36 | Cost: 0.4223891 | Acc train: 0.8933333 | Acc validation: 0.8400000 \n",
+            "Iter:    37 | Cost: 0.3658122 | Acc train: 0.9333333 | Acc validation: 0.9200000 \n",
+            "Iter:    38 | Cost: 0.3327043 | Acc train: 0.9733333 | Acc validation: 1.0000000 \n",
+            "Iter:    39 | Cost: 0.3093051 | Acc train: 0.9866667 | Acc validation: 1.0000000 \n",
+            "Iter:    40 | Cost: 0.2881224 | Acc train: 0.9866667 | Acc validation: 1.0000000 \n",
+            "Iter:    41 | Cost: 0.2731335 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    42 | Cost: 0.2604148 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    43 | Cost: 0.2514606 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    44 | Cost: 0.2447224 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    45 | Cost: 0.2426475 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    46 | Cost: 0.2395655 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    47 | Cost: 0.2348980 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    48 | Cost: 0.2340316 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    49 | Cost: 0.2413600 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    50 | Cost: 0.2563341 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    51 | Cost: 0.2674190 | Acc train: 1.0000000 | Acc validation: 0.9600000 \n",
+            "Iter:    52 | Cost: 0.2610556 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    53 | Cost: 0.2404683 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    54 | Cost: 0.2327135 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n",
+            "Iter:    55 | Cost: 0.2352412 | Acc train: 1.0000000 | Acc validation: 1.0000000 \n"
+          ]
+        }
+      ],
+      "source": [
+        "opt = NesterovMomentumOptimizer(0.01)\n",
+        "batch_size = 5\n",
+        "\n",
+        "# train the variational classifier\n",
+        "weights = weights_init\n",
+        "bias = bias_init\n",
+        "for it in range(55):\n",
+        "\n",
+        "    # Update the weights by one optimizer step\n",
+        "    batch_index = np.random.randint(0, num_train, (batch_size,))\n",
+        "    feats_train_batch = feats_train[batch_index]\n",
+        "    Y_train_batch = Y_train[batch_index]\n",
+        "    weights, bias, _, _ = opt.step(cost, weights, bias, feats_train_batch, Y_train_batch)\n",
+        "\n",
+        "    # Compute predictions on train and validation set\n",
+        "    predictions_train = [np.sign(variational_classifier(weights, bias, f)) for f in feats_train]\n",
+        "    predictions_val = [np.sign(variational_classifier(weights, bias, f)) for f in feats_val]\n",
+        "\n",
+        "    # Compute accuracy on train and validation set\n",
+        "    acc_train = accuracy(Y_train, predictions_train)\n",
+        "    acc_val = accuracy(Y_val, predictions_val)\n",
+        "\n",
+        "    print(\n",
+        "        \"Iter: {:5d} | Cost: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} \"\n",
+        "        \"\".format(it + 1, cost(weights, bias, features, Y), acc_train, acc_val)\n",
+        "    )"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fqozdRWMyqM4"
+      },
+      "source": [
+        "We can plot the continuous output of the variational classifier for the\n",
+        "first two dimensions of the Iris data set.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 52,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 430
+        },
+        "id": "Aju2qpgByqM4",
+        "outputId": "f930536e-e9e9-47c5-dbf1-75700a6e1150"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 640x480 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.figure()\n",
+        "cm = plt.cm.RdBu\n",
+        "\n",
+        "# make data for decision regions\n",
+        "xx, yy = np.meshgrid(np.linspace(0.0, 1.5, 20), np.linspace(0.0, 1.5, 20))\n",
+        "X_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())]\n",
+        "\n",
+        "# preprocess grid points like data inputs above\n",
+        "padding = 0.3 * np.ones((len(X_grid), 1))\n",
+        "X_grid = np.c_[np.c_[X_grid, padding], np.zeros((len(X_grid), 1))]  # pad each input\n",
+        "normalization = np.sqrt(np.sum(X_grid ** 2, -1))\n",
+        "X_grid = (X_grid.T / normalization).T  # normalize each input\n",
+        "features_grid = np.array(\n",
+        "    [get_angles(x) for x in X_grid]\n",
+        ")  # angles for state preparation are new features\n",
+        "predictions_grid = [variational_classifier(weights, bias, f) for f in features_grid]\n",
+        "Z = np.reshape(predictions_grid, xx.shape)\n",
+        "\n",
+        "# plot decision regions\n",
+        "cnt = plt.contourf(\n",
+        "    xx, yy, Z, levels=np.arange(-1, 1.1, 0.1), cmap=cm, alpha=0.8, extend=\"both\"\n",
+        ")\n",
+        "plt.contour(\n",
+        "    xx, yy, Z, levels=[0.0], colors=(\"black\",), linestyles=(\"--\",), linewidths=(0.8,)\n",
+        ")\n",
+        "plt.colorbar(cnt, ticks=[-1, 0, 1])\n",
+        "\n",
+        "# plot data\n",
+        "plt.scatter(\n",
+        "    X_train[:, 0][Y_train == 1],\n",
+        "    X_train[:, 1][Y_train == 1],\n",
+        "    c=\"b\",\n",
+        "    marker=\"o\",\n",
+        "    edgecolors=\"k\",\n",
+        "    label=\"class 1 train\",\n",
+        ")\n",
+        "plt.scatter(\n",
+        "    X_val[:, 0][Y_val == 1],\n",
+        "    X_val[:, 1][Y_val == 1],\n",
+        "    c=\"b\",\n",
+        "    marker=\"^\",\n",
+        "    edgecolors=\"k\",\n",
+        "    label=\"class 1 validation\",\n",
+        ")\n",
+        "plt.scatter(\n",
+        "    X_train[:, 0][Y_train == -1],\n",
+        "    X_train[:, 1][Y_train == -1],\n",
+        "    c=\"r\",\n",
+        "    marker=\"o\",\n",
+        "    edgecolors=\"k\",\n",
+        "    label=\"class -1 train\",\n",
+        ")\n",
+        "plt.scatter(\n",
+        "    X_val[:, 0][Y_val == -1],\n",
+        "    X_val[:, 1][Y_val == -1],\n",
+        "    c=\"r\",\n",
+        "    marker=\"^\",\n",
+        "    edgecolors=\"k\",\n",
+        "    label=\"class -1 validation\",\n",
+        ")\n",
+        "\n",
+        "plt.legend()\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PQxSiY4ZyqM4"
+      },
+      "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": "P2zpMNTeG-uN",
+        "outputId": "229a8b03-4242-4b25-a438-28695a8c5734"
+      },
+      "execution_count": 53,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since end of run: 1700615789.5294883\n",
+            "Wed Nov 22 01:16:29 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.17"
+    },
+    "colab": {
+      "provenance": [],
+      "machine_shape": "hm"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}