JSTARS2021/quantum_classifiers/eurosat_classification/QCNN-RealAmplitudesCircuit.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 28688,
     "status": "ok",
     "timestamp": 1627890517544,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "uc2xlyNfycy6",
    "outputId": "c6fabb32-9622-479d-ec55-4b3bdcdefcb1"
   },
   "outputs": [],
   "source": [
    "!pip uninstall qiskit\n",
    "!pip install qiskit==0.23.0\n",
    "#!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src\n",
    "!pip install pylatexenc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import qiskit\n",
    "token = 'TOKEN'\n",
    "qiskit.IBMQ.save_account(token)\n",
    "account = qiskit.IBMQ.load_account()\n",
    "provider = qiskit.IBMQ.get_provider(hub='ibm-q')\n",
    "backend = provider.get_backend('ibmq_qasm_simulator')\n",
    "print(provider, backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 511,
     "status": "ok",
     "timestamp": 1627890536973,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "mXsPVL2Qyt4G",
    "outputId": "2a08975a-3887-4a83-909e-73e1f3ec9cd0"
   },
   "outputs": [],
   "source": [
    "from qiskit import execute\n",
    "from qiskit.circuit import Parameter,ControlledGate\n",
    "from qiskit import Aer\n",
    "import qiskit\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "import torch\n",
    "from torch.autograd import Function\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "  device = torch.device(\"cuda:0\")\n",
    "  print(\"Running on the GPU\")\n",
    "else:\n",
    "  device = torch.device(\"cpu\")\n",
    "  print(\"Running on the CPU\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1627890536974,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "GLM7EOjvzYNa"
   },
   "outputs": [],
   "source": [
    "#np.random.seed = 314\n",
    "\n",
    "NUM_QUBITS = 4\n",
    "NUM_SHOTS = 800 #3000\n",
    "SHIFT = np.pi/4\n",
    "LEARNING_RATE = 0.0002\n",
    "MOMENTUM = 0.5\n",
    "\n",
    "SIMULATOR = Aer.get_backend('ibmq_qasm_simulator')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1627890536975,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "EjFSm0lgzbW2",
    "outputId": "7d49be7c-ee30-4a64-c534-f05cece34e1e"
   },
   "outputs": [],
   "source": [
    "# create list of all possible outputs of quantum circuit (2**NUM_QUBITS possible)\n",
    "import itertools\n",
    "def create_QC_OUTPUTS():\n",
    "    measurements = list(itertools.product([0, 1], repeat=NUM_QUBITS))\n",
    "    return [''.join([str(bit) for bit in measurement]) for measurement in measurements]\n",
    "\n",
    "QC_OUTPUTS = create_QC_OUTPUTS()\n",
    "print(QC_OUTPUTS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5MjzswxFOf5A"
   },
   "source": [
    "# Circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 3,
     "status": "ok",
     "timestamp": 1627890537298,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "MKJrEyNCzdX_"
   },
   "outputs": [],
   "source": [
    "class QiskitCircuit():\n",
    "    \n",
    "    def __init__(self, n_qubits, backend, shots):\n",
    "        # --- Circuit definition ---\n",
    "        self.circuit = qiskit.QuantumCircuit(n_qubits)\n",
    "        self.n_qubits = n_qubits\n",
    "        self.thetas = {k : Parameter('Theta'+str(k))for k in range(2*self.n_qubits)}\n",
    "        \n",
    "        all_qubits = [i for i in range(n_qubits)]\n",
    "        self.circuit.h(all_qubits)\n",
    "        self.circuit.barrier()\n",
    "\n",
    "        #self.circuit.h(0)\n",
    "\n",
    "        for k in range(0, 4):\n",
    "          self.circuit.ry(self.thetas[k], k)\n",
    "\n",
    "        self.circuit.cx(1, 0)\n",
    "        self.circuit.cx(2, 0)\n",
    "        self.circuit.cx(3, 0)\n",
    "        self.circuit.cx(2, 1)\n",
    "        self.circuit.cx(3, 1)\n",
    "        self.circuit.cx(3, 2)\n",
    "\n",
    "        for k in range(0, 4):\n",
    "          self.circuit.ry(self.thetas[k+4], k)\n",
    "\n",
    "        self.circuit.measure_all()\n",
    "        # ---------------------------\n",
    "        \n",
    "        self.backend = backend\n",
    "        self.shots = shots\n",
    "        \n",
    "        \n",
    "    def N_qubit_expectation_Z(self,counts, shots, nr_qubits):\n",
    "        expects = np.zeros(len(QC_OUTPUTS))\n",
    "        for k in range(len(QC_OUTPUTS)):\n",
    "            key = QC_OUTPUTS[k]\n",
    "            perc = counts.get(key, 0)/shots\n",
    "            expects[k] = perc\n",
    "        return expects\n",
    "    \n",
    "    def run(self, i):\n",
    "        params = i\n",
    "        #print('params = {}'.format(len(params)))\n",
    "        backend = Aer.get_backend('qasm_simulator')\n",
    "    \n",
    "        job_sim = execute(self.circuit,\n",
    "                              self.backend,\n",
    "                              shots=self.shots,\n",
    "                              parameter_binds = [{self.thetas[k] : params[k].item() for k in range(2*NUM_QUBITS)}])\n",
    "#         \n",
    "        result_sim = job_sim.result()\n",
    "        counts = result_sim.get_counts(self.circuit)\n",
    "        return self.N_qubit_expectation_Z(counts, self.shots, NUM_QUBITS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 276
    },
    "executionInfo": {
     "elapsed": 521,
     "status": "ok",
     "timestamp": 1627890538180,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "Afi3vEahKBVU",
    "outputId": "41c2d312-8da0-4b67-9233-a0b27eeccd1e"
   },
   "outputs": [],
   "source": [
    "circuit = QiskitCircuit(NUM_QUBITS, SIMULATOR, NUM_SHOTS)\n",
    "#print('Expected value for rotation [pi/4]: {}'.format(circuit.run(torch.Tensor([np.pi/4]*NUM_QUBITS))))\n",
    "circuit.circuit.draw(output='mpl')#, filename='Figures/{}-qubit circuit ryN.jpg'.format(NUM_QUBITS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1627890538181,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "_zDbKVw5zhWo"
   },
   "outputs": [],
   "source": [
    "class TorchCircuit(Function):    \n",
    "\n",
    "    @staticmethod\n",
    "    def forward(ctx, i):\n",
    "        if not hasattr(ctx, 'QiskitCirc'):\n",
    "            ctx.QiskitCirc = QiskitCircuit(NUM_QUBITS, SIMULATOR, shots=NUM_SHOTS)\n",
    "            \n",
    "        exp_value = ctx.QiskitCirc.run(i)\n",
    "        \n",
    "        result = torch.tensor([exp_value])\n",
    "  \n",
    "        ctx.save_for_backward(result, i)\n",
    "        \n",
    "        return result\n",
    "    \n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        \n",
    "        forward_tensor, i = ctx.saved_tensors\n",
    "#         print('forward_tensor = {}'.format(forward_tensor))\n",
    "        input_numbers = i\n",
    "#         print('input_numbers = {}'.format(input_numbers))\n",
    "        gradients = torch.Tensor()\n",
    "        \n",
    "        for k in range(2*NUM_QUBITS):\n",
    "            shift_right = input_numbers.detach().clone()\n",
    "            shift_right[k] = shift_right[k] + SHIFT\n",
    "            shift_left = input_numbers.detach().clone()\n",
    "            shift_left[k] = shift_left[k] - SHIFT\n",
    "            \n",
    "#             print('shift_right = {}, shift_left = {}'.format(shift_right, shift_left))\n",
    "            \n",
    "            expectation_right = ctx.QiskitCirc.run(shift_right)\n",
    "            expectation_left  = ctx.QiskitCirc.run(shift_left)\n",
    "#             print('expectation_right = {}, \\nexpectation_left = {}'.format(expectation_right, expectation_left))\n",
    "            \n",
    "            gradient = torch.tensor([expectation_right]) - torch.tensor([expectation_left])\n",
    "            # rescale gradient\n",
    "#             gradient = gradient / torch.norm(gradient)\n",
    "#             print('gradient for k={}: {}'.format(k, gradient))\n",
    "            gradients = torch.cat((gradients, gradient.float()))\n",
    "            \n",
    "        result = torch.Tensor(gradients)\n",
    "#         print('gradients = {}'.format(result))\n",
    "#         print('grad_output = {}'.format(grad_output))\n",
    "\n",
    "        return (result.float() * grad_output.float()).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 7,
     "status": "ok",
     "timestamp": 1627890538182,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "cjTZRiru0eKr"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('/content/drive/MyDrive/QAI4EO/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 5,
     "status": "ok",
     "timestamp": 1627890538567,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "An1kDAd-0f1q"
   },
   "outputs": [],
   "source": [
    "from DatasetHandler import DatasetHandler\n",
    "dataset_root = '/content/drive/MyDrive/QAI4EO/datasets/EuroSAT/EuroSAT'\n",
    "handler = DatasetHandler(dataset_root)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 4,
     "status": "ok",
     "timestamp": 1627890538567,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "YcZfoXab0hDP",
    "outputId": "875341ec-981a-49a5-b212-32953987deed"
   },
   "outputs": [],
   "source": [
    "classes = []\n",
    "for i, c in enumerate(handler.classes):\n",
    "  cl = c.split('/')[-1]\n",
    "  classes.append(cl)\n",
    "classes.sort()\n",
    "classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 38690,
     "status": "ok",
     "timestamp": 1627890577527,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "tTMKedxr0tCP",
    "outputId": "93a1fcc1-3dc0-4de2-90bf-91f955f929ed"
   },
   "outputs": [],
   "source": [
    "imgs_path, imgs_label = handler.load_paths_labels(dataset_root, classes=classes)\n",
    "print('Dataset images:', len(imgs_path), 'Dataset labels:', len(imgs_label))\n",
    "print('Dataset sample ->', imgs_path[0], imgs_label[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "executionInfo": {
     "elapsed": 20,
     "status": "ok",
     "timestamp": 1627890577528,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "Ku3ztjPT0urb",
    "outputId": "5a2039f6-295f-4f45-e3d6-f2f32933686f"
   },
   "outputs": [],
   "source": [
    "train_imgs, train_labels, val_images, val_labels = handler.train_validation_split(imgs_path, imgs_label, split_factor=0.2)\n",
    "print('X_train shape:', train_imgs.shape, 'Y_train shape:', train_labels.shape)\n",
    "print('  X_val shape: ', val_images.shape, '  Y_val shape: ', val_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 13,
     "status": "ok",
     "timestamp": 1627890577529,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "InesYmyx0wgc"
   },
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(3, 16, kernel_size=3)\n",
    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3)\n",
    "        self.conv3 = nn.Conv2d(32, 64, kernel_size=3)\n",
    "\n",
    "        #self.conv2_drop = nn.Dropout2d()\n",
    "\n",
    "        self.fc1 = nn.Linear(2304, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 42)\n",
    "\n",
    "        self.fc4 = nn.Linear(2304, 2*NUM_QUBITS)\n",
    "        \n",
    "        self.qc = TorchCircuit.apply\n",
    "\n",
    "        self.fc5 = nn.Linear(16, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(F.max_pool2d(self.conv1(x), 2))\n",
    "        x = F.relu(F.max_pool2d(self.conv2(x), 2))\n",
    "        x = F.relu(F.max_pool2d(self.conv3(x), 2))\n",
    "\n",
    "        x = x.view(-1, 2304)\n",
    "        #x = F.relu(self.fc1(x))\n",
    "        #x = F.dropout(x, training=self.training)\n",
    "        #x = F.relu(self.fc2(x))\n",
    "\n",
    "        #x = F.relu(self.fc3(x))\n",
    "\n",
    "        x = self.fc4(x)\n",
    "        x = np.pi*torch.tanh(x)\n",
    "        \n",
    "        x = self.qc(x[0]) # QUANTUM LAYER\n",
    "        \n",
    "        x = F.relu(x)\n",
    "        #print('output of QC = {}'.format(x))\n",
    "        \n",
    "#         # softmax rather than sigmoid\n",
    "        x = self.fc5(x.float())\n",
    "        #print('output of Linear(1, 2): {}'.format(x))\n",
    "        x = F.softmax(x, 1)\n",
    "\n",
    "        #x = torch.sigmoid(x)\n",
    "        #x = torch.cat((x, 1-x), -1)\n",
    "        return x\n",
    "    \n",
    "    \n",
    "    def predict(self, x):\n",
    "        # apply softmax\n",
    "        pred = self.forward(x)\n",
    "#         print(pred)\n",
    "        ans = torch.argmax(pred[0]).item()\n",
    "        return torch.tensor(ans)\n",
    "    \n",
    "network = Net()#.to(device)\n",
    "optimizer = optim.Adam(network.parameters(), lr=0.0002)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 13,
     "status": "ok",
     "timestamp": 1627890577531,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "8oMzCmz11PVo"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report\n",
    "\n",
    "#from torchsummary import summary\n",
    "#summary(network, (3, 64, 64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 13,
     "status": "ok",
     "timestamp": 1627890577532,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "hxkBEGs401rE"
   },
   "outputs": [],
   "source": [
    "train_loader = iter(handler.qcnn_data_loader(train_imgs, train_labels, batch_size = 1, img_shape = (64,64,3)))\n",
    "test_loader = iter(handler.qcnn_data_loader(val_images, val_labels, batch_size = 1, img_shape = (64,64,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "executionInfo": {
     "elapsed": 1040,
     "status": "ok",
     "timestamp": 1627890578560,
     "user": {
      "displayName": "Alessandro Sebastianelli",
      "photoUrl": "https://lh3.googleusercontent.com/a-/AOh14GgVWBLvEG9yF5gq_rkIyj5MCLQv1OzgwlLWxu7e=s64",
      "userId": "16665723407518839496"
     },
     "user_tz": -120
    },
    "id": "IhLeUsW1_WpK"
   },
   "outputs": [],
   "source": [
    "checkpoint = torch.load('/content/drive/MyDrive/QAI4EO/model-real-amp-2.pt')\n",
    "network.load_state_dict(checkpoint['model_state_dict'])\n",
    "optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
    "epoch = checkpoint['epoch']\n",
    "loss = checkpoint['loss']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nUoZidbl05zA",
    "outputId": "71048057-182e-409a-c302-081664138279"
   },
   "outputs": [],
   "source": [
    "train_loss_list = []\n",
    "val_loss_list = []\n",
    "epochs = 25\n",
    "\n",
    "loss_func = nn.CrossEntropyLoss()\n",
    "\n",
    "for epoch in range(epochs):\n",
    "  train_loader = iter(handler.qcnn_data_loader(train_imgs, train_labels, batch_size = 1, img_shape = (64,64,3)))\n",
    "  test_loader = iter(handler.qcnn_data_loader(val_images, val_labels, batch_size = 1, img_shape = (64,64,3)))\n",
    "  total_loss = []\n",
    "  for batch_idx in range(len(train_labels)):\n",
    "    data, target = next(train_loader) \n",
    "    # print(batch_idx)\n",
    "    optimizer.zero_grad()        \n",
    "    # Forward pass\n",
    "    output = network(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",
    "    \n",
    "    print('\\r Epoch %d ~ Batch %d (%d) ~ Loss %f ' % (epoch, batch_idx, len(train_imgs)-1, loss.item()), end='\\t\\t')\n",
    "    \n",
    "  \n",
    "  with torch.no_grad():\n",
    "    val_loss = []\n",
    "    targets = []\n",
    "    predictions = []\n",
    "    for batch_idx in range(len(val_images)):\n",
    "      data, target = next(test_loader)\n",
    "      output = network(data)\n",
    "      loss = loss_func(output, target)\n",
    "      val_loss.append(loss.item())\n",
    "\n",
    "      targets.append(target.item())\n",
    "      \n",
    "      predictions.append(network.predict(data).item())\n",
    "  \n",
    "      \n",
    "  train_loss_list.append(sum(total_loss)/len(total_loss))\n",
    "  val_loss_list.append(sum(val_loss)/len(val_loss))\n",
    "  \n",
    "  print('Training [{:.0f}%]\\t Training Loss: {:.4f} Validation Loss: {:.4f}'.format(\n",
    "      100. * (epoch + 1) / epochs, train_loss_list[-1], val_loss_list[-1]))\n",
    "  \n",
    "  if epoch % 3 == 1:\n",
    "    print(confusion_matrix(targets, predictions,normalize='true'))\n",
    "    print(classification_report(targets, predictions, target_names=classes, digits=4))\n",
    "    torch.save({\n",
    "            'epoch': epoch,\n",
    "            'model_state_dict': network.state_dict(),\n",
    "            'optimizer_state_dict': optimizer.state_dict(),\n",
    "            'loss': train_loss_list[-1],\n",
    "            }, '/content/drive/MyDrive/QAI4EO/model-real-amp-2.pt')\n",
    "    #torch.save(network.state_dict(), '/content/drive/MyDrive/QAI4EO/model-bell.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tyaee9pf1fxF"
   },
   "outputs": [],
   "source": [
    "fig, plt.plot(train_loss_list)\n",
    "plt.plot(val_loss_list)\n",
    "plt.title('Hybrid NN Training Convergence for {}-qubit'.format(NUM_QUBITS))\n",
    "plt.xlabel('Training Iterations')\n",
    "plt.ylabel('Cross Entropy Loss')\n",
    "plt.legend(['Training', 'Validation'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1eRGMZkV1gPE"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import curve_fit\n",
    "\n",
    "def func(x, a, b, c):\n",
    "  return a * np.exp(-b * x) + c\n",
    "\n",
    "x = np.linspace(0,len(train_loss_list),len(train_loss_list))\n",
    "y = func(x, 2.5, 1.3, 0.5)\n",
    "yn = np.array(val_loss_list)\n",
    "\n",
    "popt, pcov = curve_fit(func, x, yn)\n",
    "\n",
    "plt.figure()\n",
    "x1 = np.linspace(0,100+len(train_loss_list),100+len(train_loss_list))\n",
    "plt.plot(x, yn, 'ko', label=\"Loss\")\n",
    "plt.plot(x1, func(x1, *popt), 'r-', label=\"Fitted Curve\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "owQ_-Zo51i0u"
   },
   "outputs": [],
   "source": [
    "test_loader = iter(handler.qcnn_data_loader(val_images, val_labels, batch_size = 1, img_shape = (64,64,3)))\n",
    "accuracy = 0\n",
    "number = 0\n",
    "\n",
    "predictions = []\n",
    "targets = []\n",
    "\n",
    "for ct in range(len(val_images)):\n",
    "\n",
    "  data, target = next(test_loader)\n",
    "  number +=1\n",
    "  output = network.predict(data).item()\n",
    "  \n",
    "  predictions.append(output)\n",
    "  targets.append(target.item())\n",
    "  \n",
    "  accuracy += (output == target[0].item())*1\n",
    "  print('\\r ' + str(ct), end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "GZSoIb5bAveU"
   },
   "outputs": [],
   "source": [
    "plt.hist(targets, bins = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "N6ohu74x1lAN"
   },
   "outputs": [],
   "source": [
    "print(\"Performance on test data is : {}/{} = {}%\".format(accuracy,number,100*accuracy/number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "N-m3Vutb1laV"
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report\n",
    "cm = confusion_matrix(targets, predictions,normalize='true')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3I16RB4l1mzk"
   },
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(nrows = 1, ncols = 1, figsize = (12,10))\n",
    "\n",
    "cmd = ConfusionMatrixDisplay(cm, display_labels=classes)\n",
    "cmd.plot(ax=axes, cmap='Blues', xticks_rotation='vertical')\n",
    "print('S2')\n",
    "print('Accuracy:', cm.diagonal(), 'mean: ', cm.diagonal().mean())\n",
    "print(classification_report(targets, predictions, target_names=classes, digits=4))\n",
    "axes.get_images()[0].set_clim(0, 1)\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mBJoclTMRqf2"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "QCNN-RealAmplitudesCircuit.ipynb",
   "provenance": []
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}