Hybrid Neural Network.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "from torchsummary import summary\n",
    "\n",
    "import qiskit\n",
    "from qiskit import transpile, assemble, IBMQ\n",
    "from qiskit.visualization import *\n",
    "from qiskit.providers.aer import AerSimulator\n",
    "from qiskit.test.mock import FakeBelem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "provider = IBMQ.load_account()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QuantumCircuit:\n",
    "    \"\"\" \n",
    "    This class provides a simple interface for interaction \n",
    "    with the quantum circuit \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, n_qubits, backend, shots):\n",
    "        # --- Circuit definition ---\n",
    "        self._circuit = qiskit.QuantumCircuit(n_qubits)\n",
    "        \n",
    "        all_qubits = [i for i in range(n_qubits)]\n",
    "        self.theta = qiskit.circuit.Parameter('theta')\n",
    "        \n",
    "        self._circuit.h(all_qubits)\n",
    "        self._circuit.barrier()\n",
    "        self._circuit.ry(self.theta, all_qubits)\n",
    "        \n",
    "        self._circuit.measure_all()\n",
    "        # ---------------------------\n",
    "\n",
    "        self.backend = backend\n",
    "        self.shots = shots\n",
    "    \n",
    "    def run(self, thetas):\n",
    "        t_qc = transpile(self._circuit,\n",
    "                         self.backend)\n",
    "        qobj = assemble(t_qc,\n",
    "                        shots=self.shots,\n",
    "                        parameter_binds = [{self.theta: theta} for theta in thetas])\n",
    "        job = self.backend.run(qobj)\n",
    "        result = job.result().get_counts()\n",
    "        # print(f\"Result is {result}\")\n",
    "        \n",
    "        counts = np.array(list(result.values()))\n",
    "        states = np.array(list(result.keys())).astype(float)\n",
    "        \n",
    "        # Compute probabilities for each state\n",
    "        probabilities = counts / self.shots\n",
    "        # Get state expectation\n",
    "        expectation = np.sum(states * probabilities)\n",
    "        \n",
    "        return np.array([expectation])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected value for rotation pi 0.4\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 417.879x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using a noisy simulator\n",
    "noisy_backend = FakeBelem()\n",
    "simulator = AerSimulator.from_backend(noisy_backend)\n",
    "\n",
    "# simulator = qiskit.Aer.get_backend('aer_simulator')\n",
    "\n",
    "circuit = QuantumCircuit(1, simulator, 100)\n",
    "print('Expected value for rotation pi {}'.format(circuit.run([np.pi])[0]))\n",
    "circuit._circuit.draw('mpl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HybridFunction(Function):\n",
    "    \"\"\" Hybrid quantum - classical function definition \"\"\"\n",
    "    \n",
    "    @staticmethod\n",
    "    def forward(ctx, input, quantum_circuit, shift):\n",
    "        \"\"\" Forward pass computation \"\"\"\n",
    "        ctx.shift = shift\n",
    "        ctx.quantum_circuit = quantum_circuit\n",
    "\n",
    "        expectation_z = ctx.quantum_circuit.run(input[0].tolist())\n",
    "        result = torch.tensor([expectation_z])\n",
    "        ctx.save_for_backward(input, result)\n",
    "\n",
    "        return result\n",
    "        \n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        \"\"\" Backward pass computation \"\"\"\n",
    "        input, expectation_z = ctx.saved_tensors\n",
    "        input_list = np.array(input.tolist())\n",
    "        \n",
    "        shift_right = input_list + np.ones(input_list.shape) * ctx.shift\n",
    "        shift_left = input_list - np.ones(input_list.shape) * ctx.shift\n",
    "        \n",
    "        gradients = []\n",
    "        for i in range(len(input_list)):\n",
    "            expectation_right = ctx.quantum_circuit.run(shift_right[i])\n",
    "            expectation_left  = ctx.quantum_circuit.run(shift_left[i])\n",
    "            \n",
    "            gradient = torch.tensor([expectation_right]) - torch.tensor([expectation_left])\n",
    "            gradients.append(gradient)\n",
    "        gradients = np.array([gradients]).T\n",
    "        return torch.tensor([gradients]).float() * grad_output.float(), None, None\n",
    "\n",
    "class Hybrid(nn.Module):\n",
    "    \"\"\" Hybrid quantum - classical layer definition \"\"\"\n",
    "    \n",
    "    def __init__(self, backend, shots, shift):\n",
    "        super(Hybrid, self).__init__()\n",
    "        self.quantum_circuit = QuantumCircuit(2, backend, shots) # initialize 2 qubit VQC\n",
    "        self.shift = shift\n",
    "        \n",
    "    def forward(self, input):\n",
    "        return HybridFunction.apply(input, self.quantum_circuit, self.shift)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Concentrating on the first 100 samples\n",
    "n_samples = 100\n",
    "\n",
    "X_train = datasets.MNIST(root='./data', train=True, download=True,\n",
    "                         transform=transforms.Compose([transforms.ToTensor()]))\n",
    "\n",
    "# Leaving only labels 0 and 1 \n",
    "idx = np.append(np.where(X_train.targets == 0)[0][:n_samples], \n",
    "                np.where(X_train.targets == 1)[0][:n_samples])\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x216 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_samples_show = 6\n",
    "\n",
    "data_iter = iter(train_loader)\n",
    "fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))\n",
    "\n",
    "while n_samples_show > 0:\n",
    "    images, targets = data_iter.__next__()\n",
    "\n",
    "    axes[n_samples_show - 1].imshow(images[0].numpy().squeeze(), cmap='gray')\n",
    "    axes[n_samples_show - 1].set_xticks([])\n",
    "    axes[n_samples_show - 1].set_yticks([])\n",
    "    axes[n_samples_show - 1].set_title(\"Labeled: {}\".format(targets.item()))\n",
    "    \n",
    "    n_samples_show -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_samples = 50\n",
    "\n",
    "X_test = datasets.MNIST(root='./data', train=False, download=True,\n",
    "                        transform=transforms.Compose([transforms.ToTensor()]))\n",
    "\n",
    "idx = np.append(np.where(X_test.targets == 0)[0][:n_samples], \n",
    "                np.where(X_test.targets == 1)[0][:n_samples])\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": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # 1 input image channel, 6 output channels, 5x5 square convolution\n",
    "        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)\n",
    "        # 6 input channels, 16 output channels, 5x5 square convolution\n",
    "        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)\n",
    "        self.dropout = nn.Dropout2d()\n",
    "        self.fc1 = nn.Linear(256, 64) # fc stands for fully connected layer\n",
    "        self.fc2 = nn.Linear(64, 2) # output 1 to be run on 2 qubit VQC\n",
    "        # self.hybrid = Hybrid(qiskit.Aer.get_backend('aer_simulator'), 100, np.pi / 2)\n",
    "        self.hybrid = [Hybrid(qiskit.Aer.get_backend('aer_simulator'), 100, np.pi / 2) for i in range(2)]\n",
    "\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",
    "\n",
    "        # Here is where the matrixes/channels are flattened into one long vector\n",
    "        x = torch.flatten(x, start_dim=1)\n",
    "        # x = x.view(1, -1) # make it the same shape as output\n",
    "        x = F.relu(self.fc1(x)) # ReLu is applied to fc1(x) where fc1 is channel which it takes an input of 256 and outputs a vector of a size of 64.\n",
    "        x = self.fc2(x) # Final step where input is a size of 64 and output is a size of 10.\n",
    "\n",
    "        x = torch.chunk(x, 2, dim=1)\n",
    "        # x = self.hybrid(x)\n",
    "        x = tuple([hybr(x_) for hybr, x_ in zip(self.hybrid, x)])\n",
    "        return torch.cat(x, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class Net(nn.Module):\n",
    "#     def __init__(self):\n",
    "#         super(Net, self).__init__()\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(64, 1)\n",
    "#         self.hybrid = Hybrid(qiskit.Aer.get_backend('aer_simulator'), 100, np.pi / 2)\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)\n",
    "#         x = self.hybrid(x)\n",
    "#         return torch.cat((x, 1 - x), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==========================================================================================\n",
      "Layer (type:depth-idx)                   Output Shape              Param #\n",
      "==========================================================================================\n",
      "├─Conv2d: 1-1                            [-1, 6, 24, 24]           156\n",
      "├─Conv2d: 1-2                            [-1, 16, 8, 8]            2,416\n",
      "├─Dropout2d: 1-3                         [-1, 16, 4, 4]            --\n",
      "├─Linear: 1-4                            [-1, 64]                  16,448\n",
      "├─Linear: 1-5                            [-1, 2]                   130\n",
      "==========================================================================================\n",
      "Total params: 19,150\n",
      "Trainable params: 19,150\n",
      "Non-trainable params: 0\n",
      "Total mult-adds (M): 0.26\n",
      "==========================================================================================\n",
      "Input size (MB): 0.00\n",
      "Forward/backward pass size (MB): 0.03\n",
      "Params size (MB): 0.07\n",
      "Estimated Total Size (MB): 0.11\n",
      "==========================================================================================\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "==========================================================================================\n",
       "Layer (type:depth-idx)                   Output Shape              Param #\n",
       "==========================================================================================\n",
       "├─Conv2d: 1-1                            [-1, 6, 24, 24]           156\n",
       "├─Conv2d: 1-2                            [-1, 16, 8, 8]            2,416\n",
       "├─Dropout2d: 1-3                         [-1, 16, 4, 4]            --\n",
       "├─Linear: 1-4                            [-1, 64]                  16,448\n",
       "├─Linear: 1-5                            [-1, 2]                   130\n",
       "==========================================================================================\n",
       "Total params: 19,150\n",
       "Trainable params: 19,150\n",
       "Non-trainable params: 0\n",
       "Total mult-adds (M): 0.26\n",
       "==========================================================================================\n",
       "Input size (MB): 0.00\n",
       "Forward/backward pass size (MB): 0.03\n",
       "Params size (MB): 0.07\n",
       "Estimated Total Size (MB): 0.11\n",
       "=========================================================================================="
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Net()\n",
    "summary(model, (1, 28, 28), device='cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/sy/rym6stnx3d37k0n9lzxv5wbc0000gn/T/ipykernel_27707/3728979229.py:32: FutureWarning: The input object of type 'Tensor' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Tensor', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n",
      "  gradients = np.array([gradients]).T\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training [5%]\tLoss: -9.9956\n",
      "Training [10%]\tLoss: -10.5720\n",
      "Training [15%]\tLoss: -10.5989\n",
      "Training [20%]\tLoss: -10.6657\n",
      "Training [25%]\tLoss: -10.7344\n",
      "Training [30%]\tLoss: -10.8710\n",
      "Training [35%]\tLoss: -10.9029\n",
      "Training [40%]\tLoss: -10.9046\n",
      "Training [45%]\tLoss: -10.9347\n",
      "Training [50%]\tLoss: -10.9463\n",
      "Training [55%]\tLoss: -10.9376\n",
      "Training [60%]\tLoss: -10.9688\n",
      "Training [65%]\tLoss: -10.9593\n",
      "Training [70%]\tLoss: -10.9824\n",
      "Training [75%]\tLoss: -10.9819\n",
      "Training [80%]\tLoss: -10.9803\n",
      "Training [85%]\tLoss: -10.9878\n",
      "Training [90%]\tLoss: -10.9814\n",
      "Training [95%]\tLoss: -10.9890\n",
      "Training [100%]\tLoss: -10.9902\n"
     ]
    }
   ],
   "source": [
    "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
    "loss_func = nn.NLLLoss()\n",
    "\n",
    "epochs = 20\n",
    "loss_list = []\n",
    "\n",
    "model.train()\n",
    "for epoch in range(epochs):\n",
    "    total_loss = []\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        optimizer.zero_grad() # clears old gradients from the last step (otherwise you’d just accumulate the gradients from all loss.backward() calls).\n",
    "        # Forward pass\n",
    "        output = model(data)\n",
    "        # Calculating loss\n",
    "        loss = loss_func(output, target)\n",
    "        # Backward pass\n",
    "        loss.backward() # computes the derivative of the loss w.r.t. the parameters (or anything requiring gradients) using backpropagation.\n",
    "        # Optimize the weights\n",
    "        optimizer.step() # causes the optimizer to take a step based on the gradients of the parameters.\n",
    "        \n",
    "        total_loss.append(loss.item())\n",
    "    loss_list.append(sum(total_loss)/len(total_loss))\n",
    "    print('Training [{:.0f}%]\\tLoss: {:.4f}'.format(\n",
    "        100. * (epoch + 1) / epochs, loss_list[-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Negative Log Likelihood Loss')"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(loss_list)\n",
    "plt.title('Hybrid NN Training Convergence')\n",
    "plt.xlabel('Training Iterations')\n",
    "plt.ylabel('Negative Log Likelihood Loss')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performance on test data:\n",
      "\tLoss: -10.9144\n",
      "\tAccuracy: 50.0%\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    \n",
    "    correct = 0\n",
    "    for batch_idx, (data, target) in enumerate(test_loader):\n",
    "        output = model(data)\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",
    "        total_loss.append(loss.item())\n",
    "        \n",
    "    print('Performance on test data:\\n\\tLoss: {:.4f}\\n\\tAccuracy: {:.1f}%'.format(\n",
    "        sum(total_loss) / len(total_loss),\n",
    "        correct / len(test_loader) * 100)\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x216 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_samples_show = 6\n",
    "count = 0\n",
    "fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for batch_idx, (data, target) in enumerate(test_loader):\n",
    "        if count == n_samples_show:\n",
    "            break\n",
    "        output = model(data)\n",
    "        \n",
    "        pred = output.argmax(dim=1, keepdim=True) \n",
    "\n",
    "        axes[count].imshow(data[0].numpy().squeeze(), cmap='gray')\n",
    "\n",
    "        axes[count].set_xticks([])\n",
    "        axes[count].set_yticks([])\n",
    "        axes[count].set_title('Predicted {}'.format(pred.item()))\n",
    "        \n",
    "        count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.12 ('qiskit-env')",
   "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.8.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c5e597ca477812040ed5a1629c6451aa891ac46335823a5f6165f6c73dfc5551"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}