853 lines (852 with data), 162.3 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "A7xgHxPxd0J_",
        "outputId": "9245556e-8286-4bf0-c05b-77cb1b4f266a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1706001107.4723277\n",
            "Tue Jan 23 09:11:47 2024\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": "RWYw4Yy7d0KA"
      },
      "source": [
        "Quanvolutional Neural Networks {#quanvolution}\n",
        "==============================\n",
        "\n",
        "::: {.meta}\n",
        ":property=\\\"og:description\\\": Train a quantum convolutional neural\n",
        "network to classify MNIST images. :property=\\\"og:image\\\":\n",
        "<https://pennylane.ai/qml/_static/demonstration_assets//circuit.png>\n",
        ":::\n",
        "\n",
        "*Author: Andrea Mari --- Posted: 24 March 2020. Last updated: 15 January\n",
        "2021.*\n",
        "\n",
        "In this demo we implement the *Quanvolutional Neural Network*, a quantum\n",
        "machine learning model originally introduced in [Henderson et al.\n",
        "(2019)](https://arxiv.org/abs/1904.04767).\n",
        "\n",
        "![](../_static/demonstration_assets/quanvolution/circuit.png){.align-center\n",
        "width=\"90.0%\"}\n",
        "\n",
        "Introduction\n",
        "------------\n",
        "\n",
        "### Classical convolution\n",
        "\n",
        "The *convolutional neural network* (CNN) is a standard model in\n",
        "classical machine learning which is particularly suitable for processing\n",
        "images. The model is based on the idea of a *convolution layer* where,\n",
        "instead of processing the full input data with a global function, a\n",
        "local convolution is applied.\n",
        "\n",
        "If the input is an image, small local regions are sequentially processed\n",
        "with the same kernel. The results obtained for each region are usually\n",
        "associated to different channels of a single output pixel. The union of\n",
        "all the output pixels produces a new image-like object, which can be\n",
        "further processed by additional layers.\n",
        "\n",
        "### Quantum convolution\n",
        "\n",
        "One can extend the same idea also to the context of quantum variational\n",
        "circuits. A possible approach is given by the following procedure which\n",
        "is very similar to the one used in Ref. \\[1\\]. The scheme is also\n",
        "represented in the figure at the top of this tutorial.\n",
        "\n",
        "1.  A small region of the input image, in our example a $2 \\times 2$\n",
        "    square, is embedded into a quantum circuit. In this demo, this is\n",
        "    achieved with parametrized rotations applied to the qubits\n",
        "    initialized in the ground state.\n",
        "2.  A quantum computation, associated to a unitary $U$, is performed on\n",
        "    the system. The unitary could be generated by a variational quantum\n",
        "    circuit or, more simply, by a random circuit as proposed in Ref.\n",
        "    \\[1\\].\n",
        "3.  The quantum system is finally measured, obtaining a list of\n",
        "    classical expectation values. The measurement results could also be\n",
        "    classically post-processed as proposed in Ref. \\[1\\] but, for\n",
        "    simplicity, in this demo we directly use the raw expectation values.\n",
        "4.  Analogously to a classical convolution layer, each expectation value\n",
        "    is mapped to a different channel of a single output pixel.\n",
        "5.  Iterating the same procedure over different regions, one can scan\n",
        "    the full input image, producing an output object which will be\n",
        "    structured as a multi-channel image.\n",
        "6.  The quantum convolution can be followed by further quantum layers or\n",
        "    by classical layers.\n",
        "\n",
        "The main difference with respect to a classical convolution is that a\n",
        "quantum circuit can generate highly complex kernels whose computation\n",
        "could be, at least in principle, classically intractable.\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "In this tutorial we follow the approach of Ref. \\[1\\] in which a fixed\n",
        "non-trainable quantum circuit is used as a \\\"quanvolution\\\" kernel,\n",
        "while the subsequent classical layers are trained for the classification\n",
        "problem of interest. However, by leveraging the ability of PennyLane to\n",
        "evaluate gradients of quantum circuits, the quantum kernel could also be\n",
        "trained.\n",
        ":::\n",
        "\n",
        "General setup\n",
        "-------------\n",
        "\n",
        "This Python code requires *PennyLane* with the *TensorFlow* interface\n",
        "and the plotting library *matplotlib*.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "id": "VPbcKloNd0KC"
      },
      "outputs": [],
      "source": [
        "import pennylane as qml\n",
        "from pennylane import numpy as np\n",
        "from pennylane.templates import RandomLayers\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ISZAWXDMd0KC"
      },
      "source": [
        "Setting of the main hyper-parameters of the model\n",
        "=================================================\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "id": "1D5V-v5Vd0KC"
      },
      "outputs": [],
      "source": [
        "n_epochs = 30   # Number of optimization epochs\n",
        "n_layers = 1    # Number of random layers\n",
        "n_train = 50    # Size of the train dataset\n",
        "n_test = 30     # Size of the test dataset\n",
        "\n",
        "SAVE_PATH = \"/content/drive/MyDrive/Colab Notebooks/data/quanvolution\"  # Data saving folder\n",
        "PREPROCESS = True           # If False, skip quantum processing and load data from SAVE_PATH\n",
        "np.random.seed(0)           # Seed for NumPy random number generator\n",
        "tf.random.set_seed(0)       # Seed for TensorFlow random number generator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "avddR0atd0KC"
      },
      "source": [
        "Loading of the MNIST dataset\n",
        "============================\n",
        "\n",
        "We import the MNIST dataset from *Keras*. To speedup the evaluation of\n",
        "this demo we use only a small number of training and test images.\n",
        "Obviously, better results are achievable when using the full dataset.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "id": "xlhnv1hrd0KC"
      },
      "outputs": [],
      "source": [
        "mnist_dataset = keras.datasets.mnist\n",
        "(train_images, train_labels), (test_images, test_labels) = mnist_dataset.load_data()\n",
        "\n",
        "# Reduce dataset size\n",
        "train_images = train_images[:n_train]\n",
        "train_labels = train_labels[:n_train]\n",
        "test_images = test_images[:n_test]\n",
        "test_labels = test_labels[:n_test]\n",
        "\n",
        "# Normalize pixel values within 0 and 1\n",
        "train_images = train_images / 255\n",
        "test_images = test_images / 255\n",
        "\n",
        "# Add extra dimension for convolution channels\n",
        "train_images = np.array(train_images[..., tf.newaxis], requires_grad=False)\n",
        "test_images = np.array(test_images[..., tf.newaxis], requires_grad=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bDVPKQD8d0KD"
      },
      "source": [
        "Quantum circuit as a convolution kernel\n",
        "=======================================\n",
        "\n",
        "We follow the scheme described in the introduction and represented in\n",
        "the figure at the top of this demo.\n",
        "\n",
        "We initialize a PennyLane `default.qubit` device, simulating a system of\n",
        "$4$ qubits. The associated `qnode` represents the quantum circuit\n",
        "consisting of:\n",
        "\n",
        "1.  an embedding layer of local $R_y$ rotations (with angles scaled by a\n",
        "    factor of $\\pi$);\n",
        "2.  a random circuit of `n_layers`;\n",
        "3.  a final measurement in the computational basis, estimating $4$\n",
        "    expectation values.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "id": "rD5_3eztd0KD"
      },
      "outputs": [],
      "source": [
        "dev = qml.device(\"default.qubit\", wires=4)\n",
        "# Random circuit parameters\n",
        "rand_params = np.random.uniform(high=2 * np.pi, size=(n_layers, 4))\n",
        "\n",
        "@qml.qnode(dev)\n",
        "def circuit(phi):\n",
        "    # Encoding of 4 classical input values\n",
        "    for j in range(4):\n",
        "        qml.RY(np.pi * phi[j], wires=j)\n",
        "    for j in range(4):\n",
        "        qml.RY(np.pi * phi[j], wires=j)\n",
        "    for j in range(4):\n",
        "        qml.RY(np.pi * phi[j], wires=j)\n",
        "    for j in range(4):\n",
        "        qml.RY(np.pi * phi[j], wires=j)\n",
        "    for j in range(4):\n",
        "        qml.RY(np.pi * phi[j], wires=j)\n",
        "\n",
        "    # Measurement producing 4 classical output values\n",
        "    return [qml.expval(qml.PauliZ(j)) for j in range(4)]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "02g-DOe8d0KD"
      },
      "source": [
        "The next function defines the convolution scheme:\n",
        "\n",
        "1.  the image is divided into squares of $2 \\times 2$ pixels;\n",
        "2.  each square is processed by the quantum circuit;\n",
        "3.  the $4$ expectation values are mapped into $4$ different channels of\n",
        "    a single output pixel.\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "This process halves the resolution of the input image. In the standard\n",
        "language of CNN, this would correspond to a convolution with a\n",
        "$2 \\times 2$ *kernel* and a *stride* equal to $2$.\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "id": "AEL9cTFEd0KD"
      },
      "outputs": [],
      "source": [
        "def quanv(image):\n",
        "    \"\"\"Convolves the input image with many applications of the same quantum circuit.\"\"\"\n",
        "    out = np.zeros((14, 14, 4))\n",
        "\n",
        "    # Loop over the coordinates of the top-left pixel of 2X2 squares\n",
        "    for j in range(0, 28, 2):\n",
        "        for k in range(0, 28, 2):\n",
        "            # Process a squared 2x2 region of the image with a quantum circuit\n",
        "            q_results = circuit(\n",
        "                [\n",
        "                    image[j, k, 0],\n",
        "                    image[j, k + 1, 0],\n",
        "                    image[j + 1, k, 0],\n",
        "                    image[j + 1, k + 1, 0]\n",
        "                ]\n",
        "            )\n",
        "            # Assign expectation values to different channels of the output pixel (j/2, k/2)\n",
        "            for c in range(4):\n",
        "                out[j // 2, k // 2, c] = q_results[c]\n",
        "    return out"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N3MmyCQad0KD"
      },
      "source": [
        "Quantum pre-processing of the dataset\n",
        "=====================================\n",
        "\n",
        "Since we are not going to train the quantum convolution layer, it is\n",
        "more efficient to apply it as a \\\"pre-processing\\\" layer to all the\n",
        "images of our dataset. Later an entirely classical model will be\n",
        "directly trained and tested on the pre-processed dataset, avoiding\n",
        "unnecessary repetitions of quantum computations.\n",
        "\n",
        "The pre-processed images will be saved in the folder `SAVE_PATH`. Once\n",
        "saved, they can be directly loaded by setting `PREPROCESS = False`,\n",
        "otherwise the quantum convolution is evaluated at each run of the code.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "c3oexS3hd0KD",
        "outputId": "7e2cdcf7-7037-4230-b423-4a3882f3ef50"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Quantum pre-processing of train images:\n",
            "\n",
            "Quantum pre-processing of test images:\n"
          ]
        }
      ],
      "source": [
        "if PREPROCESS == True:\n",
        "    q_train_images = []\n",
        "    print(\"Quantum pre-processing of train images:\")\n",
        "    for idx, img in enumerate(train_images):\n",
        "        print(\"{}/{}        \".format(idx + 1, n_train), end=\"\\r\")\n",
        "        q_train_images.append(quanv(img))\n",
        "    q_train_images = np.asarray(q_train_images)\n",
        "\n",
        "    q_test_images = []\n",
        "    print(\"\\nQuantum pre-processing of test images:\")\n",
        "    for idx, img in enumerate(test_images):\n",
        "        print(\"{}/{}        \".format(idx + 1, n_test), end=\"\\r\")\n",
        "        q_test_images.append(quanv(img))\n",
        "    q_test_images = np.asarray(q_test_images)\n",
        "\n",
        "    # Save pre-processed images\n",
        "    np.save(SAVE_PATH + \"q_train_images.npy\", q_train_images)\n",
        "    np.save(SAVE_PATH + \"q_test_images.npy\", q_test_images)\n",
        "\n",
        "\n",
        "# Load pre-processed images\n",
        "q_train_images = np.load(SAVE_PATH + \"q_train_images.npy\")\n",
        "q_test_images = np.load(SAVE_PATH + \"q_test_images.npy\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kJYilWS1d0KE"
      },
      "source": [
        "Let us visualize the effect of the quantum convolution layer on a batch\n",
        "of samples:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "2ckiL7srd0KE",
        "outputId": "75cc8a80-8573-4abf-aed1-ace3fe942f9d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x1000 with 20 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "n_samples = 4\n",
        "n_channels = 4\n",
        "fig, axes = plt.subplots(1 + n_channels, n_samples, figsize=(10, 10))\n",
        "for k in range(n_samples):\n",
        "    axes[0, 0].set_ylabel(\"Input\")\n",
        "    if k != 0:\n",
        "        axes[0, k].yaxis.set_visible(False)\n",
        "    axes[0, k].imshow(train_images[k, :, :, 0], cmap=\"gray\")\n",
        "\n",
        "    # Plot all output channels\n",
        "    for c in range(n_channels):\n",
        "        axes[c + 1, 0].set_ylabel(\"Output [ch. {}]\".format(c))\n",
        "        if k != 0:\n",
        "            axes[c, k].yaxis.set_visible(False)\n",
        "        axes[c + 1, k].imshow(q_train_images[k, :, :, c], cmap=\"gray\")\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rCnk_yy0d0KE"
      },
      "source": [
        "Below each input image, the $4$ output channels generated by the quantum\n",
        "convolution are visualized in gray scale.\n",
        "\n",
        "One can clearly notice the downsampling of the resolution and some local\n",
        "distortion introduced by the quantum kernel. On the other hand the\n",
        "global shape of the image is preserved, as expected for a convolution\n",
        "layer.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vCjr6WvXd0KE"
      },
      "source": [
        "Hybrid quantum-classical model\n",
        "==============================\n",
        "\n",
        "After the application of the quantum convolution layer we feed the\n",
        "resulting features into a classical neural network that will be trained\n",
        "to classify the $10$ different digits of the MNIST dataset.\n",
        "\n",
        "We use a very simple model: just a fully connected layer with 10 output\n",
        "nodes with a final *softmax* activation function.\n",
        "\n",
        "The model is compiled with a *stochastic-gradient-descent* optimizer,\n",
        "and a *cross-entropy* loss function.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "id": "PHtPdynad0KE"
      },
      "outputs": [],
      "source": [
        "def MyModel():\n",
        "    \"\"\"Initializes and returns a custom Keras model\n",
        "    which is ready to be trained.\"\"\"\n",
        "    model = keras.models.Sequential([\n",
        "        keras.layers.Flatten(),\n",
        "        keras.layers.Dense(10, activation=\"softmax\")\n",
        "    ])\n",
        "\n",
        "    model.compile(\n",
        "        optimizer='adam',\n",
        "        loss=\"sparse_categorical_crossentropy\",\n",
        "        metrics=[\"accuracy\"],\n",
        "    )\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WlOj9hwGd0KE"
      },
      "source": [
        "Training\n",
        "========\n",
        "\n",
        "We first initialize an instance of the model, then we train and validate\n",
        "it with the dataset that has been already pre-processed by a quantum\n",
        "convolution.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Zj8fE8uhd0KF",
        "outputId": "62d8474f-b09d-49b2-f123-59a1de0fad62"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "13/13 - 1s - loss: 3.3982 - accuracy: 0.0800 - val_loss: 2.4322 - val_accuracy: 0.1667 - 618ms/epoch - 48ms/step\n",
            "Epoch 2/30\n",
            "13/13 - 0s - loss: 2.3140 - accuracy: 0.2200 - val_loss: 2.2665 - val_accuracy: 0.1667 - 61ms/epoch - 5ms/step\n",
            "Epoch 3/30\n",
            "13/13 - 0s - loss: 1.8342 - accuracy: 0.4000 - val_loss: 2.0048 - val_accuracy: 0.2333 - 55ms/epoch - 4ms/step\n",
            "Epoch 4/30\n",
            "13/13 - 0s - loss: 1.3792 - accuracy: 0.5600 - val_loss: 1.7315 - val_accuracy: 0.4000 - 58ms/epoch - 4ms/step\n",
            "Epoch 5/30\n",
            "13/13 - 0s - loss: 1.0954 - accuracy: 0.7400 - val_loss: 1.6365 - val_accuracy: 0.5333 - 60ms/epoch - 5ms/step\n",
            "Epoch 6/30\n",
            "13/13 - 0s - loss: 0.8925 - accuracy: 0.8600 - val_loss: 1.5946 - val_accuracy: 0.4667 - 62ms/epoch - 5ms/step\n",
            "Epoch 7/30\n",
            "13/13 - 0s - loss: 0.6799 - accuracy: 0.9600 - val_loss: 1.4987 - val_accuracy: 0.5667 - 59ms/epoch - 5ms/step\n",
            "Epoch 8/30\n",
            "13/13 - 0s - loss: 0.5317 - accuracy: 0.9800 - val_loss: 1.3944 - val_accuracy: 0.5667 - 58ms/epoch - 4ms/step\n",
            "Epoch 9/30\n",
            "13/13 - 0s - loss: 0.4489 - accuracy: 1.0000 - val_loss: 1.3570 - val_accuracy: 0.5667 - 60ms/epoch - 5ms/step\n",
            "Epoch 10/30\n",
            "13/13 - 0s - loss: 0.3587 - accuracy: 1.0000 - val_loss: 1.3851 - val_accuracy: 0.6000 - 61ms/epoch - 5ms/step\n",
            "Epoch 11/30\n",
            "13/13 - 0s - loss: 0.3260 - accuracy: 1.0000 - val_loss: 1.3113 - val_accuracy: 0.6000 - 61ms/epoch - 5ms/step\n",
            "Epoch 12/30\n",
            "13/13 - 0s - loss: 0.2876 - accuracy: 1.0000 - val_loss: 1.3493 - val_accuracy: 0.6000 - 60ms/epoch - 5ms/step\n",
            "Epoch 13/30\n",
            "13/13 - 0s - loss: 0.2440 - accuracy: 1.0000 - val_loss: 1.2804 - val_accuracy: 0.6000 - 59ms/epoch - 5ms/step\n",
            "Epoch 14/30\n",
            "13/13 - 0s - loss: 0.2329 - accuracy: 1.0000 - val_loss: 1.2621 - val_accuracy: 0.6000 - 56ms/epoch - 4ms/step\n",
            "Epoch 15/30\n",
            "13/13 - 0s - loss: 0.1906 - accuracy: 1.0000 - val_loss: 1.2416 - val_accuracy: 0.6333 - 58ms/epoch - 4ms/step\n",
            "Epoch 16/30\n",
            "13/13 - 0s - loss: 0.1655 - accuracy: 1.0000 - val_loss: 1.2744 - val_accuracy: 0.6333 - 59ms/epoch - 5ms/step\n",
            "Epoch 17/30\n",
            "13/13 - 0s - loss: 0.1579 - accuracy: 1.0000 - val_loss: 1.2545 - val_accuracy: 0.6333 - 63ms/epoch - 5ms/step\n",
            "Epoch 18/30\n",
            "13/13 - 0s - loss: 0.1364 - accuracy: 1.0000 - val_loss: 1.2386 - val_accuracy: 0.5667 - 59ms/epoch - 5ms/step\n",
            "Epoch 19/30\n",
            "13/13 - 0s - loss: 0.1261 - accuracy: 1.0000 - val_loss: 1.2477 - val_accuracy: 0.6000 - 58ms/epoch - 4ms/step\n",
            "Epoch 20/30\n",
            "13/13 - 0s - loss: 0.1165 - accuracy: 1.0000 - val_loss: 1.2106 - val_accuracy: 0.6333 - 58ms/epoch - 4ms/step\n",
            "Epoch 21/30\n",
            "13/13 - 0s - loss: 0.1061 - accuracy: 1.0000 - val_loss: 1.2456 - val_accuracy: 0.6000 - 61ms/epoch - 5ms/step\n",
            "Epoch 22/30\n",
            "13/13 - 0s - loss: 0.0974 - accuracy: 1.0000 - val_loss: 1.2140 - val_accuracy: 0.6333 - 60ms/epoch - 5ms/step\n",
            "Epoch 23/30\n",
            "13/13 - 0s - loss: 0.0922 - accuracy: 1.0000 - val_loss: 1.1991 - val_accuracy: 0.6000 - 55ms/epoch - 4ms/step\n",
            "Epoch 24/30\n",
            "13/13 - 0s - loss: 0.0851 - accuracy: 1.0000 - val_loss: 1.2005 - val_accuracy: 0.6333 - 58ms/epoch - 4ms/step\n",
            "Epoch 25/30\n",
            "13/13 - 0s - loss: 0.0828 - accuracy: 1.0000 - val_loss: 1.2124 - val_accuracy: 0.6333 - 60ms/epoch - 5ms/step\n",
            "Epoch 26/30\n",
            "13/13 - 0s - loss: 0.0742 - accuracy: 1.0000 - val_loss: 1.2000 - val_accuracy: 0.6000 - 61ms/epoch - 5ms/step\n",
            "Epoch 27/30\n",
            "13/13 - 0s - loss: 0.0710 - accuracy: 1.0000 - val_loss: 1.1876 - val_accuracy: 0.5667 - 57ms/epoch - 4ms/step\n",
            "Epoch 28/30\n",
            "13/13 - 0s - loss: 0.0707 - accuracy: 1.0000 - val_loss: 1.2066 - val_accuracy: 0.6333 - 58ms/epoch - 4ms/step\n",
            "Epoch 29/30\n",
            "13/13 - 0s - loss: 0.0638 - accuracy: 1.0000 - val_loss: 1.2051 - val_accuracy: 0.5667 - 57ms/epoch - 4ms/step\n",
            "Epoch 30/30\n",
            "13/13 - 0s - loss: 0.0591 - accuracy: 1.0000 - val_loss: 1.2000 - val_accuracy: 0.6333 - 57ms/epoch - 4ms/step\n"
          ]
        }
      ],
      "source": [
        "q_model = MyModel()\n",
        "\n",
        "q_history = q_model.fit(\n",
        "    q_train_images,\n",
        "    train_labels,\n",
        "    validation_data=(q_test_images, test_labels),\n",
        "    batch_size=4,\n",
        "    epochs=n_epochs,\n",
        "    verbose=2,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZrgNg_sSd0KF"
      },
      "source": [
        "In order to compare the results achievable with and without the quantum\n",
        "convolution layer, we initialize also a \\\"classical\\\" instance of the\n",
        "model that will be directly trained and validated with the raw MNIST\n",
        "images (i.e., without quantum pre-processing).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "xVJR8xXcd0KF",
        "outputId": "dde17096-324b-4952-b260-6ed4aebbc0d1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "13/13 - 1s - loss: 2.2841 - accuracy: 0.1600 - val_loss: 2.2303 - val_accuracy: 0.2000 - 595ms/epoch - 46ms/step\n",
            "Epoch 2/30\n",
            "13/13 - 0s - loss: 1.9151 - accuracy: 0.3600 - val_loss: 2.0875 - val_accuracy: 0.2333 - 60ms/epoch - 5ms/step\n",
            "Epoch 3/30\n",
            "13/13 - 0s - loss: 1.6244 - accuracy: 0.6000 - val_loss: 1.9563 - val_accuracy: 0.3000 - 57ms/epoch - 4ms/step\n",
            "Epoch 4/30\n",
            "13/13 - 0s - loss: 1.3999 - accuracy: 0.7600 - val_loss: 1.8314 - val_accuracy: 0.4333 - 58ms/epoch - 4ms/step\n",
            "Epoch 5/30\n",
            "13/13 - 0s - loss: 1.2055 - accuracy: 0.8600 - val_loss: 1.7188 - val_accuracy: 0.4667 - 60ms/epoch - 5ms/step\n",
            "Epoch 6/30\n",
            "13/13 - 0s - loss: 1.0482 - accuracy: 0.9000 - val_loss: 1.6277 - val_accuracy: 0.5333 - 62ms/epoch - 5ms/step\n",
            "Epoch 7/30\n",
            "13/13 - 0s - loss: 0.9132 - accuracy: 0.9400 - val_loss: 1.5588 - val_accuracy: 0.5667 - 68ms/epoch - 5ms/step\n",
            "Epoch 8/30\n",
            "13/13 - 0s - loss: 0.8004 - accuracy: 0.9400 - val_loss: 1.4942 - val_accuracy: 0.6000 - 63ms/epoch - 5ms/step\n",
            "Epoch 9/30\n",
            "13/13 - 0s - loss: 0.7067 - accuracy: 0.9600 - val_loss: 1.4353 - val_accuracy: 0.6667 - 61ms/epoch - 5ms/step\n",
            "Epoch 10/30\n",
            "13/13 - 0s - loss: 0.6278 - accuracy: 0.9600 - val_loss: 1.3951 - val_accuracy: 0.6667 - 59ms/epoch - 5ms/step\n",
            "Epoch 11/30\n",
            "13/13 - 0s - loss: 0.5670 - accuracy: 0.9800 - val_loss: 1.3493 - val_accuracy: 0.6667 - 56ms/epoch - 4ms/step\n",
            "Epoch 12/30\n",
            "13/13 - 0s - loss: 0.5099 - accuracy: 1.0000 - val_loss: 1.3366 - val_accuracy: 0.6667 - 62ms/epoch - 5ms/step\n",
            "Epoch 13/30\n",
            "13/13 - 0s - loss: 0.4598 - accuracy: 1.0000 - val_loss: 1.3056 - val_accuracy: 0.7000 - 66ms/epoch - 5ms/step\n",
            "Epoch 14/30\n",
            "13/13 - 0s - loss: 0.4156 - accuracy: 1.0000 - val_loss: 1.2667 - val_accuracy: 0.7000 - 63ms/epoch - 5ms/step\n",
            "Epoch 15/30\n",
            "13/13 - 0s - loss: 0.3775 - accuracy: 1.0000 - val_loss: 1.2387 - val_accuracy: 0.7000 - 57ms/epoch - 4ms/step\n",
            "Epoch 16/30\n",
            "13/13 - 0s - loss: 0.3453 - accuracy: 1.0000 - val_loss: 1.2205 - val_accuracy: 0.7000 - 60ms/epoch - 5ms/step\n",
            "Epoch 17/30\n",
            "13/13 - 0s - loss: 0.3180 - accuracy: 1.0000 - val_loss: 1.2042 - val_accuracy: 0.7000 - 65ms/epoch - 5ms/step\n",
            "Epoch 18/30\n",
            "13/13 - 0s - loss: 0.2930 - accuracy: 1.0000 - val_loss: 1.1806 - val_accuracy: 0.7000 - 71ms/epoch - 5ms/step\n",
            "Epoch 19/30\n",
            "13/13 - 0s - loss: 0.2694 - accuracy: 1.0000 - val_loss: 1.1752 - val_accuracy: 0.7000 - 68ms/epoch - 5ms/step\n",
            "Epoch 20/30\n",
            "13/13 - 0s - loss: 0.2501 - accuracy: 1.0000 - val_loss: 1.1549 - val_accuracy: 0.7000 - 65ms/epoch - 5ms/step\n",
            "Epoch 21/30\n",
            "13/13 - 0s - loss: 0.2323 - accuracy: 1.0000 - val_loss: 1.1502 - val_accuracy: 0.7000 - 61ms/epoch - 5ms/step\n",
            "Epoch 22/30\n",
            "13/13 - 0s - loss: 0.2159 - accuracy: 1.0000 - val_loss: 1.1358 - val_accuracy: 0.7000 - 59ms/epoch - 5ms/step\n",
            "Epoch 23/30\n",
            "13/13 - 0s - loss: 0.2013 - accuracy: 1.0000 - val_loss: 1.1257 - val_accuracy: 0.7000 - 68ms/epoch - 5ms/step\n",
            "Epoch 24/30\n",
            "13/13 - 0s - loss: 0.1882 - accuracy: 1.0000 - val_loss: 1.1157 - val_accuracy: 0.7000 - 58ms/epoch - 4ms/step\n",
            "Epoch 25/30\n",
            "13/13 - 0s - loss: 0.1775 - accuracy: 1.0000 - val_loss: 1.1089 - val_accuracy: 0.7000 - 56ms/epoch - 4ms/step\n",
            "Epoch 26/30\n",
            "13/13 - 0s - loss: 0.1659 - accuracy: 1.0000 - val_loss: 1.1014 - val_accuracy: 0.7000 - 66ms/epoch - 5ms/step\n",
            "Epoch 27/30\n",
            "13/13 - 0s - loss: 0.1568 - accuracy: 1.0000 - val_loss: 1.0906 - val_accuracy: 0.7000 - 59ms/epoch - 5ms/step\n",
            "Epoch 28/30\n",
            "13/13 - 0s - loss: 0.1486 - accuracy: 1.0000 - val_loss: 1.0831 - val_accuracy: 0.6667 - 70ms/epoch - 5ms/step\n",
            "Epoch 29/30\n",
            "13/13 - 0s - loss: 0.1400 - accuracy: 1.0000 - val_loss: 1.0802 - val_accuracy: 0.6667 - 62ms/epoch - 5ms/step\n",
            "Epoch 30/30\n",
            "13/13 - 0s - loss: 0.1319 - accuracy: 1.0000 - val_loss: 1.0752 - val_accuracy: 0.6667 - 59ms/epoch - 5ms/step\n"
          ]
        }
      ],
      "source": [
        "c_model = MyModel()\n",
        "\n",
        "c_history = c_model.fit(\n",
        "    train_images,\n",
        "    train_labels,\n",
        "    validation_data=(test_images, test_labels),\n",
        "    batch_size=4,\n",
        "    epochs=n_epochs,\n",
        "    verbose=2,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oXLGIhPJd0KF"
      },
      "source": [
        "Results\n",
        "=======\n",
        "\n",
        "We can finally plot the test accuracy and the test loss with respect to\n",
        "the number of training epochs.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 963
        },
        "id": "fwDEhq0Qd0KF",
        "outputId": "13493b34-510e-4ea8-a929-f47129f4c80a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-77-c3ef9ba498fb>:3: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-<style>'. Alternatively, directly use the seaborn API instead.\n",
            "  plt.style.use(\"seaborn\")\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x900 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.style.use(\"seaborn\")\n",
        "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(6, 9))\n",
        "\n",
        "ax1.plot(q_history.history[\"val_accuracy\"], \"-ob\", label=\"With quantum layer\")\n",
        "ax1.plot(c_history.history[\"val_accuracy\"], \"-og\", label=\"Without quantum layer\")\n",
        "ax1.set_ylabel(\"Accuracy\")\n",
        "ax1.set_ylim([0, 1])\n",
        "ax1.set_xlabel(\"Epoch\")\n",
        "ax1.legend()\n",
        "\n",
        "ax2.plot(q_history.history[\"val_loss\"], \"-ob\", label=\"With quantum layer\")\n",
        "ax2.plot(c_history.history[\"val_loss\"], \"-og\", label=\"Without quantum layer\")\n",
        "ax2.set_ylabel(\"Loss\")\n",
        "ax2.set_ylim(top=2.5)\n",
        "ax2.set_xlabel(\"Epoch\")\n",
        "ax2.legend()\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFIiSMV9d0KF"
      },
      "source": [
        "References\n",
        "==========\n",
        "\n",
        "1.  Maxwell Henderson, Samriddhi Shakya, Shashindra Pradhan, Tristan\n",
        "    Cook. \\\"Quanvolutional Neural Networks: Powering Image Recognition\n",
        "    with Quantum Circuits.\\\"\n",
        "    [arXiv:1904.04767](https://arxiv.org/abs/1904.04767), 2019.\n",
        "\n",
        "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": "DN7xl_1qggGu",
        "outputId": "80dcc6fc-d682-4ef2-ed9d-54c4677d5b7e"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1706001324.2815294\n",
            "Tue Jan 23 09:15:24 2024\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.10.13"
    },
    "colab": {
      "provenance": [],
      "machine_shape": "hm"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}