From 645d42f1a6d8e12133f6f8fbd55a14c586dd0ddc Mon Sep 17 00:00:00 2001 From: poig <43441314+poig@users.noreply.github.com> Date: Sun, 29 Jan 2023 23:00:31 +0800 Subject: [PATCH 1/6] t --- mock_data_creator.ipynb | 14 +- part1_example_cirq.ipynb | 14 +- part2_example_cirq.ipynb | 14 +- quantum_classifier.qasm | 5 +- .../Untitled-checkpoint.ipynb | 6 + .../submission_runner-checkpoint.ipynb | 1318 ++++++++++++++++ ...on_runner_realamp_spsa300-checkpoint.ipynb | 1368 +++++++++++++++++ .../submission_runner_v1-checkpoint.ipynb | 1267 +++++++++++++++ submission/submission_runner.ipynb | 1318 ++++++++++++++++ .../submission_runner_realamp_spsa300.ipynb | 1368 +++++++++++++++++ test_qiskit.py | 2 +- 11 files changed, 6652 insertions(+), 42 deletions(-) create mode 100644 submission/.ipynb_checkpoints/Untitled-checkpoint.ipynb create mode 100644 submission/.ipynb_checkpoints/submission_runner-checkpoint.ipynb create mode 100644 submission/.ipynb_checkpoints/submission_runner_realamp_spsa300-checkpoint.ipynb create mode 100644 submission/.ipynb_checkpoints/submission_runner_v1-checkpoint.ipynb create mode 100644 submission/submission_runner.ipynb create mode 100644 submission/submission_runner_realamp_spsa300.ipynb diff --git a/mock_data_creator.ipynb b/mock_data_creator.ipynb index 78ad064..4b97538 100644 --- a/mock_data_creator.ipynb +++ b/mock_data_creator.ipynb @@ -57,21 +57,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3 [Default]", "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.8.0" } }, "nbformat": 4, diff --git a/part1_example_cirq.ipynb b/part1_example_cirq.ipynb index a65faba..d491d40 100644 --- a/part1_example_cirq.ipynb +++ b/part1_example_cirq.ipynb @@ -216,21 +216,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3 [Default]", "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.8.0" } }, "nbformat": 4, diff --git a/part2_example_cirq.ipynb b/part2_example_cirq.ipynb index ffb99c4..289e3b9 100644 --- a/part2_example_cirq.ipynb +++ b/part2_example_cirq.ipynb @@ -211,21 +211,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python 3 [Default]", "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.8.0" } }, "nbformat": 4, diff --git a/quantum_classifier.qasm b/quantum_classifier.qasm index bad476c..fdddb61 100644 --- a/quantum_classifier.qasm +++ b/quantum_classifier.qasm @@ -1,4 +1,5 @@ OPENQASM 2.0; include "qelib1.inc"; -qreg q8[3]; -rx(pi) q8[0]; +gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.166885338964307) q0; ry(-0.562428401027246) q1; ry(0.48893589557941) q2; ry(1.0000212324066) q3; ry(0.997292670049591) q4; ry(0.516642028823444) q5; ry(-0.52976583280007) q6; ry(0.44621090925359) q7; ry(-0.812837886101786) q8; ry(0.00690999905273608) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.732554878640012) q0; ry(1.09250685549609) q1; ry(0.946119425708376) q2; ry(1.22520608932305) q3; ry(-0.256892484303682) q4; ry(0.849713315449811) q5; ry(-0.172935171560596) q6; ry(-0.792282689543016) q7; ry(0.105879168563046) q8; ry(0.451929686680044) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(-0.717816606765696) q0; ry(-0.406893365206504) q1; ry(0.786417140426462) q2; ry(0.715868574401998) q3; ry(1.68834007060239) q4; ry(0.16240900497929) q5; ry(0.021691745395356) q6; ry(-0.45492053378632) q7; ry(1.68422609585115) q8; ry(0.668468430274114) q9; } +qreg q[10]; +gate_RealAmplitudes(0.166885338964307,-0.562428401027246,0.48893589557941,1.0000212324066,0.997292670049591,0.516642028823444,-0.52976583280007,0.44621090925359,-0.812837886101786,0.00690999905273608,0.732554878640012,1.09250685549609,0.946119425708376,1.22520608932305,-0.256892484303682,0.849713315449811,-0.172935171560596,-0.792282689543016,0.105879168563046,0.451929686680044,-0.717816606765696,-0.406893365206504,0.786417140426462,0.715868574401998,1.68834007060239,0.16240900497929,0.021691745395356,-0.45492053378632,1.68422609585115,0.668468430274114) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9]; diff --git a/submission/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/submission/.ipynb_checkpoints/Untitled-checkpoint.ipynb new file mode 100644 index 0000000..7fec515 --- /dev/null +++ b/submission/.ipynb_checkpoints/Untitled-checkpoint.ipynb @@ -0,0 +1,6 @@ +{ + "cells": [], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/submission/.ipynb_checkpoints/submission_runner-checkpoint.ipynb b/submission/.ipynb_checkpoints/submission_runner-checkpoint.ipynb new file mode 100644 index 0000000..55a0832 --- /dev/null +++ b/submission/.ipynb_checkpoints/submission_runner-checkpoint.ipynb @@ -0,0 +1,1318 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "import qiskit\n", + "from typing import Dict, List\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "import pickle\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data_shape = X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "28*28" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " total_size = 2**int(np.ceil(np.log2(X_train[0].size)))\n", + " normalized_vector = [*normalized_vector, *np.zeros(total_size-len(normalized_vector))]\n", + " return normalized_vector\n", + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(\n", + " X_train[0], np.reshape(np.array(de_normalized_vector[:784]),data_shape), rtol=1e-2\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),data_shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import cv2\n", + "\n", + "def amplitude_encode(img, depth=11):\n", + " # Quantize image intensity values into depth levels\n", + " quantized = np.clip(np.round(img / (256 / depth)), 0, depth - 1).astype(np.uint8)\n", + " # Map quantized intensity levels to amplitude values\n", + " amplitudes = quantized * (256 / depth)\n", + " return amplitudes\n", + "\n", + "# Load an image\n", + "img = X_train[0]#cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\n", + "# Do amplitude encoding with a depth of 11\n", + "encoded = amplitude_encode(img, depth=11)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'numpy.float64' object cannot be interpreted as an integer", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[29], line 26\u001b[0m\n\u001b[0;32m 23\u001b[0m img \u001b[38;5;241m=\u001b[39m X_train[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;66;03m#.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\u001b[39;00m\n\u001b[0;32m 25\u001b[0m \u001b[38;5;66;03m# Cut the image into parts\u001b[39;00m\n\u001b[1;32m---> 26\u001b[0m parts \u001b[38;5;241m=\u001b[39m [img[i:i\u001b[38;5;241m+\u001b[39mpart_size, j:j\u001b[38;5;241m+\u001b[39mpart_size] \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpart_size\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 27\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, img\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], part_size)]\n\u001b[0;32m 29\u001b[0m \u001b[38;5;66;03m# Initialize the quantum circuit and registers\u001b[39;00m\n\u001b[0;32m 30\u001b[0m qr \u001b[38;5;241m=\u001b[39m QuantumRegister(n_qubits)\n", + "\u001b[1;31mTypeError\u001b[0m: 'numpy.float64' object cannot be interpreted as an integer" + ] + } + ], + "source": [ + "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", + "from qiskit import execute, Aer\n", + "import numpy as np\n", + "\n", + "# Function to angle encode a part of the image\n", + "def angle_encode_part(part, qc, qr, cr, n_qubits):\n", + " # Convert the part of the image to an angle value in radians\n", + " angle = 2 * np.pi * part / 256\n", + " # Apply the angle encoding using n_qubits qubits\n", + " for i in range(n_qubits):\n", + " qc.ry(angle, qr[i])\n", + " # Measure the qubits\n", + " for i in range(n_qubits):\n", + " qc.measure(qr[i], cr[i])\n", + "\n", + "# Define the number of qubits to use for each part\n", + "n_qubits = 4\n", + "\n", + "# Define the size of the parts\n", + "part_size = 28 // np.sqrt(n_qubits)\n", + "\n", + "# Load the image\n", + "img = X_train[0]#.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\n", + "\n", + "# Cut the image into parts\n", + "parts = [img[i:i+part_size, j:j+part_size] for i in range(0, img.shape[0], part_size)\n", + " for j in range(0, img.shape[1], part_size)]\n", + "\n", + "# Initialize the quantum circuit and registers\n", + "qr = QuantumRegister(n_qubits)\n", + "cr = ClassicalRegister(n_qubits)\n", + "qc = QuantumCircuit(qr, cr)\n", + "\n", + "# Loop over each part and apply angle encoding\n", + "for part in parts:\n", + " angle_encode_part(part, qc, qr, cr, n_qubits)\n", + "\n", + "# Execute the circuit on a simulator\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(qc, backend, shots=1)\n", + "result = job.result()\n", + "\n", + "# Collect the results\n", + "encoded_parts = [int(''.join([str(x) for x in result.get_counts(i).keys()]), 2)\n", + " for i in range(len(parts))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#scaler.inverse_transform(scaler.transform(X_train[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend,optimization_level=0,shots=1024)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\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" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#histogram = simulate(qc.bind_parameters(normalized_vector))\n", + "#print(histogram)\n", + "#new_histogram = {}\n", + "#\n", + "#for key in range(len(qc.parameters)):\n", + "# if key in histogram:\n", + "# new_histogram[key] = histogram[key]\n", + "# else:\n", + "# new_histogram[key] = 0\n", + "#print(new_histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#import matplotlib.pyplot as plt\n", + "#after_ = np.array(list(new_histogram.values())[:784])\n", + "#plt.imshow(np.reshape(after_,data_shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#de_normalized_vector = de_normalize(after_,X_train[0])\n", + "#plt.imshow(np.reshape(after_,data_shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import StatePreparation\n", + "def encode_qiskit(x,num_qubit=10):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit) #\n", + " qc = qc.bind_parameters(normalized_vector)\n", + " return qc\n", + "\n", + "def decode(histogram,data):\n", + " new_histogram = {}\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values()))\n", + " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 2.53682360e-04 0.00000000e+00 0.00000000e+00 4.28723188e-02\n", + " 1.35187330e+00 0.00000000e+00 0.00000000e+00 2.53682360e-04\n", + " 4.05891776e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.53682360e-04 2.53682360e-04 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 2.28314124e-03 0.00000000e+00 3.28772339e-01 4.69210893e+00\n", + " 4.09164279e+00 9.75154992e-01 7.39737762e-01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 2.53682360e-04 2.28314124e-03\n", + " 4.05891776e-03 0.00000000e+00 0.00000000e+00 2.28314124e-03]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 9.13256496e-03 0.00000000e+00 2.63931127e+00 1.05572451e+01\n", + " 7.85806478e+00 4.55512046e+00 5.26035742e+00 3.83796043e+00\n", + " 1.34197968e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 3.65302598e-02 2.53682360e-02 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 6.09471870e+00 1.41290927e+01\n", + " 1.08700354e+01 8.03767190e+00 2.90440934e+00 6.17361391e+00\n", + " 6.57570045e+00 3.01400012e+00 1.03908295e+00 1.34197968e-01\n", + " 1.50408271e+00 4.28723188e+00 1.31508935e+00 5.70785310e-02]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 2.53682360e-04\n", + " 0.00000000e+00 1.20778172e+00 1.08700354e+01 1.26153701e+01\n", + " 1.20560005e+01 1.18358042e+01 1.18358042e+01 6.74008662e+00\n", + " 4.09164279e+00 3.71416343e+00 3.77580825e+00 5.40749319e+00\n", + " 5.04345900e+00 1.96451620e+00 7.50493894e+00 1.10504036e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.53682360e-04 2.53682360e-04 2.53682360e-04\n", + " 0.00000000e+00 1.01472944e+01 1.36541993e+01 1.36541993e+01\n", + " 1.37721616e+01 1.33033566e+01 1.26153701e+01 1.26153701e+01\n", + " 1.17264671e+01 1.15093150e+01 6.82304076e+00 4.09164279e+00\n", + " 3.83796043e+00 9.74546154e+00 1.33033566e+01 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 8.49556856e+00 1.28426695e+01 1.18358042e+01\n", + " 1.26153701e+01 1.31874238e+01 1.40096083e+01 1.30719983e+01\n", + " 1.27287661e+01 1.25024814e+01 1.27287661e+01 1.23901001e+01\n", + " 1.26153701e+01 1.52272837e+01 7.59245935e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.44941423e+00 1.31874238e+01 1.20560005e+01\n", + " 1.15093150e+01 9.94536324e+00 8.21930847e+00 1.14015000e+01\n", + " 1.11873921e+01 1.12941924e+01 1.15093150e+01 1.26153701e+01\n", + " 1.22782262e+01 1.49796897e+01 1.03512550e+01 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.53682360e-04 2.28314124e-03 0.00000000e+00\n", + " 3.65302598e-02 1.21668597e+01 1.22782262e+01 1.14015000e+01\n", + " 1.20560005e+01 9.35174652e+00 7.24542189e+00 1.30719983e+01\n", + " 1.09753136e+01 1.20560005e+01 1.27287661e+01 1.14015000e+01\n", + " 1.29570802e+01 9.84515871e+00 1.10810992e+01 6.85957102e-01]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 9.13256496e-03 0.00000000e+00\n", + " 2.48634081e+00 1.51032330e+01 1.25024814e+01 1.22782262e+01\n", + " 1.20560005e+01 1.04539964e+01 9.94536324e+00 1.23901001e+01\n", + " 1.17264671e+01 1.15093150e+01 1.25024814e+01 1.22782262e+01\n", + " 1.52272837e+01 3.59239590e+00 7.07494734e+00 7.95547881e-01]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 4.05891776e-03 0.00000000e+00 0.00000000e+00\n", + " 7.67389139e-01 1.41290927e+01 1.31874238e+01 1.34197968e+01\n", + " 1.31874238e+01 1.46121039e+01 1.36541993e+01 1.15093150e+01\n", + " 1.20560005e+01 1.26153701e+01 1.38906313e+01 1.19456487e+01\n", + " 1.19456487e+01 1.10810992e+01 2.14716750e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 2.53682360e-04 4.05891776e-03\n", + " 9.13256496e-03 1.24304356e-02 1.01472944e-03 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.42490845e+01 1.29570802e+01 1.19456487e+01 1.26153701e+01\n", + " 1.25024814e+01 1.21668597e+01 1.25024814e+01 1.23901001e+01\n", + " 1.18358042e+01 1.26153701e+01 1.33033566e+01 1.17264671e+01\n", + " 1.20560005e+01 1.64956955e+01 1.50408271e+00 0.00000000e+00]\n", + " [0.00000000e+00 2.28314124e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.75154992e-01 5.33367162e+00 1.05572451e+01\n", + " 1.31874238e+01 1.08700354e+01 1.15093150e+01 1.23901001e+01\n", + " 1.20560005e+01 1.09753136e+01 1.12941924e+01 1.20560005e+01\n", + " 1.27287661e+01 1.26153701e+01 1.21668597e+01 1.17264671e+01\n", + " 1.27287661e+01 1.51032330e+01 6.41334374e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 8.21930847e-02 4.91129049e-01 1.70576019e+00 2.90440934e+00\n", + " 9.06178758e+00 1.31874238e+01 1.22782262e+01 1.25024814e+01\n", + " 1.19456487e+01 1.29570802e+01 1.01472944e+01 1.06610012e+01\n", + " 1.12941924e+01 1.34197968e+01 1.27287661e+01 1.38906313e+01\n", + " 7.85806478e+00 8.96614933e+00 1.58551475e+01 1.56024799e+01\n", + " 1.37721616e+01 1.43695836e+01 1.17264671e+01 0.00000000e+00]\n", + " [0.00000000e+00 8.24213988e-01 8.87101845e+00 1.09753136e+01\n", + " 1.27287661e+01 1.23901001e+01 1.27287661e+01 1.09753136e+01\n", + " 1.05572451e+01 1.16176374e+01 1.09753136e+01 1.10810992e+01\n", + " 1.01472944e+01 6.41334374e+00 1.52272837e+01 9.44941423e+00\n", + " 1.07652646e+01 1.26153701e+01 1.64956955e+01 1.64956955e+01\n", + " 1.23901001e+01 1.38906313e+01 1.23901001e+01 1.12941924e+01\n", + " 1.22782262e+01 1.36541993e+01 1.53518417e+01 0.00000000e+00]\n", + " [2.28314124e-03 1.03512550e+01 1.31874238e+01 1.27287661e+01\n", + " 1.23901001e+01 1.12941924e+01 1.12941924e+01 1.16176374e+01\n", + " 1.06610012e+01 1.06610012e+01 1.06610012e+01 1.22782262e+01\n", + " 1.46121039e+01 1.62356710e+00 5.70785310e+00 1.64956955e+01\n", + " 1.33033566e+01 1.23901001e+01 8.96614933e+00 6.01633085e+00\n", + " 9.25458618e+00 1.11873921e+01 1.05572451e+01 1.10810992e+01\n", + " 1.25024814e+01 1.31874238e+01 1.28426695e+01 0.00000000e+00]\n", + " [2.43636539e+00 1.37721616e+01 9.94536324e+00 1.11873921e+01\n", + " 1.25024814e+01 1.33033566e+01 1.33033566e+01 1.38906313e+01\n", + " 1.57285600e+01 1.22782262e+01 9.54758930e+00 1.17264671e+01\n", + " 1.19456487e+01 1.47341252e+01 1.07180797e+00 1.35187330e+00\n", + " 2.85037500e+00 3.47265783e+00 7.15993093e+00 1.21668597e+01\n", + " 1.23901001e+01 1.17264671e+01 1.19456487e+01 1.26153701e+01\n", + " 1.26153701e+01 1.27287661e+01 1.33033566e+01 2.13346865e-01]\n", + " [1.42696328e+00 1.05572451e+01 1.14015000e+01 1.05572451e+01\n", + " 9.44941423e+00 1.06610012e+01 1.12941924e+01 1.28426695e+01\n", + " 1.18358042e+01 8.68227877e+00 9.84515871e+00 1.07652646e+01\n", + " 9.94536324e+00 1.15093150e+01 1.46121039e+01 9.64627174e+00\n", + " 1.30719983e+01 1.52272837e+01 1.44905901e+01 1.26153701e+01\n", + " 1.20560005e+01 1.14015000e+01 1.10810992e+01 1.25024814e+01\n", + " 1.22782262e+01 1.23901001e+01 1.34197968e+01 1.13878011e+00]\n", + " [5.84484158e-01 1.04539964e+01 8.49556856e+00 9.54758930e+00\n", + " 1.15093150e+01 9.84515871e+00 8.68227877e+00 9.15793320e+00\n", + " 9.54758930e+00 9.35174652e+00 1.03512550e+01 1.16176374e+01\n", + " 1.21668597e+01 1.23901001e+01 1.22782262e+01 1.41290927e+01\n", + " 1.28426695e+01 1.18358042e+01 1.00460751e+01 1.07652646e+01\n", + " 8.77639493e+00 8.31088780e+00 7.94761466e+00 7.50493894e+00\n", + " 8.31088780e+00 1.06610012e+01 1.07652646e+01 3.35494921e+00]\n", + " [0.00000000e+00 3.77580825e+00 1.21668597e+01 9.44941423e+00\n", + " 8.12823650e+00 7.41792589e+00 8.49556856e+00 9.74546154e+00\n", + " 1.05572451e+01 1.11873921e+01 1.15093150e+01 1.08700354e+01\n", + " 1.12941924e+01 1.11873921e+01 1.01472944e+01 9.74546154e+00\n", + " 9.54758930e+00 9.25458618e+00 9.64627174e+00 9.25458618e+00\n", + " 9.94536324e+00 9.35174652e+00 7.85806478e+00 6.17361391e+00\n", + " 7.07494734e+00 7.94761466e+00 1.11873921e+01 2.14716750e+00]\n", + " [0.00000000e+00 0.00000000e+00 1.38916460e+00 9.06178758e+00\n", + " 1.14015000e+01 9.25458618e+00 7.76902228e+00 7.50493894e+00\n", + " 7.76902228e+00 8.31088780e+00 8.68227877e+00 8.96614933e+00\n", + " 9.06178758e+00 8.96614933e+00 9.44941423e+00 9.94536324e+00\n", + " 1.05572451e+01 1.10810992e+01 1.11873921e+01 1.11873921e+01\n", + " 1.12941924e+01 8.96614933e+00 8.96614933e+00 9.54758930e+00\n", + " 9.35174652e+00 1.18358042e+01 7.33142021e+00 0.00000000e+00]\n", + " [1.01472944e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.10504036e+00 1.01472944e+01 1.25024814e+01 1.42490845e+01\n", + " 1.44905901e+01 1.48566537e+01 1.53518417e+01 1.49796897e+01\n", + " 1.51032330e+01 1.23901001e+01 1.22782262e+01 9.44941423e+00\n", + " 9.25458618e+00 8.12823650e+00 8.40297449e+00 8.40297449e+00\n", + " 8.31088780e+00 7.85806478e+00 6.99047111e+00 7.15993093e+00\n", + " 2.48634081e+00 8.53387459e-01 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 4.05891776e-01\n", + " 9.43952062e-01 4.91129049e-01 1.31508935e+00 4.26440047e-01\n", + " 3.10760891e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]]\n", + "-17758.718677708395\n" + ] + } + ], + "source": [ + "#grade part1\n", + "#from part1 import encode_qiskit,decode\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "dataset = X_train[:1]\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_qiskit(data)\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + " \n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #reconstruct \n", + " image_re=decode(histogram,data)\n", + " print(image_re)\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(np.asarray(data),np.asarray(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))\n", + "# score should be between 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def multiply_by_51(lst):\n", + " new_list = []\n", + " for element in lst:\n", + " new_list.append(element * 51)\n", + " return new_list" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "list(list(de_normalize(image_re,data)[:784]))\n", + "plt.imshow(np.reshape(multiply_by_51(list(de_normalize(image_re,data)[:784])),data_shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "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": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_machine_learning.algorithms.classifiers import VQC\n", + "from qiskit.algorithms.optimizers import SPSA\n", + "vqc = VQC(\n", + " feature_map=qc,\n", + " ansatz=ansatz,\n", + " loss=\"cross_entropy\",\n", + " optimizer=COBYLA(maxiter=100),\n", + " quantum_instance=Aer.get_backend('statevector_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time elapsed: 1189.4153316020966\n" + ] + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.4" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.266317714019139) q0; ry(1.32035044188513) q1; ry(0.375724625916453) q2; ry(-0.145527578194223) q3; ry(1.24796981173025) q4; ry(-0.3722525242738) q5; ry(0.98731246639232) q6; ry(1.98782341512519) q7; ry(1.66430495324693) q8; ry(0.760045740348774) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.76943425343952) q0; ry(1.54002486179664) q1; ry(1.5166941190635) q2; ry(2.08820456685236) q3; ry(0.502872321522427) q4; ry(0.5226897740692) q5; ry(1.34895736320983) q6; ry(0.17808386546728) q7; ry(1.48787325816064) q8; ry(1.19251464386051) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.63207747410879) q0; ry(0.944742510667842) q1; ry(1.4738548596109) q2; ry(0.0395594736234817) q3; ry(0.160988017972572) q4; ry(-0.139909848244233) q5; ry(0.217661325699283) q6; ry(1.51612158505368) q7; ry(0.709288700436131) q8; ry(2.00665865500557) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.266317714019139,1.32035044188513,0.375724625916453,-0.145527578194223,1.24796981173025,-0.3722525242738,0.98731246639232,1.98782341512519,1.66430495324693,0.760045740348774,1.76943425343952,1.54002486179664,1.5166941190635,2.08820456685236,0.502872321522427,0.5226897740692,1.34895736320983,0.17808386546728,1.48787325816064,1.19251464386051,1.63207747410879,0.944742510667842,1.4738548596109,0.0395594736234817,0.160988017972572,-0.139909848244233,0.217661325699283,1.51612158505368,0.709288700436131,2.00665865500557) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# todo: histogram_to_category\n", + "#def histogram_to_category():\n" + ] + }, + { + "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))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ionq", + "language": "python", + "name": "ionq" + }, + "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.10.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "133691b27fa14898ae18af0787aeaef9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_325f0396d7b9410bba8021bbe35f813a", + "style": "IPY_MODEL_5488374837ae4a9284ee055d8e6dc4ca", + "value": "
Backend
" + } + }, + "14a021df54ea41dd800c6d49a1fb3ba9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "14b920e77c4046b2b739ce5e65ba6c87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_a42326a6516c48c9b45a061832e1b9e4", + "IPY_MODEL_133691b27fa14898ae18af0787aeaef9", + "IPY_MODEL_d36e5003b5bb4905b2f34cc06dab577e", + "IPY_MODEL_8b5e3e1c7c8b478eadaddcebb1bab545", + "IPY_MODEL_29e0bc1980f04ee5a4de1c3353ca43e1" + ], + "layout": "IPY_MODEL_95dbd7627f214404917e790abc4a0bac" + } + }, + "1a8a97e4934d4946b30b1b3ea93a6488": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "29e0bc1980f04ee5a4de1c3353ca43e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_14a021df54ea41dd800c6d49a1fb3ba9", + "style": "IPY_MODEL_7cc1a68d44ca46bdaf3b815627f44cb2", + "value": "
Message
" + } + }, + "325f0396d7b9410bba8021bbe35f813a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "4de8f8e67ba84e68acc93c41fb388ea3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a14371b37a3941f991ce693be9cd4d38", + "style": "IPY_MODEL_5be42b0bad7e42a99d879056ebabf46d", + "value": "

Circuit Properties

" + } + }, + "5488374837ae4a9284ee055d8e6dc4ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5be42b0bad7e42a99d879056ebabf46d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "7695b5f41549481193e03d22f11ad7be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "7cc1a68d44ca46bdaf3b815627f44cb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "8b5e3e1c7c8b478eadaddcebb1bab545": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d04bd44ae10f4782855b04d120889b06", + "style": "IPY_MODEL_c6c8b591acda4e488e8afb052f4fe29b", + "value": "
Queue
" + } + }, + "95dbd7627f214404917e790abc4a0bac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "a14371b37a3941f991ce693be9cd4d38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "a42326a6516c48c9b45a061832e1b9e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_1a8a97e4934d4946b30b1b3ea93a6488", + "style": "IPY_MODEL_e09458876777468d80ebae8aaa409834", + "value": "
Job ID
" + } + }, + "c6c8b591acda4e488e8afb052f4fe29b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "cc709643ef9d420387ecaf1e16125ec3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_f2c63bb964454e8f8d97f39429d02343" + ], + "layout": "IPY_MODEL_db133fac447c42cba07b68d7bf884952" + } + }, + "d04bd44ae10f4782855b04d120889b06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "d36e5003b5bb4905b2f34cc06dab577e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fb539075b7f042f9bdd58552f7479014", + "style": "IPY_MODEL_7695b5f41549481193e03d22f11ad7be", + "value": "
Status
" + } + }, + "db133fac447c42cba07b68d7bf884952": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "e09458876777468d80ebae8aaa409834": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "f1ebeebc10804474ab5638703d2165ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "f2c63bb964454e8f8d97f39429d02343": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_fd52f04fbda04dcdbb42cc4a48af47bc", + "style": "IPY_MODEL_f1ebeebc10804474ab5638703d2165ee" + } + }, + "fb539075b7f042f9bdd58552f7479014": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "fd52f04fbda04dcdbb42cc4a48af47bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/submission/.ipynb_checkpoints/submission_runner_realamp_spsa300-checkpoint.ipynb b/submission/.ipynb_checkpoints/submission_runner_realamp_spsa300-checkpoint.ipynb new file mode 100644 index 0000000..4a155d6 --- /dev/null +++ b/submission/.ipynb_checkpoints/submission_runner_realamp_spsa300-checkpoint.ipynb @@ -0,0 +1,1368 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-01-29 12:25:25.456820: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-01-29 12:25:25.593958: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2023-01-29 12:25:25.593990: I tensorflow/compiler/xla/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", + "2023-01-29 12:25:26.611421: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n", + "2023-01-29 12:25:26.611602: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n", + "2023-01-29 12:25:26.611622: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n" + ] + } + ], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "import pickle\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(28, 28)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(np.ceil(np.log2(X_train.size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros(int(np.ceil(np.log2(X_train.size))))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " total_size = 2**int(np.ceil(np.log2(X_train[0].size)))\n", + " normalized_vector = [*normalized_vector, *np.zeros(total_size-len(normalized_vector))]\n", + " return normalized_vector" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n", + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[1;36m Input \u001b[1;32mIn [12]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", + "\u001b[1;33m display(plt.imshow(X_train[0]))\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m\u001b[1;31m:\u001b[0m name 'plt' is not defined\n", + "\n", + "Use %tb to get the full traceback.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAUFElEQVR4nO3da2yc1ZkH8P8z4/ElzjiJk+CE4BIuoZDCEqhJuIlSKDREVQOli4gQC1K0QbvQbbt8ANGuyn5ZIbSA0LLbXQNZwqpQtSoIiiIKmEsWKGlMSHPdEEgcEuPYTkxsx/HYc3n2g1+oCT7Pa+adGzn/n2R5PM+cmeMZ//3OzJlzjqgqiOj4Fyt3B4ioNBh2Ik8w7ESeYNiJPMGwE3miqpQ3Vi01Wov6Ut4kkVdSGMKojshEtUhhF5GlAB4GEAfwmKreZ12+FvVYIldGuUkiMqzXNmct76fxIhIH8O8ArgGwEMAKEVmY7/URUXFFec2+GMAHqrpbVUcB/BrA8sJ0i4gKLUrY5wHYN+7n/cF5nyMiq0SkXUTa0xiJcHNEFEXR341X1VZVbVHVlgRqin1zROQQJeydAJrH/XxScB4RVaAoYd8AYIGInCIi1QBuBPB8YbpFRIWW99CbqmZE5A4Af8DY0NtqVd1WsJ4RUUFFGmdX1bUA1haoL0RURPy4LJEnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeaKkS0lTGciEqwr/RcSNPeMzG836J989w1lreOqdSLcd9rtJVcJZ0/RotNuOKuxxseT5mPHITuQJhp3IEww7kScYdiJPMOxEnmDYiTzBsBN5guPsxzmJx826ZjJmPbbI3qtzx21T7fbD7lpiaLHZtmo4Z9YTL7Wb9Uhj6WFj+CH3K8Q+jkbpm1QZsTUeTh7ZiTzBsBN5gmEn8gTDTuQJhp3IEww7kScYdiJPcJz9OGeOySJ8nH3fd6eb9Zsu+l+z/lbvqc7a3po5ZlutM8uo+s5FZv2M/+h01jIdH9lXHjJnPOx+CxOfMcNdzGbNttmBAXfR6HaksItIB4BBAFkAGVVtiXJ9RFQ8hTiyf1tVDxbgeoioiPiancgTUcOuAF4SkXdFZNVEFxCRVSLSLiLtaYxEvDkiylfUp/GXqmqniJwA4GUR+T9VXTf+AqraCqAVABqkMdrqhkSUt0hHdlXtDL73AHgWgD2NiYjKJu+wi0i9iCQ/PQ3gagBbC9UxIiqsKE/jmwA8K2PzfqsAPKWqLxakV1QwuVQqUvvR846Y9R9Os+eU18bSztobMXu+euerzWY9+1d23/Y+mHTWcu9dbLadudUe6254r8usH7xsnlnv/ab7FW1TyHL6M1750FmTPnek8w67qu4GcG6+7YmotDj0RuQJhp3IEww7kScYdiJPMOxEnhCNuGXvl9EgjbpErizZ7XnDWvY45PE9csOFZv2an79u1s+q/disD+ZqnbVRjfYBzkd2fsusD+2e5qzFRkO2TA4pZ5vspaA1bR9HZ2x0/+51y7vNtvLobGdtc9vDONK3b8Le88hO5AmGncgTDDuRJxh2Ik8w7ESeYNiJPMGwE3mC4+yVIGR74EhCHt+z37X/3/9ghj2FNUzcWNt4SKvNtoez9ZFuuzfjnuKaDhnjf2yXPQX2iDGGDwCxjP2YXvXt95y16xs3mG3vP+0cZ229tmFA+zjOTuQzhp3IEww7kScYdiJPMOxEnmDYiTzBsBN5gls2V4ISftbhWLuOnGDWDzVMNesHMtPN+sy4e7nnZGzYbDs/Ye8X2pt1j6MDQDzhXqp6VONm23/+xu/NeuqshFlPiL0U9cXGOgB/vf1vzLb12G3WXXhkJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wXF2z82usbc9rhX3lssAUC0Zs/5xeoaztmv462bb9wfszwAsbdpm1tPGWLo1zx4IHyc/MfGJWU+pPQ5v3auXNNnj6JvMqlvokV1EVotIj4hsHXdeo4i8LCK7gu/uR5SIKsJknsY/AWDpMefdDaBNVRcAaAt+JqIKFhp2VV0HoO+Ys5cDWBOcXgPg2sJ2i4gKLd/X7E2q2hWcPgCgyXVBEVkFYBUA1GJKnjdHRFFFfjdex1asdL7boaqtqtqiqi0J1ES9OSLKU75h7xaRuQAQfO8pXJeIqBjyDfvzAG4JTt8C4LnCdIeIiiX0NbuIPA3gcgCzRGQ/gF8AuA/Ab0RkJYC9AG4oZiePeyHrxkvcnnutGfdYd3yGPSr6relbzHpvtsGsH87a78NMjx911gYz7r3bAaBv2L7uM2u6zPrGo/OdtdnV9ji51W8A6BidZdYX1Bww6/d3u/dPaK499v3wz8tceZmzpuv/6KyFhl1VVzhK3O2B6CuEH5cl8gTDTuQJhp3IEww7kScYdiJPcIprJQhZSlqq7IfJGnrbt/Iss+0VU+wlk99OzTPrs6sGzbo1zXRuTb/ZNtmUMuthw36NVe7pu4PZOrPtlNiIWQ/7vc+vtpfB/ukr5ztrybMPmW0bEsYx2hjF5ZGdyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEx9krgCSqzXouZY83W2ZtGTXrB7P2ksfTY/ZUz+qQJZetrZEvbtxjtu0NGQvfOHyKWU/G3VtCz47Z4+TNCXuse0uq2ayvHTrdrK/83ivO2tOtV5ltq19821kTdT9ePLITeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ74ao2zG0suS5U9XizxkP9rMbueSxnzm3P2WHMYTdtj4VE8/F+PmPV9melm/UDaroctuZw1Jli/MzzNbFsbs7eLnl01YNYHcvY4vWUwZy9zbc3TB8L7ftfMXc7aM/3fMdvmi0d2Ik8w7ESeYNiJPMGwE3mCYSfyBMNO5AmGncgTFTXOHmV99LCxarWHPctqePlis77vWnsc/6bz/uSsHcgkzbbvGdsaA8A0Y044ANSHrK+eUvfnHz4etbeTDhurttaFB4ATjHH4rNrHuc603bcwYZ8/2J8x1rT/vj3XfvqTeXUp/MguIqtFpEdEto47714R6RSRTcHXsvxunohKZTJP458AsHSC8x9S1UXB19rCdouICi007Kq6DkBfCfpCREUU5Q26O0Rkc/A03/kCR0RWiUi7iLSnYb++I6LiyTfsvwRwGoBFALoAPOC6oKq2qmqLqrYkUJPnzRFRVHmFXVW7VTWrqjkAjwKw304morLLK+wiMnfcj9cB2Oq6LBFVhtBxdhF5GsDlAGaJyH4AvwBwuYgsAqAAOgDcVojOWOPoUVXNnWPW06c0mfW+s9x7gR+dY2yKDWDRsh1m/dam/zbrvdkGs54QY3/29Eyz7XlTOsz6q/0LzfrBqqlm3Rqnv7jePacbAA7n7P3XT6z6xKzf9cEPnbWmKfZY9mMn2wNMac2Z9Z1p+yVrf849H/4fFr5mtn0Ws826S2jYVXXFBGc/ntetEVHZ8OOyRJ5g2Ik8wbATeYJhJ/IEw07kiYqa4jpyzQVm/YSf7XbWFjXsN9surHvTrKdy9lLU1nTL7cPzzLZHc/aWzLtG7WHB/ow9BBUX9zBQz6g9xfWBPfayxW2L/9Os//zjieZI/UWsTp21Q1l72O76qfZS0YD9mN32tXXO2qnVPWbbF4bmmvWPQ6bANiX6zfr8RK+z9oPk+2bbfIfeeGQn8gTDTuQJhp3IEww7kScYdiJPMOxEnmDYiTxR2nF2sZeLXvIvG8zmVya3OWtH1Z5SGDaOHjZuaplWZS8bPJK27+aetD2FNcwZNQectesaNplt1z2yxKxfmvqRWf/wCnt6btuweypnb8b+vW/cc4VZ3/hRs1m/cP4eZ+2cZKfZNuyzDcl4yqxb044BYCjn/nt9J2V//iBfPLITeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ4QVfd840Krm9Osp938j8566+3/ZrZ/qu9CZ6251t6O7uTqg2Z9Ztze/teSjNljrl9P2GOuLwydZNZfP3ymWf9mssNZS4i93fPlUz4w67f+9E6znqm1l9EemO8+nmTq7b+9hnMPmfUfnf6qWa82fvfDWXscPex+C9uSOYy1BkEyZm+T/cCy65y1P3Y8gf7hrgkfFB7ZiTzBsBN5gmEn8gTDTuQJhp3IEww7kScYdiJPlHQ+eywNTOl2jy++MLDIbH9qnXut7YNpe330Pxw5x6yfVGdv/2ttPXy6MZ8cADalppv1F3u/YdZPrLPXT+9OT3PWDqXrzbZHjXnVAPD4Qw+a9Qe67XXnr2vc6KydW22Pox/O2cei7SHr7Q/map21lNrrG/SHjMMnjb8HAEirHa24seXz9Jg9hj9wjnsb7my3+3ZDj+wi0iwir4nIdhHZJiI/Ds5vFJGXRWRX8D3/1R+IqOgm8zQ+A+BOVV0I4EIAt4vIQgB3A2hT1QUA2oKfiahChYZdVbtUdWNwehDADgDzACwHsCa42BoA1xapj0RUAF/qDToRmQ/gPADrATSpaldQOgCgydFmlYi0i0h7ZmQoSl+JKIJJh11EpgL4HYCfqOrn3jHSsdk0E85qUNVWVW1R1ZaqGvvNIiIqnkmFXUQSGAv6r1T1meDsbhGZG9TnArC3xSSisgodehMRAfA4gB2qOn4c5nkAtwC4L/j+XNh1xUdzSO4bcdZzak+XfPWge6pnU+2g2XZRcp9Z33nUHsbZMnyis7ax6mtm27q4e7tnAJhWbU+Rra9y32cAMCvh/t1PqbH/B1vTQAFgQ8r+3f5u9utm/aOMe5Dm90NnmG23H3Xf5wAwI2QJ7y0D7vZHM/Y22iNZOxqpjD2UO63GfkwvaNzrrO2EvV1077nGtOG33O0mM85+CYCbAWwRkU3BefdgLOS/EZGVAPYCuGES10VEZRIadlV9E4DrkHtlYbtDRMXCj8sSeYJhJ/IEw07kCYadyBMMO5EnSrtl85FhxN54z1n+7UuXmM3/aflvnbU3QpZbfuGAPS46MGpP9Zw9xf1R3wZjnBsAGhP2x4TDtnyuDdn+95OM+5OJIzF7KmfWOdAy5sCIe/osALyVW2DW0zn3ls0jRg0I/3xC3+gss35iXb+zNphxT38FgI7BRrN+sN/eVjk1xY7Wm9nTnLWlc9xbkwNAXY/7MYsZfyo8shN5gmEn8gTDTuQJhp3IEww7kScYdiJPMOxEnijpls0N0qhLJP+Jcv03ubdsPvXvd5ptF0/fY9Y3Dtjztj8yxl3TIUseJ2LuZYMBYEpi1KzXhow3V8fdc9JjEy8g9JlcyDh7fdzuW9hc+4Yq97zuZNye8x0ztjWejLjxu/+pf36k606G/N4Ztf8mLpr2obO2es/FZttpy9zbbK/XNgxoH7dsJvIZw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8Ufpx9vjV7gvk7DXMoxi6folZX3LPBruedI+LnlndbbZNwB4vrg0ZT66P2WPhKeMxDPtv/uZws1nPhlzDq5+cZdbTxnhz99EGs23C+PzAZFj7EAxnQrZsHrbnu8djdm5Sr9tz7Wdud392omat/bdo4Tg7ETHsRL5g2Ik8wbATeYJhJ/IEw07kCYadyBOh4+wi0gzgSQBNABRAq6o+LCL3AvhbAL3BRe9R1bXWdUWdz16p5AJ7TfrhOXVmveaQPTd68GS7fcOH7nXpYyP2mvO5P+8w6/TVYo2zT2aTiAyAO1V1o4gkAbwrIi8HtYdU9V8L1VEiKp7J7M/eBaArOD0oIjsAzCt2x4iosL7Ua3YRmQ/gPADrg7PuEJHNIrJaRGY42qwSkXYRaU/DfrpKRMUz6bCLyFQAvwPwE1UdAPBLAKcBWISxI/8DE7VT1VZVbVHVlgTs/dSIqHgmFXYRSWAs6L9S1WcAQFW7VTWrqjkAjwJYXLxuElFUoWEXEQHwOIAdqvrguPPnjrvYdQC2Fr57RFQok3k3/hIANwPYIiKbgvPuAbBCRBZhbDiuA8BtRejfV4Ju2GLW7cmS4Rrezr9ttMWY6XgymXfj3wQmXFzcHFMnosrCT9AReYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEw07kCYadyBMMO5EnGHYiT5R0y2YR6QWwd9xZswAcLFkHvpxK7Vul9gtg3/JVyL6drKqzJyqUNOxfuHGRdlVtKVsHDJXat0rtF8C+5atUfePTeCJPMOxEnih32FvLfPuWSu1bpfYLYN/yVZK+lfU1OxGVTrmP7ERUIgw7kSfKEnYRWSoiO0XkAxG5uxx9cBGRDhHZIiKbRKS9zH1ZLSI9IrJ13HmNIvKyiOwKvk+4x16Z+naviHQG990mEVlWpr41i8hrIrJdRLaJyI+D88t63xn9Ksn9VvLX7CISB/A+gKsA7AewAcAKVd1e0o44iEgHgBZVLfsHMETkMgBHADypqmcH590PoE9V7wv+Uc5Q1bsqpG/3AjhS7m28g92K5o7fZhzAtQBuRRnvO6NfN6AE91s5juyLAXygqrtVdRTArwEsL0M/Kp6qrgPQd8zZywGsCU6vwdgfS8k5+lYRVLVLVTcGpwcBfLrNeFnvO6NfJVGOsM8DsG/cz/tRWfu9K4CXRORdEVlV7s5MoElVu4LTBwA0lbMzEwjdxruUjtlmvGLuu3y2P4+Kb9B90aWqej6AawDcHjxdrUg69hqsksZOJ7WNd6lMsM34Z8p53+W7/XlU5Qh7J4DmcT+fFJxXEVS1M/jeA+BZVN5W1N2f7qAbfO8pc38+U0nbeE+0zTgq4L4r5/bn5Qj7BgALROQUEakGcCOA58vQjy8QkfrgjROISD2Aq1F5W1E/D+CW4PQtAJ4rY18+p1K28XZtM44y33dl3/5cVUv+BWAZxt6R/xDAz8rRB0e/TgXw5+BrW7n7BuBpjD2tS2PsvY2VAGYCaAOwC8ArABorqG//A2ALgM0YC9bcMvXtUow9Rd8MYFPwtazc953Rr5Lcb/y4LJEn+AYdkScYdiJPMOxEnmDYiTzBsBN5gmEn8gTDTuSJ/wcK8iUIg3ozJAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "import matplotlib.pyplot as plt\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),X_train[0].shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "#import pennylane as qml\n", + "#dev = qml.device(\"default.qubit\", wires=10)\n", + "#\n", + "#def block(weights, wires):\n", + "# qml.CNOT(wires=[wires[0],wires[1]])\n", + "# qml.RY(weights[0], wires=wires[0])\n", + "# qml.RY(weights[1], wires=wires[1])\n", + "#\n", + "# \n", + "#import pennylane as qml\n", + "#\n", + "#n_wires = dev.num_wires\n", + "#n_block_wires = 2\n", + "#n_params_block = 2\n", + "#n_blocks = qml.TTN.get_n_blocks(range(n_wires),n_block_wires)\n", + "#n_blocks\n", + "# \n", + "#@qml.qnode(dev)\n", + "#def circuit(weights, x):\n", + "#\n", + "# qml.AmplitudeEmbedding(x, wires=[i for i in range(10)],normalize=True,pad_with=True)\n", + "#\n", + "# for w in weights:\n", + "#\n", + "# qml.TTN(range(n_wires),n_block_wires,block, n_params_block, w)\n", + "# #print(w)\n", + "# #print(x)\n", + "# \n", + "# return qml.expval(qml.PauliZ(3))\n", + "#np.random.seed(0)\n", + "#num_layers = 1\n", + "#weights_init = 2*np.pi * np.random.randn(num_layers,n_blocks, n_params_block)\n", + "#print(weights_init.shape)\n", + "#\n", + "#print(qml.draw(circuit,expansion_strategy='device',wire_order=[i for i in range(10)])(weights_init,np.asarray(X_train[0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#from qbraid import circuit_wrapper\n", + "# maybe we can use qbraid sdk\n", + "#TTN_circ = circuit_wrapper(n_blocks).transpile('qiskit')\n", + "#TTN_circ.draw()\n", + "#print(qml.draw(n_blocks)(weights))\n", + "#qml.draw(n_blocks)([0,0,0,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#def _block(self, qubits, symbols):\n", + "#\n", + "# #assert len(qubits) == 2\n", + "# #assert len(qubits) == len(symbols)\n", + "# qc = QuantumCircuit()\n", + "# qc.y()\n", + "# \n", + "# #\n", + "# #return cirq.Circuit(\n", + "# # cirq.Y(qubits[0])**symbols[0],\n", + "# # cirq.Y(qubits[1])**symbols[1], cirq.CNOT(qubits[0], qubits[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#data_symbols = []\n", + "#\n", + "#ansatz = QuantumCircuit()\n", + "#for l in range(n_layers):\n", + "# for idx, w in enumerate(ind_gates):\n", + "# ansatz.append(block(w, var_symbols[l, idx]))\n", + "# \n", + "# ## Re-encoding layer\n", + "# #if drc and (l < n_layers - 1):\n", + "# # data_circuit, expr = cirq.flatten(\n", + "# # feature_map.build(qubits, in_symbols[l]))\n", + "# # circuit += data_circuit\n", + "# # data_symbols += list(expr.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import RealAmplitudes, EfficientSU2\n", + "ansatz = RealAmplitudes(10, reps=2)\n", + "\n", + "# todo: TTN, example: https://github.com/Gopal-Dahale/qml-hep-lhc/blob/0632e2bcf892965303faa3ebc7322bc87b9ad6b3/qml_hep_lhc/ansatzes/ttn.py\n", + "# def tnn():\n", + "\n", + "#ansatz.draw()\n", + "#ansatz_ = ansatz.decompose(reps=20)\n", + "#print(ansatz_.depth())\n", + "#print(f\"Circuit operations: {ansatz_.count_ops()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "EfficientSU2(4,reps=97).num_parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\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" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{96: 6.435473980059361e-08, 99: 1.0875951026300376e-05, 100: 0.0003429464083973666, 103: 6.435473980063946e-08, 104: 1.029675836809481e-06, 109: 6.435473980059199e-08, 110: 6.435473980059214e-08, 124: 5.791926582053541e-07, 126: 8.340374278157023e-05, 127: 0.001190305267351793, 128: 0.0010379775982437844, 129: 0.00024737961979348535, 130: 0.0001876584212585344, 134: 6.435473980058929e-08, 135: 5.791926582053047e-07, 136: 1.0296758368094123e-06, 139: 5.791926582052729e-07, 152: 2.3167706328214167e-06, 154: 0.0006695467128853881, 155: 0.0026781868515415525, 156: 0.001993452420063207, 157: 0.00115555370785948, 158: 0.001334459884505117, 159: 0.0009736228584431939, 160: 3.4043657354514076e-05, 165: 9.26708253128558e-06, 166: 6.435473980059434e-06, 182: 0.0015461226237092687, 183: 0.003584301587933887, 184: 0.0027575362457156727, 185: 0.0020390155758420324, 186: 0.0007367974159770059, 187: 0.0015661369477872724, 188: 0.0016681392103712123, 189: 0.0007645986635708676, 190: 0.0002635970142232365, 191: 3.4043657354514835e-05, 192: 0.0003815592522777261, 193: 0.0010875951026300475, 194: 0.00033361497112628283, 195: 1.4479816455133771e-05, 207: 6.435473980075541e-08, 209: 0.000306392916190634, 210: 0.0027575362457156745, 211: 0.0032002968555437643, 212: 0.003058394654283475, 213: 0.0030025347401365417, 214: 0.0030025347401365565, 215: 0.0017098410817619984, 216: 0.0010379775982437946, 217: 0.0009422177454205038, 218: 0.0009578559471920467, 219: 0.0013717856335894697, 220: 0.0012794365819756217, 221: 0.0004983631050158022, 222: 0.0019038706222607787, 223: 0.00028032924657138745, 233: 6.435473980060936e-08, 234: 6.435473980058451e-08, 235: 6.435473980058954e-08, 237: 0.002574189592023769, 238: 0.0034638295150271944, 239: 0.0034638295150271887, 240: 0.0034937544690344857, 241: 0.003374826909882975, 242: 0.003200296855543776, 243: 0.003200296855543769, 244: 0.0029747978472825015, 245: 0.0029197101900131847, 246: 0.0017308850816767848, 247: 0.0010379775982437827, 248: 0.000973622858443201, 249: 0.0024722516841796482, 250: 0.003374826909882971, 265: 0.0021551758811821187, 266: 0.003257958702405072, 267: 0.0030025347401365417, 268: 0.0032002968555437943, 269: 0.0033454167937941024, 270: 0.00355399050548784, 271: 0.0033161353871848376, 272: 0.003229063424234597, 273: 0.0031716589963324826, 274: 0.0032290634242346373, 275: 0.0031431498466008246, 276: 0.003200296855543774, 277: 0.00386289325653068, 278: 0.001926073007491985, 293: 0.0023971497028323577, 294: 0.003345416793794097, 295: 0.003058394654283433, 296: 0.002919710190013182, 297: 0.0025229632191425115, 298: 0.002085093569539262, 299: 0.0028923594255979177, 300: 0.0028380440252061883, 301: 0.0028651373706622637, 302: 0.002919710190013154, 303: 0.0032002968555437535, 304: 0.0031147694063487544, 305: 0.003800083030485298, 306: 0.0026259308028234686, 317: 6.435473980071711e-08, 318: 5.79192658206503e-07, 320: 9.267082531285525e-06, 321: 0.0030865176755763145, 322: 0.003114769406348769, 323: 0.00289235942559792, 324: 0.0030583946542834676, 325: 0.002372373128009121, 326: 0.0018380357234447726, 327: 0.0033161353871848332, 328: 0.0027842434627329423, 329: 0.0030583946542834715, 330: 0.003229063424234639, 331: 0.002892359425597907, 332: 0.003286982690055168, 333: 0.0024975430969212706, 334: 0.0028110793892297636, 335: 0.0001740152164208061, 346: 2.3167706328212727e-06, 348: 0.0006307408047856239, 349: 0.003831423788768177, 350: 0.0031716589963325034, 351: 0.0031147694063487622, 352: 0.0030583946542834884, 353: 0.0026519944724426995, 354: 0.002522963219142512, 355: 0.0031431498466008385, 356: 0.002974797847282503, 357: 0.0029197101900131765, 358: 0.003171658996332502, 359: 0.00311476940634879, 360: 0.003862893256530698, 361: 0.0009113274703162244, 362: 0.0017947893382987824, 363: 0.00020181646401466416, 373: 1.0296758368095188e-06, 376: 0.00019467308789680263, 377: 0.0035843015879339227, 378: 0.003345416793794104, 379: 0.0034043657354514488, 380: 0.003345416793794111, 381: 0.0037068330125142497, 382: 0.003463829515027196, 383: 0.0029197101900131656, 384: 0.0030583946542834376, 385: 0.0032002968555437748, 386: 0.0035238081325213782, 387: 0.003030400342470205, 388: 0.0030304003424701832, 389: 0.002811079389229744, 390: 0.0005446985176722273, 394: 6.435473980056566e-08, 395: 1.0296758368089881e-06, 396: 2.316770632820139e-06, 397: 3.153382250227464e-06, 398: 2.574189592022458e-07, 404: 0.0036147413798595907, 405: 0.003286982690055168, 406: 0.003030400342470197, 407: 0.0032002968555437422, 408: 0.0031716589963325255, 409: 0.003086517675576311, 410: 0.0031716589963324974, 411: 0.0031431498466008324, 412: 0.0030025347401365417, 413: 0.003200296855543771, 414: 0.0033748269098829607, 415: 0.002974797847282472, 416: 0.003058394654283453, 417: 0.004184666955533652, 418: 0.00038155925227772113, 421: 5.791926582066301e-07, 429: 0.0002473796197934845, 430: 0.0013530584043075016, 431: 0.002678186851541544, 432: 0.0033454167937940994, 433: 0.0027575362457156615, 434: 0.0029197101900131847, 435: 0.0031431498466008394, 436: 0.003058394654283443, 437: 0.0027842434627329093, 438: 0.002865137370662268, 439: 0.0030583946542834567, 440: 0.0032290634242346183, 441: 0.0032002968555437518, 442: 0.003086517675576302, 443: 0.002974797847282463, 444: 0.0032290634242346104, 445: 0.003831423788768192, 446: 0.00162695217689884, 452: 2.085093569539324e-05, 453: 0.00012459077625395182, 454: 0.0004327212704192003, 455: 0.0007367974159770074, 456: 0.002298815660417052, 457: 0.0033454167937941154, 458: 0.0031147694063487917, 459: 0.0031716589963324956, 460: 0.003030400342470196, 461: 0.003286982690055165, 462: 0.0025741895920237995, 463: 0.0027045079401199915, 464: 0.002865137370662268, 465: 0.0034043657354514514, 466: 0.0032290634242346144, 467: 0.0035238081325213487, 468: 0.0019934524200632244, 469: 0.0022745539235122132, 470: 0.004022171237537163, 471: 0.0039580739166957864, 472: 0.0034937544690344306, 473: 0.00364530988126486, 474: 0.002974797847282465, 477: 0.00020908854961212945, 478: 0.0022504208960869698, 479: 0.002784243462732909, 480: 0.0032290634242346065, 481: 0.003143149846600816, 482: 0.0032290634242346083, 483: 0.0027842434627329024, 484: 0.0026781868515415503, 485: 0.0029471896639080295, 486: 0.0027842434627329046, 487: 0.0028110793892297584, 488: 0.002574189592023789, 489: 0.0016269521768988216, 490: 0.0038628932565307026, 491: 0.002397149702832337, 492: 0.0027309577381780157, 493: 0.0032002968555437587, 494: 0.004184666955533625, 495: 0.004184666955533652, 496: 0.003143149846600844, 497: 0.003523808132521348, 498: 0.0031431498466008363, 499: 0.0028651373706622637, 500: 0.003114769406348764, 501: 0.003463829515027178, 502: 0.0038944914337727694, 504: 5.791926582052186e-07, 505: 0.0026259308028234603, 506: 0.003345416793794113, 507: 0.003229063424234628, 508: 0.0031431498466008294, 509: 0.00286513737066227, 510: 0.0028651373706622585, 511: 0.0029471896639080026, 512: 0.0027045079401199915, 513: 0.0027045079401199893, 514: 0.002704507940119987, 515: 0.003114769406348769, 516: 0.0037068330125142666, 517: 0.0004118703347238052, 518: 0.0014479816455133844, 519: 0.004184666955533671, 520: 0.003374826909882987, 521: 0.003143149846600851, 522: 0.0022745539235122145, 523: 0.001526237009110899, 524: 0.002347725262665498, 525: 0.0028380440252062295, 526: 0.002678186851541547, 527: 0.0028110793892297797, 528: 0.003171658996332466, 529: 0.0033454167937940903, 530: 0.0032579587024050864, 532: 0.000618062921044907, 533: 0.0034937544690344783, 534: 0.002522963219142507, 535: 0.0028380440252062243, 536: 0.0031716589963324965, 537: 0.003374826909882975, 538: 0.0033748269098829806, 539: 0.0035238081325213544, 540: 0.00399005822237665, 541: 0.003114769406348788, 542: 0.002422054987135201, 543: 0.0029747978472824863, 544: 0.00303040034247021, 545: 0.0037377876423583434, 546: 0.0002718987756575123, 547: 0.0003429464083973691, 548: 0.0007230898563994767, 549: 0.000880952033130339, 550: 0.0018163481761319723, 551: 0.003086517675576315, 552: 0.003143149846600823, 553: 0.002974797847282469, 554: 0.0030304003424701798, 555: 0.0032002968555437643, 556: 0.003200296855543765, 557: 0.0032290634242346217, 558: 0.003374826909882971, 559: 5.412233617229877e-05, 560: 0.0003619954113783457, 561: 0.002678186851541548, 562: 0.0028923594255979316, 563: 0.002678186851541554, 564: 0.002397149702832335, 565: 0.002704507940119972, 566: 0.0028651373706622854, 567: 0.0032579587024050847, 568: 0.0030025347401365335, 569: 0.002202540969675343, 570: 0.002497543096921267, 571: 0.002730957738178015, 572: 0.002522963219142512, 573: 0.0029197101900131795, 574: 0.003706833012514242, 575: 0.0024470889809176093, 576: 0.0033161353871848384, 577: 0.003862893256530654, 578: 0.0036760070921497343, 579: 0.0032002968555437535, 580: 0.003058394654283475, 581: 0.002892359425597915, 582: 0.002811079389229784, 583: 0.003171658996332507, 584: 0.00311476940634879, 585: 0.0031431498466008433, 586: 0.0034043657354514414, 587: 0.0002888884269648676, 588: 0.00014827332050056986, 589: 0.002651994472442707, 590: 0.002155175881182113, 591: 0.002422054987135176, 592: 0.00291971019001318, 593: 0.0024975430969212645, 594: 0.002202540969675374, 595: 0.0023232061068014656, 596: 0.002422054987135174, 597: 0.0023723731280091086, 598: 0.002625930802823485, 599: 0.0029471896639080295, 600: 0.003086517675576291, 601: 0.003143149846600827, 602: 0.003114769406348784, 603: 0.003584301587933916, 604: 0.0032579587024050877, 605: 0.0030025347401365136, 606: 0.00254851205084332, 607: 0.0027309577381780265, 608: 0.0022264165781413774, 609: 0.002108325630607274, 610: 0.0020161696432128224, 611: 0.0019038706222607876, 612: 0.0021083256306072837, 613: 0.002704507940119988, 614: 0.0027309577381780374, 615: 0.0008510914338628575, 617: 0.000957855947192049, 618: 0.0030865176755762967, 619: 0.0023971497028323447, 620: 0.0020619902179508454, 621: 0.0018817969465091842, 622: 0.002155175881182092, 623: 0.0024722516841796252, 624: 0.0026781868515415633, 625: 0.0028380440252062378, 626: 0.0029197101900131674, 627: 0.0027575362457156593, 628: 0.002865137370662257, 629: 0.0028380440252062213, 630: 0.002574189592023771, 631: 0.0024722516841796218, 632: 0.0024220549871351647, 633: 0.0023477252626654906, 634: 0.0024470889809175907, 635: 0.002347725262665489, 636: 0.0025229632191424993, 637: 0.0023723731280091134, 638: 0.0019934524200632357, 639: 0.001566136947787275, 640: 0.0017947893382987854, 641: 0.002016169643212822, 642: 0.0028380440252062126, 643: 0.0005446985176722298, 646: 0.00035240655514805354, 647: 0.00229881566041703, 648: 0.0028923594255979034, 649: 0.0023477252626654846, 650: 0.0019708639063931842, 651: 0.0019038706222607804, 652: 0.0019708639063932055, 653: 0.002108325630607263, 654: 0.0022025409696753416, 655: 0.002274553923512201, 656: 0.002298815660417042, 657: 0.002274553923512229, 658: 0.0023971497028323556, 659: 0.002522963219142536, 660: 0.002678186851541545, 661: 0.002811079389229781, 662: 0.0028380440252062065, 663: 0.002838044025206217, 664: 0.00286513737066225, 665: 0.002274553923512197, 666: 0.0022745539235121993, 667: 0.0024220549871351764, 668: 0.0023723731280091364, 669: 0.0030025347401365404, 670: 0.0018598519802371749, 672: 2.5741895920236366e-07, 676: 0.0002803292465713921, 677: 0.0025741895920237947, 678: 0.0031716589963325034, 679: 0.0036147413798595924, 680: 0.0036760070921497386, 681: 0.00376887098168201, 682: 0.0038944914337727954, 683: 0.0038000830304853184, 684: 0.0038314237887681814, 685: 0.0031431498466008216, 686: 0.003114769406348761, 687: 0.002397149702832347, 688: 0.002347725262665483, 689: 0.0020619902179508346, 690: 0.0021316864011548787, 691: 0.0021316864011548826, 692: 0.0021083256306072594, 693: 0.001993452420063207, 694: 0.0017733592099451697, 695: 0.0018163481761319723, 696: 0.0006307408047856226, 697: 0.0002164893446891982, 707: 0.00010296758368095236, 708: 0.00023946398679801627, 709: 0.00012459077625395234, 710: 0.0003336149711262838, 711: 0.00010818031760480079, 712: 7.883455625573016e-05}\n" + ] + } + ], + "source": [ + "histogram = simulate(qc.bind_parameters(normalized_vector))\n", + "print(histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 6.435473980059361e-08, 97: 0, 98: 0, 99: 1.0875951026300376e-05, 100: 0.0003429464083973666, 101: 0, 102: 0, 103: 6.435473980063946e-08, 104: 1.029675836809481e-06, 105: 0, 106: 0, 107: 0, 108: 0, 109: 6.435473980059199e-08, 110: 6.435473980059214e-08, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 5.791926582053541e-07, 125: 0, 126: 8.340374278157023e-05, 127: 0.001190305267351793, 128: 0.0010379775982437844, 129: 0.00024737961979348535, 130: 0.0001876584212585344, 131: 0, 132: 0, 133: 0, 134: 6.435473980058929e-08, 135: 5.791926582053047e-07, 136: 1.0296758368094123e-06, 137: 0, 138: 0, 139: 5.791926582052729e-07, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 2.3167706328214167e-06, 153: 0, 154: 0.0006695467128853881, 155: 0.0026781868515415525, 156: 0.001993452420063207, 157: 0.00115555370785948, 158: 0.001334459884505117, 159: 0.0009736228584431939, 160: 3.4043657354514076e-05, 161: 0, 162: 0, 163: 0, 164: 0, 165: 9.26708253128558e-06, 166: 6.435473980059434e-06, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0.0015461226237092687, 183: 0.003584301587933887, 184: 0.0027575362457156727, 185: 0.0020390155758420324, 186: 0.0007367974159770059, 187: 0.0015661369477872724, 188: 0.0016681392103712123, 189: 0.0007645986635708676, 190: 0.0002635970142232365, 191: 3.4043657354514835e-05, 192: 0.0003815592522777261, 193: 0.0010875951026300475, 194: 0.00033361497112628283, 195: 1.4479816455133771e-05, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 6.435473980075541e-08, 208: 0, 209: 0.000306392916190634, 210: 0.0027575362457156745, 211: 0.0032002968555437643, 212: 0.003058394654283475, 213: 0.0030025347401365417, 214: 0.0030025347401365565, 215: 0.0017098410817619984, 216: 0.0010379775982437946, 217: 0.0009422177454205038, 218: 0.0009578559471920467, 219: 0.0013717856335894697, 220: 0.0012794365819756217, 221: 0.0004983631050158022, 222: 0.0019038706222607787, 223: 0.00028032924657138745, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 6.435473980060936e-08, 234: 6.435473980058451e-08, 235: 6.435473980058954e-08, 236: 0, 237: 0.002574189592023769, 238: 0.0034638295150271944, 239: 0.0034638295150271887, 240: 0.0034937544690344857, 241: 0.003374826909882975, 242: 0.003200296855543776, 243: 0.003200296855543769, 244: 0.0029747978472825015, 245: 0.0029197101900131847, 246: 0.0017308850816767848, 247: 0.0010379775982437827, 248: 0.000973622858443201, 249: 0.0024722516841796482, 250: 0.003374826909882971, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0.0021551758811821187, 266: 0.003257958702405072, 267: 0.0030025347401365417, 268: 0.0032002968555437943, 269: 0.0033454167937941024, 270: 0.00355399050548784, 271: 0.0033161353871848376, 272: 0.003229063424234597, 273: 0.0031716589963324826, 274: 0.0032290634242346373, 275: 0.0031431498466008246, 276: 0.003200296855543774, 277: 0.00386289325653068, 278: 0.001926073007491985, 279: 0, 280: 0, 281: 0, 282: 0, 283: 0, 284: 0, 285: 0, 286: 0, 287: 0, 288: 0, 289: 0, 290: 0, 291: 0, 292: 0, 293: 0.0023971497028323577, 294: 0.003345416793794097, 295: 0.003058394654283433, 296: 0.002919710190013182, 297: 0.0025229632191425115, 298: 0.002085093569539262, 299: 0.0028923594255979177, 300: 0.0028380440252061883, 301: 0.0028651373706622637, 302: 0.002919710190013154, 303: 0.0032002968555437535, 304: 0.0031147694063487544, 305: 0.003800083030485298, 306: 0.0026259308028234686, 307: 0, 308: 0, 309: 0, 310: 0, 311: 0, 312: 0, 313: 0, 314: 0, 315: 0, 316: 0, 317: 6.435473980071711e-08, 318: 5.79192658206503e-07, 319: 0, 320: 9.267082531285525e-06, 321: 0.0030865176755763145, 322: 0.003114769406348769, 323: 0.00289235942559792, 324: 0.0030583946542834676, 325: 0.002372373128009121, 326: 0.0018380357234447726, 327: 0.0033161353871848332, 328: 0.0027842434627329423, 329: 0.0030583946542834715, 330: 0.003229063424234639, 331: 0.002892359425597907, 332: 0.003286982690055168, 333: 0.0024975430969212706, 334: 0.0028110793892297636, 335: 0.0001740152164208061, 336: 0, 337: 0, 338: 0, 339: 0, 340: 0, 341: 0, 342: 0, 343: 0, 344: 0, 345: 0, 346: 2.3167706328212727e-06, 347: 0, 348: 0.0006307408047856239, 349: 0.003831423788768177, 350: 0.0031716589963325034, 351: 0.0031147694063487622, 352: 0.0030583946542834884, 353: 0.0026519944724426995, 354: 0.002522963219142512, 355: 0.0031431498466008385, 356: 0.002974797847282503, 357: 0.0029197101900131765, 358: 0.003171658996332502, 359: 0.00311476940634879, 360: 0.003862893256530698, 361: 0.0009113274703162244, 362: 0.0017947893382987824, 363: 0.00020181646401466416, 364: 0, 365: 0, 366: 0, 367: 0, 368: 0, 369: 0, 370: 0, 371: 0, 372: 0, 373: 1.0296758368095188e-06, 374: 0, 375: 0, 376: 0.00019467308789680263, 377: 0.0035843015879339227, 378: 0.003345416793794104, 379: 0.0034043657354514488, 380: 0.003345416793794111, 381: 0.0037068330125142497, 382: 0.003463829515027196, 383: 0.0029197101900131656, 384: 0.0030583946542834376, 385: 0.0032002968555437748, 386: 0.0035238081325213782, 387: 0.003030400342470205, 388: 0.0030304003424701832, 389: 0.002811079389229744, 390: 0.0005446985176722273, 391: 0, 392: 0, 393: 0, 394: 6.435473980056566e-08, 395: 1.0296758368089881e-06, 396: 2.316770632820139e-06, 397: 3.153382250227464e-06, 398: 2.574189592022458e-07, 399: 0, 400: 0, 401: 0, 402: 0, 403: 0, 404: 0.0036147413798595907, 405: 0.003286982690055168, 406: 0.003030400342470197, 407: 0.0032002968555437422, 408: 0.0031716589963325255, 409: 0.003086517675576311, 410: 0.0031716589963324974, 411: 0.0031431498466008324, 412: 0.0030025347401365417, 413: 0.003200296855543771, 414: 0.0033748269098829607, 415: 0.002974797847282472, 416: 0.003058394654283453, 417: 0.004184666955533652, 418: 0.00038155925227772113, 419: 0, 420: 0, 421: 5.791926582066301e-07, 422: 0, 423: 0, 424: 0, 425: 0, 426: 0, 427: 0, 428: 0, 429: 0.0002473796197934845, 430: 0.0013530584043075016, 431: 0.002678186851541544, 432: 0.0033454167937940994, 433: 0.0027575362457156615, 434: 0.0029197101900131847, 435: 0.0031431498466008394, 436: 0.003058394654283443, 437: 0.0027842434627329093, 438: 0.002865137370662268, 439: 0.0030583946542834567, 440: 0.0032290634242346183, 441: 0.0032002968555437518, 442: 0.003086517675576302, 443: 0.002974797847282463, 444: 0.0032290634242346104, 445: 0.003831423788768192, 446: 0.00162695217689884, 447: 0, 448: 0, 449: 0, 450: 0, 451: 0, 452: 2.085093569539324e-05, 453: 0.00012459077625395182, 454: 0.0004327212704192003, 455: 0.0007367974159770074, 456: 0.002298815660417052, 457: 0.0033454167937941154, 458: 0.0031147694063487917, 459: 0.0031716589963324956, 460: 0.003030400342470196, 461: 0.003286982690055165, 462: 0.0025741895920237995, 463: 0.0027045079401199915, 464: 0.002865137370662268, 465: 0.0034043657354514514, 466: 0.0032290634242346144, 467: 0.0035238081325213487, 468: 0.0019934524200632244, 469: 0.0022745539235122132, 470: 0.004022171237537163, 471: 0.0039580739166957864, 472: 0.0034937544690344306, 473: 0.00364530988126486, 474: 0.002974797847282465, 475: 0, 476: 0, 477: 0.00020908854961212945, 478: 0.0022504208960869698, 479: 0.002784243462732909, 480: 0.0032290634242346065, 481: 0.003143149846600816, 482: 0.0032290634242346083, 483: 0.0027842434627329024, 484: 0.0026781868515415503, 485: 0.0029471896639080295, 486: 0.0027842434627329046, 487: 0.0028110793892297584, 488: 0.002574189592023789, 489: 0.0016269521768988216, 490: 0.0038628932565307026, 491: 0.002397149702832337, 492: 0.0027309577381780157, 493: 0.0032002968555437587, 494: 0.004184666955533625, 495: 0.004184666955533652, 496: 0.003143149846600844, 497: 0.003523808132521348, 498: 0.0031431498466008363, 499: 0.0028651373706622637, 500: 0.003114769406348764, 501: 0.003463829515027178, 502: 0.0038944914337727694, 503: 0, 504: 5.791926582052186e-07, 505: 0.0026259308028234603, 506: 0.003345416793794113, 507: 0.003229063424234628, 508: 0.0031431498466008294, 509: 0.00286513737066227, 510: 0.0028651373706622585, 511: 0.0029471896639080026, 512: 0.0027045079401199915, 513: 0.0027045079401199893, 514: 0.002704507940119987, 515: 0.003114769406348769, 516: 0.0037068330125142666, 517: 0.0004118703347238052, 518: 0.0014479816455133844, 519: 0.004184666955533671, 520: 0.003374826909882987, 521: 0.003143149846600851, 522: 0.0022745539235122145, 523: 0.001526237009110899, 524: 0.002347725262665498, 525: 0.0028380440252062295, 526: 0.002678186851541547, 527: 0.0028110793892297797, 528: 0.003171658996332466, 529: 0.0033454167937940903, 530: 0.0032579587024050864, 531: 0, 532: 0.000618062921044907, 533: 0.0034937544690344783, 534: 0.002522963219142507, 535: 0.0028380440252062243, 536: 0.0031716589963324965, 537: 0.003374826909882975, 538: 0.0033748269098829806, 539: 0.0035238081325213544, 540: 0.00399005822237665, 541: 0.003114769406348788, 542: 0.002422054987135201, 543: 0.0029747978472824863, 544: 0.00303040034247021, 545: 0.0037377876423583434, 546: 0.0002718987756575123, 547: 0.0003429464083973691, 548: 0.0007230898563994767, 549: 0.000880952033130339, 550: 0.0018163481761319723, 551: 0.003086517675576315, 552: 0.003143149846600823, 553: 0.002974797847282469, 554: 0.0030304003424701798, 555: 0.0032002968555437643, 556: 0.003200296855543765, 557: 0.0032290634242346217, 558: 0.003374826909882971, 559: 5.412233617229877e-05, 560: 0.0003619954113783457, 561: 0.002678186851541548, 562: 0.0028923594255979316, 563: 0.002678186851541554, 564: 0.002397149702832335, 565: 0.002704507940119972, 566: 0.0028651373706622854, 567: 0.0032579587024050847, 568: 0.0030025347401365335, 569: 0.002202540969675343, 570: 0.002497543096921267, 571: 0.002730957738178015, 572: 0.002522963219142512, 573: 0.0029197101900131795, 574: 0.003706833012514242, 575: 0.0024470889809176093, 576: 0.0033161353871848384, 577: 0.003862893256530654, 578: 0.0036760070921497343, 579: 0.0032002968555437535, 580: 0.003058394654283475, 581: 0.002892359425597915, 582: 0.002811079389229784, 583: 0.003171658996332507, 584: 0.00311476940634879, 585: 0.0031431498466008433, 586: 0.0034043657354514414, 587: 0.0002888884269648676, 588: 0.00014827332050056986, 589: 0.002651994472442707, 590: 0.002155175881182113, 591: 0.002422054987135176, 592: 0.00291971019001318, 593: 0.0024975430969212645, 594: 0.002202540969675374, 595: 0.0023232061068014656, 596: 0.002422054987135174, 597: 0.0023723731280091086, 598: 0.002625930802823485, 599: 0.0029471896639080295, 600: 0.003086517675576291, 601: 0.003143149846600827, 602: 0.003114769406348784, 603: 0.003584301587933916, 604: 0.0032579587024050877, 605: 0.0030025347401365136, 606: 0.00254851205084332, 607: 0.0027309577381780265, 608: 0.0022264165781413774, 609: 0.002108325630607274, 610: 0.0020161696432128224, 611: 0.0019038706222607876, 612: 0.0021083256306072837, 613: 0.002704507940119988, 614: 0.0027309577381780374, 615: 0.0008510914338628575, 616: 0, 617: 0.000957855947192049, 618: 0.0030865176755762967, 619: 0.0023971497028323447, 620: 0.0020619902179508454, 621: 0.0018817969465091842, 622: 0.002155175881182092, 623: 0.0024722516841796252, 624: 0.0026781868515415633, 625: 0.0028380440252062378, 626: 0.0029197101900131674, 627: 0.0027575362457156593, 628: 0.002865137370662257, 629: 0.0028380440252062213, 630: 0.002574189592023771, 631: 0.0024722516841796218, 632: 0.0024220549871351647, 633: 0.0023477252626654906, 634: 0.0024470889809175907, 635: 0.002347725262665489, 636: 0.0025229632191424993, 637: 0.0023723731280091134, 638: 0.0019934524200632357, 639: 0.001566136947787275, 640: 0.0017947893382987854, 641: 0.002016169643212822, 642: 0.0028380440252062126, 643: 0.0005446985176722298, 644: 0, 645: 0, 646: 0.00035240655514805354, 647: 0.00229881566041703, 648: 0.0028923594255979034, 649: 0.0023477252626654846, 650: 0.0019708639063931842, 651: 0.0019038706222607804, 652: 0.0019708639063932055, 653: 0.002108325630607263, 654: 0.0022025409696753416, 655: 0.002274553923512201, 656: 0.002298815660417042, 657: 0.002274553923512229, 658: 0.0023971497028323556, 659: 0.002522963219142536, 660: 0.002678186851541545, 661: 0.002811079389229781, 662: 0.0028380440252062065, 663: 0.002838044025206217, 664: 0.00286513737066225, 665: 0.002274553923512197, 666: 0.0022745539235121993, 667: 0.0024220549871351764, 668: 0.0023723731280091364, 669: 0.0030025347401365404, 670: 0.0018598519802371749, 671: 0, 672: 2.5741895920236366e-07, 673: 0, 674: 0, 675: 0, 676: 0.0002803292465713921, 677: 0.0025741895920237947, 678: 0.0031716589963325034, 679: 0.0036147413798595924, 680: 0.0036760070921497386, 681: 0.00376887098168201, 682: 0.0038944914337727954, 683: 0.0038000830304853184, 684: 0.0038314237887681814, 685: 0.0031431498466008216, 686: 0.003114769406348761, 687: 0.002397149702832347, 688: 0.002347725262665483, 689: 0.0020619902179508346, 690: 0.0021316864011548787, 691: 0.0021316864011548826, 692: 0.0021083256306072594, 693: 0.001993452420063207, 694: 0.0017733592099451697, 695: 0.0018163481761319723, 696: 0.0006307408047856226, 697: 0.0002164893446891982, 698: 0, 699: 0, 700: 0, 701: 0, 702: 0, 703: 0, 704: 0, 705: 0, 706: 0, 707: 0.00010296758368095236, 708: 0.00023946398679801627, 709: 0.00012459077625395234, 710: 0.0003336149711262838, 711: 0.00010818031760480079, 712: 7.883455625573016e-05, 713: 0, 714: 0, 715: 0, 716: 0, 717: 0, 718: 0, 719: 0, 720: 0, 721: 0, 722: 0, 723: 0, 724: 0, 725: 0, 726: 0, 727: 0, 728: 0, 729: 0, 730: 0, 731: 0, 732: 0, 733: 0, 734: 0, 735: 0, 736: 0, 737: 0, 738: 0, 739: 0, 740: 0, 741: 0, 742: 0, 743: 0, 744: 0, 745: 0, 746: 0, 747: 0, 748: 0, 749: 0, 750: 0, 751: 0, 752: 0, 753: 0, 754: 0, 755: 0, 756: 0, 757: 0, 758: 0, 759: 0, 760: 0, 761: 0, 762: 0, 763: 0, 764: 0, 765: 0, 766: 0, 767: 0, 768: 0, 769: 0, 770: 0, 771: 0, 772: 0, 773: 0, 774: 0, 775: 0, 776: 0, 777: 0, 778: 0, 779: 0, 780: 0, 781: 0, 782: 0, 783: 0, 784: 0, 785: 0, 786: 0, 787: 0, 788: 0, 789: 0, 790: 0, 791: 0, 792: 0, 793: 0, 794: 0, 795: 0, 796: 0, 797: 0, 798: 0, 799: 0, 800: 0, 801: 0, 802: 0, 803: 0, 804: 0, 805: 0, 806: 0, 807: 0, 808: 0, 809: 0, 810: 0, 811: 0, 812: 0, 813: 0, 814: 0, 815: 0, 816: 0, 817: 0, 818: 0, 819: 0, 820: 0, 821: 0, 822: 0, 823: 0, 824: 0, 825: 0, 826: 0, 827: 0, 828: 0, 829: 0, 830: 0, 831: 0, 832: 0, 833: 0, 834: 0, 835: 0, 836: 0, 837: 0, 838: 0, 839: 0, 840: 0, 841: 0, 842: 0, 843: 0, 844: 0, 845: 0, 846: 0, 847: 0, 848: 0, 849: 0, 850: 0, 851: 0, 852: 0, 853: 0, 854: 0, 855: 0, 856: 0, 857: 0, 858: 0, 859: 0, 860: 0, 861: 0, 862: 0, 863: 0, 864: 0, 865: 0, 866: 0, 867: 0, 868: 0, 869: 0, 870: 0, 871: 0, 872: 0, 873: 0, 874: 0, 875: 0, 876: 0, 877: 0, 878: 0, 879: 0, 880: 0, 881: 0, 882: 0, 883: 0, 884: 0, 885: 0, 886: 0, 887: 0, 888: 0, 889: 0, 890: 0, 891: 0, 892: 0, 893: 0, 894: 0, 895: 0, 896: 0, 897: 0, 898: 0, 899: 0, 900: 0, 901: 0, 902: 0, 903: 0, 904: 0, 905: 0, 906: 0, 907: 0, 908: 0, 909: 0, 910: 0, 911: 0, 912: 0, 913: 0, 914: 0, 915: 0, 916: 0, 917: 0, 918: 0, 919: 0, 920: 0, 921: 0, 922: 0, 923: 0, 924: 0, 925: 0, 926: 0, 927: 0, 928: 0, 929: 0, 930: 0, 931: 0, 932: 0, 933: 0, 934: 0, 935: 0, 936: 0, 937: 0, 938: 0, 939: 0, 940: 0, 941: 0, 942: 0, 943: 0, 944: 0, 945: 0, 946: 0, 947: 0, 948: 0, 949: 0, 950: 0, 951: 0, 952: 0, 953: 0, 954: 0, 955: 0, 956: 0, 957: 0, 958: 0, 959: 0, 960: 0, 961: 0, 962: 0, 963: 0, 964: 0, 965: 0, 966: 0, 967: 0, 968: 0, 969: 0, 970: 0, 971: 0, 972: 0, 973: 0, 974: 0, 975: 0, 976: 0, 977: 0, 978: 0, 979: 0, 980: 0, 981: 0, 982: 0, 983: 0, 984: 0, 985: 0, 986: 0, 987: 0, 988: 0, 989: 0, 990: 0, 991: 0, 992: 0, 993: 0, 994: 0, 995: 0, 996: 0, 997: 0, 998: 0, 999: 0, 1000: 0, 1001: 0, 1002: 0, 1003: 0, 1004: 0, 1005: 0, 1006: 0, 1007: 0, 1008: 0, 1009: 0, 1010: 0, 1011: 0, 1012: 0, 1013: 0, 1014: 0, 1015: 0, 1016: 0, 1017: 0, 1018: 0, 1019: 0, 1020: 0, 1021: 0, 1022: 0, 1023: 0}\n" + ] + } + ], + "source": [ + "new_histogram = {}\n", + "\n", + "for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + "print(new_histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "after_ = np.array(list(new_histogram.values())[:784])\n", + "plt.imshow(np.reshape(after_,X_train[0].shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "de_normalized_vector = de_normalize(after_,X_train[0])\n", + "plt.imshow(np.reshape(after_,X_train[0].shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def encode_qiskit(x,num_qubit=10):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit)\n", + " qc.bind_parameters(normalized_vector)\n", + " return qc" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def decode(histogram):\n", + " new_histogram = {}\n", + "\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values())[:784])\n", + " return after_" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[1;36m Input \u001b[1;32mIn [30]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", + "\u001b[1;33m from part1 import encode_qiskit,decode\u001b[0m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m\u001b[1;31m:\u001b[0m No module named 'part1'\n", + "\n", + "Use %tb to get the full traceback.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#grade part1\n", + "from part1 import encode_qiskit,decode\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for data in (X_train,Y_train):\n", + " #encode image into circuit\n", + " circuit=encode_qiskit(data[0])\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + " \n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #reconstruct \n", + " image_re=decode(histogram)\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(np.asarray(data['image']),np.asarray(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": 31, + "metadata": {}, + "outputs": [], + "source": [ + "#traning_qc = QuantumCircuit(10,10)\n", + "#traning_qc.append(qc,[i for i in range(10)])\n", + "#traning_qc.append(ansatz_,[i for i in range(10)])\n", + "##qc.append(ansatz)\n", + "#traning_qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.utils import algorithm_globals\n", + "algorithm_globals.random_seed = 0\n", + "\n", + "import numpy as np\n", + "np.random.seed(algorithm_globals.random_seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "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": 34, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import SPSA" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_machine_learning.algorithms.classifiers import VQC\n", + "vqc = VQC(\n", + " feature_map=qc,\n", + " ansatz=RealAmplitudes(10, reps=2),\n", + " loss=\"cross_entropy\",\n", + " optimizer=SPSA(maxiter=300),\n", + " quantum_instance=Aer.get_backend('qasm_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time elapsed: 5874.684581756592\n" + ] + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.3" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.166885338964307) q0; ry(-0.562428401027246) q1; ry(0.48893589557941) q2; ry(1.0000212324066) q3; ry(0.997292670049591) q4; ry(0.516642028823444) q5; ry(-0.52976583280007) q6; ry(0.44621090925359) q7; ry(-0.812837886101786) q8; ry(0.00690999905273608) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.732554878640012) q0; ry(1.09250685549609) q1; ry(0.946119425708376) q2; ry(1.22520608932305) q3; ry(-0.256892484303682) q4; ry(0.849713315449811) q5; ry(-0.172935171560596) q6; ry(-0.792282689543016) q7; ry(0.105879168563046) q8; ry(0.451929686680044) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(-0.717816606765696) q0; ry(-0.406893365206504) q1; ry(0.786417140426462) q2; ry(0.715868574401998) q3; ry(1.68834007060239) q4; ry(0.16240900497929) q5; ry(0.021691745395356) q6; ry(-0.45492053378632) q7; ry(1.68422609585115) q8; ry(0.668468430274114) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.166885338964307,-0.562428401027246,0.48893589557941,1.0000212324066,0.997292670049591,0.516642028823444,-0.52976583280007,0.44621090925359,-0.812837886101786,0.00690999905273608,0.732554878640012,1.09250685549609,0.946119425708376,1.22520608932305,-0.256892484303682,0.849713315449811,-0.172935171560596,-0.792282689543016,0.105879168563046,0.451929686680044,-0.717816606765696,-0.406893365206504,0.786417140426462,0.715868574401998,1.68834007060239,0.16240900497929,0.021691745395356,-0.45492053378632,1.68422609585115,0.668468430274114) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"best_vqc.qasm\", \"w\") as f:\n", + " f.write(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import SPSA" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_esu2_spsa300 = VQC(\n", + " feature_map=qc,\n", + " ansatz=EfficientSU2(num_qubits=10, reps=20),\n", + " loss=\"cross_entropy\",\n", + " optimizer=SPSA(maxiter=300),\n", + " quantum_instance=Aer.get_backend('statevector_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc_esu2_spsa300.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_esu2_spsa300.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.266317714019139) q0; ry(1.32035044188513) q1; ry(0.375724625916453) q2; ry(-0.145527578194223) q3; ry(1.24796981173025) q4; ry(-0.3722525242738) q5; ry(0.98731246639232) q6; ry(1.98782341512519) q7; ry(1.66430495324693) q8; ry(0.760045740348774) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.76943425343952) q0; ry(1.54002486179664) q1; ry(1.5166941190635) q2; ry(2.08820456685236) q3; ry(0.502872321522427) q4; ry(0.5226897740692) q5; ry(1.34895736320983) q6; ry(0.17808386546728) q7; ry(1.48787325816064) q8; ry(1.19251464386051) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.63207747410879) q0; ry(0.944742510667842) q1; ry(1.4738548596109) q2; ry(0.0395594736234817) q3; ry(0.160988017972572) q4; ry(-0.139909848244233) q5; ry(0.217661325699283) q6; ry(1.51612158505368) q7; ry(0.709288700436131) q8; ry(2.00665865500557) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.266317714019139,1.32035044188513,0.375724625916453,-0.145527578194223,1.24796981173025,-0.3722525242738,0.98731246639232,1.98782341512519,1.66430495324693,0.760045740348774,1.76943425343952,1.54002486179664,1.5166941190635,2.08820456685236,0.502872321522427,0.5226897740692,1.34895736320983,0.17808386546728,1.48787325816064,1.19251464386051,1.63207747410879,0.944742510667842,1.4738548596109,0.0395594736234817,0.160988017972572,-0.139909848244233,0.217661325699283,1.51612158505368,0.709288700436131,2.00665865500557) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# todo: histogram_to_category\n", + "#def histogram_to_category():\n" + ] + }, + { + "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))" + ] + } + ], + "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.8.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0ba76706d2c44f5b8079dadbf9eae644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + }, + "0f9f3e72f13b494c838f67865f9e754a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2c61f71bdc9b4deebcd3e1777dc5766e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_767826b914d54f70bb5157f346d1cb93", + "style": "IPY_MODEL_4879fc589bd94ce5942e7476dd0f334a", + "value": "
Message
" + } + }, + "2c94492e14424196ba309fa46f774c67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "2f9478e6a8394b069e15a4f0d988626c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "35b3eeee622c40409e47c6f3c1abd7bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_cb0c25ba5d6241788a20a1d68882bc9f" + ], + "layout": "IPY_MODEL_2c94492e14424196ba309fa46f774c67" + } + }, + "37c62e31818245549375a731d0e461a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3c7d3faff2fd4a0db555c4fe70c5c14a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "4879fc589bd94ce5942e7476dd0f334a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5e7774ce7df04e92a1cf2d0053476e73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f7e534254a5b416ea439079965a8951a", + "style": "IPY_MODEL_37c62e31818245549375a731d0e461a4", + "value": "
Status
" + } + }, + "6e78fe288f494bc7b7055a1cbf4fd588": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "767826b914d54f70bb5157f346d1cb93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "7f437d31eeb24f069d386ef17b056adc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "844c4eb47f0246808cae2c1c15e62668": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_dac1a80538854f7cb39e6708480ca33a", + "style": "IPY_MODEL_0f9f3e72f13b494c838f67865f9e754a", + "value": "

Circuit Properties

" + } + }, + "8c97b2f86c544568b21de0bcf766a11a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "900fa225eff145fb8fd961bef128e435": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "9a7a59b64a164e8f949155f062fb8877": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_aebbd7756d974e8c8865b15b5d8cbac9", + "style": "IPY_MODEL_7f437d31eeb24f069d386ef17b056adc", + "value": "
Backend
" + } + }, + "aebbd7756d974e8c8865b15b5d8cbac9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "c776185e67b248f89fb2da4ecea7e64f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_8c97b2f86c544568b21de0bcf766a11a", + "style": "IPY_MODEL_900fa225eff145fb8fd961bef128e435", + "value": "
Job ID
" + } + }, + "cb0c25ba5d6241788a20a1d68882bc9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_0ba76706d2c44f5b8079dadbf9eae644", + "style": "IPY_MODEL_3c7d3faff2fd4a0db555c4fe70c5c14a" + } + }, + "d4f675734b714276a0ed85daaa6bc674": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_c776185e67b248f89fb2da4ecea7e64f", + "IPY_MODEL_9a7a59b64a164e8f949155f062fb8877", + "IPY_MODEL_5e7774ce7df04e92a1cf2d0053476e73", + "IPY_MODEL_ef5d3c53b9d249fc89769a1ca3c4d5a3", + "IPY_MODEL_2c61f71bdc9b4deebcd3e1777dc5766e" + ], + "layout": "IPY_MODEL_f02d7c03dbc34222b1a387d12fac3125" + } + }, + "dac1a80538854f7cb39e6708480ca33a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "ef5d3c53b9d249fc89769a1ca3c4d5a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6e78fe288f494bc7b7055a1cbf4fd588", + "style": "IPY_MODEL_2f9478e6a8394b069e15a4f0d988626c", + "value": "
Queue
" + } + }, + "f02d7c03dbc34222b1a387d12fac3125": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "f7e534254a5b416ea439079965a8951a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/submission/.ipynb_checkpoints/submission_runner_v1-checkpoint.ipynb b/submission/.ipynb_checkpoints/submission_runner_v1-checkpoint.ipynb new file mode 100644 index 0000000..8efbc56 --- /dev/null +++ b/submission/.ipynb_checkpoints/submission_runner_v1-checkpoint.ipynb @@ -0,0 +1,1267 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "import qiskit\n", + "from typing import Dict, List\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "import pickle\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(28, 28)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(np.ceil(np.log2(X_train.size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros(int(np.ceil(np.log2(X_train.size))))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " total_size = 2**int(np.ceil(np.log2(X_train[0].size)))\n", + " normalized_vector = [*normalized_vector, *np.zeros(total_size-len(normalized_vector))]\n", + " return normalized_vector" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAilUlEQVR4nO3df3DU9b3v8dfm1xIg2RBCfknAgAoqEFsKMdVSlFwgnesF5fRq650DvY4eaXCK9IdDj4r2dE5anGO9tVTvndNCnSnaOlfkyLHcKjShtGALwqXWNgdoFCwk/KjZDQlJNtnP/YNrNArC+8smnyQ8HzM7Q3a/L74fvnyTV77Z3XdCzjknAAD6WYrvBQAALk0UEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAv0nwv4MMSiYSOHDmirKwshUIh38sBABg559TS0qLi4mKlpJz7OmfAFdCRI0dUUlLiexkAgIt0+PBhjR079pyPD7gCysrKkiTdqM8pTemeVwMAsOpSXNv1cs/X83PpswJas2aNHnvsMTU2NqqsrExPPvmkZs6ced7cez92S1O60kIUEAAMOv9/wuj5nkbpkxch/OxnP9OKFSu0atUqvf766yorK9O8efN07NixvtgdAGAQ6pMCevzxx3X33XfrS1/6kq655ho9/fTTGj58uH784x/3xe4AAINQ0guos7NTu3fvVmVl5fs7SUlRZWWlduzY8ZHtOzo6FIvFet0AAENf0gvoxIkT6u7uVkFBQa/7CwoK1NjY+JHta2pqFIlEem68Ag4ALg3e34i6cuVKRaPRntvhw4d9LwkA0A+S/iq4vLw8paamqqmpqdf9TU1NKiws/Mj24XBY4XA42csAAAxwSb8CysjI0PTp07Vly5ae+xKJhLZs2aKKiopk7w4AMEj1yfuAVqxYocWLF+tTn/qUZs6cqSeeeEKtra360pe+1Be7AwAMQn1SQLfffruOHz+uhx9+WI2Njbruuuu0efPmj7wwAQBw6Qo555zvRXxQLBZTJBLRbC1gEgIADEJdLq5abVQ0GlV2dvY5t/P+KjgAwKWJAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeJHmewHAgBIK2TPOJX8dZ5E6OteceXfeVYH2lb1+Z6CcWYDjHUpLN2dcvNOcGfCCnKtB9dE5zhUQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHjBMFLgA0KpqeaM6+oyZ1Kuu8ac+dM/jLTv57Q5IklKb51pzqSdTtj388td5ky/DhYNMiw1wDmkkP1aoD+PQyjNVhUh56QL+LTgCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvGAYKfAB1qGLUrBhpIfn5Zgzd1b82pz5zfEJ5owkvR0uNGdcpn0/aZUV5sxVP/yrOdP11iFzRpLknD0S4HwIInXUqGDB7m57JBYzbe/chR0DroAAAF5QQAAAL5JeQI888ohCoVCv2+TJk5O9GwDAINcnzwFde+21evXVV9/fSYCfqwMAhrY+aYa0tDQVFtqfxAQAXDr65Dmg/fv3q7i4WBMmTNCdd96pQ4fO/QqUjo4OxWKxXjcAwNCX9AIqLy/XunXrtHnzZj311FNqaGjQZz7zGbW0tJx1+5qaGkUikZ5bSUlJspcEABiAkl5AVVVV+vznP69p06Zp3rx5evnll9Xc3Kyf//znZ91+5cqVikajPbfDhw8ne0kAgAGoz18dkJOTo6uuukoHDhw46+PhcFjhcLivlwEAGGD6/H1Ap06d0sGDB1VUVNTXuwIADCJJL6Cvfe1rqqur01tvvaXf/va3uvXWW5WamqovfOELyd4VAGAQS/qP4N555x194Qtf0MmTJzVmzBjdeOON2rlzp8aMGZPsXQEABrGkF9Bzzz2X7L8S6DeJ9vZ+2U/nJ06ZM38X2WXODEuJmzOSVJeSMGf+utX+Ctbuafbj8PbjWeZMYs+nzRlJGv2GfXBn9p6j5syJWZeZM8en2welSlLBTntm1KsHTdu7RKd04vzbMQsOAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALzo819IB3gRCgXLOfuAx1P/9Xpz5u+vqTVnDsbtE+XHZvzNnJGkzxfvtof+mz3zg/rPmjOtf4mYMykjgg3ubLze/j36XxfY/59cvMucGfV6sC/fKYubzJlY5wTT9l3xdmnjBazFvBIAAJKAAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAAL5iGjf4VdEr1AHb9A78zZ24a+WYfrOSjLlOwKdCtLsOcae4eYc6suubfzZnjV2WZM3EX7Evdv+7/tDlzKsC07tQu++fF9f99jzkjSYtyf2/OrP7fU03bd7n4BW3HFRAAwAsKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAeMEwUvQvF2w45kC2/1S+OXMye6Q509iVY86MTj1lzkhSVsppc+by9BPmzPFu+2DR1PSEOdPpUs0ZSXr02pfMmfar082Z9FC3OfPpYUfMGUn6/Jt/b86M0F8C7et8uAICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8YRgpcpDFh+8DPYaG4OZMR6jJnjsRHmTOStP/0JHPmP2L2oazzC/5ozsQDDBZNVbAhuEGGhBanv2vOtDv7AFP7GXTGDQX2waJ7A+7rfLgCAgB4QQEBALwwF9C2bdt0yy23qLi4WKFQSC+++GKvx51zevjhh1VUVKTMzExVVlZq//79yVovAGCIMBdQa2urysrKtGbNmrM+vnr1an3/+9/X008/rddee00jRozQvHnz1N7eftGLBQAMHeYXIVRVVamqquqsjznn9MQTT+jBBx/UggULJEnPPPOMCgoK9OKLL+qOO+64uNUCAIaMpD4H1NDQoMbGRlVWVvbcF4lEVF5erh07dpw109HRoVgs1usGABj6klpAjY2NkqSCgoJe9xcUFPQ89mE1NTWKRCI9t5KSkmQuCQAwQHl/FdzKlSsVjUZ7bocPH/a9JABAP0hqARUWFkqSmpqaet3f1NTU89iHhcNhZWdn97oBAIa+pBZQaWmpCgsLtWXLlp77YrGYXnvtNVVUVCRzVwCAQc78KrhTp07pwIEDPR83NDRo7969ys3N1bhx47R8+XJ9+9vf1pVXXqnS0lI99NBDKi4u1sKFC5O5bgDAIGcuoF27dummm27q+XjFihWSpMWLF2vdunX6xje+odbWVt1zzz1qbm7WjTfeqM2bN2vYsGHJWzUAYNALOeeCTenrI7FYTJFIRLO1QGkh+4A+DHChkD2Sah8+6brsgzslKXWUfXjnHTv+YN9PyP5pd7wry5zJSW0zZySprtk+jPSPJ8/+PO/H+dakfzNnXm+73JwpzrAPCJWCHb+3OvPMmSvDZ3+V8Mf5xbtl5owklQz7mznzy+WzTNt3dbVre+2jikajH/u8vvdXwQEALk0UEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4Yf51DMBFCTB8PZRmP02DTsM+fNfV5szNw18yZ37bfpk5MyatxZyJO/skcUkqCkfNmayCdnOmuXu4OZObdsqcaenONGckaXhKhzkT5P/pkxknzJn7X/2kOSNJWVNOmjPZ6bZrlcQFXttwBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXjCMFP0qlJ5hziTa7UMug8r7Q6c5c6I73ZzJSWkzZzJC3eZMZ8BhpJ/ObTBnjgcY+Pn66VJzJiv1tDkzJsU+IFSSStLtgzv/0F5izrzceoU5c9d/ftWckaRn/9d/MmcyNv/WtH2Ki1/YduaVAACQBBQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADw4tIeRhoKBYul2YdPhlIDdH2KPZNo77DvJ2EfchmUi9uHffan//E/f2DOHO7KMWca4/ZMTqp9gGm3gp3jO09HzJlhKRc2gPKDxqTFzJlYwj70NKiWxDBzJh5gAGyQY/fA6P3mjCS9EK0MlOsLXAEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBdDZhhpKM3+T3FdXYH2FWSgprPPGhySTi+Yac4cXmgflnrnJ35nzkhSY1eWObOn7XJzJpJ62pwZkWIfNNvu7INzJelI5yhzJshAzdy0U+ZMfoABpt0u2Pfaf43bj0MQQQbNvtNlP3aS1PJfWsyZnGcC7eq8uAICAHhBAQEAvDAX0LZt23TLLbeouLhYoVBIL774Yq/HlyxZolAo1Os2f/78ZK0XADBEmAuotbVVZWVlWrNmzTm3mT9/vo4ePdpze/bZZy9qkQCAocf8zH1VVZWqqqo+dptwOKzCwsLAiwIADH198hxQbW2t8vPzNWnSJC1dulQnT54857YdHR2KxWK9bgCAoS/pBTR//nw988wz2rJli7773e+qrq5OVVVV6u4++0tpa2pqFIlEem4lJSXJXhIAYABK+vuA7rjjjp4/T506VdOmTdPEiRNVW1urOXPmfGT7lStXasWKFT0fx2IxSggALgF9/jLsCRMmKC8vTwcOHDjr4+FwWNnZ2b1uAIChr88L6J133tHJkydVVFTU17sCAAwi5h/BnTp1qtfVTENDg/bu3avc3Fzl5ubq0Ucf1aJFi1RYWKiDBw/qG9/4hq644grNmzcvqQsHAAxu5gLatWuXbrrppp6P33v+ZvHixXrqqae0b98+/eQnP1Fzc7OKi4s1d+5c/dM//ZPC4XDyVg0AGPRCzjnnexEfFIvFFIlENFsLlBYKNkhxIEorsr8vKl5aYM787erh5kxbYcickaTrPvcnc2ZJwXZz5ni3/XnB9FCwQbMt3ZnmTGF6szmzNXqNOTMyzT6MNMjQU0n6ZOZb5kxzwn7uFae9a848cODvzJmC4fYBnJL0r+NfNmfiLmHO1Mft36BnpdiHIkvSr9uuMGc2XDPGtH2Xi6tWGxWNRj/2eX1mwQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMCLpP9Kbl86qmaYM/n/+JdA+7ou+x1z5ppM+xTo9oR9GviwlLg58+bpy8wZSWpLZJgz+zvtU8GjXfYpy6kh+0RiSTrWmWXO/EtDpTmzZebT5syDR+abMymZwYbdn+weac4sGhkLsCf7Of4P47aZMxMyjpkzkrSp1f6LNI/ER5kzBelRc+by9OPmjCTdlvUf5swG2aZhXyiugAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADAiwE7jDSUlqZQ6MKXV/7PvzfvY07WH80ZSWpzYXMmyGDRIEMNg4iktQXKdcTtp8+xeHagfVldFW4MlLs1e685s+0H5ebMje33mTMHb15rzmw5nWrOSNLxLvv/0x0NN5szrx8qMWeuv7zBnJma9VdzRgo2CDcrtd2cSQ91mTOtCfvXIUna2W4fNNtXuAICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8G7DDSo0unKzU87IK3fyTypHkf6/92vTkjSSXD/mbOjM84Yc6UZb5tzgSRlWIfnihJk7LtAxQ3tY41Z2qbJ5szRenN5owk/bptojnz3COPmTNL7v+qOVPx8r3mTOzyYN9jdo1w5kx22Ulz5sFP/Ls5kxHqNmeau+1DRSUpN9xqzuSkBhvuaxVkKLIkZaWcNmdSJ11h2t51d0j7z78dV0AAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMALCggA4MWAHUY6/FhCqRmJC95+U+w68z4mZB43ZyTpRDzLnPk/p6aaM2Mz3zVnIqn2QYNXhBvNGUna255jzmw+fq05U5wZM2ea4hFzRpJOxkeYM20J+1DIH33vcXPmX5oqzZlbc183ZySpLMM+WLQ5Yf9+9s3OQnOmJXHhQ4rf0+7SzRlJigYYYpoV4HMw7uxfilPdhX99/KCcFPuw1NjU0abtu+LtDCMFAAxcFBAAwAtTAdXU1GjGjBnKyspSfn6+Fi5cqPr6+l7btLe3q7q6WqNHj9bIkSO1aNEiNTU1JXXRAIDBz1RAdXV1qq6u1s6dO/XKK68oHo9r7ty5am19/5c23X///XrppZf0/PPPq66uTkeOHNFtt92W9IUDAAY30zNfmzdv7vXxunXrlJ+fr927d2vWrFmKRqP60Y9+pPXr1+vmm2+WJK1du1ZXX321du7cqeuvD/YbSAEAQ89FPQcUjUYlSbm5uZKk3bt3Kx6Pq7Ly/VfrTJ48WePGjdOOHTvO+nd0dHQoFov1ugEAhr7ABZRIJLR8+XLdcMMNmjJliiSpsbFRGRkZysnJ6bVtQUGBGhvP/lLfmpoaRSKRnltJSUnQJQEABpHABVRdXa033nhDzz333EUtYOXKlYpGoz23w4cPX9TfBwAYHAK9EXXZsmXatGmTtm3bprFjx/bcX1hYqM7OTjU3N/e6CmpqalJh4dnfcBYOhxUO29/IBwAY3ExXQM45LVu2TBs2bNDWrVtVWlra6/Hp06crPT1dW7Zs6bmvvr5ehw4dUkVFRXJWDAAYEkxXQNXV1Vq/fr02btyorKysnud1IpGIMjMzFYlEdNddd2nFihXKzc1Vdna27rvvPlVUVPAKOABAL6YCeuqppyRJs2fP7nX/2rVrtWTJEknS9773PaWkpGjRokXq6OjQvHnz9MMf/jApiwUADB0h55zzvYgPisViikQimnXjQ0pLu/ChgzOe2G3e1xuxYnNGkgqGtZgz00a+Y87Ut9kHNR45nW3ODE+LmzOSlJlqz3U5++te8sP24z0ubB+mKUlZKfZBkhmhbnOmO8Drf67NOGLOHOoaZc5IUmNXjjnzZpv982lUmn0w5h8CfN62dWWYM5LU0W1/mry9y56JhNvNmRm5b5szkpQi+5f89f/2WdP2ifZ2/eXb/6hoNKrs7HN/TWIWHADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALwI9BtR+0PK9n1KCaVf8PbP//IG8z4eWvC8OSNJdc2TzZlNjVPNmVin/TfFjhneas5kp9unTUtSbrp9X5EA04+HhbrMmXe7RpgzktSRcuHn3Hu6FTJnGjsi5sxvEleaM/FEqjkjSR0BckGmo/+tM8+cKc6MmjMtXRc+Wf+D3mrJNWdOREeaM+3D7V+Kt3dPNGckaX7hH82ZzGO2c7y748K25woIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALwIOeec70V8UCwWUyQS0WwtUJphGGkQ0TuvD5Sb8OV6c2ZmToM583psnDlzKMDwxHgi2Pch6SkJc2Z4eqc5MyzAkMuM1G5zRpJSZP90SAQYRjoi1X4cRqR1mDPZae3mjCRlpdpzKSH7+RBEaoD/o99FL0/+Qs4hK8D/U5ezfw5WRA6aM5L044ZPmzORzx0wbd/l4qrVRkWjUWVnZ59zO66AAABeUEAAAC8oIACAFxQQAMALCggA4AUFBADwggICAHhBAQEAvKCAAABeUEAAAC8oIACAFxQQAMCLgTuMNOU22zDSRLDhk/2ldVG5OVP+zd/bM1n2AYWTM5rMGUlKl3345LAAAytHpNiHfbYHPK2DfEe2/XSJOdMdYE9b373anIkHGHIpSU1t5x4geS7pAQfAWiWc/Xw43RVssHH09DBzJjXFfu611+aZM6PftA/plaTwy/avK1YMIwUADGgUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8GLgDiPVAtswUgQWmjE1UO50YaY5Ez7ZYc60jLfvJ/tgqzkjSSkdXeZM4v/+KdC+gKGKYaQAgAGNAgIAeGEqoJqaGs2YMUNZWVnKz8/XwoULVV9f32ub2bNnKxQK9brde++9SV00AGDwMxVQXV2dqqurtXPnTr3yyiuKx+OaO3euWlt7/7z97rvv1tGjR3tuq1evTuqiAQCDX5pl482bN/f6eN26dcrPz9fu3bs1a9asnvuHDx+uwsLC5KwQADAkXdRzQNFoVJKUm5vb6/6f/vSnysvL05QpU7Ry5Uq1tbWd8+/o6OhQLBbrdQMADH2mK6APSiQSWr58uW644QZNmTKl5/4vfvGLGj9+vIqLi7Vv3z498MADqq+v1wsvvHDWv6empkaPPvpo0GUAAAapwO8DWrp0qX7xi19o+/btGjt27Dm327p1q+bMmaMDBw5o4sSJH3m8o6NDHR3vvzckFouppKSE9wH1I94H9D7eBwRcvAt9H1CgK6Bly5Zp06ZN2rZt28eWjySVl5dL0jkLKBwOKxwOB1kGAGAQMxWQc0733XefNmzYoNraWpWWlp43s3fvXklSUVFRoAUCAIYmUwFVV1dr/fr12rhxo7KystTY2ChJikQiyszM1MGDB7V+/Xp97nOf0+jRo7Vv3z7df//9mjVrlqZNm9Yn/wAAwOBkKqCnnnpK0pk3m37Q2rVrtWTJEmVkZOjVV1/VE088odbWVpWUlGjRokV68MEHk7ZgAMDQYP4R3McpKSlRXV3dRS0IAHBpCPwybAwd7vd/CJQbluR1nEv2b/tpR5IS/bcr4JLHMFIAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAvKCAAgBcUEADACwoIAOAFBQQA8IICAgB4QQEBALyggAAAXlBAAAAv0nwv4MOcc5KkLsUl53kxAACzLsUlvf/1/FwGXAG1tLRIkrbrZc8rAQBcjJaWFkUikXM+HnLnq6h+lkgkdOTIEWVlZSkUCvV6LBaLqaSkRIcPH1Z2dranFfrHcTiD43AGx+EMjsMZA+E4OOfU0tKi4uJipaSc+5meAXcFlJKSorFjx37sNtnZ2Zf0CfYejsMZHIczOA5ncBzO8H0cPu7K5z28CAEA4AUFBADwYlAVUDgc1qpVqxQOh30vxSuOwxkchzM4DmdwHM4YTMdhwL0IAQBwaRhUV0AAgKGDAgIAeEEBAQC8oIAAAF4MmgJas2aNLr/8cg0bNkzl5eX63e9+53tJ/e6RRx5RKBTqdZs8ebLvZfW5bdu26ZZbblFxcbFCoZBefPHFXo875/Twww+rqKhImZmZqqys1P79+/0stg+d7zgsWbLkI+fH/Pnz/Sy2j9TU1GjGjBnKyspSfn6+Fi5cqPr6+l7btLe3q7q6WqNHj9bIkSO1aNEiNTU1eVpx37iQ4zB79uyPnA/33nuvpxWf3aAooJ/97GdasWKFVq1apddff11lZWWaN2+ejh075ntp/e7aa6/V0aNHe27bt2/3vaQ+19raqrKyMq1Zs+asj69evVrf//739fTTT+u1117TiBEjNG/ePLW3t/fzSvvW+Y6DJM2fP7/X+fHss8/24wr7Xl1dnaqrq7Vz50698sorisfjmjt3rlpbW3u2uf/++/XSSy/p+eefV11dnY4cOaLbbrvN46qT70KOgyTdfffdvc6H1atXe1rxObhBYObMma66urrn4+7ubldcXOxqamo8rqr/rVq1ypWVlflehleS3IYNG3o+TiQSrrCw0D322GM99zU3N7twOOyeffZZDyvsHx8+Ds45t3jxYrdgwQIv6/Hl2LFjTpKrq6tzzp35v09PT3fPP/98zzZ/+tOfnCS3Y8cOX8vscx8+Ds4599nPftZ95Stf8beoCzDgr4A6Ozu1e/duVVZW9tyXkpKiyspK7dixw+PK/Ni/f7+Ki4s1YcIE3XnnnTp06JDvJXnV0NCgxsbGXudHJBJReXn5JXl+1NbWKj8/X5MmTdLSpUt18uRJ30vqU9FoVJKUm5srSdq9e7fi8Xiv82Hy5MkaN27ckD4fPnwc3vPTn/5UeXl5mjJlilauXKm2tjYfyzunATeM9MNOnDih7u5uFRQU9Lq/oKBAf/7znz2tyo/y8nKtW7dOkyZN0tGjR/Xoo4/qM5/5jN544w1lZWX5Xp4XjY2NknTW8+O9xy4V8+fP12233abS0lIdPHhQ3/zmN1VVVaUdO3YoNTXV9/KSLpFIaPny5brhhhs0ZcoUSWfOh4yMDOXk5PTadiifD2c7DpL0xS9+UePHj1dxcbH27dunBx54QPX19XrhhRc8rra3AV9AeF9VVVXPn6dNm6by8nKNHz9eP//5z3XXXXd5XBkGgjvuuKPnz1OnTtW0adM0ceJE1dbWas6cOR5X1jeqq6v1xhtvXBLPg36ccx2He+65p+fPU6dOVVFRkebMmaODBw9q4sSJ/b3MsxrwP4LLy8tTamrqR17F0tTUpMLCQk+rGhhycnJ01VVX6cCBA76X4s175wDnx0dNmDBBeXl5Q/L8WLZsmTZt2qRf/epXvX59S2FhoTo7O9Xc3Nxr+6F6PpzrOJxNeXm5JA2o82HAF1BGRoamT5+uLVu29NyXSCS0ZcsWVVRUeFyZf6dOndLBgwdVVFTkeynelJaWqrCwsNf5EYvF9Nprr13y58c777yjkydPDqnzwzmnZcuWacOGDdq6datKS0t7PT59+nSlp6f3Oh/q6+t16NChIXU+nO84nM3evXslaWCdD75fBXEhnnvuORcOh926devcm2++6e655x6Xk5PjGhsbfS+tX331q191tbW1rqGhwf3mN79xlZWVLi8vzx07dsz30vpUS0uL27Nnj9uzZ4+T5B5//HG3Z88e9/bbbzvnnPvOd77jcnJy3MaNG92+ffvcggULXGlpqTt9+rTnlSfXxx2HlpYW97Wvfc3t2LHDNTQ0uFdffdV98pOfdFdeeaVrb2/3vfSkWbp0qYtEIq62ttYdPXq059bW1tazzb333uvGjRvntm7d6nbt2uUqKipcRUWFx1Un3/mOw4EDB9y3vvUtt2vXLtfQ0OA2btzoJkyY4GbNmuV55b0NigJyzrknn3zSjRs3zmVkZLiZM2e6nTt3+l5Sv7v99ttdUVGRy8jIcJdddpm7/fbb3YEDB3wvq8/96le/cpI+clu8eLFz7sxLsR966CFXUFDgwuGwmzNnjquvr/e76D7wccehra3NzZ07140ZM8alp6e78ePHu7vvvnvIfZN2tn+/JLd27dqebU6fPu2+/OUvu1GjRrnhw4e7W2+91R09etTfovvA+Y7DoUOH3KxZs1xubq4Lh8PuiiuucF//+tddNBr1u/AP4dcxAAC8GPDPAQEAhiYKCADgBQUEAPCCAgIAeEEBAQC8oIAAAF5QQAAALyggAIAXFBAAwAsKCADgBQUEAPCCAgIAePH/AIe0yFA5VNd3AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "import matplotlib.pyplot as plt\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),X_train[0].shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "#import pennylane as qml\n", + "#dev = qml.device(\"default.qubit\", wires=10)\n", + "#\n", + "#def block(weights, wires):\n", + "# qml.CNOT(wires=[wires[0],wires[1]])\n", + "# qml.RY(weights[0], wires=wires[0])\n", + "# qml.RY(weights[1], wires=wires[1])\n", + "#\n", + "# \n", + "#import pennylane as qml\n", + "#\n", + "#n_wires = dev.num_wires\n", + "#n_block_wires = 2\n", + "#n_params_block = 2\n", + "#n_blocks = qml.TTN.get_n_blocks(range(n_wires),n_block_wires)\n", + "#n_blocks\n", + "# \n", + "#@qml.qnode(dev)\n", + "#def circuit(weights, x):\n", + "#\n", + "# qml.AmplitudeEmbedding(x, wires=[i for i in range(10)],normalize=True,pad_with=True)\n", + "#\n", + "# for w in weights:\n", + "#\n", + "# qml.TTN(range(n_wires),n_block_wires,block, n_params_block, w)\n", + "# #print(w)\n", + "# #print(x)\n", + "# \n", + "# return qml.expval(qml.PauliZ(3))\n", + "#np.random.seed(0)\n", + "#num_layers = 1\n", + "#weights_init = 2*np.pi * np.random.randn(num_layers,n_blocks, n_params_block)\n", + "#print(weights_init.shape)\n", + "#\n", + "#print(qml.draw(circuit,expansion_strategy='device',wire_order=[i for i in range(10)])(weights_init,np.asarray(X_train[0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "#from qbraid import circuit_wrapper\n", + "# maybe we can use qbraid sdk\n", + "#TTN_circ = circuit_wrapper(n_blocks).transpile('qiskit')\n", + "#TTN_circ.draw()\n", + "#print(qml.draw(n_blocks)(weights))\n", + "#qml.draw(n_blocks)([0,0,0,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "#def _block(self, qubits, symbols):\n", + "#\n", + "# #assert len(qubits) == 2\n", + "# #assert len(qubits) == len(symbols)\n", + "# qc = QuantumCircuit()\n", + "# qc.y()\n", + "# \n", + "# #\n", + "# #return cirq.Circuit(\n", + "# # cirq.Y(qubits[0])**symbols[0],\n", + "# # cirq.Y(qubits[1])**symbols[1], cirq.CNOT(qubits[0], qubits[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "#data_symbols = []\n", + "#\n", + "#ansatz = QuantumCircuit()\n", + "#for l in range(n_layers):\n", + "# for idx, w in enumerate(ind_gates):\n", + "# ansatz.append(block(w, var_symbols[l, idx]))\n", + "# \n", + "# ## Re-encoding layer\n", + "# #if drc and (l < n_layers - 1):\n", + "# # data_circuit, expr = cirq.flatten(\n", + "# # feature_map.build(qubits, in_symbols[l]))\n", + "# # circuit += data_circuit\n", + "# # data_symbols += list(expr.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import RealAmplitudes, EfficientSU2\n", + "ansatz = RealAmplitudes(10, reps=2)\n", + "\n", + "# todo: TTN, example: https://github.com/Gopal-Dahale/qml-hep-lhc/blob/0632e2bcf892965303faa3ebc7322bc87b9ad6b3/qml_hep_lhc/ansatzes/ttn.py\n", + "# def tnn():\n", + "\n", + "#ansatz.draw()\n", + "#ansatz_ = ansatz.decompose(reps=20)\n", + "#print(ansatz_.depth())\n", + "#print(f\"Circuit operations: {ansatz_.count_ops()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "EfficientSU2(4,reps=97).num_parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\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" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "after_ = np.array(list(new_histogram.values())[:784])\n", + "plt.imshow(np.reshape(after_,X_train[0].shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "de_normalized_vector = de_normalize(after_,X_train[0])\n", + "plt.imshow(np.reshape(after_,X_train[0].shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import StatePreparation\n", + "def encode_qiskit(x,num_qubit=10):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit) #\n", + " qc = qc.bind_parameters(normalized_vector)\n", + " return qc\n", + "\n", + "def decode(histogram,data):\n", + " new_histogram = {}\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values()))\n", + " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#grade part1\n", + "#from part1 import encode_qiskit,decode\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "dataset = X_train[:1]\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_qiskit(data)\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + " \n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #reconstruct \n", + " image_re=decode(histogram,data)\n", + " print(image_re)\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(np.asarray(data),np.asarray(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))\n", + "# score should be between 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#traning_qc = QuantumCircuit(10,10)\n", + "#traning_qc.append(qc,[i for i in range(10)])\n", + "#traning_qc.append(ansatz_,[i for i in range(10)])\n", + "##qc.append(ansatz)\n", + "#traning_qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "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": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_machine_learning.algorithms.classifiers import VQC\n", + "vqc = VQC(\n", + " feature_map=qc,\n", + " ansatz=ansatz,\n", + " loss=\"cross_entropy\",\n", + " optimizer=COBYLA(maxiter=100),\n", + " quantum_instance=Aer.get_backend('statevector_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time elapsed: 801.2947278022766\n" + ] + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.24" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.115457980475161) q0; ry(1.86754040076432) q1; ry(2.08259753153251) q2; ry(0.234300570835282) q3; ry(0.515953141990566) q4; ry(1.65349395917796) q5; ry(1.08491471456546) q6; ry(1.08177932104991) q7; ry(1.40894078946757) q8; ry(0.26263646789421) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.233474718079866) q0; ry(-0.0939336402061521) q1; ry(0.191350773286554) q2; ry(1.21728713898372) q3; ry(-0.278541286887399) q4; ry(1.0410986521404) q5; ry(1.43966822397902) q6; ry(-0.125766054772392) q7; ry(0.587831141919945) q8; ry(0.684098279334956) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.10858394593622) q0; ry(0.409505677662811) q1; ry(1.12943503462716) q2; ry(0.0767765652349061) q3; ry(0.441295454568967) q4; ry(1.77246112475261) q5; ry(0.337942415009636) q6; ry(0.87410124616346) q7; ry(0.171878664200548) q8; ry(0.26780522610314) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.115457980475161,1.86754040076432,2.08259753153251,0.234300570835282,0.515953141990566,1.65349395917796,1.08491471456546,1.08177932104991,1.40894078946757,0.26263646789421,0.233474718079866,-0.0939336402061521,0.191350773286554,1.21728713898372,-0.278541286887399,1.0410986521404,1.43966822397902,-0.125766054772392,0.587831141919945,0.684098279334956,1.10858394593622,0.409505677662811,1.12943503462716,0.0767765652349061,0.441295454568967,1.77246112475261,0.337942415009636,0.87410124616346,0.171878664200548,0.26780522610314) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"test.qasm\", \"w\") as f:\n", + " f.write(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_recovered = QuantumCircuit.from_qasm_file(\"test.qasm\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import SPSA" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.utils import algorithm_globals\n", + "algorithm_globals.random_seed = 0\n", + "\n", + "import numpy as np\n", + "np.random.seed(algorithm_globals.random_seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import TwoLocal\n", + "qc_twolocal = TwoLocal(num_qubits=10, reps=2, rotation_blocks=['ry','rz'],\n", + " entanglement_blocks='cx', skip_final_rotation_layer=True,\n", + " insert_barriers=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_twolocal_spsa300 = VQC(\n", + " feature_map=qc,\n", + " ansatz=qc_twolocal,\n", + " loss=\"cross_entropy\",\n", + " optimizer=SPSA(maxiter=100),\n", + " quantum_instance=Aer.get_backend('statevector_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc_twolocal_spsa300.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_twolocal_cobyla300.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.266317714019139) q0; ry(1.32035044188513) q1; ry(0.375724625916453) q2; ry(-0.145527578194223) q3; ry(1.24796981173025) q4; ry(-0.3722525242738) q5; ry(0.98731246639232) q6; ry(1.98782341512519) q7; ry(1.66430495324693) q8; ry(0.760045740348774) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.76943425343952) q0; ry(1.54002486179664) q1; ry(1.5166941190635) q2; ry(2.08820456685236) q3; ry(0.502872321522427) q4; ry(0.5226897740692) q5; ry(1.34895736320983) q6; ry(0.17808386546728) q7; ry(1.48787325816064) q8; ry(1.19251464386051) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.63207747410879) q0; ry(0.944742510667842) q1; ry(1.4738548596109) q2; ry(0.0395594736234817) q3; ry(0.160988017972572) q4; ry(-0.139909848244233) q5; ry(0.217661325699283) q6; ry(1.51612158505368) q7; ry(0.709288700436131) q8; ry(2.00665865500557) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.266317714019139,1.32035044188513,0.375724625916453,-0.145527578194223,1.24796981173025,-0.3722525242738,0.98731246639232,1.98782341512519,1.66430495324693,0.760045740348774,1.76943425343952,1.54002486179664,1.5166941190635,2.08820456685236,0.502872321522427,0.5226897740692,1.34895736320983,0.17808386546728,1.48787325816064,1.19251464386051,1.63207747410879,0.944742510667842,1.4738548596109,0.0395594736234817,0.160988017972572,-0.139909848244233,0.217661325699283,1.51612158505368,0.709288700436131,2.00665865500557) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "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))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ionq", + "language": "python", + "name": "ionq" + }, + "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.10.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01129f7555644e438bddefcdf79a20a9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "0853aa3888bd497c949dc547e1365817": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "0d462f3fbd1e486fbfde53dea40368ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "217dee64d375487a927af567b3719d62": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "22205bd9b1664c9fbb8d0f97ecec05b2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "26e034e4883447c08d5dfc07e752c6ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "283e1cbcded2433ebe4217311882c641": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2c6d8adf39f248c49707b3923989750d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "31423c8447db46e4af5eca52a7c31cef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_5d7b584c3e3e42b082b106a523b526af", + "style": "IPY_MODEL_283e1cbcded2433ebe4217311882c641", + "value": "

Circuit Properties

" + } + }, + "4a7e631dfd2f4eb881827b5ea1811d70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_7206bf28aaa34f54a0f1633f793485e4" + ], + "layout": "IPY_MODEL_b1bbfaad78864ab4816b0aa3b753053e" + } + }, + "4c306a14df5f4c8f94bad2bb018932ea": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6dc1e6d89c814def95b2089625ceaf24", + "style": "IPY_MODEL_217dee64d375487a927af567b3719d62", + "value": "
Backend
" + } + }, + "549fcb7e2eb44c3abf3a592eae8d5714": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_22205bd9b1664c9fbb8d0f97ecec05b2", + "style": "IPY_MODEL_26e034e4883447c08d5dfc07e752c6ca", + "value": "
Queue
" + } + }, + "5d7b584c3e3e42b082b106a523b526af": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "698705070469409dbde3be8f5be4ea1b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "6992111baa68498a8175f77873841738": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "6dc1e6d89c814def95b2089625ceaf24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "7206bf28aaa34f54a0f1633f793485e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_eb80f343098c453c9f2ea1e0989ea2f9", + "style": "IPY_MODEL_6992111baa68498a8175f77873841738" + } + }, + "72f5fdcc1f5e42c8b195bf0c95805c70": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_d4ee0cffb08946e5beb072f0dd64a055", + "IPY_MODEL_4c306a14df5f4c8f94bad2bb018932ea", + "IPY_MODEL_b66900bbbfef4ab58db9e5324cbd13bb", + "IPY_MODEL_549fcb7e2eb44c3abf3a592eae8d5714", + "IPY_MODEL_e92cc7291e2f477a91b4867f68efd32b" + ], + "layout": "IPY_MODEL_bf9c597c799a4f4e8de0308fe0cca137" + } + }, + "a190deb8f429465193854b619df653c9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "b1bbfaad78864ab4816b0aa3b753053e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "b66900bbbfef4ab58db9e5324cbd13bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_0d462f3fbd1e486fbfde53dea40368ec", + "style": "IPY_MODEL_698705070469409dbde3be8f5be4ea1b", + "value": "
Status
" + } + }, + "bf9c597c799a4f4e8de0308fe0cca137": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "d4ee0cffb08946e5beb072f0dd64a055": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a190deb8f429465193854b619df653c9", + "style": "IPY_MODEL_01129f7555644e438bddefcdf79a20a9", + "value": "
Job ID
" + } + }, + "e92cc7291e2f477a91b4867f68efd32b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_2c6d8adf39f248c49707b3923989750d", + "style": "IPY_MODEL_0853aa3888bd497c949dc547e1365817", + "value": "
Message
" + } + }, + "eb80f343098c453c9f2ea1e0989ea2f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/submission/submission_runner.ipynb b/submission/submission_runner.ipynb new file mode 100644 index 0000000..55a0832 --- /dev/null +++ b/submission/submission_runner.ipynb @@ -0,0 +1,1318 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "import qiskit\n", + "from typing import Dict, List\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "import pickle\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "data_shape = X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "28*28" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " total_size = 2**int(np.ceil(np.log2(X_train[0].size)))\n", + " normalized_vector = [*normalized_vector, *np.zeros(total_size-len(normalized_vector))]\n", + " return normalized_vector\n", + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(\n", + " X_train[0], np.reshape(np.array(de_normalized_vector[:784]),data_shape), rtol=1e-2\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),data_shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import cv2\n", + "\n", + "def amplitude_encode(img, depth=11):\n", + " # Quantize image intensity values into depth levels\n", + " quantized = np.clip(np.round(img / (256 / depth)), 0, depth - 1).astype(np.uint8)\n", + " # Map quantized intensity levels to amplitude values\n", + " amplitudes = quantized * (256 / depth)\n", + " return amplitudes\n", + "\n", + "# Load an image\n", + "img = X_train[0]#cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\n", + "# Do amplitude encoding with a depth of 11\n", + "encoded = amplitude_encode(img, depth=11)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'numpy.float64' object cannot be interpreted as an integer", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[29], line 26\u001b[0m\n\u001b[0;32m 23\u001b[0m img \u001b[38;5;241m=\u001b[39m X_train[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;66;03m#.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\u001b[39;00m\n\u001b[0;32m 25\u001b[0m \u001b[38;5;66;03m# Cut the image into parts\u001b[39;00m\n\u001b[1;32m---> 26\u001b[0m parts \u001b[38;5;241m=\u001b[39m [img[i:i\u001b[38;5;241m+\u001b[39mpart_size, j:j\u001b[38;5;241m+\u001b[39mpart_size] \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpart_size\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 27\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, img\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], part_size)]\n\u001b[0;32m 29\u001b[0m \u001b[38;5;66;03m# Initialize the quantum circuit and registers\u001b[39;00m\n\u001b[0;32m 30\u001b[0m qr \u001b[38;5;241m=\u001b[39m QuantumRegister(n_qubits)\n", + "\u001b[1;31mTypeError\u001b[0m: 'numpy.float64' object cannot be interpreted as an integer" + ] + } + ], + "source": [ + "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", + "from qiskit import execute, Aer\n", + "import numpy as np\n", + "\n", + "# Function to angle encode a part of the image\n", + "def angle_encode_part(part, qc, qr, cr, n_qubits):\n", + " # Convert the part of the image to an angle value in radians\n", + " angle = 2 * np.pi * part / 256\n", + " # Apply the angle encoding using n_qubits qubits\n", + " for i in range(n_qubits):\n", + " qc.ry(angle, qr[i])\n", + " # Measure the qubits\n", + " for i in range(n_qubits):\n", + " qc.measure(qr[i], cr[i])\n", + "\n", + "# Define the number of qubits to use for each part\n", + "n_qubits = 4\n", + "\n", + "# Define the size of the parts\n", + "part_size = 28 // np.sqrt(n_qubits)\n", + "\n", + "# Load the image\n", + "img = X_train[0]#.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\n", + "\n", + "# Cut the image into parts\n", + "parts = [img[i:i+part_size, j:j+part_size] for i in range(0, img.shape[0], part_size)\n", + " for j in range(0, img.shape[1], part_size)]\n", + "\n", + "# Initialize the quantum circuit and registers\n", + "qr = QuantumRegister(n_qubits)\n", + "cr = ClassicalRegister(n_qubits)\n", + "qc = QuantumCircuit(qr, cr)\n", + "\n", + "# Loop over each part and apply angle encoding\n", + "for part in parts:\n", + " angle_encode_part(part, qc, qr, cr, n_qubits)\n", + "\n", + "# Execute the circuit on a simulator\n", + "backend = Aer.get_backend('qasm_simulator')\n", + "job = execute(qc, backend, shots=1)\n", + "result = job.result()\n", + "\n", + "# Collect the results\n", + "encoded_parts = [int(''.join([str(x) for x in result.get_counts(i).keys()]), 2)\n", + " for i in range(len(parts))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#scaler.inverse_transform(scaler.transform(X_train[0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend,optimization_level=0,shots=1024)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\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" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#histogram = simulate(qc.bind_parameters(normalized_vector))\n", + "#print(histogram)\n", + "#new_histogram = {}\n", + "#\n", + "#for key in range(len(qc.parameters)):\n", + "# if key in histogram:\n", + "# new_histogram[key] = histogram[key]\n", + "# else:\n", + "# new_histogram[key] = 0\n", + "#print(new_histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "#import matplotlib.pyplot as plt\n", + "#after_ = np.array(list(new_histogram.values())[:784])\n", + "#plt.imshow(np.reshape(after_,data_shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "#de_normalized_vector = de_normalize(after_,X_train[0])\n", + "#plt.imshow(np.reshape(after_,data_shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import StatePreparation\n", + "def encode_qiskit(x,num_qubit=10):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit) #\n", + " qc = qc.bind_parameters(normalized_vector)\n", + " return qc\n", + "\n", + "def decode(histogram,data):\n", + " new_histogram = {}\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values()))\n", + " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 2.53682360e-04 0.00000000e+00 0.00000000e+00 4.28723188e-02\n", + " 1.35187330e+00 0.00000000e+00 0.00000000e+00 2.53682360e-04\n", + " 4.05891776e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.53682360e-04 2.53682360e-04 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 2.28314124e-03 0.00000000e+00 3.28772339e-01 4.69210893e+00\n", + " 4.09164279e+00 9.75154992e-01 7.39737762e-01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 2.53682360e-04 2.28314124e-03\n", + " 4.05891776e-03 0.00000000e+00 0.00000000e+00 2.28314124e-03]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 9.13256496e-03 0.00000000e+00 2.63931127e+00 1.05572451e+01\n", + " 7.85806478e+00 4.55512046e+00 5.26035742e+00 3.83796043e+00\n", + " 1.34197968e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 3.65302598e-02 2.53682360e-02 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 6.09471870e+00 1.41290927e+01\n", + " 1.08700354e+01 8.03767190e+00 2.90440934e+00 6.17361391e+00\n", + " 6.57570045e+00 3.01400012e+00 1.03908295e+00 1.34197968e-01\n", + " 1.50408271e+00 4.28723188e+00 1.31508935e+00 5.70785310e-02]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 2.53682360e-04\n", + " 0.00000000e+00 1.20778172e+00 1.08700354e+01 1.26153701e+01\n", + " 1.20560005e+01 1.18358042e+01 1.18358042e+01 6.74008662e+00\n", + " 4.09164279e+00 3.71416343e+00 3.77580825e+00 5.40749319e+00\n", + " 5.04345900e+00 1.96451620e+00 7.50493894e+00 1.10504036e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.53682360e-04 2.53682360e-04 2.53682360e-04\n", + " 0.00000000e+00 1.01472944e+01 1.36541993e+01 1.36541993e+01\n", + " 1.37721616e+01 1.33033566e+01 1.26153701e+01 1.26153701e+01\n", + " 1.17264671e+01 1.15093150e+01 6.82304076e+00 4.09164279e+00\n", + " 3.83796043e+00 9.74546154e+00 1.33033566e+01 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 8.49556856e+00 1.28426695e+01 1.18358042e+01\n", + " 1.26153701e+01 1.31874238e+01 1.40096083e+01 1.30719983e+01\n", + " 1.27287661e+01 1.25024814e+01 1.27287661e+01 1.23901001e+01\n", + " 1.26153701e+01 1.52272837e+01 7.59245935e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.44941423e+00 1.31874238e+01 1.20560005e+01\n", + " 1.15093150e+01 9.94536324e+00 8.21930847e+00 1.14015000e+01\n", + " 1.11873921e+01 1.12941924e+01 1.15093150e+01 1.26153701e+01\n", + " 1.22782262e+01 1.49796897e+01 1.03512550e+01 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.53682360e-04 2.28314124e-03 0.00000000e+00\n", + " 3.65302598e-02 1.21668597e+01 1.22782262e+01 1.14015000e+01\n", + " 1.20560005e+01 9.35174652e+00 7.24542189e+00 1.30719983e+01\n", + " 1.09753136e+01 1.20560005e+01 1.27287661e+01 1.14015000e+01\n", + " 1.29570802e+01 9.84515871e+00 1.10810992e+01 6.85957102e-01]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 9.13256496e-03 0.00000000e+00\n", + " 2.48634081e+00 1.51032330e+01 1.25024814e+01 1.22782262e+01\n", + " 1.20560005e+01 1.04539964e+01 9.94536324e+00 1.23901001e+01\n", + " 1.17264671e+01 1.15093150e+01 1.25024814e+01 1.22782262e+01\n", + " 1.52272837e+01 3.59239590e+00 7.07494734e+00 7.95547881e-01]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 4.05891776e-03 0.00000000e+00 0.00000000e+00\n", + " 7.67389139e-01 1.41290927e+01 1.31874238e+01 1.34197968e+01\n", + " 1.31874238e+01 1.46121039e+01 1.36541993e+01 1.15093150e+01\n", + " 1.20560005e+01 1.26153701e+01 1.38906313e+01 1.19456487e+01\n", + " 1.19456487e+01 1.10810992e+01 2.14716750e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 2.53682360e-04 4.05891776e-03\n", + " 9.13256496e-03 1.24304356e-02 1.01472944e-03 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.42490845e+01 1.29570802e+01 1.19456487e+01 1.26153701e+01\n", + " 1.25024814e+01 1.21668597e+01 1.25024814e+01 1.23901001e+01\n", + " 1.18358042e+01 1.26153701e+01 1.33033566e+01 1.17264671e+01\n", + " 1.20560005e+01 1.64956955e+01 1.50408271e+00 0.00000000e+00]\n", + " [0.00000000e+00 2.28314124e-03 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.75154992e-01 5.33367162e+00 1.05572451e+01\n", + " 1.31874238e+01 1.08700354e+01 1.15093150e+01 1.23901001e+01\n", + " 1.20560005e+01 1.09753136e+01 1.12941924e+01 1.20560005e+01\n", + " 1.27287661e+01 1.26153701e+01 1.21668597e+01 1.17264671e+01\n", + " 1.27287661e+01 1.51032330e+01 6.41334374e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 8.21930847e-02 4.91129049e-01 1.70576019e+00 2.90440934e+00\n", + " 9.06178758e+00 1.31874238e+01 1.22782262e+01 1.25024814e+01\n", + " 1.19456487e+01 1.29570802e+01 1.01472944e+01 1.06610012e+01\n", + " 1.12941924e+01 1.34197968e+01 1.27287661e+01 1.38906313e+01\n", + " 7.85806478e+00 8.96614933e+00 1.58551475e+01 1.56024799e+01\n", + " 1.37721616e+01 1.43695836e+01 1.17264671e+01 0.00000000e+00]\n", + " [0.00000000e+00 8.24213988e-01 8.87101845e+00 1.09753136e+01\n", + " 1.27287661e+01 1.23901001e+01 1.27287661e+01 1.09753136e+01\n", + " 1.05572451e+01 1.16176374e+01 1.09753136e+01 1.10810992e+01\n", + " 1.01472944e+01 6.41334374e+00 1.52272837e+01 9.44941423e+00\n", + " 1.07652646e+01 1.26153701e+01 1.64956955e+01 1.64956955e+01\n", + " 1.23901001e+01 1.38906313e+01 1.23901001e+01 1.12941924e+01\n", + " 1.22782262e+01 1.36541993e+01 1.53518417e+01 0.00000000e+00]\n", + " [2.28314124e-03 1.03512550e+01 1.31874238e+01 1.27287661e+01\n", + " 1.23901001e+01 1.12941924e+01 1.12941924e+01 1.16176374e+01\n", + " 1.06610012e+01 1.06610012e+01 1.06610012e+01 1.22782262e+01\n", + " 1.46121039e+01 1.62356710e+00 5.70785310e+00 1.64956955e+01\n", + " 1.33033566e+01 1.23901001e+01 8.96614933e+00 6.01633085e+00\n", + " 9.25458618e+00 1.11873921e+01 1.05572451e+01 1.10810992e+01\n", + " 1.25024814e+01 1.31874238e+01 1.28426695e+01 0.00000000e+00]\n", + " [2.43636539e+00 1.37721616e+01 9.94536324e+00 1.11873921e+01\n", + " 1.25024814e+01 1.33033566e+01 1.33033566e+01 1.38906313e+01\n", + " 1.57285600e+01 1.22782262e+01 9.54758930e+00 1.17264671e+01\n", + " 1.19456487e+01 1.47341252e+01 1.07180797e+00 1.35187330e+00\n", + " 2.85037500e+00 3.47265783e+00 7.15993093e+00 1.21668597e+01\n", + " 1.23901001e+01 1.17264671e+01 1.19456487e+01 1.26153701e+01\n", + " 1.26153701e+01 1.27287661e+01 1.33033566e+01 2.13346865e-01]\n", + " [1.42696328e+00 1.05572451e+01 1.14015000e+01 1.05572451e+01\n", + " 9.44941423e+00 1.06610012e+01 1.12941924e+01 1.28426695e+01\n", + " 1.18358042e+01 8.68227877e+00 9.84515871e+00 1.07652646e+01\n", + " 9.94536324e+00 1.15093150e+01 1.46121039e+01 9.64627174e+00\n", + " 1.30719983e+01 1.52272837e+01 1.44905901e+01 1.26153701e+01\n", + " 1.20560005e+01 1.14015000e+01 1.10810992e+01 1.25024814e+01\n", + " 1.22782262e+01 1.23901001e+01 1.34197968e+01 1.13878011e+00]\n", + " [5.84484158e-01 1.04539964e+01 8.49556856e+00 9.54758930e+00\n", + " 1.15093150e+01 9.84515871e+00 8.68227877e+00 9.15793320e+00\n", + " 9.54758930e+00 9.35174652e+00 1.03512550e+01 1.16176374e+01\n", + " 1.21668597e+01 1.23901001e+01 1.22782262e+01 1.41290927e+01\n", + " 1.28426695e+01 1.18358042e+01 1.00460751e+01 1.07652646e+01\n", + " 8.77639493e+00 8.31088780e+00 7.94761466e+00 7.50493894e+00\n", + " 8.31088780e+00 1.06610012e+01 1.07652646e+01 3.35494921e+00]\n", + " [0.00000000e+00 3.77580825e+00 1.21668597e+01 9.44941423e+00\n", + " 8.12823650e+00 7.41792589e+00 8.49556856e+00 9.74546154e+00\n", + " 1.05572451e+01 1.11873921e+01 1.15093150e+01 1.08700354e+01\n", + " 1.12941924e+01 1.11873921e+01 1.01472944e+01 9.74546154e+00\n", + " 9.54758930e+00 9.25458618e+00 9.64627174e+00 9.25458618e+00\n", + " 9.94536324e+00 9.35174652e+00 7.85806478e+00 6.17361391e+00\n", + " 7.07494734e+00 7.94761466e+00 1.11873921e+01 2.14716750e+00]\n", + " [0.00000000e+00 0.00000000e+00 1.38916460e+00 9.06178758e+00\n", + " 1.14015000e+01 9.25458618e+00 7.76902228e+00 7.50493894e+00\n", + " 7.76902228e+00 8.31088780e+00 8.68227877e+00 8.96614933e+00\n", + " 9.06178758e+00 8.96614933e+00 9.44941423e+00 9.94536324e+00\n", + " 1.05572451e+01 1.10810992e+01 1.11873921e+01 1.11873921e+01\n", + " 1.12941924e+01 8.96614933e+00 8.96614933e+00 9.54758930e+00\n", + " 9.35174652e+00 1.18358042e+01 7.33142021e+00 0.00000000e+00]\n", + " [1.01472944e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.10504036e+00 1.01472944e+01 1.25024814e+01 1.42490845e+01\n", + " 1.44905901e+01 1.48566537e+01 1.53518417e+01 1.49796897e+01\n", + " 1.51032330e+01 1.23901001e+01 1.22782262e+01 9.44941423e+00\n", + " 9.25458618e+00 8.12823650e+00 8.40297449e+00 8.40297449e+00\n", + " 8.31088780e+00 7.85806478e+00 6.99047111e+00 7.15993093e+00\n", + " 2.48634081e+00 8.53387459e-01 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 4.05891776e-01\n", + " 9.43952062e-01 4.91129049e-01 1.31508935e+00 4.26440047e-01\n", + " 3.10760891e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]]\n", + "-17758.718677708395\n" + ] + } + ], + "source": [ + "#grade part1\n", + "#from part1 import encode_qiskit,decode\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "dataset = X_train[:1]\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_qiskit(data)\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + " \n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #reconstruct \n", + " image_re=decode(histogram,data)\n", + " print(image_re)\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(np.asarray(data),np.asarray(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))\n", + "# score should be between 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def multiply_by_51(lst):\n", + " new_list = []\n", + " for element in lst:\n", + " new_list.append(element * 51)\n", + " return new_list" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "list(list(de_normalize(image_re,data)[:784]))\n", + "plt.imshow(np.reshape(multiply_by_51(list(de_normalize(image_re,data)[:784])),data_shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "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": 15, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_machine_learning.algorithms.classifiers import VQC\n", + "from qiskit.algorithms.optimizers import SPSA\n", + "vqc = VQC(\n", + " feature_map=qc,\n", + " ansatz=ansatz,\n", + " loss=\"cross_entropy\",\n", + " optimizer=COBYLA(maxiter=100),\n", + " quantum_instance=Aer.get_backend('statevector_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time elapsed: 1189.4153316020966\n" + ] + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.4" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.266317714019139) q0; ry(1.32035044188513) q1; ry(0.375724625916453) q2; ry(-0.145527578194223) q3; ry(1.24796981173025) q4; ry(-0.3722525242738) q5; ry(0.98731246639232) q6; ry(1.98782341512519) q7; ry(1.66430495324693) q8; ry(0.760045740348774) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.76943425343952) q0; ry(1.54002486179664) q1; ry(1.5166941190635) q2; ry(2.08820456685236) q3; ry(0.502872321522427) q4; ry(0.5226897740692) q5; ry(1.34895736320983) q6; ry(0.17808386546728) q7; ry(1.48787325816064) q8; ry(1.19251464386051) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.63207747410879) q0; ry(0.944742510667842) q1; ry(1.4738548596109) q2; ry(0.0395594736234817) q3; ry(0.160988017972572) q4; ry(-0.139909848244233) q5; ry(0.217661325699283) q6; ry(1.51612158505368) q7; ry(0.709288700436131) q8; ry(2.00665865500557) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.266317714019139,1.32035044188513,0.375724625916453,-0.145527578194223,1.24796981173025,-0.3722525242738,0.98731246639232,1.98782341512519,1.66430495324693,0.760045740348774,1.76943425343952,1.54002486179664,1.5166941190635,2.08820456685236,0.502872321522427,0.5226897740692,1.34895736320983,0.17808386546728,1.48787325816064,1.19251464386051,1.63207747410879,0.944742510667842,1.4738548596109,0.0395594736234817,0.160988017972572,-0.139909848244233,0.217661325699283,1.51612158505368,0.709288700436131,2.00665865500557) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# todo: histogram_to_category\n", + "#def histogram_to_category():\n" + ] + }, + { + "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))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ionq", + "language": "python", + "name": "ionq" + }, + "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.10.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "133691b27fa14898ae18af0787aeaef9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_325f0396d7b9410bba8021bbe35f813a", + "style": "IPY_MODEL_5488374837ae4a9284ee055d8e6dc4ca", + "value": "
Backend
" + } + }, + "14a021df54ea41dd800c6d49a1fb3ba9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "14b920e77c4046b2b739ce5e65ba6c87": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_a42326a6516c48c9b45a061832e1b9e4", + "IPY_MODEL_133691b27fa14898ae18af0787aeaef9", + "IPY_MODEL_d36e5003b5bb4905b2f34cc06dab577e", + "IPY_MODEL_8b5e3e1c7c8b478eadaddcebb1bab545", + "IPY_MODEL_29e0bc1980f04ee5a4de1c3353ca43e1" + ], + "layout": "IPY_MODEL_95dbd7627f214404917e790abc4a0bac" + } + }, + "1a8a97e4934d4946b30b1b3ea93a6488": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "29e0bc1980f04ee5a4de1c3353ca43e1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_14a021df54ea41dd800c6d49a1fb3ba9", + "style": "IPY_MODEL_7cc1a68d44ca46bdaf3b815627f44cb2", + "value": "
Message
" + } + }, + "325f0396d7b9410bba8021bbe35f813a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "4de8f8e67ba84e68acc93c41fb388ea3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a14371b37a3941f991ce693be9cd4d38", + "style": "IPY_MODEL_5be42b0bad7e42a99d879056ebabf46d", + "value": "

Circuit Properties

" + } + }, + "5488374837ae4a9284ee055d8e6dc4ca": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5be42b0bad7e42a99d879056ebabf46d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "7695b5f41549481193e03d22f11ad7be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "7cc1a68d44ca46bdaf3b815627f44cb2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "8b5e3e1c7c8b478eadaddcebb1bab545": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_d04bd44ae10f4782855b04d120889b06", + "style": "IPY_MODEL_c6c8b591acda4e488e8afb052f4fe29b", + "value": "
Queue
" + } + }, + "95dbd7627f214404917e790abc4a0bac": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "a14371b37a3941f991ce693be9cd4d38": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "a42326a6516c48c9b45a061832e1b9e4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_1a8a97e4934d4946b30b1b3ea93a6488", + "style": "IPY_MODEL_e09458876777468d80ebae8aaa409834", + "value": "
Job ID
" + } + }, + "c6c8b591acda4e488e8afb052f4fe29b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "cc709643ef9d420387ecaf1e16125ec3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_f2c63bb964454e8f8d97f39429d02343" + ], + "layout": "IPY_MODEL_db133fac447c42cba07b68d7bf884952" + } + }, + "d04bd44ae10f4782855b04d120889b06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "d36e5003b5bb4905b2f34cc06dab577e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_fb539075b7f042f9bdd58552f7479014", + "style": "IPY_MODEL_7695b5f41549481193e03d22f11ad7be", + "value": "
Status
" + } + }, + "db133fac447c42cba07b68d7bf884952": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "e09458876777468d80ebae8aaa409834": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "f1ebeebc10804474ab5638703d2165ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "f2c63bb964454e8f8d97f39429d02343": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_fd52f04fbda04dcdbb42cc4a48af47bc", + "style": "IPY_MODEL_f1ebeebc10804474ab5638703d2165ee" + } + }, + "fb539075b7f042f9bdd58552f7479014": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "fd52f04fbda04dcdbb42cc4a48af47bc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/submission/submission_runner_realamp_spsa300.ipynb b/submission/submission_runner_realamp_spsa300.ipynb new file mode 100644 index 0000000..4a155d6 --- /dev/null +++ b/submission/submission_runner_realamp_spsa300.ipynb @@ -0,0 +1,1368 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-01-29 12:25:25.456820: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n", + "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "2023-01-29 12:25:25.593958: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n", + "2023-01-29 12:25:25.593990: I tensorflow/compiler/xla/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n", + "2023-01-29 12:25:26.611421: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n", + "2023-01-29 12:25:26.611602: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n", + "2023-01-29 12:25:26.611622: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n" + ] + } + ], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "import pickle\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(28, 28)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(np.ceil(np.log2(X_train.size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n", + " 0., 0., 0., 0., 0., 0., 0., 0., 0.])" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros(int(np.ceil(np.log2(X_train.size))))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " total_size = 2**int(np.ceil(np.log2(X_train[0].size)))\n", + " normalized_vector = [*normalized_vector, *np.zeros(total_size-len(normalized_vector))]\n", + " return normalized_vector" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 1024)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n", + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[1;36m Input \u001b[1;32mIn [12]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", + "\u001b[1;33m display(plt.imshow(X_train[0]))\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m\u001b[1;31m:\u001b[0m name 'plt' is not defined\n", + "\n", + "Use %tb to get the full traceback.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "import matplotlib.pyplot as plt\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),X_train[0].shape))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "#import pennylane as qml\n", + "#dev = qml.device(\"default.qubit\", wires=10)\n", + "#\n", + "#def block(weights, wires):\n", + "# qml.CNOT(wires=[wires[0],wires[1]])\n", + "# qml.RY(weights[0], wires=wires[0])\n", + "# qml.RY(weights[1], wires=wires[1])\n", + "#\n", + "# \n", + "#import pennylane as qml\n", + "#\n", + "#n_wires = dev.num_wires\n", + "#n_block_wires = 2\n", + "#n_params_block = 2\n", + "#n_blocks = qml.TTN.get_n_blocks(range(n_wires),n_block_wires)\n", + "#n_blocks\n", + "# \n", + "#@qml.qnode(dev)\n", + "#def circuit(weights, x):\n", + "#\n", + "# qml.AmplitudeEmbedding(x, wires=[i for i in range(10)],normalize=True,pad_with=True)\n", + "#\n", + "# for w in weights:\n", + "#\n", + "# qml.TTN(range(n_wires),n_block_wires,block, n_params_block, w)\n", + "# #print(w)\n", + "# #print(x)\n", + "# \n", + "# return qml.expval(qml.PauliZ(3))\n", + "#np.random.seed(0)\n", + "#num_layers = 1\n", + "#weights_init = 2*np.pi * np.random.randn(num_layers,n_blocks, n_params_block)\n", + "#print(weights_init.shape)\n", + "#\n", + "#print(qml.draw(circuit,expansion_strategy='device',wire_order=[i for i in range(10)])(weights_init,np.asarray(X_train[0])))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "#from qbraid import circuit_wrapper\n", + "# maybe we can use qbraid sdk\n", + "#TTN_circ = circuit_wrapper(n_blocks).transpile('qiskit')\n", + "#TTN_circ.draw()\n", + "#print(qml.draw(n_blocks)(weights))\n", + "#qml.draw(n_blocks)([0,0,0,0])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#def _block(self, qubits, symbols):\n", + "#\n", + "# #assert len(qubits) == 2\n", + "# #assert len(qubits) == len(symbols)\n", + "# qc = QuantumCircuit()\n", + "# qc.y()\n", + "# \n", + "# #\n", + "# #return cirq.Circuit(\n", + "# # cirq.Y(qubits[0])**symbols[0],\n", + "# # cirq.Y(qubits[1])**symbols[1], cirq.CNOT(qubits[0], qubits[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "#data_symbols = []\n", + "#\n", + "#ansatz = QuantumCircuit()\n", + "#for l in range(n_layers):\n", + "# for idx, w in enumerate(ind_gates):\n", + "# ansatz.append(block(w, var_symbols[l, idx]))\n", + "# \n", + "# ## Re-encoding layer\n", + "# #if drc and (l < n_layers - 1):\n", + "# # data_circuit, expr = cirq.flatten(\n", + "# # feature_map.build(qubits, in_symbols[l]))\n", + "# # circuit += data_circuit\n", + "# # data_symbols += list(expr.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit.library import RealAmplitudes, EfficientSU2\n", + "ansatz = RealAmplitudes(10, reps=2)\n", + "\n", + "# todo: TTN, example: https://github.com/Gopal-Dahale/qml-hep-lhc/blob/0632e2bcf892965303faa3ebc7322bc87b9ad6b3/qml_hep_lhc/ansatzes/ttn.py\n", + "# def tnn():\n", + "\n", + "#ansatz.draw()\n", + "#ansatz_ = ansatz.decompose(reps=20)\n", + "#print(ansatz_.depth())\n", + "#print(f\"Circuit operations: {ansatz_.count_ops()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "EfficientSU2(4,reps=97).num_parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\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" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{96: 6.435473980059361e-08, 99: 1.0875951026300376e-05, 100: 0.0003429464083973666, 103: 6.435473980063946e-08, 104: 1.029675836809481e-06, 109: 6.435473980059199e-08, 110: 6.435473980059214e-08, 124: 5.791926582053541e-07, 126: 8.340374278157023e-05, 127: 0.001190305267351793, 128: 0.0010379775982437844, 129: 0.00024737961979348535, 130: 0.0001876584212585344, 134: 6.435473980058929e-08, 135: 5.791926582053047e-07, 136: 1.0296758368094123e-06, 139: 5.791926582052729e-07, 152: 2.3167706328214167e-06, 154: 0.0006695467128853881, 155: 0.0026781868515415525, 156: 0.001993452420063207, 157: 0.00115555370785948, 158: 0.001334459884505117, 159: 0.0009736228584431939, 160: 3.4043657354514076e-05, 165: 9.26708253128558e-06, 166: 6.435473980059434e-06, 182: 0.0015461226237092687, 183: 0.003584301587933887, 184: 0.0027575362457156727, 185: 0.0020390155758420324, 186: 0.0007367974159770059, 187: 0.0015661369477872724, 188: 0.0016681392103712123, 189: 0.0007645986635708676, 190: 0.0002635970142232365, 191: 3.4043657354514835e-05, 192: 0.0003815592522777261, 193: 0.0010875951026300475, 194: 0.00033361497112628283, 195: 1.4479816455133771e-05, 207: 6.435473980075541e-08, 209: 0.000306392916190634, 210: 0.0027575362457156745, 211: 0.0032002968555437643, 212: 0.003058394654283475, 213: 0.0030025347401365417, 214: 0.0030025347401365565, 215: 0.0017098410817619984, 216: 0.0010379775982437946, 217: 0.0009422177454205038, 218: 0.0009578559471920467, 219: 0.0013717856335894697, 220: 0.0012794365819756217, 221: 0.0004983631050158022, 222: 0.0019038706222607787, 223: 0.00028032924657138745, 233: 6.435473980060936e-08, 234: 6.435473980058451e-08, 235: 6.435473980058954e-08, 237: 0.002574189592023769, 238: 0.0034638295150271944, 239: 0.0034638295150271887, 240: 0.0034937544690344857, 241: 0.003374826909882975, 242: 0.003200296855543776, 243: 0.003200296855543769, 244: 0.0029747978472825015, 245: 0.0029197101900131847, 246: 0.0017308850816767848, 247: 0.0010379775982437827, 248: 0.000973622858443201, 249: 0.0024722516841796482, 250: 0.003374826909882971, 265: 0.0021551758811821187, 266: 0.003257958702405072, 267: 0.0030025347401365417, 268: 0.0032002968555437943, 269: 0.0033454167937941024, 270: 0.00355399050548784, 271: 0.0033161353871848376, 272: 0.003229063424234597, 273: 0.0031716589963324826, 274: 0.0032290634242346373, 275: 0.0031431498466008246, 276: 0.003200296855543774, 277: 0.00386289325653068, 278: 0.001926073007491985, 293: 0.0023971497028323577, 294: 0.003345416793794097, 295: 0.003058394654283433, 296: 0.002919710190013182, 297: 0.0025229632191425115, 298: 0.002085093569539262, 299: 0.0028923594255979177, 300: 0.0028380440252061883, 301: 0.0028651373706622637, 302: 0.002919710190013154, 303: 0.0032002968555437535, 304: 0.0031147694063487544, 305: 0.003800083030485298, 306: 0.0026259308028234686, 317: 6.435473980071711e-08, 318: 5.79192658206503e-07, 320: 9.267082531285525e-06, 321: 0.0030865176755763145, 322: 0.003114769406348769, 323: 0.00289235942559792, 324: 0.0030583946542834676, 325: 0.002372373128009121, 326: 0.0018380357234447726, 327: 0.0033161353871848332, 328: 0.0027842434627329423, 329: 0.0030583946542834715, 330: 0.003229063424234639, 331: 0.002892359425597907, 332: 0.003286982690055168, 333: 0.0024975430969212706, 334: 0.0028110793892297636, 335: 0.0001740152164208061, 346: 2.3167706328212727e-06, 348: 0.0006307408047856239, 349: 0.003831423788768177, 350: 0.0031716589963325034, 351: 0.0031147694063487622, 352: 0.0030583946542834884, 353: 0.0026519944724426995, 354: 0.002522963219142512, 355: 0.0031431498466008385, 356: 0.002974797847282503, 357: 0.0029197101900131765, 358: 0.003171658996332502, 359: 0.00311476940634879, 360: 0.003862893256530698, 361: 0.0009113274703162244, 362: 0.0017947893382987824, 363: 0.00020181646401466416, 373: 1.0296758368095188e-06, 376: 0.00019467308789680263, 377: 0.0035843015879339227, 378: 0.003345416793794104, 379: 0.0034043657354514488, 380: 0.003345416793794111, 381: 0.0037068330125142497, 382: 0.003463829515027196, 383: 0.0029197101900131656, 384: 0.0030583946542834376, 385: 0.0032002968555437748, 386: 0.0035238081325213782, 387: 0.003030400342470205, 388: 0.0030304003424701832, 389: 0.002811079389229744, 390: 0.0005446985176722273, 394: 6.435473980056566e-08, 395: 1.0296758368089881e-06, 396: 2.316770632820139e-06, 397: 3.153382250227464e-06, 398: 2.574189592022458e-07, 404: 0.0036147413798595907, 405: 0.003286982690055168, 406: 0.003030400342470197, 407: 0.0032002968555437422, 408: 0.0031716589963325255, 409: 0.003086517675576311, 410: 0.0031716589963324974, 411: 0.0031431498466008324, 412: 0.0030025347401365417, 413: 0.003200296855543771, 414: 0.0033748269098829607, 415: 0.002974797847282472, 416: 0.003058394654283453, 417: 0.004184666955533652, 418: 0.00038155925227772113, 421: 5.791926582066301e-07, 429: 0.0002473796197934845, 430: 0.0013530584043075016, 431: 0.002678186851541544, 432: 0.0033454167937940994, 433: 0.0027575362457156615, 434: 0.0029197101900131847, 435: 0.0031431498466008394, 436: 0.003058394654283443, 437: 0.0027842434627329093, 438: 0.002865137370662268, 439: 0.0030583946542834567, 440: 0.0032290634242346183, 441: 0.0032002968555437518, 442: 0.003086517675576302, 443: 0.002974797847282463, 444: 0.0032290634242346104, 445: 0.003831423788768192, 446: 0.00162695217689884, 452: 2.085093569539324e-05, 453: 0.00012459077625395182, 454: 0.0004327212704192003, 455: 0.0007367974159770074, 456: 0.002298815660417052, 457: 0.0033454167937941154, 458: 0.0031147694063487917, 459: 0.0031716589963324956, 460: 0.003030400342470196, 461: 0.003286982690055165, 462: 0.0025741895920237995, 463: 0.0027045079401199915, 464: 0.002865137370662268, 465: 0.0034043657354514514, 466: 0.0032290634242346144, 467: 0.0035238081325213487, 468: 0.0019934524200632244, 469: 0.0022745539235122132, 470: 0.004022171237537163, 471: 0.0039580739166957864, 472: 0.0034937544690344306, 473: 0.00364530988126486, 474: 0.002974797847282465, 477: 0.00020908854961212945, 478: 0.0022504208960869698, 479: 0.002784243462732909, 480: 0.0032290634242346065, 481: 0.003143149846600816, 482: 0.0032290634242346083, 483: 0.0027842434627329024, 484: 0.0026781868515415503, 485: 0.0029471896639080295, 486: 0.0027842434627329046, 487: 0.0028110793892297584, 488: 0.002574189592023789, 489: 0.0016269521768988216, 490: 0.0038628932565307026, 491: 0.002397149702832337, 492: 0.0027309577381780157, 493: 0.0032002968555437587, 494: 0.004184666955533625, 495: 0.004184666955533652, 496: 0.003143149846600844, 497: 0.003523808132521348, 498: 0.0031431498466008363, 499: 0.0028651373706622637, 500: 0.003114769406348764, 501: 0.003463829515027178, 502: 0.0038944914337727694, 504: 5.791926582052186e-07, 505: 0.0026259308028234603, 506: 0.003345416793794113, 507: 0.003229063424234628, 508: 0.0031431498466008294, 509: 0.00286513737066227, 510: 0.0028651373706622585, 511: 0.0029471896639080026, 512: 0.0027045079401199915, 513: 0.0027045079401199893, 514: 0.002704507940119987, 515: 0.003114769406348769, 516: 0.0037068330125142666, 517: 0.0004118703347238052, 518: 0.0014479816455133844, 519: 0.004184666955533671, 520: 0.003374826909882987, 521: 0.003143149846600851, 522: 0.0022745539235122145, 523: 0.001526237009110899, 524: 0.002347725262665498, 525: 0.0028380440252062295, 526: 0.002678186851541547, 527: 0.0028110793892297797, 528: 0.003171658996332466, 529: 0.0033454167937940903, 530: 0.0032579587024050864, 532: 0.000618062921044907, 533: 0.0034937544690344783, 534: 0.002522963219142507, 535: 0.0028380440252062243, 536: 0.0031716589963324965, 537: 0.003374826909882975, 538: 0.0033748269098829806, 539: 0.0035238081325213544, 540: 0.00399005822237665, 541: 0.003114769406348788, 542: 0.002422054987135201, 543: 0.0029747978472824863, 544: 0.00303040034247021, 545: 0.0037377876423583434, 546: 0.0002718987756575123, 547: 0.0003429464083973691, 548: 0.0007230898563994767, 549: 0.000880952033130339, 550: 0.0018163481761319723, 551: 0.003086517675576315, 552: 0.003143149846600823, 553: 0.002974797847282469, 554: 0.0030304003424701798, 555: 0.0032002968555437643, 556: 0.003200296855543765, 557: 0.0032290634242346217, 558: 0.003374826909882971, 559: 5.412233617229877e-05, 560: 0.0003619954113783457, 561: 0.002678186851541548, 562: 0.0028923594255979316, 563: 0.002678186851541554, 564: 0.002397149702832335, 565: 0.002704507940119972, 566: 0.0028651373706622854, 567: 0.0032579587024050847, 568: 0.0030025347401365335, 569: 0.002202540969675343, 570: 0.002497543096921267, 571: 0.002730957738178015, 572: 0.002522963219142512, 573: 0.0029197101900131795, 574: 0.003706833012514242, 575: 0.0024470889809176093, 576: 0.0033161353871848384, 577: 0.003862893256530654, 578: 0.0036760070921497343, 579: 0.0032002968555437535, 580: 0.003058394654283475, 581: 0.002892359425597915, 582: 0.002811079389229784, 583: 0.003171658996332507, 584: 0.00311476940634879, 585: 0.0031431498466008433, 586: 0.0034043657354514414, 587: 0.0002888884269648676, 588: 0.00014827332050056986, 589: 0.002651994472442707, 590: 0.002155175881182113, 591: 0.002422054987135176, 592: 0.00291971019001318, 593: 0.0024975430969212645, 594: 0.002202540969675374, 595: 0.0023232061068014656, 596: 0.002422054987135174, 597: 0.0023723731280091086, 598: 0.002625930802823485, 599: 0.0029471896639080295, 600: 0.003086517675576291, 601: 0.003143149846600827, 602: 0.003114769406348784, 603: 0.003584301587933916, 604: 0.0032579587024050877, 605: 0.0030025347401365136, 606: 0.00254851205084332, 607: 0.0027309577381780265, 608: 0.0022264165781413774, 609: 0.002108325630607274, 610: 0.0020161696432128224, 611: 0.0019038706222607876, 612: 0.0021083256306072837, 613: 0.002704507940119988, 614: 0.0027309577381780374, 615: 0.0008510914338628575, 617: 0.000957855947192049, 618: 0.0030865176755762967, 619: 0.0023971497028323447, 620: 0.0020619902179508454, 621: 0.0018817969465091842, 622: 0.002155175881182092, 623: 0.0024722516841796252, 624: 0.0026781868515415633, 625: 0.0028380440252062378, 626: 0.0029197101900131674, 627: 0.0027575362457156593, 628: 0.002865137370662257, 629: 0.0028380440252062213, 630: 0.002574189592023771, 631: 0.0024722516841796218, 632: 0.0024220549871351647, 633: 0.0023477252626654906, 634: 0.0024470889809175907, 635: 0.002347725262665489, 636: 0.0025229632191424993, 637: 0.0023723731280091134, 638: 0.0019934524200632357, 639: 0.001566136947787275, 640: 0.0017947893382987854, 641: 0.002016169643212822, 642: 0.0028380440252062126, 643: 0.0005446985176722298, 646: 0.00035240655514805354, 647: 0.00229881566041703, 648: 0.0028923594255979034, 649: 0.0023477252626654846, 650: 0.0019708639063931842, 651: 0.0019038706222607804, 652: 0.0019708639063932055, 653: 0.002108325630607263, 654: 0.0022025409696753416, 655: 0.002274553923512201, 656: 0.002298815660417042, 657: 0.002274553923512229, 658: 0.0023971497028323556, 659: 0.002522963219142536, 660: 0.002678186851541545, 661: 0.002811079389229781, 662: 0.0028380440252062065, 663: 0.002838044025206217, 664: 0.00286513737066225, 665: 0.002274553923512197, 666: 0.0022745539235121993, 667: 0.0024220549871351764, 668: 0.0023723731280091364, 669: 0.0030025347401365404, 670: 0.0018598519802371749, 672: 2.5741895920236366e-07, 676: 0.0002803292465713921, 677: 0.0025741895920237947, 678: 0.0031716589963325034, 679: 0.0036147413798595924, 680: 0.0036760070921497386, 681: 0.00376887098168201, 682: 0.0038944914337727954, 683: 0.0038000830304853184, 684: 0.0038314237887681814, 685: 0.0031431498466008216, 686: 0.003114769406348761, 687: 0.002397149702832347, 688: 0.002347725262665483, 689: 0.0020619902179508346, 690: 0.0021316864011548787, 691: 0.0021316864011548826, 692: 0.0021083256306072594, 693: 0.001993452420063207, 694: 0.0017733592099451697, 695: 0.0018163481761319723, 696: 0.0006307408047856226, 697: 0.0002164893446891982, 707: 0.00010296758368095236, 708: 0.00023946398679801627, 709: 0.00012459077625395234, 710: 0.0003336149711262838, 711: 0.00010818031760480079, 712: 7.883455625573016e-05}\n" + ] + } + ], + "source": [ + "histogram = simulate(qc.bind_parameters(normalized_vector))\n", + "print(histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0, 17: 0, 18: 0, 19: 0, 20: 0, 21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0, 28: 0, 29: 0, 30: 0, 31: 0, 32: 0, 33: 0, 34: 0, 35: 0, 36: 0, 37: 0, 38: 0, 39: 0, 40: 0, 41: 0, 42: 0, 43: 0, 44: 0, 45: 0, 46: 0, 47: 0, 48: 0, 49: 0, 50: 0, 51: 0, 52: 0, 53: 0, 54: 0, 55: 0, 56: 0, 57: 0, 58: 0, 59: 0, 60: 0, 61: 0, 62: 0, 63: 0, 64: 0, 65: 0, 66: 0, 67: 0, 68: 0, 69: 0, 70: 0, 71: 0, 72: 0, 73: 0, 74: 0, 75: 0, 76: 0, 77: 0, 78: 0, 79: 0, 80: 0, 81: 0, 82: 0, 83: 0, 84: 0, 85: 0, 86: 0, 87: 0, 88: 0, 89: 0, 90: 0, 91: 0, 92: 0, 93: 0, 94: 0, 95: 0, 96: 6.435473980059361e-08, 97: 0, 98: 0, 99: 1.0875951026300376e-05, 100: 0.0003429464083973666, 101: 0, 102: 0, 103: 6.435473980063946e-08, 104: 1.029675836809481e-06, 105: 0, 106: 0, 107: 0, 108: 0, 109: 6.435473980059199e-08, 110: 6.435473980059214e-08, 111: 0, 112: 0, 113: 0, 114: 0, 115: 0, 116: 0, 117: 0, 118: 0, 119: 0, 120: 0, 121: 0, 122: 0, 123: 0, 124: 5.791926582053541e-07, 125: 0, 126: 8.340374278157023e-05, 127: 0.001190305267351793, 128: 0.0010379775982437844, 129: 0.00024737961979348535, 130: 0.0001876584212585344, 131: 0, 132: 0, 133: 0, 134: 6.435473980058929e-08, 135: 5.791926582053047e-07, 136: 1.0296758368094123e-06, 137: 0, 138: 0, 139: 5.791926582052729e-07, 140: 0, 141: 0, 142: 0, 143: 0, 144: 0, 145: 0, 146: 0, 147: 0, 148: 0, 149: 0, 150: 0, 151: 0, 152: 2.3167706328214167e-06, 153: 0, 154: 0.0006695467128853881, 155: 0.0026781868515415525, 156: 0.001993452420063207, 157: 0.00115555370785948, 158: 0.001334459884505117, 159: 0.0009736228584431939, 160: 3.4043657354514076e-05, 161: 0, 162: 0, 163: 0, 164: 0, 165: 9.26708253128558e-06, 166: 6.435473980059434e-06, 167: 0, 168: 0, 169: 0, 170: 0, 171: 0, 172: 0, 173: 0, 174: 0, 175: 0, 176: 0, 177: 0, 178: 0, 179: 0, 180: 0, 181: 0, 182: 0.0015461226237092687, 183: 0.003584301587933887, 184: 0.0027575362457156727, 185: 0.0020390155758420324, 186: 0.0007367974159770059, 187: 0.0015661369477872724, 188: 0.0016681392103712123, 189: 0.0007645986635708676, 190: 0.0002635970142232365, 191: 3.4043657354514835e-05, 192: 0.0003815592522777261, 193: 0.0010875951026300475, 194: 0.00033361497112628283, 195: 1.4479816455133771e-05, 196: 0, 197: 0, 198: 0, 199: 0, 200: 0, 201: 0, 202: 0, 203: 0, 204: 0, 205: 0, 206: 0, 207: 6.435473980075541e-08, 208: 0, 209: 0.000306392916190634, 210: 0.0027575362457156745, 211: 0.0032002968555437643, 212: 0.003058394654283475, 213: 0.0030025347401365417, 214: 0.0030025347401365565, 215: 0.0017098410817619984, 216: 0.0010379775982437946, 217: 0.0009422177454205038, 218: 0.0009578559471920467, 219: 0.0013717856335894697, 220: 0.0012794365819756217, 221: 0.0004983631050158022, 222: 0.0019038706222607787, 223: 0.00028032924657138745, 224: 0, 225: 0, 226: 0, 227: 0, 228: 0, 229: 0, 230: 0, 231: 0, 232: 0, 233: 6.435473980060936e-08, 234: 6.435473980058451e-08, 235: 6.435473980058954e-08, 236: 0, 237: 0.002574189592023769, 238: 0.0034638295150271944, 239: 0.0034638295150271887, 240: 0.0034937544690344857, 241: 0.003374826909882975, 242: 0.003200296855543776, 243: 0.003200296855543769, 244: 0.0029747978472825015, 245: 0.0029197101900131847, 246: 0.0017308850816767848, 247: 0.0010379775982437827, 248: 0.000973622858443201, 249: 0.0024722516841796482, 250: 0.003374826909882971, 251: 0, 252: 0, 253: 0, 254: 0, 255: 0, 256: 0, 257: 0, 258: 0, 259: 0, 260: 0, 261: 0, 262: 0, 263: 0, 264: 0, 265: 0.0021551758811821187, 266: 0.003257958702405072, 267: 0.0030025347401365417, 268: 0.0032002968555437943, 269: 0.0033454167937941024, 270: 0.00355399050548784, 271: 0.0033161353871848376, 272: 0.003229063424234597, 273: 0.0031716589963324826, 274: 0.0032290634242346373, 275: 0.0031431498466008246, 276: 0.003200296855543774, 277: 0.00386289325653068, 278: 0.001926073007491985, 279: 0, 280: 0, 281: 0, 282: 0, 283: 0, 284: 0, 285: 0, 286: 0, 287: 0, 288: 0, 289: 0, 290: 0, 291: 0, 292: 0, 293: 0.0023971497028323577, 294: 0.003345416793794097, 295: 0.003058394654283433, 296: 0.002919710190013182, 297: 0.0025229632191425115, 298: 0.002085093569539262, 299: 0.0028923594255979177, 300: 0.0028380440252061883, 301: 0.0028651373706622637, 302: 0.002919710190013154, 303: 0.0032002968555437535, 304: 0.0031147694063487544, 305: 0.003800083030485298, 306: 0.0026259308028234686, 307: 0, 308: 0, 309: 0, 310: 0, 311: 0, 312: 0, 313: 0, 314: 0, 315: 0, 316: 0, 317: 6.435473980071711e-08, 318: 5.79192658206503e-07, 319: 0, 320: 9.267082531285525e-06, 321: 0.0030865176755763145, 322: 0.003114769406348769, 323: 0.00289235942559792, 324: 0.0030583946542834676, 325: 0.002372373128009121, 326: 0.0018380357234447726, 327: 0.0033161353871848332, 328: 0.0027842434627329423, 329: 0.0030583946542834715, 330: 0.003229063424234639, 331: 0.002892359425597907, 332: 0.003286982690055168, 333: 0.0024975430969212706, 334: 0.0028110793892297636, 335: 0.0001740152164208061, 336: 0, 337: 0, 338: 0, 339: 0, 340: 0, 341: 0, 342: 0, 343: 0, 344: 0, 345: 0, 346: 2.3167706328212727e-06, 347: 0, 348: 0.0006307408047856239, 349: 0.003831423788768177, 350: 0.0031716589963325034, 351: 0.0031147694063487622, 352: 0.0030583946542834884, 353: 0.0026519944724426995, 354: 0.002522963219142512, 355: 0.0031431498466008385, 356: 0.002974797847282503, 357: 0.0029197101900131765, 358: 0.003171658996332502, 359: 0.00311476940634879, 360: 0.003862893256530698, 361: 0.0009113274703162244, 362: 0.0017947893382987824, 363: 0.00020181646401466416, 364: 0, 365: 0, 366: 0, 367: 0, 368: 0, 369: 0, 370: 0, 371: 0, 372: 0, 373: 1.0296758368095188e-06, 374: 0, 375: 0, 376: 0.00019467308789680263, 377: 0.0035843015879339227, 378: 0.003345416793794104, 379: 0.0034043657354514488, 380: 0.003345416793794111, 381: 0.0037068330125142497, 382: 0.003463829515027196, 383: 0.0029197101900131656, 384: 0.0030583946542834376, 385: 0.0032002968555437748, 386: 0.0035238081325213782, 387: 0.003030400342470205, 388: 0.0030304003424701832, 389: 0.002811079389229744, 390: 0.0005446985176722273, 391: 0, 392: 0, 393: 0, 394: 6.435473980056566e-08, 395: 1.0296758368089881e-06, 396: 2.316770632820139e-06, 397: 3.153382250227464e-06, 398: 2.574189592022458e-07, 399: 0, 400: 0, 401: 0, 402: 0, 403: 0, 404: 0.0036147413798595907, 405: 0.003286982690055168, 406: 0.003030400342470197, 407: 0.0032002968555437422, 408: 0.0031716589963325255, 409: 0.003086517675576311, 410: 0.0031716589963324974, 411: 0.0031431498466008324, 412: 0.0030025347401365417, 413: 0.003200296855543771, 414: 0.0033748269098829607, 415: 0.002974797847282472, 416: 0.003058394654283453, 417: 0.004184666955533652, 418: 0.00038155925227772113, 419: 0, 420: 0, 421: 5.791926582066301e-07, 422: 0, 423: 0, 424: 0, 425: 0, 426: 0, 427: 0, 428: 0, 429: 0.0002473796197934845, 430: 0.0013530584043075016, 431: 0.002678186851541544, 432: 0.0033454167937940994, 433: 0.0027575362457156615, 434: 0.0029197101900131847, 435: 0.0031431498466008394, 436: 0.003058394654283443, 437: 0.0027842434627329093, 438: 0.002865137370662268, 439: 0.0030583946542834567, 440: 0.0032290634242346183, 441: 0.0032002968555437518, 442: 0.003086517675576302, 443: 0.002974797847282463, 444: 0.0032290634242346104, 445: 0.003831423788768192, 446: 0.00162695217689884, 447: 0, 448: 0, 449: 0, 450: 0, 451: 0, 452: 2.085093569539324e-05, 453: 0.00012459077625395182, 454: 0.0004327212704192003, 455: 0.0007367974159770074, 456: 0.002298815660417052, 457: 0.0033454167937941154, 458: 0.0031147694063487917, 459: 0.0031716589963324956, 460: 0.003030400342470196, 461: 0.003286982690055165, 462: 0.0025741895920237995, 463: 0.0027045079401199915, 464: 0.002865137370662268, 465: 0.0034043657354514514, 466: 0.0032290634242346144, 467: 0.0035238081325213487, 468: 0.0019934524200632244, 469: 0.0022745539235122132, 470: 0.004022171237537163, 471: 0.0039580739166957864, 472: 0.0034937544690344306, 473: 0.00364530988126486, 474: 0.002974797847282465, 475: 0, 476: 0, 477: 0.00020908854961212945, 478: 0.0022504208960869698, 479: 0.002784243462732909, 480: 0.0032290634242346065, 481: 0.003143149846600816, 482: 0.0032290634242346083, 483: 0.0027842434627329024, 484: 0.0026781868515415503, 485: 0.0029471896639080295, 486: 0.0027842434627329046, 487: 0.0028110793892297584, 488: 0.002574189592023789, 489: 0.0016269521768988216, 490: 0.0038628932565307026, 491: 0.002397149702832337, 492: 0.0027309577381780157, 493: 0.0032002968555437587, 494: 0.004184666955533625, 495: 0.004184666955533652, 496: 0.003143149846600844, 497: 0.003523808132521348, 498: 0.0031431498466008363, 499: 0.0028651373706622637, 500: 0.003114769406348764, 501: 0.003463829515027178, 502: 0.0038944914337727694, 503: 0, 504: 5.791926582052186e-07, 505: 0.0026259308028234603, 506: 0.003345416793794113, 507: 0.003229063424234628, 508: 0.0031431498466008294, 509: 0.00286513737066227, 510: 0.0028651373706622585, 511: 0.0029471896639080026, 512: 0.0027045079401199915, 513: 0.0027045079401199893, 514: 0.002704507940119987, 515: 0.003114769406348769, 516: 0.0037068330125142666, 517: 0.0004118703347238052, 518: 0.0014479816455133844, 519: 0.004184666955533671, 520: 0.003374826909882987, 521: 0.003143149846600851, 522: 0.0022745539235122145, 523: 0.001526237009110899, 524: 0.002347725262665498, 525: 0.0028380440252062295, 526: 0.002678186851541547, 527: 0.0028110793892297797, 528: 0.003171658996332466, 529: 0.0033454167937940903, 530: 0.0032579587024050864, 531: 0, 532: 0.000618062921044907, 533: 0.0034937544690344783, 534: 0.002522963219142507, 535: 0.0028380440252062243, 536: 0.0031716589963324965, 537: 0.003374826909882975, 538: 0.0033748269098829806, 539: 0.0035238081325213544, 540: 0.00399005822237665, 541: 0.003114769406348788, 542: 0.002422054987135201, 543: 0.0029747978472824863, 544: 0.00303040034247021, 545: 0.0037377876423583434, 546: 0.0002718987756575123, 547: 0.0003429464083973691, 548: 0.0007230898563994767, 549: 0.000880952033130339, 550: 0.0018163481761319723, 551: 0.003086517675576315, 552: 0.003143149846600823, 553: 0.002974797847282469, 554: 0.0030304003424701798, 555: 0.0032002968555437643, 556: 0.003200296855543765, 557: 0.0032290634242346217, 558: 0.003374826909882971, 559: 5.412233617229877e-05, 560: 0.0003619954113783457, 561: 0.002678186851541548, 562: 0.0028923594255979316, 563: 0.002678186851541554, 564: 0.002397149702832335, 565: 0.002704507940119972, 566: 0.0028651373706622854, 567: 0.0032579587024050847, 568: 0.0030025347401365335, 569: 0.002202540969675343, 570: 0.002497543096921267, 571: 0.002730957738178015, 572: 0.002522963219142512, 573: 0.0029197101900131795, 574: 0.003706833012514242, 575: 0.0024470889809176093, 576: 0.0033161353871848384, 577: 0.003862893256530654, 578: 0.0036760070921497343, 579: 0.0032002968555437535, 580: 0.003058394654283475, 581: 0.002892359425597915, 582: 0.002811079389229784, 583: 0.003171658996332507, 584: 0.00311476940634879, 585: 0.0031431498466008433, 586: 0.0034043657354514414, 587: 0.0002888884269648676, 588: 0.00014827332050056986, 589: 0.002651994472442707, 590: 0.002155175881182113, 591: 0.002422054987135176, 592: 0.00291971019001318, 593: 0.0024975430969212645, 594: 0.002202540969675374, 595: 0.0023232061068014656, 596: 0.002422054987135174, 597: 0.0023723731280091086, 598: 0.002625930802823485, 599: 0.0029471896639080295, 600: 0.003086517675576291, 601: 0.003143149846600827, 602: 0.003114769406348784, 603: 0.003584301587933916, 604: 0.0032579587024050877, 605: 0.0030025347401365136, 606: 0.00254851205084332, 607: 0.0027309577381780265, 608: 0.0022264165781413774, 609: 0.002108325630607274, 610: 0.0020161696432128224, 611: 0.0019038706222607876, 612: 0.0021083256306072837, 613: 0.002704507940119988, 614: 0.0027309577381780374, 615: 0.0008510914338628575, 616: 0, 617: 0.000957855947192049, 618: 0.0030865176755762967, 619: 0.0023971497028323447, 620: 0.0020619902179508454, 621: 0.0018817969465091842, 622: 0.002155175881182092, 623: 0.0024722516841796252, 624: 0.0026781868515415633, 625: 0.0028380440252062378, 626: 0.0029197101900131674, 627: 0.0027575362457156593, 628: 0.002865137370662257, 629: 0.0028380440252062213, 630: 0.002574189592023771, 631: 0.0024722516841796218, 632: 0.0024220549871351647, 633: 0.0023477252626654906, 634: 0.0024470889809175907, 635: 0.002347725262665489, 636: 0.0025229632191424993, 637: 0.0023723731280091134, 638: 0.0019934524200632357, 639: 0.001566136947787275, 640: 0.0017947893382987854, 641: 0.002016169643212822, 642: 0.0028380440252062126, 643: 0.0005446985176722298, 644: 0, 645: 0, 646: 0.00035240655514805354, 647: 0.00229881566041703, 648: 0.0028923594255979034, 649: 0.0023477252626654846, 650: 0.0019708639063931842, 651: 0.0019038706222607804, 652: 0.0019708639063932055, 653: 0.002108325630607263, 654: 0.0022025409696753416, 655: 0.002274553923512201, 656: 0.002298815660417042, 657: 0.002274553923512229, 658: 0.0023971497028323556, 659: 0.002522963219142536, 660: 0.002678186851541545, 661: 0.002811079389229781, 662: 0.0028380440252062065, 663: 0.002838044025206217, 664: 0.00286513737066225, 665: 0.002274553923512197, 666: 0.0022745539235121993, 667: 0.0024220549871351764, 668: 0.0023723731280091364, 669: 0.0030025347401365404, 670: 0.0018598519802371749, 671: 0, 672: 2.5741895920236366e-07, 673: 0, 674: 0, 675: 0, 676: 0.0002803292465713921, 677: 0.0025741895920237947, 678: 0.0031716589963325034, 679: 0.0036147413798595924, 680: 0.0036760070921497386, 681: 0.00376887098168201, 682: 0.0038944914337727954, 683: 0.0038000830304853184, 684: 0.0038314237887681814, 685: 0.0031431498466008216, 686: 0.003114769406348761, 687: 0.002397149702832347, 688: 0.002347725262665483, 689: 0.0020619902179508346, 690: 0.0021316864011548787, 691: 0.0021316864011548826, 692: 0.0021083256306072594, 693: 0.001993452420063207, 694: 0.0017733592099451697, 695: 0.0018163481761319723, 696: 0.0006307408047856226, 697: 0.0002164893446891982, 698: 0, 699: 0, 700: 0, 701: 0, 702: 0, 703: 0, 704: 0, 705: 0, 706: 0, 707: 0.00010296758368095236, 708: 0.00023946398679801627, 709: 0.00012459077625395234, 710: 0.0003336149711262838, 711: 0.00010818031760480079, 712: 7.883455625573016e-05, 713: 0, 714: 0, 715: 0, 716: 0, 717: 0, 718: 0, 719: 0, 720: 0, 721: 0, 722: 0, 723: 0, 724: 0, 725: 0, 726: 0, 727: 0, 728: 0, 729: 0, 730: 0, 731: 0, 732: 0, 733: 0, 734: 0, 735: 0, 736: 0, 737: 0, 738: 0, 739: 0, 740: 0, 741: 0, 742: 0, 743: 0, 744: 0, 745: 0, 746: 0, 747: 0, 748: 0, 749: 0, 750: 0, 751: 0, 752: 0, 753: 0, 754: 0, 755: 0, 756: 0, 757: 0, 758: 0, 759: 0, 760: 0, 761: 0, 762: 0, 763: 0, 764: 0, 765: 0, 766: 0, 767: 0, 768: 0, 769: 0, 770: 0, 771: 0, 772: 0, 773: 0, 774: 0, 775: 0, 776: 0, 777: 0, 778: 0, 779: 0, 780: 0, 781: 0, 782: 0, 783: 0, 784: 0, 785: 0, 786: 0, 787: 0, 788: 0, 789: 0, 790: 0, 791: 0, 792: 0, 793: 0, 794: 0, 795: 0, 796: 0, 797: 0, 798: 0, 799: 0, 800: 0, 801: 0, 802: 0, 803: 0, 804: 0, 805: 0, 806: 0, 807: 0, 808: 0, 809: 0, 810: 0, 811: 0, 812: 0, 813: 0, 814: 0, 815: 0, 816: 0, 817: 0, 818: 0, 819: 0, 820: 0, 821: 0, 822: 0, 823: 0, 824: 0, 825: 0, 826: 0, 827: 0, 828: 0, 829: 0, 830: 0, 831: 0, 832: 0, 833: 0, 834: 0, 835: 0, 836: 0, 837: 0, 838: 0, 839: 0, 840: 0, 841: 0, 842: 0, 843: 0, 844: 0, 845: 0, 846: 0, 847: 0, 848: 0, 849: 0, 850: 0, 851: 0, 852: 0, 853: 0, 854: 0, 855: 0, 856: 0, 857: 0, 858: 0, 859: 0, 860: 0, 861: 0, 862: 0, 863: 0, 864: 0, 865: 0, 866: 0, 867: 0, 868: 0, 869: 0, 870: 0, 871: 0, 872: 0, 873: 0, 874: 0, 875: 0, 876: 0, 877: 0, 878: 0, 879: 0, 880: 0, 881: 0, 882: 0, 883: 0, 884: 0, 885: 0, 886: 0, 887: 0, 888: 0, 889: 0, 890: 0, 891: 0, 892: 0, 893: 0, 894: 0, 895: 0, 896: 0, 897: 0, 898: 0, 899: 0, 900: 0, 901: 0, 902: 0, 903: 0, 904: 0, 905: 0, 906: 0, 907: 0, 908: 0, 909: 0, 910: 0, 911: 0, 912: 0, 913: 0, 914: 0, 915: 0, 916: 0, 917: 0, 918: 0, 919: 0, 920: 0, 921: 0, 922: 0, 923: 0, 924: 0, 925: 0, 926: 0, 927: 0, 928: 0, 929: 0, 930: 0, 931: 0, 932: 0, 933: 0, 934: 0, 935: 0, 936: 0, 937: 0, 938: 0, 939: 0, 940: 0, 941: 0, 942: 0, 943: 0, 944: 0, 945: 0, 946: 0, 947: 0, 948: 0, 949: 0, 950: 0, 951: 0, 952: 0, 953: 0, 954: 0, 955: 0, 956: 0, 957: 0, 958: 0, 959: 0, 960: 0, 961: 0, 962: 0, 963: 0, 964: 0, 965: 0, 966: 0, 967: 0, 968: 0, 969: 0, 970: 0, 971: 0, 972: 0, 973: 0, 974: 0, 975: 0, 976: 0, 977: 0, 978: 0, 979: 0, 980: 0, 981: 0, 982: 0, 983: 0, 984: 0, 985: 0, 986: 0, 987: 0, 988: 0, 989: 0, 990: 0, 991: 0, 992: 0, 993: 0, 994: 0, 995: 0, 996: 0, 997: 0, 998: 0, 999: 0, 1000: 0, 1001: 0, 1002: 0, 1003: 0, 1004: 0, 1005: 0, 1006: 0, 1007: 0, 1008: 0, 1009: 0, 1010: 0, 1011: 0, 1012: 0, 1013: 0, 1014: 0, 1015: 0, 1016: 0, 1017: 0, 1018: 0, 1019: 0, 1020: 0, 1021: 0, 1022: 0, 1023: 0}\n" + ] + } + ], + "source": [ + "new_histogram = {}\n", + "\n", + "for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + "print(new_histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "after_ = np.array(list(new_histogram.values())[:784])\n", + "plt.imshow(np.reshape(after_,X_train[0].shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "de_normalized_vector = de_normalize(after_,X_train[0])\n", + "plt.imshow(np.reshape(after_,X_train[0].shape))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def encode_qiskit(x,num_qubit=10):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit)\n", + " qc.bind_parameters(normalized_vector)\n", + " return qc" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def decode(histogram):\n", + " new_histogram = {}\n", + "\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values())[:784])\n", + " return after_" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[1;36m Input \u001b[1;32mIn [30]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", + "\u001b[1;33m from part1 import encode_qiskit,decode\u001b[0m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m\u001b[1;31m:\u001b[0m No module named 'part1'\n", + "\n", + "Use %tb to get the full traceback.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#grade part1\n", + "from part1 import encode_qiskit,decode\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for data in (X_train,Y_train):\n", + " #encode image into circuit\n", + " circuit=encode_qiskit(data[0])\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + " \n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #reconstruct \n", + " image_re=decode(histogram)\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(np.asarray(data['image']),np.asarray(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": 31, + "metadata": {}, + "outputs": [], + "source": [ + "#traning_qc = QuantumCircuit(10,10)\n", + "#traning_qc.append(qc,[i for i in range(10)])\n", + "#traning_qc.append(ansatz_,[i for i in range(10)])\n", + "##qc.append(ansatz)\n", + "#traning_qc.draw()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.utils import algorithm_globals\n", + "algorithm_globals.random_seed = 0\n", + "\n", + "import numpy as np\n", + "np.random.seed(algorithm_globals.random_seed)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "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": 34, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import SPSA" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_machine_learning.algorithms.classifiers import VQC\n", + "vqc = VQC(\n", + " feature_map=qc,\n", + " ansatz=RealAmplitudes(10, reps=2),\n", + " loss=\"cross_entropy\",\n", + " optimizer=SPSA(maxiter=300),\n", + " quantum_instance=Aer.get_backend('qasm_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABHT0lEQVR4nO2dd5jc5NHAf3PdvZ5x7zYGAy4YVwymGEwPJfQE0zsklAQn9HwQOqEHCKEECB0CmGbABgzu4IrBBZ/BvXdfn+8Pafe0u9pyZe9u2fk9jx5Lr15JI91ao5l53xlRVQzDMIz0JaOuBTAMwzDqFlMEhmEYaY4pAsMwjDTHFIFhGEaaY4rAMAwjzTFFYBiGkeaYIqhjRORWEXkxxv4FIjIqCddN1nlPFJFfRGSHiAyo6fPHuO5ZIvJJbV0vEUTkORH5v7qWozKIyIcics6v5TpxZNghIt3rUob6gimCJCMiY0VknojsEpE1IvKEiDRP9HhV7auqk6opQ8QLqSbOG4X7gCtUtbGqfpeE8yMiXUVERSQr0KaqL6nqEcm4Xjqhqkep6vPVOYf7m5+c6HUS6V9dRGSSiFwQJkNjVf0pmddNFUwRJBERuRa4G7geaAYMBboAE0Qkpy5lSyJdgAV1LYSRPng/CIwqoqq2JGEBmgI7gFPD2hsD64Hz3O1bgTeAV4HtwLdAP0//AuBwdz0DuAFYCmwEXgNaevoeCHwDbAF+AcYCFwElQLErz3ve8wLtgd1h5xkAbACy3e3zgIXAZuBjoIvP/ea651dgJ7DUbVegp6ffc8D/ueujgBXAtcA6YDVwrqdvA+B+YDmwFZjstv3snneHuwxz73Wy59jhwAz3uBnAcM++ScDfgK/dZ/4J0DrK33EhcKxnO8v9+w10t18H1rjX+RLoG+VeQ+QLfzbu87vPvbe1wD+BBlFk6gF87v4GNgAvAc09+wcC37n39jrObysgRwvgffceNrvrHcOezQVemV25NgPLgKM8fccCP7nXWQacBewFFAJl7t9mS5R7mARcEK1/rOdBxe/mz+6z/0+s+wLucM9f6F7jUZ/n3wx4wT1+OXAjkJHIc/g1LGYRJI/hQB7wlrdRVXcAHwCjPc0n4PyHbQm8DLwjItk+57wS+A1wMM4LfDPwGICIdAE+BB4B8oH+wGxVfQrnRXGPOqbwcWHyrAKmACd7ms8E3lDVEhE5AfgLcJJ73q+A/4YLpqpFqtrY3eynqj2iPZgw2uL8J+wAnA88JiIt3H33AfvjPMuWwJ+AcuAgd39z956meE8oIi2B8cDDQCvgAWC8iLQKu8dzgTZADnBdFPn+C5zh2T4S2KCq37rbHwK93PN8i/Osq8JdQG+cv1tPnOdxc5S+Avwd5zewF9AJ54MC19J8G0cJtXTlP9FzbAbwLI7l1hnnI+DRGHINAX4EWgP3AM+IQyOc53uUqjbB+RvNVtWFwCXAFPdv0zzWTcfoH+95tHXvrwvOx07U+1LVv+L8bgMuyyt8RHkE53fYHef/1+9xfh8xn0Ose0sp6loT/VoX4GxgTZR9dwET3PVbgamefRk4X8Yj3e0CKiyChcBhnr7tcL72s4BxwNtRrvcc7hehp8173guAz911wbEmDnK3PwTOD5NvFz5Wgbs/3AKIZxHsBrI8+9fhuNAy3H39fK7R1T2v97ixuF/cwO+A6WHHTAHGuuuTgBs9+y4DPopyPz1xvngbutsvATdH6dvclauZz70G5Qt/Nu4z3wn08OwbBixL8Lf2G+A7d/0gYCUgnv2Tw//+nn39gc2e7UmEWgRLPPsaujK3BRrhWJ4nE2a5+N2rz3XDr+O15mI+D/d3UwzkxTh/1Pvyef6Z7vn29uy7GJgU7zkk8vdJhcUsguSxAWgdxX/Zzt0f4JfAiqqW45i97X2O6wK8LSJbRGQLjmIoA/bA+SpcWkVZ3wSGiUg7nBdJOc4XVOCaD3muuQnnP2qHKl4rnI2qWurZ3oXjPmuNY1FV5Z7a45j3XpYTKvMan2tGoKpLcJ7zcSLSEDgex2pDRDJF5C4RWSoi23CUK67slSEf5+Uyy/OcP3LbIxCRPUTkFRFZ6V73Rc812wMr1X1jufziObahiDwpIsvdY78EmotIZhTZgs9JVXe5q41VdSdwGs7X/GoRGS8ifSp539FI5HmsV9XCatyXl9ZANqG/mai/F+9zqMQ91WtMESSPKUARjksliIg0Bo4CPvM0d/LszwA6Aqt8zvkLjine3LPkqepKd180d4xGaXd2qm7G8ZOfhuMyecXzIvkFuDjsmg1U9ZtY5/SwC+c/dYC2CR63Acen63dPMe8H59l1CWvrjPOlXBUC7qETgO9d5QDOszoBJ9bSDMdSAUdRhrMTz3MQEe9z2IBj/fT1PONmWuFqC+dOnGewr6o2xbE+A9dcDXQIc1t08qxfC+wJDHGPDbjZKu3mUNWPVXU0zofND8DTgV2VPVXYdiLPI/yYePcVS6YNOJa19zdTnd9LymGKIEmo6lbgNuARERkjItki0hUnwLsCJ8AVYH8ROcm1Hv6Ao0Cm+pz2n8AdbjwAEcl3ffjguCwOF5FTRSRLRFqJSH9331oc32csXsbxi57irnuvOU5E+rrXbCYiv43/BILMBs50v57H4Phf4+JaRv8GHhCR9u7xw0QkFyegVx7jnj4AeovIme6zOA3YGyeAWBVeAY4ALiX02TTB+VttxHnJ3xnjHHOAviLSX0TycH36ELzXp4EHRaQNgIh0EJEjo5yrCU7Qc6uIdMAZlRZgCo6VeIV77ycAg8OO3Q1scWMpt8S68Wi4VskJbqygyJWn3N29FuhYiZFxIf2r8Dwg/n1F/T+gqmU4/y/vEJEm7v+va3AsrbTAFEESUdV7cAKt9wHbgGk4X9iHqWqRp+v/cL7GN+P4t09S1RKfUz4EvAt8IiLbcZTFEPdaPwNH43wZbcJ5Afdzj3sG2Ns1s9+JIu67OEHPNao6x3MPb+MMgX3FNbnn41g0iXI1cByOP/ksINr1/bgOmIcz6meTK0eGa5rfAXzt3tNQ70GquhE4FudZbMQJMh+rql53XMKo6mqcF+xwnBE4AV7AcSGsBL7HX3kHzrEIuB34FFiM47f38mdgCTDVfc6f4nzh+nEbzsigrThB8eCABFUtxrFCz8d55mfjKMDA7+0fOCOvNrjyfhRN5jhk4LwsV+H8bQ7GUZTgjGhaAKwRkUSeuV//yjwPiH9fDwGniMhmEXnY5/grcay2n3D+Ni/jfIikBRLqSjTqGyLyM3C2qn5Z17IYqYmITAP+qarP1rUsRv3ELIJ6jIjk4wTICupYFCOFEJGDRaSt6xo6B9iPqn/5G2mAzcirp4jIAcAE4BHX7WMYibInjs+7EY6r4xTXvWUYvphryDAMI80x15BhGEaak3KuodatW2vXrl3rWgzDMIyUYtasWRtU1XeSYsopgq5duzJz5sy6FsMwDCOlEJHw2fZBzDVkGIaR5pgiMAzDSHNMERiGYaQ5pggMwzDSHFMEhmEYaY4pAsMwjDTHFIFhGEaaY4qgGkz9aSNL1m2vazEMwzCqhSkCl627SigpK4/f0cPpT03l8AcsO7RhGKmNKQKXfrd/wqUvfhu337rthRRs2FkLEhmGYdQOKZdiIpl8unBtzP3//GIpd334AwAFdx1TGyIZhmEkHbMIKkFACRiGYfyaMEVgGIaR5pgiiME3SzfQ9YbxbNhRFL+zYRhGimKKIAbPfLUMgNk/b6lbQQzDMJKIKQLDMIw0xxQBYHWbDcNIZ0wRAOUePbBsw05K3Yllph4Mw0gHTBEQahEcct8k7vhgYR1KYxiGUbskbUKZiOQBXwK57nXeUNVbwvo8CBzibjYE2qhq82TJFI3wL/8pSzcCILUtiGEYRh2QzJnFRcChqrpDRLKBySLyoapODXRQ1T8G1kXkSmBAEuWJSrnFCAzDSGOS5hpShx3uZra7xHrjngH8N1nyBJi8eAOPfLY4pC1cD4iYLWAYRvqQ1BiBiGSKyGxgHTBBVadF6dcF6AZ8HmX/RSIyU0Rmrl+/vloynf3MNO6fsChmn0DMwOwEwzDSgaQqAlUtU9X+QEdgsIjsE6Xr6TgxhLIo53lKVQep6qD8/Pwal9PPNbR+e5HNKDYMIy2oleyjqrpFRCYCY4D5Pl1OBy6vDVn88AsRHHDHp7UviGEYRh2QNItARPJFpLm73gAYDUSk7xSRPkALYEqyZIlHdV1A36/aViNyGIZh1AXJdA21AyaKyFxgBk6M4H0RuV1Ejvf0Ox14Retwem+4a6iyweKjH/6KrbtLalIkwzCMWiNpriFVnYvPcFBVvTls+9ZkyZAo8VRQInqhqKQMGmTXjECGYRi1iM0sBsbPXR1zv00zMAzj14wpAuAvb8+raxEMwzDqDFMEVWRnUWldi2AYhlEjpL0iKC+vmt+n7y0f17AkhmEYdUNaKQK/gUm7S3znsIXwy+ZdvDClIPa5qyqUYRhGHVMrE8rqC0Wl5RFtu4rjK4Lb3vs+GeIYhmHUC9LKIigpi1QEuxNQBIlgaeoMw0hV0soi8IYDHpywiK27SzhjcOeIflV5qZtryDCMVCWtLALv2/qhzxbz3DcF7CqOHP3z/erKp4wYcudnvDFrRXWkMwzDqBPSShGoz3d7TbmGAO76MCKVkmEYRr0nrRSB30jRRILFiZJhgQLDMFKQtFIEVR0+mihW2MwwjFQkrRTBVa98F9FWWIOKIMM0gWEYKUhaKYKvl2yMaKvJhHKmCAzDSEXSRhFEK3fgF0CuKqYHDMNIRdJIEfi3VzHVkC+mCAzDSEXSRxFEafcrXF9VzDVkGEYqkjaKINoL32IEhmGkO6YIalATmB4wDCMVSZoiEJE8EZkuInNEZIGI3Bal36ki8r3b5+VkyVMbMQKzCAzDSEUSSjonIl2AXqr6qYg0ALJUdXucw4qAQ1V1h4hkA5NF5ENVneo5by9gHDBCVTeLSJsq3kdcoimCmrQIbGaxYRipSFyLQEQuBN4AnnSbOgLvxDtOHXa4m9nuEv7WvRB4TFU3u8esS0zsyhNtmKhZBIZhpDuJuIYuB0YA2wBUdTGQ0Je7iGSKyGxgHTBBVaeFdekN9BaRr0VkqoiMiXKei0RkpojMXL9+fSKXjiDaC9/SRxuGke4kogiKVLU4sCEiWST4/lTVMlXtj2NFDBaRfcK6ZAG9gFHAGcDTItLc5zxPqeogVR2Un5+fyKUjqI1gsVkEhmGkIokogi9E5C9AAxEZDbwOvFeZi6jqFmAiEP7FvwJ4V1VLVHUZsAhHMdQ40YPFNagI0mYMlmEYvyYSeXXdAKwH5gEXAx8AN8Y7SETyA1/3boB5NBCesP8dHGsAEWmN4yr6KSHJK0m0L/8nJi2tsWuYRWAYRioSd9SQqpYDT7tLZWgHPC8imTgK5zVVfV9Ebgdmquq7wMfAESLyPVAGXK+qkZnhaoBoMYLNu0pq7BqmBgzDSEXiKgIRWYZPTEBVu8c6TlXnAgN82m/2rCtwjbsklZqMBURDzCIwDCMFSWQewSDPeh7wW6BlcsRJHjU5TDQaNo/AMIxUJG6MQFU3epaVqvoP4Jjki1az1GS66WiYRWAYRiqSiGtooGczA8dCSGhGcn2iFjxDZhEYhpGSJPJCv9+zXgoUAKcmRZokUpPDRKNhFoFhGKlIIqOGDqkNQZKNWQSGYRj+RFUEIhJzJI+qPlDz4iSPWrEIbACpYRgpSCyLoEmtSVEL1IpFYDOLDcNIQaIqAlX1rR+QqtSOa8gsAsMwUo9ERg3lAecDfXHmEQCgquclUa4apzZcQ4ZhGKlIIs6M/wBtgSOBL3AyicYrSlPvqA01YBaBYRipSCKKoKeq3gTsVNXncSaTDUmuWDVPbVgENmrIMIxUJBFFEMjKtsWtJ9CMBAvT1CcsRmAYhuFPIhPKnhKRFsBNwLtAY3c9paiNpHOGYRipSCKK4FlVLcOJD8TMOFqfqY2kc6ZqDMNIRRJxDS0TkadE5DBJ4RwKtZF0zkYmGYaRiiSiCPoAn+IUsS8QkUdF5MDkilXzlJfXwjVMDxiGkYIkkoZ6l6q+pqonAf2BpjhuopSiNr7WLQ5hGEYqklBSBBE5WEQeB2bhTCpLueyjtYG5hgzDSEUSmVlcAHwHvIZTU3hnsoVKBrXxkq4N95NhGEZNk8ioof1UdVvSJUkytfGxbhaBYRipSCIxgiopARHJE5HpIjJHRBaISEQSOxEZKyLrRWS2u1xQlWslQu3ECJJ+CcMwjBonmSUni4BDVXWHiGQDk0XkQ1WdGtbvVVW9IolyALUzoscsAsMwUpGkKQJ1htDscDez3aUO35Q2j8AwDMOPRILFucDJQFdvf1W9PYFjM3FGGvUEHlPVaT7dThaRg4BFwB9V9Ref81wEXATQuXPneJf1pXYsguRfwzAMo6ZJZPjo/4ATcArX7/QscVHVMlXtj5O6erCbtM7Le0BXVd0PmAA8H+U8T6nqIFUdlJ+fn8ilfc5RpcMqeQ3TBIZhpB6JuIY6quqY6lxEVbeIyERgDDDf077R0+1fwD3VuU4samX4qOkBwzBSkEQsgm9EZN/KnlhE8kWkubveABgN/BDWp51n83hgYWWvkyi1owhMExiGkXokYhEcCIwVkWU4I4EEJxa8X5zj2gHPu3GCDOA1VX1fRG4HZqrqu8BVInI8jttpEzC2ivcRH4sRGIZh+JKIIjiqKidW1bnAAJ/2mz3r44BxVTl/ZamVNNRmERiGkYIkMqFsOdAcOM5dmrttKYWloTYMw/AnriIQkauBl3DKU7YBXhSRK5MtWE1jw0cNwzD8ScQ1dD4wJJBsTkTuBqYAjyRTsJrGgsWGYRj+JDJqSIAyz3aZ25Za1EqMAErLLAWpYRipRSKK4FlgmojcKiK3AlOBZ5IqVRKoja/1ZRt20vOvHzJ+7uqkX8swDKOmSCRY/ABwLs7wzk3Auar6jyTLVePUpv/+owVrau9ihmEY1SRqjEBEmqrqNhFpCRS4S2BfS1XdlHzxag4b2mkYhuFPrGDxy8CxOEnjvG9Rcbe7J1GuGsdG9BiGYfgTVRGo6rHuv91qT5xkUnuaIPUi6YZhpDOJzCP4LJG2+o5ZBIZhGP7EihHkAQ2B1iLSgooP3aZAh1qQrUaxMf6GYRj+xIoRXAz8AWiPEycIKIJtwKPJFavmMT1gGIbhT6wYwUPAQyJypaqm1CxiP8wiMAzD8CeRCWXlgboCACLSQkQuS55IqY9YtNgwjBQiEUVwoapuCWyo6mbgwqRJlCRiWQTdWjeqRUkMwzDqF4kogkyRim9ct9BMTvJESg7lMVIAZWYIOVmJPArDMIxfH4lkH/0IeFVEnnS3L3bbUgqLEBiGYfiTiCL4M87L/1J3ewJOofmUIm6w2DSFYRhpSlxFoKrlwBPukrrEeNFbHiLDMNKZRGYWjxCRCSKySER+EpFlIvJTAsflich0EZkjIgtE5LYYfU8WERWRQZW9gUSJZxHUZClLGzRkGEYqkYhr6BngjziTysri9PVSBByqqjtEJBuYLCIfqupUbycRaQJcDUyrxLkrTawUE4pNODMMI31JZKjMVlX9UFXXqerGwBLvIHXY4W5mu4vf6/ZvwN1AYcJSV4HaKF5vGIaRiiSiCCaKyL0iMkxEBgaWRE4uIpkiMhtYB0xQ1Wlh+wcCnVR1fKUlryR+FsGZQzon5VpiM8oMw0ghEnENDXH/9frvFTg03oGqWgb0d2cmvy0i+6jqfAARyQAeAMbGO4+IXARcBNC5c9Ve3uEB4f6dmjO0eytenvYzaOKDhrrnN2LF5t0Ul1ptYsMwfh0kUqryEJ8lrhIIO8cWYCIwxtPcBNgHmCQiBcBQ4F2/gLGqPqWqg1R1UH5+fmUu7TlHZFtGFT7cBfjd0C5VksEwDKM+EtciEJGb/dpV9fY4x+UDJaq6RUQaAKNxYgGB47cCrT39JwHXqerMxESvHOGjhkQgw+PCqcwQ0sBRzRpks3V3SU2IZxiGUWckEiPY6VnKgKOArgkc1w4nvjAXmIETI3hfRG4XkeOrKG+VCX/PCxUWgVK5+WQZVTElDMMw6imJTCi737stIvcBHydw3FxggE97NAtjVLxzVodIi0CCAeRo7/X8Jrms314U0qb4zxPIkIqAtKkJwzBSiapkWmsIdKxpQZKNn0XQpVVD8rIz+Osxe/nGEE4d5H+bgVFBAXdSswbZfPyHg2pSXMMwjFojkRjBPCo8J5lAPhAzPlAfCZ9HMGaftvRt34yFt4+JOtyz1G/MqUbWGzhi7z1CUlnbjAXDMFKJqBaBiHRzV48FjnOXI4D2qppypSq97/TvbhrN+Qc6txdQAu9eMSLymHLl8kN6RLT33qMxAN3znX+zMjPIyqx4lGWxpjEbhmHUM2K5ht5w//23qi53l5WqWlobgtU0547oGlxvnJcVYQXs17F5xDH7dWzO9Uf2iWj/Tf8OvHfFgRy9b1sAcjJDz1Vm+SoMw0ghYimCDBH5C9BbRK4JX2pLwJoiNyszuB4tmOv18399w6Ec1699RB/FsSL27dgs2Oa1BgDGz13N5p3FbNpZzO7iyqRnMgzDqH1iKYLTcYaLZuFM/gpfUpaMKDGBPdtW3FaH5g3inicQQ8jKjDzfM5OXMfBvEzjx8a+rKKVhGEbtEDVYrKo/AneLyFxV/bAWZUo61UkF5J14VlLqrOdkRurTQOnLH9Zsr/rFDMMwaoFEUkz8qpQA1FxSuFK3EHJWRuRj/GLR+hq5hmEYRrKxiu0JsH+XFlxwYLeI9uIyRxFkZ0UqllnLNyddLsMwjJrAFEECvHnpcM5yE815xwOVljlb2T4WgWEYRqqQSKnKhiJyk4g87W73EpFjky9a/cLPmVQSsAh8gsVeXpn+Mxe+kJRceoZhGNUmkU/ZZ3HKTg5zt1cC/5c0iZLIbcf3pU2T3Jh9Lh3Vg36dmkfd750iUFIWGDUU+zHe8NY8Jny/NmE5DcMwapNECtP0UNXTROQMAFXdJSlaguuc4V05Z3jXmH3+PCZyAhn4jzQqdS2CwKihA3u2ZvKSDVHPXVauZFrmUsMw6hmJWATFbj0BBRCRHjgWQlrRurFjSZznmaEccA0F5hG8eMGQiOO8FJaUUVauTPh+LarKzIJNrN2W1FLNhmEYcUnEIrgV+AjoJCIvASNIoLzkr41GuVkU3HVMSFuJO6EsO45rKEBhSRnvzlnFuLfmcc8p+/GnN+bSslEO3940usblNQzDSJRE5hF8ApyE8/L/LzBIVSclV6zUoKQ0Mlj8yR+jp6PeXVLGziInVdP8lVsB2LSzOIkSGoZhxCeRNNTvAS8D76rqzuSLlDqU+lgEPd2MpH4UlpTTqnEOAD9v2pVc4QzDMBIkEZ/GfcBI4HsReUNEThGRvCTLlRJUxAgqHmOsMpZOjMBZL9gQW6de9MJM/jv95+oLaRiGEYdEXENfqOplQHfgSeBUYF2yBUsFEp1HEKCwpIxi1520YUdsl9An369l3FvzqiegYRhGAiQSLMYdNXQccBowEHg+mUKlCjluamtviutYFJaUU1zqpKXeURS9rINaPQPDMGqRRGYWvwYsBA4FHsWZV3BlAsflich0EZkjIgtE5DafPpeIyDwRmS0ik0Vk76rcRF1x3yn78cfDezOwc/OE+j/55VKKXIsgFon0MQzDqCkSiRE8g/Pyv0RVJ6pqom+pIuBQVe0H9AfGiMjQsD4vq+q+qtofuAd4IMFz1wvaNM3j6sN7JZzN9KvFG4KuoVh4i9lc9tIs1m0rpOsN45n208Yqy2oYhhGNqK4hETlUVT8HGgEnhL/sVPWtWCdWx7+xw93MdhcN67PNs9kofP+vkR3F8St97vT0+WDeGo7s65TEfGHKcoZ0b5U02QzDSE9ixQgOBj7HiQ2Eo0BMRQAgIpnALKAn8JiqTvPpczlwDZCD437yO89FwEUAnTt3jnfZes3qLfFnEoeXtywscbZFYFdxKR/NX8OJAzrUWF0FwzDSm6iuIVW9xV29XVXP9S7A3xI5uaqWuW6fjsBgEdnHp89jqtoD+DNwY5TzPKWqg1R1UH5+fiKXrncctY/zVb9qy27f/arK+LmrKSkrZ1eYIpi8xHEJZWYId36wkGtem8MUcxMZhlFDJBIjeNOn7Y3KXERVtwATgTExur0C/KYy500lRvRsDfgrgsKSMj5buI7LX/6WRz5fEuIaAnhvzioAMkWCM5E3hg0//cvb87j6le+SIbphGL9yYsUI+gB9gWYicpJnV1Mg7oQyEckHSlR1izv8dDRwd1ifXqq62N08BljMr5T2zZ1HtmprhWuoYU4mu4rL6HPTR8G2hz9bzM8b2/ueQ0RokO38yXaXhFoNL09zJp89dPqAiONWbtnNbx77mtcvHkbX1o2qdyOGYfzqiBUj2BM4FmhOaJxgO3BhAuduBzzvxgkygNdU9X0RuR2YqarvAleIyOFACbAZOKfyt5AatGkSqTvDXUAB3pm9yrc9QyA32zHiCkv8j/XjvTmrWL+9iJen/8xfjt4r4eMMw0gPoioCVf0f8D8RGaaqUyp7YlWdC0R8nqrqzZ71qyt73lSge+tG/BSWQqJloxxEQgvbVJYMERrmOH+yRWu3s7OolEa5WZz6ZOw/T6McZ8LbzhiT2AzDSF8SiRFcIiLNAxsi0kJE/p08kVKfz68bxeBuLUPacrMyaJqXHdLWJDehid1BMjIkmM7ixak/c9a/prGtsITpyzYF+wTSXngJKI9oFohhGOlNIopgPzfYC4CqbsbnS98IJXxgZ3ZWBs0bOorgwJ6tKbjrGA7p06ZS51yybjtFJRUv+tm/bGG/Wz8J6bN1d0nEcQ3MIjAMIwaJKIIMEWkR2BCRliSYoyidyQgb45+TmUG56xcKWAt3nbwvedmJFbUBmFGwOW5GUj9FUOamyw4PMBuGYUBiiuB+YIqI/E1E/gZ8g5MOwohBQA/0bOPUJ8jOzOCXTc7Q0cP32gNwXDYDOrXwPT4aO+O4d7bsilQEpeWOFREr0Z1hGOlL3C97VX1BRGZSMev3JFX9PrlipT6nHdCJb5Zu5IXzBtOyUQ6ZGcL9v+3H8o072bt902C/hjmJZS5NlCKfr/6SMsci2FVkFoFhGJEk6uJpCexU1WdFJF9EuqnqsmQKluqc0L8DJ/TvENJ28v4dI/rlZDlG2VWH9uSD+WtYsm5HRJ/KUOwTLC51FUFRqSkCwzAiSSQN9S046R/GuU3ZwIvJFCqd2F7ouGvaNM3j02sO5hQfZVEZ/LKbBlxDiWQ+Bfj0+7Ws2xY/J5JhGL8OEokRnAgcD+wEUNVVQJNkCpVOLFjlFLEfkGBNg3j4WQQB15DfvnBKy8q54IWZnP701Epdd9Ha7Yx7a14wMG0YRuqQiCIodlNKK4CIWI6CGuTcEd0A6NPWiRtUtziZr0XgKoBECt7s6aa7WBanpnI4l/xnFv+d/nOljzMMo+5JRBG8JiJPAs1F5ELgU+Dp5IqVPlx1WC+W/f1oMmMUva8M/q4hR7v4TTYLp8pf9K745VZm0zBSjkRGDd0nIqOBbTj5h25W1QlJlyyN8NYV0GrW5rnhrXnMX7WV64/oQzN3AltAORSXlgfrIdd0LYNM93yJxiEMw6g/JDSbSVUnqOr1qnqdKYHk0rllw5j7375sODmZsf9sL079md88/jUAKzbvYt5KJw5RrvDYxCV0G/cBi9duDzlm3bbCoAsJHBfVhO/X8uG81Xwwb3WwfeOOIqYsjayFELBobK6CYaQesdJQT1bVA0VkO/4lJDcC96rq40mTLg254pCe7NO+GV8uXs8LU5ZH7N+nQzM6tmzAT+tj++IDvvoD754Y0n7fJ4sAGP3gl/x059FkZAjf/ryZkx7/hrOGhFZ/u/CFmcH1gruOAeC3/5zCTxt2suSOo8jyKKTATOpdCZTiNAyjfhGrQtmB7r9NVLVp+AIMAn6V2UPrkqzMDA7few9uOnZvpoyLrNyZlSE8csYADt9rD1o0zPY5Q+IEgsfLNzpK441ZK+IeE8iqujlsBnOG+0u6+pXZfPfz5oSuv3VXCZN+XMch902yPEiGUYck5BoSkYEicpWIXCkiAwBUdSMwKpnCpTPZmRm0a9aAa0f3pk/bitG6IkLf9s341zmDmP7Xw6t1jcKSMgpLyti803mpxxtVtK2w4uW/cWdRcF1V2eHOh9heWMqJj3/D8Y9OZuHqbSHHb9lVzHzXTQXQ7/ZPGPvsDJZt2BnSbhhG7ZLIhLKbgeeBVkBr4DkRuRFAVVfHOtaoPlce1ouP/nCQ777sOLGCeMz+ZQt9bvqIt76LbwnMWr45JNOpt1TmS9N+pmDjrpD+c1ds5a4PfwhpO/2pqRz7yGTf89fF9IPi0nJWbN4Vv6Nh/MpJ5E1yFnCAqt7iFrQfCvwuuWIZNcHrM3+Juf/ODxYCMH/ltpj9AE5+4puQ7Q07KiyCST+u9z0mfCjqD2ucAHXXG8bzv9krQ/ZVd7QUwC+bdjFvReKWxXWvz+HAuyda6g0j7Ukk19AqnBrFgZwDucDK6N2N+sL1b8yNuX9xNfIardlayPyVW9leWEqjXP/EeVN/2oiq+g5VfWV6qJKqiWGnI+9xAuMFdx3Df6Yup13TPA7fe4+o/d+d45QE3VlURm5WzSb/M4xUIqpFICKPiMjDwFZggYg8JyLPAvOBLbUkn1ENKlsBLVFyMjP4+4c/cOwjkznj6akRgeMApeXKi1MjRz4BERPoxj47I2T4ajSWb9xJ1xvG8+3Pm9leWML7c/3rO9/0znwu8Ix6ioUFqo10J9abIvC/aBbwtqd9UtKkMWqU7Qm84Eb2as2CVdsY1qMV4+cmFvI5ef+OIQVyft4YfSjrorX+VoefK2jTzmLaNM2Lee0vFjluqLe+XcHmXSWMn7uarIyMkGGrWsnZzdWd+/DghEWs3LKb+37bL2a/pet38I9PF3P/b/sFs84aRn0g1vDR51X1eeBVHGUwC3jV0x4TEckTkekiMkdEFojIbT59rhGR70Vkroh8JiJdqnMz6cizYw9gj6a5IW0vnDeYZg2coaWtGuVEHPP7YRWP+foj9+Tbm0YzdnjXkD7ekUpeHj1zAG2ahF5v085i376xKCzxSY4XFlNYun4Hq7fuDmkLxB0yRFix2dl3yYuzuOa1OcE+3iptqsru4jLKY0Sjj3roK16JU/ktFg99tjihobfXvT6H9+asYu6KLVW+lmEkg1iuoSwRuQdYgTNq6AXgFxG5R0QSGcBeBByqqv2A/sAYERka1uc7YJCq7ge8gVU+i8r1R+4Z8bIGOKRPG644pGdIW9tmefx77CDAmYAWTvMGFX++JnnOeoPsCh/5G5cM489H9fGVo1FuVlDJBNhWWBqhjAJECwIX+hTQCbSVlJXz78nLOOz+Lxj298/57T+/CQaXA+/zDBGipWe69+Mfg+vvzF7JXjd/xJvfxn5RP/L5klC5Vel32yc8/01BsG3DjiKueXV20PrYurukUrmZAnUhsqo52sswappYrqF7cdJNd1PV7QAi0hS4z11iTiZzM5YG/ALZ7qJhfbzTXqcCZ1dG+HTi8rCXvR/H7teOUXu2oVebxogIX/3pEJZv3MUXi9bTPb9RcDZys4YVVkLTPOcn0MBTKS0nK4PcMv+XVaOcSEUA0LZpHmu3FUW0R3P7x1IEd36wkGe/Lgi2zyjYzIyCzVz9ymz2audkaZ2+bBPrtkdeD5zhrAHGz10DwHLP8NZPFqzhov/MCjlm5ZbdbNpZTEvXglq9tZCtu0u49b0FnOMq4Ec+W8xb361kQOfmnHZAZ/rd9kmIdRWPQNK/3zz2Ncf3a8/YEV0Z2Nm/VGlJWTlFpeU0TlKcxzC8xPo0ORa4MKAEAFR1G3ApcHQiJxeRTBGZDawDJqjqtBjdzwc+jHKei0RkpojMXL/ef6hiOnPMfu3p07YJ1x+5J6fs3zE4SqdTy4bku26cs4ZUvLCaxbEIcrIyyMv2H0WTmSE095nRPGfFVt8cSDMLNrFo7faIQLCfa6iwpIyfN+4KUQLhBCapfb96W8gQ1mis3+4Mdnt04hKWrne+S6JZB9e/XuFeClSK8z6rwLyNRWt3BN1Pb38bewBdcWk593z0A1t3l4Rkf313zipOevybqMf9+c257HPLx1FHU63bXsieN35obiajRoilCFR9om6qWoZ/7iG/E5Span+gIzBYRPbx6yciZ+OkrLg3ynmeUtVBqjooPz8/kUunFS0b5fDRHw6iS6vIUhF7tm3CV386hPNGdA22eV9ugaClt3ZydmYGuVGCmRlSoTzCefPS4RFti9ft4IgHv+Toh78KaffLSXTyE1N4Y1bsuQ+J0rqx82XvtVL++Ops5q3Yyo9rtvses2R9RWB7yk9OYr2AG23x2u3B4bb/mbqcQ+6bBEBmZoV/yi/N97tzVvH4pKX849NFwXTgXqIFtj/9fi0AXy7y//CZvHgDRaXlMZWmYSRKLEXwvYj8PrzRfWn/4NM/Kqq6BZgIjPE53+HAX4HjVTX+J55RaTq1bBgylt/PteO1AHIyM4K+70DfZ889gIsP7k6/js0JfPj361gRf/jn2fuzb8dmQddKOOGjh6INOX04zFdfVVq47q+12ytKbgpw3KOTI2ZBB/DOln5thqOQCjbu4oc12xj94JfBEUvgP9JoV3GFu+u5r5exZN0OtrtpOcrKNRgj8LKzuIwf1mzjp/WhzydQqCh85vPKLbv5eMGa4HZlR0gZhh+xHJCXA2+JyHk4I4bA+WpvgFO+MiYikg+UqOoWEWkAjAbuDuszAHgSGKOq66ogv1EJmuZlsa2wlOYNszlrSOeQ+sheCyAnK4O+7ZtxycE9OG9E1+CQzkP2bANAz3xnRNGlo3pwyYvfAjBqT8dS87qA3rl8BL957OuYMl04shsH927D2c9E9xqeOKADb39XuTmMLVyF5H1Pxiv+s6OolPXbi2jdOIctnpFHz04uiHrMbs/Lf3dxGc0aZPO/2Su59b3vadEwm4sP7gE4z9fPYhhx1+dBN1MgwytAbrbz99gYNiLr2Ie/ClGilVUDqsqb367kqH3a0qiexh/emLWCTi0aMKR7q7oWJW2INXx0paoOAW4HCtzldlUdrKqJ/K9sB0wUkbnADJwYwfsicruIHO/2uRdoDLwuIrNF5N1q3IsRhxuP3RuA1o1zuePEfRngCVR6LYaWjXLIzBBuOKqP77j+Zg2zKbjrGMbs0y7YFlAkXvdHv47NOLJv9Jm9WRnCuKP2olPLBjHlDh+uGk7bpnkRfVo2jLRMEqkCd8AdnzLh+7WUlSsnDewA4BsTCeBN1LeruBRV5epXZgOO1VPkxkJyszJ9XUPeoa4rtzjDYQtLyoLn3bAjVBFEs6TCKSwpY+tuZ56FVznPX7mN616fw7i35iV0nnB+98w0hv/9syodmyjXvT6H056qXM1so3okUqHsc+Dzyp5YVecCA3zab/asVy99plEpTh3Uid96gsnRqEoyu8A5ve4PEQl+kd987N7kZGVw3H7t+cOr3zHxx/W0apxDRoaEBKr9aN04tiJ4/6oDgy+9ByY49RZa+LioMhKsyhYYUTSwcwu+XLSBbYWJTTjbsruEAX8LrdsUcA2VlmvcUqEj7vqcRf93FH3cutEA/53+M7cd37fSE9AOf+CL4DyLc0d05Zbj+gIQeASL1vrHSeLx1eINVTrOqN/YgOY0I5YSOK5fe64/cs9qnb847GXXtpljUfRo05izh3ahWcPsYDwi8ILPjaMIGudVfK9MvG5UcP3a0b154qyBtG6cS4/8xlx1WC8O38uxQPxqNUxbtqlS99IkL4umeVnBl3k83p+zmi1hX+yByXYFG3bGTfMNFVaBlwPu+JQdRaVsrsTEvYASAPjCkxQwoJi37Y68p9Kycq5/fQ7//GJp3ISFfmwrLGG9Z0jvknU7KiWzUXfUTyehUSc8ckaEAVdtbjiqD3u2bcJBvVoH2wJj4wMB3bzs2N8jXl+2d+LalYf1iujbPb8RLHSOycnMiFBM0ThrSOeQ+QcBOZvkZYW8VAGe/N3+XBw2DwHgpw2R6TQCPv6PPAHeWARGI3nZuruEw+//gjXbCiP2JRIr9lp4xWVOTGPV1kJem/kLWRnCiQM6ICLMWbGF1z0zpH87qFPUc5aUlUdYjqPuncSmncXBWMfhD3xBu2Z5TBl3WPCYp778ifMP7BZ1eLJRN5giMJJCYKJaw5yskDkMUOFzD4xIileDufcejYPrDbIzeeOSYb7+dqhwfYhEWiex8EvF0SQvm8Z5WXy9JLRGc35YPCK/SS7rtxexyGdYaqBkaFUY1r1VcBirnxKAyGDxzIJNEZZPlmeIq9cq+ZObnTYvO5N12wpZH2dehjdd99bdJREuO79UI6u3Vsj9+swV3PvxjxSWlHHtEf6Wp42CqhtMERjV4sZj9iLLJwj7jfsV6EdAAQS+CkWEO0/cl04tG/C7Z6YDMOeWIwDHhdGpZUMuPqg7T375EyLCoK4to55bcGTxvk8eO3Mgl7/8bUTf8VcdyDEPO4VymvkElxvnZtEgO/K/SPgci+fPHczRD3/FKveld9Q+bTmga0tuf/97ft5U9cI3sYLUfjzwyY++w29VYf7Krbzz3UoO9FhmAX5cs52HPlsc9/ze4bVbdkUqgniUlTtKKFZuqsoob6PmsBiBUS0uGNmdsSO6RbTHCgD7zWM4c0hnRvbKJ79JLk3znDQWzRpk06llQwDGHb1XyPDKaAR0kqoGrZI921ZYFP/6/aDget/2FfMgAvIe4alf0CQvi3krt0RcI9yt0T2/EU3ca/Vp24Qnzt6fMwZ3jiurH3nZGRzQ1RnN1dxHOcUi2hyMwtIyTnr8G/41eVlEDAMqalaHs6OolDdmrQh+pXvnTmzdXRySJmRmQagV4peDKRAL8ptVHqAm6lJUlqXrI1166YYpAiMpxBqqGWtU0uQ/H8LkGw6t8nUDI4PKFZ783SBG9mpNl1aNePmCIfztN/tELVQTEMkbmG7TNJe/HL1XRF+vRXBcv/bkZWeyhzvMNjChzpu7KZpSONcz2ztAq0a5tGrkfGn7Kcxw3puzim2FJTGzqxYWlwW/tP/w6uyI/dHcV/d/8iPXvT6HF6cu54UpBSEv/n99tYw+N33EL5t2sXVXCaf8c0rIsX4v9MBz86sIt2lnMYfcNyloodUWnyxYw2H3f8GH89K76q65howa5d0rRjCzYHPMPrFGceZmZVarWlhA/5SrMqxHK4b1cCYlDe/ZmuE9I90iY4d35blvCoJZTTM9wuVmZXJC/w5sKyzlpnfmh7QHCATY2zXLY8m6HbRvHjknYkCn5m4RndCXTfMGkV/8LRvlBJVIo5zEnoO3lrQfhT4v5cHdWjLdjSXMiVLec52bnuOm/y2I2PfhfCf4PfKeiXx27cEh+8rKNeJlP90Tt/CzCIbc+SklYTOvS8rKOfHxr7n+yD4c3LvyqWXmr9zKTxt2cny/9lH7zHFzNS2pRrW+XwNmERg1yn4dm3PegZGuIi+BL94OLWJPJKsSHosgGp9dezDfuFbHrcf3peCuY+jq5mnaz5M2I0CnMDlzfUY5tXUtgu75kfme2jR1JvBdO7o3S+44Khgc91ofAbyKoLCGain7+eQHdG4e97jxCX4lT1kaGkwvLi0PCUr/smkXpz45hb++7ShTP4sgXAkArNtexPyV2xj3pn/J1bJyZcGqrb7zM9ZtK+TYRyZz1X+/iyl7IC1IgwSVbixmFGxKKBFifcQUgVHrHLZXGx47cyBXHho/tXZl8cYIotEjv3HEl/uwHq348OqRnD20C0fv25arPENTD+6dz9Oe2EKej8XStbWjANo0iZyJ3a5ZA5o1yObKw3qR5RnS2iSKIgjUnejfyT9FdWXwm08B0LpR5QK9sQiPMRSVlgVnVENFevFAjGHK0o3sddNHrNnqPxIqQMC9lJkpLFm3nQWrtvLo54v5aP4aut4wnh5/+YBjHp7Me3Miy5We8+yMhGQPyFZdRbBw9TZ++88pnP2v0FQpqhoytyJAebky6cd19WaUlCkCo9YREY7Zr12VZjDH45xhXTmsTxvfIj7x2KtdU0SEx8/an2tG9w62iwij996DvOwMWjfOJTsz0rd1wchu3Hnivpw4oEPEvrZhaTr+PMYp+uMNqI90R/M0zcui9x5N+OnOoxkdJZ4RjfB5IGcM7sTY4f7WWbTkgFUhPIlfYUl5yFd/uN+/tFzZXVLG0L9/5luXIkDAkikuLefwB77kmIcnc98ni7jR46aDiqG13peqt3xqoKiRH0GLoBLzGnYVl7Jue6gSO+ohJ7vu4jAX03PfFHDAHZ9GuJ5emv4zY5+dwfnPz6TrDePrfOKdKQLjV0WLRjk8M/YAWlVyaGMizL3lSL654dDg7OyRnqGYuVmZnDmks2+QvGmD0C//S0f1oOCuYzjAHQb78oVDgqVBA5PnMsLOk8iM7yHdQ4fVtmvWgB1F/rOi20SpKOfl6H3bhszhiMYvYUNkb39/QUjSvlhDQtdtK4o6UmjcW45LyK/gkZfthaXMX7mVbuM+YPYvWwCCwXsgmPsJYJ9bPuaW/zmKpKSsnP/NdqyJgA75ZukGrnl1dswv9RMe/ZrBd/jnWwq38ia7KTnCs8sWuAH6z39wcm2GT1qsbUwRGEaC5GRlBHP+zLzx8BB3kR+vXjSUW47bO2paj7bN8ii46xiG92gdfBFFywgaqFA3tHvkHIpXLhrKJ388iKZhdSKKSsuCSe3Cx/x3atEwuB4teP+b/h18U2eHE+4X/2DeGr4Jm4QXjbHPTaf3jb71qCJSlwcoDosxbNtdwneuAnhi0hLmr9wa8Rx/XLOd5Rt3sqOolOenLAdg1vKKQQ2l7hyHM5+exlvfraSotJwl67bT9YbxTP0p9F7Cv/pPeLTC4tmyq4Qf1mwLbgc+DMInQIYPr82o4zexKQLDqAKtG+fGTZMwpHsrzvWZY+FHIODZMIaveumdR/PyBUM5a0jocNSh3VvRe48m5GVnMmXcoUHX067isuBw2nFhNagDOaAAsn3eQlcd1osj+rbl6sMj03jcdOzeXHxQ9+B2eIZUIMJ1Eo1A+dTKEJ6zaXthKbmum3H5xl0c+8hk5q0MHQl15D++5OB7J4W0eT/6w4PVhSVlwRnasVxLEDnq6nRP5tSA+zNcEQQUT7Tr1zamCAyjHhBwn4RnGf30moP45I8HAc7XZUaGcMeJ+wb333rc3iH9A4FpgF1FZdxwVB+uHd2b4/uHDqH0KjG/mEcgp9MJ/TvwykVDQ/adObgzZw6JPWFukifRXU0TrgjmrNjCNjcxYKxZy14ue2lWcOgoOIr4lCcqSodu2lkcHBQQawKcH96EfoH0HuGlWsMtAm9di7rAFIFh1AOKS50XQ3jepZ5tmtB7jyYR/R85YwDXju7tO6u7Ua7zAttZXErzhjlceVgvsjMzmHWjf9b3LPeaH1w1MtjmnSsRbvnkZGXEDfT7ZVGtDoHZ1n4s37iLp7/6CXCGnCbCB/PW8OqMigyrXyxaz0yPq+jQ+79g2jLHJeQNfL8wpSC4XlauHHh3ZIb+coU1WwtRVbJcayvcxRa+vXrr7rhpypOJKQLDqAdEswiicVy/9r7ZVwFG9sqnRcNsLhjZPaS9VePckIR5H149ks+vPTj4ku3QvAGDu7WMkCM8t1JmhiQsp9/s6XBOP6Aiy+nY4V19A+PemIYf8QLKfnhnVPtZMAtWOb7+D+at4XduBb0fPIkF120vjBrkHfr3z7jiv98F83AVl5VzwfMz+GyhU4s63CK45rU53PBmaLGgwpIyJv5YO4UbTREYRj2gxHV3xMvEmggtG+Xw3c1H0L9T84h9E/54EJPcmg57tWtK9/zGPHT6AN66bDjNGmZz3yn9OG9EN0Z6ZmH7xUISVQTnx5lcePLAjpw00CmZeuHIbtx6fF8uG9Ujol9SJh/GYZXHqvlq8QaOfPBLZnhmSA/7e+x6XePnruZVt67D4xOX8OnCdZz//EwgMmYA8Oa3Tl6niT+uo6SsnIc/W8y5z85g2k+JBd6rgykCw6gHZLsv1rwamOEai+YNc4KT3wI0ys1ioFu2tHOrhtx83N4hFd7CLQKIrrBOHlhRB/sPh/eiY4wv+cV3HMW9p+zH4G4tefr3g4KpqUWE08JqIXTwSd0BTuW7cPZq1zTqNcOJle4kvCzoj2u3R4wYSpRVYZPn/JLyARx87yTOfXYG/568LOjmmhGW0C8ZmCIwjHrArcftzVWH9uSgXpXPqZNsfC2CMEVw+F5tePC0ftx2Ql+O2HsPROC0A6IXtgFnRE1gvoQzYa/iOuHB6GgpucNrQ4BTx2FA5+acM6yLzxGhNMoJHWaajNnufoSPGgoQSFu+ZXcJu4qdmdhVGVlVWZKmCEQkT0Smi8gcEVkgIrf59DlIRL4VkVIROSVZshhGfadV41yuOWLPmFlb64qAG6hBdibL/n40EDnh7dEzB3LigI40zs3in2fvz49/O4p2zaruzvEqhcfOHAj4P5dWjf0S92Xz9mUjOHKftiHtfgHn3WEzm/1mhodTXffdta/NoWBD7DoVLRvmMH+lE6MYP28117wWe5JbdUmmRVAEHKqq/YD+wBgRGRrW52dgLPByEuUwDKMaNMzOZO92TXnwtH6+k+OW/f3okBd3RiWCydHwli89Zr929OvUjG6tG/HCeYND+uU3zuXNS4fzxFkDg26pJnn+1sOhffag4K5jeO7cA7j/t/2ASBeNX86h8FQf8WZlnzE4tiX05rcr+HFtZDU7L3d8sDBoHRSVlvPWtysTqnldVZKmCNQh4FDLdhcN61OgqnMBK0tkGPWUjAzhg6tHMmafdr77o82crg7h7qh2zRow8bpRHBSWjrp141z279KCo/ZtF/T3B5RI+Af0/l0ci2DUnm0Y2dsJhl/rySkF/jmHurQMjXN0bhkZ9xg7vGtwhNDx/eJbFYly+F5tgus7PYWBapqkxghEJFNEZgPrgAmqOi3OIdHOc5GIzBSRmevXJ2+iimEY9QO/AHUAb8Ee73rgizkwByKgCIb3aMX8244MDo0FJ0vstzeN5gpPTOB/l48IWgTeHEstwhL09WwTmX8poGTAf4JeLIb3aMX4qw703ecNtu9IVUWgqmWq2h/oCAwWkX2qeJ6nVHWQqg7Kz69/wTTDSFcScQH9acyeIS/PwV1bcvbQ2DOTY6XvePeKEVx9WC+W/f3okFhFIAdRQKZe7sv8tAM60dgnh1PLRjkh1ky/Ts3Jzcrk7cuG8/KFFV7s8MlfPfIjFUG5atDdUdmsuueO6BZSNjVcxgDhWVdrklqpUKaqW0RkIjAGSN7dGIZRa3x6zUE086myFs5lo3py2aiedL1hPACvXTIs7jEBi8DPDdOlVSP+GObSAbjk4B5MW7aJod2dqnR7NM1LqM51OAM6hwaV17p5kxrnZrGjqDSk+NA+HZoyf+W2EDeUnyJo1yyP1VHqL0QrSXrPKfuFxDC+WrwBVU2KKy5pikBE8oESVwk0AEYDdyfreoZh1C4920SmvqgpRIRnzz2AvpWYEzCgcwtm33xEjcty2agebC8s5c4T96FcQwvxnDqoE/NXLqBzq4bBUT1+rqHXLh7G5CUbGNO3LXd/9AOveNJbtGzkrwgO7p3P0rD01UWl5XGTHVaFZFoE7YDnRSQTxwX1mqq+LyK3AzNV9V0ROQB4G2gBHCcit6lq3yTKZBhGinDInm3id6oFOrZoGFL0J+B6apiTye+GduHAnq3pnt84pmuoU8uGnDHYcYeF547q3tq/5kNuVkawhGqAbbtLUksRuKOBBvi03+xZn4ETPzAMw0gJAnPB2jbLQ0To7sYMAu6h7DhxE6+7a/TeewTjHPecsh9fLd4QLL2Zl50ZUWNiW2EJbZpGlkOtLrUSIzAMw5g67rCo1chSiUAth6ujJP3LzhA+vHoku0vKOOnxbyL2H7ZXG166YAjDurcKCXafOqgTpw7qFFQEOe7M60nXjWLUfZMAgoWGahpTBIZh1AreYjj1iTcvHUamT3GeDHFSSofTslFOzCB0dmZGMN/RyF6tI0YZiQgjPEn9ohFQEl1bN+KcYV14fspytu1OzhBSUwSGYaQ1+3eJLP8JMOvG0THrLUfD6xr6z/lDqiyXl98P7+oogkKzCAzDMGqN8IlkiZKVhHxRgVjBNnMNGYZh1H8qO6EsEVo2yuHTaw5OmnvN0lAbhmHUADcesxeZGZKUDLKZGULPNo19Z0jXBGYRGIZh1AAXjOweUR40VTBFYBiGUY94duwBEXUSko0pAsMwjHrEIX1qf0a1xQgMwzDSHFMEhmEYaY4pAsMwjDTHFIFhGEaaY4rAMAwjzTFFYBiGkeaYIjAMw0hzTBEYhmGkOaLqk3C7HiMi64HlVTy8NbChBsWpTUz2usFkr31SVW6o37J3UdV8vx0ppwiqg4jMVNVBdS1HVTDZ6waTvfZJVbkhdWU315BhGEaaY4rAMAwjzUk3RfBUXQtQDUz2usFkr31SVW5IUdnTKkZgGIZhRJJuFoFhGIYRhikCwzCMNCdtFIGIjBGRH0VkiYjcUNfyhCMi/xaRdSIy39PWUkQmiMhi998WbruIyMPuvcwVkYF1KHcnEZkoIt+LyAIRuTqFZM8TkekiMseV/Ta3vZuITHNlfFVEctz2XHd7ibu/a13JHkBEMkXkOxF5391OCdlFpEBE5onIbBGZ6bbV+9+MK09zEXlDRH4QkYUiMixVZI9GWigCEckEHgOOAvYGzhCRvetWqgieA8aEtd0AfKaqvYDP3G1w7qOXu1wEPFFLMvpRClyrqnsDQ4HL3WebCrIXAYeqaj+gPzBGRIYCdwMPqmpPYDNwvtv/fGCz2/6g26+uuRpY6NlOJdkPUdX+nnH3qfCbAXgI+EhV+wD9cJ5/qsjuj6r+6hdgGPCxZ3scMK6u5fKRsysw37P9I9DOXW8H/OiuPwmc4devrhfgf8DoVJMdaAh8CwzBmRmaFf7bAT4GhrnrWW4/qUOZO+K8dA4F3gckhWQvAFqHtdX73wzQDFgW/uxSQfZYS1pYBEAH4BfP9gq3rb6zh6qudtfXAHu46/Xyflx3wwBgGikiu+tamQ2sAyYAS4EtqlrqdvHKF5Td3b8VaFWrAofyD+BPQLm73YrUkV2BT0Rklohc5Lalwm+mG7AeeNZ1yf1LRBqRGrJHJV0UQcqjzudEvR3rKyKNgTeBP6jqNu+++iy7qpapan+cr+vBQJ+6lSgxRORYYJ2qzqprWarIgao6EMd1crmIHOTdWY9/M1nAQOAJVR0A7KTCDQTUa9mjki6KYCXQybPd0W2r76wVkXYA7r/r3PZ6dT8iko2jBF5S1bfc5pSQPYCqbgEm4rhTmotIlrvLK19Qdnd/M2Bj7UoaZARwvIgUAK/guIceIjVkR1VXuv+uA97GUcKp8JtZAaxQ1Wnu9hs4iiEVZI9KuiiCGUAvd0RFDnA68G4dy5QI7wLnuOvn4PjfA+2/d0ckDAW2eszSWkVEBHgGWKiqD3h2pYLs+SLS3F1vgBPbWIijEE5xu4XLHrinU4DP3a+/WkdVx6lqR1XtivN7/lxVzyIFZBeRRiLSJLAOHAHMJwV+M6q6BvhFRPZ0mw4DvicFZI9JXQcpamsBjgYW4fiA/1rX8vjI919gNVCC89VxPo4P9zNgMfAp0NLtKzijoJYC84BBdSj3gThm8FxgtrscnSKy7wd858o+H7jZbe8OTAeWAK8DuW57nru9xN3fva5/N65co4D3U0V2V8Y57rIg8P8xFX4zrjz9gZnu7+YdoEWqyB5tsRQThmEYaU66uIYMwzCMKJgiMAzDSHNMERiGYaQ5pggMwzDSHFMEhmEYaY4pAiNtEZEd7r9dReTMGj73X8K2v6nJ8xtGTWKKwDCcZH+VUgSe2bvRCFEEqjq8kjIZRq1hisAw4C5gpJsb/49uIrp7RWSGm0P+YgARGSUiX4nIuzizSRGRd9zEaQsCydNE5C6ggXu+l9y2gPUh7rnnu/n4T/Oce5Inz/1L7qxtw0g68b5qDCMduAG4TlWPBXBf6FtV9QARyQW+FpFP3L4DgX1UdZm7fZ6qbnJTVMwQkTdV9QYRuUKdZHbhnIQzM7Uf0No95kt33wCgL7AK+Bonn9Dkmr5ZwwjHLALDiOQInPwws3FSarfCKSwCMN2jBACuEpE5wFSc5GK9iM2BwH/VyXq6FvgCOMBz7hWqWo6TqqNrDdyLYcTFLALDiESAK1X145BGkVE4aYe924fjFHzZJSKTcHL6VJUiz3oZ9v/TqCXMIjAM2A408Wx/DFzqptdGRHq7WTLDaYZT/nGXiPTBKdUZoCRwfBhfAae5cYh84CCcJHCGUWfYF4dhOFkky1wXz3M4ef27At+6Adv1wG98jvsIuEREFuKUIJzq2fcUMFdEvlUnPXSAt3FqHszBydr6J1Vd4yoSw6gTLPuoYRhGmmOuIcMwjDTHFIFhGEaaY4rAMAwjzTFFYBiGkeaYIjAMw0hzTBEYhmGkOaYIDMMw0pz/B7ujGRWE/bX8AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time elapsed: 5874.684581756592\n" + ] + } + ], + "source": [ + "import time\n", + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.3" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.166885338964307) q0; ry(-0.562428401027246) q1; ry(0.48893589557941) q2; ry(1.0000212324066) q3; ry(0.997292670049591) q4; ry(0.516642028823444) q5; ry(-0.52976583280007) q6; ry(0.44621090925359) q7; ry(-0.812837886101786) q8; ry(0.00690999905273608) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.732554878640012) q0; ry(1.09250685549609) q1; ry(0.946119425708376) q2; ry(1.22520608932305) q3; ry(-0.256892484303682) q4; ry(0.849713315449811) q5; ry(-0.172935171560596) q6; ry(-0.792282689543016) q7; ry(0.105879168563046) q8; ry(0.451929686680044) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(-0.717816606765696) q0; ry(-0.406893365206504) q1; ry(0.786417140426462) q2; ry(0.715868574401998) q3; ry(1.68834007060239) q4; ry(0.16240900497929) q5; ry(0.021691745395356) q6; ry(-0.45492053378632) q7; ry(1.68422609585115) q8; ry(0.668468430274114) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.166885338964307,-0.562428401027246,0.48893589557941,1.0000212324066,0.997292670049591,0.516642028823444,-0.52976583280007,0.44621090925359,-0.812837886101786,0.00690999905273608,0.732554878640012,1.09250685549609,0.946119425708376,1.22520608932305,-0.256892484303682,0.849713315449811,-0.172935171560596,-0.792282689543016,0.105879168563046,0.451929686680044,-0.717816606765696,-0.406893365206504,0.786417140426462,0.715868574401998,1.68834007060239,0.16240900497929,0.021691745395356,-0.45492053378632,1.68422609585115,0.668468430274114) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "with open(\"best_vqc.qasm\", \"w\") as f:\n", + " f.write(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.algorithms.optimizers import SPSA" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_esu2_spsa300 = VQC(\n", + " feature_map=qc,\n", + " ansatz=EfficientSU2(num_qubits=10, reps=20),\n", + " loss=\"cross_entropy\",\n", + " optimizer=SPSA(maxiter=300),\n", + " quantum_instance=Aer.get_backend('statevector_simulator'),\n", + " callback=callback_graph\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "start = time.time()\n", + "\n", + "objective_func_vals = []\n", + "vqc_esu2_spsa300.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", + "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", + "\n", + "own_elapsed = time.time() - start\n", + "print(\"Time elapsed: \", own_elapsed)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "vqc_esu2_spsa300.score(X_test_list[:50],Y_test[:50])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.266317714019139) q0; ry(1.32035044188513) q1; ry(0.375724625916453) q2; ry(-0.145527578194223) q3; ry(1.24796981173025) q4; ry(-0.3722525242738) q5; ry(0.98731246639232) q6; ry(1.98782341512519) q7; ry(1.66430495324693) q8; ry(0.760045740348774) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.76943425343952) q0; ry(1.54002486179664) q1; ry(1.5166941190635) q2; ry(2.08820456685236) q3; ry(0.502872321522427) q4; ry(0.5226897740692) q5; ry(1.34895736320983) q6; ry(0.17808386546728) q7; ry(1.48787325816064) q8; ry(1.19251464386051) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.63207747410879) q0; ry(0.944742510667842) q1; ry(1.4738548596109) q2; ry(0.0395594736234817) q3; ry(0.160988017972572) q4; ry(-0.139909848244233) q5; ry(0.217661325699283) q6; ry(1.51612158505368) q7; ry(0.709288700436131) q8; ry(2.00665865500557) q9; }\n", + "qreg q[10];\n", + "gate_RealAmplitudes(0.266317714019139,1.32035044188513,0.375724625916453,-0.145527578194223,1.24796981173025,-0.3722525242738,0.98731246639232,1.98782341512519,1.66430495324693,0.760045740348774,1.76943425343952,1.54002486179664,1.5166941190635,2.08820456685236,0.502872321522427,0.5226897740692,1.34895736320983,0.17808386546728,1.48787325816064,1.19251464386051,1.63207747410879,0.944742510667842,1.4738548596109,0.0395594736234817,0.160988017972572,-0.139909848244233,0.217661325699283,1.51612158505368,0.709288700436131,2.00665865500557) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", + "\n" + ] + } + ], + "source": [ + "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", + "print(classifier)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# todo: histogram_to_category\n", + "#def histogram_to_category():\n" + ] + }, + { + "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))" + ] + } + ], + "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.8.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "0ba76706d2c44f5b8079dadbf9eae644": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + }, + "0f9f3e72f13b494c838f67865f9e754a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2c61f71bdc9b4deebcd3e1777dc5766e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_767826b914d54f70bb5157f346d1cb93", + "style": "IPY_MODEL_4879fc589bd94ce5942e7476dd0f334a", + "value": "
Message
" + } + }, + "2c94492e14424196ba309fa46f774c67": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "2f9478e6a8394b069e15a4f0d988626c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "35b3eeee622c40409e47c6f3c1abd7bf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_cb0c25ba5d6241788a20a1d68882bc9f" + ], + "layout": "IPY_MODEL_2c94492e14424196ba309fa46f774c67" + } + }, + "37c62e31818245549375a731d0e461a4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "3c7d3faff2fd4a0db555c4fe70c5c14a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + }, + "4879fc589bd94ce5942e7476dd0f334a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "5e7774ce7df04e92a1cf2d0053476e73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f7e534254a5b416ea439079965a8951a", + "style": "IPY_MODEL_37c62e31818245549375a731d0e461a4", + "value": "
Status
" + } + }, + "6e78fe288f494bc7b7055a1cbf4fd588": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "767826b914d54f70bb5157f346d1cb93": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "7f437d31eeb24f069d386ef17b056adc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "844c4eb47f0246808cae2c1c15e62668": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_dac1a80538854f7cb39e6708480ca33a", + "style": "IPY_MODEL_0f9f3e72f13b494c838f67865f9e754a", + "value": "

Circuit Properties

" + } + }, + "8c97b2f86c544568b21de0bcf766a11a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "900fa225eff145fb8fd961bef128e435": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "9a7a59b64a164e8f949155f062fb8877": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_aebbd7756d974e8c8865b15b5d8cbac9", + "style": "IPY_MODEL_7f437d31eeb24f069d386ef17b056adc", + "value": "
Backend
" + } + }, + "aebbd7756d974e8c8865b15b5d8cbac9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "c776185e67b248f89fb2da4ecea7e64f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_8c97b2f86c544568b21de0bcf766a11a", + "style": "IPY_MODEL_900fa225eff145fb8fd961bef128e435", + "value": "
Job ID
" + } + }, + "cb0c25ba5d6241788a20a1d68882bc9f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_0ba76706d2c44f5b8079dadbf9eae644", + "style": "IPY_MODEL_3c7d3faff2fd4a0db555c4fe70c5c14a" + } + }, + "d4f675734b714276a0ed85daaa6bc674": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_c776185e67b248f89fb2da4ecea7e64f", + "IPY_MODEL_9a7a59b64a164e8f949155f062fb8877", + "IPY_MODEL_5e7774ce7df04e92a1cf2d0053476e73", + "IPY_MODEL_ef5d3c53b9d249fc89769a1ca3c4d5a3", + "IPY_MODEL_2c61f71bdc9b4deebcd3e1777dc5766e" + ], + "layout": "IPY_MODEL_f02d7c03dbc34222b1a387d12fac3125" + } + }, + "dac1a80538854f7cb39e6708480ca33a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "ef5d3c53b9d249fc89769a1ca3c4d5a3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_6e78fe288f494bc7b7055a1cbf4fd588", + "style": "IPY_MODEL_2f9478e6a8394b069e15a4f0d988626c", + "value": "
Queue
" + } + }, + "f02d7c03dbc34222b1a387d12fac3125": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "f7e534254a5b416ea439079965a8951a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/test_qiskit.py b/test_qiskit.py index ed25cd9..2f64c0c 100644 --- a/test_qiskit.py +++ b/test_qiskit.py @@ -15,7 +15,7 @@ if len(sys.argv) > 1: data_path = sys.argv[1] else: - data_path = '.' + data_path = 'data'#'.' #define utility functions From bfefe15c9a3c017142ea555f6aba8296d03e19fe Mon Sep 17 00:00:00 2001 From: "A.C.E07" <73689800+ACE07-Sev@users.noreply.github.com> Date: Fri, 3 Feb 2023 22:39:29 +0800 Subject: [PATCH 2/6] Delete submission_runner.ipynb --- submission/submission_runner.ipynb | 1318 ---------------------------- 1 file changed, 1318 deletions(-) delete mode 100644 submission/submission_runner.ipynb diff --git a/submission/submission_runner.ipynb b/submission/submission_runner.ipynb deleted file mode 100644 index 55a0832..0000000 --- a/submission/submission_runner.ipynb +++ /dev/null @@ -1,1318 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "#pip install tensorflow" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## prepare" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import warnings \n", - "warnings.filterwarnings(\"ignore\")\n", - "\n", - "import numpy as np\n", - "\n", - "# Importing standard Qiskit libraries\n", - "import qiskit\n", - "from typing import Dict, List\n", - "from qiskit import QuantumCircuit, transpile, Aer, execute\n", - "from qiskit.algorithms.optimizers import COBYLA\n", - "from qiskit.tools.jupyter import *\n", - "from qiskit.visualization import *\n", - "from qiskit.providers.aer import QasmSimulator\n", - "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", - "from qiskit.circuit import Parameter\n", - "from qiskit.quantum_info import Statevector\n", - "import pickle\n", - "from matplotlib import pyplot as plt\n", - "\n", - "from tensorflow.keras.datasets import fashion_mnist\n", - "from sklearn.preprocessing import normalize" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "data_shape = X_train[0].shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## normalize" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "784" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "28*28" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2**int(np.ceil(np.log2(X_train[0].size)))" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "def normalize(x):\n", - " \"\"\"\n", - " \"\"\"\n", - " x = x.flatten()\n", - " normalized_vector = x / np.linalg.norm(x)\n", - " total_size = 2**int(np.ceil(np.log2(X_train[0].size)))\n", - " normalized_vector = [*normalized_vector, *np.zeros(total_size-len(normalized_vector))]\n", - " return normalized_vector\n", - "def de_normalize(normalized_vector, x):\n", - " return normalized_vector * np.linalg.norm(x.flatten())" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "normalized_vector = np.array(normalize(X_train[0]))\n", - "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.allclose(\n", - " X_train[0], np.reshape(np.array(de_normalized_vector[:784]),data_shape), rtol=1e-2\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(100, 1024)" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X_train_list = []\n", - "for i in range(100):\n", - " X_train_list.append(normalize(X_train[i]))\n", - "\n", - "np.shape(X_train_list)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(100, 1024)" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X_test_list = []\n", - "for i in range(100):\n", - " X_test_list.append(normalize(X_test[i]))\n", - "np.shape(X_test_list)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## encoding" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "before normalize:\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print('before normalize:')\n", - "display(plt.imshow(X_train[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "after normalize:\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "normalized_vector = normalize(X_train[0])\n", - "#print(normalized_vector)\n", - "print('after normalize:')\n", - "plt.imshow(np.reshape(np.array(normalized_vector[:784]),data_shape))" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import cv2\n", - "\n", - "def amplitude_encode(img, depth=11):\n", - " # Quantize image intensity values into depth levels\n", - " quantized = np.clip(np.round(img / (256 / depth)), 0, depth - 1).astype(np.uint8)\n", - " # Map quantized intensity levels to amplitude values\n", - " amplitudes = quantized * (256 / depth)\n", - " return amplitudes\n", - "\n", - "# Load an image\n", - "img = X_train[0]#cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\n", - "# Do amplitude encoding with a depth of 11\n", - "encoded = amplitude_encode(img, depth=11)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "'numpy.float64' object cannot be interpreted as an integer", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[29], line 26\u001b[0m\n\u001b[0;32m 23\u001b[0m img \u001b[38;5;241m=\u001b[39m X_train[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;66;03m#.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\u001b[39;00m\n\u001b[0;32m 25\u001b[0m \u001b[38;5;66;03m# Cut the image into parts\u001b[39;00m\n\u001b[1;32m---> 26\u001b[0m parts \u001b[38;5;241m=\u001b[39m [img[i:i\u001b[38;5;241m+\u001b[39mpart_size, j:j\u001b[38;5;241m+\u001b[39mpart_size] \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mimg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpart_size\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 27\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m j \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m0\u001b[39m, img\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], part_size)]\n\u001b[0;32m 29\u001b[0m \u001b[38;5;66;03m# Initialize the quantum circuit and registers\u001b[39;00m\n\u001b[0;32m 30\u001b[0m qr \u001b[38;5;241m=\u001b[39m QuantumRegister(n_qubits)\n", - "\u001b[1;31mTypeError\u001b[0m: 'numpy.float64' object cannot be interpreted as an integer" - ] - } - ], - "source": [ - "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister\n", - "from qiskit import execute, Aer\n", - "import numpy as np\n", - "\n", - "# Function to angle encode a part of the image\n", - "def angle_encode_part(part, qc, qr, cr, n_qubits):\n", - " # Convert the part of the image to an angle value in radians\n", - " angle = 2 * np.pi * part / 256\n", - " # Apply the angle encoding using n_qubits qubits\n", - " for i in range(n_qubits):\n", - " qc.ry(angle, qr[i])\n", - " # Measure the qubits\n", - " for i in range(n_qubits):\n", - " qc.measure(qr[i], cr[i])\n", - "\n", - "# Define the number of qubits to use for each part\n", - "n_qubits = 4\n", - "\n", - "# Define the size of the parts\n", - "part_size = 28 // np.sqrt(n_qubits)\n", - "\n", - "# Load the image\n", - "img = X_train[0]#.imread('image.jpg', cv2.IMREAD_GRAYSCALE)\n", - "\n", - "# Cut the image into parts\n", - "parts = [img[i:i+part_size, j:j+part_size] for i in range(0, img.shape[0], part_size)\n", - " for j in range(0, img.shape[1], part_size)]\n", - "\n", - "# Initialize the quantum circuit and registers\n", - "qr = QuantumRegister(n_qubits)\n", - "cr = ClassicalRegister(n_qubits)\n", - "qc = QuantumCircuit(qr, cr)\n", - "\n", - "# Loop over each part and apply angle encoding\n", - "for part in parts:\n", - " angle_encode_part(part, qc, qr, cr, n_qubits)\n", - "\n", - "# Execute the circuit on a simulator\n", - "backend = Aer.get_backend('qasm_simulator')\n", - "job = execute(qc, backend, shots=1)\n", - "result = job.result()\n", - "\n", - "# Collect the results\n", - "encoded_parts = [int(''.join([str(x) for x in result.get_counts(i).keys()]), 2)\n", - " for i in range(len(parts))]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "#scaler.inverse_transform(scaler.transform(X_train[0]))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "state = normalized_vector\n", - "n = 10\n", - "qc = RawFeatureVector(2**n)\n", - "#qc = qc.bind_parameters(state)\n", - "#qc.measure_all()\n", - "\n", - "#qc_ = qc.decompose(reps=20)\n", - "#print(qc_.depth())\n", - "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", - "## qc.decompose(reps = 9).draw()\n", - "qc.num_parameters" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## test encoding & decoding (1st task)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import BasicAer\n", - "\n", - "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circ, backend,optimization_level=0,shots=1024)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\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" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "#histogram = simulate(qc.bind_parameters(normalized_vector))\n", - "#print(histogram)\n", - "#new_histogram = {}\n", - "#\n", - "#for key in range(len(qc.parameters)):\n", - "# if key in histogram:\n", - "# new_histogram[key] = histogram[key]\n", - "# else:\n", - "# new_histogram[key] = 0\n", - "#print(new_histogram)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "#import matplotlib.pyplot as plt\n", - "#after_ = np.array(list(new_histogram.values())[:784])\n", - "#plt.imshow(np.reshape(after_,data_shape))" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "#de_normalized_vector = de_normalize(after_,X_train[0])\n", - "#plt.imshow(np.reshape(after_,data_shape))" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.circuit.library import StatePreparation\n", - "def encode_qiskit(x,num_qubit=10):\n", - " normalized_vector = normalize(x)\n", - " qc = RawFeatureVector(2**num_qubit) #\n", - " qc = qc.bind_parameters(normalized_vector)\n", - " return qc\n", - "\n", - "def decode(histogram,data):\n", - " new_histogram = {}\n", - " for key in range(len(qc.parameters)):\n", - " if key in histogram:\n", - " new_histogram[key] = histogram[key]\n", - " else:\n", - " new_histogram[key] = 0\n", - " #print(new_histogram)\n", - " after_ = np.array(list(new_histogram.values()))\n", - " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 2.53682360e-04 0.00000000e+00 0.00000000e+00 4.28723188e-02\n", - " 1.35187330e+00 0.00000000e+00 0.00000000e+00 2.53682360e-04\n", - " 4.05891776e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 2.53682360e-04 2.53682360e-04 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 2.28314124e-03 0.00000000e+00 3.28772339e-01 4.69210893e+00\n", - " 4.09164279e+00 9.75154992e-01 7.39737762e-01 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 2.53682360e-04 2.28314124e-03\n", - " 4.05891776e-03 0.00000000e+00 0.00000000e+00 2.28314124e-03]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 9.13256496e-03 0.00000000e+00 2.63931127e+00 1.05572451e+01\n", - " 7.85806478e+00 4.55512046e+00 5.26035742e+00 3.83796043e+00\n", - " 1.34197968e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 3.65302598e-02 2.53682360e-02 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 6.09471870e+00 1.41290927e+01\n", - " 1.08700354e+01 8.03767190e+00 2.90440934e+00 6.17361391e+00\n", - " 6.57570045e+00 3.01400012e+00 1.03908295e+00 1.34197968e-01\n", - " 1.50408271e+00 4.28723188e+00 1.31508935e+00 5.70785310e-02]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 2.53682360e-04\n", - " 0.00000000e+00 1.20778172e+00 1.08700354e+01 1.26153701e+01\n", - " 1.20560005e+01 1.18358042e+01 1.18358042e+01 6.74008662e+00\n", - " 4.09164279e+00 3.71416343e+00 3.77580825e+00 5.40749319e+00\n", - " 5.04345900e+00 1.96451620e+00 7.50493894e+00 1.10504036e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 2.53682360e-04 2.53682360e-04 2.53682360e-04\n", - " 0.00000000e+00 1.01472944e+01 1.36541993e+01 1.36541993e+01\n", - " 1.37721616e+01 1.33033566e+01 1.26153701e+01 1.26153701e+01\n", - " 1.17264671e+01 1.15093150e+01 6.82304076e+00 4.09164279e+00\n", - " 3.83796043e+00 9.74546154e+00 1.33033566e+01 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 8.49556856e+00 1.28426695e+01 1.18358042e+01\n", - " 1.26153701e+01 1.31874238e+01 1.40096083e+01 1.30719983e+01\n", - " 1.27287661e+01 1.25024814e+01 1.27287661e+01 1.23901001e+01\n", - " 1.26153701e+01 1.52272837e+01 7.59245935e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 9.44941423e+00 1.31874238e+01 1.20560005e+01\n", - " 1.15093150e+01 9.94536324e+00 8.21930847e+00 1.14015000e+01\n", - " 1.11873921e+01 1.12941924e+01 1.15093150e+01 1.26153701e+01\n", - " 1.22782262e+01 1.49796897e+01 1.03512550e+01 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 2.53682360e-04 2.28314124e-03 0.00000000e+00\n", - " 3.65302598e-02 1.21668597e+01 1.22782262e+01 1.14015000e+01\n", - " 1.20560005e+01 9.35174652e+00 7.24542189e+00 1.30719983e+01\n", - " 1.09753136e+01 1.20560005e+01 1.27287661e+01 1.14015000e+01\n", - " 1.29570802e+01 9.84515871e+00 1.10810992e+01 6.85957102e-01]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 9.13256496e-03 0.00000000e+00\n", - " 2.48634081e+00 1.51032330e+01 1.25024814e+01 1.22782262e+01\n", - " 1.20560005e+01 1.04539964e+01 9.94536324e+00 1.23901001e+01\n", - " 1.17264671e+01 1.15093150e+01 1.25024814e+01 1.22782262e+01\n", - " 1.52272837e+01 3.59239590e+00 7.07494734e+00 7.95547881e-01]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 4.05891776e-03 0.00000000e+00 0.00000000e+00\n", - " 7.67389139e-01 1.41290927e+01 1.31874238e+01 1.34197968e+01\n", - " 1.31874238e+01 1.46121039e+01 1.36541993e+01 1.15093150e+01\n", - " 1.20560005e+01 1.26153701e+01 1.38906313e+01 1.19456487e+01\n", - " 1.19456487e+01 1.10810992e+01 2.14716750e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 2.53682360e-04 4.05891776e-03\n", - " 9.13256496e-03 1.24304356e-02 1.01472944e-03 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.42490845e+01 1.29570802e+01 1.19456487e+01 1.26153701e+01\n", - " 1.25024814e+01 1.21668597e+01 1.25024814e+01 1.23901001e+01\n", - " 1.18358042e+01 1.26153701e+01 1.33033566e+01 1.17264671e+01\n", - " 1.20560005e+01 1.64956955e+01 1.50408271e+00 0.00000000e+00]\n", - " [0.00000000e+00 2.28314124e-03 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 9.75154992e-01 5.33367162e+00 1.05572451e+01\n", - " 1.31874238e+01 1.08700354e+01 1.15093150e+01 1.23901001e+01\n", - " 1.20560005e+01 1.09753136e+01 1.12941924e+01 1.20560005e+01\n", - " 1.27287661e+01 1.26153701e+01 1.21668597e+01 1.17264671e+01\n", - " 1.27287661e+01 1.51032330e+01 6.41334374e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 8.21930847e-02 4.91129049e-01 1.70576019e+00 2.90440934e+00\n", - " 9.06178758e+00 1.31874238e+01 1.22782262e+01 1.25024814e+01\n", - " 1.19456487e+01 1.29570802e+01 1.01472944e+01 1.06610012e+01\n", - " 1.12941924e+01 1.34197968e+01 1.27287661e+01 1.38906313e+01\n", - " 7.85806478e+00 8.96614933e+00 1.58551475e+01 1.56024799e+01\n", - " 1.37721616e+01 1.43695836e+01 1.17264671e+01 0.00000000e+00]\n", - " [0.00000000e+00 8.24213988e-01 8.87101845e+00 1.09753136e+01\n", - " 1.27287661e+01 1.23901001e+01 1.27287661e+01 1.09753136e+01\n", - " 1.05572451e+01 1.16176374e+01 1.09753136e+01 1.10810992e+01\n", - " 1.01472944e+01 6.41334374e+00 1.52272837e+01 9.44941423e+00\n", - " 1.07652646e+01 1.26153701e+01 1.64956955e+01 1.64956955e+01\n", - " 1.23901001e+01 1.38906313e+01 1.23901001e+01 1.12941924e+01\n", - " 1.22782262e+01 1.36541993e+01 1.53518417e+01 0.00000000e+00]\n", - " [2.28314124e-03 1.03512550e+01 1.31874238e+01 1.27287661e+01\n", - " 1.23901001e+01 1.12941924e+01 1.12941924e+01 1.16176374e+01\n", - " 1.06610012e+01 1.06610012e+01 1.06610012e+01 1.22782262e+01\n", - " 1.46121039e+01 1.62356710e+00 5.70785310e+00 1.64956955e+01\n", - " 1.33033566e+01 1.23901001e+01 8.96614933e+00 6.01633085e+00\n", - " 9.25458618e+00 1.11873921e+01 1.05572451e+01 1.10810992e+01\n", - " 1.25024814e+01 1.31874238e+01 1.28426695e+01 0.00000000e+00]\n", - " [2.43636539e+00 1.37721616e+01 9.94536324e+00 1.11873921e+01\n", - " 1.25024814e+01 1.33033566e+01 1.33033566e+01 1.38906313e+01\n", - " 1.57285600e+01 1.22782262e+01 9.54758930e+00 1.17264671e+01\n", - " 1.19456487e+01 1.47341252e+01 1.07180797e+00 1.35187330e+00\n", - " 2.85037500e+00 3.47265783e+00 7.15993093e+00 1.21668597e+01\n", - " 1.23901001e+01 1.17264671e+01 1.19456487e+01 1.26153701e+01\n", - " 1.26153701e+01 1.27287661e+01 1.33033566e+01 2.13346865e-01]\n", - " [1.42696328e+00 1.05572451e+01 1.14015000e+01 1.05572451e+01\n", - " 9.44941423e+00 1.06610012e+01 1.12941924e+01 1.28426695e+01\n", - " 1.18358042e+01 8.68227877e+00 9.84515871e+00 1.07652646e+01\n", - " 9.94536324e+00 1.15093150e+01 1.46121039e+01 9.64627174e+00\n", - " 1.30719983e+01 1.52272837e+01 1.44905901e+01 1.26153701e+01\n", - " 1.20560005e+01 1.14015000e+01 1.10810992e+01 1.25024814e+01\n", - " 1.22782262e+01 1.23901001e+01 1.34197968e+01 1.13878011e+00]\n", - " [5.84484158e-01 1.04539964e+01 8.49556856e+00 9.54758930e+00\n", - " 1.15093150e+01 9.84515871e+00 8.68227877e+00 9.15793320e+00\n", - " 9.54758930e+00 9.35174652e+00 1.03512550e+01 1.16176374e+01\n", - " 1.21668597e+01 1.23901001e+01 1.22782262e+01 1.41290927e+01\n", - " 1.28426695e+01 1.18358042e+01 1.00460751e+01 1.07652646e+01\n", - " 8.77639493e+00 8.31088780e+00 7.94761466e+00 7.50493894e+00\n", - " 8.31088780e+00 1.06610012e+01 1.07652646e+01 3.35494921e+00]\n", - " [0.00000000e+00 3.77580825e+00 1.21668597e+01 9.44941423e+00\n", - " 8.12823650e+00 7.41792589e+00 8.49556856e+00 9.74546154e+00\n", - " 1.05572451e+01 1.11873921e+01 1.15093150e+01 1.08700354e+01\n", - " 1.12941924e+01 1.11873921e+01 1.01472944e+01 9.74546154e+00\n", - " 9.54758930e+00 9.25458618e+00 9.64627174e+00 9.25458618e+00\n", - " 9.94536324e+00 9.35174652e+00 7.85806478e+00 6.17361391e+00\n", - " 7.07494734e+00 7.94761466e+00 1.11873921e+01 2.14716750e+00]\n", - " [0.00000000e+00 0.00000000e+00 1.38916460e+00 9.06178758e+00\n", - " 1.14015000e+01 9.25458618e+00 7.76902228e+00 7.50493894e+00\n", - " 7.76902228e+00 8.31088780e+00 8.68227877e+00 8.96614933e+00\n", - " 9.06178758e+00 8.96614933e+00 9.44941423e+00 9.94536324e+00\n", - " 1.05572451e+01 1.10810992e+01 1.11873921e+01 1.11873921e+01\n", - " 1.12941924e+01 8.96614933e+00 8.96614933e+00 9.54758930e+00\n", - " 9.35174652e+00 1.18358042e+01 7.33142021e+00 0.00000000e+00]\n", - " [1.01472944e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.10504036e+00 1.01472944e+01 1.25024814e+01 1.42490845e+01\n", - " 1.44905901e+01 1.48566537e+01 1.53518417e+01 1.49796897e+01\n", - " 1.51032330e+01 1.23901001e+01 1.22782262e+01 9.44941423e+00\n", - " 9.25458618e+00 8.12823650e+00 8.40297449e+00 8.40297449e+00\n", - " 8.31088780e+00 7.85806478e+00 6.99047111e+00 7.15993093e+00\n", - " 2.48634081e+00 8.53387459e-01 0.00000000e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 4.05891776e-01\n", - " 9.43952062e-01 4.91129049e-01 1.31508935e+00 4.26440047e-01\n", - " 3.10760891e-01 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", - " [0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]]\n", - "-17758.718677708395\n" - ] - } - ], - "source": [ - "#grade part1\n", - "#from part1 import encode_qiskit,decode\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "dataset = X_train[:1]\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_qiskit(data)\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #reconstruct \n", - " image_re=decode(histogram,data)\n", - " print(image_re)\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(np.asarray(data),np.asarray(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))\n", - "# score should be between 0 and 1" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "def multiply_by_51(lst):\n", - " new_list = []\n", - " for element in lst:\n", - " new_list.append(element * 51)\n", - " return new_list" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "list(list(de_normalize(image_re,data)[:784]))\n", - "plt.imshow(np.reshape(multiply_by_51(list(de_normalize(image_re,data)[:784])),data_shape))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## train classifier circuit (2nd task)\n", - "is there a way to get the best classifier? \n", - "\n", - "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", - "\n", - "reference: \n", - "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", - "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", - "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.display import clear_output\n", - "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": 15, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit_machine_learning.algorithms.classifiers import VQC\n", - "from qiskit.algorithms.optimizers import SPSA\n", - "vqc = VQC(\n", - " feature_map=qc,\n", - " ansatz=ansatz,\n", - " loss=\"cross_entropy\",\n", - " optimizer=COBYLA(maxiter=100),\n", - " quantum_instance=Aer.get_backend('statevector_simulator'),\n", - " callback=callback_graph\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time elapsed: 1189.4153316020966\n" - ] - } - ], - "source": [ - "import time\n", - "start = time.time()\n", - "\n", - "objective_func_vals = []\n", - "vqc.fit(np.array(X_train_list),np.array(Y_train[:100]))\n", - "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", - "\n", - "own_elapsed = time.time() - start\n", - "print(\"Time elapsed: \", own_elapsed)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.4" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "vqc.score(X_test_list[:50],Y_test[:50])" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "gate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23,param24,param25,param26,param27,param28,param29) q0,q1,q2,q3,q4,q5,q6,q7,q8,q9 { ry(0.266317714019139) q0; ry(1.32035044188513) q1; ry(0.375724625916453) q2; ry(-0.145527578194223) q3; ry(1.24796981173025) q4; ry(-0.3722525242738) q5; ry(0.98731246639232) q6; ry(1.98782341512519) q7; ry(1.66430495324693) q8; ry(0.760045740348774) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.76943425343952) q0; ry(1.54002486179664) q1; ry(1.5166941190635) q2; ry(2.08820456685236) q3; ry(0.502872321522427) q4; ry(0.5226897740692) q5; ry(1.34895736320983) q6; ry(0.17808386546728) q7; ry(1.48787325816064) q8; ry(1.19251464386051) q9; cx q8,q9; cx q7,q8; cx q6,q7; cx q5,q6; cx q4,q5; cx q3,q4; cx q2,q3; cx q1,q2; cx q0,q1; ry(1.63207747410879) q0; ry(0.944742510667842) q1; ry(1.4738548596109) q2; ry(0.0395594736234817) q3; ry(0.160988017972572) q4; ry(-0.139909848244233) q5; ry(0.217661325699283) q6; ry(1.51612158505368) q7; ry(0.709288700436131) q8; ry(2.00665865500557) q9; }\n", - "qreg q[10];\n", - "gate_RealAmplitudes(0.266317714019139,1.32035044188513,0.375724625916453,-0.145527578194223,1.24796981173025,-0.3722525242738,0.98731246639232,1.98782341512519,1.66430495324693,0.760045740348774,1.76943425343952,1.54002486179664,1.5166941190635,2.08820456685236,0.502872321522427,0.5226897740692,1.34895736320983,0.17808386546728,1.48787325816064,1.19251464386051,1.63207747410879,0.944742510667842,1.4738548596109,0.0395594736234817,0.160988017972572,-0.139909848244233,0.217661325699283,1.51612158505368,0.709288700436131,2.00665865500557) q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8],q[9];\n", - "\n" - ] - } - ], - "source": [ - "classifier = ansatz.bind_parameters(vqc._fit_result.x).qasm()\n", - "print(classifier)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# todo: histogram_to_category\n", - "#def histogram_to_category():\n" - ] - }, - { - "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))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "ionq", - "language": "python", - "name": "ionq" - }, - "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.10.9" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "133691b27fa14898ae18af0787aeaef9": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_325f0396d7b9410bba8021bbe35f813a", - "style": "IPY_MODEL_5488374837ae4a9284ee055d8e6dc4ca", - "value": "
Backend
" - } - }, - "14a021df54ea41dd800c6d49a1fb3ba9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "14b920e77c4046b2b739ce5e65ba6c87": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_a42326a6516c48c9b45a061832e1b9e4", - "IPY_MODEL_133691b27fa14898ae18af0787aeaef9", - "IPY_MODEL_d36e5003b5bb4905b2f34cc06dab577e", - "IPY_MODEL_8b5e3e1c7c8b478eadaddcebb1bab545", - "IPY_MODEL_29e0bc1980f04ee5a4de1c3353ca43e1" - ], - "layout": "IPY_MODEL_95dbd7627f214404917e790abc4a0bac" - } - }, - "1a8a97e4934d4946b30b1b3ea93a6488": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "190px" - } - }, - "29e0bc1980f04ee5a4de1c3353ca43e1": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_14a021df54ea41dd800c6d49a1fb3ba9", - "style": "IPY_MODEL_7cc1a68d44ca46bdaf3b815627f44cb2", - "value": "
Message
" - } - }, - "325f0396d7b9410bba8021bbe35f813a": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "145px" - } - }, - "4de8f8e67ba84e68acc93c41fb388ea3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a14371b37a3941f991ce693be9cd4d38", - "style": "IPY_MODEL_5be42b0bad7e42a99d879056ebabf46d", - "value": "

Circuit Properties

" - } - }, - "5488374837ae4a9284ee055d8e6dc4ca": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "5be42b0bad7e42a99d879056ebabf46d": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "7695b5f41549481193e03d22f11ad7be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "7cc1a68d44ca46bdaf3b815627f44cb2": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "8b5e3e1c7c8b478eadaddcebb1bab545": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_d04bd44ae10f4782855b04d120889b06", - "style": "IPY_MODEL_c6c8b591acda4e488e8afb052f4fe29b", - "value": "
Queue
" - } - }, - "95dbd7627f214404917e790abc4a0bac": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "margin": "0px 0px 0px 37px", - "width": "600px" - } - }, - "a14371b37a3941f991ce693be9cd4d38": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "margin": "0px 0px 10px 0px" - } - }, - "a42326a6516c48c9b45a061832e1b9e4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_1a8a97e4934d4946b30b1b3ea93a6488", - "style": "IPY_MODEL_e09458876777468d80ebae8aaa409834", - "value": "
Job ID
" - } - }, - "c6c8b591acda4e488e8afb052f4fe29b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "cc709643ef9d420387ecaf1e16125ec3": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "GridBoxModel", - "state": { - "children": [ - "IPY_MODEL_f2c63bb964454e8f8d97f39429d02343" - ], - "layout": "IPY_MODEL_db133fac447c42cba07b68d7bf884952" - } - }, - "d04bd44ae10f4782855b04d120889b06": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "70px" - } - }, - "d36e5003b5bb4905b2f34cc06dab577e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_fb539075b7f042f9bdd58552f7479014", - "style": "IPY_MODEL_7695b5f41549481193e03d22f11ad7be", - "value": "
Status
" - } - }, - "db133fac447c42cba07b68d7bf884952": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "grid_template_areas": "\n \". . . . right \"\n ", - "grid_template_columns": "20% 20% 20% 20% 20%", - "width": "100%" - } - }, - "e09458876777468d80ebae8aaa409834": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "f1ebeebc10804474ab5638703d2165ee": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - }, - "f2c63bb964454e8f8d97f39429d02343": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "button_style": "primary", - "description": "Clear", - "layout": "IPY_MODEL_fd52f04fbda04dcdbb42cc4a48af47bc", - "style": "IPY_MODEL_f1ebeebc10804474ab5638703d2165ee" - } - }, - "fb539075b7f042f9bdd58552f7479014": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "95px" - } - }, - "fd52f04fbda04dcdbb42cc4a48af47bc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "grid_area": "right", - "padding": "0px 0px 0px 0px", - "width": "70px" - } - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 7b127b1c928e22390482da8ba6d42e6bd1b6ae73 Mon Sep 17 00:00:00 2001 From: "A.C.E07" <73689800+ACE07-Sev@users.noreply.github.com> Date: Fri, 3 Feb 2023 22:39:57 +0800 Subject: [PATCH 3/6] Add files via upload --- submission/Current Submission (4).ipynb | 1348 +++++++++++++++++++++++ 1 file changed, 1348 insertions(+) create mode 100644 submission/Current Submission (4).ipynb diff --git a/submission/Current Submission (4).ipynb b/submission/Current Submission (4).ipynb new file mode 100644 index 0000000..5a05ad7 --- /dev/null +++ b/submission/Current Submission (4).ipynb @@ -0,0 +1,1348 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5393e245", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7155034-fac6-4159-8aeb-5f150c0ac927", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e019f2e1-ad01-49a3-b3f7-9477c7458095", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e750f82-596d-4031-8035-657f72eaef28", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install qiskit" + ] + }, + { + "cell_type": "markdown", + "id": "5ae1c772", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "73194ae9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All packages imported successfully!\n" + ] + } + ], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "import qiskit\n", + "from typing import Dict, List\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "from qiskit.quantum_info.operators import Operator\n", + "\n", + "import pickle\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize\n", + "\n", + "print(\"All packages imported successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "876e03c7", + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "972efc8b", + "metadata": {}, + "outputs": [], + "source": [ + "data_shape = X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "id": "d09fdbb5", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "901e43e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "29e4784b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6e3a0634", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " normalized_vector = [*normalized_vector]\n", + "\n", + " return normalized_vector\n", + "\n", + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6dabde13", + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f2da7bbb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(\n", + " X_train[0], np.reshape(np.array(de_normalized_vector[:784]),data_shape), rtol=1e-2\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "54703421", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 784)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2ad71107", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 784)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "id": "0638fa04", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cb2bd8e0", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAUFElEQVR4nO3da2yc1ZkH8P8z4/ElzjiJk+CE4BIuoZDCEqhJuIlSKDREVQOli4gQC1K0QbvQbbt8ANGuyn5ZIbSA0LLbXQNZwqpQtSoIiiIKmEsWKGlMSHPdEEgcEuPYTkxsx/HYc3n2g1+oCT7Pa+adGzn/n2R5PM+cmeMZ//3OzJlzjqgqiOj4Fyt3B4ioNBh2Ik8w7ESeYNiJPMGwE3miqpQ3Vi01Wov6Ut4kkVdSGMKojshEtUhhF5GlAB4GEAfwmKreZ12+FvVYIldGuUkiMqzXNmct76fxIhIH8O8ArgGwEMAKEVmY7/URUXFFec2+GMAHqrpbVUcB/BrA8sJ0i4gKLUrY5wHYN+7n/cF5nyMiq0SkXUTa0xiJcHNEFEXR341X1VZVbVHVlgRqin1zROQQJeydAJrH/XxScB4RVaAoYd8AYIGInCIi1QBuBPB8YbpFRIWW99CbqmZE5A4Af8DY0NtqVd1WsJ4RUUFFGmdX1bUA1haoL0RURPy4LJEnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeaKkS0lTGciEqwr/RcSNPeMzG836J989w1lreOqdSLcd9rtJVcJZ0/RotNuOKuxxseT5mPHITuQJhp3IEww7kScYdiJPMOxEnmDYiTzBsBN5guPsxzmJx826ZjJmPbbI3qtzx21T7fbD7lpiaLHZtmo4Z9YTL7Wb9Uhj6WFj+CH3K8Q+jkbpm1QZsTUeTh7ZiTzBsBN5gmEn8gTDTuQJhp3IEww7kScYdiJPcJz9OGeOySJ8nH3fd6eb9Zsu+l+z/lbvqc7a3po5ZlutM8uo+s5FZv2M/+h01jIdH9lXHjJnPOx+CxOfMcNdzGbNttmBAXfR6HaksItIB4BBAFkAGVVtiXJ9RFQ8hTiyf1tVDxbgeoioiPiancgTUcOuAF4SkXdFZNVEFxCRVSLSLiLtaYxEvDkiylfUp/GXqmqniJwA4GUR+T9VXTf+AqraCqAVABqkMdrqhkSUt0hHdlXtDL73AHgWgD2NiYjKJu+wi0i9iCQ/PQ3gagBbC9UxIiqsKE/jmwA8K2PzfqsAPKWqLxakV1QwuVQqUvvR846Y9R9Os+eU18bSztobMXu+euerzWY9+1d23/Y+mHTWcu9dbLadudUe6254r8usH7xsnlnv/ab7FW1TyHL6M1750FmTPnek8w67qu4GcG6+7YmotDj0RuQJhp3IEww7kScYdiJPMOxEnhCNuGXvl9EgjbpErizZ7XnDWvY45PE9csOFZv2an79u1s+q/disD+ZqnbVRjfYBzkd2fsusD+2e5qzFRkO2TA4pZ5vspaA1bR9HZ2x0/+51y7vNtvLobGdtc9vDONK3b8Le88hO5AmGncgTDDuRJxh2Ik8w7ESeYNiJPMGwE3mC4+yVIGR74EhCHt+z37X/3/9ghj2FNUzcWNt4SKvNtoez9ZFuuzfjnuKaDhnjf2yXPQX2iDGGDwCxjP2YXvXt95y16xs3mG3vP+0cZ229tmFA+zjOTuQzhp3IEww7kScYdiJPMOxEnmDYiTzBsBN5gls2V4ISftbhWLuOnGDWDzVMNesHMtPN+sy4e7nnZGzYbDs/Ye8X2pt1j6MDQDzhXqp6VONm23/+xu/NeuqshFlPiL0U9cXGOgB/vf1vzLb12G3WXXhkJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wXF2z82usbc9rhX3lssAUC0Zs/5xeoaztmv462bb9wfszwAsbdpm1tPGWLo1zx4IHyc/MfGJWU+pPQ5v3auXNNnj6JvMqlvokV1EVotIj4hsHXdeo4i8LCK7gu/uR5SIKsJknsY/AWDpMefdDaBNVRcAaAt+JqIKFhp2VV0HoO+Ys5cDWBOcXgPg2sJ2i4gKLd/X7E2q2hWcPgCgyXVBEVkFYBUA1GJKnjdHRFFFfjdex1asdL7boaqtqtqiqi0J1ES9OSLKU75h7xaRuQAQfO8pXJeIqBjyDfvzAG4JTt8C4LnCdIeIiiX0NbuIPA3gcgCzRGQ/gF8AuA/Ab0RkJYC9AG4oZiePeyHrxkvcnnutGfdYd3yGPSr6relbzHpvtsGsH87a78NMjx911gYz7r3bAaBv2L7uM2u6zPrGo/OdtdnV9ji51W8A6BidZdYX1Bww6/d3u/dPaK499v3wz8tceZmzpuv/6KyFhl1VVzhK3O2B6CuEH5cl8gTDTuQJhp3IEww7kScYdiJPcIprJQhZSlqq7IfJGnrbt/Iss+0VU+wlk99OzTPrs6sGzbo1zXRuTb/ZNtmUMuthw36NVe7pu4PZOrPtlNiIWQ/7vc+vtpfB/ukr5ztrybMPmW0bEsYx2hjF5ZGdyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEx9krgCSqzXouZY83W2ZtGTXrB7P2ksfTY/ZUz+qQJZetrZEvbtxjtu0NGQvfOHyKWU/G3VtCz47Z4+TNCXuse0uq2ayvHTrdrK/83ivO2tOtV5ltq19821kTdT9ePLITeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ74ao2zG0suS5U9XizxkP9rMbueSxnzm3P2WHMYTdtj4VE8/F+PmPV9melm/UDaroctuZw1Jli/MzzNbFsbs7eLnl01YNYHcvY4vWUwZy9zbc3TB8L7ftfMXc7aM/3fMdvmi0d2Ik8w7ESeYNiJPMGwE3mCYSfyBMNO5AmGncgTFTXOHmV99LCxarWHPctqePlis77vWnsc/6bz/uSsHcgkzbbvGdsaA8A0Y044ANSHrK+eUvfnHz4etbeTDhurttaFB4ATjHH4rNrHuc603bcwYZ8/2J8x1rT/vj3XfvqTeXUp/MguIqtFpEdEto47714R6RSRTcHXsvxunohKZTJP458AsHSC8x9S1UXB19rCdouICi007Kq6DkBfCfpCREUU5Q26O0Rkc/A03/kCR0RWiUi7iLSnYb++I6LiyTfsvwRwGoBFALoAPOC6oKq2qmqLqrYkUJPnzRFRVHmFXVW7VTWrqjkAjwKw304morLLK+wiMnfcj9cB2Oq6LBFVhtBxdhF5GsDlAGaJyH4AvwBwuYgsAqAAOgDcVojOWOPoUVXNnWPW06c0mfW+s9x7gR+dY2yKDWDRsh1m/dam/zbrvdkGs54QY3/29Eyz7XlTOsz6q/0LzfrBqqlm3Rqnv7jePacbAA7n7P3XT6z6xKzf9cEPnbWmKfZY9mMn2wNMac2Z9Z1p+yVrf849H/4fFr5mtn0Ws826S2jYVXXFBGc/ntetEVHZ8OOyRJ5g2Ik8wbATeYJhJ/IEw07kiYqa4jpyzQVm/YSf7XbWFjXsN9surHvTrKdy9lLU1nTL7cPzzLZHc/aWzLtG7WHB/ow9BBUX9zBQz6g9xfWBPfayxW2L/9Os//zjieZI/UWsTp21Q1l72O76qfZS0YD9mN32tXXO2qnVPWbbF4bmmvWPQ6bANiX6zfr8RK+z9oPk+2bbfIfeeGQn8gTDTuQJhp3IEww7kScYdiJPMOxEnmDYiTxR2nF2sZeLXvIvG8zmVya3OWtH1Z5SGDaOHjZuaplWZS8bPJK27+aetD2FNcwZNQectesaNplt1z2yxKxfmvqRWf/wCnt6btuweypnb8b+vW/cc4VZ3/hRs1m/cP4eZ+2cZKfZNuyzDcl4yqxb044BYCjn/nt9J2V//iBfPLITeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ4QVfd840Krm9Osp938j8566+3/ZrZ/qu9CZ6251t6O7uTqg2Z9Ztze/teSjNljrl9P2GOuLwydZNZfP3ymWf9mssNZS4i93fPlUz4w67f+9E6znqm1l9EemO8+nmTq7b+9hnMPmfUfnf6qWa82fvfDWXscPex+C9uSOYy1BkEyZm+T/cCy65y1P3Y8gf7hrgkfFB7ZiTzBsBN5gmEn8gTDTuQJhp3IEww7kScYdiJPlHQ+eywNTOl2jy++MLDIbH9qnXut7YNpe330Pxw5x6yfVGdv/2ttPXy6MZ8cADalppv1F3u/YdZPrLPXT+9OT3PWDqXrzbZHjXnVAPD4Qw+a9Qe67XXnr2vc6KydW22Pox/O2cei7SHr7Q/map21lNrrG/SHjMMnjb8HAEirHa24seXz9Jg9hj9wjnsb7my3+3ZDj+wi0iwir4nIdhHZJiI/Ds5vFJGXRWRX8D3/1R+IqOgm8zQ+A+BOVV0I4EIAt4vIQgB3A2hT1QUA2oKfiahChYZdVbtUdWNwehDADgDzACwHsCa42BoA1xapj0RUAF/qDToRmQ/gPADrATSpaldQOgCgydFmlYi0i0h7ZmQoSl+JKIJJh11EpgL4HYCfqOrn3jHSsdk0E85qUNVWVW1R1ZaqGvvNIiIqnkmFXUQSGAv6r1T1meDsbhGZG9TnArC3xSSisgodehMRAfA4gB2qOn4c5nkAtwC4L/j+XNh1xUdzSO4bcdZzak+XfPWge6pnU+2g2XZRcp9Z33nUHsbZMnyis7ax6mtm27q4e7tnAJhWbU+Rra9y32cAMCvh/t1PqbH/B1vTQAFgQ8r+3f5u9utm/aOMe5Dm90NnmG23H3Xf5wAwI2QJ7y0D7vZHM/Y22iNZOxqpjD2UO63GfkwvaNzrrO2EvV1077nGtOG33O0mM85+CYCbAWwRkU3BefdgLOS/EZGVAPYCuGES10VEZRIadlV9E4DrkHtlYbtDRMXCj8sSeYJhJ/IEw07kCYadyBMMO5EnSrtl85FhxN54z1n+7UuXmM3/aflvnbU3QpZbfuGAPS46MGpP9Zw9xf1R3wZjnBsAGhP2x4TDtnyuDdn+95OM+5OJIzF7KmfWOdAy5sCIe/osALyVW2DW0zn3ls0jRg0I/3xC3+gss35iXb+zNphxT38FgI7BRrN+sN/eVjk1xY7Wm9nTnLWlc9xbkwNAXY/7MYsZfyo8shN5gmEn8gTDTuQJhp3IEww7kScYdiJPMOxEnijpls0N0qhLJP+Jcv03ubdsPvXvd5ptF0/fY9Y3Dtjztj8yxl3TIUseJ2LuZYMBYEpi1KzXhow3V8fdc9JjEy8g9JlcyDh7fdzuW9hc+4Yq97zuZNye8x0ztjWejLjxu/+pf36k606G/N4Ztf8mLpr2obO2es/FZttpy9zbbK/XNgxoH7dsJvIZw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8Ufpx9vjV7gvk7DXMoxi6folZX3LPBruedI+LnlndbbZNwB4vrg0ZT66P2WPhKeMxDPtv/uZws1nPhlzDq5+cZdbTxnhz99EGs23C+PzAZFj7EAxnQrZsHrbnu8djdm5Sr9tz7Wdud392omat/bdo4Tg7ETHsRL5g2Ik8wbATeYJhJ/IEw07kCYadyBOh4+wi0gzgSQBNABRAq6o+LCL3AvhbAL3BRe9R1bXWdUWdz16p5AJ7TfrhOXVmveaQPTd68GS7fcOH7nXpYyP2mvO5P+8w6/TVYo2zT2aTiAyAO1V1o4gkAbwrIi8HtYdU9V8L1VEiKp7J7M/eBaArOD0oIjsAzCt2x4iosL7Ua3YRmQ/gPADrg7PuEJHNIrJaRGY42qwSkXYRaU/DfrpKRMUz6bCLyFQAvwPwE1UdAPBLAKcBWISxI/8DE7VT1VZVbVHVlgTs/dSIqHgmFXYRSWAs6L9S1WcAQFW7VTWrqjkAjwJYXLxuElFUoWEXEQHwOIAdqvrguPPnjrvYdQC2Fr57RFQok3k3/hIANwPYIiKbgvPuAbBCRBZhbDiuA8BtRejfV4Ju2GLW7cmS4Rrezr9ttMWY6XgymXfj3wQmXFzcHFMnosrCT9AReYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEw07kCYadyBMMO5EnGHYiT5R0y2YR6QWwd9xZswAcLFkHvpxK7Vul9gtg3/JVyL6drKqzJyqUNOxfuHGRdlVtKVsHDJXat0rtF8C+5atUfePTeCJPMOxEnih32FvLfPuWSu1bpfYLYN/yVZK+lfU1OxGVTrmP7ERUIgw7kSfKEnYRWSoiO0XkAxG5uxx9cBGRDhHZIiKbRKS9zH1ZLSI9IrJ13HmNIvKyiOwKvk+4x16Z+naviHQG990mEVlWpr41i8hrIrJdRLaJyI+D88t63xn9Ksn9VvLX7CISB/A+gKsA7AewAcAKVd1e0o44iEgHgBZVLfsHMETkMgBHADypqmcH590PoE9V7wv+Uc5Q1bsqpG/3AjhS7m28g92K5o7fZhzAtQBuRRnvO6NfN6AE91s5juyLAXygqrtVdRTArwEsL0M/Kp6qrgPQd8zZywGsCU6vwdgfS8k5+lYRVLVLVTcGpwcBfLrNeFnvO6NfJVGOsM8DsG/cz/tRWfu9K4CXRORdEVlV7s5MoElVu4LTBwA0lbMzEwjdxruUjtlmvGLuu3y2P4+Kb9B90aWqej6AawDcHjxdrUg69hqsksZOJ7WNd6lMsM34Z8p53+W7/XlU5Qh7J4DmcT+fFJxXEVS1M/jeA+BZVN5W1N2f7qAbfO8pc38+U0nbeE+0zTgq4L4r5/bn5Qj7BgALROQUEakGcCOA58vQjy8QkfrgjROISD2Aq1F5W1E/D+CW4PQtAJ4rY18+p1K28XZtM44y33dl3/5cVUv+BWAZxt6R/xDAz8rRB0e/TgXw5+BrW7n7BuBpjD2tS2PsvY2VAGYCaAOwC8ArABorqG//A2ALgM0YC9bcMvXtUow9Rd8MYFPwtazc953Rr5Lcb/y4LJEn+AYdkScYdiJPMOxEnmDYiTzBsBN5gmEn8gTDTuSJ/wcK8iUIg3ozJAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c5fc7165", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),data_shape))" + ] + }, + { + "cell_type": "markdown", + "id": "810adc31", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c9ac8af7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "markdown", + "id": "82e19504", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e7f28b28", + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend,optimization_level=0)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " histogram[i] = population\n", + " \n", + " return histogram" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6c8605ca", + "metadata": {}, + "outputs": [], + "source": [ + "def encode_qiskit(x,num_qubit):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit)\n", + " # print(\"Number of pixels in each chunk is \" + str(len(qc.parameters)))\n", + " return qc.bind_parameters(normalized_vector)\n", + "\n", + "def encode_shallow(n, image):\n", + " # Getting the qubit number\n", + " qubit = int(np.ceil(np.log2(n)))\n", + " # print(\"Number of qubits is \" + str(qubit))\n", + " image = image.flatten()\n", + " # Discretizing the image into chunks of size n\n", + " state_chunks = [image[i * n:(i + 1) * n] for i in range((len(image) + n - 1) // n)]\n", + " # print(\"Number of pixels in each chunk is \" + str(len(state_chunks[0])))\n", + " # List of PQCs\n", + " qc_list = []\n", + " for i in range(len(state_chunks)) : # Initializing the encoder\n", + " if all(v == 0 for v in state_chunks[i]):\n", + " qc_list.append(state_chunks[i])\n", + " else:\n", + " qc = encode_qiskit(state_chunks[i], qubit)\n", + " qc_list.append(qc)\n", + " \n", + " return qc_list\n", + "\n", + "def decode(histogram,data):\n", + " new_histogram = {}\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values()))\n", + " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "38cd420c-bfb2-489c-852b-a2e7c1c5b530", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_image_re(data):\n", + " histogram = []\n", + " image_re = []\n", + " hist_new = []\n", + " circuit_list = encode_shallow(16, data)\n", + " for i in range(len(circuit_list)):\n", + " if all(v == 0 for v in circuit_list[i]):\n", + " histogram.append(circuit_list[i])\n", + " else:\n", + " histogram.append(simulate(circuit_list[i]))\n", + " \n", + " for i in range(len(histogram)):\n", + " if type(histogram[i]) is dict:\n", + " temp = list(histogram[i].values())\n", + " for j in range(16):\n", + " hist_new.append(temp[j])\n", + " else:\n", + " for j in range(16):\n", + " hist_new.append(histogram[i][j])\n", + " \n", + " print(len(hist_new))\n", + " hist_new = hist_new / np.linalg.norm(hist_new)\n", + " \n", + " sum = 0\n", + " for i in range(len(hist_new)):\n", + " sum+=hist_new[i]**2\n", + " print(sum)\n", + " \n", + " image_re = de_normalize(hist_new, X_train[0])\n", + " print(image_re)\n", + " return image_re, hist_new" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "5236a514", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "784\n", + "0.9999999999999996\n", + "[0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 2.59891569e-01 0.00000000e+00 0.00000000e+00 4.39216752e+01\n", + " 1.38496217e+03 0.00000000e+00 0.00000000e+00 2.59891569e-01\n", + " 4.15826511e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.59891569e-01 2.59891569e-01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 6.51822388e-01 0.00000000e+00 9.38624239e+01 1.33956743e+03\n", + " 1.00899945e+03 2.40473302e+02 1.82419393e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 6.25580910e-02 5.63022819e-01\n", + " 1.00092946e+00 0.00000000e+00 0.00000000e+00 5.63022819e-01\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 3.77243761e-01 0.00000000e+00 1.09023447e+02 4.36093788e+02\n", + " 3.24597298e+02 1.88160805e+02 2.17292406e+02 1.58536691e+02\n", + " 9.81409066e+02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.67151050e+02 1.85521563e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 1.48210114e+02 3.43588366e+02\n", + " 2.64335283e+02 1.95458449e+02 7.06288281e+01 1.50128671e+02\n", + " 1.59906529e+02 7.32938341e+01 2.52682051e+01 3.26339855e+00\n", + " 3.01096720e+02 8.58244994e+02 2.63262843e+02 1.14263387e+01\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 5.07837274e-02\n", + " 0.00000000e+00 1.73608631e+01 1.56247768e+02 1.81335509e+02\n", + " 1.73295034e+02 1.70129895e+02 1.70129895e+02 9.68831698e+01\n", + " 5.88139804e+01 5.33880270e+01 5.42741202e+01 7.77282415e+01\n", + " 7.24955511e+01 2.82382953e+01 1.07877289e+02 1.58840411e+01\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.71264454e-03 9.71264454e-03 9.71264454e-03\n", + " 0.00000000e+00 3.88505782e+02 5.22773380e+02 5.22773380e+02\n", + " 1.74252641e+02 1.68321073e+02 1.59616305e+02 1.59616305e+02\n", + " 1.48369436e+02 1.45621914e+02 8.63287044e+01 5.17696190e+01\n", + " 4.85598962e+01 1.23304711e+02 1.68321073e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 1.41570528e+02 2.14010810e+02 1.97232362e+02\n", + " 2.10223082e+02 2.19755811e+02 2.33456730e+02 2.17832356e+02\n", + " 2.12788273e+02 2.09005446e+02 2.12788273e+02 2.07126754e+02\n", + " 2.10892618e+02 2.54556283e+02 1.26924032e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 1.10735663e+02 1.54540597e+02 1.41281689e+02\n", + " 1.34875199e+02 1.16547583e+02 9.63203164e+01 1.33611738e+02\n", + " 1.31102653e+02 1.32354222e+02 1.34875199e+02 1.47836821e+02\n", + " 4.68151550e+02 5.71154564e+02 3.94678840e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.67255269e-03 8.70529742e-02 0.00000000e+00\n", + " 3.28779045e-01 1.09503971e+02 1.10506290e+02 1.02615593e+02\n", + " 1.08506217e+02 8.41674354e+01 6.52101270e+01 1.17650385e+02\n", + " 9.87798374e+01 1.08506217e+02 1.14561232e+02 1.02615593e+02\n", + " 1.16616101e+02 8.86082357e+01 9.97319267e+01 6.17373984e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 3.09037876e-01 0.00000000e+00\n", + " 8.41355617e+01 5.11079972e+02 4.23072852e+02 4.15484255e+02\n", + " 1.44617165e+02 1.25400403e+02 1.19299119e+02 1.48624842e+02\n", + " 1.40664264e+02 1.38059426e+02 1.49972906e+02 1.47282864e+02\n", + " 1.82658138e+02 4.30924097e+01 8.48671856e+01 9.54295579e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 6.16150110e-02 0.00000000e+00 0.00000000e+00\n", + " 1.16490880e+01 2.14481853e+02 2.00187171e+02 2.03714630e+02\n", + " 2.00187171e+02 2.21814040e+02 2.07272897e+02 1.74713215e+02\n", + " 2.28366688e+02 2.38962357e+02 2.63118559e+02 2.26276386e+02\n", + " 2.26276386e+02 2.09899952e+02 4.06719899e+01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 4.80529182e-03 7.68846691e-02\n", + " 1.72990505e-01 2.35459299e-01 1.92211673e-02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.35497228e+02 1.23211316e+02 1.13593423e+02 1.19961930e+02\n", + " 1.18888450e+02 1.15696960e+02 1.18888450e+02 1.17819795e+02\n", + " 1.12548891e+02 1.19961930e+02 1.26504123e+02 1.11509184e+02\n", + " 3.68451970e+02 5.04136632e+02 4.59673371e+01 0.00000000e+00\n", + " 0.00000000e+00 6.97766965e-02 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.98024024e+01 1.63006116e+02 3.22647445e+02\n", + " 1.06353147e+02 8.76640120e+01 9.28196355e+01 9.99229389e+01\n", + " 9.72285119e+01 8.85130532e+01 9.10847273e+01 9.72285119e+01\n", + " 1.02654192e+02 1.01739682e+02 9.81225625e+01 9.45709108e+01\n", + " 1.02654192e+02 1.21803650e+02 5.17219512e+01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.20369953e+00 7.19247622e+00 2.49804804e+01 4.25344319e+01\n", + " 1.32707873e+02 1.93126903e+02 1.79811905e+02 1.83096073e+02\n", + " 1.74941381e+02 1.89753572e+02 1.48604881e+02 1.56128003e+02\n", + " 1.01132633e+02 1.20166130e+02 1.13978370e+02 1.24382167e+02\n", + " 7.03641975e+01 8.02864217e+01 1.41973216e+02 1.39710731e+02\n", + " 1.23321343e+02 1.28670894e+02 1.05003391e+02 0.00000000e+00\n", + " 0.00000000e+00 7.38033567e+00 7.94345824e+01 9.82772676e+01\n", + " 9.57397740e+01 9.31924885e+01 9.57397740e+01 8.25511317e+01\n", + " 7.94066174e+01 8.73823878e+01 8.25511317e+01 8.33468007e+01\n", + " 7.63231617e+01 4.82381463e+01 1.14532445e+02 7.10740363e+01\n", + " 8.09712422e+01 9.48868627e+01 1.24072840e+02 1.24072840e+02\n", + " 1.02049801e+02 1.14408774e+02 1.02049801e+02 9.30234682e+01\n", + " 1.01128363e+02 1.12461426e+02 1.26443885e+02 0.00000000e+00\n", + " 1.88048609e-02 8.52570606e+01 1.08616877e+02 1.04839189e+02\n", + " 1.02049801e+02 9.30234682e+01 9.30234682e+01 9.56874902e+01\n", + " 9.24033034e+01 9.24033034e+01 9.24033034e+01 1.06420461e+02\n", + " 1.26649144e+02 1.40721271e+01 4.94723219e+01 1.42975010e+02\n", + " 1.15305690e+02 1.07390119e+02 7.77133220e+01 5.21460260e+01\n", + " 8.02133233e+01 9.69657509e+01 9.15040066e+01 9.60444663e+01\n", + " 1.00640607e+02 1.06154154e+02 1.03379002e+02 0.00000000e+00\n", + " 1.96118900e+01 1.10861089e+02 8.00566989e+01 9.00545970e+01\n", + " 1.00640607e+02 1.07087372e+02 1.07087372e+02 1.11814728e+02\n", + " 1.26609412e+02 9.88354307e+01 7.68547576e+01 9.43939625e+01\n", + " 1.20393778e+02 1.48497336e+02 1.08021770e+01 1.36248050e+01\n", + " 2.87273990e+01 3.49990535e+01 7.21610991e+01 1.22623245e+02\n", + " 1.24873166e+02 1.18184765e+02 1.20393778e+02 1.27143541e+02\n", + " 1.27143541e+02 1.28286398e+02 1.34077388e+02 2.15020849e+00\n", + " 1.23999254e+01 9.17396078e+01 9.90759547e+01 9.17396078e+01\n", + " 8.21128569e+01 9.26412201e+01 9.81434804e+01 1.11599328e+02\n", + " 1.02849941e+02 7.54466570e+01 8.55517695e+01 9.35472414e+01\n", + " 8.64225198e+01 1.00012838e+02 1.26975236e+02 8.38234954e+01\n", + " 1.09784944e+02 1.27886069e+02 1.21698962e+02 1.05949960e+02\n", + " 1.01252104e+02 9.57552937e+01 9.30644132e+01 1.05001867e+02\n", + " 1.03118463e+02 1.04058034e+02 1.12705924e+02 9.56402442e+00\n", + " 4.90877974e+00 8.77977016e+01 7.13498806e+01 8.01852580e+01\n", + " 9.35054255e+01 7.99852776e+01 7.05376620e+01 7.44020336e+01\n", + " 7.75677268e+01 7.59766362e+01 8.40969689e+01 9.43854718e+01\n", + " 9.88475328e+01 1.00661211e+02 9.97523110e+01 1.14789354e+02\n", + " 1.04338032e+02 9.61579302e+01 8.16175882e+01 8.74605179e+01\n", + " 1.00840836e+02 9.54921562e+01 9.13181454e+01 8.62317985e+01\n", + " 9.54921562e+01 1.22494975e+02 1.23692962e+02 3.85483888e+01\n", + " 0.00000000e+00 4.33840619e+01 1.39797299e+02 1.08573833e+02\n", + " 9.33934916e+01 8.52320180e+01 9.76141394e+01 1.11975418e+02\n", + " 9.61082801e+01 1.01844847e+02 1.04775484e+02 9.89557789e+01\n", + " 1.02817107e+02 1.01844847e+02 9.23762785e+01 8.87181779e+01\n", + " 8.69168404e+01 8.42494754e+01 8.78151997e+01 8.42494754e+01\n", + " 9.05379905e+01 8.51339783e+01 7.15361901e+01 5.62017278e+01\n", + " 9.35409197e+01 1.05078829e+02 1.47913319e+02 2.83886243e+01\n", + " 0.00000000e+00 0.00000000e+00 1.83667423e+01 1.19809789e+02\n", + " 1.50744132e+02 1.22358862e+02 1.02717583e+02 9.92260234e+01\n", + " 1.02717583e+02 1.09881820e+02 1.14792139e+02 1.18545314e+02\n", + " 8.73760518e+01 8.64538836e+01 9.11136461e+01 9.58957122e+01\n", + " 1.01795632e+02 1.06846766e+02 1.07871669e+02 1.07871669e+02\n", + " 1.08901464e+02 8.64538836e+01 8.64538836e+01 9.20602751e+01\n", + " 9.01719094e+01 1.14123823e+02 7.06914111e+01 0.00000000e+00\n", + " 9.90577738e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.07873916e+01 9.90577738e+01 1.22049083e+02 1.39099402e+02\n", + " 1.41456977e+02 1.45030487e+02 1.49864506e+02 1.46231562e+02\n", + " 1.47437590e+02 1.20952018e+02 1.19859906e+02 9.22450754e+01\n", + " 1.95611675e+02 1.71804328e+02 1.77611390e+02 1.77611390e+02\n", + " 1.75664979e+02 1.66093782e+02 1.47755690e+02 1.51337516e+02\n", + " 5.25531106e+01 1.80378190e+01 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.49510047e+02\n", + " 3.47704302e+02 1.80907156e+02 4.84412551e+02 1.57078993e+02\n", + " 1.14468629e+02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + "0.7906032567632196\n" + ] + } + ], + "source": [ + "#grade part1\n", + "#from part1 import encode_qiskit,decode\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "n=len(X_train)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "dataset = X_train[:1]\n", + "\n", + "for data in dataset:\n", + " image_re,hist_vector = extract_image_re(data) \n", + " \n", + " mse+=image_mse(np.asarray(data.flatten()),np.asarray(image_re))\n", + " \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", + "# score should be between 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7467384b-78a6-4d06-8dd6-bc5d02f1b691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7906032567632196\n" + ] + } + ], + "source": [ + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "bd5b0865", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "id": "cb18382c-674a-4d65-9503-2966af425ea5", + "metadata": {}, + "outputs": [], + "source": [ + "# 'Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r', 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens', 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r', 'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired', 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2', 'Pastel2_r', 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn', 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r', 'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy', 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r', 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r', 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral', 'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu', 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd', 'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r', 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r', 'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r', 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r', 'gist_earth', 'gist_earth_r', 'gist_gray', 'gist_gray_r', 'gist_heat', 'gist_heat_r', 'gist_ncar', 'gist_ncar_r', 'gist_rainbow', 'gist_rainbow_r', 'gist_stern', 'gist_stern_r', 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2', 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot', 'hot_r', 'hsv', 'hsv_r', 'inferno', 'inferno_r', 'jet', 'jet_r', 'magma', 'magma_r', 'nipy_spectral', 'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r', 'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow', 'rainbow_r', 'seismic', 'seismic_r', 'spring', 'spring_r', 'summer', 'summer_r', 'tab10', 'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r', 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', 'turbo', 'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted', 'twilight_shifted_r', 'viridis', 'viridis_r', 'winter', 'winter_r'\n", + "def plot_image(image):\n", + " # Reshape the list into a 28x28 array\n", + " image = np.array(image).reshape(28, 28)\n", + " # Plot the image using imshow\n", + " plt.imshow(image, cmap = \"Greys_r\")\n", + " # Remove the axis labels and ticks\n", + " plt.axis('off')\n", + " # Display the plot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7183ba07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.array(image_re).reshape(28, 28))" + ] + }, + { + "cell_type": "markdown", + "id": "c99038b9", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "07d890df-f0be-4e73-9d23-a656e9bdd7e3", + "metadata": {}, + "outputs": [], + "source": [ + "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", + " positive=0\n", + " label = ''\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", + " if isclose(positive, 0, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"T-shirt/Top\"\n", + " elif isclose(positive, 1, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Trousers\"\n", + " elif isclose(positive, 2, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Pullover\"\n", + " elif isclose(positive, 3, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Dress\"\n", + " elif isclose(positive, 4, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Coat\"\n", + " elif isclose(positive, 5, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Sandals\"\n", + " elif isclose(positive, 6, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Shirt\"\n", + " elif isclose(positive, 7, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Sneakers\"\n", + " elif isclose(positive, 8, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Bag\"\n", + " elif isclose(positive, 9, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Angle boots\"\n", + " \n", + " return label" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "47203d26-1dfd-4667-81f3-e8cd684d905a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[1;36m Input \u001b[1;32mIn [79]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", + "\u001b[1;33m classifier = pickle.load(open(\"ansatz.pickle\", \"rb\"))\u001b[0m\n", + "\u001b[1;31mFileNotFoundError\u001b[0m\u001b[1;31m:\u001b[0m [Errno 2] No such file or directory: 'ansatz.pickle'\n", + "\n", + "Use %tb to get the full traceback.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "classifier = pickle.load(open(\"circuit.pickle\", \"rb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "650b6a51-b675-41b3-930d-bcc29499e30c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error near line 1 Column 8\n" + ] + }, + { + "ename": "QasmError", + "evalue": "\"Expected an ID, received '.'\"", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mQasmError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [109]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m classifier \u001b[38;5;241m=\u001b[39m \u001b[43mQuantumCircuit\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_qasm_str\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcircuit.qasm\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/circuit/quantumcircuit.py:2500\u001b[0m, in \u001b[0;36mQuantumCircuit.from_qasm_str\u001b[0;34m(qasm_str)\u001b[0m\n\u001b[1;32m 2492\u001b[0m \u001b[38;5;124;03m\"\"\"Take in a QASM string and generate a QuantumCircuit object.\u001b[39;00m\n\u001b[1;32m 2493\u001b[0m \n\u001b[1;32m 2494\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 2497\u001b[0m \u001b[38;5;124;03m QuantumCircuit: The QuantumCircuit object for the input QASM\u001b[39;00m\n\u001b[1;32m 2498\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 2499\u001b[0m qasm \u001b[38;5;241m=\u001b[39m Qasm(data\u001b[38;5;241m=\u001b[39mqasm_str)\n\u001b[0;32m-> 2500\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_circuit_from_qasm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqasm\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/circuit/quantumcircuit.py:4984\u001b[0m, in \u001b[0;36m_circuit_from_qasm\u001b[0;34m(qasm)\u001b[0m\n\u001b[1;32m 4981\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mqiskit\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mconverters\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m ast_to_dag\n\u001b[1;32m 4982\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mqiskit\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mconverters\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m dag_to_circuit\n\u001b[0;32m-> 4984\u001b[0m ast \u001b[38;5;241m=\u001b[39m \u001b[43mqasm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4985\u001b[0m dag \u001b[38;5;241m=\u001b[39m ast_to_dag(ast)\n\u001b[1;32m 4986\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dag_to_circuit(dag)\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/qasm/qasm.py:53\u001b[0m, in \u001b[0;36mQasm.parse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m QasmParser(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_filename) \u001b[38;5;28;01mas\u001b[39;00m qasm_p:\n\u001b[1;32m 52\u001b[0m qasm_p\u001b[38;5;241m.\u001b[39mparse_debug(\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m---> 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mqasm_p\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/qasm/qasmparser.py:1137\u001b[0m, in \u001b[0;36mQasmParser.parse\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 1135\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mparse\u001b[39m(\u001b[38;5;28mself\u001b[39m, data):\n\u001b[1;32m 1136\u001b[0m \u001b[38;5;124;03m\"\"\"Parse some data.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1137\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlexer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlexer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse_deb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1138\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqasm \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1139\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m QasmError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUncaught exception in parser; \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msee previous messages for details.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/ply/yacc.py:333\u001b[0m, in \u001b[0;36mLRParser.parse\u001b[0;34m(self, input, lexer, debug, tracking, tokenfunc)\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparseopt(\u001b[38;5;28minput\u001b[39m, lexer, debug, tracking, tokenfunc)\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 333\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparseopt_notrack\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlexer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtracking\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtokenfunc\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/ply/yacc.py:1120\u001b[0m, in \u001b[0;36mLRParser.parseopt_notrack\u001b[0;34m(self, input, lexer, debug, tracking, tokenfunc)\u001b[0m\n\u001b[1;32m 1118\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m symstack[\u001b[38;5;241m-\u001b[39mplen:]\n\u001b[1;32m 1119\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate \u001b[38;5;241m=\u001b[39m state\n\u001b[0;32m-> 1120\u001b[0m \u001b[43mp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcallable\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpslice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1121\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m statestack[\u001b[38;5;241m-\u001b[39mplen:]\n\u001b[1;32m 1122\u001b[0m symstack\u001b[38;5;241m.\u001b[39mappend(sym)\n", + "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/qasm/qasmparser.py:397\u001b[0m, in \u001b[0;36mQasmParser.p_id_e\u001b[0;34m(self, program)\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mp_id_e\u001b[39m(\u001b[38;5;28mself\u001b[39m, program):\n\u001b[1;32m 394\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;124;03m id : error\u001b[39;00m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 397\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m QasmError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExpected an ID, received \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(program[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mvalue) \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mQasmError\u001b[0m: \"Expected an ID, received '.'\"" + ] + } + ], + "source": [ + "classifier = QuantumCircuit.from_qasm_str(\"circuit.qasm\")" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "6e97150a-0c20-4363-be5f-ff632ea2ed34", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1024\n" + ] + } + ], + "source": [ + "classify_operator = Operator(ansatz)\n", + "hist_vec = [*hist_vector]\n", + "hist_vec.extend(np.zeros(240))\n", + "\n", + "print(len(hist_vec))\n", + "hist_vec = Statevector(data = hist_vec)\n", + "output_statevector = hist_vec.evolve(classify_operator)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "6cd85420-26c7-4813-b2d8-7e5f2d8fb0e0", + "metadata": {}, + "outputs": [], + "source": [ + "features = []\n", + "for i in range(1024):\n", + " features.append(bin(i)[2:].zfill(10))\n", + "\n", + "output_statevector = list(i.real for i in output_statevector)\n", + "\n", + "hist_dictionary = dict(zip(features, output_statevector))" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "e6753673-9ee4-40f6-bc60-6c32f74cdd59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Sneakers'" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "histogram_to_category(hist_dictionary)" + ] + } + ], + "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.8.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "09fb4dc2adec4dbda718edf5f24ba06a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "1a73c36687e641fcbe79eab50083365a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2064167196b641dc80359eba5a6f7481": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + }, + "3b19c2f2bec1424a8b1d7a49ca7392f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_60ed032b3f0b40f598b86ba7cd470eff", + "style": "IPY_MODEL_e1794ce0830f45f0ad786c17ecfac533", + "value": "
Status
" + } + }, + "4c2452398d4240b5abb11e8c19a71202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_6c2276762d484d5695c29dbf55ef29ab" + ], + "layout": "IPY_MODEL_84bcb41a50d243398d317e22fe6e4d99" + } + }, + "5e622bf48ece4e018623ae2e6506892f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a6060914a26342f99f81d47c779565e9", + "style": "IPY_MODEL_8c5122655c0344ebb87eecfc99a06346", + "value": "
Job ID
" + } + }, + "60ed032b3f0b40f598b86ba7cd470eff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "6c2276762d484d5695c29dbf55ef29ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_2064167196b641dc80359eba5a6f7481", + "style": "IPY_MODEL_fe61c850e1f94359bfb9927c6c98c7be" + } + }, + "780fdb1f319e4f358204d6c0b0fc0e6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b56da9278227481ea619dd8a023cffa5", + "style": "IPY_MODEL_be1866a60deb410895a3802f64657d3e", + "value": "
Queue
" + } + }, + "7c5c2ea0ab594764a71629417062de67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b5a3cd6bd39f4054992176176e6106fc", + "style": "IPY_MODEL_09fb4dc2adec4dbda718edf5f24ba06a", + "value": "
Message
" + } + }, + "80a7dfe6ab934813a3d63ce2eb3b38ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "84bcb41a50d243398d317e22fe6e4d99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "8c5122655c0344ebb87eecfc99a06346": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "93a0ce8cb5394e79b1bdac3e175b2516": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a26aebf96de24c35a3431fb919766701", + "style": "IPY_MODEL_1a73c36687e641fcbe79eab50083365a", + "value": "
Backend
" + } + }, + "a26aebf96de24c35a3431fb919766701": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "a6060914a26342f99f81d47c779565e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "b56da9278227481ea619dd8a023cffa5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "b5a3cd6bd39f4054992176176e6106fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "be1866a60deb410895a3802f64657d3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "c01388cc2a14426cb1fbfc9ff1cbb79a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f9794da160d04ab08fac5a9c13c5acc5", + "style": "IPY_MODEL_80a7dfe6ab934813a3d63ce2eb3b38ac", + "value": "

Circuit Properties

" + } + }, + "c10e2b308bf34fa08d6b8aa85d8cb4f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_5e622bf48ece4e018623ae2e6506892f", + "IPY_MODEL_93a0ce8cb5394e79b1bdac3e175b2516", + "IPY_MODEL_3b19c2f2bec1424a8b1d7a49ca7392f8", + "IPY_MODEL_780fdb1f319e4f358204d6c0b0fc0e6b", + "IPY_MODEL_7c5c2ea0ab594764a71629417062de67" + ], + "layout": "IPY_MODEL_d983cada85d745439fdfacd1e8d4353b" + } + }, + "d983cada85d745439fdfacd1e8d4353b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "e1794ce0830f45f0ad786c17ecfac533": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "f9794da160d04ab08fac5a9c13c5acc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "fe61c850e1f94359bfb9927c6c98c7be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 57aa40807879c45fe614f28eade20c1b89dfcb44 Mon Sep 17 00:00:00 2001 From: "A.C.E07" <73689800+ACE07-Sev@users.noreply.github.com> Date: Fri, 3 Feb 2023 22:48:43 +0800 Subject: [PATCH 4/6] Delete Current Submission (4).ipynb --- submission/Current Submission (4).ipynb | 1348 ----------------------- 1 file changed, 1348 deletions(-) delete mode 100644 submission/Current Submission (4).ipynb diff --git a/submission/Current Submission (4).ipynb b/submission/Current Submission (4).ipynb deleted file mode 100644 index 5a05ad7..0000000 --- a/submission/Current Submission (4).ipynb +++ /dev/null @@ -1,1348 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "5393e245", - "metadata": {}, - "outputs": [], - "source": [ - "#pip install tensorflow" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f7155034-fac6-4159-8aeb-5f150c0ac927", - "metadata": {}, - "outputs": [], - "source": [ - "#pip install sklearn" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e019f2e1-ad01-49a3-b3f7-9477c7458095", - "metadata": {}, - "outputs": [], - "source": [ - "#pip install matplotlib" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6e750f82-596d-4031-8035-657f72eaef28", - "metadata": {}, - "outputs": [], - "source": [ - "#pip install qiskit" - ] - }, - { - "cell_type": "markdown", - "id": "5ae1c772", - "metadata": {}, - "source": [ - "## prepare" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "73194ae9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "All packages imported successfully!\n" - ] - } - ], - "source": [ - "import warnings \n", - "warnings.filterwarnings(\"ignore\")\n", - "\n", - "import numpy as np\n", - "\n", - "# Importing standard Qiskit libraries\n", - "import qiskit\n", - "from typing import Dict, List\n", - "from qiskit import QuantumCircuit, transpile, Aer, execute\n", - "from qiskit.algorithms.optimizers import COBYLA\n", - "from qiskit.tools.jupyter import *\n", - "from qiskit.visualization import *\n", - "from qiskit.providers.aer import QasmSimulator\n", - "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", - "from qiskit.circuit import Parameter\n", - "from qiskit.quantum_info import Statevector\n", - "from qiskit.quantum_info.operators import Operator\n", - "\n", - "import pickle\n", - "from matplotlib import pyplot as plt\n", - "\n", - "from tensorflow.keras.datasets import fashion_mnist\n", - "from sklearn.preprocessing import normalize\n", - "\n", - "print(\"All packages imported successfully!\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "876e03c7", - "metadata": {}, - "outputs": [], - "source": [ - "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "972efc8b", - "metadata": {}, - "outputs": [], - "source": [ - "data_shape = X_train[0].shape" - ] - }, - { - "cell_type": "markdown", - "id": "d09fdbb5", - "metadata": {}, - "source": [ - "## normalize" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "901e43e3", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2**int(np.ceil(np.log2(X_train[0].size)))" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "29e4784b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "10" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "int(np.ceil(np.log2(X_train[0].size)))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6e3a0634", - "metadata": {}, - "outputs": [], - "source": [ - "def normalize(x):\n", - " \"\"\"\n", - " \"\"\"\n", - " x = x.flatten()\n", - " normalized_vector = x / np.linalg.norm(x)\n", - " normalized_vector = [*normalized_vector]\n", - "\n", - " return normalized_vector\n", - "\n", - "def de_normalize(normalized_vector, x):\n", - " return normalized_vector * np.linalg.norm(x.flatten())" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6dabde13", - "metadata": {}, - "outputs": [], - "source": [ - "normalized_vector = np.array(normalize(X_train[0]))\n", - "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f2da7bbb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.allclose(\n", - " X_train[0], np.reshape(np.array(de_normalized_vector[:784]),data_shape), rtol=1e-2\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "54703421", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(100, 784)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X_train_list = []\n", - "for i in range(100):\n", - " X_train_list.append(normalize(X_train[i]))\n", - "\n", - "np.shape(X_train_list)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "2ad71107", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(100, 784)" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "X_test_list = []\n", - "for i in range(100):\n", - " X_test_list.append(normalize(X_test[i]))\n", - "np.shape(X_test_list)" - ] - }, - { - "cell_type": "markdown", - "id": "0638fa04", - "metadata": {}, - "source": [ - "## encoding" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "cb2bd8e0", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "before normalize:\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAUFElEQVR4nO3da2yc1ZkH8P8z4/ElzjiJk+CE4BIuoZDCEqhJuIlSKDREVQOli4gQC1K0QbvQbbt8ANGuyn5ZIbSA0LLbXQNZwqpQtSoIiiIKmEsWKGlMSHPdEEgcEuPYTkxsx/HYc3n2g1+oCT7Pa+adGzn/n2R5PM+cmeMZ//3OzJlzjqgqiOj4Fyt3B4ioNBh2Ik8w7ESeYNiJPMGwE3miqpQ3Vi01Wov6Ut4kkVdSGMKojshEtUhhF5GlAB4GEAfwmKreZ12+FvVYIldGuUkiMqzXNmct76fxIhIH8O8ArgGwEMAKEVmY7/URUXFFec2+GMAHqrpbVUcB/BrA8sJ0i4gKLUrY5wHYN+7n/cF5nyMiq0SkXUTa0xiJcHNEFEXR341X1VZVbVHVlgRqin1zROQQJeydAJrH/XxScB4RVaAoYd8AYIGInCIi1QBuBPB8YbpFRIWW99CbqmZE5A4Af8DY0NtqVd1WsJ4RUUFFGmdX1bUA1haoL0RURPy4LJEnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeaKkS0lTGciEqwr/RcSNPeMzG836J989w1lreOqdSLcd9rtJVcJZ0/RotNuOKuxxseT5mPHITuQJhp3IEww7kScYdiJPMOxEnmDYiTzBsBN5guPsxzmJx826ZjJmPbbI3qtzx21T7fbD7lpiaLHZtmo4Z9YTL7Wb9Uhj6WFj+CH3K8Q+jkbpm1QZsTUeTh7ZiTzBsBN5gmEn8gTDTuQJhp3IEww7kScYdiJPcJz9OGeOySJ8nH3fd6eb9Zsu+l+z/lbvqc7a3po5ZlutM8uo+s5FZv2M/+h01jIdH9lXHjJnPOx+CxOfMcNdzGbNttmBAXfR6HaksItIB4BBAFkAGVVtiXJ9RFQ8hTiyf1tVDxbgeoioiPiancgTUcOuAF4SkXdFZNVEFxCRVSLSLiLtaYxEvDkiylfUp/GXqmqniJwA4GUR+T9VXTf+AqraCqAVABqkMdrqhkSUt0hHdlXtDL73AHgWgD2NiYjKJu+wi0i9iCQ/PQ3gagBbC9UxIiqsKE/jmwA8K2PzfqsAPKWqLxakV1QwuVQqUvvR846Y9R9Os+eU18bSztobMXu+euerzWY9+1d23/Y+mHTWcu9dbLadudUe6254r8usH7xsnlnv/ab7FW1TyHL6M1750FmTPnek8w67qu4GcG6+7YmotDj0RuQJhp3IEww7kScYdiJPMOxEnhCNuGXvl9EgjbpErizZ7XnDWvY45PE9csOFZv2an79u1s+q/disD+ZqnbVRjfYBzkd2fsusD+2e5qzFRkO2TA4pZ5vspaA1bR9HZ2x0/+51y7vNtvLobGdtc9vDONK3b8Le88hO5AmGncgTDDuRJxh2Ik8w7ESeYNiJPMGwE3mC4+yVIGR74EhCHt+z37X/3/9ghj2FNUzcWNt4SKvNtoez9ZFuuzfjnuKaDhnjf2yXPQX2iDGGDwCxjP2YXvXt95y16xs3mG3vP+0cZ229tmFA+zjOTuQzhp3IEww7kScYdiJPMOxEnmDYiTzBsBN5gls2V4ISftbhWLuOnGDWDzVMNesHMtPN+sy4e7nnZGzYbDs/Ye8X2pt1j6MDQDzhXqp6VONm23/+xu/NeuqshFlPiL0U9cXGOgB/vf1vzLb12G3WXXhkJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wXF2z82usbc9rhX3lssAUC0Zs/5xeoaztmv462bb9wfszwAsbdpm1tPGWLo1zx4IHyc/MfGJWU+pPQ5v3auXNNnj6JvMqlvokV1EVotIj4hsHXdeo4i8LCK7gu/uR5SIKsJknsY/AWDpMefdDaBNVRcAaAt+JqIKFhp2VV0HoO+Ys5cDWBOcXgPg2sJ2i4gKLd/X7E2q2hWcPgCgyXVBEVkFYBUA1GJKnjdHRFFFfjdex1asdL7boaqtqtqiqi0J1ES9OSLKU75h7xaRuQAQfO8pXJeIqBjyDfvzAG4JTt8C4LnCdIeIiiX0NbuIPA3gcgCzRGQ/gF8AuA/Ab0RkJYC9AG4oZiePeyHrxkvcnnutGfdYd3yGPSr6relbzHpvtsGsH87a78NMjx911gYz7r3bAaBv2L7uM2u6zPrGo/OdtdnV9ji51W8A6BidZdYX1Bww6/d3u/dPaK499v3wz8tceZmzpuv/6KyFhl1VVzhK3O2B6CuEH5cl8gTDTuQJhp3IEww7kScYdiJPcIprJQhZSlqq7IfJGnrbt/Iss+0VU+wlk99OzTPrs6sGzbo1zXRuTb/ZNtmUMuthw36NVe7pu4PZOrPtlNiIWQ/7vc+vtpfB/ukr5ztrybMPmW0bEsYx2hjF5ZGdyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEx9krgCSqzXouZY83W2ZtGTXrB7P2ksfTY/ZUz+qQJZetrZEvbtxjtu0NGQvfOHyKWU/G3VtCz47Z4+TNCXuse0uq2ayvHTrdrK/83ivO2tOtV5ltq19821kTdT9ePLITeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ74ao2zG0suS5U9XizxkP9rMbueSxnzm3P2WHMYTdtj4VE8/F+PmPV9melm/UDaroctuZw1Jli/MzzNbFsbs7eLnl01YNYHcvY4vWUwZy9zbc3TB8L7ftfMXc7aM/3fMdvmi0d2Ik8w7ESeYNiJPMGwE3mCYSfyBMNO5AmGncgTFTXOHmV99LCxarWHPctqePlis77vWnsc/6bz/uSsHcgkzbbvGdsaA8A0Y044ANSHrK+eUvfnHz4etbeTDhurttaFB4ATjHH4rNrHuc603bcwYZ8/2J8x1rT/vj3XfvqTeXUp/MguIqtFpEdEto47714R6RSRTcHXsvxunohKZTJP458AsHSC8x9S1UXB19rCdouICi007Kq6DkBfCfpCREUU5Q26O0Rkc/A03/kCR0RWiUi7iLSnYb++I6LiyTfsvwRwGoBFALoAPOC6oKq2qmqLqrYkUJPnzRFRVHmFXVW7VTWrqjkAjwKw304morLLK+wiMnfcj9cB2Oq6LBFVhtBxdhF5GsDlAGaJyH4AvwBwuYgsAqAAOgDcVojOWOPoUVXNnWPW06c0mfW+s9x7gR+dY2yKDWDRsh1m/dam/zbrvdkGs54QY3/29Eyz7XlTOsz6q/0LzfrBqqlm3Rqnv7jePacbAA7n7P3XT6z6xKzf9cEPnbWmKfZY9mMn2wNMac2Z9Z1p+yVrf849H/4fFr5mtn0Ws826S2jYVXXFBGc/ntetEVHZ8OOyRJ5g2Ik8wbATeYJhJ/IEw07kiYqa4jpyzQVm/YSf7XbWFjXsN9surHvTrKdy9lLU1nTL7cPzzLZHc/aWzLtG7WHB/ow9BBUX9zBQz6g9xfWBPfayxW2L/9Os//zjieZI/UWsTp21Q1l72O76qfZS0YD9mN32tXXO2qnVPWbbF4bmmvWPQ6bANiX6zfr8RK+z9oPk+2bbfIfeeGQn8gTDTuQJhp3IEww7kScYdiJPMOxEnmDYiTxR2nF2sZeLXvIvG8zmVya3OWtH1Z5SGDaOHjZuaplWZS8bPJK27+aetD2FNcwZNQectesaNplt1z2yxKxfmvqRWf/wCnt6btuweypnb8b+vW/cc4VZ3/hRs1m/cP4eZ+2cZKfZNuyzDcl4yqxb044BYCjn/nt9J2V//iBfPLITeYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ4QVfd840Krm9Osp938j8566+3/ZrZ/qu9CZ6251t6O7uTqg2Z9Ztze/teSjNljrl9P2GOuLwydZNZfP3ymWf9mssNZS4i93fPlUz4w67f+9E6znqm1l9EemO8+nmTq7b+9hnMPmfUfnf6qWa82fvfDWXscPex+C9uSOYy1BkEyZm+T/cCy65y1P3Y8gf7hrgkfFB7ZiTzBsBN5gmEn8gTDTuQJhp3IEww7kScYdiJPlHQ+eywNTOl2jy++MLDIbH9qnXut7YNpe330Pxw5x6yfVGdv/2ttPXy6MZ8cADalppv1F3u/YdZPrLPXT+9OT3PWDqXrzbZHjXnVAPD4Qw+a9Qe67XXnr2vc6KydW22Pox/O2cei7SHr7Q/map21lNrrG/SHjMMnjb8HAEirHa24seXz9Jg9hj9wjnsb7my3+3ZDj+wi0iwir4nIdhHZJiI/Ds5vFJGXRWRX8D3/1R+IqOgm8zQ+A+BOVV0I4EIAt4vIQgB3A2hT1QUA2oKfiahChYZdVbtUdWNwehDADgDzACwHsCa42BoA1xapj0RUAF/qDToRmQ/gPADrATSpaldQOgCgydFmlYi0i0h7ZmQoSl+JKIJJh11EpgL4HYCfqOrn3jHSsdk0E85qUNVWVW1R1ZaqGvvNIiIqnkmFXUQSGAv6r1T1meDsbhGZG9TnArC3xSSisgodehMRAfA4gB2qOn4c5nkAtwC4L/j+XNh1xUdzSO4bcdZzak+XfPWge6pnU+2g2XZRcp9Z33nUHsbZMnyis7ax6mtm27q4e7tnAJhWbU+Rra9y32cAMCvh/t1PqbH/B1vTQAFgQ8r+3f5u9utm/aOMe5Dm90NnmG23H3Xf5wAwI2QJ7y0D7vZHM/Y22iNZOxqpjD2UO63GfkwvaNzrrO2EvV1077nGtOG33O0mM85+CYCbAWwRkU3BefdgLOS/EZGVAPYCuGES10VEZRIadlV9E4DrkHtlYbtDRMXCj8sSeYJhJ/IEw07kCYadyBMMO5EnSrtl85FhxN54z1n+7UuXmM3/aflvnbU3QpZbfuGAPS46MGpP9Zw9xf1R3wZjnBsAGhP2x4TDtnyuDdn+95OM+5OJIzF7KmfWOdAy5sCIe/osALyVW2DW0zn3ls0jRg0I/3xC3+gss35iXb+zNphxT38FgI7BRrN+sN/eVjk1xY7Wm9nTnLWlc9xbkwNAXY/7MYsZfyo8shN5gmEn8gTDTuQJhp3IEww7kScYdiJPMOxEnijpls0N0qhLJP+Jcv03ubdsPvXvd5ptF0/fY9Y3Dtjztj8yxl3TIUseJ2LuZYMBYEpi1KzXhow3V8fdc9JjEy8g9JlcyDh7fdzuW9hc+4Yq97zuZNye8x0ztjWejLjxu/+pf36k606G/N4Ztf8mLpr2obO2es/FZttpy9zbbK/XNgxoH7dsJvIZw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8Ufpx9vjV7gvk7DXMoxi6folZX3LPBruedI+LnlndbbZNwB4vrg0ZT66P2WPhKeMxDPtv/uZws1nPhlzDq5+cZdbTxnhz99EGs23C+PzAZFj7EAxnQrZsHrbnu8djdm5Sr9tz7Wdud392omat/bdo4Tg7ETHsRL5g2Ik8wbATeYJhJ/IEw07kCYadyBOh4+wi0gzgSQBNABRAq6o+LCL3AvhbAL3BRe9R1bXWdUWdz16p5AJ7TfrhOXVmveaQPTd68GS7fcOH7nXpYyP2mvO5P+8w6/TVYo2zT2aTiAyAO1V1o4gkAbwrIi8HtYdU9V8L1VEiKp7J7M/eBaArOD0oIjsAzCt2x4iosL7Ua3YRmQ/gPADrg7PuEJHNIrJaRGY42qwSkXYRaU/DfrpKRMUz6bCLyFQAvwPwE1UdAPBLAKcBWISxI/8DE7VT1VZVbVHVlgTs/dSIqHgmFXYRSWAs6L9S1WcAQFW7VTWrqjkAjwJYXLxuElFUoWEXEQHwOIAdqvrguPPnjrvYdQC2Fr57RFQok3k3/hIANwPYIiKbgvPuAbBCRBZhbDiuA8BtRejfV4Ju2GLW7cmS4Rrezr9ttMWY6XgymXfj3wQmXFzcHFMnosrCT9AReYJhJ/IEw07kCYadyBMMO5EnGHYiTzDsRJ5g2Ik8wbATeYJhJ/IEw07kCYadyBMMO5EnGHYiT5R0y2YR6QWwd9xZswAcLFkHvpxK7Vul9gtg3/JVyL6drKqzJyqUNOxfuHGRdlVtKVsHDJXat0rtF8C+5atUfePTeCJPMOxEnih32FvLfPuWSu1bpfYLYN/yVZK+lfU1OxGVTrmP7ERUIgw7kSfKEnYRWSoiO0XkAxG5uxx9cBGRDhHZIiKbRKS9zH1ZLSI9IrJ13HmNIvKyiOwKvk+4x16Z+naviHQG990mEVlWpr41i8hrIrJdRLaJyI+D88t63xn9Ksn9VvLX7CISB/A+gKsA7AewAcAKVd1e0o44iEgHgBZVLfsHMETkMgBHADypqmcH590PoE9V7wv+Uc5Q1bsqpG/3AjhS7m28g92K5o7fZhzAtQBuRRnvO6NfN6AE91s5juyLAXygqrtVdRTArwEsL0M/Kp6qrgPQd8zZywGsCU6vwdgfS8k5+lYRVLVLVTcGpwcBfLrNeFnvO6NfJVGOsM8DsG/cz/tRWfu9K4CXRORdEVlV7s5MoElVu4LTBwA0lbMzEwjdxruUjtlmvGLuu3y2P4+Kb9B90aWqej6AawDcHjxdrUg69hqsksZOJ7WNd6lMsM34Z8p53+W7/XlU5Qh7J4DmcT+fFJxXEVS1M/jeA+BZVN5W1N2f7qAbfO8pc38+U0nbeE+0zTgq4L4r5/bn5Qj7BgALROQUEakGcCOA58vQjy8QkfrgjROISD2Aq1F5W1E/D+CW4PQtAJ4rY18+p1K28XZtM44y33dl3/5cVUv+BWAZxt6R/xDAz8rRB0e/TgXw5+BrW7n7BuBpjD2tS2PsvY2VAGYCaAOwC8ArABorqG//A2ALgM0YC9bcMvXtUow9Rd8MYFPwtazc953Rr5Lcb/y4LJEn+AYdkScYdiJPMOxEnmDYiTzBsBN5gmEn8gTDTuSJ/wcK8iUIg3ozJAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "print('before normalize:')\n", - "display(plt.imshow(X_train[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "c5fc7165", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "after normalize:\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "normalized_vector = normalize(X_train[0])\n", - "#print(normalized_vector)\n", - "print('after normalize:')\n", - "plt.imshow(np.reshape(np.array(normalized_vector[:784]),data_shape))" - ] - }, - { - "cell_type": "markdown", - "id": "810adc31", - "metadata": {}, - "source": [ - "## circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c9ac8af7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "state = normalized_vector\n", - "n = 10\n", - "qc = RawFeatureVector(2**n)\n", - "#qc = qc.bind_parameters(state)\n", - "#qc.measure_all()\n", - "\n", - "#qc_ = qc.decompose(reps=20)\n", - "#print(qc_.depth())\n", - "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", - "## qc.decompose(reps = 9).draw()\n", - "qc.num_parameters" - ] - }, - { - "cell_type": "markdown", - "id": "82e19504", - "metadata": {}, - "source": [ - "## test encoding & decoding (1st task)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "e7f28b28", - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import BasicAer\n", - "\n", - "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circ, backend,optimization_level=0)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " histogram[i] = population\n", - " \n", - " return histogram" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "6c8605ca", - "metadata": {}, - "outputs": [], - "source": [ - "def encode_qiskit(x,num_qubit):\n", - " normalized_vector = normalize(x)\n", - " qc = RawFeatureVector(2**num_qubit)\n", - " # print(\"Number of pixels in each chunk is \" + str(len(qc.parameters)))\n", - " return qc.bind_parameters(normalized_vector)\n", - "\n", - "def encode_shallow(n, image):\n", - " # Getting the qubit number\n", - " qubit = int(np.ceil(np.log2(n)))\n", - " # print(\"Number of qubits is \" + str(qubit))\n", - " image = image.flatten()\n", - " # Discretizing the image into chunks of size n\n", - " state_chunks = [image[i * n:(i + 1) * n] for i in range((len(image) + n - 1) // n)]\n", - " # print(\"Number of pixels in each chunk is \" + str(len(state_chunks[0])))\n", - " # List of PQCs\n", - " qc_list = []\n", - " for i in range(len(state_chunks)) : # Initializing the encoder\n", - " if all(v == 0 for v in state_chunks[i]):\n", - " qc_list.append(state_chunks[i])\n", - " else:\n", - " qc = encode_qiskit(state_chunks[i], qubit)\n", - " qc_list.append(qc)\n", - " \n", - " return qc_list\n", - "\n", - "def decode(histogram,data):\n", - " new_histogram = {}\n", - " for key in range(len(qc.parameters)):\n", - " if key in histogram:\n", - " new_histogram[key] = histogram[key]\n", - " else:\n", - " new_histogram[key] = 0\n", - " #print(new_histogram)\n", - " after_ = np.array(list(new_histogram.values()))\n", - " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "38cd420c-bfb2-489c-852b-a2e7c1c5b530", - "metadata": {}, - "outputs": [], - "source": [ - "def extract_image_re(data):\n", - " histogram = []\n", - " image_re = []\n", - " hist_new = []\n", - " circuit_list = encode_shallow(16, data)\n", - " for i in range(len(circuit_list)):\n", - " if all(v == 0 for v in circuit_list[i]):\n", - " histogram.append(circuit_list[i])\n", - " else:\n", - " histogram.append(simulate(circuit_list[i]))\n", - " \n", - " for i in range(len(histogram)):\n", - " if type(histogram[i]) is dict:\n", - " temp = list(histogram[i].values())\n", - " for j in range(16):\n", - " hist_new.append(temp[j])\n", - " else:\n", - " for j in range(16):\n", - " hist_new.append(histogram[i][j])\n", - " \n", - " print(len(hist_new))\n", - " hist_new = hist_new / np.linalg.norm(hist_new)\n", - " \n", - " sum = 0\n", - " for i in range(len(hist_new)):\n", - " sum+=hist_new[i]**2\n", - " print(sum)\n", - " \n", - " image_re = de_normalize(hist_new, X_train[0])\n", - " print(image_re)\n", - " return image_re, hist_new" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "5236a514", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "784\n", - "0.9999999999999996\n", - "[0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 2.59891569e-01 0.00000000e+00 0.00000000e+00 4.39216752e+01\n", - " 1.38496217e+03 0.00000000e+00 0.00000000e+00 2.59891569e-01\n", - " 4.15826511e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 2.59891569e-01 2.59891569e-01 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 6.51822388e-01 0.00000000e+00 9.38624239e+01 1.33956743e+03\n", - " 1.00899945e+03 2.40473302e+02 1.82419393e+02 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 6.25580910e-02 5.63022819e-01\n", - " 1.00092946e+00 0.00000000e+00 0.00000000e+00 5.63022819e-01\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 3.77243761e-01 0.00000000e+00 1.09023447e+02 4.36093788e+02\n", - " 3.24597298e+02 1.88160805e+02 2.17292406e+02 1.58536691e+02\n", - " 9.81409066e+02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 2.67151050e+02 1.85521563e+02 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 1.48210114e+02 3.43588366e+02\n", - " 2.64335283e+02 1.95458449e+02 7.06288281e+01 1.50128671e+02\n", - " 1.59906529e+02 7.32938341e+01 2.52682051e+01 3.26339855e+00\n", - " 3.01096720e+02 8.58244994e+02 2.63262843e+02 1.14263387e+01\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 5.07837274e-02\n", - " 0.00000000e+00 1.73608631e+01 1.56247768e+02 1.81335509e+02\n", - " 1.73295034e+02 1.70129895e+02 1.70129895e+02 9.68831698e+01\n", - " 5.88139804e+01 5.33880270e+01 5.42741202e+01 7.77282415e+01\n", - " 7.24955511e+01 2.82382953e+01 1.07877289e+02 1.58840411e+01\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 9.71264454e-03 9.71264454e-03 9.71264454e-03\n", - " 0.00000000e+00 3.88505782e+02 5.22773380e+02 5.22773380e+02\n", - " 1.74252641e+02 1.68321073e+02 1.59616305e+02 1.59616305e+02\n", - " 1.48369436e+02 1.45621914e+02 8.63287044e+01 5.17696190e+01\n", - " 4.85598962e+01 1.23304711e+02 1.68321073e+02 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 1.41570528e+02 2.14010810e+02 1.97232362e+02\n", - " 2.10223082e+02 2.19755811e+02 2.33456730e+02 2.17832356e+02\n", - " 2.12788273e+02 2.09005446e+02 2.12788273e+02 2.07126754e+02\n", - " 2.10892618e+02 2.54556283e+02 1.26924032e+02 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 1.10735663e+02 1.54540597e+02 1.41281689e+02\n", - " 1.34875199e+02 1.16547583e+02 9.63203164e+01 1.33611738e+02\n", - " 1.31102653e+02 1.32354222e+02 1.34875199e+02 1.47836821e+02\n", - " 4.68151550e+02 5.71154564e+02 3.94678840e+02 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 9.67255269e-03 8.70529742e-02 0.00000000e+00\n", - " 3.28779045e-01 1.09503971e+02 1.10506290e+02 1.02615593e+02\n", - " 1.08506217e+02 8.41674354e+01 6.52101270e+01 1.17650385e+02\n", - " 9.87798374e+01 1.08506217e+02 1.14561232e+02 1.02615593e+02\n", - " 1.16616101e+02 8.86082357e+01 9.97319267e+01 6.17373984e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 3.09037876e-01 0.00000000e+00\n", - " 8.41355617e+01 5.11079972e+02 4.23072852e+02 4.15484255e+02\n", - " 1.44617165e+02 1.25400403e+02 1.19299119e+02 1.48624842e+02\n", - " 1.40664264e+02 1.38059426e+02 1.49972906e+02 1.47282864e+02\n", - " 1.82658138e+02 4.30924097e+01 8.48671856e+01 9.54295579e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 6.16150110e-02 0.00000000e+00 0.00000000e+00\n", - " 1.16490880e+01 2.14481853e+02 2.00187171e+02 2.03714630e+02\n", - " 2.00187171e+02 2.21814040e+02 2.07272897e+02 1.74713215e+02\n", - " 2.28366688e+02 2.38962357e+02 2.63118559e+02 2.26276386e+02\n", - " 2.26276386e+02 2.09899952e+02 4.06719899e+01 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 4.80529182e-03 7.68846691e-02\n", - " 1.72990505e-01 2.35459299e-01 1.92211673e-02 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.35497228e+02 1.23211316e+02 1.13593423e+02 1.19961930e+02\n", - " 1.18888450e+02 1.15696960e+02 1.18888450e+02 1.17819795e+02\n", - " 1.12548891e+02 1.19961930e+02 1.26504123e+02 1.11509184e+02\n", - " 3.68451970e+02 5.04136632e+02 4.59673371e+01 0.00000000e+00\n", - " 0.00000000e+00 6.97766965e-02 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 2.98024024e+01 1.63006116e+02 3.22647445e+02\n", - " 1.06353147e+02 8.76640120e+01 9.28196355e+01 9.99229389e+01\n", - " 9.72285119e+01 8.85130532e+01 9.10847273e+01 9.72285119e+01\n", - " 1.02654192e+02 1.01739682e+02 9.81225625e+01 9.45709108e+01\n", - " 1.02654192e+02 1.21803650e+02 5.17219512e+01 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.20369953e+00 7.19247622e+00 2.49804804e+01 4.25344319e+01\n", - " 1.32707873e+02 1.93126903e+02 1.79811905e+02 1.83096073e+02\n", - " 1.74941381e+02 1.89753572e+02 1.48604881e+02 1.56128003e+02\n", - " 1.01132633e+02 1.20166130e+02 1.13978370e+02 1.24382167e+02\n", - " 7.03641975e+01 8.02864217e+01 1.41973216e+02 1.39710731e+02\n", - " 1.23321343e+02 1.28670894e+02 1.05003391e+02 0.00000000e+00\n", - " 0.00000000e+00 7.38033567e+00 7.94345824e+01 9.82772676e+01\n", - " 9.57397740e+01 9.31924885e+01 9.57397740e+01 8.25511317e+01\n", - " 7.94066174e+01 8.73823878e+01 8.25511317e+01 8.33468007e+01\n", - " 7.63231617e+01 4.82381463e+01 1.14532445e+02 7.10740363e+01\n", - " 8.09712422e+01 9.48868627e+01 1.24072840e+02 1.24072840e+02\n", - " 1.02049801e+02 1.14408774e+02 1.02049801e+02 9.30234682e+01\n", - " 1.01128363e+02 1.12461426e+02 1.26443885e+02 0.00000000e+00\n", - " 1.88048609e-02 8.52570606e+01 1.08616877e+02 1.04839189e+02\n", - " 1.02049801e+02 9.30234682e+01 9.30234682e+01 9.56874902e+01\n", - " 9.24033034e+01 9.24033034e+01 9.24033034e+01 1.06420461e+02\n", - " 1.26649144e+02 1.40721271e+01 4.94723219e+01 1.42975010e+02\n", - " 1.15305690e+02 1.07390119e+02 7.77133220e+01 5.21460260e+01\n", - " 8.02133233e+01 9.69657509e+01 9.15040066e+01 9.60444663e+01\n", - " 1.00640607e+02 1.06154154e+02 1.03379002e+02 0.00000000e+00\n", - " 1.96118900e+01 1.10861089e+02 8.00566989e+01 9.00545970e+01\n", - " 1.00640607e+02 1.07087372e+02 1.07087372e+02 1.11814728e+02\n", - " 1.26609412e+02 9.88354307e+01 7.68547576e+01 9.43939625e+01\n", - " 1.20393778e+02 1.48497336e+02 1.08021770e+01 1.36248050e+01\n", - " 2.87273990e+01 3.49990535e+01 7.21610991e+01 1.22623245e+02\n", - " 1.24873166e+02 1.18184765e+02 1.20393778e+02 1.27143541e+02\n", - " 1.27143541e+02 1.28286398e+02 1.34077388e+02 2.15020849e+00\n", - " 1.23999254e+01 9.17396078e+01 9.90759547e+01 9.17396078e+01\n", - " 8.21128569e+01 9.26412201e+01 9.81434804e+01 1.11599328e+02\n", - " 1.02849941e+02 7.54466570e+01 8.55517695e+01 9.35472414e+01\n", - " 8.64225198e+01 1.00012838e+02 1.26975236e+02 8.38234954e+01\n", - " 1.09784944e+02 1.27886069e+02 1.21698962e+02 1.05949960e+02\n", - " 1.01252104e+02 9.57552937e+01 9.30644132e+01 1.05001867e+02\n", - " 1.03118463e+02 1.04058034e+02 1.12705924e+02 9.56402442e+00\n", - " 4.90877974e+00 8.77977016e+01 7.13498806e+01 8.01852580e+01\n", - " 9.35054255e+01 7.99852776e+01 7.05376620e+01 7.44020336e+01\n", - " 7.75677268e+01 7.59766362e+01 8.40969689e+01 9.43854718e+01\n", - " 9.88475328e+01 1.00661211e+02 9.97523110e+01 1.14789354e+02\n", - " 1.04338032e+02 9.61579302e+01 8.16175882e+01 8.74605179e+01\n", - " 1.00840836e+02 9.54921562e+01 9.13181454e+01 8.62317985e+01\n", - " 9.54921562e+01 1.22494975e+02 1.23692962e+02 3.85483888e+01\n", - " 0.00000000e+00 4.33840619e+01 1.39797299e+02 1.08573833e+02\n", - " 9.33934916e+01 8.52320180e+01 9.76141394e+01 1.11975418e+02\n", - " 9.61082801e+01 1.01844847e+02 1.04775484e+02 9.89557789e+01\n", - " 1.02817107e+02 1.01844847e+02 9.23762785e+01 8.87181779e+01\n", - " 8.69168404e+01 8.42494754e+01 8.78151997e+01 8.42494754e+01\n", - " 9.05379905e+01 8.51339783e+01 7.15361901e+01 5.62017278e+01\n", - " 9.35409197e+01 1.05078829e+02 1.47913319e+02 2.83886243e+01\n", - " 0.00000000e+00 0.00000000e+00 1.83667423e+01 1.19809789e+02\n", - " 1.50744132e+02 1.22358862e+02 1.02717583e+02 9.92260234e+01\n", - " 1.02717583e+02 1.09881820e+02 1.14792139e+02 1.18545314e+02\n", - " 8.73760518e+01 8.64538836e+01 9.11136461e+01 9.58957122e+01\n", - " 1.01795632e+02 1.06846766e+02 1.07871669e+02 1.07871669e+02\n", - " 1.08901464e+02 8.64538836e+01 8.64538836e+01 9.20602751e+01\n", - " 9.01719094e+01 1.14123823e+02 7.06914111e+01 0.00000000e+00\n", - " 9.90577738e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 1.07873916e+01 9.90577738e+01 1.22049083e+02 1.39099402e+02\n", - " 1.41456977e+02 1.45030487e+02 1.49864506e+02 1.46231562e+02\n", - " 1.47437590e+02 1.20952018e+02 1.19859906e+02 9.22450754e+01\n", - " 1.95611675e+02 1.71804328e+02 1.77611390e+02 1.77611390e+02\n", - " 1.75664979e+02 1.66093782e+02 1.47755690e+02 1.51337516e+02\n", - " 5.25531106e+01 1.80378190e+01 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.49510047e+02\n", - " 3.47704302e+02 1.80907156e+02 4.84412551e+02 1.57078993e+02\n", - " 1.14468629e+02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", - " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", - "0.7906032567632196\n" - ] - } - ], - "source": [ - "#grade part1\n", - "#from part1 import encode_qiskit,decode\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "n=len(X_train)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "dataset = X_train[:1]\n", - "\n", - "for data in dataset:\n", - " image_re,hist_vector = extract_image_re(data) \n", - " \n", - " mse+=image_mse(np.asarray(data.flatten()),np.asarray(image_re))\n", - " \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", - "# score should be between 0 and 1" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "7467384b-78a6-4d06-8dd6-bc5d02f1b691", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.7906032567632196\n" - ] - } - ], - "source": [ - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "bd5b0865", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 149, - "id": "cb18382c-674a-4d65-9503-2966af425ea5", - "metadata": {}, - "outputs": [], - "source": [ - "# 'Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r', 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens', 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r', 'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired', 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2', 'Pastel2_r', 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn', 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r', 'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy', 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r', 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r', 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral', 'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu', 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd', 'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r', 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r', 'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r', 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r', 'gist_earth', 'gist_earth_r', 'gist_gray', 'gist_gray_r', 'gist_heat', 'gist_heat_r', 'gist_ncar', 'gist_ncar_r', 'gist_rainbow', 'gist_rainbow_r', 'gist_stern', 'gist_stern_r', 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2', 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot', 'hot_r', 'hsv', 'hsv_r', 'inferno', 'inferno_r', 'jet', 'jet_r', 'magma', 'magma_r', 'nipy_spectral', 'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r', 'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow', 'rainbow_r', 'seismic', 'seismic_r', 'spring', 'spring_r', 'summer', 'summer_r', 'tab10', 'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r', 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', 'turbo', 'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted', 'twilight_shifted_r', 'viridis', 'viridis_r', 'winter', 'winter_r'\n", - "def plot_image(image):\n", - " # Reshape the list into a 28x28 array\n", - " image = np.array(image).reshape(28, 28)\n", - " # Plot the image using imshow\n", - " plt.imshow(image, cmap = \"Greys_r\")\n", - " # Remove the axis labels and ticks\n", - " plt.axis('off')\n", - " # Display the plot\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "7183ba07", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(np.array(image_re).reshape(28, 28))" - ] - }, - { - "cell_type": "markdown", - "id": "c99038b9", - "metadata": {}, - "source": [ - "## train classifier circuit (2nd task)\n", - "is there a way to get the best classifier? \n", - "\n", - "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", - "\n", - "reference: \n", - "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", - "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", - "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "id": "07d890df-f0be-4e73-9d23-a656e9bdd7e3", - "metadata": {}, - "outputs": [], - "source": [ - "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", - " positive=0\n", - " label = ''\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", - " if isclose(positive, 0, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"T-shirt/Top\"\n", - " elif isclose(positive, 1, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Trousers\"\n", - " elif isclose(positive, 2, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Pullover\"\n", - " elif isclose(positive, 3, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Dress\"\n", - " elif isclose(positive, 4, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Coat\"\n", - " elif isclose(positive, 5, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Sandals\"\n", - " elif isclose(positive, 6, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Shirt\"\n", - " elif isclose(positive, 7, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Sneakers\"\n", - " elif isclose(positive, 8, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Bag\"\n", - " elif isclose(positive, 9, rel_tol=1e-1, abs_tol=0.0):\n", - " label = \"Angle boots\"\n", - " \n", - " return label" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "47203d26-1dfd-4667-81f3-e8cd684d905a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", - "\u001b[1;36m Input \u001b[1;32mIn [79]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", - "\u001b[1;33m classifier = pickle.load(open(\"ansatz.pickle\", \"rb\"))\u001b[0m\n", - "\u001b[1;31mFileNotFoundError\u001b[0m\u001b[1;31m:\u001b[0m [Errno 2] No such file or directory: 'ansatz.pickle'\n", - "\n", - "Use %tb to get the full traceback.\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "classifier = pickle.load(open(\"circuit.pickle\", \"rb\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "id": "650b6a51-b675-41b3-930d-bcc29499e30c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Error near line 1 Column 8\n" - ] - }, - { - "ename": "QasmError", - "evalue": "\"Expected an ID, received '.'\"", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mQasmError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [109]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m classifier \u001b[38;5;241m=\u001b[39m \u001b[43mQuantumCircuit\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_qasm_str\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcircuit.qasm\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/circuit/quantumcircuit.py:2500\u001b[0m, in \u001b[0;36mQuantumCircuit.from_qasm_str\u001b[0;34m(qasm_str)\u001b[0m\n\u001b[1;32m 2492\u001b[0m \u001b[38;5;124;03m\"\"\"Take in a QASM string and generate a QuantumCircuit object.\u001b[39;00m\n\u001b[1;32m 2493\u001b[0m \n\u001b[1;32m 2494\u001b[0m \u001b[38;5;124;03mArgs:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 2497\u001b[0m \u001b[38;5;124;03m QuantumCircuit: The QuantumCircuit object for the input QASM\u001b[39;00m\n\u001b[1;32m 2498\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 2499\u001b[0m qasm \u001b[38;5;241m=\u001b[39m Qasm(data\u001b[38;5;241m=\u001b[39mqasm_str)\n\u001b[0;32m-> 2500\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_circuit_from_qasm\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqasm\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/circuit/quantumcircuit.py:4984\u001b[0m, in \u001b[0;36m_circuit_from_qasm\u001b[0;34m(qasm)\u001b[0m\n\u001b[1;32m 4981\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mqiskit\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mconverters\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m ast_to_dag\n\u001b[1;32m 4982\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mqiskit\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mconverters\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m dag_to_circuit\n\u001b[0;32m-> 4984\u001b[0m ast \u001b[38;5;241m=\u001b[39m \u001b[43mqasm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4985\u001b[0m dag \u001b[38;5;241m=\u001b[39m ast_to_dag(ast)\n\u001b[1;32m 4986\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dag_to_circuit(dag)\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/qasm/qasm.py:53\u001b[0m, in \u001b[0;36mQasm.parse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m QasmParser(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_filename) \u001b[38;5;28;01mas\u001b[39;00m qasm_p:\n\u001b[1;32m 52\u001b[0m qasm_p\u001b[38;5;241m.\u001b[39mparse_debug(\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m---> 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mqasm_p\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_data\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/qasm/qasmparser.py:1137\u001b[0m, in \u001b[0;36mQasmParser.parse\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 1135\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mparse\u001b[39m(\u001b[38;5;28mself\u001b[39m, data):\n\u001b[1;32m 1136\u001b[0m \u001b[38;5;124;03m\"\"\"Parse some data.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1137\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlexer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlexer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparse_deb\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1138\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqasm \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1139\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m QasmError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUncaught exception in parser; \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msee previous messages for details.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/ply/yacc.py:333\u001b[0m, in \u001b[0;36mLRParser.parse\u001b[0;34m(self, input, lexer, debug, tracking, tokenfunc)\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparseopt(\u001b[38;5;28minput\u001b[39m, lexer, debug, tracking, tokenfunc)\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 333\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mparseopt_notrack\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlexer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdebug\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtracking\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtokenfunc\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/ply/yacc.py:1120\u001b[0m, in \u001b[0;36mLRParser.parseopt_notrack\u001b[0;34m(self, input, lexer, debug, tracking, tokenfunc)\u001b[0m\n\u001b[1;32m 1118\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m symstack[\u001b[38;5;241m-\u001b[39mplen:]\n\u001b[1;32m 1119\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstate \u001b[38;5;241m=\u001b[39m state\n\u001b[0;32m-> 1120\u001b[0m \u001b[43mp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcallable\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpslice\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1121\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m statestack[\u001b[38;5;241m-\u001b[39mplen:]\n\u001b[1;32m 1122\u001b[0m symstack\u001b[38;5;241m.\u001b[39mappend(sym)\n", - "File \u001b[0;32m/opt/conda/lib/python3.8/site-packages/qiskit/qasm/qasmparser.py:397\u001b[0m, in \u001b[0;36mQasmParser.p_id_e\u001b[0;34m(self, program)\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mp_id_e\u001b[39m(\u001b[38;5;28mself\u001b[39m, program):\n\u001b[1;32m 394\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 395\u001b[0m \u001b[38;5;124;03m id : error\u001b[39;00m\n\u001b[1;32m 396\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 397\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m QasmError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mExpected an ID, received \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(program[\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mvalue) \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "\u001b[0;31mQasmError\u001b[0m: \"Expected an ID, received '.'\"" - ] - } - ], - "source": [ - "classifier = QuantumCircuit.from_qasm_str(\"circuit.qasm\")" - ] - }, - { - "cell_type": "code", - "execution_count": 102, - "id": "6e97150a-0c20-4363-be5f-ff632ea2ed34", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1024\n" - ] - } - ], - "source": [ - "classify_operator = Operator(ansatz)\n", - "hist_vec = [*hist_vector]\n", - "hist_vec.extend(np.zeros(240))\n", - "\n", - "print(len(hist_vec))\n", - "hist_vec = Statevector(data = hist_vec)\n", - "output_statevector = hist_vec.evolve(classify_operator)" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "id": "6cd85420-26c7-4813-b2d8-7e5f2d8fb0e0", - "metadata": {}, - "outputs": [], - "source": [ - "features = []\n", - "for i in range(1024):\n", - " features.append(bin(i)[2:].zfill(10))\n", - "\n", - "output_statevector = list(i.real for i in output_statevector)\n", - "\n", - "hist_dictionary = dict(zip(features, output_statevector))" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "id": "e6753673-9ee4-40f6-bc60-6c32f74cdd59", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Sneakers'" - ] - }, - "execution_count": 106, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "histogram_to_category(hist_dictionary)" - ] - } - ], - "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.8.13" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": {}, - "toc_section_display": true, - "toc_window_display": false - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "state": { - "09fb4dc2adec4dbda718edf5f24ba06a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "1a73c36687e641fcbe79eab50083365a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "2064167196b641dc80359eba5a6f7481": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "grid_area": "right", - "padding": "0px 0px 0px 0px", - "width": "70px" - } - }, - "3b19c2f2bec1424a8b1d7a49ca7392f8": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_60ed032b3f0b40f598b86ba7cd470eff", - "style": "IPY_MODEL_e1794ce0830f45f0ad786c17ecfac533", - "value": "
Status
" - } - }, - "4c2452398d4240b5abb11e8c19a71202": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "GridBoxModel", - "state": { - "children": [ - "IPY_MODEL_6c2276762d484d5695c29dbf55ef29ab" - ], - "layout": "IPY_MODEL_84bcb41a50d243398d317e22fe6e4d99" - } - }, - "5e622bf48ece4e018623ae2e6506892f": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a6060914a26342f99f81d47c779565e9", - "style": "IPY_MODEL_8c5122655c0344ebb87eecfc99a06346", - "value": "
Job ID
" - } - }, - "60ed032b3f0b40f598b86ba7cd470eff": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "95px" - } - }, - "6c2276762d484d5695c29dbf55ef29ab": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonModel", - "state": { - "button_style": "primary", - "description": "Clear", - "layout": "IPY_MODEL_2064167196b641dc80359eba5a6f7481", - "style": "IPY_MODEL_fe61c850e1f94359bfb9927c6c98c7be" - } - }, - "780fdb1f319e4f358204d6c0b0fc0e6b": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_b56da9278227481ea619dd8a023cffa5", - "style": "IPY_MODEL_be1866a60deb410895a3802f64657d3e", - "value": "
Queue
" - } - }, - "7c5c2ea0ab594764a71629417062de67": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_b5a3cd6bd39f4054992176176e6106fc", - "style": "IPY_MODEL_09fb4dc2adec4dbda718edf5f24ba06a", - "value": "
Message
" - } - }, - "80a7dfe6ab934813a3d63ce2eb3b38ac": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "84bcb41a50d243398d317e22fe6e4d99": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "grid_template_areas": "\n \". . . . right \"\n ", - "grid_template_columns": "20% 20% 20% 20% 20%", - "width": "100%" - } - }, - "8c5122655c0344ebb87eecfc99a06346": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "93a0ce8cb5394e79b1bdac3e175b2516": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_a26aebf96de24c35a3431fb919766701", - "style": "IPY_MODEL_1a73c36687e641fcbe79eab50083365a", - "value": "
Backend
" - } - }, - "a26aebf96de24c35a3431fb919766701": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "145px" - } - }, - "a6060914a26342f99f81d47c779565e9": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "190px" - } - }, - "b56da9278227481ea619dd8a023cffa5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "width": "70px" - } - }, - "b5a3cd6bd39f4054992176176e6106fc": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": {} - }, - "be1866a60deb410895a3802f64657d3e": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "c01388cc2a14426cb1fbfc9ff1cbb79a": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HTMLModel", - "state": { - "layout": "IPY_MODEL_f9794da160d04ab08fac5a9c13c5acc5", - "style": "IPY_MODEL_80a7dfe6ab934813a3d63ce2eb3b38ac", - "value": "

Circuit Properties

" - } - }, - "c10e2b308bf34fa08d6b8aa85d8cb4f4": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "HBoxModel", - "state": { - "children": [ - "IPY_MODEL_5e622bf48ece4e018623ae2e6506892f", - "IPY_MODEL_93a0ce8cb5394e79b1bdac3e175b2516", - "IPY_MODEL_3b19c2f2bec1424a8b1d7a49ca7392f8", - "IPY_MODEL_780fdb1f319e4f358204d6c0b0fc0e6b", - "IPY_MODEL_7c5c2ea0ab594764a71629417062de67" - ], - "layout": "IPY_MODEL_d983cada85d745439fdfacd1e8d4353b" - } - }, - "d983cada85d745439fdfacd1e8d4353b": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "margin": "0px 0px 0px 37px", - "width": "600px" - } - }, - "e1794ce0830f45f0ad786c17ecfac533": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "DescriptionStyleModel", - "state": { - "description_width": "" - } - }, - "f9794da160d04ab08fac5a9c13c5acc5": { - "model_module": "@jupyter-widgets/base", - "model_module_version": "1.2.0", - "model_name": "LayoutModel", - "state": { - "margin": "0px 0px 10px 0px" - } - }, - "fe61c850e1f94359bfb9927c6c98c7be": { - "model_module": "@jupyter-widgets/controls", - "model_module_version": "1.5.0", - "model_name": "ButtonStyleModel", - "state": {} - } - }, - "version_major": 2, - "version_minor": 0 - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From c3ca2ca3bab7e8309bab2d5ba44d69ca9a8e3359 Mon Sep 17 00:00:00 2001 From: "A.C.E07" <73689800+ACE07-Sev@users.noreply.github.com> Date: Fri, 3 Feb 2023 22:48:55 +0800 Subject: [PATCH 5/6] Add files via upload --- submission/Current Submission (5).ipynb | 1322 +++++++++++++++++++++++ 1 file changed, 1322 insertions(+) create mode 100644 submission/Current Submission (5).ipynb diff --git a/submission/Current Submission (5).ipynb b/submission/Current Submission (5).ipynb new file mode 100644 index 0000000..40a1e3c --- /dev/null +++ b/submission/Current Submission (5).ipynb @@ -0,0 +1,1322 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5393e245", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install tensorflow" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7155034-fac6-4159-8aeb-5f150c0ac927", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install sklearn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e019f2e1-ad01-49a3-b3f7-9477c7458095", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e750f82-596d-4031-8035-657f72eaef28", + "metadata": {}, + "outputs": [], + "source": [ + "#pip install qiskit" + ] + }, + { + "cell_type": "markdown", + "id": "5ae1c772", + "metadata": {}, + "source": [ + "## prepare" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "73194ae9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All packages imported successfully!\n" + ] + } + ], + "source": [ + "import warnings \n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "import numpy as np\n", + "\n", + "# Importing standard Qiskit libraries\n", + "import qiskit\n", + "from typing import Dict, List\n", + "from qiskit import QuantumCircuit, transpile, Aer, execute\n", + "from qiskit.algorithms.optimizers import COBYLA\n", + "from qiskit.tools.jupyter import *\n", + "from qiskit.visualization import *\n", + "from qiskit.providers.aer import QasmSimulator\n", + "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", + "from qiskit.circuit import Parameter\n", + "from qiskit.quantum_info import Statevector\n", + "from qiskit.quantum_info.operators import Operator\n", + "\n", + "import pickle\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from tensorflow.keras.datasets import fashion_mnist\n", + "from sklearn.preprocessing import normalize\n", + "\n", + "print(\"All packages imported successfully!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "876e03c7", + "metadata": {}, + "outputs": [], + "source": [ + "(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "972efc8b", + "metadata": {}, + "outputs": [], + "source": [ + "data_shape = X_train[0].shape" + ] + }, + { + "cell_type": "markdown", + "id": "d09fdbb5", + "metadata": {}, + "source": [ + "## normalize" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "901e43e3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "29e4784b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int(np.ceil(np.log2(X_train[0].size)))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6e3a0634", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(x):\n", + " \"\"\"\n", + " \"\"\"\n", + " x = x.flatten()\n", + " normalized_vector = x / np.linalg.norm(x)\n", + " normalized_vector = [*normalized_vector]\n", + "\n", + " return normalized_vector\n", + "\n", + "def de_normalize(normalized_vector, x):\n", + " return normalized_vector * np.linalg.norm(x.flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6dabde13", + "metadata": {}, + "outputs": [], + "source": [ + "normalized_vector = np.array(normalize(X_train[0]))\n", + "de_normalized_vector = de_normalize(normalized_vector,np.array(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f2da7bbb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.allclose(\n", + " X_train[0], np.reshape(np.array(de_normalized_vector[:784]),data_shape), rtol=1e-2\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "54703421", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 784)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_list = []\n", + "for i in range(100):\n", + " X_train_list.append(normalize(X_train[i]))\n", + "\n", + "np.shape(X_train_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2ad71107", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 784)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test_list = []\n", + "for i in range(100):\n", + " X_test_list.append(normalize(X_test[i]))\n", + "np.shape(X_test_list)" + ] + }, + { + "cell_type": "markdown", + "id": "0638fa04", + "metadata": {}, + "source": [ + "## encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cb2bd8e0", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "before normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "print('before normalize:')\n", + "display(plt.imshow(X_train[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c5fc7165", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "after normalize:\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "normalized_vector = normalize(X_train[0])\n", + "#print(normalized_vector)\n", + "print('after normalize:')\n", + "plt.imshow(np.reshape(np.array(normalized_vector[:784]),data_shape))" + ] + }, + { + "cell_type": "markdown", + "id": "810adc31", + "metadata": {}, + "source": [ + "## circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c9ac8af7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "state = normalized_vector\n", + "n = 10\n", + "qc = RawFeatureVector(2**n)\n", + "#qc = qc.bind_parameters(state)\n", + "#qc.measure_all()\n", + "\n", + "#qc_ = qc.decompose(reps=20)\n", + "#print(qc_.depth())\n", + "#print(f\"Circuit operations: {qc_.count_ops()}\")\n", + "## qc.decompose(reps = 9).draw()\n", + "qc.num_parameters" + ] + }, + { + "cell_type": "markdown", + "id": "82e19504", + "metadata": {}, + "source": [ + "## test encoding & decoding (1st task)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e7f28b28", + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import BasicAer\n", + "\n", + "def simulate(circ: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circ, backend,optimization_level=0)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " histogram[i] = population\n", + " \n", + " return histogram" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6c8605ca", + "metadata": {}, + "outputs": [], + "source": [ + "def encode_qiskit(x,num_qubit):\n", + " normalized_vector = normalize(x)\n", + " qc = RawFeatureVector(2**num_qubit)\n", + " # print(\"Number of pixels in each chunk is \" + str(len(qc.parameters)))\n", + " return qc.bind_parameters(normalized_vector)\n", + "\n", + "def encode_shallow(n, image):\n", + " # Getting the qubit number\n", + " qubit = int(np.ceil(np.log2(n)))\n", + " # print(\"Number of qubits is \" + str(qubit))\n", + " image = image.flatten()\n", + " # Discretizing the image into chunks of size n\n", + " state_chunks = [image[i * n:(i + 1) * n] for i in range((len(image) + n - 1) // n)]\n", + " # print(\"Number of pixels in each chunk is \" + str(len(state_chunks[0])))\n", + " # List of PQCs\n", + " qc_list = []\n", + " for i in range(len(state_chunks)) : # Initializing the encoder\n", + " if all(v == 0 for v in state_chunks[i]):\n", + " qc_list.append(state_chunks[i])\n", + " else:\n", + " qc = encode_qiskit(state_chunks[i], qubit)\n", + " qc_list.append(qc)\n", + " \n", + " return qc_list\n", + "\n", + "def decode(histogram,data):\n", + " new_histogram = {}\n", + " for key in range(len(qc.parameters)):\n", + " if key in histogram:\n", + " new_histogram[key] = histogram[key]\n", + " else:\n", + " new_histogram[key] = 0\n", + " #print(new_histogram)\n", + " after_ = np.array(list(new_histogram.values()))\n", + " return np.reshape(de_normalize(after_,data)[:784],data_shape)\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "38cd420c-bfb2-489c-852b-a2e7c1c5b530", + "metadata": {}, + "outputs": [], + "source": [ + "def extract_image_re(data):\n", + " histogram = []\n", + " image_re = []\n", + " hist_new = []\n", + " circuit_list = encode_shallow(16, data)\n", + " for i in range(len(circuit_list)):\n", + " if all(v == 0 for v in circuit_list[i]):\n", + " histogram.append(circuit_list[i])\n", + " else:\n", + " histogram.append(simulate(circuit_list[i]))\n", + " \n", + " for i in range(len(histogram)):\n", + " if type(histogram[i]) is dict:\n", + " temp = list(histogram[i].values())\n", + " for j in range(16):\n", + " hist_new.append(temp[j])\n", + " else:\n", + " for j in range(16):\n", + " hist_new.append(histogram[i][j])\n", + " \n", + " print(len(hist_new))\n", + " hist_new = hist_new / np.linalg.norm(hist_new)\n", + " \n", + " sum = 0\n", + " for i in range(len(hist_new)):\n", + " sum+=hist_new[i]**2\n", + " print(sum)\n", + " \n", + " image_re = de_normalize(hist_new, X_train[0])\n", + " print(image_re)\n", + " return image_re, hist_new" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "5236a514", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "784\n", + "0.9999999999999996\n", + "[0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 2.59891569e-01 0.00000000e+00 0.00000000e+00 4.39216752e+01\n", + " 1.38496217e+03 0.00000000e+00 0.00000000e+00 2.59891569e-01\n", + " 4.15826511e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.59891569e-01 2.59891569e-01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 6.51822388e-01 0.00000000e+00 9.38624239e+01 1.33956743e+03\n", + " 1.00899945e+03 2.40473302e+02 1.82419393e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 6.25580910e-02 5.63022819e-01\n", + " 1.00092946e+00 0.00000000e+00 0.00000000e+00 5.63022819e-01\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 3.77243761e-01 0.00000000e+00 1.09023447e+02 4.36093788e+02\n", + " 3.24597298e+02 1.88160805e+02 2.17292406e+02 1.58536691e+02\n", + " 9.81409066e+02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.67151050e+02 1.85521563e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 1.48210114e+02 3.43588366e+02\n", + " 2.64335283e+02 1.95458449e+02 7.06288281e+01 1.50128671e+02\n", + " 1.59906529e+02 7.32938341e+01 2.52682051e+01 3.26339855e+00\n", + " 3.01096720e+02 8.58244994e+02 2.63262843e+02 1.14263387e+01\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 5.07837274e-02\n", + " 0.00000000e+00 1.73608631e+01 1.56247768e+02 1.81335509e+02\n", + " 1.73295034e+02 1.70129895e+02 1.70129895e+02 9.68831698e+01\n", + " 5.88139804e+01 5.33880270e+01 5.42741202e+01 7.77282415e+01\n", + " 7.24955511e+01 2.82382953e+01 1.07877289e+02 1.58840411e+01\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.71264454e-03 9.71264454e-03 9.71264454e-03\n", + " 0.00000000e+00 3.88505782e+02 5.22773380e+02 5.22773380e+02\n", + " 1.74252641e+02 1.68321073e+02 1.59616305e+02 1.59616305e+02\n", + " 1.48369436e+02 1.45621914e+02 8.63287044e+01 5.17696190e+01\n", + " 4.85598962e+01 1.23304711e+02 1.68321073e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 1.41570528e+02 2.14010810e+02 1.97232362e+02\n", + " 2.10223082e+02 2.19755811e+02 2.33456730e+02 2.17832356e+02\n", + " 2.12788273e+02 2.09005446e+02 2.12788273e+02 2.07126754e+02\n", + " 2.10892618e+02 2.54556283e+02 1.26924032e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 1.10735663e+02 1.54540597e+02 1.41281689e+02\n", + " 1.34875199e+02 1.16547583e+02 9.63203164e+01 1.33611738e+02\n", + " 1.31102653e+02 1.32354222e+02 1.34875199e+02 1.47836821e+02\n", + " 4.68151550e+02 5.71154564e+02 3.94678840e+02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 9.67255269e-03 8.70529742e-02 0.00000000e+00\n", + " 3.28779045e-01 1.09503971e+02 1.10506290e+02 1.02615593e+02\n", + " 1.08506217e+02 8.41674354e+01 6.52101270e+01 1.17650385e+02\n", + " 9.87798374e+01 1.08506217e+02 1.14561232e+02 1.02615593e+02\n", + " 1.16616101e+02 8.86082357e+01 9.97319267e+01 6.17373984e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 3.09037876e-01 0.00000000e+00\n", + " 8.41355617e+01 5.11079972e+02 4.23072852e+02 4.15484255e+02\n", + " 1.44617165e+02 1.25400403e+02 1.19299119e+02 1.48624842e+02\n", + " 1.40664264e+02 1.38059426e+02 1.49972906e+02 1.47282864e+02\n", + " 1.82658138e+02 4.30924097e+01 8.48671856e+01 9.54295579e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 6.16150110e-02 0.00000000e+00 0.00000000e+00\n", + " 1.16490880e+01 2.14481853e+02 2.00187171e+02 2.03714630e+02\n", + " 2.00187171e+02 2.21814040e+02 2.07272897e+02 1.74713215e+02\n", + " 2.28366688e+02 2.38962357e+02 2.63118559e+02 2.26276386e+02\n", + " 2.26276386e+02 2.09899952e+02 4.06719899e+01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 4.80529182e-03 7.68846691e-02\n", + " 1.72990505e-01 2.35459299e-01 1.92211673e-02 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.35497228e+02 1.23211316e+02 1.13593423e+02 1.19961930e+02\n", + " 1.18888450e+02 1.15696960e+02 1.18888450e+02 1.17819795e+02\n", + " 1.12548891e+02 1.19961930e+02 1.26504123e+02 1.11509184e+02\n", + " 3.68451970e+02 5.04136632e+02 4.59673371e+01 0.00000000e+00\n", + " 0.00000000e+00 6.97766965e-02 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 2.98024024e+01 1.63006116e+02 3.22647445e+02\n", + " 1.06353147e+02 8.76640120e+01 9.28196355e+01 9.99229389e+01\n", + " 9.72285119e+01 8.85130532e+01 9.10847273e+01 9.72285119e+01\n", + " 1.02654192e+02 1.01739682e+02 9.81225625e+01 9.45709108e+01\n", + " 1.02654192e+02 1.21803650e+02 5.17219512e+01 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.20369953e+00 7.19247622e+00 2.49804804e+01 4.25344319e+01\n", + " 1.32707873e+02 1.93126903e+02 1.79811905e+02 1.83096073e+02\n", + " 1.74941381e+02 1.89753572e+02 1.48604881e+02 1.56128003e+02\n", + " 1.01132633e+02 1.20166130e+02 1.13978370e+02 1.24382167e+02\n", + " 7.03641975e+01 8.02864217e+01 1.41973216e+02 1.39710731e+02\n", + " 1.23321343e+02 1.28670894e+02 1.05003391e+02 0.00000000e+00\n", + " 0.00000000e+00 7.38033567e+00 7.94345824e+01 9.82772676e+01\n", + " 9.57397740e+01 9.31924885e+01 9.57397740e+01 8.25511317e+01\n", + " 7.94066174e+01 8.73823878e+01 8.25511317e+01 8.33468007e+01\n", + " 7.63231617e+01 4.82381463e+01 1.14532445e+02 7.10740363e+01\n", + " 8.09712422e+01 9.48868627e+01 1.24072840e+02 1.24072840e+02\n", + " 1.02049801e+02 1.14408774e+02 1.02049801e+02 9.30234682e+01\n", + " 1.01128363e+02 1.12461426e+02 1.26443885e+02 0.00000000e+00\n", + " 1.88048609e-02 8.52570606e+01 1.08616877e+02 1.04839189e+02\n", + " 1.02049801e+02 9.30234682e+01 9.30234682e+01 9.56874902e+01\n", + " 9.24033034e+01 9.24033034e+01 9.24033034e+01 1.06420461e+02\n", + " 1.26649144e+02 1.40721271e+01 4.94723219e+01 1.42975010e+02\n", + " 1.15305690e+02 1.07390119e+02 7.77133220e+01 5.21460260e+01\n", + " 8.02133233e+01 9.69657509e+01 9.15040066e+01 9.60444663e+01\n", + " 1.00640607e+02 1.06154154e+02 1.03379002e+02 0.00000000e+00\n", + " 1.96118900e+01 1.10861089e+02 8.00566989e+01 9.00545970e+01\n", + " 1.00640607e+02 1.07087372e+02 1.07087372e+02 1.11814728e+02\n", + " 1.26609412e+02 9.88354307e+01 7.68547576e+01 9.43939625e+01\n", + " 1.20393778e+02 1.48497336e+02 1.08021770e+01 1.36248050e+01\n", + " 2.87273990e+01 3.49990535e+01 7.21610991e+01 1.22623245e+02\n", + " 1.24873166e+02 1.18184765e+02 1.20393778e+02 1.27143541e+02\n", + " 1.27143541e+02 1.28286398e+02 1.34077388e+02 2.15020849e+00\n", + " 1.23999254e+01 9.17396078e+01 9.90759547e+01 9.17396078e+01\n", + " 8.21128569e+01 9.26412201e+01 9.81434804e+01 1.11599328e+02\n", + " 1.02849941e+02 7.54466570e+01 8.55517695e+01 9.35472414e+01\n", + " 8.64225198e+01 1.00012838e+02 1.26975236e+02 8.38234954e+01\n", + " 1.09784944e+02 1.27886069e+02 1.21698962e+02 1.05949960e+02\n", + " 1.01252104e+02 9.57552937e+01 9.30644132e+01 1.05001867e+02\n", + " 1.03118463e+02 1.04058034e+02 1.12705924e+02 9.56402442e+00\n", + " 4.90877974e+00 8.77977016e+01 7.13498806e+01 8.01852580e+01\n", + " 9.35054255e+01 7.99852776e+01 7.05376620e+01 7.44020336e+01\n", + " 7.75677268e+01 7.59766362e+01 8.40969689e+01 9.43854718e+01\n", + " 9.88475328e+01 1.00661211e+02 9.97523110e+01 1.14789354e+02\n", + " 1.04338032e+02 9.61579302e+01 8.16175882e+01 8.74605179e+01\n", + " 1.00840836e+02 9.54921562e+01 9.13181454e+01 8.62317985e+01\n", + " 9.54921562e+01 1.22494975e+02 1.23692962e+02 3.85483888e+01\n", + " 0.00000000e+00 4.33840619e+01 1.39797299e+02 1.08573833e+02\n", + " 9.33934916e+01 8.52320180e+01 9.76141394e+01 1.11975418e+02\n", + " 9.61082801e+01 1.01844847e+02 1.04775484e+02 9.89557789e+01\n", + " 1.02817107e+02 1.01844847e+02 9.23762785e+01 8.87181779e+01\n", + " 8.69168404e+01 8.42494754e+01 8.78151997e+01 8.42494754e+01\n", + " 9.05379905e+01 8.51339783e+01 7.15361901e+01 5.62017278e+01\n", + " 9.35409197e+01 1.05078829e+02 1.47913319e+02 2.83886243e+01\n", + " 0.00000000e+00 0.00000000e+00 1.83667423e+01 1.19809789e+02\n", + " 1.50744132e+02 1.22358862e+02 1.02717583e+02 9.92260234e+01\n", + " 1.02717583e+02 1.09881820e+02 1.14792139e+02 1.18545314e+02\n", + " 8.73760518e+01 8.64538836e+01 9.11136461e+01 9.58957122e+01\n", + " 1.01795632e+02 1.06846766e+02 1.07871669e+02 1.07871669e+02\n", + " 1.08901464e+02 8.64538836e+01 8.64538836e+01 9.20602751e+01\n", + " 9.01719094e+01 1.14123823e+02 7.06914111e+01 0.00000000e+00\n", + " 9.90577738e-03 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 1.07873916e+01 9.90577738e+01 1.22049083e+02 1.39099402e+02\n", + " 1.41456977e+02 1.45030487e+02 1.49864506e+02 1.46231562e+02\n", + " 1.47437590e+02 1.20952018e+02 1.19859906e+02 9.22450754e+01\n", + " 1.95611675e+02 1.71804328e+02 1.77611390e+02 1.77611390e+02\n", + " 1.75664979e+02 1.66093782e+02 1.47755690e+02 1.51337516e+02\n", + " 5.25531106e+01 1.80378190e+01 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.49510047e+02\n", + " 3.47704302e+02 1.80907156e+02 4.84412551e+02 1.57078993e+02\n", + " 1.14468629e+02 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00\n", + " 0.00000000e+00 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + "0.7906032567632196\n" + ] + } + ], + "source": [ + "#grade part1\n", + "#from part1 import encode_qiskit,decode\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "n=len(X_train)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "dataset = X_train[:1]\n", + "\n", + "for data in dataset:\n", + " image_re,hist_vector = extract_image_re(data) \n", + " \n", + " mse+=image_mse(np.asarray(data.flatten()),np.asarray(image_re))\n", + " \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", + "# score should be between 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7467384b-78a6-4d06-8dd6-bc5d02f1b691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.7906032567632196\n" + ] + } + ], + "source": [ + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "bd5b0865", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "id": "cb18382c-674a-4d65-9503-2966af425ea5", + "metadata": {}, + "outputs": [], + "source": [ + "# 'Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r', 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens', 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r', 'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired', 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2', 'Pastel2_r', 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn', 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r', 'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy', 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r', 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r', 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral', 'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu', 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd', 'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r', 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r', 'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r', 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r', 'gist_earth', 'gist_earth_r', 'gist_gray', 'gist_gray_r', 'gist_heat', 'gist_heat_r', 'gist_ncar', 'gist_ncar_r', 'gist_rainbow', 'gist_rainbow_r', 'gist_stern', 'gist_stern_r', 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2', 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot', 'hot_r', 'hsv', 'hsv_r', 'inferno', 'inferno_r', 'jet', 'jet_r', 'magma', 'magma_r', 'nipy_spectral', 'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r', 'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow', 'rainbow_r', 'seismic', 'seismic_r', 'spring', 'spring_r', 'summer', 'summer_r', 'tab10', 'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r', 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', 'turbo', 'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted', 'twilight_shifted_r', 'viridis', 'viridis_r', 'winter', 'winter_r'\n", + "def plot_image(image):\n", + " # Reshape the list into a 28x28 array\n", + " image = np.array(image).reshape(28, 28)\n", + " # Plot the image using imshow\n", + " plt.imshow(image, cmap = \"Greys_r\")\n", + " # Remove the axis labels and ticks\n", + " plt.axis('off')\n", + " # Display the plot\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7183ba07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.array(image_re).reshape(28, 28))" + ] + }, + { + "cell_type": "markdown", + "id": "c99038b9", + "metadata": {}, + "source": [ + "## train classifier circuit (2nd task)\n", + "is there a way to get the best classifier? \n", + "\n", + "Important Final Note: The goal of this problem is to explore quantum computing approaches to machine learning problems. To this end, the final score will take into account the degree of quantumness in the program. Preference will be given to creative solutions with a minimal amount of classical processing in the final solution.\n", + "\n", + "reference: \n", + "[1] calculate result from probability, https://github.com/ericardomuten/quantum_image_classifier \n", + "[2] MPS tensor circuit(ideal classifier circuit), https://journals.aps.org/prresearch/pdf/10.1103/PhysRevResearch.4.043007 , good example from qamp-mentorship https://github.com/qiskit-advocate/qamp-fall-22/issues/28 \n", + "[3] Good idea about amplitude circuit, https://journals.aps.org/prx/pdf/10.1103/PhysRevX.7.031041" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "07d890df-f0be-4e73-9d23-a656e9bdd7e3", + "metadata": {}, + "outputs": [], + "source": [ + "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", + " positive=0\n", + " label = ''\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", + " if isclose(positive, 0, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"T-shirt/Top\"\n", + " elif isclose(positive, 1, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Trousers\"\n", + " elif isclose(positive, 2, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Pullover\"\n", + " elif isclose(positive, 3, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Dress\"\n", + " elif isclose(positive, 4, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Coat\"\n", + " elif isclose(positive, 5, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Sandals\"\n", + " elif isclose(positive, 6, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Shirt\"\n", + " elif isclose(positive, 7, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Sneakers\"\n", + " elif isclose(positive, 8, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Bag\"\n", + " elif isclose(positive, 9, rel_tol=1e-1, abs_tol=0.0):\n", + " label = \"Angle boots\"\n", + " \n", + " return label" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "47203d26-1dfd-4667-81f3-e8cd684d905a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[1;36m Input \u001b[1;32mIn [79]\u001b[1;36m in \u001b[1;35m\u001b[1;36m\u001b[0m\n", + "\u001b[1;33m classifier = pickle.load(open(\"ansatz.pickle\", \"rb\"))\u001b[0m\n", + "\u001b[1;31mFileNotFoundError\u001b[0m\u001b[1;31m:\u001b[0m [Errno 2] No such file or directory: 'ansatz.pickle'\n", + "\n", + "Use %tb to get the full traceback.\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "classifier = pickle.load(open(\"circuit.pickle\", \"rb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "650b6a51-b675-41b3-930d-bcc29499e30c", + "metadata": {}, + "outputs": [], + "source": [ + "classifier = QuantumCircuit.from_qasm_file(\"iQuHACK/circuit.qasm\")" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "6e97150a-0c20-4363-be5f-ff632ea2ed34", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1024\n" + ] + } + ], + "source": [ + "classify_operator = Operator(ansatz)\n", + "hist_vec = [*hist_vector]\n", + "hist_vec.extend(np.zeros(240))\n", + "\n", + "print(len(hist_vec))\n", + "hist_vec = Statevector(data = hist_vec)\n", + "output_statevector = hist_vec.evolve(classify_operator)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "6cd85420-26c7-4813-b2d8-7e5f2d8fb0e0", + "metadata": {}, + "outputs": [], + "source": [ + "features = []\n", + "for i in range(1024):\n", + " features.append(bin(i)[2:].zfill(10))\n", + "\n", + "output_statevector = list(i.real for i in output_statevector)\n", + "\n", + "hist_dictionary = dict(zip(features, output_statevector))" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "e6753673-9ee4-40f6-bc60-6c32f74cdd59", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Sneakers'" + ] + }, + "execution_count": 106, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "histogram_to_category(hist_dictionary)" + ] + } + ], + "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.8.13" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "09fb4dc2adec4dbda718edf5f24ba06a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "1a73c36687e641fcbe79eab50083365a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "2064167196b641dc80359eba5a6f7481": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_area": "right", + "padding": "0px 0px 0px 0px", + "width": "70px" + } + }, + "3b19c2f2bec1424a8b1d7a49ca7392f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_60ed032b3f0b40f598b86ba7cd470eff", + "style": "IPY_MODEL_e1794ce0830f45f0ad786c17ecfac533", + "value": "
Status
" + } + }, + "4c2452398d4240b5abb11e8c19a71202": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "GridBoxModel", + "state": { + "children": [ + "IPY_MODEL_6c2276762d484d5695c29dbf55ef29ab" + ], + "layout": "IPY_MODEL_84bcb41a50d243398d317e22fe6e4d99" + } + }, + "5e622bf48ece4e018623ae2e6506892f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a6060914a26342f99f81d47c779565e9", + "style": "IPY_MODEL_8c5122655c0344ebb87eecfc99a06346", + "value": "
Job ID
" + } + }, + "60ed032b3f0b40f598b86ba7cd470eff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "95px" + } + }, + "6c2276762d484d5695c29dbf55ef29ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonModel", + "state": { + "button_style": "primary", + "description": "Clear", + "layout": "IPY_MODEL_2064167196b641dc80359eba5a6f7481", + "style": "IPY_MODEL_fe61c850e1f94359bfb9927c6c98c7be" + } + }, + "780fdb1f319e4f358204d6c0b0fc0e6b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b56da9278227481ea619dd8a023cffa5", + "style": "IPY_MODEL_be1866a60deb410895a3802f64657d3e", + "value": "
Queue
" + } + }, + "7c5c2ea0ab594764a71629417062de67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_b5a3cd6bd39f4054992176176e6106fc", + "style": "IPY_MODEL_09fb4dc2adec4dbda718edf5f24ba06a", + "value": "
Message
" + } + }, + "80a7dfe6ab934813a3d63ce2eb3b38ac": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "84bcb41a50d243398d317e22fe6e4d99": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "grid_template_areas": "\n \". . . . right \"\n ", + "grid_template_columns": "20% 20% 20% 20% 20%", + "width": "100%" + } + }, + "8c5122655c0344ebb87eecfc99a06346": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "93a0ce8cb5394e79b1bdac3e175b2516": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_a26aebf96de24c35a3431fb919766701", + "style": "IPY_MODEL_1a73c36687e641fcbe79eab50083365a", + "value": "
Backend
" + } + }, + "a26aebf96de24c35a3431fb919766701": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "145px" + } + }, + "a6060914a26342f99f81d47c779565e9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "190px" + } + }, + "b56da9278227481ea619dd8a023cffa5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "width": "70px" + } + }, + "b5a3cd6bd39f4054992176176e6106fc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": {} + }, + "be1866a60deb410895a3802f64657d3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "c01388cc2a14426cb1fbfc9ff1cbb79a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "layout": "IPY_MODEL_f9794da160d04ab08fac5a9c13c5acc5", + "style": "IPY_MODEL_80a7dfe6ab934813a3d63ce2eb3b38ac", + "value": "

Circuit Properties

" + } + }, + "c10e2b308bf34fa08d6b8aa85d8cb4f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "children": [ + "IPY_MODEL_5e622bf48ece4e018623ae2e6506892f", + "IPY_MODEL_93a0ce8cb5394e79b1bdac3e175b2516", + "IPY_MODEL_3b19c2f2bec1424a8b1d7a49ca7392f8", + "IPY_MODEL_780fdb1f319e4f358204d6c0b0fc0e6b", + "IPY_MODEL_7c5c2ea0ab594764a71629417062de67" + ], + "layout": "IPY_MODEL_d983cada85d745439fdfacd1e8d4353b" + } + }, + "d983cada85d745439fdfacd1e8d4353b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 0px 37px", + "width": "600px" + } + }, + "e1794ce0830f45f0ad786c17ecfac533": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "description_width": "" + } + }, + "f9794da160d04ab08fac5a9c13c5acc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "margin": "0px 0px 10px 0px" + } + }, + "fe61c850e1f94359bfb9927c6c98c7be": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ButtonStyleModel", + "state": {} + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a384cdf16e00852649830d1e2576830c38a7d003 Mon Sep 17 00:00:00 2001 From: "A.C.E07" <73689800+ACE07-Sev@users.noreply.github.com> Date: Fri, 3 Feb 2023 22:53:21 +0800 Subject: [PATCH 6/6] Add files via upload --- requirements.txt | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..75d894c --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +qiskit +matplotlib +tensorflow +scikit-learn \ No newline at end of file