From 53174daf8dd83f825e787a32c2ac67e76f01c6c1 Mon Sep 17 00:00:00 2001 From: Pierre Decoodt Date: Sun, 10 Feb 2019 15:34:33 +0100 Subject: [PATCH 1/5] Add files via upload --- ... Simulation and Real Device Run Test.ipynb | 2131 +++++++++++++++++ 1 file changed, 2131 insertions(+) create mode 100644 [WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb diff --git a/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb b/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb new file mode 100644 index 0000000..2c574e1 --- /dev/null +++ b/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb @@ -0,0 +1,2131 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NISQAI One-Qubit Quantum Neural Network Adapted for Qiskit\n", + "\n", + "\n", + "***\n", + "### Contributors\n", + "#### Add here the contributors:\n", + "Pierre Decoodt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "This is a proof of concept for the assessment on Qiskit of a NISQAI classifier$^{[1]}$.\n", + "A one-qubit neural network is tested on Aer based noise free simulation (NFS) and device noise simulation (DNS), and also on real superconducting quantum calculating device (SQC).\n", + "\n", + "The protocol follows the steps described in a previous Qiskit tutorial $^{[2]}$ using quantum state tomography $^{[3]}$ for assessing fidelity.\n", + "\n", + "The last part consist of testing training and prediction by NFS and DNS.\n", + "\n", + "NB: I use the term SQC instead of NISQ because the original Preskill paper $^{[4]}$ specifies as \"NISQ\" quantum computers with 50-100 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\decpi\\Anaconda3\\envs\\q7env\\lib\\site-packages\\marshmallow\\schema.py:364: ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See https://marshmallow.readthedocs.io/en/latest/upgrading.html#schemas-are-always-strict\n", + " ChangedInMarshmallow3Warning\n" + ] + } + ], + "source": [ + "#Import packages\n", + "# NB running this cell induces a ChangedInMarshmallow3Warning for the moment. This warning can be safely ignored.\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import time\n", + "from scipy.optimize import minimize\n", + "\n", + "# import from qiskit\n", + "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, compile\n", + "from qiskit.converters import qobj_to_circuits\n", + "from qiskit import Aer, IBMQ\n", + "from qiskit.providers.aer import noise\n", + "\n", + "# import tomography library\n", + "import qiskit.tools.qcvv.tomography as tomo\n", + "\n", + "# useful additional packages \n", + "from qiskit.tools.visualization import plot_state, plot_histogram \n", + "from qiskit.tools.qi.qi import state_fidelity, outer\n", + "from qiskit.tools.qi.qi import outer\n", + "from qiskit.quantum_info import state_fidelity\n", + "from qiskit.tools.monitor import job_monitor, backend_overview\n", + "from qiskit.providers.ibmq import least_busy\n", + "from qiskit.quantum_info.analyzation.average import average_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Aer.backends() # No need for credentials for running the next cells until next warning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Data Encoding" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set random seed for reproducible results\n", + "SEED = 1059123109\n", + "np.random.seed(seed=SEED)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# generate data points distributed uniformly at random in [0, 1) x [0, 1)\n", + "npoints = 100\n", + "data = np.random.rand(npoints, 2)\n", + "\n", + "def predicate(point):\n", + " \"\"\"Returns true if the point satisfies the predicate, else false.\"\"\"\n", + " return True if point[0] <= 0.5 else False\n", + "\n", + "# separate the data with a linear boundary y = x\n", + "labels = np.array([1 if predicate(p) else 0 for p in data])\n", + "\n", + "# plot the line y = x\n", + "xs = np.linspace(0, 1, 100)\n", + "ys = 0.5 * np.ones_like(xs)\n", + "plt.plot(ys, xs, '--k')\n", + "\n", + "# plot the data with the color key BLUE = 0 = LEFT, GREEN = 1 = RIGHT\n", + "for i in range(npoints):\n", + " if labels[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + " \n", + "# title and axis lables\n", + "plt.title(\"Random Data Points in Unit Square\", fontweight=\"bold\", fontsize=16)\n", + "\n", + "# put on a grid and show the plot\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Qubit Encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# encode the classical data via a simple linear \"qubit encoding\"\n", + "qdata = np.zeros_like(data)\n", + "for (index, point) in enumerate(data):\n", + " qdata[index][0] = np.pi * point[0]\n", + " qdata[index][1] = 2 * np.pi * point[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. State Preparation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As explained is the NISQAI one-qubit classifier description$^{[1]}$, the one-qubit encoding is achieved by realizing the following initial state: \n", + " \n", + "$$|\\psi\\rangle = \\cos(\\frac {\\theta}{2}) |0\\rangle + e^{i \\phi} \\sin(\\frac {\\theta}{2})|1\\rangle $$\n", + "\n", + "\n", + "The unitary taking the $|0\\rangle$ to the above state is: \n", + "\n", + "$$\n", + "S(\\theta, \\phi) = \\begin{pmatrix}\n", + "\\cos(\\frac {\\theta}{2}) & e^{-i \\phi}\\sin(\\frac {\\theta}{2}) \\\\\n", + "e^{i \\phi} \\sin(\\frac {\\theta}{2}) & - \\cos(\\frac {\\theta}{2})\n", + "\\end{pmatrix}\n", + "$$\n", + "\n", + "\n", + "Such an operation is not currently directly available in Qiskit to our knowledge. We therefore use arbitrary initialization in order to encode the qubit $^{[5]}$.\n", + "\n", + "A check of the results of this arbitrary initialization follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.122 5.969 0 vs 2 -- 8191 vs 8190\n", + "0.348 0.911 7946 vs 7946 -- 245 vs 246\n", + "1.652 4.618 3765 vs 3849 -- 4426 vs 4343\n", + "2.919 0.365 101 vs 94 -- 8090 vs 8098\n", + "2.582 1.018 623 vs 592 -- 7568 vs 7600\n", + "0.002 5.703 8191 vs 8192 -- 0 vs 0\n", + "2.986 5.712 49 vs 34 -- 8142 vs 8158\n", + "3.064 1.62 12 vs 15 -- 8179 vs 8177\n", + "1.516 0.87 4320 vs 4356 -- 3871 vs 3836\n", + "3.131 0.308 0 vs 0 -- 8191 vs 8192\n", + "2.118 0.197 1965 vs 1949 -- 6226 vs 6243\n" + ] + } + ], + "source": [ + "# Checking arbitrary initialization\n", + "n = 1\n", + "for i in range(5,56,5) : # modify here if wishe\n", + " # create a n-qubit quantum register\n", + " qrt = QuantumRegister(n)\n", + " crt = ClassicalRegister(n)\n", + " check_sta = QuantumCircuit(qrt,crt , name='check_sta')\n", + "\n", + " # pick an encoded data point\n", + " theta, phi = qdata[i]\n", + "\n", + " # desired vector\n", + " desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", + " qrt_vector = []\n", + "\n", + " # Initialize a 1-qubit quantum state using the arbitrary method \n", + " qrt_vector.append(qrt[0])\n", + " check_sta.initialize(desired_vector, qrt_vector)\n", + "\n", + " # Measurement circuit\n", + " measuring = QuantumCircuit(qrt,crt , name='measuring')\n", + " for i in range(n) :\n", + " measuring.measure(qrt[i] , crt[i])\n", + " test_check = check_sta+measuring\n", + "\n", + " # noise free simulation (NFS)\n", + " mode = \"NFS\"\n", + "\n", + " # test circuit \"check_sta\" : Noise free model on simulator\n", + " backend_sim = Aer.get_backend('qasm_simulator')\n", + " shots = 8192\n", + " job_noisefree = execute(test_check, backend_sim, shots=shots) \n", + " count = job_noisefree.result().get_counts(test_check)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " fr_obs1 = int(average_data(count,observable_1)*8192)\n", + " fr_obs0 = int(average_data(count,observable_0)*8192)\n", + " \n", + " fr_theo0 = int(abs(np.cos(theta / 2)**2)*shots)\n", + " fr_theo1 = int(abs(np.exp(1j * phi) * np.sin(theta / 2)**2)*shots)\n", + " print(round(theta,3), round(phi,3),\" \", fr_theo0,\"vs\", fr_obs0,\"--\", fr_theo1,\"vs\", fr_obs1) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Determine the job\n", + "n = 1\n", + "\n", + "# create a n-qubit quantum register\n", + "qr = QuantumRegister(n)\n", + "cr = ClassicalRegister(n)\n", + "initial_state = QuantumCircuit(qr, cr, name='initial_state')\n", + "\n", + "# pick a particular encoded data point\n", + "theta, phi = qdata[0]\n", + "\n", + "# desired vector\n", + "desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", + "qr_vector = []\n", + "\n", + "# Initialize a 1-qubit quantum state using the arbitrary method \n", + "qr_vector.append(qr[0])\n", + "initial_state.initialize(desired_vector, qr_vector)\n", + "\n", + "# Measurement circuit\n", + "measuring = QuantumCircuit(qr, cr, name='measuring')\n", + "for i in range(n) :\n", + " measuring.measure(qr[i] , cr[i])\n", + "test = initial_state+measuring" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the arbitrary initialization of the state by noise free simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "# QASM from test\n", + "QASM_source = test.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "test.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3d413bbc8b5e4734bc695b0e41e45e43", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:17:59\n", + "{'0': 8, '1': 992}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# noise free simulation (NFS)\n", + "mode = \"NFS\"\n", + "\n", + "# Test circuit \"initial_state\" : Noise free model on simulator\n", + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "shots = 1000\n", + "job_noisefree = execute(test, backend_sim, shots=shots)\n", + "job_monitor(job_noisefree)\n", + "\n", + "count = job_noisefree.result().get_counts(test)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, initial state, noise free simulation')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Unitary Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def unitary(angles):\n", + " \"\"\"Returns a circuit implementing the unitary Rz(theta0) P Rz(theta1) P Rz(theta2)\n", + " where thetea0 = angles[0], theta1 = angles[1], and theta2 = angles[2] and\n", + " P = Rx(pi / 2) is a pi / 2 pulse.\n", + " \"\"\"\n", + " \n", + " circuit = QuantumCircuit(qr, cr)\n", + " circuit.rz(angles[0], qr[0])\n", + " circuit.rx(np.pi / 2, qr[0]),\n", + " circuit.rz(angles[1], qr[0]),\n", + " circuit.rx(np.pi / 2, qr[0]),\n", + " circuit.rz(angles[2], qr[0])\n", + " \n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "# test angles\n", + "angles = 2 * np.pi * np.random.rand(3)\n", + "my_state = initial_state + unitary(angles)\n", + "qprog = my_state + measuring\n", + "\n", + "# QASM\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAB2CAYAAAC6afsyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAGU9JREFUeJzt3XtQVOf9BvCHm4CBXUAsKBcjajSiSBDkEpBFKUsCSpQaq8aoraOJ1Rg1Dmh6SzoaNNGaONMYKq23oMYYg1G7WhGIKFIIKkJao4OIkERKA6IYENbz+4Nhf64gu+DuHk7O85lxZjmXfZ99Pct+Oe8571oJgiCAiIiIZMla7ABEREQkHhYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEqFe+/fZbBAUFwcHBAW1tbWLHMUphYSEiIiIQFRWFFStWiB3HaGVlZbrcCxYsgJTu+N28eTMiIyPFjmGUyspKeHh4QKVSIS4uTuw4PbJr1y5MnjwZKpUKNTU1YscxSKPRQKVSQaVSYdCgQfj888/FjmSUu3fvIiEhASqVCklJSWhpaRE7kkmwEKBecXNzQ3Z2NsLCwsSOYrQhQ4bg1KlTOH36NGpra3Hp0iWxIxll5MiROHv2LE6fPg0AKC4uFjmRcVpaWnDx4kWxY/TIz3/+c+Tm5uLEiRNiRzFaTU0N8vLykJ2djdzcXHh5eYkdyaD4+Hjk5uYiNzcXvr6+iI2NFTuSUTQaDUJDQ5Gbm4sJEyZAo9GIHckkWAhQrzg4OMDV1VXsGD3i6ekJBwcHAICtrS1sbGxETmQcOzs73WN7e3v4+PiImMZ427dvx7x588SO0SM5OTmIiorCn//8Z7GjGO348ePQarWYPHkyli1bBq1WK3Yko1VUVMDDwwNOTk5iRzHKsGHDdGcBGhoaMGDAAJETmQYLAZKd0tJS1NXVYfTo0WJHMdrhw4cxZswY1NbWSuKXT2trK/Ly8jBp0iSxoxht0KBB+Oabb5CTk4OTJ0+itLRU7EhGuXnzJu7du4fs7Gz0798fWVlZYkcy2meffYZp06aJHcNoI0aMQGFhIfz9/VFcXIyIiAixI5kECwGSlR9++AFLly5FRkaG2FF6ZOrUqSgrK4OXlxeOHDkidhyDdu/ejdmzZ4sdo0fs7e3xxBNPwNbWFomJiSgrKxM7klGUSiWio6MBAJMmTcK///1vkRMZ74svvsDUqVPFjmG0nTt3Qq1Wo7y8HAkJCdizZ4/YkUyChQDJRltbG1566SW8++678PT0FDuO0R68IEmhUMDR0VHENMa5fPkyPvzwQ8THx6O8vBxbt24VO5JBt2/f1j0+c+YMhg0bJmIa40VEROjOXly4cAFDhw4VOZFxvv/+e/Tr108SZ7g6CIIANzc3AIC7uztu3bolciLTsOKXDlFvtLa24rnnnsNXX32FoKAgrF+/HqGhoWLH6tbevXvx2muvwd/fHwDwzjvvIDw8XORUhmVlZWHz5s0A2k9Npqenw9paOjV8ZGQk8vPzxY5h0LFjx/C73/0O9vb2iIyMxMaNG8WOZLQ33ngDxcXFcHd3R2ZmJvr16yd2JIM++ugjtLa2YunSpWJHMVpDQwNmzpyJlpYW2NnZYf/+/brCQMpYCBAREcmYdP6sICIiIpNjIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDLGQoCIiEjGWAgQERHJGAsBIiIiGWMhQEREJGMsBIiIiGSMhQAREZGM2YodgMT1+uuv48KFCxZvNzAwEFu2bOnVvmJlBqSZW4qZAWnmlmJmoPe5pZgZkObxYU48IyBzFy5csPgb4nHbFCOzKdplX1uuXfa1ZdqVYmZT7C+VNo3FMwKEwMBA5ObmWqw9lUr12M9h6cyANHNLMTMgzdxSzAw8fm4pZgakeXyYC88IEBERyRgLASIiIhljIUBERCRjLATIKIMHD4ajoyOcnJygVCoRHx+PGzduiB3LICnmlmJmQJq5pZgZkGZuKWaWCxYCZFBNTQ2+++47lJSU4M6dO6ioqEBtbS1SU1PFjtYtKeaWYmZAmrmlmBmQZm4pZpYTFgJkUFFRERQKBUaNGgUAGDBgAIKCgnDz5k2Rk3VPirmlmBmQZm4pZgakmVuKmbsiCAJaWlqg1WoNbnvnzh3U1dVZINXjYyFABhUVFSEkJARWVlZoa2uDRqPB/v37MXv2bLGjdUuKuaWYGZBmbilmBqSZW4qZO1y6dAkrVqxAWFgYHB0d4eDgAFtbW/j5+eHFF1/Evn37cO/ePb197ty5g4SEBMTFxaGtrU2k5MaTzTwCO3bswI4dO3p03+j48ePxzjvvIC4uznzBJKCoqAj5+flwcXHBnTt30L9/f2RkZODFF18UO1q3pJhbipkBaeaWYmZAmrmlmPnq1at49dVXcfLkSdjb2yMsLAxLliyBu7s7Wlpa8PXXX6OgoAAHDhyAh4cH0tLSMG/ePDQ1NSEhIQH5+fnIzMyErW3f/5gV5YzAvn37EBUVBYVC0WUnGVpvClqtFqtXr8bAgQPh7OyM5OTkTqdxkpKSkJWVZZb2paS4uBh79+5FQ0MDbty4AW9vb/znP/8RO5ZBUswtxcyANHNLMTMgzdxSy7xz504EBASgqKgIGzduRE1NDXJzc7F582asXbsWb731Fg4cOIDr169Do9Fg+PDhWLBgAZ5//nnEx8frioCZM2eK/VKMIkoh4OrqiiVLljxyzmVD600hLS0NWVlZKCwsRHV1NQBg7ty5etskJSXh8OHDZssgBVevXkV9fT2CgoIAAIMGDcKqVauwbds23L9/HwCQn5+PX/3qV7p9Zs6cia+++kqUvB2Myd3W1obJkydDpVJh3LhxGD9+vJiRJZkZMC73/fv3ERYWhsrKSlRXV2PixIm6911fzcy+tlzmvtTX27Ztw/z58xEeHo7y8nKsXr0aAwYM6HJba2trqNVqfPnll0hLS4NGo8GZM2fwt7/9TTJFAGDGQuCTTz7B2LFj4eTkhLi4OKxcuRIzZswAAKjVasyaNQt+fn5d7mtovSmkp6cjJSUFfn5+UCqV2LhxIzQaDSorK3XbjBs3Dra2tqJ/qImpqKgIbm5uGDJkiG5ZUlISbt68ifz8fABAcHAwzp8/DwDIycmBUqkU/ZemMbltbW2RnZ2NzMxM+Pn54dChQ2LFBSDNzIBxua2trbF+/XqsXLkSc+fORUZGBry9vcWKzL62ICn1dUFBAZYsWYKEhAT84x//gJeXl1H73b17F8eOHYO1tTWsrKxw6tQpMyc1LbMUAjt37sSqVavwl7/8Bbdu3UJiYiI++OADPPPMM+ZoDmlpaQgICDB6+1u3bqGqqkrvw2rYsGFQKBQoLS3V23bq1KmyHh4oKirq9P/m7u6OiIgIfPrppwAABwcHODg4oL6+Hn/4wx+wbt06MaLqMSY3AFy7dg1Lly7FRx99BF9fX0vH1CPFzIDxuceNG4fc3FwsWrQII0aMsHRMPexry5FKXzc3N2PBggXw8fFBZmYm+vXrZ9R+HRcGdgwHvPnmm9i1axeOHDli5sQmJJhYU1OT4ObmJhw7dkxvGQC9ZYIgCDk5OYKNjc0jn8vQ+p74+9//LkRHRwuCIAhVVVUCAKGiokJvG19fX2H37t16y44fPy4EBQWZJENfFB0dreuXx7F8+XIhOTlZ2LJli9nbNFXm8vJyITk5Waivr7dIu6bILcXMgiAIt2/fFmJjY4Vdu3YJkyZNMnu77GvL9PVP6b24Y8cOAYBw9OhRo5/n9u3bwsSJEwVra2th3759giAIQnNzszBixAghJCTEpJnNyeSFwLFjxwQXFxe9ZZWVlQIA4bvvvtNbLlYhUF9fLwAQzp8/r7eNQqEQsrKy9Jalp6cLL7zwgkkydAeAaP9McXDu3btXGD16tNDa2mpw2+jo6D6R2cvLSwgODta9QRsaGvp8bilmbm5uFp5//nkhLy9PEARBePnll4XDhw/3+dzsa3m9FydMmCA8/fTTwv37943K3FUR0GHr1q0CAKGoqMikmR/nX3dMfkl+bW0tfvazn+kty8zMhKenJzw9PU3dXK+4uLjA19cXJSUlCAwMBABUVFSgsbGx0xDD4cOHkZycbPZMgiCYvY2umOqrMfPz8/HBBx8YfZdHdHR0r78C1FSZe3MBldi5pZjZ3t4eR48e1f28c+dOo/YTOzf72rCfynuxoaEB//rXv/CnP/0JVlZWBvd/eDjg4QsDZ8+ejWXLluGf//wngoODTZLZnEx+jYC/vz+uXr2KvLw83Lt3D5mZmUhLS9N94ALtt+41NzfrJmFobm5Gc3Oz7sPQ0HpTWLRoETZs2IBr166hsbERKSkpUKvVePLJJ3Xb3L17Fzk5OUhMTDRZuz811dXVSEpKglKpxOTJk8WOQ0TUYyUlJQCAkJAQg9saKgIAwM3NDcOHD5fMheYmLwSCg4Px5ptvYvr06fD29kZhYSFCQ0P1LhbZvXs3HB0doVarodVq4ejoCEdHR1y/ft2o9Q9bv349/P39e5QzNTUVU6ZMQUhICLy8vKDVarFnzx69bY4fP45nnnkG7u7uPewF+fD29kZWVlafuECQiKg3ampqALRfNN4dY4qADn5+fqLettkTZrlr4O2338b//vc/1NbW4v3338c333yjVwjMnz8fQvv1CXr/Ov4aN7T+YWvXrkV5eXmPMtrY2OC9995DXV0dbt++jc8++6zTB/7hw4eRlJTUo+clIiJpmTVrFhoaGjB06NBut/vxxx/R2Nho1GRBBw8eRE5Ojiljmo3ZJxRqbGzE9evXzXbroDkNGTJEN/eBHBUWFiIiIgJRUVFYsWKF3roLFy7g2WefRVRUFE6fPg0AqKqqwqRJkzBx4kR88sknYkTWWbFiBaKiorB8+XK95b/85S+hUqkQHh6uG67q6rWI4VGZly9fjujoaISGhuLMmTMAgHXr1mHw4MH47W9/K0ZUnW+//RZBQUFwcHDoNKf6/PnzERoaCpVKhczMTADA66+/DpVKBZVKBVdXVzEi62zevBmRkZF6yxYvXoxnn30WkZGRuluJ8/LyEBoairCwMGzbtk2MqACk2ddlZWW63yELFizQG97t6rjuqv8twdbWFkqlEjY2Nt1uN3DgQBQVFRk1WZCTkxMcHR1NFdGszD4JcllZGZydnQ2ecjG3wMBAzJ8/v0f7/PGPfzRLFqkYMmQITp06BQcHB8yZMweXLl3C2LFjAQC///3vsX//fri5uWH69OnQaDTYsGED1q1bhwkTJuC5557D9OnTRZlnu6SkBE1NTTh9+jReffVV3ReeAO3TVwPAoUOHdON3Xb2WvpT5vffeg52dHa5fv44lS5bg6NGjWLhwISIiIpCdnW3xrA9yc3NDdnY2pk2b1uX6jz/+GMOHD9f93DFb6Pnz57Fp0yaLZOxKS0sLLl682Gl5amoqhg4diitXriA1NRUHDx7Epk2bcODAAXh7eyM8PByvvPKKCIml2dcjR47E2bNnAQALFixAcXFxt8d1V/3f10jhuwN6yuxnBCIiItDY2GjUlZjm1JtCQO48PT3h4OAAoP3gf7Barq+vh7e3N/r374+mpib8+OOPqKioQEBAAGxsbODh4YGrV6+KkrugoACxsbEAgNjYWJw7d67TNocOHcL06dMBdP1aLK27zHZ2dgDaxyfHjRsHAPDw8BD9PQW0Tyb1qL82rays8PLLL2PKlCmdru95sP/FsH37dsybN6/T8o5Tw3Z2drrj3d/fH7du3UJLSwueeOIJi+Z8kBT7uuPYBdrvaPDx8em07sHjuqv+J/Pj1xCTQaWlpairq8Po0aN1ywYOHIiysjL897//RVlZGRoaGjBy5Ejk5eXh7t27OHfuHOrr60XJ29DQAIVCAQBQKpWdcrS1teHSpUu6uc+7ei19LfO0adMQFxenKxakYNOmTTh79ixSUlKwatUqvXUajQbx8fGi5GptbUVeXh4mTZr0yG3WrFmD1157DQDwwgsvIDExEaNGjcKcOXMsFbNH+mpfA+3XWo0ZMwa1tbWd5ux/1HH9YP+T+bEQoG798MMPWLp0KTIyMvSWp6WlYeXKlXjllVcQEBAAd3d3rFmzBunp6ZgxYwZGjRoFDw8PUTK7uLigsbERQPs1Ki4uLnrrc3Jy9O4j7uq1WJqhzIcOHcK5c+ewdu1ai2frLTc3NwBAZGQkvv/+e93yK1euwMvLC/379xcl1+7duzF79uxHrt+yZQtGjx6tu35g9erVyM/Px5UrV7Br1y7cvXvXUlGN1lf7Gmifpr2srAxeXl6dpt3t6rh+uP/J/FgI0CO1tbXhpZdewrvvvttpMqinnnoKJ06c0M0LbmdnBw8PD3z++ef49NNPYW9vb/AKXHMJDw/XjZ2fPHkSYWFheusPHTqkN87a1WuxtO4yt7S0AACcnZ1FPTXdUx2FzeXLl/UKm4f739IuX76MDz/8EPHx8SgvL8fWrVt1606cOIGzZ8/qXYRpY2MDFxcX9OvXD9bW1mhtbRUjdrf6al93HLsAoFAo9C6e6+q47qr/yfxYCNAjHThwAEVFRUhJSYFKpUJBQQGWLVsGAMjIyEBMTAzmzZuHt99+GwBw9OhRxMTEYMqUKVizZo1oY9gdV1ZHRUXB2toavr6+unkOBEFAQUGB3l8bXb2WvpR55syZun596623dJlXrVqFjz/+GL/5zW9EyQy0n2aPjY3FxYsXoVarkZeXp8s9Z84cREZGYuHChUhLS9Ptc+TIEUyZMkWsyNiwYQOOHz8OjUYDf39/zJgxQ5d52bJluHbtGmJiYrB48WIAQEpKCmJjYxEeHo6YmBgolUpRckuxrzUaDaKjoxEdHY2bN28iICCg2+O6q/4n87MSxJrblvqEjlPklpz28nHbFCOzKdplX1uuXfa1ZdqVYmZT7C+VNo3107sPgnrswoULJpsz3Nj2HpxyurfPYcnMHW1KLbcUM3e0KbXcUszc0ebj5JZi5o7nkNrxYS4sBGROjAMzMDDwsdoV680kxdxSzNzRrtRySzFzR7u9bVuKmTv2742Kqu/g5zuo02Nj2+yrhQCHBoiIiIyQuiEdaSmLOj2WOl4sSEREJGMsBIiIiGSMhQAREZGMsRAgIiKSMRYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYyxECAiIpIxFgJEREQyxkKAiIhIxlgIEBERyRgLASIiIjPLzc2Fv78/hg8fjoULF0Kr1YodSYeFABERkRndv38fCxcuxIEDB3D16lU0NjZiz549YsfSYSFARERkRkVFRRg8eDBGjx4NAPj1r3+NgwcPipzq/9mKHYCIiKivaW1tQ2XN952WX6ms7vKxq8IZ7m7KLp+ruroaPj4+up99fX1x48YNE6Z9PCwEiIiIHmJra4PsMyWorNYvBjL2H+v02ArA0vnTH/lcgiDAyspK7+e+hEMDRERED7GyskLi5HBYGd4UwQGj4OXh/sj1Pj4+qKqq0v1848YNeHt7myClabAQICIi6oK350AEjXmq223s+9khbmJwt9sEBwejpqYGX3/9NQAgIyMD06c/+gyCpbEQICIiegT1xBD0s3v0KHpM+DNwfqJ/t89hY2ODv/71r/jFL36BYcOGwcnJCXPnzjV11F6zEvraYAUREVEfklNwHse/LOq03E3pjBULZ8DOVtqX2/GMABERUTcig8fCReHUaflzMaGSLwKAPlQI7Nu3D1FRUVAoFLDtomMNrTcFrVaL1atXY+DAgXB2dkZycjLq6urM0hYREUmDnZ0tnleF6i0b6jMIY54aKlIi0+ozhYCrqyuWLFmCLVu29Gq9KaSlpSErKwuFhYWorm6/P7QvjeMQEZE4xo7yw5PengDabxdMnByud0uglFm8EDhz5gzUajU8PDzg4uKCGTNmAADUajVmzZoFPz+/LvcztN4U0tPTkZKSAj8/PyiVSmzcuBEajQaVlZVma5OIiPq+B28nHB8wstvbBaXGooMbBw8exKJFi5Ceno7ExETcu3cPZ8+eNUtbaWlpyMzMRGlpqVHb37p1C1VVVRg/frxu2bBhw6BQKFBaWoonn3zSLDk7pG5IN+vzExGRaRSXXkZx6WWxY/RIWsqiR66zWCHQ1NSExYsX4/3330dycjIAwN7eHmq12iztpaamIjU11ejtGxsbAQBKpf4UkS4uLrp15tTdfxIREfUND88S+FNgsaGBvLw8WFlZYc6cOZZqskecnZ0BtJ8ZeFBDQwMUCoUYkYiIqI/5qRUBgAXPCNTV1cHV1bXPdqKLiwt8fX1RUlKCwMBAAEBFRQUaGxsREBBg9vY5NEBERObSJ4YGxo8fj2vXruGLL75AQkICGhsbUVhYqBsa0Gq1aG1txb179wAAzc3NANqHD6ysrAyuN4VFixZhw4YNiImJwYABA5CSkgK1Wm326wMADg0QEZE4LDY04O/vj+3bt+ONN96AQqHA008/jS+//FK3fvfu3XB0dIRarYZWq4WjoyMcHR1x/fp1o9Y/bP369fD39+9RxtTUVEyZMgUhISHw8vKCVqvFnj17ev+iiYiI+jhOMUxERCRjfWZCISIiIrI8FgJEREQyxkKAiIhIxlgIEBERyRgLASIiIhljIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDLGQoCIiEjGWAgQERHJGAsBIiIiGWMhQEREJGMsBIiIiGSMhQAREZGMsRAgIiKSMRYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYz9H0CNc+qii8ZVAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the circuit using a noise free simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:14\n", + "{'0': 252, '1': 748}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# noise free simulation (NFS)\n", + "mode = \"NFS\"\n", + "\n", + "# run the quantum neural network program\n", + "\n", + "shots = 1000\n", + "job_noisefree = execute(qprog, backend_sim, shots=shots)\n", + "\n", + "noisefree_count = job_noisefree.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(noisefree_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(noisefree_count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, ' + mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity in noise free device simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84c5beb68c774d79b3740bcbc5c00d32", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:18\n", + "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: NFS theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.999933478085305\n" + ] + } + ], + "source": [ + "# Execute state tomography using noise free quantum device simulation\n", + "mode = \"NFS\"\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "\n", + "my_state_job = execute(my_state_tomo_circuits, backend_tomo, shots=shots)\n", + "job_monitor(my_state_job)\n", + "my_state_tomo_result = my_state_job.result() \n", + " \n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### From here, you need credentials:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "IBMQ.load_accounts()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibmq_16_melbourne ibmqx4\n", + "----------------- ------\n", + "Num. Qubits: 14 Num. Qubits: 5\n", + "Pending Jobs: 65 Pending Jobs: 469\n", + "Least busy: True Least busy: False\n", + "Operational: True Operational: True\n", + "Avg. T1: 53.7 Avg. T1: 52.1\n", + "Avg. T2: 73.0 Avg. T2: 17.2\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "backend_overview() # you may skip running this cell if you want" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibmq_16_melbourne\n" + ] + } + ], + "source": [ + "# Make your choice of real device\n", + "#backend_real = least_busy(IBMQ.backends(operational=True, simulator=False))\n", + "#backend_real = IBMQ.get_backend('ibmqx4')\n", + "backend_real = IBMQ.get_backend('ibmq_16_melbourne')\n", + "print(backend_real)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prepare noise simulation corresponding to a given quantum device" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: ibmq_16_melbourne\n", + "noise model prepared for ibmq_16_melbourne\n" + ] + } + ], + "source": [ + "# Prepare device noise simulation (DNS)\n", + "\n", + "device = backend_real\n", + "print(\"device: \", device)\n", + "properties = device.properties()\n", + "coupling_map = device.configuration().coupling_map\n", + "prepared = False\n", + "if device.name() == 'ibmq_16_melbourne' :\n", + " gate_times = [\n", + " ('u1', None, 0), ('u2', None, 100), ('u3', None, 200),\n", + " ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),\n", + " ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),\n", + " ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),\n", + " ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),\n", + " ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773),\n", + " ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)\n", + " ]\n", + " prepared = True\n", + " \n", + "elif device.name() == 'ibmqx4' :\n", + " gate_times = [\n", + " ('u1', None, 0), ('u2', None, 60), ('u3', None, 120),\n", + " ('cx', [1, 0], 340), ('cx', [2, 0], 424), ('cx', [2, 1], 520),\n", + " ('cx', [3, 2], 620), ('cx', [3, 4], 420), ('cx', [4, 2], 920) \n", + " ]\n", + " prepared = True\n", + "\n", + "else :\n", + " print(\"No gate times yet defined in this notebook for: \", device)\n", + " \n", + "if prepared :\n", + " # Construct the noise model from backend properties and custom gate times\n", + " noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times)\n", + "\n", + " # Get the basis gates for the noise model\n", + " basis_gates = noise_model.basis_gates\n", + " \n", + " print(\"noise model prepared for\", device)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the algorithm using device noise simulation (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a02d100572e04c87b3878627bbd4ea4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 10/02/2019 10:18:47\n", + "{'0': 282, '1': 718}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute test using device noise simulation (DNS)\n", + "\n", + "backend_noise = Aer.get_backend('qasm_simulator') # for simulation (DNS)\n", + "\n", + "shots = 1000\n", + "mode = \"DNS\"\n", + "job_noise = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + "job_monitor(job_noise)\n", + "\n", + "print(job_noise.status)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "noisy_count = job_noise.result().get_counts(qprog) \n", + "print(noisy_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(noisy_count, color=['cyan'],\n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity in device noise simulation (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f59dbc091124a85ab97e057c39613ed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:51\n", + "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: DNS of ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.8969037947087841\n" + ] + } + ], + "source": [ + "# Execute state tomography using device noise simulation (DNS)\n", + "\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'. \n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "mode = \"DNS\"\n", + "my_state_job = execute(my_state_tomo_circuits, backend_tomo, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + "job_monitor(my_state_job)\n", + "my_state_tomo_result = my_state_job.result() \n", + "\n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, \"of\", device, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the algorithm on superconducting quantum computing device (SQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "55ddd53def4b48c588550d1a5dbdf1db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 10/02/2019 11:34:17\n", + "{'0': 309, '1': 715}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAccAAAFCCAYAAACEgRbZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X2clXWd//HXu+FGIO4GEWYkQARpuFkaIW9XslUKaO3noquZm1qZq5bWWllullqt7WoWappllqnVkobbllGEmPfpBoSAyAojEDIRDAQIyODs5/fHdQ0eLmaYOXDmHJh5Px+Pecw53+t7Xedzbua85/ped4oIzMzM7E1vKXUBZmZmBxuHo5mZWYbD0czMLMPhaGZmluFwNDMzy3A4mpmZZTgcregk/U7Sxc1MGyzpNUllxa6rPZB0iqRlOfdXSjq9lDUd7CRdL+mB9PZQSSGpU6nrstJyOHZQkj4h6Q+Sdkq6t9T1NIqI1RHx1ohogH0HaSNJXSV9TdJqSTskvSzpM5KU0+d3kl6X9LacttMlrcy5v1LSOkk9ctoulvS71tQuqYukWyStSQP+FUnfzPS5SNIiSdsl/VnSnZJ6Z/ocI+lBSRskbZb0gqSrWvMPQ0Q8GREjW1NvsbT0WZPUPX0dGp/vEyUo02wPDseOay3wVeD7pS6kAB4ETgOmAj2BDwH/DNyS6bcN+GILy+oEfHI/67gGmAAcl9bxbmBB40RJnwb+A/gs0Bs4ARgKzJbUOe1zNPAc8CdgbET0Bv4xXW7P/ayr1Fr6rH0XKAeq0t//UqS6SsqjIwe5iPBPB/4h+dK6dz/mmwS8BGwGvgU8DlycTrseeCCn71AggE7p/d8BXwOeT+f/OVCe7Qv8G9AAvA68BnyriTpOS6e/LdN+fDrvsJzHvA7YCgxP204HVubMsxL4PLAR6JO2XQz8rpWvyS+BTzUzrVf6HM7JtL8V+AtwYXr/AeCRA3g/TwXWZJ7TNcCLwCbgB8BhuX2Bq9MaaoEzSf7J+N/0dfjXnGV1A+5Nl/MiScivyaO2vT5rwEhgC9Arz+d5L3AnMCt9XZ8GBgLT0/peAqpz+lcCPwPWA68AV+ZM2/15zfn8XUIS6rXAp3P6dk0fY236Mx3omk67CHgqU2fkfN7uBb4N/IrkH7XT07Y7gEfSz+ZzwNE5878d+G36XizLfn7803Y/XnO0vEk6nOSL5lrgcGAFcHKei7kA+AjJl9YbwG3ZDhHxBeBJ4BORDLV+oonlTAKei4g/ZeZ9juSL/7Sc5leBu0m+DJvzB5Ig/Uxrn0iO3wNXSbpc0tjcYV3gJOAwYGamztdIvuDfkzadDjy0rwdJh1k/mEdd5wPvBY4GjiF53xoNTOs6EvgSyevzT8B44BTgS5KGpX2vS5dxdLq8C/OooTnHA6uAG9Jh1UWSzmrlvOfw5mdwJ/AsMD+9/xDwDQBJbwF+ASwkeZ6nAZ+S9N59LPvdwAiS9+XzOdttv0Cyxv8OYBzJKMG1TS6haR8k+aevJ/BU2nYecAPQF1ieTicd3v8t8GPgiLTfnZJG5/F4tp8cjrY/pgIvRsRDEbGL5L/nP+e5jPsjYnFENA51nrOfw0yHk/x335RaoH+m7WvAGS18wXwJuEJSdt6WfI1k2PR8kpB9VVJjgBwObIiIN1qosx/NPx8AIuJvIuLHedT1rYj4U0RsJPniPS9n2i7g39L38T/TOm+NiK0RsQRYAvxN2vectO/G9J+Rvf6h2Q+DgDEkIwiVwCeAH0qqasW8D0fEvIh4HXgYeD0i7otke/UMoDrt906gf0R8OSLqI6KG5J+AD+xj2TdExLaIWESytt34mp0PfDki/hIR60lC7UN5PN+fR8TTEfF/ad0AMyPi+fSz8SOS4AX4e5KRjR9ExBsRMZ/kn9Kz83g8208OR9uLpFnpDiWvSTq/iS6VJNvEAIiIyL3fSrn9VwGdSb6Y87UBqGhmWgXJMNpu6Rfat4AvN7fAiFhMMkT6+XwKiYiGiLgjIk4G+pAE0ffTL/oNwOHN7AWZW2cdzT+f/ZV9rStz7telYQKwI/29Lmf6DpKhX8i87+myDtQOkoD+ahpcjwOP8eaa9L5k62yu7iFApaS/Nv4A/woM2Meym3vNKtnzeWdfz5Y09XeS+4/l9kzdx2fqPp9kbd/amMPR9hIRU9JhzLdGxI+a6FIL5O71qdz7JNtTuufcb+qPObf/YJIvyA1NldNCuXNIvkByl4ek49LlNrXn480kw2bj97Hc64CPkQzD5S0idkTEHSTbv0aRDPntBKZl6uwBTCHZZgvJ82ntsGJrZV/rtfu5nD3e93RZB+qFAiyjJX8CXomIPjk/PSNi6j7mae41W0sSWk1N2+NzL6mpz30+l0H6E/B4pu63RsRleSzD9pPDsYOS1EnSYUAZUCbpsDyO7XoEGC1pWjrPlewZgH8EJqbHLPYm2SEk658kjZLUnWQt7qGcNZhc64BhTbQDEBFzgEeBn0kaLalM0gkkw1P3RcSyJub5K8merFfvY7nLSYbmrsxtTw8Jub6peSR9StKpkrqlr++FJNuWFkTEZpIhuNslTZbUWdJQkj1tN6T1QhLKJ0m6ufHLVdJwSQ9I6tNcvS34uKRBkspJ1phm7OdyfgpcI6mvpEHAFa2ZqYXP2hPA6nS5nSSdTLKj0G/2s8amPA9skfS59L0pkzRG0jv3Mc8X00NMRgMf5s3X7CfAtZL6p9vev0SyExUk2zRHS3pH+nyvP8C6fwkcI+lD6eels6R3Ng45p4cFrTzAx7BmOBw7rmtJhp4+T7IDxg5auWNBRGwgObzg30mGAUeQ7C3YOP23JF8mLwDzSP7Is+4n2VPvzyQ7hFzZRB+AW4GzJW2S1Nw2rrNIhuJ+TbLn6rPp7Uv28TRuJdmbdV++DPTItL2NnOeasYMkdP9MEngfB85Kt3ERETeRhNPXSfZMfIVkTeP0dNsrEbECOJFkr8klkjaTbGf6QzoPkpY0M9zdnB8Ds4Ga9Oerecyb6waSYcRX0uXd38r5mv2spds6/x/JduzNJNsCL4iIl/azxr2k/3SdQbIt7xWS9+Z7JIfTNOdxkp1jHgW+HhGz0/avkrwXLwCLSHYA+mr6OP9L8pmZA7zMmzvc7G/dW0mGlz9Asnb6Z5Jt2l3TLvv6LNoBUrK5yOzAKDlQ/oGI+N5BUMsPSYZDp0ZEfQGXOwh4MCJOLNDyPkISOCdHxOpCLLOYJJ1K8p4PKnUtHZGk2cAnI2JpqWtpj3yKJGuPLgauAo4lObyiICJiDclaXaGW931Ju0gO8zjkwtFKKyJas9OS7SeHo7U76VDdf5S6jtaIiNYOTR60JA0mOSlAU0bt71qxpCXsufNLo39uZkcxs4LxsKqZmVmGd8gxMzPLcDiamZlltNttjv369YvBgwtxjLKZmbUXf/zjHzdERIunhmy34Th48GDmzp1b6jLMzOwgUl5e3qrTHnpY1czMLMPhaGZmluFwNDMzy3A4mpmZZTgczczMMhyOZmZmGUUPR0mXS3pF0uuS5kk6pYX+H5T0R0nbJf05va6dr4RtZmZtpqjhKOlckuvo3QhUA88As9ITFzfV/2SSa8b9EBgNnElyVXWfdNjMzNpMsdccrwLujYi7I2JpRFwB1AKXNdP/RGBNRHwzIl6JiN8DtwPHF6leMzPrgIoWjpK6AONJriCeazbJ9eya8jRQIekMJQ4nuSr2r9quUjMz6+iKefq4w4EyYF2mfR1welMzRMSzks4jGUbtRlLvb4ELm+ov6RLgEoCKigrmz58PQGVlJd27d2f58uUA9O7dm2HDhrFgwQIAysrKGDduHMuWLWPbtm0AVFVVsXHjRtatS8odNGgQXbp0oaamBoC+ffsyePBgFi5cCEDnzp0ZO3YsS5cuZceOHQCMGjWK9evXs379egCGDBmCJFauXAlAv379qKioYPHixQB07dqV0aNHs2TJEnbu3AnAmDFjqK2tpa6uDoChQ4cSEaxalZwBqX///vTv358XX0wup9etWzeqqqpYtGgRu3btAmDcuHGsXr2aTZs2ATBs2DDq6+tZs2YNAAMGDKC8vJylS5MLivfo0YORI0eycOFCGhoaAKiurqampobNmzcDMHz4cLZv387atWtpfL179erFsmXLAOjZsycjRoxgwYIFRASSqK6u5uWXX2br1q0AjBw5ki1btlBbW+v3ye+T3ye/T0V5n1qraNdzlFQJvApMjIgnc9qvA86LiLc3Mc8okjCcDvwGqABuBv4YERfs6/Gqq6vD51Y1M7Nc5eXl8yJiQkv9irnmuAFoALJ7mh7B3muTja4Bno+Im9P7L0jaBjwp6QsR8ae2KdXMzDqyom1zjIh6YB4wKTNpEsleq03pThKouRrvq3DVmZmZvanYl6z6BnC/pOdJdra5FKgE7gKQdB9AzpDpL4C7JV3Gm8Oq04H5EbG6yLWbmVkHUdRwjIgZkvoB15IE3WJgakQ0Xl9rcKb/vZJ6Ap8AbgE2A48BVxevajMz62iKfrHjiLgTuLOZaac20XY7ybGNZmZmReFzq5qZmWU4HM3MzDIcjmZmZhkORzMzswyHo5mZWYbD0czsIDBnzhyOO+44xo8fz/Tp05vs8/DDD3PCCSdw4okn8rGPfWx3+/XXX89JJ53ESSedxMyZM3e3P/7445x66qlMnDiRKVOm7D5HqrWs6IdymJnZnhoaGrj66quZOXMmlZWVnHbaaUyePJm3v/3NU06vWLGC6dOn8+tf/5o+ffrsPrH37NmzWbhwIU888QQ7d+7kjDPO4PTTT6dXr1585jOf4YEHHmDkyJHcc8893HLLLdxxxx2lepqHFK85mpmV2Lx58zjqqKMYOnQoXbp0Ydq0acyaNWuPPvfddx8f/ehH6dOnD5BcmQLgpZde4uSTT6ZTp0706NGD0aNH8+ijjwIgafdVO7Zs2cLAgdlTW1tzHI5mZiVWW1vLkUceuft+ZWXl7ktPNVqxYgUrVqxg8uTJTJo0iTlz5gDJ5Z3mzJnD9u3bqaur46mnnuLVV18F4NZbb+Xcc89l9OjRzJgxg09+8pPFe1KHOA+rmpmVWFOXDpT2vLbCG2+8QU1NDb/4xS9Yu3YtU6dO5ZlnnuHv/u7vWLBgAZMnT6Zfv368853vpFOn5Kv929/+NjNmzGDChAncdtttXHvttdx2221FeU6HOq85mpmVWGVl5e61PYC1a9fuNQRaWVnJlClT6Ny5M0OGDGHEiBGsWLECgE9/+tM88cQTPPzww0QERx99NBs2bGDx4sVMmJBcunDatGk8//zzxXtShziHo5lZiR177LHU1NSwatUq6uvrmTlzJpMnT96jz9SpU3nqqacAqKurY/ny5QwdOpSGhgY2btwIwJIlS1iyZAnvfve76dOnD1u2bGH58uUAPPbYYxxzzDHFfWKHMA+rmpmVWKdOnbjppps4++yzaWho4Pzzz6eqqoobb7yR6upqpkyZwmmnncZjjz3GCSecQFlZGTfccAPl5eW8/vrrTJ06FYCePXvyne98Z/ew6vTp07nwwgt5y1veQp8+fbj9dl/DobXU1Fh3e1BdXR1z584tdRlmZnYQKS8vnxcRE1rq52FVMzOzDIejmZlZhsPRzMwsw+FoZmaW4XA0MzPLcDiamZllOBzNzMwyHI5mZmYZDkczM7MMh6OZmVmGw9HMzCzD4WhmZpbhq3KYWbvSd1Z5qUuwNrBpysaiPp7XHM3MzDIcjmZmZhkORzMzswyHo5mZWYbD0czMLMPhaGZmluFwNDMzy3A4mpmZZTgczczMMhyOZmZmGQ5HMzOzDIejmZlZhsPRzMwsw+FoZmaW4XA0MzPLcDiamZllOBzNzMwyHI5mZmYZDkczM7MMh6OZmVmGw9HMzCzD4WhmZpbhcDQzM8twOJqZmWU4HM3MzDIcjmZmZhkORzMzs4yih6OkyyW9Iul1SfMkndJC/y6SvpzOs1PSaklXFqteMzPreDoV88EknQvcClwOPJX+niVpVESsbma2nwBvAy4BXgYGAN2KUK6ZmXVQRQ1H4Crg3oi4O71/haTJwGXANdnOkt4DnA4cHREb0uaVxSjUzMw6rqINq0rqAowHZmcmzQZOama2M4H/Aa6StEbSy5Juk/TWNizVzMw6uGKuOR4OlAHrMu3rSNYOmzIM+FtgJ3AW0Ae4HagEzs52lnQJyfArFRUVzJ8/H4DKykq6d+/O8uXLAejduzfDhg1jwYIFAJSVlTFu3DiWLVvGtm3bAKiqqmLjxo2sW5eUO2jQILp06UJNTQ0Affv2ZfDgwSxcuBCAzp07M3bsWJYuXcqOHTsAGDVqFOvXr2f9+vUADBkyBEmsXLkSgH79+lFRUcHixYsB6Nq1K6NHj2bJkiXs3LkTgDFjxlBbW0tdXR0AQ4cOJSJYtWoVAP3796d///68+OKLAHTr1o2qqioWLVrErl27ABg3bhyrV69m06ZNyYs6bBj19fWsWbMGgAEDBlBeXs7SpUsB6NGjByNHjmThwoU0NDQAUF1dTU1NDZs3bwZg+PDhbN++nbVr19L4evfq1Ytly5YB0LNnT0aMGMGCBQuICCRRXV3Nyy+/zNatWwEYOXIkW7Zsoba21u+T36eCvU/WPtXV1RXk76m1FBEFfgrNPJBUCbwKTIyIJ3ParwPOi4i3NzHPbOAUYGBEbE7b3gP8Jm3LBu1u1dXVMXfu3AI/CzM72PWdVV7qEqwNbJqysSDLKS8vnxcRE1rqV8y9VTcADcDATPsR7L022agWeLUxGFNL09+DC1uemZlZomjhGBH1wDxgUmbSJOCZZmZ7GqjMbGM8Jv29qrAVmpmZJYp9nOM3gIskXSypStKtJNsP7wKQdJ+k+3L6/xioA34gabSkk0kOBXkoIv5S5NrNzKyDKOqhHBExQ1I/4FqgAlgMTI2IxrXAwZn+r0k6nWQnnP8BNgH/BXy+eFWbmVlHU+zjHImIO4E7m5l2ahNty4D3tHFZZmZmu/ncqmZmZhkORzMzswyHo5mZWYbD0czMLMPhaGZmluFwNDMzy3A4mpmZZTgczczMMhyOZmZmGQ5HMzOzDIejmZlZhsPRzMwsI69wlHSOpPfk3P+SpDWSfiOpovDlmZmZFV++a47XN96QdCzwr8BtQGfglsKVZWZmVjr5XrJqCLAsvf0PwH9FxE2SZgO/KWhlZmZmJZLvmuPrQM/09mnAnPT25px2MzOzQ1q+a45PArdIegqYAJydth8D/KmQhZmZmZVKvmuOnwDqSULx0ohYm7ZPwcOqZmbWTuS15hgRa4Azmmj/VMEqMjMzK7G8j3OUdJiksyV9TlKftO1oSeWFL8/MzKz48lpzlDScZCectwJ9gAeBvwKXpfcvLnSBZmZmxZbvmuN0YDYwANiR0/7fwLsLVZSZmVkp5bu36knACRHRICm3fTVQWbCqzMzMSmh/zq3auYm2wSTHOpqZmR3y8g3H2cBVOfdDUi/gBuCRglVlZmZWQvkOq14FPCZpGXAYMAMYDqwDzilwbWZmZiWR73GOayW9AzgPOJZkzfO7wI8iYsc+ZzYzMztE5LvmSBqC309/zMzM2p0Ww1HSNOAXEbErvd2siJhZsMrMzMxKpDVrjg8BA4G/pLebE0BZIYoyMzMrpRbDMSLe0tRtMzOz9iqvsJM0UdJegSqpTNLEwpVlZmZWOvmuCT4GNHWC8T7pNDMzs0NevuEokm2LWf2AbQdejpmZWem16lAOSf+d3gzgAUk7cyaXAWOAZwpcm5mZWUm09jjHuvS3gE3seUWOeuAp4O4C1mVmZlYyrQrHiPgwgKSVwNcjwkOoZmbWbuV7+rgb2qoQMzOzg0VrzpDzAvCuiNgkaRFN75ADQET8TSGLMzMzK4XWrDn+DGjcAWdfZ8gxMzNrF1pzhpwbmrptZmbWXvl0cGZmZhmt2ea4z+2MubzN0czM2oPWXpXDzMysw8hrm6OZmVlH4G2OZmZmGT7O0czMLMPHOZqZmWX4OEczM7OMvM6t2kjS0UBVendpRKwoXElmZmallVc4SuoH3AO8H/i/N5v1S+AjEVHX7MxmZmaHiHz3Vv0eMBw4BTgs/ZkIHIWv52hmZu1EvsOq7wVOi4hnc9qelvTPwJzClWVmZlY6+a45rgeautDxdsBDqmZm1i7kG45fBqZLOrKxIb19SzqtRZIul/SKpNclzZN0Sivn+1tJb0hanGfNZmZmedmfE48fBayU9Gp6/0jgdeAIkm2S+1rWucCtwOXAU+nvWZJGRcTqfczXF7gPeDR9PDMzszZT7BOPXwXcGxGNO+9cIWkycBlwzT7muwf4ISDg7ALWY2ZmtpeinXhcUhdgPPD1zKTZwEn7mO9yYCDwj8AXC1GLmZnZvuzXSQD20+FAGbAu074OOL2pGSSNBa4DToiIBkn7fABJlwCXAFRUVDB//nwAKisr6d69O8uXLwegd+/eDBs2jAULFgBQVlbGuHHjWLZsGdu2JfsbVVVVsXHjRtatS8odNGgQXbp0oaamBoC+ffsyePBgFi5cCEDnzp0ZO3YsS5cuZceOHQCMGjWK9evXs379egCGDBmCJFauXAlAv379qKioYPHiZDNq165dGT16NEuWLGHnzuSMfWPGjKG2tpa6umR/p6FDhxIRrFq1CoD+/fvTv39/XnzxRQC6detGVVUVixYtYteuXQCMGzeO1atXs2nTJgCGDRtGfX09a9asAWDAgAGUl5ezdOlSAHr06MHIkSNZuHAhDQ0NAFRXV1NTU8PmzZsBGD58ONu3b2ft2rU0vt69evVi2bJlAPTs2ZMRI0awYMECIgJJVFdX8/LLL7N161YARo4cyZYtW6itrfX75PepYO+TtU91dXUF+XtqLUW06jrGSedk7e8LwHnAYKBz7vSIKNvHvJXAq8DEiHgyp/064LyIeHumf1dgPvDvEXF/2nY9cHZEjGmp1urq6pg7d24rn5mZtRd9Z5WXugRrA5umbCzIcsrLy+dFxISW+uW7t+pXgAtJ9k79P+CzwB0kh3Fc3sK8G4AGkiHSXEew99okQAUwCvhBupfqG8CXgNHp/ffkWbuZmVmr5BuO5wCXRsR3SILu5xFxJcnQ56R9zRgR9cC8JvpNAp5pYpZXgbHAO3J+7gKWp7ebmsfMzOyA5bvNcQDwYnr7NaBPevvXwH+0Yv5vAPdLeh54GrgUqCQJPSTdBxARF0TELmCPYxol/QXYGRE+1tHMzNpMvuG4miTMVpOswb2XZG3wRGBHSzNHxIz05OXXkgybLgamRsSqtMvgPOsxMzMruHzD8WHgNOD3JAfz/0TSx0gOzL+5NQuIiDuBO5uZdmoL814PXN/qas3MzPZDXuEYEdfk3H5I0hqSYxT/NyJ+WejizMzMSuGAjnOMiN+TrEWamZm1G/nurYqkYyXdJ+kP6c/9ko5ti+LMzMxKIa9wlHQ+8D8kO9P8Kv0ZADwv6Z8KX56ZmVnx5Tus+m/AFyPixtxGSdcAXwUeKFRhZmZmpZLvsGp/4KdNtD9IcqYbMzOzQ16+4fgYcGoT7acCjx9oMWZmZgeD1lzseFrO3VnA1yRN4M29VE8ApuHjD83MrJ3Y34sd7740VI7baebgfjMzs0NJay52nPfhHmZmZocyB187NmfOHI477jjGjx/P9OnT95r+gx/8gJNPPpmJEycyZcoUXnrppd3TvvnNbzJ+/HiOO+44Hn30UQDWrFnD+9//fo4//nhOPPFE7rrrrqI9FzOzYtqfkwC8T9ITkjZIWi/pcUlT26I4238NDQ1cffXV/PSnP+XZZ5/lZz/72R7hB3DWWWfx9NNP88QTT3DllVdy7bXXAvDSSy8xc+ZMnnnmGR588EE++9nP0tDQQKdOnfjKV77Cc889x+zZs7nnnnv2WqaZWXuQ70kALiY5+fgK4HPA54FXgIclfaTw5dn+mjdvHkcddRRDhw6lS5cuTJs2jVmzZu3Rp1evXrtvb9++HUkAzJo1i2nTptG1a1eGDBnCUUcdxbx58xg4cCDjxo0DoGfPnhxzzDHU1tYW70mZmRVJvicB+BxwVUR8K6ftHknzSILy+wWrzA5IbW0tRx555O77lZWVzJs3b69+3/ve97jzzjupr6/n5z//+e55J0yYsMe82RBcvXo1L7zwAuPHj2+jZ2BmVjr5DqsOJrmwcdYsYMiBl2OFEhF7tTWuGea6+OKLmT9/Ptdffz233HJLq+Z97bXXuPDCC7nxxhv3WPs0M2sv8g3H1cCkJtrfA6xqot1KpLKykldffXX3/bVr1zJw4MBm+0+bNo1HHnmkxXl37drFhRdeyNlnn80ZZ5zRRtWbmZVWvuH4deBWSXdL+rCkiyR9D/hmOs0OEsceeyw1NTWsWrWK+vp6Zs6cyeTJk/fos2LFit23Z8+ezdFHHw3A5MmTmTlzJjt37mTVqlXU1NQwfvx4IoIrr7ySY445ho9//ONFfT5mZsWU78WOvyPpL8CnSc6KA7AUOCcifl7o4mz/derUiZtuuomzzz6bhoYGzj//fKqqqrjxxhuprq5mypQp3H333Tz++ON07tyZPn36cMcddwBQVVXFmWeeyYknnrh7OWVlZfz+979nxowZjBo1iokTJwLwxS9+kUmTmhpMMDM7dKmp7UtNdpQ6kQyfPhcRdW1aVQFUV1fH3LlzS12GmRVZ31nlpS7B2sCmKRsLspzy8vJ5ETGhpX6tHlaNiDeAmUDPAynMzMzsYJfvNseFwPC2KMTMzOxgkW84Xg/cIulMSW+TVJ770wb1mZmZFV2+JwF4JP09E8jdWKn0flkhijIzMyulfMPx3W1ShZmZ2UGkVeEoqTtwM3Am0BmYA1wZERvasDYzM7OSaO2a4w3ARcCPgB3AB4FvA//YNmUdPLxbePtUqN3Czax9am04TgM+GhH/CSDpR8DTksoioqHNqjMzMyuB1u6t+jbgycY7EfE88AZQ2RZFmZmZlVJrw7EMqM+0vUH+O/SYmZkd9FobbgIekLQzp+0w4G5J2xsbIuL9hSzOzMysFFobjj9sou2BQhZiZmZ2sGhVOEbEh9u6EDMzs4NFvqePMzMza/ccjmZmZhkORzMzswyHo5mZWYbD0czMLMPhaGZmluFwNDMzy3CKMC2xAAAIJ0lEQVQ4mpmZZTgczczMMhyOZmZmGQ5HMzOzDIejmZlZhsPRzMwsw+FoZmaW4XA0MzPLcDiamZllOBzNzMwyHI5mZmYZDkczM7MMh6OZmVmGw9HMzCzD4WhmZpZR9HCUdLmkVyS9LmmepFP20XeapNmS1kvaKuk5Se8vZr1mZtbxFDUcJZ0L3ArcCFQDzwCzJA1uZpZ3AXOB96X9fwU8vK9ANTMzO1Cdivx4VwH3RsTd6f0rJE0GLgOuyXaOiE9mmm6Q9D7gTODJNq3UzMw6rKKtOUrqAowHZmcmzQZOymNRPYFNharLzMwsq5hrjocDZcC6TPs64PTWLEDSx4FBwP3NTL8EuASgoqKC+fPnA1BZWUn37t1Zvnw5AL1792bYsGEsWLAAgLKyMsaNG8eyZcvYtm0bAFVVVWzcuJG+eT1FO1QsXbqUHTt2ADBq1CjWr1/P+vXrARgyZAiSWLlyJQD9+vWjoqKCxYsXA9C1a1dGjx7NkiVL2LlzJwBjxoyhtraWuro6AIYOHUpEsGrVKgD69+9P//79efHFFwHo1q0bVVVVLFq0iF27dgEwbtw4Vq9ezaZNyf9+w4YNo76+njVr1gAwYMAAysvLWbp0KQA9evRg5MiRLFy4kIaGBgCqq6upqalh8+bNAAwfPpzt27ezdu1aIPm76NWrF8uWLQOgZ8+ejBgxggULFhARSKK6upqXX36ZrVu3AjBy5Ei2bNlCbW0tcGB/T+vWJX/+gwYNokuXLtTU1ADQt29fBg8ezMKFCwHo3LkzY8eO3a/3ydqnurq6gvw9tZYiosBPoZkHkiqBV4GJEfFkTvt1wHkR8fYW5j+LJBQ/EBH/3dLjVVdXx9y5cw+waug7q/yAl2EHn01TNpa6BGsj/pttnwr1N1teXj4vIia01K+YO+RsABqAgZn2I9h7bXIPOcF4QWuC0czM7EAULRwjoh6YB0zKTJpEstdqkySdAzwAXBQRD7VdhWZmZoli7636DeB+Sc8DTwOXApXAXQCS7gOIiAvS+x8gWWP8DPCEpMa1zvqI8LiYmZm1iaKGY0TMkNQPuBaoABYDUyNiVdole7zjpSQ1Tk9/Gj0OnNq21ZqZWUdV7DVHIuJO4M5mpp26r/tmZmbF4HOrmpmZZTgczczMMhyOZmZmGQ5HMzOzDIejmZlZhsPRzMwsw+FoZmaW4XA0MzPLcDiamZllOBzNzMwyHI5mZmYZDkczM7MMh6OZmVmGw9HMzCzD4WhmZpbhcDQzM8twOJqZmWU4HM3MzDIcjmZmZhkORzMzswyHo5mZWYbD0czMLMPhaGZmluFwNDMzy3A4mpmZZTgczczMMhyOZmZmGQ5HMzOzDIejmZlZhsPRzMwsw+FoZmaW4XA0MzPLcDiamZllOBzNzMwyHI5mZmYZDkczM7MMh6OZmVmGw9HMzCzD4WhmZpbhcDQzM8twOJqZmWU4HM3MzDIcjmZmZhkORzMzswyHo5mZWYbD0czMLMPhaGZmluFwNDMzy3A4mpmZZTgczczMMhyOZmZmGQ5HMzOzDIejmZlZRtHDUdLlkl6R9LqkeZJOaaH/u9J+r0uqkXRpsWo1M7OOqajhKOlc4FbgRqAaeAaYJWlwM/2PAn6V9qsGvgbcLums4lRsZmYdUbHXHK8C7o2IuyNiaURcAdQClzXT/1JgbURckfa/G/gh8Jki1WtmZh1Q0cJRUhdgPDA7M2k2cFIzs53YRP/fABMkdS5shWZmZolirjkeDpQB6zLt64CBzcwzsJn+ndLlmZmZFVynEjxmZO6ribaW+jfVjqRLgEvSu6+Vl5cv268KO67DgQ2lLqI4yktdgFkh+G82f0Na06mY4bgBaGDvtcQj2HvtsNGfm+n/BlCX7RwR3wW+e2BldlyS/hARE0pdh5m1jv9m207RhlUjoh6YB0zKTJpEsjdqU54FTm+i/x8iYldhKzQzM0sUe2/VbwAXSbpYUpWkW4FK4C4ASfdJui+n/13AIEnT0/4XAxcBXy9y3WZm1oEUdZtjRMyQ1A+4FqgAFgNTI2JV2mVwpv8rkqYC3yQ53GMtcGVE/KyIZXckHpI2O7T4b7aNKGJf+8KYmZl1PD63qpmZWYbD0czMLMPhaGZmluFw7OAkjZA0oNR1mJkdTLxDTgck6QjgQ8C/AOtJTqpQCzwE/CwitpWwPDOzknM4dkCS7gVGAb8kOdNQP+AdQBWwBrgpIn5bsgLNbC+SegFbw1/aReFw7GAkCdhKcnzpEzltbwOOBz5Gcu7BcyPijyUr1Mz2IOk7wPPpz6qI2NJEn34RsdepNS1/3ubY8YwCXgHqGxsisToiHgT+niQ8zy1RfWaWIek8kn9cbwF+Dtws6R8kHS2pW9qnG3CPpLElLLXd8JpjB5P+Af0S6A5cAKyIiP/L9LkC+GhEvKMEJZpZhqS7SS7ccBMwDbgQOBpYBvwKeBQYCdwaEV1KVWd74jXHDiYidgBfALoB9wEXSHqbpB4AkroD7yI5tZ+ZlZikTiSjPX+NiJqI+HpEjAXeCTxOEpQ/BW4H7i9dpe2L1xw7KEljgC8C7we2kVwBZT3JVVBqgYsjYlHpKjSzRpL6AgMi4iVJXYBduTvmSDoX+AlwrPcVKAyHYweXHtbxPuBM4HWSNcYHI+KlkhZmZvsk6S0k3+ENkj5GMqTavdR1tRcOR9tN0luy2x/N7OAn6SqgLCJuLnUt7YXD0czsECepM9Dgf24Lx+FoZmaW4b1VzczMMhyOZmZmGQ5HMzOzDIejmZlZhsPRzMwsw+FoZmaW8f8BELNOb4BCSIsAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute test using superconducting quantum computing device (SQC)\n", + "\n", + "#Choose the backend\n", + "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", + "backend_SQC = device # for a real device\n", + "\n", + "# Execute on SQC and get counts\n", + "shots = 1000\n", + "if backend_SQC.name() == \"qasm_simulator\" : # optional test before final experiment \n", + " mode = \"DNS\"\n", + " job_real = execute(qprog, backend_SQC, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + "else: # final experiment on real device\n", + " mode = \"SQC\"\n", + " job_real = execute(qprog, backend_SQC)\n", + " job_monitor(job_real)\n", + "\n", + "print(job_real.status)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "real_count = job_real.result().get_counts(qprog) \n", + "print(real_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(real_count, color=['orange'], \n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity on superconducting quantum computing device (SQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "795f7379498d410c8f29c9757183ae9b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 07/02/2019 22:32:13\n", + "Tomography 1-qubit classifier on ibmq_16_melbourne , shots: 1000 , mode: SQC ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.8859731304253138\n" + ] + } + ], + "source": [ + "# Execute state tomography on superconducting quantum computing device (SQC)\n", + "mode = \"SQC\"\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "#Choose the backend\n", + "#backend_tomo = Aer.get_backend('qasm_simulator') # optional test before final experiment\n", + "backend_tomo = device # for real device\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "\n", + "# loop: 27 circuits maximum per job to avoid exceeding the allowed limit for the real device. \n", + "n_circ = 3**n\n", + "i_max = min(27,n_circ)\n", + "my_jobs = []\n", + "index_job = -1\n", + "for i in range(0,n_circ,i_max) :\n", + " circs =[]\n", + " for j in range(i, i+i_max):\n", + " circs.append(my_state_tomo_circuits[j])\n", + " if backend_tomo.name() == \"qasm_simulator\" : # optional test before final experiment\n", + " mode = \"DNS\"\n", + " my_state_job = execute(circs, backend_tomo, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + " else: # final experiment on real device\n", + " mode = \"SQC\" \n", + " my_state_job = execute(circs, backend_tomo, shots=shots)\n", + " my_jobs.append(my_state_job)\n", + " index_job = index_job + 1 \n", + " job_monitor(my_jobs[index_job], monitor_async = True)\n", + " \n", + " my_state_new_result = my_state_job.result()\n", + " if i == 0:\n", + " my_state_tomo_result = my_state_new_result\n", + " else:\n", + " my_state_tomo_result = my_state_tomo_result + my_state_new_result\n", + "\n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit classifier on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, device, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing NFS, DNS and SQC\n", + "The results mentioned above for the DNS and SQC experiments are illustrated together in the next graphs:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments on ibmqx4 using Qiskit 0.7." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "device_name = device.name()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# !!! Skip this cell if you want to see the results for a new run of the program\n", + "#Date (DMY): 07/02/2019\n", + "device_name = \"ibm_16_melbourne\"\n", + "noisefree_count = {'1': 721, '0': 279}\n", + "noisy_count = {'1': 711, '0': 289}\n", + "real_count = {'1': 695, '0': 305}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqkAAAFCCAYAAADSTUQbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XlcVNX7B/DPcWaAAWZgBpFNFllEWWRxycxcKPc1pTAVK9es1Bbr65ZmqZlr+bUsLZdcUhO01K/lgku2GgIKKgrIIpvIsA/rzPn9MTP8BhgEEoH0eb9evpp777nnPvfe0Z4595xzGecchBBCCCGEtCXtWjsAQgghhBBCaqMklRBCCCGEtDmUpBJCCCGEkDaHklRCCCGEENLmUJJKCCGEEELaHEpSCSGEEEJIm0NJKvlXYIydY4xNr2ebE2OsmDEmaOm4WhNjbBJj7KTeMmeMubdmTG0dY2wnY2yF9vMAxtid1o6JEEKIYZSkkkZjjL3BGPubMVbOGNvZ2vHocM5TOefmnHMVcP+EVocxZswY+5gxlsoYK2WM3WKMzWeMMb0y5xhjZYwxR711zzLGkvWWkxlj2YwxM7110xlj55rzHA3hnO/lnA9+2MdpCsbYR4yxq4yxKsbYBwa2WzPG9jHG8hljeYyxva0QJiGEkH8BSlJJU2QAWAFge2sH0gy+B/AMgOEAJABCAcwCsL5WuRIA7zdQlxDAvOYO8F8qAcB7AI7Xsz0cQBYAZwAdAKxrobhaDdOgf2sJIaSJ6B9O0mic83DO+REAuf9kf8bYIMbYDcZYAWNsM2PsvK7FkzH2AWNsj15ZF+3ja6FeFW6Msb+0+//AGJPXLssYWwngaQCbtV0ANhuI4xkAgwGM55zHcs6rOOd/AJgMYB5jzFWv+CYALzbwGH0tgPmMMctGXofRjLE4bWviOcZYV71tydoW3Sva8zzAGDOpp56XGWMXa60ezhhLYozdY4yt1SVH2rK/MsY2ao+bxBjro12fxhi7yxh7Sa9uK8bYj4yxQu01/8jAsergnO/inJ8AUGQg3sEAHAG8yzkv4JxXcs6jGnG9zjHGVjDGftPe06Pa+PZq47vEGHPRK9+FMXaKMaZgjMUzxl5ooP5F2uuVzBibpLfegjH2LWMshzGWwhhbonc97/t91ca8kjH2KwAlAFftuo+096GIMXaSMdZer47e2nPMZ4zFMMYGNHRtCCHkUUZJKmkR2v8ZhwFYAqA9gEQATzWxmikApgKwB1AFTQJZA+d8MYBfALyh7QLwhoF6BgH4k3OeVmvfPwHcgaaFVScdwDYAH9wnrr8BnAMwv6ETYIx1BvAdgDcBWAP4H4CjjDEjvWIvABgKoBOAbgBebqhePc8B6AEgEMAYaK6XzhMArgCwArAPwH4APQG4Q5Ogb2aMmWvLfg6gDICdtg79ev6p3gDiAexijOVqk8v+jdx3AjSt3Q4A3AD8DmAHADmA6wCWAQDTdLs4Bc35dQDwIoAvGGPe9dRrC8330QHASwC2MsY8tdv+C8ACgCuA/tB8/15p9Nlq4p0JTUt9inbdRG0dHQAYQfudYYw5QNP6vEJ7TvMBhDHGrJtwPEIIeaRQkkpaynAA1zjnhzjnlQA+heaxb1Ps1rZ86h7Bv8D+2WCp9gAy69mWCU3yqO9jAKPuk+gAwFIAcxqRVIQAOM45P6W9DusAiAH00SuziXOewTlXADgKwL+BOvV9wjlXcM5TobnGL+ptu80536Htu3sAmlbNDznn5ZzzkwAqALhrr+l4AEs55yWc81gAu5oQQ306QtOCfRaa5HA9gB/0WxPvYwfnPJFzXgDgBIBEzvlpznkVNF03ArTlRgJI1p5nFef8MjQ/joLvU/f72mtwHppEUfe9CgGwkHNexDlP1sYb2oTz3ck5j9PGUal3Hjc556UADuL/7+1kAP/jnP+Pc67mnJ+C5sfP8CYcjxBCHimUpJJmwRg7oX0UW6z/yFSPPYDqlkvOOddfbiT98ikARNAknE11D5oWQkPsAOTor+Cc5wDYDODD+irUJnLHACxo4Nj2+P9WNXDO1dCcl4NeGf3kXQnAHI1X+xrZ6y1n630u1R6/9jpzaJJ0oYG6HlQpNAnkN9pH/fu1x2hMi3rtOA3FDWj6uj6hfWSezxjLBzAJmqTYkDztjx4d3TVrD01LZ0qtbfr3qSGGvt/13VtnAM/Xirsv6v+eEkLII4+SVNIsOOfDtI/XzTnnhkZsZ0LTcgdAM5hEfxmaAUqmesuGkgr98k4AKqFJOOuE00C4p6FJZPTrA2Osl7beCwb2WQtgIIDu96l3GYAZuH8ikwFNQqI7pu46pDcQc2PVvkYZ/6COHGi6U9Su60FdQcP35kGlATjPObfU+2POOZ9dT3kZ05uZAf9/ze5B8/1yrrVNd58a831tyrmmQfOkQD9uM8756ibUQQghjxRKUkmjaQcmmQAQABAwxkxYzYFN93McgDdjbJx2n7mo+T/2aAD9mGbOUwsACw3UMZkx5sUYM4WmVfOQbtqpWrKh6UdoEOf8NIAz0PT582aMCRhjvQHsBfAt5zzewD750Dzufe8+9SZA8xh9bn1loHnEO4Ix9gxjTATgHQDlAH67zz5N8S5jTKZNwOdp42kS7TUNB/ABY8yUMeYFTX/NBjHGRNrvSDsAQu13RNcl4zA0SeFL2mseDE1C/2tTY7yPYwA6M8ZCtbGIGGM9md7gNAOWM8aMGGNPQ9Nd4HvtNTgIYCVjTMIYcwbwNgDdYKnGfF+bYg80XUqGaK+NCdPM49rxAeslhJB/LUpSSVMsgebR6gJo+tCVatc1iHN+D8DzAFZDMzuAB/SSE20fvAPQtLZFQpNs1LYbwE5oHpmaoP5k8DMAwUwzD2edwVVa46HpG/kTNAOEftd+nnmf0/gMgKGkWN+HAMzq26hNgCdDMyjnHoBRAEZxzisaqLexfoDm+kVD88Pgm39YzxvQPIrOguaa72jkftug+V68CGCx9nMoAGj72I6GZlBQATTfozHa70az4JwXQdPvdQI0LaJZAD4BYFzPLlkA8rRl9wJ4lXN+Q7ttDjQtpkkALkIzGGu79jiN+b42Je40aAa6LYKmJTsNwLugf6MJIY8xpukaSEjLY5oJ7/dwzr9uA7HsgqZVb3gzJoyPDMbYywCmc877tnYshBBCHg/0K50QjenQTF0U2NqBEEIIIUQzgpeQx552iqBPWjuOtk7bb/OEoW2c86bMQlC73uJ6Ng3jnP/yT+slhBDy70WP+wkhhBBCSJtDj/sJIYQQQkibQ0kqIYQQQghpcx7ZPqlWVlbcyak55h8nhBDyqIiOjr7HOa9+fXFkZGQHoVD4NQAfUMMNIS2JM8YKVCrVDrVavaV79+51ZtZ5ZJNUJycnREREtHYYhBBC2hC5XF7jFb9CofBrW1vbrtbW1nnt2rWjQRqEtBDOOSoqKkQZGRlzCgsLA2HgpTH0q5EQQsjjzMfa2rqQElRCWhZjDMbGxpXOzs4FAAzOwU1JKiGEkMdZO0pQCWk92r9/AoPbWjgWQgghhBBCGkRJKiGEEELw+uuvO3z44YcdmqOuW7duGZmamgZUVVU1R3XVvv32W0tbW9tupqamAb/++qu4WStvAnd3d+9jx45Jmrve+Ph4I8ZY98rKyn+0/4IFC2xDQkKcHzSOP//8UxwQENDlQet5UI/swClCCCHkn1jOlnd/mPUv48siG1POwcHBt6ysrN3t27evSqVSNQBs2LCh/f79+63++uuveABgjHU3MTFRM8YAAAKBgBcVFUUDmoRl9+7d1nl5eUKJRKLq0aNH8fHjx5MMHSsjI0P4/fffWyUlJV0FgGPHjklGjRrVefLkyTm7d+9O1ZXr3r2750svvXRv7ty5ufeL3cPDo0KpVEY15jybYvHixR3XrVuXOnny5PzmrrspEhIS4lrz+IDmHk2bNq1Tdnb2Fd261atXZzVH3U888USpVCqt2rdvn8XEiRMLmqPOf4JaUgkhreb06dPo1asXunfvjk8//bTO9kWLFqFfv37o168fevbsCRcXlxrbCwsL4e3tjffee696XVhYGJ566in07dsXwcHByM297/9LCWnTVCoVW7Vq1X1bNy9dunRNqVRGKZXKKF2C+t///tfq4MGDVidPnrypVCqjLl26dG3gwIGF9dWxZcsWq6CgoAJzc/Pq/rlisVgdHh5uFR8fb9R8Z/RgMjMzjf39/UsNbfunrY/EsAkTJii2bdtm3XDJh6fFk1TG2GuMsduMsTLGWKT2XeD3Kz+RMRbNGFMyxrIYY3sYY7YtFS8h5OFQqVR47733cPDgQfz+++8ICwvDjRs3apRZtWoVLly4gAsXLmDGjBkYOXJkne19+vSpXq6qqsLChQvx448/4uLFi/D29sa2bdta5HwIeRhee+21rC1bttjeu3fP4MCS+ly6dMlswIABhd7e3uUA4OTkVDV//vx79ZU/deqURb9+/Yr010kkElVwcPC9xYsX2xvaR/t32M7e3t5XLpf7Pffccy65ubkCoO5j602bNll17NjR18zMLMDBwcF3y5Ytcl09n376qZWrq6u3VCr179u3r8fNmzfrJMWlpaXM1NQ0QKVSoWfPnl6Ojo4+gKa1efHixbadO3f2MjMzC6ysrERycrJoyJAhbjKZzM/BwcF3xYoV1Um+SqXCokWLbB0dHX0sLS39hw8f7pqdnW3w2mZmZgoHDhzoLpFI/C0sLPy7d+/uqVKpoDvukSNHJADw9ttv2w8bNsx1zJgxnczMzAI6d+7sdeXKFeOFCxfayuVyP1tb227h4eFSXb36++r2HzNmTCdDMXz22WdWrq6u3mZmZgEdO3b0Xbt2bXsAKCwsbBccHOyRk5MjMjU1DTA1NQ1ITk4W1a5r7969Fu7u7t4SicS/V69enpcvXzbRj2Pp0qU2nTt39pJIJP4jRoxwVSqVTLd96NChRb///ru0tLSUoZW0aJLKGAsB8BmAVQACAPwG4ARjzOCs+4yxpwDsBrALgDeAsQC8AOxtkYAJIQ9NZGQkOnXqBBcXFxgZGWHcuHE4ceJEveXDwsIwfvz46uXo6Gjk5ORg4MCB1es45+CcQ6lUgnOOoqIi2NrSb1ry79WrV6+SJ554oujDDz+0acp+vXv3Lg4LC7N6//33bS5cuGDaUN/Q+Ph4sbe3d1nt9R999FHmTz/9JIuJiTGuve2///2v1f79+61Onz4df/v27aslJSWCadOm1fn/eWFhYbtFixY5HT9+/GZJSUnUb7/9dqNnz55KANi9e7flhg0b7A4dOpSYm5sb3adPn+KQkBDX2nWIxWKu6z5w6dKla2lpabG6bWFhYfL//e9/txQKRVS7du0wYsQId19fX2VmZuaVU6dOxX/55Zc2YWFhUgBYuXJlh+PHj1ueO3cuPjMzM8bS0lI1ffp0gznIihUrbOzs7Cru3bsXc/fu3ZiVK1em67pV1BYREWE5ZcqU3Pz8/Chvb2/lsGHDOqvVamRmZl559913M+bMmfOP+ona2NhUHT16NKGoqCjqq6++ur106VLHixcvmkqlUvWhQ4duWVtbV+pa0V1cXGo0JV+5csV4+vTprmvXrk27d+9ezODBg/PHjh3rXlZWVn0Shw8flp88efJWQkLC1evXr4s3b97cXretU6dOlUKhkF+5csUEraSlW1LfBrCTc76Nc36dcz4HQCaA2fWUfxLAHc75Rs75bc75HwD+C+CJFoqXEPKQZGZmwsHBoXrZ3t4emZmZBsumpaUhNTUV/fr1AwCo1Wq8//77WL58eY1yIpEI69atw1NPPQUvLy/Ex8cjNDT04Z0EIS1g5cqV6Tt27OiQkZFhcBxJ7969vSQSib9EIvF/+eWXHQHgtddeU6xevTr1zJkzFkOGDPFs3769/6JFi+r9xVZUVCTQ9XvV5+TkVDV58uScRYsWOdTeduDAAavXXnst28vLq8LCwkK9du3aO8eOHZMZeuzOGONRUVHi4uJi5uzsXNmjR48yANi2bZv1W2+9lRUYGFgmEonw8ccfZ964cUNsqDW1Pq+++mq2u7t7pbm5OT9//ryZQqEQrlu3LtPExIR7eXlVhIaG5nz33XdyANi5c6f1hx9+mO7m5lYpFov5xx9/nHHixAmDMYtEIp6dnS26deuWkbGxMR86dGhxu3aG06bu3bsXjR8/vlAkEuH555/Py8vLE65cuTLL2NiYT506VZGRkWHU1NZwAJgwYUKBt7d3uTb5Ln7qqacKz549a96YfXfv3i0fOHBgwXPPPVdobGzMly9fnl1WVtbu9OnT1fvPnj0728XFpdLGxkY1ePDggujo6BqD0UxNTVUKhaLJcTeXFktSGWNGALoDOFlr00kAferuAQD4FYAdY2wU02gPYAKA/z28SAkhLYHzulNT1tdKER4ejtGjR0Mg0Pxb+c0332DQoEHo2LFjjXKVlZXYsWMHzp8/j2vXrsHb2xsbN25s/uAJaUE9e/YsGzhwYMGyZcsMJpl//PHHtaKiouiioqLonTt3punWz549W/Hbb7/dzM/Pj96wYUPK2rVr7XUtirVJpVJVYWGhwZzggw8+yLxw4YL0999/r5HAZGdni1xcXKpfZenh4VGhUqnYnTt3RLXqVu/cuTNp69at1nZ2dn4DBgxwj4qKMgGA9PR0o8WLFzvqkmxLS0t/zjlLSUmpUcf9ODs7V2eYSUlJRjk5OUa6+iQSif+mTZvscnJyhACQmZlpNGnSJHfdNh8fH2+BQIDaMQPAsmXLslxdXcuHDh3auWPHjr73S/Ktra2rm6pNTU3VMpmsSijU/KYwNzdXA0BBQUGTc66DBw9K/fz8ulhYWPhLJBL/8+fPW9y7d69Rg94zMjJEjo6O1fdHIBDAzs6uIi0trfpc7e3tq6+dqampuqSkpEZCqlQqBXK5XNXUuJtLS47ubw/NZK3ZtdZnA3jW0A6c898ZYy9C83hfDE28p2Dg1VkAwBibCWAmANjZ2eHy5csANC00pqamSEhIAABYWFjA1dUVUVGagYcCgQB+fn6Ij49HSUkJAKBr165QKBTIztaE27FjRxgZGSEpSTMwUiaTwcnJCTExMQA0LTi+vr64fv06Sks1fbq9vLyQk5ODnJwcAICzszMYY0hOTgYAWFlZwc7ODrGxmqcWxsbG8Pb2RlxcHMrLywEAPj4+yMzMrB784eLiAs45UlI0b/aztraGtbU1rl27BgAQi8Xo2rUrrl69Wt2J3M/PD6mpqcjLywMAuLq6oqKiAnfu3AEA2NjYQC6X4/r16wAAMzMzeHp6IiYmBrr+NwEBAUhKSkJBgWaQn7u7O5RKJTIyMqC73lKpFPHx8QAAiUQCDw8PREVFgXMOxhgCAgJw69YtFBVpuj15enqisLCwuvWM7tPjdZ+kUimuX7+Oy5cvQyaT4c6dO1CpVLh8+XKd+7Rnzx5s2LABaWlpyMnJwc8//4zr169j27ZtKCoqQlVVFaqqqhASEoKioiLk5eVBqVRi7NixWLFiBYKCgug+0d8nVFTUeTX4v8aqVasyevfu7TVr1qwmj97WtublbdiwwfbKlSvi8ePH1xlA1aVLl9Jr166Z9O/fX1l7m62trWrGjBl3Fy9eXKM11cbGpjI5Obm6xTMhIcFIIBDwjh07ViYlJdVoCR0/fnzh+PHjC4uLi9lbb73lMH36dOfIyMh4Ozu7ivnz52fOnj1b0dTz0mGMVf/idXFxqXBwcChPSUmJNVTWxsamcuvWrbcHDx5c0lC9MplMvW3btjsA7vz9998mgwcP9nziiSdKxowZU9TQvvcjFovVJSUl1QlrVlaWwVystLSUvfTSS25ffPFF8sSJE/ONjY35s88+66b7ga9/3obY29tXxsXFVf+w0HY/MHJ0dGzUCLPk5GRRZWUl69atW51uIC2lNaagqn1RmYF1mg2MeQHYBOAjAD8DsAOwFsBXAKbUqZjzrQC2AkBAQAAPDAyssb2hZU9PzxrLDg4ONR5HNqaOrl271lh2dHSEo6NjjXVyubzGcu06vL29ayw7OzvD2blmdxYrK6v71uHr61tjuVOnTujUqWa/7A4dag4YrV2Hn59fjWU3N7cay1KptE5/v9p1BAQE1Fj28PCosWxmZgY7O7v71kH36dG8T/369cM777xTnbQcOXIEW7durXFvunbtilu3bqGiogJ9+/YFYwyOjo44dOhQdZl9+/YhOjoaa9asQWZmJjIyMuDk5IT27dtj5cqVCAwMrBEb3afH++/Tv5WPj0/5yJEjFd98841N586dDY5u17dp0yarDh06VA0ZMqRIKpWqw8LCpAkJCeI+ffoYTM4GDx5ccOHCBUl9yeKSJUuy3NzcfDnn1Y87nn/+ecVnn31mO3bs2AI7O7uq9957z2HEiBF5IlHNRsm0tDThhQsXzEaNGlVkZmamNjc3V+ueisycOTPno48+cujZs6eyR48eZbm5uYIffvhBOnXq1LymXB+dAQMGlJibm6sWL15su3DhwmwTExMeFRVlolQq2/Xv31/5yiuv3F2yZElHFxeX2507d67IyMgQRkREmBua0uq7776z8PX1LfPy8iq3tLRUCQQCrov7QXh5eSn3798vDw4OLvzzzz/FJ06ckPXr16/OD4eysjJWUVHRrkOHDpUikYgfPHhQ+uuvv0q9vLxKAcDe3r6qoKBAmJubK7CysqrT2jl58mRF7969vX744QfJ0KFDi1euXNnByMiIP/vss8WNifOnn36S9O7du1AsFrfaG9laMkm9B0AFoHZzeQfUbV3VWQjgL875Wu3yFcZYCYBfGGOLOedp9exHCGnjhEIh1qxZg+DgYKhUKkyaNAldu3bFqlWrEBAQgGHDhgHQDJgaN25cvV0B9NnZ2eG9997DiBEjIBKJ4OjoiM8///xhnwohLWLFihUZhw8ftmq4JGBhYaFas2aN3cyZMzup1Wpmb29fvmbNmpQhQ4YYTFBmzZqV6+/v71VcXMz0p6HSkcvl6tdffz1r5cqV1X1s5s2bdy8jI0M0YMCALuXl5axfv36FX3/9dWrtfdVqNfv0009tX3311U4A0LVr19ItW7akAMCUKVPyi4qK2k2cONE1IyPD2NzcXPX0008X/tMkVSgU4vjx4wlz5szp6OLi0q2iooJ16tSpbPny5ekAsGTJkrucczZ48ODOOTk5IrlcXjlmzJg8Q0nqzZs3jefPn++kUCiEUqlU9fLLL+eMHDnygVpRAWD16tXpEyZMcJXJZP69evUqGjNmjCIvL69OPiaTydQrVqxInTJliltFRQV75plnCp555pnqOUsDAgLKRo0apXBzc/NVqVS4evVqjblb/fz8yr/66qvbb7/9ttPkyZNFXbp0KT1y5MgtExOTRiWd+/fvl8+cOTPnQc/3QTBD/cIe2sEY+xNADOd8pt66mwDCOOcLDZQPA8A558F6656EZlYAZ855nb8MOgEBATwiIqJZ4yeEEPLvJpfLIznnPXTLMTExyX5+fvVOzfQ4eeONNxw6dOhQuXTp0rutHQtpXX/99Zd45syZztHR0TcaLv3gYmJi2vv5+bnUXt/Sj/s3ANjNGPsLmkFRrwKwB/AlADDGvgUAzrnuUf5RANsYY7Px/4/7PwVw+X4JKiGEEEKaZvPmzemtHQNpG3r16lXaUgnq/bToFFSc8wMA3gSwBEA0gL4AhnPOU7RFnLR/dOV3QjNt1RsAYgEcAnALwJiWi5oQQu7vQd6cFRwcDBcXF0yYMKHGPufPn8eAAQPQr18/DBs2rHrwEiGEPC5afOAU5/wLAF/Us22AgXX/hWZuVEIIaXN0b84KDw+Hvb09nnnmGQwdOhRdunSpLrNq1arqz1u3bsWVK9Wv2sacOXNQWlqKnTt31qh3/vz52LNnDzw9PfHNN99g/fr11L+WEPJYafHXohJCyKPkQd+c1b9/f5ib152bmzFWPb1UYWEhvTmLEPLYaY0pqAgh5JFh6M1ZkZGRBsvWfnPW/Xz22WcICQmBiYkJJBIJTp6s/R4UQgh5tFFLKiGEPIAHeXPW/WzZsgUHDhxAXFwcJk6ciCVLljxwrIQQ8m9CSSohhDwAe3t7pKf//6DojIyMeh/Nh4eHY9y4cQ3Wee/ePcTGxqJHD81MSePGjcNff/3VPAETQsi/BCWphBDyAAIDA5GUlISUlBRUVFQgPDwcQ4cOrVPu1q1byM/PR69evRqs09LSEoWFhdWvND179iw6d+7c7LETQkhbRkkqIYQ8AP03Z/Xu3Rtjx46tfnOW/gCq+t6cNXz4cLzyyiu4cOECvL29cebMGQiFQnz66ad46aWX8PTTT+PgwYP48MMPW+R8GppOCwAOHz6M3r1748knn8SMGTOq13/wwQfo06cP+vTpg/Dw8Or1NJ3Wv0tGRobQxcXFR6lUNvyat2ZgamoacO3aNaOWOFZjtGQ8EydOdHr33XftGi7ZdA4ODr5HjhyR/JN9f/rpJ3MXFxefB42htLSUderUyTs9Pf0fjYFq0TdOtSR64xQhhDSNSqVCz549a0yntW3bthrTaSUmJmLq1Kn44YcfYGlpiZycHFhbW+PkyZPYsmULvv/+e5SXl2PUqFE4cuQIpFIpevbsWWM6rcuXL7fadFqNeeMUA7o/zBg4YHhkXS0ODg6+ubm5IoFAwNu1a8fd3d3LXnzxxdx33nknR9evefz48S7h4eFWERER1wcOHKgEgNjYWGNfX18fznkkAPz9998m8+bNc7x69aoZ5xxOTk7lS5cuzQgJCSkwdNwZM2Z0tLa2rlq1alUWAPTq1cszJibGTCgUcsYYnJ2dy8aMGZP3/vvvZ7fme93J/Tk4OPh+/vnnyWPHjm3wVa6Mse5Xr16N9fHxKW/uOJYsWWKTnZ0t2rZt2536ytT3xilqSSWEEAKgcdNpffvtt5g2bRosLS0BANbW1gCAGzdu4KmnnoJQKISZmVl1qzBA02k9iP37998qKSmJSk5Ovjp//vzMzz77zDYkJMRFv4yFhYVqyZIlDvVUgbFjx3oEBQUV3r17NyYnJydm48aNqZaWlipDZUtLS9mhQ4espk2blqu//uOPP04tKSmJysjIiPnkk0/uhIeHy4OCgjzUanWznCd5dL3yyiuKQ4fIVC3cAAAgAElEQVQOWZWWlja5ZZ6SVEIIIQAMT6eVmZlZo0xiYiISExMxdOhQDBo0CKdPnwYA+Pj44PTp01AqlcjNzcXFixerB5TpptPy9vbGgQMHMG/evJY7qUeElZWVatKkSQV79uxJDA8Pt7p06ZKJbltwcPC9+Ph40+PHj9eZcDczM1OYnp5uNG/evHsmJibcxMSEDx48uGTIkCHFho5z7tw5M4lEonJzc6s0tF0qlapHjhxZdPTo0YTo6GizAwcOWACaVvhFixbZOjo6+lhaWvoPHz7cNTs7WwAATz/9tMeqVaus9evx9PT02rVrlyWgacWLjY01BoDi4mI2Y8aMjvb29r4SicS/e/funsXFxQwAzpw5YxYQENBFIpH4e3p6eh07dqzeR9kODg6+S5cutencubOXRCLxHzFihKt+94X169e3d3Jy8rGwsPAPCgpyT05OFum26cdz4MABCzc3N28zM7OADh06dFu6dKmNrtx3331n0aVLFy+JROIfEBDQ5c8//xQbikWtVmPatGmOcrncTyKR+Hfu3NlLd//Gjx/vMnfuXHsAOHbsmMTGxqbbkiVLbORyuZ+1tXW33bt3Wx44cMDCxcXFx8LCwn/BggXVv/D099Xf31AMZ8+eNfX39+8ikUj8ra2tu02ZMsWprKyMAUCPHj08AaBnz55epqamAdu2bZPVruvy5csmvXr18pRIJP7u7u7ee/futdCPIzQ01GnAgAHuZmZmAd26desSFxdnrNvu5uZWKZVKVREREWb13a/6UJJKCCEEQOOm06qqqkJSUhKOHj2Kr7/+GvPmzUNBQQGCgoIwaNAgDB06FNOnT0fPnj0hFGq6odF0Ws1n4MCBShsbm4qIiIjqBM3U1FT95ptvZi5durROa6qNjU2Vk5NT+fPPP99p9+7dlmlpafftGxgdHS12dXUtaygODw+PCm9vb+WFCxfMAWDlypUdjh8/bnnu3Ln4zMzMGEtLS9X06dOdACAkJERx6NAhK92+kZGRJhkZGUYvvPBCne4Gs2fPdoyJiTH79ddfb+Tl5UWvXr36jkAgwO3bt0Xjx4/3WLBgQWZ+fn706tWr70yePNktIyOj3vM5fPiw/OTJk7cSEhKuXr9+Xbx58+b2APDjjz9KVqxY4bBv376krKysGEdHx/Lg4GBXQ3W88cYbzp9//nlKSUlJVFxcXNzgwYOLAODixYumr7/+ussXX3yRkpeXFz116tSccePGuRtqLTx8+LD0jz/+ML9582ZsQUFB9P79+5M6dOhgsCU7NzdXVFZW1i4zM/PKggULMubOneu8Z88eeVRU1LUzZ87c2Lhxo/0/6S8rFAqxfv36NIVCEX3x4sUbFy9elKxZs8YaAP7+++94ALh06dI1pVIZNWPGjDz9fcvLy9nYsWPdg4KCCnJycmI2bNiQOnPmTNeYmJjqRPTHH3+UL1u2LCM/Pz/KxcWl/D//+U+N76Kbm1tZVFSUaZPjbuoOhBBiyCb5ptYOodnMVcxt7RBaRWOm07K3t0ePHj0gEong7OwMDw8PJCYmIjAwEO+88w7eeecdAMCMGTPg5uZmcDqt4ODgljupR1CHDh0qFQpFjcl233nnnZzPP//c5uDBg1IvL6/qfoXt2rVDRERE/PLly+0WLVrUMT093TgwMLB4x44dyb6+vnX6H+bn5wvMzc0b9Qzf1ta2Mi8vTwgAO3futN64cWOqrgX2448/znBzc/OtrKy8PWnSpLx3333X6ebNm0adO3eu2Llzp9XQoUPza/dnValU+P7779ufPXv2eqdOnSoBYNCgQSUA8PXXX1sNGDCgQNeP9rnnnitcv359SVhYmMWcOXNyYcDs2bOzXVxcKgFg8ODBBdHR0WIA2LNnjzwkJCS3b9++SgDYtGlTupWVlX98fLyRp6dnhX4dQqGQX7161aRXr15Ka2trlbW1tRIAtmzZ0j40NDQnKCioBADmzJmTu379eruIiAizESNG1GilFolEvKSkRBATE2MyYMCAksDAwHp/BAiFQr569epMoVCIqVOnKubPn+/81ltv3ZXJZOoePXqUubu7l0ZGRpp6eXlV1FeHIU8//bRS99nT07Pi5Zdfzvnll18kAO42tO/Zs2fNlEqlYOXKlVkCgQCjR48uCgoKyt+1a5fVhg0bMgBg6NChebo+0ZMmTVIsWLCgo34d5ubmqvz8/IYniK6FWlIJIYQAaNx0WsOHD8fFixcBALm5uUhISICLiwtUKhUUCgUAIC4uDnFxcRg4cCBNp/UQZGdnG8nl8hotcWKxmM+fPz/zww8/dKjdIu7m5lb57bffpqalpcXevHnziqmpqTo0NLSTobplMpmquLi4UblBZmamSCaTVWk/G02aNMldIpH4SyQSfx8fH2+BQIA7d+6IZDKZeuDAgQW7du2SA8CRI0dkkydPrpNYZmVlCcvLy5l+kq2TkpJidOLECZmufolE4h8ZGWmemZkpql1Wx97evrrLgqmpqbqkpESgPY6Rs7Nz9TEsLCzUlpaWqpSUlDp17d+/P/Gnn36ycHFx6dazZ0/P06dPmwHAnTt3jLZu3WqjH092drbozp07dVo5R48eXTR9+vS7c+fOdWrfvr3fiy++6KxQKAxeYwsLiyrdEwjdjwUHB4fq8zAxMVEXFRU1OXe7cuWK8cCBA93bt2/vZ25uHvDxxx87KBSKRjVUpqWliWxtbSv0X0Li6OhYkZGRUX29bGxsqmM0MzNTK5XKGglpcXGxoL5+0PdDSSohhBAAjZtO65lnnoFMJkPv3r0xevRoLF++HHK5HJWVlRg+fDh69+6NN998E1999RWEQmGrTqf1KDp//rzp3bt3RQMHDqzTp3Tu3Ln3ioqKBAcOHLCsb393d/fK2bNn371165bB/pMBAQGlt2/fNjG0TV9CQoLo2rVrpv369SsGNElKeHj4zaKiomjdn/Ly8su6FtEJEyYowsLC5KdPnzYrLy9vN3LkyDojzm1tbauMjY35tWvXjGtvc3R0rHjuuedy9esvLS2N0s1A0BS2trYVKSkp1ccoLCxsl5+fL3B2dq7TD7d///7KM2fOJObk5MSMHDkyb/LkyW6AJnGcO3duZu14Zs2apTB0zCVLltyNi4u7HhsbG5eYmGiyfPnyBx49aGpqqlYqldV53P26PsyaNcvZw8Oj7NatW1eLi4ujFi5cmF5f2docHR0rs7KyjFSq/88x09LSjPR/BDQkMTHRJCAgQNlwyZooSSWEEFJt0KBBuHTpEi5fvlz96H7RokUYNmwYAE0f1ZUrV+KPP/7Ar7/+ivHjxwMATExM8Mcff+CPP/7AqVOn4OvrW13nyJEj8euvv+KXX37B0aNH4eLi0uLn9W+nUCjafffddxaTJ092HTNmTG6vXr1Ka5cRiURYsGBBxubNm6vn3czJyRG89dZb9rGxscYqlQqZmZnCHTt2tPfz8zM4cKp///4lhYWFgtu3bxtsoSwqKmp3/Phx89GjR7v7+voqdf1KX3nllbtLlizpePPmTSNAkzDt2bOnOll+/vnnCzIyMoyWLl1qP2rUqDxDrwYWCAR4/vnn77399tuOycnJoqqqKpw+fdqstLSUTZs2Lff06dOWYWFh0qqqKiiVSnbs2DFJYmJivS2p9Zk0aZLiwIEDVr/99pu4tLSUzZs3z8HPz6+k9qP+srIytmXLFnlubq7A2NiYS6VStUAg4ADw6quv5uzatatDRESEmVqtRmFhYbv9+/db5OXl1cmrzp8/bxoREWFWXl7OJBKJ2tjYWN2YVyM3xN/fX3nmzBmL7OxsQWpqqvDzzz+3qa9scXGxQCqVqiwsLNRRUVEm27dv76C/3crKqurmzZt1fhwAwIABA0rEYrHq/fffty0vL2fHjh2TREREWIaGhhpMyGu7ffu2qKCgQKjrGtEUlKQSQgghbdSECRM8zMzMApydnbt98skndq+99lr2999/n1xf+ZkzZyqsra2rW7iMjY15SkqK0ZAhQzpLJJIAX19fb2NjY/XevXsN1mFiYsJfeOGF3K+//tpKf/3ChQudzMzMAmxtbf3mz5/vNGrUqLxz587d1CVbS5YsuTt8+PD8wYMHdzYzMwt44oknuvzxxx/Vo7nFYjEfOnRo3u+//y6dMmWKwT6kALBly5a0rl27lvbq1aurTCbzX7BgQUeVSgV3d/fKgwcPJqxevdrOysrK38HBodu6dets1Gp1k6c1GjNmTNHChQszQkJC3Gxtbf2Sk5ONDx48aPANE/v27bPq1KmTr7m5ecA333xjvX379tsA0K9fP+XmzZuT586d62RhYeHv5ubms2vXLitDdeTn5wteffVVZ5lM5u/s7Owrk8mqli1b1uQW4Npmz56d6+XlVerm5tbt2Wef7Txu3Lh6k8Y1a9akhYWFyc3NzQOmT5/uPHbs2Bpl33vvvYxZs2a5SCQS/6+//lqmv83ExIQfPnw44dSpUxbt27f3mzdvntOWLVtuBwQENDjADgC2b98uDw4OvvdP5tSlyfwJIc2CBk6Rf4PGTOb/uMvIyBA+9dRTnlevXr1mbm7+aCYJpEWUlpYyLy8vr4sXL8Y7ODhU1Veuvsn8aXQ/IYQQQqrZ29tX3b59O6614yD/fmKxmD/Id4ke9xNCCCGEkDaHklRCCCGEENLmUJJKCCGEEELaHOqTSgghtchlsoYL/Qso8vIaLkQIIW0UtaQSQgghhJA2h5JUQgghhBDS5lCSSgghhBBC2hxKUgkhhBBSbe3ate2nTp3q2BLHYox1j42NNfg6zsdVfHy8EWOse2VlZcOF7+Onn34yd3Fx8XmQOkpLS1mnTp2809PTW2UMEw2cIoQQQvTtY90fav0TeWRjiv3888/mCxYs6JiQkGDSrl07uLm5lW3cuDG1f//+SgBITEwUvfXWWx0vXLhgUV5eztzd3cuWLFmSERISUqCrQ61WY9WqVR127dplfefOHSOpVKoKDAwsXr58eWavXr1Kax+zrKyMrV+/3v7333+/DmgSpi5duviKxWI1AMhksqqXXnopZ9WqVQ/8Ws+2atOmTVa7du1qHxkZGd/asTyIoUOHFicnJ8c+SB1isZhPmjTp3gcffGC7bdu2O80VW2NRkkoIIY8o2Ql5a4fQbPKG1fta8keSQqFoFxwc7L5u3brUadOmKcrKytjJkyclJiYmHACys7MF/fr16/Lkk08WXblyJVYul6v27t0rmzZtmmtFRcXt0NDQfACYOnWq45kzZyw+//zzlEGDBhVXVVWxPXv2WB45csTCUJK6b98+S1dX19JOnTrVaMYrKCiIEolEuHDhgumQIUM8e/bsqXzuuecKW+ZqkNb0yiuvKHr06OG1adOmdLFY3KKvyaXH/YQQQkgbExsbawIAs2bNUgiFQpibm/Nx48YVPvHEE6UAsGrVKhtTU1P1gQMHkp2cnKrMzc35rFmzFPPmzctcuHCho1qtxtWrV413797d4dtvv00aPXp0kVgs5hKJRD179mxFfS2hJ06csOjbt29xfXH169dP6e7uXnb58mWxbl1ycrJoyJAhbjKZzM/BwcF3xYoVHXTbzp49a+rv799FIpH4W1tbd5syZYpTWVkZa8w1uHHjhlHPnj09zczMAvr06eMxZcoUpzFjxnQCgGPHjklsbGy66Zd3cHDwPXLkiKQxx2WMdV+zZo21s7Ozj1Qq9Q8NDXVSq9W4fPmyybvvvuscHR1tbmpqGiCRSPwBoFevXp4bNmxor9t/06ZNVt27d/fUr2/16tXWzs7OPmZmZgHz5s2zj4uLM/b39+9ibm4eMHz4cNf6zruqqgozZ87sKJPJ/Dp27OgbHh5uob89NzdX8MILLzhbW1t369ChQ7e5c+faV1VVobS0lEkkEv9Lly6Z6MpmZGQITUxMAtPT04W1r1FCQoJo8ODBbjKZzM/S0tJ/ypQpTrptn376qZWrq6u3VCr179u3r8fNmzeNdNvc3NwqpVKpKiIiwqwx9605UZJKCCGEtDE+Pj5lAoEA48aNczl48KA0JydHoL/93Llz0pEjR+YJBDVWIzQ0VJGenm4UFxdnfOLECamNjU3FwIEDlY097vXr18VdunQpq2/7mTNnzBISEkw8PDzKAUClUmHEiBHuvr6+yszMzCunTp2K//LLL23CwsKkACAUCrF+/fo0hUIRffHixRsXL16UrFmzxroxsUyYMMHVz8+v5N69e9Hvv/9+ZlhYmFVjz6Mxxz1x4oRFZGTk9cjIyGvHjh2ThYeHSwMDA8vWrl2b4u/vX6xUKqOKioqiG3vMkydPWkRFRV07f/789S1btthOnz7ded++fUkpKSlX4uPjxdu2bTP4aGPDhg3Wp06dsrh06dK1yMjIa0eOHKkxUXNISIiLUChEYmJibFRU1LWzZ89abNy4sb1YLOZDhw7N//bbb6uvy65du2Q9e/YscnBwqNKvo6qqCiNGjPBwdHSsSElJuZqRkREzadIkBQDs3r3bcsOGDXaHDh1KzM3Nje7Tp09xSEiIq/7+bm5uZVFRUaaNvRbNhZJUQgghpI2Ry+XqiIiIG4wxzJkzx8XOzs4/KCjIPS0tTQgAeXl5Qjs7uzoja5ycnCoBICsrS5ibmyuwtrZu0uiboqIigVQqVRmIx9/ExCTw2Wef7RIaGpozefLkfAA4f/68mUKhEK5bty7TxMSEe3l5VYSGhuZ89913cgB4+umnlc8880yJSCSCp6dnxcsvv5zzyy+/SBqK49atW0axsbFmGzZsyBCLxXzYsGHFQUFB+Y09j8Ycd8GCBVnt27dXeXh4VDz55JNFly9ffqAkbMGCBZlyuVzdo0ePMg8Pj9KgoKBCLy+vCisrK1VQUFBBfUleeHi4bPbs2Xfd3d0rbWxsVP/5z3+qW7nT0tKEFy5csNi6dWuqVCpVOzg4VL3xxhvZhw4dkgPApEmTcg8fPlyd/H7//fdWISEhdfrGnDt3zuzu3buiL7/8Mk0qlapNTU35kCFDigFg27Zt1m+99VZWYGBgmUgkwscff5x548YNsX5rqrm5uSo/P19Qu96HjfqkEkIIIW1QYGBgWVhYWDIAREVFmYSGhnZ67bXXHI8ePXpbJpNVZWZmimrvk5qaKgIAW1vbKisrK1VOTk6dMvcjlUpVhYWFdZIRhUIRzRjDRx99ZBMWFiavqKhgJiYmPCkpySgnJ8dI91gcANRqNevRo0cRAFy5csV43rx5jlevXjUrKytrp1Kp4OXl1WDLbmpqqkgikVRJpVK1bp2Tk1PFnTt3jO63n05jjuvg4FCdwIvFYnVxcfEDNdzZ29tXt16amJiobWxsatSfnZ1t8F5kZ2eLnJycKnTLbm5u5brPCQkJRlVVVczOzs5Pt45zzmxtbSsAYNSoUUUzZsxgERERZh07dqy8fv26eNKkSXVeNZecnGzk4OBQIRLVDSE9Pd1o8eLFjkuXLu2of4yUlBRR586dKwCguLhYYGlpWefHy8NGLamEEEJIGxcQEFA2ceLEe/Hx8WIA6N+/f+GxY8dkKlXNvGH37t1yGxubSi8vr/Jhw4YVZmdnG124cKHRLYReXl7K+Ph4g1NCCYVCLF++PNvY2Fite3Tu4uJS4eDgUF5UVBSt+1NSUhJ1/vz5BACYNWuWs4eHR9mtW7euFhcXRy1cuDC9MXE4OjpWFhUVCQsLC6vzlLS0tOoEVSKRqMrKyqq3VVVVQaFQVDe8/dPjAgBjdbuOmpqaqpRKZfXxsrKympT830+HDh0qU1NTq88tKSmp+vq7urpWGhkZcYVCUX19i4uLoxISEuIAQCAQYOTIkXl79uyR79ixQx4UFFQgk8nUtY/h4uJSkZGRYWRoWis7O7uK9evXp+jfw7KyssuDBg0q0ZVJTEw0CQgIaHS3keZCSSohhBDSxkRFRZksW7bMJjExUQRoBr0cOnTIKjAwsAQAFi1alF1cXNwuJCTEJTU1VahUKtlXX30l37hxo92CBQvSBQIBfH19yydPnnw3NDTU9dixY5KysjKmVCrZ1q1bZYsWLbI1dNzhw4cXXLx48b6P4+fPn5+1efNmW6VSyQYMGFBibm6uWrx4sW1xcTGrqqrCpUuXTM6fP28KaFrgpFKpysLCQh0VFWWyffv2DverW6dz584V3t7eJfPnz7cvKytjP//8s3lERISlbruPj095RUUF279/v0V5eTn7z3/+Y1dZWVmd0/zT4wKAnZ1dZVZWlpH+QCdfX9/SH3/8UVZUVNQuNjbWeO/eve3vV0dTjBs3Lu+rr77qkJiYKMrJyRGsWbOm+t44OztXPvXUUwUzZ850VCgU7VQqFeLi4oyPHz9urisTGhqqOHr0qOzQoUNWL774osFpMAYMGFBibW1d+frrr3csLCxsp1Qq2cmTJ80AYObMmTkbNmyw+/vvv00AzUCt7du3V/eLvX37tqigoEAYFBRUYqjuh4mSVEIIIaSNsbS0VF26dMnsySef7CoWiwP69OnTtUuXLqVffPFFGgDY2tqqLly4EF9eXs58fX19pFJp4Ouvv+7yySefpL755pu5unp27NiRNn369Ltvvvmmk0wm83dxcfH94YcfZOPGjTPYv3PChAkFSUlJJsnJyfW2FIaEhBRIpVLVxo0brYVCIY4fP55w5coVsYuLSze5XO4/ffp0l7y8PAEArFmzJi0sLExubm4eMH36dOexY8c2ei6x7777LikyMtJMLpf7L1++3G7cuHHV52VlZaX65JNPUufMmeNsZ2fXzczMTG1jY1P9yPxBjjty5MgiDw+PUhsbGz+ZTOYHaH4UiEQita2trd+UKVM6jR8/vtnmRHv77bdzBgwYUNi9e3dvf39/r9GjR9d4XH/w4MHkiooK1rVrVx9LS0v/4OBgt/T09Or7ExQUVCIWi9V3794VBQcHF9Q9gqYV/NixYwlJSUnGTk5O3RwcHLrt27dPDgBTpkzJf/PNNzMnTpzoam5uHuDt7e194sSJ6hkGtm/fLg8ODr7X0tNPAQDjvMWP2SICAgJ4REREa4dByGNjk3xTa4fQbD7gy1o7hGbB9zVqpp9/heaaJ1Uul0dyznvolmNiYpL9/PzuNUvlrUihULTr3bt3l+HDh+d/+umnGQ9S17p169pfu3ZNvH379rTmiq85vP322/aJiYnGP/zww+3WjuVxUVpayry8vLwuXrwYX3vGgOYUExPT3s/Pz6X2empJJYQQQv7l5HK5+n//+98tgUDAU1NTH2hQ9Pz58++1tQSVtA6xWMxv374d9zAT1Puh0f2EEELII8Dd3b1y/fr1ma0dByHNhZJUQgghhLR5GzZseKBuDOTfhx73E0IIIYSQNoeSVEIIIY8ztVqtfnRGmBHyL6P9+2fwRQGUpBJCCHmcxebk5FhQokpIy+Kco7y8XJSSkmIJ4KKhMtQnlRBCyGOrqqpqelZW1tdZWVk+oIYbQlqSmjFWoFKpNqnV6i2GClCSSggh5LHVvXv3uwBGt3YchJC66FcjIYQQQghpcyhJJYQQQgghbQ4lqYQQQgghpM2hJJUQQgghhLQ5lKQSQgghhJA2h5JUQgghhBDS5lCSSgghhBBC2hxKUgkhhBBCSJtDSSohhBBCCGlzKEklhBBCCCFtDiWphBBCCCGkzWnxJJUx9hpj7DZjrIwxFskYe7qB8kaMsQ+1+5QzxlIZY3NbKl5CCCGEENLyhC15MMZYCIDPALwG4KL2vycYY16c89R6dvsOgCOAmQBuAbABIG6BcAkhhBBCSCtp0SQVwNsAdnLOt2mX5zDGhgKYDWBh7cKMscEAngXgxjm/p12d3BKBEkIIIYSQ1tNij/sZY0YAugM4WWvTSQB96tltLIBLAN5mjN1hjN1ijG1ijJk/xFAJIYQQQkgra8mW1PYABACya63Phqa11BBXAH0BlAMYD8ASwH8B2AMIrl2YMTYTmm4BsLOzw+XLlwEA9vb2MDU1RUJCAgDAwsICrq6uiIqKAgAIBAL4+fkhPj4eJSUlAICuXbtCoVAgO1sTbseOHWFkZISkpCQAgEwmg5OTE2JiYgAAIpEIvr6+uH79OkpLSwEAXl5eyMnJQU5ODgDA2dkZjDEkJycDAKysrGBnZ4fY2FgAgLGxMby9vREXF4fy8nIAgI+PDzIzM5GbmwsAcHFxAeccKSkpAABra2tYW1vj2rVrAACxWIyuXbvi6tWrqKysBAD4+fkhNTUVeXl5movq6oqKigrcuXMHAGBjYwO5XI7r168DAMzMzODp6YmYmBioVCoAQEBAAJKSklBQUAAAcHd3h1KpREZGBnTXWyqVIj4+HgAgkUjg4eGBqKgocM7BGENAQABu3bqFoqIiAICnpycKCwuRmZlJ9+kRuE+EPEy5ubnN8veJEPLvwTjnLXMgxuwBpAPoxzn/RW/9MgAvcs67GNjnJICnAdhyzgu06wYD+Fm7rnbCWy0gIIBHREQ081kQQuqzSb6ptUNoNh/wZa0dQrPg+1hrh9Bs8oYpmqUeuVweyTnv0SyVEUIeqpYc3X8PgAqAba31HVC3dVUnE0C6LkHVuq79r1PzhkcIIYQQQtqKFktSOecVACIBDKq1aRCA3+rZ7VcA9rX6oHbW/jeleSMkhBBCCCFtRUvPk7oBwMuMsemMsa6Msc+g6V/6JQAwxr5ljH2rV34fgFwAOxhj3oyxp6CZwuoQ5/xuC8dOCCGEEEJaSItOQcU5P8AYswKwBIAdgFgAwznnulZRp1rlixljz0IzWOoSgDwARwAsaLmoCSGEEEJIS2vpeVLBOf8CwBf1bBtgYF08gMEPOSxCCCGEENKGtPhrUQkhhBBCCGkIJamEEEIIIaTNoSSVEEIIIYS0OZSkEkIIIYSQNoeSVEIIIYQQ0uZQkkoIIYQQQtocSlIJIYQQQkibQ0kqIYQQQghpcyhJJYQQQgghbQ4lqYQQQgghpM2hJJUQQgghhLQ5lKQSQgghhJA2p0lJKmPsBcbYYGk17CQAABoPSURBVL3lpYyxO4yxnxljds0fHiGEEEIIeRw1tSX1A90HxlgggEUANgEQAVjffGERQgghhJDHmbCJ5Z0BxGs/PwfgCOd8DWPsJICfmzUyQgghhBDy2GpqS2oZAIn28zMATms/F+itJ4QQQggh5IE0tSX1FwDrGWMXAfQAEKxd3xlAWnMGRgghhBBCHl9NbUl9A0AFNMnpq5zzDO36YaDH/YQQQgghpJk0qSWVc34HwCgD699stogIIYQQQshjr8nzpDLGTBhjwYyx/zDGLLXr3Bhj8uYPjxBCCCGEPI6a1JLKGHOHZrCUOQBLAN8DyAcwW7s8vbkDJIQQQgghj5+mtqR+CuAkABsApXrrfwQwsLmCIoQQQgghj7emju7vA6A351zFGNNfnwrAvtmiIoQQQgghj7Um90mF5u1StTlBM1cqIYQQQgghD6ypSepJAG/rLXPGmBTAcgDHmy0qQgghhBDyWGvq4/63AZxljMUDMAFwAIA7gGwALzRzbIQQQggh5DHV1HlSMxhj/gBeBBAITUvsVgB7Oeel992ZEEIIIYSQRmpqSyq0yeh27R9CCCGEEEKaXYNJKmNsHICjnPNK7ed6cc7Dmy0yQgghhBDy2GpMS+ohALYA7mo/14cDEDRHUIQQQggh5PHWYJLKOW9n6DMhhBBCCCEPS5OSTsZYP8ZYncSWMSZgjPVrvrAIIYQQQsjjrKkto2cByA2st9RuI4QQQggh5IE1NUll0PQ9rc0KQMmDh0MIIYQQQkgjp6BijP2o/cgB7GGMlettFgDwAfBbM8dGCCGEEEIeU42dJzVX+18GIA+A/sT9FQAuAtjWjHERQgghhJDHWKOSVM75KwDAGEsGsI5zTo/2CSGEEELIQ9PU16Iuf1iBEEIIIYQQotOYN05dAdCfc57HGLsKwwOnAACc827NGRwhhBBCCHk8NaYlNQyAbqDU/d44RQghhBBCSLNozBunlhv6TAghhBBCyMNCrzklhBBCCCFtTmP6pN63H6o+6pNKCCGEEEKaQ2P6pFI/VEIIIYQQ0qKa1CeVEEIIIYSQlkB9UgkhhBBCSJtD86QSQgghhJA2h+ZJJYQQQgghbc7/tXf/UVKVd57H319BHDBobEXp9hfgD2yikqYJigoakRFMogxqnCQbjTOEVRONIcbZOBqYzaobDfHX6jGiJhGHGTHicQ8JExbZiILi2rDiDyBqK4Qf6yAaMSA0tM/+UU1P0zTQJdVVt7vfr3PqUPXc5976lpzCT917n+dxnlRJkiRlTmvOpO4kIo4BKhteLk0pvVW4kiRJktTZ5RVSI+Jg4CHgfOCT/2iOmcDfpZTWF7g+SZIkdUL5ju5/EDgWGAb8VcNjONAXmFLY0iRJktRZ5Xu5/1xgRErp+SZt8yPiPwNzCleWJEmSOrN8z6SuAza20L4J8FK/JEmSCiLfkPpfgTsj4vDtDQ3PJzds26OIuCoi3o6IzRFRExHDWrnfGRGxLSJezbNmSZIktTOtmcy/+QT+fYF3ImJ1w+vDgc3AoeTuWd3dsS4B7gKuAp5r+HNWRAxIKa3czX4HAY8ATze8nyRJkjqw1tyTWsgJ/CcAv0opbR9kdXVEjAKuBH60m/0eAn4NBHBRAeuRJElSBuU1mf/eiIhuQDXws2abZgOn7Wa/q4DewMXATYWoRZIkSdn2qSbz/5QOAboA7zZrfxc4p6UdIuIkYCJwakqpPiJ2+wYRMR4YD1BeXs6iRYsAqKiooEePHrz55psAHHjggfTr14/FixcD0KVLFwYOHMjy5cvZuDE3LqyyspL333+fd9/NlXvEEUfQrVs3amtrATjooIM46qijePnllwHYd999Oemkk1i6dCkff/wxAAMGDGDdunWsW7cOgKOPPpqI4J133gHg4IMPpry8nFdfzd1mu99++/G5z32O1157jS1bcivRnnjiiaxdu5b163Pj0vr06UNKiRUrVgDQq1cvevXqxeuvvw5A9+7dqays5JVXXmHr1q0ADBw4kJUrV/LBBx8A0K9fP+rq6li1ahUAhx12GGVlZSxduhSA/fffn/79+/Pyyy9TX18PQFVVFbW1tXz44YcAHHvssWzatIk1a9aw/b/3AQccwPLlywHo2bMnxx13HIsXLyalRERQVVXFG2+8wUcffQRA//792bBhA2vXrvXvqQP8PUltaf369QX5PklqPyKltOde2zvnzob+I/A14Chg36bbU0pddrNvBbAaGJ5SerZJ+0TgaymlE5r13w9YBPz3lNLUhrZJwEUppRP3VGtVVVWaO3duKz+ZpL11d9ndpS6hYCaliaUuoSDStN3/sG9PPhj9fkGOU1ZWVpNSGlyQg0lqU/mO7v8JcBm50fyfAD8E7iU3/dRVe9j3PaCe3KX7pg5l57OrAOXAAOCXDaP6twE/Bj7X8Pqv86xdkiRJ7US+IfWrwBUppV+QC5xPpZSuIXdJfuTudkwp1QE1LfQbCSxoYZfVwEnA55s87gfebHje0j6SJEnqAPK9J/Uw4PWG538BPtvw/N+An7Zi/58DUyPiRWA+cAVQQS58EhGPAKSULk0pbQV2mBM1Iv4d2JJScq5USZKkDizfkLqSXKhcSe6M5rnkzo4OBT7e084ppcci4mDgRnKX818FzksprWjoclSe9UiSJKkDyjekPgmMAF4gNyn/v0TEt8lNsH97aw6QUroPuG8X287aw76TgEmtrlaSJEntUl4hNaX0oybPfxMRq8jNcfrHlNLMQhcnSZKkzmmv5klNKb1A7qyqJEmSVDD5ju4nIgZFxCMR8VLDY2pEDGqL4iRJktQ55RVSI+IbwP8hN+jpdw2Pw4AXI+I/Fb48SZIkdUb5Xu6/GbgppXRL08aI+BHw34BHC1WYJEmSOq98L/f3Aqa30P44uZWjJEmSpL2Wb0j938BZLbSfBTyzt8VIkiRJ0IrL/RExtsnLWcCtETGY/xjVfyowFucvlSRJUoG05p7U37TQNr7h0dQ97GKSfkmSJCkfewypKaW8p6mSJEmS9oYBVJ3CnDlzGDJkCNXV1dx55507bf/lL3/J6aefzvDhwxk9ejTLli1r3HbHHXdQXV3NkCFDePrppwFYtWoV559/PqeccgpDhw7l/vvvL9pnkSSpM/g0k/l/KSLmRcR7EbEuIp6JiPPaojipEOrr67n++uuZPn06zz//PE888cQOIRTgwgsvZP78+cybN49rrrmGG2+8EYBly5YxY8YMFixYwOOPP84Pf/hD6uvr6dq1Kz/5yU9YuHAhs2fP5qGHHtrpmJIk6dPLdzL/ccCTwFvAPwD/BXgbeDIi/q7w5Ul7r6amhr59+9KnTx+6devG2LFjmTVr1g59DjjggMbnmzZtIiIAmDVrFmPHjmW//fbj6KOPpm/fvtTU1NC7d28GDhwIQM+ePTn++ONZu3Zt8T6UJEkdXL6T+f8DMCGl9D+atD0UETXkAuvDBatMKpC1a9dy+OGHN76uqKigpqZmp34PPvgg9913H3V1dTz11FON+w4ePHiHfZuH0ZUrV7JkyRKqq6vb6BNIktT55Hu5/yjg31ponwUcvfflSIWXUtqpbfuZ0qbGjRvHokWLmDRpEpMnT27Vvn/5y1+47LLLuOWWW3Y4GytJkvZOviF1JTCyhfa/BlbsfTlS4VVUVLB69erG12vWrKF379677D927Fh++9vf7nHfrVu3ctlll3HRRRfxla98pY2qlySpc8o3pP4MuCsipkTE5RHxrYh4ELijYZuUOYMGDaK2tpYVK1ZQV1fHjBkzGDVq1A593nrrrcbns2fP5phjjgFg1KhRzJgxgy1btrBixQpqa2uprq4mpcQ111zD8ccfz3e+852ifh5JkjqDvO5JTSn9IiL+HfgBuVWmAJYCX00pPVXo4lR6c+bM4YYbbqC+vp5vfvObXHvttTtsv/fee5k6dSpdu3blkEMO4Z577uHII48EYOLEicyePZtPPvmEL37xi9x66618/PHHXH755bzzzjvss88+jBo1iokTJ7bpZ+jatSu33XYbF110EfX19XzjG9+gsrKSW265haqqKkaPHs2UKVN45pln2HffffnsZz/LvffeC0BlZSVjxoxh6NChjcfp0qULL7zwAo899hgDBgxg+PDhANx0002MHNnShQZJkpSvaOmeuxY7RnQld1l/YUppfZtWVQBVVVVp7ty5pS6jXauvr+cLX/gCM2bMoKKighEjRjBlyhROOOGExj7PPvss1dXV9OjRg4cffpjnnnuOhx9+mIULFzJx4sTGy+ajR4/mxz/+MYMGDaKmpoZhw4ZRV1fHmDFj+P73v2+46wDuLru71CUUzKTUtj+ciiVN2/ne6/bqg9HvF+Q4ZWVlNSmlwXvuKanUWn25P6W0DZgB9Gy7cpQlrZm6adiwYfTo0QOAwYMHs2bNGiA3uGjLli3U1dWxZcsWtm3bRq9evejRowfDhg0DoFu3bpx88smN+0iSJG2X7z2pLwPHtkUhyp6Wpm7a3Vygjz76KOeccw4AQ4YM4YwzzqCyspLKykrOPvts+vfvv0P/Dz/8kN///veceeaZbfMBJElSu5VvSJ0ETI6IMRFxZESUNX20QX0qodZO3QQwffp0Fi9ezNVXXw1AbW0tf/zjH3n11Vd57bXXmDdvHgsWLGjsv23bNsaNG8f48ePp06dPm9QvSZLar3wn8/9tw58zgKYJJhpedylEUcqG1k7d9Ic//IHJkyczc+ZM9ttvPwBmzpzJ4MGD+cxnPgPAOeecw0svvcRpp50GwLXXXssxxxzDlVdeWYRPIkmS2pt8Q+oX26QKZVLTqZvKy8uZMWMGDzzwwA59lixZwoQJE3j88cfp1atXY/sRRxzB1KlT2bZtGyklFixYwBVXXAHAzTffzIYNG7j77o4z0EaSJBVWq0JqRPQAbgfGAPsCc4BrUkrvtWFtKrHWTN00ceJENm7cyOWXXw7kwum0adO44IILePbZZzn99NOJCEaMGMGoUaNYvXo1kydP5rjjjuOss84Ccis9XXrppSX8pJIkKWtaNQVVRNwOXAX8M/Ax8HXgDymli9u2vE/PKag6toNmdYxboAs1rU4WOAVV9jgF1c6cgkpqP1p7uX8s8PcppX8FiIh/BuZHRJeUUn2bVSdJkqROqbWj+48Ent3+IqX0IrANqGiLotq7OXPmMGTIEKqrq7nzzjt32n7vvfdy6qmncsYZZzBmzBj+9Kc/NW475JBDGD58OMOHD+frX/96Y/v48eMZMmQIp512Gt/97nfZunVrUT6LJElSKbQ2pHYB6pq1bSP/gVcdXn19Pddffz3Tp0/n+eef54knnmDZsmU79Dn55JOZO3cuzz33HOeff/4Oy4J2796defPmMW/ePKZNm9bYfvHFF7Nw4ULmz5/P5s2bmTp1atE+kyRJUrG1NmQG8GhEbGnS9lfAlIjYtL0hpXR+IYtrj5qu0gQ0rtLUdCnR7SsuQW6VpunTp+/xuE2XDR00aJCrNEmSpA6ttWdSfw2sAdY3eTwK/KlZW6e3N6s0AWzevJmzzz6bkSNHNq5739TWrVuZPn06I0aMKGzhkiRJGdKqM6kppcvbupCO4tOs0jRz5szGtiVLllBeXs4777zDBRdcwIABA+jbt2/j9uuuu46hQ4cydOjQvGsrO+igvPfJqj3PSSFJktqzfJdF1R7ku0rTtGnTGldpAigvLwegT58+nHHGGSxZsqRx209/+lPWr1/PzTff3IafQJIkqfQMqQXWdJWmuro6ZsyYwahRo3bos32VpmnTpu2wStOf//xntmzJ3fa7fv16Fi5cSP/+/QF45JFHmDt3LlOmTGGfffxrkyRJHZuj8wtsb1ZpWr58ORMmTGCfffbhk08+4Xvf+17jgKsf/OAHHHnkkZx77rkAfPnLX+b6668v2eeUJElqS4bUNjBy5MgdRuMD3HDDDY3Pn3zyyRb3O+WUU5g/f36L29atW1e4AiVJkjLO68aSJEnKHEOqJEmSMseQKkmSpMwxpEqSJClzDKmSJEnKHEf378HdZXeXuoTCSRNLXYEkSVKreCZVkiRJmWNIlSRJUuYYUiVJkpQ5hlRJkiRljiFVkiRJmWNIlSRJUuYYUiVJkpQ5hlRJkiRljiFVkiRJmWNIlSRJUuYYUiVJkpQ5hlRJkiRlTtFDakRcFRFvR8TmiKiJiGG76Ts2ImZHxLqI+CgiFkbE+cWsV5IkScVX1JAaEZcAdwG3AFXAAmBWRBy1i13OBOYCX2ro/zvgyd0FW0mSJLV/XYv8fhOAX6WUpjS8vjoiRgFXAj9q3jml9L1mTf8UEV8CxgDPtmmlkiRJKpminUmNiG5ANTC72abZwGl5HKon8EGh6pIkSVL2FPNM6iFAF+DdZu3vAue05gAR8R3gCGDqLraPB8YDlJeXs2jRIgAqKiro0aMHb775JgAHHngg/fr1Y/HixQB06dKFgQMHsnz5cjZu3AhAZWUl77//fl4fUMrXK6+8wtatWwEYOHAgK1eu5IMPcr/B+vXrR11dHatWrQLgsMMOo6ysjKVLlwKw//77079/f15++WXq6+sBqKqqora2lg8//BCAY489lk2bNrFmzRog97044IADWL58OQA9e/bkuOOOY/HixaSUiAiqqqp44403+OijjwDo378/GzZsYO3atcCuv09SW1q/fj0rVqwAoFevXvTq1YvXX38dgO7du1NZWdmq75Ok9iNSSsV5o4gKYDUwPKX0bJP2icDXUkon7GH/C8mF079NKf3PPb1fVVVVmjt37l5WDXeX3b3Xx8iKSWliqUsomDQtSl1CQXwwuuP8EPK7kj0d5XsChfuulJWV1aSUBhfkYJLaVDEHTr0H1AO9m7Ufys5nV3fQJKBe2pqAKkmSpPataCE1pVQH1AAjm20aSW6Uf4si4qvAo8C3Ukq/absKJUmSlBXFHt3/c2BqRLwIzAeuACqA+wEi4hGAlNKlDa//ltwZ1OuAeRGx/SxsXUqp41wnlSRJ0g6KGlJTSo9FxMHAjUA58CpwXkppRUOX5vOlXkGuxjsbHts9A5zVttVKkiSpVIp9JpWU0n3AfbvYdtbuXkuSJKlzKPqyqJIkSdKeGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmFD2kRsRVEfF2RGyOiJqIGLaH/mc29NscEbURcUWxapUkSVJpFDWkRsQlwF3ALUAVsACYFRFH7aJ/X+B3Df2qgFuBeyLiwuJULEmSpFIo9pnUCcCvUkpTUkpLU0pXA2uBK3fR/wpgTUrp6ob+U4BfA9cVqV5JkiSVQNFCakR0A6qB2c02zQZO28VuQ1vo/3tgcETsW9gKJUmSlBXFPJN6CNAFeLdZ+7tA713s03sX/bs2HE+SJEkdUNcSvGdq9jpaaNtT/5baiYjxwPiGl38pKytb/qkqLL5DgPfa/F1iUpu/RbHEnru0E2WlLqC98buSh47zPYECfleOLtSBJLWtYobU94B6dj5reig7ny3d7v/tov82YH3zzimlB4AH9q7M4ouIl1JKg0tdh5R1flckqfMo2uX+lFIdUAOMbLZpJLnR+y15Hjinhf4vpZS2FrZCSZIkZUWxR/f/HPhWRIyLiMqIuAuoAO4HiIhHIuKRJv3vB46IiDsb+o8DvgX8rMh1S5IkqYiKek9qSumxiDgYuBEoB14FzksprWjoclSz/m9HxHnAHeSmqVoDXJNSeqKIZRdDu7tFQSoRvyuS1ElESrsbsyRJkiQVX9GXRZUkSZL2xJAqSZKkzDGkSpIkKXMMqSUUEcdFxGGlrkOSJClrHDhVZBFxKPBN4PvAOnILE6wFfgM8kVLaWMLyJEmSMsGQWmQR8StgADCT3KpZBwOfByqBVcBtKaX/VbICpYyIiAOAj5L/SElSp2RILaKICOAjcnPDzmvSdiRwCvBtcutKX5JS+r8lK1TKgIj4BfBiw2NFSmlDC30OTinttESyJKn9857U4hoAvA3UbW9IOStTSo8DXyYXYi8pUX1SJkTE18j9aJsMPAXcHhF/ExHHRET3hj7dgYci4qQSlipJaiOeSS2ihv+pzgR6AJcCb6WUPmnW52rg71NKny9BiVImRMQUoB64DRgLXAYcAywHfgc8DfQH7kopdStVnZKktuOZ1CJKKX0M/CPQHXgEuDQijoyI/QEiogdwJrnlYqVOKSK6krvi8OeUUm1K6WcppZOALwDPkAus04F7gKmlq1SS1JY8k1oCEXEicBNwPrAReJ7cSP9zyI30H5dSeqV0FUqlFREHAYellJZFRDdga9MBVBFxCfAvwCDv35akjsmQWkIN01F9CRgDbCZ3BvXxlNKykhYmZVBE7EPu36z6iPg2uUv9PUpdlySpbRhSMyIi9ml+f6qklkXEBKBLSun2UtciSWobhlRJ7U5E7AvU+8NOkjouQ6okSZIyx9H9kiRJyhxDqiRJkjLHkCpJkqTMMaRKkiQpcwypkiRJyhxDqiRJkjLn/wMiqC+zYooNhAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# NFS vs DSN vs SQC, count histograms\n", + "plot_histogram([noisefree_count, noisy_count, real_count], \n", + " title= str(n) + '- qubit QNN on ' + device_name,\n", + " color=['purple','cyan', 'orange'], bar_labels=True,\n", + " legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quantum Fidelity" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "names = ['NFS','DNS','SQC']\n", + "legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']\n", + "\n", + "fidelities = [0.999,0.897,0.886]\n", + "plt.ylabel('Quantum Fidelity')\n", + "plt.suptitle(str(n) + '- qubit QNN on {}, '.format(device.name()))\n", + "plt.axis([-0.5,2.5,0.75,1.01])\n", + "plt.grid()\n", + "plt.scatter(names, fidelities)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Several subroutines" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def obj_simple(angles, shots=1000, verbose=False):\n", + " \"\"\"Returns the number of zero outputs of a single training example.\"\"\"\n", + " # make the program\n", + " qprog = make_program([theta, phi], angles)\n", + " if verbose:\n", + " QASM_source = qprog.qasm()\n", + " print(QASM_source)\n", + " if mode == \"NFS\": \n", + " dist = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " dist = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " \n", + " dist_count = dist.result().get_counts(qprog)\n", + " observable = {'1' : 1}\n", + " obj = average_data(dist_count,observable)/shots \n", + " print(\"The current value of the objective function is:\", obj, end=\"\\r\")\n", + "\n", + " return obj" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def make_program(pangles, uangles): # to be modified if n>1!\n", + " \"\"\"Returns a program that prepares the state according\n", + " to pangles and applies the unitary according to uangles.\n", + " \"\"\"\n", + " new_state = QuantumCircuit(qr, cr)\n", + " # desired vector\n", + " desired_vector = [np.cos(pangles[0] / 2), np.exp(1j * pangles[1]) * np.sin(pangles[0] / 2)]\n", + " qr_vector = []\n", + "\n", + " # Initialize a 1-qubit quantum state using the arbitrary method \n", + " qr_vector.append(qr[0])\n", + " new_state.initialize(desired_vector, qr_vector)\n", + " \n", + " # write the program\n", + " qprogram = new_state + unitary(uangles) + measuring \n", + " \n", + " return qprogram" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def obj(uangles):\n", + " \"\"\"Returns the objective function C defined above over all training data.\n", + " \n", + " Args:\n", + " uangles [type: list]\n", + " the angles in the unitary evolution.\n", + "\n", + " rtype: int\n", + " \"\"\"\n", + " # grab some training data from the overall data set\n", + " tpoints = int(train_frac * len(qdata))\n", + " tdata = qdata[:tpoints]\n", + " tlabels = labels[:tpoints]\n", + "\n", + " \n", + " # initialize a variable to store the output predictions of the neural net\n", + " predictions = np.zeros_like(tlabels, dtype=int)\n", + " \n", + " # loop over all training data to get the predictions\n", + " for i, pangles in enumerate(tdata):\n", + " # write the program\n", + " qprog = make_program(pangles, uangles)\n", + " \n", + " # run the program\n", + " shots = 1000\n", + " \n", + " if mode == \"NFS\": \n", + " out = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " out = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " \n", + " out_count = out.result().get_counts(qprog)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " p1 = average_data(out_count,observable_1)\n", + " p0 = average_data(out_count,observable_0)\n", + " \n", + " # take the prediction to be max(p0, p1)\n", + " if p0 >= p1:\n", + " predictions[i] = 0\n", + " else:\n", + " predictions[i] = 1\n", + "\n", + "# uncomment next four lines for check \n", + "# if i == 0 :\n", + "# QASM_source = qprog.qasm()\n", + "# print(QASM_source)\n", + "# print(p0,p1)\n", + " \n", + " # compute the difference of the labels and return the cost\n", + " cost = sum(abs(predictions - tlabels)) / tpoints\n", + " print(\"The current value of the cost function is:\", cost, end=\"\\r\")\n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "def get_all_predictions(angles):\n", + " \"\"\"Returns a numpy array of all predictions.\"\"\"\n", + " # initialize a variable to store the output predictions of the neural net\n", + " zhats = np.zeros_like(labels, dtype=int)\n", + " \n", + " # loop over all data to get predictions\n", + " for i, pangles in enumerate(qdata):\n", + " # write the program\n", + " qprog = make_program(pangles, angles)\n", + " \n", + " # run the program\n", + " shots = 1000\n", + " \n", + " if mode == \"NFS\": \n", + " out = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " out = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " \n", + " out_count = out.result().get_counts(qprog)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " p1 = average_data(out_count,observable_1)\n", + " p0 = average_data(out_count,observable_0)\n", + " \n", + " # take the prediction to be max(p0, p1)\n", + " if p0 >= p1:\n", + " zhats[i] = 0\n", + " else:\n", + " zhats[i] = 1\n", + " return zhats" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 0.0060569999999999999\r" + ] + } + ], + "source": [ + "mode = \"NFS\"\n", + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(8.89515197858799) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(6.14308213587254) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(7.13449483997346) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 11:59:44\n", + "{'0': 999, '1': 1}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution\n", + "shots = 1000\n", + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "dist = execute(qprog, backend_sim, shots=shots)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, ' + mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training (NFS)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# fraction of total data to use as training data\n", + "train_frac = 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.9857142857142858\r" + ] + } + ], + "source": [ + "# get some random angles\n", + "angs = 2 * np.pi * np.random.rand(3)\n", + "cost = obj(angs)" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.014285714285714285\n", + "Total training runtime took 1.8455156366030374 minutes.\n" + ] + } + ], + "source": [ + "# train the quantum neural network and time how long it takes\n", + "start = time.time()\n", + "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", + "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "[3.321652 6.2743205 5.85861077]\n" + ] + } + ], + "source": [ + "# grab the optimal angles and minimal cost value\n", + "optimal_angles = out['x']\n", + "fval = out['fun']\n", + "\n", + "# print them out\n", + "print(fval)\n", + "print(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "# compute all the predictions of the quantum neural network\n", + "predictions = get_all_predictions(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Results of quantum neural network classification ===============\n", + "Out of 100 total data points:\n", + "The QNN was trained on 70.0% of the total data (70 training points).\n", + "The QNN classified 100 data points correctly (100.0% accuracy).\n", + "================================================================================\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEICAYAAACktLTqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X90XWWZ6PHv00qgpTWYduwC2iSIbZeVarURUGeNra1OiwJzAVuYUKcKZJCLY5cyoxKQCgQcxo51lEIzDlbbYFqKF1tvEbm9REegCtVqpV5YFZP+AEUaCJRWUshz/9j7tCcn58c+5+zf5/ms1dWcnTd7v+85ybPf/b7PfreoKsYYY9JlVNQVMMYY4z8L7sYYk0IW3I0xJoUsuBtjTApZcDfGmBSy4G6MMSlkwd0MIyLNIqIi8gb39f0i8g8V7KdRRA6KyGj/axk/IrJcRNYV+f4TIjInxCqZGmfBPYFEpFdEDrvB808i8m0RGRfEsVR1oap+x2Od5mf93B5VHaeqrwdRrwJ1mCsiD4nIgIj0hnVcL1T17araA6VPBBkislREdorIIRH5o4isEpH6rO8vd0/EH8va9gZ3W7P7eo37+sysMm8VEU83uGSd7P93zvZ1IrLc/XqOiAy5v4+Zf5vd750kIne59X9ZRJ4Skc97ObapjgX35DpXVccB7wbeA1yXW0ActfQZvwLcBfxz1BWploh8DvhXnLbUA2cDzcCPReS4rKL9wI0lrpD6gZurrNLZIvL+It9/xj2ZZ/6d627/GjAOeBtOO84Dfl9lXYwHtfSHn0qquh+4HzgDQER6RKRDRB4GDgFvEZF6EfkvEXlWRPaLyM2ZYCAio0XkqyLyvIg8DXwke//u/i7Pen2FiPzO7YXtEpF3i8haoBHY7Pba/iXP8M4pIrJJRPpFZLeIXJG1z+UiskFEvuvu9wkRacn6/ufder8sIk+KyLwC78UvVHUt8HQl76WInCYiP3GP86CIfDPTw3Z7p/tyyg+7WgFOEJH17s//UkTemVtWRBYA1wKL3ffq13nq8Ubgy8CnVfVHqnpEVXuBRcBpwN9nFf8RMAhcWqRp3wHeISIfKOf9yHEblZ0g3gPcraovqOqQqv4/Vd1YRT2MRxbcE05EpgDnAL/K2rwEaAPGA304f9yvAW8F3gV8GMgE7CuAj7rbW4CLihzrY8By4OPAG3F6YQdUdQmwB/dqQlVvy/Pj3wP2Aae4x7glJ0ifB3QDJwGbgG+6x5wOXA28R1XHA38L9BZ/Vyp2N7AdmAjcBJQ713A+cA/Q4O7rvpxeNqr6I+AWYL37Xr1z5G54H3AC8P2cnz2IcyL/cPZm4HrghtxjZTnkHrOjzPZkux2YlnMy82Ib0CEinxCRqVUc35TJgnty3SciLwI/A36C88ebsUZVn1DV13ACzUJgmaq+oqrP4VwqX+yWXQSsVNW9qtoP3FrkmJcDt6nqY+rYrap9pSrqnoD+Gvi8qv5FVXcA38I5CWX8TFW3uGP0a4FM0HsdOB6YISLHqWqvqvp+WS8ijTi9zOtV9VVV/SmwuczdbFfVjap6BPh3nAB9dgXVmQg8735+uZ4F/ip7g6puAv7MsRN2PquBRhFZWEF9AP6Cc3Io1Hs/RURezPq3yN3+aaAL5wS9y71qq7QOpgwW3JPr71T1JFVtUtWrVPVw1vf2Zn3dBBwHPJv5w8P5Q3+z+/1TcsoXC9ZTqGy89BSgX1VfzjnOqVmv/5j19SGcIY43qOpuYBnOFcNzItItIqeUWwERuTZrsu/OAnV8QVVfyaljOY6+j6o6xLErlXI9D0zMDGnlOBknkOe6DmjHOaGMoKqv4lyN3ARIBXUC+E9gkoicm+d7z7i/j5l/G9zjHlbVW1R1NjAB2ADcIyINFdbBeGTBPZ2yMyH2Aq8CE7P+8N6oqm93v/8sTtDOaCyy373A6R6OmesZoEFExuccZ3+Rnzm2Y9W7VfWvcU5UijPRWBY3wGQm+67MU+RZ4E0icmJOHTNeAcZmXrhzFsN60GS9j+5E9mScto+oTonqPorzmV2QvdGt20KcK7XhO1R9ENgNXFVkv9/GmdT8HyWOn5d7RfJlKjxBqOpLOFeYJ+LMHZgAWXBPOVV9FvgxsEJE3igio0Tk9KzJtQ3AP4nIZBF5E/CFIrv7FnCNiMx2M3HeKiJN7vf+BLylQB32Ao8At4rICSLyDuAynMv1okRkuoh8UESOxxkaOIwzVJOv7CgROQHnSkXcY9WVOoZbxz7gceDLIlInIn8NZPdQn8K5mviIO7Z9Hc5wUbbZInKB2+NehhOgt+U53J+AZimQyaSqAzhB9BsiskBEjhMntfEenF59ofetHfiXIm18DecKaFgqojuh3VPo53KsxWn3Ai+FReR6EXmP+56eAHwGeBF40uPxTIUsuNeGjwN1wC7gBWAjzuU9OJfaDwC/Bn5JziReNlW9B2fc9W7gZeA+nDF9cMbqr3OHfq7J8+OX4KTyPQP8L+AGt7dZyvHAV3CC2h9xhpOuLVD2b3CC/xacXvdhnBObV38PnIWTOngD8N3MN9yAexXOCW4/Tk9+X87P/wBYjPMeLwEucHu7ue5x/z8gIr/MVxF3Uvpa4Ks47/UfcK4c5ucMHWX/zMPAL0q08Xs4VynZpgAPl/i5zDFex3lvvA6rKM4Vw/M4n/2HgI+4k8MmQGIP6zAmP3Fu0nmrqhZLMwyrLp/E6c2/X1X3+LzvHcA8VT3g535NtPJN2BhjYkZV7xKRIzhpkr4Gd1Wd5ef+TDxYcDcmIdwbtIzxxIZljDEmhWxC1RhjUiiyYZmJEydqc3Nz1ft55ZVXOPHEE0sXTAlrb7pZe9PLr7Zu3779eVXNvcdihMiCe3NzM48//njV++np6WHOnDnVVyghrL3pZu1NL7/aKiKe7py2YRljjEkhC+7GGJNCFtyNMSaFLLgbY0wKWXA3xpgUsuBujDEpZMHdGGNSqGRwF5G7ROQ5Efltge+LiPyH+/is34jIu/2vpjHGmHJ46bmvofjC/AuBqe6/NuCO6qtVva4uaG6GUaOc/7tKPhbCGGPSo2Rwdx8U3F+kyPnAd90HJm8DThKRk4uUD1xXF7S1QV8fqDr/t7VZgDfG1A5Pq0K6j/j6oaqeked7PwS+oqo/c19vxXnK/Yi1BUSkDad3z6RJk2Z3d3dXVXmAgwcPMm7cuGHbdu6EwcGRZevqYObMqg8ZqXztTbMo2rts2TIAVq5cGepxwT7fNPOrrXPnzt2uqi2lyvmxtky+B+XmPWOoaifQCdDS0qJ+rLOQb72GD37Q6bHnEoGhoaoPGalaWosDomnvSSedBBDJ+2yfb3qF3VY/smX2kfXUdwo/8T00jY3lbTfGBKNrZxfNK5sZ9eVRNK9spmtnMGOjYR0nSfwI7puAj7tZM2cDA6qa+wDeUHV0wNixw7eNHetsN8aEo2tnF22b2+gb6ENR+gb6aNvc5nvgDes4SeMlFfJ7wKPAdBHZJyKXiciVInKlW2QL8DSwG/hPnCfER6q1FTo7oanJGYppanJet7ZGXbPkiTrrqL/fsp6Sqn1rO4eOHBq27dCRQ7RvbU/kcZKm5Ji7ql5S4vsK/E/fauST1lYL5tXKZB0dcv9uMllHEM5729UFzz3nHDfM469evTq4nfusa2cX7Vvb2TOwh8b6RjrmddA6Mx6/+HsG8j/Hu9D2uB8naewOVVNQe/uxwJ5x6JCzPazj506Ah3H86dOnM3369GAP4oO4D0c01uef5Cq0Pe7HKVfuPED/4WIZ5f6z4G4K2lOg41Noe1qOv3nzZjZv3hzsQXwQ9+GIjnkdjD1u+OTX2OPG0jHP38mvsI5Tjq6dXXzyB58cduLtfbE31BOvBXdTUNRZR1Edf8WKFaxYsSLYg/gg7sMRrTNb6Ty3k6b6JgShqb6JznM7fR82Cus4heTL1PnM/Z9h8PXhN9soymfu/0wodYIIn6Fq4q+jY/iYOwSXddTV5Qy37NnjBO+ODuffc88NL5e0rKcgx8Qb6xvpGxj5OM2ohyOytc5sDSXIhnWcXJmhscwVVGZoLPeKKuPA4QOh1c167qagsLKOCi0XAc4xk5r1FPSYeByHI2pNoaGxOLDgbopqbYXeXmdis7c3mMBabOK2oSH44wcl6DHxqIcjTPlDYBPGTAioJiPZsIyJXNQTt0EJY0w8quEI4yg0NDZhzAReevUljgwdObpNEL6+8Ouh1c167iZyUU/c5lq7di1r166tej9xTdEz/ik0NPb1hV/n23/37WFXVc0nNYd6IrbgbiIXt+UipkyZwpQpU0oXLMHGxNOv2NBY68xWepf1MnTDEL3LemkY0xBq3RIb3DO3xW/fbrelJ13clotYv34969evr3o/NiaeLoUWJ8sN4nH5fBM55h71bfHGf3FaLuKOO5yHiS1evLjqfdmYeDoUSnkEYvv5JrLnHvVt8caY2hL3u4HzSWRwT2t2hTEmnuJ+N3A+iQzuccuuMMakWxIznxIZ3OOWXWFqlz0BqDYkMfMpkcE9O7sCos+uMOWJ+gEgpWzcuJGNGzeWLBf3JXeNf5KY+ZTIbBk4ll3R0+Pclm6SIQmZThMnTvRUrtgkW5z/6E1lkpb5lMieu0muJGQ6rVmzhjVr1pQsl8RJNlM7LLibUCUh08lrcE/iJJupHRbcTajSlOmUxEk2UzssuJtQpSnTKYmTbKZ2JHZC1SRTZtI096lLcZlMLVfSJtlM7bCeuwdxT91LmjAeAGL8Zzn9yWI99xKSkLpn/LVly5aoqxA7SVw4q9ZZz72EJKTuGX+NHTuWsbkTAzUuiQtn1ToL7iUkIXXP+GvVqlWsWrUq6mrEiuX0J48F9xLSlLpnvNmwYQMbNmyIuhqxYjn9yWPBvYQ0pe4ZUynL6U8eC+4lxO0RcMZEwXL6k8eyZTyI0yPgjImK5fQni6eeu4gsEJEnRWS3iHwhz/cbReQhEfmViPxGRM7xv6rGJJfliJuwley5i8ho4HbgQ8A+4DER2aSqu7KKXQdsUNU7RGQGsAVoDqC+xgSup6fH1/1ZjriJgpee+5nAblV9WlUHgW7g/JwyCrzR/boeeMa/KhqTbJYjHm/VXFXF+YpMVLV4AZGLgAWqern7eglwlqpenVXmZODHwJuAE4H5qro9z77agDaASZMmze7u7q66AQcPHmTcuHFV7ycprL3BW79+PQCLFy/2ZX/bnx3xp3DU7JNnD3ttn2+4+g/30zfQx5AOHd02SkbRVN9Ew5gGX3/Wr7bOnTt3u6q2lCrnZUJV8mzLPSNcAqxR1RUi8l5grYicoZrVakBVO4FOgJaWFp0zZ46HwxfX09ODH/tJCmtv8JYvXw7g23GXrlxK30DfiO1N9U30XtI7bJt9vuFqXtlc+LNZ1lvRz2Z+vmNex7Bht7Db6mVYZh8wJev1ZEYOu1wGbABQ1UeBEwBvzyozJuUsRzy+qrnztliZODxP10twfwyYKiKniUgdcDGwKafMHmAegIi8DSe4/9nPihqTVJYjHl/V3HlbqkzU8yolg7uqvgZcDTwA/A4nK+YJEblRRM5zi30OuEJEfg18D1iqpQbzY8yW+DV+a53ZSu+yXoZuGKJ3Wa8F9pio5qoq38/minLtHU957qq6RVWnqerpqtrhbvuSqm5yv96lqu9X1Xeq6ixV/XGQlQ5SZonfvj5QPbbErwX4aIV5wh0zZgxjxowJ7gAmNqq5qsr+2UKiXHvHlh/I4dcSv9b790/YJ9z777+f+++/P5idm9ip5qoq87PrLlgXu3kVC+45/Fji13r//rI19U3cxXFexYJ7jkJL+ap674FbMPJX2Gvq33TTTdx0003B7NykVtzmVSy458i3xG+G1x54sWBkwzXlC3tN/a1bt7J169Zgdu6jON8daaJnwT1H9hK/+XjpgRcKOg0NNlxTibisqR+nYJpZr6ZvoA9FY5FXbeLFgnsera3Q2+us355PqeGAQsEIbLimEnFYUz9uwdTWqzGlWHAvotLhgELBqL8/f3l7HmtpmRPu0JDzf9jr68ctmNozTU0pFtyLqGY4IF8wsuexJsOECROYMGHCsG2FgmahtUWCZs80NaVYcC/C7+GASk8W2ZOwO3faGH3Q7r33Xu69995h2woFTUEiGZrxY72aOM0hGP9ZcC/Bz+EALyeL3Gyaq64aPgk7OGiTsFHomNeB5FkgVdFIhmaqzauO2xyC8Z89QzVkxZ7Hmrn5KTPp2tcHd97pBPVsmUlYe65rML74xS8CcOuttx7d1jqzlUu/f2ne8lGNc1fzTNNicwhR52cbf1jPnfjknue7+anQ8ms2CRucRx99lEcffXTE9kJriCRxnNsmZNOv5oN7nJYKKCdg2yRs+NK0LrtNyKZfzQf3OC0VUChg5+bbR3EDj4nn+iGVStOJyuRX88E97HVLiimUTXPllccmYevqwr+BxxwTp/VDqsl2SdOJyuRX8xOqjY3OUEy+7WHLBOz2dufk0tjoBPzsQN7TAzX0iM1ITJ48OeoqlJTJdslMimayXQDPAbqaCVkTfzXfc4/LuiUZUd+JaWDdunWsW7cu6moUFbc7Zk381Hxwj8O6JcaUy7JdTCk1PywDxXPPTe1ZtmwZACtXroy4JoU11jfmXfrAsl1MRs333I3JtWPHDnbs2BF1NYqybBdTigV3YxLIsl1MKTYsY0xCWbaLKcZ67sYYk0IW3BMis/7N9u327NWgTZs2jWnTpkVdDYMtS1wNC+4JkL3+DdizV8tV7sJwnZ2ddHZ2hlE1U4QtS1wdC+4JEKf1b5ImTgvDmfJUcqOW9fSPseCeAHFa/yZpKjkxtrW10dbWFmzFfJLmYFbujVph9PS9vN9x+UwsuCeAPXu1cpWcGJ966imeeuqpYCrko7QPW5S7LHHQSzJ4eb/zlfnEfZ9g4m0T2f7s9lCDvQX3BIjb+jdJkuYTY9rXlyn3Rq2gl2Tw8n7nK3Nk6AgHDh8ACPUEbME9AbLXvwFb/6YcaT4xpn19mXJv1Ar6ASRe3m8v731YJ2BPwV1EFojIkyKyW0S+UKDMIhHZJSJPiMjd/lbTZFaLnD3bVossR5oXhquFpymVs35+0EsyeHm/vb73YZyASwZ3ERkN3A4sBGYAl4jIjJwyU4EvAu9X1bcDywKoqzEVKXcZ5VmzZjFr1qwwqlaVJK4vkzvZ2H+437d9B70kg5f3O1+ZfMI4AXtZfuBMYLeqPg0gIt3A+cCurDJXALer6gsAqvqc3xU1JixxXg0yWyZotW9tZ8/AHhrrG+mY1xHbJQnyPWCkb6CPrp1dvtU5yCUZvLzfuWUaxjTw8uDLDL4+eLRMWCdgL8H9VGBv1ut9wFk5ZaYBiMjDwGhguar+yJcaGmMKStL6MvkmG4d0iPat7Ylpg5f3O7dM186uo2PsTfVNoZ2ARVWLFxD5GPC3qnq5+3oJcKaqfjqrzA+BI8AiYDLw38AZqvpizr7agDaASZMmze7u7q66AQcPHmTcuHFV7ycprL3B63BnW9sjuEsszZ/v9me3j9g2+fjJ7Ht1H7NPnh1BjcLl12c7d+7c7araUqqcl577PmBK1uvJwDN5ymxT1SPAH0TkSWAq8Fh2IVXtBDoBWlpadI4PDwPt6enBj/0khbU3eMuXLweI5H1O8+e7dOXSEQ8Y+eq0r/KNP32D3kt6o6lUiML+bL1kyzwGTBWR00SkDrgY2JRT5j5gLoCITMQZpnnaz4qGqdy1SIwxpeWbbBwlo2I9AZxkJXvuqvqaiFwNPIAznn6Xqj4hIjcCj6vqJvd7HxaRXcDrwD+r6oEgKx6UzFokmVvWM2uRQDrS54yJSr4Jyab6Ji6YeUHENUsnT3nuqrpFVaep6umq2uFu+5Ib2FHHZ1V1hqrOVNXqB9OrVGnv2xbpMiY4uXnrDWMaoq5SaqXySUzV9L5tkS7z3ve+N+oqGFO1VAb3Yr3vUsG9sfHYuum5201tuPXWW6OugjFVS+XaMtX0vtO8FklYbELamOilMrhXsxJgmtciCUMaHo5x4YUXcuGFF0ZdDeOTqNZXD3KpBS9SGdyr7X2XuxaJOSYNE9IHDhzgwIFEJnuZHFGteZ/vuJmlFsKSyuBuve/o2IS0iZOo1rwvttRCWFI5oQpOILdgHj6bkDZxEtWa93FYaz+VPXcTHZuQNnES1Zr3cVhr34K78VUahsTmzZvHvHnzoq5G4sTlwdDZolrzPg5LLaR2WMZEJ+lDYtdff33UVUicfGu1t2127hyMcjnfqNa8j8NSCxbcjTFVKzZxGfVa7VGteZ973J6enlCPb8MyxuRYuHAhCxcujLoaiRKHCUQznAV3Y3IcPnyYw4cPR12NRInDBKIZzoK7MaZqSXxYd9pZcDfGVK11Ziud53bSVN+EIDTVN9F5bmfk4+21zCZUjTFlyTzwOTf7JEkP664FFtyNyfHRj3406irEVlxTHs1IFtyNyXHNNddEXYXYinPKoxnOxtyNMZ5ZymNyWHA3JsecOXOYM2dO1NWIJUt5TA4L7sYYzyzlMTksuBtjPLOUx+SwCVVjTFks5TEZrOdujDEpZMHdmByLFi1i0aJFUVejInFcU91Ew4ZljMlx1VVXRV2FitgNRiab9dyNyXHo0CEOHTpUumDMRPUwaBNPFtyNyXHOOedwzjnn+La/sIZK7AYjk82CuzEBygyV9A30oejRoZIgArzdYGSyWXA3JkBhDpXYDUYmmwV3k1hdXdDcDKNGOf93xTAxJMyhErvByGTzlC0jIguArwOjgW+p6lcKlLsIuAd4j6o+7lstjcnR1QVtbZCZ9+zrc14DtMYoljXWN9I30Jd3exDsBiOTUbLnLiKjgduBhcAM4BIRmZGn3Hjgn4Cf+11JY3K1tx8L7BmHDjnbq7V06VKWLl1a/Y6woRITHS/DMmcCu1X1aVUdBLqB8/OUuwm4DfiLj/WrWUkYcojSngKjGoW2l8PP4G5DJcmW5JvCRFWLF3CGWhao6uXu6yXAWap6dVaZdwHXqeqFItIDXJNvWEZE2oA2gEmTJs3u7u6uugEHDx5k3LhxVe8nTvr7nWGGoaFj20aNgqYmqKtLX3uLKfT57twJg4Mjy9fVwcyZ1R1zYGAAgPr6+up2VIEgf5/7D/ez/+X9DL4+SN3oOk4dfyoNYxoCOZZXcf777T/cT99AH0N67A9xlIyiqb6povfNr7bOnTt3u6q2lCrnZcxd8mw7ekYQkVHA14ClpXakqp1AJ0BLS4v6sWZ2T09P6tbebm52gnuupiZYsyZ97S2m0Oe7f//wMXeAsWOhsxOqfXsyx+vp6SlZttDzRCsV1O9z7t2r4AwPRX0VEee/3+aVzXnnS5rqm+hd1lv2/sJuq5dhmX3AlKzXk4Fnsl6PB84AekSkFzgb2CQiJc8sJr8ghxzSorXVCeRNTSDi/N/ZGe5kapg57NWyu1fLl/SbwrwE98eAqSJymojUARcDmzLfVNUBVZ2oqs2q2gxsA86zbJnKNRZIpCi0vVa1tkJvrzN81dsbfpZMkgJm0gNVFJJ+U1jJ4K6qrwFXAw8AvwM2qOoTInKjiJwXdAVrUUeHM8SQbexYZ7uJj2oDZpiTdUkPVFFIeqaTp5uYVHWLqk5T1dNVtcPd9iVV3ZSn7BzrtVcnDkMOprRqAmahIZ3+w/1+VxNIfqCKQtIznWzJ35hqbbVgHpVPfepTnsp1zOvIO0npJWAWGtLZ//L+8irrUSYg+Tn5WwuSfFOYBfeE6+pybtzZs8cZk+/osJNCtRYvXuypXDUBs9DQzeDrefI7fZLkQGXKl7q1ZWrp5p/MLfh9faB67Bb8NLc5DHv37mXv3r2eyrbObKV3WS9DNwzRu6zXc/AsNHRTN7rOcz2NKSZVwb3Wgl2Qt+DXsiVLlrBkyZJAj1FoDPzU8acGelxTO1IV3Gst2Fk+vL8yV30/+Qls2xZsp6DQZF3Ud4ya9EjVmHutBbvGxvx3slo+fPlyV5l89dXgV5nMNwbu5a5YY7xIVc+91m7+sXx4/9TaVZ9Jv1QF96iCXVSTuJYP75+0XfUleTVD449UBfcwgl1uIL/qqmgncaO+BT8thl/dfc79l/+qL+6BM0lr3pjgpCq4Q7DBLl82zp132uV8Ggy/6jsXODfvVV8SAmeS1rwxwUldcA9SvnHZQsvhJ/Vyvhxpuqcg+6oPnuSUU57Me9WXhMBpi4QZsOBelnICdloncTPSeE9B5qrvAx/4R6ZO/ce8V33FAmdchmtskTADFtzLUihgS87jTPJezqeolwu1m11SKEA2jGmIzXCNLRJmwIJ7WQpl41x5ZfFJ3DT2ctOWXeJVocAJxGa4JumrGRp/pOompqBlAna5C3UV6+UmNbulVm+gKrRY2JLv51+uIKpxblskzFjPvUyVZOOksZdbyzdQ5VssLG3j3HGZP4ibJL0v1nMPQRp7uZVexSTBddddV/bPVLO2e9zkPkw7M38A1PTVQNLeF+u5hyCtvdy03kA1f/585s+fX9bPpGmcOwnpnlFI2vtiPfcQpLmXm0Y7duwAYNasWWX9XFrGuS1PPr9SabBxe8qVBfeQ2GPzkmPZsmVA7a7Q2FjfSN/AyHHEpM4f+KXQ+5JJg43bcI0NyxhjhrE8+fySkAabzYK7MWaYNM0f+KnQ+9J/uD9v+aiHsWxYxhgzQlrmD/yW731p39oey2Es67n7LG3LDBhTC6rJX4/rMJYFdx/FZZkBO8FU55ZbbuGWW26JuhqxlqSbeUqpdhnnuA5j2bCMj+KwzEDus0AzJxiwbB2v3ve+90VdhVhL2s08pRTLX/fanjgOY1nP3UdxWGagVldr9NMjjzzCI488EnU1YitpN/OUkta8fuu5+ygOywzE4QSTdNdeey1Qu3nupaQtGKY1r9967j6KwzIDhU4kSV7HxsRL2hZJi+uEaLUsuPsojAd0lxKHE4xJt7QFw7hOiFbLU3AXkQUi8qSI7BaRL+T5/mdFZJeI/EZEtopIk/9VDU812Sa5i2lBuJkrcTjBmHRLYzDMt4xz0pUM7iIyGrgdWAjMAC4RkRk5xX4FtKjqO4CNwG1+VzQsfqYzRpUaGfUJxqRfGoNh2njpuZ8J7FbVp1V1EOgGzs8uoKoPqWpm+nyURSCFAAAK7klEQVQbMNnfaobHz2yTOGSuxCX3Pkh+5/WvXLmSlStX+lE1YyIjqlq8gMhFwAJVvdx9vQQ4S1WvLlD+m8AfVfXmPN9rA9oAJk2aNLu7u7vK6sPBgwcZN25c1fvJ2L698Pdmz45uXxnltnfnThgcHLm9rg5mzqysDsX098P+/c4x6+rg1FOhoaHy/ZVqb3+/c8IaGjq2bdQoZziqmuNGxe/f57irpfb61da5c+duV9WWkgVVteg/4GPAt7JeLwG+UaDspTg99+NL7Xf27Nnqh4ceesiX/WQ0Nak6fdzh/5qaot1XRrntFclfB5HK61DIunWqY8cOP87Ysc72SpVqbxDv8YMPPqgPPvhg5Tuogt+/z3FXS+31q63A41oivqqqp2GZfcCUrNeTgWdyC4nIfKAdOE9VX/Ww38BUc5nuZ7ZJHDJXwkyNjGIYKoi8/ptvvpmbbx5x4WlMongJ7o8BU0XkNBGpAy4GNmUXEJF3AatxAvtz/lfTu2rHmP3MNolD5kqYJ5gobqCyvH5j8isZ3FX1NeBq4AHgd8AGVX1CRG4UkfPcYv8GjAPuEZEdIrKpwO4C50fv0c9ng0b9nNEwTzBRBNo4XB0Z/6RpQbKoecpzV9UtqjpNVU9X1Q5325dUdZP79XxVnaSqs9x/5xXfY3Dievt90Cs1Ftt/WCeYKAJtHK6OjD+qXZ3RDJe6O1Qr7T0GGXyDTkeMS7pjVIE26qsj44+0LUgWtdQF90p6j0EHx6AnGuOQT5+RhkC7evVqVq9eHXU1ak7aFiSLWuqCeyW9x0qDo9fefrVDRdnH2blz5HHiOhSVVNOnT2f69OlRV6PmpG1BsqilLrhD+b3HSoJjOb39aiYac48zODjyOJYxUplCJ+fNmzezefPmKKtWk9K2IFnUUhncy1VJcCynt1/NRKOX41jGSPmKnZxXrFjBihUroq5izUnjgmRRsuBOZcGxnN5+NRONXo5jGSPli9M8hTkmzguSJS1N057ExLEg2N7uBM3GRiewFwuO5T51qbW1smDr9TiV7r9WFTtpNjeHWhWTAEl8bqz13F3ljtOHNRRiQy7BsHkKU44kpmlacK9QWEMhucepq7MhFz/YSdOUI4lpmhbcqxBWTnf2cWbODDawB30nbVwUOzmvXbuWtWvXRl1FEyNJTNO04G6OisudrmEpdHKeMmUKU6ZMKfajpsYkMU3Tgrs5yjJIHOvXr2f9+vVRV8PESBLTNC1bxhxld7o67rjjDgAWL14ccU1MnLTObI11MM9lPXdzVKHH0iXxcXVxlLQ8aZNs1nM3JgRJzJM2yWY9d3NUf3952413ScyTTru0X0mlIrjXSvpe0OzGnuAkMU86zWrhwSCJD+79/bWVvhcku7HHsXHjRjZu3OjrPpOYJ50k5fbCa+FKKvHBff9+S9/ziy1A5pg4cSITJ070dZ9JzJNOikp64bVwJZX44D44mH97raXv+SUNT1Kq1po1a1izZo2v+0xinnRSVNILL3TF1DCmITXj8IkP7nV1+bc3NNg4vKlMEMEd4r2cbZJV0gvPdyVVN7qOl159yddx+Ozhop3P7Qz1ZJH44H7qqSPHievq4KWXbBzemFpQyXxGviup8XXjOTJ0ZFi5asbhc4eLBl8fDHXSNvHBvaFh5Djx+PFwZPhnZOPwxqRUpfMZuVdS/Yfz5/xWOg4f9aRt4oM7jBwnLpSXbePwxqSPX/MZfmc0RT1pm4rgnsvytY1xpP1GnQw/5jP8zmiKOv01lcHd8rVNNbZs2cKWLVuirkbVvKYI1soJoBS/M5qiTn9N5doylTwT1ZiMsbk9g4QqNuabCVi25s1wfq78mNlP+9Z29gzsoW50Xajpr6nsuYPla5vKrVq1ilWrVkVdjap5GfONetIv7bKHi2a+eWaoJ8zUBndjKrVhwwY2bNgQdTWq5mXMN+pJPxMcC+7GpJSXMd+oJ/1McDwFdxFZICJPishuEflCnu8fLyLr3e//XESa/a6oMaY8XiYIo570M8EpOaEqIqOB24EPAfuAx0Rkk6ruyip2GfCCqr5VRC4G/hWwZ5QZE7FSE4S5k36N9Y10zOuoycnUtPGSLXMmsFtVnwYQkW7gfCA7uJ8PLHe/3gh8U0REVdXHuhpjApC0Z4Mab6RU/BWRi4AFqnq5+3oJcJaqXp1V5rdumX3u69+7ZZ7P2Vcb0AYwadKk2d3d3VU34ODBg4wbN67q/SSFtTfdrL3p5Vdb586du11VW0qV89Jzlzzbcs8IXsqgqp1AJ0BLS4vOmTPHw+GL6+npwY/9JIW1N92svekVdlu9TKjuA6ZkvZ4MPFOojIi8AagH7MmbxhgTES/B/TFgqoicJiJ1wMXAppwym4B/cL++CPi/Nt5ujDHRKTkso6qvicjVwAPAaOAuVX1CRG4EHlfVTcB/AWtFZDdOj/3iICttjDGmOE9ry6jqFmBLzrYvZX39F+Bj/lbNGGNMpewOVWOMSSEL7sYYk0IW3I0xJoUsuBtjTAqVvEM1sAOL/Bno82FXE4HnS5ZKD2tvull708uvtjap6l+VKhRZcPeLiDzu5VbctLD2ppu1N73CbqsNyxhjTApZcDfGmBRKQ3DvjLoCIbP2ppu1N71CbWvix9yNMcaMlIaeuzHGmBwW3I0xJoUSE9xr7SHdHtr7WRHZJSK/EZGtItIURT39Uqq9WeUuEhEVkcSmz3lpq4gscj/fJ0Tk7rDr6CcPv8uNIvKQiPzK/X0+J4p6+kVE7hKR59wn1OX7vojIf7jvx29E5N2BVERVY/8PZ6nh3wNvAeqAXwMzcspcBdzpfn0xsD7qegfc3rnAWPfrT6W9vW658cBPgW1AS9T1DvCznQr8CniT+/rNUdc74PZ2Ap9yv54B9EZd7yrb/DfAu4HfFvj+OcD9OE+wOxv4eRD1SErP/ehDulV1EMg8pDvb+cB33K83AvNEJN/j/5KgZHtV9SFVPeS+3IbzhKyk8vL5AtwE3Ab8JczK+cxLW68AblfVFwBU9bmQ6+gnL+1V4I3u1/WMfNJboqjqTyn+JLrzge+qYxtwkoic7Hc9khLcTwX2Zr3e527LW0ZVXwMGgAmh1M5/Xtqb7TKcnkBSlWyviLwLmKKqPwyzYgHw8tlOA6aJyMMisk1EFoRWO/95ae9y4FIR2Yfz3IhPh1O1yJT7910RTw/riAHfHtKdEJ7bIiKXAi3ABwKtUbCKtldERgFfA5aGVaEAefls34AzNDMH54rsv0XkDFV9MeC6BcFLey8B1qjqChF5L85T3c5Q1aHgqxeJUGJVUnrutfaQbi/tRUTmA+3Aear6akh1C0Kp9o4HzgB6RKQXZ5xyU0InVb3+Lv9AVY+o6h+AJ3GCfRJ5ae9lwAYAVX0UOAFnka208vT3Xa2kBPdae0h3yfa6wxSrcQJ7ksdkoUR7VXVAVSeqarOqNuPMMZynqo9HU92qePldvg9nwhwRmYgzTPN0qLX0j5f27gHmAYjI23CC+59DrWW4NgEfd7NmzgYGVPVZ348S9cxyGTPQ5wBP4cy8t7vbbsT5IwfnF+IeYDfwC+AtUdc54Pb+H+BPwA7336ao6xxke3PK9pDQbBmPn60A/w7sAnYCF0dd54DbOwN4GCeTZgfw4ajrXGV7vwc8CxzB6aVfBlwJXJn1+d7uvh87g/pdtuUHjDEmhZIyLGOMMaYMFtyNMSaFLLgbY0wKWXA3xpgUsuBujDEpZMHdGGNSyIK7Mcak0P8HitK8ZHBmvokAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# compute statistics of the QNN\n", + "ntrain = int(train_frac * npoints)\n", + "ncorrect = npoints - sum(abs(predictions - labels))\n", + "acc = ncorrect / npoints * 100\n", + "\n", + "# print them out\n", + "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", + "print(\"Out of {} total data points:\".format(npoints))\n", + "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", + "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", + "print(\"\".center(80, \"=\"))\n", + "\n", + "# plot the points, line y = x, and prediction\n", + "plt.plot(ys, xs, '--k')\n", + "for i in range(npoints):\n", + " if predictions[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + "\n", + "plt.grid()\n", + "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing on device noise simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# Testing on device noise simulator\n", + "mode = \"DNS\"" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 0.00011199999999999999\r" + ] + } + ], + "source": [ + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(-1.51785048443617) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(0.248786966568569) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(9.26351197606004) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 12:45:53\n", + "{'0': 904, '1': 96}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdAAAAFCCAYAAABB84xIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XmcVNWd/vHPI4sCAezGFroxgAiDDTjYghpNUOIyLtHEqKMmGuOYxCExGsfELE4Wl5HMYMzoxMmYmGQclzGumUQDvxhF454YRMKWHkwLCLTYLAIC0tB+f3/c205RVC916Q36eb9e9eqqe889dW7X8tQ599QtRQRmZmZWnL06uwFmZma7IweomZlZBg5QMzOzDBygZmZmGThAzczMMnCAmpmZZeAAtS5J0lOSPtvEumGS3pbUo6PbtaeQtEDSlPT6NZLu7uQmdWmSRkgKST3T200+P637cIBakyR9UdIfJW2VdEdnt6dRRCyLiPdFRAO07s1M0t6SvitpmaQtkhZL+ook5ZR5StI7kt6fs+wESUtybi+RtEpSv5xln5X0VGvaLukiSQ3pB4C3Jb0m6T8l/VVOmcY361/nbXu3pGtybl+dbv+2pOWS7mtNGwAiYlxEtKrNHUHSeEm/kbRaUsEvp0s6T9IiSZsk/UXS5I5up1kuB6g1ZyXwT8DPOrshbeAB4HjgVKA/8Cng74Gb8sptAr7VQl09gS/tQlteiIj3AQOBE4AtwGxJ4/PKfUDSBwtVIOnTJPtwQlrXJOCJXWhTZ9sG3A98ptBKSScC/wL8HcnjdwxQ02Gt6ySNPV7rmhyg1qSIeDgi/gdYk2V7SSdK+rOk9ZJulfS7xp5i/rBh/hBZ6iBJf0i3/6Wk0vyykm4AJgO3pj2xWwu043jgb4CzImJ+RGyPiBeBC4AvSRqZU/zfgE9IGtXMrt0IfEXSvln+L40ioiEi/hIRXwB+B1yTV2Q6yQeYQg4HfhMRf0nreiMiftza+0570ifkLNpH0n2SNkp6WdKEvLJXSfpT2vv7qaTBkmam5R+XVJJT/lOSlkpaI+kfC9xXof9FdUT8FFjQRJFrgesi4sWIeDciVkTEihb2cUraM/+qpDcl1Uo6Q9Kpkv5X0lpJV+eU30vS19Pe7RpJ9zc+55pQ8PmZ1vVRJcPkb6UjG5U56yL3+SXpDkn/lNfmr0l6A/jPnGVfztmPv8vZfm9J31MyurJK0m2S+jT3v7G24QC1diFpP+Ah4JvAfsBfgIK9qWZcCFwMVADbScJtBxHxj8AzwBfTYd0vFqjnROD3EfF63ra/B5aT9EwbrQBuZ+cwy/VH4CngK63dkVZ4mOSDQK5/B/6qifB5EbgwDbZJyjsenAbBo0Xc/8dIeumlwH8D/yOpV876s0j+j38FnA7MBK4meWz3Ai5P73cs8B8kveMKYBBwQBHt2Em6b5OAMkmvpmFyaytDYgiwDzAU+DbJY3sBMJHk//3tnA9QlwNnAMembV9H8hg0peDzU8lw/L3AFUAZMAN4RFLvVu7yEJLHYThwSc6ygel+fAb495wPLf9C8rgcCozK2VdrZw5Qay+nAgsj4sGI2AbcDLxRZB13pT3GxmHVc/KDopX2A2qbWFdL8iaX67vA6ZLGNVPnt4HLJOVvm9VKkjfNXO8AN1CgFxoRdwOXASeR9F7flPT1nPX/HBGnFXH/s3Meq++ThM4Hctb/ICJWpb2+Z0g+kMyJiK3AL4CqtNzZwKMR8XS67lvAu0W0o5DBQK+07skkQVFF8uGsJduAG9L9+jnJc+GWiNgYEQtIerx/nZb9e+AfI2J52vZrgLObGUZt6vl5LvDriPhter/fA/oAR7dyf98FvhMRWyNiS85+XBcR2yJiBvA2MEaSgM8B/xARayNiIzANOK+V92W7wAFqmaTDd40TYc4vUKQCeK/HF8mvFrxeoFxzcssvJXkT3a/oxsJqoLyJdeVAXe6CiKgDbgWua6rCiJgPPAp8vakyRRoKrC2w/HZgsKTTC7Thnog4AdgXmApcJ+mkjPef+1i9S9Izr8hZvyrn+pYCt9+XXs9/3DeR8RBAXv2QhHhtRKwmCflTW7HtmsbJZjn1NNX24cAv0mHXt4BFQANJgBfS1POzIr0NvPf/fJ3kMW6Nuoh4p8B+bM+5vTltdxnQl+QYemO7/x87fyi0duAAtUwi4pR0yPR9EXFPgSK1QO5sVuXeJpms0zfn9pACdeSWH0byKXx1oea00NzHgSOVM7s2bdMRab1PF9jmRuDDJEN9TfkOyaf/1r4xNufjJD27HaQ9mGuB6wHlr28sExEPAH8C8icitVbuY7UXybDrygz15D/ufUmGcTOLiHUkgd7ePx31OnBKROybc9mnmWOtTT0/V5KEMbDDc7+xns00/9wvZj9Xk3wIGJfT5oHpxDJrZw5Qa1I6SWcfoAfQQ9I+zQxn5fs1ME7Smek2l7PjG8UrwDFKvtM5EPhGgToukDQ2fRO+DngwpzeRaxUwssByACLicZIZqg9JGieph6QPAPcAd0ZEdYFt3iKZofvVZup9Fbgv3bf3pJNGrmlqu5xyPSQdKOkHwBSSoCzkLmBv4OScbS+S9BFJ/dPJL6cA44Dft3S/TZiY81hdAWwlOc5arAeB0yR9KD3mdx2teJ9RYh+gd3p7H0l75xT5T5Ih8/3TY39XkIwAtKXbgBskDU/bUCbpY82Ub+r5eT/wEUnHp8eRv0zy/3w+3e4V4JPp438yyTHXTNLe7e3Av0raP2330NyRiHTS0pSs92FNc4Bac75J8un26yQTL7bQuuNOpMNsfwv8M8kQ3mjguZz1vyUJnz8Bsyn8ZngXcAfJsdN9yAuqHLeQHKtaJ2mniUaps4AnSYa33gFeSK9f0kT5xnoLBXau64B+ecveT86+FnCUpLeBDSSTkQYAh0fEvEKF0zfl77DjMdINJJN4lgFvkczY/XxEPAvvfUd0Zgttz/VLkmN360gmAJ2Z9n6Lkh5XvJRkIlJtWt/yVmw6nOT51TgLdwuQ+8HmeuAl4H9JhlbnkBwfbku3AL8CHpO0keQDxJHNlC/4/Ew/kF0A/ICkh3g6cHpE1KfbfSld9hZwPvA/u9jurwGvAi9K2kAy4jIGQNIBJMdLCz63bNfIP6htHUXJyQbujoifdIG2/BfJ0OupOW9sbVHvAcADEXFUW9W5u1NyIorPpiMB1oEkXUAyvFtohMd2kb+ka93VZ4ErgcPINlRZUEQsBxye1iWks7WtnXgI17qldOLNv6QnVLAOkDdzO/dydctbN1nn1U3UWczwtVkmHsI1MzPLwD1QMzOzDBygZmZmGXTrSUSDBg2KYcOGdXYzzMysC3nllVdWR0SLZ3Pq1gE6bNgwZs2a1dnNMDOzLqS0tHRpy6U8hGtmZpaJA9TMzCwDB6iZmVkGDlAzM7MMHKBmZmYZOEDNzMwycICamZll4AA1MzPLwAFqZmaWgQPUzMwsAweomZlZBg5QMzOzDBygZmZmGThAzczMMnCAmpmZZdChASrpGEm/krRCUki6qBXbHCLpd5K2pNt9W5LyypwlaaGkrenfj7fbTpiZmdHxPdD3AfOBLwFbWiosaQDwW2AVcDhwOXAVcGVOmaOA+4B7gEPTvw9IOrKtG29mZtaoZ0feWUTMAGYASLqjFZucD/QFPh0RW4D5kiqBKyV9PyICuAJ4MiJuSLe5QdKH0+WfaOt9MDMzg65/DPQo4Jk0PBv9BqgARuSUeSxvu98AR7d768zMrNvq0B5oBkOA5XnLVuWsey39u6pAmSGFKpR0CXAJQHl5OS+//DIAFRUV9O3bl1dffRWAgQMHMnLkSObMmQNAjx49mDBhAtXV1WzatAmAyspK1q5dy6pVyd0fcMAB9O7dm5qaGgBKSkoYNmwYc+fOBaBXr14ccsghLFq0iC1bks8EY8eOpa6ujrq6OgCGDx+OJJYsWQLAoEGDKC8vZ/78+QDsvffejBs3jgULFrB161YAxo8fT21tLWvWrAFgxIgRRARLly4FoKysjLKyMhYuXAhAnz59qKysZN68eWzbtg2ACRMmsGzZMtatWwfAyJEjqa+vZ/ny5N8/ePBgSktLWbRoEQD9+vVjzJgxzJ07l4aGBgCqqqqoqalh/fr1AIwaNYrNmzezcuVKGv/fAwYMoLq6GoD+/fszevRo5syZQ0QgiaqqKhYvXszGjRsBGDNmDBs2bKC2ttaPkx8nP05+nDrkcWotJaOgHU/S28AXI+KOZso8BrweEZ/JWTYcWAIcFREvSqoHPhMRd+WU+TTwo4jYp7k2VFVVxaxZs3ZtR8zMbI9SWlo6OyImtVSuqw/hvsHOPcn907+rWiiT3ys1MzNrM109QF8AJkvK7UmeCKwk6YU2ljkxb7sTgefbvXV7gMcff5wjjjiCiRMncvPNN++0/vXXX+eMM87gQx/6EKeffjorVqx4b929997LpEmTmDRpEvfee+9O237yk5/k6KN9KNrM9kwd/T3Q90k6VNKh6X0PS28PS9d/V9ITOZv8N7AZuEPSeElnAl8HGmfgAtwCHCfpG5IOlvQN4MPAzmlgO2hoaOCrX/0q999/Py+88AIPPfQQf/7zn3co861vfYtzzz2XZ599lquuuorrr78egHXr1jF9+nR++9vf8vjjjzN9+nTeeuut97Z75JFH6NevX4fuj5lZR+roHugkYE566QNcm16/Ll1fDhzUWDgi1pP0JiuAPwL/DtwEfD+nzPPAecCngT8BFwLnRsTv23lfdnuzZ8/mwAMPZMSIEfTu3ZszzzyTmTNn7lCmurqaY445BoDJkyczY8YMAGbNmsWUKVMoKSlh3333ZcqUKTzxRPLZ5+233+aHP/whX/7ylzt2h8zMOlBHfw/0KUDNrL+owLJ5wDEt1Psg8OAuNq/bqa2tZejQoe/drqioYPbs2TuUGT9+PI888ghTp07l0Ucf5e2332bt2rWsXLlyp20bZwdOmzaNSy+9lL59+3bMjpiZdYKufgzU2lGhGdh5Z0nkuuuu4/nnn+fYY4/lueeeo7y8nJ49eza57bx583jttdc47bTT2q3dZmZdQVf/Hqi1o4qKih0mBa1cuZIhQ3ac0FxeXs6dd94JJEOzjzzyCAMGDGDo0KE8++yzO2z7oQ99iJdeeom5c+cyYcIEtm/fzurVqzn99NN55JFHOmanzMw6iHug3dhhhx1GTU0NS5cupb6+nocffpiTTz55hzJr1qzh3XffBeDmm2/m/PPPB+C4447jySef5K233uKtt97iySef5LjjjuPiiy9m4cKFzJ07l5kzZ3LQQQc5PM1sj+QeaDfWs2dPpk+fztlnn01DQwPnn38+lZWVTJs2jaqqKk455RSeffZZrr/+eiRx1FFHceONNwLJ2Ua+8pWvcPzxxwNw1VVXUVJS0pm7Y2bWoTrtTERdgc9EZGZm+faUMxGZmZl1SQ5QMzOzDBygZmZmGThAzczMMnCAmpmZZeAANTMzy8ABamZmloED1MzMLAMHqJmZWQYOUDMzswwcoGZmZhk4QM3MzDLwr7G0gVL/Cskeae26dZ3dBDPrwtwDNTMzy8ABamZmloED1MzMLAMHqJmZWQYOUDMzswwcoGZmZhk4QM3MzDJwgJqZmWXgADUzM8vAAWpmZpaBA9TMzCwDB6iZmVkGDlAzM7MMHKBmZmYZOEDNzMwycICamZll4AA1MzPLwAFqZmaWgQPUzMwsAweomZlZBg5QMzOzDBygZmZmGThAzczMMnCAmpmZZeAANTMzy8ABamZmloED1MzMLAMHqJmZWQYOUDMzswwcoGZmZhk4QM3MzDJwgJqZmWXgADUzM8vAAWpmZpZBhweopC9Iek3SO5JmS5rcTNk7JEWBy6acMlOaKHNwx+yRmZl1Rx0aoJLOBW4BpgFVwPPATEnDmtjkS0B53qUGuL9A2XF55Ra3aePNzMxydHQP9Ergjoi4PSIWRcRlQC3w+UKFI2J9RLzReAEOAkYCtxco/mZu2YhoaLe9MDOzbq/DAlRSb2Ai8FjeqseAo1tZzeeABRHxfIF1f5RUK+kJSR/ehaaamZm1qGcH3td+QA9gVd7yVcAJLW0saSDwt8DVeasae7AvAb2BTwFPSJoSEU8XqOcS4BKA8vJyXn75ZQAqKiro27cvr776KgADBw5k5MiRzJkzB4AePXowYcIEqqur2bQpOQRbWVnJ2rVroaSkFbtvu5tFixaxZcsWAMaOHUtdXR11dXUADB8+HEksWbIEgEGDBlFeXs78+fMB2HvvvRk3bhwLFixg69atAIwfP57a2lrWrFkDwIgRI4gIli5dCkBZWRllZWUsXLgQgD59+lBZWcm8efPYtm0bABMmTGDZsmWsW7cOgJEjR1JfX8/y5csBGDx4MKWlpSxatAiAfv36MWbMGObOnUtDQzIoU1VVRU1NDevXrwdg1KhRbN68mZUrVwLJ62LAgAFUV1cD0L9/f0aPHs2cOXOICCRRVVXF4sWL2bhxIwBjxoxhw4YN1NbWArv2elq1KnmLOOCAA+jduzc1NTUAlJSUMGzYMObOnQtAr169OOSQQ/w4+XFq88eptRQRrS68KyRVACuAYyLimZzl3wE+ERHNTvqRdClwE1AREWtbKDsD2B4RH22uXFVVVcyaNau1u9CkUgfoHmlt+qIys+6ltLR0dkRMaqlcRx4DXQ00AEPylu/Pzr3SQj4HPNRSeKZ+D4wurnlmZmat12EBGhH1wGzgxLxVJ5LMxm2SpCOBCRSePFTIoSRDu2ZmZu2iI4+BAnwfuEvSH4DngKlABXAbgKQ7ASLiwrztPkfytZTf5Vco6QpgCbCA5BjoBcAZwFntsgdmZmZ0cIBGxH2SBgHfJPmu5nzg1IhYmhbZ6fugkvoD5wHXReEDtr2B7wFDgS0kQfqRiJjRDrtgZmYGdHwPlIj4IfDDJtZNKbBsI/C+ZuqbDkxvq/aZmZm1hs+Fa2ZmloED1MzMLAMHqJmZWQYOUDMzswwcoGZmZhkUFaCSzpH0Nzm3vy1puaTfSCpv++aZmZl1TcX2QK9pvCLpMJITu/8b0IvkPLVmZmbdQrHfAx0OVKfXPw78T0RMl/QY8Js2bZmZmVkXVmwP9B2gf3r9eODx9Pr6nOVmZmZ7vGJ7oM8AN0l6FpgEnJ0u/yvg9bZsmJmZWVdWbA/0i0A9SXBOjYiV6fJT8BCumZl1I0X1QCNiOXB6geVXtFmLzMzMdgNFfw9U0j6Szpb0NUn7pssOklTa9s0zMzPrmorqgUoaRTJx6H3AvsADwFvA59Pbn23rBpqZmXVFxfZAbwYeAwaT/PZmo18BH26rRpmZmXV1xc7CPRr4QEQ0SMpdvgyoaLNWmZmZdXFZzoXbq8CyYSTfBTUzM+sWig3Qx4Arc26HpAHAtcCv26xVZmZmXVyxQ7hXAk9Kqgb2Ae4DRgGrgHPauG1mZmZdVrHfA10p6VDgE8BhJD3YHwP3RMSWZjc2MzPbgxTbAyUNyp+lFzMzs26pxQCVdCbwSERsS683KSIebrOWmZmZdWGt6YE+CAwB3kyvNyWAHm3RKDMzs66uxQCNiL0KXTczM+vOigpEScdI2il0JfWQdEzbNcvMzKxrK7ZH+SRQ6KTx+6brzMzMuoViA1QkxzrzDQI27XpzzMzMdg+t+hqLpF+lVwO4W9LWnNU9gPHA823cNjMzsy6rtd8DXZP+FbCOHX+JpR54Fri9DdtlZmbWpbUqQCPi7wAkLQG+FxEerjUzs26t2FP5XdteDTEzM9udtOZMRH8Cjo2IdZLmUXgSEQAR8ddt2TgzM7OuqjU90IeAxklDzZ2JyMzMrNtozZmIri103czMrDvzqfnMzMwyaM0x0GaPe+byMVAzM+suWvtrLGZmZpajqGOgZmZmlvAxUDMzswz8PVAzM7MM/D1QMzOzDPw9UDMzswyKOhduI0kHAZXpzUUR8Ze2a5KZmVnXV1SAShoE/BT4KPDu/y3Wo8DFEbGmyY3NzMz2IMXOwv0JMAqYDOyTXo4BDsS/B2pmZt1IsUO4JwHHR8QLOcuek/T3wONt1ywzM7OurdgeaB1Q6Me0NwMevjUzs26j2AC9DrhZ0tDGBen1m9J1ZmZm3UKWk8kfCCyRtCK9PRR4B9if5BipmZnZHs8nkzczM8vAJ5M3MzPLoMNPJi/pC5Jek/SOpNmSJjdTdoqkKHA5OK/cWZIWStqa/v14+++JmZl1Z0UFqKTekq6V9L9pADbkXlqx/bnALcA0oAp4HpgpaVgLm44DynMui3PqPAq4D7gHODT9+4CkI4vZNzMzs2IU2wO9Hvg0yazbd4GrgH8n+QrLF1qx/ZXAHRFxe0QsiojLgFrg8y1s92ZEvJFzyQ3rK4AnI+KGtM4bgKfS5WZmZu2i2AA9B5gaET8CGoBfRsTlwHeAE5vbUFJvYCLwWN6qx4CjW7jfP0qqlfSEpA/nrTuqQJ2/aUWdZmZmmRV7JqLBwML0+tvAvun1/wf8Swvb7gf0AFblLV8FnNDENo2905eA3sCngCckTYmIp9MyQ5qoc0ihCiVdAlwCUF5ezssvvwxARUUFffv25dVXXwVg4MCBjBw5kjlz5gDQo0cPJkyYQHV1NZs2JeeSqKysZO3atVBS0sKu2+5o0aJFbNmyBYCxY8dSV1dHXV0dAMOHD0cSS5YsAWDQoEGUl5czf/58APbee2/GjRvHggUL2Lo1+TXA8ePHU1tby5o1yTlHRowYQUSwdOlSAMrKyigrK2PhwuQl1qdPHyorK5k3bx7btm0DYMKECSxbtox169YBMHLkSOrr61m+fDkAgwcPprS0lEWLFgHQr18/xowZw9y5c2loSAZuqqqqqKmpYf369QCMGjWKzZs3s3LlSiB5XQwYMIDq6moA+vfvz+jRo5kzZw4RgSSqqqpYvHgxGzduBGDMmDFs2LCB2tpaYNdeT6tWJS/nAw44gN69e1NTUwNASUkJw4YNY+7cuQD06tWLQw45xI+TH6c2f5xaSxFN/j72zoWlPwMXRcSLkp4BZkbENEmfBP41IgY3s20FsAI4JiKeyVn+HeATEXFwU9vm1TMD2B4RH01v1wOfiYi7csp8GvhRROzTXF1VVVUxa9as1txts0odoHuktemLysy6l9LS0tkRMamlcsUO4f4COD69fgtwraTXgDto+SQKq0mGffN7hvuzcw+yOb8HRufcfqMN6jQzMytKUUO4EfGNnOsPSlpOcqzxfyPi0Ra2rZc0m+RY6QM5q04EHiqiGYeSDO02eiGt48a8Op8vok4zM7OiZPpB7UYR8SLwYhGbfB+4S9IfgOeAqUAFcBuApDvTei9Mb18BLAEWkBwDvQA4Azgrp85bgKclfYOkh/xx4MPAh7Lul5mZWUuKDlBJh5F8RWRsumgRyfHPl1vaNiLuS3+U+5sk3+ecD5waEUvTIvnfB+0NfI/kfLtbSIL0IxExI6fO5yWdB/wTcC3wF+DciPh9sftmZmbWWsVOIjofuBOYRTJ0CvAB4DiSyUV3t3kL25EnEVlzPInIrHtq7SSiYnugNwDfiohpuQvT4dN/AnarADUzM8uq2Fm4ZcD9BZY/QDLz1czMrFsoNkCfBKYUWD4F+N2uNsbMzGx30Zof1D4z5+ZM4LuSJvF/s28/AJwJXNPmrTMzM+uisv6g9nunw8vxA+CHu9wiMzOz3UBrflC7w38z1MzMrKtzOJqZmWVQdIBK+oikpyWtllQn6XeSTm2PxpmZmXVVRQWopM+SnC7vL8DXgK8DrwG/kHRx2zfPzMysayr2RApfA66MiFtzlv00PUn814GftVnLzMzMurBih3CHkfx4dr6ZwPBdb46ZmdnuodgAXUbyU2H5/gZYWmC5mZnZHqnYIdzvAT9If5HleSBIfjbsU8Blbdw2MzOzLqvYH9T+kaQ3gS+TnH0Ikp8zOyciftnWjTMzM+uqWh2gknqSDNU+HRG/aL8mmZmZdX2tPgYaEduBh4H+7dccMzOz3UOxk4jmAqPaoyFmZma7k2ID9BrgJklnSHq/pNLcSzu0z8zMrEsqdhbur9O/D5PMwG2k9HaPtmiUmZlZV1dsgH64XVphZma2m2lVgErqC9wInAH0Ah4HLo+I1e3YNjMzsy6rtcdArwUuIhnCvZfkbET/0U5tMjMz6/JaO4R7JvCZiPg5gKR7gOck9YiIhnZrnZmZWRfV2h7o+4FnGm9ExB+A7UBFezTKzMysq2ttgPYA6vOWbaf4SUhmZmZ7hNYGoIC7JW3NWbYPcLukzY0LIuKjbdk4MzOzrqq1AfpfBZbd3ZYNMTMz2520KkAj4u/auyFmZma7k2JP5WdmZmY4QM3MzDJxgJqZmWXgADUzM8vAAWpmZpaBA9TMzCwDB6iZmVkGDlAzM7MMHKBmZmYZOEDNzMwycICamZll4AA1MzPLwAFqZmaWgQPUzMwsAweomZlZBg5QMzOzDBygZmZmGThAzczMMnCAmpmZZeAANTMzy8ABamZmloED1MzMLAMHqJmZWQYOUDMzsww6PEAlfUHSa5LekTRb0uRmyp4p6TFJdZI2Svq9pI/mlblIUhS47NP+e2NmZt1VhwaopHOBW4BpQBXwPDBT0rAmNjkWmAV8JC0/A/hFgdDdDJTnXiLinbbfAzMzs0TPDr6/K4E7IuL29PZlkk4GPg98I79wRHwpb9G1kj4CnAE8s2PReKM9GmxmZlZIh/VAJfUGJgKP5a16DDi6iKr6A+vylvWRtFTSckmPSqrahaaamZm1qCN7oPsBPYBVectXASe0pgJJlwIHAHflLK4GLgbmkoTrl4DnJE2IiMUF6rgEuASgvLycl19+GYCKigr69u3Lq6++CsDAgQMZOXIkc+bMAaBHjx5MmDCB6upqNm3aBEBlZSVr166FkpLWNN92M4sWLWLLli0AjB07lrq6Ourq6gAYPnw4kliyZAkAgwYNory8nPnz5wOw9957M27cOBYsWMDWrVsBGD9+PLW1taxZswaAESNGEBEsXboUgLKyMsrKyli4cCEAffr0obKyknnz5rFt2zYAJkyYwLJly1i3LvkMOXLkSOrr61m+fDkAgwcPprS0lEWLFgHQr18/xowZw9y5c2loaACgqqqKmpoa1q+B6hpFAAAJR0lEQVRfD8CoUaPYvHkzK1euBJLXxYABA6iurgagf//+jB49mjlz5hARSKKqqorFixezceNGAMaMGcOGDRuora0Fdu31tGpV8hZxwAEH0Lt3b2pqagAoKSlh2LBhzJ07F4BevXpxyCGH+HHy49Tmj1NrKSJaXXhXSKoAVgDHRMQzOcu/A3wiIg5uYfuzSILzvIj4VTPlegCvAE9GxOXN1VlVVRWzZs0qYi8KK3WA7pHWrssf6DCz7qC0tHR2RExqqVxHTiJaDTQAQ/KW78/OvdId5ITnhc2FJ0BENAB/BEZnb6qZmVnzOixAI6IemA2cmLfqRJLZuAVJOge4G7goIh5s6X4kCfhroDZ7a83MzJrX0bNwvw/cJekPwHPAVKACuA1A0p0AEXFhevs8kp7nV4CnJTX2XusjYm1a5jvAi8BiYABwOUmAfr6D9snMzLqhDg3QiLhP0iDgmyTf15wPnBoRS9Mi+d8HnUrSxpvTS6PfAVPS6/sCPyYZGl4PzCE5zvqH9tgHMzMz6PgeKBHxQ+CHTayb0tztJrb5B+Af2qJtZmZmreVz4ZqZmWXgADUzM8vAAWpmZpaBA9TMzCwDB6iZmVkGDlAzM7MMHKBmZmYZOEDNzMwycICamZll4AA1MzPLwAFqZmaWgQPUzMwsAweomZlZBg5QMzOzDBygZmZmGThAzczMMnCAmpmZZeAANTMzy8ABamZmloED1MzMLAMHqJmZWQYOUDOz3cTjjz/OEUccwcSJE7n55pt3Wr9161YuvvhiJk6cyAknnMCyZcsAqK+v59JLL+WDH/wgkydP5tlnn31vm/r6eq644goOP/xwjjzySH71q1912P7s7np2dgPMzKxlDQ0NfPWrX+Xhhx+moqKC448/npNPPpmDDz74vTJ33303++67L7Nnz+ahhx7immuu4Wc/+xl33nknAM899xx1dXWcc845PPHEE+y1117cdNNNlJWV8dJLL/Huu++ybt26ztrF3Y57oGZmu4HZs2dz4IEHMmLECHr37s2ZZ57JzJkzdygzY8YMzjvvPAA+9rGP8fTTTxMRVFdXc+yxxwJQVlbGwIEDmTNnDgD33HMPV1xxBQB77bUXgwYN6sC92r05QM3MdgO1tbUMHTr0vdsVFRXU1tY2WaZnz54MGDCAtWvXMm7cOGbMmMH27dtZunQpr7zyCitWrGD9+vUATJs2jSlTpnDRRRfx5ptvdtxO7eYcoGZmu4GI2GmZpFaVueCCC6ioqOC4447j6quv5ogjjqBnz55s376dlStXcuSRR/LUU09x+OGH8+1vf7vd9mFP42OgZma7gYqKClasWPHe7ZUrVzJkyJCCZYYOHcr27dvZsGEDJSUlSGLatGnvlTvppJMYOXIkpaWl9O3bl9NOOw1Ihn3vvvvujtmhPYB7oGZmu4HDDjuMmpoali5dSn19PQ8//DAnn3zyDmVOOeUUfv7znwPwy1/+ksmTJyOJzZs3s2nTJgCefPJJevbsycEHH4wkTjrppPdm5T799NOMGTOmY3dsN+YeqJnZbqBnz55Mnz6ds88+m4aGBs4//3wqKyuZNm0aVVVVnHLKKVxwwQVMnTqViRMnUlJSwk9+8hMAVq9ezdlnn40kKioquO22296r95prrmHq1KlcffXV7Lffftx6662dtYu7HRUaM+8uqqqqYtasWbtcT2lJSRu0xrqatZ7Ob9YtlZaWzo6ISS2V8xCumZlZBg5QMzOzDHwM1My6HR922TN19GEX90DNzMwycICamZll4AA1MzPLwAFqZmaWgQPUzMwsAweomZlZBg5QMzOzDBygZmZmGThAzczMMnCAmpmZZeAANTMzy8ABamZmloED1MzMLAMHqJmZWQYOUDMzswwcoGZmZhk4QM3MzDJwgJqZmWXQ4QEq6QuSXpP0jqTZkia3UP7YtNw7kmokTd3VOs3MzHZVhwaopHOBW4BpQBXwPDBT0rAmyh8IzEjLVQHfBX4g6aysdZqZmbWFju6BXgncERG3R8SiiLgMqAU+30T5qcDKiLgsLX878F/AV3ahTjMzs13WYQEqqTcwEXgsb9VjwNFNbHZUgfK/ASZJ6pWxTjMzs13WkT3Q/YAewKq85auAIU1sM6SJ8j3T+rLUaWZmtst6dsJ9Rt5tFVjWUvnG5WqmTME6JV0CXJLefLu0tLS62dZavv2A1Z3diI5Q2tkNMGsbfs0Wb3hrCnVkgK4GGti5Z7g/O/cgG73RRPntwBqSoCyqzoj4MfDjVrfadiDpjxExqbPbYWat49ds++mwIdyIqAdmAyfmrTqRZOZsIS8AJxQo/8eI2JaxTjMzs13W0UO43wfukvQH4DmSWbYVwG0Aku4EiIgL0/K3AV+UdDPwI+CDwEXAJ1pbp5mZWXvo0ACNiPskDQK+CZQD84FTI2JpWmRYXvnXJJ0K/CvJ11JWApdHxENF1Glty8PfZrsXv2bbiSKam79jZmZmhfhcuGZmZhk4QM3MzDJwgJqZmWXgALUWSRotaXBnt8PMrCvxJCIrSNL+wKeAfwDqSE5eUQs8CDwUEZs6sXlmZp3OAWoFSboDGAs8SnLWp0HAoUAlsByYHhG/7bQGmtlOJA0ANobf2DuEA9R2IknARpLv0z6ds+z9wJHA50jOFXluRLzSaQ01sx1I+hHwh/SyNCI2FCgzKCLWdHjj9kA+BmqFjAVeA+obF0RiWUQ8AJxGErDndlL7zCyPpE+QfLi9CfglcKOkj0s6SFKftEwf4KeSDunEpu4x3AO1naQvskeBvsCFwF8i4t28MpcBn4mIQzuhiWaWR9LtJD+uMR04E/g0cBBQDcwAngDGALdERO/OaueexD1Q20lEbAH+EegD3AlcKOn9kvoBSOoLHEty2kQz62SSepKMGr0VETUR8b2IOAQ4HPgdSZjeD/wAuKvzWrpncQ/UmiRpPPAt4KPAJpJfx6kj+YWcWuCzETGv81poZo0klQCDI+LPknoD23InE0k6F7gXOMxzF9qGA9RalH6l5SPAGcA7JD3PByLiz53aMDNrlqS9SN7nGyR9jmT4tm9nt2tP4QC1okjaK/94qJl1fZKuBHpExI2d3ZY9hQPUzKwbkNQLaPAH4LbjADUzM8vAs3DNzMwycICamZll4AA1MzPLwAFqZmaWgQPUzMwsAweomZlZBv8ftXowefi/EM8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution (DNS)\n", + "mode = \"DNS\"\n", + "dist = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['cyan'], \n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "# fraction of total data to use as training data (DNS)\n", + "train_frac = 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 1.0\r" + ] + } + ], + "source": [ + "# get some random angles\n", + "angs = 2 * np.pi * np.random.rand(3)\n", + "cost = obj(angs)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.014285714285714285\n", + "Total training runtime took 6.603797650337219 minutes.\n" + ] + } + ], + "source": [ + "# train the quantum neural network and time how long it takes\n", + "start = time.time()\n", + "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", + "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "[3.47838504 6.18048312 3.49508897]\n" + ] + } + ], + "source": [ + "# grab the optimal angles and minimal cost value\n", + "optimal_angles = out['x']\n", + "fval = out['fun']\n", + "\n", + "# print them out\n", + "print(fval)\n", + "print(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "# compute all the predictions of the quantum neural network\n", + "predictions = get_all_predictions(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Results of quantum neural network classification ===============\n", + "Out of 100 total data points:\n", + "The QNN was trained on 70.0% of the total data (70 training points).\n", + "The QNN classified 99 data points correctly (99.0% accuracy).\n", + "================================================================================\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# compute statistics of the QNN # previous experiment\n", + "ntrain = int(train_frac * npoints)\n", + "ncorrect = npoints - sum(abs(predictions - labels))\n", + "acc = ncorrect / npoints * 100\n", + "\n", + "# print them out\n", + "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", + "print(\"Out of {} total data points:\".format(npoints))\n", + "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", + "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", + "print(\"\".center(80, \"=\"))\n", + "\n", + "# plot the points, line y = x, and prediction\n", + "plt.plot(ys, xs, '--k')\n", + "for i in range(npoints):\n", + " if predictions[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + "\n", + "plt.grid()\n", + "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References:\n", + "\n", + "[1] https://github.com/QuantumAI-lib/NISQAI/blob/master/examples/one-qubit-classifier/one-qubit-classifier.ipynb\n", + "\n", + "[2] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/community/terra/qis_adv/Multi-Qubit_W_States_with_Tomography.ipynb\n", + "\n", + "[3] Smolin, J. A., Gambetta, J. M. & Smith, G. (2012). Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Phys. Rev. Lett 108(7). https://link.aps.org/doi/10.1103/PhysRevLett.108.070502\n", + "\n", + "[4] Preskill, J. (2018) Quantum Computing in the NISQ era and beyond. Quantum 2, 79 (2018). https://arxiv.org/abs/1801.00862\n", + "\n", + "[5] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7bd4ced7980d29a5561b9cabb4cb6c6398e2c069 Mon Sep 17 00:00:00 2001 From: Pierre Decoodt Date: Sun, 10 Feb 2019 15:44:50 +0100 Subject: [PATCH 2/5] Delete [WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb --- ... Simulation and Real Device Run Test.ipynb | 2131 ----------------- 1 file changed, 2131 deletions(-) delete mode 100644 [WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb diff --git a/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb b/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb deleted file mode 100644 index 2c574e1..0000000 --- a/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb +++ /dev/null @@ -1,2131 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# NISQAI One-Qubit Quantum Neural Network Adapted for Qiskit\n", - "\n", - "\n", - "***\n", - "### Contributors\n", - "#### Add here the contributors:\n", - "Pierre Decoodt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Introduction\n", - "\n", - "This is a proof of concept for the assessment on Qiskit of a NISQAI classifier$^{[1]}$.\n", - "A one-qubit neural network is tested on Aer based noise free simulation (NFS) and device noise simulation (DNS), and also on real superconducting quantum calculating device (SQC).\n", - "\n", - "The protocol follows the steps described in a previous Qiskit tutorial $^{[2]}$ using quantum state tomography $^{[3]}$ for assessing fidelity.\n", - "\n", - "The last part consist of testing training and prediction by NFS and DNS.\n", - "\n", - "NB: I use the term SQC instead of NISQ because the original Preskill paper $^{[4]}$ specifies as \"NISQ\" quantum computers with 50-100 qubits." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\decpi\\Anaconda3\\envs\\q7env\\lib\\site-packages\\marshmallow\\schema.py:364: ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See https://marshmallow.readthedocs.io/en/latest/upgrading.html#schemas-are-always-strict\n", - " ChangedInMarshmallow3Warning\n" - ] - } - ], - "source": [ - "#Import packages\n", - "# NB running this cell induces a ChangedInMarshmallow3Warning for the moment. This warning can be safely ignored.\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "import time\n", - "from scipy.optimize import minimize\n", - "\n", - "# import from qiskit\n", - "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, compile\n", - "from qiskit.converters import qobj_to_circuits\n", - "from qiskit import Aer, IBMQ\n", - "from qiskit.providers.aer import noise\n", - "\n", - "# import tomography library\n", - "import qiskit.tools.qcvv.tomography as tomo\n", - "\n", - "# useful additional packages \n", - "from qiskit.tools.visualization import plot_state, plot_histogram \n", - "from qiskit.tools.qi.qi import state_fidelity, outer\n", - "from qiskit.tools.qi.qi import outer\n", - "from qiskit.quantum_info import state_fidelity\n", - "from qiskit.tools.monitor import job_monitor, backend_overview\n", - "from qiskit.providers.ibmq import least_busy\n", - "from qiskit.quantum_info.analyzation.average import average_data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ,\n", - " ]" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Aer.backends() # No need for credentials for running the next cells until next warning" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Data Encoding" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generating Data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# set random seed for reproducible results\n", - "SEED = 1059123109\n", - "np.random.seed(seed=SEED)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# generate data points distributed uniformly at random in [0, 1) x [0, 1)\n", - "npoints = 100\n", - "data = np.random.rand(npoints, 2)\n", - "\n", - "def predicate(point):\n", - " \"\"\"Returns true if the point satisfies the predicate, else false.\"\"\"\n", - " return True if point[0] <= 0.5 else False\n", - "\n", - "# separate the data with a linear boundary y = x\n", - "labels = np.array([1 if predicate(p) else 0 for p in data])\n", - "\n", - "# plot the line y = x\n", - "xs = np.linspace(0, 1, 100)\n", - "ys = 0.5 * np.ones_like(xs)\n", - "plt.plot(ys, xs, '--k')\n", - "\n", - "# plot the data with the color key BLUE = 0 = LEFT, GREEN = 1 = RIGHT\n", - "for i in range(npoints):\n", - " if labels[i] == 0:\n", - " ckey = 'g'\n", - " else:\n", - " ckey = 'b'\n", - " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", - " \n", - "# title and axis lables\n", - "plt.title(\"Random Data Points in Unit Square\", fontweight=\"bold\", fontsize=16)\n", - "\n", - "# put on a grid and show the plot\n", - "plt.grid()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Qubit Encoding" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# encode the classical data via a simple linear \"qubit encoding\"\n", - "qdata = np.zeros_like(data)\n", - "for (index, point) in enumerate(data):\n", - " qdata[index][0] = np.pi * point[0]\n", - " qdata[index][1] = 2 * np.pi * point[1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. State Preparation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As explained is the NISQAI one-qubit classifier description$^{[1]}$, the one-qubit encoding is achieved by realizing the following initial state: \n", - " \n", - "$$|\\psi\\rangle = \\cos(\\frac {\\theta}{2}) |0\\rangle + e^{i \\phi} \\sin(\\frac {\\theta}{2})|1\\rangle $$\n", - "\n", - "\n", - "The unitary taking the $|0\\rangle$ to the above state is: \n", - "\n", - "$$\n", - "S(\\theta, \\phi) = \\begin{pmatrix}\n", - "\\cos(\\frac {\\theta}{2}) & e^{-i \\phi}\\sin(\\frac {\\theta}{2}) \\\\\n", - "e^{i \\phi} \\sin(\\frac {\\theta}{2}) & - \\cos(\\frac {\\theta}{2})\n", - "\\end{pmatrix}\n", - "$$\n", - "\n", - "\n", - "Such an operation is not currently directly available in Qiskit to our knowledge. We therefore use arbitrary initialization in order to encode the qubit $^{[5]}$.\n", - "\n", - "A check of the results of this arbitrary initialization follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3.122 5.969 0 vs 2 -- 8191 vs 8190\n", - "0.348 0.911 7946 vs 7946 -- 245 vs 246\n", - "1.652 4.618 3765 vs 3849 -- 4426 vs 4343\n", - "2.919 0.365 101 vs 94 -- 8090 vs 8098\n", - "2.582 1.018 623 vs 592 -- 7568 vs 7600\n", - "0.002 5.703 8191 vs 8192 -- 0 vs 0\n", - "2.986 5.712 49 vs 34 -- 8142 vs 8158\n", - "3.064 1.62 12 vs 15 -- 8179 vs 8177\n", - "1.516 0.87 4320 vs 4356 -- 3871 vs 3836\n", - "3.131 0.308 0 vs 0 -- 8191 vs 8192\n", - "2.118 0.197 1965 vs 1949 -- 6226 vs 6243\n" - ] - } - ], - "source": [ - "# Checking arbitrary initialization\n", - "n = 1\n", - "for i in range(5,56,5) : # modify here if wishe\n", - " # create a n-qubit quantum register\n", - " qrt = QuantumRegister(n)\n", - " crt = ClassicalRegister(n)\n", - " check_sta = QuantumCircuit(qrt,crt , name='check_sta')\n", - "\n", - " # pick an encoded data point\n", - " theta, phi = qdata[i]\n", - "\n", - " # desired vector\n", - " desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", - " qrt_vector = []\n", - "\n", - " # Initialize a 1-qubit quantum state using the arbitrary method \n", - " qrt_vector.append(qrt[0])\n", - " check_sta.initialize(desired_vector, qrt_vector)\n", - "\n", - " # Measurement circuit\n", - " measuring = QuantumCircuit(qrt,crt , name='measuring')\n", - " for i in range(n) :\n", - " measuring.measure(qrt[i] , crt[i])\n", - " test_check = check_sta+measuring\n", - "\n", - " # noise free simulation (NFS)\n", - " mode = \"NFS\"\n", - "\n", - " # test circuit \"check_sta\" : Noise free model on simulator\n", - " backend_sim = Aer.get_backend('qasm_simulator')\n", - " shots = 8192\n", - " job_noisefree = execute(test_check, backend_sim, shots=shots) \n", - " count = job_noisefree.result().get_counts(test_check)\n", - " \n", - " # get the output probabilities\n", - " observable_1 = {'1' : 1, '0' : 0}\n", - " observable_0 = {'0' : 1, '1' : 0}\n", - " fr_obs1 = int(average_data(count,observable_1)*8192)\n", - " fr_obs0 = int(average_data(count,observable_0)*8192)\n", - " \n", - " fr_theo0 = int(abs(np.cos(theta / 2)**2)*shots)\n", - " fr_theo1 = int(abs(np.exp(1j * phi) * np.sin(theta / 2)**2)*shots)\n", - " print(round(theta,3), round(phi,3),\" \", fr_theo0,\"vs\", fr_obs0,\"--\", fr_theo1,\"vs\", fr_obs1) " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Determine the job\n", - "n = 1\n", - "\n", - "# create a n-qubit quantum register\n", - "qr = QuantumRegister(n)\n", - "cr = ClassicalRegister(n)\n", - "initial_state = QuantumCircuit(qr, cr, name='initial_state')\n", - "\n", - "# pick a particular encoded data point\n", - "theta, phi = qdata[0]\n", - "\n", - "# desired vector\n", - "desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", - "qr_vector = []\n", - "\n", - "# Initialize a 1-qubit quantum state using the arbitrary method \n", - "qr_vector.append(qr[0])\n", - "initial_state.initialize(desired_vector, qr_vector)\n", - "\n", - "# Measurement circuit\n", - "measuring = QuantumCircuit(qr, cr, name='measuring')\n", - "for i in range(n) :\n", - " measuring.measure(qr[i] , cr[i])\n", - "test = initial_state+measuring" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test the arbitrary initialization of the state by noise free simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "# QASM from test\n", - "QASM_source = test.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR8AAAB2CAYAAADx25drAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAESVJREFUeJzt3XtMU/ffB/B3bYGW0YsiiorgZFMfcYDgBXAddfrAFlFU3Oa8zU3FRDFTiSu6ZBoTfpa5bGrm5hhsLvNB8DKHzl/QKJeUiE0VGXY6NwLjprGiQOcFsaXPH8bGWqQFTvul8nklJOV8T3veBfrmnMO3HJ7ZbDaDEEJcbADrAISQ/onKhxDCBJUPIYQJKh9CCBNUPoQQJqh8CCFMUPmQHrl+/ToiIiIgFAphNBpZx3GIRqNBTEwM5HI5NmzYwDqOw3Q6nSX3hx9+iBdldgyVD+mRQYMG4ezZs4iKimIdxWFBQUEoLCyEWq2GXq/H5cuXWUdyyNixY3Hu3Dmo1WoAwIULFxgn4oaAdQDinoRCIYRCIesY3eLv72+5LRAIwOfzGaZxnIeHh+W2l5cXRo4cyTANd2jPh/Q7lZWVaGpqwvjx41lHcdjx48cxYcIE6PV6+Pr6so7DCSof0q/cuXMHKSkpyM7OZh2lW+bMmQOdTocRI0bgt99+Yx2HE1Q+pN8wGo1YsmQJdu7caXUI1tc9fPjQclsikUAkEjFMwx0qH9Ijjx49wsyZM/H7778jPj4eGo2GdSS7Dh8+DK1WC6VSCYVCgbKyMtaRHFJQUIDY2FjExsbi5s2biIuLYx2JEzx6VzshhAXa8yGEMEHlQwhhgsqHEMIElQ8hhAkqH0IIE1Q+hBAmqHwIIUxQ+RBCmKDyIYQwQeVDCGGCyocQwgSVDyGECfpPhv3c+vXrUVFR4fLthoeHY9euXT26L6vMgHvm7k1mZ6I9n36uoqLC5S+I3m6TRWYutuuOX2tnoj0fgvDwcBQXF7tsewqFoteP4erMgHvm5iKzs9CeDyGECSofQggTVD6EECaofIhDhg8fDpFIBB8fH0ilUrz11luor69nHcsud83dH1D5ELsaGxtx48YNlJeX4+7du6iuroZer0daWhrraF1y19z9BZUPsUur1UIikWDcuHEAAF9fX0RERODmzZuMk3XNXXM/q6OjA21tbejo6LC7bn19PUwmkwtS9R6VD7FLq9Vi8uTJ4PF4MBqNKCgoQF5eHhYtWsQ6WpfcNXdHRwdOnTqF5cuXIyQkBAKBACKRCJ6enggLC8OqVaugVqvx7IVnrl27hilTpiA1NZVR8u7pN/N89u/fj/3793drjkVkZCR27Njxwlwnqae0Wi1KS0shk8lw9+5deHt7Izs7G++++y7raF1yx9ynT59GSkoK/v77b/j6+iI6Ohpz586Fj48PWltbUVFRgUOHDiErKwthYWHYt28foqKicO3aNSgUCnR0dCA5OZn103AIkz2f3NxcyOVySCQSCAS2/WdvnAsmkwmbNm2Cn58fxGIxkpKS0NTUZLVOYmIi8vPznbJ9d3LhwgUcPHgQLS0tqK+vR0BAAP7880/Wsexyp9xGoxHr1q1DfHw8+Hw+Dh48iOvXr+PEiRNIT0/H5s2boVKpUFBQgBs3biArKwt37tzBtGnTsHbtWkvxFBUVuc016JmUz8CBA7FmzZrnvt/E3jgXVCoV8vPzodFo0NDQAABYunSp1TqJiYk4fvy40zK4g6qqKjQ3NyMiIgIAMGzYMKSmpmLfvn2WcxClpaX46KOPLPd57733cPHiRSZ5n3Akt9FoxIwZM6BQKBAWFobIyEgmWU0mE5YtW4avv/4a69evx6VLl7Bw4UJ4enp2ur63tzdWrFgBnU6HOXPm4JtvvkFraysKCwvdpngAJ5bPoUOH8Nprr8HHxwdxcXHYuHEj3nnnHQBAfHw83n//fYwePbrT+9ob50JmZiaUSiVGjx4NqVSKzz//HAUFBfjnn38s64SFhUEgEDB/IbGk1WoxaNAgBAUFWZYlJibi5s2bKC0tBQBMmjQJly5dAgAUFRVBKpUyeyE/4UhugUCAs2fPIicnB6NHj8axY8eYZN25cycOHjyIHTt24KuvvoJQKHTofjdu3MD58+fh7e2NBw8eQKvVOjkpt5xSPj/99BNSU1MtjZyQkIA9e/Zg4sSJztgcVCoVQkNDHV6/tbUVdXV1Vi+Q4OBgSCQSVFZWWq07Z86cfn3opdVqbb5vgwcPRkxMDI4cOQIAEAqFEAqFaG5uxtatW5Gens4iqhVHcgNATU0NUlJS8N133yEwMNDVMXH16lVs3boVSUlJUCqVDt/v6XM8Go0Gcrkc69evx/Xr152Yllucl8/9+/exceNGZGZmQi6Xg8/nY+XKlTCZTE4rn7S0NJvS6IrBYAAASKVSq+Uymcwy9sSsWbNw8uTJ3od0U19++SXOnDljs1ytVmPPnj2Wz6dOnYpVq1YhKSkJfn5+rozYKUdyX7lyBZs2bcIPP/yAIUOGuDoigMe/OD09PbF3717weDyH7vN08RQVFWHChAnIzs7G3bt3sXv3bicn5g7n5VNSUoKOjg68/fbblmW3bt0CAKeVT3eJxWIAj/eAntbS0gKJRGK1rLa21iW/EXk8HpOPkpISTvJHRUXh6tWrWLt2rUPrl5SUMM8cFxeH2tpazJ07FwqFwubnwdm5b9++jby8PCxbtgxDhw51KPOzxfPkHM+rr76KxMREZGdn4+HDh5xl7u1HVzgvH71eb/NbJCcnB/7+/vD39+d6cz0ik8kQGBiI8vJyy7Lq6moYDAabw7fjx48jMTHR6ZnMZjOTj9jYWE7yl5aWYs+ePQ7/dTI2NpZ55oaGBmi1WhQXF6O4uNhmT9jZudVqNR4+fIjFixc7lPd5xfPEokWLcPv2bcv5Ny4y9/ajK5yXT0hICKqqqlBSUoL29nbk5ORApVIhPDzcso7JZEJbWxva29sBAG1tbWhra7OEtTfOheTkZGRkZKCmpgYGgwFKpRLx8fEYNWqUZZ379++jqKgICQkJnG33RdPQ0IDExERIpVLMmDGDdRy3cvHiRfD5fIeOCOwVDwBMmTLF8rjugPPymTRpEj799FPMnz8fAQEB0Gg0mDp1qtUX+Oeff4ZIJEJ8fDxMJhNEIhFEIhFqa2sdGn/Wf/7zH4SEhHQrZ1paGmbPno3JkydjxIgRMJlMOHDggNU6p06dwsSJEzF48OBufhX6j4CAAOTn5/eJk8zuprGxEcOGDYNIJOpyPUeKB3j8vfDw8EBjY6Mz4nLOKX/t2r59O27fvg29Xo/du3fjr7/+siqf5cuXd7qL9mSvw974s7Zs2YI//vijWxn5fD6++OILNDU14d9//8Uvv/xiUzKuOuQi/dO3334LnU5nd73m5maIxWK7Ewh5PB70ej22bdvGYUrncfokQ4PBgNra2j5zsrk7goKCLHOT+iONRoOYmBjI5XJs2LDBaqyiogLTpk2DXC6HWq0GANTV1eHNN9/EG2+8gUOHDrGIbLFhwwbI5XJ8/PHHVssXLlwIhUKB6Ohoy6mAzp6LK3h5eTl0nikqKgpXrlxxaAKhTCZ77uTEvsbp5aPT6SAWixEcHOzsTXUpPDwcy5cv79Z9tm3bZjVJrb8JCgpCYWEh1Go19Ho9Ll++bBn77LPPkJeXh1OnTlkOuTIyMpCeno6ioiJkZWXBaDQyyV1eXo579+5BrVajvb3davJdbm4uiouL8cknn1jO5XX2XPoaZ73NiCWnl09MTAwMBoPDcxicpSfl09/5+/tbZtsKBALw+XzLWHNzMwICAuDt7Y179+7hwYMHqK6uRmhoKPh8PoYOHYqqqiomucvKyjBz5kwAwMyZM3H+/HmbdY4dO4b58+cD6Py5EOejf6lB7KqsrERTU5PVbr+fnx90Oh1u3boFnU6HlpYWjB07FiUlJbh//z7Onz+P5uZmJnmfnq8llUptchiNRly+fNnyvq/OngtxvhdvX45w6s6dO0hJSbE5h6NSqZCSkgKxWIzQ0FAMHjwYmzdvxurVq7F3716MGzfO4YlzXHt6prrBYIBMJrMaLyoqsrqkTGfPhTgf7fmQ5zIajViyZAl27txpM0F0zJgxOH36tOU9UR4eHhg6dCh+/fVXHDlyBF5eXnj55ZeZ5I6OjsbZs2cBAGfOnEFUVJTV+LFjxzBv3jzL5509F+J8VD7kuQ4fPgytVgulUgmFQoGysjKsW7cOAJCdnY3p06fjgw8+wPbt2wEAJ0+exPTp0zF79mxs3ryZ2Xm+iIgICIVCyOVyDBgwAIGBgZYTyWazGWVlZXj99dct63f2XIjz8cxcThsmbufJ4QeLq2j2dJssMnOxXXf8WjsTnfMhqKiocOlldSsqKqzebtPTx3D1pYDdMTcXmZ2FyqefY/GDGR4e3qvtsnoxscpdXXcDowOH2dx2dJt9tXzosIuQPi4tIxMqZbLNbXdHJ5wJIUxQ+RBCmKDyIYQwQeVDCGGCyocQwgSVDyGECSofQggTVD6EECaofAghTFD5EEKYoPIhhDBB5UMIYYLKhxDCBJUPIYQJKh9CCBNUPoS8oIqLixESEoJXXnkFK1euhMlkYh3JCpUPIS+gjo4OrFy5EocPH0ZVVRUMBgMOHDjAOpYVKh9CXkBarRbDhw+3XOhxxYoVOHr0KONU1uh/OBPShxj+vYebt22v9Pr3Pw2d3h4+ZDBe8hbarN/Q0ICRI0daPg8MDER9fT3HaXuHyoeQPmQAfwD+79czaHvYbrU8O++/Nrel4peQuuq9Th/HbDZbXTetL/6rdjrsIqQP8fEWYUZMhEPrvq2YCk+PzvcfRo4cibq6Osvn9fX1CAgI4CQjV6h8COljoiND4DtQ0uU6gcOHIOx/gp87PmnSJDQ2NuLKlSsAHl+Vdf78+Zzm7C0qH0L6GAGfj1nTo7pcJ2FGTJeXo+bz+fj++++xYMECBAcHw8fHB0uXLuU6aq/QdbsI6YPMZjOy8/6LqtpGm7GJIa/gvYQ3GaTiFu35ENIH8Xg8JMyIttm78RDw8dYbUxil4lafKZ/c3FzI5XJIJBIIBLYn0eyNc8FkMmHTpk3w8/ODWCxGUlISmpqanLItQuzx9xuEKWHjrJbFTg2HVOLDKBG3+kz5DBw4EGvWrMGuXbt6NM4FlUqF/Px8aDQaNDQ8nkvR146TSf/yv/JJ8PL0APD4T+tvTA1jnIhDZhcrLS01x8XFmYcMGWKWSqXmBQsWWI0XFRWZ+Xz+c+9vb7w3AgMDzVlZWZbPq6qqzADMNTU1TtkeIY4o0fxuVqq+M1/642/WUTjl0kmGR48eRXJyMjIzM5GQkID29nacO3fOKdtSqVTIyclBZWWlQ+u3trairq4OkZGRlmXBwcGQSCSorKzEqFGjnJLzibSMTKc+PnF/uScKkXuikHWMblEpk5875rLyuXfvHlavXo3du3cjKSkJAODl5YX4+HinbC8tLQ1paWkOr28wGAAAUqnUarlMJrOMOVNX3yRCzM/MWH4RuOycT0lJCXg8HhYvXuyqTXaLWCwG8HgP6GktLS2QSLqe8EWIs71oxQO4cM+nqakJAwcO7LNfRJlMhsDAQJSXlyM8PBwAUF1dDYPBgNDQUKdvnw67yIuoTxx2RUZGoqamBidOnMCsWbNgMBig0Wgsh10mkwmPHj1Ce/vjN9S1tbUBeHxoxuPx7I5zITk5GRkZGZg+fTp8fX2hVCoRHx/v9PM9AB12kX7IlWe39+/fbx4zZoz5pZdeMvv7+5u3bNliGfvxxx/NAGw+nvylyd74s9LT083jx4/vVj6j0WhOTU01+/r6mn18fMzz5s0z37p1q6dPlxDSBXp7BSGEiT4zyZAQ0r9Q+RBCmKDyIYQwQeVDCGGCyocQwgSVDyGECSofQggTVD6EECaofAghTFD5EEKYoPIhhDBB5UMIYYLKhxDCBJUPIYQJKh9CCBNUPoQQJqh8CCFMUPkQQpig8iGEMEHlQwhhgsqHEMIElQ8hhAkqH0IIE1Q+hBAm/h/6vQ1edjDVOQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "test.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3d413bbc8b5e4734bc695b0e41e45e43", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:17:59\n", - "{'0': 8, '1': 992}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# noise free simulation (NFS)\n", - "mode = \"NFS\"\n", - "\n", - "# Test circuit \"initial_state\" : Noise free model on simulator\n", - "backend_sim = Aer.get_backend('qasm_simulator')\n", - "shots = 1000\n", - "job_noisefree = execute(test, backend_sim, shots=shots)\n", - "job_monitor(job_noisefree)\n", - "\n", - "count = job_noisefree.result().get_counts(test)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(count, color=['purple'], \n", - " title=str(n) + '- qubit QNN, initial state, noise free simulation')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Unitary Evolution" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(angles):\n", - " \"\"\"Returns a circuit implementing the unitary Rz(theta0) P Rz(theta1) P Rz(theta2)\n", - " where thetea0 = angles[0], theta1 = angles[1], and theta2 = angles[2] and\n", - " P = Rx(pi / 2) is a pi / 2 pulse.\n", - " \"\"\"\n", - " \n", - " circuit = QuantumCircuit(qr, cr)\n", - " circuit.rz(angles[0], qr[0])\n", - " circuit.rx(np.pi / 2, qr[0]),\n", - " circuit.rz(angles[1], qr[0]),\n", - " circuit.rx(np.pi / 2, qr[0]),\n", - " circuit.rz(angles[2], qr[0])\n", - " \n", - " return circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(0.314283559730307) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(4.27779036629818) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(3.31959735414771) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "# test angles\n", - "angles = 2 * np.pi * np.random.rand(3)\n", - "my_state = initial_state + unitary(angles)\n", - "qprog = my_state + measuring\n", - "\n", - "# QASM\n", - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test the circuit using a noise free simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:18:14\n", - "{'0': 252, '1': 748}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# noise free simulation (NFS)\n", - "mode = \"NFS\"\n", - "\n", - "# run the quantum neural network program\n", - "\n", - "shots = 1000\n", - "job_noisefree = execute(qprog, backend_sim, shots=shots)\n", - "\n", - "noisefree_count = job_noisefree.result().get_counts(qprog)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(noisefree_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(noisefree_count, color=['purple'], \n", - " title=str(n) + '- qubit QNN, ' + mode)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State tomography and quantum fidelity in noise free device simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "84c5beb68c774d79b3740bcbc5c00d32", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:18:18\n", - "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: NFS theta: 2.987977895799584 phi: 0.7898055544158503\n", - "Fidelity with theoretical ideal state\n", - "F = 0.999933478085305\n" - ] - } - ], - "source": [ - "# Execute state tomography using noise free quantum device simulation\n", - "mode = \"NFS\"\n", - "# obtain the final state vector\n", - "backend_stvct = Aer.get_backend('statevector_simulator')\n", - "job = execute(my_state, backend_stvct)\n", - "my_state_psi = job.result().get_statevector(my_state)\n", - "\n", - "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", - "qubit_set = []\n", - "for i in range(0,n) :\n", - " qubit_set.append(i)\n", - "\n", - "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", - "\n", - "# add the state tomography measurement circuits to the Quantum Program\n", - "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", - "\n", - "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", - "\n", - "# take 1024 shots for each measurement basis\n", - "# note: reduce this number for larger number of qubits\n", - "shots = 1000\n", - "\n", - "my_state_job = execute(my_state_tomo_circuits, backend_tomo, shots=shots)\n", - "job_monitor(my_state_job)\n", - "my_state_tomo_result = my_state_job.result() \n", - " \n", - "# extract tomography data from results\n", - "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", - "\n", - "# Quantum fidelity\n", - "\n", - "# reconstruct experimentally measured density matrix \n", - "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", - "\n", - "# calculate fidelity of fitted state:\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", - " \", shots:\", shots, \", mode:\", mode, \"theta:\", theta, 'phi:', phi)\n", - "F_fit = state_fidelity(rho_fit, my_state_psi)\n", - "print('Fidelity with theoretical ideal state')\n", - "print('F =', F_fit)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### From here, you need credentials:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "IBMQ.load_accounts()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ibmq_16_melbourne ibmqx4\n", - "----------------- ------\n", - "Num. Qubits: 14 Num. Qubits: 5\n", - "Pending Jobs: 65 Pending Jobs: 469\n", - "Least busy: True Least busy: False\n", - "Operational: True Operational: True\n", - "Avg. T1: 53.7 Avg. T1: 52.1\n", - "Avg. T2: 73.0 Avg. T2: 17.2\n", - "\n", - "\n", - "\n" - ] - } - ], - "source": [ - "backend_overview() # you may skip running this cell if you want" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ibmq_16_melbourne\n" - ] - } - ], - "source": [ - "# Make your choice of real device\n", - "#backend_real = least_busy(IBMQ.backends(operational=True, simulator=False))\n", - "#backend_real = IBMQ.get_backend('ibmqx4')\n", - "backend_real = IBMQ.get_backend('ibmq_16_melbourne')\n", - "print(backend_real)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare noise simulation corresponding to a given quantum device" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "device: ibmq_16_melbourne\n", - "noise model prepared for ibmq_16_melbourne\n" - ] - } - ], - "source": [ - "# Prepare device noise simulation (DNS)\n", - "\n", - "device = backend_real\n", - "print(\"device: \", device)\n", - "properties = device.properties()\n", - "coupling_map = device.configuration().coupling_map\n", - "prepared = False\n", - "if device.name() == 'ibmq_16_melbourne' :\n", - " gate_times = [\n", - " ('u1', None, 0), ('u2', None, 100), ('u3', None, 200),\n", - " ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),\n", - " ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),\n", - " ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),\n", - " ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),\n", - " ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773),\n", - " ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)\n", - " ]\n", - " prepared = True\n", - " \n", - "elif device.name() == 'ibmqx4' :\n", - " gate_times = [\n", - " ('u1', None, 0), ('u2', None, 60), ('u3', None, 120),\n", - " ('cx', [1, 0], 340), ('cx', [2, 0], 424), ('cx', [2, 1], 520),\n", - " ('cx', [3, 2], 620), ('cx', [3, 4], 420), ('cx', [4, 2], 920) \n", - " ]\n", - " prepared = True\n", - "\n", - "else :\n", - " print(\"No gate times yet defined in this notebook for: \", device)\n", - " \n", - "if prepared :\n", - " # Construct the noise model from backend properties and custom gate times\n", - " noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times)\n", - "\n", - " # Get the basis gates for the noise model\n", - " basis_gates = noise_model.basis_gates\n", - " \n", - " print(\"noise model prepared for\", device)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the algorithm using device noise simulation (DNS)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a02d100572e04c87b3878627bbd4ea4a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">\n", - "Date (DMY): 10/02/2019 10:18:47\n", - "{'0': 282, '1': 718}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute test using device noise simulation (DNS)\n", - "\n", - "backend_noise = Aer.get_backend('qasm_simulator') # for simulation (DNS)\n", - "\n", - "shots = 1000\n", - "mode = \"DNS\"\n", - "job_noise = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - "job_monitor(job_noise)\n", - "\n", - "print(job_noise.status)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "noisy_count = job_noise.result().get_counts(qprog) \n", - "print(noisy_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(noisy_count, color=['cyan'],\n", - " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State tomography and quantum fidelity in device noise simulation (DNS)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2f59dbc091124a85ab97e057c39613ed", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:18:51\n", - "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: DNS of ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", - "Fidelity with theoretical ideal state\n", - "F = 0.8969037947087841\n" - ] - } - ], - "source": [ - "# Execute state tomography using device noise simulation (DNS)\n", - "\n", - "# obtain the final state vector\n", - "backend_stvct = Aer.get_backend('statevector_simulator')\n", - "job = execute(my_state, backend_stvct)\n", - "my_state_psi = job.result().get_statevector(my_state)\n", - "\n", - "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", - "qubit_set = []\n", - "for i in range(0,n) :\n", - " qubit_set.append(i)\n", - "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'. \n", - "\n", - "# add the state tomography measurement circuits to the Quantum Program\n", - "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", - "\n", - "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", - "\n", - "# take 1024 shots for each measurement basis\n", - "# note: reduce this number for larger number of qubits\n", - "shots = 1000\n", - "mode = \"DNS\"\n", - "my_state_job = execute(my_state_tomo_circuits, backend_tomo, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates)\n", - "job_monitor(my_state_job)\n", - "my_state_tomo_result = my_state_job.result() \n", - "\n", - "# extract tomography data from results\n", - "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", - "\n", - "# Quantum fidelity\n", - "\n", - "# reconstruct experimentally measured density matrix \n", - "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", - "\n", - "# calculate fidelity of fitted state:\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", - " \", shots:\", shots, \", mode:\", mode, \"of\", device, \"theta:\", theta, 'phi:', phi)\n", - "F_fit = state_fidelity(rho_fit, my_state_psi)\n", - "print('Fidelity with theoretical ideal state')\n", - "print('F =', F_fit)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the algorithm on superconducting quantum computing device (SQC)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "55ddd53def4b48c588550d1a5dbdf1db", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job is being initialized

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">\n", - "Date (DMY): 10/02/2019 11:34:17\n", - "{'0': 309, '1': 715}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute test using superconducting quantum computing device (SQC)\n", - "\n", - "#Choose the backend\n", - "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", - "backend_SQC = device # for a real device\n", - "\n", - "# Execute on SQC and get counts\n", - "shots = 1000\n", - "if backend_SQC.name() == \"qasm_simulator\" : # optional test before final experiment \n", - " mode = \"DNS\"\n", - " job_real = execute(qprog, backend_SQC, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates)\n", - "else: # final experiment on real device\n", - " mode = \"SQC\"\n", - " job_real = execute(qprog, backend_SQC)\n", - " job_monitor(job_real)\n", - "\n", - "print(job_real.status)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "real_count = job_real.result().get_counts(qprog) \n", - "print(real_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(real_count, color=['orange'], \n", - " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State tomography and quantum fidelity on superconducting quantum computing device (SQC)" - ] - }, - { - "cell_type": "code", - "execution_count": 219, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "795f7379498d410c8f29c9757183ae9b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job is being initialized

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 07/02/2019 22:32:13\n", - "Tomography 1-qubit classifier on ibmq_16_melbourne , shots: 1000 , mode: SQC ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", - "Fidelity with theoretical ideal state\n", - "F = 0.8859731304253138\n" - ] - } - ], - "source": [ - "# Execute state tomography on superconducting quantum computing device (SQC)\n", - "mode = \"SQC\"\n", - "# obtain the final state vector\n", - "backend_stvct = Aer.get_backend('statevector_simulator')\n", - "job = execute(my_state, backend_stvct)\n", - "my_state_psi = job.result().get_statevector(my_state)\n", - "\n", - "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", - "qubit_set = []\n", - "for i in range(0,n) :\n", - " qubit_set.append(i)\n", - "\n", - "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", - "\n", - "# add the state tomography measurement circuits to the Quantum Program\n", - "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", - "\n", - "#Choose the backend\n", - "#backend_tomo = Aer.get_backend('qasm_simulator') # optional test before final experiment\n", - "backend_tomo = device # for real device\n", - "\n", - "# take 1024 shots for each measurement basis\n", - "# note: reduce this number for larger number of qubits\n", - "shots = 1000\n", - "\n", - "# loop: 27 circuits maximum per job to avoid exceeding the allowed limit for the real device. \n", - "n_circ = 3**n\n", - "i_max = min(27,n_circ)\n", - "my_jobs = []\n", - "index_job = -1\n", - "for i in range(0,n_circ,i_max) :\n", - " circs =[]\n", - " for j in range(i, i+i_max):\n", - " circs.append(my_state_tomo_circuits[j])\n", - " if backend_tomo.name() == \"qasm_simulator\" : # optional test before final experiment\n", - " mode = \"DNS\"\n", - " my_state_job = execute(circs, backend_tomo, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates)\n", - " else: # final experiment on real device\n", - " mode = \"SQC\" \n", - " my_state_job = execute(circs, backend_tomo, shots=shots)\n", - " my_jobs.append(my_state_job)\n", - " index_job = index_job + 1 \n", - " job_monitor(my_jobs[index_job], monitor_async = True)\n", - " \n", - " my_state_new_result = my_state_job.result()\n", - " if i == 0:\n", - " my_state_tomo_result = my_state_new_result\n", - " else:\n", - " my_state_tomo_result = my_state_tomo_result + my_state_new_result\n", - "\n", - "# extract tomography data from results\n", - "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", - "\n", - "# Quantum fidelity\n", - "\n", - "# reconstruct experimentally measured density matrix \n", - "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", - "\n", - "# calculate fidelity of fitted state:\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print('Tomography',str(n)+'-qubit classifier on', backend_tomo,\n", - " \", shots:\", shots, \", mode:\", mode, device, \"theta:\", theta, 'phi:', phi)\n", - "F_fit = state_fidelity(rho_fit, my_state_psi)\n", - "print('Fidelity with theoretical ideal state')\n", - "print('F =', F_fit)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Comparing NFS, DNS and SQC\n", - "The results mentioned above for the DNS and SQC experiments are illustrated together in the next graphs:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments on ibmqx4 using Qiskit 0.7." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "device_name = device.name()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "# !!! Skip this cell if you want to see the results for a new run of the program\n", - "#Date (DMY): 07/02/2019\n", - "device_name = \"ibm_16_melbourne\"\n", - "noisefree_count = {'1': 721, '0': 279}\n", - "noisy_count = {'1': 711, '0': 289}\n", - "real_count = {'1': 695, '0': 305}" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# NFS vs DSN vs SQC, count histograms\n", - "plot_histogram([noisefree_count, noisy_count, real_count], \n", - " title= str(n) + '- qubit QNN on ' + device_name,\n", - " color=['purple','cyan', 'orange'], bar_labels=True,\n", - " legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Quantum Fidelity" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "names = ['NFS','DNS','SQC']\n", - "legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']\n", - "\n", - "fidelities = [0.999,0.897,0.886]\n", - "plt.ylabel('Quantum Fidelity')\n", - "plt.suptitle(str(n) + '- qubit QNN on {}, '.format(device.name()))\n", - "plt.axis([-0.5,2.5,0.75,1.01])\n", - "plt.grid()\n", - "plt.scatter(names, fidelities)\n", - " \n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Several subroutines" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "def obj_simple(angles, shots=1000, verbose=False):\n", - " \"\"\"Returns the number of zero outputs of a single training example.\"\"\"\n", - " # make the program\n", - " qprog = make_program([theta, phi], angles)\n", - " if verbose:\n", - " QASM_source = qprog.qasm()\n", - " print(QASM_source)\n", - " if mode == \"NFS\": \n", - " dist = execute(qprog, backend_sim, shots=shots)\n", - " elif mode == \"DNS\":\n", - " dist = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - " \n", - " dist_count = dist.result().get_counts(qprog)\n", - " observable = {'1' : 1}\n", - " obj = average_data(dist_count,observable)/shots \n", - " print(\"The current value of the objective function is:\", obj, end=\"\\r\")\n", - "\n", - " return obj" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "def make_program(pangles, uangles): # to be modified if n>1!\n", - " \"\"\"Returns a program that prepares the state according\n", - " to pangles and applies the unitary according to uangles.\n", - " \"\"\"\n", - " new_state = QuantumCircuit(qr, cr)\n", - " # desired vector\n", - " desired_vector = [np.cos(pangles[0] / 2), np.exp(1j * pangles[1]) * np.sin(pangles[0] / 2)]\n", - " qr_vector = []\n", - "\n", - " # Initialize a 1-qubit quantum state using the arbitrary method \n", - " qr_vector.append(qr[0])\n", - " new_state.initialize(desired_vector, qr_vector)\n", - " \n", - " # write the program\n", - " qprogram = new_state + unitary(uangles) + measuring \n", - " \n", - " return qprogram" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "def obj(uangles):\n", - " \"\"\"Returns the objective function C defined above over all training data.\n", - " \n", - " Args:\n", - " uangles [type: list]\n", - " the angles in the unitary evolution.\n", - "\n", - " rtype: int\n", - " \"\"\"\n", - " # grab some training data from the overall data set\n", - " tpoints = int(train_frac * len(qdata))\n", - " tdata = qdata[:tpoints]\n", - " tlabels = labels[:tpoints]\n", - "\n", - " \n", - " # initialize a variable to store the output predictions of the neural net\n", - " predictions = np.zeros_like(tlabels, dtype=int)\n", - " \n", - " # loop over all training data to get the predictions\n", - " for i, pangles in enumerate(tdata):\n", - " # write the program\n", - " qprog = make_program(pangles, uangles)\n", - " \n", - " # run the program\n", - " shots = 1000\n", - " \n", - " if mode == \"NFS\": \n", - " out = execute(qprog, backend_sim, shots=shots)\n", - " elif mode == \"DNS\":\n", - " out = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - " \n", - " out_count = out.result().get_counts(qprog)\n", - " \n", - " # get the output probabilities\n", - " observable_1 = {'1' : 1, '0' : 0}\n", - " observable_0 = {'0' : 1, '1' : 0}\n", - " p1 = average_data(out_count,observable_1)\n", - " p0 = average_data(out_count,observable_0)\n", - " \n", - " # take the prediction to be max(p0, p1)\n", - " if p0 >= p1:\n", - " predictions[i] = 0\n", - " else:\n", - " predictions[i] = 1\n", - "\n", - "# uncomment next four lines for check \n", - "# if i == 0 :\n", - "# QASM_source = qprog.qasm()\n", - "# print(QASM_source)\n", - "# print(p0,p1)\n", - " \n", - " # compute the difference of the labels and return the cost\n", - " cost = sum(abs(predictions - tlabels)) / tpoints\n", - " print(\"The current value of the cost function is:\", cost, end=\"\\r\")\n", - " return cost" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "def get_all_predictions(angles):\n", - " \"\"\"Returns a numpy array of all predictions.\"\"\"\n", - " # initialize a variable to store the output predictions of the neural net\n", - " zhats = np.zeros_like(labels, dtype=int)\n", - " \n", - " # loop over all data to get predictions\n", - " for i, pangles in enumerate(qdata):\n", - " # write the program\n", - " qprog = make_program(pangles, angles)\n", - " \n", - " # run the program\n", - " shots = 1000\n", - " \n", - " if mode == \"NFS\": \n", - " out = execute(qprog, backend_sim, shots=shots)\n", - " elif mode == \"DNS\":\n", - " out = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - " \n", - " out_count = out.result().get_counts(qprog)\n", - " \n", - " # get the output probabilities\n", - " observable_1 = {'1' : 1, '0' : 0}\n", - " observable_0 = {'0' : 1, '1' : 0}\n", - " p1 = average_data(out_count,observable_1)\n", - " p0 = average_data(out_count,observable_0)\n", - " \n", - " # take the prediction to be max(p0, p1)\n", - " if p0 >= p1:\n", - " zhats[i] = 0\n", - " else:\n", - " zhats[i] = 1\n", - " return zhats" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(0.314283559730307) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(4.27779036629818) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(3.31959735414771) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "qprog = make_program([theta, phi], angles)\n", - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the objective function is: 0.0060569999999999999\r" - ] - } - ], - "source": [ - "mode = \"NFS\"\n", - "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "# do the circuit (neural network) with the optimal parameters\n", - "opt_angles = out['x']\n", - "qprog = make_program([theta, phi], opt_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(8.89515197858799) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(6.14308213587254) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(7.13449483997346) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 11:59:44\n", - "{'0': 999, '1': 1}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# show the output distribution\n", - "shots = 1000\n", - "backend_sim = Aer.get_backend('qasm_simulator')\n", - "dist = execute(qprog, backend_sim, shots=shots)\n", - "dist_count = dist.result().get_counts(qprog)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(dist_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(dist_count, color=['purple'], \n", - " title=str(n) + '- qubit QNN, ' + mode)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training (NFS)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "# fraction of total data to use as training data\n", - "train_frac = 0.7" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 0.9857142857142858\r" - ] - } - ], - "source": [ - "# get some random angles\n", - "angs = 2 * np.pi * np.random.rand(3)\n", - "cost = obj(angs)" - ] - }, - { - "cell_type": "code", - "execution_count": 176, - "metadata": {}, - "outputs": [], - "source": [ - "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 0.014285714285714285\n", - "Total training runtime took 1.8455156366030374 minutes.\n" - ] - } - ], - "source": [ - "# train the quantum neural network and time how long it takes\n", - "start = time.time()\n", - "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", - "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "[3.321652 6.2743205 5.85861077]\n" - ] - } - ], - "source": [ - "# grab the optimal angles and minimal cost value\n", - "optimal_angles = out['x']\n", - "fval = out['fun']\n", - "\n", - "# print them out\n", - "print(fval)\n", - "print(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [], - "source": [ - "# compute all the predictions of the quantum neural network\n", - "predictions = get_all_predictions(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "=============== Results of quantum neural network classification ===============\n", - "Out of 100 total data points:\n", - "The QNN was trained on 70.0% of the total data (70 training points).\n", - "The QNN classified 100 data points correctly (100.0% accuracy).\n", - "================================================================================\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# compute statistics of the QNN\n", - "ntrain = int(train_frac * npoints)\n", - "ncorrect = npoints - sum(abs(predictions - labels))\n", - "acc = ncorrect / npoints * 100\n", - "\n", - "# print them out\n", - "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", - "print(\"Out of {} total data points:\".format(npoints))\n", - "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", - "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", - "print(\"\".center(80, \"=\"))\n", - "\n", - "# plot the points, line y = x, and prediction\n", - "plt.plot(ys, xs, '--k')\n", - "for i in range(npoints):\n", - " if predictions[i] == 0:\n", - " ckey = 'g'\n", - " else:\n", - " ckey = 'b'\n", - " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", - "\n", - "plt.grid()\n", - "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Testing on device noise simulator" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [], - "source": [ - "# Testing on device noise simulator\n", - "mode = \"DNS\"" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(0.314283559730307) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(4.27779036629818) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(3.31959735414771) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "qprog = make_program([theta, phi], angles)\n", - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the objective function is: 0.00011199999999999999\r" - ] - } - ], - "source": [ - "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [], - "source": [ - "# do the circuit (neural network) with the optimal parameters\n", - "opt_angles = out['x']\n", - "qprog = make_program([theta, phi], opt_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(-1.51785048443617) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(0.248786966568569) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(9.26351197606004) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 12:45:53\n", - "{'0': 904, '1': 96}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# show the output distribution (DNS)\n", - "mode = \"DNS\"\n", - "dist = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - "dist_count = dist.result().get_counts(qprog)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(dist_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(dist_count, color=['cyan'], \n", - " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training (DNS)" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [], - "source": [ - "# fraction of total data to use as training data (DNS)\n", - "train_frac = 0.7" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 1.0\r" - ] - } - ], - "source": [ - "# get some random angles\n", - "angs = 2 * np.pi * np.random.rand(3)\n", - "cost = obj(angs)" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [], - "source": [ - "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 0.014285714285714285\n", - "Total training runtime took 6.603797650337219 minutes.\n" - ] - } - ], - "source": [ - "# train the quantum neural network and time how long it takes\n", - "start = time.time()\n", - "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", - "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "[3.47838504 6.18048312 3.49508897]\n" - ] - } - ], - "source": [ - "# grab the optimal angles and minimal cost value\n", - "optimal_angles = out['x']\n", - "fval = out['fun']\n", - "\n", - "# print them out\n", - "print(fval)\n", - "print(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [], - "source": [ - "# compute all the predictions of the quantum neural network\n", - "predictions = get_all_predictions(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "=============== Results of quantum neural network classification ===============\n", - "Out of 100 total data points:\n", - "The QNN was trained on 70.0% of the total data (70 training points).\n", - "The QNN classified 99 data points correctly (99.0% accuracy).\n", - "================================================================================\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# compute statistics of the QNN # previous experiment\n", - "ntrain = int(train_frac * npoints)\n", - "ncorrect = npoints - sum(abs(predictions - labels))\n", - "acc = ncorrect / npoints * 100\n", - "\n", - "# print them out\n", - "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", - "print(\"Out of {} total data points:\".format(npoints))\n", - "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", - "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", - "print(\"\".center(80, \"=\"))\n", - "\n", - "# plot the points, line y = x, and prediction\n", - "plt.plot(ys, xs, '--k')\n", - "for i in range(npoints):\n", - " if predictions[i] == 0:\n", - " ckey = 'g'\n", - " else:\n", - " ckey = 'b'\n", - " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", - "\n", - "plt.grid()\n", - "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### References:\n", - "\n", - "[1] https://github.com/QuantumAI-lib/NISQAI/blob/master/examples/one-qubit-classifier/one-qubit-classifier.ipynb\n", - "\n", - "[2] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/community/terra/qis_adv/Multi-Qubit_W_States_with_Tomography.ipynb\n", - "\n", - "[3] Smolin, J. A., Gambetta, J. M. & Smith, G. (2012). Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Phys. Rev. Lett 108(7). https://link.aps.org/doi/10.1103/PhysRevLett.108.070502\n", - "\n", - "[4] Preskill, J. (2018) Quantum Computing in the NISQ era and beyond. Quantum 2, 79 (2018). https://arxiv.org/abs/1801.00862\n", - "\n", - "[5] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.1" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 844a61d3c18cbd49c02cf64698bb5c29afa3dbe9 Mon Sep 17 00:00:00 2001 From: Pierre Decoodt Date: Sun, 10 Feb 2019 15:46:13 +0100 Subject: [PATCH 3/5] Add files via upload --- ... Simulation and Real Device Run Test.ipynb | 2131 +++++++++++++++++ 1 file changed, 2131 insertions(+) create mode 100644 examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb diff --git a/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb b/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb new file mode 100644 index 0000000..2c574e1 --- /dev/null +++ b/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb @@ -0,0 +1,2131 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NISQAI One-Qubit Quantum Neural Network Adapted for Qiskit\n", + "\n", + "\n", + "***\n", + "### Contributors\n", + "#### Add here the contributors:\n", + "Pierre Decoodt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "This is a proof of concept for the assessment on Qiskit of a NISQAI classifier$^{[1]}$.\n", + "A one-qubit neural network is tested on Aer based noise free simulation (NFS) and device noise simulation (DNS), and also on real superconducting quantum calculating device (SQC).\n", + "\n", + "The protocol follows the steps described in a previous Qiskit tutorial $^{[2]}$ using quantum state tomography $^{[3]}$ for assessing fidelity.\n", + "\n", + "The last part consist of testing training and prediction by NFS and DNS.\n", + "\n", + "NB: I use the term SQC instead of NISQ because the original Preskill paper $^{[4]}$ specifies as \"NISQ\" quantum computers with 50-100 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\decpi\\Anaconda3\\envs\\q7env\\lib\\site-packages\\marshmallow\\schema.py:364: ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See https://marshmallow.readthedocs.io/en/latest/upgrading.html#schemas-are-always-strict\n", + " ChangedInMarshmallow3Warning\n" + ] + } + ], + "source": [ + "#Import packages\n", + "# NB running this cell induces a ChangedInMarshmallow3Warning for the moment. This warning can be safely ignored.\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import time\n", + "from scipy.optimize import minimize\n", + "\n", + "# import from qiskit\n", + "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, compile\n", + "from qiskit.converters import qobj_to_circuits\n", + "from qiskit import Aer, IBMQ\n", + "from qiskit.providers.aer import noise\n", + "\n", + "# import tomography library\n", + "import qiskit.tools.qcvv.tomography as tomo\n", + "\n", + "# useful additional packages \n", + "from qiskit.tools.visualization import plot_state, plot_histogram \n", + "from qiskit.tools.qi.qi import state_fidelity, outer\n", + "from qiskit.tools.qi.qi import outer\n", + "from qiskit.quantum_info import state_fidelity\n", + "from qiskit.tools.monitor import job_monitor, backend_overview\n", + "from qiskit.providers.ibmq import least_busy\n", + "from qiskit.quantum_info.analyzation.average import average_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Aer.backends() # No need for credentials for running the next cells until next warning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Data Encoding" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set random seed for reproducible results\n", + "SEED = 1059123109\n", + "np.random.seed(seed=SEED)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# generate data points distributed uniformly at random in [0, 1) x [0, 1)\n", + "npoints = 100\n", + "data = np.random.rand(npoints, 2)\n", + "\n", + "def predicate(point):\n", + " \"\"\"Returns true if the point satisfies the predicate, else false.\"\"\"\n", + " return True if point[0] <= 0.5 else False\n", + "\n", + "# separate the data with a linear boundary y = x\n", + "labels = np.array([1 if predicate(p) else 0 for p in data])\n", + "\n", + "# plot the line y = x\n", + "xs = np.linspace(0, 1, 100)\n", + "ys = 0.5 * np.ones_like(xs)\n", + "plt.plot(ys, xs, '--k')\n", + "\n", + "# plot the data with the color key BLUE = 0 = LEFT, GREEN = 1 = RIGHT\n", + "for i in range(npoints):\n", + " if labels[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + " \n", + "# title and axis lables\n", + "plt.title(\"Random Data Points in Unit Square\", fontweight=\"bold\", fontsize=16)\n", + "\n", + "# put on a grid and show the plot\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Qubit Encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# encode the classical data via a simple linear \"qubit encoding\"\n", + "qdata = np.zeros_like(data)\n", + "for (index, point) in enumerate(data):\n", + " qdata[index][0] = np.pi * point[0]\n", + " qdata[index][1] = 2 * np.pi * point[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. State Preparation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As explained is the NISQAI one-qubit classifier description$^{[1]}$, the one-qubit encoding is achieved by realizing the following initial state: \n", + " \n", + "$$|\\psi\\rangle = \\cos(\\frac {\\theta}{2}) |0\\rangle + e^{i \\phi} \\sin(\\frac {\\theta}{2})|1\\rangle $$\n", + "\n", + "\n", + "The unitary taking the $|0\\rangle$ to the above state is: \n", + "\n", + "$$\n", + "S(\\theta, \\phi) = \\begin{pmatrix}\n", + "\\cos(\\frac {\\theta}{2}) & e^{-i \\phi}\\sin(\\frac {\\theta}{2}) \\\\\n", + "e^{i \\phi} \\sin(\\frac {\\theta}{2}) & - \\cos(\\frac {\\theta}{2})\n", + "\\end{pmatrix}\n", + "$$\n", + "\n", + "\n", + "Such an operation is not currently directly available in Qiskit to our knowledge. We therefore use arbitrary initialization in order to encode the qubit $^{[5]}$.\n", + "\n", + "A check of the results of this arbitrary initialization follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.122 5.969 0 vs 2 -- 8191 vs 8190\n", + "0.348 0.911 7946 vs 7946 -- 245 vs 246\n", + "1.652 4.618 3765 vs 3849 -- 4426 vs 4343\n", + "2.919 0.365 101 vs 94 -- 8090 vs 8098\n", + "2.582 1.018 623 vs 592 -- 7568 vs 7600\n", + "0.002 5.703 8191 vs 8192 -- 0 vs 0\n", + "2.986 5.712 49 vs 34 -- 8142 vs 8158\n", + "3.064 1.62 12 vs 15 -- 8179 vs 8177\n", + "1.516 0.87 4320 vs 4356 -- 3871 vs 3836\n", + "3.131 0.308 0 vs 0 -- 8191 vs 8192\n", + "2.118 0.197 1965 vs 1949 -- 6226 vs 6243\n" + ] + } + ], + "source": [ + "# Checking arbitrary initialization\n", + "n = 1\n", + "for i in range(5,56,5) : # modify here if wishe\n", + " # create a n-qubit quantum register\n", + " qrt = QuantumRegister(n)\n", + " crt = ClassicalRegister(n)\n", + " check_sta = QuantumCircuit(qrt,crt , name='check_sta')\n", + "\n", + " # pick an encoded data point\n", + " theta, phi = qdata[i]\n", + "\n", + " # desired vector\n", + " desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", + " qrt_vector = []\n", + "\n", + " # Initialize a 1-qubit quantum state using the arbitrary method \n", + " qrt_vector.append(qrt[0])\n", + " check_sta.initialize(desired_vector, qrt_vector)\n", + "\n", + " # Measurement circuit\n", + " measuring = QuantumCircuit(qrt,crt , name='measuring')\n", + " for i in range(n) :\n", + " measuring.measure(qrt[i] , crt[i])\n", + " test_check = check_sta+measuring\n", + "\n", + " # noise free simulation (NFS)\n", + " mode = \"NFS\"\n", + "\n", + " # test circuit \"check_sta\" : Noise free model on simulator\n", + " backend_sim = Aer.get_backend('qasm_simulator')\n", + " shots = 8192\n", + " job_noisefree = execute(test_check, backend_sim, shots=shots) \n", + " count = job_noisefree.result().get_counts(test_check)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " fr_obs1 = int(average_data(count,observable_1)*8192)\n", + " fr_obs0 = int(average_data(count,observable_0)*8192)\n", + " \n", + " fr_theo0 = int(abs(np.cos(theta / 2)**2)*shots)\n", + " fr_theo1 = int(abs(np.exp(1j * phi) * np.sin(theta / 2)**2)*shots)\n", + " print(round(theta,3), round(phi,3),\" \", fr_theo0,\"vs\", fr_obs0,\"--\", fr_theo1,\"vs\", fr_obs1) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Determine the job\n", + "n = 1\n", + "\n", + "# create a n-qubit quantum register\n", + "qr = QuantumRegister(n)\n", + "cr = ClassicalRegister(n)\n", + "initial_state = QuantumCircuit(qr, cr, name='initial_state')\n", + "\n", + "# pick a particular encoded data point\n", + "theta, phi = qdata[0]\n", + "\n", + "# desired vector\n", + "desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", + "qr_vector = []\n", + "\n", + "# Initialize a 1-qubit quantum state using the arbitrary method \n", + "qr_vector.append(qr[0])\n", + "initial_state.initialize(desired_vector, qr_vector)\n", + "\n", + "# Measurement circuit\n", + "measuring = QuantumCircuit(qr, cr, name='measuring')\n", + "for i in range(n) :\n", + " measuring.measure(qr[i] , cr[i])\n", + "test = initial_state+measuring" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the arbitrary initialization of the state by noise free simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "# QASM from test\n", + "QASM_source = test.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR8AAAB2CAYAAADx25drAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAESVJREFUeJzt3XtMU/ffB/B3bYGW0YsiiorgZFMfcYDgBXAddfrAFlFU3Oa8zU3FRDFTiSu6ZBoTfpa5bGrm5hhsLvNB8DKHzl/QKJeUiE0VGXY6NwLjprGiQOcFsaXPH8bGWqQFTvul8nklJOV8T3veBfrmnMO3HJ7ZbDaDEEJcbADrAISQ/onKhxDCBJUPIYQJKh9CCBNUPoQQJqh8CCFMUPmQHrl+/ToiIiIgFAphNBpZx3GIRqNBTEwM5HI5NmzYwDqOw3Q6nSX3hx9+iBdldgyVD+mRQYMG4ezZs4iKimIdxWFBQUEoLCyEWq2GXq/H5cuXWUdyyNixY3Hu3Dmo1WoAwIULFxgn4oaAdQDinoRCIYRCIesY3eLv72+5LRAIwOfzGaZxnIeHh+W2l5cXRo4cyTANd2jPh/Q7lZWVaGpqwvjx41lHcdjx48cxYcIE6PV6+Pr6so7DCSof0q/cuXMHKSkpyM7OZh2lW+bMmQOdTocRI0bgt99+Yx2HE1Q+pN8wGo1YsmQJdu7caXUI1tc9fPjQclsikUAkEjFMwx0qH9Ijjx49wsyZM/H7778jPj4eGo2GdSS7Dh8+DK1WC6VSCYVCgbKyMtaRHFJQUIDY2FjExsbi5s2biIuLYx2JEzx6VzshhAXa8yGEMEHlQwhhgsqHEMIElQ8hhAkqH0IIE1Q+hBAmqHwIIUxQ+RBCmKDyIYQwQeVDCGGCyocQwgSVDyGECfpPhv3c+vXrUVFR4fLthoeHY9euXT26L6vMgHvm7k1mZ6I9n36uoqLC5S+I3m6TRWYutuuOX2tnoj0fgvDwcBQXF7tsewqFoteP4erMgHvm5iKzs9CeDyGECSofQggTVD6EECaofIhDhg8fDpFIBB8fH0ilUrz11luor69nHcsud83dH1D5ELsaGxtx48YNlJeX4+7du6iuroZer0daWhrraF1y19z9BZUPsUur1UIikWDcuHEAAF9fX0RERODmzZuMk3XNXXM/q6OjA21tbejo6LC7bn19PUwmkwtS9R6VD7FLq9Vi8uTJ4PF4MBqNKCgoQF5eHhYtWsQ6WpfcNXdHRwdOnTqF5cuXIyQkBAKBACKRCJ6enggLC8OqVaugVqvx7IVnrl27hilTpiA1NZVR8u7pN/N89u/fj/3793drjkVkZCR27Njxwlwnqae0Wi1KS0shk8lw9+5deHt7Izs7G++++y7raF1yx9ynT59GSkoK/v77b/j6+iI6Ohpz586Fj48PWltbUVFRgUOHDiErKwthYWHYt28foqKicO3aNSgUCnR0dCA5OZn103AIkz2f3NxcyOVySCQSCAS2/WdvnAsmkwmbNm2Cn58fxGIxkpKS0NTUZLVOYmIi8vPznbJ9d3LhwgUcPHgQLS0tqK+vR0BAAP7880/Wsexyp9xGoxHr1q1DfHw8+Hw+Dh48iOvXr+PEiRNIT0/H5s2boVKpUFBQgBs3biArKwt37tzBtGnTsHbtWkvxFBUVuc016JmUz8CBA7FmzZrnvt/E3jgXVCoV8vPzodFo0NDQAABYunSp1TqJiYk4fvy40zK4g6qqKjQ3NyMiIgIAMGzYMKSmpmLfvn2WcxClpaX46KOPLPd57733cPHiRSZ5n3Akt9FoxIwZM6BQKBAWFobIyEgmWU0mE5YtW4avv/4a69evx6VLl7Bw4UJ4enp2ur63tzdWrFgBnU6HOXPm4JtvvkFraysKCwvdpngAJ5bPoUOH8Nprr8HHxwdxcXHYuHEj3nnnHQBAfHw83n//fYwePbrT+9ob50JmZiaUSiVGjx4NqVSKzz//HAUFBfjnn38s64SFhUEgEDB/IbGk1WoxaNAgBAUFWZYlJibi5s2bKC0tBQBMmjQJly5dAgAUFRVBKpUyeyE/4UhugUCAs2fPIicnB6NHj8axY8eYZN25cycOHjyIHTt24KuvvoJQKHTofjdu3MD58+fh7e2NBw8eQKvVOjkpt5xSPj/99BNSU1MtjZyQkIA9e/Zg4sSJztgcVCoVQkNDHV6/tbUVdXV1Vi+Q4OBgSCQSVFZWWq07Z86cfn3opdVqbb5vgwcPRkxMDI4cOQIAEAqFEAqFaG5uxtatW5Gens4iqhVHcgNATU0NUlJS8N133yEwMNDVMXH16lVs3boVSUlJUCqVDt/v6XM8Go0Gcrkc69evx/Xr152Yllucl8/9+/exceNGZGZmQi6Xg8/nY+XKlTCZTE4rn7S0NJvS6IrBYAAASKVSq+Uymcwy9sSsWbNw8uTJ3od0U19++SXOnDljs1ytVmPPnj2Wz6dOnYpVq1YhKSkJfn5+rozYKUdyX7lyBZs2bcIPP/yAIUOGuDoigMe/OD09PbF3717weDyH7vN08RQVFWHChAnIzs7G3bt3sXv3bicn5g7n5VNSUoKOjg68/fbblmW3bt0CAKeVT3eJxWIAj/eAntbS0gKJRGK1rLa21iW/EXk8HpOPkpISTvJHRUXh6tWrWLt2rUPrl5SUMM8cFxeH2tpazJ07FwqFwubnwdm5b9++jby8PCxbtgxDhw51KPOzxfPkHM+rr76KxMREZGdn4+HDh5xl7u1HVzgvH71eb/NbJCcnB/7+/vD39+d6cz0ik8kQGBiI8vJyy7Lq6moYDAabw7fjx48jMTHR6ZnMZjOTj9jYWE7yl5aWYs+ePQ7/dTI2NpZ55oaGBmi1WhQXF6O4uNhmT9jZudVqNR4+fIjFixc7lPd5xfPEokWLcPv2bcv5Ny4y9/ajK5yXT0hICKqqqlBSUoL29nbk5ORApVIhPDzcso7JZEJbWxva29sBAG1tbWhra7OEtTfOheTkZGRkZKCmpgYGgwFKpRLx8fEYNWqUZZ379++jqKgICQkJnG33RdPQ0IDExERIpVLMmDGDdRy3cvHiRfD5fIeOCOwVDwBMmTLF8rjugPPymTRpEj799FPMnz8fAQEB0Gg0mDp1qtUX+Oeff4ZIJEJ8fDxMJhNEIhFEIhFqa2sdGn/Wf/7zH4SEhHQrZ1paGmbPno3JkydjxIgRMJlMOHDggNU6p06dwsSJEzF48OBufhX6j4CAAOTn5/eJk8zuprGxEcOGDYNIJOpyPUeKB3j8vfDw8EBjY6Mz4nLOKX/t2r59O27fvg29Xo/du3fjr7/+siqf5cuXd7qL9mSvw974s7Zs2YI//vijWxn5fD6++OILNDU14d9//8Uvv/xiUzKuOuQi/dO3334LnU5nd73m5maIxWK7Ewh5PB70ej22bdvGYUrncfokQ4PBgNra2j5zsrk7goKCLHOT+iONRoOYmBjI5XJs2LDBaqyiogLTpk2DXC6HWq0GANTV1eHNN9/EG2+8gUOHDrGIbLFhwwbI5XJ8/PHHVssXLlwIhUKB6Ohoy6mAzp6LK3h5eTl0nikqKgpXrlxxaAKhTCZ77uTEvsbp5aPT6SAWixEcHOzsTXUpPDwcy5cv79Z9tm3bZjVJrb8JCgpCYWEh1Go19Ho9Ll++bBn77LPPkJeXh1OnTlkOuTIyMpCeno6ioiJkZWXBaDQyyV1eXo579+5BrVajvb3davJdbm4uiouL8cknn1jO5XX2XPoaZ73NiCWnl09MTAwMBoPDcxicpSfl09/5+/tbZtsKBALw+XzLWHNzMwICAuDt7Y179+7hwYMHqK6uRmhoKPh8PoYOHYqqqiomucvKyjBz5kwAwMyZM3H+/HmbdY4dO4b58+cD6Py5EOejf6lB7KqsrERTU5PVbr+fnx90Oh1u3boFnU6HlpYWjB07FiUlJbh//z7Onz+P5uZmJnmfnq8llUptchiNRly+fNnyvq/OngtxvhdvX45w6s6dO0hJSbE5h6NSqZCSkgKxWIzQ0FAMHjwYmzdvxurVq7F3716MGzfO4YlzXHt6prrBYIBMJrMaLyoqsrqkTGfPhTgf7fmQ5zIajViyZAl27txpM0F0zJgxOH36tOU9UR4eHhg6dCh+/fVXHDlyBF5eXnj55ZeZ5I6OjsbZs2cBAGfOnEFUVJTV+LFjxzBv3jzL5509F+J8VD7kuQ4fPgytVgulUgmFQoGysjKsW7cOAJCdnY3p06fjgw8+wPbt2wEAJ0+exPTp0zF79mxs3ryZ2Xm+iIgICIVCyOVyDBgwAIGBgZYTyWazGWVlZXj99dct63f2XIjz8cxcThsmbufJ4QeLq2j2dJssMnOxXXf8WjsTnfMhqKiocOlldSsqKqzebtPTx3D1pYDdMTcXmZ2FyqefY/GDGR4e3qvtsnoxscpdXXcDowOH2dx2dJt9tXzosIuQPi4tIxMqZbLNbXdHJ5wJIUxQ+RBCmKDyIYQwQeVDCGGCyocQwgSVDyGECSofQggTVD6EECaofAghTFD5EEKYoPIhhDBB5UMIYYLKhxDCBJUPIYQJKh9CCBNUPoS8oIqLixESEoJXXnkFK1euhMlkYh3JCpUPIS+gjo4OrFy5EocPH0ZVVRUMBgMOHDjAOpYVKh9CXkBarRbDhw+3XOhxxYoVOHr0KONU1uh/OBPShxj+vYebt22v9Pr3Pw2d3h4+ZDBe8hbarN/Q0ICRI0daPg8MDER9fT3HaXuHyoeQPmQAfwD+79czaHvYbrU8O++/Nrel4peQuuq9Th/HbDZbXTetL/6rdjrsIqQP8fEWYUZMhEPrvq2YCk+PzvcfRo4cibq6Osvn9fX1CAgI4CQjV6h8COljoiND4DtQ0uU6gcOHIOx/gp87PmnSJDQ2NuLKlSsAHl+Vdf78+Zzm7C0qH0L6GAGfj1nTo7pcJ2FGTJeXo+bz+fj++++xYMECBAcHw8fHB0uXLuU6aq/QdbsI6YPMZjOy8/6LqtpGm7GJIa/gvYQ3GaTiFu35ENIH8Xg8JMyIttm78RDw8dYbUxil4lafKZ/c3FzI5XJIJBIIBLYn0eyNc8FkMmHTpk3w8/ODWCxGUlISmpqanLItQuzx9xuEKWHjrJbFTg2HVOLDKBG3+kz5DBw4EGvWrMGuXbt6NM4FlUqF/Px8aDQaNDQ8nkvR146TSf/yv/JJ8PL0APD4T+tvTA1jnIhDZhcrLS01x8XFmYcMGWKWSqXmBQsWWI0XFRWZ+Xz+c+9vb7w3AgMDzVlZWZbPq6qqzADMNTU1TtkeIY4o0fxuVqq+M1/642/WUTjl0kmGR48eRXJyMjIzM5GQkID29nacO3fOKdtSqVTIyclBZWWlQ+u3trairq4OkZGRlmXBwcGQSCSorKzEqFGjnJLzibSMTKc+PnF/uScKkXuikHWMblEpk5875rLyuXfvHlavXo3du3cjKSkJAODl5YX4+HinbC8tLQ1paWkOr28wGAAAUqnUarlMJrOMOVNX3yRCzM/MWH4RuOycT0lJCXg8HhYvXuyqTXaLWCwG8HgP6GktLS2QSLqe8EWIs71oxQO4cM+nqakJAwcO7LNfRJlMhsDAQJSXlyM8PBwAUF1dDYPBgNDQUKdvnw67yIuoTxx2RUZGoqamBidOnMCsWbNgMBig0Wgsh10mkwmPHj1Ce/vjN9S1tbUBeHxoxuPx7I5zITk5GRkZGZg+fTp8fX2hVCoRHx/v9PM9AB12kX7IlWe39+/fbx4zZoz5pZdeMvv7+5u3bNliGfvxxx/NAGw+nvylyd74s9LT083jx4/vVj6j0WhOTU01+/r6mn18fMzz5s0z37p1q6dPlxDSBXp7BSGEiT4zyZAQ0r9Q+RBCmKDyIYQwQeVDCGGCyocQwgSVDyGECSofQggTVD6EECaofAghTFD5EEKYoPIhhDBB5UMIYYLKhxDCBJUPIYQJKh9CCBNUPoQQJqh8CCFMUPkQQpig8iGEMEHlQwhhgsqHEMIElQ8hhAkqH0IIE1Q+hBAm/h/6vQ1edjDVOQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "test.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3d413bbc8b5e4734bc695b0e41e45e43", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:17:59\n", + "{'0': 8, '1': 992}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# noise free simulation (NFS)\n", + "mode = \"NFS\"\n", + "\n", + "# Test circuit \"initial_state\" : Noise free model on simulator\n", + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "shots = 1000\n", + "job_noisefree = execute(test, backend_sim, shots=shots)\n", + "job_monitor(job_noisefree)\n", + "\n", + "count = job_noisefree.result().get_counts(test)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, initial state, noise free simulation')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Unitary Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def unitary(angles):\n", + " \"\"\"Returns a circuit implementing the unitary Rz(theta0) P Rz(theta1) P Rz(theta2)\n", + " where thetea0 = angles[0], theta1 = angles[1], and theta2 = angles[2] and\n", + " P = Rx(pi / 2) is a pi / 2 pulse.\n", + " \"\"\"\n", + " \n", + " circuit = QuantumCircuit(qr, cr)\n", + " circuit.rz(angles[0], qr[0])\n", + " circuit.rx(np.pi / 2, qr[0]),\n", + " circuit.rz(angles[1], qr[0]),\n", + " circuit.rx(np.pi / 2, qr[0]),\n", + " circuit.rz(angles[2], qr[0])\n", + " \n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "# test angles\n", + "angles = 2 * np.pi * np.random.rand(3)\n", + "my_state = initial_state + unitary(angles)\n", + "qprog = my_state + measuring\n", + "\n", + "# QASM\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the circuit using a noise free simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:14\n", + "{'0': 252, '1': 748}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# noise free simulation (NFS)\n", + "mode = \"NFS\"\n", + "\n", + "# run the quantum neural network program\n", + "\n", + "shots = 1000\n", + "job_noisefree = execute(qprog, backend_sim, shots=shots)\n", + "\n", + "noisefree_count = job_noisefree.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(noisefree_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(noisefree_count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, ' + mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity in noise free device simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84c5beb68c774d79b3740bcbc5c00d32", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:18\n", + "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: NFS theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.999933478085305\n" + ] + } + ], + "source": [ + "# Execute state tomography using noise free quantum device simulation\n", + "mode = \"NFS\"\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "\n", + "my_state_job = execute(my_state_tomo_circuits, backend_tomo, shots=shots)\n", + "job_monitor(my_state_job)\n", + "my_state_tomo_result = my_state_job.result() \n", + " \n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### From here, you need credentials:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "IBMQ.load_accounts()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibmq_16_melbourne ibmqx4\n", + "----------------- ------\n", + "Num. Qubits: 14 Num. Qubits: 5\n", + "Pending Jobs: 65 Pending Jobs: 469\n", + "Least busy: True Least busy: False\n", + "Operational: True Operational: True\n", + "Avg. T1: 53.7 Avg. T1: 52.1\n", + "Avg. T2: 73.0 Avg. T2: 17.2\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "backend_overview() # you may skip running this cell if you want" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibmq_16_melbourne\n" + ] + } + ], + "source": [ + "# Make your choice of real device\n", + "#backend_real = least_busy(IBMQ.backends(operational=True, simulator=False))\n", + "#backend_real = IBMQ.get_backend('ibmqx4')\n", + "backend_real = IBMQ.get_backend('ibmq_16_melbourne')\n", + "print(backend_real)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prepare noise simulation corresponding to a given quantum device" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: ibmq_16_melbourne\n", + "noise model prepared for ibmq_16_melbourne\n" + ] + } + ], + "source": [ + "# Prepare device noise simulation (DNS)\n", + "\n", + "device = backend_real\n", + "print(\"device: \", device)\n", + "properties = device.properties()\n", + "coupling_map = device.configuration().coupling_map\n", + "prepared = False\n", + "if device.name() == 'ibmq_16_melbourne' :\n", + " gate_times = [\n", + " ('u1', None, 0), ('u2', None, 100), ('u3', None, 200),\n", + " ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),\n", + " ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),\n", + " ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),\n", + " ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),\n", + " ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773),\n", + " ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)\n", + " ]\n", + " prepared = True\n", + " \n", + "elif device.name() == 'ibmqx4' :\n", + " gate_times = [\n", + " ('u1', None, 0), ('u2', None, 60), ('u3', None, 120),\n", + " ('cx', [1, 0], 340), ('cx', [2, 0], 424), ('cx', [2, 1], 520),\n", + " ('cx', [3, 2], 620), ('cx', [3, 4], 420), ('cx', [4, 2], 920) \n", + " ]\n", + " prepared = True\n", + "\n", + "else :\n", + " print(\"No gate times yet defined in this notebook for: \", device)\n", + " \n", + "if prepared :\n", + " # Construct the noise model from backend properties and custom gate times\n", + " noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times)\n", + "\n", + " # Get the basis gates for the noise model\n", + " basis_gates = noise_model.basis_gates\n", + " \n", + " print(\"noise model prepared for\", device)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the algorithm using device noise simulation (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a02d100572e04c87b3878627bbd4ea4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 10/02/2019 10:18:47\n", + "{'0': 282, '1': 718}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute test using device noise simulation (DNS)\n", + "\n", + "backend_noise = Aer.get_backend('qasm_simulator') # for simulation (DNS)\n", + "\n", + "shots = 1000\n", + "mode = \"DNS\"\n", + "job_noise = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + "job_monitor(job_noise)\n", + "\n", + "print(job_noise.status)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "noisy_count = job_noise.result().get_counts(qprog) \n", + "print(noisy_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(noisy_count, color=['cyan'],\n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity in device noise simulation (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f59dbc091124a85ab97e057c39613ed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:51\n", + "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: DNS of ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.8969037947087841\n" + ] + } + ], + "source": [ + "# Execute state tomography using device noise simulation (DNS)\n", + "\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'. \n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "mode = \"DNS\"\n", + "my_state_job = execute(my_state_tomo_circuits, backend_tomo, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + "job_monitor(my_state_job)\n", + "my_state_tomo_result = my_state_job.result() \n", + "\n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, \"of\", device, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the algorithm on superconducting quantum computing device (SQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "55ddd53def4b48c588550d1a5dbdf1db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 10/02/2019 11:34:17\n", + "{'0': 309, '1': 715}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute test using superconducting quantum computing device (SQC)\n", + "\n", + "#Choose the backend\n", + "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", + "backend_SQC = device # for a real device\n", + "\n", + "# Execute on SQC and get counts\n", + "shots = 1000\n", + "if backend_SQC.name() == \"qasm_simulator\" : # optional test before final experiment \n", + " mode = \"DNS\"\n", + " job_real = execute(qprog, backend_SQC, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + "else: # final experiment on real device\n", + " mode = \"SQC\"\n", + " job_real = execute(qprog, backend_SQC)\n", + " job_monitor(job_real)\n", + "\n", + "print(job_real.status)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "real_count = job_real.result().get_counts(qprog) \n", + "print(real_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(real_count, color=['orange'], \n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity on superconducting quantum computing device (SQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "795f7379498d410c8f29c9757183ae9b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 07/02/2019 22:32:13\n", + "Tomography 1-qubit classifier on ibmq_16_melbourne , shots: 1000 , mode: SQC ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.8859731304253138\n" + ] + } + ], + "source": [ + "# Execute state tomography on superconducting quantum computing device (SQC)\n", + "mode = \"SQC\"\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "#Choose the backend\n", + "#backend_tomo = Aer.get_backend('qasm_simulator') # optional test before final experiment\n", + "backend_tomo = device # for real device\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "\n", + "# loop: 27 circuits maximum per job to avoid exceeding the allowed limit for the real device. \n", + "n_circ = 3**n\n", + "i_max = min(27,n_circ)\n", + "my_jobs = []\n", + "index_job = -1\n", + "for i in range(0,n_circ,i_max) :\n", + " circs =[]\n", + " for j in range(i, i+i_max):\n", + " circs.append(my_state_tomo_circuits[j])\n", + " if backend_tomo.name() == \"qasm_simulator\" : # optional test before final experiment\n", + " mode = \"DNS\"\n", + " my_state_job = execute(circs, backend_tomo, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + " else: # final experiment on real device\n", + " mode = \"SQC\" \n", + " my_state_job = execute(circs, backend_tomo, shots=shots)\n", + " my_jobs.append(my_state_job)\n", + " index_job = index_job + 1 \n", + " job_monitor(my_jobs[index_job], monitor_async = True)\n", + " \n", + " my_state_new_result = my_state_job.result()\n", + " if i == 0:\n", + " my_state_tomo_result = my_state_new_result\n", + " else:\n", + " my_state_tomo_result = my_state_tomo_result + my_state_new_result\n", + "\n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit classifier on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, device, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing NFS, DNS and SQC\n", + "The results mentioned above for the DNS and SQC experiments are illustrated together in the next graphs:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments on ibmqx4 using Qiskit 0.7." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "device_name = device.name()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# !!! Skip this cell if you want to see the results for a new run of the program\n", + "#Date (DMY): 07/02/2019\n", + "device_name = \"ibm_16_melbourne\"\n", + "noisefree_count = {'1': 721, '0': 279}\n", + "noisy_count = {'1': 711, '0': 289}\n", + "real_count = {'1': 695, '0': 305}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# NFS vs DSN vs SQC, count histograms\n", + "plot_histogram([noisefree_count, noisy_count, real_count], \n", + " title= str(n) + '- qubit QNN on ' + device_name,\n", + " color=['purple','cyan', 'orange'], bar_labels=True,\n", + " legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quantum Fidelity" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "names = ['NFS','DNS','SQC']\n", + "legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']\n", + "\n", + "fidelities = [0.999,0.897,0.886]\n", + "plt.ylabel('Quantum Fidelity')\n", + "plt.suptitle(str(n) + '- qubit QNN on {}, '.format(device.name()))\n", + "plt.axis([-0.5,2.5,0.75,1.01])\n", + "plt.grid()\n", + "plt.scatter(names, fidelities)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Several subroutines" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def obj_simple(angles, shots=1000, verbose=False):\n", + " \"\"\"Returns the number of zero outputs of a single training example.\"\"\"\n", + " # make the program\n", + " qprog = make_program([theta, phi], angles)\n", + " if verbose:\n", + " QASM_source = qprog.qasm()\n", + " print(QASM_source)\n", + " if mode == \"NFS\": \n", + " dist = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " dist = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " \n", + " dist_count = dist.result().get_counts(qprog)\n", + " observable = {'1' : 1}\n", + " obj = average_data(dist_count,observable)/shots \n", + " print(\"The current value of the objective function is:\", obj, end=\"\\r\")\n", + "\n", + " return obj" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def make_program(pangles, uangles): # to be modified if n>1!\n", + " \"\"\"Returns a program that prepares the state according\n", + " to pangles and applies the unitary according to uangles.\n", + " \"\"\"\n", + " new_state = QuantumCircuit(qr, cr)\n", + " # desired vector\n", + " desired_vector = [np.cos(pangles[0] / 2), np.exp(1j * pangles[1]) * np.sin(pangles[0] / 2)]\n", + " qr_vector = []\n", + "\n", + " # Initialize a 1-qubit quantum state using the arbitrary method \n", + " qr_vector.append(qr[0])\n", + " new_state.initialize(desired_vector, qr_vector)\n", + " \n", + " # write the program\n", + " qprogram = new_state + unitary(uangles) + measuring \n", + " \n", + " return qprogram" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def obj(uangles):\n", + " \"\"\"Returns the objective function C defined above over all training data.\n", + " \n", + " Args:\n", + " uangles [type: list]\n", + " the angles in the unitary evolution.\n", + "\n", + " rtype: int\n", + " \"\"\"\n", + " # grab some training data from the overall data set\n", + " tpoints = int(train_frac * len(qdata))\n", + " tdata = qdata[:tpoints]\n", + " tlabels = labels[:tpoints]\n", + "\n", + " \n", + " # initialize a variable to store the output predictions of the neural net\n", + " predictions = np.zeros_like(tlabels, dtype=int)\n", + " \n", + " # loop over all training data to get the predictions\n", + " for i, pangles in enumerate(tdata):\n", + " # write the program\n", + " qprog = make_program(pangles, uangles)\n", + " \n", + " # run the program\n", + " shots = 1000\n", + " \n", + " if mode == \"NFS\": \n", + " out = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " out = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " \n", + " out_count = out.result().get_counts(qprog)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " p1 = average_data(out_count,observable_1)\n", + " p0 = average_data(out_count,observable_0)\n", + " \n", + " # take the prediction to be max(p0, p1)\n", + " if p0 >= p1:\n", + " predictions[i] = 0\n", + " else:\n", + " predictions[i] = 1\n", + "\n", + "# uncomment next four lines for check \n", + "# if i == 0 :\n", + "# QASM_source = qprog.qasm()\n", + "# print(QASM_source)\n", + "# print(p0,p1)\n", + " \n", + " # compute the difference of the labels and return the cost\n", + " cost = sum(abs(predictions - tlabels)) / tpoints\n", + " print(\"The current value of the cost function is:\", cost, end=\"\\r\")\n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "def get_all_predictions(angles):\n", + " \"\"\"Returns a numpy array of all predictions.\"\"\"\n", + " # initialize a variable to store the output predictions of the neural net\n", + " zhats = np.zeros_like(labels, dtype=int)\n", + " \n", + " # loop over all data to get predictions\n", + " for i, pangles in enumerate(qdata):\n", + " # write the program\n", + " qprog = make_program(pangles, angles)\n", + " \n", + " # run the program\n", + " shots = 1000\n", + " \n", + " if mode == \"NFS\": \n", + " out = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " out = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " \n", + " out_count = out.result().get_counts(qprog)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " p1 = average_data(out_count,observable_1)\n", + " p0 = average_data(out_count,observable_0)\n", + " \n", + " # take the prediction to be max(p0, p1)\n", + " if p0 >= p1:\n", + " zhats[i] = 0\n", + " else:\n", + " zhats[i] = 1\n", + " return zhats" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 0.0060569999999999999\r" + ] + } + ], + "source": [ + "mode = \"NFS\"\n", + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(8.89515197858799) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(6.14308213587254) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(7.13449483997346) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 11:59:44\n", + "{'0': 999, '1': 1}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution\n", + "shots = 1000\n", + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "dist = execute(qprog, backend_sim, shots=shots)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, ' + mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training (NFS)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# fraction of total data to use as training data\n", + "train_frac = 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.9857142857142858\r" + ] + } + ], + "source": [ + "# get some random angles\n", + "angs = 2 * np.pi * np.random.rand(3)\n", + "cost = obj(angs)" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.014285714285714285\n", + "Total training runtime took 1.8455156366030374 minutes.\n" + ] + } + ], + "source": [ + "# train the quantum neural network and time how long it takes\n", + "start = time.time()\n", + "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", + "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "[3.321652 6.2743205 5.85861077]\n" + ] + } + ], + "source": [ + "# grab the optimal angles and minimal cost value\n", + "optimal_angles = out['x']\n", + "fval = out['fun']\n", + "\n", + "# print them out\n", + "print(fval)\n", + "print(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "# compute all the predictions of the quantum neural network\n", + "predictions = get_all_predictions(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Results of quantum neural network classification ===============\n", + "Out of 100 total data points:\n", + "The QNN was trained on 70.0% of the total data (70 training points).\n", + "The QNN classified 100 data points correctly (100.0% accuracy).\n", + "================================================================================\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# compute statistics of the QNN\n", + "ntrain = int(train_frac * npoints)\n", + "ncorrect = npoints - sum(abs(predictions - labels))\n", + "acc = ncorrect / npoints * 100\n", + "\n", + "# print them out\n", + "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", + "print(\"Out of {} total data points:\".format(npoints))\n", + "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", + "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", + "print(\"\".center(80, \"=\"))\n", + "\n", + "# plot the points, line y = x, and prediction\n", + "plt.plot(ys, xs, '--k')\n", + "for i in range(npoints):\n", + " if predictions[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + "\n", + "plt.grid()\n", + "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing on device noise simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# Testing on device noise simulator\n", + "mode = \"DNS\"" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 0.00011199999999999999\r" + ] + } + ], + "source": [ + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(-1.51785048443617) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(0.248786966568569) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(9.26351197606004) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 12:45:53\n", + "{'0': 904, '1': 96}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution (DNS)\n", + "mode = \"DNS\"\n", + "dist = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['cyan'], \n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "# fraction of total data to use as training data (DNS)\n", + "train_frac = 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 1.0\r" + ] + } + ], + "source": [ + "# get some random angles\n", + "angs = 2 * np.pi * np.random.rand(3)\n", + "cost = obj(angs)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.014285714285714285\n", + "Total training runtime took 6.603797650337219 minutes.\n" + ] + } + ], + "source": [ + "# train the quantum neural network and time how long it takes\n", + "start = time.time()\n", + "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", + "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "[3.47838504 6.18048312 3.49508897]\n" + ] + } + ], + "source": [ + "# grab the optimal angles and minimal cost value\n", + "optimal_angles = out['x']\n", + "fval = out['fun']\n", + "\n", + "# print them out\n", + "print(fval)\n", + "print(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "# compute all the predictions of the quantum neural network\n", + "predictions = get_all_predictions(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Results of quantum neural network classification ===============\n", + "Out of 100 total data points:\n", + "The QNN was trained on 70.0% of the total data (70 training points).\n", + "The QNN classified 99 data points correctly (99.0% accuracy).\n", + "================================================================================\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# compute statistics of the QNN # previous experiment\n", + "ntrain = int(train_frac * npoints)\n", + "ncorrect = npoints - sum(abs(predictions - labels))\n", + "acc = ncorrect / npoints * 100\n", + "\n", + "# print them out\n", + "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", + "print(\"Out of {} total data points:\".format(npoints))\n", + "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", + "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", + "print(\"\".center(80, \"=\"))\n", + "\n", + "# plot the points, line y = x, and prediction\n", + "plt.plot(ys, xs, '--k')\n", + "for i in range(npoints):\n", + " if predictions[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + "\n", + "plt.grid()\n", + "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References:\n", + "\n", + "[1] https://github.com/QuantumAI-lib/NISQAI/blob/master/examples/one-qubit-classifier/one-qubit-classifier.ipynb\n", + "\n", + "[2] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/community/terra/qis_adv/Multi-Qubit_W_States_with_Tomography.ipynb\n", + "\n", + "[3] Smolin, J. A., Gambetta, J. M. & Smith, G. (2012). Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Phys. Rev. Lett 108(7). https://link.aps.org/doi/10.1103/PhysRevLett.108.070502\n", + "\n", + "[4] Preskill, J. (2018) Quantum Computing in the NISQ era and beyond. Quantum 2, 79 (2018). https://arxiv.org/abs/1801.00862\n", + "\n", + "[5] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From eafc6871d960d34c735930b846d45e8d9d91251e Mon Sep 17 00:00:00 2001 From: Pierre Decoodt Date: Tue, 12 Feb 2019 08:39:19 +0100 Subject: [PATCH 4/5] Delete [WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb Make room for a version with more real device testing --- ... Simulation and Real Device Run Test.ipynb | 2131 ----------------- 1 file changed, 2131 deletions(-) delete mode 100644 examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb diff --git a/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb b/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb deleted file mode 100644 index 2c574e1..0000000 --- a/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb +++ /dev/null @@ -1,2131 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# NISQAI One-Qubit Quantum Neural Network Adapted for Qiskit\n", - "\n", - "\n", - "***\n", - "### Contributors\n", - "#### Add here the contributors:\n", - "Pierre Decoodt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Introduction\n", - "\n", - "This is a proof of concept for the assessment on Qiskit of a NISQAI classifier$^{[1]}$.\n", - "A one-qubit neural network is tested on Aer based noise free simulation (NFS) and device noise simulation (DNS), and also on real superconducting quantum calculating device (SQC).\n", - "\n", - "The protocol follows the steps described in a previous Qiskit tutorial $^{[2]}$ using quantum state tomography $^{[3]}$ for assessing fidelity.\n", - "\n", - "The last part consist of testing training and prediction by NFS and DNS.\n", - "\n", - "NB: I use the term SQC instead of NISQ because the original Preskill paper $^{[4]}$ specifies as \"NISQ\" quantum computers with 50-100 qubits." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\decpi\\Anaconda3\\envs\\q7env\\lib\\site-packages\\marshmallow\\schema.py:364: ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See https://marshmallow.readthedocs.io/en/latest/upgrading.html#schemas-are-always-strict\n", - " ChangedInMarshmallow3Warning\n" - ] - } - ], - "source": [ - "#Import packages\n", - "# NB running this cell induces a ChangedInMarshmallow3Warning for the moment. This warning can be safely ignored.\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline\n", - "import time\n", - "from scipy.optimize import minimize\n", - "\n", - "# import from qiskit\n", - "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, compile\n", - "from qiskit.converters import qobj_to_circuits\n", - "from qiskit import Aer, IBMQ\n", - "from qiskit.providers.aer import noise\n", - "\n", - "# import tomography library\n", - "import qiskit.tools.qcvv.tomography as tomo\n", - "\n", - "# useful additional packages \n", - "from qiskit.tools.visualization import plot_state, plot_histogram \n", - "from qiskit.tools.qi.qi import state_fidelity, outer\n", - "from qiskit.tools.qi.qi import outer\n", - "from qiskit.quantum_info import state_fidelity\n", - "from qiskit.tools.monitor import job_monitor, backend_overview\n", - "from qiskit.providers.ibmq import least_busy\n", - "from qiskit.quantum_info.analyzation.average import average_data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[,\n", - " ,\n", - " ]" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Aer.backends() # No need for credentials for running the next cells until next warning" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Data Encoding" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generating Data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# set random seed for reproducible results\n", - "SEED = 1059123109\n", - "np.random.seed(seed=SEED)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# generate data points distributed uniformly at random in [0, 1) x [0, 1)\n", - "npoints = 100\n", - "data = np.random.rand(npoints, 2)\n", - "\n", - "def predicate(point):\n", - " \"\"\"Returns true if the point satisfies the predicate, else false.\"\"\"\n", - " return True if point[0] <= 0.5 else False\n", - "\n", - "# separate the data with a linear boundary y = x\n", - "labels = np.array([1 if predicate(p) else 0 for p in data])\n", - "\n", - "# plot the line y = x\n", - "xs = np.linspace(0, 1, 100)\n", - "ys = 0.5 * np.ones_like(xs)\n", - "plt.plot(ys, xs, '--k')\n", - "\n", - "# plot the data with the color key BLUE = 0 = LEFT, GREEN = 1 = RIGHT\n", - "for i in range(npoints):\n", - " if labels[i] == 0:\n", - " ckey = 'g'\n", - " else:\n", - " ckey = 'b'\n", - " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", - " \n", - "# title and axis lables\n", - "plt.title(\"Random Data Points in Unit Square\", fontweight=\"bold\", fontsize=16)\n", - "\n", - "# put on a grid and show the plot\n", - "plt.grid()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Qubit Encoding" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# encode the classical data via a simple linear \"qubit encoding\"\n", - "qdata = np.zeros_like(data)\n", - "for (index, point) in enumerate(data):\n", - " qdata[index][0] = np.pi * point[0]\n", - " qdata[index][1] = 2 * np.pi * point[1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. State Preparation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "As explained is the NISQAI one-qubit classifier description$^{[1]}$, the one-qubit encoding is achieved by realizing the following initial state: \n", - " \n", - "$$|\\psi\\rangle = \\cos(\\frac {\\theta}{2}) |0\\rangle + e^{i \\phi} \\sin(\\frac {\\theta}{2})|1\\rangle $$\n", - "\n", - "\n", - "The unitary taking the $|0\\rangle$ to the above state is: \n", - "\n", - "$$\n", - "S(\\theta, \\phi) = \\begin{pmatrix}\n", - "\\cos(\\frac {\\theta}{2}) & e^{-i \\phi}\\sin(\\frac {\\theta}{2}) \\\\\n", - "e^{i \\phi} \\sin(\\frac {\\theta}{2}) & - \\cos(\\frac {\\theta}{2})\n", - "\\end{pmatrix}\n", - "$$\n", - "\n", - "\n", - "Such an operation is not currently directly available in Qiskit to our knowledge. We therefore use arbitrary initialization in order to encode the qubit $^{[5]}$.\n", - "\n", - "A check of the results of this arbitrary initialization follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3.122 5.969 0 vs 2 -- 8191 vs 8190\n", - "0.348 0.911 7946 vs 7946 -- 245 vs 246\n", - "1.652 4.618 3765 vs 3849 -- 4426 vs 4343\n", - "2.919 0.365 101 vs 94 -- 8090 vs 8098\n", - "2.582 1.018 623 vs 592 -- 7568 vs 7600\n", - "0.002 5.703 8191 vs 8192 -- 0 vs 0\n", - "2.986 5.712 49 vs 34 -- 8142 vs 8158\n", - "3.064 1.62 12 vs 15 -- 8179 vs 8177\n", - "1.516 0.87 4320 vs 4356 -- 3871 vs 3836\n", - "3.131 0.308 0 vs 0 -- 8191 vs 8192\n", - "2.118 0.197 1965 vs 1949 -- 6226 vs 6243\n" - ] - } - ], - "source": [ - "# Checking arbitrary initialization\n", - "n = 1\n", - "for i in range(5,56,5) : # modify here if wishe\n", - " # create a n-qubit quantum register\n", - " qrt = QuantumRegister(n)\n", - " crt = ClassicalRegister(n)\n", - " check_sta = QuantumCircuit(qrt,crt , name='check_sta')\n", - "\n", - " # pick an encoded data point\n", - " theta, phi = qdata[i]\n", - "\n", - " # desired vector\n", - " desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", - " qrt_vector = []\n", - "\n", - " # Initialize a 1-qubit quantum state using the arbitrary method \n", - " qrt_vector.append(qrt[0])\n", - " check_sta.initialize(desired_vector, qrt_vector)\n", - "\n", - " # Measurement circuit\n", - " measuring = QuantumCircuit(qrt,crt , name='measuring')\n", - " for i in range(n) :\n", - " measuring.measure(qrt[i] , crt[i])\n", - " test_check = check_sta+measuring\n", - "\n", - " # noise free simulation (NFS)\n", - " mode = \"NFS\"\n", - "\n", - " # test circuit \"check_sta\" : Noise free model on simulator\n", - " backend_sim = Aer.get_backend('qasm_simulator')\n", - " shots = 8192\n", - " job_noisefree = execute(test_check, backend_sim, shots=shots) \n", - " count = job_noisefree.result().get_counts(test_check)\n", - " \n", - " # get the output probabilities\n", - " observable_1 = {'1' : 1, '0' : 0}\n", - " observable_0 = {'0' : 1, '1' : 0}\n", - " fr_obs1 = int(average_data(count,observable_1)*8192)\n", - " fr_obs0 = int(average_data(count,observable_0)*8192)\n", - " \n", - " fr_theo0 = int(abs(np.cos(theta / 2)**2)*shots)\n", - " fr_theo1 = int(abs(np.exp(1j * phi) * np.sin(theta / 2)**2)*shots)\n", - " print(round(theta,3), round(phi,3),\" \", fr_theo0,\"vs\", fr_obs0,\"--\", fr_theo1,\"vs\", fr_obs1) " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Determine the job\n", - "n = 1\n", - "\n", - "# create a n-qubit quantum register\n", - "qr = QuantumRegister(n)\n", - "cr = ClassicalRegister(n)\n", - "initial_state = QuantumCircuit(qr, cr, name='initial_state')\n", - "\n", - "# pick a particular encoded data point\n", - "theta, phi = qdata[0]\n", - "\n", - "# desired vector\n", - "desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", - "qr_vector = []\n", - "\n", - "# Initialize a 1-qubit quantum state using the arbitrary method \n", - "qr_vector.append(qr[0])\n", - "initial_state.initialize(desired_vector, qr_vector)\n", - "\n", - "# Measurement circuit\n", - "measuring = QuantumCircuit(qr, cr, name='measuring')\n", - "for i in range(n) :\n", - " measuring.measure(qr[i] , cr[i])\n", - "test = initial_state+measuring" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test the arbitrary initialization of the state by noise free simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "# QASM from test\n", - "QASM_source = test.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "test.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3d413bbc8b5e4734bc695b0e41e45e43", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:17:59\n", - "{'0': 8, '1': 992}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# noise free simulation (NFS)\n", - "mode = \"NFS\"\n", - "\n", - "# Test circuit \"initial_state\" : Noise free model on simulator\n", - "backend_sim = Aer.get_backend('qasm_simulator')\n", - "shots = 1000\n", - "job_noisefree = execute(test, backend_sim, shots=shots)\n", - "job_monitor(job_noisefree)\n", - "\n", - "count = job_noisefree.result().get_counts(test)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(count, color=['purple'], \n", - " title=str(n) + '- qubit QNN, initial state, noise free simulation')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Unitary Evolution" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(angles):\n", - " \"\"\"Returns a circuit implementing the unitary Rz(theta0) P Rz(theta1) P Rz(theta2)\n", - " where thetea0 = angles[0], theta1 = angles[1], and theta2 = angles[2] and\n", - " P = Rx(pi / 2) is a pi / 2 pulse.\n", - " \"\"\"\n", - " \n", - " circuit = QuantumCircuit(qr, cr)\n", - " circuit.rz(angles[0], qr[0])\n", - " circuit.rx(np.pi / 2, qr[0]),\n", - " circuit.rz(angles[1], qr[0]),\n", - " circuit.rx(np.pi / 2, qr[0]),\n", - " circuit.rz(angles[2], qr[0])\n", - " \n", - " return circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(0.314283559730307) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(4.27779036629818) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(3.31959735414771) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "# test angles\n", - "angles = 2 * np.pi * np.random.rand(3)\n", - "my_state = initial_state + unitary(angles)\n", - "qprog = my_state + measuring\n", - "\n", - "# QASM\n", - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Test the circuit using a noise free simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:18:14\n", - "{'0': 252, '1': 748}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# noise free simulation (NFS)\n", - "mode = \"NFS\"\n", - "\n", - "# run the quantum neural network program\n", - "\n", - "shots = 1000\n", - "job_noisefree = execute(qprog, backend_sim, shots=shots)\n", - "\n", - "noisefree_count = job_noisefree.result().get_counts(qprog)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(noisefree_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(noisefree_count, color=['purple'], \n", - " title=str(n) + '- qubit QNN, ' + mode)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State tomography and quantum fidelity in noise free device simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "84c5beb68c774d79b3740bcbc5c00d32", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:18:18\n", - "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: NFS theta: 2.987977895799584 phi: 0.7898055544158503\n", - "Fidelity with theoretical ideal state\n", - "F = 0.999933478085305\n" - ] - } - ], - "source": [ - "# Execute state tomography using noise free quantum device simulation\n", - "mode = \"NFS\"\n", - "# obtain the final state vector\n", - "backend_stvct = Aer.get_backend('statevector_simulator')\n", - "job = execute(my_state, backend_stvct)\n", - "my_state_psi = job.result().get_statevector(my_state)\n", - "\n", - "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", - "qubit_set = []\n", - "for i in range(0,n) :\n", - " qubit_set.append(i)\n", - "\n", - "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", - "\n", - "# add the state tomography measurement circuits to the Quantum Program\n", - "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", - "\n", - "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", - "\n", - "# take 1024 shots for each measurement basis\n", - "# note: reduce this number for larger number of qubits\n", - "shots = 1000\n", - "\n", - "my_state_job = execute(my_state_tomo_circuits, backend_tomo, shots=shots)\n", - "job_monitor(my_state_job)\n", - "my_state_tomo_result = my_state_job.result() \n", - " \n", - "# extract tomography data from results\n", - "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", - "\n", - "# Quantum fidelity\n", - "\n", - "# reconstruct experimentally measured density matrix \n", - "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", - "\n", - "# calculate fidelity of fitted state:\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", - " \", shots:\", shots, \", mode:\", mode, \"theta:\", theta, 'phi:', phi)\n", - "F_fit = state_fidelity(rho_fit, my_state_psi)\n", - "print('Fidelity with theoretical ideal state')\n", - "print('F =', F_fit)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### From here, you need credentials:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "IBMQ.load_accounts()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ibmq_16_melbourne ibmqx4\n", - "----------------- ------\n", - "Num. Qubits: 14 Num. Qubits: 5\n", - "Pending Jobs: 65 Pending Jobs: 469\n", - "Least busy: True Least busy: False\n", - "Operational: True Operational: True\n", - "Avg. T1: 53.7 Avg. T1: 52.1\n", - "Avg. T2: 73.0 Avg. T2: 17.2\n", - "\n", - "\n", - "\n" - ] - } - ], - "source": [ - "backend_overview() # you may skip running this cell if you want" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ibmq_16_melbourne\n" - ] - } - ], - "source": [ - "# Make your choice of real device\n", - "#backend_real = least_busy(IBMQ.backends(operational=True, simulator=False))\n", - "#backend_real = IBMQ.get_backend('ibmqx4')\n", - "backend_real = IBMQ.get_backend('ibmq_16_melbourne')\n", - "print(backend_real)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare noise simulation corresponding to a given quantum device" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "device: ibmq_16_melbourne\n", - "noise model prepared for ibmq_16_melbourne\n" - ] - } - ], - "source": [ - "# Prepare device noise simulation (DNS)\n", - "\n", - "device = backend_real\n", - "print(\"device: \", device)\n", - "properties = device.properties()\n", - "coupling_map = device.configuration().coupling_map\n", - "prepared = False\n", - "if device.name() == 'ibmq_16_melbourne' :\n", - " gate_times = [\n", - " ('u1', None, 0), ('u2', None, 100), ('u3', None, 200),\n", - " ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),\n", - " ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),\n", - " ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),\n", - " ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),\n", - " ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773),\n", - " ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)\n", - " ]\n", - " prepared = True\n", - " \n", - "elif device.name() == 'ibmqx4' :\n", - " gate_times = [\n", - " ('u1', None, 0), ('u2', None, 60), ('u3', None, 120),\n", - " ('cx', [1, 0], 340), ('cx', [2, 0], 424), ('cx', [2, 1], 520),\n", - " ('cx', [3, 2], 620), ('cx', [3, 4], 420), ('cx', [4, 2], 920) \n", - " ]\n", - " prepared = True\n", - "\n", - "else :\n", - " print(\"No gate times yet defined in this notebook for: \", device)\n", - " \n", - "if prepared :\n", - " # Construct the noise model from backend properties and custom gate times\n", - " noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times)\n", - "\n", - " # Get the basis gates for the noise model\n", - " basis_gates = noise_model.basis_gates\n", - " \n", - " print(\"noise model prepared for\", device)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the algorithm using device noise simulation (DNS)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a02d100572e04c87b3878627bbd4ea4a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">\n", - "Date (DMY): 10/02/2019 10:18:47\n", - "{'0': 282, '1': 718}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute test using device noise simulation (DNS)\n", - "\n", - "backend_noise = Aer.get_backend('qasm_simulator') # for simulation (DNS)\n", - "\n", - "shots = 1000\n", - "mode = \"DNS\"\n", - "job_noise = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - "job_monitor(job_noise)\n", - "\n", - "print(job_noise.status)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "noisy_count = job_noise.result().get_counts(qprog) \n", - "print(noisy_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(noisy_count, color=['cyan'],\n", - " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State tomography and quantum fidelity in device noise simulation (DNS)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2f59dbc091124a85ab97e057c39613ed", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job has successfully run

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 10:18:51\n", - "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: DNS of ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", - "Fidelity with theoretical ideal state\n", - "F = 0.8969037947087841\n" - ] - } - ], - "source": [ - "# Execute state tomography using device noise simulation (DNS)\n", - "\n", - "# obtain the final state vector\n", - "backend_stvct = Aer.get_backend('statevector_simulator')\n", - "job = execute(my_state, backend_stvct)\n", - "my_state_psi = job.result().get_statevector(my_state)\n", - "\n", - "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", - "qubit_set = []\n", - "for i in range(0,n) :\n", - " qubit_set.append(i)\n", - "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'. \n", - "\n", - "# add the state tomography measurement circuits to the Quantum Program\n", - "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", - "\n", - "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", - "\n", - "# take 1024 shots for each measurement basis\n", - "# note: reduce this number for larger number of qubits\n", - "shots = 1000\n", - "mode = \"DNS\"\n", - "my_state_job = execute(my_state_tomo_circuits, backend_tomo, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates)\n", - "job_monitor(my_state_job)\n", - "my_state_tomo_result = my_state_job.result() \n", - "\n", - "# extract tomography data from results\n", - "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", - "\n", - "# Quantum fidelity\n", - "\n", - "# reconstruct experimentally measured density matrix \n", - "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", - "\n", - "# calculate fidelity of fitted state:\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", - " \", shots:\", shots, \", mode:\", mode, \"of\", device, \"theta:\", theta, 'phi:', phi)\n", - "F_fit = state_fidelity(rho_fit, my_state_psi)\n", - "print('Fidelity with theoretical ideal state')\n", - "print('F =', F_fit)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run the algorithm on superconducting quantum computing device (SQC)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "55ddd53def4b48c588550d1a5dbdf1db", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job is being initialized

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - ">\n", - "Date (DMY): 10/02/2019 11:34:17\n", - "{'0': 309, '1': 715}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Execute test using superconducting quantum computing device (SQC)\n", - "\n", - "#Choose the backend\n", - "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", - "backend_SQC = device # for a real device\n", - "\n", - "# Execute on SQC and get counts\n", - "shots = 1000\n", - "if backend_SQC.name() == \"qasm_simulator\" : # optional test before final experiment \n", - " mode = \"DNS\"\n", - " job_real = execute(qprog, backend_SQC, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates)\n", - "else: # final experiment on real device\n", - " mode = \"SQC\"\n", - " job_real = execute(qprog, backend_SQC)\n", - " job_monitor(job_real)\n", - "\n", - "print(job_real.status)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "real_count = job_real.result().get_counts(qprog) \n", - "print(real_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(real_count, color=['orange'], \n", - " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### State tomography and quantum fidelity on superconducting quantum computing device (SQC)" - ] - }, - { - "cell_type": "code", - "execution_count": 219, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "795f7379498d410c8f29c9757183ae9b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HTML(value=\"

Job Status: job is being initialized

\")" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 07/02/2019 22:32:13\n", - "Tomography 1-qubit classifier on ibmq_16_melbourne , shots: 1000 , mode: SQC ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", - "Fidelity with theoretical ideal state\n", - "F = 0.8859731304253138\n" - ] - } - ], - "source": [ - "# Execute state tomography on superconducting quantum computing device (SQC)\n", - "mode = \"SQC\"\n", - "# obtain the final state vector\n", - "backend_stvct = Aer.get_backend('statevector_simulator')\n", - "job = execute(my_state, backend_stvct)\n", - "my_state_psi = job.result().get_statevector(my_state)\n", - "\n", - "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", - "qubit_set = []\n", - "for i in range(0,n) :\n", - " qubit_set.append(i)\n", - "\n", - "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", - "\n", - "# add the state tomography measurement circuits to the Quantum Program\n", - "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", - "\n", - "#Choose the backend\n", - "#backend_tomo = Aer.get_backend('qasm_simulator') # optional test before final experiment\n", - "backend_tomo = device # for real device\n", - "\n", - "# take 1024 shots for each measurement basis\n", - "# note: reduce this number for larger number of qubits\n", - "shots = 1000\n", - "\n", - "# loop: 27 circuits maximum per job to avoid exceeding the allowed limit for the real device. \n", - "n_circ = 3**n\n", - "i_max = min(27,n_circ)\n", - "my_jobs = []\n", - "index_job = -1\n", - "for i in range(0,n_circ,i_max) :\n", - " circs =[]\n", - " for j in range(i, i+i_max):\n", - " circs.append(my_state_tomo_circuits[j])\n", - " if backend_tomo.name() == \"qasm_simulator\" : # optional test before final experiment\n", - " mode = \"DNS\"\n", - " my_state_job = execute(circs, backend_tomo, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates)\n", - " else: # final experiment on real device\n", - " mode = \"SQC\" \n", - " my_state_job = execute(circs, backend_tomo, shots=shots)\n", - " my_jobs.append(my_state_job)\n", - " index_job = index_job + 1 \n", - " job_monitor(my_jobs[index_job], monitor_async = True)\n", - " \n", - " my_state_new_result = my_state_job.result()\n", - " if i == 0:\n", - " my_state_tomo_result = my_state_new_result\n", - " else:\n", - " my_state_tomo_result = my_state_tomo_result + my_state_new_result\n", - "\n", - "# extract tomography data from results\n", - "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", - "\n", - "# Quantum fidelity\n", - "\n", - "# reconstruct experimentally measured density matrix \n", - "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", - "\n", - "# calculate fidelity of fitted state:\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print('Tomography',str(n)+'-qubit classifier on', backend_tomo,\n", - " \", shots:\", shots, \", mode:\", mode, device, \"theta:\", theta, 'phi:', phi)\n", - "F_fit = state_fidelity(rho_fit, my_state_psi)\n", - "print('Fidelity with theoretical ideal state')\n", - "print('F =', F_fit)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Comparing NFS, DNS and SQC\n", - "The results mentioned above for the DNS and SQC experiments are illustrated together in the next graphs:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments on ibmqx4 using Qiskit 0.7." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "device_name = device.name()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "# !!! Skip this cell if you want to see the results for a new run of the program\n", - "#Date (DMY): 07/02/2019\n", - "device_name = \"ibm_16_melbourne\"\n", - "noisefree_count = {'1': 721, '0': 279}\n", - "noisy_count = {'1': 711, '0': 289}\n", - "real_count = {'1': 695, '0': 305}" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# NFS vs DSN vs SQC, count histograms\n", - "plot_histogram([noisefree_count, noisy_count, real_count], \n", - " title= str(n) + '- qubit QNN on ' + device_name,\n", - " color=['purple','cyan', 'orange'], bar_labels=True,\n", - " legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']) " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Quantum Fidelity" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "names = ['NFS','DNS','SQC']\n", - "legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']\n", - "\n", - "fidelities = [0.999,0.897,0.886]\n", - "plt.ylabel('Quantum Fidelity')\n", - "plt.suptitle(str(n) + '- qubit QNN on {}, '.format(device.name()))\n", - "plt.axis([-0.5,2.5,0.75,1.01])\n", - "plt.grid()\n", - "plt.scatter(names, fidelities)\n", - " \n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Several subroutines" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "def obj_simple(angles, shots=1000, verbose=False):\n", - " \"\"\"Returns the number of zero outputs of a single training example.\"\"\"\n", - " # make the program\n", - " qprog = make_program([theta, phi], angles)\n", - " if verbose:\n", - " QASM_source = qprog.qasm()\n", - " print(QASM_source)\n", - " if mode == \"NFS\": \n", - " dist = execute(qprog, backend_sim, shots=shots)\n", - " elif mode == \"DNS\":\n", - " dist = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - " \n", - " dist_count = dist.result().get_counts(qprog)\n", - " observable = {'1' : 1}\n", - " obj = average_data(dist_count,observable)/shots \n", - " print(\"The current value of the objective function is:\", obj, end=\"\\r\")\n", - "\n", - " return obj" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "def make_program(pangles, uangles): # to be modified if n>1!\n", - " \"\"\"Returns a program that prepares the state according\n", - " to pangles and applies the unitary according to uangles.\n", - " \"\"\"\n", - " new_state = QuantumCircuit(qr, cr)\n", - " # desired vector\n", - " desired_vector = [np.cos(pangles[0] / 2), np.exp(1j * pangles[1]) * np.sin(pangles[0] / 2)]\n", - " qr_vector = []\n", - "\n", - " # Initialize a 1-qubit quantum state using the arbitrary method \n", - " qr_vector.append(qr[0])\n", - " new_state.initialize(desired_vector, qr_vector)\n", - " \n", - " # write the program\n", - " qprogram = new_state + unitary(uangles) + measuring \n", - " \n", - " return qprogram" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "def obj(uangles):\n", - " \"\"\"Returns the objective function C defined above over all training data.\n", - " \n", - " Args:\n", - " uangles [type: list]\n", - " the angles in the unitary evolution.\n", - "\n", - " rtype: int\n", - " \"\"\"\n", - " # grab some training data from the overall data set\n", - " tpoints = int(train_frac * len(qdata))\n", - " tdata = qdata[:tpoints]\n", - " tlabels = labels[:tpoints]\n", - "\n", - " \n", - " # initialize a variable to store the output predictions of the neural net\n", - " predictions = np.zeros_like(tlabels, dtype=int)\n", - " \n", - " # loop over all training data to get the predictions\n", - " for i, pangles in enumerate(tdata):\n", - " # write the program\n", - " qprog = make_program(pangles, uangles)\n", - " \n", - " # run the program\n", - " shots = 1000\n", - " \n", - " if mode == \"NFS\": \n", - " out = execute(qprog, backend_sim, shots=shots)\n", - " elif mode == \"DNS\":\n", - " out = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - " \n", - " out_count = out.result().get_counts(qprog)\n", - " \n", - " # get the output probabilities\n", - " observable_1 = {'1' : 1, '0' : 0}\n", - " observable_0 = {'0' : 1, '1' : 0}\n", - " p1 = average_data(out_count,observable_1)\n", - " p0 = average_data(out_count,observable_0)\n", - " \n", - " # take the prediction to be max(p0, p1)\n", - " if p0 >= p1:\n", - " predictions[i] = 0\n", - " else:\n", - " predictions[i] = 1\n", - "\n", - "# uncomment next four lines for check \n", - "# if i == 0 :\n", - "# QASM_source = qprog.qasm()\n", - "# print(QASM_source)\n", - "# print(p0,p1)\n", - " \n", - " # compute the difference of the labels and return the cost\n", - " cost = sum(abs(predictions - tlabels)) / tpoints\n", - " print(\"The current value of the cost function is:\", cost, end=\"\\r\")\n", - " return cost" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "def get_all_predictions(angles):\n", - " \"\"\"Returns a numpy array of all predictions.\"\"\"\n", - " # initialize a variable to store the output predictions of the neural net\n", - " zhats = np.zeros_like(labels, dtype=int)\n", - " \n", - " # loop over all data to get predictions\n", - " for i, pangles in enumerate(qdata):\n", - " # write the program\n", - " qprog = make_program(pangles, angles)\n", - " \n", - " # run the program\n", - " shots = 1000\n", - " \n", - " if mode == \"NFS\": \n", - " out = execute(qprog, backend_sim, shots=shots)\n", - " elif mode == \"DNS\":\n", - " out = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - " \n", - " out_count = out.result().get_counts(qprog)\n", - " \n", - " # get the output probabilities\n", - " observable_1 = {'1' : 1, '0' : 0}\n", - " observable_0 = {'0' : 1, '1' : 0}\n", - " p1 = average_data(out_count,observable_1)\n", - " p0 = average_data(out_count,observable_0)\n", - " \n", - " # take the prediction to be max(p0, p1)\n", - " if p0 >= p1:\n", - " zhats[i] = 0\n", - " else:\n", - " zhats[i] = 1\n", - " return zhats" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(0.314283559730307) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(4.27779036629818) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(3.31959735414771) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "qprog = make_program([theta, phi], angles)\n", - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAB2CAYAAAC6afsyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAGU9JREFUeJzt3XtQVOf9BvCHm4CBXUAsKBcjajSiSBDkEpBFKUsCSpQaq8aoraOJ1Rg1Dmh6SzoaNNGaONMYKq23oMYYg1G7WhGIKFIIKkJao4OIkERKA6IYENbz+4Nhf64gu+DuHk7O85lxZjmXfZ99Pct+Oe8571oJgiCAiIiIZMla7ABEREQkHhYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEqFe+/fZbBAUFwcHBAW1tbWLHMUphYSEiIiIQFRWFFStWiB3HaGVlZbrcCxYsgJTu+N28eTMiIyPFjmGUyspKeHh4QKVSIS4uTuw4PbJr1y5MnjwZKpUKNTU1YscxSKPRQKVSQaVSYdCgQfj888/FjmSUu3fvIiEhASqVCklJSWhpaRE7kkmwEKBecXNzQ3Z2NsLCwsSOYrQhQ4bg1KlTOH36NGpra3Hp0iWxIxll5MiROHv2LE6fPg0AKC4uFjmRcVpaWnDx4kWxY/TIz3/+c+Tm5uLEiRNiRzFaTU0N8vLykJ2djdzcXHh5eYkdyaD4+Hjk5uYiNzcXvr6+iI2NFTuSUTQaDUJDQ5Gbm4sJEyZAo9GIHckkWAhQrzg4OMDV1VXsGD3i6ekJBwcHAICtrS1sbGxETmQcOzs73WN7e3v4+PiImMZ427dvx7x588SO0SM5OTmIiorCn//8Z7GjGO348ePQarWYPHkyli1bBq1WK3Yko1VUVMDDwwNOTk5iRzHKsGHDdGcBGhoaMGDAAJETmQYLAZKd0tJS1NXVYfTo0WJHMdrhw4cxZswY1NbWSuKXT2trK/Ly8jBp0iSxoxht0KBB+Oabb5CTk4OTJ0+itLRU7EhGuXnzJu7du4fs7Gz0798fWVlZYkcy2meffYZp06aJHcNoI0aMQGFhIfz9/VFcXIyIiAixI5kECwGSlR9++AFLly5FRkaG2FF6ZOrUqSgrK4OXlxeOHDkidhyDdu/ejdmzZ4sdo0fs7e3xxBNPwNbWFomJiSgrKxM7klGUSiWio6MBAJMmTcK///1vkRMZ74svvsDUqVPFjmG0nTt3Qq1Wo7y8HAkJCdizZ4/YkUyChQDJRltbG1566SW8++678PT0FDuO0R68IEmhUMDR0VHENMa5fPkyPvzwQ8THx6O8vBxbt24VO5JBt2/f1j0+c+YMhg0bJmIa40VEROjOXly4cAFDhw4VOZFxvv/+e/Tr108SZ7g6CIIANzc3AIC7uztu3bolciLTsOKXDlFvtLa24rnnnsNXX32FoKAgrF+/HqGhoWLH6tbevXvx2muvwd/fHwDwzjvvIDw8XORUhmVlZWHz5s0A2k9Npqenw9paOjV8ZGQk8vPzxY5h0LFjx/C73/0O9vb2iIyMxMaNG8WOZLQ33ngDxcXFcHd3R2ZmJvr16yd2JIM++ugjtLa2YunSpWJHMVpDQwNmzpyJlpYW2NnZYf/+/brCQMpYCBAREcmYdP6sICIiIpNjIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDLGQoCIiEjGWAgQERHJGAsBIiIiGWMhQEREJGMsBIiIiGSMhQAREZGM2YodgMT1+uuv48KFCxZvNzAwEFu2bOnVvmJlBqSZW4qZAWnmlmJmoPe5pZgZkObxYU48IyBzFy5csPgb4nHbFCOzKdplX1uuXfa1ZdqVYmZT7C+VNo3FMwKEwMBA5ObmWqw9lUr12M9h6cyANHNLMTMgzdxSzAw8fm4pZgakeXyYC88IEBERyRgLASIiIhljIUBERCRjLATIKIMHD4ajoyOcnJygVCoRHx+PGzduiB3LICnmlmJmQJq5pZgZkGZuKWaWCxYCZFBNTQ2+++47lJSU4M6dO6ioqEBtbS1SU1PFjtYtKeaWYmZAmrmlmBmQZm4pZpYTFgJkUFFRERQKBUaNGgUAGDBgAIKCgnDz5k2Rk3VPirmlmBmQZm4pZgakmVuKmbsiCAJaWlqg1WoNbnvnzh3U1dVZINXjYyFABhUVFSEkJARWVlZoa2uDRqPB/v37MXv2bLGjdUuKuaWYGZBmbilmBqSZW4qZO1y6dAkrVqxAWFgYHB0d4eDgAFtbW/j5+eHFF1/Evn37cO/ePb197ty5g4SEBMTFxaGtrU2k5MaTzTwCO3bswI4dO3p03+j48ePxzjvvIC4uznzBJKCoqAj5+flwcXHBnTt30L9/f2RkZODFF18UO1q3pJhbipkBaeaWYmZAmrmlmPnq1at49dVXcfLkSdjb2yMsLAxLliyBu7s7Wlpa8PXXX6OgoAAHDhyAh4cH0tLSMG/ePDQ1NSEhIQH5+fnIzMyErW3f/5gV5YzAvn37EBUVBYVC0WUnGVpvClqtFqtXr8bAgQPh7OyM5OTkTqdxkpKSkJWVZZb2paS4uBh79+5FQ0MDbty4AW9vb/znP/8RO5ZBUswtxcyANHNLMTMgzdxSy7xz504EBASgqKgIGzduRE1NDXJzc7F582asXbsWb731Fg4cOIDr169Do9Fg+PDhWLBgAZ5//nnEx8frioCZM2eK/VKMIkoh4OrqiiVLljxyzmVD600hLS0NWVlZKCwsRHV1NQBg7ty5etskJSXh8OHDZssgBVevXkV9fT2CgoIAAIMGDcKqVauwbds23L9/HwCQn5+PX/3qV7p9Zs6cia+++kqUvB2Myd3W1obJkydDpVJh3LhxGD9+vJiRJZkZMC73/fv3ERYWhsrKSlRXV2PixIm6911fzcy+tlzmvtTX27Ztw/z58xEeHo7y8nKsXr0aAwYM6HJba2trqNVqfPnll0hLS4NGo8GZM2fwt7/9TTJFAGDGQuCTTz7B2LFj4eTkhLi4OKxcuRIzZswAAKjVasyaNQt+fn5d7mtovSmkp6cjJSUFfn5+UCqV2LhxIzQaDSorK3XbjBs3Dra2tqJ/qImpqKgIbm5uGDJkiG5ZUlISbt68ifz8fABAcHAwzp8/DwDIycmBUqkU/ZemMbltbW2RnZ2NzMxM+Pn54dChQ2LFBSDNzIBxua2trbF+/XqsXLkSc+fORUZGBry9vcWKzL62ICn1dUFBAZYsWYKEhAT84x//gJeXl1H73b17F8eOHYO1tTWsrKxw6tQpMyc1LbMUAjt37sSqVavwl7/8Bbdu3UJiYiI++OADPPPMM+ZoDmlpaQgICDB6+1u3bqGqqkrvw2rYsGFQKBQoLS3V23bq1KmyHh4oKirq9P/m7u6OiIgIfPrppwAABwcHODg4oL6+Hn/4wx+wbt06MaLqMSY3AFy7dg1Lly7FRx99BF9fX0vH1CPFzIDxuceNG4fc3FwsWrQII0aMsHRMPexry5FKXzc3N2PBggXw8fFBZmYm+vXrZ9R+HRcGdgwHvPnmm9i1axeOHDli5sQmJJhYU1OT4ObmJhw7dkxvGQC9ZYIgCDk5OYKNjc0jn8vQ+p74+9//LkRHRwuCIAhVVVUCAKGiokJvG19fX2H37t16y44fPy4EBQWZJENfFB0dreuXx7F8+XIhOTlZ2LJli9nbNFXm8vJyITk5Waivr7dIu6bILcXMgiAIt2/fFmJjY4Vdu3YJkyZNMnu77GvL9PVP6b24Y8cOAYBw9OhRo5/n9u3bwsSJEwVra2th3759giAIQnNzszBixAghJCTEpJnNyeSFwLFjxwQXFxe9ZZWVlQIA4bvvvtNbLlYhUF9fLwAQzp8/r7eNQqEQsrKy9Jalp6cLL7zwgkkydAeAaP9McXDu3btXGD16tNDa2mpw2+jo6D6R2cvLSwgODta9QRsaGvp8bilmbm5uFp5//nkhLy9PEARBePnll4XDhw/3+dzsa3m9FydMmCA8/fTTwv37943K3FUR0GHr1q0CAKGoqMikmR/nX3dMfkl+bW0tfvazn+kty8zMhKenJzw9PU3dXK+4uLjA19cXJSUlCAwMBABUVFSgsbGx0xDD4cOHkZycbPZMgiCYvY2umOqrMfPz8/HBBx8YfZdHdHR0r78C1FSZe3MBldi5pZjZ3t4eR48e1f28c+dOo/YTOzf72rCfynuxoaEB//rXv/CnP/0JVlZWBvd/eDjg4QsDZ8+ejWXLluGf//wngoODTZLZnEx+jYC/vz+uXr2KvLw83Lt3D5mZmUhLS9N94ALtt+41NzfrJmFobm5Gc3Oz7sPQ0HpTWLRoETZs2IBr166hsbERKSkpUKvVePLJJ3Xb3L17Fzk5OUhMTDRZuz811dXVSEpKglKpxOTJk8WOQ0TUYyUlJQCAkJAQg9saKgIAwM3NDcOHD5fMheYmLwSCg4Px5ptvYvr06fD29kZhYSFCQ0P1LhbZvXs3HB0doVarodVq4ejoCEdHR1y/ft2o9Q9bv349/P39e5QzNTUVU6ZMQUhICLy8vKDVarFnzx69bY4fP45nnnkG7u7uPewF+fD29kZWVlafuECQiKg3ampqALRfNN4dY4qADn5+fqLettkTZrlr4O2338b//vc/1NbW4v3338c333yjVwjMnz8fQvv1CXr/Ov4aN7T+YWvXrkV5eXmPMtrY2OC9995DXV0dbt++jc8++6zTB/7hw4eRlJTUo+clIiJpmTVrFhoaGjB06NBut/vxxx/R2Nho1GRBBw8eRE5Ojiljmo3ZJxRqbGzE9evXzXbroDkNGTJEN/eBHBUWFiIiIgJRUVFYsWKF3roLFy7g2WefRVRUFE6fPg0AqKqqwqRJkzBx4kR88sknYkTWWbFiBaKiorB8+XK95b/85S+hUqkQHh6uG67q6rWI4VGZly9fjujoaISGhuLMmTMAgHXr1mHw4MH47W9/K0ZUnW+//RZBQUFwcHDoNKf6/PnzERoaCpVKhczMTADA66+/DpVKBZVKBVdXVzEi62zevBmRkZF6yxYvXoxnn30WkZGRuluJ8/LyEBoairCwMGzbtk2MqACk2ddlZWW63yELFizQG97t6rjuqv8twdbWFkqlEjY2Nt1uN3DgQBQVFRk1WZCTkxMcHR1NFdGszD4JcllZGZydnQ2ecjG3wMBAzJ8/v0f7/PGPfzRLFqkYMmQITp06BQcHB8yZMweXLl3C2LFjAQC///3vsX//fri5uWH69OnQaDTYsGED1q1bhwkTJuC5557D9OnTRZlnu6SkBE1NTTh9+jReffVV3ReeAO3TVwPAoUOHdON3Xb2WvpT5vffeg52dHa5fv44lS5bg6NGjWLhwISIiIpCdnW3xrA9yc3NDdnY2pk2b1uX6jz/+GMOHD9f93DFb6Pnz57Fp0yaLZOxKS0sLLl682Gl5amoqhg4diitXriA1NRUHDx7Epk2bcODAAXh7eyM8PByvvPKKCIml2dcjR47E2bNnAQALFixAcXFxt8d1V/3f10jhuwN6yuxnBCIiItDY2GjUlZjm1JtCQO48PT3h4OAAoP3gf7Barq+vh7e3N/r374+mpib8+OOPqKioQEBAAGxsbODh4YGrV6+KkrugoACxsbEAgNjYWJw7d67TNocOHcL06dMBdP1aLK27zHZ2dgDaxyfHjRsHAPDw8BD9PQW0Tyb1qL82rays8PLLL2PKlCmdru95sP/FsH37dsybN6/T8o5Tw3Z2drrj3d/fH7du3UJLSwueeOIJi+Z8kBT7uuPYBdrvaPDx8em07sHjuqv+J/Pj1xCTQaWlpairq8Po0aN1ywYOHIiysjL897//RVlZGRoaGjBy5Ejk5eXh7t27OHfuHOrr60XJ29DQAIVCAQBQKpWdcrS1teHSpUu6uc+7ei19LfO0adMQFxenKxakYNOmTTh79ixSUlKwatUqvXUajQbx8fGi5GptbUVeXh4mTZr0yG3WrFmD1157DQDwwgsvIDExEaNGjcKcOXMsFbNH+mpfA+3XWo0ZMwa1tbWd5ux/1HH9YP+T+bEQoG798MMPWLp0KTIyMvSWp6WlYeXKlXjllVcQEBAAd3d3rFmzBunp6ZgxYwZGjRoFDw8PUTK7uLigsbERQPs1Ki4uLnrrc3Jy9O4j7uq1WJqhzIcOHcK5c+ewdu1ai2frLTc3NwBAZGQkvv/+e93yK1euwMvLC/379xcl1+7duzF79uxHrt+yZQtGjx6tu35g9erVyM/Px5UrV7Br1y7cvXvXUlGN1lf7Gmifpr2srAxeXl6dpt3t6rh+uP/J/FgI0CO1tbXhpZdewrvvvttpMqinnnoKJ06c0M0LbmdnBw8PD3z++ef49NNPYW9vb/AKXHMJDw/XjZ2fPHkSYWFheusPHTqkN87a1WuxtO4yt7S0AACcnZ1FPTXdUx2FzeXLl/UKm4f739IuX76MDz/8EPHx8SgvL8fWrVt1606cOIGzZ8/qXYRpY2MDFxcX9OvXD9bW1mhtbRUjdrf6al93HLsAoFAo9C6e6+q47qr/yfxYCNAjHThwAEVFRUhJSYFKpUJBQQGWLVsGAMjIyEBMTAzmzZuHt99+GwBw9OhRxMTEYMqUKVizZo1oY9gdV1ZHRUXB2toavr6+unkOBEFAQUGB3l8bXb2WvpR55syZun596623dJlXrVqFjz/+GL/5zW9EyQy0n2aPjY3FxYsXoVarkZeXp8s9Z84cREZGYuHChUhLS9Ptc+TIEUyZMkWsyNiwYQOOHz8OjUYDf39/zJgxQ5d52bJluHbtGmJiYrB48WIAQEpKCmJjYxEeHo6YmBgolUpRckuxrzUaDaKjoxEdHY2bN28iICCg2+O6q/4n87MSxJrblvqEjlPklpz28nHbFCOzKdplX1uuXfa1ZdqVYmZT7C+VNo3107sPgnrswoULJpsz3Nj2HpxyurfPYcnMHW1KLbcUM3e0KbXcUszc0ebj5JZi5o7nkNrxYS4sBGROjAMzMDDwsdoV680kxdxSzNzRrtRySzFzR7u9bVuKmTv2742Kqu/g5zuo02Nj2+yrhQCHBoiIiIyQuiEdaSmLOj2WOl4sSEREJGMsBIiIiGSMhQAREZGMsRAgIiKSMRYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYyxECAiIpIxFgJEREQyxkKAiIhIxlgIEBERyRgLASIiIjPLzc2Fv78/hg8fjoULF0Kr1YodSYeFABERkRndv38fCxcuxIEDB3D16lU0NjZiz549YsfSYSFARERkRkVFRRg8eDBGjx4NAPj1r3+NgwcPipzq/9mKHYCIiKivaW1tQ2XN952WX6ms7vKxq8IZ7m7KLp+ruroaPj4+up99fX1x48YNE6Z9PCwEiIiIHmJra4PsMyWorNYvBjL2H+v02ArA0vnTH/lcgiDAyspK7+e+hEMDRERED7GyskLi5HBYGd4UwQGj4OXh/sj1Pj4+qKqq0v1848YNeHt7myClabAQICIi6oK350AEjXmq223s+9khbmJwt9sEBwejpqYGX3/9NQAgIyMD06c/+gyCpbEQICIiegT1xBD0s3v0KHpM+DNwfqJ/t89hY2ODv/71r/jFL36BYcOGwcnJCXPnzjV11F6zEvraYAUREVEfklNwHse/LOq03E3pjBULZ8DOVtqX2/GMABERUTcig8fCReHUaflzMaGSLwKAPlQI7Nu3D1FRUVAoFLDtomMNrTcFrVaL1atXY+DAgXB2dkZycjLq6urM0hYREUmDnZ0tnleF6i0b6jMIY54aKlIi0+ozhYCrqyuWLFmCLVu29Gq9KaSlpSErKwuFhYWorm6/P7QvjeMQEZE4xo7yw5PengDabxdMnByud0uglFm8EDhz5gzUajU8PDzg4uKCGTNmAADUajVmzZoFPz+/LvcztN4U0tPTkZKSAj8/PyiVSmzcuBEajQaVlZVma5OIiPq+B28nHB8wstvbBaXGooMbBw8exKJFi5Ceno7ExETcu3cPZ8+eNUtbaWlpyMzMRGlpqVHb37p1C1VVVRg/frxu2bBhw6BQKFBaWoonn3zSLDk7pG5IN+vzExGRaRSXXkZx6WWxY/RIWsqiR66zWCHQ1NSExYsX4/3330dycjIAwN7eHmq12iztpaamIjU11ejtGxsbAQBKpf4UkS4uLrp15tTdfxIREfUND88S+FNgsaGBvLw8WFlZYc6cOZZqskecnZ0BtJ8ZeFBDQwMUCoUYkYiIqI/5qRUBgAXPCNTV1cHV1bXPdqKLiwt8fX1RUlKCwMBAAEBFRQUaGxsREBBg9vY5NEBERObSJ4YGxo8fj2vXruGLL75AQkICGhsbUVhYqBsa0Gq1aG1txb179wAAzc3NANqHD6ysrAyuN4VFixZhw4YNiImJwYABA5CSkgK1Wm326wMADg0QEZE4LDY04O/vj+3bt+ONN96AQqHA008/jS+//FK3fvfu3XB0dIRarYZWq4WjoyMcHR1x/fp1o9Y/bP369fD39+9RxtTUVEyZMgUhISHw8vKCVqvFnj17ev+iiYiI+jhOMUxERCRjfWZCISIiIrI8FgJEREQyxkKAiIhIxlgIEBERyRgLASIiIhljIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDLGQoCIiEjGWAgQERHJGAsBIiIiGWMhQEREJGMsBIiIiGSMhQAREZGMsRAgIiKSMRYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYz9H0CNc+qii8ZVAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the objective function is: 0.0060569999999999999\r" - ] - } - ], - "source": [ - "mode = \"NFS\"\n", - "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "# do the circuit (neural network) with the optimal parameters\n", - "opt_angles = out['x']\n", - "qprog = make_program([theta, phi], opt_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(8.89515197858799) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(6.14308213587254) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(7.13449483997346) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 11:59:44\n", - "{'0': 999, '1': 1}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# show the output distribution\n", - "shots = 1000\n", - "backend_sim = Aer.get_backend('qasm_simulator')\n", - "dist = execute(qprog, backend_sim, shots=shots)\n", - "dist_count = dist.result().get_counts(qprog)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(dist_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(dist_count, color=['purple'], \n", - " title=str(n) + '- qubit QNN, ' + mode)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training (NFS)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "# fraction of total data to use as training data\n", - "train_frac = 0.7" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 0.9857142857142858\r" - ] - } - ], - "source": [ - "# get some random angles\n", - "angs = 2 * np.pi * np.random.rand(3)\n", - "cost = obj(angs)" - ] - }, - { - "cell_type": "code", - "execution_count": 176, - "metadata": {}, - "outputs": [], - "source": [ - "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 0.014285714285714285\n", - "Total training runtime took 1.8455156366030374 minutes.\n" - ] - } - ], - "source": [ - "# train the quantum neural network and time how long it takes\n", - "start = time.time()\n", - "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", - "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "[3.321652 6.2743205 5.85861077]\n" - ] - } - ], - "source": [ - "# grab the optimal angles and minimal cost value\n", - "optimal_angles = out['x']\n", - "fval = out['fun']\n", - "\n", - "# print them out\n", - "print(fval)\n", - "print(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [], - "source": [ - "# compute all the predictions of the quantum neural network\n", - "predictions = get_all_predictions(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "=============== Results of quantum neural network classification ===============\n", - "Out of 100 total data points:\n", - "The QNN was trained on 70.0% of the total data (70 training points).\n", - "The QNN classified 100 data points correctly (100.0% accuracy).\n", - "================================================================================\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# compute statistics of the QNN\n", - "ntrain = int(train_frac * npoints)\n", - "ncorrect = npoints - sum(abs(predictions - labels))\n", - "acc = ncorrect / npoints * 100\n", - "\n", - "# print them out\n", - "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", - "print(\"Out of {} total data points:\".format(npoints))\n", - "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", - "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", - "print(\"\".center(80, \"=\"))\n", - "\n", - "# plot the points, line y = x, and prediction\n", - "plt.plot(ys, xs, '--k')\n", - "for i in range(npoints):\n", - " if predictions[i] == 0:\n", - " ckey = 'g'\n", - " else:\n", - " ckey = 'b'\n", - " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", - "\n", - "plt.grid()\n", - "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Testing on device noise simulator" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [], - "source": [ - "# Testing on device noise simulator\n", - "mode = \"DNS\"" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(0.314283559730307) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(4.27779036629818) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(3.31959735414771) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "qprog = make_program([theta, phi], angles)\n", - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the objective function is: 0.00011199999999999999\r" - ] - } - ], - "source": [ - "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [], - "source": [ - "# do the circuit (neural network) with the optimal parameters\n", - "opt_angles = out['x']\n", - "qprog = make_program([theta, phi], opt_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 2.0;\n", - "include \"qelib1.inc\";\n", - "qreg q11[1];\n", - "creg c11[1];\n", - "ry(2.98797789579958) q11[0];\n", - "rz(0.789805554415850) q11[0];\n", - "rz(-1.51785048443617) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(0.248786966568569) q11[0];\n", - "rx(1.57079632679490) q11[0];\n", - "rz(9.26351197606004) q11[0];\n", - "measure q11[0] -> c11[0];\n", - "\n" - ] - } - ], - "source": [ - "QASM_source = qprog.qasm()\n", - "print(QASM_source)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Draw the circuit\n", - "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", - "qprog.draw(output='mpl', style=my_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Date (DMY): 10/02/2019 12:45:53\n", - "{'0': 904, '1': 96}\n", - "theta = 2.987977895799584 phi = 0.7898055544158503\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# show the output distribution (DNS)\n", - "mode = \"DNS\"\n", - "dist = execute(qprog, backend_noise, \n", - " noise_model=noise_model,\n", - " coupling_map=coupling_map,\n", - " basis_gates=basis_gates, shots = shots)\n", - "dist_count = dist.result().get_counts(qprog)\n", - "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", - "print(\"Date (DMY):\", time_exp)\n", - "print(dist_count)\n", - "print('theta =', theta, 'phi =', phi)\n", - "plot_histogram(dist_count, color=['cyan'], \n", - " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training (DNS)" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [], - "source": [ - "# fraction of total data to use as training data (DNS)\n", - "train_frac = 0.7" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 1.0\r" - ] - } - ], - "source": [ - "# get some random angles\n", - "angs = 2 * np.pi * np.random.rand(3)\n", - "cost = obj(angs)" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "metadata": {}, - "outputs": [], - "source": [ - "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The current value of the cost function is: 0.014285714285714285\n", - "Total training runtime took 6.603797650337219 minutes.\n" - ] - } - ], - "source": [ - "# train the quantum neural network and time how long it takes\n", - "start = time.time()\n", - "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", - "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n", - "[3.47838504 6.18048312 3.49508897]\n" - ] - } - ], - "source": [ - "# grab the optimal angles and minimal cost value\n", - "optimal_angles = out['x']\n", - "fval = out['fun']\n", - "\n", - "# print them out\n", - "print(fval)\n", - "print(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "metadata": {}, - "outputs": [], - "source": [ - "# compute all the predictions of the quantum neural network\n", - "predictions = get_all_predictions(optimal_angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "=============== Results of quantum neural network classification ===============\n", - "Out of 100 total data points:\n", - "The QNN was trained on 70.0% of the total data (70 training points).\n", - "The QNN classified 99 data points correctly (99.0% accuracy).\n", - "================================================================================\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# compute statistics of the QNN # previous experiment\n", - "ntrain = int(train_frac * npoints)\n", - "ncorrect = npoints - sum(abs(predictions - labels))\n", - "acc = ncorrect / npoints * 100\n", - "\n", - "# print them out\n", - "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", - "print(\"Out of {} total data points:\".format(npoints))\n", - "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", - "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", - "print(\"\".center(80, \"=\"))\n", - "\n", - "# plot the points, line y = x, and prediction\n", - "plt.plot(ys, xs, '--k')\n", - "for i in range(npoints):\n", - " if predictions[i] == 0:\n", - " ckey = 'g'\n", - " else:\n", - " ckey = 'b'\n", - " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", - "\n", - "plt.grid()\n", - "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### References:\n", - "\n", - "[1] https://github.com/QuantumAI-lib/NISQAI/blob/master/examples/one-qubit-classifier/one-qubit-classifier.ipynb\n", - "\n", - "[2] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/community/terra/qis_adv/Multi-Qubit_W_States_with_Tomography.ipynb\n", - "\n", - "[3] Smolin, J. A., Gambetta, J. M. & Smith, G. (2012). Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Phys. Rev. Lett 108(7). https://link.aps.org/doi/10.1103/PhysRevLett.108.070502\n", - "\n", - "[4] Preskill, J. (2018) Quantum Computing in the NISQ era and beyond. Quantum 2, 79 (2018). https://arxiv.org/abs/1801.00862\n", - "\n", - "[5] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.1" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From bf6dbe937a2a7e9abaf895f186df3f8f5fb9f033 Mon Sep 17 00:00:00 2001 From: Pierre Decoodt Date: Tue, 12 Feb 2019 08:44:07 +0100 Subject: [PATCH 5/5] Add a test of optimal circuit on real device Testing the circuit (neural network) with the optimal parameters on real device and make a final comparison. Some other minor changes --- ... Simulation and Real Device Run Test.ipynb | 2461 +++++++++++++++++ 1 file changed, 2461 insertions(+) create mode 100644 examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb diff --git a/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb b/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb new file mode 100644 index 0000000..ba1923e --- /dev/null +++ b/examples/one-qubit-classifier/[WIP] NISQAI Classifier on Qiskit with Device Noise Simulation and Real Device Run Test.ipynb @@ -0,0 +1,2461 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NISQAI One-Qubit Quantum Neural Network Adapted for Qiskit\n", + "\n", + "\n", + "***\n", + "### Contributors\n", + "#### Add here the contributors:\n", + "Pierre Decoodt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "This is a proof of concept for the assessment on Qiskit of a NISQAI classifier$^{[1]}$.\n", + "A one-qubit neural network is tested on Aer based noise free simulation (NFS) and device noise simulation (DNS), and also on real superconducting quantum calculating device (SQC).\n", + "\n", + "The protocol follows the steps described in a previous Qiskit tutorial $^{[2]}$ using quantum state tomography $^{[3]}$ for assessing fidelity.\n", + "\n", + "The last part consist of testing training and prediction by NFS and DNS.\n", + "\n", + "NB: We use the term SQC instead of NISQ because the original Preskill paper $^{[4]}$ specifies as \"NISQ\" quantum computers with 50-100 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\decpi\\Anaconda3\\envs\\q7env\\lib\\site-packages\\marshmallow\\schema.py:364: ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See https://marshmallow.readthedocs.io/en/latest/upgrading.html#schemas-are-always-strict\n", + " ChangedInMarshmallow3Warning\n" + ] + } + ], + "source": [ + "#Import packages\n", + "# NB running this cell induces a ChangedInMarshmallow3Warning for the moment. This warning can be safely ignored.\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import time\n", + "from scipy.optimize import minimize\n", + "\n", + "# import from qiskit\n", + "from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, compile\n", + "from qiskit.converters import qobj_to_circuits\n", + "from qiskit import Aer, IBMQ\n", + "from qiskit.providers.aer import noise\n", + "\n", + "# import tomography library\n", + "import qiskit.tools.qcvv.tomography as tomo\n", + "\n", + "# useful additional packages \n", + "from qiskit.tools.visualization import plot_state, plot_histogram \n", + "from qiskit.tools.qi.qi import state_fidelity, outer\n", + "from qiskit.tools.qi.qi import outer\n", + "from qiskit.quantum_info import state_fidelity\n", + "from qiskit.tools.monitor import job_monitor, backend_overview\n", + "from qiskit.providers.ibmq import least_busy\n", + "from qiskit.quantum_info.analyzation.average import average_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Aer.backends() # No need for credentials for running the next cells until next warning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Data Encoding" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set random seed for reproducible results\n", + "SEED = 1059123109\n", + "np.random.seed(seed=SEED)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# generate data points distributed uniformly at random in [0, 1) x [0, 1)\n", + "npoints = 100\n", + "data = np.random.rand(npoints, 2)\n", + "\n", + "def predicate(point):\n", + " \"\"\"Returns true if the point satisfies the predicate, else false.\"\"\"\n", + " return True if point[0] <= 0.5 else False\n", + "\n", + "# separate the data with a linear boundary y = x\n", + "labels = np.array([1 if predicate(p) else 0 for p in data])\n", + "\n", + "# plot the line y = x\n", + "xs = np.linspace(0, 1, 100)\n", + "ys = 0.5 * np.ones_like(xs)\n", + "plt.plot(ys, xs, '--k')\n", + "\n", + "# plot the data with the color key BLUE = 0 = LEFT, GREEN = 1 = RIGHT\n", + "for i in range(npoints):\n", + " if labels[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + " \n", + "# title and axis lables\n", + "plt.title(\"Random Data Points in Unit Square\", fontweight=\"bold\", fontsize=16)\n", + "\n", + "# put on a grid and show the plot\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Qubit Encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# encode the classical data via a simple linear \"qubit encoding\"\n", + "qdata = np.zeros_like(data)\n", + "for (index, point) in enumerate(data):\n", + " qdata[index][0] = np.pi * point[0]\n", + " qdata[index][1] = 2 * np.pi * point[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. State Preparation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As explained is the NISQAI one-qubit classifier description$^{[1]}$, the one-qubit encoding is achieved by realizing the following initial state: \n", + " \n", + "$$|\\psi\\rangle = \\cos(\\frac {\\theta}{2}) |0\\rangle + e^{i \\phi} \\sin(\\frac {\\theta}{2})|1\\rangle $$\n", + "\n", + "\n", + "The unitary taking the $|0\\rangle$ to the above state is: \n", + "\n", + "$$\n", + "S(\\theta, \\phi) = \\begin{pmatrix}\n", + "\\cos(\\frac {\\theta}{2}) & e^{-i \\phi}\\sin(\\frac {\\theta}{2}) \\\\\n", + "e^{i \\phi} \\sin(\\frac {\\theta}{2}) & - \\cos(\\frac {\\theta}{2})\n", + "\\end{pmatrix}\n", + "$$\n", + "\n", + "\n", + "Such an operation is not currently directly available in Qiskit to our knowledge. We therefore use arbitrary initialization in order to encode the qubit $^{[5]}$.\n", + "\n", + "A check of the results of this arbitrary initialization follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.122 5.969 0 vs 2 -- 8191 vs 8190\n", + "0.348 0.911 7946 vs 7946 -- 245 vs 246\n", + "1.652 4.618 3765 vs 3849 -- 4426 vs 4343\n", + "2.919 0.365 101 vs 94 -- 8090 vs 8098\n", + "2.582 1.018 623 vs 592 -- 7568 vs 7600\n", + "0.002 5.703 8191 vs 8192 -- 0 vs 0\n", + "2.986 5.712 49 vs 34 -- 8142 vs 8158\n", + "3.064 1.62 12 vs 15 -- 8179 vs 8177\n", + "1.516 0.87 4320 vs 4356 -- 3871 vs 3836\n", + "3.131 0.308 0 vs 0 -- 8191 vs 8192\n", + "2.118 0.197 1965 vs 1949 -- 6226 vs 6243\n" + ] + } + ], + "source": [ + "# Checking arbitrary initialization\n", + "n = 1\n", + "for i in range(5,56,5) : # modify here if wishe\n", + " # create a n-qubit quantum register\n", + " qrt = QuantumRegister(n)\n", + " crt = ClassicalRegister(n)\n", + " check_sta = QuantumCircuit(qrt,crt , name='check_sta')\n", + "\n", + " # pick an encoded data point\n", + " theta, phi = qdata[i]\n", + "\n", + " # desired vector\n", + " desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", + " qrt_vector = []\n", + "\n", + " # Initialize a 1-qubit quantum state using the arbitrary method \n", + " qrt_vector.append(qrt[0])\n", + " check_sta.initialize(desired_vector, qrt_vector)\n", + "\n", + " # Measurement circuit\n", + " measuring = QuantumCircuit(qrt,crt , name='measuring')\n", + " for i in range(n) :\n", + " measuring.measure(qrt[i] , crt[i])\n", + " test_check = check_sta+measuring\n", + "\n", + " # noise free simulation (NFS)\n", + " mode = \"NFS\"\n", + "\n", + " # test circuit \"check_sta\" : Noise free model on simulator\n", + " backend_sim = Aer.get_backend('qasm_simulator')\n", + " shots = 8192\n", + " job_noisefree = execute(test_check, backend_sim, shots=shots) \n", + " count = job_noisefree.result().get_counts(test_check)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " counts_obs1 = int(average_data(count,observable_1)*shots)\n", + " counts_obs0 = int(average_data(count,observable_0)*shots)\n", + " \n", + " counts_theo0 = int(abs(np.cos(theta / 2)**2)*shots)\n", + " counts_theo1 = int(abs(np.exp(1j * phi) * np.sin(theta / 2)**2)*shots)\n", + " print(round(theta,3), round(phi,3),\" \", counts_theo0,\"vs\", counts_obs0,\"--\", counts_theo1,\"vs\", counts_obs1) " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Determine the job\n", + "n = 1\n", + "\n", + "# create a n-qubit quantum register\n", + "qr = QuantumRegister(n)\n", + "cr = ClassicalRegister(n)\n", + "initial_state = QuantumCircuit(qr, cr, name='initial_state')\n", + "\n", + "# pick a particular encoded data point\n", + "theta, phi = qdata[0]\n", + "\n", + "# desired vector\n", + "desired_vector = [np.cos(theta / 2), np.exp(1j * phi) * np.sin(theta / 2)]\n", + "qr_vector = []\n", + "\n", + "# Initialize a 1-qubit quantum state using the arbitrary method \n", + "qr_vector.append(qr[0])\n", + "initial_state.initialize(desired_vector, qr_vector)\n", + "\n", + "# Measurement circuit\n", + "measuring = QuantumCircuit(qr, cr, name='measuring')\n", + "for i in range(n) :\n", + " measuring.measure(qr[i] , cr[i])\n", + "test = initial_state+measuring" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the arbitrary initialization of the state by noise free simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "# QASM from test\n", + "QASM_source = test.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "test.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3d413bbc8b5e4734bc695b0e41e45e43", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:17:59\n", + "{'0': 8, '1': 992}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# noise free simulation (NFS)\n", + "mode = \"NFS\"\n", + "\n", + "# Test circuit \"initial_state\" : Noise free model on simulator\n", + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "shots = 1000\n", + "job_noisefree = execute(test, backend_sim, shots=shots)\n", + "job_monitor(job_noisefree)\n", + "\n", + "count = job_noisefree.result().get_counts(test)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, initial state, noise free simulation')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Unitary Evolution" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def unitary(angles):\n", + " \"\"\"Returns a circuit implementing the unitary Rz(theta0) P Rz(theta1) P Rz(theta2)\n", + " where thetea0 = angles[0], theta1 = angles[1], and theta2 = angles[2] and\n", + " P = Rx(pi / 2) is a pi / 2 pulse.\n", + " \"\"\"\n", + " \n", + " circuit = QuantumCircuit(qr, cr)\n", + " circuit.rz(angles[0], qr[0])\n", + " circuit.rx(np.pi / 2, qr[0]),\n", + " circuit.rz(angles[1], qr[0]),\n", + " circuit.rx(np.pi / 2, qr[0]),\n", + " circuit.rz(angles[2], qr[0])\n", + " \n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "# test angles\n", + "angles = 2 * np.pi * np.random.rand(3)\n", + "my_state = initial_state + unitary(angles)\n", + "qprog = my_state + measuring\n", + "\n", + "# QASM\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Test the circuit using a noise free simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:14\n", + "{'0': 252, '1': 748}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAccAAAFCCAYAAACEgRbZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X+cVnWd9/HXRwQCF81BwkEEJFwafsSOv9afZCmV1rouWq65tdaaa97+2DVvylZX7U67My219G6jNlNzVw37sZYbuZSomW0ICIqzGAIis+wIKMRvx8/9x3VBw2EGZnDmunDm9Xw85sF1vud7zvW5GIb3fM/5nnMiM5EkSX+wV7ULkCRpT2M4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEp7iIj4ZUSc18a6YRHx+4joVem6pJ7IcJRaiIiLIuK3EbEpIu6odj1bZebSzPyjzGyGnQfpVhHRNyK+GBFLI2JDRCyMiMsjIlr0+WVEbIyIg1u0nRwRi1ssL46IFRGxT4u28yLil+2pPSLOjYiMiP9daF8WESeWX18TEVvKvwBs/ZpSXjc2IqZHxOqIeCUiZkXEqe15b2l3GY7S9pYDXwD+udqFdIL7gZOAU4EBwEeBvwVuKvRbB1y1i33tDVz6BmpZBXwmIvbdSZ97y78AbP26odz+b8DPgcHA24BLgDVvoBZplwxHqYXMfCAzfwis3J3tI2JSRDwXEa9GxNcj4pGtI7zy6OjuFn1HlEdUe7fYxdsj4jfl7X8UETXFvhFxHXAC8PXyCOvrrdRxEvBe4IzMnJ+Zr2Xmr4G/Ai6NiJEtut8KnB0Ro3by0b4MXB4Rb92dvxdgAfAE8Pcd2SgiDgAOAaZm5uby1+OZ+dhu1iG1i+EodZLyf+TTgCuBA4DfAcd1cDcfAz4BDAFeoxRc28nMfwAeBS4qj7AuamU/k4AnM/PFwrZPAssojSi3egmYClyzk7p+C/wSuLy9H6QVVwF/vzXw22kl8Dxwd0ScHhGD38D7S+1mOEqd51Tg2cz8fmZuAW4G/ruD+7irPNLbeqjzw7s5CecAoLGNdY3AoELbF4E/i4ixO9nnPwIXR0Rx23bJzDnAdOAzbXT5cPmc4tavIVm6+fO7gcWUDgc3RsTMiDh0d2qQ2stwlNopIh5qMVnknFa6DAG2jdTK/7G/2Eq/nWnZfwnQm1LQddTLQG0b62qBppYNmdkEfB34fFs7zMz5wIPAZ3ejnq3+EfhURBzYyrr7MvOtLb6Wl993WWZelJlvB4ZTOkd65xuoQdolw1Fqp8w8pcVkke+10qURaDnrM1ouU/pPvX+L5dYComX/YcAWSkG3Qzm7KPdh4E9bzkIt13RUeb8zW9nmy5RGaYfvZL9XA58EDtrF+7cqM58DHgA+t5vbvwjcBozbne2l9jIcpRbKE17eAvQCekXEWwoTZnbmJ8DYiJhc3uYStg/AOcDE8jWL+wFXtLKPv4qIMRHRn9Io7vtbL98oWAGMbKUdgMx8GPgPYFr5UoheEXE08D3gzsxsaGWbVygdupyyk/0+D9xb/mzblC8Juaat7QquBT4O7HJyT0TsHxHXRsSoiNirfF73E8Cv2/le0m4xHKXtXQlsoHTo8K/Kr69sz4aZ+TLwIeD/UppIcijweIv1P6cULE8Dsygdoiy6C7iD0rnKt1AIoRZuAc4sX/u3w6SdsjOAXwD/DmykNFv034Hzd/IxbgFaC+OWPg/sU2g7mBafdWcy8wVKn7O4j9ZsBkZQGgmvAeYDm4Bz2/Ne0u4KH3YsdZ3yhfJ3Z+a39oBavkvpcOipmbm5E/c7FLg/M4/prH1K1ebIUeo5zqN0Mf1hnbnT8oQZg1HdSnvPpUh6kytfXvKlatchvRl4WFWSpAIPq0qSVGA4SpJU0G3POQ4cODCHDRtW7TIkSXuQOXPmvJyZu7wFYrcNx2HDhjFjxoxqlyFJ2oPU1NQsaU8/D6tKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOErSHuDhhx/mqKOO4vDDD+fmm2/eYf3nPvc5Jk6cyMSJEznyyCMZMWLEduvXrFnD2LFjmTJlyra2adOmcdxxx3H88cdz5plnsnLlyq7+GN1GxcMxIi6MiBciYmNEzIqIE3bR/yMRMSci1kfEf0fE3RFxYKXqlaSu1tzczJQpU7jvvvt44oknmDZtGs8999x2fa6//npmzpzJzJkz+eQnP8kHP/jBHdYfe+yx25Zfe+01rrjiCn784x/z2GOPMXbsWKZOnVqRz9MdVDQcI+Is4BbgeqAe+BXwUEQMa6P/ccBdwHeBscDpwBjgexUpWJIqYNasWRxyyCGMGDGCPn36MHnyZB566KE2+0+bNo0zzjhj2/KcOXNoamri3e9+97a2zCQzWb9+PZnJ2rVrOfBAxxXtVemR42XAHZk5NTMXZObFQCPwqTb6HwMsy8yvZuYLmflr4GvAn1aoXknqco2NjRx00EHblocMGUJjY2OrfV988UWWLl3KxIkTAXj99de56qqruPbaa7fr17t3b2688UaOO+44xowZQ0NDAx/96Ee77kN0MxULx4joAxwOTC+smg4cu+MWADwO1EbEn0XJAcBfAj/tukolqbIyc4e2iGi17wMPPMBpp51Gr169APj2t7/NpEmTGDp06Hb9tmzZwne+8x0eeeQRnn32WcaOHctXv/rVzi++m9q7gu91ANALWFFoXwGc3NoGmflERJxN6TBqP0r1/hz469b6R8T5wPkAtbW1PPXUU0Dpt7D+/fvz/PPPA7DffvsxcuRIZs+eDUCvXr2YMGECDQ0NrFu3DoC6ujpWrVrFihWlcocOHUqfPn1YtGgRAPvvvz/Dhg1j7ty5QOm3tPHjx7NgwQI2bNgAwJgxY2hqaqKpqQmA4cOHExEsXrwYgIEDB1JbW8v8+fMB6Nu3L2PHjuWZZ55h06ZNAIwbN47GxsZtJ9JHjBhBZrJkyRIABg0axKBBg3j22WcB6NevH3V1dcybN48tW7YAMGHCBJYuXcrq1asBGDlyJJs3b2bZsmUADB48mJqaGhYsWADAPvvsw+jRo5k7dy7Nzc0A1NfXs2jRIl599VUARo0axfr161m+fDlb/7733XdfGhoaABgwYACHHnoos2fPJjOJCOrr61m4cCFr164FYPTo0axZs2bbb8h+n/w+9dTv03777ccLL7yw7f+shoYGampqti23/D7dfffdXHrppQAsXLiQn/3sZ8ybN49vfetb/P73v2fz5s2sXbuWyZMn89prr7F69WpWr17NkUceyf33379tnz31+9Re0dpvLF0hIoYALwETM/PRFu1XA2dn5jta2WYMpTC8GfgZUAt8GZiTmR/b2fvV19fnjBkzOvETSFLXeO211zjyyCP54Q9/SG1tLSeddBLf/OY3qaur267fwoULOfPMM5kzZ06rI8t77rmHOXPmcMMNN9DY2Mh73vMeHn30UQ444ACuu+46NmzYwBe+8IVKfaw9Uk1NzazMPGJX/So5cnwZaAaKZ4Tfxo6jya2uAH6TmV8uLz8dEeuARyPiHzLzxa4pVZIqZ++99+aGG27gzDPPpLm5mXPOOYe6ujquv/566uvrOeWUU4DSRJzJkye3eci1pdraWqZMmcIHPvABevfuzcEHH8xtt93W1R+l26jYyBEgIp4E5mbm+S3a/guYlplXtNJ/GpCZeWaLtmMozXIdnplL23ovR46SpKI9ceQI8BXgroj4DaXJNhcAQ4BvAETEnQAtDpn+GzA1Ij7FHw6r3gw8tbNglCTpjahoOGbmvRExELiSUtDNB07NzCXlLsMK/e+IiAHARcBNwKvAL4ApSJLURSo9ciQzbwdub2Pdia20fY3StY2SJFWE91aVJKnAcJQkqcBwlCSpwHCUJKnAcJQkqcBwlCSpwHCUJKnAcJQkqcBwlCSpoOJ3yJGkrnRrza3VLkFd4JJVl1T0/Rw5SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUYDhKklRgOEqSVGA4SpJUUPFwjIgLI+KFiNgYEbMi4oRd9O8TEZ8vb7MpIpZGxCWVqleS1PPsXck3i4izgFuAC4HHyn8+FBFjMnNpG5v9C3AwcD6wEBgM9KtAuZKkHqqi4QhcBtyRmVPLyxdHxPuBTwFXFDtHxHuBk4G3Z+bL5ebFlShUktRzVeywakT0AQ4HphdWTQeObWOz04H/BC6LiGURsTAibo2IP+rCUiVJPVwlR44HAL2AFYX2FZRGh60ZCRwPbALOAN4KfA0YApxZ7BwR51M6/EptbS1PPfUUAEOGDKF///48//zzAOy3336MHDmS2bNnA9CrVy8mTJhAQ0MD69atA6Curo5Vq1axYkWp3KFDh9KnTx8WLVoEwP7778+wYcOYO3cuAL1792b8+PEsWLCADRs2ADBmzBiamppoamoCYPjw4UQEixcvBmDgwIHU1tYyf/58APr27cvYsWN55pln2LRpEwDjxo2jsbGRlStXAjBixAgykyVLlgAwaNAgBg0axLPPPgtAv379qKurY968eWzZsgWACRMmsHTpUlavXl36Sx05ks2bN7Ns2TIABg8eTE1NDQsWLABgn332YfTo0cydO5fm5mYA6uvrWbRoEa+++ioAo0aNYv369Sxfvpytf9/77rsvDQ0NAAwYMIBDDz2U2bNnk5lEBPX19SxcuJC1a9cCMHr0aNasWUNjY6PfJ79PnfZ9Uve0cuXKTvl5aq/IzE7+CG28UcQQ4CVgYmY+2qL9auDszHxHK9tMB04ADszMV8tt7wV+Vm4rBu029fX1OWPGjE7+FJL2dLfW3FrtEtQFLlnVOfMwa2pqZmXmEbvqV8nZqi8DzcCBhfa3seNocqtG4KWtwVi2oPznsM4tT5KkkoqFY2ZuBmYBkwqrJgG/amOzx4EhhXOMf1z+c0nnVihJUkmlr3P8CnBuRJwXEXURcQul84ffAIiIOyPizhb97wFWAt+JiLERcRylS0G+n5n/U+HaJUk9REUv5cjMeyNiIHAlUAvMB07NzK2jwGGF/r+PiJMpTcL5T2A18EPgs5WrWpLU03QoHCPiw8ArmTm9vPyPlGaHPgOcm5mNu9pHZt4O3N7GuhNbaWsA3tuROiVJeiM6elj1mq0vIuIw4HPArUBv4KbOK0uSpOrp6GHV4UBD+fVfAD/MzBvKl1z8rFMrkySpSjo6ctwIDCi/Pgl4uPz61RbtkiS9qXV05PgocFNEPAYcwR/uUvPHwIudWZgkSdXS0ZHjRcBmSqF4QWYuL7efgodVJUndRIdGjpm5DPizVtr/rtMqkiSpyjp8E4CIeEtEnBkRn4mIt5bb3h4RNZ1fniRJldfR6xxHUZqE80eUnpBxP/AKpecxvhU4r7MLlCSp0jo6cryZ0vMXBwMbWrT/GHh3ZxUlSVI1dXS26rHA0ZnZHBEt25dSukeqJElvertz4/HerbQNo3StoyRJb3odDcfpwGUtljMi9gWuBX7SaVVJklRFHT2sehnwi4hoAN4C3AuMovSw4g93cm2SJFVFR69zXB4RfwKcDRxGaeT5TeB7mblhpxtLkvQm0eHnOZZD8J/LX5IkdTu7DMeImAz8W2ZuKb9uU2Y+0GmVSZJUJe0ZOX4fOBD4n/LrtiTQqzOKkiSpmnYZjpm5V2uvJUnqrjoUdhExMSJ2CNSI6BUREzuvLEmSqqejI8FfAK3dYPyt5XWSJL3pdTQcg9K5xaKBwLo3Xo4kSdXXrks5IuLH5ZcJ3B0Rm1qs7gWMA37VybVJklQV7b3OcWX5zwBWs/0TOTYDjwFTO7EuSZKqpl3hmJkfB4iIxcCNmekhVElSt9XR28dd21WFSJK0p2jPHXKeBt6VmasjYh6tT8gBIDPf2ZnFSZJUDe0ZOU4Dtk7A2dkdciRJ6hbac4eca1t7LUlSd+Xt4CRJKmjPOcednmdsyXOOkqTuoL1P5ZAkqcfo0DlHSZJ6As85SpJU4HWOkiQVeJ2jJEkFXucoSVJBh+6tulVEvB2oKy8uyMzfdV5JkiRVV4fCMSIGAt8GTgNe/0NzPAh8IjNXtrmxJElvEh2drfotYBRwAvCW8tdE4BB8nqMkqZvo6GHV9wEnZeYTLdoej4i/BR7uvLIkSaqejo4cm4DWHnS8HvCQqiSpW+hoOH4euDkiDtraUH59U3mdJElvertz4/FDgMUR8VJ5+SBgI/A2SuckJUl6U/PG45IkFXjjcUmSCrzxuCRJBR0Kx4joExHXRsR/RcTGiGhu+dVVRUqSVEkdHTn+H+CvKc1OfR3438BtlC7juLBzS5MkqTo6Go4fBi7IzH8CmoEfZeYlwNXApM4uTpKkauhoOA4Gni2//j3w1vLrfwfe254dRMSFEfFC+bDsrIg4oZ3bHR8Rr0XE/A7WLElSh3Q0HJcCQ8qvn6d0OzmAY4ANu9o4Is4CbgGuB+qBXwEPRcSwXWy3P3An8B8drFeSpA7raDj+ADip/PoW4NqIeAG4g/bdAOAy4I7MnJqZCzLzYqAR+NQutvs28F3giV30kyTpDevQjccz84oWr78fEcuAY4H/yswHd7ZtRPQBDgduLKyaXt5HW9tdCBwIfAi4qiP1SpK0O3brYcdbZeavgV+3s/sBQC9gRaF9BXByaxtExHhKk32OzszmiNjdUiVJarcOh2NEHAb8HTCm3LQA+GpmPtXOXWRhOVppIyL6Av8KXJ6ZL7SztvOB8wFqa2t56qlSSUOGDKF///48//zzAOy3336MHDmS2bNnA9CrVy8mTJhAQ0MD69aVHjpSV1fHqlWrWLGilOVDhw6lT58+LFq0CID999+fYcOGMXfuXAB69+7N+PHjWbBgARs2lE6/jhkzhqamJpqamgAYPnw4EcHixYsBGDhwILW1tcyfX5pj1LdvX8aOHcszzzzDpk2bABg3bhyNjY2sXFl66MmIESPITJYsWQLAoEGDGDRoEM8+W5on1a9fP+rq6pg3bx5btmwBYMKECSxdupTVq1cDMHLkSDZv3syyZcsAGDx4MDU1NSxYsACAffbZh9GjRzN37lyam0uXr9bX17No0SJeffVVAEaNGsX69etZvnw5W/++9913XxoaGgAYMGAAhx56KLNnzyYziQjq6+tZuHAha9euBWD06NGsWbOGxsZGv09+nzrt+6TuaeXKlZ3y89RekblDLrXdOeIcShNjZvCH839HA+8Bzs3Mu3eybR9Kj7Y6OzPvb9F+GzAuM99V6D8CeIHSJSNb7UUpTJuBUzNzelvvV19fnzNmzGj3Z5PUPdxac2u1S1AXuGTVJZ2yn5qamlmZecSu+nV05HgdcFVmXt+yMSKuAL4AtBmOmbk5ImZRuh7y/harJgHTWtnkJWB8oe3Ccv+/ABZ3sHZJktqlo+E4CLivlfb7ad9kma8Ad0XEb4DHgQsoXRryDYCIuBMgMz+WmVuA7a5pjIj/ATZlptc6SpK6TEfD8RfAiZSucWzpROCRXW2cmfdGxEDgSqCWUvidmplLyl12er2jJEmV0J6HHU9usfgQ8MWIOII/zFI9GpgMXNOeN8zM24Hb21h34i62vaa97yNJ0u7a3Ycdb5sV2sLXaCP0JEl6M2nPw4595qMkqUcx+CRJKuhwOEbEByJiZkS8HBFNEfFIRJzaFcVJklQNHQrHiDiP0s3Hfwd8BvgspQv1fxARn+j88iRJqryOXsrxGeCyzPx6i7Zvly/u/yzwz51WmSRJVdLRw6rDKD3YuOghYPgbL0eSpOrbnYcdT2ql/b3AklbaJUl60+noYdUbga+Vn8zxK0pP0zge+ChwcSfXJklSVXT0Ycf/VL6/6acp3RUHSo+s+nBm/qizi5MkqRraHY4RsTelw6czM/MHXVeSJEnV1e5zjpn5GvAAMKDrypEkqfo6OiFnLjCqKwqRJGlP0dFwvAa4KSJOj4iDI6Km5VcX1CdJUsV1dLbqT8p/PkBppupWUV7u1RlFSZJUTR0Nx3d3SRWSJO1B2hWOEdEf+DJwOtAbeBi4JDNf7sLaJEmqivaec7wWOJfSYdV/oXSXnP/XRTVJklRV7T2sOhn4m8z8V4CI+B7weET0yszmLqtOkqQqaO/I8WDg0a0Lmfkb4DVgSFcUJUlSNbU3HHsBmwttr9HxCT2SJO3x2htuAdwdEZtatL0FmBoR67c2ZOZpnVmcJEnV0N5w/G4rbXd3ZiGSJO0p2hWOmfnxri5EkqQ9RUdvHydJUrdnOHZjDz/8MEcddRSHH344N9988w7rb7vtNo4++miOP/54Tj/9dF588cVt6w444AAmTpzIxIkT+chHPrKt/fzzz+eoo47i2GOP5aKLLmLLli0V+SySVEmGYzfV3NzMlClTuO+++3jiiSeYNm0azz333HZ93vnOdzJjxgwee+wxTjvtNK6++upt6/r168fMmTOZOXMm99xzz7b2D33oQzz55JM8/vjjbNy4kbvuuqtin0mSKsVw7KZmzZrFIYccwogRI+jTpw+TJ0/moYce2q7PCSecQP/+/QE44ogjWL58+S73O2nSJCKCiOCwww5r1zaS9GZjOHZTjY2NHHTQQduWhwwZQmNjY5v97777bk4++eRtyxs3buQ973kPkyZN4ic/+ckO/bds2cJ9993HSSed1LmFS9IewIv4u6nM3KEtIlrte9999zF79mwefPDBbW1PP/00tbW1LF68mD//8z9nzJgxHHLIIdvWX3755RxzzDEcc8wxnV+8JFWZI8duasiQIbz00kvblpcvX86BBx64Q79f/vKX3HTTTdxzzz307dt3W3ttbS0AI0aM4Pjjj+fpp5/etu5LX/oSK1eu5LrrruvCTyBJ1WM4dlOHHXYYixYtYsmSJWzevJkHHniA97///dv1efrpp7nsssu45557GDRo0Lb2V155hU2bSjdDWrlyJU8++SSjR48G4M4772TGjBlMnTqVvfbyn4+k7snDqt3U3nvvzQ033MCZZ55Jc3Mz55xzDnV1dVx//fXU19dzyimncPXVV7Nu3To+/vHSPR6GDh3KPffcQ0NDA5dddhl77bUXr7/+OpdeeinveMc7APj0pz/NwQcfzPve9z4APvjBDzJlypSqfU5J6grR2rmp7qC+vj5nzJhR7TIkVditNbdWuwR1gUtWXdIp+6mpqZmVmUfsqp/HxSRJKjAcJUkqMBwlSSowHCVJKnC26i54cr976qyT+5K6J0eOkiQVGI6SJBUYjpIkFRiOkiQVGI6SJBUYjpIkFRiOkiQVGI6SJBUYjpIkFRiOkiQVGI6SJBVUPBwj4sKIeCEiNkbErIg4YSd9J0fE9Ihoioi1EfFkRJxWyXolST1PRcMxIs4CbgGuB+qBXwEPRcSwNjZ5FzAD+EC5/0+BH+wsUCVJeqMq/VSOy4A7MnNqefniiHg/8CngimLnzLy00HRtRHwAOB14tEsrlST1WBUbOUZEH+BwYHph1XTg2A7sagCwurPqkiSpqJIjxwOAXsCKQvsK4OT27CAi/hcwFLirjfXnA+cD1NbW8tRTTwEwZMgQ+vfvz/PPPw/Afvvtx8iRI5k9ezYAvXr1YsKECTQ0NLBu3ToA6urqWLVqVYc+oN48FixYwIYNGwAYM2YMTU1NNDU1ATB8+HAigsWLFwMwcOBAamtrmT9/PgB9+/Zl7NixPPPMM2zatAmAcePG0djYyMqVKwEYMWIEmcmSJUsAGDRoEIMGDeLZZ58FoF+/ftTV1TFv3jy2bNkCwIQJE1i6dCmrV5d+9xs5ciSbN29m2bJlAAwePJiamhoWLFgAwD777MPo0aOZO3cuzc3NANTX17No0SJeffVVAEaNGsX69etZvnw5UPq52HfffWloaABgwIABHHroocyePZvMJCKor69n4cKFrF27FoDRo0ezZs0aGhsbgTf287RiRenHf+jQofTp04dFixYBsP/++zNs2DDmzp0LQO/evRk/fvxufZ/UPa1cubJTfp7aKzKzkz9CG28UMQR4CZiYmY+2aL8aODsz37GL7c+gFIp/mZk/3tX71dfX54wZM95g1T7suLvyYcfdlz+z3VNn/czW1NTMyswjdtWvkhNyXgaagQML7W9jx9HkdloE48faE4ySJL0RFQvHzNwMzAImFVZNojRrtVUR8WHgbuDczPx+11UoSVJJpWerfgW4KyJ+AzwOXAAMAb4BEBF3AmTmx8rLf0lpxHg5MDMito46N2emJwQlSV2iouGYmfdGxEDgSqAWmA+cmplLyl2K1zteQKnGm8tfWz0CnNi11UqSeqpKjxzJzNuB29tYd+LOliVJqgTvrSpJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUoHhKElSgeEoSVKB4ShJUkHFwzEiLoyIFyJiY0TMiogTdtH/XeV+GyNiUURcUKlaJUk9U0XDMSLOAm4BrgfqgV8BD0XEsDb6HwL8tNyvHvgi8LWIOKMyFUuSeqJKjxwvA+7IzKmZuSAzLwYagU+10f8CYHlmXlzuPxX4LnB5heqVJPVAFQvHiOgDHA5ML6yaDhzbxmbHtNL/Z8DPCqYnAAADH0lEQVQREdG7cyuUJKmkkiPHA4BewIpC+wrgwDa2ObCN/nuX9ydJUqfbuwrvmYXlaKVtV/1baycizgfOLy/+vqampmG3Kuy5DgBernYRlXBNzTXVLkHqDP7Mdtzw9nSqZDi+DDSz4yjxbew4Otzqv9vo/xqwstg5M78JfPONldlzRcRvM/OIatchqX38me06FTusmpmbgVnApMKqSZRmo7bmCeDkVvr/NjO3dG6FkiSVVHq26leAcyPivIioi4hbgCHANwAi4s6IuLNF/28AQyPi5nL/84BzgRsrXLckqQep6DnHzLw3IgYCVwK1wHzg1MxcUu4yrND/hYg4Ffgqpcs9lgOXZOa0Cpbdk3hIWnpz8We2i0TmzubCSJLU83hvVUmSCgxHSZIKDEdJkgoMxx4uIg6NiMHVrkOS9iROyOmBIuJtwEeBvweaKN1UoRH4PjAtM9dVsTxJqjrDsQeKiDuAMcCDlO40NBD4E6AOWAbckJk/r1qBknYQEfsCa9P/tCvCcOxhIiKAtZSuL53Zou1g4E+BT1K69+BZmTmnaoVK2k5E/BPwm/LXksxc00qfgZm5w6011XGec+x5xgAvAJu3NmTJ0sy8H/ggpfA8q0r1SSqIiLMp/eJ6E/Aj4MsR8RcR8faI6Ffu0w/4dkSMr2Kp3YYjxx6m/AP0INAf+Bjwu8x8vdDnYuBvMvNPqlCipIKImErpwQ03AJOBvwbeDjQAPwX+AxgN3JKZfapVZ3fiyLGHycwNwD8A/YA7gY9FxMERsQ9ARPQH3kXp1n6Sqiwi9qZ0tOeVzFyUmTdm5njgSOARSkF5H/A14K7qVdq9OHLsoSJiHHAVcBqwjtITUJooPQWlETgvM+dVr0JJW0XE/sDgzHwuIvoAW1pOzImIs4B/AQ5zrkDnMBx7uPJlHR8ATgc2Uhox3p+Zz1W1MEk7FRF7Ufo/vDkiPknpkGr/atfVXRiO2iYi9iqef5S054uIy4BemfnlatfSXRiOkvQmFxG9gWZ/ue08hqMkSQXOVpUkqcBwlCSpwHCUJKnAcJQkqcBwlCSpwHCUJKng/wMN5NvHCOqzhwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# noise free simulation (NFS)\n", + "mode = \"NFS\"\n", + "\n", + "# run the quantum neural network program\n", + "\n", + "shots = 1000\n", + "job_noisefree = execute(qprog, backend_sim, shots=shots)\n", + "\n", + "noisefree_count = job_noisefree.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(noisefree_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(noisefree_count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, ' + mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity in noise free device simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84c5beb68c774d79b3740bcbc5c00d32", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:18\n", + "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: NFS theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.999933478085305\n" + ] + } + ], + "source": [ + "# Execute state tomography using noise free quantum device simulation\n", + "mode = \"NFS\"\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "\n", + "my_state_job = execute(my_state_tomo_circuits, backend_tomo, shots=shots)\n", + "job_monitor(my_state_job)\n", + "my_state_tomo_result = my_state_job.result() \n", + " \n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### From here, you need credentials:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "IBMQ.load_accounts()" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibmq_16_melbourne ibmqx4\n", + "----------------- ------\n", + "Num. Qubits: 14 Num. Qubits: 5\n", + "Pending Jobs: 29 Pending Jobs: 478\n", + "Least busy: True Least busy: False\n", + "Operational: True Operational: True\n", + "Avg. T1: 55.3 Avg. T1: 52.1\n", + "Avg. T2: 64.4 Avg. T2: 17.2\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "backend_overview() # you may skip running this cell if you want" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ibmq_16_melbourne\n" + ] + } + ], + "source": [ + "# Make your choice of real device\n", + "#backend_real = least_busy(IBMQ.backends(operational=True, simulator=False))\n", + "#backend_real = IBMQ.get_backend('ibmqx4')\n", + "backend_real = IBMQ.get_backend('ibmq_16_melbourne')\n", + "print(backend_real)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prepare noise simulation corresponding to a given quantum device" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "device: ibmq_16_melbourne\n", + "noise model prepared for ibmq_16_melbourne\n" + ] + } + ], + "source": [ + "# Prepare device noise simulation (DNS)\n", + "\n", + "device = backend_real\n", + "print(\"device: \", device)\n", + "properties = device.properties()\n", + "coupling_map = device.configuration().coupling_map\n", + "prepared = False\n", + "if device.name() == 'ibmq_16_melbourne' :\n", + " gate_times = [\n", + " ('u1', None, 0), ('u2', None, 100), ('u3', None, 200),\n", + " ('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),\n", + " ('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),\n", + " ('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),\n", + " ('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),\n", + " ('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12, 2], 773),\n", + " ('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)\n", + " ]\n", + " prepared = True\n", + " \n", + "elif device.name() == 'ibmqx4' :\n", + " gate_times = [\n", + " ('u1', None, 0), ('u2', None, 60), ('u3', None, 120),\n", + " ('cx', [1, 0], 340), ('cx', [2, 0], 424), ('cx', [2, 1], 520),\n", + " ('cx', [3, 2], 620), ('cx', [3, 4], 420), ('cx', [4, 2], 920) \n", + " ]\n", + " prepared = True\n", + "\n", + "else :\n", + " print(\"No gate times yet defined in this notebook for: \", device)\n", + " \n", + "if prepared :\n", + " # Construct the noise model from backend properties and custom gate times\n", + " noise_model = noise.device.basic_device_noise_model(properties, gate_times=gate_times)\n", + "\n", + " # Get the basis gates for the noise model\n", + " basis_gates = noise_model.basis_gates\n", + " \n", + " print(\"noise model prepared for\", device)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the algorithm using device noise simulation (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a02d100572e04c87b3878627bbd4ea4a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 10/02/2019 10:18:47\n", + "{'0': 282, '1': 718}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute test using device noise simulation (DNS)\n", + "\n", + "backend_noise = Aer.get_backend('qasm_simulator') # for simulation (DNS)\n", + "\n", + "shots = 1000\n", + "mode = \"DNS\"\n", + "job_noise = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + "job_monitor(job_noise)\n", + "\n", + "print(job_noise.status)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "noisy_count = job_noise.result().get_counts(qprog) \n", + "print(noisy_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(noisy_count, color=['cyan'],\n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity in device noise simulation (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2f59dbc091124a85ab97e057c39613ed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job has successfully run

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 10:18:51\n", + "Tomography 1-qubit QNN on qasm_simulator , shots: 1000 , mode: DNS of ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.8969037947087841\n" + ] + } + ], + "source": [ + "# Execute state tomography using device noise simulation (DNS)\n", + "\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'. \n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "backend_tomo = Aer.get_backend('qasm_simulator') # for simulation\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "mode = \"DNS\"\n", + "my_state_job = execute(my_state_tomo_circuits, backend_tomo, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + "job_monitor(my_state_job)\n", + "my_state_tomo_result = my_state_job.result() \n", + "\n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit QNN on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, \"of\", device, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the algorithm on superconducting quantum computing device (SQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "55ddd53def4b48c588550d1a5dbdf1db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 10/02/2019 11:34:17\n", + "{'0': 309, '1': 715}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute test using superconducting quantum computing device (SQC)\n", + "\n", + "#Choose the backend\n", + "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", + "backend_SQC = device # for a real device\n", + "\n", + "# Execute on SQC and get counts\n", + "shots = 1000\n", + "if backend_SQC.name() == \"qasm_simulator\" : # optional test before final experiment \n", + " mode = \"DNS\"\n", + " job_real = execute(qprog, backend_SQC, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + "else: # final experiment on real device\n", + " mode = \"SQC\"\n", + " job_real = execute(qprog, backend_SQC)\n", + " job_monitor(job_real)\n", + "\n", + "print(job_real.status)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "real_count = job_real.result().get_counts(qprog) \n", + "print(real_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(real_count, color=['orange'], \n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### State tomography and quantum fidelity on superconducting quantum computing device (SQC)" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "795f7379498d410c8f29c9757183ae9b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 07/02/2019 22:32:13\n", + "Tomography 1-qubit classifier on ibmq_16_melbourne , shots: 1000 , mode: SQC ibmq_16_melbourne theta: 2.987977895799584 phi: 0.7898055544158503\n", + "Fidelity with theoretical ideal state\n", + "F = 0.8859731304253138\n" + ] + } + ], + "source": [ + "# Execute state tomography on superconducting quantum computing device (SQC)\n", + "mode = \"SQC\"\n", + "# obtain the final state vector\n", + "backend_stvct = Aer.get_backend('statevector_simulator')\n", + "job = execute(my_state, backend_stvct)\n", + "my_state_psi = job.result().get_statevector(my_state)\n", + "\n", + "# construct state tomography set for measurement of qubits [0, ..., n-1] in the Pauli basis\n", + "qubit_set = []\n", + "for i in range(0,n) :\n", + " qubit_set.append(i)\n", + "\n", + "my_state_tomo_set = tomo.state_tomography_set(qubit_set) # default value for meas_basis ='Pauli'.\n", + "\n", + "# add the state tomography measurement circuits to the Quantum Program\n", + "my_state_tomo_circuits = tomo.create_tomography_circuits(my_state, qr, cr, my_state_tomo_set)\n", + "\n", + "#Choose the backend\n", + "#backend_tomo = Aer.get_backend('qasm_simulator') # optional test before final experiment\n", + "backend_tomo = device # for real device\n", + "\n", + "# take 1024 shots for each measurement basis\n", + "# note: reduce this number for larger number of qubits\n", + "shots = 1000\n", + "\n", + "# loop: 27 circuits maximum per job to avoid exceeding the allowed limit for the real device. \n", + "n_circ = 3**n\n", + "i_max = min(27,n_circ)\n", + "my_jobs = []\n", + "index_job = -1\n", + "for i in range(0,n_circ,i_max) :\n", + " circs =[]\n", + " for j in range(i, i+i_max):\n", + " circs.append(my_state_tomo_circuits[j])\n", + " if backend_tomo.name() == \"qasm_simulator\" : # optional test before final experiment\n", + " mode = \"DNS\"\n", + " my_state_job = execute(circs, backend_tomo, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates)\n", + " else: # final experiment on real device\n", + " mode = \"SQC\" \n", + " my_state_job = execute(circs, backend_tomo, shots=shots)\n", + " my_jobs.append(my_state_job)\n", + " index_job = index_job + 1 \n", + " job_monitor(my_jobs[index_job], monitor_async = True)\n", + " \n", + " my_state_new_result = my_state_job.result()\n", + " if i == 0:\n", + " my_state_tomo_result = my_state_new_result\n", + " else:\n", + " my_state_tomo_result = my_state_tomo_result + my_state_new_result\n", + "\n", + "# extract tomography data from results\n", + "my_state_tomo_data = tomo.tomography_data(my_state_tomo_result, my_state.name, my_state_tomo_set)\n", + "\n", + "# Quantum fidelity\n", + "\n", + "# reconstruct experimentally measured density matrix \n", + "rho_fit = tomo.fit_tomography_data(my_state_tomo_data)\n", + "\n", + "# calculate fidelity of fitted state:\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print('Tomography',str(n)+'-qubit classifier on', backend_tomo,\n", + " \", shots:\", shots, \", mode:\", mode, device, \"theta:\", theta, 'phi:', phi)\n", + "F_fit = state_fidelity(rho_fit, my_state_psi)\n", + "print('Fidelity with theoretical ideal state')\n", + "print('F =', F_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing NFS, DNS and SQC\n", + "The results obtained above for the NFS, DNS and SQC experiments are illustrated together in the next graphs:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Histograms\n", + "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments using Qiskit 0.7." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "device_name = device.name()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# !!! Skip this cell if you want to see the results for a new run of the program\n", + "#Date (DMY): 07/02/2019\n", + "device_name = \"ibm_16_melbourne\"\n", + "noisefree_count = {'1': 721, '0': 279}\n", + "noisy_count = {'1': 711, '0': 289}\n", + "real_count = {'1': 695, '0': 305}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqkAAAFCCAYAAADSTUQbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XlcVNX7B/DPcWaAAWZgBpFNFllEWWRxycxcKPc1pTAVK9es1Bbr65ZmqZlr+bUsLZdcUhO01K/lgku2GgIKKgrIIpvIsA/rzPn9MTP8BhgEEoH0eb9evpp777nnPvfe0Z4595xzGecchBBCCCGEtCXtWjsAQgghhBBCaqMklRBCCCGEtDmUpBJCCCGEkDaHklRCCCGEENLmUJJKCCGEEELaHEpSCSGEEEJIm0NJKvlXYIydY4xNr2ebE2OsmDEmaOm4WhNjbBJj7KTeMmeMubdmTG0dY2wnY2yF9vMAxtid1o6JEEKIYZSkkkZjjL3BGPubMVbOGNvZ2vHocM5TOefmnHMVcP+EVocxZswY+5gxlsoYK2WM3WKMzWeMMb0y5xhjZYwxR711zzLGkvWWkxlj2YwxM7110xlj55rzHA3hnO/lnA9+2MdpCsbYR4yxq4yxKsbYBwa2WzPG9jHG8hljeYyxva0QJiGEkH8BSlJJU2QAWAFge2sH0gy+B/AMgOEAJABCAcwCsL5WuRIA7zdQlxDAvOYO8F8qAcB7AI7Xsz0cQBYAZwAdAKxrobhaDdOgf2sJIaSJ6B9O0mic83DO+REAuf9kf8bYIMbYDcZYAWNsM2PsvK7FkzH2AWNsj15ZF+3ja6FeFW6Msb+0+//AGJPXLssYWwngaQCbtV0ANhuI4xkAgwGM55zHcs6rOOd/AJgMYB5jzFWv+CYALzbwGH0tgPmMMctGXofRjLE4bWviOcZYV71tydoW3Sva8zzAGDOpp56XGWMXa60ezhhLYozdY4yt1SVH2rK/MsY2ao+bxBjro12fxhi7yxh7Sa9uK8bYj4yxQu01/8jAsergnO/inJ8AUGQg3sEAHAG8yzkv4JxXcs6jGnG9zjHGVjDGftPe06Pa+PZq47vEGHPRK9+FMXaKMaZgjMUzxl5ooP5F2uuVzBibpLfegjH2LWMshzGWwhhbonc97/t91ca8kjH2KwAlAFftuo+096GIMXaSMdZer47e2nPMZ4zFMMYGNHRtCCHkUUZJKmkR2v8ZhwFYAqA9gEQATzWxmikApgKwB1AFTQJZA+d8MYBfALyh7QLwhoF6BgH4k3OeVmvfPwHcgaaFVScdwDYAH9wnrr8BnAMwv6ETYIx1BvAdgDcBWAP4H4CjjDEjvWIvABgKoBOAbgBebqhePc8B6AEgEMAYaK6XzhMArgCwArAPwH4APQG4Q5Ogb2aMmWvLfg6gDICdtg79ev6p3gDiAexijOVqk8v+jdx3AjSt3Q4A3AD8DmAHADmA6wCWAQDTdLs4Bc35dQDwIoAvGGPe9dRrC8330QHASwC2MsY8tdv+C8ACgCuA/tB8/15p9Nlq4p0JTUt9inbdRG0dHQAYQfudYYw5QNP6vEJ7TvMBhDHGrJtwPEIIeaRQkkpaynAA1zjnhzjnlQA+heaxb1Ps1rZ86h7Bv8D+2WCp9gAy69mWCU3yqO9jAKPuk+gAwFIAcxqRVIQAOM45P6W9DusAiAH00SuziXOewTlXADgKwL+BOvV9wjlXcM5TobnGL+ptu80536Htu3sAmlbNDznn5ZzzkwAqALhrr+l4AEs55yWc81gAu5oQQ306QtOCfRaa5HA9gB/0WxPvYwfnPJFzXgDgBIBEzvlpznkVNF03ArTlRgJI1p5nFef8MjQ/joLvU/f72mtwHppEUfe9CgGwkHNexDlP1sYb2oTz3ck5j9PGUal3Hjc556UADuL/7+1kAP/jnP+Pc67mnJ+C5sfP8CYcjxBCHimUpJJmwRg7oX0UW6z/yFSPPYDqlkvOOddfbiT98ikARNAknE11D5oWQkPsAOTor+Cc5wDYDODD+irUJnLHACxo4Nj2+P9WNXDO1dCcl4NeGf3kXQnAHI1X+xrZ6y1n630u1R6/9jpzaJJ0oYG6HlQpNAnkN9pH/fu1x2hMi3rtOA3FDWj6uj6hfWSezxjLBzAJmqTYkDztjx4d3TVrD01LZ0qtbfr3qSGGvt/13VtnAM/Xirsv6v+eEkLII4+SVNIsOOfDtI/XzTnnhkZsZ0LTcgdAM5hEfxmaAUqmesuGkgr98k4AKqFJOOuE00C4p6FJZPTrA2Osl7beCwb2WQtgIIDu96l3GYAZuH8ikwFNQqI7pu46pDcQc2PVvkYZ/6COHGi6U9Su60FdQcP35kGlATjPObfU+2POOZ9dT3kZ05uZAf9/ze5B8/1yrrVNd58a831tyrmmQfOkQD9uM8756ibUQQghjxRKUkmjaQcmmQAQABAwxkxYzYFN93McgDdjbJx2n7mo+T/2aAD9mGbOUwsACw3UMZkx5sUYM4WmVfOQbtqpWrKh6UdoEOf8NIAz0PT582aMCRhjvQHsBfAt5zzewD750Dzufe8+9SZA8xh9bn1loHnEO4Ix9gxjTATgHQDlAH67zz5N8S5jTKZNwOdp42kS7TUNB/ABY8yUMeYFTX/NBjHGRNrvSDsAQu13RNcl4zA0SeFL2mseDE1C/2tTY7yPYwA6M8ZCtbGIGGM9md7gNAOWM8aMGGNPQ9Nd4HvtNTgIYCVjTMIYcwbwNgDdYKnGfF+bYg80XUqGaK+NCdPM49rxAeslhJB/LUpSSVMsgebR6gJo+tCVatc1iHN+D8DzAFZDMzuAB/SSE20fvAPQtLZFQpNs1LYbwE5oHpmaoP5k8DMAwUwzD2edwVVa46HpG/kTNAOEftd+nnmf0/gMgKGkWN+HAMzq26hNgCdDMyjnHoBRAEZxzisaqLexfoDm+kVD88Pgm39YzxvQPIrOguaa72jkftug+V68CGCx9nMoAGj72I6GZlBQATTfozHa70az4JwXQdPvdQI0LaJZAD4BYFzPLlkA8rRl9wJ4lXN+Q7ttDjQtpkkALkIzGGu79jiN+b42Je40aAa6LYKmJTsNwLugf6MJIY8xpukaSEjLY5oJ7/dwzr9uA7HsgqZVb3gzJoyPDMbYywCmc877tnYshBBCHg/0K50QjenQTF0U2NqBEEIIIUQzgpeQx552iqBPWjuOtk7bb/OEoW2c86bMQlC73uJ6Ng3jnP/yT+slhBDy70WP+wkhhBBCSJtDj/sJIYQQQkibQ0kqIYQQQghpcx7ZPqlWVlbcyak55h8nhBDyqIiOjr7HOa9+fXFkZGQHoVD4NQAfUMMNIS2JM8YKVCrVDrVavaV79+51ZtZ5ZJNUJycnREREtHYYhBBC2hC5XF7jFb9CofBrW1vbrtbW1nnt2rWjQRqEtBDOOSoqKkQZGRlzCgsLA2HgpTH0q5EQQsjjzMfa2rqQElRCWhZjDMbGxpXOzs4FAAzOwU1JKiGEkMdZO0pQCWk92r9/AoPbWjgWQgghhBBCGkRJKiGEEELw+uuvO3z44YcdmqOuW7duGZmamgZUVVU1R3XVvv32W0tbW9tupqamAb/++qu4WStvAnd3d+9jx45Jmrve+Ph4I8ZY98rKyn+0/4IFC2xDQkKcHzSOP//8UxwQENDlQet5UI/swClCCCHkn1jOlnd/mPUv48siG1POwcHBt6ysrN3t27evSqVSNQBs2LCh/f79+63++uuveABgjHU3MTFRM8YAAAKBgBcVFUUDmoRl9+7d1nl5eUKJRKLq0aNH8fHjx5MMHSsjI0P4/fffWyUlJV0FgGPHjklGjRrVefLkyTm7d+9O1ZXr3r2750svvXRv7ty5ufeL3cPDo0KpVEY15jybYvHixR3XrVuXOnny5PzmrrspEhIS4lrz+IDmHk2bNq1Tdnb2Fd261atXZzVH3U888USpVCqt2rdvn8XEiRMLmqPOf4JaUgkhreb06dPo1asXunfvjk8//bTO9kWLFqFfv37o168fevbsCRcXlxrbCwsL4e3tjffee696XVhYGJ566in07dsXwcHByM297/9LCWnTVCoVW7Vq1X1bNy9dunRNqVRGKZXKKF2C+t///tfq4MGDVidPnrypVCqjLl26dG3gwIGF9dWxZcsWq6CgoAJzc/Pq/rlisVgdHh5uFR8fb9R8Z/RgMjMzjf39/UsNbfunrY/EsAkTJii2bdtm3XDJh6fFk1TG2GuMsduMsTLGWKT2XeD3Kz+RMRbNGFMyxrIYY3sYY7YtFS8h5OFQqVR47733cPDgQfz+++8ICwvDjRs3apRZtWoVLly4gAsXLmDGjBkYOXJkne19+vSpXq6qqsLChQvx448/4uLFi/D29sa2bdta5HwIeRhee+21rC1bttjeu3fP4MCS+ly6dMlswIABhd7e3uUA4OTkVDV//vx79ZU/deqURb9+/Yr010kkElVwcPC9xYsX2xvaR/t32M7e3t5XLpf7Pffccy65ubkCoO5j602bNll17NjR18zMLMDBwcF3y5Ytcl09n376qZWrq6u3VCr179u3r8fNmzfrJMWlpaXM1NQ0QKVSoWfPnl6Ojo4+gKa1efHixbadO3f2MjMzC6ysrERycrJoyJAhbjKZzM/BwcF3xYoV1Um+SqXCokWLbB0dHX0sLS39hw8f7pqdnW3w2mZmZgoHDhzoLpFI/C0sLPy7d+/uqVKpoDvukSNHJADw9ttv2w8bNsx1zJgxnczMzAI6d+7sdeXKFeOFCxfayuVyP1tb227h4eFSXb36++r2HzNmTCdDMXz22WdWrq6u3mZmZgEdO3b0Xbt2bXsAKCwsbBccHOyRk5MjMjU1DTA1NQ1ITk4W1a5r7969Fu7u7t4SicS/V69enpcvXzbRj2Pp0qU2nTt39pJIJP4jRoxwVSqVTLd96NChRb///ru0tLSUoZW0aJLKGAsB8BmAVQACAPwG4ARjzOCs+4yxpwDsBrALgDeAsQC8AOxtkYAJIQ9NZGQkOnXqBBcXFxgZGWHcuHE4ceJEveXDwsIwfvz46uXo6Gjk5ORg4MCB1es45+CcQ6lUgnOOoqIi2NrSb1ry79WrV6+SJ554oujDDz+0acp+vXv3Lg4LC7N6//33bS5cuGDaUN/Q+Ph4sbe3d1nt9R999FHmTz/9JIuJiTGuve2///2v1f79+61Onz4df/v27aslJSWCadOm1fn/eWFhYbtFixY5HT9+/GZJSUnUb7/9dqNnz55KANi9e7flhg0b7A4dOpSYm5sb3adPn+KQkBDX2nWIxWKu6z5w6dKla2lpabG6bWFhYfL//e9/txQKRVS7du0wYsQId19fX2VmZuaVU6dOxX/55Zc2YWFhUgBYuXJlh+PHj1ueO3cuPjMzM8bS0lI1ffp0gznIihUrbOzs7Cru3bsXc/fu3ZiVK1em67pV1BYREWE5ZcqU3Pz8/Chvb2/lsGHDOqvVamRmZl559913M+bMmfOP+ona2NhUHT16NKGoqCjqq6++ur106VLHixcvmkqlUvWhQ4duWVtbV+pa0V1cXGo0JV+5csV4+vTprmvXrk27d+9ezODBg/PHjh3rXlZWVn0Shw8flp88efJWQkLC1evXr4s3b97cXretU6dOlUKhkF+5csUEraSlW1LfBrCTc76Nc36dcz4HQCaA2fWUfxLAHc75Rs75bc75HwD+C+CJFoqXEPKQZGZmwsHBoXrZ3t4emZmZBsumpaUhNTUV/fr1AwCo1Wq8//77WL58eY1yIpEI69atw1NPPQUvLy/Ex8cjNDT04Z0EIS1g5cqV6Tt27OiQkZFhcBxJ7969vSQSib9EIvF/+eWXHQHgtddeU6xevTr1zJkzFkOGDPFs3769/6JFi+r9xVZUVCTQ9XvV5+TkVDV58uScRYsWOdTeduDAAavXXnst28vLq8LCwkK9du3aO8eOHZMZeuzOGONRUVHi4uJi5uzsXNmjR48yANi2bZv1W2+9lRUYGFgmEonw8ccfZ964cUNsqDW1Pq+++mq2u7t7pbm5OT9//ryZQqEQrlu3LtPExIR7eXlVhIaG5nz33XdyANi5c6f1hx9+mO7m5lYpFov5xx9/nHHixAmDMYtEIp6dnS26deuWkbGxMR86dGhxu3aG06bu3bsXjR8/vlAkEuH555/Py8vLE65cuTLL2NiYT506VZGRkWHU1NZwAJgwYUKBt7d3uTb5Ln7qqacKz549a96YfXfv3i0fOHBgwXPPPVdobGzMly9fnl1WVtbu9OnT1fvPnj0728XFpdLGxkY1ePDggujo6BqD0UxNTVUKhaLJcTeXFktSGWNGALoDOFlr00kAferuAQD4FYAdY2wU02gPYAKA/z28SAkhLYHzulNT1tdKER4ejtGjR0Mg0Pxb+c0332DQoEHo2LFjjXKVlZXYsWMHzp8/j2vXrsHb2xsbN25s/uAJaUE9e/YsGzhwYMGyZcsMJpl//PHHtaKiouiioqLonTt3punWz549W/Hbb7/dzM/Pj96wYUPK2rVr7XUtirVJpVJVYWGhwZzggw8+yLxw4YL0999/r5HAZGdni1xcXKpfZenh4VGhUqnYnTt3RLXqVu/cuTNp69at1nZ2dn4DBgxwj4qKMgGA9PR0o8WLFzvqkmxLS0t/zjlLSUmpUcf9ODs7V2eYSUlJRjk5OUa6+iQSif+mTZvscnJyhACQmZlpNGnSJHfdNh8fH2+BQIDaMQPAsmXLslxdXcuHDh3auWPHjr73S/Ktra2rm6pNTU3VMpmsSijU/KYwNzdXA0BBQUGTc66DBw9K/fz8ulhYWPhLJBL/8+fPW9y7d69Rg94zMjJEjo6O1fdHIBDAzs6uIi0trfpc7e3tq6+dqampuqSkpEZCqlQqBXK5XNXUuJtLS47ubw/NZK3ZtdZnA3jW0A6c898ZYy9C83hfDE28p2Dg1VkAwBibCWAmANjZ2eHy5csANC00pqamSEhIAABYWFjA1dUVUVGagYcCgQB+fn6Ij49HSUkJAKBr165QKBTIztaE27FjRxgZGSEpSTMwUiaTwcnJCTExMQA0LTi+vr64fv06Sks1fbq9vLyQk5ODnJwcAICzszMYY0hOTgYAWFlZwc7ODrGxmqcWxsbG8Pb2RlxcHMrLywEAPj4+yMzMrB784eLiAs45UlI0b/aztraGtbU1rl27BgAQi8Xo2rUrrl69Wt2J3M/PD6mpqcjLywMAuLq6oqKiAnfu3AEA2NjYQC6X4/r16wAAMzMzeHp6IiYmBrr+NwEBAUhKSkJBgWaQn7u7O5RKJTIyMqC73lKpFPHx8QAAiUQCDw8PREVFgXMOxhgCAgJw69YtFBVpuj15enqisLCwuvWM7tPjdZ+kUimuX7+Oy5cvQyaT4c6dO1CpVLh8+XKd+7Rnzx5s2LABaWlpyMnJwc8//4zr169j27ZtKCoqQlVVFaqqqhASEoKioiLk5eVBqVRi7NixWLFiBYKCgug+0d8nVFTUeTX4v8aqVasyevfu7TVr1qwmj97WtublbdiwwfbKlSvi8ePH1xlA1aVLl9Jr166Z9O/fX1l7m62trWrGjBl3Fy9eXKM11cbGpjI5Obm6xTMhIcFIIBDwjh07ViYlJdVoCR0/fnzh+PHjC4uLi9lbb73lMH36dOfIyMh4Ozu7ivnz52fOnj1b0dTz0mGMVf/idXFxqXBwcChPSUmJNVTWxsamcuvWrbcHDx5c0lC9MplMvW3btjsA7vz9998mgwcP9nziiSdKxowZU9TQvvcjFovVJSUl1QlrVlaWwVystLSUvfTSS25ffPFF8sSJE/ONjY35s88+66b7ga9/3obY29tXxsXFVf+w0HY/MHJ0dGzUCLPk5GRRZWUl69atW51uIC2lNaagqn1RmYF1mg2MeQHYBOAjAD8DsAOwFsBXAKbUqZjzrQC2AkBAQAAPDAyssb2hZU9PzxrLDg4ONR5HNqaOrl271lh2dHSEo6NjjXVyubzGcu06vL29ayw7OzvD2blmdxYrK6v71uHr61tjuVOnTujUqWa/7A4dag4YrV2Hn59fjWU3N7cay1KptE5/v9p1BAQE1Fj28PCosWxmZgY7O7v71kH36dG8T/369cM777xTnbQcOXIEW7durXFvunbtilu3bqGiogJ9+/YFYwyOjo44dOhQdZl9+/YhOjoaa9asQWZmJjIyMuDk5IT27dtj5cqVCAwMrBEb3afH++/Tv5WPj0/5yJEjFd98841N586dDY5u17dp0yarDh06VA0ZMqRIKpWqw8LCpAkJCeI+ffoYTM4GDx5ccOHCBUl9yeKSJUuy3NzcfDnn1Y87nn/+ecVnn31mO3bs2AI7O7uq9957z2HEiBF5IlHNRsm0tDThhQsXzEaNGlVkZmamNjc3V+ueisycOTPno48+cujZs6eyR48eZbm5uYIffvhBOnXq1LymXB+dAQMGlJibm6sWL15su3DhwmwTExMeFRVlolQq2/Xv31/5yiuv3F2yZElHFxeX2507d67IyMgQRkREmBua0uq7776z8PX1LfPy8iq3tLRUCQQCrov7QXh5eSn3798vDw4OLvzzzz/FJ06ckPXr16/OD4eysjJWUVHRrkOHDpUikYgfPHhQ+uuvv0q9vLxKAcDe3r6qoKBAmJubK7CysqrT2jl58mRF7969vX744QfJ0KFDi1euXNnByMiIP/vss8WNifOnn36S9O7du1AsFrfaG9laMkm9B0AFoHZzeQfUbV3VWQjgL875Wu3yFcZYCYBfGGOLOedp9exHCGnjhEIh1qxZg+DgYKhUKkyaNAldu3bFqlWrEBAQgGHDhgHQDJgaN25cvV0B9NnZ2eG9997DiBEjIBKJ4OjoiM8///xhnwohLWLFihUZhw8ftmq4JGBhYaFas2aN3cyZMzup1Wpmb29fvmbNmpQhQ4YYTFBmzZqV6+/v71VcXMz0p6HSkcvl6tdffz1r5cqV1X1s5s2bdy8jI0M0YMCALuXl5axfv36FX3/9dWrtfdVqNfv0009tX3311U4A0LVr19ItW7akAMCUKVPyi4qK2k2cONE1IyPD2NzcXPX0008X/tMkVSgU4vjx4wlz5szp6OLi0q2iooJ16tSpbPny5ekAsGTJkrucczZ48ODOOTk5IrlcXjlmzJg8Q0nqzZs3jefPn++kUCiEUqlU9fLLL+eMHDnygVpRAWD16tXpEyZMcJXJZP69evUqGjNmjCIvL69OPiaTydQrVqxInTJliltFRQV75plnCp555pnqOUsDAgLKRo0apXBzc/NVqVS4evVqjblb/fz8yr/66qvbb7/9ttPkyZNFXbp0KT1y5MgtExOTRiWd+/fvl8+cOTPnQc/3QTBD/cIe2sEY+xNADOd8pt66mwDCOOcLDZQPA8A558F6656EZlYAZ855nb8MOgEBATwiIqJZ4yeEEPLvJpfLIznnPXTLMTExyX5+fvVOzfQ4eeONNxw6dOhQuXTp0rutHQtpXX/99Zd45syZztHR0TcaLv3gYmJi2vv5+bnUXt/Sj/s3ANjNGPsLmkFRrwKwB/AlADDGvgUAzrnuUf5RANsYY7Px/4/7PwVw+X4JKiGEEEKaZvPmzemtHQNpG3r16lXaUgnq/bToFFSc8wMA3gSwBEA0gL4AhnPOU7RFnLR/dOV3QjNt1RsAYgEcAnALwJiWi5oQQu7vQd6cFRwcDBcXF0yYMKHGPufPn8eAAQPQr18/DBs2rHrwEiGEPC5afOAU5/wLAF/Us22AgXX/hWZuVEIIaXN0b84KDw+Hvb09nnnmGQwdOhRdunSpLrNq1arqz1u3bsWVK9Wv2sacOXNQWlqKnTt31qh3/vz52LNnDzw9PfHNN99g/fr11L+WEPJYafHXohJCyKPkQd+c1b9/f5ib152bmzFWPb1UYWEhvTmLEPLYaY0pqAgh5JFh6M1ZkZGRBsvWfnPW/Xz22WcICQmBiYkJJBIJTp6s/R4UQgh5tFFLKiGEPIAHeXPW/WzZsgUHDhxAXFwcJk6ciCVLljxwrIQQ8m9CSSohhDwAe3t7pKf//6DojIyMeh/Nh4eHY9y4cQ3Wee/ePcTGxqJHD81MSePGjcNff/3VPAETQsi/BCWphBDyAAIDA5GUlISUlBRUVFQgPDwcQ4cOrVPu1q1byM/PR69evRqs09LSEoWFhdWvND179iw6d+7c7LETQkhbRkkqIYQ8AP03Z/Xu3Rtjx46tfnOW/gCq+t6cNXz4cLzyyiu4cOECvL29cebMGQiFQnz66ad46aWX8PTTT+PgwYP48MMPW+R8GppOCwAOHz6M3r1748knn8SMGTOq13/wwQfo06cP+vTpg/Dw8Or1NJ3Wv0tGRobQxcXFR6lUNvyat2ZgamoacO3aNaOWOFZjtGQ8EydOdHr33XftGi7ZdA4ODr5HjhyR/JN9f/rpJ3MXFxefB42htLSUderUyTs9Pf0fjYFq0TdOtSR64xQhhDSNSqVCz549a0yntW3bthrTaSUmJmLq1Kn44YcfYGlpiZycHFhbW+PkyZPYsmULvv/+e5SXl2PUqFE4cuQIpFIpevbsWWM6rcuXL7fadFqNeeMUA7o/zBg4YHhkXS0ODg6+ubm5IoFAwNu1a8fd3d3LXnzxxdx33nknR9evefz48S7h4eFWERER1wcOHKgEgNjYWGNfX18fznkkAPz9998m8+bNc7x69aoZ5xxOTk7lS5cuzQgJCSkwdNwZM2Z0tLa2rlq1alUWAPTq1cszJibGTCgUcsYYnJ2dy8aMGZP3/vvvZ7fme93J/Tk4OPh+/vnnyWPHjm3wVa6Mse5Xr16N9fHxKW/uOJYsWWKTnZ0t2rZt2536ytT3xilqSSWEEAKgcdNpffvtt5g2bRosLS0BANbW1gCAGzdu4KmnnoJQKISZmVl1qzBA02k9iP37998qKSmJSk5Ovjp//vzMzz77zDYkJMRFv4yFhYVqyZIlDvVUgbFjx3oEBQUV3r17NyYnJydm48aNqZaWlipDZUtLS9mhQ4espk2blqu//uOPP04tKSmJysjIiPnkk0/uhIeHy4OCgjzUanWznCd5dL3yyiuKQ4fIVC3cAAAgAElEQVQOWZWWlja5ZZ6SVEIIIQAMT6eVmZlZo0xiYiISExMxdOhQDBo0CKdPnwYA+Pj44PTp01AqlcjNzcXFixerB5TpptPy9vbGgQMHMG/evJY7qUeElZWVatKkSQV79uxJDA8Pt7p06ZKJbltwcPC9+Ph40+PHj9eZcDczM1OYnp5uNG/evHsmJibcxMSEDx48uGTIkCHFho5z7tw5M4lEonJzc6s0tF0qlapHjhxZdPTo0YTo6GizAwcOWACaVvhFixbZOjo6+lhaWvoPHz7cNTs7WwAATz/9tMeqVaus9evx9PT02rVrlyWgacWLjY01BoDi4mI2Y8aMjvb29r4SicS/e/funsXFxQwAzpw5YxYQENBFIpH4e3p6eh07dqzeR9kODg6+S5cutencubOXRCLxHzFihKt+94X169e3d3Jy8rGwsPAPCgpyT05OFum26cdz4MABCzc3N28zM7OADh06dFu6dKmNrtx3331n0aVLFy+JROIfEBDQ5c8//xQbikWtVmPatGmOcrncTyKR+Hfu3NlLd//Gjx/vMnfuXHsAOHbsmMTGxqbbkiVLbORyuZ+1tXW33bt3Wx44cMDCxcXFx8LCwn/BggXVv/D099Xf31AMZ8+eNfX39+8ikUj8ra2tu02ZMsWprKyMAUCPHj08AaBnz55epqamAdu2bZPVruvy5csmvXr18pRIJP7u7u7ee/futdCPIzQ01GnAgAHuZmZmAd26desSFxdnrNvu5uZWKZVKVREREWb13a/6UJJKCCEEQOOm06qqqkJSUhKOHj2Kr7/+GvPmzUNBQQGCgoIwaNAgDB06FNOnT0fPnj0hFGq6odF0Ws1n4MCBShsbm4qIiIjqBM3U1FT95ptvZi5durROa6qNjU2Vk5NT+fPPP99p9+7dlmlpafftGxgdHS12dXUtaygODw+PCm9vb+WFCxfMAWDlypUdjh8/bnnu3Ln4zMzMGEtLS9X06dOdACAkJERx6NAhK92+kZGRJhkZGUYvvPBCne4Gs2fPdoyJiTH79ddfb+Tl5UWvXr36jkAgwO3bt0Xjx4/3WLBgQWZ+fn706tWr70yePNktIyOj3vM5fPiw/OTJk7cSEhKuXr9+Xbx58+b2APDjjz9KVqxY4bBv376krKysGEdHx/Lg4GBXQ3W88cYbzp9//nlKSUlJVFxcXNzgwYOLAODixYumr7/+ussXX3yRkpeXFz116tSccePGuRtqLTx8+LD0jz/+ML9582ZsQUFB9P79+5M6dOhgsCU7NzdXVFZW1i4zM/PKggULMubOneu8Z88eeVRU1LUzZ87c2Lhxo/0/6S8rFAqxfv36NIVCEX3x4sUbFy9elKxZs8YaAP7+++94ALh06dI1pVIZNWPGjDz9fcvLy9nYsWPdg4KCCnJycmI2bNiQOnPmTNeYmJjqRPTHH3+UL1u2LCM/Pz/KxcWl/D//+U+N76Kbm1tZVFSUaZPjbuoOhBBiyCb5ptYOodnMVcxt7RBaRWOm07K3t0ePHj0gEong7OwMDw8PJCYmIjAwEO+88w7eeecdAMCMGTPg5uZmcDqt4ODgljupR1CHDh0qFQpFjcl233nnnZzPP//c5uDBg1IvL6/qfoXt2rVDRERE/PLly+0WLVrUMT093TgwMLB4x44dyb6+vnX6H+bn5wvMzc0b9Qzf1ta2Mi8vTwgAO3futN64cWOqrgX2448/znBzc/OtrKy8PWnSpLx3333X6ebNm0adO3eu2Llzp9XQoUPza/dnValU+P7779ufPXv2eqdOnSoBYNCgQSUA8PXXX1sNGDCgQNeP9rnnnitcv359SVhYmMWcOXNyYcDs2bOzXVxcKgFg8ODBBdHR0WIA2LNnjzwkJCS3b9++SgDYtGlTupWVlX98fLyRp6dnhX4dQqGQX7161aRXr15Ka2trlbW1tRIAtmzZ0j40NDQnKCioBADmzJmTu379eruIiAizESNG1GilFolEvKSkRBATE2MyYMCAksDAwHp/BAiFQr569epMoVCIqVOnKubPn+/81ltv3ZXJZOoePXqUubu7l0ZGRpp6eXlV1FeHIU8//bRS99nT07Pi5Zdfzvnll18kAO42tO/Zs2fNlEqlYOXKlVkCgQCjR48uCgoKyt+1a5fVhg0bMgBg6NChebo+0ZMmTVIsWLCgo34d5ubmqvz8/IYniK6FWlIJIYQAaNx0WsOHD8fFixcBALm5uUhISICLiwtUKhUUCgUAIC4uDnFxcRg4cCBNp/UQZGdnG8nl8hotcWKxmM+fPz/zww8/dKjdIu7m5lb57bffpqalpcXevHnziqmpqTo0NLSTobplMpmquLi4UblBZmamSCaTVWk/G02aNMldIpH4SyQSfx8fH2+BQIA7d+6IZDKZeuDAgQW7du2SA8CRI0dkkydPrpNYZmVlCcvLy5l+kq2TkpJidOLECZmufolE4h8ZGWmemZkpql1Wx97evrrLgqmpqbqkpESgPY6Rs7Nz9TEsLCzUlpaWqpSUlDp17d+/P/Gnn36ycHFx6dazZ0/P06dPmwHAnTt3jLZu3WqjH092drbozp07dVo5R48eXTR9+vS7c+fOdWrfvr3fiy++6KxQKAxeYwsLiyrdEwjdjwUHB4fq8zAxMVEXFRU1OXe7cuWK8cCBA93bt2/vZ25uHvDxxx87KBSKRjVUpqWliWxtbSv0X0Li6OhYkZGRUX29bGxsqmM0MzNTK5XKGglpcXGxoL5+0PdDSSohhBAAjZtO65lnnoFMJkPv3r0xevRoLF++HHK5HJWVlRg+fDh69+6NN998E1999RWEQmGrTqf1KDp//rzp3bt3RQMHDqzTp3Tu3Ln3ioqKBAcOHLCsb393d/fK2bNn371165bB/pMBAQGlt2/fNjG0TV9CQoLo2rVrpv369SsGNElKeHj4zaKiomjdn/Ly8su6FtEJEyYowsLC5KdPnzYrLy9vN3LkyDojzm1tbauMjY35tWvXjGtvc3R0rHjuuedy9esvLS2N0s1A0BS2trYVKSkp1ccoLCxsl5+fL3B2dq7TD7d///7KM2fOJObk5MSMHDkyb/LkyW6AJnGcO3duZu14Zs2apTB0zCVLltyNi4u7HhsbG5eYmGiyfPnyBx49aGpqqlYqldV53P26PsyaNcvZw8Oj7NatW1eLi4ujFi5cmF5f2docHR0rs7KyjFSq/88x09LSjPR/BDQkMTHRJCAgQNlwyZooSSWEEFJt0KBBuHTpEi5fvlz96H7RokUYNmwYAE0f1ZUrV+KPP/7Ar7/+ivHjxwMATExM8Mcff+CPP/7AqVOn4OvrW13nyJEj8euvv+KXX37B0aNH4eLi0uLn9W+nUCjafffddxaTJ092HTNmTG6vXr1Ka5cRiURYsGBBxubNm6vn3czJyRG89dZb9rGxscYqlQqZmZnCHTt2tPfz8zM4cKp///4lhYWFgtu3bxtsoSwqKmp3/Phx89GjR7v7+voqdf1KX3nllbtLlizpePPmTSNAkzDt2bOnOll+/vnnCzIyMoyWLl1qP2rUqDxDrwYWCAR4/vnn77399tuOycnJoqqqKpw+fdqstLSUTZs2Lff06dOWYWFh0qqqKiiVSnbs2DFJYmJivS2p9Zk0aZLiwIEDVr/99pu4tLSUzZs3z8HPz6+k9qP+srIytmXLFnlubq7A2NiYS6VStUAg4ADw6quv5uzatatDRESEmVqtRmFhYbv9+/db5OXl1cmrzp8/bxoREWFWXl7OJBKJ2tjYWN2YVyM3xN/fX3nmzBmL7OxsQWpqqvDzzz+3qa9scXGxQCqVqiwsLNRRUVEm27dv76C/3crKqurmzZt1fhwAwIABA0rEYrHq/fffty0vL2fHjh2TREREWIaGhhpMyGu7ffu2qKCgQKjrGtEUlKQSQgghbdSECRM8zMzMApydnbt98skndq+99lr2999/n1xf+ZkzZyqsra2rW7iMjY15SkqK0ZAhQzpLJJIAX19fb2NjY/XevXsN1mFiYsJfeOGF3K+//tpKf/3ChQudzMzMAmxtbf3mz5/vNGrUqLxz587d1CVbS5YsuTt8+PD8wYMHdzYzMwt44oknuvzxxx/Vo7nFYjEfOnRo3u+//y6dMmWKwT6kALBly5a0rl27lvbq1aurTCbzX7BgQUeVSgV3d/fKgwcPJqxevdrOysrK38HBodu6dets1Gp1k6c1GjNmTNHChQszQkJC3Gxtbf2Sk5ONDx48aPANE/v27bPq1KmTr7m5ecA333xjvX379tsA0K9fP+XmzZuT586d62RhYeHv5ubms2vXLitDdeTn5wteffVVZ5lM5u/s7Owrk8mqli1b1uQW4Npmz56d6+XlVerm5tbt2Wef7Txu3Lh6k8Y1a9akhYWFyc3NzQOmT5/uPHbs2Bpl33vvvYxZs2a5SCQS/6+//lqmv83ExIQfPnw44dSpUxbt27f3mzdvntOWLVtuBwQENDjADgC2b98uDw4OvvdP5tSlyfwJIc2CBk6Rf4PGTOb/uMvIyBA+9dRTnlevXr1mbm7+aCYJpEWUlpYyLy8vr4sXL8Y7ODhU1Veuvsn8aXQ/IYQQQqrZ29tX3b59O6614yD/fmKxmD/Id4ke9xNCCCGEkDaHklRCCCGEENLmUJJKCCGEEELaHOqTSgghtchlsoYL/Qso8vIaLkQIIW0UtaQSQgghhJA2h5JUQgghhBDS5lCSSgghhBBC2hxKUgkhhBBSbe3ate2nTp3q2BLHYox1j42NNfg6zsdVfHy8EWOse2VlZcOF7+Onn34yd3Fx8XmQOkpLS1mnTp2809PTW2UMEw2cIoQQQvTtY90fav0TeWRjiv3888/mCxYs6JiQkGDSrl07uLm5lW3cuDG1f//+SgBITEwUvfXWWx0vXLhgUV5eztzd3cuWLFmSERISUqCrQ61WY9WqVR127dplfefOHSOpVKoKDAwsXr58eWavXr1Kax+zrKyMrV+/3v7333+/DmgSpi5duviKxWI1AMhksqqXXnopZ9WqVQ/8Ws+2atOmTVa7du1qHxkZGd/asTyIoUOHFicnJ8c+SB1isZhPmjTp3gcffGC7bdu2O80VW2NRkkoIIY8o2Ql5a4fQbPKG1fta8keSQqFoFxwc7L5u3brUadOmKcrKytjJkyclJiYmHACys7MF/fr16/Lkk08WXblyJVYul6v27t0rmzZtmmtFRcXt0NDQfACYOnWq45kzZyw+//zzlEGDBhVXVVWxPXv2WB45csTCUJK6b98+S1dX19JOnTrVaMYrKCiIEolEuHDhgumQIUM8e/bsqXzuuecKW+ZqkNb0yiuvKHr06OG1adOmdLFY3KKvyaXH/YQQQkgbExsbawIAs2bNUgiFQpibm/Nx48YVPvHEE6UAsGrVKhtTU1P1gQMHkp2cnKrMzc35rFmzFPPmzctcuHCho1qtxtWrV413797d4dtvv00aPXp0kVgs5hKJRD179mxFfS2hJ06csOjbt29xfXH169dP6e7uXnb58mWxbl1ycrJoyJAhbjKZzM/BwcF3xYoVHXTbzp49a+rv799FIpH4W1tbd5syZYpTWVkZa8w1uHHjhlHPnj09zczMAvr06eMxZcoUpzFjxnQCgGPHjklsbGy66Zd3cHDwPXLkiKQxx2WMdV+zZo21s7Ozj1Qq9Q8NDXVSq9W4fPmyybvvvuscHR1tbmpqGiCRSPwBoFevXp4bNmxor9t/06ZNVt27d/fUr2/16tXWzs7OPmZmZgHz5s2zj4uLM/b39+9ibm4eMHz4cNf6zruqqgozZ87sKJPJ/Dp27OgbHh5uob89NzdX8MILLzhbW1t369ChQ7e5c+faV1VVobS0lEkkEv9Lly6Z6MpmZGQITUxMAtPT04W1r1FCQoJo8ODBbjKZzM/S0tJ/ypQpTrptn376qZWrq6u3VCr179u3r8fNmzeNdNvc3NwqpVKpKiIiwqwx9605UZJKCCGEtDE+Pj5lAoEA48aNczl48KA0JydHoL/93Llz0pEjR+YJBDVWIzQ0VJGenm4UFxdnfOLECamNjU3FwIEDlY097vXr18VdunQpq2/7mTNnzBISEkw8PDzKAUClUmHEiBHuvr6+yszMzCunTp2K//LLL23CwsKkACAUCrF+/fo0hUIRffHixRsXL16UrFmzxroxsUyYMMHVz8+v5N69e9Hvv/9+ZlhYmFVjz6Mxxz1x4oRFZGTk9cjIyGvHjh2ThYeHSwMDA8vWrl2b4u/vX6xUKqOKioqiG3vMkydPWkRFRV07f/789S1btthOnz7ded++fUkpKSlX4uPjxdu2bTP4aGPDhg3Wp06dsrh06dK1yMjIa0eOHKkxUXNISIiLUChEYmJibFRU1LWzZ89abNy4sb1YLOZDhw7N//bbb6uvy65du2Q9e/YscnBwqNKvo6qqCiNGjPBwdHSsSElJuZqRkREzadIkBQDs3r3bcsOGDXaHDh1KzM3Nje7Tp09xSEiIq/7+bm5uZVFRUaaNvRbNhZJUQgghpI2Ry+XqiIiIG4wxzJkzx8XOzs4/KCjIPS0tTQgAeXl5Qjs7uzoja5ycnCoBICsrS5ibmyuwtrZu0uiboqIigVQqVRmIx9/ExCTw2Wef7RIaGpozefLkfAA4f/68mUKhEK5bty7TxMSEe3l5VYSGhuZ89913cgB4+umnlc8880yJSCSCp6dnxcsvv5zzyy+/SBqK49atW0axsbFmGzZsyBCLxXzYsGHFQUFB+Y09j8Ycd8GCBVnt27dXeXh4VDz55JNFly9ffqAkbMGCBZlyuVzdo0ePMg8Pj9KgoKBCLy+vCisrK1VQUFBBfUleeHi4bPbs2Xfd3d0rbWxsVP/5z3+qW7nT0tKEFy5csNi6dWuqVCpVOzg4VL3xxhvZhw4dkgPApEmTcg8fPlyd/H7//fdWISEhdfrGnDt3zuzu3buiL7/8Mk0qlapNTU35kCFDigFg27Zt1m+99VZWYGBgmUgkwscff5x548YNsX5rqrm5uSo/P19Qu96HjfqkEkIIIW1QYGBgWVhYWDIAREVFmYSGhnZ67bXXHI8ePXpbJpNVZWZmimrvk5qaKgIAW1vbKisrK1VOTk6dMvcjlUpVhYWFdZIRhUIRzRjDRx99ZBMWFiavqKhgJiYmPCkpySgnJ8dI91gcANRqNevRo0cRAFy5csV43rx5jlevXjUrKytrp1Kp4OXl1WDLbmpqqkgikVRJpVK1bp2Tk1PFnTt3jO63n05jjuvg4FCdwIvFYnVxcfEDNdzZ29tXt16amJiobWxsatSfnZ1t8F5kZ2eLnJycKnTLbm5u5brPCQkJRlVVVczOzs5Pt45zzmxtbSsAYNSoUUUzZsxgERERZh07dqy8fv26eNKkSXVeNZecnGzk4OBQIRLVDSE9Pd1o8eLFjkuXLu2of4yUlBRR586dKwCguLhYYGlpWefHy8NGLamEEEJIGxcQEFA2ceLEe/Hx8WIA6N+/f+GxY8dkKlXNvGH37t1yGxubSi8vr/Jhw4YVZmdnG124cKHRLYReXl7K+Ph4g1NCCYVCLF++PNvY2Fite3Tu4uJS4eDgUF5UVBSt+1NSUhJ1/vz5BACYNWuWs4eHR9mtW7euFhcXRy1cuDC9MXE4OjpWFhUVCQsLC6vzlLS0tOoEVSKRqMrKyqq3VVVVQaFQVDe8/dPjAgBjdbuOmpqaqpRKZfXxsrKympT830+HDh0qU1NTq88tKSmp+vq7urpWGhkZcYVCUX19i4uLoxISEuIAQCAQYOTIkXl79uyR79ixQx4UFFQgk8nUtY/h4uJSkZGRYWRoWis7O7uK9evXp+jfw7KyssuDBg0q0ZVJTEw0CQgIaHS3keZCSSohhBDSxkRFRZksW7bMJjExUQRoBr0cOnTIKjAwsAQAFi1alF1cXNwuJCTEJTU1VahUKtlXX30l37hxo92CBQvSBQIBfH19yydPnnw3NDTU9dixY5KysjKmVCrZ1q1bZYsWLbI1dNzhw4cXXLx48b6P4+fPn5+1efNmW6VSyQYMGFBibm6uWrx4sW1xcTGrqqrCpUuXTM6fP28KaFrgpFKpysLCQh0VFWWyffv2DverW6dz584V3t7eJfPnz7cvKytjP//8s3lERISlbruPj095RUUF279/v0V5eTn7z3/+Y1dZWVmd0/zT4wKAnZ1dZVZWlpH+QCdfX9/SH3/8UVZUVNQuNjbWeO/eve3vV0dTjBs3Lu+rr77qkJiYKMrJyRGsWbOm+t44OztXPvXUUwUzZ850VCgU7VQqFeLi4oyPHz9urisTGhqqOHr0qOzQoUNWL774osFpMAYMGFBibW1d+frrr3csLCxsp1Qq2cmTJ80AYObMmTkbNmyw+/vvv00AzUCt7du3V/eLvX37tqigoEAYFBRUYqjuh4mSVEIIIaSNsbS0VF26dMnsySef7CoWiwP69OnTtUuXLqVffPFFGgDY2tqqLly4EF9eXs58fX19pFJp4Ouvv+7yySefpL755pu5unp27NiRNn369Ltvvvmmk0wm83dxcfH94YcfZOPGjTPYv3PChAkFSUlJJsnJyfW2FIaEhBRIpVLVxo0brYVCIY4fP55w5coVsYuLSze5XO4/ffp0l7y8PAEArFmzJi0sLExubm4eMH36dOexY8c2ei6x7777LikyMtJMLpf7L1++3G7cuHHV52VlZaX65JNPUufMmeNsZ2fXzczMTG1jY1P9yPxBjjty5MgiDw+PUhsbGz+ZTOYHaH4UiEQita2trd+UKVM6jR8/vtnmRHv77bdzBgwYUNi9e3dvf39/r9GjR9d4XH/w4MHkiooK1rVrVx9LS0v/4OBgt/T09Or7ExQUVCIWi9V3794VBQcHF9Q9gqYV/NixYwlJSUnGTk5O3RwcHLrt27dPDgBTpkzJf/PNNzMnTpzoam5uHuDt7e194sSJ6hkGtm/fLg8ODr7X0tNPAQDjvMWP2SICAgJ4REREa4dByGNjk3xTa4fQbD7gy1o7hGbB9zVqpp9/heaaJ1Uul0dyznvolmNiYpL9/PzuNUvlrUihULTr3bt3l+HDh+d/+umnGQ9S17p169pfu3ZNvH379rTmiq85vP322/aJiYnGP/zww+3WjuVxUVpayry8vLwuXrwYX3vGgOYUExPT3s/Pz6X2empJJYQQQv7l5HK5+n//+98tgUDAU1NTH2hQ9Pz58++1tQSVtA6xWMxv374d9zAT1Puh0f2EEELII8Dd3b1y/fr1ma0dByHNhZJUQgghhLR5GzZseKBuDOTfhx73E0IIIYSQNoeSVEIIIY8ztVqtfnRGmBHyL6P9+2fwRQGUpBJCCHmcxebk5FhQokpIy+Kco7y8XJSSkmIJ4KKhMtQnlRBCyGOrqqpqelZW1tdZWVk+oIYbQlqSmjFWoFKpNqnV6i2GClCSSggh5LHVvXv3uwBGt3YchJC66FcjIYQQQghpcyhJJYQQQgghbQ4lqYQQQgghpM2hJJUQQgghhLQ5lKQSQgghhJA2h5JUQgghhBDS5lCSSgghhBBC2hxKUgkhhBBCSJtDSSohhBBCCGlzKEklhBBCCCFtDiWphBBCCCGkzWnxJJUx9hpj7DZjrIwxFskYe7qB8kaMsQ+1+5QzxlIZY3NbKl5CCCGEENLyhC15MMZYCIDPALwG4KL2vycYY16c89R6dvsOgCOAmQBuAbABIG6BcAkhhBBCSCtp0SQVwNsAdnLOt2mX5zDGhgKYDWBh7cKMscEAngXgxjm/p12d3BKBEkIIIYSQ1tNij/sZY0YAugM4WWvTSQB96tltLIBLAN5mjN1hjN1ijG1ijJk/xFAJIYQQQkgra8mW1PYABACya63Phqa11BBXAH0BlAMYD8ASwH8B2AMIrl2YMTYTmm4BsLOzw+XLlwEA9vb2MDU1RUJCAgDAwsICrq6uiIqKAgAIBAL4+fkhPj4eJSUlAICuXbtCoVAgO1sTbseOHWFkZISkpCQAgEwmg5OTE2JiYgAAIpEIvr6+uH79OkpLSwEAXl5eyMnJQU5ODgDA2dkZjDEkJycDAKysrGBnZ4fY2FgAgLGxMby9vREXF4fy8nIAgI+PDzIzM5GbmwsAcHFxAeccKSkpAABra2tYW1vj2rVrAACxWIyuXbvi6tWrqKysBAD4+fkhNTUVeXl5movq6oqKigrcuXMHAGBjYwO5XI7r168DAMzMzODp6YmYmBioVCoAQEBAAJKSklBQUAAAcHd3h1KpREZGBnTXWyqVIj4+HgAgkUjg4eGBqKgocM7BGENAQABu3bqFoqIiAICnpycKCwuRmZlJ9+kRuE+EPEy5ubnN8veJEPLvwTjnLXMgxuwBpAPoxzn/RW/9MgAvcs67GNjnJICnAdhyzgu06wYD+Fm7rnbCWy0gIIBHREQ081kQQuqzSb6ptUNoNh/wZa0dQrPg+1hrh9Bs8oYpmqUeuVweyTnv0SyVEUIeqpYc3X8PgAqAba31HVC3dVUnE0C6LkHVuq79r1PzhkcIIYQQQtqKFktSOecVACIBDKq1aRCA3+rZ7VcA9rX6oHbW/jeleSMkhBBCCCFtRUvPk7oBwMuMsemMsa6Msc+g6V/6JQAwxr5ljH2rV34fgFwAOxhj3oyxp6CZwuoQ5/xuC8dOCCGEEEJaSItOQcU5P8AYswKwBIAdgFgAwznnulZRp1rlixljz0IzWOoSgDwARwAsaLmoCSGEEEJIS2vpeVLBOf8CwBf1bBtgYF08gMEPOSxCCCGEENKGtPhrUQkhhBBCCGkIJamEEEIIIaTNoSSVEEIIIYS0OZSkEkIIIYSQNoeSVEIIIYQQ0uZQkkoIIYQQQtocSlIJIYQQQkibQ0kqIYQQQghpcyhJJYQQQgghbQ4lqYQQQgghpM2hJJUQQgghhLQ5lKQSQgghhJA2p0lJKmPsBcbYYGk17CQAABoPSURBVL3lpYyxO4yxnxljds0fHiGEEEIIeRw1tSX1A90HxlgggEUANgEQAVjffGERQgghhJDHmbCJ5Z0BxGs/PwfgCOd8DWPsJICfmzUyQgghhBDy2GpqS2oZAIn28zMATms/F+itJ4QQQggh5IE0tSX1FwDrGWMXAfQAEKxd3xlAWnMGRgghhBBCHl9NbUl9A0AFNMnpq5zzDO36YaDH/YQQQgghpJk0qSWVc34HwCgD699stogIIYQQQshjr8nzpDLGTBhjwYyx/zDGLLXr3Bhj8uYPjxBCCCGEPI6a1JLKGHOHZrCUOQBLAN8DyAcwW7s8vbkDJIQQQgghj5+mtqR+CuAkABsApXrrfwQwsLmCIoQQQgghj7emju7vA6A351zFGNNfnwrAvtmiIoQQQgghj7Um90mF5u1StTlBM1cqIYQQQgghD6ypSepJAG/rLXPGmBTAcgDHmy0qQgghhBDyWGvq4/63AZxljMUDMAFwAIA7gGwALzRzbIQQQggh5DHV1HlSMxhj/gBeBBAITUvsVgB7Oeel992ZEEIIIYSQRmpqSyq0yeh27R9CCCGEEEKaXYNJKmNsHICjnPNK7ed6cc7Dmy0yQgghhBDy2GpMS+ohALYA7mo/14cDEDRHUIQQQggh5PHWYJLKOW9n6DMhhBBCCCEPS5OSTsZYP8ZYncSWMSZgjPVrvrAIIYQQQsjjrKkto2cByA2st9RuI4QQQggh5IE1NUll0PQ9rc0KQMmDh0MIIYQQQkgjp6BijP2o/cgB7GGMlettFgDwAfBbM8dGCCGEEEIeU42dJzVX+18GIA+A/sT9FQAuAtjWjHERQgghhJDHWKOSVM75KwDAGEsGsI5zTo/2CSGEEELIQ9PU16Iuf1iBEEIIIYQQotOYN05dAdCfc57HGLsKwwOnAACc827NGRwhhBBCCHk8NaYlNQyAbqDU/d44RQghhBBCSLNozBunlhv6TAghhBBCyMNCrzklhBBCCCFtTmP6pN63H6o+6pNKCCGEEEKaQ2P6pFI/VEIIIYQQ0qKa1CeVEEIIIYSQlkB9UgkhhBBCSJtD86QSQgghhJA2h+ZJJYQQQgghbc7/tXf/UVKVd57H319BHDBobEXp9hfgD2yikqYJigoakRFMogxqnCQbjTOEVRONIcbZOBqYzaobDfHX6jGiJhGHGTHicQ8JExbZiILi2rDiDyBqK4Qf6yAaMSA0tM/+UU1P0zTQJdVVt7vfr3PqUPXc5976lpzCT917n+dxnlRJkiRlTmvOpO4kIo4BKhteLk0pvVW4kiRJktTZ5RVSI+Jg4CHgfOCT/2iOmcDfpZTWF7g+SZIkdUL5ju5/EDgWGAb8VcNjONAXmFLY0iRJktRZ5Xu5/1xgRErp+SZt8yPiPwNzCleWJEmSOrN8z6SuAza20L4J8FK/JEmSCiLfkPpfgTsj4vDtDQ3PJzds26OIuCoi3o6IzRFRExHDWrnfGRGxLSJezbNmSZIktTOtmcy/+QT+fYF3ImJ1w+vDgc3AoeTuWd3dsS4B7gKuAp5r+HNWRAxIKa3czX4HAY8ATze8nyRJkjqw1tyTWsgJ/CcAv0opbR9kdXVEjAKuBH60m/0eAn4NBHBRAeuRJElSBuU1mf/eiIhuQDXws2abZgOn7Wa/q4DewMXATYWoRZIkSdn2qSbz/5QOAboA7zZrfxc4p6UdIuIkYCJwakqpPiJ2+wYRMR4YD1BeXs6iRYsAqKiooEePHrz55psAHHjggfTr14/FixcD0KVLFwYOHMjy5cvZuDE3LqyyspL333+fd9/NlXvEEUfQrVs3amtrATjooIM46qijePnllwHYd999Oemkk1i6dCkff/wxAAMGDGDdunWsW7cOgKOPPpqI4J133gHg4IMPpry8nFdfzd1mu99++/G5z32O1157jS1bcivRnnjiiaxdu5b163Pj0vr06UNKiRUrVgDQq1cvevXqxeuvvw5A9+7dqays5JVXXmHr1q0ADBw4kJUrV/LBBx8A0K9fP+rq6li1ahUAhx12GGVlZSxduhSA/fffn/79+/Pyyy9TX18PQFVVFbW1tXz44YcAHHvssWzatIk1a9aw/b/3AQccwPLlywHo2bMnxx13HIsXLyalRERQVVXFG2+8wUcffQRA//792bBhA2vXrvXvqQP8PUltaf369QX5PklqPyKltOde2zvnzob+I/A14Chg36bbU0pddrNvBbAaGJ5SerZJ+0TgaymlE5r13w9YBPz3lNLUhrZJwEUppRP3VGtVVVWaO3duKz+ZpL11d9ndpS6hYCaliaUuoSDStN3/sG9PPhj9fkGOU1ZWVpNSGlyQg0lqU/mO7v8JcBm50fyfAD8E7iU3/dRVe9j3PaCe3KX7pg5l57OrAOXAAOCXDaP6twE/Bj7X8Pqv86xdkiRJ7US+IfWrwBUppV+QC5xPpZSuIXdJfuTudkwp1QE1LfQbCSxoYZfVwEnA55s87gfebHje0j6SJEnqAPK9J/Uw4PWG538BPtvw/N+An7Zi/58DUyPiRWA+cAVQQS58EhGPAKSULk0pbQV2mBM1Iv4d2JJScq5USZKkDizfkLqSXKhcSe6M5rnkzo4OBT7e084ppcci4mDgRnKX818FzksprWjoclSe9UiSJKkDyjekPgmMAF4gNyn/v0TEt8lNsH97aw6QUroPuG8X287aw76TgEmtrlaSJEntUl4hNaX0oybPfxMRq8jNcfrHlNLMQhcnSZKkzmmv5klNKb1A7qyqJEmSVDD5ju4nIgZFxCMR8VLDY2pEDGqL4iRJktQ55RVSI+IbwP8hN+jpdw2Pw4AXI+I/Fb48SZIkdUb5Xu6/GbgppXRL08aI+BHw34BHC1WYJEmSOq98L/f3Aqa30P44uZWjJEmSpL2Wb0j938BZLbSfBTyzt8VIkiRJ0IrL/RExtsnLWcCtETGY/xjVfyowFucvlSRJUoG05p7U37TQNr7h0dQ97GKSfkmSJCkfewypKaW8p6mSJEmS9oYBVJ3CnDlzGDJkCNXV1dx55507bf/lL3/J6aefzvDhwxk9ejTLli1r3HbHHXdQXV3NkCFDePrppwFYtWoV559/PqeccgpDhw7l/vvvL9pnkSSpM/g0k/l/KSLmRcR7EbEuIp6JiPPaojipEOrr67n++uuZPn06zz//PE888cQOIRTgwgsvZP78+cybN49rrrmGG2+8EYBly5YxY8YMFixYwOOPP84Pf/hD6uvr6dq1Kz/5yU9YuHAhs2fP5qGHHtrpmJIk6dPLdzL/ccCTwFvAPwD/BXgbeDIi/q7w5Ul7r6amhr59+9KnTx+6devG2LFjmTVr1g59DjjggMbnmzZtIiIAmDVrFmPHjmW//fbj6KOPpm/fvtTU1NC7d28GDhwIQM+ePTn++ONZu3Zt8T6UJEkdXL6T+f8DMCGl9D+atD0UETXkAuvDBatMKpC1a9dy+OGHN76uqKigpqZmp34PPvgg9913H3V1dTz11FON+w4ePHiHfZuH0ZUrV7JkyRKqq6vb6BNIktT55Hu5/yjg31ponwUcvfflSIWXUtqpbfuZ0qbGjRvHokWLmDRpEpMnT27Vvn/5y1+47LLLuOWWW3Y4GytJkvZOviF1JTCyhfa/BlbsfTlS4VVUVLB69erG12vWrKF379677D927Fh++9vf7nHfrVu3ctlll3HRRRfxla98pY2qlySpc8o3pP4MuCsipkTE5RHxrYh4ELijYZuUOYMGDaK2tpYVK1ZQV1fHjBkzGDVq1A593nrrrcbns2fP5phjjgFg1KhRzJgxgy1btrBixQpqa2uprq4mpcQ111zD8ccfz3e+852ifh5JkjqDvO5JTSn9IiL+HfgBuVWmAJYCX00pPVXo4lR6c+bM4YYbbqC+vp5vfvObXHvttTtsv/fee5k6dSpdu3blkEMO4Z577uHII48EYOLEicyePZtPPvmEL37xi9x66618/PHHXH755bzzzjvss88+jBo1iokTJ7bpZ+jatSu33XYbF110EfX19XzjG9+gsrKSW265haqqKkaPHs2UKVN45pln2HffffnsZz/LvffeC0BlZSVjxoxh6NChjcfp0qULL7zwAo899hgDBgxg+PDhANx0002MHNnShQZJkpSvaOmeuxY7RnQld1l/YUppfZtWVQBVVVVp7ty5pS6jXauvr+cLX/gCM2bMoKKighEjRjBlyhROOOGExj7PPvss1dXV9OjRg4cffpjnnnuOhx9+mIULFzJx4sTGy+ajR4/mxz/+MYMGDaKmpoZhw4ZRV1fHmDFj+P73v2+46wDuLru71CUUzKTUtj+ciiVN2/ne6/bqg9HvF+Q4ZWVlNSmlwXvuKanUWn25P6W0DZgB9Gy7cpQlrZm6adiwYfTo0QOAwYMHs2bNGiA3uGjLli3U1dWxZcsWtm3bRq9evejRowfDhg0DoFu3bpx88smN+0iSJG2X7z2pLwPHtkUhyp6Wpm7a3Vygjz76KOeccw4AQ4YM4YwzzqCyspLKykrOPvts+vfvv0P/Dz/8kN///veceeaZbfMBJElSu5VvSJ0ETI6IMRFxZESUNX20QX0qodZO3QQwffp0Fi9ezNVXXw1AbW0tf/zjH3n11Vd57bXXmDdvHgsWLGjsv23bNsaNG8f48ePp06dPm9QvSZLar3wn8/9tw58zgKYJJhpedylEUcqG1k7d9Ic//IHJkyczc+ZM9ttvPwBmzpzJ4MGD+cxnPgPAOeecw0svvcRpp50GwLXXXssxxxzDlVdeWYRPIkmS2pt8Q+oX26QKZVLTqZvKy8uZMWMGDzzwwA59lixZwoQJE3j88cfp1atXY/sRRxzB1KlT2bZtGyklFixYwBVXXAHAzTffzIYNG7j77o4z0EaSJBVWq0JqRPQAbgfGAPsCc4BrUkrvtWFtKrHWTN00ceJENm7cyOWXXw7kwum0adO44IILePbZZzn99NOJCEaMGMGoUaNYvXo1kydP5rjjjuOss84Ccis9XXrppSX8pJIkKWtaNQVVRNwOXAX8M/Ax8HXgDymli9u2vE/PKag6toNmdYxboAs1rU4WOAVV9jgF1c6cgkpqP1p7uX8s8PcppX8FiIh/BuZHRJeUUn2bVSdJkqROqbWj+48Ent3+IqX0IrANqGiLotq7OXPmMGTIEKqrq7nzzjt32n7vvfdy6qmncsYZZzBmzBj+9Kc/NW475JBDGD58OMOHD+frX/96Y/v48eMZMmQIp512Gt/97nfZunVrUT6LJElSKbQ2pHYB6pq1bSP/gVcdXn19Pddffz3Tp0/n+eef54knnmDZsmU79Dn55JOZO3cuzz33HOeff/4Oy4J2796defPmMW/ePKZNm9bYfvHFF7Nw4ULmz5/P5s2bmTp1atE+kyRJUrG1NmQG8GhEbGnS9lfAlIjYtL0hpXR+IYtrj5qu0gQ0rtLUdCnR7SsuQW6VpunTp+/xuE2XDR00aJCrNEmSpA6ttWdSfw2sAdY3eTwK/KlZW6e3N6s0AWzevJmzzz6bkSNHNq5739TWrVuZPn06I0aMKGzhkiRJGdKqM6kppcvbupCO4tOs0jRz5szGtiVLllBeXs4777zDBRdcwIABA+jbt2/j9uuuu46hQ4cydOjQvGsrO+igvPfJqj3PSSFJktqzfJdF1R7ku0rTtGnTGldpAigvLwegT58+nHHGGSxZsqRx209/+lPWr1/PzTff3IafQJIkqfQMqQXWdJWmuro6ZsyYwahRo3bos32VpmnTpu2wStOf//xntmzJ3fa7fv16Fi5cSP/+/QF45JFHmDt3LlOmTGGfffxrkyRJHZuj8wtsb1ZpWr58ORMmTGCfffbhk08+4Xvf+17jgKsf/OAHHHnkkZx77rkAfPnLX+b6668v2eeUJElqS4bUNjBy5MgdRuMD3HDDDY3Pn3zyyRb3O+WUU5g/f36L29atW1e4AiVJkjLO68aSJEnKHEOqJEmSMseQKkmSpMwxpEqSJClzDKmSJEnKHEf378HdZXeXuoTCSRNLXYEkSVKreCZVkiRJmWNIlSRJUuYYUiVJkpQ5hlRJkiRljiFVkiRJmWNIlSRJUuYYUiVJkpQ5hlRJkiRljiFVkiRJmWNIlSRJUuYYUiVJkpQ5hlRJkiRlTtFDakRcFRFvR8TmiKiJiGG76Ts2ImZHxLqI+CgiFkbE+cWsV5IkScVX1JAaEZcAdwG3AFXAAmBWRBy1i13OBOYCX2ro/zvgyd0FW0mSJLV/XYv8fhOAX6WUpjS8vjoiRgFXAj9q3jml9L1mTf8UEV8CxgDPtmmlkiRJKpminUmNiG5ANTC72abZwGl5HKon8EGh6pIkSVL2FPNM6iFAF+DdZu3vAue05gAR8R3gCGDqLraPB8YDlJeXs2jRIgAqKiro0aMHb775JgAHHngg/fr1Y/HixQB06dKFgQMHsnz5cjZu3AhAZWUl77//fl4fUMrXK6+8wtatWwEYOHAgK1eu5IMPcr/B+vXrR11dHatWrQLgsMMOo6ysjKVLlwKw//77079/f15++WXq6+sBqKqqora2lg8//BCAY489lk2bNrFmzRog97044IADWL58OQA9e/bkuOOOY/HixaSUiAiqqqp44403+OijjwDo378/GzZsYO3atcCuv09SW1q/fj0rVqwAoFevXvTq1YvXX38dgO7du1NZWdmq75Ok9iNSSsV5o4gKYDUwPKX0bJP2icDXUkon7GH/C8mF079NKf3PPb1fVVVVmjt37l5WDXeX3b3Xx8iKSWliqUsomDQtSl1CQXwwuuP8EPK7kj0d5XsChfuulJWV1aSUBhfkYJLaVDEHTr0H1AO9m7Ufys5nV3fQJKBe2pqAKkmSpPataCE1pVQH1AAjm20aSW6Uf4si4qvAo8C3Ukq/absKJUmSlBXFHt3/c2BqRLwIzAeuACqA+wEi4hGAlNKlDa//ltwZ1OuAeRGx/SxsXUqp41wnlSRJ0g6KGlJTSo9FxMHAjUA58CpwXkppRUOX5vOlXkGuxjsbHts9A5zVttVKkiSpVIp9JpWU0n3AfbvYdtbuXkuSJKlzKPqyqJIkSdKeGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmGFIlSZKUOYZUSZIkZY4hVZIkSZljSJUkSVLmFD2kRsRVEfF2RGyOiJqIGLaH/mc29NscEbURcUWxapUkSVJpFDWkRsQlwF3ALUAVsACYFRFH7aJ/X+B3Df2qgFuBeyLiwuJULEmSpFIo9pnUCcCvUkpTUkpLU0pXA2uBK3fR/wpgTUrp6ob+U4BfA9cVqV5JkiSVQNFCakR0A6qB2c02zQZO28VuQ1vo/3tgcETsW9gKJUmSlBXFPJN6CNAFeLdZ+7tA713s03sX/bs2HE+SJEkdUNcSvGdq9jpaaNtT/5baiYjxwPiGl38pKytb/qkqLL5DgPfa/F1iUpu/RbHEnru0E2WlLqC98buSh47zPYECfleOLtSBJLWtYobU94B6dj5reig7ny3d7v/tov82YH3zzimlB4AH9q7M4ouIl1JKg0tdh5R1flckqfMo2uX+lFIdUAOMbLZpJLnR+y15Hjinhf4vpZS2FrZCSZIkZUWxR/f/HPhWRIyLiMqIuAuoAO4HiIhHIuKRJv3vB46IiDsb+o8DvgX8rMh1S5IkqYiKek9qSumxiDgYuBEoB14FzksprWjoclSz/m9HxHnAHeSmqVoDXJNSeqKIZRdDu7tFQSoRvyuS1ElESrsbsyRJkiQVX9GXRZUkSZL2xJAqSZKkzDGkSpIkKXMMqSUUEcdFxGGlrkOSJClrHDhVZBFxKPBN4PvAOnILE6wFfgM8kVLaWMLyJEmSMsGQWmQR8StgADCT3KpZBwOfByqBVcBtKaX/VbICpYyIiAOAj5L/SElSp2RILaKICOAjcnPDzmvSdiRwCvBtcutKX5JS+r8lK1TKgIj4BfBiw2NFSmlDC30OTinttESyJKn9857U4hoAvA3UbW9IOStTSo8DXyYXYi8pUX1SJkTE18j9aJsMPAXcHhF/ExHHRET3hj7dgYci4qQSlipJaiOeSS2ihv+pzgR6AJcCb6WUPmnW52rg71NKny9BiVImRMQUoB64DRgLXAYcAywHfgc8DfQH7kopdStVnZKktuOZ1CJKKX0M/CPQHXgEuDQijoyI/QEiogdwJrnlYqVOKSK6krvi8OeUUm1K6WcppZOALwDPkAus04F7gKmlq1SS1JY8k1oCEXEicBNwPrAReJ7cSP9zyI30H5dSeqV0FUqlFREHAYellJZFRDdga9MBVBFxCfAvwCDv35akjsmQWkIN01F9CRgDbCZ3BvXxlNKykhYmZVBE7EPu36z6iPg2uUv9PUpdlySpbRhSMyIi9ml+f6qklkXEBKBLSun2UtciSWobhlRJ7U5E7AvU+8NOkjouQ6okSZIyx9H9kiRJyhxDqiRJkjLHkCpJkqTMMaRKkiQpcwypkiRJyhxDqiRJkjLn/wMiqC+zYooNhAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# NFS vs DSN vs SQC, count histograms\n", + "plot_histogram([noisefree_count, noisy_count, real_count], \n", + " title= str(n) + '- qubit QNN on ' + device_name,\n", + " color=['purple','cyan', 'orange'], bar_labels=True,\n", + " legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Quantum Fidelity" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "names = ['NFS','DNS','SQC']\n", + "legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']\n", + "\n", + "fidelities = [0.999,0.897,0.886]\n", + "plt.ylabel('Quantum Fidelity')\n", + "plt.suptitle(str(n) + '- qubit QNN on {}, '.format(device.name()))\n", + "plt.axis([-0.5,2.5,0.75,1.01])\n", + "plt.grid()\n", + "plt.scatter(names, fidelities)\n", + " \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Several functions before the next steps" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "metadata": {}, + "outputs": [], + "source": [ + "def obj_simple(angles, shots=1000, verbose=False):\n", + " \"\"\"Returns the number of zero outputs of a single training example.\"\"\"\n", + " # make the program\n", + " qprog = make_program([theta, phi], angles)\n", + " if verbose:\n", + " QASM_source = qprog.qasm()\n", + " print(QASM_source)\n", + " if mode == \"NFS\": \n", + " dist = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " dist = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " elif mode == \"SQC\": \n", + " dist = execute(qprog, backend_SQC, shots=shots)\n", + " \n", + " dist_count = dist.result().get_counts(qprog)\n", + " observable = {'1' : 1}\n", + " obj = average_data(dist_count,observable)/shots \n", + " print(\"The current value of the objective function is:\", obj, end=\"\\r\")\n", + "\n", + " return obj" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [], + "source": [ + "def make_program(pangles, uangles): # to be modified if n>1!\n", + " \"\"\"Returns a program that prepares the state according\n", + " to pangles and applies the unitary according to uangles.\n", + " \"\"\"\n", + " new_state = QuantumCircuit(qr, cr)\n", + " # desired vector\n", + " desired_vector = [np.cos(pangles[0] / 2), np.exp(1j * pangles[1]) * np.sin(pangles[0] / 2)]\n", + " qr_vector = []\n", + "\n", + " # Initialize a 1-qubit quantum state using the arbitrary method \n", + " qr_vector.append(qr[0])\n", + " new_state.initialize(desired_vector, qr_vector)\n", + " \n", + " # write the program\n", + " qprogram = new_state + unitary(uangles) + measuring \n", + " \n", + " return qprogram" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [], + "source": [ + "def obj(uangles):\n", + " \"\"\"Returns the objective function C defined above over all training data.\n", + " \n", + " Args:\n", + " uangles [type: list]\n", + " the angles in the unitary evolution.\n", + "\n", + " rtype: int\n", + " \"\"\"\n", + " # grab some training data from the overall data set\n", + " tpoints = int(train_frac * len(qdata))\n", + " tdata = qdata[:tpoints]\n", + " tlabels = labels[:tpoints]\n", + "\n", + " \n", + " # initialize a variable to store the output predictions of the neural net\n", + " predictions = np.zeros_like(tlabels, dtype=int)\n", + " \n", + " # loop over all training data to get the predictions\n", + " for i, pangles in enumerate(tdata):\n", + " # write the program\n", + " qprog = make_program(pangles, uangles)\n", + " \n", + " # run the program\n", + " shots = 1000\n", + " \n", + " if mode == \"NFS\": \n", + " out = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " out = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " elif mode == \"SQC\": \n", + " out = execute(qprog, backend_SQC, shots=shots)\n", + " \n", + " out_count = out.result().get_counts(qprog)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " p1 = average_data(out_count,observable_1)\n", + " p0 = average_data(out_count,observable_0)\n", + " \n", + " # take the prediction to be max(p0, p1)\n", + " if p0 >= p1:\n", + " predictions[i] = 0\n", + " else:\n", + " predictions[i] = 1\n", + "\n", + "# uncomment next four lines for check \n", + "# if i == 0 :\n", + "# QASM_source = qprog.qasm()\n", + "# print(QASM_source)\n", + "# print(p0,p1)\n", + " \n", + " # compute the difference of the labels and return the cost\n", + " cost = sum(abs(predictions - tlabels)) / tpoints\n", + " print(\"The current value of the cost function is:\", cost, end=\"\\r\")\n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [], + "source": [ + "def get_all_predictions(angles):\n", + " \"\"\"Returns a numpy array of all predictions.\"\"\"\n", + " # initialize a variable to store the output predictions of the neural net\n", + " zhats = np.zeros_like(labels, dtype=int)\n", + " \n", + " # loop over all data to get predictions\n", + " for i, pangles in enumerate(qdata):\n", + " # write the program\n", + " qprog = make_program(pangles, angles)\n", + " \n", + " # run the program\n", + " shots = 1000\n", + " \n", + " if mode == \"NFS\": \n", + " out = execute(qprog, backend_sim, shots=shots)\n", + " elif mode == \"DNS\":\n", + " out = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + " elif mode == \"SQC\": \n", + " out = execute(qprog, backend_SQC, shots=shots)\n", + " \n", + " out_count = out.result().get_counts(qprog)\n", + " \n", + " # get the output probabilities\n", + " observable_1 = {'1' : 1, '0' : 0}\n", + " observable_0 = {'0' : 1, '1' : 0}\n", + " p1 = average_data(out_count,observable_1)\n", + " p0 = average_data(out_count,observable_0)\n", + " \n", + " # take the prediction to be max(p0, p1)\n", + " if p0 >= p1:\n", + " zhats[i] = 0\n", + " else:\n", + " zhats[i] = 1\n", + " return zhats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing on noise free simulator (NFS)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 0.0060569999999999999\r" + ] + } + ], + "source": [ + "mode = \"NFS\"\n", + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(8.89515197858799) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(6.14308213587254) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(7.13449483997346) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgIAAAB2CAYAAAC6afsyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAGhhJREFUeJzt3XlUVOf9BvAHAWEIm4gFBTGCJlESJAiyBGSC1sGA0kiNcY22Htt4tO5FY2ubtOhoEmtiayINiShFjXHBrWMiAhE1dIgShMQkBnEhEUsFR1G28f7+8DC/jCAMODOXm/t8zvGc4b73zvvM6yzfucs7NoIgCCAiIiJZ6iF2ACIiIhIPCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYyxECAiIpIxFgLUJd9//z1CQkLg6OiI5uZmseOYpLCwEFFRUYiJicGiRYvEjmOy0tJSQ+5Zs2ZBSlf8rl+/HtHR0WLHMElFRQW8vLygVCoxZswYseN0ytatWzFq1CgolUpUVlaKHadDGo0GSqUSSqUSffv2xb59+8SOZJLbt28jISEBSqUSSUlJaGhoEDuSWbAQoC7x8PBATk4OIiIixI5isgEDBuDYsWM4fvw4rl27hrNnz4odySSPP/44Tp48iePHjwMAioqKRE5kmoaGBnzxxRdix+iUn//858jLy8PHH38sdhSTVVZWIj8/Hzk5OcjLy4OPj4/YkToUHx+PvLw85OXlwc/PD6NHjxY7kkk0Gg3Cw8ORl5eHESNGQKPRiB3JLFgIUJc4OjqiV69eYsfoFG9vbzg6OgIA7OzsYGtrK3Ii09jb2xtuOzg4oH///iKmMd17772Hl156SewYnZKbm4uYmBj87W9/EzuKyY4cOQK9Xo9Ro0Zh/vz50Ov1YkcyWXl5Oby8vODs7Cx2FJMEBAQY9gLU1taid+/eIicyDxYCJDslJSWorq7G0KFDxY5isv379+PJJ5/EtWvXJPHm09TUhPz8fMTFxYkdxWR9+/bFN998g9zcXBw9ehQlJSViRzJJVVUVGhsbkZOTAycnJ2RnZ4sdyWR79uzB888/L3YMkw0ePBiFhYUIDAxEUVERoqKixI5kFiwESFauX7+OefPmIT09XewonTJ+/HiUlpbCx8cHBw8eFDtOh7Zt24YpU6aIHaNTHBwc8Mgjj8DOzg6JiYkoLS0VO5JJ3NzcEBsbCwCIi4vDV199JXIi0x04cADjx48XO4bJMjIyoFKpUFZWhoSEBGRmZoodySxYCJBsNDc3Y9q0aXj99dfh7e0tdhyT/fiEJFdXVygUChHTmObrr7/GO++8g/j4eJSVlWHjxo1iR+rQzZs3DbdPnDiBgIAAEdOYLioqyrD3ori4GAMHDhQ5kWmuXr2Knj17SmIPVwtBEODh4QEA8PT0xI0bN0ROZB42/NEh6oqmpiaMHTsWn3/+OUJCQrB69WqEh4eLHatd27dvx+9+9zsEBgYCANasWYPIyEiRU3UsOzsb69evB3Bv12RaWhp69JBODR8dHY2CggKxY3To8OHD+OMf/wgHBwdER0dj3bp1Ykcy2dKlS1FUVARPT09kZWWhZ8+eYkfq0ObNm9HU1IR58+aJHcVktbW1mDRpEhoaGmBvb4+dO3caCgMpYyFAREQkY9L5WkFERERmx0KAiIhIxlgIEBERyRgLASIiIhljIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDLGQoCIiEjGWAgQERHJGAsBIiIiGbMTOwCJa+HChSguLrZ6v8HBwdiwYUOXthUrMyDN3FLMDEgztxQzA13PLcXMgDSfH5bEPQIyV1xcbPUXxMP2KUZmc/TLsbZevxxr6/Qrxczm2F4qfZqKewQIwcHByMvLs1p/SqXyoe/D2pkBaeaWYmZAmrmlmBl4+NxSzAxI8/lhKdwjQEREJGMsBIiIiGSMhQAREZGMsRAgk/Tr1w8KhQLOzs5wc3NDfHw8Ll++LHasDkkxtxQzA9LMLcXMgDRzSzGzXLAQoA5VVlbihx9+wOnTp3Hr1i2Ul5fj2rVrWL58udjR2iXF3FLMDEgztxQzA9LMLcXMcsJCgDqk1Wrh6uqKJ554AgDQu3dvhISEoKqqSuRk7ZNibilmBqSZW4qZAWnmlmLmtgiCgIaGBuj1+g7XvXXrFqqrq62Q6uGxEKAOabVahIWFwcbGBs3NzdBoNNi5cyemTJkidrR2STG3FDMD0swtxcyANHNLMXOLs2fPYtGiRYiIiIBCoYCjoyPs7Ozg7++PF154ATt27EBjY6PRNrdu3UJCQgLGjBmD5uZmkZKbTjbzCGzZsgVbtmzp1HWjw4cPx5o1azBmzBjLBZMArVaLgoICuLu749atW3ByckJ6ejpeeOEFsaO1S4q5pZgZkGZuKWYGpJlbipnPnz+Pl19+GUePHoWDgwMiIiIwd+5ceHp6oqGhAV9++SVOnTqFXbt2wcvLC2q1Gi+99BLq6uqQkJCAgoICZGVlwc6u+3/MirJHYMeOHYiJiYGrq2ubg9RRuzno9XosW7YMffr0gYuLC5KTk1vtxklKSkJ2drZF+peSoqIibN++HbW1tbh8+TJ8fX1x7tw5sWN1SIq5pZgZkGZuKWYGpJlbapkzMjIQFBQErVaLdevWobKyEnl5eVi/fj1eeeUVvPrqq9i1axcuXrwIjUaDQYMGYdasWXjuuecQHx9vKAImTZok9kMxiSiFQK9evTB37twHzrncUbs5qNVqZGdno7CwEFeuXAEATJ8+3WidpKQk7N+/32IZpOD8+fOoqalBSEgIAKBv375YsmQJ3n33Xdy9excAUFBQgF/96leGbSZNmoTPP/9clLwtTMnd3NyMUaNGQalUYtiwYRg+fLiYkSWZGTAt9927dxEREYGKigpcuXIFI0eONLzuumtmjrX1MnensX733Xcxc+ZMREZGoqysDMuWLUPv3r3bXLdHjx5QqVT49NNPoVarodFocOLECbz//vuSKQIACxYCH374IZ566ik4OztjzJgxWLx4MSZOnAgAUKlUmDx5Mvz9/dvctqN2c0hLS0NKSgr8/f3h5uaGdevWQaPRoKKiwrDOsGHDYGdnJ/qHmpi0Wi08PDwwYMAAw7KkpCRUVVWhoKAAABAaGoozZ84AAHJzc+Hm5ib6m6Ypue3s7JCTk4OsrCz4+/tj7969YsUFIM3MgGm5e/TogdWrV2Px4sWYPn060tPT4evrK1ZkjrUVSWmsT506hblz5yIhIQH//ve/4ePjY9J2t2/fxuHDh9GjRw/Y2Njg2LFjFk5qXhYpBDIyMrBkyRJs2rQJN27cQGJiIt5++208/fTTlugOarUaQUFBJq9/48YNXLp0yejDKiAgAK6urigpKTFad/z48bI+PKDValv9v3l6eiIqKgofffQRAMDR0RGOjo6oqanBn/70J6SmpooR1YgpuQHgwoULmDdvHjZv3gw/Pz9rxzQixcyA6bmHDRuGvLw8zJkzB4MHD7Z2TCMca+uRyljX19dj1qxZ6N+/P7KystCzZ0+Ttms5MbDlcMDKlSuxdetWHDx40MKJzUgws7q6OsHDw0M4fPiw0TIARssEQRByc3MFW1vbB95XR+2d8cEHHwixsbGCIAjCpUuXBABCeXm50Tp+fn7Ctm3bjJYdOXJECAkJMUuG7ig2NtYwLg9jwYIFQnJysrBhwwaL92muzGVlZUJycrJQU1NjlX7NkVuKmQVBEG7evCmMHj1a2Lp1qxAXF2fxfjnW1hnrn9JrccuWLQIA4dChQybfz82bN4WRI0cKPXr0EHbs2CEIgiDU19cLgwcPFsLCwsya2ZLMXggcPnxYcHd3N1pWUVEhABB++OEHo+ViFQI1NTUCAOHMmTNG67i6ugrZ2dlGy9LS0oRf/OIXZsnQHgCi/TPHk3P79u3C0KFDhaampg7XjY2N7RaZfXx8hNDQUMMLtLa2ttvnlmLm+vp64bnnnhPy8/MFQRCEGTNmCPv37+/2uTnW8notjhgxQhgyZIhw9+5dkzK3VQS02LhxowBA0Gq1Zs38MP/aY/ZT8q9du4af/exnRsuysrLg7e0Nb29vc3fXJe7u7vDz88Pp06cRHBwMACgvL4dOp2t1iGH//v1ITk62eCZBECzeR1vM9dOYBQUFePvtt02+yiM2NrbLPwFqrsxdOYFK7NxSzOzg4IBDhw4Z/s7IyDBpO7Fzc6w79lN5LdbW1uI///kP/vKXv8DGxqbD7e8/HHD/iYFTpkzB/Pnz8cknnyA0NNQsmS3J7OcIBAYG4vz588jPz0djYyOysrKgVqsNH7jAvUv36uvrDZMw1NfXo76+3vBh2FG7OcyZMwdr167FhQsXoNPpkJKSApVKhUcffdSwzu3bt5Gbm4vExESz9ftTc+XKFSQlJcHNzQ2jRo0SOw4RUaedPn0aABAWFtbhuh0VAQDg4eGBQYMGSeZEc7MXAqGhoVi5ciUmTJgAX19fFBYWIjw83OhkkW3btkGhUEClUkGv10OhUEChUODixYsmtd9v9erVCAwM7FTO5cuXY9y4cQgLC4OPjw/0ej0yMzON1jly5AiefvppeHp6dnIU5MPX1xfZ2dnd4gRBIqKuqKysBHDvpPH2mFIEtPD39xf1ss3OsMhVA6+99hr+97//4dq1a3jrrbfwzTffGBUCM2fOhHDv/ASjfy3fxjtqv98rr7yCsrKyTmW0tbXFG2+8gerqaty8eRN79uxp9YG/f/9+JCUldep+iYhIWiZPnoza2loMHDiw3fXu3LkDnU5n0mRBu3fvRm5urjljWozFJxTS6XS4ePGixS4dtKQBAwYY5j6Qo8LCQkRFRSEmJgaLFi0yaisuLsYzzzyDmJgYHD9+HABw6dIlxMXFYeTIkfjwww/FiGywaNEixMTEYMGCBUbLX3zxRSiVSkRGRhoOV7X1WKzt9u3bSEhIgFKpRFJSEhoaGgxtn3zyCSIiIvDss88aZmP7/vvvERcXh6ioKBw9elSUzC05QkJC4Ojo2GpO9ZkzZyI8PBxKpRJZWVkAgIULF0KpVEKpVKJXr15iRAYAbN261TCBTcu3QQBITU1Fv3798Ic//MFo/Tt37sDb25tj3UkajcaQoW/fvti3b5+h7f3338fAgQMxbdo0w7I1a9Zg5MiRCAsLs+pcAnZ2dnBzc4OtrW276/Xp0wdardakyYKcnZ2hUCjMFdGiLD4JcmlpKVxcXDrc5WJpwcHBmDlzZqe2+fOf/2yRLFIxYMAAHDt2DI6Ojpg6dSrOnj2Lp556CgCwatUq7Ny5Ex4eHpgwYQI0Gg3Wrl2L1NRUjBgxAmPHjsWECRNEmWf79OnTqKurw/Hjx/Hyyy8bfvAEuDd9NQDs3bvXcPyurcdibRqNBuHh4Vi1ahVSU1Oh0WgMe6Nee+015OTkQKfTYeHChdi5cyfUajX++te/IigoCImJiRg9erTVMwP3joXm5OTg+eefb7P9X//6FwYNGmT4u2W20DNnzuDNN9+0Ssb7VVZWIj8/Hzk5Oa3aZs+ejaioqFZtaWlpePLJJ60VsU1SHOv4+HjEx8cDAMLDw42ep+PHj8fIkSON3meXLl2KFStW4NatWxg9evQDH6uYpPDbAZ1l8T0CUVFR0Ol0Jp2JaUldKQTkztvbG46OjgDuPfl/XC3X1NTA19cXTk5OqKurw507d1BeXo6goCDY2trCy8sL58+fFyX3qVOnDG84o0ePxmeffdZqnb1792LChAkA2n4s1hYQEGDYC1BbW9tqStNHHnkEffv2xXfffQcAKCkpQWRkJJydneHi4oKbN29aPTNwbzKpB33btLGxwYwZMzBu3LhW5/f8ePyt7ciRI9Dr9Rg1ahTmz59v9JOyXl5erd6rGhsbUVhYiOjoaGtHNSLFsW5RXl4OLy8vODs7G5Z5enq2+lC1t7cHcG8PjNiFl5zwZ4ipQyUlJaiursbQoUMNy/r06YPS0lL897//RWlpKWpra/H4448jPz8ft2/fxmeffYaamhpR8tbW1sLV1RUA4Obm1ipHc3Mzzp49a5j7vK3HYm2DBw9GYWEhAgMDUVRUhKioKKP2qqoqnDt3Dl999RWAe1fWtHxgtfUYu4M333wTJ0+eREpKCpYsWWLUptFoDN8Ura2qqgqNjY3IycmBk5NThzOHfvDBB61+h6S76a5j3WLPnj0mf7ufO3cugoKCEBcXZ+FU1IKFALXr+vXrmDdvHtLT042Wq9VqLF68GL/97W8RFBQET09PrFixAmlpaZg4cSKeeOIJeHl5iZLZ3d0dOp0OwL1zVNzd3Y3ac3Nzja4jbuuxWFtGRgZUKhXKysqQkJBgdAXLunXr8OKLL0KtVuOZZ54BAKO9M209xu7Aw8MDABAdHY2rV68aln/77bfw8fGBk5OTKLnc3NwQGxsLAIiLizMUV21pbm7GkSNHMHbsWGvF65LuOtYtDhw4gPHjx5u07qZNm3Du3DleiWRFLATogZqbmzFt2jS8/vrrrSaDeuyxx/Dxxx8b5gW3t7eHl5cX9u3bh48++ggODg4dnoFrKZGRkYZjvEePHkVERIRR+969e42+nbT1WKxNEATDm7mnpydu3LhhaIuMjERubi5WrlyJIUOGAACCgoJw6tQp1NXVQafTGfaAdCctxdjXX39tVKjcP/7WFhUVZfhNkeLi4nafp1VVVbh8+TLi4+ORmZmJFStWdMu9L911rAHg6tWr6Nmz5wN/we/HWg6PKRSKbvmc/qn66Z31QGaza9cuaLVapKSkALh3Rm9WVhY2btyI9PR0ZGZmwsnJCX//+98BAIcOHcIbb7wBW1tbrF27VrTzQlrOrI6JicGwYcPg5+eH1NRUrFy5EoIg4NSpU4bMANp8LNY2ZcoUTJo0Cdu2bYO9vT0yMjIMmVNTU3H06FH07t0bmzdvBgD8/ve/x4wZM3Dnzh28+uqromQGgKamJowdOxZffPEFVCoVVq1ahYKCAqxcuRJTp05FTU0NbGxs8M477xi2OXjwoKg/5BUcHAyFQgGlUglPT09MnjzZMNbp6enYtGkTrl+/jpqaGvzjH/+AVqsFcO/k4ejoaNHOwJfiWANAdna20WXY8+fPx8aNG3Hw4EGo1Wp89913SE5Oxu7du7FgwQKcO3cOjY2NWLZsmYip5cVGEGtuW+oWWnaRW3Pay4ftU4zM5uiXY229fjnW1ulXipnNsb1U+jQV9wgQiouLzTZnuKn9/XjK6a7ehzUzt/QptdxSzNzSp9RySzFzS58Pk1uKmVvuQ2rPD0thISBzYjwxg4ODH6pfsV5MUswtxcwt/UottxQzt/Tb1b6lmLll+64ov/QD/P36trptap/dtRDgoQEiIiITLF+bBnXKnFa3pY5XDRAREckYCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYyxECAiIpIxFgJEREQyxkKAiIhIxlgIEBERyRgLASIiIhljIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDLGQoCIiMjC8vLyEBgYiEGDBmH27NnQ6/ViRzJgIUBERGRBd+/exezZs7Fr1y6cP38eOp0OmZmZYscyYCFARERkQVqtFv369cPQoUMBAL/+9a+xe/dukVP9PzuxAxAREXU3TU3NqKi82mr5txVX2rzdy9UFnh5ubd7XlStX0L9/f8Pffn5+uHz5shnTPhwWAkRERPexs7NFzonTqLhiXAyk7zzc6rYNgHkzJzzwvgRBgI2NjdHf3QkPDRAREd3HxsYGiaMiYdPxqggNegI+Xp4PbO/fvz8uXbpk+Pvy5cvw9fU1Q0rzYCFARETUBl/vPgh58rF213HoaY8xI0PbXSc0NBSVlZX48ssvAQDp6emYMOHBexCsjYUAERHRA6hGhqGn/YOPoj8b+TRcHnFq9z5sbW3xz3/+E7/85S8REBAAZ2dnTJ8+3dxRu8xG6G4HK4iIiLqR3FNncORTbavlHm4uWDR7IuztpH26HfcIEBERtSM69Cm4uzq3Wj722XDJFwFANyoEduzYgZiYGLi6usKujYHtqN0c9Ho9li1bhj59+sDFxQXJycmorq62SF9ERCQN9vZ2eE4ZbrRsYP++ePKxgSIlMq9uUwj06tULc+fOxYYNG7rUbg5qtRrZ2dkoLCzElSv3rg/tTsdxiIhIHE894Y9Hfb0B3LtcMHFUpNElgVJm9ULgxIkTUKlU8PLygru7OyZOnAgAUKlUmDx5Mvz9/dvcrqN2c0hLS0NKSgr8/f3h5uaGdevWQaPRoKKiwmJ9EhFR9/fjywmHBz3e7uWCUmPVgxu7d+/GnDlzkJaWhsTERDQ2NuLkyZMW6UutViMrKwslJSUmrX/jxg1cunQJw4cPNywLCAiAq6srSkpK8Oijj1okZ4vla9Msev9ERGQeRSVfo6jka7FjdIo6Zc4D26xWCNTV1eE3v/kN3nrrLSQnJwMAHBwcoFKpLNLf8uXLsXz5cpPX1+l0AAA3N+MpIt3d3Q1tltTefxIREXUP988S+FNgtUMD+fn5sLGxwdSpU63VZae4uLgAuLdn4Mdqa2vh6uoqRiQiIupmfmpFAGDFPQLV1dXo1atXtx1Ed3d3+Pn54fTp0wgODgYAlJeXQ6fTISgoyOL989AAERFZSrc4NDB8+HBcuHABBw4cQEJCAnQ6HQoLCw2HBvR6PZqamtDY2AgAqK+vB3Dv8IGNjU2H7eYwZ84crF27Fs8++yx69+6NlJQUqFQqi58fAPDQABERicNqhwYCAwPx3nvvYenSpXB1dcWQIUPw6aefGtq3bdsGhUIBlUoFvV4PhUIBhUKBixcvmtR+v9WrVyMwMLBTGZcvX45x48YhLCwMPj4+0Ov1yMzM7PqDJiIi6uY4xTAREZGMdZsJhYiIiMj6WAgQERHJGAsBIiIiGWMhQEREJGMsBIiIiGSMhQAREZGMsRAgIiKSMRYCREREMsZCgIiISMZYCBAREckYCwEiIiIZYyFAREQkYywEiIiIZIyFABERkYyxECAiIpIxFgJEREQyxkKAiIhIxlgIEBERyRgLASIiIhljIUBERCRjLASIiIhkjIUAERGRjLEQICIikjEWAkRERDL2f2Oim5FAg6rSAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 11:59:44\n", + "{'0': 999, '1': 1}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution\n", + "shots = 1000\n", + "backend_sim = Aer.get_backend('qasm_simulator')\n", + "dist = execute(qprog, backend_sim, shots=shots)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['purple'], \n", + " title=str(n) + '- qubit QNN, ' + mode)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training (NFS)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "# fraction of total data to use as training data\n", + "train_frac = 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.9857142857142858\r" + ] + } + ], + "source": [ + "# get some random angles\n", + "angs = 2 * np.pi * np.random.rand(3)\n", + "cost = obj(angs)" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.014285714285714285\n", + "Total training runtime took 1.8455156366030374 minutes.\n" + ] + } + ], + "source": [ + "# train the quantum neural network and time how long it takes\n", + "start = time.time()\n", + "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", + "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "[3.321652 6.2743205 5.85861077]\n" + ] + } + ], + "source": [ + "# grab the optimal angles and minimal cost value\n", + "optimal_angles = out['x']\n", + "fval = out['fun']\n", + "\n", + "# print them out\n", + "print(fval)\n", + "print(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "# compute all the predictions of the quantum neural network\n", + "predictions = get_all_predictions(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Results of quantum neural network classification ===============\n", + "Out of 100 total data points:\n", + "The QNN was trained on 70.0% of the total data (70 training points).\n", + "The QNN classified 100 data points correctly (100.0% accuracy).\n", + "================================================================================\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# compute statistics of the QNN\n", + "ntrain = int(train_frac * npoints)\n", + "ncorrect = npoints - sum(abs(predictions - labels))\n", + "acc = ncorrect / npoints * 100\n", + "\n", + "# print them out\n", + "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", + "print(\"Out of {} total data points:\".format(npoints))\n", + "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", + "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", + "print(\"\".center(80, \"=\"))\n", + "\n", + "# plot the points, line y = x, and prediction\n", + "plt.plot(ys, xs, '--k')\n", + "for i in range(npoints):\n", + " if predictions[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + "\n", + "plt.grid()\n", + "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing on device noise simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# Testing on device noise simulator\n", + "mode = \"DNS\"" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 0.00011199999999999999\r" + ] + } + ], + "source": [ + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(-1.51785048443617) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(0.248786966568569) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(9.26351197606004) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Date (DMY): 10/02/2019 12:45:53\n", + "{'0': 904, '1': 96}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution (DNS)\n", + "mode = \"DNS\"\n", + "dist = execute(qprog, backend_noise, \n", + " noise_model=noise_model,\n", + " coupling_map=coupling_map,\n", + " basis_gates=basis_gates, shots = shots)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['cyan'], \n", + " title= str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training (DNS)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "# fraction of total data to use as training data (DNS)\n", + "train_frac = 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 1.0\r" + ] + } + ], + "source": [ + "# get some random angles\n", + "angs = 2 * np.pi * np.random.rand(3)\n", + "cost = obj(angs)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "optimal_angles = [7.85082205, 0.01934754, 9.62729993]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you chose to skip the training, you should not execute the next cell. Otherwise, continue through the notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the cost function is: 0.014285714285714285\n", + "Total training runtime took 6.603797650337219 minutes.\n" + ] + } + ], + "source": [ + "# train the quantum neural network and time how long it takes\n", + "start = time.time()\n", + "out = minimize(fun=obj, x0=angs, method=\"Powell\")\n", + "print(\"\\nTotal training runtime took {} minutes.\".format((time.time() - start) / 60))" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n", + "[3.47838504 6.18048312 3.49508897]\n" + ] + } + ], + "source": [ + "# grab the optimal angles and minimal cost value\n", + "optimal_angles = out['x']\n", + "fval = out['fun']\n", + "\n", + "# print them out\n", + "print(fval)\n", + "print(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "# compute all the predictions of the quantum neural network\n", + "predictions = get_all_predictions(optimal_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=============== Results of quantum neural network classification ===============\n", + "Out of 100 total data points:\n", + "The QNN was trained on 70.0% of the total data (70 training points).\n", + "The QNN classified 99 data points correctly (99.0% accuracy).\n", + "================================================================================\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# compute statistics of the QNN # previous experiment\n", + "ntrain = int(train_frac * npoints)\n", + "ncorrect = npoints - sum(abs(predictions - labels))\n", + "acc = ncorrect / npoints * 100\n", + "\n", + "# print them out\n", + "print(\" Results of quantum neural network classification \".center(80, \"=\"))\n", + "print(\"Out of {} total data points:\".format(npoints))\n", + "print(\"The QNN was trained on {}% of the total data ({} training points).\".format(train_frac * 100, ntrain))\n", + "print(\"The QNN classified {} data points correctly ({}% accuracy).\".format(ncorrect, acc))\n", + "print(\"\".center(80, \"=\"))\n", + "\n", + "# plot the points, line y = x, and prediction\n", + "plt.plot(ys, xs, '--k')\n", + "for i in range(npoints):\n", + " if predictions[i] == 0:\n", + " ckey = 'g'\n", + " else:\n", + " ckey = 'b'\n", + " plt.scatter(data[i, 0], data[i, 1], color=ckey)\n", + "\n", + "plt.grid()\n", + "plt.title(\"Predictions \" + str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing on SQC" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [], + "source": [ + "mode = \"SQC\"" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(0.314283559730307) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(4.27779036629818) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(3.31959735414771) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "qprog = make_program([theta, phi], angles)\n", + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [], + "source": [ + "#Choose the backend\n", + "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", + "backend_SQC = device # for a real device" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 1.4999999999999999e-05\r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Got a 502 code response to /api/Jobs/5c615f0259faae0051bd00dc/status: 502 Bad Gateway: Registered endpoint failed to handle the request.\n", + "\n", + "Got a 502 code response to /api/Jobs/5c615f0259faae0051bd00dc/status: 502 Bad Gateway: Registered endpoint failed to handle the request.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current value of the objective function is: 3.4e-0599999999994e-05\r" + ] + } + ], + "source": [ + "out = minimize(obj_simple, x0=2 * np.pi * np.random.rand(3), method=\"Powell\")" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [], + "source": [ + "# do the circuit (neural network) with the optimal parameters\n", + "opt_angles = out['x']\n", + "qprog = make_program([theta, phi], opt_angles)" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OPENQASM 2.0;\n", + "include \"qelib1.inc\";\n", + "qreg q11[1];\n", + "creg c11[1];\n", + "ry(2.98797789579958) q11[0];\n", + "rz(0.789805554415850) q11[0];\n", + "rz(-0.142437712576473) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(-0.0683511471663817) q11[0];\n", + "rx(1.57079632679490) q11[0];\n", + "rz(5.50839819635551) q11[0];\n", + "measure q11[0] -> c11[0];\n", + "\n" + ] + } + ], + "source": [ + "QASM_source = qprog.qasm()\n", + "print(QASM_source)" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Draw the circuit\n", + "my_style = {'latexdrawerstyle': False, 'cregbundle': True, 'fold': 30, 'showindex': True}\n", + "qprog.draw(output='mpl', style=my_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "51c04fa2b67b472594bdcc653e76dd6e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HTML(value=\"

Job Status: job is being initialized

\")" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">\n", + "Date (DMY): 11/02/2019 23:07:39\n", + "{'0': 976, '1': 24}\n", + "theta = 2.987977895799584 phi = 0.7898055544158503\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show the output distribution\n", + "shots = 1000\n", + "#Choose the backend\n", + "#backend_SQC = Aer.get_backend('qasm_simulator') # for optional test before final experiment \n", + "backend_SQC = device # for a real device\n", + "\n", + "dist = execute(qprog, backend_SQC, shots=shots)\n", + "job_monitor(dist)\n", + "\n", + "print(dist.status)\n", + "dist_count = dist.result().get_counts(qprog)\n", + "time_exp = time.strftime('%d/%m/%Y %H:%M:%S')\n", + "print(\"Date (DMY):\", time_exp)\n", + "print(dist_count)\n", + "print('theta =', theta, 'phi =', phi)\n", + "plot_histogram(dist_count, color=['orange'], \n", + " title=str(n) + '- qubit QNN, ' + mode + ': {}, '.format(device.name()))" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.14243771 -0.06835115 5.5083982 ]\n" + ] + } + ], + "source": [ + "# for the circuit (neural network) with the optimal parameters on SQC\n", + "print(opt_angles)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparing NFS, DNS and SQC for the circuit (neural network) with the optimal parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Herafter a comparison of the histograms of estimated outcome probabilities obtained during noise-free simulation, DNS and SQC experiments on real device using Qiskit 0.7" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + "#Date (DMY): 11/02/2019\n", + "device_name = \"ibm_16_melbourne\"\n", + "noisefree_count = {'1': 1, '0': 999}\n", + "noisy_count = {'1': 96, '0': 904}\n", + "real_count = {'1': 24, '0': 976}" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# NFS vs DSN vs SQC, count histograms\n", + "plot_histogram([noisefree_count, noisy_count, real_count], \n", + " title= str(n) + '- qubit QNN on ' + device_name,\n", + " color=['purple','cyan', 'orange'], bar_labels=True,\n", + " legend = ['NFS (Noise free simulation)', 'DNS (Device noise simulation)','SQC (Real quantum device)']) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### References:\n", + "\n", + "[1] https://github.com/QuantumAI-lib/NISQAI/blob/master/examples/one-qubit-classifier/one-qubit-classifier.ipynb\n", + "\n", + "[2] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/community/terra/qis_adv/Multi-Qubit_W_States_with_Tomography.ipynb\n", + "\n", + "[3] Smolin, J. A., Gambetta, J. M. & Smith, G. (2012). Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise. Phys. Rev. Lett 108(7). https://link.aps.org/doi/10.1103/PhysRevLett.108.070502\n", + "\n", + "[4] Preskill, J. (2018) Quantum Computing in the NISQ era and beyond. Quantum 2, 79 (2018). https://arxiv.org/abs/1801.00862\n", + "\n", + "[5] https://nbviewer.jupyter.org/github/Qiskit/qiskit-tutorial/blob/master/qiskit/terra/summary_of_quantum_operations.ipynb" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}