examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4d3113ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cirq\n",
    "import numpy as np\n",
    "import pickle\n",
    "import json\n",
    "import os\n",
    "from collections import Counter\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "#define utility functions\n",
    "\n",
    "def simulate(circuit: cirq.Circuit) -> dict:\n",
    "    \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n",
    "    \"\"\"\n",
    "    simulator = cirq.Simulator()\n",
    "    result = simulator.simulate(circuit)\n",
    "    \n",
    "    state_vector=result.final_state_vector\n",
    "    \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",
    "    \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n",
    "    the problem description.\"\"\"\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: cirq.Circuit):\n",
    "    \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n",
    "    counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n",
    "    \n",
    "    #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n",
    "    #for k>2\n",
    "    for i in range(2,20):\n",
    "        assert counter[i]==0\n",
    "        \n",
    "    return counter\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "82f90e0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#load the mock data (for testing only)\n",
    "files=os.listdir(\"mock_data\")\n",
    "dataset=list()\n",
    "for file in files:\n",
    "    with open('mock_data/'+file, \"r\") as infile:\n",
    "        loaded = json.load(infile)\n",
    "        dataset.append(loaded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cb96a334",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x1ae11fc42e0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#load the actual hackthon data (fashion-mnist)\n",
    "images=np.load('data/images.npy')\n",
    "labels=np.load('data/labels.npy')\n",
    "#you can visualize it\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(images[1100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b02b160e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "#grade part1\n",
    "from part1 import encode_cirq,decode\n",
    "\n",
    "n=len(dataset)\n",
    "mse=0\n",
    "gatecount=0\n",
    "\n",
    "for data in dataset:\n",
    "    #encode image into circuit\n",
    "    circuit=encode_cirq(data['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",
    "    \n",
    "    #reconstruct the image\n",
    "    image_re=decode(histogram)\n",
    "    \n",
    "    #calculate mse\n",
    "    mse+=image_mse(data['image'],image_re)\n",
    "    \n",
    "#fidelity of reconstruction\n",
    "f=1-mse\n",
    "gatecount=gatecount/n\n",
    "\n",
    "#score for part1 \n",
    "print(f*(0.999**gatecount))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2fe52c43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "#grade part 2\n",
    "\n",
    "#load classifier circuit\n",
    "with open('part2.pickle', 'rb') as f:\n",
    "    classifier=pickle.load(f)\n",
    "    \n",
    "score=0\n",
    "\n",
    "\n",
    "for data in dataset:\n",
    "    #encode image into circuit\n",
    "    circuit=encode_cirq(data['image'])\n",
    "    \n",
    "    #append with classifier circuit\n",
    "    \n",
    "    circuit.append(classifier)\n",
    "    \n",
    "    #simulate circuit\n",
    "    histogram=simulate(circuit)\n",
    "    \n",
    "    #count the gate used in the circuit for score calculation\n",
    "    gatecount+=count_gates(circuit)[2]\n",
    "    \n",
    "    #convert histogram to category\n",
    "    cat=histogram_to_category(histogram)\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,
   "id": "de96fdf1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.0 (main, Oct 25 2022, 14:13:24) [Clang 14.0.0 (clang-1400.0.29.202)]"
  },
  "vscode": {
   "interpreter": {
    "hash": "1a1af0ee75eeea9e2e1ee996c87e7a2b11a0bebd85af04bb136d915cefc0abce"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}