From 31998b2da33f64a36622fbcd1990203ad5313cbc Mon Sep 17 00:00:00 2001 From: EC2 Default User Date: Mon, 27 Mar 2023 09:12:29 +0000 Subject: [PATCH 01/37] first commit --- notebooks/textbook/Bells_Inequality.ipynb | 6 +- ...m_Approximate_Optimization_Algorithm.ipynb | 30 +- .../Quantum_Neuron/Quantum_Neuron.ipynb | 760 ++++++++++++++++++ .../img/activation_function_circuit.png | Bin 0 -> 61148 bytes .../img/classical_and_quantum_neuron.png | Bin 0 -> 54344 bytes .../img/linear_combination_circuit.png | Bin 0 -> 45800 bytes notebooks/textbook/Quantum_Neuron/inputs.txt | 16 + .../textbook/Quantum_Neuron/model.tar.gz | Bin 0 -> 693 bytes .../Quantum_Neuron/qn/quantum_neuron.py | 140 ++++ .../Quantum_Neuron/test_quantum_neuron.py | 40 + notebooks/textbook/Template.ipynb | 9 +- .../__init__.py | 2 +- .../algorithms/quantum_neuron/__init__.py | 18 + .../quantum_neuron/quantum_neuron.py | 144 ++++ .../quantum_neuron/test_quantum_neuron.py | 4 + 15 files changed, 1145 insertions(+), 24 deletions(-) create mode 100644 notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb create mode 100644 notebooks/textbook/Quantum_Neuron/img/activation_function_circuit.png create mode 100644 notebooks/textbook/Quantum_Neuron/img/classical_and_quantum_neuron.png create mode 100644 notebooks/textbook/Quantum_Neuron/img/linear_combination_circuit.png create mode 100644 notebooks/textbook/Quantum_Neuron/inputs.txt create mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz create mode 100644 notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py create mode 100644 notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py create mode 100644 src/braket/experimental/algorithms/quantum_neuron/__init__.py create mode 100644 src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py create mode 100644 test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py diff --git a/notebooks/textbook/Bells_Inequality.ipynb b/notebooks/textbook/Bells_Inequality.ipynb index f9748e93..0bd4605b 100644 --- a/notebooks/textbook/Bells_Inequality.ipynb +++ b/notebooks/textbook/Bells_Inequality.ipynb @@ -215,9 +215,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "conda_braket", "language": "python", - "name": "python3" + "name": "conda_braket" }, "language_info": { "codemirror_mode": { @@ -229,7 +229,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.7.12" }, "vscode": { "interpreter": { diff --git a/notebooks/textbook/Quantum_Approximate_Optimization_Algorithm.ipynb b/notebooks/textbook/Quantum_Approximate_Optimization_Algorithm.ipynb index a4d88430..f3dfe5f6 100644 --- a/notebooks/textbook/Quantum_Approximate_Optimization_Algorithm.ipynb +++ b/notebooks/textbook/Quantum_Approximate_Optimization_Algorithm.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "8b423ad7", + "id": "455cd77b", "metadata": {}, "source": [ "# QUANTUM APPROXIMATE OPTIMIZATION ALGORITHM (QAOA)" @@ -10,7 +10,7 @@ }, { "cell_type": "markdown", - "id": "12e108d5", + "id": "849472aa", "metadata": {}, "source": [ "In this noteook, we show how to (approximately) solve binary combinatorial optimization problems, using the __Quantum Approximate Optimization Algorithm (QAOA)__.\n", @@ -24,7 +24,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "bd0a975d", + "id": "f59d6171", "metadata": {}, "outputs": [], "source": [ @@ -41,7 +41,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "50e4d13a", + "id": "75c20f85", "metadata": {}, "outputs": [ { @@ -66,7 +66,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "6e26acc1", + "id": "d6012510", "metadata": {}, "outputs": [ { @@ -93,7 +93,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "223d34d0", + "id": "1a1a0687", "metadata": {}, "outputs": [ { @@ -112,7 +112,7 @@ }, { "cell_type": "markdown", - "id": "8cc043c3", + "id": "8ea08a49", "metadata": {}, "source": [ "## Run on a local simulator\n", @@ -123,7 +123,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "c700195c", + "id": "d0dfe14f", "metadata": {}, "outputs": [], "source": [ @@ -140,7 +140,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "bc524eef", + "id": "bab1d2ca", "metadata": {}, "outputs": [ { @@ -169,7 +169,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "16df2abe", + "id": "5d313165", "metadata": {}, "outputs": [ { @@ -207,7 +207,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "96992efa", + "id": "2b6ef1c3", "metadata": {}, "outputs": [ { @@ -229,7 +229,7 @@ }, { "cell_type": "markdown", - "id": "64478182", + "id": "8ca8961a", "metadata": {}, "source": [ "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)." @@ -238,9 +238,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.5 64-bit ('braket')", + "display_name": "conda_braket", "language": "python", - "name": "python3" + "name": "conda_braket" }, "language_info": { "codemirror_mode": { @@ -252,7 +252,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.7.12" }, "vscode": { "interpreter": { diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb new file mode 100644 index 00000000..dbfa6325 --- /dev/null +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -0,0 +1,760 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quantum Neuron\n", + "\n", + "In this work, we build [quantum neuron](https://arxiv.org/abs/1711.11240) with [PennyLane](https://pennylane.ai/), and run it on different devices such as SV1, IonQ, and Aspen-M-2.\n", + "We aim to reproduce Fig.1(d) of the paper." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nfrom braket.experimental.algorithms.quantum_neuron import (\\n generate_random_numbers,\\n linear_combination,\\n quantum_neuron,\\n activation_function\\n)\\n'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qn.quantum_neuron import (\n", + " generate_random_numbers,\n", + " linear_combination,\n", + " quantum_neuron,\n", + " activation_function\n", + ")\n", + "\n", + "'''\n", + "from braket.experimental.algorithms.quantum_neuron import (\n", + " generate_random_numbers,\n", + " linear_combination,\n", + " quantum_neuron,\n", + " activation_function\n", + ")\n", + "'''" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import time, os, sys, ast\n", + "from IPython.display import Image\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from typing import List\n", + "from braket.aws import AwsQuantumJob\n", + "from braket.jobs.image_uris import Framework, retrieve_image\n", + "\n", + "import pennylane as qml" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.27.0\n" + ] + } + ], + "source": [ + "print(qml.version())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction\n", + "Machine learning is used in many areas of everyday life. The technology has developed so far largely due to advances in neural networks. It can be seen that a neural network is composed of many neurons connected together. In other words, a neuron is the basic unit of a neural network. Since many studies had been done on neurons and show successful results, several approaches to combine it with quantum computing are also proposed. Such approaches are called quantum neuron. The advantage of the method is that you can process classical neural network tasks maintaining the ability to have superpositions of inputs and proserve quantum coherence and entanglement.\n", + "\n", + "The below shows classical and quantum neuron, based on Figure 1 of the paper. At the end of this work, you can get to learn how to build a non-linear transformation from linear nature of quantum mechanics.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building Linear Combination Circuit\n", + "\n", + "Before we explain a quantum neuron, let us review a classical neuron. A classical neuron is a function that takes $n$ variables $x_1, \\cdots, x_n$ and maps them to the output value $a=\\sigma\\left(w_1 x_1+w_2 x_2+\\cdots+w_n x_n+b\\right)$ with $\\{w_i\\}$ and $b$ being the synaptic weights and bias, respectively (shown in (a)). The quantity $\\theta = w_1 x_1+w_2 x_2+\\cdots+w_n x_n+b$ is called the input signal to the neuron. The activation function $\\sigma(z)$ is a nonlinear function such as the step function and the sigmoid function.\n", + "\n", + "In order to mimic the classical neuron, first, we use inputs $\\left| x \\right> = \\left| x_1 ... x_n \\right>$ as a control state and apply $R_y(2w_i)$ onto an ancilla qubit conditioned on the $i$-th qubit, followed by $R_y(2b)$ on the ancilla qubit. This ammounts to applying the $R_y(2\\theta)$ on the ancilla qubit conditioned on the input state $\\left| x \\right>$ (shown in (b) and below). (At the bottom of the below figure, we simplify these circuits). This process means the linear combination of the inputs $\\{x_i\\}$, the weights $\\{w_i\\}$, and bias $b$.\n", + "\n", + "
\n", + "\n", + "We can calculate the effect of the circuit:\n", + "$$\n", + "\\begin{split}\n", + " &\\left| x_1 ... x_n \\right> \\otimes \\left| 0 \\right> \\\\\n", + " &\\xrightarrow{1} \\left| x_1 ... x_n \\right> \\otimes Ry(2w_1 x_1) \\left| 0 \\right> \\\\\n", + " &\\xrightarrow{2} \\left| x_1 ... x_n \\right> \\otimes Ry(2w_1 x_1 + 2w_n x_n) \\left| 0 \\right> \\\\\n", + " &\\xrightarrow{3} \\left| x_1 ... x_n \\right> \\otimes Ry(2w_1 x_1 + 2w_n x_n + 2b) \\left| 0 \\right> \\\\\n", + " &= \\left| x_1 ... x_n \\right> \\otimes Ry(2\\theta) \\left| 0 \\right> \\\\\n", + "\\end{split}\n", + "$$\n", + "where the two terms separated by tensor product represent, from left to right, inputs, and ancilla qubit(s), respectively." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build Activation Function Circuit\n", + "\n", + "Secondly, after building a linear combination circuit, we build an activation function circuit. However it seems a unique idea that came out of nowhere, we show how to build an activation function circuit below.\n", + "\n", + "
\n", + "\n", + "In this circuit, we prepare inputs $\\left| x \\right>$, ancilla $\\left| 0 \\right>$, and output $\\left| \\psi \\right>$ as initial state.\n", + "We post the detailed calculation in Appx, but as a result, one measure the ancilla qubit of the circuit (④), and if it is 0, the output qubit is $R_y(2q(\\theta))\\left| \\psi \\right>$ (where $ q(\\theta) = \\arctan(\\tan^2 \\theta)$). This means that a non-linear function is operated on the output qubit! What happens when 1 is measured? In such a case, the output qubit become $R_y(-\\frac{\\pi}{2})\\left| \\psi \\right>$, so we can operate $R_y(\\frac{\\pi}{2})$ to correct it to $\\left| 0 \\right>$.\n", + "\n", + "The shape of $q(\\theta) = \\arctan(\\tan^2 \\theta)$ is similar to [sigmoid function](https://en.wikipedia.org/wiki/Sigmoid_function), which have been used as activation function of classical neurons (as shown below)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_array = np.linspace(0, np.pi/2, 20)\n", + "nl_function = np.arctan(np.tan(x_array)**2)\n", + "\n", + "plt.scatter(x_array, nl_function, label=r\"theory\")\n", + "plt.xlabel(r\"$\\theta$\")\n", + "plt.ylabel(r\"$q(\\theta)$\")\n", + "plt.title('Activation Function by Quantum Neuron')\n", + "plt.legend(bbox_to_anchor=(0, 1), loc='upper left', borderaxespad=1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References \n", + "[1] Yudong Cao, Gian Giacomo Guerreschi, Alán Aspuru-Guzik, \"Quantum Neuron: an elementary building block for machine learning on quantum computers\", (2017), [arXiv:1711.11240](https://arxiv.org/abs/1711.11240)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# [Optional] Print the circuits" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "n_inputs = 4" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.03464765739182245, 0.15436116079311354, 0.39528521365787317, 0.6472795562698698]\n" + ] + } + ], + "source": [ + "bias = 0.05 # constant\n", + "weights = generate_random_numbers(n_inputs, np.pi/2-bias)\n", + "print(weights)\n", + "inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "theta = np.inner(np.array(list(inputs_list[11]), dtype=int), np.array(weights)) + bias # linear comination with numpy\n", + "theta = theta.item() # Convert numpy array to native python float-type\n", + "\n", + "ancilla = n_inputs # ID of an ancilla qubit\n", + "output = n_inputs + 1 # ID of an output qubit\n", + "n_qubits = n_inputs + 2 # +2: ancilla and output" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Print Linear Combination Circuits" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "n_lc_qubits = n_inputs + 1\n", + "lc_dev = qml.device(\n", + " \"braket.local.qubit\",\n", + " wires=n_lc_qubits,\n", + " shots=100)\n", + "\n", + "@qml.qnode(lc_dev)\n", + "def lc_circuit():\n", + " # test for inputs_list[11] (='1011')\n", + " linear_combination(inputs_list[11], weights, bias, ancilla, n_qubits)\n", + " \n", + " return qml.expval(qml.PauliZ(ancilla))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The datapath rcparam was deprecated in Matplotlib 3.2.1 and will be removed two minor releases later.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The savefig.frameon rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The text.latex.unicode rcparam was deprecated in Matplotlib 3.0 and will be removed in 3.2.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The verbose.fileo rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The verbose.level rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", + " self[key] = other[key]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qml.drawer.use_style(\"black_white\")\n", + "fig, ax = qml.draw_mpl(lc_circuit, decimals=2)()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Print Activation Function Circuits" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The datapath rcparam was deprecated in Matplotlib 3.2.1 and will be removed two minor releases later.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The savefig.frameon rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The text.latex.unicode rcparam was deprecated in Matplotlib 3.0 and will be removed in 3.2.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The verbose.fileo rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", + " self[key] = other[key]\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", + "The verbose.level rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", + " self[key] = other[key]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "af_dev = qml.device(\n", + " \"braket.local.qubit\",\n", + " wires=n_qubits,\n", + " shots=100)\n", + "\n", + "@qml.qnode(af_dev)\n", + "def af_circuit():\n", + " # test for inputs_list[11] (='1011')\n", + " activation_function(inputs_list[11], weights, bias, ancilla, output, n_qubits)\n", + " \n", + " return [qml.sample(qml.PauliZ(i)) for i in range(n_qubits)]\n", + " \n", + "qml.drawer.use_style(\"black_white\")\n", + "fig, ax = qml.draw_mpl(af_circuit, decimals=2)()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### post-processing\n", + "\n", + "When building the activation function circuit using PennyLane, we don't actually correct the output qubit in \"1\" cases. We only adopt the \"0\" cases." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In the sample obtained, we adopt the cases where its ancilla qubit is 0.\n", + "[[1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]]\n" + ] + } + ], + "source": [ + "sample = af_circuit()\n", + "sample = sample.T\n", + "sample = (1 - sample.numpy()) / 2\n", + "\n", + "print('In the sample obtained, we adopt the cases where its ancilla qubit is 0.')\n", + "adopted_sample = sample[sample[:,ancilla] == 0]\n", + "\n", + "print(adopted_sample)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The last qubit of `adopted_sample` represents a measurement result of $Ry(2q(\\theta)) \\left|0\\right>$.\n", + "\n", + "Let $p_0$ be the probability of 0 when measuring output qubit.\n", + "Using $ Ry(2q(\\theta)) \\left|0\\right> = \\cos q(\\theta) \\left|0\\right> + \\sin q(\\theta) \\left|1\\right>$,\n", + "$$ p_0 = \\cos^2 q(\\theta) \\\\\n", + "\\therefore q(\\theta) = \\cos^{-1}\\sqrt{p_0}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta: 1.1272124273195654\n", + "q_theta: 1.2820534188408945\n" + ] + } + ], + "source": [ + "count_0 = len(adopted_sample[adopted_sample[:,output] == 0])\n", + "count_1 = len(adopted_sample[adopted_sample[:,output] == 1])\n", + "\n", + "p_0 = count_0 / (count_0 + count_1)\n", + "q_theta = np.arccos(np.sqrt(p_0))\n", + "print(f'theta: {theta}')\n", + "print(f'q_theta: {q_theta}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run on AWS managed Simulator and QPU\n", + "Now, let's repeat the quantum neuron circuit on quntum devices such as SV1 and IonQ, changing $\\theta$ slightly." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Hybrid Jobs general setting\n", + "\n", + "# Using autograd interface with Base container\n", + "interface = \"autograd\"\n", + "hyperparameters = {\n", + " \"n_inputs\": n_inputs,\n", + " \"shots\": \"100\",\n", + " \"interface\": interface,\n", + " # Maximum number of simultaneous tasks allowed\n", + " \"max_parallel\": \"10\",\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run on AWS Simulator (SV1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Hybrid Jobs setting specific for SV1\n", + "\n", + "region = 'us-east-1'\n", + "image_uri = retrieve_image(Framework.BASE, region)\n", + "sv1 = \"arn:aws:braket:::device/quantum-simulator/amazon/sv1\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Run on SV1\n", + "\n", + "sv1_job = AwsQuantumJob.create(\n", + " device=sv1,\n", + " source_module=\"qn\",\n", + " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", + " image_uri=image_uri,\n", + " # Relative to the source_module\n", + " entry_point=\"qn.quantum_neuron\",\n", + " copy_checkpoints_from_job=None,\n", + " # general parameters\n", + " hyperparameters=hyperparameters,\n", + " wait_until_complete=False\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QUEUED\n" + ] + } + ], + "source": [ + "print(sv1_job.state())" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SV1 Task Summary\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.933, 'billed_execution_duration': 48.0}}\n", + "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", + "Estimated cost to run the job with SV1: 0.06 USD\n" + ] + } + ], + "source": [ + "print(\"SV1 Task Summary\")\n", + "print(sv1_job.result()['task summary'])\n", + "print('Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).')\n", + "print(f\"Estimated cost to run the job with SV1: {sv1_job.result()['estimated cost']} USD\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run on QPU (IonQ)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Hybrid Jobs setting specific for IonQ\n", + "\n", + "region = 'us-east-1'\n", + "image_uri = retrieve_image(Framework.BASE, region)\n", + "ionq = \"arn:aws:braket:::device/qpu/ionq/ionQdevice\"" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Run on IonQ\n", + "\n", + "ionq_job = AwsQuantumJob.create(\n", + " device=ionq,\n", + " source_module=\"qn\",\n", + " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", + " image_uri=image_uri,\n", + " # Relative to the source_module\n", + " entry_point=\"qn.quantum_neuron\",\n", + " copy_checkpoints_from_job=None,\n", + " # general parameters\n", + " hyperparameters=hyperparameters,\n", + " input_data=\"inputs.txt\",\n", + " wait_until_complete=False\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "COMPLETED\n" + ] + } + ], + "source": [ + "print(ionq_job.state())" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IonQ Task Summary\n", + "{'arn:aws:braket:::device/qpu/ionq/ionQdevice': {'shots': 1600, 'tasks': {'COMPLETED': 16}}}\n", + "Note: Charges shown are estimates based on your Amazon Braket quantum processing unit (QPU). Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", + "Estimated cost to run the job with IonQ: 20.8 USD\n" + ] + } + ], + "source": [ + "print(\"IonQ Task Summary\")\n", + "print(ionq_job.result()['task summary'])\n", + "print('Note: Charges shown are estimates based on your Amazon Braket quantum processing unit (QPU). Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).')\n", + "print(f\"Estimated cost to run the job with IonQ: {ionq_job.result()['estimated cost']} USD\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_array = np.linspace(0, np.pi/2, 20)\n", + "nl_function = np.arctan(np.tan(x_array)**2)\n", + "sv1_theta_list = sv1_job.result()['theta_list']\n", + "sv1_q_theta_list = sv1_job.result()['q_theta_list']\n", + "# ionq_theta_list = ionq_job.result()['theta_list']\n", + "# ionq_q_theta_list = ionq_job.result()['q_theta_list']\n", + "\n", + "plt.scatter(x_array, nl_function, label=r\"theory\")\n", + "plt.scatter(sv1_theta_list, sv1_q_theta_list, label=r\"SV1\")\n", + "# plt.plot(ionq_theta_list, ionq_q_theta_list, label=r\"IonQ\")\n", + "plt.xlabel(r\"$\\theta$\")\n", + "plt.ylabel(r\"$q(\\theta)$\")\n", + "plt.legend(bbox_to_anchor=(0, 1), loc='upper left', borderaxespad=1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "conda_braket", + "language": "python", + "name": "conda_braket" + }, + "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.12" + }, + "vscode": { + "interpreter": { + "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/textbook/Quantum_Neuron/img/activation_function_circuit.png b/notebooks/textbook/Quantum_Neuron/img/activation_function_circuit.png new file mode 100644 index 0000000000000000000000000000000000000000..44f6d7fd6587d5602cb8d540b24cd024ad1a7190 GIT binary patch literal 61148 zcmdRWglEnK_Zka@7#g0gJWzMCK?e81011&e=syk7<4yq1XD)4`uDL08tb3epu=E6 z)-d>=*XVval4>xOwZ(=HQbg{e2e~ zM=>5AcXxMgcL8n(Co3L4QBhGIUVa{aelBnYm$Rq6%RLV+duN6}Zt~ZCZX%t{ova;Q ztR3v>p!?o4b8vN$q^E}-^!MK%{dBRm{PiSz=Rb!92FL?_!^6kT%k#gQAw8`BAI+d| z{%H1dTz@=H0=k))o(9s{!PXV(mXs*3#Lp-E>*TNg{n6mp_1gBiq|Hu>%J@2wEO zzW?=@f1dokftr&w5=`XJe)0YJjDMc{$Mw+Y#MG@lkhX}M)^9Qj6jt72d&n2kr6KY$ zNsI2SQ`Z__eg7;3v*@kyRdyluLm1jcx?Wj0{AR>>WQs#dV{l?kqDAxyb9KA(L7=T= z=Gpw%*pPr#Hwg|KAudh??0>yv=&(uPZ{l(p|JRqGg&(sF694?Nq96Q!yy#@$@4Il+ zt%|Z4WzhfE3pBm(KiYwt{r}iB1oM4@+yi&{y*4e8W{gO zejj=nWLWB>0M~111lX4nJi<8*1vH2I#kC*NJj&xnt8e9@dL6FjFm8|?lQ$*X-WBzq zIc~U!ZfH4+sXeEJE=7MCH_*lI#_QTC{k-9t+wac#jD3Y1Ovv%)(f+e`e&;w}_*>7t zKT<~dEyMRXjI@_@?B8s2X}+mhJ`|86qC@-bwT`WxFimYRcN@Kq=}Y=2LVtq5|8$1V z16pn4)S^#}5khF3wZr8$&q?lz>Tx;mWoICKSBEJH>pYJy=oR~<*q+$DSTU(9|DOLH zp-jd>T7nNID^ferH(pwZJ8JB)yYh=IETtE?t{GaJ{DHk`G*>GMVg(K2I-l0-aA19A zN_R?Fa#ElD6!?R_A>RjEL2AU^AzGuQLot&6KIwmY<`fT$6|Eepu%*EH$XMw3`4WZ1 znVa{SbY>01tcrGT>$dJGCy#240qw-2AI@7XNx~L;A++>cSz4C9i>@<98m+gc`0a)& zw$6IgY~&*a?iSV3Fi>ccr8(>N~V5F^>GYJ@L&t zO)E?D@Uk6W$^BK^ptpn@X)3)Pv#vD!|tm0`Q899o98nLlAEECIn z^-5eTH5hBT2X#)rTapJY-^-gYh(7Kdjg4-ecQloxedsU!`!=Nu0wNJDm)!m?!Y>gX zqKGPW7&IF0TW3Cw&3Z@5w|*+2_>Pl0k5sHA?wl@R{C78&mZ3TUD;GB`*kE4uIiOP zhxammsTecYsDJR>k-H_<>7C8C6#wo%-|#D|-8kfwb1HjIQpAzFW9-}m(LPc_9~)&- z9u7%@S{)in*I?U`NxJt0bxplJ9fl9+u^~XM2g+yx*!UQPEq-rtKFf-F&oD#_F=uv zcdN@y^HX#b=p0wYX+>sL=#6H*yTkg3*mG8fstw}o5Of^EJh84LI_>?`SCKD@JNSz2 z=9!(ZYbxj7TTDNn3LH?AB}ua^ev^MrqABH~pUu^^ypUWrc|Ny2R3OhX>+tVB zLP|&8uY>B00@$K-d6>8^g=k4%U+*nZMpZ^)G9OBvnFi_Z#m|pbvVI_&+9%-&9Z9_S zG`|}z88{ldGri*m7SP1S@Q(QGbP_(~u0~GF@|>u~T$jmd3HLjV#ie0Ur(z_(6wVAk zYOLD5GfC8WW6;-ZcB7&f-u-g?%s)R(h+6UK}|#%;)ocU9;+G1|*Z?=>=% zX(CNEmFT3gNoEuThLl0id2o`x{%~Sr)zI2|;?`L*?GVeRqOfe&a+jHksbH`aF@CtH z&v552LZuB#z_b>7Fy zl}@uW<iYGE*KY3)v3R+4Sdr4e=AQ8&*8rnw@=@XdksYvgkPM;0vE_4UdoGGU!UOG>k&weUXR6m$@R_Nply$FEs-}<4#br74MWV@5 zP9y)@sSfZ@p%ibqgmZKYxN9HnMm?PVq!diVv?DNkvfUG(t(~L1J@0eTRh}-Iq}w7UK7urw$Q9&XZ4y)=KT3Bvo!%Y~G45`5{0XD+W{j zGL`2{WIwA!HxbGz#q$=&P=4hcrQJi#Di`aKS23J=8e*ICQnyycv_F};nLF)IzgH3D z@91;9B}jUIqA+N5bW<%awkDpvIwud~DX-aG^0EX~ZYwNCxA2kncQsoa|H zZhwsh%bzQ8ezMK)v0+-dR<&$#c5*mm2UlT1i^u+0ojR34+L=#RlUfN+8iK!SsB&F~ z>r|L{Z3c!?i|ZWiuk*NtP+ceLiOfv((XTsN;_zIr-7m%D$(3XS`l^vx{iYou6|NgG zm>W8@dcwgH_wd}2y-eHTI#p#7E+*}c{>!!oG+g5D4)L>BeTg|M*ma$xvy9JVW;HWy zU9O*n$-+WloLNm8NxtXD6NE)lM+*##U*86m+KuQit0rA}h%f#062%*<`NI6VyKip= zb_+B-Mi+Nq`+ho*u0(t|aehY5eL3JE>yOEWE3KVzT;JwRJu!0v--d~?Q;{pvaAqX( z-t*tfB$jH#Ai}2PIQV2MpatfBGZ>@OGu5)?p2!4^hlq_Sbl!hZsb13 zBs}3&f-@(K0}qkOJ=V+7$=fNuf%x$~M^}wQXi5#&KjSIJg-h5K(IKCCacO4I&~C#T zgu7?jqs!{c7MPozh*jLLy&OE;XeMBIBO{B8>~5v?<;+ZW)Bh-X2D*-ok9O=z(wHS} zqYPPiPo>F71)50h9G%4sAsyKM_~Qa&aRR10^o_QAK%-pxxjEIjeOGpq39W&eyIawC^W zsi)^uh6=ad4_;?HNM455ou54(`#9oIU#qU^dw%M^I8>5}Uw^ceb1}K%!YDXX43uV} zw9v9BO*9M#9spe9#s!xCpRq*~{0AHQaG6bJ{7i$_aIiYzB(u>Jk{6%Xbes@-A>28( z;d_>5hU;>FV4TAF?tn>e?PGVlGV%Lg=xRgRX)p|>x%5lFB(i*b-U|5{XG|a@@;!bk z$N)J52I%dq=(Ylda1BCJRAi&v&J+rZhLx0EOA)a|?LK-9DEn{Kkqz;xr4972y$-j; zRCh$rn9=Hq9i61FN6ZG2OcwnnPD7(3#I zIma76vi1-)b4gm5_+Xhv^#=G8@MvgSR)qUs0rMV?!}u0k@kwxq-_0jAqTzOCQv>&V zQY0T1;3)=_w`c?Ulj()znvqvk7?!R_cE9+%+-9wKp< zk9nSwAAIYjpQgMY@l7qb$mE|l+b&*uSZvXG z8po?Zq!{iOeN5rzW&l*QvHf6{CQGAG=in5VzK8U4=B9~CMcBY4H~#DX)Pz%AAIw@p z^k0{_uNya(6#~;njj7_gIby$M3N%0xHZL8}B4~`je}sv@&}K#}z*!kBkvkhM({@`w zZLLfnK=S*}!;@Iiljd&8`)O*deFEZlx}(!6eST76_i3>F8IKwRH@=c__FPd@Xt zt^2*{!R6z8_fD8mX_vubap;%6FIR5nms`=-R##7pkLEO~lX#O*lPW(s8BWFIXY=W3 z1yN)csPnzSU4Q!1i;UX|{6_(^IuV2nw-zRVN@2YTKLk7Fow^7H2vq!K(-6Gb?fOwL z9E+%i?dkOh;QMuK?)F5`UE}AA`F8G#R}mxb5;kB+oPED z7lUVmfW_}qKHq4sCvg01=r)A>+IRvf?8}hCPJfHIL)6BIs(oEs_2J9JglcC><%#&v z2k$&vT^-3G^|{=Ma^>-4F-6_|iJ%EiQe|y!tzFxJBK1IxONE+n#zaz5w00tA;WJ>s zOjbW`9nPl`i06E405XG}R4cXB#t?|>z3@7yNhNzy4eN}!@X~WI4klA~X@hFFyaqLr zI7C8T``5Z6^Hy9E(TKUviOUWrt;c#-FbSNJVEN=L#v(o^9-?Ol)4Q%4Q$e(34|c)2 za{(v1PG@E?nO4*(ef)3Y+%vLWAFoB8pY9XrqC)(5 zLvpFE-~S?Gy63Z;SAl!t_r1VG`VGxRa&8i@H?vjC`QK#Kf0!zyUXy!@olDBfcv%bG zZC`-%b(7?BBNpxV5w7WR!Fx^c!=;=87Xh&Q3|BV>OB415M6ab})_201x~Ab1KgH*=+`EuiG-{b=TByCb$H7X*$Z zmk$#^a1kwWH8J_#uEYcdY-%SHf?`X_EVYb%oda%BoP`ffzoN;*E;!#Jgt2`1x}@ft&yfh+VQ4*z*_FfogA zfpIOoj`%47Ese00T9nLX?3)ukY0uWaybh=n%H8GBNPjk&vJ33rQxh{!=@OzJ52Y>- z79*dRfBAS5mQO9t7blAFC$&q!crI*f9%k3B63dQ^Pr3(I3yn^uGYRHGlyk)k{Yygr zM7c(sgMMxton3SXazFkR>5}r|52W4I3e}cV^X3~vrQXRaCTDb_GI~`p+;=_ZFgssQ zzW?y7Bja}PmKYD>Q^N#aM^+{$@(n5Fh?{-?e8tKj>v3#8vnx9-J=60R--z|WTBA6- z1MRcX(whM9Vsm8|EYBnO(P-@y{DvvR<10~>l$+~ljduX2p0t|YX71h9oIJ0U>tT99 z$?QFX2D)vpxH^&ZDXSrRqJ8=AruHcP9EU^8DTcDcHu=n!EOZr!TfH)yr4z~%wlq%b zma=np_@4l=!X`mep!F_28?QM`bu-u&I&-Z%-80C;76HE3j!L8;ez<_zWB`FwM505T zUYPirNabvt0lYh0C63eDfN(|8U!+H3J9KAtWWbFg&hEyAD8C+@!Lc6GgbPSPPQ0Q- zQZHX9lq^gxCLHg%gyS<$jE0zQnAbnvTP@QdCbRvjoItE5akuVds}s9kW2D?J8tfq> z$eBAlJ6^w-(a!SJmIG%79XR?kH+YKi>X>1)Tlbo53%A-y|22s-hteUe;!_?AkHPk5{m5p>MDM*+gEa(dZ^4j zQfW4{vEAY3KcIBOxKN2M7Cn zyQ+~T1hw7eVayt0C(+i4Y&|a=y1HcvH?}%?#5Lfft^-DdA+VK4vYS{a;D1|}xUYQ2 z$ZRdFLS>M~G;U-F*bQH=?MlBHOtjU(QLrFeBmJOTKf+HO?jh|Q#Ngaci~d$2oDA5T za$CK;(ct;>3uMWNSAkZzaTd)J_y9ws8-(CYxAUSsDVB}J-1yn^xq8}sWM6Sv4F9_i zxuZMPPb^ZSr&MC-GiK3R*)Y2c_&rYSip}>;#H2VMbdd4z*i@Wmak*SZ7_f2YOW#W) z;bP66?mBf2xpcTj<86CNpd+Tk5es%wJA`U-q;QE*<{C_DGN+%(KG4q1jFsgz3A%y| zJKNm%Ewp8O6C?7@2V3g+%Q6FrSWjrRJXu~cQ|tFtdaH^``Wc+|LW>)qL0cY+6b}^t;+C|l z)JGb1+`#fbdR4P=%$o6XY4`_!Q4T|Qb-VQ45%rXj8}fc5H%p>v%i~UeJm)Fh`o!v( zHi{BNj}bpedbE@^HOn-V#iYW7=76)|Gsk5zmtp`1AONHAm`k+IoQ$k_3ON?7S0N{& zknThR#Xk=gC8m|;@of%Yr|0Mfa_EOjex12nB@;tSmoED`nRcBJxF{8dExLXm)5tUA zI=!mm{fXxUQFk~y=6FXcW%G?rOboluEpCY|d~5w_MQ?lo*0*!`(Ra7Ud&$HnPWLK{ zdlxBHt?*5`zP-MuW<4-@Y4w0Sjw_&bB0q+{6WQ`^!lhJ>KtfhbxKf>~R!p74+4yiu zdTV)UvDj3I+q46OFcO2J1`W@R<*Lr67cQo8GeIFSarRY zHMgzN0nzDV|LFBexmy^7vT3Z;WKa`d<)HkC+L5fQ*Lk#Z%%rb}u0q0UODEY!^tSv# zR%E0`hY10v4b9P#1~vR*+I^%d2a@jz6G8_SwHQj~{he%5%{o@sUx>bv3$#t6{M^S#Fym?7Gc z=6Uh}mbGSS8w|wJs7ZU$p!OoURPsQJy2f?>R++_vJFi(CW2m_LI;bz>`@fyKpOwuS zm_~)N9j96RhIMaNMW;#knrN<@f{|`gA-gHAd?@bwyLGBs&)DVo-m7Pa;0HBZiK8^< z^*VaG2Tg)HpC$0%c%A!^T8vDnDmx!cf6&S2jX(E4GrG7YPaLqx9d!DCT+w#>_rXrVHCkeH-U2 zN{aZd#c8C?Gu70swul>Jw6Tb>OqFxnK*+dGL#0yZy-`CANx{L}?xNv2+ z?1|I(St^d>^E!#p5K&ixkz;1v(<6xV7)^X{b0vz|OGD3s9ei4kgmi?9x*2K~CgMal ze+(vbXnRd?D-Kdh8u94}^?Ugk3#pF3+))(4#*ezHW0O&?S&+^3)W?ut*)G1W=M5Vb zTMI_>H@maZSSb}RD!xZy_!2Pi#=N}oZ9WD?vDDz zovi+_r0-&tVdt=+=a~tx?pd$&vAMM zB3{w4T3bUQoTUC0BBK*-Aoh$-R+uoY&M#|e*Dg`{?%DB5Lw|jWk zIjDUmW8%qlQ5h%DFnl2uhSRBz3e^=E#j`Lj|tu-o~J#w%2 z&Q}pDR%Iy~Vd5BjfY?rYA7gM)rzb-4u{%djh8@52p?mLnA_sEn6-8i37NY9a7Fwyp z?n1otc*Jgq0KDe4$a5y2S=yYsODw-O1GFpJ9H6C|IPK|wteBR+wdr&tfQH|`(XsaU zyQaBAL=@l$i~P-s`z*y*?YZ(J8mAq;&5x&SebCv9;WpOcs?~o>LQ(BGw6E*KLTrBx7RF<@q-_22cS*gu@hsXXXQb`dv*sU>k6Jk$Q4K__>1QobZ!qO& z7ak>J;-*Op^F*G9)~IK&esR6!GhbSHO-Eys;rwOnEY9DX_vZnsh8Z~7HETXX<2LAH z`o`Sx)Z2bnQaK0nM_HZHs1^s`XKrDAyRG}yvZcytIk-nn2|NekO z*wstt%Y~emM=y6otePBcbrq=3+=u!Ra>sb`M35Rjr@wy|Al46hPcxym73B zBt+h^icvGg=0o1h-1e955HP$`iQSnF!AS|6VMtFIKko%JElZ_eyc-&e`pwk?qQ|eq zCtsNFDmAFV3vb?^oy#beL7&wn>;R;_<~_QH>*DZZp@x*FB;+C08#A;;lAn4?#L zkca0EpH$n9*4<*e5u&nsN~y?(63-b1F-B8lvQ@)LVwTAuP*; zOBL8TFx3}{W^*&AX^w+^M?=I!f|)#PK8wRz z!ar;yT!|bN0qGQ!cI5>`Y5Obsh4|6!>02ZZ1w~36aQNbE=(kPOS#?IUG%PcDTHcmL zmu1-KdGsQ!FKL(Q-vaojW=2UsSP6}rSmNzp69O#jpRdb?P;_6hj&O#A008$U^*%V$ zy#Dn#g#@Q#(z(>Xbge~z%-vb4P70AJ?W2(R1gub4 zL6D#8m7GLv^cv&hkkr6vzj^oqY{>Z|=Wm?jUmr&q8jw0`MHZ^RI`wz&z`>*_&_xmo zUFeXGpnD9zZIw$%ljohuPgBVk%g$$*$rY`3`F^Sz5JY@d zJ006UIO|Q*?{s`=B!%%f^irxx;iIRQXnYM0gz=Yj?XC@!UcHQeRn+}us0M9LAvgU@ z@j4Iv(R#~~yO|_62zZ~|xMp)X9OD+~MIpYqt0Y5%O`||*mk1Wl#-sK|Rb;dxT?kNi zcV!L)>TzUn%(bg#gz?Iy$gv%H$xn9{ONb z$j_DfZPk513Qt(-;~>{g5!3=#tAH^YnIbwjaf3Zsj49~ug`fP=pKFdrwBZjPY^;t< zf$kE4hCb@eg%P0#2VHl-Rxesi%r})sm+>1=fr$lcGor3TBsa5+G;^x7Z{14$`56GY zyFzsx05u4xExf~>Z)yU@LKhiPUJMOm16z5mL&m>m20U|60XU;nCn|^=zdTA5=Vj>S#*xeYdC>p?TOi=P#X3&>;YSFE#nH~< zFh%ixMiCs$oH#nQm`mYBON1YGApypBz1-|fNB~KA1bXH6Qnh#NCrAeXXcCooe!}A(3<(RNiSzJmKnDZr^<531fcPCJWwHSM zokDzXTdBba$meIHl&+tu{qLRPe}j&#Gs%Lo%;)sc;asA_4B%U0@(e1(l&c`{o7NIF zWQbe#c;8;H^nPS0t+cUa*UM{w*M6wwdyD-xEG*({K|$TogQ@6CzqH}sY7waPS27wM zNzUD(3LSA=9Q$MLCO2h4h&C_`0gzAseqU*ZMvD$vHo-~db>y3m>iahTmCS3ccHh|B9)RUefU{mGULGjmY0CtU(#X>nOs45)s$>T& zdYo*)1)Lb3it$G|UI3jhw(3cFHm8~>bZ4z{o@Q~RqCf(`yTy)EP0zO7q{F1oJgob3 z6KW2AJa^0VCKoDfRh;MxCZ$KYU?({?;Vd#*>C;{Y3NDQpf%$7^ZBU@nV?+V8MeJ4X zFhTS65-~m!W;~v$n#`V|92@mY&}PZwneS)8fwuQ|-!?6}tqx~w`=3)DOg0j6Kk3WX zR>8%^wE(#9*4~JN3TVYhf*bg4b+l3-iJR(*D@=v%I}X{kh#xJ_Z6>&w^#QW(daADA z6++6v+*aW{-@P?x9&W8d&zdIYw!-@2s&L#J`R5&@mCm#6EUDM^X1?$Hp<&FJ0KVUT zUY^{D5r{#*GWCIie-sva;J_W>F~*I=CnBboFe#GEScq7kk#QpEOaLSB=Dma(P=IhW zmg<79Xl6t*-juQ43*W--mGP_kg?tWWutK2$EzH!A+?pNjCx@=Y=1eqO>9(qG*UoR* zbp;iBk<&hH5VcOCcz$+jSK?O;S9L17z8o%n_Qjf~a)yZ7z3B;#^?FL6lkd@DrsELc zx`@B`c^&O8vor@0#MAm5$hLaUC%cytneQxo_5T34)+h+0RF3DS?q<-%H$@6O-m^`R z@GRE(K<(VcH%yOP9e3x|btUe)1GCzIA&~D<%Ky%w!rmWwUmYfkwwHQ-!g4L-C&w!z z321qoX@2y-^coCj5HdkwxXp?UDX;?a$K02gP=@rA+5GbWTkcmz?X8a3*j(`w+xa3l z3$(~USK8&mXuT3kobsZ4M9~{5qkKbA&)Hbrbif!M?Q5z@BICRI3R8X0^yYP|-Rwm7 zN1YkA@(nACjdh;bl{+gz)VeoD?cT5rVVuf+h9f+Gq#c3ePJ~Xm?BWH_y&_+8bUd3;b8IPsRM1>di{BRo=dJu_3gS!iv)}uMg(Ka7BV1j^u^A~ zkmfO7@!2P*4}i>9PQ!MhM?AoMo&spZcBP%%7LZ(6o*SE-gDJgxgb-Z~Y3$vrLG`XR zSxh!?lCd6P*e6hwQFkOuRFz(3|3Yf>Ul2 zc$C+_G;WNb(~1}a1U-d4mR-A7-c)=QBCxqXOrqNbZY>woKhks2+44Ev9mr6L=dMb2 zBjt@#7IFVXVRiE+l(kS^*jQW&7#xM9=erm_9%;N+#a!O&EPV`V-59;bi`?VStMNSB z4M&bDsI{vxoN-9w*PDz}3uy)Mn3S=(Q!Y=(No+J=Naa)K%sqh}f5Bn;)Q*L&WjiOw zQ}V(dcy~X@l;-3BdmBNB#80}ENk90t<5{1^$0wDCMsIH7)RKAve%rMiq(MXjRilz$ zyQdE&R+WA;vDHoCK%f7#X}`6h4M%O?ub_J0D262!SvVRJbqqh-Udi0rexHdvdnsFt z+(jR%v`aqYOxO$VqLIGcT|N6^G-&eS#meJXt$qoTzy&FQT#%eKQ>2%w-@x-fY#ceZ z#m$812a;1V6#iqG55B)AjC?Va#ZLcailCZFOEHA2RQhm+80C-zC6b(-uKO-K6_xaZ zt;A-P>>AfhbV7@#!(S*B!sKX%hmy0fomhL?aD>C}G@~e7Y)&J^%zLmJ{0K{c_2G)e zSd>z+)2558#DBA?Wt`w%d0l+s>h~&1%Q=Fsu+$7v9)lzW<@_?=R@In%WM|wkJyx8k zI%@(~d(jSdwZUvvSCXivPQGDQVlY?dSQLTuiMmxFb)#|_zW`?o!=a)Pj zzGGHnq&eNbT~|3KyoAO3ts#KxH;?EeojT_&kN$vxJOdU>j%C$kvA|{L1~jZE;rC?C zsmK#$I9r>@=Dz~N8S8kNuXh9GETC^(6&P#d z7Hq6f%9EOGFwkC5pBDkBtWVEBIX}eK$}_pu&l$R|cBvX3^^ocrnn;V(B^j2Y5DEsr zi}WZu;)che@&2E+epK3R6x+@LvXt(}MI^rQR#CEO(&CSI0b@Dc;_DJa zrPk364&9Rbqr__*toJ5ckw5^QK!#8U7*1Nn^`NrPz~<-1at{h}=oi+CZ21>s8Q6ti z;k)6``oha}R=~6YwknY6dwxcU?_0!pQ6)bV(955w=2j~7E(DT41H5o=teX#DBKZN& z;JH%NYS`ZM3g^s?_d_QVNB_9H+T5dQ&5t12EQ7scu*jVF6B7OyJ>Z=&+dze9;~AqI zwB_kqu_boDYdSUK3D2AeNVitK_}or}#;W)JemjvDnF=}u{p3YtHy}DP6Q7TzPd*#u z+(Z>n*(T%3hZ3@00eLL^c4gZj9prwh5EhL`T1p1W?82E5FnpHP=0sE*5W|b!NsL(f zo^NDey7{HT!6fb5U{uTz1iOjMG~ zRaIo-bC>}+1^gCm5eu5-^{)%%eEnaKpvx6TnN<|dJB!~G2JQh3!|%Rkxay9Dn+~aTiK6ZPPcN<_M?XA7M-q~V zmObc;LSbNa0FTq6823at_Zly2)0&13!~t7?JSQ>Mac-S}3wTk$3(<@IBw-AgaLB71 zM!A5dW}mj3gCm`T4qsEE3Yr70sJO7GdZp~eA5<){KU4UxFQ^zMqY)=MxY(|0nn9=r zd40iU0VKV6G!h8k!V8q0X_SHw7-u`1@7=zQhu}6%t^EOC-zr>;E565;L=2f?cy)Lqf5$q%GMh6XK^oTkcDzr+ z?6q|%1#K8|;%V3hE7|o;V>RJll5D~gwS3%iJz+Cf*3)JJ=>@wXgVOug z2EXE}zJH6^*_(zgMX@%9{xtPNtpTGL$+QX3mzo+rIW&xrZ4f1u%H0>aE`*=La{DFS2H%qjkaG}2%AunO68hj$u9I?YSrWisdelCO zN$$89rD<77LV%mRttx)QceujWWUc0HtEH0K%!?f2Kl$^?EO!lE@D z$TUAOsDnh++8lDXJ%5J#E5m`w?{fXeYCuLvcLZT;)!UbX#x>>#G&g8;4Ij!6R8qMh6;KHl$3F76s#$n(g8y|AP8X@T;w2?$KU!`zBP#C#10F` z!w{1eVmzRRqYrv>eVteV=!pLpl72pXAX!u*67qjRWgy2-nJz1@eLIFQF&Q0YRPAOx zAqJ)3HoWGCbc#3BKGIRofd0mrbdS`IFKyA&gljS_mX;zVF{5GA5{M<#S z9q-D7dIAq2VTtAg{Ufo^@i};`edNwPsi6QVvX{vfqMXAxjMxATOGpBFnJ>s#^o#_ z*BKh1m?m2mCz~s@oRkSqTB#$$4cv-RUAvy>{Zib!J?@uu`58bk)}Qbr>JstfnhnK; z?jOKqE>;H7R_+h0DKrMK+@{o@mZCuY)%z|bG|K2-?f)sJGUd=5b8T@B#KY~W#)sl} z%`z0}w9(C5!|n*OeLI94To&ra2fteTg+t{}Z@W#kAs@ZL4#GVg#Z~6w@1d_WU&63@ zSjPmAPKWBJqyQc@=8;+<0dsB$!D^i{2|wXnix8N*NhgVQoE(5xAaotlHMBGp`dp6ja%lYK!+v6h6oT+)0>~|L0-> zK=O~6mQ3u^Ed5XrHwMxT1qNtoS{+8(gAN9$=hscIMArPQPjkr z_H8kNKG&^~O=#g>jjjPPrGI@i2w0a1gxJ{tUVOH(-YRTFT0t*=L;1(2NhKoSHaW6( zQs>nyI!e$L`dpoe=^|{9OQ<;P+T44?xc8b|E5YhAparna3W~ai=z-W7%$%BVf0`yY z@p_0rVIcA0<}O~Wjn~vUMYNH3enodcc>a26Fqy`Pmewi7rup_hOo;V8@)z7hLmg=w z9Hf!u{v+=GTL?b_aZyYApbsBH0}$q+ATHIuSfhF zBSyag!Isxw<0)Ew%3?m|#ivT?;DACnZTFHQYa#&9Gs`fupkNSg3QPXT{tHx!ffewZ=`2H+ zl^EYSb*SC0W5h722ck{}JOsK-sH!vMe9e(z$L$OabmcBG}K4+~h- ziO0`&w~4```YgRTdEc2Y`52Voz2J9T;ji3D_Uv8nY}p!GDJ%9F$v=Tb1nQ7=-bmp5 zqj<6b69NP=pLO{I_nQ}>m6vYo0(b&giWaQo2nFrIQtt|v$DZY(dWEmmb8K{2ubCK* z-_WO3&;KHNAzcA5?u(n|5B{|+{{R@;RM4yUpQMiod}|6xdb=DG&oR;;^X-*RoJLDX zTgV;pS-7iDe@LEZdu!*dZ~Uz)RbAqaa8-LJ*~z6Y+}}4eumWCu?s>OO>eTK!KW-h~ zT3Eyi%GvCzaqV?o;2bJ750?-)BkvhBoyO)x#rqy;4%EfztM0a0@6zk{E=F`XO%Wb17oOiSVj6K< z3l{02T?DQPi=@wO5Marm>oH7P>sL+_+&%X*-v9Z4^bTO^WaO-g-XIjKlU$`zN%)XyB~IFVZ|&;BVWL-atgl(&_P z(g6`9`e=O7IC;Q!jH!BmEoc9(EBl~O110{sD9JvgfN50bVldz-r+fWW_c0Uy7P7w% z#)%M>hqSX@J{hZHn>y^XYAVz)X*V?jn}eb5eX?%^v)Lle_Q zL+cH!kmG)tZKPG@Kc_>xgM>h?kln2bOz#TAkR4ukHJ+gRC`AVlpLcuI7MI(yzi3h zfGzNsHi8c5B+-xK&s%#fwJ-UKR=mW~z;3zV6-i$?k&{XGjHXsd zU}HrW1uXEP{zs5P3=+qn9xIrVH~`-yFl}%OML^ta@d&!!;`XrC!0y>m{BH4A%dEa2 z0iES-SB}`2@?Ca#@e7~4>#?Ffs}%ju|2>qS!}7X4+57gv(y-k~nQm2$h^EeYZSI3i zrx@pXtLGLoHQr?6^!>VW0_wLecG9a&d1j?=Da7ATEtn}-oEu6pu(3-OEPpmLGx^8 z)Wpl+XVFa8!-pDMpk#mtU#!ml+$9=F-JMrm9Bt4ha#}B1OMsx_Zy&d-YvvydMFpv5 zagfHIQ+e2&Xo|{>*NHQ>TulAEX#xB5w*W#EE9SH?HK17 zoeug;3%=oSkG>(TIS=``!=G$qD{w^q#MXew{_z6acq91R`$rU~50jn|YBI|R>UAu< z1f`(=6sEt9`PBe_*Ck*T3~(~Q7SIlaX)~Z^a3Hpzoy82-gbeN@3*Ye`->h zG;GsTu|W7JU4-3yvyZy%)+48Bo?uTuzkz{h+I;f8>i{gQ0K0KBj>nnc3JNpFN|9X^ zDf+>=|LaW5%jkiC>W_k^p@xhN^*M$seO=|j`|G|Q+mDWdFvB%~pUEa@e;WiTm!X_R zde05r6k_1Cl*izhI<^u}q;CsHY|)w|JpnMUZ&HZ_DIC}?x*ekBe|XUepw30r(zE0` zH1IZ7;JSFwy`3%M-3K`UV^$qh0ZPEDHQl>vlS~bmwBqLEj3^mqh)Y!(=KLw_plf3T zhELjap=DMBOyYz)A;$s(xY+AEMJ_I|o_q!6^;dfVF3B@azm5`4%Os0 zu8Q|30nO8cW4d2<)5m!M#&_V$xY9hif6V}L9fZb!>#!97D~LZ?u&UPiRPtl7FDL#= zOPJBHAx<@@X+lml1?CIS111NmK&wn~$fnRph-Mdk_lw#D(|ZNnN#N-#%vl(48AQJX zvk5hFdOt@dXja%8<$Y;%&sVOnA2W0qhR7a3letSyxbUa*vrs>}o#+g|)lJQuoM;%~ zylNKkn}}}(`DyDpZ?=#xKb^iBBE?zJfebVO1eM|X0;trjOtGq>aI)EQ!QuB-CA^Xm zBT7Ql#)Q5)Qqhw!H-j`74DuXWwFQFs*UtI~$%LVV#Lq06GbYI7id6o=GS{9#B^glZ z;rOHFJP?JNE@56IQv}7K5F<;$*>^5~w`lQP$_(#R4glYfH+c;WfZ++#qS7rB)C)I^n&q1Zrw60N1E;0MUsT`*Hv~xCN4Z z0jFeSG1rw4*gbCpqR+$OZCiJCprX@nys%cJL%yGw3guiW}8)`$R9b65MfFsqVPoTS_Ht$U_de%1t{F*pK9 zv=h)b+zhuu+Yq0Nkc+Q_XxIT~Hh^3kDp3Fx*39Ps<=KpAK9WJ9 zW3n+|wolijuQMsC=UN%bNQFcEsQh-YGKeQ&O*#;Y(_Owd}Oy~^VpTXFMc#8K+L)tS?Lg&<{t=q0=mCTf2=?>Us z1ueJ1!h6G3;W$axt)sNEG+ItvcJS)O5zKplcE3o)Fkb?|jnr{pzz!kzR))^9)Z-qY z2d)CX<5foQG0<{ICXDm_tAM$K>W3@YTU%cJE0 zD-iLrAx$>GVhEJan>P4;jFb#5vKtYq{diH_nxZi(2bYxnWolSGlz*_Qeh3(A_atU= z21|X>_~)0#?h_}u`2zmVsqI?OhsflDZP4|AJy+5ksKEWhWJ>hv@e89sL@^(QZW0>pftAZj^nuJyb@H?8gJqgnP^|tE`*N(wB(73 zDd1Qkwzz%BDwWH1>3jPF`6ALs;A94v)G8WBpPGl$w;DBaEil8PUSFzTc=NneV5S*g zoO6it%0wpo)(c7|4xQY~B0XU&j%hFInGkM*HvP9B^ktLsR9VeKRsIki>jmUfbhR0$ zUueTsyV41XGAsAk{PAeWa&@?jVK9!{NdLI4>EObtGfkjvn4zJ(0q#W+yU)k$?4*^O!1{+P|CNc2bHWK!X&m7B}DUT>2T?p@0x0)wtc~}L!fY;0|1SoZRwzx@=^IF zn2WxLPWRNGlEVrL&at1JOo@Ti5$AM}Mo!w5K4Q1ODnagUCbiuqpr2*o)GV|Z0ocbS z>hjwkzB#bI|H93hGyZs8GPC_k&pbTsx*yXJsFB3%+;CeT&$GFdA)6><*Mv*F(tROt zvc_}U;`C^@7nDvfj#XErycfWgD@Z*0bk(5^K=q6zmY;Ds*lM}IDV>@67ZJL7H}4Vz z>Vo`~UB+HQ1*$2==Z;CWkM}#EGT!?foUVK{ev?Pd-A)7%o+E$O}OQ5I2TheJSb%evBdcrd85)Y*S%kR_a2P z4j`QG^In@0?t-6XSZ*Y}Kzaavy+DWeAQ5D2(7cp+9WZ2Q8=a_xTF0&V*br<*e+cT~ z;Jzw=MuY0c+CeD~4^(EPLvjX^7=ok7#m;@t_kAD9U|}*)g^vUN!e8%8;6-w%oC~)_ zK?bmJrElgzxzU%0b_|D%5!D5U=?n@Ve@MlL zKtD79w7Hk}L=cmL6fQ|(C3BC|ajuV#8b~+^6I*)kxV>@G6Nx~xK_PhdIM{o zcdiPQGwlfA_gpVPf?t{#CMR{X6`%COsNwFudv*ou-ar+oky_a70VEU)lq8ZO0ZKhG zcNqJD$<2*LhVg4fntl$G@&q#7972^YIiKWQN_6r62s^8&xVCLw6WoFa*TM?-pur)y zLyF+;?(QzZ-Gc$0S857tSMW5CX=2PSO6&b%$9Xn1Yeqfus}LeX%-U6^7V@^oG8 z7cwL3E~UvHJaeS@OX&GdQ7XN9a9r#gaTuUzB2q!0Z$5wUz6eEER4Da4FjS<|X^lwQ zgmGQ`^SN;?COtc2ABE13mExK`Z>y|ZQu5C}08>Ds+fg+Ks1a<3q1ZC}I4Uq-;@C;h zOBZXt14TvAms~L2o)5)NpV~aZ-IpD2im&|4D!}=kb@d9VY%lW%HjUi(`3BGY5zp+IG4C(Hihy~e zxs%3QsM{sxPE$hPT%9k3fJU5ViAz^<*}JC9JTJo3iBd|<-|9!iX&zUTdls#R&CTcg zLVd8LQ|jT|7ykv=r=^&PQ0YdKo$DO9meL>do+%Kvv2=3)LZ^~jY3C`cS3&?z2tk&zq5KP)e zBz9YIpxC(*Xb~qJoR}c`G8)qpRWLnv_~{}FbK-HuX>u05^_S2bWMdGYOn_9 z*S#irWr9cwfBPj{S>Tw+uOARow7)5#mgh$aE-~ zadisF8$2HY)LmhfM*tlIhmZ z;*@ck$b&x~)labrrRL1@-Qa`olC;?N>#l&hBrG@PMexNAPK>+P*?=V!)hOvOZ~j*#2FpbGnT7@QjFiL+r&s}OJQ2pMage9 zXt_XI7eg9qlsRcrJSjQ+chvQ%-?P^JgTK)0qb1m9wHNu$7fpv39>I$rJf5KW0Yw&E z8{>AxF}7ofWg13ZWf>@b3g{BW-rOGogE5W@FGQ1wCg|m@HwjJ&fO3 zG3lcnr5lm)fN4$o9l!}xM@sSOMc=a(cQ0_J=!?PBZ@fz3jwOA^r=g~d+vaJ(*HPQY z|FLEm0ajsdD;bG)M~1G@M@wR_d#yzlia%^atQG?({3mfRD92VX1_(H33M+t}*3n_K z{5FkzYFb`1e7N)iHsfu;nK^59Z^Rp^y1VJPXp)Nbkh1Vv={3>q`+&_sFoB%AQU?(r z5=|;Q$flA5jDkE)_&3X_k{HtC0{a27E3kAqeX&euIhYl9YWo zY7sN_4br-2e_Q;I!?!mPUvTM#l1E@#zAUOMYYp#8B-YOkWhw2hZ*~h~k~PSIwHRTv zsyx_2XXORh_BOU5>Ep|i{bP(cmLoz@#~$#l@1fA%#$>r~M(nblaKkf5+E?oT9zyA^ z!bm>qhl9KP8d|=Ie##&mf;0ZP>Oa5FcjTPOCdh!Mu?6Cn^LFx8^4b-`J)Txn07r#Rs zxh}@F%+-678A6|743&gE!1k7Szb6CGps^bQQT2xTh@0H)!gx^Any;2wSa#L}s0M@E z4+S5ktA{%UlFemA%ge9qOX0$rb5r}1vO=M_R@GeK6@y%kiDz%bFFpdvsf~wY(pT+4 z8K1mb;CW~(Lc7I#XFnh`V|JH$iqOyY*AYW>yE0&w!2=xJUq{IZZQ8>(Ll~zaz3sk%f5265Z}A{)2(*%Gg2}N&{~VS|p%zam&QN4`f|7 zfrY_oBVYkz%9GZVMNp5h6$tJahiczZediBzU|5H6668$6+UE|6BU7cYBka`(AO@OD z>4s~z782ij#eb{5P*X5>@foXM{*Y{Bq5|@dz?G8}-qd+NH&)v|g_r{Gaotq?KyDe8 z1;nL4aZ<1C7=tY5tFo&Q287)e2C;TjX}w2mp;1QL&zWJme{a?HS;D;;y_hKE@ zy%llo-A*9F*bsPOb9=UNUU#|ELKNoq+vHmTLkJ#Ty^R1oCj>c3s^-DGI}nbKFvX<* zV_*_ESA0*IWsJ4ad`eVrEn>5rWJdhhuqaj9P*akzmOjP+SqI>6i7Lk=6O2`D-HoU5 zxs)kHdC7tT{E!h-(BYL6NU~sSV_J00gl;IjoAd*BfRjNi@8_5&HjMz?Z}vTk=;FKw z^J^^+WCPkt;#!sLjxFErzQ5(*4QeEm5N>y+>>%Jby2H--tQ)>GBz*7QV@x`5;frNG z87pnjUNP8K4N1;%J=d2;?H=_JD2h9;Epa9O@f5UK`$ey_L-!y?+D@)enOzYInHa34 zPhgpouhhC8ge2mP5sSXL5#;3F$u*Mg-XQ6XIIa3blebXXebe!Y5L<~|ERQ_hu*Mdb zY^<-l6r98s29!5+jrai7UFFn3ztNl9;w}VqLi6i$tPqiKHj0pehYYJKOdjU1$YZtf zLd=X6s{M{g5Hew+PehbBy!J!z0n-R3`oihJ*QP(NpW_W5G<}Qh5|+T2)5TlqphPq| zMVd7(a{e3Ohz*X$?oE^H>lp6z>7l{<+V7$$YYm~8E>+;NS*R5$seo-9Vls-LLO|kh z`e(s-Y=s=L$e#;-<(mE`6RJsqhM_NCZ)XeA;5X7#lpyY<9|ZTXuFFs71Cs0zF63ZMM-vX>et?RVn%~wMumd!MOWAp&umq1 z=k)1JHkCn;djm#)q)kYm8%zUss$h(CH6To<1<|LNrxz*V*F$KTDlyN08YS_b575!P zu2NbNHYIcbJ_Z$H$}ICk8tL<6dzJ2+(ES?{FLSXrBw~9HeLfwL+6SDe&C9Arg8cfW(TTqG+Gxrz~#%r z=Dg)=e>}P)r64@HBT)lj={FLLj2bK(5+P2L?nywvOV3PDxL>JwPjgxKhon1*F+T07 zzPMgCsB*$UA|yMqo&C9ift#!+PmW`B<-1v0Q7>aKX4YUA%m@OcQsgf3RS0$`AI&G{ zju@BdOpfguDt4=-4Pzody{QWzGZq?@Cl!5tgE}}Sne_*%D-Ttm_Dy|m60gXT&p4~w z)_ujH9xepJl=COvTJxK*Oj0T1Wf@l-89J}X(`i`C#ntM&B8}_Ylu+9l%C$@XPw4gD z$SGe3xZ!kT&%6hw#liOLY1hDE{1bmr4znx|crdE+S~tx$$5+A5J3N0CvMCAZ+yruC zK8Y|sa*c*efxu3z#RD$zAvl)}gXFo(LOr6IpfTD<*Y(F>opT3xp95aYoitYN3*bTP z@BxOUrqH?In$|9PWNx`~L%5(Qb3oea9}VjISe#Dqo={*+zxMLm(u6gDpHczVgi5Nq zfhN+ezzdlKo7@lAXMB2F_UJqK2+8LooG>ODddoJll)?v5D+W55p3R2`o$welidT-JeIvYH{42{cxCoTR)UO+ zmx`X38Y2I>Ht=%SMz|0D7k*vf$Qwu~AN}4JB=#5azi%@9rTnrZ<8Mm+3lpy!PjtQv-8M&k~ zcC`TZn)hH7N;w11SDzR6g(0o3c4rpRf>EJf8CE@DtI+_`Yz@~OFdXYIh8=#DU_%&% z9yWdFf|@AJnqKSy@hC{jYc{9pY7h8_;dUU9{47O z=M6zuBADPVM~RxR$dd@=Algt%uy_l-AZ5nDn7rYgBGq~%L z1oxe8l!KZ612rEVdZJX?k&6{C@rdBvc4Ds}QTEI$qKvLo3`Y13BaS&o&Mh7i&v57|)~!`Ull)hC75IJ%f3BaBXLUHT-`}UD2U4TU1?Q^;MKsPE!uz?- zyVjZ99L_7U{OH1x5)d|eT-78&%^=`xtE-T$Wp4ciY6CYKNTwU<653FjP+$PZDHY)i zybwmU$!m}h(PJWGE;qA5M>vOzDMvia+c(b(_hV?;uR%35ayV`?G>AEn;M zvIV(hTH@`DVMIt7?a~EdN)d1ZYC)4#u1;M@w;Fx;#%n?Ay_CLcn%$>}gD}rkHSa#@ zYDHQD-wxDcu5YpDlRSL2w$|}A#vncL0hBwCz=ts(U=}42RPzvM4btar=hL;QN>Y1$0qXvjvEh1d=L?rZe7Jk>ooO}g0WhwCgn~1ONBNb z+c1+lAKUqN*$>eK;0t?paPT!w-~JeE1=Tt#0e^x7y0?qu0}CB=8b!v7Q4L0dK83pv z`>+dx19=!#d~=8BG%Gzu)(t8sor{Mu`19aP#;l43)o394m03H}Fd%6b({W*}c5LlK zMv~Lg=am{J4QPp)w<6<>u!Iug3qMS@msI%bN6Z)z+UIG&s^J+yyj!xYxGV9a-JW+C z9mauioO6;fJeF7*#8qh##Krit)?-*ZBcm?}>GrLiGDp#m-q#_Bxi2D-uRzqU-%BD!U0miMUJj4!JICmv4( zb~((YFgJ3O{U$!bi>nI||9X}Ub&s!968$-;%Pd^bc;-{+mun`twg1WfhSKPzt3XEe-K=?KKMD>>pmv9+!h&F~% zPg;dM!r$Jwd|pwz4CnHfoY4%qEmZ*d23o&Y8C@ z;PmUVD9?WJKO*!J_zDDYk(my~^eXlBN2NGi5V0^#q+9*uiI>M&%ldSaV6sVdc^t}B z@Z)0aa_RUj50enyW;$Mj@v`BnCfnlIsq+{YqMmH9lYYDr)z6d_8im$1Q;&q&W|xfI z?7ANoOKMvN7I-umr_Ebv0jK%q-G!)21}XkpZ>nn_JiBSZNvarfjMN;l?DJpfSXu>d zkLMQNcu;e=3VS#8mG4 z8>A^Z_RT!YhSuR^d?ZKgZ&?@Q+1`CDhQ#j&kg3v1FqFr7gr^?^G9jO03 zT(NAkUw^qhc);^je?|NGKIUm_Ulf+>mtLPe;5-yho9nG2#F3ZhU@0A*NG%V8* z?$Hw45ZuRrw*Nrlsa_(t=QT{7+N@F7600wgU`_xOSGZDmn~S$}K73gR+#=W0@3hH) zx^Ue!Q4kWEfRK^qZ5n%xSaB}g3Be1MuF_*X6lv1%1<()rs~;!7gj{Wy1{YB@n6`EP+wultc`9@>-K0kS*uAGB*>pR@cIITVk^?z$v= zz^)fi5)7;y$oB}_y-WU}TRR(AvIMRml6-P64Wc1tNtr`|lYzE&iX7 zT0m07J@M&$6YG$A#5nj>xJSAuq(B6w;>(Nq5WyRg_zcviaoFF5Ccwii0#)1(cHGt@ zb-we}dV2RUQdc*|@E10;vN}}D!-xXNfeoxD?4Ex+X8WkBNwbrIQcaNL`mX28# zZ^=@lRJRJ&dR5$|-3F?IlJJY<4fTRsz-JP46mEa@sFjqG@X4qa2uk%fF?cPKkqcd*AmB{)Tf!?*%Yzzn&8f z$Es@`PfL@WCw?L7u|qwocJWq0J^SNuu}Ub}k9EGY<%T$VT1c*e6EtE~7-W(qvGdv^ zHX_75Mc+NeFdY-J;SqC=U&V4*M+r8sVZ2K-ip6w#msvN~R10B~O_y)Z?QmG_6{4i^ z$om>eU8DBa$fxg>7}%LL-O5ZFc8As5XTujdMIqHQ{bIbCBBfxg@A87^@snZ|;!+@+ zV#Qu8(J`k7e>y}=dj{dUCrlK2kz8s0>vy2Q$0?xY2jr>`07@eK@E^#T|I z3!YcM4DhIlLp#Gh==rF3&8BsQDPE9ML!a@p+5HsA#)at=pW|34>h{!;yr1vJLi$mH zKV%U43N0`nEW(3RIu+<-KWDCEMM_cv=pXnHk&}#Jk%`mZZ@nUvjSqSN1O&yWFmvtl z-u1BKo@j$g7#qa!4FeY}d+ z)dVKqFP?DO^H8WNk=ymazE+yE0%PyGbUbRXAsYigA?)Y~P#+G*q`XpaQBn|N3y67> zpuC-iYdFk$F<2Mwjlt1ks6(HPempVLCrty1CE{j2`ouJ~jd}o6vMf0U8+sRGck~ve zAHM3vn;0Rx%9}9M*-M(o^e7z~OM*@tULeJ9F&3L5uS@|2G4ry7cldU#mkb z`#*D60>jrNdYIbQ+g-Ca>YZyyw_FG2VTOv6b%#9hr48rm5CRz`t8CvWc#L|Z1iIe4 zrbn~Yxim+U=ke-CFH0uP=`R7f=DW8ZnQOa58>Nkt+XORq;Ey%e98_~-(H2C+*CI9I zMOD+{gV;RLy%k5m(m=pMI7uzi)ha8~u2UhGVydz75UZ>ADGa^hh#XQEoKBmjmC1GI z`eYzSvUzvdy^aZ;XkP;TOl1EtdUY}apZBN?jVj6S{70Lp=Hx?ymkYT&zkU{ko=eb+Ue zR$b;LAUNv;u+(E>=1SkOG@WL$aE>Egv(mkmrXFuRZFWy|6ZKLa zsK)mXA!8i>EYz%L0F7{pV{Z4A9bpS?2tf7XPGt=z(vAX9f z%uvbmXs>31nX#3E0t>~*ufmd=ZodOt5td5ZL2wd*p~}8$LF=kgen{-6kPrhf+qJ` z>4ITNiT(EP;HV(IAh4|bASaQ*W)#}dSyr?~aUDpa zB6Eq6R!AvhQMp`Jkv2U{v;TGRfuBA3wIj**QyFQD9u5gQKCux)nuirt4RQ*u_=3S% z%eom(?#*R^s4ij6&yrcHRfwX1&$kW@0Md&}G4=i!w49bq&8HCoZEl6BoCMDlnj+5Y z3-In2COVVihuupjp=YuRu}WXPvTIj_z-_&0K&5vE#6e*}$!}DpRzAzA;3Us|I(il44LwBu&h{Wgx2NLKatLR7uP-qT;ieMa4+z4qIy_;Pf)80OthX zZ=8aMT=049^`)3vrnVRx+Gz`k9}e-POx_jb>R8_83x4WMg}jKH_RpaPpzOX~r)WUY zMa{+4RW-;%hmfTifM)0|@kD{~Z&BIZIEZgVjvoE$0n}^;PDPRSVO2JvP5Tw-h&o^9 zc$inM98Fg6M#$B|D1=T{Y@E?kWsFb=+i$c*1-{v1HpTf3@0ZNFBV;-TMq*ETTlTJI z&}wZ+NzApyuCLlIj;bF%4i*Ma_JB&uvTd6@f1fI$sRh6T*AIibhMLzJFr;?_p z(}rV9bAGtWqDkpjI%-Y&ggUCxJ3pbltIWMIf%+^CC)3@m^vRp+46}*5?6p5n*&aE( zYkO_vzj*$oV4n;u3mc(N`HThnyO@Y0Ce7MBVW9n7XFszIN`o`0%CYipr>F3Dh zZVAjjeA^uR{)@v5|GZ%gY^BD9rcgoiWog13pc1;EcIJjT46{xHAp1WoGmuR@pE_C%JU(JB6?_7;e7g^W-+%a1Ya=1UVrTKCnt(cDQ}Oxnd%e5GA}7TI*b&&O z+8^>&Mv1lZ!_oxOlXxS}?XU)~ono7LZwrW$$nOyZQHF95ObB0qz4*|8{-%aQb0Zht z^3ei;Rf4#~>!juVmC&ya1Q7utSUoqhhx1iw|JN8Wh@JNs?yG(9;x|gn<;(RX+XNz7 zF$pV^-<5XBCG+Oj4t@Wid9A7dK0T9IFOrD&?0~g@<4G2`eg2_R5szi?>XZJiQv2p9 zFEljmz#7MO!9(n1qV&(WLp}@^rCue(6LoJ|y5gjfJ!&!;EEoB&P4GSl6u;1AXj#_c zgYZB3#Q9TTJXgD^j@;DIK*2$GP;GwVhL-nI--cQOXaUD8=m)gK(xKS9PkK~)Br}Dx z&Wk7XZ1>Pfgi`X6&%S0O1tDk{4_AOZ?rRWD26>docx~Jxc?|D#|7K?b4&YE(MM>*TBG_@PA}$9%-TMJnkJ~25`@M{j3tPi;q5yD{3%yS7CRTy(O-Cix zxqYnuG@{(0!kw-O25!>306=xKh>FFb2?{_81c^=MRq5vNP_$9wkltoWNh?Bir=7ne z93}*BP(w+4P>Rett4iQt0343HNxjT?<}n99&CSGnQm?-F4rf7jM~E-&cP4^E5U@XI zU2Ynh*m8djuy9jTH3G$y!#C8|?^0OFsf9dKM;=V5Ph@&QhC!>CPrrrN2{q*c97i6o zsnXvB)m{W;GV1!mro2~z>=ayGaF8BKrb0d410TY{K8gx*QYdLf7u3>&6%gGeKJ^2*i2FE_MV<6&#H+0Jekn1jBF9u=>m$ z`rXhiSJSc_b0#77SY3D+kR5>f@*|c%2*U4f?mtS>_vx8i8%4hquG80TCEUKM{h)%g z`AcQA=+f^RnXSs3Q68>7xjgYqsGIN0PuSx2z@8rD0Btb{e>O_Fm=jD zRCCfUPe8tV5f>|5RwGulzxYOHP>2Ep0o~yXXHE6-@379jf$KrpcH$fJ3yF>7(2J<^$zG~d>nn+ftqh0 z?$3)r^ZI?dgX0Z9e@%TpX6ZWf3LAw$cItW&!dxujGVuaOHb>uoe>P!QfaX!shh2wv z?1sZzV9v2`uw43Tq3?5ljM$xZE<=MTj(&dM6_$5{SP`9OnxVm`IZv%8*KkdZ_!v*7$`$9+|{JH*uvS(wCn zpLTiCla`TXtMO+zZ(Bisdnmrq&UHq@xg+Chcw}02*?Ic1)ImWLA#Fbr)Ta4!j zv5ZS=lka&Vfog}@{BDgL^Tx}H9n0NJ(6zo8PB6vOFKdT6rm(+jGavc48l+#ODR0QJ z&TwI06d#wkQudXlW$!JO3vHO~6lUrWbb4`INJD+Wawo2vC}5ea)U1^=5GgQWVzn zOw~3r4WwzC_tUQsh?UA@w_AaKM^rA4@F+%9Ku94579;{yOIYxv+~ao+WReUA!<9e4 z@&AO`RAhx$*{~JqyqQX#bWJj#RRpiVit%7QbZnf)xXCy|`<|9>e-kgq2?%U+-Zvbq z7Cx#nM1FeP1%gJ-2E@ZNO@`ipM7(ZZ*K2Vk57^jB%w>^!eS#su0T@oM<`a*_V7`fP- z97una%xkcSG(kBHdyDdRdKoWc`2O3cFJqWm5n?6^f3y}(eUdwxerbms{sP$JN70@% zL5ggqpT^u5V8Em2wy^0>`fzD<5K90pAz_raV9QZcz?hPB=#w;*NsJY7CO`yTs(*fs>n!Z1l?Prt2I!*H~r#P%5z2(xLprwEZX3j*H-;1 zu?oa^jrVMutLstCS^(AVXLKa7@sJ23THgX)F=+6e-OEKrf4gXcUziOW3kVY+Dp*_} zZU!oj4bGRiAObzE`)WiNS=!$#jpP{c`OL%~p1)-4fJ95(Ayt?La2G&h5HUJ2PmK(V zy~*s6ulmR;9H1Ug1|TxaRtrEyay8Zczi6(g{$pN$xit!8^0e!#C0sgrPJ6J0cXI#) z9}*5j25!4Pwy^zzEOU#vetP|^hE~5WaQj=4O=-}Lvxqq!i>|d9zW5OtY+Vr#U;*6D z7KZ+bbauI!{l+RmSPf|={GgBbugej^ZqPd!K9wss*@rjp_3w|HnmBH8=%wC4piZjaa>4LKKA_ld9C|kk0@0Vge1)j_|K>NhU)WxY7ruu>$}vjR5$m zj34fZk$~@om%{ijNj#v62YWzAr>kCQjlun)_4mffToNEAl0M~CSjp7{5}rShl{mC{wQmWL#O?nr4O38)^4q<+@o7ecdDB?}cCWxNaQ@5Ix5?YxjnxD7z+QuYN~!ppgaGuC_`8 z>A!Nh3IOw~J`$-6m~7a-ILW=VB%(i5eKj0Zybkc;;-P@EDt?h(ffE)M`P!otsJ5Ra z`@vH*7mYX~b6L*B0nze68b^TY)|dR|FnA=(Fn+K3FBk1gTaIFqXZ|}AjOC$3 zQts%9gDSWqUps-~%(Jm^%ZV8yN3yaSQ)2#aQ{Z1iStj0pnU7XZgI8bPM1k(7gSP4% zY-qLs#bKkh6tn@=cYuk*su1OLAp$I{Fu3Lay1n9ryI`YT6w&}-i8#Fz^iOlwzlaba zAYd#I!jR)ya$j(x-LU#uFFJjFfq7OwZdyml`sb!@UhMrUl7O1y1?29?@)g8lO`*K& z{QqN!6Slw-wwFOh63-Tf;AB1sNIWXgf4U3Xxl|$j+A`uuuB5Dt*=nMaj@`<%5gaM4 zzcG@YV56kz+rqFr;Q#;t1JqzKvJzfI$*8Y}%4ef$40eF|f~%u(21#D4)30?GgGM0kX>sL|ZdVPU{P-B?7Kpn8D4 z^+0+ibqJ-3dx@SMsfT|5_s4qxs0P!Ym`?s!AYeKm+0dklLel{cPlQH|8cpm9Zh8KY zgR)olzs6#o6fDNG?N}NcG_{(9M98D4_R9*l$U?_ zv-Nak*Jno_tRb>j-Y-RInJ0MtNe|ktcVqm9Xn%77l*FNL`4LRee&%9>KCIUgRUzn7c{CbaRUj%>7D0r z$6Jq!?Tb(~=<+?%lr9=aq<d1W4l%^X7Ko#tMFlxB& z)RPzu?&>cLV~^!CYV)c}%C#}O#=^i>xD4`k_wultx4_Mb*cM^!ZGNY~i#NWBy4Q7B zd%uhS3WIKnrt4kw?46vfVq?b;DSyOO`}^%Zmtjja zCaWc-nMm2~B?O75+xmlRYnkFnT+JHB%#_8ZMX3hXwQ9_}&JXpcFie!rL_3X2jWqwY zjfOM7YBdyhJLS3T!3L*Jj=Bj&uCOU=D>gU}QE`<;S!>7|ryh%EoH9>4ev)GfZ0q<# ztNu~cI#cI=SOBQ1CKC=Igwwkuyu;H~XSy?}|x(Dw;C{zB_uSZ7gnQci8^ReXwXu05ZOkJ@CDZk^P0HhWT$naMDNCf` zi99Y3Mxg%6w|X~ZF;!eTG&LU{Jq1_^o+~X`_DC2my1nDuaxnJ2TxSo5WvY(pr;lC3 zW<8|;$jucinKXBLs*NYAn%u@#N}Sw%8j`jA=KS%VKK0!jz(S3L&G4V)@!v=@0%|20 zZDlzXFxGk-Hwn%~ZWq<73OtJY7Hj9?7BtbD)nA{;v-Ed;VeILZ42SXAO(U(|<}NX;{|V z#!x2~mW-X$8^dYF$bTj!nP$+}hvV26tMqay0wFkwStnC!@!2XUX&A(OSo_3qm+V*8 zKctZvMeJA8Ke0^Z{+ejDb&=l4XSI zqmw);+drs5)qZN%AK7H=(Hkf7q?{*F?w7vC4{@lj7XAEGI(9x0$@SkGS)@1+3W5Um zYT~JsY;*A-KHiOEi}YKr$rf83PgQlH%5T+Dwtc_u;>ACID>^s)7%`(zu+B;;Oc21i zn)+oFV{^PP;rBR0wVax4j`#3Zb%b?Y?ZBSJu??(oh3JSqWGBmB>f)_cGTe4p!-Q8| z?&~J(#m?HHt;7T!d0qI?tm7sef*Z?=!w_a4MW&JmK)Wgg*^^Vb;ag$x4H+Ts?1SX~ zC$9M?nkMIjUH3JPj@LTP_V{@CY(H(2nSoHMLT;X3ILCyjt33tsnPm9DKOb*-ui5Y& z(m>)_-yF0;}G}0^I;c^n}<>UnN5csX*b$h9Rq?!9TgU2HTo7j!M+&P`}lf} z_td7QPIOr=Flk>ZsKZ&JIOFcyQ`=9~1zFg+-;{`5ukl*()_(sODU}5-fqgjy0No!C z;E6|)hQ^Yy;}sm>Ig&E`eRtI zO{4Wg_c6S!;qW%Piy6Dhco-cf4r*rw2NT0uzPA*Pv0)%IGA@hmwu#FPJFY@0yGx~t z74hdhQPyo|!z4@9r0frDHb2j%2CUXjJZb9F+QxhYE}h~{Ej5$C>k%L51GJVLJkg)r zK9&)dj;4>(a}nvjAV33#u+7&xzCD%D|9BPwb&e(ILfzC9Hl;>g0yj#JM@Ax(F+q}n zYw3ksd~~C!-v?DnxXygw)4Zr0_~J288nE8u(^gcTy~+it@NO11o+p{d=?c>Jr64*EzZ{t&p5aoSJ=8L&ag1>8hy`Ou*`a*80UBz3TUCwtn=d`9qDn(i z9vP*Z1mwt4Ne#0 zi=ZGvv&G&s6x_;H+!LmHogi<{SyT~x7UFm24kwQeV z&Sh(gx|R#Em7F}2s^7elZ+N8`(5bN(qTLl>ZOxV1TXta7X(-IUYSoz4M2hlcmF9i{ zed+OOxWL!WD4l+7F;Y5Ky4^$hpEK}3hv5J$YW+Hhfk%y{$92$1NRQ}lSZ>zUB*!kl z2LCrj%>9LrmDE=o0(y1MVsb>C=c+2>2yBk)jc~jLA;s!z^SlZV5e+v!3l2ATgZ<}h z)=QR|w0d~yw;i9qOYeRRZRSvlE<{8@SQUWL}|1dT0}h zBuCqpTlc{c^K))c=i#?B1qJ1(+-0>zSNRWS=+m=Y^H;7V{~U^iIgtP^q*Mx{Cf4|{ z)7-z?2QRk2*K1?Sh75lf7}BzF6bFM2EhcuKl%aux#6Y#Vq2?q-3A9~9#*oIJ#AYoh zq!;nf?b2fMFh40h{DyXC{i2QDIXd0AOT=1CNv-CSSN<+Lm}uBF!vs?|suV@xv8{Ap zeEkhV6wkU1ydH5A;``oZca?YanD&GKGM3iir-4HBnPIbLK#>JUoYfc)Y*K5~5 z>XW2t-)o)_p$p<_gR2dt&uEjS|D<)Y0Vd4+^_Z@p|LBzUvvbJYbxwKTQbYH%i2^kW z=}Y7yJdBCRhmDnl?d@TNF*A;HMGDWw@>>i#ga$a{=0LM-EO zzRI4KKV2xGHCy{sX?3Cb3%z;%cjRX_%z-=%y}2%RvhUnYEN_U6{Q@&FsgkE*Q>baG z9uutS99TL7Q*f*sWBV!^~_$+Zc#Bw}xZap^!7!?0$j>VV45VFa_ zE%np&Gi{&VZP`~?H9n6N)ZngHBi2`L_|_V0qa}0=6pW<9BD#vu0^+_Q0sstf?O!0R z{~49aFIgkC2Vwz3*pZz}!#WlNFDwouYTI<_yO=O5x6qb54OhHVm-Ow;j zsmpxObGtx;1lk|peG)U+=KVqyOA1qrIkbM{K-3SIqjcx&d&xxFCEr1sMw2-@!)Zr9C;WWN#O+22-eIiZlc z>b`IGlJ#l-xWzAm(KHmb{e|I*9rp0w6w`m+2-m>MAzMMZ3hSa-DG5j4WO=DGrZxJm z#Vn)a5H1dt$ck6_3Ky2N275TPc)VZrCco!)oz~|!I~S7ARvRJZFl)9nNpR^@pELjJ zvr~I-e(@eu1HUAvGd>|O;zRw&wn;2vX;ahaFfskinf3Tpdd=uzR+o?41Z<4@hO-kr5Q5*8g$I{;liVbBq!gt$7#c_O?bgC6ENUUrkP)rn;E0nJ=+R2Oz5W zXFIwVXC%)9YqfFrUu!j(_peM%3s>@TU~||`b~aqQRog2bUx>&6X&Wt6d^D2TTyt9*;N?!w z+N>@X6qC6;B*h_c?vT329X_NeM%MOBA zRQq5Ps8wqu8Pb5Pz395Au}%D1@c8}MZD@XKW3ha3w6g9W8I8d{$db!_*@r!r+4ULe zBrc_z)f>IlNsh8cX^o4{rmUp1_l+{HT>roQ7A+TV%P?eIYKPDGEwaX28eG|!15ktp zS#=rF>lLq*@&x0VD3F^DcJ+tI=vp0ZCRn_^*3nlsNz!V*d`GxF0l*OZH zTD)}Ym|=rVQYb=Kbnk~@iqy&=>?dzewpc!d>wj`x$-{8clXYpgE*f$r)W>HFx}c!Z z;aeG40pc9Y#FJGWw9%@L&k|3*b>X${j(Uo&4@aEwTg%0+iL!G8CgjOS?4$q0u7BrB z{>hkV!~V=T9z%$X_8~0FC1R9{CJ&9$S})-EV-o)v9V4KBoR@?|qED{jAz)OofD1l} zSyp}HyGGCwO}&iBS~w+)#H6Ut!VO3%2RPy{|5_oPYN5hzPELFd%-X3Mj+mGJPzK32SR8IIV28>LbOHT=&| zQTuiLc&ATqEaGeMigh;m|8(;y2r{0_{Bfdpn!emn|9^uK5VkP=kx7~O|Doq>UtZ=4qNBjp=Bkzm*V!!0_ zD)PyrhI`ZwA4C$Mi=;J7@M5w|v?Q?Dp%=7P5y}MR&P=qi-;-u2uCwQqBL8-osem>L zHir#O)kf!ifkiy)^#Vtgrc3L+hd*eq9s#LL!Gg*u*v8G~WU5@bnz0WsJAiIT7S^lN zEq769->IrnxW#5ao@4!JgXRPy9$K`tWpZl2@;Zk>^3#t*@4lo$;nD&Ud?W8=)F1NH zavz;WGoq!j!r99<599dLCd=ujYE7AjDMk=o1M>%Z`wLS8HL!;>@Y-Z?BR%&?$Ryh_-9W0U6nP9!p=hKbL$nBH!S(c|#V$BCpg+P0 ztPkJgFKBYHK7}ZLKXU1drF(A4t~PY#5u<<1fv;EQC@FEnFn&ph*ANl2b(x_$h4iFt zAeQr?!nz0&LpLUiR+XtnjdTK*T4d{?pBG>{@_rlAs*0u+qs%8>IZqZ6{+YS^Bl4VX z`k`>(BS@lHC;`NSx2IQu`5{>eFC z(}dOjUfam}z~f2rPZb}6W)+MNUTC_e2}}%TZwP*?-g-SmaX;t)eq^f!LD<;X6rHrz z>lpS;J@*84eklVosQDnFFJdL-B`pyJN?W`iqw|O)kXoRUFOYnv!ilF_X6W$}wJ&4e zqLX($#7j=nRJWqjwxAdFl!n{<@uUKg9@$T;T?lubYbEjwf9r*eUy zTRnQkVr2)Eb)jLhQK|`)OEMZC3>sdy{s0+1iDDU0LzhItWBk@fzCEH8b`NpiG_T=x z98L@sU805hJJYPI7sA!bsF6gTUuBsSZv~;#v$zz1ljLLUJ95Mrv}os~ zje|RZ*|8gBdesl2J^G4u3~DUPpN)s!hbAc4K4o*6KaXY{zvAYb8r{3#-jQ+ioy3@I z-5g!KkiIxD{fW2b;eMfPy6AQEcqcbx5m~!%`+8nW1(mn)%90%vqLiZd{yb+eAAofd zl(QkpC<(^5D~P9;jT>KI!6q4VNN!Uf>*uwF$;@)7@ap{FvUx&Qpu89}wD7v&c-{;| zXFAbN9APmDrM*-t_SuN$GB#(wU9RP$2x|Kb((G+bjnVkEl4^5X z>mGbqC4Z(88s{pb^wc4!g5SJd-~ZRpp;i9%WdN0=4qNciw2C97#=keQ*Sm)E@fXn{*p(fYRuO% z4(hLyGb1K~MdJezSKkXk#d7(}QS|XRooj}zJ_@&lnHlZ5O`I-Cg$Hw~7Iu(}H9Pd) zdw2PI_IrVV42NMXH3V>smc5u-s@5^Ueq|7Vjx0Y5*Jb7Y6E6R*zDkB-NP2#hBBEpB zgz|D6Q!v3Uqv2tFOWA#0E)LiIEykebp`EE_1~w!T9$lvQ24uUDI%U)MmZI9&UG54$ z8p;}1A%gm2IdX{!Uo^m^Y%dJ+k8U7;yA7y$Pw zd{nB<2?vEuoSXsWKt<5AgiK2TDP<*tBoeTn1~G#=6(PpZ)Am&1@FUfir(&4lIx*f~ zeNW01kiO94PFl11u&+kS(>zB~zi171s8Hh-J!>6!V0(ff$k>w|D4qNHrt5&fn<3B; z{lj}U5--bz6CkUT1dIW#8LEy(MU(&l#$vKa9n8nPUQ7mD(ZFm%XxCVzm=|NG*bl|< zW5tZlwZS+g-!MaJ49Elc%v5)52^o05X|a^asgSJ(`D&%bGR}B!l-mD_Hp}-U<(|z7 z=k`Phi7^ZMyLzXbm)8aVJZVW{P_-FBB1?S!1pQ zglN63ePwDn;Q7y?B3X=wUd~%MDVa3xb;agdbpq#lw_l$akV^RZu;wi5gVhB#+zvnA zIY9i#1Lj^Xy+k?#K-GY1#v6bV_U;%0LRo`--ITWT%y78AWr0XUNbF^nmSCYk;eTWD4GsiGrxz4u4Ck4*&-;dSi4z z(hazbdmUJ3^E?&2T_S!~7KK?w5uP6o96;EaA4(AX^2 zsm!#m4%vv)04gp`Ky>Y6{bV)P4>|Eo^S;m(krf3=DC$m%h6+>`l-J%oBUOuL>>KVv zp2lEKH)%jQ(hTyemT+>&hOf*35+q`f=77?r(mZ1cFWI=`^U= z$>Kjg+;_)xZltGCE5Z=oHb!a$KA($54DdY^F15?+wyoLnx-p`HfMpfnjviP>M_}M6 z&@4gT?mLG2<4%?v2)@MVu*OB0i|Aw|1V-g=OuI<6!Y-&DB#3POG9dU}aWG|C)=N18 zi)iTQ_0rEdyC#6v%zyiq&e3Sb&^5|o4n!~5ta&tz`w`sjECA*dkuqlP*XOVUw4@SQ zH3|q_6k|!T99?HcSiWTEy`V86BYdJ3-Grjo`%O_9!)GOo`P05*5nSJ|B~26Bz8r*Q zUz!CNgmpvw#PG*2Nr%|@LmFe3n0p#pbtjk(s7hr!!M9AAED*1JT)JP8?F8aWRzQrB zLF%Q0j}^#lenJevBi|h18&eiu0^^$Hk{i-(R3TEV2j)O|_ucjvpat2+K_Ybgja?Zm?dt`ax;!G^-3N@Q;=#Lw(NZS!)OC+Pj8hwYj`(n z#>8u8;LmZM$Keg9*O=I8BoVh^<6U>dvKK(Cb-pWw$1j=JktjkA<_t`^c%YZNHRef9 z*ir~vz*en)$T^0K@f^CDZr%@l*R8=6=r#(Va?EFAP&gjH1ESc)hNlSEq7_2Ltf*BL zJJ#G?@C^{Mg+3SuJ)@-Jp(Q_l8QbHj;jqoO&i&*4<)eLwN$2D z6u<^GEl00gH&>2q%o=HYn+?MGsZS~1IYr*$egGGp2GR>n*ID)rb=Vb^`gKF@S^;TB zynyrjI3EN%JW53tZpx%VDRgb;?3Jx_YE0{F$f&nsfLGndr`z*!l7sk?6lF!g^vx*G z<6!aRfUazPuVIN8@^R2XI>SY!hD6pr1(Xn^t=|`QQ(PAV^>}eK4PQp~tNsQ!*RCVsU|w zzX|W#u9X|Gv7Du+9UTPnbq9I5bje(haDq5RVrQ&K1}iz~CIv>v?PQOJo!8YBJTtBB z_w@p3QmXF2{YQ7LdedLec#@PZ0@pbc9N)u1W}Ou2=I79&t1#u;KSoeF6FaiQuebcdUiSntiXSpC$pjR~Gl%QqLYP z1OZWf3|OS3i38l?TOOGBS$tpVt-jbm*caVUI(KOJ%mf0P2JUNcnARf=Om<%a(^8w) z4l66!`#|`X6)3yDGP-@lpU4!F{My@59r_X_PCd1Yms$OhB}`gORBaDnX;0XzjbKM` znVn@`Q{E?xrQN(B&@e#<;_zI_(b6A=sl0bh4X{&-0qpldm3X5Tun-=Mp0}(>824t~ zGiBYwngP%!kX^=*2R$BSNM5g3UW5O6$6a>&D5 z0y<~AIGluhcVE34CSIXrz~m6ij_L9@FfFbD(eb=ZjrZ|3Bar5c)_SE)!fnABIJgKl zZz7EwngsVOabGhxES{`c6FlL&iUP`{m#f6P9&ojL5V*LK%=e=|^9AwF-1ny?hRTn= z0oCfkkrY0MnNWr#JsE&NxQlq@$iXO;UJ1b0ob?P>eyQTV%?y1u5n3#PFCNWz$hc|dmma!hb_V1J} zw7qUQAco#N|Cmhi7ANYhBcIkz6@v(p?cs*fy@6^sa3txM2vtApnN>1M;n1qmC2Pr6 z^eSE zUEC0BzPXGQf(Zp@I+WZE-yvW=PgP9_lzx=W!vthi65R#JmS-R3r@mL480w$W8YVA& zy43D$DRd4bvN*5ro4(H!YZs^DYBd4wg`K*reZX6xZ${pR@)GCa&1U}{4 zTNQfddJog|r=9!rE4ta+F*NUET_cD_#=LW`yI(~BK6WRPZY5%3-jO{ zd!Q|WBq-!jUu|&&B&E~fp`NBQJy?TwWkctiS=@~qDz7hr$T!xC4h;e;M{O(m3EsZr zw~UY-a`=&^5BVm-KP*8S$VtdmE4bkF;xjeUC*VjAqeXf zydt@!(=#-SYgX-qt>{kHV=Dm*WAC#?Q|AB}fR!uBI3hm3|Kx$n^;nbq^+j*Sz4&`L5)=|>5AQKt z?vXq`*>4#%U+tMu^eZ5hpQ7uj-u@^<9KQeutde)Uv5zXVgzKsM0Pli&Zz3dJ`s1@; z41zTfjZV*Mk+lvL(tPC!qPDxmkj1I@D+;GTnkaY}2ckUAm$`=V&}x*U0LV}}h!idT zke$xk(E;2aOUIdQrzY`95H0jjo>|h#*-9PChIFUfXoyo)ob{2qx?a%8Bo>J_MW;G}f8+E%`g`<= zG%;{j&HxCE@vieqkFEy9V&;}lwJQ}odj3!8#sd9`JeKE;XRJzwjJZLu>nHBkWeC6H zr&jF&46SQd-$Qe&$UU@bm>mNFIQ&;STJQ{ zSlgdpF7eH9YTxep{!zEs8D^g%k6Y~+!@3hnFLQJG82FT|yj%|R007?S)>`iT%&M7X zT1!n9lB37VSgM@&X|8o|VkjM51XA_=(+=_x9~OH|(;{4NHoi_Wi(8du6xVh*n=J7iwo z9xj2B7snFP#z?XuY24#90teV5qZ3W+9V!T?FO^j=;AsK>0?B1n{+0}&2T*3vpaK-6 zNq`M!<}DCFRIJ0p@ZldF_d_!@V<2x|KuiFgLcPK@#RYbi}PL*SrsvUKMo1&I?3}eva`fQz4SOE_q**IASe^3bf19p{l8bBMYiRU0Y~+H7R)+YtPp8RgcwWo z(+6f_NLFKzIDw#2(h6QtT)XnvPc)F>WhGh8M_|XSJ4~o|kQMfDH}v7ny;a{AfJldo z7H;U4P?X|a<%>2&Ugk*UDFfLznYSlc+M)Ir(q=`ET&S_Wsf zNKk(%mxp2l?S`KdcTLq=gSHDTq+Crc?+0Xsz~*eZ?jigdvZ#)(rO#z~(OBKUAhXCc z=_`sA7NzAOjD;Q2?@D5o*aKfLfQ=)Hfat7;u-g$(M*TIk+wtkwcnkY+VMPU6{zr~_eFt#>S=lU{xIJYxGYQ>x>cK1QEA!fF3w#aGigteyOa6K`x&VoR zIvm%QAP@+a3R?9;B5sm`0b2A#N&0qtwT5zcy~*0r@1p zS^=RFE)97~-4(iFIqpcaydv-yy|O3X`G=PD*P#;}(K%V1a5R`V;(6uVj|t%f9AAu= zhI7LHa*zG@ezbLCpOe#vi_s^Xxz9uS9yj0fXHVwo9<)eQG=&UT^mwCTW)^0;m{BsO z&8f?U+1Dj#FwY%}CV`u=?%d6UzvXZRge~!Z*b%?q2?~vgVOchdRLPEJP$P%`&ldDY zi4s>;pa@)8Lh93mQM)^HL4TGKTq#G;jn2ApL_1^5ez@RD=e8rPH~sI4%P-EXadiGDBg_K2lx(g#;>Bo+O`fgK;664;#GZ(vMU3&n{4yxGg*iqFYD zLM0XJGR#SbM$HkVIZN%w;Yp%7QK|#YQ~fmx)$vS?HRB^ zjs&LXzkj6g&u+Z&L__aey?3FSb+*@wMp}>HmLcXQ-ui5?_5w#nxzlKpHU5q)b|1TD z=el$`XQ*>z(9SFBps(ey*Gqn`Wmb_e97n@aZD@shLY)k*>!2=L%HcynBF`@Ql^vFF?3;hrvo;#el#&&$VV#XnskWbHd# zKlg6M8O|gN@e+DISPl|&EdZ5%x>wYWiWweGHq#vKBk8n@_zOkj7)b2Y&$9>C27xK* zYLDHYvt=DloIIR&tq}4?vOMzCYy0FWiB{5s_Cv;}?+~(8fW_%(N6~?a1wk{edBC7k zN;HDlC1RGxz}4{>~c*??ShWELDj;LpfZFhB8A|*zxrKo1xW%cGt$v z6_yMd$BFr;%s6G~6-LoBPg3IOCE@WKIQakkVL=MCnPB6?&aW9c|C*~Pn6HepajyH) znO=IyF9G@l;0Bl~ZjHW3)KtvO?pK(~GJP}lTskxh86@$WpRa-~b=YJzi&H-_AZKeXS_U|g5-56zc!S5=e0!o zttX8nycnP8iB(VcQ*2TFGKSJSV`2CIc>Ex!0sPQ=>L)rwkfD_$Bou^&LYhGi_H_2q zF(P)hv4!vI*#ppH%}srfA#}frn4BC@Jlc%7Iy1Kd4RA!ycYGY#)X9ez#)iCF(oRmEsiqISHPdSi>T&K$>c=yQn~GXqTDJmDvL%-+CfF(<8@Sz3Xw*D$(;weR6r z%EjUZ57hQr^X|x%QTGgk{^P<%qNUwTM!F@A{oj^{e{8SkOinxHD%pA#&zlbw`yEit z>54ebzEC(x9+HAiNNDxN-S4iM&!r(1TALZnj|!vFIb3O+a$#j9j(kthERn~9t?66# zHfr^o@1;%W&!ciZ9AH5iEactHej!t!>QPpD@>$2C6Cswz{BFs>Z1t$$lIv^q_+aC1 zLYfSb4gZxe6$z9Zz1+@KXQAIS7YYAK(w_h8M6G8Q7^DEvAw=!wsGmJn&Oox-dXkze zDqTjdJN0avAqe5q>E}&dE5>>S4{Xa1fHl1ov9*on6E&0`5C{{24;`H#kOrAX|BRa` ze;E?A&>f_jiTp+~0M1yzWolvbL}I-3RM1>W&RDP@z-t}HFw6b16<6^RJzhZVqEo-0 zbHF9!Ikf324z#rk`#p~q#9p1=*|!2-g@@}&bRZT5)lKs`q#aV0DXtcd}a=UR9!ZN_507ol7tCVZ7$O!sH;pg^ugNO2pRDkT?m(r zMu8Bquv(FkU()~vfX@jxRiF&<4ftI`4?-@W4*EW=6dkMJR3V@_??k??zf~rl01eEs zko$9s{{1^-a%Z? z*NEN4c)L1u0ZAzle*8T*$Lon`I=4EV+KtZP2&uUJGiiWQl1IQF{C3bo-c0`=(PywaUNJYnZBU#%sVnJ%96KxT9$tm9d@Q5|9Gi9 zZ7DHu8pI81>AR8egYliL$#Q4lmsDKqRk(nUAg=(6I*3vezxKK4dD4PHQlc(i$2v&U zsr+=;2AMNXy^hnLLycOj=88-8`lClNU~C~;%YMOxpC6`$0~5?cz0_GLbm6FrxgnUP z3fprFX7;=m{IXoz85PRAA`@QlJj@#-|1lm&q3GUie)#jTFM_we6-8hdivZ8odwm1q zzg+IF>aHelsA(@#o6Boa%3N%jzjpKTTPNa^K3j|>y%jVoRb{NeH1BAj7v4EAhiOKCm#PhX#ve+d4zpwx1Df9 zj|{%^EPr>y^7>h6Q15!7_o4kVoW_0h4Wr6*nTgl!dJ>4(1Iz;fhe!RvpjSS`gJ;cR zz>_Fpotff*qau>0+_8q=PdTcjI^dJ&K=uPv2)D+2F%b4F%S5M(3yQ6@)*t+y>MXKI zQ$HjKulT9=GS+`_b1#?Czt!MUD4l3tK;HiF#F#RCb<3GopzGc0PNl4{8-CN7*?}Sw zcLQ->;|5v(3UesJJLA4v&Ddp+`l8)dFuLAiYz?25f4IC|dL)4idEd6hglBO-{4FmUvC_a36zE>< zE+OGJ=1KDH}D&GWAM`Suk1rT9=Q zCFNJph!3aLrb%0Ij9_ANyedN~PT zcl&vC5(lEp=DPcQ?88(~QZy3hM`iyv872&oT6NCc);-=lEfUssk7tqd*5YA+qqbhI`L8$tT_O;G z?y-N?pQX~CegF@Z%M?k?UL}P$KUilVKUUHSJ_}fPI$TeexPy{;e%>??C<`?j(9C9D z9J?YBcQbO#$1f)1m3hZxQexCuzsE1uVxRR))O!kO_;W8^o50dqm(4Egph+0ecEwS$ zpl^yy$M{wg!zb;o_5l9fVdI8JE?AVVkpm+sDvCeK>xYJMp>Cj*3NL|nGL}ibIIBqH zBskyUjx}-*<5qQ>ZfO|!_JwYuAdJGtsYIXSR36+8l~gs^|70Kt7!XBJ*@^`T4D{!f zWXtWmn(wQ!R6ZY^%M~@(OakPnL2A%Hucn47#ro`WPjl@#ePT5+rzxMu~=<+p(Zssw! z%f!Pk$=8<$5r&@m14m;Kd9XX%3wn^PLB8I0sj>_K2N_{^LQ)X{iXHYqy(cWTf3J_^ zNE)~Q4pVPI08)kSIV}^hvCzxpQ&63kj-x(KLPSQLU1vNu|9MTB55!$W_8447p}j^- zj|x4uRv@e|WgosRd&~{J3av8LUvoClG7GF1Kx21e7E=|C(eklyk?LHeKj zF#L0j1QPjrrQOMI86Y)#B=i9JFadyBtv!8R^G_xb=!2Wh%S^2~$Na|>kj#dM6okwo z?9Sl$jz2?n^<)5lHS)#bkErg?3*ylMotR*O2o1)+Lx6vMU~_#AV6xx}B~8ma2ncNb z3Nlife_ZhQok|9SM?jGCenk_$hjely4#TblOs`|`mZ@Ia-xs3%=V_xOA{H>=bTK($ z{yB<&K7+nDCtM#-?4MuxCpZCd6e17+k*>l>|5XiLi|CAJ)i|8uzvRRP&nHmQ_0B)P z7K#i0DP65zIvaerXN({j@$Pu2D`5c+d)j$imBJ_RJ}Q|PHigu$KI(*!CH^;s03KH# zBy-T40t*2@5NLv6Ab)*e(_b>0;H{g0p)?c+*1~$zfuWl_fZz;9lN-cJ#-o4WWmatI zZTjDm5V&x>7#POT4KWSEKSTTHjsjWmz)Sq=mjhIhfb!PST+mea13*Hrr~Kmc&v}`B z2A6obp>jg~HAw`KZUrO@)}rhrd+Xkvq+nTtzxZ=hXRjQ%3QAG^i#XcAR$LQ=wN?|$ z!hfFcpVJ_Q8mV?<5J%_amp;k={u@tPFgJ{=V1F)_KPJZj4!E<$EXeB76lnEX4f}XL*oLK~?Jr%%@m~Mw#K3fMi+;yG{06}Y6Ysw^PYv3-NyFg3PuX1r z<}3)H0I{*2?m8M9ry{K2K4(eNG6>|y>A}Tn5-7ubEnM5Zj%`W#ZR4*oBV1Mi{;6RT z*^U7d1ELUcsvUE0P6q^3yv&a+=D7cL>kwtQz#%U{$hFK&mm6Tk3jhp+#sZ64vmv+$ z3}`#f%YFrLwm3L?XzB~buV0p|#Q^)?-u3G4pVMt97{SmFmmCf5K|cT>rA$>L3h`K6 zjgn-7j=wPTaEo@hE}#+sK@yY_tz7|6&p6<(qYV#HgqUE6wsQ>lxOi-QKs4-*OvDco6hFBv#T>V7J_8Ld(ZCF)x9V*pjQo2oFH_xjd_ zW^TFv0)v2QcIMc0fomU_wC5}4&dv%w@IKlGHho41@b3LEfZp-#fc7h_+2g=*tJ|mS zGeCY@*w~XRnSX42RdY2ew+hkIjboG8ZU0!Ag0<+(=^WXJXvAD%0RuXVt&N^R)#9NB z03cO$c`#d@TN>ip=y&b41G;bxRoXSo&w)RBbH1a~GyvaH%oMn8j-F6dzXE}?f0>cT zXa0%|wufavA+5KLhZ*3%t5OA@QW;c|J_XOAp+F_Wwq)*LU+lvj!D%2YXkKha>sSUf z_a`q_BDhyRr4TIWlnjKIJ_a!VowAzI@Psx1D=KKdj`pMmUf0z-R(?-rfX=er{z8-U z@kEBn=$&ETrEH0)Ym3idF>9r6G%xmGUoRN+Q@BR9ZKOFi4=$p)b|fD^1^Dem{f~^; zrdgMB6M2+XF_8Fxn7_J)zs_(FGM`~Q+nyZsdp>ywn#ok^EMbN-J5i|mx^519_ue6x zN`l%O;&1`V-5t2RT|{Nu$tR%@gdqU59-dVy583qsn%>&>qLW?s0W`%n-&E?08I?

eM#jmx^CU1@ne%yzQK^t4!;zPic8xN$=^CD%EiERoZoZv!O+ar8T`<3{+Y zj3xG`;)GZuG*>k&mK~r@TL)-EW|&C=4xf6;KZ>5UBoLb9k-jxE,(WY#_uG`MfK?D|FGa~;386z!2_-^CfGW)Y{^Rxx829l6gH zkMIDNg7aymi|X3w*+H(xj%}BS`Ti(r*(hAsoF?(8m zg}k%*J6NwSPZXtyfcyI&A?G)HPyK7)zG}%ZG>7`n?glNYy32P0-QudR0*}$k0wbT` z+A1L%&pVueXFkh+N@ZdM`r|d0Cs=#lC%ZNcU7`!xV#7(?uUU7qLxaqE2f$gvxgcS6 zurNg7s!HY5iI~`on96h_5`RbcwT|WJoOPDN>+0ia0|S$lL_j0ykALvLFtFc|}{ac|OBsi1p-o)hy4OJ+FtCng`$^)D%`Fj&rzb zH3wbNp4o$YsJ5HiwJGDlk*5hn(1_b%j{J>q{3}E=Wy;3+5=7I6TW9!9RLczt+bLNO z*%Xk{)KrSg`&`7^%_ZkFZ#D$Ln5;X~|YS}z)W|y|J$?-d4UO(hNp>~CxezN1f)Q45y?UzxX;SyQq9m2z%3+-#G z#^G-J@n}q{q^kmezT8`!SNp=6SyJ}R4$!yD6l-QZOOUl9y9OjRQy5C*74-MO)>c2P z^_`w9u1JwmVyApu=oM0w5yQ5bc0O9&boH?2memrU(4d=Y>8*D`Fs4p>ZOgW6L(xA@ zUP(gqqWL!&q-Z$R18VEC-<%@R6hiwbzmGEUzTR9(~(&7lYDaRg_%VAI+g zr8n+@y9&6q-`O6J7ELp_6VzS20h|1SxBw=4rLU>ub_Ekz*5GJGepi|7>i1c0H)aBE zy{fy3b2tms#h;2q^z8N3jEiM;c11r+t$0mL-9AhuCGid7*$?sAvxzyfdi)U{G(S5D z=le5mWidxm6Qwb#^`sdIMhd4ee{UYolJaTovKjR%>UPfeXW<1SJh$2kP6grw6bbTz zRV^*ew{3AByMEpJTqPC$G!OL^5&{x?p(Z9XA6ml-&4fupT8aGWDfWUS{XEucf$egdD|BYjJnJ z-1$NehI)1q%t!Y}R8JGg2FZ>IvJx{op`xD*AJN!s7B(mrj#ZY@3dQOr`er*jjbE2 zrfbli-gCCkOkzUx-(DHF=+yd$90lTh$*&ksQmwqB$s%<#0a7gTsO=h%M;OTrvS5&(kCZOE!zuCuIAdR z#`6WGXpG^`Zb2e=3uBRX3xMSnUtu#k11#|fTuCPo#`KO01M6jL>;@%nzTyAjCo5fr1@9eKW zyIie!wF*Z>A*Ouq^al~?Y!Z&}SDH(s377fmXS;C>61WueJzEMca~iQ<5ZSXW-i(-` zRp_a4FcIt)&#mH!pV8rlnlFok)%#S-7K|Kj z$Sp^pg!SZ;T?_TYc?xp6wDW8pGju5vjG($Z&Mm9Su%6TK@NiuwCJUz^gBU!P8WoA_ zXXi5=H|A@@0ttX0|f`Lk#hJB$Sspy<_BtX-bS^vDNE2L zt$<_8ropLQT83#!R>P#Nv-(;$bwk*_LXrGZ_r-o+T^q1?HglUS?|Z};nNKY7D^8u6 zK>If9#wQrnk3S>Wr!^eW=vR~Rnhlp@1kb#qAMIbSFCuHz_V#&DQ-DQrlI(l&BaEoDG$miJ z$jnu}H>VCT_4I&Dan*3uShApT$r)_kroKX#bUN2&oHHuQy!hR)G4-}1AT}lTd4@;D z?Mo(vC9=VG#d#|9cXU(nhBqww9{hA1bZ^@ie?#fr)G(4+BF(KwlE}7X=A-$Aq;%Co z)%>=nBoYQBoAWPSs=pt2Xh5HR^`w6H_;coJvSozWV+`6f^S=Ym}2R`gdIy>;! zM}yI^V9k6WA>?rkd@E(tX5Sk|igf_e^jxF&*CyrD?8JoP1yocgQy1?ZC6Rk1Rj=A_ zyyye83m8Z+lV*kP;Dn<;{6e)O^0^Bje>v)e!|iZF-T{86)fZaIYpI+V7TepFw<(1u zk@#vJ9AP_>;m-1664&zM+^DH7TW+sV9#4_=D(3ri8Rxbcd^i78I-dl9>mGWxTjr{G z;lze7=-9OUGlbn>JITI$cE~jvs$%?(jPV5To} zsmaw^sk}z{G;?vPWJvgX4}tj*O^pi6$mHjdpz%S@rm~sOs<2h%Q{s4^WS~BM{f58c zz^z-FGksN z^NylI#rVb0yEZiQ6&@rmaV7^4n{{y7W|-mJK4nLLKvT+upR7oF5x8tD3wIxA zqn?sm!JCu%n1?wIY?2#>LIU6{v%zI)^{Tno=uGr~SH#o^K}C!ZMFj27$l{Mu;x77! z6CM#q`(F~!|9r(VU3Nc1ee5x+~H$J58r+9 zucFJ}+cu^QXf>c9y*K^)Z~pax1|19wA{FcVU%S&^8D}6U18UHGpm_Ozd^;%YfOiT5 ze32fr%s5GX@J)HW-4Xu`{;ybAo$0RYhVmRJm{>+|*2jQ?Q-~R>+Ttw=;7bdNDRp); zi9l^%6IaG(D4sPZIcrH_B$Z#OqG^NdvJUt+=pJeAY9#cN9nt^+^O~X1P@;d`0;n_5 ze1i1-SM}-%ci-kNynY7f9)I2jD)!-Z#&xy{Kei_N#i@m#6~PIm?wm_#;Pi_F{J&3B z1z%HoT@-tD(OU5AXK= z_x%DCJpcsrf_=nuHA+xfeXax4BR*LnaYEKUIoOLz5jg)@L+N81)eT?kL|mFR3r|(g5KsO zkpG+atBVvB6;*L|ycIZL8A}>UXE~tS`~$|%pf(M;Ia|e%+6@B)e|7x^M^3lx$*@&Z zy~L3;K~+GHW}gF`F$=Ke5H&u_!=HRy`y`e_w@T7|!C9`Wdz~rG{!K}9r{y}ZAc+S} zop;gaA3;m0%l|9iAXsoT5hUD+kNvN;0J+)ZwN{PQd*%0sF20~HE^vP&AJ`t8__W^A zv_IL025m-?^4SaKfZVQO$alHIV8Fb?zWdo@i*B3q!}XIk%}Qgjz_+N?PH!;webG-=aFizD@03#5a7 z{91g_(qZlf)B{Ea>ZTsg{sP7SvG8ID;OYdNzCyK=AzkCISa*ilD{D19&9{(4uS?W( zU%CMyeO>>X^TPaaj9(?DdU!F#ZBk^ns=Ewu_O> zT=}#B=20S>7l+ml&ElnMbGaQL77$+gRE6nbss$w|7CAfIRRO%oGN72Rzinlva8r667sS>pqyKjRj^5v0XDtC z#a%MNEKtMyoGR>QTSkSwa7~=%yE&S%=T_<+&F_2htQ3sW+3tg6^Yphb-R4J+tIa}u zvy$DmyW2lg?S6YFmglT*cC10!ND3JwUR}Rz2gMg0GjIF-bzp1J|GA?v={7;@>E65` zQ8?Q=s4F)(RW?hAEJt2CfI4;c#aa3nzL$1IX^kXsTHVw`x9n(kIrgg#9bjg66rLY%+2me+2Icc9a9(Ne zEi~19_p~*uO#3nX^wPnG;(0%xM*n924;lnSbV&px+yDd!%?Au5uvDBE*VJp+}9<)iA9zKGG4a^vw6o+o`BQGhoxQqbju_XrkGAqr~<7ebu&&F+Phd+oh51 z2}qvm$1Z`|#=s7}>1@s`s#K^gHr&e(XNe9=tE99}t9@GDa8=c^8{JhAHO`{t&X{c6 z@-iUAZR0&j7IB(aWGu5K>~BN zyCoLt_Tf7)Kwj8s(=0mH?6{anRu%o;vkh?T`*{0bp*T4SpW^Lw#5=sKe(cKlvul^B z9cTUk|5v+!f79)U@mH}Kv0)FRca2Pa+fOF11eOvr5yw8Fyi14b+ZSN|^A5fpFseBY z)Hc1bdRfaAKhl~j{3V#+us}JDFM>rQWiUP|&2`2WG!L2OQb*o^$i*J@m|TMo>bi%X@N~8+XB<`JjgXPg_g?WE5Y-7Jy~n@A-FR|kR=^() z-JPwbf4a>W&mJdR_5a$t&abA^CCn;&6uZLGL^#okz?ZN7_Z# z$G}OdHzwy(Fjl$RPWVClji)w?m;{>4Wn-p+|X#AHm zm^ugb4jYxq)lA{Dc^pF3mZD|#wYd`K{=|g>0h<1^PFIBC2_~ubCm;Hsm-*Yh-m=;; zdAC?Iv^x%TC^po~g9<(i54D;XJ=y@GT-!UP+57Gv%%ZZ!u5GTbjPb!-f?|nNZULfF zpOXZ4h!B$#h#e_Z#g60XLn+GHq+Itkl!F7}2*yuiDm~n-;caOQAbT`k5v7uQG|CTp z5+L`Hd?$qN!Jdt0<(H`7Y?WKCmuJM|cH9ZM1O07h`4hRmXqA)~o33+yM%$eNS2Yjv zlJ%P?Bd|C3Tdy@Awpcrhl9eiq#-VgCAtDjT->BurAc)bncjnF;`HA-bSY{8Kdoldk z%g7(M%nA)$uYvTFQ|mw0D-0D8zqe(f*daN&dwDBJ>Luv!g(J-8L{i_4W4)&Hx#&fr zi15flsf>z29-zBMD<^%cRog$!>^dI(h*_*g>Pke?^)RPI6V_-XjAF0MBDR+Z^Hw9y zG~bsgO!KpHCESdj&b~*K=^k*5NDoJn}89?_ZWgqDc9J$AA_VIZf{ng-Vy!o zXgs}5Dvika5P;540*9fR5f58j17=Zg*c%A*)~(J8fSxDVu|Z<`3BMSkS49U3Xt?f2 zAKmAaP*9XU+531Qh&}rIxS1_|1~zwJwcb$5beB)nT>zCRBDpc$5zy)oUVqphvk^v?PAx)>kCeT6UB=M*TF*wCm|G7^jTIY~4(h%!8MZg4Qzq+7){b`TOg4 z8$FByGSRX8R&2+qLCESB5R^vIb3*qgizjbpEj$%BFUbjW+gI|^)1{_z-WBPgK-mBk zUpsS8gL$%$)=OP%gJQN{vWGS|ArgX44FzCCskhA9`}!&WrPlR@5fv+P&v?uh&z>79 zyTddcVOTAwv5B&&95!j9IA4)!{qet!Ln!v}Zit^>A9-*luFUjfTZcxzTf@{aC6f~% zf&%ql&&DVE4+TC8+8nMKe!reVdl#%!8x#QT1gvQm|hSRcPCGeG*u;GeeZXJ{S?7HL7T-H)epwCB|B&3## zS!$SQf~S0P=BEB3wdXaWG4c(E41LxZERU?74rr&O)ZKFG;(-n4kC_vg4}46+IyP6J zYV?8#wd!1<-t6J9ba^@*{#(1T-eD+73E}VFAk{`r-%nhMQN8OfE!{kVftQKj{aB+S zY45e1=jLtxVjN4e=BBulBm-FPIq#F4=Ke&^BdD|RbH(I`fXkG7iQ(Of)`=BGUq^K+ z?N?YDO=fN}g(J~}=0{g~{63ZyHuIwYyX)c^dlw{Atcx>;^-25H+*KJ&sn0QbtsB9{ znM7eI7}j$ml2<)Q92?bzu}U6l=g*o=O-3?C{B#^x!SAjnpvC7FViwjl2n3z;e+AWV ze#lY5BPp(aZkycpeccWiK`we?=M><@XAV#7)3YN*IyV=Df~t%%R(qBzqjMl0$-WY| zb(r+%spEv_%VR|ZXat-iH!uTKjj3kUq|13vmsDm?>O6rhYP9KTvht!eA&K@hU%Gsj z2)2c2L9rk~d|Tm19&;n?BPWt9#CKy_d5wYYopal%X*~71F~1h&zmwceILu*AH)(79 z2LphgYeT+8k+pU-CtrXfMqP$0eG(;H)`Cn{u_fx6Mk|UYlH$;U4BjB1uznqQl%#b? zY0|u6+At(7QF;!*hon*qC=`VIhL@C6TY#v%N&YQPcJS7;izgGWKift_tzFnNHOOA> zFXa^krmoX=E2kljYKmh|C5~B{Ek{B&N7D_OqFoEA>RP9nxuY#LKCG^OGh*gV4A<-%{jeT zF!#n7M5@lcO3a}$&o_8DIXaXQHsJgT0MVt$!}~3ycWf)b4e6I+^`jDv*L~U4OU9T! z{%}BPSPXQmd+RG~O;j3M9^r&czc#YXH7LG*K;$oMEOkXStB|~_VPH2gf;bS%j{-`l34-kek^x>ec1!FLa9P0*s-2*>s^Qas7$ODjP#>l#EJ0LmI$1{(hU z5iXH5rL>(32@^s0g%|q)_si#^6GTnlvV!Mg3+iR|MRPz2PgDzOPZUr;x2>i2f-iT zNOVfeG?y)6Hmgs8Aq=DBecbT!4*}YoskSyByuopo%}kN}#Wna^N<93U1L=*AmL9s8 zJDrYk8@9ThPH%%`(Q$wi2VA|WZYk!}BBp(K7|38( z`)0yD4@6<3mh{*&+Z6GfSz!MZF!~R@BQkMOWRSkEP5_x{tauq&;mE<(`v$56 z(MDACPtNHkIV3NHoX9r-{_V0>+REj?+BJ$)Qv~+4Zd!|MFz6>okz_!!YfjH#(72uH zhNJQoRidloF)>@!Ed8*tbepUR)*oP8*>ZrOI!PSQFZFfG(@J}hcw*gh={)YLn7jq< zf*WXyKsL!59HoKvlOr(%h~x>_JF~_rb=7@U{OlTFKH2vi60fy?bhlXf1E;iiaxfX! zk}7y2BS*GtGqYjcWx-#I@vM~X7Iz^{HG|I-j4$HsYjIs~6LT3Bs8aoIV**3nasK^N zM##`zlLj#Vh8|S&Zsic~L7C$If(o~xUm|2bA9V^BtFc~i?Q7FQLmoN{dKko366Dpg z>%QcPFWdX+VAv!M12`#OSH=3TAb)E-2wHf!pVS6ap00`=cwq-Q{m_7zlLM>s2lL!Y zRP(1jtWe`2ZkbWb*D?)`cJxADjsd+t&)&B$8s@y8O13#NHaph9YE%5k&}oxl zn?8Y!d3~VYMVSP~z*nj^lOqT=6fp-E`=qpi+CpAIL~hv??vyE>a;5G%?V5cTvaxI> z$}4NivPq7#(0=}faCWa%;wzEO9ujnLAvGnEUeb91@b)k~%A*A_P7#bK46grXKiz1Cb0MhX4Qo literal 0 HcmV?d00001 diff --git a/notebooks/textbook/Quantum_Neuron/img/classical_and_quantum_neuron.png b/notebooks/textbook/Quantum_Neuron/img/classical_and_quantum_neuron.png new file mode 100644 index 0000000000000000000000000000000000000000..963ade3002165364e1ee3b9b0469545c92baad80 GIT binary patch literal 54344 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

SHJGWu=$ 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 literal 0 HcmV?d00001 diff --git a/notebooks/textbook/Quantum_Neuron/inputs.txt b/notebooks/textbook/Quantum_Neuron/inputs.txt new file mode 100644 index 00000000..26e6de77 --- /dev/null +++ b/notebooks/textbook/Quantum_Neuron/inputs.txt @@ -0,0 +1,16 @@ +0000 +0001 +0010 +0011 +0100 +0101 +0110 +0111 +1000 +1001 +1010 +1011 +1100 +1101 +1110 +1111 diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..4248f98e905f6103c71f6e42cf9304e25597a99e GIT binary patch literal 693 zcmV;m0!sZKiwFP!00000|Lv5)ZWA#OhWjY1J(ulxJhsQV(jpEZkl=<;_FprZz!O3=^DQ%>U%{B^Hihx-T8{s;H%`IxTy{9$#`@6zi&t^2WEH23X3?Rxq0 zxZGV1=hJeXa_X-8aoS9|UoRzAL+x?X-j?XFFFQ>8Ac3-Qx>;ojrtxbnnJ@aBmRs2@ zKR-bS?zn-@$ABR^dGJ26yi1J8Av-kIyTHL3f83Z3B05jO$A}@2EqMrJy)hm_w8mKH zOOT!M1VN6K$HUOrEY|()X4RkE%xRzJ-HU0no3|+s<4M}3Z^Qm%x;1s< zbTQ;fzR59z$HG%xc=_(_`!{DF&ra)NIrRNqznaUDU#{md<->)5E?V)qJ>P7%a%=vW zL)^hbtuW=yF3Ig`RzrQlVuk;4pI!~4td%=04M+e(tTXQ literal 0 HcmV?d00001 diff --git a/notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py b/notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py new file mode 100644 index 00000000..bc58fd21 --- /dev/null +++ b/notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py @@ -0,0 +1,140 @@ +import json +import os +import time +import sys +import ast + +import numpy as np +import matplotlib.pyplot as plt +import random +from typing import List +from braket.aws import AwsQuantumJob, AwsSession +from braket.jobs.image_uris import Framework, retrieve_image +from braket.jobs import load_job_checkpoint, save_job_checkpoint, save_job_result +from braket.tracking import Tracker + +import pennylane as qml + +# Given an integer n, returns n random numbers such that the sum is greater than or equal to 0 and less than upper_total +def generate_random_numbers(n, upper_total): + random.seed(0) + random_numbers = [random.uniform(0, upper_total) for _ in range(n)] + + total = sum(random_numbers) + + while total < 0 or total >= upper_total: + random_numbers = [random.uniform(0, upper_total) for _ in range(n)] + total = sum(random_numbers) + + return sorted(random_numbers) + + +def init_pl_device(device_arn, n_qubits, shots, max_parallel): + return qml.device( + "braket.aws.qubit", + device_arn=device_arn, + wires=n_qubits, + shots=shots, + # Set s3_destination_folder=None to output task results to a default folder + s3_destination_folder=None, + parallel=True, + max_parallel=max_parallel, + # poll_timeout_seconds=30, + ) + +def linear_combination(inputs:str, weights, bias, ancilla, n_qubits): + for qubit in range(len(inputs)): + if(inputs[qubit]=='1'): + qml.PauliX(qubit) + + for qubit in range(len(inputs)): + + qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) + + qml.RY(2*bias, wires=ancilla) + +def activation_function(inputs:str, weights, bias, ancilla, output, n_qubits): + linear_combination(inputs, weights, bias, ancilla, n_qubits) + + qml.CY(wires=[ancilla, output]) + qml.RZ(phi=-np.pi/2, wires=ancilla) + + for qubit in range(len(inputs)): + qml.CRY(phi=-2*weights[qubit], wires=[qubit, ancilla]) # note '-(minus)' + + qml.RY(-2*bias, wires=ancilla) # note '-(minus)' + +def quantum_neuron(inputs:str, weights, bias, n_qubits, dev): + ancilla = len(inputs) # ID of an ancilla qubit + output = len(inputs) + 1 # ID of an output qubit + + theta = np.inner(np.array(list(inputs), dtype=int), np.array(weights)) + bias # linear comination with numpy + theta = theta.item() # Convert numpy array to native python float-type + + @qml.qnode(dev) + def af_circuit(): + activation_function(inputs, weights, bias, ancilla, output, n_qubits) + + return [qml.sample(qml.PauliZ(i)) for i in range(n_qubits)] + + # post-processing + sample = af_circuit() + sample = sample.T + sample = (1 - sample.numpy()) / 2 + + adopted_sample = sample[sample[:,ancilla] == 0] + + count_0 = len(adopted_sample[adopted_sample[:,output] == 0]) + count_1 = len(adopted_sample[adopted_sample[:,output] == 1]) + + p_0 = count_0 / (count_0 + count_1) + + q_theta = np.arccos(np.sqrt(p_0)) + + return theta, q_theta + +def main(): + t = Tracker().start() + + input_dir = os.environ["AMZN_BRAKET_INPUT_DIR"] + output_dir = os.environ["AMZN_BRAKET_JOB_RESULTS_DIR"] + job_name = os.environ["AMZN_BRAKET_JOB_NAME"] # noqa + checkpoint_dir = os.environ["AMZN_BRAKET_CHECKPOINT_DIR"] # noqa + hp_file = os.environ["AMZN_BRAKET_HP_FILE"] + device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"] + + # Read the hyperparameters + with open(hp_file, "r") as f: + hyperparams = json.load(f) + + n_inputs = int(hyperparams["n_inputs"]) + shots = int(hyperparams["shots"]) + interface = hyperparams["interface"] + max_parallel = int(hyperparams["max_parallel"]) + + n_qubits = n_inputs+2 # +2: ancilla and output qubit + + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi/2-bias) + + if "copy_checkpoints_from_job" in hyperparams: + copy_checkpoints_from_job = hyperparams["copy_checkpoints_from_job"].split("/", 2)[-1] + else: + copy_checkpoints_from_job = None + + # Run quantum neuron circuit + dev = init_pl_device(device_arn, n_qubits, shots, max_parallel) + theta_list = [] + q_theta_list = [] + + for i in range(2**n_inputs): + theta, q_theta = quantum_neuron(inputs_list[i], weights, bias, n_qubits, dev) + + theta_list.append(theta) + q_theta_list.append(q_theta) + + save_job_result({"theta_list": theta_list, "q_theta_list": q_theta_list, "task summary": t.quantum_tasks_statistics(), "estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost()}) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py b/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py new file mode 100644 index 00000000..fae0aeef --- /dev/null +++ b/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py @@ -0,0 +1,40 @@ +import pennylane as qml +import numpy as np + +from qn.quantum_neuron import ( + generate_random_numbers, + linear_combination, + quantum_neuron, + activation_function +) + +# WIP +''' +def test_linear_combination(): + for n_inputs in range(3, 7): + n_qubits = n_inputs+2 # +2: ancilla and output qubit + + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi/2-bias) + ancilla = len(weights) # ID of an ancilla qubit + + dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100) + + @qml.qnode(dev) + def lc_circuit(inputs, weights, bias, ancilla, n_qubits): + linear_combination(inputs, weights, bias, ancilla, n_qubits) + return qml.expval(qml.PauliZ(ancilla)) + + output = lc_circuit(inputs_list[1], weights, bias) + print(output) + + # expected_output = np.cos(weights[0]) * np.cos(weights[2]) * np.cos(bias) - np.sin(weights[0]) * np.sin(weights[2]) * np.cos(bias) + + # np.testing.assert_almost_equal(output, expected_output, decimal=6) + + +# def test_activation_function(): + +# def test_quantum_neuron(): +''' diff --git a/notebooks/textbook/Template.ipynb b/notebooks/textbook/Template.ipynb index d1832b15..f1303b80 100644 --- a/notebooks/textbook/Template.ipynb +++ b/notebooks/textbook/Template.ipynb @@ -107,9 +107,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.5 64-bit ('braket')", + "display_name": "conda_braket", "language": "python", - "name": "python3" + "name": "conda_braket" }, "language_info": { "codemirror_mode": { @@ -121,9 +121,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.7.12" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d" @@ -131,5 +130,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py b/src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py index 2a1faa26..e3ca15c6 100644 --- a/src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py +++ b/src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py @@ -15,4 +15,4 @@ cost_function, qaoa, run_qaoa_circuit, -) +) \ No newline at end of file diff --git a/src/braket/experimental/algorithms/quantum_neuron/__init__.py b/src/braket/experimental/algorithms/quantum_neuron/__init__.py new file mode 100644 index 00000000..e2ee15e3 --- /dev/null +++ b/src/braket/experimental/algorithms/quantum_neuron/__init__.py @@ -0,0 +1,18 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). You +# may not use this file except in compliance with the License. A copy of +# the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file is +# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF +# ANY KIND, either express or implied. See the License for the specific +# language governing permissions and limitations under the License. + +print('inside __init__.py') + +from braket.experimental.algorithms.quantum_neuron.quantum_neuron import ( # noqa: F401 + linear_combination, +) \ No newline at end of file diff --git a/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py b/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py new file mode 100644 index 00000000..81ccea9a --- /dev/null +++ b/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py @@ -0,0 +1,144 @@ +import json +import os +import time +import sys +import ast + +import numpy as np +import matplotlib.pyplot as plt +from typing import List +from braket.aws import AwsQuantumJob, AwsSession +from braket.jobs.image_uris import Framework, retrieve_image +from braket.jobs import load_job_checkpoint, save_job_checkpoint, save_job_result +from braket.tracking import Tracker + +import pennylane as qml + +def init_pl_device(device_arn, n_qubits, shots, max_parallel): + return qml.device( + "braket.aws.qubit", + device_arn=device_arn, + wires=n_qubits, + shots=shots, + # Set s3_destination_folder=None to output task results to a default folder + s3_destination_folder=None, + parallel=True, + max_parallel=max_parallel, + # poll_timeout_seconds=30, + ) + +def linear_combination(inputs:str, weights, bias, ancilla): + # print(f'len(inputs): {len(inputs)}') + for qubit in range(len(inputs)): + if(inputs[qubit]=='1'): + qml.PauliX(qubit) + + for qubit in range(len(inputs)): + # print(f'qubit: {qubit}') + + qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) + + qml.RY(2*bias, wires=ancilla) + +def activation_function(inputs:str, weights, bias, ancilla, output, n_qubits): + ''' + for qubit in range(len(inputs)): + if(inputs[qubit]=='1'): + qml.PauliX(qubit) + + for qubit in range(len(inputs)): + qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) + + qml.RY(2*bias, wires=ancilla) + ''' + linear_combination(inputs, weights, bias, ancilla) + + qml.CY(wires=[ancilla, output]) + qml.RZ(phi=-np.pi/2, wires=ancilla) + + for qubit in range(len(inputs)): + qml.CRY(phi=-2*weights[qubit], wires=[qubit, ancilla]) # note '-(minus)' + + qml.RY(-2*bias, wires=ancilla) # note '-(minus)' + + # return [qml.sample(qml.PauliZ(i)) for i in range(n_nodes)] + +def quantum_neuron(inputs:str, weights, bias, n_qubits, dev): + ancilla = len(weights) # ID of an ancilla qubit + output = len(weights) + 1 # ID of an output qubit + + theta = np.inner(np.array(list(inputs), dtype=int), np.array(weights)) + bias # linear comination with numpy + theta = theta.item() # Convert numpy array to native python float-type + + # ここでaf_circuitが何かをreturnするように修正する必要がある + # af_circuit = qml.QNode(af, dev) + @qml.qnode(dev) + def af_circuit(): + activation_function(inputs, weights, bias, ancilla, output, n_qubits) + + return [qml.sample(qml.PauliZ(i)) for i in range(n_qubits)] + + + sample = af_circuit() + sample = sample.T + sample = (1 - sample.numpy()) / 2 + + adopted_sample = sample[sample[:,ancilla] == 0] + + count_0 = len(adopted_sample[adopted_sample[:,output] == 0]) + count_1 = len(adopted_sample[adopted_sample[:,output] == 1]) + + p_0 = count_0 / (count_0 + count_1) + + q_theta = np.arccos(np.sqrt(p_0)) + + return theta, q_theta + +def main(): + t = Tracker().start() + + input_dir = os.environ["AMZN_BRAKET_INPUT_DIR"] + output_dir = os.environ["AMZN_BRAKET_JOB_RESULTS_DIR"] + job_name = os.environ["AMZN_BRAKET_JOB_NAME"] # noqa + checkpoint_dir = os.environ["AMZN_BRAKET_CHECKPOINT_DIR"] # noqa + hp_file = os.environ["AMZN_BRAKET_HP_FILE"] + device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"] + + # Read the hyperparameters + with open(hp_file, "r") as f: + hyperparams = json.load(f) + + n_inputs = int(hyperparams["n_inputs"]) + weights = ast.literal_eval(hyperparams["weights"]) + bias = float(hyperparams["bias"]) + shots = int(hyperparams["shots"]) + interface = hyperparams["interface"] + max_parallel = int(hyperparams["max_parallel"]) + + if "copy_checkpoints_from_job" in hyperparams: + copy_checkpoints_from_job = hyperparams["copy_checkpoints_from_job"].split("/", 2)[-1] + else: + copy_checkpoints_from_job = None + + # Read input strings from input file + with open(f"{input_dir}/input/inputs.txt") as f: + inputs = [s.strip() for s in f.readlines()] + + # Prepare quantum neuron circuit + n_qubits = n_inputs+2 # +2: ancilla and output qubit + + # Run quantum neuron circuit + dev = init_pl_device(device_arn, n_qubits, shots, max_parallel) + theta_list = [] + q_theta_list = [] + + for i in range(2**n_inputs): + theta, q_theta = quantum_neuron(inputs[i], weights, bias, n_qubits, dev) + + theta_list.append(theta) + q_theta_list.append(q_theta) + + save_job_result({"theta_list": theta_list, "q_theta_list": q_theta_list, "task summary": t.quantum_tasks_statistics(), "estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost()}) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py new file mode 100644 index 00000000..88deaaa9 --- /dev/null +++ b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py @@ -0,0 +1,4 @@ +import pennylane as qml +import numpy as np +from quantum_neuron import quantum_neuron + From 581573a77cbc9c40d8b2aac381a57bf8c0bd6c4c Mon Sep 17 00:00:00 2001 From: yuttaky Date: Fri, 31 Mar 2023 06:46:53 +0000 Subject: [PATCH 02/37] second commit --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 93 +++++++++------ .../textbook/Quantum_Neuron/model.tar.gz | Bin 693 -> 679 bytes .../Quantum_Neuron/qn/quantum_neuron.py | 16 ++- .../textbook/Quantum_Neuron/run_test.ipynb | 108 ++++++++++++++++++ .../Quantum_Neuron/test_quantum_neuron.py | 70 +++++++++--- 5 files changed, 232 insertions(+), 55 deletions(-) create mode 100644 notebooks/textbook/Quantum_Neuron/run_test.ipynb diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index dbfa6325..1ed49d9a 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -14,28 +14,35 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, + "outputs": [], + "source": [ + "from qn.quantum_neuron import (\n", + " generate_random_numbers,\n", + " linear_combination,\n", + " quantum_neuron,\n", + " activation_function\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'\\nfrom braket.experimental.algorithms.quantum_neuron import (\\n generate_random_numbers,\\n linear_combination,\\n quantum_neuron,\\n activation_function\\n)\\n'" + "'\\nfrom braket.experimental.algorithms.quantum_neuron.quantum_neuron import (\\n generate_random_numbers,\\n linear_combination,\\n quantum_neuron,\\n activation_function\\n)\\n'" ] }, - "execution_count": 1, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from qn.quantum_neuron import (\n", - " generate_random_numbers,\n", - " linear_combination,\n", - " quantum_neuron,\n", - " activation_function\n", - ")\n", - "\n", "'''\n", - "from braket.experimental.algorithms.quantum_neuron import (\n", + "from braket.experimental.algorithms.quantum_neuron.quantum_neuron import (\n", " generate_random_numbers,\n", " linear_combination,\n", " quantum_neuron,\n", @@ -46,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -63,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -132,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -175,7 +182,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -184,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -204,12 +211,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta: 1.1272124273195654\n" + ] + } + ], "source": [ "theta = np.inner(np.array(list(inputs_list[11]), dtype=int), np.array(weights)) + bias # linear comination with numpy\n", "theta = theta.item() # Convert numpy array to native python float-type\n", + "print(f'theta: {theta}')\n", "\n", "ancilla = n_inputs # ID of an ancilla qubit\n", "output = n_inputs + 1 # ID of an output qubit\n", @@ -225,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -245,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -295,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -359,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -367,8 +383,7 @@ "output_type": "stream", "text": [ "In the sample obtained, we adopt the cases where its ancilla qubit is 0.\n", - "[[1. 0. 1. 1. 0. 0.]\n", - " [1. 0. 1. 1. 0. 0.]\n", + "[[1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -378,7 +393,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -397,11 +411,11 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -409,6 +423,11 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -431,13 +450,11 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]]\n" @@ -469,7 +486,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -477,7 +494,7 @@ "output_type": "stream", "text": [ "theta: 1.1272124273195654\n", - "q_theta: 1.2820534188408945\n" + "q_theta: 1.4067623857719214\n" ] } ], @@ -501,7 +518,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -527,7 +544,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -540,7 +557,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -562,14 +579,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "QUEUED\n" + "RUNNING\n" ] } ], @@ -579,7 +596,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -587,7 +604,7 @@ "output_type": "stream", "text": [ "SV1 Task Summary\n", - "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.933, 'billed_execution_duration': 48.0}}\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.641, 'billed_execution_duration': 48.0}}\n", "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with SV1: 0.06 USD\n" ] @@ -692,12 +709,12 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "

" ] diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz index 4248f98e905f6103c71f6e42cf9304e25597a99e..2ab8def51f760b862a3dc272f66260db6eb85fdf 100644 GIT binary patch delta 670 zcmV;P0%85N1*Zj&6@Q#d>KTv6<6LPG2M|bbLnv~Sm6|r2w7Z*9sQT`VofcJv8x%Oq zmq^)+?SK9m+uOIpZaogu^I^L=cqSY;$3%_W^Yj;(p#dUr7$P7v4iFt4H14?!J!UtI zxj%5fo$G0Ff56(`;C6D_=ZkjyusCbG{JPD{wx7(J+sP((t$#k;4^Pjxr^9@i$2`4k z`(ZVV?Q*WM8k!t7lj{=QZpsRn+-aZ;9IqCm26O+lN{(mknCELQmaD&brN(rAjkAs+j=$s zsf)F~0K}}R89jNZ%>gwhrAD<3EK-a1AqH`xb#T%ZHGg$gNT931qh7vJSS^x^o>Qwr zf-F=7LeyrnFMdc8^ACZDWg}VlQ8$u#Z$V4a%~2y-m=;kLd?JcS5>wQq^vHttFX^sJ zc_#o?1!Bz%-Y4(Xit|-LHANdAd}*y<>C2dhi)Pq$-NRwa{brWG472_Doy}&;_IkBw zkFIukGk@;77sIOCt@F6;k8+p4Z8t~5HPnT}*>)WCNl%r#7ar=s%Xe?zzd8AMa$E~RGlKgTG$<*Cdg<)KESuazw*wzizR`A31dA03z ztX!$fbzW`8_GX;i{p%NoVHk#C7=~dOhG7_nVHX&NVHk#C7=~dOhVftV9n2qf@c<|Q E0KVlzjsO4v delta 684 zcmV;d0#p5`1+@i`6@NXK?RY%4$GOrX4j_==hEU`tD>ZGBZFjw;Q1#szJ4Hgk4N5Qb zB~p^{c;=sf?Tr02Z}Ze$PQ(7_i2wuOi5fWY>!%5TjUkdO3(jK$22G%&2A)dL&&*R! z;}QIIuV07z2h#or_wD(ZuKN68bprdfv0XIx?LO^#`G4}b++7am({i11>aP27 z+Dy4$FC|t(?QzrImgulAJ52i^fwFMAS!D^P@oO!aFZ!I8TiGl>KS2lXxPi{cfFU}0 z@IJD48_>7a)#MB|)8 zGG0Do9XiS=qJ)vF-=S1=0ZQ{CkU0AK2&yK@le=9EKnKQFP2#!C%_0|_Gi+Venm~tZ?d{awGB%aLEM=P~8Og@7(v@wq+UY`1c2{+L7D!9%Su<;^b1 z?P^v-eZpde|8bvQ4Wq1;J9fQIn|\n", + "z_expected_value: -0.13088\n", + "\n", + "theoritical_z_expected_value: -0.13088\n", + "\n", + "0: ────╭●────────────────────────────────────────────────┤ \n", + "1: ──X─│─────────╭●──────────────────────────────────────┤ \n", + "2: ────│─────────│─────────╭●────────────────────────────┤ \n", + "3: ──X─│─────────│─────────│─────────╭●──────────────────┤ \n", + "4: ────╰RY(0.07)─╰RY(0.31)─╰RY(0.79)─╰RY(1.29)──RY(0.10)─┤ \n", + "z_expected_value: -0.13116\n", + "\n", + "theoritical_z_expected_value: -0.13116\n", + "\n", + "0: ────╭●──────────────────────────────────────────────────────────┤ \n", + "1: ────│─────────╭●────────────────────────────────────────────────┤ \n", + "2: ──X─│─────────│─────────╭●──────────────────────────────────────┤ \n", + "3: ────│─────────│─────────│─────────╭●────────────────────────────┤ \n", + "4: ──X─│─────────│─────────│─────────│─────────╭●──────────────────┤ \n", + "5: ────╰RY(0.06)─╰RY(0.14)─╰RY(0.40)─╰RY(0.89)─╰RY(1.28)──RY(0.10)─┤ \n", + "z_expected_value: -0.20478\n", + "\n", + "theoritical_z_expected_value: -0.20478\n", + "\u001b[32mPASSED\u001b[0m\n", + "test_quantum_neuron.py::test_quantum_neuron \n", + "q_theta: 0.9181000628169432\n", + "expected_q_theta: 0.9205739886726427\n", + "\n", + "q_theta: 0.9185355467979665\n", + "expected_q_theta: 0.9167356239940488\n", + "\n", + "q_theta: 0.9914070072591556\n", + "expected_q_theta: 0.9892466704720225\n", + "\u001b[32mPASSED\u001b[0m\n", + "\n", + "\u001b[33m=============================== warnings summary ===============================\u001b[0m\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/graphml.py:346\n", + " /home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/graphml.py:346: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n", + " Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " (np.int, \"int\"), (np.int8, \"int\"),\n", + "\n", + "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/gexf.py:223\n", + " /home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/gexf.py:223: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n", + " Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " (np.int, \"int\"), (np.int8, \"int\"),\n", + "\n", + "-- Docs: https://docs.pytest.org/en/latest/warnings.html\n", + "\u001b[33m\u001b[1m===================== 2 passed, 2 warnings in 7.79 seconds =====================\u001b[0m\n" + ] + } + ], + "source": [ + "!pytest test_quantum_neuron.py -s" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74305562", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "conda_braket", + "language": "python", + "name": "conda_braket" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py b/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py index fae0aeef..b5df0a31 100644 --- a/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py +++ b/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py @@ -1,3 +1,16 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). You +# may not use this file except in compliance with the License. A copy of +# the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file is +# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF +# ANY KIND, either express or implied. See the License for the specific +# language governing permissions and limitations under the License. + import pennylane as qml import numpy as np @@ -8,33 +21,58 @@ activation_function ) -# WIP -''' def test_linear_combination(): - for n_inputs in range(3, 7): + for n_inputs in range(3, 6): + print() n_qubits = n_inputs+2 # +2: ancilla and output qubit - - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] bias = 0.05 # constant weights = generate_random_numbers(n_inputs, np.pi/2-bias) ancilla = len(weights) # ID of an ancilla qubit - dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100) + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + + dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) @qml.qnode(dev) - def lc_circuit(inputs, weights, bias, ancilla, n_qubits): - linear_combination(inputs, weights, bias, ancilla, n_qubits) + def lc_circuit(): + linear_combination(inputs_list[input_to_test], weights, bias, ancilla, n_qubits) return qml.expval(qml.PauliZ(ancilla)) - output = lc_circuit(inputs_list[1], weights, bias) - print(output) + print(qml.draw(lc_circuit, decimals=2)()) + + z_expected_value = lc_circuit() + print(f'z_expected_value: {z_expected_value}\n') - # expected_output = np.cos(weights[0]) * np.cos(weights[2]) * np.cos(bias) - np.sin(weights[0]) * np.sin(weights[2]) * np.cos(bias) + theta = np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + bias # linear comination with numpy + theta = theta.item() # Convert numpy array to native python float-type + # print(f'theta: {theta}') + # print(f'RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0))}') + # print(f'shape of RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0)).shape}') + + theoritical_z_expected_value = np.cos(theta)**2 - np.sin(theta)**2 # Z expected value of Ry(2*theta)|0> + print(f'theoritical_z_expected_value: {z_expected_value}') + - # np.testing.assert_almost_equal(output, expected_output, decimal=6) + np.testing.assert_almost_equal(z_expected_value, theoritical_z_expected_value, decimal=2) - -# def test_activation_function(): +def test_quantum_neuron(): + for n_inputs in range(3, 6): + print() + n_qubits = n_inputs+2 # +2: ancilla and output qubit + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi/2-bias) -# def test_quantum_neuron(): -''' + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + + dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) + + theta, q_theta = quantum_neuron(inputs_list[input_to_test], weights, bias, n_qubits, dev) + print(f'q_theta: {q_theta}') + + expected_q_theta = np.arctan(np.tan(theta)**2) + print(f'expected_q_theta: {expected_q_theta}') + + np.testing.assert_almost_equal(q_theta, expected_q_theta, decimal=2) + \ No newline at end of file From 3d8ce23fbc4ff98f74c9d697394efb9f8f5c6eb4 Mon Sep 17 00:00:00 2001 From: yuttaky Date: Fri, 31 Mar 2023 06:58:29 +0000 Subject: [PATCH 03/37] third commit --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 23 ++++++++---------- notebooks/textbook/Quantum_Neuron/inputs.txt | 16 ------------ .../textbook/Quantum_Neuron/model.tar.gz | Bin 679 -> 692 bytes 3 files changed, 10 insertions(+), 29 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/inputs.txt diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index 1ed49d9a..cbadc67b 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -406,15 +406,12 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -423,7 +420,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -435,6 +431,7 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -457,7 +454,7 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]]\n" + " [1. 0. 1. 1. 0. 0.]]\n" ] } ], @@ -494,7 +491,7 @@ "output_type": "stream", "text": [ "theta: 1.1272124273195654\n", - "q_theta: 1.4067623857719214\n" + "q_theta: 1.3652273956337229\n" ] } ], @@ -579,14 +576,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "RUNNING\n" + "COMPLETED\n" ] } ], @@ -596,7 +593,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -604,7 +601,7 @@ "output_type": "stream", "text": [ "SV1 Task Summary\n", - "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.641, 'billed_execution_duration': 48.0}}\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.511, 'billed_execution_duration': 48.0}}\n", "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with SV1: 0.06 USD\n" ] @@ -709,12 +706,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/notebooks/textbook/Quantum_Neuron/inputs.txt b/notebooks/textbook/Quantum_Neuron/inputs.txt deleted file mode 100644 index 26e6de77..00000000 --- a/notebooks/textbook/Quantum_Neuron/inputs.txt +++ /dev/null @@ -1,16 +0,0 @@ -0000 -0001 -0010 -0011 -0100 -0101 -0110 -0111 -1000 -1001 -1010 -1011 -1100 -1101 -1110 -1111 diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz index 2ab8def51f760b862a3dc272f66260db6eb85fdf..28db0e38691a5c914c31eb4db67951c0dd1f3a5f 100644 GIT binary patch delta 682 zcmV;b0#*H|1+)c_7JtjuV~@w4Txk&p5J+%CC~}jPnl_tlcfF;6`tFR~7NNooN-y&z zQa0o9`1e2dj@>lx^3J|ukoG_LzBnDzMVCLU&$>Rn?$V|k7t7}RVxRg>9)IqK+wCk(`FLqJ#ZtU*TrWCA+?=cxpv2SO7d7_uB4mY8QI zBp0NxkyT=;XMd5TB0CeTiJn5qGZD)YJ~)PGEmnmhK$a|O2xN+_3InsVF@QlP_EjL1 zB#XA>d-8Q*>)4nWK|aXNb6q7yvN2XQ7>%!6CWn^MILWh7wptZN5G7uwgQdWq#n!9U zZ!XsTk?7#yWV#n0s}B}qKvUwLrBX2hTIYk0CdxjDk$&_Jo~!LnOk*oO^&oas0b(Lz z5TD42Own6{OwvzhrI7?;LN(p9mm^`tD{m3+1o0 zW%@EL?|)A7a=F}e*V}b>bTy}ap8FTmwx4$?593kl)3;%NG+jfTIGqi7k|#N1=DzS$ z2VTB=`~JO!@9MNNWIO@N~P|$(8wI4#w8p)(TVJ_DQZ* zvmR=D#aeo}Os|Gf#>xe|+@uGU+z}ny7c5>S1i+235IBUE7y3NbBpUj%u$tHKLK7ZT~PtUif!+e>?JiToD zVKt2Ha;~u&njAKh>k{2=$_kj=X`l=ouNI>QbN{tUj%V$d=WAW8e?PgY3x|!Ha*7yJ z2#lOWza>T#Py&MI5G8ux!v>}0ocXl0es*RlmJXFLUfEtJe62T ziHUtwVW(N7=zk%xDkkqDItd)hJSS9Agy<6pB2|ZKKvNbs47voX!263WwaMBeub$?YzpsT^7UcORTEs~3#Q>#LP zEK~$S)Mm3Uen=AY4}pkfBU$%RH8?w8 zCjeFjV$BTRC-2pY^Ho7LMH?S{X{})C%b16YX4rMz!(q$)W|qGUv;Fy<&1TE?dbMbe zu6B7d?ti)$!>Ze@^SJGga+kktH%G%Y)P=*@b{zCcPnEkD9_ql$cW>XnIr(^UTnEb; zZ*SVguAK1sa@Xf^fBv;?1Uh)STCeqz{BjP-)ZJBuVO(`tFH^JF)(zEG@Wb_awe5AR zT&c@-UTwzqW}Mvp>lcP$7=~dOhG7_nVHk#C7#4 Date: Sat, 6 May 2023 02:01:08 +0000 Subject: [PATCH 04/37] enable import quantum_neuron --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 251 +++++++----------- .../img/classical_and_quantum_neuron.png | Bin 54344 -> 53879 bytes .../textbook/Quantum_Neuron/model.tar.gz | Bin 692 -> 673 bytes .../algorithms/quantum_neuron/__init__.py | 6 +- .../quantum_neuron/quantum_neuron.py | 135 +++++++--- .../quantum_neuron/test_quantum_neuron.py | 76 +++++- 6 files changed, 274 insertions(+), 194 deletions(-) diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index cbadc67b..ab844148 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -13,10 +13,12 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "from qn.quantum_neuron import (\n", + "from braket.experimental.algorithms.quantum_neuron.quantum_neuron import (\n", " generate_random_numbers,\n", " linear_combination,\n", " quantum_neuron,\n", @@ -27,34 +29,9 @@ { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'\\nfrom braket.experimental.algorithms.quantum_neuron.quantum_neuron import (\\n generate_random_numbers,\\n linear_combination,\\n quantum_neuron,\\n activation_function\\n)\\n'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "'''\n", - "from braket.experimental.algorithms.quantum_neuron.quantum_neuron import (\n", - " generate_random_numbers,\n", - " linear_combination,\n", - " quantum_neuron,\n", - " activation_function\n", - ")\n", - "'''" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "import time, os, sys, ast\n", @@ -68,23 +45,6 @@ "import pennylane as qml" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.27.0\n" - ] - } - ], - "source": [ - "print(qml.version())" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -139,12 +99,14 @@ }, { "cell_type": "code", - "execution_count": 5, - "metadata": {}, + "execution_count": 3, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -182,8 +144,10 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, + "execution_count": 4, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "n_inputs = 4" @@ -191,8 +155,10 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": 5, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", @@ -211,8 +177,10 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": 6, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", @@ -241,8 +209,10 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": 7, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "n_lc_qubits = n_inputs + 1\n", @@ -261,33 +231,14 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, + "execution_count": 8, + "metadata": { + "tags": [] + }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The datapath rcparam was deprecated in Matplotlib 3.2.1 and will be removed two minor releases later.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The savefig.frameon rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The text.latex.unicode rcparam was deprecated in Matplotlib 3.0 and will be removed in 3.2.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The verbose.fileo rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The verbose.level rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", - " self[key] = other[key]\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -311,33 +262,14 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": 9, + "metadata": { + "tags": [] + }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The datapath rcparam was deprecated in Matplotlib 3.2.1 and will be removed two minor releases later.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The savefig.frameon rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The text.latex.unicode rcparam was deprecated in Matplotlib 3.0 and will be removed in 3.2.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The verbose.fileo rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", - " self[key] = other[key]\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/_collections_abc.py:841: MatplotlibDeprecationWarning: \n", - "The verbose.level rcparam was deprecated in Matplotlib 3.1 and will be removed in 3.3.\n", - " self[key] = other[key]\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -375,8 +307,10 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, + "execution_count": 10, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", @@ -406,10 +340,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -431,7 +361,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -452,9 +381,7 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]]\n" + " [1. 0. 1. 1. 0. 1.]]\n" ] } ], @@ -483,15 +410,17 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": 11, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "theta: 1.1272124273195654\n", - "q_theta: 1.3652273956337229\n" + "q_theta: 1.5707963267948966\n" ] } ], @@ -515,8 +444,10 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": 12, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "# Hybrid Jobs general setting\n", @@ -541,8 +472,10 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "execution_count": 13, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "# Hybrid Jobs setting specific for SV1\n", @@ -554,21 +487,21 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, + "execution_count": 14, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "# Run on SV1\n", "\n", "sv1_job = AwsQuantumJob.create(\n", " device=sv1,\n", - " source_module=\"qn\",\n", + " source_module=\"/home/ec2-user/SageMaker/amazon-braket-algorithm-library/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py\",\n", " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", " image_uri=image_uri,\n", - " # Relative to the source_module\n", - " entry_point=\"qn.quantum_neuron\",\n", + " entry_point=\"quantum_neuron:main\",\n", " copy_checkpoints_from_job=None,\n", - " # general parameters\n", " hyperparameters=hyperparameters,\n", " wait_until_complete=False\n", ")" @@ -576,14 +509,16 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, + "execution_count": 15, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "COMPLETED\n" + "QUEUED\n" ] } ], @@ -593,15 +528,17 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, + "execution_count": 16, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SV1 Task Summary\n", - "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.511, 'billed_execution_duration': 48.0}}\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.444, 'billed_execution_duration': 48.0}}\n", "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with SV1: 0.06 USD\n" ] @@ -623,8 +560,10 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, + "execution_count": 17, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "# Hybrid Jobs setting specific for IonQ\n", @@ -636,31 +575,33 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": {}, + "execution_count": 18, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ "# Run on IonQ\n", "\n", "ionq_job = AwsQuantumJob.create(\n", " device=ionq,\n", - " source_module=\"qn\",\n", + " source_module=\"/home/ec2-user/SageMaker/amazon-braket-algorithm-library/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py\",\n", " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", " image_uri=image_uri,\n", - " # Relative to the source_module\n", - " entry_point=\"qn.quantum_neuron\",\n", + " entry_point=\"quantum_neuron:main\",\n", " copy_checkpoints_from_job=None,\n", - " # general parameters\n", " hyperparameters=hyperparameters,\n", - " input_data=\"inputs.txt\",\n", + " # input_data=\"inputs.txt\",\n", " wait_until_complete=False\n", ")" ] }, { "cell_type": "code", - "execution_count": 26, - "metadata": {}, + "execution_count": 22, + "metadata": { + "tags": [] + }, "outputs": [ { "name": "stdout", @@ -676,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -706,12 +647,14 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, + "execution_count": 25, + "metadata": { + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -725,12 +668,12 @@ "nl_function = np.arctan(np.tan(x_array)**2)\n", "sv1_theta_list = sv1_job.result()['theta_list']\n", "sv1_q_theta_list = sv1_job.result()['q_theta_list']\n", - "# ionq_theta_list = ionq_job.result()['theta_list']\n", - "# ionq_q_theta_list = ionq_job.result()['q_theta_list']\n", + "ionq_theta_list = ionq_job.result()['theta_list']\n", + "ionq_q_theta_list = ionq_job.result()['q_theta_list']\n", "\n", "plt.scatter(x_array, nl_function, label=r\"theory\")\n", "plt.scatter(sv1_theta_list, sv1_q_theta_list, label=r\"SV1\")\n", - "# plt.plot(ionq_theta_list, ionq_q_theta_list, label=r\"IonQ\")\n", + "plt.scatter(ionq_theta_list, ionq_q_theta_list, label=r\"IonQ\")\n", "plt.xlabel(r\"$\\theta$\")\n", "plt.ylabel(r\"$q(\\theta)$\")\n", "plt.legend(bbox_to_anchor=(0, 1), loc='upper left', borderaxespad=1)\n", @@ -761,7 +704,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.12" + "version": "3.9.16" }, "vscode": { "interpreter": { diff --git a/notebooks/textbook/Quantum_Neuron/img/classical_and_quantum_neuron.png b/notebooks/textbook/Quantum_Neuron/img/classical_and_quantum_neuron.png index 963ade3002165364e1ee3b9b0469545c92baad80..eb8dae7656d05ee6011b6e7c64b1b99fb1762aae 100644 GIT binary patch literal 53879 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 auE-__E-uHPs`K3ef273a#R{J3djBtd)8$D3 literal 54344 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

SHJGWu=$ z_+JrCKS`$T+Zf*SwIA5L0ew=w0GYxGI9ACz(QJH+zf`=#XfZ*K_Fn2+ z5H9$~f>8d4XhM|Z>oJ!iO@9s5ZN@GN&R&(}2+(RpPxYJH5BpL-Ke<9)<=*8c>3+%D z6+D9bOPcu=!DE_5)&U7KtsZtup}*f91s&NHP4WDx9sx$@#KwLmMNbd^y8a6qv!^+Aq7=)t7VjE67G)u^Q0W`G*;Yhq|$uNnxgp3Mq?>lP> ze}0&!_7Hw{OS!h7_-qBRE6MbwZ_A`g3%)KJsxRrZYLb z_RxMHz*r&Bu~apMz3dI|WxqX=q%Ztuk{+Hw20p@nJ&%3|CJWU6F+b*7j@-IZ4&1$` z1JlVGi6>lWvRNd|MF+p$>AAiAtMa72)~SC)06~z_KG1s%GYY7JD5YyVjitiFBJF96 z2-THDnPo+B4w+@6_RlPRU*3eXIa7F&DG1Mqrl0z#hnHO<+k;)Ap%OilY-S7v+c~fb z#EN=dTr)b5kZjydbvXvBDKtUs6k^ZDb1qHrU$X>Z;d6Y!>06r3njtP%WyV6IcM95H zAI#+X-^-M#I&f+@Eo*&4SR+q%btobI$SQu4YXAXEHJ=+T6Pzt`gAOutJ8gRdj4R7O zGRaDqF&?~tNvFEx88e4PLD~y2X!cGzLVHf*6(K zJKct&?>4)e=lzdL#%00AV%1}2{WqC{>mMv9Cg zlo~)Xjv9C=LBDbs#~ZQD0pyYBkgqPd^#+HGey zkHhoJ{rRw5w_`iM>H1+ajNN)^u^O5kH?zAE-S5f@oIO~e44iIOqXpakM@>0ibYr`` zw#D}M3(SF!8<>kGO3ExGn(b3!F*0Q)48kd=fO6d69F$mM5>-kmhBA*J20;`^8W00Z z31(}f2niDiX%4Z(SXH8gWQoCc$t52}v5XoZ5oDHB=0T2S3r;~XlXYYXngH9fs1dX! zR23%GKsg~q73C@r%Or|a=Cg3!n1TZ2jCMs0taX>1g>tTHVg{}yONgWqg3Y6BrB;O* zO$pm_BuVXQGGGiuLO7Xa$|ykqGPBIWs@V=EW{&0} zut;58BuBMf%|1}BWS2QI|=6N==LnxxSCbYUtbFimN%0VZEXog11$pkvJQF#i1tO_*GBu_42 zu~)0=j8J`6hGJ$2WbY(UET)d_aMcWl?e?it+kUrbzYUA2`4@}Dy1Uz~x|7?R!-+NY zZTb2*#p?XwVm}UcXPpR-`Gz|1>ixS9Z_hrToz}sJhjKEyVccw6J3!59Umqe_M?4*w z*Zbba$}zgRZa2HJ`##Pd{`E`3aU92S9LI4S$8j9TaU92S9LI4S$8j9T`EU6N(`Uc7 H04M+epyxN; literal 692 zcmV;l0!#fLiwFP!00000|Lv5)ZWA#OhWjY1oXgf@kH?-|X%PnyNN__aa+8&sHk)mC zy`_Nq?u^|Qp~4MHFY_f*HskU5_doWI-8Ap=)Sgen{@{r)U<@HP=8ng|Kp`}M2;hxz zUh=?NfP=<7m7rglr<}$E^Ve%V-rPTs_CNT(I33ePmp`n}x<0+`(xw|1%jWxHpZZQ7 z?uXm+;dEMUQcmqOYG`rTEUrs**q0fwxRpQ|INq+a1k?Dnmds~ePOF_v zmcO4&Yy4qjTH;^>dry`)%D2Q2y^Y?2BOhXLK!**qhOH+I#B4)ASMsbuM*w63I{@dY z1fvH+6CfC}937UJXC@>Uq_B}yVyS15q#`>LtcjjN$ukkl5@r+T`NR( zE<}_)I5C*2c*o)v69pT|MXm+JMad)Cka4Bh&jQj#AH?$jPCSJ=U;~l?=>&_Jo~!Ln zOk*oO^&oas0b(Lz5TD42Own6{OwvzhrI7?;LN(p9mm^`tD{m3+1o0W%@EL?@se_x!iQu+jVzzHK%=^`xn!;pLZz_<5B9{n9ljAyAPJDOMt><#ySDSfE`R+DIYXD^Mbi3QhmHA^1 z#@5`{3RB+pNv>A29%_5VT6(xluZB^^$_2aJrR_d= upper_total: + random_numbers = [random.uniform(0, upper_total) for _ in range(n)] + total = sum(random_numbers) + + return sorted(random_numbers) + + def init_pl_device(device_arn, n_qubits, shots, max_parallel): + """Load a Device for PennyLane and return the instance. + + Args: + device_arn (str): Name of the device to load. + n_qubits (int): Number of qubits. + shots (int): How many circuit executions are used to estimate stochastic return values. + max_parallel (int): Maximum number of simultaneous tasks allowed. + + Returns: + Device: Braket device to run on. + """ return qml.device( "braket.aws.qubit", device_arn=device_arn, @@ -27,31 +72,42 @@ def init_pl_device(device_arn, n_qubits, shots, max_parallel): # poll_timeout_seconds=30, ) -def linear_combination(inputs:str, weights, bias, ancilla): - # print(f'len(inputs): {len(inputs)}') +def linear_combination(inputs, weights, bias, ancilla, n_qubits): + """Build Linear Combination Circuit. + + Args: + inputs (str): Binary inputs, such as '1011'. + weights (List[float]): Weights of the neuron. + bias (float): Bias of the neuron. + + Returns: + None (To complete, the expected value must be returned after this function) + """ for qubit in range(len(inputs)): if(inputs[qubit]=='1'): qml.PauliX(qubit) for qubit in range(len(inputs)): - # print(f'qubit: {qubit}') qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) qml.RY(2*bias, wires=ancilla) -def activation_function(inputs:str, weights, bias, ancilla, output, n_qubits): - ''' - for qubit in range(len(inputs)): - if(inputs[qubit]=='1'): - qml.PauliX(qubit) - - for qubit in range(len(inputs)): - qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) - - qml.RY(2*bias, wires=ancilla) - ''' - linear_combination(inputs, weights, bias, ancilla) +def activation_function(inputs, weights, bias, ancilla, output, n_qubits): + """Build Activation Function Circuit. + + Args: + inputs (str): Binary inputs, such as '1011'. + weights (List[float]): Weights of the neuron. + bias (float): Bias of the neuron. + ancilla (int): ID of an ancilla qubit. + output (int): ID of an output qubit. + n_qubits (int): Number of qubits. + + Returns: + None (To complete, the expected value must be returned after this function) + """ + linear_combination(inputs, weights, bias, ancilla, n_qubits) qml.CY(wires=[ancilla, output]) qml.RZ(phi=-np.pi/2, wires=ancilla) @@ -60,25 +116,34 @@ def activation_function(inputs:str, weights, bias, ancilla, output, n_qubits): qml.CRY(phi=-2*weights[qubit], wires=[qubit, ancilla]) # note '-(minus)' qml.RY(-2*bias, wires=ancilla) # note '-(minus)' - - # return [qml.sample(qml.PauliZ(i)) for i in range(n_nodes)] -def quantum_neuron(inputs:str, weights, bias, n_qubits, dev): - ancilla = len(weights) # ID of an ancilla qubit - output = len(weights) + 1 # ID of an output qubit +def quantum_neuron(inputs, weights, bias, n_qubits, dev): + """Build Quantum Neuron Circuit. + + Args: + inputs (str): Binary inputs, such as '1011'. + weights (List[float]): Weights of the neuron. + bias (float): Bias of the neuron. + n_qubits (int): Number of qubits. + dev (Device): Braket device to run on. + + Returns: + theta (float): Input signal to the quantum neuron. + q_theta (float): Output of the quantum neuron. + """ + ancilla = len(inputs) # ID of an ancilla qubit + output = len(inputs) + 1 # ID of an output qubit theta = np.inner(np.array(list(inputs), dtype=int), np.array(weights)) + bias # linear comination with numpy theta = theta.item() # Convert numpy array to native python float-type - # ここでaf_circuitが何かをreturnするように修正する必要がある - # af_circuit = qml.QNode(af, dev) @qml.qnode(dev) def af_circuit(): activation_function(inputs, weights, bias, ancilla, output, n_qubits) return [qml.sample(qml.PauliZ(i)) for i in range(n_qubits)] - + ### start of post-processing ### sample = af_circuit() sample = sample.T sample = (1 - sample.numpy()) / 2 @@ -91,6 +156,7 @@ def af_circuit(): p_0 = count_0 / (count_0 + count_1) q_theta = np.arccos(np.sqrt(p_0)) + ### end of post-processing ### return theta, q_theta @@ -109,35 +175,32 @@ def main(): hyperparams = json.load(f) n_inputs = int(hyperparams["n_inputs"]) - weights = ast.literal_eval(hyperparams["weights"]) - bias = float(hyperparams["bias"]) shots = int(hyperparams["shots"]) interface = hyperparams["interface"] max_parallel = int(hyperparams["max_parallel"]) + n_qubits = n_inputs+2 # +2: ancilla and output qubit + + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi/2-bias) + if "copy_checkpoints_from_job" in hyperparams: copy_checkpoints_from_job = hyperparams["copy_checkpoints_from_job"].split("/", 2)[-1] else: copy_checkpoints_from_job = None - # Read input strings from input file - with open(f"{input_dir}/input/inputs.txt") as f: - inputs = [s.strip() for s in f.readlines()] - - # Prepare quantum neuron circuit - n_qubits = n_inputs+2 # +2: ancilla and output qubit - # Run quantum neuron circuit dev = init_pl_device(device_arn, n_qubits, shots, max_parallel) theta_list = [] q_theta_list = [] for i in range(2**n_inputs): - theta, q_theta = quantum_neuron(inputs[i], weights, bias, n_qubits, dev) + theta, q_theta = quantum_neuron(inputs_list[i], weights, bias, n_qubits, dev) theta_list.append(theta) q_theta_list.append(q_theta) - + save_job_result({"theta_list": theta_list, "q_theta_list": q_theta_list, "task summary": t.quantum_tasks_statistics(), "estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost()}) if __name__ == "__main__": diff --git a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py index 88deaaa9..9e0487da 100644 --- a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py +++ b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py @@ -1,4 +1,78 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). You +# may not use this file except in compliance with the License. A copy of +# the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file is +# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF +# ANY KIND, either express or implied. See the License for the specific +# language governing permissions and limitations under the License. + import pennylane as qml import numpy as np -from quantum_neuron import quantum_neuron +from braket.experimental.algorithms.quantum_neuron.quantum_neuron import ( + generate_random_numbers, + linear_combination, + quantum_neuron, + activation_function +) + +def test_linear_combination(): + for n_inputs in range(3, 6): + print() + n_qubits = n_inputs+2 # +2: ancilla and output qubit + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi/2-bias) + ancilla = len(weights) # ID of an ancilla qubit + + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + + dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) + + @qml.qnode(dev) + def lc_circuit(): + linear_combination(inputs_list[input_to_test], weights, bias, ancilla, n_qubits) + return qml.expval(qml.PauliZ(ancilla)) + + print(qml.draw(lc_circuit, decimals=2)()) + + z_expected_value = lc_circuit() + print(f'z_expected_value: {z_expected_value}\n') + + theta = np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + bias # linear comination with numpy + theta = theta.item() # Convert numpy array to native python float-type + # print(f'theta: {theta}') + # print(f'RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0))}') + # print(f'shape of RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0)).shape}') + + theoritical_z_expected_value = np.cos(theta)**2 - np.sin(theta)**2 # Z expected value of Ry(2*theta)|0> + print(f'theoritical_z_expected_value: {z_expected_value}') + + + np.testing.assert_almost_equal(z_expected_value, theoritical_z_expected_value, decimal=2) + +def test_quantum_neuron(): + for n_inputs in range(3, 6): + print() + n_qubits = n_inputs+2 # +2: ancilla and output qubit + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi/2-bias) + + inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + + dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) + + theta, q_theta = quantum_neuron(inputs_list[input_to_test], weights, bias, n_qubits, dev) + print(f'q_theta: {q_theta}') + + expected_q_theta = np.arctan(np.tan(theta)**2) + print(f'expected_q_theta: {expected_q_theta}') + + np.testing.assert_almost_equal(q_theta, expected_q_theta, decimal=2) + \ No newline at end of file From f875d5b71cb1bf53ae17c35fc0ecce30154cf919 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 6 May 2023 02:10:54 +0000 Subject: [PATCH 05/37] delete run_test.ipynb --- .../textbook/Quantum_Neuron/run_test.ipynb | 108 ------------------ .../Quantum_Neuron/test_quantum_neuron.py | 78 ------------- 2 files changed, 186 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/run_test.ipynb delete mode 100644 notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py diff --git a/notebooks/textbook/Quantum_Neuron/run_test.ipynb b/notebooks/textbook/Quantum_Neuron/run_test.ipynb deleted file mode 100644 index 0668a334..00000000 --- a/notebooks/textbook/Quantum_Neuron/run_test.ipynb +++ /dev/null @@ -1,108 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "be8e8f0d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m============================= test session starts ==============================\u001b[0m\n", - "platform linux -- Python 3.7.12, pytest-4.6.4, py-1.11.0, pluggy-0.13.1 -- /home/ec2-user/anaconda3/envs/Braket/bin/python\n", - "cachedir: .pytest_cache\n", - "rootdir: /home/ec2-user/SageMaker/amazon-braket-algorithm-library, inifile: setup.cfg\n", - "collected 2 items \u001b[0m\u001b[1m\n", - "\n", - "test_quantum_neuron.py::test_linear_combination \n", - "0: ──X─╭●──────────────────────────────────────┤ \n", - "1: ────│─────────╭●────────────────────────────┤ \n", - "2: ──X─│─────────│─────────╭●──────────────────┤ \n", - "3: ────╰RY(0.24)─╰RY(0.97)─╰RY(1.36)──RY(0.10)─┤ \n", - "z_expected_value: -0.13088\n", - "\n", - "theoritical_z_expected_value: -0.13088\n", - "\n", - "0: ────╭●────────────────────────────────────────────────┤ \n", - "1: ──X─│─────────╭●──────────────────────────────────────┤ \n", - "2: ────│─────────│─────────╭●────────────────────────────┤ \n", - "3: ──X─│─────────│─────────│─────────╭●──────────────────┤ \n", - "4: ────╰RY(0.07)─╰RY(0.31)─╰RY(0.79)─╰RY(1.29)──RY(0.10)─┤ \n", - "z_expected_value: -0.13116\n", - "\n", - "theoritical_z_expected_value: -0.13116\n", - "\n", - "0: ────╭●──────────────────────────────────────────────────────────┤ \n", - "1: ────│─────────╭●────────────────────────────────────────────────┤ \n", - "2: ──X─│─────────│─────────╭●──────────────────────────────────────┤ \n", - "3: ────│─────────│─────────│─────────╭●────────────────────────────┤ \n", - "4: ──X─│─────────│─────────│─────────│─────────╭●──────────────────┤ \n", - "5: ────╰RY(0.06)─╰RY(0.14)─╰RY(0.40)─╰RY(0.89)─╰RY(1.28)──RY(0.10)─┤ \n", - "z_expected_value: -0.20478\n", - "\n", - "theoritical_z_expected_value: -0.20478\n", - "\u001b[32mPASSED\u001b[0m\n", - "test_quantum_neuron.py::test_quantum_neuron \n", - "q_theta: 0.9181000628169432\n", - "expected_q_theta: 0.9205739886726427\n", - "\n", - "q_theta: 0.9185355467979665\n", - "expected_q_theta: 0.9167356239940488\n", - "\n", - "q_theta: 0.9914070072591556\n", - "expected_q_theta: 0.9892466704720225\n", - "\u001b[32mPASSED\u001b[0m\n", - "\n", - "\u001b[33m=============================== warnings summary ===============================\u001b[0m\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/graphml.py:346\n", - " /home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/graphml.py:346: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n", - " Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", - " (np.int, \"int\"), (np.int8, \"int\"),\n", - "\n", - "/home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/gexf.py:223\n", - " /home/ec2-user/anaconda3/envs/Braket/lib/python3.7/site-packages/networkx/readwrite/gexf.py:223: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n", - " Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", - " (np.int, \"int\"), (np.int8, \"int\"),\n", - "\n", - "-- Docs: https://docs.pytest.org/en/latest/warnings.html\n", - "\u001b[33m\u001b[1m===================== 2 passed, 2 warnings in 7.79 seconds =====================\u001b[0m\n" - ] - } - ], - "source": [ - "!pytest test_quantum_neuron.py -s" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "74305562", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "conda_braket", - "language": "python", - "name": "conda_braket" - }, - "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.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py b/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py deleted file mode 100644 index b5df0a31..00000000 --- a/notebooks/textbook/Quantum_Neuron/test_quantum_neuron.py +++ /dev/null @@ -1,78 +0,0 @@ -# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"). You -# may not use this file except in compliance with the License. A copy of -# the License is located at -# -# http://aws.amazon.com/apache2.0/ -# -# or in the "license" file accompanying this file. This file is -# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF -# ANY KIND, either express or implied. See the License for the specific -# language governing permissions and limitations under the License. - -import pennylane as qml -import numpy as np - -from qn.quantum_neuron import ( - generate_random_numbers, - linear_combination, - quantum_neuron, - activation_function -) - -def test_linear_combination(): - for n_inputs in range(3, 6): - print() - n_qubits = n_inputs+2 # +2: ancilla and output qubit - bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi/2-bias) - ancilla = len(weights) # ID of an ancilla qubit - - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] - input_to_test = 5 # I picked this at random. - - dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - - @qml.qnode(dev) - def lc_circuit(): - linear_combination(inputs_list[input_to_test], weights, bias, ancilla, n_qubits) - return qml.expval(qml.PauliZ(ancilla)) - - print(qml.draw(lc_circuit, decimals=2)()) - - z_expected_value = lc_circuit() - print(f'z_expected_value: {z_expected_value}\n') - - theta = np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + bias # linear comination with numpy - theta = theta.item() # Convert numpy array to native python float-type - # print(f'theta: {theta}') - # print(f'RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0))}') - # print(f'shape of RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0)).shape}') - - theoritical_z_expected_value = np.cos(theta)**2 - np.sin(theta)**2 # Z expected value of Ry(2*theta)|0> - print(f'theoritical_z_expected_value: {z_expected_value}') - - - np.testing.assert_almost_equal(z_expected_value, theoritical_z_expected_value, decimal=2) - -def test_quantum_neuron(): - for n_inputs in range(3, 6): - print() - n_qubits = n_inputs+2 # +2: ancilla and output qubit - bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi/2-bias) - - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] - input_to_test = 5 # I picked this at random. - - dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - - theta, q_theta = quantum_neuron(inputs_list[input_to_test], weights, bias, n_qubits, dev) - print(f'q_theta: {q_theta}') - - expected_q_theta = np.arctan(np.tan(theta)**2) - print(f'expected_q_theta: {expected_q_theta}') - - np.testing.assert_almost_equal(q_theta, expected_q_theta, decimal=2) - \ No newline at end of file From e09bf9551baaf4386c1edb596a6b0c91794d90dc Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 6 May 2023 02:14:25 +0000 Subject: [PATCH 06/37] delete model.tar.gz --- notebooks/textbook/Quantum_Neuron/model.tar.gz | Bin 673 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz deleted file mode 100644 index bed32732f7a3a3a1733858ec78de4ac18f33ac91..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 673 zcmV;S0$%+eiwFP!00000|Lv5)Zrd;nhWjW+&P7U6A|>X!cGzLVHf*6(K zJKct&?>4)e=lzdL#%00AV%1}2{WqC{>mMv9Cg zlo~)Xjv9C=LBDbs#~ZQD0pyYBkgqPd^#+HGey zkHhoJ{rRw5w_`iM>H1+ajNN)^u^O5kH?zAE-S5f@oIO~e44iIOqXpakM@>0ibYr`` zw#D}M3(SF!8<>kGO3ExGn(b3!F*0Q)48kd=fO6d69F$mM5>-kmhBA*J20;`^8W00Z z31(}f2niDiX%4Z(SXH8gWQoCc$t52}v5XoZ5oDHB=0T2S3r;~XlXYYXngH9fs1dX! zR23%GKsg~q73C@r%Or|a=Cg3!n1TZ2jCMs0taX>1g>tTHVg{}yONgWqg3Y6BrB;O* zO$pm_BuVXQGGGiuLO7Xa$|ykqGPBIWs@V=EW{&0} zut;58BuBMf%|1}BWS2QI|=6N==LnxxSCbYUtbFimN%0VZEXog11$pkvJQF#i1tO_*GBu_42 zu~)0=j8J`6hGJ$2WbY(UET)d_aMcWl?e?it+kUrbzYUA2`4@}Dy1Uz~x|7?R!-+NY zZTb2*#p?XwVm}UcXPpR-`Gz|1>ixS9Z_hrToz}sJhjKEyVccw6J3!59Umqe_M?4*w z*Zbba$}zgRZa2HJ`##Pd{`E`3aU92S9LI4S$8j9TaU92S9LI4S$8j9T`EU6N(`Uc7 H04M+epyxN; From edc0a3ebe62f035c615ca1056a805054b1f4a246 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 6 May 2023 02:17:47 +0000 Subject: [PATCH 07/37] delete notebooks/textbook/Quantum_Neuron/qn --- .../Quantum_Neuron/qn/quantum_neuron.py | 154 ------------------ 1 file changed, 154 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py diff --git a/notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py b/notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py deleted file mode 100644 index 89304c94..00000000 --- a/notebooks/textbook/Quantum_Neuron/qn/quantum_neuron.py +++ /dev/null @@ -1,154 +0,0 @@ -# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"). You -# may not use this file except in compliance with the License. A copy of -# the License is located at -# -# http://aws.amazon.com/apache2.0/ -# -# or in the "license" file accompanying this file. This file is -# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF -# ANY KIND, either express or implied. See the License for the specific -# language governing permissions and limitations under the License. - -import json -import os -import time -import sys -import ast - -import numpy as np -import matplotlib.pyplot as plt -import random -from typing import List -from braket.aws import AwsQuantumJob, AwsSession -from braket.jobs.image_uris import Framework, retrieve_image -from braket.jobs import load_job_checkpoint, save_job_checkpoint, save_job_result -from braket.tracking import Tracker - -import pennylane as qml - -# Given an integer n, returns n random numbers such that the sum is greater than or equal to 0 and less than upper_total -def generate_random_numbers(n, upper_total): - random.seed(0) - random_numbers = [random.uniform(0, upper_total) for _ in range(n)] - - total = sum(random_numbers) - - while total < 0 or total >= upper_total: - random_numbers = [random.uniform(0, upper_total) for _ in range(n)] - total = sum(random_numbers) - - return sorted(random_numbers) - - -def init_pl_device(device_arn, n_qubits, shots, max_parallel): - return qml.device( - "braket.aws.qubit", - device_arn=device_arn, - wires=n_qubits, - shots=shots, - # Set s3_destination_folder=None to output task results to a default folder - s3_destination_folder=None, - parallel=True, - max_parallel=max_parallel, - # poll_timeout_seconds=30, - ) - -def linear_combination(inputs:str, weights, bias, ancilla, n_qubits): - for qubit in range(len(inputs)): - if(inputs[qubit]=='1'): - qml.PauliX(qubit) - - for qubit in range(len(inputs)): - - qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) - - qml.RY(2*bias, wires=ancilla) - -def activation_function(inputs:str, weights, bias, ancilla, output, n_qubits): - linear_combination(inputs, weights, bias, ancilla, n_qubits) - - qml.CY(wires=[ancilla, output]) - qml.RZ(phi=-np.pi/2, wires=ancilla) - - for qubit in range(len(inputs)): - qml.CRY(phi=-2*weights[qubit], wires=[qubit, ancilla]) # note '-(minus)' - - qml.RY(-2*bias, wires=ancilla) # note '-(minus)' - -def quantum_neuron(inputs:str, weights, bias, n_qubits, dev): - ancilla = len(inputs) # ID of an ancilla qubit - output = len(inputs) + 1 # ID of an output qubit - - theta = np.inner(np.array(list(inputs), dtype=int), np.array(weights)) + bias # linear comination with numpy - theta = theta.item() # Convert numpy array to native python float-type - - @qml.qnode(dev) - def af_circuit(): - activation_function(inputs, weights, bias, ancilla, output, n_qubits) - - return [qml.sample(qml.PauliZ(i)) for i in range(n_qubits)] - - ### start of post-processing ### - sample = af_circuit() - sample = sample.T - sample = (1 - sample.numpy()) / 2 - - adopted_sample = sample[sample[:,ancilla] == 0] - - count_0 = len(adopted_sample[adopted_sample[:,output] == 0]) - count_1 = len(adopted_sample[adopted_sample[:,output] == 1]) - - p_0 = count_0 / (count_0 + count_1) - - q_theta = np.arccos(np.sqrt(p_0)) - ### end of post-processing ### - - return theta, q_theta - -def main(): - t = Tracker().start() - - input_dir = os.environ["AMZN_BRAKET_INPUT_DIR"] - output_dir = os.environ["AMZN_BRAKET_JOB_RESULTS_DIR"] - job_name = os.environ["AMZN_BRAKET_JOB_NAME"] # noqa - checkpoint_dir = os.environ["AMZN_BRAKET_CHECKPOINT_DIR"] # noqa - hp_file = os.environ["AMZN_BRAKET_HP_FILE"] - device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"] - - # Read the hyperparameters - with open(hp_file, "r") as f: - hyperparams = json.load(f) - - n_inputs = int(hyperparams["n_inputs"]) - shots = int(hyperparams["shots"]) - interface = hyperparams["interface"] - max_parallel = int(hyperparams["max_parallel"]) - - n_qubits = n_inputs+2 # +2: ancilla and output qubit - - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] - bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi/2-bias) - - if "copy_checkpoints_from_job" in hyperparams: - copy_checkpoints_from_job = hyperparams["copy_checkpoints_from_job"].split("/", 2)[-1] - else: - copy_checkpoints_from_job = None - - # Run quantum neuron circuit - dev = init_pl_device(device_arn, n_qubits, shots, max_parallel) - theta_list = [] - q_theta_list = [] - - for i in range(2**n_inputs): - theta, q_theta = quantum_neuron(inputs_list[i], weights, bias, n_qubits, dev) - - theta_list.append(theta) - q_theta_list.append(q_theta) - - save_job_result({"theta_list": theta_list, "q_theta_list": q_theta_list, "task summary": t.quantum_tasks_statistics(), "estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost()}) - -if __name__ == "__main__": - main() \ No newline at end of file From a9360efafda6fc7409e0f51a5ee32f435eb21b95 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Wed, 12 Jul 2023 23:25:12 +0000 Subject: [PATCH 08/37] fix Quantum_Neuron.ipynb and quantum_neuron.py as reviewed --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 55 +- .../textbook/Quantum_Neuron/model.tar.gz | Bin 0 -> 684 bytes .../__init__.py | 2 +- .../algorithms/quantum_neuron/__init__.py | 4 +- .../quantum_neuron/quantum_neuron.py | 143 ++- .../quantum_neuron/test_quantum_neuron.py | 67 +- tox_result.txt | 1044 +++++++++++++++++ 7 files changed, 1199 insertions(+), 116 deletions(-) create mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz create mode 100644 tox_result.txt diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index ab844148..611cc2fd 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -6,7 +6,7 @@ "source": [ "# Quantum Neuron\n", "\n", - "In this work, we build [quantum neuron](https://arxiv.org/abs/1711.11240) with [PennyLane](https://pennylane.ai/), and run it on different devices such as SV1, IonQ, and Aspen-M-2.\n", + "In this work, we build [quantum neuron](https://arxiv.org/abs/1711.11240) with [PennyLane](https://pennylane.ai/), and run it on different devices such as SV1, IonQ, and Aspen-M-3.\n", "We aim to reproduce Fig.1(d) of the paper." ] }, @@ -34,11 +34,9 @@ }, "outputs": [], "source": [ - "import time, os, sys, ast\n", - "from IPython.display import Image\n", + "import time\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from typing import List\n", "from braket.aws import AwsQuantumJob\n", "from braket.jobs.image_uris import Framework, retrieve_image\n", "\n", @@ -50,7 +48,7 @@ "metadata": {}, "source": [ "## Introduction\n", - "Machine learning is used in many areas of everyday life. The technology has developed so far largely due to advances in neural networks. It can be seen that a neural network is composed of many neurons connected together. In other words, a neuron is the basic unit of a neural network. Since many studies had been done on neurons and show successful results, several approaches to combine it with quantum computing are also proposed. Such approaches are called quantum neuron. The advantage of the method is that you can process classical neural network tasks maintaining the ability to have superpositions of inputs and proserve quantum coherence and entanglement.\n", + "Machine learning is used in many areas of everyday life. The technology has developed so far largely due to advances in neural networks. It can be seen that a neural network is composed of many neurons connected together. In other words, a neuron is the basic unit of a neural network. Since many studies have been done on neurons and shown successful results, several approaches to combine it with quantum computing are also proposed. Such approaches are called quantum neuron. The advantage of the method is that you can process classical neural network tasks while maintaining the ability to have superpositions of inputs and preserve quantum coherence and entanglement.\n", "\n", "The below shows classical and quantum neuron, based on Figure 1 of the paper. At the end of this work, you can get to learn how to build a non-linear transformation from linear nature of quantum mechanics.\n", "

" @@ -86,8 +84,7 @@ "metadata": {}, "source": [ "## Build Activation Function Circuit\n", - "\n", - "Secondly, after building a linear combination circuit, we build an activation function circuit. However it seems a unique idea that came out of nowhere, we show how to build an activation function circuit below.\n", + "Then, like in a classical neuron, the linear combination is followed by an activation function. we show how to build an activation function circuit below.\n", "\n", "
\n", "\n", @@ -330,13 +327,23 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -381,14 +388,21 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]]\n" ] } ], "source": [ - "sample = af_circuit()\n", + "# sample = af_circuit()\n", + "sample = np.array(af_circuit())\n", + "\n", "sample = sample.T\n", - "sample = (1 - sample.numpy()) / 2\n", + "\n", + "#sample = (1 - sample.numpy()) / 2\n", + "sample = (1 - sample) / 2\n", "\n", "print('In the sample obtained, we adopt the cases where its ancilla qubit is 0.')\n", "adopted_sample = sample[sample[:,ancilla] == 0]\n", @@ -420,7 +434,7 @@ "output_type": "stream", "text": [ "theta: 1.1272124273195654\n", - "q_theta: 1.5707963267948966\n" + "q_theta: 1.342359325028566\n" ] } ], @@ -538,7 +552,7 @@ "output_type": "stream", "text": [ "SV1 Task Summary\n", - "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.444, 'billed_execution_duration': 48.0}}\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.929, 'billed_execution_duration': 48.0}}\n", "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with SV1: 0.06 USD\n" ] @@ -570,7 +584,7 @@ "\n", "region = 'us-east-1'\n", "image_uri = retrieve_image(Framework.BASE, region)\n", - "ionq = \"arn:aws:braket:::device/qpu/ionq/ionQdevice\"" + "ionq = \"arn:aws:braket:us-east-1::device/qpu/ionq/Harmony\"" ] }, { @@ -598,7 +612,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 19, "metadata": { "tags": [] }, @@ -607,7 +621,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "COMPLETED\n" + "QUEUED\n" ] } ], @@ -625,7 +639,7 @@ "output_type": "stream", "text": [ "IonQ Task Summary\n", - "{'arn:aws:braket:::device/qpu/ionq/ionQdevice': {'shots': 1600, 'tasks': {'COMPLETED': 16}}}\n", + "{'arn:aws:braket:us-east-1::device/qpu/ionq/Harmony': {'shots': 1600, 'tasks': {'COMPLETED': 16}}}\n", "Note: Charges shown are estimates based on your Amazon Braket quantum processing unit (QPU). Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with IonQ: 20.8 USD\n" ] @@ -647,14 +661,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -664,7 +678,10 @@ } ], "source": [ - "x_array = np.linspace(0, np.pi/2, 20)\n", + "# The theta_list of SV1 and the theta_list of IonQ have the same value.\n", + "# Since we want to calculate the theoretical values using the same theta_list for each device, we calculated the theoretical values using the theta_list for SV1 this time.\n", + "x_array = sv1_job.result()['theta_list']\n", + "\n", "nl_function = np.arctan(np.tan(x_array)**2)\n", "sv1_theta_list = sv1_job.result()['theta_list']\n", "sv1_q_theta_list = sv1_job.result()['q_theta_list']\n", @@ -704,7 +721,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.16" + "version": "3.10.11" }, "vscode": { "interpreter": { diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0185c0f4298742a68709c5427f4cc3232c81cd22 GIT binary patch literal 684 zcmV;d0#p4TiwFP!00000|Lv4fPuoBY$N4BxpP`(6w(s26!NkL+P1@e32?ZL70&O8l z*(TKQKHmkTiPw#75B{Y}6W`hXpX0l}8+NzjFuxwQn}b&(KnOzAgo&5`AWRJqab!t| z(gZ+6K4`*g3Hp`YFt+_c`0ZRT7xxFG{S6*x7kzuvjh`;Bx^;Wjwac!bEt<#Krd@aT z@H9NX-d+sn%XVz%cU?cMhOt|oo2{B=ht2GvSht(v0kgds%D~C$ax`Px|EM9yt8Q%1 zZ_U|Wzl3?k!*~RX#j<-? zU3SO!ce`V2?fc`iwqI{Ilh<&y9S3`|h73;jkSL@dH zQFFPi-x94co_EgMZEs^`H{IQ~tIgPbA7}f2eO5S*<2a7vIF92uj^j9v<2a7vIF92u Sj^jB0A3p*3H= upper_total: + + while not 0 <= total < upper_total: random_numbers = [random.uniform(0, upper_total) for _ in range(n)] total = sum(random_numbers) - + return sorted(random_numbers) def init_pl_device(device_arn, n_qubits, shots, max_parallel): """Load a Device for PennyLane and return the instance. - + Args: device_arn (str): Name of the device to load. n_qubits (int): Number of qubits. shots (int): How many circuit executions are used to estimate stochastic return values. max_parallel (int): Maximum number of simultaneous tasks allowed. - + Returns: Device: Braket device to run on. """ @@ -72,30 +72,31 @@ def init_pl_device(device_arn, n_qubits, shots, max_parallel): # poll_timeout_seconds=30, ) + def linear_combination(inputs, weights, bias, ancilla, n_qubits): """Build Linear Combination Circuit. - - Args: + + Args: inputs (str): Binary inputs, such as '1011'. weights (List[float]): Weights of the neuron. bias (float): Bias of the neuron. - + Returns: None (To complete, the expected value must be returned after this function) """ for qubit in range(len(inputs)): - if(inputs[qubit]=='1'): + if inputs[qubit] == "1": qml.PauliX(qubit) - + for qubit in range(len(inputs)): - - qml.CRY(phi=2*weights[qubit], wires=[qubit, ancilla]) - - qml.RY(2*bias, wires=ancilla) + qml.CRY(phi=2 * weights[qubit], wires=[qubit, ancilla]) + + qml.RY(2 * bias, wires=ancilla) + def activation_function(inputs, weights, bias, ancilla, output, n_qubits): """Build Activation Function Circuit. - + Args: inputs (str): Binary inputs, such as '1011'. weights (List[float]): Weights of the neuron. @@ -103,105 +104,121 @@ def activation_function(inputs, weights, bias, ancilla, output, n_qubits): ancilla (int): ID of an ancilla qubit. output (int): ID of an output qubit. n_qubits (int): Number of qubits. - + Returns: None (To complete, the expected value must be returned after this function) """ linear_combination(inputs, weights, bias, ancilla, n_qubits) - + qml.CY(wires=[ancilla, output]) - qml.RZ(phi=-np.pi/2, wires=ancilla) - + qml.RZ(phi=-np.pi / 2, wires=ancilla) + for qubit in range(len(inputs)): - qml.CRY(phi=-2*weights[qubit], wires=[qubit, ancilla]) # note '-(minus)' - - qml.RY(-2*bias, wires=ancilla) # note '-(minus)' + qml.CRY(phi=-2 * weights[qubit], wires=[qubit, ancilla]) # note '-(minus)' + + qml.RY(-2 * bias, wires=ancilla) # note '-(minus)' + def quantum_neuron(inputs, weights, bias, n_qubits, dev): """Build Quantum Neuron Circuit. - + Args: inputs (str): Binary inputs, such as '1011'. weights (List[float]): Weights of the neuron. bias (float): Bias of the neuron. n_qubits (int): Number of qubits. dev (Device): Braket device to run on. - + Returns: theta (float): Input signal to the quantum neuron. q_theta (float): Output of the quantum neuron. """ - ancilla = len(inputs) # ID of an ancilla qubit - output = len(inputs) + 1 # ID of an output qubit - - theta = np.inner(np.array(list(inputs), dtype=int), np.array(weights)) + bias # linear comination with numpy - theta = theta.item() # Convert numpy array to native python float-type - + ancilla = len(inputs) # ID of an ancilla qubit + output = len(inputs) + 1 # ID of an output qubit + + theta = ( + np.inner(np.array(list(inputs), dtype=int), np.array(weights)) + bias + ) # linear comination with numpy + theta = theta.item() # Convert numpy array to native python float-type + @qml.qnode(dev) def af_circuit(): activation_function(inputs, weights, bias, ancilla, output, n_qubits) - + return [qml.sample(qml.PauliZ(i)) for i in range(n_qubits)] - + ### start of post-processing ### - sample = af_circuit() + # sample = af_circuit() + sample = np.array(af_circuit()) + sample = sample.T - sample = (1 - sample.numpy()) / 2 + + # sample = (1 - sample.numpy()) / 2 + sample = (1 - sample) / 2 - adopted_sample = sample[sample[:,ancilla] == 0] + adopted_sample = sample[sample[:, ancilla] == 0] - count_0 = len(adopted_sample[adopted_sample[:,output] == 0]) - count_1 = len(adopted_sample[adopted_sample[:,output] == 1]) + count_0 = len(adopted_sample[adopted_sample[:, output] == 0]) + count_1 = len(adopted_sample[adopted_sample[:, output] == 1]) p_0 = count_0 / (count_0 + count_1) - + q_theta = np.arccos(np.sqrt(p_0)) ### end of post-processing ### - + return theta, q_theta + def main(): t = Tracker().start() - + input_dir = os.environ["AMZN_BRAKET_INPUT_DIR"] output_dir = os.environ["AMZN_BRAKET_JOB_RESULTS_DIR"] job_name = os.environ["AMZN_BRAKET_JOB_NAME"] # noqa checkpoint_dir = os.environ["AMZN_BRAKET_CHECKPOINT_DIR"] # noqa hp_file = os.environ["AMZN_BRAKET_HP_FILE"] device_arn = os.environ["AMZN_BRAKET_DEVICE_ARN"] - + # Read the hyperparameters with open(hp_file, "r") as f: hyperparams = json.load(f) - + n_inputs = int(hyperparams["n_inputs"]) shots = int(hyperparams["shots"]) interface = hyperparams["interface"] max_parallel = int(hyperparams["max_parallel"]) - - n_qubits = n_inputs+2 # +2: ancilla and output qubit - - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] + + n_qubits = n_inputs + 2 # +2: ancilla and output qubit + + inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi/2-bias) - + weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) + if "copy_checkpoints_from_job" in hyperparams: copy_checkpoints_from_job = hyperparams["copy_checkpoints_from_job"].split("/", 2)[-1] else: copy_checkpoints_from_job = None - + # Run quantum neuron circuit dev = init_pl_device(device_arn, n_qubits, shots, max_parallel) theta_list = [] q_theta_list = [] - + for i in range(2**n_inputs): theta, q_theta = quantum_neuron(inputs_list[i], weights, bias, n_qubits, dev) - + theta_list.append(theta) q_theta_list.append(q_theta) - - save_job_result({"theta_list": theta_list, "q_theta_list": q_theta_list, "task summary": t.quantum_tasks_statistics(), "estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost()}) + + save_job_result( + { + "theta_list": theta_list, + "q_theta_list": q_theta_list, + "task summary": t.quantum_tasks_statistics(), + "estimated cost": t.qpu_tasks_cost() + t.simulator_tasks_cost(), + } + ) + if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py index 9e0487da..d8c08756 100644 --- a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py +++ b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py @@ -11,68 +11,73 @@ # ANY KIND, either express or implied. See the License for the specific # language governing permissions and limitations under the License. -import pennylane as qml import numpy as np +import pennylane as qml from braket.experimental.algorithms.quantum_neuron.quantum_neuron import ( + activation_function, generate_random_numbers, linear_combination, quantum_neuron, - activation_function ) + def test_linear_combination(): for n_inputs in range(3, 6): print() - n_qubits = n_inputs+2 # +2: ancilla and output qubit + n_qubits = n_inputs + 2 # +2: ancilla and output qubit bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi/2-bias) - ancilla = len(weights) # ID of an ancilla qubit - - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] - input_to_test = 5 # I picked this at random. - + weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) + ancilla = len(weights) # ID of an ancilla qubit + + inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) @qml.qnode(dev) def lc_circuit(): linear_combination(inputs_list[input_to_test], weights, bias, ancilla, n_qubits) return qml.expval(qml.PauliZ(ancilla)) - + print(qml.draw(lc_circuit, decimals=2)()) - + z_expected_value = lc_circuit() - print(f'z_expected_value: {z_expected_value}\n') + print(f"z_expected_value: {z_expected_value}\n") - theta = np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + bias # linear comination with numpy - theta = theta.item() # Convert numpy array to native python float-type + theta = ( + np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + + bias + ) # linear comination with numpy + theta = theta.item() # Convert numpy array to native python float-type # print(f'theta: {theta}') # print(f'RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0))}') # print(f'shape of RY(theta): {qml.matrix(qml.RY(phi=theta, wires=0)).shape}') - - theoritical_z_expected_value = np.cos(theta)**2 - np.sin(theta)**2 # Z expected value of Ry(2*theta)|0> - print(f'theoritical_z_expected_value: {z_expected_value}') - + + theoritical_z_expected_value = ( + np.cos(theta) ** 2 - np.sin(theta) ** 2 + ) # Z expected value of Ry(2*theta)|0> + print(f"theoritical_z_expected_value: {z_expected_value}") np.testing.assert_almost_equal(z_expected_value, theoritical_z_expected_value, decimal=2) - + + def test_quantum_neuron(): for n_inputs in range(3, 6): print() - n_qubits = n_inputs+2 # +2: ancilla and output qubit + n_qubits = n_inputs + 2 # +2: ancilla and output qubit bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi/2-bias) + weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) + + inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. - inputs_list = [format(i, f'0{n_inputs}b') for i in range(2**n_inputs)] - input_to_test = 5 # I picked this at random. - dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - + theta, q_theta = quantum_neuron(inputs_list[input_to_test], weights, bias, n_qubits, dev) - print(f'q_theta: {q_theta}') - - expected_q_theta = np.arctan(np.tan(theta)**2) - print(f'expected_q_theta: {expected_q_theta}') - + print(f"q_theta: {q_theta}") + + expected_q_theta = np.arctan(np.tan(theta) ** 2) + print(f"expected_q_theta: {expected_q_theta}") + np.testing.assert_almost_equal(q_theta, expected_q_theta, decimal=2) - \ No newline at end of file diff --git a/tox_result.txt b/tox_result.txt new file mode 100644 index 00000000..cc0a8da9 --- /dev/null +++ b/tox_result.txt @@ -0,0 +1,1044 @@ +linters: commands[0]> isort -rc . +Fixing /home/ec2-user/SageMaker/amazon-braket-algorithm-library/test/unit_tests/braket/experimental/algorithms/shors/test_shors.py +Fixing /home/ec2-user/SageMaker/amazon-braket-algorithm-library/test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py +Skipped 3 files +linters: commands[1]> black ./ +linters: commands[2]> flake8 +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:17:1: F401 'time' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:18:1: F401 'typing.List' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:20:1: F401 'matplotlib.pyplot as plt' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:23:1: F401 'braket.aws.AwsQuantumJob' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:23:1: F401 'braket.aws.AwsSession' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:24:1: F401 'braket.jobs.load_job_checkpoint' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:24:1: F401 'braket.jobs.save_job_checkpoint' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:25:1: F401 'braket.jobs.image_uris.Framework' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:25:1: F401 'braket.jobs.image_uris.retrieve_image' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:30:101: E501 line too long (105 > 100 characters) +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:150:5: E266 too many leading '#' for block comment +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:163:5: E266 too many leading '#' for block comment +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:171:5: F841 local variable 'input_dir' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:172:5: F841 local variable 'output_dir' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:184:5: F841 local variable 'interface' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:196:9: F841 local variable 'copy_checkpoints_from_job' is assigned to but never used +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:17:1: F401 'braket.experimental.algorithms.quantum_neuron.quantum_neuron.activation_function' imported but unused +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:28:28: E226 missing whitespace around arithmetic operator +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:28:30: E261 at least two spaces before inline comment +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:30:58: E226 missing whitespace around arithmetic operator +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:30:60: E226 missing whitespace around arithmetic operator +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:31:31: E261 at least two spaces before inline comment +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:32:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:35:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:42:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:44:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:48:101: E501 line too long (138 > 100 characters) +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:53:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:54:101: E501 line too long (112 > 100 characters) +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:56:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:58:9: E303 too many blank lines (2) +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:59:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:60:1: E302 expected 2 blank lines, found 1 +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:63:28: E226 missing whitespace around arithmetic operator +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:63:30: E261 at least two spaces before inline comment +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:65:58: E226 missing whitespace around arithmetic operator +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:65:60: E226 missing whitespace around arithmetic operator +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:69:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:71:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:74:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:77:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:79:1: W293 blank line contains whitespace +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:79:9: W292 no newline at end of file +./test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:17:1: F401 'braket.experimental.algorithms.quantum_neuron.quantum_neuron.activation_function' imported but unused +linters: exit 1 (1.38 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> flake8 pid=21482 +linters: FAIL ✖ in 2.38 seconds +.pkg: _optional_hooks> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ +.pkg: get_requires_for_build_sdist> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ +.pkg: prepare_metadata_for_build_wheel> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ +.pkg: build_sdist> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ +docs: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/4/amazon-braket-algorithm-library-1.3.6.dev0.tar.gz +docs: commands[0]> sphinx-build -E -T -b html doc build/documentation/html +Running Sphinx v6.2.1 +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bells_inequality.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bells_inequality.bells_inequality.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bernstein_vazirani.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.chsh_inequality.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.chsh_inequality.chsh_inequality.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.deutsch_jozsa.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.grovers_search.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.grovers_search.grovers_search.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.qc_qmc.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.qc_qmc.classical_qmc.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.qc_qmc.qc_qmc.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_approximate_optimization.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.qcbm.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_fourier_transform.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_neuron.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_neuron.quantum_neuron.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_phase_estimation.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_walk.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_walk.quantum_walk.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.shors.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.shors.shors.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.simons.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.simons.simons.rst. +Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/modules.rst. +building [mo]: targets for 0 po files that are out of date +writing output... +building [html]: targets for 34 source files that are out of date +updating environment: [new config] 34 added, 0 changed, 0 removed +reading sources... [ 2%] _apidoc/braket +reading sources... [ 5%] _apidoc/braket.experimental +reading sources... [ 8%] _apidoc/braket.experimental.algorithms +reading sources... [ 11%] _apidoc/braket.experimental.algorithms.bells_inequality +reading sources... [ 14%] _apidoc/braket.experimental.algorithms.bells_inequality.bells_inequality +reading sources... [ 17%] _apidoc/braket.experimental.algorithms.bernstein_vazirani +reading sources... [ 20%] _apidoc/braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani +reading sources... [ 23%] _apidoc/braket.experimental.algorithms.chsh_inequality +reading sources... [ 26%] _apidoc/braket.experimental.algorithms.chsh_inequality.chsh_inequality +reading sources... [ 29%] _apidoc/braket.experimental.algorithms.deutsch_jozsa +reading sources... [ 32%] _apidoc/braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa +reading sources... [ 35%] _apidoc/braket.experimental.algorithms.grovers_search +reading sources... [ 38%] _apidoc/braket.experimental.algorithms.grovers_search.grovers_search +reading sources... [ 41%] _apidoc/braket.experimental.algorithms.qc_qmc +reading sources... [ 44%] _apidoc/braket.experimental.algorithms.qc_qmc.classical_qmc +reading sources... [ 47%] _apidoc/braket.experimental.algorithms.qc_qmc.qc_qmc +reading sources... [ 50%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization +reading sources... [ 52%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization +reading sources... [ 55%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine +reading sources... [ 58%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.qcbm +reading sources... [ 61%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform +reading sources... [ 64%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform +reading sources... [ 67%] _apidoc/braket.experimental.algorithms.quantum_neuron +reading sources... [ 70%] _apidoc/braket.experimental.algorithms.quantum_neuron.quantum_neuron +reading sources... [ 73%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation +reading sources... [ 76%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation +reading sources... [ 79%] _apidoc/braket.experimental.algorithms.quantum_walk +reading sources... [ 82%] _apidoc/braket.experimental.algorithms.quantum_walk.quantum_walk +reading sources... [ 85%] _apidoc/braket.experimental.algorithms.shors +reading sources... [ 88%] _apidoc/braket.experimental.algorithms.shors.shors +reading sources... [ 91%] _apidoc/braket.experimental.algorithms.simons +reading sources... [ 94%] _apidoc/braket.experimental.algorithms.simons.simons +reading sources... [ 97%] _apidoc/modules +reading sources... [100%] index + +looking for now-outdated files... none found +pickling environment... done +checking consistency... done +preparing documents... done +writing output... [ 2%] _apidoc/braket +writing output... [ 5%] _apidoc/braket.experimental +writing output... [ 8%] _apidoc/braket.experimental.algorithms +writing output... [ 11%] _apidoc/braket.experimental.algorithms.bells_inequality +writing output... [ 14%] _apidoc/braket.experimental.algorithms.bells_inequality.bells_inequality +writing output... [ 17%] _apidoc/braket.experimental.algorithms.bernstein_vazirani +writing output... [ 20%] _apidoc/braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani +writing output... [ 23%] _apidoc/braket.experimental.algorithms.chsh_inequality +writing output... [ 26%] _apidoc/braket.experimental.algorithms.chsh_inequality.chsh_inequality +writing output... [ 29%] _apidoc/braket.experimental.algorithms.deutsch_jozsa +writing output... [ 32%] _apidoc/braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa +writing output... [ 35%] _apidoc/braket.experimental.algorithms.grovers_search +writing output... [ 38%] _apidoc/braket.experimental.algorithms.grovers_search.grovers_search +writing output... [ 41%] _apidoc/braket.experimental.algorithms.qc_qmc +writing output... [ 44%] _apidoc/braket.experimental.algorithms.qc_qmc.classical_qmc +writing output... [ 47%] _apidoc/braket.experimental.algorithms.qc_qmc.qc_qmc +writing output... [ 50%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization +writing output... [ 52%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization +writing output... [ 55%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine +writing output... [ 58%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.qcbm +writing output... [ 61%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform +writing output... [ 64%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform +writing output... [ 67%] _apidoc/braket.experimental.algorithms.quantum_neuron +writing output... [ 70%] _apidoc/braket.experimental.algorithms.quantum_neuron.quantum_neuron +writing output... [ 73%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation +writing output... [ 76%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation +writing output... [ 79%] _apidoc/braket.experimental.algorithms.quantum_walk +writing output... [ 82%] _apidoc/braket.experimental.algorithms.quantum_walk.quantum_walk +writing output... [ 85%] _apidoc/braket.experimental.algorithms.shors +writing output... [ 88%] _apidoc/braket.experimental.algorithms.shors.shors +writing output... [ 91%] _apidoc/braket.experimental.algorithms.simons +writing output... [ 94%] _apidoc/braket.experimental.algorithms.simons.simons +writing output... [ 97%] _apidoc/modules +writing output... [100%] index + +generating indices... genindex py-modindex done +highlighting module code... [ 6%] braket.experimental.algorithms.bells_inequality.bells_inequality +highlighting module code... [ 13%] braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani +highlighting module code... [ 20%] braket.experimental.algorithms.chsh_inequality.chsh_inequality +highlighting module code... [ 26%] braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa +highlighting module code... [ 33%] braket.experimental.algorithms.grovers_search.grovers_search +highlighting module code... [ 40%] braket.experimental.algorithms.qc_qmc.classical_qmc +highlighting module code... [ 46%] braket.experimental.algorithms.qc_qmc.qc_qmc +highlighting module code... [ 53%] braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization +highlighting module code... [ 60%] braket.experimental.algorithms.quantum_circuit_born_machine.qcbm +highlighting module code... [ 66%] braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform +highlighting module code... [ 73%] braket.experimental.algorithms.quantum_neuron.quantum_neuron +highlighting module code... [ 80%] braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation +highlighting module code... [ 86%] braket.experimental.algorithms.quantum_walk.quantum_walk +highlighting module code... [ 93%] braket.experimental.algorithms.shors.shors +highlighting module code... [100%] braket.experimental.algorithms.simons.simons + +writing additional pages... search done +copying static files... done +copying extra files... done +dumping search index in English (code: en)... done +dumping object inventory... done +build succeeded, 11 warnings. + +The HTML pages are in build/documentation/html. +docs: OK ✔ in 15.16 seconds +unit-tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/5/amazon-braket-algorithm-library-1.3.6.dev0.tar.gz +unit-tests: commands[0]> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket +================================================== test session starts =================================================== +platform linux -- Python 3.10.8, pytest-7.3.1, pluggy-1.0.0 -- /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/bin/python +cachedir: .tox/unit-tests/.pytest_cache +rootdir: /home/ec2-user/SageMaker/amazon-braket-algorithm-library +configfile: setup.cfg +testpaths: test/unit_tests +plugins: rerunfailures-11.1.2, cov-4.1.0, xdist-3.3.1 +collecting ... collected 78 items + +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet PASSED [ 1%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet_rotated_zero PASSED [ 2%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet_rotated PASSED [ 3%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_not_verbose PASSED [ 5%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_shots_0 PASSED [ 6%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_not_violated PASSED [ 7%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality PASSED [ 8%] +test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani PASSED [ 10%] +test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani_results[100-0] PASSED [ 11%] +test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani_results[11-10] PASSED [ 12%] +test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani_results[10111-50] PASSED [ 14%] +test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_chsh_reduces_to_bell PASSED [ 15%] +test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_chsh_reduces_to_bell_not_verbose PASSED [ 16%] +test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_chsh_no_violation PASSED [ 17%] +test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_max_chsh_violation PASSED [ 19%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_constant_oracle_circuit PASSED [ 20%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_fail_constant_oracle_circuit XFAIL [ 21%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_balanced_oracle_circuit PASSED [ 23%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_fail_balanced_oracle_circuit XFAIL [ 24%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_dj_circuit PASSED [ 25%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_get_deutsch_jozsa_results_constant PASSED [ 26%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_get_deutsch_jozsa_results_balanced PASSED [ 28%] +test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[00] PASSED [ 29%] +test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[000] PASSED [ 30%] +test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[0000] PASSED [ 32%] +test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[00000] PASSED [ 33%] +test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution_decompose_ccnot[True] PASSED [ 34%] +test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution_decompose_ccnot[False] PASSED [ 35%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_properties PASSED [ 37%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_qc_qmc PASSED [ 38%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_q_full_imag_time_evolution PASSED [ 39%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_classical_qmc PASSED [ 41%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_full_imag_time_evolution PASSED [ 42%] +test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa PASSED [ 43%] +test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa_evaluate_circuit PASSED [ 44%] +test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa_cost_function PASSED [ 46%] +test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_mmd_loss PASSED [ 47%] +test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm PASSED [ 48%] +test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm_no_qubits XFAIL [ 50%] +test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm_gradient PASSED [ 51%] +test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py::test_qft PASSED [ 52%] +test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py::test_inverse_qft PASSED [ 53%] +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination FAILED [ 55%] +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron FAILED [ 56%] +test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_2_precision_qubits PASSED [ 57%] +test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_0_shots PASSED [ 58%] +test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_3_precision_qubits PASSED [ 60%] +test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_HX_eigenstate PASSED [ 61%] +test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_X_eigenstate PASSED [ 62%] +test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_inverse_qft PASSED [ 64%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_quantum_walk_4_nodes_4_steps PASSED [ 65%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-0-+] PASSED [ 66%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-1-+] PASSED [ 67%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-2-+] PASSED [ 69%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-3-+] PASSED [ 70%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-4-+] PASSED [ 71%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-5-+] PASSED [ 73%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-6-+] PASSED [ 74%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-7-+] PASSED [ 75%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-0--] PASSED [ 76%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-1--] PASSED [ 78%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-2--] PASSED [ 79%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-3--] PASSED [ 80%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-4--] PASSED [ 82%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-5--] PASSED [ 83%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-6--] PASSED [ 84%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-7--] PASSED [ 85%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_value_error_num_nodes XFAIL [ 87%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_run_quantum_walk PASSED [ 88%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_invalid_a_N PASSED [ 89%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_shors_algorithm PASSED [ 91%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_all_valid_a PASSED [ 92%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_no_counts PASSED [ 93%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[00000] PASSED [ 94%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[10110] PASSED [ 96%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_low_shot_number XFAIL [ 97%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_bad_string XFAIL [ 98%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_zero_shot_number XFAIL [100%] + +======================================================== FAILURES ======================================================== +________________________________________________ test_linear_combination _________________________________________________ + + def test_linear_combination(): + for n_inputs in range(3, 6): + print() + n_qubits = n_inputs + 2 # +2: ancilla and output qubit + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) + ancilla = len(weights) # ID of an ancilla qubit + + inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + +> dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) + +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:36: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} + + def device(name, *args, **kwargs): + r"""device(name, wires=1, *args, **kwargs) + Load a :class:`~.Device` and return the instance. + + This function is used to load a particular quantum device, + which can then be used to construct QNodes. + + PennyLane comes with support for the following devices: + + * :mod:`'default.qubit' `: a simple + state simulator of qubit-based quantum circuit architectures. + + * :mod:`'default.gaussian' `: a simple simulator + of Gaussian states and operations on continuous-variable circuit architectures. + + * :mod:`'default.qubit.tf' `: a state simulator + of qubit-based quantum circuit architectures written in TensorFlow, which allows + automatic differentiation through the simulation. + + * :mod:`'default.qubit.autograd' `: a state simulator + of qubit-based quantum circuit architectures which allows + automatic differentiation through the simulation via python's autograd library. + + Additional devices are supported through plugins — see + the `available plugins `_ for more + details. + + Args: + name (str): the name of the device to load + wires (int): the number of wires (subsystems) to initialise + the device with + + Keyword Args: + config (pennylane.Configuration): a PennyLane configuration object + that contains global and/or device specific configurations. + custom_decomps (Dict[Union(str, qml.Operator), Callable]): Custom + decompositions to be applied by the device at runtime. + decomp_depth (int): For when custom decompositions are specified, + the maximum expansion depth used by the expansion function. + + All devices must be loaded by specifying their **short-name** as listed above, + followed by the **wires** (subsystems) you wish to initialize. The *wires* + argument can be an integer, in which case the wires of the device are addressed + by consecutive integers: + + .. code-block:: python + + dev = qml.device('default.qubit', wires=5) + + def circuit(): + qml.Hadamard(wires=1) + qml.Hadamard(wires=[0]) + qml.CNOT(wires=[3, 4]) + ... + + The *wires* argument can also be a sequence of unique numbers or strings, specifying custom wire labels + that the user employs to address the wires: + + .. code-block:: python + + dev = qml.device('default.qubit', wires=['ancilla', 'q11', 'q12', -1, 1]) + + def circuit(): + qml.Hadamard(wires='q11') + qml.Hadamard(wires=['ancilla']) + qml.CNOT(wires=['q12', -1]) + ... + + Most devices accept a ``shots`` argument which specifies how many circuit executions + are used to estimate stochastic return values. In particular, ``qml.sample()`` measurements + will return as many samples as specified in the shots argument. The shots argument can be + changed on a per-call basis using the built-in ``shots`` keyword argument. + + .. code-block:: python + + dev = qml.device('default.qubit', wires=1, shots=10) + + @qml.qnode(dev) + def circuit(a): + qml.RX(a, wires=0) + return qml.sample(qml.PauliZ(wires=0)) + + >>> circuit(0.8) # 10 samples are returned + [ 1 1 1 -1 -1 1 1 1 1 1] + >>> circuit(0.8, shots=3) # default is overwritten for this call + [1 1 1] + >>> circuit(0.8) # back to default of 10 samples + [ 1 1 1 -1 -1 1 1 1 1 1] + + When constructing a device, we may optionally pass a dictionary of custom + decompositions to be applied to certain operations upon device execution. + This is useful for enabling support of gates on devices where they would normally + be unsupported. + + For example, suppose we are running on an ion trap device which does not + natively implement the CNOT gate, but we would still like to write our + circuits in terms of CNOTs. On a ion trap device, CNOT can be implemented + using the ``IsingXX`` gate. We first define a decomposition function + (such functions have the signature ``decomposition(*params, wires)``): + + .. code-block:: python + + def ion_trap_cnot(wires): + return [ + qml.RY(np.pi/2, wires=wires[0]), + qml.IsingXX(np.pi/2, wires=wires), + qml.RX(-np.pi/2, wires=wires[0]), + qml.RY(-np.pi/2, wires=wires[0]), + qml.RY(-np.pi/2, wires=wires[1]) + ] + + Next, we create a device, and a QNode for testing. When constructing the + QNode, we can set the expansion strategy to ``"device"`` to ensure the + decomposition is applied and will be viewable when we draw the circuit. + + .. code-block:: python + + # As the CNOT gate normally has no decomposition, we can use default.qubit + # here for expository purposes. + dev = qml.device( + 'default.qubit', wires=2, custom_decomps={"CNOT" : ion_trap_cnot} + ) + + @qml.qnode(dev, expansion_strategy="device") + def run_cnot(): + qml.CNOT(wires=[0, 1]) + return qml.expval(qml.PauliX(wires=1)) + + >>> print(qml.draw(run_cnot)()) + 0: ──RY(1.57)─╭IsingXX(1.57)──RX(-1.57)──RY(-1.57)─┤ + 1: ───────────╰IsingXX(1.57)──RY(-1.57)────────────┤ + + Some devices may accept additional arguments. For instance, + ``default.gaussian`` accepts the keyword argument ``hbar``, to set + the convention used in the commutation relation :math:`[\x,\p]=i\hbar` + (by default set to 2). + + Please refer to the documentation for the individual devices to see any + additional arguments that might be required or supported. + """ + if name not in plugin_devices: + # Device does not exist in the loaded device list. + # Attempt to refresh the devices, in case the user + # installed the plugin during the current Python session. + refresh_devices() + + if name in plugin_devices: + options = {} + + # load global configuration settings if available + config = kwargs.get("config", default_config) + + if config: + # combine configuration options with keyword arguments. + # Keyword arguments take preference, followed by device options, + # followed by plugin options, followed by global options. + options.update(config["main"]) + options.update(config[name.split(".")[0] + ".global"]) + options.update(config[name]) + + # Pop the custom decomposition keyword argument; we will use it here + # only and not pass it to the device. + custom_decomps = kwargs.pop("custom_decomps", None) + decomp_depth = kwargs.pop("decomp_depth", 10) + + kwargs.pop("config", None) + options.update(kwargs) + + # loads the device class + plugin_device_class = plugin_devices[name].load() + + if Version(version()) not in SimpleSpec(plugin_device_class.pennylane_requires): + raise DeviceError( + f"The {name} plugin requires PennyLane versions {plugin_device_class.pennylane_requires}, " + f"however PennyLane version {__version__} is installed." + ) + + # Construct the device + dev = plugin_device_class(*args, **options) + + # Once the device is constructed, we set its custom expansion function if + # any custom decompositions were specified. + if custom_decomps is not None: + custom_decomp_expand_fn = pennylane.transforms.create_decomp_expand_fn( + custom_decomps, dev, decomp_depth=decomp_depth + ) + dev.custom_expand(custom_decomp_expand_fn) + + return dev + +> raise DeviceError("Device does not exist. Make sure the required plugin is installed.") +E pennylane._device.DeviceError: Device does not exist. Make sure the required plugin is installed. + +.tox/unit-tests/lib/python3.10/site-packages/pennylane/__init__.py:338: DeviceError +-------------------------------------------------- Captured stdout call -------------------------------------------------- + +__________________________________________________ test_quantum_neuron ___________________________________________________ + + def test_quantum_neuron(): + for n_inputs in range(3, 6): + print() + n_qubits = n_inputs + 2 # +2: ancilla and output qubit + bias = 0.05 # constant + weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) + + inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] + input_to_test = 5 # I picked this at random. + +> dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) + +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:75: +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + +name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} + + def device(name, *args, **kwargs): + r"""device(name, wires=1, *args, **kwargs) + Load a :class:`~.Device` and return the instance. + + This function is used to load a particular quantum device, + which can then be used to construct QNodes. + + PennyLane comes with support for the following devices: + + * :mod:`'default.qubit' `: a simple + state simulator of qubit-based quantum circuit architectures. + + * :mod:`'default.gaussian' `: a simple simulator + of Gaussian states and operations on continuous-variable circuit architectures. + + * :mod:`'default.qubit.tf' `: a state simulator + of qubit-based quantum circuit architectures written in TensorFlow, which allows + automatic differentiation through the simulation. + + * :mod:`'default.qubit.autograd' `: a state simulator + of qubit-based quantum circuit architectures which allows + automatic differentiation through the simulation via python's autograd library. + + Additional devices are supported through plugins — see + the `available plugins `_ for more + details. + + Args: + name (str): the name of the device to load + wires (int): the number of wires (subsystems) to initialise + the device with + + Keyword Args: + config (pennylane.Configuration): a PennyLane configuration object + that contains global and/or device specific configurations. + custom_decomps (Dict[Union(str, qml.Operator), Callable]): Custom + decompositions to be applied by the device at runtime. + decomp_depth (int): For when custom decompositions are specified, + the maximum expansion depth used by the expansion function. + + All devices must be loaded by specifying their **short-name** as listed above, + followed by the **wires** (subsystems) you wish to initialize. The *wires* + argument can be an integer, in which case the wires of the device are addressed + by consecutive integers: + + .. code-block:: python + + dev = qml.device('default.qubit', wires=5) + + def circuit(): + qml.Hadamard(wires=1) + qml.Hadamard(wires=[0]) + qml.CNOT(wires=[3, 4]) + ... + + The *wires* argument can also be a sequence of unique numbers or strings, specifying custom wire labels + that the user employs to address the wires: + + .. code-block:: python + + dev = qml.device('default.qubit', wires=['ancilla', 'q11', 'q12', -1, 1]) + + def circuit(): + qml.Hadamard(wires='q11') + qml.Hadamard(wires=['ancilla']) + qml.CNOT(wires=['q12', -1]) + ... + + Most devices accept a ``shots`` argument which specifies how many circuit executions + are used to estimate stochastic return values. In particular, ``qml.sample()`` measurements + will return as many samples as specified in the shots argument. The shots argument can be + changed on a per-call basis using the built-in ``shots`` keyword argument. + + .. code-block:: python + + dev = qml.device('default.qubit', wires=1, shots=10) + + @qml.qnode(dev) + def circuit(a): + qml.RX(a, wires=0) + return qml.sample(qml.PauliZ(wires=0)) + + >>> circuit(0.8) # 10 samples are returned + [ 1 1 1 -1 -1 1 1 1 1 1] + >>> circuit(0.8, shots=3) # default is overwritten for this call + [1 1 1] + >>> circuit(0.8) # back to default of 10 samples + [ 1 1 1 -1 -1 1 1 1 1 1] + + When constructing a device, we may optionally pass a dictionary of custom + decompositions to be applied to certain operations upon device execution. + This is useful for enabling support of gates on devices where they would normally + be unsupported. + + For example, suppose we are running on an ion trap device which does not + natively implement the CNOT gate, but we would still like to write our + circuits in terms of CNOTs. On a ion trap device, CNOT can be implemented + using the ``IsingXX`` gate. We first define a decomposition function + (such functions have the signature ``decomposition(*params, wires)``): + + .. code-block:: python + + def ion_trap_cnot(wires): + return [ + qml.RY(np.pi/2, wires=wires[0]), + qml.IsingXX(np.pi/2, wires=wires), + qml.RX(-np.pi/2, wires=wires[0]), + qml.RY(-np.pi/2, wires=wires[0]), + qml.RY(-np.pi/2, wires=wires[1]) + ] + + Next, we create a device, and a QNode for testing. When constructing the + QNode, we can set the expansion strategy to ``"device"`` to ensure the + decomposition is applied and will be viewable when we draw the circuit. + + .. code-block:: python + + # As the CNOT gate normally has no decomposition, we can use default.qubit + # here for expository purposes. + dev = qml.device( + 'default.qubit', wires=2, custom_decomps={"CNOT" : ion_trap_cnot} + ) + + @qml.qnode(dev, expansion_strategy="device") + def run_cnot(): + qml.CNOT(wires=[0, 1]) + return qml.expval(qml.PauliX(wires=1)) + + >>> print(qml.draw(run_cnot)()) + 0: ──RY(1.57)─╭IsingXX(1.57)──RX(-1.57)──RY(-1.57)─┤ + 1: ───────────╰IsingXX(1.57)──RY(-1.57)────────────┤ + + Some devices may accept additional arguments. For instance, + ``default.gaussian`` accepts the keyword argument ``hbar``, to set + the convention used in the commutation relation :math:`[\x,\p]=i\hbar` + (by default set to 2). + + Please refer to the documentation for the individual devices to see any + additional arguments that might be required or supported. + """ + if name not in plugin_devices: + # Device does not exist in the loaded device list. + # Attempt to refresh the devices, in case the user + # installed the plugin during the current Python session. + refresh_devices() + + if name in plugin_devices: + options = {} + + # load global configuration settings if available + config = kwargs.get("config", default_config) + + if config: + # combine configuration options with keyword arguments. + # Keyword arguments take preference, followed by device options, + # followed by plugin options, followed by global options. + options.update(config["main"]) + options.update(config[name.split(".")[0] + ".global"]) + options.update(config[name]) + + # Pop the custom decomposition keyword argument; we will use it here + # only and not pass it to the device. + custom_decomps = kwargs.pop("custom_decomps", None) + decomp_depth = kwargs.pop("decomp_depth", 10) + + kwargs.pop("config", None) + options.update(kwargs) + + # loads the device class + plugin_device_class = plugin_devices[name].load() + + if Version(version()) not in SimpleSpec(plugin_device_class.pennylane_requires): + raise DeviceError( + f"The {name} plugin requires PennyLane versions {plugin_device_class.pennylane_requires}, " + f"however PennyLane version {__version__} is installed." + ) + + # Construct the device + dev = plugin_device_class(*args, **options) + + # Once the device is constructed, we set its custom expansion function if + # any custom decompositions were specified. + if custom_decomps is not None: + custom_decomp_expand_fn = pennylane.transforms.create_decomp_expand_fn( + custom_decomps, dev, decomp_depth=decomp_depth + ) + dev.custom_expand(custom_decomp_expand_fn) + + return dev + +> raise DeviceError("Device does not exist. Make sure the required plugin is installed.") +E pennylane._device.DeviceError: Device does not exist. Make sure the required plugin is installed. + +.tox/unit-tests/lib/python3.10/site-packages/pennylane/__init__.py:338: DeviceError +-------------------------------------------------- Captured stdout call -------------------------------------------------- + +==================================================== warnings summary ==================================================== +.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:121 +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:121: DeprecationWarning: pkg_resources is deprecated as an API + warnings.warn("pkg_resources is deprecated as an API", DeprecationWarning) + +.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: 4 warnings +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py: 8 warnings + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google')`. + Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages + declare_namespace(pkg) + +.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870 +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google.logging')`. + Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages + declare_namespace(pkg) + +.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2349 +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2349: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google')`. + Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages + declare_namespace(parent) + +.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870 +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('mpl_toolkits')`. + Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages + declare_namespace(pkg) + +.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: 5 warnings +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py: 10 warnings + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('sphinxcontrib')`. + Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages + declare_namespace(pkg) + +.tox/unit-tests/lib/python3.10/site-packages/openfermion/hamiltonians/hartree_fock.py:11 + /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/openfermion/hamiltonians/hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated. + from scipy.optimize.optimize import OptimizeResult + +-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html + +---------- coverage: platform linux, python 3.10.8-final-0 ----------- +Name Stmts Miss Branch BrPart Cover Missing +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +.tox/unit-tests/lib/python3.10/site-packages/braket/_schemas/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/_schemas/_version.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/_sdk/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/_sdk/_version.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/__init__.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/analog_hamiltonian_simulation.py 50 21 6 0 52% 40-41, 46, 51, 60, 66, 72-76, 95-108, 117, 122, 135 +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/atom_arrangement.py 50 25 16 0 41% 40-44, 47-49, 52-53, 61, 78-79, 94, 97, 100, 114-124 +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/discretization_types.py 8 0 2 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/driving_field.py 49 29 4 0 38% 62-65, 69, 74, 79, 84, 108-112, 124-138, 160-179 +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/field.py 25 12 4 0 45% 32-33, 38, 43, 66-76 +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/hamiltonian.py 22 12 4 0 38% 30, 35, 47-48, 51-54, 57-60 +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/pattern.py 13 4 2 0 60% 29, 35, 48-49 +.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/shifting_field.py 35 18 6 0 41% 50-51, 55, 62, 76-84, 134-138, 150-156 +.tox/unit-tests/lib/python3.10/site-packages/braket/annealing/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/annealing/problem.py 35 15 2 0 54% 60-62, 71, 80, 90, 102-103, 114-115, 127-128, 139-140, 148 +.tox/unit-tests/lib/python3.10/site-packages/braket/aws/__init__.py 5 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_device.py 198 129 52 0 28% 81-89, 162, 244, 269, 272-273, 280-290, 295-314, 317-331, 336, 341, 345, 350, 358-410, 420, 440-442, 451-470, 474, 480, 483, 486-488, 494-495, 501-502, 540-582, 585-600, 618-621 +.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_quantum_job.py 196 134 46 0 26% 176-205, 215-224, 231-232, 244-246, 251, 256, 273, 312-347, 360-362, 387-396, 407-408, 431-441, 445-453, 479-497, 503-518, 522-523, 526, 529-531, 534, 540-544, 554-563, 571-593 +.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_quantum_task.py 251 162 57 0 29% 159-182, 225-235, 247-249, 254, 258-262, 266-267, 284-286, 304, 307-314, 319-321, 342-354, 357-371, 378, 389, 409-432, 439-453, 456, 459-461, 464, 479, 494-496, 511-534, 549-551, 566-610, 630-639, 654-656, 662-675, 691-712, 722, 734, 739-740, 745, 750, 757 +.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_quantum_task_batch.py 131 96 72 0 17% 95-124, 143-179, 203-237, 254-274, 301-316, 320-322, 334-362, 367, 372, 380-389, 394 +.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_session.py 249 181 78 0 21% 54-91, 95, 99, 108-110, 119-121, 130-132, 141-143, 152-154, 164-175, 188-190, 194, 206-207, 221-233, 245-246, 250, 276-278, 294-299, 321, 333, 346-348, 357-358, 387-401, 411-412, 423-429, 450-459, 480-492, 507-514, 531-589, 601, 625-642, 653-657, 674-685, 702-704, 727-739, 764-774, 792-821 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/__init__.py 19 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/angled_gate.py 76 25 12 1 61% 57, 94, 102-110, 120, 153-156, 175, 185, 195, 210, 218, 221, 229, 244, 279, 317-325 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/ascii_circuit_diagram.py 138 17 74 10 86% 45, 71->79, 89, 93, 121, 129, 173, 246-254, 257, 291 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/basis_state.py 40 11 10 1 60% 13, 21, 25, 41, 50-55, 60-67 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/circuit.py 426 154 227 29 56% 149, 180-195, 201, 285, 290-295, 297->317, 306->314, 326, 353, 355->339, 363-366, 370, 446, 454-459, 549, 559, 615-631, 742-775, 824-844, 862, 877-882, 924, 975-1004, 1060, 1077, 1118, 1123, 1129, 1132-1138, 1184, 1191-1192, 1199, 1209-1214, 1219-1225, 1261-1272, 1303-1306, 1316, 1328-1331, 1345, 1348, 1359, 1372, 1385-1391, 1419->1421 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/circuit_diagram.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/circuit_helpers.py 16 5 16 6 66% 32, 34, 39, 42, 43->40, 46 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/compiler_directive.py 32 15 6 0 45% 35-37, 41, 46, 71-76, 80, 84, 95, 100, 103 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/compiler_directives.py 21 8 0 0 62% 27, 30, 33, 36, 46, 49, 52, 55 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/free_parameter.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/free_parameter_expression.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/gate.py 56 18 16 4 61% 56, 66, 107-109, 114, 126, 138, 172-187 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/gates.py 838 251 58 0 67% 75, 78, 137, 140, 143, 202, 205, 208, 260, 264, 267, 270, 273, 277, 310, 332, 335, 338, 390, 394, 397, 400, 403, 407, 440, 455, 459, 462, 465, 468, 472, 505, 530, 533, 595, 598, 650, 654, 657, 660, 663, 667, 700, 715, 719, 722, 725, 728, 732, 765, 798, 805-807, 867, 875, 878, 885-887, 891, 894, 928, 958, 961, 1023, 1031, 1034, 1037, 1040, 1044, 1078, 1110, 1113, 1167, 1170, 1173, 1235, 1239, 1242, 1245, 1248, 1260, 1294, 1314, 1325, 1328, 1331, 1342, 1346, 1382, 1404, 1415, 1418, 1425-1427, 1438, 1442, 1478, 1509, 1512, 1515, 1567, 1575, 1578, 1581, 1584, 1588, 1615-1617, 1647, 1650, 1653, 1705, 1713, 1716, 1719, 1722, 1726, 1753-1755, 1770, 1774, 1777, 1780, 1783, 1795, 1816-1818, 1830, 1834, 1837, 1840, 1843, 1855, 1876-1878, 1890, 1894, 1897, 1900, 1903, 1907, 1928-1930, 1942, 1946, 1949, 1952, 1955, 1966, 2000, 2022, 2033, 2036, 2043-2045, 2056, 2060, 2096, 2118, 2129, 2132, 2139-2141, 2152, 2156, 2192, 2214, 2225, 2228, 2231, 2242, 2246, 2282, 2311, 2314, 2391, 2394, 2397, 2461, 2469, 2472, 2480, 2484, 2487, 2521, 2540, 2548, 2551, 2559, 2563, 2566, 2600, 2624, 2633, 2636, 2646, 2650, 2653, 2691, 2720-2727, 2730, 2733, 2736, 2744-2752, 2755-2757, 2761, 2787-2790, 2808-2814, 2819, 2824, 2834-2835, 2838, 2843-2848, 2888, 2910-2920 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/instruction.py 77 16 24 8 72% 87, 91, 128, 160-162, 185-186, 188, 256, 258, 296, 299-302 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/moments.py 132 35 36 7 69% 130, 181, 188-191, 193, 222-231, 252, 254, 259, 266, 282, 286, 307, 310, 313, 316, 319, 322-324, 327-330, 333, 336 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/noise.py 217 124 56 0 34% 54, 64, 88-102, 114, 130, 138, 141-143, 146, 159-163, 202-206, 214, 217, 220, 232, 235-237, 250, 260, 294, 328, 375-396, 407-417, 425, 431, 434-436, 444, 458, 473, 483-486, 527-535, 550-554, 562, 570, 578, 581, 591, 594-596, 610, 623, 633, 671-675, 683, 686, 689, 701, 704-706, 719, 729, 769-773, 781, 784, 791, 805, 808-814, 824, 843-846, 859-861 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/noise_helpers.py 97 79 66 0 11% 37-38, 53-55, 68-80, 96-100, 114-125, 150-180, 213-232, 268-322 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/noises.py 356 182 58 0 43% 81, 88, 93-94, 101-103, 107, 124, 137, 150, 184, 191, 196-197, 204-206, 210, 227, 240, 253, 314, 323, 330-331, 341-345, 349, 372, 385-389, 402, 458, 465, 470-471, 478-482, 486, 503, 516, 529, 584, 591, 598-600, 611-623, 627, 647, 661, 674, 711, 718, 725-727, 737-744, 748, 768, 780, 793, 867-875, 882-895, 898, 904, 924, 939-943, 956-959, 991, 998, 1003-1004, 1011-1013, 1017, 1034, 1047, 1060, 1110, 1118, 1125-1126, 1136-1144, 1148, 1168, 1184-1186, 1199, 1236, 1243, 1248-1249, 1256-1258, 1262, 1279, 1291, 1304, 1328-1345, 1352, 1355, 1363-1374, 1378-1384, 1406-1411, 1422, 1435, 1454-1460, 1464, 1477-1479 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/observable.py 81 26 18 5 63% 45, 72, 77, 85, 89, 105, 121, 129, 143, 158, 162-166, 169, 172-175, 178-181, 189, 203, 207, 210 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/observables.py 337 182 126 3 38% 44, 47, 50-52, 57-62, 65, 71, 88, 91-93, 98-103, 106, 110, 118, 121, 135, 138, 141-143, 148-153, 156, 160, 174, 177, 180-182, 187-192, 195, 199, 219-221, 231, 238, 272-275, 277, 306-308, 311-316, 344, 354-357, 365-369, 383-398, 404, 408-425, 447-457, 461-466, 469, 476-486, 498, 501, 505, 509, 512, 515, 518, 522, 549-561, 564, 567-569, 576-586, 589-592, 595, 598, 602, 610, 613, 633-641, 644-645, 662-666, 670-687 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/operator.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/parameterizable.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/quantum_operator.py 47 16 14 5 62% 56, 63, 66, 69, 72-76, 101, 119, 127, 140-145, 148 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/quantum_operator_helpers.py 28 18 8 0 28% 32-39, 58, 71, 91, 107-108, 123-131 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/qubit.py 20 3 6 2 81% 41, 43, 50 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/qubit_set.py 19 0 8 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/result_type.py 98 37 38 8 51% 48, 90, 95, 101, 105, 118, 154-162, 174, 212-213, 218-226, 231, 236, 254, 257-263, 269, 293-301, 322, 325, 331 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/result_types.py 192 74 49 1 52% 50, 53, 56, 69, 72-74, 77, 82, 104-106, 110, 118, 121-125, 128-133, 150, 153-155, 158, 161, 166, 213-218, 226-234, 268, 294-306, 310, 313, 316-317, 333, 336-338, 341, 344, 347, 388, 391-395, 426, 432, 479-484, 547, 554-559, 562-567, 586, 623, 630-635, 638-643, 662 +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/serialization.py 15 0 2 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/unitary_calculation.py 44 34 20 0 16% 26-38, 67-93, 121-140 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/__init__.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/_version.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/density_matrix_simulation.py 73 46 24 0 28% 38-42, 45, 61-69, 88-108, 111, 123, 133-135, 138-141, 149, 161-166, 187-194, 211-213, 233-243 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/density_matrix_simulator.py 16 7 0 0 56% 38-40, 44-47 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/gate_operations.py 502 140 0 0 72% 53, 77, 101, 108, 116, 120, 125, 149, 156, 164, 175, 180, 204, 211, 219, 223, 228, 235, 243, 247, 252, 259, 267, 278, 283, 290, 298, 302, 307, 314, 322, 326, 331, 355, 379, 386, 394, 398, 403, 410, 418, 422, 427, 434-439, 443, 447, 452, 477, 484-489, 493, 497, 502, 527, 534-539, 543, 547, 552, 579, 586-591, 595-597, 601, 606, 633, 657, 664, 672, 684, 689, 696-701, 705, 717, 722, 732-737, 741-743, 755, 760, 770-775, 779-781, 792, 797, 807-812, 816-818, 829, 834, 844-849, 853-855, 866, 871, 907, 943, 954-959, 963, 972, 983-988, 992, 1001, 1012-1018, 1022, 1033, 1040-1048, 1052, 1056, 1061, 1083-1090, 1101, 1116, 1125-1128, 1132, 1136 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/linalg_utils.py 46 17 16 1 55% 51-58, 144-156 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/noise_operations.py 202 104 16 0 46% 35-36, 40-42, 46, 51, 58-59, 63-65, 69, 74, 81-84, 88-94, 98, 103, 112-113, 117-123, 127, 132, 139-140, 144-156, 160, 165, 172-173, 177-184, 188, 193, 200-201, 205-207, 211, 216, 223-225, 229-239, 243, 248, 257-258, 262-264, 268, 273, 282-287, 291, 295, 300, 318-332, 336, 340, 345 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/observables.py 211 82 50 3 53% 43, 46, 50, 54, 58, 61, 64, 67, 88-90, 94, 111, 115, 119, 122, 125-127, 131, 145, 149, 153, 156, 159-161, 165, 182, 186, 190, 193, 196-198, 202, 233, 236, 240, 250-262, 265, 270, 274, 278, 281, 284-288, 291-293, 296, 315-322, 337, 346, 350, 354, 362, 371, 374, 382-397, 409 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/arrays.py 91 66 52 3 20% 29-37, 42-46, 51, 56, 58, 66-77, 85-90, 97, 102-105, 110, 119-131, 143-170, 181-195 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/casting.py 100 57 51 1 29% 33-41, 52-62, 68-81, 87-97, 103-109, 115-125, 143, 150, 156, 169, 175, 180, 185, 190, 195, 200 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/functions.py 26 8 8 2 65% 138->exit, 174, 181-185, 193, 199 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/quantum.py 38 29 22 0 15% 17-19, 28-30, 38-41, 46-54, 68, 77, 88-96 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/circuit.py 66 31 40 4 41% 33-34, 37-38, 72-90, 94-108, 111-112, 117 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/interpreter.py 382 225 168 19 35% 114, 117-118, 124, 134-135, 141, 162-163, 165, 169, 174-181, 185-189, 193-198, 206, 210, 221, 223, 233, 242-243, 247, 252, 257-261, 266-275, 279-288, 291-339, 347, 352, 363-384, 396-424, 428-436, 440-447, 459-473, 477, 481-485, 489-501, 505-507, 511-515, 523, 525-533, 537-546, 550-590, 594-595, 599-602, 621 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/braket_pragmas.py 123 54 31 1 51% 45-49, 78-83, 87-88, 110, 117-118, 133-137, 149-157, 162-170, 175-177, 180-181, 184-188, 191-205, 208-210, 213 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/BraketPragmasLexer.py 886 1 6 1 99% 8 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/BraketPragmasParser.py 6458 4128 1280 37 31% 9, 833, 837, 841, 845, 849, 852-853, 856-857, 863, 882-904, 914-915, 918, 921, 924, 927, 931, 934, 938, 941-942, 945-946, 949-952, 959-981, 988-989, 992, 995, 998, 1001-1002, 1005-1006, 1009-1012, 1019-1033, 1040-1041, 1044, 1047-1050, 1054, 1057-1060, 1063, 1066-1067, 1070-1071, 1074-1077, 1084-1113, 1120-1121, 1124, 1127-1130, 1134, 1137-1140, 1143, 1146-1147, 1150-1151, 1154-1157, 1164-1193, 1204, 1207, 1210, 1214, 1217-1218, 1221-1222, 1228, 1245-1248, 1262, 1266, 1270, 1274, 1278, 1281-1282, 1285-1286, 1292, 1306-1309, 1316-1319, 1326-1331, 1341-1342, 1345, 1349, 1352-1353, 1356-1357, 1360-1363, 1370-1382, 1389-1390, 1393, 1396, 1399-1400, 1403-1404, 1407-1410, 1417-1429, 1448, 1451-1452, 1455-1456, 1462, 1479->1489, 1484-1487, 1501, 1504, 1507, 1510-1511, 1514-1515, 1518-1521, 1536, 1540-1543, 1558, 1573, 1576-1577, 1580-1581, 1587, 1597-1600, 1603-1606, 1609-1610, 1613-1614, 1620, 1658-1663, 1673-1674, 1677, 1681, 1685, 1688-1689, 1692-1693, 1696-1699, 1706-1720, 1727-1728, 1731, 1734, 1737-1738, 1741-1742, 1745-1748, 1755-1767, 1774-1775, 1778-1781, 1784-1787, 1790, 1793-1794, 1797-1798, 1801-1804, 1811-1836, 1855, 1858-1859, 1862-1863, 1869, 1884-1887, 1901, 1905, 1909, 1913, 1916-1917, 1920-1921, 1927, 1952-1962, 1977, 1988-1989, 1992, 1995, 1998-1999, 2002-2003, 2006-2009, 2022, 2027, 2030-2031, 2034-2035, 2041, 2066-2079, 2093, 2096, 2100, 2104, 2108, 2111-2112, 2115-2116, 2122, 2140-2145, 2151-2154, 2164-2165, 2168, 2171, 2174, 2178, 2181, 2185, 2188-2189, 2192-2193, 2196-2199, 2206-2226, 2237, 2240, 2243, 2246, 2249-2250, 2253-2254, 2257-2260, 2275, 2279-2282, 2296, 2299, 2302, 2305, 2308, 2311, 2314-2315, 2318-2319, 2322-2325, 2340, 2344-2347, 2357-2358, 2362, 2366, 2373-2376, 2379, 2381, 2383, 2385, 2388-2389, 2392-2393, 2396-2399, 2405-2411, 2414, 2416, 2418, 2420, 2422-2425, 2428-2429, 2432-2433, 2436-2439, 2445-2519, 2526-2527, 2530, 2533, 2536, 2540, 2543-2544, 2547-2548, 2551-2554, 2561-2577, 2584-2585, 2589, 2593, 2600-2602, 2605, 2608, 2610, 2613, 2615, 2619-2620, 2623-2624, 2627-2630, 2636-2638, 2641, 2643, 2645, 2648, 2650, 2654-2655, 2658-2659, 2662-2665, 2671-2714, 2721-2722, 2725-2728, 2732-2735, 2738, 2741-2742, 2745-2746, 2749-2752, 2759-2784, 2791-2792, 2795-2798, 2801-2804, 2807, 2810-2811, 2814-2815, 2818-2821, 2828-2853, 2860-2861, 2864, 2867, 2870, 2873, 2876, 2879, 2882, 2885, 2888, 2891, 2894-2895, 2898-2899, 2902-2905, 2912-2930, 2937-2938, 2941, 2944, 2948-2951, 2955, 2958-2959, 2962-2963, 2966-2969, 2976-3007, 3014-3015, 3018, 3021, 3024, 3027, 3030-3031, 3034-3035, 3038-3041, 3048-3064, 3071-3072, 3075, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3107, 3111, 3115, 3119, 3123, 3127, 3131, 3135, 3139, 3143, 3147, 3151, 3155, 3159, 3163, 3167, 3171, 3175, 3179, 3183, 3187-3190, 3194, 3197-3198, 3201-3202, 3205-3208, 3215-3388, 3395-3396, 3399, 3402, 3405, 3408-3409, 3412-3413, 3416-3419, 3426-3447, 3454-3455, 3458, 3461, 3464-3467, 3471, 3474-3475, 3478-3479, 3482-3485, 3492-3517, 3524-3525, 3528, 3531, 3534, 3537-3538, 3541-3542, 3545-3548, 3555-3569, 3576-3577, 3580, 3584, 3588, 3591-3592, 3595-3596, 3599-3602, 3609-3634, 3641-3642, 3645, 3648, 3651, 3654, 3657-3658, 3661-3662, 3665-3668, 3675-3691, 3698-3699, 3702, 3705, 3708, 3711, 3714-3715, 3718-3719, 3722-3725, 3732-3748, 3755-3756, 3759, 3762, 3765, 3768-3769, 3772-3773, 3776-3779, 3786-3800, 3807-3808, 3811, 3814, 3817, 3820-3821, 3824-3825, 3828-3831, 3838-3852, 3859-3860, 3863, 3866, 3869, 3872-3873, 3876-3877, 3880-3883, 3890-3904, 3911-3913, 3916, 3919, 3923-3926, 3929, 3932, 3936, 3940, 3943, 3947, 3950, 3953-3954, 3957-3958, 3961-3964, 3971-4013, 4020-4023, 4026, 4029, 4032, 4036, 4039-4042, 4046, 4049, 4052-4053, 4056-4057, 4060-4063, 4070-4100, 4107-4108, 4111, 4114, 4117, 4121, 4125, 4128-4129, 4132-4133, 4136-4139, 4146-4175, 4182-4184, 4187, 4190, 4193, 4197, 4200, 4204, 4207-4208, 4211-4212, 4215-4218, 4225-4245, 4252-4253, 4256, 4259, 4262, 4266, 4269-4270, 4273-4274, 4277-4280, 4287-4310, 4317-4318, 4321, 4324, 4328, 4332, 4335-4336, 4339-4340, 4343-4346, 4353-4376, 4383-4384, 4387, 4390, 4394, 4397, 4401, 4404-4405, 4408-4409, 4412-4415, 4422-4447, 4454-4455, 4458, 4461, 4465, 4468-4471, 4475, 4478, 4481, 4485, 4489, 4492, 4495-4496, 4499-4500, 4503-4506, 4513-4625, 4632-4633, 4636, 4640, 4643, 4646, 4650, 4653-4654, 4657-4658, 4661-4664, 4671-4696, 4703-4704, 4707, 4710, 4714, 4717, 4720-4721, 4724-4725, 4728-4731, 4738-4754, 4761-4762, 4765, 4768, 4771, 4774, 4778, 4781, 4784-4785, 4788-4789, 4792-4795, 4802-4822, 4829-4830, 4833, 4836, 4839, 4843, 4847, 4850, 4854, 4857-4858, 4861-4862, 4865-4868, 4875-4914, 4921-4922, 4925, 4928, 4932, 4935, 4938, 4942, 4945, 4948-4949, 4952-4953, 4956-4959, 4966-4988, 4995-4996, 4999, 5002, 5005, 5008, 5011, 5015, 5019, 5022-5023, 5026-5027, 5030-5033, 5040-5076, 5083-5084, 5087, 5090, 5093, 5096, 5099, 5103, 5106-5107, 5110-5111, 5114-5117, 5124-5154, 5161-5162, 5165, 5169, 5172, 5175, 5178-5179, 5182-5183, 5186-5189, 5196-5212, 5219-5220, 5223, 5226, 5229, 5232, 5235, 5239, 5243, 5247, 5250-5251, 5254-5255, 5258-5261, 5268-5305, 5312-5313, 5316, 5319, 5322, 5325, 5328, 5331, 5335, 5339, 5342-5343, 5346-5347, 5350-5353, 5360-5397, 5404-5407, 5410, 5413, 5416, 5420-5423, 5427, 5430, 5433, 5436-5437, 5440-5441, 5444-5447, 5454-5491, 5498-5500, 5503, 5507, 5510, 5513, 5516, 5520, 5524, 5527-5528, 5531-5532, 5535-5538, 5545-5582, 5589-5590, 5593, 5597, 5600, 5603-5604, 5607-5608, 5611-5614, 5621-5635, 5642-5643, 5646, 5649, 5652, 5656, 5659, 5662, 5665, 5668, 5672, 5676, 5679-5680, 5683-5684, 5687-5690, 5697-5755, 5767, 5777-5779, 5782-5785, 5788, 5791-5792, 5795-5796, 5799-5802, 5808-5810, 5813-5816, 5819, 5821, 5824-5825, 5828-5829, 5832-5835, 5841-5842, 5845, 5847, 5849, 5852, 5855-5856, 5859-5860, 5863-5866, 5872-5873, 5876, 5878, 5881, 5884-5885, 5888-5889, 5892-5895, 5901-5903, 5906-5909, 5912, 5915-5916, 5919-5920, 5923-5926, 5932-5934, 5937-5940, 5943, 5945, 5947, 5950-5951, 5954-5955, 5958-5961, 5967-5969, 5972-5975, 5978, 5981-5982, 5985-5986, 5989-5992, 5998-5999, 6002, 6004, 6007, 6009, 6012, 6016-6017, 6020-6021, 6024-6027, 6033-6035, 6038-6041, 6044, 6047-6048, 6051-6052, 6055-6058, 6064-6066, 6069-6072, 6075, 6078-6079, 6082-6083, 6086-6089, 6095-6096, 6099, 6101, 6103, 6105, 6109-6110, 6113-6114, 6117-6120, 6126-6128, 6131-6134, 6137, 6140-6141, 6144-6145, 6148-6151, 6157-6159, 6162-6165, 6168, 6171-6172, 6175-6176, 6179-6182, 6188-6190, 6193-6196, 6199, 6202-6203, 6206-6207, 6210-6213, 6219-6221, 6224-6227, 6230, 6233-6234, 6237-6238, 6241-6244, 6250-6251, 6254, 6257, 6261-6262, 6265-6266, 6269-6272, 6278-6280, 6283, 6286, 6288, 6290, 6293-6294, 6297-6298, 6301-6304, 6314, 6316, 6318, 6320, 6322, 6324, 6326, 6328, 6330, 6332, 6334, 6337-6338, 6341-6342, 6345-6348, 6366-6376, 6379-6392, 6395-6418, 6421-6432, 6435-6452, 6454->6468, 6461, 6473-6654, 6664-6665, 6668-6671, 6675-6678, 6681, 6684-6685, 6688-6689, 6692-6695, 6702-6727, 6734-6735, 6738, 6742, 6746, 6750, 6753-6754, 6757-6758, 6761-6764, 6771-6801, 6808-6809, 6812, 6815, 6819, 6822-6823, 6826-6827, 6830-6833, 6840-6854, 6861-6862, 6865-6868, 6871-6874, 6878, 6881-6882, 6885-6886, 6889-6892, 6899-6938, 6945-6946, 6949, 6952-6955, 6959, 6962-6965, 6968, 6971-6972, 6975-6976, 6979-6982, 6989-7027, 7034-7035, 7038, 7041, 7044-7047, 7051-7054, 7058-7061, 7064, 7067-7068, 7071-7072, 7075-7078, 7085-7147, 7158, 7161, 7164, 7168-7171, 7175-7178, 7182-7185, 7188, 7191-7192, 7195-7196, 7199-7202, 7220-7222, 7232-7235, 7242-7261, 7267-7268, 7273, 7277-7280, 7294, 7297-7300, 7304, 7307-7308, 7311-7312, 7318, 7342-7345, 7355-7356, 7359, 7362, 7366, 7369-7370, 7373-7374, 7377-7380, 7387-7401, 7408-7409, 7412, 7415, 7418, 7421, 7424, 7428, 7431, 7434, 7437, 7440-7441, 7444-7445, 7448-7451, 7458-7512, 7519-7520, 7523, 7526, 7530, 7533, 7536, 7539, 7542, 7545, 7548, 7551, 7554, 7557, 7561, 7564, 7567-7568, 7571-7572, 7575-7578, 7585-7698, 7705-7706, 7709, 7712, 7716, 7719-7720, 7723-7724, 7727-7730, 7737-7758, 7765-7766, 7769, 7772, 7775, 7779, 7782, 7786, 7789, 7792-7793, 7796-7797, 7800-7803, 7810-7832, 7839-7840, 7843, 7846, 7849, 7853, 7856, 7859, 7862, 7865, 7869, 7872, 7875, 7879, 7882-7883, 7886-7887, 7890-7893, 7900-7946, 7953-7954, 7957, 7960, 7964, 7967, 7970-7971, 7974-7975, 7978-7981, 7988-8004, 8011-8012, 8015, 8019, 8022, 8025-8026, 8029-8030, 8033-8036, 8043-8068, 8075-8076, 8079, 8083, 8087, 8090, 8094, 8097-8098, 8101-8102, 8105-8108, 8115-8154, 8161-8162, 8165, 8168, 8171, 8174-8175, 8178-8179, 8182-8185, 8192-8210, 8217-8218, 8221, 8225, 8228, 8232, 8235, 8238, 8242, 8246, 8249-8250, 8253-8254, 8257-8260, 8267-8324, 8331-8332, 8335-8338, 8342-8345, 8348, 8351-8352, 8355-8356, 8359-8362, 8369-8403, 8410-8411, 8414-8417, 8421-8424, 8427, 8430-8431, 8434-8435, 8438-8441, 8448-8482, 8489-8490, 8493-8496, 8500-8503, 8506, 8509-8510, 8513-8514, 8517-8520, 8527-8561, 8568-8569, 8572-8575, 8578-8581, 8584, 8587-8588, 8591-8592, 8595-8598, 8605-8639, 8646-8647, 8650-8653, 8657-8660, 8663, 8666-8667, 8670-8671, 8674-8677, 8684-8718, 8725-8726, 8729-8732, 8736-8739, 8742, 8745-8746, 8749-8750, 8753-8756, 8763-8797, 8802-8809, 8812-8857 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/BraketPragmasParserVisitor.py 224 106 2 1 53% 6, 19, 24, 29, 34, 49, 54, 59, 64, 69, 74, 79, 84, 89, 94, 104, 109, 114, 119, 124, 129, 134, 139, 144, 149, 154, 159, 164, 169, 174, 179, 184, 189, 194, 199, 204, 209, 214, 219, 224, 229, 234, 239, 244, 249, 254, 259, 264, 269, 274, 279, 284, 289, 294, 299, 304, 309, 314, 319, 324, 329, 334, 339, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 394, 399, 404, 409, 414, 419, 424, 429, 434, 439, 444, 449, 454, 459, 464, 469, 474, 479, 484, 489, 494, 499, 504, 509, 514, 519, 524, 529, 534, 539, 544, 549, 554 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/qasm3Lexer.py 698 1 6 1 99% 8 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/qasm3Parser.py 4812 2818 986 74 36% 9, 647, 657, 661, 664-665, 668-669, 672-675, 707-710, 724, 730, 733, 736-737, 740-741, 744-747, 764-767, 785, 789, 793, 797, 801, 805, 809, 813, 817, 821, 825, 829, 833, 837, 841, 845, 849, 853, 857, 861, 865, 869, 873, 877, 881, 885, 889, 896, 900, 903-904, 907-908, 914, 939-943, 949-951, 959-961, 964-966, 969-971, 974-976, 984-986, 989-991, 994-996, 999-1001, 1004-1006, 1009-1011, 1014-1016, 1019-1021, 1024-1026, 1034-1036, 1039-1041, 1044-1046, 1049-1051, 1054-1056, 1059-1061, 1068-1081, 1086-1091, 1101-1102, 1105, 1108, 1111, 1114-1115, 1118-1119, 1122-1125, 1132-1153, 1160-1161, 1164, 1167, 1170-1173, 1177, 1180-1181, 1184-1185, 1188-1191, 1198-1223, 1234, 1240, 1243-1244, 1247-1248, 1254, 1269-1272, 1282-1283, 1286, 1290, 1294, 1297-1298, 1301-1302, 1305-1308, 1315-1340, 1347-1348, 1351, 1354, 1357, 1360, 1363-1364, 1367-1368, 1371-1374, 1381-1397, 1404-1405, 1408, 1411, 1414, 1417, 1420-1421, 1424-1425, 1428-1431, 1438-1454, 1461-1462, 1465, 1468, 1471, 1474-1475, 1478-1479, 1482-1485, 1492-1506, 1513-1514, 1517, 1520, 1523, 1526-1527, 1530-1531, 1534-1537, 1544-1558, 1565-1566, 1569, 1572, 1575, 1578-1579, 1582-1583, 1586-1589, 1596-1610, 1617-1619, 1622, 1625, 1629-1632, 1635, 1638, 1642, 1646, 1649, 1653, 1656, 1659-1660, 1663-1664, 1667-1670, 1677-1719, 1726-1729, 1732, 1735, 1738, 1742, 1745-1748, 1752, 1755, 1758-1759, 1762-1763, 1766-1769, 1776-1806, 1813-1814, 1817, 1820, 1823, 1827, 1831, 1834-1835, 1838-1839, 1842-1845, 1852-1881, 1888-1890, 1893, 1896, 1899, 1903, 1906, 1910, 1913-1914, 1917-1918, 1921-1924, 1931-1951, 1958-1959, 1962, 1965, 1968, 1972, 1975-1976, 1979-1980, 1983-1986, 1993-2016, 2023-2024, 2027, 2030, 2034, 2038, 2041-2042, 2045-2046, 2049-2052, 2059-2082, 2089-2090, 2093, 2096, 2100, 2103, 2107, 2110-2111, 2114-2115, 2118-2121, 2128-2153, 2171, 2177, 2181, 2184, 2198, 2201-2202, 2205-2206, 2212, 2232-2236, 2249->2254, 2262-2263, 2272-2328, 2338-2339, 2342, 2346, 2349, 2352, 2356, 2359-2360, 2363-2364, 2367-2370, 2377-2402, 2409-2410, 2413, 2416, 2420, 2423, 2426-2427, 2430-2431, 2434-2437, 2444-2460, 2467-2468, 2471, 2474, 2477, 2480, 2484, 2487, 2490-2491, 2494-2495, 2498-2501, 2508-2528, 2542, 2553, 2560, 2563-2564, 2567-2568, 2574, 2593-2598, 2606-2609, 2614-2617, 2627-2628, 2631, 2634, 2638, 2641, 2644, 2648, 2651, 2654-2655, 2658-2659, 2662-2665, 2672-2694, 2701-2702, 2705, 2708, 2711, 2714, 2717, 2721, 2725, 2728-2729, 2732-2733, 2736-2739, 2746-2782, 2789-2790, 2793, 2796, 2799, 2802, 2805, 2809, 2812-2813, 2816-2817, 2820-2823, 2830-2860, 2878, 2881, 2884-2885, 2888-2889, 2895, 2912-2915, 2925-2926, 2929, 2932, 2935, 2938, 2941, 2945, 2949, 2953, 2956-2957, 2960-2961, 2964-2967, 2974-3011, 3018-3019, 3022, 3025, 3028, 3031, 3034, 3037, 3041, 3045, 3048-3049, 3052-3053, 3056-3059, 3066-3103, 3110-3113, 3116, 3119, 3122, 3126-3129, 3133, 3136, 3139, 3142-3143, 3146-3147, 3150-3153, 3160-3197, 3213, 3216, 3219, 3222, 3230, 3233-3234, 3237-3238, 3244, 3262, 3270-3272, 3278, 3282-3285, 3295-3296, 3299, 3303, 3306, 3309-3310, 3313-3314, 3317-3320, 3327-3341, 3348-3349, 3352, 3355, 3358, 3362, 3365, 3368, 3371, 3374, 3378, 3382, 3385-3386, 3389-3390, 3393-3396, 3403-3461, 3473, 3483-3485, 3488-3491, 3494, 3497-3498, 3501-3502, 3505-3508, 3514-3516, 3519-3522, 3525, 3527, 3530-3531, 3534-3535, 3538-3541, 3547-3548, 3551, 3553, 3555, 3558, 3561-3562, 3565-3566, 3569-3572, 3578-3579, 3582, 3584, 3587, 3590-3591, 3594-3595, 3598-3601, 3607-3609, 3612-3615, 3618, 3621-3622, 3625-3626, 3629-3632, 3638-3640, 3643-3646, 3649, 3651, 3653, 3656-3657, 3660-3661, 3664-3667, 3673-3675, 3678-3681, 3684, 3687-3688, 3691-3692, 3695-3698, 3704-3705, 3708, 3710, 3713, 3715, 3718, 3722-3723, 3726-3727, 3730-3733, 3739-3741, 3744-3747, 3750, 3753-3754, 3757-3758, 3761-3764, 3770-3772, 3775-3778, 3781, 3784-3785, 3788-3789, 3792-3795, 3801-3802, 3805, 3807, 3809, 3811, 3815-3816, 3819-3820, 3823-3826, 3832-3834, 3837-3840, 3843, 3846-3847, 3850-3851, 3854-3857, 3863-3865, 3868-3871, 3874, 3877-3878, 3881-3882, 3885-3888, 3894-3896, 3899-3902, 3905, 3908-3909, 3912-3913, 3916-3919, 3925-3927, 3930-3933, 3936, 3939-3940, 3943-3944, 3947-3950, 3956-3957, 3960, 3963, 3967-3968, 3971-3972, 3975-3978, 3992, 3994, 3996, 3999-4000, 4003-4004, 4010, 4032, 4034, 4036, 4038, 4040, 4043-4044, 4047-4048, 4054, 4072-4082, 4092, 4101-4124, 4127-4138, 4141-4158, 4160->4174, 4167, 4179-4360, 4370-4371, 4374-4377, 4381-4384, 4387, 4390-4391, 4394-4395, 4398-4401, 4408-4433, 4440-4441, 4444, 4448, 4452, 4456, 4459-4460, 4463-4464, 4467-4470, 4477-4507, 4518, 4525, 4528-4529, 4532-4533, 4539, 4554-4557, 4567-4568, 4571-4574, 4577-4580, 4584, 4587-4588, 4591-4592, 4595-4598, 4605-4644, 4651-4652, 4655, 4658-4661, 4665, 4668-4671, 4674, 4677-4678, 4681-4682, 4685-4688, 4695-4733, 4740-4741, 4744, 4747, 4750-4753, 4757-4760, 4764-4767, 4770, 4773-4774, 4777-4778, 4781-4784, 4791-4853, 4864, 4867, 4874-4877, 4881-4884, 4888-4891, 4894, 4897-4898, 4901-4902, 4908, 4926-4928, 4938-4941, 4948-4967, 4973-4974, 4979, 4983-4986, 5006, 5010, 5013-5014, 5017-5018, 5024, 5048-5051, 5061-5062, 5065, 5068, 5072, 5075-5076, 5079-5080, 5083-5086, 5093-5107, 5114-5115, 5118, 5121, 5124, 5127, 5130, 5134, 5137, 5140, 5143, 5146-5147, 5150-5151, 5154-5157, 5164-5218, 5236, 5239, 5242, 5245, 5257, 5260, 5263, 5267, 5270, 5273-5274, 5277-5278, 5284, 5305->5310, 5311-5401, 5415, 5422, 5425-5426, 5429-5430, 5433-5436, 5453->5463, 5458-5461, 5471-5472, 5475, 5478, 5481, 5485, 5488, 5492, 5495, 5498-5499, 5502-5503, 5506-5509, 5516-5538, 5545-5546, 5549, 5552, 5555, 5559, 5562, 5565, 5568, 5571, 5575, 5578, 5581, 5585, 5588-5589, 5592-5593, 5596-5599, 5606-5652, 5663, 5670, 5673, 5676-5677, 5680-5681, 5687, 5704-5707, 5728, 5731-5732, 5735-5736, 5742, 5760-5771, 5781-5782, 5785, 5789, 5793, 5796, 5800, 5803-5804, 5807-5808, 5811-5814, 5821-5860, 5867-5868, 5871, 5874, 5877, 5880-5881, 5884-5885, 5888-5891, 5898-5916, 5923-5924, 5927, 5931, 5934, 5938, 5941, 5944, 5948, 5952, 5955-5956, 5959-5960, 5963-5966, 5973-6030, 6037-6038, 6041-6044, 6048-6051, 6054, 6057-6058, 6061-6062, 6065-6068, 6075-6109, 6123, 6127-6130, 6133, 6136-6137, 6140-6141, 6144-6147, 6165-6172, 6178-6185, 6195-6196, 6199-6202, 6206-6209, 6212, 6215-6216, 6219-6220, 6223-6226, 6233-6267, 6274-6275, 6278-6281, 6284-6287, 6290, 6293-6294, 6297-6298, 6301-6304, 6311-6345, 6359, 6363-6366, 6369, 6372-6373, 6376-6377, 6380-6383, 6401->6406, 6414-6421, 6431-6432, 6435-6438, 6442-6445, 6448, 6451-6452, 6455-6456, 6459-6462, 6469-6503, 6508-6515, 6518-6563 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/qasm3ParserVisitor.py 160 78 2 1 51% 6, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119, 124, 129, 134, 139, 144, 149, 154, 159, 164, 169, 174, 179, 184, 189, 194, 199, 204, 209, 214, 219, 224, 229, 234, 239, 244, 249, 254, 259, 264, 269, 274, 279, 284, 289, 294, 299, 304, 309, 314, 319, 324, 329, 334, 339, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 394 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/openqasm_ast.py 269 0 122 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/openqasm_parser.py 492 255 216 22 40% 47-48, 85->90, 92-93, 116, 126, 137, 157-159, 162, 165, 177, 180, 202, 208, 213, 220, 228, 234, 242-247, 251-252, 259-261, 265-267, 274, 276, 286, 294-296, 300-313, 322-345, 355-360, 364, 368, 372-382, 390-398, 419-423, 434-445, 449-453, 459-461, 465-468, 478-480, 489-500, 509, 518-520, 524-532, 536-538, 542, 546, 560, 580, 585, 590-591, 595-608, 613, 615, 617, 621, 624-645, 652-663, 667, 673-691, 695, 699-707, 713, 728, 740-746, 754, 756, 758, 761-774, 778-792, 800, 805-834, 838-856, 860-862, 867 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/program_context.py 281 98 60 6 58% 55, 58-59, 62-66, 78, 88->92, 90, 94-98, 102-107, 123, 126, 149-152, 158-162, 166-169, 172-177, 180-186, 204, 261, 277, 296-299, 309-312, 328, 343, 346, 358, 361, 390, 397-398, 436, 440-442, 446-448, 460, 464, 481-484, 501, 514, 521, 525-528, 541-546, 561, 569-573, 585-586, 590 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/operation.py 54 8 4 1 81% 62, 66, 81, 97, 105, 108-110 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/operation_helpers.py 32 15 16 0 40% 36, 41, 67, 81-86, 100-101, 113-114, 126-128 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/result_types.py 126 35 33 9 65% 57, 119, 141, 174, 179, 194, 206-213, 221, 234, 248-249, 254, 317, 322, 330, 336, 349, 351, 353, 355, 359-367, 372, 375-376 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulation.py 22 4 0 0 82% 65, 76, 87, 92 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulation_strategies/batch_operation_strategy.py 26 20 14 0 15% 56-61, 67-91 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulation_strategies/single_operation_strategy.py 14 0 2 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulator.py 149 49 86 10 63% 88, 117, 141, 144, 146, 150, 167-169, 216, 228, 257-259, 265, 279-291, 295-303, 424-467 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/state_vector_simulation.py 52 10 10 2 71% 57, 59, 85-93, 129, 139-141 +.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/state_vector_simulator.py 18 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/__init__.py 13 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/blackbird_device_action_properties.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/continuous_variable_qpu_paradigm_properties_v1.py 14 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_action_properties.py 12 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_capabilities.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_connectivity.py 4 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_execution_window.py 19 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_service_properties_v1.py 22 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/__init__.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_2000Q_device_level_parameters_v1.py 24 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_2000Q_device_parameters_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_advantage_device_level_parameters_v1.py 21 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_advantage_device_parameters_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_device_capabilities_v1.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_device_parameters_v1.py 11 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_provider_level_parameters_v1.py 30 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_provider_properties_v1.py 28 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/debias.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/error_mitigation_properties.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/error_mitigation_scheme.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/gate_model_parameters_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/gate_model_qpu_paradigm_properties_v1.py 10 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/ionq_device_capabilities_v1.py 28 7 0 0 75% 31-36, 40-44 +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/ionq_device_parameters_v1.py 19 6 4 0 57% 65-70 +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/ionq_provider_properties_v1.py 30 12 4 0 53% 28-35, 39-42 +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/jaqcd_device_action_properties.py 9 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/openqasm_device_action_properties.py 21 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/oqc_device_capabilities_v1.py 19 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/oqc_device_parameters_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/oqc_provider_properties_v1.py 11 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/__init__.py 0 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/frame_v1.py 11 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/port_v1.py 14 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/pulse_device_action_properties_v1.py 17 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/pulse_function_v1.py 11 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/result_type.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/rigetti_device_capabilities_v1.py 19 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/rigetti_device_parameters_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/rigetti_provider_properties_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/gate_model_simulator_device_capabilities_v1.py 13 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/gate_model_simulator_device_parameters_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/gate_model_simulator_paradigm_properties_v1.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/standardized_gate_model_qpu_device_properties_v1.py 35 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/xanadu_device_capabilities_v1.py 14 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/xanadu_device_parameters_v1.py 5 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/xanadu_provider_properties_v1.py 12 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/devices/__init__.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/devices/device.py 20 2 0 0 90% 97, 106 +.tox/unit-tests/lib/python3.10/site-packages/braket/devices/local_simulator.py 129 65 42 2 40% 135-179, 188, 198, 209, 213, 221, 227, 239, 257-263, 267-274, 285-296, 306-312, 322-328 +.tox/unit-tests/lib/python3.10/site-packages/braket/error_mitigation/__init__.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/error_mitigation/debias.py 6 1 0 0 83% 26 +.tox/unit-tests/lib/python3.10/site-packages/braket/error_mitigation/error_mitigation.py 5 1 0 0 80% 26 +.tox/unit-tests/lib/python3.10/site-packages/braket/ipython_utils.py 11 4 4 2 60% 31-34, 37 +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/__init__.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/atom_arrangement.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/driving_field.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/hamiltonian.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/physical_field.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/program_v1.py 14 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/shifting_field.py 4 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/time_series.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/annealing/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/annealing/problem_v1.py 13 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/blackbird/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/blackbird/program_v1.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/instructions.py 193 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/program_v1.py 31 13 12 0 42% 232-251 +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/results.py 35 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/shared_models.py 74 18 12 0 65% 255-258, 284-306 +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/openqasm/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/openqasm/modifiers.py 18 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/ir/openqasm/program_v1.py 10 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/config.py 26 3 12 0 87% 73-82 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/data_persistence.py 30 23 10 0 18% 50-62, 93-104, 129-136 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/image_uris.py 30 19 10 0 28% 43-55, 67-69, 85-91 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/logs.py 70 55 32 0 15% 46, 55-58, 67, 93-110, 134-155, 190-230 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/__init__.py 4 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/cwl_insights_metrics_fetcher.py 48 31 12 0 28% 45-48, 65, 79-90, 104-107, 125-128, 164-186 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/cwl_metrics_fetcher.py 56 42 22 0 18% 40-42, 55-57, 74-93, 106-124, 154-162 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/definitions.py 12 0 6 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/exceptions.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/log_metrics_parser.py 71 53 32 0 17% 37-38, 59-63, 79-87, 99-110, 129-143, 174-183, 209-211 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/quantum_job.py 26 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/quantum_job_creation.py 107 83 40 0 16% 138-222, 234-242, 259-266, 285-294, 305-315, 330-333, 344-348, 369-374, 391-401, 416, 426 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/serialization.py 8 2 4 0 50% 38, 63 +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs_data/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/jobs_data/persisted_job_data_v1.py 12 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/__init__.py 3 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/free_parameter.py 29 4 2 1 84% 85, 94, 97, 104 +.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/free_parameter_expression.py 63 27 24 5 49% 47, 51, 79, 87, 90-93, 96, 99-102, 105, 109, 117-120, 123, 126, 129-131, 152-157 +.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/parameterizable.py 11 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/__init__.py 4 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/approximation_parser.py 211 155 96 0 20% 55-59, 71, 76-79, 82-93, 101-102, 110, 124-132, 142-146, 157-165, 175-176, 186-189, 199-206, 219-263, 273, 283, 293, 303, 313, 323-326, 336-338, 346-348, 356-358, 366-369, 377-379, 387, 395-411, 421-422, 432-433, 443-444, 448-453, 467-471, 475 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/free_parameters.py 26 13 4 0 43% 26-27, 31, 38-39, 51-55, 66-69 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/qasm_parser.py 23 11 4 0 44% 27, 37, 47-51, 66-67, 79-81 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/qasm_transformer.py 14 8 2 0 38% 28-30, 39-58 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/frame.py 20 9 0 0 55% 49-54, 59, 62, 74 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/port.py 18 7 0 0 61% 34-36, 41, 46, 49, 52 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/pulse_sequence.py 138 103 46 0 19% 45-49, 61-62, 69, 86-89, 105-108, 124-127, 143-146, 162-165, 181-191, 204-208, 221-231, 244-248, 263-293, 301-311, 316-320, 333-339, 345-350 +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/pulse_sequence_trace.py 9 0 2 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/waveforms.py 103 54 4 0 46% 72-73, 76, 86, 95, 113-115, 121, 130-135, 138, 149-152, 165-167, 196-201, 207, 216-224, 227, 241-251, 269-283, 310-314, 320, 329-336, 339, 352-361, 378-388, 392, 398-404 +.tox/unit-tests/lib/python3.10/site-packages/braket/schema_common/__init__.py 2 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/schema_common/schema_base.py 22 10 4 0 46% 52, 66-70, 74-78 +.tox/unit-tests/lib/python3.10/site-packages/braket/schema_common/schema_header.py 16 8 0 0 50% 35, 38, 51-56 +.tox/unit-tests/lib/python3.10/site-packages/braket/simulator/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/simulator/braket_simulator.py 14 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/__init__.py 13 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/additional_metadata.py 23 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/analog_hamiltonian_simulation_task_result_v1.py 19 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/annealing_task_result_v1.py 14 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/dwave_metadata_v1.py 22 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/gate_model_task_result_v1.py 18 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/ionq_metadata_v1.py 7 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/oqc_metadata_v1.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/photonic_model_task_result_v1.py 11 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/quera_metadata_v1.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/rigetti_metadata_v1.py 17 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/simulator_metadata_v1.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/task_metadata_v1.py 20 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/xanadu_metadata_v1.py 6 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/__init__.py 10 2 2 1 75% 33-35 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/analog_hamiltonian_simulation_quantum_task_result.py 80 47 34 0 32% 39-45, 54-59, 65, 69, 77-81, 88-100, 117-130, 139-151, 155-159 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/annealing_quantum_task_result.py 57 34 16 0 34% 67-79, 82-99, 113, 126, 130-143, 163-174 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/gate_model_quantum_task_result.py 201 65 82 5 63% 103, 120-126, 132-134, 194-201, 235-237, 263-274, 280, 298, 342-351, 371-399, 421-424, 459-462, 471-474, 483-494 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/local_quantum_task.py 20 5 0 0 75% 42, 46, 49, 64, 67 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/local_quantum_task_batch.py 7 2 0 0 71% 40, 49 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/photonic_model_quantum_task_result.py 27 11 6 0 55% 30-32, 48, 52, 60-66 +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/quantum_task.py 19 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/quantum_task_batch.py 8 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/timings/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/timings/time_series.py 118 85 52 0 21% 38-40, 57-65, 73-74, 82-83, 86-87, 90, 93-95, 108-117, 130-133, 164-177, 228-256, 270-276, 291-299, 320-333 +.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/__init__.py 1 0 0 0 100% +.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/pricing.py 26 11 6 0 47% 34-55, 63-65 +.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/tracker.py 128 98 44 0 17% 39, 42-43, 46, 53, 60, 67, 76, 91-95, 114-118, 145-171, 175, 179, 188-191, 195-202, 206-248, 252-291 +.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/tracking_context.py 18 5 2 0 65% 26, 33, 40-41, 44 +.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/tracking_events.py 18 0 8 0 100% +src/braket/experimental/__init__.py 0 0 0 0 100% +src/braket/experimental/algorithms/__init__.py 0 0 0 0 100% +src/braket/experimental/algorithms/bells_inequality/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/bells_inequality/bells_inequality.py 38 0 16 0 100% +src/braket/experimental/algorithms/bernstein_vazirani/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/bernstein_vazirani/bernstein_vazirani.py 26 0 6 0 100% +src/braket/experimental/algorithms/chsh_inequality/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/chsh_inequality/chsh_inequality.py 30 0 12 0 100% +src/braket/experimental/algorithms/deutsch_jozsa/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/deutsch_jozsa/deutsch_jozsa.py 49 0 18 0 100% +src/braket/experimental/algorithms/grovers_search/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/grovers_search/grovers_search.py 87 0 14 0 100% +src/braket/experimental/algorithms/qc_qmc/__init__.py 0 0 0 0 100% +src/braket/experimental/algorithms/qc_qmc/classical_qmc.py 131 0 26 0 100% +src/braket/experimental/algorithms/qc_qmc/qc_qmc.py 184 0 50 0 100% +src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/quantum_approximate_optimization/quantum_approximate_optimization.py 47 0 12 0 100% +src/braket/experimental/algorithms/quantum_circuit_born_machine/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/quantum_circuit_born_machine/qcbm.py 80 0 18 0 100% +src/braket/experimental/algorithms/quantum_fourier_transform/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/quantum_fourier_transform/quantum_fourier_transform.py 44 0 18 0 100% +src/braket/experimental/algorithms/quantum_neuron/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py 85 59 26 1 30% 63, 87-94, 111-119, 136-165, 169-209, 220 +src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py 75 0 30 0 100% +src/braket/experimental/algorithms/quantum_walk/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/quantum_walk/quantum_walk.py 61 0 26 0 100% +src/braket/experimental/algorithms/shors/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/shors/shors.py 109 0 48 0 100% +src/braket/experimental/algorithms/simons/__init__.py 1 0 0 0 100% +src/braket/experimental/algorithms/simons/simons.py 55 0 29 0 100% +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +TOTAL 25941 11933 5669 306 48% +Coverage HTML written to dir build/coverage +Coverage XML written to file build/coverage/coverage.xml + +================================================ short test summary info ================================================= +FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination - ... +FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - penn... +================================= 2 failed, 69 passed, 7 xfailed, 40 warnings in 36.31s ================================== +unit-tests: exit 1 (37.55 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket pid=21884 +unit-tests: FAIL ✖ in 40.96 seconds +integ_tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/6/amazon-braket-algorithm-library-1.3.6.dev0.tar.gz +.pkg: _exit> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ + linters: FAIL code 1 (2.38=setup[0.10]+cmd[0.47,0.42,1.38] seconds) + docs: OK (15.16=setup[3.93]+cmd[11.23] seconds) + unit-tests: FAIL code 1 (40.96=setup[3.41]+cmd[37.55] seconds) + integ_tests: OK (3.68 seconds) + evaluation failed :( (62.51 seconds) From ab2b53b29fd17b58f512da9d60f75a5dd5fff66a Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Thu, 13 Jul 2023 04:30:13 +0000 Subject: [PATCH 09/37] install black[jupyter] --- .../quantum_neuron/quantum_neuron.py | 4 +- tox_result.txt | 126 ++++++++++-------- 2 files changed, 74 insertions(+), 56 deletions(-) diff --git a/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py b/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py index 29fe39f9..3921e168 100644 --- a/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py +++ b/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py @@ -150,9 +150,9 @@ def af_circuit(): ### start of post-processing ### # sample = af_circuit() sample = np.array(af_circuit()) - + sample = sample.T - + # sample = (1 - sample.numpy()) / 2 sample = (1 - sample) / 2 diff --git a/tox_result.txt b/tox_result.txt index cc0a8da9..5b9ef52b 100644 --- a/tox_result.txt +++ b/tox_result.txt @@ -4,6 +4,24 @@ Fixing /home/ec2-user/SageMaker/amazon-braket-algorithm-library/test/unit_tests/ Skipped 3 files linters: commands[1]> black ./ linters: commands[2]> flake8 +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:17:1: F401 'time' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:18:1: F401 'typing.List' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:20:1: F401 'matplotlib.pyplot as plt' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:23:1: F401 'braket.aws.AwsQuantumJob' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:23:1: F401 'braket.aws.AwsSession' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:24:1: F401 'braket.jobs.load_job_checkpoint' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:24:1: F401 'braket.jobs.save_job_checkpoint' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:25:1: F401 'braket.jobs.image_uris.Framework' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:25:1: F401 'braket.jobs.image_uris.retrieve_image' imported but unused +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:30:101: E501 line too long (105 > 100 characters) +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:150:5: E266 too many leading '#' for block comment +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:153:1: W293 blank line contains whitespace +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:155:1: W293 blank line contains whitespace +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:167:5: E266 too many leading '#' for block comment +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:175:5: F841 local variable 'input_dir' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:176:5: F841 local variable 'output_dir' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:188:5: F841 local variable 'interface' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:200:9: F841 local variable 'copy_checkpoints_from_job' is assigned to but never used ./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:17:1: F401 'time' imported but unused ./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:18:1: F401 'typing.List' imported but unused ./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:20:1: F401 'matplotlib.pyplot as plt' imported but unused @@ -15,11 +33,11 @@ linters: commands[2]> flake8 ./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:25:1: F401 'braket.jobs.image_uris.retrieve_image' imported but unused ./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:30:101: E501 line too long (105 > 100 characters) ./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:150:5: E266 too many leading '#' for block comment -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:163:5: E266 too many leading '#' for block comment -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:171:5: F841 local variable 'input_dir' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:172:5: F841 local variable 'output_dir' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:184:5: F841 local variable 'interface' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:196:9: F841 local variable 'copy_checkpoints_from_job' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:167:5: E266 too many leading '#' for block comment +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:175:5: F841 local variable 'input_dir' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:176:5: F841 local variable 'output_dir' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:188:5: F841 local variable 'interface' is assigned to but never used +./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:200:9: F841 local variable 'copy_checkpoints_from_job' is assigned to but never used ./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:17:1: F401 'braket.experimental.algorithms.quantum_neuron.quantum_neuron.activation_function' imported but unused ./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:28:28: E226 missing whitespace around arithmetic operator ./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:28:30: E261 at least two spaces before inline comment @@ -48,13 +66,13 @@ linters: commands[2]> flake8 ./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:79:1: W293 blank line contains whitespace ./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:79:9: W292 no newline at end of file ./test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:17:1: F401 'braket.experimental.algorithms.quantum_neuron.quantum_neuron.activation_function' imported but unused -linters: exit 1 (1.38 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> flake8 pid=21482 -linters: FAIL ✖ in 2.38 seconds +linters: exit 1 (1.28 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> flake8 pid=31800 +linters: FAIL ✖ in 2.01 seconds .pkg: _optional_hooks> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ .pkg: get_requires_for_build_sdist> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ .pkg: prepare_metadata_for_build_wheel> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ .pkg: build_sdist> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ -docs: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/4/amazon-braket-algorithm-library-1.3.6.dev0.tar.gz +docs: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/10/amazon-braket-algorithm-library-1.4.1.dev0.tar.gz docs: commands[0]> sphinx-build -E -T -b html doc build/documentation/html Running Sphinx v6.2.1 Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.rst. @@ -190,13 +208,13 @@ copying static files... done copying extra files... done dumping search index in English (code: en)... done dumping object inventory... done -build succeeded, 11 warnings. +build succeeded, 9 warnings. The HTML pages are in build/documentation/html. -docs: OK ✔ in 15.16 seconds -unit-tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/5/amazon-braket-algorithm-library-1.3.6.dev0.tar.gz +docs: OK ✔ in 10.79 seconds +unit-tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/11/amazon-braket-algorithm-library-1.4.1.dev0.tar.gz unit-tests: commands[0]> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket -================================================== test session starts =================================================== +=================================================== test session starts =================================================== platform linux -- Python 3.10.8, pytest-7.3.1, pluggy-1.0.0 -- /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/bin/python cachedir: .tox/unit-tests/.pytest_cache rootdir: /home/ec2-user/SageMaker/amazon-braket-algorithm-library @@ -205,7 +223,7 @@ testpaths: test/unit_tests plugins: rerunfailures-11.1.2, cov-4.1.0, xdist-3.3.1 collecting ... collected 78 items -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet PASSED [ 1%] +test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet PASSED [ 1%] test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet_rotated_zero PASSED [ 2%] test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet_rotated PASSED [ 3%] test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_not_verbose PASSED [ 5%] @@ -224,7 +242,7 @@ test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa. test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_fail_constant_oracle_circuit XFAIL [ 21%] test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_balanced_oracle_circuit PASSED [ 23%] test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_fail_balanced_oracle_circuit XFAIL [ 24%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_dj_circuit PASSED [ 25%] +test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_dj_circuit PASSED [ 25%] test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_get_deutsch_jozsa_results_constant PASSED [ 26%] test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_get_deutsch_jozsa_results_balanced PASSED [ 28%] test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[00] PASSED [ 29%] @@ -233,22 +251,22 @@ test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_searc test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[00000] PASSED [ 33%] test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution_decompose_ccnot[True] PASSED [ 34%] test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution_decompose_ccnot[False] PASSED [ 35%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_properties PASSED [ 37%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_qc_qmc PASSED [ 38%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_q_full_imag_time_evolution PASSED [ 39%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_classical_qmc PASSED [ 41%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_full_imag_time_evolution PASSED [ 42%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_properties PASSED [ 37%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_qc_qmc PASSED [ 38%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_q_full_imag_time_evolution PASSED [ 39%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_classical_qmc PASSED [ 41%] +test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_full_imag_time_evolution PASSED [ 42%] test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa PASSED [ 43%] test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa_evaluate_circuit PASSED [ 44%] test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa_cost_function PASSED [ 46%] -test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_mmd_loss PASSED [ 47%] -test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm PASSED [ 48%] +test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_mmd_loss PASSED [ 47%] +test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm PASSED [ 48%] test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm_no_qubits XFAIL [ 50%] test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm_gradient PASSED [ 51%] test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py::test_qft PASSED [ 52%] test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py::test_inverse_qft PASSED [ 53%] test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination FAILED [ 55%] -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron FAILED [ 56%] +test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron FAILED [ 56%] test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_2_precision_qubits PASSED [ 57%] test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_0_shots PASSED [ 58%] test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_3_precision_qubits PASSED [ 60%] @@ -272,20 +290,20 @@ test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-5--] PASSED [ 83%] test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-6--] PASSED [ 84%] test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-7--] PASSED [ 85%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_value_error_num_nodes XFAIL [ 87%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_run_quantum_walk PASSED [ 88%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_invalid_a_N PASSED [ 89%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_shors_algorithm PASSED [ 91%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_all_valid_a PASSED [ 92%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_no_counts PASSED [ 93%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[00000] PASSED [ 94%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[10110] PASSED [ 96%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_low_shot_number XFAIL [ 97%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_bad_string XFAIL [ 98%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_zero_shot_number XFAIL [100%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_value_error_num_nodes XFAIL [ 87%] +test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_run_quantum_walk PASSED [ 88%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_invalid_a_N PASSED [ 89%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_shors_algorithm PASSED [ 91%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_all_valid_a PASSED [ 92%] +test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_no_counts PASSED [ 93%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[00000] PASSED [ 94%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[10110] PASSED [ 96%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_low_shot_number XFAIL [ 97%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_bad_string XFAIL [ 98%] +test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_zero_shot_number XFAIL [100%] -======================================================== FAILURES ======================================================== -________________________________________________ test_linear_combination _________________________________________________ +======================================================== FAILURES ========================================================= +_________________________________________________ test_linear_combination _________________________________________________ def test_linear_combination(): for n_inputs in range(3, 6): @@ -301,7 +319,7 @@ ________________________________________________ test_linear_combination _______ > dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:36: -_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} @@ -499,9 +517,9 @@ name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} E pennylane._device.DeviceError: Device does not exist. Make sure the required plugin is installed. .tox/unit-tests/lib/python3.10/site-packages/pennylane/__init__.py:338: DeviceError --------------------------------------------------- Captured stdout call -------------------------------------------------- +-------------------------------------------------- Captured stdout call --------------------------------------------------- -__________________________________________________ test_quantum_neuron ___________________________________________________ +___________________________________________________ test_quantum_neuron ___________________________________________________ def test_quantum_neuron(): for n_inputs in range(3, 6): @@ -516,7 +534,7 @@ __________________________________________________ test_quantum_neuron _________ > dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:75: -_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ +_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} @@ -714,9 +732,9 @@ name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} E pennylane._device.DeviceError: Device does not exist. Make sure the required plugin is installed. .tox/unit-tests/lib/python3.10/site-packages/pennylane/__init__.py:338: DeviceError --------------------------------------------------- Captured stdout call -------------------------------------------------- +-------------------------------------------------- Captured stdout call --------------------------------------------------- -==================================================== warnings summary ==================================================== +==================================================== warnings summary ===================================================== .tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:121 test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron @@ -1015,7 +1033,7 @@ src/braket/experimental/algorithms/quantum_circuit_born_machine/qcbm.py src/braket/experimental/algorithms/quantum_fourier_transform/__init__.py 1 0 0 0 100% src/braket/experimental/algorithms/quantum_fourier_transform/quantum_fourier_transform.py 44 0 18 0 100% src/braket/experimental/algorithms/quantum_neuron/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py 85 59 26 1 30% 63, 87-94, 111-119, 136-165, 169-209, 220 +src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py 85 59 26 1 30% 63, 87-94, 111-119, 136-169, 173-213, 224 src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py 1 0 0 0 100% src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py 75 0 30 0 100% src/braket/experimental/algorithms/quantum_walk/__init__.py 1 0 0 0 100% @@ -1029,16 +1047,16 @@ TOTAL Coverage HTML written to dir build/coverage Coverage XML written to file build/coverage/coverage.xml -================================================ short test summary info ================================================= -FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination - ... -FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - penn... -================================= 2 failed, 69 passed, 7 xfailed, 40 warnings in 36.31s ================================== -unit-tests: exit 1 (37.55 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket pid=21884 -unit-tests: FAIL ✖ in 40.96 seconds -integ_tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/6/amazon-braket-algorithm-library-1.3.6.dev0.tar.gz +================================================= short test summary info ================================================= +FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination - p... +FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - penny... +================================== 2 failed, 69 passed, 7 xfailed, 40 warnings in 34.09s ================================== +unit-tests: exit 1 (35.18 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket pid=32164 +unit-tests: FAIL ✖ in 38.53 seconds +integ_tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/12/amazon-braket-algorithm-library-1.4.1.dev0.tar.gz .pkg: _exit> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ - linters: FAIL code 1 (2.38=setup[0.10]+cmd[0.47,0.42,1.38] seconds) - docs: OK (15.16=setup[3.93]+cmd[11.23] seconds) - unit-tests: FAIL code 1 (40.96=setup[3.41]+cmd[37.55] seconds) - integ_tests: OK (3.68 seconds) - evaluation failed :( (62.51 seconds) + linters: FAIL code 1 (2.01=setup[0.05]+cmd[0.28,0.39,1.28] seconds) + docs: OK (10.79=setup[3.45]+cmd[7.34] seconds) + unit-tests: FAIL code 1 (38.53=setup[3.34]+cmd[35.18] seconds) + integ_tests: OK (2.99 seconds) + evaluation failed :( (54.50 seconds) From fcc21d391c068238a3cec0a74d6317998f3c7011 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Fri, 14 Jul 2023 00:00:31 +0000 Subject: [PATCH 10/37] fix style errors --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 21 +++++----- .../textbook/Quantum_Neuron/model.tar.gz | Bin 684 -> 0 bytes .../quantum_neuron/quantum_neuron.py | 36 +++++++----------- .../quantum_neuron/test_quantum_neuron.py | 10 ++--- 4 files changed, 28 insertions(+), 39 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index 611cc2fd..b96a1729 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -327,7 +327,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -337,13 +336,11 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -358,6 +355,7 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -383,6 +381,10 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -390,7 +392,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]]\n" ] } @@ -434,7 +435,7 @@ "output_type": "stream", "text": [ "theta: 1.1272124273195654\n", - "q_theta: 1.342359325028566\n" + "q_theta: 1.4110057479590656\n" ] } ], @@ -515,7 +516,7 @@ " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", " image_uri=image_uri,\n", " entry_point=\"quantum_neuron:main\",\n", - " copy_checkpoints_from_job=None,\n", + " # copy_checkpoints_from_job=None,\n", " hyperparameters=hyperparameters,\n", " wait_until_complete=False\n", ")" @@ -532,7 +533,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "QUEUED\n" + "RUNNING\n" ] } ], @@ -552,7 +553,7 @@ "output_type": "stream", "text": [ "SV1 Task Summary\n", - "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.929, 'billed_execution_duration': 48.0}}\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.793, 'billed_execution_duration': 48.0}}\n", "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with SV1: 0.06 USD\n" ] @@ -661,14 +662,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 17, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz deleted file mode 100644 index 0185c0f4298742a68709c5427f4cc3232c81cd22..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 684 zcmV;d0#p4TiwFP!00000|Lv4fPuoBY$N4BxpP`(6w(s26!NkL+P1@e32?ZL70&O8l z*(TKQKHmkTiPw#75B{Y}6W`hXpX0l}8+NzjFuxwQn}b&(KnOzAgo&5`AWRJqab!t| z(gZ+6K4`*g3Hp`YFt+_c`0ZRT7xxFG{S6*x7kzuvjh`;Bx^;Wjwac!bEt<#Krd@aT z@H9NX-d+sn%XVz%cU?cMhOt|oo2{B=ht2GvSht(v0kgds%D~C$ax`Px|EM9yt8Q%1 zZ_U|Wzl3?k!*~RX#j<-? zU3SO!ce`V2?fc`iwqI{Ilh<&y9S3`|h73;jkSL@dH zQFFPi-x94co_EgMZEs^`H{IQ~tIgPbA7}f2eO5S*<2a7vIF92uj^j9v<2a7vIF92u Sj^jB0A3p*3H print(f"theoritical_z_expected_value: {z_expected_value}") - np.testing.assert_almost_equal(z_expected_value, theoritical_z_expected_value, decimal=2) + np.testing.assert_almost_equal(z_expected_value, + theoritical_z_expected_value, decimal=2) def test_quantum_neuron(): @@ -74,7 +71,8 @@ def test_quantum_neuron(): dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - theta, q_theta = quantum_neuron(inputs_list[input_to_test], weights, bias, n_qubits, dev) + theta, q_theta = quantum_neuron(inputs_list[input_to_test], + weights, bias, n_qubits, dev) print(f"q_theta: {q_theta}") expected_q_theta = np.arctan(np.tan(theta) ** 2) From 55e6728910cf8454f6139c0d28ab4fdc4b40f5fb Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Fri, 14 Jul 2023 00:11:27 +0000 Subject: [PATCH 11/37] fix style errors --- .../quantum_neuron/test_quantum_neuron.py | 7 +- tox_result.txt | 1062 ----------------- 2 files changed, 4 insertions(+), 1065 deletions(-) delete mode 100644 tox_result.txt diff --git a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py index d35f06e8..36fed31a 100644 --- a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py +++ b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py @@ -44,10 +44,11 @@ def lc_circuit(): z_expected_value = lc_circuit() print(f"z_expected_value: {z_expected_value}\n") - theta = ( - np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + theta = ( # linear comination with numpy + np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), + np.array(weights)) + bias - ) # linear comination with numpy + ) theta = theta.item() # Convert numpy array to native python float-type theoritical_z_expected_value = ( diff --git a/tox_result.txt b/tox_result.txt deleted file mode 100644 index 5b9ef52b..00000000 --- a/tox_result.txt +++ /dev/null @@ -1,1062 +0,0 @@ -linters: commands[0]> isort -rc . -Fixing /home/ec2-user/SageMaker/amazon-braket-algorithm-library/test/unit_tests/braket/experimental/algorithms/shors/test_shors.py -Fixing /home/ec2-user/SageMaker/amazon-braket-algorithm-library/test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py -Skipped 3 files -linters: commands[1]> black ./ -linters: commands[2]> flake8 -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:17:1: F401 'time' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:18:1: F401 'typing.List' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:20:1: F401 'matplotlib.pyplot as plt' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:23:1: F401 'braket.aws.AwsQuantumJob' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:23:1: F401 'braket.aws.AwsSession' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:24:1: F401 'braket.jobs.load_job_checkpoint' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:24:1: F401 'braket.jobs.save_job_checkpoint' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:25:1: F401 'braket.jobs.image_uris.Framework' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:25:1: F401 'braket.jobs.image_uris.retrieve_image' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:30:101: E501 line too long (105 > 100 characters) -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:150:5: E266 too many leading '#' for block comment -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:153:1: W293 blank line contains whitespace -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:155:1: W293 blank line contains whitespace -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:167:5: E266 too many leading '#' for block comment -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:175:5: F841 local variable 'input_dir' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:176:5: F841 local variable 'output_dir' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:188:5: F841 local variable 'interface' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/quantum_neuron-checkpoint.py:200:9: F841 local variable 'copy_checkpoints_from_job' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:17:1: F401 'time' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:18:1: F401 'typing.List' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:20:1: F401 'matplotlib.pyplot as plt' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:23:1: F401 'braket.aws.AwsQuantumJob' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:23:1: F401 'braket.aws.AwsSession' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:24:1: F401 'braket.jobs.load_job_checkpoint' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:24:1: F401 'braket.jobs.save_job_checkpoint' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:25:1: F401 'braket.jobs.image_uris.Framework' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:25:1: F401 'braket.jobs.image_uris.retrieve_image' imported but unused -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:30:101: E501 line too long (105 > 100 characters) -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:150:5: E266 too many leading '#' for block comment -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:167:5: E266 too many leading '#' for block comment -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:175:5: F841 local variable 'input_dir' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:176:5: F841 local variable 'output_dir' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:188:5: F841 local variable 'interface' is assigned to but never used -./src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py:200:9: F841 local variable 'copy_checkpoints_from_job' is assigned to but never used -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:17:1: F401 'braket.experimental.algorithms.quantum_neuron.quantum_neuron.activation_function' imported but unused -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:28:28: E226 missing whitespace around arithmetic operator -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:28:30: E261 at least two spaces before inline comment -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:30:58: E226 missing whitespace around arithmetic operator -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:30:60: E226 missing whitespace around arithmetic operator -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:31:31: E261 at least two spaces before inline comment -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:32:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:35:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:42:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:44:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:48:101: E501 line too long (138 > 100 characters) -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:53:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:54:101: E501 line too long (112 > 100 characters) -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:56:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:58:9: E303 too many blank lines (2) -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:59:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:60:1: E302 expected 2 blank lines, found 1 -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:63:28: E226 missing whitespace around arithmetic operator -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:63:30: E261 at least two spaces before inline comment -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:65:58: E226 missing whitespace around arithmetic operator -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:65:60: E226 missing whitespace around arithmetic operator -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:69:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:71:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:74:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:77:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:79:1: W293 blank line contains whitespace -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/.ipynb_checkpoints/test_quantum_neuron-checkpoint.py:79:9: W292 no newline at end of file -./test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:17:1: F401 'braket.experimental.algorithms.quantum_neuron.quantum_neuron.activation_function' imported but unused -linters: exit 1 (1.28 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> flake8 pid=31800 -linters: FAIL ✖ in 2.01 seconds -.pkg: _optional_hooks> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ -.pkg: get_requires_for_build_sdist> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ -.pkg: prepare_metadata_for_build_wheel> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ -.pkg: build_sdist> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ -docs: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/10/amazon-braket-algorithm-library-1.4.1.dev0.tar.gz -docs: commands[0]> sphinx-build -E -T -b html doc build/documentation/html -Running Sphinx v6.2.1 -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bells_inequality.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bells_inequality.bells_inequality.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bernstein_vazirani.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.chsh_inequality.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.chsh_inequality.chsh_inequality.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.deutsch_jozsa.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.grovers_search.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.grovers_search.grovers_search.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.qc_qmc.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.qc_qmc.classical_qmc.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.qc_qmc.qc_qmc.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_approximate_optimization.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.qcbm.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_fourier_transform.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_neuron.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_neuron.quantum_neuron.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_phase_estimation.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_walk.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.quantum_walk.quantum_walk.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.shors.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.shors.shors.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.simons.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/braket.experimental.algorithms.simons.simons.rst. -Creating file /home/ec2-user/SageMaker/amazon-braket-algorithm-library/doc/_apidoc/modules.rst. -building [mo]: targets for 0 po files that are out of date -writing output... -building [html]: targets for 34 source files that are out of date -updating environment: [new config] 34 added, 0 changed, 0 removed -reading sources... [ 2%] _apidoc/braket -reading sources... [ 5%] _apidoc/braket.experimental -reading sources... [ 8%] _apidoc/braket.experimental.algorithms -reading sources... [ 11%] _apidoc/braket.experimental.algorithms.bells_inequality -reading sources... [ 14%] _apidoc/braket.experimental.algorithms.bells_inequality.bells_inequality -reading sources... [ 17%] _apidoc/braket.experimental.algorithms.bernstein_vazirani -reading sources... [ 20%] _apidoc/braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani -reading sources... [ 23%] _apidoc/braket.experimental.algorithms.chsh_inequality -reading sources... [ 26%] _apidoc/braket.experimental.algorithms.chsh_inequality.chsh_inequality -reading sources... [ 29%] _apidoc/braket.experimental.algorithms.deutsch_jozsa -reading sources... [ 32%] _apidoc/braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa -reading sources... [ 35%] _apidoc/braket.experimental.algorithms.grovers_search -reading sources... [ 38%] _apidoc/braket.experimental.algorithms.grovers_search.grovers_search -reading sources... [ 41%] _apidoc/braket.experimental.algorithms.qc_qmc -reading sources... [ 44%] _apidoc/braket.experimental.algorithms.qc_qmc.classical_qmc -reading sources... [ 47%] _apidoc/braket.experimental.algorithms.qc_qmc.qc_qmc -reading sources... [ 50%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization -reading sources... [ 52%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization -reading sources... [ 55%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine -reading sources... [ 58%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.qcbm -reading sources... [ 61%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform -reading sources... [ 64%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform -reading sources... [ 67%] _apidoc/braket.experimental.algorithms.quantum_neuron -reading sources... [ 70%] _apidoc/braket.experimental.algorithms.quantum_neuron.quantum_neuron -reading sources... [ 73%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation -reading sources... [ 76%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation -reading sources... [ 79%] _apidoc/braket.experimental.algorithms.quantum_walk -reading sources... [ 82%] _apidoc/braket.experimental.algorithms.quantum_walk.quantum_walk -reading sources... [ 85%] _apidoc/braket.experimental.algorithms.shors -reading sources... [ 88%] _apidoc/braket.experimental.algorithms.shors.shors -reading sources... [ 91%] _apidoc/braket.experimental.algorithms.simons -reading sources... [ 94%] _apidoc/braket.experimental.algorithms.simons.simons -reading sources... [ 97%] _apidoc/modules -reading sources... [100%] index - -looking for now-outdated files... none found -pickling environment... done -checking consistency... done -preparing documents... done -writing output... [ 2%] _apidoc/braket -writing output... [ 5%] _apidoc/braket.experimental -writing output... [ 8%] _apidoc/braket.experimental.algorithms -writing output... [ 11%] _apidoc/braket.experimental.algorithms.bells_inequality -writing output... [ 14%] _apidoc/braket.experimental.algorithms.bells_inequality.bells_inequality -writing output... [ 17%] _apidoc/braket.experimental.algorithms.bernstein_vazirani -writing output... [ 20%] _apidoc/braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani -writing output... [ 23%] _apidoc/braket.experimental.algorithms.chsh_inequality -writing output... [ 26%] _apidoc/braket.experimental.algorithms.chsh_inequality.chsh_inequality -writing output... [ 29%] _apidoc/braket.experimental.algorithms.deutsch_jozsa -writing output... [ 32%] _apidoc/braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa -writing output... [ 35%] _apidoc/braket.experimental.algorithms.grovers_search -writing output... [ 38%] _apidoc/braket.experimental.algorithms.grovers_search.grovers_search -writing output... [ 41%] _apidoc/braket.experimental.algorithms.qc_qmc -writing output... [ 44%] _apidoc/braket.experimental.algorithms.qc_qmc.classical_qmc -writing output... [ 47%] _apidoc/braket.experimental.algorithms.qc_qmc.qc_qmc -writing output... [ 50%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization -writing output... [ 52%] _apidoc/braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization -writing output... [ 55%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine -writing output... [ 58%] _apidoc/braket.experimental.algorithms.quantum_circuit_born_machine.qcbm -writing output... [ 61%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform -writing output... [ 64%] _apidoc/braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform -writing output... [ 67%] _apidoc/braket.experimental.algorithms.quantum_neuron -writing output... [ 70%] _apidoc/braket.experimental.algorithms.quantum_neuron.quantum_neuron -writing output... [ 73%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation -writing output... [ 76%] _apidoc/braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation -writing output... [ 79%] _apidoc/braket.experimental.algorithms.quantum_walk -writing output... [ 82%] _apidoc/braket.experimental.algorithms.quantum_walk.quantum_walk -writing output... [ 85%] _apidoc/braket.experimental.algorithms.shors -writing output... [ 88%] _apidoc/braket.experimental.algorithms.shors.shors -writing output... [ 91%] _apidoc/braket.experimental.algorithms.simons -writing output... [ 94%] _apidoc/braket.experimental.algorithms.simons.simons -writing output... [ 97%] _apidoc/modules -writing output... [100%] index - -generating indices... genindex py-modindex done -highlighting module code... [ 6%] braket.experimental.algorithms.bells_inequality.bells_inequality -highlighting module code... [ 13%] braket.experimental.algorithms.bernstein_vazirani.bernstein_vazirani -highlighting module code... [ 20%] braket.experimental.algorithms.chsh_inequality.chsh_inequality -highlighting module code... [ 26%] braket.experimental.algorithms.deutsch_jozsa.deutsch_jozsa -highlighting module code... [ 33%] braket.experimental.algorithms.grovers_search.grovers_search -highlighting module code... [ 40%] braket.experimental.algorithms.qc_qmc.classical_qmc -highlighting module code... [ 46%] braket.experimental.algorithms.qc_qmc.qc_qmc -highlighting module code... [ 53%] braket.experimental.algorithms.quantum_approximate_optimization.quantum_approximate_optimization -highlighting module code... [ 60%] braket.experimental.algorithms.quantum_circuit_born_machine.qcbm -highlighting module code... [ 66%] braket.experimental.algorithms.quantum_fourier_transform.quantum_fourier_transform -highlighting module code... [ 73%] braket.experimental.algorithms.quantum_neuron.quantum_neuron -highlighting module code... [ 80%] braket.experimental.algorithms.quantum_phase_estimation.quantum_phase_estimation -highlighting module code... [ 86%] braket.experimental.algorithms.quantum_walk.quantum_walk -highlighting module code... [ 93%] braket.experimental.algorithms.shors.shors -highlighting module code... [100%] braket.experimental.algorithms.simons.simons - -writing additional pages... search done -copying static files... done -copying extra files... done -dumping search index in English (code: en)... done -dumping object inventory... done -build succeeded, 9 warnings. - -The HTML pages are in build/documentation/html. -docs: OK ✔ in 10.79 seconds -unit-tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/11/amazon-braket-algorithm-library-1.4.1.dev0.tar.gz -unit-tests: commands[0]> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket -=================================================== test session starts =================================================== -platform linux -- Python 3.10.8, pytest-7.3.1, pluggy-1.0.0 -- /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/bin/python -cachedir: .tox/unit-tests/.pytest_cache -rootdir: /home/ec2-user/SageMaker/amazon-braket-algorithm-library -configfile: setup.cfg -testpaths: test/unit_tests -plugins: rerunfailures-11.1.2, cov-4.1.0, xdist-3.3.1 -collecting ... collected 78 items - -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet PASSED [ 1%] -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet_rotated_zero PASSED [ 2%] -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_singlet_rotated PASSED [ 3%] -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_not_verbose PASSED [ 5%] -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_shots_0 PASSED [ 6%] -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality_not_violated PASSED [ 7%] -test/unit_tests/braket/experimental/algorithms/bells_inequality/test_bells_inequality.py::test_bell_inequality PASSED [ 8%] -test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani PASSED [ 10%] -test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani_results[100-0] PASSED [ 11%] -test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani_results[11-10] PASSED [ 12%] -test/unit_tests/braket/experimental/algorithms/bernstein_varzirani/test_bernstien_vazirani.py::test_get_bernstein_vazirani_results[10111-50] PASSED [ 14%] -test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_chsh_reduces_to_bell PASSED [ 15%] -test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_chsh_reduces_to_bell_not_verbose PASSED [ 16%] -test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_chsh_no_violation PASSED [ 17%] -test/unit_tests/braket/experimental/algorithms/chsh_inequality/test_chsh_inequality.py::test_max_chsh_violation PASSED [ 19%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_constant_oracle_circuit PASSED [ 20%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_fail_constant_oracle_circuit XFAIL [ 21%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_balanced_oracle_circuit PASSED [ 23%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_fail_balanced_oracle_circuit XFAIL [ 24%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_dj_circuit PASSED [ 25%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_get_deutsch_jozsa_results_constant PASSED [ 26%] -test/unit_tests/braket/experimental/algorithms/deutsch_jozsa/test_deutsch_jozsa.py::test_get_deutsch_jozsa_results_balanced PASSED [ 28%] -test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[00] PASSED [ 29%] -test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[000] PASSED [ 30%] -test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[0000] PASSED [ 32%] -test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution[00000] PASSED [ 33%] -test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution_decompose_ccnot[True] PASSED [ 34%] -test/unit_tests/braket/experimental/algorithms/grovers_search/test_grovers_search.py::test_grovers_search_solution_decompose_ccnot[False] PASSED [ 35%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_properties PASSED [ 37%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_qc_qmc PASSED [ 38%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_q_full_imag_time_evolution PASSED [ 39%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_classical_qmc PASSED [ 41%] -test/unit_tests/braket/experimental/algorithms/qc_qmc/test_qc_qmc.py::test_full_imag_time_evolution PASSED [ 42%] -test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa PASSED [ 43%] -test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa_evaluate_circuit PASSED [ 44%] -test/unit_tests/braket/experimental/algorithms/quantum_approximate_optimization/test_quantum_approximate_optimization.py::test_qaoa_cost_function PASSED [ 46%] -test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_mmd_loss PASSED [ 47%] -test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm PASSED [ 48%] -test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm_no_qubits XFAIL [ 50%] -test/unit_tests/braket/experimental/algorithms/quantum_circuit_born_machine/test_qcbm.py::test_qcbm_gradient PASSED [ 51%] -test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py::test_qft PASSED [ 52%] -test/unit_tests/braket/experimental/algorithms/quantum_fourier_transform/test_quantum_fourier_transform.py::test_inverse_qft PASSED [ 53%] -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination FAILED [ 55%] -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron FAILED [ 56%] -test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_2_precision_qubits PASSED [ 57%] -test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_0_shots PASSED [ 58%] -test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_3_precision_qubits PASSED [ 60%] -test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_HX_eigenstate PASSED [ 61%] -test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_cnot_qpe_run_X_eigenstate PASSED [ 62%] -test/unit_tests/braket/experimental/algorithms/quantum_phase_estimation/test_quantum_phase_estimation.py::test_inverse_qft PASSED [ 64%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_quantum_walk_4_nodes_4_steps PASSED [ 65%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-0-+] PASSED [ 66%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-1-+] PASSED [ 67%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-2-+] PASSED [ 69%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-3-+] PASSED [ 70%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-4-+] PASSED [ 71%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-5-+] PASSED [ 73%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-6-+] PASSED [ 74%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-7-+] PASSED [ 75%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-0--] PASSED [ 76%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-1--] PASSED [ 78%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-2--] PASSED [ 79%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-3--] PASSED [ 80%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-4--] PASSED [ 82%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-5--] PASSED [ 83%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-6--] PASSED [ 84%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_qft_conditional_add_1[3-7--] PASSED [ 85%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_value_error_num_nodes XFAIL [ 87%] -test/unit_tests/braket/experimental/algorithms/quantum_walk/test_quantum_walk.py::test_run_quantum_walk PASSED [ 88%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_invalid_a_N PASSED [ 89%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_shors_algorithm PASSED [ 91%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_all_valid_a PASSED [ 92%] -test/unit_tests/braket/experimental/algorithms/shors/test_shors.py::test_no_counts PASSED [ 93%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[00000] PASSED [ 94%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_simons_algorithm[10110] PASSED [ 96%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_low_shot_number XFAIL [ 97%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_bad_string XFAIL [ 98%] -test/unit_tests/braket/experimental/algorithms/simons/test_simons.py::test_zero_shot_number XFAIL [100%] - -======================================================== FAILURES ========================================================= -_________________________________________________ test_linear_combination _________________________________________________ - - def test_linear_combination(): - for n_inputs in range(3, 6): - print() - n_qubits = n_inputs + 2 # +2: ancilla and output qubit - bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) - ancilla = len(weights) # ID of an ancilla qubit - - inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] - input_to_test = 5 # I picked this at random. - -> dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:36: -_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ - -name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} - - def device(name, *args, **kwargs): - r"""device(name, wires=1, *args, **kwargs) - Load a :class:`~.Device` and return the instance. - - This function is used to load a particular quantum device, - which can then be used to construct QNodes. - - PennyLane comes with support for the following devices: - - * :mod:`'default.qubit' `: a simple - state simulator of qubit-based quantum circuit architectures. - - * :mod:`'default.gaussian' `: a simple simulator - of Gaussian states and operations on continuous-variable circuit architectures. - - * :mod:`'default.qubit.tf' `: a state simulator - of qubit-based quantum circuit architectures written in TensorFlow, which allows - automatic differentiation through the simulation. - - * :mod:`'default.qubit.autograd' `: a state simulator - of qubit-based quantum circuit architectures which allows - automatic differentiation through the simulation via python's autograd library. - - Additional devices are supported through plugins — see - the `available plugins `_ for more - details. - - Args: - name (str): the name of the device to load - wires (int): the number of wires (subsystems) to initialise - the device with - - Keyword Args: - config (pennylane.Configuration): a PennyLane configuration object - that contains global and/or device specific configurations. - custom_decomps (Dict[Union(str, qml.Operator), Callable]): Custom - decompositions to be applied by the device at runtime. - decomp_depth (int): For when custom decompositions are specified, - the maximum expansion depth used by the expansion function. - - All devices must be loaded by specifying their **short-name** as listed above, - followed by the **wires** (subsystems) you wish to initialize. The *wires* - argument can be an integer, in which case the wires of the device are addressed - by consecutive integers: - - .. code-block:: python - - dev = qml.device('default.qubit', wires=5) - - def circuit(): - qml.Hadamard(wires=1) - qml.Hadamard(wires=[0]) - qml.CNOT(wires=[3, 4]) - ... - - The *wires* argument can also be a sequence of unique numbers or strings, specifying custom wire labels - that the user employs to address the wires: - - .. code-block:: python - - dev = qml.device('default.qubit', wires=['ancilla', 'q11', 'q12', -1, 1]) - - def circuit(): - qml.Hadamard(wires='q11') - qml.Hadamard(wires=['ancilla']) - qml.CNOT(wires=['q12', -1]) - ... - - Most devices accept a ``shots`` argument which specifies how many circuit executions - are used to estimate stochastic return values. In particular, ``qml.sample()`` measurements - will return as many samples as specified in the shots argument. The shots argument can be - changed on a per-call basis using the built-in ``shots`` keyword argument. - - .. code-block:: python - - dev = qml.device('default.qubit', wires=1, shots=10) - - @qml.qnode(dev) - def circuit(a): - qml.RX(a, wires=0) - return qml.sample(qml.PauliZ(wires=0)) - - >>> circuit(0.8) # 10 samples are returned - [ 1 1 1 -1 -1 1 1 1 1 1] - >>> circuit(0.8, shots=3) # default is overwritten for this call - [1 1 1] - >>> circuit(0.8) # back to default of 10 samples - [ 1 1 1 -1 -1 1 1 1 1 1] - - When constructing a device, we may optionally pass a dictionary of custom - decompositions to be applied to certain operations upon device execution. - This is useful for enabling support of gates on devices where they would normally - be unsupported. - - For example, suppose we are running on an ion trap device which does not - natively implement the CNOT gate, but we would still like to write our - circuits in terms of CNOTs. On a ion trap device, CNOT can be implemented - using the ``IsingXX`` gate. We first define a decomposition function - (such functions have the signature ``decomposition(*params, wires)``): - - .. code-block:: python - - def ion_trap_cnot(wires): - return [ - qml.RY(np.pi/2, wires=wires[0]), - qml.IsingXX(np.pi/2, wires=wires), - qml.RX(-np.pi/2, wires=wires[0]), - qml.RY(-np.pi/2, wires=wires[0]), - qml.RY(-np.pi/2, wires=wires[1]) - ] - - Next, we create a device, and a QNode for testing. When constructing the - QNode, we can set the expansion strategy to ``"device"`` to ensure the - decomposition is applied and will be viewable when we draw the circuit. - - .. code-block:: python - - # As the CNOT gate normally has no decomposition, we can use default.qubit - # here for expository purposes. - dev = qml.device( - 'default.qubit', wires=2, custom_decomps={"CNOT" : ion_trap_cnot} - ) - - @qml.qnode(dev, expansion_strategy="device") - def run_cnot(): - qml.CNOT(wires=[0, 1]) - return qml.expval(qml.PauliX(wires=1)) - - >>> print(qml.draw(run_cnot)()) - 0: ──RY(1.57)─╭IsingXX(1.57)──RX(-1.57)──RY(-1.57)─┤ - 1: ───────────╰IsingXX(1.57)──RY(-1.57)────────────┤ - - Some devices may accept additional arguments. For instance, - ``default.gaussian`` accepts the keyword argument ``hbar``, to set - the convention used in the commutation relation :math:`[\x,\p]=i\hbar` - (by default set to 2). - - Please refer to the documentation for the individual devices to see any - additional arguments that might be required or supported. - """ - if name not in plugin_devices: - # Device does not exist in the loaded device list. - # Attempt to refresh the devices, in case the user - # installed the plugin during the current Python session. - refresh_devices() - - if name in plugin_devices: - options = {} - - # load global configuration settings if available - config = kwargs.get("config", default_config) - - if config: - # combine configuration options with keyword arguments. - # Keyword arguments take preference, followed by device options, - # followed by plugin options, followed by global options. - options.update(config["main"]) - options.update(config[name.split(".")[0] + ".global"]) - options.update(config[name]) - - # Pop the custom decomposition keyword argument; we will use it here - # only and not pass it to the device. - custom_decomps = kwargs.pop("custom_decomps", None) - decomp_depth = kwargs.pop("decomp_depth", 10) - - kwargs.pop("config", None) - options.update(kwargs) - - # loads the device class - plugin_device_class = plugin_devices[name].load() - - if Version(version()) not in SimpleSpec(plugin_device_class.pennylane_requires): - raise DeviceError( - f"The {name} plugin requires PennyLane versions {plugin_device_class.pennylane_requires}, " - f"however PennyLane version {__version__} is installed." - ) - - # Construct the device - dev = plugin_device_class(*args, **options) - - # Once the device is constructed, we set its custom expansion function if - # any custom decompositions were specified. - if custom_decomps is not None: - custom_decomp_expand_fn = pennylane.transforms.create_decomp_expand_fn( - custom_decomps, dev, decomp_depth=decomp_depth - ) - dev.custom_expand(custom_decomp_expand_fn) - - return dev - -> raise DeviceError("Device does not exist. Make sure the required plugin is installed.") -E pennylane._device.DeviceError: Device does not exist. Make sure the required plugin is installed. - -.tox/unit-tests/lib/python3.10/site-packages/pennylane/__init__.py:338: DeviceError --------------------------------------------------- Captured stdout call --------------------------------------------------- - -___________________________________________________ test_quantum_neuron ___________________________________________________ - - def test_quantum_neuron(): - for n_inputs in range(3, 6): - print() - n_qubits = n_inputs + 2 # +2: ancilla and output qubit - bias = 0.05 # constant - weights = generate_random_numbers(n_inputs, np.pi / 2 - bias) - - inputs_list = [format(i, f"0{n_inputs}b") for i in range(2**n_inputs)] - input_to_test = 5 # I picked this at random. - -> dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py:75: -_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ - -name = 'braket.local.qubit', args = (), kwargs = {'shots': 100000, 'wires': 5} - - def device(name, *args, **kwargs): - r"""device(name, wires=1, *args, **kwargs) - Load a :class:`~.Device` and return the instance. - - This function is used to load a particular quantum device, - which can then be used to construct QNodes. - - PennyLane comes with support for the following devices: - - * :mod:`'default.qubit' `: a simple - state simulator of qubit-based quantum circuit architectures. - - * :mod:`'default.gaussian' `: a simple simulator - of Gaussian states and operations on continuous-variable circuit architectures. - - * :mod:`'default.qubit.tf' `: a state simulator - of qubit-based quantum circuit architectures written in TensorFlow, which allows - automatic differentiation through the simulation. - - * :mod:`'default.qubit.autograd' `: a state simulator - of qubit-based quantum circuit architectures which allows - automatic differentiation through the simulation via python's autograd library. - - Additional devices are supported through plugins — see - the `available plugins `_ for more - details. - - Args: - name (str): the name of the device to load - wires (int): the number of wires (subsystems) to initialise - the device with - - Keyword Args: - config (pennylane.Configuration): a PennyLane configuration object - that contains global and/or device specific configurations. - custom_decomps (Dict[Union(str, qml.Operator), Callable]): Custom - decompositions to be applied by the device at runtime. - decomp_depth (int): For when custom decompositions are specified, - the maximum expansion depth used by the expansion function. - - All devices must be loaded by specifying their **short-name** as listed above, - followed by the **wires** (subsystems) you wish to initialize. The *wires* - argument can be an integer, in which case the wires of the device are addressed - by consecutive integers: - - .. code-block:: python - - dev = qml.device('default.qubit', wires=5) - - def circuit(): - qml.Hadamard(wires=1) - qml.Hadamard(wires=[0]) - qml.CNOT(wires=[3, 4]) - ... - - The *wires* argument can also be a sequence of unique numbers or strings, specifying custom wire labels - that the user employs to address the wires: - - .. code-block:: python - - dev = qml.device('default.qubit', wires=['ancilla', 'q11', 'q12', -1, 1]) - - def circuit(): - qml.Hadamard(wires='q11') - qml.Hadamard(wires=['ancilla']) - qml.CNOT(wires=['q12', -1]) - ... - - Most devices accept a ``shots`` argument which specifies how many circuit executions - are used to estimate stochastic return values. In particular, ``qml.sample()`` measurements - will return as many samples as specified in the shots argument. The shots argument can be - changed on a per-call basis using the built-in ``shots`` keyword argument. - - .. code-block:: python - - dev = qml.device('default.qubit', wires=1, shots=10) - - @qml.qnode(dev) - def circuit(a): - qml.RX(a, wires=0) - return qml.sample(qml.PauliZ(wires=0)) - - >>> circuit(0.8) # 10 samples are returned - [ 1 1 1 -1 -1 1 1 1 1 1] - >>> circuit(0.8, shots=3) # default is overwritten for this call - [1 1 1] - >>> circuit(0.8) # back to default of 10 samples - [ 1 1 1 -1 -1 1 1 1 1 1] - - When constructing a device, we may optionally pass a dictionary of custom - decompositions to be applied to certain operations upon device execution. - This is useful for enabling support of gates on devices where they would normally - be unsupported. - - For example, suppose we are running on an ion trap device which does not - natively implement the CNOT gate, but we would still like to write our - circuits in terms of CNOTs. On a ion trap device, CNOT can be implemented - using the ``IsingXX`` gate. We first define a decomposition function - (such functions have the signature ``decomposition(*params, wires)``): - - .. code-block:: python - - def ion_trap_cnot(wires): - return [ - qml.RY(np.pi/2, wires=wires[0]), - qml.IsingXX(np.pi/2, wires=wires), - qml.RX(-np.pi/2, wires=wires[0]), - qml.RY(-np.pi/2, wires=wires[0]), - qml.RY(-np.pi/2, wires=wires[1]) - ] - - Next, we create a device, and a QNode for testing. When constructing the - QNode, we can set the expansion strategy to ``"device"`` to ensure the - decomposition is applied and will be viewable when we draw the circuit. - - .. code-block:: python - - # As the CNOT gate normally has no decomposition, we can use default.qubit - # here for expository purposes. - dev = qml.device( - 'default.qubit', wires=2, custom_decomps={"CNOT" : ion_trap_cnot} - ) - - @qml.qnode(dev, expansion_strategy="device") - def run_cnot(): - qml.CNOT(wires=[0, 1]) - return qml.expval(qml.PauliX(wires=1)) - - >>> print(qml.draw(run_cnot)()) - 0: ──RY(1.57)─╭IsingXX(1.57)──RX(-1.57)──RY(-1.57)─┤ - 1: ───────────╰IsingXX(1.57)──RY(-1.57)────────────┤ - - Some devices may accept additional arguments. For instance, - ``default.gaussian`` accepts the keyword argument ``hbar``, to set - the convention used in the commutation relation :math:`[\x,\p]=i\hbar` - (by default set to 2). - - Please refer to the documentation for the individual devices to see any - additional arguments that might be required or supported. - """ - if name not in plugin_devices: - # Device does not exist in the loaded device list. - # Attempt to refresh the devices, in case the user - # installed the plugin during the current Python session. - refresh_devices() - - if name in plugin_devices: - options = {} - - # load global configuration settings if available - config = kwargs.get("config", default_config) - - if config: - # combine configuration options with keyword arguments. - # Keyword arguments take preference, followed by device options, - # followed by plugin options, followed by global options. - options.update(config["main"]) - options.update(config[name.split(".")[0] + ".global"]) - options.update(config[name]) - - # Pop the custom decomposition keyword argument; we will use it here - # only and not pass it to the device. - custom_decomps = kwargs.pop("custom_decomps", None) - decomp_depth = kwargs.pop("decomp_depth", 10) - - kwargs.pop("config", None) - options.update(kwargs) - - # loads the device class - plugin_device_class = plugin_devices[name].load() - - if Version(version()) not in SimpleSpec(plugin_device_class.pennylane_requires): - raise DeviceError( - f"The {name} plugin requires PennyLane versions {plugin_device_class.pennylane_requires}, " - f"however PennyLane version {__version__} is installed." - ) - - # Construct the device - dev = plugin_device_class(*args, **options) - - # Once the device is constructed, we set its custom expansion function if - # any custom decompositions were specified. - if custom_decomps is not None: - custom_decomp_expand_fn = pennylane.transforms.create_decomp_expand_fn( - custom_decomps, dev, decomp_depth=decomp_depth - ) - dev.custom_expand(custom_decomp_expand_fn) - - return dev - -> raise DeviceError("Device does not exist. Make sure the required plugin is installed.") -E pennylane._device.DeviceError: Device does not exist. Make sure the required plugin is installed. - -.tox/unit-tests/lib/python3.10/site-packages/pennylane/__init__.py:338: DeviceError --------------------------------------------------- Captured stdout call --------------------------------------------------- - -==================================================== warnings summary ===================================================== -.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:121 -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:121: DeprecationWarning: pkg_resources is deprecated as an API - warnings.warn("pkg_resources is deprecated as an API", DeprecationWarning) - -.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: 4 warnings -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py: 8 warnings - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google')`. - Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages - declare_namespace(pkg) - -.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870 -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google.logging')`. - Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages - declare_namespace(pkg) - -.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2349 -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2349: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google')`. - Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages - declare_namespace(parent) - -.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870 -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('mpl_toolkits')`. - Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages - declare_namespace(pkg) - -.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: 5 warnings -test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py: 10 warnings - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/pkg_resources/__init__.py:2870: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('sphinxcontrib')`. - Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages - declare_namespace(pkg) - -.tox/unit-tests/lib/python3.10/site-packages/openfermion/hamiltonians/hartree_fock.py:11 - /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/unit-tests/lib/python3.10/site-packages/openfermion/hamiltonians/hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated. - from scipy.optimize.optimize import OptimizeResult - --- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html - ----------- coverage: platform linux, python 3.10.8-final-0 ----------- -Name Stmts Miss Branch BrPart Cover Missing ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -.tox/unit-tests/lib/python3.10/site-packages/braket/_schemas/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/_schemas/_version.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/_sdk/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/_sdk/_version.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/__init__.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/analog_hamiltonian_simulation.py 50 21 6 0 52% 40-41, 46, 51, 60, 66, 72-76, 95-108, 117, 122, 135 -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/atom_arrangement.py 50 25 16 0 41% 40-44, 47-49, 52-53, 61, 78-79, 94, 97, 100, 114-124 -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/discretization_types.py 8 0 2 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/driving_field.py 49 29 4 0 38% 62-65, 69, 74, 79, 84, 108-112, 124-138, 160-179 -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/field.py 25 12 4 0 45% 32-33, 38, 43, 66-76 -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/hamiltonian.py 22 12 4 0 38% 30, 35, 47-48, 51-54, 57-60 -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/pattern.py 13 4 2 0 60% 29, 35, 48-49 -.tox/unit-tests/lib/python3.10/site-packages/braket/ahs/shifting_field.py 35 18 6 0 41% 50-51, 55, 62, 76-84, 134-138, 150-156 -.tox/unit-tests/lib/python3.10/site-packages/braket/annealing/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/annealing/problem.py 35 15 2 0 54% 60-62, 71, 80, 90, 102-103, 114-115, 127-128, 139-140, 148 -.tox/unit-tests/lib/python3.10/site-packages/braket/aws/__init__.py 5 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_device.py 198 129 52 0 28% 81-89, 162, 244, 269, 272-273, 280-290, 295-314, 317-331, 336, 341, 345, 350, 358-410, 420, 440-442, 451-470, 474, 480, 483, 486-488, 494-495, 501-502, 540-582, 585-600, 618-621 -.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_quantum_job.py 196 134 46 0 26% 176-205, 215-224, 231-232, 244-246, 251, 256, 273, 312-347, 360-362, 387-396, 407-408, 431-441, 445-453, 479-497, 503-518, 522-523, 526, 529-531, 534, 540-544, 554-563, 571-593 -.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_quantum_task.py 251 162 57 0 29% 159-182, 225-235, 247-249, 254, 258-262, 266-267, 284-286, 304, 307-314, 319-321, 342-354, 357-371, 378, 389, 409-432, 439-453, 456, 459-461, 464, 479, 494-496, 511-534, 549-551, 566-610, 630-639, 654-656, 662-675, 691-712, 722, 734, 739-740, 745, 750, 757 -.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_quantum_task_batch.py 131 96 72 0 17% 95-124, 143-179, 203-237, 254-274, 301-316, 320-322, 334-362, 367, 372, 380-389, 394 -.tox/unit-tests/lib/python3.10/site-packages/braket/aws/aws_session.py 249 181 78 0 21% 54-91, 95, 99, 108-110, 119-121, 130-132, 141-143, 152-154, 164-175, 188-190, 194, 206-207, 221-233, 245-246, 250, 276-278, 294-299, 321, 333, 346-348, 357-358, 387-401, 411-412, 423-429, 450-459, 480-492, 507-514, 531-589, 601, 625-642, 653-657, 674-685, 702-704, 727-739, 764-774, 792-821 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/__init__.py 19 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/angled_gate.py 76 25 12 1 61% 57, 94, 102-110, 120, 153-156, 175, 185, 195, 210, 218, 221, 229, 244, 279, 317-325 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/ascii_circuit_diagram.py 138 17 74 10 86% 45, 71->79, 89, 93, 121, 129, 173, 246-254, 257, 291 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/basis_state.py 40 11 10 1 60% 13, 21, 25, 41, 50-55, 60-67 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/circuit.py 426 154 227 29 56% 149, 180-195, 201, 285, 290-295, 297->317, 306->314, 326, 353, 355->339, 363-366, 370, 446, 454-459, 549, 559, 615-631, 742-775, 824-844, 862, 877-882, 924, 975-1004, 1060, 1077, 1118, 1123, 1129, 1132-1138, 1184, 1191-1192, 1199, 1209-1214, 1219-1225, 1261-1272, 1303-1306, 1316, 1328-1331, 1345, 1348, 1359, 1372, 1385-1391, 1419->1421 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/circuit_diagram.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/circuit_helpers.py 16 5 16 6 66% 32, 34, 39, 42, 43->40, 46 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/compiler_directive.py 32 15 6 0 45% 35-37, 41, 46, 71-76, 80, 84, 95, 100, 103 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/compiler_directives.py 21 8 0 0 62% 27, 30, 33, 36, 46, 49, 52, 55 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/free_parameter.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/free_parameter_expression.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/gate.py 56 18 16 4 61% 56, 66, 107-109, 114, 126, 138, 172-187 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/gates.py 838 251 58 0 67% 75, 78, 137, 140, 143, 202, 205, 208, 260, 264, 267, 270, 273, 277, 310, 332, 335, 338, 390, 394, 397, 400, 403, 407, 440, 455, 459, 462, 465, 468, 472, 505, 530, 533, 595, 598, 650, 654, 657, 660, 663, 667, 700, 715, 719, 722, 725, 728, 732, 765, 798, 805-807, 867, 875, 878, 885-887, 891, 894, 928, 958, 961, 1023, 1031, 1034, 1037, 1040, 1044, 1078, 1110, 1113, 1167, 1170, 1173, 1235, 1239, 1242, 1245, 1248, 1260, 1294, 1314, 1325, 1328, 1331, 1342, 1346, 1382, 1404, 1415, 1418, 1425-1427, 1438, 1442, 1478, 1509, 1512, 1515, 1567, 1575, 1578, 1581, 1584, 1588, 1615-1617, 1647, 1650, 1653, 1705, 1713, 1716, 1719, 1722, 1726, 1753-1755, 1770, 1774, 1777, 1780, 1783, 1795, 1816-1818, 1830, 1834, 1837, 1840, 1843, 1855, 1876-1878, 1890, 1894, 1897, 1900, 1903, 1907, 1928-1930, 1942, 1946, 1949, 1952, 1955, 1966, 2000, 2022, 2033, 2036, 2043-2045, 2056, 2060, 2096, 2118, 2129, 2132, 2139-2141, 2152, 2156, 2192, 2214, 2225, 2228, 2231, 2242, 2246, 2282, 2311, 2314, 2391, 2394, 2397, 2461, 2469, 2472, 2480, 2484, 2487, 2521, 2540, 2548, 2551, 2559, 2563, 2566, 2600, 2624, 2633, 2636, 2646, 2650, 2653, 2691, 2720-2727, 2730, 2733, 2736, 2744-2752, 2755-2757, 2761, 2787-2790, 2808-2814, 2819, 2824, 2834-2835, 2838, 2843-2848, 2888, 2910-2920 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/instruction.py 77 16 24 8 72% 87, 91, 128, 160-162, 185-186, 188, 256, 258, 296, 299-302 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/moments.py 132 35 36 7 69% 130, 181, 188-191, 193, 222-231, 252, 254, 259, 266, 282, 286, 307, 310, 313, 316, 319, 322-324, 327-330, 333, 336 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/noise.py 217 124 56 0 34% 54, 64, 88-102, 114, 130, 138, 141-143, 146, 159-163, 202-206, 214, 217, 220, 232, 235-237, 250, 260, 294, 328, 375-396, 407-417, 425, 431, 434-436, 444, 458, 473, 483-486, 527-535, 550-554, 562, 570, 578, 581, 591, 594-596, 610, 623, 633, 671-675, 683, 686, 689, 701, 704-706, 719, 729, 769-773, 781, 784, 791, 805, 808-814, 824, 843-846, 859-861 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/noise_helpers.py 97 79 66 0 11% 37-38, 53-55, 68-80, 96-100, 114-125, 150-180, 213-232, 268-322 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/noises.py 356 182 58 0 43% 81, 88, 93-94, 101-103, 107, 124, 137, 150, 184, 191, 196-197, 204-206, 210, 227, 240, 253, 314, 323, 330-331, 341-345, 349, 372, 385-389, 402, 458, 465, 470-471, 478-482, 486, 503, 516, 529, 584, 591, 598-600, 611-623, 627, 647, 661, 674, 711, 718, 725-727, 737-744, 748, 768, 780, 793, 867-875, 882-895, 898, 904, 924, 939-943, 956-959, 991, 998, 1003-1004, 1011-1013, 1017, 1034, 1047, 1060, 1110, 1118, 1125-1126, 1136-1144, 1148, 1168, 1184-1186, 1199, 1236, 1243, 1248-1249, 1256-1258, 1262, 1279, 1291, 1304, 1328-1345, 1352, 1355, 1363-1374, 1378-1384, 1406-1411, 1422, 1435, 1454-1460, 1464, 1477-1479 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/observable.py 81 26 18 5 63% 45, 72, 77, 85, 89, 105, 121, 129, 143, 158, 162-166, 169, 172-175, 178-181, 189, 203, 207, 210 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/observables.py 337 182 126 3 38% 44, 47, 50-52, 57-62, 65, 71, 88, 91-93, 98-103, 106, 110, 118, 121, 135, 138, 141-143, 148-153, 156, 160, 174, 177, 180-182, 187-192, 195, 199, 219-221, 231, 238, 272-275, 277, 306-308, 311-316, 344, 354-357, 365-369, 383-398, 404, 408-425, 447-457, 461-466, 469, 476-486, 498, 501, 505, 509, 512, 515, 518, 522, 549-561, 564, 567-569, 576-586, 589-592, 595, 598, 602, 610, 613, 633-641, 644-645, 662-666, 670-687 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/operator.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/parameterizable.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/quantum_operator.py 47 16 14 5 62% 56, 63, 66, 69, 72-76, 101, 119, 127, 140-145, 148 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/quantum_operator_helpers.py 28 18 8 0 28% 32-39, 58, 71, 91, 107-108, 123-131 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/qubit.py 20 3 6 2 81% 41, 43, 50 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/qubit_set.py 19 0 8 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/result_type.py 98 37 38 8 51% 48, 90, 95, 101, 105, 118, 154-162, 174, 212-213, 218-226, 231, 236, 254, 257-263, 269, 293-301, 322, 325, 331 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/result_types.py 192 74 49 1 52% 50, 53, 56, 69, 72-74, 77, 82, 104-106, 110, 118, 121-125, 128-133, 150, 153-155, 158, 161, 166, 213-218, 226-234, 268, 294-306, 310, 313, 316-317, 333, 336-338, 341, 344, 347, 388, 391-395, 426, 432, 479-484, 547, 554-559, 562-567, 586, 623, 630-635, 638-643, 662 -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/serialization.py 15 0 2 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/circuits/unitary_calculation.py 44 34 20 0 16% 26-38, 67-93, 121-140 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/__init__.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/_version.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/density_matrix_simulation.py 73 46 24 0 28% 38-42, 45, 61-69, 88-108, 111, 123, 133-135, 138-141, 149, 161-166, 187-194, 211-213, 233-243 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/density_matrix_simulator.py 16 7 0 0 56% 38-40, 44-47 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/gate_operations.py 502 140 0 0 72% 53, 77, 101, 108, 116, 120, 125, 149, 156, 164, 175, 180, 204, 211, 219, 223, 228, 235, 243, 247, 252, 259, 267, 278, 283, 290, 298, 302, 307, 314, 322, 326, 331, 355, 379, 386, 394, 398, 403, 410, 418, 422, 427, 434-439, 443, 447, 452, 477, 484-489, 493, 497, 502, 527, 534-539, 543, 547, 552, 579, 586-591, 595-597, 601, 606, 633, 657, 664, 672, 684, 689, 696-701, 705, 717, 722, 732-737, 741-743, 755, 760, 770-775, 779-781, 792, 797, 807-812, 816-818, 829, 834, 844-849, 853-855, 866, 871, 907, 943, 954-959, 963, 972, 983-988, 992, 1001, 1012-1018, 1022, 1033, 1040-1048, 1052, 1056, 1061, 1083-1090, 1101, 1116, 1125-1128, 1132, 1136 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/linalg_utils.py 46 17 16 1 55% 51-58, 144-156 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/noise_operations.py 202 104 16 0 46% 35-36, 40-42, 46, 51, 58-59, 63-65, 69, 74, 81-84, 88-94, 98, 103, 112-113, 117-123, 127, 132, 139-140, 144-156, 160, 165, 172-173, 177-184, 188, 193, 200-201, 205-207, 211, 216, 223-225, 229-239, 243, 248, 257-258, 262-264, 268, 273, 282-287, 291, 295, 300, 318-332, 336, 340, 345 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/observables.py 211 82 50 3 53% 43, 46, 50, 54, 58, 61, 64, 67, 88-90, 94, 111, 115, 119, 122, 125-127, 131, 145, 149, 153, 156, 159-161, 165, 182, 186, 190, 193, 196-198, 202, 233, 236, 240, 250-262, 265, 270, 274, 278, 281, 284-288, 291-293, 296, 315-322, 337, 346, 350, 354, 362, 371, 374, 382-397, 409 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/arrays.py 91 66 52 3 20% 29-37, 42-46, 51, 56, 58, 66-77, 85-90, 97, 102-105, 110, 119-131, 143-170, 181-195 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/casting.py 100 57 51 1 29% 33-41, 52-62, 68-81, 87-97, 103-109, 115-125, 143, 150, 156, 169, 175, 180, 185, 190, 195, 200 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/functions.py 26 8 8 2 65% 138->exit, 174, 181-185, 193, 199 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/_helpers/quantum.py 38 29 22 0 15% 17-19, 28-30, 38-41, 46-54, 68, 77, 88-96 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/circuit.py 66 31 40 4 41% 33-34, 37-38, 72-90, 94-108, 111-112, 117 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/interpreter.py 382 225 168 19 35% 114, 117-118, 124, 134-135, 141, 162-163, 165, 169, 174-181, 185-189, 193-198, 206, 210, 221, 223, 233, 242-243, 247, 252, 257-261, 266-275, 279-288, 291-339, 347, 352, 363-384, 396-424, 428-436, 440-447, 459-473, 477, 481-485, 489-501, 505-507, 511-515, 523, 525-533, 537-546, 550-590, 594-595, 599-602, 621 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/braket_pragmas.py 123 54 31 1 51% 45-49, 78-83, 87-88, 110, 117-118, 133-137, 149-157, 162-170, 175-177, 180-181, 184-188, 191-205, 208-210, 213 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/BraketPragmasLexer.py 886 1 6 1 99% 8 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/BraketPragmasParser.py 6458 4128 1280 37 31% 9, 833, 837, 841, 845, 849, 852-853, 856-857, 863, 882-904, 914-915, 918, 921, 924, 927, 931, 934, 938, 941-942, 945-946, 949-952, 959-981, 988-989, 992, 995, 998, 1001-1002, 1005-1006, 1009-1012, 1019-1033, 1040-1041, 1044, 1047-1050, 1054, 1057-1060, 1063, 1066-1067, 1070-1071, 1074-1077, 1084-1113, 1120-1121, 1124, 1127-1130, 1134, 1137-1140, 1143, 1146-1147, 1150-1151, 1154-1157, 1164-1193, 1204, 1207, 1210, 1214, 1217-1218, 1221-1222, 1228, 1245-1248, 1262, 1266, 1270, 1274, 1278, 1281-1282, 1285-1286, 1292, 1306-1309, 1316-1319, 1326-1331, 1341-1342, 1345, 1349, 1352-1353, 1356-1357, 1360-1363, 1370-1382, 1389-1390, 1393, 1396, 1399-1400, 1403-1404, 1407-1410, 1417-1429, 1448, 1451-1452, 1455-1456, 1462, 1479->1489, 1484-1487, 1501, 1504, 1507, 1510-1511, 1514-1515, 1518-1521, 1536, 1540-1543, 1558, 1573, 1576-1577, 1580-1581, 1587, 1597-1600, 1603-1606, 1609-1610, 1613-1614, 1620, 1658-1663, 1673-1674, 1677, 1681, 1685, 1688-1689, 1692-1693, 1696-1699, 1706-1720, 1727-1728, 1731, 1734, 1737-1738, 1741-1742, 1745-1748, 1755-1767, 1774-1775, 1778-1781, 1784-1787, 1790, 1793-1794, 1797-1798, 1801-1804, 1811-1836, 1855, 1858-1859, 1862-1863, 1869, 1884-1887, 1901, 1905, 1909, 1913, 1916-1917, 1920-1921, 1927, 1952-1962, 1977, 1988-1989, 1992, 1995, 1998-1999, 2002-2003, 2006-2009, 2022, 2027, 2030-2031, 2034-2035, 2041, 2066-2079, 2093, 2096, 2100, 2104, 2108, 2111-2112, 2115-2116, 2122, 2140-2145, 2151-2154, 2164-2165, 2168, 2171, 2174, 2178, 2181, 2185, 2188-2189, 2192-2193, 2196-2199, 2206-2226, 2237, 2240, 2243, 2246, 2249-2250, 2253-2254, 2257-2260, 2275, 2279-2282, 2296, 2299, 2302, 2305, 2308, 2311, 2314-2315, 2318-2319, 2322-2325, 2340, 2344-2347, 2357-2358, 2362, 2366, 2373-2376, 2379, 2381, 2383, 2385, 2388-2389, 2392-2393, 2396-2399, 2405-2411, 2414, 2416, 2418, 2420, 2422-2425, 2428-2429, 2432-2433, 2436-2439, 2445-2519, 2526-2527, 2530, 2533, 2536, 2540, 2543-2544, 2547-2548, 2551-2554, 2561-2577, 2584-2585, 2589, 2593, 2600-2602, 2605, 2608, 2610, 2613, 2615, 2619-2620, 2623-2624, 2627-2630, 2636-2638, 2641, 2643, 2645, 2648, 2650, 2654-2655, 2658-2659, 2662-2665, 2671-2714, 2721-2722, 2725-2728, 2732-2735, 2738, 2741-2742, 2745-2746, 2749-2752, 2759-2784, 2791-2792, 2795-2798, 2801-2804, 2807, 2810-2811, 2814-2815, 2818-2821, 2828-2853, 2860-2861, 2864, 2867, 2870, 2873, 2876, 2879, 2882, 2885, 2888, 2891, 2894-2895, 2898-2899, 2902-2905, 2912-2930, 2937-2938, 2941, 2944, 2948-2951, 2955, 2958-2959, 2962-2963, 2966-2969, 2976-3007, 3014-3015, 3018, 3021, 3024, 3027, 3030-3031, 3034-3035, 3038-3041, 3048-3064, 3071-3072, 3075, 3079, 3083, 3087, 3091, 3095, 3099, 3103, 3107, 3111, 3115, 3119, 3123, 3127, 3131, 3135, 3139, 3143, 3147, 3151, 3155, 3159, 3163, 3167, 3171, 3175, 3179, 3183, 3187-3190, 3194, 3197-3198, 3201-3202, 3205-3208, 3215-3388, 3395-3396, 3399, 3402, 3405, 3408-3409, 3412-3413, 3416-3419, 3426-3447, 3454-3455, 3458, 3461, 3464-3467, 3471, 3474-3475, 3478-3479, 3482-3485, 3492-3517, 3524-3525, 3528, 3531, 3534, 3537-3538, 3541-3542, 3545-3548, 3555-3569, 3576-3577, 3580, 3584, 3588, 3591-3592, 3595-3596, 3599-3602, 3609-3634, 3641-3642, 3645, 3648, 3651, 3654, 3657-3658, 3661-3662, 3665-3668, 3675-3691, 3698-3699, 3702, 3705, 3708, 3711, 3714-3715, 3718-3719, 3722-3725, 3732-3748, 3755-3756, 3759, 3762, 3765, 3768-3769, 3772-3773, 3776-3779, 3786-3800, 3807-3808, 3811, 3814, 3817, 3820-3821, 3824-3825, 3828-3831, 3838-3852, 3859-3860, 3863, 3866, 3869, 3872-3873, 3876-3877, 3880-3883, 3890-3904, 3911-3913, 3916, 3919, 3923-3926, 3929, 3932, 3936, 3940, 3943, 3947, 3950, 3953-3954, 3957-3958, 3961-3964, 3971-4013, 4020-4023, 4026, 4029, 4032, 4036, 4039-4042, 4046, 4049, 4052-4053, 4056-4057, 4060-4063, 4070-4100, 4107-4108, 4111, 4114, 4117, 4121, 4125, 4128-4129, 4132-4133, 4136-4139, 4146-4175, 4182-4184, 4187, 4190, 4193, 4197, 4200, 4204, 4207-4208, 4211-4212, 4215-4218, 4225-4245, 4252-4253, 4256, 4259, 4262, 4266, 4269-4270, 4273-4274, 4277-4280, 4287-4310, 4317-4318, 4321, 4324, 4328, 4332, 4335-4336, 4339-4340, 4343-4346, 4353-4376, 4383-4384, 4387, 4390, 4394, 4397, 4401, 4404-4405, 4408-4409, 4412-4415, 4422-4447, 4454-4455, 4458, 4461, 4465, 4468-4471, 4475, 4478, 4481, 4485, 4489, 4492, 4495-4496, 4499-4500, 4503-4506, 4513-4625, 4632-4633, 4636, 4640, 4643, 4646, 4650, 4653-4654, 4657-4658, 4661-4664, 4671-4696, 4703-4704, 4707, 4710, 4714, 4717, 4720-4721, 4724-4725, 4728-4731, 4738-4754, 4761-4762, 4765, 4768, 4771, 4774, 4778, 4781, 4784-4785, 4788-4789, 4792-4795, 4802-4822, 4829-4830, 4833, 4836, 4839, 4843, 4847, 4850, 4854, 4857-4858, 4861-4862, 4865-4868, 4875-4914, 4921-4922, 4925, 4928, 4932, 4935, 4938, 4942, 4945, 4948-4949, 4952-4953, 4956-4959, 4966-4988, 4995-4996, 4999, 5002, 5005, 5008, 5011, 5015, 5019, 5022-5023, 5026-5027, 5030-5033, 5040-5076, 5083-5084, 5087, 5090, 5093, 5096, 5099, 5103, 5106-5107, 5110-5111, 5114-5117, 5124-5154, 5161-5162, 5165, 5169, 5172, 5175, 5178-5179, 5182-5183, 5186-5189, 5196-5212, 5219-5220, 5223, 5226, 5229, 5232, 5235, 5239, 5243, 5247, 5250-5251, 5254-5255, 5258-5261, 5268-5305, 5312-5313, 5316, 5319, 5322, 5325, 5328, 5331, 5335, 5339, 5342-5343, 5346-5347, 5350-5353, 5360-5397, 5404-5407, 5410, 5413, 5416, 5420-5423, 5427, 5430, 5433, 5436-5437, 5440-5441, 5444-5447, 5454-5491, 5498-5500, 5503, 5507, 5510, 5513, 5516, 5520, 5524, 5527-5528, 5531-5532, 5535-5538, 5545-5582, 5589-5590, 5593, 5597, 5600, 5603-5604, 5607-5608, 5611-5614, 5621-5635, 5642-5643, 5646, 5649, 5652, 5656, 5659, 5662, 5665, 5668, 5672, 5676, 5679-5680, 5683-5684, 5687-5690, 5697-5755, 5767, 5777-5779, 5782-5785, 5788, 5791-5792, 5795-5796, 5799-5802, 5808-5810, 5813-5816, 5819, 5821, 5824-5825, 5828-5829, 5832-5835, 5841-5842, 5845, 5847, 5849, 5852, 5855-5856, 5859-5860, 5863-5866, 5872-5873, 5876, 5878, 5881, 5884-5885, 5888-5889, 5892-5895, 5901-5903, 5906-5909, 5912, 5915-5916, 5919-5920, 5923-5926, 5932-5934, 5937-5940, 5943, 5945, 5947, 5950-5951, 5954-5955, 5958-5961, 5967-5969, 5972-5975, 5978, 5981-5982, 5985-5986, 5989-5992, 5998-5999, 6002, 6004, 6007, 6009, 6012, 6016-6017, 6020-6021, 6024-6027, 6033-6035, 6038-6041, 6044, 6047-6048, 6051-6052, 6055-6058, 6064-6066, 6069-6072, 6075, 6078-6079, 6082-6083, 6086-6089, 6095-6096, 6099, 6101, 6103, 6105, 6109-6110, 6113-6114, 6117-6120, 6126-6128, 6131-6134, 6137, 6140-6141, 6144-6145, 6148-6151, 6157-6159, 6162-6165, 6168, 6171-6172, 6175-6176, 6179-6182, 6188-6190, 6193-6196, 6199, 6202-6203, 6206-6207, 6210-6213, 6219-6221, 6224-6227, 6230, 6233-6234, 6237-6238, 6241-6244, 6250-6251, 6254, 6257, 6261-6262, 6265-6266, 6269-6272, 6278-6280, 6283, 6286, 6288, 6290, 6293-6294, 6297-6298, 6301-6304, 6314, 6316, 6318, 6320, 6322, 6324, 6326, 6328, 6330, 6332, 6334, 6337-6338, 6341-6342, 6345-6348, 6366-6376, 6379-6392, 6395-6418, 6421-6432, 6435-6452, 6454->6468, 6461, 6473-6654, 6664-6665, 6668-6671, 6675-6678, 6681, 6684-6685, 6688-6689, 6692-6695, 6702-6727, 6734-6735, 6738, 6742, 6746, 6750, 6753-6754, 6757-6758, 6761-6764, 6771-6801, 6808-6809, 6812, 6815, 6819, 6822-6823, 6826-6827, 6830-6833, 6840-6854, 6861-6862, 6865-6868, 6871-6874, 6878, 6881-6882, 6885-6886, 6889-6892, 6899-6938, 6945-6946, 6949, 6952-6955, 6959, 6962-6965, 6968, 6971-6972, 6975-6976, 6979-6982, 6989-7027, 7034-7035, 7038, 7041, 7044-7047, 7051-7054, 7058-7061, 7064, 7067-7068, 7071-7072, 7075-7078, 7085-7147, 7158, 7161, 7164, 7168-7171, 7175-7178, 7182-7185, 7188, 7191-7192, 7195-7196, 7199-7202, 7220-7222, 7232-7235, 7242-7261, 7267-7268, 7273, 7277-7280, 7294, 7297-7300, 7304, 7307-7308, 7311-7312, 7318, 7342-7345, 7355-7356, 7359, 7362, 7366, 7369-7370, 7373-7374, 7377-7380, 7387-7401, 7408-7409, 7412, 7415, 7418, 7421, 7424, 7428, 7431, 7434, 7437, 7440-7441, 7444-7445, 7448-7451, 7458-7512, 7519-7520, 7523, 7526, 7530, 7533, 7536, 7539, 7542, 7545, 7548, 7551, 7554, 7557, 7561, 7564, 7567-7568, 7571-7572, 7575-7578, 7585-7698, 7705-7706, 7709, 7712, 7716, 7719-7720, 7723-7724, 7727-7730, 7737-7758, 7765-7766, 7769, 7772, 7775, 7779, 7782, 7786, 7789, 7792-7793, 7796-7797, 7800-7803, 7810-7832, 7839-7840, 7843, 7846, 7849, 7853, 7856, 7859, 7862, 7865, 7869, 7872, 7875, 7879, 7882-7883, 7886-7887, 7890-7893, 7900-7946, 7953-7954, 7957, 7960, 7964, 7967, 7970-7971, 7974-7975, 7978-7981, 7988-8004, 8011-8012, 8015, 8019, 8022, 8025-8026, 8029-8030, 8033-8036, 8043-8068, 8075-8076, 8079, 8083, 8087, 8090, 8094, 8097-8098, 8101-8102, 8105-8108, 8115-8154, 8161-8162, 8165, 8168, 8171, 8174-8175, 8178-8179, 8182-8185, 8192-8210, 8217-8218, 8221, 8225, 8228, 8232, 8235, 8238, 8242, 8246, 8249-8250, 8253-8254, 8257-8260, 8267-8324, 8331-8332, 8335-8338, 8342-8345, 8348, 8351-8352, 8355-8356, 8359-8362, 8369-8403, 8410-8411, 8414-8417, 8421-8424, 8427, 8430-8431, 8434-8435, 8438-8441, 8448-8482, 8489-8490, 8493-8496, 8500-8503, 8506, 8509-8510, 8513-8514, 8517-8520, 8527-8561, 8568-8569, 8572-8575, 8578-8581, 8584, 8587-8588, 8591-8592, 8595-8598, 8605-8639, 8646-8647, 8650-8653, 8657-8660, 8663, 8666-8667, 8670-8671, 8674-8677, 8684-8718, 8725-8726, 8729-8732, 8736-8739, 8742, 8745-8746, 8749-8750, 8753-8756, 8763-8797, 8802-8809, 8812-8857 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/BraketPragmasParserVisitor.py 224 106 2 1 53% 6, 19, 24, 29, 34, 49, 54, 59, 64, 69, 74, 79, 84, 89, 94, 104, 109, 114, 119, 124, 129, 134, 139, 144, 149, 154, 159, 164, 169, 174, 179, 184, 189, 194, 199, 204, 209, 214, 219, 224, 229, 234, 239, 244, 249, 254, 259, 264, 269, 274, 279, 284, 289, 294, 299, 304, 309, 314, 319, 324, 329, 334, 339, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 394, 399, 404, 409, 414, 419, 424, 429, 434, 439, 444, 449, 454, 459, 464, 469, 474, 479, 484, 489, 494, 499, 504, 509, 514, 519, 524, 529, 534, 539, 544, 549, 554 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/qasm3Lexer.py 698 1 6 1 99% 8 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/qasm3Parser.py 4812 2818 986 74 36% 9, 647, 657, 661, 664-665, 668-669, 672-675, 707-710, 724, 730, 733, 736-737, 740-741, 744-747, 764-767, 785, 789, 793, 797, 801, 805, 809, 813, 817, 821, 825, 829, 833, 837, 841, 845, 849, 853, 857, 861, 865, 869, 873, 877, 881, 885, 889, 896, 900, 903-904, 907-908, 914, 939-943, 949-951, 959-961, 964-966, 969-971, 974-976, 984-986, 989-991, 994-996, 999-1001, 1004-1006, 1009-1011, 1014-1016, 1019-1021, 1024-1026, 1034-1036, 1039-1041, 1044-1046, 1049-1051, 1054-1056, 1059-1061, 1068-1081, 1086-1091, 1101-1102, 1105, 1108, 1111, 1114-1115, 1118-1119, 1122-1125, 1132-1153, 1160-1161, 1164, 1167, 1170-1173, 1177, 1180-1181, 1184-1185, 1188-1191, 1198-1223, 1234, 1240, 1243-1244, 1247-1248, 1254, 1269-1272, 1282-1283, 1286, 1290, 1294, 1297-1298, 1301-1302, 1305-1308, 1315-1340, 1347-1348, 1351, 1354, 1357, 1360, 1363-1364, 1367-1368, 1371-1374, 1381-1397, 1404-1405, 1408, 1411, 1414, 1417, 1420-1421, 1424-1425, 1428-1431, 1438-1454, 1461-1462, 1465, 1468, 1471, 1474-1475, 1478-1479, 1482-1485, 1492-1506, 1513-1514, 1517, 1520, 1523, 1526-1527, 1530-1531, 1534-1537, 1544-1558, 1565-1566, 1569, 1572, 1575, 1578-1579, 1582-1583, 1586-1589, 1596-1610, 1617-1619, 1622, 1625, 1629-1632, 1635, 1638, 1642, 1646, 1649, 1653, 1656, 1659-1660, 1663-1664, 1667-1670, 1677-1719, 1726-1729, 1732, 1735, 1738, 1742, 1745-1748, 1752, 1755, 1758-1759, 1762-1763, 1766-1769, 1776-1806, 1813-1814, 1817, 1820, 1823, 1827, 1831, 1834-1835, 1838-1839, 1842-1845, 1852-1881, 1888-1890, 1893, 1896, 1899, 1903, 1906, 1910, 1913-1914, 1917-1918, 1921-1924, 1931-1951, 1958-1959, 1962, 1965, 1968, 1972, 1975-1976, 1979-1980, 1983-1986, 1993-2016, 2023-2024, 2027, 2030, 2034, 2038, 2041-2042, 2045-2046, 2049-2052, 2059-2082, 2089-2090, 2093, 2096, 2100, 2103, 2107, 2110-2111, 2114-2115, 2118-2121, 2128-2153, 2171, 2177, 2181, 2184, 2198, 2201-2202, 2205-2206, 2212, 2232-2236, 2249->2254, 2262-2263, 2272-2328, 2338-2339, 2342, 2346, 2349, 2352, 2356, 2359-2360, 2363-2364, 2367-2370, 2377-2402, 2409-2410, 2413, 2416, 2420, 2423, 2426-2427, 2430-2431, 2434-2437, 2444-2460, 2467-2468, 2471, 2474, 2477, 2480, 2484, 2487, 2490-2491, 2494-2495, 2498-2501, 2508-2528, 2542, 2553, 2560, 2563-2564, 2567-2568, 2574, 2593-2598, 2606-2609, 2614-2617, 2627-2628, 2631, 2634, 2638, 2641, 2644, 2648, 2651, 2654-2655, 2658-2659, 2662-2665, 2672-2694, 2701-2702, 2705, 2708, 2711, 2714, 2717, 2721, 2725, 2728-2729, 2732-2733, 2736-2739, 2746-2782, 2789-2790, 2793, 2796, 2799, 2802, 2805, 2809, 2812-2813, 2816-2817, 2820-2823, 2830-2860, 2878, 2881, 2884-2885, 2888-2889, 2895, 2912-2915, 2925-2926, 2929, 2932, 2935, 2938, 2941, 2945, 2949, 2953, 2956-2957, 2960-2961, 2964-2967, 2974-3011, 3018-3019, 3022, 3025, 3028, 3031, 3034, 3037, 3041, 3045, 3048-3049, 3052-3053, 3056-3059, 3066-3103, 3110-3113, 3116, 3119, 3122, 3126-3129, 3133, 3136, 3139, 3142-3143, 3146-3147, 3150-3153, 3160-3197, 3213, 3216, 3219, 3222, 3230, 3233-3234, 3237-3238, 3244, 3262, 3270-3272, 3278, 3282-3285, 3295-3296, 3299, 3303, 3306, 3309-3310, 3313-3314, 3317-3320, 3327-3341, 3348-3349, 3352, 3355, 3358, 3362, 3365, 3368, 3371, 3374, 3378, 3382, 3385-3386, 3389-3390, 3393-3396, 3403-3461, 3473, 3483-3485, 3488-3491, 3494, 3497-3498, 3501-3502, 3505-3508, 3514-3516, 3519-3522, 3525, 3527, 3530-3531, 3534-3535, 3538-3541, 3547-3548, 3551, 3553, 3555, 3558, 3561-3562, 3565-3566, 3569-3572, 3578-3579, 3582, 3584, 3587, 3590-3591, 3594-3595, 3598-3601, 3607-3609, 3612-3615, 3618, 3621-3622, 3625-3626, 3629-3632, 3638-3640, 3643-3646, 3649, 3651, 3653, 3656-3657, 3660-3661, 3664-3667, 3673-3675, 3678-3681, 3684, 3687-3688, 3691-3692, 3695-3698, 3704-3705, 3708, 3710, 3713, 3715, 3718, 3722-3723, 3726-3727, 3730-3733, 3739-3741, 3744-3747, 3750, 3753-3754, 3757-3758, 3761-3764, 3770-3772, 3775-3778, 3781, 3784-3785, 3788-3789, 3792-3795, 3801-3802, 3805, 3807, 3809, 3811, 3815-3816, 3819-3820, 3823-3826, 3832-3834, 3837-3840, 3843, 3846-3847, 3850-3851, 3854-3857, 3863-3865, 3868-3871, 3874, 3877-3878, 3881-3882, 3885-3888, 3894-3896, 3899-3902, 3905, 3908-3909, 3912-3913, 3916-3919, 3925-3927, 3930-3933, 3936, 3939-3940, 3943-3944, 3947-3950, 3956-3957, 3960, 3963, 3967-3968, 3971-3972, 3975-3978, 3992, 3994, 3996, 3999-4000, 4003-4004, 4010, 4032, 4034, 4036, 4038, 4040, 4043-4044, 4047-4048, 4054, 4072-4082, 4092, 4101-4124, 4127-4138, 4141-4158, 4160->4174, 4167, 4179-4360, 4370-4371, 4374-4377, 4381-4384, 4387, 4390-4391, 4394-4395, 4398-4401, 4408-4433, 4440-4441, 4444, 4448, 4452, 4456, 4459-4460, 4463-4464, 4467-4470, 4477-4507, 4518, 4525, 4528-4529, 4532-4533, 4539, 4554-4557, 4567-4568, 4571-4574, 4577-4580, 4584, 4587-4588, 4591-4592, 4595-4598, 4605-4644, 4651-4652, 4655, 4658-4661, 4665, 4668-4671, 4674, 4677-4678, 4681-4682, 4685-4688, 4695-4733, 4740-4741, 4744, 4747, 4750-4753, 4757-4760, 4764-4767, 4770, 4773-4774, 4777-4778, 4781-4784, 4791-4853, 4864, 4867, 4874-4877, 4881-4884, 4888-4891, 4894, 4897-4898, 4901-4902, 4908, 4926-4928, 4938-4941, 4948-4967, 4973-4974, 4979, 4983-4986, 5006, 5010, 5013-5014, 5017-5018, 5024, 5048-5051, 5061-5062, 5065, 5068, 5072, 5075-5076, 5079-5080, 5083-5086, 5093-5107, 5114-5115, 5118, 5121, 5124, 5127, 5130, 5134, 5137, 5140, 5143, 5146-5147, 5150-5151, 5154-5157, 5164-5218, 5236, 5239, 5242, 5245, 5257, 5260, 5263, 5267, 5270, 5273-5274, 5277-5278, 5284, 5305->5310, 5311-5401, 5415, 5422, 5425-5426, 5429-5430, 5433-5436, 5453->5463, 5458-5461, 5471-5472, 5475, 5478, 5481, 5485, 5488, 5492, 5495, 5498-5499, 5502-5503, 5506-5509, 5516-5538, 5545-5546, 5549, 5552, 5555, 5559, 5562, 5565, 5568, 5571, 5575, 5578, 5581, 5585, 5588-5589, 5592-5593, 5596-5599, 5606-5652, 5663, 5670, 5673, 5676-5677, 5680-5681, 5687, 5704-5707, 5728, 5731-5732, 5735-5736, 5742, 5760-5771, 5781-5782, 5785, 5789, 5793, 5796, 5800, 5803-5804, 5807-5808, 5811-5814, 5821-5860, 5867-5868, 5871, 5874, 5877, 5880-5881, 5884-5885, 5888-5891, 5898-5916, 5923-5924, 5927, 5931, 5934, 5938, 5941, 5944, 5948, 5952, 5955-5956, 5959-5960, 5963-5966, 5973-6030, 6037-6038, 6041-6044, 6048-6051, 6054, 6057-6058, 6061-6062, 6065-6068, 6075-6109, 6123, 6127-6130, 6133, 6136-6137, 6140-6141, 6144-6147, 6165-6172, 6178-6185, 6195-6196, 6199-6202, 6206-6209, 6212, 6215-6216, 6219-6220, 6223-6226, 6233-6267, 6274-6275, 6278-6281, 6284-6287, 6290, 6293-6294, 6297-6298, 6301-6304, 6311-6345, 6359, 6363-6366, 6369, 6372-6373, 6376-6377, 6380-6383, 6401->6406, 6414-6421, 6431-6432, 6435-6438, 6442-6445, 6448, 6451-6452, 6455-6456, 6459-6462, 6469-6503, 6508-6515, 6518-6563 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/generated/qasm3ParserVisitor.py 160 78 2 1 51% 6, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64, 69, 74, 79, 84, 89, 94, 99, 104, 109, 114, 119, 124, 129, 134, 139, 144, 149, 154, 159, 164, 169, 174, 179, 184, 189, 194, 199, 204, 209, 214, 219, 224, 229, 234, 239, 244, 249, 254, 259, 264, 269, 274, 279, 284, 289, 294, 299, 304, 309, 314, 319, 324, 329, 334, 339, 344, 349, 354, 359, 364, 369, 374, 379, 384, 389, 394 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/openqasm_ast.py 269 0 122 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/parser/openqasm_parser.py 492 255 216 22 40% 47-48, 85->90, 92-93, 116, 126, 137, 157-159, 162, 165, 177, 180, 202, 208, 213, 220, 228, 234, 242-247, 251-252, 259-261, 265-267, 274, 276, 286, 294-296, 300-313, 322-345, 355-360, 364, 368, 372-382, 390-398, 419-423, 434-445, 449-453, 459-461, 465-468, 478-480, 489-500, 509, 518-520, 524-532, 536-538, 542, 546, 560, 580, 585, 590-591, 595-608, 613, 615, 617, 621, 624-645, 652-663, 667, 673-691, 695, 699-707, 713, 728, 740-746, 754, 756, 758, 761-774, 778-792, 800, 805-834, 838-856, 860-862, 867 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/openqasm/program_context.py 281 98 60 6 58% 55, 58-59, 62-66, 78, 88->92, 90, 94-98, 102-107, 123, 126, 149-152, 158-162, 166-169, 172-177, 180-186, 204, 261, 277, 296-299, 309-312, 328, 343, 346, 358, 361, 390, 397-398, 436, 440-442, 446-448, 460, 464, 481-484, 501, 514, 521, 525-528, 541-546, 561, 569-573, 585-586, 590 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/operation.py 54 8 4 1 81% 62, 66, 81, 97, 105, 108-110 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/operation_helpers.py 32 15 16 0 40% 36, 41, 67, 81-86, 100-101, 113-114, 126-128 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/result_types.py 126 35 33 9 65% 57, 119, 141, 174, 179, 194, 206-213, 221, 234, 248-249, 254, 317, 322, 330, 336, 349, 351, 353, 355, 359-367, 372, 375-376 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulation.py 22 4 0 0 82% 65, 76, 87, 92 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulation_strategies/batch_operation_strategy.py 26 20 14 0 15% 56-61, 67-91 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulation_strategies/single_operation_strategy.py 14 0 2 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/simulator.py 149 49 86 10 63% 88, 117, 141, 144, 146, 150, 167-169, 216, 228, 257-259, 265, 279-291, 295-303, 424-467 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/state_vector_simulation.py 52 10 10 2 71% 57, 59, 85-93, 129, 139-141 -.tox/unit-tests/lib/python3.10/site-packages/braket/default_simulator/state_vector_simulator.py 18 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/__init__.py 13 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/blackbird_device_action_properties.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/continuous_variable_qpu_paradigm_properties_v1.py 14 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_action_properties.py 12 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_capabilities.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_connectivity.py 4 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_execution_window.py 19 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/device_service_properties_v1.py 22 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/__init__.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_2000Q_device_level_parameters_v1.py 24 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_2000Q_device_parameters_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_advantage_device_level_parameters_v1.py 21 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_advantage_device_parameters_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_device_capabilities_v1.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_device_parameters_v1.py 11 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_provider_level_parameters_v1.py 30 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/dwave/dwave_provider_properties_v1.py 28 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/debias.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/error_mitigation_properties.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/error_mitigation/error_mitigation_scheme.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/gate_model_parameters_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/gate_model_qpu_paradigm_properties_v1.py 10 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/ionq_device_capabilities_v1.py 28 7 0 0 75% 31-36, 40-44 -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/ionq_device_parameters_v1.py 19 6 4 0 57% 65-70 -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/ionq/ionq_provider_properties_v1.py 30 12 4 0 53% 28-35, 39-42 -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/jaqcd_device_action_properties.py 9 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/openqasm_device_action_properties.py 21 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/oqc_device_capabilities_v1.py 19 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/oqc_device_parameters_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/oqc/oqc_provider_properties_v1.py 11 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/__init__.py 0 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/frame_v1.py 11 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/port_v1.py 14 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/pulse_device_action_properties_v1.py 17 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/pulse/pulse_function_v1.py 11 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/result_type.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/rigetti_device_capabilities_v1.py 19 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/rigetti_device_parameters_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/rigetti/rigetti_provider_properties_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/gate_model_simulator_device_capabilities_v1.py 13 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/gate_model_simulator_device_parameters_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/simulators/gate_model_simulator_paradigm_properties_v1.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/standardized_gate_model_qpu_device_properties_v1.py 35 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/xanadu_device_capabilities_v1.py 14 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/xanadu_device_parameters_v1.py 5 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/device_schema/xanadu/xanadu_provider_properties_v1.py 12 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/devices/__init__.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/devices/device.py 20 2 0 0 90% 97, 106 -.tox/unit-tests/lib/python3.10/site-packages/braket/devices/local_simulator.py 129 65 42 2 40% 135-179, 188, 198, 209, 213, 221, 227, 239, 257-263, 267-274, 285-296, 306-312, 322-328 -.tox/unit-tests/lib/python3.10/site-packages/braket/error_mitigation/__init__.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/error_mitigation/debias.py 6 1 0 0 83% 26 -.tox/unit-tests/lib/python3.10/site-packages/braket/error_mitigation/error_mitigation.py 5 1 0 0 80% 26 -.tox/unit-tests/lib/python3.10/site-packages/braket/ipython_utils.py 11 4 4 2 60% 31-34, 37 -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/__init__.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/atom_arrangement.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/driving_field.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/hamiltonian.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/physical_field.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/program_v1.py 14 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/shifting_field.py 4 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/ahs/time_series.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/annealing/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/annealing/problem_v1.py 13 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/blackbird/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/blackbird/program_v1.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/instructions.py 193 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/program_v1.py 31 13 12 0 42% 232-251 -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/results.py 35 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/jaqcd/shared_models.py 74 18 12 0 65% 255-258, 284-306 -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/openqasm/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/openqasm/modifiers.py 18 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/ir/openqasm/program_v1.py 10 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/config.py 26 3 12 0 87% 73-82 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/data_persistence.py 30 23 10 0 18% 50-62, 93-104, 129-136 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/image_uris.py 30 19 10 0 28% 43-55, 67-69, 85-91 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/logs.py 70 55 32 0 15% 46, 55-58, 67, 93-110, 134-155, 190-230 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/__init__.py 4 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/cwl_insights_metrics_fetcher.py 48 31 12 0 28% 45-48, 65, 79-90, 104-107, 125-128, 164-186 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/cwl_metrics_fetcher.py 56 42 22 0 18% 40-42, 55-57, 74-93, 106-124, 154-162 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/definitions.py 12 0 6 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/exceptions.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/metrics_data/log_metrics_parser.py 71 53 32 0 17% 37-38, 59-63, 79-87, 99-110, 129-143, 174-183, 209-211 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/quantum_job.py 26 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/quantum_job_creation.py 107 83 40 0 16% 138-222, 234-242, 259-266, 285-294, 305-315, 330-333, 344-348, 369-374, 391-401, 416, 426 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs/serialization.py 8 2 4 0 50% 38, 63 -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs_data/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/jobs_data/persisted_job_data_v1.py 12 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/__init__.py 3 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/free_parameter.py 29 4 2 1 84% 85, 94, 97, 104 -.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/free_parameter_expression.py 63 27 24 5 49% 47, 51, 79, 87, 90-93, 96, 99-102, 105, 109, 117-120, 123, 126, 129-131, 152-157 -.tox/unit-tests/lib/python3.10/site-packages/braket/parametric/parameterizable.py 11 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/__init__.py 4 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/approximation_parser.py 211 155 96 0 20% 55-59, 71, 76-79, 82-93, 101-102, 110, 124-132, 142-146, 157-165, 175-176, 186-189, 199-206, 219-263, 273, 283, 293, 303, 313, 323-326, 336-338, 346-348, 356-358, 366-369, 377-379, 387, 395-411, 421-422, 432-433, 443-444, 448-453, 467-471, 475 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/free_parameters.py 26 13 4 0 43% 26-27, 31, 38-39, 51-55, 66-69 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/qasm_parser.py 23 11 4 0 44% 27, 37, 47-51, 66-67, 79-81 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/ast/qasm_transformer.py 14 8 2 0 38% 28-30, 39-58 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/frame.py 20 9 0 0 55% 49-54, 59, 62, 74 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/port.py 18 7 0 0 61% 34-36, 41, 46, 49, 52 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/pulse_sequence.py 138 103 46 0 19% 45-49, 61-62, 69, 86-89, 105-108, 124-127, 143-146, 162-165, 181-191, 204-208, 221-231, 244-248, 263-293, 301-311, 316-320, 333-339, 345-350 -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/pulse_sequence_trace.py 9 0 2 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/pulse/waveforms.py 103 54 4 0 46% 72-73, 76, 86, 95, 113-115, 121, 130-135, 138, 149-152, 165-167, 196-201, 207, 216-224, 227, 241-251, 269-283, 310-314, 320, 329-336, 339, 352-361, 378-388, 392, 398-404 -.tox/unit-tests/lib/python3.10/site-packages/braket/schema_common/__init__.py 2 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/schema_common/schema_base.py 22 10 4 0 46% 52, 66-70, 74-78 -.tox/unit-tests/lib/python3.10/site-packages/braket/schema_common/schema_header.py 16 8 0 0 50% 35, 38, 51-56 -.tox/unit-tests/lib/python3.10/site-packages/braket/simulator/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/simulator/braket_simulator.py 14 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/__init__.py 13 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/additional_metadata.py 23 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/analog_hamiltonian_simulation_task_result_v1.py 19 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/annealing_task_result_v1.py 14 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/dwave_metadata_v1.py 22 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/gate_model_task_result_v1.py 18 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/ionq_metadata_v1.py 7 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/oqc_metadata_v1.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/photonic_model_task_result_v1.py 11 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/quera_metadata_v1.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/rigetti_metadata_v1.py 17 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/simulator_metadata_v1.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/task_metadata_v1.py 20 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/task_result/xanadu_metadata_v1.py 6 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/__init__.py 10 2 2 1 75% 33-35 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/analog_hamiltonian_simulation_quantum_task_result.py 80 47 34 0 32% 39-45, 54-59, 65, 69, 77-81, 88-100, 117-130, 139-151, 155-159 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/annealing_quantum_task_result.py 57 34 16 0 34% 67-79, 82-99, 113, 126, 130-143, 163-174 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/gate_model_quantum_task_result.py 201 65 82 5 63% 103, 120-126, 132-134, 194-201, 235-237, 263-274, 280, 298, 342-351, 371-399, 421-424, 459-462, 471-474, 483-494 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/local_quantum_task.py 20 5 0 0 75% 42, 46, 49, 64, 67 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/local_quantum_task_batch.py 7 2 0 0 71% 40, 49 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/photonic_model_quantum_task_result.py 27 11 6 0 55% 30-32, 48, 52, 60-66 -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/quantum_task.py 19 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/tasks/quantum_task_batch.py 8 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/timings/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/timings/time_series.py 118 85 52 0 21% 38-40, 57-65, 73-74, 82-83, 86-87, 90, 93-95, 108-117, 130-133, 164-177, 228-256, 270-276, 291-299, 320-333 -.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/__init__.py 1 0 0 0 100% -.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/pricing.py 26 11 6 0 47% 34-55, 63-65 -.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/tracker.py 128 98 44 0 17% 39, 42-43, 46, 53, 60, 67, 76, 91-95, 114-118, 145-171, 175, 179, 188-191, 195-202, 206-248, 252-291 -.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/tracking_context.py 18 5 2 0 65% 26, 33, 40-41, 44 -.tox/unit-tests/lib/python3.10/site-packages/braket/tracking/tracking_events.py 18 0 8 0 100% -src/braket/experimental/__init__.py 0 0 0 0 100% -src/braket/experimental/algorithms/__init__.py 0 0 0 0 100% -src/braket/experimental/algorithms/bells_inequality/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/bells_inequality/bells_inequality.py 38 0 16 0 100% -src/braket/experimental/algorithms/bernstein_vazirani/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/bernstein_vazirani/bernstein_vazirani.py 26 0 6 0 100% -src/braket/experimental/algorithms/chsh_inequality/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/chsh_inequality/chsh_inequality.py 30 0 12 0 100% -src/braket/experimental/algorithms/deutsch_jozsa/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/deutsch_jozsa/deutsch_jozsa.py 49 0 18 0 100% -src/braket/experimental/algorithms/grovers_search/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/grovers_search/grovers_search.py 87 0 14 0 100% -src/braket/experimental/algorithms/qc_qmc/__init__.py 0 0 0 0 100% -src/braket/experimental/algorithms/qc_qmc/classical_qmc.py 131 0 26 0 100% -src/braket/experimental/algorithms/qc_qmc/qc_qmc.py 184 0 50 0 100% -src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_approximate_optimization/quantum_approximate_optimization.py 47 0 12 0 100% -src/braket/experimental/algorithms/quantum_circuit_born_machine/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_circuit_born_machine/qcbm.py 80 0 18 0 100% -src/braket/experimental/algorithms/quantum_fourier_transform/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_fourier_transform/quantum_fourier_transform.py 44 0 18 0 100% -src/braket/experimental/algorithms/quantum_neuron/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py 85 59 26 1 30% 63, 87-94, 111-119, 136-169, 173-213, 224 -src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_phase_estimation/quantum_phase_estimation.py 75 0 30 0 100% -src/braket/experimental/algorithms/quantum_walk/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/quantum_walk/quantum_walk.py 61 0 26 0 100% -src/braket/experimental/algorithms/shors/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/shors/shors.py 109 0 48 0 100% -src/braket/experimental/algorithms/simons/__init__.py 1 0 0 0 100% -src/braket/experimental/algorithms/simons/simons.py 55 0 29 0 100% ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -TOTAL 25941 11933 5669 306 48% -Coverage HTML written to dir build/coverage -Coverage XML written to file build/coverage/coverage.xml - -================================================= short test summary info ================================================= -FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_linear_combination - p... -FAILED test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py::test_quantum_neuron - penny... -================================== 2 failed, 69 passed, 7 xfailed, 40 warnings in 34.09s ================================== -unit-tests: exit 1 (35.18 seconds) /home/ec2-user/SageMaker/amazon-braket-algorithm-library> pytest --cov-report term-missing --cov-report html --cov-report xml --cov=braket pid=32164 -unit-tests: FAIL ✖ in 38.53 seconds -integ_tests: install_package> python -I -m pip install --force-reinstall --no-deps /home/ec2-user/SageMaker/amazon-braket-algorithm-library/.tox/.tmp/package/12/amazon-braket-algorithm-library-1.4.1.dev0.tar.gz -.pkg: _exit> python /home/ec2-user/anaconda3/envs/JupyterSystemEnv/lib/python3.10/site-packages/pyproject_api/_backend.py True setuptools.build_meta __legacy__ - linters: FAIL code 1 (2.01=setup[0.05]+cmd[0.28,0.39,1.28] seconds) - docs: OK (10.79=setup[3.45]+cmd[7.34] seconds) - unit-tests: FAIL code 1 (38.53=setup[3.34]+cmd[35.18] seconds) - integ_tests: OK (2.99 seconds) - evaluation failed :( (54.50 seconds) From 4a5d8a13161a11fdd1b5cbf224481d1aabfdb5bc Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Fri, 14 Jul 2023 00:32:31 +0000 Subject: [PATCH 12/37] fix: style errors --- .../algorithms/quantum_neuron/test_quantum_neuron.py | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py index 36fed31a..be4cf544 100644 --- a/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py +++ b/test/unit_tests/braket/experimental/algorithms/quantum_neuron/test_quantum_neuron.py @@ -45,8 +45,7 @@ def lc_circuit(): print(f"z_expected_value: {z_expected_value}\n") theta = ( # linear comination with numpy - np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), - np.array(weights)) + np.inner(np.array(list(inputs_list[input_to_test]), dtype=int), np.array(weights)) + bias ) theta = theta.item() # Convert numpy array to native python float-type @@ -56,8 +55,7 @@ def lc_circuit(): ) # Z expected value of Ry(2*theta)|0> print(f"theoritical_z_expected_value: {z_expected_value}") - np.testing.assert_almost_equal(z_expected_value, - theoritical_z_expected_value, decimal=2) + np.testing.assert_almost_equal(z_expected_value, theoritical_z_expected_value, decimal=2) def test_quantum_neuron(): @@ -72,8 +70,7 @@ def test_quantum_neuron(): dev = qml.device("braket.local.qubit", wires=n_qubits, shots=100000) - theta, q_theta = quantum_neuron(inputs_list[input_to_test], - weights, bias, n_qubits, dev) + theta, q_theta = quantum_neuron(inputs_list[input_to_test], weights, bias, n_qubits, dev) print(f"q_theta: {q_theta}") expected_q_theta = np.arctan(np.tan(theta) ** 2) From 927f5155391000708db6e8e0bd66b2ca786c2f7a Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Mon, 17 Jul 2023 23:03:38 +0000 Subject: [PATCH 13/37] fix: style errors --- notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index b96a1729..265a0860 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -722,7 +722,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.10.12" }, "vscode": { "interpreter": { From 6ea06e81901da5b646d3fa67ca7f82daaf49c714 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 22 Jul 2023 15:05:41 +0000 Subject: [PATCH 14/37] fix setup.py --- setup.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index d626147a..6a22daeb 100644 --- a/setup.py +++ b/setup.py @@ -29,8 +29,9 @@ install_requires=[ "amazon-braket-sdk>=1.35.1", "scipy>=1.5.2", - "pennylane>=0.29.1", + "pennylane>=0.30.0", "openfermion>=1.5.1", + "amazon-braket-pennylane-plugin>=1.17.4", ], extras_require={ "test": [ From 5e1de8fd8cc93569bb88040f7a124bb4da794c79 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Fri, 28 Jul 2023 01:50:46 +0000 Subject: [PATCH 15/37] add Quantum_Neuron_mocks.py --- test/integ_tests/textbook/Quantum_Neuron_mocks.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 test/integ_tests/textbook/Quantum_Neuron_mocks.py diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py new file mode 100644 index 00000000..d6d1c293 --- /dev/null +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -0,0 +1,10 @@ +def pre_run_inject(mock_utils): + mocker = mock_utils.Mocker() + mock_utils.mock_default_device_calls(mocker) + mocker.set_task_result_return( + mock_utils.read_file("quantum_neuron_results.json", __file__) + ) + + +def post_run(tb): + pass \ No newline at end of file From 82f379a0dfefaa920a876673c4f2cadaeb38c869 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Fri, 28 Jul 2023 01:56:11 +0000 Subject: [PATCH 16/37] add Quantum_Neuron_mocks.py --- test/integ_tests/textbook/Quantum_Neuron_mocks.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index d6d1c293..b11f81e3 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -1,10 +1,8 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_task_result_return( - mock_utils.read_file("quantum_neuron_results.json", __file__) - ) + mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) def post_run(tb): - pass \ No newline at end of file + pass From 5255e3ee689d7aa54bc497e17709daf3bdfc5bf4 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Fri, 28 Jul 2023 02:24:36 +0000 Subject: [PATCH 17/37] exclude Quantum_Neuron_mocks.py for integ test --- test/integ_tests/test_all_notebooks.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/integ_tests/test_all_notebooks.py b/test/integ_tests/test_all_notebooks.py index 1e12023f..3a7530d9 100644 --- a/test/integ_tests/test_all_notebooks.py +++ b/test/integ_tests/test_all_notebooks.py @@ -11,6 +11,8 @@ # need high processing power and lead to timeouts. "Quantum_Computing_Quantum_Monte_Carlo.ipynb", "Template.ipynb", + # for test + "Quantum_Neuron.ipynb", ] logging.basicConfig(level=logging.INFO) From a024e6a57f3b6d26ad2a0b650c2e3a8884e1599c Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 02:13:11 +0000 Subject: [PATCH 18/37] edit test_all_notebooks.py --- test/integ_tests/test_all_notebooks.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/integ_tests/test_all_notebooks.py b/test/integ_tests/test_all_notebooks.py index 3a7530d9..1e12023f 100644 --- a/test/integ_tests/test_all_notebooks.py +++ b/test/integ_tests/test_all_notebooks.py @@ -11,8 +11,6 @@ # need high processing power and lead to timeouts. "Quantum_Computing_Quantum_Monte_Carlo.ipynb", "Template.ipynb", - # for test - "Quantum_Neuron.ipynb", ] logging.basicConfig(level=logging.INFO) From 31791736a7732a9dbf50af7305d7cacd65b87f25 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 02:59:33 +0000 Subject: [PATCH 19/37] add mock for Quantum_Neuron --- test/integ_tests/mock_utils.py | 4 ++++ test/integ_tests/textbook/Quantum_Neuron_mocks.py | 5 +++++ 2 files changed, 9 insertions(+) diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index 335872f8..9c5b72b7 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -27,6 +27,10 @@ def set_get_device_result(self, result): def set_create_quantum_task_result(self, result): self._wrapper.boto_client.create_quantum_task.return_value = result + + ### test + def set_create_job_result(self, result): + self._wrapper.boto_client.create_job.return_value = result def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index b11f81e3..d2269731 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -1,6 +1,11 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) + mocker.set_create_job_result( + { + "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" + } + ) mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) From 5702e277da4ca0d98b11164e3761de81265a7000 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 03:08:30 +0000 Subject: [PATCH 20/37] add mock for Quantum_Neuron --- test/integ_tests/mock_utils.py | 2 +- test/integ_tests/textbook/Quantum_Neuron_mocks.py | 6 +----- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index 9c5b72b7..c16e5458 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -27,7 +27,7 @@ def set_get_device_result(self, result): def set_create_quantum_task_result(self, result): self._wrapper.boto_client.create_quantum_task.return_value = result - + ### test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index d2269731..f525f4ba 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -1,11 +1,7 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_create_job_result( - { - "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" - } - ) + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) From c0c236405e80920853eb10ce69f2531aa63dc278 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 03:13:26 +0000 Subject: [PATCH 21/37] add mock for Quantum_Neuron --- test/integ_tests/mock_utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index c16e5458..a6501af0 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -28,7 +28,7 @@ def set_get_device_result(self, result): def set_create_quantum_task_result(self, result): self._wrapper.boto_client.create_quantum_task.return_value = result - ### test + # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result From b782a5990cd18bbd97b113e897034687619fde4f Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 03:33:42 +0000 Subject: [PATCH 22/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 3 +++ test/integ_tests/textbook/Quantum_Neuron_mocks.py | 2 ++ 2 files changed, 5 insertions(+) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index 523d961f..65856b67 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,6 +1,9 @@ def pre_run_inject(mock_utils): + print("This is inside default_mocks.py") + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) def post_run(tb): diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index f525f4ba..6b3f652e 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -1,4 +1,6 @@ def pre_run_inject(mock_utils): + print("This is inside Quantum_Neuron_mocks.py") + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) From b87dfe19f355cce2a6dfc5d8dc207a227495076d Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 04:33:00 +0000 Subject: [PATCH 23/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 9 +++++++-- test/integ_tests/mock_utils.py | 7 +++++++ test/integ_tests/textbook/Quantum_Neuron_mocks.py | 9 +++++++-- 3 files changed, 21 insertions(+), 4 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index 65856b67..57886ca8 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,9 +1,14 @@ def pre_run_inject(mock_utils): print("This is inside default_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) + mocker.set_create_job_result( + { + "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" + } + ) + mocker.__iter__.return_value = [] def post_run(tb): diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index a6501af0..b32d3509 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -21,6 +21,10 @@ def __init__(self): tracker = braket.tracking.Tracker().start() tracker.qpu_tasks_cost.return_value = 0 tracker.simulator_tasks_cost.return_value = 0 + + # test + def __iter__(self): + return iter(self.list) def set_get_device_result(self, result): self._wrapper.boto_client.get_device.return_value = result @@ -31,6 +35,7 @@ def set_create_quantum_task_result(self, result): # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result + def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result @@ -114,6 +119,8 @@ def __init__(self): self.boto_client.get_authorization_token.return_value = { "authorizationData": [{"authorizationToken": "TestToken"}] } + def __iter__(self): + return iter(self.list) class Boto3SessionAllWrapper(SessionWrapper): diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index 6b3f652e..657b33a8 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -1,9 +1,14 @@ def pre_run_inject(mock_utils): print("This is inside Quantum_Neuron_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) + mocker.set_create_job_result( + { + "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" + } + ) + mocker.__iter__.return_value = [] mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) From d8a2ffd3869c398bc10db2024e41a76210b9b6e6 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 04:33:26 +0000 Subject: [PATCH 24/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 8 ++------ test/integ_tests/mock_utils.py | 4 ++-- test/integ_tests/textbook/Quantum_Neuron_mocks.py | 8 ++------ 3 files changed, 6 insertions(+), 14 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index 57886ca8..b70c1167 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,13 +1,9 @@ def pre_run_inject(mock_utils): print("This is inside default_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_create_job_result( - { - "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" - } - ) + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) mocker.__iter__.return_value = [] diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index b32d3509..294f0b23 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -21,7 +21,7 @@ def __init__(self): tracker = braket.tracking.Tracker().start() tracker.qpu_tasks_cost.return_value = 0 tracker.simulator_tasks_cost.return_value = 0 - + # test def __iter__(self): return iter(self.list) @@ -35,7 +35,6 @@ def set_create_quantum_task_result(self, result): # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result - def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result @@ -119,6 +118,7 @@ def __init__(self): self.boto_client.get_authorization_token.return_value = { "authorizationData": [{"authorizationToken": "TestToken"}] } + def __iter__(self): return iter(self.list) diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index 657b33a8..05c716a2 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -1,13 +1,9 @@ def pre_run_inject(mock_utils): print("This is inside Quantum_Neuron_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_create_job_result( - { - "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" - } - ) + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) mocker.__iter__.return_value = [] mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) From 9b59414058967863ed377be89ef78045fa731814 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 04:54:51 +0000 Subject: [PATCH 25/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 1 - 1 file changed, 1 deletion(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index b70c1167..65856b67 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -4,7 +4,6 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) - mocker.__iter__.return_value = [] def post_run(tb): From a7e55431e81f8f292ef97c0cf1729377297d3986 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 05:14:26 +0000 Subject: [PATCH 26/37] add mock for Quantum_Neuron --- test/integ_tests/mock_utils.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index 294f0b23..68efceb7 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -35,6 +35,7 @@ def set_create_quantum_task_result(self, result): # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result + self._wrapper.boto_client.create_job.__iter__.return_value = [] def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result From e0cfbc83e11c069130989158db721ffa838d9226 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 06:09:34 +0000 Subject: [PATCH 27/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 1 + test/integ_tests/mock_utils.py | 13 +++++-------- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index 65856b67..f720da2f 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -3,6 +3,7 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) + mocker.set_get_default_jobs_role() mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index 68efceb7..01a92fa6 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -22,10 +22,6 @@ def __init__(self): tracker.qpu_tasks_cost.return_value = 0 tracker.simulator_tasks_cost.return_value = 0 - # test - def __iter__(self): - return iter(self.list) - def set_get_device_result(self, result): self._wrapper.boto_client.get_device.return_value = result @@ -35,7 +31,10 @@ def set_create_quantum_task_result(self, result): # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result - self._wrapper.boto_client.create_job.__iter__.return_value = [] + + # test + def set_get_default_jobs_role(self): + self._wrapper.boto_client.get_default_jobs_role.return_value = mock.Mock() def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result @@ -120,14 +119,12 @@ def __init__(self): "authorizationData": [{"authorizationToken": "TestToken"}] } - def __iter__(self): - return iter(self.list) - class Boto3SessionAllWrapper(SessionWrapper): def __init__(self): super().__init__() boto3.Session = self + print("inside Boto3SessionAllWrapeper constructor") def __call__(self, *args, **kwargs): return self From 4a3ce2a161b4483b7441cdd59bdba46840aaa510 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 06:23:55 +0000 Subject: [PATCH 28/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 10 +++++++--- test/integ_tests/mock_utils.py | 6 +++--- test/integ_tests/textbook/Quantum_Neuron_mocks.py | 8 ++++++-- 3 files changed, 16 insertions(+), 8 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index f720da2f..400b93cf 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,10 +1,14 @@ def pre_run_inject(mock_utils): print("This is inside default_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_get_default_jobs_role() - mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) + mocker.set_get_default_jobs_role('arn:aws:iam::000000:role/service-role/TestRole') + mocker.set_create_job_result( + { + "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" + } + ) def post_run(tb): diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index 01a92fa6..b30f1ef3 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -31,10 +31,10 @@ def set_create_quantum_task_result(self, result): # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result - + # test - def set_get_default_jobs_role(self): - self._wrapper.boto_client.get_default_jobs_role.return_value = mock.Mock() + def set_get_default_jobs_role(self, result): + self._wrapper.boto_client.get_default_jobs_role.return_value = result def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index 05c716a2..a7945a93 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -3,8 +3,12 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) - mocker.__iter__.return_value = [] + mocker.set_get_default_jobs_role('arn:aws:iam::000000:role/service-role/TestRole') + mocker.set_create_job_result( + { + "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" + } + ) mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) From 853bd96fa18e85daccdce46f0da210d842240c77 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 06:24:41 +0000 Subject: [PATCH 29/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 10 +++------- test/integ_tests/mock_utils.py | 2 +- test/integ_tests/textbook/Quantum_Neuron_mocks.py | 8 ++------ 3 files changed, 6 insertions(+), 14 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index 400b93cf..bf1117cd 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,14 +1,10 @@ def pre_run_inject(mock_utils): print("This is inside default_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_get_default_jobs_role('arn:aws:iam::000000:role/service-role/TestRole') - mocker.set_create_job_result( - { - "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" - } - ) + mocker.set_get_default_jobs_role("arn:aws:iam::000000:role/service-role/TestRole") + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) def post_run(tb): diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index b30f1ef3..2688ddc6 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -31,7 +31,7 @@ def set_create_quantum_task_result(self, result): # test def set_create_job_result(self, result): self._wrapper.boto_client.create_job.return_value = result - + # test def set_get_default_jobs_role(self, result): self._wrapper.boto_client.get_default_jobs_role.return_value = result diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py index a7945a93..5094e07a 100644 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron_mocks.py @@ -3,12 +3,8 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_get_default_jobs_role('arn:aws:iam::000000:role/service-role/TestRole') - mocker.set_create_job_result( - { - "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" - } - ) + mocker.set_get_default_jobs_role("arn:aws:iam::000000:role/service-role/TestRole") + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) From 8543c76b0e056a27a3e6e1ee6b1c94ee65c3e1c4 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 06:39:45 +0000 Subject: [PATCH 30/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index bf1117cd..d6caf7fa 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,10 +1,14 @@ def pre_run_inject(mock_utils): print("This is inside default_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_get_default_jobs_role("arn:aws:iam::000000:role/service-role/TestRole") - mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) + mocker.set_get_default_jobs_role('arn:aws:iam::000000:role/service-role/AmazonBraketJobsExecutionRole') + mocker.set_create_job_result( + { + "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" + } + ) def post_run(tb): From b179e6c47c18d5d071258170ad5bc97ca9919f21 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Sat, 12 Aug 2023 06:39:59 +0000 Subject: [PATCH 31/37] add mock for Quantum_Neuron --- test/integ_tests/default_mocks/default_mocks.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/test/integ_tests/default_mocks/default_mocks.py b/test/integ_tests/default_mocks/default_mocks.py index d6caf7fa..c7c54d7e 100644 --- a/test/integ_tests/default_mocks/default_mocks.py +++ b/test/integ_tests/default_mocks/default_mocks.py @@ -1,14 +1,12 @@ def pre_run_inject(mock_utils): print("This is inside default_mocks.py") - + mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_get_default_jobs_role('arn:aws:iam::000000:role/service-role/AmazonBraketJobsExecutionRole') - mocker.set_create_job_result( - { - "jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN" - } + mocker.set_get_default_jobs_role( + "arn:aws:iam::000000:role/service-role/AmazonBraketJobsExecutionRole" ) + mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) def post_run(tb): From b75a080ded65d9e193ba6eb86e9d0ff4858e1fc0 Mon Sep 17 00:00:00 2001 From: Abe Coull <85974725+math411@users.noreply.github.com> Date: Tue, 15 Aug 2023 21:46:11 +0000 Subject: [PATCH 32/37] update mock files for quantum neuron --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 5 +- .../textbook/Quantum_Neuron/model.tar.gz | Bin 0 -> 878 bytes test/integ_tests/mock_utils.py | 3 + .../Quantum_Neuron/Quantum_Neuron_mocks.py | 45 +++++++++++++ .../quantum_neuron_mock_results.json | 60 ++++++++++++++++++ .../textbook/Quantum_Neuron_mocks.py | 12 ---- 6 files changed, 110 insertions(+), 15 deletions(-) create mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz create mode 100644 test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py create mode 100644 test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json delete mode 100644 test/integ_tests/textbook/Quantum_Neuron_mocks.py diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index 265a0860..a63b0897 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -509,10 +509,9 @@ "outputs": [], "source": [ "# Run on SV1\n", - "\n", "sv1_job = AwsQuantumJob.create(\n", " device=sv1,\n", - " source_module=\"/home/ec2-user/SageMaker/amazon-braket-algorithm-library/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py\",\n", + " source_module=\"../../../src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py\",\n", " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", " image_uri=image_uri,\n", " entry_point=\"quantum_neuron:main\",\n", @@ -600,7 +599,7 @@ "\n", "ionq_job = AwsQuantumJob.create(\n", " device=ionq,\n", - " source_module=\"/home/ec2-user/SageMaker/amazon-braket-algorithm-library/src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py\",\n", + " source_module=\"../../../src/braket/experimental/algorithms/quantum_neuron/quantum_neuron.py\",\n", " job_name=\"qn-job-\" + interface + \"-\" + str(int(time.time())),\n", " image_uri=image_uri,\n", " entry_point=\"quantum_neuron:main\",\n", diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8e66c60901b12f9b87e10e820b21d6c6c405a9b4 GIT binary patch literal 878 zcmV-!1Cjh6iwFqE@Y`ep|7~w%Wo#~VVR8WNR!xuFHW2lBe}&+4>Ttd|!vY0*D2g5n z^jH*u;#E^8YkOhI#Rf(Gdmp{ontKR(N`N+efGv?T@!_Xwyq!*~ z&w})bPd!r-y}s9eN=&>O9#&rf=Xn`V2*3I|!7=QY-G2Ixa$yq7EE{wD3*D?b{`WXd z^Z9O>H*e?T;d8~Pn>y!QpX8R>X9atb6{+Uzc%!=imEb<4FS-A>$J=SXAGgyd{Qk}U zAH`oc!?1pR8sAOJFWWz+{rGqhtiK(q1-8SupV0c~vw3@bJ-@mgmvM7Ho#x%VOt-Jl zcj;QccpUO)wHyz16s^(qq4uw<#}B*h0?T-Me+{rbo)626Hl>f_$HSYusrEc|EaUuc zn9uwDqa@Xs>Nyo+9Q=5S{hYgofrd>1~$|zDPtyf>?R}w zGjhugxihWbj-@=?Z78b3AKXZpAm}DTb&&WY}y@A6~|C`6-G3y zqa-BU6;}7ssvIA$ZVK5+f{3)84%-Ih&Vt%YhBjN?YDO%G553_2yI6jEc6|PLJmGAs zC*b|vxH~M?ZU6uP literal 0 HcmV?d00001 diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index 2688ddc6..cc1d62f4 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -35,6 +35,9 @@ def set_create_job_result(self, result): # test def set_get_default_jobs_role(self, result): self._wrapper.boto_client.get_default_jobs_role.return_value = result + + def set_get_job_result(self, result): + self._wrapper.boto_client.get_job.return_value = result def set_get_quantum_task_result(self, result): self._wrapper.boto_client.get_quantum_task.return_value = result diff --git a/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py new file mode 100644 index 00000000..5146129b --- /dev/null +++ b/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py @@ -0,0 +1,45 @@ +import tarfile + + +def pre_run_inject(mock_utils): + mocker = mock_utils.Mocker() + mock_utils.mock_default_device_calls(mocker) + mocker.set_search_result([ + { + "Roles" : [ + { + "RoleName": "AmazonBraketJobsExecutionRole", + "Arn" : "TestRoleARN" + } + ] + } + ]) + mocker.set_create_job_result({ + "jobArn" : f"arn:aws:braket:{mocker.region_name}:000000:job/testJob" + }) + mocker.set_get_job_result({ + "instanceConfig" : { + "instanceCount" : 1 + }, + "jobName": "testJob", + "status": "COMPLETED", + "outputDataConfig": { + "s3Path" : "s3://amazon-br-invalid-path/test-path/test-results" + }, + "checkpointConfig": { + "s3Uri" : "s3://amazon-br-invalid-path/test-path/test-results" + } + }) + mocker.set_log_streams_result({ + "logStreams": [] + }) + mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_mock_results.json", __file__)) + default_job_results = mock_utils.read_file("quantum_neuron_mock_results.json", __file__) + with open("results.json", "w") as f: + f.write(default_job_results) + with tarfile.open("model.tar.gz", "w:gz") as tar: + tar.add("results.json") + + +def post_run(tb): + pass diff --git a/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json b/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json new file mode 100644 index 00000000..20e5ea1e --- /dev/null +++ b/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json @@ -0,0 +1,60 @@ +{ + "braketSchemaHeader": { + "name": "braket.jobs_data.persisted_job_data", + "version": "1" + }, + "dataDictionary": { + "counts": 10, + "angles": 0, + "task summary": "successfully tested", + "estimated cost": 0, + "params": [ + 0.318286378384603, + 0.8066883422428826, + 0.9965059377813476, + 0.3896290997335934, + 0.5206564140072295, + -0.2764708825453678, + -0.31186280728130517, + 1.0301286608615072, + 0.9152848732773509, + 0.5028883778151009, + -0.08787270522674204, + 0.7817302047193129, + 0.9277263943430585, + 0.013617062714961346, + 0.33473964459716515, + 0.5093557157601054, + -0.10513831465073813, + 0.7394344226370994, + 0.7317135947685797, + 0.22689351139220243, + 0.6120112028390869, + 0.12146385313274964, + 1.0822225752513248, + -0.03458224708388502, + -0.1581787215562068, + 0.6144033545499605, + -0.03156199169778191, + 0.9605311859582252, + 0.29158765472875725, + 0.4800667308210175, + 0.5278158981111709, + 0.2207241644995396, + -0.018214728388751607, + 1.0549851014368496, + 0.454472915580011, + 0.6728275933353882, + 0.5217854000399934, + 0.39243334991421674, + 0.9821097084351791, + 0.5170651734719544, + 0.7873812585011286, + 0.8900537481277946, + 0.21275468530086444, + 0.9275566358136947, + 0.39455123195247166 + ] + }, + "dataFormat": "plaintext" +} \ No newline at end of file diff --git a/test/integ_tests/textbook/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron_mocks.py deleted file mode 100644 index 5094e07a..00000000 --- a/test/integ_tests/textbook/Quantum_Neuron_mocks.py +++ /dev/null @@ -1,12 +0,0 @@ -def pre_run_inject(mock_utils): - print("This is inside Quantum_Neuron_mocks.py") - - mocker = mock_utils.Mocker() - mock_utils.mock_default_device_calls(mocker) - mocker.set_get_default_jobs_role("arn:aws:iam::000000:role/service-role/TestRole") - mocker.set_create_job_result({"jobArn": "arn:aws:braket:us-east-1:000000:job/TestARN"}) - mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_results.json", __file__)) - - -def post_run(tb): - pass From db6f157966885f8009814ab751ccb29db332370e Mon Sep 17 00:00:00 2001 From: Abe Coull <85974725+math411@users.noreply.github.com> Date: Wed, 16 Aug 2023 23:32:02 +0000 Subject: [PATCH 33/37] update mock results.json --- .../textbook/Quantum_Neuron/model.tar.gz | Bin 878 -> 814 bytes .../quantum_neuron_mock_results.json | 102 +++++++++--------- 2 files changed, 49 insertions(+), 53 deletions(-) diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz index 8e66c60901b12f9b87e10e820b21d6c6c405a9b4..9fef3c35279091093cbbe96ea89155deba15a27e 100644 GIT binary patch literal 814 zcmV+}1JV2+iwFpAT-{^>|7~w%Wo#~VVR8WNmS2k-HxR)6e4oPjIbCZ;n$gG*2qYK9`PM)Xbcp;K@9EW{|yIfOG7T7|3h=J2bRdnlD-ZyKbL`>$poFnfGt< z|0sW6ESIaxKE6rgPrIws#=DDPwOM9KW_5~f(*O6fn%CXsu-(ToHrJ^i4#SxCTOFH* zR!{z3^e)S~Q(gxv9lXtwRi5+Wup3np``;fb8L!e9w@2MhM}N5=&6vi}li7a`9(^EU z*i7l zfgM|~2QYdrnd?QT{gr|>9*q$D`C20`ABwyUAc(H8Sk2JmW}A3w(}l%81e-gzae)IB z218zm4)Y$wR2&*@Fh&IQRJ?aY+IA#b;zih1E%y^*|?pf{6fqmVLe+E9$Qs>Np?yW${0P%kt>m3g2d=7lCvg914U zWI=se_`?MX8a^_@njjwLiX4NRl9SahfS*>xtmbGoIaH%ep$EMo7rdsK7xFj{3p7^4 zO@sz=#)%a907m86?_NU(R$LiV1ah7NYoR!R!qb}eqDBTaQ1`Kgg%C8w_2jxa3p|SH z7>75@;oP?K>Yik=KW*Y~!{)AyY&M&HdUx2R_1kkijpz28;n1FsaqRkaY~vr@X}xcu z*kjsfxa!711zM&vm%cy1@PSp6@cEBFy!!s-&o5t0tBV=8kM>G8X?M=8YP&!8alGqh zxn$_k)XT&1sBQ3rE1Wdu!Tj5cLfz4ZDR52rER sjH`>=`tnk#R4SE9rBbO>DwRs5QmIrbl}e>jsZ?hC1?LFSCjck_0Cr5B82|tP literal 878 zcmV-!1Cjh6iwFqE@Y`ep|7~w%Wo#~VVR8WNR!xuFHW2lBe}&+4>Ttd|!vY0*D2g5n z^jH*u;#E^8YkOhI#Rf(Gdmp{ontKR(N`N+efGv?T@!_Xwyq!*~ z&w})bPd!r-y}s9eN=&>O9#&rf=Xn`V2*3I|!7=QY-G2Ixa$yq7EE{wD3*D?b{`WXd z^Z9O>H*e?T;d8~Pn>y!QpX8R>X9atb6{+Uzc%!=imEb<4FS-A>$J=SXAGgyd{Qk}U zAH`oc!?1pR8sAOJFWWz+{rGqhtiK(q1-8SupV0c~vw3@bJ-@mgmvM7Ho#x%VOt-Jl zcj;QccpUO)wHyz16s^(qq4uw<#}B*h0?T-Me+{rbo)626Hl>f_$HSYusrEc|EaUuc zn9uwDqa@Xs>Nyo+9Q=5S{hYgofrd>1~$|zDPtyf>?R}w zGjhugxihWbj-@=?Z78b3AKXZpAm}DTb&&WY}y@A6~|C`6-G3y zqa-BU6;}7ssvIA$ZVK5+f{3)84%-Ih&Vt%YhBjN?YDO%G553_2yI6jEc6|PLJmGAs zC*b|vxH~M?ZU6uP diff --git a/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json b/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json index 20e5ea1e..7439d94c 100644 --- a/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json +++ b/test/integ_tests/textbook/Quantum_Neuron/quantum_neuron_mock_results.json @@ -1,60 +1,56 @@ { "braketSchemaHeader": { - "name": "braket.jobs_data.persisted_job_data", - "version": "1" + "name": "braket.jobs_data.persisted_job_data", + "version": "1" }, "dataDictionary": { - "counts": 10, - "angles": 0, - "task summary": "successfully tested", - "estimated cost": 0, - "params": [ - 0.318286378384603, - 0.8066883422428826, - 0.9965059377813476, - 0.3896290997335934, - 0.5206564140072295, - -0.2764708825453678, - -0.31186280728130517, - 1.0301286608615072, - 0.9152848732773509, - 0.5028883778151009, - -0.08787270522674204, - 0.7817302047193129, - 0.9277263943430585, - 0.013617062714961346, - 0.33473964459716515, - 0.5093557157601054, - -0.10513831465073813, - 0.7394344226370994, - 0.7317135947685797, - 0.22689351139220243, - 0.6120112028390869, - 0.12146385313274964, - 1.0822225752513248, - -0.03458224708388502, - -0.1581787215562068, - 0.6144033545499605, - -0.03156199169778191, - 0.9605311859582252, - 0.29158765472875725, - 0.4800667308210175, - 0.5278158981111709, - 0.2207241644995396, - -0.018214728388751607, - 1.0549851014368496, - 0.454472915580011, - 0.6728275933353882, - 0.5217854000399934, - 0.39243334991421674, - 0.9821097084351791, - 0.5170651734719544, - 0.7873812585011286, - 0.8900537481277946, - 0.21275468530086444, - 0.9275566358136947, - 0.39455123195247166 - ] + "theta_list": [ + 0.05, + 0.6972795562698698, + 0.44528521365787316, + 1.092564769927743, + 0.20436116079311356, + 0.8516407170629834, + 0.5996463744509868, + 1.2469259307208567, + 0.08464765739182245, + 0.7319272136616922, + 0.4799328710496956, + 1.1272124273195654, + 0.23900881818493597, + 0.8862883744548058, + 0.6342940318428092, + 1.281573588112679 + ], + "q_theta_list": [ + 0.0, + 0.5843738968484468, + 0.20001073679725934, + 1.2982434522597153, + 0.0, + 0.8940954595312877, + 0.4959085508631171, + 1.4614697276429123, + 0.0, + 0.668964074268407, + 0.27054976297857297, + 1.3328552019646882, + 0.10332588178831384, + 0.8821547596528411, + 0.5135859096310333, + 1.419463689817681 + ], + "task summary": { + "arn:aws:braket:::device/quantum-simulator/amazon/dm1": { + "shots": 1600, + "tasks": { + "COMPLETED": 16 + }, + "execution_duration": 0.235, + "billed_execution_duration": 48.0 + } + }, + "estimated cost": 0.06 }, "dataFormat": "plaintext" } \ No newline at end of file From 816eb0b3dfcee9886b02a5258f3a1d51a7347105 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Thu, 17 Aug 2023 00:47:23 +0000 Subject: [PATCH 34/37] add mock for Quantum_Neuron --- test/integ_tests/mock_utils.py | 2 +- .../Quantum_Neuron/Quantum_Neuron_mocks.py | 45 +++++++------------ 2 files changed, 18 insertions(+), 29 deletions(-) diff --git a/test/integ_tests/mock_utils.py b/test/integ_tests/mock_utils.py index cc1d62f4..b0595bfc 100644 --- a/test/integ_tests/mock_utils.py +++ b/test/integ_tests/mock_utils.py @@ -35,7 +35,7 @@ def set_create_job_result(self, result): # test def set_get_default_jobs_role(self, result): self._wrapper.boto_client.get_default_jobs_role.return_value = result - + def set_get_job_result(self, result): self._wrapper.boto_client.get_job.return_value = result diff --git a/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py b/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py index 5146129b..6c0f2bf5 100644 --- a/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py +++ b/test/integ_tests/textbook/Quantum_Neuron/Quantum_Neuron_mocks.py @@ -4,36 +4,25 @@ def pre_run_inject(mock_utils): mocker = mock_utils.Mocker() mock_utils.mock_default_device_calls(mocker) - mocker.set_search_result([ + mocker.set_search_result( + [{"Roles": [{"RoleName": "AmazonBraketJobsExecutionRole", "Arn": "TestRoleARN"}]}] + ) + mocker.set_create_job_result( + {"jobArn": f"arn:aws:braket:{mocker.region_name}:000000:job/testJob"} + ) + mocker.set_get_job_result( { - "Roles" : [ - { - "RoleName": "AmazonBraketJobsExecutionRole", - "Arn" : "TestRoleARN" - } - ] + "instanceConfig": {"instanceCount": 1}, + "jobName": "testJob", + "status": "COMPLETED", + "outputDataConfig": {"s3Path": "s3://amazon-br-invalid-path/test-path/test-results"}, + "checkpointConfig": {"s3Uri": "s3://amazon-br-invalid-path/test-path/test-results"}, } - ]) - mocker.set_create_job_result({ - "jobArn" : f"arn:aws:braket:{mocker.region_name}:000000:job/testJob" - }) - mocker.set_get_job_result({ - "instanceConfig" : { - "instanceCount" : 1 - }, - "jobName": "testJob", - "status": "COMPLETED", - "outputDataConfig": { - "s3Path" : "s3://amazon-br-invalid-path/test-path/test-results" - }, - "checkpointConfig": { - "s3Uri" : "s3://amazon-br-invalid-path/test-path/test-results" - } - }) - mocker.set_log_streams_result({ - "logStreams": [] - }) - mocker.set_task_result_return(mock_utils.read_file("quantum_neuron_mock_results.json", __file__)) + ) + mocker.set_log_streams_result({"logStreams": []}) + mocker.set_task_result_return( + mock_utils.read_file("quantum_neuron_mock_results.json", __file__) + ) default_job_results = mock_utils.read_file("quantum_neuron_mock_results.json", __file__) with open("results.json", "w") as f: f.write(default_job_results) From a23f72b4b29015978162e5e8e75bd7393c43e08d Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Tue, 22 Aug 2023 03:31:33 +0000 Subject: [PATCH 35/37] run QPU --- .../Quantum_Neuron/Quantum_Neuron.ipynb | 31 +++++------------- .../textbook/Quantum_Neuron/model.tar.gz | Bin 814 -> 0 bytes 2 files changed, 8 insertions(+), 23 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index a63b0897..754a3267 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -330,6 +330,7 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", + " [1. 0. 1. 1. 0. 0.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -355,14 +356,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 0.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", @@ -385,13 +378,6 @@ " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", - " [1. 0. 1. 1. 0. 1.]\n", " [1. 0. 1. 1. 0. 1.]]\n" ] } @@ -435,7 +421,7 @@ "output_type": "stream", "text": [ "theta: 1.1272124273195654\n", - "q_theta: 1.4110057479590656\n" + "q_theta: 1.3944724879791448\n" ] } ], @@ -532,7 +518,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "RUNNING\n" + "QUEUED\n" ] } ], @@ -552,7 +538,7 @@ "output_type": "stream", "text": [ "SV1 Task Summary\n", - "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.793, 'billed_execution_duration': 48.0}}\n", + "{'arn:aws:braket:::device/quantum-simulator/amazon/sv1': {'shots': 1600, 'tasks': {'COMPLETED': 16}, 'execution_duration': 0.483, 'billed_execution_duration': 48.0}}\n", "Note: Charges shown are estimates based on your Amazon Braket simulator. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n", "Estimated cost to run the job with SV1: 0.06 USD\n" ] @@ -605,14 +591,13 @@ " entry_point=\"quantum_neuron:main\",\n", " copy_checkpoints_from_job=None,\n", " hyperparameters=hyperparameters,\n", - " # input_data=\"inputs.txt\",\n", " wait_until_complete=False\n", ")" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": { "tags": [] }, @@ -621,7 +606,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "QUEUED\n" + "COMPLETED\n" ] } ], @@ -661,14 +646,14 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 24, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz deleted file mode 100644 index 9fef3c35279091093cbbe96ea89155deba15a27e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 814 zcmV+}1JV2+iwFpAT-{^>|7~w%Wo#~VVR8WNmS2k-HxR)6e4oPjIbCZ;n$gG*2qYK9`PM)Xbcp;K@9EW{|yIfOG7T7|3h=J2bRdnlD-ZyKbL`>$poFnfGt< z|0sW6ESIaxKE6rgPrIws#=DDPwOM9KW_5~f(*O6fn%CXsu-(ToHrJ^i4#SxCTOFH* zR!{z3^e)S~Q(gxv9lXtwRi5+Wup3np``;fb8L!e9w@2MhM}N5=&6vi}li7a`9(^EU z*i7l zfgM|~2QYdrnd?QT{gr|>9*q$D`C20`ABwyUAc(H8Sk2JmW}A3w(}l%81e-gzae)IB z218zm4)Y$wR2&*@Fh&IQRJ?aY+IA#b;zih1E%y^*|?pf{6fqmVLe+E9$Qs>Np?yW${0P%kt>m3g2d=7lCvg914U zWI=se_`?MX8a^_@njjwLiX4NRl9SahfS*>xtmbGoIaH%ep$EMo7rdsK7xFj{3p7^4 zO@sz=#)%a907m86?_NU(R$LiV1ah7NYoR!R!qb}eqDBTaQ1`Kgg%C8w_2jxa3p|SH z7>75@;oP?K>Yik=KW*Y~!{)AyY&M&HdUx2R_1kkijpz28;n1FsaqRkaY~vr@X}xcu z*kjsfxa!711zM&vm%cy1@PSp6@cEBFy!!s-&o5t0tBV=8kM>G8X?M=8YP&!8alGqh zxn$_k)XT&1sBQ3rE1Wdu!Tj5cLfz4ZDR52rER sjH`>=`tnk#R4SE9rBbO>DwRs5QmIrbl}e>jsZ?hC1?LFSCjck_0Cr5B82|tP From 6a4ca9fd784fe9d9c9bf5046199f65e15d0bfb23 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Tue, 22 Aug 2023 04:26:15 +0000 Subject: [PATCH 36/37] run QPU --- .../textbook/Quantum_Neuron/Quantum_Neuron.ipynb | 5 +++-- notebooks/textbook/Quantum_Neuron/model.tar.gz | Bin 0 -> 682 bytes 2 files changed, 3 insertions(+), 2 deletions(-) create mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz diff --git a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb index 754a3267..9d7c2367 100644 --- a/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb +++ b/notebooks/textbook/Quantum_Neuron/Quantum_Neuron.ipynb @@ -646,14 +646,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 27, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHICAYAAACoOCtxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABmV0lEQVR4nO3deVxU5f4H8M8MMDOAssmiGK4pigYupLkFGIZLmmZp6hWXXCq9Zd5KrRtIm0tm+kvT9JZaae5rKkoqpmKZGJobaZJ4VXBDQJZhmef3B5fJkQHmjLMxfN6v17yKM8855zuHkfnOc57n+8iEEAJEREREdkpu7QCIiIiIzInJDhEREdk1JjtERERk15jsEBERkV1jskNERER2jckOERER2TUmO0RERGTXmOwQERGRXWOyQ0RERHaNyQ7VWKNHj0aTJk2scu6ZM2dCJpNZ5dw1UXh4OMLDwy1+3pUrV0Imk+H48eMWPzcR2Q4mO2Q2X3zxBWQyGTp37mz0Ma5du4aZM2ciJSXFdIEZKD8/HzNnzkRiYqLFz10VmUym91G/fn2rxnX27FnMnDkTf/31l1XjsKYffvgBvXv3Rr169aBSqdCyZUu89dZbuHPnjrVD07Fr1y7MnDnT2mHoVf5+/vTTTys8x+SVjMVkh8xm9erVaNKkCY4dO4aLFy8adYxr164hLi5Ob7KzfPlypKamPmSUlcvPz0dcXJzeZOff//43CgoKzHbu6vTq1QvffvutzmPx4sVWiwcoS3bi4uL0Jjt79+7F3r17LR+UBb355pvo378/MjIyMG3aNCxatAiRkZH4/PPP0a5dO1y4cMHaIWrt2rULcXFx1g6jSp988gny8/OtHQbZCUdrB0D2KS0tDUlJSdi8eTMmTpyI1atXIzY21qTncHJyMunxpHB0dISjo/X++bRs2RL/+Mc/rHZ+qRQKhbVDMKvvv/8en376KYYOHYrVq1fDwcFB+9zo0aMRERGBF154AcePH7fq+6amaNeuHVJSUrB06VJMnTrV2uFACIHCwkI4OztbOxQyliAygw8++EB4enoKtVotXnnlFdGiRQu97bKyssSUKVNE48aNhUKhEA0bNhQjR44UN2/eFAcOHBAAKjxWrFghhBBi1KhRonHjxkIIIYqKioSnp6cYPXp0hXNkZ2cLpVIp/vWvfwkhhFCr1eK9994THTp0EG5ubsLFxUV0795d7N+/X7tPWlqa3nPHxsYKIYSIjY0VD/7zKS4uFu+//75o1qyZUCgUonHjxmLGjBmisLBQp13jxo1Fv379xKFDh8Tjjz8ulEqlaNq0qVi1apVB1xaAmDRpUqXP339d7qcv5vJjbdmyRbRp00YoFAoRFBQkdu/eXWH///73v2Ls2LGiQYMGQqFQiCZNmoiXX35ZqNVqsWLFCr3X68CBA0IIIcLCwkRYWJjO8TIzM8XYsWOFr6+vUCqVIjg4WKxcuVKnTfnv4ZNPPhFffvml9tqGhoaKY8eOVXutyuM6ePCgmDBhgvDy8hJ169YVI0eOFHfu3NG2i46OFvXq1RNFRUUVjtGrVy/RsmXLKs8TGBgoPD09RXZ2tt7n4+LiBACxbt067bbGjRuLUaNGVWj74LUy5P0qhOHXatSoUXp/V0II7b+58t/bg8cu/7dXfhxXV1dx+fJl0a9fP+Hq6ir8/f3FokWLhBBCnDp1SkRERAgXFxfRqFEjsXr16iqvYbny92TPnj2Fn5+fyM/P1z5X/vv89ddfdfY5d+6cGDx4sPD09BRKpVJ07NhRbNu2TaeNvvf//cdMS0vTbiv/NxofHy86duwolEql+Oyzz4QQQvz555/i+eefF56ensLZ2Vl07txZ/PDDDzrHLL+O69atEx9++KFo2LChUCqVomfPnuLChQsGXQcyLd7GIrNYvXo1nnvuOSgUCgwbNgwXLlzAr7/+qtPm3r176NGjBz7//HM8/fTTWLhwIV5++WWcP38e//3vf9G6dWu8//77AIAJEyZob9c8+eSTFc7n5OSEQYMGYevWrSgqKtJ5buvWrVCr1XjxxRcBADk5OfjPf/6D8PBwzJkzBzNnzsTNmzcRFRWlvV3m4+ODJUuWAAAGDRqkPfdzzz1X6WseN24cYmJi0KFDB3z22WcICwvDrFmztOe938WLF/H888+jV69e+PTTT+Hp6YnRo0fjzJkzBl3fwsJC3Lp1S+ehVqsN2vdBhw8fxquvvooXX3wRc+fORWFhIQYPHozbt29r21y7dg2dOnXC2rVrMXToUPzf//0fRo4ciYMHDyI/Px9PPvkkXnvtNQDAO++8o71erVu31nvOgoIChIeH49tvv8WIESPwySefwN3dHaNHj8bChQsrtF+zZg0++eQTTJw4ER9++CH++usvPPfccyguLjboNU6ePBnnzp3DzJkzER0djdWrV2PgwIEQQgAARo4cidu3b2PPnj06+2VkZGD//v1V9qJduHABqampePbZZ+Hm5qa3TXR0NABgx44dBsV7P0Per/er7lpNnDgRvXr1AgCd26DGKC0tRZ8+fRAQEIC5c+eiSZMmmDx5MlauXInevXsjNDQUc+bMQd26dREdHY20tDSDjz1z5kxkZmZq/x1W5syZM3jiiSdw7tw5TJ8+HZ9++ilcXV0xcOBAbNmyxajXBQCpqakYNmwYevXqhYULF6Jdu3bIzMxE165dsWfPHrz66qv46KOPUFhYiAEDBug91+zZs7Flyxa8+eabmDFjBn7++WeMGDHC6JjoIVg72yL7c/z4cQFAJCQkCCGE0Gg04pFHHhGvv/66TruYmBgBQGzevLnCMTQajRBCiF9//bXCN8pyD/Zg7NmzRwAQO3bs0GnXt29f0axZM+3PJSUlQq1W67TJysoSfn5+YuzYsdptN2/e1OnNud+D3xJTUlIEADFu3Diddm+++aYAoPMtvHHjxgKA+Omnn7Tbbty4odP7VBXo+VZ+/zWS2rOjUCjExYsXtdtOnjwpAIjPP/9cuy06OlrI5fIK36iF+Pt3tWHDBr29AkJU7K1YsGCBACC+++477baioiLRpUsXUadOHZGTkyOE+LtHoV69ejo9Mdu2bdP7u35Q+bf2jh076vTazJ07VwDQfvsvLS0VjzzyiBg6dKjO/vPnzxcymUxcunSp0nNs3bpVANB+86+Mm5ub6NChg/ZnQ3t2DH2/SrlWkyZN0tvLIbVnB4D4+OOPdeJydnYWMplMrF27Vrv9/Pnzlf5behDu67mMiIgQ9evX1/bu6OvZeeqpp8Rjjz2m04Oq0WhE165ddXqUpfbsABDx8fE6badMmSIAiEOHDmm35ebmiqZNm4omTZqI0tJSIcTf17F169Y6v7uFCxcKAOL333+v9jqQabFnh0xu9erV8PPzQ0REBICy2RVDhw7F2rVrUVpaqm23adMmhISEYNCgQRWOYcy07p49e8Lb2xvr1q3TbsvKykJCQgKGDh2q3ebg4KAdQ6LRaHDnzh2UlJQgNDQUJ06ckHxeoGzAJ4AK4wv+9a9/AQB27typsz0oKAg9evTQ/uzj44PAwEBcunTJoPM9++yzSEhI0HlERUUZFXtkZCSaN2+u/Tk4OBhubm7aWDQaDbZu3Yr+/fsjNDS0wv7G/K527dqF+vXrY9iwYdptTk5OeO2113Dv3j0cPHhQp/3QoUPh6emp/bn82hl6vSZMmKAzxuuVV16Bo6Oj9vcml8sxYsQIbN++Hbm5udp2q1evRteuXdG0adNKj13evm7dulXGULduXZ1jG0rq+/Vhr5VU48aN0/6/h4cHAgMD4erqiiFDhmi3BwYGwsPDQ3IMM2fOREZGBpYuXar3+Tt37mD//v0YMmQIcnNztb2ct2/fRlRUFC5cuICrV68a9bqaNm1a4d/Url270KlTJ3Tv3l27rU6dOpgwYQL++usvnD17Vqf9mDFjdMarmft3QZVjskMmVVpairVr1yIiIgJpaWm4ePEiLl68iM6dOyMzMxP79u3Ttv3zzz/Rtm1bk53b0dERgwcPxrZt27S3dDZv3ozi4mKdZAcAVq1aheDgYKhUKtSrVw8+Pj7YuXMnsrOzjTr35cuXIZfL8eijj+psr1+/Pjw8PHD58mWd7Y0aNapwDE9PT2RlZRl0vkceeQSRkZE6jwYNGhgVe3Wx3Lx5Ezk5OSb9XV2+fBktWrSAXK77J6j8tld116v8w9zQ69WiRQudn+vUqYMGDRrozByLjo5GQUGB9nZEamoqkpOTMXLkyCqPXZ7kVJfI5ObmwtfX16B4HyTl/fqw10oKlUoFHx8fnW3u7u545JFHKiTB7u7ukmN48sknERERgblz5+qd/Xjx4kUIIfDee+/Bx8dH51E+IeLGjRsSX1UZfQnu5cuXERgYWGG7ud63ZDpMdsik9u/fj+vXr2Pt2rVo0aKF9lH+LW/16tVmPf+LL76I3Nxc7N69GwCwfv16tGrVCiEhIdo23333HUaPHo3mzZvjq6++Qnx8PBISEtCzZ09oNJqHOr+hvRz3z9a5n/jfGBJzxHB/r5qlYjEVS8QYFBSEjh074rvvvgNQ9j5RKBQ6PRSV7QcAp06dqrTN5cuXkZOTg2bNmmm3Gfp7kvp+fZhrZar3jil/X7GxscjIyMCXX35Z4bny1//mm29W6Oksf5R/AZH62kwx86om/NuqLTgHkkxq9erV8PX11VvzZfPmzdiyZQuWLl0KZ2dnNG/eHKdPn67yeFJvkTz55JNo0KAB1q1bh+7du2P//v149913ddps3LgRzZo1w+bNm3WO/+DUeCnnbty4MTQaDS5cuKAzKDczMxN3795F48aNJb2Oh+Hp6Ym7d+9W2P7gt05D+fj4wM3NzaS/q8aNG+PUqVPQaDQ6vTvnz5/XPm9KFy5c0N5WBcoGx1+/fh19+/bVaRcdHY2pU6fi+vXrWLNmDfr166dzS0ifFi1aIDAwEFu3bsXChQv13s765ptvAAAvvPCCdltVv6f7kyJD369SVPa7Kn+tD8Zl7HvHFMLCwrSDs2NiYnSeK79OTk5OiIyMrPI49782Dw8P7XYpr61x48Z6a3uZ631LpsOeHTKZgoICbN68Gc888wyef/75Co/JkycjNzcX27dvBwAMHjwYJ0+e1DuLofybj6urK4CKf3wrI5fL8fzzz2PHjh349ttvUVJSUuEWVvm3rfu/Xf3yyy84evSoTjsXFxeDz13+oblgwQKd7fPnzwcA9OvXz6D4TaF58+bIzs7W6Wm4fv260TNT5HI5Bg4ciB07duitXGvM76pv377IyMjQGV9VUlKCzz//HHXq1EFYWJhRsVZm2bJlOjO3lixZgpKSEvTp00en3bBhwyCTyfD666/j0qVLBtcyio2NRVZWFl5++eUKPQXJycmYM2cO2rdvr3O+5s2b4+eff9aZPfjDDz/gypUrOvsb+n6VorLfVePGjeHg4ICffvpJZ/sXX3xh9LlMoXzszrJly3S2+/r6Ijw8HF9++SWuX79eYb+bN29q/798XNr9ry0vLw+rVq0yOI6+ffvi2LFjOtc+Ly8Py5YtQ5MmTbS9fGR72LNDJlM+uHPAgAF6n3/iiSfg4+OD1atXY+jQoXjrrbewceNGvPDCCxg7diw6duyIO3fuYPv27Vi6dClCQkLQvHlzeHh4YOnSpahbty5cXV3RuXPnKgeMDh06FJ9//jliY2Px2GOPVZj+/Mwzz2Dz5s0YNGgQ+vXrh7S0NCxduhRBQUG4d++etp2zszOCgoKwbt06tGzZEl5eXmjbtq3esSshISEYNWoUli1bhrt37yIsLAzHjh3DqlWrMHDgQJ1eBXN78cUXMW3aNAwaNAivvfYa8vPzsWTJErRs2dLoAdgff/wx9u7di7CwMEyYMAGtW7fG9evXsWHDBhw+fBgeHh5o164dHBwcMGfOHGRnZ0OpVKJnz556x6lMmDABX375JUaPHo3k5GQ0adIEGzduxJEjR7BgwYJqB/tKVVRUhKeeegpDhgxBamoqvvjiC3Tv3r3Ce9XHxwe9e/fGhg0b4OHhYXCSOmzYMBw/fhzz58/H2bNnMWLECHh6euLEiRP4+uuv4ePjg40bN+oUFBw3bhw2btyI3r17Y8iQIfjzzz/x3Xff6QwWBwx/v0rRsWNHAMBrr72GqKgoODg44MUXX4S7uzteeOEFfP7555DJZGjevDl++OEHo8e9mEpYWBjCwsIqDFwHgMWLF6N79+547LHHMH78eDRr1gyZmZk4evQo/vvf/+LkyZMAgKeffhqNGjXCSy+9hLfeegsODg7a3016erpBcUyfPh3ff/89+vTpg9deew1eXl5YtWoV0tLSsGnTpgpj0MiGWGkWGNmh/v37C5VKJfLy8iptM3r0aOHk5CRu3bolhBDi9u3bYvLkyaJhw4ZCoVCIRx55RIwaNUr7vBBlU2eDgoKEo6OjQVOsNRqNCAgIEADEhx9+qPf5jz/+WDRu3FgolUrRvn178cMPP+g9XlJSkujYsaNQKBQGFRWMi4sTTZs2FU5OTiIgIKDKooIP0ld4Tx9UU1RQCCH27t0r2rZtKxQKhQgMDBTfffddlUUFH6RvWvTly5dFdHS08PHxEUqlUjRr1kxMmjRJZ2rt8uXLRbNmzYSDg4NBRQXHjBkjvL29hUKhEI899liFEgP3F8rTdx2qm8r8YFFBT09PUadOHTFixAhx+/ZtvfusX79eABATJkyo8tj6bN++XURGRgoPDw9tSYA2bdpUWmzw008/1Rac69atmzh+/HiFa2Xo+1XKtSopKRH//Oc/hY+Pj5DJZDrvi5s3b4rBgwcLFxcX4enpKSZOnChOnz5daVHBB4WFhYk2bdpU2F7Z+15frPrek/cXGX2wBMKff/4poqOjRf369YWTk5No2LCheOaZZ8TGjRt12iUnJ4vOnTsLhUIhGjVqJObPn19lUUF9yosKenh4CJVKJTp16lRpUcENGzbobNc3hZ8sQyYER0oREZXbtm0bBg4ciJ9++kmnPIAxxo0bh6+++grLly/XmaJNRJbFZIeI6D7PPPMMzp07h4sXLxpVQ+h+paWlGDhwIOLj47Ft27YKA6KJyDI4ZoeICMDatWtx6tQp7Ny5EwsXLnzoRAcoG1xszBIRRGRa7NkhIkLZdOw6depg6NChWLp0KVcnJ7Ij/NdMRAQWeiOyZ5wnR0RERHaNyQ4RERHZtVp/G0uj0eDatWuoW7euSQYkEhERkfkJIZCbmwt/f/9qCzrW+mTn2rVrCAgIsHYYREREZIQrV67gkUceqbJNrU92ysvSX7lyBW5ublaOhoiIiAyRk5ODgIAAg5aXqfXJTvmtKzc3NyY7RERENYwhQ1A4QJmIiIjsGpMdIiIismtMdoiIiMiuMdkhIiIiu8Zkh4iIiOwakx0iIiKya0x2iIiIyK4x2SEiIiK7VuuLCpqCRqOBRqOxdhi1glwur3YNFCIisr6ColLsOHUNiak3cDe/GB4uTggP9EX/YH84KxwsGguTHSMJIXDz5k1kZ2ejpKTE2uHUKkqlEn5+fnB1dbV2KEREpEfC2UxM23QKd/KKdLbv+j0Ds3efx5zBwegV5GexePgV2QhCCGRmZuL27dtMdKxArVbj+vXr7E0jIrJBCWczMfHb4xUSnXJ38oow8dvj+PFspsViYrJjhJs3byIrK8vaYdRqxcXFuHHjhrXDICKi+xQUlWLaplPQiKrbaQTw9qZTKCwutUhcTHaMkJ2dbe0QCPw9EBHZmh2nrlXao/OgO3lF2H7ympkjKsMxOxJpNJoKt648PT3h7e1tpYhqj/z8fFy9elX7c/nAcA5YJiIyL0MHGyem/t3jroIa/R2OIlyeAg/k4S5ckahphx2lXVAIJQDgYOpNDAkNMHv8THYk0jdOxNvbG46OvJTm5uLiUmEbkx0iIvOSMtj4bn4xACBSnow5TstQT5ars08/h2OY7vg9phVPwI+ajsjKN6wX6GHxU4KIiIj0kjrY2MPFCZHyZHzpNL9ColOuniwXXzrNx1PyZHi6KMwW+/2Y7BAREVEFxgw2furRupjjtAwOsqp3cpAJzHVahp6P1jVhxJVjskNITEyETCbD3bt3rR0KERHZCGMGG/eX/1xpj86D6slyMcDh6MOEaDAONLEya1SYDA8PR7t27bBgwQKzHJ+IiGq++wcbG+Jg6k0McfpR0j5Ol/YBodGS9jEGkx0rsrUKk5ZWVFQEhcIy92uJiEia8sHGhsrKLwIUEmvQFdyR1t5IvI1lJdaqMDl69GgcPHgQCxcuhEwmg0wmw19//QUASE5ORmhoKFxcXNC1a1ekpqbq7Ltt2zZ06NABKpUKzZo1Q1xcnM40/PT0dDz77LOoU6cO3NzcMGTIEGRm/h3/zJkz0a5dO/znP/9B06ZNoVKp8M0336BevXpQq9U65xo4cCBGjhxp0tdORESG83BxktTe00UBOHtKO4mzl7T2RmKyYwXWrDC5cOFCdOnSBePHj8f169dx/fp1BASU1Th499138emnn+L48eNwdHTE2LFjtfsdOnQI0dHReP3113H27Fl8+eWXWLlyJT766KOyWDUaPPvss7hz5w4OHjyIhIQEXLp0CUOHDtU5/8WLF7Fp0yZs3rwZKSkpeOGFF1BaWort27dr29y4cQM7d+7UOT8REVlWeKCvpPZhgT5Ai6elnaRFL2ntjcRkxwqsWWHS3d0dCoUCLi4uqF+/PurXrw8Hh7KxQR999BHCwsIQFBSE6dOnIykpCYWFhQCAuLg4TJ8+HaNGjUKzZs3Qq1cvfPDBB/jyyy8BAPv27cPvv/+ONWvWoGPHjujcuTO++eYbHDx4EL/++qv2/EVFRfjmm2/Qvn17BAcHw9nZGcOHD8eKFSu0bb777js0atQI4eHhJnvdREQkTf9gf3i5GjbUoJ6rAgNC/IE2zwEu9Qw7gYs30HbwQ0RoOCY7VmDMoC9LCA4O1v5/gwYNAEC7/tTJkyfx/vvvo06dOtpHee9Qfn4+zp07h4CAAG0vEQAEBQXBw8MD586d025r3LgxfHx8dM47fvx47N27V1sdeeXKlRg9ejRkMpnZXisREVXNWeGAOYODIZeVVUN+wSERi50WYLXTR1jstAAvOCRCBTXkMmDO4GConBwAhQswYBEgqya9kMmBZxcBTs6WeCkcoGwNRg36sgAnp7/vz5YnGuUVo+/du4e4uDg899xzFfZTqVQGn8PV1bXCtvbt2yMkJATffPMNnn76aZw5cwY7d+6UGj4REZlYryA/bO6ZjcZHpsETOTrP9XM4hnec1uJytzlod/9kmlZ9gRfXANsmAfm3Kx7Uxbss0QnsY+bo/8ZkxwqMGvRlQgqFAqWl0sYBdejQAampqXj00Uf1Pt+6dWtcuXIFV65c0fbunD17Fnfv3kVQUFC1xx83bhwWLFiAq1evIjIyUqeHiIiIrOT8LrRLmgSg4lJJAOCJHHgmTQIaeeomL4F9gDfOAKc3ARcSymZdOXuVjdFpO9hiPTrlmOxYQXigL3b9nmFw+7BAn+obSdCkSRP88ssv+Ouvv1CnTh296309KCYmBs888wwaNWqE559/HnK5HCdPnsTp06fx4YcfIjIyEo899hhGjBiBBQsWoKSkBK+++irCwsIQGhpa7fGHDx+ON998E8uXL8c333xjipdJREQPoygf2D4ZENV8RghNWS/OG2d0kxgnZ6D9P8oeVsYxO1Zg1KAvE3rzzTfh4OCAoKAg+Pj4ID09vdp9oqKi8MMPP2Dv3r14/PHH8cQTT+Czzz5D48aNAZTd9tq2bRs8PT3x5JNPIjIyEs2aNcO6desMisnd3R2DBw9GnTp1MHDgwId5eUREZApnNuu/DaVP/u2yXhwbJRNCVDMB2nJ++uknfPLJJ0hOTsb169exZcsWgz/4jhw5grCwMLRt2xYpKSkGnzMnJwfu7u7Izs6Gm5tbte1LSkpw4cIFnW0tWrSQvOp5eZ2dqqafy2XAspGhiLTjwoL3e+qpp9CmTRv83//9n97nTXXtiYjIAOujgbPbDG8fNBAYssps4TxIyue3TfXs5OXlISQkBIsXL5a03927dxEdHY2nnnrKTJGZXq8gPywbGVppD089V0WtSXSysrKwZcsWJCYmYtKkSdYOh4hIuqJ84LfvyhKEVf3L/vvbd2Xba6oC26yGbAyb+krcp08f9OkjfXT2yy+/jOHDh8PBwQFbt241fWBmEhnkh6QWPbH95DUcTL2JrPwieLooEBbogwEh/mXT+GqB9u3bIysrC3PmzEFgYKC1wyEikub8rrKxLQ/e8jm7DUiIKZuK3aqvdWJ7GDZaDdkYNpXsGGPFihW4dOkSvvvuO3z44YfWDkcylZMDhoQGYEho7Z19VL5cBRFRjXN+F7BuROWDePNvlz3/4hqLTrU2iRZPS7uNZaFqyMawqdtYUl24cAHTp0/Hd999Z/C4DbVajZycHJ0HERGRZFJnKxUXWCYuU7HRasjGqLHJTmlpKYYPH464uDi0bNnS4P1mzZoFd3d37YP1XIiIyCh2NFtJLxuthmyMGpvs5Obm4vjx45g8eTIcHR3h6OiI999/HydPnoSjoyP279+vd78ZM2YgOztb+7hy5YqFIyciIrtwYa/E9gnmicOcyqshV9bD4+JdI27R1dgxO25ubvj99991tn3xxRfYv38/Nm7ciKZNm+rdT6lUQqlUWiJEIiKyZ3Y0W6lKNlYN2Rg2lezcu3cPFy9e1P6clpaGlJQUeHl5oVGjRpgxYwauXr2Kb775BnK5HG3bttXZ39fXFyqVqsJ2IiIik7Oj2UrVsqFqyMawqdtYx48fR/v27dG+fXsAwNSpU9G+fXvExMQAAK5fv25QtV8iIiKza/G0xPa2O1vJ3tlUBWVrsFYFZZKO156IbEpRPrCgrWGDlF28gTdOa2/5FBSVYsepa0hMvYG7+cXwcHFCeKAv+gf7w1lRO2qsPawaW0G5VrJC1c2bN2/ilVdeQaNGjaBUKlG/fn1ERUXh4MGD8Pb2xuzZs/Xu98EHH8DPzw/FxcW4fv06hg8fjpYtW0Iul2PKlClmi5eIyCYZOVsp4Wwmus3Zj7c3nsKu3zOQ9Odt7Po9A29vPIVuc/Yj4WymBYKvXZjsWNP5XWXfCrZNKivclPZT2X+3TSrbfn6XWU47ePBg/Pbbb1i1ahX++OMPbN++HeHh4cjOzsY//vEPrFixosI+QgisXLkS0dHRcHJyglqtho+PD/79738jJCTELHESEdk8ibOVytdFvJNXpLf5nbwiTPz2OH5kwmNSvI1lrdtY1VXdBMq+DZh4St/du3fh6emJxMREhIWFVXj+999/R3BwMA4dOoTu3btrtycmJiIiIgLnzp1Dq1atdPYJDw9Hu3btsGDBApPFqQ9vYxGRzSouqHa2UkFRKbrN2V9ponM/L1cFkqb3rDXLBhmDt7FsnRWrbtapUwd16tTB1q1boVarKzz/2GOP4fHHH8fXX3+ts33FihXo2rVrhUSHiIjw92ylIauAUTvK/tv+HzrTsnecumZQogOU9fBsP3nNXNHWOkx2rMGKVTcdHR2xcuVKrFq1Ch4eHujWrRveeecdnDp1StvmpZdewoYNG3Dv3j0AZQUcN27ciLFjx5osDiKi2iYx9Yak9gdTb5opktqHyY41WLnq5uDBg3Ht2jVs374dvXv3RmJiIjp06ICVK1cCAIYNG4bS0lKsX78eALBu3TrI5XIMHTrUpHEQEdUmd/OLJbXPyjesF4iqx2THGmyg6qZKpUKvXr3w3nvvISkpCaNHj0ZsbCyAsurUzz//vHag8ooVKzBkyBDUqVPH5HEQEdUWHi5Oktp7uijMFEntw2THGmyw6mZQUBDy8vK0P7/00ks4fPgwfvjhByQlJeGll14yewxERPYsPNBXUvuwQB8zRVL7cBqLNbR4umyKucHtTVd18/bt23jhhRcwduxYBAcHo27dujh+/Djmzp2LZ599VtvuySefxKOPPoro6Gi0atUKXbt2rXCslJQUAGXLfNy8eRMpKSlQKBQICgoyWbxERDWBIUUC+wf7Y/bu87iTVwQV1OjvcBTh8hR4IA934YpETTvsKO2CQihRz1WBASH+Vn5VfysoKUB8WjwOXT2EHHUO3JRu6NGwB3o37Q1nR9tfG4tTz60x9fwhqm4+LLVajZkzZ2Lv3r34888/UVxcjICAALzwwgt455134Oz893lmzZqFd955B3PnzsVbb71V4VgymazCtsaNG+Ovv/4ySawP4tRzIrJFCWczMW3TKb0zrbxcFZgzOBi9gvy0bdev/hKzHZehniy3Qvvboi6ml0zA0BETEfm/faztQPoBxCbFIktdcQiGp9ITcV3jENEowuJxSfn8ZrJTy+rs1GRMdojI1pQXCdRU8UkqlwHLRoaWJS/nd0GsGwFZFX/7hUwOmY387T+QfgBTEqdAU0W8cpkcCyMWIjwg3HKBgXV2agaJVTeJiMi2FBSVYtqmU1UmOgCgEcDbm06hMD8X2D65ykQHQNnzJq6xZoyCkgLEJsVWmegAgEZoEHMkBoUlhRaKTDp+JbamwD7AG2eqrbpJRES2R2qRwFN7VqCT1Bpr7f/xEBE+nPi0eL23rvTJUmdhd9puDGoxyMxRGYfJjrWVV9204huaiIikk1ok0PHPH6Wd4EKCVT8bDl09JKn94auHbTbZ4W0sIiIiI0gtEqgozpZ2AjPUWJMiR50jqX22WuLrsyAmO0REREaQWiSwyMld2gksUGOtKm7K6ift3M9dKfH1WRCTHSIiIiNILRJY0jxS2glMWGPNGD0a9pDUvnvD7maK5OEx2SEiIjJC/2B/eLkatqRDPVcFgqPGVD4D90Eu3mUTVayod9Pe8FQaVvHfS+WFPk1td/Ywkx0iIiIjOCscMGdwMOQV66vqkMuAOYODoXKpCwxYVFZDrSoyOfDsIqvPyHV2dEZc1zjIq4lXLpMjrmscVI4qC0UmHZMdIiIiI/UK8sOykaGV9vDUc1X8XVAQqHE11iIaRWBhxMJKe3i8VF5WKSgoFSsoW6uCMknGa09EtqqwuBTbT17DwdSbyMovgqeLAmGBPhgQ4g+Vk0PFHYoLalSNtcKSQuxO243DVw8jW50Nd6U7ujfsjj5N+1itR4fLRUhg7WTHGourjR49Gnfv3sXWrVtNdsyCggLMnj0b33//PS5fvoy6desiIiICM2fORJs2bUxyDiY7RERUTsrnNz8lrKiyxdUSLifgs+TPrLa4mlRqtRqRkZFIT0/Hp59+is6dOyMzMxOzZs1C586d8eOPP+KJJ56wdphERFRLccyOlZQvrlZZKe4sdRamJE5B4pVEs8ahVqvx2muvwdfXFyqVCt27d8evv/6qfT4xMREymQz79u1DaGgoXFxc0LVrV6SmpmrbLFiwAEePHsUPP/yAIUOGoHHjxujUqRM2bdqE1q1b46WXXkIt70AkIiIrYrJjBba0uNrbb7+NTZs2YdWqVThx4gQeffRRREVF4c4d3cqd7777Lj799FMcP34cjo6OGDt2rPa5NWvWoFevXggJCdHZRy6X44033sDZs2dx8uRJs70GIiKiqjDZsQJjFlczh7y8PCxZsgSffPIJ+vTpg6CgICxfvhzOzs746quvdNp+9NFHCAsLQ1BQEKZPn46kpCQUFpYlYX/88Qdat26t9xzl2//44w+zvAYiIqLqMNmxAmMWVzOHP//8E8XFxejWrZt2m5OTEzp16oRz587ptA0ODtb+f4MGDQAAN278vQhedbepFArDCm8RERGZGpMdK6iJi6s5Of29BoxMVlZBS6Mpuw3XokWLCslRufLtLVu2NHOERERE+jHZsQJbWVytefPmUCgUOHLkiHZbcXExfv31VwQFBRl8nGHDhuHHH3+sMC5Ho9Hgs88+Q2hoqKTjERERmRKTHSuwlcXVXF1d8corr+Ctt95CfHw8zp49i/HjxyM/Px8vvfSSwcd544030KlTJ/Tv3x8bNmxAeno6fv31VwwePBgXLlzAqlWrzBI/ERGRIVhnxwp6N+2Nz5I/M2iQsrkXV5s9ezY0Gg1GjhyJ3NxchIaGYs+ePfD0NGzxNwBQqVTYt28fZs2ahRkzZuDy5csoKSnBo48+itOnT+ORRx4xW/xERETVYQVlK1VQLq+zU9X0c7lMXiPWHNFn9+7dGDRoEObNm4fJkyeb5JisoExEROWkfH7zNpaV2MviapXp06cPdu/ejTt37uDWrVvWDoeIiGoxfiW2ovCAcOx9fq/NLa5mKhEREYiIsP3lLoiIyL4x2bEylaMKg1oMwqAWg6wdChERkV2yqdtYP/30E/r37w9/f3/IZLJqV+XevHkzevXqBR8fH7i5uaFLly7Ys2ePZYIlIiKiGsGmenby8vIQEhKCsWPH4rnnnqu2/U8//YRevXrh448/hoeHB1asWIH+/fvjl19+Qfv27c0So1xeMT+8desWvL29zXI++lt+fn6Fbfp+H0RERPez2dlYMpkMW7ZswcCBAyXt16ZNGwwdOhQxMTEGtZc6GwsALly4gJKSEklxkenJ5XIEBgZaOwwiIrICKZ/fNtWz87A0Gg1yc3Ph5eVVaRu1Wg21Wq39OSdH2tINAODu7o7bt28bFSOZjru7eSpLExGRfbGrewDz5s3DvXv3MGTIkErbzJo1C+7u7tpHQECA5PP4+PhIKrpHpufk5ARfX19rh0FERDWA3SQ7a9asQVxcHNavX1/lh+CMGTOQnZ2tfVy5ckXyuWQyGfz8/FCvXj0WtLMCpVIJf39/jtchIiKD2MUn9dq1azFu3Dhs2LABkZGRVbZVKpVQKpUPfU6ZTAZfX1/4+vpCo9FoVwAn85LL5UxyiIhIkhqf7Hz//fcYO3Ys1q5di379+lklBn4AExER6SooKUB8WjwOXT2EHHUO3JRu6NGwB3o37Q1nR2eLxmJTyc69e/dw8eJF7c9paWlISUmBl5cXGjVqhBkzZuDq1av45ptvAJTduho1ahQWLlyIzp07IyMjAwDg7OzMwatERERWciD9AGKTYisseJ1wOQGfJX+GuK5xiGhkuQr7NtUdcfz4cbRv315bI2fq1Klo3769dhr59evXkZ6erm2/bNkylJSUYNKkSWjQoIH28frrr1slfiIiotqufKHrBxOdclnqLExJnILEK4kWi8lm6+xYijF1doiIiKiigpICRG2MqjTRuZ+n0hN7n99r9DqQXPWciIiILC4+Ld6gRAco6+HZnbbbzBGVYbJDREREJnHo6iFJ7Q9fPWymSHQx2SEiIiKTyFFLW5UgW51tpkh0MdkhIiIik3BTShv76q60zMxpJjtERERkEj0a9pDUvnvD7maKRBeTHSIiIjKJ3k17w1Np2NqRXiov9Gnax8wRlWGyQ0RERCbh7OiMuK5xkMuqTi/kMjniusYZPe1cKiY7REREZDIRjSKwMGJhpT08XiovLIxYiPCAcIvFxKKCLCpIRERkcoUlhdidthuHrx5Gtjob7kp3dG/YHX2a9jFJj46Uz28mO0x2iIiIahxWUCYiIiL6HyY7REREZNeY7BAREZFdY7JDREREds3R2gEQERHVNgUlBYhPi8ehq4eQo86Bm9INPRr2QO+mveHs6Gzt8OwOZ2NxNhYREVnQgfQDiE2KRZY6q8JznkpPxHWNQ0SjCCtEVrNwNhYREZENOpB+AFMSp+hNdAAgS52FKYlTkHgl0aJx2TsmO0RERBZQUFKA2KRYaISmynYaoUHMkRgUlhRaKDL7x2SHiIjIAuLT4ivt0XlQljoLu9N2mzmi2oPJDhERkQUcunpIUvvDVw+bKZLah8kOERGRBeSocyS1z1ZnmymS2ofJDhERkQW4KaXN+HVXupspktqHyQ4REZEF9GjYQ1L77g27mymS2ofJDhERkQX0btobnkpPg9p6qbzQp2kfM0dUezDZISIisgBnR2fEdY2DXFb1R69cJkdc1zioHFUWisz+cbkIIiKih2To8g8RjSKwMGIhYo7E6J2G7qXyQlzXOIQHhFswevvH5SK4XAQR2Tmuw2Rexiz/UFhSiN1pu3H46mFkq7PhrnRH94bd0adpH/boGEjK5zeTHSY7RGTHuA6TeZUv/1BVVWS5TI6FEQvZW2NiXBuLiIi4DpOZcfmHmoPJDhGRHeIHsflx+Yeag8kOEZEd4gex+XH5h5qDyQ4RkR3iB7H5cfmHmoPJDhGRHeIHsflx+Yeag3V2iIjs0MN+EHO6evV6NOyBhMsJBrfn8g/WY1M9Oz/99BP69+8Pf39/yGQybN26tdp9EhMT0aFDByiVSjz66KNYuXKl2eMkIrJ1D7MO04H0A4jaGIWYpBgkXE7ALxm/IOFyAmKSYhC1MQoH0g+YOtwaics/1Bw2lezk5eUhJCQEixcvNqh9Wloa+vXrh4iICKSkpGDKlCkYN24c9uzZY+ZIiYhsm7EfxJyubjgu/1Bz2GxRQZlMhi1btmDgwIGVtpk2bRp27tyJ06dPa7e9+OKLuHv3LuLj4w06D4sKEpG9klrwrqCkAFEbowyaxeWp9MTe5/fyAxxA4pVELv9gBVI+v2v0mJ2jR48iMjJSZ1tUVBSmTJlS6T5qtRpqtVr7c06OtEF8REQ1xd/rML2HLPXdCs97KT0R1+197QexMdPVB7UYZMKIa6bwgHDsfX4vl3+wYTU62cnIyICfn5/ONj8/P+Tk5KCgoADOzhUH0c2aNQtxcXGWCpGIyKrC8/KxN/0qdssLcdhZhWwHB7iXlqJ7QSH6aPKgapevbWvMdHUmO2VUjioMajGI18NG1ehkxxgzZszA1KlTtT/n5OQgICDAihEREZnJ+V3AuhFQCQ0GARh0L++BBnnAuhHAi2uAwD7IKpQ2/fxO4V1TRUpkVjU62alfvz4yMzN1tmVmZsLNzU1vrw4AKJVKKJVKS4RHRGQ9RfnA9slANctFQGiAbZOAN84gP99B0iny82v0RwjVIjY1G0uqLl26YN++fTrbEhIS0KVLFytFRERkI85sBvJvG9Y2/zZwehMa3SqRdIrGEtsTWYtNJTv37t1DSkoKUlJSAJRNLU9JSUF6ejqAsltQ0dHR2vYvv/wyLl26hLfffhvnz5/HF198gfXr1+ONN96wRvhERLbjwl6J7RPQ/04GPEtLDWruVVqKZ7KuGxEYkeXZVLJz/PhxtG/fHu3btwcATJ06Fe3bt0dMTAwA4Pr169rEBwCaNm2KnTt3IiEhASEhIfj000/xn//8B1FRUVaJn4jIZhQYNqvq7/Z34CvLR9ytO5BXU5FELgTibt6BH/KrbEdkK2zqhmt4eDiqKvujrzpyeHg4fvvtNzNGRURUAzkbVlDw7/ZecPVQIeL6b1iYeQsxPl7Icqg4hsertBRxN+8gvKAAVxr4mihYIvOyqWSHiIhMpMXTwNltEtr3gl+JBti5F+EFBdh75Rp2u7pUnK6elw/V/76U1u/4jJmCJzItJjtERPaozXNAQoxhg5RdvIG2g6EQAkU/xkChzoJKCAy6l6dnunqZIqUXFCEvmDhoIvOwqTE7RERkIgoXYMAioJp1myCTA88uApycAYULFIO+gKhmHyGTQ/HcF2X7ENUATHaIiOxVq75lBQNd6ul/3sVbW1Dw/n1kL66BqGQf4eIN2YP7ENk4m10I1FK4ECgR2b3iAuD0JuBCAlBwB3D2Alr0AtoOrrx3xph9iCxIyuc3kx0mO0RERDVOrVn1nIiIqldQVIodp64hMfUG7uYXw8PFCeGBvugf7A9nhbQlIohqIiY7RER2LOFsJqZtOoU7eUU623f9noHZu89jzuBg9Arys1J0RJbBAcpERHYq4WwmJn57vEKiU+5OXhEmfnscP57N1Ps8kb1gskNEZIcKikoxbdMpaKoZlakRwNubTqGw2LA1sYhqIiY7RER2aMepa5X26DzoTl4Rtp+8ZuaIiKyHyQ4RkR1KTL0hqf3B1JtmioTI+pjsEBHZobv5xZLaZ+Ub1gtEVBMx2SEiskMeLk6S2nu6KMwUCZH1MdkhIrJD4YG+ktqHBfqYKRIi62OyQ0Rkh/oH+8PL1bDemnquCgwI8TdzRETWw2SHiMgOOSscMGdwMOSyqtvJZcCcwcFQObGSMtkvJjtERHaqV5Aflo0MrbSHp56rAstGhiKSFZTJznG5CCIiOxYZ5IekFj2x/eQ1HEy9iaz8Ini6KBAW6IMBIf7s0aFagckOEZGdUzk5YEhoAIaEBlg7FCKr4G0sIiIismtMdoiIiMiuMdkhIiIiu8Zkh4iIiOwakx0iIiKya0x2iIiIyK4x2SEiIiK7xmSHiIiI7BqTHSIiIrJrTHaIiIjIrjHZISIiIrvGZIeIiIjsGpMdIiIismtMdoiIiMiu2Vyys3jxYjRp0gQqlQqdO3fGsWPHqmy/YMECBAYGwtnZGQEBAXjjjTdQWFhooWiJiIjI1tlUsrNu3TpMnToVsbGxOHHiBEJCQhAVFYUbN27obb9mzRpMnz4dsbGxOHfuHL766iusW7cO77zzjoUjJyIiIltlU8nO/PnzMX78eIwZMwZBQUFYunQpXFxc8PXXX+ttn5SUhG7dumH48OFo0qQJnn76aQwbNqza3iAiIiKqPWwm2SkqKkJycjIiIyO12+RyOSIjI3H06FG9+3Tt2hXJycna5ObSpUvYtWsX+vbta5GYiYiIyPY5WjuAcrdu3UJpaSn8/Px0tvv5+eH8+fN69xk+fDhu3bqF7t27QwiBkpISvPzyy1XexlKr1VCr1dqfc3JyTPMCiIiIyCbZTM+OMRITE/Hxxx/jiy++wIkTJ7B582bs3LkTH3zwQaX7zJo1C+7u7tpHQECABSMmIiIiS5MJIYSxOxcXFyMjIwP5+fnw8fGBl5eX0YEUFRXBxcUFGzduxMCBA7XbR40ahbt372Lbtm0V9unRoweeeOIJfPLJJ9pt3333HSZMmIB79+5BLq+Yy+nr2QkICEB2djbc3NyMjp+IiIgsJycnB+7u7gZ9fkvu2cnNzcWSJUsQFhYGNzc3NGnSBK1bt4aPjw8aN26M8ePH49dff5UctEKhQMeOHbFv3z7tNo1Gg3379qFLly5698nPz6+Q0Dg4OAAAKsvhlEol3NzcdB5ERERkvyQlO/Pnz0eTJk2wYsUKREZGYuvWrUhJScEff/yBo0ePIjY2FiUlJXj66afRu3dvXLhwQVIwU6dOxfLly7Fq1SqcO3cOr7zyCvLy8jBmzBgAQHR0NGbMmKFt379/fyxZsgRr165FWloaEhIS8N5776F///7apIeIiIhqN0kDlH/99Vf89NNPaNOmjd7nO3XqhLFjx2Lp0qVYsWIFDh06hBYtWhh8/KFDh+LmzZuIiYlBRkYG2rVrh/j4eO2g5fT0dJ2enH//+9+QyWT497//jatXr8LHxwf9+/fHRx99JOVlERERkR17qDE79kDKPT8iIiKyDWYbs5Obm4t//etf2jE6jz76KPr27YuPPvqo0unhRERERNYk6TZWdHQ0kpOTMX78ePj5+aGgoADTpk3DpUuXEBMTg2eeeQZLliyBv7+/ueIlIiIikkTSbSxXV1ccPnwY7du3126rW7cuTp48CQcHB3z00UfYuXMnDh8+jKZNm5olYFPjbSwikqqgpADxafE4dPUQctQ5cFO6oUfDHujdtDecHZ2tHR5RrSDl81tSz46fnx/y8/P1Pte4cWMsW7YMH374IV5//XVs375dyqGJiKxGSvJyIP0AYpNikaXO0tmecDkBnyV/hriucYhoFGHJ8ImoGpJ6dubPn48vv/wS69evR0hICIC/e3aaNWsGAPjrr7/Qtm1b3Lt3zzwRmxh7dohqt8qSFwDwVHrqJC8H0g9gSuIUaISm0uPJZXIsjFiI8IBwc4VMRDDjAOWpU6eif//+6NChA3r37o2lS5dCo9FAJpNp26xduxbe3t7GRU5EZEHlyYu+RAcAstRZmJI4BYlXElFQUoDYpNgqEx0A0AgNYo7EoLCk0AwRE5ExJFdQnjdvHpKSklC3bl3861//QkFBAUJCQtCsWTPUq1cPH3zwgc7yDUREtkhq8rLjzx2VJkUPylJnYXfablOESUQmYNSq5507d8aGDRtQVFSEEydO4I8//kBOTg68vb3Rs2dP+Pr6mjpOIiKTik+Ll5S8bL6wWdLxD189jEEtBhkTGhGZmFHJTjmFQoEnnngCTzzxhKniISKyiENXD0lqfz3vuqT22epsSe2JyHwk3cZKT0+XdPCrV69Kak9EZCk56hxpO0isNe+udJe2AxGZjaRk5/HHH8fEiROrXNU8Ozsby5cvR9u2bbFp06aHDpCIyBzclNJmXzao00BS++4Nu0tqT0TmI+k21tmzZ/HRRx+hV69eUKlU6NixI/z9/aFSqZCVlYWzZ8/izJkz6NChA+bOnYu+ffuaK24ioofSo2EPJFxOMLj9oEcH4dq9awaN8/FSeaFP0z4PEx4RmZCknp169eph/vz5uH79OhYtWoQWLVrg1q1buHDhAgBgxIgRSE5OxtGjR5noEJFN6920NzyVnga19VJ54dlHn0Vc4wGQV1OaTC4E4hoPgMpRZYowicgEjF71/NSpUwgKCoKj40ONcbY6FhUkqr0kFQn06wQsaItEkY8YHy9kOThUaOtVWoq4m3cQLnMB3jgDOHHpCCJzkfL5bXSyI5fLoVAo0KpVK4SEhOg8alJRQSY7RLVb4pVExByJ0Xt7ykvlhbiucWXVkH/7Dtg2CQBQKJNht6sLDjurkO3gAPfSUnQvKESfvHyoyv+kPrsYaP8Py70QolrGIsnO7t27ER0djbCwMCgUCpw+fRqnT5+GTCZD/fr1tYlPcHAwhg0bZtQLsQQmO0RUWFKI3Wm7cfjqYWSrs+GudEf3ht3Rp2mfv29HrY8Gzm4z/KBBA4Ehq8wSLxFZKNlp1aoV5syZg2effVa7LT4+HpMnT8b48eNx48YNnDp1CqdPn8b169LqU1gSkx0iMsiq/kDaT4a3b/okMGqH+eIhquXMtur5/S5fvozg4GCdbb1798bcuXOxfv16rF271thDExFVIGVlcrNwNmww89/tvcwTBxFJJnltrHJdunTBN998U2F7+/btsXs314QhItM5kH4AURujEJMUg4TLCfgl4xckXE5ATFIMojZG4UD6AbPHUNQ0UlL74mZPmSkSIpLK6GTniy++wGeffYbx48fjzJkz0Gg0KC4uxuLFi+Hh4WHCEImoNpOyMrk57dA8gduirkFtbwk3bC/tYtZ4iMhwRic7rVq1ws8//4y0tDQ89thjcHFxgYuLC7744gvMmjXLlDESUS0ldWXywpJCs8Wy72IuphVPQKmQVdmuVMgwrXg89l/MNVssRCTNQxXJadWqFX788Uekp6cjJSUFcrkcHTt2RIMG0sqqExHpI3Vl8t1pu8220vjd/GIkaTpiQvFUzHVahnqyisnMLeGGacXjsU/TEV3zi8wSBxFJZ5KKgI0aNUKjRo1McSgiIi2pK5MfvnrYbMmOh4sTAJQlMurPMcAhCWHyk/DEPWShDg5qQrC9tCvUUAAAPF0UZomDiKSr2eWPiciuSV2ZPFudbaZIgPBAX+z6PQMAoIYCG0rDsaE0vNL2YYE+ZouFiKQxeswOEZG5SV2Z3F3pbqZIgP7B/vByNay3pp6rAgNC/M0WCxFJw2SHiGxWj4Y9JLXv3rC7mSIBnBUOmDM4GPKqxydDLgPmDA6Gyqni2llEZB1MdojIZkldmbxP0z5mjadXkB+WjQyttIennqsCy0aGIjLIz6xxEJE0HLNDRDbL2dEZcV3jDFqZPK5r3N/rWJlRZJAfklr0xPaT13Aw9Say8ovg6aJAWKAPBoT4s0eHyAYZvTaWveDaWES2z+CVyYmo1rDIQqD2gskOUc1g0MrkRFRrMNmRgMkOERUUlWLHqWtITL2Bu/nF8HBxQnigL/oH+8NZwdtSRLbIIqueExHZg4SzmZi26RTu5OlWPN71ewZm7z6POYOD0YsDjolqNM7GIqJaK+FsJiZ+e7xColPuTl4RJn57HD+ezbRwZERkSkx2iKhWKigqxbRNp6Cp5ka+RgBvbzqFwuJSywRGRCbH21hEVCvtOHVN26Ojghr9HY4iXJ4CD+ThLlyRqGmHHaVdUAgl7uQVYfvJaxgSGmDlqInIGDbXs7N48WI0adIEKpUKnTt3xrFjx6psf/fuXUyaNAkNGjSAUqlEy5YtsWvXLgtFS0Q1VWLqDQBApDwZR5Sv4ROnZejncAzdHM6gn8MxfOK0DEeUryFSngwAOJh605rhEtFDsKlkZ926dZg6dSpiY2Nx4sQJhISEICoqCjdu3NDbvqioCL169cJff/2FjRs3IjU1FcuXL0fDhg0tHDkR1TR384sRKU/Gl07zUU+Wq7dNPVkuvnSaj6fkycjK1z+uh4hsn00lO/Pnz8f48eMxZswYBAUFYenSpXBxccHXX3+tt/3XX3+NO3fuYOvWrejWrRuaNGmCsLAwhISEWDhyIqppfFSlmOO0DA6yqgftOMgE5jotg6+qVlfpIKrRbGbMTlFREZKTkzFjxgztNrlcjsjISBw9elTvPtu3b0eXLl0wadIkbNu2DT4+Phg+fDimTZsGBwf9tTHUajXUarX255ycHNO+ECKqVkFJAeLT4nHo6iHkqHPgpnRDj4Y90Ltpbzg7OlskhhF1kivt0XlQPVkuhtf5FUAX8wZFRGZhM8nOrVu3UFpaCj8/3XoWfn5+OH/+vN59Ll26hP3792PEiBHYtWsXLl68iFdffRXFxcWIjY3Vu8+sWbMQFxdn8viJyDAH0g8gNim2wtIPCZcT8FnyZ4jrGoeIRhFmj6Oj+ldp7YuOmykSIjI3m7qNJZVGo4Gvry+WLVuGjh07YujQoXj33XexdOnSSveZMWMGsrOztY8rV65YMGKi2u1A+gFMSZyid40rAMhSZ2FK4hQkXkk0eywO6rvS2hfqj5mIbJ/N9Ox4e3vDwcEBmZm6xbsyMzNRv359vfs0aNAATk5OOresWrdujYyMDBQVFUGhUFTYR6lUQqlUmjZ4IqpWQUkBYpNiq1y9HAA0QoOYIzHY+/xe86555ewpsb2XeeIgIrOzmZ4dhUKBjh07Yt++fdptGo0G+/btQ5cu+u+Td+vWDRcvXoRG8/cfzz/++AMNGjTQm+gQkfXEp8VX2qPzoCx1Fnan7TZvQC2elti+l3niICKzs5lkBwCmTp2K5cuXY9WqVTh37hxeeeUV5OXlYcyYMQCA6OhonQHMr7zyCu7cuYPXX38df/zxB3bu3ImPP/4YkyZNstZLIKJKHLp6SFL7w1cPmymS/2nzHOBSz7C2Lt5A28HmjYeIzMZmbmMBwNChQ3Hz5k3ExMQgIyMD7dq1Q3x8vHbQcnp6OuTyv/OzgIAA7NmzB2+88QaCg4PRsGFDvP7665g2bZq1XgIRVSJHLW3mY7Y620yR/I/CBRiwCFg3Aqjq1ppMDjy7CHCyzCwxIjI9mRCiVhePkLJEPBEZb2riVCRcTjC4/dONn8an4Z+aMaL/Sd0NbJsE5N+u+JyLd1miE9jH/HEQkSRSPr9tqmeHiOxXj4Y9JCU73Rt2N2M09wnsA7xxBji9CbiQABTcKRuM3KJX2a0r9ugQ1Xjs2WHPDpFFFJQUIGpjlEGDlL1UXtgzeI95Z2MRUY0m5fPbpgYoE5H9cnZ0RlzXOMhlVf/ZkcvkiOsax0SHiEyGyQ4RWUxEowgsjFgIT6X+GjdeKi8sjFiI8IBwywZGRHaNt7F4G4vI4gpLCrE7bTcOXz2MbHU23JXu6N6wO/o07cMeHSIyiJTPbyY7THaIiIhqHI7ZISIiIvofJjtERERk15jsEBERkV1jskNERER2jRWUiahGKCgqxY5T15CYegN384vh4eKE8EBf9A/2h7PCwdrhEZENY7JDRDYv4Wwmpm06hTt5RTrbd/2egdm7z2PO4GD0CvKzUnREZOt4G4uIbFrC2UxM/PZ4hUSn3J28Ikz89jh+PJtp4ciIqKZgskNENqugqBTTNp2CpppqYBoBvL3pFAqLSy0TGBHVKEx2iMhm7Th1rdIenQfdySvC9pPXzBwREdVETHaIyGYlpt6Q1P5g6k0zRUJENRmTHSKyWXfziyW1z8o3rBeIiGoXJjtEZLM8XJwktfd0UZgpEiKqyZjsEJHNCg/0ldQ+LNDHTJEQUU3GZIeIbFb/YH94uRrWW1PPVYEBIf5mjoiIaiImO0Rks5wVDpgzOBhyWdXt5DJgzuBgqJxYSZmIKmKyQ0Q2rVeQH5aNDK20h6eeqwLLRoYikhWUiagSXC6CiGxeZJAfklr0xPaT13Aw9Say8ovg6aJAWKAPBoT4s0eHiKrEZIeIagSVkwOGhAZgSGiAtUMhohqGyQ4RWZxRK5gX5QNnNgMX9gIFWYCzJ9DiaaDNc4DCxbIvgIhqFJkQoppVZ+xbTk4O3N3dkZ2dDTc3N2uHQ2T3KlvBHAC8XBX6VzA/vwvYPhnIv13xgC71gAGLgFZ9zRQxEdkiKZ/fHKBMRBZj1Arm53cB60boT3SAsu3rRgCpu80QMRHZAyY7RGQRRq1gXpRf1qMjNFXvJDTAtklAcYHpAiYiu8Fkh4gswqgVzM9srrxH50H5t4HTmx4iQiKyV0x2iMgijFrB/MJeaSe5kCCtPRHVCpyNRUQWYdQK5oosaScpuCOtPRHVCkx2iMgijFrB3MlT2kmcvaS1J6JagbexiMgijFrBvMXT0k7Sope09kRUKzDZISKLMGoF8zbPldXRMYSLN9B28ENESET2yiaTncWLF6NJkyZQqVTo3Lkzjh07ZtB+a9euhUwmw8CBA80bIBFJdv8K5iqo8YJDIhY7LcBqp4+w2GkBXnBIhApq3RXMFS5lBQNl1fypksmBZxcBTs6WeClEVMPYXAXldevWITo6GkuXLkXnzp2xYMECbNiwAampqfD1rbwb/K+//kL37t3RrFkzeHl5YevWrQadjxWUiSwrJWENGh+ZBk/kVHguC2643G0O2vUarvtE6u6yOjp6Kyh7lyU6gX3MFDER2SIpn982l+x07twZjz/+OBYtWgQA0Gg0CAgIwD//+U9Mnz5d7z6lpaV48sknMXbsWBw6dAh3795lskNki8qrIVdVJFAmB15cUzF5KS4oq6NzIaFs1pWzV9kYnbaD2aNDVAtJ+fy2qdlYRUVFSE5OxowZM7Tb5HI5IiMjcfTo0Ur3e//99+Hr64uXXnoJhw4dqvIcarUaarVa+3NOTsVvl0RkBlKrIb9xRjeJcXIG2v+j7EFEJIFNjdm5desWSktL4eenuwign58fMjIy9O5z+PBhfPXVV1i+fLlB55g1axbc3d21j4CAgIeOm4gMwGrIRGQlNpXsSJWbm4uRI0di+fLl8Pb2NmifGTNmIDs7W/u4cuWKmaMkIgCshkxEVmNTt7G8vb3h4OCAzMxMne2ZmZmoX79+hfZ//vkn/vrrL/Tv31+7TaMp6yJ3dHREamoqmjdvrrOPUqmEUqk0Q/REVKUCVkMmIuuwqZ4dhUKBjh07Yt++fdptGo0G+/btQ5cuXSq0b9WqFX7//XekpKRoHwMGDEBERARSUlJ4i4rIljizGjIRWYdN9ewAwNSpUzFq1CiEhoaiU6dOWLBgAfLy8jBmzBgAQHR0NBo2bIhZs2ZBpVKhbdu2Ovt7eHgAQIXtRGRlLZ4Gzm6T0J7VkInINGwu2Rk6dChu3ryJmJgYZGRkoF27doiPj9cOWk5PT4dcblMdUkRkiDbPAQkxhg1SZjVkIjIhm6uzY2mss0NkQQ9TZ4eI6D5SPr/ZRUJEltOqb1kiU9l6Vy7eTHSIyORs7jYWEdm5wD5lBQNZDZmILITJDhFZHqshE5EF8TYWERER2TUmO0RERGTXmOwQERGRXWOyQ0RERHaNyQ4RERHZNSY7REREZNc49ZzIHhTlA2c2Axf2lq0u7uxZthZVm+cAhYu1oyMisiomO0Q13fldwPbJFdecOrutbC2qAYvKKhcTEdVSvI1FVJOVrzVV2eKa+bfLnk/dbdm4iIhsCJMdopqqKL+sR6eqRTWBsue3TQKKCywTFxGRjeFtLBtRUFKA+LR4HLp6CDnqHLgp3dCjYQ/0btobzo5cK4j0OLO58h6dB+XfLluLisszEFEtxGTHBhxIP4DYpFhkqbN0tidcTsBnyZ8hrmscIhpFWCk6sgpDBhxf2CvtmBcSmOwQUa3EZMfKDqQfwJTEKdBUcisiS52FKYlTsDBiIcIDwi0bHFmHoQOOC7L071+Zgjumi5GIqAZhsmNFBSUFiE2KrTTRKacRGsQcicHe5/dC5aiyUHRkFf8bcFwAgfg6rjjk4owcuRxuGg165Begd94dOK8bAby4pqy3RwpnL/PETERk4zhA2Yri0+Ir3LqqTJY6C7vTOKPGrv1vwPEBZyWiAvwR41MPCa4u+MVZhQRXF8T41ENUgD8OOCvLBhw3C5d2/Ba9zBI2EZGtY7JjRYeuHpLU/vDVw2aKhGzCmc04gHxM8fVGloOD3iZZDg6Y4uuNRJEPCAAu9Qw7tos30Haw6WIlIqpBmOxYUY46R1L7bHW2mSIhW1DwRzxivb2gkcmqbKeRyRDj44XCSweAAYsgZFX/MxYyOfDsIsCJs/qIqHZismNFbko3Se3dle5mioRsQXzhfyvt0XlQloMDdhdeQYKmI8YXvYHboq7edreEG8YXvYEfSzuYMlQiohqFA5StqEfDHki4nGBw++4Nu5sxGrK2Q/JSoJr6gA+2T9x0CndKO6Jr6ecY4JCEMPlJeOIeslAHBzUh2F7aFWoocGLTKSS16AmVk2HJFBGRPWGyYwaGFgjs3bQ3Pkv+zKBByl4qL/Rp2secYZOV5bi4A/fuGtz+iswFd/KKAABqKLChNBwbSsP1tr2TV4TtJ69hSGiACSIlIqpZeBvLxA6kH0DUxijEJMUg4XICfsn4BQmXExCTFIOojVE4kH5A29bZ0RlxXeMgr2bMhVwmR1zXOE47t3Nuns0ltb9T2kBS+4OpNyW1JyKyF0x2TKi8QGBlPTXlBQITryRqt0U0isDCiIXwVOqvmeKl8mJBwVqih8TfsVPJY5LaZ+UXSWpPRGQvZEIIYe0grCknJwfu7u7Izs6Gm5u0AcP3KygpQNTGKINuSXkqPSsUCCwsKcTutN04fPUwstXZcFe6o3vD7ujTtA97dGoJKe8hL5UXWhXPxp7ThldF7vdYAywewYHKRGQfpHx+c8yOiRhTIHBQi0HabSpHFQa1GKSzjWqX8tuaVS0fAvx9W/NG5iOSkp2wQB9ThElEVOPwNpaJsEAgmUL5bU2PSm5reio9tbc1+wf7w8tVYdBx67kqMCDE35ShEhHVGOzZMREWCCRTKc5tjXsXp6HA4Tgc66RC5pAPUeqCknuBcCwNRXFwawCAs8IBcwYHY+K3x6Gp4ma0XAbMGRzMaedEVGuxZ8dEWCCQTCHhbCYmfnscWfeAkuxQFF4dgYL08Si8OgIl2aHIugdM/PY4fjybCQDoFeSHZSNDK+3hqeeqwLKRoYgM8rPkyyAisins2TERFgikh1VQVIppm05V2UsDABoBvH1fkcDIID8kteiJ7Sev4WDqTWTlF8HTRYGwQB8MCPFnjw4R1XpMdkyEBQLpYe04dU1bJLA6DxYJVDk5YEhoAIsGEhHpwdtYJsICgfSwElNvSGrPIoFERIZhz44Jlc+kiTkSo7eHx0vlhbiucbWyQKChS2jUZnfziyW1Z5FAIiLD2GSys3jxYnzyySfIyMhASEgIPv/8c3Tq1Elv2+XLl+Obb77B6dOnAQAdO3bExx9/XGl7cwsPCMfe5/eyQOB9DqQfQGxSbIUEMOFyAj5L/gxxXeMQ0SjCStHZDg8XJ0ntPV0Mm3ZORFTb2Vyys27dOkydOhVLly5F586dsWDBAkRFRSE1NRW+vr4V2icmJmLYsGHo2rUrVCoV5syZg6effhpnzpxBw4YNrfAK7L9AoJRemvIlNCorkle+hAaXxADCA32x6/cMg9uzSCARkWFsbrmIzp074/HHH8eiRYsAABqNBgEBAfjnP/+J6dOnV7t/aWkpPD09sWjRIkRHR1fb3lTLRdQWlfXSAGUF7+7vpXnYJTRqm4KiUnSbs9+gQcr1XBU4Mr0nZ1oRUa0l5fPbpgYoFxUVITk5GZGRkdptcrkckZGROHr0qEHHyM/PR3FxMby8vMwVZq0ldaFTY5bQqM3KiwTKZVW3Y5FAIiJpbCrZuXXrFkpLS+Hnp1sAzc/PDxkZhnXvT5s2Df7+/joJ0/3UajVycnJ0HlS9gpICxCbFVrlmEwBohAYxR2JQWFLIJTSMYGyRwIKSAmy5sAVTE6di3J5xmJo4FVsubEFBSYElwiYismk2N2bnYcyePRtr165FYmIiVCr9t0NmzZqFuLg4C0dW8xnTS8MlNIwjtUggB4ATEVXNppIdb29vODg4IDMzU2d7ZmYm6tevX+W+8+bNw+zZs/Hjjz8iODi40nYzZszA1KlTtT/n5OQgIICF2KpjTC8Nl9AwnqFFAjkAnIioejZ1G0uhUKBjx47Yt2+fdptGo8G+ffvQpUuXSvebO3cuPvjgA8THxyM0NLTKcyiVSri5uek8qHrG9NL0aNhD0j5cQkMaY24tEhHVRjaV7ADA1KlTsXz5cqxatQrnzp3DK6+8gry8PIwZMwYAEB0djRkzZmjbz5kzB++99x6+/vprNGnSBBkZGcjIyMC9e/es9RLskjG9NL2b9oan0tOg9lxCQzoOACciMozNJTtDhw7FvHnzEBMTg3bt2iElJQXx8fHaQcvp6em4fv26tv2SJUtQVFSE559/Hg0aNNA+5s2bZ62XYJeM6aXhEhrmxQHgRESGsbk6O5bGOjuGkVIzx0vlhT2D92iTl8QriVxCwwzG7RmHXzJ+Mbh95/qd8Z+o/5gxIiIiy5Hy+W1TA5TJdpX30lQ1GBbQ30vDJTTMgwPAiYgMw2SHDPYwC53a+xIa1tCjYQ8kXE4wuD0HgBNRbcXbWLyNJVlhSSF7aWzAw9xaJCKq6aR8fjPZYbJDNVh1dXaAsluLrLNDRPamxq6NRUTSlN9arGyKv5fKi4kOEdV67Nlhzw7ZAd5aJKLahrexJGCyQ0REVPPwNhYRERHR/zDZISIiIrvGZIeIiIjsGpMdIiIismtMdoiIiMiuMdkhIiIiu8Zkh4iIiOwakx0iIiKya0x2iIiIyK4x2SEiIiK7xmSHiIiI7BqTHSIiIrJrjtYOgGqHgqJS7Dh1DYmpN3A3vxgeLk4ID/RF/2B/OCscrB0eERHZMSY7ZHYJZzMxbdMp3Mkr0tm+6/cMzN59HnMGB6NXkJ+VoiMiInvH21hkVglnMzHx2+MVEp1yd/KKMPHb4/jxbKaFIyMiotqCyQ6ZTUFRKaZtOgWNqLqdRgBvbzqFwuJSywRGRES1Cm9jkWSGjr/ZcepapT06D7qTV4TtJ69hSGiAucImIqJaiskOSSJl/E1i6g1Jxz6YepPJDhERmRxvY5HBpI6/uZtfLOn4WfmG9QIRERFJwWSHDGLM+BsPFydJ5/B0UTxEhERERPox2SGDGDP+JjzQV9I5wgJ9jAmNiIioSkx2yCDGjL/pH+wPL1fDemvquSowIMTfmNCIiIiqxGSHDGLM+BtnhQPmDA6GXFZ1W7kMmDM4GConVlImIiLTY7JDBjF2/E2vID8sGxlaaQ9PPVcFlo0MRSQrKBMRkZlw6rmNsPW1o8IDfbHr9wyD298//iYyyA9JLXpi+8lrOJh6E1n5RfB0USAs0AcDQvzZo0NERGYlE0JUM7/GvuXk5MDd3R3Z2dlwc3MzyTGlJi6V1a4BAC9XhU2sHVVQVIpuc/YbNEi5nqsCR6b3ZBJDRERmI+Xzm8mOiZOdhLOZiN34K7qpDyJcngIP5OEuXJGoaYcjyjDEPf+4TuJSXrtGIdTo73C0wj47SrugSKa0iVs9DxVrUT5wZjNwYS9QkAU4ewItngbaPAcoXKzzgoiIqMZisiOBKZOdhLOZWL/6S8x2XIZ6stwKz98WdTG9ZAKGjpiIyCA/bW9Jh4KjmONU+T7TiifghHMXJNlAb0lKwho0PjINnsip8FwW3HC52xy06zVc94nzu4Dtk4H82xUP6FIPGLAIaNXXTBETEZE9kvL5bZMDlBcvXowmTZpApVKhc+fOOHbsWJXtN2zYgFatWkGlUuGxxx7Drl27LBTp3wqKSrFz41dY6jhfb9ICAPVkuVjqOB8/bPwahcVlt7o6FBzFl05V7/Ol03y0LziK7SevmfMlVO/8LrRLmqQ30QEAT+SgXdIkIHW3zj5YN0J/ogOUbV83QncfIiIiE7K5ZGfdunWYOnUqYmNjceLECYSEhCAqKgo3buiv85KUlIRhw4bhpZdewm+//YaBAwdi4MCBOH36tEXj3vXbn3iv9As4yKruKHOQCbxXuhg7T1zCkXPpmOO0zKB95jotQ9K5/5oyZGmK8st6Z4Sm6nZCA2ybBBQXGLcPERGRidlcsjN//nyMHz8eY8aMQVBQEJYuXQoXFxd8/fXXetsvXLgQvXv3xltvvYXWrVvjgw8+QIcOHbBo0SKLxp2XvL7S3pkH1ZPlIj95PYJu/yhpn9a39z5MiA/nzObKe2celH8bOL3JuH2IiIhMzKaSnaKiIiQnJyMyMlK7TS6XIzIyEkePHtW7z9GjR3XaA0BUVFSl7dVqNXJycnQephCY87Ok9i1yj+LxkuOS9nm8JFlSe5O6IDHRupBg3D5EREQmZlPJzq1bt1BaWgo/P92ZPH5+fsjI0F/jJSMjQ1L7WbNmwd3dXfsICAgwSezusnuS2nviHhoq1ZL2aagslNTepAqyJLa/Y9w+REREJmZTyY4lzJgxA9nZ2drHlStXTHJcVw9pi1i6ePjC20faVHJv3/qS2puUs6fE9l7G7UNERGRiNpXseHt7w8HBAZmZmTrbMzMzUb++/g/6+vXrS2qvVCrh5uam8zAFvw79JbWv3/EZOARGSdrHoeXTktqbVAuJ527Ry7h9iIiITMymkh2FQoGOHTti37592m0ajQb79u1Dly5d9O7TpUsXnfYAkJCQUGl7c1GEPI8ipWE9GUVKLziFvFBWUM+lnmEncPEG2g5+iAgfkjGx1qTXR0REdsumkh0AmDp1KpYvX45Vq1bh3LlzeOWVV5CXl4cxY8YAAKKjozFjxgxt+9dffx3x8fH49NNPcf78ecycORPHjx/H5MmTLRu4wgWKQV9AyKq+pEImh+K5LwAn57LKwQMWAdXsA5kceHZR2T7WYkysNen1ERGR3bK5ZGfo0KGYN28eYmJi0K5dO6SkpCA+Pl47CDk9PR3Xr1/Xtu/atSvWrFmDZcuWISQkBBs3bsTWrVvRtm1bywffqi9kL66BqKQ3Q7h4Q/biGiCwj84+eHFN5T0gLt5lz9+/j7UYE2tNen1ERGSXuFyEGRYCRXFBWc2YCwllM4ycvcrGo7QdXHnvhTH7WIu9vz4iIrJ5XBtLArMkO0RERGRWNX5tLCIiIiJTYbJDREREdo3JDhEREdk1JjtERERk15jsEBERkV1jskNERER2jckOERER2TUmO0RERGTXHK0dgLWV11TMycmxciRERERkqPLPbUNqI9f6ZCc3NxcAEBAQYOVIiIiISKrc3Fy4u7tX2abWLxeh0Whw7do11K1bFzKZDEBZthgQEIArV65wCYlK8BpVj9eoerxG1eM1MgyvU/Xs7RoJIZCbmwt/f3/I5VWPyqn1PTtyuRyPPPKI3ufc3Nzs4g1hTrxG1eM1qh6vUfV4jQzD61Q9e7pG1fXolOMAZSIiIrJrTHaIiIjIrjHZ0UOpVCI2NhZKpdLaodgsXqPq8RpVj9eoerxGhuF1ql5tvka1foAyERER2Tf27BAREZFdY7JDREREdo3JDhEREdk1JjtERERk12plsrN48WI0adIEKpUKnTt3xrFjx6psv2HDBrRq1QoqlQqPPfYYdu3aZaFIrUvKdVq+fDl69OgBT09PeHp6IjIystrrag+kvpfKrV27FjKZDAMHDjRvgDZA6jW6e/cuJk2ahAYNGkCpVKJly5Z2/29O6jVasGABAgMD4ezsjICAALzxxhsoLCy0ULSW99NPP6F///7w9/eHTCbD1q1bq90nMTERHTp0gFKpxKOPPoqVK1eaPU5rknqNNm/ejF69esHHxwdubm7o0qUL9uzZY5lgrUHUMmvXrhUKhUJ8/fXX4syZM2L8+PHCw8NDZGZm6m1/5MgR4eDgIObOnSvOnj0r/v3vfwsnJyfx+++/Wzhyy5J6nYYPHy4WL14sfvvtN3Hu3DkxevRo4e7uLv773/9aOHLLkXqNyqWlpYmGDRuKHj16iGeffdYywVqJ1GukVqtFaGio6Nu3rzh8+LBIS0sTiYmJIiUlxcKRW47Ua7R69WqhVCrF6tWrRVpamtizZ49o0KCBeOONNywcueXs2rVLvPvuu2Lz5s0CgNiyZUuV7S9duiRcXFzE1KlTxdmzZ8Xnn38uHBwcRHx8vGUCtgKp1+j1118Xc+bMEceOHRN//PGHmDFjhnBychInTpywTMAWVuuSnU6dOolJkyZpfy4tLRX+/v5i1qxZetsPGTJE9OvXT2db586dxcSJE80ap7VJvU4PKikpEXXr1hWrVq0yV4hWZ8w1KikpEV27dhX/+c9/xKhRo+w+2ZF6jZYsWSKaNWsmioqKLBWi1Um9RpMmTRI9e/bU2TZ16lTRrVs3s8ZpKwz5IH/77bdFmzZtdLYNHTpUREVFmTEy22HINdInKChIxMXFmT4gG1CrbmMVFRUhOTkZkZGR2m1yuRyRkZE4evSo3n2OHj2q0x4AoqKiKm1vD4y5Tg/Kz89HcXExvLy8zBWmVRl7jd5//334+vripZdeskSYVmXMNdq+fTu6dOmCSZMmwc/PD23btsXHH3+M0tJSS4VtUcZco65duyI5OVl7q+vSpUvYtWsX+vbta5GYa4La+Hf7YWk0GuTm5trt3+xatRDorVu3UFpaCj8/P53tfn5+OH/+vN59MjIy9LbPyMgwW5zWZsx1etC0adPg7+9f4Q+OvTDmGh0+fBhfffUVUlJSLBCh9RlzjS5duoT9+/djxIgR2LVrFy5evIhXX30VxcXFiI2NtUTYFmXMNRo+fDhu3bqF7t27QwiBkpISvPzyy3jnnXcsEXKNUNnf7ZycHBQUFMDZ2dlKkdmuefPm4d69exgyZIi1QzGLWtWzQ5Yxe/ZsrF27Flu2bIFKpbJ2ODYhNzcXI0eOxPLly+Ht7W3tcGyWRqOBr68vli1bho4dO2Lo0KF49913sXTpUmuHZjMSExPx8ccf44svvsCJEyewefNm7Ny5Ex988IG1Q6Maas2aNYiLi8P69evh6+tr7XDMolb17Hh7e8PBwQGZmZk62zMzM1G/fn29+9SvX19Se3tgzHUqN2/ePMyePRs//vgjgoODzRmmVUm9Rn/++Sf++usv9O/fX7tNo9EAABwdHZGamormzZubN2gLM+Z91KBBAzg5OcHBwUG7rXXr1sjIyEBRUREUCoVZY7Y0Y67Re++9h5EjR2LcuHEAgMceewx5eXmYMGEC3n33Xcjl/A5b2d9tNzc39uo8YO3atRg3bhw2bNhgtz3xQC3r2VEoFOjYsSP27dun3abRaLBv3z506dJF7z5dunTRaQ8ACQkJlba3B8ZcJwCYO3cuPvjgA8THxyM0NNQSoVqN1GvUqlUr/P7770hJSdE+BgwYgIiICKSkpCAgIMCS4VuEMe+jbt264eLFi9pEEAD++OMPNGjQwO4SHcC4a5Sfn18hoSlPDgWXOgRQO/9uG+P777/HmDFj8P3336Nfv37WDse8rD1C2tLWrl0rlEqlWLlypTh79qyYMGGC8PDwEBkZGUIIIUaOHCmmT5+ubX/kyBHh6Ogo5s2bJ86dOydiY2NrzdRzKddp9uzZQqFQiI0bN4rr169rH7m5udZ6CWYn9Ro9qDbMxpJ6jdLT00XdunXF5MmTRWpqqvjhhx+Er6+v+PDDD631EsxO6jWKjY0VdevWFd9//724dOmS2Lt3r2jevLkYMmSItV6C2eXm5orffvtN/PbbbwKAmD9/vvjtt9/E5cuXhRBCTJ8+XYwcOVLbvnzq+VtvvSXOnTsnFi9ebPdTz6Veo9WrVwtHR0exePFinb/Zd+/etdZLMKtal+wIIcTnn38uGjVqJBQKhejUqZP4+eeftc+FhYWJUaNG6bRfv369aNmypVAoFKJNmzZi586dFo7YOqRcp8aNGwsAFR6xsbGWD9yCpL6X7lcbkh0hpF+jpKQk0blzZ6FUKkWzZs3ERx99JEpKSiwctWVJuUbFxcVi5syZonnz5kKlUomAgADx6quviqysLMsHbiEHDhzQ+/el/LqMGjVKhIWFVdinXbt2QqFQiGbNmokVK1ZYPG5LknqNwsLCqmxvb2RCsN+TiIiI7FetGrNDREREtQ+THSIiIrJrTHaIiIjIrjHZISIiIrvGZIeIiIjsGpMdIiIismtMdoiIiMiuMdkhIiIiu8Zkh4jskhAC8+fPR9OmTeHi4oKBAwciOzvb2mERkRUw2SEiu/TWW29hyZIlWLVqFQ4dOoTk5GTMnDnT2mERkRVwuQgisju//PILunTpguPHj6NDhw4AgPfffx+rV69GamqqlaMjIktjzw4R2Z158+bhqaee0iY6AODn54dbt25ZMSoishYmO0RkV9RqNXbu3IlBgwbpbC8sLIS7u7uVoiIia+JtLCKyK0ePHkXXrl2hUqng4OCg3V5cXIyIiAjEx8dbMToisgZHawdARGRKf/zxB1xdXZGSkqKzvV+/fujWrZt1giIiq2KyQ0R2JScnB97e3nj00Ue12y5fvowLFy5g8ODBVoyMiKyFY3aIyK54e3sjOzsb99+h/+ijj9C3b18EBQVZMTIishb27BCRXenZsycKCwsxe/ZsvPjii1i9ejV27NiBY8eOWTs0IrIS9uwQkV3x8/PDypUrsWTJErRp0wY///wzDh8+jICAAGuHRkRWwtlYREREZNfYs0NERER2jckOERER2TUmO0RERGTXmOwQERGRXWOyQ0RERHaNyQ4RERHZNSY7REREZNeY7BAREZFdY7JDREREdo3JDhEREdk1JjtERERk15jsEBERkV37f4XtjjtYAPoqAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -678,6 +678,7 @@ "plt.scatter(ionq_theta_list, ionq_q_theta_list, label=r\"IonQ\")\n", "plt.xlabel(r\"$\\theta$\")\n", "plt.ylabel(r\"$q(\\theta)$\")\n", + "plt.title('Activation Function by Quantum Neuron')\n", "plt.legend(bbox_to_anchor=(0, 1), loc='upper left', borderaxespad=1)\n", "plt.show()" ] diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2927c4249f20daa9465ffb6f9b9e65ccc529ee71 GIT binary patch literal 682 zcmV;b0#*GViwFP!00000|Lv4fZxb;L$M;cAecn3TiQ~AhY-kT4kl+oW>eimLZfm>U zT?c6DcgIOL3GEdIJowjEZ5=26=kMhDZrI(9!}NOCZjN3FK!6lu0|#DyV`6GBMzJgg zmIjar`KW={67(y(VQl*&`0ZLRH}?mm{S6)`mwkKFjh_}*-MYQ#+GW>IX3gVd)2=)F z@iaWW-d+y#WjnUhyRIKr!`Ln77OSDjaWi=+(e0+pz{%bMW#DYJ7%kZLKkAa>RX4Wt zTbpcuzrYmuxPfU>AyMW;Nwd96EJmixgdwqH37C!>oPrXkC`pw>Vkmh8F(kwUq5&~* zD#6T{A_xj3(i~!mv1*Dbh%F3OC71OmCREvVKyj>Xfl9d4Row_ZOV)VANu+Hb?`aQ0`r;iPMa@dRhHW%saJ zbf@=syHh*Z_oo+azus;RvxckfIM}aJ;%U{P4!rsB{^Psz&*x`#aKA6tqZ`K6y0u%> zEVi|iWXIz9-n`xRHdgM^-EF(tjNSKfvj5jl3deCA$8j9TaU92S9LI4S$8j9TaU92S Q9Or-JC)nR_umC6k03}mPjsO4v literal 0 HcmV?d00001 From c66fde4262ae11968deb205ddd212d9f1e5c5094 Mon Sep 17 00:00:00 2001 From: YutoTakaki Date: Tue, 22 Aug 2023 05:09:47 +0000 Subject: [PATCH 37/37] run QPU --- notebooks/textbook/Quantum_Neuron/model.tar.gz | Bin 682 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 notebooks/textbook/Quantum_Neuron/model.tar.gz diff --git a/notebooks/textbook/Quantum_Neuron/model.tar.gz b/notebooks/textbook/Quantum_Neuron/model.tar.gz deleted file mode 100644 index 2927c4249f20daa9465ffb6f9b9e65ccc529ee71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 682 zcmV;b0#*GViwFP!00000|Lv4fZxb;L$M;cAecn3TiQ~AhY-kT4kl+oW>eimLZfm>U zT?c6DcgIOL3GEdIJowjEZ5=26=kMhDZrI(9!}NOCZjN3FK!6lu0|#DyV`6GBMzJgg zmIjar`KW={67(y(VQl*&`0ZLRH}?mm{S6)`mwkKFjh_}*-MYQ#+GW>IX3gVd)2=)F z@iaWW-d+y#WjnUhyRIKr!`Ln77OSDjaWi=+(e0+pz{%bMW#DYJ7%kZLKkAa>RX4Wt zTbpcuzrYmuxPfU>AyMW;Nwd96EJmixgdwqH37C!>oPrXkC`pw>Vkmh8F(kwUq5&~* zD#6T{A_xj3(i~!mv1*Dbh%F3OC71OmCREvVKyj>Xfl9d4Row_ZOV)VANu+Hb?`aQ0`r;iPMa@dRhHW%saJ zbf@=syHh*Z_oo+azus;RvxckfIM}aJ;%U{P4!rsB{^Psz&*x`#aKA6tqZ`K6y0u%> zEVi|iWXIz9-n`xRHdgM^-EF(tjNSKfvj5jl3deCA$8j9TaU92S9LI4S$8j9TaU92S Q9Or-JC)nR_umC6k03}mPjsO4v