From 020a64c8ea4511bff179e592a820395925cff4d3 Mon Sep 17 00:00:00 2001 From: mjk Date: Sun, 29 Jan 2023 00:11:42 -0500 Subject: [PATCH] added qiskit examples --- part1_example_qiskit.ipynb | 50 +++------- part2_example_qiskit.ipynb | 63 +++++-------- test_qiskit.py | 182 +++++++++++++++++++++++++++++++++++++ 3 files changed, 218 insertions(+), 77 deletions(-) create mode 100644 test_qiskit.py diff --git a/part1_example_qiskit.ipynb b/part1_example_qiskit.ipynb index c68c722..3c72b02 100644 --- a/part1_example_qiskit.ipynb +++ b/part1_example_qiskit.ipynb @@ -2,18 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Make sure to include this identifier at the beginning of your submission\n", - "teamname = 'your_team_name'\n", - "task = 'part 1'" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -75,22 +64,7 @@ "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)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "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)" + " return mean_squared_error(255*image1,255*image2)" ] }, { @@ -101,7 +75,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -110,7 +84,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -122,11 +96,13 @@ } ], "source": [ + "data_path='mock_data'\n", "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", + "images=np.load(data_path+'/images.npy')\n", + "labels=np.load(data_path+'/labels.npy')\n", "#you can visualize it\n", - "plt.imshow(images[1100])" + "import matplotlib.pyplot as plt\n", + "plt.imshow(images[1])" ] }, { @@ -137,7 +113,7 @@ "source": [ "#submission to part 1, you should make this into a .py file\n", "\n", - "n=len(dataset)\n", + "n=len(images)\n", "mse=0\n", "gatecount=0\n", "\n", @@ -185,11 +161,11 @@ "source": [ "#how we grade your submission\n", "\n", - "n=len(dataset)\n", + "n=len(images)\n", "mse=0\n", "gatecount=0\n", "\n", - "for data in dataset:\n", + "for data in images:\n", " #encode image into circuit\n", " circuit,image_re=run_part1(data['image'])\n", " \n", @@ -200,7 +176,7 @@ " mse+=image_mse(data['image'],image_re)\n", " \n", "#fidelity of reconstruction\n", - "f=1-mse\n", + "f=1-mse/n\n", "gatecount=gatecount/n\n", "\n", "#score for part1 \n", diff --git a/part2_example_qiskit.ipynb b/part2_example_qiskit.ipynb index 867ccd6..6a4e1d3 100644 --- a/part2_example_qiskit.ipynb +++ b/part2_example_qiskit.ipynb @@ -2,18 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Make sure to include this identifier at the beginning of your submission\n", - "teamname = 'your_team_name'\n", - "task = 'part 2'" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -75,35 +64,20 @@ "cell_type": "code", "execution_count": 2, "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": 3, - "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -115,17 +89,18 @@ } ], "source": [ + "data_path='mock_data'\n", "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", + "images=np.load(data_path+'/images.npy')\n", + "labels=np.load(data_path+'/labels.npy')\n", "#you can visualize it\n", "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" + "plt.imshow(images[1])" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +117,7 @@ "\n", "def run_part2(image):\n", "\n", - " #loade the quantum classifier circuit\n", + " #load the quantum classifier circuit\n", " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", " \n", " #encode image into circuit\n", @@ -161,6 +136,12 @@ " \n", " #convert histogram to category\n", " label=histogram_to_category(histogram)\n", + "\n", + " #thresholding the label, any way you want\n", + " if label>0.5:\n", + " label=1\n", + " else:\n", + " label=0\n", " \n", " return circuit,label\n", "#score" @@ -168,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -184,17 +165,19 @@ "\n", "score=0\n", "gatecount=0\n", - "n=len(dataset)\n", + "n=len(images)\n", "\n", - "for data in dataset:\n", + "for i in range(n):\n", " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", + " circuit,label=run_part2(images[i])\n", + " \n", + "\n", " \n", " #count the gate used in the circuit for score calculation\n", " gatecount+=count_gates(circuit)[2]\n", " \n", " #check label\n", - " if label==data['category']:\n", + " if label==labels[i]:\n", " score+=1\n", "#score\n", "score=score/n\n", diff --git a/test_qiskit.py b/test_qiskit.py new file mode 100644 index 0000000..ed25cd9 --- /dev/null +++ b/test_qiskit.py @@ -0,0 +1,182 @@ +import qiskit +from qiskit import quantum_info +from qiskit.execute_function import execute +from qiskit import BasicAer +import numpy as np +import pickle +import json +import os +import sys +from collections import Counter +from sklearn.metrics import mean_squared_error +from typing import Dict, List +import matplotlib.pyplot as plt + +if len(sys.argv) > 1: + data_path = sys.argv[1] +else: + data_path = '.' + +#define utility functions + +def simulate(circuit: qiskit.QuantumCircuit) -> dict: + """Simulate the circuit, give the state vector as the result.""" + backend = BasicAer.get_backend('statevector_simulator') + job = execute(circuit, backend) + result = job.result() + state_vector = result.get_statevector() + + histogram = dict() + for i in range(len(state_vector)): + population = abs(state_vector[i]) ** 2 + if population > 1e-9: + histogram[i] = population + + return histogram + + +def histogram_to_category(histogram): + """This function takes a histogram representation of circuit execution results, and processes into labels as described in + the problem description.""" + assert abs(sum(histogram.values())-1)<1e-8 + positive=0 + for key in histogram.keys(): + digits = bin(int(key))[2:].zfill(20) + if digits[-1]=='0': + positive+=histogram[key] + + return positive + +def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]: + """Returns the number of gate operations with each number of qubits.""" + counter = Counter([len(gate[1]) for gate in circuit.data]) + #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit + #for k>2 + for i in range(2,20): + assert counter[i]==0 + + return counter + + +def image_mse(image1,image2): + # Using sklearns mean squared error: + # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html + return mean_squared_error(255*image1,255*image2) + +def test(): + #load the actual hackthon data (fashion-mnist) + images=np.load(data_path+'/images.npy') + labels=np.load(data_path+'/labels.npy') + + #test part 1 + + n=len(images) + mse=0 + gatecount=0 + + for image in images: + #encode image into circuit + circuit,image_re=run_part1(image) + image_re = np.asarray(image_re) + + #count the number of 2qubit gates used + gatecount+=count_gates(circuit)[2] + + #calculate mse + mse+=image_mse(image,image_re) + + #fidelity of reconstruction + f=1-mse/n + gatecount=gatecount/n + + #score for part1 + score_part1=f*(0.999**gatecount) + + #test part 2 + + score=0 + gatecount=0 + n=len(images) + + for i in range(n): + #run part 2 + circuit,label=run_part2(images[i]) + + #count the gate used in the circuit for score calculation + gatecount+=count_gates(circuit)[2] + + #check label + if label==labels[i]: + score+=1 + #score + score=score/n + gatecount=gatecount/n + + score_part2=score*(0.999**gatecount) + + print(score_part1, ",", score_part2, ",", data_path, sep="") + + +############################ +# YOUR CODE HERE # +############################ +def encode(image): + q = qiskit.QuantumRegister(3) + circuit = qiskit.QuantumCircuit(q) + if image[0][0]==0: + circuit.rx(np.pi,0) + return circuit + +def decode(histogram): + if 1 in histogram.keys(): + image=[[0,0],[0,0]] + else: + image=[[1,1],[1,1]] + return image + +def run_part1(image): + #encode image into a circuit + circuit=encode(image) + + #simulate circuit + histogram=simulate(circuit) + + #reconstruct the image + image_re=decode(histogram) + + return circuit,image_re + +def run_part2(image): + # load the quantum classifier circuit + classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm') + + #encode image into circuit + circuit=encode(image) + + #append with classifier circuit + nq1 = circuit.width() + nq2 = classifier.width() + nq = max(nq1, nq2) + qc = qiskit.QuantumCircuit(nq) + qc.append(circuit.to_instruction(), list(range(nq1))) + qc.append(classifier.to_instruction(), list(range(nq2))) + + #simulate circuit + histogram=simulate(qc) + + #convert histogram to category + label=histogram_to_category(histogram) + + #thresholding the label, any way you want + if label>0.5: + label=1 + else: + label=0 + + return circuit,label + +############################ +# END YOUR CODE # +############################ + +test()