{ "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": null, "metadata": {}, "outputs": [], "source": [ "# Install the relevant packages.\n", "\n", "!pip install matplotlib==3.8.4 torch==2.0.1+cu118 torchvision==0.15.2+cu118 scikit-learn==1.4.2 -q --extra-index-url https://download.pytorch.org/whl/cu118" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Import the relevant libraries\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": 3, "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": 4, "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": 5, "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": 6, "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": 7, "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", "if device != 'cpu':\n", " sample_to_plot = x_train[:10].to(torch.device('cpu'))\n", "else:\n", " sample_to_plot = x_train[:10]\n", "\n", "grid_img = torchvision.utils.make_grid(sample_to_plot,\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": 8, "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": 9, "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": 10, "metadata": {}, "outputs": [], "source": [ "class Hybrid_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(Hybrid_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": 11, "metadata": {}, "outputs": [], "source": [ "def accuracy_score(y, y_hat):\n", " return sum((y == (y_hat >= classification_threshold))) / len(y)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "hybrid_model = Hybrid_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": 13, "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": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CUDA-Q Version proto-0.8.0-developer (https://github.com/NVIDIA/cuda-quantum 018ba9130a0e5800b93e86d0096a22daf7a132f8)\n" ] } ], "source": [ "print(cudaq.__version__)" ] } ], "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.10.12" }, "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 }