From 8aefd737fead5d711fd62bf8033095ace6b25b1c Mon Sep 17 00:00:00 2001 From: Miguel Date: Sat, 28 Jan 2023 19:49:43 +0000 Subject: [PATCH 01/10] initial changes for encoding --- .../examples_qiskit-checkpoint.ipynb | 204 +++ .../mock_data_creator-checkpoint.ipynb | 79 + .ipynb_checkpoints/part1-checkpoint.py | 25 + .../part1_example_qiskit-checkpoint.ipynb | 234 +++ .../part2_example_qiskit-checkpoint.ipynb | 230 +++ __pycache__/part1.cpython-39.pyc | Bin 844 -> 830 bytes data1.json | 1 + data2.json | 1 + examples.ipynb | 4 +- examples_qiskit.ipynb | 34 +- mock_data_creator.ipynb | 4 +- part1_example_qiskit.ipynb | 64 +- part2_example_qiskit.ipynb | 1462 ++++++++++++++++- 13 files changed, 2308 insertions(+), 34 deletions(-) create mode 100644 .ipynb_checkpoints/examples_qiskit-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/mock_data_creator-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/part1-checkpoint.py create mode 100644 .ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb create mode 100644 .ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb create mode 100644 data1.json create mode 100644 data2.json diff --git a/.ipynb_checkpoints/examples_qiskit-checkpoint.ipynb b/.ipynb_checkpoints/examples_qiskit-checkpoint.ipynb new file mode 100644 index 0000000..bab8c57 --- /dev/null +++ b/.ipynb_checkpoints/examples_qiskit-checkpoint.ipynb @@ -0,0 +1,204 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "\n", + "#define utility functions\n", + "\n", + "#this simulate a circuit (without measurement) and output results in the format of histogram.\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " return Counter([len(gate[1]) for gate in circuit.data])\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(image1, image2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#load data\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + } + ], + "source": [ + "#grade part1\n", + "from part1 import encode_qiskit,decode\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for data in dataset:\n", + " #encode image into circuit\n", + " circuit=encode_qiskit(data['image'])\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + " \n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #reconstruct \n", + " image_re=decode(histogram)\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(np.asarray(data['image']),np.asarray(image_re))\n", + " \n", + "#fidelity of reconstruction\n", + "f=1-mse\n", + "gatecount=gatecount/n\n", + "\n", + "#score for part1\n", + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + } + ], + "source": [ + "#grade part 2\n", + "\n", + "#load classifier circuit\n", + "classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n", + " \n", + "score=0\n", + "\n", + "for data in dataset:\n", + " #encode image into circuit\n", + " circuit=encode_qiskit(data['image'])\n", + " \n", + " nq1 = circuit.width()\n", + " nq2 = classifier.width()\n", + " nq = max(nq1, nq2)\n", + " qc = qiskit.QuantumCircuit(nq)\n", + " qc.append(circuit.to_instruction(), list(range(nq1)))\n", + " qc.append(classifier.to_instruction(), list(range(nq2)))\n", + "\n", + " gatecount+=count_gates(qc)[2]\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(qc)\n", + " \n", + " #convert histogram to category\n", + " cat=histogram_to_category(histogram)\n", + " \n", + " \n", + " if cat==data['category']:\n", + " score+=1\n", + "#score\n", + "score=score/n\n", + "gatecount=gatecount/n\n", + "\n", + "print(score*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.15" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/mock_data_creator-checkpoint.ipynb b/.ipynb_checkpoints/mock_data_creator-checkpoint.ipynb new file mode 100644 index 0000000..78ad064 --- /dev/null +++ b/.ipynb_checkpoints/mock_data_creator-checkpoint.ipynb @@ -0,0 +1,79 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "edbfcaa1", + "metadata": {}, + "outputs": [], + "source": [ + "import cirq\n", + "import numpy as np\n", + "import pickle\n", + "import json" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3d1a8015", + "metadata": {}, + "outputs": [], + "source": [ + "#making mock data data1.json and data2.json\n", + "\n", + "image1={\"image\":[[0,0],[0,0]],\"category\":1}\n", + "image2={\"image\":[[1,1],[1,1]],\"category\":0}\n", + "\n", + "with open('data1.json', \"w\") as outfile:\n", + " json.dump(image1, outfile)\n", + " \n", + "with open('data2.json', \"w\") as outfile:\n", + " json.dump(image2, outfile)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d36c16ef", + "metadata": {}, + "outputs": [], + "source": [ + "circuit=cirq.Circuit()\n", + "circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", + "#making mock submission for part2\n", + "with open('part2.pickle', 'wb') as f:\n", + " pickle.dump(circuit,f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55574177", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/.ipynb_checkpoints/part1-checkpoint.py b/.ipynb_checkpoints/part1-checkpoint.py new file mode 100644 index 0000000..d133097 --- /dev/null +++ b/.ipynb_checkpoints/part1-checkpoint.py @@ -0,0 +1,25 @@ +import cirq +import qiskit +import numpy as np + + +def encode_cirq(image): + circuit=cirq.Circuit() + if image[0][0]==0: + circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0))) + return circuit + +def encode_qiskit(image): + q = qiskit.QuantumRegister(3) + circuit = qiskit.QuantumCircuit(q) + if image[0][0]==0: + circuit.rx(np.pi,0) + return circuit + + +def decode(histogram): + if 1 in histogram.keys(): + image=[[0,0],[0,0]] + else: + image=[[1,1],[1,1]] + return image \ No newline at end of file diff --git a/.ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb b/.ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb new file mode 100644 index 0000000..90b2c18 --- /dev/null +++ b/.ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb @@ -0,0 +1,234 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(2,20):\n", + " assert counter[i]==0\n", + " \n", + " return counter\n", + "\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(image1, image2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#load the mock data (for testing only)\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#load the actual hackthon data (fashion-mnist)\n", + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')\n", + "#you can visualize it\n", + "plt.imshow(images[1100])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#submission to part 1, you should make this into a .py file\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "# Functions 'encode' and 'decode' are dummy.\n", + "def encode(image):\n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " if image[0][0]==0:\n", + " circuit.rx(np.pi,0)\n", + " return circuit\n", + "\n", + "def decode(histogram):\n", + " if 1 in histogram.keys():\n", + " image=[[0,0],[0,0]]\n", + " else:\n", + " image=[[1,1],[1,1]]\n", + " return image\n", + "\n", + "def run_part1(image):\n", + " #encode image into a circuit\n", + " circuit=encode(image)\n", + "\n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re=decode(histogram)\n", + "\n", + " return circuit,image_re" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + } + ], + "source": [ + "#how we grade your submission\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for data in dataset:\n", + " #encode image into circuit\n", + " circuit,image_re=run_part1(data['image'])\n", + " \n", + " #count the number of 2qubit gates used\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(data['image'],image_re)\n", + " \n", + "#fidelity of reconstruction\n", + "f=1-mse\n", + "gatecount=gatecount/n\n", + "\n", + "#score for part1 \n", + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.15 (main, Oct 11 2022, 22:27:25) \n[Clang 14.0.0 (clang-1400.0.29.102)]" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb b/.ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb new file mode 100644 index 0000000..8b48841 --- /dev/null +++ b/.ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb @@ -0,0 +1,230 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(2,20):\n", + " assert counter[i]==0\n", + " \n", + " return counter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#load the mock data (for testing only)\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#load the actual hackthon data (fashion-mnist)\n", + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')\n", + "#you can visualize it\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(images[1100])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#your submission\n", + "\n", + "# Functions 'encode' and 'decode' are dummy.\n", + "def encode(image):\n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " if image[0][0]==0:\n", + " circuit.rx(np.pi,0)\n", + " return circuit\n", + "\n", + "\n", + "def run_part2(image):\n", + "\n", + " #loade the quantum classifier circuit\n", + " classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n", + " \n", + " #encode image into circuit\n", + " circuit=encode(image)\n", + " \n", + " #append with classifier circuit\n", + " nq1 = circuit.width()\n", + " nq2 = classifier.width()\n", + " nq = max(nq1, nq2)\n", + " qc = qiskit.QuantumCircuit(nq)\n", + " qc.append(circuit.to_instruction(), list(range(nq1)))\n", + " qc.append(classifier.to_instruction(), list(range(nq2)))\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(qc)\n", + " \n", + " #convert histogram to category\n", + " label=histogram_to_category(histogram)\n", + " \n", + " return circuit,label\n", + "#score" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + } + ], + "source": [ + "#how we grade your submission\n", + "\n", + "score=0\n", + "gatecount=0\n", + "n=len(dataset)\n", + "\n", + "for data in dataset:\n", + " #run part 2\n", + " circuit,label=run_part2(data['image'])\n", + " \n", + " #count the gate used in the circuit for score calculation\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #check label\n", + " if label==data['category']:\n", + " score+=1\n", + "#score\n", + "score=score/n\n", + "gatecount=gatecount/n\n", + "\n", + "print(score*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.15" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/__pycache__/part1.cpython-39.pyc b/__pycache__/part1.cpython-39.pyc index 9e215d215c79a1d8dca086341d2c02c391ba5810..e7f94c0b8103120aef2ec500730ae35d5e28a25f 100644 GIT binary patch delta 56 zcmX@ZwvUZFk(ZZ?0SNj+u5RS!Wt3CX&&bbB)z8W=t4z$(H!?6Xj`z&Z3ycp+&CM@K K-R#21!2|%Zm=GfX delta 70 zcmdnTc7}~Rk(ZZ?0SJ7Hu59GyWz;dz4=qkDD%LMftjy0#P1SeFFVD-#PfRJ+H!?6X YjxWeb%*)HnOOMaY&nw()#>l}00M" + "" ] }, - "execution_count": 3, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -147,13 +186,13 @@ "\n", "def run_part1(image):\n", " #encode image into a circuit\n", - " circuit=encode(image)\n", + " circuit = encode(image)\n", "\n", " #simulate circuit\n", - " histogram=simulate(circuit)\n", + " histogram = simulate(circuit)\n", "\n", " #reconstruct the image\n", - " image_re=decode(histogram)\n", + " image_re = decode(histogram)\n", "\n", " return circuit,image_re" ] @@ -206,7 +245,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 [Default]", "language": "python", "name": "python3" }, @@ -220,9 +259,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15 (main, Oct 11 2022, 22:27:25) \n[Clang 14.0.0 (clang-1400.0.29.102)]" + "version": "3.9.10" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" @@ -230,5 +268,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/part2_example_qiskit.ipynb b/part2_example_qiskit.ipynb index 8b48841..1fff63c 100644 --- a/part2_example_qiskit.ipynb +++ b/part2_example_qiskit.ipynb @@ -77,22 +77,22 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 3, + "execution_count": 95, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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\n", "text/plain": [ "
" ] @@ -114,7 +114,1452 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.00392156862745098" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2000, 28, 28)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.00392156862745098" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " ...,\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", + "\n", + " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 2.41234518e-07, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 2.41234518e-07, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 3.01543147e-07, 0.00000000e+00, 0.00000000e+00],\n", + " ...,\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 3.01543147e-07, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 2.41234518e-07, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 3.01543147e-07, 0.00000000e+00, 0.00000000e+00]],\n", + "\n", + " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " ...,\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " ...,\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", + "\n", + " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " ...,\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", + "\n", + " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " ...,\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", + " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", + " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]]])" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images_normalized = (images/ 255.0)\n", + "\n", + "images_normalized" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(images[0])\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(images_normalized[0])\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "def min_max_normalization(s):\n", + "\n", + " normalized_s=(s-s.min())/(s.max()-s.min())\n", + " \n", + " return normalized_s\n", + "\n", + "def z_normalization(s):\n", + " \n", + " normalized_s=(s-s.mean())/s.std()\n", + " \n", + " return normalized_s\n", + "\n", + "\n", + "def variance_map(images, images_normalization, variance_normalization=None):\n", + "\n", + " variance_series = pd.DataFrame(images.reshape(2000, 28 * 28)).var().rename(\"variance\")\n", + " \n", + " if variance_normalization:\n", + " variance_series = variance_normalization(variance_series)\n", + "\n", + " variance_map = np.array(variance_series).reshape(28, 28)\n", + "\n", + " variance_map \n", + " \n", + " plt.imshow(variance_map)\n", + " plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "variance_map(images, variance_normalization=z_normalization)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "variance_map(images, variance_normalization=min_max_normalization)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "28 * 28" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "672" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "28 * (24)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "x_train = images.reshape(2000, 28 * 28)" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "n_qubits_data = 8" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.decomposition import PCA\n", + "\n", + "# Create an instance of PCA\n", + "pca = PCA(n_components=2 ** n_qubits_data)\n", + "\n", + "# Fit PCA on your 784-dimensional data\n", + "pca.fit(x_train)\n", + "\n", + "# Apply dimensionality reduction on your data\n", + "data_pca = pca.transform(x_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2000, 256)" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_pca.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The sum of the states from the training set 0 1.0\n" + ] + } + ], + "source": [ + "import cmath\n", + "#Funtion to normalize the data of an array\n", + "'''\n", + "Input = Array with n values\n", + "Output = Array with normalized valued\n", + "'''\n", + "def Normalize(row):\n", + " #We calculate the squareroot of the sum of the square values of the row\n", + " suma = np.sqrt(np.sum(row**2)) \n", + " if suma == 0.:\n", + " #If the sum is zero we return a 0\n", + " return 0.0\n", + " #Else we divide each value between the sum value above\n", + " row = row/suma\n", + " return row \n", + "\n", + "#Normalize the training set data\n", + "for i in range(len(x_train)):\n", + " data_pca[i] = Normalize(data_pca[i])\n", + "\n", + " \n", + "print(\"The sum of the states from the training set 0\",np.sum(data_pca[0]**2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2000, 256)" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_pca.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "num_layers = 1 #Number of layers\n", + "#Making a ndarray of floats based on the number of layers\n", + "params = np.random.random(10*(num_layers))" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "#Function to create a quantum circuit based on the number of qubit and a\n", + "#vector of complex amplitudes to initialize to\n", + "'''\n", + "Input: Number of qubits, vector of complex amplitudes\n", + "Output: Quantum Circuit\n", + "'''\n", + "def input_data(n,inputs):\n", + " circuit = QuantumCircuit(n,1) #create the quantum circuit with n qubits\n", + " #initialization of the circuit with the vector of amplitudes\n", + " inputs\n", + " circuit.initialize(inputs, range(0,n,1)) \n", + " circuit.barrier() #Draw a barrier\n", + " return circuit\n", + "\n", + "#Example of a quantum circuit with the first row of te trainig set\n", + "input_data(n_qubits_data, data_pca[0]).draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector\n", + "from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap\n", + "from qiskit.circuit.library import TwoLocal, NLocal, RealAmplitudes, EfficientSU2\n", + "from qiskit.circuit.library import HGate, RXGate, RYGate, RZGate, CXGate, CRXGate, CRZGate\n", + "\n", + "#Function to create a quantum variational circuit\n", + "'''\n", + "Input: number of qubits, number of layers, parameters to initialized the circuit\n", + "Output: Quantum Circuit\n", + "'''\n", + "def vqc(n, num_layers,params):\n", + " #Set the number of layers and qubits\n", + " #ParameterVectors are initialized with a string identifier and an integer specifying the vector length\n", + " parameters = ParameterVector('θ', 10*(num_layers))\n", + " len_p = len(parameters)\n", + " circuit = QuantumCircuit(n, 1) #create the quantum circuit with n qubits\n", + " \n", + "\n", + " #Creating the circuit for each layer\n", + " for layer in range(num_layers):\n", + " #Applying a ry gate in each qubit\n", + " for i in range(n):\n", + " #the rotation of the ry gate is defined in the parameters list\n", + " #based on the layer\n", + " circuit.ry(parameters[(layer)+i], i)\n", + " circuit.barrier() #Create a barrier\n", + "\n", + " circuit.cx(2,0) #Apply a CNOT gate between the qubit 2 and 0\n", + " circuit.cx(3,1) #Apply a CNOT gate between the qubit 3 and 1\n", + " circuit.cx(5,4) #Apply a CNOT gate between the qubit 5 and 4\n", + " circuit.barrier() #Create a barrier\n", + " \n", + " #Apply a RY gate in the qubit 0 with the rotation specified in the parameter list\n", + " circuit.ry(parameters[6+(layer)],0)\n", + " #Apply a RY gate in the qubit 1 with the rotation specified in the parameter list\n", + " circuit.ry(parameters[7+(layer)],1)\n", + " #Apply a RY gate in the qubit 4 with the rotation specified in the parameter list\n", + " circuit.ry(parameters[8+(layer)],4)\n", + " circuit.barrier() #Create a barrier\n", + " \n", + " circuit.cx(4,1) #Apply a CNOT gate between the qubit 4 and 1\n", + " circuit.barrier() #Create a barrier\n", + " \n", + " #Apply a RY gate in the qubit 1 with the rotation specified in the parameter list\n", + " circuit.ry(parameters[9+(layer)], 1)\n", + " circuit.barrier() #Create a barrier\n", + " \n", + "\n", + " #Creating a parameters dictionary\n", + " params_dict = {}\n", + " i = 0\n", + " for p in parameters:\n", + " #The name of the value will be the string identifier and an integer specifying the vector length\n", + " params_dict[p] = params[i] \n", + " i += 1\n", + " #Assign parameters using the assign_parameters method\n", + " circuit = circuit.assign_parameters(parameters = params_dict)\n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1QAAAG5CAYAAACJJHUoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAACPcElEQVR4nOzdeZyNdf/H8dc5Z/YZM4Oxb1mGWWSXLYylUrdCN0Kr+kWDhFRKlJRKiu47tKi0iLLFLUq2KVuRJcOMsTN2MZgxhjkzvz9OnZqMwTRzrmsu7+fj4VG+5zrX+cx33r7nfM51nevYsrOzsxEREREREZFrZje6ABERERERkaJKDZWIiIiIiEg+qaESERERERHJJzVUIiIiIiIi+aSGSkREREREJJ/UUImIiIiIiOSTGioREREREZF8UkMlIiIiIiKST2qoRERERERE8kkNlYiIiIiISD6poRIREREREcknNVQiIiIiIiL5pIZKREREREQkn9RQiYiIiIiI5JMaKhERERERkXxSQyUiIiIiIpJPaqhERERERETySQ2ViIiIiIhIPqmhEhERERERyScvowsQsbLExMQ8b3/nnXcYMGBAnttEREQUZEliIlfKBygjUvQURK6V6auj5xixmqL6vKgjVCIGmjhxotEliMkpI2JFyrVnaJ7FisyYazVUIiIiIiIi+aSGSkREREREJJ/UUIkYaNasWUaXICanjIgVKdeeoXkWKzJjrtVQiYiIiIiI5JMaKhEDde3a1egSxOSUEbEi5dozNM9iRWbMtS6b7kHbl8HZY0ZXYR3FSkOttkZXISK50XpX+LQGioiYgxoqDzp7DFKSja5CRKTwab0TEZHrhU75EzFQ//79jS5BTE4ZEStSrj1D8yxWZMZcq6ESMdCVvulbRBkRK1KuPUPzLFZkxlyroRIxUKtWrYwu4apkZcPxM7BhL6xMgtU7IOEQpJ43ujLrKyoZEbkWyrVnaJ7FisyYa32GSsRAx48fN7qEPJ1Kg1U7YO2uyzdPFYtDi5rQ8Abw0YpS4MyeEZH8UK49Q/MsVmTGXOvlz3XsyckxJOxbg8Phjd3uoGzxqvRqN5zWdbsZXZoYLCsL4rbDN5sh05n3tsmn4MufYOlW6NkMqpf2TI0i+aF1T0RECppO+bvO3dt+BP97JZU5L/7GbY0f4tUvenHwxE6jy7puREVFGV3CJS5kwvsrYN6GKzdTf3UiFd75HuISC62065IZM1LUad0znnLtGZpnsSIz5loNlQDgcHhxe5NHcWZlsuvQJqPLuW7Mnj3b6BJycGbBRz9A4uH83T8bmPuL63NWUjDMlhEr0bpnHOXaMzTPYkVmzLUaKgHgYuYFFqyeDEDFsJoGV3P9GDlypNEl5LBs25WbqQn3uv7kZe4vcOhUwdV1PTNbRqxE655xlGvP0DyLFZkx12qornNfLH2FziNC6ficPx9/9zxDuk2hWvk6AIyZ1ou12xa4t31hamfWb19sVKmWNHPmTKNLcDt+Br7dUjD7cmbB9LWQnV0w+7uemSkjVqF1z3jKtWdonsWKzJhrUzdUWVlZjBs3jvDwcPz8/Khbty5xcXHUqlWLPn36GF2eJfRqN5yvR6cw68UT3BRxB5t3LnffFttpAlO/G0F6Rio/bplDoF8IjWrdamC1Uph+SHI1QgXlwEnYdazg9idSULTuiYhIQTJ1Q/XII48wevRo+vbty6JFi+jevTs9e/Zk9+7dNGzY0OjyLKVYQHGGdJvCT4nfsDp+HgDFg0rT5eYnmDhvIF8sfZnH7hpvcJVSWC46Yd3ugt/vGn3OX0xM656IiBQE0zZU06dPZ+rUqcyfP5+hQ4fSpk0bhg8fTrNmzcjMzKRBgwZGl2g5wQEl+HfLIXz07XNkZbkOVdzW+CGSjyfRucVAggNKGFyh9cTFxRldAuD6vNP5iwW/Xx2h+ufMkhGr0rpnDOXaMzTPYkVmzLVpG6oxY8bQoUMHWrdunWO8Ro0aeHt7U6eO63z3vXv30rp1a2rWrMmNN97Ijz/+aES5ltGl5ROcPHOY73/51D1WvmQNKoTVMLAq69q6davRJQCQfLJw9pty7vJfCCxXxywZsTKte56nXHuG5lmsyIy5NuUX+yYnJxMfH8/gwYMvuW3//v1ER0fj6+sLQN++fbnnnnvo168fq1evplu3buzZswcfH588H8NmsxVK7XkZ99hy6laP8fjjXs6bsSsuGQv0C2bOS4X06rqAxcWtoHHPNkaXkafcMvxX48ePv6ptCttNnUfQrOtLOcaudCW/y90+aFrOv1epHsXJQwn/oDrrutLvHsyTkWtltvXuD0V93fsrs66BBZFrM2bajIrKc4zI1TLb82L2VV5dy5RHqJKTkwEoW7ZsjvH09HTi4uLcp/udOHGClStX8sgjjwDQvHlzypcvz/LlyxGRa1F4l+PLLsR9i4iIiBjNln21rZcH7dy5k/DwcMaPH8+gQYPc46NGjeLFF19k4sSJ9OvXjw0bNtC1a1d27/7z0/Tdu3enffv2prwK4PoZkJJsdBXWEVoRGvUwuoq8JSYm5nl7ZGQkCQl5H72JiIgoyJJy9dMu12XOr8YfR6b+fiTqcl7tBv55HzC+bl0pH2CejFwrrXeFz6xrYEHk2oyZNqOi8hwjcrWK6vOiKU/5q1atGnXq1GHMmDGUKFGCChUqMGvWLBYuXAigK/yJZYwaNcroEgCoVEifuy9VTM3UP2WWjIgUJOXaMzTPYkVmzLUpT/mz2+3MnDmT6OhoYmNj6d27N2FhYfTv3x+Hw+G+IEXlypU5evQoGRkZ7vvu2bOHKlWqGFW6yDXp3r270SUAUCYEgv0Kfr/hZa+8jeTNLBkRKUjKtWdonsWKzJhrUzZUADVr1mT58uWkpaWxf/9+Ro8ezZYtW4iKisLf3x+AsLAwWrRowYcffgjA6tWrOXjwIG3amO9DuiK5iYyMNLoEABx2aBZe8PttUQj7vN6YJSMiBUm59gzNs1iRGXNtylP+Lmf9+vU0bdo0x9i7777LQw89xIQJE/Dx8WH69OlXvMKfmUyeP5ik5PXUqNCA/p3edo+/8nkPTp49wsXMDDIupvPekE3MWPYaP29fRMaFc/Rs+xw339iFnQc38d+5/bHb7TzcYQw3VmvJd+umMmP5q5QoVo6ISjfxaMexOJ2ZvPFVb46c3EPTyI70aDuMnQc38vqMB0jPOMvnz+0FIC39NK9Ov5f0jFRa1O7M3S0HsedIPBNm9cFud1C+ZA2Gdv+I9du/Y8by1wBIPr6dgXdPplr5uoyd8QA2bISFVOSZnp/hsDvoPbYWJYqVA2Dg3ZOoUiaKo6f28d+5/Tl/IY12De7j9pseYePOZXy8aDg+3n480+MzSoVW5MnJMWSTjQ0b990ykvo12nr8d3S9aBEOPyRCegF9H1VUeahQvGD2JUXf5da6X5K+Z+p3I/D19mfg3ZOpXDqCE6cP8fr0+7iQeZ4Hb32JBjXbM2neIHYd2gTA7sObmfvSKWYse411278FIOnAOqY9f4A1W+ezeP1U93Zv9F3OqbNHLlmvmkT+iyGTWrHnyBbeHbyJCmE1yHRevGTsdNoJRn58Fw6HN4F+ITx/35f4evvTaUQINcrXB+CFB+cQHFCCDxY8TfzeVdjtdp7s9hEVS4Xnuv7ltq7tORLP27MfIzs7myfunky18nVyfR4QERHzKTINVWpqKklJSfTr1y/HeLVq1fjhhx8Mquqf2ZG8gfSMVMb3+5G3Z8ey/cA6alVqDMDw+2YAsHLLXHYc/AWArq2fpEfbYaRnpPL0++25+cYufLJ4JM/f9yXFAkow6pO7ebWa68VFt9ZPcUeT/3M/1upt86lUOoJhPT/j+Y86cvLMEcqXrMF/Hl/Lsx/c5t7um5/ep239e2lbvyejPvk37RrcR6VStXh7wGoA3viyN0nJ62kc0YHGER0AePw/TWgQ3p5M50Ve7r2AQP8QPlo0nJ8TF9Is6k5CAktdcqnijxcNZ2j3jwkNKuUem7ZkNK89uph9x7YxfdmrDLx7ousx+yzF4SgyUS2ygv2hSyP4Ys0/35efN3Rv8s/3I9aQ11r3+ZKXGNt3KefOn2Hy/EE8f9+XfLn8NR68bTTVy9fl+Y860qBme/p1mgDAzoMbmRX3JgA92g6jR9thnE47wUufdiU4oAS3NX6I2xo/hNOZSb+3G1G9fF1stnqXrFcOuxejHvqaD755xl1nbmNB/sUZ328ldrudzxaPYu22BbSu242qZW/Msa6dOXeSpOT1vD1gFfF7VvG/NZOIvWt8rusfXLquffLtCJ67dzp2m53/zOnHS73n5fo8ICIi5mPaU/7+LigoCKfTyeOPP250KQUmYf9aGta8BYAG4e3Ztu/SV7Kr4udyc+27AfByeAOQcTGdG8rWBiA1/RSlQivi5xPA+YtpZFxMB2DujxMYMqkVG3YsBSBx31oahrseq271NiQe+JkAv2L4+wTmeLzDv+2mWjnXZ9SqlIli+4F17scF8PbypVRIpRzbhxYrg79vEMUCihPoH+Ku1W5zAHD23EmGTGrFhFl9uXDxPJnOixxN2ceE2X0Z9sFtJB9P4vyFc/h4+xPgV4zIyk3Yd9T1pW12m52n32/PK5/34My5ovc9MVcSExNjdAk5NK4Kza9wmt6gaXlf4c9ugwdaQGhAwdZ2vTJbRvLjSmudv08gJYPLcei3XQDsObKF6Bua4+8bRIBvMdLOn3FvuzJ+Li1uvDvH/ddsnU+zqLtyjP265wfqVGuV4zsH/7pe2Ww2ihcrk+M+uY057A7sdtdTpTPbSYUw1z+Q/ccSGDypJVMWDiM7Oxt/nyAC/UJwZjlJO59CcEBJ4NL1D3Jf186mn6J0aCXCQiqQej4lRw1/fR6wCivkuijQPIsVmTHXRaahsqLU9BQCfIMBCPQLITU9Jcftmc6L7DmyhfCKDdxj/5nTj75v1XGf+hYSWIo9R+JJST3O3iPxpKan0KJ2Z94b8isjH5jN+wuG4sxykno+hQC/Px8r7W+P9YdKpWvx6+44nFlOft3zg7um1Vvn8+i42qScPUpwYEn39iu3zKFF7S459nHi9CF+SfqeRjVvBWB8/5W81e8HShevwjc/vc/ptBPsPvwrg/79Ho/d+RYffPM0qekpBP4+FwBZ2U4ARjwwizdjV9As+i6+WPLyNc6w+U2ePNnoEnKw2aBrY2hVK3/39/WCR1pBVIWCret6ZraM5MeV1rpTZ4+y/1giB466LoObleV0N0J/X6/Wb/+WxrU65Lj/qvi5tLgx5zqU29qU29jVSNz/M/3ebsSmncsoV6IqAFOf2cFbsT+Qeu4Ua7b9D28vH8qWqMrDY2vxztwBdLjJ9f2If1//IPd1LTs7688H/Mu3meT2PGAFVsh1UaB5FisyY67VUBko0C+Ecxmud17TMs4Q5B+a4/bNu1ZQt3pMjrGBd0/io6cS+WLpKwD83x2v8e78Ibw9+zGqlqtDSGAYQf6h2O12QoNKUbFUTU6dPep6rN/f5T13/gyBf3usP9ze5FG27V3Nc1Nup2Rwefe7tc2j7+KDofGEhVZk7bYF7u3XJPyP5n95Z/hCZgZvfPkgQ7p94D6dJTjAdU3uFrW7sPdIPIF+IVQpHUVoUCluKBvNmXO/EegfQlrGn+9C/3F066/33XMk/qrntqiIjY01uoRL2G1wdyPoEwMh/ld/v5pl4Zl/QXTFQivtumTGjFyrvNa6R+8YyyvTejBj2WtE3dACAJvtz6emtIw/16vk4zsIC66An8+fhz/PnT/L6bQT7kYHXN9sH79nJTdWa5Wjjr+vV1crovJNTHpiPS1qd+HbdR8BrrXJZrPRvHZn9h6JZ9/RBA6e2MHHTyfx/P0z+fjb4e7t4M/17+9j7nXtL0fS/vrz5/Y8YAVWyHVRoHkWKzJjrtVQGSiqSjM2/n5K3sYdS4isnPOCG6vi5+Z4N/VCpuvy8D7e/u53eyuWqsnrfRYzqOt7lA6tjJfD2316TMbFdA6e2EFoUCkiqzRj407XY23etdz9+YW/8/cJZFivzxnzf4vIzs4iqkoz9+MCBPgG4+vtepV98swRvB0+OY5YTZjVh7ua96dKmSgALmZecN9/695VlCtZHT+fAPx9gzh/4RwnTh8kwDcYf59ALlxMJz0jlcT9P7vv/8fPsnXPKsqXrH7Nc2x2K1asMLqEy4qqAM93gnubQbVS4JXLahHoCw1vgIG3QGxbKBHk8TItz8wZuVp5rXVRNzRj3GPL6dVuOJXLuK7cVK1cHbbtXUP6hTTXG0C/H13/+5oIsG77IhpH3J5jbPuBdYRXbIDD7nCP5bZeXY2LmRfc/x/oF4yPtz/pF9JwZrmOom/d+8falE3g729mhQSGkZZ+Otf1D3Jf14L9S3A8JZkTpw+5zya43M9sBVbIdVGgeRYrMmOu9Ul/A4VXbIC3tx+DJ7Wkevl6lA6tzLSlr3Bvu+FkZ2ezbd8aBnR+x739pHlPcOBYIpnOC3SLeQqART9/yNINn+Pj7c/jXVwXcZjzw3jWbf+W7OwserQZhpfDm2ZRd/LGl7MZNPFmboq4g5LB5TiWcoBxX/Zm75F4nn6vPUO6TeHMud94f8FQbNjoHvM0vt7+rI6fx6wf3wKgQlg4DX8/lW/11nk0i+7krm/b3jWsjJ/D0VP7mPPjBLrc/ATRNzTnuQ9vx98niCD/4gzr+TkAvdo9z7NTbsPpzKR/5/+6xtoO55n3b8HH24+n7/kEgKfea4uvtz8+Xn48dc/Uwv2FyCW8HdC4muuPMwuOnoaxru/XZmQnKB6Y4411kVzltdZNW/oKG3csITigJIP+/R4A3WOeZuyMB8i4mM4Dt/75BY4/JSxg1EPzcux7ZfxcerUbnmMst88c/X29Ahj9WXfi967k4Ikd3BPzNM1rd7pkrERwOd7/5insNjvF/EvwTM/PSD6exJszH8bfJ4iyJarywK2jcNgdBPgWY/Cklq4LYnR6m9T0U7muf7mtaw/cOoqXP78HwL2W5/Y8ICIi5mPLzv7LydpSqNbPgJRko6uwjtCK0KiH0VXkLTExMc/bIyMjSUhIyHObiIiIgizpH/vjghQT7jW2Diu4Uj6gaGYEtN55glnXwILItRkzbUZWfI6R61tRfV7UKX8iBrrSgiCijIgVKdeeoXkWKzJjrtVQiRjoq6++MroEMTllRKxIufYMzbNYkRlzrc9QeVCx0kZXYC1WmM8XXniB7t27G12GmFhRzYgV/n2aXVGe46Ka66JG8yxWZMZcq6HyoFptja5ARMQztN6JiMj1Qqf8iYiIiIiI5JMaKhEDTZo0yegSxOSUEbEi5dozNM9iRWbMtRoqEQNFR0cbXYKYnDIiVqRce4bmWazIjLlWQyVioNatWxtdgpicMiJWpFx7huZZrMiMuVZDJSIiIiIikk9qqERERERERPJJDZWIgRo3bmx0CWJyyohYkXLtGZpnsSIz5loNlYiB1q1bZ3QJYnLKiFiRcu0ZmmexIjPmWg2ViIiIiIhIPqmhEhERERERySc1VCIGmjVrltEliMkpI2JFyrVnaJ7FisyYazVUIiIiIiIi+aSGSsRAXbt2NboEMTllRKxIufYMzbNYkRlz7WV0AVa3fRmcPWZ0FdZXrDTUamt0FSLyB619hU/rnliV1o/Cp/WjYKmhKmRnj0FKstFViIh4ltY+EckvrR9S1OiUPxED9e/f3+gSxOSUEbEi5dozNM9iRWbMtRoqEQMNGDDA6BLE5JQRsSLl2jM0z2JFZsy1TvkTMVCrVq344YcfjC7DcrKyYNsh2HoQDvwGJ1LBmQX+3lC+OFQJg8ZVIayY0ZVemTIiVmT2XKdfgF/2ws6jkHwSzqQDNgj2g4olILwMNKwKft5GV5o3s8+zSH6YMddqqK5jT06OIWHfGhwOb+x2B2WLV6VXu+G0rtvN6NKuG8ePHze6BEvJzna9CPpmM5xKu/T2i044cxgSD8PiLRBVAe5uBCWDPF7qVVNGCpbWPXMwa64vZMKiX2HVDtf//92JVNefTfth/kZoURM63Ag+Jn01ZdZ5Lsq0hhjPjLk26RIgnnJv+xHc2/55nM5M5q1+h1e/6EWNCvWpEFbD6NJErsm5C/DFGoi/yg8yZ+M6grXjKPy7ETSpXqjliYlo3ZPcJJ+ET1bC8bNXt31GJizbBlsOwIM3u45cyfVBa4j8nT5DJQA4HF7c3uRRnFmZ7Dq0yehyrhtRUVFGl2AJ5y7ApCVX30z91YVMmL4WViQUfF0FQRkpPFr3jGO2XO89Af/9/uqbqb86fhbeWQL7fyv4uv4ps82z1WgNMYYZc62GSgC4mHmBBasnA1AxrKbB1Vw/Zs+ebXQJRV52Nny2CpJPXX6bCfe6/uTl6w2w1YSX6VVGCo/WPeOYKddn0uGD5a4jTpdzpTXk/EV4fzmcPV/w9f0TZppnK9IaYgwz5loN1XXui6Wv0HlEKB2f8+fj755nSLcpVCtfB4Ax03qxdtsC97YvTO3M+u2LjSrVkkaOHGl0CUXeT7sg4VDB7OvLn+FcRsHsq6AoIwVP657xzJLr7GyY+TOkXfjn+0rNgFnr/vl+CpJZ5tlqtIYYy4y5NnVDlZWVxbhx4wgPD8fPz4+6desSFxdHrVq16NOnj9HlWUKvdsP5enQKs148wU0Rd7B553L3bbGdJjD1uxGkZ6Ty45Y5BPqF0KjWrQZWaz0zZ840uoQiLdMJCzYX3P7OpMOKxILbX0FQRgqe1j3jmSXXe0/AlgI8Mr15v2ufZmGWebYarSHGMmOuTd1QPfLII4wePZq+ffuyaNEiunfvTs+ePdm9ezcNGzY0ujxLKRZQnCHdpvBT4jesjp8HQPGg0nS5+QkmzhvIF0tf5rG7xhtcpUhOmw9AagGfYrN2p6tRE+vTuicrkwp+n6sKYZ9iTlpD5A+mbaimT5/O1KlTmT9/PkOHDqVNmzYMHz6cZs2akZmZSYMGDYwu0XKCA0rw75ZD+Ojb58jKygLgtsYPkXw8ic4tBhIcoEsYibn8ur/g93nmvLneYZbCpXXv+pWVVbBHp/7w6wHIyi74/Yo5aQ0RMHFDNWbMGDp06EDr1q1zjNeoUQNvb2/q1HGdqzpy5Ehq1qyJ3W5n1qxZRpRqKV1aPsHJM4f5/pdP3WPlS9bQpUALSVxcnNElFGkHThat/eaHMlL4tO55nhlyfexs7t819U9lZObvaoGFwQzzfD3QGuJZZsy1Kb+HKjk5mfj4eAYPHnzJbfv37yc6OhpfX18AOnTowEMPPcTDDz98TY9hs9kKpNYrGffYcupWj/HIY12rN2NXXDIW6BfMnJdM9GryKsXFraBxzzZGl3GJ3DL8V7t27aJ69by/AGn8eHOdLvDE5663Xj31b+hy7A5vHv/kAtnZ2e5arnQlv8vdPmhazr+/PO492n70WAFUmbcr5QOKZkbAvGuf1r3CVxC59kSmqzfqTMdBc3OMFdQa0izmTvZsXJD7xgXIis8xYN71A6yzhlh5/YCCy3V29tUdbjblEarkZNcx+LJly+YYT09PJy4uLsfpfs2bN6datWoerU+koMyfP9/oEoosu5c3UDiNncPLp8D3mV/KiFiRGXJtdxTev3OHl2+h7ftamGGeRQqaGXNty77a1suDdu7cSXh4OOPHj2fQoEHu8VGjRvHiiy8yceJE+vXrl+M+MTExDBgwgK5du3q42rytnwEpJvxuG6sJrQiNehhdxaUSE/O+ZFxkZCQJCXl/o2xERERBlvSP/fFO7JXeyS1sWVkwdMbVfVbhj1r//i7y5bSsCf9unP/artaV8gFFMyOgtc8Tiuq6B1fOtScyvfUgfLDi6ra91jWkbxuILJ+vsq6JFZ9jQOuHJ1h5/QDP59qUp/xVq1aNOnXqMGbMGEqUKEGFChWYNWsWCxcuBNAV/kQEux3KhMDhlILfd/niBb9PETGX8qFFc98iYj6mPOXPbrczc+ZMoqOjiY2NpXfv3oSFhdG/f38cDof7ghQiRd2oUaOMLqFIq1KycPZbuZD2mx/KiFiRGXIdGgDBfgW/3xB/CAko+P3mhxnmWaSgmTHXpjxCBVCzZk2WL1+eY+z+++8nKioKf39/g6oSKVjdu3c3uoQirXFVWLurYPdZPtRc7y4rI2JFZsi1zQaNqsGybQW738Ym+li3GeZZpKCZMdembahys379epo2bZpjbMSIEXz88cccP36cLVu2MGjQIOLi4q549Q8jTZ4/mKTk9dSo0ID+nd52j8dtnsnMuDewYaNn2+doXrsTE2b1Zc+ReGw2GwO7TKJa+TpMmjeIXYc2AbD78GbmvnSKxes/4dufPyTjYjq3Ne7NXc375Tq27+g23pr5KAD1a7TloQ6jmbHsNdZt/xaApAPrmPb8AbbuXcUXS1/Bho2WdbrSrfWT7jpn/zCeH7fMZkL/lew5Es+EWX2w2x2UL1mDod0/wmazXfIzJuz/iXfnD8Zms1OrUmNi7xrPzoObmDx/EADHTu2jS8snuLvlIHqPrUWJYuUAGHj3JKqUiQLgtzOHeeDVarz/5BbLXIr0as4DlsurVtrV/BxKKbh9tqzleqFlFlbKyOXWvlc+78HJs0e4mJlBxsV03huyiW9//ohpS0YTfUMLhvX6HIALF8/z37n9OXJyD1XKRjOg83/5dPGLrIqfS5B/cZpF3UXX1kP4bt1UZix/lRLFyhFR6SYe7TgWgBnLX2dD0vc4szJ5o+8ydh/ezOszHiA94yyfP7cXgJNnjvDKtB5kk035ktUZ2v0jNu9awdgZD1K2RFVKh1bmmZ6f5rr2/XbmMCM+7si+o9v438upOBxeOJ2ZvDb9Pk6lHqVWxcbuWjqNCKFG+foAvPDgHIIDSrDz4EY++OZpnFmZdGs9lCaR/wJgR/IG+r3dkG9fu4jDUaSeti/LLLluXgNWJBTc90bZbdDMRE9PZpnngnC59QMg42I694+pyrCen9OgZnumLX2F+asn0qHxw/Tu8DIAvyR9z9TvRuDr7c/AuydTuXQEny0e5X7981CHl2kQ3o6srCw++OZpdh3aRFBAcUbePzPX11Pnzp/l1S96cebcSTo27cstjR7Ide3ZeXDjJevMd+umsnj9VMD1Ou6Nvss5dfYIM5a/BkDy8e0MvHsyzaLuYuyMBziWsh8vhw/D75sBwMiP78Lh8CbQL4Tn7/sSX2//XNeUGcteY23CAooHleHpnp/i7xNY2L8mjzBjrovMypyamkpSUtIlF6MYPXo0o0ePNqiqa7cjeQPpGamM7/cjb8+OZfuBddSq5Pr0+5wfxzPusRXYbDaendKB5rU7cU/bYZQrUZXk4zv4cOEwXnhwNv06TQBg58GNzIp7E4C29Xtxa6MHcWY56TehAXc175fr2II17/LIHa9Sp1ornnn/FlLTU+jRdhg92g7jdNoJXvq0K8EBJaheri4T+q/CbrPz5Lsx3HHT/xHoH8KFzAx3MwdQqVQt3h6wGoA3vuxNUvJ67DbHJT9jmdAqvNF3GT7efrz6xb3sObyFGhXquS8/OvLjTjSJ7AhASGCpXC9LOufHCURUblI4vxgpkmw26NoY/vs9FMTroSoloYmJ3l22krzWvj9eJKzcMpcdB38BoFn0XdxYrRWfLX7RvY+5K/9Dm/q9aBDeLse++3Z8kwY12+cY69b6Ke5o8n/uvyfu/5nzGamM7bvEPVa+ZA3+8/hanv3gNvfYso1f0KHxw9zS6AHemvkouw5tBqB9w/vdL8wg97WvatkbGdtnKS9+0sW93cr4uVQrX5eebZ/lna8fZ9ehzVQvX5eqZW+8ZJ37fMloRj00Dz+fnOeLzV8zifAK+jL7whBWDNpHw+L4gtnfLbWhZFDB7Ev+lNf6AbDopylULXej++933PR/RFdpzsadS91jny95ibF9l3Lu/Bkmzx/E8/d9SftGD3D/rS+Qmp7CyI/vokF4O37cMovKZSLpe+c4931zez218KcPiKnXg5h6PXjq3TbE1HNd4eHva09u68xtjR/itsYP4XRm0u/tRlQvXxebrR6NIzoA8Ph/mtAgvD27Dm3Cy8uHt/r9wNIN01i6YRqdWgxgfL+V2O12Pls8irXbFtC6brdL1pTfzhxmy54fmdB/JT/+OptFP03h7pZPFNwvRXIw5WeochMUFITT6eTxxx83upR/JGH/WhrWvAWABuHt2bZvjfu2ciWrc/5CGukZqQT6BrvGSlQFwMvhjd3uyLGvlfFzaXHj3e7bATKdF6hcOvKyYxVL1SLt/GmcWU4AvP9yadc1W+fTLOouAEoXr4zD7sBms+Gwe2GzuaLy7c8fckujB933+eMx/thXqZBKuf6MJYLL4uPtOlndYc/5s6RfSOPU2SPuo05nz51kyKRWTJjVlwsXzwNwOu0E586foUzxG65uouW6Ua00tIvOe5tB0658dS5fL+jZzHWxCyl4ea19f1gVP5eba7vWtJDAMBz2nO/5bd69gjXb5vPk5BhWb/3zsrlTFj7D0++1Z+fBTe6xuT9OYMikVmzY4XpBtTZhAafTTjD03TZ89v1LAAT4FbvkHduKpWqSdv40AOkZZwnyDwVg+cbpDJ7UkmUbpwO5r30+3n4UC8h5RZPDJ3dTrZzrc7/Vy9dj215XE7b/WAKDJ7VkysJhZGdnc/i33VzIPM9Ln3XlhamdOXX2KAB7j2ylVEhF/H2L5Tm/kn+31oZKJfLe5mrWkMol4ZYrrEWSP3mtHxczL5Cwfy3RN7RwjxUvVibXr9Tw9wmkZHA5Dv3mOlf8j9dY3l6+7lMT1m5bwL4jW3lycgwLf/oAyP31VML+tTSoeQsOu4Nq5ety4Jjr6nR/X3tyW2f+8OueH6hTrVWOWg//tpvQYmXw9w0iLKQCWb+/XktNTyE4oCQOuwP7709UzmwnFcLCgUvXlGMp+91n+FQvX49t+1ZfzVRLPumlg4elpqcQ8HuzFOgXQmp6ivu2FrW7EDuhPo+Nr0enFjkbxw8XPUuXmwfmGFu//Vsa1+rg/vtn37/EQ6+HE16x4WXHGta8hUlfD+ThsbWIrNIMX+8/P4+2Kn4uLW78851VgJ8TF1G+ZHUC/IqR6bzI5l0rqF+jbY5tVm+dz6PjapNy9ijBgSXz/Bl3H/qV02nH3f/IAdYlLqLRX36O8f1X8la/HyhdvArf/PQ+4Do61anFgMvMatEVExNjdAmWcEfdf3aaja8X9GkDZUMKrqaCYpWM5LUuAGQ6L7LnyBbCK17+SMzh33bRJOJfvPzIN0xbMhqnM5PONw9k0qBfGHj3ZCbOc62bLWp35r0hvzLygdm8v2AoziwnKWePEhRQnHGPLWf/0W3sSN6Q62PUqnwT3/z0Pg+/EYmXw4cyxatQs2IjPno6kTH/9y1fr/wPKanHgUvXvtxUKlWLX3fFAbB553JSz7t+7qnP7OCt2B9IPXeKNdv+x6mzRzl4PImR98/iX0378sXSVwCtfZ7g5XBd5vyffHayfHHoE+Pal5mYaZ7/ibzWj8Xrp9KuwX1XtZ9TZ4+y/1giB47mPF3s08Uv0rFpX9c2qUepVDqCsX2WsHTDNPebG39/PZWanuJ+8zvQL4TU8ym5rj15WbllDi1qd7nsWHBgGBkX03n4jUgWrJnMzb+/iZ64/2f6vd2ITTuXuZvCv68p5UpUI/HAzzidmWzateySNbcoM2Ou1VB5WKBfCOcyzgCQlnHG/e4nwOffv8SUodv48KkEPl/yknt8zo8TqFI6itpVb3aPJR/fQVhwhRynhtx/y0g+GbaLH36dyZm033Idm/rdCJ6//ys+fjqJvYe3cOTkXgDOnT/L6bQT7n+Y4HqX5KsVY3nsLte3TS/55TPa1u91yc/UPPouPhgaT1hoRdZuW3DZn/HMuZO88/UAnuz2YY77r4qf614kAIIDXG8Vtqjdhb1H4klNT+F4ygFuKGu9t/4mT55sdAmWYLdB95ugc0PwvsYXNBWLwxO3QvXShVPbP2WVjOS19gFs3rWCutVjrriPOtVb4+8TSPmwGpxKPepeLyqWCndvF+Qfit1uJzSoFBVL1eTU2aOu+1ZrDUDd6m3Yfyz38+9nxb3Jfe1H8tFTCQT6h/Dr7h/w9w3Cy+GNv08gN1ZrxcETO4BL177cNI26k4zMdJ56rx3eXr4UDyoDuNY5m81G89qd2XsknkD/EGpWaoyfTwD1arRl/7EEko/vIMAvmJDAsLwntwgyW66D/GDALdCo6pW3/bubqsHj7V37MBuzzXN+XW79cDozWb/9O26KuP2K+3j0jrG8Mq0HM5a9RtRfjmat3DKXM+d+c7+++WOtcDi8iKrSjIMndgKXvp4K9A8h7feazp0/Q5BfaK5rz+VkZ2cTv2clN1ZrlWN8TcL/aP772UK/JC0mJLAUHz2VwP23vsjMONdpiBGVb2LSE+tpUbsL3677CLh0TQkNKkX7Bvfx9PvtOXh8h3vtsQIz5loNlYdFVWnGxt8PA2/csYTIyn9eZMPHyxc/7wD8fALJdF4AYP32xWzdu5p72z+fYz+r4ufmeFfjQmYGAN4OH3y9A/D28s11LDs7m2L+JbDb7QT4hZCecRaAddsX0fgvC9K582d548uHeLLbh+5D1QeOb+d/aybz7Acd2Hd0K1+v/K/7MQACfIPx9fbP9Wf844PZfTqOo0RwWfd9Mp0X2X8sgerl6wKuQ/d/7HPr3lWUK1mdA8e3k3w8iWc/6MCGHd/z9uzH8j3/ZhMbG2t0CZZhs0FMBDx9h+sqW15XWN3CglwN2OAO5v7eKatkJK+1Dy5d03LfR3P2HP4VZ5aToyf3EhJYirTzrhc0p9NO4HRmArjHMi6mc/DEDkKDShF1g+u+ALsObaJsicu8cs7OptjvTVpwQEnSzp9278+Z5STpwDrKFL8h17UvNw67gwGd/8sbfZditztoVOs20i+kud+53rp3FeVLVqdCWDgpqcdwZjnd9e05soWkA+t49oMO7Dn8KxPmaO0rTAE+cF9z15GmGlfx2jO8jOvIVq9m4O9T6OXlixnnOT8ut36cSj3KsZT9PPtBB5Zu+JwPFz3L2XOnct/HDc0Y99hyerUbTuUyrtP2dh/6lfmrJ/J4l4nu7aJvaM7u39eKPUe2UKZ4lVxfT0VVdtX0x7/ZSqUjcl17Lmf7gXWEV2yA4y8fgTh55gjeDh/3Ee/s7Gz3m0YhgWGknT/NxcwL7u0D/YLx8fbPdU0BuKPJo7wZu4LKZaLcF7mxAjPmushclMIqwis2wNvbj8GTWlK9fD1Kh1Zm2tJXuLfdcDo2i2XQRNe7Jnc06QPAxHmPE+AbzNB321CpVC0GdX0PgJ8SFjDqoXnu/c5Y9iqbd60g03mB9g3ux983iE8Xv3jJ2D1tnuH1GfdjtzuoXDrS/SHOlfFz6dVuuHt/81a/w5GTexj31cMADL3nYx791+vu2wdNvJnONz/O6vh5zPrxLQAqhIXTsOat2O32HD9jROWbWLZxOkkH1vHBN08D8MjtrxJ1QzM27lxGvep/nkKYmn6K5z68HX+fIIL8izOs5+cE+BXjP4+7zpceO+OhS5rLomzFihVGl2A5pYLh3mbQqT4kHYEDJ2H57wcjGlSBCsXhhjCoWtp1ZMvsrJKRvNa+7Oxstu1bw4DO77i3X7ttATOWv8bh33Yx6pN/88KDs7mnzTOMnfEg5zLOcEeTR/H28mHi14+z50g82dlZPHKH6wpZc34Yz7rt35KdnUWPNsPwcnjTNLIjb816lCGTW1O5VATRNzTnWMoBxn3Zm71H4nn6vfYM6TaFO5v3Y+yXD/L5kpcIDihJz7bP8f0vn7Lwp/ex2ey0qdeTsJDyua59mc6LPDfldnYf3sywKbfx8O1jKBVSkVe/uBe7zU77hg8QFlKBnQc38ebMh/H3CaJsiao8cOsoHHYHdzR5lKHvxmCz2XnqnqmUK1GVlr8fvX9ycgyD7n7X87+4QmLmXEdVcP05ehp2HoMDv/359QzNakDFEq6Gq0ywsXVeDTPP87XIa/2Y+MQ6wHXaXu0bbqZYQHEW/fwh/1s9ibPnTnL23CkG3j2RaUtfYeOOJQQHlGTQv12vpd7/5ilOpR7l2Q9uI9AvhJd6z6ND40cY++WDzPlxAo1q3Uap0Iq5vp66vcn/8eoXvZi36r/c0aQP3l4+zFj26iVrT27rTNkSN+T4zOgfVm+dR7PoTu6/N6p5K9+t+4gnJ8eQnZ3F0O4fs+vQJt7/5insNjvF/EvwTM/PSD6edMmaAvDSZ904e+4k1crVoW/HNz302yp8Zsy1LTs7u4AuFiq5WT8DUpKNrsL6QitCox5GV3GpxMTEPG+/mkt/RkREFGRJ/9gfH8yecK+xdVwLs9Z8pXxA0cwIaO3zhKK67sGVc222TBfVNUTrh1yOldcP8HyudcqfiIiIiIhIPqmhEjGQ2b6YTsxHGRErUq49Q/MsVmTGXOszVIWsmEmvHGY1RXWev/rqK7p37250GWJiRTUjRfXfZFFSlOe4qOa6qCmq81yUs11UFOU5NmOu1VAVslptr7yNXL9eeOEF0y0KYi5FNSNa+yQvRTXXRU1RnWetH5IXM+Zap/yJiIiIiIjkkxoqERERERGRfFJDJWKgSZMmGV2CmJwyIlakXHuG5lmsyIy5VkMlYqDo6GijSxCTU0bEipRrz9A8ixWZMddqqEQM1Lp1a6NLEJNTRsSKlGvP0DyLFZkx12qoRERERERE8kkNlYiBGjdubHQJYnLKiFiRcu0ZmmexIjPmWg2ViIHWrVtndAlicsqIWJFy7RmaZ7EiM+ZaDZWIiIiIiEg+qaESERERERHJJzVUIgaaNWuW0SWIySkjYkXKtWdonsWKzJhrNVQiIiIiIiL5pIZKxEBdu3Y1ugQxOWVErEi59gzNs1iRGXPtZXQBVrd9GZw9ZnQV1lesNNRqa3QVIiIiInK9UUNVyM4eg5Rko6sQEREREZHCoFP+RAzUv39/o0sQk1NGxIqUa8/QPIsVmTHXaqhEDDRgwACjSxCTU0bEipRrz9A8ixWZMddqqEQM1KpVK6NLEJNTRsSKlGvP0DyLFZkx12qoRAx0/Phxo0sQk1NGxIqUa8/QPIsVmTHXuijFdezJyTEk7FuDw+GN3e6gbPGq9Go3nNZ1uxldmoiIiIhIkaCG6jp3b/sR3Nv+eZzOTOatfodXv+hFjQr1qRBWw+jSrgtRUVFGlyAmp4yIFSnXnqF5FisyY651yp8A4HB4cXuTR3FmZbLr0Cajy7luzJ492+gSxOSUEbEi5dozNM9iRWbMtRoqAeBi5gUWrJ4MQMWwmgZXc/0YOXKk0SWIySkjYkXKtWdonsWKzJhrUzdUWVlZjBs3jvDwcPz8/Khbty5xcXHUqlWLPn36GF2eJXyx9BU6jwil43P+fPzd8wzpNoVq5esAMGZaL9ZuW+De9oWpnVm/fbFRpVrSzJkzjS7hmhxO+fP/0zIMK+O6UtQyInI1lGvP0DyLFZkx16ZuqB555BFGjx5N3759WbRoEd27d6dnz57s3r2bhg0bGl2eJfRqN5yvR6cw68UT3BRxB5t3LnffFttpAlO/G0F6Rio/bplDoF8IjWrdamC1YpSDp+DtxfD6N3+OjZwDM9ZCxkXj6hIRERExmmkvSjF9+nSmTp3KihUraN26NQBt2rRhw4YNzJkzhwYNGhhcobUUCyjOkG5TePC16qyOn0fz2p0oHlSaLjc/wcR5A9l1aBOv91lidJligD+aqYvOnOPOLFi7Cw6fhv7twMe0q4mIiIhI4THtEaoxY8bQoUMHdzP1hxo1auDt7U2dOnU4deoUHTt2pGbNmtStW5dbb72VnTt3GlRx0RccUIJ/txzCR98+R1ZWFgC3NX6I5ONJdG4xkOCAEgZXaD1xcXFGl3BFs9fBxUzIzs799n0n4Kddnq3pelIUMiJyrZRrz9A8ixWZMdembKiSk5OJj4+nW7dLvw9p//79REdH4+vri81mY9CgQSQlJbF582Y6duxI7969DajYOrq0fIKTZw7z/S+fusfKl6yhy6gXkq1btxpdQp6Onobdx+EyvRQANuDHJE9VdP0xe0ZE8kO59gzNs1iRGXNtypN0kpOTAShbtmyO8fT0dOLi4rj99tsBCA0NpX379u7bmzdvztixY6/qMWw2WwFVm7dxjy2nbvUYjzzWtXozdsUlY4F+wcx56aTni/mH4uJW0LhnG6PLuMTgwYPzvH38+PFXtY1RqjfqQsdBc/LcJhs4ejoLm93r8oexDPbE5666PPXv/mpd6XcP5s+IyN8VRK7NlumiuoZo/ZCixmzPi9lX+brGlEeowsLCAEhKyvm299ixYzl8+PBlL0gxYcIEOnfuXNjliVw3sjIvXN12TqdpmykRERGRwmTLvtrWy4OysrKoX78+hw8fZty4cVSoUIFZs2axcOFC9u/fz9q1a2nSpEmO+4waNYpFixaxbNkyAgICDKr8UutnQEqy0VVYX2hFaNTD6CoulZiYmOftkZGRJCQk5LlNREREQZZ0Tc5dcF3NL9N5+W1sNogqD4/GeKysazZomuu/E+41to6/u1I+wPwZEfm7gsi12TJdVNcQrR9S1BTV50VTHqGy2+3MnDmT6OhoYmNj6d27N2FhYfTv3x+Hw0GdOnVybP/yyy+zYMECvv32W1M1UyJXMmrUKKNLyFOADzStlvc22dnQWs/HhcbsGRHJD+XaMzTPYkVmzLUpP0MFULNmTZYvX55j7P777ycqKgp/f3/32KhRo1i4cCHff/89oaGhHq5S5J/p3r270SVc0V0NXJdG33XMdQGKPw5p//H/d9aDmmUve3f5h4pCRkSulXLtGZpnsSIz5tqUR6guZ/369Tk+P7V161ZefPFFfvvtN2JiYqhXrx716tUzrkCRaxQZGWl0CVfk4wWxbaHbTVA21HWKn5cdald0ff9Uu2ijK7S2opARkWulXHuG5lmsyIy5Nu0Rqr9LTU0lKSmJfv36uceio6Ov+uobZjJ5/mCSktdTo0ID+nd62z0et3kmM+PewIaNnm2fo3ntToyd8RAHjiXg4+3Pv5r2oW39XoDrqiOPja9PpxYDuKPJ//Hp4hdZFT+XIP/iNIu6i66thzBj2Wus2/4tAEkH1jHt+QMkHVjP50tewpmVSf0a7Xj49lfYvGsFY2c8SNkSVSkdWplnen6K05nJa9Pv41TqUWpVbMyjHV1XT3zn68fZc3gL5UpWY3DXD3DYHcxY9hprExZQPKgMT/f8FH+fQJ6cHANA2vnTlClehVEPfc20pa8wf/VEOjR+mN4dXgbglc97cPLsES5mZpBxMZ33hmziwsXz/Hduf46c3EOVstEM6PxfZix7jZ+3LyLjwjl6tn2Om2/s4sHfmHg5oEW46092tqupEhEREZEi1FAFBQXhdObxyfgiYkfyBtIzUhnf70fenh3L9gPrqFWpMQBzfhzPuMdWYLPZeHZKB5rX7gTAsF7TLvkeqDXb/kdoUKkcY307vkmDmn9eRr5H22H0aDuM02kneOnTrgQHlKBejTY0qnUrAEPfbUNK6nEA2je8393kAKyMn0u18nXp2fZZ3vn6cXYd2kym8wKZmRd4M3YFM+Pe5KdtC6hV+Sa27PmRCf1X8uOvs1n00xTubvmE+5Lss38Yj79vMQDuuOn/iK7SnI07l7ofZ/h9M1yPt2UuOw7+AsDclf+hTf1eNAhv596ua+sn6dF2GOkZqTz9fns1VAZSMyUiIiLypyJ1yp8VJOxfS8OatwDQILw92/atcd9WrmR1zl9IIz0jlUDfYMD1nRdjZzzAiI/u5Oipfe5tl2/8gph6OS9rN2XhMzz9Xnt2HtyUY3zN1vk0i7oLAC+HNwDOLCfFi5UlwC/49/1NZ/CklizbOB2Awyd3U62c6+If1cvXY9ve1Rz+bTdV/zK2dd9qjqXsp0qZqD+327c652Nvm0/zaFdjWLxYmct+h8eq+LncXPtuADbvXsGabfN5cnIMq7fOz1F3xsV0bihb+3LTW+TExMQYXYKYnDIiVqRce4bmWazIjLlWQ+VhqekpBPzeLAX6hZCanuK+rUXtLsROqM9j4+vRqcXjAPS9803eHrCae9o8w3v/exKA9dsXU6daa+w2h/u+nW8eyKRBvzDw7slMnPd4jsdcFT+XFn85ovPN2vd5eGwtggNK4uPlS82Kjfjo6UTG/N+3fL3yP6SkHqdSqVr8uisOgM07l5N6PoWKpWrx627X2Kady0hLT6FciWokHvgZpzOTTbuW5fh5TqUew4btkiNpf5fpvMieI1sIr9gAgMO/7aJJxL94+ZFvmLZkNE5nJgD/mdOPvm/VoX6Ntlc932Y3efJko0sQk1NGxIqUa8/QPIsVmTHXaqg8LNAvhHMZZwBIyzhDkH+o+7bPv3+JKUO38eFTCXy+5CUAggNKAFC76s2cPHsEgEU/T+G2xr1z7PeP7SqWCs8xfu78WU6nnaBciarusX817cPHTydx4nQyOw9uxN83CC+HN/4+gdxYrRUHT+ygadSdZGSm89R77fD28qV4UBlqVKjHDWVrM/TdNpzLOENosTKEBpWifYP7ePr99hw8voPiQWXcj7Nm6zya/X50Ki+bd62gbvWYHHNUp3pr/H0CKR9Wg1OpRwEYePckPnoqkS+WvnLFfRYVsbGxRpcgJqeMiBUp156heRYrMmOu1VB5WFSVZmzc4foM0cYdS4is3NR9m4+XL37eAfj5BJLpvABA2nlX83Xg2HZ385V8PIkXpnZm1g9vMvfHCew/luje7nTaCfcRHYB12xfROOJ2998vZGYAru/68vMJxMfb331fZ5aTpAPrKFP8Bhx2BwM6/5c3+i7FbnfQqNZtANx/y0jGPbac4ICSNIn8FwB3NHmUN2NXULlMlHsMYFX819xc+8qfdVoVP5cWf9kuqkpz9hz+FWeWk6Mn9xISWMpdt4+3v/sInxWsWLHC6BLE5JQRsSLl2jM0z2JFZsx1kbkohVWEV2yAt7cfgye1pHr5epQOrcy0pa9wb7vhdGwWy6CJLQC4o0kfAF774l7Opp/CZrMx8G7XIc73hmwC4Lt1U3FmZVK5dAQTZvVlz5F4srOzeOSO19yPtzJ+Lr3aDXf//bt1H7Ni0wyysp3UrRZD5dIRLPxpCgt/eh+bzU6bej0JCynPidMHefWLe7Hb7LRv+ABhIRXIysriqffaYrc7qF+jHZGVmwDw0mfdOHvuJNXK1aFvxzcBVyOYmp5C6eKV3Y+96OcP+d/qSZw9d5Kz504x8O6JZGdns23fGgZ0fse93T1tnmHsjAc5l3GGO5o8ireXDxNmP8aBY4lkOi/QLeapQvjNiIiIiIhcO1t2UbzueBGyfgakJBtdhfWFVoRGPa68naclJibmeXtkZCQJCQl5bhMREVGQJV2XBk1z/XfCvcbW8XdXygcoI1L0FESuzZbporqGaP2QoqaoPi/qlD8RA11pQRBRRsSKlGvP0DyLFZkx12qoRAz01VdfGV2CmJwyIlakXHuG5lmsyIy51meoClmx0kZXcH0oqvP8wgsv0L17d6PLEBNTRsSKlGvP0DyLFZkx12qoClkt63xlkoiIiIiI/I1O+RMREREREcknNVQiBpo0aZLRJYjJKSNiRcq1Z2iexYrMmGs1VCIGio6ONroEMTllRKxIufYMzbNYkRlzrYZKxECtW7c2ugQxOWVErEi59gzNs1iRGXOthkpERERERCSf1FCJiIiIiIjkkxoqEQM1btzY6BLE5JQRsSLl2jM0z2JFZsy1GioRA61bt87oEsTklBGxIuXaMzTPYkVmzLUaKhERERERkXxSQyUiIiIiIpJPaqhEDDRr1iyjSxCTU0bEipRrz9A8ixWZMddqqERERERERPJJDZWIgbp27Wp0CWJyyohYkXLtGZpnsSIz5trL6AKsbvsyOHvM6Cqsr1hpqNXW6CpERERE5HqjhqqQnT0GKclGVyEiIiIiIoVBp/yJGKh///5GlyAmp4yIFSnXnqF5FisyY67VUIkYaMCAAUaXICanjIgVKdeeoXkWKzJjrtVQiRioVatWRpcgJqeMiBUp156heRYrMmOu9Rmq69iTk2NI2LcGh8Mbu91B2eJV6dVuOK3rdjO6tOvG8ePHjS5BTE4ZEStSrj1D8yxWZMZcq6G6zt3bfgT3tn8epzOTeavf4dUvelGjQn0qhNUwujQREREREdPTKX8CgMPhxe1NHsWZlcmuQ5uMLue6ERUVZXQJYnLKiFiRcu0ZmmexIjPmWg2VAHAx8wILVk8GoGJYTYOruX7Mnj3b6BLE5JQRsSLl2jM0z2JFZsy1Gqrr3BdLX6HziFA6PufPx989z5BuU6hWvg4AY6b1Yu22Be5tX5jamfXbFxtVqiWNHDnS6BLE5JQRsSLl2jM0z2JFZsy1qRuqrKwsxo0bR3h4OH5+ftStW5e4uDhq1apFnz59jC7PEnq1G87Xo1OY9eIJboq4g807l7tvi+00ganfjSA9I5Uft8wh0C+ERrVuNbBa65k5c6bRJVjab6kwf+Off//PYli/BzKdxtV0rZQRsSLl2jM0z2JFZsy1qS9K8cgjjzBnzhxGjBhBw4YNWb16NT179uT48eMMGTLE6PIspVhAcYZ0m8KDr1Vndfw8mtfuRPGg0nS5+QkmzhvIrkObeL3PEqPLFLlqCYfgwx9yNk97jsPu47BqB/RtA37extUnIiIi1mDaI1TTp09n6tSpzJ8/n6FDh9KmTRuGDx9Os2bNyMzMpEGDBkaXaDnBASX4d8shfPTtc2RlZQFwW+OHSD6eROcWAwkOKGFwhSJX52Sqq5ly/u1IVPbv/91zHL78yeNliYiIiAWZtqEaM2YMHTp0oHXr1jnGa9Sogbe3N3XquD7n07lzZ+rUqUP9+vW56aabWLJER1H+iS4tn+DkmcN8/8un7rHyJWvoMuqFJC4uzugSLGn1TteRqew8ttm0D06leaykfFNGxIqUa8/QPIsVmTHXpjzlLzk5mfj4eAYPHnzJbfv37yc6OhpfX18Apk6dSmhoKAAbN24kJiaGkydP4nA48nwMm81W4HXnZtxjy6lbPcYjj3Wt3oxdcclYoF8wc1466fli/qG4uBU07tnG6DIukVuG/2rXrl1Ur149z23Gjx9fkCVdF+4fm0jxcjXz/HeeDcR07sevSyZ7rrC/uVI+QBmRoqcgcm22TD/xuevtGU+9drhaeo4RqzHb82J2dl5vzf7JlEeokpOTAShbtmyO8fT0dOLi4nKc7vdHMwVw+vRpbDbbVf/wIkabP3++0SVYko9f4FW98PHyCfBANf+MMiJWpFx7huZZrMiMubZlm7D72LlzJ+Hh4YwfP55Bgwa5x0eNGsWLL77IxIkT6devn3u8f//+LFq0iNOnT/PVV1/Rrl07A6rO3foZkJJsdBXWF1oRGvUwuopLJSYm5nl7ZGQkCQkJeW4TERFRkCVdFyYugZ3H4Eqr28OtoE4lz9SUmyvlA5QRKXoKItdmy/Sgaa7/TrjX2Dr+Ts8xYjVF9XnRlKf8VatWjTp16jBmzBhKlChBhQoVmDVrFgsXLgSgYcOGObafOHEi4DqncvDgwfzwww8EBQV5vG4RMYdmNWDH0by3KeYH0RU8U4+IiIhYlylP+bPb7cycOZPo6GhiY2Pp3bs3YWFh9O/fH4fD4b4gxd+1bt0au93OqlWrPFyxSP6MGjXK6BIsqW5lqFEm7226NASHKVfAnJQRsSLl2jM0z2JFZsy1KY9QAdSsWZPly5fnGLv//vuJiorC398fgNTUVH777TeqVKkCuC5KsWvXLiIjIz1er0h+dO/e3egSLMlhh0djYObP8MvenKf+FfODuxtB/SpGVXdtlBGxIuXaMzTPYkVmzLVpG6rcrF+/nqZNm7r/npaWxj333ENqaipeXl74+fnx+eefU7lyZQOrvDqT5w8mKXk9NSo0oH+nt93j05a+wvzVE+nQ+GF6d3gZgLjNM5kZ9wY2bPRs+xzNa3cCIONiOvePqcqwnp/ToGZ7Jszqy54j8dhsNgZ2mUS18nXYvCuOKd88DTYbtzZ6iDubPQa4rlry2Pj6dGoxgDua/B8XLp7nv3P7c+TkHqqUjWZA5/9e9X0/Xfwiq+LnEuRfnGZRd9G19RCysrL44Jun2XVoE0EBxRl5/0y+WzeVGctfpUSxckRUuolHO47F6czkja96c+TkHppGdqRH22G5jgHMWP46G5K+x5mVyRt9l2G3F4HDC1dwNecBS/74esF9zeHOerDtEGRkQlgQRJYvGkem/qCMiBUp156heRYrMmOui0xDlZqaSlJSUo6LUZQpU4a1a9caWFX+7EjeQHpGKuP7/cjbs2PZfmAdtSo1BuCOm/6P6CrN2bhzqXv7OT+OZ9xjK7DZbDw7pYO7oVr00xSqlrvRvd09bYdRrkRVko/v4MOFw3jhwdnM+uFNRtw/k7CQijzxTjN3U7Rm2/8IDSrlvu/clf+hTf1eNAj/84IeV3tfgL4d36RBzfbuv/+4ZRaVy0TS985xObbr1vop7mjyf+6/r942n0qlIxjW8zOe/6gjJ88cYeu+1ZeMHUvZz/mMVMb21feMybUJCXB9pkpERESkMBSZ92mDgoJwOp08/vjjRpfyjyXsX0vDmrcA0CC8Pdv2rXHfVrxYmUsu91yuZHXOX0gjPSOVQN9gAC5mXiBh/1qib2jx53YlqgLg5fDGbnd9D1elUrVIO3+ai84M/HwC3dsu3/gFMfX+vCze5t0rWLNtPk9OjmH11vnXdF+AKQuf4en32rPz4CYA1m5bwL4jW3lycgwLf/rAvd3cHycwZFIrNuxwNYyJ+9bSMNw1F3WrtyHxwM+5jq1NWMDptBMMfbcNn33/0tVNtIiIiIhIISsyDZWVpKanEPB7YxToF0Jqekqe27eo3YXYCfV5bHw9OrVwNZSL10+lXYP7ct3+w0XP0uXmge77Pvfh7Tw8NsK9/frti6lTrTV2259ffnz4t100ifgXLz/yDdOWjMbpzLzq+3a+eSCTBv3CwLsnM3Geq75TqUepVDqCsX2WsHTDNE6dPUqL2p15b8ivjHxgNu8vGIozy0nq+RQC/P6ci7T0lFzHUs4eJSigOOMeW87+o9vYkbzhmubcrGJiYowuQUxOGRErUq49Q/MsVmTGXKuhMkCgXwjnMs4AkJZxhiD/0Dy3//z7l5gydBsfPpXA50tewunMZP3277gp4vZLtp3z4wSqlI6idtWbAfhw4TDeHrCGqc/sYPEvn3D+wjkW/TyF2xr3vqSmOtVb4+8TSPmwGpxKPXrV9w0OKAFAxVLhOfdXrTUOhxdRVZpx8MROgvxDsdvthAaVomKpmpw6e9Q1F+ddc3Hu/BkC/UMvO1anWmvAddRq/zFznTubX5MnTza6BDE5ZUSsSLn2DM2zWJEZc62GygBRVZqx8fdT3jbuWEJk5aZ5bu/j5YufdwB+PoFkOi9wKvUox1L28+wHHVi64XM+XPQsZ8+dYv32xWzdu5p72z/vvq/d7iDILxRvLx/sNjtO50WSjyfxwtTOzPrhTeb+OIH9xxKJqtKcPYd/xZnl5OjJvYQElrrq+6b93vycTjuB05kJQPQNzdl9+FcA9hzZQpniVdzbZVxM5+CJHYQGlSKySjP358U271pOrUqNcx2LusFVH8CuQ5so+/vpjUVdbGys0SWIySkjYkXKtWdonsWKzJjrInNRCisJr9gAb28/Bk9qSfXy9SgdWplpS1/h3nbDWfTzh/xv9STOnjvJ2XOnGHj3RDo2i2XQRNdnpe5o0oewkApMfGIdAJ8ufpHaN9xMsYDiTJz3OAG+wQx9tw2VStViUNf3uCfmGZ55vz02m53GEbcT6B/Ce0M2AfDduqk4szKpXDqCe9o8w9gZD3Iu4wx3NHkUby+fq77vH1cXzM7O4pE7XgOgQ+NHGPvlg8z5cQKNat1GqdCKfLZ4FOu2f0t2dhY92gzDy+FNs6g7eePL2QyaeDM3RdxByeByuY41jezIW7MeZcjk1lQuFUH0Dc09/nsrDCtWrDC6BDE5ZUSsSLn2DM2zWJEZc23Lzv7rN7RIQVs/A1KSja7C+kIrQqMeV97O0xITE/O8/Wou/RkREVGQJYmJXCkfoIxI0VMQuTZbpgdNc/13wr3G1vF3eo4Rqymqz4s65U9ERERERCSf1FCJGMhsX0wn5qOMiBUp156heRYrMmOu9RmqQlastNEVXB+K6jx/9dVXdO/e3egyxMSUEbEi5dozNM9iRWbMtT5DJVKIdH675KWonisukhd9hspz9BwjVlNUnxd1yp+IiIiIiEg+qaESERERERHJJzVUIgaaNGmS0SWIySkjYkXKtWdonsWKzJhrNVQiBoqOjja6BDE5ZUSsSLn2DM2zWJEZc62GSsRArVu3NroEMTllRKxIufYMzbNYkRlzrYZKREREREQkn9RQiRiocePGRpcgJqeMiBUp156heRYrMmOu1VCJGGjdunVGlyAmp4yIFSnXnqF5FisyY67VUImIiIiIiOSTGioREREREZF8UkMlYqBZs2YZXYKYnDIiVqRce4bmWazIjLlWQyUiIiIiIpJPaqhEDNS1a1ejSxCTU0bEipRrz9A8ixWZMddeRhdgVduXwdljRldx/SlWGmq1NboKkeub1j/P0HonImIOaqgKydljkJJsdBUiIp6n9U9ERK4nOuVPxED9+/c3ugQxOWVErEi59gzNs1iRGXOthkrEQAMGDDC6BDE5ZUSsSLn2DM2zWJEZc62GSsRArVq1MrqEq3IqDTbshfkbYcZa+PIn+D4eEg7B+YtGV2dtRSUjItdCufYMzbNYkRlzrc9QXceenBxDwr41OBze2O0OyhavSq92w2ldt5vRpV03jh8/bnQJeUo4BHGJkHj48tv4ekGjqtAmEsKKea6264XZM1LUaN0zB+XaMzTPYkVmzLUaquvcve1HcG/753E6M5m3+h1e/aIXNSrUp0JYDaNLEwOlZcCc9fDL3itvm5EJq3bAz7vhzvpwc02w2wq9RJF807onIiIFSaf8CQAOhxe3N3kUZ1Ymuw5tMrqc60ZUVJTRJVwi5RxM+O7qmqm/uuh0NWHT10JWVqGUdl0yY0asQuuecZRrz9A8ixWZMddqqASAi5kXWLB6MgAVw2oaXM31Y/bs2UaXkEP6BZi0FI6fzf8+1u2Gub8UXE3XO7NlxEq07hlHufYMzbNYkRlzrYbqOvfF0lfoPCKUjs/58/F3zzOk2xSqla8DwJhpvVi7bYF72xemdmb99sVGlWpJI0eONLqEHOZtgGNn8t5mwr2uP3n5Mcn1+Sv558yWESvQumc85dozNM9iRWbMtakbqqysLMaNG0d4eDh+fn7UrVuXuLg4atWqRZ8+fYwuzxJ6tRvO16NTmPXiCW6KuIPNO5e7b4vtNIGp340gPSOVH7fMIdAvhEa1bjWwWuuZOXOm0SW47TkOa3cV3P6++gmcOvXvHzNTRqxC657xilKu9//25/8f+O3y25lRUZpnkatlxlybuqF65JFHGD16NH379mXRokV0796dnj17snv3bho2bGh0eZZSLKA4Q7pN4afEb1gdPw+A4kGl6XLzE0ycN5Avlr7MY3eNN7hKKUw/bC/Y/Z06B/HJBbtPkYKkdU/ycuQ0vLkI3vr2z7E3v3WNHT1tXF0iYj6mbaimT5/O1KlTmT9/PkOHDqVNmzYMHz6cZs2akZmZSYMGDYwu0XKCA0rw75ZD+Ojb58j6/aoCtzV+iOTjSXRuMZDggBIGVyiF5fxF+PVAwe/3pwI84iVSGLTuSW5OnIX/LIbkk5felnwK3l4Mv6V6vi4RMSfTNlRjxoyhQ4cOtG7dOsd4jRo18Pb2pk6dOjnG33//fWw2G7NmzfJkmZbTpeUTnDxzmO9/+dQ9Vr5kDV1OuJDExcUZXQIAB04Wzul5+36D7OyC3+/1xCwZsTKte55n9lx/u8V1kZ7clq/sbNdt323xeFnXzOzzLJIfZsy1Kb+HKjk5mfj4eAYPHnzJbfv37yc6OhpfX1/32I4dO/j4449p2rSpJ8ss8t6MXXHJWKBfMHNeyuUtOSkUW7dupXTp0kaXwcFThbPftAw4nQ6hAYWz/+uBWTJiFVr3zMHMuT53ATbuzb2Z+kM2rq+WuLsR+Hl7pq78MPM8i+SXGXNt2oYKoGzZsjnG09PTiYuL4/bbb3ePZWZm8vDDDzN58mQGDRp01Y9hsxXuN4+Oe2w5davHFOpjyKXi4lbQuGcbo8twy+1Ngb8aP378VW1T2Jp0GUnTf4/KMXalK/ld7vZB03L+vUat2vyWvPUfVGddV/rdg3kyci20/nmG2da7PxREro3MdMmK0dz3WvwVt3NmQfkbIjl1KNEDVeWuqDzHiFwtsz0vZl/laTambKjCwsIASEpK4o477nCPjx07lsOHD+e4IMXo0aO5/fbbqVevnqfLvG483WOq0SVIIctyZhbavp3Oi4W2b5HConXv+nUxI+2qt83MOFeIlYhIUWHLvtrWy4OysrKoX78+hw8fZty4cVSoUIFZs2axcOFC9u/fz9q1a2nSpAk//fQTQ4cOZcWKFTgcDmJiYhgwYABdu3Y1+kdg/QxI0RXOPC60IjTqYXQVf0pMzPudy8jISBISEvLcJiIioiBLytWGvfDpqqvb9o8jU38/EpUbuw1e6w4+pnzrxnhXygeYJyPXQuufZ5htvftDQeTayExnZ8Pr37iu5He5F0g2oFwoPHUHFPIJL3kqKs8xIlerqD4vmvKiFHa7nZkzZxIdHU1sbCy9e/cmLCyM/v3743A43BekWL58Obt27aJ69erccMMNrF27ln79+vHmm28a/BOIXJ1Ro0ZdeSMPqFSycPZbNlTN1D9lloyIFCQz59pmg7ZRV/4MVdsoY5upq2HmeRbJLzPm2rQvdWrWrMny5ctzjN1///1ERUXh7+8PwLBhwxg2bJj7djMdoRK5Gt27dze6BADCgqBMMBw9U7D7jS5fsPu7HpklIyIFyey5blwVjp2BJVtdR6P+aK7++P9boqFRVePqu1pmn2eR/DBjrk15hOpy1q9fry/0FUuJjIw0ugTA9S5ri5oFvE+geXjB7vN6ZJaMiBQks+faZoOO9eDxW6BeFQjxd/2pVwUG3gL/qmd0hVfH7PMskh9mzLVpj1D9XWpqKklJSfTr1++y26xYscJzBeXD5PmDSUpeT40KDejf6W33+J4j8bw9+zGys7N54u7JVCtfh1c+78HJs0e4mJlBxsV03huyiROnD/H69Pu4kHmeB299iQY127N5VxxTvnkabDZubfQQdzZ7jG9//ohpS0YTfUMLhvX6HICdBzfx37n9sdvtPNxhDDdWa8ni9Z/w7c8fknExndsa9+au5v04dmo/b3z5EM6sTDq1GEDrut1Zs+1/fLH0FWzYaFmnK91aPwnA9+s/ZfEvn5CV5eTZXtMIC6kAwOwfxvPjltlM6L8y15/7yMm9PP7fJlQuHYmXw4fX+ywG4KsVb7B66zzKFK/CU/dMBWDIpFbsObKFdwdvcn8nTKcRIdQoXx+AFx6coy/eLCBNqkNcYsF9WWWLmlA8sGD2JdZwuTXwl6TvmfrdCHy9/Rl492Qql47Idc36OXER784fTHBgmHt9+cPIjztRtdyN9O7wMufOn+XVL3px5txJOjbtyy2NHsh1bN/Rbbw181EA6tdoy0MdRvPduqnMWP4qJYqVI6LSTTzacSybd61g7IwHKVuiKqVDK/NMz09xOjN5bfp9nEo9Sq2KjXm041h3LT9umcPkeU/wxfOub8vObc0aMqkV2Gw47F48d+90ige5LgG8I3kD/d5uyLevXcTh8OKDBU8Tv3cVdrudJ7t9RMVSepfCk6qXdv0REclLkTlCFRQUhNPp5PHHHze6lHzZkbyB9IxUxvf7kczMC2w/sM592yffjuC5e6cz4v6vmPrdCACG3zeDN2NX0D3maZpGdQTgy+Wv8eBto3nt0cVMW/oyALN+eJMR98/k7f6rWbzuYwCaRd/Fa32+z/H4nyweyfP3fcmr//cdXyx9BYC29XvxVr8f+M/ja/lm7XsAzFj+Or07vMIbjy1n4U9TcDozqV6uLhP6r+LtAatZs20+aemnOXH6IL/ujuONvkt5M3aFu5m6kJnBrkObrvhzNwy/hTdjV7ibqVOpx9i0azkT+q+kark6rIr/Gofdi1EPfU3LG3Oewlm17I28GbuCN2NXqJkqQL5e0LOp68jSP1UyCO6sVwA7EsvIaw38fMlLjO27lGd7fcGni18Acl+zIis35d0hmy/Z9+5Dv5JxMd3994U/fUBMvR681e8HFv08hYuZF3IdW7DmXR6541XeHrCKhP1rSU1PAaBb66d4M3ZFjiapfcP7eTN2Bc/0dH3578r4uVQrX5dxjy0nIzOdXYf+rOvHX2dRKrSS+++5rVlj+y7lrdg4bmn4AN+v/8S97fw1kwiv0ACAM+dOkpS8nrcHrOKR21/jf2sm5W/yRUSkUBWZhqqoS9i/loY1bwGgQXh7tu1b477tbPopSodWIiykAqnnU3Lcb1X8XG6ufTcAe45sIfqG5vj7BhHgW4y082eoVKoWaedPc9GZgZ+P63BASGAYDnvOg4+p6acoFVoRP58Azl9MI+NiOl4O17cRZjovULm06/DpkZO7qVq+Dg67g+LFypB8Ygeli1fGYXdg+/3dVJvNzvrt3+HMcvLUe+145+vHcWY5Afj25w+5pdGDV/y5N+1azuBJLZn9g+t7ApIOrKdutRj3dgn71mCz2SherMwlc7n/WAKDJ7VkysJhV/39AGYVExNjdAk51CgD/26c9zaDpuV9hb8AH3g0BnxN/GWXRYnZMpJfea2BAP4+gZQMLseh33YBua9ZxQKK4+Ple8m+5676D3c1//PshYT9a2lQ8xYcdgfVytflwLHEXMcq/r5+/rF+ef++77k/TmDIpFZs2LHUvc/lG6czeFJLlm2cDsDhk7upVs51gaTq5euxbe9qAH5KWEiD8PbYbH8+vea2Zv2x/mZcTKdKmWgA9h7ZSqmQivj7Fvt9ToII9AvBmeUk7XwKwQGFdPUYA1gl12aneRYrMmOu1VB5SGp6CgG+wQAE+oW43wkFyM7O4i9/cf9vpvMie45sIbyi693KrCyn+wuJA/1CSEtPoUXtLjz34e08PDaCdg3uu+zjhwSWYs+ReFJSj7P3SLz78T/7/iUeej2c8Iquz6ZVLFWLX3fFcf7CORL2ryXtL3X+nLiI8iWrE+BXjFOpR8l0XuCNvkvx9Q5g9dZ5ZDovsnnXCurXaJvnz10iuBwfP5PEuL7L2bBjCbsP/Ura+RQC/P6y3d8ay7+a+swO3or9gdRzp1iz7X+X3a4omDx5stElXOLmmtCrGXg7rv2+pYNh4K1QNqTg67pemTEj+ZHXGghw6uxR9h9L5MBR16VwL7dm/d3+Y4mEBpYiyD80x2MF+uZcT3Iba1jzFiZ9PZCHx9YiskozfL39aVG7M+8N+ZWRD8zm/QVDcWY5qVmxER89nciY//uWr1f+h5TU41T6fa0E2LxzuXvN+v6XTy5Zi3Nbs46d2s/A/zZj/qp3qFruRgDm/DiBTi0GuO/n7eVD2RJVeXhsLd6ZO4AONz1yjbNuXlbJtdlpnsWKzJhrNVQeEugXwrkM1yXU0jLO5Hjy/+t1V//6rubmXSuoWz0m19vSMs4Q6B/KhwuH8faANUx9ZgeLf/mE8xdy/5LB/7vjNd6dP4S3Zz9G1XJ1CAl0fXny/beM5JNhu/jh15mcSfuNnm2fZeFP7zP6s25ULhXhPkJ0+LfdfLViLI/dNd7989Sp1hqAejXasv9YAkt++Yy29Xtd8ef28fLF3ycQh8OLppEd2Xs03rXdedd2586fIcgvlMsJDiiBzWajee3O7D1y5W+zN7PY2FijS8jVTdXgmX9BrbJXt72Xw3UJ4aG3q5kqaGbNyLXKaw189I6xvDKtBzOWvUbUDS2Ay69Zfzf7h7focvMTOR/LP4S0jJzrSW5jU78bwfP3f8XHTyex9/AWjpzcS5B/KHa7ndCgUlQsVZNTZ4/i7xuEl8Mbf59AbqzWioMndtA06k4yMtN56r12eHv5UjyoDBt3LiOqSjO8vXxy1JPbmlW6eGX+8/gaHrh1FDPjxpF8fAcBfsE5fs59RxM4eGIHHz+dxPP3z+Tjb4f/g9+AuVgl12aneRYrMmOu1VB5SFSVZmz8/fSRjTuWEFm5qfu2YP8SHE9J5sTpQ+6jNOA63a9F7S7uv1crV4dte9eQfiGNc+fPEOgXjN3uIMgvFG8vH+w2O07nxVwfv2KpmrzeZzGDur5H6dDKeDm8uZCZAYC3wwdf7wDXi4JiZRj10NeMfGAW3l6+lC1RlXPnz/LGlw/xZLcP8f/9tMKoKs3ZffhXAHYd2kS5ElU5cHw7/1szmWc/6MC+o1v5euV/c/25z50/665r695VlCtZnZqVGvPrbte7vRt2LCGySlNyk34hzX16zta9qyhfsvo1/BbMx8wXUgkrBrHtXI1V6wioXBK8/rJiBPpCrXLQqQGM6gJ31dd3ThUGM2fkWuS1Bkbd0Ixxjy2nV7vhVC7jOv04tzUrN0dP7eONLx/ig2+eZvnG6WzeFUdUZddjObOc7Dq0iUqlI3Idy87Opph/Cex2OwF+IaRnnCXt9zd2Mi6mc/DEDkKDSrnHnFlOkg6so0zxG3DYHQzo/F/e6LsUu91Bo1q3sfdIPGu2znevgR9/+3yua1am86L71L8Av2B8vf3Zc2QLSQfW8ewHHdhz+FcmzHkMyCbw9wYvJDCMtPTThfK7MYJVcm12mmexIjPmWi9/PCS8YgO8vf0YPKkl1cvXo3RoZaYtfYV72w3ngVtH8fLn9wDweJeJAGRnZ7Nt3xoGdH7HvY/uMU8zdsYDZFxM54FbXV9qdk/MMzzzvut8/cYRtxPoH8LabQuYsfw1Dv+2i1Gf/JsXHpzNop8/ZOmGz/Hx9nc/xoxlr7J51woynRdo3+B+/H2D+CnhG2bGjcNuc/B//3odm83GvNXvcOTkHsZ99TAAQ+/5mBoV6uHr7c+Tk2MICQzj3y0H5zg6NWjizXS+2XUBkb/+3BGVb+KnhIV88t0IvL18qV21JZGVmwBwY7VWDJp4M6VDK3N3y0EAjP6sO/F7V3LwxA7uiXma0sWr8ObMh/H3CaJsiarueZDCUy4Uuvz+bQVZWTDE9RESXv63+b/UUswjrzVw2tJX2LhjCcEBJRn0b9cFcnJbs7YfWM+HC4ex90g8T7/XnpcfXsBrj34HuI7ob9ixhLrVW1OjQn1e/aIX81b9lzua9MHby4fbm/zfJWP3tHmG12fcj93uoHLpSKqWu5HPFo9i3fZvyc7OokebYXg5vFm8/hMW/vQ+NpudNvV6EhZSnhOnD/LqF/dit9lp3/ABwkIq0OXmgXS5eSDgWgN7d3iZnQc3XbJm/Xb6IK/NuB+7zY63w5en7plKieCytLzR9XnZJyfHMOjud3E4vAjwLcbgSS1xOjPp95crI4qIiHnYsov6p/pNav0MSEk2uorrT2hFaNTD6Cr+lJiYmOftkZGRJCQk5LlNREREQZb0j/1xQYoJ9xpbhxVcKR9QNDOi9c8zzLbe/aEgcm22TJuVFZ9j5PpWVJ8XdcqfiIGutCCIKCNiRcq1Z2iexYrMmGud8ldIiumLAA1R1Ob9q6++onv37kaXISZWFDNS1P4dFlVFeZ6LYq6LIs2zWJEZc61T/kQKkRVPx9ApfwWnqJ7aIJIXnfLnOVZ8jpHrW1F9XtQpfyIiIiIiIvmkhkpERERERCSf1FCJGGjSpElGlyAmp4yIFSnXnqF5FisyY67VUIkYKDo62ugSxOSUEbEi5dozNM9iRWbMtRoqEQO1bt3a6BLE5JQRsSLl2jM0z2JFZsy1GioREREREZF8UkMlYqDGjRsbXYKYnDIiVqRce4bmWazIjLlWQyVioHXr1hldgpicMiJWpFx7huZZrMiMuVZDJSIiIiIikk9qqERERERERPJJDZWIgWbNmmV0CWJyyohYkXLtGZpnsSIz5loNlYiIiIiISD6poRIxUNeuXY0uQUxOGRErUq49Q/MsVmTGXHsZXYDVbV8GZ48ZXYX1FSsNtdoaXYWIiIiIXG/UUBWys8cgJdnoKkREREREpDDolD8RA/Xv39/oEsTklBGxIuXaMzTPYkVmzLUaKhEDDRgwwOgSxOSUEbEi5dozNM9iRWbMtRoqEQO1atXK6BLE5JQRsSLl2jM0z2JFZsy1GioRAx0/ftzoEsTklBGxIuXaMzTPYkVmzLUuSnEde3JyDAn71uBweGO3OyhbvCq92g2ndd1uRpcmIiIiIlIkqKG6zt3bfgT3tn8epzOTeavf4dUvelGjQn0qhNUwurTrQlRUlNEliMkpI2JFyrVnaJ7FisyYa53yJwA4HF7c3uRRnFmZ7Dq0yehyrhuzZ882ugQxOWVErEi59gzNs1iRGXOthkoAuJh5gQWrJwNQMaymwdVcP0aOHGl0CWJyyohYkXLtGZpnsSIz5loN1XXui6Wv0HlEKB2f8+fj755nSLcpVCtfB4Ax03qxdtsC97YvTO3M+u2LjSrVkmbOnGl0CWJyyohYkXLtGZpnsSIz5trUDVVWVhbjxo0jPDwcPz8/6tatS1xcHLVq1aJPnz5Gl2cJvdoN5+vRKcx68QQ3RdzB5p3L3bfFdprA1O9GkJ6Ryo9b5hDoF0KjWrcaWK0YJdMJq5Lg9W/+HPswDnYcMa4mERERETMw9UUpHnnkEebMmcOIESNo2LAhq1evpmfPnhw/fpwhQ4YYXZ6lFAsozpBuU3jwteqsjp9H89qdKB5Umi43P8HEeQPZdWgTr/dZYnSZYoALmfDecth1DGx/GY8/CFuS4c560C7aqOpEREREjGXaI1TTp09n6tSpzJ8/n6FDh9KmTRuGDx9Os2bNyMzMpEGDBkaXaDnBASX4d8shfPTtc2RlZQFwW+OHSD6eROcWAwkOKGFwhdYTFxdndAlXNH+Dq5kCyP7LePbvf/nfJkjSkapCUxQyInKtlGvP0DyLFZkx16ZtqMaMGUOHDh1o3bp1jvEaNWrg7e1NnTquz/nExMRQtWpV6tWrR7169Rg2bJgR5VpGl5ZPcPLMYb7/5VP3WPmSNXQZ9UKydetWo0vI07kLsHZ33tvYbBCX6Jl6rkdmz4hIfijXnqF5FisyY65NecpfcnIy8fHxDB48+JLb9u/fT3R0NL6+vu6xN954g65du17TY9hstitvVADGPbacutVjPPJY1+rN2BWXjAX6BTPnpZOeL+YfiotbQeOebYwu4xK5Zfivxo8ff1XbGKVqvX9x19AFeW6TnQ2/7ruIzebjoaqs40q/ezB/RkT+riByrUxfnaL+HCPyd2Z7XszOzr7yRpj0CFVycjIAZcuWzTGenp5OXFycTvcT8RC719U1SXaHw3WoSkREROQ6Y8u+2tbLg3bu3El4eDjjx49n0KBB7vFRo0bx4osvMnHiRPr16we4Tvk7fPgwPj4+VKtWjdGjR7tPBzSD9TMgJdnoKqwvtCI06mF0FZdKTMz7XLjIyEgSEhLy3CYiIqIgS7omR0/Dq3kfoMIGlAqG5+70SEmWcqV8gPkzIvJ3BZFrZfrqFPXnGJG/K6rPi6Y85a9atWrUqVOHMWPGUKJECSpUqMCsWbNYuHAhAA0bNnRv++mnn1KpUiVsNhszZszgtttuY+fOnQQGBhpVvshVGzVqlNEl5KlMCFQrBXuO57wgxV9lAy31XdCFxuwZEckP5dozNM9iRWbMtSlP+bPb7cycOZPo6GhiY2Pp3bs3YWFh9O/fH4fDkeMIVOXKld2fh+rRowc+Pj5s377dqNJFrkn37t2NLuGK/t0YvL1yXjL9r24IgybVPVrSdaUoZETkWinXnqF5FisyY65N2VAB1KxZk+XLl5OWlsb+/fsZPXo0W7ZsISoqCn9/fwDOnz/PiRMn3PdZunQpZ8+epUYNXZFOiobIyEijS7iiCsXhiVuhaqmc4w47NK0OsW3Bx5THuq2hKGRE5Fop156heRYrMmOui9TLoPXr19O0aVP338+cOcPtt9/OhQsXsNvtBAcHM3/+fIKDgw2s8somzx9MUvJ6alRoQP9Ob7vHz5w7yduzH+NM2gnqhbfj3nbDGTvjIQ4cS8DH259/Ne1D2/q92HlwE/+d2x+73c7DHcZwY7WWHDu1nze+fAhnViadWgygdd3unDxzhFem9SCbbMqXrM7Q7h/x3bqpLF4/FYDdhzfzRt/lhAaVZsTHHdl3dBv/ezkVh8OLE6cPXTK250g8E2b1wW53UL5kDYZ2/wibzcb36z9l8S+fkJXl5Nle0wgLqXDJGNgu2V/C/p94d/5gbDY7tSo1JvYu1xVZ3vn6cfYc3kK5ktUY3PUDHHYHOw9u5INvnsaZlUm31kNpEvkvA35z168KxWHgrXDkNBxOcTVT1UtDoO8V7yoiIiJiaUWmoUpNTSUpKcl9MQqA0qVL88svvxhY1bXbkbyB9IxUxvf7kbdnx7L9wDpqVWoMwGffj+LB216icumcH6Qb1mtaju+B+mTxSJ6/70uKBZRg1Cd382q1b5mx/HV6d3iFWpVv4rkpt3Nz7btZtvELOjR+mFsaPcBbMx9l16HN3Nb4IW5r/BBOZyb93m5E9fJ1uZiZwdg+S3nxky7uxwgOKHHJWKVStXh7wGoA3viyN0nJ6ykZXJ5fd8fxRt+l7u1OnD54ydiFi+cv2V+Z0Cq80XcZPt5+vPrFvew5vIULmefJzLzAm7ErmBn3Jj9tW0Dz2p34fMloRj00Dz+fgAL6TUh+lA1x/RERERERF9Oe8vd3QUFBOJ1OHn/8caNL+UcS9q+lYc1bAGgQ3p5t+9a4b9t7JJ7pS8cw9N02bNvrGrfZbIyd8QAjPrqTo6f2AZCafopSoRXx8wng/MU0Mi6mc+TkbqqWr4PD7qB4sTIkn9hBxVI1STt/GoD0jLME+Ye6H+vXPT9Qp1orbDYbPt5+FAsonqPO3Ma8HN7u//f28qVUSCXWb/8OZ5aTp95rxztfP44zy5nrWG77KxFcFh9vPwAcdm/sdgeHf9tN1XKuz8hVL1+PrftWc/i33VzIPM9Ln3XlhamdOXX2aL7n32xiYmKMLkFMThkRK1KuPUPzLFZkxlwXmYbKKlLTUwjwdZ2SGOgXQmp6ivu2bXtX06Ptswy/dwbvf/MUAH3vfJO3B6zmnjbP8N7/ngQgJLAUe47Ek5J6nL1H4klNT6FiqVr8uiuO8xfOkbB/LWnpKdSqfBPf/PQ+D78RiZfDhzLFq7gfa+WWObSo/efRoqu1eut8Hh1Xm5SzRwkOLMmp1KNkOi/wRt+l+HoHsHrrvFzH8rL70K+cTjtOlTJRrp9jdxwAm3YuIy09hVNnj3LweBIj75/Fv5r25Yulr1xz3WY1efJko0sQk1NGxIqUa8/QPIsVmTHXaqg8LNAvhHMZZwBIyziT46hRxVI1qVImkuLFymC3uX41wQElAKhd9WZOnj0CwP/d8Rrvzh/C27Mfo2q5OoQEhtGz7bMs/Ol9Rn/WjcqlIiherAyz4t7kvvYj+eipBAL9Q/h19w+A61uf4/es5MZqra65/ubRd/HB0HjCQiuydtsCAv1CqFOtNQD1arRl/7GEXMcu58y5k7zz9QCe7PYhADUq1OOGsrUZ+m4bzmWcIbRYGQL9Q6hZqTF+PgFX3F9RExsba3QJYnLKiFiRcu0ZmmexIjPmWg2Vh0VVacbGHa7PFm3csYTIyn9eZKNCqZr8duYw6RfScGZlApB23tV8HTi23d18VSxVk9f7LGZQ1/coHVoZL4c3xYuVYdRDXzPygVl4e/lStkRVyM6m2O8NWXBASffpf9sPrCO8YgMcdsc11X4hM8P9/wG+wfh6+xNVpTm7D/8KwK5DmyhXomquY7lxOjN5bfp99Ok4jhLBZd3j998yknGPLSc4oCRNIv9FhbBwUlKP4cxysuvQJtfPZhErVqwwugQxOWVErEi59gzNs1iRGXNdZC5KYRXhFRvg7e3H4EktqV6+HqVDKzNt6Svc2244D946ijHTenLhYjr33fICAK99cS9n009hs9kYeLfrEOeinz9k6YbP8fH25/EuEwH4KeEbZsaNw25z8H//eh2bzcadzfsx9ssH+XzJSwQHlKRn2+cAWBU/l5tr3+2uKdN5keem3M7uw5sZNuU2Hr59DOEVGlwydurMEWb9+BYAFcLCaVjzVux2O77e/jw5OYaQwDD+3XIw3l4+l4zl9hiHf9tN0oF1fPDN0wA8cvurRFRuwlPvtcVud1C/RjsiKzcB4I4mjzL03RhsNjtP3TPVI78rEREREZErsWVnZ2cbXYSVrZ8BKclGV2F9oRWhUQ+jq7hUYmJinrdHRkaSkJD3KYwRERF53i5F15XyAcqIFD0FkWtl+uroOUaspqg+L+qUPxEDXWlBEFFGxIqUa8/QPIsVmTHXaqhEDPTVV18ZXYKYnDIiVqRce4bmWazIjLnWKX+FbPsyOHvM6Cqsr1hpqNXW6CoupdMxJC9F9dQGkbzolD/P0XOMWE1RfV7URSkKmRlf5IuIiIiISMHQKX8iIiIiIiL5pIZKxECTJk0yugQxOWVErEi59gzNs1iRGXOthkrEQNHR0UaXICanjIgVKdeeoXkWKzJjrtVQiRiodevWRpcgJqeMiBUp156heRYrMmOu1VCJiIiIiIjkkxoqERERERGRfFJDJWKgxo0bG12CmJwyIlakXHuG5lmsyIy5VkMlYqB169YZXYKYnDIiVqRce4bmWazIjLlWQyUiIiIiIpJPaqhERERERETySQ2ViIFmzZpldAlicsqIWJFy7RmaZ7EiM+ZaDZWIiIiIiEg+qaESMVDXrl2NLkFMThkRK1KuPUPzLFZkxlx7GV2A1W1fBmePGV2F9RUrDbXaGl2FiIiIiFxv1FAVsrPHICXZ6CpERERERKQw6JQ/EQP179/f6BLE5JQRsSLl2jM0z2JFZsy1LTs7O9voIqxs/QwdofKE0IrQqIfRVVwqMTHxH+8jIiKiACoRMyqIfIAyIuaidc9zNNdiNUX1eVFHqEQM1KpVK6NLEJNTRsSKlGvP0DyLFZkx1/oM1XXsyckxJOxbg8Phjd3uoGzxqvRqN5zWdbsZXdp14/jx40aXICanjIgVKdeeoXkWKzJjrtVQXefubT+Ce9s/j9OZybzV7/DqF72oUaE+FcJqGF2aiIiIiIjp6ZQ/AcDh8OL2Jo/izMpk16FNRpdz3YiKijK6BDE5ZUSsSLn2DM2zWJEZc62GSgC4mHmBBasnA1AxrKbB1Vw/Zs+ebXQJYnLKiFiRcu0ZmmexIjPmWg3Vde6Lpa/QeUQoHZ/z5+PvnmdItylUK18HgDHTerF22wL3ti9M7cz67YuNKtWSRo4caXQJYnLKiFiRcu0ZmmexIjPm2tQNVVZWFuPGjSM8PBw/Pz/q1q1LXFwctWrVok+fPkaXZwm92g3n69EpzHrxBDdF3MHmncvdt8V2msDU70aQnpHKj1vmEOgXQqNatxpYrfXMnDnT6BLE5JQRsSLl2jM0z2JFZsy1qRuqRx55hNGjR9O3b18WLVpE9+7d6dmzJ7t376Zhw4ZGl2cpxQKKM6TbFH5K/IbV8fMAKB5Umi43P8HEeQP5YunLPHbXeIOrFBERERExF9Ne5W/69OlMnTqVFStW0Lp1awDatGnDhg0bmDNnDg0aNDC4QusJDijBv1sO4aNvn6Np1J3Y7XZua/wQi36eQucWAwkOKGF0iSIiIiIipmLaI1RjxoyhQ4cO7mbqDzVq1MDb25s6dVyf87lw4QJDhgwhPDycG2+80ZRf9lWUdGn5BCfPHOb7Xz51j5UvWUOXUS8kcXFxRpcgJqeMiBUp156heRYrMmOuTXmEKjk5mfj4eAYPHnzJbfv37yc6OhpfX18AnnvuOc6ePUtiYiIOh4PDhw97utwi683YFZeMBfoFM+elk54v5jq1detWSpcubXQZYmLKiFiRcu0ZmmexIjPm2rQNFUDZsmVzjKenpxMXF8ftt98OwLlz53jvvfc4cOAADocDgHLlyl3VY9hstgKs+PLGPbacutVjPPJY17O4uBU07tnG6DIukdubAn81fvz4q9pGrOlKv3tQRqToKYhcK9NXR88xYjVme17Mzs6+qu1MecpfWFgYAElJSTnGx44dy+HDh90XpNi5cychISG89dZb3HTTTTRt2pSvvvrK4/Va3dM9plK76s1GlyEiIiIiYjq27KttvTwoKyuL+vXrc/jwYcaNG0eFChWYNWsWCxcuZP/+/axdu5YmTZqwYcMGGjZsyKRJk4iNjWXv3r00b96cb775hvr16xv9YwCwfgakJBtdhfWFVoRGPYyu4lKJiYl53h4ZGUlCQkKe20RERBRkSWIiV8oHKCNS9BRErpXpq6PnGLGaovq8aMojVHa7nZkzZxIdHU1sbCy9e/cmLCyM/v3743A43BekqFy5MgAPPvggADfccAMtWrTg559/Nqx2kWsxatQoo0sQk1NGxIqUa8/QPIsVmTHXpmyoAGrWrMny5ctJS0tj//79jB49mi1bthAVFYW/vz/gOjWwQ4cOfPPNNwD89ttv/Pzzz9StW9fI0kWuWvfu3Y0uQUxOGRErUq49Q/MsVmTGXJu2ocrN+vXrL/lC33fffZf33nuPG2+8kdatWzNs2DCaNm1qUIUi1yYyMtLoEsTklBGxIuXaMzTPYkVmzLUpr/KXm9TUVJKSkujXr1+O8SpVqrBkyRKDqsqfyfMHk5S8nhoVGtC/09vu8V+SvmfqdyPw9fZn4N2TqVw6ghOnD/H69Pu4kHmeB299iQY12zNp3iB2HdoEwO7Dm5n70ilmLHuNddu/BSDpwDqmPX+ANVvns3j9VPd2b/RdzqmzR5ix/DUAko9vZ+Ddk2kS+S+GTGrFniNbeHfwJiqE1SDTefGSsdNpJxj58V04HN4E+oXw/H1f4uvtT6cRIdQo7/rM2gsPziE4oAQfLHia+L2rsNvtPNntIyqWCqf32FqUKOa6CuPAuydRpUwUT06OIZtsbNi475aR1K/Rlj1H4nl79mNkZ2fzxN2TqVa+Dq983oOTZ49wMTODjIvpvDdkk2d+WSIiIiIieSgyDVVQUBBOp9PoMv6xHckbSM9IZXy/H3l7dizbD6yjVqXGAHy+5CXG9l3KufNnmDx/EM/f9yVfLn+NB28bTfXydXn+o440qNmefp0mALDz4EZmxb0JQI+2w+jRdhin007w0qddCQ4owW2NH+K2xg/hdGbS7+1GVC9fF5utHo0jOgDw+H+a0CC8PQ67F6Me+poPvnnGXWduY0H+xRnfbyV2u53PFo9i7bYFtK7bjaplb8zxnVZnzp0kKXk9bw9YRfyeVfxvzSRi7xpPSGCpXL/76o0+S3E4/oziJ9+O4Ll7p2O32fnPnH681Hsew++bAcDKLXPZcfCXAvldiIiIiIj8U0XqlD8rSNi/loY1bwGgQXh7tu1bk+N2f59ASgaX49BvuwDYc2QL0Tc0x983iADfYqSdP+PedmX8XFrceHeO+6/ZOp9mUXflGPt1zw/UqdYqx3dvHf5tN6HFyuDvG4TNZqN4sTI57pPbmMPuwG53RcaZ7aRCWDgA+48lMHhSS6YsHEZ2djb+PkEE+oXgzHKSdj6F4ICSAJw9d5Ihk1oxYVZfLlw8D4DdZufp99vzyuc9OHPO9YXCZ9NPUTq0EmEhFUg9n5KjhlXxc7m5ds6fuSiLiYkxugQxOWVErEi59gzNs1iRGXOthsrDUtNTCPANBiDQL4TU9JQct586e5T9xxI5cNR1OcisLKe7EQr0CyHtL9uv3/4tjWt1yHH/VfFzaXFjlxxjK7fMoUXtK49djcT9P9Pv7UZs2rmMciWqAjD1mR28FfsDqedOsWbb//D28qFsiao8PLYW78wdQIebHgFgfP+VvNXvB0oXr8I3P70PwIgHZvFm7AqaRd/FF0teBiA7O+vPB/zLVf0znRfZc2QL4RUbXHPdZjV58mSjSxCTU0bEipRrz9A8ixWZMddqqDws0C+Ecxmuo0xpGWcI8g913/boHWN5ZVoPZix7jagbWgBgs/35K0rLOEPg79snH99BWHAF/HwC3LefO3+W02kn3I0OuL7hOX7PSm6s1ipHHWsS/kfzvx3JuhoRlW9i0hPraVG7C9+u+wiA4IAS2Gw2mtfuzN4j8ew7msDBEzv4+Okknr9/Jh9/O9y9HUCL2l3YeyT+krE9v4/xlyNpf/35N+9aQd3qMddcs5nFxsYaXYKYnDIiVqRce4bmWazIjLlWQ+VhUVWasXHHUgA27lhCZOU/r0gYdUMzxj22nF7thlO5jOsKJtXK1WHb3jWkX0jj3PkzBPq5jm6tip97yRGmddsX0Tji9hxj2w+sI7xiAxx2h3vs5JkjeDt8CA4seU21X8y84P7/QL9gfLz9Sb+QhjPL9dm2rXtXUb5kdSCbQP9Q7HY7IYFhpKWf5mLmBS5kZri3K1eyOoD7FMate/64LwT7l+B4SjInTh8i4Pef93I/c1G3YsUKo0sQk1NGxIqUa8/QPIsVmTHXReaiFFYRXrEB3t5+DJ7Ukurl61E6tDLTlr7Cve2GM23pK2zcsYTggJIM+vd7AHSPeZqxMx4g42I6D9z65xeZ/ZSwgFEPzcux75Xxc+nVbniOsdw+c7R66zyaRXfKMTb6s+7E713JwRM7uCfmaZrX7nTJWIngcrz/zVPYbXaK+ZfgmZ6fkXw8iTdnPoy/TxBlS1TlgVtH4bA7CPAtxuBJLV0XxOj0Nqnpp3juw9vx9wkiyL84w3p+DsBT77XF19sfHy8/nrpnKgAP3DqKlz+/B4DHu0wEXEfatu1bw4DO7/zD34CIiIiISMGxZWf/5UMqUuDWz4CUZKOrsL7QitCoh9FVXCoxMTHP2yMjI0lISMhzm4iIiIIsSUzkSvkAZUSKnoLItTJ9dfQcI1ZTVJ8XdcqfiIGutCCIKCNiRcq1Z2iexYrMmGud8lfIipU2uoLrQ1Gd56+++oru3bsbXYaYmDIiVqRce4bmWazIjLnWKX8ihUinY0heiuqpDSJ50Sl/nqPnGLGaovq8qFP+RERERERE8kkNlYiIiIiISD6poRIx0KRJk4wuQUxOGRErUq49Q/MsVmTGXKuhEjFQdHS00SWIySkjYkXKtWdonsWKzJhrNVQiBmrdurXRJYjJKSNiRcq1Z2iexYrMmGs1VCIiIiIiIvmkhkrEQI0bNza6BDE5ZUSsSLn2DM2zWJEZc62GSsRA69atM7oEMTllRKxIufYMzbNYkRlzrYZKREREREQkn9RQiYiIiIiI5JMaKhEDzZo1y+gSxOSUEbEi5dozNM9iRWbMtRoqERERERGRfFJDJWKgrl27Gl2CmJwyIlakXHuG5lmsyIy59jK6AKvbvgzOHjO6CmsrVhpqtTW6ChERERG5HqmhKmRnj0FKstFViIiIiIhIYdApfyIG6t+/v9EliMkpI2JFyrVnaJ7FisyYa1t2dna20UVY2foZOkJV2EIrQqMeRleRu8TExH+8j4iIiAKoRMyoIPIByoiYi9Y9z9Fci9UU1edFHaESMVCrVq2MLkFMThkRK1KuPUPzLFZkxlyroRIx0PHjx40uQUxOGRErUq49Q/MsVmTGXOuiFNexJyfHkLBvDQ6HN3a7g7LFq9Kr3XBa1+1mdGkiIiIiIkWCGqrr3L3tR3Bv++dxOjOZt/odXv2iFzUq1KdCWA2jS7suREVFGV2CmJwyIlakXHuG5lmsyIy51il/AoDD4cXtTR7FmZXJrkObjC7nujF79myjSxCTU0bEipRrz9A8ixWZMddqqASAi5kXWLB6MgAVw2oaXM31Y+TIkUaXICanjIgVKdeeoXkWKzJjrtVQXee+WPoKnUeE0vE5fz7+7nmGdJtCtfJ1ABgzrRdrty1wb/vC1M6s377YqFItaebMmUaXICanjIgVKdeeoXkWKzJjrk3dUGVlZTFu3DjCw8Px8/Ojbt26xMXFUatWLfr06WN0eZbQq91wvh6dwqwXT3BTxB1s3rncfVtspwlM/W4E6Rmp/LhlDoF+ITSqdauB1YqIiIiImIupG6pHHnmE0aNH07dvXxYtWkT37t3p2bMnu3fvpmHDhkaXZynFAoozpNsUfkr8htXx8wAoHlSaLjc/wcR5A/li6cs8dtd4g6sUERERETEX017lb/r06UydOpUVK1bQunVrANq0acOGDRuYM2cODRo0MLhC6wkOKMG/Ww7ho2+fo2nUndjtdm5r/BCLfp5C5xYDCQ4oYXSJlhMXF2d0CWJyyohYkXLtGZpnsSIz5tq0R6jGjBlDhw4d3M3UH2rUqIG3tzd16tQhJSWFevXquf9ERUVhs9nYsmWLQVUXfV1aPsHJM4f5/pdP3WPlS9bQZdQLydatW40uQUxOGRErUq49Q/MsVmTGXJvyCFVycjLx8fEMHjz4ktv2799PdHQ0vr6++Pr6smnTJvdtn376KW+99RY33njjFR/DZrMVZMmXNe6x5dStHuORx7pWb8auuGQs0C+YOS+d9Hwx/0Bc3Aoa92xjdBm5yi3DfzV+/Pir2kas6Uq/e1BGpOgpiFwr01dHzzFiNWZ7XszOzr6q7Ux5hCo5ORmAsmXL5hhPT08nLi7usqf7ffDBB7pYhYiIiIiIeIwt+2pbLw/auXMn4eHhjB8/nkGDBrnHR40axYsvvsjEiRPp169fjvskJibSsGFDDh06REhIiIcrvrz1MyAl2egqrC20IjTqYXQVuUtMTMzz9sjISBISEvLcJiIioiBLEhO5Uj5AGZGipyByrUxfHT3HiNUU1edFU57yV61aNerUqcOYMWMoUaIEFSpUYNasWSxcuBAg1yv8vf/++3Tv3t1UzZTIlYwaNcroEsTklBGxIuXaMzTPYkVmzLUpT/mz2+3MnDmT6OhoYmNj6d27N2FhYfTv3x+Hw0GdOnVybJ+RkcGnn36q0/2kyOnevbvRJYjJKSNiRcq1Z2iexYrMmGtTNlQANWvWZPny5aSlpbF//35Gjx7Nli1biIqKwt/fP8e2c+fOpVy5cjRr1sygakXyJzIy0ugSxOSUEbEi5dozNM9iRWbMtSlP+buc9evX07Rp00vGP/jgAx599FEDKsqfyfMHk5S8nhoVGtC/09vu8Vc+78HJs0e4mJlBxsV03huyiW9//ohpS0YTfUMLhvX6HIALF8/z37n9OXJyD1XKRjOg83/5dPGLrIqfS5B/cZpF3UXX1kP4bt1UZix/lRLFyhFR6SYe7TgWgBnLX2dD0vc4szJ5o+8ydh/ezOszHiA94yyfP7cXgJNnjvDKtB5kk035ktUZ2v0jNu9awdgZD1K2RFVKh1bmmZ6fsudIPBNm9cFud1C+ZA2Gdv+I384cZsTHHdl3dBv/ezkVh8MLpzOT16bfx6nUo9Sq2NhdS6cRIdQoXx+AFx6cQ3BACXYe3MgH3zyNMyuTbq2H0iTyXwDsSN5Av7cb8u1rF3E4ilR0RURERMSiisyr0tTUVJKSki65GAXA0qVLDagof3YkbyA9I5Xx/X7k7dmxbD+wjlqVGgMw/L4ZAKzcMpcdB38BoFn0XdxYrRWfLX7RvY+5K/9Dm/q9aBDeLse++3Z8kwY12+cY69b6Ke5o8n/uvyfu/5nzGamM7bvEPVa+ZA3+8/hanv3gNvfYso1f0KHxw9zS6AHemvkouw5tBqB9w/vp3eFl93aVStXi7QGrAXjjy94kJa+natkbGdtnKS9+0sW93cr4uVQrX5eebZ/lna8fZ9ehzVQvX5eqZW+85PLtny8ZzaiH5uHnE5BjfP6aSYRX0Bc6i4iIiIh5mPaUv78LCgrC6XTy+OOPG13KP5Kwfy0Na94CQIPw9mzbt+aSbVbFz+Xm2ncDEBIYhsOes+/dvHsFa7bN58nJMazeOt89PmXhMzz9Xnt2HtzkHpv74wSGTGrFhh2upnNtwgJOp51g6Ltt+Oz7lwAI8CuGv09gjseoWKomaedPA5CecZYg/1AAlm+czuBJLVm2cToAXg5v9328vXwpFVIJH28/igUUz7G/wyd3U62c67Nv1cvXY9teVxO2/1gCgye1ZMrCYWRnZ3P4t91cyDzPS5915YWpnTl19igAe49spVRIRfx9i+U5v0VNTEyM0SWIySkjYkXKtWdonsWKzJjrItNQWUVqegoBvsEABPqFkJqekuP2TOdF9hzZQnjFyx+JOfzbLppE/IuXH/mGaUtG43Rm0vnmgUwa9AsD757MxHmuprNF7c68N+RXRj4wm/cXDMWZ5STl7FGCAooz7rHl7D+6jR3JG3J9jFqVb+Kbn97n4Tci8XL4UKZ4FWpWbMRHTycy5v++5euV/yEl9TgAq7fO59FxtUk5e5TgwJK57q9SqVr8uisOgM07l5N63vVzT31mB2/F/kDquVOs2fY/Tp09ysHjSYy8fxb/atqXL5a+AvD/7d1pjF1lHQbwZ5Yu02ln2jIFLHco0BZaCkIshloCpdCAEFG0IZSgEDYRqUE2QQgSTFR2IQpliwFXQERMiNEItrK0VES2UpYKRaBSClKWtnRKZ8YPwETj0JYDM3fh9/t45573/PPef+6ZJ+e978mtd1+WL+wxe9MmuYrMmTOn3CVQ4fQItUhf9w/zTC2qxL4WqPpZ8+DWrOl4I0myuuONnjs/73n46XnZZezeGx3jk2OnpWlgc0a3jcvKVS+lZcjIJElp1Pie9w1tGp76+voMHzoqpVHbZ+WbL71z7HbTkiS7jJ2e51b0vo//LX+5JF+e8Z385PTH09zUmkeeuStNg4amsWFAmgY2Z+ft9sqyV5YkSaZO+nyuPW1R2oaXct/i23sdb8qOB6Vj/Vs5/ep9M6BxUEYM3SJJ0jJkZOrq6jJ1p4Pz7PJFaW5qzfbtn87ggUOy67h98tyKx/PCy0syZHBLWpvbNjy5VeiEE04odwlUOD1CLdLX/cM8U4sqsa8Fqn6245jP5MF3l989uOSOTNz6fzfZuHfRb7PHTl/s7dD/GmNqlr74SDq7OvPSq8+mtXlUVq99J6S9vvqVdHauT5Ke1zrefivLXlmS4UNHZcdt3jk2SZ7+10PZcuS2vZ+kuzvD3g1pLUM2y+q1r/eM19nVmaeevz9bjNgm69Z39BwyZFBLBg1o6nW4hvqGzD74R7no+DtTX9+Q3XbYP2+tW53Ors4kyWPP3pvRm43NVm3j89qqFens6uypb+nyR/PU8/fn29d+NktffCSX3fq1Dc5PNZk3b165S6DC6RFqkb7uH+aZWlSJfV01m1LUivGlT2XAgME5+co9M3b0rtl8+Nb5xZ3fy+H7np3u7u4s/ueCzD74xz3vv2/x7blx7vl58d9P57wbZubcI3+TQ6efkQtvPDJrOt7IgbsflwGNA3PFbd/I0uWL0t3dlWMOPD9JcutdP8z9T/4h3d1dmTX9zDQ2DMiUiZ/Lpbccl1PmTMvWoyZk0jZTs+K153PxTUfl2eWL8q2rZ+SUQ67LQVO/ngtvOjI/v+O7aRmyWQ7b56z86YGf5vcLr0ldXX2m73pY2lpHZ/6i3+WWuy9NkmzVNj6Tt98v6zvfzlnXHZBnXnw4Z163f44+4PsZ1VrKD355eOrr6jNj8hFpa90q/1j2UC759dFpGjg0W47cNkfsd14a6hty4O7H5bSr9k5dXX1OP/T6fGLkttlz53d+U3bqnL3zzS9d1f8fHAAA9KKuu7u7u9xF1LK/3Zi89kK5q6htw0vJbrPKXUXvnnjiiQ3+feLEiXn88d6XXb5nwoQJH2VJVJCN9UeiR6g+H0Vf6+lN4xpDranW66Ilf1BGG/tCAD1CLdLX/cM8U4sqsa8FKiijm2++udwlUOH0CLVIX/cP80wtqsS+tuSvjz355+TNFeWuorYN2zzZYZ9yV9E7yzHYkGpd2gAbYslf/3GNodZU63XRphR9rFL/0QcAAD48S/4AAAAKEqigjK688spyl0CF0yPUIn3dP8wztagS+1qggjKaNGlSuUugwukRapG+7h/mmVpUiX0tUEEZTZs2rdwlUOH0CLVIX/cP80wtqsS+FqgAAAAKEqgAAAAKsm069KGNPQfh3HPP9QyQj7FN+ez1CNVGX/cf1xhqTbV+f3iwLwAAQEGW/AEAABQkUAEAABQkUAEAABQkUAEAABQkUAEAABQkUAEAABQkUAEAABQkUPXipJNOSqlUSmOj5x4DAADvz4N9e3HPPfdk3LhxKZVKWb9+fbnLAQAAKpRAtQGNjY0CFQAA8L4s+QMAAChIoAIAAChIoAIAAChIoAIAAChIoOrF8ccfn1KplM7OzpRKpZx44ok9f7OHBwAA8B67/H1A8+57KMuWv5xDD9onjQ0N5S4HAAAoI3eoPoCOjnW5a+HDWff2emEKAACo/kD16KOPZubMmWlra8vgwYMzfvz4nH322X1yrvl/fyxr1nZkxh6T+2R8AACgujSWu4AP44EHHshee+2V9vb2XHTRRRkzZkyWLl2a+fPnb/TYMy+4pvB5r/jZbYWPBQAAKt/5Z3x1k95X1YHq1FNPTXNzcxYuXJjW1tae14855pgyVgUAAHxcVO2mFGvWrMmwYcMye/bsXH755X16ro6Odbngql+lffTmOeqQA/r0XAAAQPWo2jtUK1euTFdXV0qlUqHjiyz5e/KZ5z/UUkEAAKA6bOqSv6rdlGLEiBGpr6/PsmXLyl0KAADwMVW1S/6SZPr06Vm8eHGWLFmSlpaWPjnH3AUP5o933Z8Tv3Jw2kdv3ifnAAAAqlPV3qFKkosvvjirVq3KlClTcv3112fu3Lm54YYbcuyxx34k43d0rMvdf30kO2zXLkwBAAD/p2p/Q5UkkydPzoIFC3LOOefk5JNPztq1a9Pe3p5Zs2Z9JOO/+vqbaWoa5LlTAABAr6p6yV9/6OrqSn19Vd/IAwAA+ohABQAAUJBbLwAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAX9B4Fs6uEzbEOLAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc(n_qubits_data, num_layers,params).draw(output=\"mpl\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Fucntion to make a swap test\n", + "'''\n", + "Input: Number of qubits\n", + "Output: Quantum circuit\n", + "'''\n", + "def swap_test(n):\n", + " qubits_values = 2*n+1 #Create a new qubit value to create our circuit\n", + " qc = QuantumCircuit(qubits_values) #Create the quantum circuit with the qubits value\n", + " qc.h(0) #Applying a H gate to the first qubit\n", + " for i in range(n):\n", + " #Applying a cswap gate between the first quibit and the i+1 and 2*n-i qubits\n", + " qc.cswap(0,i+1,2*n-i) \n", + " qc.h(0) #Applying a H gate to the first qubit\n", + " qc.barrier() #Create a barrier\n", + " return qc\n", + "#Example of a swap test with 2 quibits\n", + "swap_test(2).draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 126, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "size_reduce = 2 #Number of qubits we want to reduce\n", + "circuit_init = input_data(n_qubits_data, data_pca[0]) #Create a inicial circui\n", + "circuit_vqc = vqc(n_qubits_data,num_layers,params) #Create a quantum variational circuit\n", + "circuit_swap_test = swap_test(size_reduce) #Create a swap test circuit\n", + "\n", + "#Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", + "circuit_full = QuantumCircuit(n_qubits_data+size_reduce+1,1)\n", + "\n", + "#Combine the initial circuit, the quantum variatinal circuit and the swap test\n", + "#For the initial circuit and QVC we start at the qubit size_reduce + 1\n", + "#For the swap test we start at the qubit 0\n", + "circuit_full = circuit_full.compose(circuit_init,[i for i in range(size_reduce+1,n_qubits_data+size_reduce+1)])\n", + "circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(size_reduce+1,n_qubits_data+size_reduce+1)])\n", + "circuit_full = circuit_full.compose(circuit_swap_test,[i for i in range(2*size_reduce+1)])\n", + "circuit_full.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 127, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vqc(n_qubits_data,num_layers,params).inverse().draw(output = \"mpl\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [], + "source": [ + "from random import shuffle\n", + "from scipy.optimize import minimize " + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_qubits_data" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/scipy/optimize/_minimize.py:702: OptimizeWarning: Unknown solver options: max_iter\n", + " res = _minimize_cobyla(fun, x0, args, constraints, callback=callback,\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.860546875\n", + "0.787109375\n", + "0.845703125\n", + "0.745703125\n", + "0.786328125\n", + "0.787890625\n", + "0.7515625\n", + "0.738671875\n", + "0.7625\n", + "0.7453125\n", + "0.84140625\n", + "0.41875\n", + "0.390234375\n", + "0.467578125\n", + "0.36484375\n", + "0.41875\n", + "0.426953125\n", + "0.370703125\n", + "0.490234375\n", + "0.4140625\n", + "0.581640625\n", + "0.421484375\n", + "0.361328125\n", + "0.331640625\n", + "0.2703125\n", + "0.26875\n", + "0.27421875\n", + "0.294140625\n", + "0.32578125\n", + "0.253515625\n", + "0.245703125\n", + "0.2828125\n", + "0.24296875\n", + "0.260546875\n", + "0.260546875\n", + "0.31328125\n", + "0.269140625\n", + "0.264453125\n", + "0.25859375\n", + "0.230078125\n", + "0.269921875\n", + "0.2484375\n", + "0.265625\n", + "0.270703125\n", + "0.260546875\n", + "0.25390625\n", + "0.25859375\n", + "0.24765625\n", + "0.249609375\n", + "0.238671875\n", + "0.266015625\n", + "0.25390625\n", + "0.248046875\n", + "0.238671875\n", + "0.2359375\n", + "0.252734375\n", + "0.25625\n", + "0.270703125\n", + "0.231640625\n", + "0.25\n", + "0.262109375\n", + "0.25859375\n", + "0.255078125\n", + "0.24609375\n", + "0.246484375\n", + "0.234765625\n", + "0.252734375\n", + "0.264453125\n", + "0.224609375\n", + "0.26796875\n", + "0.244921875\n", + "0.263671875\n", + "0.259765625\n", + "0.262109375\n", + "0.234375\n", + "0.24765625\n", + "0.256640625\n", + "0.251171875\n", + "0.244921875\n", + "0.24609375\n", + "0.244140625\n", + "0.24921875\n", + "0.26015625\n", + "0.237109375\n", + "0.242578125\n", + "0.24609375\n", + "0.248828125\n", + "0.257421875\n", + "0.246484375\n", + "0.24296875\n", + "0.24609375\n", + "0.259375\n", + "0.258203125\n", + "0.25859375\n", + "0.23828125\n", + "0.2421875\n", + "0.2484375\n", + "0.234765625\n", + "0.24765625\n", + "0.26015625\n", + "0.26015625\n", + "0.24375\n", + "0.251171875\n", + "0.237109375\n", + "0.24921875\n", + "0.24453125\n", + "0.24375\n", + "0.253515625\n", + "0.253125\n", + "0.241015625\n", + "0.256640625\n", + "0.258984375\n", + "0.255078125\n", + "0.24453125\n", + "0.2421875\n", + "0.25390625\n", + "0.266015625\n", + "0.2453125\n", + "0.252734375\n", + "0.237890625\n", + "0.24765625\n", + "0.24609375\n", + "0.24296875\n", + "0.23671875\n", + "0.255859375\n", + "0.244140625\n", + "0.2609375\n", + "0.2484375\n", + "0.241015625\n", + "0.251953125\n", + "0.25390625\n", + "0.243359375\n", + "0.248046875\n", + "0.253125\n", + "0.25703125\n", + "0.25\n", + "0.25625\n", + " cost: 0.25625\n", + "[ 3.25402569 -0.87167382 2.74528436 0.39132926 -1.3705645 0.34323234\n", + " 2.93714471 0.80357588 1.32506271 0.17947663]\n" + ] + } + ], + "source": [ + "from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute, QuantumRegister, ClassicalRegister\n", + "\n", + "#Function to identify a function cost\n", + "'''\n", + "Input: An array of parameters(vector of complex amplitudes)\n", + "Output: Function cost\n", + "'''\n", + "def objective_function(params):\n", + " n = n_qubits_data\n", + " costo = 0\n", + " shuffle(data_pca) #reorganize the order of the train set items\n", + " length = 5 #We only will consider the first five elements of the taining set\n", + " #For each item of the trainig set\n", + " for i in range(length):\n", + " circuit_init = input_data(n, data_pca[i])#Create a inicial circuit\n", + " circuit_vqc = vqc(n, num_layers,params) #Create a quantum variational circuit\n", + " circuit_swap_test = swap_test(size_reduce) #Create a swap test circuit\n", + "\n", + " #Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", + " circuit_full = QuantumCircuit(n + size_reduce+1,1)\n", + " \n", + " #Combine the initial circuit, the quantum variatinal circuit and the swap test\n", + " #For the initial circuit and QVC we start at the qubit size_reduce + 1\n", + " #For the swap test we start at the qubit 0\n", + " circuit_full = circuit_full.compose(circuit_init,[i for i in range(size_reduce+1,n+size_reduce+1)])\n", + " circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(size_reduce+1,n+size_reduce+1)])\n", + " circuit_full = circuit_full.compose(circuit_swap_test,[i for i in range(2*size_reduce+1)])\n", + " \n", + " #\n", + " circuit_full.measure(0, 0) # Measure the first qubit\n", + " \n", + " #qc.draw()\n", + " \n", + " #Execute the circuit in the qasm_simulator\n", + " job = execute( circuit_full, Aer.get_backend('qasm_simulator'),shots=shots )\n", + " counts = job.result().get_counts() #Count the results of the execution\n", + " probs = {} #Calculate the probabilities of 0 and 1 state\n", + " \n", + " for output in ['0','1']:\n", + " if output in counts:\n", + " probs[output] = counts[output]/shots #Calculate the average of a state\n", + " else:\n", + " probs[output] = 0\n", + " costo += (1 + probs['1'] - probs['0']) #Update the actual function cost\n", + " \n", + " print(costo / length)\n", + " \n", + " return costo / length\n", + "\n", + "shots = 1024 #Number of shots\n", + "max_iter = 2\n", + "\n", + "for i in range(1):\n", + " #Minimization of the objective_fucntion by a COBYLA method\n", + " options = {\n", + " \"max_iter\": max_iter\n", + " }\n", + " minimum = minimize(objective_function, params, method='COBYLA', tol=1e-6, options=options)\n", + " params = minimum.x #Get the solution array\n", + " #Show the cost of the solution array\n", + " print(\" cost: \",objective_function(params))\n", + " print(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "params_minimized = params" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# P Q C\n", + "# Rotations CRY, CRZ < - controlled by parameters\n", + "# -> " + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [], + "source": [ + "import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2000/2000 [00:37<00:00, 53.27it/s]\n" + ] + } + ], + "source": [ + "#Function to compress the training set values\n", + "'''\n", + "Input: An array of parameters(vector of complex amplitudes)\n", + "Output: Array with compress values\n", + "'''\n", + "def compress_result(*, params, n, size_reduce, X, shots=1024):\n", + " reduce = [] #List to save the compress values\n", + " #For each row in the training set we will\n", + " for i in tqdm.tqdm(range(len(X))):\n", + " circuit_init = input_data(n, X[i]) #Create a inicial circuit\n", + " circuit_vqc = vqc(n,num_layers,params) #Create a quantum variational circuit\n", + " \n", + " #Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", + " circuit_full = QuantumCircuit(n, n-size_reduce)\n", + "\n", + " #Combine the initial circuit, the quantum variatinal circuit\n", + " circuit_full = circuit_full.compose(circuit_init,[i for i in range(n)])\n", + " circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(n)])\n", + " len_cf = len(circuit_full) #Known the length of the circuit\n", + " #For each n - the the desired qubits to reduce we will\n", + " for i in range(n-size_reduce):\n", + " circuit_full.measure(size_reduce+i, i) #Measure the circuit in the position size_reduce+i \n", + " #We will execute the full circuit in the qasm simulator\n", + " job = execute( circuit_full, Aer.get_backend('qasm_simulator'), shots=shots )\n", + " result = job.result().get_counts() #Get the results of the execution\n", + " #Get the probabilities of each state\n", + " probs = {k: np.sqrt(v / shots) for k, v in result.items()}\n", + " reduce.append(probs) #Save the probabilities\n", + " \n", + " return reduce\n", + " \n", + "#Call the compress_result_train function with the parameters defined above\n", + "reduce_img = compress_result(params=params_minimized, n=n_qubits_data, size_reduce=size_reduce, X=data_pca, shots=1024)\n", + "train_reduce = [] #List to save the new values of the image reduction\n", + "#for each value in the reduce_img list\n", + "for i in reduce_img:\n", + " index_image = [] #List to save the reduction values\n", + " #We now take in count we want a 6X6 image\n", + " size = n_qubits_data - size_reduce \n", + " \n", + " for j in range(size * size):\n", + " bin_index = bin(j)[2:] #We take the binary value of j from the 2 position to the end\n", + " \n", + " while len(bin_index) < size: #While bin_index is less than 4\n", + " bin_index = '0'+bin_index #We concatenate a 0 string at the beginnig\n", + " try: \n", + " #We try to save the element of the row in the position bin_index\n", + " index_image.append(i[bin_index])\n", + " except:\n", + " index_image.append(0) #If we can't, we only save a 0\n", + " \n", + " #We save the new imagen values in the train_recuce list\n", + " train_reduce.append(np.array(index_image))" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 3.25402569, -0.87167382, 2.74528436, 0.39132926, -1.3705645 ,\n", + " 0.34323234, 2.93714471, 0.80357588, 1.32506271, 0.17947663])" + ] + }, + "execution_count": 143, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "params_minimized" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'110111': 0.03125,\n", + " '001001': 0.04419417382415922,\n", + " '101101': 0.04419417382415922,\n", + " '110010': 0.03125,\n", + " '101111': 0.04419417382415922,\n", + " '110000': 0.06987712429686843,\n", + " '101110': 0.03125,\n", + " '001010': 0.04419417382415922,\n", + " '011010': 0.04419417382415922,\n", + " '100100': 0.0625,\n", + " '001110': 0.04419417382415922,\n", + " '100011': 0.04419417382415922,\n", + " '110100': 0.06987712429686843,\n", + " '000010': 0.04419417382415922,\n", + " '010110': 0.09375,\n", + " '000011': 0.04419417382415922,\n", + " '100000': 0.05412658773652741,\n", + " '101100': 0.04419417382415922,\n", + " '101010': 0.04419417382415922,\n", + " '001111': 0.08838834764831845,\n", + " '000001': 0.08838834764831845,\n", + " '010101': 0.14657549249448218,\n", + " '010010': 0.05412658773652741,\n", + " '100010': 0.07654655446197431,\n", + " '001101': 0.11692679333668567,\n", + " '010000': 0.1926379375927805,\n", + " '111001': 0.10825317547305482,\n", + " '110001': 0.30136408628102984,\n", + " '001011': 0.08267972847076846,\n", + " '110011': 0.08838834764831845,\n", + " '101001': 0.06987712429686843,\n", + " '011101': 0.08267972847076846,\n", + " '101011': 0.04419417382415922,\n", + " '000101': 0.10364452469860624,\n", + " '111110': 0.03125,\n", + " '010001': 0.7241643891410292,\n", + " '010011': 0.2209708691207961,\n", + " '000111': 0.09882117688026186,\n", + " '100111': 0.03125,\n", + " '011011': 0.03125,\n", + " '011111': 0.05412658773652741,\n", + " '011000': 0.05412658773652741,\n", + " '000100': 0.1288470508005519,\n", + " '011001': 0.18221724671391565,\n", + " '000000': 0.0625,\n", + " '011100': 0.05412658773652741,\n", + " '111100': 0.08267972847076846,\n", + " '111011': 0.0625,\n", + " '010111': 0.08267972847076846,\n", + " '010100': 0.16535945694153692,\n", + " '001000': 0.0625,\n", + " '111101': 0.10364452469860624,\n", + " '001100': 0.04419417382415922,\n", + " '111010': 0.04419417382415922}" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduce_img[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def plot_images(x, size=28, i=0):\n", + " plt.figure()\n", + "\n", + " #subplot(r,c) provide the no. of rows and columns\n", + " f, axarr = plt.subplots(5,1) \n", + " \n", + " # use the created array to output your multiple images. In this case I have stacked 4 images vertically\n", + " axarr[0].imshow(x[i+0].reshape(size,size)*255)\n", + " axarr[1].imshow(x[i+1].reshape(size,size)*255)\n", + " axarr[2].imshow(x[i+2].reshape(size,size)*255)\n", + " axarr[3].imshow(x[i+3].reshape(size,size)*255)\n", + " axarr[4].imshow(x[i+4].reshape(size,size)*255)\n", + " \n", + "plot_images(x_train, size=28, i=1500)" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(36,)" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_reduce[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.09882118, 0.13621559, 0. , 0.07654655, 0.12884705,\n", + " 0.0625 , 0.03125 , 0.06987712, 0.06987712, 0. ,\n", + " 0.03125 , 0.0625 , 0. , 0.10364452, 0. ,\n", + " 0.05412659, 0.1711633 , 0.72348981, 0.08838835, 0.23799291,\n", + " 0.14657549, 0.125 , 0.11692679, 0.0625 , 0.03125 ,\n", + " 0.20963137, 0.04419417, 0.03125 , 0.03125 , 0.08267973,\n", + " 0.03125 , 0.06987712, 0.05412659, 0. , 0.06987712,\n", + " 0.03125 ])" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_reduce[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_images(train_reduce, size=6, i=25)" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "36" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Function to decode the training set values compressed\n", + "'''\n", + "Input: An array of parameters(vector of complex amplitudes)\n", + "Output: Array with decode values\n", + "'''\n", + "def decoder_result_train(params):\n", + " reduce = [] #List to save the decoded values\n", + " #For each row in the test set reduced we will\n", + " for i in range(len(train_reduce)):\n", + " #Create a initial circuit with 6 qubits and a list of 48 zeros and the i row of the test reduced values\n", + " circuit_init = input_data(n,np.concatenate((np.zeros(48), train_reduce[i]), axis=0))\n", + " #Create the inverse VQC \n", + " circuit_vqc = vqc(n,num_layers,params).inverse()\n", + "\n", + " #Create a new circuit to combine the inicial circuit and the VQC\n", + " circuit_full = QuantumCircuit(n,n)\n", + " \n", + " #Combine the initial circuit, the quantum variatinal circuit\n", + " circuit_full = circuit_full.compose(circuit_init,[i for i in range(n)])\n", + " circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(n)])\n", + " #We will execute the full circuit in the qasm simulator\n", + " job = execute( circuit_full, Aer.get_backend('statevector_simulator') )\n", + " result = job.result().get_statevector() #Get the results of the execution\n", + " reduce.append(result) #Save the results\n", + " return reduce\n", + " \n", + "#Call the decoder_result_train function \n", + "decoder_train =decoder_result_train(params)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
     »\n",
+       "q_0: »\n",
+       "     »\n",
+       "q_1: »\n",
+       "     »\n",
+       "q_2: »\n",
+       "     »\n",
+       "q_3: »\n",
+       "     »\n",
+       "q_4: »\n",
+       "     »\n",
+       "q_5: »\n",
+       "     »\n",
+       "q_6: »\n",
+       "     »\n",
+       "q_7: »\n",
+       "     »\n",
+       "c: 1/»\n",
+       "     »\n",
+       "«     ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐»\n",
+       "«q_0: ┤0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
+       "«q_1: ┤1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
+       "«q_2: ┤2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
+       "«q_3: ┤3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │  Initialize(0.19933,0.78458,0.060899,-0.027745,0.11977,0.082523,0.12581,-0.14133,-0.016088,0.026866,-0.019481,-0.14062,0.0078529,-0.0083738,-0.0076929,-0.02553,-0.048177,-0.012015,0.0028569,-0.043265,-0.096038,-0.0070439,-0.10802,-0.12586,0.063355,-0.020224,-0.044352,0.053306,0.017528,-0.087435,-0.03596,0.085269,0.085289,-0.014925,0.095256,-0.019094,-0.0079092,0.022646,0.060792,-0.0097256,-0.017249,-0.057585,-0.0042668,0.039688,-0.0071199,0.028444,-0.037858,0.041783,-0.013583,0.013934,0.0077143,0.07646,0.031435,0.043461,-0.0016037,0.10471,-0.016493,-0.049929,-0.016514,-0.024419,-0.020249,-0.022882,-0.001635,-0.039676,-0.094962,0.055315,-0.012034,-0.0043611,0.064414,0.0051576,0.0092164,-0.025113,0.022099,-0.06501,-0.0094487,-0.023682,-0.049237,0.017527,-0.010831,0.0068719,0.013686,-0.046753,-0.01355,0.018597,-0.080883,0.033222,0.059485,0.070075,-0.052423,0.034505,0.00088157,-0.033224,0.0085052,0.0048633,0.012664,-0.029608,0.02963,-0.0083869,0.044219,-0.022338,0.008193,0.016718,-0.040688,0.0020877,0.016231,-0.0040373,0.085946,-0.00055113,-0.03307,0.0084604,-0.019586,-0.022871,-0.051835,-0.033727,0.020317,-0.030812,-0.008016,-0.014824,0.054878,-0.024544,-0.014974,0.048952,0.018366,0.027505,-0.0087697,0.029066,-0.021802,-0.019985,-0.024976,-0.01525,-0.026949,-0.012689,-0.011489,0.0043565,0.0093918,0.008106,-0.002721,-0.062332,0.0040207,-0.031922,0.0070477,-0.046791,-0.024917,0.031065,0.0043196,0.020311,0.0023385,0.041404,0.0036015,0.02561,-0.023687,0.0024591,-0.0040734,-0.0092194,0.0012252,0.0014434,-0.029637,0.0064809,-0.025973,-0.019026,-0.0021421,0.0038971,0.033392,0.0086663,0.034408,0.0033675,0.024363,-0.0061191,-0.0022511,0.00039314,0.038701,-0.015828,-0.005892,-0.031952,-0.012703,-0.032764,0.0082279,-0.0189,0.0032144,0.022357,0.0016688,0.010722,0.021873,0.022183,-0.03733,0.02195,-0.015607,-0.018195,-0.021413,0.014492,0.016177,-0.019251,0.048351,0.0011298,0.008538,0.0076566,-0.032159,-0.0496,-0.02278,0.0097229,0.033377,-0.0044157,-0.00093023,0.00056362,-0.007001,0.019911,-0.040736,-0.046184,-0.0099688,-0.0014499,-0.015302,0.018341,-0.025148,0.0098564,-0.0086303,-0.032014,0.01639,0.014977,-0.013512,0.0051044,-0.0091627,0.025143,0.0069158,-0.0031569,0.0052421,-0.030917,-0.025982,-0.0049395,-0.0096566,0.016997,0.015062,0.0022722,-0.031119,0.0038691,0.03321,0.010916,0.014046,-0.016742,-0.01859,-0.033715,-0.021029,0.0057678,-0.003423,0.042017,-0.019512,-0.0024657,0.033014,-0.0012892,0.032856,-0.0064646,0.01211,0.0053955,-0.0024682,-0.0052844,0.011111,0.02473) │»\n",
+       "«q_4: ┤4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
+       "«q_5: ┤5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
+       "«q_6: ┤6                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
+       "«q_7: ┤7                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
+       "«     └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘»\n",
+       "«c: 1/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════»\n",
+       "«                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            »\n",
+       "«      ░ \n",
+       "«q_0: ─░─\n",
+       "«      ░ \n",
+       "«q_1: ─░─\n",
+       "«      ░ \n",
+       "«q_2: ─░─\n",
+       "«      ░ \n",
+       "«q_3: ─░─\n",
+       "«      ░ \n",
+       "«q_4: ─░─\n",
+       "«      ░ \n",
+       "«q_5: ─░─\n",
+       "«      ░ \n",
+       "«q_6: ─░─\n",
+       "«      ░ \n",
+       "«q_7: ─░─\n",
+       "«      ░ \n",
+       "«c: 1/═══\n",
+       "«
" + ], + "text/plain": [ + " »\n", + "q_0: »\n", + " »\n", + "q_1: »\n", + " »\n", + "q_2: »\n", + " »\n", + "q_3: »\n", + " »\n", + "q_4: »\n", + " »\n", + "q_5: »\n", + " »\n", + "q_6: »\n", + " »\n", + "q_7: »\n", + " »\n", + "c: 1/»\n", + " »\n", + "« ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐»\n", + "«q_0: ┤0 ├»\n", + "« │ │»\n", + "«q_1: ┤1 ├»\n", + "« │ │»\n", + "«q_2: ┤2 ├»\n", + "« │ │»\n", + "«q_3: ┤3 ├»\n", + "« │ Initialize(0.19933,0.78458,0.060899,-0.027745,0.11977,0.082523,0.12581,-0.14133,-0.016088,0.026866,-0.019481,-0.14062,0.0078529,-0.0083738,-0.0076929,-0.02553,-0.048177,-0.012015,0.0028569,-0.043265,-0.096038,-0.0070439,-0.10802,-0.12586,0.063355,-0.020224,-0.044352,0.053306,0.017528,-0.087435,-0.03596,0.085269,0.085289,-0.014925,0.095256,-0.019094,-0.0079092,0.022646,0.060792,-0.0097256,-0.017249,-0.057585,-0.0042668,0.039688,-0.0071199,0.028444,-0.037858,0.041783,-0.013583,0.013934,0.0077143,0.07646,0.031435,0.043461,-0.0016037,0.10471,-0.016493,-0.049929,-0.016514,-0.024419,-0.020249,-0.022882,-0.001635,-0.039676,-0.094962,0.055315,-0.012034,-0.0043611,0.064414,0.0051576,0.0092164,-0.025113,0.022099,-0.06501,-0.0094487,-0.023682,-0.049237,0.017527,-0.010831,0.0068719,0.013686,-0.046753,-0.01355,0.018597,-0.080883,0.033222,0.059485,0.070075,-0.052423,0.034505,0.00088157,-0.033224,0.0085052,0.0048633,0.012664,-0.029608,0.02963,-0.0083869,0.044219,-0.022338,0.008193,0.016718,-0.040688,0.0020877,0.016231,-0.0040373,0.085946,-0.00055113,-0.03307,0.0084604,-0.019586,-0.022871,-0.051835,-0.033727,0.020317,-0.030812,-0.008016,-0.014824,0.054878,-0.024544,-0.014974,0.048952,0.018366,0.027505,-0.0087697,0.029066,-0.021802,-0.019985,-0.024976,-0.01525,-0.026949,-0.012689,-0.011489,0.0043565,0.0093918,0.008106,-0.002721,-0.062332,0.0040207,-0.031922,0.0070477,-0.046791,-0.024917,0.031065,0.0043196,0.020311,0.0023385,0.041404,0.0036015,0.02561,-0.023687,0.0024591,-0.0040734,-0.0092194,0.0012252,0.0014434,-0.029637,0.0064809,-0.025973,-0.019026,-0.0021421,0.0038971,0.033392,0.0086663,0.034408,0.0033675,0.024363,-0.0061191,-0.0022511,0.00039314,0.038701,-0.015828,-0.005892,-0.031952,-0.012703,-0.032764,0.0082279,-0.0189,0.0032144,0.022357,0.0016688,0.010722,0.021873,0.022183,-0.03733,0.02195,-0.015607,-0.018195,-0.021413,0.014492,0.016177,-0.019251,0.048351,0.0011298,0.008538,0.0076566,-0.032159,-0.0496,-0.02278,0.0097229,0.033377,-0.0044157,-0.00093023,0.00056362,-0.007001,0.019911,-0.040736,-0.046184,-0.0099688,-0.0014499,-0.015302,0.018341,-0.025148,0.0098564,-0.0086303,-0.032014,0.01639,0.014977,-0.013512,0.0051044,-0.0091627,0.025143,0.0069158,-0.0031569,0.0052421,-0.030917,-0.025982,-0.0049395,-0.0096566,0.016997,0.015062,0.0022722,-0.031119,0.0038691,0.03321,0.010916,0.014046,-0.016742,-0.01859,-0.033715,-0.021029,0.0057678,-0.003423,0.042017,-0.019512,-0.0024657,0.033014,-0.0012892,0.032856,-0.0064646,0.01211,0.0053955,-0.0024682,-0.0052844,0.011111,0.02473) │»\n", + "«q_4: ┤4 ├»\n", + "« │ │»\n", + "«q_5: ┤5 ├»\n", + "« │ │»\n", + "«q_6: ┤6 ├»\n", + "« │ │»\n", + "«q_7: ┤7 ├»\n", + "« └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘»\n", + "«c: 1/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════»\n", + "« »\n", + "« ░ \n", + "«q_0: ─░─\n", + "« ░ \n", + "«q_1: ─░─\n", + "« ░ \n", + "«q_2: ─░─\n", + "« ░ \n", + "«q_3: ─░─\n", + "« ░ \n", + "«q_4: ─░─\n", + "« ░ \n", + "«q_5: ─░─\n", + "« ░ \n", + "«q_6: ─░─\n", + "« ░ \n", + "«q_7: ─░─\n", + "« ░ \n", + "«c: 1/═══\n", + "« " + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "circuit_init.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -202,7 +1647,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 [Default]", "language": "python", "name": "python3" }, @@ -216,9 +1661,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.9.10" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" @@ -226,5 +1670,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } From 1f92b33cb7dd7de3ceedc09c68949db6f1ca9a98 Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 03:00:59 +0000 Subject: [PATCH 02/10] PCA and No PCA amplitude encoding --- part1_no_pca.ipynb | 951 +++ part1_with_pca.ipynb | 1135 ++++ part2_with_pca.ipynb | 12946 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 15032 insertions(+) create mode 100644 part1_no_pca.ipynb create mode 100644 part1_with_pca.ipynb create mode 100644 part2_with_pca.ipynb diff --git a/part1_no_pca.ipynb b/part1_no_pca.ipynb new file mode 100644 index 0000000..108a556 --- /dev/null +++ b/part1_no_pca.ipynb @@ -0,0 +1,951 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(3,20):\n", + " assert counter.get(i,0)==0\n", + " \n", + " \n", + " return counter\n", + "\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(image1, image2)" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.000000\n" + ] + } + ], + "source": [ + "a = 1e-9\n", + "print('{:f}'.format(a))" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "metadata": {}, + "outputs": [], + "source": [ + "#load the mock data (for testing only)\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", + " {'image': [[0, 0], [0, 0]], 'category': 1}]" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 122, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#load the actual hackthon data (fashion-mnist)\n", + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')\n", + "#you can visualize it\n", + "plt.imshow(images[1100])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.00392156862745098" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "images." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#submission to part 1, you should make this into a .py file\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "# Functions 'encode' and 'decode' are dummy.\n", + "def encode(image):\n", + " \n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " if image[0][0]==0:\n", + " circuit.rx(np.pi,0)\n", + " return circuit\n", + "\n", + "def decode(histogram):\n", + " if 1 in histogram.keys():\n", + " image=[[0,0],[0,0]]\n", + " else:\n", + " image=[[1,1],[1,1]]\n", + " return image\n", + "\n", + "def run_part1(image):\n", + " #encode image into a circuit\n", + " circuit = encode(image)\n", + "\n", + " #simulate circuit\n", + " histogram = simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re = decode(histogram)\n", + "\n", + " return circuit,image_re" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + } + ], + "source": [ + "#how we grade your submission\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for data in dataset:\n", + " #encode image into circuit\n", + " circuit,image_re=run_part1(data['image'])\n", + " \n", + " #count the number of 2qubit gates used\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(data['image'],image_re)\n", + " \n", + "#fidelity of reconstruction\n", + "f=1-mse\n", + "gatecount=gatecount/n\n", + "\n", + "#score for part1 \n", + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def encode(image):\n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " circuit.h([0, 1, 2])\n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", + " {'image': [[0, 0], [0, 0]], 'category': 1}]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0.12499999999999994,\n", + " 1: 0.12499999999999994,\n", + " 2: 0.12499999999999994,\n", + " 3: 0.12499999999999994,\n", + " 4: 0.12499999999999994,\n", + " 5: 0.12499999999999994,\n", + " 6: 0.12499999999999994,\n", + " 7: 0.12499999999999994}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulate(encode(dataset[0]['image']))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0.12499999999999994,\n", + " 1: 0.12499999999999994,\n", + " 2: 0.12499999999999994,\n", + " 3: 0.12499999999999994,\n", + " 4: 0.12499999999999994,\n", + " 5: 0.12499999999999994,\n", + " 6: 0.12499999999999994,\n", + " 7: 0.12499999999999994}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulate(encode(dataset[1]['image']))" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "64" + ] + }, + "execution_count": 155, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 6" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "256" + ] + }, + "execution_count": 153, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 8 " + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "512" + ] + }, + "execution_count": 154, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 9" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(images[0] * 255)\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'desired_state' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdesired_state\u001b[49m\n", + "\u001b[0;31mNameError\u001b[0m: name 'desired_state' is not defined" + ] + } + ], + "source": [ + "desired_state" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 160, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 10" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 158, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "28 * 28" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(784,)\n", + "240\n", + "(1024,)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAC4CAYAAAD61bdSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAUsUlEQVR4nO3da4zc1XnH8d+zszve9doYbOMLvuBgwMVQAu1ySYgqGhJC0kSQSqVBKvKLtI7aJEpU3iBeFFS1Ul40kFRqoziF4KpJSCRCgyhqmjhpKZc4OBaNAXNxwMQ2xpcY8G3tnZ15+mKHdu3z/PHuzmXnjL8fyfLss2dmzn/m0Zn/zvM/55i7CwCQn57p7gAAYGoYwAEgUwzgAJApBnAAyBQDOABkigEcADLV0ABuZjeY2Ytmts3Mbm9Wp4DpRm4jBzbV68DNrCTpJUkflrRT0tOSbnH354vuU7YZ3q/BKT3ftJjZn4RGB0th0+pA+jqeOXg0bPvW4fQ1KB9M7+9m4f1rvWmsPO942Lavp5rEDh+YGbYtvz2a9uFY/Lid6JiOaMSPxy/aJJDbJyK3p19Rbgcv14RdKWmbu78iSWb2gKQbJRUmeb8GdZVd18BTtpddfEkS23PVGWHbty5OE+QPr9oUtn3oySuS2LIfpkle64uTfHhe+ofTObe+GrZdPPB2EnvqgcvDtkv/bW8Sq764LWzbiTb6hmY9FLk9Drk9/Ypyu5GvUJZI2jHu55312AnMbK2ZbTKzTRXl84mH0xq5jSy0vIjp7uvcfcjdh/o0o9VPB7QNuY3p1shXKLskLRv389J6rCP0vPeiMP7yrXOS2KVX/ips+57B9C/mBSOzwrabdi1PYpsPLAtaSt/+g39MYjM/UUn7VU6/p5SklypHktijhy8O237z5fclsTOufyNse/GfpH+q7jke/1n9xM9WJ7FVd8bfMFQPHgzjHYzcHofc7tzcbuQM/GlJF5jZe8ysLOlTkh5uTreAaUVuIwtTPgN391Ez+5ykH0oqSbrP3Z9rWs+AaUJuIxeNfIUid39U0qNN6gvQMcht5ICZmACQKQZwAMjUlGdiTsUZNtdbMdmhtOr8JPb2V2th25qnEwjePjIQtj1+rC+9fyX+zOsbSCvto/vix7XRYBLD/PQ6YivF7031YDmJ9RyL+1WbnU7CKPWnM9gkqRb0q68/vb8kzT0jvVqgWov7MPeu9IoDf3pL2LYRG32DDvqBhmdiTgW5PYbcbm9ucwYOAJliAAeATDGAA0CmGMABIFMNXQfeKV79m7SgUj4WFyiOHAmm8FpcUIlWvCyV4wJSdTRditNnxgWVsG58OC0qqai+PBA87qy00CRJpZ5gKc9aXOfrnREsuVnQh30H0mnIg4PHwrYvfiZdJ+TCp+PHxYnIbZHb74IzcADIFAM4AGSKARwAMsUADgCZYgAHgExldRVKafWFYbzcl1aYjx6Nd0jpHxhJYiPH45ehGlW0CyrXFnwUnr0o3bNPkvpKaaU9mgY9Wo03mR0sp8fwelA5l6TK0WBqcjm+gqBaCZ6vYGJ6b1/6GJXgagVJOnf5/iQ2+sHfjR/3J7+In7DLkdtjyO3J4QwcADLFAA4AmWIAB4BMMYADQKYaKmKa2XZJhyRVJY26+1AzOlVk1/Xzw/js/nQn6qhwIkmVoJjhBW0Lp/sGzpn/VhLb8/NFYdvzHkwLQPba7jQ2Z3Z4/6OrFiSx0Vvizi5clPZr34H4caPXwaP1nSV5KZ123R+sGy1JM0ppIW7n1XEhbulPwnDbkdv/j9zu3NxuxlUov+/uaSkWyB+5jY7GVygAkKlGB3CX9B9m9gszW9uMDgEdgtxGx2v0K5QPuPsuM1sg6Udm9oK7Pza+QT3510pSv2Y2+HRA25Db6HgNnYG7+676/3slPSTpyqDNOncfcvehPsVf7gOdhtxGDqZ8Bm5mg5J63P1Q/fb1kv66aT0LHLliOIwPBDtGnzUzbhtV8KsFlfpoYfelZ78Ztn3rkXOS2PkP/Tps++qa5Uls+LzgDK4S9+ucDenVBqs+/1zY9uW/uiSJLbk0vbJBknbsnJfEembEU5Nn9KdV+YFyXKm3YFOB0fceDtt2AnL7ROR25+Z2I1+hLJT0kI1t7dEr6dvu/u9N6RUwvchtZGHKA7i7vyLpvU3sC9ARyG3kgssIASBTDOAAkKms1gNfuWhfGH/9YFqQOXNOvF5x5KWdC8P4wrPTx9i5JZ5CvPLvn0xiL3zl6rBtbVa65vGF56bFl/1H40vTPnXnxiR2z+/dELa98LbNSeyldReHbWfMPp7Ejh9Id0WXpAWLfpPE5pTj4trbI+ljrJh/IGx7uiK3x5Dbk8MZOABkigEcADLFAA4AmWIAB4BMMYADQKY69iqU3nOXJbEdh2aFbcu96aLqh0fitSl+Z/6OJLanYHH5lXPSavRZXw+byi/9rSRWm5X2S5IuWvl6EjteTd+KA/vjft29+/ok9hfX/jhs++Pj6WPM3Noftl3+kfRqgReG4ysTrlvwYhJ7YyTePfzVN9NpzHMGjoVty+9P58/Yk/8Tts0VuU1uv6PR3OYMHAAyxQAOAJliAAeATDGAA0CmOraIuedDS5PYvMG0QCJJx0bTw+jtSXeWlqTzBtIpy1tnxcWMJQNvJbH9g0vCtqX96dTk8htnhW0PP5Ie22h/+ll6TjXejbtUSeP/8txHwraLlE6DHl4UvzbDo31JbN68eG3jqwa3JbH1R64J20ZrUke7eUvSby5Kp1jPSw8ha+Q2uf1/fWgwtzkDB4BMMYADQKYYwAEgUwzgAJApBnAAyNQpr0Ixs/skfVzSXne/pB6bK+m7klZI2i7pZnePt7SeosE96Y7RvzkSLwJ/ZjB19aYlz4RtHz9wfhJ7dXNaOZek6z/6fBKrziqHbUv70ur5FR/cGrZ9ctl5SaynL62ezx6Mp+SuOf9nSezb268I2+qraWjBqnjzgMjxn84P4xuXp6/j++f8Kmz70psLklh0VYAkDS+IdytvBXL7ROT2mJxyeyJn4PdLOnlLjNslbXD3CyRtqP8M5OZ+kdvI2CkHcHd/TNLJewTdKGl9/fZ6STc1t1tA65HbyN1UJ/IsdPfd9dtvSIo33pNkZmslrZWkfsV/JgIdhNxGNhouYrq7S4qnVY39fp27D7n7UJ/iZTCBTkRuo9NN9Qx8j5ktdvfdZrZY0t5mdkqS+h/5eRJb/MjE7//ItR8M4+Ut25PYwKfj4sJTB9KCzI7Px9Nkl3w9nbL81CvxtN4/vfyJJBatN3xkNB4UHnhtKIn1fyOe2rz3s+9PYstmvhK23Xd0MIlV4mWb9V+Xprtx+zXvC9vOeeKZ+EECS/XqhNu2CLl9EnK7c3N7qmfgD0taU7+9RtIPmtMdYNqR28jGKQdwM/uOpKckrTKznWb2aUlfkvRhM3tZ0ofqPwNZIbeRu1N+heLutxT86rom9wVoK3IbuWMmJgBkigEcADLVsRs6yILquRde0ZUo/efmMJ5OYpYOr6yEbZ99fXES6+2Nq++v/FEpia38p7i/T/zqgiT28p+nO5X374+vIJj33EgSO3hu+vyS1PexdGrx9jfjqn6lkqbDsYXxlQkRm0RF/rRGbpPbTcIZOABkigEcADLFAA4AmWIAB4BMdW4RcxJFnagoZL3xmrxeSYsk/a/HbXvmH01iw4fjKcC/fdGvk9jOv5wTtq08vjyJldJuyePajbb/cRpbtSJ9fkna9Xbah9HR+IFLpbSIZSNN+IzvKTiQiapF5bmMkdvk9jsazG3OwAEgUwzgAJApBnAAyBQDOABkqnOLmJMRFIV8NJ6BFunfH8cPH08LQL3luOjwwu50c9M5s+KNW8/7xEtJrOZpsarH4mLX3qPpQsY73jwzbFurpZ/RtVo8C663dxLFtcmICjXRbERpcgW+0wG5TW6/C87AASBTDOAAkCkGcADIFAM4AGSKARwAMnXKq1DM7D5JH5e0190vqcfukvRnkt5ZkPcOd3+0VZ1stZ5KXB3uCabf9vTEbS2oqh880h+23XLknAk/bqRaDar6Bffv60ur5MPD5bBtb0+wHvQk+lWowfWvW4XcPilGbk/eNOf2RM7A75d0QxC/x90vq//LNsFxWrtf5DYydsoB3N0fk3SgDX0B2orcRu4a+Q78c2b2SzO7z8zifYwkmdlaM9tkZpsqOt7A0wFtQ24jC1MdwL8maaWkyyTtlvTloobuvs7dh9x9qE/xcpVAByG3kY0pTaV39z3v3Dazb0h6pGk9mgalgpOncjnd9LRajT/zPJguHN1fiqcRT2a6ca03bVu0DnL4/FFBp8iciU/b7gbkdorc7lxTOgM3s/FbWn9S0rPN6Q4wvcht5GQilxF+R9K1kuab2U5Jd0q61swuk+SStkv6TOu6CLQGuY3cnXIAd/dbgvC9LegL0FbkNnLHTEwAyBQDOABkqjs2dGhQLZ59G1bKKwULxkfTfcPpuwWqweL0KqjUR1Obi2bvRgvclwsW7h8N+jBzFtc354zcHtOtuc0ZOABkigEcADLFAA4AmWIAB4BMUcSUVBks2Mm6FKw3XEt385biZYEr1XgK8ESn+5Z744JMNSjeVAo2wo4KUFGhSIqnTBdNr0YeyO0x3Zrb+R8BAJymGMABIFMM4ACQKQZwAMgUAzgAZKp7r0Kxgs8mT6vftYJXoTSJXauj6ntRRTwqqk9mIfpoWnAp2GW8yMhIfMDRIv2TedxC0XsRvA+YIHK70OmW25yBA0CmGMABIFMM4ACQKQZwAMjURPbEXCbpnyUt1Ng+gevc/atmNlfSdyWt0NjegTe7+5ut62r7hTtnB1NypXiqbq2oRhJ8bMa7ecd3rwWFnqKiUjRduDaJ3cdnzhiJO9EFyO2TkNvZmcgZ+Kik29x9taSrJX3WzFZLul3SBne/QNKG+s9ATshtZO2UA7i773b3zfXbhyRtlbRE0o2S1tebrZd0U4v6CLQEuY3cTeo6cDNbIelySRslLXT33fVfvaGxP0Oj+6yVtFaS+jVzyh0FWoncRo4mXMQ0s1mSHpT0RXc/OP537u4a+w4x4e7r3H3I3Yf6NKOhzgKtQG4jVxMawM2sT2MJ/i13/349vMfMFtd/v1jS3tZ0EWgdchs5m8hVKCbpXklb3f3ucb96WNIaSV+q//+DlvRwqnzi02R7KnG8ElW0J7GbdrTgvBRX5aOdu4sWvS8FU5NHKvFbGfVrYCCuvkeP0T9zOGzbDcjtk5Db2ZnId+DXSLpV0hYze6Yeu0Njyf09M/u0pNck3dySHgKtQ24ja6ccwN39ccVr1EjSdc3tDtA+5DZyx0xMAMgUAzgAZIr1wKXCj7FozeRoh24pnqpbcPVZGC2aLhyJpgAX3Xt0NN09vKhttZoeQ1RUwjQjtyWR2xJn4ACQLQZwAMgUAzgAZIoBHAAyxQAOAJnq3qtQJqGWFrMlSdVaWrkuqqjP6Et3va4VLZAfxHonURGPpiYXzUaJpjzHVxXEJtMWnYfcLtYNuc0ZOABkigEcADLFAA4AmWIAB4BMUcSU5AWvQk9Q4yiabhwVgIqKJNHO29Wg+tNbios/0ZrLw8f6wrb9/emC0EVFpRFLX4jRoK+SJrX/jAUv5CSWtEYDyO0x3ZrbnIEDQKYYwAEgUwzgAJApBnAAyNQpB3AzW2ZmPzWz583sOTP7Qj1+l5ntMrNn6v8+1vruAs1DbiN3E7kKZVTSbe6+2cxmS/qFmf2o/rt73P3vWte9BkyiFFyLi9wF1fe4bVTRLpqoGy0kP6v/eFH3EsMjaYfL5YJdvoNjKKq+R8c2Uo3nYg++S/+Sx61NfEH/NiO3xz8suS0pr9yeyKbGuyXtrt8+ZGZbJS1pdceAViO3kbtJfQduZiskXS5pYz30OTP7pZndZ2ZnFdxnrZltMrNNFU38kxhoJ3IbOZrwAG5msyQ9KOmL7n5Q0tckrZR0mcbOYr4c3c/d17n7kLsP9U3qEnmgPcht5GpCA7iZ9Wkswb/l7t+XJHff4+5Vd69J+oakK1vXTaA1yG3k7JTfgZuZSbpX0lZ3v3tcfHH9O0RJ+qSkZ1vTxamxUlyg8NF0beORM+Oi0OwZ6Z/FxyrxS3bmwLEkNqM3fS5JGuxNd97usbQPB47F5ZRKMA15oDwcti2X0gJQpaB4UwmOLbp/tyC3T0Ru52ciV6FcI+lWSVvM7Jl67A5Jt5jZZRpbw327pM+0oH9AK5HbyNpErkJ5XPFVQ482vztA+5DbyB0zMQEgUwzgAJApBnAAyFTXbugQVeSLnLEtnhj82uK5Sax6sBy2PaTZQScKnjCKRx+lpYIHCHbjLhS1LViMv6cvrcovWnQwbHto4j1Ak5Hb79L2NMttzsABIFMM4ACQKQZwAMgUAzgAZMq8aBHgVjyZ2T5Jr9V/nC9pf9uevH04rulzrrufPR1PPC63c3idpqpbjy2H4wpzu60D+AlPbLbJ3Yem5clbiOM6vXXz69Stx5bzcfEVCgBkigEcADI1nQP4uml87lbiuE5v3fw6deuxZXtc0/YdOACgMXyFAgCZYgAHgEy1fQA3sxvM7EUz22Zmt7f7+ZupvmP5XjN7dlxsrpn9yMxerv8f7mjeycxsmZn91MyeN7PnzOwL9Xj2x9ZK3ZLb5HU+x9bWAdzMSpL+QdJHJa3W2NZVq9vZhya7X9INJ8Vul7TB3S+QtKH+c25GJd3m7qslXS3ps/X3qRuOrSW6LLfvF3mdhXafgV8paZu7v+LuI5IekHRjm/vQNO7+mKQDJ4VvlLS+fnu9pJva2admcPfd7r65fvuQpK2SlqgLjq2Fuia3yet8jq3dA/gSSTvG/byzHusmC8ftaP6GpIXT2ZlGmdkKSZdL2qguO7Ym6/bc7qr3vlvymiJmC/nYNZrZXqdpZrMkPSjpi+5+wur3uR8bpi73976b8rrdA/guScvG/by0Husme8xssSTV/987zf2ZEjPr01iSf8vdv18Pd8WxtUi353ZXvPfdltftHsCflnSBmb3HzMqSPiXp4Tb3odUelrSmfnuNpB9MY1+mxMxM0r2Strr73eN+lf2xtVC353b273035nXbZ2Ka2cckfUVSSdJ97v63be1AE5nZdyRdq7HlKPdIulPSv0r6nqTlGlte9GZ3P7kg1NHM7AOS/lvSFkm1evgOjX1fmPWxtVK35DZ5nc+xMZUeADJFERMAMsUADgCZYgAHgEwxgANAphjAASBTDOAAkCkGcADI1P8CGfYzn+xo6woAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "2.669391111109774e-35" + ] + }, + "execution_count": 146, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "AMPLITUDE_ENCODING_N_QUBITS = 10\n", + "IMAGE_SIZE = 28\n", + "\n", + "def encode(image):\n", + " \n", + " image_vector = np.resize(image, IMAGE_SIZE * IMAGE_SIZE)\n", + " \n", + " qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS)\n", + " \n", + " N = IMAGE_SIZE * IMAGE_SIZE\n", + " \n", + " zero_padding = 2 ** AMPLITUDE_ENCODING_N_QUBITS - N\n", + " \n", + " print(image_vector.shape)\n", + " print(zero_padding)\n", + " \n", + " image_vector = np.concatenate((image_vector, np.zeros(zero_padding)), axis=0)\n", + " \n", + " print(image_vector.shape)\n", + " \n", + " normalization_factor = np.sqrt(np.sum(image_vector**2)) \n", + " #Else we divide each value between the sum value above\n", + " image_vector /= normalization_factor\n", + "\n", + " ###########\n", + " qc.initialize(image_vector)\n", + " ##########\n", + " \n", + " for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2):\n", + " qc = qc.decompose()\n", + " \n", + " return qc, normalization_factor\n", + "\n", + "def decode(histogram, normalizaton_factor):\n", + " histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS)\n", + " for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS):\n", + " histogram_array[i] = histogram.get(i, 0)\n", + " root = np.sqrt(histogram_array)\n", + " \n", + " root = root * normalization_factor\n", + " \n", + " N = IMAGE_SIZE * IMAGE_SIZE\n", + " \n", + " image_rec = root[:N]\n", + " \n", + " image_rec = image_rec.reshape(28, 28)\n", + " \n", + " return image_rec\n", + "\n", + "\n", + "img = images[0]\n", + "\n", + "img = np.array(img)\n", + " \n", + "qc, normalization_factor = encode(img) \n", + "\n", + "histogram = simulate(qc)\n", + "\n", + "image_rec = decode(histogram, normalization_factor)\n", + "\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "\n", + "ax1.imshow(img)\n", + "\n", + "ax2.imshow(image_rec)\n", + "\n", + "plt.show()\n", + "\n", + "image_mse(img, image_rec)" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.460739251294167e-05" + ] + }, + "execution_count": 148, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "0.99 ** (1022)" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({1: 1033, 2: 1022})" + ] + }, + "execution_count": 147, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "count_gates(qc)" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2000it [2:52:47, 5.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.305203764154009e-111\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "def run_part1(images, image_index, n_qubits=8):\n", + " #encode image into a circuit\n", + " circuit, decoder_params = encode_amplitude(images, image_index, n_qubits=n_qubits)\n", + "\n", + " #simulate circuit\n", + " histogram = simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re = decode_amplitude(histogram, **decoder_params)\n", + "\n", + " return circuit,image_re\n", + "\n", + "#how we grade your submission\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for i, data in tqdm.tqdm(enumerate(images)):\n", + " #encode image into circuit\n", + " circuit, image_re =run_part1(images, i, n_qubits=8)\n", + " \n", + " #count the number of 2qubit gates used\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #calculate mse\n", + " #print(images[i].shape)\n", + " #print(image_re.shape)\n", + " mse+=image_mse(images[i],image_re)\n", + " \n", + "#fidelity of reconstruction\n", + "f=1-mse\n", + "gatecount=gatecount/n\n", + "\n", + "#score for part1 \n", + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
label
0True
1True
2True
3True
4True
......
495True
496True
497True
498True
499True
\n", + "

500 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " label\n", + "0 True\n", + "1 True\n", + "2 True\n", + "3 True\n", + "4 True\n", + ".. ...\n", + "495 True\n", + "496 True\n", + "497 True\n", + "498 True\n", + "499 True\n", + "\n", + "[500 rows x 1 columns]" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "pd.DataFrame(labels, columns=[\"label\"]).query(\"label==True\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Shirt vs no shirt\n", + "no shirt pueden ser distintos\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 10" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({2: 254, 1: 135})\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[110], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m qc_decomposed \u001b[38;5;241m=\u001b[39m qc\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mcount_gates\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqc_decomposed\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[108], line 52\u001b[0m, in \u001b[0;36mcount_gates\u001b[0;34m(circuit)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28mprint\u001b[39m(counter)\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m20\u001b[39m):\n\u001b[0;32m---> 52\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m counter\u001b[38;5;241m.\u001b[39mget(i,\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m counter\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", + "count_gates(qc_decomposed)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys([0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255])" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "histogram.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + }, + "vscode": { + "interpreter": { + "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/part1_with_pca.ipynb b/part1_with_pca.ipynb new file mode 100644 index 0000000..12f0618 --- /dev/null +++ b/part1_with_pca.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(3,20):\n", + " assert counter.get(i,0)==0\n", + " \n", + " \n", + " return counter\n", + "\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(image1, image2)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.000000\n" + ] + } + ], + "source": [ + "a = 1e-9\n", + "print('{:f}'.format(a))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#load the mock data (for testing only)\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", + " {'image': [[0, 0], [0, 0]], 'category': 1}]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#load the actual hackthon data (fashion-mnist)\n", + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')\n", + "#you can visualize it\n", + "plt.imshow(images[1100])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#submission to part 1, you should make this into a .py file\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "# Functions 'encode' and 'decode' are dummy.\n", + "def encode(image):\n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " if image[0][0]==0:\n", + " circuit.rx(np.pi,0)\n", + " return circuit\n", + "\n", + "def decode(histogram):\n", + " if 1 in histogram.keys():\n", + " image=[[0,0],[0,0]]\n", + " else:\n", + " image=[[1,1],[1,1]]\n", + " return image\n", + "\n", + "def run_part1(image):\n", + " #encode image into a circuit\n", + " circuit = encode(image)\n", + "\n", + " #simulate circuit\n", + " histogram = simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re = decode(histogram)\n", + "\n", + " return circuit,image_re" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0\n" + ] + } + ], + "source": [ + "#how we grade your submission\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for data in dataset:\n", + " #encode image into circuit\n", + " circuit,image_re=run_part1(data['image'])\n", + " \n", + " #count the number of 2qubit gates used\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #calculate mse\n", + " mse+=image_mse(data['image'],image_re)\n", + " \n", + "#fidelity of reconstruction\n", + "f=1-mse\n", + "gatecount=gatecount/n\n", + "\n", + "#score for part1 \n", + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def encode(image):\n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " circuit.h([0, 1, 2])\n", + " return circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", + " {'image': [[0, 0], [0, 0]], 'category': 1}]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0.12499999999999994,\n", + " 1: 0.12499999999999994,\n", + " 2: 0.12499999999999994,\n", + " 3: 0.12499999999999994,\n", + " 4: 0.12499999999999994,\n", + " 5: 0.12499999999999994,\n", + " 6: 0.12499999999999994,\n", + " 7: 0.12499999999999994}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulate(encode(dataset[0]['image']))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: 0.12499999999999994,\n", + " 1: 0.12499999999999994,\n", + " 2: 0.12499999999999994,\n", + " 3: 0.12499999999999994,\n", + " 4: 0.12499999999999994,\n", + " 5: 0.12499999999999994,\n", + " 6: 0.12499999999999994,\n", + " 7: 0.12499999999999994}" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "simulate(encode(dataset[1]['image']))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'desired_state' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdesired_state\u001b[49m\n", + "\u001b[0;31mNameError\u001b[0m: name 'desired_state' is not defined" + ] + } + ], + "source": [ + "desired_state" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "784" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "28 * 28" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Raw Image data\n", + "[0. 0. 0. 0. 0.]\n", + "Image PCA\n", + "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", + " 2.54252086e-03]\n", + "Image PCA min_ removed\n", + "[0. 0.00930002 0.02270273 0.00663033 0.01194021]\n", + "(28, 28)\n", + "(256,)\n", + "1.0\n", + "PCA normalized\n", + "[0. 0.06119 0.14939 0.04363 0.07857]\n", + "Squared PCA\n", + "[0. 0.00374 0.02232 0.0019 0.00617]\n", + "###########Histogram\n", + "[0. 0.00374478 0.0223159 0.00190339 0.0061728 ]\n", + "Histogram root\n", + "[0. 0.06119461 0.14938508 0.04362791 0.07856718]\n", + "Denormalized \n", + "[0. 0.00930002 0.02270273 0.00663033 0.01194021]\n", + "Sumar mínimo\n", + "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", + " 2.54252086e-03]\n", + "(256,)\n", + "Reconstructed Image PCA\n", + "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", + " 2.54252086e-03]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "from sklearn.decomposition import PCA\n", + "\n", + "def encode_amplitude(images, image_index, n_qubits, debug=False):\n", + " N_images = len(images)\n", + " # We have 28x28 images as input\n", + " # - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\n", + " # 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \n", + " # into n_qubits (parametrized)\n", + " \n", + " \n", + " # [apply PCA]\n", + " # Create an instance of PCA\n", + " pca = PCA(n_components=2**n_qubits)\n", + "\n", + " # Fit PCA on your 784-dimensional data\n", + " data = images.reshape(N_images, 28 * 28)\n", + " pca.fit(data)\n", + "\n", + " # Apply dimensionality reduction on your data\n", + " data_pca = pca.transform(data)\n", + "\n", + " image = images[image_index]\n", + " \n", + " if debug:\n", + " \n", + " print(\"Raw Image data\")\n", + " print(data[image_index][:5])\n", + " \n", + " image_pca = data_pca[image_index]\n", + " \n", + " min_ = image_pca.min()\n", + " \n", + " if debug:\n", + " print(\"Image PCA\")\n", + " print(image_pca[:5])\n", + "\n", + " \n", + " image_pca = image_pca - min_\n", + " \n", + " if debug:\n", + " print(\"Image PCA min_ removed\")\n", + " print(image_pca[:5])\n", + " \n", + " # [normalize]\n", + " def normalize(row):\n", + " #We calculate the squareroot of the sum of the square values of the row\n", + " normalization_factor = np.sqrt(np.sum(row**2)) \n", + " if normalization_factor == 0.:\n", + " #If the sum is zero we return a 0\n", + " return 0.0\n", + " #Else we divide each value between the sum value above\n", + " row = row / normalization_factor\n", + " return row, normalization_factor\n", + " \n", + " image_pca_normalized, normalization_factor = normalize(image_pca)\n", + " \n", + " if debug:\n", + " print(image.shape)\n", + "\n", + " print(image_pca_normalized.shape)\n", + "\n", + " print(np.sum(image_pca_normalized**2))\n", + " \n", + " desired_state = image_pca_normalized\n", + " \n", + " #print(np.round(desired_state, 3))\n", + " if debug:\n", + " print(\"PCA normalized\")\n", + " print(np.round(image_pca_normalized, 5)[:5])\n", + "\n", + " print(\"Squared PCA\")\n", + " print(np.round(desired_state ** 2, 5)[:5])\n", + " \n", + " ##########\n", + " # Amplitude Encoding\n", + " qc = QuantumCircuit(n_qubits)\n", + " qc.initialize(desired_state)\n", + " qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", + "\n", + " ##########\n", + " \n", + " decoder_params = dict(\n", + " pca=pca,\n", + " min_=min_,\n", + " normalization_factor=normalization_factor,\n", + " n_qubits=n_qubits,\n", + " image=image\n", + " )\n", + " \n", + " return qc_decomposed, decoder_params\n", + "\n", + "def decode_amplitude(histogram, normalization_factor, min_, pca, n_qubits, image, debug=False):\n", + " \n", + " histogram_array = np.zeros(2 ** n_qubits)\n", + " \n", + " for i in range(2 ** n_qubits):\n", + " histogram_array[i] = histogram.get(i, 0)\n", + " \n", + " if debug:\n", + " print(\"###########Histogram\")\n", + "\n", + " print(histogram_array[:5])\n", + " \n", + " root = np.sqrt(histogram_array)\n", + " \n", + " if debug:\n", + " print(\"Histogram root\")\n", + " print(root[:5])\n", + " \n", + " root = root * normalization_factor\n", + " \n", + " if debug:\n", + " print(\"Denormalized \")\n", + " print(root[:5])\n", + " \n", + " root = root + min_\n", + " if debug:\n", + " print(\"Sumar mínimo\")\n", + " print(root[:5])\n", + " \n", + " print(root.shape)\n", + " \n", + " print(\"Reconstructed Image PCA\")\n", + " print(root[:5])\n", + " \n", + " reconstruction = pca.inverse_transform([root])\n", + " \n", + " #print(reconstruction)\n", + " \n", + " reconstructed_image = reconstruction[0].reshape(28, 28)\n", + " \n", + " if debug:\n", + " \n", + " fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "\n", + " ax1.imshow(image)\n", + " \n", + " ax2.imshow(reconstructed_image)\n", + " \n", + " plt.show()\n", + " \n", + " return reconstructed_image\n", + " \n", + "qc, decoder_params = encode_amplitude(images, 250, 8, debug=True) \n", + "\n", + "histogram = simulate(qc)\n", + "\n", + "\n", + "image = decode_amplitude(histogram, **decoder_params, debug=True)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({1: 135, 2: 254})" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "count_gates(qc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "1982it [2:45:41, 25.61s/it]" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "def run_part1(images, image_index, n_qubits=8):\n", + " #encode image into a circuit\n", + " circuit, decoder_params = encode_amplitude(images, image_index, n_qubits=n_qubits)\n", + "\n", + " #simulate circuit\n", + " histogram = simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re = decode_amplitude(histogram, **decoder_params)\n", + "\n", + " return circuit,image_re\n", + "\n", + "#how we grade your submission\n", + "\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "for i, data in tqdm.tqdm(enumerate(images)):\n", + " #encode image into circuit\n", + " circuit, image_re =run_part1(images, i, n_qubits=8)\n", + " \n", + " #count the number of 2qubit gates used\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #calculate mse\n", + " #print(images[i].shape)\n", + " #print(image_re.shape)\n", + " mse+=image_mse(images[i],image_re)\n", + " \n", + "#fidelity of reconstruction\n", + "f=1-mse\n", + "gatecount=gatecount/n\n", + "\n", + "#score for part1 \n", + "print(f*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
label
0True
1True
2True
3True
4True
......
495True
496True
497True
498True
499True
\n", + "

500 rows × 1 columns

\n", + "
" + ], + "text/plain": [ + " label\n", + "0 True\n", + "1 True\n", + "2 True\n", + "3 True\n", + "4 True\n", + ".. ...\n", + "495 True\n", + "496 True\n", + "497 True\n", + "498 True\n", + "499 True\n", + "\n", + "[500 rows x 1 columns]" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "pd.DataFrame(labels, columns=[\"label\"]).query(\"label==True\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Shirt vs no shirt\n", + "no shirt pueden ser distintos\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1024" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 10" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
                                                                              »\n",
+       "q_0: ─|0>─────────────────────────────────────────────────────────────────────»\n",
+       "                                                                              »\n",
+       "q_1: ─|0>─────────────────────────────────────────────────────────────────────»\n",
+       "                                                                              »\n",
+       "q_2: ─|0>─────────────────────────────────────────────────────────────────────»\n",
+       "                                                                              »\n",
+       "q_3: ─|0>─────────────────────────────────────────────────────────────────────»\n",
+       "                                                                              »\n",
+       "q_4: ─|0>─────────────────────────────────────────────────────────────────────»\n",
+       "                                                                              »\n",
+       "q_5: ─|0>─────────────────────────────────────────────────────────────────────»\n",
+       "          ┌───────────────────────┐┌───┐┌───────────────────────────────┐┌───┐»\n",
+       "q_6: ─|0>─┤ multiplex1_reverse_dg ├┤ X ├┤ multiplex1_reverse_reverse_dg ├┤ X ├»\n",
+       "          └─────┬────────────┬────┘└─┬─┘└───────────────────────────────┘└─┬─┘»\n",
+       "q_7: ─|0>───────┤ Ry(1.5738) ├───────■─────────────────────────────────────■──»\n",
+       "                └────────────┘                                                »\n",
+       "«                                                                           »\n",
+       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_2: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_3: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_4: ──────────────────────────────────────────────────────────────────────»\n",
+       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
+       "«q_5: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
+       "«     │  multiplex2_reverse_dg │└─┬─┘│  multiplex2_reverse_reverse_dg │└─┬─┘»\n",
+       "«q_6: ┤1                       ├──┼──┤1                               ├──┼──»\n",
+       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
+       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
+       "«                                                                           »\n",
+       "«                                                                           »\n",
+       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_2: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_3: ──────────────────────────────────────────────────────────────────────»\n",
+       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
+       "«q_4: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
+       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
+       "«q_5: ┤1 multiplex3_reverse_dg ├──┼──┤1 multiplex3_reverse_reverse_dg ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_6: ┤2                       ├──┼──┤2                               ├──┼──»\n",
+       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
+       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
+       "«                                                                           »\n",
+       "«                                                                           »\n",
+       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_2: ──────────────────────────────────────────────────────────────────────»\n",
+       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
+       "«q_3: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
+       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
+       "«q_4: ┤1                       ├──┼──┤1                               ├──┼──»\n",
+       "«     │  multiplex4_reverse_dg │  │  │  multiplex4_reverse_reverse_dg │  │  »\n",
+       "«q_5: ┤2                       ├──┼──┤2                               ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_6: ┤3                       ├──┼──┤3                               ├──┼──»\n",
+       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
+       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
+       "«                                                                           »\n",
+       "«                                                                           »\n",
+       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
+       "«                                                                           »\n",
+       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
+       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
+       "«q_2: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
+       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
+       "«q_3: ┤1                       ├──┼──┤1                               ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_4: ┤2 multiplex5_reverse_dg ├──┼──┤2 multiplex5_reverse_reverse_dg ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_5: ┤3                       ├──┼──┤3                               ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_6: ┤4                       ├──┼──┤4                               ├──┼──»\n",
+       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
+       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
+       "«                                                                           »\n",
+       "«                                                                           »\n",
+       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
+       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
+       "«q_1: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
+       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
+       "«q_2: ┤1                       ├──┼──┤1                               ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_3: ┤2                       ├──┼──┤2                               ├──┼──»\n",
+       "«     │  multiplex6_reverse_dg │  │  │  multiplex6_reverse_reverse_dg │  │  »\n",
+       "«q_4: ┤3                       ├──┼──┤3                               ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_5: ┤4                       ├──┼──┤4                               ├──┼──»\n",
+       "«     │                        │  │  │                                │  │  »\n",
+       "«q_6: ┤5                       ├──┼──┤5                               ├──┼──»\n",
+       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
+       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
+       "«                                                                           »\n",
+       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐\n",
+       "«q_0: ┤0                       ├┤ X ├┤0                               ├┤ X ├\n",
+       "«     │                        │└─┬─┘│                                │└─┬─┘\n",
+       "«q_1: ┤1                       ├──┼──┤1                               ├──┼──\n",
+       "«     │                        │  │  │                                │  │  \n",
+       "«q_2: ┤2                       ├──┼──┤2                               ├──┼──\n",
+       "«     │                        │  │  │                                │  │  \n",
+       "«q_3: ┤3 multiplex7_reverse_dg ├──┼──┤3 multiplex7_reverse_reverse_dg ├──┼──\n",
+       "«     │                        │  │  │                                │  │  \n",
+       "«q_4: ┤4                       ├──┼──┤4                               ├──┼──\n",
+       "«     │                        │  │  │                                │  │  \n",
+       "«q_5: ┤5                       ├──┼──┤5                               ├──┼──\n",
+       "«     │                        │  │  │                                │  │  \n",
+       "«q_6: ┤6                       ├──┼──┤6                               ├──┼──\n",
+       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  \n",
+       "«q_7: ────────────────────────────■──────────────────────────────────────■──\n",
+       "«
" + ], + "text/plain": [ + " »\n", + "q_0: ─|0>─────────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_1: ─|0>─────────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_2: ─|0>─────────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_3: ─|0>─────────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_4: ─|0>─────────────────────────────────────────────────────────────────────»\n", + " »\n", + "q_5: ─|0>─────────────────────────────────────────────────────────────────────»\n", + " ┌───────────────────────┐┌───┐┌───────────────────────────────┐┌───┐»\n", + "q_6: ─|0>─┤ multiplex1_reverse_dg ├┤ X ├┤ multiplex1_reverse_reverse_dg ├┤ X ├»\n", + " └─────┬────────────┬────┘└─┬─┘└───────────────────────────────┘└─┬─┘»\n", + "q_7: ─|0>───────┤ Ry(1.5738) ├───────■─────────────────────────────────────■──»\n", + " └────────────┘ »\n", + "« »\n", + "«q_0: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_1: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_2: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_3: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_4: ──────────────────────────────────────────────────────────────────────»\n", + "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", + "«q_5: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", + "« │ multiplex2_reverse_dg │└─┬─┘│ multiplex2_reverse_reverse_dg │└─┬─┘»\n", + "«q_6: ┤1 ├──┼──┤1 ├──┼──»\n", + "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", + "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", + "« »\n", + "« »\n", + "«q_0: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_1: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_2: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_3: ──────────────────────────────────────────────────────────────────────»\n", + "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", + "«q_4: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", + "« │ │└─┬─┘│ │└─┬─┘»\n", + "«q_5: ┤1 multiplex3_reverse_dg ├──┼──┤1 multiplex3_reverse_reverse_dg ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_6: ┤2 ├──┼──┤2 ├──┼──»\n", + "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", + "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", + "« »\n", + "« »\n", + "«q_0: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_1: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_2: ──────────────────────────────────────────────────────────────────────»\n", + "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", + "«q_3: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", + "« │ │└─┬─┘│ │└─┬─┘»\n", + "«q_4: ┤1 ├──┼──┤1 ├──┼──»\n", + "« │ multiplex4_reverse_dg │ │ │ multiplex4_reverse_reverse_dg │ │ »\n", + "«q_5: ┤2 ├──┼──┤2 ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_6: ┤3 ├──┼──┤3 ├──┼──»\n", + "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", + "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", + "« »\n", + "« »\n", + "«q_0: ──────────────────────────────────────────────────────────────────────»\n", + "« »\n", + "«q_1: ──────────────────────────────────────────────────────────────────────»\n", + "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", + "«q_2: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", + "« │ │└─┬─┘│ │└─┬─┘»\n", + "«q_3: ┤1 ├──┼──┤1 ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_4: ┤2 multiplex5_reverse_dg ├──┼──┤2 multiplex5_reverse_reverse_dg ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_5: ┤3 ├──┼──┤3 ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_6: ┤4 ├──┼──┤4 ├──┼──»\n", + "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", + "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", + "« »\n", + "« »\n", + "«q_0: ──────────────────────────────────────────────────────────────────────»\n", + "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", + "«q_1: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", + "« │ │└─┬─┘│ │└─┬─┘»\n", + "«q_2: ┤1 ├──┼──┤1 ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_3: ┤2 ├──┼──┤2 ├──┼──»\n", + "« │ multiplex6_reverse_dg │ │ │ multiplex6_reverse_reverse_dg │ │ »\n", + "«q_4: ┤3 ├──┼──┤3 ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_5: ┤4 ├──┼──┤4 ├──┼──»\n", + "« │ │ │ │ │ │ »\n", + "«q_6: ┤5 ├──┼──┤5 ├──┼──»\n", + "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", + "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", + "« »\n", + "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐\n", + "«q_0: ┤0 ├┤ X ├┤0 ├┤ X ├\n", + "« │ │└─┬─┘│ │└─┬─┘\n", + "«q_1: ┤1 ├──┼──┤1 ├──┼──\n", + "« │ │ │ │ │ │ \n", + "«q_2: ┤2 ├──┼──┤2 ├──┼──\n", + "« │ │ │ │ │ │ \n", + "«q_3: ┤3 multiplex7_reverse_dg ├──┼──┤3 multiplex7_reverse_reverse_dg ├──┼──\n", + "« │ │ │ │ │ │ \n", + "«q_4: ┤4 ├──┼──┤4 ├──┼──\n", + "« │ │ │ │ │ │ \n", + "«q_5: ┤5 ├──┼──┤5 ├──┼──\n", + "« │ │ │ │ │ │ \n", + "«q_6: ┤6 ├──┼──┤6 ├──┼──\n", + "« └────────────────────────┘ │ └────────────────────────────────┘ │ \n", + "«q_7: ────────────────────────────■──────────────────────────────────────■──\n", + "« " + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc.decompose().decompose().decompose().decompose().draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({2: 254, 1: 135})\n" + ] + }, + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[110], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m qc_decomposed \u001b[38;5;241m=\u001b[39m qc\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mcount_gates\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqc_decomposed\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[108], line 52\u001b[0m, in \u001b[0;36mcount_gates\u001b[0;34m(circuit)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28mprint\u001b[39m(counter)\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m20\u001b[39m):\n\u001b[0;32m---> 52\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m counter\u001b[38;5;241m.\u001b[39mget(i,\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m counter\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] + } + ], + "source": [ + "qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", + "count_gates(qc_decomposed)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_keys([0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255])" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "histogram.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + }, + "vscode": { + "interpreter": { + "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/part2_with_pca.ipynb b/part2_with_pca.ipynb new file mode 100644 index 0000000..bd75312 --- /dev/null +++ b/part2_with_pca.ipynb @@ -0,0 +1,12946 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8 # assert sum to 1.0\n", + " positive=0\n", + " # 0 - suma \n", + " # 1 - no suma\n", + " # 10 suma\n", + " # 11 no suma\n", + " # 100 suma\n", + " # 101 no suma\n", + " # suma la probabilidad de todos los bitstrings pares,\n", + " # en otras palabras, la probabilidad de que el qubit 0 sea 0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(3,20):\n", + " assert counter[i]==0\n", + " \n", + " return counter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#load the mock data (for testing only)\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQiElEQVR4nO3dXYyc9XXH8d/Z2Rd712vjxcY2xuUtkBZFwjRb2iqkJUJBhBuDFNFQKSIq7eYiSEHKRRGVGm4qoaokygWK5AQUp6KkqRKE06AG6iZCpK1jg1wwuAXXsbFdv2Js/MLuzu6eXuw4Wpt9zrOel52xz/cjrWb2OfPMHI/98zMz//k/f3N3Abj0dbW7AQDzg7ADSRB2IAnCDiRB2IEkuufzwXqtzxdoYD4f8qJgvb1hfWx5T1jv7q8W1qpj8b42EZZlU3F9qi8ezVk6cKaw9sH4gnDf7gMWP/jpD+N6QqM6rXEfm/WJayjsZnaXpG9Jqkj6rrs/Ht1+gQb0+3ZHIw95Sepe/Vth/Z2R1WF95ScPFtb27bwi3LfvSCWsd42HZZ25tvg/Gkm6b3hLYe3Fd3873PeKv4n/o9Kv3ojrCW32TYW1ul/Gm1lF0pOSPifpJkn3m9lN9d4fgNZq5D37rZJ2uvsudx+X9ANJ65rTFoBmayTsqyXtnfH7vtq2c5jZiJltNbOtVY018HAAGtHyT+Pdfb27D7v7cI/6Wv1wAAo0Evb9ktbM+P2q2jYAHaiRsG+RdIOZXWtmvZK+IGljc9oC0Gx1D725+4SZPSTpZ5oeenva3d9sWmeJ7PzzeGjt+T99Iqz/+4fXFdbWXP9euO+dwRj9XGw83R/Wd46tLKz95Jbvhvt+euThsH7jr8IyztPQOLu7vyDphSb1AqCF+LoskARhB5Ig7EAShB1IgrADSRB2IIl5nc+O2a38z8mwvuXz8RTYd8cvL6wdqi4J9335VDyXvlIyob2vZEJ81Yun0G4evTLct39X3BsuDEd2IAnCDiRB2IEkCDuQBGEHkiDsQBIMvXWAhYfiUyJXPf5rioa/Biuj4b79ldaeKuzERPEU2GhYTpK6Tze7m9w4sgNJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEoyzd4CuE8XLGkvS3QM7w/qTx/6wsFY2zl421t1j8fTbsvqZqeJpqqen4hWCBg6WrBeNC8KRHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYJy9A5y4eVlY3zJ2RVg/NVk8Xj02NVRXT2dNuTW0/7HqQGHtqt73w30PfCYeZx/8x7paSquhsJvZbkknJU1KmnD34WY0BaD5mnFk/4y7H23C/QBoId6zA0k0GnaX9KKZvWpmI7PdwMxGzGyrmW2tqrXnOwNQrNGX8be5+34zu0LSS2b23+7+8swbuPt6SeslabENeYOPB6BODR3Z3X1/7fKwpOck3dqMpgA0X91hN7MBMxs8e13SnZK2N6sxAM3VyMv4FZKeM7Oz9/MP7v4vTekqmwePhOXV3cfDel9X8Xnjy+abl42jL+s9FdbfHYvH8Qe7i+fTj5acD//jN+4P67wnvDB1h93dd0m6uYm9AGghht6AJAg7kARhB5Ig7EAShB1IgimuHeCyL8VrEx//5cKwvqCrWlg7NRGfrvm6hfGw347TV4b17q54aK+RYcG3d1wV1m9QPDSHc3FkB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkGGfvABMHD4X1F47Hkws/vfjtwtpPj8X7Hq0OhvWrF8bnEj04tiSsR1Nopzw+1qz6RVjGBeLIDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJMM5+EThe7Q/ra7qPFdZ+b/Gvw33fOhPPVy+zqDte0qs6VSmsjU71hPsO7opPY82ppC8MR3YgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSIJx9ovAK3uuC+t/smxzYe39iYFw37UD74b1srHwMtVgWeajE4vCfbs+LD4fviTFZ53H+UqP7Gb2tJkdNrPtM7YNmdlLZvZO7XJpa9sE0Ki5vIz/nqS7ztv2iKRN7n6DpE213wF0sNKwu/vLks7/PuY6SRtq1zdIuqe5bQFotnrfs69w9wO16wclrSi6oZmNSBqRpAWKv+MNoHUa/jTe3V3BnAR3X+/uw+4+3KN4kUEArVNv2A+Z2SpJql0ebl5LAFqh3rBvlPRA7foDkp5vTjsAWqX0PbuZPSvpdknLzGyfpK9LelzSD83sQUl7JN3Xyiazq47Gf02jXjwWXvXi+eSSNFly7vYyZWusR2vHX9nzfrjv5oVr62kJBUrD7u73F5TuaHIvAFqIr8sCSRB2IAnCDiRB2IEkCDuQBFNcLwKf/Z0dYf3IxOLCWtnQ26FqvOTylb3x8NgCi6eh7q0OFdaG+uJTRR/663hY74p1YRnn4cgOJEHYgSQIO5AEYQeSIOxAEoQdSIKwA0kwzn4RuG7h0bB+YrL4dF9Lu0+H+/Z3jYf1Lk2F9WgcXZIqwcLKe6uXh/v+2cf+I6z/tHt5WPeJibCeDUd2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiCcfYOMPXHt4T1/q5/C+snJxcU1nq64rHmd8fise6KxePsSyofhvWh7uI560cmBsN9y05TffLeT4b1Rf9UvJR1RhzZgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJxtk7wJGbF4b1vmDZY0k6MVm8/5nJvnDfsnH0svnw1/TGc+2PB3Pty3orG2c//rH4nPiLwmo+pUd2M3vazA6b2fYZ2x4zs/1mtq32c3dr2wTQqLm8jP+epLtm2f5Nd19b+3mhuW0BaLbSsLv7y5KOzUMvAFqokQ/oHjKz12sv85cW3cjMRsxsq5ltrWqsgYcD0Ih6w/5tSddLWivpgKQnim7o7uvdfdjdh3sUfyADoHXqCru7H3L3SXefkvQdSbc2ty0AzVZX2M1s1Yxf75W0vei2ADpD6Ti7mT0r6XZJy8xsn6SvS7rdzNZKckm7JX25dS1e+s6sLD63uiQNdMWfdYxO9RTWBiujde8rSZdVzoT1w8Ha8JI05VZcU3FNkj6xcG9YnxiInzecqzTs7n7/LJufakEvAFqIr8sCSRB2IAnCDiRB2IEkCDuQBFNcO0B1KJ7KubZvX1jfM7assLaoZOjtqt542kM0RVWSTkzE9SXdxUN31al4iuqxyXiS6vjKeOovzsWRHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYJy9A3QvHg/rvzhzY933vabnvbC+Z3x5WB/1+J9INI4uSVUvHkvvr8R/7n3jQ2G9f2m8XDTOxZEdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5JgnL0DLB6Mx6pX97wf1pd3f1BY2zm2Mtx3suR0zksq8Vj2qckFYT3SpfhU0KdKlnRe3B/P1ce5OLIDSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBKMs3eASlc83ry8UjyOLkmvnP543Y+9pGRJ5rGSJZ2j+eqS1GPF58Sv2FS8b1d8Pv1FvfF8eJyr9MhuZmvM7Odm9paZvWlmX61tHzKzl8zsndrl0ta3C6Bec3kZPyHpa+5+k6Q/kPQVM7tJ0iOSNrn7DZI21X4H0KFKw+7uB9z9tdr1k5J2SFotaZ2kDbWbbZB0T4t6BNAEF/Se3cyukXSLpM2SVrj7gVrpoKQVBfuMSBqRpAWK1wUD0Dpz/jTezBZJ+pGkh939nE+M3N2l2Wc1uPt6dx929+EexRMbALTOnMJuZj2aDvoz7v7j2uZDZraqVl8l6XBrWgTQDKUv483MJD0laYe7f2NGaaOkByQ9Xrt8viUdJvDheDy8tcAmwvqkF/+f3dMV79tl8bDfmcnesB4NrU3ff/Hw2mTJsF6ZJb3x9NuTDd37pWcu79k/JemLkt4ws221bY9qOuQ/NLMHJe2RdF9LOgTQFKVhd/dXpMIzHNzR3HYAtApflwWSIOxAEoQdSIKwA0kQdiAJprh2gPHx+K/hsq76p3KWjdGXTWHtL3nssiWd+4Jx+LLpsaMlvfWWTIHFuTiyA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EASjLN3gPEz8Xjy7oklYX2wUrx0cdmSzI0qG4eP5ruXjbNPeWt7z4YjO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kwTh7B6gcjc/NPthVPI4uST3BnPW+kvPClykbC68oXnb5xOTCwtqCrmpdPZ010B2P8b/X0L1fejiyA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EASc1mffY2k70taIcklrXf3b5nZY5L+QtKR2k0fdfcXWtXopaw7Xma8VDU4d3uP4vPGj3rZ2vDxWPjy7ngV9NFq8f2fmOoP9x2biv95Rmu/46Pm8qWaCUlfc/fXzGxQ0qtm9lKt9k13/7vWtQegWeayPvsBSQdq10+a2Q5Jq1vdGIDmuqD37GZ2jaRbJG2ubXrIzF43s6fNbGnBPiNmttXMtlY11li3AOo257Cb2SJJP5L0sLt/IOnbkq6XtFbTR/4nZtvP3de7+7C7D/eor/GOAdRlTmE3sx5NB/0Zd/+xJLn7IXefdPcpSd+RdGvr2gTQqNKwm5lJekrSDnf/xoztq2bc7F5J25vfHoBmmcun8Z+S9EVJb5jZttq2RyXdb2ZrNT0ct1vSl1vQXwqLd8X13pJppFf3HimsLS6ZHnv7wvi+902cCusrKsVTWCXp/akDhbXdE/HU3r3Vy8P6Px+7OazjXHP5NP4VadaTjzOmDlxE+AYdkARhB5Ig7EAShB1IgrADSRB2IAlOJd0Blv/s12F92yNrwvqTO28vrHU/MxTuO/TKvrDuC0u+4lyJjxf2wel4/wZM7P+/lt33pYgjO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kYe6NLel7QQ9mdkTSnhmblkk6Om8NXJhO7a1T+5LorV7N7O1qd18+W2Few/6RBzfb6u7DbWsg0Km9dWpfEr3Va75642U8kARhB5Jod9jXt/nxI53aW6f2JdFbvealt7a+Zwcwf9p9ZAcwTwg7kERbwm5md5nZ/5jZTjN7pB09FDGz3Wb2hpltM7Otbe7laTM7bGbbZ2wbMrOXzOyd2uWsa+y1qbfHzGx/7bnbZmZ3t6m3NWb2czN7y8zeNLOv1ra39bkL+pqX523e37ObWUXS25I+K2mfpC2S7nf3t+a1kQJmtlvSsLu3/QsYZvZHkk5J+r67f6K27W8lHXP3x2v/US5197/skN4ek3Sq3ct411YrWjVzmXFJ90j6ktr43AV93ad5eN7acWS/VdJOd9/l7uOSfiBpXRv66Hju/rKkY+dtXidpQ+36Bk3/Y5l3Bb11BHc/4O6v1a6flHR2mfG2PndBX/OiHWFfLWnvjN/3qbPWe3dJL5rZq2Y20u5mZrHC3c+uqXRQ0op2NjOL0mW859N5y4x3zHNXz/LnjeIDuo+6zd1/V9LnJH2l9nK1I/n0e7BOGjud0zLe82WWZcZ/o53PXb3LnzeqHWHfL2nmGRSvqm3rCO6+v3Z5WNJz6rylqA+dXUG3dnm4zf38Rict4z3bMuPqgOeuncuftyPsWyTdYGbXmlmvpC9I2tiGPj7CzAZqH5zIzAYk3anOW4p6o6QHatcfkPR8G3s5R6cs4120zLja/Ny1fflzd5/3H0l3a/oT+f+V9Fft6KGgr+sk/Vft58129ybpWU2/rKtq+rONByVdLmmTpHck/aukoQ7q7e8lvSHpdU0Ha1WbertN0y/RX5e0rfZzd7ufu6CveXne+LoskAQf0AFJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEv8PE4DsMh8Hn6sAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#load the actual hackthon data (fashion-mnist)\n", + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')\n", + "#you can visualize it\n", + "import matplotlib.pyplot as plt\n", + "plt.imshow(images[1100])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#your submission\n", + "\n", + "# Functions 'encode' and 'decode' are dummy.\n", + "def encode(image):\n", + " q = qiskit.QuantumRegister(3)\n", + " circuit = qiskit.QuantumCircuit(q)\n", + " if image[0][0]==0:\n", + " circuit.rx(np.pi,0)\n", + " return circuit\n", + "\n", + "\n", + "def run_part2(image):\n", + "\n", + " #loade the quantum classifier circuit\n", + " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", + " \n", + " #encode image into circuit\n", + " circuit=encode(image)\n", + " \n", + " #append with classifier circuit\n", + " nq1 = circuit.width()\n", + " nq2 = classifier.width()\n", + " nq = max(nq1, nq2)\n", + " qc = qiskit.QuantumCircuit(nq)\n", + " qc.append(circuit.to_instruction(), list(range(nq1)))\n", + " qc.append(classifier.to_instruction(), list(range(nq2)))\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(qc)\n", + " \n", + " #convert histogram to category\n", + " label=histogram_to_category(histogram)\n", + " \n", + " return circuit,label\n", + "#score" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.0\n" + ] + } + ], + "source": [ + "#how we grade your submission\n", + "\n", + "score=0\n", + "gatecount=0\n", + "n=len(dataset)\n", + "\n", + "for data in dataset:\n", + " #run part 2\n", + " circuit,label=run_part2(data['image'])\n", + " \n", + " #count the gate used in the circuit for score calculation\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #check label\n", + " if label==data['category']:\n", + " score+=1\n", + "#score\n", + "score=score/n\n", + "gatecount=gatecount/n\n", + "\n", + "print(score*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "from sklearn.decomposition import PCA\n", + "\n", + "#your submission\n", + "\n", + "# Functions 'encode' and 'decode' are dummy.\n", + "def encode_amplitude(images, image_index, n_qubits, debug=False):\n", + " N_images = len(images)\n", + " # We have 28x28 images as input\n", + " # - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\n", + " # 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \n", + " # into n_qubits (parametrized)\n", + " \n", + " \n", + " # [apply PCA]\n", + " # Create an instance of PCA\n", + " pca = PCA(n_components=2**n_qubits)\n", + "\n", + " # Fit PCA on your 784-dimensional data\n", + " data = images.reshape(N_images, 28 * 28)\n", + " pca.fit(data)\n", + "\n", + " # Apply dimensionality reduction on your data\n", + " data_pca = pca.transform(data)\n", + "\n", + " image = images[image_index]\n", + " \n", + " if debug:\n", + " \n", + " print(\"Raw Image data\")\n", + " print(data[image_index][:5])\n", + " \n", + " image_pca = data_pca[image_index]\n", + " \n", + " min_ = image_pca.min()\n", + " \n", + " if debug:\n", + " print(\"Image PCA\")\n", + " print(image_pca[:5])\n", + "\n", + " \n", + " image_pca = image_pca - min_\n", + " \n", + " if debug:\n", + " print(\"Image PCA min_ removed\")\n", + " print(image_pca[:5])\n", + " \n", + " # [normalize]\n", + " def normalize(row):\n", + " #We calculate the squareroot of the sum of the square values of the row\n", + " normalization_factor = np.sqrt(np.sum(row**2)) \n", + " if normalization_factor == 0.:\n", + " #If the sum is zero we return a 0\n", + " return 0.0\n", + " #Else we divide each value between the sum value above\n", + " row = row / normalization_factor\n", + " return row, normalization_factor\n", + " \n", + " image_pca_normalized, normalization_factor = normalize(image_pca)\n", + " \n", + " if debug:\n", + " print(image.shape)\n", + "\n", + " print(image_pca_normalized.shape)\n", + "\n", + " print(np.sum(image_pca_normalized**2))\n", + " \n", + " desired_state = image_pca_normalized\n", + " \n", + " #print(np.round(desired_state, 3))\n", + " if debug:\n", + " print(\"PCA normalized\")\n", + " print(np.round(image_pca_normalized, 5)[:5])\n", + "\n", + " print(\"Squared PCA\")\n", + " print(np.round(desired_state ** 2, 5)[:5])\n", + " \n", + " ##########\n", + " # Amplitude Encoding\n", + " qc = QuantumCircuit(n_qubits)\n", + " qc.initialize(desired_state)\n", + " qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", + "\n", + " ##########\n", + " \n", + " decoder_params = dict(\n", + " pca=pca,\n", + " min_=min_,\n", + " normalization_factor=normalization_factor,\n", + " n_qubits=n_qubits,\n", + " image=image\n", + " )\n", + " \n", + " return qc_decomposed, decoder_params\n", + "\n", + "def run_part2(images, image_index, n_qubits):\n", + "\n", + " #loade the quantum classifier circuit\n", + " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", + " \n", + " #encode image into circuit\n", + " circuit, _ = encode_amplitude(images, image_index, n_qubits)\n", + " \n", + " #append with classifier circuit\n", + " nq1 = circuit.width()\n", + " nq2 = classifier.width()\n", + " nq = max(nq1, nq2)\n", + " qc = qiskit.QuantumCircuit(nq)\n", + " qc.append(circuit.to_instruction(), list(range(nq1)))\n", + " qc.append(classifier.to_instruction(), list(range(nq2)))\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(qc)\n", + " \n", + " #convert histogram to category\n", + " label=histogram_to_category(histogram)\n", + " \n", + " return circuit,label\n", + "#score" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " 0.5323555582257801)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "run_part2(images, 0, 8)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "run_part2() missing 2 required positional arguments: 'image_index' and 'n_qubits'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[36], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m n\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mlen\u001b[39m(dataset)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m data \u001b[38;5;129;01min\u001b[39;00m dataset:\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m#run part 2\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m circuit,label\u001b[38;5;241m=\u001b[39m\u001b[43mrun_part2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mimage\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m#count the gate used in the circuit for score calculation\u001b[39;00m\n\u001b[1;32m 12\u001b[0m gatecount\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39mcount_gates(circuit)[\u001b[38;5;241m2\u001b[39m]\n", + "\u001b[0;31mTypeError\u001b[0m: run_part2() missing 2 required positional arguments: 'image_index' and 'n_qubits'" + ] + } + ], + "source": [ + "#how we grade your submission\n", + "\n", + "score=0\n", + "gatecount=0\n", + "n=len(dataset)\n", + "\n", + "for data in dataset:\n", + " #run part 2\n", + " circuit,label=run_part2(data['image'])\n", + " \n", + " #count the gate used in the circuit for score calculation\n", + " gatecount+=count_gates(circuit)[2]\n", + " \n", + " #check label\n", + " if label==data['category']:\n", + " score+=1\n", + "#score\n", + "score=score/n\n", + "gatecount=gatecount/n\n", + "\n", + "print(score*(0.999**gatecount))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import QuantumCircuit\n", + "qc = QuantumCircuit(1)\n", + "#qc.x(0)\n", + "\n", + "a = qc.qasm(filename=\"quantum_classifier.qasm\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " data\t\t\t\t part1_example_qiskit.ipynb\n", + " data1.json\t\t\t part1.py\n", + " data2.json\t\t\t part2_example_cirq.ipynb\n", + " examples.ipynb\t\t\t part2_example_qiskit-Copy1.ipynb\n", + " examples_qiskit.ipynb\t\t part2_example_qiskit.ipynb\n", + "'MIT iQuHACK remote challenge .docx' part2.pickle\n", + " MIT_iQuHACK_remote_challenge.pdf part2.qasm\n", + " mock_data\t\t\t __pycache__\n", + " mock_data_creator.ipynb\t quantum_classifier.qasm\n", + " part1_example_cirq.ipynb\t README.md\n", + " part1_example_qiskit-Copy1.ipynb\n" + ] + } + ], + "source": [ + "!ls" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# versioned classifer" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
   \n",
+       "q: \n",
+       "
" + ], + "text/plain": [ + " \n", + "q: \n", + " " + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "classifier.draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ True, True, True, ..., False, False, False])" + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:09<00:38, 9.51s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5886651262609048\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:29<00:46, 15.66s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.635555073783909\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:50<00:35, 17.92s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.6394353896795691\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:28<00:26, 26.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5571776351730213\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:40<00:00, 20.11s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.6313328175555944\n", + "[False True False False False] [0.5886651262609048, 0.635555073783909, 0.6394353896795691, 0.5571776351730213, 0.6313328175555944]\n", + "Loss\n", + "0.8348271641207405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:10<00:40, 10.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5887672655465805\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:24<00:37, 12.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5887795315504828\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:52<00:38, 19.49s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5946188604607769\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:25<00:25, 25.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5478308104464287\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:58<00:00, 23.79s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5954196131409886\n", + "[False True False False False] [0.5887672655465805, 0.5887795315504828, 0.5946188604607769, 0.5478308104464287, 0.5954196131409886]\n", + "Loss\n", + "0.8039661384001928\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:10<00:41, 10.46s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.6042148860124525\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:17<00:24, 8.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5909436173541671\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:52<00:41, 20.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5872112853515093\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:11<00:19, 19.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.581567395202677\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:19<00:00, 15.83s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5882434543551341\n", + "[False True False False False] [0.6042148860124525, 0.5909436173541671, 0.5872112853515093, 0.581567395202677, 0.5882434543551341]\n", + "Loss\n", + "0.8192600766547915\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:23<01:35, 23.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.6482366557230557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [01:02<01:37, 32.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.629216034457888\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [01:19<00:51, 25.67s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.6364463671356472\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:38<00:22, 22.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5952576435570955\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:50<00:00, 22.01s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.632391172474394\n", + "[False True False False False] [0.6482366557230557, 0.629216034457888, 0.6364463671356472, 0.5952576435570955, 0.632391172474394]\n", + "Loss\n", + "0.8850292328798368\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:06<00:27, 6.85s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5560127547288942\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:22<00:35, 11.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5301498216093532\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:29<00:19, 9.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5375805143537935\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:39<00:09, 9.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.506783527318943\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:01<00:00, 12.32s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.541118651861013\n", + "[False True False False False] [0.5560127547288942, 0.5301498216093532, 0.5375805143537935, 0.506783527318943, 0.541118651861013]\n", + "Loss\n", + "0.7407217215964954\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:14<00:56, 14.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5768871930688416\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:20<00:28, 9.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5497010069723379\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:57<00:44, 22.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5697864242327038\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:11<00:18, 18.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5322058577855764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:43<00:00, 20.73s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5644241939997484\n", + "[False True False False False] [0.5768871930688416, 0.5497010069723379, 0.5697864242327038, 0.5322058577855764, 0.5644241939997484]\n", + "Loss\n", + "0.7785568217225514\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:07<00:31, 7.85s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5772392112104014\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:23<00:38, 12.70s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5537397226449562\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:52<00:39, 19.78s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5668504855390445\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:00<00:15, 15.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.533056444679258\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:38<00:00, 19.61s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5653006066248942\n", + "[False True False False False] [0.5772392112104014, 0.5537397226449562, 0.5668504855390445, 0.533056444679258, 0.5653006066248942]\n", + "Loss\n", + "0.7766658063282734\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:42<02:49, 42.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.46263282315096216\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:55<01:15, 25.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4547075091520982\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [01:23<00:53, 26.60s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.45840960165281147\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:30<00:18, 18.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.44299854801015875\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [02:07<00:00, 25.55s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4588012765777399\n", + "[False True False False False] [0.46263282315096216, 0.4547075091520982, 0.45840960165281147, 0.44299854801015875, 0.4588012765777399]\n", + "Loss\n", + "0.6443152051419245\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:28<01:52, 28.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4451348060818319\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:37<00:50, 16.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.43285858454688086\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [01:16<00:54, 27.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4379326714344286\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:36<00:24, 24.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4289803397148101\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [02:18<00:00, 27.76s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4371584767496989\n", + "[False True False False False] [0.4451348060818319, 0.43285858454688086, 0.4379326714344286, 0.4289803397148101, 0.4371584767496989]\n", + "Loss\n", + "0.6275193474653809\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:32<02:10, 32.68s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5597488893554801\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [01:07<01:42, 34.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5398738773269588\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [01:40<01:06, 33.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5408618872182283\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [02:01<00:28, 28.42s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.571415618234901\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [02:08<00:00, 25.79s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5552053951139723\n", + "[False True False False False] [0.5597488893554801, 0.5398738773269588, 0.5408618872182283, 0.571415618234901, 0.5552053951139723]\n", + "Loss\n", + "0.7745288506165932\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:06<00:24, 6.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3865351769054153\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:44<01:15, 25.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3993995727392796\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:57<00:38, 19.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40966690819490065\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:10<00:17, 17.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.38241319650500133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:18<00:00, 15.73s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4065279130003209\n", + "[False True False False False] [0.3865351769054153, 0.3993995727392796, 0.40966690819490065, 0.38241319650500133, 0.4065279130003209]\n", + "Loss\n", + "0.5874388732831373\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:44<02:58, 44.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4621599262859051\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [01:32<02:19, 46.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.462740104977792\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [02:05<01:20, 40.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4673291779347078\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [02:11<00:26, 26.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4568380575607388\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [02:32<00:00, 30.51s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.46191207605713097\n", + "[False True False False False] [0.4621599262859051, 0.462740104977792, 0.4673291779347078, 0.4568380575607388, 0.46191207605713097]\n", + "Loss\n", + "0.6501432893166127\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:36<02:27, 36.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.369807563371284\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [01:12<01:48, 36.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3604028358611908\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [01:44<01:08, 34.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3743517415311594\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [02:24<00:36, 36.52s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3548900569465631\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [02:42<00:00, 32.53s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36963326432027716\n", + "[False True False False False] [0.369807563371284, 0.3604028358611908, 0.3743517415311594, 0.3548900569465631, 0.36963326432027716]\n", + "Loss\n", + "0.5702035840667261\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:45<03:01, 45.35s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35447136774987215\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [01:08<01:36, 32.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.34929289364028476\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [01:28<00:53, 26.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36052823098651654\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:50<00:24, 24.67s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3508202147244561\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [02:16<00:00, 27.36s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3614104100542209\n", + "[False True False False False] [0.35447136774987215, 0.34929289364028476, 0.36052823098651654, 0.3508202147244561, 0.3614104100542209]\n", + "Loss\n", + "0.5634363742402475\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:18<01:13, 18.46s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39427714536400554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:22<00:29, 9.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40283506366759403\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:26<00:14, 7.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4136467994413509\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:30<00:06, 6.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3967395644317901\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:34<00:00, 6.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4136126662215701\n", + "[False True False False False] [0.39427714536400554, 0.40283506366759403, 0.4136467994413509, 0.3967395644317901, 0.4136126662215701]\n", + "Loss\n", + "0.5967149498371546\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39342067246967344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.38444537959813646\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39539608562323136\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39195427344574146\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3956931161690733\n", + "[False True False False False] [0.39342067246967344, 0.38444537959813646, 0.39539608562323136, 0.39195427344574146, 0.3956931161690733]\n", + "Loss\n", + "0.5920466715273044\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.38104219657932026\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3921320250715751\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4046609531724643\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.38762670624458084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40698511859140374\n", + "[False True False False False] [0.38104219657932026, 0.3921320250715751, 0.4046609531724643, 0.38762670624458084, 0.40698511859140374]\n", + "Loss\n", + "0.589489618883053\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4996597605950226\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5045278759859043\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.517634811070131\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.510977376601686\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.515357502904338\n", + "[False True False False False] [0.4996597605950226, 0.5045278759859043, 0.517634811070131, 0.510977376601686, 0.515357502904338]\n", + "Loss\n", + "0.7090686445661614\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36977251990880994\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36147405530262083\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37869230113866714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.365291476047138\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3750147421230764\n", + "[False True False False False] [0.36977251990880994, 0.36147405530262083, 0.37869230113866714, 0.365291476047138, 0.3750147421230764]\n", + "Loss\n", + "0.5759569810048877\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32680673625873813\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33371137066244666\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3367996095435105\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32727558593394374\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33461044186072936\n", + "[False True False False False] [0.32680673625873813, 0.33371137066244666, 0.3367996095435105, 0.32727558593394374, 0.33461044186072936]\n", + "Loss\n", + "0.54153637176862\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3234701932468214\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33257161355609854\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33269733586018124\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3195218004572857\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32716846681546863\n", + "[False True False False False] [0.3234701932468214, 0.33257161355609854, 0.33269733586018124, 0.3195218004572857, 0.32716846681546863]\n", + "Loss\n", + "0.5354820395810107\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.34444524312447194\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36561075691008915\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35922770951871574\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3460689832476736\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.14s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3571977039326527\n", + "[False True False False False] [0.34444524312447194, 0.36561075691008915, 0.35922770951871574, 0.3460689832476736, 0.3571977039326527]\n", + "Loss\n", + "0.5480424146812086\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3453488953479874\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35654940102551874\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3619448910579684\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.34170420934943124\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35126890433274877\n", + "[False True False False False] [0.3453488953479874, 0.35654940102551874, 0.3619448910579684, 0.34170420934943124, 0.35126890433274877]\n", + "Loss\n", + "0.5510207702825525\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3647713870840714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36560614980139516\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3682028268650631\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3595555571010323\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3620355481422257\n", + "[False True False False False] [0.3647713870840714, 0.36560614980139516, 0.3682028268650631, 0.3595555571010323, 0.3620355481422257]\n", + "Loss\n", + "0.5628442849571667\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3892840520675162\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37605453622898194\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3812519809230065\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37211458149767584\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37345396223655525\n", + "[False True False False False] [0.3892840520675162, 0.37605453622898194, 0.3812519809230065, 0.37211458149767584, 0.37345396223655525]\n", + "Loss\n", + "0.5768264403028794\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.50s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35791850804181075\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.41s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.364168634936583\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36032012091954607\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36177573409649627\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.19s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36576078799916434\n", + "[False True False False False] [0.35791850804181075, 0.364168634936583, 0.36032012091954607, 0.36177573409649627, 0.36576078799916434]\n", + "Loss\n", + "0.5608720669060392\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3431832952467062\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33707057695817905\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.34192862556595777\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3452037684786383\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3337238755315904\n", + "[False True False False False] [0.3431832952467062, 0.33707057695817905, 0.34192862556595777, 0.3452037684786383, 0.3337238755315904]\n", + "Loss\n", + "0.5511474788959638\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3599882716753128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37418341045045944\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39012142277350087\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3641264655497175\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3842285651998308\n", + "[False True False False False] [0.3599882716753128, 0.37418341045045944, 0.39012142277350087, 0.3641264655497175, 0.3842285651998308]\n", + "Loss\n", + "0.5722816768941134\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32575564218067277\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3234549214313968\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31157891541518784\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3215313982088845\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31111652194676515\n", + "[False True False False False] [0.32575564218067277, 0.3234549214313968, 0.31157891541518784, 0.3215313982088845, 0.31111652194676515]\n", + "Loss\n", + "0.5313626018856659\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36618341319143793\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35403768374256817\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3580666378367964\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3596841034935682\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35983296301858336\n", + "[False True False False False] [0.36618341319143793, 0.35403768374256817, 0.3580666378367964, 0.3596841034935682, 0.35983296301858336]\n", + "Loss\n", + "0.5658876274720608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37046282330133595\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36354534731396443\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3562040008146169\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3450947303994383\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35505625151372056\n", + "[False True False False False] [0.37046282330133595, 0.36354534731396443, 0.3562040008146169, 0.3450947303994383, 0.35505625151372056]\n", + "Loss\n", + "0.5553703680305133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.380230262626159\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.25s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3572119811646339\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3666330119567727\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36581121710098563\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3557073242834386\n", + "[False True False False False] [0.380230262626159, 0.3572119811646339, 0.3666330119567727, 0.36581121710098563, 0.3557073242834386]\n", + "Loss\n", + "0.5719098419117892\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35663703753951137\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3671983712448269\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.362950488697297\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3445507435196846\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.22s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36209997701506685\n", + "[False True False False False] [0.35663703753951137, 0.3671983712448269, 0.362950488697297, 0.3445507435196846, 0.36209997701506685]\n", + "Loss\n", + "0.5531630580227895\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5253693408521137\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5097793751568319\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4956836188952259\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.5269470541612721\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.50573127974192\n", + "[False True False False False] [0.5253693408521137, 0.5097793751568319, 0.4956836188952259, 0.5269470541612721, 0.50573127974192]\n", + "Loss\n", + "0.7113541902666731\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3298705057580248\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31926947141501666\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.30957253741541224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32083012956424023\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3107622980577531\n", + "[False True False False False] [0.3298705057580248, 0.31926947141501666, 0.30957253741541224, 0.32083012956424023, 0.3107622980577531]\n", + "Loss\n", + "0.5343003089108512\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:18, 4.58s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3404224718526728\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.43s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33413301311722216\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32259945668290185\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3386504392598052\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.21s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32620573227373484\n", + "[False True False False False] [0.3404224718526728, 0.33413301311722216, 0.32259945668290185, 0.3386504392598052, 0.32620573227373484]\n", + "Loss\n", + "0.542033522972876\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31465886650351016\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.313194136481489\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3094347573927366\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31398422454817443\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3134184240371007\n", + "[False True False False False] [0.31465886650351016, 0.313194136481489, 0.3094347573927366, 0.31398422454817443, 0.3134184240371007]\n", + "Loss\n", + "0.5323800615570604\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3262605359592778\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32863458826144337\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3154798430206206\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3190312243138961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.18s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31694323731027585\n", + "[False True False False False] [0.3262605359592778, 0.32863458826144337, 0.3154798430206206, 0.3190312243138961, 0.31694323731027585]\n", + "Loss\n", + "0.5304347881203599\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33112149187993084\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33983585700744806\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3285797855473206\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32510684615992386\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3306713221358046\n", + "[False True False False False] [0.33112149187993084, 0.33983585700744806, 0.3285797855473206, 0.32510684615992386, 0.3306713221358046]\n", + "Loss\n", + "0.5348972818955202\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.35705771615661697\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.36527590731511067\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.356540437326691\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3561192545025821\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3601914773928603\n", + "[False True False False False] [0.35705771615661697, 0.36527590731511067, 0.356540437326691, 0.3561192545025821, 0.3601914773928603]\n", + "Loss\n", + "0.5553053584501128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.34129624291073557\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.350291427853868\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3348680926292176\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33567311343089773\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3387169953277613\n", + "[False True False False False] [0.34129624291073557, 0.350291427853868, 0.3348680926292176, 0.33567311343089773, 0.3387169953277613]\n", + "Loss\n", + "0.5393590873314492\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40703263174577314\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4198797818223454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40812784331116725\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40768876702296214\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.18s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4131723106263382\n", + "[False True False False False] [0.40703263174577314, 0.4198797818223454, 0.40812784331116725, 0.40768876702296214, 0.4131723106263382]\n", + "Loss\n", + "0.5943228937501457\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3242865716196675\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3291540494747667\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3156154982442203\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31909371798695346\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.319732614087155\n", + "[False True False False False] [0.3242865716196675, 0.3291540494747667, 0.3156154982442203, 0.31909371798695346, 0.319732614087155]\n", + "Loss\n", + "0.5304101887795788\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32340582358371395\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32847261888998447\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3158358137205245\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3187643438433877\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3195264887368705\n", + "[False True False False False] [0.32340582358371395, 0.32847261888998447, 0.3158358137205245, 0.3187643438433877, 0.3195264887368705]\n", + "Loss\n", + "0.5304712298942121\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3265460748233359\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3292011715640585\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3158950764513984\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3176448178250027\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.11s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31848577466107064\n", + "[False True False False False] [0.3265460748233359, 0.3292011715640585, 0.3158950764513984, 0.3176448178250027, 0.31848577466107064]\n", + "Loss\n", + "0.5303418080399969\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32481400728222015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32998057031889644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31533093720001554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3200331842970167\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31905231103580034\n", + "[False True False False False] [0.32481400728222015, 0.32998057031889644, 0.31533093720001554, 0.3200331842970167, 0.31905231103580034]\n", + "Loss\n", + "0.5300578672175336\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32871194664038944\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32909350065318643\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31557926159626265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.320232346124385\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3205090545990064\n", + "[False True False False False] [0.32871194664038944, 0.32909350065318643, 0.31557926159626265, 0.320232346124385, 0.3205090545990064]\n", + "Loss\n", + "0.532313669586405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3248907450598018\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3287184394667966\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3153727172020793\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3194819386190833\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3201011522443733\n", + "[False True False False False] [0.3248907450598018, 0.3287184394667966, 0.3153727172020793, 0.3194819386190833, 0.3201011522443733]\n", + "Loss\n", + "0.5310054612691196\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.326606106178247\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.32666862179464207\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31418660056679093\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3186760166843882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3234238327135931\n", + "[False True False False False] [0.326606106178247, 0.32666862179464207, 0.31418660056679093, 0.3186760166843882, 0.3234238327135931]\n", + "Loss\n", + "0.5331622277336845\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1586911031052453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1603507044082502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15466896821450166\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1636195451048787\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.44s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15367328258659857\n", + "[False True False False False] [0.1586911031052453, 0.1603507044082502, 0.15466896821450166, 0.1636195451048787, 0.15367328258659857]\n", + "Loss\n", + "0.5033473613858332\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19456541439612654\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19611534490711094\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1930977637563495\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.195803508495091\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18933576689262593\n", + "[False True False False False] [0.19456541439612654, 0.19611534490711094, 0.1930977637563495, 0.195803508495091, 0.18933576689262593]\n", + "Loss\n", + "0.49755826484589527\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.48s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40653866917610615\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40446678837985467\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40044409672318015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40508595643567213\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.22s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.40563651508012816\n", + "[False True False False False] [0.40653866917610615, 0.40446678837985467, 0.40044409672318015, 0.40508595643567213, 0.40563651508012816]\n", + "Loss\n", + "0.595627499906749\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:18, 4.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.25768491485836204\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2540129451382102\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:08, 4.38s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2582873584129265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.25597132598869543\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.33s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.25360689744375614\n", + "[False True False False False] [0.25768491485836204, 0.2540129451382102, 0.2582873584129265, 0.25597132598869543, 0.25360689744375614]\n", + "Loss\n", + "0.5110646984723072\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16116584531648073\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.42s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15950538873915934\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:08, 4.42s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1406148537778437\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16524271331231716\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.24s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14272278910281083\n", + "[False True False False False] [0.16116584531648073, 0.15950538873915934, 0.1406148537778437, 0.16524271331231716, 0.14272278910281083]\n", + "Loss\n", + "0.49951322863292197\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1882961524220535\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18647070359767837\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.25s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18146077341782085\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18940455631721573\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.42s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18023169554473892\n", + "[False True False False False] [0.1882961524220535, 0.18647070359767837, 0.18146077341782085, 0.18940455631721573, 0.18023169554473892]\n", + "Loss\n", + "0.4994109081710043\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.83s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17669006580057361\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18801156103552372\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18194985083900964\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18627352494553656\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1802449488757163\n", + "[False True False False False] [0.17669006580057361, 0.18801156103552372, 0.18194985083900964, 0.18627352494553656, 0.1802449488757163]\n", + "Loss\n", + "0.4942773430984643\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.30s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17464420138027842\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.22s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1823635451773762\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1792534817790338\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18953482055863977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.32s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1787017018217077\n", + "[False True False False False] [0.17464420138027842, 0.1823635451773762, 0.1792534817790338, 0.18953482055863977, 0.1787017018217077]\n", + "Loss\n", + "0.4996501127094848\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.09215641646032387\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:12, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.10638044405544046\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.09918136620973955\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.10685159743928796\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.09532401790239671\n", + "[False True False False False] [0.09215641646032387, 0.10638044405544046, 0.09918136620973955, 0.10685159743928796, 0.09532401790239671]\n", + "Loss\n", + "0.5310097978651453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.201815006636465\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2040462006905253\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19985765600210018\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21338039408441703\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19737938449725415\n", + "[False True False False False] [0.201815006636465, 0.2040462006905253, 0.19985765600210018, 0.21338039408441703, 0.19737938449725415]\n", + "Loss\n", + "0.49953459821608764\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.11650565738928655\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.12946639357451342\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.12926660532740697\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.13440292782621474\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1225823934268294\n", + "[False True False False False] [0.11650565738928655, 0.12946639357451342, 0.12926660532740697, 0.13440292782621474, 0.1225823934268294]\n", + "Loss\n", + "0.5163463496597933\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17340724645214473\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18361350383894307\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18012642390945502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18795666300333327\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17771053999439795\n", + "[False True False False False] [0.17340724645214473, 0.18361350383894307, 0.18012642390945502, 0.18795666300333327, 0.17771053999439795]\n", + "Loss\n", + "0.4975669794308816\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1417936680479085\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15101641082645642\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14444488640695924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15524363101362676\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14128336180450804\n", + "[False True False False False] [0.1417936680479085, 0.15101641082645642, 0.14444488640695924, 0.15524363101362676, 0.14128336180450804]\n", + "Loss\n", + "0.5040611119639709\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1972957783079646\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2102958550612722\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20631898355517297\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2075617692092128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19977565388267782\n", + "[False True False False False] [0.1972957783079646, 0.2102958550612722, 0.20631898355517297, 0.2075617692092128, 0.19977565388267782]\n", + "Loss\n", + "0.49311727960917506\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.83s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4135469673010354\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4171409565310763\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.4249977470332644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.41459461824209454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.42018389586472366\n", + "[False True False False False] [0.4135469673010354, 0.4171409565310763, 0.4249977470332644, 0.41459461824209454, 0.42018389586472366]\n", + "Loss\n", + "0.6083740205599146\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18898071856613483\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20178650795177006\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19871122516311057\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20236531251586304\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1944486900481864\n", + "[False True False False False] [0.18898071856613483, 0.20178650795177006, 0.19871122516311057, 0.20236531251586304, 0.1944486900481864]\n", + "Loss\n", + "0.49477506228073664\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.24s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1695053857575129\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17892798842950247\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17905892556465808\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1817424417699664\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1723103672591952\n", + "[False True False False False] [0.1695053857575129, 0.17892798842950247, 0.17905892556465808, 0.1817424417699664, 0.1723103672591952]\n", + "Loss\n", + "0.49870095928406577\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19423455075123439\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21074591208853713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20597244570074205\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20537371314477404\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20230189923878059\n", + "[False True False False False] [0.19423455075123439, 0.21074591208853713, 0.20597244570074205, 0.20537371314477404, 0.20230189923878059]\n", + "Loss\n", + "0.49192204128145905\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16478111070485466\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19305715113404445\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1831520276123124\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1734547911017242\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1779399038607908\n", + "[False True False False False] [0.16478111070485466, 0.19305715113404445, 0.1831520276123124, 0.1734547911017242, 0.1779399038607908]\n", + "Loss\n", + "0.4827150364708753\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:06<00:24, 6.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17426220796033037\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:10<00:14, 4.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19926835362074374\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:14<00:09, 4.68s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19506944859011405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:18<00:04, 4.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1916412255180296\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.60s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1879461170955461\n", + "[False True False False False] [0.17426220796033037, 0.19926835362074374, 0.19506944859011405, 0.1916412255180296, 0.1879461170955461]\n", + "Loss\n", + "0.4885036003423431\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1449201437966644\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:12, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16872986609849405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16261762775887556\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1541721077933156\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1545041674365591\n", + "[False True False False False] [0.1449201437966644, 0.16872986609849405, 0.16261762775887556, 0.1541721077933156, 0.1545041674365591]\n", + "Loss\n", + "0.48975251533887487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17635235222088622\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:12<00:20, 6.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20527328831024638\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:27<00:20, 10.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1921235147475296\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [01:00<00:19, 19.44s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18446752742692676\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [01:13<00:00, 14.67s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18893964578533953\n", + "[False True False False False] [0.17635235222088622, 0.20527328831024638, 0.1921235147475296, 0.18446752742692676, 0.18893964578533953]\n", + "Loss\n", + "0.48081969398971786\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31188640594536243\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:12, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.341678387788547\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20169116245498142\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19752377992244047\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17424756986272397\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.96s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18951400418096734\n", + "[False True False False False] [0.16843235064334472, 0.20169116245498142, 0.19752377992244047, 0.17424756986272397, 0.18951400418096734]\n", + "Loss\n", + "0.4814189641221791\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14750962920402982\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18073174474779835\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17334272116239413\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15395933894288724\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16595273306975322\n", + "[False True False False False] [0.14750962920402982, 0.18073174474779835, 0.17334272116239413, 0.15395933894288724, 0.16595273306975322]\n", + "Loss\n", + "0.4818705862602416\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16836284109774297\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20477401638328838\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1988375547795738\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17368807762673932\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18791346902928172\n", + "[False True False False False] [0.16836284109774297, 0.20477401638328838, 0.1988375547795738, 0.17368807762673932, 0.18791346902928172]\n", + "Loss\n", + "0.4781660365673718\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15404079607222432\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16971417536574365\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16897229256060478\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15968621176119766\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1607720964721375\n", + "[False True False False False] [0.15404079607222432, 0.16971417536574365, 0.16897229256060478, 0.15968621176119766, 0.1607720964721375]\n", + "Loss\n", + "0.4950537470666626\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18000617424217522\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:11, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21586302805277205\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20882124642938857\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.22s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18396734527037326\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:23<00:00, 4.66s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20009126308491818\n", + "[False True False False False] [0.18000617424217522, 0.21586302805277205, 0.20882124642938857, 0.18396734527037326, 0.20009126308491818]\n", + "Loss\n", + "0.4784719132096679\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1444161711697637\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16899752430196321\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1681249441995779\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14827494385723208\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15739431204228935\n", + "[False True False False False] [0.1444161711697637, 0.16899752430196321, 0.1681249441995779, 0.14827494385723208, 0.15739431204228935]\n", + "Loss\n", + "0.48993262512537183\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1809336134352711\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21078702447408532\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20583482542732662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1872619454486529\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19586762064078855\n", + "[False True False False False] [0.1809336134352711, 0.21078702447408532, 0.20583482542732662, 0.1872619454486529, 0.19586762064078855]\n", + "Loss\n", + "0.4824597518205711\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1574516375638041\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.195085630971131\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1870464583174152\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1663779982890453\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17814495512627423\n", + "[False True False False False] [0.1574516375638041, 0.195085630971131, 0.1870464583174152, 0.1663779982890453, 0.17814495512627423]\n", + "Loss\n", + "0.4781777345094718\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17723579988390972\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21129946823188195\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20351499280948304\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18011054719258146\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1956701334724591\n", + "[False True False False False] [0.17723579988390972, 0.21129946823188195, 0.20351499280948304, 0.18011054719258146, 0.1956701334724591]\n", + "Loss\n", + "0.4786886099635542\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33401038785752807\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3829747128778231\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.37259835905184063\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33496254536551\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3614299560786519\n", + "[False True False False False] [0.33401038785752807, 0.3829747128778231, 0.37259835905184063, 0.33496254536551, 0.3614299560786519]\n", + "Loss\n", + "0.5377743430885994\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16883212257405827\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20370306381206843\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19801149544886174\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17682443511450932\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19083960422276686\n", + "[False True False False False] [0.16883212257405827, 0.20370306381206843, 0.19801149544886174, 0.17682443511450932, 0.19083960422276686]\n", + "Loss\n", + "0.48060406020651636\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14989981649161485\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18196134596372215\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17416524929883342\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15630204033788964\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16623070397838788\n", + "[False True False False False] [0.14989981649161485, 0.18196134596372215, 0.17416524929883342, 0.15630204033788964, 0.16623070397838788]\n", + "Loss\n", + "0.48189638248590966\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17403583720436375\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.92s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20904819152162832\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20259439230089135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18185719675882286\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.11s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19406670083731606\n", + "[False True False False False] [0.17403583720436375, 0.20904819152162832, 0.20259439230089135, 0.18185719675882286, 0.19406670083731606]\n", + "Loss\n", + "0.4798517706780444\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16080725312805222\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19311031539940196\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18743233862632105\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16697940442883025\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17769167371782735\n", + "[False True False False False] [0.16080725312805222, 0.19311031539940196, 0.18743233862632105, 0.16697940442883025, 0.17769167371782735]\n", + "Loss\n", + "0.48114028050844454\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17383446692338714\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20708302912504487\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20113579772326745\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17747043267851845\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.21s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1900993797953595\n", + "[False True False False False] [0.17383446692338714, 0.20708302912504487, 0.20113579772326745, 0.17747043267851845, 0.1900993797953595]\n", + "Loss\n", + "0.4792748935286079\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16998485239968067\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20433246326628968\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19696779785612678\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1753928099085578\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18841979829505043\n", + "[False True False False False] [0.16998485239968067, 0.20433246326628968, 0.19696779785612678, 0.1753928099085578, 0.18841979829505043]\n", + "Loss\n", + "0.4790597772638675\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17189690195748197\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20857761364120023\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20145096381074973\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17879722541486615\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1933327817867839\n", + "[False True False False False] [0.17189690195748197, 0.20857761364120023, 0.20145096381074973, 0.17879722541486615, 0.1933327817867839]\n", + "Loss\n", + "0.47856997197554796\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16954032036314767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20583944374823307\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1993024342859389\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17468000591300167\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.37s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.190550987551769\n", + "[False True False False False] [0.16954032036314767, 0.20583944374823307, 0.1993024342859389, 0.17468000591300167, 0.190550987551769]\n", + "Loss\n", + "0.4784184557264945\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17282936400413026\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20871118283006404\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20165872525338283\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1776626263321877\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19365739703016666\n", + "[False True False False False] [0.17282936400413026, 0.20871118283006404, 0.20165872525338283, 0.1776626263321877, 0.19365739703016666]\n", + "Loss\n", + "0.478523673259459\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17125730233977066\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20688228727424368\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20036965319853803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17685309196024887\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18981758940582819\n", + "[False True False False False] [0.17125730233977066, 0.20688228727424368, 0.20036965319853803, 0.17685309196024887, 0.18981758940582819]\n", + "Loss\n", + "0.47843460618368405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17281467829429709\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20713210650239158\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2013069156468326\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17749338586517652\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1930444115544414\n", + "[False True False False False] [0.17281467829429709, 0.20713210650239158, 0.2013069156468326, 0.17749338586517652, 0.1930444115544414]\n", + "Loss\n", + "0.4797577890564364\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31372083525014977\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.34236370703901087\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:09, 4.53s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3332659966252576\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:18<00:04, 4.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.31638675425204627\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:23<00:00, 4.64s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.33360165279935344\n", + "[False True False False False] [0.31372083525014977, 0.34236370703901087, 0.3332659966252576, 0.31638675425204627, 0.33360165279935344]\n", + "Loss\n", + "0.527989430481093\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:19<01:18, 19.70s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2379509285906789\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:27<00:37, 12.50s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.280829833380348\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:31<00:17, 8.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.27054370100227987\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:35<00:07, 7.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.24130510188405704\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:39<00:00, 8.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.26494690556598244\n", + "[False True False False False] [0.2379509285906789, 0.280829833380348, 0.27054370100227987, 0.24130510188405704, 0.26494690556598244]\n", + "Loss\n", + "0.48823492397781665\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19816825224796725\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20212594376320436\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1994380002793589\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:22<00:06, 6.65s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19625096256442232\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:28<00:00, 5.61s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18934438883959168\n", + "[False True False False False] [0.19816825224796725, 0.20212594376320436, 0.1994380002793589, 0.19625096256442232, 0.18934438883959168]\n", + "Loss\n", + "0.49410844747547544\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:14<00:59, 14.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17949250929846358\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:24<00:35, 11.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21959569134776102\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:28<00:16, 8.37s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21119942137037248\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:32<00:06, 6.65s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18511093443246365\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:37<00:00, 7.45s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2024167302235697\n", + "[False True False False False] [0.17949250929846358, 0.21959569134776102, 0.21119942137037248, 0.18511093443246365, 0.2024167302235697]\n", + "Loss\n", + "0.4763826996652788\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3786751445900572\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.35s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39825167740658374\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:09, 4.59s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.39619459264555107\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:20<00:05, 5.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3943446925068937\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:25<00:00, 5.07s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3990160433057032\n", + "[False True False False False] [0.3786751445900572, 0.39825167740658374, 0.39619459264555107, 0.3943446925068937, 0.3990160433057032]\n", + "Loss\n", + "0.5823413870208729\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14565795183344235\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18166344849858482\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17370511175773642\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15264460892256554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16362443216272346\n", + "[False True False False False] [0.14565795183344235, 0.18166344849858482, 0.17370511175773642, 0.15264460892256554, 0.16362443216272346]\n", + "Loss\n", + "0.4796278594559869\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14917397635056373\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18553731565684128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17220114278311924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15922879359274938\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1670681096618819\n", + "[False True False False False] [0.14917397635056373, 0.18553731565684128, 0.17220114278311924, 0.15922879359274938, 0.1670681096618819]\n", + "Loss\n", + "0.4782542107117641\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2531976750793608\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2879308679593536\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2874439703208228\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.25619315267569565\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.27362799845717295\n", + "[False True False False False] [0.2531976750793608, 0.2879308679593536, 0.2874439703208228, 0.25619315267569565, 0.27362799845717295]\n", + "Loss\n", + "0.498310648726269\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19963001925994756\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.24650096427630838\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:09, 4.52s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.24529509619596918\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:18<00:04, 4.71s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21559694636088172\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.57s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2371650893460951\n", + "[False True False False False] [0.19963001925994756, 0.24650096427630838, 0.24529509619596918, 0.21559694636088172, 0.2371650893460951]\n", + "Loss\n", + "0.48360898990220125\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.23s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1624441295391298\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:09<00:13, 4.65s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19981199925703133\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:09, 4.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19398725972905742\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.44s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17534321616192552\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.42s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18601406111332058\n", + "[False True False False False] [0.1624441295391298, 0.19981199925703133, 0.19398725972905742, 0.17534321616192552, 0.18601406111332058]\n", + "Loss\n", + "0.48038031611474247\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17724936390940335\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19897462362820734\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1999462090576642\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.44s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17621442841609974\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.26s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18443932067575777\n", + "[False True False False False] [0.17724936390940335, 0.19897462362820734, 0.1999462090576642, 0.17621442841609974, 0.18443932067575777]\n", + "Loss\n", + "0.4860961757102301\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19807491806762328\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23982198723646628\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2275664994793589\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20191708931053107\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21959181830068353\n", + "[False True False False False] [0.19807491806762328, 0.23982198723646628, 0.2275664994793589, 0.20191708931053107, 0.21959181830068353]\n", + "Loss\n", + "0.47605775454792243\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19395451801589791\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2315725888715496\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21467084258950517\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19721020687734728\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2088953241654645\n", + "[False True False False False] [0.19395451801589791, 0.2315725888715496, 0.21467084258950517, 0.19721020687734728, 0.2088953241654645]\n", + "Loss\n", + "0.4748233415031894\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19110823724693135\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21893317525756512\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19293946070211643\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19590871243226382\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1921536650730935\n", + "[False True False False False] [0.19110823724693135, 0.21893317525756512, 0.19293946070211643, 0.19590871243226382, 0.1921536650730935]\n", + "Loss\n", + "0.4753722764437331\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20069304240931388\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2360823789317549\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22066259230305596\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2027414004329905\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:24<00:00, 5.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21414104899408193\n", + "[False True False False False] [0.20069304240931388, 0.2360823789317549, 0.22066259230305596, 0.2027414004329905, 0.21414104899408193]\n", + "Loss\n", + "0.47689000798275033\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:18<01:13, 18.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16428589387816944\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:31<00:45, 15.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19238207028262186\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:35<00:20, 10.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17460630783069336\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:39<00:07, 7.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16626171470713982\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:43<00:00, 8.72s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16922287625088447\n", + "[False True False False False] [0.16428589387816944, 0.19238207028262186, 0.17460630783069336, 0.16626171470713982, 0.16922287625088447]\n", + "Loss\n", + "0.4773729792970725\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:18, 4.66s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18190971161547514\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.40s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21806063092880357\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.22s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20372815658041715\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.187578324177676\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.20s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19663083320699667\n", + "[False True False False False] [0.18190971161547514, 0.21806063092880357, 0.20372815658041715, 0.187578324177676, 0.19663083320699667]\n", + "Loss\n", + "0.4756512094041387\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16617054725849195\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.92s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19903525917466794\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18052917015257147\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16575438044576254\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17347532683371444\n", + "[False True False False False] [0.16617054725849195, 0.19903525917466794, 0.18052917015257147, 0.16575438044576254, 0.17347532683371444]\n", + "Loss\n", + "0.47336981540262596\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16958054416429552\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1963235411344507\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18212367275126637\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1676565420679599\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.11s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17420564948995554\n", + "[False True False False False] [0.16958054416429552, 0.1963235411344507, 0.18212367275126637, 0.1676565420679599, 0.17420564948995554]\n", + "Loss\n", + "0.4779558722193169\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:18, 4.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16237966308600776\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.25s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18726088935864033\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17120457492837746\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15580579740974318\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1634543478465198\n", + "[False True False False False] [0.16237966308600776, 0.18726088935864033, 0.17120457492837746, 0.15580579740974318, 0.1634543478465198]\n", + "Loss\n", + "0.47761433383486407\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17577586669185416\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21062184681101992\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19013425487587415\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17357326408775056\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17986671450513733\n", + "[False True False False False] [0.17577586669185416, 0.21062184681101992, 0.19013425487587415, 0.17357326408775056, 0.17986671450513733]\n", + "Loss\n", + "0.47016458762593316\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16148802152182276\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19678887316162463\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17627049946684276\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15503558044881313\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17093052905558945\n", + "[False True False False False] [0.16148802152182276, 0.19678887316162463, 0.17627049946684276, 0.15503558044881313, 0.17093052905558945]\n", + "Loss\n", + "0.4703150824047212\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17734051640967324\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21478531803023335\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:14<00:09, 5.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19116741447957383\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:18<00:04, 4.70s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.174539506021326\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:30<00:00, 6.15s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18230919665212447\n", + "[False True False False False] [0.17734051640967324, 0.21478531803023335, 0.19116741447957383, 0.174539506021326, 0.18230919665212447]\n", + "Loss\n", + "0.46771547733616803\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:06<00:26, 6.73s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17925384028428967\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:10<00:15, 5.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21446999844840212\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:14<00:09, 4.62s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19204007490076555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:18<00:04, 4.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17917274148691242\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.58s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18581688249082964\n", + "[False True False False False] [0.17925384028428967, 0.21446999844840212, 0.19204007490076555, 0.17917274148691242, 0.18581688249082964]\n", + "Loss\n", + "0.470676442467531\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17859643389557467\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2151315357661695\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18902925343697743\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17267343345391037\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18256549373760395\n", + "[False True False False False] [0.17859643389557467, 0.2151315357661695, 0.18902925343697743, 0.17267343345391037, 0.18256549373760395]\n", + "Loss\n", + "0.46678199020260225\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16485517592269344\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21668045518603712\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1865121256974214\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1679413716354515\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17559367120190147\n", + "[False True False False False] [0.16485517592269344, 0.21668045518603712, 0.1865121256974214, 0.1679413716354515, 0.17559367120190147]\n", + "Loss\n", + "0.458570015930444\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.13540022929097087\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17815501281432897\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1511381664419089\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14082349392850305\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.25s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14016369598836217\n", + "[False True False False False] [0.13540022929097087, 0.17815501281432897, 0.1511381664419089, 0.14082349392850305, 0.14016369598836217]\n", + "Loss\n", + "0.46744856376401245\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.21s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19801023119313754\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.31s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.258258324285915\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.18s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2147948397690559\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20272204682646466\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.14s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21279791893028113\n", + "[False True False False False] [0.19801023119313754, 0.258258324285915, 0.2147948397690559, 0.20272204682646466, 0.21279791893028113]\n", + "Loss\n", + "0.4564173624833952\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20082041173885545\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.92s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2680057092303525\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22498237546087654\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20538477759221974\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2188919219882056\n", + "[False True False False False] [0.20082041173885545, 0.2680057092303525, 0.22498237546087654, 0.20538477759221974, 0.2188919219882056]\n", + "Loss\n", + "0.45454502587525597\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2253279314157279\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:12, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.30023847498435385\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.25764733078107405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22620276633529832\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2524890992420781\n", + "[False True False False False] [0.2253279314157279, 0.30023847498435385, 0.25764733078107405, 0.22620276633529832, 0.2524890992420781]\n", + "Loss\n", + "0.4607752671717014\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.33s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20470954780203882\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2680293933642416\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22700338934402037\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2108061949213992\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22464653423197448\n", + "[False True False False False] [0.20470954780203882, 0.2680293933642416, 0.22700338934402037, 0.2108061949213992, 0.22464653423197448]\n", + "Loss\n", + "0.45887334968450677\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19253510943491914\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.24838702148146863\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20756302804497315\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1928484654004219\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20211498914833587\n", + "[False True False False False] [0.19253510943491914, 0.24838702148146863, 0.20756302804497315, 0.1928484654004219, 0.20211498914833587]\n", + "Loss\n", + "0.4558599663048767\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20942775905773278\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.27537419474855357\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2303939380798518\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21180541726323981\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22929942754150978\n", + "[False True False False False] [0.20942775905773278, 0.27537419474855357, 0.2303939380798518, 0.21180541726323981, 0.22929942754150978]\n", + "Loss\n", + "0.4569929543495433\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21606815764587617\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2719436239262941\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.24140394085591713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22823687277887772\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2350773533396097\n", + "[False True False False False] [0.21606815764587617, 0.2719436239262941, 0.24140394085591713, 0.22823687277887772, 0.2350773533396097]\n", + "Loss\n", + "0.4697875427569306\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20728974381714343\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.27254381757451074\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23153916795402835\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20941984854530948\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22638197305709362\n", + "[False True False False False] [0.20728974381714343, 0.27254381757451074, 0.23153916795402835, 0.20941984854530948, 0.22638197305709362]\n", + "Loss\n", + "0.4574568661832249\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16653111058918996\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.229936566333003\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1926814043939102\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1742031396761318\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18309912752749732\n", + "[False True False False False] [0.16653111058918996, 0.229936566333003, 0.1926814043939102, 0.1742031396761318, 0.18309912752749732]\n", + "Loss\n", + "0.4519583196064795\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16441380232673455\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23166643867147224\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1944394585747119\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17303798529112852\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18596797504306364\n", + "[False True False False False] [0.16441380232673455, 0.23166643867147224, 0.1944394585747119, 0.17303798529112852, 0.18596797504306364]\n", + "Loss\n", + "0.4508094960333707\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.152183095014405\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.56s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22351275731016698\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:09, 4.50s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18898909212523823\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.38s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1571284380675573\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.33s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17846713503064773\n", + "[False True False False False] [0.152183095014405, 0.22351275731016698, 0.18898909212523823, 0.1571284380675573, 0.17846713503064773]\n", + "Loss\n", + "0.4480750339046776\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.27s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14945984018534428\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21930612076510353\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18533995217883875\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15414989966933934\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1740219742309344\n", + "[False True False False False] [0.14945984018534428, 0.21930612076510353, 0.18533995217883875, 0.15414989966933934, 0.1740219742309344]\n", + "Loss\n", + "0.4485509930243447\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15000720090943015\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20509668942320192\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17283650100495357\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15238772444966983\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16595878030839994\n", + "[False True False False False] [0.15000720090943015, 0.20509668942320192, 0.17283650100495357, 0.15238772444966983, 0.16595878030839994]\n", + "Loss\n", + "0.4566716964825016\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15365919542591275\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2231393670279896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18755767604027762\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15639426789391783\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17725188630213143\n", + "[False True False False False] [0.15365919542591275, 0.2231393670279896, 0.18755767604027762, 0.15639426789391783, 0.17725188630213143]\n", + "Loss\n", + "0.44793549386172415\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.159504901423437\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22697641713621802\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.193277692416323\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16099227388180398\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1821590124007243\n", + "[False True False False False] [0.159504901423437, 0.22697641713621802, 0.193277692416323, 0.16099227388180398, 0.1821590124007243]\n", + "Loss\n", + "0.44961436104121555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1631367212849207\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23596529880817044\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20254349523642512\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:03, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16600129844012734\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1896119446260616\n", + "[False True False False False] [0.1631367212849207, 0.23596529880817044, 0.20254349523642512, 0.16600129844012734, 0.1896119446260616]\n", + "Loss\n", + "0.44805171529922044\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1412007583018143\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20702839675307075\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17254882256007445\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1471797787842289\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1625635408872719\n", + "[False True False False False] [0.1412007583018143, 0.20702839675307075, 0.17254882256007445, 0.1471797787842289, 0.1625635408872719]\n", + "Loss\n", + "0.4506281968831609\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14530131289927506\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.20910925284872797\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17225540320312704\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15017295207140438\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16275105235836976\n", + "[False True False False False] [0.14530131289927506, 0.20910925284872797, 0.17225540320312704, 0.15017295207140438, 0.16275105235836976]\n", + "Loss\n", + "0.450262317042584\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.79s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23148359917911857\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.3193913483173988\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.28196555163942005\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22861224907314912\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2720867697242496\n", + "[False True False False False] [0.23148359917911857, 0.3193913483173988, 0.28196555163942005, 0.22861224907314912, 0.2720867697242496]\n", + "Loss\n", + "0.4626013556085006\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15177267479781925\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22589046247367844\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18979416026111554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15935640859734962\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18030372346900722\n", + "[False True False False False] [0.15177267479781925, 0.22589046247367844, 0.18979416026111554, 0.15935640859734962, 0.18030372346900722]\n", + "Loss\n", + "0.44703750520272945\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.29s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19321116066275196\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2716511536821668\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23946659382880997\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1982400972110423\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22597178026609224\n", + "[False True False False False] [0.19321116066275196, 0.2716511536821668, 0.23946659382880997, 0.1982400972110423, 0.22597178026609224]\n", + "Loss\n", + "0.4537516284844726\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15483309098171782\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22490456124504515\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19133787569402877\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1637091037204444\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18071728449405325\n", + "[False True False False False] [0.15483309098171782, 0.22490456124504515, 0.19133787569402877, 0.1637091037204444, 0.18071728449405325]\n", + "Loss\n", + "0.4501558406034828\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16025358177169488\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:12, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22913960860204596\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.17s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19165618618423455\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.16s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16863362624345404\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.14s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.184841699026096\n", + "[False True False False False] [0.16025358177169488, 0.22913960860204596, 0.19165618618423455, 0.16863362624345404, 0.184841699026096]\n", + "Loss\n", + "0.4499809159640377\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:18, 4.55s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1511538325843545\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.13s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2205029325368996\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.185506100488104\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.14s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15754614047021856\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1774950086094271\n", + "[False True False False False] [0.1511538325843545, 0.2205029325368996, 0.185506100488104, 0.15754614047021856, 0.1774950086094271]\n", + "Loss\n", + "0.4495494078962703\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.84s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1332951681833524\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19023018650236626\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16232711703650915\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1359754088619265\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14925019783153481\n", + "[False True False False False] [0.1332951681833524, 0.19023018650236626, 0.16232711703650915, 0.1359754088619265, 0.14925019783153481]\n", + "Loss\n", + "0.45749921920409\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1547811546371251\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2258891578846073\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.09s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19155038742274313\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.161916642421967\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:30<00:00, 6.07s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18216403314042096\n", + "[False True False False False] [0.1547811546371251, 0.2258891578846073, 0.19155038742274313, 0.161916642421967, 0.18216403314042096]\n", + "Loss\n", + "0.4492477351659992\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:06<00:24, 6.10s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16225406314043886\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:10<00:14, 4.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2317979217699585\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:14<00:09, 4.54s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19665290106834743\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:18<00:04, 4.34s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16520741426639635\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:22<00:00, 4.46s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18714962339631738\n", + "[False True False False False] [0.16225406314043886, 0.2317979217699585, 0.19665290106834743, 0.16520741426639635, 0.18714962339631738]\n", + "Loss\n", + "0.449135666436477\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1514633505841626\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22051349443907217\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1892364051418256\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15881962642661052\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17886470222454687\n", + "[False True False False False] [0.1514633505841626, 0.22051349443907217, 0.1892364051418256, 0.15881962642661052, 0.17886470222454687]\n", + "Loss\n", + "0.4511667416241966\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1558064792142228\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2170687963499356\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18445803795108023\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1567162308915782\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17526588680263117\n", + "[False True False False False] [0.1558064792142228, 0.2170687963499356, 0.18445803795108023, 0.1567162308915782, 0.17526588680263117]\n", + "Loss\n", + "0.4527925712361839\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1527566561102167\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22338166618374417\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.94s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19005471647397273\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1599421583046078\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.96s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1797411142678577\n", + "[False True False False False] [0.1527566561102167, 0.22338166618374417, 0.19005471647397273, 0.1599421583046078, 0.1797411142678577]\n", + "Loss\n", + "0.4495698353979913\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15640367414271006\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22625881572092493\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19335620207283158\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1588710402845297\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1813576631403355\n", + "[False True False False False] [0.15640367414271006, 0.22625881572092493, 0.19335620207283158, 0.1588710402845297, 0.1813576631403355]\n", + "Loss\n", + "0.44882966088302584\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15688037457950896\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22971332686281531\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19353308679026118\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16517678186023477\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18494570110040248\n", + "[False True False False False] [0.15688037457950896, 0.22971332686281531, 0.19353308679026118, 0.16517678186023477, 0.18494570110040248]\n", + "Loss\n", + "0.4483395642711436\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.83s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16426092427021902\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23546143800564748\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.95s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2018091494917266\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16300030321174439\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1890954905477386\n", + "[False True False False False] [0.16426092427021902, 0.23546143800564748, 0.2018091494917266, 0.16300030321174439, 0.1890954905477386]\n", + "Loss\n", + "0.44771820899202713\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:17, 4.47s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1923365522680751\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.39s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2636884118470859\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22437183772216968\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.32s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.19409481516899832\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.28s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21438196151887978\n", + "[False True False False False] [0.1923365522680751, 0.2636884118470859, 0.22437183772216968, 0.19409481516899832, 0.21438196151887978]\n", + "Loss\n", + "0.45155055004022043\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.11492336811997594\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:13, 4.35s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1769543777041838\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:13<00:08, 4.36s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14329726241838484\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:17<00:04, 4.28s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1253683557686221\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:21<00:00, 4.25s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.13551601413207848\n", + "[False True False False False] [0.11492336811997594, 0.1769543777041838, 0.14329726241838484, 0.1253683557686221, 0.13551601413207848]\n", + "Loss\n", + "0.4576367245464792\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17535908257057245\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:11, 3.98s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.24954425144400919\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.2215550931357295\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.12s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18630918133096866\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.19s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.21086873833013936\n", + "[False True False False False] [0.17535908257057245, 0.24954425144400919, 0.2215550931357295, 0.18630918133096866, 0.21086873833013936]\n", + "Loss\n", + "0.4548761477397937\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.13516804709239857\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:08<00:12, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18276614400405725\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:12<00:08, 4.26s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1491392288593184\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.19s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.13498626972116123\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.17s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.14118023922789544\n", + "[False True False False False] [0.13516804709239857, 0.18276614400405725, 0.1491392288593184, 0.13498626972116123, 0.14118023922789544]\n", + "Loss\n", + "0.46069615649572554\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.15163010110229141\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.22302587692034473\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.97s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.18389956611800104\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16018141836345046\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.17561662644909892\n", + "[False True False False False] [0.15163010110229141, 0.22302587692034473, 0.18389956611800104, 0.16018141836345046, 0.17561662644909892]\n", + "Loss\n", + "0.4471625689392103\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.16324456142641605\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.23167985026795024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pred label\n", + "0.1987531357092364\n" + ] + } + ], + "source": [ + "from sklearn.utils import shuffle\n", + "from sklearn.metrics import log_loss\n", + "import tqdm\n", + "\n", + "from scipy.optimize import minimize \n", + "\n", + "\n", + "def ansatz(num_qubits):\n", + " return RealAmplitudes(num_qubits, reps=5)\n", + "\n", + "#Function to identify a function cost\n", + "'''\n", + "Input: An array of parameters(vector of complex amplitudes)\n", + "Output: Function cost\n", + "'''\n", + "\n", + "def objective_function(params, images, labels, shots=1024, mini_batch=5, n_qubits=8):\n", + "\n", + " running_loss = 0\n", + "\n", + " images, labels = shuffle(images, labels, random_state=42)\n", + " \n", + " \n", + " y_pred = []\n", + "\n", + " #For each item of the trainig set\n", + " for i in tqdm.tqdm(range(mini_batch)):\n", + "\n", + " circuit, _ = encode_amplitud(images, i, n_qubits) #Create a inicial circuit\n", + " vqc = ansatz(n_qubits)\n", + "\n", + " vqc = vqc.assign_parameters(params)\n", + "\n", + " #Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", + " circuit_full = QuantumCircuit(n_qubits)\n", + " \n", + " qubits = list(range(n_qubits))\n", + " \n", + " circuit_full.append(circuit.to_instruction(), qubits)\n", + " circuit_full.append(vqc.to_instruction(), qubits)\n", + "\n", + " #Combine the initial circuit, the quantum variatinal circuit and the swap test\n", + " #For the initial circuit and QVC we start at the qubit size_reduce + 1\n", + " #For the swap test we start at the qubit 0\n", + "\n", + " #Execute the circuit in the qasm_simulator\n", + " histogram = simulate(circuit_full)\n", + "\n", + " pred_label = histogram_to_category(histogram)\n", + " \n", + " #print(histogram)\n", + " print(\"Pred label\")\n", + " print(pred_label)\n", + " \n", + " y_pred.append(pred_label)\n", + " \n", + " y_true = labels[:mini_batch]\n", + " \n", + "\n", + " loss = log_loss(y_true, y_pred)\n", + " \n", + " print(y_true, y_pred)\n", + " print(\"Loss\")\n", + " print(loss)\n", + " \n", + "\n", + " return loss\n", + "\n", + "n_qubits = 8\n", + "shots = 1024\n", + "mini_batch = 5\n", + "\n", + "vqc = ansatz(n_qubits)\n", + "initial_point = algorithm_globals.random.random(vqc.num_parameters)\n", + "\n", + "for i in range(1):\n", + " #Minimization of the objective_fucntion by a COBYLA method\n", + " minimum = minimize(objective_function, initial_point, args=(images, labels, shots, mini_batch, n_qubits), method='COBYLA', tol=1e-6)\n", + " params = minimum.x #Get the solution array\n", + " #Show the cost of the solution array\n", + " print(\"Cost: \", objective_function(params))\n", + " print(params)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "True False True \n", + "\n", + "0.7. 0.2. 0.8" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + }, + "vscode": { + "interpreter": { + "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 2358696919321f134b1959e29912eab9cf555d0c Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 05:12:42 +0000 Subject: [PATCH 03/10] Fixes --- part1_no_pca.ipynb | 448 ++- part2_with_pca.ipynb | 8670 ++++-------------------------------------- 2 files changed, 1249 insertions(+), 7869 deletions(-) diff --git a/part1_no_pca.ipynb b/part1_no_pca.ipynb index 108a556..7b40a6f 100644 --- a/part1_no_pca.ipynb +++ b/part1_no_pca.ipynb @@ -158,6 +158,78 @@ "plt.imshow(images[1100])" ] }, + { + "cell_type": "code", + "execution_count": 167, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.33333333, 0.66666667, 1. ])" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.preprocessing import KBinsDiscretizer\n", + "import numpy as np\n", + "\n", + "bins = np.linspace(0, 1, 4)\n", + "bins\n", + "#def " + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "63.75" + ] + }, + "execution_count": 165, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "255 / 4" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.0" + ] + }, + "execution_count": 164, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(images * 255).max()" + ] + }, { "cell_type": "code", "execution_count": 11, @@ -501,7 +573,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 197, "metadata": {}, "outputs": [ { @@ -515,7 +587,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -525,13 +597,20 @@ }, "output_type": "display_data" }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({1: 1033, 2: 1022})\n" + ] + }, { "data": { "text/plain": [ - "2.669391111109774e-35" + "1.7936362821808585e-34" ] }, - "execution_count": 146, + "execution_count": 197, "metadata": {}, "output_type": "execute_result" } @@ -589,7 +668,7 @@ " return image_rec\n", "\n", "\n", - "img = images[0]\n", + "img = images[500]\n", "\n", "img = np.array(img)\n", " \n", @@ -608,6 +687,8 @@ "\n", "plt.show()\n", "\n", + "print(count_gates(qc))\n", + "\n", "image_mse(img, image_rec)" ] }, @@ -633,7 +714,7 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": 196, "metadata": {}, "outputs": [ { @@ -642,14 +723,12 @@ "Counter({1: 1033, 2: 1022})" ] }, - "execution_count": 147, + "execution_count": 196, "metadata": {}, "output_type": "execute_result" } ], - "source": [ - "count_gates(qc)" - ] + "source": [] }, { "cell_type": "code", @@ -681,15 +760,15 @@ "source": [ "import tqdm\n", "\n", - "def run_part1(images, image_index, n_qubits=8):\n", + "def run_part1(image):\n", " #encode image into a circuit\n", - " circuit, decoder_params = encode_amplitude(images, image_index, n_qubits=n_qubits)\n", + " circuit, normalization_factor = encode(image)\n", "\n", " #simulate circuit\n", " histogram = simulate(circuit)\n", "\n", " #reconstruct the image\n", - " image_re = decode_amplitude(histogram, **decoder_params)\n", + " image_re = decode_amplitude(histogram, normalization_factor)\n", "\n", " return circuit,image_re\n", "\n", @@ -699,9 +778,9 @@ "mse=0\n", "gatecount=0\n", "\n", - "for i, data in tqdm.tqdm(enumerate(images)):\n", + "for i, image in tqdm.tqdm(enumerate(images)):\n", " #encode image into circuit\n", - " circuit, image_re =run_part1(images, i, n_qubits=8)\n", + " circuit, image_re =run_part1(image)\n", " \n", " #count the number of 2qubit gates used\n", " gatecount+=count_gates(circuit)[2]\n", @@ -709,7 +788,7 @@ " #calculate mse\n", " #print(images[i].shape)\n", " #print(image_re.shape)\n", - " mse+=image_mse(images[i],image_re)\n", + " mse+=image_mse(image,image_re)\n", " \n", "#fidelity of reconstruction\n", "f=1-mse\n", @@ -907,12 +986,347 @@ "histogram.keys()" ] }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.7853981633974483, 1.5707963267948966, 2.356194490192345, 3.141592653589793]" + ] + }, + "execution_count": 170, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bins = [\n", + " np.pi / 4,\n", + " np.pi / 2,\n", + " (3 / 4) * np.pi,\n", + " np.pi\n", + "]\n", + "\n", + "bins" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "np.linspace()" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 2 2 3]\n", + "4.123105625617661\n" + ] + }, + { + "data": { + "text/plain": [ + "array([0. , 0.48507125, 0.48507125, 0.72760688])" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "digitized = np.digitize([0.2, 1.76, 2.2, 3.0], bins)\n", + "\n", + "normalization_factor = np.sqrt(np.sum(digitized**2)) \n", + "\n", + "print(digitized)\n", + "print(normalization_factor)\n", + "digitized = digitized / normalization_factor\n", + "\n", + "digitized" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0. , 0.78539816, 1.57079633, 2.35619449, 3.14159265])" + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.linspace(0, np.pi, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Counter({2: 1})\n" + ] + }, + { + "data": { + "text/html": [ + "
            ┌────────────┐ ┌───┐┌───────────┐┌───┐\n",
+       "q_0: ─|0>───┤ Ry(2.5536) ├─┤ X ├┤ Ry(0.588) ├┤ X ├\n",
+       "          ┌─┴────────────┴┐└─┬─┘└───────────┘└─┬─┘\n",
+       "q_1: ─|0>─┤ R(2.1287,π/2) ├──■─────────────────■──\n",
+       "          └───────────────┘
" + ], + "text/plain": [ + " ┌────────────┐ ┌───┐┌───────────┐┌───┐\n", + "q_0: ─|0>───┤ Ry(2.5536) ├─┤ X ├┤ Ry(0.588) ├┤ X ├\n", + " ┌─┴────────────┴┐└─┬─┘└───────────┘└─┬─┘\n", + "q_1: ─|0>─┤ R(2.1287,π/2) ├──■─────────────────■──\n", + " └───────────────┘ " + ] + }, + "execution_count": 193, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc = QuantumCircuit(2)\n", + "qc.initialize(digitized)\n", + "\n", + "\n", + "print(count_gates(qc))\n", + "\n", + "qc.decompose().decompose().decompose().decompose().decompose().draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.125 0.25 0.375 0.5 0.625 0.75 0.875 1. ]\n", + "[0. 0. 0. 0. 0. 0.\n", + " 0. 0. 0.15294118 0.35294118 0.52941176 0.78431373\n", + " 0.51764706 0.23529412 0.25098039 0.3254902 0.71764706 0.76470588\n", + " 0.38039216 0.11372549]\n", + "[0 0 0 0 0 0 0 0 1 2 4 6 4 1 2 2 5 6 3 0]\n", + "(784,)\n", + "240\n", + "(1024,)\n", + "Counter({1: 1033, 2: 1022})\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "11.398437011639373" + ] + }, + "execution_count": 212, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit import QuantumCircuit\n", + "\n", + "AMPLITUDE_ENCODING_N_QUBITS = 10\n", + "IMAGE_SIZE = 28\n", + "COLOR_BUCKETS = 8\n", + "\n", + "def encode(image):\n", + " \n", + " image = image * 255\n", + " \n", + " bins = np.linspace(0, 1.0, COLOR_BUCKETS + 1)[1:]\n", + " \n", + " print(bins)\n", + " \n", + " image_vector = np.resize(image, IMAGE_SIZE * IMAGE_SIZE)\n", + " \n", + " print(image_vector[:20])\n", + " \n", + " image_vector = np.digitize(image_vector, bins)\n", + " \n", + " print(image_vector[:20])\n", + " \n", + " qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS)\n", + " \n", + " N = IMAGE_SIZE * IMAGE_SIZE\n", + " \n", + " zero_padding = 2 ** AMPLITUDE_ENCODING_N_QUBITS - N\n", + " \n", + " print(image_vector.shape)\n", + " print(zero_padding)\n", + " \n", + " image_vector = np.concatenate((image_vector, np.zeros(zero_padding)), axis=0)\n", + " \n", + " print(image_vector.shape)\n", + " \n", + " normalization_factor = np.sqrt(np.sum(image_vector**2)) \n", + " #Else we divide each value between the sum value above\n", + " image_vector /= normalization_factor\n", + "\n", + " ###########\n", + " qc.initialize(image_vector)\n", + " ##########\n", + " \n", + " for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2):\n", + " qc = qc.decompose()\n", + " \n", + " return qc, normalization_factor\n", + "\n", + "def decode(histogram, normalizaton_factor):\n", + " histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS)\n", + " for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS):\n", + " histogram_array[i] = histogram.get(i, 0)\n", + " root = np.sqrt(histogram_array)\n", + " \n", + " root = root * normalization_factor\n", + " \n", + " N = IMAGE_SIZE * IMAGE_SIZE\n", + " \n", + " image_rec = root[:N]\n", + " \n", + " image_rec = image_rec.reshape(28, 28)\n", + " \n", + " return image_rec\n", + "\n", + "\n", + "img = images[0]\n", + "\n", + "img = np.array(img)\n", + " \n", + "qc, normalization_factor = encode(img) \n", + "\n", + "print(count_gates(qc))\n", + "\n", + "histogram = simulate(qc)\n", + "\n", + "image_rec = decode(histogram, normalization_factor)\n", + "\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "\n", + "ax1.imshow(img)\n", + "\n", + "ax2.imshow(image_rec)\n", + "\n", + "plt.show()\n", + "\n", + "image_mse(img, image_rec)" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({2: 1})" + ] + }, + "execution_count": 190, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from https://stackoverflow.com/questions/42463172/how-to-perform-max-mean-pooling-on-a-2d-array-using-numpy\n", + "import numpy as np\n", + "def asStride(arr,sub_shape,stride):\n", + " '''Get a strided sub-matrices view of an ndarray.\n", + " See also skimage.util.shape.view_as_windows()\n", + " '''\n", + " s0,s1=arr.strides[:2]\n", + " m1,n1=arr.shape[:2]\n", + " m2,n2=sub_shape\n", + " view_shape=(1+(m1-m2)//stride[0],1+(n1-n2)//stride[1],m2,n2)+arr.shape[2:]\n", + " strides=(stride[0]*s0,stride[1]*s1,s0,s1)+arr.strides[2:]\n", + " subs=np.lib.stride_tricks.as_strided(arr,view_shape,strides=strides)\n", + " return subs\n", + "\n", + "def poolingOverlap(mat,ksize,stride=None,method='max',pad=False):\n", + " '''Overlapping pooling on 2D or 3D data.\n", + " : ndarray, input array to pool.\n", + " : tuple of 2, kernel size in (ky, kx).\n", + " : tuple of 2 or None, stride of pooling window.\n", + " If None, same as (non-overlapping pooling).\n", + " : str, 'max for max-pooling,\n", + " 'mean' for mean-pooling.\n", + " : bool, pad or not. If no pad, output has size\n", + " (n-f)//s+1, n being size, f being kernel size, s stride.\n", + " if pad, output has size ceil(n/s).\n", + " Return : pooled matrix.\n", + " '''\n", + "\n", + " m, n = mat.shape[:2]\n", + " ky,kx=ksize\n", + " if stride is None:\n", + " stride=(ky,kx)\n", + " sy,sx=stride\n", + "\n", + " _ceil=lambda x,y: int(np.ceil(x/float(y)))\n", + "\n", + " if pad:\n", + " ny=_ceil(m,sy)\n", + " nx=_ceil(n,sx)\n", + " size=((ny-1)*sy+ky, (nx-1)*sx+kx) + mat.shape[2:]\n", + " mat_pad=np.full(size,np.nan)\n", + " mat_pad[:m,:n,...]=mat\n", + " else:\n", + " mat_pad=mat[:(m-ky)//sy*sy+ky, :(n-kx)//sx*sx+kx, ...]\n", + "\n", + " view=asStride(mat_pad,ksize,stride)\n", + "\n", + " if method=='max':\n", + " result=np.nanmax(view,axis=(2,3))\n", + " else:\n", + " result=np.nanmean(view,axis=(2,3))\n", + "\n", + " return result" + ] }, { "cell_type": "code", diff --git a/part2_with_pca.ipynb b/part2_with_pca.ipynb index bd75312..e4ba4a3 100644 --- a/part2_with_pca.ipynb +++ b/part2_with_pca.ipynb @@ -91,7 +91,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -202,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -211,47 +211,18 @@ "\n", "#your submission\n", "\n", + "N_QUBITS_AMPLITUDE_ENCODING = 8\n", + "\n", "# Functions 'encode' and 'decode' are dummy.\n", - "def encode_amplitude(images, image_index, n_qubits, debug=False):\n", - " N_images = len(images)\n", + "def encode_amplitude(image, debug=False):\n", " # We have 28x28 images as input\n", " # - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\n", " # 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \n", " # into n_qubits (parametrized)\n", " \n", - " \n", - " # [apply PCA]\n", - " # Create an instance of PCA\n", - " pca = PCA(n_components=2**n_qubits)\n", - "\n", - " # Fit PCA on your 784-dimensional data\n", - " data = images.reshape(N_images, 28 * 28)\n", - " pca.fit(data)\n", - "\n", - " # Apply dimensionality reduction on your data\n", - " data_pca = pca.transform(data)\n", - "\n", - " image = images[image_index]\n", - " \n", - " if debug:\n", - " \n", - " print(\"Raw Image data\")\n", - " print(data[image_index][:5])\n", - " \n", - " image_pca = data_pca[image_index]\n", - " \n", - " min_ = image_pca.min()\n", - " \n", - " if debug:\n", - " print(\"Image PCA\")\n", - " print(image_pca[:5])\n", + " min_ = image.min()\n", "\n", - " \n", - " image_pca = image_pca - min_\n", - " \n", - " if debug:\n", - " print(\"Image PCA min_ removed\")\n", - " print(image_pca[:5])\n", + " image_pca = image - min_\n", " \n", " # [normalize]\n", " def normalize(row):\n", @@ -266,33 +237,17 @@ " \n", " image_pca_normalized, normalization_factor = normalize(image_pca)\n", " \n", - " if debug:\n", - " print(image.shape)\n", - "\n", - " print(image_pca_normalized.shape)\n", - "\n", - " print(np.sum(image_pca_normalized**2))\n", - " \n", " desired_state = image_pca_normalized\n", " \n", - " #print(np.round(desired_state, 3))\n", - " if debug:\n", - " print(\"PCA normalized\")\n", - " print(np.round(image_pca_normalized, 5)[:5])\n", - "\n", - " print(\"Squared PCA\")\n", - " print(np.round(desired_state ** 2, 5)[:5])\n", - " \n", " ##########\n", " # Amplitude Encoding\n", - " qc = QuantumCircuit(n_qubits)\n", + " qc = QuantumCircuit(N_QUBITS_AMPLITUDE_ENCODING)\n", " qc.initialize(desired_state)\n", " qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", "\n", " ##########\n", " \n", " decoder_params = dict(\n", - " pca=pca,\n", " min_=min_,\n", " normalization_factor=normalization_factor,\n", " n_qubits=n_qubits,\n", @@ -301,13 +256,13 @@ " \n", " return qc_decomposed, decoder_params\n", "\n", - "def run_part2(images, image_index, n_qubits):\n", + "def run_part2(image):\n", "\n", " #loade the quantum classifier circuit\n", " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", " \n", " #encode image into circuit\n", - " circuit, _ = encode_amplitude(images, image_index, n_qubits)\n", + " circuit, _ = encode_amplitude(image)\n", " \n", " #append with classifier circuit\n", " nq1 = circuit.width()\n", @@ -329,39 +284,40 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(,\n", - " 0.5323555582257801)" + "" ] }, - "execution_count": 7, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "run_part2(images, 0, 8)" + "encode_amplitude" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 15, "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "run_part2() missing 2 required positional arguments: 'image_index' and 'n_qubits'", + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'min'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[36], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m n\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mlen\u001b[39m(dataset)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m data \u001b[38;5;129;01min\u001b[39;00m dataset:\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m#run part 2\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m circuit,label\u001b[38;5;241m=\u001b[39m\u001b[43mrun_part2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mimage\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m#count the gate used in the circuit for score calculation\u001b[39;00m\n\u001b[1;32m 12\u001b[0m gatecount\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39mcount_gates(circuit)[\u001b[38;5;241m2\u001b[39m]\n", - "\u001b[0;31mTypeError\u001b[0m: run_part2() missing 2 required positional arguments: 'image_index' and 'n_qubits'" + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m n\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mlen\u001b[39m(dataset)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m data \u001b[38;5;129;01min\u001b[39;00m dataset:\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m#run part 2\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m circuit,label\u001b[38;5;241m=\u001b[39m\u001b[43mrun_part2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mimage\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m#count the gate used in the circuit for score calculation\u001b[39;00m\n\u001b[1;32m 12\u001b[0m gatecount\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39mcount_gates(circuit)[\u001b[38;5;241m2\u001b[39m]\n", + "Cell \u001b[0;32mIn[13], line 57\u001b[0m, in \u001b[0;36mrun_part2\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 54\u001b[0m classifier\u001b[38;5;241m=\u001b[39mqiskit\u001b[38;5;241m.\u001b[39mQuantumCircuit\u001b[38;5;241m.\u001b[39mfrom_qasm_file(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mquantum_classifier.qasm\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 56\u001b[0m \u001b[38;5;66;03m#encode image into circuit\u001b[39;00m\n\u001b[0;32m---> 57\u001b[0m circuit, _ \u001b[38;5;241m=\u001b[39m \u001b[43mencode_amplitude\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;66;03m#append with classifier circuit\u001b[39;00m\n\u001b[1;32m 60\u001b[0m nq1 \u001b[38;5;241m=\u001b[39m circuit\u001b[38;5;241m.\u001b[39mwidth()\n", + "Cell \u001b[0;32mIn[13], line 15\u001b[0m, in \u001b[0;36mencode_amplitude\u001b[0;34m(image, debug)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mencode_amplitude\u001b[39m(image, debug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[1;32m 10\u001b[0m \u001b[38;5;66;03m# We have 28x28 images as input\u001b[39;00m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m# - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;66;03m# 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# into n_qubits (parametrized)\u001b[39;00m\n\u001b[0;32m---> 15\u001b[0m min_ \u001b[38;5;241m=\u001b[39m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmin\u001b[49m()\n\u001b[1;32m 17\u001b[0m image_pca \u001b[38;5;241m=\u001b[39m image \u001b[38;5;241m-\u001b[39m min_\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# [normalize]\u001b[39;00m\n", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'min'" ] } ], @@ -474,26 +430,6 @@ "classifier.draw()" ] }, - { - "cell_type": "code", - "execution_count": 129, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ True, True, True, ..., False, False, False])" - ] - }, - "execution_count": 129, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "labels" - ] - }, { "cell_type": "code", "execution_count": null, @@ -503,163 +439,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:09<00:38, 9.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5886651262609048\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:29<00:46, 15.66s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.635555073783909\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:50<00:35, 17.92s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.6394353896795691\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [01:28<00:26, 26.20s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5571776351730213\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [01:40<00:00, 20.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.6313328175555944\n", - "[False True False False False] [0.5886651262609048, 0.635555073783909, 0.6394353896795691, 0.5571776351730213, 0.6313328175555944]\n", - "Loss\n", - "0.8348271641207405\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:10<00:40, 10.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5887672655465805\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:24<00:37, 12.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5887795315504828\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:52<00:38, 19.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5946188604607769\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [01:25<00:25, 25.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5478308104464287\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [01:58<00:00, 23.79s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.5954196131409886\n", - "[False True False False False] [0.5887672655465805, 0.5887795315504828, 0.5946188604607769, 0.5478308104464287, 0.5954196131409886]\n", - "Loss\n", - "0.8039661384001928\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:10<00:41, 10.46s/it]" + " 4%|▍ | 1/25 [00:03<01:24, 3.50s/it]" ] }, { @@ -667,14 +447,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.6042148860124525\n" + "0.22439816871034923 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:17<00:24, 8.26s/it]" + " 8%|▊ | 2/25 [00:07<01:20, 3.51s/it]" ] }, { @@ -682,14 +462,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5909436173541671\n" + "0.21170995251224078 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:52<00:41, 20.53s/it]" + " 12%|█▏ | 3/25 [00:10<01:17, 3.54s/it]" ] }, { @@ -697,14 +477,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5872112853515093\n" + "0.20662628224997392 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:11<00:19, 19.88s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" ] }, { @@ -712,14 +492,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.581567395202677\n" + "0.25445433121633726 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:19<00:00, 15.83s/it]\n" + " 20%|██ | 5/25 [00:17<01:10, 3.54s/it]" ] }, { @@ -727,17 +507,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5882434543551341\n", - "[False True False False False] [0.6042148860124525, 0.5909436173541671, 0.5872112853515093, 0.581567395202677, 0.5882434543551341]\n", - "Loss\n", - "0.8192600766547915\n" + "0.20667354912605257 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:23<01:35, 23.84s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.53s/it]" ] }, { @@ -745,14 +522,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.6482366557230557\n" + "0.1897896296762502 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [01:02<01:37, 32.62s/it]" + " 28%|██▊ | 7/25 [00:24<01:03, 3.52s/it]" ] }, { @@ -760,14 +537,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.629216034457888\n" + "0.2057015746555031 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [01:19<00:51, 25.67s/it]" + " 32%|███▏ | 8/25 [00:28<00:59, 3.52s/it]" ] }, { @@ -775,14 +552,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.6364463671356472\n" + "0.20449671568497396 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:38<00:22, 22.75s/it]" + " 36%|███▌ | 9/25 [00:31<00:56, 3.51s/it]" ] }, { @@ -790,14 +567,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5952576435570955\n" + "0.24551086370310526 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:50<00:00, 22.01s/it]\n" + " 40%|████ | 10/25 [00:35<00:52, 3.52s/it]" ] }, { @@ -805,17 +582,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.632391172474394\n", - "[False True False False False] [0.6482366557230557, 0.629216034457888, 0.6364463671356472, 0.5952576435570955, 0.632391172474394]\n", - "Loss\n", - "0.8850292328798368\n" + "0.2074080983684203 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:06<00:27, 6.85s/it]" + " 44%|████▍ | 11/25 [00:38<00:49, 3.52s/it]" ] }, { @@ -823,14 +597,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5560127547288942\n" + "0.21582851207990894 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:22<00:35, 11.79s/it]" + " 48%|████▊ | 12/25 [00:42<00:45, 3.52s/it]" ] }, { @@ -838,14 +612,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5301498216093532\n" + "0.22654322634275184 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:29<00:19, 9.99s/it]" + " 52%|█████▏ | 13/25 [00:45<00:42, 3.52s/it]" ] }, { @@ -853,14 +627,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5375805143537935\n" + "0.18209408638661978 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:39<00:09, 9.71s/it]" + " 56%|█████▌ | 14/25 [00:49<00:38, 3.54s/it]" ] }, { @@ -868,14 +642,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.506783527318943\n" + "0.20240314267513765 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:01<00:00, 12.32s/it]\n" + " 60%|██████ | 15/25 [00:52<00:35, 3.54s/it]" ] }, { @@ -883,17 +657,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.541118651861013\n", - "[False True False False False] [0.5560127547288942, 0.5301498216093532, 0.5375805143537935, 0.506783527318943, 0.541118651861013]\n", - "Loss\n", - "0.7407217215964954\n" + "0.22936205445425328 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:14<00:56, 14.02s/it]" + " 64%|██████▍ | 16/25 [00:56<00:31, 3.54s/it]" ] }, { @@ -901,14 +672,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5768871930688416\n" + "0.2699754101286921 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:20<00:28, 9.54s/it]" + " 68%|██████▊ | 17/25 [00:59<00:28, 3.54s/it]" ] }, { @@ -916,14 +687,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5497010069723379\n" + "0.21295420601122067 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:57<00:44, 22.18s/it]" + " 72%|███████▏ | 18/25 [01:03<00:24, 3.52s/it]" ] }, { @@ -931,14 +702,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5697864242327038\n" + "0.25320741377365946 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:11<00:18, 18.71s/it]" + " 76%|███████▌ | 19/25 [01:06<00:21, 3.52s/it]" ] }, { @@ -946,14 +717,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5322058577855764\n" + "0.25027978164215253 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:43<00:00, 20.73s/it]\n" + " 80%|████████ | 20/25 [01:10<00:17, 3.52s/it]" ] }, { @@ -961,17 +732,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5644241939997484\n", - "[False True False False False] [0.5768871930688416, 0.5497010069723379, 0.5697864242327038, 0.5322058577855764, 0.5644241939997484]\n", - "Loss\n", - "0.7785568217225514\n" + "0.21812988323654317 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:07<00:31, 7.85s/it]" + " 84%|████████▍ | 21/25 [01:13<00:14, 3.51s/it]" ] }, { @@ -979,14 +747,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5772392112104014\n" + "0.21376971638099182 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:23<00:38, 12.70s/it]" + " 88%|████████▊ | 22/25 [01:17<00:10, 3.51s/it]" ] }, { @@ -994,14 +762,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5537397226449562\n" + "0.21527802698413995 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:52<00:39, 19.78s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.51s/it]" ] }, { @@ -1009,14 +777,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5668504855390445\n" + "0.21257775126821837 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:00<00:15, 15.13s/it]" + " 96%|█████████▌| 24/25 [01:24<00:03, 3.53s/it]" ] }, { @@ -1024,14 +792,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.533056444679258\n" + "0.2108350723040899 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:38<00:00, 19.61s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.53s/it]\n" ] }, { @@ -1039,17 +807,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5653006066248942\n", - "[False True False False False] [0.5772392112104014, 0.5537397226449562, 0.5668504855390445, 0.533056444679258, 0.5653006066248942]\n", + "0.2175567325846446 False\n", + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 1 0 1 0 0] [0.22439816871034923, 0.21170995251224078, 0.20662628224997392, 0.25445433121633726, 0.20667354912605257, 0.1897896296762502, 0.2057015746555031, 0.20449671568497396, 0.24551086370310526, 0.2074080983684203, 0.21582851207990894, 0.22654322634275184, 0.18209408638661978, 0.20240314267513765, 0.22936205445425328, 0.2699754101286921, 0.21295420601122067, 0.25320741377365946, 0.25027978164215253, 0.21812988323654317, 0.21376971638099182, 0.21527802698413995, 0.21257775126821837, 0.2108350723040899, 0.2175567325846446]\n", "Loss\n", - "0.7766658063282734\n" + "0.5745100031491128\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:42<02:49, 42.27s/it]" + " 4%|▍ | 1/25 [00:03<01:23, 3.49s/it]" ] }, { @@ -1057,14 +827,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.46263282315096216\n" + "0.256399222775756 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:55<01:15, 25.11s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.52s/it]" ] }, { @@ -1072,14 +842,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4547075091520982\n" + "0.2522511254583919 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [01:23<00:53, 26.60s/it]" + " 12%|█▏ | 3/25 [00:10<01:17, 3.52s/it]" ] }, { @@ -1087,14 +857,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.45840960165281147\n" + "0.22699886538358147 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:30<00:18, 18.77s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" ] }, { @@ -1102,14 +872,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.44299854801015875\n" + "0.27895830430144714 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [02:07<00:00, 25.55s/it]\n" + " 20%|██ | 5/25 [00:17<01:10, 3.54s/it]" ] }, { @@ -1117,17 +887,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4588012765777399\n", - "[False True False False False] [0.46263282315096216, 0.4547075091520982, 0.45840960165281147, 0.44299854801015875, 0.4588012765777399]\n", - "Loss\n", - "0.6443152051419245\n" + "0.27200285489720577 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:28<01:52, 28.10s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.54s/it]" ] }, { @@ -1135,14 +902,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4451348060818319\n" + "0.2729102581282131 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:37<00:50, 16.86s/it]" + " 28%|██▊ | 7/25 [00:24<01:04, 3.56s/it]" ] }, { @@ -1150,14 +917,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.43285858454688086\n" + "0.2595648491949362 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [01:16<00:54, 27.06s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" ] }, { @@ -1165,14 +932,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4379326714344286\n" + "0.29628643240883934 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:36<00:24, 24.48s/it]" + " 36%|███▌ | 9/25 [00:31<00:57, 3.58s/it]" ] }, { @@ -1180,14 +947,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4289803397148101\n" + "0.29554996814920703 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [02:18<00:00, 27.76s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.57s/it]" ] }, { @@ -1195,17 +962,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4371584767496989\n", - "[False True False False False] [0.4451348060818319, 0.43285858454688086, 0.4379326714344286, 0.4289803397148101, 0.4371584767496989]\n", - "Loss\n", - "0.6275193474653809\n" + "0.26960990182632666 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:32<02:10, 32.68s/it]" + " 44%|████▍ | 11/25 [00:39<00:49, 3.56s/it]" ] }, { @@ -1213,14 +977,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5597488893554801\n" + "0.27770201252810756 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [01:07<01:42, 34.23s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.56s/it]" ] }, { @@ -1228,14 +992,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5398738773269588\n" + "0.3014902258350622 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [01:40<01:06, 33.40s/it]" + " 52%|█████▏ | 13/25 [00:46<00:42, 3.55s/it]" ] }, { @@ -1243,14 +1007,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5408618872182283\n" + "0.2395650310981694 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [02:01<00:28, 28.42s/it]" + " 56%|█████▌ | 14/25 [00:49<00:39, 3.55s/it]" ] }, { @@ -1258,14 +1022,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.571415618234901\n" + "0.23872871330654108 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [02:08<00:00, 25.79s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.54s/it]" ] }, { @@ -1273,17 +1037,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5552053951139723\n", - "[False True False False False] [0.5597488893554801, 0.5398738773269588, 0.5408618872182283, 0.571415618234901, 0.5552053951139723]\n", - "Loss\n", - "0.7745288506165932\n" + "0.28355292140538935 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:06<00:24, 6.21s/it]" + " 64%|██████▍ | 16/25 [00:56<00:31, 3.54s/it]" ] }, { @@ -1291,14 +1052,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3865351769054153\n" + "0.28880802552904417 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:44<01:15, 25.03s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.55s/it]" ] }, { @@ -1306,14 +1067,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3993995727392796\n" + "0.29439435327977337 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:57<00:38, 19.40s/it]" + " 72%|███████▏ | 18/25 [01:03<00:24, 3.54s/it]" ] }, { @@ -1321,14 +1082,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40966690819490065\n" + "0.2884215729214027 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:10<00:17, 17.01s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.55s/it]" ] }, { @@ -1336,14 +1097,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.38241319650500133\n" + "0.26214237472350965 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:18<00:00, 15.73s/it]\n" + " 80%|████████ | 20/25 [01:10<00:17, 3.53s/it]" ] }, { @@ -1351,17 +1112,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4065279130003209\n", - "[False True False False False] [0.3865351769054153, 0.3993995727392796, 0.40966690819490065, 0.38241319650500133, 0.4065279130003209]\n", - "Loss\n", - "0.5874388732831373\n" + "0.2535764189529114 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:44<02:58, 44.62s/it]" + " 84%|████████▍ | 21/25 [01:14<00:14, 3.54s/it]" ] }, { @@ -1369,14 +1127,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4621599262859051\n" + "0.2922011621858887 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [01:32<02:19, 46.48s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.55s/it]" ] }, { @@ -1384,14 +1142,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.462740104977792\n" + "0.2300621753768395 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [02:05<01:20, 40.26s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.56s/it]" ] }, { @@ -1399,14 +1157,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4673291779347078\n" + "0.2985209362922094 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [02:11<00:26, 26.90s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.56s/it]" ] }, { @@ -1414,14 +1172,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4568380575607388\n" + "0.26980845445291735 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [02:32<00:00, 30.51s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.55s/it]\n" ] }, { @@ -1429,17 +1187,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.46191207605713097\n", - "[False True False False False] [0.4621599262859051, 0.462740104977792, 0.4673291779347078, 0.4568380575607388, 0.46191207605713097]\n", + "0.2229926576056259 False\n", + "(2000,)\n", + "25\n", + "[0 0 1 0 1 0 1 0 1 1 0 0 1 1 0 1 1 0 0 0 0 0 1 0 0] [0.256399222775756, 0.2522511254583919, 0.22699886538358147, 0.27895830430144714, 0.27200285489720577, 0.2729102581282131, 0.2595648491949362, 0.29628643240883934, 0.29554996814920703, 0.26960990182632666, 0.27770201252810756, 0.3014902258350622, 0.2395650310981694, 0.23872871330654108, 0.28355292140538935, 0.28880802552904417, 0.29439435327977337, 0.2884215729214027, 0.26214237472350965, 0.2535764189529114, 0.2922011621858887, 0.2300621753768395, 0.2985209362922094, 0.26980845445291735, 0.2229926576056259]\n", "Loss\n", - "0.6501432893166127\n" + "0.7164196534818487\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:36<02:27, 36.77s/it]" + " 4%|▍ | 1/25 [00:03<01:24, 3.52s/it]" ] }, { @@ -1447,14 +1207,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.369807563371284\n" + "0.17181826212888904 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [01:12<01:48, 36.27s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.54s/it]" ] }, { @@ -1462,14 +1222,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3604028358611908\n" + "0.16375452807056995 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [01:44<01:08, 34.09s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.56s/it]" ] }, { @@ -1477,14 +1237,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3743517415311594\n" + "0.21299900819965478 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [02:24<00:36, 36.52s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" ] }, { @@ -1492,14 +1252,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3548900569465631\n" + "0.2278272620860801 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [02:42<00:00, 32.53s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.56s/it]" ] }, { @@ -1507,17 +1267,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36963326432027716\n", - "[False True False False False] [0.369807563371284, 0.3604028358611908, 0.3743517415311594, 0.3548900569465631, 0.36963326432027716]\n", - "Loss\n", - "0.5702035840667261\n" + "0.1888169279222505 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:45<03:01, 45.35s/it]" + " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" ] }, { @@ -1525,14 +1282,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35447136774987215\n" + "0.2482197101809898 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [01:08<01:36, 32.10s/it]" + " 28%|██▊ | 7/25 [00:24<01:03, 3.54s/it]" ] }, { @@ -1540,14 +1297,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.34929289364028476\n" + "0.15542771450935472 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [01:28<00:53, 26.81s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.56s/it]" ] }, { @@ -1555,14 +1312,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36052823098651654\n" + "0.20114162179223788 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:50<00:24, 24.67s/it]" + " 36%|███▌ | 9/25 [00:31<00:57, 3.57s/it]" ] }, { @@ -1570,14 +1327,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3508202147244561\n" + "0.17532790267608767 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [02:16<00:00, 27.36s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.57s/it]" ] }, { @@ -1585,17 +1342,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3614104100542209\n", - "[False True False False False] [0.35447136774987215, 0.34929289364028476, 0.36052823098651654, 0.3508202147244561, 0.3614104100542209]\n", - "Loss\n", - "0.5634363742402475\n" + "0.15710178726073862 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:18<01:13, 18.46s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.57s/it]" ] }, { @@ -1603,14 +1357,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.39427714536400554\n" + "0.19105020575020518 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:22<00:29, 9.99s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.57s/it]" ] }, { @@ -1618,14 +1372,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40283506366759403\n" + "0.20259934003924285 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:26<00:14, 7.30s/it]" + " 52%|█████▏ | 13/25 [00:46<00:42, 3.57s/it]" ] }, { @@ -1633,14 +1387,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4136467994413509\n" + "0.18765566460928884 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:30<00:06, 6.04s/it]" + " 56%|█████▌ | 14/25 [00:49<00:39, 3.55s/it]" ] }, { @@ -1648,14 +1402,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3967395644317901\n" + "0.1868390840132907 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:34<00:00, 6.98s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.56s/it]" ] }, { @@ -1663,17 +1417,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4136126662215701\n", - "[False True False False False] [0.39427714536400554, 0.40283506366759403, 0.4136467994413509, 0.3967395644317901, 0.4136126662215701]\n", - "Loss\n", - "0.5967149498371546\n" + "0.13791001881349174 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" + " 64%|██████▍ | 16/25 [00:56<00:31, 3.55s/it]" ] }, { @@ -1681,14 +1432,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.39342067246967344\n" + "0.17835326918675837 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.56s/it]" ] }, { @@ -1696,14 +1447,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.38444537959813646\n" + "0.17357667472036098 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + " 72%|███████▏ | 18/25 [01:03<00:24, 3.55s/it]" ] }, { @@ -1711,14 +1462,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.39539608562323136\n" + "0.17734696981974893 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.53s/it]" ] }, { @@ -1726,14 +1477,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.39195427344574146\n" + "0.16400438270433337 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + " 80%|████████ | 20/25 [01:10<00:17, 3.53s/it]" ] }, { @@ -1741,17 +1492,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3956931161690733\n", - "[False True False False False] [0.39342067246967344, 0.38444537959813646, 0.39539608562323136, 0.39195427344574146, 0.3956931161690733]\n", - "Loss\n", - "0.5920466715273044\n" + "0.16547798793189464 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.36s/it]" + " 84%|████████▍ | 21/25 [01:14<00:14, 3.54s/it]" ] }, { @@ -1759,14 +1507,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.38104219657932026\n" + "0.20236448913447921 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.57s/it]" ] }, { @@ -1774,14 +1522,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3921320250715751\n" + "0.17004337263866906 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.11s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.57s/it]" ] }, { @@ -1789,14 +1537,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4046609531724643\n" + "0.1759592510663209 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.55s/it]" ] }, { @@ -1804,14 +1552,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.38762670624458084\n" + "0.19861226650606195 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.55s/it]\n" ] }, { @@ -1819,17 +1567,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40698511859140374\n", - "[False True False False False] [0.38104219657932026, 0.3921320250715751, 0.4046609531724643, 0.38762670624458084, 0.40698511859140374]\n", + "0.20867643215519466 True\n", + "(2000,)\n", + "25\n", + "[0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 0 1 0 0 0 1 1 0 1] [0.17181826212888904, 0.16375452807056995, 0.21299900819965478, 0.2278272620860801, 0.1888169279222505, 0.2482197101809898, 0.15542771450935472, 0.20114162179223788, 0.17532790267608767, 0.15710178726073862, 0.19105020575020518, 0.20259934003924285, 0.18765566460928884, 0.1868390840132907, 0.13791001881349174, 0.17835326918675837, 0.17357667472036098, 0.17734696981974893, 0.16400438270433337, 0.16547798793189464, 0.20236448913447921, 0.17004337263866906, 0.1759592510663209, 0.19861226650606195, 0.20867643215519466]\n", "Loss\n", - "0.589489618883053\n" + "0.7230144877578292\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" + " 4%|▍ | 1/25 [00:03<01:25, 3.55s/it]" ] }, { @@ -1837,14 +1587,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4996597605950226\n" + "0.2849321652383916 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.56s/it]" ] }, { @@ -1852,14 +1602,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5045278759859043\n" + "0.20286386878482496 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.24s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.59s/it]" ] }, { @@ -1867,14 +1617,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.517634811070131\n" + "0.18633902093218147 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" + " 16%|█▌ | 4/25 [00:14<01:15, 3.60s/it]" ] }, { @@ -1882,14 +1632,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.510977376601686\n" + "0.21053467487391994 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.59s/it]" ] }, { @@ -1897,17 +1647,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.515357502904338\n", - "[False True False False False] [0.4996597605950226, 0.5045278759859043, 0.517634811070131, 0.510977376601686, 0.515357502904338]\n", - "Loss\n", - "0.7090686445661614\n" + "0.18639975433484018 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.04s/it]" + " 24%|██▍ | 6/25 [00:21<01:08, 3.59s/it]" ] }, { @@ -1915,14 +1662,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36977251990880994\n" + "0.2502934372689309 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" + " 28%|██▊ | 7/25 [00:25<01:04, 3.59s/it]" ] }, { @@ -1930,14 +1677,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36147405530262083\n" + "0.21012390184504182 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + " 32%|███▏ | 8/25 [00:28<01:01, 3.59s/it]" ] }, { @@ -1945,14 +1692,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.37869230113866714\n" + "0.2284541316446929 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" ] }, { @@ -1960,14 +1707,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.365291476047138\n" + "0.19507123612580993 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.60s/it]" ] }, { @@ -1975,17 +1722,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3750147421230764\n", - "[False True False False False] [0.36977251990880994, 0.36147405530262083, 0.37869230113866714, 0.365291476047138, 0.3750147421230764]\n", - "Loss\n", - "0.5759569810048877\n" + "0.1811484501087359 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.88s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.60s/it]" ] }, { @@ -1993,14 +1737,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32680673625873813\n" + "0.21189159271689423 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" + " 48%|████▊ | 12/25 [00:43<00:46, 3.57s/it]" ] }, { @@ -2008,14 +1752,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33371137066244666\n" + "0.21149326487536751 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + " 52%|█████▏ | 13/25 [00:46<00:43, 3.58s/it]" ] }, { @@ -2023,14 +1767,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3367996095435105\n" + "0.2190143224736442 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" + " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" ] }, { @@ -2038,14 +1782,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32727558593394374\n" + "0.1915135358184522 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" ] }, { @@ -2053,17 +1797,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33461044186072936\n", - "[False True False False False] [0.32680673625873813, 0.33371137066244666, 0.3367996095435105, 0.32727558593394374, 0.33461044186072936]\n", - "Loss\n", - "0.54153637176862\n" + "0.19504081439113843 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.97s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.59s/it]" ] }, { @@ -2071,14 +1812,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3234701932468214\n" + "0.17308093631776605 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.56s/it]" ] }, { @@ -2086,14 +1827,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33257161355609854\n" + "0.19591618595711896 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.57s/it]" ] }, { @@ -2101,14 +1842,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33269733586018124\n" + "0.2039485232365668 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + " 76%|███████▌ | 19/25 [01:08<00:21, 3.58s/it]" ] }, { @@ -2116,14 +1857,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3195218004572857\n" + "0.20780633132527676 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.59s/it]" ] }, { @@ -2131,17 +1872,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32716846681546863\n", - "[False True False False False] [0.3234701932468214, 0.33257161355609854, 0.33269733586018124, 0.3195218004572857, 0.32716846681546863]\n", - "Loss\n", - "0.5354820395810107\n" + "0.2152011273941204 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.16s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.59s/it]" ] }, { @@ -2149,14 +1887,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.34444524312447194\n" + "0.20830135308769465 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.28s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.59s/it]" ] }, { @@ -2164,14 +1902,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36561075691008915\n" + "0.21717094696311115 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.18s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.60s/it]" ] }, { @@ -2179,14 +1917,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35922770951871574\n" + "0.2037701141327782 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + " 96%|█████████▌| 24/25 [01:26<00:03, 3.62s/it]" ] }, { @@ -2194,14 +1932,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3460689832476736\n" + "0.23457062507336532 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.14s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.59s/it]\n" ] }, { @@ -2209,17 +1947,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3571977039326527\n", - "[False True False False False] [0.34444524312447194, 0.36561075691008915, 0.35922770951871574, 0.3460689832476736, 0.3571977039326527]\n", + "0.1871634794348724 False\n", + "(2000,)\n", + "25\n", + "[0 0 1 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0] [0.2849321652383916, 0.20286386878482496, 0.18633902093218147, 0.21053467487391994, 0.18639975433484018, 0.2502934372689309, 0.21012390184504182, 0.2284541316446929, 0.19507123612580993, 0.1811484501087359, 0.21189159271689423, 0.21149326487536751, 0.2190143224736442, 0.1915135358184522, 0.19504081439113843, 0.17308093631776605, 0.19591618595711896, 0.2039485232365668, 0.20780633132527676, 0.2152011273941204, 0.20830135308769465, 0.21717094696311115, 0.2037701141327782, 0.23457062507336532, 0.1871634794348724]\n", "Loss\n", - "0.5480424146812086\n" + "0.5240604799152201\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" + " 4%|▍ | 1/25 [00:03<01:24, 3.50s/it]" ] }, { @@ -2227,14 +1967,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3453488953479874\n" + "0.16283109679980393 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:11, 3.98s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.53s/it]" ] }, { @@ -2242,14 +1982,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35654940102551874\n" + "0.17946315734416562 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.57s/it]" ] }, { @@ -2257,14 +1997,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3619448910579684\n" + "0.17902537717587483 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.57s/it]" ] }, { @@ -2272,14 +2012,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.34170420934943124\n" + "0.177927062148211 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.58s/it]" ] }, { @@ -2287,17 +2027,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35126890433274877\n", - "[False True False False False] [0.3453488953479874, 0.35654940102551874, 0.3619448910579684, 0.34170420934943124, 0.35126890433274877]\n", - "Loss\n", - "0.5510207702825525\n" + "0.17831548679953227 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.56s/it]" ] }, { @@ -2305,14 +2042,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3647713870840714\n" + "0.17890148831251332 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + " 28%|██▊ | 7/25 [00:24<01:04, 3.57s/it]" ] }, { @@ -2320,14 +2057,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36560614980139516\n" + "0.15666123233254392 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.03s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" ] }, { @@ -2335,14 +2072,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3682028268650631\n" + "0.17031083698047703 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" ] }, { @@ -2350,14 +2087,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3595555571010323\n" + "0.17693175281842033 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.59s/it]" ] }, { @@ -2365,17 +2102,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3620355481422257\n", - "[False True False False False] [0.3647713870840714, 0.36560614980139516, 0.3682028268650631, 0.3595555571010323, 0.3620355481422257]\n", - "Loss\n", - "0.5628442849571667\n" + "0.17322400363874468 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.04s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" ] }, { @@ -2383,14 +2117,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3892840520675162\n" + "0.16535205548915363 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" ] }, { @@ -2398,14 +2132,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.37605453622898194\n" + "0.17397100045416 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + " 52%|█████▏ | 13/25 [00:46<00:43, 3.60s/it]" ] }, { @@ -2413,14 +2147,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3812519809230065\n" + "0.1711366132497 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" ] }, { @@ -2428,14 +2162,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.37211458149767584\n" + "0.1629396067087388 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" ] }, { @@ -2443,17 +2177,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.37345396223655525\n", - "[False True False False False] [0.3892840520675162, 0.37605453622898194, 0.3812519809230065, 0.37211458149767584, 0.37345396223655525]\n", - "Loss\n", - "0.5768264403028794\n" + "0.18534608849343184 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.50s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.58s/it]" ] }, { @@ -2461,14 +2192,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35791850804181075\n" + "0.18196742487737852 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.41s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" ] }, { @@ -2476,14 +2207,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.364168634936583\n" + "0.17560770823374847 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.24s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" ] }, { @@ -2491,14 +2222,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36032012091954607\n" + "0.1800520829574006 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.15s/it]" + " 76%|███████▌ | 19/25 [01:08<00:21, 3.58s/it]" ] }, { @@ -2506,14 +2237,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36177573409649627\n" + "0.2292491724142283 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.19s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" ] }, { @@ -2521,17 +2252,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36576078799916434\n", - "[False True False False False] [0.35791850804181075, 0.364168634936583, 0.36032012091954607, 0.36177573409649627, 0.36576078799916434]\n", - "Loss\n", - "0.5608720669060392\n" + "0.17924235043058903 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" ] }, { @@ -2539,14 +2267,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3431832952467062\n" + "0.15916901609947576 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.58s/it]" ] }, { @@ -2554,14 +2282,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33707057695817905\n" + "0.23686523193568162 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.95s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.58s/it]" ] }, { @@ -2569,14 +2297,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.34192862556595777\n" + "0.17340951170801105 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 4.00s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" ] }, { @@ -2584,14 +2312,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3452037684786383\n" + "0.17351662940742563 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" ] }, { @@ -2599,17 +2327,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3337238755315904\n", - "[False True False False False] [0.3431832952467062, 0.33707057695817905, 0.34192862556595777, 0.3452037684786383, 0.3337238755315904]\n", + "0.17709241668022432 False\n", + "(2000,)\n", + "25\n", + "[1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0] [0.16283109679980393, 0.17946315734416562, 0.17902537717587483, 0.177927062148211, 0.17831548679953227, 0.17890148831251332, 0.15666123233254392, 0.17031083698047703, 0.17693175281842033, 0.17322400363874468, 0.16535205548915363, 0.17397100045416, 0.1711366132497, 0.1629396067087388, 0.18534608849343184, 0.18196742487737852, 0.17560770823374847, 0.1800520829574006, 0.2292491724142283, 0.17924235043058903, 0.15916901609947576, 0.23686523193568162, 0.17340951170801105, 0.17351662940742563, 0.17709241668022432]\n", "Loss\n", - "0.5511474788959638\n" + "0.44762737596139124\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + " 4%|▍ | 1/25 [00:03<01:24, 3.53s/it]" ] }, { @@ -2617,14 +2347,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3599882716753128\n" + "0.19027154262146928 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.03s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.55s/it]" ] }, { @@ -2632,14 +2362,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.37418341045045944\n" + "0.20962204236631773 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.04s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.55s/it]" ] }, { @@ -2647,14 +2377,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.39012142277350087\n" + "0.28177562288287994 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" ] }, { @@ -2662,14 +2392,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3641264655497175\n" + "0.19151212284865304 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.55s/it]" ] }, { @@ -2677,17 +2407,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3842285651998308\n", - "[False True False False False] [0.3599882716753128, 0.37418341045045944, 0.39012142277350087, 0.3641264655497175, 0.3842285651998308]\n", - "Loss\n", - "0.5722816768941134\n" + "0.24613075884950736 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.20s/it]" + " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" ] }, { @@ -2695,14 +2422,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32575564218067277\n" + "0.19238845205677335 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.02s/it]" + " 28%|██▊ | 7/25 [00:24<01:03, 3.54s/it]" ] }, { @@ -2710,14 +2437,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3234549214313968\n" + "0.26809120605832 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.56s/it]" ] }, { @@ -2725,14 +2452,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31157891541518784\n" + "0.20421675819551724 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + " 36%|███▌ | 9/25 [00:31<00:56, 3.56s/it]" ] }, { @@ -2740,14 +2467,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3215313982088845\n" + "0.20163202738124741 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.55s/it]" ] }, { @@ -2755,17 +2482,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31111652194676515\n", - "[False True False False False] [0.32575564218067277, 0.3234549214313968, 0.31157891541518784, 0.3215313982088845, 0.31111652194676515]\n", - "Loss\n", - "0.5313626018856659\n" + "0.24085412614856774 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.15s/it]" + " 44%|████▍ | 11/25 [00:39<00:49, 3.55s/it]" ] }, { @@ -2773,14 +2497,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36618341319143793\n" + "0.1999475968263486 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.11s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.56s/it]" ] }, { @@ -2788,14 +2512,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35403768374256817\n" + "0.20513585840580348 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" + " 52%|█████▏ | 13/25 [00:46<00:42, 3.56s/it]" ] }, { @@ -2803,14 +2527,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3580666378367964\n" + "0.19699425811936974 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + " 56%|█████▌ | 14/25 [00:49<00:39, 3.55s/it]" ] }, { @@ -2818,14 +2542,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3596841034935682\n" + "0.20589457314655998 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.57s/it]" ] }, { @@ -2833,17 +2557,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35983296301858336\n", - "[False True False False False] [0.36618341319143793, 0.35403768374256817, 0.3580666378367964, 0.3596841034935682, 0.35983296301858336]\n", - "Loss\n", - "0.5658876274720608\n" + "0.21153540176323005 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.15s/it]" + " 64%|██████▍ | 16/25 [00:56<00:32, 3.58s/it]" ] }, { @@ -2851,14 +2572,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.37046282330133595\n" + "0.2288623745047924 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.59s/it]" ] }, { @@ -2866,14 +2587,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36354534731396443\n" + "0.18659184646813276 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" ] }, { @@ -2881,14 +2602,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3562040008146169\n" + "0.1962874183407712 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.00s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.57s/it]" ] }, { @@ -2896,14 +2617,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3450947303994383\n" + "0.21957569744189961 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.56s/it]" ] }, { @@ -2911,17 +2632,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35505625151372056\n", - "[False True False False False] [0.37046282330133595, 0.36354534731396443, 0.3562040008146169, 0.3450947303994383, 0.35505625151372056]\n", - "Loss\n", - "0.5553703680305133\n" + "0.19090653969907714 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.36s/it]" + " 84%|████████▍ | 21/25 [01:14<00:14, 3.56s/it]" ] }, { @@ -2929,14 +2647,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.380230262626159\n" + "0.24027825324295135 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.25s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.56s/it]" ] }, { @@ -2944,14 +2662,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3572119811646339\n" + "0.21908296241595637 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.16s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.56s/it]" ] }, { @@ -2959,14 +2677,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3666330119567727\n" + "0.19697209914420513 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.56s/it]" ] }, { @@ -2974,14 +2692,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36581121710098563\n" + "0.1974207146416112 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.56s/it]\n" ] }, { @@ -2989,17 +2707,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3557073242834386\n", - "[False True False False False] [0.380230262626159, 0.3572119811646339, 0.3666330119567727, 0.36581121710098563, 0.3557073242834386]\n", + "0.21221518631677777 False\n", + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0] [0.19027154262146928, 0.20962204236631773, 0.28177562288287994, 0.19151212284865304, 0.24613075884950736, 0.19238845205677335, 0.26809120605832, 0.20421675819551724, 0.20163202738124741, 0.24085412614856774, 0.1999475968263486, 0.20513585840580348, 0.19699425811936974, 0.20589457314655998, 0.21153540176323005, 0.2288623745047924, 0.18659184646813276, 0.1962874183407712, 0.21957569744189961, 0.19090653969907714, 0.24027825324295135, 0.21908296241595637, 0.19697209914420513, 0.1974207146416112, 0.21221518631677777]\n", "Loss\n", - "0.5719098419117892\n" + "0.4102339432755233\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.96s/it]" + " 4%|▍ | 1/25 [00:03<01:25, 3.54s/it]" ] }, { @@ -3007,14 +2727,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35663703753951137\n" + "0.13976598316592387 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.17s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.54s/it]" ] }, { @@ -3022,14 +2742,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3671983712448269\n" + "0.14929889397682605 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.28s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.56s/it]" ] }, { @@ -3037,14 +2757,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.362950488697297\n" + "0.1565241388058825 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.33s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" ] }, { @@ -3052,14 +2772,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3445507435196846\n" + "0.14138269381462773 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.22s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.56s/it]" ] }, { @@ -3067,17 +2787,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36209997701506685\n", - "[False True False False False] [0.35663703753951137, 0.3671983712448269, 0.362950488697297, 0.3445507435196846, 0.36209997701506685]\n", - "Loss\n", - "0.5531630580227895\n" + "0.1525756303547523 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.79s/it]" + " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" ] }, { @@ -3085,14 +2802,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5253693408521137\n" + "0.15437448321103872 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + " 28%|██▊ | 7/25 [00:24<01:03, 3.53s/it]" ] }, { @@ -3100,14 +2817,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5097793751568319\n" + "0.13952785230938694 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.54s/it]" ] }, { @@ -3115,14 +2832,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4956836188952259\n" + "0.1854102629494309 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" + " 36%|███▌ | 9/25 [00:31<00:56, 3.54s/it]" ] }, { @@ -3130,14 +2847,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.5269470541612721\n" + "0.15351414146270678 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.54s/it]" ] }, { @@ -3145,17 +2862,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.50573127974192\n", - "[False True False False False] [0.5253693408521137, 0.5097793751568319, 0.4956836188952259, 0.5269470541612721, 0.50573127974192]\n", - "Loss\n", - "0.7113541902666731\n" + "0.1558319525933675 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.17s/it]" + " 44%|████▍ | 11/25 [00:38<00:49, 3.55s/it]" ] }, { @@ -3163,14 +2877,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3298705057580248\n" + "0.15394353253559934 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.54s/it]" ] }, { @@ -3178,14 +2892,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31926947141501666\n" + "0.15490947487241205 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" + " 52%|█████▏ | 13/25 [00:45<00:42, 3.53s/it]" ] }, { @@ -3193,14 +2907,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.30957253741541224\n" + "0.15287928803693554 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + " 56%|█████▌ | 14/25 [00:49<00:38, 3.53s/it]" ] }, { @@ -3208,14 +2922,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32083012956424023\n" + "0.13171560682056738 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.53s/it]" ] }, { @@ -3223,17 +2937,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3107622980577531\n", - "[False True False False False] [0.3298705057580248, 0.31926947141501666, 0.30957253741541224, 0.32083012956424023, 0.3107622980577531]\n", - "Loss\n", - "0.5343003089108512\n" + "0.14866853215945944 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:18, 4.58s/it]" + " 64%|██████▍ | 16/25 [00:56<00:31, 3.53s/it]" ] }, { @@ -3241,14 +2952,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3404224718526728\n" + "0.13866207317245263 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.43s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.52s/it]" ] }, { @@ -3256,14 +2967,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33413301311722216\n" + "0.1480428283692804 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.27s/it]" + " 72%|███████▏ | 18/25 [01:03<00:24, 3.52s/it]" ] }, { @@ -3271,14 +2982,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32259945668290185\n" + "0.19427327391578808 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.18s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.52s/it]" ] }, { @@ -3286,14 +2997,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3386504392598052\n" + "0.19195532735089207 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.21s/it]\n" + " 80%|████████ | 20/25 [01:10<00:17, 3.53s/it]" ] }, { @@ -3301,17 +3012,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32620573227373484\n", - "[False True False False False] [0.3404224718526728, 0.33413301311722216, 0.32259945668290185, 0.3386504392598052, 0.32620573227373484]\n", - "Loss\n", - "0.542033522972876\n" + "0.15151222827976818 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + " 84%|████████▍ | 21/25 [01:14<00:14, 3.52s/it]" ] }, { @@ -3319,14 +3027,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31465886650351016\n" + "0.17434082568245562 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" + " 88%|████████▊ | 22/25 [01:17<00:10, 3.52s/it]" ] }, { @@ -3334,14 +3042,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.313194136481489\n" + "0.1837219423649988 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.51s/it]" ] }, { @@ -3349,14 +3057,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3094347573927366\n" + "0.16252735909388816 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" + " 96%|█████████▌| 24/25 [01:24<00:03, 3.51s/it]" ] }, { @@ -3364,14 +3072,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31398422454817443\n" + "0.16847295055273948 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.53s/it]\n" ] }, { @@ -3379,17 +3087,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3134184240371007\n", - "[False True False False False] [0.31465886650351016, 0.313194136481489, 0.3094347573927366, 0.31398422454817443, 0.3134184240371007]\n", + "0.1439717988649608 False\n", + "(2000,)\n", + "25\n", + "[1 0 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0] [0.13976598316592387, 0.14929889397682605, 0.1565241388058825, 0.14138269381462773, 0.1525756303547523, 0.15437448321103872, 0.13952785230938694, 0.1854102629494309, 0.15351414146270678, 0.1558319525933675, 0.15394353253559934, 0.15490947487241205, 0.15287928803693554, 0.13171560682056738, 0.14866853215945944, 0.13866207317245263, 0.1480428283692804, 0.19427327391578808, 0.19195532735089207, 0.15151222827976818, 0.17434082568245562, 0.1837219423649988, 0.16252735909388816, 0.16847295055273948, 0.1439717988649608]\n", "Loss\n", - "0.5323800615570604\n" + "0.6010824073288937\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" + " 4%|▍ | 1/25 [00:03<01:23, 3.49s/it]" ] }, { @@ -3397,14 +3107,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3262605359592778\n" + "0.2290374845241696 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + " 8%|▊ | 2/25 [00:07<01:20, 3.51s/it]" ] }, { @@ -3412,14 +3122,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32863458826144337\n" + "0.21279402705498196 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" + " 12%|█▏ | 3/25 [00:10<01:17, 3.53s/it]" ] }, { @@ -3427,14 +3137,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3154798430206206\n" + "0.21944909761014547 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + " 16%|█▌ | 4/25 [00:13<01:13, 3.49s/it]" ] }, { @@ -3442,14 +3152,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3190312243138961\n" + "0.22202924244267103 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.18s/it]\n" + " 20%|██ | 5/25 [00:17<01:10, 3.50s/it]" ] }, { @@ -3457,17 +3167,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31694323731027585\n", - "[False True False False False] [0.3262605359592778, 0.32863458826144337, 0.3154798430206206, 0.3190312243138961, 0.31694323731027585]\n", - "Loss\n", - "0.5304347881203599\n" + "0.21639627757978738 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.21s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.53s/it]" ] }, { @@ -3475,14 +3182,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33112149187993084\n" + "0.22388938293996102 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.19s/it]" + " 28%|██▊ | 7/25 [00:24<01:03, 3.54s/it]" ] }, { @@ -3490,14 +3197,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33983585700744806\n" + "0.2235139867948017 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.56s/it]" ] }, { @@ -3505,14 +3212,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3285797855473206\n" + "0.22304806251945988 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + " 36%|███▌ | 9/25 [00:31<00:57, 3.57s/it]" ] }, { @@ -3520,14 +3227,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32510684615992386\n" + "0.21753107614249736 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.56s/it]" ] }, { @@ -3535,17 +3242,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3306713221358046\n", - "[False True False False False] [0.33112149187993084, 0.33983585700744806, 0.3285797855473206, 0.32510684615992386, 0.3306713221358046]\n", - "Loss\n", - "0.5348972818955202\n" + "0.2211916872828005 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.90s/it]" + " 44%|████▍ | 11/25 [00:38<00:49, 3.54s/it]" ] }, { @@ -3553,14 +3257,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.35705771615661697\n" + "0.21853827953787885 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 4.00s/it]" + " 48%|████▊ | 12/25 [00:42<00:45, 3.53s/it]" ] }, { @@ -3568,14 +3272,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.36527590731511067\n" + "0.2150683397057167 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + " 52%|█████▏ | 13/25 [00:45<00:42, 3.55s/it]" ] }, { @@ -3583,14 +3287,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.356540437326691\n" + "0.22531481141953646 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" + " 56%|█████▌ | 14/25 [00:49<00:39, 3.57s/it]" ] }, { @@ -3598,14 +3302,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3561192545025821\n" + "0.22193533160155027 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.56s/it]" ] }, { @@ -3613,17 +3317,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3601914773928603\n", - "[False True False False False] [0.35705771615661697, 0.36527590731511067, 0.356540437326691, 0.3561192545025821, 0.3601914773928603]\n", - "Loss\n", - "0.5553053584501128\n" + "0.23527369179072966 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" + " 64%|██████▍ | 16/25 [00:56<00:32, 3.56s/it]" ] }, { @@ -3631,14 +3332,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.34129624291073557\n" + "0.21703384817356056 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.57s/it]" ] }, { @@ -3646,14 +3347,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.350291427853868\n" + "0.22310085102044613 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + " 72%|███████▏ | 18/25 [01:03<00:24, 3.56s/it]" ] }, { @@ -3661,14 +3362,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3348680926292176\n" + "0.21924366255549568 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.55s/it]" ] }, { @@ -3676,14 +3377,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.33567311343089773\n" + "0.2422156191724952 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 80%|████████ | 20/25 [01:10<00:17, 3.55s/it]" ] }, { @@ -3691,17 +3392,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3387169953277613\n", - "[False True False False False] [0.34129624291073557, 0.350291427853868, 0.3348680926292176, 0.33567311343089773, 0.3387169953277613]\n", - "Loss\n", - "0.5393590873314492\n" + "0.22333041943239412 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.12s/it]" + " 84%|████████▍ | 21/25 [01:14<00:14, 3.56s/it]" ] }, { @@ -3709,14 +3407,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40703263174577314\n" + "0.2235655911269626 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.33s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.55s/it]" ] }, { @@ -3724,14 +3422,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4198797818223454\n" + "0.2407504381991235 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.20s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.55s/it]" ] }, { @@ -3739,14 +3437,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40812784331116725\n" + "0.2092441949942492 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.16s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.55s/it]" ] }, { @@ -3754,14 +3452,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40768876702296214\n" + "0.2351955348801181 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.18s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.55s/it]\n" ] }, { @@ -3769,17 +3467,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4131723106263382\n", - "[False True False False False] [0.40703263174577314, 0.4198797818223454, 0.40812784331116725, 0.40768876702296214, 0.4131723106263382]\n", + "0.21699603182000732 False\n", + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0] [0.2290374845241696, 0.21279402705498196, 0.21944909761014547, 0.22202924244267103, 0.21639627757978738, 0.22388938293996102, 0.2235139867948017, 0.22304806251945988, 0.21753107614249736, 0.2211916872828005, 0.21853827953787885, 0.2150683397057167, 0.22531481141953646, 0.22193533160155027, 0.23527369179072966, 0.21703384817356056, 0.22310085102044613, 0.21924366255549568, 0.2422156191724952, 0.22333041943239412, 0.2235655911269626, 0.2407504381991235, 0.2092441949942492, 0.2351955348801181, 0.21699603182000732]\n", "Loss\n", - "0.5943228937501457\n" + "0.5017928449607514\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + " 4%|▍ | 1/25 [00:03<01:24, 3.50s/it]" ] }, { @@ -3787,14 +3487,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3242865716196675\n" + "0.1669627981584769 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.53s/it]" ] }, { @@ -3802,14 +3502,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3291540494747667\n" + "0.16135777113880967 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.55s/it]" ] }, { @@ -3817,14 +3517,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3156154982442203\n" + "0.1608723884276439 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.56s/it]" ] }, { @@ -3832,14 +3532,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31909371798695346\n" + "0.16541653885351726 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.55s/it]" ] }, { @@ -3847,17 +3547,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.319732614087155\n", - "[False True False False False] [0.3242865716196675, 0.3291540494747667, 0.3156154982442203, 0.31909371798695346, 0.319732614087155]\n", - "Loss\n", - "0.5304101887795788\n" + "0.17799513345024612 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" ] }, { @@ -3865,14 +3562,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32340582358371395\n" + "0.17278695935783053 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + " 28%|██▊ | 7/25 [00:24<01:03, 3.53s/it]" ] }, { @@ -3880,14 +3577,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32847261888998447\n" + "0.17574953364100315 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.02s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.55s/it]" ] }, { @@ -3895,14 +3592,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3158358137205245\n" + "0.1600886852678649 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + " 36%|███▌ | 9/25 [00:31<00:56, 3.56s/it]" ] }, { @@ -3910,14 +3607,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3187643438433877\n" + "0.15802741117911595 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.57s/it]" ] }, { @@ -3925,17 +3622,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3195264887368705\n", - "[False True False False False] [0.32340582358371395, 0.32847261888998447, 0.3158358137205245, 0.3187643438433877, 0.3195264887368705]\n", - "Loss\n", - "0.5304712298942121\n" + "0.17286932168773506 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.58s/it]" ] }, { @@ -3943,14 +3637,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3265460748233359\n" + "0.20233628996861266 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.58s/it]" ] }, { @@ -3958,14 +3652,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3292011715640585\n" + "0.16474206298388455 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" + " 52%|█████▏ | 13/25 [00:46<00:42, 3.58s/it]" ] }, { @@ -3973,14 +3667,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3158950764513984\n" + "0.167651185371576 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" + " 56%|█████▌ | 14/25 [00:49<00:39, 3.57s/it]" ] }, { @@ -3988,14 +3682,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3176448178250027\n" + "0.16633076716123038 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.11s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.57s/it]" ] }, { @@ -4003,17 +3697,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31848577466107064\n", - "[False True False False False] [0.3265460748233359, 0.3292011715640585, 0.3158950764513984, 0.3176448178250027, 0.31848577466107064]\n", - "Loss\n", - "0.5303418080399969\n" + "0.1602628789333549 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.89s/it]" + " 64%|██████▍ | 16/25 [00:56<00:32, 3.56s/it]" ] }, { @@ -4021,14 +3712,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32481400728222015\n" + "0.1851564387385181 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.56s/it]" ] }, { @@ -4036,14 +3727,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32998057031889644\n" + "0.19287988734206502 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.01s/it]" + " 72%|███████▏ | 18/25 [01:04<00:24, 3.55s/it]" ] }, { @@ -4051,14 +3742,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31533093720001554\n" + "0.16429284543018066 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.56s/it]" ] }, { @@ -4066,14 +3757,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3200331842970167\n" + "0.16906877672058565 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.55s/it]" ] }, { @@ -4081,17 +3772,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31905231103580034\n", - "[False True False False False] [0.32481400728222015, 0.32998057031889644, 0.31533093720001554, 0.3200331842970167, 0.31905231103580034]\n", - "Loss\n", - "0.5300578672175336\n" + "0.18603039154373505 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" + " 84%|████████▍ | 21/25 [01:14<00:14, 3.55s/it]" ] }, { @@ -4099,14 +3787,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32871194664038944\n" + "0.1682647706554944 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.55s/it]" ] }, { @@ -4114,14 +3802,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32909350065318643\n" + "0.2758763904739883 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + " 92%|█████████▏| 23/25 [01:21<00:07, 3.55s/it]" ] }, { @@ -4129,14 +3817,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31557926159626265\n" + "0.18467633058537877 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.55s/it]" ] }, { @@ -4144,14 +3832,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.320232346124385\n" + "0.1616071010625062 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + "100%|██████████| 25/25 [01:28<00:00, 3.56s/it]\n" ] }, { @@ -4159,17 +3847,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3205090545990064\n", - "[False True False False False] [0.32871194664038944, 0.32909350065318643, 0.31557926159626265, 0.320232346124385, 0.3205090545990064]\n", + "0.21630896490387616 False\n", + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1 0] [0.1669627981584769, 0.16135777113880967, 0.1608723884276439, 0.16541653885351726, 0.17799513345024612, 0.17278695935783053, 0.17574953364100315, 0.1600886852678649, 0.15802741117911595, 0.17286932168773506, 0.20233628996861266, 0.16474206298388455, 0.167651185371576, 0.16633076716123038, 0.1602628789333549, 0.1851564387385181, 0.19287988734206502, 0.16429284543018066, 0.16906877672058565, 0.18603039154373505, 0.1682647706554944, 0.2758763904739883, 0.18467633058537877, 0.1616071010625062, 0.21630896490387616]\n", "Loss\n", - "0.532313669586405\n" + "0.5751547187323194\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.90s/it]" + " 4%|▍ | 1/25 [00:03<01:23, 3.48s/it]" ] }, { @@ -4177,14 +3867,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3248907450598018\n" + "0.3065914597155552 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 4.00s/it]" + " 8%|▊ | 2/25 [00:07<01:20, 3.52s/it]" ] }, { @@ -4192,14 +3882,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3287184394667966\n" + "0.3385033446212355 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" + " 12%|█▏ | 3/25 [00:10<01:17, 3.54s/it]" ] }, { @@ -4207,14 +3897,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3153727172020793\n" + "0.3136335258664232 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" ] }, { @@ -4222,14 +3912,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3194819386190833\n" + "0.3478088322322282 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.56s/it]" ] }, { @@ -4237,17 +3927,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3201011522443733\n", - "[False True False False False] [0.3248907450598018, 0.3287184394667966, 0.3153727172020793, 0.3194819386190833, 0.3201011522443733]\n", - "Loss\n", - "0.5310054612691196\n" + "0.3111426195443546 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.54s/it]" ] }, { @@ -4255,14 +3942,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.326606106178247\n" + "0.34219527232081387 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + " 28%|██▊ | 7/25 [00:24<01:04, 3.57s/it]" ] }, { @@ -4270,14 +3957,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.32666862179464207\n" + "0.31006464319877014 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" ] }, { @@ -4285,14 +3972,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31418660056679093\n" + "0.32023282395212216 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" + " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" ] }, { @@ -4300,14 +3987,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3186760166843882\n" + "0.3150387357021503 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.58s/it]" ] }, { @@ -4315,17 +4002,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.3234238327135931\n", - "[False True False False False] [0.326606106178247, 0.32666862179464207, 0.31418660056679093, 0.3186760166843882, 0.3234238327135931]\n", - "Loss\n", - "0.5331622277336845\n" + "0.31109419281387185 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" ] }, { @@ -4333,14 +4017,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1586911031052453\n" + "0.3016909952465716 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.29s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" ] }, { @@ -4348,14 +4032,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1603507044082502\n" + "0.2916070075499417 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.39s/it]" + " 52%|█████▏ | 13/25 [00:46<00:43, 3.59s/it]" ] }, { @@ -4363,14 +4047,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.15466896821450166\n" + "0.3077913836860651 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.36s/it]" + " 56%|█████▌ | 14/25 [00:49<00:39, 3.58s/it]" ] }, { @@ -4378,14 +4062,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1636195451048787\n" + "0.31896798026679224 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.44s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.58s/it]" ] }, { @@ -4393,17 +4077,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.15367328258659857\n", - "[False True False False False] [0.1586911031052453, 0.1603507044082502, 0.15466896821450166, 0.1636195451048787, 0.15367328258659857]\n", - "Loss\n", - "0.5033473613858332\n" + "0.30003495303315864 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.40s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.59s/it]" ] }, { @@ -4411,14 +4092,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19456541439612654\n" + "0.3389951592634215 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.12s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" ] }, { @@ -4426,14 +4107,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19611534490711094\n" + "0.31825775754518576 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" ] }, { @@ -4441,14 +4122,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1930977637563495\n" + "0.4119127415225298 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + " 76%|███████▌ | 19/25 [01:07<00:21, 3.58s/it]" ] }, { @@ -4456,14 +4137,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.195803508495091\n" + "0.34397339053775255 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" ] }, { @@ -4471,17 +4152,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18933576689262593\n", - "[False True False False False] [0.19456541439612654, 0.19611534490711094, 0.1930977637563495, 0.195803508495091, 0.18933576689262593]\n", - "Loss\n", - "0.49755826484589527\n" + "0.30943064622322036 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.48s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" ] }, { @@ -4489,14 +4167,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40653866917610615\n" + "0.30687808920418336 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.24s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.58s/it]" ] }, { @@ -4504,14 +4182,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40446678837985467\n" + "0.30955035893907396 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.19s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.58s/it]" ] }, { @@ -4519,14 +4197,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40044409672318015\n" + "0.3110044710873081 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.14s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" ] }, { @@ -4534,14 +4212,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40508595643567213\n" + "0.307851803173844 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.22s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.57s/it]\n" ] }, { @@ -4549,17 +4227,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.40563651508012816\n", - "[False True False False False] [0.40653866917610615, 0.40446678837985467, 0.40044409672318015, 0.40508595643567213, 0.40563651508012816]\n", + "0.31755594842314844 False\n", + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 0 1 0 1 1 0 0] [0.3065914597155552, 0.3385033446212355, 0.3136335258664232, 0.3478088322322282, 0.3111426195443546, 0.34219527232081387, 0.31006464319877014, 0.32023282395212216, 0.3150387357021503, 0.31109419281387185, 0.3016909952465716, 0.2916070075499417, 0.3077913836860651, 0.31896798026679224, 0.30003495303315864, 0.3389951592634215, 0.31825775754518576, 0.4119127415225298, 0.34397339053775255, 0.30943064622322036, 0.30687808920418336, 0.30955035893907396, 0.3110044710873081, 0.307851803173844, 0.31755594842314844]\n", "Loss\n", - "0.595627499906749\n" + "0.576007284320459\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:18, 4.56s/it]" + " 4%|▍ | 1/25 [00:03<01:25, 3.55s/it]" ] }, { @@ -4567,14 +4247,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.25768491485836204\n" + "0.22879642476096165 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.20s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.56s/it]" ] }, { @@ -4582,14 +4262,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.2540129451382102\n" + "0.22343476916208238 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:13<00:08, 4.38s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.57s/it]" ] }, { @@ -4597,14 +4277,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.2582873584129265\n" + "0.21078758737690054 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.39s/it]" + " 16%|█▌ | 4/25 [00:14<01:15, 3.58s/it]" ] }, { @@ -4612,14 +4292,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.25597132598869543\n" + "0.2262680290164814 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.33s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.59s/it]" ] }, { @@ -4627,17 +4307,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.25360689744375614\n", - "[False True False False False] [0.25768491485836204, 0.2540129451382102, 0.2582873584129265, 0.25597132598869543, 0.25360689744375614]\n", - "Loss\n", - "0.5110646984723072\n" + "0.27399780427379344 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.56s/it]" ] }, { @@ -4645,14 +4322,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.16116584531648073\n" + "0.21505507840492866 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.42s/it]" + " 28%|██▊ | 7/25 [00:25<01:04, 3.57s/it]" ] }, { @@ -4660,14 +4337,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.15950538873915934\n" + "0.19953843070899113 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:13<00:08, 4.42s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.59s/it]" ] }, { @@ -4675,14 +4352,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1406148537778437\n" + "0.2048080362757129 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.26s/it]" + " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" ] }, { @@ -4690,14 +4367,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.16524271331231716\n" + "0.21645950450632437 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.24s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.59s/it]" ] }, { @@ -4705,17 +4382,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.14272278910281083\n", - "[False True False False False] [0.16116584531648073, 0.15950538873915934, 0.1406148537778437, 0.16524271331231716, 0.14272278910281083]\n", - "Loss\n", - "0.49951322863292197\n" + "0.21378271906551952 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.27s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.60s/it]" ] }, { @@ -4723,14 +4397,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1882961524220535\n" + "0.25721092304530624 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.08s/it]" + " 48%|████▊ | 12/25 [00:43<00:46, 3.60s/it]" ] }, { @@ -4738,14 +4412,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18647070359767837\n" + "0.2941010630624442 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.25s/it]" + " 52%|█████▏ | 13/25 [00:46<00:43, 3.60s/it]" ] }, { @@ -4753,14 +4427,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18146077341782085\n" + "0.22641181102452668 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.54s/it]" + " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" ] }, { @@ -4768,14 +4442,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18940455631721573\n" + "0.20154368047200416 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.42s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.57s/it]" ] }, { @@ -4783,17 +4457,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18023169554473892\n", - "[False True False False False] [0.1882961524220535, 0.18647070359767837, 0.18146077341782085, 0.18940455631721573, 0.18023169554473892]\n", - "Loss\n", - "0.4994109081710043\n" + "0.2414624007498712 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.83s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.58s/it]" ] }, { @@ -4801,14 +4472,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17669006580057361\n" + "0.22033721756045732 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + " 68%|██████▊ | 17/25 [01:01<00:28, 3.61s/it]" ] }, { @@ -4816,14 +4487,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18801156103552372\n" + "0.1977388959176667 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.61s/it]" ] }, { @@ -4831,14 +4502,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18194985083900964\n" + "0.22338082957192276 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" + " 76%|███████▌ | 19/25 [01:08<00:21, 3.61s/it]" ] }, { @@ -4846,14 +4517,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18627352494553656\n" + "0.20828153539528785 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" + " 80%|████████ | 20/25 [01:11<00:18, 3.60s/it]" ] }, { @@ -4861,17 +4532,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1802449488757163\n", - "[False True False False False] [0.17669006580057361, 0.18801156103552372, 0.18194985083900964, 0.18627352494553656, 0.1802449488757163]\n", - "Loss\n", - "0.4942773430984643\n" + "0.24963797271348281 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.30s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.60s/it]" ] }, { @@ -4879,14 +4547,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17464420138027842\n" + "0.21534957889516365 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.22s/it]" + " 88%|████████▊ | 22/25 [01:19<00:10, 3.60s/it]" ] }, { @@ -4894,14 +4562,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1823635451773762\n" + "0.2698777115415653 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.27s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.60s/it]" ] }, { @@ -4909,14 +4577,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1792534817790338\n" + "0.22121570148487193 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.40s/it]" + " 96%|█████████▌| 24/25 [01:26<00:03, 3.60s/it]" ] }, { @@ -4924,14 +4592,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18953482055863977\n" + "0.2782601344117515 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.32s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.59s/it]\n" ] }, { @@ -4939,17 +4607,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1787017018217077\n", - "[False True False False False] [0.17464420138027842, 0.1823635451773762, 0.1792534817790338, 0.18953482055863977, 0.1787017018217077]\n", + "0.29277509543021046 False\n", + "(2000,)\n", + "25\n", + "[0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0] [0.22879642476096165, 0.22343476916208238, 0.21078758737690054, 0.2262680290164814, 0.27399780427379344, 0.21505507840492866, 0.19953843070899113, 0.2048080362757129, 0.21645950450632437, 0.21378271906551952, 0.25721092304530624, 0.2941010630624442, 0.22641181102452668, 0.20154368047200416, 0.2414624007498712, 0.22033721756045732, 0.1977388959176667, 0.22338082957192276, 0.20828153539528785, 0.24963797271348281, 0.21534957889516365, 0.2698777115415653, 0.22121570148487193, 0.2782601344117515, 0.29277509543021046]\n", "Loss\n", - "0.4996501127094848\n" + "0.5364037669204643\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + " 4%|▍ | 1/25 [00:03<01:24, 3.51s/it]" ] }, { @@ -4957,14 +4627,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.09215641646032387\n" + "0.2247906184732505 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:12, 4.01s/it]" + " 8%|▊ | 2/25 [00:07<01:21, 3.56s/it]" ] }, { @@ -4972,14 +4642,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.10638044405544046\n" + "0.2344956934107105 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.59s/it]" ] }, { @@ -4987,14 +4657,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.09918136620973955\n" + "0.2382635908623606 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + " 16%|█▌ | 4/25 [00:14<01:15, 3.58s/it]" ] }, { @@ -5002,14 +4672,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.10685159743928796\n" + "0.2858845788778354 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.58s/it]" ] }, { @@ -5017,17 +4687,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.09532401790239671\n", - "[False True False False False] [0.09215641646032387, 0.10638044405544046, 0.09918136620973955, 0.10685159743928796, 0.09532401790239671]\n", - "Loss\n", - "0.5310097978651453\n" + "0.24417656000078722 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.39s/it]" + " 24%|██▍ | 6/25 [00:21<01:07, 3.55s/it]" ] }, { @@ -5035,14 +4702,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.201815006636465\n" + "0.23293600846648013 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" + " 28%|██▊ | 7/25 [00:24<01:04, 3.56s/it]" ] }, { @@ -5050,14 +4717,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.2040462006905253\n" + "0.2520125755038133 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" + " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" ] }, { @@ -5065,14 +4732,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19985765600210018\n" + "0.2440278637660495 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + " 36%|███▌ | 9/25 [00:32<00:57, 3.58s/it]" ] }, { @@ -5080,14 +4747,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.21338039408441703\n" + "0.22533837252887468 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.58s/it]" ] }, { @@ -5095,17 +4762,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19737938449725415\n", - "[False True False False False] [0.201815006636465, 0.2040462006905253, 0.19985765600210018, 0.21338039408441703, 0.19737938449725415]\n", - "Loss\n", - "0.49953459821608764\n" + "0.23202892840887043 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" ] }, { @@ -5113,14 +4777,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.11650565738928655\n" + "0.2202759509546124 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" ] }, { @@ -5128,14 +4792,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.12946639357451342\n" + "0.23909577416525488 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" + " 52%|█████▏ | 13/25 [00:46<00:43, 3.59s/it]" ] }, { @@ -5143,14 +4807,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.12926660532740697\n" + "0.2320268497296893 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" + " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" ] }, { @@ -5158,14 +4822,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.13440292782621474\n" + "0.23914645309069105 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.56s/it]" ] }, { @@ -5173,17 +4837,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1225823934268294\n", - "[False True False False False] [0.11650565738928655, 0.12946639357451342, 0.12926660532740697, 0.13440292782621474, 0.1225823934268294]\n", - "Loss\n", - "0.5163463496597933\n" + "0.2263393078800365 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.57s/it]" ] }, { @@ -5191,14 +4852,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17340724645214473\n" + "0.23520777326578143 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" ] }, { @@ -5206,14 +4867,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18361350383894307\n" + "0.23733945108303484 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.59s/it]" ] }, { @@ -5221,14 +4882,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18012642390945502\n" + "0.23891928306475807 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" + " 76%|███████▌ | 19/25 [01:08<00:21, 3.59s/it]" ] }, { @@ -5236,14 +4897,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18795666300333327\n" + "0.2542695750446766 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" ] }, { @@ -5251,17 +4912,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17771053999439795\n", - "[False True False False False] [0.17340724645214473, 0.18361350383894307, 0.18012642390945502, 0.18795666300333327, 0.17771053999439795]\n", - "Loss\n", - "0.4975669794308816\n" + "0.22910511440752088 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" ] }, { @@ -5269,14 +4927,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1417936680479085\n" + "0.23696975019728528 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.59s/it]" ] }, { @@ -5284,14 +4942,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.15101641082645642\n" + "0.22916612016786056 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.59s/it]" ] }, { @@ -5299,14 +4957,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.14444488640695924\n" + "0.22528578949711658 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" ] }, { @@ -5314,14 +4972,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.15524363101362676\n" + "0.22935665661004093 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" ] }, { @@ -5329,17 +4987,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.14128336180450804\n", - "[False True False False False] [0.1417936680479085, 0.15101641082645642, 0.14444488640695924, 0.15524363101362676, 0.14128336180450804]\n", + "0.23565582761214882 False\n", + "(2000,)\n", + "25\n", + "[1 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0] [0.2247906184732505, 0.2344956934107105, 0.2382635908623606, 0.2858845788778354, 0.24417656000078722, 0.23293600846648013, 0.2520125755038133, 0.2440278637660495, 0.22533837252887468, 0.23202892840887043, 0.2202759509546124, 0.23909577416525488, 0.2320268497296893, 0.23914645309069105, 0.2263393078800365, 0.23520777326578143, 0.23733945108303484, 0.23891928306475807, 0.2542695750446766, 0.22910511440752088, 0.23696975019728528, 0.22916612016786056, 0.22528578949711658, 0.22935665661004093, 0.23565582761214882]\n", "Loss\n", - "0.5040611119639709\n" + "0.6042893835670573\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" + " 4%|▍ | 1/25 [00:03<01:25, 3.56s/it]" ] }, { @@ -5347,14 +5007,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1972957783079646\n" + "0.2637363469413959 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" + " 8%|▊ | 2/25 [00:07<01:22, 3.57s/it]" ] }, { @@ -5362,14 +5022,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.2102958550612722\n" + "0.2789895274610281 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.58s/it]" ] }, { @@ -5377,14 +5037,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20631898355517297\n" + "0.2526705394466902 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" + " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" ] }, { @@ -5392,14 +5052,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.2075617692092128\n" + "0.25205469452098594 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" + " 20%|██ | 5/25 [00:17<01:11, 3.57s/it]" ] }, { @@ -5407,17 +5067,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19977565388267782\n", - "[False True False False False] [0.1972957783079646, 0.2102958550612722, 0.20631898355517297, 0.2075617692092128, 0.19977565388267782]\n", - "Loss\n", - "0.49311727960917506\n" + "0.259064033202045 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.83s/it]" + " 24%|██▍ | 6/25 [00:21<01:08, 3.58s/it]" ] }, { @@ -5425,14 +5082,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4135469673010354\n" + "0.2528640181989056 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" + " 28%|██▊ | 7/25 [00:25<01:04, 3.59s/it]" ] }, { @@ -5440,14 +5097,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4171409565310763\n" + "0.25400492028073757 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.01s/it]" + " 32%|███▏ | 8/25 [00:28<01:01, 3.59s/it]" ] }, { @@ -5455,14 +5112,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.4249977470332644\n" + "0.2655239233401808 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.12s/it]" + " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" ] }, { @@ -5470,14 +5127,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.41459461824209454\n" + "0.2562749533170576 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" + " 40%|████ | 10/25 [00:35<00:53, 3.60s/it]" ] }, { @@ -5485,17 +5142,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.42018389586472366\n", - "[False True False False False] [0.4135469673010354, 0.4171409565310763, 0.4249977470332644, 0.41459461824209454, 0.42018389586472366]\n", - "Loss\n", - "0.6083740205599146\n" + "0.2551470327797913 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" ] }, { @@ -5503,14 +5157,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18898071856613483\n" + "0.25562885572434846 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.19s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" ] }, { @@ -5518,14 +5172,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20178650795177006\n" + "0.26930184743227864 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.12s/it]" + " 52%|█████▏ | 13/25 [00:46<00:43, 3.60s/it]" ] }, { @@ -5533,14 +5187,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19871122516311057\n" + "0.2550102550835394 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" ] }, { @@ -5548,14 +5202,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20236531251586304\n" + "0.24633418446876987 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" ] }, { @@ -5563,17 +5217,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1944486900481864\n", - "[False True False False False] [0.18898071856613483, 0.20178650795177006, 0.19871122516311057, 0.20236531251586304, 0.1944486900481864]\n", - "Loss\n", - "0.49477506228073664\n" + "0.28915515135581704 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.24s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.59s/it]" ] }, { @@ -5581,14 +5232,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1695053857575129\n" + "0.2553754093563006 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.21s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" ] }, { @@ -5596,14 +5247,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17892798842950247\n" + "0.2515290044190871 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" ] }, { @@ -5611,14 +5262,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17905892556465808\n" + "0.2559475468627948 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" + " 76%|███████▌ | 19/25 [01:08<00:21, 3.59s/it]" ] }, { @@ -5626,14 +5277,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1817424417699664\n" + "0.27871002841931664 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" ] }, { @@ -5641,17 +5292,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1723103672591952\n", - "[False True False False False] [0.1695053857575129, 0.17892798842950247, 0.17905892556465808, 0.1817424417699664, 0.1723103672591952]\n", - "Loss\n", - "0.49870095928406577\n" + "0.28146164992251427 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 4.00s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" ] }, { @@ -5659,14 +5307,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19423455075123439\n" + "0.330852744166781 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.59s/it]" ] }, { @@ -5674,14 +5322,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.21074591208853713\n" + "0.2708598655695078 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.59s/it]" ] }, { @@ -5689,14 +5337,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20597244570074205\n" + "0.2647693350459092 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" + " 96%|█████████▌| 24/25 [01:26<00:03, 3.59s/it]" ] }, { @@ -5704,14 +5352,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20537371314477404\n" + "0.24790440024030994 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.12s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" ] }, { @@ -5719,32 +5367,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20230189923878059\n", - "[False True False False False] [0.19423455075123439, 0.21074591208853713, 0.20597244570074205, 0.20537371314477404, 0.20230189923878059]\n", + "0.2538188142799934 False\n", + "(2000,)\n", + "25\n", + "[0 0 0 0 1 0 1 0 0 0 0 0 1 1 0 1 0 1 0 0 0 1 0 1 0] [0.2637363469413959, 0.2789895274610281, 0.2526705394466902, 0.25205469452098594, 0.259064033202045, 0.2528640181989056, 0.25400492028073757, 0.2655239233401808, 0.2562749533170576, 0.2551470327797913, 0.25562885572434846, 0.26930184743227864, 0.2550102550835394, 0.24633418446876987, 0.28915515135581704, 0.2553754093563006, 0.2515290044190871, 0.2559475468627948, 0.27871002841931664, 0.28146164992251427, 0.330852744166781, 0.2708598655695078, 0.2647693350459092, 0.24790440024030994, 0.2538188142799934]\n", "Loss\n", - "0.49192204128145905\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16478111070485466\n" + "0.6488929366740943\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.17s/it]" + " 4%|▍ | 1/25 [00:03<01:25, 3.55s/it]" ] }, { @@ -5752,14 +5387,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19305715113404445\n" + "0.16905027713814144 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" + " 8%|▊ | 2/25 [00:07<01:22, 3.57s/it]" ] }, { @@ -5767,14 +5402,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1831520276123124\n" + "0.17084679309771103 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" + " 12%|█▏ | 3/25 [00:10<01:18, 3.57s/it]" ] }, { @@ -5782,14 +5417,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1734547911017242\n" + "0.17578660011127104 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" + " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" ] }, { @@ -5797,17 +5432,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1779399038607908\n", - "[False True False False False] [0.16478111070485466, 0.19305715113404445, 0.1831520276123124, 0.1734547911017242, 0.1779399038607908]\n", - "Loss\n", - "0.4827150364708753\n" + "0.1690150359735411 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:06<00:24, 6.01s/it]" + " 20%|██ | 5/25 [00:17<01:11, 3.57s/it]" ] }, { @@ -5815,14 +5447,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17426220796033037\n" + "0.16774151596276152 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:10<00:14, 4.93s/it]" + " 24%|██▍ | 6/25 [00:21<01:08, 3.58s/it]" ] }, { @@ -5830,14 +5462,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19926835362074374\n" + "0.16335366064724455 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:14<00:09, 4.68s/it]" + " 28%|██▊ | 7/25 [00:25<01:04, 3.59s/it]" ] }, { @@ -5845,14 +5477,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19506944859011405\n" + "0.16192626506639896 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:18<00:04, 4.53s/it]" + " 32%|███▏ | 8/25 [00:28<01:01, 3.59s/it]" ] }, { @@ -5860,14 +5492,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1916412255180296\n" + "0.17666922874269395 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.60s/it]\n" + " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" ] }, { @@ -5875,17 +5507,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1879461170955461\n", - "[False True False False False] [0.17426220796033037, 0.19926835362074374, 0.19506944859011405, 0.1916412255180296, 0.1879461170955461]\n", - "Loss\n", - "0.4885036003423431\n" + "0.19985647696604023 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.88s/it]" + " 40%|████ | 10/25 [00:35<00:53, 3.59s/it]" ] }, { @@ -5893,14 +5522,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1449201437966644\n" + "0.20352440278629041 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:12, 4.00s/it]" + " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" ] }, { @@ -5908,14 +5537,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.16872986609849405\n" + "0.17005482022574725 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.01s/it]" + " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" ] }, { @@ -5923,14 +5552,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.16261762775887556\n" + "0.16360587706632226 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" + " 52%|█████▏ | 13/25 [00:46<00:42, 3.57s/it]" ] }, { @@ -5938,14 +5567,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1541721077933156\n" + "0.16621715212502536 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" + " 56%|█████▌ | 14/25 [00:50<00:39, 3.58s/it]" ] }, { @@ -5953,17 +5582,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1545041674365591\n", - "[False True False False False] [0.1449201437966644, 0.16872986609849405, 0.16261762775887556, 0.1541721077933156, 0.1545041674365591]\n", - "Loss\n", - "0.48975251533887487\n" + "0.18987239657019428 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" + " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" ] }, { @@ -5971,14 +5597,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17635235222088622\n" + "0.2010654508430945 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:12<00:20, 6.79s/it]" + " 64%|██████▍ | 16/25 [00:57<00:32, 3.58s/it]" ] }, { @@ -5986,14 +5612,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20527328831024638\n" + "0.1759016679061598 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:27<00:20, 10.34s/it]" + " 68%|██████▊ | 17/25 [01:00<00:28, 3.59s/it]" ] }, { @@ -6001,14 +5627,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.1921235147475296\n" + "0.1656350060635573 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [01:00<00:19, 19.44s/it]" + " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" ] }, { @@ -6016,14 +5642,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18446752742692676\n" + "0.20791571461620273 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [01:13<00:00, 14.67s/it]\n" + " 76%|███████▌ | 19/25 [01:08<00:21, 3.58s/it]" ] }, { @@ -6031,17 +5657,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18893964578533953\n", - "[False True False False False] [0.17635235222088622, 0.20527328831024638, 0.1921235147475296, 0.18446752742692676, 0.18893964578533953]\n", - "Loss\n", - "0.48081969398971786\n" + "0.17182299826426808 True\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" + " 80%|████████ | 20/25 [01:11<00:17, 3.58s/it]" ] }, { @@ -6049,14 +5672,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.31188640594536243\n" + "0.26089912858327524 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:12, 4.00s/it]" + " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" ] }, { @@ -6064,14 +5687,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.341678387788547\n" + "0.17048448855018555 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" + " 88%|████████▊ | 22/25 [01:18<00:10, 3.56s/it]" ] }, { @@ -6079,14 +5702,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.20169116245498142\n" + "0.162252615456351 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.94s/it]" + " 92%|█████████▏| 23/25 [01:22<00:07, 3.57s/it]" ] }, { @@ -6094,14 +5717,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.19752377992244047\n" + "0.16571227063349506 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.96s/it]" + " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" ] }, { @@ -6109,14 +5732,14 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.17424756986272397\n" + "0.20604417553288668 False\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.96s/it]\n" + "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" ] }, { @@ -6124,6685 +5747,19 @@ "output_type": "stream", "text": [ "Pred label\n", - "0.18951400418096734\n", - "[False True False False False] [0.16843235064334472, 0.20169116245498142, 0.19752377992244047, 0.17424756986272397, 0.18951400418096734]\n", + "0.20198441492007618 False\n", + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 1 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0] [0.16905027713814144, 0.17084679309771103, 0.17578660011127104, 0.1690150359735411, 0.16774151596276152, 0.16335366064724455, 0.16192626506639896, 0.17666922874269395, 0.19985647696604023, 0.20352440278629041, 0.17005482022574725, 0.16360587706632226, 0.16621715212502536, 0.18987239657019428, 0.2010654508430945, 0.1759016679061598, 0.1656350060635573, 0.20791571461620273, 0.17182299826426808, 0.26089912858327524, 0.17048448855018555, 0.162252615456351, 0.16571227063349506, 0.20604417553288668, 0.20198441492007618]\n", "Loss\n", - "0.4814189641221791\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14750962920402982\n" + "0.7004560659948242\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18073174474779835\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17334272116239413\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15395933894288724\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16595273306975322\n", - "[False True False False False] [0.14750962920402982, 0.18073174474779835, 0.17334272116239413, 0.15395933894288724, 0.16595273306975322]\n", - "Loss\n", - "0.4818705862602416\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16836284109774297\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.89s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20477401638328838\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1988375547795738\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17368807762673932\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18791346902928172\n", - "[False True False False False] [0.16836284109774297, 0.20477401638328838, 0.1988375547795738, 0.17368807762673932, 0.18791346902928172]\n", - "Loss\n", - "0.4781660365673718\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15404079607222432\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16971417536574365\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16897229256060478\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15968621176119766\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1607720964721375\n", - "[False True False False False] [0.15404079607222432, 0.16971417536574365, 0.16897229256060478, 0.15968621176119766, 0.1607720964721375]\n", - "Loss\n", - "0.4950537470666626\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.18s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18000617424217522\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:11, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21586302805277205\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20882124642938857\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.22s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18396734527037326\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:23<00:00, 4.66s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20009126308491818\n", - "[False True False False False] [0.18000617424217522, 0.21586302805277205, 0.20882124642938857, 0.18396734527037326, 0.20009126308491818]\n", - "Loss\n", - "0.4784719132096679\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1444161711697637\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16899752430196321\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1681249441995779\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14827494385723208\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15739431204228935\n", - "[False True False False False] [0.1444161711697637, 0.16899752430196321, 0.1681249441995779, 0.14827494385723208, 0.15739431204228935]\n", - "Loss\n", - "0.48993262512537183\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1809336134352711\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21078702447408532\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20583482542732662\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1872619454486529\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.13s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19586762064078855\n", - "[False True False False False] [0.1809336134352711, 0.21078702447408532, 0.20583482542732662, 0.1872619454486529, 0.19586762064078855]\n", - "Loss\n", - "0.4824597518205711\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1574516375638041\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.20s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.195085630971131\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1870464583174152\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.12s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1663779982890453\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17814495512627423\n", - "[False True False False False] [0.1574516375638041, 0.195085630971131, 0.1870464583174152, 0.1663779982890453, 0.17814495512627423]\n", - "Loss\n", - "0.4781777345094718\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17723579988390972\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21129946823188195\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20351499280948304\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18011054719258146\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1956701334724591\n", - "[False True False False False] [0.17723579988390972, 0.21129946823188195, 0.20351499280948304, 0.18011054719258146, 0.1956701334724591]\n", - "Loss\n", - "0.4786886099635542\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.87s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.33401038785752807\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3829747128778231\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.37259835905184063\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.33496254536551\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3614299560786519\n", - "[False True False False False] [0.33401038785752807, 0.3829747128778231, 0.37259835905184063, 0.33496254536551, 0.3614299560786519]\n", - "Loss\n", - "0.5377743430885994\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16883212257405827\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20370306381206843\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19801149544886174\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17682443511450932\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19083960422276686\n", - "[False True False False False] [0.16883212257405827, 0.20370306381206843, 0.19801149544886174, 0.17682443511450932, 0.19083960422276686]\n", - "Loss\n", - "0.48060406020651636\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14989981649161485\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18196134596372215\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17416524929883342\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15630204033788964\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16623070397838788\n", - "[False True False False False] [0.14989981649161485, 0.18196134596372215, 0.17416524929883342, 0.15630204033788964, 0.16623070397838788]\n", - "Loss\n", - "0.48189638248590966\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17403583720436375\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.92s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20904819152162832\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20259439230089135\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18185719675882286\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19406670083731606\n", - "[False True False False False] [0.17403583720436375, 0.20904819152162832, 0.20259439230089135, 0.18185719675882286, 0.19406670083731606]\n", - "Loss\n", - "0.4798517706780444\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16080725312805222\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19311031539940196\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18743233862632105\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16697940442883025\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17769167371782735\n", - "[False True False False False] [0.16080725312805222, 0.19311031539940196, 0.18743233862632105, 0.16697940442883025, 0.17769167371782735]\n", - "Loss\n", - "0.48114028050844454\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.27s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17383446692338714\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20708302912504487\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20113579772326745\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.27s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17747043267851845\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.21s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1900993797953595\n", - "[False True False False False] [0.17383446692338714, 0.20708302912504487, 0.20113579772326745, 0.17747043267851845, 0.1900993797953595]\n", - "Loss\n", - "0.4792748935286079\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16998485239968067\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20433246326628968\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19696779785612678\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1753928099085578\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18841979829505043\n", - "[False True False False False] [0.16998485239968067, 0.20433246326628968, 0.19696779785612678, 0.1753928099085578, 0.18841979829505043]\n", - "Loss\n", - "0.4790597772638675\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17189690195748197\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20857761364120023\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20145096381074973\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17879722541486615\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1933327817867839\n", - "[False True False False False] [0.17189690195748197, 0.20857761364120023, 0.20145096381074973, 0.17879722541486615, 0.1933327817867839]\n", - "Loss\n", - "0.47856997197554796\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.88s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16954032036314767\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20583944374823307\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.16s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1993024342859389\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17468000591300167\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.37s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.190550987551769\n", - "[False True False False False] [0.16954032036314767, 0.20583944374823307, 0.1993024342859389, 0.17468000591300167, 0.190550987551769]\n", - "Loss\n", - "0.4784184557264945\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17282936400413026\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20871118283006404\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20165872525338283\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1776626263321877\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19365739703016666\n", - "[False True False False False] [0.17282936400413026, 0.20871118283006404, 0.20165872525338283, 0.1776626263321877, 0.19365739703016666]\n", - "Loss\n", - "0.478523673259459\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17125730233977066\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20688228727424368\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20036965319853803\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17685309196024887\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.03s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18981758940582819\n", - "[False True False False False] [0.17125730233977066, 0.20688228727424368, 0.20036965319853803, 0.17685309196024887, 0.18981758940582819]\n", - "Loss\n", - "0.47843460618368405\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17281467829429709\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20713210650239158\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2013069156468326\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.20s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17749338586517652\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1930444115544414\n", - "[False True False False False] [0.17281467829429709, 0.20713210650239158, 0.2013069156468326, 0.17749338586517652, 0.1930444115544414]\n", - "Loss\n", - "0.4797577890564364\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31372083525014977\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.34236370703901087\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:13<00:09, 4.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3332659966252576\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:18<00:04, 4.74s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31638675425204627\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:23<00:00, 4.64s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.33360165279935344\n", - "[False True False False False] [0.31372083525014977, 0.34236370703901087, 0.3332659966252576, 0.31638675425204627, 0.33360165279935344]\n", - "Loss\n", - "0.527989430481093\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:19<01:18, 19.70s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2379509285906789\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:27<00:37, 12.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.280829833380348\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:31<00:17, 8.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27054370100227987\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:35<00:07, 7.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24130510188405704\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:39<00:00, 8.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26494690556598244\n", - "[False True False False False] [0.2379509285906789, 0.280829833380348, 0.27054370100227987, 0.24130510188405704, 0.26494690556598244]\n", - "Loss\n", - "0.48823492397781665\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19816825224796725\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20212594376320436\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1994380002793589\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:22<00:06, 6.65s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19625096256442232\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:28<00:00, 5.61s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18934438883959168\n", - "[False True False False False] [0.19816825224796725, 0.20212594376320436, 0.1994380002793589, 0.19625096256442232, 0.18934438883959168]\n", - "Loss\n", - "0.49410844747547544\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:14<00:59, 14.89s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17949250929846358\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:24<00:35, 11.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21959569134776102\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:28<00:16, 8.37s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21119942137037248\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:32<00:06, 6.65s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18511093443246365\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:37<00:00, 7.45s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2024167302235697\n", - "[False True False False False] [0.17949250929846358, 0.21959569134776102, 0.21119942137037248, 0.18511093443246365, 0.2024167302235697]\n", - "Loss\n", - "0.4763826996652788\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3786751445900572\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.35s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.39825167740658374\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:13<00:09, 4.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.39619459264555107\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:20<00:05, 5.62s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3943446925068937\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:25<00:00, 5.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3990160433057032\n", - "[False True False False False] [0.3786751445900572, 0.39825167740658374, 0.39619459264555107, 0.3943446925068937, 0.3990160433057032]\n", - "Loss\n", - "0.5823413870208729\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14565795183344235\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.89s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18166344849858482\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17370511175773642\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15264460892256554\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16362443216272346\n", - "[False True False False False] [0.14565795183344235, 0.18166344849858482, 0.17370511175773642, 0.15264460892256554, 0.16362443216272346]\n", - "Loss\n", - "0.4796278594559869\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14917397635056373\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18553731565684128\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17220114278311924\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.18s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15922879359274938\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1670681096618819\n", - "[False True False False False] [0.14917397635056373, 0.18553731565684128, 0.17220114278311924, 0.15922879359274938, 0.1670681096618819]\n", - "Loss\n", - "0.4782542107117641\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2531976750793608\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2879308679593536\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2874439703208228\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25619315267569565\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27362799845717295\n", - "[False True False False False] [0.2531976750793608, 0.2879308679593536, 0.2874439703208228, 0.25619315267569565, 0.27362799845717295]\n", - "Loss\n", - "0.498310648726269\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19963001925994756\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24650096427630838\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:13<00:09, 4.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24529509619596918\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:18<00:04, 4.71s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21559694636088172\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.57s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2371650893460951\n", - "[False True False False False] [0.19963001925994756, 0.24650096427630838, 0.24529509619596918, 0.21559694636088172, 0.2371650893460951]\n", - "Loss\n", - "0.48360898990220125\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.23s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1624441295391298\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:09<00:13, 4.65s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19981199925703133\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:13<00:09, 4.62s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19398725972905742\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.44s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17534321616192552\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.42s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18601406111332058\n", - "[False True False False False] [0.1624441295391298, 0.19981199925703133, 0.19398725972905742, 0.17534321616192552, 0.18601406111332058]\n", - "Loss\n", - "0.48038031611474247\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.20s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17724936390940335\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19897462362820734\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1999462090576642\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.44s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17621442841609974\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.26s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18443932067575777\n", - "[False True False False False] [0.17724936390940335, 0.19897462362820734, 0.1999462090576642, 0.17621442841609974, 0.18443932067575777]\n", - "Loss\n", - "0.4860961757102301\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19807491806762328\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23982198723646628\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2275664994793589\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20191708931053107\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.05s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21959181830068353\n", - "[False True False False False] [0.19807491806762328, 0.23982198723646628, 0.2275664994793589, 0.20191708931053107, 0.21959181830068353]\n", - "Loss\n", - "0.47605775454792243\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19395451801589791\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2315725888715496\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21467084258950517\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19721020687734728\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2088953241654645\n", - "[False True False False False] [0.19395451801589791, 0.2315725888715496, 0.21467084258950517, 0.19721020687734728, 0.2088953241654645]\n", - "Loss\n", - "0.4748233415031894\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19110823724693135\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21893317525756512\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19293946070211643\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19590871243226382\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1921536650730935\n", - "[False True False False False] [0.19110823724693135, 0.21893317525756512, 0.19293946070211643, 0.19590871243226382, 0.1921536650730935]\n", - "Loss\n", - "0.4753722764437331\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20069304240931388\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2360823789317549\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22066259230305596\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2027414004329905\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:24<00:00, 5.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21414104899408193\n", - "[False True False False False] [0.20069304240931388, 0.2360823789317549, 0.22066259230305596, 0.2027414004329905, 0.21414104899408193]\n", - "Loss\n", - "0.47689000798275033\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:18<01:13, 18.26s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16428589387816944\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:31<00:45, 15.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19238207028262186\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:35<00:20, 10.18s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17460630783069336\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:39<00:07, 7.77s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16626171470713982\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:43<00:00, 8.72s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16922287625088447\n", - "[False True False False False] [0.16428589387816944, 0.19238207028262186, 0.17460630783069336, 0.16626171470713982, 0.16922287625088447]\n", - "Loss\n", - "0.4773729792970725\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:18, 4.66s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18190971161547514\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.40s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21806063092880357\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.22s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20372815658041715\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.187578324177676\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.20s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19663083320699667\n", - "[False True False False False] [0.18190971161547514, 0.21806063092880357, 0.20372815658041715, 0.187578324177676, 0.19663083320699667]\n", - "Loss\n", - "0.4756512094041387\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16617054725849195\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.92s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19903525917466794\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18052917015257147\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16575438044576254\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17347532683371444\n", - "[False True False False False] [0.16617054725849195, 0.19903525917466794, 0.18052917015257147, 0.16575438044576254, 0.17347532683371444]\n", - "Loss\n", - "0.47336981540262596\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16958054416429552\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1963235411344507\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18212367275126637\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1676565420679599\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.11s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17420564948995554\n", - "[False True False False False] [0.16958054416429552, 0.1963235411344507, 0.18212367275126637, 0.1676565420679599, 0.17420564948995554]\n", - "Loss\n", - "0.4779558722193169\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:18, 4.62s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16237966308600776\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.25s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18726088935864033\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17120457492837746\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15580579740974318\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1634543478465198\n", - "[False True False False False] [0.16237966308600776, 0.18726088935864033, 0.17120457492837746, 0.15580579740974318, 0.1634543478465198]\n", - "Loss\n", - "0.47761433383486407\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17577586669185416\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21062184681101992\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19013425487587415\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17357326408775056\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17986671450513733\n", - "[False True False False False] [0.17577586669185416, 0.21062184681101992, 0.19013425487587415, 0.17357326408775056, 0.17986671450513733]\n", - "Loss\n", - "0.47016458762593316\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16148802152182276\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19678887316162463\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17627049946684276\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15503558044881313\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17093052905558945\n", - "[False True False False False] [0.16148802152182276, 0.19678887316162463, 0.17627049946684276, 0.15503558044881313, 0.17093052905558945]\n", - "Loss\n", - "0.4703150824047212\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17734051640967324\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21478531803023335\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:14<00:09, 5.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19116741447957383\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:18<00:04, 4.70s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.174539506021326\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:30<00:00, 6.15s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18230919665212447\n", - "[False True False False False] [0.17734051640967324, 0.21478531803023335, 0.19116741447957383, 0.174539506021326, 0.18230919665212447]\n", - "Loss\n", - "0.46771547733616803\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:06<00:26, 6.73s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17925384028428967\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:10<00:15, 5.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21446999844840212\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:14<00:09, 4.62s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19204007490076555\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:18<00:04, 4.39s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17917274148691242\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18581688249082964\n", - "[False True False False False] [0.17925384028428967, 0.21446999844840212, 0.19204007490076555, 0.17917274148691242, 0.18581688249082964]\n", - "Loss\n", - "0.470676442467531\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17859643389557467\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2151315357661695\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18902925343697743\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17267343345391037\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18256549373760395\n", - "[False True False False False] [0.17859643389557467, 0.2151315357661695, 0.18902925343697743, 0.17267343345391037, 0.18256549373760395]\n", - "Loss\n", - "0.46678199020260225\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16485517592269344\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21668045518603712\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1865121256974214\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1679413716354515\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17559367120190147\n", - "[False True False False False] [0.16485517592269344, 0.21668045518603712, 0.1865121256974214, 0.1679413716354515, 0.17559367120190147]\n", - "Loss\n", - "0.458570015930444\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13540022929097087\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17815501281432897\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.27s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1511381664419089\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14082349392850305\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.25s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14016369598836217\n", - "[False True False False False] [0.13540022929097087, 0.17815501281432897, 0.1511381664419089, 0.14082349392850305, 0.14016369598836217]\n", - "Loss\n", - "0.46744856376401245\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.21s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19801023119313754\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.31s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.258258324285915\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.18s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2147948397690559\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20272204682646466\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.14s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21279791893028113\n", - "[False True False False False] [0.19801023119313754, 0.258258324285915, 0.2147948397690559, 0.20272204682646466, 0.21279791893028113]\n", - "Loss\n", - "0.4564173624833952\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20082041173885545\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.92s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2680057092303525\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22498237546087654\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20538477759221974\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2188919219882056\n", - "[False True False False False] [0.20082041173885545, 0.2680057092303525, 0.22498237546087654, 0.20538477759221974, 0.2188919219882056]\n", - "Loss\n", - "0.45454502587525597\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2253279314157279\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:12, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.30023847498435385\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25764733078107405\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22620276633529832\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2524890992420781\n", - "[False True False False False] [0.2253279314157279, 0.30023847498435385, 0.25764733078107405, 0.22620276633529832, 0.2524890992420781]\n", - "Loss\n", - "0.4607752671717014\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.33s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20470954780203882\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2680293933642416\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22700338934402037\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2108061949213992\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22464653423197448\n", - "[False True False False False] [0.20470954780203882, 0.2680293933642416, 0.22700338934402037, 0.2108061949213992, 0.22464653423197448]\n", - "Loss\n", - "0.45887334968450677\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19253510943491914\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24838702148146863\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20756302804497315\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1928484654004219\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.98s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20211498914833587\n", - "[False True False False False] [0.19253510943491914, 0.24838702148146863, 0.20756302804497315, 0.1928484654004219, 0.20211498914833587]\n", - "Loss\n", - "0.4558599663048767\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20942775905773278\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27537419474855357\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2303939380798518\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21180541726323981\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22929942754150978\n", - "[False True False False False] [0.20942775905773278, 0.27537419474855357, 0.2303939380798518, 0.21180541726323981, 0.22929942754150978]\n", - "Loss\n", - "0.4569929543495433\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.80s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21606815764587617\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2719436239262941\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24140394085591713\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22823687277887772\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2350773533396097\n", - "[False True False False False] [0.21606815764587617, 0.2719436239262941, 0.24140394085591713, 0.22823687277887772, 0.2350773533396097]\n", - "Loss\n", - "0.4697875427569306\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20728974381714343\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27254381757451074\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23153916795402835\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20941984854530948\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22638197305709362\n", - "[False True False False False] [0.20728974381714343, 0.27254381757451074, 0.23153916795402835, 0.20941984854530948, 0.22638197305709362]\n", - "Loss\n", - "0.4574568661832249\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16653111058918996\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.229936566333003\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1926814043939102\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1742031396761318\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.10s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18309912752749732\n", - "[False True False False False] [0.16653111058918996, 0.229936566333003, 0.1926814043939102, 0.1742031396761318, 0.18309912752749732]\n", - "Loss\n", - "0.4519583196064795\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16441380232673455\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23166643867147224\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1944394585747119\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17303798529112852\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18596797504306364\n", - "[False True False False False] [0.16441380232673455, 0.23166643867147224, 0.1944394585747119, 0.17303798529112852, 0.18596797504306364]\n", - "Loss\n", - "0.4508094960333707\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.152183095014405\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22351275731016698\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:13<00:09, 4.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18898909212523823\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.38s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1571284380675573\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.33s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17846713503064773\n", - "[False True False False False] [0.152183095014405, 0.22351275731016698, 0.18898909212523823, 0.1571284380675573, 0.17846713503064773]\n", - "Loss\n", - "0.4480750339046776\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.27s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14945984018534428\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.16s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21930612076510353\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18533995217883875\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.07s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15414989966933934\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1740219742309344\n", - "[False True False False False] [0.14945984018534428, 0.21930612076510353, 0.18533995217883875, 0.15414989966933934, 0.1740219742309344]\n", - "Loss\n", - "0.4485509930243447\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15000720090943015\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20509668942320192\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17283650100495357\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15238772444966983\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.06s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16595878030839994\n", - "[False True False False False] [0.15000720090943015, 0.20509668942320192, 0.17283650100495357, 0.15238772444966983, 0.16595878030839994]\n", - "Loss\n", - "0.4566716964825016\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15365919542591275\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2231393670279896\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18755767604027762\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.04s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15639426789391783\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.04s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17725188630213143\n", - "[False True False False False] [0.15365919542591275, 0.2231393670279896, 0.18755767604027762, 0.15639426789391783, 0.17725188630213143]\n", - "Loss\n", - "0.44793549386172415\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.159504901423437\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.16s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22697641713621802\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.193277692416323\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.06s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16099227388180398\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1821590124007243\n", - "[False True False False False] [0.159504901423437, 0.22697641713621802, 0.193277692416323, 0.16099227388180398, 0.1821590124007243]\n", - "Loss\n", - "0.44961436104121555\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.14s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1631367212849207\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:11, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23596529880817044\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20254349523642512\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:03, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16600129844012734\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1896119446260616\n", - "[False True False False False] [0.1631367212849207, 0.23596529880817044, 0.20254349523642512, 0.16600129844012734, 0.1896119446260616]\n", - "Loss\n", - "0.44805171529922044\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1412007583018143\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20702839675307075\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17254882256007445\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1471797787842289\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1625635408872719\n", - "[False True False False False] [0.1412007583018143, 0.20702839675307075, 0.17254882256007445, 0.1471797787842289, 0.1625635408872719]\n", - "Loss\n", - "0.4506281968831609\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14530131289927506\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.90s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20910925284872797\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17225540320312704\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15017295207140438\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16275105235836976\n", - "[False True False False False] [0.14530131289927506, 0.20910925284872797, 0.17225540320312704, 0.15017295207140438, 0.16275105235836976]\n", - "Loss\n", - "0.450262317042584\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.79s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23148359917911857\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3193913483173988\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.28196555163942005\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22861224907314912\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2720867697242496\n", - "[False True False False False] [0.23148359917911857, 0.3193913483173988, 0.28196555163942005, 0.22861224907314912, 0.2720867697242496]\n", - "Loss\n", - "0.4626013556085006\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15177267479781925\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22589046247367844\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18979416026111554\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15935640859734962\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18030372346900722\n", - "[False True False False False] [0.15177267479781925, 0.22589046247367844, 0.18979416026111554, 0.15935640859734962, 0.18030372346900722]\n", - "Loss\n", - "0.44703750520272945\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.29s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19321116066275196\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.11s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2716511536821668\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.08s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23946659382880997\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.05s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1982400972110423\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.08s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22597178026609224\n", - "[False True False False False] [0.19321116066275196, 0.2716511536821668, 0.23946659382880997, 0.1982400972110423, 0.22597178026609224]\n", - "Loss\n", - "0.4537516284844726\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15483309098171782\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22490456124504515\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19133787569402877\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1637091037204444\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.99s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18071728449405325\n", - "[False True False False False] [0.15483309098171782, 0.22490456124504515, 0.19133787569402877, 0.1637091037204444, 0.18071728449405325]\n", - "Loss\n", - "0.4501558406034828\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16025358177169488\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:12, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22913960860204596\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.17s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19165618618423455\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.16s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16863362624345404\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.14s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.184841699026096\n", - "[False True False False False] [0.16025358177169488, 0.22913960860204596, 0.19165618618423455, 0.16863362624345404, 0.184841699026096]\n", - "Loss\n", - "0.4499809159640377\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:18, 4.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1511538325843545\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.13s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2205029325368996\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.12s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.185506100488104\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.14s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15754614047021856\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.15s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1774950086094271\n", - "[False True False False False] [0.1511538325843545, 0.2205029325368996, 0.185506100488104, 0.15754614047021856, 0.1774950086094271]\n", - "Loss\n", - "0.4495494078962703\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.84s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1332951681833524\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19023018650236626\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16232711703650915\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1359754088619265\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.01s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14925019783153481\n", - "[False True False False False] [0.1332951681833524, 0.19023018650236626, 0.16232711703650915, 0.1359754088619265, 0.14925019783153481]\n", - "Loss\n", - "0.45749921920409\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.36s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1547811546371251\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2258891578846073\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.09s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19155038742274313\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.161916642421967\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:30<00:00, 6.07s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18216403314042096\n", - "[False True False False False] [0.1547811546371251, 0.2258891578846073, 0.19155038742274313, 0.161916642421967, 0.18216403314042096]\n", - "Loss\n", - "0.4492477351659992\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:06<00:24, 6.10s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16225406314043886\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:10<00:14, 4.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2317979217699585\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:14<00:09, 4.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19665290106834743\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:18<00:04, 4.34s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16520741426639635\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:22<00:00, 4.46s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18714962339631738\n", - "[False True False False False] [0.16225406314043886, 0.2317979217699585, 0.19665290106834743, 0.16520741426639635, 0.18714962339631738]\n", - "Loss\n", - "0.449135666436477\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1514633505841626\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.89s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22051349443907217\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1892364051418256\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15881962642661052\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17886470222454687\n", - "[False True False False False] [0.1514633505841626, 0.22051349443907217, 0.1892364051418256, 0.15881962642661052, 0.17886470222454687]\n", - "Loss\n", - "0.4511667416241966\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.82s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1558064792142228\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2170687963499356\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18445803795108023\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:04, 4.01s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1567162308915782\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17526588680263117\n", - "[False True False False False] [0.1558064792142228, 0.2170687963499356, 0.18445803795108023, 0.1567162308915782, 0.17526588680263117]\n", - "Loss\n", - "0.4527925712361839\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1527566561102167\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.88s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22338166618374417\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.94s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19005471647397273\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1599421583046078\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.96s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1797411142678577\n", - "[False True False False False] [0.1527566561102167, 0.22338166618374417, 0.19005471647397273, 0.1599421583046078, 0.1797411142678577]\n", - "Loss\n", - "0.4495698353979913\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.81s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15640367414271006\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22625881572092493\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19335620207283158\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.15s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1588710402845297\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.09s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1813576631403355\n", - "[False True False False False] [0.15640367414271006, 0.22625881572092493, 0.19335620207283158, 0.1588710402845297, 0.1813576631403355]\n", - "Loss\n", - "0.44882966088302584\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15688037457950896\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.96s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22971332686281531\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:08, 4.00s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19353308679026118\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16517678186023477\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.00s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18494570110040248\n", - "[False True False False False] [0.15688037457950896, 0.22971332686281531, 0.19353308679026118, 0.16517678186023477, 0.18494570110040248]\n", - "Loss\n", - "0.4483395642711436\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.83s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16426092427021902\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.91s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23546143800564748\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.95s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2018091494917266\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:15<00:03, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16300030321174439\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:19<00:00, 3.97s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1890954905477386\n", - "[False True False False False] [0.16426092427021902, 0.23546143800564748, 0.2018091494917266, 0.16300030321174439, 0.1890954905477386]\n", - "Loss\n", - "0.44771820899202713\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:17, 4.47s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1923365522680751\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.39s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2636884118470859\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.26s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22437183772216968\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.32s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19409481516899832\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.28s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21438196151887978\n", - "[False True False False False] [0.1923365522680751, 0.2636884118470859, 0.22437183772216968, 0.19409481516899832, 0.21438196151887978]\n", - "Loss\n", - "0.45155055004022043\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.11492336811997594\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:13, 4.35s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1769543777041838\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:13<00:08, 4.36s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14329726241838484\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:17<00:04, 4.28s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1253683557686221\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:21<00:00, 4.25s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13551601413207848\n", - "[False True False False False] [0.11492336811997594, 0.1769543777041838, 0.14329726241838484, 0.1253683557686221, 0.13551601413207848]\n", - "Loss\n", - "0.4576367245464792\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17535908257057245\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:11, 3.98s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24954425144400919\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2215550931357295\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.12s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18630918133096866\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.19s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21086873833013936\n", - "[False True False False False] [0.17535908257057245, 0.24954425144400919, 0.2215550931357295, 0.18630918133096866, 0.21086873833013936]\n", - "Loss\n", - "0.4548761477397937\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13516804709239857\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:08<00:12, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18276614400405725\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:12<00:08, 4.26s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1491392288593184\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.19s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13498626972116123\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.17s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14118023922789544\n", - "[False True False False False] [0.13516804709239857, 0.18276614400405725, 0.1491392288593184, 0.13498626972116123, 0.14118023922789544]\n", - "Loss\n", - "0.46069615649572554\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:04<00:16, 4.02s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15163010110229141\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22302587692034473\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.97s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18389956611800104\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 4/5 [00:16<00:04, 4.03s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16018141836345046\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 5/5 [00:20<00:00, 4.02s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17561662644909892\n", - "[False True False False False] [0.15163010110229141, 0.22302587692034473, 0.18389956611800104, 0.16018141836345046, 0.17561662644909892]\n", - "Loss\n", - "0.4471625689392103\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 1/5 [00:03<00:15, 3.86s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16324456142641605\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 2/5 [00:07<00:11, 3.93s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23167985026795024\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 3/5 [00:11<00:07, 3.99s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1987531357092364\n" + " 0%| | 0/25 [00:00 Date: Sun, 29 Jan 2023 05:52:17 +0000 Subject: [PATCH 04/10] Fixes and exploration with 4 qubits PCA --- part1_with_pca.ipynb | 255 +++++++++++++++++++++++++++++++++++++++---- part2_with_pca.ipynb | 4 +- 2 files changed, 239 insertions(+), 20 deletions(-) diff --git a/part1_with_pca.ipynb b/part1_with_pca.ipynb index 12f0618..585b2da 100644 --- a/part1_with_pca.ipynb +++ b/part1_with_pca.ipynb @@ -367,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 70, "metadata": {}, "outputs": [ { @@ -382,22 +382,22 @@ "Image PCA min_ removed\n", "[0. 0.00930002 0.02270273 0.00663033 0.01194021]\n", "(28, 28)\n", - "(256,)\n", - "1.0\n", + "(64,)\n", + "0.9999999999999998\n", "PCA normalized\n", - "[0. 0.06119 0.14939 0.04363 0.07857]\n", + "[0. 0.12037 0.29384 0.08582 0.15454]\n", "Squared PCA\n", - "[0. 0.00374 0.02232 0.0019 0.00617]\n", + "[0. 0.01449 0.08634 0.00736 0.02388]\n", "###########Histogram\n", - "[0. 0.00374478 0.0223159 0.00190339 0.0061728 ]\n", + "[0. 0.01448892 0.0863424 0.00736442 0.02388317]\n", "Histogram root\n", - "[0. 0.06119461 0.14938508 0.04362791 0.07856718]\n", + "[0. 0.12036993 0.29384077 0.0858162 0.15454181]\n", "Denormalized \n", "[0. 0.00930002 0.02270273 0.00663033 0.01194021]\n", "Sumar mínimo\n", "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", " 2.54252086e-03]\n", - "(256,)\n", + "(64,)\n", "Reconstructed Image PCA\n", "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", " 2.54252086e-03]\n" @@ -405,7 +405,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAC4CAYAAAD61bdSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAfL0lEQVR4nO2de6xd9XXnv+vce859+drXbxvbYB6GhOAGJoaQhhmRIVCSpoJqKgYmE1E1iqNRIjWjzEiIGU2qkapGapvMjFS1ooWBUZg8BKRBTGgTObQkKnFxCOHlAMYYP/D7dd/3vNb8cQ8dx+v7G59z7znX93f9/UgI33XX2fu39157nX33epm7QwghRH4UzvcChBBCzAw5cCGEyBQ5cCGEyBQ5cCGEyBQ5cCGEyBQ5cCGEyJRZOXAzu93MXjezXWZ2X7sWJcT5RrYtcsBmmgduZl0A3gBwK4D9AJ4HcI+7v5b6TMl6vBcDM9pfjlTW8GP1rigrHRib1b6qK/m+6oP1IOvZM8XXVY+6OTGJMZR9yma7nRnZdqHX+7oGZ7trtprZfTx1f7PN1hO6hag8tbq36SX0HK9GYbnS9LrKK/uoqg/U4r4O8GPwqXLcFTmuxi+4vGnaX1szURtBuT4ZFtw9i23eAGCXu+8GADP7FoA7ACSNvBcD+LDdMotdtoEC8Z71aAjt2O7+3/swVa0Mxgt86f3PzWr3R/71r1P52D8fDbLLf28X1a2Pj89qDfTcAu05v02w3be1a1Mt23Zf1yA+svRftWv//4/ZOpNKdFwAgO546/v4BF9Cf3Sgu754ZdNLuOKRo3Ff7x7m+7LoVPf+7jVUt379cJBt/C/8eOtv7gmyQl/iS4jJU19uDG//g9BzJx+n8tlYxzoA+874eX9D9iuY2VYz22FmOyrgT35CzDNatu1yfXLOFifEe3Q8iOnuD7j7FnffUkRPp3cnxJxxpm2XCs2/UhCiXczmFcoBABvO+Hl9Qza/aeHP+alPXB9k+z+eeE2wNj6B9bzMVb9xz/8Ist5/E9f1rZM30M9fO/BOkN216EWqe9kTnw+y1/94M18YYcPT/E/H3qf+MQrn6FXJHDD3tt3Kq5IqeacMADVy/tespKonPxTlh27j76VL/UT+Fl/C1+/6n0F2/WeOB9mfneC2/YnBl4Lsxt5nqe6lT30uyH75hUTcqTAUZOt/wN+BL/7HfUHmqXf29D16wkew6zNLZvME/jyATWZ2qZmVANwN4Mn2LEuI84psW2TBjJ/A3b1qZl8E8LeY/sp5yN1fbdvKhDhPyLZFLszmFQrc/fsAvt+mtQgxb5BtixxQJaYQQmSKHLgQQmTKjCsxZ8JiW+bnu5Dn2Oc/EmQnbuAR5u6+GO33gzxdrHssRqOLozzKvfyVuL+9d8Xk/y1X7KGff+3ImiAbfIxXAU4tjmsYCxnNDcjXefUSnt/s1ah88bf580DP088ndthetvs2DPuJWVdizoQlxZU+q0KerkTmwgQ5/4kKwn2f+0CQjb6fF7aUBqK8cjRR8dgdfcTgG/zta4EkyIzdGAvEbr78Tfr5Z/dcHmQDz/DMksogqRBdyv1ZZVW85/qX8sKlyYlSkK15kqdADz37dpAlfSorBmqy6Oe5k4/jdOVoOGA9gQshRKbIgQshRKbIgQshRKbIgQshRKbMKg98PnPoS7w736rfimWyp37Bo3rd+2IwwxLVsLVSDFCUSddBADh8fTHIVvxd1D301zGgAwCD/fF7d/gS/l1c64vb7Z7gQbB6PFz0vsYDWxMXxRNR/A/vUt1q+UNxDdt+RnUvCFjAMtHtzkn59b5/90Gqu+xfHgyysTdW8TUcjIHB3nFuF8yGppYn1kvMcMVTMfD/s8W/Rj8/SPIJJlbxdU2si+ema5zfB6XD8Z6rk/sbAOyqGHRd+YUYrASA08MXB1nfz2OrCwCwUlyDT82uwZ+ewIUQIlPkwIUQIlPkwIUQIlPkwIUQIlPkwIUQIlMWRhYKmaNX+vgxqrqbZJwUyjzKXWghQNw70nwFd7U/ykbXx88PX8bLq7vibNNkdkzpdNQdX8MzCGjpf6IqmEX79x5bSnUr98aNbGrb+MoMYY39EwMdbF1sm7DkY4eo7r49K+LnU50yiJxlmwBAD+lOUFnMN1teEkvDj19D7CpxuziRF0e4bvFkPGcskwoAqv3x2AoxKWR6G8dj2fyBxUuo7vG74/G+/9XEIiokxSY1yKPJEns9gQshRKbIgQshRKbIgQshRKbIgQshRKbMKohpZnsAjACoAai6+5Z2LKpVutddFGQT5USEggRJqisS07hPJ4IRhNGLY9CB9VEGgIG9MTjJgk21WiK4SmJg3aN8Xac2xwbN3ad5cHRyTdQtHeO6tTUxwls9xXsmf/B9e4NsggSeAQBz2J/+/0dbbLulY0kErYrxFjUkJqQTe/Fevt2uI/G6TlzMt1u/LMprx/i1HtgXt1sjLfSrA/zc9B+Mx1AeoqqoLI7bsMRp9K6om+hegMKy2Cv92CEetf3ND74cZLt7oj8CAJR5b/bZ0I4slI+5O0/5ECJvZNtiXqNXKEIIkSmzdeAO4Adm9jMz29qOBQkxT5Bti3nPbF+h3OTuB8xsFYAfmtkv3f3ZMxUaxr8VAHpBKliEmJ+0ZtuFRedjjeICZ1ZP4O5+oPH/IwC+C+AGovOAu29x9y1F8MCHEPONVm27VODDroXoJDN+AjezAQAFdx9p/Ps2AP+1bStrger65UFmRsZjJ+hdwmvmK4Mxk+XpT/8x1f33e34nyN76m8uobhcJRtdIwks3H5rNSSR1FE/GrABaMg+gUIm65dX8PA4siuds8ugg1e3vJhPQ1/MhGtV9+6l8LpmxbTebdVIgmT2Jxv5ejLrHRxKDCAZIFlEfzyyZ7I2pTDdfySfFv3o8lvOfOJCYYE8eCWs98bwUSYsHgGecFBJJN3T/ZLAKAHiRZIklLteGFaeCbN9bK6luN0kJqy/lf43ZwSNRVkpkunU192w9m1coqwF816bTwboB/G93/5tZbE+I+YJsW2TBjB24u+8GwGc7CZExsm2RC0ojFEKITJEDF0KITFkQ/cDLS2IgIFW12jUVgyeXrjhOdU8uitOp7/rD/0h1e07HiEgpxlYB8J7FrJQ+1du4Tq5aIRGz7TlF+oH/Go+OOmkdYBX+HX/zhl1B9vT41VR3vBq3O3bNWqrbMw+CmJ3GSIAqFf6cuChOjy8Wed+EqdMxTXfLpt1U91Q5BiF/8vfXUN3eo9GGehOeg/WlZ+XtLJAPAOWl8Uz0v8sDnv0H43kc28hvBJuKuqxkHgBuWfN6kD16kgfoT5TjOR+5NF4zAFj8Ku2XQXVRaG6+gJ7AhRAiU+TAhRAiU+TAhRAiU+TAhRAiU+TAhRAiUxZEFoqTiG2pxKPRPaRa+Kt3P0F1u0huwF3Pfpnqski781kIKJDgd3E87qtnmHenLw/E793iBNet9sRzM3CA96SpDETddZ9+m+r+2+X/EGR/W3g/1R0jWShVcgwA8u6Wc/aQikSttrPp5GRwAwCc3hjbOQz0JFI49kSD2/qpv6OqR6txQMFXTl5KdUsj8TjKgzxLYmp51O09FnX7D3N7LZGsqdRglJ6TUdY1xc9jlbSq2fzP3qG6vzEYhzR8q+tDVHe0Ei12bDW37UWTsV1CocTPgyXsIXy+KS0hhBDzDjlwIYTIFDlwIYTIFDlwIYTIlAURxDy1KQZ6ymV+aGxI9yPHf53qXtV/KMg23f4W1b1z9c+D7HBlCdV9ZzLW2N+9/KdB9leH/wX9/ClSvvupVS9R3T/6h08G2VWXHqS6R8diCfCmRbGHMQAcqsVjqw7z2v93CkuDbHVieviC4uyg5nviRfE81w5EWwP4RPepSsK2j8dgXyURST9eiz2r77z7x1T3Y4OvBdlPRq+iujtHY+/w6xbvC7JXR3krhclavJd/Z9UOqvu1XbcG2eYhPoP64HgM2q7pHaa6e6vLgmxqjNv22yfjvVwc5UHXruVxu6jMblK9nsCFECJT5MCFECJT5MCFECJT5MCFECJT5MCFECJTzpmFYmYPAfgUgCPufk1DtgzAtwFsBLAHwF3uTgpb54bxi2LUd9lgHMYAAJVizADY2MsHOvzJd+8IsttufYHq9hdimeyDr36E6g7+KK7hyGdiVsDP39lAP79u5akg+8beD1PdxcvHguz+jf+H6v7FwY8F2Y/2X0l1r38fL7FnsCnf727mk7sv5l0NOsJ5s21SYu/X8ayOsYtjus7Gfj6Q48iqmPXCsk0A4I9++okg+883crt4bXJ9kD22+1qqW34lZied+mgcHnF6iqTXAOgvxjYDDx/4KNVl2Tgb+/m9zEre/37/FVR385VxqEihxAcvsLYGx3hHAqxcGbOxfPderlw8KxunzjNbmnkCfxjA7WfJ7gOwzd03AdjW+FmI3HgYsm2RMed04O7+LIATZ4nvAPBI49+PALizvcsSovPItkXuzLSQZ7W7v1cNcgjA6pSimW0FsBUAehELUISYZ8zMtgv8VYUQnWTWQUx3d6RnssLdH3D3Le6+pZh3s1BxgdGKbZcK/J2uEJ1kpk/gh81srbsfNLO1AHi99RyxakcM9BxYQspWAdgH4v24c5yX9a5+Pm53140rqO62pz4dZLUreLDp5E0x4Dm8LwaKenpJ32gAB44OBVnXXu5AKitiX/R7f7CV6haHJoOsbzt/srzpulgeXVjE1/vuj+Oxrd/Gg8zzgI7bdv1oDLR1jcZgMwAsfTkGN3cvWkV1bXO8ft84yAPpFz0dS9b/ag0PFh45FsvQC138e622LN4zu4/EcvNCgX9+pDt+fuxo4i930kv76URP+ompWApf2cUnzX9g84EodN4W4cgL8Q+0S7bF6wAAtdfeCDIr8hL9wsBZ1ycxpX6mT+BPAri38e97AXxvhtsRYr4h2xbZcE4HbmbfBPAcgKvMbL+ZfRbAVwHcamZvAvh442chskK2LXLnnK9Q3P2exK9uafNahJhTZNsid1SJKYQQmSIHLoQQmbIgBjoMPLY9yK58rPnP8xENwOBVMVtgbf9pqvv6mpjt0fM2zwzpORkjyhY/jloi67KXBa4TyW6FavOXuGdNzCJZ8jZZGIDPXnxTkF2BONRCRKw7XpPa8bPriaZZ+Z1XgmzVU7E0HQBQjtevunyIqg4OjgTZ0GLeMeDwWzHzyob5s1+RVZyfjK0jEkkdKJP5E30jXNljIg1OnSJCABs3vxtkky/wDKuvPPG7QXblm3uoLhvOUT/Bz6P3xBu60JdIP00MAwmfb0pLCCHEvEMOXAghMkUOXAghMkUOXAghMmVBBDFRIJGPOu/f2wq1pbGE93SFBx2sFoMOXROJ4Av52qyTuFQhMbC6QOKKdV6RCxuLa0jpdnfFczY1yKeaJ8JozcOuGdCW6zZvqMVSbwBAKQbaulbEcnMAsL4WznQpXtjantjyAACmbrk2yNb1nqK63hevSX2S23bfkWjcdXKpPXH5nXikLt6hAVUSrywmAp51EjWt9CfK03fuieuqJeySlLgXVvJr6axdgiWeoT1hO2fvqyktIYQQ8w45cCGEyBQ5cCGEyBQ5cCGEyJSFEcRsJfDVSsCTDBItWLK/f/x4an4FiZ0YWUI9dXVYEDQRFGL7qhf5MZRJ1WahUxaykIKVKZKBKHIBu/gF9AnSUz4V+JqKfeZTwdF6KW7j4GQcSAwANhHXVkxUYk4NkYHN7HATAXqmOzXEdbvKzScOTFRixLOyiOtaTwwG2wDvSe7jpPc3GVqdlNd4pXOq/3dQa0pLCCHEvEMOXAghMkUOXAghMkUOXAghMkUOXAghMuWcOQZm9hCATwE44u7XNGR/AOBzAI421O539+93apHtxEi03xMZEdXBGI0eLif695KEA5ZZAvBIO+vnTfUSpEqTacZLvbkINwDUeXtlvqvEhG2vJFIOzjNtt+1U9kHYMUsjSnyWZaeQbJOUriczIqKonEhl8iIx7kQrhOJotK2JNfFGKI7xz9d648JS9xHTLS/hx9tfJyX+Cduuj4zGNUwlbLhOzk0qw4pmwCWyUNrYD/xhALcT+dfd/drGf1k4byHO4mHItkXGnNOBu/uzAPi4ECEyRrYtcmc278C/aGYvmdlDZrY0pWRmW81sh5ntqCDxp58Q84uWbbtcJwUdQnSYmTrwPwdwOYBrARwE8KcpRXd/wN23uPuWIlKliULMG2Zk26VCIjYiRAeZUaG0ux9+799m9pcAnmrbiuYRU0vj6Rmf4jdqYSp+F6YCi6mgTCdggdDU/lmbgMpg8wHPZM/kjGirbSfK462r+ecmGoRMlNLTcu/ENZkaitsYr/IgtE3G42ABxIZ2kJROklL8GCechvTtrvbzfbE1eBfXZb3ux/hMYxSGYksB6+d92f3UcBQmAtLWG6OmniqZb/JemtETuJmtPePH3wYQR2cLkSGybZETzaQRfhPAzQBWmNl+AF8BcLOZXYvpZKQ9AD7fuSUK0Rlk2yJ3zunA3f0eIn6wA2sRYk6RbYvcUSWmEEJkihy4EEJkysIY6NAKTTZKB4BaKeqOT/FIfTfpu18r8Wg0myrfVY37suYGUzeUuZhN+U6V6FeqJGuC97EXZ+NIl8OfrUoyS6yQyCxhn+9O3Lak/Nonee0Fs+3Dozwtg2UtkWQRAEC1r7lzMLGSy7vJQIauKb6z6kDcV9c4P4/HTw9E3ZQrKFeCyAfj56d/QW7SVEuJKrnxmawF9AQuhBCZIgcuhBCZIgcuhBCZIgcuhBCZcuEFMVuABXpGR3kpfU8l6ta7eUAnFQAKeqmvVzppnqvWSWlxgQRMAWBiJPaqKSUCseIsDDFAniqpJgFLZ32lAWAiNsny8uz7q0+sJDZAJrcDvCVErcTXWyABx67xKCuQ+wUA6kUS4E3YKwvyswQBAKiTfuCVwcT1YS0JJvk5d9YuIdUPfIosrth8QJqhJ3AhhMgUOXAhhMgUOXAhhMgUOXAhhMgUOXAhhMiUCy8LpclyZwAYW0syS6YSTfpnOcuANa0v1FoYplBIHFcLX9E2HLMQyitaOLBU9P1CJdG2gWaRpBr4s220MCjCKzxbpLKIDO8Y5hlWpdNkyEJf4thI5hVr51BLZGjRLJTEqWEl9qlBE/UKOTfLYsl8Ch8bT/yCnN/E9aEtFFL+KFnn/6voCVwIITJFDlwIITJFDlwIITJFDlwIITKlmZmYGwD8LwCrMd31+AF3/+9mtgzAtwFsxPTswLvc/WTnltoeWpmcPrmy+YbctOw98fXIwhZkIDzqVJPrsnJngAd1UkEhVprcs4I0Om+VQgvlxnNIx207ZWusX3RC12vxohQWD1Ld+vAI2QC3oSorI08Ewlnrh3qq1z2JC9Z6mA2mSumjzBIBT4YlSvS9Gm/GKzce4rpTJMic6sHewnwB1mccJPDcCs18ugrgy+5+NYAbAXzBzK4GcB+Abe6+CcC2xs9C5IRsW2TNOR24ux909xca/x4BsBPAOgB3AHikofYIgDs7tEYhOoJsW+ROS3ngZrYRwHUAtgNY7e4HG786hOk/Q9lntgLYCgC9ms8l5imztu0CH0cmRCdp+gWMmS0C8DiAL7n78Jm/8+kMdfqiyt0fcPct7r6liNiuVIjzTTtsu1TgRTBCdJKmHLiZFTFt4I+6+xMN8WEzW9v4/VoARzqzRCE6h2xb5EwzWSgG4EEAO939a2f86kkA9wL4auP/3+vICttNK9kPq8hE73F+ympkGndyIEOzJDJLWPVucl91NmiCq7IslE2rjlLdqXmaWdIKHbdtS1yUFjIXCoviNHQf6OO7I0MhfJxnEdV7SXYLS28CUGNtHlLD1EnKipFMmNoAt5Xu0WhX1cXN25UVE+e2HK/F8t4xqnq6p4VXvU0OXgDA23ikbOHsjJVEIk4z78A/CuAzAF42sxcbsvsxbdzfMbPPAngHwF1NbEuI+YRsW2TNOR24u/8EdIgXAOCW9i5HiLlDti1yR5WYQgiRKXLgQgiRKQu3H3gquJAoLWZsuigmH7zxynq+2UTAkcGChZQ2fL2ysvlUwJNNCh8q8T7IRzdfGWT1X+xsaW0XLNVUBDDiEzEI6aeHiSZgpNzbSnzS/Ic37wqy7a9fRnWL5WgXlaHmA4vdw/HmYMFKAKiTsvlkeXwXCa5OcN2uqWj0G/uPU93nL98YZN3buW0XhpbEdaWuL5OztgotoCdwIYTIFDlwIYTIFDlwIYTIFDlwIYTIFDlwIYTIlAWchZKaphCj510kkgwAVy45HGS7pi5uegmsEX5yaWy49WSq6X3zmTR1FuxPNO43MuV7ZWmU6u7etDjIBn7B12BkSrdnVnbfVliGVGKSORuGkSzeJlkovp42UsQNS34aZNsrl1PdVuytMBmNu7aIlPgnyva7JuLnC+OJe5mdiMRSqwPxF8NV3pJg9KLYdG+o0MKzLhvcANBrbImBDn52qljiousJXAghMkUOXAghMkUOXAghMkUOXAghMmXBBjFZ4AzgwbPa+y6huj89HMvIUxPda2xKdyLwUGNnnU2aT8VhyaF5K5O7E6X8LK70o/2xZB4ASFwqiVcTQZ2FTqrXM2vnwPqrgwe5vMAnWxkJjlYW8VLtXROryLr4elkQkhoLgHof0SWiAunPDXCbrw3x0nSrkIAnCYICQPdIPLZnD/DWAbY6bmOI9FpPkmhfgFoL22gSPYELIUSmyIELIUSmyIELIUSmyIELIUSmnNOBm9kGM3vGzF4zs1fN7Pcb8j8wswNm9mLjv092frlCtA/ZtsidZrJQqgC+7O4vmNkggJ+Z2Q8bv/u6u/9J55Y3C1qY/D18GZ9CXeoaCbLiGN/uJIvUp4LOLNpPmtNXE5O72aR5I7LpjUQ5a4QPAD3H4vf5bRf/km/2P0XdV57gS7BSzITwqSmuPLe0z7Ydcep4ygZJtoj18syS+omTQVZYOsR1hwaD7NCN3LYrJ9cEWfdpnglTW10OMq8ljo20YzBi7/W+hG2Tsn3r5jcSs+JawraN9JS4dcPrVPel31oXZIXHlvM1TMVzwwZrAIB7zMZKDn9okmaGGh8EcLDx7xEz2wkgHqEQmSHbFrnT0jtwM9sI4DoA2xuiL5rZS2b2kJktTXxmq5ntMLMdFcyLpy4hArO17bJPztVShfgnmnbgZrYIwOMAvuTuwwD+HMDlAK7F9FPMn7LPufsD7r7F3bcUwf9MFOJ80g7bLlnvXC1XiH+iKQduZkVMG/ij7v4EALj7YXevuXsdwF8CuKFzyxSiM8i2Rc6c8x24TdfnPghgp7t/7Qz52sY7RAD4bQCvdGaJnefI9Vz+kcEYQNp32TKq27soBjO6u3mgxklQp9gVdXuKPMBRq8fv3XI1MeU71ZScMNofA147h2OwCwBuXv5GkL2C2CO8sYim1zCXtNW2DcDZZe+pnvSsFzorr0/JWT9xAHboaJBNrqJvf3DN0oNBtncR7x2+aCi2lOgv8fYIlVo85l5ix6OT/K/xtYuH4zZpU3tOyt73HY3noafA76/bVr8WZM8keqVbf/zLy8fi+ZpWbqEPfK25fvnNZKF8FMBnALxsZi82ZPcDuMfMrsV0MHgPgM83tUch5g+ybZE1zWSh/AS8LdP3278cIeYO2bbIHVViCiFEpsiBCyFEpsiBCyFEpizYgQ5eab5EddOjfPL6y+9cHWSXvMGj71WSwTGxrPnvx3p3fBWbKntydtUSweziRMxiKCaC5EvGY8ny/h2XUt1vj0f5EJ6jul6JGToXBJ7opcCychIl1dZDsjUSJfq1E6eCbN0zfLs/fvdDQbZ+D9cdWz0UZKNL+Rq6JqJsmMyUqPE5EzgwFbNFSsM8Q6e8JK6hK1FPtXQ0buN7L99EdQskAWT9yIt8wyRbxCf4IqyP1AqkSukTmUZnoydwIYTIFDlwIYTIFDlwIYTIFDlwIYTIFPNUCW8ndmZ2FMA7jR9XADg2ZzufO3Rc549L3H3l+djxGbadw3maKQv12HI4Lmrbc+rAf2XHZjvcfct52XkH0XFd2Czk87RQjy3n49IrFCGEyBQ5cCGEyJTz6cAfOI/77iQ6rgubhXyeFuqxZXtc5+0duBBCiNmhVyhCCJEpcuBCCJEpc+7Azex2M3vdzHaZ2X1zvf920phYfsTMXjlDtszMfmhmbzb+z2dazWPMbIOZPWNmr5nZq2b2+w159sfWSRaKbcuu8zm2OXXgZtYF4M8AfALA1ZgeXRVb/uXDwwBuP0t2H4Bt7r4JwLbGz7lRBfBld78awI0AvtC4Tgvh2DrCArPthyG7zoK5fgK/AcAud9/t7mUA3wJwxxyvoW24+7MATpwlvgPAI41/PwLgzrlcUztw94Pu/kLj3yMAdgJYhwVwbB1kwdi27DqfY5trB74OwL4zft7fkC0kVp8x0fwQAD7qOxPMbCOA6wBsxwI7tjaz0G17QV37hWLXCmJ2EJ/O0cw2T9PMFgF4HMCX3H34zN/lfmxi5uR+7ReSXc+1Az8AYMMZP69vyBYSh81sLQA0/n/kPK9nRphZEdNG/qi7P9EQL4hj6xAL3bYXxLVfaHY91w78eQCbzOxSMysBuBvAk3O8hk7zJIB7G/++F8D3zuNaZoSZGYAHAex096+d8avsj62DLHTbzv7aL0S7nvNKTDP7JID/hukpjg+5+x/O6QLaiJl9E8DNmG5HeRjAVwD8NYDvALgY0+1F73L3swNC8xozuwnAjwG8DOC9wY73Y/p9YdbH1kkWim3LrvM5NpXSCyFEpiiIKYQQmSIHLoQQmSIHLoQQmSIHLoQQmSIHLoQQmSIHLoQQmSIHLoQQmfJ/AUrL0PYFdpatAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -560,8 +560,8 @@ " plt.show()\n", " \n", " return reconstructed_image\n", - " \n", - "qc, decoder_params = encode_amplitude(images, 250, 8, debug=True) \n", + "\n", + "qc, decoder_params = encode_amplitude(images, 250, 6, debug=True) \n", "\n", "histogram = simulate(qc)\n", "\n", @@ -572,22 +572,45 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "121" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qc.depth()" + ] + }, + { + "cell_type": "code", + "execution_count": 74, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Counter({1: 135, 2: 254})" + "Counter({1: 69, 2: 62})" ] }, - "execution_count": 14, + "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "count_gates(qc)" + "count_gates(qc)\n", + "# 4 qubits -> 2x qubit gates\n", + "# 6 qubits -> 62 2 qubit gates\n", + "# 8 qubits -> 253 2 qubit gates" ] }, { @@ -599,7 +622,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "1982it [2:45:41, 25.61s/it]" + "48it [01:55, 4.45s/it]" ] } ], @@ -624,9 +647,16 @@ "mse=0\n", "gatecount=0\n", "\n", + "max_iter = 50\n", + "\n", + "n_qubits = 6\n", + "\n", + "\n", + "# 1 - mse with 4 qubits - > 0.18 \n", + "# \n", "for i, data in tqdm.tqdm(enumerate(images)):\n", " #encode image into circuit\n", - " circuit, image_re =run_part1(images, i, n_qubits=8)\n", + " circuit, image_re =run_part1(images, i, n_qubits=n_qubits)\n", " \n", " #count the number of 2qubit gates used\n", " gatecount+=count_gates(circuit)[2]\n", @@ -634,16 +664,203 @@ " #calculate mse\n", " #print(images[i].shape)\n", " #print(image_re.shape)\n", - " mse+=image_mse(images[i],image_re)\n", + " images_orig = images[i] * 255\n", + " image_re *= 255\n", + " \n", + " mse+=image_mse(images_orig,image_re)\n", + " \n", + " if i == max_iter:\n", + " break\n", " \n", "#fidelity of reconstruction\n", "f=1-mse\n", - "gatecount=gatecount/n\n", + "gatecount=gatecount/max_iter\n", "\n", "#score for part1 \n", "print(f*(0.999**gatecount))" ] }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "#images[1500]" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1e-06" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "\n", + "round(mean_squared_error(images[1500] * 255 * 255, image_re), 6)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(images[max_iter] * 255 * 255)\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(image_re * 255 * 255)\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7.133031791432462e-08" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image_mse(images[max_iter], image_re)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(images[max_iter])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(image_re)" + ] + }, { "cell_type": "code", "execution_count": 87, diff --git a/part2_with_pca.ipynb b/part2_with_pca.ipynb index e4ba4a3..0ce6972 100644 --- a/part2_with_pca.ipynb +++ b/part2_with_pca.ipynb @@ -202,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -276,7 +276,9 @@ " histogram=simulate(qc)\n", " \n", " #convert histogram to category\n", + " \n", " label=histogram_to_category(histogram)\n", + " # for final prediction we need apply a clasif. threshold\n", " \n", " return circuit,label\n", "#score" From 45fdb286e2e32353d9878a484a7df8bc8aeb2b48 Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 05:55:34 +0000 Subject: [PATCH 05/10] remove debug --- part1_with_pca.ipynb | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/part1_with_pca.ipynb b/part1_with_pca.ipynb index 585b2da..aca6f9f 100644 --- a/part1_with_pca.ipynb +++ b/part1_with_pca.ipynb @@ -534,14 +534,7 @@ " print(root[:5])\n", " \n", " root = root + min_\n", - " if debug:\n", - " print(\"Sumar mínimo\")\n", - " print(root[:5])\n", - " \n", - " print(root.shape)\n", - " \n", - " print(\"Reconstructed Image PCA\")\n", - " print(root[:5])\n", + "\n", " \n", " reconstruction = pca.inverse_transform([root])\n", " \n", @@ -615,14 +608,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "48it [01:55, 4.45s/it]" + "50it [02:08, 2.58s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.5868325769829128\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" ] } ], @@ -653,7 +660,8 @@ "\n", "\n", "# 1 - mse with 4 qubits - > 0.18 \n", - "# \n", + "# 2 - mse with 6 qubits -> 0.5868325769829128\n", + "\n", "for i, data in tqdm.tqdm(enumerate(images)):\n", " #encode image into circuit\n", " circuit, image_re =run_part1(images, i, n_qubits=n_qubits)\n", From 96cedf68c670a76d7d5af68c001ebf1f0c6aea5d Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 05:56:16 +0000 Subject: [PATCH 06/10] just in case --- part1_with_pca.ipynb | 49 ++++++++------------------------------------ 1 file changed, 8 insertions(+), 41 deletions(-) diff --git a/part1_with_pca.ipynb b/part1_with_pca.ipynb index aca6f9f..eea7591 100644 --- a/part1_with_pca.ipynb +++ b/part1_with_pca.ipynb @@ -368,7 +368,12 @@ { "cell_type": "code", "execution_count": 70, - "metadata": {}, + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, "outputs": [ { "name": "stdout", @@ -441,25 +446,12 @@ "\n", " image = images[image_index]\n", " \n", - " if debug:\n", - " \n", - " print(\"Raw Image data\")\n", - " print(data[image_index][:5])\n", - " \n", " image_pca = data_pca[image_index]\n", " \n", " min_ = image_pca.min()\n", " \n", - " if debug:\n", - " print(\"Image PCA\")\n", - " print(image_pca[:5])\n", - "\n", - " \n", " image_pca = image_pca - min_\n", " \n", - " if debug:\n", - " print(\"Image PCA min_ removed\")\n", - " print(image_pca[:5])\n", " \n", " # [normalize]\n", " def normalize(row):\n", @@ -474,23 +466,9 @@ " \n", " image_pca_normalized, normalization_factor = normalize(image_pca)\n", " \n", - " if debug:\n", - " print(image.shape)\n", - "\n", - " print(image_pca_normalized.shape)\n", - "\n", - " print(np.sum(image_pca_normalized**2))\n", " \n", " desired_state = image_pca_normalized\n", " \n", - " #print(np.round(desired_state, 3))\n", - " if debug:\n", - " print(\"PCA normalized\")\n", - " print(np.round(image_pca_normalized, 5)[:5])\n", - "\n", - " print(\"Squared PCA\")\n", - " print(np.round(desired_state ** 2, 5)[:5])\n", - " \n", " ##########\n", " # Amplitude Encoding\n", " qc = QuantumCircuit(n_qubits)\n", @@ -509,30 +487,19 @@ " \n", " return qc_decomposed, decoder_params\n", "\n", - "def decode_amplitude(histogram, normalization_factor, min_, pca, n_qubits, image, debug=False):\n", + "def decode_amplitude(histogram, normalization_factor, min_, pca, n_qubits, image):\n", " \n", " histogram_array = np.zeros(2 ** n_qubits)\n", " \n", " for i in range(2 ** n_qubits):\n", " histogram_array[i] = histogram.get(i, 0)\n", - " \n", - " if debug:\n", - " print(\"###########Histogram\")\n", "\n", - " print(histogram_array[:5])\n", - " \n", " root = np.sqrt(histogram_array)\n", " \n", - " if debug:\n", - " print(\"Histogram root\")\n", - " print(root[:5])\n", " \n", " root = root * normalization_factor\n", " \n", - " if debug:\n", - " print(\"Denormalized \")\n", - " print(root[:5])\n", - " \n", + "\n", " root = root + min_\n", "\n", " \n", From 833e015d22cd35b4b5020c9225bb872b77fa564f Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 14:20:47 +0000 Subject: [PATCH 07/10] Add test.ipynb --- test.ipynb | 348 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 348 insertions(+) create mode 100644 test.ipynb diff --git a/test.ipynb b/test.ipynb new file mode 100644 index 0000000..7d1dded --- /dev/null +++ b/test.ipynb @@ -0,0 +1,348 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "e2e5bcd9-2cb8-465d-b166-23128574b2c7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 2000/2000 [00:00<00:00, 23223.70it/s]\n", + " 1%| | 12/2000 [00:01<05:20, 6.21it/s]\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 247\u001b[0m\n\u001b[1;32m 241\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m circuit,label\n\u001b[1;32m 243\u001b[0m \u001b[38;5;66;03m############################\u001b[39;00m\n\u001b[1;32m 244\u001b[0m \u001b[38;5;66;03m# END YOUR CODE #\u001b[39;00m\n\u001b[1;32m 245\u001b[0m \u001b[38;5;66;03m############################\u001b[39;00m\n\u001b[0;32m--> 247\u001b[0m \u001b[43mtest\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[2], line 127\u001b[0m, in \u001b[0;36mtest\u001b[0;34m()\u001b[0m\n\u001b[1;32m 123\u001b[0m gatecount\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(\u001b[38;5;28mrange\u001b[39m(n)):\n\u001b[1;32m 126\u001b[0m \u001b[38;5;66;03m#encode image into circuit\u001b[39;00m\n\u001b[0;32m--> 127\u001b[0m circuit,image_re\u001b[38;5;241m=\u001b[39m\u001b[43mrun_part1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdataset\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mimage_vector\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 128\u001b[0m image_re \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39masarray(image_re)\n\u001b[1;32m 130\u001b[0m \u001b[38;5;66;03m#count the number of 2qubit gates used\u001b[39;00m\n", + "Cell \u001b[0;32mIn[2], line 204\u001b[0m, in \u001b[0;36mrun_part1\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_part1\u001b[39m(image):\n\u001b[1;32m 203\u001b[0m \u001b[38;5;66;03m#encode image into a circuit\u001b[39;00m\n\u001b[0;32m--> 204\u001b[0m circuit\u001b[38;5;241m=\u001b[39m\u001b[43mencode\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;66;03m#simulate circuit\u001b[39;00m\n\u001b[1;32m 207\u001b[0m histogram\u001b[38;5;241m=\u001b[39msimulate(circuit)\n", + "Cell \u001b[0;32mIn[2], line 180\u001b[0m, in \u001b[0;36mencode\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 177\u001b[0m qc\u001b[38;5;241m.\u001b[39minitialize(image)\n\u001b[1;32m 179\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(AMPLITUDE_ENCODING_N_QUBITS \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m):\n\u001b[0;32m--> 180\u001b[0m qc \u001b[38;5;241m=\u001b[39m \u001b[43mqc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qc\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/quantumcircuit.py:1612\u001b[0m, in \u001b[0;36mQuantumCircuit.decompose\u001b[0;34m(self, gates_to_decompose, reps)\u001b[0m\n\u001b[1;32m 1610\u001b[0m pass_ \u001b[38;5;241m=\u001b[39m Decompose(gates_to_decompose)\n\u001b[1;32m 1611\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(reps):\n\u001b[0;32m-> 1612\u001b[0m dag \u001b[38;5;241m=\u001b[39m \u001b[43mpass_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdag\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1613\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dag_to_circuit(dag)\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/transpiler/passes/basis/decompose.py:90\u001b[0m, in \u001b[0;36mDecompose.run\u001b[0;34m(self, dag)\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m node \u001b[38;5;129;01min\u001b[39;00m dag\u001b[38;5;241m.\u001b[39mop_nodes():\n\u001b[1;32m 89\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_should_decompose(node):\n\u001b[0;32m---> 90\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdefinition\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;66;03m# TODO: allow choosing among multiple decomposition rules\u001b[39;00m\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:239\u001b[0m, in \u001b[0;36mInstruction.definition\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Return definition in terms of other basic gates.\"\"\"\u001b[39;00m\n\u001b[1;32m 238\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 239\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_define\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 240\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:111\u001b[0m, in \u001b[0;36mStatePreparation._define\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefinition \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_define_from_int()\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 111\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefinition \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_define_synthesis\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:171\u001b[0m, in \u001b[0;36mStatePreparation._define_synthesis\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Calculate a subcircuit that implements this initialization\u001b[39;00m\n\u001b[1;32m 162\u001b[0m \n\u001b[1;32m 163\u001b[0m \u001b[38;5;124;03mImplements a recursive initialization algorithm, including optimizations,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 168\u001b[0m \u001b[38;5;124;03mdouble cnots.\u001b[39;00m\n\u001b[1;32m 169\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 170\u001b[0m \u001b[38;5;66;03m# call to generate the circuit that takes the desired vector to zero\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m disentangling_circuit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_gates_to_uncompute\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;66;03m# invert the circuit to create the desired vector from zero (assuming\u001b[39;00m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# the qubits are in the zero state)\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_inverse \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m:\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:281\u001b[0m, in \u001b[0;36mStatePreparation._gates_to_uncompute\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 278\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(rz_mult\u001b[38;5;241m.\u001b[39mto_instruction(), q[i : \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_qubits])\n\u001b[1;32m 280\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mnorm(thetas) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 281\u001b[0m ry_mult \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_multiplex\u001b[49m\u001b[43m(\u001b[49m\u001b[43mRYGate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mthetas\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlast_cnot\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43madd_last_cnot\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 282\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(ry_mult\u001b[38;5;241m.\u001b[39mto_instruction()\u001b[38;5;241m.\u001b[39mreverse_ops(), q[i : \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_qubits])\n\u001b[1;32m 283\u001b[0m circuit\u001b[38;5;241m.\u001b[39mglobal_phase \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mangle(\u001b[38;5;28msum\u001b[39m(remaining_param))\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:390\u001b[0m, in \u001b[0;36mStatePreparation._multiplex\u001b[0;34m(self, target_gate, list_of_angles, last_cnot)\u001b[0m\n\u001b[1;32m 387\u001b[0m list_of_angles \u001b[38;5;241m=\u001b[39m angle_weight\u001b[38;5;241m.\u001b[39mdot(np\u001b[38;5;241m.\u001b[39marray(list_of_angles))\u001b[38;5;241m.\u001b[39mtolist()\n\u001b[1;32m 389\u001b[0m \u001b[38;5;66;03m# recursive step on half the angles fulfilling the above assumption\u001b[39;00m\n\u001b[0;32m--> 390\u001b[0m multiplex_1 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_multiplex\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtarget_gate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlist_of_angles\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mlist_len\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 391\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(multiplex_1\u001b[38;5;241m.\u001b[39mto_instruction(), q[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 393\u001b[0m \u001b[38;5;66;03m# attach CNOT as follows, thereby flipping the LSB qubit\u001b[39;00m\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:401\u001b[0m, in \u001b[0;36mStatePreparation._multiplex\u001b[0;34m(self, target_gate, list_of_angles, last_cnot)\u001b[0m\n\u001b[1;32m 399\u001b[0m multiplex_2 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_multiplex(target_gate, list_of_angles[(list_len \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m) :], \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m list_len \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 401\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(\u001b[43mmultiplex_2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_instruction\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreverse_ops\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m, q[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 402\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 403\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(multiplex_2\u001b[38;5;241m.\u001b[39mto_instruction(), q[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:345\u001b[0m, in \u001b[0;36mInstruction.reverse_ops\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 342\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition:\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m--> 345\u001b[0m reverse_inst \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m_reverse\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 346\u001b[0m reversed_definition \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition\u001b[38;5;241m.\u001b[39mcopy_empty_like()\n\u001b[1;32m 347\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m inst \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mreversed\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition):\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:427\u001b[0m, in \u001b[0;36mInstruction.copy\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 415\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcopy\u001b[39m(\u001b[38;5;28mself\u001b[39m, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 416\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 417\u001b[0m \u001b[38;5;124;03m Copy of the instruction.\u001b[39;00m\n\u001b[1;32m 418\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[38;5;124;03m updated if it was provided\u001b[39;00m\n\u001b[1;32m 426\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 427\u001b[0m cpy \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__deepcopy__\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 429\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name:\n\u001b[1;32m 430\u001b[0m cpy\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m=\u001b[39m name\n", + "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:437\u001b[0m, in \u001b[0;36mInstruction.__deepcopy__\u001b[0;34m(self, _memo)\u001b[0m\n\u001b[1;32m 435\u001b[0m cpy\u001b[38;5;241m.\u001b[39m_params \u001b[38;5;241m=\u001b[39m copy\u001b[38;5;241m.\u001b[39mcopy(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_params)\n\u001b[1;32m 436\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition:\n\u001b[0;32m--> 437\u001b[0m cpy\u001b[38;5;241m.\u001b[39m_definition \u001b[38;5;241m=\u001b[39m \u001b[43mcopy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_definition\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_memo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 438\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cpy\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:172\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m y \u001b[38;5;241m=\u001b[39m x\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43m_reconstruct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# If is its own copy, don't memoize.\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m x:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:270\u001b[0m, in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m deep:\n\u001b[0;32m--> 270\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(y, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__setstate__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 272\u001b[0m y\u001b[38;5;241m.\u001b[39m__setstate__(state)\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:230\u001b[0m, in \u001b[0;36m_deepcopy_dict\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 228\u001b[0m memo[\u001b[38;5;28mid\u001b[39m(x)] \u001b[38;5;241m=\u001b[39m y\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m x\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m--> 230\u001b[0m y[deepcopy(key, memo)] \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:205\u001b[0m, in \u001b[0;36m_deepcopy_list\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 203\u001b[0m append \u001b[38;5;241m=\u001b[39m y\u001b[38;5;241m.\u001b[39mappend\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x:\n\u001b[0;32m--> 205\u001b[0m append(\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:172\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m y \u001b[38;5;241m=\u001b[39m x\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43m_reconstruct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# If is its own copy, don't memoize.\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m x:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:270\u001b[0m, in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m deep:\n\u001b[0;32m--> 270\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(y, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__setstate__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 272\u001b[0m y\u001b[38;5;241m.\u001b[39m__setstate__(state)\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m_deepcopy_tuple\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [deepcopy(a, memo) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:230\u001b[0m, in \u001b[0;36m_deepcopy_dict\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 228\u001b[0m memo[\u001b[38;5;28mid\u001b[39m(x)] \u001b[38;5;241m=\u001b[39m y\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m x\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m--> 230\u001b[0m y[deepcopy(key, memo)] \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m_deepcopy_tuple\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [deepcopy(a, memo) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:172\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m y \u001b[38;5;241m=\u001b[39m x\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43m_reconstruct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# If is its own copy, don't memoize.\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m x:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:270\u001b[0m, in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m deep:\n\u001b[0;32m--> 270\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(y, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__setstate__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 272\u001b[0m y\u001b[38;5;241m.\u001b[39m__setstate__(state)\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m_deepcopy_tuple\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [deepcopy(a, memo) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:230\u001b[0m, in \u001b[0;36m_deepcopy_dict\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 228\u001b[0m memo[\u001b[38;5;28mid\u001b[39m(x)] \u001b[38;5;241m=\u001b[39m y\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m x\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m--> 230\u001b[0m y[\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m] \u001b[38;5;241m=\u001b[39m deepcopy(value, memo)\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", + "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:182\u001b[0m, in \u001b[0;36m_deepcopy_atomic\u001b[0;34m(x, memo)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n\u001b[1;32m 180\u001b[0m _deepcopy_dispatch \u001b[38;5;241m=\u001b[39m d \u001b[38;5;241m=\u001b[39m {}\n\u001b[0;32m--> 182\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_atomic\u001b[39m(x, memo):\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n\u001b[1;32m 184\u001b[0m d[\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28;01mNone\u001b[39;00m)] \u001b[38;5;241m=\u001b[39m _deepcopy_atomic\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info, QuantumCircuit\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "import sys\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "from sklearn.decomposition import PCA\n", + "import tqdm\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "if len(sys.argv) > 1:\n", + " data_path = sys.argv[1]\n", + "else:\n", + " data_path = '.'\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function takes a histogram representation of circuit execution results, and processes into labels as described in\n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(3,20):\n", + " assert counter[i]==0\n", + " \n", + " return counter\n", + "\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(255*image1,255*image2)\n", + "\n", + "# [normalize]\n", + "def normalize(row):\n", + " #We calculate the squareroot of the sum of the square values of the row\n", + " normalization_factor = np.sqrt(np.sum(row**2)) \n", + " if normalization_factor == 0.:\n", + " #If the sum is zero we return a 0\n", + " return 0.0\n", + " #Else we divide each value between the sum value above\n", + " row = row / normalization_factor\n", + " return row, normalization_factor\n", + "#\n", + "data_path = \"./data\"\n", + "\n", + "def test():\n", + " #load the actual hackthon data (fashion-mnist)\n", + " images=np.load(data_path+'/images.npy')\n", + " labels=np.load(data_path+'/labels.npy')\n", + " \n", + " #test part 1\n", + " global pca, AMPLITUDE_ENCODING_N_QUBITS,IMAGE_SIZE, dataset\n", + "\n", + " AMPLITUDE_ENCODING_N_QUBITS = 4\n", + " IMAGE_SIZE = 28\n", + " N_IMAGES = len(images)\n", + "\n", + " pca = PCA(n_components=2**AMPLITUDE_ENCODING_N_QUBITS)\n", + " \n", + " data = images.reshape(N_IMAGES, IMAGE_SIZE * IMAGE_SIZE)\n", + " pca.fit(data)\n", + " \n", + " # Apply dimensionality reduction on your data\n", + " images_pca = pca.transform(data)\n", + " \n", + " dataset = []\n", + " for i in tqdm.tqdm(range(len(images))):\n", + " image_pca = images_pca[i]\n", + " image_pca_min_ = image_pca.min()\n", + " image_pca_positive = image_pca - image_pca_min_\n", + " \n", + " dataset_i = {}\n", + " \n", + " normalized_state, normalization_factor = normalize(image_pca_positive)\n", + " \n", + " dataset_i[\"image\"] = images[i]\n", + " dataset_i[\"image_vector\"] = normalized_state\n", + " dataset_i[\"label\"] = labels[i]\n", + " dataset_i[\"normalization_factor\"] = normalization_factor\n", + " dataset_i[\"pca_min_\"] = image_pca_min_\n", + " \n", + " dataset.append(dataset_i)\n", + " \n", + " n=len(images)\n", + " mse=0\n", + " gatecount=0\n", + "\n", + " for i in tqdm.tqdm(range(n)):\n", + " #encode image into circuit\n", + " circuit,image_re=run_part1(dataset[i][\"image_vector\"])\n", + " image_re = np.asarray(image_re)\n", + "\n", + " #count the number of 2qubit gates used\n", + " gatecount += count_gates(circuit)[2]\n", + "\n", + " #calculate mse\n", + " mse+=image_mse(dataset[i][\"image\"], image_re)\n", + "\n", + " #fidelity of reconstruction\n", + " f=1-mse/n\n", + " gatecount=gatecount/n\n", + "\n", + " #score for part1\n", + " score_part1=f*(0.999**gatecount)\n", + " \n", + " print(score_part1)\n", + "\n", + " #test part 2\n", + " \n", + " score=0\n", + " gatecount=0\n", + " n=len(images)\n", + "\n", + " for i in range(n):\n", + " #run part 2\n", + " circuit,label=run_part2(images[i])\n", + "\n", + " #count the gate used in the circuit for score calculation\n", + " gatecount+=count_gates(circuit)[2]\n", + "\n", + " #check label\n", + " if label==labels[i]:\n", + " score+=1\n", + " \n", + " #score\n", + " score=score/n\n", + " gatecount=gatecount/n\n", + "\n", + " score_part2=score*(0.999**gatecount)\n", + " \n", + " print(score_part1, \",\", score_part2, \",\", data_path, sep=\"\")\n", + "\n", + "\n", + "############################\n", + "# YOUR CODE HERE #\n", + "############################\n", + "def encode(image):\n", + " qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS)\n", + "\n", + " qc.initialize(image)\n", + " \n", + " for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2):\n", + " qc = qc.decompose()\n", + " \n", + " return qc\n", + "\n", + "def decode(histogram):\n", + " histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS)\n", + " for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS):\n", + " histogram_array[i] = histogram.get(i, 0)\n", + " \n", + " root = np.sqrt(histogram_array)\n", + " \n", + " root = root * dataset[i][\"normalization_factor\"]\n", + " \n", + " root = root + dataset[i][\"pca_min_\"]\n", + "\n", + " reconstruction = pca.inverse_transform([root])\n", + "\n", + " \n", + " image = reconstruction.reshape(IMAGE_SIZE, IMAGE_SIZE)\n", + " \n", + " return image\n", + "\n", + "def run_part1(image):\n", + " #encode image into a circuit\n", + " circuit=encode(image)\n", + "\n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re=decode(histogram)\n", + "\n", + " return circuit,image_re\n", + "\n", + "def run_part2(image):\n", + " # load the quantum classifier circuit\n", + " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", + " \n", + " #encode image into circuit\n", + " circuit=encode(image)\n", + " \n", + " #append with classifier circuit\n", + " nq1 = circuit.width()\n", + " nq2 = classifier.width()\n", + " nq = max(nq1, nq2)\n", + " qc = qiskit.QuantumCircuit(nq)\n", + " qc.append(circuit.to_instruction(), list(range(nq1)))\n", + " qc.append(classifier.to_instruction(), list(range(nq2)))\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(qc)\n", + " \n", + " #convert histogram to category\n", + " label=histogram_to_category(histogram)\n", + " \n", + " #thresholding the label, any way you want\n", + " if label>0.5:\n", + " label=1\n", + " else:\n", + " label=0\n", + " \n", + " return circuit,label\n", + "\n", + "############################\n", + "# END YOUR CODE #\n", + "############################\n", + "\n", + "test()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21a93cc3-13b1-40bc-85fa-6e5bfd5ee403", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 [Default]", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6876aa7ed28ba727137d9c8daa08deaae0371eab Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 14:40:55 +0000 Subject: [PATCH 08/10] submission commit add trained qasm, test.ipynb --- data1.json | 1 - data2.json | 1 - examples.ipynb | 249 -- examples_qiskit.ipynb | 222 -- mock_data_creator.ipynb | 79 - part1.py | 25 - part1_example_cirq.ipynb | 226 -- part1_example_qiskit.ipynb | 272 -- part1_no_pca.ipynb | 1365 --------- part1_with_pca.ipynb | 1327 -------- part2.pickle | Bin 497 -> 0 bytes part2.qasm | 4 - part2_example_cirq.ipynb | 221 -- part2_example_qiskit.ipynb | 1674 ---------- part2_with_pca.ipynb | 5914 ------------------------------------ quantum_classifier.qasm | 5 + test.ipynb | 56 +- test.py | 256 ++ train_classifier.ipynb | 2694 ++++++++++++++++ 19 files changed, 2958 insertions(+), 11633 deletions(-) delete mode 100644 data1.json delete mode 100644 data2.json delete mode 100644 examples.ipynb delete mode 100644 examples_qiskit.ipynb delete mode 100644 mock_data_creator.ipynb delete mode 100644 part1.py delete mode 100644 part1_example_cirq.ipynb delete mode 100644 part1_example_qiskit.ipynb delete mode 100644 part1_no_pca.ipynb delete mode 100644 part1_with_pca.ipynb delete mode 100644 part2.pickle delete mode 100644 part2.qasm delete mode 100644 part2_example_cirq.ipynb delete mode 100644 part2_example_qiskit.ipynb delete mode 100644 part2_with_pca.ipynb create mode 100644 quantum_classifier.qasm create mode 100644 test.py create mode 100644 train_classifier.ipynb diff --git a/data1.json b/data1.json deleted file mode 100644 index 7bd26cd..0000000 --- a/data1.json +++ /dev/null @@ -1 +0,0 @@ -{"image": [[0, 0], [0, 0]], "category": 1} \ No newline at end of file diff --git a/data2.json b/data2.json deleted file mode 100644 index f8517a1..0000000 --- a/data2.json +++ /dev/null @@ -1 +0,0 @@ -{"image": [[1, 1], [1, 1]], "category": 0} \ No newline at end of file diff --git a/examples.ipynb b/examples.ipynb deleted file mode 100644 index 3e0b5fe..0000000 --- a/examples.ipynb +++ /dev/null @@ -1,249 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 23, - "id": "4d3113ae", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: cirq.Circuit) -> dict:\n", - " \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n", - " \"\"\"\n", - " simulator = cirq.Simulator()\n", - " result = simulator.simulate(circuit)\n", - " \n", - " state_vector=result.final_state_vector\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: cirq.Circuit):\n", - " \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n", - " counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n", - " \n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "82f90e0d", - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "cb96a334", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "b02b160e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part1\n", - "from part1 import encode_cirq,decode\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode_cirq(data['image'])\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " #count the number of 2-qubit gates\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #reconstruct the image\n", - " image_re=decode(histogram)\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "2fe52c43", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part 2\n", - "\n", - "#load classifier circuit\n", - "with open('part2.pickle', 'rb') as f:\n", - " classifier=pickle.load(f)\n", - " \n", - "score=0\n", - "\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode_cirq(data['image'])\n", - " \n", - " #append with classifier circuit\n", - " \n", - " circuit.append(classifier)\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #convert histogram to category\n", - " cat=histogram_to_category(histogram)\n", - " \n", - " if cat==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "de96fdf1", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - }, - "vscode": { - "interpreter": { - "hash": "1a1af0ee75eeea9e2e1ee996c87e7a2b11a0bebd85af04bb136d915cefc0abce" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples_qiskit.ipynb b/examples_qiskit.ipynb deleted file mode 100644 index 168cc4f..0000000 --- a/examples_qiskit.ipynb +++ /dev/null @@ -1,222 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "\n", - "#define utility functions\n", - "\n", - "#this simulate a circuit (without measurement) and output results in the format of histogram.\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " return Counter([len(gate[1]) for gate in circuit.data])\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "#load data\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'image': [[1, 1], [1, 1]], 'category': 0}\n", - "{'image': [[0, 0], [0, 0]], 'category': 1}\n" - ] - } - ], - "source": [ - "for data in dataset:\n", - " print(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part1\n", - "from part1 import encode_qiskit,decode\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode_qiskit(data['image'])\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #reconstruct \n", - " image_re=decode(histogram)\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(np.asarray(data['image']),np.asarray(image_re))\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1\n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part 2\n", - "\n", - "#load classifier circuit\n", - "classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n", - " \n", - "score=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode_qiskit(data['image'])\n", - " \n", - " nq1 = circuit.width()\n", - " nq2 = classifier.width()\n", - " nq = max(nq1, nq2)\n", - " qc = qiskit.QuantumCircuit(nq)\n", - " qc.append(circuit.to_instruction(), list(range(nq1)))\n", - " qc.append(classifier.to_instruction(), list(range(nq2)))\n", - "\n", - " gatecount+=count_gates(qc)[2]\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(qc)\n", - " \n", - " #convert histogram to category\n", - " cat=histogram_to_category(histogram)\n", - " \n", - " \n", - " if cat==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - }, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/mock_data_creator.ipynb b/mock_data_creator.ipynb deleted file mode 100644 index 4d7c7ba..0000000 --- a/mock_data_creator.ipynb +++ /dev/null @@ -1,79 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "edbfcaa1", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3d1a8015", - "metadata": {}, - "outputs": [], - "source": [ - "#making mock data data1.json and data2.json\n", - "\n", - "image1={\"image\":[[0,0],[0,0]],\"category\":1}\n", - "image2={\"image\":[[1,1],[1,1]],\"category\":0}\n", - "\n", - "with open('data1.json', \"w\") as outfile:\n", - " json.dump(image1, outfile)\n", - " \n", - "with open('data2.json', \"w\") as outfile:\n", - " json.dump(image2, outfile)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d36c16ef", - "metadata": {}, - "outputs": [], - "source": [ - "circuit=cirq.Circuit()\n", - "circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", - "#making mock submission for part2\n", - "with open('part2.pickle', 'wb') as f:\n", - " pickle.dump(circuit,f)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "55574177", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/part1.py b/part1.py deleted file mode 100644 index d133097..0000000 --- a/part1.py +++ /dev/null @@ -1,25 +0,0 @@ -import cirq -import qiskit -import numpy as np - - -def encode_cirq(image): - circuit=cirq.Circuit() - if image[0][0]==0: - circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0))) - return circuit - -def encode_qiskit(image): - q = qiskit.QuantumRegister(3) - circuit = qiskit.QuantumCircuit(q) - if image[0][0]==0: - circuit.rx(np.pi,0) - return circuit - - -def decode(histogram): - if 1 in histogram.keys(): - image=[[0,0],[0,0]] - else: - image=[[1,1],[1,1]] - return image \ No newline at end of file diff --git a/part1_example_cirq.ipynb b/part1_example_cirq.ipynb deleted file mode 100644 index c3d383b..0000000 --- a/part1_example_cirq.ipynb +++ /dev/null @@ -1,226 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 8, - "id": "9c97e0dc", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: cirq.Circuit) -> dict:\n", - " \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n", - " \"\"\"\n", - " simulator = cirq.Simulator()\n", - " result = simulator.simulate(circuit)\n", - " \n", - " state_vector=result.final_state_vector\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: cirq.Circuit):\n", - " \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n", - " counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n", - " \n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7f19ddcc", - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "a443b6a8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "cb2031cd", - "metadata": {}, - "outputs": [], - "source": [ - "#submission to part 1, you should make this into a .py file\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "def encode(image):\n", - " circuit=cirq.Circuit()\n", - " if image[0][0]==0:\n", - " circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", - " return circuit\n", - "\n", - "def decode(histogram):\n", - " if 1 in histogram.keys():\n", - " image=[[0,0],[0,0]]\n", - " else:\n", - " image=[[1,1],[1,1]]\n", - " return image\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit=encode(data['image'])\n", - "\n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re=decode(histogram)\n", - "\n", - " return circuit,image_re" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "385faa44", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit,image_re=run_part1(data['image'])\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ad7e81d7", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/part1_example_qiskit.ipynb b/part1_example_qiskit.ipynb deleted file mode 100644 index d8bb37d..0000000 --- a/part1_example_qiskit.ipynb +++ /dev/null @@ -1,272 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.000000\n" - ] - } - ], - "source": [ - "a = 1e-9\n", - "print('{:f}'.format(a))" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", - " {'image': [[0, 0], [0, 0]], 'category': 1}]" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#submission to part 1, you should make this into a .py file\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "def decode(histogram):\n", - " if 1 in histogram.keys():\n", - " image=[[0,0],[0,0]]\n", - " else:\n", - " image=[[1,1],[1,1]]\n", - " return image\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit = encode(image)\n", - "\n", - " #simulate circuit\n", - " histogram = simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re = decode(histogram)\n", - "\n", - " return circuit,image_re" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit,image_re=run_part1(data['image'])\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - }, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/part1_no_pca.ipynb b/part1_no_pca.ipynb deleted file mode 100644 index 7b40a6f..0000000 --- a/part1_no_pca.ipynb +++ /dev/null @@ -1,1365 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 118, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(3,20):\n", - " assert counter.get(i,0)==0\n", - " \n", - " \n", - " return counter\n", - "\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.000000\n" - ] - } - ], - "source": [ - "a = 1e-9\n", - "print('{:f}'.format(a))" - ] - }, - { - "cell_type": "code", - "execution_count": 120, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 121, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", - " {'image': [[0, 0], [0, 0]], 'category': 1}]" - ] - }, - "execution_count": 121, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 122, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 122, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQiElEQVR4nO3dXYyc9XXH8d/Z2Rd712vjxcY2xuUtkBZFwjRb2iqkJUJBhBuDFNFQKSIq7eYiSEHKRRGVGm4qoaokygWK5AQUp6KkqRKE06AG6iZCpK1jg1wwuAXXsbFdv2Js/MLuzu6eXuw4Wpt9zrOel52xz/cjrWb2OfPMHI/98zMz//k/f3N3Abj0dbW7AQDzg7ADSRB2IAnCDiRB2IEkuufzwXqtzxdoYD4f8qJgvb1hfWx5T1jv7q8W1qpj8b42EZZlU3F9qi8ezVk6cKaw9sH4gnDf7gMWP/jpD+N6QqM6rXEfm/WJayjsZnaXpG9Jqkj6rrs/Ht1+gQb0+3ZHIw95Sepe/Vth/Z2R1WF95ScPFtb27bwi3LfvSCWsd42HZZ25tvg/Gkm6b3hLYe3Fd3873PeKv4n/o9Kv3ojrCW32TYW1ul/Gm1lF0pOSPifpJkn3m9lN9d4fgNZq5D37rZJ2uvsudx+X9ANJ65rTFoBmayTsqyXtnfH7vtq2c5jZiJltNbOtVY018HAAGtHyT+Pdfb27D7v7cI/6Wv1wAAo0Evb9ktbM+P2q2jYAHaiRsG+RdIOZXWtmvZK+IGljc9oC0Gx1D725+4SZPSTpZ5oeenva3d9sWmeJ7PzzeGjt+T99Iqz/+4fXFdbWXP9euO+dwRj9XGw83R/Wd46tLKz95Jbvhvt+euThsH7jr8IyztPQOLu7vyDphSb1AqCF+LoskARhB5Ig7EAShB1IgrADSRB2IIl5nc+O2a38z8mwvuXz8RTYd8cvL6wdqi4J9335VDyXvlIyob2vZEJ81Yun0G4evTLct39X3BsuDEd2IAnCDiRB2IEkCDuQBGEHkiDsQBIMvXWAhYfiUyJXPf5rioa/Biuj4b79ldaeKuzERPEU2GhYTpK6Tze7m9w4sgNJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEoyzd4CuE8XLGkvS3QM7w/qTx/6wsFY2zl421t1j8fTbsvqZqeJpqqen4hWCBg6WrBeNC8KRHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYJy9A5y4eVlY3zJ2RVg/NVk8Xj02NVRXT2dNuTW0/7HqQGHtqt73w30PfCYeZx/8x7paSquhsJvZbkknJU1KmnD34WY0BaD5mnFk/4y7H23C/QBoId6zA0k0GnaX9KKZvWpmI7PdwMxGzGyrmW2tqrXnOwNQrNGX8be5+34zu0LSS2b23+7+8swbuPt6SeslabENeYOPB6BODR3Z3X1/7fKwpOck3dqMpgA0X91hN7MBMxs8e13SnZK2N6sxAM3VyMv4FZKeM7Oz9/MP7v4vTekqmwePhOXV3cfDel9X8Xnjy+abl42jL+s9FdbfHYvH8Qe7i+fTj5acD//jN+4P67wnvDB1h93dd0m6uYm9AGghht6AJAg7kARhB5Ig7EAShB1IgimuHeCyL8VrEx//5cKwvqCrWlg7NRGfrvm6hfGw347TV4b17q54aK+RYcG3d1wV1m9QPDSHc3FkB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkGGfvABMHD4X1F47Hkws/vfjtwtpPj8X7Hq0OhvWrF8bnEj04tiSsR1Nopzw+1qz6RVjGBeLIDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJMM5+EThe7Q/ra7qPFdZ+b/Gvw33fOhPPVy+zqDte0qs6VSmsjU71hPsO7opPY82ppC8MR3YgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSIJx9ovAK3uuC+t/smxzYe39iYFw37UD74b1srHwMtVgWeajE4vCfbs+LD4fviTFZ53H+UqP7Gb2tJkdNrPtM7YNmdlLZvZO7XJpa9sE0Ki5vIz/nqS7ztv2iKRN7n6DpE213wF0sNKwu/vLks7/PuY6SRtq1zdIuqe5bQFotnrfs69w9wO16wclrSi6oZmNSBqRpAWKv+MNoHUa/jTe3V3BnAR3X+/uw+4+3KN4kUEArVNv2A+Z2SpJql0ebl5LAFqh3rBvlPRA7foDkp5vTjsAWqX0PbuZPSvpdknLzGyfpK9LelzSD83sQUl7JN3Xyiazq47Gf02jXjwWXvXi+eSSNFly7vYyZWusR2vHX9nzfrjv5oVr62kJBUrD7u73F5TuaHIvAFqIr8sCSRB2IAnCDiRB2IEkCDuQBFNcLwKf/Z0dYf3IxOLCWtnQ26FqvOTylb3x8NgCi6eh7q0OFdaG+uJTRR/663hY74p1YRnn4cgOJEHYgSQIO5AEYQeSIOxAEoQdSIKwA0kwzn4RuG7h0bB+YrL4dF9Lu0+H+/Z3jYf1Lk2F9WgcXZIqwcLKe6uXh/v+2cf+I6z/tHt5WPeJibCeDUd2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiCcfYOMPXHt4T1/q5/C+snJxcU1nq64rHmd8fise6KxePsSyofhvWh7uI560cmBsN9y05TffLeT4b1Rf9UvJR1RhzZgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJxtk7wJGbF4b1vmDZY0k6MVm8/5nJvnDfsnH0svnw1/TGc+2PB3Pty3orG2c//rH4nPiLwmo+pUd2M3vazA6b2fYZ2x4zs/1mtq32c3dr2wTQqLm8jP+epLtm2f5Nd19b+3mhuW0BaLbSsLv7y5KOzUMvAFqokQ/oHjKz12sv85cW3cjMRsxsq5ltrWqsgYcD0Ih6w/5tSddLWivpgKQnim7o7uvdfdjdh3sUfyADoHXqCru7H3L3SXefkvQdSbc2ty0AzVZX2M1s1Yxf75W0vei2ADpD6Ti7mT0r6XZJy8xsn6SvS7rdzNZKckm7JX25dS1e+s6sLD63uiQNdMWfdYxO9RTWBiujde8rSZdVzoT1w8Ha8JI05VZcU3FNkj6xcG9YnxiInzecqzTs7n7/LJufakEvAFqIr8sCSRB2IAnCDiRB2IEkCDuQBFNcO0B1KJ7KubZvX1jfM7assLaoZOjtqt542kM0RVWSTkzE9SXdxUN31al4iuqxyXiS6vjKeOovzsWRHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYJy9A3QvHg/rvzhzY933vabnvbC+Z3x5WB/1+J9INI4uSVUvHkvvr8R/7n3jQ2G9f2m8XDTOxZEdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5JgnL0DLB6Mx6pX97wf1pd3f1BY2zm2Mtx3suR0zksq8Vj2qckFYT3SpfhU0KdKlnRe3B/P1ce5OLIDSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBKMs3eASlc83ry8UjyOLkmvnP543Y+9pGRJ5rGSJZ2j+eqS1GPF58Sv2FS8b1d8Pv1FvfF8eJyr9MhuZmvM7Odm9paZvWlmX61tHzKzl8zsndrl0ta3C6Bec3kZPyHpa+5+k6Q/kPQVM7tJ0iOSNrn7DZI21X4H0KFKw+7uB9z9tdr1k5J2SFotaZ2kDbWbbZB0T4t6BNAEF/Se3cyukXSLpM2SVrj7gVrpoKQVBfuMSBqRpAWK1wUD0Dpz/jTezBZJ+pGkh939nE+M3N2l2Wc1uPt6dx929+EexRMbALTOnMJuZj2aDvoz7v7j2uZDZraqVl8l6XBrWgTQDKUv483MJD0laYe7f2NGaaOkByQ9Xrt8viUdJvDheDy8tcAmwvqkF/+f3dMV79tl8bDfmcnesB4NrU3ff/Hw2mTJsF6ZJb3x9NuTDd37pWcu79k/JemLkt4ws221bY9qOuQ/NLMHJe2RdF9LOgTQFKVhd/dXpMIzHNzR3HYAtApflwWSIOxAEoQdSIKwA0kQdiAJprh2gPHx+K/hsq76p3KWjdGXTWHtL3nssiWd+4Jx+LLpsaMlvfWWTIHFuTiyA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EASjLN3gPEz8Xjy7oklYX2wUrx0cdmSzI0qG4eP5ruXjbNPeWt7z4YjO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kwTh7B6gcjc/NPthVPI4uST3BnPW+kvPClykbC68oXnb5xOTCwtqCrmpdPZ010B2P8b/X0L1fejiyA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EASc1mffY2k70taIcklrXf3b5nZY5L+QtKR2k0fdfcXWtXopaw7Xma8VDU4d3uP4vPGj3rZ2vDxWPjy7ngV9NFq8f2fmOoP9x2biv95Rmu/46Pm8qWaCUlfc/fXzGxQ0qtm9lKt9k13/7vWtQegWeayPvsBSQdq10+a2Q5Jq1vdGIDmuqD37GZ2jaRbJG2ubXrIzF43s6fNbGnBPiNmttXMtlY11li3AOo257Cb2SJJP5L0sLt/IOnbkq6XtFbTR/4nZtvP3de7+7C7D/eor/GOAdRlTmE3sx5NB/0Zd/+xJLn7IXefdPcpSd+RdGvr2gTQqNKwm5lJekrSDnf/xoztq2bc7F5J25vfHoBmmcun8Z+S9EVJb5jZttq2RyXdb2ZrNT0ct1vSl1vQXwqLd8X13pJppFf3HimsLS6ZHnv7wvi+902cCusrKsVTWCXp/akDhbXdE/HU3r3Vy8P6Px+7OazjXHP5NP4VadaTjzOmDlxE+AYdkARhB5Ig7EAShB1IgrADSRB2IAlOJd0Blv/s12F92yNrwvqTO28vrHU/MxTuO/TKvrDuC0u+4lyJjxf2wel4/wZM7P+/lt33pYgjO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kYe6NLel7QQ9mdkTSnhmblkk6Om8NXJhO7a1T+5LorV7N7O1qd18+W2Few/6RBzfb6u7DbWsg0Km9dWpfEr3Va75642U8kARhB5Jod9jXt/nxI53aW6f2JdFbvealt7a+Zwcwf9p9ZAcwTwg7kERbwm5md5nZ/5jZTjN7pB09FDGz3Wb2hpltM7Otbe7laTM7bGbbZ2wbMrOXzOyd2uWsa+y1qbfHzGx/7bnbZmZ3t6m3NWb2czN7y8zeNLOv1ra39bkL+pqX523e37ObWUXS25I+K2mfpC2S7nf3t+a1kQJmtlvSsLu3/QsYZvZHkk5J+r67f6K27W8lHXP3x2v/US5197/skN4ek3Sq3ct411YrWjVzmXFJ90j6ktr43AV93ad5eN7acWS/VdJOd9/l7uOSfiBpXRv66Hju/rKkY+dtXidpQ+36Bk3/Y5l3Bb11BHc/4O6v1a6flHR2mfG2PndBX/OiHWFfLWnvjN/3qbPWe3dJL5rZq2Y20u5mZrHC3c+uqXRQ0op2NjOL0mW859N5y4x3zHNXz/LnjeIDuo+6zd1/V9LnJH2l9nK1I/n0e7BOGjud0zLe82WWZcZ/o53PXb3LnzeqHWHfL2nmGRSvqm3rCO6+v3Z5WNJz6rylqA+dXUG3dnm4zf38Rict4z3bMuPqgOeuncuftyPsWyTdYGbXmlmvpC9I2tiGPj7CzAZqH5zIzAYk3anOW4p6o6QHatcfkPR8G3s5R6cs4120zLja/Ny1fflzd5/3H0l3a/oT+f+V9Fft6KGgr+sk/Vft58129ybpWU2/rKtq+rONByVdLmmTpHck/aukoQ7q7e8lvSHpdU0Ha1WbertN0y/RX5e0rfZzd7ufu6CveXne+LoskAQf0AFJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEv8PE4DsMh8Hn6sAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 167, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.33333333, 0.66666667, 1. ])" - ] - }, - "execution_count": 167, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn.preprocessing import KBinsDiscretizer\n", - "import numpy as np\n", - "\n", - "bins = np.linspace(0, 1, 4)\n", - "bins\n", - "#def " - ] - }, - { - "cell_type": "code", - "execution_count": 165, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "63.75" - ] - }, - "execution_count": 165, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "255 / 4" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 164, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.0" - ] - }, - "execution_count": 164, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "(images * 255).max()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.00392156862745098" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#submission to part 1, you should make this into a .py file\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " \n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "def decode(histogram):\n", - " if 1 in histogram.keys():\n", - " image=[[0,0],[0,0]]\n", - " else:\n", - " image=[[1,1],[1,1]]\n", - " return image\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit = encode(image)\n", - "\n", - " #simulate circuit\n", - " histogram = simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re = decode(histogram)\n", - "\n", - " return circuit,image_re" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit,image_re=run_part1(data['image'])\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " circuit.h([0, 1, 2])\n", - " return circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", - " {'image': [[0, 0], [0, 0]], 'category': 1}]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 0.12499999999999994,\n", - " 1: 0.12499999999999994,\n", - " 2: 0.12499999999999994,\n", - " 3: 0.12499999999999994,\n", - " 4: 0.12499999999999994,\n", - " 5: 0.12499999999999994,\n", - " 6: 0.12499999999999994,\n", - " 7: 0.12499999999999994}" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulate(encode(dataset[0]['image']))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 0.12499999999999994,\n", - " 1: 0.12499999999999994,\n", - " 2: 0.12499999999999994,\n", - " 3: 0.12499999999999994,\n", - " 4: 0.12499999999999994,\n", - " 5: 0.12499999999999994,\n", - " 6: 0.12499999999999994,\n", - " 7: 0.12499999999999994}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulate(encode(dataset[1]['image']))" - ] - }, - { - "cell_type": "code", - "execution_count": 155, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "64" - ] - }, - "execution_count": 155, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 ** 6" - ] - }, - { - "cell_type": "code", - "execution_count": 153, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "256" - ] - }, - "execution_count": 153, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 ** 8 " - ] - }, - { - "cell_type": "code", - "execution_count": 154, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "512" - ] - }, - "execution_count": 154, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 ** 9" - ] - }, - { - "cell_type": "code", - "execution_count": 152, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 152, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(images[0] * 255)\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'desired_state' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdesired_state\u001b[49m\n", - "\u001b[0;31mNameError\u001b[0m: name 'desired_state' is not defined" - ] - } - ], - "source": [ - "desired_state" - ] - }, - { - "cell_type": "code", - "execution_count": 160, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 160, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 ** 10" - ] - }, - { - "cell_type": "code", - "execution_count": 158, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "784" - ] - }, - "execution_count": 158, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "28 * 28" - ] - }, - { - "cell_type": "code", - "execution_count": 197, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(784,)\n", - "240\n", - "(1024,)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counter({1: 1033, 2: 1022})\n" - ] - }, - { - "data": { - "text/plain": [ - "1.7936362821808585e-34" - ] - }, - "execution_count": 197, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "AMPLITUDE_ENCODING_N_QUBITS = 10\n", - "IMAGE_SIZE = 28\n", - "\n", - "def encode(image):\n", - " \n", - " image_vector = np.resize(image, IMAGE_SIZE * IMAGE_SIZE)\n", - " \n", - " qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS)\n", - " \n", - " N = IMAGE_SIZE * IMAGE_SIZE\n", - " \n", - " zero_padding = 2 ** AMPLITUDE_ENCODING_N_QUBITS - N\n", - " \n", - " print(image_vector.shape)\n", - " print(zero_padding)\n", - " \n", - " image_vector = np.concatenate((image_vector, np.zeros(zero_padding)), axis=0)\n", - " \n", - " print(image_vector.shape)\n", - " \n", - " normalization_factor = np.sqrt(np.sum(image_vector**2)) \n", - " #Else we divide each value between the sum value above\n", - " image_vector /= normalization_factor\n", - "\n", - " ###########\n", - " qc.initialize(image_vector)\n", - " ##########\n", - " \n", - " for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2):\n", - " qc = qc.decompose()\n", - " \n", - " return qc, normalization_factor\n", - "\n", - "def decode(histogram, normalizaton_factor):\n", - " histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS)\n", - " for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS):\n", - " histogram_array[i] = histogram.get(i, 0)\n", - " root = np.sqrt(histogram_array)\n", - " \n", - " root = root * normalization_factor\n", - " \n", - " N = IMAGE_SIZE * IMAGE_SIZE\n", - " \n", - " image_rec = root[:N]\n", - " \n", - " image_rec = image_rec.reshape(28, 28)\n", - " \n", - " return image_rec\n", - "\n", - "\n", - "img = images[500]\n", - "\n", - "img = np.array(img)\n", - " \n", - "qc, normalization_factor = encode(img) \n", - "\n", - "histogram = simulate(qc)\n", - "\n", - "image_rec = decode(histogram, normalization_factor)\n", - "\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "\n", - "ax1.imshow(img)\n", - "\n", - "ax2.imshow(image_rec)\n", - "\n", - "plt.show()\n", - "\n", - "print(count_gates(qc))\n", - "\n", - "image_mse(img, image_rec)" - ] - }, - { - "cell_type": "code", - "execution_count": 148, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "3.460739251294167e-05" - ] - }, - "execution_count": 148, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "0.99 ** (1022)" - ] - }, - { - "cell_type": "code", - "execution_count": 196, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Counter({1: 1033, 2: 1022})" - ] - }, - "execution_count": 196, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 117, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2000it [2:52:47, 5.18s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "4.305203764154009e-111\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "import tqdm\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit, normalization_factor = encode(image)\n", - "\n", - " #simulate circuit\n", - " histogram = simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re = decode_amplitude(histogram, normalization_factor)\n", - "\n", - " return circuit,image_re\n", - "\n", - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for i, image in tqdm.tqdm(enumerate(images)):\n", - " #encode image into circuit\n", - " circuit, image_re =run_part1(image)\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " #print(images[i].shape)\n", - " #print(image_re.shape)\n", - " mse+=image_mse(image,image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
label
0True
1True
2True
3True
4True
......
495True
496True
497True
498True
499True
\n", - "

500 rows × 1 columns

\n", - "
" - ], - "text/plain": [ - " label\n", - "0 True\n", - "1 True\n", - "2 True\n", - "3 True\n", - "4 True\n", - ".. ...\n", - "495 True\n", - "496 True\n", - "497 True\n", - "498 True\n", - "499 True\n", - "\n", - "[500 rows x 1 columns]" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "pd.DataFrame(labels, columns=[\"label\"]).query(\"label==True\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "Shirt vs no shirt\n", - "no shirt pueden ser distintos\n", - "\"\"\"" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 ** 10" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counter({2: 254, 1: 135})\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[110], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m qc_decomposed \u001b[38;5;241m=\u001b[39m qc\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mcount_gates\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqc_decomposed\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[108], line 52\u001b[0m, in \u001b[0;36mcount_gates\u001b[0;34m(circuit)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28mprint\u001b[39m(counter)\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m20\u001b[39m):\n\u001b[0;32m---> 52\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m counter\u001b[38;5;241m.\u001b[39mget(i,\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m counter\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], - "source": [ - "qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", - "count_gates(qc_decomposed)" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys([0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255])" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "histogram.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 170, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[0.7853981633974483, 1.5707963267948966, 2.356194490192345, 3.141592653589793]" - ] - }, - "execution_count": 170, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "bins = [\n", - " np.pi / 4,\n", - " np.pi / 2,\n", - " (3 / 4) * np.pi,\n", - " np.pi\n", - "]\n", - "\n", - "bins" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.linspace()" - ] - }, - { - "cell_type": "code", - "execution_count": 179, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0 2 2 3]\n", - "4.123105625617661\n" - ] - }, - { - "data": { - "text/plain": [ - "array([0. , 0.48507125, 0.48507125, 0.72760688])" - ] - }, - "execution_count": 179, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "digitized = np.digitize([0.2, 1.76, 2.2, 3.0], bins)\n", - "\n", - "normalization_factor = np.sqrt(np.sum(digitized**2)) \n", - "\n", - "print(digitized)\n", - "print(normalization_factor)\n", - "digitized = digitized / normalization_factor\n", - "\n", - "digitized" - ] - }, - { - "cell_type": "code", - "execution_count": 210, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0. , 0.78539816, 1.57079633, 2.35619449, 3.14159265])" - ] - }, - "execution_count": 210, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.linspace(0, np.pi, 5)" - ] - }, - { - "cell_type": "code", - "execution_count": 193, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counter({2: 1})\n" - ] - }, - { - "data": { - "text/html": [ - "
            ┌────────────┐ ┌───┐┌───────────┐┌───┐\n",
-       "q_0: ─|0>───┤ Ry(2.5536) ├─┤ X ├┤ Ry(0.588) ├┤ X ├\n",
-       "          ┌─┴────────────┴┐└─┬─┘└───────────┘└─┬─┘\n",
-       "q_1: ─|0>─┤ R(2.1287,π/2) ├──■─────────────────■──\n",
-       "          └───────────────┘
" - ], - "text/plain": [ - " ┌────────────┐ ┌───┐┌───────────┐┌───┐\n", - "q_0: ─|0>───┤ Ry(2.5536) ├─┤ X ├┤ Ry(0.588) ├┤ X ├\n", - " ┌─┴────────────┴┐└─┬─┘└───────────┘└─┬─┘\n", - "q_1: ─|0>─┤ R(2.1287,π/2) ├──■─────────────────■──\n", - " └───────────────┘ " - ] - }, - "execution_count": 193, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qc = QuantumCircuit(2)\n", - "qc.initialize(digitized)\n", - "\n", - "\n", - "print(count_gates(qc))\n", - "\n", - "qc.decompose().decompose().decompose().decompose().decompose().draw()" - ] - }, - { - "cell_type": "code", - "execution_count": 212, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.125 0.25 0.375 0.5 0.625 0.75 0.875 1. ]\n", - "[0. 0. 0. 0. 0. 0.\n", - " 0. 0. 0.15294118 0.35294118 0.52941176 0.78431373\n", - " 0.51764706 0.23529412 0.25098039 0.3254902 0.71764706 0.76470588\n", - " 0.38039216 0.11372549]\n", - "[0 0 0 0 0 0 0 0 1 2 4 6 4 1 2 2 5 6 3 0]\n", - "(784,)\n", - "240\n", - "(1024,)\n", - "Counter({1: 1033, 2: 1022})\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "11.398437011639373" - ] - }, - "execution_count": 212, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "\n", - "AMPLITUDE_ENCODING_N_QUBITS = 10\n", - "IMAGE_SIZE = 28\n", - "COLOR_BUCKETS = 8\n", - "\n", - "def encode(image):\n", - " \n", - " image = image * 255\n", - " \n", - " bins = np.linspace(0, 1.0, COLOR_BUCKETS + 1)[1:]\n", - " \n", - " print(bins)\n", - " \n", - " image_vector = np.resize(image, IMAGE_SIZE * IMAGE_SIZE)\n", - " \n", - " print(image_vector[:20])\n", - " \n", - " image_vector = np.digitize(image_vector, bins)\n", - " \n", - " print(image_vector[:20])\n", - " \n", - " qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS)\n", - " \n", - " N = IMAGE_SIZE * IMAGE_SIZE\n", - " \n", - " zero_padding = 2 ** AMPLITUDE_ENCODING_N_QUBITS - N\n", - " \n", - " print(image_vector.shape)\n", - " print(zero_padding)\n", - " \n", - " image_vector = np.concatenate((image_vector, np.zeros(zero_padding)), axis=0)\n", - " \n", - " print(image_vector.shape)\n", - " \n", - " normalization_factor = np.sqrt(np.sum(image_vector**2)) \n", - " #Else we divide each value between the sum value above\n", - " image_vector /= normalization_factor\n", - "\n", - " ###########\n", - " qc.initialize(image_vector)\n", - " ##########\n", - " \n", - " for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2):\n", - " qc = qc.decompose()\n", - " \n", - " return qc, normalization_factor\n", - "\n", - "def decode(histogram, normalizaton_factor):\n", - " histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS)\n", - " for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS):\n", - " histogram_array[i] = histogram.get(i, 0)\n", - " root = np.sqrt(histogram_array)\n", - " \n", - " root = root * normalization_factor\n", - " \n", - " N = IMAGE_SIZE * IMAGE_SIZE\n", - " \n", - " image_rec = root[:N]\n", - " \n", - " image_rec = image_rec.reshape(28, 28)\n", - " \n", - " return image_rec\n", - "\n", - "\n", - "img = images[0]\n", - "\n", - "img = np.array(img)\n", - " \n", - "qc, normalization_factor = encode(img) \n", - "\n", - "print(count_gates(qc))\n", - "\n", - "histogram = simulate(qc)\n", - "\n", - "image_rec = decode(histogram, normalization_factor)\n", - "\n", - "\n", - "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "\n", - "ax1.imshow(img)\n", - "\n", - "ax2.imshow(image_rec)\n", - "\n", - "plt.show()\n", - "\n", - "image_mse(img, image_rec)" - ] - }, - { - "cell_type": "code", - "execution_count": 190, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Counter({2: 1})" - ] - }, - "execution_count": 190, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# from https://stackoverflow.com/questions/42463172/how-to-perform-max-mean-pooling-on-a-2d-array-using-numpy\n", - "import numpy as np\n", - "def asStride(arr,sub_shape,stride):\n", - " '''Get a strided sub-matrices view of an ndarray.\n", - " See also skimage.util.shape.view_as_windows()\n", - " '''\n", - " s0,s1=arr.strides[:2]\n", - " m1,n1=arr.shape[:2]\n", - " m2,n2=sub_shape\n", - " view_shape=(1+(m1-m2)//stride[0],1+(n1-n2)//stride[1],m2,n2)+arr.shape[2:]\n", - " strides=(stride[0]*s0,stride[1]*s1,s0,s1)+arr.strides[2:]\n", - " subs=np.lib.stride_tricks.as_strided(arr,view_shape,strides=strides)\n", - " return subs\n", - "\n", - "def poolingOverlap(mat,ksize,stride=None,method='max',pad=False):\n", - " '''Overlapping pooling on 2D or 3D data.\n", - " : ndarray, input array to pool.\n", - " : tuple of 2, kernel size in (ky, kx).\n", - " : tuple of 2 or None, stride of pooling window.\n", - " If None, same as (non-overlapping pooling).\n", - " : str, 'max for max-pooling,\n", - " 'mean' for mean-pooling.\n", - " : bool, pad or not. If no pad, output has size\n", - " (n-f)//s+1, n being size, f being kernel size, s stride.\n", - " if pad, output has size ceil(n/s).\n", - " Return : pooled matrix.\n", - " '''\n", - "\n", - " m, n = mat.shape[:2]\n", - " ky,kx=ksize\n", - " if stride is None:\n", - " stride=(ky,kx)\n", - " sy,sx=stride\n", - "\n", - " _ceil=lambda x,y: int(np.ceil(x/float(y)))\n", - "\n", - " if pad:\n", - " ny=_ceil(m,sy)\n", - " nx=_ceil(n,sx)\n", - " size=((ny-1)*sy+ky, (nx-1)*sx+kx) + mat.shape[2:]\n", - " mat_pad=np.full(size,np.nan)\n", - " mat_pad[:m,:n,...]=mat\n", - " else:\n", - " mat_pad=mat[:(m-ky)//sy*sy+ky, :(n-kx)//sx*sx+kx, ...]\n", - "\n", - " view=asStride(mat_pad,ksize,stride)\n", - "\n", - " if method=='max':\n", - " result=np.nanmax(view,axis=(2,3))\n", - " else:\n", - " result=np.nanmean(view,axis=(2,3))\n", - "\n", - " return result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - }, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/part1_with_pca.ipynb b/part1_with_pca.ipynb deleted file mode 100644 index eea7591..0000000 --- a/part1_with_pca.ipynb +++ /dev/null @@ -1,1327 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(3,20):\n", - " assert counter.get(i,0)==0\n", - " \n", - " \n", - " return counter\n", - "\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.000000\n" - ] - } - ], - "source": [ - "a = 1e-9\n", - "print('{:f}'.format(a))" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", - " {'image': [[0, 0], [0, 0]], 'category': 1}]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "#submission to part 1, you should make this into a .py file\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "def decode(histogram):\n", - " if 1 in histogram.keys():\n", - " image=[[0,0],[0,0]]\n", - " else:\n", - " image=[[1,1],[1,1]]\n", - " return image\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit = encode(image)\n", - "\n", - " #simulate circuit\n", - " histogram = simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re = decode(histogram)\n", - "\n", - " return circuit,image_re" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit,image_re=run_part1(data['image'])\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " circuit.h([0, 1, 2])\n", - " return circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'image': [[1, 1], [1, 1]], 'category': 0},\n", - " {'image': [[0, 0], [0, 0]], 'category': 1}]" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 0.12499999999999994,\n", - " 1: 0.12499999999999994,\n", - " 2: 0.12499999999999994,\n", - " 3: 0.12499999999999994,\n", - " 4: 0.12499999999999994,\n", - " 5: 0.12499999999999994,\n", - " 6: 0.12499999999999994,\n", - " 7: 0.12499999999999994}" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulate(encode(dataset[0]['image']))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 0.12499999999999994,\n", - " 1: 0.12499999999999994,\n", - " 2: 0.12499999999999994,\n", - " 3: 0.12499999999999994,\n", - " 4: 0.12499999999999994,\n", - " 5: 0.12499999999999994,\n", - " 6: 0.12499999999999994,\n", - " 7: 0.12499999999999994}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "simulate(encode(dataset[1]['image']))" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'desired_state' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mdesired_state\u001b[49m\n", - "\u001b[0;31mNameError\u001b[0m: name 'desired_state' is not defined" - ] - } - ], - "source": [ - "desired_state" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "784" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "28 * 28" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": { - "jupyter": { - "source_hidden": true - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Raw Image data\n", - "[0. 0. 0. 0. 0.]\n", - "Image PCA\n", - "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", - " 2.54252086e-03]\n", - "Image PCA min_ removed\n", - "[0. 0.00930002 0.02270273 0.00663033 0.01194021]\n", - "(28, 28)\n", - "(64,)\n", - "0.9999999999999998\n", - "PCA normalized\n", - "[0. 0.12037 0.29384 0.08582 0.15454]\n", - "Squared PCA\n", - "[0. 0.01449 0.08634 0.00736 0.02388]\n", - "###########Histogram\n", - "[0. 0.01448892 0.0863424 0.00736442 0.02388317]\n", - "Histogram root\n", - "[0. 0.12036993 0.29384077 0.0858162 0.15454181]\n", - "Denormalized \n", - "[0. 0.00930002 0.02270273 0.00663033 0.01194021]\n", - "Sumar mínimo\n", - "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", - " 2.54252086e-03]\n", - "(64,)\n", - "Reconstructed Image PCA\n", - "[-9.39768822e-03 -9.76664193e-05 1.33050374e-02 -2.76735712e-03\n", - " 2.54252086e-03]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAC4CAYAAAD61bdSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAAAe/klEQVR4nO2da4xd53We33VuM8OZIYf3i0iJlERJkaVYQmhZjlVXgS+QDQdygEK16roCbJT+YaNx4xYQ1B8JCgR1kcRpCxQJlEqQjDi+wJZjwbVjG3RaObAiS9ZdoiXLMq8ihyLF4ZBzO7fVH3NUUFzvF54zZ87MfEfvAwiaWVxn72/vvfY6e/a6mbtDCCFEfhSWewFCCCEWhhy4EEJkihy4EEJkihy4EEJkihy4EEJkihy4EEJkSlcO3MxuM7OXzOwVM7t7sRYlxHIj2xY5YAvNAzezIoCXAXwQwBEAjwO4091fTH2mYgM+iOEF7S9Halv4sXoxyipHp7raV30j31dztBlkAwfm+LqaUTcnZjGFqs9Zt9tZkG0Xh3yovKbbXS8d7LY3furqw6UgawzyzRaqUVacizuzhN/xYlxDdYSvi0nLk3y7hWqd7Iyq8g0vMzO1M6g2ZsLK4pVpn5sAvOLurwKAmX0NwO0AkkY+iGG8297fxS4XgQLxns1GT7Z75FPvpqq10Wg5u+55tKvdn/iXv03lU//sXJBd8alXqG5zerqrNdBzCyzO+W2Dx3zfYm2qY9seKq/Bey79N4u1//+PNaOteKF7D2ON+GXtZe4OTu/ZGGQTV/E/3le9Fte75tXo1Yuz3CZqq8tBdvSf83UZccA7fki+QQAMHjgVhakvkVLCjqky+XIi1wzo7ro9eujLVN7NK5RLABw+7/cjLdlbMLO9ZvaEmT1RA3/yE2KF0bFtVxszS7Y4Id6k50FMd7/X3fe4+54yBnq9OyGWjPNtu1IcWu7liLch3bxCOQpgx3m/b2/JVjYd/Dk/9+F3BdmRDyT+vNo6G0QDz3HVv77zfwTZ4L+K6/ra6Zvo528YPhhkd4w8TXUvf+gzQfbSn1zPF0bY8X3+5+Dgd38WhUv0qmQJWHLbTv3ZDRKXsGriPJM//afesZmqvnF1fFVx9irynhjA6JYzQfa+bQeo7r/b9OMg21ZsP862trgqyH4+x1+L/NejHw6yF3Zvobqzh6N89Ff8+XXTk/FVYvnoG1SXvoZJxBKSrxi7oJsn8McB7DazXWZWAfBxAA8vzrKEWFZk2yILFvwE7u51M/scgB8AKAK4391fWLSVCbFMyLZFLnTzCgXu/j0A31uktQixYpBtixxQJaYQQmSKHLgQQmTKgisxF8JqW+fLXchz8jPvCbI3bqpR3dJQjMr7MV6CVpqKkefyOR6NXv983N+hO2K2wZ4rD9DPv3iCRNS/OUp151bHNUyFjOYW5Ou8flnMrgEAr0flS7/OnwcGvv94YoeLy2O+D5P+xrLU0a0Z3OLdFPKwwhoA8GmSXz7Kq25f+mzMOBneFTNIAGB2phL35fzUNU9Em6+c5td6bn3MkNl61etRNjxJP//ieLTtxn5u24zqdp6xUh6K99x1245R3RPTcX8zD/Fsni0/OBKFiWuJSsz8abe459FDX8aZ2eNBWU/gQgiRKXLgQgiRKXLgQgiRKXLgQgiRKV3lga9kjn+ed+fb9LuHg2ziGR7VKx2OgR5LVDE3KjEYXCVdBwFg/F0xmLHh/0Td4397Bf386Kr4vTt5Gf8ubgzF7ZZiV0oAQDMeLgZf5D0+ZrbFE1H+D69R3Xr1t+Ia9v2c6r4doGXzdW5YLIh56FNXUt333vx8kP3k6WuobvFcLOtubOABQCuwjohUFYPjcbunSWDydIGXvNP7azjVepYIa4n74Ews0X9qYhfV/a13vBpkpbsmqO6xY/FaDP+Ud/s02u2xu5i7nsCFECJT5MCFECJT5MCFECJT5MCFECJT5MCFECJT+iMLhTRQr3zgJFV9lWScFKo8ElzoYALc4Nn2o8n1GBDHue3x85OX8wbwxdmom8qOqZyJutNbeFSflv4nOi0Up+N3/6GTa6lu7a64kd2LNr4yQ8iQBj97lqra9pitUbhpguq+emZDkA0e57f47M5o3APDPAtljmR21EkmFAAUick2BuP1b8ZELABAgc0eTjxmFtn8apIxAwDNVfEGsSrf8FMHdwTZ7/4Gn87y5HvjAe9+NjG4vUpadgx1N6VMT+BCCJEpcuBCCJEpcuBCCJEpcuBCCJEpXQUxzewAgLMAGgDq7r5nMRbVKaVLtgXZTDURJSFxj/oG3g+8cobUlic4dykJTJV4QGX4UAx8GFFtNBLBVRKwLJ3j65q4PkaFSmd4cHR2S9StnOS6jS0xCFaf4AGZd15zKMhmUpO7l7A//T/FYth2ctI8mbLenCJ9vwHM7hoLsl3rYjsIADhwOgaRZ3fwwOTmzbFP+Pj4GqpbmIo2wIKNQCJgSdo5eJn3zG7OtL+vAjk0m0q4tLGoPLKJ3zSsV/qR6TGqW94d+5o3NibO48vxPjDSI3z+H9pLiliMLJTfcXee8iFE3si2xYpGr1CEECJTunXgDuCHZvZzM9u7GAsSYoUg2xYrnm5fodzi7kfNbBOAH5nZL9z9kfMVWsa/FwAGQSpYhFiZdGbbpdXLsUbxNqerJ3B3P9r6/wkA3wZwE9G51933uPueMrqrOhJiqejUtitF3jddiF6y4CdwMxsGUHD3s62fPwTgPy/ayjqgvn19kJklQteEwTW8Zr42GiPE3//En1Ddf3/gXwTZr/7ucqpbJNHzBkl4KfHEBE4iaF0+HaP6tGQeQKEWdaub+XkcHonnbPZ1Pj18VSkecG07H6JRP0ymfC8xC7XtkHVCSuYBwKs8M4Rx5vJog+sSfRMajfg8tmELn/5++ZpTQXZyYoQvoh6Ns74qMWRhIB6z1Unrh8TgBVYK30jsyxrRXouJYSXYGNc1NjRLVWdK8fyemuXl8VvWxBYIsxv5BPuh/aScfzbRr2NokMsvoJtXKJsBfNvm011KAP7G3f+ui+0JsVKQbYssWLADd/dXAbxzEdcixIpAti1yQWmEQgiRKXLgQgiRKX3RD7y6JgZZUnEi1kN414YY0AGA0yPTQXbHH/9HqjtwJgZaKjG2CoBPf2el9EwPAJrkqqXKjQcmSD/w3+TRUSetA1LBplt3xMnb35++lupOkyDY1HVbqe7ACghiLghHbAOQmjRPAleF1TyAOLMpGkaVGQAA93it3735INWdY9sgnweAxjAJvo0kDG6ONQTvYPI6U63wYHCdxMxZwBQASoW4jaESb6Fxw/pog48e5xPsNw7HcvwT2/j1GR6N19hrfA02cME9k+jKoCdwIYTIFDlwIYTIFDlwIYTIFDlwIYTIFDlwIYTIlL7IQvECmUpf4VHygV9G2Rc//hDVLZLQ7x2PfIHqGgmUO5+FQBvRl6fjvgYmefS9Ohy/d8sziUj9QDw3w0d5T5racNS95BO/prr/ev1Pg+wHhd+gulOsFJscA4B8u+UY4MW3HpPN8iwUhm/n5de1kWgXp2Z4U7jqXCy7/+jap6nuY1NXBNma1VNUd6ocr0ohMf29VooupVGON4LPJm4OknFSXsVTyhoDpJSelMEDQKMedbcPT1DdD6x5Ich+cjSeLwCYa8TjndnEM2F8lJTjn46DNQC0PdBBT+BCCJEpcuBCCJEpcuBCCJEpcuBCCJEpfRHEnNgdgzfVKj+0QRLre/DUb1Pdq1cdD7Ldt/2K6n5s81NBNl7j06kPzsYa+4+v/8cg+1/j76Ofn6jGINZHNz1Ldf/LTz8SZFfvOkZ1X5+KQZbdIyeo7vFGPLb6JK/9P1iI09I385hr1oR+4CSgBwCFtWNBNnUJL6VvjsSg3PQcP89G+jG8bzD2qwaAZ2ZiCfcNG1+jukPFqLv/DA+6Ts7GPtZsXXM1fm5KxXi8G1bFlhYAUG3GwOQ71x2luk+f2h63O8Cn0u8uxznWs1U+PX6aTJWvjiUCvFviPVO+sP3CmzTau0H0BC6EEJkiBy6EEJkiBy6EEJkiBy6EEJkiBy6EEJly0SwUM7sfwEcBnHD361qydQC+DmAngAMA7nD3071b5j/N9LYYyV03yiPXtXLMtNg5yAc6/Om3bw+yD33wSaq7qhCb9N/3wnuo7uiP4xpOfDJmITx1cAf9/CUbJ4Lsrw+9m+quXh/Lo+/Z+b+p7l8e+50g+/GRq6juu67hJfaMHRsmguy163nWxaW8q0FPWGzbvrClg5V4ubgPxiySmfWJW7EZszIaTf7cVSpH3TeavAz9GwduDLL3bOHDHxgnz/Ep7VPT7TVDKCVK3pvlWEI+WeXbrJOp9KtYnwoAW4Yng+z/HruS6t4x9rMgGxni0+PZEI3GCM8gqa2O17h8MnXdL8j8SVTWt/ME/gCA2y6Q3Q1gn7vvBrCv9bsQufEAZNsiYy7qwN39EQBvXCC+HcCDrZ8fBPCxxV2WEL1Hti1yZ6GFPJvd/c1qkOMAeFY/ADPbC2AvAAyCd1ETYgWxMNsurV6CpQnxVroOYrq7IzlyE3D3e919j7vvKefbLFS8DenEtivFoSVcmRDzLPQJfNzMtrr7MTPbCoDXWy8Rm56IQYOja9ZRXXtHvB/3T/MJ6Zsfj9t95eYNVHffdz8RZI0r+fT307fEgMjk4VjqOzDIJ1YffX0syIqHYgkzANQ2xL7od/1wL9Utj80G2dBjPNh4y42Hg6wwwtf72k/isW3fx4PMK4DFs+1EmbTNxfO05lf8fDQq8a/WqR28RUNtOO7vD7bGQDwAnHs2tnNAIoj50uSmIDt7pv0vLK/GYGPDeWl6dSAGN1NtMWqzUf786Daq2yTBxtd/we/lv1wfg/knj/FzXjkR17D+FaqKweOkdL/G5xYE21nkqfQPA7ir9fNdAL6zwO0IsdKQbYtsuKgDN7OvAngUwNVmdsTMPg3giwA+aGa/BPCB1u9CZIVsW+TORV+huPudiX96/yKvRYglRbYtckeVmEIIkSly4EIIkSl9MdBh+JuPBdlV32z/83xEAzB6dSyx37qKT5F+aUuMJg/8mmeGDJyOEXEjwehGIuuSVGKno9T19i/xwBaSHfFrHiX/9KW3BNmViEMt3takmvVX43kuvXyEqm46EfPLfaT9DJD9J66m8lVkAP2NIzwL5dk3YmaH1/izn5VJGTmbYJ84NV6P2200Es+ZpLz81AyvNbluXRxicuTALqr7s4PvDLKdv+Al+qXZmLlVOsPL7gsTJAslZSPFCzJ3uiilF0IIsQKRAxdCiEyRAxdCiEyRAxdCiEzpiyAmCqTvMumj3CmNtTEgcqbGA5PWiFGG4gyPPDj52mySuFSitTEKJK7Y5IPKYVNxDSldNhF8bpT3tO668we7ZsCiXLcVQ6H75yObJUYwEXtbA0BzIgbYN2yJfb8BoDYS1zZW5OX8J86QdgqJIKZXiZypFlPT2Iloipfdg0y7Hz/FS96vGYsdESqTfA1rX4zBxtKhREeFclybr+a90p30h7dEKf2FveVT6AlcCCEyRQ5cCCEyRQ5cCCEyRQ5cCCEypT+CmJ0EvjoJeDZjkKNAAicpmqn5FSQ+YWQJzdTVYUHQREyQ7atZ5sdQJVWbhV5ZSD8FK1sYsRfKhVV2AKzET7QPESOa4sFGr5Nq4FOxUnBeOW63kSj3mzsXda3ZXpANAGyaGXxiWZV4Dj0R8DQSSG3OpW4Esq9UdeMs6Ws/xJMXWCVlc5Bfy0KTVKnW+X3Qri3pCVwIITJFDlwIITJFDlwIITJFDlwIITJFDlwIITLlojkGZnY/gI8COOHu17VkfwTg3wJ4vaV2j7t/r1eLXEyMZAB4IiOiPhprzieriWg0CTCzzBKAl9Kz/shUL4F3kIXSSQZBM1HFTHdV5jX6Xkv0BFhmVpRtW+KalDtIAyLbKJ7kZfe+KU6aH6+N8e3W4nZTmSEUkkjjrEc4eEuKVNk9kxan+E3TJDdCdYyfc5uO/by9mOh/TrJIrJE4N+wap/qBt0k7LuIBALcR+Z+7+w2t/7Jw3kJcwAOQbYuMuagDd/dHALyxBGsRYkmRbYvc6eYd+OfM7Fkzu9/M1qaUzGyvmT1hZk/UwEcNCbHC6Ni2qw1eXCNEL1moA/8LAFcAuAHAMQB/llJ093vdfY+77ymzl2FCrCwWZNuVIp/FKEQvWVChtLuPv/mzmf0VgO8u2opWEHNr4+mZnuNBzMJc/C5MBRZTwc1ewAKhqf2zNgG10fYDnt7Ivzy+G9u+sIezkcA20wOSleU0yOVVHhRmAfrmSf6GaG7N1iD75UwMbAJAYYoE/hO2XSBV6DRonjg37JylAogskFqc42fy2HQcDl0dTazhHPlrqoNSeqvx+8DLpIVComd8T/uBm9n5V//3ADy/kO0IsdKQbYucaCeN8KsAbgWwwcyOAPhDALea2Q2Yz+Q5AOAzvVuiEL1Bti1y56IO3N3vJOL7erAWIZYU2bbIHVViCiFEpsiBCyFEpvTHQIdOaDO6CwCNStSdnuPl4qUZ9nleJsumyhfrJDMhEamnpBrkkyucKtGv1UlqgbLjFp22Bz8A8IHYy8BW8YtSGIsT2RsnT1Hd2XXRCF6b4RPd2QyTVCl8YxXJymC2zUrmE3gpUUrPslBmeHrMa5MxC2VuYyJrimXzDA9R1cI0GZiRKo9npfSJFgoa6CCEEH2OHLgQQmSKHLgQQmSKHLgQQmTK2y+I2QEsiHnuHC+pHSA9k5up4Eub8ZtkP3A6aZ6rNkmgp0CCSgAwczb2qqkkArHi4qRKwBmsDB4AmpUoL43wICYNtJ04SXXP7I4R8kqBB/UaQySaXk4E6AdjhJ5Oik9Nj2cB08R9VByNdfs1MqkeANYNxPYDA7tO8yWMxRr75ghPXjAyad5LievO2iIkkioUxBRCiD5HDlwIITJFDlwIITJFDlwIITJFDlwIITLl7ZeF0kEZ89RWklmSiJ53O6ShTkqQC52UGydKmzv5irbJmMpS3dDBgTXzH+iw0mBDAHyQZ0T4IOubwPsx+OqYwfHaFC+lZxknVuHXulknBkcyobyc6BPBhj+kptKzjJUBvt0zUzFDZ8faCb6EwXgePFHy3lwVr4XVO+mB0R16AhdCiEyRAxdCiEyRAxdCiEyRAxdCiExpZybmDgBfBrAZ84Wu97r7fzezdQC+DmAn5mcH3uHuvDZ1BdHJ5PTZje0HI2jZe6qilshYz+Um1Uz0Z05UJjcGSQAqcQpY//GBDaTReacUyOJWQMBzRdl2KXEBCZ4ou7fZWMae0i0NxPN/aoqX6NtcNGRPBNhpn+9E6wb6eTaVPlG23yTHZqSlBQDMnI5BzI3bjlDd8VUbg6x0do6vgbQ6sEQ/cFZib4ngaLKNxgW0o1YH8AV3vxbAzQA+a2bXArgbwD533w1gX+t3IXJCti2y5qIO3N2PufuTrZ/PAtgP4BIAtwN4sKX2IICP9WiNQvQE2bbInY7ywM1sJ4AbATwGYLO7H2v903HM/xnKPrMXwF4AGNR8LrFC6dq2S3FklxC9pu0gppmNAPgWgM+7++T5/+buDv5qF+5+r7vvcfc9ZcR2pUIsN4th25Uin5koRC9py4GbWRnzBv4Vd3+oJR43s62tf98K4ERvlihE75Bti5xpJwvFANwHYL+7f+m8f3oYwF0Avtj6/3d6ssLFppPsh00k8jzNT1ljiDVrb39XlFTPexapT+2LlCY3E1edZQDs3vQ61Z1boZklnbBsts0yD+r83BXmYmYJGyIAAKjG8ngbHaGq68fOBdlMNTEVZCSuoVBKlOizUnqmx0rmwcvjLbGvMinnryd0jexvw0A8BwBwZDTeIJWjieEPa4bjvmr8WnqhgwEfbbb8aOcd+HsBfBLAc2b2dEt2D+aN+xtm9mkABwHc0fbqhFgZyLZF1lzUgbv7P4AO8QIAvH9xlyPE0iHbFrmjSkwhhMgUOXAhhMiU/u0HnihRpVGSBLu3xeSDl5/fzjfbfiU0DRZSFuHrlZXNpwKeBVKGPFaZprqvX39VkDWf2d/R2vqeDmzQZ3jLgsLZmJ5otRhUTG53/VqqOjYY93dulqf5Fkjv7mIpEagrRt2mk0B6IthppK99al/09KaCo7PxBt1Q5kHMc1ujWxx+apbqFobiObOz/J4pkDoYa3TXO1xP4EIIkSly4EIIkSly4EIIkSly4EIIkSly4EIIkSl9nIWSmqYQI9rFMT6N+6o140H2ytylbS+BBN/TSyPB6OJsYhJ2osE91WXZMYkJ9jYX97exwiP1r+6O3feGn+FrMNJ43zMru18QiZJ3lnnQJGXwAFBIZZwwSDn+3OUbqOpQYSrIpicHqa6TgQ4NS7gONkGeDXlIZYsQWbPYvpuyGX7fF8kx1BKpY9U1cW1erfIdsutTb/+aeTGRjdNmdoqewIUQIlPkwIUQIlPkwIUQIlPkwIUQIlP6NojJAmcAD541rrmM6v7jeCyJTU10b1RYI+OELjvrbNJ8Kg5LDs1L7Qc2U6X8bNr9j4/EknkAGOmgAtjrPEDX96RK6YncEsEsL0djYTKA9wk/u6NCdW8YjQH6V0fW8+2OkhL9RIS+0SABzzoLYtOPo0CCoAVSng8ARgy2WuE9zRskaPqbQ4ep7t9sjtu1VXwcJL0WQzwY3AleSDXJfCt6AhdCiEyRAxdCiEyRAxdCiEyRAxdCiEy5qAM3sx1m9vdm9qKZvWBmv9+S/5GZHTWzp1v/faT3yxVi8ZBti9xpJwulDuAL7v6kmY0C+LmZ/aj1b3/u7n/au+V1QZtRXACYvJxHmCvFs0FWnuLbnWVpGalMDRbBJ9H3+nAi5YVE1NnU7fmNkLJgVu4MYOBk/D7/0KW/4Jv9T1H3+Yf4EqwSMyF8bo4rLy3LY9sdDBVBg9jAAL9ta+vjhPSZjdwujs3G9hH1NifKA0CzkcjyIofWrJHtJuy1yQY6VLguy0JJTjgl+xsrxnYCAFDfFMvmm+tj6wgAsCopm0+0UGCtDjqyBUI7Q42PATjW+vmsme0HcElXexViBSDbFrnT0TtwM9sJ4EYAj7VEnzOzZ83sfjOjs5vMbK+ZPWFmT9SwIp66hAh0a9vVBh+JJkQvaduBm9kIgG8B+Ly7TwL4CwBXALgB808xf8Y+5+73uvsed99TBp+5J8Ryshi2XSnG2ZVC9Jq2HLiZlTFv4F9x94cAwN3H3b3h7k0AfwXgpt4tU4jeINsWOXPRd+BmZgDuA7Df3b90nnxr6x0iAPwegOd7s8Tec+JdXP6e0dNBdvjydVR3cCQGPkqpyd0kiFkuRt2BMu8r3GjG790qKVcG+ETwFOdIufD+yS1U99b1LwfZ8+CBHjS7C9T0ip7bdipAxabHJ/qBs6vnA7xcvDYSb+fprTygtnPVqSAb3zDKdUfeCLICCyACmCMN6KfrMYg92+DHwLY7UuKvXoeK8ZyNz/JjOFeNf/1fX5mkups3nwmy+sgI1S1NxPNrLFgJAKV4bixxb7RbSt9OFsp7AXwSwHNm9nRLdg+AO83sBsx38TgA4DNt7VGIlYNsW2RNO1ko/wD+IPC9xV+OEEuHbFvkjioxhRAiU+TAhRAiU+TAhRAiU/p2oIN3MM1791f45PXnDl4bZJe9zLMF6iSDY2ZdB6XJpfgqNlX25Oyq8SQUlGdilLsc51QAANZMx4j6kSd2Ud2vT0f5GB6lul5LTPR+u8IGOqxK5JGfmgiiQmJYSaUU7W39M7xNxLcnbwmycuwcAQAYL28PslRyE7NNI7diIomFDzFJJTGxjhSJm6ZOZizc/NIfUN3hg/H8rp2MmTgAUDgdM1lSbSKMDX9IDf1oEz2BCyFEpsiBCyFEpsiBCyFEpsiBCyFEpph32Y+2o52ZvQ7gYOvXDQBOLtnOlw4d1/JxmbtvXI4dn2fbOZynhdKvx5bDcVHbXlIH/pYdmz3h7nuWZec9RMf19qafz1O/HlvOx6VXKEIIkSly4EIIkSnL6cDvXcZ99xId19ubfj5P/Xps2R7Xsr0DF0II0R16hSKEEJkiBy6EEJmy5A7czG4zs5fM7BUzu3up97+YtCaWnzCz58+TrTOzH5nZL1v/pxPNVzJmtsPM/t7MXjSzF8zs91vy7I+tl/SLbcuu8zm2JXXgZlYE8D8BfBjAtZgfXRVb/uXDAwBuu0B2N4B97r4bwL7W77lRB/AFd78WwM0APtu6Tv1wbD2hz2z7Acius2Cpn8BvAvCKu7/q7lUAXwNw+xKvYdFw90cAXNhn8nYAD7Z+fhDAx5ZyTYuBux9z9ydbP58FsB/AJeiDY+shfWPbsut8jm2pHfglAA6f9/uRlqyf2HzeRPPjADYv52K6xcx2ArgRwGPos2NbZPrdtvvq2veLXSuI2UN8Pkcz2zxNMxsB8C0An3f3t3Suz/3YxMLJ/dr3k10vtQM/CmDHeb9vb8n6iXEz2woArf+fWOb1LAgzK2PeyL/i7g+1xH1xbD2i3227L659v9n1UjvwxwHsNrNdZlYB8HEADy/xGnrNwwDuav18F4DvLONaFoSZGYD7AOx39y+d90/ZH1sP6Xfbzv7a96NdL3klppl9BMB/w/wUx/vd/Y+XdAGLiJl9FcCtmG9HOQ7gDwH8LYBvALgU8+1F73B3PlBvhWJmtwD4CYDnALw5KPMezL8vzPrYekm/2LbsOp9jUym9EEJkioKYQgiRKXLgQgiRKXLgQgiRKXLgQgiRKXLgQgiRKXLgQgiRKXLgQgiRKf8PDajlwsR6j4AAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "from sklearn.decomposition import PCA\n", - "\n", - "def encode_amplitude(images, image_index, n_qubits, debug=False):\n", - " N_images = len(images)\n", - " # We have 28x28 images as input\n", - " # - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\n", - " # 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \n", - " # into n_qubits (parametrized)\n", - " \n", - " \n", - " # [apply PCA]\n", - " # Create an instance of PCA\n", - " pca = PCA(n_components=2**n_qubits)\n", - "\n", - " # Fit PCA on your 784-dimensional data\n", - " data = images.reshape(N_images, 28 * 28)\n", - " pca.fit(data)\n", - "\n", - " # Apply dimensionality reduction on your data\n", - " data_pca = pca.transform(data)\n", - "\n", - " image = images[image_index]\n", - " \n", - " image_pca = data_pca[image_index]\n", - " \n", - " min_ = image_pca.min()\n", - " \n", - " image_pca = image_pca - min_\n", - " \n", - " \n", - " # [normalize]\n", - " def normalize(row):\n", - " #We calculate the squareroot of the sum of the square values of the row\n", - " normalization_factor = np.sqrt(np.sum(row**2)) \n", - " if normalization_factor == 0.:\n", - " #If the sum is zero we return a 0\n", - " return 0.0\n", - " #Else we divide each value between the sum value above\n", - " row = row / normalization_factor\n", - " return row, normalization_factor\n", - " \n", - " image_pca_normalized, normalization_factor = normalize(image_pca)\n", - " \n", - " \n", - " desired_state = image_pca_normalized\n", - " \n", - " ##########\n", - " # Amplitude Encoding\n", - " qc = QuantumCircuit(n_qubits)\n", - " qc.initialize(desired_state)\n", - " qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", - "\n", - " ##########\n", - " \n", - " decoder_params = dict(\n", - " pca=pca,\n", - " min_=min_,\n", - " normalization_factor=normalization_factor,\n", - " n_qubits=n_qubits,\n", - " image=image\n", - " )\n", - " \n", - " return qc_decomposed, decoder_params\n", - "\n", - "def decode_amplitude(histogram, normalization_factor, min_, pca, n_qubits, image):\n", - " \n", - " histogram_array = np.zeros(2 ** n_qubits)\n", - " \n", - " for i in range(2 ** n_qubits):\n", - " histogram_array[i] = histogram.get(i, 0)\n", - "\n", - " root = np.sqrt(histogram_array)\n", - " \n", - " \n", - " root = root * normalization_factor\n", - " \n", - "\n", - " root = root + min_\n", - "\n", - " \n", - " reconstruction = pca.inverse_transform([root])\n", - " \n", - " #print(reconstruction)\n", - " \n", - " reconstructed_image = reconstruction[0].reshape(28, 28)\n", - " \n", - " if debug:\n", - " \n", - " fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", - "\n", - " ax1.imshow(image)\n", - " \n", - " ax2.imshow(reconstructed_image)\n", - " \n", - " plt.show()\n", - " \n", - " return reconstructed_image\n", - "\n", - "qc, decoder_params = encode_amplitude(images, 250, 6, debug=True) \n", - "\n", - "histogram = simulate(qc)\n", - "\n", - "\n", - "image = decode_amplitude(histogram, **decoder_params, debug=True)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "121" - ] - }, - "execution_count": 73, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qc.depth()" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Counter({1: 69, 2: 62})" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "count_gates(qc)\n", - "# 4 qubits -> 2x qubit gates\n", - "# 6 qubits -> 62 2 qubit gates\n", - "# 8 qubits -> 253 2 qubit gates" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "50it [02:08, 2.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5868325769829128\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "import tqdm\n", - "\n", - "def run_part1(images, image_index, n_qubits=8):\n", - " #encode image into a circuit\n", - " circuit, decoder_params = encode_amplitude(images, image_index, n_qubits=n_qubits)\n", - "\n", - " #simulate circuit\n", - " histogram = simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re = decode_amplitude(histogram, **decoder_params)\n", - "\n", - " return circuit,image_re\n", - "\n", - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "max_iter = 50\n", - "\n", - "n_qubits = 6\n", - "\n", - "\n", - "# 1 - mse with 4 qubits - > 0.18 \n", - "# 2 - mse with 6 qubits -> 0.5868325769829128\n", - "\n", - "for i, data in tqdm.tqdm(enumerate(images)):\n", - " #encode image into circuit\n", - " circuit, image_re =run_part1(images, i, n_qubits=n_qubits)\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " #print(images[i].shape)\n", - " #print(image_re.shape)\n", - " images_orig = images[i] * 255\n", - " image_re *= 255\n", - " \n", - " mse+=image_mse(images_orig,image_re)\n", - " \n", - " if i == max_iter:\n", - " break\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/max_iter\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "#images[1500]" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1e-06" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from sklearn.metrics import mean_squared_error\n", - "\n", - "round(mean_squared_error(images[1500] * 255 * 255, image_re), 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(images[max_iter] * 255 * 255)\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(image_re * 255 * 255)\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "7.133031791432462e-08" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "image_mse(images[max_iter], image_re)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(images[max_iter])" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(image_re)" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
label
0True
1True
2True
3True
4True
......
495True
496True
497True
498True
499True
\n", - "

500 rows × 1 columns

\n", - "
" - ], - "text/plain": [ - " label\n", - "0 True\n", - "1 True\n", - "2 True\n", - "3 True\n", - "4 True\n", - ".. ...\n", - "495 True\n", - "496 True\n", - "497 True\n", - "498 True\n", - "499 True\n", - "\n", - "[500 rows x 1 columns]" - ] - }, - "execution_count": 87, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "pd.DataFrame(labels, columns=[\"label\"]).query(\"label==True\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\"\"\"\n", - "Shirt vs no shirt\n", - "no shirt pueden ser distintos\n", - "\"\"\"" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1024" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2 ** 10" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
                                                                              »\n",
-       "q_0: ─|0>─────────────────────────────────────────────────────────────────────»\n",
-       "                                                                              »\n",
-       "q_1: ─|0>─────────────────────────────────────────────────────────────────────»\n",
-       "                                                                              »\n",
-       "q_2: ─|0>─────────────────────────────────────────────────────────────────────»\n",
-       "                                                                              »\n",
-       "q_3: ─|0>─────────────────────────────────────────────────────────────────────»\n",
-       "                                                                              »\n",
-       "q_4: ─|0>─────────────────────────────────────────────────────────────────────»\n",
-       "                                                                              »\n",
-       "q_5: ─|0>─────────────────────────────────────────────────────────────────────»\n",
-       "          ┌───────────────────────┐┌───┐┌───────────────────────────────┐┌───┐»\n",
-       "q_6: ─|0>─┤ multiplex1_reverse_dg ├┤ X ├┤ multiplex1_reverse_reverse_dg ├┤ X ├»\n",
-       "          └─────┬────────────┬────┘└─┬─┘└───────────────────────────────┘└─┬─┘»\n",
-       "q_7: ─|0>───────┤ Ry(1.5738) ├───────■─────────────────────────────────────■──»\n",
-       "                └────────────┘                                                »\n",
-       "«                                                                           »\n",
-       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_2: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_3: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_4: ──────────────────────────────────────────────────────────────────────»\n",
-       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
-       "«q_5: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
-       "«     │  multiplex2_reverse_dg │└─┬─┘│  multiplex2_reverse_reverse_dg │└─┬─┘»\n",
-       "«q_6: ┤1                       ├──┼──┤1                               ├──┼──»\n",
-       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
-       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
-       "«                                                                           »\n",
-       "«                                                                           »\n",
-       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_2: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_3: ──────────────────────────────────────────────────────────────────────»\n",
-       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
-       "«q_4: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
-       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
-       "«q_5: ┤1 multiplex3_reverse_dg ├──┼──┤1 multiplex3_reverse_reverse_dg ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_6: ┤2                       ├──┼──┤2                               ├──┼──»\n",
-       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
-       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
-       "«                                                                           »\n",
-       "«                                                                           »\n",
-       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_2: ──────────────────────────────────────────────────────────────────────»\n",
-       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
-       "«q_3: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
-       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
-       "«q_4: ┤1                       ├──┼──┤1                               ├──┼──»\n",
-       "«     │  multiplex4_reverse_dg │  │  │  multiplex4_reverse_reverse_dg │  │  »\n",
-       "«q_5: ┤2                       ├──┼──┤2                               ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_6: ┤3                       ├──┼──┤3                               ├──┼──»\n",
-       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
-       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
-       "«                                                                           »\n",
-       "«                                                                           »\n",
-       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
-       "«                                                                           »\n",
-       "«q_1: ──────────────────────────────────────────────────────────────────────»\n",
-       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
-       "«q_2: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
-       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
-       "«q_3: ┤1                       ├──┼──┤1                               ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_4: ┤2 multiplex5_reverse_dg ├──┼──┤2 multiplex5_reverse_reverse_dg ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_5: ┤3                       ├──┼──┤3                               ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_6: ┤4                       ├──┼──┤4                               ├──┼──»\n",
-       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
-       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
-       "«                                                                           »\n",
-       "«                                                                           »\n",
-       "«q_0: ──────────────────────────────────────────────────────────────────────»\n",
-       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n",
-       "«q_1: ┤0                       ├┤ X ├┤0                               ├┤ X ├»\n",
-       "«     │                        │└─┬─┘│                                │└─┬─┘»\n",
-       "«q_2: ┤1                       ├──┼──┤1                               ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_3: ┤2                       ├──┼──┤2                               ├──┼──»\n",
-       "«     │  multiplex6_reverse_dg │  │  │  multiplex6_reverse_reverse_dg │  │  »\n",
-       "«q_4: ┤3                       ├──┼──┤3                               ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_5: ┤4                       ├──┼──┤4                               ├──┼──»\n",
-       "«     │                        │  │  │                                │  │  »\n",
-       "«q_6: ┤5                       ├──┼──┤5                               ├──┼──»\n",
-       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  »\n",
-       "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n",
-       "«                                                                           »\n",
-       "«     ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐\n",
-       "«q_0: ┤0                       ├┤ X ├┤0                               ├┤ X ├\n",
-       "«     │                        │└─┬─┘│                                │└─┬─┘\n",
-       "«q_1: ┤1                       ├──┼──┤1                               ├──┼──\n",
-       "«     │                        │  │  │                                │  │  \n",
-       "«q_2: ┤2                       ├──┼──┤2                               ├──┼──\n",
-       "«     │                        │  │  │                                │  │  \n",
-       "«q_3: ┤3 multiplex7_reverse_dg ├──┼──┤3 multiplex7_reverse_reverse_dg ├──┼──\n",
-       "«     │                        │  │  │                                │  │  \n",
-       "«q_4: ┤4                       ├──┼──┤4                               ├──┼──\n",
-       "«     │                        │  │  │                                │  │  \n",
-       "«q_5: ┤5                       ├──┼──┤5                               ├──┼──\n",
-       "«     │                        │  │  │                                │  │  \n",
-       "«q_6: ┤6                       ├──┼──┤6                               ├──┼──\n",
-       "«     └────────────────────────┘  │  └────────────────────────────────┘  │  \n",
-       "«q_7: ────────────────────────────■──────────────────────────────────────■──\n",
-       "«
" - ], - "text/plain": [ - " »\n", - "q_0: ─|0>─────────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_1: ─|0>─────────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_2: ─|0>─────────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_3: ─|0>─────────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_4: ─|0>─────────────────────────────────────────────────────────────────────»\n", - " »\n", - "q_5: ─|0>─────────────────────────────────────────────────────────────────────»\n", - " ┌───────────────────────┐┌───┐┌───────────────────────────────┐┌───┐»\n", - "q_6: ─|0>─┤ multiplex1_reverse_dg ├┤ X ├┤ multiplex1_reverse_reverse_dg ├┤ X ├»\n", - " └─────┬────────────┬────┘└─┬─┘└───────────────────────────────┘└─┬─┘»\n", - "q_7: ─|0>───────┤ Ry(1.5738) ├───────■─────────────────────────────────────■──»\n", - " └────────────┘ »\n", - "« »\n", - "«q_0: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_1: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_2: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_3: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_4: ──────────────────────────────────────────────────────────────────────»\n", - "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", - "«q_5: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", - "« │ multiplex2_reverse_dg │└─┬─┘│ multiplex2_reverse_reverse_dg │└─┬─┘»\n", - "«q_6: ┤1 ├──┼──┤1 ├──┼──»\n", - "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", - "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", - "« »\n", - "« »\n", - "«q_0: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_1: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_2: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_3: ──────────────────────────────────────────────────────────────────────»\n", - "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", - "«q_4: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", - "« │ │└─┬─┘│ │└─┬─┘»\n", - "«q_5: ┤1 multiplex3_reverse_dg ├──┼──┤1 multiplex3_reverse_reverse_dg ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_6: ┤2 ├──┼──┤2 ├──┼──»\n", - "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", - "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", - "« »\n", - "« »\n", - "«q_0: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_1: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_2: ──────────────────────────────────────────────────────────────────────»\n", - "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", - "«q_3: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", - "« │ │└─┬─┘│ │└─┬─┘»\n", - "«q_4: ┤1 ├──┼──┤1 ├──┼──»\n", - "« │ multiplex4_reverse_dg │ │ │ multiplex4_reverse_reverse_dg │ │ »\n", - "«q_5: ┤2 ├──┼──┤2 ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_6: ┤3 ├──┼──┤3 ├──┼──»\n", - "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", - "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", - "« »\n", - "« »\n", - "«q_0: ──────────────────────────────────────────────────────────────────────»\n", - "« »\n", - "«q_1: ──────────────────────────────────────────────────────────────────────»\n", - "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", - "«q_2: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", - "« │ │└─┬─┘│ │└─┬─┘»\n", - "«q_3: ┤1 ├──┼──┤1 ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_4: ┤2 multiplex5_reverse_dg ├──┼──┤2 multiplex5_reverse_reverse_dg ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_5: ┤3 ├──┼──┤3 ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_6: ┤4 ├──┼──┤4 ├──┼──»\n", - "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", - "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", - "« »\n", - "« »\n", - "«q_0: ──────────────────────────────────────────────────────────────────────»\n", - "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐»\n", - "«q_1: ┤0 ├┤ X ├┤0 ├┤ X ├»\n", - "« │ │└─┬─┘│ │└─┬─┘»\n", - "«q_2: ┤1 ├──┼──┤1 ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_3: ┤2 ├──┼──┤2 ├──┼──»\n", - "« │ multiplex6_reverse_dg │ │ │ multiplex6_reverse_reverse_dg │ │ »\n", - "«q_4: ┤3 ├──┼──┤3 ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_5: ┤4 ├──┼──┤4 ├──┼──»\n", - "« │ │ │ │ │ │ »\n", - "«q_6: ┤5 ├──┼──┤5 ├──┼──»\n", - "« └────────────────────────┘ │ └────────────────────────────────┘ │ »\n", - "«q_7: ────────────────────────────■──────────────────────────────────────■──»\n", - "« »\n", - "« ┌────────────────────────┐┌───┐┌────────────────────────────────┐┌───┐\n", - "«q_0: ┤0 ├┤ X ├┤0 ├┤ X ├\n", - "« │ │└─┬─┘│ │└─┬─┘\n", - "«q_1: ┤1 ├──┼──┤1 ├──┼──\n", - "« │ │ │ │ │ │ \n", - "«q_2: ┤2 ├──┼──┤2 ├──┼──\n", - "« │ │ │ │ │ │ \n", - "«q_3: ┤3 multiplex7_reverse_dg ├──┼──┤3 multiplex7_reverse_reverse_dg ├──┼──\n", - "« │ │ │ │ │ │ \n", - "«q_4: ┤4 ├──┼──┤4 ├──┼──\n", - "« │ │ │ │ │ │ \n", - "«q_5: ┤5 ├──┼──┤5 ├──┼──\n", - "« │ │ │ │ │ │ \n", - "«q_6: ┤6 ├──┼──┤6 ├──┼──\n", - "« └────────────────────────┘ │ └────────────────────────────────┘ │ \n", - "«q_7: ────────────────────────────■──────────────────────────────────────■──\n", - "« " - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qc.decompose().decompose().decompose().decompose().draw()" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Counter({2: 254, 1: 135})\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[110], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m qc_decomposed \u001b[38;5;241m=\u001b[39m qc\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\u001b[38;5;241m.\u001b[39mdecompose()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mcount_gates\u001b[49m\u001b[43m(\u001b[49m\u001b[43mqc_decomposed\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[108], line 52\u001b[0m, in \u001b[0;36mcount_gates\u001b[0;34m(circuit)\u001b[0m\n\u001b[1;32m 50\u001b[0m \u001b[38;5;28mprint\u001b[39m(counter)\n\u001b[1;32m 51\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2\u001b[39m,\u001b[38;5;241m20\u001b[39m):\n\u001b[0;32m---> 52\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m counter\u001b[38;5;241m.\u001b[39mget(i,\u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m==\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 55\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m counter\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] - } - ], - "source": [ - "qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", - "count_gates(qc_decomposed)" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys([0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255])" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "histogram.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - }, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/part2.pickle b/part2.pickle deleted file mode 100644 index 3065aa7e6212c84960ac864c9f6e12c35889815f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 497 zcmY*Wy-ve05H1x^3RFS}1VUoyRtEA4Ac54O{0PK~PPStjLt?kN1eE~^1~xB<<9T=$ zCT4aPE=i+;C0q9QW8Zgvnt%VAYm~!pDwB=_UQ})}tT*IaM-@bGwD(MpL0edKUc^5+rABYGIExSrvAbAG;jxov6CVOjLZ!aAD>fV2b8eR z8pT}gV@O3hq%*$^q2c(*Nodf_rEkGFm)x>CR;cfd(ip_X>WU)YKHPBlA?e?PXEB68tEig}Y@f&cbAHd05q#jcp QP|jwliwn4faw$*-zoEs#wg3PC diff --git a/part2.qasm b/part2.qasm deleted file mode 100644 index bad476c..0000000 --- a/part2.qasm +++ /dev/null @@ -1,4 +0,0 @@ -OPENQASM 2.0; -include "qelib1.inc"; -qreg q8[3]; -rx(pi) q8[0]; diff --git a/part2_example_cirq.ipynb b/part2_example_cirq.ipynb deleted file mode 100644 index 2bb7a6d..0000000 --- a/part2_example_cirq.ipynb +++ /dev/null @@ -1,221 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "id": "5519a2aa", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: cirq.Circuit) -> dict:\n", - " \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n", - " \"\"\"\n", - " simulator = cirq.Simulator()\n", - " result = simulator.simulate(circuit)\n", - " \n", - " state_vector=result.final_state_vector\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: cirq.Circuit):\n", - " \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n", - " counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n", - " \n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "11a77286", - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "dfbb6735", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "66e9a047", - "metadata": {}, - "outputs": [], - "source": [ - "#you submission\n", - "\n", - "def encode(image):\n", - " circuit=cirq.Circuit()\n", - " if image[0][0]==0:\n", - " circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", - " return circuit\n", - "\n", - "\n", - "def run_part2(image):\n", - "\n", - " #loade the quantum classifier circuit\n", - " with open('part2.pickle', 'rb') as f:\n", - " classifier=pickle.load(f)\n", - " \n", - " #encode image into circuit\n", - " circuit=encode(image)\n", - " \n", - " #append with classifier circuit\n", - " \n", - " circuit.append(classifier)\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " #convert histogram to category\n", - " label=histogram_to_category(histogram)\n", - " \n", - " return circuit,label\n", - "#score" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "18e6015f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "score=0\n", - "gatecount=0\n", - "n=len(dataset)\n", - "\n", - "for data in dataset:\n", - " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #check label\n", - " if label==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a73d2810", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/part2_example_qiskit.ipynb b/part2_example_qiskit.ipynb deleted file mode 100644 index 1fff63c..0000000 --- a/part2_example_qiskit.ipynb +++ /dev/null @@ -1,1674 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 95, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.00392156862745098" - ] - }, - "execution_count": 96, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images.max()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2000, 28, 28)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.00392156862745098" - ] - }, - "execution_count": 66, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images.max()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " ...,\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", - "\n", - " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 2.41234518e-07, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 2.41234518e-07, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 3.01543147e-07, 0.00000000e+00, 0.00000000e+00],\n", - " ...,\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 3.01543147e-07, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 2.41234518e-07, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 3.01543147e-07, 0.00000000e+00, 0.00000000e+00]],\n", - "\n", - " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " ...,\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", - "\n", - " ...,\n", - "\n", - " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " ...,\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", - "\n", - " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " ...,\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]],\n", - "\n", - " [[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " ...,\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n", - " [0.00000000e+00, 0.00000000e+00, 0.00000000e+00, ...,\n", - " 0.00000000e+00, 0.00000000e+00, 0.00000000e+00]]])" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "images_normalized = (images/ 255.0)\n", - "\n", - "images_normalized" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(images[0])\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.imshow(images_normalized[0])\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "\n", - "def min_max_normalization(s):\n", - "\n", - " normalized_s=(s-s.min())/(s.max()-s.min())\n", - " \n", - " return normalized_s\n", - "\n", - "def z_normalization(s):\n", - " \n", - " normalized_s=(s-s.mean())/s.std()\n", - " \n", - " return normalized_s\n", - "\n", - "\n", - "def variance_map(images, images_normalization, variance_normalization=None):\n", - "\n", - " variance_series = pd.DataFrame(images.reshape(2000, 28 * 28)).var().rename(\"variance\")\n", - " \n", - " if variance_normalization:\n", - " variance_series = variance_normalization(variance_series)\n", - "\n", - " variance_map = np.array(variance_series).reshape(28, 28)\n", - "\n", - " variance_map \n", - " \n", - " plt.imshow(variance_map)\n", - " plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "variance_map(images, variance_normalization=z_normalization)" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "variance_map(images, variance_normalization=min_max_normalization)" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "784" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "28 * 28" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "672" - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "28 * (24)" - ] - }, - { - "cell_type": "code", - "execution_count": 97, - "metadata": {}, - "outputs": [], - "source": [ - "x_train = images.reshape(2000, 28 * 28)" - ] - }, - { - "cell_type": "code", - "execution_count": 106, - "metadata": {}, - "outputs": [], - "source": [ - "n_qubits_data = 8" - ] - }, - { - "cell_type": "code", - "execution_count": 107, - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.decomposition import PCA\n", - "\n", - "# Create an instance of PCA\n", - "pca = PCA(n_components=2 ** n_qubits_data)\n", - "\n", - "# Fit PCA on your 784-dimensional data\n", - "pca.fit(x_train)\n", - "\n", - "# Apply dimensionality reduction on your data\n", - "data_pca = pca.transform(x_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2000, 256)" - ] - }, - "execution_count": 108, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data_pca.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 109, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The sum of the states from the training set 0 1.0\n" - ] - } - ], - "source": [ - "import cmath\n", - "#Funtion to normalize the data of an array\n", - "'''\n", - "Input = Array with n values\n", - "Output = Array with normalized valued\n", - "'''\n", - "def Normalize(row):\n", - " #We calculate the squareroot of the sum of the square values of the row\n", - " suma = np.sqrt(np.sum(row**2)) \n", - " if suma == 0.:\n", - " #If the sum is zero we return a 0\n", - " return 0.0\n", - " #Else we divide each value between the sum value above\n", - " row = row/suma\n", - " return row \n", - "\n", - "#Normalize the training set data\n", - "for i in range(len(x_train)):\n", - " data_pca[i] = Normalize(data_pca[i])\n", - "\n", - " \n", - "print(\"The sum of the states from the training set 0\",np.sum(data_pca[0]**2))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2000, 256)" - ] - }, - "execution_count": 111, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data_pca.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": {}, - "outputs": [], - "source": [ - "num_layers = 1 #Number of layers\n", - "#Making a ndarray of floats based on the number of layers\n", - "params = np.random.random(10*(num_layers))" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 123, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit import QuantumCircuit\n", - "#Function to create a quantum circuit based on the number of qubit and a\n", - "#vector of complex amplitudes to initialize to\n", - "'''\n", - "Input: Number of qubits, vector of complex amplitudes\n", - "Output: Quantum Circuit\n", - "'''\n", - "def input_data(n,inputs):\n", - " circuit = QuantumCircuit(n,1) #create the quantum circuit with n qubits\n", - " #initialization of the circuit with the vector of amplitudes\n", - " inputs\n", - " circuit.initialize(inputs, range(0,n,1)) \n", - " circuit.barrier() #Draw a barrier\n", - " return circuit\n", - "\n", - "#Example of a quantum circuit with the first row of te trainig set\n", - "input_data(n_qubits_data, data_pca[0]).draw(output=\"mpl\")" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit.circuit import QuantumCircuit, Parameter, ParameterVector\n", - "from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap\n", - "from qiskit.circuit.library import TwoLocal, NLocal, RealAmplitudes, EfficientSU2\n", - "from qiskit.circuit.library import HGate, RXGate, RYGate, RZGate, CXGate, CRXGate, CRZGate\n", - "\n", - "#Function to create a quantum variational circuit\n", - "'''\n", - "Input: number of qubits, number of layers, parameters to initialized the circuit\n", - "Output: Quantum Circuit\n", - "'''\n", - "def vqc(n, num_layers,params):\n", - " #Set the number of layers and qubits\n", - " #ParameterVectors are initialized with a string identifier and an integer specifying the vector length\n", - " parameters = ParameterVector('θ', 10*(num_layers))\n", - " len_p = len(parameters)\n", - " circuit = QuantumCircuit(n, 1) #create the quantum circuit with n qubits\n", - " \n", - "\n", - " #Creating the circuit for each layer\n", - " for layer in range(num_layers):\n", - " #Applying a ry gate in each qubit\n", - " for i in range(n):\n", - " #the rotation of the ry gate is defined in the parameters list\n", - " #based on the layer\n", - " circuit.ry(parameters[(layer)+i], i)\n", - " circuit.barrier() #Create a barrier\n", - "\n", - " circuit.cx(2,0) #Apply a CNOT gate between the qubit 2 and 0\n", - " circuit.cx(3,1) #Apply a CNOT gate between the qubit 3 and 1\n", - " circuit.cx(5,4) #Apply a CNOT gate between the qubit 5 and 4\n", - " circuit.barrier() #Create a barrier\n", - " \n", - " #Apply a RY gate in the qubit 0 with the rotation specified in the parameter list\n", - " circuit.ry(parameters[6+(layer)],0)\n", - " #Apply a RY gate in the qubit 1 with the rotation specified in the parameter list\n", - " circuit.ry(parameters[7+(layer)],1)\n", - " #Apply a RY gate in the qubit 4 with the rotation specified in the parameter list\n", - " circuit.ry(parameters[8+(layer)],4)\n", - " circuit.barrier() #Create a barrier\n", - " \n", - " circuit.cx(4,1) #Apply a CNOT gate between the qubit 4 and 1\n", - " circuit.barrier() #Create a barrier\n", - " \n", - " #Apply a RY gate in the qubit 1 with the rotation specified in the parameter list\n", - " circuit.ry(parameters[9+(layer)], 1)\n", - " circuit.barrier() #Create a barrier\n", - " \n", - "\n", - " #Creating a parameters dictionary\n", - " params_dict = {}\n", - " i = 0\n", - " for p in parameters:\n", - " #The name of the value will be the string identifier and an integer specifying the vector length\n", - " params_dict[p] = params[i] \n", - " i += 1\n", - " #Assign parameters using the assign_parameters method\n", - " circuit = circuit.assign_parameters(parameters = params_dict)\n", - " return circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 118, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1QAAAG5CAYAAACJJHUoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAAsTAAALEwEAmpwYAACPcElEQVR4nOzdeZyNdf/H8dc5Z/YZM4Oxb1mGWWSXLYylUrdCN0Kr+kWDhFRKlJRKiu47tKi0iLLFLUq2KVuRJcOMsTN2MZgxhjkzvz9OnZqMwTRzrmsu7+fj4VG+5zrX+cx33r7nfM51nevYsrOzsxEREREREZFrZje6ABERERERkaJKDZWIiIiIiEg+qaESERERERHJJzVUIiIiIiIi+aSGSkREREREJJ/UUImIiIiIiOSTGioREREREZF8UkMlIiIiIiKST2qoRERERERE8kkNlYiIiIiISD6poRIREREREcknNVQiIiIiIiL5pIZKREREREQkn9RQiYiIiIiI5JMaKhERERERkXxSQyUiIiIiIpJPaqhERERERETySQ2ViIiIiIhIPqmhEhERERERyScvowsQsbLExMQ8b3/nnXcYMGBAnttEREQUZEliIlfKBygjUvQURK6V6auj5xixmqL6vKgjVCIGmjhxotEliMkpI2JFyrVnaJ7FisyYazVUIiIiIiIi+aSGSkREREREJJ/UUIkYaNasWUaXICanjIgVKdeeoXkWKzJjrtVQiYiIiIiI5JMaKhEDde3a1egSxOSUEbEi5dozNM9iRWbMtS6b7kHbl8HZY0ZXYR3FSkOttkZXISK50XpX+LQGioiYgxoqDzp7DFKSja5CRKTwab0TEZHrhU75EzFQ//79jS5BTE4ZEStSrj1D8yxWZMZcq6ESMdCVvulbRBkRK1KuPUPzLFZkxlyroRIxUKtWrYwu4apkZcPxM7BhL6xMgtU7IOEQpJ43ujLrKyoZEbkWyrVnaJ7FisyYa32GSsRAx48fN7qEPJ1Kg1U7YO2uyzdPFYtDi5rQ8Abw0YpS4MyeEZH8UK49Q/MsVmTGXOvlz3XsyckxJOxbg8Phjd3uoGzxqvRqN5zWdbsZXZoYLCsL4rbDN5sh05n3tsmn4MufYOlW6NkMqpf2TI0i+aF1T0RECppO+bvO3dt+BP97JZU5L/7GbY0f4tUvenHwxE6jy7puREVFGV3CJS5kwvsrYN6GKzdTf3UiFd75HuISC62065IZM1LUad0znnLtGZpnsSIz5loNlQDgcHhxe5NHcWZlsuvQJqPLuW7Mnj3b6BJycGbBRz9A4uH83T8bmPuL63NWUjDMlhEr0bpnHOXaMzTPYkVmzLUaKgHgYuYFFqyeDEDFsJoGV3P9GDlypNEl5LBs25WbqQn3uv7kZe4vcOhUwdV1PTNbRqxE655xlGvP0DyLFZkx12qornNfLH2FziNC6ficPx9/9zxDuk2hWvk6AIyZ1ou12xa4t31hamfWb19sVKmWNHPmTKNLcDt+Br7dUjD7cmbB9LWQnV0w+7uemSkjVqF1z3jKtWdonsWKzJhrUzdUWVlZjBs3jvDwcPz8/Khbty5xcXHUqlWLPn36GF2eJfRqN5yvR6cw68UT3BRxB5t3LnffFttpAlO/G0F6Rio/bplDoF8IjWrdamC1Uph+SHI1QgXlwEnYdazg9idSULTuiYhIQTJ1Q/XII48wevRo+vbty6JFi+jevTs9e/Zk9+7dNGzY0OjyLKVYQHGGdJvCT4nfsDp+HgDFg0rT5eYnmDhvIF8sfZnH7hpvcJVSWC46Yd3ugt/vGn3OX0xM656IiBQE0zZU06dPZ+rUqcyfP5+hQ4fSpk0bhg8fTrNmzcjMzKRBgwZGl2g5wQEl+HfLIXz07XNkZbkOVdzW+CGSjyfRucVAggNKGFyh9cTFxRldAuD6vNP5iwW/Xx2h+ufMkhGr0rpnDOXaMzTPYkVmzLVpG6oxY8bQoUMHWrdunWO8Ro0aeHt7U6eO63z3vXv30rp1a2rWrMmNN97Ijz/+aES5ltGl5ROcPHOY73/51D1WvmQNKoTVMLAq69q6davRJQCQfLJw9pty7vJfCCxXxywZsTKte56nXHuG5lmsyIy5NuUX+yYnJxMfH8/gwYMvuW3//v1ER0fj6+sLQN++fbnnnnvo168fq1evplu3buzZswcfH588H8NmsxVK7XkZ99hy6laP8fjjXs6bsSsuGQv0C2bOS4X06rqAxcWtoHHPNkaXkafcMvxX48ePv6ptCttNnUfQrOtLOcaudCW/y90+aFrOv1epHsXJQwn/oDrrutLvHsyTkWtltvXuD0V93fsrs66BBZFrM2bajIrKc4zI1TLb82L2VV5dy5RHqJKTkwEoW7ZsjvH09HTi4uLcp/udOHGClStX8sgjjwDQvHlzypcvz/LlyxGRa1F4l+PLLsR9i4iIiBjNln21rZcH7dy5k/DwcMaPH8+gQYPc46NGjeLFF19k4sSJ9OvXjw0bNtC1a1d27/7z0/Tdu3enffv2prwK4PoZkJJsdBXWEVoRGvUwuoq8JSYm5nl7ZGQkCQl5H72JiIgoyJJy9dMu12XOr8YfR6b+fiTqcl7tBv55HzC+bl0pH2CejFwrrXeFz6xrYEHk2oyZNqOi8hwjcrWK6vOiKU/5q1atGnXq1GHMmDGUKFGCChUqMGvWLBYuXAigK/yJZYwaNcroEgCoVEifuy9VTM3UP2WWjIgUJOXaMzTPYkVmzLUpT/mz2+3MnDmT6OhoYmNj6d27N2FhYfTv3x+Hw+G+IEXlypU5evQoGRkZ7vvu2bOHKlWqGFW6yDXp3r270SUAUCYEgv0Kfr/hZa+8jeTNLBkRKUjKtWdonsWKzJhrUzZUADVr1mT58uWkpaWxf/9+Ro8ezZYtW4iKisLf3x+AsLAwWrRowYcffgjA6tWrOXjwIG3amO9DuiK5iYyMNLoEABx2aBZe8PttUQj7vN6YJSMiBUm59gzNs1iRGXNtylP+Lmf9+vU0bdo0x9i7777LQw89xIQJE/Dx8WH69OlXvMKfmUyeP5ik5PXUqNCA/p3edo+/8nkPTp49wsXMDDIupvPekE3MWPYaP29fRMaFc/Rs+xw339iFnQc38d+5/bHb7TzcYQw3VmvJd+umMmP5q5QoVo6ISjfxaMexOJ2ZvPFVb46c3EPTyI70aDuMnQc38vqMB0jPOMvnz+0FIC39NK9Ov5f0jFRa1O7M3S0HsedIPBNm9cFud1C+ZA2Gdv+I9du/Y8by1wBIPr6dgXdPplr5uoyd8QA2bISFVOSZnp/hsDvoPbYWJYqVA2Dg3ZOoUiaKo6f28d+5/Tl/IY12De7j9pseYePOZXy8aDg+3n480+MzSoVW5MnJMWSTjQ0b990ykvo12nr8d3S9aBEOPyRCegF9H1VUeahQvGD2JUXf5da6X5K+Z+p3I/D19mfg3ZOpXDqCE6cP8fr0+7iQeZ4Hb32JBjXbM2neIHYd2gTA7sObmfvSKWYse411278FIOnAOqY9f4A1W+ezeP1U93Zv9F3OqbNHLlmvmkT+iyGTWrHnyBbeHbyJCmE1yHRevGTsdNoJRn58Fw6HN4F+ITx/35f4evvTaUQINcrXB+CFB+cQHFCCDxY8TfzeVdjtdp7s9hEVS4Xnuv7ltq7tORLP27MfIzs7myfunky18nVyfR4QERHzKTINVWpqKklJSfTr1y/HeLVq1fjhhx8Mquqf2ZG8gfSMVMb3+5G3Z8ey/cA6alVqDMDw+2YAsHLLXHYc/AWArq2fpEfbYaRnpPL0++25+cYufLJ4JM/f9yXFAkow6pO7ebWa68VFt9ZPcUeT/3M/1upt86lUOoJhPT/j+Y86cvLMEcqXrMF/Hl/Lsx/c5t7um5/ep239e2lbvyejPvk37RrcR6VStXh7wGoA3viyN0nJ62kc0YHGER0AePw/TWgQ3p5M50Ve7r2AQP8QPlo0nJ8TF9Is6k5CAktdcqnijxcNZ2j3jwkNKuUem7ZkNK89uph9x7YxfdmrDLx7ousx+yzF4SgyUS2ygv2hSyP4Ys0/35efN3Rv8s/3I9aQ11r3+ZKXGNt3KefOn2Hy/EE8f9+XfLn8NR68bTTVy9fl+Y860qBme/p1mgDAzoMbmRX3JgA92g6jR9thnE47wUufdiU4oAS3NX6I2xo/hNOZSb+3G1G9fF1stnqXrFcOuxejHvqaD755xl1nbmNB/sUZ328ldrudzxaPYu22BbSu242qZW/Msa6dOXeSpOT1vD1gFfF7VvG/NZOIvWt8rusfXLquffLtCJ67dzp2m53/zOnHS73n5fo8ICIi5mPaU/7+LigoCKfTyeOPP250KQUmYf9aGta8BYAG4e3Ztu/SV7Kr4udyc+27AfByeAOQcTGdG8rWBiA1/RSlQivi5xPA+YtpZFxMB2DujxMYMqkVG3YsBSBx31oahrseq271NiQe+JkAv2L4+wTmeLzDv+2mWjnXZ9SqlIli+4F17scF8PbypVRIpRzbhxYrg79vEMUCihPoH+Ku1W5zAHD23EmGTGrFhFl9uXDxPJnOixxN2ceE2X0Z9sFtJB9P4vyFc/h4+xPgV4zIyk3Yd9T1pW12m52n32/PK5/34My5ovc9MVcSExNjdAk5NK4Kza9wmt6gaXlf4c9ugwdaQGhAwdZ2vTJbRvLjSmudv08gJYPLcei3XQDsObKF6Bua4+8bRIBvMdLOn3FvuzJ+Li1uvDvH/ddsnU+zqLtyjP265wfqVGuV4zsH/7pe2Ww2ihcrk+M+uY057A7sdtdTpTPbSYUw1z+Q/ccSGDypJVMWDiM7Oxt/nyAC/UJwZjlJO59CcEBJ4NL1D3Jf186mn6J0aCXCQiqQej4lRw1/fR6wCivkuijQPIsVmTHXRaahsqLU9BQCfIMBCPQLITU9Jcftmc6L7DmyhfCKDdxj/5nTj75v1XGf+hYSWIo9R+JJST3O3iPxpKan0KJ2Z94b8isjH5jN+wuG4sxykno+hQC/Px8r7W+P9YdKpWvx6+44nFlOft3zg7um1Vvn8+i42qScPUpwYEn39iu3zKFF7S459nHi9CF+SfqeRjVvBWB8/5W81e8HShevwjc/vc/ptBPsPvwrg/79Ho/d+RYffPM0qekpBP4+FwBZ2U4ARjwwizdjV9As+i6+WPLyNc6w+U2ePNnoEnKw2aBrY2hVK3/39/WCR1pBVIWCret6ZraM5MeV1rpTZ4+y/1giB466LoObleV0N0J/X6/Wb/+WxrU65Lj/qvi5tLgx5zqU29qU29jVSNz/M/3ebsSmncsoV6IqAFOf2cFbsT+Qeu4Ua7b9D28vH8qWqMrDY2vxztwBdLjJ9f2If1//IPd1LTs7688H/Mu3meT2PGAFVsh1UaB5FisyY67VUBko0C+Ecxmud17TMs4Q5B+a4/bNu1ZQt3pMjrGBd0/io6cS+WLpKwD83x2v8e78Ibw9+zGqlqtDSGAYQf6h2O12QoNKUbFUTU6dPep6rN/f5T13/gyBf3usP9ze5FG27V3Nc1Nup2Rwefe7tc2j7+KDofGEhVZk7bYF7u3XJPyP5n95Z/hCZgZvfPkgQ7p94D6dJTjAdU3uFrW7sPdIPIF+IVQpHUVoUCluKBvNmXO/EegfQlrGn+9C/3F066/33XMk/qrntqiIjY01uoRL2G1wdyPoEwMh/ld/v5pl4Zl/QXTFQivtumTGjFyrvNa6R+8YyyvTejBj2WtE3dACAJvtz6emtIw/16vk4zsIC66An8+fhz/PnT/L6bQT7kYHXN9sH79nJTdWa5Wjjr+vV1crovJNTHpiPS1qd+HbdR8BrrXJZrPRvHZn9h6JZ9/RBA6e2MHHTyfx/P0z+fjb4e7t4M/17+9j7nXtL0fS/vrz5/Y8YAVWyHVRoHkWKzJjrtVQGSiqSjM2/n5K3sYdS4isnPOCG6vi5+Z4N/VCpuvy8D7e/u53eyuWqsnrfRYzqOt7lA6tjJfD2316TMbFdA6e2EFoUCkiqzRj407XY23etdz9+YW/8/cJZFivzxnzf4vIzs4iqkoz9+MCBPgG4+vtepV98swRvB0+OY5YTZjVh7ua96dKmSgALmZecN9/695VlCtZHT+fAPx9gzh/4RwnTh8kwDcYf59ALlxMJz0jlcT9P7vv/8fPsnXPKsqXrH7Nc2x2K1asMLqEy4qqAM93gnubQbVS4JXLahHoCw1vgIG3QGxbKBHk8TItz8wZuVp5rXVRNzRj3GPL6dVuOJXLuK7cVK1cHbbtXUP6hTTXG0C/H13/+5oIsG77IhpH3J5jbPuBdYRXbIDD7nCP5bZeXY2LmRfc/x/oF4yPtz/pF9JwZrmOom/d+8falE3g729mhQSGkZZ+Otf1D3Jf14L9S3A8JZkTpw+5zya43M9sBVbIdVGgeRYrMmOu9Ul/A4VXbIC3tx+DJ7Wkevl6lA6tzLSlr3Bvu+FkZ2ezbd8aBnR+x739pHlPcOBYIpnOC3SLeQqART9/yNINn+Pj7c/jXVwXcZjzw3jWbf+W7OwserQZhpfDm2ZRd/LGl7MZNPFmboq4g5LB5TiWcoBxX/Zm75F4nn6vPUO6TeHMud94f8FQbNjoHvM0vt7+rI6fx6wf3wKgQlg4DX8/lW/11nk0i+7krm/b3jWsjJ/D0VP7mPPjBLrc/ATRNzTnuQ9vx98niCD/4gzr+TkAvdo9z7NTbsPpzKR/5/+6xtoO55n3b8HH24+n7/kEgKfea4uvtz8+Xn48dc/Uwv2FyCW8HdC4muuPMwuOnoaxru/XZmQnKB6Y4411kVzltdZNW/oKG3csITigJIP+/R4A3WOeZuyMB8i4mM4Dt/75BY4/JSxg1EPzcux7ZfxcerUbnmMst88c/X29Ahj9WXfi967k4Ikd3BPzNM1rd7pkrERwOd7/5insNjvF/EvwTM/PSD6exJszH8bfJ4iyJarywK2jcNgdBPgWY/Cklq4LYnR6m9T0U7muf7mtaw/cOoqXP78HwL2W5/Y8ICIi5mPLzv7LydpSqNbPgJRko6uwjtCK0KiH0VXkLTExMc/bIyMjSUhIyHObiIiIgizpH/vjghQT7jW2Diu4Uj6gaGYEtN55glnXwILItRkzbUZWfI6R61tRfV7UKX8iBrrSgiCijIgVKdeeoXkWKzJjrtVQiRjoq6++MroEMTllRKxIufYMzbNYkRlzrc9QeVCx0kZXYC1WmM8XXniB7t27G12GmFhRzYgV/n2aXVGe46Ka66JG8yxWZMZcq6HyoFptja5ARMQztN6JiMj1Qqf8iYiIiIiI5JMaKhEDTZo0yegSxOSUEbEi5dozNM9iRWbMtRoqEQNFR0cbXYKYnDIiVqRce4bmWazIjLlWQyVioNatWxtdgpicMiJWpFx7huZZrMiMuVZDJSIiIiIikk9qqERERERERPJJDZWIgRo3bmx0CWJyyohYkXLtGZpnsSIz5loNlYiB1q1bZ3QJYnLKiFiRcu0ZmmexIjPmWg2ViIiIiIhIPqmhEhERERERySc1VCIGmjVrltEliMkpI2JFyrVnaJ7FisyYazVUIiIiIiIi+aSGSsRAXbt2NboEMTllRKxIufYMzbNYkRlz7WV0AVa3fRmcPWZ0FdZXrDTUamt0FSLyB619hU/rnliV1o/Cp/WjYKmhKmRnj0FKstFViIh4ltY+EckvrR9S1OiUPxED9e/f3+gSxOSUEbEi5dozNM9iRWbMtRoqEQMNGDDA6BLE5JQRsSLl2jM0z2JFZsy1TvkTMVCrVq344YcfjC7DcrKyYNsh2HoQDvwGJ1LBmQX+3lC+OFQJg8ZVIayY0ZVemTIiVmT2XKdfgF/2ws6jkHwSzqQDNgj2g4olILwMNKwKft5GV5o3s8+zSH6YMddqqK5jT06OIWHfGhwOb+x2B2WLV6VXu+G0rtvN6NKuG8ePHze6BEvJzna9CPpmM5xKu/T2i044cxgSD8PiLRBVAe5uBCWDPF7qVVNGCpbWPXMwa64vZMKiX2HVDtf//92JVNefTfth/kZoURM63Ag+Jn01ZdZ5Lsq0hhjPjLk26RIgnnJv+xHc2/55nM5M5q1+h1e/6EWNCvWpEFbD6NJErsm5C/DFGoi/yg8yZ+M6grXjKPy7ETSpXqjliYlo3ZPcJJ+ET1bC8bNXt31GJizbBlsOwIM3u45cyfVBa4j8nT5DJQA4HF7c3uRRnFmZ7Dq0yehyrhtRUVFGl2AJ5y7ApCVX30z91YVMmL4WViQUfF0FQRkpPFr3jGO2XO89Af/9/uqbqb86fhbeWQL7fyv4uv4ps82z1WgNMYYZc62GSgC4mHmBBasnA1AxrKbB1Vw/Zs+ebXQJRV52Nny2CpJPXX6bCfe6/uTl6w2w1YSX6VVGCo/WPeOYKddn0uGD5a4jTpdzpTXk/EV4fzmcPV/w9f0TZppnK9IaYgwz5loN1XXui6Wv0HlEKB2f8+fj755nSLcpVCtfB4Ax03qxdtsC97YvTO3M+u2LjSrVkkaOHGl0CUXeT7sg4VDB7OvLn+FcRsHsq6AoIwVP657xzJLr7GyY+TOkXfjn+0rNgFnr/vl+CpJZ5tlqtIYYy4y5NnVDlZWVxbhx4wgPD8fPz4+6desSFxdHrVq16NOnj9HlWUKvdsP5enQKs148wU0Rd7B553L3bbGdJjD1uxGkZ6Ty45Y5BPqF0KjWrQZWaz0zZ840uoQiLdMJCzYX3P7OpMOKxILbX0FQRgqe1j3jmSXXe0/AlgI8Mr15v2ufZmGWebYarSHGMmOuTd1QPfLII4wePZq+ffuyaNEiunfvTs+ePdm9ezcNGzY0ujxLKRZQnCHdpvBT4jesjp8HQPGg0nS5+QkmzhvIF0tf5rG7xhtcpUhOmw9AagGfYrN2p6tRE+vTuicrkwp+n6sKYZ9iTlpD5A+mbaimT5/O1KlTmT9/PkOHDqVNmzYMHz6cZs2akZmZSYMGDYwu0XKCA0rw75ZD+Ojb58jKygLgtsYPkXw8ic4tBhIcoEsYibn8ur/g93nmvLneYZbCpXXv+pWVVbBHp/7w6wHIyi74/Yo5aQ0RMHFDNWbMGDp06EDr1q1zjNeoUQNvb2/q1HGdqzpy5Ehq1qyJ3W5n1qxZRpRqKV1aPsHJM4f5/pdP3WPlS9bQpUALSVxcnNElFGkHThat/eaHMlL4tO55nhlyfexs7t819U9lZObvaoGFwQzzfD3QGuJZZsy1Kb+HKjk5mfj4eAYPHnzJbfv37yc6OhpfX18AOnTowEMPPcTDDz98TY9hs9kKpNYrGffYcupWj/HIY12rN2NXXDIW6BfMnJdM9GryKsXFraBxzzZGl3GJ3DL8V7t27aJ69by/AGn8eHOdLvDE5663Xj31b+hy7A5vHv/kAtnZ2e5arnQlv8vdPmhazr+/PO492n70WAFUmbcr5QOKZkbAvGuf1r3CVxC59kSmqzfqTMdBc3OMFdQa0izmTvZsXJD7xgXIis8xYN71A6yzhlh5/YCCy3V29tUdbjblEarkZNcx+LJly+YYT09PJy4uLsfpfs2bN6datWoerU+koMyfP9/oEoosu5c3UDiNncPLp8D3mV/KiFiRGXJtdxTev3OHl2+h7ftamGGeRQqaGXNty77a1suDdu7cSXh4OOPHj2fQoEHu8VGjRvHiiy8yceJE+vXrl+M+MTExDBgwgK5du3q42rytnwEpJvxuG6sJrQiNehhdxaUSE/O+ZFxkZCQJCXl/o2xERERBlvSP/fFO7JXeyS1sWVkwdMbVfVbhj1r//i7y5bSsCf9unP/artaV8gFFMyOgtc8Tiuq6B1fOtScyvfUgfLDi6ra91jWkbxuILJ+vsq6JFZ9jQOuHJ1h5/QDP59qUp/xVq1aNOnXqMGbMGEqUKEGFChWYNWsWCxcuBNAV/kQEux3KhMDhlILfd/niBb9PETGX8qFFc98iYj6mPOXPbrczc+ZMoqOjiY2NpXfv3oSFhdG/f38cDof7ghQiRd2oUaOMLqFIq1KycPZbuZD2mx/KiFiRGXIdGgDBfgW/3xB/CAko+P3mhxnmWaSgmTHXpjxCBVCzZk2WL1+eY+z+++8nKioKf39/g6oSKVjdu3c3uoQirXFVWLurYPdZPtRc7y4rI2JFZsi1zQaNqsGybQW738Ym+li3GeZZpKCZMdembahys379epo2bZpjbMSIEXz88cccP36cLVu2MGjQIOLi4q549Q8jTZ4/mKTk9dSo0ID+nd52j8dtnsnMuDewYaNn2+doXrsTE2b1Zc+ReGw2GwO7TKJa+TpMmjeIXYc2AbD78GbmvnSKxes/4dufPyTjYjq3Ne7NXc375Tq27+g23pr5KAD1a7TloQ6jmbHsNdZt/xaApAPrmPb8AbbuXcUXS1/Bho2WdbrSrfWT7jpn/zCeH7fMZkL/lew5Es+EWX2w2x2UL1mDod0/wmazXfIzJuz/iXfnD8Zms1OrUmNi7xrPzoObmDx/EADHTu2jS8snuLvlIHqPrUWJYuUAGHj3JKqUiQLgtzOHeeDVarz/5BbLXIr0as4DlsurVtrV/BxKKbh9tqzleqFlFlbKyOXWvlc+78HJs0e4mJlBxsV03huyiW9//ohpS0YTfUMLhvX6HIALF8/z37n9OXJyD1XKRjOg83/5dPGLrIqfS5B/cZpF3UXX1kP4bt1UZix/lRLFyhFR6SYe7TgWgBnLX2dD0vc4szJ5o+8ydh/ezOszHiA94yyfP7cXgJNnjvDKtB5kk035ktUZ2v0jNu9awdgZD1K2RFVKh1bmmZ6f5rr2/XbmMCM+7si+o9v438upOBxeOJ2ZvDb9Pk6lHqVWxcbuWjqNCKFG+foAvPDgHIIDSrDz4EY++OZpnFmZdGs9lCaR/wJgR/IG+r3dkG9fu4jDUaSeti/LLLluXgNWJBTc90bZbdDMRE9PZpnngnC59QMg42I694+pyrCen9OgZnumLX2F+asn0qHxw/Tu8DIAvyR9z9TvRuDr7c/AuydTuXQEny0e5X7981CHl2kQ3o6srCw++OZpdh3aRFBAcUbePzPX11Pnzp/l1S96cebcSTo27cstjR7Ide3ZeXDjJevMd+umsnj9VMD1Ou6Nvss5dfYIM5a/BkDy8e0MvHsyzaLuYuyMBziWsh8vhw/D75sBwMiP78Lh8CbQL4Tn7/sSX2//XNeUGcteY23CAooHleHpnp/i7xNY2L8mjzBjrovMypyamkpSUtIlF6MYPXo0o0ePNqiqa7cjeQPpGamM7/cjb8+OZfuBddSq5Pr0+5wfxzPusRXYbDaendKB5rU7cU/bYZQrUZXk4zv4cOEwXnhwNv06TQBg58GNzIp7E4C29Xtxa6MHcWY56TehAXc175fr2II17/LIHa9Sp1ornnn/FlLTU+jRdhg92g7jdNoJXvq0K8EBJaheri4T+q/CbrPz5Lsx3HHT/xHoH8KFzAx3MwdQqVQt3h6wGoA3vuxNUvJ67DbHJT9jmdAqvNF3GT7efrz6xb3sObyFGhXquS8/OvLjTjSJ7AhASGCpXC9LOufHCURUblI4vxgpkmw26NoY/vs9FMTroSoloYmJ3l22krzWvj9eJKzcMpcdB38BoFn0XdxYrRWfLX7RvY+5K/9Dm/q9aBDeLse++3Z8kwY12+cY69b6Ke5o8n/uvyfu/5nzGamM7bvEPVa+ZA3+8/hanv3gNvfYso1f0KHxw9zS6AHemvkouw5tBqB9w/vdL8wg97WvatkbGdtnKS9+0sW93cr4uVQrX5eebZ/lna8fZ9ehzVQvX5eqZW+8ZJ37fMloRj00Dz+fnOeLzV8zifAK+jL7whBWDNpHw+L4gtnfLbWhZFDB7Ev+lNf6AbDopylULXej++933PR/RFdpzsadS91jny95ibF9l3Lu/Bkmzx/E8/d9SftGD3D/rS+Qmp7CyI/vokF4O37cMovKZSLpe+c4931zez218KcPiKnXg5h6PXjq3TbE1HNd4eHva09u68xtjR/itsYP4XRm0u/tRlQvXxebrR6NIzoA8Ph/mtAgvD27Dm3Cy8uHt/r9wNIN01i6YRqdWgxgfL+V2O12Pls8irXbFtC6brdL1pTfzhxmy54fmdB/JT/+OptFP03h7pZPFNwvRXIw5WeochMUFITT6eTxxx83upR/JGH/WhrWvAWABuHt2bZvjfu2ciWrc/5CGukZqQT6BrvGSlQFwMvhjd3uyLGvlfFzaXHj3e7bATKdF6hcOvKyYxVL1SLt/GmcWU4AvP9yadc1W+fTLOouAEoXr4zD7sBms+Gwe2GzuaLy7c8fckujB933+eMx/thXqZBKuf6MJYLL4uPtOlndYc/5s6RfSOPU2SPuo05nz51kyKRWTJjVlwsXzwNwOu0E586foUzxG65uouW6Ua00tIvOe5tB0658dS5fL+jZzHWxCyl4ea19f1gVP5eba7vWtJDAMBz2nO/5bd69gjXb5vPk5BhWb/3zsrlTFj7D0++1Z+fBTe6xuT9OYMikVmzY4XpBtTZhAafTTjD03TZ89v1LAAT4FbvkHduKpWqSdv40AOkZZwnyDwVg+cbpDJ7UkmUbpwO5r30+3n4UC8h5RZPDJ3dTrZzrc7/Vy9dj215XE7b/WAKDJ7VkysJhZGdnc/i33VzIPM9Ln3XlhamdOXX2KAB7j2ylVEhF/H2L5Tm/kn+31oZKJfLe5mrWkMol4ZYrrEWSP3mtHxczL5Cwfy3RN7RwjxUvVibXr9Tw9wmkZHA5Dv3mOlf8j9dY3l6+7lMT1m5bwL4jW3lycgwLf/oAyP31VML+tTSoeQsOu4Nq5ety4Jjr6nR/X3tyW2f+8OueH6hTrVWOWg//tpvQYmXw9w0iLKQCWb+/XktNTyE4oCQOuwP7709UzmwnFcLCgUvXlGMp+91n+FQvX49t+1ZfzVRLPumlg4elpqcQ8HuzFOgXQmp6ivu2FrW7EDuhPo+Nr0enFjkbxw8XPUuXmwfmGFu//Vsa1+rg/vtn37/EQ6+HE16x4WXHGta8hUlfD+ThsbWIrNIMX+8/P4+2Kn4uLW78851VgJ8TF1G+ZHUC/IqR6bzI5l0rqF+jbY5tVm+dz6PjapNy9ijBgSXz/Bl3H/qV02nH3f/IAdYlLqLRX36O8f1X8la/HyhdvArf/PQ+4Do61anFgMvMatEVExNjdAmWcEfdf3aaja8X9GkDZUMKrqaCYpWM5LUuAGQ6L7LnyBbCK17+SMzh33bRJOJfvPzIN0xbMhqnM5PONw9k0qBfGHj3ZCbOc62bLWp35r0hvzLygdm8v2AoziwnKWePEhRQnHGPLWf/0W3sSN6Q62PUqnwT3/z0Pg+/EYmXw4cyxatQs2IjPno6kTH/9y1fr/wPKanHgUvXvtxUKlWLX3fFAbB553JSz7t+7qnP7OCt2B9IPXeKNdv+x6mzRzl4PImR98/iX0378sXSVwCtfZ7g5XBd5vyffHayfHHoE+Pal5mYaZ7/ibzWj8Xrp9KuwX1XtZ9TZ4+y/1giB47mPF3s08Uv0rFpX9c2qUepVDqCsX2WsHTDNPebG39/PZWanuJ+8zvQL4TU8ym5rj15WbllDi1qd7nsWHBgGBkX03n4jUgWrJnMzb+/iZ64/2f6vd2ITTuXuZvCv68p5UpUI/HAzzidmWzateySNbcoM2Ou1VB5WKBfCOcyzgCQlnHG/e4nwOffv8SUodv48KkEPl/yknt8zo8TqFI6itpVb3aPJR/fQVhwhRynhtx/y0g+GbaLH36dyZm033Idm/rdCJ6//ys+fjqJvYe3cOTkXgDOnT/L6bQT7n+Y4HqX5KsVY3nsLte3TS/55TPa1u91yc/UPPouPhgaT1hoRdZuW3DZn/HMuZO88/UAnuz2YY77r4qf614kAIIDXG8Vtqjdhb1H4klNT+F4ygFuKGu9t/4mT55sdAmWYLdB95ugc0PwvsYXNBWLwxO3QvXShVPbP2WVjOS19gFs3rWCutVjrriPOtVb4+8TSPmwGpxKPepeLyqWCndvF+Qfit1uJzSoFBVL1eTU2aOu+1ZrDUDd6m3Yfyz38+9nxb3Jfe1H8tFTCQT6h/Dr7h/w9w3Cy+GNv08gN1ZrxcETO4BL177cNI26k4zMdJ56rx3eXr4UDyoDuNY5m81G89qd2XsknkD/EGpWaoyfTwD1arRl/7EEko/vIMAvmJDAsLwntwgyW66D/GDALdCo6pW3/bubqsHj7V37MBuzzXN+XW79cDozWb/9O26KuP2K+3j0jrG8Mq0HM5a9RtRfjmat3DKXM+d+c7+++WOtcDi8iKrSjIMndgKXvp4K9A8h7feazp0/Q5BfaK5rz+VkZ2cTv2clN1ZrlWN8TcL/aP772UK/JC0mJLAUHz2VwP23vsjMONdpiBGVb2LSE+tpUbsL3677CLh0TQkNKkX7Bvfx9PvtOXh8h3vtsQIz5loNlYdFVWnGxt8PA2/csYTIyn9eZMPHyxc/7wD8fALJdF4AYP32xWzdu5p72z+fYz+r4ufmeFfjQmYGAN4OH3y9A/D28s11LDs7m2L+JbDb7QT4hZCecRaAddsX0fgvC9K582d548uHeLLbh+5D1QeOb+d/aybz7Acd2Hd0K1+v/K/7MQACfIPx9fbP9Wf844PZfTqOo0RwWfd9Mp0X2X8sgerl6wKuQ/d/7HPr3lWUK1mdA8e3k3w8iWc/6MCGHd/z9uzH8j3/ZhMbG2t0CZZhs0FMBDx9h+sqW15XWN3CglwN2OAO5v7eKatkJK+1Dy5d03LfR3P2HP4VZ5aToyf3EhJYirTzrhc0p9NO4HRmArjHMi6mc/DEDkKDShF1g+u+ALsObaJsicu8cs7OptjvTVpwQEnSzp9278+Z5STpwDrKFL8h17UvNw67gwGd/8sbfZditztoVOs20i+kud+53rp3FeVLVqdCWDgpqcdwZjnd9e05soWkA+t49oMO7Dn8KxPmaO0rTAE+cF9z15GmGlfx2jO8jOvIVq9m4O9T6OXlixnnOT8ut36cSj3KsZT9PPtBB5Zu+JwPFz3L2XOnct/HDc0Y99hyerUbTuUyrtP2dh/6lfmrJ/J4l4nu7aJvaM7u39eKPUe2UKZ4lVxfT0VVdtX0x7/ZSqUjcl17Lmf7gXWEV2yA4y8fgTh55gjeDh/3Ee/s7Gz3m0YhgWGknT/NxcwL7u0D/YLx8fbPdU0BuKPJo7wZu4LKZaLcF7mxAjPmushclMIqwis2wNvbj8GTWlK9fD1Kh1Zm2tJXuLfdcDo2i2XQRNe7Jnc06QPAxHmPE+AbzNB321CpVC0GdX0PgJ8SFjDqoXnu/c5Y9iqbd60g03mB9g3ux983iE8Xv3jJ2D1tnuH1GfdjtzuoXDrS/SHOlfFz6dVuuHt/81a/w5GTexj31cMADL3nYx791+vu2wdNvJnONz/O6vh5zPrxLQAqhIXTsOat2O32HD9jROWbWLZxOkkH1vHBN08D8MjtrxJ1QzM27lxGvep/nkKYmn6K5z68HX+fIIL8izOs5+cE+BXjP4+7zpceO+OhS5rLomzFihVGl2A5pYLh3mbQqT4kHYEDJ2H57wcjGlSBCsXhhjCoWtp1ZMvsrJKRvNa+7Oxstu1bw4DO77i3X7ttATOWv8bh33Yx6pN/88KDs7mnzTOMnfEg5zLOcEeTR/H28mHi14+z50g82dlZPHKH6wpZc34Yz7rt35KdnUWPNsPwcnjTNLIjb816lCGTW1O5VATRNzTnWMoBxn3Zm71H4nn6vfYM6TaFO5v3Y+yXD/L5kpcIDihJz7bP8f0vn7Lwp/ex2ey0qdeTsJDyua59mc6LPDfldnYf3sywKbfx8O1jKBVSkVe/uBe7zU77hg8QFlKBnQc38ebMh/H3CaJsiao8cOsoHHYHdzR5lKHvxmCz2XnqnqmUK1GVlr8fvX9ycgyD7n7X87+4QmLmXEdVcP05ehp2HoMDv/359QzNakDFEq6Gq0ywsXVeDTPP87XIa/2Y+MQ6wHXaXu0bbqZYQHEW/fwh/1s9ibPnTnL23CkG3j2RaUtfYeOOJQQHlGTQv12vpd7/5ilOpR7l2Q9uI9AvhJd6z6ND40cY++WDzPlxAo1q3Uap0Iq5vp66vcn/8eoXvZi36r/c0aQP3l4+zFj26iVrT27rTNkSN+T4zOgfVm+dR7PoTu6/N6p5K9+t+4gnJ8eQnZ3F0O4fs+vQJt7/5insNjvF/EvwTM/PSD6edMmaAvDSZ904e+4k1crVoW/HNz302yp8Zsy1LTs7u4AuFiq5WT8DUpKNrsL6QitCox5GV3GpxMTEPG+/mkt/RkREFGRJ/9gfH8yecK+xdVwLs9Z8pXxA0cwIaO3zhKK67sGVc222TBfVNUTrh1yOldcP8HyudcqfiIiIiIhIPqmhEjGQ2b6YTsxHGRErUq49Q/MsVmTGXOszVIWsmEmvHGY1RXWev/rqK7p37250GWJiRTUjRfXfZFFSlOe4qOa6qCmq81yUs11UFOU5NmOu1VAVslptr7yNXL9eeOEF0y0KYi5FNSNa+yQvRTXXRU1RnWetH5IXM+Zap/yJiIiIiIjkkxoqERERERGRfFJDJWKgSZMmGV2CmJwyIlakXHuG5lmsyIy5VkMlYqDo6GijSxCTU0bEipRrz9A8ixWZMddqqEQM1Lp1a6NLEJNTRsSKlGvP0DyLFZkx12qoRERERERE8kkNlYiBGjdubHQJYnLKiFiRcu0ZmmexIjPmWg2ViIHWrVtndAlicsqIWJFy7RmaZ7EiM+ZaDZWIiIiIiEg+qaESERERERHJJzVUIgaaNWuW0SWIySkjYkXKtWdonsWKzJhrNVQiIiIiIiL5pIZKxEBdu3Y1ugQxOWVErEi59gzNs1iRGXPtZXQBVrd9GZw9ZnQV1lesNNRqa3QVIiIiInK9UUNVyM4eg5Rko6sQEREREZHCoFP+RAzUv39/o0sQk1NGxIqUa8/QPIsVmTHXaqhEDDRgwACjSxCTU0bEipRrz9A8ixWZMddqqEQM1KpVK6NLEJNTRsSKlGvP0DyLFZkx12qoRAx0/Phxo0sQk1NGxIqUa8/QPIsVmTHXuijFdezJyTEk7FuDw+GN3e6gbPGq9Go3nNZ1uxldmoiIiIhIkaCG6jp3b/sR3Nv+eZzOTOatfodXv+hFjQr1qRBWw+jSrgtRUVFGlyAmp4yIFSnXnqF5FisyY651yp8A4HB4cXuTR3FmZbLr0Cajy7luzJ492+gSxOSUEbEi5dozNM9iRWbMtRoqAeBi5gUWrJ4MQMWwmgZXc/0YOXKk0SWIySkjYkXKtWdonsWKzJhrUzdUWVlZjBs3jvDwcPz8/Khbty5xcXHUqlWLPn36GF2eJXyx9BU6jwil43P+fPzd8wzpNoVq5esAMGZaL9ZuW+De9oWpnVm/fbFRpVrSzJkzjS7hmhxO+fP/0zIMK+O6UtQyInI1lGvP0DyLFZkx16ZuqB555BFGjx5N3759WbRoEd27d6dnz57s3r2bhg0bGl2eJfRqN5yvR6cw68UT3BRxB5t3LnffFttpAlO/G0F6Rio/bplDoF8IjWrdamC1YpSDp+DtxfD6N3+OjZwDM9ZCxkXj6hIRERExmmkvSjF9+nSmTp3KihUraN26NQBt2rRhw4YNzJkzhwYNGhhcobUUCyjOkG5TePC16qyOn0fz2p0oHlSaLjc/wcR5A9l1aBOv91lidJligD+aqYvOnOPOLFi7Cw6fhv7twMe0q4mIiIhI4THtEaoxY8bQoUMHdzP1hxo1auDt7U2dOnU4deoUHTt2pGbNmtStW5dbb72VnTt3GlRx0RccUIJ/txzCR98+R1ZWFgC3NX6I5ONJdG4xkOCAEgZXaD1xcXFGl3BFs9fBxUzIzs799n0n4Kddnq3pelIUMiJyrZRrz9A8ixWZMdembKiSk5OJj4+nW7dLvw9p//79REdH4+vri81mY9CgQSQlJbF582Y6duxI7969DajYOrq0fIKTZw7z/S+fusfKl6yhy6gXkq1btxpdQp6Onobdx+EyvRQANuDHJE9VdP0xe0ZE8kO59gzNs1iRGXNtypN0kpOTAShbtmyO8fT0dOLi4rj99tsBCA0NpX379u7bmzdvztixY6/qMWw2WwFVm7dxjy2nbvUYjzzWtXozdsUlY4F+wcx56aTni/mH4uJW0LhnG6PLuMTgwYPzvH38+PFXtY1RqjfqQsdBc/LcJhs4ejoLm93r8oexDPbE5666PPXv/mpd6XcP5s+IyN8VRK7NlumiuoZo/ZCixmzPi9lX+brGlEeowsLCAEhKyvm299ixYzl8+PBlL0gxYcIEOnfuXNjliVw3sjIvXN12TqdpmykRERGRwmTLvtrWy4OysrKoX78+hw8fZty4cVSoUIFZs2axcOFC9u/fz9q1a2nSpEmO+4waNYpFixaxbNkyAgICDKr8UutnQEqy0VVYX2hFaNTD6CoulZiYmOftkZGRJCQk5LlNREREQZZ0Tc5dcF3NL9N5+W1sNogqD4/GeKysazZomuu/E+41to6/u1I+wPwZEfm7gsi12TJdVNcQrR9S1BTV50VTHqGy2+3MnDmT6OhoYmNj6d27N2FhYfTv3x+Hw0GdOnVybP/yyy+zYMECvv32W1M1UyJXMmrUKKNLyFOADzStlvc22dnQWs/HhcbsGRHJD+XaMzTPYkVmzLUpP0MFULNmTZYvX55j7P777ycqKgp/f3/32KhRo1i4cCHff/89oaGhHq5S5J/p3r270SVc0V0NXJdG33XMdQGKPw5p//H/d9aDmmUve3f5h4pCRkSulXLtGZpnsSIz5tqUR6guZ/369Tk+P7V161ZefPFFfvvtN2JiYqhXrx716tUzrkCRaxQZGWl0CVfk4wWxbaHbTVA21HWKn5cdald0ff9Uu2ijK7S2opARkWulXHuG5lmsyIy5Nu0Rqr9LTU0lKSmJfv36uceio6Ov+uobZjJ5/mCSktdTo0ID+nd62z0et3kmM+PewIaNnm2fo3ntToyd8RAHjiXg4+3Pv5r2oW39XoDrqiOPja9PpxYDuKPJ//Hp4hdZFT+XIP/iNIu6i66thzBj2Wus2/4tAEkH1jHt+QMkHVjP50tewpmVSf0a7Xj49lfYvGsFY2c8SNkSVSkdWplnen6K05nJa9Pv41TqUWpVbMyjHV1XT3zn68fZc3gL5UpWY3DXD3DYHcxY9hprExZQPKgMT/f8FH+fQJ6cHANA2vnTlClehVEPfc20pa8wf/VEOjR+mN4dXgbglc97cPLsES5mZpBxMZ33hmziwsXz/Hduf46c3EOVstEM6PxfZix7jZ+3LyLjwjl6tn2Om2/s4sHfmHg5oEW46092tqupEhEREZEi1FAFBQXhdObxyfgiYkfyBtIzUhnf70fenh3L9gPrqFWpMQBzfhzPuMdWYLPZeHZKB5rX7gTAsF7TLvkeqDXb/kdoUKkcY307vkmDmn9eRr5H22H0aDuM02kneOnTrgQHlKBejTY0qnUrAEPfbUNK6nEA2je8393kAKyMn0u18nXp2fZZ3vn6cXYd2kym8wKZmRd4M3YFM+Pe5KdtC6hV+Sa27PmRCf1X8uOvs1n00xTubvmE+5Lss38Yj79vMQDuuOn/iK7SnI07l7ofZ/h9M1yPt2UuOw7+AsDclf+hTf1eNAhv596ua+sn6dF2GOkZqTz9fns1VAZSMyUiIiLypyJ1yp8VJOxfS8OatwDQILw92/atcd9WrmR1zl9IIz0jlUDfYMD1nRdjZzzAiI/u5Oipfe5tl2/8gph6OS9rN2XhMzz9Xnt2HtyUY3zN1vk0i7oLAC+HNwDOLCfFi5UlwC/49/1NZ/CklizbOB2Awyd3U62c6+If1cvXY9ve1Rz+bTdV/zK2dd9qjqXsp0qZqD+327c652Nvm0/zaFdjWLxYmct+h8eq+LncXPtuADbvXsGabfN5cnIMq7fOz1F3xsV0bihb+3LTW+TExMQYXYKYnDIiVqRce4bmWazIjLlWQ+VhqekpBPzeLAX6hZCanuK+rUXtLsROqM9j4+vRqcXjAPS9803eHrCae9o8w3v/exKA9dsXU6daa+w2h/u+nW8eyKRBvzDw7slMnPd4jsdcFT+XFn85ovPN2vd5eGwtggNK4uPlS82Kjfjo6UTG/N+3fL3yP6SkHqdSqVr8uisOgM07l5N6PoWKpWrx627X2Kady0hLT6FciWokHvgZpzOTTbuW5fh5TqUew4btkiNpf5fpvMieI1sIr9gAgMO/7aJJxL94+ZFvmLZkNE5nJgD/mdOPvm/VoX6Ntlc932Y3efJko0sQk1NGxIqUa8/QPIsVmTHXaqg8LNAvhHMZZwBIyzhDkH+o+7bPv3+JKUO38eFTCXy+5CUAggNKAFC76s2cPHsEgEU/T+G2xr1z7PeP7SqWCs8xfu78WU6nnaBciarusX817cPHTydx4nQyOw9uxN83CC+HN/4+gdxYrRUHT+ygadSdZGSm89R77fD28qV4UBlqVKjHDWVrM/TdNpzLOENosTKEBpWifYP7ePr99hw8voPiQWXcj7Nm6zya/X50Ki+bd62gbvWYHHNUp3pr/H0CKR9Wg1OpRwEYePckPnoqkS+WvnLFfRYVsbGxRpcgJqeMiBUp156heRYrMmOu1VB5WFSVZmzc4foM0cYdS4is3NR9m4+XL37eAfj5BJLpvABA2nlX83Xg2HZ385V8PIkXpnZm1g9vMvfHCew/luje7nTaCfcRHYB12xfROOJ2998vZGYAru/68vMJxMfb331fZ5aTpAPrKFP8Bhx2BwM6/5c3+i7FbnfQqNZtANx/y0jGPbac4ICSNIn8FwB3NHmUN2NXULlMlHsMYFX819xc+8qfdVoVP5cWf9kuqkpz9hz+FWeWk6Mn9xISWMpdt4+3v/sInxWsWLHC6BLE5JQRsSLl2jM0z2JFZsx1kbkohVWEV2yAt7cfgye1pHr5epQOrcy0pa9wb7vhdGwWy6CJLQC4o0kfAF774l7Opp/CZrMx8G7XIc73hmwC4Lt1U3FmZVK5dAQTZvVlz5F4srOzeOSO19yPtzJ+Lr3aDXf//bt1H7Ni0wyysp3UrRZD5dIRLPxpCgt/eh+bzU6bej0JCynPidMHefWLe7Hb7LRv+ABhIRXIysriqffaYrc7qF+jHZGVmwDw0mfdOHvuJNXK1aFvxzcBVyOYmp5C6eKV3Y+96OcP+d/qSZw9d5Kz504x8O6JZGdns23fGgZ0fse93T1tnmHsjAc5l3GGO5o8ireXDxNmP8aBY4lkOi/QLeapQvjNiIiIiIhcO1t2UbzueBGyfgakJBtdhfWFVoRGPa68naclJibmeXtkZCQJCQl5bhMREVGQJV2XBk1z/XfCvcbW8XdXygcoI1L0FESuzZbporqGaP2QoqaoPi/qlD8RA11pQRBRRsSKlGvP0DyLFZkx12qoRAz01VdfGV2CmJwyIlakXHuG5lmsyIy51meoClmx0kZXcH0oqvP8wgsv0L17d6PLEBNTRsSKlGvP0DyLFZkx12qoClkt63xlkoiIiIiI/I1O+RMREREREcknNVQiBpo0aZLRJYjJKSNiRcq1Z2iexYrMmGs1VCIGio6ONroEMTllRKxIufYMzbNYkRlzrYZKxECtW7c2ugQxOWVErEi59gzNs1iRGXOthkpERERERCSf1FCJiIiIiIjkkxoqEQM1btzY6BLE5JQRsSLl2jM0z2JFZsy1GioRA61bt87oEsTklBGxIuXaMzTPYkVmzLUaKhERERERkXxSQyUiIiIiIpJPaqhEDDRr1iyjSxCTU0bEipRrz9A8ixWZMddqqERERERERPJJDZWIgbp27Wp0CWJyyohYkXLtGZpnsSIz5trL6AKsbvsyOHvM6Cqsr1hpqNXW6CpERERE5HqjhqqQnT0GKclGVyEiIiIiIoVBp/yJGKh///5GlyAmp4yIFSnXnqF5FisyY67VUIkYaMCAAUaXICanjIgVKdeeoXkWKzJjrtVQiRioVatWRpcgJqeMiBUp156heRYrMmOu9Rmq69iTk2NI2LcGh8Mbu91B2eJV6dVuOK3rdjO6tOvG8ePHjS5BTE4ZEStSrj1D8yxWZMZcq6G6zt3bfgT3tn8epzOTeavf4dUvelGjQn0qhNUwujQREREREdPTKX8CgMPhxe1NHsWZlcmuQ5uMLue6ERUVZXQJYnLKiFiRcu0ZmmexIjPmWg2VAHAx8wILVk8GoGJYTYOruX7Mnj3b6BLE5JQRsSLl2jM0z2JFZsy1Gqrr3BdLX6HziFA6PufPx989z5BuU6hWvg4AY6b1Yu22Be5tX5jamfXbFxtVqiWNHDnS6BLE5JQRsSLl2jM0z2JFZsy1qRuqrKwsxo0bR3h4OH5+ftStW5e4uDhq1apFnz59jC7PEnq1G87Xo1OY9eIJboq4g807l7tvi+00ganfjSA9I5Uft8wh0C+ERrVuNbBa65k5c6bRJVjab6kwf+Off//PYli/BzKdxtV0rZQRsSLl2jM0z2JFZsy1qS9K8cgjjzBnzhxGjBhBw4YNWb16NT179uT48eMMGTLE6PIspVhAcYZ0m8KDr1Vndfw8mtfuRPGg0nS5+QkmzhvIrkObeL3PEqPLFLlqCYfgwx9yNk97jsPu47BqB/RtA37extUnIiIi1mDaI1TTp09n6tSpzJ8/n6FDh9KmTRuGDx9Os2bNyMzMpEGDBkaXaDnBASX4d8shfPTtc2RlZQFwW+OHSD6eROcWAwkOKGFwhSJX52Sqq5ly/u1IVPbv/91zHL78yeNliYiIiAWZtqEaM2YMHTp0oHXr1jnGa9Sogbe3N3XquD7n07lzZ+rUqUP9+vW56aabWLJER1H+iS4tn+DkmcN8/8un7rHyJWvoMuqFJC4uzugSLGn1TteRqew8ttm0D06leaykfFNGxIqUa8/QPIsVmTHXpjzlLzk5mfj4eAYPHnzJbfv37yc6OhpfX18Apk6dSmhoKAAbN24kJiaGkydP4nA48nwMm81W4HXnZtxjy6lbPcYjj3Wt3oxdcclYoF8wc1466fli/qG4uBU07tnG6DIukVuG/2rXrl1Ur149z23Gjx9fkCVdF+4fm0jxcjXz/HeeDcR07sevSyZ7rrC/uVI+QBmRoqcgcm22TD/xuevtGU+9drhaeo4RqzHb82J2dl5vzf7JlEeokpOTAShbtmyO8fT0dOLi4nKc7vdHMwVw+vRpbDbbVf/wIkabP3++0SVYko9f4FW98PHyCfBANf+MMiJWpFx7huZZrMiMubZlm7D72LlzJ+Hh4YwfP55Bgwa5x0eNGsWLL77IxIkT6devn3u8f//+LFq0iNOnT/PVV1/Rrl07A6rO3foZkJJsdBXWF1oRGvUwuopLJSYm5nl7ZGQkCQkJeW4TERFRkCVdFyYugZ3H4Eqr28OtoE4lz9SUmyvlA5QRKXoKItdmy/Sgaa7/TrjX2Dr+Ts8xYjVF9XnRlKf8VatWjTp16jBmzBhKlChBhQoVmDVrFgsXLgSgYcOGObafOHEi4DqncvDgwfzwww8EBQV5vG4RMYdmNWDH0by3KeYH0RU8U4+IiIhYlylP+bPb7cycOZPo6GhiY2Pp3bs3YWFh9O/fH4fD4b4gxd+1bt0au93OqlWrPFyxSP6MGjXK6BIsqW5lqFEm7226NASHKVfAnJQRsSLl2jM0z2JFZsy1KY9QAdSsWZPly5fnGLv//vuJiorC398fgNTUVH777TeqVKkCuC5KsWvXLiIjIz1er0h+dO/e3egSLMlhh0djYObP8MvenKf+FfODuxtB/SpGVXdtlBGxIuXaMzTPYkVmzLVpG6rcrF+/nqZNm7r/npaWxj333ENqaipeXl74+fnx+eefU7lyZQOrvDqT5w8mKXk9NSo0oH+nt93j05a+wvzVE+nQ+GF6d3gZgLjNM5kZ9wY2bPRs+xzNa3cCIONiOvePqcqwnp/ToGZ7Jszqy54j8dhsNgZ2mUS18nXYvCuOKd88DTYbtzZ6iDubPQa4rlry2Pj6dGoxgDua/B8XLp7nv3P7c+TkHqqUjWZA5/9e9X0/Xfwiq+LnEuRfnGZRd9G19RCysrL44Jun2XVoE0EBxRl5/0y+WzeVGctfpUSxckRUuolHO47F6czkja96c+TkHppGdqRH22G5jgHMWP46G5K+x5mVyRt9l2G3F4HDC1dwNecBS/74esF9zeHOerDtEGRkQlgQRJYvGkem/qCMiBUp156heRYrMmOui0xDlZqaSlJSUo6LUZQpU4a1a9caWFX+7EjeQHpGKuP7/cjbs2PZfmAdtSo1BuCOm/6P6CrN2bhzqXv7OT+OZ9xjK7DZbDw7pYO7oVr00xSqlrvRvd09bYdRrkRVko/v4MOFw3jhwdnM+uFNRtw/k7CQijzxTjN3U7Rm2/8IDSrlvu/clf+hTf1eNAj/84IeV3tfgL4d36RBzfbuv/+4ZRaVy0TS985xObbr1vop7mjyf+6/r942n0qlIxjW8zOe/6gjJ88cYeu+1ZeMHUvZz/mMVMb21feMybUJCXB9pkpERESkMBSZ92mDgoJwOp08/vjjRpfyjyXsX0vDmrcA0CC8Pdv2rXHfVrxYmUsu91yuZHXOX0gjPSOVQN9gAC5mXiBh/1qib2jx53YlqgLg5fDGbnd9D1elUrVIO3+ai84M/HwC3dsu3/gFMfX+vCze5t0rWLNtPk9OjmH11vnXdF+AKQuf4en32rPz4CYA1m5bwL4jW3lycgwLf/rAvd3cHycwZFIrNuxwNYyJ+9bSMNw1F3WrtyHxwM+5jq1NWMDptBMMfbcNn33/0tVNtIiIiIhIISsyDZWVpKanEPB7YxToF0Jqekqe27eo3YXYCfV5bHw9OrVwNZSL10+lXYP7ct3+w0XP0uXmge77Pvfh7Tw8NsK9/frti6lTrTV2259ffnz4t100ifgXLz/yDdOWjMbpzLzq+3a+eSCTBv3CwLsnM3Geq75TqUepVDqCsX2WsHTDNE6dPUqL2p15b8ivjHxgNu8vGIozy0nq+RQC/P6ci7T0lFzHUs4eJSigOOMeW87+o9vYkbzhmubcrGJiYowuQUxOGRErUq49Q/MsVmTGXKuhMkCgXwjnMs4AkJZxhiD/0Dy3//z7l5gydBsfPpXA50tewunMZP3277gp4vZLtp3z4wSqlI6idtWbAfhw4TDeHrCGqc/sYPEvn3D+wjkW/TyF2xr3vqSmOtVb4+8TSPmwGpxKPXrV9w0OKAFAxVLhOfdXrTUOhxdRVZpx8MROgvxDsdvthAaVomKpmpw6e9Q1F+ddc3Hu/BkC/UMvO1anWmvAddRq/zFznTubX5MnTza6BDE5ZUSsSLn2DM2zWJEZc62GygBRVZqx8fdT3jbuWEJk5aZ5bu/j5YufdwB+PoFkOi9wKvUox1L28+wHHVi64XM+XPQsZ8+dYv32xWzdu5p72z/vvq/d7iDILxRvLx/sNjtO50WSjyfxwtTOzPrhTeb+OIH9xxKJqtKcPYd/xZnl5OjJvYQElrrq+6b93vycTjuB05kJQPQNzdl9+FcA9hzZQpniVdzbZVxM5+CJHYQGlSKySjP358U271pOrUqNcx2LusFVH8CuQ5so+/vpjUVdbGys0SWIySkjYkXKtWdonsWKzJjrInNRCisJr9gAb28/Bk9qSfXy9SgdWplpS1/h3nbDWfTzh/xv9STOnjvJ2XOnGHj3RDo2i2XQRNdnpe5o0oewkApMfGIdAJ8ufpHaN9xMsYDiTJz3OAG+wQx9tw2VStViUNf3uCfmGZ55vz02m53GEbcT6B/Ce0M2AfDduqk4szKpXDqCe9o8w9gZD3Iu4wx3NHkUby+fq77vH1cXzM7O4pE7XgOgQ+NHGPvlg8z5cQKNat1GqdCKfLZ4FOu2f0t2dhY92gzDy+FNs6g7eePL2QyaeDM3RdxByeByuY41jezIW7MeZcjk1lQuFUH0Dc09/nsrDCtWrDC6BDE5ZUSsSLn2DM2zWJEZc23Lzv7rN7RIQVs/A1KSja7C+kIrQqMeV97O0xITE/O8/Wou/RkREVGQJYmJXCkfoIxI0VMQuTZbpgdNc/13wr3G1vF3eo4Rqymqz4s65U9ERERERCSf1FCJGMhsX0wn5qOMiBUp156heRYrMmOu9RmqQlastNEVXB+K6jx/9dVXdO/e3egyxMSUEbEi5dozNM9iRWbMtT5DJVKIdH675KWonisukhd9hspz9BwjVlNUnxd1yp+IiIiIiEg+qaESERERERHJJzVUIgaaNGmS0SWIySkjYkXKtWdonsWKzJhrNVQiBoqOjja6BDE5ZUSsSLn2DM2zWJEZc62GSsRArVu3NroEMTllRKxIufYMzbNYkRlzrYZKREREREQkn9RQiRiocePGRpcgJqeMiBUp156heRYrMmOu1VCJGGjdunVGlyAmp4yIFSnXnqF5FisyY67VUImIiIiIiOSTGioREREREZF8UkMlYqBZs2YZXYKYnDIiVqRce4bmWazIjLlWQyUiIiIiIpJPaqhEDNS1a1ejSxCTU0bEipRrz9A8ixWZMddeRhdgVduXwdljRldx/SlWGmq1NboKkeub1j/P0HonImIOaqgKydljkJJsdBUiIp6n9U9ERK4nOuVPxED9+/c3ugQxOWVErEi59gzNs1iRGXOthkrEQAMGDDC6BDE5ZUSsSLn2DM2zWJEZc62GSsRArVq1MrqEq3IqDTbshfkbYcZa+PIn+D4eEg7B+YtGV2dtRSUjItdCufYMzbNYkRlzrc9QXceenBxDwr41OBze2O0OyhavSq92w2ldt5vRpV03jh8/bnQJeUo4BHGJkHj48tv4ekGjqtAmEsKKea6264XZM1LUaN0zB+XaMzTPYkVmzLUaquvcve1HcG/753E6M5m3+h1e/aIXNSrUp0JYDaNLEwOlZcCc9fDL3itvm5EJq3bAz7vhzvpwc02w2wq9RJF807onIiIFSaf8CQAOhxe3N3kUZ1Ymuw5tMrqc60ZUVJTRJVwi5RxM+O7qmqm/uuh0NWHT10JWVqGUdl0yY0asQuuecZRrz9A8ixWZMddqqASAi5kXWLB6MgAVw2oaXM31Y/bs2UaXkEP6BZi0FI6fzf8+1u2Gub8UXE3XO7NlxEq07hlHufYMzbNYkRlzrYbqOvfF0lfoPCKUjs/58/F3zzOk2xSqla8DwJhpvVi7bYF72xemdmb99sVGlWpJI0eONLqEHOZtgGNn8t5mwr2uP3n5Mcn1+Sv558yWESvQumc85dozNM9iRWbMtakbqqysLMaNG0d4eDh+fn7UrVuXuLg4atWqRZ8+fYwuzxJ6tRvO16NTmPXiCW6KuIPNO5e7b4vtNIGp340gPSOVH7fMIdAvhEa1bjWwWuuZOXOm0SW47TkOa3cV3P6++gmcOvXvHzNTRqxC657xilKu9//25/8f+O3y25lRUZpnkatlxlybuqF65JFHGD16NH379mXRokV0796dnj17snv3bho2bGh0eZZSLKA4Q7pN4afEb1gdPw+A4kGl6XLzE0ycN5Avlr7MY3eNN7hKKUw/bC/Y/Z06B/HJBbtPkYKkdU/ycuQ0vLkI3vr2z7E3v3WNHT1tXF0iYj6mbaimT5/O1KlTmT9/PkOHDqVNmzYMHz6cZs2akZmZSYMGDYwu0XKCA0rw75ZD+Ojb58j6/aoCtzV+iOTjSXRuMZDggBIGVyiF5fxF+PVAwe/3pwI84iVSGLTuSW5OnIX/LIbkk5felnwK3l4Mv6V6vi4RMSfTNlRjxoyhQ4cOtG7dOsd4jRo18Pb2pk6dOjnG33//fWw2G7NmzfJkmZbTpeUTnDxzmO9/+dQ9Vr5kDV1OuJDExcUZXQIAB04Wzul5+36D7OyC3+/1xCwZsTKte55n9lx/u8V1kZ7clq/sbNdt323xeFnXzOzzLJIfZsy1Kb+HKjk5mfj4eAYPHnzJbfv37yc6OhpfX1/32I4dO/j4449p2rSpJ8ss8t6MXXHJWKBfMHNeyuUtOSkUW7dupXTp0kaXwcFThbPftAw4nQ6hAYWz/+uBWTJiFVr3zMHMuT53ATbuzb2Z+kM2rq+WuLsR+Hl7pq78MPM8i+SXGXNt2oYKoGzZsjnG09PTiYuL4/bbb3ePZWZm8vDDDzN58mQGDRp01Y9hsxXuN4+Oe2w5davHFOpjyKXi4lbQuGcbo8twy+1Ngb8aP378VW1T2Jp0GUnTf4/KMXalK/ld7vZB03L+vUat2vyWvPUfVGddV/rdg3kyci20/nmG2da7PxREro3MdMmK0dz3WvwVt3NmQfkbIjl1KNEDVeWuqDzHiFwtsz0vZl/laTambKjCwsIASEpK4o477nCPjx07lsOHD+e4IMXo0aO5/fbbqVevnqfLvG483WOq0SVIIctyZhbavp3Oi4W2b5HConXv+nUxI+2qt83MOFeIlYhIUWHLvtrWy4OysrKoX78+hw8fZty4cVSoUIFZs2axcOFC9u/fz9q1a2nSpAk//fQTQ4cOZcWKFTgcDmJiYhgwYABdu3Y1+kdg/QxI0RXOPC60IjTqYXQVf0pMzPudy8jISBISEvLcJiIioiBLytWGvfDpqqvb9o8jU38/EpUbuw1e6w4+pnzrxnhXygeYJyPXQuufZ5htvftDQeTayExnZ8Pr37iu5He5F0g2oFwoPHUHFPIJL3kqKs8xIlerqD4vmvKiFHa7nZkzZxIdHU1sbCy9e/cmLCyM/v3743A43BekWL58Obt27aJ69erccMMNrF27ln79+vHmm28a/BOIXJ1Ro0ZdeSMPqFSycPZbNlTN1D9lloyIFCQz59pmg7ZRV/4MVdsoY5upq2HmeRbJLzPm2rQvdWrWrMny5ctzjN1///1ERUXh7+8PwLBhwxg2bJj7djMdoRK5Gt27dze6BADCgqBMMBw9U7D7jS5fsPu7HpklIyIFyey5blwVjp2BJVtdR6P+aK7++P9boqFRVePqu1pmn2eR/DBjrk15hOpy1q9fry/0FUuJjIw0ugTA9S5ri5oFvE+geXjB7vN6ZJaMiBQks+faZoOO9eDxW6BeFQjxd/2pVwUG3gL/qmd0hVfH7PMskh9mzLVpj1D9XWpqKklJSfTr1++y26xYscJzBeXD5PmDSUpeT40KDejf6W33+J4j8bw9+zGys7N54u7JVCtfh1c+78HJs0e4mJlBxsV03huyiROnD/H69Pu4kHmeB299iQY127N5VxxTvnkabDZubfQQdzZ7jG9//ohpS0YTfUMLhvX6HICdBzfx37n9sdvtPNxhDDdWa8ni9Z/w7c8fknExndsa9+au5v04dmo/b3z5EM6sTDq1GEDrut1Zs+1/fLH0FWzYaFmnK91aPwnA9+s/ZfEvn5CV5eTZXtMIC6kAwOwfxvPjltlM6L8y15/7yMm9PP7fJlQuHYmXw4fX+ywG4KsVb7B66zzKFK/CU/dMBWDIpFbsObKFdwdvcn8nTKcRIdQoXx+AFx6coy/eLCBNqkNcYsF9WWWLmlA8sGD2JdZwuTXwl6TvmfrdCHy9/Rl492Qql47Idc36OXER784fTHBgmHt9+cPIjztRtdyN9O7wMufOn+XVL3px5txJOjbtyy2NHsh1bN/Rbbw181EA6tdoy0MdRvPduqnMWP4qJYqVI6LSTTzacSybd61g7IwHKVuiKqVDK/NMz09xOjN5bfp9nEo9Sq2KjXm041h3LT9umcPkeU/wxfOub8vObc0aMqkV2Gw47F48d+90ige5LgG8I3kD/d5uyLevXcTh8OKDBU8Tv3cVdrudJ7t9RMVSepfCk6qXdv0REclLkTlCFRQUhNPp5PHHHze6lHzZkbyB9IxUxvf7kczMC2w/sM592yffjuC5e6cz4v6vmPrdCACG3zeDN2NX0D3maZpGdQTgy+Wv8eBto3nt0cVMW/oyALN+eJMR98/k7f6rWbzuYwCaRd/Fa32+z/H4nyweyfP3fcmr//cdXyx9BYC29XvxVr8f+M/ja/lm7XsAzFj+Or07vMIbjy1n4U9TcDozqV6uLhP6r+LtAatZs20+aemnOXH6IL/ujuONvkt5M3aFu5m6kJnBrkObrvhzNwy/hTdjV7ibqVOpx9i0azkT+q+kark6rIr/Gofdi1EPfU3LG3Oewlm17I28GbuCN2NXqJkqQL5e0LOp68jSP1UyCO6sVwA7EsvIaw38fMlLjO27lGd7fcGni18Acl+zIis35d0hmy/Z9+5Dv5JxMd3994U/fUBMvR681e8HFv08hYuZF3IdW7DmXR6541XeHrCKhP1rSU1PAaBb66d4M3ZFjiapfcP7eTN2Bc/0dH3578r4uVQrX5dxjy0nIzOdXYf+rOvHX2dRKrSS+++5rVlj+y7lrdg4bmn4AN+v/8S97fw1kwiv0ACAM+dOkpS8nrcHrOKR21/jf2sm5W/yRUSkUBWZhqqoS9i/loY1bwGgQXh7tu1b477tbPopSodWIiykAqnnU3Lcb1X8XG6ufTcAe45sIfqG5vj7BhHgW4y082eoVKoWaedPc9GZgZ+P63BASGAYDnvOg4+p6acoFVoRP58Azl9MI+NiOl4O17cRZjovULm06/DpkZO7qVq+Dg67g+LFypB8Ygeli1fGYXdg+/3dVJvNzvrt3+HMcvLUe+145+vHcWY5Afj25w+5pdGDV/y5N+1azuBJLZn9g+t7ApIOrKdutRj3dgn71mCz2SherMwlc7n/WAKDJ7VkysJhV/39AGYVExNjdAk51CgD/26c9zaDpuV9hb8AH3g0BnxN/GWXRYnZMpJfea2BAP4+gZQMLseh33YBua9ZxQKK4+Ple8m+5676D3c1//PshYT9a2lQ8xYcdgfVytflwLHEXMcq/r5+/rF+ef++77k/TmDIpFZs2LHUvc/lG6czeFJLlm2cDsDhk7upVs51gaTq5euxbe9qAH5KWEiD8PbYbH8+vea2Zv2x/mZcTKdKmWgA9h7ZSqmQivj7Fvt9ToII9AvBmeUk7XwKwQGFdPUYA1gl12aneRYrMmOu1VB5SGp6CgG+wQAE+oW43wkFyM7O4i9/cf9vpvMie45sIbyi693KrCyn+wuJA/1CSEtPoUXtLjz34e08PDaCdg3uu+zjhwSWYs+ReFJSj7P3SLz78T/7/iUeej2c8Iquz6ZVLFWLX3fFcf7CORL2ryXtL3X+nLiI8iWrE+BXjFOpR8l0XuCNvkvx9Q5g9dZ5ZDovsnnXCurXaJvnz10iuBwfP5PEuL7L2bBjCbsP/Ura+RQC/P6y3d8ay7+a+swO3or9gdRzp1iz7X+X3a4omDx5stElXOLmmtCrGXg7rv2+pYNh4K1QNqTg67pemTEj+ZHXGghw6uxR9h9L5MBR16VwL7dm/d3+Y4mEBpYiyD80x2MF+uZcT3Iba1jzFiZ9PZCHx9YiskozfL39aVG7M+8N+ZWRD8zm/QVDcWY5qVmxER89nciY//uWr1f+h5TU41T6fa0E2LxzuXvN+v6XTy5Zi3Nbs46d2s/A/zZj/qp3qFruRgDm/DiBTi0GuO/n7eVD2RJVeXhsLd6ZO4AONz1yjbNuXlbJtdlpnsWKzJhrNVQeEugXwrkM1yXU0jLO5Hjy/+t1V//6rubmXSuoWz0m19vSMs4Q6B/KhwuH8faANUx9ZgeLf/mE8xdy/5LB/7vjNd6dP4S3Zz9G1XJ1CAl0fXny/beM5JNhu/jh15mcSfuNnm2fZeFP7zP6s25ULhXhPkJ0+LfdfLViLI/dNd7989Sp1hqAejXasv9YAkt++Yy29Xtd8ef28fLF3ycQh8OLppEd2Xs03rXdedd2586fIcgvlMsJDiiBzWajee3O7D1y5W+zN7PY2FijS8jVTdXgmX9BrbJXt72Xw3UJ4aG3q5kqaGbNyLXKaw189I6xvDKtBzOWvUbUDS2Ay69Zfzf7h7focvMTOR/LP4S0jJzrSW5jU78bwfP3f8XHTyex9/AWjpzcS5B/KHa7ndCgUlQsVZNTZ4/i7xuEl8Mbf59AbqzWioMndtA06k4yMtN56r12eHv5UjyoDBt3LiOqSjO8vXxy1JPbmlW6eGX+8/gaHrh1FDPjxpF8fAcBfsE5fs59RxM4eGIHHz+dxPP3z+Tjb4f/g9+AuVgl12aneRYrMmOu1VB5SFSVZmz8/fSRjTuWEFm5qfu2YP8SHE9J5sTpQ+6jNOA63a9F7S7uv1crV4dte9eQfiGNc+fPEOgXjN3uIMgvFG8vH+w2O07nxVwfv2KpmrzeZzGDur5H6dDKeDm8uZCZAYC3wwdf7wDXi4JiZRj10NeMfGAW3l6+lC1RlXPnz/LGlw/xZLcP8f/9tMKoKs3ZffhXAHYd2kS5ElU5cHw7/1szmWc/6MC+o1v5euV/c/25z50/665r695VlCtZnZqVGvPrbte7vRt2LCGySlNyk34hzX16zta9qyhfsvo1/BbMx8wXUgkrBrHtXI1V6wioXBK8/rJiBPpCrXLQqQGM6gJ31dd3ThUGM2fkWuS1Bkbd0Ixxjy2nV7vhVC7jOv04tzUrN0dP7eONLx/ig2+eZvnG6WzeFUdUZddjObOc7Dq0iUqlI3Idy87Opph/Cex2OwF+IaRnnCXt9zd2Mi6mc/DEDkKDSrnHnFlOkg6so0zxG3DYHQzo/F/e6LsUu91Bo1q3sfdIPGu2znevgR9/+3yua1am86L71L8Av2B8vf3Zc2QLSQfW8ewHHdhz+FcmzHkMyCbw9wYvJDCMtPTThfK7MYJVcm12mmexIjPmWi9/PCS8YgO8vf0YPKkl1cvXo3RoZaYtfYV72w3ngVtH8fLn9wDweJeJAGRnZ7Nt3xoGdH7HvY/uMU8zdsYDZFxM54FbXV9qdk/MMzzzvut8/cYRtxPoH8LabQuYsfw1Dv+2i1Gf/JsXHpzNop8/ZOmGz/Hx9nc/xoxlr7J51woynRdo3+B+/H2D+CnhG2bGjcNuc/B//3odm83GvNXvcOTkHsZ99TAAQ+/5mBoV6uHr7c+Tk2MICQzj3y0H5zg6NWjizXS+2XUBkb/+3BGVb+KnhIV88t0IvL18qV21JZGVmwBwY7VWDJp4M6VDK3N3y0EAjP6sO/F7V3LwxA7uiXma0sWr8ObMh/H3CaJsiarueZDCUy4Uuvz+bQVZWTDE9RESXv63+b/UUswjrzVw2tJX2LhjCcEBJRn0b9cFcnJbs7YfWM+HC4ex90g8T7/XnpcfXsBrj34HuI7ob9ixhLrVW1OjQn1e/aIX81b9lzua9MHby4fbm/zfJWP3tHmG12fcj93uoHLpSKqWu5HPFo9i3fZvyc7OokebYXg5vFm8/hMW/vQ+NpudNvV6EhZSnhOnD/LqF/dit9lp3/ABwkIq0OXmgXS5eSDgWgN7d3iZnQc3XbJm/Xb6IK/NuB+7zY63w5en7plKieCytLzR9XnZJyfHMOjud3E4vAjwLcbgSS1xOjPp95crI4qIiHnYsov6p/pNav0MSEk2uorrT2hFaNTD6Cr+lJiYmOftkZGRJCQk5LlNREREQZb0j/1xQYoJ9xpbhxVcKR9QNDOi9c8zzLbe/aEgcm22TJuVFZ9j5PpWVJ8XdcqfiIGutCCIKCNiRcq1Z2iexYrMmGud8ldIiumLAA1R1Ob9q6++onv37kaXISZWFDNS1P4dFlVFeZ6LYq6LIs2zWJEZc61T/kQKkRVPx9ApfwWnqJ7aIJIXnfLnOVZ8jpHrW1F9XtQpfyIiIiIiIvmkhkpERERERCSf1FCJGGjSpElGlyAmp4yIFSnXnqF5FisyY67VUIkYKDo62ugSxOSUEbEi5dozNM9iRWbMtRoqEQO1bt3a6BLE5JQRsSLl2jM0z2JFZsy1GioREREREZF8UkMlYqDGjRsbXYKYnDIiVqRce4bmWazIjLlWQyVioHXr1hldgpicMiJWpFx7huZZrMiMuVZDJSIiIiIikk9qqERERERERPJJDZWIgWbNmmV0CWJyyohYkXLtGZpnsSIz5loNlYiIiIiISD6poRIxUNeuXY0uQUxOGRErUq49Q/MsVmTGXHsZXYDVbV8GZ48ZXYX1FSsNtdoaXYWIiIiIXG/UUBWys8cgJdnoKkREREREpDDolD8RA/Xv39/oEsTklBGxIuXaMzTPYkVmzLUaKhEDDRgwwOgSxOSUEbEi5dozNM9iRWbMtRoqEQO1atXK6BLE5JQRsSLl2jM0z2JFZsy1GioRAx0/ftzoEsTklBGxIuXaMzTPYkVmzLUuSnEde3JyDAn71uBweGO3OyhbvCq92g2ndd1uRpcmIiIiIlIkqKG6zt3bfgT3tn8epzOTeavf4dUvelGjQn0qhNUwurTrQlRUlNEliMkpI2JFyrVnaJ7FisyYa53yJwA4HF7c3uRRnFmZ7Dq0yehyrhuzZ882ugQxOWVErEi59gzNs1iRGXOthkoAuJh5gQWrJwNQMaymwdVcP0aOHGl0CWJyyohYkXLtGZpnsSIz5loN1XXui6Wv0HlEKB2f8+fj755nSLcpVCtfB4Ax03qxdtsC97YvTO3M+u2LjSrVkmbOnGl0CWJyyohYkXLtGZpnsSIz5trUDVVWVhbjxo0jPDwcPz8/6tatS1xcHLVq1aJPnz5Gl2cJvdoN5+vRKcx68QQ3RdzB5p3L3bfFdprA1O9GkJ6Ryo9b5hDoF0KjWrcaWK0YJdMJq5Lg9W/+HPswDnYcMa4mERERETMw9UUpHnnkEebMmcOIESNo2LAhq1evpmfPnhw/fpwhQ4YYXZ6lFAsozpBuU3jwteqsjp9H89qdKB5Umi43P8HEeQPZdWgTr/dZYnSZYoALmfDecth1DGx/GY8/CFuS4c560C7aqOpEREREjGXaI1TTp09n6tSpzJ8/n6FDh9KmTRuGDx9Os2bNyMzMpEGDBkaXaDnBASX4d8shfPTtc2RlZQFwW+OHSD6eROcWAwkOKGFwhdYTFxdndAlXNH+Dq5kCyP7LePbvf/nfJkjSkapCUxQyInKtlGvP0DyLFZkx16ZtqMaMGUOHDh1o3bp1jvEaNWrg7e1NnTquz/nExMRQtWpV6tWrR7169Rg2bJgR5VpGl5ZPcPLMYb7/5VP3WPmSNXQZ9UKydetWo0vI07kLsHZ33tvYbBCX6Jl6rkdmz4hIfijXnqF5FisyY65NecpfcnIy8fHxDB48+JLb9u/fT3R0NL6+vu6xN954g65du17TY9hstitvVADGPbacutVjPPJY1+rN2BWXjAX6BTPnpZOeL+YfiotbQeOebYwu4xK5Zfivxo8ff1XbGKVqvX9x19AFeW6TnQ2/7ruIzebjoaqs40q/ezB/RkT+riByrUxfnaL+HCPyd2Z7XszOzr7yRpj0CFVycjIAZcuWzTGenp5OXFycTvcT8RC719U1SXaHw3WoSkREROQ6Y8u+2tbLg3bu3El4eDjjx49n0KBB7vFRo0bx4osvMnHiRPr16we4Tvk7fPgwPj4+VKtWjdGjR7tPBzSD9TMgJdnoKqwvtCI06mF0FZdKTMz7XLjIyEgSEhLy3CYiIqIgS7omR0/Dq3kfoMIGlAqG5+70SEmWcqV8gPkzIvJ3BZFrZfrqFPXnGJG/K6rPi6Y85a9atWrUqVOHMWPGUKJECSpUqMCsWbNYuHAhAA0bNnRv++mnn1KpUiVsNhszZszgtttuY+fOnQQGBhpVvshVGzVqlNEl5KlMCFQrBXuO57wgxV9lAy31XdCFxuwZEckP5dozNM9iRWbMtSlP+bPb7cycOZPo6GhiY2Pp3bs3YWFh9O/fH4fDkeMIVOXKld2fh+rRowc+Pj5s377dqNJFrkn37t2NLuGK/t0YvL1yXjL9r24IgybVPVrSdaUoZETkWinXnqF5FisyY65N2VAB1KxZk+XLl5OWlsb+/fsZPXo0W7ZsISoqCn9/fwDOnz/PiRMn3PdZunQpZ8+epUYNXZFOiobIyEijS7iiCsXhiVuhaqmc4w47NK0OsW3Bx5THuq2hKGRE5Fop156heRYrMmOui9TLoPXr19O0aVP338+cOcPtt9/OhQsXsNvtBAcHM3/+fIKDgw2s8somzx9MUvJ6alRoQP9Ob7vHz5w7yduzH+NM2gnqhbfj3nbDGTvjIQ4cS8DH259/Ne1D2/q92HlwE/+d2x+73c7DHcZwY7WWHDu1nze+fAhnViadWgygdd3unDxzhFem9SCbbMqXrM7Q7h/x3bqpLF4/FYDdhzfzRt/lhAaVZsTHHdl3dBv/ezkVh8OLE6cPXTK250g8E2b1wW53UL5kDYZ2/wibzcb36z9l8S+fkJXl5Nle0wgLqXDJGNgu2V/C/p94d/5gbDY7tSo1JvYu1xVZ3vn6cfYc3kK5ktUY3PUDHHYHOw9u5INvnsaZlUm31kNpEvkvA35z168KxWHgrXDkNBxOcTVT1UtDoO8V7yoiIiJiaUWmoUpNTSUpKcl9MQqA0qVL88svvxhY1bXbkbyB9IxUxvf7kbdnx7L9wDpqVWoMwGffj+LB216icumcH6Qb1mtaju+B+mTxSJ6/70uKBZRg1Cd382q1b5mx/HV6d3iFWpVv4rkpt3Nz7btZtvELOjR+mFsaPcBbMx9l16HN3Nb4IW5r/BBOZyb93m5E9fJ1uZiZwdg+S3nxky7uxwgOKHHJWKVStXh7wGoA3viyN0nJ6ykZXJ5fd8fxRt+l7u1OnD54ydiFi+cv2V+Z0Cq80XcZPt5+vPrFvew5vIULmefJzLzAm7ErmBn3Jj9tW0Dz2p34fMloRj00Dz+fgAL6TUh+lA1x/RERERERF9Oe8vd3QUFBOJ1OHn/8caNL+UcS9q+lYc1bAGgQ3p5t+9a4b9t7JJ7pS8cw9N02bNvrGrfZbIyd8QAjPrqTo6f2AZCafopSoRXx8wng/MU0Mi6mc+TkbqqWr4PD7qB4sTIkn9hBxVI1STt/GoD0jLME+Ye6H+vXPT9Qp1orbDYbPt5+FAsonqPO3Ma8HN7u//f28qVUSCXWb/8OZ5aTp95rxztfP44zy5nrWG77KxFcFh9vPwAcdm/sdgeHf9tN1XKuz8hVL1+PrftWc/i33VzIPM9Ln3XlhamdOXX2aL7n32xiYmKMLkFMThkRK1KuPUPzLFZkxlwXmYbKKlLTUwjwdZ2SGOgXQmp6ivu2bXtX06Ptswy/dwbvf/MUAH3vfJO3B6zmnjbP8N7/ngQgJLAUe47Ek5J6nL1H4klNT6FiqVr8uiuO8xfOkbB/LWnpKdSqfBPf/PQ+D78RiZfDhzLFq7gfa+WWObSo/efRoqu1eut8Hh1Xm5SzRwkOLMmp1KNkOi/wRt+l+HoHsHrrvFzH8rL70K+cTjtOlTJRrp9jdxwAm3YuIy09hVNnj3LweBIj75/Fv5r25Yulr1xz3WY1efJko0sQk1NGxIqUa8/QPIsVmTHXaqg8LNAvhHMZZwBIyziT46hRxVI1qVImkuLFymC3uX41wQElAKhd9WZOnj0CwP/d8Rrvzh/C27Mfo2q5OoQEhtGz7bMs/Ol9Rn/WjcqlIiherAyz4t7kvvYj+eipBAL9Q/h19w+A61uf4/es5MZqra65/ubRd/HB0HjCQiuydtsCAv1CqFOtNQD1arRl/7GEXMcu58y5k7zz9QCe7PYhADUq1OOGsrUZ+m4bzmWcIbRYGQL9Q6hZqTF+PgFX3F9RExsba3QJYnLKiFiRcu0ZmmexIjPmWg2Vh0VVacbGHa7PFm3csYTIyn9eZKNCqZr8duYw6RfScGZlApB23tV8HTi23d18VSxVk9f7LGZQ1/coHVoZL4c3xYuVYdRDXzPygVl4e/lStkRVyM6m2O8NWXBASffpf9sPrCO8YgMcdsc11X4hM8P9/wG+wfh6+xNVpTm7D/8KwK5DmyhXomquY7lxOjN5bfp99Ok4jhLBZd3j998yknGPLSc4oCRNIv9FhbBwUlKP4cxysuvQJtfPZhErVqwwugQxOWVErEi59gzNs1iRGXNdZC5KYRXhFRvg7e3H4EktqV6+HqVDKzNt6Svc2244D946ijHTenLhYjr33fICAK99cS9n009hs9kYeLfrEOeinz9k6YbP8fH25/EuEwH4KeEbZsaNw25z8H//eh2bzcadzfsx9ssH+XzJSwQHlKRn2+cAWBU/l5tr3+2uKdN5keem3M7uw5sZNuU2Hr59DOEVGlwydurMEWb9+BYAFcLCaVjzVux2O77e/jw5OYaQwDD+3XIw3l4+l4zl9hiHf9tN0oF1fPDN0wA8cvurRFRuwlPvtcVud1C/RjsiKzcB4I4mjzL03RhsNjtP3TPVI78rEREREZErsWVnZ2cbXYSVrZ8BKclGV2F9oRWhUQ+jq7hUYmJinrdHRkaSkJD3KYwRERF53i5F15XyAcqIFD0FkWtl+uroOUaspqg+L+qUPxEDXWlBEFFGxIqUa8/QPIsVmTHXaqhEDPTVV18ZXYKYnDIiVqRce4bmWazIjLnWKX+FbPsyOHvM6Cqsr1hpqNXW6CoupdMxJC9F9dQGkbzolD/P0XOMWE1RfV7URSkKmRlf5IuIiIiISMHQKX8iIiIiIiL5pIZKxECTJk0yugQxOWVErEi59gzNs1iRGXOthkrEQNHR0UaXICanjIgVKdeeoXkWKzJjrtVQiRiodevWRpcgJqeMiBUp156heRYrMmOu1VCJiIiIiIjkkxoqERERERGRfFJDJWKgxo0bG12CmJwyIlakXHuG5lmsyIy5VkMlYqB169YZXYKYnDIiVqRce4bmWazIjLlWQyUiIiIiIpJPaqhERERERETySQ2ViIFmzZpldAlicsqIWJFy7RmaZ7EiM+ZaDZWIiIiIiEg+qaESMVDXrl2NLkFMThkRK1KuPUPzLFZkxlx7GV2A1W1fBmePGV2F9RUrDbXaGl2FiIiIiFxv1FAVsrPHICXZ6CpERERERKQw6JQ/EQP179/f6BLE5JQRsSLl2jM0z2JFZsy1LTs7O9voIqxs/QwdofKE0IrQqIfRVVwqMTHxH+8jIiKiACoRMyqIfIAyIuaidc9zNNdiNUX1eVFHqEQM1KpVK6NLEJNTRsSKlGvP0DyLFZkx1/oM1XXsyckxJOxbg8Phjd3uoGzxqvRqN5zWdbsZXdp14/jx40aXICanjIgVKdeeoXkWKzJjrtVQXefubT+Ce9s/j9OZybzV7/DqF72oUaE+FcJqGF2aiIiIiIjp6ZQ/AcDh8OL2Jo/izMpk16FNRpdz3YiKijK6BDE5ZUSsSLn2DM2zWJEZc62GSgC4mHmBBasnA1AxrKbB1Vw/Zs+ebXQJYnLKiFiRcu0ZmmexIjPmWg3Vde6Lpa/QeUQoHZ/z5+PvnmdItylUK18HgDHTerF22wL3ti9M7cz67YuNKtWSRo4caXQJYnLKiFiRcu0ZmmexIjPm2tQNVVZWFuPGjSM8PBw/Pz/q1q1LXFwctWrVok+fPkaXZwm92g3n69EpzHrxBDdF3MHmncvdt8V2msDU70aQnpHKj1vmEOgXQqNatxpYrfXMnDnT6BLE5JQRsSLl2jM0z2JFZsy1qRuqRx55hNGjR9O3b18WLVpE9+7d6dmzJ7t376Zhw4ZGl2cpxQKKM6TbFH5K/IbV8fMAKB5Umi43P8HEeQP5YunLPHbXeIOrFBERERExF9Ne5W/69OlMnTqVFStW0Lp1awDatGnDhg0bmDNnDg0aNDC4QusJDijBv1sO4aNvn6Np1J3Y7XZua/wQi36eQucWAwkOKGF0iSIiIiIipmLaI1RjxoyhQ4cO7mbqDzVq1MDb25s6dVyf87lw4QJDhgwhPDycG2+80ZRf9lWUdGn5BCfPHOb7Xz51j5UvWUOXUS8kcXFxRpcgJqeMiBUp156heRYrMmOuTXmEKjk5mfj4eAYPHnzJbfv37yc6OhpfX18AnnvuOc6ePUtiYiIOh4PDhw97utwi683YFZeMBfoFM+elk54v5jq1detWSpcubXQZYmLKiFiRcu0ZmmexIjPm2rQNFUDZsmVzjKenpxMXF8ftt98OwLlz53jvvfc4cOAADocDgHLlyl3VY9hstgKs+PLGPbacutVjPPJY17O4uBU07tnG6DIukdubAn81fvz4q9pGrOlKv3tQRqToKYhcK9NXR88xYjVme17Mzs6+qu1MecpfWFgYAElJSTnGx44dy+HDh90XpNi5cychISG89dZb3HTTTTRt2pSvvvrK4/Va3dM9plK76s1GlyEiIiIiYjq27KttvTwoKyuL+vXrc/jwYcaNG0eFChWYNWsWCxcuZP/+/axdu5YmTZqwYcMGGjZsyKRJk4iNjWXv3r00b96cb775hvr16xv9YwCwfgakJBtdhfWFVoRGPYyu4lKJiYl53h4ZGUlCQkKe20RERBRkSWIiV8oHKCNS9BRErpXpq6PnGLGaovq8aMojVHa7nZkzZxIdHU1sbCy9e/cmLCyM/v3743A43BekqFy5MgAPPvggADfccAMtWrTg559/Nqx2kWsxatQoo0sQk1NGxIqUa8/QPIsVmTHXpmyoAGrWrMny5ctJS0tj//79jB49mi1bthAVFYW/vz/gOjWwQ4cOfPPNNwD89ttv/Pzzz9StW9fI0kWuWvfu3Y0uQUxOGRErUq49Q/MsVmTGXJu2ocrN+vXrL/lC33fffZf33nuPG2+8kdatWzNs2DCaNm1qUIUi1yYyMtLoEsTklBGxIuXaMzTPYkVmzLUpr/KXm9TUVJKSkujXr1+O8SpVqrBkyRKDqsqfyfMHk5S8nhoVGtC/09vu8V+SvmfqdyPw9fZn4N2TqVw6ghOnD/H69Pu4kHmeB299iQY12zNp3iB2HdoEwO7Dm5n70ilmLHuNddu/BSDpwDqmPX+ANVvns3j9VPd2b/RdzqmzR5ix/DUAko9vZ+Ddk2kS+S+GTGrFniNbeHfwJiqE1SDTefGSsdNpJxj58V04HN4E+oXw/H1f4uvtT6cRIdQo7/rM2gsPziE4oAQfLHia+L2rsNvtPNntIyqWCqf32FqUKOa6CuPAuydRpUwUT06OIZtsbNi475aR1K/Rlj1H4nl79mNkZ2fzxN2TqVa+Dq983oOTZ49wMTODjIvpvDdkk2d+WSIiIiIieSgyDVVQUBBOp9PoMv6xHckbSM9IZXy/H3l7dizbD6yjVqXGAHy+5CXG9l3KufNnmDx/EM/f9yVfLn+NB28bTfXydXn+o440qNmefp0mALDz4EZmxb0JQI+2w+jRdhin007w0qddCQ4owW2NH+K2xg/hdGbS7+1GVC9fF5utHo0jOgDw+H+a0CC8PQ67F6Me+poPvnnGXWduY0H+xRnfbyV2u53PFo9i7bYFtK7bjaplb8zxnVZnzp0kKXk9bw9YRfyeVfxvzSRi7xpPSGCpXL/76o0+S3E4/oziJ9+O4Ll7p2O32fnPnH681Hsew++bAcDKLXPZcfCXAvldiIiIiIj8U0XqlD8rSNi/loY1bwGgQXh7tu1bk+N2f59ASgaX49BvuwDYc2QL0Tc0x983iADfYqSdP+PedmX8XFrceHeO+6/ZOp9mUXflGPt1zw/UqdYqx3dvHf5tN6HFyuDvG4TNZqN4sTI57pPbmMPuwG53RcaZ7aRCWDgA+48lMHhSS6YsHEZ2djb+PkEE+oXgzHKSdj6F4ICSAJw9d5Ihk1oxYVZfLlw8D4DdZufp99vzyuc9OHPO9YXCZ9NPUTq0EmEhFUg9n5KjhlXxc7m5ds6fuSiLiYkxugQxOWVErEi59gzNs1iRGXOthsrDUtNTCPANBiDQL4TU9JQct586e5T9xxI5cNR1OcisLKe7EQr0CyHtL9uv3/4tjWt1yHH/VfFzaXFjlxxjK7fMoUXtK49djcT9P9Pv7UZs2rmMciWqAjD1mR28FfsDqedOsWbb//D28qFsiao8PLYW78wdQIebHgFgfP+VvNXvB0oXr8I3P70PwIgHZvFm7AqaRd/FF0teBiA7O+vPB/zLVf0znRfZc2QL4RUbXHPdZjV58mSjSxCTU0bEipRrz9A8ixWZMddqqDws0C+Ecxmuo0xpGWcI8g913/boHWN5ZVoPZix7jagbWgBgs/35K0rLOEPg79snH99BWHAF/HwC3LefO3+W02kn3I0OuL7hOX7PSm6s1ipHHWsS/kfzvx3JuhoRlW9i0hPraVG7C9+u+wiA4IAS2Gw2mtfuzN4j8ew7msDBEzv4+Okknr9/Jh9/O9y9HUCL2l3YeyT+krE9v4/xlyNpf/35N+9aQd3qMddcs5nFxsYaXYKYnDIiVqRce4bmWazIjLlWQ+VhUVWasXHHUgA27lhCZOU/r0gYdUMzxj22nF7thlO5jOsKJtXK1WHb3jWkX0jj3PkzBPq5jm6tip97yRGmddsX0Tji9hxj2w+sI7xiAxx2h3vs5JkjeDt8CA4seU21X8y84P7/QL9gfLz9Sb+QhjPL9dm2rXtXUb5kdSCbQP9Q7HY7IYFhpKWf5mLmBS5kZri3K1eyOoD7FMate/64LwT7l+B4SjInTh8i4Pef93I/c1G3YsUKo0sQk1NGxIqUa8/QPIsVmTHXReaiFFYRXrEB3t5+DJ7Ukurl61E6tDLTlr7Cve2GM23pK2zcsYTggJIM+vd7AHSPeZqxMx4g42I6D9z65xeZ/ZSwgFEPzcux75Xxc+nVbniOsdw+c7R66zyaRXfKMTb6s+7E713JwRM7uCfmaZrX7nTJWIngcrz/zVPYbXaK+ZfgmZ6fkXw8iTdnPoy/TxBlS1TlgVtH4bA7CPAtxuBJLV0XxOj0Nqnpp3juw9vx9wkiyL84w3p+DsBT77XF19sfHy8/nrpnKgAP3DqKlz+/B4DHu0wEXEfatu1bw4DO7/zD34CIiIiISMGxZWf/5UMqUuDWz4CUZKOrsL7QitCoh9FVXCoxMTHP2yMjI0lISMhzm4iIiIIsSUzkSvkAZUSKnoLItTJ9dfQcI1ZTVJ8XdcqfiIGutCCIKCNiRcq1Z2iexYrMmGud8lfIipU2uoLrQ1Gd56+++oru3bsbXYaYmDIiVqRce4bmWazIjLnWKX8ihUinY0heiuqpDSJ50Sl/nqPnGLGaovq8qFP+RERERERE8kkNlYiIiIiISD6poRIx0KRJk4wuQUxOGRErUq49Q/MsVmTGXKuhEjFQdHS00SWIySkjYkXKtWdonsWKzJhrNVQiBmrdurXRJYjJKSNiRcq1Z2iexYrMmGs1VCIiIiIiIvmkhkrEQI0bNza6BDE5ZUSsSLn2DM2zWJEZc62GSsRA69atM7oEMTllRKxIufYMzbNYkRlzrYZKREREREQkn9RQiYiIiIiI5JMaKhEDzZo1y+gSxOSUEbEi5dozNM9iRWbMtRoqERERERGRfFJDJWKgrl27Gl2CmJwyIlakXHuG5lmsyIy59jK6AKvbvgzOHjO6CmsrVhpqtTW6ChERERG5HqmhKmRnj0FKstFViIiIiIhIYdApfyIG6t+/v9EliMkpI2JFyrVnaJ7FisyYa1t2dna20UVY2foZOkJV2EIrQqMeRleRu8TExH+8j4iIiAKoRMyoIPIByoiYi9Y9z9Fci9UU1edFHaESMVCrVq2MLkFMThkRK1KuPUPzLFZkxlyroRIx0PHjx40uQUxOGRErUq49Q/MsVmTGXOuiFNexJyfHkLBvDQ6HN3a7g7LFq9Kr3XBa1+1mdGkiIiIiIkWCGqrr3L3tR3Bv++dxOjOZt/odXv2iFzUq1KdCWA2jS7suREVFGV2CmJwyIlakXHuG5lmsyIy51il/AoDD4cXtTR7FmZXJrkObjC7nujF79myjSxCTU0bEipRrz9A8ixWZMddqqASAi5kXWLB6MgAVw2oaXM31Y+TIkUaXICanjIgVKdeeoXkWKzJjrtVQXee+WPoKnUeE0vE5fz7+7nmGdJtCtfJ1ABgzrRdrty1wb/vC1M6s377YqFItaebMmUaXICanjIgVKdeeoXkWKzJjrk3dUGVlZTFu3DjCw8Px8/Ojbt26xMXFUatWLfr06WN0eZbQq91wvh6dwqwXT3BTxB1s3rncfVtspwlM/W4E6Rmp/LhlDoF+ITSqdauB1YqIiIiImIupG6pHHnmE0aNH07dvXxYtWkT37t3p2bMnu3fvpmHDhkaXZynFAoozpNsUfkr8htXx8wAoHlSaLjc/wcR5A/li6cs8dtd4g6sUERERETEX017lb/r06UydOpUVK1bQunVrANq0acOGDRuYM2cODRo0MLhC6wkOKMG/Ww7ho2+fo2nUndjtdm5r/BCLfp5C5xYDCQ4oYXSJlhMXF2d0CWJyyohYkXLtGZpnsSIz5tq0R6jGjBlDhw4d3M3UH2rUqIG3tzd16tQhJSWFevXquf9ERUVhs9nYsmWLQVUXfV1aPsHJM4f5/pdP3WPlS9bQZdQLydatW40uQUxOGRErUq49Q/MsVmTGXJvyCFVycjLx8fEMHjz4ktv2799PdHQ0vr6++Pr6smnTJvdtn376KW+99RY33njjFR/DZrMVZMmXNe6x5dStHuORx7pWb8auuGQs0C+YOS+d9Hwx/0Bc3Aoa92xjdBm5yi3DfzV+/Pir2kas6Uq/e1BGpOgpiFwr01dHzzFiNWZ7XszOzr6q7Ux5hCo5ORmAsmXL5hhPT08nLi7usqf7ffDBB7pYhYiIiIiIeIwt+2pbLw/auXMn4eHhjB8/nkGDBrnHR40axYsvvsjEiRPp169fjvskJibSsGFDDh06REhIiIcrvrz1MyAl2egqrC20IjTqYXQVuUtMTMzz9sjISBISEvLcJiIioiBLEhO5Uj5AGZGipyByrUxfHT3HiNUU1edFU57yV61aNerUqcOYMWMoUaIEFSpUYNasWSxcuBAg1yv8vf/++3Tv3t1UzZTIlYwaNcroEsTklBGxIuXaMzTPYkVmzLUpT/mz2+3MnDmT6OhoYmNj6d27N2FhYfTv3x+Hw0GdOnVybJ+RkcGnn36q0/2kyOnevbvRJYjJKSNiRcq1Z2iexYrMmGtTNlQANWvWZPny5aSlpbF//35Gjx7Nli1biIqKwt/fP8e2c+fOpVy5cjRr1sygakXyJzIy0ugSxOSUEbEi5dozNM9iRWbMtSlP+buc9evX07Rp00vGP/jgAx599FEDKsqfyfMHk5S8nhoVGtC/09vu8Vc+78HJs0e4mJlBxsV03huyiW9//ohpS0YTfUMLhvX6HIALF8/z37n9OXJyD1XKRjOg83/5dPGLrIqfS5B/cZpF3UXX1kP4bt1UZix/lRLFyhFR6SYe7TgWgBnLX2dD0vc4szJ5o+8ydh/ezOszHiA94yyfP7cXgJNnjvDKtB5kk035ktUZ2v0jNu9awdgZD1K2RFVKh1bmmZ6fsudIPBNm9cFud1C+ZA2Gdv+I384cZsTHHdl3dBv/ezkVh8MLpzOT16bfx6nUo9Sq2NhdS6cRIdQoXx+AFx6cQ3BACXYe3MgH3zyNMyuTbq2H0iTyXwDsSN5Av7cb8u1rF3E4ilR0RURERMSiisyr0tTUVJKSki65GAXA0qVLDagof3YkbyA9I5Xx/X7k7dmxbD+wjlqVGgMw/L4ZAKzcMpcdB38BoFn0XdxYrRWfLX7RvY+5K/9Dm/q9aBDeLse++3Z8kwY12+cY69b6Ke5o8n/uvyfu/5nzGamM7bvEPVa+ZA3+8/hanv3gNvfYso1f0KHxw9zS6AHemvkouw5tBqB9w/vp3eFl93aVStXi7QGrAXjjy94kJa+natkbGdtnKS9+0sW93cr4uVQrX5eebZ/lna8fZ9ehzVQvX5eqZW+85PLtny8ZzaiH5uHnE5BjfP6aSYRX0Bc6i4iIiIh5mPaUv78LCgrC6XTy+OOPG13KP5Kwfy0Na94CQIPw9mzbt+aSbVbFz+Xm2ncDEBIYhsOes+/dvHsFa7bN58nJMazeOt89PmXhMzz9Xnt2HtzkHpv74wSGTGrFhh2upnNtwgJOp51g6Ltt+Oz7lwAI8CuGv09gjseoWKomaedPA5CecZYg/1AAlm+czuBJLVm2cToAXg5v9328vXwpFVIJH28/igUUz7G/wyd3U62c67Nv1cvXY9teVxO2/1gCgye1ZMrCYWRnZ3P4t91cyDzPS5915YWpnTl19igAe49spVRIRfx9i+U5v0VNTEyM0SWIySkjYkXKtWdonsWKzJjrItNQWUVqegoBvsEABPqFkJqekuP2TOdF9hzZQnjFyx+JOfzbLppE/IuXH/mGaUtG43Rm0vnmgUwa9AsD757MxHmuprNF7c68N+RXRj4wm/cXDMWZ5STl7FGCAooz7rHl7D+6jR3JG3J9jFqVb+Kbn97n4Tci8XL4UKZ4FWpWbMRHTycy5v++5euV/yEl9TgAq7fO59FxtUk5e5TgwJK57q9SqVr8uisOgM07l5N63vVzT31mB2/F/kDquVOs2fY/Tp09ysHjSYy8fxb/atqXL5a+AvD/7d1pjF1lHQbwZ5Yu02ln2jIFLHco0BZaCkIshloCpdCAEFG0IZSgEDYRqUE2QQgSTFR2IQpliwFXQERMiNEItrK0VES2UpYKRaBSClKWtnRKZ8YPwETj0JYDM3fh9/t45573/PPef+6ZJ+e978mtd1+WL+wxe9MmuYrMmTOn3CVQ4fQItUhf9w/zTC2qxL4WqPpZ8+DWrOl4I0myuuONnjs/73n46XnZZezeGx3jk2OnpWlgc0a3jcvKVS+lZcjIJElp1Pie9w1tGp76+voMHzoqpVHbZ+WbL71z7HbTkiS7jJ2e51b0vo//LX+5JF+e8Z385PTH09zUmkeeuStNg4amsWFAmgY2Z+ft9sqyV5YkSaZO+nyuPW1R2oaXct/i23sdb8qOB6Vj/Vs5/ep9M6BxUEYM3SJJ0jJkZOrq6jJ1p4Pz7PJFaW5qzfbtn87ggUOy67h98tyKx/PCy0syZHBLWpvbNjy5VeiEE04odwlUOD1CLdLX/cM8U4sqsa8Fqn6245jP5MF3l989uOSOTNz6fzfZuHfRb7PHTl/s7dD/GmNqlr74SDq7OvPSq8+mtXlUVq99J6S9vvqVdHauT5Ke1zrefivLXlmS4UNHZcdt3jk2SZ7+10PZcuS2vZ+kuzvD3g1pLUM2y+q1r/eM19nVmaeevz9bjNgm69Z39BwyZFBLBg1o6nW4hvqGzD74R7no+DtTX9+Q3XbYP2+tW53Ors4kyWPP3pvRm43NVm3j89qqFens6uypb+nyR/PU8/fn29d+NktffCSX3fq1Dc5PNZk3b165S6DC6RFqkb7uH+aZWlSJfV01m1LUivGlT2XAgME5+co9M3b0rtl8+Nb5xZ3fy+H7np3u7u4s/ueCzD74xz3vv2/x7blx7vl58d9P57wbZubcI3+TQ6efkQtvPDJrOt7IgbsflwGNA3PFbd/I0uWL0t3dlWMOPD9JcutdP8z9T/4h3d1dmTX9zDQ2DMiUiZ/Lpbccl1PmTMvWoyZk0jZTs+K153PxTUfl2eWL8q2rZ+SUQ67LQVO/ngtvOjI/v+O7aRmyWQ7b56z86YGf5vcLr0ldXX2m73pY2lpHZ/6i3+WWuy9NkmzVNj6Tt98v6zvfzlnXHZBnXnw4Z163f44+4PsZ1VrKD355eOrr6jNj8hFpa90q/1j2UC759dFpGjg0W47cNkfsd14a6hty4O7H5bSr9k5dXX1OP/T6fGLkttlz53d+U3bqnL3zzS9d1f8fHAAA9KKuu7u7u9xF1LK/3Zi89kK5q6htw0vJbrPKXUXvnnjiiQ3+feLEiXn88d6XXb5nwoQJH2VJVJCN9UeiR6g+H0Vf6+lN4xpDranW66Ilf1BGG/tCAD1CLdLX/cM8U4sqsa8FKiijm2++udwlUOH0CLVIX/cP80wtqsS+tuSvjz355+TNFeWuorYN2zzZYZ9yV9E7yzHYkGpd2gAbYslf/3GNodZU63XRphR9rFL/0QcAAD48S/4AAAAKEqigjK688spyl0CF0yPUIn3dP8wztagS+1qggjKaNGlSuUugwukRapG+7h/mmVpUiX0tUEEZTZs2rdwlUOH0CLVIX/cP80wtqsS+FqgAAAAKEqgAAAAKsm069KGNPQfh3HPP9QyQj7FN+ez1CNVGX/cf1xhqTbV+f3iwLwAAQEGW/AEAABQkUAEAABQkUAEAABQkUAEAABQkUAEAABQkUAEAABQkUAEAABQkUPXipJNOSqlUSmOj5x4DAADvz4N9e3HPPfdk3LhxKZVKWb9+fbnLAQAAKpRAtQGNjY0CFQAA8L4s+QMAAChIoAIAAChIoAIAAChIoAIAAChIoOrF8ccfn1KplM7OzpRKpZx44ok9f7OHBwAA8B67/H1A8+57KMuWv5xDD9onjQ0N5S4HAAAoI3eoPoCOjnW5a+HDWff2emEKAACo/kD16KOPZubMmWlra8vgwYMzfvz4nH322X1yrvl/fyxr1nZkxh6T+2R8AACgujSWu4AP44EHHshee+2V9vb2XHTRRRkzZkyWLl2a+fPnb/TYMy+4pvB5r/jZbYWPBQAAKt/5Z3x1k95X1YHq1FNPTXNzcxYuXJjW1tae14855pgyVgUAAHxcVO2mFGvWrMmwYcMye/bsXH755X16ro6Odbngql+lffTmOeqQA/r0XAAAQPWo2jtUK1euTFdXV0qlUqHjiyz5e/KZ5z/UUkEAAKA6bOqSv6rdlGLEiBGpr6/PsmXLyl0KAADwMVW1S/6SZPr06Vm8eHGWLFmSlpaWPjnH3AUP5o933Z8Tv3Jw2kdv3ifnAAAAqlPV3qFKkosvvjirVq3KlClTcv3112fu3Lm54YYbcuyxx34k43d0rMvdf30kO2zXLkwBAAD/p2p/Q5UkkydPzoIFC3LOOefk5JNPztq1a9Pe3p5Zs2Z9JOO/+vqbaWoa5LlTAABAr6p6yV9/6OrqSn19Vd/IAwAA+ohABQAAUJBbLwAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAUJVAAAAAX9B4Fs6uEzbEOLAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 118, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "vqc(n_qubits_data, num_layers,params).draw(output=\"mpl\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#Fucntion to make a swap test\n", - "'''\n", - "Input: Number of qubits\n", - "Output: Quantum circuit\n", - "'''\n", - "def swap_test(n):\n", - " qubits_values = 2*n+1 #Create a new qubit value to create our circuit\n", - " qc = QuantumCircuit(qubits_values) #Create the quantum circuit with the qubits value\n", - " qc.h(0) #Applying a H gate to the first qubit\n", - " for i in range(n):\n", - " #Applying a cswap gate between the first quibit and the i+1 and 2*n-i qubits\n", - " qc.cswap(0,i+1,2*n-i) \n", - " qc.h(0) #Applying a H gate to the first qubit\n", - " qc.barrier() #Create a barrier\n", - " return qc\n", - "#Example of a swap test with 2 quibits\n", - "swap_test(2).draw(output=\"mpl\")" - ] - }, - { - "cell_type": "code", - "execution_count": 126, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 126, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "size_reduce = 2 #Number of qubits we want to reduce\n", - "circuit_init = input_data(n_qubits_data, data_pca[0]) #Create a inicial circui\n", - "circuit_vqc = vqc(n_qubits_data,num_layers,params) #Create a quantum variational circuit\n", - "circuit_swap_test = swap_test(size_reduce) #Create a swap test circuit\n", - "\n", - "#Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", - "circuit_full = QuantumCircuit(n_qubits_data+size_reduce+1,1)\n", - "\n", - "#Combine the initial circuit, the quantum variatinal circuit and the swap test\n", - "#For the initial circuit and QVC we start at the qubit size_reduce + 1\n", - "#For the swap test we start at the qubit 0\n", - "circuit_full = circuit_full.compose(circuit_init,[i for i in range(size_reduce+1,n_qubits_data+size_reduce+1)])\n", - "circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(size_reduce+1,n_qubits_data+size_reduce+1)])\n", - "circuit_full = circuit_full.compose(circuit_swap_test,[i for i in range(2*size_reduce+1)])\n", - "circuit_full.draw(output=\"mpl\")" - ] - }, - { - "cell_type": "code", - "execution_count": 127, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 127, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "vqc(n_qubits_data,num_layers,params).inverse().draw(output = \"mpl\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "metadata": {}, - "outputs": [], - "source": [ - "from random import shuffle\n", - "from scipy.optimize import minimize " - ] - }, - { - "cell_type": "code", - "execution_count": 131, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8" - ] - }, - "execution_count": 131, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "n_qubits_data" - ] - }, - { - "cell_type": "code", - "execution_count": 138, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/scipy/optimize/_minimize.py:702: OptimizeWarning: Unknown solver options: max_iter\n", - " res = _minimize_cobyla(fun, x0, args, constraints, callback=callback,\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.860546875\n", - "0.787109375\n", - "0.845703125\n", - "0.745703125\n", - "0.786328125\n", - "0.787890625\n", - "0.7515625\n", - "0.738671875\n", - "0.7625\n", - "0.7453125\n", - "0.84140625\n", - "0.41875\n", - "0.390234375\n", - "0.467578125\n", - "0.36484375\n", - "0.41875\n", - "0.426953125\n", - "0.370703125\n", - "0.490234375\n", - "0.4140625\n", - "0.581640625\n", - "0.421484375\n", - "0.361328125\n", - "0.331640625\n", - "0.2703125\n", - "0.26875\n", - "0.27421875\n", - "0.294140625\n", - "0.32578125\n", - "0.253515625\n", - "0.245703125\n", - "0.2828125\n", - "0.24296875\n", - "0.260546875\n", - "0.260546875\n", - "0.31328125\n", - "0.269140625\n", - "0.264453125\n", - "0.25859375\n", - "0.230078125\n", - "0.269921875\n", - "0.2484375\n", - "0.265625\n", - "0.270703125\n", - "0.260546875\n", - "0.25390625\n", - "0.25859375\n", - "0.24765625\n", - "0.249609375\n", - "0.238671875\n", - "0.266015625\n", - "0.25390625\n", - "0.248046875\n", - "0.238671875\n", - "0.2359375\n", - "0.252734375\n", - "0.25625\n", - "0.270703125\n", - "0.231640625\n", - "0.25\n", - "0.262109375\n", - "0.25859375\n", - "0.255078125\n", - "0.24609375\n", - "0.246484375\n", - "0.234765625\n", - "0.252734375\n", - "0.264453125\n", - "0.224609375\n", - "0.26796875\n", - "0.244921875\n", - "0.263671875\n", - "0.259765625\n", - "0.262109375\n", - "0.234375\n", - "0.24765625\n", - "0.256640625\n", - "0.251171875\n", - "0.244921875\n", - "0.24609375\n", - "0.244140625\n", - "0.24921875\n", - "0.26015625\n", - "0.237109375\n", - "0.242578125\n", - "0.24609375\n", - "0.248828125\n", - "0.257421875\n", - "0.246484375\n", - "0.24296875\n", - "0.24609375\n", - "0.259375\n", - "0.258203125\n", - "0.25859375\n", - "0.23828125\n", - "0.2421875\n", - "0.2484375\n", - "0.234765625\n", - "0.24765625\n", - "0.26015625\n", - "0.26015625\n", - "0.24375\n", - "0.251171875\n", - "0.237109375\n", - "0.24921875\n", - "0.24453125\n", - "0.24375\n", - "0.253515625\n", - "0.253125\n", - "0.241015625\n", - "0.256640625\n", - "0.258984375\n", - "0.255078125\n", - "0.24453125\n", - "0.2421875\n", - "0.25390625\n", - "0.266015625\n", - "0.2453125\n", - "0.252734375\n", - "0.237890625\n", - "0.24765625\n", - "0.24609375\n", - "0.24296875\n", - "0.23671875\n", - "0.255859375\n", - "0.244140625\n", - "0.2609375\n", - "0.2484375\n", - "0.241015625\n", - "0.251953125\n", - "0.25390625\n", - "0.243359375\n", - "0.248046875\n", - "0.253125\n", - "0.25703125\n", - "0.25\n", - "0.25625\n", - " cost: 0.25625\n", - "[ 3.25402569 -0.87167382 2.74528436 0.39132926 -1.3705645 0.34323234\n", - " 2.93714471 0.80357588 1.32506271 0.17947663]\n" - ] - } - ], - "source": [ - "from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute, QuantumRegister, ClassicalRegister\n", - "\n", - "#Function to identify a function cost\n", - "'''\n", - "Input: An array of parameters(vector of complex amplitudes)\n", - "Output: Function cost\n", - "'''\n", - "def objective_function(params):\n", - " n = n_qubits_data\n", - " costo = 0\n", - " shuffle(data_pca) #reorganize the order of the train set items\n", - " length = 5 #We only will consider the first five elements of the taining set\n", - " #For each item of the trainig set\n", - " for i in range(length):\n", - " circuit_init = input_data(n, data_pca[i])#Create a inicial circuit\n", - " circuit_vqc = vqc(n, num_layers,params) #Create a quantum variational circuit\n", - " circuit_swap_test = swap_test(size_reduce) #Create a swap test circuit\n", - "\n", - " #Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", - " circuit_full = QuantumCircuit(n + size_reduce+1,1)\n", - " \n", - " #Combine the initial circuit, the quantum variatinal circuit and the swap test\n", - " #For the initial circuit and QVC we start at the qubit size_reduce + 1\n", - " #For the swap test we start at the qubit 0\n", - " circuit_full = circuit_full.compose(circuit_init,[i for i in range(size_reduce+1,n+size_reduce+1)])\n", - " circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(size_reduce+1,n+size_reduce+1)])\n", - " circuit_full = circuit_full.compose(circuit_swap_test,[i for i in range(2*size_reduce+1)])\n", - " \n", - " #\n", - " circuit_full.measure(0, 0) # Measure the first qubit\n", - " \n", - " #qc.draw()\n", - " \n", - " #Execute the circuit in the qasm_simulator\n", - " job = execute( circuit_full, Aer.get_backend('qasm_simulator'),shots=shots )\n", - " counts = job.result().get_counts() #Count the results of the execution\n", - " probs = {} #Calculate the probabilities of 0 and 1 state\n", - " \n", - " for output in ['0','1']:\n", - " if output in counts:\n", - " probs[output] = counts[output]/shots #Calculate the average of a state\n", - " else:\n", - " probs[output] = 0\n", - " costo += (1 + probs['1'] - probs['0']) #Update the actual function cost\n", - " \n", - " print(costo / length)\n", - " \n", - " return costo / length\n", - "\n", - "shots = 1024 #Number of shots\n", - "max_iter = 2\n", - "\n", - "for i in range(1):\n", - " #Minimization of the objective_fucntion by a COBYLA method\n", - " options = {\n", - " \"max_iter\": max_iter\n", - " }\n", - " minimum = minimize(objective_function, params, method='COBYLA', tol=1e-6, options=options)\n", - " params = minimum.x #Get the solution array\n", - " #Show the cost of the solution array\n", - " print(\" cost: \",objective_function(params))\n", - " print(params)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "params_minimized = params" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# P Q C\n", - "# Rotations CRY, CRZ < - controlled by parameters\n", - "# -> " - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [], - "source": [ - "import tqdm" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2000/2000 [00:37<00:00, 53.27it/s]\n" - ] - } - ], - "source": [ - "#Function to compress the training set values\n", - "'''\n", - "Input: An array of parameters(vector of complex amplitudes)\n", - "Output: Array with compress values\n", - "'''\n", - "def compress_result(*, params, n, size_reduce, X, shots=1024):\n", - " reduce = [] #List to save the compress values\n", - " #For each row in the training set we will\n", - " for i in tqdm.tqdm(range(len(X))):\n", - " circuit_init = input_data(n, X[i]) #Create a inicial circuit\n", - " circuit_vqc = vqc(n,num_layers,params) #Create a quantum variational circuit\n", - " \n", - " #Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", - " circuit_full = QuantumCircuit(n, n-size_reduce)\n", - "\n", - " #Combine the initial circuit, the quantum variatinal circuit\n", - " circuit_full = circuit_full.compose(circuit_init,[i for i in range(n)])\n", - " circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(n)])\n", - " len_cf = len(circuit_full) #Known the length of the circuit\n", - " #For each n - the the desired qubits to reduce we will\n", - " for i in range(n-size_reduce):\n", - " circuit_full.measure(size_reduce+i, i) #Measure the circuit in the position size_reduce+i \n", - " #We will execute the full circuit in the qasm simulator\n", - " job = execute( circuit_full, Aer.get_backend('qasm_simulator'), shots=shots )\n", - " result = job.result().get_counts() #Get the results of the execution\n", - " #Get the probabilities of each state\n", - " probs = {k: np.sqrt(v / shots) for k, v in result.items()}\n", - " reduce.append(probs) #Save the probabilities\n", - " \n", - " return reduce\n", - " \n", - "#Call the compress_result_train function with the parameters defined above\n", - "reduce_img = compress_result(params=params_minimized, n=n_qubits_data, size_reduce=size_reduce, X=data_pca, shots=1024)\n", - "train_reduce = [] #List to save the new values of the image reduction\n", - "#for each value in the reduce_img list\n", - "for i in reduce_img:\n", - " index_image = [] #List to save the reduction values\n", - " #We now take in count we want a 6X6 image\n", - " size = n_qubits_data - size_reduce \n", - " \n", - " for j in range(size * size):\n", - " bin_index = bin(j)[2:] #We take the binary value of j from the 2 position to the end\n", - " \n", - " while len(bin_index) < size: #While bin_index is less than 4\n", - " bin_index = '0'+bin_index #We concatenate a 0 string at the beginnig\n", - " try: \n", - " #We try to save the element of the row in the position bin_index\n", - " index_image.append(i[bin_index])\n", - " except:\n", - " index_image.append(0) #If we can't, we only save a 0\n", - " \n", - " #We save the new imagen values in the train_recuce list\n", - " train_reduce.append(np.array(index_image))" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 3.25402569, -0.87167382, 2.74528436, 0.39132926, -1.3705645 ,\n", - " 0.34323234, 2.93714471, 0.80357588, 1.32506271, 0.17947663])" - ] - }, - "execution_count": 143, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "params_minimized" - ] - }, - { - "cell_type": "code", - "execution_count": 150, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'110111': 0.03125,\n", - " '001001': 0.04419417382415922,\n", - " '101101': 0.04419417382415922,\n", - " '110010': 0.03125,\n", - " '101111': 0.04419417382415922,\n", - " '110000': 0.06987712429686843,\n", - " '101110': 0.03125,\n", - " '001010': 0.04419417382415922,\n", - " '011010': 0.04419417382415922,\n", - " '100100': 0.0625,\n", - " '001110': 0.04419417382415922,\n", - " '100011': 0.04419417382415922,\n", - " '110100': 0.06987712429686843,\n", - " '000010': 0.04419417382415922,\n", - " '010110': 0.09375,\n", - " '000011': 0.04419417382415922,\n", - " '100000': 0.05412658773652741,\n", - " '101100': 0.04419417382415922,\n", - " '101010': 0.04419417382415922,\n", - " '001111': 0.08838834764831845,\n", - " '000001': 0.08838834764831845,\n", - " '010101': 0.14657549249448218,\n", - " '010010': 0.05412658773652741,\n", - " '100010': 0.07654655446197431,\n", - " '001101': 0.11692679333668567,\n", - " '010000': 0.1926379375927805,\n", - " '111001': 0.10825317547305482,\n", - " '110001': 0.30136408628102984,\n", - " '001011': 0.08267972847076846,\n", - " '110011': 0.08838834764831845,\n", - " '101001': 0.06987712429686843,\n", - " '011101': 0.08267972847076846,\n", - " '101011': 0.04419417382415922,\n", - " '000101': 0.10364452469860624,\n", - " '111110': 0.03125,\n", - " '010001': 0.7241643891410292,\n", - " '010011': 0.2209708691207961,\n", - " '000111': 0.09882117688026186,\n", - " '100111': 0.03125,\n", - " '011011': 0.03125,\n", - " '011111': 0.05412658773652741,\n", - " '011000': 0.05412658773652741,\n", - " '000100': 0.1288470508005519,\n", - " '011001': 0.18221724671391565,\n", - " '000000': 0.0625,\n", - " '011100': 0.05412658773652741,\n", - " '111100': 0.08267972847076846,\n", - " '111011': 0.0625,\n", - " '010111': 0.08267972847076846,\n", - " '010100': 0.16535945694153692,\n", - " '001000': 0.0625,\n", - " '111101': 0.10364452469860624,\n", - " '001100': 0.04419417382415922,\n", - " '111010': 0.04419417382415922}" - ] - }, - "execution_count": 150, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reduce_img[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 161, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def plot_images(x, size=28, i=0):\n", - " plt.figure()\n", - "\n", - " #subplot(r,c) provide the no. of rows and columns\n", - " f, axarr = plt.subplots(5,1) \n", - " \n", - " # use the created array to output your multiple images. In this case I have stacked 4 images vertically\n", - " axarr[0].imshow(x[i+0].reshape(size,size)*255)\n", - " axarr[1].imshow(x[i+1].reshape(size,size)*255)\n", - " axarr[2].imshow(x[i+2].reshape(size,size)*255)\n", - " axarr[3].imshow(x[i+3].reshape(size,size)*255)\n", - " axarr[4].imshow(x[i+4].reshape(size,size)*255)\n", - " \n", - "plot_images(x_train, size=28, i=1500)" - ] - }, - { - "cell_type": "code", - "execution_count": 170, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(36,)" - ] - }, - "execution_count": 170, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "train_reduce[0].shape" - ] - }, - { - "cell_type": "code", - "execution_count": 169, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.09882118, 0.13621559, 0. , 0.07654655, 0.12884705,\n", - " 0.0625 , 0.03125 , 0.06987712, 0.06987712, 0. ,\n", - " 0.03125 , 0.0625 , 0. , 0.10364452, 0. ,\n", - " 0.05412659, 0.1711633 , 0.72348981, 0.08838835, 0.23799291,\n", - " 0.14657549, 0.125 , 0.11692679, 0.0625 , 0.03125 ,\n", - " 0.20963137, 0.04419417, 0.03125 , 0.03125 , 0.08267973,\n", - " 0.03125 , 0.06987712, 0.05412659, 0. , 0.06987712,\n", - " 0.03125 ])" - ] - }, - "execution_count": 169, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "train_reduce[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 167, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_images(train_reduce, size=6, i=25)" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "36" - ] - }, - "execution_count": 141, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#Function to decode the training set values compressed\n", - "'''\n", - "Input: An array of parameters(vector of complex amplitudes)\n", - "Output: Array with decode values\n", - "'''\n", - "def decoder_result_train(params):\n", - " reduce = [] #List to save the decoded values\n", - " #For each row in the test set reduced we will\n", - " for i in range(len(train_reduce)):\n", - " #Create a initial circuit with 6 qubits and a list of 48 zeros and the i row of the test reduced values\n", - " circuit_init = input_data(n,np.concatenate((np.zeros(48), train_reduce[i]), axis=0))\n", - " #Create the inverse VQC \n", - " circuit_vqc = vqc(n,num_layers,params).inverse()\n", - "\n", - " #Create a new circuit to combine the inicial circuit and the VQC\n", - " circuit_full = QuantumCircuit(n,n)\n", - " \n", - " #Combine the initial circuit, the quantum variatinal circuit\n", - " circuit_full = circuit_full.compose(circuit_init,[i for i in range(n)])\n", - " circuit_full = circuit_full.compose(circuit_vqc,[i for i in range(n)])\n", - " #We will execute the full circuit in the qasm simulator\n", - " job = execute( circuit_full, Aer.get_backend('statevector_simulator') )\n", - " result = job.result().get_statevector() #Get the results of the execution\n", - " reduce.append(result) #Save the results\n", - " return reduce\n", - " \n", - "#Call the decoder_result_train function \n", - "decoder_train =decoder_result_train(params)" - ] - }, - { - "cell_type": "code", - "execution_count": 124, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
     »\n",
-       "q_0: »\n",
-       "     »\n",
-       "q_1: »\n",
-       "     »\n",
-       "q_2: »\n",
-       "     »\n",
-       "q_3: »\n",
-       "     »\n",
-       "q_4: »\n",
-       "     »\n",
-       "q_5: »\n",
-       "     »\n",
-       "q_6: »\n",
-       "     »\n",
-       "q_7: »\n",
-       "     »\n",
-       "c: 1/»\n",
-       "     »\n",
-       "«     ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐»\n",
-       "«q_0: ┤0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
-       "«q_1: ┤1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
-       "«q_2: ┤2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
-       "«q_3: ┤3                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │  Initialize(0.19933,0.78458,0.060899,-0.027745,0.11977,0.082523,0.12581,-0.14133,-0.016088,0.026866,-0.019481,-0.14062,0.0078529,-0.0083738,-0.0076929,-0.02553,-0.048177,-0.012015,0.0028569,-0.043265,-0.096038,-0.0070439,-0.10802,-0.12586,0.063355,-0.020224,-0.044352,0.053306,0.017528,-0.087435,-0.03596,0.085269,0.085289,-0.014925,0.095256,-0.019094,-0.0079092,0.022646,0.060792,-0.0097256,-0.017249,-0.057585,-0.0042668,0.039688,-0.0071199,0.028444,-0.037858,0.041783,-0.013583,0.013934,0.0077143,0.07646,0.031435,0.043461,-0.0016037,0.10471,-0.016493,-0.049929,-0.016514,-0.024419,-0.020249,-0.022882,-0.001635,-0.039676,-0.094962,0.055315,-0.012034,-0.0043611,0.064414,0.0051576,0.0092164,-0.025113,0.022099,-0.06501,-0.0094487,-0.023682,-0.049237,0.017527,-0.010831,0.0068719,0.013686,-0.046753,-0.01355,0.018597,-0.080883,0.033222,0.059485,0.070075,-0.052423,0.034505,0.00088157,-0.033224,0.0085052,0.0048633,0.012664,-0.029608,0.02963,-0.0083869,0.044219,-0.022338,0.008193,0.016718,-0.040688,0.0020877,0.016231,-0.0040373,0.085946,-0.00055113,-0.03307,0.0084604,-0.019586,-0.022871,-0.051835,-0.033727,0.020317,-0.030812,-0.008016,-0.014824,0.054878,-0.024544,-0.014974,0.048952,0.018366,0.027505,-0.0087697,0.029066,-0.021802,-0.019985,-0.024976,-0.01525,-0.026949,-0.012689,-0.011489,0.0043565,0.0093918,0.008106,-0.002721,-0.062332,0.0040207,-0.031922,0.0070477,-0.046791,-0.024917,0.031065,0.0043196,0.020311,0.0023385,0.041404,0.0036015,0.02561,-0.023687,0.0024591,-0.0040734,-0.0092194,0.0012252,0.0014434,-0.029637,0.0064809,-0.025973,-0.019026,-0.0021421,0.0038971,0.033392,0.0086663,0.034408,0.0033675,0.024363,-0.0061191,-0.0022511,0.00039314,0.038701,-0.015828,-0.005892,-0.031952,-0.012703,-0.032764,0.0082279,-0.0189,0.0032144,0.022357,0.0016688,0.010722,0.021873,0.022183,-0.03733,0.02195,-0.015607,-0.018195,-0.021413,0.014492,0.016177,-0.019251,0.048351,0.0011298,0.008538,0.0076566,-0.032159,-0.0496,-0.02278,0.0097229,0.033377,-0.0044157,-0.00093023,0.00056362,-0.007001,0.019911,-0.040736,-0.046184,-0.0099688,-0.0014499,-0.015302,0.018341,-0.025148,0.0098564,-0.0086303,-0.032014,0.01639,0.014977,-0.013512,0.0051044,-0.0091627,0.025143,0.0069158,-0.0031569,0.0052421,-0.030917,-0.025982,-0.0049395,-0.0096566,0.016997,0.015062,0.0022722,-0.031119,0.0038691,0.03321,0.010916,0.014046,-0.016742,-0.01859,-0.033715,-0.021029,0.0057678,-0.003423,0.042017,-0.019512,-0.0024657,0.033014,-0.0012892,0.032856,-0.0064646,0.01211,0.0053955,-0.0024682,-0.0052844,0.011111,0.02473) │»\n",
-       "«q_4: ┤4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
-       "«q_5: ┤5                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
-       "«q_6: ┤6                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     │                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     │»\n",
-       "«q_7: ┤7                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ├»\n",
-       "«     └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘»\n",
-       "«c: 1/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════»\n",
-       "«                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            »\n",
-       "«      ░ \n",
-       "«q_0: ─░─\n",
-       "«      ░ \n",
-       "«q_1: ─░─\n",
-       "«      ░ \n",
-       "«q_2: ─░─\n",
-       "«      ░ \n",
-       "«q_3: ─░─\n",
-       "«      ░ \n",
-       "«q_4: ─░─\n",
-       "«      ░ \n",
-       "«q_5: ─░─\n",
-       "«      ░ \n",
-       "«q_6: ─░─\n",
-       "«      ░ \n",
-       "«q_7: ─░─\n",
-       "«      ░ \n",
-       "«c: 1/═══\n",
-       "«
" - ], - "text/plain": [ - " »\n", - "q_0: »\n", - " »\n", - "q_1: »\n", - " »\n", - "q_2: »\n", - " »\n", - "q_3: »\n", - " »\n", - "q_4: »\n", - " »\n", - "q_5: »\n", - " »\n", - "q_6: »\n", - " »\n", - "q_7: »\n", - " »\n", - "c: 1/»\n", - " »\n", - "« ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐»\n", - "«q_0: ┤0 ├»\n", - "« │ │»\n", - "«q_1: ┤1 ├»\n", - "« │ │»\n", - "«q_2: ┤2 ├»\n", - "« │ │»\n", - "«q_3: ┤3 ├»\n", - "« │ Initialize(0.19933,0.78458,0.060899,-0.027745,0.11977,0.082523,0.12581,-0.14133,-0.016088,0.026866,-0.019481,-0.14062,0.0078529,-0.0083738,-0.0076929,-0.02553,-0.048177,-0.012015,0.0028569,-0.043265,-0.096038,-0.0070439,-0.10802,-0.12586,0.063355,-0.020224,-0.044352,0.053306,0.017528,-0.087435,-0.03596,0.085269,0.085289,-0.014925,0.095256,-0.019094,-0.0079092,0.022646,0.060792,-0.0097256,-0.017249,-0.057585,-0.0042668,0.039688,-0.0071199,0.028444,-0.037858,0.041783,-0.013583,0.013934,0.0077143,0.07646,0.031435,0.043461,-0.0016037,0.10471,-0.016493,-0.049929,-0.016514,-0.024419,-0.020249,-0.022882,-0.001635,-0.039676,-0.094962,0.055315,-0.012034,-0.0043611,0.064414,0.0051576,0.0092164,-0.025113,0.022099,-0.06501,-0.0094487,-0.023682,-0.049237,0.017527,-0.010831,0.0068719,0.013686,-0.046753,-0.01355,0.018597,-0.080883,0.033222,0.059485,0.070075,-0.052423,0.034505,0.00088157,-0.033224,0.0085052,0.0048633,0.012664,-0.029608,0.02963,-0.0083869,0.044219,-0.022338,0.008193,0.016718,-0.040688,0.0020877,0.016231,-0.0040373,0.085946,-0.00055113,-0.03307,0.0084604,-0.019586,-0.022871,-0.051835,-0.033727,0.020317,-0.030812,-0.008016,-0.014824,0.054878,-0.024544,-0.014974,0.048952,0.018366,0.027505,-0.0087697,0.029066,-0.021802,-0.019985,-0.024976,-0.01525,-0.026949,-0.012689,-0.011489,0.0043565,0.0093918,0.008106,-0.002721,-0.062332,0.0040207,-0.031922,0.0070477,-0.046791,-0.024917,0.031065,0.0043196,0.020311,0.0023385,0.041404,0.0036015,0.02561,-0.023687,0.0024591,-0.0040734,-0.0092194,0.0012252,0.0014434,-0.029637,0.0064809,-0.025973,-0.019026,-0.0021421,0.0038971,0.033392,0.0086663,0.034408,0.0033675,0.024363,-0.0061191,-0.0022511,0.00039314,0.038701,-0.015828,-0.005892,-0.031952,-0.012703,-0.032764,0.0082279,-0.0189,0.0032144,0.022357,0.0016688,0.010722,0.021873,0.022183,-0.03733,0.02195,-0.015607,-0.018195,-0.021413,0.014492,0.016177,-0.019251,0.048351,0.0011298,0.008538,0.0076566,-0.032159,-0.0496,-0.02278,0.0097229,0.033377,-0.0044157,-0.00093023,0.00056362,-0.007001,0.019911,-0.040736,-0.046184,-0.0099688,-0.0014499,-0.015302,0.018341,-0.025148,0.0098564,-0.0086303,-0.032014,0.01639,0.014977,-0.013512,0.0051044,-0.0091627,0.025143,0.0069158,-0.0031569,0.0052421,-0.030917,-0.025982,-0.0049395,-0.0096566,0.016997,0.015062,0.0022722,-0.031119,0.0038691,0.03321,0.010916,0.014046,-0.016742,-0.01859,-0.033715,-0.021029,0.0057678,-0.003423,0.042017,-0.019512,-0.0024657,0.033014,-0.0012892,0.032856,-0.0064646,0.01211,0.0053955,-0.0024682,-0.0052844,0.011111,0.02473) │»\n", - "«q_4: ┤4 ├»\n", - "« │ │»\n", - "«q_5: ┤5 ├»\n", - "« │ │»\n", - "«q_6: ┤6 ├»\n", - "« │ │»\n", - "«q_7: ┤7 ├»\n", - "« └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘»\n", - "«c: 1/═══════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════»\n", - "« »\n", - "« ░ \n", - "«q_0: ─░─\n", - "« ░ \n", - "«q_1: ─░─\n", - "« ░ \n", - "«q_2: ─░─\n", - "« ░ \n", - "«q_3: ─░─\n", - "« ░ \n", - "«q_4: ─░─\n", - "« ░ \n", - "«q_5: ─░─\n", - "« ░ \n", - "«q_6: ─░─\n", - "« ░ \n", - "«q_7: ─░─\n", - "« ░ \n", - "«c: 1/═══\n", - "« " - ] - }, - "execution_count": 124, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "circuit_init.draw()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#your submission\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "\n", - "def run_part2(image):\n", - "\n", - " #loade the quantum classifier circuit\n", - " classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n", - " \n", - " #encode image into circuit\n", - " circuit=encode(image)\n", - " \n", - " #append with classifier circuit\n", - " nq1 = circuit.width()\n", - " nq2 = classifier.width()\n", - " nq = max(nq1, nq2)\n", - " qc = qiskit.QuantumCircuit(nq)\n", - " qc.append(circuit.to_instruction(), list(range(nq1)))\n", - " qc.append(classifier.to_instruction(), list(range(nq2)))\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(qc)\n", - " \n", - " #convert histogram to category\n", - " label=histogram_to_category(histogram)\n", - " \n", - " return circuit,label\n", - "#score" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "score=0\n", - "gatecount=0\n", - "n=len(dataset)\n", - "\n", - "for data in dataset:\n", - " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #check label\n", - " if label==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 [Default]", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.10" - }, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/part2_with_pca.ipynb b/part2_with_pca.ipynb deleted file mode 100644 index 0ce6972..0000000 --- a/part2_with_pca.ipynb +++ /dev/null @@ -1,5914 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8 # assert sum to 1.0\n", - " positive=0\n", - " # 0 - suma \n", - " # 1 - no suma\n", - " # 10 suma\n", - " # 11 no suma\n", - " # 100 suma\n", - " # 101 no suma\n", - " # suma la probabilidad de todos los bitstrings pares,\n", - " # en otras palabras, la probabilidad de que el qubit 0 sea 0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(3,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#your submission\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "\n", - "def run_part2(image):\n", - "\n", - " #loade the quantum classifier circuit\n", - " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", - " \n", - " #encode image into circuit\n", - " circuit=encode(image)\n", - " \n", - " #append with classifier circuit\n", - " nq1 = circuit.width()\n", - " nq2 = classifier.width()\n", - " nq = max(nq1, nq2)\n", - " qc = qiskit.QuantumCircuit(nq)\n", - " qc.append(circuit.to_instruction(), list(range(nq1)))\n", - " qc.append(classifier.to_instruction(), list(range(nq2)))\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(qc)\n", - " \n", - " #convert histogram to category\n", - " label=histogram_to_category(histogram)\n", - " \n", - " return circuit,label\n", - "#score" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "score=0\n", - "gatecount=0\n", - "n=len(dataset)\n", - "\n", - "for data in dataset:\n", - " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #check label\n", - " if label==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit import QuantumCircuit\n", - "from sklearn.decomposition import PCA\n", - "\n", - "#your submission\n", - "\n", - "N_QUBITS_AMPLITUDE_ENCODING = 8\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode_amplitude(image, debug=False):\n", - " # We have 28x28 images as input\n", - " # - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\n", - " # 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \n", - " # into n_qubits (parametrized)\n", - " \n", - " min_ = image.min()\n", - "\n", - " image_pca = image - min_\n", - " \n", - " # [normalize]\n", - " def normalize(row):\n", - " #We calculate the squareroot of the sum of the square values of the row\n", - " normalization_factor = np.sqrt(np.sum(row**2)) \n", - " if normalization_factor == 0.:\n", - " #If the sum is zero we return a 0\n", - " return 0.0\n", - " #Else we divide each value between the sum value above\n", - " row = row / normalization_factor\n", - " return row, normalization_factor\n", - " \n", - " image_pca_normalized, normalization_factor = normalize(image_pca)\n", - " \n", - " desired_state = image_pca_normalized\n", - " \n", - " ##########\n", - " # Amplitude Encoding\n", - " qc = QuantumCircuit(N_QUBITS_AMPLITUDE_ENCODING)\n", - " qc.initialize(desired_state)\n", - " qc_decomposed = qc.decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose().decompose()\n", - "\n", - " ##########\n", - " \n", - " decoder_params = dict(\n", - " min_=min_,\n", - " normalization_factor=normalization_factor,\n", - " n_qubits=n_qubits,\n", - " image=image\n", - " )\n", - " \n", - " return qc_decomposed, decoder_params\n", - "\n", - "def run_part2(image):\n", - "\n", - " #loade the quantum classifier circuit\n", - " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", - " \n", - " #encode image into circuit\n", - " circuit, _ = encode_amplitude(image)\n", - " \n", - " #append with classifier circuit\n", - " nq1 = circuit.width()\n", - " nq2 = classifier.width()\n", - " nq = max(nq1, nq2)\n", - " qc = qiskit.QuantumCircuit(nq)\n", - " qc.append(circuit.to_instruction(), list(range(nq1)))\n", - " qc.append(classifier.to_instruction(), list(range(nq2)))\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(qc)\n", - " \n", - " #convert histogram to category\n", - " \n", - " label=histogram_to_category(histogram)\n", - " # for final prediction we need apply a clasif. threshold\n", - " \n", - " return circuit,label\n", - "#score" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "encode_amplitude" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'list' object has no attribute 'min'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[15], line 9\u001b[0m\n\u001b[1;32m 5\u001b[0m n\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mlen\u001b[39m(dataset)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m data \u001b[38;5;129;01min\u001b[39;00m dataset:\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m#run part 2\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m circuit,label\u001b[38;5;241m=\u001b[39m\u001b[43mrun_part2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mimage\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m#count the gate used in the circuit for score calculation\u001b[39;00m\n\u001b[1;32m 12\u001b[0m gatecount\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39mcount_gates(circuit)[\u001b[38;5;241m2\u001b[39m]\n", - "Cell \u001b[0;32mIn[13], line 57\u001b[0m, in \u001b[0;36mrun_part2\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 54\u001b[0m classifier\u001b[38;5;241m=\u001b[39mqiskit\u001b[38;5;241m.\u001b[39mQuantumCircuit\u001b[38;5;241m.\u001b[39mfrom_qasm_file(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mquantum_classifier.qasm\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 56\u001b[0m \u001b[38;5;66;03m#encode image into circuit\u001b[39;00m\n\u001b[0;32m---> 57\u001b[0m circuit, _ \u001b[38;5;241m=\u001b[39m \u001b[43mencode_amplitude\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;66;03m#append with classifier circuit\u001b[39;00m\n\u001b[1;32m 60\u001b[0m nq1 \u001b[38;5;241m=\u001b[39m circuit\u001b[38;5;241m.\u001b[39mwidth()\n", - "Cell \u001b[0;32mIn[13], line 15\u001b[0m, in \u001b[0;36mencode_amplitude\u001b[0;34m(image, debug)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mencode_amplitude\u001b[39m(image, debug\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[1;32m 10\u001b[0m \u001b[38;5;66;03m# We have 28x28 images as input\u001b[39;00m\n\u001b[1;32m 11\u001b[0m \u001b[38;5;66;03m# - we can do amplitude encoding of a normalized amplitude vector that has size of 2 ** n (full power of two)\u001b[39;00m\n\u001b[1;32m 12\u001b[0m \u001b[38;5;66;03m# 28 x 28 = 784 doesn't fit into a full power of two, so we use PCA to reduce the dimensionality to fit it \u001b[39;00m\n\u001b[1;32m 13\u001b[0m \u001b[38;5;66;03m# into n_qubits (parametrized)\u001b[39;00m\n\u001b[0;32m---> 15\u001b[0m min_ \u001b[38;5;241m=\u001b[39m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmin\u001b[49m()\n\u001b[1;32m 17\u001b[0m image_pca \u001b[38;5;241m=\u001b[39m image \u001b[38;5;241m-\u001b[39m min_\n\u001b[1;32m 19\u001b[0m \u001b[38;5;66;03m# [normalize]\u001b[39;00m\n", - "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'min'" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "score=0\n", - "gatecount=0\n", - "n=len(dataset)\n", - "\n", - "for data in dataset:\n", - " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #check label\n", - " if label==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit import QuantumCircuit\n", - "qc = QuantumCircuit(1)\n", - "#qc.x(0)\n", - "\n", - "a = qc.qasm(filename=\"quantum_classifier.qasm\")" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " data\t\t\t\t part1_example_qiskit.ipynb\n", - " data1.json\t\t\t part1.py\n", - " data2.json\t\t\t part2_example_cirq.ipynb\n", - " examples.ipynb\t\t\t part2_example_qiskit-Copy1.ipynb\n", - " examples_qiskit.ipynb\t\t part2_example_qiskit.ipynb\n", - "'MIT iQuHACK remote challenge .docx' part2.pickle\n", - " MIT_iQuHACK_remote_challenge.pdf part2.qasm\n", - " mock_data\t\t\t __pycache__\n", - " mock_data_creator.ipynb\t quantum_classifier.qasm\n", - " part1_example_cirq.ipynb\t README.md\n", - " part1_example_qiskit-Copy1.ipynb\n" - ] - } - ], - "source": [ - "!ls" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# versioned classifer" - ] - }, - { - "cell_type": "code", - "execution_count": 122, - "metadata": {}, - "outputs": [], - "source": [ - "classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
   \n",
-       "q: \n",
-       "
" - ], - "text/plain": [ - " \n", - "q: \n", - " " - ] - }, - "execution_count": 123, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "classifier.draw()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:24, 3.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22439816871034923 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:20, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21170995251224078 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:17, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20662628224997392 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25445433121633726 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:10, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20667354912605257 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1897896296762502 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:03, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2057015746555031 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<00:59, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20449671568497396 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:56, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24551086370310526 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:52, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2074080983684203 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:38<00:49, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21582851207990894 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:45, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22654322634275184 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:45<00:42, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18209408638661978 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:38, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20240314267513765 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:52<00:35, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22936205445425328 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:31, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2699754101286921 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [00:59<00:28, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21295420601122067 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:03<00:24, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25320741377365946 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:06<00:21, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25027978164215253 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:10<00:17, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21812988323654317 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:13<00:14, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21376971638099182 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:17<00:10, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21527802698413995 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21257775126821837 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:24<00:03, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2108350723040899 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.53s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2175567325846446 False\n", - "(2000,)\n", - "25\n", - "[0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 1 0 1 0 0] [0.22439816871034923, 0.21170995251224078, 0.20662628224997392, 0.25445433121633726, 0.20667354912605257, 0.1897896296762502, 0.2057015746555031, 0.20449671568497396, 0.24551086370310526, 0.2074080983684203, 0.21582851207990894, 0.22654322634275184, 0.18209408638661978, 0.20240314267513765, 0.22936205445425328, 0.2699754101286921, 0.21295420601122067, 0.25320741377365946, 0.25027978164215253, 0.21812988323654317, 0.21376971638099182, 0.21527802698413995, 0.21257775126821837, 0.2108350723040899, 0.2175567325846446]\n", - "Loss\n", - "0.5745100031491128\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:23, 3.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.256399222775756 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2522511254583919 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:17, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22699886538358147 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27895830430144714 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:10, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27200285489720577 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2729102581282131 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:04, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2595648491949362 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.29628643240883934 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:57, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.29554996814920703 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26960990182632666 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:49, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27770201252810756 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3014902258350622 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:42, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2395650310981694 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:39, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23872871330654108 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.28355292140538935 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:31, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.28880802552904417 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.29439435327977337 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:03<00:24, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2884215729214027 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26214237472350965 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:10<00:17, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2535764189529114 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:14<00:14, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2922011621858887 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2300621753768395 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2985209362922094 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26980845445291735 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.55s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2229926576056259 False\n", - "(2000,)\n", - "25\n", - "[0 0 1 0 1 0 1 0 1 1 0 0 1 1 0 1 1 0 0 0 0 0 1 0 0] [0.256399222775756, 0.2522511254583919, 0.22699886538358147, 0.27895830430144714, 0.27200285489720577, 0.2729102581282131, 0.2595648491949362, 0.29628643240883934, 0.29554996814920703, 0.26960990182632666, 0.27770201252810756, 0.3014902258350622, 0.2395650310981694, 0.23872871330654108, 0.28355292140538935, 0.28880802552904417, 0.29439435327977337, 0.2884215729214027, 0.26214237472350965, 0.2535764189529114, 0.2922011621858887, 0.2300621753768395, 0.2985209362922094, 0.26980845445291735, 0.2229926576056259]\n", - "Loss\n", - "0.7164196534818487\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:24, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17181826212888904 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16375452807056995 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21299900819965478 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2278272620860801 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1888169279222505 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2482197101809898 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:03, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15542771450935472 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20114162179223788 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:57, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17532790267608767 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15710178726073862 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19105020575020518 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20259934003924285 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:42, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18765566460928884 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:39, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1868390840132907 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13791001881349174 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:31, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17835326918675837 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17357667472036098 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:03<00:24, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17734696981974893 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16400438270433337 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:10<00:17, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16547798793189464 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:14<00:14, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20236448913447921 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17004337263866906 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1759592510663209 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19861226650606195 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.55s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20867643215519466 True\n", - "(2000,)\n", - "25\n", - "[0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 0 1 0 0 0 1 1 0 1] [0.17181826212888904, 0.16375452807056995, 0.21299900819965478, 0.2278272620860801, 0.1888169279222505, 0.2482197101809898, 0.15542771450935472, 0.20114162179223788, 0.17532790267608767, 0.15710178726073862, 0.19105020575020518, 0.20259934003924285, 0.18765566460928884, 0.1868390840132907, 0.13791001881349174, 0.17835326918675837, 0.17357667472036098, 0.17734696981974893, 0.16400438270433337, 0.16547798793189464, 0.20236448913447921, 0.17004337263866906, 0.1759592510663209, 0.19861226650606195, 0.20867643215519466]\n", - "Loss\n", - "0.7230144877578292\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:25, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2849321652383916 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20286386878482496 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18633902093218147 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:15, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21053467487391994 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18639975433484018 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:08, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2502934372689309 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:25<01:04, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21012390184504182 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:01, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2284541316446929 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19507123612580993 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1811484501087359 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21189159271689423 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:43<00:46, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21149326487536751 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:43, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2190143224736442 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1915135358184522 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19504081439113843 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17308093631776605 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19591618595711896 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2039485232365668 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:08<00:21, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20780633132527676 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2152011273941204 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20830135308769465 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21717094696311115 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2037701141327782 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:26<00:03, 3.62s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23457062507336532 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.59s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1871634794348724 False\n", - "(2000,)\n", - "25\n", - "[0 0 1 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0] [0.2849321652383916, 0.20286386878482496, 0.18633902093218147, 0.21053467487391994, 0.18639975433484018, 0.2502934372689309, 0.21012390184504182, 0.2284541316446929, 0.19507123612580993, 0.1811484501087359, 0.21189159271689423, 0.21149326487536751, 0.2190143224736442, 0.1915135358184522, 0.19504081439113843, 0.17308093631776605, 0.19591618595711896, 0.2039485232365668, 0.20780633132527676, 0.2152011273941204, 0.20830135308769465, 0.21717094696311115, 0.2037701141327782, 0.23457062507336532, 0.1871634794348724]\n", - "Loss\n", - "0.5240604799152201\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:24, 3.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16283109679980393 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17946315734416562 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17902537717587483 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.177927062148211 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17831548679953227 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17890148831251332 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:04, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15666123233254392 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17031083698047703 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17693175281842033 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17322400363874468 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16535205548915363 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17397100045416 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:43, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1711366132497 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1629396067087388 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18534608849343184 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18196742487737852 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17560770823374847 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1800520829574006 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:08<00:21, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2292491724142283 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17924235043058903 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15916901609947576 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23686523193568162 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17340951170801105 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17351662940742563 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17709241668022432 False\n", - "(2000,)\n", - "25\n", - "[1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0] [0.16283109679980393, 0.17946315734416562, 0.17902537717587483, 0.177927062148211, 0.17831548679953227, 0.17890148831251332, 0.15666123233254392, 0.17031083698047703, 0.17693175281842033, 0.17322400363874468, 0.16535205548915363, 0.17397100045416, 0.1711366132497, 0.1629396067087388, 0.18534608849343184, 0.18196742487737852, 0.17560770823374847, 0.1800520829574006, 0.2292491724142283, 0.17924235043058903, 0.15916901609947576, 0.23686523193568162, 0.17340951170801105, 0.17351662940742563, 0.17709241668022432]\n", - "Loss\n", - "0.44762737596139124\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:24, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19027154262146928 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20962204236631773 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.28177562288287994 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19151212284865304 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24613075884950736 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19238845205677335 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:03, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26809120605832 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20421675819551724 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:56, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20163202738124741 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24085412614856774 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:49, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1999475968263486 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20513585840580348 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:42, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19699425811936974 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:39, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20589457314655998 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21153540176323005 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:32, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2288623745047924 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18659184646813276 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1962874183407712 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21957569744189961 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19090653969907714 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:14<00:14, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24027825324295135 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21908296241595637 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19697209914420513 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1974207146416112 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.56s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21221518631677777 False\n", - "(2000,)\n", - "25\n", - "[0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0] [0.19027154262146928, 0.20962204236631773, 0.28177562288287994, 0.19151212284865304, 0.24613075884950736, 0.19238845205677335, 0.26809120605832, 0.20421675819551724, 0.20163202738124741, 0.24085412614856774, 0.1999475968263486, 0.20513585840580348, 0.19699425811936974, 0.20589457314655998, 0.21153540176323005, 0.2288623745047924, 0.18659184646813276, 0.1962874183407712, 0.21957569744189961, 0.19090653969907714, 0.24027825324295135, 0.21908296241595637, 0.19697209914420513, 0.1974207146416112, 0.21221518631677777]\n", - "Loss\n", - "0.4102339432755233\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:25, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13976598316592387 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14929889397682605 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1565241388058825 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14138269381462773 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1525756303547523 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15437448321103872 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:03, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13952785230938694 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1854102629494309 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:56, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15351414146270678 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1558319525933675 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:38<00:49, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15394353253559934 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15490947487241205 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:45<00:42, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15287928803693554 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:38, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13171560682056738 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.14866853215945944 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:31, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.13866207317245263 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1480428283692804 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:03<00:24, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19427327391578808 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19195532735089207 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:10<00:17, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15151222827976818 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:14<00:14, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17434082568245562 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:17<00:10, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1837219423649988 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16252735909388816 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:24<00:03, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16847295055273948 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.53s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1439717988649608 False\n", - "(2000,)\n", - "25\n", - "[1 0 0 1 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0] [0.13976598316592387, 0.14929889397682605, 0.1565241388058825, 0.14138269381462773, 0.1525756303547523, 0.15437448321103872, 0.13952785230938694, 0.1854102629494309, 0.15351414146270678, 0.1558319525933675, 0.15394353253559934, 0.15490947487241205, 0.15287928803693554, 0.13171560682056738, 0.14866853215945944, 0.13866207317245263, 0.1480428283692804, 0.19427327391578808, 0.19195532735089207, 0.15151222827976818, 0.17434082568245562, 0.1837219423649988, 0.16252735909388816, 0.16847295055273948, 0.1439717988649608]\n", - "Loss\n", - "0.6010824073288937\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:23, 3.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2290374845241696 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:20, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21279402705498196 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:17, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21944909761014547 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:13<01:13, 3.49s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22202924244267103 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:10, 3.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21639627757978738 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22388938293996102 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:03, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2235139867948017 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22304806251945988 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:57, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21753107614249736 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2211916872828005 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:38<00:49, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21853827953787885 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:45, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2150683397057167 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:45<00:42, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22531481141953646 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:39, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22193533160155027 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23527369179072966 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:32, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21703384817356056 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22310085102044613 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:03<00:24, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21924366255549568 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2422156191724952 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:10<00:17, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22333041943239412 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:14<00:14, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2235655911269626 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2407504381991235 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2092441949942492 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2351955348801181 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.55s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21699603182000732 False\n", - "(2000,)\n", - "25\n", - "[0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 0] [0.2290374845241696, 0.21279402705498196, 0.21944909761014547, 0.22202924244267103, 0.21639627757978738, 0.22388938293996102, 0.2235139867948017, 0.22304806251945988, 0.21753107614249736, 0.2211916872828005, 0.21853827953787885, 0.2150683397057167, 0.22531481141953646, 0.22193533160155027, 0.23527369179072966, 0.21703384817356056, 0.22310085102044613, 0.21924366255549568, 0.2422156191724952, 0.22333041943239412, 0.2235655911269626, 0.2407504381991235, 0.2092441949942492, 0.2351955348801181, 0.21699603182000732]\n", - "Loss\n", - "0.5017928449607514\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:24, 3.50s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1669627981584769 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16135777113880967 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1608723884276439 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16541653885351726 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17799513345024612 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:06, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17278695935783053 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:03, 3.53s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17574953364100315 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1600886852678649 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:31<00:56, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.15802741117911595 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17286932168773506 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20233628996861266 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16474206298388455 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:42, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.167651185371576 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:39, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16633076716123038 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1602628789333549 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:56<00:32, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1851564387385181 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19287988734206502 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:24, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16429284543018066 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16906877672058565 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18603039154373505 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:14<00:14, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1682647706554944 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2758763904739883 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:21<00:07, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18467633058537877 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1616071010625062 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:28<00:00, 3.56s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21630896490387616 False\n", - "(2000,)\n", - "25\n", - "[0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 0 1 1 0] [0.1669627981584769, 0.16135777113880967, 0.1608723884276439, 0.16541653885351726, 0.17799513345024612, 0.17278695935783053, 0.17574953364100315, 0.1600886852678649, 0.15802741117911595, 0.17286932168773506, 0.20233628996861266, 0.16474206298388455, 0.167651185371576, 0.16633076716123038, 0.1602628789333549, 0.1851564387385181, 0.19287988734206502, 0.16429284543018066, 0.16906877672058565, 0.18603039154373505, 0.1682647706554944, 0.2758763904739883, 0.18467633058537877, 0.1616071010625062, 0.21630896490387616]\n", - "Loss\n", - "0.5751547187323194\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:23, 3.48s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3065914597155552 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:20, 3.52s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3385033446212355 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:17, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3136335258664232 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3478088322322282 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3111426195443546 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.34219527232081387 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:04, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31006464319877014 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.32023282395212216 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3150387357021503 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31109419281387185 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3016909952465716 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2916070075499417 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:43, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3077913836860651 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:49<00:39, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31896798026679224 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.30003495303315864 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3389951592634215 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31825775754518576 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.4119127415225298 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:07<00:21, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.34397339053775255 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.30943064622322036 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.30687808920418336 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.30955035893907396 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.3110044710873081 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.307851803173844 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.57s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.31755594842314844 False\n", - "(2000,)\n", - "25\n", - "[0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 0 1 0 1 1 0 0] [0.3065914597155552, 0.3385033446212355, 0.3136335258664232, 0.3478088322322282, 0.3111426195443546, 0.34219527232081387, 0.31006464319877014, 0.32023282395212216, 0.3150387357021503, 0.31109419281387185, 0.3016909952465716, 0.2916070075499417, 0.3077913836860651, 0.31896798026679224, 0.30003495303315864, 0.3389951592634215, 0.31825775754518576, 0.4119127415225298, 0.34397339053775255, 0.30943064622322036, 0.30687808920418336, 0.30955035893907396, 0.3110044710873081, 0.307851803173844, 0.31755594842314844]\n", - "Loss\n", - "0.576007284320459\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:25, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22879642476096165 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22343476916208238 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21078758737690054 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:15, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2262680290164814 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27399780427379344 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21505507840492866 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:25<01:04, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19953843070899113 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2048080362757129 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21645950450632437 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21378271906551952 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25721092304530624 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:43<00:46, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2941010630624442 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:43, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22641181102452668 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20154368047200416 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2414624007498712 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22033721756045732 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:01<00:28, 3.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1977388959176667 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22338082957192276 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:08<00:21, 3.61s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20828153539528785 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:18, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24963797271348281 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.21534957889516365 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:19<00:10, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2698777115415653 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22121570148487193 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:26<00:03, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2782601344117515 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.59s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.29277509543021046 False\n", - "(2000,)\n", - "25\n", - "[0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0] [0.22879642476096165, 0.22343476916208238, 0.21078758737690054, 0.2262680290164814, 0.27399780427379344, 0.21505507840492866, 0.19953843070899113, 0.2048080362757129, 0.21645950450632437, 0.21378271906551952, 0.25721092304530624, 0.2941010630624442, 0.22641181102452668, 0.20154368047200416, 0.2414624007498712, 0.22033721756045732, 0.1977388959176667, 0.22338082957192276, 0.20828153539528785, 0.24963797271348281, 0.21534957889516365, 0.2698777115415653, 0.22121570148487193, 0.2782601344117515, 0.29277509543021046]\n", - "Loss\n", - "0.5364037669204643\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:24, 3.51s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2247906184732505 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:21, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2344956934107105 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2382635908623606 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:15, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2858845788778354 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24417656000078722 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:07, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23293600846648013 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:24<01:04, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2520125755038133 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:00, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2440278637660495 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22533837252887468 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23202892840887043 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2202759509546124 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23909577416525488 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:43, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2320268497296893 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23914645309069105 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2263393078800365 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23520777326578143 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23733945108303484 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23891928306475807 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:08<00:21, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2542695750446766 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22910511440752088 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23696975019728528 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22916612016786056 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22528578949711658 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.22935665661004093 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.23565582761214882 False\n", - "(2000,)\n", - "25\n", - "[1 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0] [0.2247906184732505, 0.2344956934107105, 0.2382635908623606, 0.2858845788778354, 0.24417656000078722, 0.23293600846648013, 0.2520125755038133, 0.2440278637660495, 0.22533837252887468, 0.23202892840887043, 0.2202759509546124, 0.23909577416525488, 0.2320268497296893, 0.23914645309069105, 0.2263393078800365, 0.23520777326578143, 0.23733945108303484, 0.23891928306475807, 0.2542695750446766, 0.22910511440752088, 0.23696975019728528, 0.22916612016786056, 0.22528578949711658, 0.22935665661004093, 0.23565582761214882]\n", - "Loss\n", - "0.6042893835670573\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:25, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2637363469413959 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:22, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2789895274610281 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2526705394466902 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25205469452098594 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.259064033202045 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:08, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2528640181989056 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:25<01:04, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25400492028073757 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:01, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2655239233401808 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2562749533170576 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2551470327797913 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.25562885572434846 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26930184743227864 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:43, 3.60s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2550102550835394 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:50<00:39, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24633418446876987 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.28915515135581704 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2553754093563006 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2515290044190871 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2559475468627948 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:08<00:21, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.27871002841931664 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.28146164992251427 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.330852744166781 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2708598655695078 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2647693350459092 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:26<00:03, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.24790440024030994 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2538188142799934 False\n", - "(2000,)\n", - "25\n", - "[0 0 0 0 1 0 1 0 0 0 0 0 1 1 0 1 0 1 0 0 0 1 0 1 0] [0.2637363469413959, 0.2789895274610281, 0.2526705394466902, 0.25205469452098594, 0.259064033202045, 0.2528640181989056, 0.25400492028073757, 0.2655239233401808, 0.2562749533170576, 0.2551470327797913, 0.25562885572434846, 0.26930184743227864, 0.2550102550835394, 0.24633418446876987, 0.28915515135581704, 0.2553754093563006, 0.2515290044190871, 0.2559475468627948, 0.27871002841931664, 0.28146164992251427, 0.330852744166781, 0.2708598655695078, 0.2647693350459092, 0.24790440024030994, 0.2538188142799934]\n", - "Loss\n", - "0.6488929366740943\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 4%|▍ | 1/25 [00:03<01:25, 3.55s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16905027713814144 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 8%|▊ | 2/25 [00:07<01:22, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17084679309771103 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 12%|█▏ | 3/25 [00:10<01:18, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17578660011127104 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 16%|█▌ | 4/25 [00:14<01:14, 3.54s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1690150359735411 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 20%|██ | 5/25 [00:17<01:11, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16774151596276152 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 24%|██▍ | 6/25 [00:21<01:08, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16335366064724455 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 28%|██▊ | 7/25 [00:25<01:04, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16192626506639896 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 32%|███▏ | 8/25 [00:28<01:01, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17666922874269395 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 36%|███▌ | 9/25 [00:32<00:57, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.19985647696604023 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 40%|████ | 10/25 [00:35<00:53, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20352440278629041 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 44%|████▍ | 11/25 [00:39<00:50, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17005482022574725 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 48%|████▊ | 12/25 [00:42<00:46, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16360587706632226 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 52%|█████▏ | 13/25 [00:46<00:42, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16621715212502536 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 56%|█████▌ | 14/25 [00:50<00:39, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.18987239657019428 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 60%|██████ | 15/25 [00:53<00:35, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.2010654508430945 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 64%|██████▍ | 16/25 [00:57<00:32, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1759016679061598 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 68%|██████▊ | 17/25 [01:00<00:28, 3.59s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.1656350060635573 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 72%|███████▏ | 18/25 [01:04<00:25, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20791571461620273 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 76%|███████▌ | 19/25 [01:08<00:21, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17182299826426808 True\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 80%|████████ | 20/25 [01:11<00:17, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.26089912858327524 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 84%|████████▍ | 21/25 [01:15<00:14, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.17048448855018555 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 88%|████████▊ | 22/25 [01:18<00:10, 3.56s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.162252615456351 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 92%|█████████▏| 23/25 [01:22<00:07, 3.57s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.16571227063349506 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 96%|█████████▌| 24/25 [01:25<00:03, 3.58s/it]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20604417553288668 False\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 25/25 [01:29<00:00, 3.58s/it]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pred label\n", - "0.20198441492007618 False\n", - "(2000,)\n", - "25\n", - "[0 0 0 0 0 1 1 0 0 1 1 1 1 1 0 0 0 0 1 0 0 0 0 0 0] [0.16905027713814144, 0.17084679309771103, 0.17578660011127104, 0.1690150359735411, 0.16774151596276152, 0.16335366064724455, 0.16192626506639896, 0.17666922874269395, 0.19985647696604023, 0.20352440278629041, 0.17005482022574725, 0.16360587706632226, 0.16621715212502536, 0.18987239657019428, 0.2010654508430945, 0.1759016679061598, 0.1656350060635573, 0.20791571461620273, 0.17182299826426808, 0.26089912858327524, 0.17048448855018555, 0.162252615456351, 0.16571227063349506, 0.20604417553288668, 0.20198441492007618]\n", - "Loss\n", - "0.7004560659948242\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/25 [00:00 247\u001b[0m \u001b[43mtest\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[2], line 127\u001b[0m, in \u001b[0;36mtest\u001b[0;34m()\u001b[0m\n\u001b[1;32m 123\u001b[0m gatecount\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 125\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m tqdm\u001b[38;5;241m.\u001b[39mtqdm(\u001b[38;5;28mrange\u001b[39m(n)):\n\u001b[1;32m 126\u001b[0m \u001b[38;5;66;03m#encode image into circuit\u001b[39;00m\n\u001b[0;32m--> 127\u001b[0m circuit,image_re\u001b[38;5;241m=\u001b[39m\u001b[43mrun_part1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdataset\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mimage_vector\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 128\u001b[0m image_re \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39masarray(image_re)\n\u001b[1;32m 130\u001b[0m \u001b[38;5;66;03m#count the number of 2qubit gates used\u001b[39;00m\n", - "Cell \u001b[0;32mIn[2], line 204\u001b[0m, in \u001b[0;36mrun_part1\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 202\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mrun_part1\u001b[39m(image):\n\u001b[1;32m 203\u001b[0m \u001b[38;5;66;03m#encode image into a circuit\u001b[39;00m\n\u001b[0;32m--> 204\u001b[0m circuit\u001b[38;5;241m=\u001b[39m\u001b[43mencode\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;66;03m#simulate circuit\u001b[39;00m\n\u001b[1;32m 207\u001b[0m histogram\u001b[38;5;241m=\u001b[39msimulate(circuit)\n", - "Cell \u001b[0;32mIn[2], line 180\u001b[0m, in \u001b[0;36mencode\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 177\u001b[0m qc\u001b[38;5;241m.\u001b[39minitialize(image)\n\u001b[1;32m 179\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(AMPLITUDE_ENCODING_N_QUBITS \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m2\u001b[39m):\n\u001b[0;32m--> 180\u001b[0m qc \u001b[38;5;241m=\u001b[39m \u001b[43mqc\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecompose\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 182\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m qc\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/quantumcircuit.py:1612\u001b[0m, in \u001b[0;36mQuantumCircuit.decompose\u001b[0;34m(self, gates_to_decompose, reps)\u001b[0m\n\u001b[1;32m 1610\u001b[0m pass_ \u001b[38;5;241m=\u001b[39m Decompose(gates_to_decompose)\n\u001b[1;32m 1611\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(reps):\n\u001b[0;32m-> 1612\u001b[0m dag \u001b[38;5;241m=\u001b[39m \u001b[43mpass_\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdag\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1613\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m dag_to_circuit(dag)\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/transpiler/passes/basis/decompose.py:90\u001b[0m, in \u001b[0;36mDecompose.run\u001b[0;34m(self, dag)\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m node \u001b[38;5;129;01min\u001b[39;00m dag\u001b[38;5;241m.\u001b[39mop_nodes():\n\u001b[1;32m 89\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_should_decompose(node):\n\u001b[0;32m---> 90\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28;43mgetattr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mnode\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdefinition\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 91\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 92\u001b[0m \u001b[38;5;66;03m# TODO: allow choosing among multiple decomposition rules\u001b[39;00m\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:239\u001b[0m, in \u001b[0;36mInstruction.definition\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Return definition in terms of other basic gates.\"\"\"\u001b[39;00m\n\u001b[1;32m 238\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 239\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_define\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 240\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:111\u001b[0m, in \u001b[0;36mStatePreparation._define\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefinition \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_define_from_int()\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 111\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdefinition \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_define_synthesis\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:171\u001b[0m, in \u001b[0;36mStatePreparation._define_synthesis\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Calculate a subcircuit that implements this initialization\u001b[39;00m\n\u001b[1;32m 162\u001b[0m \n\u001b[1;32m 163\u001b[0m \u001b[38;5;124;03mImplements a recursive initialization algorithm, including optimizations,\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 168\u001b[0m \u001b[38;5;124;03mdouble cnots.\u001b[39;00m\n\u001b[1;32m 169\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 170\u001b[0m \u001b[38;5;66;03m# call to generate the circuit that takes the desired vector to zero\u001b[39;00m\n\u001b[0;32m--> 171\u001b[0m disentangling_circuit \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_gates_to_uncompute\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;66;03m# invert the circuit to create the desired vector from zero (assuming\u001b[39;00m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# the qubits are in the zero state)\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_inverse \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m:\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:281\u001b[0m, in \u001b[0;36mStatePreparation._gates_to_uncompute\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 278\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(rz_mult\u001b[38;5;241m.\u001b[39mto_instruction(), q[i : \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_qubits])\n\u001b[1;32m 280\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39mlinalg\u001b[38;5;241m.\u001b[39mnorm(thetas) \u001b[38;5;241m!=\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m--> 281\u001b[0m ry_mult \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_multiplex\u001b[49m\u001b[43m(\u001b[49m\u001b[43mRYGate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mthetas\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlast_cnot\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43madd_last_cnot\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 282\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(ry_mult\u001b[38;5;241m.\u001b[39mto_instruction()\u001b[38;5;241m.\u001b[39mreverse_ops(), q[i : \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_qubits])\n\u001b[1;32m 283\u001b[0m circuit\u001b[38;5;241m.\u001b[39mglobal_phase \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mangle(\u001b[38;5;28msum\u001b[39m(remaining_param))\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:390\u001b[0m, in \u001b[0;36mStatePreparation._multiplex\u001b[0;34m(self, target_gate, list_of_angles, last_cnot)\u001b[0m\n\u001b[1;32m 387\u001b[0m list_of_angles \u001b[38;5;241m=\u001b[39m angle_weight\u001b[38;5;241m.\u001b[39mdot(np\u001b[38;5;241m.\u001b[39marray(list_of_angles))\u001b[38;5;241m.\u001b[39mtolist()\n\u001b[1;32m 389\u001b[0m \u001b[38;5;66;03m# recursive step on half the angles fulfilling the above assumption\u001b[39;00m\n\u001b[0;32m--> 390\u001b[0m multiplex_1 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_multiplex\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtarget_gate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mlist_of_angles\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mlist_len\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 391\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(multiplex_1\u001b[38;5;241m.\u001b[39mto_instruction(), q[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 393\u001b[0m \u001b[38;5;66;03m# attach CNOT as follows, thereby flipping the LSB qubit\u001b[39;00m\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/library/data_preparation/state_preparation.py:401\u001b[0m, in \u001b[0;36mStatePreparation._multiplex\u001b[0;34m(self, target_gate, list_of_angles, last_cnot)\u001b[0m\n\u001b[1;32m 399\u001b[0m multiplex_2 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_multiplex(target_gate, list_of_angles[(list_len \u001b[38;5;241m/\u001b[39m\u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m) :], \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 400\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m list_len \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 401\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(\u001b[43mmultiplex_2\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto_instruction\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreverse_ops\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m, q[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 402\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 403\u001b[0m circuit\u001b[38;5;241m.\u001b[39mappend(multiplex_2\u001b[38;5;241m.\u001b[39mto_instruction(), q[\u001b[38;5;241m0\u001b[39m:\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m])\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:345\u001b[0m, in \u001b[0;36mInstruction.reverse_ops\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 342\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition:\n\u001b[1;32m 343\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m--> 345\u001b[0m reverse_inst \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m_reverse\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 346\u001b[0m reversed_definition \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition\u001b[38;5;241m.\u001b[39mcopy_empty_like()\n\u001b[1;32m 347\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m inst \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mreversed\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition):\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:427\u001b[0m, in \u001b[0;36mInstruction.copy\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 415\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcopy\u001b[39m(\u001b[38;5;28mself\u001b[39m, name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 416\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 417\u001b[0m \u001b[38;5;124;03m Copy of the instruction.\u001b[39;00m\n\u001b[1;32m 418\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 425\u001b[0m \u001b[38;5;124;03m updated if it was provided\u001b[39;00m\n\u001b[1;32m 426\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 427\u001b[0m cpy \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__deepcopy__\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 429\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name:\n\u001b[1;32m 430\u001b[0m cpy\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m=\u001b[39m name\n", - "File \u001b[0;32m/opt/.qbraid/environments/qbraid_000000/pyenv/lib/python3.9/site-packages/qiskit/circuit/instruction.py:437\u001b[0m, in \u001b[0;36mInstruction.__deepcopy__\u001b[0;34m(self, _memo)\u001b[0m\n\u001b[1;32m 435\u001b[0m cpy\u001b[38;5;241m.\u001b[39m_params \u001b[38;5;241m=\u001b[39m copy\u001b[38;5;241m.\u001b[39mcopy(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_params)\n\u001b[1;32m 436\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_definition:\n\u001b[0;32m--> 437\u001b[0m cpy\u001b[38;5;241m.\u001b[39m_definition \u001b[38;5;241m=\u001b[39m \u001b[43mcopy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_definition\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_memo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 438\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m cpy\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:172\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m y \u001b[38;5;241m=\u001b[39m x\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43m_reconstruct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# If is its own copy, don't memoize.\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m x:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:270\u001b[0m, in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m deep:\n\u001b[0;32m--> 270\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(y, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__setstate__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 272\u001b[0m y\u001b[38;5;241m.\u001b[39m__setstate__(state)\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:230\u001b[0m, in \u001b[0;36m_deepcopy_dict\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 228\u001b[0m memo[\u001b[38;5;28mid\u001b[39m(x)] \u001b[38;5;241m=\u001b[39m y\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m x\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m--> 230\u001b[0m y[deepcopy(key, memo)] \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:205\u001b[0m, in \u001b[0;36m_deepcopy_list\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 203\u001b[0m append \u001b[38;5;241m=\u001b[39m y\u001b[38;5;241m.\u001b[39mappend\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x:\n\u001b[0;32m--> 205\u001b[0m append(\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:172\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m y \u001b[38;5;241m=\u001b[39m x\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43m_reconstruct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# If is its own copy, don't memoize.\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m x:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:270\u001b[0m, in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m deep:\n\u001b[0;32m--> 270\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(y, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__setstate__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 272\u001b[0m y\u001b[38;5;241m.\u001b[39m__setstate__(state)\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m_deepcopy_tuple\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [deepcopy(a, memo) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:230\u001b[0m, in \u001b[0;36m_deepcopy_dict\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 228\u001b[0m memo[\u001b[38;5;28mid\u001b[39m(x)] \u001b[38;5;241m=\u001b[39m y\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m x\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m--> 230\u001b[0m y[deepcopy(key, memo)] \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvalue\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m_deepcopy_tuple\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [deepcopy(a, memo) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:172\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m y \u001b[38;5;241m=\u001b[39m x\n\u001b[1;32m 171\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 172\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43m_reconstruct\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mrv\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 174\u001b[0m \u001b[38;5;66;03m# If is its own copy, don't memoize.\u001b[39;00m\n\u001b[1;32m 175\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m x:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:270\u001b[0m, in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 268\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m state \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 269\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m deep:\n\u001b[0;32m--> 270\u001b[0m state \u001b[38;5;241m=\u001b[39m \u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 271\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(y, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m__setstate__\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 272\u001b[0m y\u001b[38;5;241m.\u001b[39m__setstate__(state)\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m_deepcopy_tuple\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [deepcopy(a, memo) \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:210\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_tuple\u001b[39m(x, memo, deepcopy\u001b[38;5;241m=\u001b[39mdeepcopy):\n\u001b[0;32m--> 210\u001b[0m y \u001b[38;5;241m=\u001b[39m [\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m x]\n\u001b[1;32m 211\u001b[0m \u001b[38;5;66;03m# We're not going to put the tuple in the memo, but it's still important we\u001b[39;00m\n\u001b[1;32m 212\u001b[0m \u001b[38;5;66;03m# check for it, in case the tuple contains recursive mutable structures.\u001b[39;00m\n\u001b[1;32m 213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:230\u001b[0m, in \u001b[0;36m_deepcopy_dict\u001b[0;34m(x, memo, deepcopy)\u001b[0m\n\u001b[1;32m 228\u001b[0m memo[\u001b[38;5;28mid\u001b[39m(x)] \u001b[38;5;241m=\u001b[39m y\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, value \u001b[38;5;129;01min\u001b[39;00m x\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m--> 230\u001b[0m y[\u001b[43mdeepcopy\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m] \u001b[38;5;241m=\u001b[39m deepcopy(value, memo)\n\u001b[1;32m 231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:146\u001b[0m, in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 144\u001b[0m copier \u001b[38;5;241m=\u001b[39m _deepcopy_dispatch\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;28mcls\u001b[39m)\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m copier \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[43mcopier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmemo\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(\u001b[38;5;28mcls\u001b[39m, \u001b[38;5;28mtype\u001b[39m):\n", - "File \u001b[0;32m/opt/conda/lib/python3.9/copy.py:182\u001b[0m, in \u001b[0;36m_deepcopy_atomic\u001b[0;34m(x, memo)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m y\n\u001b[1;32m 180\u001b[0m _deepcopy_dispatch \u001b[38;5;241m=\u001b[39m d \u001b[38;5;241m=\u001b[39m {}\n\u001b[0;32m--> 182\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_deepcopy_atomic\u001b[39m(x, memo):\n\u001b[1;32m 183\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m x\n\u001b[1;32m 184\u001b[0m d[\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28;01mNone\u001b[39;00m)] \u001b[38;5;241m=\u001b[39m _deepcopy_atomic\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + "100%|██████████| 2000/2000 [00:00<00:00, 58652.57it/s]\n", + " 9%|▉ | 187/2000 [00:28<04:22, 6.89it/s]" ] } ], diff --git a/test.py b/test.py new file mode 100644 index 0000000..af565fe --- /dev/null +++ b/test.py @@ -0,0 +1,256 @@ +# -*- coding: utf-8 -*- +"""test.ipynb + +Automatically generated by Colaboratory. + +Original file is located at + https://colab.research.google.com/drive/1s-l9A942fTckwR938T0zcdLhQPd5TOMm +""" + +import qiskit +from qiskit import quantum_info, QuantumCircuit +from qiskit.execute_function import execute +from qiskit import BasicAer +import numpy as np +import pickle +import json +import os +import sys +from collections import Counter +from sklearn.metrics import mean_squared_error +from typing import Dict, List +from sklearn.decomposition import PCA +import tqdm + + +import matplotlib.pyplot as plt + +if len(sys.argv) > 1: + data_path = sys.argv[1] +else: + data_path = '.' + +#define utility functions + +def simulate(circuit: qiskit.QuantumCircuit) -> dict: + """Simulate the circuit, give the state vector as the result.""" + backend = BasicAer.get_backend('statevector_simulator') + job = execute(circuit, backend) + result = job.result() + state_vector = result.get_statevector() + + histogram = dict() + for i in range(len(state_vector)): + population = abs(state_vector[i]) ** 2 + if population > 1e-9: + histogram[i] = population + + return histogram + + +def histogram_to_category(histogram): + """This function takes a histogram representation of circuit execution results, and processes into labels as described in + the problem description.""" + assert abs(sum(histogram.values())-1)<1e-8 + positive=0 + for key in histogram.keys(): + digits = bin(int(key))[2:].zfill(20) + if digits[-1]=='0': + positive+=histogram[key] + + return positive + +def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]: + """Returns the number of gate operations with each number of qubits.""" + counter = Counter([len(gate[1]) for gate in circuit.data]) + #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit + #for k>2 + for i in range(3,20): + assert counter[i]==0 + + return counter + + +def image_mse(image1,image2): + # Using sklearns mean squared error: + # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html + return mean_squared_error(255*image1,255*image2) + +# [normalize] +def normalize(row): + #We calculate the squareroot of the sum of the square values of the row + normalization_factor = np.sqrt(np.sum(row**2)) + if normalization_factor == 0.: + #If the sum is zero we return a 0 + return 0.0 + #Else we divide each value between the sum value above + row = row / normalization_factor + return row, normalization_factor +# +data_path = "./data" + +def test(): + #load the actual hackthon data (fashion-mnist) + images=np.load(data_path+'/images.npy') + labels=np.load(data_path+'/labels.npy') + + #test part 1 + global pca, AMPLITUDE_ENCODING_N_QUBITS,IMAGE_SIZE, dataset + + AMPLITUDE_ENCODING_N_QUBITS = 4 + IMAGE_SIZE = 28 + N_IMAGES = len(images) + + pca = PCA(n_components=2**AMPLITUDE_ENCODING_N_QUBITS) + + data = images.reshape(N_IMAGES, IMAGE_SIZE * IMAGE_SIZE) + pca.fit(data) + + # Apply dimensionality reduction on your data + images_pca = pca.transform(data) + + dataset = [] + for i in tqdm.tqdm(range(len(images))): + image_pca = images_pca[i] + image_pca_min_ = image_pca.min() + image_pca_positive = image_pca - image_pca_min_ + + dataset_i = {} + + normalized_state, normalization_factor = normalize(image_pca_positive) + + dataset_i["image"] = images[i] + dataset_i["image_vector"] = normalized_state + dataset_i["label"] = labels[i] + dataset_i["normalization_factor"] = normalization_factor + dataset_i["pca_min_"] = image_pca_min_ + + dataset.append(dataset_i) + + n=len(images) + mse=0 + gatecount=0 + + for i in tqdm.tqdm(range(n)): + #encode image into circuit + circuit,image_re=run_part1(dataset[i]["image_vector"]) + image_re = np.asarray(image_re) + + #count the number of 2qubit gates used + gatecount += count_gates(circuit)[2] + + #calculate mse + mse+=image_mse(dataset[i]["image"], image_re) + + #fidelity of reconstruction + f=1-mse/n + gatecount=gatecount/n + + #score for part1 + score_part1=f*(0.999**gatecount) + + print(score_part1) + + #test part 2 + + score=0 + gatecount=0 + n=len(images) + + for i in range(n): + #run part 2 + circuit,label=run_part2(images[i]) + + #count the gate used in the circuit for score calculation + gatecount+=count_gates(circuit)[2] + + #check label + if label==labels[i]: + score+=1 + + #score + score=score/n + gatecount=gatecount/n + + score_part2=score*(0.999**gatecount) + + print(score_part1, ",", score_part2, ",", data_path, sep="") + + +############################ +# YOUR CODE HERE # +############################ +def encode(image): + qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS) + + qc.initialize(image) + + for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2): + qc = qc.decompose() + + return qc + +def decode(histogram): + histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS) + for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS): + histogram_array[i] = histogram.get(i, 0) + + root = np.sqrt(histogram_array) + + root = root * dataset[i]["normalization_factor"] + + root = root + dataset[i]["pca_min_"] + + reconstruction = pca.inverse_transform([root]) + + + image = reconstruction.reshape(IMAGE_SIZE, IMAGE_SIZE) + + return image + +def run_part1(image): + #encode image into a circuit + circuit=encode(image) + + #simulate circuit + histogram=simulate(circuit) + + #reconstruct the image + image_re=decode(histogram) + + return circuit,image_re + +def run_part2(image): + # load the quantum classifier circuit + classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm') + + #encode image into circuit + circuit=encode(image) + + # append with classifier circuit + nq1 = circuit.width() + nq2 = classifier.width() + nq = max(nq1, nq2) + qc = qiskit.QuantumCircuit(nq) + qc.append(circuit.to_instruction(), list(range(nq1))) + qc.append(classifier.to_instruction(), list(range(nq2))) + + # simulate circuit + histogram=simulate(qc) + + # convert histogram to category + label=histogram_to_category(histogram) + + # thresholding the label, any way you want + if label>0.5: + label=1 + else: + label=0 + + return circuit,label + +############################ +# END YOUR CODE # +############################ + +test() \ No newline at end of file diff --git a/train_classifier.ipynb b/train_classifier.ipynb new file mode 100644 index 0000000..6743ceb --- /dev/null +++ b/train_classifier.ipynb @@ -0,0 +1,2694 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install qiskit" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3PB9KaTr2CIt", + "outputId": "5288d69d-2245-41cc-ead0-1f0219092a17" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting qiskit\n", + " Downloading qiskit-0.40.0.tar.gz (14 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting qiskit-terra==0.23.0\n", + " Downloading qiskit_terra-0.23.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (5.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.1/5.1 MB\u001b[0m \u001b[31m67.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting qiskit-aer==0.11.2\n", + " Downloading qiskit_aer-0.11.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.8/12.8 MB\u001b[0m \u001b[31m77.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting qiskit-ibmq-provider==0.19.2\n", + " Downloading qiskit_ibmq_provider-0.19.2-py3-none-any.whl (240 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m240.4/240.4 KB\u001b[0m \u001b[31m29.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.8/dist-packages (from qiskit-aer==0.11.2->qiskit) (1.21.6)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.8/dist-packages (from qiskit-aer==0.11.2->qiskit) (1.7.3)\n", + "Collecting websocket-client>=1.0.1\n", + " Downloading websocket_client-1.5.0-py3-none-any.whl (55 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m55.9/55.9 KB\u001b[0m \u001b[31m8.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting websockets>=10.0\n", + " Downloading websockets-10.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (106 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m107.0/107.0 KB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: urllib3>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (1.24.3)\n", + "Collecting requests-ntlm>=1.1.0\n", + " Downloading requests_ntlm-1.1.0-py2.py3-none-any.whl (5.7 kB)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.8/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (2.8.2)\n", + "Requirement already satisfied: requests>=2.19 in /usr/local/lib/python3.8/dist-packages (from qiskit-ibmq-provider==0.19.2->qiskit) (2.25.1)\n", + "Collecting stevedore>=3.0.0\n", + " Downloading stevedore-4.1.1-py3-none-any.whl (50 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.0/50.0 KB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: dill>=0.3 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra==0.23.0->qiskit) (0.3.6)\n", + "Collecting symengine>=0.9\n", + " Downloading symengine-0.9.2-cp38-cp38-manylinux2010_x86_64.whl (37.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m37.5/37.5 MB\u001b[0m \u001b[31m16.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ply>=3.10\n", + " Downloading ply-3.11-py2.py3-none-any.whl (49 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.6/49.6 KB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra==0.23.0->qiskit) (1.7.1)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra==0.23.0->qiskit) (5.4.8)\n", + "Collecting rustworkx>=0.12.0\n", + " Downloading rustworkx-0.12.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.9/1.9 MB\u001b[0m \u001b[31m61.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.8.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.0)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (4.0.0)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests>=2.19->qiskit-ibmq-provider==0.19.2->qiskit) (2022.12.7)\n", + "Collecting cryptography>=1.3\n", + " Downloading cryptography-39.0.0-cp36-abi3-manylinux_2_28_x86_64.whl (4.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.2/4.2 MB\u001b[0m \u001b[31m95.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting ntlm-auth>=1.0.2\n", + " Downloading ntlm_auth-1.5.0-py2.py3-none-any.whl (29 kB)\n", + "Collecting pbr!=2.1.0,>=2.0.0\n", + " Downloading pbr-5.11.1-py2.py3-none-any.whl (112 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m112.7/112.7 KB\u001b[0m \u001b[31m12.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.8/dist-packages (from sympy>=1.3->qiskit-terra==0.23.0->qiskit) (1.2.1)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.8/dist-packages (from cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.12->cryptography>=1.3->requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.19.2->qiskit) (2.21)\n", + "Building wheels for collected packages: qiskit\n", + " Building wheel for qiskit (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for qiskit: filename=qiskit-0.40.0-py3-none-any.whl size=12841 sha256=da78fe2389582649fb7eea82e893b93862fa51cb70676cd30c07ddbeed1f956a\n", + " Stored in directory: /root/.cache/pip/wheels/44/52/90/52d837f0b0cc96b59422d8c3a66dd38e8e08660439e513d707\n", + "Successfully built qiskit\n", + "Installing collected packages: ply, websockets, websocket-client, symengine, rustworkx, pbr, ntlm-auth, stevedore, cryptography, requests-ntlm, qiskit-terra, qiskit-ibmq-provider, qiskit-aer, qiskit\n", + "Successfully installed cryptography-39.0.0 ntlm-auth-1.5.0 pbr-5.11.1 ply-3.11 qiskit-0.40.0 qiskit-aer-0.11.2 qiskit-ibmq-provider-0.19.2 qiskit-terra-0.23.0 requests-ntlm-1.1.0 rustworkx-0.12.1 stevedore-4.1.1 symengine-0.9.2 websocket-client-1.5.0 websockets-10.4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "pip install qiskit_machine_learning" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 679 + }, + "id": "D0bSM9FA21tR", + "outputId": "9e8c3eb6-f65d-4b6c-afb3-1e666bf883e1" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting qiskit_machine_learning\n", + " Downloading qiskit_machine_learning-0.5.0-py3-none-any.whl (152 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.8/152.8 KB\u001b[0m \u001b[31m12.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: scipy>=1.4 in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (1.7.3)\n", + "Collecting dill<0.3.6,>=0.3.4\n", + " Downloading dill-0.3.5.1-py2.py3-none-any.whl (95 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m95.8/95.8 KB\u001b[0m \u001b[31m13.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: psutil>=5 in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (5.4.8)\n", + "Requirement already satisfied: qiskit-terra>=0.22 in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (0.23.0)\n", + "Requirement already satisfied: setuptools>=40.1.0 in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (57.4.0)\n", + "Requirement already satisfied: scikit-learn>=0.20.0 in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (1.0.2)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (1.21.6)\n", + "Requirement already satisfied: fastdtw in /usr/local/lib/python3.8/dist-packages (from qiskit_machine_learning) (0.3.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra>=0.22->qiskit_machine_learning) (2.8.2)\n", + "Requirement already satisfied: symengine>=0.9 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra>=0.22->qiskit_machine_learning) (0.9.2)\n", + "Requirement already satisfied: rustworkx>=0.12.0 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra>=0.22->qiskit_machine_learning) (0.12.1)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra>=0.22->qiskit_machine_learning) (4.1.1)\n", + "Requirement already satisfied: ply>=3.10 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra>=0.22->qiskit_machine_learning) (3.11)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.8/dist-packages (from qiskit-terra>=0.22->qiskit_machine_learning) (1.7.1)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from scikit-learn>=0.20.0->qiskit_machine_learning) (3.1.0)\n", + "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.8/dist-packages (from scikit-learn>=0.20.0->qiskit_machine_learning) (1.2.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.8.0->qiskit-terra>=0.22->qiskit_machine_learning) (1.15.0)\n", + "Requirement already satisfied: pbr!=2.1.0,>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from stevedore>=3.0.0->qiskit-terra>=0.22->qiskit_machine_learning) (5.11.1)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.8/dist-packages (from sympy>=1.3->qiskit-terra>=0.22->qiskit_machine_learning) (1.2.1)\n", + "Installing collected packages: dill, qiskit_machine_learning\n", + " Attempting uninstall: dill\n", + " Found existing installation: dill 0.3.6\n", + " Uninstalling dill-0.3.6:\n", + " Successfully uninstalled dill-0.3.6\n", + "Successfully installed dill-0.3.5.1 qiskit_machine_learning-0.5.0\n" + ] + }, + { + "output_type": "display_data", + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "dill" + ] + } + } + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 443 + }, + "id": "eXGMb6MT14_8", + "outputId": "b6a0b24b-76ea-485a-d2b4-097fbbda2d43" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 2000/2000 [00:00<00:00, 22945.77it/s]\n", + " 0%| | 8/2000 [00:01<07:06, 4.67it/s]\n" + ] + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 245\u001b[0m \u001b[0;31m############################\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 246\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 247\u001b[0;31m \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mtest\u001b[0;34m()\u001b[0m\n\u001b[1;32m 125\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;31m#encode image into circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 127\u001b[0;31m \u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mimage_re\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrun_part1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"image_vector\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 128\u001b[0m \u001b[0mimage_re\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage_re\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mrun_part1\u001b[0;34m(image)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 206\u001b[0m \u001b[0;31m#simulate circuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 207\u001b[0;31m \u001b[0mhistogram\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msimulate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 208\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 209\u001b[0m \u001b[0;31m#reconstruct the image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36msimulate\u001b[0;34m(circuit)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0;34m\"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0mbackend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBasicAer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_backend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'statevector_simulator'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mjob\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbackend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mstate_vector\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_statevector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/execute_function.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(experiments, backend, basis_gates, coupling_map, backend_properties, initial_layout, seed_transpiler, optimization_level, pass_manager, qobj_id, qobj_header, shots, memory, max_credits, seed_simulator, default_qubit_los, default_meas_los, qubit_lo_range, meas_lo_range, schedule_los, meas_level, meas_return, memory_slots, memory_slot_size, rep_time, rep_delay, parameter_binds, schedule_circuit, inst_map, meas_map, scheduling_method, init_qubits, **run_config)\u001b[0m\n\u001b[1;32m 297\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;31m# transpiling the circuits using given transpile options\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 299\u001b[0;31m experiments = transpile(\n\u001b[0m\u001b[1;32m 300\u001b[0m \u001b[0mexperiments\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 301\u001b[0m \u001b[0mbasis_gates\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbasis_gates\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/compiler/transpiler.py\u001b[0m in \u001b[0;36mtranspile\u001b[0;34m(circuits, backend, basis_gates, inst_map, coupling_map, backend_properties, initial_layout, layout_method, routing_method, translation_method, scheduling_method, instruction_durations, dt, approximation_degree, timing_constraints, seed_transpiler, optimization_level, callback, output_name, unitary_synthesis_method, unitary_synthesis_plugin_config, target, hls_config, init_method, optimization_method, ignore_backend_supplied_default_methods)\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[0mtranspile_config\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpass_manager\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_combine_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mshared_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0munique_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 380\u001b[0m output_circuits.append(\n\u001b[0;32m--> 381\u001b[0;31m _serial_transpile_circuit(\n\u001b[0m\u001b[1;32m 382\u001b[0m \u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 383\u001b[0m \u001b[0mpass_manager\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/compiler/transpiler.py\u001b[0m in \u001b[0;36m_serial_transpile_circuit\u001b[0;34m(circuit, pass_manager, callback, output_name, num_qubits, faulty_qubits_map, backend_prop)\u001b[0m\n\u001b[1;32m 472\u001b[0m \u001b[0mbackend_prop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 473\u001b[0m ):\n\u001b[0;32m--> 474\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpass_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcallback\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 475\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfaulty_qubits_map\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 476\u001b[0m return _remap_circuit_faulty_backend(\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/transpiler/passmanager.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, circuits, output_name, callback)\u001b[0m\n\u001b[1;32m 526\u001b[0m ) -> Union[QuantumCircuit, List[QuantumCircuit]]:\n\u001b[1;32m 527\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_passmanager\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 528\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/transpiler/passmanager.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, circuits, output_name, callback)\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcircuits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 227\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mQuantumCircuit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 228\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_single_circuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 229\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuits\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 230\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_run_single_circuit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuits\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/transpiler/passmanager.py\u001b[0m in \u001b[0;36m_run_single_circuit\u001b[0;34m(self, circuit, output_name, callback)\u001b[0m\n\u001b[1;32m 281\u001b[0m \"\"\"\n\u001b[1;32m 282\u001b[0m \u001b[0mrunning_passmanager\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_running_passmanager\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 283\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrunning_passmanager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moutput_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moutput_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcallback\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcallback\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 284\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mproperty_set\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrunning_passmanager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mproperty_set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 285\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/transpiler/runningpassmanager.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, circuit, output_name, callback)\u001b[0m\n\u001b[1;32m 115\u001b[0m \"\"\"\n\u001b[1;32m 116\u001b[0m \u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcircuit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m \u001b[0mdag\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcircuit_to_dag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcircuit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 118\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mcircuit\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/converters/circuit_to_dag.py\u001b[0m in \u001b[0;36mcircuit_to_dag\u001b[0;34m(circuit)\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0minstruction\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mcircuit\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 60\u001b[0m dagcircuit.apply_operation_back(\n\u001b[0;32m---> 61\u001b[0;31m \u001b[0mcopy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minstruction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moperation\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstruction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mqubits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minstruction\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclbits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 62\u001b[0m )\n\u001b[1;32m 63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.8/copy.py\u001b[0m in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0mcopier\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"__deepcopy__\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcopier\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcopier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmemo\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 154\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0mreductor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdispatch_table\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/qiskit/circuit/instruction.py\u001b[0m in \u001b[0;36m__deepcopy__\u001b[0;34m(self, _memo)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[0mcpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_params\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 436\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_definition\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 437\u001b[0;31m \u001b[0mcpy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_definition\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcopy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_definition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_memo\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 438\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcpy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.8/copy.py\u001b[0m in \u001b[0;36mdeepcopy\u001b[0;34m(x, memo, _nil)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_reconstruct\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmemo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mrv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0;31m# If is its own copy, don't memoize.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.8/copy.py\u001b[0m in \u001b[0;36m_reconstruct\u001b[0;34m(x, memo, func, args, state, listiter, dictiter, deepcopy)\u001b[0m\n\u001b[1;32m 256\u001b[0m \u001b[0mmemo\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmemo\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 257\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 258\u001b[0;31m def _reconstruct(x, memo, func, args,\n\u001b[0m\u001b[1;32m 259\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlistiter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdictiter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 260\u001b[0m deepcopy=deepcopy):\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info, QuantumCircuit\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "import sys\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "from sklearn.decomposition import PCA\n", + "import tqdm\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "if len(sys.argv) > 1:\n", + " data_path = sys.argv[1]\n", + "else:\n", + " data_path = '.'\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function takes a histogram representation of circuit execution results, and processes into labels as described in\n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(3,20):\n", + " assert counter[i]==0\n", + " \n", + " return counter\n", + "\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(255*image1,255*image2)\n", + "\n", + "# [normalize]\n", + "def normalize(row):\n", + " #We calculate the squareroot of the sum of the square values of the row\n", + " normalization_factor = np.sqrt(np.sum(row**2)) \n", + " if normalization_factor == 0.:\n", + " #If the sum is zero we return a 0\n", + " return 0.0\n", + " #Else we divide each value between the sum value above\n", + " row = row / normalization_factor\n", + " return row, normalization_factor\n", + "#\n", + "data_path = \"./data\"\n", + "\n", + "def test():\n", + " #load the actual hackthon data (fashion-mnist)\n", + " images=np.load(data_path+'/images.npy')\n", + " labels=np.load(data_path+'/labels.npy')\n", + " \n", + " #test part 1\n", + " global pca, AMPLITUDE_ENCODING_N_QUBITS,IMAGE_SIZE, dataset\n", + "\n", + " AMPLITUDE_ENCODING_N_QUBITS = 4\n", + " IMAGE_SIZE = 28\n", + " N_IMAGES = len(images)\n", + "\n", + " pca = PCA(n_components=2**AMPLITUDE_ENCODING_N_QUBITS)\n", + " \n", + " data = images.reshape(N_IMAGES, IMAGE_SIZE * IMAGE_SIZE)\n", + " pca.fit(data)\n", + " \n", + " # Apply dimensionality reduction on your data\n", + " images_pca = pca.transform(data)\n", + " \n", + " dataset = []\n", + " for i in tqdm.tqdm(range(len(images))):\n", + " image_pca = images_pca[i]\n", + " image_pca_min_ = image_pca.min()\n", + " image_pca_positive = image_pca - image_pca_min_\n", + " \n", + " dataset_i = {}\n", + " \n", + " normalized_state, normalization_factor = normalize(image_pca_positive)\n", + " \n", + " dataset_i[\"image\"] = images[i]\n", + " dataset_i[\"image_vector\"] = normalized_state\n", + " dataset_i[\"label\"] = labels[i]\n", + " dataset_i[\"normalization_factor\"] = normalization_factor\n", + " dataset_i[\"pca_min_\"] = image_pca_min_\n", + " \n", + " dataset.append(dataset_i)\n", + " \n", + " n=len(images)\n", + " mse=0\n", + " gatecount=0\n", + "\n", + " for i in tqdm.tqdm(range(n)):\n", + " #encode image into circuit\n", + " circuit,image_re=run_part1(dataset[i][\"image_vector\"])\n", + " image_re = np.asarray(image_re)\n", + "\n", + " #count the number of 2qubit gates used\n", + " gatecount += count_gates(circuit)[2]\n", + "\n", + " #calculate mse\n", + " mse+=image_mse(dataset[i][\"image\"], image_re)\n", + "\n", + " #fidelity of reconstruction\n", + " f=1-mse/n\n", + " gatecount=gatecount/n\n", + "\n", + " #score for part1\n", + " score_part1=f*(0.999**gatecount)\n", + " \n", + " print(score_part_1)\n", + "\n", + " #test part 2\n", + " \n", + " score=0\n", + " gatecount=0\n", + " n=len(images)\n", + "\n", + " for i in range(n):\n", + " #run part 2\n", + " circuit,label=run_part2(images[i])\n", + "\n", + " #count the gate used in the circuit for score calculation\n", + " gatecount+=count_gates(circuit)[2]\n", + "\n", + " #check label\n", + " if label==labels[i]:\n", + " score+=1\n", + " \n", + " #score\n", + " score=score/n\n", + " gatecount=gatecount/n\n", + "\n", + " score_part2=score*(0.999**gatecount)\n", + " \n", + " print(score_part1, \",\", score_part2, \",\", data_path, sep=\"\")\n", + "\n", + "\n", + "############################\n", + "# YOUR CODE HERE #\n", + "############################\n", + "def encode(image):\n", + " qc = QuantumCircuit(AMPLITUDE_ENCODING_N_QUBITS)\n", + "\n", + " qc.initialize(image)\n", + " \n", + " for i in range(AMPLITUDE_ENCODING_N_QUBITS + 2):\n", + " qc = qc.decompose()\n", + " \n", + " return qc\n", + "\n", + "def decode(histogram):\n", + " histogram_array = np.zeros(2 ** AMPLITUDE_ENCODING_N_QUBITS)\n", + " for i in range(2 ** AMPLITUDE_ENCODING_N_QUBITS):\n", + " histogram_array[i] = histogram.get(i, 0)\n", + " \n", + " root = np.sqrt(histogram_array)\n", + " \n", + " root = root * dataset[i][\"normalization_factor\"]\n", + " \n", + " root = root + dataset[i][\"pca_min_\"]\n", + "\n", + " reconstruction = pca.inverse_transform([root])\n", + "\n", + " \n", + " image = reconstruction.reshape(IMAGE_SIZE, IMAGE_SIZE)\n", + " \n", + " return image\n", + "\n", + "def run_part1(image):\n", + " #encode image into a circuit\n", + " circuit=encode(image)\n", + "\n", + " #simulate circuit\n", + " histogram=simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re=decode(histogram)\n", + "\n", + " return circuit,image_re\n", + "\n", + "def run_part2(image):\n", + " # load the quantum classifier circuit\n", + " classifier=qiskit.QuantumCircuit.from_qasm_file('quantum_classifier.qasm')\n", + " \n", + " #encode image into circuit\n", + " circuit=encode(image)\n", + " \n", + " #append with classifier circuit\n", + " nq1 = circuit.width()\n", + " nq2 = classifier.width()\n", + " nq = max(nq1, nq2)\n", + " qc = qiskit.QuantumCircuit(nq)\n", + " qc.append(circuit.to_instruction(), list(range(nq1)))\n", + " qc.append(classifier.to_instruction(), list(range(nq2)))\n", + " \n", + " #simulate circuit\n", + " histogram=simulate(qc)\n", + " \n", + " #convert histogram to category\n", + " label=histogram_to_category(histogram)\n", + " \n", + " #thresholding the label, any way you want\n", + " if label>0.5:\n", + " label=1\n", + " else:\n", + " label=0\n", + " \n", + " return circuit,label\n", + "\n", + "############################\n", + "# END YOUR CODE #\n", + "############################\n", + "\n", + "test()" + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.utils import shuffle\n", + "from sklearn.metrics import log_loss\n", + "import tqdm\n", + "from qiskit.circuit.library import RealAmplitudes\n", + "from qiskit.utils import algorithm_globals\n", + "\n", + "\n", + "from scipy.optimize import minimize \n", + "\n", + "\n", + "def ansatz(num_qubits):\n", + " return RealAmplitudes(num_qubits, reps=5)\n", + "\n", + "#Function to identify a function cost\n", + "'''\n", + "Input: An array of parameters(vector of complex amplitudes)\n", + "Output: Function cost\n", + "'''\n", + "\n", + "def objective_function(params, images, labels, shots=1024, mini_batch=5, n_qubits=8):\n", + " running_loss = 0\n", + " images, labels = shuffle(images, labels)\n", + " y_pred = []\n", + "\n", + " #For each item of the trainig set\n", + " for i in tqdm.tqdm(range(mini_batch)):\n", + " \n", + " image = images[i]\n", + " \n", + " circuit = encode(image) #Create a inicial circuit\n", + " vqc = ansatz(n_qubits)\n", + "\n", + " vqc = vqc.assign_parameters(params)\n", + "\n", + " #Create a new circuit based on the size of the initial circuit and the desired qubits to reduce\n", + " circuit_full = QuantumCircuit(n_qubits)\n", + " \n", + " qubits = list(range(n_qubits))\n", + " \n", + " circuit_full.append(circuit.to_instruction(), qubits)\n", + " circuit_full.append(vqc.to_instruction(), qubits)\n", + "\n", + " #Combine the initial circuit, the quantum variatinal circuit and the swap test\n", + " #For the initial circuit and QVC we start at the qubit size_reduce + 1\n", + " \n", + " #Execute the circuit in the qasm_simulator\n", + " histogram = simulate(circuit_full)\n", + "\n", + " pred_label = histogram_to_category(histogram)\n", + " \n", + " y_pred.append(pred_label)\n", + " \n", + " print(labels.shape)\n", + " \n", + " print(len(y_pred))\n", + " y_true = labels[:mini_batch].astype(int)\n", + " \n", + " \n", + "\n", + " loss = log_loss(y_true, y_pred, labels=[0, 1])\n", + " \n", + " print(y_true, y_pred)\n", + " print(\"Loss\")\n", + " print(loss)\n", + " \n", + "\n", + " return loss\n", + "\n", + "def train_classifier():\n", + " images=np.load(data_path+'/images.npy')\n", + " labels=np.load(data_path+'/labels.npy')\n", + "\n", + " N_images = len(images) \n", + " N_QUBITS = 4\n", + " shots = 1024\n", + " mini_batch = 25\n", + "\n", + " vqc = ansatz(N_QUBITS)\n", + " np.random.seed(42)\n", + " initial_point = algorithm_globals.random.random(vqc.num_parameters)\n", + "\n", + " #test part 1\n", + " global pca, AMPLITUDE_ENCODING_N_QUBITS,IMAGE_SIZE, dataset\n", + "\n", + " AMPLITUDE_ENCODING_N_QUBITS = 4\n", + " IMAGE_SIZE = 28\n", + " N_IMAGES = len(images)\n", + "\n", + " pca = PCA(n_components=2**AMPLITUDE_ENCODING_N_QUBITS)\n", + " \n", + " data = images.reshape(N_IMAGES, IMAGE_SIZE * IMAGE_SIZE)\n", + " pca.fit(data)\n", + " \n", + " # Apply dimensionality reduction on your data\n", + " images_pca = pca.transform(data)\n", + " # dataset pre-processing\n", + " X_train = []\n", + " dataset = []\n", + " for i in tqdm.tqdm(range(len(images))):\n", + " image_pca = images_pca[i]\n", + " image_pca_min_ = image_pca.min()\n", + " image_pca_positive = image_pca - image_pca_min_\n", + " \n", + " dataset_i = {}\n", + " \n", + " normalized_state, normalization_factor = normalize(image_pca_positive)\n", + " \n", + " dataset_i[\"image\"] = images[i]\n", + " dataset_i[\"image_vector\"] = normalized_state\n", + " dataset_i[\"label\"] = labels[i]\n", + " dataset_i[\"normalization_factor\"] = normalization_factor\n", + " dataset_i[\"pca_min_\"] = image_pca_min_\n", + " X_train.append(normalized_state)\n", + " dataset.append(dataset_i)\n", + "\n", + " X_train = np.array(X_train)\n", + "\n", + " #Minimization of the objective_fucntion by a COBYLA method\n", + " minimum = minimize(objective_function, \n", + " initial_point, \n", + " args=(X_train, labels, shots, mini_batch, N_QUBITS), \n", + " method='COBYLA', \n", + " tol=1e-6,\n", + " options={\n", + " \"maxiter\": 100\n", + " }\n", + " )\n", + " params = minimum.x #Get the solution array\n", + " #Show the cost of the solution array\n", + " #print(\"Cost: \", objective_function(params))\n", + " print(params)\n", + "\n", + " return params, minimum\n", + "\n", + "params, minimum = train_classifier()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kardiamJ16C-", + "outputId": "cbe18b21-af38-4fd7-f4ec-544e358d9164" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 2000/2000 [00:00<00:00, 24238.72it/s]\n", + "100%|██████████| 25/25 [00:05<00:00, 4.58it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 1 0 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0] [0.44519858402025986, 0.5085602502018445, 0.40632671451209795, 0.20092020244151756, 0.3977107001676153, 0.41472526492673534, 0.6251959425415752, 0.29942951568515996, 0.3723311667474298, 0.6656642171294723, 0.30642829538372324, 0.628821208180102, 0.40582039822943494, 0.6455649988743064, 0.39777949169730054, 0.3522800502215791, 0.6681438022149653, 0.27692736072648644, 0.7358593160250066, 0.4871031485313555, 0.7418107528346649, 0.7457709858003171, 0.40421499000484673, 0.6774790218773664, 0.7173770307390636]\n", + "Loss\n", + "0.6950484021617176\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.43it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 1 0 0 0 1 0 1 1 1 0 1 0 0 1 0 0 0 0 0 0 1 0] [0.6713651596247816, 0.32797071264017913, 0.6159082805404793, 0.6948126275844074, 0.5181274856264813, 0.4416224649531305, 0.7651560098836326, 0.3891186175970222, 0.8428280495170285, 0.38185086463612594, 0.34402203331214204, 0.39887725924693174, 0.5719200121674068, 0.6428755510693174, 0.7002503570243181, 0.342133916074148, 0.41743510840906595, 0.6569694358548138, 0.7230374549782524, 0.5044971611725263, 0.9487756613093175, 0.4196608441677173, 0.38158536866452547, 0.5494787663284962, 0.81562557728394]\n", + "Loss\n", + "1.007307867649984\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.22it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 0 1 0] [0.3161426804619409, 0.525812893918048, 0.15152449778814656, 0.5159805905465868, 0.30521341548078657, 0.627944887691082, 0.21770975675776247, 0.6530907982853387, 0.4014338771026449, 0.40717556762670043, 0.3896615528359388, 0.5639420091848597, 0.2775013762502942, 0.41409152496054935, 0.554807525668249, 0.36825999659599246, 0.5180061637894745, 0.6113942345112583, 0.6928522357788024, 0.5890127031885675, 0.28966828678925205, 0.588864736144661, 0.2270164169457504, 0.592547965790828, 0.3529251305449724]\n", + "Loss\n", + "0.5492886348847913\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.32it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0] [0.489827375402157, 0.36110212645926676, 0.23295179255985293, 0.2575735528362733, 0.30338182519741513, 0.2947606895479705, 0.218686257828648, 0.2625493709929567, 0.27985818747882485, 0.1779685396878382, 0.45939146186879665, 0.2954152989110424, 0.18178467127761633, 0.4042178128458602, 0.28523571013168103, 0.3046970339951046, 0.1938272322377514, 0.11179042638179577, 0.28760325075437876, 0.3596147639239648, 0.24603199478078613, 0.17891620899275845, 0.14200324937875072, 0.3574500805061423, 0.2379756713585529]\n", + "Loss\n", + "0.5299397602370532\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.32it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 1 0 0 0 1 0 1 0 1 0 1 0 1 0 0 1 0 0 0 1] [0.1076630497237271, 0.3515095648675286, 0.3621367638714106, 0.055942117274697084, 0.5341235045371815, 0.5288924287427778, 0.39750470627839896, 0.36303646939700224, 0.15159662921810343, 0.4076748737811838, 0.20453772428573636, 0.3983483526914981, 0.4116847642750084, 0.5399922284087225, 0.38026968538055694, 0.461413773323828, 0.3635609378363328, 0.1498338322893529, 0.4665637784534496, 0.66313938010933, 0.3912011444603135, 0.2806752362687405, 0.11906109575875003, 0.35687829289123624, 0.3821415657587119]\n", + "Loss\n", + "0.5900131532286113\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.92it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 1 0 0 0 0 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0] [0.6703963935419779, 0.5382387003989364, 0.5989349055525331, 0.49066693591667276, 0.6380069245212516, 0.8709332681278472, 0.652771723560037, 0.3310431373134298, 0.7184702211227347, 0.5679171370819375, 0.37921021544673966, 0.5485553716829865, 0.4436537452652735, 0.5579751232105111, 0.5482632606391545, 0.5171419535092207, 0.42849468302268334, 0.5661112304803004, 0.44672510833846857, 0.6327243230988808, 0.5512678404100027, 0.7624315155687088, 0.41069281281468917, 0.5403593632133151, 0.6182999935296536]\n", + "Loss\n", + "0.810766448882395\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0.4058154382957029, 0.5121152048021309, 0.3595669412574303, 0.49173355580401584, 0.5048628073502891, 0.6769411534774596, 0.7934609608382284, 0.8114074698860186, 0.5352091120608897, 0.5940644898632671, 0.495142248055607, 0.7552141690717098, 0.7448197672155208, 0.6016208908224239, 0.8628053116607186, 0.42642623341605623, 0.514477190119382, 0.47256324327038257, 0.36005006886849045, 0.4230425962632963, 0.3928197725754425, 0.5173651819495484, 0.5109642019195214, 0.5351580036942589, 0.8232376277175146]\n", + "Loss\n", + "0.896769716361815\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.39it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0] [0.5547811686003535, 0.24008645165985898, 0.46604865827018027, 0.3627249271191896, 0.3991248101627021, 0.5933141874841698, 0.37921586653278905, 0.2261932814892541, 0.6738375000288936, 0.380896746585959, 0.5319970562101544, 0.4869951523643044, 0.5608560342435324, 0.41394321202930767, 0.44226400946336397, 0.7020612522740677, 0.4409037742186424, 0.5808765940375586, 0.5512187473868894, 0.5180941064237825, 0.4908226747412065, 0.568061216571957, 0.567953759014902, 0.3613358665115178, 0.40309777123666823]\n", + "Loss\n", + "0.645266248037059\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.21it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0] [0.5574878871124967, 0.31730094732166547, 0.36595364725249063, 0.21979415847461165, 0.44079624815109547, 0.2934444923834692, 0.2429529462000074, 0.34197868781379875, 0.2151966950039165, 0.3579367214676502, 0.29638969045699515, 0.3229313263372552, 0.4142677706573377, 0.6384836167663386, 0.25850837051574116, 0.3053647103374007, 0.3030867021476561, 0.41736872347010806, 0.42966552501683397, 0.36814494845026047, 0.41445176304682196, 0.2984989852433838, 0.30438335141612627, 0.321030623947243, 0.31836400477192456]\n", + "Loss\n", + "0.5939544107353314\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.40it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1] [0.06433534790970587, 0.5074828485062922, 0.16689421243740182, 0.15245690724781258, 0.13797539956913238, 0.3271524743972863, 0.09108654595203658, 0.6219615910961256, 0.1704373604772264, 0.0953124532373042, 0.19706159708424761, 0.2532514676238848, 0.5656205542821644, 0.38068193435224096, 0.3896439514201853, 0.6407888610594891, 0.09560933730969953, 0.16405764204831066, 0.09669101099151492, 0.5045810886907645, 0.2797203002864601, 0.10349913358846313, 0.42166852798793863, 0.3678460791475427, 0.22698816078398143]\n", + "Loss\n", + "0.9270658315828387\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.32it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 1] [0.13915137442817482, 0.07208408427537984, 0.4722635006544194, 0.18562996310786123, 0.3468186788175827, 0.3269277267323909, 0.32580728509117124, 0.26450713805472714, 0.37545452503105387, 0.19414435318822404, 0.13541332814490334, 0.26541629323791943, 0.29239528933800607, 0.39266176713075773, 0.2612033251072293, 0.18060277433795305, 0.2641923265329735, 0.12845091354789995, 0.28334071469587546, 0.4083341238128736, 0.3448505812948566, 0.12017666332591435, 0.14135144742772707, 0.395483515856559, 0.2510788845001727]\n", + "Loss\n", + "0.5999810319327736\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.75it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1 0 1 1 0 0] [0.2972320755544233, 0.15535842241659148, 0.5543912365669875, 0.3301862850565475, 0.6492310260291216, 0.3071399967346729, 0.19897543077022337, 0.24684268540745924, 0.29507046140616094, 0.1438300999380153, 0.5090502575830858, 0.19191742849921176, 0.20735660143600076, 0.15144952677077164, 0.27859063600812756, 0.25171439818444746, 0.39927695310574524, 0.49131629280782163, 0.6525807120455412, 0.35171265355034753, 0.21483533943135782, 0.5308745958899868, 0.2737170991012762, 0.14056943722756485, 0.22087953218398573]\n", + "Loss\n", + "0.6555997670349555\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.49it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1] [0.4962013147404283, 0.23515931151877342, 0.5377658549385856, 0.22765502377354838, 0.38857728095276023, 0.17841334087006577, 0.31955390185775095, 0.1780872123640531, 0.18257374373016708, 0.3220702775793027, 0.5240882178897629, 0.16426217496200202, 0.3369766549144346, 0.2671299806820289, 0.2277529216364139, 0.5800454614336916, 0.3910992727185255, 0.32812093409596427, 0.28371424868748574, 0.15663868270246806, 0.09988518523427102, 0.2247510290204852, 0.3095220873680078, 0.35766927924880704, 0.21670545169387886]\n", + "Loss\n", + "0.7439377488351986\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.30it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0] [0.6375373115932557, 0.394921550933168, 0.6375851358021226, 0.48039638807550555, 0.5323296170497155, 0.5979325479190568, 0.5792895371823035, 0.5881683253618746, 0.4975070032652983, 0.8306105971570923, 0.46923427884311003, 0.5204673237099549, 0.5506655155695737, 0.6294536642762751, 0.6715040891497774, 0.6445704930424091, 0.6564763573614711, 0.6329023964831019, 0.44665351258284325, 0.49039718126039245, 0.7556471632490424, 0.5724830537097136, 0.5632650061496771, 0.514590274271011, 0.6121567859133411]\n", + "Loss\n", + "0.8051027275410554\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 0] [0.5809279326852694, 0.5787342445130249, 0.47334985543901203, 0.5201567860967695, 0.5945233645802285, 0.5407573229493594, 0.6870934919739524, 0.48918290793414043, 0.49654677037978906, 0.3219680638540187, 0.8298408423519577, 0.6533734019336586, 0.5067767141307389, 0.5501267186433428, 0.45345914929307163, 0.7957552091437112, 0.5444759237809715, 0.5525337918804041, 0.6902338628152074, 0.709789983966451, 0.6290713980693543, 0.6830379687690529, 0.8494426792239576, 0.4402410855150118, 0.43265107148652404]\n", + "Loss\n", + "0.7852859530981681\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.23it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 1] [0.4573126661862429, 0.2792050959686748, 0.2725433310432512, 0.48289216114928235, 0.19359401096884343, 0.29090860504426974, 0.3559828840699166, 0.33956263555344307, 0.4793756691130753, 0.38308967368012015, 0.22974270268109875, 0.4138074321227002, 0.37264145191444353, 0.27098954657853513, 0.2994319016193355, 0.5117415477625172, 0.5520579043226983, 0.41001537410664435, 0.3651803316150706, 0.26982157954557745, 0.4151756017704016, 0.5544687594318843, 0.4487529158569858, 0.2663369480475301, 0.2571254206379988]\n", + "Loss\n", + "0.6241871825220557\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0] [0.380037053756083, 0.31429247929950344, 0.5552881513921635, 0.43661366063216045, 0.356357748469392, 0.5221492515971922, 0.4191454656644541, 0.4813635336206337, 0.23175778915166878, 0.599777221989054, 0.28110384986519527, 0.47236700913577695, 0.4545599483729894, 0.25773415587039283, 0.25950303043450684, 0.32119856027076227, 0.4694261341249724, 0.23864491209883498, 0.25665194004171643, 0.24431623537794098, 0.5459053996718373, 0.5076209075348597, 0.39329519942773483, 0.32350568157153436, 0.36881419394664583]\n", + "Loss\n", + "0.5353110980861441\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.33it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0] [0.2916200556347915, 0.46974717760359697, 0.5536357643796718, 0.3440451472135647, 0.35664277664606653, 0.7784233045761044, 0.5607973842439778, 0.40216342127018007, 0.2242478308255083, 0.24007316080165003, 0.4800270749587116, 0.5138707523906018, 0.7353606893076261, 0.6286805098858643, 0.560993414953511, 0.4823407763690367, 0.564450845145279, 0.4436904391126636, 0.33522311368759095, 0.45083743837492724, 0.42511900217645104, 0.18169908138122337, 0.4882394071074552, 0.2810496983461326, 0.39119858644474376]\n", + "Loss\n", + "0.8190514607938465\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.26it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0] [0.3608661076601218, 0.29843757605396154, 0.2474506066493457, 0.18630502286165376, 0.3942677685937604, 0.2804236878190935, 0.15088186653488028, 0.42612074601156746, 0.3899666970799271, 0.18460605653810064, 0.36667673147256485, 0.3922294287736279, 0.2970371978186375, 0.36265570574617034, 0.1996624564982773, 0.49452060601197234, 0.45221312557646526, 0.1644234766386213, 0.40421124848923046, 0.38225566846265613, 0.3820207940463038, 0.28240004718734324, 0.23623745681311395, 0.28315347317549966, 0.2589792047174237]\n", + "Loss\n", + "0.5375035142675022\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.37it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1] [0.3634129472999538, 0.14267859602065194, 0.11091695182739396, 0.4280407183834297, 0.27953274451318283, 0.15369537472350223, 0.2896016257423768, 0.14691882925846253, 0.24319916106813882, 0.06936876429143865, 0.16522716575224417, 0.5687834378655566, 0.48391463082276254, 0.1762155899748491, 0.3794409749048626, 0.43100810473061757, 0.3163275144885015, 0.2299724098653843, 0.46393449010047094, 0.15527915040821558, 0.12970659149712993, 0.1139132218354316, 0.2586051952852234, 0.21503753604999043, 0.3622891221372586]\n", + "Loss\n", + "0.5509766169532706\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.28it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 1 0 0 0 0 1 0 0 1 1 1 1 1 0 1 0 0 1 0 0 1 0] [0.18918735480359833, 0.13374763855913377, 0.2982928249242249, 0.39840639810305334, 0.4848425617525859, 0.13993650824587786, 0.4215575791645655, 0.44812555778622676, 0.3715220712177961, 0.15071829794511526, 0.10164769271640191, 0.16899311372008283, 0.4137350870275539, 0.4146736196817678, 0.35409971987080546, 0.31111464638775793, 0.25065554556280545, 0.2955077242435698, 0.2272012745506866, 0.3949251336205574, 0.1865093695285427, 0.13962069359776882, 0.1356831124249656, 0.36046272215426045, 0.16917026064725724]\n", + "Loss\n", + "0.6998036516253374\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.38it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1] [0.5544126666210487, 0.6408619702648494, 0.45253410417335366, 0.7389956608703482, 0.3815277833835158, 0.4019037152809214, 0.5703986775622684, 0.6133383015878743, 0.5616531705278426, 0.44619153155173347, 0.3998857768826336, 0.4607066414095792, 0.7140858029039648, 0.4539524515031816, 0.4424658235100303, 0.5717380207738608, 0.5916522281386476, 0.6950548780971775, 0.6150020544105095, 0.8008838155460177, 0.5574307461159778, 0.5629497991049439, 0.4149686823601287, 0.3677683070824295, 0.709242067325374]\n", + "Loss\n", + "0.7992723307600351\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.39it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 0 0 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0] [0.5470518571794623, 0.26887415151992616, 0.28749967375550994, 0.4901881945461513, 0.3750463561279367, 0.3585862273556254, 0.3665924138602481, 0.2186862578286481, 0.3910525967362009, 0.43233960303129326, 0.4856951564991841, 0.3802272332795821, 0.24380499284931825, 0.30082667892957854, 0.29961139081328547, 0.19196072083669574, 0.4671359549327671, 0.16740876364158266, 0.300935391921436, 0.183831381009661, 0.19404058782838907, 0.30416940724563457, 0.37931665303263756, 0.2354776006536153, 0.11179042638179577]\n", + "Loss\n", + "0.49523616801992715\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 1 1 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 0] [0.2569661855823211, 0.4887741735859771, 0.3527071120427178, 0.235086081031203, 0.3915036526061315, 0.32131976555187225, 0.24653322808819894, 0.30147595261635945, 0.22617254818739557, 0.4752202012144776, 0.44214290775734383, 0.3969823851655403, 0.2093142023667517, 0.1621355002405807, 0.12532328511699062, 0.15156336609187923, 0.33245902632410607, 0.46322821197122666, 0.3129480060302372, 0.5308694630161197, 0.21470010335349557, 0.1785771959748302, 0.3095688051170094, 0.18638040890531277, 0.2332799675292917]\n", + "Loss\n", + "0.6383259801889571\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.37it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 1 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 1 0 0 0 1 0 1] [0.4176053416012342, 0.43104722268384754, 0.41896664375944304, 0.3341277419652158, 0.32131976555187214, 0.18675453681229312, 0.2181435570044632, 0.335843089319768, 0.4900331927067718, 0.4713644637727435, 0.39078925300728, 0.3572046184307819, 0.3357153546497531, 0.33039756465412856, 0.4064529283756293, 0.19417475589678473, 0.5118173484409118, 0.2735794768345956, 0.3492311689353607, 0.22072457794229022, 0.15035011342371313, 0.20815826605092083, 0.34720024690387963, 0.27435397051672794, 0.4117090926454872]\n", + "Loss\n", + "0.6456072591278645\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.24it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 1 0 1 1 0 0] [0.3329252560956439, 0.3636228331035207, 0.3643255946820611, 0.19664114088325613, 0.28713021697713087, 0.2488851403894542, 0.5594613635480162, 0.5611017346319602, 0.23308857927382207, 0.5660083707584962, 0.6922500767032166, 0.46753400887481616, 0.27395901578983795, 0.3845347621883715, 0.3402496317535896, 0.4456364969861335, 0.5135298400504532, 0.2666183716111477, 0.2123828282055899, 0.49480317758301046, 0.23143543308154865, 0.20971555551769652, 0.3286429337987887, 0.23982573627936601, 0.26983955484969874]\n", + "Loss\n", + "0.5717471085536292\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0] [0.20247061340516215, 0.4472500961966206, 0.23455124100524907, 0.11042085171801426, 0.4128841017615651, 0.22354995202617015, 0.19141982302199462, 0.29289648507535665, 0.2905245377472092, 0.34163141406381825, 0.12091946229485237, 0.16176212391422057, 0.7296906535240025, 0.3991833807032641, 0.20789543770505017, 0.19599734266813046, 0.22971859063109876, 0.1002349618873657, 0.09265534068655898, 0.5349208530596542, 0.29781381467222257, 0.1834171637224102, 0.22730724696351004, 0.08079107314683139, 0.5688555338536512]\n", + "Loss\n", + "0.5381181239965518\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.07it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 1 0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 0 1 0 0 0 0] [0.6532498488657295, 0.3559143915303845, 0.22377432263246896, 0.46913364109838795, 0.3096051991631266, 0.2611813657776445, 0.342404168212737, 0.3419492725019492, 0.44304553466705354, 0.24498647917171826, 0.24908020443579465, 0.2714429027454147, 0.3734334627091059, 0.35547267626379897, 0.3550110906756798, 0.3935215145457033, 0.3313468468509265, 0.3671148481075856, 0.44201896070445024, 0.17961067156157506, 0.34238225072759787, 0.12278605478650559, 0.24392033589499154, 0.41780725268480207, 0.24048961512392683]\n", + "Loss\n", + "0.53365011075199\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0] [0.28739978560439616, 0.36280775095217915, 0.3472636525579941, 0.5501736450454403, 0.23763948525556144, 0.19704575253402096, 0.41942562960117646, 0.19514718135801667, 0.44361572499125224, 0.48059134890905997, 0.27464159152266865, 0.42515976230959207, 0.41994494949228156, 0.2519153176513088, 0.2369866989429475, 0.35836856279068524, 0.3813454080176372, 0.3346144668897188, 0.3784982891160505, 0.49712444288417296, 0.2100367763588507, 0.2811374313209223, 0.2818282173241043, 0.34893240170505974, 0.2412253015475282]\n", + "Loss\n", + "0.46791101608912866\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.14it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 1 0 1 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0] [0.1166080908042371, 0.23285841436229243, 0.1491194350964561, 0.32603712272022234, 0.25436436553593533, 0.5632621224934903, 0.3077311951448165, 0.7246053035818216, 0.32088698369836377, 0.17315192007074093, 0.43415906587876163, 0.40437874345258584, 0.19518594331486086, 0.46824099989213247, 0.26960496563216535, 0.32213785202997436, 0.1608075349713798, 0.18089613832088058, 0.319696016393196, 0.5515257455258302, 0.3320337235968034, 0.4898609748598822, 0.47432905305324213, 0.31318817556678563, 0.21023949143358847]\n", + "Loss\n", + "0.5885410570377506\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:06<00:00, 4.13it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1] [0.46582022262433476, 0.3723458357365397, 0.7985662908715331, 0.34008361453289465, 0.601382170828066, 0.4907255417564113, 0.20269192611037834, 0.3570096955733828, 0.31353045531977675, 0.34433946660009573, 0.26569027802950673, 0.44283247669915515, 0.2152033690498618, 0.1657896469958733, 0.35503247901146195, 0.229936362074208, 0.46004573396144505, 0.32136719078994275, 0.25798238040242544, 0.38325495865348697, 0.22634903710259396, 0.44722758569256493, 0.30148777943756333, 0.22486784012109773, 0.3063865575030408]\n", + "Loss\n", + "0.5365838996749019\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.34it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 1 0 0 0 0 0] [0.17008914007495637, 0.25731077413270614, 0.4548859735090597, 0.45776467526431885, 0.2371764213231881, 0.1897278869137794, 0.37269967783723323, 0.2202937725229689, 0.4050727850895174, 0.19240871455975905, 0.3924138754220051, 0.22482435714656396, 0.17913243869010279, 0.24200512298378576, 0.3823469414980931, 0.20310940611906847, 0.3280422111840855, 0.46000548829483273, 0.21147181982494628, 0.2727472979201906, 0.5390725133651193, 0.2560155607264672, 0.2694054465834687, 0.18385510531701998, 0.19087877509010132]\n", + "Loss\n", + "0.5079296740581982\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.18it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 1 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0] [0.41282879936726147, 0.34166022042887156, 0.16711885978832614, 0.293933842945807, 0.3534562763508921, 0.3961050998678018, 0.33644729547815977, 0.49665210237051094, 0.29332787386090164, 0.5349955263986093, 0.6366351109335846, 0.5682522141410473, 0.29969404209781453, 0.4479324595343947, 0.29214739806231027, 0.4559653219731424, 0.2799469001160261, 0.5254859845611279, 0.42731797408592564, 0.21831198098490365, 0.48767350314659874, 0.29568540650304087, 0.3397194869320807, 0.6393221964455822, 0.2788990721706763]\n", + "Loss\n", + "0.5399283214332288\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.33it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0] [0.31685783398709577, 0.37451112670134246, 0.18724747331024735, 0.4076859959730174, 0.2803147200746946, 0.22401458235702626, 0.32502695783635216, 0.25285054782658684, 0.18858971184984955, 0.2648296660798878, 0.5097693101877533, 0.5765496320168635, 0.18792660053015406, 0.41253947431833915, 0.36501239319787515, 0.2256561498451868, 0.2958272975664411, 0.5130734791980032, 0.32043564225375226, 0.3673249612853051, 0.4130095704088428, 0.44469562134424856, 0.5997338244984932, 0.21240330310714842, 0.1808150392996649]\n", + "Loss\n", + "0.5266928229083481\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.21it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 1 0 0 1 0 1 1 0 0 0 0 1 0 0 0 1 0 0 0 0 0] [0.4713992509245458, 0.3783469212820418, 0.3207060470942085, 0.467787291824187, 0.2924503867892831, 0.48553392133564477, 0.19853818083654695, 0.5509433917889195, 0.40819125258524513, 0.48125159338902634, 0.5579130786963601, 0.2908622531977835, 0.5487036951340905, 0.5869994186701883, 0.5095159990444305, 0.6089132946558891, 0.392749298388123, 0.446019786600484, 0.33532121370764134, 0.47097720779390784, 0.3453679712575347, 0.34920397645866824, 0.25662016735070525, 0.4259891496156958, 0.612672457185347]\n", + "Loss\n", + "0.6227262315712123\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.39it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0.2547728919388048, 0.3804261581862051, 0.5172991372348762, 0.4621089292913077, 0.611455882122396, 0.4856003870011876, 0.4489945545872605, 0.20916016344754476, 0.5387893546618032, 0.35105588973302665, 0.46050743360014357, 0.3595971239979474, 0.31338266833228867, 0.21029570629045768, 0.40799411738285246, 0.26584375758527795, 0.6219765570019401, 0.3214932422642731, 0.5593502976170656, 0.301529510406895, 0.22148041963918325, 0.4034165599921827, 0.4407657770070058, 0.17117716537807598, 0.3970674781805412]\n", + "Loss\n", + "0.533449260797153\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.29it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0] [0.19549163056322286, 0.5309207974081798, 0.39362531410515456, 0.20475601856434, 0.12347120982038687, 0.3541698659301371, 0.21493027820478472, 0.34603376001233715, 0.5272235816586701, 0.1978199503863524, 0.23720904548723265, 0.48810277286703563, 0.25477279895042726, 0.4648750158616854, 0.31697690905567266, 0.2016726731713026, 0.5589873143294287, 0.3665047963954319, 0.19110690509607614, 0.41225450105181255, 0.25125582761859144, 0.20965022420844548, 0.283825582182074, 0.21872939037416872, 0.2698439375504655]\n", + "Loss\n", + "0.39932965771038037\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.11it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 1 1 0 1 1 0 0 0 0] [0.28520521942335153, 0.3312113212478303, 0.3929058860568856, 0.26431235439636763, 0.5374259793793499, 0.3230923620053276, 0.3695181085750129, 0.28618055945501863, 0.33588952219565815, 0.5216591888897124, 0.256611609989397, 0.1924355180426852, 0.7159128225644736, 0.30451747567603166, 0.5654492014535428, 0.6338723302670065, 0.18331892904794253, 0.4276047271019378, 0.29868756836797755, 0.42907869885878464, 0.6563606611007528, 0.3772925703661654, 0.42613997999244096, 0.4045449803608471, 0.47511129504697447]\n", + "Loss\n", + "0.6103609121789184\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.57it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 1 0 0 0 0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 1] [0.28364266826572715, 0.4926862394592051, 0.3151546304138531, 0.33365873117884426, 0.2827845180318583, 0.4362221255332502, 0.5267231174989091, 0.4482838413015346, 0.5663312451871242, 0.39932364373852264, 0.3322221494288286, 0.24068413116664525, 0.33971048365095435, 0.36313530552828605, 0.4520250053035479, 0.3451528810230497, 0.48342193772127584, 0.4074072858273507, 0.3233250190586884, 0.17167579899380325, 0.24035236960217163, 0.31699105270047045, 0.535305703625031, 0.24736708092158835, 0.36870514677128663]\n", + "Loss\n", + "0.5984076729004326\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:07<00:00, 3.46it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 1 0 0 0 0 1 1 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0] [0.5352119603314303, 0.40071250759414195, 0.32779626308141985, 0.4734644016086396, 0.3819532113260762, 0.45300877383913585, 0.24760192990773228, 0.5251223925437503, 0.5170478207762655, 0.4025261481922494, 0.5889163068668355, 0.2947912736555935, 0.5547892460162507, 0.5683978963389029, 0.21061966669314272, 0.2887240358062117, 0.46243815437956226, 0.2693220749370572, 0.37719197346774314, 0.2811621449236997, 0.5568373822111277, 0.5856046234724708, 0.35598491625346174, 0.372081627800176, 0.36474249462657804]\n", + "Loss\n", + "0.5727855231408753\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.18it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0] [0.48401978103989324, 0.563821528875892, 0.42590030419978764, 0.313908086658949, 0.20418318696172266, 0.40584333541182277, 0.3313607405447591, 0.39150178000736247, 0.4930913286770988, 0.4900852109658332, 0.5949035579892624, 0.32528092274424875, 0.28959765200200727, 0.3982086676806537, 0.41418964103998, 0.3113036830998552, 0.49830848072232337, 0.3999688169716667, 0.3952330071478612, 0.349435175820061, 0.3536671481020385, 0.5341176145219109, 0.42098362670775624, 0.43383966190284423, 0.4237107866638943]\n", + "Loss\n", + "0.6103446695007086\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.23it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 1 0 0 1 0 0 0] [0.32698731594069635, 0.31417000644304627, 0.2910517862206071, 0.2569774079085812, 0.18377714556511746, 0.27203997627385695, 0.3746361541287121, 0.4674786610822109, 0.5079284136709448, 0.4719361089611496, 0.40460953486590057, 0.446850462502949, 0.19243300814471637, 0.3274090846462312, 0.27702826033958766, 0.4613758636255477, 0.256927984484965, 0.476190196240772, 0.32168200976538575, 0.2894067080972653, 0.393224656113158, 0.32151457710061493, 0.20951437118902982, 0.275931094208333, 0.5706267533401896]\n", + "Loss\n", + "0.5617689441882758\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.24it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 1 0] [0.4732194168670343, 0.31713330045826116, 0.3993262935116213, 0.2283425388859865, 0.20512332542577816, 0.21774266533021647, 0.22111939430393326, 0.4384924703054732, 0.36246992207484907, 0.5752290828103918, 0.31767669951887034, 0.3812455874273563, 0.3177994007532596, 0.385256239684015, 0.20737753800811798, 0.3311280627171276, 0.47161665618614546, 0.2269825570322795, 0.45966748066997487, 0.4059406048754991, 0.3918303943614391, 0.33293209559229564, 0.37920583239603867, 0.31511230997348366, 0.3040281991257459]\n", + "Loss\n", + "0.575211098781069\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.32it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0] [0.511531418291707, 0.2910915151001859, 0.5383357728883009, 0.29743860068537575, 0.2678848013222837, 0.4689216905477181, 0.5002912125055374, 0.4372210437492676, 0.19414134781576797, 0.15454748477767172, 0.5816168360632801, 0.5696919187210128, 0.29855908475368836, 0.29921616100144655, 0.2581246801470779, 0.4275108072467987, 0.3374881403434067, 0.20119095171755055, 0.2768029951958806, 0.6030809792889879, 0.4039967490959382, 0.4779928884496826, 0.2891338605153062, 0.519723825646957, 0.4501150373626767]\n", + "Loss\n", + "0.5104016120949666\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.13it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 1 0 0 0 0 1 1 0 0 0 1 0 0 0 1 0 0 0 0] [0.20354231023320518, 0.4417076660816024, 0.2134469925010923, 0.4203904907202823, 0.32952299947323954, 0.22863004572895207, 0.45985257869481444, 0.19407626963105012, 0.5165738331224623, 0.3257888000960214, 0.2501765078693101, 0.4816344735935858, 0.23407095187626653, 0.2832979911575429, 0.4575999943595184, 0.44273502501175876, 0.32084570742941104, 0.3786855309061769, 0.5759226597565791, 0.19189226149956232, 0.45340405122863003, 0.27228221975173134, 0.3453212380766607, 0.2908942499662926, 0.25510811123830873]\n", + "Loss\n", + "0.5417855944903984\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0] [0.4584989610744503, 0.31811754845866164, 0.3248732910097147, 0.6737914801784745, 0.34596741591381264, 0.41397820421332343, 0.4595580820908803, 0.5105903960619202, 0.2872483604391442, 0.3646980653651311, 0.617332488061397, 0.30291591760018355, 0.3463369681338638, 0.28781315638655464, 0.13424916508986215, 0.5064993240450271, 0.36137125441345674, 0.4783123422634619, 0.42761326611294015, 0.33078256652661364, 0.2443210200703319, 0.22506864180480352, 0.3081095067907856, 0.3097867814289068, 0.39547789984781834]\n", + "Loss\n", + "0.4932757497189705\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.37it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0] [0.5005777019453568, 0.38027373995369546, 0.580878033528621, 0.30467304157933317, 0.2913235653103464, 0.45866593312960563, 0.15572829917885467, 0.412204562656464, 0.5818352138195779, 0.34051881281734286, 0.3532986279078704, 0.45764869481429665, 0.5895947305930033, 0.2661041069769167, 0.4233640001449838, 0.4870928938143031, 0.6347337514958522, 0.5684462457996526, 0.6610687741560244, 0.19887624845418572, 0.3668382550296754, 0.30947254838563476, 0.5182854469995648, 0.7639739891516273, 0.26849002171543146]\n", + "Loss\n", + "0.5698638934919297\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.14it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0] [0.21044428357846484, 0.5353962616772903, 0.4963888296290724, 0.42858591079104114, 0.38253903114623333, 0.39938250944185777, 0.48112812016849515, 0.24273912300850126, 0.29192827219212236, 0.442882943731739, 0.2905795839984147, 0.2272683086546534, 0.24926303399321664, 0.5060718889912963, 0.2032520181820331, 0.3466256870646747, 0.42737836088991193, 0.30210945264388833, 0.6394309903649115, 0.19913896743484477, 0.17470574100861624, 0.3221270746341736, 0.5080504956066517, 0.48792596106751907, 0.39131954869345137]\n", + "Loss\n", + "0.5091632400352943\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.30it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 1 1 0 0 0 0 0 1 0 0 1 1 0 0 1 0 0 1 0 1 0] [0.5955071637182237, 0.37694352723059416, 0.4557049650269383, 0.20684211016557624, 0.36952712223279793, 0.3176911006362709, 0.3802972312708427, 0.21935262335562716, 0.3125213578053787, 0.2668178765349784, 0.39951222825302135, 0.4564196467387206, 0.27157219525634047, 0.4125901382931505, 0.4133373694775989, 0.3855322011954009, 0.26049990385405686, 0.2764106692618034, 0.384047940382775, 0.38834734332309295, 0.13363534545060402, 0.3631376444814981, 0.32187838807710384, 0.5302566011535998, 0.26973670180788756]\n", + "Loss\n", + "0.5928632225598061\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:06<00:00, 3.91it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0] [0.4420339410911929, 0.39520974337465686, 0.6197050332420448, 0.4454535743878772, 0.48390196431051286, 0.5544364944929059, 0.46571772383647403, 0.4948154298464023, 0.5354894802337692, 0.2502704876512177, 0.5202143616937138, 0.3742098578852481, 0.3893789888654027, 0.536082288824066, 0.3648803638383359, 0.45480575041714466, 0.36399120100634574, 0.36697263613920705, 0.37557287559751784, 0.2823372850002534, 0.6453194679888876, 0.20674662503943272, 0.462186277598447, 0.5459345265512606, 0.3115207947052525]\n", + "Loss\n", + "0.6081439674106455\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.29it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0] [0.4430737069030667, 0.1858646917701331, 0.19254246220574497, 0.4348998426652589, 0.3555306867040342, 0.34228938053949826, 0.35728987323768446, 0.23982488257433082, 0.36532933314641275, 0.4048760853546357, 0.2342380934761562, 0.14874365679940377, 0.42644479801892643, 0.32999380801924566, 0.46756429221623996, 0.26512723920720566, 0.24922679644021506, 0.28254324643284007, 0.4920850617519363, 0.15974888351947825, 0.07381028622772035, 0.18653336928748418, 0.4284255894911534, 0.29155932455674116, 0.33298190065899386]\n", + "Loss\n", + "0.4229607390520711\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.79it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 1 0 0 1 1 1 0 1 0 0 1 0 0 0 1 0 1 1 0 0 1] [0.25290043859345057, 0.16691356862626985, 0.4043094859240721, 0.1892836952296002, 0.30616366065412004, 0.6368530635085738, 0.20774609819901665, 0.26551113094191897, 0.36579591960409213, 0.386034471480728, 0.23424823826633162, 0.3548673151082866, 0.14885380470347614, 0.2555794563927272, 0.3665223537099418, 0.29397086495577834, 0.4082599323339161, 0.40098417082815563, 0.5704249963695825, 0.2808886676148515, 0.4010115438916538, 0.45625861457483335, 0.2425079752526268, 0.21982063811033575, 0.4916223304757307]\n", + "Loss\n", + "0.6388832760772822\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.18it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0] [0.3201196450644189, 0.26640058240064096, 0.29280592628879004, 0.5273987110567004, 0.2639097999054483, 0.1862019728972542, 0.22470162395277793, 0.5002072751692062, 0.14295330435739675, 0.31398783687284104, 0.3393342466074118, 0.13419101783569906, 0.4428586895575576, 0.3667195916821687, 0.24266779584069412, 0.21703219759836578, 0.45951715502769774, 0.12295724698475015, 0.24051362299661957, 0.5152686185854503, 0.2942234422579017, 0.37609039492096363, 0.31582351030808536, 0.3277370321754593, 0.21898107120348193]\n", + "Loss\n", + "0.5259676919193843\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.16it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0] [0.35813178549195257, 0.36490768391205297, 0.4775489226881117, 0.44003926233099244, 0.637609970475058, 0.3156896388961821, 0.35217399974401414, 0.5212010812998582, 0.44997056846785344, 0.43711016962695387, 0.3004121921545305, 0.40495492706255065, 0.5210670836027308, 0.4923838925347529, 0.137996401982666, 0.5817868712318264, 0.30270563216317914, 0.38659008162624375, 0.42170147888665316, 0.4063148147694634, 0.4901651494714865, 0.5324638931493016, 0.4162401104384651, 0.3878993549909036, 0.3693654011595282]\n", + "Loss\n", + "0.6222429493084956\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.24it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0] [0.3613269119241675, 0.27553264151882617, 0.556332025541354, 0.264920928360856, 0.4851482121520407, 0.25651313517103086, 0.36115360886412096, 0.4597318122835928, 0.4165742995344238, 0.41940015185128215, 0.34586462236333826, 0.25801719074331336, 0.3934537840211493, 0.5021444932769814, 0.2469374483563625, 0.3003559543651572, 0.27459481493918425, 0.5306234127545526, 0.4606076930709735, 0.35338894839449475, 0.26762695308172285, 0.4255007750459878, 0.35429668215682875, 0.19667598174004475, 0.4675517041356021]\n", + "Loss\n", + "0.5498456310275086\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.19it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 0 1 0 0] [0.3729873544912892, 0.41155335142697336, 0.4712515882431627, 0.4115346460577253, 0.3049115130361036, 0.43046807841649476, 0.3612961603642385, 0.1733738896612128, 0.42499283677566313, 0.2736114198978266, 0.5171662916761341, 0.2603354629884507, 0.2209208581059258, 0.28202240673915274, 0.6075363335718362, 0.28421411705693417, 0.3930904972256354, 0.3651026675003695, 0.3959667845400988, 0.37918499939668415, 0.37644963527380304, 0.26663561768846605, 0.43313509497252684, 0.4386029337622933, 0.5264333695458441]\n", + "Loss\n", + "0.588180648992632\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.14it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 0 1 0 0 0 1 0] [0.14884270741704564, 0.36822591266104343, 0.2919369456451784, 0.1613194878849371, 0.1490241251850555, 0.25500253795562766, 0.25688722306297246, 0.4799985185106404, 0.4801220982990417, 0.26501725945330357, 0.2199535798582279, 0.5441750358192818, 0.3297542431315666, 0.47738758187883157, 0.38801115403425135, 0.2568626519336329, 0.5090881167417738, 0.4765327253062697, 0.4662948181635126, 0.38683850489119775, 0.28135238757993636, 0.3415848035463651, 0.24897196882061387, 0.32561554697054873, 0.285434556271989]\n", + "Loss\n", + "0.5067088505646095\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 1 0] [0.24625512404277752, 0.2462981593949584, 0.22983788897414525, 0.37921744632585647, 0.20409024972934428, 0.17940911078116384, 0.3461857754946631, 0.30849567140238626, 0.332862372189897, 0.22865425676718643, 0.4524763502638156, 0.27184939411887526, 0.2950326953108659, 0.4299853277778143, 0.5730886251208307, 0.46806000825528815, 0.20676707814968542, 0.20143285262295568, 0.21516018854635974, 0.2843561019752331, 0.18738922347145895, 0.39208138766800893, 0.2535566451958483, 0.17618577375547714, 0.28450970475237747]\n", + "Loss\n", + "0.6050161513246813\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.23it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0] [0.4391894098920167, 0.662640051286044, 0.27113367033714614, 0.41090590202704835, 0.5168239502949229, 0.4766351770407503, 0.45639411461623447, 0.28086052527286137, 0.2563241124262114, 0.46943413779918813, 0.2750218481516089, 0.4660730820183997, 0.3942084256423864, 0.4042882020503485, 0.20373424266450993, 0.31074196203125987, 0.26261842507644495, 0.2580285115248057, 0.4627508938769428, 0.41770858621113555, 0.4944536294031928, 0.4324549091436286, 0.6011904587065898, 0.49734720627429685, 0.23464519234468587]\n", + "Loss\n", + "0.6080320820733537\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.24it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0.19861017797586988, 0.2163254578029424, 0.5059118836811026, 0.5417990642791297, 0.31842530767329735, 0.5346347557732876, 0.46905280344054656, 0.4543575454215485, 0.4076698305835798, 0.3370636445841664, 0.4014869944581012, 0.4954843992735604, 0.23776235455499906, 0.3336955068284575, 0.6188284172310288, 0.37535799876394926, 0.3826254125431981, 0.40056154402887845, 0.35327847728894585, 0.3186761336678008, 0.5788502944789881, 0.44866165024402804, 0.24478415526679975, 0.25086108199099, 0.255056608133568]\n", + "Loss\n", + "0.5255624906589909\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.28it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 1] [0.34624723076888575, 0.2551082006289983, 0.5435826275787223, 0.25086792702829486, 0.2778723200603402, 0.603514206891626, 0.4511551656001711, 0.2075463425687216, 0.542881249066028, 0.2667160277679815, 0.3465829963497688, 0.49872127681383044, 0.25827983211821975, 0.3038825646822295, 0.36240759889853025, 0.3688381425430311, 0.3615301087578653, 0.2403572873289223, 0.2838704763420709, 0.673720656806265, 0.6101216375868628, 0.24177958110539827, 0.5631334421469396, 0.40008897220083794, 0.4635940018796856]\n", + "Loss\n", + "0.5879309922996583\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0] [0.4842373271686802, 0.2307065929885675, 0.2897568965229526, 0.2975571021283536, 0.45001311737786576, 0.38716451326031764, 0.44301068594858095, 0.5661019765790765, 0.4568085857010303, 0.6498127402658684, 0.29344362219581976, 0.5095941728810865, 0.14313395280843483, 0.39421725113527273, 0.38983357796716767, 0.4951655978807999, 0.24130883028646133, 0.25433633343474243, 0.20822331365984909, 0.37411898440460695, 0.3784137426916895, 0.4212594898431623, 0.25522794506928204, 0.19057184182689435, 0.4577662616041194]\n", + "Loss\n", + "0.5220322296878352\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:05<00:00, 4.44it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0] [0.35338388492298123, 0.5000449872133323, 0.23089704033880165, 0.2583039920724605, 0.2953015266897089, 0.47734608473132145, 0.4609735884677204, 0.35122162742903973, 0.39268358032529826, 0.18689011987498474, 0.38590626048468174, 0.4994423527817656, 0.5235943828023552, 0.45340479350742013, 0.2748922039029307, 0.3312399272529256, 0.38288902343826003, 0.2769471209304062, 0.356333129221284, 0.2538581465599312, 0.49728579652059857, 0.3016346329065612, 0.6921439129681197, 0.40755228779561087, 0.41968532611007237]\n", + "Loss\n", + "0.5119865937778176\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.20it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 1 0 1 0 1 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0] [0.342559690331089, 0.5236431241218416, 0.39628886395541474, 0.19335613663550102, 0.2837828204639113, 0.4703759078942138, 0.4284506600136497, 0.6608366696220808, 0.39360841260107926, 0.4449489284749565, 0.21687905101233224, 0.2523630166994392, 0.3973889347609008, 0.5040277695734428, 0.4847747962056561, 0.4200890739814074, 0.36510889020303045, 0.5516686879068586, 0.41421620515569646, 0.34385402034795975, 0.4656760746011727, 0.2762120873200823, 0.39613727954647066, 0.3310853425015312, 0.36579512368023487]\n", + "Loss\n", + "0.564162258313717\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0] [0.4589448569550353, 0.26566084787533323, 0.22927664736496245, 0.510035275562386, 0.4540486682493762, 0.42858704452122454, 0.3354855171511124, 0.5684283855765744, 0.26894785488905293, 0.44962605094435315, 0.2517184471361147, 0.5394308401219512, 0.38460967475631747, 0.4450967197409512, 0.566292007133549, 0.2357463320856374, 0.2067789192054524, 0.44014483220069456, 0.40086801305300174, 0.402581810547434, 0.3788010251467508, 0.3528894586974961, 0.5416896442835829, 0.2822508853652364, 0.366028102967136]\n", + "Loss\n", + "0.5671493018138115\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.20it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 1 0 0 1 0 0 0 1 0 1 1 0 0 0 1 0 0 0 0 1] [0.34499165144241833, 0.6816553336956847, 0.2589062376634626, 0.24132515858101444, 0.35496997424297866, 0.39766564049027897, 0.6413573327805075, 0.7374894372578197, 0.5085210496605679, 0.186467037055655, 0.2784195337723493, 0.21245062189641079, 0.5525829519725585, 0.35019661442591365, 0.4366646307274816, 0.33242558254593413, 0.1349768988035671, 0.2929192112385002, 0.5258518214517556, 0.47418339789682024, 0.24771828946237429, 0.2845859991260803, 0.28490927792303056, 0.1754545303688279, 0.4351034018006982]\n", + "Loss\n", + "0.5932082204148282\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0] [0.5098742797573447, 0.34386704543332935, 0.4636366414127328, 0.4357659143005347, 0.44827906466392264, 0.2885432615094855, 0.46079745909019365, 0.46701787560357194, 0.273456451903569, 0.4724631365349622, 0.36484001836439894, 0.3084578924899501, 0.4788900604962193, 0.4064569596343399, 0.31208652027615535, 0.4212414791128897, 0.3365814291772728, 0.3787332680451353, 0.6476870633735803, 0.29032882975014473, 0.3129898512961542, 0.20470697904842522, 0.4570112210980386, 0.2763313493862599, 0.3997811504797958]\n", + "Loss\n", + "0.5723140615821187\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.40it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 1 1] [0.4587187410029443, 0.40928647691885633, 0.2635596711053038, 0.22975354990945282, 0.3967719471789216, 0.4798898654545906, 0.3998618927942513, 0.620853557309515, 0.23660055938147187, 0.27043406067989656, 0.4138099180568078, 0.35095347078742756, 0.4105980696929751, 0.26004990401421385, 0.42854274317392416, 0.47231393174993286, 0.3548794271120392, 0.3217087085986659, 0.6763532488559285, 0.27538243170112797, 0.6635963925239381, 0.6275009302908465, 0.278485987401268, 0.37457399356944604, 0.49440568700734067]\n", + "Loss\n", + "0.625523667652792\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 1 0 0 0 0 0 1 1 0 1 0 0 1 0 1 0 0 0] [0.2259737990495084, 0.46613560065830373, 0.27302224170123834, 0.2857052834113135, 0.2049352641431454, 0.4637144332007915, 0.33575046812458376, 0.5005483164901555, 0.26043713582528877, 0.4051586973184169, 0.5930972162566825, 0.28290184321854445, 0.46871912096621615, 0.275642270177589, 0.38823798263827025, 0.43339297950318745, 0.31168904754305665, 0.5493793882610989, 0.2536611818655393, 0.3320096364472244, 0.3973144443604305, 0.23329461717043642, 0.36885223948267293, 0.3249501263366549, 0.29113322270731307]\n", + "Loss\n", + "0.6257360322701057\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0] [0.22906161776508693, 0.456143452858393, 0.355919546470794, 0.7324442762103764, 0.33260967767768557, 0.44279507078874314, 0.5116971322663821, 0.393490966225872, 0.2712019570515655, 0.5733836407408478, 0.41621172739033235, 0.48806297511212393, 0.19167520698611426, 0.2968452303462556, 0.5440197129403526, 0.4548005983270972, 0.29354263870490505, 0.37247943618190926, 0.5610143022391185, 0.4882459662731552, 0.2703245813830587, 0.217427526932321, 0.24155566804834003, 0.2825819805614949, 0.5669657393471044]\n", + "Loss\n", + "0.5672939629626144\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.27it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 1 0 1 0 0 0 0 1 0 1 1 1 1 0 1 1 0 0 0 0 0 0 0] [0.4065324998453015, 0.40528464331729697, 0.3448841622117507, 0.5755028792767087, 0.4863468717025396, 0.3235850497157585, 0.28891048201827685, 0.21101003642893765, 0.6565101216816709, 0.3751482740719252, 0.31421942625311505, 0.471485805566489, 0.35509027103214963, 0.32580272898506, 0.7124506935001863, 0.2809961314776041, 0.489563737740958, 0.4239550185256047, 0.5991837430003344, 0.5823759779526019, 0.2709112213350293, 0.3274688097394671, 0.2934391683242277, 0.4685579646200807, 0.29247596688825145]\n", + "Loss\n", + "0.6573091060678599\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 0 1 1 0 1 0 1 0 0 0 0 0 1 0 1 1 0 0 1 0 0] [0.4874109786743642, 0.40765408205724163, 0.40659402295611957, 0.6683781977179005, 0.29213611584135885, 0.24030137581006614, 0.4610062638038247, 0.4917647342706687, 0.37642037105742104, 0.27219488166755534, 0.45676373914539026, 0.5158813361573482, 0.31029051979295563, 0.20514059843612525, 0.5348872180048297, 0.4198838148627013, 0.48975603307547705, 0.36761903312736016, 0.37675322033357733, 0.30628703490839176, 0.15989976834419453, 0.4271039237213497, 0.2860151458059087, 0.4531081608764877, 0.31029051325304663]\n", + "Loss\n", + "0.6837929322195414\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.25it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 1 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0] [0.4306538026379048, 0.3161003932862271, 0.19278469240393065, 0.3903806519466912, 0.4015205244596922, 0.4316936422295392, 0.28677761493910475, 0.34267676692954674, 0.23463296502278697, 0.29367472811466677, 0.6176268089792343, 0.2715623738665731, 0.18642635770488517, 0.32845768393992825, 0.19719240636229557, 0.41740922645185274, 0.3856880644415962, 0.5110417178951031, 0.4515180555447038, 0.4130105999041319, 0.5097406364514208, 0.2916699969052607, 0.3911086968704943, 0.3419979592878614, 0.20382691186430396]\n", + "Loss\n", + "0.503883535716793\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.40it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 0 0 0 1 0 0 0 1 1 0] [0.2854343389423734, 0.22341914660986625, 0.15144305609980174, 0.34678595094441483, 0.5707771967564699, 0.2078632859002025, 0.429969550123765, 0.4994865401013099, 0.5965663861271703, 0.36963300864673104, 0.45858015155034776, 0.19201548354326606, 0.6443496289338823, 0.295953108592948, 0.49498352421061403, 0.7247212768759308, 0.3111068340542225, 0.4849442502373036, 0.47035578553260493, 0.28363825664636344, 0.46612237944004875, 0.2993002788327958, 0.3903570479376789, 0.3136043757078111, 0.34750558146264743]\n", + "Loss\n", + "0.55523675198344\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.34it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 1 0 1 0 0 0 0 1] [0.4550034045796181, 0.4024069912446461, 0.6028327843394405, 0.41858391737020173, 0.4267099865639714, 0.5267490109209085, 0.48206709413869286, 0.39796209275372424, 0.3094145966918649, 0.18657724529205788, 0.48007499996774394, 0.7007848978234428, 0.43515522958371133, 0.5578285067871955, 0.3764653761989042, 0.3727024654918156, 0.25677072063962714, 0.5462407597946706, 0.23138629002775107, 0.5088844367723425, 0.4703608242421737, 0.1972762196564329, 0.2255149564046599, 0.3542248892388192, 0.4545947724030077]\n", + "Loss\n", + "0.5319766608494801\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.39it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 1 0 0] [0.3029307116448536, 0.6725128579376702, 0.5371318684479938, 0.23568331232813136, 0.28690517028061835, 0.36205187904126335, 0.2952704790785773, 0.4786520181644036, 0.15512626432530247, 0.613420263220013, 0.09844454189486934, 0.29256150265238445, 0.47244628137488826, 0.46511186812332483, 0.33562180169711975, 0.49304195496657705, 0.47662782299665524, 0.17320583673569304, 0.35457578673634443, 0.41963038320287094, 0.38111657957619643, 0.2731029924182975, 0.4839762106832507, 0.27369712744796565, 0.4582376373000071]\n", + "Loss\n", + "0.5594094009733912\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.44it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 1 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0] [0.4072387773594184, 0.408185166868005, 0.3704243331726294, 0.43546573358095636, 0.3548080860566547, 0.26694791237048443, 0.30340194514772295, 0.1860958864123046, 0.5023584824705679, 0.3398371429657956, 0.20395478408938805, 0.5658285297700361, 0.6157822425173605, 0.26804346491282727, 0.4650543371031943, 0.26680900299481325, 0.5337880158331658, 0.35638320609718654, 0.32658013603376373, 0.24021359570060902, 0.6251326253817966, 0.29949256615899145, 0.4715226691953611, 0.29656168409688805, 0.34867600303884094]\n", + "Loss\n", + "0.53318608803566\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.32it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 1 1 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 1] [0.2374903903059873, 0.2777813135380293, 0.3411222449133261, 0.28043357013457876, 0.2769444111123329, 0.27565857110148195, 0.553924468144404, 0.4719934033746668, 0.36502611440933375, 0.3122498245780688, 0.46626381129192146, 0.6336717341415739, 0.35483175674493794, 0.2907714765152037, 0.36223784959220195, 0.3709600753930126, 0.31703186234003566, 0.2617398952673643, 0.40417477902971377, 0.31480530545545016, 0.537712786198294, 0.3118822574173347, 0.5476599801443977, 0.443599862973186, 0.46551906718675606]\n", + "Loss\n", + "0.5708355744094075\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.42it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 1 0 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 1 0] [0.2794817092559835, 0.3049865880525296, 0.22121631903700137, 0.4838659687422586, 0.3812426612092576, 0.27394250008270427, 0.3796572159522169, 0.24206434377879282, 0.415057838450637, 0.24509217941954492, 0.3936008439956759, 0.35226119293616276, 0.34588876428699283, 0.24070601391642063, 0.3597498822396854, 0.24581260348934564, 0.3927120620133214, 0.24337135246469196, 0.2241961257383111, 0.4346055081572392, 0.39988599509396805, 0.4165168211443475, 0.377125346539378, 0.43956324487380555, 0.31486417415241935]\n", + "Loss\n", + "0.5191758491624942\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.41it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 1] [0.23487577852542899, 0.2937624263484869, 0.28484763107045097, 0.31609470136650314, 0.504019649508362, 0.41246186230899906, 0.24725163894952817, 0.2869534477519903, 0.47798895149809534, 0.469155961926953, 0.27639816396634653, 0.2911064581377919, 0.4092599466539797, 0.21005559854245714, 0.3076964627651282, 0.2550857375280304, 0.5023109042168485, 0.5607005341508147, 0.649141586813452, 0.44610967984059247, 0.26138594705879636, 0.29610936545459077, 0.4752722836536353, 0.3100669445870144, 0.3159955631192477]\n", + "Loss\n", + "0.47847541670798754\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.26it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 1 0 1 0 0 0 1 1 0] [0.30786126124593216, 0.4558775304027567, 0.5950277424637225, 0.2891689345573553, 0.3822088622634321, 0.495286955158686, 0.2863884416418506, 0.3101955814035088, 0.4684153149681554, 0.41410104149629323, 0.11844597264511003, 0.5084504997391166, 0.4084242505596338, 0.5389924501587189, 0.2652434208343567, 0.5187960423240754, 0.38334002118713034, 0.24554805787661463, 0.4361345585574841, 0.4947508338430574, 0.5372087563970813, 0.3825617349737256, 0.37305404256424257, 0.4576671710117691, 0.2579656202396821]\n", + "Loss\n", + "0.6541377228415368\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.37it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0] [0.31326938827327555, 0.2561655765095824, 0.2238399712535663, 0.2755630910208595, 0.24596758087044182, 0.17115167454251612, 0.45722994947537743, 0.21243949051339547, 0.6064338435859076, 0.5703871808987849, 0.39121088275734556, 0.27168248453880683, 0.21396677183483614, 0.17314959355132004, 0.5331367467086929, 0.2568063513752424, 0.27535352423829035, 0.6564571430157717, 0.2582127440149655, 0.3470922426301329, 0.539266763644767, 0.22970378128974914, 0.48111461955867935, 0.22772023252626045, 0.4718697401744505]\n", + "Loss\n", + "0.4489687103252303\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0] [0.2763247293026467, 0.27753533551180176, 0.24140129734053184, 0.49246840354544685, 0.48333809512146514, 0.3110712206539013, 0.24534768069587098, 0.2774563395658926, 0.5319473894916995, 0.22647908703870612, 0.22904011930235268, 0.3097679013010772, 0.39793707962325203, 0.4754269538966829, 0.5777557199728691, 0.32724199186647507, 0.48438047539554285, 0.42211017457871947, 0.47003613215153306, 0.6747870483581206, 0.5468288793003417, 0.38412404467539607, 0.24020860168694927, 0.2826841246597908, 0.46813977384934036]\n", + "Loss\n", + "0.5101709212398042\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0] [0.33476714866296897, 0.4695854870030304, 0.3540539676263318, 0.4850281190710748, 0.5748113533899537, 0.3963407021272704, 0.2560090857755006, 0.3695020627002438, 0.45601609992621955, 0.4387173418620466, 0.33945053822694354, 0.5720440448571305, 0.4133403943915796, 0.37710842194106997, 0.412776446881589, 0.21991401127358962, 0.26399891721757457, 0.2938895408078156, 0.45226658993711444, 0.31696908413884306, 0.4083234099646236, 0.303708909985716, 0.3270447356683235, 0.5745119828912805, 0.3465857488037399]\n", + "Loss\n", + "0.580110022342041\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.43it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 1 1 0 0 0 1 1 1 1 0 1 0 1 0 1 0 0 0 0 0 0] [0.48755907504485085, 0.38921457849189534, 0.3686453053770695, 0.2664103896488317, 0.44544783777364777, 0.39322741070488587, 0.3931574604490279, 0.42914023241952876, 0.3075622645894014, 0.365663064315066, 0.5306379917208914, 0.4562547000819376, 0.6459488171748391, 0.4404665759427797, 0.46516004560894453, 0.2829323053541594, 0.41504002654695393, 0.48611602898394735, 0.49727508227032124, 0.4272457498148128, 0.27948306093010217, 0.2381298894265002, 0.3221629084358746, 0.6396086892421532, 0.2077822442830013]\n", + "Loss\n", + "0.5893575025890542\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1] [0.4761737468572701, 0.46335403884286563, 0.3124056151948978, 0.20889555167306212, 0.3259188152544734, 0.2690302024475903, 0.23921056511158356, 0.24388726938506664, 0.2820628635390516, 0.5336436399441695, 0.1556627431633497, 0.3873732367557685, 0.24434868867436346, 0.5775867569209762, 0.4333311558010891, 0.3737391874766227, 0.2830126032905617, 0.4505342485176952, 0.2643667253341768, 0.6251433034376424, 0.35949099450661326, 0.3848403643229422, 0.3552200313366326, 0.6835022474134604, 0.4732689023609927]\n", + "Loss\n", + "0.5401399775064768\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.46it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0] [0.4591939177252313, 0.6202784313860856, 0.32275716894155604, 0.47973549171418417, 0.6184243407048905, 0.4663123357697524, 0.4672384861164829, 0.3705270045104539, 0.28603769277411845, 0.361209481315273, 0.4597220307595333, 0.4004037459772542, 0.2685388208981012, 0.39593958875403884, 0.21149298778255116, 0.4506681339259347, 0.35670221444130523, 0.47834646417067933, 0.2141269901524909, 0.1662824443615835, 0.530336107937883, 0.20157107778115488, 0.2193679352259913, 0.19566911537463183, 0.26702045300309935]\n", + "Loss\n", + "0.5221044196453131\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.46it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0] [0.49907967212377247, 0.42151075205689165, 0.3618429732120282, 0.4015378008033015, 0.49782646328517394, 0.46666653163553307, 0.492533935121576, 0.372950880554099, 0.40390293538863836, 0.2232063664870488, 0.23078741810583384, 0.23601810715562177, 0.3787747524891755, 0.4899107501452352, 0.38713714946538624, 0.6044147146571415, 0.633634846034287, 0.24064503096148418, 0.6625101958957433, 0.27492663959102565, 0.5395955121676737, 0.47952015661756187, 0.5637826818255206, 0.5281631160540776, 0.27572449253924886]\n", + "Loss\n", + "0.5805412089099845\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0] [0.5988278981856332, 0.4500141228739078, 0.3939524088657773, 0.37879717250534534, 0.561616266079152, 0.43164534267396043, 0.4530224575461337, 0.28753725857550394, 0.22490197504586384, 0.4045665054829799, 0.39939662560296996, 0.28973459026201, 0.4644572684669657, 0.5023114266288122, 0.30673980003193196, 0.19464951704410105, 0.38732741418366556, 0.3476069388842789, 0.2790825550884747, 0.49216392779984575, 0.5834746511575599, 0.5036202475280993, 0.2267606154463004, 0.23930797753600325, 0.4555246046929717]\n", + "Loss\n", + "0.5904759058598446\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.39it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0] [0.23771062663551024, 0.4801890644886302, 0.6442113053065759, 0.3588200312444634, 0.5684923001326601, 0.3433520486333863, 0.2801505220506256, 0.4051399915272826, 0.28313579917683673, 0.4574725114055847, 0.25344019857837563, 0.4661412415456311, 0.24423831182346364, 0.5787277638967014, 0.3247281336437787, 0.3337208727288321, 0.42466053912837187, 0.4325343836132765, 0.30461664096147045, 0.24776779868353055, 0.23099535940355706, 0.43978518052264914, 0.6691778625561848, 0.23499119731240473, 0.2825801350974801]\n", + "Loss\n", + "0.5049127742884032\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.34it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 1] [0.23555327814535978, 0.3938520955733311, 0.2502713112487151, 0.34530019966396075, 0.25416822308327314, 0.5041486035814842, 0.4667297886197652, 0.39413733101886844, 0.2515688768341789, 0.3882236270057972, 0.4028007988823741, 0.34229087342737474, 0.21572595543181722, 0.1995397207986096, 0.2751848336948765, 0.34128507088354304, 0.5057246765727201, 0.22366951378561378, 0.3292985260796535, 0.5055076642478623, 0.3714621512072047, 0.4435926392250792, 0.5008345412206341, 0.266133796832484, 0.4837243057952208]\n", + "Loss\n", + "0.4837325910955243\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.31it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 1 0 1 0 1] [0.26880316495604784, 0.21978215361953946, 0.3523494648361227, 0.473904604071491, 0.34319068593722646, 0.18146679112761352, 0.2635912588466722, 0.5441855724888387, 0.4854594526090723, 0.6227765654878945, 0.40029667703628236, 0.42419009824437426, 0.3919867345622857, 0.32287063785980646, 0.25159358611484556, 0.2778232730156857, 0.27709696142104645, 0.5759273991638778, 0.564656040778249, 0.22674280941035746, 0.42730940760368247, 0.3531371393366176, 0.33976459069860804, 0.34631958213113145, 0.40446290546125324]\n", + "Loss\n", + "0.547149692646935\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.44it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 0 0 0 1 0 0 1 1 1 0 0 1 0 0 0 1 0 1 1 0] [0.344184738540878, 0.26544251313584305, 0.30693316754896904, 0.2797472949745911, 0.4893461442931555, 0.23878049053387904, 0.3395029185072831, 0.49556574419176125, 0.4620094951435631, 0.4600140112125587, 0.2610499953038929, 0.5368399353582775, 0.3715038576915887, 0.4194094332764476, 0.34711566173704667, 0.24687634276463796, 0.3449702445112335, 0.2447231537182194, 0.25248316167895546, 0.24389982547243275, 0.4722649200104047, 0.25170446013175, 0.48369260203798686, 0.3851749109244691, 0.35897317469875956]\n", + "Loss\n", + "0.5389783595886454\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.44it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1] [0.39788656948016254, 0.5453614376312044, 0.6838838487941593, 0.4596594961595248, 0.3569639810054452, 0.28494396358705876, 0.3743798245445423, 0.5791444192447648, 0.27548994037032815, 0.4069793809715258, 0.6385837115044033, 0.46270347303470694, 0.30634619028764515, 0.6756330929784163, 0.3098232449651085, 0.2886335111258068, 0.36750402918195546, 0.42324979800430196, 0.1886760735113156, 0.24133541060922284, 0.5369488700324706, 0.35563040798649687, 0.2567024240496755, 0.25056143692138966, 0.4883070585573208]\n", + "Loss\n", + "0.534423244235851\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.35it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 1 0 0 0] [0.35076680931453325, 0.36813945599689624, 0.2423008392452746, 0.18812807716006574, 0.2741288557364272, 0.40148732322449776, 0.42163933600459613, 0.329607450333196, 0.26356990566803096, 0.4759152674455227, 0.5640930174457641, 0.3885014948361618, 0.597749319888975, 0.4028823618989008, 0.23100405580515906, 0.27134684351103855, 0.373033569589572, 0.2927722266626428, 0.41314764477866184, 0.2987216925188219, 0.3918132763245623, 0.3864632673719498, 0.2850218053481738, 0.4891666657413192, 0.5448604178279075]\n", + "Loss\n", + "0.6419530802497471\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.43it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0] [0.48963531856240783, 0.4391148284280446, 0.35634798733839523, 0.39165174707074946, 0.39132333770734223, 0.34198386144068627, 0.3774931297115475, 0.5566448241082393, 0.2526672732899332, 0.2656629134831282, 0.39594157505373406, 0.22125618866703323, 0.4089212659039269, 0.4595071213690432, 0.22659398064216063, 0.23685276564383187, 0.21638080778056248, 0.4768234104436464, 0.3471715349282979, 0.255438046482327, 0.2194226672864823, 0.4216469353722725, 0.41813203877179345, 0.349439869075088, 0.2930366659695531]\n", + "Loss\n", + "0.475827482273573\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.42it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 0 1 0 0 1 0 1 0 1 0 0 1 0 0 1 1 0 0 0 1 1 0] [0.4053722767037281, 0.37989143236862194, 0.47323504508327285, 0.49078394465976377, 0.45562840744268207, 0.47418907801383764, 0.5003226292779379, 0.400232896270396, 0.2811965362334977, 0.3713591533637336, 0.2673613925996377, 0.40322301309480846, 0.23298207228524323, 0.3452135320974887, 0.46670458970843837, 0.2474451830338704, 0.22802816551706984, 0.39525353466152646, 0.4909458071396119, 0.587017592501768, 0.32631529963064565, 0.33655502314392166, 0.3712275106466, 0.4923950776682408, 0.2580982360169816]\n", + "Loss\n", + "0.6085268462878561\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.32it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 1 0 1 0 1 0 0 0 0 0 1 1 1 1 0 0 1 0 0 0 0 0 0] [0.5064117276658848, 0.582606394530645, 0.43159801524815045, 0.2830759500562336, 0.45220109310645795, 0.37717952523497517, 0.355352641852072, 0.356804406701175, 0.2595683105616583, 0.4265578514056183, 0.34368333191994493, 0.5670550425654248, 0.5031492997027959, 0.39130293939839844, 0.6471133768901106, 0.49704317725029523, 0.2775908288929886, 0.1857201606178082, 0.489306308204554, 0.3399390343856141, 0.44858304782373737, 0.20556068386896048, 0.5829410813160572, 0.3080436388833854, 0.22895089300015303]\n", + "Loss\n", + "0.5743672965309764\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.44it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0] [0.44337416390285245, 0.22347025276139912, 0.4072912541043265, 0.37766311460352586, 0.3295190573725797, 0.3408275648833128, 0.4871100069392723, 0.2726044317927426, 0.3841790962794557, 0.3774391639455364, 0.3717301345404526, 0.5724713212872472, 0.2838573958376767, 0.32353255401048003, 0.25107948278654957, 0.3507348520007304, 0.16193560909690166, 0.5661635677831014, 0.4054158502441977, 0.24700077035303386, 0.3791385306708585, 0.25520862678452616, 0.507448457872475, 0.3922288476864353, 0.2692315495095034]\n", + "Loss\n", + "0.532458449969321\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 25/25 [00:04<00:00, 5.29it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(2000,)\n", + "25\n", + "[0 0 0 1 0 0 1 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0] [0.3417753386555086, 0.5536320468722367, 0.42613222915669113, 0.4412413804602271, 0.3205896641985686, 0.42071812688023735, 0.5023080336617323, 0.4804877689496918, 0.37041189940560204, 0.5967165922866011, 0.468403262165466, 0.3624440501946382, 0.35831932881784306, 0.4905533743320733, 0.3694065635938489, 0.45968188883127525, 0.46445083378450114, 0.28430256309503754, 0.23795509623995448, 0.22151486007673432, 0.2759404667112512, 0.22965115146463683, 0.7141930492003385, 0.4768950328074967, 0.2394397339014594]\n", + "Loss\n", + "0.5776595803693259\n", + "[ 0.55562182 1.14319133 1.0737959 0.40937078 0.0165973 0.50865298\n", + " 0.30024442 0.1364341 -0.06497169 0.57702616 0.13664098 1.24139061\n", + " 0.45566212 0.64294409 0.57014194 0.03931625 0.87284308 0.49789603\n", + " 0.79267549 0.03023329 0.44871798 1.52403189 0.8777964 0.5086433 ]\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "best_params = params" + ], + "metadata": { + "id": "9mKYCp4u7g9p" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "vqc." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 314 + }, + "id": "QhCDvNUq9NMD", + "outputId": "e6da79f8-5307-48e7-e1d4-0bbf58dcef6f" + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " »\n", + "q_0: »\n", + " »\n", + "q_1: »\n", + " »\n", + "q_2: »\n", + " »\n", + "q_3: »\n", + " »\n", + "« ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n", + "«q_0: ┤0 ├\n", + "« │ │\n", + "«q_1: ┤1 ├\n", + "« │ RealAmplitudes(θ[0],θ[1],θ[2],θ[3],θ[4],θ[5],θ[6],θ[7],θ[8],θ[9],θ[10],θ[11],θ[12],θ[13],θ[14],θ[15],θ[16],θ[17],θ[18],θ[19],θ[20],θ[21],θ[22],θ[23]) │\n", + "«q_2: ┤2 ├\n", + "« │ │\n", + "«q_3: ┤3 ├\n", + "« └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘" + ], + "text/html": [ + "
     »\n",
+              "q_0: »\n",
+              "     »\n",
+              "q_1: »\n",
+              "     »\n",
+              "q_2: »\n",
+              "     »\n",
+              "q_3: »\n",
+              "     »\n",
+              "«     ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐\n",
+              "«q_0: ┤0                                                                                                                                                       ├\n",
+              "«     │                                                                                                                                                        │\n",
+              "«q_1: ┤1                                                                                                                                                       ├\n",
+              "«     │  RealAmplitudes(θ[0],θ[1],θ[2],θ[3],θ[4],θ[5],θ[6],θ[7],θ[8],θ[9],θ[10],θ[11],θ[12],θ[13],θ[14],θ[15],θ[16],θ[17],θ[18],θ[19],θ[20],θ[21],θ[22],θ[23]) │\n",
+              "«q_2: ┤2                                                                                                                                                       ├\n",
+              "«     │                                                                                                                                                        │\n",
+              "«q_3: ┤3                                                                                                                                                       ├\n",
+              "«     └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
" + ] + }, + "metadata": {}, + "execution_count": 25 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from qiskit import QuantumCircuit\n", + "N_QUBITS = 4\n", + "vqc = ansatz(N_QUBITS)\n", + "\n", + "vqc = vqc.assign_parameters(best_params)\n", + "\n", + "vqc.qasm(filename=\"quantum_classifier.qasm\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 268 + }, + "id": "gfq8UhJH7CEn", + "outputId": "556e5a7c-ec1e-4da6-f764-62130a5ce4c0" + }, + "execution_count": 27, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'OPENQASM 2.0;\\ninclude \"qelib1.inc\";\\ngate gate_RealAmplitudes(param0,param1,param2,param3,param4,param5,param6,param7,param8,param9,param10,param11,param12,param13,param14,param15,param16,param17,param18,param19,param20,param21,param22,param23) q0,q1,q2,q3 { ry(0.555621819228932) q0; ry(1.14319132801287) q1; ry(1.07379590145389) q2; ry(0.409370781763752) q3; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.0165973010020706) q0; ry(0.508652978720279) q1; ry(0.300244419920286) q2; ry(0.136434104028988) q3; cx q2,q3; cx q1,q2; cx q0,q1; ry(-0.0649716942665253) q0; ry(0.577026156276957) q1; ry(0.13664098460932) q2; ry(1.24139060584453) q3; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.455662122094092) q0; ry(0.642944089110158) q1; ry(0.570141938819558) q2; ry(0.0393162465417179) q3; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.872843078509701) q0; ry(0.497896034397818) q1; ry(0.792675492672247) q2; ry(0.0302332873841969) q3; cx q2,q3; cx q1,q2; cx q0,q1; ry(0.448717981940666) q0; ry(1.52403189005694) q1; ry(0.877796397476269) q2; ry(0.508643300858681) q3; }\\nqreg q[4];\\ngate_RealAmplitudes(0.555621819228932,1.14319132801287,1.07379590145389,0.409370781763752,0.0165973010020706,0.508652978720279,0.300244419920286,0.136434104028988,-0.0649716942665253,0.577026156276957,0.13664098460932,1.24139060584453,0.455662122094092,0.642944089110158,0.570141938819558,0.0393162465417179,0.872843078509701,0.497896034397818,0.792675492672247,0.0302332873841969,0.448717981940666,1.52403189005694,0.877796397476269,0.508643300858681) q[0],q[1],q[2],q[3];\\n'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "source": [ + "!ls" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "a7ArfSyV9Xiq", + "outputId": "f06143d5-aaf0-411e-81a9-079f79e989b0" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "data quantum_classifier.qasm sample_data\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "\n", + "files.download('quantum_classifier.qasm')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "XZTU5w3x9cel", + "outputId": "6994ed13-9732-4aea-88b0-c04ddf7f33bb" + }, + "execution_count": 30, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "\n", + " async function download(id, filename, size) {\n", + " if (!google.colab.kernel.accessAllowed) {\n", + " return;\n", + " }\n", + " const div = document.createElement('div');\n", + " const label = document.createElement('label');\n", + " label.textContent = `Downloading \"${filename}\": `;\n", + " div.appendChild(label);\n", + " const progress = document.createElement('progress');\n", + " progress.max = size;\n", + " div.appendChild(progress);\n", + " document.body.appendChild(div);\n", + "\n", + " const buffers = [];\n", + " let downloaded = 0;\n", + "\n", + " const channel = await google.colab.kernel.comms.open(id);\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + "\n", + " for await (const message of channel.messages) {\n", + " // Send a message to notify the kernel that we're ready.\n", + " channel.send({})\n", + " if (message.buffers) {\n", + " for (const buffer of message.buffers) {\n", + " buffers.push(buffer);\n", + " downloaded += buffer.byteLength;\n", + " progress.value = downloaded;\n", + " }\n", + " }\n", + " }\n", + " const blob = new Blob(buffers, {type: 'application/binary'});\n", + " const a = document.createElement('a');\n", + " a.href = window.URL.createObjectURL(blob);\n", + " a.download = filename;\n", + " div.appendChild(a);\n", + " a.click();\n", + " div.remove();\n", + " }\n", + " " + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "" + ], + "application/javascript": [ + "download(\"download_4991390e-5a53-4b29-ab15-96165d0de025\", \"quantum_classifier.qasm\", 1519)" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "vqc = ansatz(N_QUBITS)" + ], + "metadata": { + "id": "k2MPHTTD7lmK" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "params" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 204 + }, + "id": "6GvYf_fP2TG_", + "outputId": "b9f0011e-dac5-448b-e933-a58af1de4db4" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "error", + "ename": "NameError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparams\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'params' is not defined" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "DVtOX_Ep6ve8" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 8a5494a9cdada4640de88250ac77109f0d1a892b Mon Sep 17 00:00:00 2001 From: Miguel Date: Sun, 29 Jan 2023 14:51:47 +0000 Subject: [PATCH 09/10] Make sure it runs on qbraid --- test.ipynb | 46 ++++++++++++++++++++++++++++++++++++++-------- test.py | 25 +++++++------------------ 2 files changed, 45 insertions(+), 26 deletions(-) diff --git a/test.ipynb b/test.ipynb index 1d7c541..bf9c8a7 100644 --- a/test.ipynb +++ b/test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "e2e5bcd9-2cb8-465d-b166-23128574b2c7", "metadata": {}, "outputs": [ @@ -10,8 +10,36 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 2000/2000 [00:00<00:00, 58652.57it/s]\n", - " 9%|▉ | 187/2000 [00:28<04:22, 6.89it/s]" + "100%|██████████| 2000/2000 [00:00<00:00, 23292.31it/s]\n", + "100%|██████████| 10/10 [00:01<00:00, 7.02it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9379616325363924\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 10/10 [00:01<00:00, 6.84it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9379616325363924,0.3944362547996004,./data\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" ] } ], @@ -139,7 +167,8 @@ " n=len(images)\n", " mse=0\n", " gatecount=0\n", - "\n", + " n = 10 # sanity check to test that code works\n", + " \n", " for i in tqdm.tqdm(range(n)):\n", " #encode image into circuit\n", " circuit,image_re=run_part1(dataset[i][\"image_vector\"])\n", @@ -165,16 +194,17 @@ " score=0\n", " gatecount=0\n", " n=len(images)\n", - "\n", - " for i in range(n):\n", + " \n", + " n = 10\n", + " for i in tqdm.tqdm(range(n)):\n", " #run part 2\n", - " circuit,label=run_part2(images[i])\n", + " circuit,label=run_part2(dataset[i * 100][\"image_vector\"])\n", "\n", " #count the gate used in the circuit for score calculation\n", " gatecount+=count_gates(circuit)[2]\n", "\n", " #check label\n", - " if label==labels[i]:\n", + " if label==labels[i * 100]:\n", " score+=1\n", " \n", " #score\n", diff --git a/test.py b/test.py index af565fe..21d0d05 100644 --- a/test.py +++ b/test.py @@ -1,12 +1,3 @@ -# -*- coding: utf-8 -*- -"""test.ipynb - -Automatically generated by Colaboratory. - -Original file is located at - https://colab.research.google.com/drive/1s-l9A942fTckwR938T0zcdLhQPd5TOMm -""" - import qiskit from qiskit import quantum_info, QuantumCircuit from qiskit.execute_function import execute @@ -86,8 +77,6 @@ def normalize(row): #Else we divide each value between the sum value above row = row / normalization_factor return row, normalization_factor -# -data_path = "./data" def test(): #load the actual hackthon data (fashion-mnist) @@ -130,7 +119,7 @@ def test(): n=len(images) mse=0 gatecount=0 - + for i in tqdm.tqdm(range(n)): #encode image into circuit circuit,image_re=run_part1(dataset[i]["image_vector"]) @@ -157,9 +146,9 @@ def test(): gatecount=0 n=len(images) - for i in range(n): + for i in tqdm.tqdm(range(n)): #run part 2 - circuit,label=run_part2(images[i]) + circuit,label=run_part2(dataset[i]["image_vector"]) #count the gate used in the circuit for score calculation gatecount+=count_gates(circuit)[2] @@ -227,7 +216,7 @@ def run_part2(image): #encode image into circuit circuit=encode(image) - # append with classifier circuit + #append with classifier circuit nq1 = circuit.width() nq2 = classifier.width() nq = max(nq1, nq2) @@ -235,13 +224,13 @@ def run_part2(image): qc.append(circuit.to_instruction(), list(range(nq1))) qc.append(classifier.to_instruction(), list(range(nq2))) - # simulate circuit + #simulate circuit histogram=simulate(qc) - # convert histogram to category + #convert histogram to category label=histogram_to_category(histogram) - # thresholding the label, any way you want + #thresholding the label, any way you want if label>0.5: label=1 else: From 85e1a74574fad139bedf4172d9dede12b47f128c Mon Sep 17 00:00:00 2001 From: Miguel Date: Thu, 2 Feb 2023 04:54:13 +0000 Subject: [PATCH 10/10] add requirements.txt --- .gitignore | 1 + .ipynb_checkpoints/examples-checkpoint.ipynb | 251 ------------ .../examples_qiskit-checkpoint.ipynb | 204 ---------- .../mock_data_creator-checkpoint.ipynb | 79 ---- .ipynb_checkpoints/part1-checkpoint.py | 25 -- .../part1_example_cirq-checkpoint.ipynb | 226 ----------- .../part1_example_qiskit-checkpoint.ipynb | 234 ----------- .../part2_example_cirq-checkpoint.ipynb | 221 ----------- .../part2_example_qiskit-checkpoint.ipynb | 230 ----------- requirements.txt | 367 ++++++++++++++++++ 10 files changed, 368 insertions(+), 1470 deletions(-) create mode 100644 .gitignore delete mode 100644 .ipynb_checkpoints/examples-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/examples_qiskit-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/mock_data_creator-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/part1-checkpoint.py delete mode 100644 .ipynb_checkpoints/part1_example_cirq-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/part2_example_cirq-checkpoint.ipynb delete mode 100644 .ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb create mode 100644 requirements.txt diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..87620ac --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.ipynb_checkpoints/ diff --git a/.ipynb_checkpoints/examples-checkpoint.ipynb b/.ipynb_checkpoints/examples-checkpoint.ipynb deleted file mode 100644 index 91fd780..0000000 --- a/.ipynb_checkpoints/examples-checkpoint.ipynb +++ /dev/null @@ -1,251 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 23, - "id": "4d3113ae", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: cirq.Circuit) -> dict:\n", - " \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n", - " \"\"\"\n", - " simulator = cirq.Simulator()\n", - " result = simulator.simulate(circuit)\n", - " \n", - " state_vector=result.final_state_vector\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: cirq.Circuit):\n", - " \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n", - " counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n", - " \n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "82f90e0d", - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "cb96a334", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "b02b160e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#submission part 1\n", - "\n", - "#load the definition of the encoder and decoder\n", - "from part1 import encode,decode\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode(data['image'])\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " #count the number of 2-qubit gates\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #reconstruct the image\n", - " image_re=decode(histogram)\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "2fe52c43", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part 2\n", - "\n", - "#load classifier circuit\n", - "with open('part2.pickle', 'rb') as f:\n", - " classifier=pickle.load(f)\n", - " \n", - "score=0\n", - "\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode(data['image'])\n", - " \n", - " #append with classifier circuit\n", - " \n", - " circuit.append(classifier)\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #convert histogram to category\n", - " cat=histogram_to_category(histogram)\n", - " \n", - " if cat==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "de96fdf1", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - }, - "vscode": { - "interpreter": { - "hash": "1a1af0ee75eeea9e2e1ee996c87e7a2b11a0bebd85af04bb136d915cefc0abce" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/examples_qiskit-checkpoint.ipynb b/.ipynb_checkpoints/examples_qiskit-checkpoint.ipynb deleted file mode 100644 index bab8c57..0000000 --- a/.ipynb_checkpoints/examples_qiskit-checkpoint.ipynb +++ /dev/null @@ -1,204 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "\n", - "#define utility functions\n", - "\n", - "#this simulate a circuit (without measurement) and output results in the format of histogram.\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " return Counter([len(gate[1]) for gate in circuit.data])\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#load data\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part1\n", - "from part1 import encode_qiskit,decode\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode_qiskit(data['image'])\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #reconstruct \n", - " image_re=decode(histogram)\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(np.asarray(data['image']),np.asarray(image_re))\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1\n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#grade part 2\n", - "\n", - "#load classifier circuit\n", - "classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n", - " \n", - "score=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit=encode_qiskit(data['image'])\n", - " \n", - " nq1 = circuit.width()\n", - " nq2 = classifier.width()\n", - " nq = max(nq1, nq2)\n", - " qc = qiskit.QuantumCircuit(nq)\n", - " qc.append(circuit.to_instruction(), list(range(nq1)))\n", - " qc.append(classifier.to_instruction(), list(range(nq2)))\n", - "\n", - " gatecount+=count_gates(qc)[2]\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(qc)\n", - " \n", - " #convert histogram to category\n", - " cat=histogram_to_category(histogram)\n", - " \n", - " \n", - " if cat==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.15" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.ipynb_checkpoints/mock_data_creator-checkpoint.ipynb b/.ipynb_checkpoints/mock_data_creator-checkpoint.ipynb deleted file mode 100644 index 78ad064..0000000 --- a/.ipynb_checkpoints/mock_data_creator-checkpoint.ipynb +++ /dev/null @@ -1,79 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "edbfcaa1", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3d1a8015", - "metadata": {}, - "outputs": [], - "source": [ - "#making mock data data1.json and data2.json\n", - "\n", - "image1={\"image\":[[0,0],[0,0]],\"category\":1}\n", - "image2={\"image\":[[1,1],[1,1]],\"category\":0}\n", - "\n", - "with open('data1.json', \"w\") as outfile:\n", - " json.dump(image1, outfile)\n", - " \n", - "with open('data2.json', \"w\") as outfile:\n", - " json.dump(image2, outfile)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d36c16ef", - "metadata": {}, - "outputs": [], - "source": [ - "circuit=cirq.Circuit()\n", - "circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", - "#making mock submission for part2\n", - "with open('part2.pickle', 'wb') as f:\n", - " pickle.dump(circuit,f)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "55574177", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/part1-checkpoint.py b/.ipynb_checkpoints/part1-checkpoint.py deleted file mode 100644 index d133097..0000000 --- a/.ipynb_checkpoints/part1-checkpoint.py +++ /dev/null @@ -1,25 +0,0 @@ -import cirq -import qiskit -import numpy as np - - -def encode_cirq(image): - circuit=cirq.Circuit() - if image[0][0]==0: - circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0))) - return circuit - -def encode_qiskit(image): - q = qiskit.QuantumRegister(3) - circuit = qiskit.QuantumCircuit(q) - if image[0][0]==0: - circuit.rx(np.pi,0) - return circuit - - -def decode(histogram): - if 1 in histogram.keys(): - image=[[0,0],[0,0]] - else: - image=[[1,1],[1,1]] - return image \ No newline at end of file diff --git a/.ipynb_checkpoints/part1_example_cirq-checkpoint.ipynb b/.ipynb_checkpoints/part1_example_cirq-checkpoint.ipynb deleted file mode 100644 index c3d383b..0000000 --- a/.ipynb_checkpoints/part1_example_cirq-checkpoint.ipynb +++ /dev/null @@ -1,226 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 8, - "id": "9c97e0dc", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: cirq.Circuit) -> dict:\n", - " \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n", - " \"\"\"\n", - " simulator = cirq.Simulator()\n", - " result = simulator.simulate(circuit)\n", - " \n", - " state_vector=result.final_state_vector\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: cirq.Circuit):\n", - " \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n", - " counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n", - " \n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7f19ddcc", - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "a443b6a8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "cb2031cd", - "metadata": {}, - "outputs": [], - "source": [ - "#submission to part 1, you should make this into a .py file\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "def encode(image):\n", - " circuit=cirq.Circuit()\n", - " if image[0][0]==0:\n", - " circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", - " return circuit\n", - "\n", - "def decode(histogram):\n", - " if 1 in histogram.keys():\n", - " image=[[0,0],[0,0]]\n", - " else:\n", - " image=[[1,1],[1,1]]\n", - " return image\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit=encode(data['image'])\n", - "\n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re=decode(histogram)\n", - "\n", - " return circuit,image_re" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "385faa44", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit,image_re=run_part1(data['image'])\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ad7e81d7", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb b/.ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb deleted file mode 100644 index 90b2c18..0000000 --- a/.ipynb_checkpoints/part1_example_qiskit-checkpoint.ipynb +++ /dev/null @@ -1,234 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "import matplotlib.pyplot as plt\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n", - "\n", - "def image_mse(image1,image2):\n", - " # Using sklearns mean squared error:\n", - " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(image1, image2)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#submission to part 1, you should make this into a .py file\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "def decode(histogram):\n", - " if 1 in histogram.keys():\n", - " image=[[0,0],[0,0]]\n", - " else:\n", - " image=[[1,1],[1,1]]\n", - " return image\n", - "\n", - "def run_part1(image):\n", - " #encode image into a circuit\n", - " circuit=encode(image)\n", - "\n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - "\n", - " #reconstruct the image\n", - " image_re=decode(histogram)\n", - "\n", - " return circuit,image_re" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "n=len(dataset)\n", - "mse=0\n", - "gatecount=0\n", - "\n", - "for data in dataset:\n", - " #encode image into circuit\n", - " circuit,image_re=run_part1(data['image'])\n", - " \n", - " #count the number of 2qubit gates used\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #calculate mse\n", - " mse+=image_mse(data['image'],image_re)\n", - " \n", - "#fidelity of reconstruction\n", - "f=1-mse\n", - "gatecount=gatecount/n\n", - "\n", - "#score for part1 \n", - "print(f*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.15 (main, Oct 11 2022, 22:27:25) \n[Clang 14.0.0 (clang-1400.0.29.102)]" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/.ipynb_checkpoints/part2_example_cirq-checkpoint.ipynb b/.ipynb_checkpoints/part2_example_cirq-checkpoint.ipynb deleted file mode 100644 index 2bb7a6d..0000000 --- a/.ipynb_checkpoints/part2_example_cirq-checkpoint.ipynb +++ /dev/null @@ -1,221 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "id": "5519a2aa", - "metadata": {}, - "outputs": [], - "source": [ - "import cirq\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: cirq.Circuit) -> dict:\n", - " \"\"\"This funcion simulate a cirq circuit (without measurement) and output results in the format of histogram.\n", - " \"\"\"\n", - " simulator = cirq.Simulator()\n", - " result = simulator.simulate(circuit)\n", - " \n", - " state_vector=result.final_state_vector\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "def count_gates(circuit: cirq.Circuit):\n", - " \"\"\"Returns the number of 1-qubit gates, number of 2-qubit gates, number of 3-qubit gates....\"\"\"\n", - " counter=Counter([len(op.qubits) for op in circuit.all_operations()])\n", - " \n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "11a77286", - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "dfbb6735", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "66e9a047", - "metadata": {}, - "outputs": [], - "source": [ - "#you submission\n", - "\n", - "def encode(image):\n", - " circuit=cirq.Circuit()\n", - " if image[0][0]==0:\n", - " circuit.append(cirq.rx(np.pi).on(cirq.LineQubit(0)))\n", - " return circuit\n", - "\n", - "\n", - "def run_part2(image):\n", - "\n", - " #loade the quantum classifier circuit\n", - " with open('part2.pickle', 'rb') as f:\n", - " classifier=pickle.load(f)\n", - " \n", - " #encode image into circuit\n", - " circuit=encode(image)\n", - " \n", - " #append with classifier circuit\n", - " \n", - " circuit.append(classifier)\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(circuit)\n", - " \n", - " #convert histogram to category\n", - " label=histogram_to_category(histogram)\n", - " \n", - " return circuit,label\n", - "#score" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "18e6015f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "score=0\n", - "gatecount=0\n", - "n=len(dataset)\n", - "\n", - "for data in dataset:\n", - " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #check label\n", - " if label==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a73d2810", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/.ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb b/.ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb deleted file mode 100644 index 8b48841..0000000 --- a/.ipynb_checkpoints/part2_example_qiskit-checkpoint.ipynb +++ /dev/null @@ -1,230 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import qiskit\n", - "from qiskit import quantum_info\n", - "from qiskit.execute_function import execute\n", - "from qiskit import BasicAer\n", - "import numpy as np\n", - "import pickle\n", - "import json\n", - "import os\n", - "from collections import Counter\n", - "from sklearn.metrics import mean_squared_error\n", - "from typing import Dict, List\n", - "\n", - "#define utility functions\n", - "\n", - "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", - " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", - " backend = BasicAer.get_backend('statevector_simulator')\n", - " job = execute(circuit, backend)\n", - " result = job.result()\n", - " state_vector = result.get_statevector()\n", - " \n", - " histogram = dict()\n", - " for i in range(len(state_vector)):\n", - " population = abs(state_vector[i]) ** 2\n", - " if population > 1e-9:\n", - " histogram[i] = population\n", - " \n", - " return histogram\n", - "\n", - "\n", - "def histogram_to_category(histogram):\n", - " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", - " the problem description.\"\"\"\n", - " assert abs(sum(histogram.values())-1)<1e-8\n", - " positive=0\n", - " for key in histogram.keys():\n", - " digits = bin(int(key))[2:].zfill(20)\n", - " if digits[-1]=='0':\n", - " positive+=histogram[key]\n", - " \n", - " return positive\n", - "\n", - "\n", - "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", - " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", - " counter = Counter([len(gate[1]) for gate in circuit.data])\n", - " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", - " #for k>2\n", - " for i in range(2,20):\n", - " assert counter[i]==0\n", - " \n", - " return counter" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#load the mock data (for testing only)\n", - "files=os.listdir(\"mock_data\")\n", - "dataset=list()\n", - "for file in files:\n", - " with open('mock_data/'+file, \"r\") as infile:\n", - " loaded = json.load(infile)\n", - " dataset.append(loaded)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load('data/images.npy')\n", - "labels=np.load('data/labels.npy')\n", - "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1100])" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "#your submission\n", - "\n", - "# Functions 'encode' and 'decode' are dummy.\n", - "def encode(image):\n", - " q = qiskit.QuantumRegister(3)\n", - " circuit = qiskit.QuantumCircuit(q)\n", - " if image[0][0]==0:\n", - " circuit.rx(np.pi,0)\n", - " return circuit\n", - "\n", - "\n", - "def run_part2(image):\n", - "\n", - " #loade the quantum classifier circuit\n", - " classifier=qiskit.QuantumCircuit.from_qasm_file('part2.qasm')\n", - " \n", - " #encode image into circuit\n", - " circuit=encode(image)\n", - " \n", - " #append with classifier circuit\n", - " nq1 = circuit.width()\n", - " nq2 = classifier.width()\n", - " nq = max(nq1, nq2)\n", - " qc = qiskit.QuantumCircuit(nq)\n", - " qc.append(circuit.to_instruction(), list(range(nq1)))\n", - " qc.append(classifier.to_instruction(), list(range(nq2)))\n", - " \n", - " #simulate circuit\n", - " histogram=simulate(qc)\n", - " \n", - " #convert histogram to category\n", - " label=histogram_to_category(histogram)\n", - " \n", - " return circuit,label\n", - "#score" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0\n" - ] - } - ], - "source": [ - "#how we grade your submission\n", - "\n", - "score=0\n", - "gatecount=0\n", - "n=len(dataset)\n", - "\n", - "for data in dataset:\n", - " #run part 2\n", - " circuit,label=run_part2(data['image'])\n", - " \n", - " #count the gate used in the circuit for score calculation\n", - " gatecount+=count_gates(circuit)[2]\n", - " \n", - " #check label\n", - " if label==data['category']:\n", - " score+=1\n", - "#score\n", - "score=score/n\n", - "gatecount=gatecount/n\n", - "\n", - "print(score*(0.999**gatecount))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.9.15" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" - } - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..678658c --- /dev/null +++ b/requirements.txt @@ -0,0 +1,367 @@ +absl-py==1.4.0 +aiofile==3.8.1 +aiohttp==3.8.3 +aiosignal==1.3.1 +alembic @ file:///home/conda/feedstock_root/build_artifacts/alembic_1647367721563/work +amazon-braket-default-simulator==1.11.4 +amazon-braket-ocean-plugin==1.0.11 +amazon-braket-pennylane-plugin==1.10.4 +amazon-braket-schemas==1.14.0 +amazon-braket-sdk==1.35.3 +antlr4-python3-runtime==4.9.2 +anyio==3.6.2 +appdirs==1.4.4 +appnope==0.1.3 +argcomplete==2.0.0 +argon2-cffi==21.3.0 +argon2-cffi-bindings==21.2.0 +asttokens @ file:///home/conda/feedstock_root/build_artifacts/asttokens_1618968359944/work +astunparse==1.6.3 +async-generator==1.10 +async-timeout==4.0.2 +attrs==20.3.0 +autograd==1.5 +autoray==0.6.0 +awscli==1.27.57 +azure-core==1.26.2 +azure-identity==1.12.0 +azure-quantum @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/azure_quantum-0.27.244707-py3-none-any.whl +azure-storage-blob==12.14.1 +Babel @ file:///home/conda/feedstock_root/build_artifacts/babel_1619719576210/work +backcall==0.2.0 +backoff==2.2.1 +backports.functools-lru-cache @ file:///home/conda/feedstock_root/build_artifacts/backports.functools_lru_cache_1618230623929/work +beautifulsoup4==4.11.1 +bleach==6.0.0 +blinker==1.4 +bokeh==3.0.3 +boltons==21.0.0 +boto3==1.26.57 +botocore==1.29.57 +brotlipy @ file:///home/conda/feedstock_root/build_artifacts/brotlipy_1636012194889/work +cached-property==1.5.2 +cachetools==4.2.4 +caio==0.9.11 +certifi==2022.12.7 +certipy==0.1.3 +cffi==1.15.1 +chardet==3.0.4 +charset-normalizer==3.0.1 +cirq==1.1.0 +cirq-aqt==1.1.0 +cirq-core==1.1.0 +cirq-google==1.1.0 +cirq-ionq==1.1.0 +cirq-pasqal==1.1.0 +cirq-rigetti==1.1.0 +cirq-web==1.1.0 +click==8.1.3 +code-snippets @ file:///tmp/qbraid/wheels/code_snippets-0.1.2-py3-none-any.whl +colorama==0.4.6 +comm==0.1.2 +conda==4.11.0 +conda-package-handling @ file:///home/conda/feedstock_root/build_artifacts/conda-package-handling_1636021710069/work +configobj==5.0.8 +contourpy==1.0.7 +cryptography==39.0.0 +cycler==0.11.0 +Cython==0.29.33 +debugpy==1.6.6 +decorator==5.1.1 +defusedxml==0.7.1 +Deprecated==1.2.13 +deprecation==2.1.0 +dill==0.3.5.1 +dimod==0.12.3 +diskcache==5.4.0 +dlx==1.0.4 +docplex==2.25.236 +docs-react-widget @ file:///tmp/qbraid/wheels/docs_react_widget-0.1.0-py3-none-any.whl +docutils==0.16 +duet==0.2.7 +dwave-cloud-client==0.10.4 +dwave-greedy==0.3.0 +dwave-hybrid==0.6.10 +dwave-inspector==0.4.0 +dwave-neal==0.6.0 +dwave-networkx==0.8.13 +dwave-ocean-sdk==6.2.0 +dwave-preprocessing==0.5.4 +dwave-samplers==1.0.0 +dwave-system==1.18.0 +dwave-tabu==0.5.0 +dwavebinarycsp==0.2.0 +entrypoints==0.4 +environment-manager @ file:///tmp/qbraid/wheels/environment_manager-0.1.4-py3-none-any.whl +executing @ file:///home/conda/feedstock_root/build_artifacts/executing_1646044401614/work +fastdtw==0.3.4 +fasteners==0.18 +fastjsonschema==2.16.2 +Flask==2.2.2 +flatbuffers==23.1.21 +flit_core @ file:///home/conda/feedstock_root/build_artifacts/flit-core_1645629044586/work/source/flit_core +fonttools==4.38.0 +frozendict==2.3.4 +frozenlist==1.3.3 +future==0.18.3 +gast==0.4.0 +gitdb==4.0.10 +GitPython==3.1.30 +google-api-core==1.34.0 +google-api-python-client==2.31.0 +google-auth==2.16.0 +google-auth-httplib2==0.1.0 +google-auth-oauthlib==0.4.6 +google-pasta==0.2.0 +googleapis-common-protos==1.58.0 +graphviz==0.20.1 +greenlet @ file:///home/conda/feedstock_root/build_artifacts/greenlet_1635836790477/work +grpcio==1.51.1 +grpcio-status==1.48.2 +h11==0.14.0 +h5py==3.2.1 +homebase==1.0.1 +html5lib==1.1 +httpcore==0.16.3 +httplib2==0.21.0 +httpx==0.23.3 +ibm-cloud-sdk-core==3.16.1 +ibm-platform-services==0.31.0 +idna==2.8 +imageio==2.25.0 +importlib-metadata==6.0.0 +importlib-resources @ file:///home/conda/feedstock_root/build_artifacts/importlib_resources_1635615662634/work +inflection==0.5.1 +ipykernel==6.20.2 +ipyparallel==8.4.1 +ipython==8.8.0 +ipython-genutils==0.2.0 +ipyvue==1.8.0 +ipyvuetify==1.8.4 +ipywidgets==8.0.4 +iso8601==1.1.0 +isodate==0.6.1 +itsdangerous==2.1.2 +jedi @ file:///home/conda/feedstock_root/build_artifacts/jedi_1637175083648/work +Jinja2==3.1.2 +jmespath==1.0.1 +joblib==1.2.0 +json5 @ file:///home/conda/feedstock_root/build_artifacts/json5_1600692310011/work +jsonref==1.1.0 +jsonschema==4.17.3 +jupyter-bokeh==3.0.5 +jupyter-client @ file:///home/conda/feedstock_root/build_artifacts/jupyter_client_1642858610849/work +jupyter-server==1.23.5 +jupyter-server-mathjax==0.2.6 +jupyter-telemetry @ file:///home/conda/feedstock_root/build_artifacts/jupyter_telemetry_1605173804246/work +jupyter_core==5.1.5 +jupyterhub @ file:///home/conda/feedstock_root/build_artifacts/jupyterhub-feedstock_1647267198467/work +jupyterlab==3.5.3 +jupyterlab-git==0.41.0 +jupyterlab-pygments @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_pygments_1601375948261/work +jupyterlab-server @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_server_1641592475363/work +jupyterlab-widgets==3.0.5 +keras==2.11.0 +keras-nightly==2.12.0.dev2023012508 +Keras-Preprocessing==1.1.2 +kiwisolver==1.4.4 +lab-main-menu @ file:///tmp/qbraid/wheels/lab_main_menu-0.1.1-py3-none-any.whl +lark==0.11.3 +lark-parser==0.12.0 +libclang==15.0.6.1 +libmambapy @ file:///home/conda/feedstock_root/build_artifacts/mamba-split_1644831758535/work/libmambapy +lxml==4.9.2 +Mako @ file:///home/conda/feedstock_root/build_artifacts/mako_1646959760357/work +mamba @ file:///home/conda/feedstock_root/build_artifacts/mamba-split_1644831758535/work/mamba +Markdown==3.4.1 +MarkupSafe==2.1.2 +matplotlib==3.6.0 +matplotlib-inline @ file:///home/conda/feedstock_root/build_artifacts/matplotlib-inline_1631080358261/work +minorminer==0.2.10 +mistune==2.0.4 +more-itertools==9.0.0 +mpltools==0.2.0 +mpmath==1.2.1 +msal==1.20.0 +msal-extensions==1.0.0 +msgpack==0.6.2 +msrest==0.7.1 +mthree==1.1.0 +multidict==6.0.4 +multitasking==0.0.11 +mypy-extensions==0.4.3 +Nasdaq-Data-Link==1.0.4 +nbclassic==0.4.8 +nbclient==0.7.2 +nbconvert==7.2.9 +nbdime==3.1.1 +nbformat==5.7.3 +nest-asyncio==1.5.6 +networkx==2.8.8 +ninja==1.11.1 +notebook==6.5.2 +notebook-shim @ file:///home/conda/feedstock_root/build_artifacts/notebook-shim_1646330736330/work +ntlm-auth==1.5.0 +numpy==1.21.6 +nvidia-cublas-cu11==11.10.3.66 +nvidia-cuda-nvrtc-cu11==11.7.99 +nvidia-cuda-runtime-cu11==11.7.99 +nvidia-cudnn-cu11==8.5.0.96 +oauth2client==4.1.3 +oauthlib==3.2.2 +opencv-python==4.7.0.68 +openfermion==1.5.1 +openpulse==0.4.1 +openqasm3==0.4.0 +opt-einsum==3.3.0 +oqpy==0.1.2 +orjson==3.8.5 +packaging==23.0 +pamela==1.0.0 +pandas==1.5.3 +pandocfilters==1.5.0 +parso==0.8.3 +pbr==5.11.1 +penaltymodel==1.0.2 +PennyLane==0.27.0 +PennyLane-Cirq==0.28.0 +PennyLane-Lightning==0.28.0 +PennyLane-qiskit==0.28.0 +pexpect==4.8.0 +pickleshare==0.7.5 +Pillow==9.4.0 +platformdirs==2.6.2 +plucky==0.4.3 +ply==3.11 +portalocker==2.7.0 +prometheus-client==0.16.0 +prompt-toolkit==3.0.36 +proto-plus==1.22.2 +protobuf==3.19.6 +psutil==5.9.4 +ptyprocess==0.7.0 +PubChemPy==1.0.4 +pure-eval @ file:///home/conda/feedstock_root/build_artifacts/pure_eval_1642875951954/work +py==1.11.0 +pyasn1==0.4.8 +pyasn1-modules==0.2.8 +pybind11==2.10.3 +pycosat @ file:///home/conda/feedstock_root/build_artifacts/pycosat_1636020362356/work +pycparser==2.21 +pycurl==7.45.1 +pydantic==1.10.4 +Pygments==2.14.0 +PyJWT==2.6.0 +pylatexenc==2.10 +pyOpenSSL @ file:///home/conda/feedstock_root/build_artifacts/pyopenssl_1643496850550/work +pyparsing==3.0.9 +pyqir-generator==0.4.2a1 +pyqubo==1.4.0 +pyquil==3.3.2 +pyrsistent==0.19.3 +pyscf==2.1.1 +PySocks==1.7.1 +python-constraint==1.4.0 +python-dateutil==2.8.2 +python-json-logger @ file:///home/conda/feedstock_root/build_artifacts/python-json-logger_1602545356084/work +python-markdown-math==0.8 +python-rapidjson==1.9 +pytket==1.11.1 +pytket-cirq==0.28.0 +pytket-qiskit==0.34.0 +pytz==2022.7.1 +PyYAML==5.4.1 +pyzmq==25.0.0 +qcs-api-client==0.21.2 +qdk @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qdk-0.27.244707-py3-none-any.whl +qickstart-graders @ git+https://github.com/TheGupta2012/QickStart.git@65501cc7d5e98506b90e58e43d8d4a2aee551739 +QInfer==1.0 +qiskit==0.39.5 +qiskit-aer==0.11.2 +qiskit-aqua==0.9.5 +qiskit-finance==0.3.4 +qiskit-ibm-runtime==0.8.0 +qiskit-ibmq-provider==0.19.2 +qiskit-ignis==0.7.0 +qiskit-ionq==0.3.10 +qiskit-machine-learning==0.5.0 +qiskit-nature==0.5.2 +qiskit-optimization==0.4.0 +qiskit-qir==0.2.0 +qiskit-terra==0.22.4 +qsharp @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qsharp-0.27.244707-py3-none-any.whl +qsharp-chemistry @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qsharp_chemistry-0.27.244707-py3-none-any.whl +qsharp-core @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qsharp_core-0.27.244707-py3-none-any.whl +Quandl==3.7.0 +quantum-jobs @ file:///tmp/qbraid/wheels/quantum_jobs-0.1.1-py3-none-any.whl +qutip==4.7.1 +qwasm==1.0.1 +rectangle-packer==2.0.1 +requests==2.28.2 +requests-ntlm==1.1.0 +requests-oauthlib==1.3.1 +retry==0.9.2 +retrying==1.3.4 +retworkx==0.12.1 +rfc3339==6.2 +rfc3986==1.5.0 +rpcq==3.10.0 +rsa==4.9 +ruamel-yaml-conda @ file:///home/conda/feedstock_root/build_artifacts/ruamel_yaml_1636009144459/work +ruamel.yaml==0.17.21 +ruamel.yaml.clib==0.2.7 +rustworkx==0.12.1 +s3transfer==0.6.0 +scikit-learn==1.2.1 +scipy==1.10.0 +seaborn==0.12.2 +semantic-version==2.10.0 +Send2Trash==1.8.0 +six==1.16.0 +smmap==5.0.0 +sniffio==1.3.0 +sortedcontainers==2.4.0 +soupsieve==2.3.2.post1 +SQLAlchemy @ file:///home/conda/feedstock_root/build_artifacts/sqlalchemy_1646615291967/work +stack-data @ file:///home/conda/feedstock_root/build_artifacts/stack_data_1644872665635/work +stevedore==4.1.1 +symengine==0.9.2 +sympy==1.11.1 +tensorboard==2.11.2 +tensorboard-data-server==0.6.1 +tensorboard-plugin-wit==1.8.1 +tensorflow==2.11.0 +tensorflow-estimator==2.11.0 +tensorflow-io-gcs-filesystem==0.30.0 +termcolor==2.2.0 +terminado==0.17.1 +testpath==0.6.0 +threadpoolctl==3.1.0 +tinycss2==1.2.1 +toml==0.10.2 +tomli==2.0.1 +torch==1.13.1 +tornado==6.2 +tqdm==4.64.1 +traitlets==5.8.1 +tweedledum==1.1.1 +types-Jinja2==2.11.9 +types-MarkupSafe==1.1.10 +types-pkg-resources==0.1.3 +types-python-dateutil==2.8.19.6 +types-retry==0.9.9.1 +typing_extensions==4.4.0 +ui-tweaks @ file:///tmp/qbraid/wheels/ui_tweaks-0.1.1-py3-none-any.whl +uritemplate==4.1.1 +urllib3==1.26.14 +wcwidth==0.2.6 +webencodings==0.5.1 +websocket-client==1.3.3 +websockets==10.4 +Werkzeug==2.2.2 +widgetsnbextension==4.0.5 +wrapt==1.14.1 +xyzservices==2022.9.0 +yarl==1.8.2 +yfinance==0.2.6 +zipp==3.11.0