1173 lines (1173 with data), 256.1 kB

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "WNXEyZ23rdz-"
      },
      "outputs": [],
      "source": [
        "# This cell is added by sphinx-gallery\n",
        "# It can be customized to whatever you like\n",
        "# from google.colab import drive\n",
        "# drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "WYVI3RMhAdap"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "id": "sANL984ird0B",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "7c3a12a2-ff66-4596-9aba-8ff998e6d848"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time in seconds since beginning of run: 1685943611.0886571\n",
            "Mon Jun  5 05:40:11 2023\n"
          ]
        }
      ],
      "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",
        "from PIL import Image\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\"] = \"16\"\n",
        "\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": "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": 79,
      "metadata": {
        "id": "Wncy61Mdrd0B"
      },
      "outputs": [],
      "source": [
        "n_qubits = 20               # Number of qubits\n",
        "step = 0.0006               # Learning rate\n",
        "batch_size = 17             # Number of samples for each training step\n",
        "num_epochs = 30             # 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": 80,
      "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": 81,
      "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",
      "execution_count": 82,
      "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(232),\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(232),\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/drive/MyDrive/Colab Notebooks/data/Shuffle Split 10 of 17 Classes Big Brain Tumor MRI Images\"\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": 83,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "id": "u55iZYEOrd0D",
        "outputId": "dc55e578-9efb-4902-a0eb-ac0f13015ddf"
      },
      "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": 84,
      "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)"
      ]
    },
    {
      "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": 85,
      "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 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",
        "    # 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": 86,
      "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(2048, n_qubits)\n",
        "        self.q_params = nn.Parameter(q_delta * torch.randn(q_depth * n_qubits))\n",
        "        self.post_net = nn.Linear(n_qubits, 10)\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": 87,
      "metadata": {
        "id": "MAh4FqBYrd0D",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 0
        },
        "outputId": "5c092ed9-c1c1-480e-d120-41ff791b3f3a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n"
          ]
        }
      ],
      "source": [
        "model_hybrid = torchvision.models.resnet50(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": 88,
      "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": 89,
      "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": 90,
      "metadata": {
        "id": "nco3IrE6rd0E"
      },
      "outputs": [],
      "source": [
        "exp_lr_scheduler = lr_scheduler.StepLR(\n",
        "    optimizer_hybrid, step_size=1000, 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": 91,
      "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": "code",
      "source": [
        "#!pip install -U scikit-learn\n",
        "import numpy as np\n",
        "import torch\n",
        "import copy\n",
        "import time\n",
        "import sklearn\n",
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "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",
        "            all_labels = []\n",
        "            all_preds = []\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",
        "\n",
        "                all_labels.extend(labels.cpu().numpy())\n",
        "                all_preds.extend(preds.cpu().numpy())\n",
        "\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",
        "            # Calculate and print confusion matrix\n",
        "            if phase == \"validation\":\n",
        "                cm = confusion_matrix(all_labels, all_preds)\n",
        "                print(\"Confusion Matrix:\")\n",
        "                print(cm)\n",
        "\n",
        "    # Print final results"
      ],
      "metadata": {
        "id": "tMGx77J_zSLE"
      },
      "execution_count": 92,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CmAl9fIQrd0E"
      },
      "source": [
        "We are ready to perform the actual training process.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {
        "id": "rAQBdDA_rd0E",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 3933
        },
        "outputId": "7b3e4f1f-4182-47ac-8800-341e2dd94875"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training started:\n",
            "Phase: train Epoch: 1/30 Loss: 1.9051 Acc: 0.2975        \n",
            "Phase: validation   Epoch: 1/30 Loss: 1.6243 Acc: 0.4897        \n",
            "Confusion Matrix:\n",
            "[[ 55   7   3  58  32   2   0   0   0   0]\n",
            " [  5  55   2   6  99   0   0   0   0   0]\n",
            " [  0   0  61   0   1  58   0   3   0   0]\n",
            " [ 22   0   2  93  12   0   0   0   0   0]\n",
            " [ 14   4   0   5 207   2   0   1   0   0]\n",
            " [  1   0  19   1   3  95   0   4   0   0]\n",
            " [  6   0   3  50  22   0  18   1   0   1]\n",
            " [  0   0   7   0   0  55   0  47   0   0]\n",
            " [  3   0   0   2  90   0   0   0   0   0]\n",
            " [  1   0   5   2  53   0   0   1   0  10]]\n",
            "Phase: train Epoch: 2/30 Loss: 1.5724 Acc: 0.4823        \n",
            "Phase: validation   Epoch: 2/30 Loss: 1.4402 Acc: 0.5172        \n",
            "Confusion Matrix:\n",
            "[[ 81   1   0  51  23   0   1   0   0   0]\n",
            " [  8  39   0   2 118   0   0   0   0   0]\n",
            " [  0   0  96   0   1  11   0  15   0   0]\n",
            " [ 20   0   2  96  11   0   0   0   0   0]\n",
            " [  7   0   2  11 212   0   0   1   0   0]\n",
            " [  0   0  75   1   3  30   0  14   0   0]\n",
            " [ 12   0   1  37  18   0  31   1   0   1]\n",
            " [  0   0  21   0   1  11   0  76   0   0]\n",
            " [  5   0   0   1  88   0   0   0   1   0]\n",
            " [  2   0   3   0  51   0   0   1   0  15]]\n",
            "Phase: train Epoch: 3/30 Loss: 1.3715 Acc: 0.5842        \n",
            "Phase: validation   Epoch: 3/30 Loss: 1.2943 Acc: 0.5737        \n",
            "Confusion Matrix:\n",
            "[[ 96   1   0  25  26   0   9   0   0   0]\n",
            " [  7  51   0   0 109   0   0   0   0   0]\n",
            " [  0   0  81   0  10  10   1  21   0   0]\n",
            " [ 35   0   0  75  13   0   6   0   0   0]\n",
            " [  7   0   0   1 222   0   1   2   0   0]\n",
            " [  2   0  56   0   8  25   1  31   0   0]\n",
            " [  5   0   0  10  11   0  75   0   0   0]\n",
            " [  0   0   8   0   3   7   0  91   0   0]\n",
            " [  1   0   0   1  68   0   0   0  25   0]\n",
            " [  0   0   0   0  59   0   3   0   0  10]]\n",
            "Phase: train Epoch: 4/30 Loss: 1.2408 Acc: 0.6269        \n",
            "Phase: validation   Epoch: 4/30 Loss: 1.1349 Acc: 0.6960        \n",
            "Confusion Matrix:\n",
            "[[ 75   2   1  47  10   0  13   0   6   3]\n",
            " [  9  89   0   2  60   0   2   0   4   1]\n",
            " [  0   0  78   0   0  30   1  14   0   0]\n",
            " [ 16   0   2  97   1   0  11   0   2   0]\n",
            " [  8   1   0   7 193   1   2   1   6  14]\n",
            " [  0   0  20   1   1  86   1  13   1   0]\n",
            " [  4   0   0   9   2   0  85   0   0   1]\n",
            " [  0   0   5   0   0  22   0  82   0   0]\n",
            " [  0   1   0   2   9   0   0   0  82   1]\n",
            " [  0   0   2   1  20   0   5   0   0  44]]\n",
            "Phase: train Epoch: 5/30 Loss: 1.1178 Acc: 0.6779        \n",
            "Phase: validation   Epoch: 5/30 Loss: 1.0509 Acc: 0.7089        \n",
            "Confusion Matrix:\n",
            "[[123   9   2  18   0   0   4   0   0   1]\n",
            " [ 12 139   0   1  14   0   0   0   1   0]\n",
            " [  0   0  87   0   0  14   1  21   0   0]\n",
            " [ 37   2   1  84   1   0   4   0   0   0]\n",
            " [ 10  48   1  14 144   0   2   1   0  13]\n",
            " [  0   0  38   3   0  59   0  22   0   1]\n",
            " [  9   5   0  10   0   0  77   0   0   0]\n",
            " [  0   0   8   0   0   9   0  92   0   0]\n",
            " [  3   5   0   1   9   0   0   0  77   0]\n",
            " [  1   9   3   2   8   0   3   0   0  46]]\n",
            "Phase: train Epoch: 6/30 Loss: 1.0091 Acc: 0.7106        \n",
            "Phase: validation   Epoch: 6/30 Loss: 0.9293 Acc: 0.7410        \n",
            "Confusion Matrix:\n",
            "[[110  11   1  16   3   0  13   0   0   3]\n",
            " [  8 131   0   0  24   0   0   1   3   0]\n",
            " [  0   0  82   0   0  21   1  19   0   0]\n",
            " [ 30   0   2  83   3   0  10   0   1   0]\n",
            " [  8  26   0   8 174   1   1   1   3  11]\n",
            " [  0   0  25   0   0  74   0  23   0   1]\n",
            " [  8   1   0   4   2   0  85   0   0   1]\n",
            " [  0   0   4   0   0   9   0  96   0   0]\n",
            " [  0   4   0   2   3   0   0   0  86   0]\n",
            " [  0   7   4   1   9   0   2   0   0  49]]\n",
            "Phase: train Epoch: 7/30 Loss: 0.9341 Acc: 0.7411        \n",
            "Phase: validation   Epoch: 7/30 Loss: 1.0064 Acc: 0.6944        \n",
            "Confusion Matrix:\n",
            "[[126   9   0   9  11   0   2   0   0   0]\n",
            " [  7 125   0   0  34   0   0   0   1   0]\n",
            " [  5   6  82   1  10  11   1   7   0   0]\n",
            " [ 47   1   1  64  11   0   5   0   0   0]\n",
            " [  4  14   0   2 208   1   1   0   1   2]\n",
            " [  8   6  42   2  10  48   0   7   0   0]\n",
            " [  9   1   0   5   5   0  80   0   0   1]\n",
            " [  3   3  14   0   3  10   2  74   0   0]\n",
            " [  0   3   0   1  14   0   0   0  77   0]\n",
            " [  2   7   0   2  36   0   0   0   0  25]]\n",
            "Phase: train Epoch: 8/30 Loss: 0.8810 Acc: 0.7470        \n",
            "Phase: validation   Epoch: 8/30 Loss: 0.8609 Acc: 0.7471        \n",
            "Confusion Matrix:\n",
            "[[101   5   1  24   9   0  16   0   0   1]\n",
            " [  5 116   0   1  39   0   1   1   4   0]\n",
            " [  0   0  88   0   1   6   1  27   0   0]\n",
            " [ 11   1   0  99   6   0  11   0   1   0]\n",
            " [  2   5   1   9 199   0   2   1   6   8]\n",
            " [  0   0  37   0   3  49   1  33   0   0]\n",
            " [  4   0   0   5   2   0  90   0   0   0]\n",
            " [  0   0   6   0   0   0   0 103   0   0]\n",
            " [  0   2   0   2   3   0   0   0  88   0]\n",
            " [  0   2   2   1  19   0   3   0   0  45]]\n",
            "Phase: train Epoch: 9/30 Loss: 0.8138 Acc: 0.7666        \n",
            "Phase: validation   Epoch: 9/30 Loss: 0.7972 Acc: 0.7678        \n",
            "Confusion Matrix:\n",
            "[[114   7   1  19   4   0  12   0   0   0]\n",
            " [  8 125   0   1  30   1   0   1   1   0]\n",
            " [  0   0  76   0   0  22   1  24   0   0]\n",
            " [ 16   0   0  97   4   0  11   0   1   0]\n",
            " [  3  11   0   8 194   1   3   1   7   5]\n",
            " [  0   0  23   0   0  69   1  29   0   1]\n",
            " [  3   0   0   3   1   0  94   0   0   0]\n",
            " [  0   0   3   0   0   4   0 102   0   0]\n",
            " [  2   1   0   1   4   0   0   0  87   0]\n",
            " [  0   5   3   1  11   0   4   0   1  47]]\n",
            "Phase: train Epoch: 10/30 Loss: 0.7510 Acc: 0.7775        \n",
            "Phase: validation   Epoch: 10/30 Loss: 0.7569 Acc: 0.7662        \n",
            "Confusion Matrix:\n",
            "[[ 98   7   1  26   2   0  20   0   0   3]\n",
            " [  8 132   0   0  20   0   1   0   2   4]\n",
            " [  0   0  85   0   0  30   1   7   0   0]\n",
            " [  9   0   1 103   1   0  15   0   0   0]\n",
            " [  2  16   0  12 180   2   3   0   4  14]\n",
            " [  0   0  20   0   0  90   1  11   0   1]\n",
            " [  3   2   0   3   0   0  93   0   0   0]\n",
            " [  0   0   6   0   0  24   0  79   0   0]\n",
            " [  0   4   0   2   3   0   0   0  86   0]\n",
            " [  0   3   3   0   4   0   5   0   0  57]]\n",
            "Phase: train Epoch: 11/30 Loss: 0.7298 Acc: 0.7862        \n",
            "Phase: validation   Epoch: 11/30 Loss: 0.7479 Acc: 0.7578        \n",
            "Confusion Matrix:\n",
            "[[109   2   0  18   6   0  11   0   8   3]\n",
            " [  4  96   0   0  57   1   1   1   7   0]\n",
            " [  0   0  72   0   1  38   0  11   0   1]\n",
            " [ 11   0   0  93   6   0   9   0   5   5]\n",
            " [  3   2   0   3 207   2   1   0   6   9]\n",
            " [  0   0  14   1   2  96   0   9   1   0]\n",
            " [  4   0   0   5   2   0  89   0   0   1]\n",
            " [  0   0   5   0   0  13   0  91   0   0]\n",
            " [  1   1   0   1   5   0   0   0  87   0]\n",
            " [  0   1   0   1  15   0   2   0   1  52]]\n",
            "Phase: train Epoch: 12/30 Loss: 0.7349 Acc: 0.7712        \n",
            "Phase: validation   Epoch: 12/30 Loss: 0.6927 Acc: 0.7754        \n",
            "Confusion Matrix:\n",
            "[[115   8   0  17   0   0  13   0   1   3]\n",
            " [  9 128   0   1  26   0   0   0   1   2]\n",
            " [  1   1  88   0   2  27   1   3   0   0]\n",
            " [ 12   1   0  98   7   0   9   0   0   2]\n",
            " [  2  11   0  10 196   2   1   0   0  11]\n",
            " [  1   2  28   3   2  81   0   5   0   1]\n",
            " [  4   2   0   3   0   0  92   0   0   0]\n",
            " [  1   2  11   0   0  21   1  72   0   1]\n",
            " [  0   3   0   1   5   0   0   0  86   0]\n",
            " [  0   4   0   0   6   0   3   0   0  59]]\n",
            "Phase: train Epoch: 13/30 Loss: 0.6608 Acc: 0.7948        \n",
            "Phase: validation   Epoch: 13/30 Loss: 0.6373 Acc: 0.8021        \n",
            "Confusion Matrix:\n",
            "[[122  11   1  11   2   0   6   0   1   3]\n",
            " [  3 138   0   0  22   1   0   0   2   1]\n",
            " [  0   0  89   0   2  25   0   6   0   1]\n",
            " [ 17   3   1  96   6   0   4   0   0   2]\n",
            " [  4  15   0   3 199   2   0   0   0  10]\n",
            " [  0   1  17   0   1  94   0  10   0   0]\n",
            " [ 10   2   0   2   0   0  87   0   0   0]\n",
            " [  0   0   9   0   0  14   0  86   0   0]\n",
            " [  0   5   0   1   3   0   0   0  86   0]\n",
            " [  3   9   1   0   6   0   0   0   0  53]]\n",
            "Phase: train Epoch: 14/30 Loss: 0.6274 Acc: 0.8144        \n",
            "Phase: validation   Epoch: 14/30 Loss: 0.6640 Acc: 0.7830        \n",
            "Confusion Matrix:\n",
            "[[114   6   1  23   2   0   7   0   1   3]\n",
            " [  3 125   0   1  35   0   0   0   2   1]\n",
            " [  0   0  86   1   2  24   1   9   0   0]\n",
            " [  9   1   0 108   5   0   4   0   1   1]\n",
            " [  2   7   0  10 199   2   1   0   1  11]\n",
            " [  0   0  31   4   2  78   0   8   0   0]\n",
            " [  3   0   0   7   1   0  90   0   0   0]\n",
            " [  0   0  12   0   0  10   0  87   0   0]\n",
            " [  0   2   0   2   3   0   0   0  87   1]\n",
            " [  3   2   1   3  11   0   1   0   0  51]]\n",
            "Phase: train Epoch: 15/30 Loss: 0.6185 Acc: 0.8116        \n",
            "Phase: validation   Epoch: 15/30 Loss: 0.7286 Acc: 0.7296        \n",
            "Confusion Matrix:\n",
            "[[117   4   1  16   0   0  18   0   0   1]\n",
            " [ 13 118   0   1  25   1   1   1   2   5]\n",
            " [  0   0 106   0   0   2   2  13   0   0]\n",
            " [ 14   0   0  78   2   0  32   0   0   3]\n",
            " [  1   8   2   9 180   0   8   0   6  19]\n",
            " [  0   0  77   2   1  23   1  18   0   1]\n",
            " [  0   0   1   1   1   0  98   0   0   0]\n",
            " [  0   0  22   0   0   1   0  86   0   0]\n",
            " [  1   1   0   1   3   0   1   0  88   0]\n",
            " [  0   0   2   0   4   0   5   0   0  61]]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-93-bbd0ce1e21df>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m model_hybrid = train_model(\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mmodel_hybrid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer_hybrid\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexp_lr_scheduler\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_epochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_epochs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m )\n",
            "\u001b[0;32m<ipython-input-92-ef1a1cf14921>\u001b[0m in \u001b[0;36mtrain_model\u001b[0;34m(model, criterion, optimizer, scheduler, num_epochs)\u001b[0m\n\u001b[1;32m     43\u001b[0m                 \u001b[0;31m# Track/compute gradient and make an optimization step only when training\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     44\u001b[0m                 \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_grad_enabled\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mphase\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"train\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m                     \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     46\u001b[0m                     \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpreds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m                     \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1499\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1500\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1502\u001b[0m         \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1503\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torchvision/models/resnet.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    283\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    284\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0mTensor\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 285\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_forward_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    286\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    287\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torchvision/models/resnet.py\u001b[0m in \u001b[0;36m_forward_impl\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m    278\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mavgpool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    279\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 280\u001b[0;31m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    281\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    282\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1499\u001b[0m                 \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_pre_hooks\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0m_global_backward_hooks\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1500\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1501\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1502\u001b[0m         \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1503\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-86-ef8634c23b32>\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input_features)\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0mq_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mq_out\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     30\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0melem\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mq_in\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m             \u001b[0mq_out_elem\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mquantum_net\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0melem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mq_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munsqueeze\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     32\u001b[0m             \u001b[0mq_out\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mq_out\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mq_out_elem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/qnode.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    865\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute_kwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"mode\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    866\u001b[0m             \u001b[0;31m# pylint: disable=unexpected-keyword-arg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 867\u001b[0;31m             res = qml.execute(\n\u001b[0m\u001b[1;32m    868\u001b[0m                 \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtape\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    869\u001b[0m                 \u001b[0mdevice\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/interfaces/execution.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(tapes, device, gradient_fn, interface, grad_on_execution, gradient_kwargs, cache, cachesize, max_diff, override_shots, expand_fn, max_expansion, device_batch_transform)\u001b[0m\n\u001b[1;32m    405\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mgradient_fn\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"backprop\"\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0minterface\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    406\u001b[0m         return batch_fn(\n\u001b[0;32m--> 407\u001b[0;31m             qml.interfaces.cache_execute(\n\u001b[0m\u001b[1;32m    408\u001b[0m                 \u001b[0mbatch_execute\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_tuple\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexpand_fn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexpand_fn\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    409\u001b[0m             )(tapes)\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/interfaces/execution.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(tapes, **kwargs)\u001b[0m\n\u001b[1;32m    202\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    203\u001b[0m             \u001b[0;31m# execute all unique tapes that do not exist in the cache\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 204\u001b[0;31m             \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexecution_tapes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    205\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    206\u001b[0m         \u001b[0mfinal_res\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/interfaces/execution.py\u001b[0m in \u001b[0;36mfn\u001b[0;34m(tapes, **kwargs)\u001b[0m\n\u001b[1;32m    128\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtapes\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mSequence\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mQuantumTape\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=function-redefined\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    129\u001b[0m             \u001b[0mtapes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mexpand_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtape\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mtape\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtapes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 130\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0moriginal_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtapes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    131\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    132\u001b[0m     \u001b[0;34m@\u001b[0m\u001b[0mwraps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.10/contextlib.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(*args, **kwds)\u001b[0m\n\u001b[1;32m     77\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     78\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_recreate_cm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 79\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     80\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     81\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/_qubit_device.py\u001b[0m in \u001b[0;36mbatch_execute\u001b[0;34m(self, circuits)\u001b[0m\n\u001b[1;32m    586\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    587\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 588\u001b[0;31m             \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    589\u001b[0m             \u001b[0mresults\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    590\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/devices/default_qubit_torch.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(self, circuit, **kwargs)\u001b[0m\n\u001b[1;32m    230\u001b[0m                     )\n\u001b[1;32m    231\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 232\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    233\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    234\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_asarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/_qubit_device.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(self, circuit, **kwargs)\u001b[0m\n\u001b[1;32m    316\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    317\u001b[0m         \u001b[0;31m# apply all circuit operations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 318\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moperations\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrotations\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_diagonalizing_gates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    319\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    320\u001b[0m         \u001b[0;31m# generate computational basis samples\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/devices/default_qubit.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(self, operations, rotations, **kwargs)\u001b[0m\n\u001b[1;32m    274\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_apply_parametrized_evolution\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moperation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    275\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 276\u001b[0;31m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_state\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_apply_operation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moperation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    277\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    278\u001b[0m         \u001b[0;31m# store the pre-rotated state\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/devices/default_qubit.py\u001b[0m in \u001b[0;36m_apply_operation\u001b[0;34m(self, state, operation)\u001b[0m\n\u001b[1;32m    320\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwires\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    321\u001b[0m             \u001b[0;31m# Einsum is faster for small gates\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 322\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_apply_unitary_einsum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    323\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    324\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_apply_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/pennylane/devices/default_qubit.py\u001b[0m in \u001b[0;36m_apply_unitary_einsum\u001b[0;34m(self, state, mat, wires)\u001b[0m\n\u001b[1;32m    868\u001b[0m         )\n\u001b[1;32m    869\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 870\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_einsum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meinsum_indices\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmat\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    871\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    872\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_apply_diagonal_unitary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mphases\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwires\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/functional.py\u001b[0m in \u001b[0;36meinsum\u001b[0;34m(*args)\u001b[0m\n\u001b[1;32m    376\u001b[0m         \u001b[0;31m# the path for contracting 0 or 1 time(s) is already optimized\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    377\u001b[0m         \u001b[0;31m# or the user has disabled using opt_einsum\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 378\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_VF\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0meinsum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mequation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moperands\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# type: ignore[attr-defined]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    379\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    380\u001b[0m     \u001b[0mpath\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ],
      "source": [
        "model_hybrid = train_model(\n",
        "    model_hybrid, criterion, optimizer_hybrid, exp_lr_scheduler, num_epochs=num_epochs\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "seconds = time.time()\n",
        "print(\"Time in seconds since beginning of run:\", seconds)\n",
        "local_time = time.ctime(seconds)\n",
        "print(local_time)"
      ],
      "metadata": {
        "id": "-qU71GfkJOnf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "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": [],
      "gpuType": "V100"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}