Quanvolutional_Neural_Network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Quanvolutional Neural Network",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "HoERN4a-VLhE"
      },
      "source": [
        "!pip install tensorflow-quantum"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AF8VLtDCbeDI"
      },
      "source": [
        "#imports\n",
        "import os\n",
        "\n",
        "import numpy as np\n",
        "np.random.seed(11)\n",
        "import pandas as pd\n",
        "import os\n",
        "from glob import glob\n",
        "import seaborn as sns\n",
        "from PIL import Image\n",
        "from sklearn.preprocessing import StandardScaler \n",
        "from sklearn.model_selection import train_test_split, KFold, cross_val_score, GridSearchCV\n",
        "from sklearn.metrics import accuracy_score\n",
        "import itertools\n",
        "\n",
        "from tqdm import tqdm\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "\n",
        "import tensorflow as tf\n",
        "import tensorflow_quantum as tfq\n",
        "\n",
        "import cirq\n",
        "import sympy\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import collections\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from cirq.contrib.svg import SVGCircuit"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gY9RxlczWDea"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G5-R2AAzV3RH"
      },
      "source": [
        "folder_benign_train = '/content/drive/My Drive/binary-data/train/benign'\n",
        "folder_malignant_train = '/content/drive/My Drive/binary-data/train/malignant'\n",
        "\n",
        "folder_benign_test = '/content/drive/My Drive/binary-data/test/benign'\n",
        "folder_malignant_test = '/content/drive/My Drive/binary-data/test/malignant'\n",
        "\n",
        "read = lambda imname: np.asarray(Image.open(imname).convert(\"RGB\"))\n",
        "\n",
        "# Load in training pictures \n",
        "ims_benign = [read(os.path.join(folder_benign_train, filename)) for filename in tqdm(os.listdir(folder_benign_train))]\n",
        "X_benign = np.array(ims_benign, dtype='uint8')\n",
        "ims_malignant = [read(os.path.join(folder_malignant_train, filename)) for filename in tqdm(os.listdir(folder_malignant_train))]\n",
        "X_malignant = np.array(ims_malignant, dtype='uint8')\n",
        "\n",
        "# Load in testing pictures\n",
        "ims_benign = [read(os.path.join(folder_benign_test, filename)) for filename in tqdm(os.listdir(folder_benign_test))]\n",
        "X_benign_test = np.array(ims_benign, dtype='uint8')\n",
        "ims_malignant = [read(os.path.join(folder_malignant_test, filename)) for filename in tqdm(os.listdir(folder_malignant_test))]\n",
        "X_malignant_test = np.array(ims_malignant, dtype='uint8')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CfjgWlFZdoZq"
      },
      "source": [
        "#create labels\n",
        "y_benign = np.zeros(X_benign.shape[0])\n",
        "y_malignant = np.ones(X_malignant.shape[0])\n",
        "\n",
        "y_benign_test = np.zeros(X_benign_test.shape[0])\n",
        "y_malignant_test = np.ones(X_malignant_test.shape[0])\n",
        "\n",
        "#merge data\n",
        "X_train = np.concatenate((X_benign, X_malignant), axis = 0) #training data\n",
        "y_train = np.concatenate((y_benign, y_malignant), axis = 0) #training labels\n",
        "\n",
        "X_test = np.concatenate((X_benign_test, X_malignant_test), axis = 0) #test data\n",
        "y_test = np.concatenate((y_benign_test, y_malignant_test), axis = 0) #test labels"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NVGtOva3dmJH"
      },
      "source": [
        "#shuffle data\n",
        "s = np.arange(X_train.shape[0])\n",
        "np.random.shuffle(s)\n",
        "X_train = X_train[s]\n",
        "y_train = y_train[s]\n",
        "\n",
        "s = np.arange(X_test.shape[0])\n",
        "np.random.shuffle(s)\n",
        "X_test = X_test[s]\n",
        "y_test = y_test[s]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o5B8Z7L8GbVv"
      },
      "source": [
        "# Display first 15 images of moles, and how they are classified\n",
        "w=40\n",
        "h=30\n",
        "fig=plt.figure(figsize=(12, 8))\n",
        "columns = 5\n",
        "rows = 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "350eueV0efO9"
      },
      "source": [
        "y_train = y_train.reshape(-1,1)\n",
        "y_test = y_test.reshape(-1,1)\n",
        "\n",
        "enc = OneHotEncoder(handle_unknown='ignore')\n",
        "enc.fit(y_train)\n",
        "\n",
        "y_train = enc.transform(y_train).toarray()\n",
        "y_test = enc.transform(y_test).toarray()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7aVZDlhDefLo"
      },
      "source": [
        "# With data augmentation to prevent overfitting \n",
        "X_train = X_train/255.\n",
        "X_test = X_test/255.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VHckuGY3efHm"
      },
      "source": [
        "import cv2 \n",
        "\n",
        "#grayscaled & resized data\n",
        "gray_X_train = []\n",
        "gray_X_test = []\n",
        "\n",
        "\n",
        "def rgb2gray(rgb):\n",
        "    return np.dot(rgb[...,:3], [0.2989, 0.5870, 0.1140])\n",
        "\n",
        "for image in X_train:\n",
        "  img = rgb2gray(image)\n",
        "  gray_X_train.append(cv2.resize(img, (4,4)))\n",
        "\n",
        "for image in X_test:\n",
        "  img = rgb2gray(image)\n",
        "  gray_X_test.append(cv2.resize(img, (4,4)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3L0fEiLJflGI"
      },
      "source": [
        "def convert_to_circuit(image):\n",
        "    \"\"\"Encode truncated classical image into quantum datapoint.\"\"\"\n",
        "    values = np.ndarray.flatten(image)\n",
        "    qubits = cirq.GridQubit.rect(4, 4)\n",
        "    circuit = cirq.Circuit()\n",
        "    for i, value in enumerate(values):\n",
        "        if value:\n",
        "            circuit.append(cirq.X(qubits[i]))\n",
        "    return circuit\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aHjD-iR1flZ0"
      },
      "source": [
        "x_train_circ = [convert_to_circuit(x) for x in gray_X_train]\n",
        "x_test_circ = [convert_to_circuit(x) for x in gray_X_test]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TnSXF1_cmbTh"
      },
      "source": [
        "x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)\n",
        "x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gt9AVkOKflpI"
      },
      "source": [
        "#QNN Implementation: classification is based on the expectation of the readout qubit --> use 2 qubit gates with the readout qubit always acted on \n",
        "\n",
        "class CircuitLayerBuilder():\n",
        "    def __init__(self, data_qubits, readout):\n",
        "        self.data_qubits = data_qubits\n",
        "        self.readout = readout\n",
        "    \n",
        "    def add_layer(self, circuit, gate, prefix):\n",
        "        for i, qubit in enumerate(self.data_qubits):\n",
        "            symbol = sympy.Symbol(prefix + '-' + str(i))\n",
        "            circuit.append(gate(qubit, self.readout)**symbol)\n",
        "\n",
        "#2 layered model that matches the data-circuit size \n",
        "#preparation and readout operations \n",
        "\n",
        "def create_quantum_model():\n",
        "    data_qubits = cirq.GridQubit.rect(4, 4)  # a 4x4 grid.\n",
        "    readout = cirq.GridQubit(-1, -1)         # a single qubit at [-1,-1]\n",
        "    circuit = cirq.Circuit()\n",
        "    \n",
        "    # Prepare the readout qubit.\n",
        "    circuit.append(cirq.X(readout))\n",
        "    circuit.append(cirq.H(readout))\n",
        "    \n",
        "    builder = CircuitLayerBuilder(\n",
        "        data_qubits = data_qubits,\n",
        "        readout=readout)\n",
        "\n",
        "    # Then add layers (experiment by adding more).\n",
        "    builder.add_layer(circuit, cirq.XX, \"xx1\")\n",
        "    builder.add_layer(circuit, cirq.ZZ, \"zz1\")\n",
        "\n",
        "    # Finally, prepare the readout qubit.\n",
        "    circuit.append(cirq.H(readout))\n",
        "\n",
        "    return circuit, cirq.Z(readout)\n",
        "\n",
        "model_circuit, model_readout = create_quantum_model()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3pEvKEir5rAq"
      },
      "source": [
        "# Build the Keras model.\n",
        "model = tf.keras.Sequential([\n",
        "    # The input is the data-circuit, encoded as a tf.string\n",
        "    tf.keras.layers.Input(shape=(), dtype=tf.string),\n",
        "    # The PQC layer returns the expected value of the readout gate, range [-1,1].\n",
        "    tfq.layers.PQC(model_circuit, model_readout),\n",
        "])\n",
        "\n",
        "y_train_hinge = 2.0*y_train-1.0\n",
        "y_test_hinge = 2.0*y_test-1.0\n",
        "\n",
        "#hinge_accuracy = handles [-1, 1] as y_true labels argument\n",
        "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)\n",
        "\n",
        "model.compile(\n",
        "    loss=tf.keras.losses.Hinge(),\n",
        "    optimizer=tf.keras.optimizers.Adam(),\n",
        "    metrics=[hinge_accuracy])\n",
        "\n",
        "print(model.summary())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PDudCTFN5v_7"
      },
      "source": [
        "EPOCHS = 3\n",
        "BATCH_SIZE = 8\n",
        "\n",
        "NUM_EXAMPLES = len(x_train_tfcirc)\n",
        "\n",
        "x_train_tfcirc_sub = x_train_tfcirc[:NUM_EXAMPLES]\n",
        "y_train_hinge_sub = y_train_hinge[:NUM_EXAMPLES]\n",
        "\n",
        "qnn_history = model.fit(\n",
        "      x_train_tfcirc_sub, y_train_hinge_sub,\n",
        "      batch_size=8,\n",
        "      epochs=EPOCHS,\n",
        "      verbose=1,\n",
        "      validation_data=(x_test_tfcirc, y_test_hinge))\n",
        "\n",
        "qnn_results = model.evaluate(x_test_tfcirc, y_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cknMTcXUn_Mm"
      },
      "source": [
        "model.save_weights(\"model.h5\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ynCiFjJio2FS"
      },
      "source": [
        "!pip install coremltools\n",
        "\n",
        "output_labels = ['0', '1']\n",
        "ios_model = coremltools.converters.keras.convert('model.h5', input_names=['image'], output_names=['output'], \n",
        "                                                   class_labels=output_labels, image_input_names='image')\n",
        "\n",
        "ios_model.save('your_model_name.mlmodel')"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}