From e322d6a2e81be97810c0209c74999e9d4e8e1406 Mon Sep 17 00:00:00 2001 From: AnikenC Date: Wed, 21 Aug 2024 09:37:26 +0800 Subject: [PATCH 1/2] updated ppo to handle general noise --- .../general_noise_q_env_config.py | 242 ++ .../using_general_env.ipynb | 3706 +++++++++++++++++ rl_qoc/base_parametrised_q_env.py | 1541 +++++++ rl_qoc/general_noise_quantum_environment.py | 691 +++ rl_qoc/ppo_cleanrl.py | 445 ++ 5 files changed, 6625 insertions(+) create mode 100644 gate_level/spillover_noise_use_case/general_noise_q_env_config.py create mode 100644 gate_level/spillover_noise_use_case/using_general_env.ipynb create mode 100644 rl_qoc/base_parametrised_q_env.py create mode 100644 rl_qoc/general_noise_quantum_environment.py create mode 100644 rl_qoc/ppo_cleanrl.py diff --git a/gate_level/spillover_noise_use_case/general_noise_q_env_config.py b/gate_level/spillover_noise_use_case/general_noise_q_env_config.py new file mode 100644 index 0000000..5f32000 --- /dev/null +++ b/gate_level/spillover_noise_use_case/general_noise_q_env_config.py @@ -0,0 +1,242 @@ +from __future__ import annotations +from typing import Optional, Dict, List +import warnings +import os +import numpy as np +from rl_qoc.helper_functions import ( + generate_default_instruction_durations_dict, + select_backend, + get_q_env_config, + load_q_env_from_yaml_file, +) +from qiskit import QuantumCircuit, QuantumRegister, transpile +from qiskit.quantum_info import Operator +from qiskit.circuit import ParameterVector +from qiskit.providers import BackendV2 +import qiskit_aer.noise as noise +from qiskit_aer import AerSimulator +from qiskit.quantum_info import Operator +from qiskit.circuit.library import RXGate, IGate, CRXGate +from qiskit.providers.fake_provider import GenericBackendV2 +from qiskit.transpiler import InstructionDurations +from qiskit.transpiler import CouplingMap + +current_dir = os.path.dirname(os.path.realpath(__file__)) +config_file_name = "noise_q_env_gate_config.yml" +config_file_address = os.path.join(current_dir, config_file_name) + + +def apply_parametrized_circuit( + qc: QuantumCircuit, params: ParameterVector, q_reg: QuantumRegister, **kwargs +): + """ + Define ansatz circuit to be played on Quantum Computer. Should be parametrized with qiskit_pulse ParameterVector + This function is used to run the QuantumCircuit instance on a Runtime backend + :param qc: Quantum Circuit instance to add the gate on + :param params: Parameters of the custom Gate + :param q_reg: Quantum Register formed of target qubits + :return: + """ + target = kwargs["target"] + my_qc = QuantumCircuit(q_reg, name=f"{target['gate'].name}_cal") + optimal_params = np.pi * np.array([0.0, 0.0, 0.5, 0.5, -0.5, 0.5, -0.5]) + # optimal_params = np.pi * np.zeros(len(params)) + + my_qc.u( + optimal_params[0] + params[0], + optimal_params[1] + params[1], + optimal_params[2] + params[2], + q_reg[0], + ) + my_qc.u( + optimal_params[3] + params[3], + optimal_params[4] + params[4], + optimal_params[5] + params[5], + q_reg[1], + ) + + my_qc.rzx(optimal_params[6] + params[6], q_reg[0], q_reg[1]) + + qc.append(my_qc.to_instruction(label=my_qc.name), q_reg) + + +def get_backend_parametrised( + phi, + gamma, + print_noise_model, + real_backend: Optional[bool] = None, + backend_name: Optional[str] = None, + use_dynamics: Optional[bool] = None, + physical_qubits: Optional[list] = None, + channel: Optional[str] = None, + instance: Optional[str] = None, + solver_options: Optional[Dict] = None, + calibration_files: Optional[str] = None, +): + """ + Define backend on which the calibration is performed. + This function uses data from the yaml file to define the backend. + If provided parameters on the backend are null, then the user should provide the backend instance. + :param real_backend: If True, then calibration is performed on real quantum hardware, otherwise on simulator + :param backend_name: Name of the backend to be used, if None, then least busy backend is used + :param use_dynamics: If True, then DynamicsBackend is used, otherwise standard backend is used + :param physical_qubits: Physical qubits indices to be used for the calibration + :param channel: Qiskit Runtime Channel (for real backend) + :param instance: Qiskit Runtime Instance (for real backend) + :param solver_options: Options for the solver (for DynamicsBackend) + :param calibration_files: Path to the calibration files (for DynamicsBackend) + :return: Backend instance + """ + # Real backend initialization + + backend = select_backend( + real_backend, + channel, + instance, + backend_name, + use_dynamics, + physical_qubits, + solver_options, + calibration_files, + ) + + ### Random noise with Kraus operators ### + # dim = 4 # For a 4x4 system (e.g., 2 qubits) + # num_ops = 3 # Number of Kraus operators + # epsilon = 0.01 # Noise strength parameter + # kraus_ops_eps = generate_random_cptp_map(dim, num_ops, epsilon) + # noise_model = NoiseModel() + # noise_model.add_all_qubit_quantum_error(kraus_ops_eps, ['rzx']) + + ### Custom spillover noise model ### + global custom_rx_gate_label + + identity_op = Operator(IGate()) + rx_phi_gamma_op = Operator(RXGate(gamma * float(phi))) + ident_rx_op = rx_phi_gamma_op.tensor(identity_op) + + noise_model = noise.NoiseModel() + coherent_rx_noise = noise.coherent_unitary_error(ident_rx_op) + noise_model.add_quantum_error(coherent_rx_noise, [custom_rx_gate_label], [0, 1]) + noise_model.add_basis_gates(["unitary"]) + if print_noise_model: + print("\n", noise_model, "\n") + + generic_backend = GenericBackendV2( + num_qubits=2, + dtm=2.2222 * 1e-10, + basis_gates=["cx", "id", "rz", "sx", "x", "crx"], + ) + # backend = AerSimulator.from_backend(generic_backend, noise_model=noise_model) + backend = AerSimulator( + noise_model=noise_model, coupling_map=CouplingMap.from_full(5) + ) + # coupling_map=CouplingMap.from_full(5), + # method="density_matrix" + # ) + + if backend is None: + # TODO: Add here your custom backend + # For now use FakeJakartaV2 as a safe working custom backend + # backend = FakeProvider().get_backend("fake_jakarta") + from qiskit_ibm_runtime.fake_provider import FakeTorontoV2 + + # backend = FakeTorontoV2() + if backend is None: + warnings.warn("No backend was provided, State vector simulation will be used") + return backend + + +# Custom spillover noise model +phi = np.pi / 4 # rotation angle +gamma = 0.01 # spillover rate for the CRX gate +custom_rx_gate_label = "custom_kron(rx,ident)_gate" + + +def get_parameterised_circuit_context( + phi, + print_circuit, + backend: Optional[BackendV2], + initial_layout: Optional[List[int]] = None, +): + """ + Define the context of the circuit to be used in the training + :param backend: Backend instance + :return: QuantumCircuit instance + """ + global custom_rx_gate_label + + circuit = QuantumCircuit(2) + rx_op = Operator(RXGate(float(phi))) + identity_op = Operator(IGate()) + rx_op_2q = identity_op.tensor(rx_op) + circuit.unitary(rx_op_2q, [0, 1], label=custom_rx_gate_label) + + circuit.cx(0, 1) + + if backend is not None: + circuit = transpile(circuit, backend, optimization_level=1, seed_transpiler=42) + if print_circuit: + print("Circuit context") + print(circuit) + return circuit + + +def get_instruction_durations(backend: Optional[BackendV2] = None): + if backend is not None and backend.instruction_durations.duration_by_name_qubits: + instruction_durations = backend.instruction_durations + else: + # User input for default gate durations + single_qubit_gate_time = 1.6e-7 + two_qubit_gate_time = 5.3e-7 + readout_time = 1.2e-6 + reset_time = 1.0e-6 + virtual_gates = ["rz", "s", "t"] + + circuit_gate_times = { + "x": single_qubit_gate_time, + "sx": single_qubit_gate_time, + "h": single_qubit_gate_time, + "u": single_qubit_gate_time, + "cx": two_qubit_gate_time, + "rzx": two_qubit_gate_time, + "measure": readout_time, + "reset": reset_time, + } + circuit_gate_times.update({gate: 0.0 for gate in virtual_gates}) + + n_qubits = backend.num_qubits if backend else 10 + instruction_durations_dict = generate_default_instruction_durations_dict( + n_qubits=n_qubits, + single_qubit_gate_time=single_qubit_gate_time, + two_qubit_gate_time=two_qubit_gate_time, + circuit_gate_times=circuit_gate_times, + virtual_gates=virtual_gates, + ) + + instruction_durations = InstructionDurations() + instruction_durations.dt = 2.2222222222222221e-10 + instruction_durations.duration_by_name_qubits = instruction_durations_dict + + return instruction_durations + + +### Modified ### +params, backend_params, runtime_options = load_q_env_from_yaml_file(config_file_address) + +# Do not touch part below, just retrieve in your notebook training_config and circuit_context +# q_env_config = get_q_env_config( +# config_file_address, +# get_backend, +# apply_parametrized_circuit, +# ) +# q_env_config.backend_config.parametrized_circuit_kwargs = { +# "target": q_env_config.target, +# "backend": q_env_config.backend, +# } +# q_env_config.backend_config.instruction_durations_dict = get_instruction_durations( +# q_env_config.backend +# ) +# circuit_context = get_circuit_context( +# q_env_config.backend, q_env_config.physical_qubits +# ) diff --git a/gate_level/spillover_noise_use_case/using_general_env.ipynb b/gate_level/spillover_noise_use_case/using_general_env.ipynb new file mode 100644 index 0000000..f080cbc --- /dev/null +++ b/gate_level/spillover_noise_use_case/using_general_env.ipynb @@ -0,0 +1,3706 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "import logging\n", + "from gymnasium.wrappers import RescaleAction, ClipAction\n", + "\n", + "# Setting path for all packages\n", + "os.environ[\"KMP_DUPLICATE_LIB_OK\"] = \"True\"\n", + "module_path = os.path.abspath(\n", + " os.path.join(\n", + " \"/Users/chatt07/Desktop/new_context_env/Quantum_Optimal_Control\"\n", + " )\n", + ")\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + "\n", + "# Importing Config Files\n", + "from general_noise_q_env_config import (\n", + " params,\n", + " backend_params,\n", + " runtime_options,\n", + " apply_parametrized_circuit,\n", + " get_backend_parametrised,\n", + " get_parameterised_circuit_context,\n", + " get_instruction_durations\n", + ")\n", + "# Importing Environment\n", + "from rl_qoc.general_noise_quantum_environment import GeneralNoiseQuantumEnvironment\n", + "# Importing PPO\n", + "from rl_qoc.ppo_cleanrl import PPO_CleanRL\n", + "from rl_qoc.helper_functions import load_from_yaml_file\n", + "\n", + "logging.basicConfig(\n", + " level=logging.WARNING,\n", + " format=\"%(asctime)s INFO %(message)s\", # hardcoded INFO level\n", + " datefmt=\"%Y-%m-%d %H:%M:%S\",\n", + " stream=sys.stdout,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Backend with Aer Noise Model needs to reset\n", + "Circuit Context should either be parametrised and take phi, or be reset\n", + "\"\"\"\n", + "\n", + "from itertools import product\n", + "import sys\n", + "from typing import Dict, Optional, List, Any, TypeVar, SupportsFloat, Union\n", + "\n", + "import numpy as np\n", + "from gymnasium.spaces import Box\n", + "\n", + "# Qiskit imports\n", + "from qiskit import transpile\n", + "from qiskit.circuit import (\n", + " QuantumCircuit,\n", + " QuantumRegister,\n", + " ParameterVector,\n", + " CircuitInstruction,\n", + ")\n", + "from qiskit.quantum_info import state_fidelity, Statevector\n", + "from qiskit.transpiler import Layout\n", + "from qiskit_aer.backends import AerSimulator\n", + "from qiskit_aer.backends.aerbackend import AerBackend\n", + "from qiskit_aer.noise import NoiseModel\n", + "from qiskit_dynamics import DynamicsBackend\n", + "from qiskit_ibm_runtime import EstimatorV2\n", + "\n", + "from qiskit_ibm_runtime import IBMBackend as RuntimeBackend\n", + "\n", + "from rl_qoc.helper_functions import (\n", + " projected_statevector,\n", + " get_instruction_timings,\n", + " get_q_env_config,\n", + ")\n", + "from rl_qoc.qconfig import QEnvConfig, QiskitConfig\n", + "from rl_qoc.base_parametrised_q_env import (\n", + " GateTarget,\n", + " BaseParametrisedQuantumEnvironment,\n", + ")\n", + "from rl_qoc.custom_jax_sim import JaxSolver\n", + "\n", + "import logging\n", + "\n", + "logging.basicConfig(\n", + " level=logging.WARNING,\n", + " format=\"%(asctime)s INFO %(message)s\", # hardcoded INFO level\n", + " datefmt=\"%Y-%m-%d %H:%M:%S\",\n", + " stream=sys.stdout,\n", + ")\n", + "\n", + "ObsType = TypeVar(\"ObsType\")\n", + "ActType = TypeVar(\"ActType\")\n", + "\n", + "\n", + "def create_array(circ_trunc, batchsize, n_actions):\n", + " arr = np.empty((circ_trunc,), dtype=object)\n", + " for i in range(circ_trunc):\n", + " arr[i] = np.zeros((i + 1, batchsize, n_actions))\n", + " return arr\n", + "\n", + "\n", + "class GeneralNoiseQuantumEnvironment(BaseParametrisedQuantumEnvironment):\n", + "\n", + " def __init__(\n", + " self,\n", + " params,\n", + " backend_params,\n", + " runtime_options,\n", + " apply_parametrized_circuit,\n", + " get_backend_parametrised,\n", + " get_parameterised_circuit_context,\n", + " get_instruction_durations,\n", + " gamma,\n", + " circuit_param_distribution,\n", + " phi_low,\n", + " phi_max,\n", + " num_params,\n", + " discrete_history_length,\n", + " optimal_error_precision,\n", + " training_steps_per_gate: Union[List[int], int] = 1500,\n", + " intermediate_rewards: bool = False,\n", + " ):\n", + " self.params = params\n", + " self.backend_params = backend_params\n", + " self.runtime_options = runtime_options\n", + " self.apply_parametrized_circuit = apply_parametrized_circuit\n", + " self.get_backend_parametrised = get_backend_parametrised\n", + " self.get_parameterised_circuit_context = get_parameterised_circuit_context\n", + " self.get_instruction_durations = get_instruction_durations\n", + " self.gamma = gamma\n", + " self._training_steps_per_gate = training_steps_per_gate\n", + " self._intermediate_rewards = intermediate_rewards\n", + " self.circuit_fidelity_history = []\n", + " self.phi_low = phi_low\n", + " self.phi_max = phi_max\n", + " self.num_params = num_params\n", + " self.optimal_error_precision = optimal_error_precision\n", + " self.example_phi = phi_max\n", + " self.circuit_param_distribution = circuit_param_distribution\n", + "\n", + " # Making Example Backend and Circuit Context\n", + " self.example_backend = self.get_backend_parametrised(\n", + " phi=self.example_phi,\n", + " gamma=self.gamma,\n", + " print_noise_model=True,\n", + " **self.backend_params,\n", + " )\n", + " self.backend_config = QiskitConfig(\n", + " self.apply_parametrized_circuit,\n", + " self.example_backend,\n", + " estimator_options=(\n", + " self.runtime_options\n", + " if isinstance(self.example_backend, RuntimeBackend)\n", + " else None\n", + " ),\n", + " # parametrized_circuit_kwargs=parametrized_circ_args,\n", + " )\n", + " self.q_env_config = QEnvConfig(\n", + " backend_config=self.backend_config, **self.params\n", + " )\n", + " self.q_env_config.backend_config.parametrized_circuit_kwargs = {\n", + " \"target\": self.q_env_config.target,\n", + " \"backend\": self.q_env_config.backend,\n", + " }\n", + " self.q_env_config.backend_config.instruction_durations_dict = (\n", + " self.get_instruction_durations(self.q_env_config.backend)\n", + " )\n", + " print_circuit = True\n", + " self.circuit_context = self.get_parameterised_circuit_context(\n", + " self.example_phi, print_circuit, self.example_backend\n", + " )\n", + "\n", + " # Define target register and nearest neighbor register for truncated circuits\n", + " self.circ_tgt_register = QuantumRegister(\n", + " bits=[\n", + " self.circuit_context.qubits[i]\n", + " for i in self.q_env_config.physical_qubits\n", + " ],\n", + " name=\"tgt\",\n", + " )\n", + "\n", + " # Adjust target register to match it with circuit context\n", + " self.target_instruction = CircuitInstruction(\n", + " self.q_env_config.target[\"gate\"],\n", + " (qubit for qubit in self.circ_tgt_register),\n", + " )\n", + " self._tgt_instruction_counts = self.circuit_context.data.count(\n", + " self.target_instruction\n", + " )\n", + " if self.tgt_instruction_counts == 0:\n", + " raise ValueError(\"Target gate not found in circuit context\")\n", + "\n", + " self._parameters = [\n", + " ParameterVector(f\"a_{j}\", self.q_env_config.n_actions)\n", + " for j in range(self.tgt_instruction_counts)\n", + " ]\n", + "\n", + " # Store time and instruction indices where target gate is played in circuit\n", + " try:\n", + " self._op_start_times = self.circuit_context.op_start_times\n", + " except AttributeError:\n", + " self._op_start_times = get_instruction_timings(self.circuit_context)\n", + "\n", + " ### Very important, keep after _op_start_times ###\n", + " super().__init__(self.q_env_config)\n", + "\n", + " self._target_instruction_timings = []\n", + " for i, instruction in enumerate(self.circuit_context.data):\n", + " if instruction == self.target_instruction:\n", + " self._target_instruction_timings.append(self._op_start_times[i])\n", + "\n", + " self._param_values = create_array(\n", + " self.tgt_instruction_counts, self.batch_size, self.action_space.shape[-1]\n", + " )\n", + " self.observation_space = Box(\n", + " low=np.array([-1.0]), high=np.array([1.0]), dtype=np.float32\n", + " ) # multiply by pi for actual values\n", + " self.phi_bound = 0.0\n", + "\n", + " self.discrete_reward_history = np.ones((discrete_history_length, num_params))\n", + " self.discrete_obs_vals = np.linspace(\n", + " self.observation_space.low, self.observation_space.high, self.num_params\n", + " ).flatten()\n", + " print(f\"Observation Vals: {self.discrete_obs_vals}\")\n", + "\n", + " def define_target_and_circuits(self):\n", + " \"\"\"\n", + " Define target gate and circuits for calibration\n", + " \"\"\"\n", + "\n", + " assert \"gate\" in self.config.target, \"Target should be a gate\"\n", + "\n", + " # Build registers for all relevant qubits\n", + " circ_nn_register, circ_anc_register = (\n", + " QuantumRegister(\n", + " bits=[self.circuit_context.qubits[i] for i in qubits],\n", + " name=reg_name,\n", + " )\n", + " for reg_name, qubits in zip(\n", + " [\"nn\", \"anc\"],\n", + " [self.physical_neighbor_qubits, self.physical_next_neighbor_qubits],\n", + " )\n", + " )\n", + " tgt_register = QuantumRegister(len(self.physical_target_qubits), name=\"tgt\")\n", + " layouts = [\n", + " Layout(\n", + " {\n", + " tgt_register[i]: self.physical_target_qubits[i]\n", + " for i in range(tgt_register.size)\n", + " }\n", + " )\n", + " for _ in range(self.tgt_instruction_counts)\n", + " ]\n", + " nn_registers, anc_registers = [\n", + " [QuantumRegister(1, name=f\"{name}_{i}\") for i in range(reg.size)]\n", + " for name, reg in zip([\"nn\", \"anc\"], [circ_nn_register, circ_anc_register])\n", + " ]\n", + " # Create mapping between circuit context qubits and custom circuit associated single qubit registers\n", + " mapping = {\n", + " circ_reg[i]: reg[i]\n", + " for circ_reg, reg in zip(\n", + " [circ_nn_register, self.circ_tgt_register, circ_anc_register],\n", + " [nn_registers, tgt_register, anc_registers],\n", + " )\n", + " for i in range(circ_reg.size)\n", + " }\n", + "\n", + " # Initialize custom and baseline circuits for each target gate (by default only contains target qubits)\n", + " custom_circuits, baseline_circuits = [\n", + " [\n", + " QuantumCircuit(tgt_register, name=name + str(i))\n", + " for i in range(self.tgt_instruction_counts)\n", + " ]\n", + " for name in [\"c_circ_trunc_\", \"b_circ_trunc_\"]\n", + " ]\n", + " # Build sub-circuit contexts: each circuit goes until target gate and preserves nearest neighbor operations\n", + " for i in range(self.tgt_instruction_counts): # Loop over target gates\n", + " counts = 0\n", + " for start_time, instruction in zip(\n", + " self._op_start_times, self.circuit_context.data\n", + " ): # Loop over instructions in circuit context\n", + "\n", + " # Check if instruction involves target or nearest neighbor qubits\n", + " involves_target_qubits = any(\n", + " [\n", + " qubit in reg\n", + " for reg in [self.circ_tgt_register, circ_nn_register]\n", + " for qubit in instruction.qubits\n", + " ]\n", + " )\n", + " if involves_target_qubits:\n", + " involved_qubits = [\n", + " qubit\n", + " for qubit in instruction.qubits\n", + " if qubit not in self.circ_tgt_register\n", + " ]\n", + " else:\n", + " involved_qubits = []\n", + "\n", + " # If instruction involves target or nn qubits and happens before target gate, add it to custom circuit\n", + "\n", + " if (\n", + " counts <= i or start_time <= self._target_instruction_timings[i]\n", + " ) and involves_target_qubits:\n", + " for qubit in involved_qubits:\n", + " if (\n", + " mapping[qubit] not in custom_circuits[i].qregs\n", + " ): # Add register if not already added\n", + " baseline_circuits[i].add_register(mapping[qubit])\n", + " custom_circuits[i].add_register(mapping[qubit])\n", + " if (\n", + " self.circuit_context.layout.final_layout is not None\n", + " ): # Update physical layout\n", + " layouts[i].add(\n", + " mapping[qubit][0],\n", + " self.circuit_context.layout.final_layout[qubit],\n", + " )\n", + " else:\n", + " layouts[i].add(\n", + " mapping[qubit][0],\n", + " self.circuit_context.qubits.index(qubit),\n", + " )\n", + "\n", + " baseline_circuits[i].append(\n", + " instruction.operation,\n", + " (\n", + " (\n", + " mapping[q][0]\n", + " if q not in self.circ_tgt_register\n", + " else mapping[q]\n", + " )\n", + " for q in instruction.qubits\n", + " ),\n", + " )\n", + " if instruction != self.target_instruction:\n", + " custom_circuits[i].append(\n", + " instruction.operation,\n", + " (\n", + " (\n", + " mapping[q][0]\n", + " if q not in self.circ_tgt_register\n", + " else mapping[q]\n", + " )\n", + " for q in instruction.qubits\n", + " ),\n", + " )\n", + " else: # Add custom instruction in place of target gate\n", + " try:\n", + " self.parametrized_circuit_func(\n", + " custom_circuits[i],\n", + " self.parameters[counts],\n", + " tgt_register,\n", + " **self._func_args,\n", + " )\n", + " except TypeError:\n", + " raise TypeError(\"Failed to call parametrized_circuit_func\")\n", + " counts += 1\n", + " # custom_circuits[i] = remove_unused_wires(custom_circuits[i])\n", + " # baseline_circuits[i] = remove_unused_wires(baseline_circuits[i])\n", + "\n", + " target = GateTarget(\n", + " self.config.target[\"gate\"],\n", + " self.physical_target_qubits,\n", + " self.config.n_reps,\n", + " baseline_circuits,\n", + " tgt_register,\n", + " layouts,\n", + " )\n", + " return target, custom_circuits, baseline_circuits\n", + "\n", + " def reset(\n", + " self,\n", + " override_obs: Optional[np.ndarray] = None,\n", + " seed: Optional[int] = None,\n", + " options: Optional[Dict[str, Any]] = None,\n", + " ) -> tuple[ObsType, dict[str, Any]]:\n", + " \"\"\"Reset the Environment, chooses a new input state\"\"\"\n", + " super().reset(seed=seed)\n", + "\n", + " if self.circuit_param_distribution == \"uniform\":\n", + " self.phi_bound = np.random.uniform(\n", + " low=self.observation_space.low, high=self.observation_space.high\n", + " )\n", + " if self.circuit_param_distribution == \"normal\":\n", + " self.phi_bound = np.random.normal(loc=0.0, scale=0.5, size=None)\n", + " self.phi_bound = np.clip(\n", + " self.phi_bound,\n", + " a_min=self.observation_space.low,\n", + " a_max=self.observation_space.high,\n", + " )\n", + " if self.circuit_param_distribution == \"simple_discrete\":\n", + " self.phi_bound = np.random.choice(\n", + " a=self.discrete_obs_vals, size=len(self.observation_space.shape), replace=True\n", + " )\n", + " if self.circuit_param_distribution == \"moving_discrete\":\n", + " self.prob_weights = (np.mean(\n", + " self.discrete_reward_history, axis=0\n", + " ) + np.log10(self.optimal_error_precision)) ** 2\n", + " self.prob_weights /= np.sum(self.prob_weights)\n", + " self.phi_bound = np.random.choice(\n", + " a=self.discrete_obs_vals, size=len(self.observation_space.shape), replace=True, p=self.prob_weights\n", + " )\n", + " if override_obs is not None:\n", + " self.phi_bound = override_obs\n", + " self._param_values = create_array(\n", + " self.tgt_instruction_counts, self.batch_size, self.action_space.shape[0]\n", + " )\n", + " self._inside_trunc_tracker = 0\n", + "\n", + " self.phi_rad = (\n", + " self.phi_bound * (self.phi_max - self.phi_low) / 2 + (self.phi_max + self.phi_low) / 2\n", + " ) # scaling factor for radian parameters\n", + " assert self.phi_rad <= self.phi_max\n", + " assert self.phi_rad >= self.phi_low\n", + "\n", + " # Making Backend and Circuit Context\n", + " self.step_backend = self.get_backend_parametrised(\n", + " phi=self.phi_rad,\n", + " gamma=self.gamma,\n", + " print_noise_model=False,\n", + " **self.backend_params,\n", + " )\n", + " self.step_backend_config = QiskitConfig(\n", + " self.apply_parametrized_circuit,\n", + " self.step_backend,\n", + " estimator_options=(\n", + " self.runtime_options\n", + " if isinstance(self.step_backend, RuntimeBackend)\n", + " else None\n", + " ),\n", + " # parametrized_circuit_kwargs=parametrized_circ_args,\n", + " )\n", + " self.step_q_env_config = QEnvConfig(\n", + " backend_config=self.step_backend_config, **self.params\n", + " )\n", + " self.step_q_env_config.backend_config.parametrized_circuit_kwargs = {\n", + " \"target\": self.step_q_env_config.target,\n", + " \"backend\": self.step_q_env_config.backend,\n", + " }\n", + " self.step_q_env_config.backend_config.instruction_durations_dict = (\n", + " self.get_instruction_durations(self.step_q_env_config.backend)\n", + " )\n", + " print_circuit = False\n", + " self.step_circuit_context = self.get_parameterised_circuit_context(\n", + " self.phi_rad, print_circuit, self.step_backend\n", + " )\n", + "\n", + " # Redefining Targets based on new phi\n", + " self.extract_from_config(\n", + " self.step_q_env_config\n", + " ) # effectively reruns super.__init__() functionalities\n", + "\n", + " return self._get_obs(), self._get_info()\n", + "\n", + " def step(\n", + " self, action: ActType\n", + " ) -> tuple[ObsType, SupportsFloat, bool, bool, dict[str, Any]]:\n", + "\n", + " # trunc_index tells us which circuit truncation should be trained\n", + " # Dependent on global_step and method select_trunc_index\n", + " trunc_index = self.trunc_index\n", + " # Figure out if in middle of param loading or should compute the final reward (step_status < trunc_index or ==)\n", + " step_status = self._inside_trunc_tracker\n", + " self._step_tracker += 1\n", + "\n", + " if self._episode_ended:\n", + " terminated = True\n", + " return (\n", + " self.reset()[0],\n", + " np.zeros(self.batch_size),\n", + " terminated,\n", + " False,\n", + " self._get_info(),\n", + " )\n", + "\n", + " if trunc_index >= self.tgt_instruction_counts:\n", + " # raise IndexError(f\"Circuit does contain only {self.tgt_instruction_counts} target gates and step\"\n", + " # f\" function tries to access gate nb {trunc_index} \")\n", + " truncated = True\n", + " return (\n", + " self.reset()[0],\n", + " np.zeros(self.batch_size),\n", + " False,\n", + " truncated,\n", + " self._get_info(),\n", + " )\n", + "\n", + " params, batch_size = np.array(action), len(np.array(action))\n", + " if batch_size != self.batch_size:\n", + " raise ValueError(\n", + " f\"Action batch size {batch_size} does not match environment batch size {self.batch_size}\"\n", + " )\n", + " self._param_values[trunc_index][step_status] = params\n", + " params = np.reshape(\n", + " np.vstack([param_set for param_set in self._param_values[trunc_index]]),\n", + " (self.batch_size, (trunc_index + 1) * self.action_space.shape[-1]),\n", + " )\n", + " if step_status < trunc_index: # Intermediate step within the circuit truncation\n", + " self._inside_trunc_tracker += 1\n", + " terminated = False\n", + "\n", + " if self._intermediate_rewards:\n", + " reward = self.perform_action(params)\n", + " obs = reward # Set observation to obtained reward (might not be the smartest choice here)\n", + " return obs, reward, terminated, False, self._get_info()\n", + " else:\n", + " return (\n", + " self._get_obs(),\n", + " np.zeros(batch_size),\n", + " terminated,\n", + " False,\n", + " self._get_info(),\n", + " )\n", + "\n", + " else:\n", + " terminated = self._episode_ended = True\n", + " reward = self.perform_action(params)\n", + " if self._intermediate_rewards:\n", + " obs = reward\n", + " else:\n", + " obs = self._get_obs()\n", + "\n", + " # Using Negative Log Error as the Reward\n", + " if np.mean(reward) > self._max_return:\n", + " self._max_return = np.mean(reward)\n", + " self._optimal_action = self.mean_action\n", + " self.reward_history.append(reward)\n", + " assert (\n", + " len(reward) == self.batch_size\n", + " ), f\"Reward table size mismatch {len(reward)} != {self.batch_size} \"\n", + " assert not np.any(np.isinf(reward)) and not np.any(\n", + " np.isnan(reward)\n", + " ), \"Reward table contains NaN or Inf values\"\n", + " max_fidelity = 1.0 - self.optimal_error_precision\n", + " reward = np.clip(reward, a_min=0.0, a_max=max_fidelity)\n", + " reward = -np.log10(1.0 - reward)\n", + " if self.circuit_param_distribution in [\n", + " \"simple_discrete\",\n", + " \"moving_discrete\",\n", + " ]:\n", + " self.update_discrete_history(reward, obs)\n", + " self.rl_reward_history.append(reward)\n", + "\n", + " return obs, reward, terminated, False, self._get_info()\n", + "\n", + " def update_discrete_history(self, reward, obs):\n", + " obs_ind = np.argmin(np.abs(self.discrete_obs_vals - obs))\n", + " print(obs.shape)\n", + " print(reward.shape)\n", + " self.discrete_reward_history[:, obs_ind] = np.append(\n", + " [np.mean(reward)], self.discrete_reward_history[:-1, obs_ind], axis=0\n", + " )\n", + "\n", + " def _get_obs(self):\n", + " return np.array([self.phi_bound])\n", + "\n", + " def compute_benchmarks(self, qc: QuantumCircuit, params: np.array) -> np.array:\n", + " \"\"\"\n", + " Method to store in lists all relevant data to assess performance of training (fidelity information)\n", + " :param params: Batch of actions\n", + " \"\"\"\n", + " new_qc = qc.copy()\n", + " n_actions = self.action_space.shape[-1]\n", + " n_custom_instructions = (\n", + " self.trunc_index + 1\n", + " ) # Count custom instructions present in the current truncation\n", + " baseline_circ = self.baseline_circuits[self.trunc_index]\n", + " target = Statevector(baseline_circ)\n", + "\n", + " if (\n", + " self.config.check_on_exp\n", + " ): # Perform real experiments to retrieve from measurement data fidelities\n", + " # Assess circuit fidelity with ComputeUncompute algo\n", + " try:\n", + " # job = self.fidelity_checker.run(\n", + " # [qc] * len(params),\n", + " # [baseline_circ] * len(params),\n", + " # values_1=params,\n", + " # )\n", + " # circuit_fidelities = job.result().fidelities\n", + " angle_sets = np.clip(\n", + " np.random.normal(\n", + " self.mean_action,\n", + " self.std_action,\n", + " size=(self.config.benchmark_batch_size, n_actions),\n", + " ),\n", + " self.action_space.low,\n", + " self.action_space.high,\n", + " )\n", + "\n", + " print(\"Starting Direct Fidelity Estimation...\")\n", + " observables, shots = self.retrieve_observables(\n", + " self._input_state.target_state,\n", + " self.circuits[self.trunc_index],\n", + " self.config.benchmark_config.dfe_precision,\n", + " )\n", + " if self.abstraction_level == \"circuit\":\n", + " new_qc = self.backend_info.custom_transpile(\n", + " new_qc,\n", + " initial_layout=self.layout[self.trunc_index],\n", + " scheduling=False,\n", + " )\n", + " pubs = [\n", + " (\n", + " new_qc,\n", + " obs.apply_layout(new_qc.layout),\n", + " angle_sets,\n", + " 1 / np.sqrt(shot),\n", + " )\n", + " for obs, shot in zip(\n", + " observables.group_commuting(qubit_wise=True), shots\n", + " )\n", + " ]\n", + " if isinstance(self.estimator, EstimatorV2):\n", + " self.estimator.options.update(\n", + " job_tags=[f\"DFE_step{self._step_tracker}\"]\n", + " )\n", + " job = self.estimator.run(pubs=pubs)\n", + " results = job.result()\n", + " circuit_fidelities = np.sum(\n", + " [result.data.evs for result in results], axis=0\n", + " ) / len(observables)\n", + " print(\"Finished DFE\")\n", + " except Exception as exc:\n", + " self.close()\n", + " raise exc\n", + "\n", + " else: # Perform ideal simulation at circuit or pulse level\n", + " if self.abstraction_level == \"circuit\":\n", + " # Calculate circuit fidelity with statevector simulation\n", + " if isinstance(self.backend, AerBackend):\n", + " backend = self.backend\n", + " elif self.backend is None:\n", + " backend = AerSimulator(method=\"statevector\")\n", + "\n", + " else:\n", + " noise_model = NoiseModel.from_backend(self.backend)\n", + " backend = AerSimulator(\n", + " noise_model=noise_model, method=\"density_matrix\"\n", + " )\n", + " new_qc.save_density_matrix()\n", + " circ = transpile(new_qc, backend=backend, optimization_level=0)\n", + "\n", + " states_result = backend.run(\n", + " circ,\n", + " parameter_binds=[\n", + " {\n", + " self._parameters[i][j]: params[:, i * n_actions + j]\n", + " for i in range(n_custom_instructions)\n", + " for j in range(n_actions)\n", + " }\n", + " ],\n", + " ).result()\n", + " output_states = [\n", + " states_result.data(i)[\"density_matrix\"]\n", + " for i in range(self.batch_size)\n", + " ]\n", + "\n", + " else: # Pulse simulation\n", + " # Calculate circuit fidelity with pulse simulation\n", + " if isinstance(self.backend, DynamicsBackend) and isinstance(\n", + " self.backend.options.solver, JaxSolver\n", + " ):\n", + " # Jax compatible pulse simulation\n", + "\n", + " output_states = np.array(self.backend.options.solver.batched_sims)[\n", + " :, 1, :\n", + " ]\n", + "\n", + " output_states = [\n", + " projected_statevector(s, self.backend.options.subsystem_dims)\n", + " for s in output_states\n", + " ]\n", + "\n", + " else:\n", + " raise NotImplementedError(\n", + " \"Pulse simulation not yet implemented for this backend\"\n", + " )\n", + " circuit_fidelities = [\n", + " state_fidelity(state, Statevector(baseline_circ))\n", + " for state in output_states\n", + " ]\n", + " # circuit_fidelities = [state_fidelity(partial_trace(state,\n", + " # list(range(state.num_qubits))[target.num_qubits:]),\n", + " # partial_trace(Statevector(baseline_circ),\n", + " # list(range(state.num_qubits))[target.num_qubits:]))\n", + " # for state in output_states]\n", + " self.circuit_fidelity_history.append(np.mean(circuit_fidelities))\n", + " print(\"Fidelity stored\", self.circuit_fidelity_history[-1])\n", + " return circuit_fidelities\n", + "\n", + " @property\n", + " def parameters(self) -> List[ParameterVector]:\n", + " return self._parameters\n", + "\n", + " @property\n", + " def fidelity_history(self):\n", + " return self.circuit_fidelity_history\n", + "\n", + " @property\n", + " def tgt_instruction_counts(self) -> int:\n", + " return self._tgt_instruction_counts\n", + "\n", + " @property\n", + " def trunc_index(self) -> int:\n", + " if self._intermediate_rewards:\n", + " return self.step_tracker % self.tgt_instruction_counts\n", + " else:\n", + " return np.min(\n", + " [\n", + " self._step_tracker // self.training_steps_per_gate,\n", + " self.tgt_instruction_counts - 1,\n", + " ]\n", + " )\n", + "\n", + " @property\n", + " def training_steps_per_gate(self) -> int:\n", + " return self._training_steps_per_gate\n", + "\n", + " @training_steps_per_gate.setter\n", + " def training_steps_per_gate(self, nb_of_steps: int):\n", + " try:\n", + " assert nb_of_steps > 0 and isinstance(nb_of_steps, int)\n", + " self._training_steps_per_gate = nb_of_steps\n", + " except AssertionError:\n", + " raise ValueError(\"Training steps number should be positive integer.\")\n", + "\n", + " def episode_length(self, global_step: int) -> int:\n", + " # assert (\n", + " # global_step == self.step_tracker\n", + " # ), \"Given step not synchronized with internal environment step counter\"\n", + " return 1 + self.trunc_index\n", + "\n", + " def clear_history(self) -> None:\n", + " \"\"\"Reset all counters related to training\"\"\"\n", + " super().clear_history()\n", + " self.circuit_fidelity_history.clear()\n", + " self.discrete_reward_history = np.ones_like(self.discrete_reward_history)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Observation Vals: [-1. -0.875 -0.75 -0.625 -0.5 -0.375 -0.25 -0.125 0. 0.125\n", + " 0.25 0.375 0.5 0.625 0.75 0.875 1. ]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "q_env = GeneralNoiseQuantumEnvironment(\n", + " params,\n", + " backend_params,\n", + " runtime_options,\n", + " apply_parametrized_circuit,\n", + " get_backend_parametrised,\n", + " get_parameterised_circuit_context,\n", + " get_instruction_durations,\n", + " gamma=0.3,\n", + " circuit_param_distribution=\"moving_discrete\",\n", + " phi_low=-1.5 * np.pi,\n", + " phi_max=+1.5 * np.pi,\n", + " optimal_error_precision=1e-4,\n", + " num_params=17,\n", + " discrete_history_length=3,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.]]\n", + "Fidelity stored 0.9999999999999996\n", + "(1, 1)\n", + "(32,)\n", + "[[0.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "zeros_action = np.zeros((32, 7))\n", + "\n", + "next_obs, _ = q_env.reset(seed=1)\n", + "print(next_obs)\n", + "obs, reward, terminated, truncated, info = q_env.step(zeros_action)\n", + "print(obs)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(17,)\n" + ] + } + ], + "source": [ + "print(q_env.discrete_obs_vals.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5. 1. 1.]\n" + ] + } + ], + "source": [ + "d_history = q_env.discrete_reward_history\n", + "\n", + "reward = 5\n", + "obs_ind = 10\n", + "\n", + "d_history[:, obs_ind] = np.append([reward], d_history[:-1, obs_ind])\n", + "print(d_history[:, obs_ind])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwUAAACuCAYAAABnVqHJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA2UElEQVR4nO3deXwN1//H8dfNzb6QhJDYCUFC7WpXS6ml1FJdqOq3u1LVKkqrql90+1ZX3VT7/ba6oqW20ioVS1TUGrFGIiERSZB9u/f3R5r7k+ZmJaK57+fjkcfDnTlz5sy4mcxnzpnzMZjNZjMiIiIiImKz7Cq7ASIiIiIiUrkUFIiIiIiI2DgFBSIiIiIiNk5BgYiIiIiIjVNQICIiIiJi4xQUiIiIiIjYOAUFIiIiIiI2TkGBiIiIiIiNU1AgIiIiImLjFBSIiIiIiNg4BQUiIiIiIjZOQYGIiIiIiI1TUCAiIiIiYuMUFIiIiIiI2DgFBSIiIiIiNk5BgYiIiIiIjVNQICIiIiJi4xQUiIiIiIjYOAUFIiIiIiI2TkGBiIiIiIiNU1AgIiIiImLjFBSIiIiIiNg4BQUiIiIiIjZOQYGIiIiIiI1TUCAiIiIiYuMUFIiIiIiI2DgFBSIiIiIiNk5BgYiIiIiIjVNQICIiIiJi4xQUiIiIiIjYOAUFIiIiIiI2TkGBiIiIiIiNU1AgIiIiImLjFBSIiIiIiNg4BQUiIiIiIjZOQYGIiIiIiI1TUCAiIiIiYuPsK7sBUrnMZjM56ZmV3QwRsQH2Lk4YDIZyb6/rlYiIdVd7fQUFBTYvJz2TZf7jKrsZImIDxp78EgdX53Jvr+uViIh1V3t9BQ0fEhERERGxeQoKRERERERsnIICEREREREbp6BARERERMTGKSgQEREREbFxCgpERERERGycggIRERERERunoEBERERExMYpKBARERERsXEKCkREREREbJyCAhERERERG2df2Q2oaG+88QYpKSlMnTqV6tWr/2PqFhERERG5Xgxms9lc2Y2oKJcuXcLLywtnZ2eSk5MxGo3/iLqvp+y0DJb5j6vsZoiIDRh78kscXJ3Lvb2uVyIi1l3t9RWq+PChvXv3Yjabad269TW/aa/IukVERERErqcqPXxo7969ALRr1+4fVfcNx2Ag8OEhNL/vVtzr+ZCRcJmIn3aw77VvyUnPrOzWiYj8P12vRETKpUr2FKxYsQKDwcC0adMA+OijjzAYDJafBQsWWMrGxsYyZcoUGjdujLOzM82aNeO1117DZDIxYcIEDAYDS5YsKVfdVUXneRPo/NIELh6LZtfzSzm9ZieBDw6m3/9mgsFQ2c0TEbHQ9UpEpHyqZE9Bamoq3bt3JzQ0lIyMDNq1a4erq6tlfbdu3QAICQlh8ODBJCYm4u7uTlBQENHR0cyYMYOIiAiOHDkCQNu2bctcd1XhGVCPlv8axOm1u9jy0BuW5clR5+ky/0Ea39GdiB+CK7GFIiJ5dL0SESm/KhkUjB8/nnHjxuHh4QHA5s2b8fT0LFAmNjaW4cOHk5iYyMyZM5kzZw4uLi6YzWbmz5/PnDlzcHBwwGg00qpVqzLVXZU0HtEDg50dYZ+sLbD8+LJf6DB7LP6jeumPrIjcEHS9EhEpvyo5fAjg2LFjpKWl0bBhQ6s37ZMmTSIuLo4nnniChQsX4uLiAoDBYGD27NkEBgaSlZVFQEAAzs7OZaq7KqnZtimm3Fwu/Hm8wPLczGwSD52mZlv/SmqZiEhBul6JiJRflQ0K9u3bBxQc+pPv0KFDrFy5Ek9PTxYuXFhovcFgoGPHjkVuX1zd+SIiIhg2bBgeHh54eXkxfvx4EhISynoYlc61theZicmYsnIKrUuLTcS5RnXsHKpkh5OI/MPoeiUiUn5V9upY3I37N998g9lsZuzYsZZhQH/n5OQEQJs2bcpUN0BycjJ9+vTB29ubr7/+mvT0dKZPn87QoUPZvn07dnZlj8U6duxIbGxsmbcriYPZjhfpXOR6o4sTuVnZVtflZuYtt3dxJCu78B9hEZErBTQLINtgKvf2ul6JiFiXf3319fVlz5495arDJoOCzZs3A9CvX78itz979ixQvqDg448/JiYmht9//50GDRoAUK9ePbp168bq1au54447SncQV4iNjSUmJqbM25XE0WCE2kWvz03PxMHNerZmo5MDADnpWde8XSJS9Zw9d5Ysc265t9f1SkTEuqu9voKNBgVnzpwBsNyw/11ubi4hISFA+YKCNWvW0KNHjwL1d+3alSZNmvDTTz+VKyjw9fUt8zal4WC2g2Ie3KXFJVE9oB52jvaFuuRdfb3JSLiESU/dRKQU6vjVueqeAl2vREQKy7++Xs39YpUMCuLi4oiLi8PT05NGjRoVWp+amgpATo71Pw6rVq0iPj6eWrVq4efnV6a6AcLCwrjzzjsLLQ8KCiIsLKxsB/OX8nYFlSQ7LYNl/uOKXH9h3wnq3tKWmu2acT7kiGW50ckB71aNiNt1pMhtRUSudOz4MRxcnUsuWARdr0RErLva6ytU0ReNjx49CkBAQIDV9fk3+qGhoYXWJSUl8eyzzwLWewlKqju/DmuzEnl7e5OYmFh8428wEat2YDaZCHx4SIHlzcb2x8HVmVMrf6+klomIFKTrlYhI+VXJngI3NzcAoqOjSU1NtXzO179/f8LCwliwYAG9e/cmKCgIgPDwcO677z5OnToFWA8KSqq7qrkYHkX4Zxto+eBg+nz6LNG/7qV6s7oEPjiY2B2HObVSc36LyI1B1ysRkfKrkkFBUFAQDRo0ICoqigYNGhAQEIDRaGTcuHE89thjTJ8+nWXLlhETE0ObNm0sT/3Dw8Np164dgwcPZt26dbRv377MdQN4eXlx8eLFQtsmJibi7e1docdeEXbP+ZyUM/EEjOtPvX7tyUi8zJGl6/nztW/BbK7s5omIWOh6JSJSPlUyKHB2dmb9+vXMmjWLXbt2ERISgtlstty0161bl+DgYKZPn86WLVuIioqiRYsWLFq0iMcffxx//7wENz169Chz3QAtW7a0+u5AWFgYvXr1qqCjrjhmk4nDH/3E4Y9+quymiIgUS9crEZHyqZJBAUBgYCA//vhjketbtGjB6tWrCy0PDg4mOjqa9u3bU79+/XLVPXToUGbNmkV0dDT16tUDICQkhJMnT/L666+X6ThERERERCpalXzRuLzS0tIsT/wnT55c7noeeeQR/Pz8GD58OGvWrGH58uXcc889dO7cmeHDh1+r5oqIiIiIXBM2GRQ8//zzluRk+cLCwhg8eDCHDx+mZ8+ejB8/vtz1V6tWjc2bN+Pn58fdd9/NQw89RLdu3VizZk25shmLiIiIiFSkKjt8qCiRkZHMnz+fBQsW0LRpU7y9vTl//jwREREAdOvWjZUrV171zbu/vz9r1qy5Fk0WEREREalQNvfY2tXVlalTpxIUFMSFCxcIDQ0lOTmZ/v37s3TpUrZu3UrNmjUru5kiIiIiIteNzfUU+Pj48Oabb1Z2M0REREREbhg211MgIiIiIiIFKSgQERER+Qfp8dYTTDi3vLKbIVWMggIRERERERunoEBERERExMYpKBARERERsXE2N/uQiIiI2CY7B3sCHx5CkxE9qOZfB1N2DpcjYjnx7W+Ef7YBezdnhm16HXtXZ1b3e4aMhMuWbds/dy83PTmS4KmLOfHN5jLt16ORLzdNGUmdXm1wrlmNzMRkLuw7yf5F35Nw4BQAdXq3odk9fanZtikutTwxZeUQv+8EB95eQdzOsGt6HkSsUU+BiIiIVHl2Dvbc+vXzdHzhPtIvXOLP175l7ytfk3DgJA0H3wxATmoGWx9/CydPd3q8M9myrV+P1rR6Yjinfgguc0BQo40/t//8Ko2HdydqfQghzy/lyNL1GJ3s8enY3FKu6ZhbcPJ05+T3Wwl5fimHP16DZ9O6DPzuRWrd3PLanASRYqinQERERKq8wIeH4Ne9FQfeWcnehV8VXGkwWP6ZsP8koQuX0XnuBIIeG8bJ77fQ870nSY2+wM7pH5V5vz3eegKjowNrBj9H0pFIy/KD7/5QYL87pn1ITnpmgW2P/m8jd2xdxE2TR/BLyJEy71ukLBQUiIiISJXXZGRPMpOS2f/m94VXms0FPoZ9tAa/Hq1p/9w9NBrWFScvd9YPf4HslPQy7dO7VWO8WjQg/L8/FwgIrO33yoDA3tUZo5M9ZpOJ+L3H8WkfUKb9ipSHggIRERGp8qo18SPx0GlyM7NLVT54ynuM3P4uPu2aEbrwKy7sO1H2fTb2BSDxUESJZT0a1qb9zHupc0sbnDzdC6wzm0xl3rdIWSkoEBEREfmb2l0CLTfn3kGNKnRf9q7O3PbDPBxcnQn7ZC1J4ZFkp2RgNploPXkkdXq2rtD9i4BeNBa54bjX82HCueW0fWZMZTelWM41qnHv0f/SbGz/67bP21a8xOjdi0tV1rdrEBPOLafpmFsqtlGlcPvG1+i+aGJlN0PEpl0+eZbqTetg51jy81C3ujXp/sZjJB2J5NCHq2k8rFu5rnWXT50DSg4q/Hq2xs2vBrtf/Jx9//mOyLUhnN26n3PbDuLg6lTm/YqUh4ICqfKajrmFwIeHVHYzqpx2M+8hI+FymWfiqKoCHx5SZACy743v8L+zd4U/bSwr93o+tH1mzA3XLpGKcHLlNpy8PGjz1Ohiyxns7Oi1eApGZ0e2PLaI0H9/yfk/jtJ53gSqN6tbpn0mHj5NUngUze7ui2dAvSLLmXP/Gh50xYvHkDdNqU8HvU8g14eGD0mV1/SuPrjX9yHsk7WV3ZQqw9XPm2Z39+WPl/77/3/MroONd78MhpLLVYbAh4eQciaeE99tKbTuzMY9pJyJ56Ypo9jyyH+uf+OK4F6/Fm2njSHlzHkSD5+u7OaIVKgjS9ZRf0BH2kwdTc22/sRs3U9uRjaezetT3b8OG++aB0DbaWOo3bkl26d9yKVj0QD8PvEthv3yBr0/mMqawTMxZeWUer/BT73PwO9fZMj6Vzj+1WYuHo3CsZobtbsGEvPbPsKXruf87iOkxSXR6cXxuNf3Ie1cAt5BjfAf3ZvEsEi8AxtWyDkRuZJ6CkSqGHs35wrfR/P7BoDZTMQPwaUqb+96bdpkys4p0x/jG8mpFb9Tf2BHXHw8K7spIjbJlJ3DprtfZu8rX+FapyYdZt5Lh+fuxaddUyLXhQB5ww5bPzmCiFXbOb7sF8u2KdHx7Hj2Q7yDGtFpzvgy7Tdh/0nWDJpJ1PrdNB7WlZvnP0jgw0Mw5+Ry/o9wALIup7Hpnn9z4c/jtPzXIDq9eD+eAfXZNG4BiQdPXbuTIFIMg9n8t3m4xKZkp2WwzH/cddlXSZkkIW8+56Z39eFzv8LduxPOLefEt78R/NT7lmX+d/amxQO3Ub1JHQwORjLiL3E+9Bi753xGZsJlRu9ejHv9WoXq2jDyRWJ3HgagdpeWtHlqNDXbNcXOwZ5LJ2II/2wDx78uOCzmthUv4V7fhw0jX6TTvAn4dWuF2WzmzM9/sGvWp+SkZ9J68ggCxvbDtZYXF49HEzL7U87/cbRM58m9ng+j//iAfW98x77/fGdZXueWNvT5ZBqJh0/z6/2vkHUp9f/bNHouHV+4D7/urXDy8rCcP6+WDWn77Bhq3xyIg6sTyVFxnPh2C4c//KnAbBb5531ZwHg6zB5LwyFdcHR34cKBU/wx979c+PN4gTaO2PY2mRdTWHf77ALLfbsGcdvKlwie8h72rs60eGAgHg19OfjuD1RvVpeGQ7uw8c55lnOff1y3LpvNyRXbCH7y3WLPTf7xLu9ccHx+/YGdaPvMGDyb1c0b0vTdFmJ3hTHw2zkET3mvwNN7O0d7gh4bRpORPanWsDa5mdnEhRzhz9e/LTBDyJXHgsFA0OPDqNbIl/T4i4R/toFDi1dZyk44t9xqe5d3epyU6HgAfNo3Y8jaheyc8TFH/7ex2OO0puGQm2kz9U6q+9chPeESx7/azPk/whn43YsFjtHezZnWk+6gTq82eDSqjYObC6lnLxC5Zhf7Fn1PbnoWkDesrsfbkwrtJ3bHYTaMetHyufn4ATQb2w/PZvUwm0x5WVjf/J7YHYcLbVuSsSe/xOEqAsTreb0SEfknudrrK2j4kFwn+Zkk/bq3ImbLPk6u2EZuZhZeLRvQcPDNlqCgLJqM7kXPdyYTuyuMP1//lpyMLNzq1KBev/a41KhGZsJlds/5jPazxuLs7cHuFz+3bHvxeF6XcL1bO9B36XTSz1/k8Ic/kZ2aQePh3en+5kTcG9bmz1e+LrBPe1cnBi6fS+zOw4QuWEaNNv4E3NsPo5MjGUnJ+LRvxpGl67Gzt6fV47fT778z+b7T4+SkZlzV+fO/szfd//M4ZzaF8vvEtwpMqWfv5syglfM4/8dR9r7yNc41qwN5WTRvW/kS5uxcjny+gfTzF6k/oCMdX7gPr6BGbHvi7UL7GfD182QkXGb/m9/j5OVB0KND6f/lcyzvPNFyDM41q1O9aV3ClhQ9HCvw4SE4eXlwbNkvpMdfJPVsAoc/XkPNtk3p+d6TrL51GpmJybj4eNLznclcjohl18xPynVuGgzqTJ8l00g5E8++Rcsx5+TS9O4+1OvfvlBZg72RW796nlodm3Ny+VbCl67HsZorzcb2Z/Dqf7N+xBwS9p8ssE3z8QNw9qnO8a83k3UpFf9Rvej4wn2knkuw9JT8PultOr80gYzEZA68vcKybUbCZcu/Ew5GkJuRhW/XoDIHBY2GdaP3B0+RfDqOfW9+jyknl6ZjbqH+gI6Fyrr5eRNwbz9Orw3h1A/bMOeYqN01kFZPDMe7dWM23fNvAGJ3hbH/7RW0mTKKo19sJO6vxEjp8ZcsdfV870ka39GdyDW7OPHNbxgdHWgyqicDvp3Dbw++zpmNe8p0HCIicuNSUCDXRWkzSZZFw0E3k5Wcxs+j5xYY177v9W8t/47a8AeBDw/F3tmRUyu2FdytnR1dFjxETmoGawbPJD0uCYDwzzYwcPlcWk+6gxPf/kZyRKxlG+ca1Tn4/ioOf7DasszJ051Gw7qScDCCtUNnYc7JBeDS8Wj6/XcmTUb25NgXm8p1jACtJ4+gw6yxhH++gV2zPi2UZMfZuxr731rOn69+U2B553kPYHR04Kehsy1Jc8KXrqf3R0/jP7InJ77ezLnggwW2STh4il3PLbF8vngsmj6fPFPgGPJflks+HVdkm93q1uSHnlMK3BQDbH38LQb9OI8ei57g1wmv0vPdyThWc2PT2PnkpJU9cDLY2dH55QfIvJjCmsEzyUxMBuDoF5sYvrnw2P2W/xqEX/dWbLznZc5u2W9ZHv75zwzf8iad5owv8JTcciy9niI7OQ2A499s5s4/PqDlvwZZgoJTK7bRfsY9ZMRfKvQ9y2fKziH1XAKezYt+2dDqMRrt6DT3fjISLrNm8EyyLqXmHeN/N1o9xuTI83zX4THL9zDv+DZwefrdf42lbsqFfSdIiTrPua0HaDNlFPF7jhVqd4NBnfEf1Ysdz37IsS//fxhF2JK1DFm7kM4vP6CgQGyWg4cr9s6OxZbJzc4h62LKdWqRyNXTOwVyXZQlk2RpZV1Oxd7FiXr9O5Rr+xo3NcG9ng/Hv9lsCQgg7+bt0OJV2BmNNBjYucA2ppxcwpeuL7AsLuQIBjs7jv5vY4Ebsfwnr9Ua+5WrfdgZuHn+g3SYNZa9r36dd7NexLm6MkiBvOlCa3duwZmNewpl0cx/kt1gUMFjAzj88ZoCn2O3Hyx0DM41qgGQeTG5yKafXL61UEAAcOHP4/z56jfUH9CRQT/Oo07vNoQuWEbiwZIT+1hT46YmuNf14cQ3v1kCAoDs5DSrT+ObjOrJxePRJBw4hZO3h+XHztGes1sPUKtzC4x/+0N//NvfLAEBQG56FvGhx6nWpOz/r5lJKZaenNKqcZM/bn41OPHtFktAAJCTlmH1GE3ZOZbvocFoh2N1N5y8PTi77QAANds3K9V+m4zqRVZyGlHrdxc4V47V3TizcQ8eDWqX6xyIVAU3v/wAdx1YUuxP30+frexmipSJegrkuihrJsnSOPDOSmp3CaTf5zPISLxM7M4wYjb/ScSq7aUaruPeIO9dg4tHzxRal7/Mo2HB9xHS45IKHUP+k6CUqPMFl/91A+fkVTAzZWkFPjwERw9XQhd+xcF3VhZZLv3CJbIupxVY5t6gNmD92C4dj8GUm4tHw9qF1qVEFjyGzKS8Y7vyGCxxSTE9PJdOnity3aHFq6h3awd8uwQSs2UfYX8LRMoi/xgunYgptO7iX7OGXMmzWT3sXZy45/BnRdbp5O1B2tkEy+eUyMI9IplJyTh7Vyt7gw2UOQj2+Ot7eunk2ULrrC0DaH7/QJqPH4Bn83rYGY0F1jlVdyvVfj2b1cXRw5W7Dy0tsoyzj6dlHnYRW3Jw8SpOrvi92DJXBvEi/wQKCuSGUtR77wZj4U6t5IhYfuz9FH49WuPXszW+XYPo/p/HaTttDBtGzCHZys3cVbevmFTzRU3NaSjn8Kizvx/At0tLmo/rT8SPwYWCjny56Znlqt+aoo7vymPI/KsHID/TZ1nb5F6/Ft4t86bX82jki72b81W/c1EWiWGR/DH38yLXZ/6th+NaTrnq5OlutQflWgp8dCid504gZss+jny6jrTYREzZObj6etPznckY7ErZQWwwkH7hEr9PfKvIIhfDo65No0X+YS4di7ZMVypSVSgokOviykySxU0pmfnXU3dHT/cCYzGtPdUGMGXlELP5T2I2/wlA3b7tuHXZbAIfvZ2QWXlj44sKNPKDBs/m9Quts4ybj7R+I349XDwSxb7XvmHg8rkMWjmPDXfOLfB+Q3FSooo+tupN62JnNJY7aEo6ltf7UJ5hUQajHb0/eAqDvR27Zn/KzS8/QNdXH2HbpHfK1Zb8Y6jetHBCIWuJgi5HxOJcoxrngg+Ve9haUUqayM3O0R63OjUtUx+WVsqZvO9gdf86hdZZW+Y/qjfJUXFsund+gWOs26dt4TZTdJsvnzpHvf5+xIceL9f7HiIi8s+idwrkuihtJsn8oQh1erYusDzosdsLlXXy9ii0LH9s+pVPsXNSM3C0MmQi8WAEKdHxNL2rT4G54w32RlpNHI7ZZCLq593FtreiXTwWzYaRczAY7Ri0ch7Vmxa+CbQmI+EycbvDqX9rh0KBQevJIwCIWl++Y8tMuExSeFS5smy2n3EPPh0CCJn1KeFL13P4w5/wH9UL/zt7l6stCQdOkRpzgaZ39ynwfXBwd6H5+AGFyp/8fiuutb0IerTw9wko83j/K+WkZuBYTO9JjVaNMTo5ELcrrEz1Xth/krTYRJredUuB77G9q7PVYzSbTGAu2LtjMNrRetIIq20GcLQyxO3k91uxMxrpMOteq+26mnMlIiI3HvUUyHVR2kySET8E037mvXR7/TGqN61L5sUU6vZph7OVAGDANy+QdSmVuJAjpJ5NwLGaG03vugWzycTJ5Vst5eL3HqP+gI7cvOAh4vccxZxr4lzwQTISLrNr1hL6Lp3O0PWvcHTZL+SkpNNoWDdqdWzO/rdXlPrJfEW6dOIs60fO4bbv53Lbipf4+c6XrI6X/7vdcz7jtpUvMejHlwnPn5L01g7U7dOOkyu3FZp5qCxO/7STNlNH41LLk/TzF0u1jV+vm2j1xHBOrtxmmVM/dOFX1O4aSJcFD3F+z1HL+c7P1fD3OfP/zmwysfvFz7nl46cZuu4Vji37BVNOLs3u6UtmUjLu9XwKlA9bspY6vW+i04vj8evRinPBh8hOScOtbk38erQmNzObn0fPLc8pIX7vcZrd05d20+/Om/LWZObMxj3k/DWUqm6/9uRmZZc5GDPnmvhj3v/ovfgphq57heNf/4opx0TTu24hMykZj4a1C/RSRK7ZSYfZ4+j/1Wyi1oXg4O5CkxE9MF3xEny+i8eiyUpOo8X9A8lNzyLrUirpFy4Ru/0QkWt3cfzrzbR8cDDerZsQ/UsoGYnJuPl549OxOdUa+bKiyxPlOlciInLjUU+BXBelySQJkJ2Szi/jFpB09Aw3PTmSttPGkBaXyKZ7/12ozvD/bsSca6L5fbfSZeFDBD12O6kxF/j5zpcsw4kgb0adY1/9SqOhXejxziR6fzgVz4C8p+fRm0L5ecxLXDoRQ6vHh9Fh1liMTo5sf3pxoRwFlSk5Ipb1I+eQm5nNwBUv4dWy5JT3CftPsu722cTtCqPF/QPp9OL9uNXzYc/LXxA8ufgkYSU5tuwXMJtpMqJnqco716hGz3cmkxwZx87pH1mWm3Ny+f3xtzCbzfT+YCp2DnnPKezdXQBIjU0sse7Itbv47eH/kJ2cRttnxhD44GAi1+xiz7+/LFTWnJPLL+MWEPL8UpxrVKPts2Po9NIEGg/rTnLUeQ6++0OpjseavQu/InL9blpMGEiv956k94dTLTM1AfiP6sWZn/eQHn+xzHVH/BDMbw//h5yMLNpOu4uWDw3i9E87OfDXC+i5GVmWsocWryZ0wTI8GtSi87wHaPHAbcRs3c82K4nhcjOy2PrYIrJT0un80gR6fziVtk/faVm//enF/D75HTCbaT15BF3+/S+ajrmFnNQMQhcsK/NxiIjIjUsZjW2cMoRKeXV99RHq9G7Dyh5PFpiK9Vpo+eBgOs65j1V9nq4Ss9vUH9iJPp9OY83AGSQePn3N6g169HY6zb2ftUOeI37v8ZI3qGTKaCwiUjGU0VhEKs2fr31D4zu60+zuPgWSW10LdW5pw7EvNlWJgACg7TNjOPn91nIHBHYO9phzTQVmh7J3dabFA7eRkXiZhHLmeZBr66anRtH0rj4ARKzabultbPvMGFo8MJDze46xecKrAHg09qXn25Nx8vYgOzmN4CnvWYYFDlw+F+/AhuxftJywT4rOHF5eNds1o9vrj2J0diTtXALbJr9LWmwi7vV8GLnrPS4eiSL4qfdJPHyaev3a03b6XXg1b8DR//3M7jmfW+oJfGQoLSYMJCc1g9W3Xvs5+Y0ujnT/z0RqtvXHbDLn9cat3QXAbStewq1eTU588xv7Fy3Hs0UDuix8CJea1THl5HLhzxPsmrWE3IwsjM6ODPlpPh6Nfdk26R2iNvxxzdtar38HOr04HoOdHUnhUQRPeY/slHR8uwbRf9ksLp88y8a7XyYj4TLtZt5DgwEdLTObHXzvRyJWbQeg4wv30Wh4NxIPRrD5gdeueTuda1Sj57uT8WjoS25WNrue+4S4XXk5dUbvXkxuZjaHPljN8a9+LbDdwO9fpEbrJnzV4n4gb/KPPkumUT2gHmsHP3dNH3bka3ZP37x3oewMxG4/xM6Zn+RlrB9zC51ffoDLEbGsuW0G8P/fh+y/puc+8f1Wy3TXPd+fQp0erYhYtb3A9/daKe53ecK55SQdiWTPv7+0jGCo3TWQTnPGY3RxwmCA7U9/QHzoMRoN60bbZ+7Etba35TxfbwoKRK6TK19mLkpWclqBoSA3soyEy3zVvGIuXL/et7BC6q0sPw0ofMNUloyoHg1r0X/ZbCJWbScl6jwutbxoOuYWPBrWZueMjzFlFz2jl1wftbu0pPEdPVjd9xlMubkMXj2f+D+OEv3rXgBOrdxW4Iak22uPcuzLTZz4bgsNh3Shx9uTWDNoJgA/j55Lj7cq6H0Ng4Fe7z/JjmkfErvjMEGPDaPzvAfY8kheduyclII3+JcjzrF96mIa3d4VB7eCTyHDPl5D4sEIOs+bUCFNbfXYMExZ2azsNhn3+rUYsm4hsTsOWfKn/PHi55Yb/NzMLEJmfUrSkUgMdnb0WjyF1k/cwb7/fEduRharb32W21a8VCHttHd1pvubj7Nh5BwunTjLzfMfpM3U0ex5+Qsgb/a9K8/p4cWrLAGjq683d/z+Fme3HSAzMZk9L3/BxaNnrCaXvBY6zB5HfOhxNt07nxpt/Om7dDrLb55o6e3d+tiiQjf4gY8OJTkyjhqtm1iWJUfGsfrWZxm9e3GFtNO9fi3aTb+bnwZMJz3+In0/n0HzcbcS/vkGAGJ3HC4UNF35fbjStifepu0zY3Cs7lohbS3udxlg/R0vWHIJudT2oufbk9g0dj6Xjsdg52hv+TtwevUOLuw9zrBf3qiQdpaGggKR6+SuA0tKLBM85T3LS7hStd388gOWp8pFyX/ROiPhMvGhx2kysicuNapjys0l6UgUofO/5PRPO69Ti21Lz/enUN2/DnYO9qSevcCOpz8o9n2QRsO6c2r5VsuL5ce/3kzjET0sQcGVnGtUo0Ybfzbe/TKQ915MlwUP4tHIl+TTZZvcoPGIHgQ+NAQ7B3sMdgb2vvo10ZtCiyxf46YmmHNNxO44DMDRLzbSfsbdGJ0crJbP761rOOjmMrXr71x8POn1wVM4eLhgdHIkdvshQp5fWuzUwI2Gd2fH03k3nSlnzhO74zANBt1c6Ck2UGBSCLPJxIV9J/FqUXhK5tIIfHQoTe7ogZ29EVNOLiHPLyU+9FiR5ev2bUfioQgunchLJhj+358Z8PULlqDg765MNmnv5ozBYChXPhvPFg3o+urD2Ls4YXRy4NQPwRx4a0Wx2zQa1pWVXScDee+dpcUl4ts1kHPbrE884RlQjwa3dWb7U+/TaGjXMrcxX8c54/HtGoidvZGslHR2TPuQy0UkXwRoOLQLZzb+/ztYR/+3kZumjLQEBRXFr0dr2s24G6OTI3aO9oR99BPHv95cZPmy/i63mDCQUz8Ec+l4XsJNU1YOWcVM0369KSgQuU5+HlPyUyprGYilaipLRtTMpJRik4jJtbd7zmeWRHatJ91B22lj2Dnj4yLLu9etyfndRyyfU86cp/Ed3a2Wdatbk/S4pAKJ8VJiLuBWt2aZg4KzW/YR8UNwXhvq+TBk7QK+7/R4kflg3OvVJCU63vI5JzWDrJR0XGp7ganiXjHMupzKr+NfISctA4OdHX0/n0HjYd0sw2astrVuwbamnDmPW92aJe7L3sWJgLH9yv0y/MnlvxP2Ud7QE5/2zejx9iR+6DmlTO10qe1pNelmvpYPDqbFhIG41qnBjmc+KFdSw5Qz5/n5zpcwZeVgdHZk8Or5nPv9QJHvFzl5uWNnb18guE05E49bXR+r5Q32Rrq98Tjbn1l81UkcD77/I3vm/Q+AxsO7c/PLD+TlUilCoXMaHV/i/32H2ePyZn87Fk3ogmVFJvwsTsLBU6wf/gJmkwlHT3eGbXqdmC37SDtnfdKLsv4uewbUJyU6ngHfzsHZ24O4kCOEzl9meZhQ2RQUiFwnRT2JEdukjKg3tiYjeuA/ujdGJweMTg5kJiZXdpOscm9Qm17vT8HVrwbmnFwcPd3xaFDL8tT6hmFnoMPz46jduQUYDLjUrMbF8Khig4Jy7cbBnt4fPU3Mlv3lzsVSo1VjbpoyEicvD8w5uVRvWhejs+M1Hdp55NN1HPl0HV6BDen13pOc3brfMiyqtOydHen0ysN4BzXCbDLjVqcG3q0aX7NJB9o+cyeR60K4dDym0PTOZVWn1020/NcgHNxdMNgZCuQSuhZ+n/wOaWcTAGjxwG30/+I5fuw9tcz1OHl50P3NiVRr4oc5JxcnL3e8WjQoMigoK4PRjtpdWrJxzDyyUzPo8dYTtH32LkvAVNkUFIiIiFyhVucWtHxwMOuGziIj4TL1B3Sk3bN3FbtNSsyFAjdO7vVrkRpzwWrZ1JgLuNT2wmC0szxhdK9bs8jyxen9wVOEzl9meQH3nrDPMDoV/a5KSnTBdtq7OePo4Up6XFKp3nsqr6BHb8elZnXWDnmO3MxsOs29H6Oz9SFLlrb+dU7zc6G416/F2a37iyxvsDfS+6OppJ9PYvcLS8vVTjsHe/p8Oo0No+aSsP8kDu4ujD3+BUZH+yKDgpSYC9TpfZPls3v9WqTHXSzV0/WksEjSYhPx7RZE5NqyZTtv/9y9ZCQms/rWZzHnmujz6bNFDgODvB5HU24uLj6elt4C9/o+pMbEWy3v2zUIt7o1afmv2zAYjTh4uDB692J+GjTT0otWGm51a9Jl/oOsGTST5Mg4vFo2ZNAP84rdJiXmAtUa+Vo+u9fzKfb3Iz8gAAj/bAOd5ozHycu9zIFW11cfIXrzXn578HUAbt/4WrHntKy/y6kxF0g8fNrSCxzxQzCtnyycWLKyKE+BiIjIFRyru5GTkk5mUgp2DvYE3HdridtE/rSTJqN7Y+/ihJ2jPc3u6UvEj9afgmckXCbxYAT+o3oB0HBIF1LPJRY5dKjBoM70eGdyEW11J+VM3jCJJqN64uRVONHjlRIOnMJgb8S3WxAAze8bwJlNe8jNzC7xGEtjxLa3cfX1ttJON9LPJ5GbmY2Lj2epxqdH/rTTkrXbvX4tfLsFEbXB+tN/g9GO3h9OJTMphR3TPiyx7hYP3EZ7K9m6jU4Oee+R/HVT1/LBQSXWFfPbn3i3bmLJON/i/oHF9oBUD6hn+bdHw9p4t2pcZEJKV19vRmx72+o6R0930s4mYM41Uc2/DnV63WS13JWuPKc12vjj6utN7E7rWdbX3/ECyzs9zvLOE1k//Hmyk9NZ3nlikQFB+1n30uKB2wotd/BwxZSTS9r5JABa/KtwmULtXLuL+gM6WgLV5uMHFPn7ZDDaFciw3nDIzaRfuFRkQFCzbVMGfGc9Kaajpxupfw1bqt2lJV6BxecEKuvv8qkfgvHr3go7x7xn8nX7tiPxcGSx+7ie1FMgIiJyhZjf9uE/qhcjgt8mMymFs9sO4GblRvdKsTsPc3rVdob/9iYAEau3E/1L0S/87pj+ET3eeoLWT44kOyWd4KfeL7JstcZ+ZCenWV23e85SbvnkGbIupXFu+8EC47CtMpvZNukdur72KEYnB9LjkvIS1BXBr0drerw9CQcPFwwGAw2HdGXXc59wZuOeQmWda1TLezp7sfDN2JEl67jlk2cYvmUR6bGJnN12oPh2AocWr6L7oomM3Pke5lwTIbOWFDmMq/Hw7jQa0oXEw6cZtinvKW/cH0cJmWV9ggfPgHokRxYec56dks6fr37D0PWvkJF4ucgb0SvlpGaw45kP6PvZDAxGOy4ePcO2J98rsnzH5+/DvUEtzNk5mHJN7Jr1qeXF079z9fW2mo0c4MBbK+j57mT8x9xCcmQs54IPldjWPf/+kp7vPcnI7e+Sm53DtknvXLM8M96BjUjYf6rQ8vxhYndsWURmUkqRgd2VUqLO8+cb3zFodV7i0tgdhzn6xSarZY2ODvT/chZGR3vMJjMZicn8ev8rRdbtXt+nyF6f0PnL6LrwYdo8NZrEw6e5sPdEiW0ty+9y/J6jRP38B8M2vY4518TFo9HsnPFRkeWvNwUFIiIiVzDn5LL1sUUFlpUmw/n+RcvZv2h5qfZx+eRZ1t0+u1Rla3Vqzu4XPrO67tSKbZxasc3yec9LJY9Njg89xup+z5Rq3+eCD/J9h0dLVbZ21yDClqyzesOVGnOBtYOfK1U9+XLSMwv9PxTl1MptnFq5reSCf/EKbGg16znkBSOHFq+yfD78weoS6zuzcY/VQMmaX8eXfsrl2l0DOfie9UzriYciWNXn6VLXBZBx4RKb/poppyxSouOLnTvfYGeHc41qRK6zPgRq9wufFfgOlzRLEsDxZb9wfFnJOXBy0jMt+QpKo3bXoCLP6bnfD7Cyu/VeuaKU5XcZ8r5PpflOVQYNHxIREalA2akZ1Lu1I30/L92Ny8Dlc6ndNZDstLwZSTY/8FrJPQDXgMlkIic9k2GbXsc7qFGJ5QMfGUqXVx4i46+n95FrdpbqZu9ayLyYQvtZY2kzdXSJZY3Ojgzb9DruDWtZhkmtH/4COakZFd1McrNzcPLyYNim13GuUa3E8h1fuI/Wk0dYelsOf7C6QNBXkTISLtPzvSdpdm+/Est6NKzNsE2vY7A3YsrOwWwy5c3NX8wUs9dKTkYW3kGNGLrh1VKV7/n+FJqM6klWcjoAIbOWcH53eEU20SL9fBK3rZxH3b7tSizbaFg3+v1vZrFTH1c0g9l8Hf4H5YaVnZbBMv9xld0MEbEBY09+iYOrc8kFi1DZ1yvvoEZWk4pdmT31RtH38xm4/20Kx8xLqfw8em7lNKgIze7tR0sr49B3Pb+U8yFHrGxReYZueBW7v00zmnQsmm1PWB/zX1naTB1Nw8GF80r89tAbJEfGVUKLrHOuUY0B37xQaPnZ3w8UmeOhsnR99RF82jcrtHzt7bNvmISjV3t9BQUFNq+y/8iKiO34pwcFIiI3qmsRFGj4kIiIiIiIjVNQICIiIiJi4xQUiIiIiIjYuCo/Jekbb7xBSkoKU6dOpXr16iVvcIPULSIiIiJyvVTpF40vXbqEl5cXzs7OJCcnYzQa/xF1X096cU9Erhe9aCwiUjH0onEJ9u7di9lspnXr1tf8pr0i6xYRERERuZ6q9PChvXv3AtCuXclJI26kum8krSePoEbrJtS4qQkeDWuTcuY8yztPrOxmiYhYpWuWiEj5VMmeghUrVmAwGJg2bRoAH330EQaDwfKzYMECS9nY2FimTJlC48aNcXZ2plmzZrz22muYTCYmTJiAwWBgyZIl5aq7Kugwayy+3VuRfDqWzKTkym6OiEixdM0SESmfKtlTkJqaSvfu3QkNDSUjI4N27drh6upqWd+tWzcAQkJCGDx4MImJibi7uxMUFER0dDQzZswgIiKCI0fysim2bdu2zHVXFctvnkhK1HkAhv/2Jg5uVzdeTUSkIumaJSJSPlUyKBg/fjzjxo3Dw8MDgM2bN+Pp6VmgTGxsLMOHDycxMZGZM2cyZ84cXFxcMJvNzJ8/nzlz5uDg4IDRaKRVq1Zlqrsqyf/jKiLyT6BrlohI+VTJ4UMAx44dIy0tjYYNG1q9aZ80aRJxcXE88cQTLFy4EBcXFwAMBgOzZ88mMDCQrKwsAgICcHZ2LlPdIiIiIiL/JFU2KNi3bx9QcOhPvkOHDrFy5Uo8PT1ZuHBhofUGg4GOHTsWuX1xdQNER0czadIkOnfujJOTEwaDoTyHICIiIiJyXVTJ4UNQ/I37N998g9lsZuzYsZZhQH/n5OQEQJs2bcpUN8CJEydYsWIFnTp1wtHRke3bt5e5/X/XsWNHYmNjr7qev3Mw2/Eina95vSIifxfQLIBsg6nc2+t6JSJiXf711dfXlz179pSrDpsMCjZv3gxAv379itz+7NmzQPmCgl69enHu3DkA5s6de02CgtjYWGJiYq66nr9zNBih9jWvVkSkkLPnzpJlzi339rpeiYhYd7XXV7DRoODMmTMANGjQwOq2ubm5hISEAOULCuzsrv2oLF9f32teJ+Q9eaP8D+5EREqtjl+dq+4p0PVKRKSw/Ovr1dwvVsmgIC4ujri4ODw9PWnUqFGh9ampqQDk5ORY3X7VqlXEx8dTq1Yt/Pz8ylR3RSlvV1BJstMyWOY/rkLqFhG50rHjx3BwLf8UobpeiYhYd7XXV6iiLxofPXoUgICAAKvr82/0Q0NDC61LSkri2WefBaz3EpRUt4iIiIjIP02V7Clwc3MD8mYBSk1NtXzO179/f8LCwliwYAG9e/cmKCgIgPDwcO677z5OnToFWA8KSqq7qmkyuhfu9XwAcK5RDTsHe256ahQAKdHxnFr+e2U2T0SkAF2zRETKp0oGBUFBQTRo0ICoqCgaNGhAQEAARqORcePG8dhjjzF9+nSWLVtGTEwMbdq0sTz1Dw8Pp127dgwePJh169bRvn37Mtdd1QTc0w/fbkEFlrWfcQ8AsTsO6w+siNxQdM0SESmfKhkUODs7s379embNmsWuXbsICQnBbDZbbtrr1q1LcHAw06dPZ8uWLURFRdGiRQsWLVrE448/jr+/PwA9evQoc91VzYZRL1Z2E0RESk3XLBGR8qmSQQFAYGAgP/74Y5HrW7RowerVqwstDw4OJjo6mvbt21O/fv1y1S0iIiIi8k9SZYOC8khLS7M88Z88efJV1bV8+XIAwsLCCnxu1KiRJVuyiIiIiMiNwCaDgueff56JEydSp04dy7KwsDAmTpzI4cOH6dmzJ+PHj7+qfdx5551WP99///18/vnnV1W3iIiIiMi1ZHNBQWRkJPPnz2fBggU0bdoUb29vzp8/T0REBADdunVj5cqVV52AzGw2X4vmioiIiIhUuCqZp6A4rq6uTJ06laCgIC5cuEBoaCjJycn079+fpUuXsnXrVmrWrFnZzRQRERERuW5srqfAx8eHN998s7KbISIiIiJyw7C5ngIRERERESlIQYGIiIiIiI1TUCAiIiIiYuMUFIiIiIiI2DgFBSIiIiIiNk5BgYiIiIiIjVNQICIiIiJi4xQUiIiIiIjYOAUFIiIiIiI2zmA2m82V3QipPGazmZz0zMpuhojYAHsXJwwGQ7m31/VKRMS6q72+goICERERERGbp+FDIiIiIiI2TkGBiIiIiIiNU1AgIiIiImLjFBSIiIiIiNg4BQUiIiIiIjZOQYGIiIiIiI1TUCAiIiIiYuMUFIiIiIiI2DgFBSIiIiIiNk5BgYiIiIiIjVNQICIiIiJi4xQUiIiIiIjYOAUFIiIiIiI2TkGBiIiIiIiNU1AgIiIiImLjFBSIiIiIiNg4BQUiIiIiIjZOQYGIiIiIiI1TUCAiIiIiYuMUFIiIiIiI2DgFBSIiIiIiNk5BgYiIiIiIjVNQICIiIiJi4xQUiIiIiIjYOAUFIiIiIiI27v8AFlI3kmk5SA4AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "q_env.unwrapped.circuits[0].draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.09090909 0.09090909 0.09090909 0.09090909 0.09090909 0.09090909\n", + " 0.09090909 0.09090909 0.09090909 0.09090909 0.09090909]\n", + "[-1. -0.8 -0.6 -0.4 -0.2 0. 0.2 0.4 0.6 0.8 1. ]\n", + "[170 169 175 193 195 186 186 204 158 180 184]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "num_params = 11\n", + "batchsize = 2000\n", + "\n", + "prob_weights = np.ones(num_params) / num_params\n", + "print(prob_weights)\n", + "vals = np.linspace(-1., 1., num_params)\n", + "print(vals)\n", + "\n", + "np.random.seed(seed=3)\n", + "prob_distr = np.random.choice(vals, size=batchsize, p=prob_weights, replace=True)\n", + "unique_vals, counts = np.unique(prob_distr, return_counts=True)\n", + "print(counts)\n", + "\n", + "plt.hist(prob_distr)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# Adapted from CleanRL ppo_continuous_action.py\n", + "import random\n", + "import time\n", + "from typing import Optional, Dict\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import MaxNLocator\n", + "from IPython.display import clear_output\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.distributions.normal import Normal\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "\n", + "from rl_qoc.base_q_env import BaseQuantumEnvironment\n", + "\n", + "\n", + "def layer_init(layer, std=np.sqrt(2), bias_const=0.0):\n", + " torch.nn.init.orthogonal_(layer.weight, std)\n", + " # torch.nn.init.zeros_(layer.weight)\n", + " torch.nn.init.constant_(layer.bias, bias_const)\n", + " return layer\n", + "\n", + "\n", + "def plot_curves(env: BaseQuantumEnvironment):\n", + " \"\"\"\n", + " Plots the reward history and fidelity history of the environment\n", + " \"\"\"\n", + " fidelity_range = [i * env.benchmark_cycle for i in range(len(env.fidelity_history))]\n", + "\n", + " fig, ax = plt.subplots(4, figsize=(8.0, 6.0 * 4))\n", + "\n", + " ax[0].plot(np.mean(env.reward_history, axis=1), label=\"Reward\")\n", + " ax[0].plot(\n", + " fidelity_range,\n", + " env.fidelity_history,\n", + " label=f\"Circuit Fidelity\",\n", + " )\n", + "\n", + " ax[0].set_title(\"Reward History\")\n", + " ax[0].legend()\n", + " ax[0].set_xlabel(\"Iteration\")\n", + " ax[0].set_ylabel(\"Reward\")\n", + " # Ensure integer ticks on the x-axis\n", + " plt.gca().xaxis.set_major_locator(MaxNLocator(integer=True))\n", + "\n", + " ax[1].plot(np.mean(env.rl_reward_history, axis=1), label=\"RL Reward\")\n", + "\n", + " ax[1].set_title(\"RL Reward History\")\n", + " ax[1].legend()\n", + " ax[1].set_xlabel(\"Iteration\")\n", + " ax[1].set_ylabel(\"RL Reward\")\n", + " # Ensure integer ticks on the x-axis\n", + " plt.gca().xaxis.set_major_locator(MaxNLocator(integer=True))\n", + "\n", + " ax[2].errorbar(env.discrete_obs_vals, np.mean(env.discrete_reward_history, axis=0), yerr=np.std(env.discrete_reward_history, axis=0), label=\"Reward History\")\n", + " ax[2].legend()\n", + " ax[2].set_xlabel(\"Obs Val\")\n", + " ax[2].set_ylabel('Reward')\n", + "\n", + " ax[3].scatter(env.discrete_obs_vals, env.prob_weights, label='Probability Distribution Weights')\n", + " ax[3].legend()\n", + " ax[3].set_xlabel(\"Obs Val\")\n", + " ax[3].set_ylabel('Probability')\n", + "\n", + " plt.show()\n", + "\n", + "\n", + "class Agent(nn.Module):\n", + " def __init__(self, env, use_combined_networks, activation_function_str, layer_size, robust_ppo):\n", + " super().__init__()\n", + " self.use_combined_networks = use_combined_networks\n", + " self.robust_ppo = robust_ppo\n", + " if activation_function_str == \"tanh\":\n", + " self.activation_fn = nn.Tanh\n", + " elif activation_function_str == \"relu\":\n", + " self.activation_fn = nn.ReLU\n", + " elif activation_function_str == \"gelu\":\n", + " self.activation_fn = nn.GELU\n", + " elif activation_function_str == \"leaky_relu\":\n", + " self.activation_fn = nn.LeakyReLU\n", + " elif activation_function_str == \"elu\":\n", + " self.activation_fn = nn.ELU\n", + " if not self.use_combined_networks:\n", + " self.critic = nn.Sequential(\n", + " layer_init(\n", + " nn.Linear(np.array(env.observation_space.shape).prod(), layer_size)\n", + " ),\n", + " self.activation_fn(),\n", + " layer_init(nn.Linear(layer_size, layer_size)),\n", + " self.activation_fn(),\n", + " layer_init(nn.Linear(layer_size, 1), std=1.0),\n", + " )\n", + " self.actor_mean = nn.Sequential(\n", + " layer_init(\n", + " nn.Linear(np.array(env.observation_space.shape).prod(), layer_size)\n", + " ),\n", + " self.activation_fn(),\n", + " layer_init(nn.Linear(layer_size, layer_size)),\n", + " self.activation_fn(),\n", + " layer_init(nn.Linear(layer_size, np.prod(env.action_space.shape)), std=0.01),\n", + " )\n", + " self.actor_logstd = nn.Parameter(\n", + " torch.zeros(1, np.prod(env.action_space.shape))\n", + " )\n", + " if self.use_combined_networks:\n", + " self.main_network = nn.Sequential(\n", + " layer_init(\n", + " nn.Linear(np.array(env.observation_space.shape).prod(), layer_size)\n", + " ),\n", + " self.activation_fn(),\n", + " layer_init(nn.Linear(layer_size, layer_size)),\n", + " self.activation_fn(),\n", + " )\n", + " self.actor_mean = nn.Sequential(\n", + " self.main_network,\n", + " layer_init(nn.Linear(layer_size, np.prod(env.action_space.shape)), std=0.01),\n", + " self.activation_fn(),\n", + " )\n", + " self.actor_std = nn.Sequential(\n", + " self.main_network,\n", + " layer_init(nn.Linear(layer_size, np.prod(env.action_space.shape)), std=0.01),\n", + " nn.Sigmoid(),\n", + " )\n", + " self.critic = nn.Sequential(\n", + " self.main_network,\n", + " layer_init(nn.Linear(layer_size, 1), std=1.0),\n", + " )\n", + " self.actor_logstd = nn.Parameter(\n", + " torch.zeros(1, np.prod(env.action_space.shape))\n", + " )\n", + "\n", + " def get_value(self, x):\n", + " return self.critic(x)\n", + "\n", + " def get_action_and_value(self, x, action=None):\n", + " action_mean = self.actor_mean(x)\n", + " # action_logstd = self.actor_logstd.expand_as(action_mean)\n", + " # action_std = torch.exp(action_logstd)\n", + " if self.use_combined_networks:\n", + " action_std = self.actor_std(x)\n", + " else:\n", + " action_logstd = self.actor_logstd.expand_as(action_mean)\n", + " action_std = torch.exp(action_logstd)\n", + " probs = Normal(action_mean, action_std)\n", + " if action is None:\n", + " action = probs.sample()\n", + " return (\n", + " action,\n", + " probs.log_prob(action).sum(1),\n", + " probs.entropy().sum(1),\n", + " self.critic(x),\n", + " )\n", + "\n", + "\n", + "class PPO_CleanRL:\n", + " def __init__(\n", + " self,\n", + " agent_config: Dict,\n", + " env: BaseQuantumEnvironment,\n", + " chkpt_dir: Optional[str] = \"tmp/ppo\",\n", + " chkpt_dir_critic: Optional[str] = \"tmp/critic_ppo\",\n", + " ):\n", + " # General Run Params\n", + " self.agent_config = agent_config\n", + " self.exp_name = self.agent_config[\"exp_name\"]\n", + " self.seed = self.agent_config[\"seed\"]\n", + " self.torch_deterministic = self.agent_config[\"torch_deterministic\"]\n", + " self.cuda = self.agent_config[\"cuda\"]\n", + " self.track = self.agent_config[\"track\"]\n", + " self.wandb_project_name = self.agent_config[\"wandb_project_name\"]\n", + " self.wandb_entity = self.agent_config[\"wandb_entity\"]\n", + " self.save_model = self.agent_config[\"save_model\"]\n", + " self.plot_real_time = self.agent_config[\"plot_real_time\"]\n", + " self.num_prints = self.agent_config[\"num_prints\"]\n", + "\n", + " # PPO Specific Params\n", + " self.num_updates = self.agent_config[\"total_updates\"]\n", + " self.learning_rate = self.agent_config[\"learning_rate\"]\n", + " self.num_envs = self.agent_config[\"num_envs\"]\n", + " self.num_steps = self.agent_config[\"num_steps\"]\n", + " self.anneal_lr = self.agent_config[\"anneal_lr\"]\n", + " self.anneal_num_updates = self.agent_config[\"anneal_num_updates\"]\n", + " self.exp_anneal_lr = self.agent_config[\"exp_anneal_lr\"]\n", + " self.exp_update_time = self.agent_config[\"exp_update_time\"]\n", + " self.plateau_lr = self.agent_config[\"plateau_lr\"]\n", + " self.gamma = self.agent_config[\"gamma\"]\n", + " self.gae_lambda = self.agent_config[\"gae_lambda\"]\n", + " self.num_minibatches = self.agent_config[\"num_minibatches\"]\n", + " self.update_epochs = self.agent_config[\"update_epochs\"]\n", + " self.norm_adv = self.agent_config[\"norm_adv\"]\n", + " self.activation_function_str = self.agent_config[\"activation_function_str\"]\n", + " self.use_combined_networks = self.agent_config[\"use_combined_networks\"]\n", + " self.layer_size = self.agent_config[\"layer_size\"]\n", + " self.clip_coef = self.agent_config[\"clip_coef\"]\n", + " self.clip_vloss = self.agent_config[\"clip_vloss\"]\n", + " self.ent_coef = self.agent_config[\"ent_coef\"]\n", + " self.vf_coef = self.agent_config[\"vf_coef\"]\n", + " self.max_grad_norm = self.agent_config[\"max_grad_norm\"]\n", + " self.target_kl = self.agent_config[\"target_kl\"]\n", + " self.robust_ppo = self.agent_config[\"robust_ppo\"]\n", + "\n", + " self.batch_size = int(self.num_envs * self.num_steps)\n", + " self.minibatch_size = int(self.batch_size // self.num_minibatches)\n", + "\n", + " assert self.anneal_lr + self.exp_anneal_lr, \"Learning Rate Combination doesn't work\"\n", + "\n", + " self.run_name = f\"PPO_CleanRL__{self.exp_name}__{self.seed}__{int(time.time())}\"\n", + "\n", + " if self.track:\n", + " import wandb\n", + "\n", + " wandb.init(\n", + " project=self.wandb_project_name,\n", + " entity=self.wandb_entity,\n", + " sync_tensorboard=True,\n", + " config=self.agent_config,\n", + " name=self.run_name,\n", + " monitor_gym=True,\n", + " save_code=True,\n", + " )\n", + " self.writer = SummaryWriter(f\"runs/{self.run_name}\")\n", + " self.writer.add_text(\n", + " \"hyperparameters\",\n", + " \"|param|value|\\n|-|-|\\n%s\"\n", + " % (\n", + " \"\\n\".join(\n", + " [f\"|{key}|{value}|\" for key, value in self.agent_config.items()]\n", + " )\n", + " ),\n", + " )\n", + "\n", + " # TRY NOT TO MODIFY: seeding\n", + " random.seed(self.seed)\n", + " np.random.seed(self.seed)\n", + " torch.manual_seed(self.seed)\n", + " torch.backends.cudnn.deterministic = self.torch_deterministic\n", + "\n", + " self.device = torch.device(\n", + " \"cuda\" if torch.cuda.is_available() and self.cuda else \"cpu\"\n", + " )\n", + "\n", + " self.env = env\n", + "\n", + " self.agent = Agent(\n", + " self.env,\n", + " self.use_combined_networks,\n", + " self.activation_function_str,\n", + " self.layer_size,\n", + " ).to(self.device)\n", + " self.optimizer = optim.Adam(\n", + " self.agent.parameters(), lr=self.learning_rate, eps=1e-5\n", + " )\n", + "\n", + " def run_training(self):\n", + " # ALGO Logic: Storage setup\n", + " self.obs = torch.zeros(\n", + " (self.num_steps, self.num_envs) + self.env.observation_space.shape\n", + " ).to(self.device)\n", + " self.actions = torch.zeros(\n", + " (self.num_steps, self.num_envs) + self.env.action_space.shape\n", + " ).to(self.device)\n", + " self.logprobs = torch.zeros((self.num_steps, self.num_envs)).to(self.device)\n", + " self.rewards = torch.zeros((self.num_steps, self.num_envs)).to(self.device)\n", + " self.dones = torch.zeros((self.num_steps, self.num_envs)).to(self.device)\n", + " self.values = torch.zeros((self.num_steps, self.num_envs)).to(self.device)\n", + "\n", + " # TRY NOT TO MODIFY: start the game\n", + " global_step = 0\n", + " start_time = time.time()\n", + " next_obs, _ = self.env.reset(seed=self.seed)\n", + " next_obs = np.tile(next_obs, (self.num_envs, 1))\n", + " next_obs = torch.Tensor(next_obs).to(self.device)\n", + " next_done = torch.zeros(self.num_envs).to(self.device)\n", + "\n", + " for update in range(1, self.num_updates + 1):\n", + " # Annealing the Learning Rate\n", + " if self.anneal_lr or self.exp_anneal_lr:\n", + " if self.anneal_lr:\n", + " frac = 1.0 - (update - 1.0) / self.anneal_num_updates\n", + " lrnow = np.clip(frac, a_min=0., a_max=None) * self.learning_rate + self.plateau_lr\n", + " self.optimizer.param_groups[0][\"lr\"] = lrnow\n", + " if self.exp_anneal_lr:\n", + " lrnow = self.learning_rate * np.exp(-update / self.exp_update_time) + self.plateau_lr\n", + " self.optimizer.param_groups[0][\"lr\"] = lrnow\n", + "\n", + " for step in range(0, self.num_steps):\n", + " global_step += self.num_envs\n", + " self.obs[step] = next_obs\n", + " self.dones[step] = next_done\n", + "\n", + " # ALGO LOGIC: action logic\n", + " with torch.no_grad():\n", + " action, logprob, _, value = self.agent.get_action_and_value(\n", + " next_obs\n", + " )\n", + " self.values[step] = value.flatten()\n", + " self.actions[step] = action\n", + " self.logprobs[step] = logprob\n", + "\n", + " # TRY NOT TO MODIFY: execute the game and log data.\n", + " cpu_action = action.cpu().numpy()\n", + " cpu_action = np.clip(\n", + " cpu_action,\n", + " self.env.action_space.low,\n", + " self.env.action_space.high,\n", + " )\n", + "\n", + " next_obs, reward, terminations, truncations, infos = self.env.step(\n", + " cpu_action\n", + " )\n", + " print(f\"Mean Action: {np.mean(cpu_action, axis=0)}\")\n", + " next_obs = np.tile(next_obs, (self.num_envs, 1))\n", + " next_done = np.logical_or(terminations, truncations)\n", + " if next_done:\n", + " next_obs, _ = self.env.reset(seed=self.seed)\n", + " next_obs = np.tile(next_obs, (self.num_envs, 1))\n", + " self.rewards[step] = torch.tensor(reward).to(self.device).view(-1)\n", + " next_obs, next_done = torch.Tensor(next_obs).to(\n", + " self.device\n", + " ), torch.Tensor(next_done).to(self.device)\n", + "\n", + " if \"final_info\" in infos:\n", + " for info in infos[\"final_info\"]:\n", + " if info and \"episode\" in info:\n", + " print(\n", + " f\"global_step={global_step}, episodic_return={info['episode']['r']}\"\n", + " )\n", + " self.writer.add_scalar(\n", + " \"charts/episodic_return\",\n", + " info[\"episode\"][\"r\"],\n", + " global_step,\n", + " )\n", + " self.writer.add_scalar(\n", + " \"charts/episodic_length\",\n", + " info[\"episode\"][\"l\"],\n", + " global_step,\n", + " )\n", + "\n", + " # bootstrap value if not done\n", + " with torch.no_grad():\n", + " next_value = self.agent.get_value(next_obs).reshape(1, -1)\n", + " advantages = torch.zeros_like(self.rewards).to(self.device)\n", + " lastgaelam = 0\n", + " for t in reversed(range(self.num_steps)):\n", + " if t == self.num_steps - 1:\n", + " nextnonterminal = 1.0 - next_done\n", + " nextvalues = next_value\n", + " else:\n", + " nextnonterminal = 1.0 - self.dones[t + 1]\n", + " nextvalues = self.values[t + 1]\n", + " delta = (\n", + " self.rewards[t]\n", + " + self.gamma * nextvalues * nextnonterminal\n", + " - self.values[t]\n", + " )\n", + " advantages[t] = lastgaelam = (\n", + " delta\n", + " + self.gamma * self.gae_lambda * nextnonterminal * lastgaelam\n", + " )\n", + " returns = advantages + self.values\n", + "\n", + " # flatten the batch\n", + " b_obs = self.obs.reshape((-1,) + self.env.observation_space.shape)\n", + " b_logprobs = self.logprobs.reshape(-1)\n", + " b_actions = self.actions.reshape((-1,) + self.env.action_space.shape)\n", + " b_advantages = advantages.reshape(-1)\n", + " b_returns = returns.reshape(-1)\n", + " b_values = self.values.reshape(-1)\n", + "\n", + " # Optimizing the policy and value network\n", + " b_inds = np.arange(self.batch_size)\n", + " clipfracs = []\n", + " for epoch in range(self.update_epochs):\n", + " np.random.shuffle(b_inds)\n", + " for start in range(0, self.batch_size, self.minibatch_size):\n", + " end = start + self.minibatch_size\n", + " mb_inds = b_inds[start:end]\n", + "\n", + " _, newlogprob, entropy, newvalue = self.agent.get_action_and_value(\n", + " b_obs[mb_inds], b_actions[mb_inds]\n", + " )\n", + " logratio = newlogprob - b_logprobs[mb_inds]\n", + " ratio = logratio.exp()\n", + "\n", + " with torch.no_grad():\n", + " # calculate approx_kl http://joschu.net/blog/kl-approx.html\n", + " old_approx_kl = (-logratio).mean()\n", + " approx_kl = ((ratio - 1) - logratio).mean()\n", + " clipfracs += [\n", + " ((ratio - 1.0).abs() > self.clip_coef).float().mean().item()\n", + " ]\n", + "\n", + " mb_advantages = b_advantages[mb_inds]\n", + " if self.norm_adv:\n", + " mb_advantages = (mb_advantages - mb_advantages.mean()) / (\n", + " mb_advantages.std() + 1e-8\n", + " )\n", + "\n", + " # Policy loss\n", + " pg_loss1 = -mb_advantages * ratio\n", + " pg_loss2 = -mb_advantages * torch.clamp(\n", + " ratio, 1 - self.clip_coef, 1 + self.clip_coef\n", + " )\n", + " pg_loss = torch.max(pg_loss1, pg_loss2).mean()\n", + "\n", + " # Value loss\n", + " newvalue = newvalue.view(-1)\n", + " if self.clip_vloss:\n", + " v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2\n", + " v_clipped = b_values[mb_inds] + torch.clamp(\n", + " newvalue - b_values[mb_inds],\n", + " -self.clip_coef,\n", + " self.clip_coef,\n", + " )\n", + " v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2\n", + " v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)\n", + " v_loss = 0.5 * v_loss_max.mean()\n", + " else:\n", + " v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean()\n", + "\n", + " entropy_loss = entropy.mean()\n", + " loss = (\n", + " pg_loss - self.ent_coef * entropy_loss + v_loss * self.vf_coef\n", + " )\n", + "\n", + " self.optimizer.zero_grad()\n", + " loss.backward()\n", + " nn.utils.clip_grad_norm_(\n", + " self.agent.parameters(), self.max_grad_norm\n", + " )\n", + " self.optimizer.step()\n", + "\n", + " if self.target_kl is not None and approx_kl > self.target_kl:\n", + " break\n", + "\n", + " y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy()\n", + " var_y = np.var(y_true)\n", + " explained_var = (\n", + " np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y\n", + " )\n", + "\n", + " # TRY NOT TO MODIFY: record rewards for plotting purposes\n", + " self.writer.add_scalar(\n", + " \"charts/learning_rate\",\n", + " self.optimizer.param_groups[0][\"lr\"],\n", + " global_step,\n", + " )\n", + " self.writer.add_scalar(\"losses/value_loss\", v_loss.item(), global_step)\n", + " self.writer.add_scalar(\"losses/policy_loss\", pg_loss.item(), global_step)\n", + " self.writer.add_scalar(\"losses/entropy\", entropy_loss.item(), global_step)\n", + " self.writer.add_scalar(\n", + " \"losses/old_approx_kl\", old_approx_kl.item(), global_step\n", + " )\n", + " self.writer.add_scalar(\"losses/approx_kl\", approx_kl.item(), global_step)\n", + " self.writer.add_scalar(\"losses/clipfrac\", np.mean(clipfracs), global_step)\n", + " self.writer.add_scalar(\n", + " \"losses/explained_variance\", explained_var, global_step\n", + " )\n", + " print(\"SPS:\", int(global_step / (time.time() - start_time)))\n", + " self.writer.add_scalar(\n", + " \"charts/SPS\", int(global_step / (time.time() - start_time)), global_step\n", + " )\n", + "\n", + " if global_step % self.num_prints == 0:\n", + " clear_output(wait=True)\n", + " if self.plot_real_time:\n", + " plot_curves(self.env.unwrapped)\n", + "\n", + " if self.save_model:\n", + " model_path = f\"runs/{self.run_name}/{self.exp_name}.cleanrl_model\"\n", + " torch.save(self.agent.state_dict(), model_path)\n", + " print(f\"model saved to {model_path}\")\n", + "\n", + " self.env.close()\n", + " self.writer.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "agent_config = {\n", + " \"exp_name\": \"Test PPO CleanRL\",\n", + " \"seed\": 1,\n", + " \"torch_deterministic\": True,\n", + " \"cuda\": False,\n", + " \"track\": False,\n", + " \"wandb_project_name\": \"Context Aware Calibrations\",\n", + " \"wandb_entity\": None,\n", + " \"save_model\": True,\n", + " \"plot_real_time\": True,\n", + " \"num_prints\": 5,\n", + " \"total_updates\": 600,\n", + " \"learning_rate\": 3e-5,\n", + " \"num_envs\": 32,\n", + " \"num_steps\": 1,\n", + " \"anneal_lr\": True,\n", + " \"anneal_num_updates\": 400,\n", + " \"exp_anneal_lr\": False,\n", + " \"exp_update_time\": 200,\n", + " \"plateau_lr\": 1e-6,\n", + " \"gamma\": 0.99,\n", + " \"gae_lambda\": 0.95,\n", + " \"num_minibatches\": 4,\n", + " \"update_epochs\": 8,\n", + " \"norm_adv\": True,\n", + " \"activation_function_str\": \"tanh\",\n", + " \"use_combined_networks\": True,\n", + " \"layer_size\": 64,\n", + " \"clip_coef\": 0.2,\n", + " \"clip_vloss\": True,\n", + " \"ent_coef\": 0.,\n", + " \"vf_coef\": 0.5,\n", + " \"max_grad_norm\": 0.5,\n", + " \"target_kl\": None,\n", + " \"robust\": False,\n", + "}\n", + "\n", + "ppo_agent = PPO_CleanRL(agent_config, q_env)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 17)\n", + "[0.36610833 0.81724011 0.42037057 0.43765815 0.49182518 0.56861233\n", + " 0.73345736 0.5757898 0.85029423 0.57461907 0.58766874 0.5660607\n", + " 0.54962453 0.49839076 0.43894606 0.39062092 0.35642864]\n", + "(17,)\n", + "[-3.14 -3.14 -3.14 -3.14 -3.14 -3.14 -3.14]\n" + ] + } + ], + "source": [ + "print(ppo_agent.env.discrete_reward_history.shape)\n", + "print(np.mean(ppo_agent.env.discrete_reward_history, axis=0))\n", + "print(ppo_agent.env.discrete_obs_vals.shape)\n", + "print(ppo_agent.env.action_space.low)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "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[51], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m q_env\u001b[38;5;241m.\u001b[39mclear_history()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mppo_agent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_training\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "Cell \u001b[0;32mIn[39], line 467\u001b[0m, in \u001b[0;36mPPO_CleanRL.run_training\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 465\u001b[0m clear_output(wait\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 466\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mplot_real_time:\n\u001b[0;32m--> 467\u001b[0m \u001b[43mplot_curves\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munwrapped\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 469\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msave_model:\n\u001b[1;32m 470\u001b[0m model_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mruns/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexp_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.cleanrl_model\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "Cell \u001b[0;32mIn[39], line 32\u001b[0m, in \u001b[0;36mplot_curves\u001b[0;34m(env)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;124;03mPlots the reward history and fidelity history of the environment\u001b[39;00m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 30\u001b[0m fidelity_range \u001b[38;5;241m=\u001b[39m [i \u001b[38;5;241m*\u001b[39m env\u001b[38;5;241m.\u001b[39mbenchmark_cycle \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;28mlen\u001b[39m(env\u001b[38;5;241m.\u001b[39mfidelity_history))]\n\u001b[0;32m---> 32\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubplots\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfigsize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m8.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m6.0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 34\u001b[0m ax[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mplot(np\u001b[38;5;241m.\u001b[39mmean(env\u001b[38;5;241m.\u001b[39mreward_history, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m), label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mReward\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 35\u001b[0m ax[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 36\u001b[0m fidelity_range,\n\u001b[1;32m 37\u001b[0m env\u001b[38;5;241m.\u001b[39mfidelity_history,\n\u001b[1;32m 38\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCircuit Fidelity\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 39\u001b[0m )\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/pyplot.py:1760\u001b[0m, in \u001b[0;36msubplots\u001b[0;34m(nrows, ncols, sharex, sharey, squeeze, width_ratios, height_ratios, subplot_kw, gridspec_kw, **fig_kw)\u001b[0m\n\u001b[1;32m 1615\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1616\u001b[0m \u001b[38;5;124;03mCreate a figure and a set of subplots.\u001b[39;00m\n\u001b[1;32m 1617\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1757\u001b[0m \n\u001b[1;32m 1758\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1759\u001b[0m fig \u001b[38;5;241m=\u001b[39m figure(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mfig_kw)\n\u001b[0;32m-> 1760\u001b[0m axs \u001b[38;5;241m=\u001b[39m \u001b[43mfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubplots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnrows\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnrows\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mncols\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mncols\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msharex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msharey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1761\u001b[0m \u001b[43m \u001b[49m\u001b[43msqueeze\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msqueeze\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msubplot_kw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msubplot_kw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1762\u001b[0m \u001b[43m \u001b[49m\u001b[43mgridspec_kw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgridspec_kw\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheight_ratios\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheight_ratios\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1763\u001b[0m \u001b[43m \u001b[49m\u001b[43mwidth_ratios\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwidth_ratios\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1764\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fig, axs\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/figure.py:861\u001b[0m, in \u001b[0;36mFigureBase.subplots\u001b[0;34m(self, nrows, ncols, sharex, sharey, squeeze, width_ratios, height_ratios, subplot_kw, gridspec_kw)\u001b[0m\n\u001b[1;32m 858\u001b[0m gridspec_kw[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mwidth_ratios\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m width_ratios\n\u001b[1;32m 860\u001b[0m gs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_gridspec(nrows, ncols, figure\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mgridspec_kw)\n\u001b[0;32m--> 861\u001b[0m axs \u001b[38;5;241m=\u001b[39m \u001b[43mgs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubplots\u001b[49m\u001b[43m(\u001b[49m\u001b[43msharex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msharey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msqueeze\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msqueeze\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 862\u001b[0m \u001b[43m \u001b[49m\u001b[43msubplot_kw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msubplot_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 863\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m axs\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/gridspec.py:283\u001b[0m, in \u001b[0;36mGridSpecBase.subplots\u001b[0;34m(self, sharex, sharey, squeeze, subplot_kw)\u001b[0m\n\u001b[1;32m 281\u001b[0m subplot_kw[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msharex\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m shared_with[sharex]\n\u001b[1;32m 282\u001b[0m subplot_kw[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msharey\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m shared_with[sharey]\n\u001b[0;32m--> 283\u001b[0m axarr[row, col] \u001b[38;5;241m=\u001b[39m \u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madd_subplot\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msubplot_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 286\u001b[0m \u001b[38;5;66;03m# turn off redundant tick labeling\u001b[39;00m\n\u001b[1;32m 287\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m sharex \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcol\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mall\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/figure.py:710\u001b[0m, in \u001b[0;36mFigureBase.add_subplot\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 708\u001b[0m args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mstr\u001b[39m(args[\u001b[38;5;241m0\u001b[39m])))\n\u001b[1;32m 709\u001b[0m projection_class, pkw \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_process_projection_requirements(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 710\u001b[0m ax \u001b[38;5;241m=\u001b[39m \u001b[43mprojection_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 711\u001b[0m key \u001b[38;5;241m=\u001b[39m (projection_class, pkw)\n\u001b[1;32m 712\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_axes_internal(ax, key)\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:681\u001b[0m, in \u001b[0;36m_AxesBase.__init__\u001b[0;34m(self, fig, facecolor, frameon, sharex, sharey, label, xscale, yscale, box_aspect, forward_navigation_events, *args, **kwargs)\u001b[0m\n\u001b[1;32m 678\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mset_axisbelow(mpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.axisbelow\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m 680\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_rasterization_zorder \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m--> 681\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclear\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 683\u001b[0m \u001b[38;5;66;03m# funcs used to format x and y - fall back on major formatters\u001b[39;00m\n\u001b[1;32m 684\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfmt_xdata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:1391\u001b[0m, in \u001b[0;36m_AxesBase.clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1389\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcla()\n\u001b[1;32m 1390\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1391\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__clear\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:1307\u001b[0m, in \u001b[0;36m_AxesBase.__clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1304\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlegend_ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1305\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcontainers \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m-> 1307\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrid\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Disable grid on init to use rcParameter\u001b[39;00m\n\u001b[1;32m 1308\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrid(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gridOn, which\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.grid.which\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m 1309\u001b[0m axis\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.grid.axis\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m 1310\u001b[0m props \u001b[38;5;241m=\u001b[39m font_manager\u001b[38;5;241m.\u001b[39mFontProperties(\n\u001b[1;32m 1311\u001b[0m size\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.titlesize\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m 1312\u001b[0m weight\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.titleweight\u001b[39m\u001b[38;5;124m'\u001b[39m])\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:3276\u001b[0m, in \u001b[0;36m_AxesBase.grid\u001b[0;34m(self, visible, which, axis, **kwargs)\u001b[0m\n\u001b[1;32m 3274\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mxaxis\u001b[38;5;241m.\u001b[39mgrid(visible, which\u001b[38;5;241m=\u001b[39mwhich, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 3275\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m axis \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mboth\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[0;32m-> 3276\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43myaxis\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrid\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvisible\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwhich\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwhich\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axis.py:1732\u001b[0m, in \u001b[0;36mAxis.grid\u001b[0;34m(self, visible, which, **kwargs)\u001b[0m\n\u001b[1;32m 1729\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m which \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmajor\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mboth\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[1;32m 1730\u001b[0m gridkw[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgridOn\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m (\u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_major_tick_kw[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgridOn\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 1731\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m visible \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m visible)\n\u001b[0;32m-> 1732\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_tick_params\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwhich\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmajor\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgridkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1733\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axis.py:999\u001b[0m, in \u001b[0;36mAxis.set_tick_params\u001b[0;34m(self, which, reset, **kwargs)\u001b[0m\n\u001b[1;32m 997\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_major_tick_kw\u001b[38;5;241m.\u001b[39mupdate(kwtrans)\n\u001b[1;32m 998\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m tick \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmajorTicks:\n\u001b[0;32m--> 999\u001b[0m \u001b[43mtick\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_apply_params\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwtrans\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1000\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m which \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mminor\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mboth\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[1;32m 1001\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_minor_tick_kw\u001b[38;5;241m.\u001b[39mupdate(kwtrans)\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axis.py:372\u001b[0m, in \u001b[0;36mTick._apply_params\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 368\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlabel2\u001b[38;5;241m.\u001b[39mset(rotation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_labelrotation[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 370\u001b[0m label_kw \u001b[38;5;241m=\u001b[39m {k[\u001b[38;5;241m5\u001b[39m:]: v \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 371\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabelsize\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabelcolor\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabelfontfamily\u001b[39m\u001b[38;5;124m'\u001b[39m]}\n\u001b[0;32m--> 372\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlabel1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mlabel_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 373\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlabel2\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mlabel_kw)\n\u001b[1;32m 375\u001b[0m grid_kw \u001b[38;5;241m=\u001b[39m {k[\u001b[38;5;241m5\u001b[39m:]: v \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 376\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m _gridline_param_names}\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/artist.py:147\u001b[0m, in \u001b[0;36mArtist.__init_subclass__..\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_autogenerated_signature\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 140\u001b[0m \u001b[38;5;66;03m# Don't overwrite cls.set if the subclass or one of its parents\u001b[39;00m\n\u001b[1;32m 141\u001b[0m \u001b[38;5;66;03m# has defined a set method set itself.\u001b[39;00m\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# If there was no explicit definition, cls.set is inherited from\u001b[39;00m\n\u001b[1;32m 143\u001b[0m \u001b[38;5;66;03m# the hierarchy of auto-generated set methods, which hold the\u001b[39;00m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;66;03m# flag _autogenerated_signature.\u001b[39;00m\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m--> 147\u001b[0m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m \u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: \u001b[43mArtist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mset\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.set\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/artist.py:1224\u001b[0m, in \u001b[0;36mArtist.set\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 1220\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mset\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 1221\u001b[0m \u001b[38;5;66;03m# docstring and signature are auto-generated via\u001b[39;00m\n\u001b[1;32m 1222\u001b[0m \u001b[38;5;66;03m# Artist._update_set_signature_and_docstring() at the end of the\u001b[39;00m\n\u001b[1;32m 1223\u001b[0m \u001b[38;5;66;03m# module.\u001b[39;00m\n\u001b[0;32m-> 1224\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_internal_update(\u001b[43mcbook\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_kwargs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m)\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/cbook.py:1834\u001b[0m, in \u001b[0;36mnormalize_kwargs\u001b[0;34m(kw, alias_mapping)\u001b[0m\n\u001b[1;32m 1830\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(alias_mapping, \u001b[38;5;28mtype\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(alias_mapping, Artist)\n\u001b[1;32m 1831\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(alias_mapping, Artist)):\n\u001b[1;32m 1832\u001b[0m alias_mapping \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(alias_mapping, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_alias_map\u001b[39m\u001b[38;5;124m\"\u001b[39m, {})\n\u001b[0;32m-> 1834\u001b[0m to_canonical \u001b[38;5;241m=\u001b[39m {alias: canonical\n\u001b[1;32m 1835\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m canonical, alias_list \u001b[38;5;129;01min\u001b[39;00m alias_mapping\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 1836\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m alias \u001b[38;5;129;01min\u001b[39;00m alias_list}\n\u001b[1;32m 1837\u001b[0m canonical_to_seen \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1838\u001b[0m ret \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;66;03m# output dictionary\u001b[39;00m\n", + "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/cbook.py:1834\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 1830\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(alias_mapping, \u001b[38;5;28mtype\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(alias_mapping, Artist)\n\u001b[1;32m 1831\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(alias_mapping, Artist)):\n\u001b[1;32m 1832\u001b[0m alias_mapping \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(alias_mapping, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_alias_map\u001b[39m\u001b[38;5;124m\"\u001b[39m, {})\n\u001b[0;32m-> 1834\u001b[0m to_canonical \u001b[38;5;241m=\u001b[39m {alias: canonical\n\u001b[1;32m 1835\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m canonical, alias_list \u001b[38;5;129;01min\u001b[39;00m alias_mapping\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 1836\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m alias \u001b[38;5;129;01min\u001b[39;00m alias_list}\n\u001b[1;32m 1837\u001b[0m canonical_to_seen \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1838\u001b[0m ret \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;66;03m# output dictionary\u001b[39;00m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "q_env.clear_history()\n", + "ppo_agent.run_training()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1. -0.9 -0.8 -0.7 -0.6 -0.5\n", + " -0.39999998 -0.3 -0.19999999 -0.09999996 0. 0.10000002\n", + " 0.20000005 0.30000007 0.39999998 0.5 0.6 0.70000005\n", + " 0.8000001 0.9 1. ]\n" + ] + } + ], + "source": [ + "print(ppo_agent.env.discrete_obs_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9985995241871047\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9989732950258189\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9991835665874736\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9991081664874701\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9993452535454714\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9991510376887669\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9995420779042276\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9995453289505949\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9995466226025103\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9996009987598009\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997088713602433\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997319127536364\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997183285770944\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997444975389426\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9996295721608842\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997271981655309\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997616966267021\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997601831590299\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997367445139802\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997647632355686\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997938771814829\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998158747724952\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998578400656049\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998197848648662\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.999810771690542\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998122971266185\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998038140052423\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998304602814778\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997426172712619\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.999815431793327\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997965279126374\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997830233255156\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997172481636374\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9996888193529829\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997247064895984\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9998288664455286\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997487795034264\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997905559265658\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9996899007498741\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.999706906434308\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997365253398192\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997472124344526\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997632480785048\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9996653711909514\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9997019581148314\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9995417912820541\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9994268507614065\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9991504418737474\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9991466368245276\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9986412498753037\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.998531131165249\n", + "(1,)\n", + "(32,)\n" + ] + } + ], + "source": [ + "# Evaluating Policy across Parameter Space\n", + "\n", + "import torch\n", + "\n", + "obs_linspace = np.linspace(-1.0, 1.0, 51)\n", + "\n", + "mean_reward = np.zeros_like(obs_linspace)\n", + "std_reward = np.zeros_like(obs_linspace)\n", + "mean_actions = np.zeros((len(obs_linspace),) + q_env.action_space.shape)\n", + "std_actions = np.zeros((len(obs_linspace),) + q_env.action_space.shape)\n", + "\n", + "for i, test_obs in enumerate(obs_linspace):\n", + " test_obs, _ = ppo_agent.env.reset(seed=ppo_agent.seed, override_obs=test_obs)\n", + " batch_test_obs = np.tile(test_obs, (ppo_agent.num_envs, 1))\n", + " with torch.no_grad():\n", + " action, logprob, _, value = ppo_agent.agent.get_action_and_value(\n", + " torch.Tensor(batch_test_obs)\n", + " )\n", + " cpu_action = action.cpu().numpy()\n", + " cpu_action = np.clip(\n", + " cpu_action,\n", + " ppo_agent.env.action_space.low,\n", + " ppo_agent.env.action_space.high,\n", + " )\n", + "\n", + " played_action = cpu_action\n", + " # played_action[:, 0] = 0.\n", + " # played_action[:, 1] = 0.\n", + " # played_action[:, 2] = 0.\n", + " # played_action[:, 4] = 0.\n", + " # played_action[:, 5] = 0.\n", + " # played_action[:, 3] = -0.5 * q_env.gamma * test_obs * np.pi + 0.25\n", + " # played_action[:, 6] = 0.5 * q_env.gamma * test_obs * np.pi + 0.25\n", + "\n", + " mean_actions[i] = np.mean(played_action, axis=0)\n", + " std_actions[i] = np.std(played_action, axis=0)\n", + "\n", + " next_obs, reward, terminations, truncations, infos = ppo_agent.env.step(\n", + " played_action\n", + " )\n", + " mean_reward[i] = np.mean(reward)\n", + " std_reward[i] = np.std(reward)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.835838404566957\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "mean_fidelity = 1. - 10**(-mean_reward)\n", + "std_fidelity = 1. - 10**(-std_reward)\n", + "\n", + "obs_rad_linspace = obs_linspace * np.pi\n", + "\n", + "print(np.max(mean_reward))\n", + "\n", + "plt.errorbar(obs_rad_linspace, mean_reward, yerr=std_reward, fmt=\"o\", label='Evaluated Policy Rewards')\n", + "plt.axvline(x=obs_rad_linspace[np.argmax(mean_reward)])\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 32, 1])\n" + ] + } + ], + "source": [ + "print(ppo_agent.obs.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reward_hist = np.array(q_env.reward_history)\n", + "\n", + "pf_mean_hist = -np.log10(1. - np.mean(reward_hist, axis=1))\n", + "pf_std_hist = -np.log10(1. - np.std(reward_hist, axis=1))\n", + "\n", + "plt.errorbar(np.arange(len(reward_hist)), pf_mean_hist, yerr=pf_std_hist)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-5.58376662e-04 3.71710137e-02 2.83655882e-01 5.84286869e-01\n", + " -4.34491336e-02 -5.35132289e-02 -2.96272606e-01]\n", + " [ 3.35727964e-04 1.86646610e-01 4.43352520e-01 5.76919436e-01\n", + " -4.07642983e-02 -6.03764504e-02 -2.82482535e-01]\n", + " [-2.79297633e-03 1.26424050e-02 3.59021217e-01 5.59786916e-01\n", + " -4.45756391e-02 -5.56047261e-02 -2.65633523e-01]\n", + " [-3.27075133e-03 4.99847606e-02 3.19938004e-01 5.41228771e-01\n", + " -3.83227505e-02 -5.43864556e-02 -2.52430707e-01]\n", + " [-3.22321733e-03 6.04441166e-02 2.32093483e-01 5.25236070e-01\n", + " -3.25061455e-02 -5.38300537e-02 -2.34052226e-01]\n", + " [-1.95786779e-04 9.35754627e-02 2.57606506e-01 5.18513501e-01\n", + " -4.55953032e-02 -3.77426706e-02 -2.14172736e-01]\n", + " [ 1.36486220e-03 1.83728822e-02 2.73302644e-01 5.08394480e-01\n", + " -3.62073854e-02 -4.81719449e-02 -1.90479100e-01]\n", + " [-2.68273777e-03 9.33362618e-02 3.52148443e-01 4.93035048e-01\n", + " -3.66185680e-02 -5.38651086e-02 -1.70757920e-01]\n", + " [-9.27919755e-04 1.73141599e-01 2.77335882e-01 4.84731942e-01\n", + " -3.21951695e-02 -5.44991232e-02 -1.50890082e-01]\n", + " [-2.67657079e-03 9.75594297e-02 2.25941360e-01 4.68628138e-01\n", + " -2.31804792e-02 -5.70043027e-02 -1.36018276e-01]\n", + " [-2.67326413e-03 -1.66244619e-02 3.24222296e-01 4.53654110e-01\n", + " -2.66986061e-02 -4.85775135e-02 -1.16542205e-01]\n", + " [-1.07768772e-03 -4.90250103e-02 3.47329736e-01 4.38644886e-01\n", + " -2.97536626e-02 -6.10259660e-02 -8.80995244e-02]\n", + " [ 6.78420474e-04 1.14128247e-01 1.13038838e-01 4.23338801e-01\n", + " -2.60650553e-02 -4.16751467e-02 -7.56628960e-02]\n", + " [ 9.52997769e-04 -2.58845557e-02 3.86070192e-01 4.09358531e-01\n", + " -1.99937001e-02 -4.25034836e-02 -4.54639830e-02]\n", + " [ 6.31468720e-05 9.08210352e-02 1.83577374e-01 3.94338608e-01\n", + " -1.88802592e-02 -4.55579422e-02 -3.10266502e-02]\n", + " [ 6.35380391e-04 -8.77136514e-02 3.28510076e-01 3.77283573e-01\n", + " -1.29690524e-02 -4.50170860e-02 -6.36846758e-03]\n", + " [ 1.00073719e-03 1.31835625e-01 3.50351840e-01 3.60998631e-01\n", + " -1.31607475e-02 -5.28283194e-02 1.94083508e-02]\n", + " [ 7.99460104e-04 -1.22535676e-02 2.57124215e-01 3.41023654e-01\n", + " -9.62677691e-03 -3.82847711e-02 2.80133113e-02]\n", + " [-1.75455015e-03 2.81211823e-01 2.50498086e-01 3.21292728e-01\n", + " -1.35917198e-02 -5.39221354e-02 4.99829203e-02]\n", + " [-2.29953369e-03 1.54793978e-01 2.13255763e-01 3.11559737e-01\n", + " -9.13888775e-03 -4.63940687e-02 7.53421783e-02]\n", + " [ 1.88979227e-03 4.94206138e-02 1.86860114e-01 2.85523653e-01\n", + " -7.55845103e-03 -4.58789393e-02 9.76347178e-02]\n", + " [-1.00098434e-03 3.60827446e-02 4.82431263e-01 2.66881049e-01\n", + " -8.91293492e-03 -5.69317378e-02 1.15597278e-01]\n", + " [ 2.63199385e-04 1.91758364e-01 2.12104857e-01 2.48195857e-01\n", + " -3.42038530e-03 -6.00379221e-02 1.32513463e-01]\n", + " [-4.33847774e-03 4.31166403e-03 2.86155134e-01 2.34144226e-01\n", + " -1.20803388e-03 -4.23068777e-02 1.56352177e-01]\n", + " [-4.87854704e-04 7.07283467e-02 3.34997505e-01 2.14004293e-01\n", + " -3.84147788e-05 -5.40042445e-02 1.80351034e-01]\n", + " [-8.95267120e-04 7.13667348e-02 3.11324775e-01 1.96452349e-01\n", + " 5.42395795e-03 -4.83864546e-02 2.02768072e-01]\n", + " [-1.16005260e-03 3.81037518e-02 3.22996914e-01 1.72234610e-01\n", + " 7.00039603e-03 -5.32412939e-02 2.20106825e-01]\n", + " [-2.12345901e-03 2.20832154e-01 3.13613385e-01 1.54573604e-01\n", + " 9.73308180e-03 -5.03826216e-02 2.36980751e-01]\n", + " [ 7.64394645e-05 1.58828691e-01 1.85871497e-01 1.36068329e-01\n", + " 1.02785844e-02 -5.10814823e-02 2.63184667e-01]\n", + " [ 1.81912328e-05 1.76636040e-01 3.96664560e-01 1.14803195e-01\n", + " 9.03652888e-03 -4.93537411e-02 2.79278576e-01]\n", + " [ 1.29923504e-03 2.10962459e-01 3.58348757e-01 9.97341201e-02\n", + " 1.00341877e-02 -5.26990108e-02 2.93530107e-01]\n", + " [-1.12952862e-03 8.20996165e-02 3.09355021e-01 7.81879351e-02\n", + " 1.47725195e-02 -4.54406999e-02 3.17280471e-01]\n", + " [ 6.67073531e-04 5.48780225e-02 2.83605218e-01 5.40479906e-02\n", + " 1.71851683e-02 -6.27930462e-02 3.32167625e-01]\n", + " [-1.04102679e-03 1.94142893e-01 2.63496310e-01 3.87156643e-02\n", + " 1.78968590e-02 -5.43451533e-02 3.55374128e-01]\n", + " [ 6.98322779e-04 6.98832795e-02 2.26173311e-01 1.57313645e-02\n", + " 2.16248576e-02 -5.88655025e-02 3.67800176e-01]\n", + " [ 1.09194370e-05 1.41051665e-01 2.45627254e-01 2.90450919e-03\n", + " 2.05357131e-02 -5.75263798e-02 3.84045780e-01]\n", + " [-3.93119262e-06 5.49332276e-02 3.24228108e-01 -2.26857122e-02\n", + " 2.41305828e-02 -5.45962043e-02 4.01913106e-01]\n", + " [ 2.38947032e-04 2.00921386e-01 4.12730932e-01 -3.95076834e-02\n", + " 2.20026802e-02 -4.83079404e-02 4.17185634e-01]\n", + " [-1.46564475e-04 1.79424658e-01 2.51978815e-01 -5.59336618e-02\n", + " 2.63350420e-02 -5.04102595e-02 4.42543209e-01]\n", + " [-1.71882845e-03 5.23010567e-02 2.42769033e-01 -7.73226246e-02\n", + " 3.04085184e-02 -5.79289049e-02 4.47403282e-01]\n", + " [ 3.14023043e-03 1.26089364e-01 2.88250357e-01 -1.00384541e-01\n", + " 3.19290459e-02 -5.02152555e-02 4.66118157e-01]\n", + " [ 7.31402542e-06 5.28462306e-02 3.91727805e-01 -1.16412513e-01\n", + " 3.49375829e-02 -4.76681963e-02 4.81652468e-01]\n", + " [ 1.47933664e-03 2.13671774e-01 1.91049784e-01 -1.37827843e-01\n", + " 3.52223255e-02 -4.64182124e-02 5.02750099e-01]\n", + " [-4.57210263e-04 2.07729980e-01 2.28208259e-01 -1.54687583e-01\n", + " 3.62687223e-02 -3.89702134e-02 5.11603117e-01]\n", + " [-2.11749284e-04 2.73397833e-01 2.33013049e-01 -1.70880228e-01\n", + " 3.89538184e-02 -4.18340489e-02 5.28123915e-01]\n", + " [-1.36930472e-03 2.21530989e-01 3.16481858e-01 -1.89784229e-01\n", + " 3.60112488e-02 -4.93225753e-02 5.37120938e-01]\n", + " [ 3.27408756e-03 2.98784107e-01 2.75724888e-01 -2.10383117e-01\n", + " 4.32928689e-02 -5.47275022e-02 5.45810640e-01]\n", + " [ 3.42207612e-04 1.58325478e-01 3.49794984e-01 -2.25133970e-01\n", + " 4.48424928e-02 -4.88688909e-02 5.62125623e-01]\n", + " [-1.16307242e-03 1.23091221e-01 3.19913924e-01 -2.44522244e-01\n", + " 4.44088094e-02 -4.78904769e-02 5.77923179e-01]\n", + " [ 1.89866358e-03 1.93869084e-01 1.13300495e-01 -2.61649340e-01\n", + " 4.98280823e-02 -4.68509719e-02 5.84139943e-01]\n", + " [ 2.40421225e-03 2.39012554e-01 3.37499797e-01 -2.77788222e-01\n", + " 5.17962016e-02 -5.17398864e-02 6.00755692e-01]]\n", + "[ 0.0002632 0.19175836 0.21210486 0.24819586 -0.00342039 -0.06003792\n", + " 0.13251346]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(mean_actions)\n", + "print(mean_actions[np.argmax(mean_reward)])\n", + "plt.axvline(x=obs_rad_linspace[np.argmax(mean_reward)])\n", + "for i in range(len(mean_actions.T)):\n", + " plt.errorbar(obs_rad_linspace, mean_actions[:, i], yerr=std_actions[:, i], fmt=\"o\", label=f'Action {i}')\n", + "plt.plot(obs_rad_linspace, obs_rad_linspace * 0.15, label='analytical +')\n", + "plt.plot(obs_rad_linspace, -obs_rad_linspace * 0.15, label='analytical -')\n", + "plt.plot(obs_rad_linspace, mean_actions[:, 3] + mean_actions[:, 6], label='sum 3 + 6')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(obs_linspace, mean_fidelity, label='Evaluated Policy Rewards')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.7938926261462362\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.8306559326618255\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.8644843137107057\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.8950775061878449\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9221639627510073\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9455032620941837\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9648882429441255\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9801468428384712\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9911436253643444\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.99778098230154\n", + "\n", + " NoiseModel: Ideal \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9999999999999998\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.99778098230154\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9911436253643444\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9801468428384716\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9648882429441259\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9455032620941841\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.9221639627510079\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.8950775061878453\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.8644843137107061\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.8306559326618265\n", + "\n", + " NoiseModel:\n", + " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", + " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", + " Qubits with noise: [0, 1]\n", + " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", + "\n", + "Circuit context\n", + " ┌─────────────────────────────┐ \n", + " q_0 -> 0 ┤0 ├──■──\n", + " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", + " q_1 -> 1 ┤1 ├┤ X ├\n", + " └─────────────────────────────┘└───┘\n", + " ancilla_0 -> 2 ────────────────────────────────────\n", + " \n", + " ancilla_1 -> 3 ────────────────────────────────────\n", + " \n", + " ancilla_2 -> 4 ────────────────────────────────────\n", + " \n", + " ancilla_3 -> 5 ────────────────────────────────────\n", + " \n", + " ancilla_4 -> 6 ────────────────────────────────────\n", + " \n", + " ancilla_5 -> 7 ────────────────────────────────────\n", + " \n", + " ancilla_6 -> 8 ────────────────────────────────────\n", + " \n", + " ancilla_7 -> 9 ────────────────────────────────────\n", + " \n", + " ancilla_8 -> 10 ────────────────────────────────────\n", + " \n", + " ancilla_9 -> 11 ────────────────────────────────────\n", + " \n", + "ancilla_10 -> 12 ────────────────────────────────────\n", + " \n", + "ancilla_11 -> 13 ────────────────────────────────────\n", + " \n", + "ancilla_12 -> 14 ────────────────────────────────────\n", + " \n", + "ancilla_13 -> 15 ────────────────────────────────────\n", + " \n", + "ancilla_14 -> 16 ────────────────────────────────────\n", + " \n", + "ancilla_15 -> 17 ────────────────────────────────────\n", + " \n", + "ancilla_16 -> 18 ────────────────────────────────────\n", + " \n", + "ancilla_17 -> 19 ────────────────────────────────────\n", + " \n", + "ancilla_18 -> 20 ────────────────────────────────────\n", + " \n", + "ancilla_19 -> 21 ────────────────────────────────────\n", + " \n", + "ancilla_20 -> 22 ────────────────────────────────────\n", + " \n", + "ancilla_21 -> 23 ────────────────────────────────────\n", + " \n", + "ancilla_22 -> 24 ────────────────────────────────────\n", + " \n", + "ancilla_23 -> 25 ────────────────────────────────────\n", + " \n", + "ancilla_24 -> 26 ────────────────────────────────────\n", + " \n", + "ancilla_25 -> 27 ────────────────────────────────────\n", + " \n", + "ancilla_26 -> 28 ────────────────────────────────────\n", + " \n", + "Fidelity stored 0.7938926261462371\n" + ] + } + ], + "source": [ + "# Evaluating Policy across Parameter Space\n", + "\n", + "import torch\n", + "\n", + "obs_linspace = np.linspace(-1.0, 1.0, 21)\n", + "\n", + "zeros_mean_reward = np.zeros_like(obs_linspace)\n", + "zeros_std_reward = np.zeros_like(obs_linspace)\n", + "\n", + "for i, test_obs in enumerate(obs_linspace):\n", + " test_obs, _ = ppo_agent.env.reset(seed=ppo_agent.seed, override_obs=test_obs)\n", + " batch_test_obs = np.tile(test_obs, (ppo_agent.num_envs, 1))\n", + " with torch.no_grad():\n", + " action, logprob, _, value = ppo_agent.agent.get_action_and_value(\n", + " torch.Tensor(batch_test_obs)\n", + " )\n", + " cpu_action = action.cpu().numpy()\n", + " cpu_action = np.clip(\n", + " cpu_action,\n", + " ppo_agent.env.action_space.low,\n", + " ppo_agent.env.action_space.high,\n", + " )\n", + " cpu_action = np.zeros_like(cpu_action)\n", + "\n", + " next_obs, reward, terminations, truncations, infos = ppo_agent.env.step(\n", + " cpu_action\n", + " )\n", + " zeros_mean_reward[i] = np.mean(reward)\n", + " zeros_std_reward[i] = np.std(reward)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "zeros_mean_fidelity = 1. - np.exp(-zeros_mean_reward)\n", + "zeros_std_fidelity = 1. - np.exp(-zeros_std_reward)\n", + "\n", + "plt.errorbar(obs_linspace * np.pi, zeros_mean_reward * np.log10(np.e), yerr=zeros_std_reward * np.log10(np.e), fmt=\"o\", label='Evaluated Policy Rewards')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGdCAYAAABO2DpVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA/u0lEQVR4nO3deXxU1f3/8fckkElISCBsCRKSyCKExRUUEAmKEqoRsaJFFFyrCCi1WtR+W7TWAnWjdUG0luhPcCkYwVqDoCQoIHsUSATFIAhhETAhLAkk5/fHNFOGLGSSO2tez8djHjp37tz74Wbm3s/cc87n2IwxRgAAABYI8XUAAAAgeJBYAAAAy5BYAAAAy5BYAAAAy5BYAAAAy5BYAAAAy5BYAAAAy5BYAAAAyzTx9g4rKiq0e/duNW/eXDabzdu7BwAA9WCM0eHDh9W+fXuFhNR8X8LricXu3buVkJDg7d0CAAAL7Ny5Ux06dKjxda8nFs2bN5fkCCw6OtrbuwcAAPVQXFyshIQE53W8Jl5PLCqbP6Kjo0ksAAAIMGfqxkDnTQAAYBkSCwAAYBkSCwAAYBmv97EAgOoYY3Ty5EmVl5f7OhSgUQoNDVWTJk0aXAqCxAKAz5WVlamwsFBHjx71dShAo9asWTPFx8crLCys3tsgsQDgUxUVFSooKFBoaKjat2+vsLAwiucBXmaMUVlZmfbv36+CggJ16dKl1iJYtSGxAOBTZWVlqqioUEJCgpo1a+brcIBGKyIiQk2bNtUPP/ygsrIyhYeH12s7dN4E4Bfq++sIgHWs+B5yxwKANSrKpR9WSCV7pah2UmJ/KSTUqyEcLTuplD8ukiTl/WmomoVxigO8ze3UZNeuXbrlllvUqlUrRUREqFevXlq7dq0nYgMQKPIWSjN6Sm9cI82/0/HfGT0dy9Eg27dvl81mU25urq9DqVFSUpJmzJjhse1nZ2fLZrPp559/liRlZGSoRYsWHttfoDv9eHmbW4nFoUOHNGDAADVt2lQff/yx8vLy9Oyzz6ply5aeig+Av8tbKL03Rire7bq8uNCx3IvJRXmFcf7/6oKDLs894bbbbpPNZqvySEtL8+h+reDpZOBUjz/+uPPYNGnSRElJSfrNb36jkpKSem3vpptu0tatWy2O8n8qk7nKR2xsrAYNGqTPP//cY/sMJm7dJ5w+fboSEhI0e/Zs57Lk5GTLgwIQICrKpazJkqq7gBtJNinrEanb1R5vFsnaVKgpCzc7n982e43iY8I1JT1FaT3jPbbftLQ0l3OiJNntdo/tL1D16NFDS5Ys0cmTJ7V8+XLdcccdOnr0qGbNmuX2tiIiIhQREeGBKF0tWbJEPXr00E8//aSnnnpK11xzjbZu3ap27dp5fN91UVZW1qBhoZ7i1h2LhQsX6qKLLtLIkSPVtm1bnX/++XrttddqfU9paamKi4tdHgCCxA8rqt6pcGGk4l2O9Twoa1Ohxr21XnuLS12W7yk6rnFvrVfWpkKP7dtutysuLs7lUXkX9+abb9ZNN93ksv6JEyfUunVrvfnmm47Ys7J06aWXqkWLFmrVqpWuueYabdu2rcb9VdcM8MEHH7gM0d22bZuGDx+udu3aKSoqSn369NGSJUucr6empuqHH37Qb37zG+ev8kpffPGFBg4cqIiICCUkJOj+++/XkSNHnK/v27dP6enpioiIUHJysubMmVOn49SkSRPFxcWpQ4cOuummmzR69GgtXOi4m1VaWqr7779fbdu2VXh4uC699FKtWbPGrWPw4Ycfqk+fPgoPD1fr1q01YsQISdKf/vQn9ezZs8o2zjvvPP3hD3+oNeZWrVopLi5OPXv21GOPPabi4mKtWrXK+fqmTZs0bNgwRUVFqV27drr11lv1008/SZL+/e9/q0WLFs6Cb7m5ubLZbHrkkUec77/rrrt0yy23SJIOHDigUaNG6ayzzlKzZs3Uq1cvvf322y7xpKamasKECZo0aZJat26toUOHSpL+85//qGvXroqIiNDgwYO1fft2l/f98MMPSk9PV8uWLRUZGakePXroP//5T63/9oZwK7H4/vvvNXPmTHXp0kWLFi3SuHHjdP/99+uNN96o8T1Tp05VTEyM85GQkNDgoAH4iZK91q5XD+UVRk98mFfjPRNJeuLDPI83i1Rn9OjR+vDDD11u+S9atEhHjx51XviOHDmiBx98UGvXrtWnn36qkJAQjRgxQhUVFfXeb0lJiX7xi1/o008/1YYNG5SWlqb09HTt2LFDkvT++++rQ4cO+tOf/qTCwkIVFjoSr23btiktLU2//OUv9fXXX+vdd9/VF198oQkTJji3fdttt2nnzp1aunSp5s2bp5dffln79u1zO8aIiAiVlZVJkn73u99p/vz5euONN7R+/Xp17txZQ4cO1cGDB+u0rY8++kgjRozQL37xC23YsEGffvqp+vbtK0m64447lJ+f75KobNiwQV9//bVuv/32Om3/2LFjzkSw8g7Bzz//rMsvv1znn3++1q5dq6ysLO3du1c33nijJGngwIE6fPiwNmzYIEnKyclR69atlZ2d7dxuTk6OUlNTJUnHjx/XhRdeqI8++kibNm3Sr3/9a916661avXq1SyxvvPGGwsLCtHz5cr3yyivauXOnrr/+eqWnpys3N1d33XWXS/IiSePHj1dpaamWLVumjRs3avr06YqKiqrTv71ejBuaNm1q+vXr57Js4sSJ5pJLLqnxPcePHzdFRUXOx86dO40kU1RU5M6uAfij75cZMyX6zI/vl9W4iWPHjpm8vDxz7NixeoWw4rufTOLkf5/xseK7n+r7r6zR2LFjTWhoqImMjHR5PPXUU8YYY06cOGFat25t3nzzTed7Ro0aZW666aYat7l//34jyWzcuNEYY0xBQYGRZDZs2GCMMWb27NkmJibG5T2ZmZnmTKfzHj16mBdeeMH5PDEx0Tz//PMu69x5553m17/+tcuyzz//3ISEhJhjx46ZLVu2GElm9erVztfz8/ONpCrbOtWUKVPMueee63y+du1a07p1a3PDDTeYkpIS07RpUzNnzhzn62VlZaZ9+/bmr3/9qzHGmKVLlxpJ5tChQ9Ueg379+pnRo0fXuP9hw4aZcePGOZ9PnDjRpKam1rh+5TGPiIgwkZGRxmazGUnmwgsvNGVlZcYYY5588klz1VVXubyv8vq2ZcsWY4wxF1xwgXn66aeNMcZcd9115qmnnjJhYWHm8OHD5scffzSSzNatW2uM4+qrrza//e1vnc8HDRpkzj//fJd1Hn30UZOSkuKybPLkyS7Hq1evXubxxx+vcT+nqu37WFRUVKfrt1t3LOLj45WSkuKyrHv37s4suDp2u13R0dEuDwBBIrG/FN1eUk2VMm1S9FmO9Txk3+Hjlq7nrsGDBys3N9flce+990py3P6/8cYbnc0FR44c0YIFCzR69Gjn+7/99luNGjVKZ599tqKjo5WUlCRJtZ5Xz6SkpEQPPfSQunfvrhYtWigqKkr5+fln3OZXX32ljIwMRUVFOR9Dhw51VkfNz89XkyZNdOGFFzrf061btzqN0Ni4caOioqIUERGhvn37ql+/fnrxxRe1bds2nThxQgMGDHCu27RpU/Xt21f5+fl1+vfm5ubqiiuuqPH1u+++W2+//baOHz+usrIyzZ07V3fccccZt/vuu+9qw4YNmj9/vjp37qyMjAw1bdpUkuNYLV261OVYdevWTZKcTVmDBg1Sdna2jDH6/PPPdf3116t79+764osvlJOTo/bt26tLly6SpPLycj355JPq1auXYmNjFRUVpUWLFlX5m5167CUpPz9fF198scuyfv36uTy///779ec//1kDBgzQlClT9PXXX5/x394QbnXeHDBggLZs2eKybOvWrUpMTLQ0KAABIiRUSpvuGP0hm1w7cf432Uib5tGOm22b1606YF3Xc1dkZKQ6d+5c4+ujR4/WoEGDtG/fPi1evFgREREuo0bS09OVmJio1157Te3bt1dFRYV69uzpbCY4XUhIiIxxbdY5ceKEy/OHHnpIixcv1jPPPKPOnTsrIiJCN9xwQ43brFRSUqJ77rlH999/f5XXOnbs2KCRGOecc44WLlyoJk2aOEu3S9LevQ1vJjtTR8709HTZ7XZlZmYqLCxMJ06c0A033HDG7SYkJKhLly7q0qWLTp48qREjRmjTpk2y2+0qKSlRenq6pk+fXuV98fGOzsKpqan65z//qa+++kpNmzZVt27dlJqaquzsbB06dEiDBg1yvufpp5/W3/72N82YMUO9evVSZGSkJk2aVOVvFhkZWZdD4uKuu+7S0KFD9dFHH+mTTz7R1KlT9eyzz2rixIlub6su3Lpj8Zvf/EZffvml/vKXv+i7777T3Llz9eqrr2r8+PEeCQ5AAEi5VrrxTSn6tJEX0e0dy1Ou9eju+ybHKj4mvLZ7JoqPCVff5FiPxlGT/v37KyEhQe+++67mzJmjkSNHOn/1HjhwQFu2bNH//d//6YorrlD37t116NChWrfXpk0bHT582KVD5ek1LpYvX67bbrtNI0aMUK9evRQXF1elQ19YWFiVmWQvuOAC5eXlqXPnzlUeYWFh6tatm06ePKl169Y537Nly5Y61UsICwtT586dlZSU5DKSoVOnTs4+A5VOnDihNWvWVLlDXpPevXvr008/rfH1Jk2aaOzYsZo9e7Zmz56tX/3qV26PKrnhhhvUpEkTvfzyy5Icx2rz5s1KSkqqcqwqL/6V/Syef/55ZxJRmVhkZ2c7+1dIjr/Z8OHDdcstt+jcc8/V2WefXadErnv37lX6YXz55ZdV1ktISNC9996r999/X7/97W/POPCiIdxKLPr06aPMzEy9/fbb6tmzp5588knNmDHD5bYegEYo5Vpp0iZp7L+lX77u+O+kjR5PKiQpNMSmKemOC9DpyUXl8ynpKQoN8czEZqWlpdqzZ4/Lo3JkQKWbb75Zr7zyihYvXuxyvmzZsqVatWqlV199Vd99950+++wzPfjgg7Xu7+KLL1azZs302GOPadu2bZo7d64yMjJc1unSpYvef/995ebm6quvvtLNN99cpTNoUlKSli1bpl27djnjnTx5slasWKEJEyYoNzdX3377rRYsWODsvHnOOecoLS1N99xzj1atWqV169bprrvuatDQz8jISI0bN04PP/ywsrKylJeXp7vvvltHjx7VnXfeWadtTJkyRW+//bamTJmi/Px8ZwfFU91111367LPPlJWVVadmkNPZbDbdf//9mjZtmo4eParx48fr4MGDGjVqlNasWaNt27Zp0aJFuv32250JW8uWLdW7d2/NmTPHmURcdtllWr9+vbZu3epyx6JLly5avHixVqxYofz8fN1zzz11uptz77336ttvv9XDDz+sLVu2VPt5mDRpkhYtWqSCggKtX79eS5cuVffu3d0+BnVWp94cFqpr5w8AjUNDO29W+njjbtP3qcUuHTYv+csS8/HG3RZFWtXYsWONHO0/Lo9zzjnHZb28vDwjySQmJpqKigqX1xYvXmy6d+9u7Ha76d27t8nOzjaSTGZmpjGmaudNYxydNTt37mwiIiLMNddcY1599VWXzpsFBQVm8ODBJiIiwiQkJJgXX3zRDBo0yDzwwAPOdVauXGl69+5t7Ha7y3tXr15trrzyShMVFWUiIyNN7969nZ1RjTGmsLDQXH311cZut5uOHTuaN998s9qOoKc6vfPm6Y4dO2YmTpxoWrdubex2uxkwYIBLB9Ezdd40xpj58+eb8847z4SFhZnWrVub66+/vsp+Bg4caHr06FFjHJWqO+bGGHPkyBHTsmVLM336dGOMMVu3bjUjRowwLVq0MBEREaZbt25m0qRJLn/jBx54wEgy+fn5zmXnnnuuiYuLc9n2gQMHzPDhw01UVJRp27at+b//+z8zZswYM3z4cOc6p/8NK3344Yemc+fOxm63m4EDB5p//vOfLsdrwoQJplOnTsZut5s2bdqYW2+91fz0U/Wdma3ovGkz5rTGOg8rLi5WTEyMioqK6MgJQMePH1dBQYGSk5PrPZtipcPHT6jX459IkjJu76OBXdp47E4FAosxRl26dNF99913xrtCjVlt38e6Xr+ZoQdA0Dg1ieibHEtSAUnS/v379c4772jPnj11rl2B+iOxABA0moU10fZpV/s6DPiZtm3bqnXr1nr11VeZ28oLSCwAAEHNyy3+jZ7b06YDAADUhMQCAABYhsQCAABYhsQCAABYhsQCAABYhsQCQPAoOyI9HuN4lB058/oALEdiAQCok6SkJM2YMcP53Gaz6YMPPvBZPP7u9OPVWJBYAAgeFafM1vnDCtfnFsvOzpbNZqvxMXjwYI/tuz62b9/uEl+rVq101VVXacOGDfXeZmFhoYYNG2ZhlK5SU1Od8YaHh6tr166aOnUqdSn8HIkFgOCQt1B6qe//ns+5QZrR07HcA/r376/CwsIqj1mzZslms+m+++6r97bLysosjNTVkiVLVFhYqEWLFqmkpETDhg2r07Tn1YmLi5Pdbrc2wNPcfffdKiws1JYtW/Too4/qj3/8o1555RWP7tMd5eXlVWaObexILAAEvryF0ntjpMOFrsuLCx3LPZBchIWFKS4uzuVx6NAhPfTQQ3rsscc0cuRI57qbNm3SsGHDFBUVpXbt2unWW291mVo9NTVVEyZM0KRJk9S6dWsNHTpUkpSTk6O+ffvKbrcrPj5ejzzyiE6ePOl837x589SrVy9FRESoVatWGjJkiI4cqb1vSatWrRQXF6eLLrpIzzzzjPbu3atVq1ZJkubPn68ePXrIbrcrKSlJzz77bK3bOr0p5Mcff9SoUaMUGxuryMhIXXTRRVq1apW2b9+ukJAQrV271uX9M2bMUGJiYq0X5mbNmikuLk6JiYm6/fbb1bt3by1evNj5emlpqR566CGdddZZioyM1MUXX6zs7GxJjoqbbdq00bx585zrn3feeYqPj3c+/+KLL2S323X06FFJ0nPPPadevXopMjJSCQkJuu+++1RSUuJcPyMjQy1atNDChQuVkpIiu92uHTt2aN++fUpPT1dERISSk5M1Z84cl3+HMUaPP/64OnbsKLvdrvbt2+v++++v9fgGKhILAIGtolzKmizHjOWn+++yrEc82iwiST///LOGDx+u1NRUPfnkky7LL7/8cp1//vlau3atsrKytHfvXt14440u73/jjTcUFham5cuX65VXXtGuXbv0i1/8Qn369NFXX32lmTNn6vXXX9ef//xnSY5miFGjRumOO+5Qfn6+srOzdf3117vVTBARESHJcYdk3bp1uvHGG/WrX/1KGzdu1OOPP64//OEPysjIqNO2SkpKNGjQIO3atUsLFy7UV199pd/97neqqKhQUlKShgwZotmzZ7u8Z/bs2brtttsUEnLmS5ExRp9//rm++eYbhYWFOZdPmDBBK1eu1DvvvKOvv/5aI0eOVFpamr799lvZbDZddtllzkTj0KFDys/P17Fjx/TNN99IciRvffr0UbNmzSRJISEh+vvf/67NmzfrjTfe0Geffabf/e53LrEcPXpU06dP1z/+8Q9t3rxZbdu21W233aadO3dq6dKlmjdvnl5++WXt27fP+Z758+fr+eef16xZs/Ttt9/qgw8+UK9evep0bANOrZOqe0Bd53MH0DgcO3bM5OXlmWPHjtVvA98vM2ZK9Jkf3y+zNvBTlJeXm2HDhpnu3bub4uJil9eefPJJc9VVV7ks27lzp5FktmzZYowxZtCgQeb88893Weexxx4z55xzjqmoqHAue+mll0xUVJQpLy8369atM5LM9u3b6xRjQUGBkWQ2bNhgjDHm0KFDZsSIESYqKsrs2bPH3HzzzebKK690ec/DDz9sUlJSnM8TExPN888/73wuyWRmZhpjjJk1a5Zp3ry5OXDgQLX7f/fdd03Lli3N8ePHjTHGrFu3zthsNlNQUFBjzIMGDTJNmzY1kZGRpmnTpkaSCQ8PN8uXLzfGGPPDDz+Y0NBQs2vXLpf3XXHFFebRRx81xhjz97//3fTo0cMYY8wHH3xgLr74YjN8+HAzc+ZMY4wxQ4YMMY899liNMfzrX/8yrVq1cj6fPXu2kWRyc3Ody7Zs2WIkmdWrVzuX5efnG0nO4/Xss8+arl27mrKyshr35Q9q+z7W9frNHQsAga1kr7Xr1cNjjz2mlStXasGCBWrevLnLa1999ZWWLl2qqKgo56Nbt26SpG3btjnXu/DCC13el5+fr379+slm+9/U7wMGDFBJSYl+/PFHnXvuubriiivUq1cvjRw5Uq+99poOHTp0xlj79++vqKgotWzZUl999ZXeffddtWvXTvn5+RowYIDLugMGDNC3336r8vIz3+3Jzc3V+eefr9jY2Gpfv+666xQaGqrMzExJjiaFwYMHKykpqdbtjh49Wrm5uVq+fLmGDRum3//+9+rfv78kaePGjSovL1fXrl1djm9OTo7z2A4aNEh5eXnav3+/cnJylJqaqtTUVGVnZ+vEiRNasWKFUlNTnftbsmSJrrjiCp111llq3ry5br31Vh04cMDZVCI5msF69+7tfJ6fn68mTZq4/A27deumFi1aOJ+PHDlSx44d09lnn627775bmZmZLs1awYTZTQEEtqh21q7npnfeeUfPPPOMPvroI3Xp0qXK6yUlJUpPT9f06dOrvHZqW39kZKRb+w0NDdXixYu1YsUKffLJJ3rhhRf0+9//XqtWrVJycnKN73v33XeVkpKiVq1auVz4GqqyWaUmYWFhGjNmjGbPnq3rr79ec+fO1d/+9rczbjcmJkadO3eWJL333nvq3LmzLrnkEg0ZMkQlJSUKDQ3VunXrFBoa6vK+qKgoSVKvXr0UGxurnJwc5eTk6KmnnlJcXJymT5+uNWvW6MSJE85EZfv27brmmms0btw4PfXUU4qNjdUXX3yhO++8U2VlZc7mkoiICJeEry4SEhK0ZcsWLVmyRIsXL9Z9992np59+Wjk5OWratKlb2/J33LEAENgS+0vR7SXVdKK3SdFnOdazWG5uru68805NmzbN2eHydBdccIE2b96spKQkde7c2eVRWzLRvXt3rVy50qXPxPLly9W8eXN16NBBkqPz5IABA/TEE09ow4YNCgsLc94RqElCQoI6depUJano3r27li9f7rJs+fLl6tq1a5WLdnV69+6t3NxcHTx4sMZ17rrrLi1ZskQvv/yyTp48qeuvv/6M2z1VVFSUHnjgAT300EMyxuj8889XeXm59u3bV+XYxsXFSXIco4EDB2rBggXavHmzLr30UvXu3VulpaWaNWuWLrroIuffYd26daqoqNCzzz6rSy65RF27dtXu3bvPGFe3bt108uRJrVu3zrlsy5YtVUbbREREKD09XX//+9+VnZ2tlStXauPGjW4dg0BAYgEgsIWESmmVdwNOTy7++zxtmmM9C/3000+67rrrlJqaqltuuUV79uxxeezfv1+SNH78eB08eFCjRo3SmjVrtG3bNi1atEi33357rU0M9913n3bu3KmJEyfqm2++0YIFCzRlyhQ9+OCDCgkJ0apVq/SXv/xFa9eu1Y4dO/T+++9r//796t69e73+Pb/97W/16aef6sknn9TWrVv1xhtv6MUXX9RDDz1Up/ePGjVKcXFxuu6667R8+XJ9//33mj9/vlauXOlcp3v37rrkkks0efJkjRo16ox3Oapzzz33aOvWrZo/f766du2q0aNHa8yYMXr//fdVUFCg1atXa+rUqfroo4+c70lNTdXbb7+t8847T1FRUQoJCdFll12mOXPmaNCgQc71OnfurBMnTuiFF17Q999/r//3//5fnYa2nnPOOUpLS9M999yjVatWad26dbrrrrtc/n0ZGRl6/fXXtWnTJn3//fd66623FBERocTERLePgd/zTPePmtF5E8CpGtx5s9LmBcY8c45rh81nuzuWe0BGRoaRY9hJtY/ExETnulu3bjUjRowwLVq0MBEREaZbt25m0qRJzo6ZgwYNMg888ECVfWRnZ5s+ffqYsLAwExcXZyZPnmxOnDhhjDEmLy/PDB061LRp08bY7XbTtWtX88ILL9QY7+mdN6szb948k5KSYpo2bWo6duxonn76aZfXa+u8aYwx27dvN7/85S9NdHS0adasmbnooovMqlWrXLbx+uuvV+noWJOajss999xjevToYcrLy01ZWZn54x//aJKSkkzTpk1NfHy8GTFihPn666+d62/YsMFIMpMnT3Yue/75540kk5WV5bLt5557zsTHx5uIiAgzdOhQ8+abbxpJ5tChQ8YYR+fNmJiYKjEVFhaaq6++2tjtdtOxY0fz5ptvuhyvzMxMc/HFF5vo6GgTGRlpLrnkErNkyZIzHgNvs6Lzps0Y75YwKy4uVkxMjIqKihQdHe3NXQPwQ8ePH1dBQYGSk5MVHh7ewI0VS9MSHP8/ep7U6XLL71SgYZ588kn961//0tdff+3rUFCN2r6Pdb1+0xQCIHicmkQk9iep8CMlJSXatGmTXnzxRU2cONHX4cCDSCwABI+wSOnxIscjzL1RFvCsCRMm6MILL1RqaqruuOMOX4cDD2K4KQDA4zIyMupcxROBjTsWAADAMiQWAADAMiQWAPyClweoAaiGFd9DEgsAPlVZzvjUuRgA+Ebl97AhZcbpvAnAp0JDQ9WiRQvnFNPNmjVzex4GAA1jjNHRo0e1b98+tWjRok5l3GtCYgHA5yrndahMLgD4RosWLZzfx/oisQDgczabTfHx8Wrbtq1OnDjh63CARqlp06YNulNRicQCgN8IDQ215MQGwHfovAkAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACxDYgEAACzjVmLx+OOPy2azuTy6devmqdgAAECAaeLuG3r06KElS5b8bwNN3N4EAAAIUm5nBU2aNFFcXJwnYgEAAAHO7T4W3377rdq3b6+zzz5bo0eP1o4dO2pdv7S0VMXFxS4PAAAQnNxKLC6++GJlZGQoKytLM2fOVEFBgQYOHKjDhw/X+J6pU6cqJibG+UhISGhw0AAAwD/ZjDGmvm/++eeflZiYqOeee0533nlnteuUlpaqtLTU+by4uFgJCQkqKipSdHR0fXcNAAC8qLi4WDExMWe8fjeo52WLFi3UtWtXfffddzWuY7fbZbfbG7IbAAAQIBpUx6KkpETbtm1TfHy8VfEAAIAA5lZi8dBDDyknJ0fbt2/XihUrNGLECIWGhmrUqFGeig8AAAQQt5pCfvzxR40aNUoHDhxQmzZtdOmll+rLL79UmzZtPBUfAAAIIG4lFu+8846n4gAAAEGAuUIAAIBlSCwAAIBlSCwAAIBlSCwAAIBlSCwAP3S07KSSHvlISY98pKNlJ30dDgDUGYkFAACwDIkFAACwDIkFAACwDIkFAACwDIkFAACwDIkFAACwDIkFAACwDIkFAACwDIkFAACwDIkF4IfKK4zz/1cXHHR5DgD+jMQC8DNZmwo15Lkc5/PbZq/RpdM/U9amQh9GBQB1Q2IB+JGsTYUa99Z67S0udVm+p+i4xr21nuQCgN8jsQD8RHmF0RMf5qm6Ro/KZU98mEezCAC/RmIB+InVBQdVWHS8xteNpMKi41pdcNB7QQGAm0gsAD+x73DNSUV91gMAXyCxAPxE2+bhlq4HAL5AYgH4ib7JsYqPCZethtdtkuJjwtU3OdabYQGAW0gsAD8RGmLTlPQUSaqSXFQ+n5KeotCQmlIPAPA9EgvAj6T1jNfMWy5Q22i7y/K4mHDNvOUCpfWM91FkAFA3TXwdAABXaT3jNaBza/V6/BNJUsbtfTSwSxvuVAAICNyxAPzQqUlE3+RYkgoAAYPEAqino2UnlfTIR0p65CMdLTvp63AAwC+QWAAAAMuQWAAAAMuQWAAAAMuQWAAAAMuQWAAAAMuQWAD1dOr05asLDjKdOQCIxAKol6xNhRryXI7z+W2z1+jS6Z8pa1OhD6MCAN+zGWO8+jOruLhYMTExKioqUnR0tDd3DVgia1Ohxr21Xqd/cSpLWFF6G0Awquv1mzsWgBvKK4ye+DCvSlIhybnsiQ/zaBYB0GiRWABuWF1wUIVFx2t83UgqLDqu1QUHvRcUAPgREgvADfsO15xU1Gc9AAg2JBaAG9o2D7d0PQAINiQWgBv6JscqPiZcNc01apMUHxOuvsmx3gwLAPwGiQXghtAQm6akp0hSleSi8vmU9BSmOQfQaJFYAG5K6xmvmbdcoLbRdpflcTHhDDUF0Og18XUAQCBK6xmvAZ1bq9fjn0iSMm7vo4Fd2nCnAkCjxx0LoJ5OTSL6JseSVACASCwAAICFSCwAAIBlSCwAAIBlSCwAAIBlSCwAAIBlGG4K1FOzsCbaPu1qX4cBAH6FOxYAAMAyJBYAAMAyDUospk2bJpvNpkmTJlkUDgAACGT1TizWrFmjWbNmqXfv3lbGAwAAAli9EouSkhKNHj1ar732mlq2bGl1TAAAIEDVK7EYP368rr76ag0ZMuSM65aWlqq4uNjlAQAAgpPbw03feecdrV+/XmvWrKnT+lOnTtUTTzzhdmAAACDwuHXHYufOnXrggQc0Z84chYeH1+k9jz76qIqKipyPnTt31itQAADg/2zGGFPXlT/44AONGDFCoaGhzmXl5eWy2WwKCQlRaWmpy2vVKS4uVkxMjIqKihQdHV3/yAEAgNfU9frtVlPIFVdcoY0bN7osu/3229WtWzdNnjz5jEkFAAAIbm4lFs2bN1fPnj1dlkVGRqpVq1ZVlgMAgMaHypsAAMAyDZ6ELDs724IwAABAMOCOBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBQAAsAyJBdCIHC07qaRHPlLSIx/paNlJX4cDIAiRWACNSHmFcf7/6oKDLs8BwAokFkAjkbWpUEOey3E+v232Gl06/TNlbSr0YVQAgg2JBdAIZG0q1Li31mtvcanL8j1FxzXurfUkFwAsQ2IBBLnyCqMnPsxTdY0elcue+DCPZhEAliCxAILc6oKDKiw6XuPrRlJh0XGtLjjovaAABC0SCyDI7Ttcc1JRn/UAoDYkFkCQa9s83NL1AKA2JBZAkOubHKv4mHDZanjdJik+Jlx9k2O9GRaAIEViAQS50BCbpqSnSFKV5KLy+ZT0FIWG1JR6AEDdkVggqFFp0iGtZ7xm3nKB2kbbXZbHxYRr5i0XKK1nvI8iAxBsmvg6AMCTTq80ObBLm0b7yzytZ7wGdG6tXo9/IknKuL1Poz4eADzDZozx6uD14uJixcTEqKioSNHR0d7cNRqZrE2FmrJws0tRqPiYcE1JT+EXOgC4qa7Xb5pCEJSoNAkAvkFigaBDpUkA8B0SCwQdKk0CgO+QWCDoUGkSAHyHxAJBh0qTAOA7JBYIOlSaBADfIbFA0KHSJAD4DokFghKVJgHAN6i8iaBFpUkA8D4SCwS15uFNtX3a1b4OAwAaDZpCAACAZUgsAACAZUgsAACAZUgsAACAZUgsAACAZUgsAACAZUgsAACAZahjAcAS5RVGqwsOat/h42rb3DEXC8XIgMaHxAJAg2VtKtQTH+apsOh/U9HHx4RrSnoK5dOBRoamEAANkrWpUOPeWu+SVEjSnqLjGvfWemVtKvRRZAB8gcQCQL2VVxg98WGeTDWvVS574sM8lVdUtwaAYERiAaDeVhccrHKn4lRGUmHRca0uOOi9oAD4FIkFgHrbd7jmpKI+6wEIfCQWAOqtbfNwS9cDEPhILADUW9/kWMXHhKumQaU2OUaH9E2O9WZYAHyIxAJ+obzCaOW2A1qQu0srtx2gs1+ACA2xaUp6iiRVSS4qn09JT6GeBdCIUMcCPpe1qVBTFm7W3uJS5zJqIASOtJ7xmnnLBVXqWMTxNwQaJZsxxqs/DYuLixUTE6OioiJFR0d7c9fwQ5U1EE7/EFb+vp15ywVcmAIElTeB4FbX6zd3LOAzZ6qBYJOjBsKVKXFcoAJAaIhN/Tq18nUYAHzMrT4WM2fOVO/evRUdHa3o6Gj169dPH3/8sadiQ5CjBgIABB+3EosOHTpo2rRpWrdundauXavLL79cw4cP1+bNmz0VH4IYNRAAIPi41RSSnp7u8vypp57SzJkz9eWXX6pHjx6WBobgRw0EAAg+9e5jUV5ern/96186cuSI+vXrV+N6paWlKi39X2//4uLi+u4SQaayBsKeouPV9rOwyTGygBoIABA43K5jsXHjRkVFRclut+vee+9VZmamUlJSalx/6tSpiomJcT4SEhIaFDCCBzUQACD4uD3ctKysTDt27FBRUZHmzZunf/zjH8rJyakxuajujkVCQgLDTeGUtamwSg0E6lgAgH+p63DTBtexGDJkiDp16qRZs2ZZGhgaF2ogoCZ8NgD/4LU6FhUVFS53JID6oAYCqsPdLCDwuJVYPProoxo2bJg6duyow4cPa+7cucrOztaiRYs8FR+ARqqmqqx7io5r3FvrqcoK+Cm3Eot9+/ZpzJgxKiwsVExMjHr37q1Fixbpyiuv9FR8ABohqrICgcutxOL111/3VBwA4OROVVaa0AD/wrTpAPwOVVmBwEViAcDvUJUVCFwkFgD8TmVV1pp6T9jkGB1CVVbA/5BYAPA7VGUFAheJBeqsvMJo5bYDWpC7Syu3HVB5RYNqqwG1SusZr5m3XKC4GNfmjriYcIaaAn6swQWy0DhQqAi+kNYzXlemxFF5EwggDS7p7S5KegeemgoVVZ7a+fUIAMGvrtdvmkJQqzMVKpIchYpoFgEASCQWOAN3ChUBAEAfC9SKQkUIZsycCliPxAK1olBRkKkol35YIZXslaLaSYn9pZBQX0dVOw/FTIdkwDNILFCrykJFe4qOV9vPwibH8D8KFQWAvIVS1mSpePf/lkW3l9KmSynX+i6u2ngoZmZOBTyHPhaoFYWKgkTeQum9Ma4XaEkqLnQsz1vom7hq46GY6ZAMeBaJBc6IQkUBrqLc8au/tktp1iOO9fyFB2OmQzLgWTSFoE4oVBTAflhR9Ve/CyMV73KslzzQa2HVyoMx0yEZ8CwSC9RZaIhN/Tq18nUYcFfJXmvX8wYPxkyHZMCzaAoBgl1UO2vX8wYPxszMqYBnkVgAwS6xv2MkRW2X0uizHOv5Cw/GTIdkwLNILIBgFxLqGJ4pqcZLado0/6pn4eGY6ZAMeA6TkAUhqgmiWtXWhDjLcYEOqDoW1sXsqe8K30EEo7pev0ksggzVBFErKm96HN9BBCsSi0aI6c0B3+I7iGDGtOmNDNUEAd/iOwg4kFgECaoJAr7FdxBwILEIElQTBHyL7yDgQGIRJKgmCPgW30HAgcQiSFBNEPAtvoOAA4lFkKCaIOBbfAcBBxKLIEI1QcC3vPEdLK8wWrntgBbk7tLKbQcYZQK/Qx2LIETVP8C3PPUdpPgWfIkCWQAQRCi+BV+jQJaf43YmgLqi+BYCSRNfB9AYcTsTgDvcKb7Vr1Mr7wUGVIM7Fl5WeTvz9JPEnqLjGvfWemVtKvRRZAD8FcW3EEhILLyI25kA6oPiWwgkJBZexFwCAOrDG8W36PcFq9DHwou4nQmgPiqLb417a71skstdTyuKb9HvC1bijoUXcTsTQH15qvgW/b5gNe5YeFHl7cw9Rcer7Wdhk+MkwVwCAKqT1jNeV6bEWVZ860z9vmxy9Pu6MiWOInuoM+5YeBFzCQBoqNAQm/p1aqXh552lfp1aNeh8Qb8veAKJhZcxnwcAf0G/L3gCTSFn4Ima/1bfzgSA+vBWvy/mL2pcSCxq4cme0pW3MwHAV7zR74sRJ40PTSE1oKc0gGDn6X5fnEcbJxKLalAhE0Bj4al+X5xHGy+aQqrBhD8AGhNP9PviPNp4kVhUg57SABobq/t9cR5tvEgsqkGFTABoGG+cRxlt4p9ILKpBhUz4XEW59MMKqWSvFNVOSuwvhYT6Oqrgw3H2GE+fRxlt4r9ILKrh6Ql/gFrlLZSyJkvFu/+3LLq9lDZdSrnWd3EFG46zR3nyPFo52uT0hKVytAnFBn2LUSE1oEImfCJvofTeGNeLnSQVFzqW5y30TVzBhuPsFZ44jzLaxP/ZjDFePfrFxcWKiYlRUVGRoqOjLdmmJ9vZaMOD11SUSzN6Vr3YOdkcv6gnbeR2fUNwnL3OyvPoym0HNOq1L8+43tt3X8JoE4vV9frtVlPI1KlT9f777+ubb75RRESE+vfvr+nTp+ucc85pcMD15el2Nipkwmt+WFHLxU6SjFS8y7Fe8kCvhRV0OM5eZ+V5lNEm/s+tppCcnByNHz9eX375pRYvXqwTJ07oqquu0pEjRzwVX62o6oagUrLX2vVQPY5zQGPUnv9z645FVlaWy/OMjAy1bdtW69at02WXXWZpYGdypnY2mxztbFemxNF0gcAQ1c7a9VA9jnNA89aoPZrB669Bo0KKiookSbGxNf8BS0tLVVpa6nxeXFzckF06UdUNQSexv6Ntv7hQqumUGd3esR7qj+Mc0Lwxao+hrA1T71EhFRUVmjRpkgYMGKCePXvWuN7UqVMVExPjfCQkJNR3ly5oZ0PQCQl1DHWUVOOUUGnT6FDYUBzngOfJUXs0sTdcvUeFjBs3Th9//LG++OILdejQocb1qrtjkZCQ0OBRIfQMRtCqtr7CWY6LHfUVrMNxDnhWN1eUVxhdOv2zGu+GVzazfDH58kbZLOKRUSGVJkyYoH//+99atmxZrUmFJNntdtnt9vrsplZUx0TQSrlW6nY1FSE9jeMc8KwetUcTuzXcSiyMMZo4caIyMzOVnZ2t5ORkT8V1RlTHRFALCWWoozdwnHEKbzWxB3vHULcSi/Hjx2vu3LlasGCBmjdvrj179kiSYmJiFBER4ZEAa1PZznZ6J5s4OtkAANzkjaGsjaFjqFt9LGy26jOq2bNn67bbbqvTNgKt8iYAoHGo7GNxpib2+vaxqGmOk8ot+ft0ER7pY+Hl6t91RnVMAEBDebKJvTHVXmISMgAA/stTQ1nd6Rga6Jg2HQCAU6T1jNeVKXGWNrE3ptpLJBYAAJzG6iZ2b3QM9Zf+hiQWAAB4mKdrL/nTaBP6WAAA4GGVHUOlGgvJ17tjqL+VISexAADACzzRMfRMo00kx2iT8grvjeqkKQQAAC+xumOoP5YhJ7EA6quinHkmUD0+G6iFlR1D/XG0CYkFUB/VzozZ3jEdNzNjNm58NuBF3hht4i76WADuylsovTfG9cIhScWFjuV5C30TF3yPzwa8rHK0SU0NKTY5Rod4c6ZvEgvAHRXljl+jtXWVynrEsR4aFz4b8AFPjjapLxILwB0/rKj6a9SFkYp3OdZD48JnAz7iqTLk9UUfC8AdJXutXQ/Bg88GfMgTZcjri8QCcEdUO2vXQ/DgswEf85eZvmkKAdyR2N/Rw7+2rlLRZznWQ+PCZwOQRGIBuCck1DFsUFKNXaXSplGzoDHiswFIIrEA3JdyrXTjm1L0aR2iots7llOroPHiswHIZozxXgFxScXFxYqJiVFRUZGio6O9uWvAWlRXRE34bCAI1fX6TedNoL5CQqXkgb6OAv6IzwYaMZpCAACAZUgsAACAZUgsAACAZUgsAACAZei8ieBG73wEGz7T8HMkFgheeQsds02eOjFUdHtHESPqCSAQ8ZlGAKApBMEpb6H03piqs00WFzqW5y30TVxAffGZRoAgsUDwqSh3/KpTdbXf/rss6xHHekAg4DONAEJigeDzw4qqv+pcGKl4l2M9IBDwmUYAIbFA8CnZa+16gK/xmUYAIbFA8IlqZ+16gK/xmUYAIbFA8Ens7+gpX2Xq6ko2Kfosx3pAIOAzjQBCYoHgExLqGH4nqeqJ+L/P06Yx9h+Bg880AgiJBYJTyrXSjW9K0fGuy6PbO5Yz5h+Bhs80AoTNGFPd+CWPqet87oAlqFKIYMNnGj5S1+s3lTcR3EJCpeSBvo4CsA6fafg5Egv4B36FAb7FdxAWIbGA7zH/AeBbfAdhITpvwreY/wDwLb6DsBiJBXyH+Q8A3+I7CA8gsYDvMP8B4Ft8B+EBJBbwHeY/AHyL7yA8gMQCvsP8B4Bv8R2EB5BYwHeY/wDwLb6D8AASC/gO8x8AvsV3EB5AYgHfYv4DwLf4DsJizBWCuvNkZT6q/gG+xfcbZ8BcIbCWpyvzMf8B4Fue+g5S1bPRoSkEZ0ZlPgD1wbmjUSKxQO2ozAegPjh3NFokFqgdlfkA1AfnjkaLxAK1ozIfgPrg3NFokVigdlTmA1AfnDsaLbcTi2XLlik9PV3t27eXzWbTBx984IGw4DeozAegPjh3NFpuJxZHjhzRueeeq5deeskT8cAKFeVSwefSxnmO/zakcxSV+QDUhzfOHVae62AZt+tYDBs2TMOGDfNELLCCJ8aMV1bmq3a70xiLDqB6njx3UB/DbzWo8qbNZlNmZqauu+66Or+HypseVDlmvMrwrv/+OmhoeV6q5wGoD6vPHZ4+16FaflN5s7S0VKWlpS6BwQPOOGbc5hgz3u3q+n+hqY4JoD6sPHd441yHBvH4qJCpU6cqJibG+UhISPD0LhsnxowDaAw41/k9jycWjz76qIqKipyPnTt3enqXjRNjxgE0Bpzr/J7Hm0LsdrvsdrundwPGjANoDDjX+T23E4uSkhJ99913zucFBQXKzc1VbGysOnbsaGlwQc3qzkyVY8aLC1V926PN8TpjxgEEMm+d6+isXm9uJxZr167V4MGDnc8ffPBBSdLYsWOVkZFhWWBBzRPDpCrHjL83Ro6e0ad+4ag3ASBIeONcx1DWBmnQcNP6aPTDTT09TKraL8RZ1JsAEFw8da5jKGuN6nr9JrHwpopyaUbPWno0//cW3qSNDa9Gxy08AMHO6nOdt87RAcpv6ljgFO4Mk2rImG/qTQBoDKw+13nrHB3kmN3UmxgmBQD+i3O0JbhjcSZW3mpjmBQA+C9vnaODvLmaxKI2VvcMZkgoAPgvb5yjG8GIE5pCalLZM/j09rbiQsfyvIXub5MpyAHAf3n6HO2J64ofIrGozhknuZFjkpuKcve3XTmNcHS86/Lo9o16GBMA+AVPnaM9eV3xMzSFVMfTPYNTrnXMvBfEbWwAELA8cY5uRCNOgiOxsLojjDd6BjMkFAD8l9XnaG9cV/ykU2jgJxae6AjD6A0AgJU8fV3xo06hgd3HwlMdYSp7BlfpvFPJ5igdy+gNAEBdePK64medQgM3sfBkRxhGbwAArOSp64ofdgoN3MTCnY4w9cHoDQCAlTxxXfH0tbAeArePhTc6wjB6AwBgJauvK35YhjxwEwtvdbBk9AYAwEpWXlf8cLBB4DaF0MESANDY+eG1MHATCzpYAgAaOz+8FgZuYiHRwRIAAD+7FtqMMdWNUfGY4uJixcTEqKioSNHR0dZs1E+qjQEA4DMevhbW9foduJ03T0UHSwBAY+cn18LAbgoBAAB+hcQCAABYhsQCAABYhsQCAABYhsQCAABYhsQCAABYhsQCAABYhsQCAABYhsQCAABYxuuVNysriBcXF3t71wAAoJ4qr9tnmgnE64nF4cOHJUkJCQne3jUAAGigw4cPKyYmpsbXvT4JWUVFhXbv3q3mzZvLZqtp/njPKS4uVkJCgnbu3GndJGhBhONTO45P7Tg+NePY1I7jUzt/OD7GGB0+fFjt27dXSEjNPSm8fsciJCREHTp08PZuq4iOjubDWwuOT+04PrXj+NSMY1M7jk/tfH18artTUYnOmwAAwDIkFgAAwDKNLrGw2+2aMmWK7Ha7r0PxSxyf2nF8asfxqRnHpnYcn9oF0vHxeudNAAAQvBrdHQsAAOA5JBYAAMAyJBYAAMAyJBYAAMAyjT6xuPbaa9WxY0eFh4crPj5et956q3bv3u3rsHxu+/btuvPOO5WcnKyIiAh16tRJU6ZMUVlZma9D8xtPPfWU+vfvr2bNmqlFixa+DsfnXnrpJSUlJSk8PFwXX3yxVq9e7euQ/MKyZcuUnp6u9u3by2az6YMPPvB1SH5l6tSp6tOnj5o3b662bdvquuuu05YtW3wdlt+YOXOmevfu7SyM1a9fP3388ce+DqtWjT6xGDx4sN577z1t2bJF8+fP17Zt23TDDTf4Oiyf++abb1RRUaFZs2Zp8+bNev755/XKK6/oscce83VofqOsrEwjR47UuHHjfB2Kz7377rt68MEHNWXKFK1fv17nnnuuhg4dqn379vk6NJ87cuSIzj33XL300ku+DsUv5eTkaPz48fryyy+1ePFinThxQldddZWOHDni69D8QocOHTRt2jStW7dOa9eu1eWXX67hw4dr8+bNvg6tZgYuFixYYGw2mykrK/N1KH7nr3/9q0lOTvZ1GH5n9uzZJiYmxtdh+FTfvn3N+PHjnc/Ly8tN+/btzdSpU30Ylf+RZDIzM30dhl/bt2+fkWRycnJ8HYrfatmypfnHP/7h6zBq1OjvWJzq4MGDmjNnjvr376+mTZv6Ohy/U1RUpNjYWF+HAT9TVlamdevWaciQIc5lISEhGjJkiFauXOnDyBCIioqKJIlzTTXKy8v1zjvv6MiRI+rXr5+vw6kRiYWkyZMnKzIyUq1atdKOHTu0YMECX4fkd7777ju98MILuueee3wdCvzMTz/9pPLycrVr185lebt27bRnzx4fRYVAVFFRoUmTJmnAgAHq2bOnr8PxGxs3blRUVJTsdrvuvfdeZWZmKiUlxddh1SgoE4tHHnlENput1sc333zjXP/hhx/Whg0b9Mknnyg0NFRjxoyRCdKCpO4eG0natWuX0tLSNHLkSN19990+itw76nN8AFhj/Pjx2rRpk9555x1fh+JXzjnnHOXm5mrVqlUaN26cxo4dq7y8PF+HVaOgLOm9f/9+HThwoNZ1zj77bIWFhVVZ/uOPPyohIUErVqzw61tN9eXusdm9e7dSU1N1ySWXKCMjQyEhQZmLOtXns5ORkaFJkybp559/9nB0/qmsrEzNmjXTvHnzdN111zmXjx07Vj///DN3AE9hs9mUmZnpcpzgMGHCBC1YsEDLli1TcnKyr8Pxa0OGDFGnTp00a9YsX4dSrSa+DsAT2rRpozZt2tTrvRUVFZKk0tJSK0PyG+4cm127dmnw4MG68MILNXv27KBPKqSGfXYaq7CwMF144YX69NNPnRfMiooKffrpp5owYYJvg4PfM8Zo4sSJyszMVHZ2NklFHVRUVPj1NSooE4u6WrVqldasWaNLL71ULVu21LZt2/SHP/xBnTp1Csq7Fe7YtWuXUlNTlZiYqGeeeUb79+93vhYXF+fDyPzHjh07dPDgQe3YsUPl5eXKzc2VJHXu3FlRUVG+Dc7LHnzwQY0dO1YXXXSR+vbtqxkzZujIkSO6/fbbfR2az5WUlOi7775zPi8oKFBubq5iY2PVsWNHH0bmH8aPH6+5c+dqwYIFat68ubNfTkxMjCIiInwcne89+uijGjZsmDp27KjDhw9r7ty5ys7O1qJFi3wdWs18OyjFt77++mszePBgExsba+x2u0lKSjL33nuv+fHHH30dms/Nnj3bSKr2AYexY8dWe3yWLl3q69B84oUXXjAdO3Y0YWFhpm/fvubLL7/0dUh+YenSpdV+TsaOHevr0PxCTeeZ2bNn+zo0v3DHHXeYxMREExYWZtq0aWOuuOIK88knn/g6rFoFZR8LAADgG8HfaA4AALyGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFiGxAIAAFjm/wOgJIjg9QknTAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(obs_linspace * np.pi, mean_reward * np.log10(np.e), yerr=std_reward * np.log10(np.e), fmt=\"o\", label='Evaluated Policy Rewards')\n", + "plt.errorbar(obs_linspace * np.pi, zeros_mean_reward * np.log10(np.e), yerr=zeros_std_reward * np.log10(np.e), fmt=\"o\", label='Zeros Policy Rewards')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1e-06\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "updates = np.arange(800)\n", + "\n", + "init_lr = 3e-5\n", + "exp_time = 100\n", + "plateau_lr = 1e-6\n", + "\n", + "num_anneal_updates = 400\n", + "frac = 1.0 - (updates - 1.0) / num_anneal_updates\n", + "lr = np.clip(frac, a_min=0., a_max=None) * init_lr + plateau_lr\n", + "\n", + "exp_lr = init_lr * np.exp(-updates / exp_time) + plateau_lr\n", + "\n", + "print(lr[-1])\n", + "\n", + "plt.plot(updates, lr, label='Linear Learning Rate')\n", + "plt.plot(updates, exp_lr, label='Exp Learning Rate')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Nearly 3 9s all over ###\n", + "\n", + "# agent_config = {\n", + "# \"exp_name\": \"Test PPO CleanRL\",\n", + "# \"seed\": 1,\n", + "# \"torch_deterministic\": True,\n", + "# \"cuda\": False,\n", + "# \"track\": False,\n", + "# \"wandb_project_name\": \"Context Aware Calibrations\",\n", + "# \"wandb_entity\": None,\n", + "# \"save_model\": True,\n", + "# \"plot_real_time\": True,\n", + "# \"num_prints\": 5,\n", + "# \"total_updates\": 600,\n", + "# \"learning_rate\": 3e-5,\n", + "# \"num_envs\": 32,\n", + "# \"num_steps\": 1,\n", + "# \"anneal_lr\": True,\n", + "# \"anneal_num_updates\": 400,\n", + "# \"exp_anneal_lr\": False,\n", + "# \"exp_update_time\": 100,\n", + "# \"plateau_lr\": 1e-6,\n", + "# \"gamma\": 0.99,\n", + "# \"gae_lambda\": 0.95,\n", + "# \"num_minibatches\": 4,\n", + "# \"update_epochs\": 8,\n", + "# \"norm_adv\": True,\n", + "# \"activation_function_str\": \"tanh\",\n", + "# \"use_combined_networks\": True,\n", + "# \"layer_size\": 64,\n", + "# \"clip_coef\": 0.2,\n", + "# \"clip_vloss\": True,\n", + "# \"ent_coef\": 0.,\n", + "# \"vf_coef\": 0.5,\n", + "# \"max_grad_norm\": 0.5,\n", + "# \"target_kl\": None\n", + "# }" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "new_context_env", + "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.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/rl_qoc/base_parametrised_q_env.py b/rl_qoc/base_parametrised_q_env.py new file mode 100644 index 0000000..c79ebbf --- /dev/null +++ b/rl_qoc/base_parametrised_q_env.py @@ -0,0 +1,1541 @@ +""" +Class to generate a RL environment suitable for usage with PyTorch, leveraging Qiskit modules to simulate +quantum system (could also include QUA code in the future) + +Author: Arthur Strauss +Created on 28/11/2022 +Last updated: 16/02/2024 +""" + +from __future__ import annotations +from abc import ABC, abstractmethod + +# For compatibility for options formatting between Estimators. +import json +import signal +from dataclasses import asdict, dataclass +from itertools import product +from typing import Optional, List, Callable, Any, Tuple + +from gymnasium import Env +import numpy as np +from gymnasium.core import ObsType +from gymnasium.spaces import Box +from qiskit import schedule, transpile, QiskitError + +# Qiskit imports +from qiskit.circuit import ( + QuantumCircuit, + QuantumRegister, + Gate, + ParameterVector, +) + +# Qiskit Estimator Primitives: for computing Pauli expectation value sampling easily +from qiskit.primitives import ( + BaseEstimatorV1, + BaseEstimatorV2, + BaseSamplerV2, + BaseSamplerV1, +) +from qiskit.quantum_info import Clifford, random_clifford + +# Qiskit Quantum Information, for fidelity benchmarking +from qiskit.quantum_info.operators import SparsePauliOp, Operator, pauli_basis +from qiskit.quantum_info.states import DensityMatrix, Statevector +from qiskit.transpiler import ( + Layout, + InstructionProperties, + CouplingMap, + InstructionDurations, +) +from qiskit_algorithms.state_fidelities import ComputeUncompute +from qiskit.providers import BackendV2 + +# Qiskit dynamics for pulse simulation (& benchmarking) +from qiskit_dynamics import DynamicsBackend +from qiskit_experiments.library import InterleavedRB + +# Qiskit Experiments for generating reliable baseline for complex gate calibrations / state preparations +from qiskit_experiments.library.tomography.basis import ( + PauliPreparationBasis, + Pauli6PreparationBasis, +) +from qiskit_ibm_runtime import ( + EstimatorV1 as RuntimeEstimatorV1, + EstimatorV2 as RuntimeEstimatorV2, + SamplerV1 as RuntimeSamplerV1, + IBMBackend, +) + +from rl_qoc.helper_functions import ( + retrieve_primitives, + handle_session, + simulate_pulse_schedule, + retrieve_neighbor_qubits, + substitute_target_gate, + get_hardware_runtime_single_circuit, +) +from rl_qoc.qconfig import ( + QiskitConfig, + QEnvConfig, + CAFEConfig, + ChannelConfig, + ORBITConfig, + XEBConfig, +) + + +def _calculate_chi_target(target: DensityMatrix | Operator | QuantumCircuit | Gate): + """ + Calculate characteristic function for the given target. Based on DFE scheme + :param target: Density matrix of the target state or Operator of the target gate + :return: Characteristic function of the target state + """ + + if not isinstance(target, (DensityMatrix, Operator)): + try: # Try to convert to Operator (in case Gate or QuantumCircuit is provided) + target = Operator(target) + except Exception as e: + raise ValueError( + "Target should be a DensityMatrix or an Operator (Gate or QuantumCircuit) object" + ) from e + d = 2**target.num_qubits + basis = pauli_basis(num_qubits=target.num_qubits) + if isinstance(target, DensityMatrix): + chi = np.real( + [target.expectation_value(basis[k]) for k in range(d**2)] + ) / np.sqrt(d) + else: + dms = [DensityMatrix(pauli).evolve(target) for pauli in basis] + chi = ( + np.real( + [ + dms[k_].expectation_value(basis[k]) + for k, k_ in product(range(d**2), repeat=2) + ] + ) + / d + ) + # Real part is taken to convert it in good format, + # but imaginary part is always 0. as dm is hermitian and Pauli is traceless + return chi + + +@dataclass +class BaseTarget(ABC): + """ + Base class for the target of the quantum environment + """ + + def __init__( + self, + physical_qubits: int | List[int], + target_type: str, + tgt_register: Optional[QuantumRegister] = None, + layout: Optional[List[Layout]] = None, + ): + self.physical_qubits = ( + list(range(physical_qubits)) + if isinstance(physical_qubits, int) + else physical_qubits + ) + self.target_type = target_type + self._tgt_register = ( + QuantumRegister(len(self.physical_qubits), "tgt") + if tgt_register is None + else tgt_register + ) + self._layout: List[Layout] = ( + [ + Layout( + { + self._tgt_register[i]: self.physical_qubits[i] + for i in range(len(self.physical_qubits)) + } + ) + ] + if layout is None + else layout + ) + self._n_qubits = len(self.physical_qubits) + + @property + def tgt_register(self): + return self._tgt_register + + @property + def layout(self) -> List[Layout]: + return self._layout + + @layout.setter + def layout(self, layout: List[Layout] | Layout): + if isinstance(layout, Layout): + layout = [layout] + self._layout = layout + + @property + def n_qubits(self): + return self._n_qubits + + @n_qubits.setter + def n_qubits(self, n_qubits: int): + self._n_qubits = n_qubits + + +class StateTarget(BaseTarget): + """ + Class to represent the state target for the quantum environment + """ + + def __init__( + self, + dm: Optional[DensityMatrix] = None, + circuit: Optional[QuantumCircuit] = None, + physical_qubits: Optional[List[int]] = None, + ): + + if dm is None and circuit is None: + raise ValueError("No target provided") + if dm is not None and circuit is not None: + assert ( + DensityMatrix(circuit) == dm + ), "Provided circuit does not generate the provided density matrix" + self.dm = DensityMatrix(circuit) if dm is None else dm + self.circuit = circuit if isinstance(circuit, QuantumCircuit) else None + self.Chi = _calculate_chi_target(self.dm) + super().__init__( + self.dm.num_qubits if physical_qubits is None else physical_qubits, "state" + ) + + +class InputState(StateTarget): + """ + Class to represent the input state for the quantum environment + """ + + def __init__( + self, + input_circuit: QuantumCircuit, + target_op: Gate | QuantumCircuit, + tgt_register: QuantumRegister, + n_reps: int = 1, + ): + """ + Initialize the input state for the quantum environment + :param input_circuit: Quantum circuit representing the input state + :param target_op: Gate to be calibrated + :param tgt_register: Quantum register for the target gate + :param n_reps: Number of repetitions of the target gate + """ + + if isinstance(target_op, Gate): + circ = QuantumCircuit(tgt_register) + else: + circ = target_op.copy_empty_like() + + circ.compose(input_circuit, inplace=True) + super().__init__(circuit=input_circuit) + for _ in range(n_reps): + if isinstance(target_op, Gate): + circ.append(target_op, tgt_register) + else: + for instr in target_op.data: + circ.append(instr) + # circ.compose(target_op, inplace=True) + self.target_state = StateTarget(circuit=circ) + + @property + def layout(self): + raise AttributeError("Input state does not have a layout") + + @layout.setter + def layout(self, layout: List[Layout] | Layout): + raise AttributeError("Input state does not have a layout") + + @property + def tgt_register(self): + raise AttributeError("Input state does not have a target register") + + +class GateTarget(BaseTarget): + """ + Class to represent the gate target for the quantum environment + """ + + def __init__( + self, + gate: Gate, + physical_qubits: Optional[List[int]] = None, + n_reps: int = 1, + target_op: Optional[Gate | QuantumCircuit | List[QuantumCircuit]] = None, + tgt_register: Optional[QuantumRegister] = None, + layout: Optional[List[Layout]] = None, + ): + """ + Initialize the gate target for the quantum environment + :param gate: Gate to be calibrated + :param physical_qubits: Physical qubits forming the target gate + :param n_reps: Number of repetitions of the target gate / circuit + :param target_op: Element to be repeated in the calibration (default is the gate to be calibrated) + :param tgt_register: Specify target QuantumRegister if already declared + :param layout: Specify layout or list of layouts if already declared + """ + self.gate = gate + if target_op is not None: + if not isinstance(target_op, List): + target_op = [target_op] + if not all([isinstance(op, (QuantumCircuit, Gate)) for op in target_op]): + raise ValueError( + "target_op should be either Gate or QuantumCircuit, or a list of them" + ) + + else: + target_op = [gate] + self.target_op = target_op + self.n_reps = n_reps + super().__init__( + gate.num_qubits if physical_qubits is None else physical_qubits, + "gate", + tgt_register, + layout, + ) + input_circuits = [ + [ + PauliPreparationBasis().circuit(s) + for s in product(range(4), repeat=op.num_qubits) + ] + for op in self.target_op + ] + input_states = [ + [ + InputState( + input_circuit=circ, + target_op=op, + tgt_register=self.tgt_register, + n_reps=n_reps, + ) + for circ in input_circuits_list + ] + for op, input_circuits_list in zip(self.target_op, input_circuits) + ] + self.input_states = input_states + self.Chi = _calculate_chi_target(Operator(gate).power(n_reps)) + + +class QiskitBackendInfo: + """ + Class to store information on Qiskit backend (can also generate some dummy information for the case of no backend) + """ + + def __init__( + self, + backend: Optional[BackendV2] = None, + custom_instruction_durations: Optional[InstructionDurations] = None, + ): + if backend is not None and backend.coupling_map is None: + raise QiskitError("Backend does not have a coupling map") + self.backend = backend + self._instruction_durations = custom_instruction_durations + + def custom_transpile( + self, + qc: QuantumCircuit | List[QuantumCircuit], + initial_layout: Optional[Layout] = None, + scheduling: bool = True, + optimization_level: int = 0, + remove_final_measurements: bool = True, + ): + """ + Custom transpile function to transpile the quantum circuit + """ + if self.backend is None and self.instruction_durations is None and scheduling: + raise QiskitError( + "Backend or instruction durations should be provided for scheduling" + ) + if remove_final_measurements: + if isinstance(qc, QuantumCircuit): + circuit = qc.remove_final_measurements(inplace=False) + else: + circuit = [circ.remove_final_measurements(inplace=False) for circ in qc] + else: + circuit = qc + return transpile( + circuit, + backend=self.backend, + scheduling_method=( + "asap" + if self.instruction_durations is not None and scheduling + else None + ), + basis_gates=self.basis_gates, + coupling_map=(self.coupling_map if self.coupling_map.size() != 0 else None), + instruction_durations=self.instruction_durations, + optimization_level=optimization_level, + initial_layout=initial_layout, + dt=self.dt, + ) + + @property + def coupling_map(self): + """ + Retrieve the coupling map of the backend (default is fully connected if backend is None) + """ + return ( + self.backend.coupling_map + if self.backend is not None + else CouplingMap.from_full(5) + ) + + @property + def basis_gates(self): + """ + Retrieve the basis gates of the backend (default is ['x', 'sx', 'cx', 'rz', 'measure', 'reset']) + """ + return ( + self.backend.operation_names + if self.backend is not None + else ["x", "sx", "cx", "rz", "measure", "reset"] + ) + + @property + def dt(self): + """ + Retrieve the time unit of the backend (default is 1e-9) + """ + return self.backend.dt if self.backend is not None else 1e-9 + + @property + def instruction_durations(self): + """ + Retrieve the instruction durations of the backend (default is None) + """ + return ( + self.backend.instruction_durations + if self.backend is not None + and self.backend.instruction_durations.duration_by_name_qubits + else self._instruction_durations + ) + + +class BaseParametrisedQuantumEnvironment(ABC, Env): + metadata = {"render_modes": ["human"]} + + def __init__(self, training_config: QEnvConfig): + """ + Initialize the quantum environment + Args: + training_config: QEnvConfig object containing the training configuration + """ + self.extract_from_config(training_config) + + self._mean_action = np.zeros(self.action_space.shape[-1]) + self._std_action = np.ones(self.action_space.shape[-1]) + # Data storage + self._optimal_action = np.zeros(self.action_space.shape[-1]) + self._seed = training_config.seed + self._session_counts = 0 + self._step_tracker = 0 + self._inside_trunc_tracker = 0 + self._total_shots = [] + self._hardware_runtime = [] + self._max_return = 0 + self._episode_ended = False + self._episode_tracker = 0 + self._benchmark_cycle = training_config.benchmark_cycle + self.action_history = [] + self.density_matrix_history = [] + self.reward_history = [] + self.rl_reward_history = [] + self.qc_history = [] + self._pubs, self._ideal_pubs = [], [] + self._observables, self._pauli_shots = None, None + self._index_input_state = 0 + signal.signal(signal.SIGINT, self.signal_handler) + signal.signal(signal.SIGTERM, self.signal_handler) + + if isinstance(self.target, GateTarget): + self._input_state = self.target.input_states[self.trunc_index][ + self._index_input_state + ] + self.process_fidelity_history = [] + self.avg_fidelity_history = [] + + else: + self.state_fidelity_history = [] + + def extract_from_config(self, training_config): + self._training_config = training_config + self._reward_methods = { + "channel": self.channel_reward_pubs, + "state": self.state_reward_pubs, + "cafe": self.cafe_reward_pubs, + "xeb": self.xeb_reward_pubs, + "orbit": self.orbit_reward_pubs, + "fidelity": self.compute_benchmarks, + } + if self.config.reward_method not in self._reward_methods: + raise ValueError( + f"Reward method {self.config.reward_method} not implemented. Only " + f"{list(self._reward_methods.keys())} are supported." + ) + self.n_shots = training_config.n_shots + self.n_reps = training_config.n_reps + self.sampling_Pauli_space = training_config.sampling_paulis + self.c_factor = training_config.c_factor + self.batch_size = training_config.batch_size + + self.training_with_cal = training_config.training_with_cal + + self.action_space: Box = training_config.action_space + + self.parametrized_circuit_func: Callable = training_config.parametrized_circuit + self._func_args = training_config.parametrized_circuit_kwargs + self.backend = training_config.backend + self.backend_info = QiskitBackendInfo( + self.backend, training_config.backend_config.instruction_durations_dict + ) + self._physical_target_qubits = training_config.target.get( + "physical_qubits", None + ) + + # gate = training_config.target.get("gate", None) + # gate_name_base = gate.name if gate is not None else "G" + # gate_name_base += "_cal" + # self.custom_gates = [] + # for param_vec in self.parameters: + # if not isinstance(param_vec, ParameterVector): + # self.custom_gates.append( + # Gate( + # gate_name_base + str(0), + # len(self.physical_target_qubits), + # params=self.parameters.params, + # ) + # ) + # break + # else: + # self.custom_gates.append( + # Gate( + # gate_name_base + param_vec.name[-1], + # len(self.physical_target_qubits), + # params=param_vec.params, + # ) + # ) + # if self.backend is not None: + # for custom_gate in self.custom_gates: + # if custom_gate.name not in self.backend.operation_names: + # self.backend.target.add_instruction( + # custom_gate, + # properties={ + # tuple(self.physical_target_qubits): InstructionProperties() + # }, + # ) + + self._physical_neighbor_qubits = retrieve_neighbor_qubits( + self.backend_info.coupling_map, self.physical_target_qubits + ) + self._physical_next_neighbor_qubits = retrieve_neighbor_qubits( + self.backend_info.coupling_map, + self.physical_target_qubits + self.physical_neighbor_qubits, + ) + if isinstance(training_config.backend_config, QiskitConfig): + estimator_options = training_config.backend_config.estimator_options + else: + estimator_options = None + + self.target, self.circuits, self.baseline_circuits = ( + self.define_target_and_circuits() + ) + self.abstraction_level = "pulse" if self.circuits[0].calibrations else "circuit" + self._estimator, self._sampler = retrieve_primitives( + self.backend, + self.config.backend_config, + estimator_options, + self.circuits[0], + ) + if not isinstance(self.sampler, BaseSamplerV1): + if hasattr(self.estimator, "session"): + self.fidelity_checker = ComputeUncompute( + RuntimeSamplerV1(session=self.estimator.session) + ) + else: + # TODO: Account for BackendSampler vs AerSampler + self.fidelity_checker = None + else: + self.fidelity_checker = ComputeUncompute(self._sampler) + + @abstractmethod + def define_target_and_circuits( + self, + ) -> tuple[BaseTarget, List[QuantumCircuit], List[QuantumCircuit]]: + raise NotImplementedError("Define target method not implemented") + + @abstractmethod + def episode_length(self, global_step: int) -> int: + """ + Args: + global_step: Step in the training loop + + Returns: Episode length + + """ + pass + + @abstractmethod + def _get_obs(self): + pass + + @abstractmethod + def compute_benchmarks(self, qc: QuantumCircuit, params: np.array) -> np.array: + """ + Benchmark through tomography the fidelity of the quantum system + Args: + qc: Quantum circuit to benchmark + params: + + Returns: + + """ + + def perform_action(self, actions: np.array): + """ + Send the action batch to the quantum system and retrieve the reward + :param actions: action vectors to execute on quantum system + :return: Reward table (reward for each action in the batch) + """ + + trunc_index = self._inside_trunc_tracker + qc = self.circuits[ + trunc_index + ].copy() # TODO: self.circuits needs to be updated + input_state_circ = None + params, batch_size = np.array(actions), actions.shape[0] + if batch_size != self.batch_size: + raise ValueError(f"Batch size mismatch: {batch_size} != {self.batch_size} ") + + # Get the reward method from the configuration + reward_method = self.config.reward_method + if self.do_benchmark(): # Benchmarking or fidelity access + fids = self.compute_benchmarks(qc, params) + if reward_method == "fidelity": + self._total_shots.append(0) + self._hardware_runtime.append(0.0) + return fids + + # Check if the reward method exists in the dictionary + self._pubs, total_shots = self._reward_methods[reward_method](qc, params) + self._total_shots.append(total_shots) + if self.backend_info.instruction_durations is not None: + self._hardware_runtime.append( + get_hardware_runtime_single_circuit( + qc, + self.backend_info.instruction_durations.duration_by_name_qubits, + ) + * self.total_shots[-1] + ) + print("Hardware runtime taken:", sum(self.hardware_runtime)) + + counts = ( + self._session_counts + if isinstance(self.estimator, (RuntimeEstimatorV1, RuntimeEstimatorV2)) + else trunc_index + ) + self.estimator = handle_session( + self.estimator, self.backend, counts, qc, input_state_circ + ) + print( + f"Sending {'Estimator' if isinstance(self.primitive, BaseEstimatorV2) else 'Sampler'} job..." + ) + if isinstance(self.estimator, BaseEstimatorV1): + # TODO: Remove V1 support (once pulse support for V2 is added) + reward_table = self.run_v1_primitive(qc, params) + else: # EstimatorV2 + job = self.primitive.run(pubs=self._pubs) + pub_results = job.result() + + if self.config.dfe: + reward_table = np.sum( + [pub_result.data.evs for pub_result in pub_results], axis=0 + ) / len(self._observables) + else: + pub_counts = [ + [pub_result.data.meas.get_counts(i) for i in range(self.batch_size)] + for pub_result in pub_results + ] + if self.config.reward_method == "xeb": + # TODO: Implement XEB reward computation using Sampler + reward_table = np.zeros(self.batch_size) + raise NotImplementedError( + "XEB reward computation not implemented yet" + ) + else: + survival_probability = [ + [ + count.get("0" * qc.num_qubits, 0) / self.n_shots + for count in counts + ] + for counts in pub_counts + ] + reward_table = np.mean(survival_probability, axis=0) + + print( + f"Finished {'Estimator' if isinstance(self.primitive, BaseEstimatorV2) else 'Sampler'} job" + ) + + return reward_table # Shape [batchsize] + + def reset( + self, + *, + seed: int | None = None, + options: dict[str, Any] | None = None, + ) -> tuple[ObsType, dict[str, Any]]: + """ + Reset the environment to its initial state + :param seed: Seed for random number generator + :param options: Options for the reset + :return: Initial observation + """ + super().reset(seed=seed) + self._episode_tracker += 1 + self._episode_ended = False + + if isinstance(self.estimator, RuntimeEstimatorV2): + self.estimator.options.update(job_tags=[f"rl_qoc_step{self._step_tracker}"]) + + target_state = None + if isinstance(self.target, GateTarget): + if self.config.reward_method == "state": + input_states = self.target.input_states[self.trunc_index] + self._index_input_state = np.random.randint(len(input_states)) + self._input_state = input_states[self._index_input_state] + target_state = self._input_state.target_state # (Gate |input>=|target>) + + else: # State preparation task + target_state = self.target + + if target_state is not None: + self._observables, self._pauli_shots = self.retrieve_observables( + target_state, self.circuits[self.trunc_index] + ) + + return self._get_obs(), self._get_info() + + def retrieve_observables( + self, + target_state: StateTarget, + qc: QuantumCircuit, + dfe_tuple: Optional[Tuple[float, float]] = None, + ): + """ + Retrieve observables to sample for the DFE protocol (PhysRevLett.106.230501) for given target state + + :param target_state: Target state to prepare + :param qc: Quantum circuit to be executed on quantum system + :param dfe_tuple: Optional Tuple (Ɛ, δ) from DFE paper + :return: Observables to sample, number of shots for each observable + """ + # Direct fidelity estimation protocol (https://doi.org/10.1103/PhysRevLett.106.230501) + probabilities = target_state.Chi**2 + full_basis = pauli_basis(qc.num_qubits) + if not np.isclose(np.sum(probabilities), 1, atol=1e-5): + print("probabilities sum um to", np.sum(probabilities)) + print("probabilities renormalized") + probabilities = probabilities / np.sum(probabilities) + + l = ( + self.sampling_Pauli_space + if dfe_tuple is None + else int(np.ceil(1 / (dfe_tuple[0] ** 2 * dfe_tuple[1]))) + ) + k_samples = np.random.choice(len(probabilities), size=l, p=probabilities) + + pauli_indices, pauli_shots = np.unique(k_samples, return_counts=True) + reward_factor = self.c_factor / ( + np.sqrt(target_state.dm.dim) * target_state.Chi[pauli_indices] + ) + + if dfe_tuple is not None: + pauli_shots = np.ceil( + 2 + * np.log(2 / dfe_tuple[1]) + / ( + target_state.dm.dim + * l + * dfe_tuple[0] ** 2 + * target_state.Chi[pauli_indices] ** 2 + ) + ) + # Retrieve Pauli observables to sample, and build a weighted sum to feed the Estimator primitive + observables = SparsePauliOp( + full_basis[pauli_indices], reward_factor, copy=False + ) + shots_per_basis = [] + + for i, commuting_group in enumerate( + observables.paulis.group_qubit_wise_commuting() + ): + max_pauli_shots = 0 + for pauli in commuting_group: + pauli_index = list(full_basis).index(pauli) + ref_index = list(pauli_indices).index(pauli_index) + max_pauli_shots = max(max_pauli_shots, pauli_shots[ref_index]) + shots_per_basis.append(max_pauli_shots) + + return observables, shots_per_basis + + def state_reward_pubs(self, qc: QuantumCircuit, params): + """ + Retrieve observables and input state to sample for the DFE protocol for a target state + """ + + prep_circuit = qc.copy() + if isinstance(self.target, GateTarget): + # Append input state prep circuit to the custom circuit with front composition + prep_circuit = qc.compose( + self._input_state.circuit, inplace=False, front=True + ) + for _ in range(self.n_reps - 1): # Repeat circuit for noise amplification + prep_circuit.compose(qc, inplace=True) + + prep_circuit = self.backend_info.custom_transpile( + prep_circuit, + initial_layout=self.layout[self._inside_trunc_tracker], + scheduling=False, + ) + + pubs = [ + ( + prep_circuit, + obs.apply_layout(prep_circuit.layout), + params, + 1 / np.sqrt(self.n_shots * pauli_shots), + ) + for obs, pauli_shots in zip( + self._observables.group_commuting(qubit_wise=True), + self._pauli_shots, + ) + ] + total_shots = self.batch_size * np.sum(self._pauli_shots * self.n_shots) + + return pubs, total_shots + + def channel_reward_pubs( + self, + qc: QuantumCircuit, + params: np.array, + dfe_precision: Optional[Tuple[float, float]] = None, + ): + """ + Retrieve observables and input state to sample for the DFE protocol for a target gate + + :param qc: Quantum circuit to be executed on quantum system + :param params: Action vectors to execute on quantum system + :param dfe_precision: Optional Tuple (Ɛ, δ) from DFE paper + :return: Observables to sample, input state to prepare + """ + assert isinstance(self.target, GateTarget), "Target type should be a gate" + assert isinstance( + self.config.reward_config, ChannelConfig + ), "ChannelConfig object required for channel reward method" + nb_states = self.config.reward_config.num_eigenstates_per_pauli + assert ( + nb_states <= 2**qc.num_qubits + ), f"Number of eigenstates per Pauli should be less than {2 ** qc.num_qubits}" + d = 2**qc.num_qubits + probabilities = self.target.Chi**2 / (d**2) + basis = pauli_basis(num_qubits=qc.num_qubits) + + if dfe_precision is not None: + eps, delta = dfe_precision + l = int(np.ceil(1 / (eps**2 * delta))) + else: + l = self.sampling_Pauli_space + + samples, self._pauli_shots = np.unique( + np.random.choice(len(probabilities), size=l, p=probabilities), + return_counts=True, + ) + + pauli_indices = [np.unravel_index(sample, (d**2, d**2)) for sample in samples] + pauli_prep, pauli_meas = zip( + *[(basis[p[0]], basis[p[1]]) for p in pauli_indices] + ) + reward_factor = [self.c_factor / (d * self.target.Chi[p]) for p in samples] + self._observables = [ + SparsePauliOp(pauli_meas[i], reward_factor[i]) for i in range(len(samples)) + ] + if dfe_precision is not None: + self._pauli_shots = np.ceil( + 2 + * np.log(2 / delta) + / (d * l * eps**2 * self.target.Chi[pauli_indices] ** 2) + ) + + pubs = [] + total_shots = 0 + for prep, obs, shot in zip(pauli_prep, self._observables, self._pauli_shots): + max_input_states = d // nb_states + selected_input_states = np.random.choice( + d, size=max_input_states, replace=False + ) + for input_state in selected_input_states: + prep_indices = [] + dedicated_shots = shot // ( + max_input_states + ) # Number of shots per Pauli eigenstate (divided equally) + if dedicated_shots == 0: + continue + inputs = np.unravel_index(input_state, (2,) * qc.num_qubits) + parity = (-1) ** np.sum(inputs) + for i, pauli_op in enumerate(reversed(prep.to_label())): + if pauli_op == "I" or pauli_op == "Z": + prep_indices.append(inputs[i]) + elif pauli_op == "X": + prep_indices.append(2 + inputs[i]) + else: + prep_indices.append(4 + inputs[i]) + + prep_circuit = qc.compose( + Pauli6PreparationBasis().circuit(prep_indices), + front=True, + inplace=False, + ) + for _ in range(self.n_reps - 1): + prep_circuit.compose(qc, inplace=True) + prep_circuit = self.backend_info.custom_transpile( + prep_circuit, + initial_layout=self.layout[self._inside_trunc_tracker], + scheduling=False, + ) + + pubs.append( + ( + prep_circuit, + parity * obs.apply_layout(prep_circuit.layout), + params, + 1 / np.sqrt(dedicated_shots * self.n_shots), + ) + ) + total_shots += dedicated_shots * self.n_shots * self.batch_size + if len(pubs) == 0: # If nothing was sampled, retry + pubs, total_shots = self.channel_reward_pubs(qc, params) + + return pubs, total_shots + + def cafe_reward_pubs(self, circuit: QuantumCircuit, params): + """ + Retrieve PUBs for Context-Aware Fidelity Estimation (CAFE) protocol + + :param circuit: Quantum circuit to be executed on quantum system + :param params: Action vectors to execute on quantum system + """ + + assert isinstance(self.target, GateTarget), "Target type should be a gate" + assert isinstance( + self.config.reward_config, CAFEConfig + ), "CAFEConfig object required for CAFE reward method" + + pubs = [] + total_shots = 0 + circuit_ref = self.baseline_circuits[self._inside_trunc_tracker] + layout = self.layout[self._inside_trunc_tracker] + + input_circuits = [ + Pauli6PreparationBasis().circuit(s) + for s in product(range(4), repeat=circuit.num_qubits) + ] + # samples, shots = np.unique( + # np.random.choice(len(input_circuits), self.sampling_Pauli_space), + # return_counts=True, + # ) + # for sample, shot in zip(samples, shots): + for sample in range(len(input_circuits)): + run_qc = QuantumCircuit.copy_empty_like( + circuit, name="cafe_circ" + ) # Circuit with custom target gate + ref_qc = QuantumCircuit.copy_empty_like( + circuit_ref, name="cafe_ref_circ" + ) # Circuit with reference gate + + for qc, context in zip([run_qc, ref_qc], [circuit, circuit_ref]): + # Bind input states to the circuits + qc.compose(input_circuits[sample], inplace=True) + qc.barrier() + for _ in range( + self.n_reps + ): # Add custom target gate to run circuit n_reps times + qc.compose(context, inplace=True) + qc.barrier() + + # Compute inverse unitary for reference circuit + reverse_unitary = Operator(ref_qc).adjoint() + reverse_unitary_qc = QuantumCircuit.copy_empty_like(run_qc) + reverse_unitary_qc.unitary( + reverse_unitary, + reverse_unitary_qc.qubits, + label="U_inv", + ) + reverse_unitary_qc.measure_all() + + reverse_unitary_qc = self.backend_info.custom_transpile( + reverse_unitary_qc, + initial_layout=layout, + scheduling=False, + optimization_level=3, # Find smallest circuit implementing inverse unitary + remove_final_measurements=False, + ) + + # Bind inverse unitary + measurement to run circuit + for circ, pubs_ in zip([run_qc, ref_qc], [pubs, self._ideal_pubs]): + transpiled_circuit = self.backend_info.custom_transpile( + circ, initial_layout=layout, scheduling=False + ) + transpiled_circuit.barrier(self.involved_qubits) + # Add the inverse unitary + measurement to the circuit + transpiled_circuit.compose(reverse_unitary_qc, inplace=True) + pubs_.append((transpiled_circuit, params, self.n_shots)) + # pubs_.append((transpiled_circuit, params, self.n_shots * shot)) + total_shots += self.batch_size * self.n_shots + # total_shots += self.batch_size * self.n_shots * shot + + return pubs, total_shots + + def xeb_reward_pubs(self, circuit: QuantumCircuit, params): + """ + Retrieve PUBs for XEB protocol + + :param circuit: Quantum circuit to be executed on quantum system + :param params: Action vectors to execute on quantum system + """ + # TODO: Complete XEB (will be relevant once pattern for parallel XEB is figured out) + assert isinstance(self.target, GateTarget), "Target type should be a gate" + assert isinstance( + self.config.reward_config, XEBConfig + ), "XEBConfig object required for XEB reward method" + layout = self.layout[self._inside_trunc_tracker] + circuit_ref = self.baseline_circuits[self._inside_trunc_tracker] + pubs = [] + total_shots = 0 + + for seq in range(self.sampling_Pauli_space): + ref_qc = QuantumCircuit.copy_empty_like( + circuit_ref, + name="xeb_ref_circ", + ) + run_qc = QuantumCircuit.copy_empty_like( + circuit, + name="xeb_run_circ", + ) + for l in range(self.n_reps): + pass + + return pubs, total_shots + + def orbit_reward_pubs(self, circuit: QuantumCircuit, params): + """ + Retrieve PUBs for ORBIT protocol + + :param circuit: Quantum circuit to be executed on quantum system + :param params: Action vectors to execute on quantum system + """ + assert isinstance(self.target, GateTarget), "Target type should be a gate" + assert isinstance( + self.config.reward_config, ORBITConfig + ), "ORBITConfig object required for ORBIT reward method" + layout = self.layout[self._inside_trunc_tracker] + circuit_ref = self.baseline_circuits[self._inside_trunc_tracker] + pubs = [] + total_shots = 0 + if self.config.reward_config.use_interleaved: # Interleaved RB + try: + Clifford(circuit_ref) + except QiskitError as e: + raise ValueError( + "Circuit should be a Clifford circuit for using interleaved RB directly" + ) from e + ref_element = circuit_ref.to_gate(label="ref_circ") + custom_element = circuit.to_gate(label="custom_circ") + exp = InterleavedRB( + ref_element, + self.involved_qubits, + [self.n_reps], + self.backend, + self.sampling_Pauli_space, + self.seed, + circuit_order="RRRIII", + ) + # ref_circuits = exp.circuits()[0: self.n_reps] + interleaved_circuits = exp.circuits()[self.n_reps :] + run_circuits = [ + substitute_target_gate(circ, ref_element, custom_element) + for circ in interleaved_circuits + ] + run_circuits = self.backend_info.custom_transpile( + run_circuits, + initial_layout=layout, + scheduling=False, + remove_final_measurements=False, + ) + pubs = [(qc, params, self.n_shots) for qc in run_circuits] + total_shots += self.batch_size * self.n_shots * len(pubs) + self._ideal_pubs = [ + (qc, params, self.n_shots) for qc in interleaved_circuits + ] + else: + for seq in range(self.sampling_Pauli_space): + ref_qc = QuantumCircuit.copy_empty_like( + circuit_ref, + name="orbit_ref_circ", + ) + run_qc = QuantumCircuit.copy_empty_like(circuit, name="orbit_run_circ") + for l in range(self.n_reps): + r_cliff = random_clifford(circuit.num_qubits) + for qc, context in zip([run_qc, ref_qc], [circuit, circuit_ref]): + qc.compose(r_cliff.to_circuit(), inplace=True) + qc.barrier() + qc.compose(context, inplace=True) + qc.barrier() + + reverse_unitary = Operator(ref_qc).adjoint() + reverse_unitary_qc = QuantumCircuit.copy_empty_like(run_qc) + reverse_unitary_qc.unitary( + reverse_unitary, reverse_unitary_qc.qubits, label="U_inv" + ) + reverse_unitary_qc.measure_all() + + reverse_unitary_qc = self.backend_info.custom_transpile( + reverse_unitary_qc, + initial_layout=layout, + scheduling=False, + optimization_level=3, + remove_final_measurements=False, + ) # Try to get the smallest possible circuit for the reverse unitary + + for circ, pubs_ in zip([run_qc, ref_qc], [pubs, self._ideal_pubs]): + transpiled_circuit = self.backend_info.custom_transpile( + circ, initial_layout=layout, scheduling=False + ) + transpiled_circuit.barrier(self.involved_qubits) + # Add the inverse unitary + measurement to the circuit + transpiled_circuit.compose(reverse_unitary_qc, inplace=True) + pubs_.append((transpiled_circuit, params, self.n_shots)) + + total_shots += self.batch_size * self.n_shots + + return pubs, total_shots + + def _observable_to_observation(self): + """ + Convert the observable to an observation to be given to the agent + """ + if self.config.reward_method == "state": + n_qubits = self.observables.num_qubits + d = 2**n_qubits + pauli_to_index = {pauli: i for i, pauli in enumerate(pauli_basis(n_qubits))} + array_obs = np.zeros(d**2) + for pauli in self.observables: + array_obs[pauli_to_index[pauli.paulis[0]]] = pauli.coeffs[0] + + array_obs = [] + return array_obs + else: + raise NotImplementedError("Channel estimator not yet implemented") + + def modify_environment_params(self, **kwargs): + """ + Modify environment parameters + """ + pass + + @property + def config(self): + return self._training_config + + @property + def estimator(self) -> BaseEstimatorV1 | BaseEstimatorV2: + return self._estimator + + @estimator.setter + def estimator(self, estimator: BaseEstimatorV1 | BaseEstimatorV2): + self._estimator = estimator + + @property + def sampler(self) -> BaseSamplerV1 | BaseSamplerV2: + return self._sampler + + @sampler.setter + def sampler(self, sampler: BaseSamplerV1 | BaseSamplerV2): + self._sampler = sampler + + @property + def primitive(self) -> BaseEstimatorV2 | BaseSamplerV2: + if ( + self.config.reward_method == "state" + or self.config.reward_method == "channel" + ): + return self.estimator + else: + return self.sampler + + @property + def physical_target_qubits(self): + return self._physical_target_qubits + + @property + def physical_neighbor_qubits(self): + return self._physical_neighbor_qubits + + @property + def physical_next_neighbor_qubits(self): + return self._physical_next_neighbor_qubits + + @property + @abstractmethod + def tgt_instruction_counts(self) -> int: + """ + Number of occurrences of the target instruction in the circuit + """ + raise NotImplementedError("Target instruction counts not implemented") + + @property + def fidelity_history(self): + return ( + self.avg_fidelity_history + if self.target.target_type == "gate" + else self.state_fidelity_history + ) + + @property + def step_tracker(self): + return self._step_tracker + + @step_tracker.setter + def step_tracker(self, step: int): + assert step >= 0, "step must be positive integer" + self._step_tracker = step + + def signal_handler(self, signum, frame): + """Signal handler for SIGTERM and SIGINT signals.""" + print(f"Received signal {signum}, closing environment...") + self.close() + + def close(self) -> None: + if isinstance(self.backend, IBMBackend): + self.estimator.session.close() + + def clear_history(self): + """ + Clear all stored data to start new training. + """ + self._step_tracker = 0 + self._episode_tracker = 0 + self.qc_history.clear() + self.action_history.clear() + self.reward_history.clear() + self.rl_reward_history.clear() + self._total_shots.clear() + self._hardware_runtime.clear() + if isinstance(self.target, GateTarget): + self.avg_fidelity_history.clear() + self.process_fidelity_history.clear() + + else: + self.state_fidelity_history.clear() + self.density_matrix_history.clear() + + def update_gate_calibration(self): + """ + Update backend target with the optimal action found during training + + :return: Pulse calibration for the target gate + """ + if not isinstance(self.target, GateTarget): + raise ValueError("Target type should be a gate for gate calibration task.") + + if self.abstraction_level == "pulse": + sched = schedule(self.circuits[0], self.backend).assign_parameters( + { + param: action + for param, action in zip(self.parameters[0], self._optimal_action) + } + ) + duration = sched.duration + if isinstance(self.backend, DynamicsBackend): + error = 1.0 + error -= simulate_pulse_schedule( + self.backend, + sched, + target_unitary=Operator(self.target.gate), + target_state=Statevector.from_int(0, dims=[2] * self.n_qubits), + )["gate_fidelity"]["optimal"] + + else: + error = 1.0 - np.max(self.avg_fidelity_history) + instruction_prop = InstructionProperties(duration, error, sched) + self.backend.target.update_instruction_properties( + self.target.gate.name, + tuple(self.physical_target_qubits), + instruction_prop, + ) + + return self.backend.target.get_calibration( + self.target.gate.name, tuple(self.physical_target_qubits) + ) + else: + return self.circuits[0].assign_parameters( + {self.parameters[0]: self._optimal_action} + ) + + @property + def benchmark_cycle(self) -> int: + """ + Cycle at which fidelity benchmarking is performed + :return: + """ + return self._benchmark_cycle + + @benchmark_cycle.setter + def benchmark_cycle(self, step: int) -> None: + """ + Set cycle at which fidelity benchmarking is performed + :param step: + :return: + """ + assert step >= 0, "Cycle needs to be a positive integer" + self._benchmark_cycle = step + + def do_benchmark(self) -> bool: + """ + Check if benchmarking should be performed at current step + :return: + """ + if self.config.reward_method == "fidelity": + return True + elif self.benchmark_cycle == 0: + return False + else: + return self._episode_tracker % self.benchmark_cycle == 0 + + def _get_info(self) -> Any: + step = self._episode_tracker + if self._episode_ended: + if self.do_benchmark(): + info = { + "step": step, + "average return": np.mean(self.reward_history, axis=1)[-1], + "circuit fidelity": self.fidelity_history[-1], + "max return": np.max(np.mean(self.reward_history, axis=1)), + "max circuit fidelity": np.max(self.fidelity_history), + "arg max return": np.argmax(np.mean(self.reward_history, axis=1)), + "arg max circuit fidelity": np.argmax(self.fidelity_history), + "optimal action": self.optimal_action, + "input_state": ( + self.target.input_states[self.trunc_index][ + self._index_input_state + ].circuit.name + if isinstance(self.target, GateTarget) + else None + ), + } + else: + info = { + "step": step, + "average return": np.mean(self.reward_history, axis=1)[-1], + "max return": np.max(np.mean(self.reward_history, axis=1)), + "arg_max return": np.argmax(np.mean(self.reward_history, axis=1)), + "optimal action": self.optimal_action, + "input_state": ( + self.target.input_states[self.trunc_index][ + self._index_input_state + ].circuit.name + if isinstance(self.target, GateTarget) + else None + ), + } + else: + info = { + "reset_stage": self._inside_trunc_tracker == 0, + "step": step, + "gate_index": self._inside_trunc_tracker, + "input_state": self.target.input_states[self.trunc_index][ + self._index_input_state + ].circuit.name, + "truncation_index": self.trunc_index, + } + return info + + def _ident_str(self): + """This is a one-line description of the environment with some key parameters.""" + if isinstance(self.target, GateTarget): + ident_str = f"gate_calibration_{self.target.gate.name}-gate_physical_qubits_{'-'.join(map(str, self.target.physical_qubits))}" + elif isinstance(self.target, StateTarget): + ident_str = f"state_preparation_physical_qubits_{'-'.join(map(str, self.target.physical_qubits))}" + else: + raise ValueError("Target type not recognized") + return ident_str + + def __repr__(self): + string = f"QuantumEnvironment composed of {self.n_qubits} qubits, \n" + string += ( + f"Defined target: {self.target.target_type} " + f"({self.target.gate if isinstance(self.target, GateTarget) else self.target.dm})\n" + ) + string += f"Physical qubits: {self.target.physical_qubits}\n" + string += f"Backend: {self.backend},\n" + string += f"Abstraction level: {self.abstraction_level},\n" + string += f"Run options: N_shots ({self.n_shots}), Sampling_Pauli_space ({self.sampling_Pauli_space}), \n" + string += f"Batch size: {self.batch_size}, \n" + return string + + # Properties + + @property + def seed(self): + return self._seed + + @seed.setter + def seed(self, seed): + self._seed = seed + + @property + def batch_size(self) -> Optional[int]: + return self._batch_size + + @batch_size.setter + def batch_size(self, size: int): + try: + assert size > 0 and isinstance(size, int) + self._batch_size = size + except AssertionError: + raise ValueError("Batch size should be positive integer.") + + @property + def n_qubits(self): + return self.target.n_qubits + + @n_qubits.setter + def n_qubits(self, n_qubits): + assert ( + isinstance(n_qubits, int) and n_qubits > 0 + ), "n_qubits must be a positive integer" + self.target.n_qubits = n_qubits + + @property + def layout(self): + return self.target.layout + + @layout.setter + def layout(self, layout: Layout | List[Layout]): + if isinstance(layout, Layout): + layout = [layout] + self.target.layout = layout + + @property + @abstractmethod + def parameters(self) -> List[ParameterVector] | ParameterVector: + """ + Return the Qiskit ParameterVector defining the actions applied on the environment + """ + raise NotImplementedError("Parameters not implemented") + + @property + def involved_qubits(self): + """ + Return the qubits involved in the calibration task + """ + return list(self.layout[self._inside_trunc_tracker].get_physical_bits().keys()) + + @property + def observables(self) -> SparsePauliOp: + return self._observables + + @property + def total_shots(self): + return self._total_shots + + @property + def hardware_runtime(self): + return self._hardware_runtime + + @property + def n_actions(self): + return self.action_space.shape[-1] + + @property + def optimal_action(self): + return self._optimal_action + + @property + def mean_action(self): + return self._mean_action + + @mean_action.setter + def mean_action(self, value): + self._mean_action = np.array(value) + + @property + def std_action(self): + return self._std_action + + @std_action.setter + def std_action(self, value): + self._std_action = np.array(value) + + @property + def ident_str(self): + return self._ident_str() + + @property + @abstractmethod + def trunc_index(self) -> int: + """ + Index of the truncation to be applied + """ + raise NotImplementedError("Truncation index not implemented") + + def to_json(self): + return json.dumps( + { + "n_qubits": self.n_qubits, + "config": asdict(self.config), + "abstraction_level": self.abstraction_level, + "sampling_Pauli_space": self.sampling_Pauli_space, + "n_shots": self.n_shots, + "target_type": self.target.target_type, + "target": self.target, + "c_factor": self.c_factor, + "reward_history": self.reward_history, + "rl_reward_history": self.rl_reward_history, + "action_history": self.action_history, + "fidelity_history": ( + self.avg_fidelity_history + if self.target.target_type == "gate" + else self.state_fidelity_history + ), + } + ) + + def compute_channel_reward(self, params, trunc_index): + pass + + def run_v1_primitive(self, qc: QuantumCircuit, params: np.array): + if self.config.reward_method == "channel": + raise NotImplementedError( + "Channel estimator not implemented for EstimatorV1" + ) + + job = self.estimator.run( + circuits=[qc] * self.batch_size, + observables=[self._observables.apply_layout(qc.layout)] * self.batch_size, + parameter_values=params, + shots=int(np.max(self._pauli_shots) * self.n_shots), + ) + self._total_shots.append( + int(np.max(self._pauli_shots) * self.n_shots) + * self.batch_size + * len(self._observables.group_commuting(qubit_wise=True)) + ) + reward_table = job.result().values / self._observables.size + + return reward_table diff --git a/rl_qoc/general_noise_quantum_environment.py b/rl_qoc/general_noise_quantum_environment.py new file mode 100644 index 0000000..002b6c3 --- /dev/null +++ b/rl_qoc/general_noise_quantum_environment.py @@ -0,0 +1,691 @@ +""" +Backend with Aer Noise Model needs to reset +Circuit Context should either be parametrised and take phi, or be reset +""" + +from itertools import product +import sys +from typing import Dict, Optional, List, Any, TypeVar, SupportsFloat, Union + +import numpy as np +from gymnasium.spaces import Box + +# Qiskit imports +from qiskit import transpile +from qiskit.circuit import ( + QuantumCircuit, + QuantumRegister, + ParameterVector, + CircuitInstruction, +) +from qiskit.quantum_info import state_fidelity, Statevector +from qiskit.transpiler import Layout +from qiskit_aer.backends import AerSimulator +from qiskit_aer.backends.aerbackend import AerBackend +from qiskit_aer.noise import NoiseModel +from qiskit_dynamics import DynamicsBackend +from qiskit_ibm_runtime import EstimatorV2 + +from qiskit_ibm_runtime import IBMBackend as RuntimeBackend + +from rl_qoc.helper_functions import ( + projected_statevector, + get_instruction_timings, + get_q_env_config, +) +from rl_qoc.qconfig import QEnvConfig, QiskitConfig +from rl_qoc.base_parametrised_q_env import ( + GateTarget, + BaseParametrisedQuantumEnvironment, +) +from rl_qoc.custom_jax_sim import JaxSolver + +import logging + +logging.basicConfig( + level=logging.WARNING, + format="%(asctime)s INFO %(message)s", # hardcoded INFO level + datefmt="%Y-%m-%d %H:%M:%S", + stream=sys.stdout, +) + +ObsType = TypeVar("ObsType") +ActType = TypeVar("ActType") + + +def create_array(circ_trunc, batchsize, n_actions): + arr = np.empty((circ_trunc,), dtype=object) + for i in range(circ_trunc): + arr[i] = np.zeros((i + 1, batchsize, n_actions)) + return arr + + +class GeneralNoiseQuantumEnvironment(BaseParametrisedQuantumEnvironment): + + def __init__( + self, + params, + backend_params, + runtime_options, + apply_parametrized_circuit, + get_backend_parametrised, + get_parameterised_circuit_context, + get_instruction_durations, + gamma, + circuit_param_distribution, + phi_max, + num_params, + discrete_history_length, + optimal_error_precision, + training_steps_per_gate: Union[List[int], int] = 1500, + intermediate_rewards: bool = False, + ): + self.params = params + self.backend_params = backend_params + self.runtime_options = runtime_options + self.apply_parametrized_circuit = apply_parametrized_circuit + self.get_backend_parametrised = get_backend_parametrised + self.get_parameterised_circuit_context = get_parameterised_circuit_context + self.get_instruction_durations = get_instruction_durations + self.gamma = gamma + self._training_steps_per_gate = training_steps_per_gate + self._intermediate_rewards = intermediate_rewards + self.circuit_fidelity_history = [] + self.phi_max = phi_max + self.num_params = num_params + self.optimal_error_precision = optimal_error_precision + self.example_phi = phi_max + self.circuit_param_distribution = circuit_param_distribution + + # Making Example Backend and Circuit Context + self.example_backend = self.get_backend_parametrised( + phi=self.example_phi, + gamma=self.gamma, + print_noise_model=True, + **self.backend_params, + ) + self.backend_config = QiskitConfig( + self.apply_parametrized_circuit, + self.example_backend, + estimator_options=( + self.runtime_options + if isinstance(self.example_backend, RuntimeBackend) + else None + ), + # parametrized_circuit_kwargs=parametrized_circ_args, + ) + self.q_env_config = QEnvConfig( + backend_config=self.backend_config, **self.params + ) + self.q_env_config.backend_config.parametrized_circuit_kwargs = { + "target": self.q_env_config.target, + "backend": self.q_env_config.backend, + } + self.q_env_config.backend_config.instruction_durations_dict = ( + self.get_instruction_durations(self.q_env_config.backend) + ) + print_circuit = True + self.circuit_context = self.get_parameterised_circuit_context( + self.example_phi, print_circuit, self.example_backend + ) + + # Define target register and nearest neighbor register for truncated circuits + self.circ_tgt_register = QuantumRegister( + bits=[ + self.circuit_context.qubits[i] + for i in self.q_env_config.physical_qubits + ], + name="tgt", + ) + + # Adjust target register to match it with circuit context + self.target_instruction = CircuitInstruction( + self.q_env_config.target["gate"], + (qubit for qubit in self.circ_tgt_register), + ) + self._tgt_instruction_counts = self.circuit_context.data.count( + self.target_instruction + ) + if self.tgt_instruction_counts == 0: + raise ValueError("Target gate not found in circuit context") + + self._parameters = [ + ParameterVector(f"a_{j}", self.q_env_config.n_actions) + for j in range(self.tgt_instruction_counts) + ] + + # Store time and instruction indices where target gate is played in circuit + try: + self._op_start_times = self.circuit_context.op_start_times + except AttributeError: + self._op_start_times = get_instruction_timings(self.circuit_context) + + ### Very important, keep after _op_start_times ### + super().__init__(self.q_env_config) + + self._target_instruction_timings = [] + for i, instruction in enumerate(self.circuit_context.data): + if instruction == self.target_instruction: + self._target_instruction_timings.append(self._op_start_times[i]) + + self._param_values = create_array( + self.tgt_instruction_counts, self.batch_size, self.action_space.shape[-1] + ) + self.observation_space = Box( + low=np.array([-1.0]), high=np.array([1.0]), dtype=np.float32 + ) # multiply by pi for actual values + self.phi_bound = 0.0 + + self.discrete_reward_history = np.ones((discrete_history_length, num_params)) + self.discrete_obs_vals = np.linspace( + self.action_space.low, self.action_space.high, self.num_params + ) + + def define_target_and_circuits(self): + """ + Define target gate and circuits for calibration + """ + + assert "gate" in self.config.target, "Target should be a gate" + + # Build registers for all relevant qubits + circ_nn_register, circ_anc_register = ( + QuantumRegister( + bits=[self.circuit_context.qubits[i] for i in qubits], + name=reg_name, + ) + for reg_name, qubits in zip( + ["nn", "anc"], + [self.physical_neighbor_qubits, self.physical_next_neighbor_qubits], + ) + ) + tgt_register = QuantumRegister(len(self.physical_target_qubits), name="tgt") + layouts = [ + Layout( + { + tgt_register[i]: self.physical_target_qubits[i] + for i in range(tgt_register.size) + } + ) + for _ in range(self.tgt_instruction_counts) + ] + nn_registers, anc_registers = [ + [QuantumRegister(1, name=f"{name}_{i}") for i in range(reg.size)] + for name, reg in zip(["nn", "anc"], [circ_nn_register, circ_anc_register]) + ] + # Create mapping between circuit context qubits and custom circuit associated single qubit registers + mapping = { + circ_reg[i]: reg[i] + for circ_reg, reg in zip( + [circ_nn_register, self.circ_tgt_register, circ_anc_register], + [nn_registers, tgt_register, anc_registers], + ) + for i in range(circ_reg.size) + } + + # Initialize custom and baseline circuits for each target gate (by default only contains target qubits) + custom_circuits, baseline_circuits = [ + [ + QuantumCircuit(tgt_register, name=name + str(i)) + for i in range(self.tgt_instruction_counts) + ] + for name in ["c_circ_trunc_", "b_circ_trunc_"] + ] + # Build sub-circuit contexts: each circuit goes until target gate and preserves nearest neighbor operations + for i in range(self.tgt_instruction_counts): # Loop over target gates + counts = 0 + for start_time, instruction in zip( + self._op_start_times, self.circuit_context.data + ): # Loop over instructions in circuit context + + # Check if instruction involves target or nearest neighbor qubits + involves_target_qubits = any( + [ + qubit in reg + for reg in [self.circ_tgt_register, circ_nn_register] + for qubit in instruction.qubits + ] + ) + if involves_target_qubits: + involved_qubits = [ + qubit + for qubit in instruction.qubits + if qubit not in self.circ_tgt_register + ] + else: + involved_qubits = [] + + # If instruction involves target or nn qubits and happens before target gate, add it to custom circuit + + if ( + counts <= i or start_time <= self._target_instruction_timings[i] + ) and involves_target_qubits: + for qubit in involved_qubits: + if ( + mapping[qubit] not in custom_circuits[i].qregs + ): # Add register if not already added + baseline_circuits[i].add_register(mapping[qubit]) + custom_circuits[i].add_register(mapping[qubit]) + if ( + self.circuit_context.layout.final_layout is not None + ): # Update physical layout + layouts[i].add( + mapping[qubit][0], + self.circuit_context.layout.final_layout[qubit], + ) + else: + layouts[i].add( + mapping[qubit][0], + self.circuit_context.qubits.index(qubit), + ) + + baseline_circuits[i].append( + instruction.operation, + ( + ( + mapping[q][0] + if q not in self.circ_tgt_register + else mapping[q] + ) + for q in instruction.qubits + ), + ) + if instruction != self.target_instruction: + custom_circuits[i].append( + instruction.operation, + ( + ( + mapping[q][0] + if q not in self.circ_tgt_register + else mapping[q] + ) + for q in instruction.qubits + ), + ) + else: # Add custom instruction in place of target gate + try: + self.parametrized_circuit_func( + custom_circuits[i], + self.parameters[counts], + tgt_register, + **self._func_args, + ) + except TypeError: + raise TypeError("Failed to call parametrized_circuit_func") + counts += 1 + # custom_circuits[i] = remove_unused_wires(custom_circuits[i]) + # baseline_circuits[i] = remove_unused_wires(baseline_circuits[i]) + + target = GateTarget( + self.config.target["gate"], + self.physical_target_qubits, + self.config.n_reps, + baseline_circuits, + tgt_register, + layouts, + ) + return target, custom_circuits, baseline_circuits + + def reset( + self, + override_obs: Optional[np.ndarray] = None, + seed: Optional[int] = None, + options: Optional[Dict[str, Any]] = None, + ) -> tuple[ObsType, dict[str, Any]]: + """Reset the Environment, chooses a new input state""" + super().reset(seed=seed) + + if self.circuit_param_distribution == "uniform": + self.phi_bound = np.random.uniform( + low=self.observation_space.low, high=self.observation_space.high + ) + if self.circuit_param_distribution == "normal": + self.phi_bound = np.random.normal(loc=0.0, scale=0.5, size=None) + self.phi_bound = np.clip( + self.phi_bound, + a_min=self.observation_space.low, + a_max=self.observation_space.high, + ) + if self.circuit_param_distribution == "simple_discrete": + self.phi_bound = np.random.choice( + self.discrete_obs_vals, len(self.phi_max), replace=True + ) + if self.circuit_param_distribution == "moving_discrete": + prob_weights = -np.log10(self.optimal_error_precision) - np.mean( + self.discrete_reward_history, axis=0 + ) + self.phi_bound = np.random.choice( + self.discrete_obs_vals, len(self.phi_max), replace=True, p=prob_weights + ) + if override_obs is not None: + self.phi_bound = override_obs + self._param_values = create_array( + self.tgt_instruction_counts, self.batch_size, self.action_space.shape[0] + ) + self._inside_trunc_tracker = 0 + + self.phi_rad = ( + self.phi_bound * self.phi_max + ) # scaling factor for radian parameters + assert np.abs(self.phi_rad) <= self.phi_max + + # Making Backend and Circuit Context + self.step_backend = self.get_backend_parametrised( + phi=self.phi_rad, + gamma=self.gamma, + print_noise_model=False, + **self.backend_params, + ) + self.step_backend_config = QiskitConfig( + self.apply_parametrized_circuit, + self.step_backend, + estimator_options=( + self.runtime_options + if isinstance(self.step_backend, RuntimeBackend) + else None + ), + # parametrized_circuit_kwargs=parametrized_circ_args, + ) + self.step_q_env_config = QEnvConfig( + backend_config=self.step_backend_config, **self.params + ) + self.step_q_env_config.backend_config.parametrized_circuit_kwargs = { + "target": self.step_q_env_config.target, + "backend": self.step_q_env_config.backend, + } + self.step_q_env_config.backend_config.instruction_durations_dict = ( + self.get_instruction_durations(self.step_q_env_config.backend) + ) + print_circuit = False + self.step_circuit_context = self.get_parameterised_circuit_context( + self.phi_rad, print_circuit, self.step_backend + ) + + # Redefining Targets based on new phi + self.extract_from_config( + self.step_q_env_config + ) # effectively reruns super.__init__() functionalities + + return self._get_obs(), self._get_info() + + def step( + self, action: ActType + ) -> tuple[ObsType, SupportsFloat, bool, bool, dict[str, Any]]: + + # trunc_index tells us which circuit truncation should be trained + # Dependent on global_step and method select_trunc_index + trunc_index = self.trunc_index + # Figure out if in middle of param loading or should compute the final reward (step_status < trunc_index or ==) + step_status = self._inside_trunc_tracker + self._step_tracker += 1 + + if self._episode_ended: + terminated = True + return ( + self.reset()[0], + np.zeros(self.batch_size), + terminated, + False, + self._get_info(), + ) + + if trunc_index >= self.tgt_instruction_counts: + # raise IndexError(f"Circuit does contain only {self.tgt_instruction_counts} target gates and step" + # f" function tries to access gate nb {trunc_index} ") + truncated = True + return ( + self.reset()[0], + np.zeros(self.batch_size), + False, + truncated, + self._get_info(), + ) + + params, batch_size = np.array(action), len(np.array(action)) + if batch_size != self.batch_size: + raise ValueError( + f"Action batch size {batch_size} does not match environment batch size {self.batch_size}" + ) + self._param_values[trunc_index][step_status] = params + params = np.reshape( + np.vstack([param_set for param_set in self._param_values[trunc_index]]), + (self.batch_size, (trunc_index + 1) * self.action_space.shape[-1]), + ) + if step_status < trunc_index: # Intermediate step within the circuit truncation + self._inside_trunc_tracker += 1 + terminated = False + + if self._intermediate_rewards: + reward = self.perform_action(params) + obs = reward # Set observation to obtained reward (might not be the smartest choice here) + return obs, reward, terminated, False, self._get_info() + else: + return ( + self._get_obs(), + np.zeros(batch_size), + terminated, + False, + self._get_info(), + ) + + else: + terminated = self._episode_ended = True + reward = self.perform_action(params) + if self._intermediate_rewards: + obs = reward + else: + obs = self._get_obs() + + # Using Negative Log Error as the Reward + if np.mean(reward) > self._max_return: + self._max_return = np.mean(reward) + self._optimal_action = self.mean_action + self.reward_history.append(reward) + assert ( + len(reward) == self.batch_size + ), f"Reward table size mismatch {len(reward)} != {self.batch_size} " + assert not np.any(np.isinf(reward)) and not np.any( + np.isnan(reward) + ), "Reward table contains NaN or Inf values" + max_fidelity = 1.0 - self.optimal_error_precision + reward = np.clip(reward, a_min=0.0, a_max=max_fidelity) + reward = -np.log10(1.0 - reward) + if self.circuit_param_distribution in [ + "simple_discrete", + "moving_discrete", + ]: + self.update_discrete_history(reward, obs) + self.rl_reward_history.append(reward) + + return obs, reward, terminated, False, self._get_info() + + def update_discrete_history(self, reward, obs): + obs_ind = np.argmin(np.abs(self.discrete_obs_vals - obs)) + self.discrete_reward_history[:, obs_ind] = np.append( + [reward], self.discrete_reward_history[:-1, obs_ind], axis=0 + ) + + def _get_obs(self): + return np.array([self.phi_bound]) + + def compute_benchmarks(self, qc: QuantumCircuit, params: np.array) -> np.array: + """ + Method to store in lists all relevant data to assess performance of training (fidelity information) + :param params: Batch of actions + """ + new_qc = qc.copy() + n_actions = self.action_space.shape[-1] + n_custom_instructions = ( + self.trunc_index + 1 + ) # Count custom instructions present in the current truncation + baseline_circ = self.baseline_circuits[self.trunc_index] + target = Statevector(baseline_circ) + + if ( + self.config.check_on_exp + ): # Perform real experiments to retrieve from measurement data fidelities + # Assess circuit fidelity with ComputeUncompute algo + try: + # job = self.fidelity_checker.run( + # [qc] * len(params), + # [baseline_circ] * len(params), + # values_1=params, + # ) + # circuit_fidelities = job.result().fidelities + angle_sets = np.clip( + np.random.normal( + self.mean_action, + self.std_action, + size=(self.config.benchmark_batch_size, n_actions), + ), + self.action_space.low, + self.action_space.high, + ) + + print("Starting Direct Fidelity Estimation...") + observables, shots = self.retrieve_observables( + self._input_state.target_state, + self.circuits[self.trunc_index], + self.config.benchmark_config.dfe_precision, + ) + if self.abstraction_level == "circuit": + new_qc = self.backend_info.custom_transpile( + new_qc, + initial_layout=self.layout[self.trunc_index], + scheduling=False, + ) + pubs = [ + ( + new_qc, + obs.apply_layout(new_qc.layout), + angle_sets, + 1 / np.sqrt(shot), + ) + for obs, shot in zip( + observables.group_commuting(qubit_wise=True), shots + ) + ] + if isinstance(self.estimator, EstimatorV2): + self.estimator.options.update( + job_tags=[f"DFE_step{self._step_tracker}"] + ) + job = self.estimator.run(pubs=pubs) + results = job.result() + circuit_fidelities = np.sum( + [result.data.evs for result in results], axis=0 + ) / len(observables) + print("Finished DFE") + except Exception as exc: + self.close() + raise exc + + else: # Perform ideal simulation at circuit or pulse level + if self.abstraction_level == "circuit": + # Calculate circuit fidelity with statevector simulation + if isinstance(self.backend, AerBackend): + backend = self.backend + elif self.backend is None: + backend = AerSimulator(method="statevector") + + else: + noise_model = NoiseModel.from_backend(self.backend) + backend = AerSimulator( + noise_model=noise_model, method="density_matrix" + ) + new_qc.save_density_matrix() + circ = transpile(new_qc, backend=backend, optimization_level=0) + + states_result = backend.run( + circ, + parameter_binds=[ + { + self._parameters[i][j]: params[:, i * n_actions + j] + for i in range(n_custom_instructions) + for j in range(n_actions) + } + ], + ).result() + output_states = [ + states_result.data(i)["density_matrix"] + for i in range(self.batch_size) + ] + + else: # Pulse simulation + # Calculate circuit fidelity with pulse simulation + if isinstance(self.backend, DynamicsBackend) and isinstance( + self.backend.options.solver, JaxSolver + ): + # Jax compatible pulse simulation + + output_states = np.array(self.backend.options.solver.batched_sims)[ + :, 1, : + ] + + output_states = [ + projected_statevector(s, self.backend.options.subsystem_dims) + for s in output_states + ] + + else: + raise NotImplementedError( + "Pulse simulation not yet implemented for this backend" + ) + circuit_fidelities = [ + state_fidelity(state, Statevector(baseline_circ)) + for state in output_states + ] + # circuit_fidelities = [state_fidelity(partial_trace(state, + # list(range(state.num_qubits))[target.num_qubits:]), + # partial_trace(Statevector(baseline_circ), + # list(range(state.num_qubits))[target.num_qubits:])) + # for state in output_states] + self.circuit_fidelity_history.append(np.mean(circuit_fidelities)) + print("Fidelity stored", self.circuit_fidelity_history[-1]) + return circuit_fidelities + + @property + def parameters(self) -> List[ParameterVector]: + return self._parameters + + @property + def fidelity_history(self): + return self.circuit_fidelity_history + + @property + def tgt_instruction_counts(self) -> int: + return self._tgt_instruction_counts + + @property + def trunc_index(self) -> int: + if self._intermediate_rewards: + return self.step_tracker % self.tgt_instruction_counts + else: + return np.min( + [ + self._step_tracker // self.training_steps_per_gate, + self.tgt_instruction_counts - 1, + ] + ) + + @property + def training_steps_per_gate(self) -> int: + return self._training_steps_per_gate + + @training_steps_per_gate.setter + def training_steps_per_gate(self, nb_of_steps: int): + try: + assert nb_of_steps > 0 and isinstance(nb_of_steps, int) + self._training_steps_per_gate = nb_of_steps + except AssertionError: + raise ValueError("Training steps number should be positive integer.") + + def episode_length(self, global_step: int) -> int: + # assert ( + # global_step == self.step_tracker + # ), "Given step not synchronized with internal environment step counter" + return 1 + self.trunc_index + + def clear_history(self) -> None: + """Reset all counters related to training""" + super().clear_history() + self.circuit_fidelity_history.clear() diff --git a/rl_qoc/ppo_cleanrl.py b/rl_qoc/ppo_cleanrl.py new file mode 100644 index 0000000..d18924e --- /dev/null +++ b/rl_qoc/ppo_cleanrl.py @@ -0,0 +1,445 @@ +# Adapted from CleanRL ppo_continuous_action.py +import random +import time +from typing import Optional, Dict + +import numpy as np +import matplotlib.pyplot as plt +from matplotlib.ticker import MaxNLocator +from IPython.display import clear_output +import torch +import torch.nn as nn +import torch.optim as optim +from torch.distributions.normal import Normal +from torch.utils.tensorboard import SummaryWriter + +from rl_qoc.base_q_env import BaseQuantumEnvironment + + +def layer_init(layer, std=np.sqrt(2), bias_const=0.0): + torch.nn.init.orthogonal_(layer.weight, std) + # torch.nn.init.zeros_(layer.weight) + torch.nn.init.constant_(layer.bias, bias_const) + return layer + + +def plot_curves(env: BaseQuantumEnvironment): + """ + Plots the reward history and fidelity history of the environment + """ + fidelity_range = [i * env.benchmark_cycle for i in range(len(env.fidelity_history))] + plt.plot(np.mean(env.reward_history, axis=1), label="Reward") + plt.plot( + fidelity_range, + env.fidelity_history, + label=f"Circuit Fidelity", + ) + + plt.title("Reward History") + plt.legend() + plt.xlabel("Iteration") + plt.ylabel("Reward") + # Ensure integer ticks on the x-axis + plt.gca().xaxis.set_major_locator(MaxNLocator(integer=True)) + plt.show() + + +class Agent(nn.Module): + def __init__(self, env, use_combined_networks, activation_function_str, layer_size): + super().__init__() + self.use_combined_networks = use_combined_networks + if activation_function_str == "tanh": + self.activation_fn = nn.Tanh + elif activation_function_str == "relu": + self.activation_fn = nn.ReLU + elif activation_function_str == "gelu": + self.activation_fn = nn.GELU + elif activation_function_str == "elu": + self.activation_fn = nn.ELU + if not self.use_combined_networks: + self.critic = nn.Sequential( + layer_init( + nn.Linear(np.array(env.observation_space.shape).prod(), layer_size) + ), + self.activation_fn(), + layer_init(nn.Linear(layer_size, layer_size)), + self.activation_fn(), + layer_init(nn.Linear(layer_size, 1), std=1.0), + ) + self.actor_mean = nn.Sequential( + layer_init( + nn.Linear(np.array(env.observation_space.shape).prod(), layer_size) + ), + self.activation_fn(), + layer_init(nn.Linear(layer_size, layer_size)), + self.activation_fn(), + layer_init( + nn.Linear(layer_size, np.prod(env.action_space.shape)), std=0.01 + ), + ) + self.actor_logstd = nn.Parameter( + torch.zeros(1, np.prod(env.action_space.shape)) + ) + if self.use_combined_networks: + self.main_network = nn.Sequential( + layer_init( + nn.Linear(np.array(env.observation_space.shape).prod(), layer_size) + ), + self.activation_fn(), + layer_init(nn.Linear(layer_size, layer_size)), + self.activation_fn(), + ) + self.actor_mean = nn.Sequential( + self.main_network, + layer_init( + nn.Linear(layer_size, np.prod(env.action_space.shape)), std=0.01 + ), + self.activation_fn(), + ) + self.actor_std = nn.Sequential( + self.main_network, + layer_init( + nn.Linear(layer_size, np.prod(env.action_space.shape)), std=0.01 + ), + nn.Sigmoid(), + ) + self.critic = nn.Sequential( + self.main_network, + layer_init(nn.Linear(layer_size, 1), std=1.0), + ) + self.actor_logstd = nn.Parameter( + torch.zeros(1, np.prod(env.action_space.shape)) + ) + + def get_value(self, x): + return self.critic(x) + + def get_action_and_value(self, x, action=None): + action_mean = self.actor_mean(x) + # action_logstd = self.actor_logstd.expand_as(action_mean) + # action_std = torch.exp(action_logstd) + if self.use_combined_networks: + action_std = self.actor_std(x) + else: + action_logstd = self.actor_logstd.expand_as(action_mean) + action_std = torch.exp(action_logstd) + probs = Normal(action_mean, action_std) + if action is None: + action = probs.sample() + return ( + action, + probs.log_prob(action).sum(1), + probs.entropy().sum(1), + self.critic(x), + ) + + +class PPO_CleanRL: + def __init__( + self, + agent_config: Dict, + env: BaseQuantumEnvironment, + chkpt_dir: Optional[str] = "tmp/ppo", + chkpt_dir_critic: Optional[str] = "tmp/critic_ppo", + ): + # General Run Params + self.agent_config = agent_config + self.exp_name = self.agent_config["exp_name"] + self.seed = self.agent_config["seed"] + self.torch_deterministic = self.agent_config["torch_deterministic"] + self.cuda = self.agent_config["cuda"] + self.track = self.agent_config["track"] + self.wandb_project_name = self.agent_config["wandb_project_name"] + self.wandb_entity = self.agent_config["wandb_entity"] + self.save_model = self.agent_config["save_model"] + self.plot_real_time = self.agent_config["plot_real_time"] + self.num_prints = self.agent_config["num_prints"] + + # PPO Specific Params + self.num_updates = self.agent_config["total_updates"] + self.learning_rate = self.agent_config["learning_rate"] + self.num_envs = self.agent_config["num_envs"] + self.num_steps = self.agent_config["num_steps"] + self.anneal_lr = self.agent_config["anneal_lr"] + self.gamma = self.agent_config["gamma"] + self.gae_lambda = self.agent_config["gae_lambda"] + self.num_minibatches = self.agent_config["num_minibatches"] + self.update_epochs = self.agent_config["update_epochs"] + self.norm_adv = self.agent_config["norm_adv"] + self.activation_function_str = self.agent_config["activation_function_str"] + self.use_combined_networks = self.agent_config["use_combined_networks"] + self.layer_size = self.agent_config["layer_size"] + self.clip_coef = self.agent_config["clip_coef"] + self.clip_vloss = self.agent_config["clip_vloss"] + self.ent_coef = self.agent_config["ent_coef"] + self.vf_coef = self.agent_config["vf_coef"] + self.max_grad_norm = self.agent_config["max_grad_norm"] + self.target_kl = self.agent_config["target_kl"] + + self.batch_size = int(self.num_envs * self.num_steps) + self.minibatch_size = int(self.batch_size // self.num_minibatches) + + self.run_name = f"PPO_CleanRL__{self.exp_name}__{self.seed}__{int(time.time())}" + + if self.track: + import wandb + + wandb.init( + project=self.wandb_project_name, + entity=self.wandb_entity, + sync_tensorboard=True, + config=self.agent_config, + name=self.run_name, + monitor_gym=True, + save_code=True, + ) + self.writer = SummaryWriter(f"runs/{self.run_name}") + self.writer.add_text( + "hyperparameters", + "|param|value|\n|-|-|\n%s" + % ( + "\n".join( + [f"|{key}|{value}|" for key, value in self.agent_config.items()] + ) + ), + ) + + # TRY NOT TO MODIFY: seeding + random.seed(self.seed) + np.random.seed(self.seed) + torch.manual_seed(self.seed) + torch.backends.cudnn.deterministic = self.torch_deterministic + + self.device = torch.device( + "cuda" if torch.cuda.is_available() and self.cuda else "cpu" + ) + + self.env = env + + self.agent = Agent( + self.env, + self.use_combined_networks, + self.activation_function_str, + self.layer_size, + ).to(self.device) + self.optimizer = optim.Adam( + self.agent.parameters(), lr=self.learning_rate, eps=1e-5 + ) + + def run_training(self): + # ALGO Logic: Storage setup + self.obs = torch.zeros( + (self.num_steps, self.num_envs) + self.env.observation_space.shape + ).to(self.device) + self.actions = torch.zeros( + (self.num_steps, self.num_envs) + self.env.action_space.shape + ).to(self.device) + self.logprobs = torch.zeros((self.num_steps, self.num_envs)).to(self.device) + self.rewards = torch.zeros((self.num_steps, self.num_envs)).to(self.device) + self.dones = torch.zeros((self.num_steps, self.num_envs)).to(self.device) + self.values = torch.zeros((self.num_steps, self.num_envs)).to(self.device) + + # TRY NOT TO MODIFY: start the game + global_step = 0 + start_time = time.time() + next_obs, _ = self.env.reset(seed=self.seed) + next_obs = np.tile(next_obs, (self.num_envs, 1)) + next_obs = torch.Tensor(next_obs).to(self.device) + next_done = torch.zeros(self.num_envs).to(self.device) + + for update in range(1, self.num_updates + 1): + # Annealing the Learning Rate + if self.anneal_lr: + frac = 1.0 - (update - 1.0) / self.num_updates + lrnow = frac * self.learning_rate + self.optimizer.param_groups[0]["lr"] = lrnow + + for step in range(0, self.num_steps): + global_step += self.num_envs + self.obs[step] = next_obs + self.dones[step] = next_done + + # ALGO LOGIC: action logic + with torch.no_grad(): + action, logprob, _, value = self.agent.get_action_and_value( + next_obs + ) + self.values[step] = value.flatten() + self.actions[step] = action + self.logprobs[step] = logprob + + # TRY NOT TO MODIFY: execute the game and log data. + cpu_action = action.cpu().numpy() + cpu_action = np.clip( + cpu_action, + self.env.action_space.low, + self.env.action_space.high, + ) + + next_obs, reward, terminations, truncations, infos = self.env.step( + cpu_action + ) + next_obs = np.tile(next_obs, (self.num_envs, 1)) + next_done = np.logical_or(terminations, truncations) + if next_done: + next_obs, _ = self.env.reset(seed=self.seed) + next_obs = np.tile(next_obs, (self.num_envs, 1)) + self.rewards[step] = torch.tensor(reward).to(self.device).view(-1) + next_obs, next_done = torch.Tensor(next_obs).to( + self.device + ), torch.Tensor(next_done).to(self.device) + + if "final_info" in infos: + for info in infos["final_info"]: + if info and "episode" in info: + print( + f"global_step={global_step}, episodic_return={info['episode']['r']}" + ) + self.writer.add_scalar( + "charts/episodic_return", + info["episode"]["r"], + global_step, + ) + self.writer.add_scalar( + "charts/episodic_length", + info["episode"]["l"], + global_step, + ) + + # bootstrap value if not done + with torch.no_grad(): + next_value = self.agent.get_value(next_obs).reshape(1, -1) + advantages = torch.zeros_like(self.rewards).to(self.device) + lastgaelam = 0 + for t in reversed(range(self.num_steps)): + if t == self.num_steps - 1: + nextnonterminal = 1.0 - next_done + nextvalues = next_value + else: + nextnonterminal = 1.0 - self.dones[t + 1] + nextvalues = self.values[t + 1] + delta = ( + self.rewards[t] + + self.gamma * nextvalues * nextnonterminal + - self.values[t] + ) + advantages[t] = lastgaelam = ( + delta + + self.gamma * self.gae_lambda * nextnonterminal * lastgaelam + ) + returns = advantages + self.values + + # flatten the batch + b_obs = self.obs.reshape((-1,) + self.env.observation_space.shape) + b_logprobs = self.logprobs.reshape(-1) + b_actions = self.actions.reshape((-1,) + self.env.action_space.shape) + b_advantages = advantages.reshape(-1) + b_returns = returns.reshape(-1) + b_values = self.values.reshape(-1) + + # Optimizing the policy and value network + b_inds = np.arange(self.batch_size) + clipfracs = [] + for epoch in range(self.update_epochs): + np.random.shuffle(b_inds) + for start in range(0, self.batch_size, self.minibatch_size): + end = start + self.minibatch_size + mb_inds = b_inds[start:end] + + _, newlogprob, entropy, newvalue = self.agent.get_action_and_value( + b_obs[mb_inds], b_actions[mb_inds] + ) + logratio = newlogprob - b_logprobs[mb_inds] + ratio = logratio.exp() + + with torch.no_grad(): + # calculate approx_kl http://joschu.net/blog/kl-approx.html + old_approx_kl = (-logratio).mean() + approx_kl = ((ratio - 1) - logratio).mean() + clipfracs += [ + ((ratio - 1.0).abs() > self.clip_coef).float().mean().item() + ] + + mb_advantages = b_advantages[mb_inds] + if self.norm_adv: + mb_advantages = (mb_advantages - mb_advantages.mean()) / ( + mb_advantages.std() + 1e-8 + ) + + # Policy loss + pg_loss1 = -mb_advantages * ratio + pg_loss2 = -mb_advantages * torch.clamp( + ratio, 1 - self.clip_coef, 1 + self.clip_coef + ) + pg_loss = torch.max(pg_loss1, pg_loss2).mean() + + # Value loss + newvalue = newvalue.view(-1) + if self.clip_vloss: + v_loss_unclipped = (newvalue - b_returns[mb_inds]) ** 2 + v_clipped = b_values[mb_inds] + torch.clamp( + newvalue - b_values[mb_inds], + -self.clip_coef, + self.clip_coef, + ) + v_loss_clipped = (v_clipped - b_returns[mb_inds]) ** 2 + v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped) + v_loss = 0.5 * v_loss_max.mean() + else: + v_loss = 0.5 * ((newvalue - b_returns[mb_inds]) ** 2).mean() + + entropy_loss = entropy.mean() + loss = ( + pg_loss - self.ent_coef * entropy_loss + v_loss * self.vf_coef + ) + + self.optimizer.zero_grad() + loss.backward() + nn.utils.clip_grad_norm_( + self.agent.parameters(), self.max_grad_norm + ) + self.optimizer.step() + + if self.target_kl is not None and approx_kl > self.target_kl: + break + + y_pred, y_true = b_values.cpu().numpy(), b_returns.cpu().numpy() + var_y = np.var(y_true) + explained_var = ( + np.nan if var_y == 0 else 1 - np.var(y_true - y_pred) / var_y + ) + + # TRY NOT TO MODIFY: record rewards for plotting purposes + self.writer.add_scalar( + "charts/learning_rate", + self.optimizer.param_groups[0]["lr"], + global_step, + ) + self.writer.add_scalar("losses/value_loss", v_loss.item(), global_step) + self.writer.add_scalar("losses/policy_loss", pg_loss.item(), global_step) + self.writer.add_scalar("losses/entropy", entropy_loss.item(), global_step) + self.writer.add_scalar( + "losses/old_approx_kl", old_approx_kl.item(), global_step + ) + self.writer.add_scalar("losses/approx_kl", approx_kl.item(), global_step) + self.writer.add_scalar("losses/clipfrac", np.mean(clipfracs), global_step) + self.writer.add_scalar( + "losses/explained_variance", explained_var, global_step + ) + print("SPS:", int(global_step / (time.time() - start_time))) + self.writer.add_scalar( + "charts/SPS", int(global_step / (time.time() - start_time)), global_step + ) + + if global_step % self.num_prints == 0: + clear_output(wait=True) + if self.plot_real_time: + plot_curves(self.env.unwrapped) + + if self.save_model: + model_path = f"runs/{self.run_name}/{self.exp_name}.cleanrl_model" + torch.save(self.agent.state_dict(), model_path) + print(f"model saved to {model_path}") + + self.env.close() + self.writer.close() From ef047e259e1751e7126d3ad952e08f585284ae1c Mon Sep 17 00:00:00 2001 From: AnikenC Date: Wed, 21 Aug 2024 10:14:13 +0800 Subject: [PATCH 2/2] demonstrating 3 9s on example notebook --- .gitignore | 1 + .../noise_q_env_gate_config.yml | 12 +- .../using_general_env.ipynb | 3790 ++++++++--------- rl_qoc/ppo.py | 10 +- 4 files changed, 1827 insertions(+), 1986 deletions(-) diff --git a/.gitignore b/.gitignore index 9b440e3..e282310 100644 --- a/.gitignore +++ b/.gitignore @@ -128,3 +128,4 @@ dmypy.json .idea/ contextual_gate_calibration/runs/ +runs/ \ No newline at end of file diff --git a/gate_level/spillover_noise_use_case/noise_q_env_gate_config.yml b/gate_level/spillover_noise_use_case/noise_q_env_gate_config.yml index 6dc0f74..3aa1e0a 100755 --- a/gate_level/spillover_noise_use_case/noise_q_env_gate_config.yml +++ b/gate_level/spillover_noise_use_case/noise_q_env_gate_config.yml @@ -47,7 +47,7 @@ BACKEND: # Backend configuration (If all set to null, the user needs to specify TARGET: # Target Gate configuration GATE: "CX" # STATE: "0" # Target state (if GATE is null) - PHYSICAL_QUBITS: [ 0, 1 ] + PHYSICAL_QUBITS: [0, 1] ENV: # Environment configuration EXECUTION: @@ -55,13 +55,13 @@ ENV: # Environment configuration N_SHOTS: 1024 # Number of shots for each Pauli N_REPS: 1 # Number of repetitions for the fidelity benchmarking C_FACTOR: 1. # Cost factor for the reward function - BATCH_SIZE: 256 # Number of actions to evaluate per policy iteration + BATCH_SIZE: 32 # Number of actions to evaluate per policy iteration SEED: 100 ACTION_SPACE: - LOW: [ -0.1, -0.1, -0.1, -0.1, -0.1, -0.1, -0.1 ] - HIGH: [ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ] + LOW: [-3.14, -3.14, -3.14, -3.14, -3.14, -3.14, -3.14] + HIGH: [3.14, 3.14, 3.14, 3.14, 3.14, 3.14, 3.14] REWARD: - REWARD_METHOD: "state" # Choose between "fidelity", "state", "channel", "xeb", "cafe" + REWARD_METHOD: "fidelity" # Choose between "fidelity", "state", "channel", "xeb", "cafe" REWARD_PARAMS: # All unused parameters should be set to null (only assign values to parameters used by chosen reward method) NUM_SEQUENCES: null # Number of random sequences to generate for ORBIT or XEB reward DEPTH: null # Circuit depth for the random sequences in ORBIT or XEB reward @@ -75,5 +75,3 @@ ENV: # Environment configuration TOMOGRAPHY_ANALYSIS: "default" # Analysis method for tomography experiment DFE_PRECISION: (1e-3, 1e-3) # Precision tuple (eps, delta) for the DFE analysis TRAINING_WITH_CAL: True - - diff --git a/gate_level/spillover_noise_use_case/using_general_env.ipynb b/gate_level/spillover_noise_use_case/using_general_env.ipynb index f080cbc..0e2cdf2 100644 --- a/gate_level/spillover_noise_use_case/using_general_env.ipynb +++ b/gate_level/spillover_noise_use_case/using_general_env.ipynb @@ -24,7 +24,7 @@ "os.environ[\"KMP_DUPLICATE_LIB_OK\"] = \"True\"\n", "module_path = os.path.abspath(\n", " os.path.join(\n", - " \"/Users/chatt07/Desktop/new_context_env/Quantum_Optimal_Control\"\n", + " \"/Users/chatt07/Desktop/new_context_env/aniket_clones/Quantum_Optimal_Control\"\n", " )\n", ")\n", "if module_path not in sys.path:\n", @@ -56,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -763,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -840,6 +840,18 @@ "Observation Vals: [-1. -0.875 -0.75 -0.625 -0.5 -0.375 -0.25 -0.125 0. 0.125\n", " 0.25 0.375 0.5 0.625 0.75 0.875 1. ]\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] } ], "source": [ @@ -855,8 +867,8 @@ " get_instruction_durations,\n", " gamma=0.3,\n", " circuit_param_distribution=\"moving_discrete\",\n", - " phi_low=-1.5 * np.pi,\n", - " phi_max=+1.5 * np.pi,\n", + " phi_low=-np.pi,\n", + " phi_max=+np.pi,\n", " optimal_error_precision=1e-4,\n", " num_params=17,\n", " discrete_history_length=3,\n", @@ -865,18 +877,30 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[0.]]\n", - "Fidelity stored 0.9999999999999996\n", + "[[-0.875]]\n", + "Fidelity stored 0.8394003544926455\n", "(1, 1)\n", "(32,)\n", - "[[0.]]\n" + "[[-0.875]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" ] } ], @@ -892,7 +916,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -909,7 +933,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -932,7 +956,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -942,7 +966,7 @@ "
" ] }, - "execution_count": 33, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -953,7 +977,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1000,7 +1024,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -1254,6 +1278,7 @@ " self.use_combined_networks,\n", " self.activation_function_str,\n", " self.layer_size,\n", + " self.robust_ppo\n", " ).to(self.device)\n", " self.optimizer = optim.Adam(\n", " self.agent.parameters(), lr=self.learning_rate, eps=1e-5\n", @@ -1485,7 +1510,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -1507,7 +1532,7 @@ " \"anneal_lr\": True,\n", " \"anneal_num_updates\": 400,\n", " \"exp_anneal_lr\": False,\n", - " \"exp_update_time\": 200,\n", + " \"exp_update_time\": 100,\n", " \"plateau_lr\": 1e-6,\n", " \"gamma\": 0.99,\n", " \"gae_lambda\": 0.95,\n", @@ -1523,7 +1548,7 @@ " \"vf_coef\": 0.5,\n", " \"max_grad_norm\": 0.5,\n", " \"target_kl\": None,\n", - " \"robust\": False,\n", + " \"robust_ppo\": False,\n", "}\n", "\n", "ppo_agent = PPO_CleanRL(agent_config, q_env)" @@ -1531,7 +1556,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -1539,9 +1564,9 @@ "output_type": "stream", "text": [ "(3, 17)\n", - "[0.36610833 0.81724011 0.42037057 0.43765815 0.49182518 0.56861233\n", - " 0.73345736 0.5757898 0.85029423 0.57461907 0.58766874 0.5660607\n", - " 0.54962453 0.49839076 0.43894606 0.39062092 0.35642864]\n", + "[1. 0.93141847 1. 1. 1. 1.\n", + " 1. 1. 1. 1. 2.33333333 1.\n", + " 1. 1. 1. 1. 1. ]\n", "(17,)\n", "[-3.14 -3.14 -3.14 -3.14 -3.14 -3.14 -3.14]\n" ] @@ -1556,46 +1581,25 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 22, "metadata": {}, "outputs": [ - { - "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[51], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m q_env\u001b[38;5;241m.\u001b[39mclear_history()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mppo_agent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_training\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "Cell \u001b[0;32mIn[39], line 467\u001b[0m, in \u001b[0;36mPPO_CleanRL.run_training\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 465\u001b[0m clear_output(wait\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 466\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mplot_real_time:\n\u001b[0;32m--> 467\u001b[0m \u001b[43mplot_curves\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43munwrapped\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 469\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msave_model:\n\u001b[1;32m 470\u001b[0m model_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mruns/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexp_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.cleanrl_model\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", - "Cell \u001b[0;32mIn[39], line 32\u001b[0m, in \u001b[0;36mplot_curves\u001b[0;34m(env)\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;124;03mPlots the reward history and fidelity history of the environment\u001b[39;00m\n\u001b[1;32m 29\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 30\u001b[0m fidelity_range \u001b[38;5;241m=\u001b[39m [i \u001b[38;5;241m*\u001b[39m env\u001b[38;5;241m.\u001b[39mbenchmark_cycle \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;28mlen\u001b[39m(env\u001b[38;5;241m.\u001b[39mfidelity_history))]\n\u001b[0;32m---> 32\u001b[0m fig, ax \u001b[38;5;241m=\u001b[39m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubplots\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfigsize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m8.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m6.0\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 34\u001b[0m ax[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mplot(np\u001b[38;5;241m.\u001b[39mmean(env\u001b[38;5;241m.\u001b[39mreward_history, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m), label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mReward\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 35\u001b[0m ax[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 36\u001b[0m fidelity_range,\n\u001b[1;32m 37\u001b[0m env\u001b[38;5;241m.\u001b[39mfidelity_history,\n\u001b[1;32m 38\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCircuit Fidelity\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m 39\u001b[0m )\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/pyplot.py:1760\u001b[0m, in \u001b[0;36msubplots\u001b[0;34m(nrows, ncols, sharex, sharey, squeeze, width_ratios, height_ratios, subplot_kw, gridspec_kw, **fig_kw)\u001b[0m\n\u001b[1;32m 1615\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1616\u001b[0m \u001b[38;5;124;03mCreate a figure and a set of subplots.\u001b[39;00m\n\u001b[1;32m 1617\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1757\u001b[0m \n\u001b[1;32m 1758\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1759\u001b[0m fig \u001b[38;5;241m=\u001b[39m figure(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mfig_kw)\n\u001b[0;32m-> 1760\u001b[0m axs \u001b[38;5;241m=\u001b[39m \u001b[43mfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubplots\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnrows\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnrows\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mncols\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mncols\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msharex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msharey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharey\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1761\u001b[0m \u001b[43m \u001b[49m\u001b[43msqueeze\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msqueeze\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msubplot_kw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msubplot_kw\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1762\u001b[0m \u001b[43m \u001b[49m\u001b[43mgridspec_kw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgridspec_kw\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheight_ratios\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheight_ratios\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1763\u001b[0m \u001b[43m \u001b[49m\u001b[43mwidth_ratios\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwidth_ratios\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1764\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m fig, axs\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/figure.py:861\u001b[0m, in \u001b[0;36mFigureBase.subplots\u001b[0;34m(self, nrows, ncols, sharex, sharey, squeeze, width_ratios, height_ratios, subplot_kw, gridspec_kw)\u001b[0m\n\u001b[1;32m 858\u001b[0m gridspec_kw[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mwidth_ratios\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m width_ratios\n\u001b[1;32m 860\u001b[0m gs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39madd_gridspec(nrows, ncols, figure\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mgridspec_kw)\n\u001b[0;32m--> 861\u001b[0m axs \u001b[38;5;241m=\u001b[39m \u001b[43mgs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msubplots\u001b[49m\u001b[43m(\u001b[49m\u001b[43msharex\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharex\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msharey\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msharey\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msqueeze\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msqueeze\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 862\u001b[0m \u001b[43m \u001b[49m\u001b[43msubplot_kw\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msubplot_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 863\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m axs\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/gridspec.py:283\u001b[0m, in \u001b[0;36mGridSpecBase.subplots\u001b[0;34m(self, sharex, sharey, squeeze, subplot_kw)\u001b[0m\n\u001b[1;32m 281\u001b[0m subplot_kw[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msharex\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m shared_with[sharex]\n\u001b[1;32m 282\u001b[0m subplot_kw[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msharey\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m shared_with[sharey]\n\u001b[0;32m--> 283\u001b[0m axarr[row, col] \u001b[38;5;241m=\u001b[39m \u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43madd_subplot\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 284\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcol\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43msubplot_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 286\u001b[0m \u001b[38;5;66;03m# turn off redundant tick labeling\u001b[39;00m\n\u001b[1;32m 287\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m sharex \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcol\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mall\u001b[39m\u001b[38;5;124m\"\u001b[39m]:\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/figure.py:710\u001b[0m, in \u001b[0;36mFigureBase.add_subplot\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 708\u001b[0m args \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mtuple\u001b[39m(\u001b[38;5;28mmap\u001b[39m(\u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mstr\u001b[39m(args[\u001b[38;5;241m0\u001b[39m])))\n\u001b[1;32m 709\u001b[0m projection_class, pkw \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_process_projection_requirements(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 710\u001b[0m ax \u001b[38;5;241m=\u001b[39m \u001b[43mprojection_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 711\u001b[0m key \u001b[38;5;241m=\u001b[39m (projection_class, pkw)\n\u001b[1;32m 712\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_add_axes_internal(ax, key)\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:681\u001b[0m, in \u001b[0;36m_AxesBase.__init__\u001b[0;34m(self, fig, facecolor, frameon, sharex, sharey, label, xscale, yscale, box_aspect, forward_navigation_events, *args, **kwargs)\u001b[0m\n\u001b[1;32m 678\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mset_axisbelow(mpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.axisbelow\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m 680\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_rasterization_zorder \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m--> 681\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mclear\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 683\u001b[0m \u001b[38;5;66;03m# funcs used to format x and y - fall back on major formatters\u001b[39;00m\n\u001b[1;32m 684\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfmt_xdata \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:1391\u001b[0m, in \u001b[0;36m_AxesBase.clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1389\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcla()\n\u001b[1;32m 1390\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1391\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__clear\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:1307\u001b[0m, in \u001b[0;36m_AxesBase.__clear\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1304\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlegend_ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1305\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcontainers \u001b[38;5;241m=\u001b[39m []\n\u001b[0;32m-> 1307\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrid\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Disable grid on init to use rcParameter\u001b[39;00m\n\u001b[1;32m 1308\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mgrid(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_gridOn, which\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.grid.which\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m 1309\u001b[0m axis\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.grid.axis\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m 1310\u001b[0m props \u001b[38;5;241m=\u001b[39m font_manager\u001b[38;5;241m.\u001b[39mFontProperties(\n\u001b[1;32m 1311\u001b[0m size\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.titlesize\u001b[39m\u001b[38;5;124m'\u001b[39m],\n\u001b[1;32m 1312\u001b[0m weight\u001b[38;5;241m=\u001b[39mmpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes.titleweight\u001b[39m\u001b[38;5;124m'\u001b[39m])\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axes/_base.py:3276\u001b[0m, in \u001b[0;36m_AxesBase.grid\u001b[0;34m(self, visible, which, axis, **kwargs)\u001b[0m\n\u001b[1;32m 3274\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mxaxis\u001b[38;5;241m.\u001b[39mgrid(visible, which\u001b[38;5;241m=\u001b[39mwhich, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 3275\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m axis \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mboth\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[0;32m-> 3276\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43myaxis\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgrid\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvisible\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwhich\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwhich\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axis.py:1732\u001b[0m, in \u001b[0;36mAxis.grid\u001b[0;34m(self, visible, which, **kwargs)\u001b[0m\n\u001b[1;32m 1729\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m which \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmajor\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mboth\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[1;32m 1730\u001b[0m gridkw[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgridOn\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m (\u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_major_tick_kw[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgridOn\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m 1731\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m visible \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m visible)\n\u001b[0;32m-> 1732\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_tick_params\u001b[49m\u001b[43m(\u001b[49m\u001b[43mwhich\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmajor\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mgridkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1733\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axis.py:999\u001b[0m, in \u001b[0;36mAxis.set_tick_params\u001b[0;34m(self, which, reset, **kwargs)\u001b[0m\n\u001b[1;32m 997\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_major_tick_kw\u001b[38;5;241m.\u001b[39mupdate(kwtrans)\n\u001b[1;32m 998\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m tick \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mmajorTicks:\n\u001b[0;32m--> 999\u001b[0m \u001b[43mtick\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_apply_params\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwtrans\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1000\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m which \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mminor\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mboth\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n\u001b[1;32m 1001\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_minor_tick_kw\u001b[38;5;241m.\u001b[39mupdate(kwtrans)\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/axis.py:372\u001b[0m, in \u001b[0;36mTick._apply_params\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 368\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlabel2\u001b[38;5;241m.\u001b[39mset(rotation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_labelrotation[\u001b[38;5;241m1\u001b[39m])\n\u001b[1;32m 370\u001b[0m label_kw \u001b[38;5;241m=\u001b[39m {k[\u001b[38;5;241m5\u001b[39m:]: v \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 371\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabelsize\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabelcolor\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlabelfontfamily\u001b[39m\u001b[38;5;124m'\u001b[39m]}\n\u001b[0;32m--> 372\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlabel1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mlabel_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 373\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlabel2\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mlabel_kw)\n\u001b[1;32m 375\u001b[0m grid_kw \u001b[38;5;241m=\u001b[39m {k[\u001b[38;5;241m5\u001b[39m:]: v \u001b[38;5;28;01mfor\u001b[39;00m k, v \u001b[38;5;129;01min\u001b[39;00m kwargs\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 376\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m _gridline_param_names}\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/artist.py:147\u001b[0m, in \u001b[0;36mArtist.__init_subclass__..\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_autogenerated_signature\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 140\u001b[0m \u001b[38;5;66;03m# Don't overwrite cls.set if the subclass or one of its parents\u001b[39;00m\n\u001b[1;32m 141\u001b[0m \u001b[38;5;66;03m# has defined a set method set itself.\u001b[39;00m\n\u001b[1;32m 142\u001b[0m \u001b[38;5;66;03m# If there was no explicit definition, cls.set is inherited from\u001b[39;00m\n\u001b[1;32m 143\u001b[0m \u001b[38;5;66;03m# the hierarchy of auto-generated set methods, which hold the\u001b[39;00m\n\u001b[1;32m 144\u001b[0m \u001b[38;5;66;03m# flag _autogenerated_signature.\u001b[39;00m\n\u001b[1;32m 145\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m--> 147\u001b[0m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mlambda\u001b[39;00m \u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: \u001b[43mArtist\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 148\u001b[0m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mset\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39mset\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__qualname__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.set\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/artist.py:1224\u001b[0m, in \u001b[0;36mArtist.set\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 1220\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mset\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 1221\u001b[0m \u001b[38;5;66;03m# docstring and signature are auto-generated via\u001b[39;00m\n\u001b[1;32m 1222\u001b[0m \u001b[38;5;66;03m# Artist._update_set_signature_and_docstring() at the end of the\u001b[39;00m\n\u001b[1;32m 1223\u001b[0m \u001b[38;5;66;03m# module.\u001b[39;00m\n\u001b[0;32m-> 1224\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_internal_update(\u001b[43mcbook\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mnormalize_kwargs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m)\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/cbook.py:1834\u001b[0m, in \u001b[0;36mnormalize_kwargs\u001b[0;34m(kw, alias_mapping)\u001b[0m\n\u001b[1;32m 1830\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(alias_mapping, \u001b[38;5;28mtype\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(alias_mapping, Artist)\n\u001b[1;32m 1831\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(alias_mapping, Artist)):\n\u001b[1;32m 1832\u001b[0m alias_mapping \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(alias_mapping, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_alias_map\u001b[39m\u001b[38;5;124m\"\u001b[39m, {})\n\u001b[0;32m-> 1834\u001b[0m to_canonical \u001b[38;5;241m=\u001b[39m {alias: canonical\n\u001b[1;32m 1835\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m canonical, alias_list \u001b[38;5;129;01min\u001b[39;00m alias_mapping\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 1836\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m alias \u001b[38;5;129;01min\u001b[39;00m alias_list}\n\u001b[1;32m 1837\u001b[0m canonical_to_seen \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1838\u001b[0m ret \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;66;03m# output dictionary\u001b[39;00m\n", - "File \u001b[0;32m~/Desktop/new_context_env/lib/python3.9/site-packages/matplotlib/cbook.py:1834\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 1830\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m (\u001b[38;5;28misinstance\u001b[39m(alias_mapping, \u001b[38;5;28mtype\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28missubclass\u001b[39m(alias_mapping, Artist)\n\u001b[1;32m 1831\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(alias_mapping, Artist)):\n\u001b[1;32m 1832\u001b[0m alias_mapping \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(alias_mapping, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_alias_map\u001b[39m\u001b[38;5;124m\"\u001b[39m, {})\n\u001b[0;32m-> 1834\u001b[0m to_canonical \u001b[38;5;241m=\u001b[39m {alias: canonical\n\u001b[1;32m 1835\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m canonical, alias_list \u001b[38;5;129;01min\u001b[39;00m alias_mapping\u001b[38;5;241m.\u001b[39mitems()\n\u001b[1;32m 1836\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m alias \u001b[38;5;129;01min\u001b[39;00m alias_list}\n\u001b[1;32m 1837\u001b[0m canonical_to_seen \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 1838\u001b[0m ret \u001b[38;5;241m=\u001b[39m {} \u001b[38;5;66;03m# output dictionary\u001b[39;00m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model saved to runs/PPO_CleanRL__Test PPO CleanRL__1__1724204973/Test PPO CleanRL.cleanrl_model\n" + ] } ], "source": [ @@ -1605,17 +1609,15 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[-1. -0.9 -0.8 -0.7 -0.6 -0.5\n", - " -0.39999998 -0.3 -0.19999999 -0.09999996 0. 0.10000002\n", - " 0.20000005 0.30000007 0.39999998 0.5 0.6 0.70000005\n", - " 0.8000001 0.9 1. ]\n" + "[-1. -0.875 -0.75 -0.625 -0.5 -0.375 -0.25 -0.125 0. 0.125\n", + " 0.25 0.375 0.5 0.625 0.75 0.875 1. ]\n" ] } ], @@ -1625,1890 +1627,1797 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 24, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Fidelity stored 0.9985995241871047\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9989732950258189\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9991835665874736\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9991081664874701\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9993452535454714\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9991510376887669\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9995420779042276\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9995453289505949\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9995466226025103\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9996009987598009\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997088713602433\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997319127536364\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997183285770944\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997444975389426\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9996295721608842\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997271981655309\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997616966267021\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997601831590299\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997367445139802\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997647632355686\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997938771814829\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998158747724952\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998578400656049\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998197848648662\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.999810771690542\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998122971266185\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998038140052423\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998304602814778\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997426172712619\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.999815431793327\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997965279126374\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997830233255156\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997172481636374\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9996888193529829\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997247064895984\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9998288664455286\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997487795034264\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997905559265658\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9996899007498741\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.999706906434308\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997365253398192\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997472124344526\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997632480785048\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9996653711909514\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9997019581148314\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9995417912820541\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9994268507614065\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9991504418737474\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9991466368245276\n", - "(1,)\n", - "(32,)\n", - "Fidelity stored 0.9986412498753037\n", + "Fidelity stored 0.9991098814879024\n", "(1,)\n", - "(32,)\n", - "Fidelity stored 0.998531131165249\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9993526831500384\n", "(1,)\n", "(32,)\n" ] - } - ], - "source": [ - "# Evaluating Policy across Parameter Space\n", - "\n", - "import torch\n", - "\n", - "obs_linspace = np.linspace(-1.0, 1.0, 51)\n", - "\n", - "mean_reward = np.zeros_like(obs_linspace)\n", - "std_reward = np.zeros_like(obs_linspace)\n", - "mean_actions = np.zeros((len(obs_linspace),) + q_env.action_space.shape)\n", - "std_actions = np.zeros((len(obs_linspace),) + q_env.action_space.shape)\n", - "\n", - "for i, test_obs in enumerate(obs_linspace):\n", - " test_obs, _ = ppo_agent.env.reset(seed=ppo_agent.seed, override_obs=test_obs)\n", - " batch_test_obs = np.tile(test_obs, (ppo_agent.num_envs, 1))\n", - " with torch.no_grad():\n", - " action, logprob, _, value = ppo_agent.agent.get_action_and_value(\n", - " torch.Tensor(batch_test_obs)\n", - " )\n", - " cpu_action = action.cpu().numpy()\n", - " cpu_action = np.clip(\n", - " cpu_action,\n", - " ppo_agent.env.action_space.low,\n", - " ppo_agent.env.action_space.high,\n", - " )\n", - "\n", - " played_action = cpu_action\n", - " # played_action[:, 0] = 0.\n", - " # played_action[:, 1] = 0.\n", - " # played_action[:, 2] = 0.\n", - " # played_action[:, 4] = 0.\n", - " # played_action[:, 5] = 0.\n", - " # played_action[:, 3] = -0.5 * q_env.gamma * test_obs * np.pi + 0.25\n", - " # played_action[:, 6] = 0.5 * q_env.gamma * test_obs * np.pi + 0.25\n", - "\n", - " mean_actions[i] = np.mean(played_action, axis=0)\n", - " std_actions[i] = np.std(played_action, axis=0)\n", - "\n", - " next_obs, reward, terminations, truncations, infos = ppo_agent.env.step(\n", - " played_action\n", - " )\n", - " mean_reward[i] = np.mean(reward)\n", - " std_reward[i] = np.std(reward)" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "3.835838404566957\n" + "Fidelity stored 0.9994870384067535\n", + "(1,)\n", + "(32,)\n" ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "mean_fidelity = 1. - 10**(-mean_reward)\n", - "std_fidelity = 1. - 10**(-std_reward)\n", - "\n", - "obs_rad_linspace = obs_linspace * np.pi\n", - "\n", - "print(np.max(mean_reward))\n", - "\n", - "plt.errorbar(obs_rad_linspace, mean_reward, yerr=std_reward, fmt=\"o\", label='Evaluated Policy Rewards')\n", - "plt.axvline(x=obs_rad_linspace[np.argmax(mean_reward)])\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "torch.Size([1, 32, 1])\n" + "Fidelity stored 0.9993436619301848\n", + "(1,)\n", + "(32,)\n" ] - } - ], - "source": [ - "print(ppo_agent.obs.shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGgCAYAAAB45mdaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB6sElEQVR4nO2deXwU9f3/X7O72c1BEkAgCRAOBTnkBsXgAVUUkar0sNbaYq3aarHV6q9WbKutVuO31qptLWrV0moprVqx9UIE8QJBEJRDEeRGEu7c2SS78/sjmd3PzHxmdmaPbJJ9PR+PPNid+cxnPjO77Oc17+ujqKqqghBCCCEkTXjSPQBCCCGEZDYUI4QQQghJKxQjhBBCCEkrFCOEEEIISSsUI4QQQghJKxQjhBBCCEkrFCOEEEIISSsUI4QQQghJKxQjhBBCCEkrFCOEEEIISSsJiZH77rsPiqLgpptusm337LPPYvjw4cjOzsbo0aPxyiuvJHJaQgghhHQhfPEe+MEHH+Cxxx7DmDFjbNutXLkSl19+OcrLy/HlL38ZCxcuxOzZs/Hhhx9i1KhRjs4VDofxxRdfID8/H4qixDtkQgghhLQjqqqipqYGffv2hcdjY/9Q46CmpkYdOnSounTpUnXq1KnqjTfeaNn2G9/4hjpr1izdtsmTJ6s/+MEPHJ9v7969KgD+8Y9//OMf//jXCf/27t1rO8/HZRmZO3cuZs2ahenTp+M3v/mNbdtVq1bh5ptv1m2bMWMGFi9ebHlMMBhEMBiMvFfbFhbeu3cvCgoK4hkyIYQQQtqZ6upqlJaWIj8/37adazGyaNEifPjhh/jggw8cta+oqEBRUZFuW1FRESoqKiyPKS8vx69//WvT9oKCAooRQgghpJMRK8TCVQDr3r17ceONN+If//gHsrOzExqYHfPmzUNVVVXkb+/evSk7FyGEEELSiyvLyLp163Dw4EFMmDAhsi0UCuHtt9/Gn/70JwSDQXi9Xt0xxcXFqKys1G2rrKxEcXGx5XkCgQACgYCboRFCCCGkk+LKMnLuuedi48aN2LBhQ+Rv0qRJuOKKK7BhwwaTEAGAsrIyLFu2TLdt6dKlKCsrS2zkhBBCCOkSuLKM5Ofnm9Jx8/LycMIJJ0S2z5kzB/369UN5eTkA4MYbb8TUqVPxwAMPYNasWVi0aBHWrl2Lxx9/PEmXQAghhJDOTNIrsO7ZswcHDhyIvJ8yZQoWLlyIxx9/HGPHjsVzzz2HxYsXO64xQgghhJCujaJqebMdmOrqahQWFqKqqorZNIQQQkgnwen8zbVpCCGEEJJWKEYIIYQQklYoRgghhBCSVihGCCGEEJJWKEYIIYQQklYoRgghhBCSVihGCCGEkE5EKKziqXd3YtP+qnQPJWm4XrWXEEIIIenj+Q/34a6XtgAAdt03K82jSQ60jBBCCCGdiK5kEdGgGCGEEEI6EUq6B5ACKEYIIYSQToSiROVIKNzhV3RxBMUIIYQQ0kmpbmhO9xCSAsUIIYQQ0omob2qJvD5OMUIIISQdHK9vwn8/+gKNzaF0D4WkgeoGQYzUN0FVVdQGW2yO6PhQjBBCSCfjyqfW4Mf/XI/7Xv003UMhaaC6MWoNOd7QjOueWYfxd72O/ccbItsbm0P46bMf4dWNB9IxRNdQjBBCSCfjo32tqZ2LN+xP80hIPKiqiv9+9AW2VdbEdbwoRqobmrFkcyWaQyqeX7cvsv0fq/fg2XX7cP0/Pkx4vO0BxQghhHRSQqGukUnR2akNtmD9nmNQVWefx/JPD+LH/1yP8x58O67zVQlxIodqgpHXPXKzIq8P1jTG1Xe6oBghhJBOSsjh5EdSg6qq+PX/NmPUnUvwlT+vxEsfm10iobCKr89fibkLoxaK1TuPJnReMWZE7Otvq3Zjz5F6AIBH6VzVSChGCCGkk9LSRWpMpJOWUBhLNlfgcG0wdmMDH++rwl/f2xV5/+KGL0xtdhyqxdrdx/DyxwcQbGkNOK5pjD/YtKklrHPTLN1SGXm9/WAtZv3hHQCAp3NpEYoRQgjpLGzYexy//t/myPuuUvAqnfz1vV34wdPrcMmf3ovZds3Oo7rJ/2hdk26/T6IAsrO8kdfH61tFRF0CmS/7jzdAVQGvR0F2lnkKr2nrW7SMOHUfpROKEUII6STMfuQ93ZN4qsWIqqpY9kkl9h6tT+l5EiEUVvGfD/fFPcZXNrW6VsRMFBmqquIbj63CtX9fiwNVrW2NqdVer7054khtq3hJJA1395E6AMCQ3t3w9+9NlrYJtoR0VVqDLeG4z9deUIwQQkgX4lhdE5Z9UomWUOIT0Iqth3D139birN++mYSRpYZn3t+Nm//9Ec594K24jm9xGAQsCgjNItLYohcjMsuIaJTQjktEjGiiq7RnLk4b3BOPfnuiqc3Ow3U6N019U8evR0MxQgghXYhvPLYKV/9tLRas3JVwX2t2JRZoKWPv0Xpc+/e1+CBJfS/79CAAoMmB+Np5uA7rduvP6zTuRnOxiDQ06c/plYiRsKBGjta3ipFE3DS72wJUB56QCwC4YFQxrpt6kq7N5v3VaBKsITsO1cZ9vvaCYoQQQroQ2w62TjyyYMqOwC3//ghLt1Ti0kdXJaW/ehcT+5d+twJfm78q4uoA4NiCdKw+Gh+iuWfEsuyA3DKiEyNtQbKJiJE9bZaRAT1zI9vy/F5dm9U7j6CxOXpdX390VUw3VLqhGCGEkC5IMuJJ4knIUFUV1/xtLX767EfS/dvjfEpfuf0wvvzHd/DxvuO67U5cEKqq4s2tB6NjOBgdg9P7dEywjGjnrDZkxXg9rVPq7iN1EcERTrKbJiJGToiKkRyDGFm144jJhfT+50fiPmd7QDFCCCFxcqCqQZdmmQoam0NxxX+Ek5BBEU+pis8P1eGNTyrx7Lp90oneKrNDVVXb6/zWE6uxaX81rnhitW670Toh478ffYGr/vpB5L14Xc7dNFHLSIMmRgyL1Hk9wPaDNZh6/4pIiq14vUcSFCOqqkotI2LGDgDsPdqAI4ZU5byAvk1Hg2KEEELi4GBNI8rKl2PMr15P2TkO1wYx4e6luPpvay3bNFhYBtKV9iuKoGaJuLAa1Q//8SHO/L83Y07UxhoddQ4sI8s/Pah7rwg2H6dCT0zjbWjWLCN6MeLzePDutsMAgF1H6hEOqzrLiObqEV0objhS14T6phAUBejfIyeyPddvFhoHa4x1Uzp24RGKEUJIxvBpRXXSLBnr9xxPSj92/OuDvahvCuGtzw5ZttGewI2kqzqreFqpGJEMKxxW8eqmClRUN2LNTnfuBCsxZksclhHRTdPYHMLWihrsPFyna+P1KDr3yb5jDTpxlmhWixa8WlKQjYAvKkByssxi5JBBjGhxLrLPpCNAMUIIyQjW7jqKCx56B1+6f0VS+msPy8OWA9WR11bujR2GCVEjnCbLiArRMmIeg8x9dESwOvTMC7g6X50DN43xlAqAjfuqMO3+NyUWBDmim+azylrMeOhtkyD1eRRdfY+tlTW66zXWJXHKgaoGXL3gA9y4aD2A1rRekWwHlpH6phA+2HUUp9yxBH95e0dc40glFCOEkIxgyeYKAPqJLxHclGLfcagW/1i92/Kp9Fhdky724eN9x/Hm1oP4VBAjs/7wrqvxxbKM1DQ2m+IKjCgG076T+AyxbsfE3yzF9oOGlWkllpMvhEwPr8tAFScGIKMAOlDViIv+9C52HXFeKE1M7f1wzzFpG49H0V3fZ5U1CAsfebzumYWr92DZpwex71jrfRrcK0+3P1uwkhQVtIq5JkOhs/qmFlzxxGo0hcK455VP4hpHKqEYIYRkBMm2TrsJKj3ngbfw8xc24Z9r9pj2NTSFMO13K3DaPcvwSZv4uPhP7+Gqv36Azw9FrR6ilcQJ4RjDG/2r1zHxN2/Yuq1EXfDqxgMYeccSPPXuTtt+RcGlqsAdL27W7ReFgRb/IYoRJ4G3P3vuY8t9jc0hVFQ14o/LtuGs3y7HwWrz6rXz/rMx5jmMBIXsFCurmM+j6Ma/41CdyTIST2n2SsM1GMWIWN+kpDAHMhqaQiaB0pGgGCGEZAShWLOzS+JZpG7jvirTtiN1QVQ1NKM22JJU87lTN5KY5mrHj/7Z6iK466Uttu2ME544GYfCqi7gVMtGEWtgPLduH6okBcZE/rV2r+W+c363AqeXL8MDSz/D3qMNeOztHZZBs0Ze3XgAp97zBq58ag1e+vgL/HLxpsj1iPdTK+tuxOtRdAGru46YxYgb996He45h9iPvmWrGDDKIEbHP4oJsaV+fCynVA0/IlbZJJ750D4AQQtqDWG6LumALVn1+BKcO6onC3KzY/cUhRgpyzP2K/VQ3NidtUTOnAaxOT+fxKJGiGWt2HsUpfQuQF4hOIUfrmtAzz2+KE/F5os+8NQYrjGaV+eJ49Mn/6fd3Y9vBGiz6fhkO1wbxk39tcCyYAOCLKrMlxOk9XbhmDw7VBPFWzaFI0HBxYTbmfmmITnxarfCrQG8Z2XW4TidOGppDrkTsV/+8Urr9RIMYKSmMCpAeefLv7mJB0GR5O54douONiBBCUoA46W/5otpkvr9/yVZc8/e1OPXeNyIFq7ZV1uAfq3frjj1Y04htlTW2k8qSzRX4w7JtJldOoUSMiP0EW8JxiZx/r92LlZ8f1m2zm4D1+9yf7xuPrcJ3nlwd6evmf2/AhLuX4rl1+0xxMT5h8bjqBn3MifbeWJH0/R2tJdvLX/kU72w7jAMOBIaxCqlGltfjWHC9s+2wadsbn7Su0hsyfE4AcErfApT2jLpFwqpqqisi1iJpbA47zmb584rtlvuMAayDeuVh/hUT8O8flKEgW/8d+/KYEtPxbqrWthe0jBBCMgIxsPLCtnTYXffNimyraJvwmlrCqKxuxIm9u+G8B98G0BpU+c3TBgAATrtnGQDg+2efaHmuHzy9DkDrJPuT806ObC/I9kFVVfzv4wMY1bcAz67bB7/wlBpsDsfl/rm1LYZCvB47USPuUtVWS0dxQbYuLRXQV6YwTv4ftmWSLPukEv/5cD+A1jLk00cU6dqJJdKN68ccqWu1MFhZcY7WWQfYNoXCugDbHL9XGsfj9zkXIzI015psQb1T+hZg9c7oWjdhVV9XBICu9HxDc0hnObKK1Q22hPDb17bqtnk9ChZcdSoCPq+pyBkAzBzdKjqMa/70yPWb2jqpzdLeUIwQQjIC2YSnqmokFbNeSLs0BlF+vL8K3zQcK8Z/iP2IT75/W7ULV50xOPI+N+DDa5sq8OO2+AsjO4/U4cz/W+7sgiSohvgMK8Tre/7Dffjnmr0Y3a8Q//vRmfqGwmxpNaGv2RXNLAmFVFPMiOimMQoarW6GVRqyYpNZs3Fflc5NFPB5URc0T7IBn0eXbuyWlrCKY3VN0u9Prl8/hbZaRvRtGoQMmqaWsO7+WF3d1ooa07YeuVk4a2jvmOMtyNaPqXe+OVW6Ltii+852BOimIYRkBLLJuUEQIA1C2qrxAVt7uhf7EDMYVBV4ccN+nP/gW1grTM6NzWEcqBIWKFOBdbvlaaFAa6GqwxbBkU4QrSri5TY2h7DvWDSNVbyOf65pDQbduN8cXCtiNZ2/tz3q2qhubLZ10xg/gt8v/QzbKmviKtD29UdXYebD0YJvXo+CmqA58NXvwk0DmOMxgNbVi2XfH2OJ9VDYLGSN1ppaYYxWevFjSaBzfnbsOCYA6C5YQgI+j86N1K976+uWsOpoleP2xJUYmT9/PsaMGYOCggIUFBSgrKwMr776qmX7BQsWQFEU3V92tjzSlxBCUolsMhGzIsSnamNbj2Y9EQSLxyNOsipuXLQBn1XW4rpn1umOFSf5RJ7QnRAUnrpDYRV/XLYN3//7WpzzuxU48//ejKQOO56chYayGJSKqkZs/iKacrzzcJ2pXLvoppF9Bj94Zp3lpOwWWSl5v8/j6q7nS+J61uw8KnWfGS0jqqqaxIhRnBkX15PdV+1zEu9dt4AzR8aJvaNiqrRnrm6Mo/oVRF5/sNNaFKcDV2Kkf//+uO+++7Bu3TqsXbsW55xzDi655BJs3rzZ8piCggIcOHAg8rd79+6EB00IIW6RTYSy9UYA89OtNimI5bzFSURsXWVYPE2ssxFW41t8ziliIGgorOKBpZ/h9S2VkQyTpVsq28bhbHoWb5lMMLy+pUL3/vNDdbjzv/r5wCu4aWTn3XGoDs2S+hfBlpCr1VTCqmoKhAUAj+JCfAHIlcRj7DxcJ00NN64JEwqb3TRNhliTWoMYkd1XrcDauSP6RLY5XejupN7dIq+zszy6MY4t7R55/e0nV8ddETYVuBIjF110ES688EIMHToUJ598Mu655x5069YN77//vuUxiqKguLg48ldUVGTZlhBCUoVUjAglvkWrh3HS9ErESKONeLEiGSvp2iFaBmRmeO06nLpFYgXTvrapVYzIMjY0fAYLEgD06hbQFe76pMJc0O14jFojRlTVvIgeoJWkd37fZZP+gapGadG8PFPMSGw3jXGMsu+E9jn2yY96EroFnLlpxODWhqZQxKoHAOcM76NrK7tf6SLumJFQKIRFixahrq4OZWVllu1qa2sxcOBAlJaWxrSiaASDQVRXV+v+CCEkEWQ/+kfb3DQVVY2orI5mbhiFizaJi0/eYmlvpxqj1TKSPNOIcYE0mWVARBMGqsNwgVjiScskuXRSqfU5JTEjAZ8Hy26eismDewKIBrKKXPfMOldVZ8OqKnXTyKwVduT4ze6QiqqGiGXkJMENkmsQLrJsGqObxlhrRXaPtc9RDD7Nz3aeb6LFvcwcVaIrcDasKF/XrtNaRgBg48aN6NatGwKBAK677jq88MILGDlypLTtsGHD8NRTT+HFF1/EM888g3A4jClTpmDfvn225ygvL0dhYWHkr7TU+otOCCFWbNpfhQeXfoZGi2JTx+qbUBtswenly3TbnbhpYllGLm9LBRZJVkEzDaObwOgCMKKJKiuRUVHViOufWYc1bSJDls4qEgqrOLmoG07pW2DZRmYZ8XoUeDwKZtlYVNbvOS6tL2KFlZumJewuUkd002h1YY7VN0diik4d1DOy32wZUU2fsdFNY7RGyD6KqGUkKkacxowAwDPXTMbds0dh7peGoH+PXCyeewbeu+0ckxDu1GJk2LBh2LBhA1avXo3rr78eV155JbZskZcHLisrw5w5czBu3DhMnToV//nPf9C7d2889thjtueYN28eqqqqIn9791qX/iWEECu+/Md38fCybXjkze3yANa6Jry68YBpu9Ekr8U9iCvENraIYsR87v49cnDa4J66bcleSddYb+JbT6y2be/zKAiHVbwsuWag1Rrx6qYKXPnUGgDOSuj3zPPbPrXrYkbarl/TJxeP7Zu0GJrK6iB+9rx5zZlQOOxKBIrWjpLC7Ij1SStZP2FAj8j+gE8/hcpSe02WkaALN01BVIwYhacdfbvn4DunD0RO2zHjSrtHMmlEGjqQGHFdZ8Tv92PIkCEAgIkTJ+KDDz7Aww8/HFNgAEBWVhbGjx+P7dutK8sBQCAQQCDgbhlpQgixYssX1dKn/KqG5khQp4g5ZqT13wadZSRs2R5oTSn1G8puq7CuLREPfp+750mv14O7X96Cv763S7p/w97jAFonqWfX7nVUgM3rURDwWU+UMjeNlonUPdePLI8npWmmri0jwqSf4/eipDAbOw5HC5cNKYoGiGYZ7r8stTe2m8Y8BlnMiJi9lQjZWZ7Id7ehAxU/S7jOSDgcRjBovwy1RigUwsaNG1FSYm2aI4SQVCAL2gyFVFTWmH+/wmG9uf13r3+GZ97fbYgZCenaG/H7PMjy6ieQJBtGTP3HwqsolkLEyE+f+zhSldYOTwzThqwQm3iMN0mTrBWhsDmOww4xDifX79VZJ4BWkfmHy8fjB2efiIkDepiq1BrPZRTBTgJYte9Zz7xozZBk3ab/3RAtbNdpLSPz5s3DzJkzMWDAANTU1GDhwoVYsWIFlixZAgCYM2cO+vXrh/LycgDAXXfdhdNPPx1DhgzB8ePHcf/992P37t245pprkn8lhBBigaLIBUNIba2uKdtudOv8YvEm/PriUyLvg4JlRLSSaGR5PaYFyZIdM+LWMmJ8Ko/FJw4CSLU4hLGl3fFRm2VFRDQMaNcvTqypFiNPvrtTF+ujUVQQ0AUta+MSXV85WT5dzAvQOt6Lx/bFxWP7th4j7F/0wV5sMyzqZ7T6GLOEjMHEwZZoyXixwqw3Sf6soUX5mDiwB9btPib93qYLV9/kgwcPYs6cORg2bBjOPfdcfPDBB1iyZAnOO+88AMCePXtw4EDUF3ns2DFce+21GDFiBC688EJUV1dj5cqVlgGvhBCSKmQuh1DYQoyEVXy077hpu1hDQ5xkrIptGc34YVVNqp/G7eqrbicf2Qq4RjTjzGPfnijdrz35v7vtcCSmpT0tIzIhArRmmhjxehQEDJYR4+KGxvE+dNk43XtjhV1jam9FdYPuvdEyIgYhi0GrqcjC6kgBrK4sI08++aTt/hUrVujeP/jgg3jwwQddD4oQQpKNzBze2BwyBRQCrammxuJddog1SjT8Pg8CXqMYgW5xt0RxK0ZSYZbXhIWVqAiFVXxyoBrffnK16Ri741KNMfgUaJ3ws4XtuX4vCmKIkTH9u+P2C4fj3lc+lZ6n2eCmMbq+jN9LLWsnJ8urO1ePXGd1RpygWX86rZuGEEI6I298clC6/YjFOjBbvnBX20hqGZG4aZpawvis0rwIWrzIJlQ7ZKIpUZQYYiSsqro1ZIxtO5IY8SqKzk2T6/eZLCNGtw2gzxgyYnTTGNceMhrstPV1NBfN3ZecguWfHoysGp0MtCybjhTASjFCCMlYDtXKg++9LgNDZavF+n0Ksnz6fn6/9DNX/cbCrWUkFRU3tSFYaQqZRUoXM5KmlWMDkrLvxpiRk4u6odmiAJ7xOCuMbhojxjgi7bukpUt/p2wQvlM2yLYPt+RktX5oHckywlV7CSEZy+G2TJrBvfLw5ysmRGoxuJ0gpW4ar9e1WHCL22watwGsTtBcLlYxDbL6LkoMN82XhvVO0uiskVlGPIqi2z66fyG6mywj8uOs0Nw0xjRvDePt0TJpnK5FEw/ZHTBmhGKEEJKxaPEiJ+T5ceHoEvTr0SZGXLoOrAJYrSagZOG3qe8hw7hibDKIHTNi3hbLTZNqEQdYWEY8ii59++SifJObRuaRsasBotUZEUu7ixgtRxXVrTElvbqlrtZWRwxgpRghhHQZmlrCuO7pdXjy3Z2ujuveFhzojTGxWlEvcdNkeZW0WEYundgf//6BfL2wVLhptIk4bjeN5EC3KcvxILeMAGcO7YUTe+fhu1MGIcvrkcSMyI+zQosZMdYr0TDen71HW9fpKe2RK2ueFBjASgghKeTZdXvx2uYKvLa5AlefOdjxcdrkp80zMteCHZapvSkWI7IAxPsvHWvZPjVuGu3f5Llp2sUyYuGmyc/OwvJbpkW2xUrtBezdepplpEeuX7rfqNX2HmtN/S3taS7fniyiAaydtM4IIYQ4JdkFvpyw3VBwyinaRKr9ayzhLWJcKReQx4wEfB5TAGuysVvV9qsT+pm2pcQyYrh3Rlok69uIk7dsIncbCyOiFSOLhayEvczd4iSbxi5mRKvA6vMoUiFjFGvtYRmhm4YQkhE89tbnmPSbN/D5oVZxsOyTSky+9w28t/1wSs9bWe18lVcRbZLQ/rWzjHSX1Huolbpp2iFmxKb/+746Bk9ffZpuW3UKA1itXBVNLRI3jTDsZLtpnB5r5aYxkmNYoE6aTeMgZsSjKNLPS3PTqKqKVzceiKwPVNozlW4aZtMQQjKA8lc/xZG6Jjzw+lYAwNV/W4vK6iCuiLGqbKJ8cTxOMaLFikQsI9ZixPikDEC6dL3f50l57MNvvz4Gkwb2kO7z+zyYPPgE3bZUGKus3DQXnFIMwFxnw9g22W4ap1YVn6SdzEpjFC1uU3u175LHIxdKmu5d9slBXP+PDwG0ioWBJ6Q+ZiQVdWfihWKEEJIyZE+CRyXl15OFk4XdZGhPtlosg8y1oCETI/LU3uTHjPTOD2D9L8/DV8f3w1PfnYTxA3rgueunoG9htrR9ewSCRiwjhhlZK4Xf1GJ++o4lRhKxKMkCTGXIzitLTzZukwkWu4BnzTKiKIr089DcmQfarHpej4Lnr5+C/OzkVVw1olWVrW6gGCGEZADiQl8aE+5eKm1bG2yRLmbnhop43TSRLJrW93YxI3I3jflHPSsFAawjSwrQI8+P3182DucML4psNxbmak9EESLOyZqFoqlFZhmJvk62ZcRpJpRMtDgpLyNzyditGxPbTdP6r3afZo0uwSl9C2MPJAG0YNrj9al7MHALxQghJGXIxAhgDm7de7Qeo+5cgm898X57DMuExxAz8srGCsu23XPMWRHSCqxeT0KBmDLs1n9JF+KQRIuHNvHKXF7JqjNy4ehiXDqxv2E8ztwoslPEWwzWiZvGq1i5aVr3a2KkPaxZ2jo3x+qTH0MULxQjhJCkIk6MeX65GDEuTrd4/X4AwPs7jlr2W9/Ugov++G4kDgUADtcGcdVf12DplspEhiyUNI89GxVKLCN1Fm6aZAewWk163ztjEABg+ogieYMUIt4z0Wrgs7GMKLGyaRxmIY3p3x13XnyKbpvslv/K0Ka1XfI+GycVe2MFsLanGOneZhlpaA51mIwaihFCSFIRl0C3KmltXKDOyYP9P9fsxcb9Vfjj8u2RbXe/tAVvbj2Ea/++1tTeTWqxN0Z6qki+xNojK3rm8SS/6JnV+K6fNgT//kEZ/vSt8Uk9nxO8lm4azTJin9orCyTNshEKP5x2UuR1KKyaBJrMjWK1KJ4RqxWVZem8uuMcfG+sY0Za/20KtX6HUp2BBQAF2b7I51bV0DGsIxQjhJCkIqaPWrkVjtbpF6iTVek0IivYta+tQJQMN64Lo5vGDmOqJyDPpgGiQZzJwkqMeD0KThvcU7fIW3shDkkcnyZGgrKYEeG2yK7Jzr11ybho/ZSWkGo6XtafrKaImyq7MsHkti9PB3LTKIoSCcQ+1kHiRihGCCEm9hypx5Pv7oxriXFRjFgJAqNlxIkVo7HZPKnZBZqGUmQZkT1l11qkSMZ6onaL2zL17YHHwuWiCQrZZxSrAqvdmjti81A4bIrzcJKeC8QWGLq2MVw6Tj6WWAGssRbUSzZaIPaxOlpGCCEdkPqmFpx9/5u4+6Ut+N3rn9q23Xu0Hp8YqoCK6YJWFo8jdfZumpc+/gLf//tanQlZ5tuWxSNouLGMRIuexW4rW2At2fU7fnzOEOn2eAMs48HpuUQxIR6jWUZkdUa8McSInWVEdMO0hFWTa0XqpslyttKu1TXHEoF2Rc+ibeSWMu3/SLAdLSNANKOmqoGWEUJIByRXCDpdv+e4bduzfvsmZj78Dg7WRFNq9ZYR+XHGWiMq9LP5DQvX4/UtlbjzxU2RbTIrjZ0YaUmRm0b2lK2RrKdaq1iT9rSMnDaop6N2OjeNR7SMaHVGYqT2ShSA3YQsighjzIiiWFlGzALSjdUqVluZsDEeo1hYRtQ0uGmAjpdRQzFCCLHkwz3H8fX5K/FphfUaKIB+TRhx/RMry8jhWn3MiJVlQUyxlZWulsUjaDTb7DOiTWBOAhHt4jKslol3i89CjDhxIxkZXpzvqv1j35mI704ZhLsuGeWovZWbxm8nRsTUXlkAq42oE+f40p65pnsiO1QawOpCjMRqKxNARjeQR5GPI1JnpE25t5ebJlr4jGKEENJBsLMwrN19DNf8zZytIiKKAjGY06qImdHKYWXEaAqFI0+OMjeNGI9gjDuRuQesiFhGYkz2imI/WfRKQIzoa2/I28QjRp787qmu2k8e3BO/uvgUx6vGivdMFHPaZCyzUFkJGA17MaJg0fdPx4/OGYLLTi3VWWYUWGXTePHyj8/Uj1tWvMzinLGyomRaxZgR5LHIptH+j2iVatvLMpLr10rCM7WXENIBeGXjAYy84zW8sH6fZZtDNUHLfQAQFIJLRWuIVRCpMZ7DKCT694hOhNpk1igRTKLgMM55zZIF2qyIVmCN/QRsF/g4ebDetVFU4FyciCLHSnTE46Xp1z0H3z59gOP22mSea1Ejxm5MstReN8dEj7WPGTn9xBNwy/nDkOX16ASQoihyN02WB6f0LcQvvzwyss2NmybW90JmUTPGhzitwNpelpGOtnIvxQghGc4P//EhWsIqfvKvj2K2PVDVgB/9cz3W7T6mExBBYf0RURSEwyrW7T5m6scoUozuHPHHX7N+NEqe4EQRZBQ4biwjToueeT2KbWbFD6edhOunnYRF3z8dADCkTz7+72ujTSJFhlUlU+P548GNRUWczF+cewbOGxktpCYTCVaZMXaCQh/0KokZcShkTGOB/B5p7hFxSB6Pgp9MPxm9ukUr6lq56eJJ7TWKHY+i6Iq5aSvnRmJGQu0bM5LTJjZpGSGEdAjsAjKN3Prcx/jfR1/ga/NX6kSH6KZRDZaRr81faerH6L4xWjV0YqRFs4zYu2mMgsbO9WREswbEmuu9HsV2ks3PzsLPLhiO00+MrpZ72akDcM7wPjHHIN4DK9HhJKZFhisxIpx7bGl3zGhbfReQiwR90TNzAKsMnTVDst+uPkusa3FaZ8TnUXDj9KH44OfTbfvT2tqf07zNeP0eBfB7o+PQqhOH1VbrhBZ3RTcNISQj6ZlnXmvFiPb7vutIXWSbOPkHm0NY+flhnHHfcrzxSaXQRt6fcbtRSIgTivbEKMumEeMRjJYRuxokRhy7aTyKZXBprt9rebwTMSDeA6thxGvBd6NhjGMVxaosrdmYzaJhJ0a8xkAPA7FiRqxQFPm9065B/IZon5UTgRezzoi0VorHtk1uW3XisKriW395H5XVra7Q9nbTNDR3jJV7nTkFCSFdlu65fhyoiqbm2hUgEycRcfIPtoTxrb+sBgDsPx6timoVwGp00xhPKU7MmqiQZdOITL3/Td17VwGsWtEzJ2LEok03i0UBAWdiQLwFVhNkPAGsbo8zCiqdGJE8tVu7aeJztQD2lggn1isjsjojbgJYY7lpnKX26r/XUcuIig+FFPr2c9O0iRFaRgghHYHuOdGF3w7WNNqmy4qTtSggPjlQI21vVXjMKFKMAkjcr7lbZBVYRQ4bqro+8uZ2i5ZmnGbTeBXr9Wa6ZduJEXdqJBELi/y4+NuK1pBYKbLioXbuLL2bxtzOo1iLvphuGpmVwqvFZ0S3pT611xzAKv5/0ESHUYjTTUMI6bS4iY8w0iMvKkZOu2cZ/rTcehIXJwLxKU8seiYSK5smHFbx7w/2YsfhOv1+iWUk6DLqf8XWQ47bavOmk6duq6dk2QJ6Gk7mPbHwm1X79rCMGIWT6DaQxV5YjdXWTROzoml8gkyBPJtGEwbid9bJSruR42Nm05i3GcWYR9G7FbX7bHRRtptlJOKm6RhihG4aQjo5b356ENf8fS3uvmQUvjXZeQqnRkF2lu79n2wsCl4LMSIWOhOxctOEVRW1wRYsWrMHv3n5E8lx0ddNoTA+q6xBjcVidMlAm/hiuWk8imK5omy+4T4aj4uFeKuss2lidiMl3sBXQO/iiFVWXfy0nbppZEPzKIq1GIlxD8TPcOE1kzG6f6G0nbR/y1gd99k05gBWRff/QTvEaD1st5gRWkYIIcnk+n+sQyis4vYXNialvz42hbvEH3pRMMhW1AWsLSNvbzuMUXcukQoRwBgzouJvK3fZjDhx3BQ9s7KM2MWMOLGM6ANY0+emMRIrZkQnRoSP27ZWiIOMmLhcVYr+M+ydH7AUiW4E2uh+ckFjNybj9SuKovv/oB1jrJ/Tfm6a1u8rY0YIIUkhz2FxKiuMZmK72AfxoU08ri4o/0GzihmJ5VYyBrAafzBVVcXeo/W2fbghsmpvLHM8bMSIi5iRMiH1V+MCIYXW6unfyYJsMhJZ00Z0zSTiptFWiQX01yE73KNYu0bs3TTGSrburtuq9U/OOxnXTzsJ/7vhTOl+p6m9MsuIsRx7e1lGtJiRjuKmoRghpJOjmVvjxagXaiUuFy3I0MpNU21hGdGWRXeLmAjT3BI2ZcaEVSTNEgQ4XyhPsXHT2FtG9P2eKhRBu/uSU/DqjWfpCqMlswIrkKCbJpZlxGJQxsk4S1dh1v6cXk98bhpFMax7Y+gj3tWVc/0+/OyC4ZYuH9k9MIopr6JIY0aMLs72jhmpb+oYqb0UI4R0chK2jLT9QJ5c1A0AUGsTm6HoxEh0u5XfucVFeq2Gqqo6odMUCptqhoRVNWaJ+liI83PEMuJgzrYMYLW1jOjf5wkCsjDXjxElBZbFw0TcBF2KxIrRsENfZyRWzEj0czO6KcSxx7qOuN000F+rSYwgTjUSA2lqr9Ey4lFw9ZmDAQAzRxVHLSMGId/eqb2NzWHL2K72hGKEkE5OXiBRy0jrD5H2I2gX0Cb+uNvVI9FojuNHLhTWi5Hv/vUDXe0SrU2iq436JE/QTmIyLFN7XcSM5AptZS4iq3EkowKrmzVZAL1rxisxS1iN1ao4HGBI7ZXFkSrWgsVNNo2xWFmsr2y891c2VqO7RVFaK9qu/+V5eORbEyLXMX/F5/rj2jm1F5BXN25vKEYI6cTUBltwvN79pHy0rgkHq1vTcTW9EGtlUkD/ozvjobdjto/HMhJWzbEmm/ZX696rKlCVoBjRWSIcu2msJ3M3MSOiZUS77TrLgcVHEf/aNPH3IbOGWPUtTvb2hcvEmBFzO69HgdfCAhVr+LZuGvtD48ZZam/r+x55fng8iqWoaq+YkWxBZNpZQ9sLihFCOjFn3LdcV6PDSb0RVVUx4e6lOO3eZahvaolYIezXEmn9V3zQPOZABFkFsNrxwa6jMZ9gm0Jh1CWYBSBzGzgRI1Zt3MSM5AltZdVfrSuw2g7PEsXGWhCLWJOjVSE8YxyF6CIRu7RK7bUaZyzrhbjXrRUo3sga6UJ5kgBW3bksTtZeYsTjUSLWkZ8993G7nNMOihFCOjFG64BVIKmIKBAOVDVGxIjdgnnaJOP2qTqeANYrnlgd80mtKg5rkBF91kXrv7EnOsWyTbZk3RYN420T43y0cTiJqYg3m8ajs7q468NJ7RUZxmsQhUrM+6zo79kYi8BR2XG69We81mNIJk5Se41tZMfcesGwuD/jeDhzSC8AwK4jyctMixeKEUK6EE5cF6ZF6tqMKU6eyNzWuWgJx18Z1o5j9U2xG8VAFjDqpM6IFU7dEkB0kTQgOtmLgbGWqb1JCGB1ay1w07duu83XSVdCXnK812AZKe2R62gsCuxdRSkLYJVcqzlmxChGDO19Hvxw2pBkD82WH50zFEDrqsHphmKEkC6EMzES/UF++eMDkToDTtw07WEZcYImRgps4jRiIQZjatcVa7Kyu3r7gE39e51lJJLJE9tNE382jbVl5PppJznuR3Z2q++E3Vhjxn0oij6g1+H3rvW+WRePix3A6ug0JmQi0WgpM16C8Zi/XXVafCdPgOy2eKBOJ0bmz5+PMWPGoKCgAAUFBSgrK8Orr75qe8yzzz6L4cOHIzs7G6NHj8Yrr7yS0IAJIdYcrJanu6qqiu0HaxAKq7of5N8v/Qxvfda6hkuWgyh+t5NhPAGsTtCCdnvk+ePuQ9QO2mSXSIqjncXBKC5yJbVhdG4jy2ya+MYmHieOc2z/QvzsguG2LjqRnpL7LV6bmGFlFzyqn4jNF9Ua4Bl9H2PRXEuMn8npJ/a0aJkYzsSIvo14366behLKTjIXwks12hhjLULZHrgSI/3798d9992HdevWYe3atTjnnHNwySWXYPPmzdL2K1euxOWXX46rr74a69evx+zZszF79mxs2rQpKYMnhOj5cM8x6fYn392J6b9/G7c9/7Gp4qqGIzeNS8tIPAGsTtAsIz1ynYuRb5+uX7dHdANok79xuOZl4K2v382y92Kwq+bKEicr67VpEreMyCw4sT6lBy4di29NHoCZo4pN+6yGlEihNZMVwallBPYr804c2BP/+v7pWDXvnLjHJkMmHmNbRqKvxeq07YmWKdXYEnKUqp9KXImRiy66CBdeeCGGDh2Kk08+Gffccw+6deuG999/X9r+4YcfxgUXXICf/vSnGDFiBO6++25MmDABf/rTn5IyeEKInjU7j0q3P/TGNgDAs+v2Wa4X46S+gVvLSKrcNJpl5AQXlpHzR+onUtHPH3HTGO6NcTKL101jFBdi1VwtA0qfauysH6ckGjPytYn9ce9XRksLvonfCV3wqGPXinmbR1EsrTmxCMcIlJ184gkoKcyRjyXefBrJYdmGlGijoBI/y+456REjmmBSVSCYwMrfySDumJFQKIRFixahrq4OZWVl0jarVq3C9OnTddtmzJiBVatW2fYdDAZRXV2t+yMkk6lpbMafV2zH7iN1tu027a9CfVMLDtcG8dy6fRFfsK4WhMVvjt/GFh7vM26qAli12JhCFz/ixslRtIx4HFpG7G6EG8uIOJZgRIyI7ZOcTWNRe0M1vYiF+fx6N010u102TSy8HgUtgpC1E3rG4aUqSNUWySljuWlEwdndhYUvmYi1RoJpdtW4FiMbN25Et27dEAgEcN111+GFF17AyJEjpW0rKipQVFSk21ZUVISKigrbc5SXl6OwsDDyV1pa6naYhHQpfvniJvz2ta2Yev8K27UkWsIqNuw5jm8+/j7+37MfofyV1lVxxQnI0k3jwDJiZVWxHE+KLCN1bam/uQGv49obxslAtqCa8d64s4w4jxkRJ2rNeuSViCMjyagzoq+iG19/Is6zaaIn06X5So5VFGDKSb2gKMD3zz7RVe2NRK4pXs+STHQb43DMdUaiG9yI6mSS5Y3G5qS7CqtrMTJs2DBs2LABq1evxvXXX48rr7wSW7ZsSeqg5s2bh6qqqsjf3r17k9o/IZ2NVZ8fibzOtViLRlv4avXOo9h+sBYA8MqmVuHvRIw4qcDqNsCzOUWWEa1kfU6W17E7wNhOVvHUeGtMYsQ2ZsS5m0Z8O7w433I8RpKxNo1MNDm1JkjTcHWWFiGANRHLiKLgl18egY/vPB+3XzjClUhIR+TDCd0CePTbE3RxSV6PohP4doK0ICex9aXiRVEUIYg1vWLE9R3w+/0YMqQ1F3rixIn44IMP8PDDD+Oxxx4ztS0uLkZlZaVuW2VlJYqLzUFQIoFAAIFAwO3QCOmyOKmsetbQXnh9SyWeeX93ZJs2AYg/hInEjHQYy0ibdSgny9s20cc+j3GC19e6sLKMOH9es7WMCK89Suv53vx/07DvWD1G9Wst6CWeyroCa3xiRC90JAGsCXxMiQbbWseMKMjPdmcxiD9kNnEuGFWCgpwsPPP+ntaxKAoCXk/k/6656Fn0dX4gPZYRoNWdVN8USntGTcJ1RsLhMIJBeTphWVkZli1bptu2dOlSyxgTQogcJ2LkG5NKMbhXHo7URQuCaQGZuiBDi4nHiWXEbXZMS4qyaTQ3TbbfuWXEOBmIFTIdZ9PY9J9lZxmRBMsO7pWHs4b2No3B+FrfTxKyaSwsGU6wcqlI2yoK7p49SrpPPG9xQbbjPmOhKAr6Fpr7ay/Ez82j6Nf1MX504p1PdLHLRMj2dYxaI64sI/PmzcPMmTMxYMAA1NTUYOHChVixYgWWLFkCAJgzZw769euH8vJyAMCNN96IqVOn4oEHHsCsWbOwaNEirF27Fo8//njyr4SQLkyTg3oduX4vTuqdh53CWjXak774Q2jlpnFSa8LqWCuSXWfEo7QKhrpg4m4a/Wq0bdk0hsnZaO2wmyStFnZrPc5shbEbX/JjRqKvZYG2Tj9V2djtYlC+c/pA/HLxJttzXH3midhxqA6HaoN4Z9th6XmcZrkoCjBpUE/c8eWROLF3nqNjkolufSEoulgX42cqro5tt8hiqumUbpqDBw9izpw5OHDgAAoLCzFmzBgsWbIE5513HgBgz5498AiPAFOmTMHChQvxi1/8ArfffjuGDh2KxYsXY9QouVomhMhxkiLr83pM1g3tSd+jixmRH58Sy0iS3TQBnxcNzaFIEG9uApYR/VNrmxiJaRmxPleWw3LwVlaPWCXSjW3coK8zIhEjCfhpxL7teintkYOjbVY78XQ5fi9+f9k4PP3+7ogYSZTvnTk4Kf24xWOyjEQFr/EzbRDEiCiM2xttjI1pTu11JUaefPJJ2/0rVqwwbbv00ktx6aWXuhoUIaTVNXPDwg8x+URnlRl9XsWUAhm1jAhixEJQ2MWMRGIqXP5eJTuANZDlQUNzCLVtlpHsLK/joE7jJCymXkayacLGmBEXlhGHqb1WzWTZPUbiLSSmdxNF32iiwKkUkVlVYg3p+eun4LG3PsfPZ43A1PtXWDdMQmpPojEjiRRqA/SfraLYW0bqbLLi2pOOUhI+fbYhQogt//3oC7y+pRKvb6mM3RitE4VxpdCaxhZ8+Y/vYM/R6KqciVRglQWw5vm9qGuS/5Al2zKiZazUCwGsjt00ip0Yaf3XqNPcWCKcFj2zivtwVIE1CWvT+GzcKrE4pW8BzhneB3uP1mNbW8ZWrHikiQN74PE5k3Tb0lvrM3WYLSPWYqTB4v9Me6PVGkm3GOFCeYR0UI7HWJnWaFr3eTzSIMpN+/VFAy3dNDaWkdpgC8pf/UTqpimwqZGQSACrz6PgozvP123T5tFIaq8bN42hXbbPPFFcOFqf6ecmm8YoBEX02TSx3TReD3DvV0ab2iS7zoiGU1GiKAqe+u6pKP9qdGz6++qsI7ciyKkGS9SykahlxRj3Iwp8o1btaJaRTlf0jBDSPljFiVzzt7V4fXOFSVRkeRVk+WL/nMZrGXnsrR3SY8V1VpKJx6OgMCdLF1hrnMhz/V7Lyd2IvWWkdd/Qonz8/XvR1VPdrE1jJ4piiQHjdkVR8K3JA/Dp3RfgorF9I9vjz6aJvo6nHLypP92km3B3XQbx66EYLCPG706HsYxEYkZoGSGESGi2yER545NKfP/pddJqoYkULvM7EDIyt4vjUt0u0SY5UewYJ77sLK9tfQ8RowjItjCh9+2ebXmM3ZlsU3t1MSPO3TTZWV5Hx8bCYyGG4rVbeR24lOxIVcn2dOsiO8uIKWYk2MHECN00hBAZVmJEwyhGsiTZNPLj5Nv93tgR/TLLSIq0SGTCE9MejU+XOS4CWE1uGollxHgOo+vF7lR2VgsnlgTRYmE12cdr1RAPe+njA3H1IWKVhpxIDGoy5EmCXpqEjxfvhaLos2SMH11Dmid/jWgAK900hBAJsdJ5ZaXL7eIWNKzcNF6PEvPHWBYz4lEU/Gb2KHx1Qj+cNqhnzPM7RZvA84Ty90ZLRY7faxIBPo+Ce78y2uQ+cuKmMbZzk01jh9iNMzeNcE6hjZNaMDJEgXXZpOhaX/Gm9Irji9da4+p8KT9DcjBat/w2LsaOQH1TC/65pnW5lSO18uKl7QXFCCEdFLeWEZ/XmZvm433Hpdu9HiXmk7csm0ZRFHz79IH4/TfGOYpZMdIzT75iqfbjbeemkVlG8gI+fGvyAMwaU6Lvz3BrrGJR9JaI5PxEKhb968cnz7gRjw1kxVePwqPrI/Fr0llGhO6cShuZBrL75lw5ZRAAYPa4vjatYvUSm8QtI+JrRfcd652vX+Ikv+17nRPnZ5oMcv0+3P/1MQCATytq0jYOgKm9hHRYYosR/fssjzM3zc+e3yjd7lFaJ9/mkLX5WBZvkmhMQ5/8QKQYlog24Ymlso39y7JptKf9O748Er27BfCnN7dLjw1YWEbEydVodXFaCdSILpvGwSJ4xrLiGvFaRpLRh4iVGymR4mm2BdN65mLrby5wtXpvOtC7r/T/hweckKtr+8w1k/F/r32K2y8c0W7jkzGutDsAYOP+KoTCatyF9RKlY3+yhGQwscRIyODG8XqduWmsUJT4LCOJxjTkW5TCjgSwCoul6d0DrRlAJjHS9m9ewGdbidMvWZumtV/r64nfTSM/l66NKIIsBF52nFYNnWUkCdU+9TEw7TN5BXzemKm76faE6O6FAlRUN0beFhgW/Rtb2h0Lrz09slBiujixdzd0C/hQ3xTCtoPps45QjBDSjny45xhWbndW8rqpxf4ps9ZQp8CpZcQKj2K/vgogr8BqF2PhBAUKHv7mOMl4Wvv6cpu7pU9+QPdjn5PVOjmZAkeF22b3pC7eK9lCdsbXrWNt5YFLx1r2K8N1QTNRjAhji1dIiF2LlpF4DRn6zzy+Pox0hJiKeC1fGkaRVlmd3jgMJ3g9CsYP6I5R/QpQ25i+2icUI4S0E+Gwiq/+eSW+9cRqnVvi6VW7sOwTc5XVWJaRmsZm3Xuvx1wO3g2OYkZkqThJCGa8ZFw/k1VH6+v8kUX457Wn49Ubz9KJgxx/68RsN2Yx5sPYLktXkMph9krbvq9N7I9P774Apw7qYXtdhsNa+3dQgVUvEkSrRnyfr3h9+toXcXVnyBoRxu3weJlI/Mr4fjixdx6+2xYfEg/pljNGi1ZBGhfAc8Pfv3caXvrRWZiUxAB0t3SOO0VIF6BeSOU7Vt+Ennl+bPmiGr98cTOA1oqbPq+Cb7RlO8QSI7f8+yPd+yyvonM9uMWjKDEDNmVuGnEGclrzQ4YsOwhonezKTjoh8lpDy4Yxuj3EbgpzsyKTW/dcfaBslkUNCLvMF/FddpbX8cKBVv3r+rbYLk7cSQlg9Xlxz1dG4YHXP8Pv2iw8d140Er/+3xb86JwhzvrTuZScf+bFBdmoqG7E9JFFpn15AR+W3zLNcV+poCAnsSnR+Dn/9utjced/N+En009OdGgpJdHKtcmAYoSQdqIuGDWBfm/BB/jrd0/FwZqoT/n2F1oDSy8Z1xcBnzemGNn8hb7Mu+JATNihKLHdLFYF0zQSMbUbe5Z1JQ4vt80yYrxk41P3ry4+RXo+sciblWvGeD3GMTmtdu928hYvoUlYTTX+1N7o64DPg2+eNgDfOm1AZBK66ozBuHB0CfoYMj6ssEqFjuX2efP/TcPh2iBKe+baN4yTeL9+j3xrAh57+3OUf2VMQuc3WoyGFedj0ffLEuozU6CbhpB2olYQI7uP1OOH//hQOjFpxYdi1RmRYbe+TCycTJKx1ppJJBLfKCJkfRljRmTtnN41nZvGwu1gvCXGEVnVbDEixiJY3aP87Czk+r3wez04oVvUihMMJS5GZKm9xqfhooJsx0/IXot7FCubJsfvTZkQAeKP+Zg1pgT/veFMU8aLW1gaP35oGSGknRAtIwDwxfEG6ZNcsCUEICumZURGIm4ar0eJOZnILCNiae9kpgXKsk7E7iNuGoNpxGlQpj6AVS4WYl2NczeN+NoigNWj4MNfnmcaW7NgGYnXnJ7sbBpd3RTOwBH03/+uujZxaqAYIaSdqDWIkYbmEJ5bt8/ULhixjLgXI4m4aTwK0BQrnVgy04ub4l3iXobUTSMJYDXqL6frnlhlHonziXHy/4ZQvRRwLkacTt7ZkpiQeL4HRpJeZ8RCsKV7+k136IPiwmVF9FCMENJOGBfGag6peHHDF6Z2wbbVM5va2U2jKAoO15qLj4nIJl9xS1yWEcXcj1Vfjtw0Dm/b2P6FGF6cj5LCbN124/oiGg9/cxwuHquvAOrUTaO3jDgbn0Y87jojSpItI7o4EXFHhk/A6SoY1hWgGCGknTC6aayoamhBbbBFF7jolESKniUjZiQRk71xXpeNR+w+YhmJ85w+rwev3niW5BzyANYJA3qYLCWOA1gdFD2zIpa1ytn5o6+TUQ4+SVXyk066pYB4nzNcl7mGYoSQdsLoprHia/NXAoDpid2OpT85G4C168EJTibJWG6JeFeVlSETI4rEMmJ80nczCchiMIwlvaNtzcfHyi6K9hN/jEU8otTu/MkoqW4Vu3LJ+L545v09GNtWYry98SfBBZUIHaFwW2elg+pbQroeTi0jGgeqGmM3QuuCW0OL8gEkJkYUBfjeGYPh93rwq4tGOj5ODHpN5o+x7OlbZxlpEyN5htV5E30k1QkQyK0kGo6zaRJw0yRbjCTDMqKLExHuwS9mjcQfLh+Pv111asLncMPD3xyHvoXZ+NO3JrTreY1YF64jsaBlhJB2wq0YcYo40SVimfB4FPzyyyNw6wXD8NHe446PSzhmxAKZpUZWgdW4to3TAFYrrFJ7ZWJEWgRO2mf0tdt7lIwAVn2dkcRjRkTRm+eP3v/sLK8prqY9uGRcP1wyrl+7n9eI+NkmsmhgJkIxQkg7URu0Xg03EUSzfyJmaq+iQFEUZGd5XbkSxN/cZLppZK4A/aJxbZYRv/5nTJaREv8YxHOb98vW6pGhixlxGXCRnGwaMYA1ccuI3+fBHy8fj+ZQGD3y/LEPyBAYvxo/FCOEtBOpsoyIE02iC+XJXrvqI5mWEUlfokDRKrDmBfTiY0FSXQT2sR7xlIPvkZtl09JMMrJpRJIhRgDgojRYQDo68azTQ1phzAgh7YRxld1k4UmSm0bvnoivH9G18ui3E/Pfxyp6psWMdBNiRv57wxmYODA1i30l4qYRx90j150lIZiEmJEWwYQT7/o2hKQSihFC2olgc2rcNKJwSMRN46RKqAyrmBGnVhqrM8nXpjHHjIgBrKnMZpDpvPFtWSOxrA3iZ9TTpVsjGW6a5iSUlCfuYMiIO+imIaSdcFqTwi3iJJlQaq/F4md98gM4WBO0PlD41RX78CWYQhqr6Fm2xDKSyqJTMmvRfV8bgxN778Clk/rbHqu3jLhz0yQD0dWTzLgeYk2igdSZBiUyIUnikwPV2LivynK/0zRQt4gTtC+BomdWWSStxb6c9aGzjCQ46cUseiZJ7U2+GBHTls17e+b5cdvM4TipdzfbXsR7292lm+ax70xEj9ws/OHy8a6OExG/eh1hufiuzIC2hQDH9u+e3oF0MmgZISQJtITCmPnwOwCAjb86H/nZ5qdfp8GObklWQSsrN02WzwOPoljGR4hb9cIosWcdWcCoRxLA2i2FbhrxkhPpO5GYkdNPPAEf/vK8hETEqYN6YOLAHji5yF40kcRZdstUtITUiBuROINihJAkUC/Eg1Q3tkjFSKp8yOIclVg2jZg5IvapwKMATiJefJ7kWGlaxyPZJoxL5qZJpQsiETGit4y4d9Mkas3weT14/vopCfVBnJHl9YAxwu6hm4aQJCBWybRyT6TKTZNIQS0RfRl0vbXFbjLUWQ90bpoEY0ZilYOXpPYm2wOhd28kp8/CnPaPGSGko0MxQkgSENMvrSRHqsRIrG6dZk9YFfjK8nps160RA/VEY4hoGTltsHW6bWmbj92IzE0jjkMWM9LYnHjmiRWJWEbEz6B3fiAZwyGkS0E3DSFJoFFw01jFhqQqm8ZOjDx02TgsWLkLGxyUd/foAlj1KbpODS5ewU2kc5lYjPGScX1x+4UjLMZjv02LGQmJNTR87Zva65TsLC/euPlsAEpSK8QS0lWgGCEkCTgRI+21VoVHiQqf2eP74en3dzs8zsJN0xbAaoV4WV5d3IlYjdJ87bl+Lx7+pnWGiNPU3rxAFp6/fgqqG5sxqFdyAzRVXTZNYkJnSJ/8RIdDSJeFYoSQJCC6aazcMcmyjPi9HjQJRayMIsfn0e+3c7GIiHO/Vxczojgu8y7Gz4p9yG7JxIE9bPsKSlwumsVGUfSuj1h9xYtYoKyhuQV5AcZ7EJIKKEYISQLO3DTJUSOBLIMYMez3GlJfnMaRWtUZMbppAj6PPkZGtIwIJ9Mtpy6cJzvLg+wsL+79ymjb8ew+Wm/apo0jJ8ub0noZt14wDG9tPYSbpp+Mk3p3Q7eAj0KEkBRCMUJIEhCf4lNtGcnO8qKmMbrOjfF0xvRWXWVVj+Ko3okuK8bgpsnPzkKwNlqRVV8OPvpa1AriOR/8xjjMOKU4prVl95E60zbtWnJSHHfxw2lD8MNpQwAAl04qTem5CCEUI4QkBb1lRN4mnCQ1kp2lN3UY4zGMk7yuEJlTMWK0jAgbugW8OFxrdZw8ZkRRgIXXTsbm/dW4YFSxI6uGbLVa7TgWlCKka+Eqtbe8vBynnnoq8vPz0adPH8yePRtbt261PWbBggVQFEX3l52dndCgCeloiG6LWG6ae74yKqFzBXz6iTiWZcRjyIxxgscYMyKWYffrn2HEmBWfzk2jH+OUk3rh2rNPdOVeqTesdCy6aQghXQdXlpG33noLc+fOxamnnoqWlhbcfvvtOP/887Flyxbk5eVZHldQUKATLVwbgXQ1RMuIJjpUVdV91zWNkkjJdsBcN0QaM2Lx3mlVVHPMiLkMuwzx0qxiRpzw0GXjMPXk3sg1CB8PLSOEdElciZHXXntN937BggXo06cP1q1bh7PPPtvyOEVRUFxcHN8ICekEGANYl39aiVuf24jfXToG04b1ARC1IPgTXMI9Voppsi0jPhdixGMRBOu2Fv7s8f0s+m/9l7U6COlaJPSrWFVVBQDo2dO6uiIA1NbWYuDAgSgtLcUll1yCzZs327YPBoOorq7W/RHSUalpbMbxhubI+5Cq4nsL1uJwbRDfW/BBZLtmMXFaEdUKRQHuvuSUyHvjPO/1Gi0j0ddOrTLGOBMxI6e4wNrNalVSPll42imAlRDSvsT9qxgOh3HTTTfhjDPOwKhR1j7wYcOG4amnnsKLL76IZ555BuFwGFOmTMG+ffssjykvL0dhYWHkr7SU0eykY1IXbMG0+1fgoTe2RbaJgapi+EjETZOoGAHwnbJBwha9GjGuCaO3cjisFyIc4/Uouj565vmx5KaoJdRqZdtE3DRWaH3aWWcIIZ2PuH8V586di02bNmHRokW27crKyjBnzhyMGzcOU6dOxX/+8x/07t0bjz32mOUx8+bNQ1VVVeRv79698Q6TkJTywa6jOFLXpNsmChDRZRK1jCQ4kRosDibLiNFN49FbORydQvhl8BnESHaWF8OKo9VEddk8FoXTklV8NtEA1vy2dWxO6m0d40YIaX/iSu294YYb8NJLL+Htt99G//79XR2blZWF8ePHY/v27ZZtAoEAAgEuJkU6Juv3HMPvXt+Kn184Ep9W1Jj2i9k04qSpTchO4zasMMqJmAGsSYkZie5zGq8hChpZOfh40MaVHadl5PkfTsFjb+3Aj88dkpTxEEKSg6tfRVVVccMNN+CFF17A8uXLMXjwYNcnDIVC2LhxI0pKSlwfS0hH4Ct/Xon3th/BVQvW4CPJAnRi0TNx0tS2J6hFYi5lb3TFiOLEuRgR+jNYRnKMdU6cuGmSWPANABau3mNK+3XCyUX5eOAbYzHwBFpGCOlIuLKMzJ07FwsXLsSLL76I/Px8VFRUAAAKCwuRk5MDAJgzZw769euH8vJyAMBdd92F008/HUOGDMHx48dx//33Y/fu3bjmmmuSfCmEtC+V1UHsPmIuWV4lBLOKBco0i0migZ0my4hhpvcmIWbEYxMzYmcZEXs31hlJBledMQi9uvkxa0xfU9ovIaTz4uoZbf78+aiqqsK0adNQUlIS+fvXv/4VabNnzx4cOHAg8v7YsWO49tprMWLECFx44YWorq7GypUrMXLkyORdBSFpwO/zSJ/OK6oaI69DQhVRbUK2EiOPfGuCo/Ma6/QY53lzam/0tVPLiGK0jAidGGt8iOcXjxOv08m6PDNHtab/XzjaugxA91w/vlM2SLeAHSGk8+Pq0cLJEugrVqzQvX/wwQfx4IMPuhoUIR2VJZsrIq8DPg/qm0KmNl8cb4i8rglGxYo2ITeFzMf8dMYwnDrI2cqzZsuI/r1d0bN4UntbLSPRfUbLiPi7YFlnxAG/u3QsLhrbF1NP7u3uQEJIpydB7zUhXY93th3CE+/sMInv+qYW/ODpdZH3ohi5eGzfyPYGoQBaXbAl0o8mRnKyfMgzWhdU1SQirDBO8sZxmiwjcVRgdeOmObkomlmjd9O4ixnJC/hw4egS5AXofiEk0+D/ekIE6pta8J0n1wBonWTPFp7SfYZYDL/Xg6Ntab2/mDUC+483YN3uY6jTWUNaxUmu3xdJ+fUoCooKs7HjkH5VWp9TF4rJNqLHLpvGeA1WiF0YLSOadeV/N5yJf63dg59MP1kcnNCHWGckWZVGCCFdEYoRQtBazv3Tihqc0rdAt02kprHZeFhEYOT4vZFJvzaojyOpbWxBrt8XsWB4PEBRvl6MqCqQ5dBqYdQisWJG9Nk01ueob2qJBIWKcSkBn1dnXdGKto3uX4jR/UcbhiZm0whjpBYhhNhAMUIynoPVjfjuXz/AlgPV+OG0kyLbC3OydO2qG/Uio0WoJ5Lr90VKphvFSE2wBX0AvWWkwFxHx6nVwiQnTDEj+n6Mi94Z+dkFwzGutLspO+WqMwbhUE0QI0ryDav4Wo9TPJeis4wQQog1FCMko2lsDuG0e5dF3v95xeeR1yHD47zRMqKl6gZ8Hng9SsQCIbOMANGYEY8CFBWa13dxbBkxYC56ZngfI7X3ekGAidx5UXT9G11Gjs96nFZ7nAS/E0IyFwawkozloTc+w5Pv7rTc3xLST6DVDXLLiBZwqVkP6oJ6944W5KqtWaMoii7gFWgVFMaUXSuMqcHGiX5ESdTVVN/UElc2jd057dKDra6BUoQQYgctIyQj2bD3uG5xOxliWXcAqLawjGgl360sI40trWJE0wxeRcEpfQux9Cdn47wH39btc4Ipm8aw//ppJyHL68HUk3u3uY/cZ9MYceqmGdzLorIp1QghxAaKEZKRiLVArGgOhXXvjW6alnDr/rxAmxiJWEb0YiTY3NouFHHTtLYbKqTEuiGWASXg82Lul6Jrr8STTWNEPMzOMtI7P4BXbzwLeYb4E2oRQogdFCMkIzFaL2S0GC0jBjdNY5vIyGmbeDULhLEQWrDNMqLFjMjEhJvUV2Nqbyyrii4t15cMN429GhLdRBqMGSGE2MGYEZKRGK0XMoyWEaObRkMrYOa1MFloKcKRbJqIaImO4YQEypvHEjKim8ZhXTUTosvKaT0UEUoRQogdtIyQjMSJGDEGsNY0yo/RUmKtKqhqFhRVyKbRjvvLnElY+flhXH7aAEfjBmQVWO3biyKpb/ccx+cREa1E8QTB0jBCCLGDlhGSkdRJ1pQxosWEaFQ3yC0juW2WEY9FsTGTZUQQB+eNLMKdF51iaW3onR/A0D7d8PTVp0W2xVooz4g4rj755pRiJ4iWkXhSkFmBlRBiB8UIyUjq44gZCbaEpe3++9EXrSm0hjm6R26W7ji7mBErTh3UA0tvnoqzhsa/eJxosSmW1DdxgihGnK6hI0LLCCHEDooRkpFYuVxEjG6aprYYEuOqsnPKBppSaAGgR25rHEhjcwiqqkYmZGOdEDtkbWNVYDX3EX3dq1t8sSmiGHFaDwUArpjc6n766YxhcZ2XEJIZMGaEZAzNoXAkLfW4hcvF2F72PjtLr+G1dFmjcIiKkbDOMmAV6CpDZoUw1xmJEcAq1giJM5vGaCVyym9mj8KPzx2KooL4LDKEkMyAlhGSEew7Vo/xdy3FHS9uAgAcr2+KeYxxAtbEiFbkTEMrj24UGd3b3DSNLaGIiwZwZxmRihHD+5gBrLpsmvjSacJxihFFUShECCExoRghGcET7+xEbbAFf1+1G4DDOiMmy0jrhJxtECNadomdm0Zc50Zx8b9OZkVxG8Aqtg42xw7clWEM5iWEkGRCMUIygoDBPdEciv2kb2UZMYoRzU1jTIjpntcWwGpw0yTbMhILUbzkBXxYPPcMlz2YS+MTQkgyoRghGUHAICCM8SAyjAGsVmLEyk3Ts80yEjS5aRwOGnIxYizHHqu6qTgsBQrGlXbH1yb0dz4ImFcwJoSQZEIxQjICMehUVVWT0JDRbHBNNLdobhr9f5ssTyw3TRjhJFhGfvnlkejXPQe3XzhC1yaW0UI8mxsXkUjIwf0ihJB4YTYNyQiyfVFrRkNzyFEMhCZY6ptakOv3WQewes2WEY8CFOS0/vdqbNZbRtzEkIrC5eozB+PqMwc7P1hywngDWGkZIYSkEooRkhFkCTEjtY0tzmJGQmGs3nEElz3+Pn587tBInZEcv9FNo8WMRCf6XL8v4hpqbAlBFbSPG0Hgi3cxGQGxB607txVRHXi1CCEkbuimIRlBSJhNa4ItpkwZGc1hFXe9tAUA8Idl2yKWEtHKAsjdNNlZ3ki7+qYQjtQFI/vs6ow8eeUk3ft4qp3aEbdlhNk0hJAUQjFCMgIxM8apZSQUUiO1QgAhgNVkGTG7aXL93khsyY5DdTjngbci++z0wLkjijD3SydF3hvjUOJBF8AaZ3fxFj0jhBAn0E1DMgJRfHx1/kpHqarN4TAKc6JipMkyZsRsGcnJ8pqyboBWMRCrnLpovXBTrdVJf4rrxOBWmNpLCEkltIyQjEB0yzidWFtCKgpzomu5BJvty8GLwiHb742s5ivixE2iEyMpihlxK0ooRgghqYRihGQEzXFMpi3hMAqyo8bDJos6I37NTSP8b8rN8iI/OwtGnEgAUYwkJYBV6CL+mBGKEUJI6qAYIRmBk4BVI80hVToJO3LT+L3IzzZ7QcMOUmRF/RHIkv8XrW+KlrM/pW9BzD41GDNCCOmIUIyQTk1LKIw9R+pjtmuIY02WllBYOgk7cdPk+L3I8npMbhYnc7ooavzGGvNt5Pp9WPH/puG7UwbhL3MmSdtoiC6ZWPEqhBCSDihGSKfmh//4EGff/yZe21SR9L5bwqrOAqFh7abRB7AC7teRAfSuFGMZe5FBvfLwq4tPQd/uOfYdSgbhts4IIYSkEooR0ql5fUslAOAv7+ywbeek/LvsGJlXxWqhPMWQ2tu6zfVpdW4aK8uIu/5oDSGEdGwoRkiXIFYshpOF8Yy0hMOm4zyKeaE67b1XmPMjlpE4hIDeMpL4f9FkSJGnrz4NPfP8eOw7E5PQGyGE6KEYIV2CWHGhToqcyY4xHpfl9ZgyXKRuGn/8bholyZYRGVeWDQIAnH1yb0ftzxraG+t+MR0zTilOyXgIIZkNi56RLkEsqeFkYTzZMU0Gy4hfEpSquWnEYFdNsMTjIhH7t4sZcYpsCGNLu2PdL6ZHVhZ21g/dPYSQ1EAxQroGMUwj8caMmNw0HsUkRrSF8sSU3349WoNK44sZiZ1N4warMZzQLZBw34QQkgwoRkiXIKwCv1y8CR/vr8LfrjoV3due+F/csB8BnzfOmBHVJGJqGptNJdqz2oJFxJTcovxsAPFm00RfJydmhBYNQkjHhjEjpEugQsXT7+/GR3uP4/89+xEAYN+xety4aAOue2adNEU3Fi0hs5smrJoXr8uS1BkpKmwVI9OGOYvJEFHayTJCCCEdBYoR0iUQQ0Le+OQg6pta0NQS3VgbdF/0rFnippGhuWnEwmpFBa1i5N6vjsFtM4e7Oq/oBjIWWCOEkK6Iq1+68vJynHrqqcjPz0efPn0we/ZsbN26NeZxzz77LIYPH47s7GyMHj0ar7zyStwDJkSGmNqrKK0VSoOCGNmw97jrPvcfb8D6PbGP09w0h2uDkW3dAq0e0MKcLFw39SRX59XXGUlGACtNI4SQjo0rMfLWW29h7ty5eP/997F06VI0Nzfj/PPPR11dneUxK1euxOWXX46rr74a69evx+zZszF79mxs2rQp4cEToiHGr2qv64Jm18xZQ3s56u+ScX0dn1tz04hiJBGUJNcZKTvxBABAn3wGrBJCOiauAlhfe+013fsFCxagT58+WLduHc4++2zpMQ8//DAuuOAC/PSnPwUA3H333Vi6dCn+9Kc/4dFHH41z2IToF78zxnYAQI1EjMwpG4R3th2O2feQ3t0cj0OLIfnK+H545v09mDSwh+NjpQjCKhkxI73zA9hwx3mR2ieEENLRSCibpqqqCgDQs2dPyzarVq3CzTffrNs2Y8YMLF682PKYYDCIYDD6lFldXZ3IMEkXRRQgYnyIRm2jWYz4vM5cFlociEZ2lgeNzfbxIxMH9sQ7t34pEi8SL81CAEwyLCMAItlFhBDSEYn7ly4cDuOmm27CGWecgVGjRlm2q6ioQFFRkW5bUVERKiqsFzYrLy9HYWFh5K+0tDTeYZIuTFAQB0GDGGkJhaVuGs2lEgvVULfk6jMHR17bZeaU9syF32c+h5uwDTGdOFUVWAkhpCMRt2Vk7ty52LRpE959991kjgcAMG/ePJ01pbq6moKEmBAtIw0GgdAUCqNWIkZiWUZe+tGZKO2Zi8Xr9+u2XzKuHy4e2w8DT8g1LZTnBJ9HcVySXszg8VGMEEIygLjEyA033ICXXnoJb7/9Nvr372/btri4GJWVlbptlZWVKC62XuMiEAggEGCwHbFHtIzUNYVM+2RiJCuGGBnVrxCAWbRkeT0Y3CsPgN4yMqzIWWxJa1VVp2LEfbVYQgjpzLh67FJVFTfccANeeOEFLF++HIMHD455TFlZGZYtW6bbtnTpUpSVlbkbKSEGmkLWtUOCLWF5zIhDN415Zd6oOMn1+/DUdyfhR+cMwb+vm+KoPzdr1LTEUS2WEEI6M64sI3PnzsXChQvx4osvIj8/PxL3UVhYiJyc1rU45syZg379+qG8vBwAcOONN2Lq1Kl44IEHMGvWLCxatAhr167F448/nuRLIZmGXUDpdc+sk9YWcRzAamhnjN04Z3gRzhmuj4Wyw7jSrx3NYVpGCCGZhSvLyPz581FVVYVp06ahpKQk8vevf/0r0mbPnj04cOBA5P2UKVOwcOFCPP744xg7diyee+45LF682DbolRArXvr4C/zqv5sRCqvSdF4NqyJnRouHFUYLitPjrDCWkLcjnnV0CCGkM+PKMmLMMJCxYsUK07ZLL70Ul156qZtTkQzlUE0Q+dk+aZBofVMLbli4HgAwoiTfsctFxKmFwmgZcWpRscK40q8ddNMQQjINrtpLOgyfH6rBuQ+8DQDYctcM5Pr1X0/x/ZLNlVj+6UHX53AqYJJuGXERM8IMGkJIpsFfPdJhWLvrWOS1UYgYcSJERpQUmLbZBb2KGIueJSpG3MSMfP+sEzGipAC3X+hugT1CCOmsUIyQDkOyvROXjOuL66eeqNtWmJOFCQO6xzw2SxAPXo/iys0iw83xPfL8ePXGs/D9s90tsEcIIZ0VumlIhyFsEZN0pDaIt7cdwsxRJa76OyHPj+9OGYQTugUwfkAP9O+Rg9752XjsO5Pwj9W7ceaQXvj6o6ukx4quklBYRX1TS0xrjR1xhLcQQkjGQDFCOgwyMVLf1IKJv3kDAPDR3ipX/Q08IQ/ZWV5cc5beOtI7P4Cbpp+Mg9WNlseKAavdc7MSEiKA81gVQgjJRPgLSToMIUl9DVEELN1Sado/tE83zL9igrS/kkL7Betka8hoiGvYBGzaOSVBLw8hhHRpaBkhHYZYtb5kpdzv+9oYnNhWpt1IrNVzbcWIL3queNaiMeImm4YQQjINWkZIhyEsqJEDVQ04Wtek269IJnSfR7EUC3ZiA7BfEdeXZMtIogGwhBDSlaFlhHQYxJiRsvLlAFrrjdjh9ShxiwW7eh6iFSbgS9wyQjFCCCHW0DJCOgwhSQCrnfUCaA00dVNqPRbairyiUMnOomWEEEJSCcUI6TCEJUEjdUH7ImV2xcQ0YeGEWWNKsOPeCyMBs2KdkWRYRhgzQggh1lCMkA6DLIC1Jthse4wxZTY7y4PLJpXizf83zVU6bs9cv87CIlZcTXRdGgD43hmDIq/diCRCCMkEGDNCOgyy1N7DtU2SllGM7o/SHrn4v6+PcX3uFsO5RQHiTYJV4+Jx/TBhYA+UFObQZUMIIQYoRkiHQVb0rFIoTCYTK0arhayNE0JhfS160TKSLPHQv0duUvohhJCuBt00pMPQJFmc5gdPr4u8lrk3jEJBFgTrBJNlxLA2DSGEkNRBMUI6BJv2V+Gxt3bYtqlpNIsRY8xISyhOMWI4ThQgyczWIYQQYoZihKSd+qYWfPmP78ZsF2wxW06MVgurxfZiYXTviAXWkhEzQgghxBqKEZJ2ElmEzpjaa3S32CG6fU4/qadlO7ppCCEktTCAlXRqTDEjLsRIrt+HNbefiw17j2P6iCLH5yCEEJJcaBkhHZ4XfjjFcl+W16OzcFxz5mBXffcpyMb5pxTbxoXQTUMIIamFlhHS4enVLWC5z6O0Wji23TMT2yprMaIkP+nnZwArIYSkFooR0uEJ2KwNowWaZnk9GNm3ICXnj7E8DiGEkAThzyzp8MjWrGlP6KYhhJDUQjFCOgRZFuu/LLtlKrrn+tt5NHq8Hv43IYSQVMJfWdIhyJL4Qr5z+kCc1LsbAr72/5qKQbGj+6fG/UMIIaQVxoyQDoHf50F9U8i0DQAamkOyQ1JKrt+H5bdMxcb9Vbh4bN92Pz8hhGQSFCOkQyCLy5BZS9qTE3t3w4m9u6V1DIQQkgnQTUM6BLJS75plJNfvw+Zfz2jvIRFCCGknKEZIh6CxxeyK8QtBrXkBGvEIIaSrQjFC0k4orEpX2/WnIXCVEEJI+8Nfe5J2mgQXzdj+hZHX6Y4ZIYQQ0j7w156khPqmFgy67WUMuu1lbNp/3LZto5Atk+P3Rl7TMkIIIZkBf+1Jyvn5C5ts92vBqz6PgoAvKkZoGSGEkMyAv/YkJeT6owGnxvohobCKd7YdQkPb9mBb8Gp2lhdeYVE6P8UIIYRkBExRICknrOqDU1/csB83//uj6Pu5UwAAAZ9HL0bopiGEkIyAv/Yk5Xx+qA6Dbns5UmJ9+acHdfsP1TYBaBUjYukzUcSI5dkJIYR0LShGSLtT2iNH974u2Co0jG6abFpGCCEkI3D9a//222/joosuQt++faEoChYvXmzbfsWKFVAUxfRXUVER75hJJ0WLI2kJ6902FVWNAIAdh+t0YqR3fnb7DY4QQkjacC1G6urqMHbsWDzyyCOujtu6dSsOHDgQ+evTp4/bU5MugnHhu/JXP428FsVIQU5W5HWu34dd983Crvtm6doQQgjp/LgOYJ05cyZmzpzp+kR9+vRB9+7dXR9Huh4NTeZ1aABg1ugSvRjJln89KUUIIaRr0W5O+XHjxqGkpATnnXce3nvvPdu2wWAQ1dXVuj/SdWhsNq9DAwA98rJ0+/Kzs6TtPJIVfgkhhHReUi5GSkpK8Oijj+L555/H888/j9LSUkybNg0ffvih5THl5eUoLCyM/JWWlqZ6mKSdOFjdaJkZ0zPXj7pgVIxYpvZSixBCSJci5XVGhg0bhmHDhkXeT5kyBZ9//jkefPBBPP3009Jj5s2bh5tvvjnyvrq6moKkE1Hf1IKRdywxbX/qvZ24639bLI/rked3lMJLLUIIIV2LtBQ9O+200/Duu+9a7g8EAggEAu04IpJMDlY3SrcbhUhBtg/VjVHx0TNPbxmxQnTT1De16Kq9EkII6XykpZDDhg0bUFJSko5Tk3ag2ZC6a0WPPL/+fa4fdQ4sI8OL8+MaFyGEkI6J60fK2tpabN++PfJ+586d2LBhA3r27IkBAwZg3rx52L9/P/7+978DAB566CEMHjwYp5xyChobG/HEE09g+fLleP3115N3FSStHK9vwri7lgIAttw1AwGvN8YRrfgMKbpeDxxZRn73jTE494G33Q+UEEJIh8S1GFm7di2+9KUvRd5rsR1XXnklFixYgAMHDmDPnj2R/U1NTbjllluwf/9+5ObmYsyYMXjjjTd0fZDOzYsb9uveawvfxcLn0RvmiguzdZYRKxfMSb3zseu+WXGMlBBCSEfEtRiZNm0aVNXaDL9gwQLd+1tvvRW33nqr64GRzkNDc7RuSK7fh2CLvI6IEWPxspLCHHx9Qj88/f4eiyMIIYR0RRj5RxLGqE2dWka8gmFky10zkOv34eezRmLqyX1w+kknMDCVEEIyBK5ERpJKOKwi2OzMMvKNU83p2tlZXkwfWYRuAQoRQgjJFChGSMKoiJpGGppDjt0000dwfSJCCCF005AkEBZSeeubQo7dNIU5fgaiEkIIoWWEOKe+qQWDbnsZg257WVcpVVyFt6HJuWWEEEIIAShGSJwcqglGXou1QeqaWihGCCGEuIJuGhIX81d8jjsuGmlag6Y+hmWEbhlCCCFGaBkhcdEckguOhqYQgs3OYkYIIYQQgJYR4gKx7keWV65jv/3k6vYaDiGEkC4CLSMkLhQldhsjX5vQL/kDIYQQ0umhZYTExT/X7MU/1+x1dcztF45I0WgIIYR0ZihGSMph0CohhBA76KYhhBBCSFqhGCEpRyyQRgghhBihGCGOEcu+E0IIIcmCYoQ4psmitsg3JvXH5l+f386jIYQQ0lWgGCGOsaqsmhfwIS+QhV33zcJPZ5zczqMihBDS2aEYIY5pshAj3QLRpKwLRhW313AIIYR0EZjaSxxj5aYRxUhJYU7k9fpfTkePvEDKx0UIIaRzQ8sIcYyVZSQvINe0gSxvKodDCCGki0DLCLGlvqklsjLvE1dOkrYRLSO5fh+LnBFCCHEFLSPEMT/+53rpdivLCCGEEOIEihHimPqmkHR7N4oRQgghCUAxQmzJ9ccWGj6GhhBCCEkAihGSMFlefo0IIYTED2cRkjB5DqwnhBBCiBUUIyRh+vXIid2IEEIIsYBiJIOpb2rBoNtexqDbXrZcWTfExfEIIYSkGIoRAgB467ND0u0VVQ22x225a4ajIFdCCCHECooRAgC4/pkPpduPNzS380gIIYRkGhQjxJZjdU2W+26bOZxWEUIIIQlDMZLBOBESlTVBy3098/zJHA4hhJAMhY+1GU6e34u6tsqqg257GQCw9hfnYtJvlgEAfnzuEMtjT6AYIYQQkgRoGclwcmOUcv/Dsu3Wx/pZepUQQkjiUIxkODJBoVlFZMwe1zfymm4aQgghyYBiJMNpagm7ai9WHaEYIYQQkgwoRjKcOotiZ1b0yQ9EXtNNQwghJBkwgDWDqG9qwcg7lui2+TyKqz7ERfEUxd2xhBBCiAzXlpG3334bF110Efr27QtFUbB48eKYx6xYsQITJkxAIBDAkCFDsGDBgjiGSlJBi8ty7x7a0gghhCQZ11NLXV0dxo4di0ceecRR+507d2LWrFn40pe+hA0bNuCmm27CNddcgyVLlsQ+mCQVVU18nZlx/btj132zsOu+WSx4RgghJCm4nk1mzpyJmTNnOm7/6KOPYvDgwXjggQcAACNGjMC7776LBx98EDNmzHB7epIAizfsj+u4m88bit8v3QYAmDKkVzKHRAghhKQ+gHXVqlWYPn26btuMGTOwatUqy2OCwSCqq6t1fyRxnl8Xnxg5uahbkkdCCCGEREm5GKmoqEBRUZFuW1FREaqrq9HQIF8Rtry8HIWFhZG/0tLSVA8zIxjQMzdmm7yAOUPmpN4UI4QQQlJHhwxHnDdvHqqqqiJ/e/fuTfeQOhT1TS0YdNvLGHTby6i3Sc01tgs6qCnSu1vAtK1fj1zGiRBCCEkZKZ9ZiouLUVlZqdtWWVmJgoIC5OTkSI8JBAIIBMyTIkmMmsbYNUXyYpSHJ4QQQpJNymeesrIyvPLKK7ptS5cuRVlZWapPTQSM9UWsyMliITNCCCHti2s3TW1tLTZs2IANGzYAaE3d3bBhA/bs2QOg1cUyZ86cSPvrrrsOO3bswK233opPP/0Uf/7zn/Hvf/8bP/nJT5JzBSSpsKoqIYSQ9sa1GFm7di3Gjx+P8ePHAwBuvvlmjB8/HnfccQcA4MCBAxFhAgCDBw/Gyy+/jKVLl2Ls2LF44IEH8MQTTzCt1wV2MSJLt1RaHOWc80+JBhgHsjpkGBEhhJAujGs3zbRp02yLZ8mqq06bNg3r1693eyrigFuf+xiXjOuXUB+iayZbeP2jc4bglvOHJdQ3IYQQEgtGK3YyrGI/jOvObLlrhuMVebsFfNh13ywAwM9f2BjZns34EUIIIe0AbfKdHLsC73VBefbM6H4FuveiZcTvjS5+5+W3gxBCSDtAy0gXxS57xu/Tq4wcIWg1IAiTnnn+5A+MEEIIMcBn3y6CXfEzI36DyUN0xxypDUZeTznphMQHRgghhMSAYqQdcFoxNS7a/DQPti1k54Sxpd1170U3zcXj+kZeM2aEEEJIe0A3TQfGGJQqQ4WKQbe97LjP75w+ANdNPQmPvrUjsk0UHSNKCmSHEUIIISmDlpFOjk2WtRRFUUwxIx5+CwghhKQRWkZiIFonttw1I+GF4g7XBtGrG5LapxvGD+hu2ia6aXp1y46k+RJCCCHtAZ+J25mzf7siqXEjLg0jOH9kkWlbwMevASGEkPTBWcgFI+9YkvwAVAucxIsAQCjsTo4oioJcvw+rbz8nss3rUWyOIIQQQlILxUgMnFYxTZSUZtxICPiirhlFoRghhBCSPjJWjDid/I/XNyWlH7vj00GWUGmVUoQQQkg6YQCrgCxYtb45lHC/xoUFJ/1mmfS1xsg7lmDtL85N+LxGxGBZ0RrSr0dO0s9FCCGEOCVjLSNOqW8KGd47s4SI7YJxuHpkIiVVDOiZ227nIoQQQoxQjMSgPpi4ZeRgTWMSRkIIIYR0TShGLNAyZ0IxqoqJ1hErS0mtxeq5hBBCCGHMSEyMlpEGg9vGGA8iS8mtS4J1JR623DUDgP0KvoQQQki6oWUEwK7DddLt9U0tmLvwQ902n1efe/LqpoqY/dc2pt4yYhXwmuv3Ydd9s7DrvlntWumVEEIIcQpnJwBbDlTjwj+866htVX1z5LXM4iBz1bSHm0YTHU6LpRFCCCEdBYoRAEdqg47bHm9ojt3IQEeMGdHECyGEEJJu6KYBUP7qVul2Y3wIAHzz8dWW/VgFsFbFIWAIIYSQTIFiJInsO9Yg3f6HZdvbeSSEEEJI54FuGhvO+u0KV+2/9Zc1qRmIC+h+IYQQ0tmgZYQQQgghaYViJM28c+s0R+223DUjUjdEto9pu4QQQjorFCMdiLW/OFdXL8SJUKEQIYQQ0tnJ2Fks1+/D+/POwenly9vtnOeN7IOlWw7GfTzjQQghhHRFMtoykuP3tuv5/N7Yt1u0crT3+AghhJB0kNFiJMuBOEgmLWHzonui4KC7hRBCSCaS0WLEDT+dcXLCfXzz1FJX7bmuDCGEkEyAYsQh2b7EXSaj+xcmYSSEEEJI14KP2w7J9qdGtxmDUq1KyhNCCCFdlYwWI7l+H0b3K8DG/dW67aP6FWCTYVsyLCMiVim5zJghhBCSaWS8m8bvM98CWdZLdlZiYmTtL85l3AchhBAiIePFiEwgeD2KaVt2lvWtenHulKSOiRBCCMkkMl6M5EgsHrKU3+65funxW+6agZ555n1b7pqhq6ZKCCGEEDkZ7zeQWTyyvGbLSI7Q7tFvT8AFo0oi78O55vohgN7qQhcNIYQQIicuy8gjjzyCQYMGITs7G5MnT8aaNWss2y5YsACKouj+srOz4x5wsglJCpEZLSNb7pqBHnmByHujNcUjcevIYN0QQgghxIzrGfFf//oXbr75Zjz66KOYPHkyHnroIcyYMQNbt25Fnz59pMcUFBRg69atkfeK4mzybg8amkOmbTI3jShAfBLLiQxmxhBCCCGxcW0Z+f3vf49rr70WV111FUaOHIlHH30Uubm5eOqppyyPURQFxcXFkb+ioqKEBp1MGpvDpm1+QWxoWTCi66akMKddxkYIIYRkAq4sI01NTVi3bh3mzZsX2ebxeDB9+nSsWrXK8rja2loMHDgQ4XAYEyZMwL333otTTjnFsn0wGEQwGIy8r66utmybKM0hsxjJDZgtGqI1p7iw47iZCCGEkM6OK8vI4cOHEQqFTJaNoqIiVFRUSI8ZNmwYnnrqKbz44ot45plnEA6HMWXKFOzbt8/yPOXl5SgsLIz8lZa6W9PFDV8Z38+07UBVY8rORwghhBA9KU/tLSsrw5w5czBu3DhMnToV//nPf9C7d2889thjlsfMmzcPVVVVkb+9e/embHwXj+1r2rbzcF1CfVpVVyWEEEKIGVczZq9eveD1elFZWanbXllZieLiYkd9ZGVlYfz48di+fbtlm0AggEAgYLk/mcgyYeaUDWyXcxNCCCHEpWXE7/dj4sSJWLZsWWRbOBzGsmXLUFZW5qiPUCiEjRs3oqSkJHbjNHHx2I47NkIIIaSr4dqXcPPNN+PKK6/EpEmTcNppp+Ghhx5CXV0drrrqKgDAnDlz0K9fP5SXlwMA7rrrLpx++ukYMmQIjh8/jvvvvx+7d+/GNddck9wrSSJuU4+ZwksIIYTEj2sxctlll+HQoUO44447UFFRgXHjxuG1116LBLXu2bMHHk/U4HLs2DFce+21qKioQI8ePTBx4kSsXLkSI0eOTN5VEEIIIaTToqiqKq9l3oGorq5GYWEhqqqqUFBQkNS+65taMPKOJbpta39xLnp1y7ZsxwBVQgghJDZO5++MXyiPEEIIIekl48WIFu/BFXYJIYSQ9EBfQxuxVthlkCohhBCSGjLeMkIIIYSQ9ELLSBu0fBBCCCHpgZYRQgghhKQVihFCCCGEpBWKEUIIIYSkFYoRQgghhKQVihFCCCGEpBWKEUIIIYSkFYoRQgghhKQVihFCCCGEpBWKEUIIIYSkFYoRQgghhKQVihFCCCGEpBWKEUIIIYSkFYoRQgghhKQVihFCCCGEpBWKEUIIIYSkFV+6B+AEVVUBANXV1WkeCSGEEEKcos3b2jxuRacQIzU1NQCA0tLSNI+EEEIIIW6pqalBYWGh5X5FjSVXOgDhcBhffPEF8vPzoShK0vqtrq5GaWkp9u7di4KCgqT129nhfTHDe2KG90QO74sZ3hMzmXJPVFVFTU0N+vbtC4/HOjKkU1hGPB4P+vfvn7L+CwoKuvSXIV54X8zwnpjhPZHD+2KG98RMJtwTO4uIBgNYCSGEEJJWKEYIIYQQklYyWowEAgHceeedCAQC6R5Kh4L3xQzviRneEzm8L2Z4T8zwnujpFAGshBBCCOm6ZLRlhBBCCCHph2KEEEIIIWmFYoQQQgghaYVihBBCCCFphWKEEEIIIWklo8XII488gkGDBiE7OxuTJ0/GmjVr0j2klPH222/joosuQt++faEoChYvXqzbr6oq7rjjDpSUlCAnJwfTp0/Htm3bdG2OHj2KK664AgUFBejevTuuvvpq1NbWtuNVJJfy8nKceuqpyM/PR58+fTB79mxs3bpV16axsRFz587FCSecgG7duuFrX/saKisrdW327NmDWbNmITc3F3369MFPf/pTtLS0tOelJI358+djzJgxkaqQZWVlePXVVyP7M+1+yLjvvvugKApuuummyLZMvC+/+tWvoCiK7m/48OGR/Zl4TwBg//79+Pa3v40TTjgBOTk5GD16NNauXRvZn4m/tY5QM5RFixapfr9ffeqpp9TNmzer1157rdq9e3e1srIy3UNLCa+88or685//XP3Pf/6jAlBfeOEF3f777rtPLSwsVBcvXqx+9NFH6sUXX6wOHjxYbWhoiLS54IIL1LFjx6rvv/+++s4776hDhgxRL7/88na+kuQxY8YM9a9//au6adMmdcOGDeqFF16oDhgwQK2trY20ue6669TS0lJ12bJl6tq1a9XTTz9dnTJlSmR/S0uLOmrUKHX69Onq+vXr1VdeeUXt1auXOm/evHRcUsL897//VV9++WX1s88+U7du3arefvvtalZWlrpp0yZVVTPvfhhZs2aNOmjQIHXMmDHqjTfeGNmeifflzjvvVE855RT1wIEDkb9Dhw5F9mfiPTl69Kg6cOBA9bvf/a66evVqdceOHeqSJUvU7du3R9pk4m+tEzJWjJx22mnq3LlzI+9DoZDat29ftby8PI2jah+MYiQcDqvFxcXq/fffH9l2/PhxNRAIqP/85z9VVVXVLVu2qADUDz74INLm1VdfVRVFUffv399uY08lBw8eVAGob731lqqqrfcgKytLffbZZyNtPvnkExWAumrVKlVVW0Wex+NRKyoqIm3mz5+vFhQUqMFgsH0vIEX06NFDfeKJJzL+ftTU1KhDhw5Vly5dqk6dOjUiRjL1vtx5553q2LFjpfsy9Z787Gc/U88880zL/fyttSYj3TRNTU1Yt24dpk+fHtnm8Xgwffp0rFq1Ko0jSw87d+5ERUWF7n4UFhZi8uTJkfuxatUqdO/eHZMmTYq0mT59OjweD1avXt3uY04FVVVVAICePXsCANatW4fm5mbdfRk+fDgGDBiguy+jR49GUVFRpM2MGTNQXV2NzZs3t+Pok08oFMKiRYtQV1eHsrKyjL8fc+fOxaxZs3TXD2T292Tbtm3o27cvTjzxRFxxxRXYs2cPgMy9J//9738xadIkXHrppejTpw/Gjx+Pv/zlL5H9/K21JiPFyOHDhxEKhXT/CQCgqKgIFRUVaRpV+tCu2e5+VFRUoE+fPrr9Pp8PPXv27BL3LBwO46abbsIZZ5yBUaNGAWi9Zr/fj+7du+vaGu+L7L5p+zojGzduRLdu3RAIBHDdddfhhRdewMiRIzP2fgDAokWL8OGHH6K8vNy0L1Pvy+TJk7FgwQK89tprmD9/Pnbu3ImzzjoLNTU1GXtPduzYgfnz52Po0KFYsmQJrr/+evz4xz/G3/72NwD8rbXDl+4BENIRmDt3LjZt2oR333033UNJO8OGDcOGDRtQVVWF5557DldeeSXeeuutdA8rbezduxc33ngjli5diuzs7HQPp8Mwc+bMyOsxY8Zg8uTJGDhwIP79738jJycnjSNLH+FwGJMmTcK9994LABg/fjw2bdqERx99FFdeeWWaR9exyUjLSK9eveD1ek2R3ZWVlSguLk7TqNKHds1296O4uBgHDx7U7W9pacHRo0c7/T274YYb8NJLL+HNN99E//79I9uLi4vR1NSE48eP69ob74vsvmn7OiN+vx9DhgzBxIkTUV5ejrFjx+Lhhx/O2Puxbt06HDx4EBMmTIDP54PP58Nbb72FP/zhD/D5fCgqKsrI+2Kke/fuOPnkk7F9+/aM/a6UlJRg5MiRum0jRoyIuK8y/bfWjowUI36/HxMnTsSyZcsi28LhMJYtW4aysrI0jiw9DB48GMXFxbr7UV1djdWrV0fuR1lZGY4fP45169ZF2ixfvhzhcBiTJ09u9zEnA1VVccMNN+CFF17A8uXLMXjwYN3+iRMnIisrS3dftm7dij179ujuy8aNG3U/HkuXLkVBQYHpR6mzEg6HEQwGM/Z+nHvuudi4cSM2bNgQ+Zs0aRKuuOKKyOtMvC9Gamtr8fnnn6OkpCRjvytnnHGGqTzAZ599hoEDBwLI3N9aR6Q7gjZdLFq0SA0EAuqCBQvULVu2qN///vfV7t276yK7uxI1NTXq+vXr1fXr16sA1N///vfq+vXr1d27d6uq2ppu1r17d/XFF19UP/74Y/WSSy6RppuNHz9eXb16tfruu++qQ4cO7dTpZtdff71aWFiorlixQpeeWF9fH2lz3XXXqQMGDFCXL1+url27Vi0rK1PLysoi+7X0xPPPP1/dsGGD+tprr6m9e/futOmJt912m/rWW2+pO3fuVD/++GP1tttuUxVFUV9//XVVVTPvflghZtOoambel1tuuUVdsWKFunPnTvW9995Tp0+frvbq1Us9ePCgqqqZeU/WrFmj+nw+9Z577lG3bdum/uMf/1Bzc3PVZ555JtImE39rnZCxYkRVVfWPf/yjOmDAANXv96unnXaa+v7776d7SCnjzTffVAGY/q688kpVVVtTzn75y1+qRUVFaiAQUM8991x169atuj6OHDmiXn755Wq3bt3UgoIC9aqrrlJramrScDXJQXY/AKh//etfI20aGhrUH/7wh2qPHj3U3Nxc9Stf+Yp64MABXT+7du1SZ86cqebk5Ki9evVSb7nlFrW5ubmdryY5fO9731MHDhyo+v1+tXfv3uq5554bESKqmnn3wwqjGMnE+3LZZZepJSUlqt/vV/v166dedtllunoamXhPVFVV//e//6mjRo1SA4GAOnz4cPXxxx/X7c/E31onKKqqqumxyRBCCCGEZGjMCCGEEEI6DhQjhBBCCEkrFCOEEEIISSsUI4QQQghJKxQjhBBCCEkrFCOEEEIISSsUI4QQQghJKxQjhBBCCEkrFCOEEEIISSsUI4QQQghJKxQjhBBCCEkr/x+uuFIY6PmGrQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "reward_hist = np.array(q_env.reward_history)\n", - "\n", - "pf_mean_hist = -np.log10(1. - np.mean(reward_hist, axis=1))\n", - "pf_std_hist = -np.log10(1. - np.std(reward_hist, axis=1))\n", - "\n", - "plt.errorbar(np.arange(len(reward_hist)), pf_mean_hist, yerr=pf_std_hist)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "metadata": {}, - "outputs": [ + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "[[-5.58376662e-04 3.71710137e-02 2.83655882e-01 5.84286869e-01\n", - " -4.34491336e-02 -5.35132289e-02 -2.96272606e-01]\n", - " [ 3.35727964e-04 1.86646610e-01 4.43352520e-01 5.76919436e-01\n", - " -4.07642983e-02 -6.03764504e-02 -2.82482535e-01]\n", - " [-2.79297633e-03 1.26424050e-02 3.59021217e-01 5.59786916e-01\n", - " -4.45756391e-02 -5.56047261e-02 -2.65633523e-01]\n", - " [-3.27075133e-03 4.99847606e-02 3.19938004e-01 5.41228771e-01\n", - " -3.83227505e-02 -5.43864556e-02 -2.52430707e-01]\n", - " [-3.22321733e-03 6.04441166e-02 2.32093483e-01 5.25236070e-01\n", - " -3.25061455e-02 -5.38300537e-02 -2.34052226e-01]\n", - " [-1.95786779e-04 9.35754627e-02 2.57606506e-01 5.18513501e-01\n", - " -4.55953032e-02 -3.77426706e-02 -2.14172736e-01]\n", - " [ 1.36486220e-03 1.83728822e-02 2.73302644e-01 5.08394480e-01\n", - " -3.62073854e-02 -4.81719449e-02 -1.90479100e-01]\n", - " [-2.68273777e-03 9.33362618e-02 3.52148443e-01 4.93035048e-01\n", - " -3.66185680e-02 -5.38651086e-02 -1.70757920e-01]\n", - " [-9.27919755e-04 1.73141599e-01 2.77335882e-01 4.84731942e-01\n", - " -3.21951695e-02 -5.44991232e-02 -1.50890082e-01]\n", - " [-2.67657079e-03 9.75594297e-02 2.25941360e-01 4.68628138e-01\n", - " -2.31804792e-02 -5.70043027e-02 -1.36018276e-01]\n", - " [-2.67326413e-03 -1.66244619e-02 3.24222296e-01 4.53654110e-01\n", - " -2.66986061e-02 -4.85775135e-02 -1.16542205e-01]\n", - " [-1.07768772e-03 -4.90250103e-02 3.47329736e-01 4.38644886e-01\n", - " -2.97536626e-02 -6.10259660e-02 -8.80995244e-02]\n", - " [ 6.78420474e-04 1.14128247e-01 1.13038838e-01 4.23338801e-01\n", - " -2.60650553e-02 -4.16751467e-02 -7.56628960e-02]\n", - " [ 9.52997769e-04 -2.58845557e-02 3.86070192e-01 4.09358531e-01\n", - " -1.99937001e-02 -4.25034836e-02 -4.54639830e-02]\n", - " [ 6.31468720e-05 9.08210352e-02 1.83577374e-01 3.94338608e-01\n", - " -1.88802592e-02 -4.55579422e-02 -3.10266502e-02]\n", - " [ 6.35380391e-04 -8.77136514e-02 3.28510076e-01 3.77283573e-01\n", - " -1.29690524e-02 -4.50170860e-02 -6.36846758e-03]\n", - " [ 1.00073719e-03 1.31835625e-01 3.50351840e-01 3.60998631e-01\n", - " -1.31607475e-02 -5.28283194e-02 1.94083508e-02]\n", - " [ 7.99460104e-04 -1.22535676e-02 2.57124215e-01 3.41023654e-01\n", - " -9.62677691e-03 -3.82847711e-02 2.80133113e-02]\n", - " [-1.75455015e-03 2.81211823e-01 2.50498086e-01 3.21292728e-01\n", - " -1.35917198e-02 -5.39221354e-02 4.99829203e-02]\n", - " [-2.29953369e-03 1.54793978e-01 2.13255763e-01 3.11559737e-01\n", - " -9.13888775e-03 -4.63940687e-02 7.53421783e-02]\n", - " [ 1.88979227e-03 4.94206138e-02 1.86860114e-01 2.85523653e-01\n", - " -7.55845103e-03 -4.58789393e-02 9.76347178e-02]\n", - " [-1.00098434e-03 3.60827446e-02 4.82431263e-01 2.66881049e-01\n", - " -8.91293492e-03 -5.69317378e-02 1.15597278e-01]\n", - " [ 2.63199385e-04 1.91758364e-01 2.12104857e-01 2.48195857e-01\n", - " -3.42038530e-03 -6.00379221e-02 1.32513463e-01]\n", - " [-4.33847774e-03 4.31166403e-03 2.86155134e-01 2.34144226e-01\n", - " -1.20803388e-03 -4.23068777e-02 1.56352177e-01]\n", - " [-4.87854704e-04 7.07283467e-02 3.34997505e-01 2.14004293e-01\n", - " -3.84147788e-05 -5.40042445e-02 1.80351034e-01]\n", - " [-8.95267120e-04 7.13667348e-02 3.11324775e-01 1.96452349e-01\n", - " 5.42395795e-03 -4.83864546e-02 2.02768072e-01]\n", - " [-1.16005260e-03 3.81037518e-02 3.22996914e-01 1.72234610e-01\n", - " 7.00039603e-03 -5.32412939e-02 2.20106825e-01]\n", - " [-2.12345901e-03 2.20832154e-01 3.13613385e-01 1.54573604e-01\n", - " 9.73308180e-03 -5.03826216e-02 2.36980751e-01]\n", - " [ 7.64394645e-05 1.58828691e-01 1.85871497e-01 1.36068329e-01\n", - " 1.02785844e-02 -5.10814823e-02 2.63184667e-01]\n", - " [ 1.81912328e-05 1.76636040e-01 3.96664560e-01 1.14803195e-01\n", - " 9.03652888e-03 -4.93537411e-02 2.79278576e-01]\n", - " [ 1.29923504e-03 2.10962459e-01 3.58348757e-01 9.97341201e-02\n", - " 1.00341877e-02 -5.26990108e-02 2.93530107e-01]\n", - " [-1.12952862e-03 8.20996165e-02 3.09355021e-01 7.81879351e-02\n", - " 1.47725195e-02 -4.54406999e-02 3.17280471e-01]\n", - " [ 6.67073531e-04 5.48780225e-02 2.83605218e-01 5.40479906e-02\n", - " 1.71851683e-02 -6.27930462e-02 3.32167625e-01]\n", - " [-1.04102679e-03 1.94142893e-01 2.63496310e-01 3.87156643e-02\n", - " 1.78968590e-02 -5.43451533e-02 3.55374128e-01]\n", - " [ 6.98322779e-04 6.98832795e-02 2.26173311e-01 1.57313645e-02\n", - " 2.16248576e-02 -5.88655025e-02 3.67800176e-01]\n", - " [ 1.09194370e-05 1.41051665e-01 2.45627254e-01 2.90450919e-03\n", - " 2.05357131e-02 -5.75263798e-02 3.84045780e-01]\n", - " [-3.93119262e-06 5.49332276e-02 3.24228108e-01 -2.26857122e-02\n", - " 2.41305828e-02 -5.45962043e-02 4.01913106e-01]\n", - " [ 2.38947032e-04 2.00921386e-01 4.12730932e-01 -3.95076834e-02\n", - " 2.20026802e-02 -4.83079404e-02 4.17185634e-01]\n", - " [-1.46564475e-04 1.79424658e-01 2.51978815e-01 -5.59336618e-02\n", - " 2.63350420e-02 -5.04102595e-02 4.42543209e-01]\n", - " [-1.71882845e-03 5.23010567e-02 2.42769033e-01 -7.73226246e-02\n", - " 3.04085184e-02 -5.79289049e-02 4.47403282e-01]\n", - " [ 3.14023043e-03 1.26089364e-01 2.88250357e-01 -1.00384541e-01\n", - " 3.19290459e-02 -5.02152555e-02 4.66118157e-01]\n", - " [ 7.31402542e-06 5.28462306e-02 3.91727805e-01 -1.16412513e-01\n", - " 3.49375829e-02 -4.76681963e-02 4.81652468e-01]\n", - " [ 1.47933664e-03 2.13671774e-01 1.91049784e-01 -1.37827843e-01\n", - " 3.52223255e-02 -4.64182124e-02 5.02750099e-01]\n", - " [-4.57210263e-04 2.07729980e-01 2.28208259e-01 -1.54687583e-01\n", - " 3.62687223e-02 -3.89702134e-02 5.11603117e-01]\n", - " [-2.11749284e-04 2.73397833e-01 2.33013049e-01 -1.70880228e-01\n", - " 3.89538184e-02 -4.18340489e-02 5.28123915e-01]\n", - " [-1.36930472e-03 2.21530989e-01 3.16481858e-01 -1.89784229e-01\n", - " 3.60112488e-02 -4.93225753e-02 5.37120938e-01]\n", - " [ 3.27408756e-03 2.98784107e-01 2.75724888e-01 -2.10383117e-01\n", - " 4.32928689e-02 -5.47275022e-02 5.45810640e-01]\n", - " [ 3.42207612e-04 1.58325478e-01 3.49794984e-01 -2.25133970e-01\n", - " 4.48424928e-02 -4.88688909e-02 5.62125623e-01]\n", - " [-1.16307242e-03 1.23091221e-01 3.19913924e-01 -2.44522244e-01\n", - " 4.44088094e-02 -4.78904769e-02 5.77923179e-01]\n", - " [ 1.89866358e-03 1.93869084e-01 1.13300495e-01 -2.61649340e-01\n", - " 4.98280823e-02 -4.68509719e-02 5.84139943e-01]\n", - " [ 2.40421225e-03 2.39012554e-01 3.37499797e-01 -2.77788222e-01\n", - " 5.17962016e-02 -5.17398864e-02 6.00755692e-01]]\n", - "[ 0.0002632 0.19175836 0.21210486 0.24819586 -0.00342039 -0.06003792\n", - " 0.13251346]\n" + "Fidelity stored 0.9995819233201195\n", + "(1,)\n", + "(32,)\n" ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print(mean_actions)\n", - "print(mean_actions[np.argmax(mean_reward)])\n", - "plt.axvline(x=obs_rad_linspace[np.argmax(mean_reward)])\n", - "for i in range(len(mean_actions.T)):\n", - " plt.errorbar(obs_rad_linspace, mean_actions[:, i], yerr=std_actions[:, i], fmt=\"o\", label=f'Action {i}')\n", - "plt.plot(obs_rad_linspace, obs_rad_linspace * 0.15, label='analytical +')\n", - "plt.plot(obs_rad_linspace, -obs_rad_linspace * 0.15, label='analytical -')\n", - "plt.plot(obs_rad_linspace, mean_actions[:, 3] + mean_actions[:, 6], label='sum 3 + 6')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [ + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.scatter(obs_linspace, mean_fidelity, label='Evaluated Policy Rewards')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9992867174368594\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996172728049516\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.999580450010197\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9994970631798292\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9994989197867016\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9995501681994544\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.999652680926903\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9995400640654557\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996348729194049\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9994418448583102\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9995877880786447\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996640988715186\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996049754997258\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996066893328095\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996283621480437\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997364776793454\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997545278396223\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9998025692318201\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997584439217018\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997843891517456\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator') has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator') has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997978641792905\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9998000445032751\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9998163544692007\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997313669710846\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.999803394617222\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997668602913659\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997534308574461\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996658029150061\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996205973975986\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996574384608383\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997939145925396\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996722048677942\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997239626440546\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9995919419550613\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996563219545755\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996573702254364\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997093987719088\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996836748291678\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996783878323732\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9997641243050471\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996846250775983\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9996417329842491\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9994577996403126\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9994989969490946\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9991660845844965\n", + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.9991209428639112\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + } + ], + "source": [ + "# Evaluating Policy across Parameter Space\n", + "\n", + "import torch\n", + "\n", + "obs_linspace = np.linspace(-1.0, 1.0, 51)\n", + "\n", + "mean_reward = np.zeros_like(obs_linspace)\n", + "std_reward = np.zeros_like(obs_linspace)\n", + "mean_actions = np.zeros((len(obs_linspace),) + q_env.action_space.shape)\n", + "std_actions = np.zeros((len(obs_linspace),) + q_env.action_space.shape)\n", + "\n", + "for i, test_obs in enumerate(obs_linspace):\n", + " test_obs, _ = ppo_agent.env.reset(seed=ppo_agent.seed, override_obs=test_obs)\n", + " batch_test_obs = np.tile(test_obs, (ppo_agent.num_envs, 1))\n", + " with torch.no_grad():\n", + " action, logprob, _, value = ppo_agent.agent.get_action_and_value(\n", + " torch.Tensor(batch_test_obs)\n", + " )\n", + " cpu_action = action.cpu().numpy()\n", + " cpu_action = np.clip(\n", + " cpu_action,\n", + " ppo_agent.env.action_space.low,\n", + " ppo_agent.env.action_space.high,\n", + " )\n", + "\n", + " played_action = cpu_action\n", + " # played_action[:, 0] = 0.\n", + " # played_action[:, 1] = 0.\n", + " # played_action[:, 2] = 0.\n", + " # played_action[:, 4] = 0.\n", + " # played_action[:, 5] = 0.\n", + " # played_action[:, 3] = -0.5 * q_env.gamma * test_obs * np.pi + 0.25\n", + " # played_action[:, 6] = 0.5 * q_env.gamma * test_obs * np.pi + 0.25\n", + "\n", + " mean_actions[i] = np.mean(played_action, axis=0)\n", + " std_actions[i] = np.std(played_action, axis=0)\n", + "\n", + " next_obs, reward, terminations, truncations, infos = ppo_agent.env.step(\n", + " played_action\n", + " )\n", + " mean_reward[i] = np.mean(reward)\n", + " std_reward[i] = np.std(reward)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.7740517577766477\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "mean_fidelity = 1. - 10**(-mean_reward)\n", + "std_fidelity = 1. - 10**(-std_reward)\n", + "\n", + "obs_rad_linspace = obs_linspace * np.pi\n", + "\n", + "print(np.max(mean_reward))\n", + "\n", + "plt.errorbar(obs_rad_linspace, mean_reward, yerr=std_reward, fmt=\"o\", label='Evaluated Policy Rewards')\n", + "plt.axvline(x=obs_rad_linspace[np.argmax(mean_reward)])\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([1, 32, 1])\n" + ] + } + ], + "source": [ + "print(ppo_agent.obs.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reward_hist = np.array(q_env.reward_history)\n", + "\n", + "pf_mean_hist = -np.log10(1. - np.mean(reward_hist, axis=1))\n", + "pf_std_hist = -np.log10(1. - np.std(reward_hist, axis=1))\n", + "\n", + "plt.errorbar(np.arange(len(reward_hist)), pf_mean_hist, yerr=pf_std_hist)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-2.25193286e-03 3.51546258e-02 2.76137739e-01 5.70612133e-01\n", + " -4.23651077e-02 -4.96658646e-02 -3.28356147e-01]\n", + " [-1.33653800e-03 1.81385323e-01 4.36828494e-01 5.63252389e-01\n", + " -3.97507586e-02 -5.56993708e-02 -3.15008372e-01]\n", + " [-4.53636516e-03 1.06929038e-02 3.52190912e-01 5.45740187e-01\n", + " -4.39931080e-02 -5.16052879e-02 -2.98519343e-01]\n", + " [-5.02966624e-03 4.70714495e-02 3.13045502e-01 5.26723146e-01\n", + " -3.76090892e-02 -5.06050475e-02 -2.85728514e-01]\n", + " [-4.98519000e-03 5.71150780e-02 2.24864274e-01 5.10371208e-01\n", + " -3.16675231e-02 -5.01827560e-02 -2.67616451e-01]\n", + " [-1.87280052e-03 8.93799737e-02 2.50681520e-01 5.03729641e-01\n", + " -4.58045714e-02 -3.61755863e-02 -2.47925133e-01]\n", + " [-2.62326270e-04 1.54881552e-02 2.66636044e-01 4.93556052e-01\n", + " -3.60654928e-02 -4.53606397e-02 -2.24266380e-01]\n", + " [-4.44081239e-03 8.87579918e-02 3.46121341e-01 4.77892816e-01\n", + " -3.67523246e-02 -5.04158884e-02 -2.04641595e-01]\n", + " [-2.62884167e-03 1.66785508e-01 2.71049917e-01 4.69671309e-01\n", + " -3.22783254e-02 -5.10439873e-02 -1.84820428e-01]\n", + " [-4.44277097e-03 9.25249681e-02 2.19532311e-01 4.53248709e-01\n", + " -2.28739027e-02 -5.33193611e-02 -1.70118392e-01]\n", + " [-4.44373814e-03 -1.95784718e-02 3.18605900e-01 4.38028395e-01\n", + " -2.68944837e-02 -4.59864549e-02 -1.50618225e-01]\n", + " [-2.78907968e-03 -5.15232719e-02 3.42060387e-01 4.22784388e-01\n", + " -3.04382816e-02 -5.70197776e-02 -1.21770076e-01]\n", + " [-9.62342834e-04 1.08239852e-01 1.06505699e-01 4.07240957e-01\n", + " -2.67349444e-02 -4.00504321e-02 -1.09474421e-01]\n", + " [-6.75540068e-04 -2.91966088e-02 3.81473958e-01 3.93122435e-01\n", + " -2.04522982e-02 -4.08517085e-02 -7.86702111e-02]\n", + " [-1.60423690e-03 8.50582346e-02 1.77899271e-01 3.77919674e-01\n", + " -1.95136704e-02 -4.36225981e-02 -6.42087609e-02]\n", + " [-1.00650184e-03 -9.01656151e-02 3.23989987e-01 3.60567689e-01\n", + " -1.33812949e-02 -4.32220846e-02 -3.90457697e-02]\n", + " [-6.23872445e-04 1.24962904e-01 3.46203774e-01 3.44052166e-01\n", + " -1.38536375e-02 -5.02144136e-02 -1.26475105e-02]\n", + " [-8.34449078e-04 -1.64964218e-02 2.52588153e-01 3.23610336e-01\n", + " -1.02845328e-02 -3.74169573e-02 -4.15222347e-03]\n", + " [-3.51565564e-03 2.71180451e-01 2.46148095e-01 3.03437233e-01\n", + " -1.48679456e-02 -5.13611846e-02 1.83701217e-02]\n", + " [-4.09145141e-03 1.47052035e-01 2.08885863e-01 2.93989033e-01\n", + " -1.02962870e-02 -4.47694920e-02 4.45083305e-02]\n", + " [ 3.13908909e-04 4.35501374e-02 1.82543278e-01 2.67082304e-01\n", + " -8.84921569e-03 -4.43977155e-02 6.74918890e-02]\n", + " [-2.72981729e-03 3.03272773e-02 4.80400324e-01 2.48112753e-01\n", + " -1.06083173e-02 -5.43164015e-02 8.59789997e-02]\n", + " [-1.39773590e-03 1.82937860e-01 2.08438843e-01 2.29110360e-01\n", + " -4.88267234e-03 -5.71798496e-02 1.03411354e-01]\n", + " [-6.25569467e-03 -1.11268996e-03 2.83254445e-01 2.15111226e-01\n", + " -2.73825089e-03 -4.14769426e-02 1.28187835e-01]\n", + " [-2.19017058e-03 6.39383942e-02 3.32693547e-01 1.94570839e-01\n", + " -1.73438620e-03 -5.19998148e-02 1.53193742e-01]\n", + " [-2.62070284e-03 6.44477829e-02 3.09104562e-01 1.76832333e-01\n", + " 3.98520334e-03 -4.70799170e-02 1.76586971e-01]\n", + " [-2.90054991e-03 3.16849165e-02 3.21114719e-01 1.51904672e-01\n", + " 5.44363819e-03 -5.15130274e-02 1.94661558e-01]\n", + " [-3.92079260e-03 2.10956112e-01 3.11918348e-01 1.34067282e-01\n", + " 8.17704387e-03 -4.90525588e-02 2.12285116e-01]\n", + " [-1.58673932e-03 1.49994135e-01 1.83496356e-01 1.15327746e-01\n", + " 8.50491505e-03 -4.97740544e-02 2.39838153e-01]\n", + " [-1.64547237e-03 1.67390257e-01 3.96094918e-01 9.36065018e-02\n", + " 6.86052674e-03 -4.83211689e-02 2.56719500e-01]\n", + " [-2.80701846e-04 2.01017410e-01 3.57755721e-01 7.86087960e-02\n", + " 7.68591557e-03 -5.14186211e-02 2.71678060e-01]\n", + " [-2.85788998e-03 7.43813738e-02 3.08655977e-01 5.65932728e-02\n", + " 1.26481643e-02 -4.49952520e-02 2.96762735e-01]\n", + " [-9.42018407e-04 4.75578457e-02 2.82970756e-01 3.17603983e-02\n", + " 1.50465034e-02 -6.06924258e-02 3.12461734e-01]\n", + " [-2.75476300e-03 1.84286341e-01 2.62966961e-01 1.65002029e-02\n", + " 1.55655704e-02 -5.31938933e-02 3.37045461e-01]\n", + " [-8.95637204e-04 6.21372461e-02 2.25617439e-01 -7.07726832e-03\n", + " 1.94296446e-02 -5.73663823e-02 3.50179046e-01]\n", + " [-1.62101025e-03 1.31996244e-01 2.45473683e-01 -1.95968095e-02\n", + " 1.79564077e-02 -5.62610477e-02 3.67404073e-01]\n", + " [-1.62896106e-03 4.73010391e-02 3.24928910e-01 -4.60148528e-02\n", + " 2.16825474e-02 -5.37161008e-02 3.86382401e-01]\n", + " [-1.36098952e-03 1.90724179e-01 4.14365917e-01 -6.28800318e-02\n", + " 1.90560333e-02 -4.81296927e-02 4.02612031e-01]\n", + " [-1.76328351e-03 1.69546932e-01 2.52636492e-01 -7.93103129e-02\n", + " 2.36110929e-02 -5.01234308e-02 4.29638416e-01]\n", + " [-3.43393278e-03 4.45193760e-02 2.43608698e-01 -1.01158254e-01\n", + " 2.78860256e-02 -5.70267625e-02 4.34769660e-01]\n", + " [ 1.77327741e-03 1.17017105e-01 2.89692968e-01 -1.24840192e-01\n", + " 2.93250922e-02 -5.01312613e-02 4.54728663e-01]\n", + " [-1.56600541e-03 4.49425392e-02 3.94222915e-01 -1.40840888e-01\n", + " 3.24259028e-02 -4.79101539e-02 4.71297711e-01]\n", + " [ 2.27138953e-05 2.03074574e-01 1.92239970e-01 -1.62736431e-01\n", + " 3.24946828e-02 -4.68619466e-02 4.93839949e-01]\n", + " [-2.03797361e-03 1.97203413e-01 2.29934469e-01 -1.79654732e-01\n", + " 3.34150903e-02 -4.01719958e-02 5.03267109e-01]\n", + " [-1.76115497e-03 2.61787057e-01 2.35023066e-01 -1.95847556e-01\n", + " 3.61682214e-02 -4.28572297e-02 5.20921648e-01]\n", + " [-2.98805302e-03 2.10738614e-01 3.19387257e-01 -2.15016946e-01\n", + " 3.26384939e-02 -4.97633852e-02 5.30505657e-01]\n", + " [ 2.00904021e-03 2.86750466e-01 2.78556079e-01 -2.36054778e-01\n", + " 4.05371673e-02 -5.47818430e-02 5.39757013e-01]\n", + " [-1.12070004e-03 1.48496658e-01 3.53445828e-01 -2.50691473e-01\n", + " 4.20348868e-02 -4.95184883e-02 5.57202458e-01]\n", + " [-2.72061024e-03 1.13790803e-01 3.23571384e-01 -2.70425886e-01\n", + " 4.13164198e-02 -4.87061627e-02 5.74097097e-01]\n", + " [ 5.86277514e-04 1.83454335e-01 1.15581498e-01 -2.87692636e-01\n", + " 4.71540950e-02 -4.78347205e-02 5.80684841e-01]\n", + " [ 1.14873680e-03 2.27898180e-01 3.41767251e-01 -3.03888023e-01\n", + " 4.91331965e-02 -5.23952693e-02 5.98463774e-01]]\n", + "[-0.00290055 0.03168492 0.32111472 0.15190467 0.00544364 -0.05151303\n", + " 0.19466156]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(mean_actions)\n", + "print(mean_actions[np.argmax(mean_reward)])\n", + "plt.axvline(x=obs_rad_linspace[np.argmax(mean_reward)])\n", + "for i in range(len(mean_actions.T)):\n", + " plt.errorbar(obs_rad_linspace, mean_actions[:, i], yerr=std_actions[:, i], fmt=\"o\", label=f'Action {i}')\n", + "plt.plot(obs_rad_linspace, obs_rad_linspace * 0.15, label='analytical +')\n", + "plt.plot(obs_rad_linspace, -obs_rad_linspace * 0.15, label='analytical -')\n", + "plt.plot(obs_rad_linspace, mean_actions[:, 3] + mean_actions[:, 6], label='sum 3 + 6')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(obs_linspace, mean_fidelity, label='Evaluated Policy Rewards')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.7938926261462362\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.8306559326618255\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.8644843137107057\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.8950775061878449\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9221639627510073\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9455032620941837\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9648882429441255\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9801468428384712\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9911436253643444\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.99778098230154\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator') has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator') has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9999999999999998\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.99778098230154\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9911436253643444\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9801468428384716\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9648882429441259\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9455032620941841\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.9221639627510079\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fidelity stored 0.8950775061878453\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.7938926261462362\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.8306559326618255\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.8644843137107057\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.8950775061878449\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9221639627510073\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9455032620941837\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9648882429441255\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9801468428384712\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9911436253643444\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.99778098230154\n", - "\n", - " NoiseModel: Ideal \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9999999999999998\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.99778098230154\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9911436253643444\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9801468428384716\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9648882429441259\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9455032620941841\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.9221639627510079\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.8950775061878453\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", "Fidelity stored 0.8644843137107061\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Fidelity stored 0.8306559326618265\n", - "\n", - " NoiseModel:\n", - " Basis gates: ['cx', 'id', 'rz', 'sx', 'unitary']\n", - " Instructions with noise: ['custom_kron(rx,ident)_gate']\n", - " Qubits with noise: [0, 1]\n", - " Specific qubit errors: [('custom_kron(rx,ident)_gate', (0, 1))] \n", - "\n", - "Circuit context\n", - " ┌─────────────────────────────┐ \n", - " q_0 -> 0 ┤0 ├──■──\n", - " │ custom_kron(rx,ident)_gate │┌─┴─┐\n", - " q_1 -> 1 ┤1 ├┤ X ├\n", - " └─────────────────────────────┘└───┘\n", - " ancilla_0 -> 2 ────────────────────────────────────\n", - " \n", - " ancilla_1 -> 3 ────────────────────────────────────\n", - " \n", - " ancilla_2 -> 4 ────────────────────────────────────\n", - " \n", - " ancilla_3 -> 5 ────────────────────────────────────\n", - " \n", - " ancilla_4 -> 6 ────────────────────────────────────\n", - " \n", - " ancilla_5 -> 7 ────────────────────────────────────\n", - " \n", - " ancilla_6 -> 8 ────────────────────────────────────\n", - " \n", - " ancilla_7 -> 9 ────────────────────────────────────\n", - " \n", - " ancilla_8 -> 10 ────────────────────────────────────\n", - " \n", - " ancilla_9 -> 11 ────────────────────────────────────\n", - " \n", - "ancilla_10 -> 12 ────────────────────────────────────\n", - " \n", - "ancilla_11 -> 13 ────────────────────────────────────\n", - " \n", - "ancilla_12 -> 14 ────────────────────────────────────\n", - " \n", - "ancilla_13 -> 15 ────────────────────────────────────\n", - " \n", - "ancilla_14 -> 16 ────────────────────────────────────\n", - " \n", - "ancilla_15 -> 17 ────────────────────────────────────\n", - " \n", - "ancilla_16 -> 18 ────────────────────────────────────\n", - " \n", - "ancilla_17 -> 19 ────────────────────────────────────\n", - " \n", - "ancilla_18 -> 20 ────────────────────────────────────\n", - " \n", - "ancilla_19 -> 21 ────────────────────────────────────\n", - " \n", - "ancilla_20 -> 22 ────────────────────────────────────\n", - " \n", - "ancilla_21 -> 23 ────────────────────────────────────\n", - " \n", - "ancilla_22 -> 24 ────────────────────────────────────\n", - " \n", - "ancilla_23 -> 25 ────────────────────────────────────\n", - " \n", - "ancilla_24 -> 26 ────────────────────────────────────\n", - " \n", - "ancilla_25 -> 27 ────────────────────────────────────\n", - " \n", - "ancilla_26 -> 28 ────────────────────────────────────\n", - " \n", - "Fidelity stored 0.7938926261462371\n" + "(1,)\n", + "(32,)\n", + "Fidelity stored 0.7938926261462371\n", + "(1,)\n", + "(32,)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n", + "/Users/chatt07/Desktop/new_context_env/lib/python3.9/site-packages/qiskit_aer/noise/noise_model.py:379: UserWarning: Qiskit backend AerSimulator('aer_simulator'\n", + " noise_model=) has no QubitProperties, so the resulting noise model will not include any thermal relaxation errors.\n", + " warn(\n" ] } ], @@ -3546,12 +3455,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3569,73 +3478,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(obs_linspace * np.pi, mean_reward * np.log10(np.e), yerr=std_reward * np.log10(np.e), fmt=\"o\", label='Evaluated Policy Rewards')\n", - "plt.errorbar(obs_linspace * np.pi, zeros_mean_reward * np.log10(np.e), yerr=zeros_std_reward * np.log10(np.e), fmt=\"o\", label='Zeros Policy Rewards')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1e-06\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "updates = np.arange(800)\n", - "\n", - "init_lr = 3e-5\n", - "exp_time = 100\n", - "plateau_lr = 1e-6\n", - "\n", - "num_anneal_updates = 400\n", - "frac = 1.0 - (updates - 1.0) / num_anneal_updates\n", - "lr = np.clip(frac, a_min=0., a_max=None) * init_lr + plateau_lr\n", - "\n", - "exp_lr = init_lr * np.exp(-updates / exp_time) + plateau_lr\n", - "\n", - "print(lr[-1])\n", - "\n", - "plt.plot(updates, lr, label='Linear Learning Rate')\n", - "plt.plot(updates, exp_lr, label='Exp Learning Rate')\n", - "plt.legend()\n", - "plt.show()" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/rl_qoc/ppo.py b/rl_qoc/ppo.py index 327023f..591cc3c 100644 --- a/rl_qoc/ppo.py +++ b/rl_qoc/ppo.py @@ -98,7 +98,7 @@ def get_optimizer_from_str(optim_str): return optim_dict[optim_str] -def initialize_environment(env: BaseQuantumEnvironment | Wrapper) -> tuple: +def initialize_environment(env: BaseQuantumEnvironment) -> tuple: """ Initializes the environment by extracting necessary information. @@ -325,7 +325,7 @@ def get_empty_tensors(env, num_time_steps, batchsize): def reset_env( - env: BaseQuantumEnvironment | Wrapper, seed, global_step, batchsize, dones + env: BaseQuantumEnvironment, seed, global_step, batchsize, dones ): """ Resets the environment and returns the initial observation, number of steps, batch observations, and batch done flags. @@ -366,7 +366,7 @@ def take_step( min_action, max_action, agent: Agent, - env: BaseQuantumEnvironment | Wrapper, + env: BaseQuantumEnvironment, writer, ): """ @@ -476,7 +476,7 @@ def do_bootstrap( def flatten_batch( - env: BaseQuantumEnvironment | Wrapper, + env: BaseQuantumEnvironment, obs, logprobs, actions, @@ -740,7 +740,7 @@ class CustomPPO: def __init__( self, agent_config: Dict, - env: BaseQuantumEnvironment | Wrapper, + env: BaseQuantumEnvironment, chkpt_dir: Optional[str] = "tmp/ppo", chkpt_dir_critic: Optional[str] = "tmp/critic_ppo", ):