hybrid_qnns.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hybrid Quantum Neural Networks \n",
    "\n",
    "The example below highlights a hybrid quantum neural network workflow with CUDA Quantum and Pytorch where both layers are GPU accelerated to maximise performance. \n",
    "\n",
    "\n",
    "<img src=\"images/hybrid.png\" alt=\"hybrid\" width=\"600\">\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We perform binary classification on the MNIST dataset where data flows through the neural network architecture to the quantum circuit whose output is used to classify hand written digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install matplotlib torch torchvision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the relevant packages\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "from torch.autograd import Function\n",
    "from torchvision import datasets, transforms\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import cudaq\n",
    "from cudaq import spin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# GPU utilities\n",
    "\n",
    "cudaq.set_target(\"nvidia\")  # Set CUDAQ to run on GPU's\n",
    "\n",
    "torch.cuda.is_available(\n",
    ")  # If this is True then the NVIDIA drivers are correctly installed\n",
    "\n",
    "torch.cuda.device_count()  # Counts the number of GPU's available\n",
    "\n",
    "torch.cuda.current_device()\n",
    "\n",
    "torch.cuda.get_device_name(0)\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9912422/9912422 [00:00<00:00, 72632367.27it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 28881/28881 [00:00<00:00, 85487433.89it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 1648877/1648877 [00:00<00:00, 27770426.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4542/4542 [00:00<00:00, 16394603.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Training set\n",
    "sample_count = 140\n",
    "\n",
    "X_train = datasets.MNIST(\n",
    "    root=\"./data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=transforms.Compose([transforms.ToTensor()]),\n",
    ")\n",
    "\n",
    "# Leaving only labels 0 and 1\n",
    "idx = np.append(\n",
    "    np.where(X_train.targets == 0)[0][:sample_count],\n",
    "    np.where(X_train.targets == 1)[0][:sample_count],\n",
    ")\n",
    "\n",
    "X_train.data = X_train.data[idx]\n",
    "X_train.targets = X_train.targets[idx]\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(X_train, batch_size=1, shuffle=True)\n",
    "\n",
    "# Test set\n",
    "sample_count = 70\n",
    "\n",
    "X_test = datasets.MNIST(\n",
    "    root=\"./data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=transforms.Compose([transforms.ToTensor()]),\n",
    ")\n",
    "idx = np.append(\n",
    "    np.where(X_test.targets == 0)[0][:sample_count],\n",
    "    np.where(X_test.targets == 1)[0][:sample_count],\n",
    ")\n",
    "\n",
    "X_test.data = X_test.data[idx]\n",
    "X_test.targets = X_test.targets[idx]\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(X_test, batch_size=1, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumCircuit:\n",
    "    \"\"\"This class defines the quantum circuit structure and the run method which is used to calculate an expectation value\"\"\"\n",
    "\n",
    "    def __init__(self, qubit_count: int):\n",
    "        \"\"\"Define the quantum circuit in CUDA Quantum\"\"\"\n",
    "\n",
    "        kernel, thetas = cudaq.make_kernel(list)\n",
    "\n",
    "        self.kernel = kernel\n",
    "\n",
    "        self.theta = thetas\n",
    "\n",
    "        qubits = kernel.qalloc(qubit_count)\n",
    "\n",
    "        self.kernel.h(qubits)\n",
    "\n",
    "        # Variational gate parameters which are optimised during training\n",
    "        kernel.ry(thetas[0], qubits[0])\n",
    "        kernel.rx(thetas[1], qubits[0])\n",
    "\n",
    "    def run(self, thetas: torch.tensor) -> torch.tensor:\n",
    "        \"\"\"Excetute the quantum circuit to output an expectation value\"\"\"\n",
    "\n",
    "        expectation = torch.tensor(cudaq.observe(self.kernel, spin.z(0),\n",
    "                                                 thetas).expectation(),\n",
    "                                   device=device)\n",
    "\n",
    "        return expectation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumFunction(Function):\n",
    "    \"\"\"Allows the quantum circuit to pass data through it and compute the gradients\"\"\"\n",
    "\n",
    "    @staticmethod\n",
    "    def forward(ctx, thetas: torch.tensor, quantum_circuit,\n",
    "                shift) -> torch.tensor:\n",
    "        # Save shift and quantum_circuit in context to use in backward\n",
    "        ctx.shift = shift\n",
    "        ctx.quantum_circuit = quantum_circuit\n",
    "\n",
    "        # Calculate exp_val\n",
    "        expectation_z = ctx.quantum_circuit.run(thetas)\n",
    "\n",
    "        ctx.save_for_backward(thetas, expectation_z)\n",
    "\n",
    "        return expectation_z\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        \"\"\"Backward pass computation via finite difference parameter shift\"\"\"\n",
    "\n",
    "        thetas, expectation_z = ctx.saved_tensors\n",
    "\n",
    "        gradients = torch.zeros(len(thetas), device=device)\n",
    "\n",
    "        for i in range(len(thetas)):\n",
    "            shift_right = torch.clone(thetas)\n",
    "\n",
    "            shift_right[i] += ctx.shift\n",
    "\n",
    "            shift_left = torch.clone(thetas)\n",
    "\n",
    "            shift_left[i] -= ctx.shift\n",
    "\n",
    "            expectation_right = ctx.quantum_circuit.run(shift_right)\n",
    "            expectation_left = ctx.quantum_circuit.run(shift_left)\n",
    "\n",
    "            gradients[i] = 0.5 * (expectation_right - expectation_left)\n",
    "\n",
    "        return gradients * grad_output.float(), None, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumLayer(nn.Module):\n",
    "    \"\"\"Encapsulates a quantum circuit and a quantum function into a quantum layer\"\"\"\n",
    "\n",
    "    def __init__(self, shift: torch.tensor):\n",
    "        super(QuantumLayer, self).__init__()\n",
    "        self.quantum_circuit = QuantumCircuit(1)  # 1 qubit quantum circuit\n",
    "        self.shift = shift\n",
    "\n",
    "    def forward(self, input):\n",
    "        ans = QuantumFunction.apply(input, self.quantum_circuit, self.shift)\n",
    "\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "\n",
    "        # Neural network structure\n",
    "        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)\n",
    "        self.dropout = nn.Dropout2d()\n",
    "        self.fc1 = nn.Linear(256, 64)\n",
    "        self.fc2 = nn.Linear(\n",
    "            64, 2\n",
    "        )  # Output a 2D tensor since we have 2 variational parameters in our quantum circuit\n",
    "        self.hybrid = QuantumLayer(\n",
    "            torch.tensor(np.pi / 2)\n",
    "        )  # Input is the magnitude of the parameter shifts to calculate gradients\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.max_pool2d(x, 2)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.max_pool2d(x, 2)\n",
    "        x = self.dropout(x)\n",
    "        x = x.view(1, -1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x).reshape(\n",
    "            -1)  # Reshapes required to satisfy input dimensions to CUDAQ\n",
    "        x = self.hybrid(x).reshape(-1)\n",
    "\n",
    "        return torch.cat((x, 1 - x), -1).unsqueeze(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training [5%]\tLoss: -1.1866\n",
      "Training [10%]\tLoss: -1.3703\n",
      "Training [15%]\tLoss: -1.3844\n",
      "Training [20%]\tLoss: -1.4073\n",
      "Training [25%]\tLoss: -1.4137\n",
      "Training [30%]\tLoss: -1.4255\n",
      "Training [35%]\tLoss: -1.4483\n",
      "Training [40%]\tLoss: -1.4524\n",
      "Training [45%]\tLoss: -1.4641\n",
      "Training [50%]\tLoss: -1.4565\n",
      "Training [55%]\tLoss: -1.4760\n",
      "Training [60%]\tLoss: -1.4755\n",
      "Training [65%]\tLoss: -1.4795\n",
      "Training [70%]\tLoss: -1.4867\n",
      "Training [75%]\tLoss: -1.4888\n",
      "Training [80%]\tLoss: -1.4942\n",
      "Training [85%]\tLoss: -1.4907\n",
      "Training [90%]\tLoss: -1.4817\n",
      "Training [95%]\tLoss: -1.4939\n",
      "Training [100%]\tLoss: -1.4860\n"
     ]
    }
   ],
   "source": [
    "# We move our model to the CUDA device to minimise data transfer between GPU and CPU\n",
    "\n",
    "model = Net().to(device)\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "loss_func = nn.NLLLoss().to(device)\n",
    "\n",
    "epochs = 20\n",
    "\n",
    "epoch_loss = []\n",
    "\n",
    "model.train()\n",
    "for epoch in range(epochs):\n",
    "    batch_loss = 0.0\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):  # batch training\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        data, target = data.to(device), target.to(device)\n",
    "\n",
    "        # Forward pass\n",
    "        output = model(data).to(device)\n",
    "\n",
    "        # Calculating loss\n",
    "        loss = loss_func(output, target).to(device)\n",
    "\n",
    "        # Backward pass\n",
    "        loss.backward()\n",
    "\n",
    "        # Optimize the weights\n",
    "        optimizer.step()\n",
    "\n",
    "        batch_loss += loss.item()\n",
    "\n",
    "    epoch_loss.append(batch_loss / batch_idx)\n",
    "\n",
    "    print(\"Training [{:.0f}%]\\tLoss: {:.4f}\".format(\n",
    "        100.0 * (epoch + 1) / epochs, epoch_loss[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Neg Log Likelihood Loss')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epoch_loss)\n",
    "plt.title(\"Hybrid NN Training Convergence\")\n",
    "plt.xlabel(\"Training Iterations\")\n",
    "\n",
    "plt.ylabel(\"Neg Log Likelihood Loss\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance on test data:\n",
      "\tAccuracy: 100.0%\n"
     ]
    }
   ],
   "source": [
    "# Testing on the test set\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    correct = 0\n",
    "    for batch_idx, (data, target) in enumerate(test_loader):\n",
    "        data, target = data.to(device), target.to(device)\n",
    "\n",
    "        output = model(data).to(device)\n",
    "\n",
    "        pred = output.argmax(dim=1, keepdim=True)\n",
    "        correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "\n",
    "        loss = loss_func(output, target)\n",
    "        epoch_loss.append(loss.item())\n",
    "\n",
    "    print(\"Performance on test data:\\n\\tAccuracy: {:.1f}%\".format(\n",
    "        correct / len(test_loader) * 100))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12 (main, Jun 11 2023, 05:26:28) [GCC 11.4.0]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}