PART2_CLASSIFICATION.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: OMP_NUM_THREADS=1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.python/current/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ['KMP_DUPLICATE_LIB_OK']='True'\n",
    "# OpenMP: number of parallel threads.\n",
    "%env OMP_NUM_THREADS=1\n",
    "\n",
    "# Plotting\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# PyTorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "\n",
    "# Pennylane\n",
    "import pennylane as qml\n",
    "from pennylane import numpy as np\n",
    "\n",
    "# Other tools\n",
    "import time\n",
    "import os\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_qubits = 4                     # Number of qubits\n",
    "quantum = True                   # If set to \"False\", the dressed quantum circuit is replaced by \n",
    "                                 # An enterily classical net (defined by the next parameter). \n",
    "classical_model = '512_nq_2'     # Possible choices: '512_2','512_nq_2','551_512_2'. \n",
    "step = 0.0004                    # Learning rate\n",
    "batch_size = 4                   # Number of samples for each training step\n",
    "num_epochs = 30                  # Number of training epochs\n",
    "q_depth = 6                      # Depth of the quantum circuit (number of variational layers)\n",
    "gamma_lr_scheduler = 0.1         # Learning rate reduction applied every 10 epochs.                       \n",
    "max_layers = 15                  # Keep 15 even if not all are used.\n",
    "q_delta = 0.01                   # Initial spread of random quantum weights\n",
    "rng_seed = 0                     # Seed for random number generator\n",
    "start_time = time.time()         # Start of the computation timer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev = qml.device('default.qubit', wires=n_qubits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_transforms = {\n",
    "    'train': transforms.Compose([\n",
    "        #transforms.RandomResizedCrop(224),     # uncomment for data augmentation\n",
    "        #transforms.RandomHorizontalFlip(),     # uncomment for data augmentation\n",
    "        transforms.Resize(28),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        # Normalize input channels using mean values and standard deviations of ImageNet.\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "    'val': transforms.Compose([\n",
    "        transforms.Resize(28),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the actual hackthon data (fashion-mnist)\n",
    "images=np.load('/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/images.npy')\n",
    "labels=np.load('/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/labels.npy')\n",
    "\n",
    "dataset_list = []\n",
    "\n",
    "for i in range(len(images)):\n",
    "    dataset_test = {'image':images[i].tolist(),'category': labels[i].tolist()}\n",
    "    dataset_list.append(dataset_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "\n",
    "image_array = np.load(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/images.npy\")\n",
    "label_array = np.load(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/labels.npy\")\n",
    "\n",
    "for i in range(image_array.shape[0]):\n",
    "    image = image_array[i]\n",
    "    label = label_array[i]\n",
    "    \n",
    "    folder_name = \"True\" if label else \"False\"\n",
    "    folder_path = os.path.join(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data\", folder_name)\n",
    "    \n",
    "    if not os.path.exists(folder_path):\n",
    "        os.makedirs(folder_path)\n",
    "        \n",
    "    file_path = os.path.join(folder_path, f\"image_{i}.png\")\n",
    "    plt.imsave(file_path, image, cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load images and labels\n",
    "images = np.load(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/images.npy\")\n",
    "labels = np.load(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/labels.npy\")\n",
    "\n",
    "# Calculate number of images in each dataset\n",
    "num_images = len(images)\n",
    "num_train = int(0.8 * num_images)\n",
    "num_val = num_images - num_train\n",
    "\n",
    "# Split images and labels into train and val datasets\n",
    "train_images = images[:num_train]\n",
    "val_images = images[num_train:]\n",
    "train_labels = labels[:num_train]\n",
    "val_labels = labels[num_train:]\n",
    "\n",
    "# Make directories for train and val datasets\n",
    "os.makedirs(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/train\", exist_ok=True)\n",
    "os.makedirs(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/val\", exist_ok=True)\n",
    "\n",
    "# Make directories for True and False labels in train and val datasets\n",
    "os.makedirs(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/train/True\", exist_ok=True)\n",
    "os.makedirs(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/train/False\", exist_ok=True)\n",
    "os.makedirs(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/val/True\", exist_ok=True)\n",
    "os.makedirs(\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/val/False\", exist_ok=True)\n",
    "\n",
    "# Save train images to corresponding True/False directories\n",
    "for i, (image, label) in enumerate(zip(train_images, train_labels)):\n",
    "    plt.imsave(f\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/train/{label}/{i}.png\", image, cmap='gray')\n",
    "\n",
    "# Save val images to corresponding True/False directories\n",
    "for i, (image, label) in enumerate(zip(val_images, val_labels)):\n",
    "    plt.imsave(f\"/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/data/val/{label}/{i}.png\", image, cmap='gray')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_transforms = {\n",
    "    'train': transforms.Compose([\n",
    "        #transforms.RandomResizedCrop(224),     # uncomment for data augmentation\n",
    "        #transforms.RandomHorizontalFlip(),     # uncomment for data augmentation\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        # Normalize input channels using mean values and standard deviations of ImageNet.\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "    'val': transforms.Compose([\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ]),\n",
    "}\n",
    "\n",
    "data_dir = '/workspaces/2023_IonQ_Remote/.ipynb_checkpoints/Class_Data'\n",
    "image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),\n",
    "                     data_transforms[x]) for x in ['train', 'val']}\n",
    "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}\n",
    "class_names = image_datasets['train'].classes\n",
    "\n",
    "# Initialize dataloader\n",
    "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], \n",
    "                  batch_size=batch_size, shuffle=True) for x in ['train', 'val']}\n",
    "\n",
    "# function to plot images\n",
    "def imshow(inp, title=None):\n",
    "    \"\"\"Display image from tensor.\"\"\"\n",
    "    inp = inp.numpy().transpose((1, 2, 0))\n",
    "    # We apply the inverse of the initial normalization operation.\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    inp = std * inp + mean  \n",
    "    inp = np.clip(inp, 0, 1)\n",
    "    plt.imshow(inp)\n",
    "    if title is not None:\n",
    "        plt.title(title)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get a batch of training data\n",
    "inputs, classes = next(iter(dataloaders['val']))\n",
    "# Make a grid from batch\n",
    "out = torchvision.utils.make_grid(inputs)\n",
    "from skimage.io import imread, imsave\n",
    "import skimage\n",
    "\n",
    "imshow(out, title=[class_names[x] for x in classes])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(rng_seed)\n",
    "dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], \n",
    "                  batch_size=batch_size,shuffle=True) for x in ['train', 'val']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def H_layer(nqubits):\n",
    "    \"\"\"Layer of single-qubit Hadamard gates. \n",
    "    \"\"\"\n",
    "    for idx in range(nqubits):\n",
    "        qml.Hadamard(wires=idx)\n",
    "        \n",
    "def RY_layer(w):\n",
    "    \"\"\"Layer of parametrized qubit rotations around the y axis. \n",
    "    \"\"\"\n",
    "    for idx, element in enumerate(w):\n",
    "        qml.RY(element, wires=idx)\n",
    "\n",
    "def entangling_layer(nqubits):\n",
    "    \"\"\"Layer of CNOTs followed by another shifted layer of CNOT.\n",
    "    \"\"\"\n",
    "    # In other words it should apply something like :\n",
    "    #CNOT  CNOT  CNOT  CNOT...  CNOT\n",
    "    #   CNOT  CNOT  CNOT...  CNOT  \n",
    "    for i in range(0, nqubits - 1, 2): #loop over even indices: i=0,2,...N-2  \n",
    "        qml.CNOT(wires=[i, i + 1])\n",
    "    for i in range(1, nqubits - 1, 2): #loop over odd indices:  i=1,3,...N-3\n",
    "        qml.CNOT(wires=[i, i + 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "@qml.qnode(dev, interface='torch')\n",
    "def q_net(q_in, q_weights_flat):\n",
    "        \n",
    "        # Reshape weights\n",
    "        q_weights = q_weights_flat.reshape(max_layers, n_qubits)\n",
    "        \n",
    "        # Start from state |+> , unbiased w.r.t. |0> and |1>\n",
    "        H_layer(n_qubits)   \n",
    "        \n",
    "        # Embed features in the quantum node\n",
    "        RY_layer(q_in)      \n",
    "       \n",
    "        # Sequence of trainable variational layers\n",
    "        for k in range(q_depth):\n",
    "            entangling_layer(n_qubits)\n",
    "            RY_layer(q_weights[k + 1])\n",
    "\n",
    "        # Expectation values in the Z basis\n",
    "        return [qml.expval(qml.PauliZ(j)) for j in range(n_qubits)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Quantumnet(nn.Module):\n",
    "        def __init__(self):\n",
    "            super().__init__()\n",
    "            self.pre_net = nn.Linear(512, n_qubits)\n",
    "            self.q_params = nn.Parameter(q_delta * torch.randn(max_layers * n_qubits))\n",
    "            self.post_net = nn.Linear(n_qubits, 2)\n",
    "\n",
    "        def forward(self, input_features):\n",
    "            pre_out = self.pre_net(input_features) \n",
    "            q_in = torch.tanh(pre_out) * np.pi / 2.0   \n",
    "            \n",
    "            # Apply the quantum circuit to each element of the batch and append to q_out\n",
    "            q_out = torch.Tensor(0, n_qubits)\n",
    "            q_out = q_out.to(device)\n",
    "            for elem in q_in:\n",
    "                q_out_elem = q_net(elem,self.q_params).float().unsqueeze(0)\n",
    "                q_out = torch.cat((q_out, q_out_elem))\n",
    "            return self.post_net(q_out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def H_layer(nqubits):\n",
    "    \"\"\"Layer of single-qubit Hadamard gates. \n",
    "    \"\"\"\n",
    "    for idx in range(nqubits):\n",
    "        qml.Hadamard(wires=idx)\n",
    "        \n",
    "def RY_layer(w):\n",
    "    \"\"\"Layer of parametrized qubit rotations around the y axis. \n",
    "    \"\"\"\n",
    "    for idx, element in enumerate(w):\n",
    "        qml.RY(element, wires=idx)\n",
    "\n",
    "def entangling_layer(nqubits):\n",
    "    \"\"\"Layer of CNOTs followed by another shifted layer of CNOT.\n",
    "    \"\"\"\n",
    "    # In other words it should apply something like :\n",
    "    #CNOT  CNOT  CNOT  CNOT...  CNOT\n",
    "    #   CNOT  CNOT  CNOT...  CNOT  \n",
    "    for i in range(0, nqubits - 1, 2): #loop over even indices: i=0,2,...N-2  \n",
    "        qml.CNOT(wires=[i, i + 1])\n",
    "    for i in range(1, nqubits - 1, 2): #loop over odd indices:  i=1,3,...N-3\n",
    "        qml.CNOT(wires=[i, i + 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_hybrid = torchvision.models.resnet18(pretrained=True)\n",
    "\n",
    "for param in model_hybrid.parameters():\n",
    "    param.requires_grad = False\n",
    "    \n",
    "if quantum:\n",
    "    model_hybrid.fc = Quantumnet()\n",
    "    \n",
    "elif classical_model == '512_2':\n",
    "    model_hybrid.fc = nn.Linear(512, 2)\n",
    "    \n",
    "elif classical_model == '512_nq_2':\n",
    "    model_hybrid.fc = nn.Sequential(nn.Linear(512, n_qubits), torch.nn.ReLU(), nn.Linear(n_qubits, 2)) \n",
    "\n",
    "elif classical_model == '551_512_2':\n",
    "    model_hybrid.fc = nn.Sequential(nn.Linear(512, 512), torch.nn.ReLU(), nn.Linear(512, 2))\n",
    "\n",
    "# Use CUDA or CPU according to the \"device\" object.\n",
    "model_hybrid = model_hybrid.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer_hybrid = optim.Adam(model_hybrid.fc.parameters(), lr=step)\n",
    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_hybrid, step_size=10, gamma=gamma_lr_scheduler)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, criterion, optimizer, scheduler, num_epochs):\n",
    "        since = time.time()\n",
    "        best_model_wts = copy.deepcopy(model.state_dict())\n",
    "        best_acc = 0.0\n",
    "        best_loss = 10000.0   # Large arbitrary number\n",
    "        best_acc_train = 0.0\n",
    "        best_loss_train = 10000.0  # Large arbitrary number\n",
    "        print('Training started:')\n",
    "        \n",
    "        for epoch in range(num_epochs):    \n",
    "            \n",
    "            # Each epoch has a training and validation phase\n",
    "            for phase in ['train', 'val']:\n",
    "                if phase == 'train':\n",
    "                    scheduler.step()\n",
    "                    # Set model to training mode\n",
    "                    model.train()  \n",
    "                else:\n",
    "                    # Set model to evaluate mode\n",
    "                    model.eval()\n",
    "                running_loss = 0.0\n",
    "                running_corrects = 0\n",
    "                \n",
    "                # Iterate over data.\n",
    "                n_batches = dataset_sizes[phase] // batch_size\n",
    "                it = 0\n",
    "                for inputs, labels in dataloaders[phase]:\n",
    "                    since_batch = time.time()\n",
    "                    batch_size_ = len(inputs)\n",
    "                    inputs = inputs.to(device)\n",
    "                    labels = labels.to(device)\n",
    "                    optimizer.zero_grad()\n",
    "                    \n",
    "                    # Track/compute gradient and make an optimization step only when training\n",
    "                    with torch.set_grad_enabled(phase == 'train'):\n",
    "                        outputs = model(inputs)\n",
    "                        _, preds = torch.max(outputs, 1)\n",
    "                        loss = criterion(outputs, labels)\n",
    "                        if phase == 'train':\n",
    "                            loss.backward()\n",
    "                            optimizer.step()\n",
    "                    \n",
    "                    # Print iteration results\n",
    "                    running_loss += loss.item() * batch_size_\n",
    "                    batch_corrects = torch.sum(preds == labels.data).item()\n",
    "                    running_corrects += batch_corrects\n",
    "                    print('Phase: {} Epoch: {}/{} Iter: {}/{} Batch time: {:.4f}'.format(phase, epoch + 1, num_epochs, it + 1, n_batches + 1, time.time() - since_batch), end='\\r', flush=True)\n",
    "                    it += 1\n",
    "                \n",
    "                # Print epoch results\n",
    "                epoch_loss = running_loss / dataset_sizes[phase]\n",
    "                epoch_acc = running_corrects / dataset_sizes[phase]\n",
    "                print('Phase: {} Epoch: {}/{} Loss: {:.4f} Acc: {:.4f}        '.format('train' if phase == 'train' else 'val  ', epoch + 1, num_epochs, epoch_loss, epoch_acc))\n",
    "                \n",
    "                # Check if this is the best model wrt previous epochs\n",
    "                if phase == 'val' and epoch_acc > best_acc:\n",
    "                    best_acc = epoch_acc\n",
    "                    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "                if phase == 'val' and epoch_loss < best_loss:\n",
    "                    best_loss = epoch_loss\n",
    "                if phase == 'train' and epoch_acc > best_acc_train:\n",
    "                    best_acc_train = epoch_acc\n",
    "                if phase == 'train' and epoch_loss < best_loss_train:\n",
    "                    best_loss_train = epoch_loss\n",
    "        \n",
    "        # Print final results           \n",
    "        model.load_state_dict(best_model_wts)\n",
    "        time_elapsed = time.time() - since\n",
    "        print('Training completed in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))\n",
    "        print('Best test loss: {:.4f} | Best test accuracy: {:.4f}'.format(best_loss, best_acc))\n",
    "        return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started:\n",
      "Phase: train Epoch: 1/2 Loss: 0.3217 Acc: 0.8785        \n",
      "Phase: val   Epoch: 1/2 Loss: 0.2322 Acc: 0.9270        \n",
      "Phase: train Epoch: 2/2 Loss: 0.3161 Acc: 0.8750        \n",
      "Phase: val   Epoch: 2/2 Loss: 0.2132 Acc: 0.9300        \n",
      "Training completed in 10m 41s\n",
      "Best test loss: 0.2132 | Best test accuracy: 0.9300\n"
     ]
    }
   ],
   "source": [
    "model_hybrid = train_model(model_hybrid, criterion, optimizer_hybrid,exp_lr_scheduler, num_epochs=2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9079348075227761\n"
     ]
    }
   ],
   "source": [
    "# Accuracy from the model\n",
    "#score in part 2\n",
    "\n",
    "score= 0.93\n",
    "\n",
    "# four qubits 6 layers\n",
    "gatecount= 24\n",
    "\n",
    "print(score*(0.999**gatecount))"
   ]
  }
 ],
 "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.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3ad933181bd8a04b432d3370b9dc3b0662ad032c4dfaa4e4f1596c548f763858"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}