c2q_transfer_learning_cifar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example 3: Hybrid transfer learning for image classification (CIFAR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an example of a hybrid network for image classification, developed according to the *classical-to-quantum transfer learning* scheme presented in [1].\n",
    "\n",
    "This notebook is inspired by the official PyTorch  [tutorial on transfer learning](https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html) by Sasank Chilamkurthy [2].\n",
    "\n",
    "The starting point is a convolutional neural network—ResNet18, introduced by Microsoft in 2016 [3]—which is pre-trained on the public ImageNet dataset. We replace the last fully connected layer with a *dressed quantum circuit* [1] that we train on a different dataset. \n",
    "\n",
    "Specifically, we focus on the following sub-classes of the CIFAR 10 dataset:\n",
    "- Ref. [1], Example 3, dataset (a): *dogs* and *cats*.\n",
    "- Ref. [1], Example 3, dataset (b): *planes* and *cars*.\n",
    "\n",
    "The code can be easily modified to deal with different and/or more CIFAR classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General setup\n",
    "**Important:** this code makes use of the machine learning framework *PyTorch*, which is assumed to be correctly installed.\n",
    "\n",
    "The main imported modules are: some common PyTorch libraries, the quantum \n",
    "software framework `pennylane` [4] and the python plotting library `matplotlib`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: OMP_NUM_THREADS=1\n"
     ]
    }
   ],
   "source": [
    "# OpenMP: number of parallel threads.\n",
    "%env OMP_NUM_THREADS=1\n",
    "\n",
    "# Plotting\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\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, models, transforms\n",
    "\n",
    "# Pennylane\n",
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "\n",
    "# Other tools\n",
    "import time\n",
    "import copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Please choose and run only one of the following two cells, depending on the dataset of interest."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Settings to reproduce the results of ***Ref. [1], Example 3, dataset (a)***, i.e., _dogs_ vs. _cats_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_classes = ['cat', 'dog']  # Subset of CIFAR ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "n_qubits = 4                       # Number of qubits\n",
    "quantum = True                     # If set to \"False\", the dressed quantum circuit is replaced by \n",
    "                                   # An enterily classical net (defined by the next parameter). \n",
    "classical_model = '512_n'          # Possible choices: '512_n','512_nq_n','551_512_n'. [nq=n_qubits, n=num_filtered_classes]\n",
    "step = 0.001                       # Learning rate\n",
    "batch_size = 8                     # Number of samples for each training step\n",
    "num_epochs = 3                     # Number of training epochs\n",
    "q_depth = 5                        # Depth of the quantum circuit (number of variational layers)\n",
    "gamma_lr_scheduler = 1             # Learning rate reduction applied every 10 epochs.                       \n",
    "max_layers = 15                    # Keep 15 even if not all are used.\n",
    "q_delta = 0.01                     # Initial spread of random quantum weights\n",
    "rng_seed = 0                       # Seed for random number generator\n",
    "start_time = time.time()           # start of the computation timer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Settings to reproduce the results of ***Ref. [1], Example 3, dataset (b)***, i.e., _planes_ vs. _cars_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_classes = ['plane', 'car'] # Subset of CIFAR ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "n_qubits = 4                        # Number of qubits\n",
    "quantum = True                      # If set to \"False\", the dressed quantum circuit is replaced by \n",
    "                                    # An enterily classical net (defined by the next parameter). \n",
    "classical_model = '512_n'           # Possible choices: '512_n','512_nq_n','551_512_n'. [nq=n_qubits, n=num_filtered_classes]\n",
    "step = 0.0007                       # Learning rate\n",
    "batch_size = 8                      # Number of samples for each training step\n",
    "num_epochs = 3                      # Number of training epochs\n",
    "q_depth = 4                         # Depth of the quantum circuit (number of variational layers)\n",
    "gamma_lr_scheduler = 0.1            # Learning rate reduction applied every 3 epochs.                       \n",
    "max_layers = 15                     # Keep 15 even if not all are used.\n",
    "q_delta = 0.01                      # Initial spread of random quantum weights\n",
    "rng_seed = 0                        # Seed for random number generator\n",
    "start_time = time.time()            # Start of the computation timer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us initialize a PennyLane with the default simulator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=n_qubits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configure PyTorch to use CUDA, only if available. Otherwise simply use the CPU."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset loading\n",
    "\n",
    "**Remark:** It may take several minutes to download the CIFAR dataset (only the first time).\n",
    "The PyTorch packages `torchvision` and `torch.utils.data` are used for loading the dataset and performing standard preliminary image operations: resize, center, crop, normalize, *etc.* ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# Fixed pre-processing operations\n",
    "data_transforms = {\n",
    "    'train': transforms.Compose([\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",
    "    'val': transforms.Compose([\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",
    "# =================== begin CIFAR dataset loading ===================\n",
    "trainset_full = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
    "                                        download=True, transform=data_transforms['train'])\n",
    "testset_full = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                       download=True, transform=data_transforms['val'])\n",
    "image_datasets_full={'train': trainset_full, 'val': testset_full}\n",
    "\n",
    "# CIFAR classes\n",
    "class_names = ('plane', 'car', 'bird', 'cat',\n",
    "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
    "\n",
    "# Get indices of samples associated to filtered_classes\n",
    "filtered_labels=[class_names.index(cl) for cl in filtered_classes]\n",
    "sub_indices={'train': [], 'val': []}\n",
    "for phase in ['train', 'val']:\n",
    "    for idx, label in enumerate(image_datasets_full[phase].targets):  \n",
    "        if label in filtered_labels:\n",
    "            sub_indices[phase].append(idx)\n",
    "            \n",
    "# Initialize sub-datasets according to filtered indices\n",
    "image_datasets = {x: torch.utils.data.Subset(image_datasets_full[x], sub_indices[x])\n",
    "                for x in ['train', 'val']}\n",
    "\n",
    "def labels_to_filtered(labels):\n",
    "    \"\"\"Maps CIFAR labels (0,1,2,3,4,5,6,7,8,9) to the index of filtered_labels\"\"\"\n",
    "    return [filtered_labels.index(label) for label in labels]\n",
    "# =================== end CIFAR dataset loading ==========================\n",
    "\n",
    "# Number of samples\n",
    "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}\n",
    "\n",
    "# Initialize dataloader\n",
    "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], \n",
    "                  batch_size=batch_size, shuffle=True, num_workers=0) for x in ['train', 'val']}\n",
    "\n",
    "# Function to plot images from tensors\n",
    "def imshow(inp, title=None):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\n",
    "    inp = inp.numpy().transpose((1, 2, 0))\n",
    "    # We apply the 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": {},
   "source": [
    "Let us show a batch of the test data, just to have an idea of the classification problem.<br>\n",
    "*Hint:* re-run the next cell to see more samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get a batch of training data\n",
    "inputs, classes = next(iter(dataloaders['val']))\n",
    "\n",
    "# Make a grid from batch\n",
    "out = torchvision.utils.make_grid(inputs)\n",
    "imshow(out, title=[class_names[x] for x in classes])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to get reproducible results, we set a manual seed for the random number generator and re-initialize the dataloaders."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(rng_seed)\n",
    "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], \n",
    "                  batch_size=batch_size, shuffle=True, num_workers=0) for x in ['train', 'val']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hybrid transfer learning model (classical-to-quantum).\n",
    "\n",
    "We first define some quantum layers that will compose the quantum circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "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",
    "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",
    "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": {},
   "source": [
    "Let us define the quantum circuit by using the PennyLane `qnode` decorator . The structure is that of a typical variational quantum circuit:\n",
    "1. All qubits are first initialized in a balanced superposition of *up* and *down* states, then they are rotated according to the input parameters (local embedding);\n",
    "2. Successively a sequence of trainable rotation layers and constant entangling layers is applied. This block is responsible for the main computation necessary to solve the classification problem.\n",
    "3. Eventually, for each qubit, the local expectation value of the Z operator is measured. This produces a classical output vector, suitable for additional post-processing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface='torch')\n",
    "def q_net(q_in, q_weights_flat):\n",
    "        \n",
    "        # Reshape weights\n",
    "        q_weights = q_weights_flat.reshape(max_layers, 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_in)\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+1])\n",
    "\n",
    "        # Expectation values in the Z basis\n",
    "        return [qml.expval(qml.PauliZ(j)) for j in range(n_qubits)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now define a custom `torch.nn.Module` representing a *dressed* quantum circuit.<br>\n",
    "This is a concatenation of:\n",
    "1. A classical pre-processing layer (`nn.Linear`)\n",
    "2. A classical activation function (`F.tanh`)\n",
    "3. A constant `np.pi/2.0` scaling factor.\n",
    "2. The previously defined quantum circuit (`q_net`)\n",
    "2. A classical post-processing layer (`nn.Linear`)\n",
    "\n",
    "The input of the module is a batch of vectors with 512 real parameters (features) and the output is a batch of vectors with *n* real outputs (one for each class of images)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Quantumnet(nn.Module):\n",
    "        def __init__(self):\n",
    "            super().__init__()\n",
    "            self.pre_net = nn.Linear(512, n_qubits)\n",
    "            self.q_params = nn.Parameter(q_delta * torch.randn(max_layers * n_qubits))\n",
    "            self.post_net = nn.Linear(n_qubits, len(filtered_classes))\n",
    "\n",
    "        def forward(self, input_features):\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 = q_net(elem,self.q_params).float().unsqueeze(0)\n",
    "                q_out = torch.cat((q_out, q_out_elem))\n",
    "            return self.post_net(q_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are finally ready to build our full hybrid classical-quantum network. We follow the *transfer learning* approach:\n",
    "1. First load the classical pre-trained network *ResNet18* from the `torchvision.models` zoo.<br> **Important:** the model is downloaded from Internet and it may take a long time (only the first time). \n",
    "2. Freeze all the weights since they should not be trained.\n",
    "3. Replace the last fully connected layer with our trainable dressed quantum circuit (`Quantumnet`). Alternatively, if `quantum==False`, an entirely classical analogue is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_hybrid = torchvision.models.resnet18(pretrained=True)\n",
    "\n",
    "for param in model_hybrid.parameters():\n",
    "    param.requires_grad = False\n",
    "\n",
    "if quantum:\n",
    "    model_hybrid.fc = Quantumnet()\n",
    "\n",
    "elif classical_model == '512_n':\n",
    "    model_hybrid.fc = nn.Linear(512,len(filtered_classes))\n",
    "\n",
    "elif classical_model == '512_nq_n':\n",
    "    model_hybrid.fc = nn.Sequential(nn.Linear(512, n_qubits),torch.nn.ReLU(),nn.Linear(n_qubits, len(filtered_classes))) \n",
    "\n",
    "elif classical_model == '551_512_n':\n",
    "    model_hybrid.fc = nn.Sequential(nn.Linear(512, 512), torch.nn.ReLU(), nn.Linear(512, len(filtered_classes)))\n",
    "\n",
    "# Use CUDA or CPU according to the \"device\" object.\n",
    "model_hybrid = model_hybrid.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training and results\n",
    "Before training the network we need to specify the *loss* function. We use the *relative entropy* as objective function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also initialize the *optimizer* which is called at each training step in order to update the weights of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer_hybrid = optim.Adam(model_hybrid.fc.parameters(), lr=step)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We schedule to reduce the learning rate by a factor of `gamma_lr_scheduler` every epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_hybrid, step_size=3, gamma=gamma_lr_scheduler)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What follows is a training function that will be called later. This function should return a trained model that can be used to make predictions (classifications). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "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",
    "        for epoch in range(num_epochs):\n",
    "            \n",
    "            # Each epoch has a training and validation phase\n",
    "            for phase in ['train', 'val']:\n",
    "                if phase == 'train':\n",
    "                    # Set model to training mode\n",
    "                    scheduler.step()\n",
    "                    model.train() \n",
    "                else:\n",
    "                    # Set model to evaluate mode\n",
    "                    model.eval()   \n",
    "                \n",
    "                # Iteration loop\n",
    "                running_loss = 0.0\n",
    "                running_corrects = 0\n",
    "                n_batches = dataset_sizes[phase] // batch_size\n",
    "                it = 0\n",
    "                for inputs, cifar_labels in dataloaders[phase]:\n",
    "                    since_batch = time.time()\n",
    "                    batch_size_ = len(inputs)\n",
    "                    inputs = inputs.to(device)\n",
    "                    labels = torch.tensor(labels_to_filtered(cifar_labels))\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('Phase: {} Epoch: {}/{} Iter: {}/{} Batch time: {:.4f}'.format(phase, epoch + 1, num_epochs, it + 1, n_batches + 1, time.time() - since_batch), end='\\r', flush=True)\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('Phase: {} Epoch: {}/{} Loss: {:.4f} Acc: {:.4f}             '.format('train' if phase == 'train' else 'val  ', epoch + 1, num_epochs, epoch_loss, epoch_acc))\n",
    "                \n",
    "                # Check if this is the best model wrt previous epochs\n",
    "                if phase == 'val' and epoch_acc > best_acc:\n",
    "                    best_acc = epoch_acc\n",
    "                    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "                if phase == 'val' 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",
    "        # Print final results             \n",
    "        model.load_state_dict(best_model_wts)\n",
    "        time_elapsed = time.time() - since\n",
    "        print('Training completed in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
    "        print('Best test loss: {:.4f} | Best test accuracy: {:.4f}'.format(best_loss, best_acc))\n",
    "        return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are ready perform the actual training process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started:\n",
      "Phase: train Epoch: 1/3 Loss: 0.5538 Acc: 0.7223             \n",
      "Phase: val   Epoch: 1/3 Loss: 0.4698 Acc: 0.7560             \n",
      "Phase: train Epoch: 2/3 Loss: 0.4800 Acc: 0.7769             \n",
      "Phase: val   Epoch: 2/3 Loss: 0.4098 Acc: 0.8270             \n",
      "Phase: train Epoch: 3/3 Loss: 0.4722 Acc: 0.7751             \n",
      "Phase: val   Epoch: 3/3 Loss: 0.4039 Acc: 0.8165             \n",
      "Training completed in 676m 5s\n",
      "Best test loss: 0.4039 | Best test accuracy: 0.8270\n"
     ]
    }
   ],
   "source": [
    "model_hybrid = train_model(model_hybrid, criterion, optimizer_hybrid, exp_lr_scheduler, num_epochs=num_epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We save the optimal weights that achieved the best accuracy into a PyTorch file that will be created in the current working directory. In this way, the saved weights can be loaded in the future without training again.\n",
    "\n",
    "**Important: Be aware that running next cell will overwrite a previously saved file. So, we suggest to run the next cell only after a good training process.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model state_dict saved.\n"
     ]
    }
   ],
   "source": [
    "if quantum:\n",
    "        torch.save(model_hybrid.state_dict(), \n",
    "            'quantum_' + filtered_classes[0] + '_' + filtered_classes[1] + '.pt'\n",
    "        )\n",
    "else:\n",
    "        torch.save(model_hybrid.state_dict(), \n",
    "            'classical_' + filtered_classes[0] + '_' + filtered_classes[1] + '.pt'\n",
    "        )\n",
    "print(\"Model state_dict saved.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load model from file\n",
    "To load the pre-trained weights it is necessary to first define the model. So, before this cell, one should have run all the cells above the *[Training and results](##Training_and_results)* section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "if quantum:\n",
    "    model_hybrid.load_state_dict(torch.load(\n",
    "        'quantum_' + filtered_classes[0] + '_' + filtered_classes[1] + '.pt'\n",
    "        )\n",
    "    )\n",
    "                                 \n",
    "else:\n",
    "    model_hybrid.load_state_dict(torch.load(\n",
    "        'classical_' + filtered_classes[0] + '_' + filtered_classes[1] + '.pt'\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We apply the model to the test dataset to compute the associated *loss* and *accuracy*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter: 250/251\n",
      "Test Loss: 0.4098 Test Acc: 0.8270        \n"
     ]
    }
   ],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "running_loss = 0.0\n",
    "running_corrects = 0\n",
    "n_batches = dataset_sizes['val'] // batch_size\n",
    "it = 0\n",
    "model_hybrid.eval()\n",
    "\n",
    "# Testing loop\n",
    "for inputs, cifar_labels in dataloaders['val']:\n",
    "    inputs = inputs.to(device)\n",
    "    labels = torch.tensor(labels_to_filtered(cifar_labels))\n",
    "    labels = labels.to(device)\n",
    "    batch_size_ = len(inputs)\n",
    "    with torch.set_grad_enabled(False):\n",
    "        outputs = model_hybrid(inputs)\n",
    "        _, preds = torch.max(outputs, 1)\n",
    "        loss = criterion(outputs, labels)\n",
    "    running_loss += loss.item() * batch_size_\n",
    "    batch_corrects = torch.sum(preds == labels.data).item()\n",
    "    running_corrects += batch_corrects\n",
    "    print('Iter: {}/{}'.format(it+1,n_batches+1), end='\\r', flush=True)\n",
    "    it += 1\n",
    "                    \n",
    "# Print final results\n",
    "epoch_loss = running_loss / dataset_sizes['val']\n",
    "epoch_acc = running_corrects / dataset_sizes['val']\n",
    "print('\\nTest Loss: {:.4f} Test Acc: {:.4f}        '.format(epoch_loss, epoch_acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualize the model\n",
    "Let us compute and the visualize the predictions for a batch of test data.\n",
    "*Hint:* re-run the next cell to see more samples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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, cifar_labels) in enumerate(dataloaders['val']):\n",
    "            inputs = inputs.to(device)\n",
    "            labels = torch.tensor(labels_to_filtered(cifar_labels))\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(filtered_classes[preds[j]]))\n",
    "                imshow(inputs.cpu().data[j])\n",
    "                if images_so_far == num_images:\n",
    "                    return\n",
    "        \n",
    "visualize_model(model_hybrid, num_images=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "[1] Andrea Mari, Thomas R. Bromley, Josh Izaac, Maria Schuld, and Nathan Killoran. _Transfer learning in hybrid classical-quantum neural networks_. [arXiv:1912.08278](https://arxiv.org/abs/1912.08278), (2019).\n",
    "\n",
    "[2] Sasank Chilamkurthy. PyTorch transfer learning tutorial. https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html.\n",
    "\n",
    "[3] Kaiming He, Xiangyu Zhang, Shaoqing ren and Jian Sun. _Deep residual learning for image recognition_.\n",
    "  Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 770-778 (2016). [DOI: 10.1109/CVPR.2016.90]( https://doi.org/10.1109/CVPR.2016.90).\n",
    "  \n",
    "[4] Ville Bergholm, Josh Izaac, Maria Schuld, Christian Gogolin, Carsten Blank, Keri McKiernan, and Nathan Killoran. PennyLane: Automatic differentiation of hybrid quantum-classical computations. [arXiv:1811.04968](https://arxiv.org/abs/1811.04968), (2018)."
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "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.7.5"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 2
}