{ "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-Q and PyTorch where both layers can GPU accelerated to maximise performance." ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "\"hybrid\"\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": 1, "metadata": {}, "outputs": [], "source": [ "# Import the relevant packages.\n", "\n", "!pip install matplotlib==3.8.4\n", "!pip install torch==2.2.2\n", "!pip install torchvision==0.17.0\n", "!pip install scikit-learn==1.4.2\n", "\n", "import cudaq\n", "from cudaq import spin\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "import numpy as np\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 torchvision\n", "\n", "from sklearn.model_selection import train_test_split\n", "\n", "torch.manual_seed(22)\n", "cudaq.set_random_seed(44)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Set CUDAQ and PyTorch to run on either CPU or GPU.\n", "\n", "device = torch.device('cpu')\n", "cudaq.set_target(\"qpp-cpu\")\n", "\n", "# cudaq.set_target(\"nvidia\")\n", "# device = torch.device(\"cuda:0\")" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def prepare_data(target_digits, sample_count, test_size):\n", " \"\"\"Load and prepare the MNIST dataset to be used \n", " \n", " Args: \n", " target_digits (list): digits to perform classification of \n", " sample_count (int): total number of images to be used\n", " test_size (float): percentage of sample_count to be used as test set, the remainder is the training set\n", " \n", " Returns: \n", " dataset in train, test format with targets \n", " \n", " \"\"\"\n", "\n", " transform = transforms.Compose(\n", " [transforms.ToTensor(),\n", " transforms.Normalize((0.1307), (0.3081))])\n", "\n", " dataset = datasets.MNIST(\"./data\",\n", " train=True,\n", " download=True,\n", " transform=transform)\n", "\n", " # Filter out the required labels.\n", " idx = (dataset.targets == target_digits[0]) | (dataset.targets\n", " == target_digits[1])\n", " dataset.data = dataset.data[idx]\n", " dataset.targets = dataset.targets[idx]\n", "\n", " # Select a subset based on number of datapoints specified by sample_count.\n", " subset_indices = torch.randperm(dataset.data.size(0))[:sample_count]\n", "\n", " x = dataset.data[subset_indices].float().unsqueeze(1).to(device)\n", "\n", " y = dataset.targets[subset_indices].to(device).float().to(device)\n", "\n", " # Relabel the targets as a 0 or a 1.\n", " y = torch.where(y == min(target_digits), 0.0, 1.0)\n", "\n", " x_train, x_test, y_train, y_test = train_test_split(x,\n", " y,\n", " test_size=test_size /\n", " 100,\n", " shuffle=True,\n", " random_state=42)\n", "\n", " return x_train, x_test, y_train, y_test" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Classical parameters.\n", "\n", "sample_count = 1000 # Total number of images to use.\n", "target_digits = [5, 6] # Hand written digits to classify.\n", "test_size = 30 # Percentage of dataset to be used for testing.\n", "classification_threshold = 0.5 # Classification boundary used to measure accuracy.\n", "epochs = 1000 # Number of epochs to train for.\n", "\n", "# Quantum parmeters.\n", "\n", "qubit_count = 1\n", "hamiltonian = spin.z(0) # Measurement operator.\n", "shift = torch.tensor(torch.pi / 2) # Magnitude of parameter shift." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "x_train, x_test, y_train, y_test = prepare_data(target_digits, sample_count,\n", " test_size)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot some images from the training set to visualise.\n", "\n", "grid_img = torchvision.utils.make_grid(x_train[:10],\n", " nrow=5,\n", " padding=3,\n", " normalize=True)\n", "plt.imshow(grid_img.permute(1, 2, 0))\n", "plt.axis('off') \n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class QuantumFunction(Function):\n", " \"\"\"Allows the quantum circuit to input data, output expectation values \n", " and calculate gradients of variational parameters via finite difference\"\"\"\n", "\n", " def __init__(self, qubit_count: int, hamiltonian: cudaq.SpinOperator):\n", " \"\"\"Define the quantum circuit in CUDA Quantum\"\"\"\n", "\n", " @cudaq.kernel\n", " def kernel(qubit_count: int, thetas: np.ndarray):\n", "\n", " qubits = cudaq.qvector(qubit_count)\n", "\n", " ry(thetas[0], qubits[0])\n", " rx(thetas[1], qubits[0])\n", "\n", " self.kernel = kernel\n", " self.qubit_count = qubit_count\n", " self.hamiltonian = hamiltonian\n", "\n", " def run(self, theta_vals: torch.tensor) -> torch.tensor:\n", " \"\"\"Excetute the quantum circuit to output an expectation value\"\"\"\n", "\n", " #If running on GPU, thetas is a torch.tensor that will live on GPU memory. The observe function calls a .tolist() method on inputs which moves thetas from GPU to CPU.\n", "\n", " qubit_count = [self.qubit_count for _ in range(theta_vals.shape[0])]\n", "\n", " results = cudaq.observe(self.kernel, self.hamiltonian, qubit_count,\n", " theta_vals)\n", "\n", " exp_vals = [results[i].expectation() for i in range(len(results))]\n", " exp_vals = torch.Tensor(exp_vals).to(device)\n", "\n", " return exp_vals\n", "\n", " @staticmethod\n", " def forward(ctx, thetas: torch.tensor, quantum_circuit,\n", " shift) -> torch.tensor:\n", "\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 expectation value.\n", " exp_vals = ctx.quantum_circuit.run(thetas).reshape(-1, 1)\n", "\n", " ctx.save_for_backward(thetas, exp_vals)\n", "\n", " return exp_vals\n", "\n", " @staticmethod\n", " def backward(ctx, grad_output):\n", " \"\"\"Backward pass computation via finite difference\"\"\"\n", "\n", " thetas, _ = ctx.saved_tensors\n", "\n", " gradients = torch.zeros(thetas.shape, device=device)\n", "\n", " for i in range(thetas.shape[1]):\n", "\n", " thetas_plus = thetas.clone()\n", " thetas_plus[:, i] += ctx.shift\n", " exp_vals_plus = ctx.quantum_circuit.run(thetas_plus)\n", "\n", " thetas_minus = thetas.clone()\n", " thetas_minus[:, i] -= ctx.shift\n", " exp_vals_minus = ctx.quantum_circuit.run(thetas_minus)\n", "\n", " gradients[:, i] = (exp_vals_plus - exp_vals_minus) / (2 * ctx.shift)\n", "\n", " gradients = torch.mul(grad_output, gradients)\n", "\n", " return gradients, None, None" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "class QuantumLayer(nn.Module):\n", " \"\"\"Encapsulates a quantum circuit into a quantum layer adhering PyTorch convention\"\"\"\n", "\n", " def __init__(self, qubit_count: int, hamiltonian, shift: torch.tensor):\n", " super(QuantumLayer, self).__init__()\n", "\n", " self.quantum_circuit = QuantumFunction(qubit_count, hamiltonian)\n", " self.shift = shift\n", "\n", " def forward(self, input):\n", "\n", " result = QuantumFunction.apply(input, self.quantum_circuit, self.shift)\n", "\n", " return result" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "class Hyrbid_QNN(nn.Module):\n", " \"\"\"Structure of the hybrid neural network with classical fully connected layers and quantum layers\"\"\"\n", "\n", " def __init__(self):\n", " super(Hyrbid_QNN, self).__init__()\n", "\n", " self.fc1 = nn.Linear(28 * 28, 256)\n", " self.fc2 = nn.Linear(256, 128)\n", " self.dropout = nn.Dropout(0.25)\n", "\n", " self.fc3 = nn.Linear(128, 64)\n", " self.fc4 = nn.Linear(64, 32)\n", " self.fc5 = nn.Linear(32, 2)\n", " self.dropout = nn.Dropout(0.25)\n", "\n", " # The 2 outputs from PyTorch fc5 layer feed into the 2 variational gates in the quantum circuit.\n", " self.quantum = QuantumLayer(qubit_count, hamiltonian, shift)\n", "\n", " def forward(self, x):\n", "\n", " x = x.view(-1, 28 * 28) # Turns images into vectors.\n", "\n", " x = torch.relu(self.fc1(x))\n", " x = torch.relu(self.fc2(x))\n", " x = self.dropout(x)\n", "\n", " x = torch.relu(self.fc3(x))\n", " x = torch.relu(self.fc4(x))\n", " x = torch.relu(self.fc5(x))\n", " x = self.dropout(x)\n", "\n", " # Quantum circuit outputs an expectation value which is fed into the sigmoid activation function to perform classification.\n", " x = torch.sigmoid(self.quantum(x))\n", "\n", " return x.view(-1)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def accuracy_score(y, y_hat):\n", " return sum((y == (y_hat >= classification_threshold))) / len(y)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "hybrid_model = Hyrbid_QNN().to(device)\n", "\n", "optimizer = optim.Adadelta(hybrid_model.parameters(),\n", " lr=0.001,\n", " weight_decay=0.8)\n", "\n", "loss_function = nn.BCELoss().to(device)\n", "\n", "training_cost = []\n", "testing_cost = []\n", "training_accuracy = []\n", "testing_accuracy = []\n", "\n", "hybrid_model.train()\n", "for epoch in range(epochs):\n", "\n", " optimizer.zero_grad()\n", "\n", " y_hat_train = hybrid_model(x_train).to(device)\n", "\n", " train_cost = loss_function(y_hat_train, y_train).to(device)\n", "\n", " train_cost.backward()\n", "\n", " optimizer.step()\n", "\n", " training_accuracy.append(accuracy_score(y_train, y_hat_train))\n", " training_cost.append(train_cost.item())\n", "\n", " hybrid_model.eval()\n", " with torch.no_grad():\n", "\n", " y_hat_test = hybrid_model(x_test).to(device)\n", "\n", " test_cost = loss_function(y_hat_test, y_test).to(device)\n", "\n", " testing_accuracy.append(accuracy_score(y_test, y_hat_test))\n", " testing_cost.append(test_cost.item())" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(10, 5))\n", "\n", "plt.subplot(1, 2, 1)\n", "plt.plot(training_cost, label='Train')\n", "plt.plot(testing_cost, label='Test')\n", "plt.xlabel('Epochs')\n", "plt.ylabel('Cost')\n", "plt.legend()\n", "\n", "plt.subplot(1, 2, 2)\n", "plt.plot(training_accuracy, label='Train')\n", "plt.plot(testing_accuracy, label='Test')\n", "plt.xlabel('Epochs')\n", "plt.ylabel('Accuracy')\n", "plt.legend()\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CUDA-Q Version latest (https://github.com/NVIDIA/cuda-quantum a726804916fd397408cbf595ce6fe5f33dcd8b4c)\n" ] } ], "source": [ "print(cudaq.__version__)" ] } ], "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, Nov 20 2023, 15:14:05) [GCC 11.4.0]" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" } } }, "nbformat": 4, "nbformat_minor": 2 }