868 lines (867 with data), 339.0 kB

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns \n",
    "sns.set_style('dark')\n",
    "\n",
    "# ====== Scikit-learn imports ======\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import (\n",
    "    auc,\n",
    "    roc_curve,\n",
    "    ConfusionMatrixDisplay,\n",
    "    f1_score,\n",
    "    balanced_accuracy_score,\n",
    ")\n",
    "from sklearn.preprocessing import StandardScaler, LabelBinarizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# ====== Qiskit imports ======\n",
    "\n",
    "from qiskit.circuit.library import ZZFeatureMap\n",
    "from qiskit import QuantumCircuit\n",
    "from qiskit_aer import AerSimulator\n",
    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
    "from qiskit_algorithms.utils import algorithm_globals\n",
    "from qiskit.primitives import Sampler\n",
    "from qiskit_ibm_runtime.fake_provider import FakeManilaV2\n",
    "from qiskit.circuit.library import RealAmplitudes, EfficientSU2\n",
    "from qiskit_algorithms.state_fidelities import ComputeUncompute\n",
    "from qiskit_machine_learning.kernels import FidelityQuantumKernel\n",
    "from qiskit_machine_learning.algorithms import QSVC\n",
    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
    "from qiskit_algorithms.optimizers import COBYLA, NFT, SLSQP\n",
    "\n",
    "## ====== Torch imports ======\n",
    "import torch\n",
    "import torch.nn as nn \n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from lightning.pytorch.utilities.types import OptimizerLRScheduler\n",
    "import torch.utils.data\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "\n",
    "import lightning, lightning.pytorch.loggers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\8J6010897\\AppData\\Local\\Temp\\ipykernel_81408\\1421692985.py:6: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  labels_filtered['Labels'] = [x.split(' ')[1] for x in labels_filtered['Labels']]\n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv(\"C:/Users/8J6010897/Documents/GitHub/ISMB/data/GSE116237_forQ.csv\")\n",
    "labels = pd.read_csv(\"C:/Users/8J6010897/Documents/GitHub/ISMB/data/GSE116237 filtered labels.csv\")\n",
    "labels.drop('Unnamed: 0', axis=1, inplace=True)\n",
    "labels.columns = ['Cells', 'Labels']\n",
    "labels_filtered = labels[labels['Cells'].isin(list(df['Cells']))]\n",
    "labels_filtered['Labels'] = [x.split(' ')[1] for x in labels_filtered['Labels']]\n",
    "df = pd.merge(df, labels_filtered, on='Cells', how='inner')\n",
    "df['Labels'] = df['Labels'].map({'T0': 0, 'phase2': 1})\n",
    "y = np.array(df['Labels'])\n",
    "X = df[df.columns[1:-1]].values\n",
    "\n",
    "num_samples = X.shape[0]\n",
    "num_feats = X.shape[1]\n",
    "output_dim = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2001\n"
     ]
    }
   ],
   "source": [
    "print(num_feats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedder = torch.nn.Sequential(\n",
    "            nn.Linear(num_feats,256),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(256,64),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(64,32), \n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(32,16), \n",
    "            nn.LeakyReLU(),\n",
    "            nn.Linear(16,output_dim),\n",
    "            nn.LeakyReLU(), \n",
    "            ) \n",
    "\n",
    "classifier = torch.nn.Sequential(\n",
    "            nn.Linear(output_dim,1),\n",
    "            nn.Softmax(dim=1)\n",
    "            )\n",
    "class BinaryClassifierModel(lightning.LightningModule):\n",
    "    def __init__(self, embedder, classifier, input_dim,learning_rate=1e-3):\n",
    "        super().__init__()\n",
    "        # self.fc1 = nn.Linear(input_dim, 264)\n",
    "        # self.fc2 = nn.Linear(264, 128)\n",
    "        # self.fc3 = nn.Linear(128, 64)\n",
    "        # self.fc4 = nn.Linear(64, 8)\n",
    "        # self.fc5 = nn.Linear(8,4)\n",
    "        # self.fc6 = nn.Linear(4,1)\n",
    "        self.input_dim = input_dim\n",
    "        self.embedder = embedder\n",
    "        self.classifier = classifier\n",
    "        \n",
    "        self.learning_rate = learning_rate\n",
    "        self.loss_fun = nn.BCELoss()   \n",
    "    # def forward(self, x):\n",
    "    #     x = F.relu(self.fc1(x))\n",
    "    #     x = F.relu(self.fc2(x))\n",
    "    #     x = F.relu(self.fc3(x))\n",
    "    #     x = F.relu(self.fc4(x))\n",
    "    #     x = F.relu(self.fc5(x))\n",
    "    #     return F.softmax(self.fc6(x), dim=1)\n",
    "    \n",
    "    def train_dataloader(self):\n",
    "        return DataLoader(self.train_data, batch_size=32, shuffle=True)\n",
    "\n",
    "    def val_dataloader(self):\n",
    "        return DataLoader(self.val_data, batch_size=32)  # No shuffling for validation\n",
    "    \n",
    "    def forward(self, X): \n",
    "        x = self.embedder(X)\n",
    "        x = self.classifier(x) \n",
    "        return x \n",
    "    \n",
    "    def training_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y = y.unsqueeze(1)\n",
    "        y_float = y.float()\n",
    "        x_embedder = self.embedder(x)\n",
    "        y_hat = self.classifier(x_embedder)\n",
    "        #y_hat = torch.argmax(y_hat, dim=1)\n",
    "        loss = self.loss_fun(y_hat, y_float)\n",
    "        self.log(\"train_loss\", loss, \n",
    "                prog_bar=True, \n",
    "                logger=True)\n",
    "        return loss\n",
    "    \n",
    "    def validation_step(self, batch, batch_idx):\n",
    "        x, y = batch\n",
    "        y = y.unsqueeze(1)\n",
    "        y_float = y.float()\n",
    "        x_embedder = self.embedder(x)\n",
    "        y_hat = self.classifier(x_embedder)\n",
    "        val_loss = self.loss_fun(y_hat, y_float)\n",
    "        f1score = f1_score(y_hat, y)\n",
    "        print(f1score)\n",
    "        #print(val_loss)\n",
    "        self.log(\"val_loss\", val_loss, prog_bar=False, logger=True)  # Log on epoch end\n",
    "        return val_loss\n",
    "\n",
    "        \n",
    "    def configure_optimizers(self):\n",
    "        return torch.optim.Adam(self.classifier.parameters(), lr=self.learning_rate)\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_data(X_train, y_train, X_val, y_val):\n",
    "    # Assuming X and y are NumPy arrays\n",
    "\n",
    "    train_data = TensorDataset(torch.tensor(X_train, dtype=torch.float32), \n",
    "                        torch.tensor(y_train, dtype=torch.float32))\n",
    "    val_data = TensorDataset(torch.tensor(X_val, dtype=torch.float32), \n",
    "                        torch.tensor(y_val, dtype=torch.float32))\n",
    "    \n",
    "    return train_data, val_data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "GPU available: False, used: False\n",
      "TPU available: False, using: 0 TPU cores\n",
      "HPU available: False, using: 0 HPUs\n",
      "Missing logger folder: .\\original_classifier\n",
      "\n",
      "  | Name       | Type       | Params | Mode \n",
      "--------------------------------------------------\n",
      "0 | embedder   | Sequential | 531 K  | train\n",
      "1 | classifier | Sequential | 11     | train\n",
      "2 | loss_fun   | BCELoss    | 0      | train\n",
      "--------------------------------------------------\n",
      "531 K     Trainable params\n",
      "0         Non-trainable params\n",
      "531 K     Total params\n",
      "2.127     Total estimated model params size (MB)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sanity Checking DataLoader 0:   0%|          | 0/1 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\8J6010897\\AppData\\Local\\anaconda3\\envs\\new\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:424: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=15` in the `DataLoader` to improve performance.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "                                                                           "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\8J6010897\\AppData\\Local\\anaconda3\\envs\\new\\Lib\\site-packages\\lightning\\pytorch\\trainer\\connectors\\data_connector.py:424: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=15` in the `DataLoader` to improve performance.\n",
      "c:\\Users\\8J6010897\\AppData\\Local\\anaconda3\\envs\\new\\Lib\\site-packages\\lightning\\pytorch\\loops\\fit_loop.py:298: The number of training batches (9) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: 100%|██████████| 9/9 [00:00<00:00, 144.95it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 1: 100%|██████████| 9/9 [00:00<00:00, 160.47it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 2: 100%|██████████| 9/9 [00:00<00:00, 150.92it/s, v_num=0, train_loss=66.70]0.6666666666666666\n",
      "Epoch 3: 100%|██████████| 9/9 [00:00<00:00, 146.09it/s, v_num=0, train_loss=66.70]0.6666666666666666\n",
      "Epoch 4: 100%|██████████| 9/9 [00:00<00:00, 156.24it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 5: 100%|██████████| 9/9 [00:00<00:00, 136.02it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 6: 100%|██████████| 9/9 [00:00<00:00, 153.54it/s, v_num=0, train_loss=11.10]0.6666666666666666\n",
      "Epoch 7: 100%|██████████| 9/9 [00:00<00:00, 143.76it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 8: 100%|██████████| 9/9 [00:00<00:00, 134.04it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 9: 100%|██████████| 9/9 [00:00<00:00, 138.20it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 10: 100%|██████████| 9/9 [00:00<00:00, 107.60it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 11: 100%|██████████| 9/9 [00:00<00:00, 142.64it/s, v_num=0, train_loss=66.70]0.6666666666666666\n",
      "Epoch 12: 100%|██████████| 9/9 [00:00<00:00, 169.58it/s, v_num=0, train_loss=66.70]0.6666666666666666\n",
      "Epoch 13: 100%|██████████| 9/9 [00:00<00:00, 159.26it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 14: 100%|██████████| 9/9 [00:00<00:00, 136.16it/s, v_num=0, train_loss=77.80]0.6666666666666666\n",
      "Epoch 15: 100%|██████████| 9/9 [00:00<00:00, 171.18it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 16: 100%|██████████| 9/9 [00:00<00:00, 154.89it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 17: 100%|██████████| 9/9 [00:00<00:00, 161.93it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 18: 100%|██████████| 9/9 [00:00<00:00, 153.55it/s, v_num=0, train_loss=55.60]0.6666666666666666\n",
      "Epoch 19: 100%|██████████| 9/9 [00:00<00:00, 141.49it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 20: 100%|██████████| 9/9 [00:00<00:00, 157.69it/s, v_num=0, train_loss=66.70]0.6666666666666666\n",
      "Epoch 21: 100%|██████████| 9/9 [00:00<00:00, 160.46it/s, v_num=0, train_loss=77.80]0.6666666666666666\n",
      "Epoch 22: 100%|██████████| 9/9 [00:00<00:00, 154.90it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 23: 100%|██████████| 9/9 [00:00<00:00, 154.94it/s, v_num=0, train_loss=77.80]0.6666666666666666\n",
      "Epoch 24: 100%|██████████| 9/9 [00:00<00:00, 101.52it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 25: 100%|██████████| 9/9 [00:00<00:00, 160.51it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 26: 100%|██████████| 9/9 [00:00<00:00, 160.46it/s, v_num=0, train_loss=55.60]0.6666666666666666\n",
      "Epoch 27: 100%|██████████| 9/9 [00:00<00:00, 163.42it/s, v_num=0, train_loss=88.90]0.6666666666666666\n",
      "Epoch 28: 100%|██████████| 9/9 [00:00<00:00, 144.94it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 29: 100%|██████████| 9/9 [00:00<00:00, 134.03it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 30: 100%|██████████| 9/9 [00:00<00:00, 160.46it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 31: 100%|██████████| 9/9 [00:00<00:00, 164.87it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 32: 100%|██████████| 9/9 [00:00<00:00, 129.30it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 33: 100%|██████████| 9/9 [00:00<00:00, 133.12it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 34: 100%|██████████| 9/9 [00:00<00:00, 148.53it/s, v_num=0, train_loss=66.70]0.6666666666666666\n",
      "Epoch 35: 100%|██████████| 9/9 [00:00<00:00, 137.17it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 36: 100%|██████████| 9/9 [00:00<00:00, 148.49it/s, v_num=0, train_loss=22.20]0.6666666666666666\n",
      "Epoch 37: 100%|██████████| 9/9 [00:00<00:00, 141.53it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 38: 100%|██████████| 9/9 [00:00<00:00, 135.08it/s, v_num=0, train_loss=44.40]0.6666666666666666\n",
      "Epoch 39: 100%|██████████| 9/9 [00:00<00:00, 136.11it/s, v_num=0, train_loss=33.30]0.6666666666666666\n",
      "Epoch 39: 100%|██████████| 9/9 [00:00<00:00, 76.44it/s, v_num=0, train_loss=33.30] "
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "`Trainer.fit` stopped: `max_epochs=40` reached.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 39: 100%|██████████| 9/9 [00:00<00:00, 68.57it/s, v_num=0, train_loss=33.30]\n",
      "Mean F1 score:  0.6545454545454545\n",
      "SVC: 0.6891891891891891\n"
     ]
    }
   ],
   "source": [
    "f1s = []\n",
    "embeddings_train = []\n",
    "embeddings_test = []\n",
    "num_iter = 1\n",
    "for i in range(num_iter): \n",
    "\n",
    "    X_working, X_held_out, y_working, y_held_out = train_test_split(X,\n",
    "                                                        y,\n",
    "                                                        train_size=0.8,\n",
    "                                                        shuffle=True)\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_working,\n",
    "                                                        y_working,\n",
    "                                                        train_size=0.9,\n",
    "                                                        shuffle=True)\n",
    "\n",
    "    num_epochs = 40\n",
    "    model = BinaryClassifierModel(embedder, classifier, input_dim=num_feats)\n",
    "    model.train_data, model.val_data = prepare_data(X_train, y_train, X_test, y_test)  # Prepare data for training\n",
    "    logger = lightning.pytorch.loggers.TensorBoardLogger(save_dir=\".\",name=\"original_classifier\")\n",
    "    # Train the model\n",
    "    trainer = lightning.Trainer(max_epochs=num_epochs, \n",
    "                                logger=logger)  # Adjust progress bar refresh rate as needed\n",
    "    trainer.fit(model)\n",
    "    model.eval()\n",
    "    embedded_test = model.embedder(torch.tensor(X_held_out, dtype=torch.float32))\n",
    "    y_pred = model.classifier(embedded_test)\n",
    "    #y_pred = model(torch.tensor(X_held_out, dtype=torch.float32))\n",
    "    y_pred_proba = y_pred.detach().cpu().numpy()\n",
    "    y_pred_class = np.round(y_pred_proba)\n",
    "\n",
    "    f1 = f1_score(y_held_out, y_pred_class)\n",
    "    f1s.append(f1)\n",
    "    \n",
    "    embedded_train = model.embedder(torch.tensor(X_working, dtype=torch.float32)).detach().numpy()\n",
    "    embeddings_train.append(embedded_train)\n",
    "    embeddings_test.append(embedded_test.detach().numpy())\n",
    "    \n",
    "\n",
    "print(\"Mean F1 score: \", np.mean(f1s))\n",
    "embedded_train = embeddings_train[0]\n",
    "embedded_test = embeddings_test[0]\n",
    "svc = SVC()\n",
    "svc_vanilla = svc.fit(embedded_train, y_working)\n",
    "labels_vanilla = svc_vanilla.predict(embedded_test)\n",
    "f1_svc = f1_score(y_held_out, labels_vanilla, average='micro')\n",
    "print(\"SVC: \" + str(f1_svc))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6545454545454545\n",
      "SVC: 0.6486486486486487\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(f1s))\n",
    "c = 10 \n",
    "embedded_train = embeddings_train[0]\n",
    "embedded_test = embeddings_test[0]\n",
    "svc = SVC(C=c)\n",
    "svc_vanilla = svc.fit(embedded_train, y_working)\n",
    "labels_vanilla = svc_vanilla.predict(embedded_test)\n",
    "f1_svc = f1_score(y_held_out, labels_vanilla, average='micro')\n",
    "print(\"SVC: \" + str(f1_svc))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QSVC: 0.6351351351351351\n"
     ]
    }
   ],
   "source": [
    "service = QiskitRuntimeService(instance=\"ibm-q-ccf/cleveland-access/wl-protein\") \n",
    "backend = service.least_busy(simulator=False, operational=True) \n",
    "#backend = AerSimulator(method='statevector')\n",
    "algorithm_globals.random_seed = 12345\n",
    "feature_map = ZZFeatureMap(feature_dimension=num_feats, \n",
    "                                reps=3, \n",
    "                                entanglement='linear', \n",
    "                                insert_barriers=True)\n",
    "sampler = Sampler() \n",
    "fidelity = ComputeUncompute(sampler=sampler)\n",
    "Qkernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=feature_map)\n",
    "qsvc = SVC(kernel=Qkernel.evaluate, C=c)\n",
    "qsvc_model = qsvc.fit(embedded_train, y_working)\n",
    "labels_qsvc = qsvc_model.predict(embedded_test)\n",
    "f1_qsvc = f1_score(y_held_out, labels_qsvc, average='micro')\n",
    "\n",
    "print(\"QSVC: \" + str(f1_qsvc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VQC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_features = output_dim\n",
    "\n",
    "feature_map = ZZFeatureMap(feature_dimension=num_features, \n",
    "                        reps=3, \n",
    "                        entanglement='linear')\n",
    "#feature_map.decompose().draw(output=\"mpl\", style=\"clifford\", fold=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "ansatz = RealAmplitudes(num_qubits=output_dim, reps=3)\n",
    "#ansatz.decompose().draw(output=\"mpl\", style=\"clifford\", fold=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = COBYLA(maxiter=100)\n",
    "sampler = Sampler() \n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.display import clear_output\n",
    "\n",
    "objective_func_vals = []\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 6)\n",
    "\n",
    "\n",
    "def callback_graph(weights, obj_func_eval):\n",
    "    clear_output(wait=True)\n",
    "    objective_func_vals.append(obj_func_eval)\n",
    "    plt.title(\"Objective function value against iteration\")\n",
    "    plt.xlabel(\"Iteration\")\n",
    "    plt.ylabel(\"Objective function value\")\n",
    "    plt.plot(range(len(objective_func_vals)), objective_func_vals)\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training time: 808 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from qiskit_machine_learning.algorithms.classifiers import VQC\n",
    "\n",
    "sampler = Sampler(options={\"shots\": 5000})\n",
    "vqc = VQC(\n",
    "    sampler=sampler,\n",
    "    feature_map=feature_map,\n",
    "    ansatz=ansatz,\n",
    "    optimizer=optimizer,\n",
    "    callback=callback_graph,\n",
    ")\n",
    "\n",
    "# clear objective value history\n",
    "objective_func_vals = []\n",
    "\n",
    "start = time.time()\n",
    "vqc.fit(embedded_train, y_working)\n",
    "elapsed = time.time() - start\n",
    "\n",
    "print(f\"Training time: {round(elapsed)} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum VQC on the training dataset: 0.58\n",
      "Quantum VQC on the test dataset:     0.49\n"
     ]
    }
   ],
   "source": [
    "train_score_q4 = vqc.score(embedded_train, y_working)\n",
    "test_score_q4 = vqc.score(embedded_test, y_held_out)\n",
    "\n",
    "print(f\"Quantum VQC on the training dataset: {train_score_q4:.2f}\")\n",
    "print(f\"Quantum VQC on the test dataset:     {test_score_q4:.2f}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QNN (EstimatorQNN and SamplerQNN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from IPython.display import clear_output\n",
    "from qiskit import QuantumCircuit\n",
    "from qiskit.circuit import Parameter\n",
    "from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap\n",
    "from qiskit_algorithms.optimizers import COBYLA, L_BFGS_B\n",
    "from qiskit_algorithms.utils import algorithm_globals\n",
    "\n",
    "from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC\n",
    "from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN\n",
    "from qiskit_machine_learning.circuit.library import QNNCircuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1290.83x869.556 with 1 Axes>"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# construct QNN with the QNNCircuit's default ZZFeatureMap feature map and RealAmplitudes ansatz.\n",
    "qc_qnn = QNNCircuit(num_qubits=num_features)\n",
    "qc_qnn.draw(\"mpl\", style=\"clifford\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimator_qnn = EstimatorQNN(circuit=qc_qnn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.00631974]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# QNN maps inputs to [-1, +1]\n",
    "estimator_qnn.forward(embedded_train[0, :], algorithm_globals.random.random(estimator_qnn.num_weights))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# callback function that draws a live plot when the .fit() method is called\n",
    "def callback_graph(weights, obj_func_eval):\n",
    "    clear_output(wait=True)\n",
    "    objective_func_vals.append(obj_func_eval)\n",
    "    plt.title(\"Objective function value against iteration\")\n",
    "    plt.xlabel(\"Iteration\")\n",
    "    plt.ylabel(\"Objective function value\")\n",
    "    plt.plot(range(len(objective_func_vals)), objective_func_vals)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct neural network classifier\n",
    "estimator_classifier = NeuralNetworkClassifier(\n",
    "    estimator_qnn, optimizer=COBYLA(maxiter=100), callback=callback_graph\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create empty array for callback to store evaluations of the objective function\n",
    "objective_func_vals = []\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 6)\n",
    "\n",
    "# fit classifier to data\n",
    "estimator_classifier.fit(embedded_train, y_working)\n",
    "\n",
    "# return to default figsize\n",
    "plt.rcParams[\"figure.figsize\"] = (6, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum estimator QNN on the training dataset: 0.55\n",
      "Quantum estimator QNN on the test dataset:     0.49\n"
     ]
    }
   ],
   "source": [
    "train_score_q4 = estimator_classifier.score(embedded_train, y_working)\n",
    "test_score_q4 = estimator_classifier.score(embedded_test, y_held_out)\n",
    "\n",
    "print(f\"Quantum estimator QNN on the training dataset: {train_score_q4:.2f}\")\n",
    "print(f\"Quantum estimator QNN on the test dataset:     {test_score_q4:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1290.83x869.556 with 1 Axes>"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# construct a quantum circuit from the default ZZFeatureMap feature map and a customized RealAmplitudes ansatz\n",
    "qc_sampler = QNNCircuit(ansatz=RealAmplitudes(num_features, reps=1))\n",
    "qc_sampler.draw(\"mpl\", style=\"clifford\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parity maps bitstrings to 0 or 1\n",
    "def parity(x):\n",
    "    return \"{:b}\".format(x).count(\"1\") % 2\n",
    "\n",
    "\n",
    "output_shape = 2  # corresponds to the number of classes, possible outcomes of the (parity) mapping."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct QNN\n",
    "sampler_qnn = SamplerQNN(\n",
    "    circuit=qc_sampler,\n",
    "    interpret=parity,\n",
    "    output_shape=output_shape,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# construct classifier\n",
    "sampler_classifier = NeuralNetworkClassifier(\n",
    "    neural_network=sampler_qnn, optimizer=COBYLA(maxiter=100), callback=callback_graph\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create empty array for callback to store evaluations of the objective function\n",
    "objective_func_vals = []\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 6)\n",
    "\n",
    "# fit classifier to data\n",
    "sampler_classifier.fit(embedded_train, y_working)\n",
    "\n",
    "# return to default figsize\n",
    "plt.rcParams[\"figure.figsize\"] = (6, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Sampler QNN on the training dataset: 0.61\n",
      "Quantum Sampler QNN on the test dataset:     0.57\n"
     ]
    }
   ],
   "source": [
    "train_score_q4 = sampler_classifier.score(embedded_train, y_working)\n",
    "test_score_q4 = sampler_classifier.score(embedded_test, y_held_out)\n",
    "\n",
    "print(f\"Quantum Sampler QNN on the training dataset: {train_score_q4:.2f}\")\n",
    "print(f\"Quantum Sampler QNN on the test dataset:     {test_score_q4:.2f}\")"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}