decoding.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pickle\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from collections import Counter\n",
    "from typing import Dict, List\n",
    "from IPython.display import clear_output\n",
    "\n",
    "import qiskit\n",
    "from qiskit import quantum_info\n",
    "from qiskit.execute_function import execute\n",
    "from qiskit import BasicAer\n",
    "from qiskit import QuantumCircuit\n",
    "from qiskit.algorithms.optimizers import COBYLA\n",
    "from qiskit.circuit import ParameterVector\n",
    "from qiskit.circuit.library import ZFeatureMap\n",
    "from qiskit.quantum_info import SparsePauliOp\n",
    "from qiskit.utils import algorithm_globals\n",
    "from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier\n",
    "from qiskit_machine_learning.neural_networks import EstimatorQNN\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#define utility functions\n",
    "\n",
    "#this simulate a circuit (without measurement) and output results in the format of histogram.\n",
    "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n",
    "    \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n",
    "    \n",
    "    backend = BasicAer.get_backend('statevector_simulator')\n",
    "    job = execute(circuit, backend)\n",
    "    result = job.result()\n",
    "    state_vector = result.get_statevector()\n",
    "    histogram = dict()\n",
    "    for i in range(len(state_vector)):\n",
    "        population = abs(state_vector[i]) ** 2\n",
    "        if population > 1e-9:\n",
    "            histogram[i] = population\n",
    "    \n",
    "    return histogram\n",
    "\n",
    "\n",
    "def histogram_to_category(histogram):\n",
    "    assert abs(sum(histogram.values())-1)<1e-8\n",
    "    positive=0\n",
    "    for key in histogram.keys():\n",
    "        digits = bin(int(key))[2:].zfill(20)\n",
    "        if digits[-1]=='0':\n",
    "            positive+=histogram[key]\n",
    "        \n",
    "    return positive\n",
    "\n",
    "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n",
    "    \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n",
    "    return Counter([len(gate[1]) for gate in circuit.data])\n",
    "\n",
    "def image_mse(image1,image2):\n",
    "    # Using sklearns mean squared error:\n",
    "    # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n",
    "    return mean_squared_error(image1, image2)\n",
    "#load the actual hackthon data (fashion-mnist)\n",
    "images=np.load('images.npy')\n",
    "labels=np.load('labels.npy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_img = np.matrix(images[10])\n",
    "def downsizing(sample_img):\n",
    "    test_img = np.zeros((3,5))\n",
    "    col_break_pt = [5,11,17,23,28]\n",
    "    row_break_pt = [9,18,28]\n",
    "    for i in range(3):\n",
    "        for j in range(5):\n",
    "            if j==0:\n",
    "                test_img[i,j] = round(10*np.mean(sample_img[9*i:row_break_pt[i],:col_break_pt[j]]),4)\n",
    "            else:\n",
    "                test_img[i,j] = round(10*np.mean(sample_img[9*i:row_break_pt[i],col_break_pt[j-1]:col_break_pt[j]]),4)\n",
    "    return test_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def downsizing_2(sample_img):\n",
    "    test_img = np.zeros((2,2))\n",
    "    break_pt = [14,28]\n",
    "    for i in range(2):\n",
    "        for j in range(2):\n",
    "            test_img[i,j] = round(np.mean(sample_img[14*i:break_pt[i],14*j:break_pt[j]]),5)\n",
    "    return test_img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2208da73248>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(sample_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_img = downsizing_2(sample_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x2208db2c8c8>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#test_img = downsizing(sample_img)\n",
    "plt.imshow(test_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reconstruction(test_img):\n",
    "    img = np.zeros((28,28))\n",
    "    min_img = 1e-4\n",
    "    for i in range(9):\n",
    "        for j in range(5):\n",
    "            img[8-i,4-j] = abs(round(test_img[0,0] - j**3*1e-5 - 3*i*1e-6 - 2*min_img,2))\n",
    "\n",
    "    for i in range(9):\n",
    "        for j in range(5):\n",
    "            img[8-i,23+j] = abs(round(test_img[0,4]-2*min_img -j**3*1e-5 -i*3*1e-6,2))\n",
    "\n",
    "\n",
    "\n",
    "    for k in range(3):\n",
    "        for i in range(9):\n",
    "            for j in range(6):\n",
    "                img[i,5+k*6 +j]= round(test_img[0,k+1]-5*(abs(k-1))*min_img+j*1e-6  +i*1e-6,5-2*abs(k-1))\n",
    "\n",
    "    for i in range(9):\n",
    "        for j in range(5):\n",
    "            img[17-i,4-j] = abs(round(test_img[1,0] - j**3*1e-5 - 2*min_img,2))\n",
    "    for i in range(9):\n",
    "        for j in range(5):\n",
    "            img[17-i,23+j] = abs(round(test_img[1,4]-2*min_img -j**3*1e-5 ,2))\n",
    "    for k in range(3):\n",
    "        for i in range(9):\n",
    "            for j in range(6):\n",
    "                img[9+i,5+k*6 +j]= round(test_img[1,k+1]-5*(abs(k-1))*min_img,5-2*abs(k-1))\n",
    "\n",
    "    for i in range(10):\n",
    "        for j in range(5):\n",
    "            img[18+i,5-j] = abs(round(test_img[2,0] - j**3*1e-5 -i**3*1e-6  - 2*min_img,2))\n",
    "    for i in range(10):\n",
    "        for j in range(5):\n",
    "            img[18+i,27-j] = abs(round(test_img[2,4]-2*min_img-i**3*1e-6  -j**3*1e-5 ,2))\n",
    "    for k in range(3):\n",
    "        for i in range(10):\n",
    "            for j in range(6):\n",
    "                img[18+i,5+k*6 +j]= round(test_img[2,k+1]-4*(abs(k-1))*min_img-i**3*1e-6 ,5)\n",
    "    return img\n",
    "#plt.imshow(reconstruction(test_img))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reconstruction_2(image):\n",
    "    img = np.zeros((28,28))\n",
    "    min_img = 1e-4\n",
    "    for i in range(14):\n",
    "        for j in range(14):\n",
    "            img[13-i,13-j] = max(round(test_img[0,0] - j*1e-5  - 2*min_img,5),0)\n",
    "\n",
    "    for i in range(14):\n",
    "        for j in range(14):\n",
    "            img[13-i,13+j] = max(round(test_img[0,1]-2*min_img -j*1e-5 ,5),0)\n",
    "\n",
    "    for i in range(14):\n",
    "        for j in range(14):\n",
    "            img[14+i,13- j]= max(round(test_img[1,0] - j**2*1e-5 - 0.5*i*1e-6 - 2*min_img,5),0)\n",
    "    for i in range(14):\n",
    "        for j in range(14):\n",
    "            img[14+i,13+ j]= max(round(test_img[1,1] - j**2*1e-5 - 0.5*i*1e-6 - 2*min_img,5),0)\n",
    "            \n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03844588342905314"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.norm(reconstruction_2(test_img)-sample_img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_2(histogram): \n",
    "    n=4\n",
    "    options = {}\n",
    "    hist_keys = list(histogram.keys())\n",
    "    for i in range(n):\n",
    "        options[i]=0\n",
    "    for i in range(len(histogram)):\n",
    "        for j in range(i,len(histogram)):\n",
    "            x = hist_keys[i]^hist_keys[j]\n",
    "            if x and (not(x & (x-1))):\n",
    "                val1 = bin(hist_keys[i])[2:].zfill(n)\n",
    "                val2 = bin(hist_keys[j])[2:].zfill(n)\n",
    "                for k in range(n):\n",
    "                    if val1[k]!=val2[k]:\n",
    "                        if options[n-1-k] ==0:                            \n",
    "                            options[n-1-k] = 2*np.arctan(np.sqrt(histogram[hist_keys[j]]/histogram[hist_keys[i]]))\n",
    "            else:\n",
    "                continue\n",
    "    image = []\n",
    "    for i in range(n):\n",
    "        image.append(round(options[i]/10,4))\n",
    "    return reconstruction_2(np.asarray(image).reshape((2,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode(histogram): \n",
    "    n=16\n",
    "    options = {}\n",
    "    hist_keys = list(histogram.keys())\n",
    "    for i in range(n):\n",
    "        options[i]=0\n",
    "    for i in range(len(histogram)):\n",
    "        for j in range(i,len(histogram)):\n",
    "            x = hist_keys[i]^hist_keys[j]\n",
    "            if x and (not(x & (x-1))):\n",
    "                val1 = bin(hist_keys[i])[2:].zfill(n)\n",
    "                val2 = bin(hist_keys[j])[2:].zfill(n)\n",
    "                for k in range(n):\n",
    "                    if val1[k]!=val2[k]:\n",
    "                        if options[n-1-k] ==0:                            \n",
    "                            options[n-1-k] = 2*np.arctan(np.sqrt(histogram[hist_keys[j]]/histogram[hist_keys[i]]))\n",
    "            else:\n",
    "                continue\n",
    "    image = []\n",
    "    for i in range(n):\n",
    "        image.append(round(options[i]/10,4))\n",
    "    return reconstruction_2(np.asarray(image).reshape((4,4)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_qiskit(image):\n",
    "    img_arr = np.asarray(downsizing(image)).reshape(-1)\n",
    "    desired_state = img_arr\n",
    "    q = qiskit.QuantumRegister(len(desired_state))\n",
    "    circuit = qiskit.QuantumCircuit(q)\n",
    "    i=0\n",
    "    for ele in desired_state:\n",
    "        if ele>1e-8:\n",
    "            circuit.rx(10*ele,i)\n",
    "        i+=1\n",
    "    circuit.decompose().draw()\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encode_qiskit_2(image):\n",
    "    img_arr = np.asarray(downsizing_2(image)).reshape(-1)\n",
    "    desired_state = img_arr\n",
    "    q = qiskit.QuantumRegister(len(desired_state))\n",
    "    circuit = qiskit.QuantumCircuit(q)\n",
    "    i=0\n",
    "    for ele in desired_state:\n",
    "        if ele>1e-8:\n",
    "            circuit.rx(10*ele,i)\n",
    "        i+=1\n",
    "    circuit.decompose().draw()\n",
    "    return circuit\n",
    "J = sample_img\n",
    "encode_qiskit_2(J).draw()\n",
    "circuit=encode_qiskit_2(J)\n",
    "\n",
    "#simulate circuit\n",
    "histogram_2=simulate(circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9999990666280378\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = len(images)\n",
    "mse=0\n",
    "gatecount=0\n",
    "\n",
    "for image in images[100:1000]:\n",
    "    #encode image into circuit\n",
    "    #J = downsizing(image)\n",
    "    circuit=encode_qiskit_2(image)\n",
    "\n",
    "    #simulate circuit\n",
    "    histogram_2=simulate(circuit)\n",
    "\n",
    "    #count the number of 2-qubit gates\n",
    "    gatecount+=count_gates(circuit)[2]\n",
    "    #print(gatecount)\n",
    "\n",
    "    #reconstruct the image\n",
    "    image_re=decode_2(histogram_2)\n",
    "    #image_rec = reconstruction(downsizing(image))\n",
    "    #calculate mse\n",
    "    mse+=image_mse(np.asarray(image),image_re)\n",
    "#fidelity of reconstruction\n",
    "f=1-mse/n\n",
    "gatecount=gatecount/n\n",
    "\n",
    "#score for part1\n",
    "print(f*(0.999**gatecount))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">       ┌───────────┐\n",
       " q4_0: ┤ Rx(0.011) ├\n",
       "       ├───────────┤\n",
       " q4_1: ┤ Rx(0.104) ├\n",
       "       ├───────────┤\n",
       " q4_2: ┤ Rx(0.194) ├\n",
       "       ├───────────┤\n",
       " q4_3: ┤ Rx(0.091) ├\n",
       "       ├───────────┤\n",
       " q4_4: ┤ Rx(0.018) ├\n",
       "       ├───────────┤\n",
       " q4_5: ┤ Rx(0.024) ├\n",
       "       ├───────────┤\n",
       " q4_6: ┤ Rx(0.202) ├\n",
       "       ├───────────┤\n",
       " q4_7: ┤ Rx(0.276) ├\n",
       "       ├───────────┤\n",
       " q4_8: ┤ Rx(0.222) ├\n",
       "       ├───────────┤\n",
       " q4_9: ┤ Rx(0.038) ├\n",
       "       └───────────┘\n",
       "q4_10: ─────────────\n",
       "       ┌───────────┐\n",
       "q4_11: ┤ Rx(0.147) ├\n",
       "       ├───────────┤\n",
       "q4_12: ┤ Rx(0.289) ├\n",
       "       ├───────────┤\n",
       "q4_13: ┤ Rx(0.188) ├\n",
       "       └───────────┘\n",
       "q4_14: ─────────────\n",
       "                    </pre>"
      ],
      "text/plain": [
       "       ┌───────────┐\n",
       " q4_0: ┤ Rx(0.011) ├\n",
       "       ├───────────┤\n",
       " q4_1: ┤ Rx(0.104) ├\n",
       "       ├───────────┤\n",
       " q4_2: ┤ Rx(0.194) ├\n",
       "       ├───────────┤\n",
       " q4_3: ┤ Rx(0.091) ├\n",
       "       ├───────────┤\n",
       " q4_4: ┤ Rx(0.018) ├\n",
       "       ├───────────┤\n",
       " q4_5: ┤ Rx(0.024) ├\n",
       "       ├───────────┤\n",
       " q4_6: ┤ Rx(0.202) ├\n",
       "       ├───────────┤\n",
       " q4_7: ┤ Rx(0.276) ├\n",
       "       ├───────────┤\n",
       " q4_8: ┤ Rx(0.222) ├\n",
       "       ├───────────┤\n",
       " q4_9: ┤ Rx(0.038) ├\n",
       "       └───────────┘\n",
       "q4_10: ─────────────\n",
       "       ┌───────────┐\n",
       "q4_11: ┤ Rx(0.147) ├\n",
       "       ├───────────┤\n",
       "q4_12: ┤ Rx(0.289) ├\n",
       "       ├───────────┤\n",
       "q4_13: ┤ Rx(0.188) ├\n",
       "       └───────────┘\n",
       "q4_14: ─────────────\n",
       "                    "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J = sample_img\n",
    "encode_qiskit(J).draw()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "circuit=encode_qiskit(J)\n",
    "\n",
    "#simulate circuit\n",
    "histogram=simulate(circuit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 28)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "images[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9999999938363309\n"
     ]
    }
   ],
   "source": [
    "\n",
    "n = len(images)\n",
    "mse=0\n",
    "gatecount=0\n",
    "\n",
    "for image in images[0:10]:\n",
    "    #encode image into circuit\n",
    "    #J = downsizing(image)\n",
    "    circuit=encode_qiskit(image)\n",
    "\n",
    "    #simulate circuit\n",
    "    histogram=simulate(circuit)\n",
    "\n",
    "    #count the number of 2-qubit gates\n",
    "    gatecount+=count_gates(circuit)[2]\n",
    "    #print(gatecount)\n",
    "\n",
    "    #reconstruct the image\n",
    "    image_re=decode(histogram)\n",
    "    #image_rec = reconstruction(downsizing(image))\n",
    "    #calculate mse\n",
    "    mse+=image_mse(np.asarray(image),image_re)\n",
    "#fidelity of reconstruction\n",
    "f=1-mse/n\n",
    "gatecount=gatecount/n\n",
    "\n",
    "#score for part1\n",
    "print(f*(0.999**gatecount))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = len(images)\n",
    "n_train = int(0.75*n)\n",
    "x_train = images[:n_train]\n",
    "x_test = images[n_train:]\n",
    "y_train = labels[:n_train]\n",
    "y_test = labels[n_train:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 507.852x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We now define a two qubit unitary as defined in [3]\n",
    "def conv_circuit(params):\n",
    "    target = QuantumCircuit(2)\n",
    "    target.rz(-np.pi / 2, 1)\n",
    "    target.cx(1, 0)\n",
    "    target.rz(params[0], 0)\n",
    "    target.ry(params[1], 1)\n",
    "    target.cx(0, 1)\n",
    "    target.ry(params[2], 1)\n",
    "    target.cx(1, 0)\n",
    "    target.rz(np.pi / 2, 0)\n",
    "    return target\n",
    "\n",
    "\n",
    "# Let's draw this circuit and see what it looks like\n",
    "params = ParameterVector(\"θ\", length=3)\n",
    "circuit = conv_circuit(params)\n",
    "circuit.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1591.6x565.88 with 1 Axes>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def conv_layer(num_qubits, param_prefix):\n",
    "    qc = QuantumCircuit(num_qubits, name=\"Convolutional Layer\")\n",
    "    qubits = list(range(num_qubits))\n",
    "    param_index = 0\n",
    "    params = ParameterVector(param_prefix, length=num_qubits * 3)\n",
    "    for q1, q2 in zip(qubits[0::2], qubits[1::2]):\n",
    "        qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])\n",
    "        qc.barrier()\n",
    "        param_index += 3\n",
    "    for q1, q2 in zip(qubits[1::2], qubits[2::2] + [0]):\n",
    "        qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])\n",
    "        qc.barrier()\n",
    "        param_index += 3\n",
    "\n",
    "    qc_inst = qc.to_instruction()\n",
    "\n",
    "    qc = QuantumCircuit(num_qubits)\n",
    "    qc.append(qc_inst, qubits)\n",
    "    return qc\n",
    "\n",
    "\n",
    "circuit = conv_layer(4, \"θ\")\n",
    "circuit.decompose().draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 387.452x144.48 with 1 Axes>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def pool_circuit(params):\n",
    "    target = QuantumCircuit(2)\n",
    "    target.rz(-np.pi / 2, 1)\n",
    "    target.cx(1, 0)\n",
    "    target.rz(params[0], 0)\n",
    "    target.ry(params[1], 1)\n",
    "    target.cx(0, 1)\n",
    "    target.ry(params[2], 1)\n",
    "\n",
    "    return target\n",
    "\n",
    "\n",
    "params = ParameterVector(\"θ\", length=3)\n",
    "circuit = pool_circuit(params)\n",
    "circuit.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 808.997x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def pool_layer(sources, sinks, param_prefix):\n",
    "    num_qubits = len(sources) + len(sinks)\n",
    "    qc = QuantumCircuit(num_qubits, name=\"Pooling Layer\")\n",
    "    param_index = 0\n",
    "    params = ParameterVector(param_prefix, length=num_qubits // 2 * 3)\n",
    "    for source, sink in zip(sources, sinks):\n",
    "        qc = qc.compose(pool_circuit(params[param_index : (param_index + 3)]), [source, sink])\n",
    "        qc.barrier()\n",
    "        param_index += 3\n",
    "\n",
    "    qc_inst = qc.to_instruction()\n",
    "\n",
    "    qc = QuantumCircuit(num_qubits)\n",
    "    qc.append(qc_inst, range(num_qubits))\n",
    "    return qc\n",
    "\n",
    "\n",
    "sources = [i for i in range(0,2)]\n",
    "sinks = [i for i in range(2,4)]\n",
    "circuit = pool_layer(sources, sinks, \"θ\")\n",
    "circuit.decompose().draw(\"mpl\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_dataset_2(images,labels):\n",
    "    n = len(images)\n",
    "    img = []\n",
    "    lab = []\n",
    "    for image in images:\n",
    "        img.append(255*downsizing_2(image.reshape((28,28))).reshape(-1))\n",
    "            \n",
    "    for label in labels:\n",
    "        lab.append(int(label))\n",
    "    return img,lab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "images, labels = generate_dataset_2(images,labels)\n",
    "\n",
    "train_images, test_images, train_labels, test_labels = train_test_split(\n",
    "    images, labels, test_size=0.3\n",
    ")\n",
    "\n",
    "#Let’s see some examples in our dataset\n",
    "\n",
    "fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={\"xticks\": [], \"yticks\": []})\n",
    "for i in range(4):\n",
    "    ax[i // 2, i % 2].imshow(\n",
    "        train_images[i].reshape(2, 2),  # Change back to 2 by 4\n",
    "        aspect=\"equal\",\n",
    "    )\n",
    "plt.subplots_adjust(wspace=0.1, hspace=0.025)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 327.397x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feature_map = ZFeatureMap(4)\n",
    "feature_map.decompose().draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_map = ZFeatureMap(4)\n",
    "\n",
    "ansatz = QuantumCircuit(4, name=\"Ansatz\")\n",
    "\n",
    "# First Convolutional Layer\n",
    "ansatz.compose(conv_layer(4, \"с1\"), list(range(4)), inplace=True)\n",
    "\n",
    "# First Pooling Layer\n",
    "ansatz.compose(pool_layer([i for i in range(0,2)], [i for i in range(2,4)], \"p1\"), list(range(4)), inplace=True)\n",
    "\n",
    "# Second Convolutional Layer\n",
    "ansatz.compose(conv_layer(2, \"с2\"), list(range(2,4)), inplace=True)\n",
    "\n",
    "# Second Pooling Layer\n",
    "ansatz.compose(pool_layer([0],[1], \"p2\"), list(range(2,4)), inplace=True)\n",
    "\n",
    "# Combining the feature map and ansatz\n",
    "circuit = QuantumCircuit(4)\n",
    "circuit.compose(feature_map, range(4), inplace=True)\n",
    "circuit.compose(ansatz, range(4), inplace=True)\n",
    "\n",
    "observable = SparsePauliOp.from_list([(\"Z\" + \"I\" * 3, 1)])\n",
    "\n",
    "# we decompose the circuit for the QNN to avoid additional data copying\n",
    "qnn = EstimatorQNN(\n",
    "    circuit=circuit.decompose(),\n",
    "    observables=observable,\n",
    "    input_params=feature_map.parameters,\n",
    "    weight_params=ansatz.parameters,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1411x264.88 with 1 Axes>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "circuit.draw(\"mpl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def callback_graph(weights, obj_func_eval):\n",
    "    clear_output(wait=True)\n",
    "    objective_func_vals.append(obj_func_eval)\n",
    "    plt.title(\"Objective function value against iteration\")\n",
    "    plt.xlabel(\"Iteration\")\n",
    "    plt.ylabel(\"Objective function value\")\n",
    "    plt.plot(range(len(objective_func_vals)), objective_func_vals)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = NeuralNetworkClassifier(\n",
    "    qnn,\n",
    "    optimizer=COBYLA(maxiter=100),  # Set max iterations here\n",
    "    callback=callback_graph,\n",
    "    #initial_point=initial_point,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.asarray(train_images)\n",
    "y = np.asarray(train_labels)\n",
    "\n",
    "objective_func_vals = []\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 6)\n",
    "classifier.fit(x, y)\n",
    "\n",
    "# score classifier\n",
    "print(f\"Accuracy from the train data : {np.round(100 * classifier.score(x, y), 2)}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_predict = classifier.predict(test_images)\n",
    "x = np.asarray(test_images)\n",
    "y = np.asarray(test_labels)\n",
    "print(f\"Accuracy from the test data : {np.round(100 * classifier.score(x, y), 2)}%\")\n",
    "\n",
    "# Let's see some examples in our dataset\n",
    "fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={\"xticks\": [], \"yticks\": []})\n",
    "for i in range(0, 4):\n",
    "    ax[i // 2, i % 2].imshow(test_images[i].reshape(2, 2), aspect=\"equal\")\n",
    "    if y_predict[i] == -1:\n",
    "        ax[i // 2, i % 2].set_title(\"The QCNN predicts this is a Horizontal Line\")\n",
    "    if y_predict[i] == +1:\n",
    "        ax[i // 2, i % 2].set_title(\"The QCNN predicts this is a Vertical Line\")\n",
    "plt.subplots_adjust(wspace=0.1, hspace=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#grade part 2\n",
    "\n",
    "#load classifier circuit\n",
    "classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n",
    "    \n",
    "score=0\n",
    "\n",
    "for data in dataset:\n",
    "    #encode image into circuit\n",
    "    circuit=encode_qiskit(data['image'])\n",
    "    \n",
    "    nq1 = circuit.width()\n",
    "    nq2 = classifier.width()\n",
    "    nq = max(nq1, nq2)\n",
    "    qc = qiskit.QuantumCircuit(nq)\n",
    "    qc.append(circuit.to_instruction(), list(range(nq1)))\n",
    "    qc.append(classifier.to_instruction(), list(range(nq2)))\n",
    "\n",
    "    gatecount+=count_gates(qc)[2]\n",
    "    \n",
    "    #simulate circuit\n",
    "    histogram=simulate(qc)\n",
    "    \n",
    "    #convert histogram to category\n",
    "    cat=histogram_to_category(histogram)\n",
    "    \n",
    "    \n",
    "    if cat==data['category']:\n",
    "        score+=1\n",
    "#score\n",
    "score=score/n\n",
    "gatecount=gatecount/n\n",
    "\n",
    "print(score*(0.999**gatecount))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}