MNIST-classification_digit_3_6_classification_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "import tensorflow as tf\n",
    "import sklearn.datasets\n",
    "from sklearn.datasets import fetch_openml\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "tf.keras.backend.set_floatx('float64')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load and reduce the data\n",
    "\n",
    "Load the MNIST data and check number of training and test examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of original training examples: 60000\n",
      "Number of original test examples: 10000\n"
     ]
    }
   ],
   "source": [
    "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()\n",
    "\n",
    "# Rescale the images from [0,255] to the [0.0,1.0] range.\n",
    "x_train, x_test = x_train[..., np.newaxis]/255.0, x_test[..., np.newaxis]/255.0  # add colour dimension\n",
    "\n",
    "print(\"Number of original training examples:\", len(x_train))\n",
    "print(\"Number of original test examples:\", len(x_test))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a function to filter out only 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter_01(x, y):\n",
    "    keep = (y == 3) | (y == 6)\n",
    "    x, y = x[keep], y[keep]\n",
    "    y = y == 3\n",
    "    return x,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of filtered training examples: 12049\n",
      "Number of filtered test examples: 1968\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True     6131\n",
       "False    5918\n",
       "dtype: int64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train, y_train = filter_01(x_train, y_train)\n",
    "x_test, y_test = filter_01(x_test, y_test)\n",
    "\n",
    "print(\"Number of filtered training examples:\", len(x_train))\n",
    "print(\"Number of filtered test examples:\", len(x_test))\n",
    "pd.Series(y_train).value_counts()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the original images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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(x_train[0, :, :, 0], cmap='Greys')\n",
    "ax = plt.gca()\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "plt.title(\"28x28 image of a 0\", fontsize=20)\n",
    "# save to file as pdf\n",
    "plt.savefig('28x28_MNIST_0.pdf', bbox_inches='tight', pad_inches=0)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce images to 9x9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train_small = tf.image.resize(x_train, (9,9)).numpy()\n",
    "x_test_small = tf.image.resize(x_test, (9,9)).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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(x_train_small[0,:,:,0], vmin=0, vmax=1, cmap='Greys')\n",
    "ax = plt.gca()\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "plt.title(\"9x9 image of a 0\", fontsize=20)\n",
    "# save to file as pdf\n",
    "plt.savefig('9x9_MNIST_0.pdf', bbox_inches='tight', pad_inches=0)\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Further reduce images to 9x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12049, 9)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_train_small = x_train_small[:,4,:,:].reshape((-1,9))  # take only central slices\n",
    "x_test_small = x_test_small[:,4,:,:].reshape((-1,9))  # take only central slices\n",
    "print(x_train_small.shape)\n",
    "plt.imshow(x_train_small[0,:].reshape((1,-1)), vmin=0, vmax=1, cmap='Greys')\n",
    "ax = plt.gca()\n",
    "ax.set_xticks([])\n",
    "ax.set_yticks([])\n",
    "plt.title(\"9x1 image of a 0\", fontsize=20)\n",
    "# save to file as pdf\n",
    "plt.savefig('9x1_MNIST_0.pdf', bbox_inches='tight', pad_inches=0)\n",
    "plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up the Quantum Neural Network\n",
    "\n",
    "Create quantum circuit using pennylane qnode, then conver this to a Keras layer to make a Keras model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 426ms/step\n",
      "Model: \"QNN\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " inputs (InputLayer)         [(None, 9)]               0         \n",
      "                                                                 \n",
      " quantumLayer (KerasLayer)   (None, 1)                 51        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 51\n",
      "Trainable params: 51\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "n_qubits = 9\n",
    "n_layers = 1\n",
    "dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "\n",
    "@qml.qnode(dev, diff_method=\"adjoint\")\n",
    "def qnode(inputs, weights):\n",
    "\n",
    "    for ii in range(n_qubits):\n",
    "        qml.RY(np.pi * inputs[ii], wires=ii)\n",
    "\n",
    "    for jj in range(n_layers):\n",
    "        for ii in range(n_qubits-1):\n",
    "            qml.RZ(weights[jj,2*ii,0], wires=0)\n",
    "            qml.RY(weights[jj,2*ii,1], wires=0)\n",
    "            qml.RZ(weights[jj,2*ii,2], wires=0)\n",
    "\n",
    "            qml.RZ(weights[jj,2*ii+1,0], wires=ii+1)\n",
    "            qml.RY(weights[jj,2*ii+1,1], wires=ii+1)\n",
    "            qml.RZ(weights[jj,2*ii+1,2], wires=ii+1)\n",
    "\n",
    "            #qml.U3(*list(weights[jj,2*ii,:]), wires=0)\n",
    "            #qml.U3(*list(weights[jj,2*ii+1,:]), wires=ii+1)\n",
    "            qml.CNOT(wires=[ii+1,0])\n",
    "            \n",
    "        qml.RZ(weights[jj,2*(n_qubits-1),0], wires=0)\n",
    "        qml.RY(weights[jj,2*(n_qubits-1),1], wires=0)\n",
    "        qml.RZ(weights[jj,2*(n_qubits-1),2], wires=0)\n",
    "\n",
    "    return qml.expval(qml.PauliZ(0))\n",
    "\n",
    "weight_shapes = {\"weights\": (n_layers, 2*(n_qubits-1)+1, 3) }\n",
    "\n",
    "\n",
    "qlayer = qml.qnn.KerasLayer(qnode, weight_shapes, output_dim=1, name=\"quantumLayer\")\n",
    "inputs = tf.keras.Input(shape=(n_qubits,), name=\"inputs\")\n",
    "outputs = qlayer(inputs)\n",
    "model = tf.keras.Model(inputs=inputs, outputs=outputs, name=\"QNN\")\n",
    "\n",
    "model.predict(x_train_small[0,:])\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_quantum_model(n_qubits, n_layers):\n",
    "    \n",
    "    # Create a quantum device with the specified number of qubits\n",
    "    dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "\n",
    "    @qml.qnode(dev, diff_method=\"adjoint\")\n",
    "    def qnode(inputs, weights):\n",
    "        \n",
    "        # Apply RY rotations based on input values\n",
    "        for ii in range(n_qubits):\n",
    "            qml.RY(np.pi * inputs[ii], wires=ii)\n",
    "\n",
    "        # Apply quantum layers\n",
    "        for jj in range(n_layers):\n",
    "            for ii in range(n_qubits-1):\n",
    "                \n",
    "                # Apply RZ, RY, RZ gates on wire 0\n",
    "                qml.RZ(weights[jj, 2*ii, 0], wires=0)\n",
    "                qml.RY(weights[jj, 2*ii, 1], wires=0)\n",
    "                qml.RZ(weights[jj, 2*ii, 2], wires=0)\n",
    "\n",
    "                # Apply RZ, RY, RZ gates on wire (ii + 1)\n",
    "                qml.RZ(weights[jj, 2*ii+1, 0], wires=ii+1)\n",
    "                qml.RY(weights[jj, 2*ii+1, 1], wires=ii+1)\n",
    "                qml.RZ(weights[jj, 2*ii+1, 2], wires=ii+1)\n",
    "\n",
    "                # Apply CNOT gate between wire (ii + 1) and wire 0\n",
    "                qml.CNOT(wires=[ii+1, 0])\n",
    "\n",
    "            # Apply RZ, RY, RZ gates on wire 0 after the CNOTs\n",
    "            qml.RZ(weights[jj, 2*(n_qubits-1), 0], wires=0)\n",
    "            qml.RY(weights[jj, 2*(n_qubits-1), 1], wires=0)\n",
    "            qml.RZ(weights[jj, 2*(n_qubits-1), 2], wires=0)\n",
    "\n",
    "        # Measure the expectation value of Pauli-Z on wire 0\n",
    "        return qml.expval(qml.PauliZ(0))\n",
    "\n",
    "    # Define weight shapes for the KerasLayer\n",
    "    weight_shapes = {\"weights\": (n_layers, 2*(n_qubits-1)+1, 3)}\n",
    "\n",
    "    # Create the quantum layer with the qnode and weight_shapes\n",
    "    qlayer = qml.qnn.KerasLayer(qnode, weight_shapes, output_dim=1, name=\"quantumLayer\")\n",
    "\n",
    "    # Create the Keras input layer with the shape of the inputs\n",
    "    inputs = tf.keras.Input(shape=(n_qubits,), name=\"inputs\")\n",
    "\n",
    "    # Connect the quantum layer to the inputs\n",
    "    outputs = qlayer(inputs)\n",
    "\n",
    "    # Create the Keras model with the inputs and outputs\n",
    "    model = tf.keras.Model(inputs=inputs, outputs=outputs, name=\"QNN\")\n",
    "\n",
    "    return model, qnode\n",
    "\n",
    "model, q_node = create_quantum_model(n_qubits, n_layers)\n",
    "model.predict(x_train_sliced[0,:])\n",
    "print(model.summary())\n",
    "plot_model(model, to_file=\"quantum_ml_model.png\", show_shapes=True, show_dtype=True, show_layer_names=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.keras.utils import plot_model\n",
    "\n",
    "plot_model(model, to_file=\"quantum_ml_model.png\", show_shapes=True, show_dtype=True, show_layer_names=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ──RY(2.75)──RZ(0.90)──RY(0.21)──RZ(0.65)─╭X──RZ(0.18)──RY(0.33)──RZ(0.20)─╭X──RZ(0.14)──RY(0.39)\n",
      "1: ──RY(1.97)──RZ(0.79)──RY(0.41)──RZ(0.53)─╰●───────────────────────────────│─────────────────────\n",
      "2: ──RY(2.92)──RZ(0.20)──RY(0.90)──RZ(0.58)──────────────────────────────────╰●────────────────────\n",
      "3: ──RY(0.63)──RZ(0.21)──RY(0.64)──RZ(0.95)────────────────────────────────────────────────────────\n",
      "4: ──RY(2.56)──RZ(0.26)──RY(0.63)──RZ(0.27)────────────────────────────────────────────────────────\n",
      "5: ──RY(3.05)──RZ(0.18)──RY(0.16)──RZ(0.44)────────────────────────────────────────────────────────\n",
      "6: ──RY(1.74)──RZ(0.18)──RY(0.66)──RZ(0.02)────────────────────────────────────────────────────────\n",
      "7: ──RY(0.42)──RZ(0.74)──RY(0.86)──RZ(0.51)────────────────────────────────────────────────────────\n",
      "8: ──RY(1.12)──RZ(0.63)──RY(0.90)──RZ(0.19)────────────────────────────────────────────────────────\n",
      "\n",
      "───RZ(0.57)─╭X──RZ(0.25)──RY(0.35)──RZ(0.22)─╭X──RZ(0.75)──RY(0.04)──RZ(0.52)─╭X──RZ(0.70)──RY(0.53)\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────╰●───────────────────────────────│────────────────────────────────│─────────────────────\n",
      "─────────────────────────────────────────────╰●───────────────────────────────│─────────────────────\n",
      "──────────────────────────────────────────────────────────────────────────────╰●────────────────────\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "────────────────────────────────────────────────────────────────────────────────────────────────────\n",
      "\n",
      "───RZ(0.80)─╭X──RZ(0.17)──RY(0.15)──RZ(0.77)─╭X──RZ(0.47)──RY(0.76)──RZ(0.94)─╭X──RZ(0.46)──RY(0.13)\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────│────────────────────────────────│────────────────────────────────│─────────────────────\n",
      "────────────╰●───────────────────────────────│────────────────────────────────│─────────────────────\n",
      "─────────────────────────────────────────────╰●───────────────────────────────│─────────────────────\n",
      "──────────────────────────────────────────────────────────────────────────────╰●────────────────────\n",
      "\n",
      "───RZ(0.96)─┤  <Z>\n",
      "────────────┤     \n",
      "────────────┤     \n",
      "────────────┤     \n",
      "────────────┤     \n",
      "────────────┤     \n",
      "────────────┤     \n",
      "────────────┤     \n",
      "────────────┤     \n"
     ]
    }
   ],
   "source": [
    "circuit_diagram = qml.draw(qnode)\n",
    "sample_inputs = np.random.rand(n_qubits)\n",
    "sample_weights = np.random.rand(n_layers, 2*(n_qubits-1)+1, 3)\n",
    "\n",
    "print(circuit_diagram(sample_inputs, sample_weights))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Redefine the classification values to match the Hinge loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_hinge = 2.0*y_train-1.0\n",
    "y_test_hinge = 2.0*y_test-1.0"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the hinge accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hinge_accuracy(y_true, y_pred):\n",
    "    y_true = tf.squeeze(y_true) > 0.0\n",
    "    y_pred = tf.squeeze(y_pred) > 0.0\n",
    "    result = tf.cast(y_true == y_pred, tf.float32)\n",
    "\n",
    "    return tf.reduce_mean(result)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compile and train the model\n",
    "\n",
    "Compile the model using the hinge loss and accuracy and the Adam optimiser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "    loss=tf.keras.losses.Hinge(),\n",
    "    optimizer=tf.keras.optimizers.Adam(),\n",
    "    metrics=[hinge_accuracy])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"QNN\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " inputs (InputLayer)         [(None, 9)]               0         \n",
      "                                                                 \n",
      " quantumLayer (KerasLayer)   (None, 1)                 51        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 51\n",
      "Trainable params: 51\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(model.summary())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the model over 20 epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "512\n",
      "Epoch 1/20\n",
      "16/16 [==============================] - 116s 8s/step - loss: 0.7949 - hinge_accuracy: 0.7754 - val_loss: 0.7842 - val_hinge_accuracy: 0.8029\n",
      "Epoch 2/20\n",
      "16/16 [==============================] - 129s 8s/step - loss: 0.7478 - hinge_accuracy: 0.8398 - val_loss: 0.7406 - val_hinge_accuracy: 0.8619\n",
      "Epoch 3/20\n",
      "16/16 [==============================] - 130s 8s/step - loss: 0.6949 - hinge_accuracy: 0.9082 - val_loss: 0.6912 - val_hinge_accuracy: 0.8886\n",
      "Epoch 4/20\n",
      "16/16 [==============================] - 122s 8s/step - loss: 0.6369 - hinge_accuracy: 0.9238 - val_loss: 0.6366 - val_hinge_accuracy: 0.9027\n",
      "Epoch 5/20\n",
      "16/16 [==============================] - 122s 8s/step - loss: 0.5746 - hinge_accuracy: 0.9355 - val_loss: 0.5780 - val_hinge_accuracy: 0.9254\n",
      "Epoch 6/20\n",
      "16/16 [==============================] - 124s 8s/step - loss: 0.5098 - hinge_accuracy: 0.9531 - val_loss: 0.5184 - val_hinge_accuracy: 0.9420\n",
      "Epoch 7/20\n",
      "16/16 [==============================] - 122s 8s/step - loss: 0.4452 - hinge_accuracy: 0.9727 - val_loss: 0.4587 - val_hinge_accuracy: 0.9572\n",
      "Epoch 8/20\n",
      "16/16 [==============================] - 120s 8s/step - loss: 0.3837 - hinge_accuracy: 0.9805 - val_loss: 0.4018 - val_hinge_accuracy: 0.9642\n",
      "Epoch 9/20\n",
      "16/16 [==============================] - 124s 8s/step - loss: 0.3262 - hinge_accuracy: 0.9844 - val_loss: 0.3503 - val_hinge_accuracy: 0.9672\n",
      "Epoch 10/20\n",
      "16/16 [==============================] - 125s 8s/step - loss: 0.2753 - hinge_accuracy: 0.9844 - val_loss: 0.3059 - val_hinge_accuracy: 0.9693\n",
      "Epoch 11/20\n",
      "16/16 [==============================] - 124s 8s/step - loss: 0.2330 - hinge_accuracy: 0.9883 - val_loss: 0.2680 - val_hinge_accuracy: 0.9698\n",
      "Epoch 12/20\n",
      "16/16 [==============================] - 127s 8s/step - loss: 0.1973 - hinge_accuracy: 0.9883 - val_loss: 0.2377 - val_hinge_accuracy: 0.9718\n",
      "Epoch 13/20\n",
      "16/16 [==============================] - 123s 8s/step - loss: 0.1697 - hinge_accuracy: 0.9922 - val_loss: 0.2133 - val_hinge_accuracy: 0.9738\n",
      "Epoch 14/20\n",
      "16/16 [==============================] - 127s 8s/step - loss: 0.1482 - hinge_accuracy: 0.9922 - val_loss: 0.1945 - val_hinge_accuracy: 0.9753\n",
      "Epoch 15/20\n",
      "16/16 [==============================] - 125s 8s/step - loss: 0.1319 - hinge_accuracy: 0.9922 - val_loss: 0.1801 - val_hinge_accuracy: 0.9763\n",
      "Epoch 16/20\n",
      "16/16 [==============================] - 120s 8s/step - loss: 0.1197 - hinge_accuracy: 0.9922 - val_loss: 0.1692 - val_hinge_accuracy: 0.9773\n",
      "Epoch 17/20\n",
      "16/16 [==============================] - 123s 8s/step - loss: 0.1105 - hinge_accuracy: 0.9922 - val_loss: 0.1608 - val_hinge_accuracy: 0.9788\n",
      "Epoch 18/20\n",
      "16/16 [==============================] - 123s 8s/step - loss: 0.1037 - hinge_accuracy: 0.9922 - val_loss: 0.1540 - val_hinge_accuracy: 0.9803\n",
      "Epoch 19/20\n",
      "16/16 [==============================] - 122s 8s/step - loss: 0.0981 - hinge_accuracy: 0.9922 - val_loss: 0.1486 - val_hinge_accuracy: 0.9803\n",
      "Epoch 20/20\n",
      "16/16 [==============================] - 117s 8s/step - loss: 0.0939 - hinge_accuracy: 0.9922 - val_loss: 0.1440 - val_hinge_accuracy: 0.9808\n",
      "62/62 [==============================] - 76s 1s/step - loss: 0.1440 - hinge_accuracy: 0.9808\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 20\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "NUM_EXAMPLES = 512 #x_train_small.shape[0]\n",
    "print(NUM_EXAMPLES)\n",
    "\n",
    "x_train_sub = x_train_small[:NUM_EXAMPLES,:]\n",
    "y_train_hinge_sub = y_train_hinge[:NUM_EXAMPLES]\n",
    "\n",
    "x_test_sub = x_test_small[:,:]\n",
    "y_test_sub = y_test[:]\n",
    "\n",
    "qnn_history_1layer = model.fit(\n",
    "      x_train_sub, y_train_hinge_sub,\n",
    "      batch_size=BATCH_SIZE,\n",
    "      epochs=EPOCHS,\n",
    "      verbose=1,\n",
    "      validation_data=(x_test_sub, y_test_sub))\n",
    "\n",
    "qnn_results_1layer = model.evaluate(x_test_sub, y_test_sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [0.7948610737076639,\n",
       "  0.747792502576677,\n",
       "  0.6949325005123872,\n",
       "  0.63687125836657,\n",
       "  0.5746490536454402,\n",
       "  0.5097967228108742,\n",
       "  0.4452283333492036,\n",
       "  0.3837232509988997,\n",
       "  0.326215743752812,\n",
       "  0.275303303158548,\n",
       "  0.2329972143218012,\n",
       "  0.1973051505247757,\n",
       "  0.16970821046253975,\n",
       "  0.14815786166757106,\n",
       "  0.13192971004601295,\n",
       "  0.11967931721619546,\n",
       "  0.11047155728175485,\n",
       "  0.103677711187808,\n",
       "  0.09814878346648996,\n",
       "  0.0939320501603964],\n",
       " 'hinge_accuracy': [0.775390625,\n",
       "  0.83984375,\n",
       "  0.908203125,\n",
       "  0.923828125,\n",
       "  0.935546875,\n",
       "  0.953125,\n",
       "  0.97265625,\n",
       "  0.98046875,\n",
       "  0.984375,\n",
       "  0.984375,\n",
       "  0.98828125,\n",
       "  0.98828125,\n",
       "  0.9921875,\n",
       "  0.9921875,\n",
       "  0.9921875,\n",
       "  0.9921875,\n",
       "  0.9921875,\n",
       "  0.9921875,\n",
       "  0.9921875,\n",
       "  0.9921875],\n",
       " 'val_loss': [0.7841518037654658,\n",
       "  0.7405903996850309,\n",
       "  0.6912318639937944,\n",
       "  0.636639164014819,\n",
       "  0.5780122791066481,\n",
       "  0.5183518558250495,\n",
       "  0.45866246354486634,\n",
       "  0.40181119262681886,\n",
       "  0.3503085625247908,\n",
       "  0.30593768987919956,\n",
       "  0.2679786654576807,\n",
       "  0.23773485846057982,\n",
       "  0.21330243146748154,\n",
       "  0.19449756440640623,\n",
       "  0.1800564377115347,\n",
       "  0.16915863357399036,\n",
       "  0.16079108338587417,\n",
       "  0.1539803341417857,\n",
       "  0.14863778121007462,\n",
       "  0.14404912734313635],\n",
       " 'val_hinge_accuracy': [0.8029233870967742,\n",
       "  0.8618951612903226,\n",
       "  0.8886088709677419,\n",
       "  0.9027217741935484,\n",
       "  0.9254032258064516,\n",
       "  0.9420362903225806,\n",
       "  0.9571572580645161,\n",
       "  0.9642137096774194,\n",
       "  0.9672379032258065,\n",
       "  0.9692540322580645,\n",
       "  0.969758064516129,\n",
       "  0.9717741935483871,\n",
       "  0.9737903225806451,\n",
       "  0.9753024193548387,\n",
       "  0.9763104838709677,\n",
       "  0.9773185483870968,\n",
       "  0.9788306451612904,\n",
       "  0.9803427419354839,\n",
       "  0.9803427419354839,\n",
       "  0.9808467741935484]}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qnn_history_1layer.history"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create and train a 2 layer version of the QNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 94ms/step\n",
      "Model: \"QNN\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " inputs (InputLayer)         [(None, 9)]               0         \n",
      "                                                                 \n",
      " quantumLayer (KerasLayer)   (None, 1)                 102       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 102\n",
      "Trainable params: 102\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "n_qubits = 9\n",
    "n_layers = 2\n",
    "dev = qml.device(\"default.qubit\", wires=n_qubits)\n",
    "\n",
    "@qml.qnode(dev, diff_method=\"adjoint\")\n",
    "def qnode(inputs, weights):\n",
    "\n",
    "    for ii in range(n_qubits):\n",
    "        qml.RY(np.pi * inputs[ii], wires=ii)\n",
    "\n",
    "    for jj in range(n_layers):\n",
    "        for ii in range(n_qubits-1):\n",
    "            qml.RZ(weights[jj,2*ii,0], wires=0)\n",
    "            qml.RY(weights[jj,2*ii,1], wires=0)\n",
    "            qml.RZ(weights[jj,2*ii,2], wires=0)\n",
    "\n",
    "            qml.RZ(weights[jj,2*ii+1,0], wires=ii+1)\n",
    "            qml.RY(weights[jj,2*ii+1,1], wires=ii+1)\n",
    "            qml.RZ(weights[jj,2*ii+1,2], wires=ii+1)\n",
    "\n",
    "            #qml.U3(*list(weights[jj,2*ii,:]), wires=0)\n",
    "            #qml.U3(*list(weights[jj,2*ii+1,:]), wires=ii+1)\n",
    "            qml.CNOT(wires=[ii+1,0])\n",
    "            \n",
    "        qml.RZ(weights[jj,2*(n_qubits-1),0], wires=0)\n",
    "        qml.RY(weights[jj,2*(n_qubits-1),1], wires=0)\n",
    "        qml.RZ(weights[jj,2*(n_qubits-1),2], wires=0)\n",
    "\n",
    "    return qml.expval(qml.PauliZ(0))\n",
    "\n",
    "weight_shapes = {\"weights\": (n_layers, 2*(n_qubits-1)+1, 3) }\n",
    "\n",
    "\n",
    "qlayer = qml.qnn.KerasLayer(qnode, weight_shapes, output_dim=1, name=\"quantumLayer\")\n",
    "inputs = tf.keras.Input(shape=(n_qubits,), name=\"inputs\")\n",
    "outputs = qlayer(inputs)\n",
    "model2 = tf.keras.Model(inputs=inputs, outputs=outputs, name=\"QNN\")\n",
    "\n",
    "model2.predict(x_train_small[0,:])\n",
    "print(model2.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "model2.compile(\n",
    "    loss=tf.keras.losses.Hinge(),\n",
    "    optimizer=tf.keras.optimizers.Adam(),\n",
    "    metrics=[hinge_accuracy])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "512\n",
      "Epoch 1/20\n",
      "16/16 [==============================] - 221s 14s/step - loss: 1.3413 - hinge_accuracy: 0.1426 - val_loss: 1.3481 - val_hinge_accuracy: 0.1159\n",
      "Epoch 2/20\n",
      "16/16 [==============================] - 230s 15s/step - loss: 1.2572 - hinge_accuracy: 0.1738 - val_loss: 1.2678 - val_hinge_accuracy: 0.1497\n",
      "Epoch 3/20\n",
      "16/16 [==============================] - 223s 14s/step - loss: 1.1718 - hinge_accuracy: 0.2227 - val_loss: 1.1823 - val_hinge_accuracy: 0.2087\n",
      "Epoch 4/20\n",
      "16/16 [==============================] - 225s 15s/step - loss: 1.0806 - hinge_accuracy: 0.3242 - val_loss: 1.0901 - val_hinge_accuracy: 0.3392\n",
      "Epoch 5/20\n",
      "16/16 [==============================] - 230s 15s/step - loss: 0.9835 - hinge_accuracy: 0.5137 - val_loss: 0.9902 - val_hinge_accuracy: 0.5197\n",
      "Epoch 6/20\n",
      "16/16 [==============================] - 226s 15s/step - loss: 0.8788 - hinge_accuracy: 0.6738 - val_loss: 0.8858 - val_hinge_accuracy: 0.6573\n",
      "Epoch 7/20\n",
      "16/16 [==============================] - 219s 14s/step - loss: 0.7720 - hinge_accuracy: 0.8164 - val_loss: 0.7782 - val_hinge_accuracy: 0.7923\n",
      "Epoch 8/20\n",
      "16/16 [==============================] - 226s 15s/step - loss: 0.6649 - hinge_accuracy: 0.9180 - val_loss: 0.6743 - val_hinge_accuracy: 0.8931\n",
      "Epoch 9/20\n",
      "16/16 [==============================] - 221s 14s/step - loss: 0.5650 - hinge_accuracy: 0.9590 - val_loss: 0.5776 - val_hinge_accuracy: 0.9274\n",
      "Epoch 10/20\n",
      "16/16 [==============================] - 226s 15s/step - loss: 0.4750 - hinge_accuracy: 0.9648 - val_loss: 0.4921 - val_hinge_accuracy: 0.9516\n",
      "Epoch 11/20\n",
      "16/16 [==============================] - 223s 14s/step - loss: 0.3974 - hinge_accuracy: 0.9785 - val_loss: 0.4202 - val_hinge_accuracy: 0.9627\n",
      "Epoch 12/20\n",
      "16/16 [==============================] - 226s 15s/step - loss: 0.3334 - hinge_accuracy: 0.9844 - val_loss: 0.3609 - val_hinge_accuracy: 0.9688\n",
      "Epoch 13/20\n",
      "16/16 [==============================] - 229s 15s/step - loss: 0.2814 - hinge_accuracy: 0.9902 - val_loss: 0.3126 - val_hinge_accuracy: 0.9743\n",
      "Epoch 14/20\n",
      "16/16 [==============================] - 259s 17s/step - loss: 0.2395 - hinge_accuracy: 0.9961 - val_loss: 0.2722 - val_hinge_accuracy: 0.9753\n",
      "Epoch 15/20\n",
      "16/16 [==============================] - 323s 21s/step - loss: 0.2042 - hinge_accuracy: 0.9961 - val_loss: 0.2390 - val_hinge_accuracy: 0.9768\n",
      "Epoch 16/20\n",
      "16/16 [==============================] - 253s 16s/step - loss: 0.1753 - hinge_accuracy: 0.9980 - val_loss: 0.2106 - val_hinge_accuracy: 0.9793\n",
      "Epoch 17/20\n",
      "16/16 [==============================] - 323s 21s/step - loss: 0.1507 - hinge_accuracy: 0.9980 - val_loss: 0.1858 - val_hinge_accuracy: 0.9839\n",
      "Epoch 18/20\n",
      "16/16 [==============================] - 265s 17s/step - loss: 0.1294 - hinge_accuracy: 0.9980 - val_loss: 0.1649 - val_hinge_accuracy: 0.9849\n",
      "Epoch 19/20\n",
      "16/16 [==============================] - 264s 17s/step - loss: 0.1114 - hinge_accuracy: 0.9980 - val_loss: 0.1468 - val_hinge_accuracy: 0.9874\n",
      "Epoch 20/20\n",
      "16/16 [==============================] - 262s 17s/step - loss: 0.0962 - hinge_accuracy: 1.0000 - val_loss: 0.1312 - val_hinge_accuracy: 0.9899\n",
      "62/62 [==============================] - 169s 3s/step - loss: 0.1312 - hinge_accuracy: 0.9899\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 20\n",
    "BATCH_SIZE = 32\n",
    "\n",
    "NUM_EXAMPLES = 512 #x_train_small.shape[0]\n",
    "print(NUM_EXAMPLES)\n",
    "\n",
    "x_train_sub = x_train_small[:NUM_EXAMPLES,:]\n",
    "y_train_hinge_sub = y_train_hinge[:NUM_EXAMPLES]\n",
    "\n",
    "x_test_sub = x_test_small[:,:]\n",
    "y_test_sub = y_test[:]\n",
    "\n",
    "qnn_history_2layer = model2.fit(\n",
    "      x_train_sub, y_train_hinge_sub,\n",
    "      batch_size=BATCH_SIZE,\n",
    "      epochs=EPOCHS,\n",
    "      verbose=1,\n",
    "      validation_data=(x_test_sub, y_test_sub))\n",
    "\n",
    "qnn_results_2layer = model2.evaluate(x_test_sub, y_test_sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'loss': [1.3413382869175614,\n",
       "  1.257158245783547,\n",
       "  1.1717778574682909,\n",
       "  1.0805867696149776,\n",
       "  0.9834880632450164,\n",
       "  0.8788159335340346,\n",
       "  0.7720185404790528,\n",
       "  0.6648715723502568,\n",
       "  0.5650397934258788,\n",
       "  0.4750214415105203,\n",
       "  0.39739542345157464,\n",
       "  0.33343198183226064,\n",
       "  0.2813899822297749,\n",
       "  0.23949438801413053,\n",
       "  0.20422700741697178,\n",
       "  0.17526618262852978,\n",
       "  0.15071860022352598,\n",
       "  0.1294208141592533,\n",
       "  0.11144211520870792,\n",
       "  0.09621070616034656],\n",
       " 'hinge_accuracy': [0.142578125,\n",
       "  0.173828125,\n",
       "  0.22265625,\n",
       "  0.32421875,\n",
       "  0.513671875,\n",
       "  0.673828125,\n",
       "  0.81640625,\n",
       "  0.91796875,\n",
       "  0.958984375,\n",
       "  0.96484375,\n",
       "  0.978515625,\n",
       "  0.984375,\n",
       "  0.990234375,\n",
       "  0.99609375,\n",
       "  0.99609375,\n",
       "  0.998046875,\n",
       "  0.998046875,\n",
       "  0.998046875,\n",
       "  0.998046875,\n",
       "  1.0],\n",
       " 'val_loss': [1.3480957858191063,\n",
       "  1.2678485014292395,\n",
       "  1.1822944548006231,\n",
       "  1.0900566090809363,\n",
       "  0.9902096832225786,\n",
       "  0.8858413965523876,\n",
       "  0.778242943948875,\n",
       "  0.6742622187171513,\n",
       "  0.5775994367846176,\n",
       "  0.49206464410612855,\n",
       "  0.42022965025275655,\n",
       "  0.36094937831371854,\n",
       "  0.3126056939282153,\n",
       "  0.27215341787730174,\n",
       "  0.23895672798251877,\n",
       "  0.21056317351458753,\n",
       "  0.1858214484932709,\n",
       "  0.16488399009282886,\n",
       "  0.14678521614752124,\n",
       "  0.1312039906957503],\n",
       " 'val_hinge_accuracy': [0.1159274193548387,\n",
       "  0.14969758064516128,\n",
       "  0.2086693548387097,\n",
       "  0.3392137096774194,\n",
       "  0.5196572580645161,\n",
       "  0.657258064516129,\n",
       "  0.7923387096774194,\n",
       "  0.8931451612903226,\n",
       "  0.9274193548387096,\n",
       "  0.9516129032258065,\n",
       "  0.9627016129032258,\n",
       "  0.96875,\n",
       "  0.9742943548387096,\n",
       "  0.9753024193548387,\n",
       "  0.9768145161290323,\n",
       "  0.9793346774193549,\n",
       "  0.9838709677419355,\n",
       "  0.9848790322580645,\n",
       "  0.9873991935483871,\n",
       "  0.9899193548387096]}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qnn_history_2layer.history"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot the results!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the hinge accuracy for the qnn history for both 1 and 2 layer on the same axes\n",
    "plt.plot(np.arange(1,21), qnn_history_1layer.history[\"hinge_accuracy\"], label=\"TRAIN - 1 layer QNN\")\n",
    "plt.plot(np.arange(1,21), qnn_history_1layer.history[\"val_hinge_accuracy\"], label=\"VAL - 1 layer QNN\")\n",
    "plt.plot(np.arange(1,21), qnn_history_2layer.history[\"hinge_accuracy\"], label=\"TRAIN - 2 layer QNN\")\n",
    "plt.plot(np.arange(1,21), qnn_history_2layer.history[\"val_hinge_accuracy\"], label=\"VAL - 2 layer QNN\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Hinge Accuracy\")\n",
    "plt.legend()\n",
    "# modify x_ticks to also include 20\n",
    "plt.xticks(np.arange(0, 21, 2.5))\n",
    "# save as pdf with tight layout and no padding\n",
    "plt.savefig(\"qnn_hinge_accuracy.pdf\", bbox_inches=\"tight\", pad_inches=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the hinge accuracy for the loss for both 1 and 2 layer on the same axes\n",
    "plt.plot(np.arange(1,21), qnn_history_1layer.history[\"loss\"], label=\"TRAIN - 1 layer QNN\")\n",
    "plt.plot(np.arange(1,21), qnn_history_1layer.history[\"val_loss\"], label=\"VAL - 1 layer QNN\")\n",
    "plt.plot(np.arange(1,21), qnn_history_2layer.history[\"loss\"], label=\"TRAIN - 2 layer QNN\")\n",
    "plt.plot(np.arange(1,21), qnn_history_2layer.history[\"val_loss\"], label=\"VAL - 2 layer QNN\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Hinge Loss\")\n",
    "plt.legend()\n",
    "# modify x_ticks to also include 20\n",
    "plt.xticks(np.arange(0, 21, 2.5))\n",
    "# save as pdf with tight layout and no padding\n",
    "plt.savefig(\"qnn_hinge_loss.pdf\", bbox_inches=\"tight\", pad_inches=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "    #--------------- PLOT CONFUSION MATRIX -----------------\n",
    "    y_pred = model.predict(x_test_sub)\n",
    "    y_pred = np.argmax(y_pred, axis=1)\n",
    "    y_test_sub = np.argmax(y_test_sub, axis=1)\n",
    "    cm = confusion_matrix(y_test_sub, y_pred)\n",
    "    print(cm)\n",
    "    plt.figure(figsize=(10,10))\n",
    "    sns.heatmap(cm, annot=True, fmt=\"d\")\n",
    "    plt.title(\"Confusion matrix\")\n",
    "    plt.ylabel('Actual label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.savefig(\"QML_model_experiment_{}_confusion_matrix.png\".format(key))\n",
    "    plt.clf()\n",
    "    \n",
    "    #--------------- PLOT CLASSIFICATION REPORT -----------------\n",
    "    print(classification_report(y_test_sub, y_pred))\n",
    "    plt.figure(figsize=(10,10))\n",
    "    sns.heatmap(cm/np.sum(cm), annot=True, fmt='.2%', cmap='Blues')\n",
    "    plt.title(\"Confusion matrix\")\n",
    "    plt.ylabel('Actual label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    plt.savefig(\"QML_model_experiment_{}_confusion_matrix_norm.png\".format(key))\n",
    "    plt.clf()\n",
    "\n",
    "    #--------------- PLOT ROC CURVE -----------------\n",
    "    # plot ROC curve using the already calculated metrics\n",
    "    fpr = dict()\n",
    "    tpr = dict()\n",
    "    roc_auc = dict()\n",
    "    for i in range(10):\n",
    "        fpr[i], tpr[i], _ = roc_curve(y_test_sub, y_pred)\n",
    "        roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "    \n",
    "    # Compute micro-average ROC curve and ROC area\n",
    "    fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(y_test_sub.ravel(), y_pred.ravel())\n",
    "    roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n",
    "\n",
    "    # Compute macro-average ROC curve and ROC area\n",
    "    # First aggregate all false positive rates\n",
    "    all_fpr = np.unique(np.concatenate([fpr[i] for i in range(10)]))\n",
    "\n",
    "    # Then interpolate all ROC curves at this points\n",
    "    mean_tpr = np.zeros_like(all_fpr)\n",
    "    for i in range(10):\n",
    "        mean_tpr += interp(all_fpr, fpr[i], tpr[i])\n",
    "\n",
    "    # Finally average it and compute AUC\n",
    "    mean_tpr /= 10\n",
    "\n",
    "    fpr[\"macro\"] = all_fpr\n",
    "    tpr[\"macro\"] = mean_tpr\n",
    "    roc_auc[\"macro\"] = auc(fpr[\"macro\"], tpr[\"macro\"])\n",
    "\n",
    "    # Plot all ROC curves\n",
    "    plt.figure(figsize=(10,10))\n",
    "    plt.plot(fpr[\"micro\"], tpr[\"micro\"],\n",
    "            label='micro-average ROC curve (area = {0:0.2f})'\n",
    "                ''.format(roc_auc[\"micro\"]),\n",
    "            color='deeppink', linestyle=':', linewidth=4)\n",
    "    \n",
    "    plt.plot(fpr[\"macro\"], tpr[\"macro\"],\n",
    "            label='macro-average ROC curve (area = {0:0.2f})'\n",
    "                ''.format(roc_auc[\"macro\"]),\n",
    "            color='navy', linestyle=':', linewidth=4)\n",
    "    \n",
    "    colors = cycle(['aqua', 'darkorange', 'cornflowerblue', 'red', 'green', 'yellow', 'purple', 'pink', 'brown', 'black'])\n",
    "    for i, color in zip(range(10), colors):\n",
    "        plt.plot(fpr[i], tpr[i], color=color, lw=2,\n",
    "                label='ROC curve of class {0} (area = {1:0.2f})'\n",
    "                ''.format(i, roc_auc[i]))\n",
    "    \n",
    "    plt.plot([0, 1], [0, 1], 'k--', lw=2)\n",
    "    plt.xlim([-0.05, 1.0])\n",
    "    plt.ylim([0.0, 1.05])\n",
    "    plt.xlabel('False Positive Rate (FPR)')\n",
    "    plt.ylabel('True Positive Rate (TPR)')\n",
    "    plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
    "    plt.legend(loc=\"lower right\")\n",
    "    plt.savefig(\"QML_model_experiment_{}_roc_curve.png\".format(key))\n",
    "    plt.clf()\n",
    "\n",
    "    #--------------- PLOT PRECISION-RECALL CURVE -----------------\n",
    "    # plot precision-recall curve using the already calculated metrics\n",
    "    precision = dict()\n",
    "    recall = dict()\n",
    "    pr_auc = dict()\n",
    "    for i in range(10):\n",
    "        precision[i], recall[i], _ = precision_recall_curve(y_test_sub, y_pred)\n",
    "        pr_auc[i] = auc(recall[i], precision[i])\n",
    "    \n",
    "    # Compute micro-average ROC curve and ROC area\n",
    "    precision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(y_test_sub.ravel(), y_pred.ravel())\n",
    "    pr_auc[\"micro\"] = auc(recall[\"micro\"], precision[\"micro\"])\n",
    "\n",
    "    # Compute macro-average ROC curve and ROC area\n",
    "    # First aggregate all false positive rates\n",
    "    all_recall = np.unique(np.concatenate([recall[i] for i in range(10)]))\n",
    "\n",
    "    # Then interpolate all ROC curves at this points\n",
    "    mean_precision = np.zeros_like(all_recall)\n",
    "    for i in range(10):\n",
    "        mean_precision += interp(all_recall, recall[i], precision[i])\n",
    "    \n",
    "    # Finally average it and compute AUC\n",
    "    mean_precision /= 10\n",
    "\n",
    "    recall[\"macro\"] = all_recall\n",
    "    precision[\"macro\"] = mean_precision\n",
    "    pr_auc[\"macro\"] = auc(recall[\"macro\"], precision[\"macro\"])\n",
    "\n",
    "    # Plot all ROC curves\n",
    "    plt.figure(figsize=(10,10))\n",
    "    plt.plot(recall[\"micro\"], precision[\"micro\"],\n",
    "            label='micro-average Precision-Recall curve (area = {0:0.2f})'\n",
    "                ''.format(pr_auc[\"micro\"]),\n",
    "            color='deeppink', linestyle=':', linewidth=4)\n",
    "    \n",
    "    plt.plot(recall[\"macro\"], precision[\"macro\"],\n",
    "            label='macro-average Precision-Recall curve (area = {0:0.2f})'\n",
    "                ''.format(pr_auc[\"macro\"]),\n",
    "            color='navy', linestyle=':', linewidth=4)\n",
    "    \n",
    "    colors = cycle(['aqua', 'darkorange', 'cornflowerblue', 'red', 'green', 'yellow', 'purple', 'pink', 'brown', 'black'])\n",
    "    for i, color in zip(range(10), colors):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " #--------------- SAVE MODEL AS TFLITE -----------------\n",
    "    converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "    tflite_model = converter.convert()\n",
    "    open(\"QML_model_experiment_{}.tflite\".format(key), \"wb\").write(tflite_model)\n",
    "\n",
    "    #--------------- SAVE MODEL AS TFLITE QUANTIZED -----------------\n",
    "    converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "    converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
    "    tflite_quant_model = converter.convert()\n",
    "    open(\"QML_model_experiment_{}_quantized.tflite\".format(key), \"wb\").write(tflite_quant_model)\n",
    "\n",
    "    #--------------- SAVE MODEL AS TFLITE QUANTIZED WITH POST TRAINING QUANTIZATION -----------------\n",
    "    converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "    converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
    "    converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]\n",
    "    converter.inference_input_type = tf.uint8\n",
    "    converter.inference_output_type = tf.uint8\n",
    "    tflite_quant_model = converter.convert()\n",
    "    open(\"QML_model_experiment_{}_quantized_post_training.tflite\".format(key), \"wb\").write(tflite_quant_model)\n",
    "\n",
    "    #--------------- SAVE MODEL AS TFLITE QUANTIZED WITH POST TRAINING QUANTIZATION AND QUANTIZATION RANGE -----------------\n",
    "    def representative_dataset_gen():\n",
    "        for input_value in tf.data.Dataset.from_tensor_slices(x_train_sub).batch(1).take(100):\n",
    "            yield [input_value]\n",
    "        \n",
    "    converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "    converter.optimizations = [tf.lite.Optimize.DEFAULT]\n",
    "    converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]\n",
    "    converter.inference_input_type = tf.uint8\n",
    "    converter.inference_output_type = tf.uint8\n",
    "    converter.representative_dataset = representative_dataset_gen\n",
    "    tflite_quant_model = converter.convert()\n",
    "    open(\"QML_model_experiment_{}_quantized_post_training_quantization_range.tflite\".format(key), \"wb\").write(tflite_quant_model)\n",
    "\n",
    "   \n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf_gpu_env",
   "language": "python",
   "name": "tf_gpu_env"
  },
  "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "66a612e4ee5d9343e2fda4842cd4535190425ea2d31d59f514fa54a2d33459fb"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}