test_medmnist.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import medmnist\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim \n",
    "import torch.utils.data as data\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "from medmnist import INFO, Evaluator\n",
    "from tqdm import tqdm\n",
    "\n",
    "from qiskit.circuit import QuantumCircuit, Parameter\n",
    "from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap\n",
    "from qiskit.utils import QuantumInstance, algorithm_globals\n",
    "from qiskit.opflow import AerPauliExpectation\n",
    "from qiskit_aer import Aer\n",
    "from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN\n",
    "from qiskit_machine_learning.connectors import TorchConnector\n",
    "\n",
    "from qpie import QPIE\n",
    "from neqr import NEQR\n",
    "\n",
    "from skimage.transform import resize\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "flags = [\"pathmnist\", \n",
    "         \"octmnist\", \n",
    "         \"pneumoniamnist\",\n",
    "         \"chestmnist\",\n",
    "         \"dermamnist\",\n",
    "         \"retinamnist\",\n",
    "         \"breastmnist\",\n",
    "         \"bloodmnist\",\n",
    "         \"tissuemnist\",\n",
    "         \"organcmnist\",\n",
    "         \"organsmnist\",\n",
    "         \"organmnist3d\",\n",
    "         \"nodulemnist3d\",\n",
    "         \"adrenalmnist3d\",\n",
    "         \"fracturemnist3d\",\n",
    "         \"vesselmnist3d\",\n",
    "         \"synapsemnist3d\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_EPOCHS = 3\n",
    "BATCH_SIZE = 128\n",
    "lr = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_flag = flags[2]\n",
    "info = INFO[data_flag]\n",
    "task = info[\"task\"]\n",
    "n_channel = info[\"n_channels\"]\n",
    "n_classes = len(info[\"label\"])\n",
    "\n",
    "DataClass = getattr(medmnist, info[\"python_class\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                     transforms.Normalize(mean=[.5], std=[.5])])\n",
    "\n",
    "train_dataset = DataClass(split='train', transform=data_transform)\n",
    "test_dataset = DataClass(split='test', transform=data_transform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4708"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_dataset.imgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4708, 28, 28)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset.imgs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_dataset.imgs[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(train_dataset.imgs[0], cmap=\"gray\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "train_loader_at_eval = data.DataLoader(dataset=train_dataset, batch_size=2*BATCH_SIZE, shuffle=True)\n",
    "test_loader = data.DataLoader(dataset=test_dataset, batch_size=2*BATCH_SIZE, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    \n",
    "    def __init__(self, in_channels, num_classes) -> None:\n",
    "        super(Net, self).__init__()\n",
    "        \n",
    "        self.layer1 = nn.Sequential(nn.Conv2d(in_channels=in_channels, out_channels=16, kernel_size=3),\n",
    "                                    nn.BatchNorm2d(16),\n",
    "                                    nn.ReLU())\n",
    "        \n",
    "        self.layer2 = nn.Sequential(nn.Conv2d(in_channels=16, out_channels=16, kernel_size=3),\n",
    "                                    nn.BatchNorm2d(16),\n",
    "                                    nn.ReLU(),\n",
    "                                    nn.MaxPool2d(kernel_size=2, stride=2))\n",
    "        \n",
    "        self.layer3 = nn.Sequential(nn.Conv2d(in_channels=16, out_channels=64, kernel_size=3),\n",
    "                                    nn.BatchNorm2d(64),\n",
    "                                    nn.ReLU())\n",
    "        \n",
    "        self.layer4 = nn.Sequential(nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3),\n",
    "                                    nn.BatchNorm2d(64),\n",
    "                                    nn.ReLU())\n",
    "        \n",
    "        self.layer5 = nn.Sequential(nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=1),\n",
    "                                    nn.BatchNorm2d(64),\n",
    "                                    nn.ReLU(),\n",
    "                                    nn.MaxPool2d(kernel_size=2, stride=2))\n",
    "        \n",
    "        self.fc = nn.Sequential(nn.Linear(64 * 4 * 4, 128),\n",
    "                                nn.ReLU(),\n",
    "                                nn.Linear(128, 128),\n",
    "                                nn.ReLU(),\n",
    "                                nn.Linear(128, num_classes))\n",
    "        \n",
    "    def forward(self, x):\n",
    "            \n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "        x = self.layer5(x)\n",
    "        x = x.view(x.size(0), -1)\n",
    "        x = self.fc(x)\n",
    "            \n",
    "        return x    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Net(in_channels=n_channel, num_classes=n_classes)\n",
    "\n",
    "if task == \"multi-label, binary-class\":\n",
    "    criterion = nn.BCEWithLogitsLoss()\n",
    "else:\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "optimizer = optim.Adam(model.parameters(), lr=lr)\n",
    "# optimizer = optim.LBFGS(model.parameters(), lr=lr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 37/37 [00:03<00:00, 11.42it/s]\n",
      "100%|██████████| 37/37 [00:03<00:00, 11.37it/s]\n",
      "100%|██████████| 37/37 [00:03<00:00, 11.53it/s]\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(NUM_EPOCHS):\n",
    "    train_correct = 0\n",
    "    train_total = 0\n",
    "    test_correct = 0\n",
    "    test_total = 0\n",
    "    \n",
    "    model.train()\n",
    "    for inputs, targets in tqdm(train_loader):\n",
    "        # forward + backward + optimize\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        \n",
    "        if task == 'multi-label, binary-class':\n",
    "            targets = targets.to(torch.float32)\n",
    "            loss = criterion(outputs, targets)\n",
    "        else:\n",
    "            targets = targets.squeeze().long()\n",
    "            loss = criterion(outputs, targets)\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(split):\n",
    "    model.eval()\n",
    "    y_true = torch.tensor([])\n",
    "    y_score = torch.tensor([])\n",
    "    \n",
    "    data_loader = train_loader_at_eval if split == 'train' else test_loader\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for inputs, targets in data_loader:\n",
    "            outputs = model(inputs)\n",
    "\n",
    "            if task == 'multi-label, binary-class':\n",
    "                targets = targets.to(torch.float32)\n",
    "                outputs = outputs.softmax(dim=-1)\n",
    "            else:\n",
    "                targets = targets.squeeze().long()\n",
    "                outputs = outputs.softmax(dim=-1)\n",
    "                targets = targets.float().resize_(len(targets), 1)\n",
    "\n",
    "            y_true = torch.cat((y_true, targets), 0)\n",
    "            y_score = torch.cat((y_score, outputs), 0)\n",
    "\n",
    "        y_true = y_true.numpy()\n",
    "        y_score = y_score.detach().numpy()\n",
    "        \n",
    "        evaluator = Evaluator(data_flag, split)\n",
    "        metrics = evaluator.evaluate(y_score)\n",
    "    \n",
    "        print('%s  auc: %.3f  acc:%.3f' % (split, *metrics))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> Evaluating ...\n",
      "train  auc: 0.509  acc:0.600\n",
      "test  auc: 0.965  acc:0.912\n"
     ]
    }
   ],
   "source": [
    "print('==> Evaluating ...')\n",
    "test('train')\n",
    "test('test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "algorithm_globals.random_seed = 42\n",
    "qi = QuantumInstance(backend=Aer.get_backend(\"statevector_simulator\"))\n",
    "# device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_qnn():\n",
    "    feature_map = ZZFeatureMap(2)\n",
    "    ansatz = RealAmplitudes(2, reps=1)\n",
    "    qnn = TwoLayerQNN(2, \n",
    "                      feature_map=feature_map,\n",
    "                      ansatz=ansatz,\n",
    "                      input_gradients=True,\n",
    "                      exp_val=AerPauliExpectation(),\n",
    "                      quantum_instance=qi)\n",
    "    return qnn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import cat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HybridNet(nn.Module):\n",
    "    \n",
    "    def __init__(self, qnn):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 2, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(2, 16, kernel_size=5)\n",
    "        self.dropout = nn.Dropout2d()\n",
    "        self.fc1 = nn.Linear(256, 64)\n",
    "        self.fc2 = nn.Linear(64, 2)  # 2-dimensional input to QNN\n",
    "        self.qnn = TorchConnector(qnn)  # Apply torch connector, weights chosen\n",
    "        # uniformly at random from interval [-1,1].\n",
    "        self.fc3 = nn.Linear(1, 1)  # 1-dimensional output from QNN\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(x.shape[0], -1)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        x = self.qnn(x)  # apply QNN\n",
    "        x = self.fc3(x)\n",
    "        return cat((x, 1 - x), -1)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "qnn = create_qnn()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "model4 = HybridNet(qnn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_transform = transforms.Compose([transforms.ToTensor()])\n",
    "\n",
    "train_dataset = DataClass(split='train', transform=data_transform)\n",
    "test_dataset = DataClass(split='test', transform=data_transform)\n",
    "\n",
    "train_loader = data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "train_loader_at_eval = data.DataLoader(dataset=train_dataset, batch_size=2*BATCH_SIZE, shuffle=True)\n",
    "test_loader = data.DataLoader(dataset=test_dataset, batch_size=2*BATCH_SIZE, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "if task == \"multi-label, binary-class\":\n",
    "    criterion = nn.BCEWithLogitsLoss()\n",
    "else:\n",
    "    criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 37/37 [17:51<00:00, 28.95s/it]\n",
      "100%|██████████| 37/37 [17:14<00:00, 27.95s/it]\n",
      "100%|██████████| 37/37 [16:47<00:00, 27.22s/it]\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(NUM_EPOCHS):\n",
    "    train_correct = 0\n",
    "    train_total = 0\n",
    "    test_correct = 0\n",
    "    test_total = 0\n",
    "    \n",
    "    model4.train()\n",
    "    for inputs, targets in tqdm(train_loader):\n",
    "        # forward + backward + optimize\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model4(inputs)\n",
    "        \n",
    "        if task == 'multi-label, binary-class':\n",
    "            targets = targets.to(torch.float32)\n",
    "            loss = criterion(outputs, targets)\n",
    "        else:\n",
    "            targets = targets.squeeze().long()\n",
    "            loss = criterion(outputs, targets)\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(split):\n",
    "    model4.eval()\n",
    "    y_true = torch.tensor([])\n",
    "    y_score = torch.tensor([])\n",
    "    \n",
    "    data_loader = train_loader_at_eval if split == 'train' else test_loader\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for inputs, targets in data_loader:\n",
    "            outputs = model4(inputs)\n",
    "\n",
    "            if task == 'multi-label, binary-class':\n",
    "                targets = targets.to(torch.float32)\n",
    "                outputs = outputs.softmax(dim=-1)\n",
    "            else:\n",
    "                targets = targets.squeeze().long()\n",
    "                outputs = outputs.softmax(dim=-1)\n",
    "                targets = targets.float().resize_(len(targets), 1)\n",
    "\n",
    "            y_true = torch.cat((y_true, targets), 0)\n",
    "            y_score = torch.cat((y_score, outputs), 0)\n",
    "\n",
    "        y_true = y_true.numpy()\n",
    "        y_score = y_score.detach().numpy()\n",
    "        \n",
    "        evaluator = Evaluator(data_flag, split)\n",
    "        metrics = evaluator.evaluate(y_score)\n",
    "    \n",
    "        print('%s  auc: %.3f  acc: %.3f' % (split, *metrics))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "==> Evaluating ...\n",
      "train  auc: 0.488  acc:0.742\n",
      "test  auc: 0.895  acc:0.625\n"
     ]
    }
   ],
   "source": [
    "print('==> Evaluating ...')\n",
    "test('train')\n",
    "test('test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.10 ('env': venv)",
   "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.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "80a69d6ce830a09ed870da0a1d33f00078d677b0e1f72c1f32f3bfa7a0aa7bc6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}