Quantum_Binary_Classifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Quantum Binary Classifier",
      "provenance": [],
      "authorship_tag": "ABX9TyOqk1AI9gtwuJm/N1blKasw",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/chakshu-dhannawat/Quantum-Machine-Learning/blob/main/Quantum_Binary_Classifier.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Requirements:\n",
        "#!pip install qiskit"
      ],
      "metadata": {
        "id": "D73c8DC2XtUu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dy_9vB-oXdg2"
      },
      "outputs": [],
      "source": [
        "#Importing the necessary libraries\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\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 qiskit\n",
        "from qiskit import transpile, assemble\n",
        "from qiskit.visualization import *\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ]
    },
    {
      "cell_type": "code",
      "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",
        "        \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])"
      ],
      "metadata": {
        "id": "-sEOU4QmXkEB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 111
        },
        "id": "EQjkOiyMXnGb",
        "outputId": "24629214-3dec-419f-dd86-75c43a338182"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Expected value for rotation pi 0.5\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "        ┌───┐ ░ ┌───────────┐ ░ ┌─┐\n",
              "     q: ┤ H ├─░─┤ Ry(theta) ├─░─┤M├\n",
              "        └───┘ ░ └───────────┘ ░ └╥┘\n",
              "meas: 1/═════════════════════════╩═\n",
              "                                 0 "
            ],
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐ ░ ┌───────────┐ ░ ┌─┐\n",
              "     q: ┤ H ├─░─┤ Ry(theta) ├─░─┤M├\n",
              "        └───┘ ░ └───────────┘ ░ └╥┘\n",
              "meas: 1/═════════════════════════╩═\n",
              "                                 0 </pre>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "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(1, backend, shots)\n",
        "        self.shift = shift\n",
        "        \n",
        "    def forward(self, input):\n",
        "        return HybridFunction.apply(input, self.quantum_circuit, self.shift)"
      ],
      "metadata": {
        "id": "ted4SywnXpq-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "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)\n",
        "\n",
        "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"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "id": "H7PPotJZX5K2",
        "outputId": "47558b31-e09d-4bf5-8fb8-809987126b3b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x216 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## Testing data\n",
        "\n",
        "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)"
      ],
      "metadata": {
        "id": "O6LfP4_XX8lA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## Implementing out Hybrid Neural Network\n",
        "\n",
        "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)"
      ],
      "metadata": {
        "id": "OrcvDj6yYLd0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## Training our Network\n",
        "\n",
        "model = Net()\n",
        "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()\n",
        "        # Forward pass\n",
        "        output = model(data)\n",
        "        # Calculating loss\n",
        "        loss = loss_func(output, target)\n",
        "        # Backward pass\n",
        "        loss.backward()\n",
        "        # Optimize the weights\n",
        "        optimizer.step()\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]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L14UBoM_YNao",
        "outputId": "d4868297-6e7b-4a87-d38b-f30701859fef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Training [5%]\tLoss: -0.7778\n",
            "Training [10%]\tLoss: -0.9135\n",
            "Training [15%]\tLoss: -0.9382\n",
            "Training [20%]\tLoss: -0.9400\n",
            "Training [25%]\tLoss: -0.9534\n",
            "Training [30%]\tLoss: -0.9528\n",
            "Training [35%]\tLoss: -0.9556\n",
            "Training [40%]\tLoss: -0.9604\n",
            "Training [45%]\tLoss: -0.9705\n",
            "Training [50%]\tLoss: -0.9734\n",
            "Training [55%]\tLoss: -0.9715\n",
            "Training [60%]\tLoss: -0.9704\n",
            "Training [65%]\tLoss: -0.9752\n",
            "Training [70%]\tLoss: -0.9795\n",
            "Training [75%]\tLoss: -0.9849\n",
            "Training [80%]\tLoss: -0.9840\n",
            "Training [85%]\tLoss: -0.9860\n",
            "Training [90%]\tLoss: -0.9878\n",
            "Training [95%]\tLoss: -0.9892\n",
            "Training [100%]\tLoss: -0.9910\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(loss_list)\n",
        "plt.title('Hybrid NN Training Convergence')\n",
        "plt.xlabel('Training Iterations')\n",
        "plt.ylabel('Neg Log Likelihood Loss')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "DPPT9bVhYVlc",
        "outputId": "d5158000-afa8-461a-876e-76df4ffba899"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0, 0.5, 'Neg Log Likelihood Loss')"
            ]
          },
          "metadata": {},
          "execution_count": 18
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## network testing\n",
        "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",
        "        )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WOX4teXDYp4_",
        "outputId": "82d01f12-c461-4537-9e84-e7f78b6a48bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Performance on test data:\n",
            "\tLoss: -0.9874\n",
            "\tAccuracy: 100.0%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 130
        },
        "id": "Dl5wDF80YuFy",
        "outputId": "73109e34-281b-4687-97fa-88b2f1e5eaae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x216 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "THhdo7DwYxJr"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}