[404218]: / Code / PennyLane / 2 Class 4 Class 10 Class / 02 Class 98.7% kkawchak.ipynb

Download this file

1026 lines (1026 with data), 262.2 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 134,
      "metadata": {
        "id": "WNXEyZ23rdz-"
      },
      "outputs": [],
      "source": [
        "# This cell is added by sphinx-gallery\n",
        "# It can be customized to whatever you like\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2XSuLtL8rdz_"
      },
      "source": [
        "Quantum transfer learning {#quantum_transfer_learning}\n",
        "=========================\n",
        "\n",
        "::: {.meta}\n",
        ":property=\\\"og:description\\\": Combine PyTorch and PennyLane to train a\n",
        "hybrid quantum-classical image classifier using transfer learning.\n",
        ":property=\\\"og:image\\\":\n",
        "<https://pennylane.ai/qml/_images/transfer_images.png>\n",
        ":::\n",
        "\n",
        "*Author: Andrea Mari --- Posted: 19 December 2019. Last updated: 28\n",
        "January 2021.*\n",
        "\n",
        "In this tutorial we apply a machine learning method, known as *transfer\n",
        "learning*, to an image classifier based on a hybrid classical-quantum\n",
        "network.\n",
        "\n",
        "This example follows the general structure of the PyTorch [tutorial on\n",
        "transfer\n",
        "learning](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html)\n",
        "by Sasank Chilamkurthy, with the crucial difference of using a quantum\n",
        "circuit to perform the final classification task.\n",
        "\n",
        "More details on this topic can be found in the research paper \\[1\\]\n",
        "([Mari et al. (2019)](https://arxiv.org/abs/1912.08278)).\n",
        "\n",
        "Introduction\n",
        "------------\n",
        "\n",
        "Transfer learning is a well-established technique for training\n",
        "artificial neural networks (see e.g., Ref. \\[2\\]), which is based on the\n",
        "general intuition that if a pre-trained network is good at solving a\n",
        "given problem, then, with just a bit of additional training, it can be\n",
        "used to also solve a different but related problem.\n",
        "\n",
        "As discussed in Ref. \\[1\\], this idea can be formalized in terms of two\n",
        "abstract networks $A$ and $B$, independently from their quantum or\n",
        "classical physical nature.\n",
        "\n",
        "| \n",
        "\n",
        "![](../demonstrations/quantum_transfer_learning/transfer_learning_general.png){.align-center}\n",
        "\n",
        "| \n",
        "\n",
        "As sketched in the above figure, one can give the following **general\n",
        "definition of the transfer learning method**:\n",
        "\n",
        "1.  Take a network $A$ that has been pre-trained on a dataset $D_A$ and\n",
        "    for a given task $T_A$.\n",
        "2.  Remove some of the final layers. In this way, the resulting\n",
        "    truncated network $A'$ can be used as a feature extractor.\n",
        "3.  Connect a new trainable network $B$ at the end of the pre-trained\n",
        "    network $A'$.\n",
        "4.  Keep the weights of $A'$ constant, and train the final block $B$\n",
        "    with a new dataset $D_B$ and/or for a new task of interest $T_B$.\n",
        "\n",
        "When dealing with hybrid systems, depending on the physical nature\n",
        "(classical or quantum) of the networks $A$ and $B$, one can have\n",
        "different implementations of transfer learning as\n",
        "\n",
        "summarized in following table:\n",
        "\n",
        "| \n",
        "\n",
        "::: {.rst-class}\n",
        "docstable\n",
        ":::\n",
        "\n",
        "  -------------------------------------------------------------------------\n",
        "  Network A   Network B   Transfer learning scheme\n",
        "  ----------- ----------- -------------------------------------------------\n",
        "  Classical   Classical   CC - Standard classical method. See e.g., Ref.\n",
        "                          \\[2\\].\n",
        "\n",
        "  Classical   Quantum     CQ - **Hybrid model presented in this tutorial.**\n",
        "\n",
        "  Quantum     Classical   QC - Model studied in Ref. \\[1\\].\n",
        "\n",
        "  Quantum     Quantum     QQ - Model studied in Ref. \\[1\\].\n",
        "  -------------------------------------------------------------------------\n",
        "\n",
        "Classical-to-quantum transfer learning\n",
        "--------------------------------------\n",
        "\n",
        "We focus on the CQ transfer learning scheme discussed in the previous\n",
        "section and we give a specific example.\n",
        "\n",
        "1.  As pre-trained network $A$ we use **ResNet18**, a deep residual\n",
        "    neural network introduced by Microsoft in Ref. \\[3\\], which is\n",
        "    pre-trained on the *ImageNet* dataset.\n",
        "2.  After removing its final layer we obtain $A'$, a pre-processing\n",
        "    block which maps any input high-resolution image into 512 abstract\n",
        "    features.\n",
        "3.  Such features are classified by a 4-qubit \\\"dressed quantum\n",
        "    circuit\\\" $B$, i.e., a variational quantum circuit sandwiched\n",
        "    between two classical layers.\n",
        "4.  The hybrid model is trained, keeping $A'$ constant, on the\n",
        "    *Hymenoptera* dataset (a small subclass of ImageNet) containing\n",
        "    images of *ants* and *bees*.\n",
        "\n",
        "A graphical representation of the full data processing pipeline is given\n",
        "in the figure below.\n",
        "\n",
        "![](../demonstrations/quantum_transfer_learning/transfer_learning_c2q.png){.align-center}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eT6yf0-xrd0A"
      },
      "source": [
        "General setup\n",
        "=============\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "To use the PyTorch interface in PennyLane, you must first [install\n",
        "PyTorch](https://pytorch.org/get-started/locally/#start-locally).\n",
        ":::\n",
        "\n",
        "In addition to *PennyLane*, we will also need some standard *PyTorch*\n",
        "libraries and the plotting library *matplotlib*.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 135,
      "metadata": {
        "id": "sANL984ird0B"
      },
      "outputs": [],
      "source": [
        "#!pip install pennylane\n",
        "# Some parts of this code are based on the Python script:\n",
        "# https://github.com/pytorch/tutorials/blob/master/beginner_source/transfer_learning_tutorial.py\n",
        "# License: BSD\n",
        "\n",
        "import time\n",
        "import os\n",
        "import copy\n",
        "\n",
        "# PyTorch\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.optim import lr_scheduler\n",
        "import torchvision\n",
        "from torchvision import datasets, transforms\n",
        "\n",
        "# Pennylane\n",
        "import pennylane as qml\n",
        "from pennylane import numpy as np\n",
        "\n",
        "torch.manual_seed(42)\n",
        "np.random.seed(42)\n",
        "\n",
        "# Plotting\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# OpenMP: number of parallel threads.\n",
        "os.environ[\"OMP_NUM_THREADS\"] = \"1\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o7eGTk_Prd0B"
      },
      "source": [
        "Setting of the main hyper-parameters of the model\n",
        "=================================================\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "To reproduce the results of Ref. \\[1\\], `num_epochs` should be set to\n",
        "`30` which may take a long time. We suggest to first try with\n",
        "`num_epochs=1` and, if everything runs smoothly, increase it to a larger\n",
        "value.\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 136,
      "metadata": {
        "id": "Wncy61Mdrd0B"
      },
      "outputs": [],
      "source": [
        "n_qubits = 8                # Number of qubits\n",
        "step = 0.0004               # Learning rate\n",
        "batch_size = 4              # Number of samples for each training step\n",
        "num_epochs = 10              # Number of training epochs\n",
        "q_depth = 6                 # Depth of the quantum circuit (number of variational layers)\n",
        "gamma_lr_scheduler = 0.1    # Learning rate reduction applied every 10 epochs.\n",
        "q_delta = 0.01              # Initial spread of random quantum weights\n",
        "start_time = time.time()    # Start of the computation timer"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PVqjLo8Rrd0B"
      },
      "source": [
        "We initialize a PennyLane device with a `default.qubit` backend.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 137,
      "metadata": {
        "id": "qLOa5trRrd0B"
      },
      "outputs": [],
      "source": [
        "dev = qml.device(\"default.qubit\", wires=n_qubits)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dxlK7Jjtrd0C"
      },
      "source": [
        "We configure PyTorch to use CUDA only if available. Otherwise the CPU is\n",
        "used.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 138,
      "metadata": {
        "id": "Br_YGwRDrd0C"
      },
      "outputs": [],
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WFHuYd5xrd0C"
      },
      "source": [
        "Dataset loading\n",
        "===============\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "The dataset containing images of *ants* and *bees* can be downloaded\n",
        "[here](https://download.pytorch.org/tutorial/hymenoptera_data.zip) and\n",
        "should be extracted in the subfolder `../_data/hymenoptera_data`.\n",
        ":::\n",
        "\n",
        "This is a very small dataset (roughly 250 images), too small for\n",
        "training from scratch a classical or quantum model, however it is enough\n",
        "when using *transfer learning* approach.\n",
        "\n",
        "The PyTorch packages `torchvision` and `torch.utils.data` are used for\n",
        "loading the dataset and performing standard preliminary image\n",
        "operations: resize, center, crop, normalize, *etc.*\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#os.system(\"rm -rf /content/data/.ipynb_checkpoints\")\n",
        "#os.system(\"rm -rf /content/data/braintumor_data/.ipynb_checkpoints\")\n",
        "#os.system(\"rm -rf /content/data/braintumor_data/train/.ipynb_checkpoints\")\n",
        "#os.system(\"rm -rf /content/data/braintumor_data/val/.ipynb_checkpoints\")"
      ],
      "metadata": {
        "id": "DM8SDO3Wthcc"
      },
      "execution_count": 139,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 140,
      "metadata": {
        "id": "jQrNNVnUrd0C"
      },
      "outputs": [],
      "source": [
        "data_transforms = {\n",
        "    \"train\": transforms.Compose(\n",
        "        [\n",
        "            # transforms.RandomResizedCrop(224),     # uncomment for data augmentation\n",
        "            # transforms.RandomHorizontalFlip(),     # uncomment for data augmentation\n",
        "            transforms.Resize(256),\n",
        "            transforms.CenterCrop(224),\n",
        "            transforms.ToTensor(),\n",
        "            # Normalize input channels using mean values and standard deviations of ImageNet.\n",
        "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
        "        ]\n",
        "    ),\n",
        "    \"val\": transforms.Compose(\n",
        "        [\n",
        "            transforms.Resize(256),\n",
        "            transforms.CenterCrop(224),\n",
        "            transforms.ToTensor(),\n",
        "            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
        "        ]\n",
        "    ),\n",
        "}\n",
        "\n",
        "data_dir = \"/content/data/braintumor_data\"\n",
        "image_datasets = {\n",
        "    x if x == \"train\" else \"validation\": datasets.ImageFolder(\n",
        "        os.path.join(data_dir, x), data_transforms[x]\n",
        "    )\n",
        "    for x in [\"train\", \"val\"]\n",
        "}\n",
        "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"validation\"]}\n",
        "class_names = image_datasets[\"train\"].classes\n",
        "\n",
        "# Initialize dataloader\n",
        "dataloaders = {\n",
        "    x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True)\n",
        "    for x in [\"train\", \"validation\"]\n",
        "}\n",
        "\n",
        "# function to plot images\n",
        "def imshow(inp, title=None):\n",
        "    \"\"\"Display image from tensor.\"\"\"\n",
        "    inp = inp.numpy().transpose((1, 2, 0))\n",
        "    # Inverse of the initial normalization operation.\n",
        "    mean = np.array([0.485, 0.456, 0.406])\n",
        "    std = np.array([0.229, 0.224, 0.225])\n",
        "    inp = std * inp + mean\n",
        "    inp = np.clip(inp, 0, 1)\n",
        "    plt.imshow(inp)\n",
        "    if title is not None:\n",
        "        plt.title(title)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "piWk71nkrd0C"
      },
      "source": [
        "Let us show a batch of the test data, just to have an idea of the\n",
        "classification problem.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 141,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 207
        },
        "id": "u55iZYEOrd0D",
        "outputId": "73751854-36b0-4a7c-f3d7-7a15eec00da0"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Get a batch of training data\n",
        "inputs, classes = next(iter(dataloaders[\"validation\"]))\n",
        "\n",
        "# Make a grid from batch\n",
        "out = torchvision.utils.make_grid(inputs)\n",
        "\n",
        "imshow(out, title=[class_names[x] for x in classes])\n",
        "\n",
        "dataloaders = {\n",
        "    x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True)\n",
        "    for x in [\"train\", \"validation\"]\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ds09ighxrd0D"
      },
      "source": [
        "Variational quantum circuit\n",
        "===========================\n",
        "\n",
        "We first define some quantum layers that will compose the quantum\n",
        "circuit.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 142,
      "metadata": {
        "id": "OIbOa-KBrd0D"
      },
      "outputs": [],
      "source": [
        "def H_layer(nqubits):\n",
        "    \"\"\"Layer of single-qubit Hadamard gates.\n",
        "    \"\"\"\n",
        "    for idx in range(nqubits):\n",
        "        qml.Hadamard(wires=idx)\n",
        "\n",
        "\n",
        "def RY_layer(w):\n",
        "    \"\"\"Layer of parametrized qubit rotations around the y axis.\n",
        "    \"\"\"\n",
        "    for idx, element in enumerate(w):\n",
        "        qml.RY(element, wires=idx)\n",
        "\n",
        "\n",
        "def entangling_layer(nqubits):\n",
        "    \"\"\"Layer of CNOTs followed by another shifted layer of CNOT.\n",
        "    \"\"\"\n",
        "    # In other words it should apply something like :\n",
        "    # CNOT  CNOT  CNOT  CNOT...  CNOT\n",
        "    #   CNOT  CNOT  CNOT...  CNOT\n",
        "    for i in range(0, nqubits - 1, 2):  # Loop over even indices: i=0,2,...N-2\n",
        "        qml.CNOT(wires=[i, i + 1])\n",
        "    for i in range(1, nqubits - 1, 2):  # Loop over odd indices:  i=1,3,...N-3\n",
        "        qml.CNOT(wires=[i, i + 1])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ue__y4sQrd0D"
      },
      "source": [
        "Now we define the quantum circuit through the PennyLane\n",
        "[qnode]{.title-ref} decorator .\n",
        "\n",
        "The structure is that of a typical variational quantum circuit:\n",
        "\n",
        "-   **Embedding layer:** All qubits are first initialized in a balanced\n",
        "    superposition of *up* and *down* states, then they are rotated\n",
        "    according to the input parameters (local embedding).\n",
        "-   **Variational layers:** A sequence of trainable rotation layers and\n",
        "    constant entangling layers is applied.\n",
        "-   **Measurement layer:** For each qubit, the local expectation value\n",
        "    of the $Z$ operator is measured. This produces a classical output\n",
        "    vector, suitable for additional post-processing.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 143,
      "metadata": {
        "id": "C-O_cK6jrd0D"
      },
      "outputs": [],
      "source": [
        "@qml.qnode(dev, interface=\"torch\")\n",
        "def quantum_net(q_input_features, q_weights_flat):\n",
        "    \"\"\"\n",
        "    The variational quantum circuit.\n",
        "    \"\"\"\n",
        "\n",
        "    # Reshape weights\n",
        "    q_weights = q_weights_flat.reshape(q_depth, n_qubits)\n",
        "\n",
        "    # Start from state |+> , unbiased w.r.t. |0> and |1>\n",
        "    H_layer(n_qubits)\n",
        "\n",
        "    # Embed features in the quantum node\n",
        "    RY_layer(q_input_features)\n",
        "\n",
        "    # Sequence of trainable variational layers\n",
        "    for k in range(q_depth):\n",
        "        entangling_layer(n_qubits)\n",
        "        RY_layer(q_weights[k])\n",
        "\n",
        "    # Expectation values in the Z basis\n",
        "    exp_vals = [qml.expval(qml.PauliZ(position)) for position in range(n_qubits)]\n",
        "    return tuple(exp_vals)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7FNHREgVrd0D"
      },
      "source": [
        "Dressed quantum circuit\n",
        "=======================\n",
        "\n",
        "We can now define a custom `torch.nn.Module` representing a *dressed*\n",
        "quantum circuit.\n",
        "\n",
        "This is a concatenation of:\n",
        "\n",
        "-   A classical pre-processing layer (`nn.Linear`).\n",
        "-   A classical activation function (`torch.tanh`).\n",
        "-   A constant `np.pi/2.0` scaling.\n",
        "-   The previously defined quantum circuit (`quantum_net`).\n",
        "-   A classical post-processing layer (`nn.Linear`).\n",
        "\n",
        "The input of the module is a batch of vectors with 512 real parameters\n",
        "(features) and the output is a batch of vectors with two real outputs\n",
        "(associated with the two classes of images: *ants* and *bees*).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 144,
      "metadata": {
        "id": "C96kWCjWrd0D"
      },
      "outputs": [],
      "source": [
        "class DressedQuantumNet(nn.Module):\n",
        "    \"\"\"\n",
        "    Torch module implementing the *dressed* quantum net.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        \"\"\"\n",
        "        Definition of the *dressed* layout.\n",
        "        \"\"\"\n",
        "\n",
        "        super().__init__()\n",
        "        self.pre_net = nn.Linear(512, n_qubits)\n",
        "        self.q_params = nn.Parameter(q_delta * torch.randn(q_depth * n_qubits))\n",
        "        self.post_net = nn.Linear(n_qubits, 2)\n",
        "\n",
        "    def forward(self, input_features):\n",
        "        \"\"\"\n",
        "        Defining how tensors are supposed to move through the *dressed* quantum\n",
        "        net.\n",
        "        \"\"\"\n",
        "\n",
        "        # obtain the input features for the quantum circuit\n",
        "        # by reducing the feature dimension from 512 to 4\n",
        "        pre_out = self.pre_net(input_features)\n",
        "        q_in = torch.tanh(pre_out) * np.pi / 2.0\n",
        "\n",
        "        # Apply the quantum circuit to each element of the batch and append to q_out\n",
        "        q_out = torch.Tensor(0, n_qubits)\n",
        "        q_out = q_out.to(device)\n",
        "        for elem in q_in:\n",
        "            q_out_elem = torch.hstack(quantum_net(elem, self.q_params)).float().unsqueeze(0)\n",
        "            q_out = torch.cat((q_out, q_out_elem))\n",
        "\n",
        "        # return the two-dimensional prediction from the postprocessing layer\n",
        "        return self.post_net(q_out)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7hQlpDQdrd0D"
      },
      "source": [
        "Hybrid classical-quantum model\n",
        "==============================\n",
        "\n",
        "We are finally ready to build our full hybrid classical-quantum network.\n",
        "We follow the *transfer learning* approach:\n",
        "\n",
        "1.  First load the classical pre-trained network *ResNet18* from the\n",
        "    `torchvision.models` zoo.\n",
        "2.  Freeze all the weights since they should not be trained.\n",
        "3.  Replace the last fully connected layer with our trainable dressed\n",
        "    quantum circuit (`DressedQuantumNet`).\n",
        "\n",
        "::: {.note}\n",
        "::: {.title}\n",
        "Note\n",
        ":::\n",
        "\n",
        "The *ResNet18* model is automatically downloaded by PyTorch and it may\n",
        "take several minutes (only the first time).\n",
        ":::\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 145,
      "metadata": {
        "id": "MAh4FqBYrd0D"
      },
      "outputs": [],
      "source": [
        "model_hybrid = torchvision.models.resnet18(pretrained=True)\n",
        "\n",
        "for param in model_hybrid.parameters():\n",
        "    param.requires_grad = False\n",
        "\n",
        "\n",
        "# Notice that model_hybrid.fc is the last layer of ResNet18\n",
        "model_hybrid.fc = DressedQuantumNet()\n",
        "\n",
        "# Use CUDA or CPU according to the \"device\" object.\n",
        "model_hybrid = model_hybrid.to(device)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ovX-Tkb0rd0E"
      },
      "source": [
        "Training and results\n",
        "====================\n",
        "\n",
        "Before training the network we need to specify the *loss* function.\n",
        "\n",
        "We use, as usual in classification problem, the *cross-entropy* which is\n",
        "directly available within `torch.nn`.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 146,
      "metadata": {
        "id": "gkmFIK4Brd0E"
      },
      "outputs": [],
      "source": [
        "criterion = nn.CrossEntropyLoss()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qhFORuvard0E"
      },
      "source": [
        "We also initialize the *Adam optimizer* which is called at each training\n",
        "step in order to update the weights of the model.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 147,
      "metadata": {
        "id": "_K9M-VPMrd0E"
      },
      "outputs": [],
      "source": [
        "optimizer_hybrid = optim.Adam(model_hybrid.fc.parameters(), lr=step)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IGG8pksyrd0E"
      },
      "source": [
        "We schedule to reduce the learning rate by a factor of\n",
        "`gamma_lr_scheduler` every 10 epochs.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 148,
      "metadata": {
        "id": "nco3IrE6rd0E"
      },
      "outputs": [],
      "source": [
        "exp_lr_scheduler = lr_scheduler.StepLR(\n",
        "    optimizer_hybrid, step_size=10, gamma=gamma_lr_scheduler\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yJvpPNCRrd0E"
      },
      "source": [
        "What follows is a training function that will be called later. This\n",
        "function should return a trained model that can be used to make\n",
        "predictions (classifications).\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 149,
      "metadata": {
        "id": "8uO5BrOPrd0E"
      },
      "outputs": [],
      "source": [
        "def train_model(model, criterion, optimizer, scheduler, num_epochs):\n",
        "    since = time.time()\n",
        "    best_model_wts = copy.deepcopy(model.state_dict())\n",
        "    best_acc = 0.0\n",
        "    best_loss = 10000.0  # Large arbitrary number\n",
        "    best_acc_train = 0.0\n",
        "    best_loss_train = 10000.0  # Large arbitrary number\n",
        "    print(\"Training started:\")\n",
        "\n",
        "    for epoch in range(num_epochs):\n",
        "\n",
        "        # Each epoch has a training and validation phase\n",
        "        for phase in [\"train\", \"validation\"]:\n",
        "            if phase == \"train\":\n",
        "                # Set model to training mode\n",
        "                model.train()\n",
        "            else:\n",
        "                # Set model to evaluate mode\n",
        "                model.eval()\n",
        "            running_loss = 0.0\n",
        "            running_corrects = 0\n",
        "\n",
        "            # Iterate over data.\n",
        "            n_batches = dataset_sizes[phase] // batch_size\n",
        "            it = 0\n",
        "            for inputs, labels in dataloaders[phase]:\n",
        "                since_batch = time.time()\n",
        "                batch_size_ = len(inputs)\n",
        "                inputs = inputs.to(device)\n",
        "                labels = labels.to(device)\n",
        "                optimizer.zero_grad()\n",
        "\n",
        "                # Track/compute gradient and make an optimization step only when training\n",
        "                with torch.set_grad_enabled(phase == \"train\"):\n",
        "                    outputs = model(inputs)\n",
        "                    _, preds = torch.max(outputs, 1)\n",
        "                    loss = criterion(outputs, labels)\n",
        "                    if phase == \"train\":\n",
        "                        loss.backward()\n",
        "                        optimizer.step()\n",
        "\n",
        "                # Print iteration results\n",
        "                running_loss += loss.item() * batch_size_\n",
        "                batch_corrects = torch.sum(preds == labels.data).item()\n",
        "                running_corrects += batch_corrects\n",
        "                print(\n",
        "                    \"Phase: {} Epoch: {}/{} Iter: {}/{} Batch time: {:.4f}\".format(\n",
        "                        phase,\n",
        "                        epoch + 1,\n",
        "                        num_epochs,\n",
        "                        it + 1,\n",
        "                        n_batches + 1,\n",
        "                        time.time() - since_batch,\n",
        "                    ),\n",
        "                    end=\"\\r\",\n",
        "                    flush=True,\n",
        "                )\n",
        "                it += 1\n",
        "\n",
        "            # Print epoch results\n",
        "            epoch_loss = running_loss / dataset_sizes[phase]\n",
        "            epoch_acc = running_corrects / dataset_sizes[phase]\n",
        "            print(\n",
        "                \"Phase: {} Epoch: {}/{} Loss: {:.4f} Acc: {:.4f}        \".format(\n",
        "                    \"train\" if phase == \"train\" else \"validation  \",\n",
        "                    epoch + 1,\n",
        "                    num_epochs,\n",
        "                    epoch_loss,\n",
        "                    epoch_acc,\n",
        "                )\n",
        "            )\n",
        "\n",
        "            # Check if this is the best model wrt previous epochs\n",
        "            if phase == \"validation\" and epoch_acc > best_acc:\n",
        "                best_acc = epoch_acc\n",
        "                best_model_wts = copy.deepcopy(model.state_dict())\n",
        "            if phase == \"validation\" and epoch_loss < best_loss:\n",
        "                best_loss = epoch_loss\n",
        "            if phase == \"train\" and epoch_acc > best_acc_train:\n",
        "                best_acc_train = epoch_acc\n",
        "            if phase == \"train\" and epoch_loss < best_loss_train:\n",
        "                best_loss_train = epoch_loss\n",
        "      \n",
        "            # Update learning rate\n",
        "            if phase == \"train\":\n",
        "                scheduler.step()\n",
        "\n",
        "    # Print final results\n",
        "    model.load_state_dict(best_model_wts)\n",
        "    time_elapsed = time.time() - since\n",
        "    print(\n",
        "        \"Training completed in {:.0f}m {:.0f}s\".format(time_elapsed // 60, time_elapsed % 60)\n",
        "    )\n",
        "    print(\"Best test loss: {:.4f} | Best test accuracy: {:.4f}\".format(best_loss, best_acc))\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmAl9fIQrd0E"
      },
      "source": [
        "We are ready to perform the actual training process.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 150,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "id": "rAQBdDA_rd0E",
        "outputId": "73f47c5c-f075-442e-9e89-5c32884f4628"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training started:\n",
            "Phase: train Epoch: 1/10 Loss: 0.5880 Acc: 0.7224        \n",
            "Phase: validation   Epoch: 1/10 Loss: 0.5439 Acc: 0.7124        \n",
            "Phase: train Epoch: 2/10 Loss: 0.4812 Acc: 0.7959        \n",
            "Phase: validation   Epoch: 2/10 Loss: 0.3592 Acc: 0.9281        \n",
            "Phase: train Epoch: 3/10 Loss: 0.4324 Acc: 0.8286        \n",
            "Phase: validation   Epoch: 3/10 Loss: 0.3039 Acc: 0.9608        \n",
            "Phase: train Epoch: 4/10 Loss: 0.3621 Acc: 0.8571        \n",
            "Phase: validation   Epoch: 4/10 Loss: 0.2444 Acc: 0.9869        \n",
            "Phase: train Epoch: 5/10 Loss: 0.3151 Acc: 0.9061        \n",
            "Phase: validation   Epoch: 5/10 Loss: 0.2588 Acc: 0.9346        \n",
            "Phase: train Epoch: 6/10 Loss: 0.3695 Acc: 0.8449        \n",
            "Phase: validation   Epoch: 6/10 Loss: 0.2074 Acc: 0.9542        \n",
            "Phase: train Epoch: 7/10 Loss: 0.3297 Acc: 0.8694        \n",
            "Phase: validation   Epoch: 7/10 Loss: 0.2383 Acc: 0.9281        \n",
            "Phase: train Epoch: 8/10 Loss: 0.2947 Acc: 0.8898        \n",
            "Phase: validation   Epoch: 8/10 Loss: 0.1836 Acc: 0.9542        \n",
            "Phase: train Epoch: 9/10 Loss: 0.2570 Acc: 0.9184        \n",
            "Phase: validation   Epoch: 9/10 Loss: 0.1716 Acc: 0.9542        \n",
            "Phase: train Epoch: 10/10 Loss: 0.3674 Acc: 0.8327        \n",
            "Phase: validation   Epoch: 10/10 Loss: 0.1764 Acc: 0.9542        \n",
            "Training completed in 8m 27s\n",
            "Best test loss: 0.1716 | Best test accuracy: 0.9869\n"
          ]
        }
      ],
      "source": [
        "model_hybrid = train_model(\n",
        "    model_hybrid, criterion, optimizer_hybrid, exp_lr_scheduler, num_epochs=num_epochs\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s4cEc4mird0E"
      },
      "source": [
        "Visualizing the model predictions\n",
        "=================================\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ARvjv_lbrd0E"
      },
      "source": [
        "We first define a visualization function for a batch of test data.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 151,
      "metadata": {
        "id": "CtUY4xU_rd0E"
      },
      "outputs": [],
      "source": [
        "def visualize_model(model, num_images=6, fig_name=\"Predictions\"):\n",
        "    images_so_far = 0\n",
        "    _fig = plt.figure(fig_name)\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for _i, (inputs, labels) in enumerate(dataloaders[\"validation\"]):\n",
        "            inputs = inputs.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            _, preds = torch.max(outputs, 1)\n",
        "            for j in range(inputs.size()[0]):\n",
        "                images_so_far += 1\n",
        "                ax = plt.subplot(num_images // 2, 2, images_so_far)\n",
        "                ax.axis(\"off\")\n",
        "                ax.set_title(\"[{}]\".format(class_names[preds[j]]))\n",
        "                imshow(inputs.cpu().data[j])\n",
        "                if images_so_far == num_images:\n",
        "                    return"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F6I5Rk92rd0E"
      },
      "source": [
        "Finally, we can run the previous function to see a batch of images with\n",
        "the corresponding predictions.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 152,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 428
        },
        "id": "-RoYcZQXrd0E",
        "outputId": "55b61473-ba7f-48a5-c5a6-be167a01c79c"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "visualize_model(model_hybrid, num_images=batch_size)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IBXZTnzjrd0E"
      },
      "source": [
        "References\n",
        "==========\n",
        "\n",
        "\\[1\\] Andrea Mari, Thomas R. Bromley, Josh Izaac, Maria Schuld, and\n",
        "Nathan Killoran. *Transfer learning in hybrid classical-quantum neural\n",
        "networks*. arXiv:1912.08278 (2019).\n",
        "\n",
        "\\[2\\] Rajat Raina, Alexis Battle, Honglak Lee, Benjamin Packer, and\n",
        "Andrew Y Ng. *Self-taught learning: transfer learning from unlabeled\n",
        "data*. Proceedings of the 24th International Conference on Machine\n",
        "Learning\\*, 759--766 (2007).\n",
        "\n",
        "\\[3\\] Kaiming He, Xiangyu Zhang, Shaoqing ren and Jian Sun. *Deep\n",
        "residual learning for image recognition*. Proceedings of the IEEE\n",
        "Conference on Computer Vision and Pattern Recognition, 770-778 (2016).\n",
        "\n",
        "\\[4\\] Ville Bergholm, Josh Izaac, Maria Schuld, Christian Gogolin,\n",
        "Carsten Blank, Keri McKiernan, and Nathan Killoran. *PennyLane:\n",
        "Automatic differentiation of hybrid quantum-classical computations*.\n",
        "arXiv:1811.04968 (2018).\n",
        "\n",
        "About the author\n",
        "================\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "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.16"
    },
    "colab": {
      "provenance": []
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}