849 lines (848 with data), 164.4 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "A7xgHxPxd0J_",
        "outputId": "a451f08d-11f6-4bfb-aaaa-aacc94bf335d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1706000532.674983\n",
            "Tue Jan 23 09:02:12 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": 41,
      "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": 42,
      "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": 43,
      "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": 44,
      "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",
        "\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": 45,
      "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": 46,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "c3oexS3hd0KD",
        "outputId": "2c6fd948-1e5f-49af-fbe9-c5807e289533"
      },
      "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": 47,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1006
        },
        "id": "2ckiL7srd0KE",
        "outputId": "8f230428-4604-40f8-f41e-ad195ecb5883"
      },
      "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": 48,
      "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": 49,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "Zj8fE8uhd0KF",
        "outputId": "4b04e624-d0ab-4698-f90a-fd458fcb4dd1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "13/13 - 1s - loss: 2.8481 - accuracy: 0.0600 - val_loss: 1.9021 - val_accuracy: 0.2667 - 634ms/epoch - 49ms/step\n",
            "Epoch 2/30\n",
            "13/13 - 0s - loss: 2.0555 - accuracy: 0.2400 - val_loss: 1.7946 - val_accuracy: 0.4333 - 58ms/epoch - 4ms/step\n",
            "Epoch 3/30\n",
            "13/13 - 0s - loss: 1.5602 - accuracy: 0.4600 - val_loss: 1.5959 - val_accuracy: 0.3667 - 57ms/epoch - 4ms/step\n",
            "Epoch 4/30\n",
            "13/13 - 0s - loss: 1.1533 - accuracy: 0.6600 - val_loss: 1.3802 - val_accuracy: 0.6000 - 58ms/epoch - 4ms/step\n",
            "Epoch 5/30\n",
            "13/13 - 0s - loss: 0.9763 - accuracy: 0.7600 - val_loss: 1.3067 - val_accuracy: 0.6000 - 62ms/epoch - 5ms/step\n",
            "Epoch 6/30\n",
            "13/13 - 0s - loss: 0.8007 - accuracy: 0.8800 - val_loss: 1.2756 - val_accuracy: 0.6333 - 60ms/epoch - 5ms/step\n",
            "Epoch 7/30\n",
            "13/13 - 0s - loss: 0.6282 - accuracy: 0.8800 - val_loss: 1.1779 - val_accuracy: 0.6333 - 62ms/epoch - 5ms/step\n",
            "Epoch 8/30\n",
            "13/13 - 0s - loss: 0.5104 - accuracy: 0.9800 - val_loss: 1.1393 - val_accuracy: 0.6667 - 64ms/epoch - 5ms/step\n",
            "Epoch 9/30\n",
            "13/13 - 0s - loss: 0.4416 - accuracy: 0.9600 - val_loss: 1.1094 - val_accuracy: 0.6667 - 60ms/epoch - 5ms/step\n",
            "Epoch 10/30\n",
            "13/13 - 0s - loss: 0.3533 - accuracy: 0.9800 - val_loss: 1.1126 - val_accuracy: 0.7333 - 69ms/epoch - 5ms/step\n",
            "Epoch 11/30\n",
            "13/13 - 0s - loss: 0.3269 - accuracy: 0.9800 - val_loss: 1.0447 - val_accuracy: 0.7333 - 64ms/epoch - 5ms/step\n",
            "Epoch 12/30\n",
            "13/13 - 0s - loss: 0.2835 - accuracy: 1.0000 - val_loss: 1.0868 - val_accuracy: 0.6000 - 67ms/epoch - 5ms/step\n",
            "Epoch 13/30\n",
            "13/13 - 0s - loss: 0.2458 - accuracy: 1.0000 - val_loss: 1.0278 - val_accuracy: 0.7000 - 68ms/epoch - 5ms/step\n",
            "Epoch 14/30\n",
            "13/13 - 0s - loss: 0.2351 - accuracy: 1.0000 - val_loss: 0.9897 - val_accuracy: 0.7333 - 67ms/epoch - 5ms/step\n",
            "Epoch 15/30\n",
            "13/13 - 0s - loss: 0.1879 - accuracy: 1.0000 - val_loss: 1.0072 - val_accuracy: 0.7333 - 60ms/epoch - 5ms/step\n",
            "Epoch 16/30\n",
            "13/13 - 0s - loss: 0.1629 - accuracy: 1.0000 - val_loss: 1.0040 - val_accuracy: 0.7333 - 59ms/epoch - 5ms/step\n",
            "Epoch 17/30\n",
            "13/13 - 0s - loss: 0.1563 - accuracy: 1.0000 - val_loss: 0.9802 - val_accuracy: 0.6667 - 69ms/epoch - 5ms/step\n",
            "Epoch 18/30\n",
            "13/13 - 0s - loss: 0.1350 - accuracy: 1.0000 - val_loss: 0.9918 - val_accuracy: 0.6667 - 63ms/epoch - 5ms/step\n",
            "Epoch 19/30\n",
            "13/13 - 0s - loss: 0.1243 - accuracy: 1.0000 - val_loss: 0.9774 - val_accuracy: 0.7000 - 56ms/epoch - 4ms/step\n",
            "Epoch 20/30\n",
            "13/13 - 0s - loss: 0.1158 - accuracy: 1.0000 - val_loss: 0.9486 - val_accuracy: 0.7333 - 60ms/epoch - 5ms/step\n",
            "Epoch 21/30\n",
            "13/13 - 0s - loss: 0.1065 - accuracy: 1.0000 - val_loss: 0.9731 - val_accuracy: 0.7333 - 64ms/epoch - 5ms/step\n",
            "Epoch 22/30\n",
            "13/13 - 0s - loss: 0.0976 - accuracy: 1.0000 - val_loss: 0.9788 - val_accuracy: 0.6333 - 66ms/epoch - 5ms/step\n",
            "Epoch 23/30\n",
            "13/13 - 0s - loss: 0.0916 - accuracy: 1.0000 - val_loss: 0.9479 - val_accuracy: 0.7000 - 58ms/epoch - 4ms/step\n",
            "Epoch 24/30\n",
            "13/13 - 0s - loss: 0.0845 - accuracy: 1.0000 - val_loss: 0.9399 - val_accuracy: 0.7000 - 58ms/epoch - 4ms/step\n",
            "Epoch 25/30\n",
            "13/13 - 0s - loss: 0.0823 - accuracy: 1.0000 - val_loss: 0.9394 - val_accuracy: 0.7333 - 63ms/epoch - 5ms/step\n",
            "Epoch 26/30\n",
            "13/13 - 0s - loss: 0.0730 - accuracy: 1.0000 - val_loss: 0.9388 - val_accuracy: 0.6667 - 63ms/epoch - 5ms/step\n",
            "Epoch 27/30\n",
            "13/13 - 0s - loss: 0.0696 - accuracy: 1.0000 - val_loss: 0.9393 - val_accuracy: 0.6667 - 63ms/epoch - 5ms/step\n",
            "Epoch 28/30\n",
            "13/13 - 0s - loss: 0.0685 - accuracy: 1.0000 - val_loss: 0.9293 - val_accuracy: 0.7333 - 58ms/epoch - 4ms/step\n",
            "Epoch 29/30\n",
            "13/13 - 0s - loss: 0.0626 - accuracy: 1.0000 - val_loss: 0.9379 - val_accuracy: 0.7000 - 64ms/epoch - 5ms/step\n",
            "Epoch 30/30\n",
            "13/13 - 0s - loss: 0.0581 - accuracy: 1.0000 - val_loss: 0.9287 - val_accuracy: 0.7333 - 66ms/epoch - 5ms/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": 50,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "xVJR8xXcd0KF",
        "outputId": "f9da64c5-0a15-4e14-bf57-9691f01a49ad"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/30\n",
            "13/13 - 1s - loss: 2.3161 - accuracy: 0.1000 - val_loss: 2.1424 - val_accuracy: 0.2333 - 596ms/epoch - 46ms/step\n",
            "Epoch 2/30\n",
            "13/13 - 0s - loss: 1.9413 - accuracy: 0.4400 - val_loss: 2.0106 - val_accuracy: 0.4000 - 58ms/epoch - 4ms/step\n",
            "Epoch 3/30\n",
            "13/13 - 0s - loss: 1.6574 - accuracy: 0.6200 - val_loss: 1.8778 - val_accuracy: 0.5333 - 59ms/epoch - 5ms/step\n",
            "Epoch 4/30\n",
            "13/13 - 0s - loss: 1.4239 - accuracy: 0.7400 - val_loss: 1.7541 - val_accuracy: 0.5667 - 59ms/epoch - 5ms/step\n",
            "Epoch 5/30\n",
            "13/13 - 0s - loss: 1.2229 - accuracy: 0.8200 - val_loss: 1.6397 - val_accuracy: 0.6333 - 66ms/epoch - 5ms/step\n",
            "Epoch 6/30\n",
            "13/13 - 0s - loss: 1.0643 - accuracy: 0.8600 - val_loss: 1.5453 - val_accuracy: 0.6667 - 65ms/epoch - 5ms/step\n",
            "Epoch 7/30\n",
            "13/13 - 0s - loss: 0.9290 - accuracy: 0.9000 - val_loss: 1.4749 - val_accuracy: 0.7000 - 62ms/epoch - 5ms/step\n",
            "Epoch 8/30\n",
            "13/13 - 0s - loss: 0.8146 - accuracy: 0.9200 - val_loss: 1.4082 - val_accuracy: 0.7000 - 66ms/epoch - 5ms/step\n",
            "Epoch 9/30\n",
            "13/13 - 0s - loss: 0.7191 - accuracy: 0.9600 - val_loss: 1.3524 - val_accuracy: 0.7000 - 59ms/epoch - 5ms/step\n",
            "Epoch 10/30\n",
            "13/13 - 0s - loss: 0.6384 - accuracy: 0.9600 - val_loss: 1.3109 - val_accuracy: 0.7000 - 58ms/epoch - 4ms/step\n",
            "Epoch 11/30\n",
            "13/13 - 0s - loss: 0.5761 - accuracy: 0.9600 - val_loss: 1.2666 - val_accuracy: 0.6667 - 57ms/epoch - 4ms/step\n",
            "Epoch 12/30\n",
            "13/13 - 0s - loss: 0.5188 - accuracy: 0.9800 - val_loss: 1.2518 - val_accuracy: 0.6667 - 61ms/epoch - 5ms/step\n",
            "Epoch 13/30\n",
            "13/13 - 0s - loss: 0.4691 - accuracy: 1.0000 - val_loss: 1.2206 - val_accuracy: 0.7000 - 63ms/epoch - 5ms/step\n",
            "Epoch 14/30\n",
            "13/13 - 0s - loss: 0.4228 - accuracy: 1.0000 - val_loss: 1.1836 - val_accuracy: 0.7000 - 59ms/epoch - 5ms/step\n",
            "Epoch 15/30\n",
            "13/13 - 0s - loss: 0.3839 - accuracy: 1.0000 - val_loss: 1.1603 - val_accuracy: 0.7000 - 58ms/epoch - 4ms/step\n",
            "Epoch 16/30\n",
            "13/13 - 0s - loss: 0.3513 - accuracy: 1.0000 - val_loss: 1.1427 - val_accuracy: 0.7000 - 57ms/epoch - 4ms/step\n",
            "Epoch 17/30\n",
            "13/13 - 0s - loss: 0.3240 - accuracy: 1.0000 - val_loss: 1.1263 - val_accuracy: 0.7000 - 59ms/epoch - 5ms/step\n",
            "Epoch 18/30\n",
            "13/13 - 0s - loss: 0.2985 - accuracy: 1.0000 - val_loss: 1.1009 - val_accuracy: 0.7333 - 69ms/epoch - 5ms/step\n",
            "Epoch 19/30\n",
            "13/13 - 0s - loss: 0.2739 - accuracy: 1.0000 - val_loss: 1.0940 - val_accuracy: 0.7333 - 57ms/epoch - 4ms/step\n",
            "Epoch 20/30\n",
            "13/13 - 0s - loss: 0.2549 - accuracy: 1.0000 - val_loss: 1.0754 - val_accuracy: 0.7333 - 64ms/epoch - 5ms/step\n",
            "Epoch 21/30\n",
            "13/13 - 0s - loss: 0.2364 - accuracy: 1.0000 - val_loss: 1.0701 - val_accuracy: 0.7333 - 59ms/epoch - 5ms/step\n",
            "Epoch 22/30\n",
            "13/13 - 0s - loss: 0.2201 - accuracy: 1.0000 - val_loss: 1.0568 - val_accuracy: 0.7333 - 59ms/epoch - 5ms/step\n",
            "Epoch 23/30\n",
            "13/13 - 0s - loss: 0.2049 - accuracy: 1.0000 - val_loss: 1.0467 - val_accuracy: 0.7667 - 54ms/epoch - 4ms/step\n",
            "Epoch 24/30\n",
            "13/13 - 0s - loss: 0.1917 - accuracy: 1.0000 - val_loss: 1.0370 - val_accuracy: 0.7667 - 57ms/epoch - 4ms/step\n",
            "Epoch 25/30\n",
            "13/13 - 0s - loss: 0.1813 - accuracy: 1.0000 - val_loss: 1.0302 - val_accuracy: 0.7667 - 58ms/epoch - 4ms/step\n",
            "Epoch 26/30\n",
            "13/13 - 0s - loss: 0.1692 - accuracy: 1.0000 - val_loss: 1.0232 - val_accuracy: 0.7667 - 59ms/epoch - 5ms/step\n",
            "Epoch 27/30\n",
            "13/13 - 0s - loss: 0.1599 - accuracy: 1.0000 - val_loss: 1.0124 - val_accuracy: 0.7667 - 61ms/epoch - 5ms/step\n",
            "Epoch 28/30\n",
            "13/13 - 0s - loss: 0.1517 - accuracy: 1.0000 - val_loss: 1.0051 - val_accuracy: 0.7333 - 68ms/epoch - 5ms/step\n",
            "Epoch 29/30\n",
            "13/13 - 0s - loss: 0.1427 - accuracy: 1.0000 - val_loss: 1.0031 - val_accuracy: 0.7333 - 55ms/epoch - 4ms/step\n",
            "Epoch 30/30\n",
            "13/13 - 0s - loss: 0.1346 - accuracy: 1.0000 - val_loss: 0.9982 - val_accuracy: 0.7333 - 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": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 963
        },
        "id": "fwDEhq0Qd0KF",
        "outputId": "9ebca639-3bbb-47fc-8525-8814ad187ece"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-51-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": "8d650552-8908-4056-d1c0-a9e6cb50a2e8"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since end of run: 1706000683.8116486\n",
            "Tue Jan 23 09:04:43 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
}