From 71e1bf1084390c47de122c48c520f297d3526deb Mon Sep 17 00:00:00 2001 From: Manoel Marques Date: Wed, 29 Jun 2022 10:32:43 -0400 Subject: [PATCH 01/96] Add primitives branch to CI workflow --- .github/workflows/main.yml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 5f3f93eeb..d177615be 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -16,17 +16,16 @@ on: push: branches: - main + - primitives - 'stable/**' pull_request: branches: - main + - primitives - 'stable/**' - schedule: - # run every day at 1AM - - cron: '0 1 * * *' concurrency: - group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }} + group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }}-${{ github.workflow }} cancel-in-progress: true jobs: From ae9c043be427212c058741014398c1feea347e93 Mon Sep 17 00:00:00 2001 From: Gian Gentinetta Date: Wed, 29 Jun 2022 18:01:58 +0200 Subject: [PATCH 02/96] added pocs --- .../primitives/__init__.py | 24 +++ .../primitives/kernels/__init__.py | 44 +++++ .../primitives/kernels/base_kernel.py | 118 ++++++++++++++ .../primitives/kernels/pseudo_kernel.py | 131 +++++++++++++++ .../primitives/kernels/quantum_kernel.py | 152 ++++++++++++++++++ .../kernels/trainable_quantum_kernel.py | 69 ++++++++ qiskit_machine_learning/utils/__init__.py | 4 + qiskit_machine_learning/utils/utils.py | 20 +++ 8 files changed, 562 insertions(+) create mode 100644 qiskit_machine_learning/primitives/__init__.py create mode 100644 qiskit_machine_learning/primitives/kernels/__init__.py create mode 100644 qiskit_machine_learning/primitives/kernels/base_kernel.py create mode 100644 qiskit_machine_learning/primitives/kernels/pseudo_kernel.py create mode 100644 qiskit_machine_learning/primitives/kernels/quantum_kernel.py create mode 100644 qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py create mode 100644 qiskit_machine_learning/utils/utils.py diff --git a/qiskit_machine_learning/primitives/__init__.py b/qiskit_machine_learning/primitives/__init__.py new file mode 100644 index 000000000..66253d188 --- /dev/null +++ b/qiskit_machine_learning/primitives/__init__.py @@ -0,0 +1,24 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Primitives (:mod:`qiskit_machine_learning.primitives`) +=============================================================== + +.. currentmodule:: qiskit_machine_learning.primitives + +""" + +from .kernels import BaseKernel, QuantumKernel, TrainableQuantumKernel, PseudoKernel + + +__all__ = ["BaseKernel", "QuantumKernel", "TrainableQuantumKernel", "PseudoKernel"] diff --git a/qiskit_machine_learning/primitives/kernels/__init__.py b/qiskit_machine_learning/primitives/kernels/__init__.py new file mode 100644 index 000000000..c28b088d5 --- /dev/null +++ b/qiskit_machine_learning/primitives/kernels/__init__.py @@ -0,0 +1,44 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Primitives Quantum Kernels (:mod:`qiskit_machine_learning.primitives.kernels`) + +.. currentmodule:: qiskit_machine_learning.primitives.kernels + +Quantum Kernels +=============== + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + BaseKernel + QuantumKernel + TrainableKernel + PseudoKernel + +Submodules +========== + +.. autosummary:: + :toctree: + + algorithms +""" + +from .base_kernel import BaseKernel +from .quantum_kernel import QuantumKernel +from .trainable_quantum_kernel import TrainableQuantumKernel +from .pseudo_kernel import PseudoKernel + +__all__ = ["BaseKernel", "QuantumKernel", "TrainableQuantumKernel", "PseudoKernel"] diff --git a/qiskit_machine_learning/primitives/kernels/base_kernel.py b/qiskit_machine_learning/primitives/kernels/base_kernel.py new file mode 100644 index 000000000..5826696ab --- /dev/null +++ b/qiskit_machine_learning/primitives/kernels/base_kernel.py @@ -0,0 +1,118 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +from abc import abstractmethod +from typing import Tuple, Callable, List + +import numpy as np + +from qiskit import QuantumCircuit +from qiskit.primitives import Sampler + +SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] + + +class BaseKernel: + """ + Abstract class providing the interface for the quantum kernel classes. + """ + + def __init__(self, sampler_factory: SamplerFactory, *, enforce_psd: bool = True) -> None: + """ + Args: + sampler_factory: A callable that creates a qiskit primitives sampler given a list of circuits. + enforce_psd: Project to closest positive semidefinite matrix if x = y. + Only enforced when not using the state vector simulator. Default True. + """ + self._num_features: int = 0 + self._enforce_psd = enforce_psd + self._sampler_factory = sampler_factory + + @abstractmethod + def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray: + r""" + Construct kernel matrix for given data + + If y_vec is None, self inner product is calculated. + + Args: + x_vec: 1D or 2D array of datapoints, NxD, where N is the number of datapoints, + D is the feature dimension + y_vec: 1D or 2D array of datapoints, MxD, where M is the number of datapoints, + D is the feature dimension + + Returns: + 2D matrix, NxM + + Raises: + QiskitMachineLearningError: + - A quantum instance or backend has not been provided + ValueError: + - x_vec and/or y_vec are not one or two dimensional arrays + - x_vec and y_vec have have incompatible dimensions + - x_vec and/or y_vec have incompatible dimension with feature map and + and feature map can not be modified to match. + """ + raise NotImplementedError() + + def _check_and_reshape(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> Tuple[np.ndarray]: + r""" + Performs checks on the dimensions of the input data x_vec and y_vec. + Reshapes the arrays so that `x_vec.shape = (N,D)` and `y_vec.shape = (M,D)`. + """ + if not isinstance(x_vec, np.ndarray): + x_vec = np.asarray(x_vec) + + if y_vec is not None and not isinstance(y_vec, np.ndarray): + y_vec = np.asarray(y_vec) + + if x_vec.ndim > 2: + raise ValueError("x_vec must be a 1D or 2D array") + + if x_vec.ndim == 1: + x_vec = x_vec.reshape(1, -1) + + if y_vec is not None and y_vec.ndim > 2: + raise ValueError("y_vec must be a 1D or 2D array") + + if y_vec is not None and y_vec.ndim == 1: + y_vec = y_vec.reshape(1, -1) + + if y_vec is not None and y_vec.shape[1] != x_vec.shape[1]: + raise ValueError( + "x_vec and y_vec have incompatible dimensions.\n" + f"x_vec has {x_vec.shape[1]} dimensions, but y_vec has {y_vec.shape[1]}." + ) + + if x_vec.shape[1] != self._num_features: + raise ValueError( + "x_vec and class feature map have incompatible dimensions.\n" + f"x_vec has {x_vec.shape[1]} dimensions, " + f"but feature map has {self._num_features}." + ) + + if y_vec is None: + y_vec = x_vec + + return x_vec, y_vec + + def _make_psd(self, kernel_matrix: np.ndarray) -> np.ndarray: + r""" + Find the closest positive semi-definite approximation to symmetric kernel matrix. + The (symmetric) matrix should always be positive semi-definite by construction, + but this can be violated in case of noise, such as sampling noise, thus the + adjustment is only done if NOT using the statevector simulation. + + Args: + kernel_matrix: symmetric 2D array of the kernel entries + """ + d, u = np.linalg.eig(kernel_matrix) + return u @ np.diag(np.maximum(0, d)) @ u.transpose() diff --git a/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py b/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py new file mode 100644 index 000000000..1b1eff6d2 --- /dev/null +++ b/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py @@ -0,0 +1,131 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Pseudo Overlap Kernel""" + +from typing import Optional, Callable, Union, List +import numpy as np + +from qiskit import QuantumCircuit +from qiskit.primitives import Sampler +from qiskit.primitives.fidelity import BaseFidelity + +from qiskit_machine_learning.primitives import QuantumKernel +from qiskit_machine_learning.utils import make_2d + +SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] + + +class PseudoKernel(QuantumKernel): + """ + Pseudo kernel + """ + + def __init__( + self, + sampler_factory: SamplerFactory, + feature_map: Optional[QuantumCircuit] = None, + *, + num_training_parameters: int = 0, + fidelity: Union[str, BaseFidelity] = "zero_prob", + enforce_psd: bool = True, + ) -> None: + super().__init__(sampler_factory, feature_map, fidelity=fidelity, enforce_psd=enforce_psd) + self.num_parameters = num_training_parameters + + def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray: + # allow users to only provide features, parameters are set to 0 + if x_vec.shape[1] + self.num_parameters == self._num_features: + return self.evaluate_batch(x_vec, y_vec) + else: + return super().evaluate(x_vec, y_vec) + + def evaluate_batch( + self, + x_vec: np.ndarray, + y_vec: np.ndarray, + x_parameters: np.ndarray = None, + y_parameters: np.ndarray = None, + ) -> np.ndarray: + r""" + Construct kernel matrix for given data and feature map + + If y_vec is None, self inner product is calculated. + If using `statevector_simulator`, only build circuits for :math:`\Psi(x)|0\rangle`, + then perform inner product classically. + + Args: + x_vec: 1D or 2D array of datapoints, NxD, where N is the number of datapoints, + D is the feature dimension + y_vec: 1D or 2D array of datapoints, MxD, where M is the number of datapoints, + D is the feature dimension + x_parameters: 1D or 2D array of parameters, NxP, where N is the number of datapoints, + P is the number of trainable parameters + y_parameters: 1D or 2D array of parameters, MxP + + + Returns: + 2D matrix, NxM + + Raises: + QiskitMachineLearningError: + - A quantum instance or backend has not been provided + ValueError: + - x_vec and/or y_vec are not one or two dimensional arrays + - x_vec and y_vec have have incompatible dimensions + - x_vec and/or y_vec have incompatible dimension with feature map and + and feature map can not be modified to match. + """ + if x_parameters is None: + x_parameters = np.zeros((x_vec.shape[0], self.num_parameters)) + + if y_parameters is None: + y_parameters = np.zeros((y_vec.shape[0], self.num_parameters)) + + if len(x_vec.shape) == 1: + x_vec = x_vec.reshape(1, -1) + + if len(y_vec.shape) == 1: + y_vec = y_vec.reshape(1, -1) + + if len(x_parameters.shape) == 1: + x_parameters = make_2d(x_parameters, x_vec.shape[0]) + + if len(y_parameters.shape) == 1: + y_parameters = make_2d(y_parameters, y_vec.shape[0]) + + if x_vec.shape[0] != x_parameters.shape[0]: + if x_parameters.shape[0] == 1: + x_parameters = make_2d(x_parameters, x_vec.shape[0]) + else: + raise ValueError( + f"Number of x data points ({x_vec.shape[0]}) does not coincide with number of parameter vectors {x_parameters.shape[0]}." + ) + if y_vec.shape[0] != y_parameters.shape[0]: + if y_parameters.shape[0] == 1: + x_parameters = make_2d(y_parameters, y_vec.shape[0]) + else: + raise ValueError( + f"Number of y data points ({y_vec.shape[0]}) does not coincide with number of parameter vectors {y_parameters.shape[0]}." + ) + + if x_parameters.shape[1] != self.num_parameters: + raise ValueError( + f"Number of parameters provided ({x_parameters.shape[0]}) does not coincide with the number provided in the feature map ({self.num_parameters})." + ) + + if y_parameters.shape[1] != self.num_parameters: + raise ValueError( + f"Number of parameters provided ({y_parameters.shape[0]}) does not coincide with the number provided in the feature map ({self.num_parameters})." + ) + + return self.evaluate(np.hstack((x_vec, x_parameters)), np.hstack((y_vec, y_parameters))) diff --git a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py new file mode 100644 index 000000000..02be21b1d --- /dev/null +++ b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py @@ -0,0 +1,152 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +from typing import Optional, Tuple, Callable, List, Union +import numpy as np + +from qiskit import QuantumCircuit +from qiskit.circuit.library import ZZFeatureMap +from qiskit.primitives import Sampler +from qiskit.primitives.fidelity import BaseFidelity, Fidelity + +from qiskit_machine_learning.primitives import BaseKernel + + +SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] + + +class QuantumKernel(BaseKernel): + """ + Overlap Kernel + """ + + def __init__( + self, + sampler_factory: SamplerFactory, + feature_map: Optional[QuantumCircuit] = None, + *, + fidelity: Union[str, BaseFidelity] = "zero_prob", + enforce_psd: bool = True, + ) -> None: + super().__init__(sampler_factory, enforce_psd=enforce_psd) + + if feature_map is None: + feature_map = ZZFeatureMap(2).decompose() + + self._num_features = feature_map.num_parameters + + if isinstance(fidelity, str) and fidelity == "zero_prob": + self._fidelity = Fidelity() + else: + self._fidelity = fidelity + self._fidelity.set_circuits(feature_map, feature_map) + + def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray: + x_vec, y_vec = self._check_and_reshape(x_vec, y_vec) + is_symmetric = np.all(x_vec == y_vec) + shape = len(x_vec), len(y_vec) + + if is_symmetric: + left_parameters, right_parameters = self._get_symmetric_parametrization(x_vec) + kernel_matrix = self._get_symmetric_kernel_matrix( + left_parameters, right_parameters, shape + ) + + else: + left_parameters, right_parameters = self._get_parametrization(x_vec, y_vec) + kernel_matrix = self._get_kernel_matrix(left_parameters, right_parameters, shape) + + if is_symmetric and self._enforce_psd: + kernel_matrix = self._make_psd(kernel_matrix) + return kernel_matrix + + def _get_parametrization(self, x_vec: np.ndarray, y_vec: np.ndarray) -> Tuple[np.ndarray]: + """ + Combines x_vec and y_vec to get all the combinations needed to evaluate the kernel entries. + """ + x_count = x_vec.shape[0] + y_count = y_vec.shape[0] + + left_parameters = np.zeros((x_count * y_count, x_vec.shape[1])) + right_parameters = np.zeros((x_count * y_count, y_vec.shape[1])) + index = 0 + for x_i in x_vec: + for y_j in y_vec: + left_parameters[index, :] = x_i + right_parameters[index, :] = y_j + index += 1 + + return left_parameters, right_parameters + + def _get_symmetric_parametrization(self, x_vec: np.ndarray) -> Tuple[np.ndarray]: + """ + Combines two copies of x_vec to get all the combinations needed to evaluate the kernel entries. + """ + x_count = x_vec.shape[0] + + left_parameters = np.zeros((x_count * (x_count + 1) // 2, x_vec.shape[1])) + right_parameters = np.zeros((x_count * (x_count + 1) // 2, x_vec.shape[1])) + + index = 0 + for i, x_i in enumerate(x_vec): + for x_j in x_vec[i:]: + left_parameters[index, :] = x_i + right_parameters[index, :] = x_j + index += 1 + + return left_parameters, right_parameters + + def _get_kernel_matrix( + self, left_parameters: np.ndarray, right_parameters: np.ndarray, shape: Tuple + ) -> np.ndarray: + """ + Given a parametrization, this computes the symmetric kernel matrix. + """ + kernel_entries = self._fidelity.compute(left_parameters, right_parameters) + kernel_matrix = np.zeros(shape) + + index = 0 + for i in range(shape[0]): + for j in range(shape[1]): + kernel_matrix[i, j] = kernel_entries[index] + index += 1 + return kernel_matrix + + def _get_symmetric_kernel_matrix( + self, left_parameters: np.ndarray, right_parameters: np.ndarray, shape: Tuple + ) -> np.ndarray: + """ + Given a set of parametrization, this computes the kernel matrix. + """ + kernel_entries = self._fidelity.compute(left_parameters, right_parameters) + kernel_matrix = np.zeros(shape) + index = 0 + for i in range(shape[0]): + for j in range(i, shape[1]): + kernel_matrix[i, j] = kernel_entries[index] + index += 1 + + kernel_matrix = kernel_matrix + kernel_matrix.T - np.diag(kernel_matrix.diagonal()) + return kernel_matrix + + def __enter__(self): + """ + Creates the full fidelity class by creating the sampler from the factory. + """ + self._fidelity.sampler_from_factory(self._sampler_factory) + return self + + def __exit__(self, *args): + """ + Closes the sampler session. + """ + self._fidelity.sampler.close() diff --git a/qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py b/qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py new file mode 100644 index 000000000..3041ec182 --- /dev/null +++ b/qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py @@ -0,0 +1,69 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Trainable Quantum Kernel""" + +from typing import Tuple, Optional, Callable, List, Union +import numpy as np + +from qiskit import QuantumCircuit +from qiskit.primitives import Sampler +from qiskit.primitives.fidelity import BaseFidelity + + +from qiskit_machine_learning.primitives.kernels import QuantumKernel +from qiskit_machine_learning.utils import make_2d + +SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] + + +class TrainableQuantumKernel(QuantumKernel): + """ + Trainable overlap kernel. + """ + + def __init__( + self, + sampler_factory: SamplerFactory, + feature_map: Optional[QuantumCircuit] = None, + *, + fidelity: Union[str, BaseFidelity] = "zero_prob", + num_training_parameters: int = 0, + enforce_psd: bool = True, + ) -> None: + super().__init__(sampler_factory, feature_map, fidelity=fidelity, enforce_psd=enforce_psd) + self.num_parameters = num_training_parameters + self._num_features = self._num_features - self.num_parameters + + self.parameter_values = np.zeros(self.num_parameters) + + def bind_parameters_values(self, parameter_values: np.ndarray) -> None: + """ + Fix the training parameters to numerical values. + """ + if parameter_values.shape == self.parameter_values.shape: + self.parameter_values = parameter_values + else: + raise ValueError( + f"The given parameters are in the wrong shape {parameter_values.shape}, expected {self.parameter_values.shape}." + ) + + def _get_parametrization(self, x_vec: np.ndarray, y_vec: np.ndarray) -> Tuple[np.ndarray]: + new_x_vec = np.hstack((x_vec, make_2d(self.parameter_values, len(x_vec)))) + new_y_vec = np.hstack((y_vec, make_2d(self.parameter_values, len(y_vec)))) + + return super()._get_parametrization(new_x_vec, new_y_vec) + + def _get_symmetric_parametrization(self, x_vec: np.ndarray) -> np.ndarray: + new_x_vec = np.hstack((x_vec, make_2d(self.parameter_values, len(x_vec)))) + + return super()._get_symmetric_parametrization(new_x_vec) diff --git a/qiskit_machine_learning/utils/__init__.py b/qiskit_machine_learning/utils/__init__.py index 000618000..0ac0473ae 100644 --- a/qiskit_machine_learning/utils/__init__.py +++ b/qiskit_machine_learning/utils/__init__.py @@ -26,3 +26,7 @@ loss_functions """ + +from .utils import make_2d + +__all__ = ["make_2d"] diff --git a/qiskit_machine_learning/utils/utils.py b/qiskit_machine_learning/utils/utils.py new file mode 100644 index 000000000..901658f3c --- /dev/null +++ b/qiskit_machine_learning/utils/utils.py @@ -0,0 +1,20 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +import numpy as np + + +def make_2d(array: np.ndarray, n_copies: int): + """ + Takes a 1D numpy array and copies n times it along a second axis. + """ + return np.repeat(array[np.newaxis, :], n_copies, axis=0) From 3aae2df0fb70e686e77e321ad2ce69cabb469415 Mon Sep 17 00:00:00 2001 From: Gian Gentinetta Date: Thu, 30 Jun 2022 17:52:02 +0200 Subject: [PATCH 03/96] init fixed --- qiskit_machine_learning/primitives/kernels/quantum_kernel.py | 1 + 1 file changed, 1 insertion(+) diff --git a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py index 02be21b1d..e7ec20c2e 100644 --- a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py +++ b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py @@ -9,6 +9,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. +"""Overlap Quantum Kernel""" from typing import Optional, Tuple, Callable, List, Union import numpy as np From fa98e9197e1bad69caab71e9e6b63021b4225954 Mon Sep 17 00:00:00 2001 From: Gian Gentinetta Date: Thu, 30 Jun 2022 17:56:28 +0200 Subject: [PATCH 04/96] more init --- qiskit_machine_learning/primitives/__init__.py | 5 ----- qiskit_machine_learning/primitives/kernels/pseudo_kernel.py | 2 +- qiskit_machine_learning/primitives/kernels/quantum_kernel.py | 2 +- 3 files changed, 2 insertions(+), 7 deletions(-) diff --git a/qiskit_machine_learning/primitives/__init__.py b/qiskit_machine_learning/primitives/__init__.py index 66253d188..886a6a30c 100644 --- a/qiskit_machine_learning/primitives/__init__.py +++ b/qiskit_machine_learning/primitives/__init__.py @@ -17,8 +17,3 @@ .. currentmodule:: qiskit_machine_learning.primitives """ - -from .kernels import BaseKernel, QuantumKernel, TrainableQuantumKernel, PseudoKernel - - -__all__ = ["BaseKernel", "QuantumKernel", "TrainableQuantumKernel", "PseudoKernel"] diff --git a/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py b/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py index 1b1eff6d2..63b6e4b3d 100644 --- a/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py +++ b/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py @@ -19,7 +19,7 @@ from qiskit.primitives import Sampler from qiskit.primitives.fidelity import BaseFidelity -from qiskit_machine_learning.primitives import QuantumKernel +from qiskit_machine_learning.primitives.kernels import QuantumKernel from qiskit_machine_learning.utils import make_2d SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] diff --git a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py index e7ec20c2e..16d10e3b0 100644 --- a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py +++ b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py @@ -19,7 +19,7 @@ from qiskit.primitives import Sampler from qiskit.primitives.fidelity import BaseFidelity, Fidelity -from qiskit_machine_learning.primitives import BaseKernel +from qiskit_machine_learning.primitives.kernels import BaseKernel SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] From 51063336a45737435e96a631346f20b27c8da0fc Mon Sep 17 00:00:00 2001 From: ElePT Date: Tue, 5 Jul 2022 11:12:15 +0200 Subject: [PATCH 05/96] Add qnns PoC --- .../qnns/neural_networks/sampler_qnn.py | 305 ++++++++++++++++++ .../primitives/qnns/primitives/__init__.py | 58 ++++ .../qnns/primitives/base_estimator.py | 238 ++++++++++++++ .../qnns/primitives/base_sampler.py | 181 +++++++++++ .../primitives/qnns/primitives/estimator.py | 115 +++++++ .../qnns/primitives/estimator_result.py | 44 +++ .../qnns/primitives/factories/__init__.py | 2 + .../primitives/factories/estimator_factory.py | 16 + .../statevector_estimator_factory.py | 13 + .../qnns/primitives/gradient/__init__.py | 14 + .../gradient/base_estimator_gradient.py | 37 +++ .../finite_diff_estimator_gradient.py | 56 ++++ .../gradient/finite_diff_sampler_gradient.py | 55 ++++ .../gradient/lin_comb_estimator_gradient.py | 224 +++++++++++++ .../gradient/lin_comb_sampler_gradient.py | 221 +++++++++++++ .../param_shift_estimator_gradient.py | 139 ++++++++ .../gradient/param_shift_sampler_gradient.py | 134 ++++++++ .../primitives/qnns/primitives/sampler.py | 115 +++++++ .../qnns/primitives/sampler_result.py | 43 +++ .../primitives/qnns/primitives/utils.py | 113 +++++++ .../primitives/qnns/sampler-qnn-example.py | 75 +++++ 21 files changed, 2198 insertions(+) create mode 100644 qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/__init__.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/estimator.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py create mode 100755 qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/sampler.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py create mode 100644 qiskit_machine_learning/primitives/qnns/primitives/utils.py create mode 100644 qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py diff --git a/qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py b/qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py new file mode 100644 index 000000000..9d3f3000a --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py @@ -0,0 +1,305 @@ +import logging +from numbers import Integral +import numpy as np +from typing import Optional, Union, List, Tuple, Callable, cast, Iterable +from qiskit import QuantumCircuit +from qiskit.circuit import Parameter +from qiskit_machine_learning.exceptions import QiskitMachineLearningError, QiskitError + +logger = logging.getLogger(__name__) + +# from primitives.gradient import FiniteDiffEstimatorGradient, FiniteDiffSamplerGradient + +from scipy.sparse import coo_matrix + +from primitives.gradient.param_shift_sampler_gradient import ParamShiftSamplerGradient +from qiskit.primitives import Sampler + +class SamplerQNN(): + + def __init__( + self, + circuit: QuantumCircuit, + input_params: Optional[List[Parameter]] = None, + weight_params: Optional[List[Parameter]] = None, + interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]] = None, + output_shape: Union[int, Tuple[int, ...]] = None, + sampler_factory: Callable = None, + gradient_method: str = "param_shift", + + ): + # IGNORING SPARSE + # SKIPPING CUSTOM GRADIENT + # SKIPPING "INPUT GRADIENTS" -> by default with primitives? + + # we allow only one circuit at this moment + self._circuit = circuit + # self._gradient = ParamShiftSamplerGradient(sampler, self._circuit) + + self._gradient_method = gradient_method + self._sampler_factory = sampler_factory + + self._input_params = list(input_params or []) + self._weight_params = list(weight_params or []) + + self.output_shape = None + self._num_inputs = len(self._input_params) + self._num_weights = len(self._weight_params) + self.num_weights = self._num_weights + # the circuit must always have measurements.... (?) + # add measurements in case none are given + if len(self._circuit.clbits) == 0: + self._circuit.measure_all() + + self._interpret = interpret + self._original_interpret = interpret + + # set interpret and compute output shape + self.set_interpret(interpret, output_shape) + + self._input_gradients = None + + # def output_shape(self): + # return self._output_shape + # return self._output_shape + + def __enter__(self): + self.open() + return self + + def __exit__(self, *exc_info): + self.close() + + def open(self): + # we should delay instantiation of the primitives till they are really required + if self._gradient_method == "param_shift": + # if gradient method -> sampler with gradient functionality + self._sampler = ParamShiftSamplerGradient( + circuit = self._circuit, + sampler = self._sampler_factory + ) + else: + # if no gradient method -> sampler without gradient functionality + self._sampler = self._sampler_factory( + circuits = [self._circuit], + parameters = [self._input_params + self._weight_params] + ) + pass + + def close(self): + self._sampler.__exit__() + + def set_interpret( + self, + interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]], + output_shape: Union[int, Tuple[int, ...]] = None, + ) -> None: + """Change 'interpret' and corresponding 'output_shape'. If self.sampling==True, the + output _shape does not have to be set and is inferred from the interpret function. + Otherwise, the output_shape needs to be given. + + Args: + interpret: A callable that maps the measured integer to another unsigned integer or + tuple of unsigned integers. See constructor for more details. + output_shape: The output shape of the custom interpretation, only used in the case + where an interpret function is provided and ``sampling==False``. See constructor + for more details. + """ + + # save original values + self._original_output_shape = output_shape + self._original_interpret = interpret + + # derive target values to be used in computations + self._output_shape = self._compute_output_shape(interpret, output_shape) + self._interpret = interpret if interpret is not None else lambda x: x + self.output_shape = self._output_shape + + def _compute_output_shape(self, interpret, output_shape) -> Tuple[int, ...]: + """Validate and compute the output shape.""" + + # this definition is required by mypy + output_shape_: Tuple[int, ...] = (-1,) + # todo: move sampling code to the super class + + if interpret is not None: + if output_shape is None: + raise QiskitMachineLearningError( + "No output shape given, but required in case of custom interpret!" + ) + if isinstance(output_shape, Integral): + output_shape = int(output_shape) + output_shape_ = (output_shape,) + else: + output_shape_ = output_shape + else: + if output_shape is not None: + # Warn user that output_shape parameter will be ignored + logger.warning( + "No interpret function given, output_shape will be automatically " + "determined as 2^num_qubits." + ) + + output_shape_ = (2 ** self._circuit.num_qubits,) + + # # final validation + # output_shape_ = self._validate_output_shape(output_shape_) + + return output_shape_ + + def forward( + self, + input_data: Optional[Union[List[float], np.ndarray, float]], + weights: Optional[Union[List[float], np.ndarray, float]], + ) -> np.ndarray: + + result = self._forward(input_data, weights) + return result + + def _preprocess(self, input_data, weights): + if len(input_data.shape) == 1: + input_data = np.expand_dims(input_data, 0) + num_samples = input_data.shape[0] + # quick fix for 0 inputs + if num_samples == 0: + num_samples = 1 + + parameters = [] + for i in range(num_samples): + param_values = [input_data[i,j] for j, input_param in enumerate(self._input_params)] + param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] + parameters.append(param_values) + + return parameters, num_samples + + def _postprocess(self, num_samples, result): + + prob = np.zeros((num_samples, *self._output_shape)) + + for i in range(num_samples): + counts = result[i].quasi_dists[0] + print(counts) + shots = sum(counts.values()) + + # evaluate probabilities + for b, v in counts.items(): + key = (i, int(self._interpret(b))) # type: ignore + prob[key] += v / shots + + return prob + + def _forward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> np.ndarray: + + parameter_values, num_samples = self._preprocess(input_data, weights) + + # result = self._sampler([0] * num_samples, parameter_values) + + results = [] + for sample in range(num_samples): + result = self._sampler(parameter_values) + results.append(result) + + result = self._postprocess(num_samples, results) + + return result + + def backward( + self, + input_data: Optional[Union[List[float], np.ndarray, float]], + weights: Optional[Union[List[float], np.ndarray, float]], + ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + + result = self._backward(input_data, weights) + return result + + def _preprocess_gradient(self, input_data, weights): + + if len(input_data.shape) == 1: + input_data = np.expand_dims(input_data, 0) + + num_samples = input_data.shape[0] + # quick fix for 0 inputs + if num_samples == 0: + num_samples = 1 + + parameters = [] + for i in range(num_samples): + + param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] + param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] + parameters.append(param_values) + + return parameters, num_samples + + def _postprocess_gradient(self, num_samples, results): + + input_grad = np.zeros((num_samples, 1, self._num_inputs)) if self._input_gradients else None + weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) + + if self._input_gradients: + num_grad_vars = self._num_inputs + self._num_weights + else: + num_grad_vars = self._num_weights + + for sample in range(num_samples): + + for i in range(num_grad_vars): + grad = results[sample].quasi_dists[i + self._num_inputs] + for k in grad.keys(): + val = results[sample].quasi_dists[i + self._num_inputs][k] + # get index for input or weights gradients + if self._input_gradients: + grad_index = i if i < self._num_inputs else i - self._num_inputs + else: + grad_index = i + # interpret integer and construct key + key = self._interpret(k) + if isinstance(key, Integral): + key = (sample, int(key), grad_index) + else: + # if key is an array-type, cast to hashable tuple + key = tuple(cast(Iterable[int], key)) + key = (sample, *key, grad_index) + # store value for inputs or weights gradients + if self._input_gradients: + # we compute input gradients first + if i < self._num_inputs: + input_grad[key] += np.real(val) + else: + weights_grad[key] += np.real(val) + else: + weights_grad[key] += np.real(val) + + return input_grad, weights_grad + + def _backward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + + # prepare parameters in the required format + parameter_values, num_samples = self._preprocess_gradient(input_data, weights) + + results = [] + for sample in range(num_samples): + if self._input_gradients: + result = self._sampler.gradient(parameter_values[sample]) + else: + result = self._sampler.gradient(parameter_values[sample], + partial=self._sampler._circuit.parameters[self._num_inputs:]) + + results.append(result) + input_grad, weights_grad = self._postprocess_gradient(num_samples, results) + + return None , weights_grad # `None` for gradients wrt input data, see TorchConnector + + + + + + + + + + diff --git a/qiskit_machine_learning/primitives/qnns/primitives/__init__.py b/qiskit_machine_learning/primitives/qnns/primitives/__init__.py new file mode 100644 index 000000000..bd00dedc7 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/__init__.py @@ -0,0 +1,58 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +===================================== +Primitives (:mod:`qiskit.primitives`) +===================================== + +.. currentmodule:: qiskit.primitives + +.. automodule:: qiskit.primitives.base_estimator +.. automodule:: qiskit.primitives.base_sampler + +.. currentmodule:: qiskit.primitives + +Estimator +========= + +.. autosummary:: + :toctree: ../stubs/ + + BaseEstimator + Estimator + +Sampler +======= + +.. autosummary:: + :toctree: ../stubs/ + + BaseSampler + Sampler + +Results +======= + +.. autosummary:: + :toctree: ../stubs/ + + EstimatorResult + SamplerResult +""" + +from .base_estimator import BaseEstimator +from .base_sampler import BaseSampler +from .estimator import Estimator +from .estimator_result import EstimatorResult +from .sampler import Sampler +from .sampler_result import SamplerResult diff --git a/qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py b/qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py new file mode 100644 index 000000000..199a5b503 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py @@ -0,0 +1,238 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +r""" + +.. estimator-desc: + +===================== +Overview of Estimator +===================== + +Estimator class estimates expectation values of quantum circuits and observables. + +An estimator object is initialized with multiple quantum circuits and observables +and users can specify pairs of quantum circuits and observables +to estimate the expectation values. + +An estimator is initialized with the following elements. + +* quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits + (a list of :class:`~qiskit.circuit.QuantumCircuit`)) + +* observables (:math:`H_j`): a list of :class:`~qiskit.quantum_info.SparsePauliOp`. + +The estimator is called with the following inputs. + +* circuit indexes: a list of indexes of the quantum circuits. + +* observable indexes: a list of indexes of the observables. + +* parameters: a list of parameters of the quantum circuits. + (:class:`~qiskit.circuit.parametertable.ParameterView` or + a list of :class:`~qiskit.circuit.Parameter`). + +* parameter values (:math:`\theta_k`): list of sets of values + to be bound to the parameters of the quantum circuits. + (list of list of float) + +The output is an :class:`~qiskit.primitives.EstimatorResult` which contains a list of +expectation values plus optional metadata like confidence intervals for the estimation. + +.. math:: + + \langle\psi_i(\theta_k)|H_j|\psi_i(\theta_k)\rangle + + +The estimator object is expected to be ``close()`` d after use or +accessed inside "with" context +and the objects are called with parameter values and run options +(e.g., ``shots`` or number of shots). + +Here is an example of how estimator is used. + +.. code-block:: python + + from qiskit.circuit.library import RealAmplitudes + from qiskit.quantum_info import SparsePauliOp + + psi1 = RealAmplitudes(num_qubits=2, reps=2) + psi2 = RealAmplitudes(num_qubits=2, reps=3) + + params1 = psi1.parameters + params2 = psi2.parameters + + H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)]) + H2 = SparsePauliOp.from_list([("IZ", 1)]) + H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)]) + + with Estimator([psi1, psi2], [H1, H2, H3], [params1, params2]) as e: + theta1 = [0, 1, 1, 2, 3, 5] + theta2 = [0, 1, 1, 2, 3, 5, 8, 13] + theta3 = [1, 2, 3, 4, 5, 6] + + # calculate [ ] + result = e([0], [0], [theta1]) + print(result) + + # calculate [ , ] + result2 = e([0, 0], [1, 2], [theta1]*2) + print(result2) + + # calculate [ ] + result3 = e([1], [1], [theta2]) + print(result3) + + # calculate [ , ] + result4 = e([0, 0], [0, 0], [theta1, theta3]) + print(result4) + + # calculate [ , + # , + # ] + result5 = e([0, 1, 0], [0, 1, 2], [theta1, theta2, theta3]) + print(result5) +""" +from __future__ import annotations + +from abc import ABC, abstractmethod +from collections.abc import Iterable, Sequence + +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.circuit.parametertable import ParameterView +from qiskit.exceptions import QiskitError +from qiskit.quantum_info.operators import SparsePauliOp + +from .estimator_result import EstimatorResult + + +class BaseEstimator(ABC): + """Estimator base class. + + Base class for Estimator that estimates expectation values of quantum circuits and observables. + """ + + def __init__( + self, + circuits: Iterable[QuantumCircuit], + observables: Iterable[SparsePauliOp], + parameters: Iterable[Iterable[Parameter]] | None = None, + ): + """ + Creating an instance of an Estimator, or using one in a ``with`` context opens a session that + holds resources until the instance is ``close()`` ed or the context is exited. + + Args: + circuits: Quantum circuits that represent quantum states. + observables: Observables. + parameters: Parameters of quantum circuits, specifying the order in which values + will be bound. Defaults to ``[circ.parameters for circ in circuits]`` + The indexing is such that ``parameters[i, j]`` is the j-th formal parameter of + ``circuits[i]``. + + Raises: + QiskitError: For mismatch of circuits and parameters list. + """ + self._circuits = tuple(circuits) + self._observables = tuple(observables) + if parameters is None: + self._parameters = tuple(circ.parameters for circ in self._circuits) + else: + self._parameters = tuple(ParameterView(par) for par in parameters) + if len(self._parameters) != len(self._circuits): + raise QiskitError( + f"Different number of parameters ({len(self._parameters)} and " + f"circuits ({len(self._circuits)}" + ) + for i, (circ, params) in enumerate(zip(self._circuits, self._parameters)): + if circ.num_parameters != len(params): + raise QiskitError( + f"Different numbers of parameters of {i}-th circuit: " + f"expected {circ.num_parameters}, actual {len(params)}." + ) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + self.close() + + @abstractmethod + def close(self): + """Close the session and free resources""" + ... + + @property + def circuits(self) -> tuple[QuantumCircuit, ...]: + """Quantum circuits that represents quantum states. + + Returns: + The quantum circuits. + """ + return self._circuits + + @property + def observables(self) -> tuple[SparsePauliOp, ...]: + """Observables to be estimated. + + Returns: + The observables. + """ + return self._observables + + @property + def parameters(self) -> tuple[ParameterView, ...]: + """Parameters of the quantum circuits. + + Returns: + Parameters, where ``parameters[i][j]`` is the j-th parameter of the i-th circuit. + """ + return self._parameters + + @abstractmethod + def __call__( + self, + circuit_indices: Sequence[int], + observable_indices: Sequence[int], + parameter_values: Sequence[Sequence[float]], + **run_options, + ) -> EstimatorResult: + """Run the estimation of expectation value(s). + + ``circuit_indices``, ``observable_indices``, and ``parameter_values`` should have the same + length. The i-th element of the result is the expectation of observable + + .. code-block:: python + + obs = self.observables[observable_indices[i]] + + for the state prepared by + + .. code-block:: python + + circ = self.circuits[circuit_indices[i]] + + with bound parameters + + .. code-block:: python + + values = parameter_values[i]. + + Args: + circuit_indices: the list of circuit indices. + observable_indices: the list of observable indices. + parameter_values: concrete parameters to be bound. + run_options: runtime options used for circuit execution. + + Returns: + EstimatorResult: The result of the estimator. + """ + ... diff --git a/qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py b/qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py new file mode 100644 index 000000000..28b5b69d6 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py @@ -0,0 +1,181 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +r""" +=================== +Overview of Sampler +=================== + +Sampler class calculates probabilities or quasi-probabilities of bitstrings from quantum circuits. + +A sampler is initialized with the following elements. + +* quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits. + (a list of :class:`~qiskit.circuit.QuantumCircuit`)) + +* parameters: a list of parameters of the quantum circuits. + (:class:`~qiskit.circuit.parametertable.ParameterView` or + a list of :class:`~qiskit.circuit.Parameter`). + +The sampler is run with the following inputs. + +* circuit indexes: a list of indices of the circuits to evaluate. + +* parameter values (:math:`\theta_k`): list of sets of parameter values + to be bound to the parameters of the quantum circuits. + (list of list of float) + +The output is a :class:`~qiskit.primitives.SamplerResult` which contains probabilities +or quasi-probabilities of bitstrings, +plus optional metadata like error bars in the samples. + +The sampler object is expected to be closed after use or +accessed within "with" context +and the objects are called with parameter values and run options +(e.g., ``shots`` or number of shots). + +Here is an example of how sampler is used. + +.. code-block:: python + + from qiskit import QuantumCircuit + from qiskit.circuit.library import RealAmplitudes + + bell = QuantumCircuit(2) + bell.h(0) + bell.cx(0, 1) + bell.measure_all() + + # executes a Bell circuit + with Sampler(circuits=[bell], parameters=[[]]) as sampler: + result = sampler(parameters=[[]], circuits=[0]) + print([q.binary_probabilities() for q in result.quasi_dists]) + + # executes three Bell circuits + with Sampler([bell]*3, [[]] * 3) as sampler: + result = sampler([0, 1, 2], [[]]*3) + print([q.binary_probabilities() for q in result.quasi_dists]) + + # parameterized circuit + pqc = RealAmplitudes(num_qubits=2, reps=2) + pqc.measure_all() + pqc2 = RealAmplitudes(num_qubits=2, reps=3) + pqc2.measure_all() + + theta1 = [0, 1, 1, 2, 3, 5] + theta2 = [1, 2, 3, 4, 5, 6] + theta3 = [0, 1, 2, 3, 4, 5, 6, 7] + + with Sampler(circuits=[pqc, pqc2], parameters=[pqc.parameters, pqc2.parameters]) as sampler: + result = sampler([0, 0, 1], [theta1, theta2, theta3]) + + # result of pqc(theta1) + print(result.quasi_dists[0].binary_probabilities()) + + # result of pqc(theta2) + print(result.quasi_dists[1].binary_probabilities()) + + # result of pqc2(theta3) + print(result.quasi_dists[2].binary_probabilities()) + +""" +from __future__ import annotations + +from abc import ABC, abstractmethod +from collections.abc import Iterable, Sequence + +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.circuit.parametertable import ParameterView +from qiskit.exceptions import QiskitError + +from .sampler_result import SamplerResult + + +class BaseSampler(ABC): + """Sampler base class + + Base class of Sampler that calculates quasi-probabilities of bitstrings from quantum circuits. + """ + + def __init__( + self, + circuits: Iterable[QuantumCircuit], + parameters: Iterable[Iterable[Parameter]] | None = None, + ): + """ + Args: + circuits: Quantum circuits to be executed. + parameters: Parameters of each of the quantum circuits. + Defaults to ``[circ.parameters for circ in circuits]``. + + Raises: + QiskitError: For mismatch of circuits and parameters list. + """ + self._circuits = tuple(circuits) + if parameters is None: + self._parameters = tuple(circ.parameters for circ in self._circuits) + else: + self._parameters = tuple(ParameterView(par) for par in parameters) + if len(self._parameters) != len(self._circuits): + raise QiskitError( + f"Different number of parameters ({len(self._parameters)} " + f"and circuits ({len(self._circuits)}" + ) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + self.close() + + @abstractmethod + def close(self): + """Close the session and free resources""" + ... + + @property + def circuits(self) -> tuple[QuantumCircuit, ...]: + """Quantum circuits to be sampled. + + Returns: + The quantum circuits to be sampled. + """ + return self._circuits + + @property + def parameters(self) -> tuple[ParameterView, ...]: + """Parameters of quantum circuits. + + Returns: + List of the parameters in each quantum circuit. + """ + return self._parameters + + @abstractmethod + def __call__( + self, + circuit_indices: Sequence[int], + parameter_values: Sequence[Sequence[float]], + **run_options, + ) -> SamplerResult: + """Run the sampling of bitstrings. + + Args: + circuit_indices: Indices of the circuits to evaluate. + parameter_values: Parameters to be bound to the circuit. + run_options: Backend runtime options used for circuit execution. + + Returns: + The result of the sampler. The i-th result corresponds to + ``self.circuits[circuit_indices[i]]`` evaluated with parameters bound as + ``parameter_values[i]``. + """ + ... diff --git a/qiskit_machine_learning/primitives/qnns/primitives/estimator.py b/qiskit_machine_learning/primitives/qnns/primitives/estimator.py new file mode 100644 index 000000000..6e9a08c86 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/estimator.py @@ -0,0 +1,115 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Estimator class +""" + +from __future__ import annotations + +from collections.abc import Iterable, Sequence +from typing import cast + +import numpy as np + +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.exceptions import QiskitError +from qiskit.opflow import PauliSumOp +from qiskit.quantum_info import Statevector +from qiskit.quantum_info.operators.base_operator import BaseOperator + +from .base_estimator import BaseEstimator +from .estimator_result import EstimatorResult +from .utils import init_circuit, init_observable + + +class Estimator(BaseEstimator): + """ + Estimator class + """ + + def __init__( + self, + circuits: QuantumCircuit | Iterable[QuantumCircuit], + observables: BaseOperator | PauliSumOp | Iterable[BaseOperator | PauliSumOp], + parameters: Iterable[Iterable[Parameter]] | None = None, + ): + if isinstance(circuits, QuantumCircuit): + circuits = [circuits] + circuits = [init_circuit(circuit) for circuit in circuits] + + if isinstance(observables, (PauliSumOp, BaseOperator)): + observables = [observables] + observables = [init_observable(observable) for observable in observables] + + super().__init__( + circuits=circuits, + observables=observables, + parameters=parameters, + ) + self._is_closed = False + + def __call__( + self, + circuit_indices: Sequence[int] | None = None, + observable_indices: Sequence[int] | None = None, + parameter_values: Sequence[Sequence[float]] | Sequence[float] | None = None, + **run_options, + ) -> EstimatorResult: + if self._is_closed: + raise QiskitError("The primitive has been closed.") + + if isinstance(parameter_values, np.ndarray): + parameter_values = parameter_values.tolist() + if parameter_values and not isinstance(parameter_values[0], (np.ndarray, Sequence)): + parameter_values = cast("Sequence[float]", parameter_values) + parameter_values = [parameter_values] + if circuit_indices is None: + circuit_indices = list(range(len(self._circuits))) + if observable_indices is None: + observable_indices = list(range(len(self._observables))) + if parameter_values is None: + parameter_values = [[]] * len(circuit_indices) + if len(circuit_indices) != len(observable_indices): + raise QiskitError( + f"The number of circuit indices ({len(circuit_indices)}) does not match " + f"the number of observable indices ({len(observable_indices)})." + ) + if len(circuit_indices) != len(parameter_values): + raise QiskitError( + f"The number of circuit indices ({len(circuit_indices)}) does not match " + f"the number of parameter value sets ({len(parameter_values)})." + ) + + bound_circuits = [] + for i, value in zip(circuit_indices, parameter_values): + if len(value) != len(self._parameters[i]): + raise QiskitError( + f"The number of values ({len(value)}) does not match " + f"the number of parameters ({len(self._parameters[i])})." + ) + bound_circuits.append( + self._circuits[i].bind_parameters(dict(zip(self._parameters[i], value))) + ) + sorted_observables = [self._observables[i] for i in observable_indices] + expectation_values = [] + for circ, obs in zip(bound_circuits, sorted_observables): + if circ.num_qubits != obs.num_qubits: + raise QiskitError( + f"The number of qubits of a circuit ({circ.num_qubits}) does not match " + f"the number of qubits of a observable ({obs.num_qubits})." + ) + expectation_values.append(Statevector(circ).expectation_value(obs)) + + return EstimatorResult(np.real_if_close(expectation_values), [{}] * len(expectation_values)) + + def close(self): + self._is_closed = True diff --git a/qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py b/qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py new file mode 100644 index 000000000..e26d9848c --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py @@ -0,0 +1,44 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Estimator result class +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + import numpy as np + + +@dataclass(frozen=True) +class EstimatorResult: + """Result of Estimator. + + .. code-block:: python + + result = estimator(circuits, observables, params) + + where the i-th elements of ``result`` correspond to the circuit and observable given by + ``circuit_indices[i]``, ``observable_indices[i]``, and the parameter values bounds by ``params[i]``. + For example, ``results.values[i]`` gives the expectation value, and ``result.metadata[i]`` + is a metadata dictionary for this circuit and parameters. + + Args: + values (np.ndarray): The array of the expectation values. + metadata (list[dict]): List of the metadata. + """ + + values: "np.ndarray[Any, np.dtype[np.float64]]" + metadata: list[dict[str, Any]] diff --git a/qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py b/qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py new file mode 100644 index 000000000..d0ac2ee93 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py @@ -0,0 +1,2 @@ +from .estimator_factory import EstimatorFactory +from .statevector_estimator_factory import StatevectorEstimatorFactory diff --git a/qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py b/qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py new file mode 100644 index 000000000..6be57a319 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py @@ -0,0 +1,16 @@ +from abc import ABC, abstractmethod + +from qiskit.primitives import BaseEstimator + +class EstimatorFactory(ABC): + """Class to construct an estimator, given circuits and observables.""" + + def __init__(self, circuits=None, observables=None, parameters=None): + self.circuits = circuits + self.observables = observables + self.parameters = parameters + + @abstractmethod + def __call__(self, circuits=None, observables=None, parameters=None) -> BaseEstimator: + pass + diff --git a/qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py b/qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py new file mode 100644 index 000000000..3c9b95c8a --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py @@ -0,0 +1,13 @@ +from qiskit.primitives import Estimator +from .estimator_factory import EstimatorFactory + +class StatevectorEstimatorFactory(EstimatorFactory): + """Estimator factory evaluated with statevector simulations.""" + + def __call__(self, circuits=None, observables=None, parameters=None) -> Estimator: + circuits = circuits or self.circuits + observables = observables or self.observables + parameters = parameters or self.parameters + + return Estimator(circuits, observables, parameters) + diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py new file mode 100755 index 000000000..687a25aae --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py @@ -0,0 +1,14 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +from .finite_diff_estimator_gradient import FiniteDiffEstimatorGradient +from .finite_diff_sampler_gradient import FiniteDiffSamplerGradient diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py new file mode 100644 index 000000000..f38f4fa0a --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py @@ -0,0 +1,37 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Abstract Base class of Gradient. +""" + +from __future__ import annotations + +from abc import ABC, abstractmethod +from collections.abc import Sequence + +from ..base_estimator import BaseEstimator + + +class BaseEstimatorGradient(ABC): + def __init__(self, estimator: BaseEstimator): + self._estimator = estimator + + @abstractmethod + def gradient( + self, + circuit_indices: Sequence[int], + observable_indices: Sequence[int], + parameter_values: Sequence[Sequence[float]], + **run_options, + ) -> EstimatorResult: + ... diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py new file mode 100644 index 000000000..ab61934b0 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py @@ -0,0 +1,56 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np + +from ..base_estimator import BaseEstimator +from ..estimator_result import EstimatorResult +from .base_estimator_gradient import BaseEstimatorGradient + + +class FiniteDiffEstimatorGradient(BaseEstimatorGradient): + def __init__(self, estimator: BaseEstimator, epsilon: float = 1e-6): + self._epsilon = epsilon + super().__init__(estimator) + + def gradient( + self, + circuit_index: int, + observable_index: int, + parameter_value: Sequence[float], + **run_options, + ) -> EstimatorResult: + run_options = run_options.copy() + + dim = len(parameter_value) + ret = [parameter_value] + for i in range(dim): + ei = parameter_value.copy() + ei[i] += self._epsilon + ret.append(ei) + param_array = np.array(ret).tolist() + circuit_indices = [circuit_index] * (dim + 1) + observable_indices = [observable_index] * (dim + 1) + results = self._estimator.__call__( + circuit_indices, observable_indices, param_array, **run_options + ) + + values = results.values + grad = np.zeros(dim) + f_ref = values[0] + for i, f_i in enumerate(values[1:]): + grad[i] = (f_i - f_ref) / self._epsilon + return EstimatorResult(values=grad, metadata=[{}] * len(grad)) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py new file mode 100644 index 000000000..c40131e40 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py @@ -0,0 +1,55 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +from __future__ import annotations + +from collections.abc import Sequence + +import numpy as np + +from qiskit.result import QuasiDistribution + +from ..base_sampler import BaseSampler +from ..sampler_result import SamplerResult + + +class FiniteDiffSamplerGradient: + def __init__(self, sampler: BaseSampler, epsilon: float = 1e-6): + self._epsilon = epsilon + self._sampler = sampler + + def gradient( + self, + circuit_index: int, + parameter_value: Sequence[float], + **run_options, + ) -> SamplerResult: + run_options = run_options.copy() + + dim = len(parameter_value) + params = [parameter_value] + for i in range(dim): + ei = parameter_value.copy() + ei[i] += self._epsilon + params.append(ei) + param_list = np.array(params).tolist() + circuit_indices = [circuit_index] * (dim + 1) + results = self._sampler.__call__(circuit_indices, param_list, **run_options) + + quasi_dists = results.quasi_dists + ret = [] + f_ref = quasi_dists[0] + for f_i in quasi_dists[1:]: + ret.append( + QuasiDistribution({key: (f_i[key] - f_ref[key]) / self._epsilon for key in f_ref}) + ) + return SamplerResult(quasi_dists=ret, metadata=[{}] * len(ret)) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py new file mode 100644 index 000000000..40d5604f1 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py @@ -0,0 +1,224 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Gradient of expectation values with linear combination of unitaries (LCU) +""" + +from __future__ import annotations + +from collections import defaultdict +from dataclasses import dataclass +from typing import Sequence, Type + +import numpy as np + +from qiskit import transpile +from qiskit.circuit import ( + Gate, + Instruction, + Parameter, + ParameterExpression, + QuantumCircuit, + QuantumRegister, +) +from qiskit.circuit.library.standard_gates import ( + CXGate, + CYGate, + CZGate, + RXGate, + RXXGate, + RYGate, + RYYGate, + RZGate, + RZXGate, + RZZGate, +) +from qiskit.quantum_info import Pauli, SparsePauliOp + +from ..base_estimator import BaseEstimator +from ..estimator_result import EstimatorResult +from .base_estimator_gradient import BaseEstimatorGradient + +Pauli_Z = Pauli("Z") + + +@dataclass +class SubEstimator: + coeff: float | ParameterExpression + circuit: QuantumCircuit + index: int + + +class LinCombEstimatorGradient(BaseEstimatorGradient): + """LCU estimator gradient""" + + SUPPORTED_GATES = [ + "rx", + "ry", + "rz", + "rzx", + "rzz", + "ryy", + "rxx", + "cx", + "cy", + "cz", + "ccx", + "swap", + "iswap", + "h", + "t", + "s", + "sdg", + "x", + "y", + "z", + ] + + def __init__( + self, estimator: Type[BaseEstimator], circuit: QuantumCircuit, observable: SparsePauliOp + ): + self._circuit = circuit + self._observable = observable + self._grad, observable = self._preprocessing() + circuits = [self._circuit] + observables = [self._observable, observable] + for param, lst in self._grad.items(): + for arg in lst: + circuits.append(arg.circuit) + super().__init__(estimator(circuits=circuits, observables=observables)) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + pass + + @classmethod + def _gradient_circuits(cls, circuit: QuantumCircuit): + circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) + qr_superpos = QuantumRegister(1, "superpos") + circuit2.add_register(qr_superpos) + circuit2.h(qr_superpos) + circuit2.data.insert(0, circuit2.data.pop()) + circuit2.sdg(qr_superpos) + circuit2.data.insert(1, circuit2.data.pop()) + ret = defaultdict(list) + for i, (inst, qregs, _) in enumerate(circuit2.data): + if inst.is_parameterized(): + param = inst.params[0] + for p in param.parameters: + gate = cls._gate_gradient(inst) + circuit3 = circuit2.copy() + # insert `gate` to i-th position + circuit3.append(gate, [qr_superpos[0]] + qregs, []) + circuit3.data.insert(i, circuit3.data.pop()) + # + circuit3.h(qr_superpos) + ret[p].append((circuit3, param.gradient(p))) + return ret + + def _preprocessing(self): + grad = self._gradient_circuits(self._circuit) + ret = {} + observable = self._observable.expand(Pauli_Z) + index = 1 + for param in self._circuit.parameters: + lst = [] + for circ, coeff in grad[param]: + lst.append(SubEstimator(coeff=coeff, circuit=circ, index=index)) + index += 1 + ret[param] = lst + return ret, observable + + def __call__( + self, parameter_values: Sequence[Sequence[float]], **run_options + ) -> EstimatorResult: + return self._estimator([0], [0], parameter_values, **run_options) + + def gradient( + self, + parameter_value: Sequence[float], + partial: Sequence[Parameter] | None = None, + **run_options, + ) -> EstimatorResult: + parameters = partial or self._circuit.parameters + + param_map = {} + for j, param in enumerate(self._circuit.parameters): + param_map[param] = parameter_value[j] + + circ_indices = [] + for param in parameters: + circ_indices.extend([f.index for f in self._grad[param]]) + size = len(circ_indices) + results = self._estimator(circ_indices, [1] * size, [parameter_value] * size, **run_options) + + param_set = set(parameters) + values = np.zeros(len(parameter_value)) + metadata = [{} for _ in range(len(parameters))] + i = 0 + for j, (param, lst) in enumerate(self._grad.items()): + if param not in param_set: + continue + for subest in lst: + coeff = subest.coeff + if isinstance(coeff, ParameterExpression): + local_map = {param: param_map[param] for param in coeff.parameters} + bound_coeff = coeff.bind(local_map) + else: + bound_coeff = coeff + values[j] += bound_coeff * results.values[i] + i += 1 + + return EstimatorResult(values=values, metadata=metadata) + + @staticmethod + def _gate_gradient(gate: Gate) -> Instruction: + if isinstance(gate, RXGate): + # theta + return CXGate() + if isinstance(gate, RYGate): + # theta + return CYGate() + if isinstance(gate, RZGate): + # theta + return CZGate() + if isinstance(gate, RXXGate): + # theta + cxx_circ = QuantumCircuit(3) + cxx_circ.cx(0, 1) + cxx_circ.cx(0, 2) + cxx = cxx_circ.to_instruction() + return cxx + if isinstance(gate, RYYGate): + # theta + cyy_circ = QuantumCircuit(3) + cyy_circ.cy(0, 1) + cyy_circ.cy(0, 2) + cyy = cyy_circ.to_instruction() + return cyy + if isinstance(gate, RZZGate): + # theta + czz_circ = QuantumCircuit(3) + czz_circ.cz(0, 1) + czz_circ.cz(0, 2) + czz = czz_circ.to_instruction() + return czz + if isinstance(gate, RZXGate): + # theta + czx_circ = QuantumCircuit(3) + czx_circ.cx(0, 2) + czx_circ.cz(0, 1) + czx = czx_circ.to_instruction() + return czx + raise TypeError(f"Unrecognized parameterized gate, {gate}") diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py new file mode 100644 index 000000000..0c7f3409f --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py @@ -0,0 +1,221 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Gradient of probabilities with linear combination of unitaries (LCU) +""" + +from __future__ import annotations + +from collections import Counter, defaultdict +from dataclasses import dataclass +from typing import Sequence, Type + +from qiskit import transpile +from qiskit.circuit import ( + ClassicalRegister, + Gate, + Instruction, + Parameter, + ParameterExpression, + QuantumCircuit, + QuantumRegister, +) +from qiskit.circuit.library.standard_gates import ( + CXGate, + CYGate, + CZGate, + RXGate, + RXXGate, + RYGate, + RYYGate, + RZGate, + RZXGate, + RZZGate, +) +from qiskit.result import QuasiDistribution + +from ..base_sampler import BaseSampler +from ..sampler_result import SamplerResult + + +@dataclass +class SubEstimator: + coeff: float | ParameterExpression + circuit: QuantumCircuit + index: int + + +class LinCombSamplerGradient: + """LCU sampler gradient""" + + SUPPORTED_GATES = [ + "rx", + "ry", + "rz", + "rzx", + "rzz", + "ryy", + "rxx", + "cx", + "cy", + "cz", + "ccx", + "swap", + "iswap", + "h", + "t", + "s", + "sdg", + "x", + "y", + "z", + ] + + def __init__(self, sampler: Type[BaseSampler], circuit: QuantumCircuit): + self._circuit = circuit + self._grad = self._preprocessing() + circuits = [self._circuit] + for param, lst in self._grad.items(): + for arg in lst: + circuits.append(arg.circuit) + self._sampler = sampler(circuits=circuits) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + pass + + @classmethod + def _gradient_circuits(cls, circuit: QuantumCircuit): + circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) + qr_superpos = QuantumRegister(1, "superpos") + cr_superpos = ClassicalRegister(1, "superpos") + circuit2.add_register(qr_superpos) + circuit2.add_bits(cr_superpos) + circuit2.h(qr_superpos) + circuit2.data.insert(0, circuit2.data.pop()) + circuit2.sdg(qr_superpos) + circuit2.data.insert(1, circuit2.data.pop()) + ret = defaultdict(list) + for i, (inst, qregs, _) in enumerate(circuit2.data): + if inst.is_parameterized(): + param = inst.params[0] + for p in param.parameters: + gate = cls._gate_gradient(inst) + circuit3 = circuit2.copy() + # insert `gate` to i-th position + circuit3.append(gate, [qr_superpos[0]] + qregs, []) + circuit3.data.insert(i, circuit3.data.pop()) + # + circuit3.h(qr_superpos) + circuit3.measure(qr_superpos, cr_superpos) + ret[p].append((circuit3, param.gradient(p))) + return ret + + def _preprocessing(self): + grad = self._gradient_circuits(self._circuit) + ret = {} + index = 1 + for param in self._circuit.parameters: + lst = [] + for circ, coeff in grad[param]: + lst.append(SubEstimator(coeff=coeff, circuit=circ, index=index)) + index += 1 + ret[param] = lst + return ret + + def __call__(self, parameter_values: Sequence[Sequence[float]], **run_options) -> SamplerResult: + return self._sampler([0], parameter_values, **run_options) + + def gradient( + self, + parameter_value: Sequence[float], + partial: Sequence[Parameter] | None = None, + **run_options, + ) -> SamplerResult: + parameters = partial or self._circuit.parameters + + param_map = {} + for j, param in enumerate(self._circuit.parameters): + param_map[param] = parameter_value[j] + + circ_indices = [] + for param in parameters: + circ_indices.extend([f.index for f in self._grad[param]]) + size = len(circ_indices) + results = self._sampler(circ_indices, [parameter_value] * size, **run_options) + + param_set = set(parameters) + dists = [Counter() for _ in range(len(parameter_value))] + metadata = [{} for _ in range(len(parameters))] + num_bitstrings = 2**self._circuit.num_qubits + i = 0 + for j, (param, lst) in enumerate(self._grad.items()): + if param not in param_set: + continue + for subest in lst: + coeff = subest.coeff + if isinstance(coeff, ParameterExpression): + local_map = {param: param_map[param] for param in coeff.parameters} + bound_coeff = float(coeff.bind(local_map)) + else: + bound_coeff = coeff + for k, v in results.quasi_dists[i].items(): + sign, k2 = divmod(k, num_bitstrings) + dists[j][k2] += (-1) ** sign * bound_coeff * v + i += 1 + + return SamplerResult( + quasi_dists=[QuasiDistribution(dist) for dist in dists], metadata=metadata + ) + + @staticmethod + def _gate_gradient(gate: Gate) -> Instruction: + if isinstance(gate, RXGate): + # theta + return CXGate() + if isinstance(gate, RYGate): + # theta + return CYGate() + if isinstance(gate, RZGate): + # theta + return CZGate() + if isinstance(gate, RXXGate): + # theta + cxx_circ = QuantumCircuit(3) + cxx_circ.cx(0, 1) + cxx_circ.cx(0, 2) + cxx = cxx_circ.to_instruction() + return cxx + if isinstance(gate, RYYGate): + # theta + cyy_circ = QuantumCircuit(3) + cyy_circ.cy(0, 1) + cyy_circ.cy(0, 2) + cyy = cyy_circ.to_instruction() + return cyy + if isinstance(gate, RZZGate): + # theta + czz_circ = QuantumCircuit(3) + czz_circ.cz(0, 1) + czz_circ.cz(0, 2) + czz = czz_circ.to_instruction() + return czz + if isinstance(gate, RZXGate): + # theta + czx_circ = QuantumCircuit(3) + czx_circ.cx(0, 2) + czx_circ.cz(0, 1) + czx = czx_circ.to_instruction() + return czx + raise TypeError(f"Unrecognized parameterized gate, {gate}") diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py new file mode 100644 index 000000000..b112e85ff --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py @@ -0,0 +1,139 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Gradient of expectation values with parameter shift +""" + +from __future__ import annotations + +from collections import defaultdict +from dataclasses import dataclass +from typing import Sequence, Type + +import numpy as np + +from qiskit import transpile +from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit +from qiskit.quantum_info import SparsePauliOp + +from ..base_estimator import BaseEstimator +from ..estimator_result import EstimatorResult +from .base_estimator_gradient import BaseEstimatorGradient + + +@dataclass +class SubEstimator: + coeff: float | ParameterExpression + circuit: QuantumCircuit + observable: SparsePauliOp + index: int + + +class ParamShiftEstimatorGradient(BaseEstimatorGradient): + """Parameter shift estimator gradient""" + + SUPPORTED_GATES = ["x", "y", "z", "h", "rx", "ry", "rz", "p", "cx", "cy", "cz"] + + def __init__( + self, estimator: Type[BaseEstimator], circuit: QuantumCircuit, observable: SparsePauliOp + ): + self._circuit = circuit + self._observable = observable + self._grad = self._preprocessing() + circuits = [self._circuit] + observables = [self._observable] + for param, lst in self._grad.items(): + for arg in lst: + circuits.append(arg.circuit) + super().__init__(estimator(circuits=circuits, observables=observables)) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + pass + + @classmethod + def _gradient_circuits(cls, circuit: QuantumCircuit): + circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) + ret = defaultdict(list) + for inst in circuit2.data: + if inst[0].is_parameterized(): + param = inst[0].params[0] + for p in param.parameters: + # TODO: Need to wait for an appropriate way to update parameters of + # a particular instruction. + # See https://github.com/Qiskit/qiskit-terra/issues/7894 + inst[0].params[0] = param + np.pi / 2 + ret[p].append((circuit2.copy(), param.gradient(p) / 2)) + inst[0].params[0] = param - np.pi / 2 + ret[p].append((circuit2.copy(), -param.gradient(p) / 2)) + inst[0].params[0] = param + return ret + + def _preprocessing(self): + grad = self._gradient_circuits(self._circuit) + ret = {} + index = 1 + for param in self._circuit.parameters: + lst = [] + for circ, coeff in grad[param]: + lst.append( + SubEstimator( + coeff=coeff, circuit=circ, observable=self._observable, index=index + ) + ) + index += 1 + ret[param] = lst + return ret + + def __call__( + self, parameter_values: Sequence[Sequence[float]], **run_options + ) -> EstimatorResult: + return self._estimator([0], [0], parameter_values, **run_options) + + def gradient( + self, + parameter_value: Sequence[float], + partial: Sequence[Parameter] | None = None, + **run_options, + ) -> EstimatorResult: + parameters = partial or self._circuit.parameters + + param_map = {} + for j, param in enumerate(self._circuit.parameters): + param_map[param] = parameter_value[j] + + circ_indices = [] + for param in parameters: + circ_indices.extend([f.index for f in self._grad[param]]) + size = len(circ_indices) + results = self._estimator(circ_indices, [0] * size, [parameter_value] * size, **run_options) + + param_set = set(parameters) + values = np.zeros(len(parameter_value)) + metadata = [{} for _ in range(len(parameters))] + i = 0 + for j, (param, lst) in enumerate(self._grad.items()): + if param not in param_set: + continue + for subest in lst: + coeff = subest.coeff + if isinstance(coeff, ParameterExpression): + local_map = {param: param_map[param] for param in coeff.parameters} + bound_coeff = coeff.bind(local_map) + else: + bound_coeff = coeff + values[j] += bound_coeff * results.values[i] + i += 1 + + return EstimatorResult(values=values, metadata=metadata) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py new file mode 100644 index 000000000..8c8b6f938 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py @@ -0,0 +1,134 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Gradient of probabilities with parameter shift +""" + +from __future__ import annotations + +from collections import Counter, defaultdict +from dataclasses import dataclass +from typing import Sequence, Type + +import numpy as np + +from qiskit import transpile +from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit +from qiskit.result import QuasiDistribution + +from ..base_sampler import BaseSampler +from ..sampler_result import SamplerResult + + +@dataclass +class SubSampler: + coeff: float | ParameterExpression + circuit: QuantumCircuit + index: int + + +class ParamShiftSamplerGradient: + """Parameter shift estimator gradient""" + + SUPPORTED_GATES = ["x", "y", "z", "h", "rx", "ry", "rz", "p", "cx", "cy", "cz"] + + def __init__(self, sampler: Type[BaseSampler], circuit: QuantumCircuit): + self._circuit = circuit + self._grad = self._preprocessing() + circuits = [self._circuit] + for param, lst in self._grad.items(): + for arg in lst: + circuits.append(arg.circuit) + self._sampler = sampler(circuits=circuits) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + pass + + @classmethod + def _gradient_circuits(cls, circuit: QuantumCircuit): + circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) + ret = defaultdict(list) + for inst in circuit2.data: + if inst[0].is_parameterized(): + param = inst[0].params[0] + for p in param.parameters: + # TODO: Need to wait for an appropriate way to update parameters of + # a particular instruction. + # See https://github.com/Qiskit/qiskit-terra/issues/7894 + inst[0].params[0] = param + np.pi / 2 + ret[p].append((circuit2.copy(), param.gradient(p) / 2)) + inst[0].params[0] = param - np.pi / 2 + ret[p].append((circuit2.copy(), -param.gradient(p) / 2)) + inst[0].params[0] = param + return ret + + def _preprocessing(self): + grad = self._gradient_circuits(self._circuit) + # print("gradient circuits: ", grad) + ret = {} + index = 1 + for param in self._circuit.parameters: + lst = [] + for circ, coeff in grad[param]: + lst.append(SubSampler(coeff=coeff, circuit=circ, index=index)) + index += 1 + ret[param] = lst + return ret + + def __call__(self, parameter_values: Sequence[Sequence[float]], **run_options) -> SamplerResult: + return self._sampler([0], parameter_values, **run_options) + + def gradient( + self, + parameter_value: Sequence[float], + partial: Sequence[Parameter] | None = None, + **run_options, + ) -> SamplerResult: + + parameters = partial or self._circuit.parameters + + param_map = {} + + for j, param in enumerate(self._circuit.parameters): + param_map[param] = parameter_value[j] + + circ_indices = [] + for param in parameters: + circ_indices.extend([f.index for f in self._grad[param]]) + size = len(circ_indices) + results = self._sampler(circ_indices, [parameter_value] * size, **run_options) + + param_set = set(parameters) + dists = [Counter() for _ in range(len(parameter_value))] + metadata = [{} for _ in range(len(parameters))] + i = 0 + for j, (param, lst) in enumerate(self._grad.items()): + if param not in param_set: + continue + for subest in lst: + coeff = subest.coeff + if isinstance(coeff, ParameterExpression): + local_map = {param: param_map[param] for param in coeff.parameters} + bound_coeff = float(coeff.bind(local_map)) + else: + bound_coeff = coeff + dists[j].update( + Counter({k: bound_coeff * v for k, v in results.quasi_dists[i].items()}) + ) + i += 1 + + return SamplerResult( + quasi_dists=[QuasiDistribution(dist) for dist in dists], metadata=metadata + ) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/sampler.py b/qiskit_machine_learning/primitives/qnns/primitives/sampler.py new file mode 100644 index 000000000..cecb0c948 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/sampler.py @@ -0,0 +1,115 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Sampler class +""" + +from __future__ import annotations + +from collections.abc import Iterable, Sequence +from typing import cast + +import numpy as np + +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.exceptions import QiskitError +from qiskit.quantum_info import Statevector +from qiskit.result import QuasiDistribution + +from .base_sampler import BaseSampler +from .sampler_result import SamplerResult +from .utils import final_measurement_mapping, init_circuit + + +class Sampler(BaseSampler): + """ + Sampler class + """ + + def __init__( + self, + circuits: QuantumCircuit | Iterable[QuantumCircuit], + parameters: Iterable[Iterable[Parameter]] | None = None, + ): + """ + Args: + circuits: circuits to be executed + parameters: Parameters of each of the quantum circuits. + Defaults to ``[circ.parameters for circ in circuits]``. + + Raises: + QiskitError: if some classical bits are not used for measurements. + """ + if isinstance(circuits, QuantumCircuit): + circuits = [circuits] + circuits = [init_circuit(circuit) for circuit in circuits] + q_c_mappings = [final_measurement_mapping(circuit) for circuit in circuits] + self._qargs_list = [] + for circuit, q_c_mapping in zip(circuits, q_c_mappings): + if set(range(circuit.num_clbits)) != set(q_c_mapping.values()): + raise QiskitError( + "some classical bits are not used for measurements." + f" the number of classical bits {circuit.num_clbits}," + f" the used classical bits {set(q_c_mapping.values())}." + ) + c_q_mapping = sorted((c, q) for q, c in q_c_mapping.items()) + self._qargs_list.append([q for _, q in c_q_mapping]) + circuits = [circuit.remove_final_measurements(inplace=False) for circuit in circuits] + super().__init__(circuits, parameters) + self._is_closed = False + + def __call__( + self, + circuit_indices: Sequence[int] | None = None, + parameter_values: Sequence[Sequence[float]] | Sequence[float] | None = None, + **run_options, + ) -> SamplerResult: + if self._is_closed: + raise QiskitError("The primitive has been closed.") + + if isinstance(parameter_values, np.ndarray): + parameter_values = parameter_values.tolist() + if parameter_values and not isinstance(parameter_values[0], (np.ndarray, Sequence)): + parameter_values = cast("Sequence[float]", parameter_values) + parameter_values = [parameter_values] + if circuit_indices is None: + circuit_indices = list(range(len(self._circuits))) + if parameter_values is None: + parameter_values = [[]] * len(circuit_indices) + if len(circuit_indices) != len(parameter_values): + raise QiskitError( + f"The number of circuit indices ({len(circuit_indices)}) does not match " + f"the number of parameter value sets ({len(parameter_values)})." + ) + + bound_circuits_qargs = [] + for i, value in zip(circuit_indices, parameter_values): + if len(value) != len(self._parameters[i]): + raise QiskitError( + f"The number of values ({len(value)}) does not match " + f"the number of parameters ({len(self._parameters[i])})." + ) + bound_circuits_qargs.append( + ( + self._circuits[i].bind_parameters(dict(zip(self._parameters[i], value))), + self._qargs_list[i], + ) + ) + probabilities = [ + Statevector(circ).probabilities(qargs=qargs) for circ, qargs in bound_circuits_qargs + ] + quasis = [QuasiDistribution(dict(enumerate(p))) for p in probabilities] + + return SamplerResult(quasis, [{}] * len(circuit_indices)) + + def close(self): + self._is_closed = True diff --git a/qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py b/qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py new file mode 100644 index 000000000..5b53b1066 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py @@ -0,0 +1,43 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Sampler result class +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Any + +from qiskit.result import QuasiDistribution + + +@dataclass(frozen=True) +class SamplerResult: + """Result of Sampler. + + .. code-block:: python + + result = sampler(circuits, params) + + where the i-th elements of ``result`` correspond to the circuit given by ``circuit_indices[i]``, + and the parameter values bounds by ``params[i]``. + For example, ``results.quasi_dists[i]`` gives the quasi-probabilities of bitstrings, and + ``result.metadata[i]`` is a metadata dictionary for this circuit and parameters. + + Args: + quasi_dists (list[QuasiDistribution]): List of the quasi-probabilities. + metadata (list[dict]): List of the metadata. + """ + + quasi_dists: list[QuasiDistribution] + metadata: list[dict[str, Any]] diff --git a/qiskit_machine_learning/primitives/qnns/primitives/utils.py b/qiskit_machine_learning/primitives/qnns/primitives/utils.py new file mode 100644 index 000000000..e5abc4120 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/primitives/utils.py @@ -0,0 +1,113 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Utility functions for primitives +""" + +from __future__ import annotations + +from qiskit.circuit import ParameterExpression, QuantumCircuit +from qiskit.extensions.quantum_initializer.initializer import Initialize +from qiskit.opflow import PauliSumOp +from qiskit.quantum_info import SparsePauliOp, Statevector +from qiskit.quantum_info.operators.base_operator import BaseOperator +from qiskit.quantum_info.operators.symplectic.base_pauli import BasePauli + + +def init_circuit(state: QuantumCircuit | Statevector) -> QuantumCircuit: + """Initialize state by converting the input to a quantum circuit. + + Args: + state: The state as quantum circuit or statevector. + + Returns: + The state as quantum circuit. + """ + if isinstance(state, QuantumCircuit): + return state + if not isinstance(state, Statevector): + state = Statevector(state) + qc = QuantumCircuit(state.num_qubits) + qc.append(Initialize(state), qargs=range(state.num_qubits)) + return qc + + +def init_observable(observable: BaseOperator | PauliSumOp) -> SparsePauliOp: + """Initialize observable by converting the input to a :class:`~qiskit.quantum_info.SparsePauliOp`. + + Args: + observable: The observable. + + Returns: + The observable as :class:`~qiskit.quantum_info.SparsePauliOp`. + + Raises: + TypeError: If the observable is a :class:`~qiskit.opflow.PauliSumOp` and has a parameterized + coefficient. + """ + if isinstance(observable, SparsePauliOp): + return observable + elif isinstance(observable, PauliSumOp): + if isinstance(observable.coeff, ParameterExpression): + raise TypeError( + f"Observable must have numerical coefficient, not {type(observable.coeff)}." + ) + return observable.coeff * observable.primitive + elif isinstance(observable, BasePauli): + return SparsePauliOp(observable) + elif isinstance(observable, BaseOperator): + return SparsePauliOp.from_operator(observable) + else: + return SparsePauliOp(observable) + + +def final_measurement_mapping(circuit: QuantumCircuit) -> dict[int, int]: + """Return the final measurement mapping for the circuit. + + Dict keys label measured qubits, whereas the values indicate the + classical bit onto which that qubits measurement result is stored. + + Note: this function is a slightly simplified version of a utility function + ``_final_measurement_mapping`` of + `mthree `_. + + Parameters: + circuit: Input quantum circuit. + + Returns: + Mapping of qubits to classical bits for final measurements. + """ + active_qubits = list(range(circuit.num_qubits)) + active_cbits = list(range(circuit.num_clbits)) + + # Find final measurements starting in back + mapping = {} + for item in circuit._data[::-1]: + if item[0].name == "measure": + cbit = circuit.find_bit(item[2][0]).index + qbit = circuit.find_bit(item[1][0]).index + if cbit in active_cbits and qbit in active_qubits: + mapping[qbit] = cbit + active_cbits.remove(cbit) + active_qubits.remove(qbit) + elif item[0].name != "barrier": + for qq in item[1]: + _temp_qubit = circuit.find_bit(qq).index + if _temp_qubit in active_qubits: + active_qubits.remove(_temp_qubit) + + if not active_cbits or not active_qubits: + break + + # Sort so that classical bits are in numeric order low->high. + mapping = dict(sorted(mapping.items(), key=lambda item: item[1])) + return mapping diff --git a/qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py b/qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py new file mode 100644 index 000000000..7ff555ea9 --- /dev/null +++ b/qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py @@ -0,0 +1,75 @@ +# THIS EXAMPLE USES THE TERRA PRIMITIVES! +import numpy as np +from qiskit.primitives import Sampler, Estimator +from qiskit import Aer, QuantumCircuit +from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap +from qiskit.utils import QuantumInstance, algorithm_globals +from qiskit_machine_learning.neural_networks import CircuitQNN +from primitives.gradient.param_shift_sampler_gradient import ParamShiftSamplerGradient +from primitives.gradient.finite_diff_sampler_gradient import FiniteDiffSamplerGradient +algorithm_globals.random_seed = 42 + +# DEFINE CIRCUIT FOR SAMPLER +num_qubits = 3 +qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) +qc.draw(output="mpl") +# ADD MEASUREMENT HERE --> TRICKY +qc.measure_all() + +# --------------------- + +from qiskit import Aer +from qiskit.utils import QuantumInstance + +qi_qasm = QuantumInstance(Aer.get_backend("aer_simulator"), shots=10) +qi_sv = QuantumInstance(Aer.get_backend("statevector_simulator")) + +parity = lambda x: "{:b}".format(x).count("1") % 2 +output_shape = 2 # this is required in case of a callable with dense output + +qnn2 = CircuitQNN( + qc, + input_params=qc.parameters[:3], + weight_params=qc.parameters[3:], + sparse = False, + interpret = parity, + output_shape = output_shape, + quantum_instance=qi_sv, +) +inputs = np.asarray(algorithm_globals.random.random(size = (1, qnn2._num_inputs))) +weights = algorithm_globals.random.random(qnn2._num_weights) +print("inputs: ", inputs) +print("weights: ", weights) + +np.set_printoptions(precision=2) +f = qnn2.forward(inputs, weights) +print( f"fwd pass: {f}") +np.set_printoptions(precision=2) +b = qnn2.backward(inputs, weights) +print( f"bkwd pass: {b}" ) +# --------------------- + +# IMPORT QNN +from neural_networks.sampler_qnn_2 import SamplerQNN + +with SamplerQNN( + circuit=qc, + input_params=qc.parameters[:3], + weight_params=qc.parameters[3:], + sampler_factory=Sampler, + interpret = parity, + output_shape = output_shape, + ) as qnn: + # inputs = np.asarray(algorithm_globals.random.random((2, qnn._num_inputs))) + # weights = algorithm_globals.random.random(qnn._num_weights) + print("inputs: ", inputs) + print("weights: ", weights) + + np.set_printoptions(precision=2) + f = qnn.forward(inputs, weights) + print(f"fwd pass: {f}") + np.set_printoptions(precision=2) + b = qnn.backward(inputs, weights) + print(f"bkwd pass: {b}") + + From eecbdab7443f6996eaaf687c56dd662647ab0e88 Mon Sep 17 00:00:00 2001 From: ElePT Date: Fri, 8 Jul 2022 11:38:20 +0200 Subject: [PATCH 06/96] Establish qnn branch --- .../primitives/kernels/__init__.py | 44 ----- .../primitives/kernels/base_kernel.py | 118 -------------- .../primitives/kernels/pseudo_kernel.py | 131 --------------- .../primitives/kernels/quantum_kernel.py | 153 ------------------ .../kernels/trainable_quantum_kernel.py | 69 -------- 5 files changed, 515 deletions(-) delete mode 100644 qiskit_machine_learning/primitives/kernels/__init__.py delete mode 100644 qiskit_machine_learning/primitives/kernels/base_kernel.py delete mode 100644 qiskit_machine_learning/primitives/kernels/pseudo_kernel.py delete mode 100644 qiskit_machine_learning/primitives/kernels/quantum_kernel.py delete mode 100644 qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py diff --git a/qiskit_machine_learning/primitives/kernels/__init__.py b/qiskit_machine_learning/primitives/kernels/__init__.py deleted file mode 100644 index c28b088d5..000000000 --- a/qiskit_machine_learning/primitives/kernels/__init__.py +++ /dev/null @@ -1,44 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -""" -Primitives Quantum Kernels (:mod:`qiskit_machine_learning.primitives.kernels`) - -.. currentmodule:: qiskit_machine_learning.primitives.kernels - -Quantum Kernels -=============== - -.. autosummary:: - :toctree: ../stubs/ - :nosignatures: - - BaseKernel - QuantumKernel - TrainableKernel - PseudoKernel - -Submodules -========== - -.. autosummary:: - :toctree: - - algorithms -""" - -from .base_kernel import BaseKernel -from .quantum_kernel import QuantumKernel -from .trainable_quantum_kernel import TrainableQuantumKernel -from .pseudo_kernel import PseudoKernel - -__all__ = ["BaseKernel", "QuantumKernel", "TrainableQuantumKernel", "PseudoKernel"] diff --git a/qiskit_machine_learning/primitives/kernels/base_kernel.py b/qiskit_machine_learning/primitives/kernels/base_kernel.py deleted file mode 100644 index 5826696ab..000000000 --- a/qiskit_machine_learning/primitives/kernels/base_kernel.py +++ /dev/null @@ -1,118 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -from abc import abstractmethod -from typing import Tuple, Callable, List - -import numpy as np - -from qiskit import QuantumCircuit -from qiskit.primitives import Sampler - -SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] - - -class BaseKernel: - """ - Abstract class providing the interface for the quantum kernel classes. - """ - - def __init__(self, sampler_factory: SamplerFactory, *, enforce_psd: bool = True) -> None: - """ - Args: - sampler_factory: A callable that creates a qiskit primitives sampler given a list of circuits. - enforce_psd: Project to closest positive semidefinite matrix if x = y. - Only enforced when not using the state vector simulator. Default True. - """ - self._num_features: int = 0 - self._enforce_psd = enforce_psd - self._sampler_factory = sampler_factory - - @abstractmethod - def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray: - r""" - Construct kernel matrix for given data - - If y_vec is None, self inner product is calculated. - - Args: - x_vec: 1D or 2D array of datapoints, NxD, where N is the number of datapoints, - D is the feature dimension - y_vec: 1D or 2D array of datapoints, MxD, where M is the number of datapoints, - D is the feature dimension - - Returns: - 2D matrix, NxM - - Raises: - QiskitMachineLearningError: - - A quantum instance or backend has not been provided - ValueError: - - x_vec and/or y_vec are not one or two dimensional arrays - - x_vec and y_vec have have incompatible dimensions - - x_vec and/or y_vec have incompatible dimension with feature map and - and feature map can not be modified to match. - """ - raise NotImplementedError() - - def _check_and_reshape(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> Tuple[np.ndarray]: - r""" - Performs checks on the dimensions of the input data x_vec and y_vec. - Reshapes the arrays so that `x_vec.shape = (N,D)` and `y_vec.shape = (M,D)`. - """ - if not isinstance(x_vec, np.ndarray): - x_vec = np.asarray(x_vec) - - if y_vec is not None and not isinstance(y_vec, np.ndarray): - y_vec = np.asarray(y_vec) - - if x_vec.ndim > 2: - raise ValueError("x_vec must be a 1D or 2D array") - - if x_vec.ndim == 1: - x_vec = x_vec.reshape(1, -1) - - if y_vec is not None and y_vec.ndim > 2: - raise ValueError("y_vec must be a 1D or 2D array") - - if y_vec is not None and y_vec.ndim == 1: - y_vec = y_vec.reshape(1, -1) - - if y_vec is not None and y_vec.shape[1] != x_vec.shape[1]: - raise ValueError( - "x_vec and y_vec have incompatible dimensions.\n" - f"x_vec has {x_vec.shape[1]} dimensions, but y_vec has {y_vec.shape[1]}." - ) - - if x_vec.shape[1] != self._num_features: - raise ValueError( - "x_vec and class feature map have incompatible dimensions.\n" - f"x_vec has {x_vec.shape[1]} dimensions, " - f"but feature map has {self._num_features}." - ) - - if y_vec is None: - y_vec = x_vec - - return x_vec, y_vec - - def _make_psd(self, kernel_matrix: np.ndarray) -> np.ndarray: - r""" - Find the closest positive semi-definite approximation to symmetric kernel matrix. - The (symmetric) matrix should always be positive semi-definite by construction, - but this can be violated in case of noise, such as sampling noise, thus the - adjustment is only done if NOT using the statevector simulation. - - Args: - kernel_matrix: symmetric 2D array of the kernel entries - """ - d, u = np.linalg.eig(kernel_matrix) - return u @ np.diag(np.maximum(0, d)) @ u.transpose() diff --git a/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py b/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py deleted file mode 100644 index 63b6e4b3d..000000000 --- a/qiskit_machine_learning/primitives/kernels/pseudo_kernel.py +++ /dev/null @@ -1,131 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -"""Pseudo Overlap Kernel""" - -from typing import Optional, Callable, Union, List -import numpy as np - -from qiskit import QuantumCircuit -from qiskit.primitives import Sampler -from qiskit.primitives.fidelity import BaseFidelity - -from qiskit_machine_learning.primitives.kernels import QuantumKernel -from qiskit_machine_learning.utils import make_2d - -SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] - - -class PseudoKernel(QuantumKernel): - """ - Pseudo kernel - """ - - def __init__( - self, - sampler_factory: SamplerFactory, - feature_map: Optional[QuantumCircuit] = None, - *, - num_training_parameters: int = 0, - fidelity: Union[str, BaseFidelity] = "zero_prob", - enforce_psd: bool = True, - ) -> None: - super().__init__(sampler_factory, feature_map, fidelity=fidelity, enforce_psd=enforce_psd) - self.num_parameters = num_training_parameters - - def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray: - # allow users to only provide features, parameters are set to 0 - if x_vec.shape[1] + self.num_parameters == self._num_features: - return self.evaluate_batch(x_vec, y_vec) - else: - return super().evaluate(x_vec, y_vec) - - def evaluate_batch( - self, - x_vec: np.ndarray, - y_vec: np.ndarray, - x_parameters: np.ndarray = None, - y_parameters: np.ndarray = None, - ) -> np.ndarray: - r""" - Construct kernel matrix for given data and feature map - - If y_vec is None, self inner product is calculated. - If using `statevector_simulator`, only build circuits for :math:`\Psi(x)|0\rangle`, - then perform inner product classically. - - Args: - x_vec: 1D or 2D array of datapoints, NxD, where N is the number of datapoints, - D is the feature dimension - y_vec: 1D or 2D array of datapoints, MxD, where M is the number of datapoints, - D is the feature dimension - x_parameters: 1D or 2D array of parameters, NxP, where N is the number of datapoints, - P is the number of trainable parameters - y_parameters: 1D or 2D array of parameters, MxP - - - Returns: - 2D matrix, NxM - - Raises: - QiskitMachineLearningError: - - A quantum instance or backend has not been provided - ValueError: - - x_vec and/or y_vec are not one or two dimensional arrays - - x_vec and y_vec have have incompatible dimensions - - x_vec and/or y_vec have incompatible dimension with feature map and - and feature map can not be modified to match. - """ - if x_parameters is None: - x_parameters = np.zeros((x_vec.shape[0], self.num_parameters)) - - if y_parameters is None: - y_parameters = np.zeros((y_vec.shape[0], self.num_parameters)) - - if len(x_vec.shape) == 1: - x_vec = x_vec.reshape(1, -1) - - if len(y_vec.shape) == 1: - y_vec = y_vec.reshape(1, -1) - - if len(x_parameters.shape) == 1: - x_parameters = make_2d(x_parameters, x_vec.shape[0]) - - if len(y_parameters.shape) == 1: - y_parameters = make_2d(y_parameters, y_vec.shape[0]) - - if x_vec.shape[0] != x_parameters.shape[0]: - if x_parameters.shape[0] == 1: - x_parameters = make_2d(x_parameters, x_vec.shape[0]) - else: - raise ValueError( - f"Number of x data points ({x_vec.shape[0]}) does not coincide with number of parameter vectors {x_parameters.shape[0]}." - ) - if y_vec.shape[0] != y_parameters.shape[0]: - if y_parameters.shape[0] == 1: - x_parameters = make_2d(y_parameters, y_vec.shape[0]) - else: - raise ValueError( - f"Number of y data points ({y_vec.shape[0]}) does not coincide with number of parameter vectors {y_parameters.shape[0]}." - ) - - if x_parameters.shape[1] != self.num_parameters: - raise ValueError( - f"Number of parameters provided ({x_parameters.shape[0]}) does not coincide with the number provided in the feature map ({self.num_parameters})." - ) - - if y_parameters.shape[1] != self.num_parameters: - raise ValueError( - f"Number of parameters provided ({y_parameters.shape[0]}) does not coincide with the number provided in the feature map ({self.num_parameters})." - ) - - return self.evaluate(np.hstack((x_vec, x_parameters)), np.hstack((y_vec, y_parameters))) diff --git a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py b/qiskit_machine_learning/primitives/kernels/quantum_kernel.py deleted file mode 100644 index 16d10e3b0..000000000 --- a/qiskit_machine_learning/primitives/kernels/quantum_kernel.py +++ /dev/null @@ -1,153 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -"""Overlap Quantum Kernel""" - -from typing import Optional, Tuple, Callable, List, Union -import numpy as np - -from qiskit import QuantumCircuit -from qiskit.circuit.library import ZZFeatureMap -from qiskit.primitives import Sampler -from qiskit.primitives.fidelity import BaseFidelity, Fidelity - -from qiskit_machine_learning.primitives.kernels import BaseKernel - - -SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] - - -class QuantumKernel(BaseKernel): - """ - Overlap Kernel - """ - - def __init__( - self, - sampler_factory: SamplerFactory, - feature_map: Optional[QuantumCircuit] = None, - *, - fidelity: Union[str, BaseFidelity] = "zero_prob", - enforce_psd: bool = True, - ) -> None: - super().__init__(sampler_factory, enforce_psd=enforce_psd) - - if feature_map is None: - feature_map = ZZFeatureMap(2).decompose() - - self._num_features = feature_map.num_parameters - - if isinstance(fidelity, str) and fidelity == "zero_prob": - self._fidelity = Fidelity() - else: - self._fidelity = fidelity - self._fidelity.set_circuits(feature_map, feature_map) - - def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray: - x_vec, y_vec = self._check_and_reshape(x_vec, y_vec) - is_symmetric = np.all(x_vec == y_vec) - shape = len(x_vec), len(y_vec) - - if is_symmetric: - left_parameters, right_parameters = self._get_symmetric_parametrization(x_vec) - kernel_matrix = self._get_symmetric_kernel_matrix( - left_parameters, right_parameters, shape - ) - - else: - left_parameters, right_parameters = self._get_parametrization(x_vec, y_vec) - kernel_matrix = self._get_kernel_matrix(left_parameters, right_parameters, shape) - - if is_symmetric and self._enforce_psd: - kernel_matrix = self._make_psd(kernel_matrix) - return kernel_matrix - - def _get_parametrization(self, x_vec: np.ndarray, y_vec: np.ndarray) -> Tuple[np.ndarray]: - """ - Combines x_vec and y_vec to get all the combinations needed to evaluate the kernel entries. - """ - x_count = x_vec.shape[0] - y_count = y_vec.shape[0] - - left_parameters = np.zeros((x_count * y_count, x_vec.shape[1])) - right_parameters = np.zeros((x_count * y_count, y_vec.shape[1])) - index = 0 - for x_i in x_vec: - for y_j in y_vec: - left_parameters[index, :] = x_i - right_parameters[index, :] = y_j - index += 1 - - return left_parameters, right_parameters - - def _get_symmetric_parametrization(self, x_vec: np.ndarray) -> Tuple[np.ndarray]: - """ - Combines two copies of x_vec to get all the combinations needed to evaluate the kernel entries. - """ - x_count = x_vec.shape[0] - - left_parameters = np.zeros((x_count * (x_count + 1) // 2, x_vec.shape[1])) - right_parameters = np.zeros((x_count * (x_count + 1) // 2, x_vec.shape[1])) - - index = 0 - for i, x_i in enumerate(x_vec): - for x_j in x_vec[i:]: - left_parameters[index, :] = x_i - right_parameters[index, :] = x_j - index += 1 - - return left_parameters, right_parameters - - def _get_kernel_matrix( - self, left_parameters: np.ndarray, right_parameters: np.ndarray, shape: Tuple - ) -> np.ndarray: - """ - Given a parametrization, this computes the symmetric kernel matrix. - """ - kernel_entries = self._fidelity.compute(left_parameters, right_parameters) - kernel_matrix = np.zeros(shape) - - index = 0 - for i in range(shape[0]): - for j in range(shape[1]): - kernel_matrix[i, j] = kernel_entries[index] - index += 1 - return kernel_matrix - - def _get_symmetric_kernel_matrix( - self, left_parameters: np.ndarray, right_parameters: np.ndarray, shape: Tuple - ) -> np.ndarray: - """ - Given a set of parametrization, this computes the kernel matrix. - """ - kernel_entries = self._fidelity.compute(left_parameters, right_parameters) - kernel_matrix = np.zeros(shape) - index = 0 - for i in range(shape[0]): - for j in range(i, shape[1]): - kernel_matrix[i, j] = kernel_entries[index] - index += 1 - - kernel_matrix = kernel_matrix + kernel_matrix.T - np.diag(kernel_matrix.diagonal()) - return kernel_matrix - - def __enter__(self): - """ - Creates the full fidelity class by creating the sampler from the factory. - """ - self._fidelity.sampler_from_factory(self._sampler_factory) - return self - - def __exit__(self, *args): - """ - Closes the sampler session. - """ - self._fidelity.sampler.close() diff --git a/qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py b/qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py deleted file mode 100644 index 3041ec182..000000000 --- a/qiskit_machine_learning/primitives/kernels/trainable_quantum_kernel.py +++ /dev/null @@ -1,69 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -"""Trainable Quantum Kernel""" - -from typing import Tuple, Optional, Callable, List, Union -import numpy as np - -from qiskit import QuantumCircuit -from qiskit.primitives import Sampler -from qiskit.primitives.fidelity import BaseFidelity - - -from qiskit_machine_learning.primitives.kernels import QuantumKernel -from qiskit_machine_learning.utils import make_2d - -SamplerFactory = Callable[[List[QuantumCircuit]], Sampler] - - -class TrainableQuantumKernel(QuantumKernel): - """ - Trainable overlap kernel. - """ - - def __init__( - self, - sampler_factory: SamplerFactory, - feature_map: Optional[QuantumCircuit] = None, - *, - fidelity: Union[str, BaseFidelity] = "zero_prob", - num_training_parameters: int = 0, - enforce_psd: bool = True, - ) -> None: - super().__init__(sampler_factory, feature_map, fidelity=fidelity, enforce_psd=enforce_psd) - self.num_parameters = num_training_parameters - self._num_features = self._num_features - self.num_parameters - - self.parameter_values = np.zeros(self.num_parameters) - - def bind_parameters_values(self, parameter_values: np.ndarray) -> None: - """ - Fix the training parameters to numerical values. - """ - if parameter_values.shape == self.parameter_values.shape: - self.parameter_values = parameter_values - else: - raise ValueError( - f"The given parameters are in the wrong shape {parameter_values.shape}, expected {self.parameter_values.shape}." - ) - - def _get_parametrization(self, x_vec: np.ndarray, y_vec: np.ndarray) -> Tuple[np.ndarray]: - new_x_vec = np.hstack((x_vec, make_2d(self.parameter_values, len(x_vec)))) - new_y_vec = np.hstack((y_vec, make_2d(self.parameter_values, len(y_vec)))) - - return super()._get_parametrization(new_x_vec, new_y_vec) - - def _get_symmetric_parametrization(self, x_vec: np.ndarray) -> np.ndarray: - new_x_vec = np.hstack((x_vec, make_2d(self.parameter_values, len(x_vec)))) - - return super()._get_symmetric_parametrization(new_x_vec) From a212196d814d1b193dc621647965819534479209 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 11 Jul 2022 13:04:22 +0200 Subject: [PATCH 07/96] Add fwd unit test --- test/primitives/test_sampler_qnn.py | 76 +++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 test/primitives/test_sampler_qnn.py diff --git a/test/primitives/test_sampler_qnn.py b/test/primitives/test_sampler_qnn.py new file mode 100644 index 000000000..7a671a098 --- /dev/null +++ b/test/primitives/test_sampler_qnn.py @@ -0,0 +1,76 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Test Sampler QNN with Terra primitives.""" +import numpy as np +from test import QiskitMachineLearningTestCase + +from qiskit.primitives import Sampler +from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap +from qiskit.utils import QuantumInstance, algorithm_globals +from qiskit import Aer +from qiskit.utils import QuantumInstance + +from qiskit_machine_learning.neural_networks import CircuitQNN +from qiskit_machine_learning.primitives.sampler_qnn import SamplerQNN + +algorithm_globals.random_seed = 42 + + +class TestSamplerQNN(QiskitMachineLearningTestCase): + """Sampler QNN Tests.""" + + def setUp(self): + super().setUp() + algorithm_globals.random_seed = 12345 + + # define test circuit + num_qubits = 3 + self.qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) + self.qi_qasm = QuantumInstance(Aer.get_backend("aer_simulator"), shots=10) + + def test_forward_pass(self): + + parity = lambda x: "{:b}".format(x).count("1") % 2 + output_shape = 2 # this is required in case of a callable with dense output + + circuit_qnn = CircuitQNN( + self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sparse=False, + interpret=parity, + output_shape=output_shape, + quantum_instance=self.qi_qasm, + ) + + inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + weights = algorithm_globals.random.random(circuit_qnn._num_weights) + circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) + + sampler_factory = Sampler + with SamplerQNN( + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sampler_factory=sampler_factory, + interpret = parity, + output_shape = output_shape, + ) as qnn: + + sampler_qnn_fwd = qnn.forward(inputs, weights) + + np.testing.assert_array_almost_equal(np.asarray(sampler_qnn_fwd), + np.asarray(circuit_qnn_fwd),0.1) + + + From 81f8082a5444f0eab95207970790bebc5de14e58 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 11 Jul 2022 13:04:41 +0200 Subject: [PATCH 08/96] Refactor sampler qnn --- .../primitives/qnns/primitives/__init__.py | 58 ----- .../qnns/primitives/base_estimator.py | 238 ------------------ .../qnns/primitives/base_sampler.py | 181 ------------- .../primitives/qnns/primitives/estimator.py | 115 --------- .../qnns/primitives/estimator_result.py | 44 ---- .../qnns/primitives/factories/__init__.py | 2 - .../primitives/factories/estimator_factory.py | 16 -- .../statevector_estimator_factory.py | 13 - .../qnns/primitives/gradient/__init__.py | 14 -- .../gradient/base_estimator_gradient.py | 37 --- .../finite_diff_estimator_gradient.py | 56 ----- .../gradient/finite_diff_sampler_gradient.py | 55 ---- .../gradient/lin_comb_estimator_gradient.py | 224 ----------------- .../gradient/lin_comb_sampler_gradient.py | 221 ---------------- .../param_shift_estimator_gradient.py | 139 ---------- .../gradient/param_shift_sampler_gradient.py | 134 ---------- .../primitives/qnns/primitives/sampler.py | 115 --------- .../qnns/primitives/sampler_result.py | 43 ---- .../primitives/qnns/primitives/utils.py | 113 --------- .../primitives/qnns/sampler-qnn-example.py | 75 ------ .../{qnns/neural_networks => }/sampler_qnn.py | 87 ++++--- 21 files changed, 51 insertions(+), 1929 deletions(-) delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/__init__.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/estimator.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py delete mode 100755 qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/sampler.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py delete mode 100644 qiskit_machine_learning/primitives/qnns/primitives/utils.py delete mode 100644 qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py rename qiskit_machine_learning/primitives/{qnns/neural_networks => }/sampler_qnn.py (83%) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/__init__.py b/qiskit_machine_learning/primitives/qnns/primitives/__init__.py deleted file mode 100644 index bd00dedc7..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/__init__.py +++ /dev/null @@ -1,58 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -""" -===================================== -Primitives (:mod:`qiskit.primitives`) -===================================== - -.. currentmodule:: qiskit.primitives - -.. automodule:: qiskit.primitives.base_estimator -.. automodule:: qiskit.primitives.base_sampler - -.. currentmodule:: qiskit.primitives - -Estimator -========= - -.. autosummary:: - :toctree: ../stubs/ - - BaseEstimator - Estimator - -Sampler -======= - -.. autosummary:: - :toctree: ../stubs/ - - BaseSampler - Sampler - -Results -======= - -.. autosummary:: - :toctree: ../stubs/ - - EstimatorResult - SamplerResult -""" - -from .base_estimator import BaseEstimator -from .base_sampler import BaseSampler -from .estimator import Estimator -from .estimator_result import EstimatorResult -from .sampler import Sampler -from .sampler_result import SamplerResult diff --git a/qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py b/qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py deleted file mode 100644 index 199a5b503..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/base_estimator.py +++ /dev/null @@ -1,238 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -r""" - -.. estimator-desc: - -===================== -Overview of Estimator -===================== - -Estimator class estimates expectation values of quantum circuits and observables. - -An estimator object is initialized with multiple quantum circuits and observables -and users can specify pairs of quantum circuits and observables -to estimate the expectation values. - -An estimator is initialized with the following elements. - -* quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits - (a list of :class:`~qiskit.circuit.QuantumCircuit`)) - -* observables (:math:`H_j`): a list of :class:`~qiskit.quantum_info.SparsePauliOp`. - -The estimator is called with the following inputs. - -* circuit indexes: a list of indexes of the quantum circuits. - -* observable indexes: a list of indexes of the observables. - -* parameters: a list of parameters of the quantum circuits. - (:class:`~qiskit.circuit.parametertable.ParameterView` or - a list of :class:`~qiskit.circuit.Parameter`). - -* parameter values (:math:`\theta_k`): list of sets of values - to be bound to the parameters of the quantum circuits. - (list of list of float) - -The output is an :class:`~qiskit.primitives.EstimatorResult` which contains a list of -expectation values plus optional metadata like confidence intervals for the estimation. - -.. math:: - - \langle\psi_i(\theta_k)|H_j|\psi_i(\theta_k)\rangle - - -The estimator object is expected to be ``close()`` d after use or -accessed inside "with" context -and the objects are called with parameter values and run options -(e.g., ``shots`` or number of shots). - -Here is an example of how estimator is used. - -.. code-block:: python - - from qiskit.circuit.library import RealAmplitudes - from qiskit.quantum_info import SparsePauliOp - - psi1 = RealAmplitudes(num_qubits=2, reps=2) - psi2 = RealAmplitudes(num_qubits=2, reps=3) - - params1 = psi1.parameters - params2 = psi2.parameters - - H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)]) - H2 = SparsePauliOp.from_list([("IZ", 1)]) - H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)]) - - with Estimator([psi1, psi2], [H1, H2, H3], [params1, params2]) as e: - theta1 = [0, 1, 1, 2, 3, 5] - theta2 = [0, 1, 1, 2, 3, 5, 8, 13] - theta3 = [1, 2, 3, 4, 5, 6] - - # calculate [ ] - result = e([0], [0], [theta1]) - print(result) - - # calculate [ , ] - result2 = e([0, 0], [1, 2], [theta1]*2) - print(result2) - - # calculate [ ] - result3 = e([1], [1], [theta2]) - print(result3) - - # calculate [ , ] - result4 = e([0, 0], [0, 0], [theta1, theta3]) - print(result4) - - # calculate [ , - # , - # ] - result5 = e([0, 1, 0], [0, 1, 2], [theta1, theta2, theta3]) - print(result5) -""" -from __future__ import annotations - -from abc import ABC, abstractmethod -from collections.abc import Iterable, Sequence - -from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.circuit.parametertable import ParameterView -from qiskit.exceptions import QiskitError -from qiskit.quantum_info.operators import SparsePauliOp - -from .estimator_result import EstimatorResult - - -class BaseEstimator(ABC): - """Estimator base class. - - Base class for Estimator that estimates expectation values of quantum circuits and observables. - """ - - def __init__( - self, - circuits: Iterable[QuantumCircuit], - observables: Iterable[SparsePauliOp], - parameters: Iterable[Iterable[Parameter]] | None = None, - ): - """ - Creating an instance of an Estimator, or using one in a ``with`` context opens a session that - holds resources until the instance is ``close()`` ed or the context is exited. - - Args: - circuits: Quantum circuits that represent quantum states. - observables: Observables. - parameters: Parameters of quantum circuits, specifying the order in which values - will be bound. Defaults to ``[circ.parameters for circ in circuits]`` - The indexing is such that ``parameters[i, j]`` is the j-th formal parameter of - ``circuits[i]``. - - Raises: - QiskitError: For mismatch of circuits and parameters list. - """ - self._circuits = tuple(circuits) - self._observables = tuple(observables) - if parameters is None: - self._parameters = tuple(circ.parameters for circ in self._circuits) - else: - self._parameters = tuple(ParameterView(par) for par in parameters) - if len(self._parameters) != len(self._circuits): - raise QiskitError( - f"Different number of parameters ({len(self._parameters)} and " - f"circuits ({len(self._circuits)}" - ) - for i, (circ, params) in enumerate(zip(self._circuits, self._parameters)): - if circ.num_parameters != len(params): - raise QiskitError( - f"Different numbers of parameters of {i}-th circuit: " - f"expected {circ.num_parameters}, actual {len(params)}." - ) - - def __enter__(self): - return self - - def __exit__(self, *exc_info): - self.close() - - @abstractmethod - def close(self): - """Close the session and free resources""" - ... - - @property - def circuits(self) -> tuple[QuantumCircuit, ...]: - """Quantum circuits that represents quantum states. - - Returns: - The quantum circuits. - """ - return self._circuits - - @property - def observables(self) -> tuple[SparsePauliOp, ...]: - """Observables to be estimated. - - Returns: - The observables. - """ - return self._observables - - @property - def parameters(self) -> tuple[ParameterView, ...]: - """Parameters of the quantum circuits. - - Returns: - Parameters, where ``parameters[i][j]`` is the j-th parameter of the i-th circuit. - """ - return self._parameters - - @abstractmethod - def __call__( - self, - circuit_indices: Sequence[int], - observable_indices: Sequence[int], - parameter_values: Sequence[Sequence[float]], - **run_options, - ) -> EstimatorResult: - """Run the estimation of expectation value(s). - - ``circuit_indices``, ``observable_indices``, and ``parameter_values`` should have the same - length. The i-th element of the result is the expectation of observable - - .. code-block:: python - - obs = self.observables[observable_indices[i]] - - for the state prepared by - - .. code-block:: python - - circ = self.circuits[circuit_indices[i]] - - with bound parameters - - .. code-block:: python - - values = parameter_values[i]. - - Args: - circuit_indices: the list of circuit indices. - observable_indices: the list of observable indices. - parameter_values: concrete parameters to be bound. - run_options: runtime options used for circuit execution. - - Returns: - EstimatorResult: The result of the estimator. - """ - ... diff --git a/qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py b/qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py deleted file mode 100644 index 28b5b69d6..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/base_sampler.py +++ /dev/null @@ -1,181 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -r""" -=================== -Overview of Sampler -=================== - -Sampler class calculates probabilities or quasi-probabilities of bitstrings from quantum circuits. - -A sampler is initialized with the following elements. - -* quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits. - (a list of :class:`~qiskit.circuit.QuantumCircuit`)) - -* parameters: a list of parameters of the quantum circuits. - (:class:`~qiskit.circuit.parametertable.ParameterView` or - a list of :class:`~qiskit.circuit.Parameter`). - -The sampler is run with the following inputs. - -* circuit indexes: a list of indices of the circuits to evaluate. - -* parameter values (:math:`\theta_k`): list of sets of parameter values - to be bound to the parameters of the quantum circuits. - (list of list of float) - -The output is a :class:`~qiskit.primitives.SamplerResult` which contains probabilities -or quasi-probabilities of bitstrings, -plus optional metadata like error bars in the samples. - -The sampler object is expected to be closed after use or -accessed within "with" context -and the objects are called with parameter values and run options -(e.g., ``shots`` or number of shots). - -Here is an example of how sampler is used. - -.. code-block:: python - - from qiskit import QuantumCircuit - from qiskit.circuit.library import RealAmplitudes - - bell = QuantumCircuit(2) - bell.h(0) - bell.cx(0, 1) - bell.measure_all() - - # executes a Bell circuit - with Sampler(circuits=[bell], parameters=[[]]) as sampler: - result = sampler(parameters=[[]], circuits=[0]) - print([q.binary_probabilities() for q in result.quasi_dists]) - - # executes three Bell circuits - with Sampler([bell]*3, [[]] * 3) as sampler: - result = sampler([0, 1, 2], [[]]*3) - print([q.binary_probabilities() for q in result.quasi_dists]) - - # parameterized circuit - pqc = RealAmplitudes(num_qubits=2, reps=2) - pqc.measure_all() - pqc2 = RealAmplitudes(num_qubits=2, reps=3) - pqc2.measure_all() - - theta1 = [0, 1, 1, 2, 3, 5] - theta2 = [1, 2, 3, 4, 5, 6] - theta3 = [0, 1, 2, 3, 4, 5, 6, 7] - - with Sampler(circuits=[pqc, pqc2], parameters=[pqc.parameters, pqc2.parameters]) as sampler: - result = sampler([0, 0, 1], [theta1, theta2, theta3]) - - # result of pqc(theta1) - print(result.quasi_dists[0].binary_probabilities()) - - # result of pqc(theta2) - print(result.quasi_dists[1].binary_probabilities()) - - # result of pqc2(theta3) - print(result.quasi_dists[2].binary_probabilities()) - -""" -from __future__ import annotations - -from abc import ABC, abstractmethod -from collections.abc import Iterable, Sequence - -from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.circuit.parametertable import ParameterView -from qiskit.exceptions import QiskitError - -from .sampler_result import SamplerResult - - -class BaseSampler(ABC): - """Sampler base class - - Base class of Sampler that calculates quasi-probabilities of bitstrings from quantum circuits. - """ - - def __init__( - self, - circuits: Iterable[QuantumCircuit], - parameters: Iterable[Iterable[Parameter]] | None = None, - ): - """ - Args: - circuits: Quantum circuits to be executed. - parameters: Parameters of each of the quantum circuits. - Defaults to ``[circ.parameters for circ in circuits]``. - - Raises: - QiskitError: For mismatch of circuits and parameters list. - """ - self._circuits = tuple(circuits) - if parameters is None: - self._parameters = tuple(circ.parameters for circ in self._circuits) - else: - self._parameters = tuple(ParameterView(par) for par in parameters) - if len(self._parameters) != len(self._circuits): - raise QiskitError( - f"Different number of parameters ({len(self._parameters)} " - f"and circuits ({len(self._circuits)}" - ) - - def __enter__(self): - return self - - def __exit__(self, *exc_info): - self.close() - - @abstractmethod - def close(self): - """Close the session and free resources""" - ... - - @property - def circuits(self) -> tuple[QuantumCircuit, ...]: - """Quantum circuits to be sampled. - - Returns: - The quantum circuits to be sampled. - """ - return self._circuits - - @property - def parameters(self) -> tuple[ParameterView, ...]: - """Parameters of quantum circuits. - - Returns: - List of the parameters in each quantum circuit. - """ - return self._parameters - - @abstractmethod - def __call__( - self, - circuit_indices: Sequence[int], - parameter_values: Sequence[Sequence[float]], - **run_options, - ) -> SamplerResult: - """Run the sampling of bitstrings. - - Args: - circuit_indices: Indices of the circuits to evaluate. - parameter_values: Parameters to be bound to the circuit. - run_options: Backend runtime options used for circuit execution. - - Returns: - The result of the sampler. The i-th result corresponds to - ``self.circuits[circuit_indices[i]]`` evaluated with parameters bound as - ``parameter_values[i]``. - """ - ... diff --git a/qiskit_machine_learning/primitives/qnns/primitives/estimator.py b/qiskit_machine_learning/primitives/qnns/primitives/estimator.py deleted file mode 100644 index 6e9a08c86..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/estimator.py +++ /dev/null @@ -1,115 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Estimator class -""" - -from __future__ import annotations - -from collections.abc import Iterable, Sequence -from typing import cast - -import numpy as np - -from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.exceptions import QiskitError -from qiskit.opflow import PauliSumOp -from qiskit.quantum_info import Statevector -from qiskit.quantum_info.operators.base_operator import BaseOperator - -from .base_estimator import BaseEstimator -from .estimator_result import EstimatorResult -from .utils import init_circuit, init_observable - - -class Estimator(BaseEstimator): - """ - Estimator class - """ - - def __init__( - self, - circuits: QuantumCircuit | Iterable[QuantumCircuit], - observables: BaseOperator | PauliSumOp | Iterable[BaseOperator | PauliSumOp], - parameters: Iterable[Iterable[Parameter]] | None = None, - ): - if isinstance(circuits, QuantumCircuit): - circuits = [circuits] - circuits = [init_circuit(circuit) for circuit in circuits] - - if isinstance(observables, (PauliSumOp, BaseOperator)): - observables = [observables] - observables = [init_observable(observable) for observable in observables] - - super().__init__( - circuits=circuits, - observables=observables, - parameters=parameters, - ) - self._is_closed = False - - def __call__( - self, - circuit_indices: Sequence[int] | None = None, - observable_indices: Sequence[int] | None = None, - parameter_values: Sequence[Sequence[float]] | Sequence[float] | None = None, - **run_options, - ) -> EstimatorResult: - if self._is_closed: - raise QiskitError("The primitive has been closed.") - - if isinstance(parameter_values, np.ndarray): - parameter_values = parameter_values.tolist() - if parameter_values and not isinstance(parameter_values[0], (np.ndarray, Sequence)): - parameter_values = cast("Sequence[float]", parameter_values) - parameter_values = [parameter_values] - if circuit_indices is None: - circuit_indices = list(range(len(self._circuits))) - if observable_indices is None: - observable_indices = list(range(len(self._observables))) - if parameter_values is None: - parameter_values = [[]] * len(circuit_indices) - if len(circuit_indices) != len(observable_indices): - raise QiskitError( - f"The number of circuit indices ({len(circuit_indices)}) does not match " - f"the number of observable indices ({len(observable_indices)})." - ) - if len(circuit_indices) != len(parameter_values): - raise QiskitError( - f"The number of circuit indices ({len(circuit_indices)}) does not match " - f"the number of parameter value sets ({len(parameter_values)})." - ) - - bound_circuits = [] - for i, value in zip(circuit_indices, parameter_values): - if len(value) != len(self._parameters[i]): - raise QiskitError( - f"The number of values ({len(value)}) does not match " - f"the number of parameters ({len(self._parameters[i])})." - ) - bound_circuits.append( - self._circuits[i].bind_parameters(dict(zip(self._parameters[i], value))) - ) - sorted_observables = [self._observables[i] for i in observable_indices] - expectation_values = [] - for circ, obs in zip(bound_circuits, sorted_observables): - if circ.num_qubits != obs.num_qubits: - raise QiskitError( - f"The number of qubits of a circuit ({circ.num_qubits}) does not match " - f"the number of qubits of a observable ({obs.num_qubits})." - ) - expectation_values.append(Statevector(circ).expectation_value(obs)) - - return EstimatorResult(np.real_if_close(expectation_values), [{}] * len(expectation_values)) - - def close(self): - self._is_closed = True diff --git a/qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py b/qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py deleted file mode 100644 index e26d9848c..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/estimator_result.py +++ /dev/null @@ -1,44 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Estimator result class -""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import TYPE_CHECKING, Any - -if TYPE_CHECKING: - import numpy as np - - -@dataclass(frozen=True) -class EstimatorResult: - """Result of Estimator. - - .. code-block:: python - - result = estimator(circuits, observables, params) - - where the i-th elements of ``result`` correspond to the circuit and observable given by - ``circuit_indices[i]``, ``observable_indices[i]``, and the parameter values bounds by ``params[i]``. - For example, ``results.values[i]`` gives the expectation value, and ``result.metadata[i]`` - is a metadata dictionary for this circuit and parameters. - - Args: - values (np.ndarray): The array of the expectation values. - metadata (list[dict]): List of the metadata. - """ - - values: "np.ndarray[Any, np.dtype[np.float64]]" - metadata: list[dict[str, Any]] diff --git a/qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py b/qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py deleted file mode 100644 index d0ac2ee93..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/factories/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .estimator_factory import EstimatorFactory -from .statevector_estimator_factory import StatevectorEstimatorFactory diff --git a/qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py b/qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py deleted file mode 100644 index 6be57a319..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/factories/estimator_factory.py +++ /dev/null @@ -1,16 +0,0 @@ -from abc import ABC, abstractmethod - -from qiskit.primitives import BaseEstimator - -class EstimatorFactory(ABC): - """Class to construct an estimator, given circuits and observables.""" - - def __init__(self, circuits=None, observables=None, parameters=None): - self.circuits = circuits - self.observables = observables - self.parameters = parameters - - @abstractmethod - def __call__(self, circuits=None, observables=None, parameters=None) -> BaseEstimator: - pass - diff --git a/qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py b/qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py deleted file mode 100644 index 3c9b95c8a..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/factories/statevector_estimator_factory.py +++ /dev/null @@ -1,13 +0,0 @@ -from qiskit.primitives import Estimator -from .estimator_factory import EstimatorFactory - -class StatevectorEstimatorFactory(EstimatorFactory): - """Estimator factory evaluated with statevector simulations.""" - - def __call__(self, circuits=None, observables=None, parameters=None) -> Estimator: - circuits = circuits or self.circuits - observables = observables or self.observables - parameters = parameters or self.parameters - - return Estimator(circuits, observables, parameters) - diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py deleted file mode 100755 index 687a25aae..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/__init__.py +++ /dev/null @@ -1,14 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -from .finite_diff_estimator_gradient import FiniteDiffEstimatorGradient -from .finite_diff_sampler_gradient import FiniteDiffSamplerGradient diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py deleted file mode 100644 index f38f4fa0a..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/base_estimator_gradient.py +++ /dev/null @@ -1,37 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -""" -Abstract Base class of Gradient. -""" - -from __future__ import annotations - -from abc import ABC, abstractmethod -from collections.abc import Sequence - -from ..base_estimator import BaseEstimator - - -class BaseEstimatorGradient(ABC): - def __init__(self, estimator: BaseEstimator): - self._estimator = estimator - - @abstractmethod - def gradient( - self, - circuit_indices: Sequence[int], - observable_indices: Sequence[int], - parameter_values: Sequence[Sequence[float]], - **run_options, - ) -> EstimatorResult: - ... diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py deleted file mode 100644 index ab61934b0..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_estimator_gradient.py +++ /dev/null @@ -1,56 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -from __future__ import annotations - -from collections.abc import Sequence - -import numpy as np - -from ..base_estimator import BaseEstimator -from ..estimator_result import EstimatorResult -from .base_estimator_gradient import BaseEstimatorGradient - - -class FiniteDiffEstimatorGradient(BaseEstimatorGradient): - def __init__(self, estimator: BaseEstimator, epsilon: float = 1e-6): - self._epsilon = epsilon - super().__init__(estimator) - - def gradient( - self, - circuit_index: int, - observable_index: int, - parameter_value: Sequence[float], - **run_options, - ) -> EstimatorResult: - run_options = run_options.copy() - - dim = len(parameter_value) - ret = [parameter_value] - for i in range(dim): - ei = parameter_value.copy() - ei[i] += self._epsilon - ret.append(ei) - param_array = np.array(ret).tolist() - circuit_indices = [circuit_index] * (dim + 1) - observable_indices = [observable_index] * (dim + 1) - results = self._estimator.__call__( - circuit_indices, observable_indices, param_array, **run_options - ) - - values = results.values - grad = np.zeros(dim) - f_ref = values[0] - for i, f_i in enumerate(values[1:]): - grad[i] = (f_i - f_ref) / self._epsilon - return EstimatorResult(values=grad, metadata=[{}] * len(grad)) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py deleted file mode 100644 index c40131e40..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/finite_diff_sampler_gradient.py +++ /dev/null @@ -1,55 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -from __future__ import annotations - -from collections.abc import Sequence - -import numpy as np - -from qiskit.result import QuasiDistribution - -from ..base_sampler import BaseSampler -from ..sampler_result import SamplerResult - - -class FiniteDiffSamplerGradient: - def __init__(self, sampler: BaseSampler, epsilon: float = 1e-6): - self._epsilon = epsilon - self._sampler = sampler - - def gradient( - self, - circuit_index: int, - parameter_value: Sequence[float], - **run_options, - ) -> SamplerResult: - run_options = run_options.copy() - - dim = len(parameter_value) - params = [parameter_value] - for i in range(dim): - ei = parameter_value.copy() - ei[i] += self._epsilon - params.append(ei) - param_list = np.array(params).tolist() - circuit_indices = [circuit_index] * (dim + 1) - results = self._sampler.__call__(circuit_indices, param_list, **run_options) - - quasi_dists = results.quasi_dists - ret = [] - f_ref = quasi_dists[0] - for f_i in quasi_dists[1:]: - ret.append( - QuasiDistribution({key: (f_i[key] - f_ref[key]) / self._epsilon for key in f_ref}) - ) - return SamplerResult(quasi_dists=ret, metadata=[{}] * len(ret)) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py deleted file mode 100644 index 40d5604f1..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_estimator_gradient.py +++ /dev/null @@ -1,224 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Gradient of expectation values with linear combination of unitaries (LCU) -""" - -from __future__ import annotations - -from collections import defaultdict -from dataclasses import dataclass -from typing import Sequence, Type - -import numpy as np - -from qiskit import transpile -from qiskit.circuit import ( - Gate, - Instruction, - Parameter, - ParameterExpression, - QuantumCircuit, - QuantumRegister, -) -from qiskit.circuit.library.standard_gates import ( - CXGate, - CYGate, - CZGate, - RXGate, - RXXGate, - RYGate, - RYYGate, - RZGate, - RZXGate, - RZZGate, -) -from qiskit.quantum_info import Pauli, SparsePauliOp - -from ..base_estimator import BaseEstimator -from ..estimator_result import EstimatorResult -from .base_estimator_gradient import BaseEstimatorGradient - -Pauli_Z = Pauli("Z") - - -@dataclass -class SubEstimator: - coeff: float | ParameterExpression - circuit: QuantumCircuit - index: int - - -class LinCombEstimatorGradient(BaseEstimatorGradient): - """LCU estimator gradient""" - - SUPPORTED_GATES = [ - "rx", - "ry", - "rz", - "rzx", - "rzz", - "ryy", - "rxx", - "cx", - "cy", - "cz", - "ccx", - "swap", - "iswap", - "h", - "t", - "s", - "sdg", - "x", - "y", - "z", - ] - - def __init__( - self, estimator: Type[BaseEstimator], circuit: QuantumCircuit, observable: SparsePauliOp - ): - self._circuit = circuit - self._observable = observable - self._grad, observable = self._preprocessing() - circuits = [self._circuit] - observables = [self._observable, observable] - for param, lst in self._grad.items(): - for arg in lst: - circuits.append(arg.circuit) - super().__init__(estimator(circuits=circuits, observables=observables)) - - def __enter__(self): - return self - - def __exit__(self, *exc_info): - pass - - @classmethod - def _gradient_circuits(cls, circuit: QuantumCircuit): - circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) - qr_superpos = QuantumRegister(1, "superpos") - circuit2.add_register(qr_superpos) - circuit2.h(qr_superpos) - circuit2.data.insert(0, circuit2.data.pop()) - circuit2.sdg(qr_superpos) - circuit2.data.insert(1, circuit2.data.pop()) - ret = defaultdict(list) - for i, (inst, qregs, _) in enumerate(circuit2.data): - if inst.is_parameterized(): - param = inst.params[0] - for p in param.parameters: - gate = cls._gate_gradient(inst) - circuit3 = circuit2.copy() - # insert `gate` to i-th position - circuit3.append(gate, [qr_superpos[0]] + qregs, []) - circuit3.data.insert(i, circuit3.data.pop()) - # - circuit3.h(qr_superpos) - ret[p].append((circuit3, param.gradient(p))) - return ret - - def _preprocessing(self): - grad = self._gradient_circuits(self._circuit) - ret = {} - observable = self._observable.expand(Pauli_Z) - index = 1 - for param in self._circuit.parameters: - lst = [] - for circ, coeff in grad[param]: - lst.append(SubEstimator(coeff=coeff, circuit=circ, index=index)) - index += 1 - ret[param] = lst - return ret, observable - - def __call__( - self, parameter_values: Sequence[Sequence[float]], **run_options - ) -> EstimatorResult: - return self._estimator([0], [0], parameter_values, **run_options) - - def gradient( - self, - parameter_value: Sequence[float], - partial: Sequence[Parameter] | None = None, - **run_options, - ) -> EstimatorResult: - parameters = partial or self._circuit.parameters - - param_map = {} - for j, param in enumerate(self._circuit.parameters): - param_map[param] = parameter_value[j] - - circ_indices = [] - for param in parameters: - circ_indices.extend([f.index for f in self._grad[param]]) - size = len(circ_indices) - results = self._estimator(circ_indices, [1] * size, [parameter_value] * size, **run_options) - - param_set = set(parameters) - values = np.zeros(len(parameter_value)) - metadata = [{} for _ in range(len(parameters))] - i = 0 - for j, (param, lst) in enumerate(self._grad.items()): - if param not in param_set: - continue - for subest in lst: - coeff = subest.coeff - if isinstance(coeff, ParameterExpression): - local_map = {param: param_map[param] for param in coeff.parameters} - bound_coeff = coeff.bind(local_map) - else: - bound_coeff = coeff - values[j] += bound_coeff * results.values[i] - i += 1 - - return EstimatorResult(values=values, metadata=metadata) - - @staticmethod - def _gate_gradient(gate: Gate) -> Instruction: - if isinstance(gate, RXGate): - # theta - return CXGate() - if isinstance(gate, RYGate): - # theta - return CYGate() - if isinstance(gate, RZGate): - # theta - return CZGate() - if isinstance(gate, RXXGate): - # theta - cxx_circ = QuantumCircuit(3) - cxx_circ.cx(0, 1) - cxx_circ.cx(0, 2) - cxx = cxx_circ.to_instruction() - return cxx - if isinstance(gate, RYYGate): - # theta - cyy_circ = QuantumCircuit(3) - cyy_circ.cy(0, 1) - cyy_circ.cy(0, 2) - cyy = cyy_circ.to_instruction() - return cyy - if isinstance(gate, RZZGate): - # theta - czz_circ = QuantumCircuit(3) - czz_circ.cz(0, 1) - czz_circ.cz(0, 2) - czz = czz_circ.to_instruction() - return czz - if isinstance(gate, RZXGate): - # theta - czx_circ = QuantumCircuit(3) - czx_circ.cx(0, 2) - czx_circ.cz(0, 1) - czx = czx_circ.to_instruction() - return czx - raise TypeError(f"Unrecognized parameterized gate, {gate}") diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py deleted file mode 100644 index 0c7f3409f..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/lin_comb_sampler_gradient.py +++ /dev/null @@ -1,221 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Gradient of probabilities with linear combination of unitaries (LCU) -""" - -from __future__ import annotations - -from collections import Counter, defaultdict -from dataclasses import dataclass -from typing import Sequence, Type - -from qiskit import transpile -from qiskit.circuit import ( - ClassicalRegister, - Gate, - Instruction, - Parameter, - ParameterExpression, - QuantumCircuit, - QuantumRegister, -) -from qiskit.circuit.library.standard_gates import ( - CXGate, - CYGate, - CZGate, - RXGate, - RXXGate, - RYGate, - RYYGate, - RZGate, - RZXGate, - RZZGate, -) -from qiskit.result import QuasiDistribution - -from ..base_sampler import BaseSampler -from ..sampler_result import SamplerResult - - -@dataclass -class SubEstimator: - coeff: float | ParameterExpression - circuit: QuantumCircuit - index: int - - -class LinCombSamplerGradient: - """LCU sampler gradient""" - - SUPPORTED_GATES = [ - "rx", - "ry", - "rz", - "rzx", - "rzz", - "ryy", - "rxx", - "cx", - "cy", - "cz", - "ccx", - "swap", - "iswap", - "h", - "t", - "s", - "sdg", - "x", - "y", - "z", - ] - - def __init__(self, sampler: Type[BaseSampler], circuit: QuantumCircuit): - self._circuit = circuit - self._grad = self._preprocessing() - circuits = [self._circuit] - for param, lst in self._grad.items(): - for arg in lst: - circuits.append(arg.circuit) - self._sampler = sampler(circuits=circuits) - - def __enter__(self): - return self - - def __exit__(self, *exc_info): - pass - - @classmethod - def _gradient_circuits(cls, circuit: QuantumCircuit): - circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) - qr_superpos = QuantumRegister(1, "superpos") - cr_superpos = ClassicalRegister(1, "superpos") - circuit2.add_register(qr_superpos) - circuit2.add_bits(cr_superpos) - circuit2.h(qr_superpos) - circuit2.data.insert(0, circuit2.data.pop()) - circuit2.sdg(qr_superpos) - circuit2.data.insert(1, circuit2.data.pop()) - ret = defaultdict(list) - for i, (inst, qregs, _) in enumerate(circuit2.data): - if inst.is_parameterized(): - param = inst.params[0] - for p in param.parameters: - gate = cls._gate_gradient(inst) - circuit3 = circuit2.copy() - # insert `gate` to i-th position - circuit3.append(gate, [qr_superpos[0]] + qregs, []) - circuit3.data.insert(i, circuit3.data.pop()) - # - circuit3.h(qr_superpos) - circuit3.measure(qr_superpos, cr_superpos) - ret[p].append((circuit3, param.gradient(p))) - return ret - - def _preprocessing(self): - grad = self._gradient_circuits(self._circuit) - ret = {} - index = 1 - for param in self._circuit.parameters: - lst = [] - for circ, coeff in grad[param]: - lst.append(SubEstimator(coeff=coeff, circuit=circ, index=index)) - index += 1 - ret[param] = lst - return ret - - def __call__(self, parameter_values: Sequence[Sequence[float]], **run_options) -> SamplerResult: - return self._sampler([0], parameter_values, **run_options) - - def gradient( - self, - parameter_value: Sequence[float], - partial: Sequence[Parameter] | None = None, - **run_options, - ) -> SamplerResult: - parameters = partial or self._circuit.parameters - - param_map = {} - for j, param in enumerate(self._circuit.parameters): - param_map[param] = parameter_value[j] - - circ_indices = [] - for param in parameters: - circ_indices.extend([f.index for f in self._grad[param]]) - size = len(circ_indices) - results = self._sampler(circ_indices, [parameter_value] * size, **run_options) - - param_set = set(parameters) - dists = [Counter() for _ in range(len(parameter_value))] - metadata = [{} for _ in range(len(parameters))] - num_bitstrings = 2**self._circuit.num_qubits - i = 0 - for j, (param, lst) in enumerate(self._grad.items()): - if param not in param_set: - continue - for subest in lst: - coeff = subest.coeff - if isinstance(coeff, ParameterExpression): - local_map = {param: param_map[param] for param in coeff.parameters} - bound_coeff = float(coeff.bind(local_map)) - else: - bound_coeff = coeff - for k, v in results.quasi_dists[i].items(): - sign, k2 = divmod(k, num_bitstrings) - dists[j][k2] += (-1) ** sign * bound_coeff * v - i += 1 - - return SamplerResult( - quasi_dists=[QuasiDistribution(dist) for dist in dists], metadata=metadata - ) - - @staticmethod - def _gate_gradient(gate: Gate) -> Instruction: - if isinstance(gate, RXGate): - # theta - return CXGate() - if isinstance(gate, RYGate): - # theta - return CYGate() - if isinstance(gate, RZGate): - # theta - return CZGate() - if isinstance(gate, RXXGate): - # theta - cxx_circ = QuantumCircuit(3) - cxx_circ.cx(0, 1) - cxx_circ.cx(0, 2) - cxx = cxx_circ.to_instruction() - return cxx - if isinstance(gate, RYYGate): - # theta - cyy_circ = QuantumCircuit(3) - cyy_circ.cy(0, 1) - cyy_circ.cy(0, 2) - cyy = cyy_circ.to_instruction() - return cyy - if isinstance(gate, RZZGate): - # theta - czz_circ = QuantumCircuit(3) - czz_circ.cz(0, 1) - czz_circ.cz(0, 2) - czz = czz_circ.to_instruction() - return czz - if isinstance(gate, RZXGate): - # theta - czx_circ = QuantumCircuit(3) - czx_circ.cx(0, 2) - czx_circ.cz(0, 1) - czx = czx_circ.to_instruction() - return czx - raise TypeError(f"Unrecognized parameterized gate, {gate}") diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py deleted file mode 100644 index b112e85ff..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_estimator_gradient.py +++ /dev/null @@ -1,139 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Gradient of expectation values with parameter shift -""" - -from __future__ import annotations - -from collections import defaultdict -from dataclasses import dataclass -from typing import Sequence, Type - -import numpy as np - -from qiskit import transpile -from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit -from qiskit.quantum_info import SparsePauliOp - -from ..base_estimator import BaseEstimator -from ..estimator_result import EstimatorResult -from .base_estimator_gradient import BaseEstimatorGradient - - -@dataclass -class SubEstimator: - coeff: float | ParameterExpression - circuit: QuantumCircuit - observable: SparsePauliOp - index: int - - -class ParamShiftEstimatorGradient(BaseEstimatorGradient): - """Parameter shift estimator gradient""" - - SUPPORTED_GATES = ["x", "y", "z", "h", "rx", "ry", "rz", "p", "cx", "cy", "cz"] - - def __init__( - self, estimator: Type[BaseEstimator], circuit: QuantumCircuit, observable: SparsePauliOp - ): - self._circuit = circuit - self._observable = observable - self._grad = self._preprocessing() - circuits = [self._circuit] - observables = [self._observable] - for param, lst in self._grad.items(): - for arg in lst: - circuits.append(arg.circuit) - super().__init__(estimator(circuits=circuits, observables=observables)) - - def __enter__(self): - return self - - def __exit__(self, *exc_info): - pass - - @classmethod - def _gradient_circuits(cls, circuit: QuantumCircuit): - circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) - ret = defaultdict(list) - for inst in circuit2.data: - if inst[0].is_parameterized(): - param = inst[0].params[0] - for p in param.parameters: - # TODO: Need to wait for an appropriate way to update parameters of - # a particular instruction. - # See https://github.com/Qiskit/qiskit-terra/issues/7894 - inst[0].params[0] = param + np.pi / 2 - ret[p].append((circuit2.copy(), param.gradient(p) / 2)) - inst[0].params[0] = param - np.pi / 2 - ret[p].append((circuit2.copy(), -param.gradient(p) / 2)) - inst[0].params[0] = param - return ret - - def _preprocessing(self): - grad = self._gradient_circuits(self._circuit) - ret = {} - index = 1 - for param in self._circuit.parameters: - lst = [] - for circ, coeff in grad[param]: - lst.append( - SubEstimator( - coeff=coeff, circuit=circ, observable=self._observable, index=index - ) - ) - index += 1 - ret[param] = lst - return ret - - def __call__( - self, parameter_values: Sequence[Sequence[float]], **run_options - ) -> EstimatorResult: - return self._estimator([0], [0], parameter_values, **run_options) - - def gradient( - self, - parameter_value: Sequence[float], - partial: Sequence[Parameter] | None = None, - **run_options, - ) -> EstimatorResult: - parameters = partial or self._circuit.parameters - - param_map = {} - for j, param in enumerate(self._circuit.parameters): - param_map[param] = parameter_value[j] - - circ_indices = [] - for param in parameters: - circ_indices.extend([f.index for f in self._grad[param]]) - size = len(circ_indices) - results = self._estimator(circ_indices, [0] * size, [parameter_value] * size, **run_options) - - param_set = set(parameters) - values = np.zeros(len(parameter_value)) - metadata = [{} for _ in range(len(parameters))] - i = 0 - for j, (param, lst) in enumerate(self._grad.items()): - if param not in param_set: - continue - for subest in lst: - coeff = subest.coeff - if isinstance(coeff, ParameterExpression): - local_map = {param: param_map[param] for param in coeff.parameters} - bound_coeff = coeff.bind(local_map) - else: - bound_coeff = coeff - values[j] += bound_coeff * results.values[i] - i += 1 - - return EstimatorResult(values=values, metadata=metadata) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py b/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py deleted file mode 100644 index 8c8b6f938..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/gradient/param_shift_sampler_gradient.py +++ /dev/null @@ -1,134 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Gradient of probabilities with parameter shift -""" - -from __future__ import annotations - -from collections import Counter, defaultdict -from dataclasses import dataclass -from typing import Sequence, Type - -import numpy as np - -from qiskit import transpile -from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit -from qiskit.result import QuasiDistribution - -from ..base_sampler import BaseSampler -from ..sampler_result import SamplerResult - - -@dataclass -class SubSampler: - coeff: float | ParameterExpression - circuit: QuantumCircuit - index: int - - -class ParamShiftSamplerGradient: - """Parameter shift estimator gradient""" - - SUPPORTED_GATES = ["x", "y", "z", "h", "rx", "ry", "rz", "p", "cx", "cy", "cz"] - - def __init__(self, sampler: Type[BaseSampler], circuit: QuantumCircuit): - self._circuit = circuit - self._grad = self._preprocessing() - circuits = [self._circuit] - for param, lst in self._grad.items(): - for arg in lst: - circuits.append(arg.circuit) - self._sampler = sampler(circuits=circuits) - - def __enter__(self): - return self - - def __exit__(self, *exc_info): - pass - - @classmethod - def _gradient_circuits(cls, circuit: QuantumCircuit): - circuit2 = transpile(circuit, basis_gates=cls.SUPPORTED_GATES, optimization_level=0) - ret = defaultdict(list) - for inst in circuit2.data: - if inst[0].is_parameterized(): - param = inst[0].params[0] - for p in param.parameters: - # TODO: Need to wait for an appropriate way to update parameters of - # a particular instruction. - # See https://github.com/Qiskit/qiskit-terra/issues/7894 - inst[0].params[0] = param + np.pi / 2 - ret[p].append((circuit2.copy(), param.gradient(p) / 2)) - inst[0].params[0] = param - np.pi / 2 - ret[p].append((circuit2.copy(), -param.gradient(p) / 2)) - inst[0].params[0] = param - return ret - - def _preprocessing(self): - grad = self._gradient_circuits(self._circuit) - # print("gradient circuits: ", grad) - ret = {} - index = 1 - for param in self._circuit.parameters: - lst = [] - for circ, coeff in grad[param]: - lst.append(SubSampler(coeff=coeff, circuit=circ, index=index)) - index += 1 - ret[param] = lst - return ret - - def __call__(self, parameter_values: Sequence[Sequence[float]], **run_options) -> SamplerResult: - return self._sampler([0], parameter_values, **run_options) - - def gradient( - self, - parameter_value: Sequence[float], - partial: Sequence[Parameter] | None = None, - **run_options, - ) -> SamplerResult: - - parameters = partial or self._circuit.parameters - - param_map = {} - - for j, param in enumerate(self._circuit.parameters): - param_map[param] = parameter_value[j] - - circ_indices = [] - for param in parameters: - circ_indices.extend([f.index for f in self._grad[param]]) - size = len(circ_indices) - results = self._sampler(circ_indices, [parameter_value] * size, **run_options) - - param_set = set(parameters) - dists = [Counter() for _ in range(len(parameter_value))] - metadata = [{} for _ in range(len(parameters))] - i = 0 - for j, (param, lst) in enumerate(self._grad.items()): - if param not in param_set: - continue - for subest in lst: - coeff = subest.coeff - if isinstance(coeff, ParameterExpression): - local_map = {param: param_map[param] for param in coeff.parameters} - bound_coeff = float(coeff.bind(local_map)) - else: - bound_coeff = coeff - dists[j].update( - Counter({k: bound_coeff * v for k, v in results.quasi_dists[i].items()}) - ) - i += 1 - - return SamplerResult( - quasi_dists=[QuasiDistribution(dist) for dist in dists], metadata=metadata - ) diff --git a/qiskit_machine_learning/primitives/qnns/primitives/sampler.py b/qiskit_machine_learning/primitives/qnns/primitives/sampler.py deleted file mode 100644 index cecb0c948..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/sampler.py +++ /dev/null @@ -1,115 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Sampler class -""" - -from __future__ import annotations - -from collections.abc import Iterable, Sequence -from typing import cast - -import numpy as np - -from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.exceptions import QiskitError -from qiskit.quantum_info import Statevector -from qiskit.result import QuasiDistribution - -from .base_sampler import BaseSampler -from .sampler_result import SamplerResult -from .utils import final_measurement_mapping, init_circuit - - -class Sampler(BaseSampler): - """ - Sampler class - """ - - def __init__( - self, - circuits: QuantumCircuit | Iterable[QuantumCircuit], - parameters: Iterable[Iterable[Parameter]] | None = None, - ): - """ - Args: - circuits: circuits to be executed - parameters: Parameters of each of the quantum circuits. - Defaults to ``[circ.parameters for circ in circuits]``. - - Raises: - QiskitError: if some classical bits are not used for measurements. - """ - if isinstance(circuits, QuantumCircuit): - circuits = [circuits] - circuits = [init_circuit(circuit) for circuit in circuits] - q_c_mappings = [final_measurement_mapping(circuit) for circuit in circuits] - self._qargs_list = [] - for circuit, q_c_mapping in zip(circuits, q_c_mappings): - if set(range(circuit.num_clbits)) != set(q_c_mapping.values()): - raise QiskitError( - "some classical bits are not used for measurements." - f" the number of classical bits {circuit.num_clbits}," - f" the used classical bits {set(q_c_mapping.values())}." - ) - c_q_mapping = sorted((c, q) for q, c in q_c_mapping.items()) - self._qargs_list.append([q for _, q in c_q_mapping]) - circuits = [circuit.remove_final_measurements(inplace=False) for circuit in circuits] - super().__init__(circuits, parameters) - self._is_closed = False - - def __call__( - self, - circuit_indices: Sequence[int] | None = None, - parameter_values: Sequence[Sequence[float]] | Sequence[float] | None = None, - **run_options, - ) -> SamplerResult: - if self._is_closed: - raise QiskitError("The primitive has been closed.") - - if isinstance(parameter_values, np.ndarray): - parameter_values = parameter_values.tolist() - if parameter_values and not isinstance(parameter_values[0], (np.ndarray, Sequence)): - parameter_values = cast("Sequence[float]", parameter_values) - parameter_values = [parameter_values] - if circuit_indices is None: - circuit_indices = list(range(len(self._circuits))) - if parameter_values is None: - parameter_values = [[]] * len(circuit_indices) - if len(circuit_indices) != len(parameter_values): - raise QiskitError( - f"The number of circuit indices ({len(circuit_indices)}) does not match " - f"the number of parameter value sets ({len(parameter_values)})." - ) - - bound_circuits_qargs = [] - for i, value in zip(circuit_indices, parameter_values): - if len(value) != len(self._parameters[i]): - raise QiskitError( - f"The number of values ({len(value)}) does not match " - f"the number of parameters ({len(self._parameters[i])})." - ) - bound_circuits_qargs.append( - ( - self._circuits[i].bind_parameters(dict(zip(self._parameters[i], value))), - self._qargs_list[i], - ) - ) - probabilities = [ - Statevector(circ).probabilities(qargs=qargs) for circ, qargs in bound_circuits_qargs - ] - quasis = [QuasiDistribution(dict(enumerate(p))) for p in probabilities] - - return SamplerResult(quasis, [{}] * len(circuit_indices)) - - def close(self): - self._is_closed = True diff --git a/qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py b/qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py deleted file mode 100644 index 5b53b1066..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/sampler_result.py +++ /dev/null @@ -1,43 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Sampler result class -""" - -from __future__ import annotations - -from dataclasses import dataclass -from typing import Any - -from qiskit.result import QuasiDistribution - - -@dataclass(frozen=True) -class SamplerResult: - """Result of Sampler. - - .. code-block:: python - - result = sampler(circuits, params) - - where the i-th elements of ``result`` correspond to the circuit given by ``circuit_indices[i]``, - and the parameter values bounds by ``params[i]``. - For example, ``results.quasi_dists[i]`` gives the quasi-probabilities of bitstrings, and - ``result.metadata[i]`` is a metadata dictionary for this circuit and parameters. - - Args: - quasi_dists (list[QuasiDistribution]): List of the quasi-probabilities. - metadata (list[dict]): List of the metadata. - """ - - quasi_dists: list[QuasiDistribution] - metadata: list[dict[str, Any]] diff --git a/qiskit_machine_learning/primitives/qnns/primitives/utils.py b/qiskit_machine_learning/primitives/qnns/primitives/utils.py deleted file mode 100644 index e5abc4120..000000000 --- a/qiskit_machine_learning/primitives/qnns/primitives/utils.py +++ /dev/null @@ -1,113 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. -""" -Utility functions for primitives -""" - -from __future__ import annotations - -from qiskit.circuit import ParameterExpression, QuantumCircuit -from qiskit.extensions.quantum_initializer.initializer import Initialize -from qiskit.opflow import PauliSumOp -from qiskit.quantum_info import SparsePauliOp, Statevector -from qiskit.quantum_info.operators.base_operator import BaseOperator -from qiskit.quantum_info.operators.symplectic.base_pauli import BasePauli - - -def init_circuit(state: QuantumCircuit | Statevector) -> QuantumCircuit: - """Initialize state by converting the input to a quantum circuit. - - Args: - state: The state as quantum circuit or statevector. - - Returns: - The state as quantum circuit. - """ - if isinstance(state, QuantumCircuit): - return state - if not isinstance(state, Statevector): - state = Statevector(state) - qc = QuantumCircuit(state.num_qubits) - qc.append(Initialize(state), qargs=range(state.num_qubits)) - return qc - - -def init_observable(observable: BaseOperator | PauliSumOp) -> SparsePauliOp: - """Initialize observable by converting the input to a :class:`~qiskit.quantum_info.SparsePauliOp`. - - Args: - observable: The observable. - - Returns: - The observable as :class:`~qiskit.quantum_info.SparsePauliOp`. - - Raises: - TypeError: If the observable is a :class:`~qiskit.opflow.PauliSumOp` and has a parameterized - coefficient. - """ - if isinstance(observable, SparsePauliOp): - return observable - elif isinstance(observable, PauliSumOp): - if isinstance(observable.coeff, ParameterExpression): - raise TypeError( - f"Observable must have numerical coefficient, not {type(observable.coeff)}." - ) - return observable.coeff * observable.primitive - elif isinstance(observable, BasePauli): - return SparsePauliOp(observable) - elif isinstance(observable, BaseOperator): - return SparsePauliOp.from_operator(observable) - else: - return SparsePauliOp(observable) - - -def final_measurement_mapping(circuit: QuantumCircuit) -> dict[int, int]: - """Return the final measurement mapping for the circuit. - - Dict keys label measured qubits, whereas the values indicate the - classical bit onto which that qubits measurement result is stored. - - Note: this function is a slightly simplified version of a utility function - ``_final_measurement_mapping`` of - `mthree `_. - - Parameters: - circuit: Input quantum circuit. - - Returns: - Mapping of qubits to classical bits for final measurements. - """ - active_qubits = list(range(circuit.num_qubits)) - active_cbits = list(range(circuit.num_clbits)) - - # Find final measurements starting in back - mapping = {} - for item in circuit._data[::-1]: - if item[0].name == "measure": - cbit = circuit.find_bit(item[2][0]).index - qbit = circuit.find_bit(item[1][0]).index - if cbit in active_cbits and qbit in active_qubits: - mapping[qbit] = cbit - active_cbits.remove(cbit) - active_qubits.remove(qbit) - elif item[0].name != "barrier": - for qq in item[1]: - _temp_qubit = circuit.find_bit(qq).index - if _temp_qubit in active_qubits: - active_qubits.remove(_temp_qubit) - - if not active_cbits or not active_qubits: - break - - # Sort so that classical bits are in numeric order low->high. - mapping = dict(sorted(mapping.items(), key=lambda item: item[1])) - return mapping diff --git a/qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py b/qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py deleted file mode 100644 index 7ff555ea9..000000000 --- a/qiskit_machine_learning/primitives/qnns/sampler-qnn-example.py +++ /dev/null @@ -1,75 +0,0 @@ -# THIS EXAMPLE USES THE TERRA PRIMITIVES! -import numpy as np -from qiskit.primitives import Sampler, Estimator -from qiskit import Aer, QuantumCircuit -from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap -from qiskit.utils import QuantumInstance, algorithm_globals -from qiskit_machine_learning.neural_networks import CircuitQNN -from primitives.gradient.param_shift_sampler_gradient import ParamShiftSamplerGradient -from primitives.gradient.finite_diff_sampler_gradient import FiniteDiffSamplerGradient -algorithm_globals.random_seed = 42 - -# DEFINE CIRCUIT FOR SAMPLER -num_qubits = 3 -qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) -qc.draw(output="mpl") -# ADD MEASUREMENT HERE --> TRICKY -qc.measure_all() - -# --------------------- - -from qiskit import Aer -from qiskit.utils import QuantumInstance - -qi_qasm = QuantumInstance(Aer.get_backend("aer_simulator"), shots=10) -qi_sv = QuantumInstance(Aer.get_backend("statevector_simulator")) - -parity = lambda x: "{:b}".format(x).count("1") % 2 -output_shape = 2 # this is required in case of a callable with dense output - -qnn2 = CircuitQNN( - qc, - input_params=qc.parameters[:3], - weight_params=qc.parameters[3:], - sparse = False, - interpret = parity, - output_shape = output_shape, - quantum_instance=qi_sv, -) -inputs = np.asarray(algorithm_globals.random.random(size = (1, qnn2._num_inputs))) -weights = algorithm_globals.random.random(qnn2._num_weights) -print("inputs: ", inputs) -print("weights: ", weights) - -np.set_printoptions(precision=2) -f = qnn2.forward(inputs, weights) -print( f"fwd pass: {f}") -np.set_printoptions(precision=2) -b = qnn2.backward(inputs, weights) -print( f"bkwd pass: {b}" ) -# --------------------- - -# IMPORT QNN -from neural_networks.sampler_qnn_2 import SamplerQNN - -with SamplerQNN( - circuit=qc, - input_params=qc.parameters[:3], - weight_params=qc.parameters[3:], - sampler_factory=Sampler, - interpret = parity, - output_shape = output_shape, - ) as qnn: - # inputs = np.asarray(algorithm_globals.random.random((2, qnn._num_inputs))) - # weights = algorithm_globals.random.random(qnn._num_weights) - print("inputs: ", inputs) - print("weights: ", weights) - - np.set_printoptions(precision=2) - f = qnn.forward(inputs, weights) - print(f"fwd pass: {f}") - np.set_printoptions(precision=2) - b = qnn.backward(inputs, weights) - print(f"bkwd pass: {b}") - - diff --git a/qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py b/qiskit_machine_learning/primitives/sampler_qnn.py similarity index 83% rename from qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py rename to qiskit_machine_learning/primitives/sampler_qnn.py index 9d3f3000a..dd344e0db 100644 --- a/qiskit_machine_learning/primitives/qnns/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/primitives/sampler_qnn.py @@ -1,21 +1,30 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2020, 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""A Neural Network implementation based on the Sampler primitive.""" + import logging from numbers import Integral import numpy as np from typing import Optional, Union, List, Tuple, Callable, cast, Iterable + from qiskit import QuantumCircuit from qiskit.circuit import Parameter from qiskit_machine_learning.exceptions import QiskitMachineLearningError, QiskitError logger = logging.getLogger(__name__) -# from primitives.gradient import FiniteDiffEstimatorGradient, FiniteDiffSamplerGradient - -from scipy.sparse import coo_matrix - -from primitives.gradient.param_shift_sampler_gradient import ParamShiftSamplerGradient -from qiskit.primitives import Sampler - class SamplerQNN(): + """A Neural Network implementation based on the Sampler primitive.""" def __init__( self, @@ -25,16 +34,10 @@ def __init__( interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]] = None, output_shape: Union[int, Tuple[int, ...]] = None, sampler_factory: Callable = None, - gradient_method: str = "param_shift", + gradient_method: str = None, ): - # IGNORING SPARSE - # SKIPPING CUSTOM GRADIENT - # SKIPPING "INPUT GRADIENTS" -> by default with primitives? - - # we allow only one circuit at this moment self._circuit = circuit - # self._gradient = ParamShiftSamplerGradient(sampler, self._circuit) self._gradient_method = gradient_method self._sampler_factory = sampler_factory @@ -45,8 +48,10 @@ def __init__( self.output_shape = None self._num_inputs = len(self._input_params) self._num_weights = len(self._weight_params) + self.num_weights = self._num_weights - # the circuit must always have measurements.... (?) + + # the circuit must always have measurements... # add measurements in case none are given if len(self._circuit.clbits) == 0: self._circuit.measure_all() @@ -57,11 +62,9 @@ def __init__( # set interpret and compute output shape self.set_interpret(interpret, output_shape) + # not implemented yet self._input_gradients = None - # def output_shape(self): - # return self._output_shape - # return self._output_shape def __enter__(self): self.open() @@ -71,22 +74,31 @@ def __exit__(self, *exc_info): self.close() def open(self): - # we should delay instantiation of the primitives till they are really required + """ + Open sampler/gradient session. + """ + + # we should delay instantiation of the primitives until they are really required if self._gradient_method == "param_shift": # if gradient method -> sampler with gradient functionality - self._sampler = ParamShiftSamplerGradient( - circuit = self._circuit, - sampler = self._sampler_factory - ) + # self._sampler = ParamShiftSamplerGradient( + # circuit = self._circuit, + # sampler = self._sampler_factory + # ) + pass # waiting for gradients + else: # if no gradient method -> sampler without gradient functionality self._sampler = self._sampler_factory( - circuits = [self._circuit], + circuits = self._circuit, parameters = [self._input_params + self._weight_params] ) pass def close(self): + """ + Close sampler/gradient session. + """ self._sampler.__exit__() def set_interpret( @@ -94,15 +106,13 @@ def set_interpret( interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]], output_shape: Union[int, Tuple[int, ...]] = None, ) -> None: - """Change 'interpret' and corresponding 'output_shape'. If self.sampling==True, the - output _shape does not have to be set and is inferred from the interpret function. - Otherwise, the output_shape needs to be given. + """Change 'interpret' and corresponding 'output_shape'. Args: interpret: A callable that maps the measured integer to another unsigned integer or tuple of unsigned integers. See constructor for more details. output_shape: The output shape of the custom interpretation, only used in the case - where an interpret function is provided and ``sampling==False``. See constructor + where an interpret function is provided. See constructor for more details. """ @@ -177,7 +187,7 @@ def _postprocess(self, num_samples, result): prob = np.zeros((num_samples, *self._output_shape)) for i in range(num_samples): - counts = result[i].quasi_dists[0] + counts = result.quasi_dists[i] print(counts) shots = sum(counts.values()) @@ -194,12 +204,14 @@ def _forward( parameter_values, num_samples = self._preprocess(input_data, weights) - # result = self._sampler([0] * num_samples, parameter_values) + # sampler allows batching (gradient doesn't) + results = self._sampler([0] * num_samples, parameter_values) - results = [] - for sample in range(num_samples): - result = self._sampler(parameter_values) - results.append(result) + # results = [] + # for sample in range(num_samples): + # result = self._sampler(circuits = self._circuit, + # parameter_values = parameter_values) + # results.append(result) result = self._postprocess(num_samples, results) @@ -211,8 +223,9 @@ def backward( weights: Optional[Union[List[float], np.ndarray, float]], ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: - result = self._backward(input_data, weights) - return result + # result = self._backward(input_data, weights) + # return result + pass def _preprocess_gradient(self, input_data, weights): @@ -303,3 +316,5 @@ def _backward( + + From ada284bb37282ee67cc9a07d345dfadfc70bff12 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 11 Jul 2022 13:12:49 +0200 Subject: [PATCH 09/96] Undo kernel changes --- qiskit_machine_learning/utils/__init__.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/qiskit_machine_learning/utils/__init__.py b/qiskit_machine_learning/utils/__init__.py index 0ac0473ae..000618000 100644 --- a/qiskit_machine_learning/utils/__init__.py +++ b/qiskit_machine_learning/utils/__init__.py @@ -26,7 +26,3 @@ loss_functions """ - -from .utils import make_2d - -__all__ = ["make_2d"] From b2d42f21829366e77ffd6894d88113c49b5d1154 Mon Sep 17 00:00:00 2001 From: ElePT Date: Thu, 14 Jul 2022 13:30:22 +0200 Subject: [PATCH 10/96] Start adding new type hint style --- .../primitives/sampler_qnn.py | 189 ++++++++++-------- test/primitives/test_sampler_qnn.py | 26 ++- 2 files changed, 122 insertions(+), 93 deletions(-) diff --git a/qiskit_machine_learning/primitives/sampler_qnn.py b/qiskit_machine_learning/primitives/sampler_qnn.py index dd344e0db..3ab503531 100644 --- a/qiskit_machine_learning/primitives/sampler_qnn.py +++ b/qiskit_machine_learning/primitives/sampler_qnn.py @@ -12,36 +12,60 @@ """A Neural Network implementation based on the Sampler primitive.""" +from __future__ import annotations import logging from numbers import Integral -import numpy as np from typing import Optional, Union, List, Tuple, Callable, cast, Iterable +import numpy as np + from qiskit import QuantumCircuit from qiskit.circuit import Parameter from qiskit_machine_learning.exceptions import QiskitMachineLearningError, QiskitError logger = logging.getLogger(__name__) -class SamplerQNN(): + +class SamplerQNN: """A Neural Network implementation based on the Sampler primitive.""" def __init__( - self, - circuit: QuantumCircuit, - input_params: Optional[List[Parameter]] = None, - weight_params: Optional[List[Parameter]] = None, - interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]] = None, - output_shape: Union[int, Tuple[int, ...]] = None, - sampler_factory: Callable = None, - gradient_method: str = None, - - ): + self, + circuit: QuantumCircuit, + input_params: List[Parameter] | None = None, + weight_params: List[Parameter] | None = None, + interpret: Callable[[int], int | Tuple[int, ...]] | None = None, + output_shape: int | Tuple[int, ...] | None = None, + sampler_factory: Callable | None = None, + gradient_factory: Callable | str | None = None, + )-> None: + """ + + Args: + circuit: The parametrized quantum circuit that generates the samples of this network. + input_params: The parameters of the circuit corresponding to the input. + weight_params: The parameters of the circuit corresponding to the trainable weights. + interpret: A callable that maps the measured integer to another unsigned integer or + tuple of unsigned integers. These are used as new indices for the (potentially + sparse) output array. If no interpret function is + passed, then an identity function will be used by this neural network. + output_shape: The output shape of the custom interpretation + sampler_factory: Factory for sampler primitive + gradient_factory: String indicating pre-implemented gradient method or factory for + gradient class + input_gradients: to be added + Raises: + QiskitMachineLearningError: Invalid parameter values. + """ + self._circuit = circuit - self._gradient_method = gradient_method + self._gradient_factory = gradient_factory self._sampler_factory = sampler_factory + self._sampler = None + self._gradient = None + self._input_params = list(input_params or []) self._weight_params = list(weight_params or []) @@ -63,39 +87,39 @@ def __init__( self.set_interpret(interpret, output_shape) # not implemented yet - self._input_gradients = None - + # self._input_gradients = None def __enter__(self): + """ + QNN used with context managers. + """ self.open() return self - def __exit__(self, *exc_info): + def __exit__(self, *exc_info) -> None: + """ + QNN used with context managers. + """ self.close() - def open(self): + def open(self) -> None: """ Open sampler/gradient session. """ - # we should delay instantiation of the primitives until they are really required - if self._gradient_method == "param_shift": + self._sampler = self._sampler_factory( + circuits=self._circuit, parameters=[self._input_params + self._weight_params] + ) + + if self._gradient_factory is not None: # if gradient method -> sampler with gradient functionality - # self._sampler = ParamShiftSamplerGradient( + # self._gradient = ParamShiftSamplerGradient( # circuit = self._circuit, # sampler = self._sampler_factory # ) - pass # waiting for gradients + pass # waiting for gradients - else: - # if no gradient method -> sampler without gradient functionality - self._sampler = self._sampler_factory( - circuits = self._circuit, - parameters = [self._input_params + self._weight_params] - ) - pass - - def close(self): + def close(self) -> None: """ Close sampler/gradient session. """ @@ -103,8 +127,8 @@ def close(self): def set_interpret( self, - interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]], - output_shape: Union[int, Tuple[int, ...]] = None, + interpret: Callable[[int], int| Tuple[int, ...]] | None = None, + output_shape: int | Tuple[int, ...] | None = None ) -> None: """Change 'interpret' and corresponding 'output_shape'. @@ -125,12 +149,15 @@ def set_interpret( self._interpret = interpret if interpret is not None else lambda x: x self.output_shape = self._output_shape - def _compute_output_shape(self, interpret, output_shape) -> Tuple[int, ...]: + def _compute_output_shape( + self, + interpret: Callable[[int], int | Tuple[int, ...]] | None = None, + output_shape: int | Tuple[int, ...] | None = None + ) -> Tuple[int, ...]: """Validate and compute the output shape.""" # this definition is required by mypy output_shape_: Tuple[int, ...] = (-1,) - # todo: move sampling code to the super class if interpret is not None: if output_shape is None: @@ -150,23 +177,30 @@ def _compute_output_shape(self, interpret, output_shape) -> Tuple[int, ...]: "determined as 2^num_qubits." ) - output_shape_ = (2 ** self._circuit.num_qubits,) - - # # final validation - # output_shape_ = self._validate_output_shape(output_shape_) + output_shape_ = (2**self._circuit.num_qubits,) return output_shape_ def forward( - self, - input_data: Optional[Union[List[float], np.ndarray, float]], - weights: Optional[Union[List[float], np.ndarray, float]], + self, + input_data: List[float] | np.ndarray | float | None, + weights: List[float] | np.ndarray | float | None, ) -> np.ndarray: - + """ + Forward pass of the network. Returns the probabilities. + Format depends on the set interpret function. + """ result = self._forward(input_data, weights) return result - def _preprocess(self, input_data, weights): + def _preprocess( + self, + input_data: List[float] | np.ndarray | float | None, + weights: List[float] | np.ndarray | float | None, + ) -> Tuple[List[float], int]: + """ + Pre-processing during forward pass of the network. + """ if len(input_data.shape) == 1: input_data = np.expand_dims(input_data, 0) num_samples = input_data.shape[0] @@ -176,14 +210,16 @@ def _preprocess(self, input_data, weights): parameters = [] for i in range(num_samples): - param_values = [input_data[i,j] for j, input_param in enumerate(self._input_params)] + param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] parameters.append(param_values) return parameters, num_samples def _postprocess(self, num_samples, result): - + """ + Post-processing during forward pass of the network. + """ prob = np.zeros((num_samples, *self._output_shape)) for i in range(num_samples): @@ -193,42 +229,43 @@ def _postprocess(self, num_samples, result): # evaluate probabilities for b, v in counts.items(): - key = (i, int(self._interpret(b))) # type: ignore + key = (i, int(self._interpret(b))) # type: ignore prob[key] += v / shots return prob def _forward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> np.ndarray: - + """ + Forward pass of the network. + """ parameter_values, num_samples = self._preprocess(input_data, weights) # sampler allows batching (gradient doesn't) results = self._sampler([0] * num_samples, parameter_values) - # results = [] - # for sample in range(num_samples): - # result = self._sampler(circuits = self._circuit, - # parameter_values = parameter_values) - # results.append(result) - result = self._postprocess(num_samples, results) return result def backward( - self, - input_data: Optional[Union[List[float], np.ndarray, float]], - weights: Optional[Union[List[float], np.ndarray, float]], + self, + input_data: Optional[Union[List[float], np.ndarray, float]], + weights: Optional[Union[List[float], np.ndarray, float]], ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: - - # result = self._backward(input_data, weights) - # return result - pass + """Backward pass of the network. Returns (None, None) when no gradient is + provided and the corresponding here probability gradients otherwise. + """ + if self._gradient: + return self._backward(input_data, weights) + else: + return None, None def _preprocess_gradient(self, input_data, weights): - + """ + Pre-processing during backward pass of the network. + """ if len(input_data.shape) == 1: input_data = np.expand_dims(input_data, 0) @@ -247,7 +284,9 @@ def _preprocess_gradient(self, input_data, weights): return parameters, num_samples def _postprocess_gradient(self, num_samples, results): - + """ + Post-processing during backward pass of the network. + """ input_grad = np.zeros((num_samples, 1, self._num_inputs)) if self._input_gradients else None weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) @@ -291,30 +330,22 @@ def _backward( self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + """Backward pass of the network. + """ # prepare parameters in the required format parameter_values, num_samples = self._preprocess_gradient(input_data, weights) results = [] for sample in range(num_samples): if self._input_gradients: - result = self._sampler.gradient(parameter_values[sample]) + result = self._gradient(parameter_values[sample]) else: - result = self._sampler.gradient(parameter_values[sample], - partial=self._sampler._circuit.parameters[self._num_inputs:]) + result = self._gradient( + parameter_values[sample], + partial=self._sampler._circuit.parameters[self._num_inputs :], + ) results.append(result) input_grad, weights_grad = self._postprocess_gradient(num_samples, results) - return None , weights_grad # `None` for gradients wrt input data, see TorchConnector - - - - - - - - - - - - + return None, weights_grad # `None` for gradients wrt input data, see TorchConnector diff --git a/test/primitives/test_sampler_qnn.py b/test/primitives/test_sampler_qnn.py index 7a671a098..544f356a2 100644 --- a/test/primitives/test_sampler_qnn.py +++ b/test/primitives/test_sampler_qnn.py @@ -51,7 +51,7 @@ def test_forward_pass(self): interpret=parity, output_shape=output_shape, quantum_instance=self.qi_qasm, - ) + ) inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) weights = algorithm_globals.random.random(circuit_qnn._num_weights) @@ -59,18 +59,16 @@ def test_forward_pass(self): sampler_factory = Sampler with SamplerQNN( - circuit=self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sampler_factory=sampler_factory, - interpret = parity, - output_shape = output_shape, - ) as qnn: - - sampler_qnn_fwd = qnn.forward(inputs, weights) - - np.testing.assert_array_almost_equal(np.asarray(sampler_qnn_fwd), - np.asarray(circuit_qnn_fwd),0.1) - + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sampler_factory=sampler_factory, + interpret=parity, + output_shape=output_shape, + ) as qnn: + sampler_qnn_fwd = qnn.forward(inputs, weights) + np.testing.assert_array_almost_equal( + np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 + ) From d6574d39660a2125ae9adbe06957bb3fb5d4f52f Mon Sep 17 00:00:00 2001 From: ElePT Date: Thu, 14 Jul 2022 13:51:50 +0200 Subject: [PATCH 11/96] Move to neural_networks --- __init__.py | 0 .../neural_networks/__init__.py | 11 +++++++++++ .../sampler_qnn.py | 0 .../primitives/__init__.py | 19 ------------------- 4 files changed, 11 insertions(+), 19 deletions(-) create mode 100644 __init__.py rename qiskit_machine_learning/{primitives => neural_networks}/sampler_qnn.py (100%) delete mode 100644 qiskit_machine_learning/primitives/__init__.py diff --git a/__init__.py b/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/qiskit_machine_learning/neural_networks/__init__.py b/qiskit_machine_learning/neural_networks/__init__.py index f1b86c5c1..2a5794ac5 100644 --- a/qiskit_machine_learning/neural_networks/__init__.py +++ b/qiskit_machine_learning/neural_networks/__init__.py @@ -57,6 +57,15 @@ EffectiveDimension LocalEffectiveDimension +Neural Networks using Primitives +================================ + +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + SamplerQNN + """ from .circuit_qnn import CircuitQNN @@ -65,6 +74,7 @@ from .opflow_qnn import OpflowQNN from .sampling_neural_network import SamplingNeuralNetwork from .two_layer_qnn import TwoLayerQNN +from .sampler_qnn import SamplerQNN __all__ = [ "NeuralNetwork", @@ -74,4 +84,5 @@ "CircuitQNN", "EffectiveDimension", "LocalEffectiveDimension", + "SamplerQNN" ] diff --git a/qiskit_machine_learning/primitives/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py similarity index 100% rename from qiskit_machine_learning/primitives/sampler_qnn.py rename to qiskit_machine_learning/neural_networks/sampler_qnn.py diff --git a/qiskit_machine_learning/primitives/__init__.py b/qiskit_machine_learning/primitives/__init__.py deleted file mode 100644 index 886a6a30c..000000000 --- a/qiskit_machine_learning/primitives/__init__.py +++ /dev/null @@ -1,19 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -""" -Primitives (:mod:`qiskit_machine_learning.primitives`) -=============================================================== - -.. currentmodule:: qiskit_machine_learning.primitives - -""" From fc0f5846097c85995f54af5ff6f430dccca5b691 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 14 Sep 2022 12:11:56 +0200 Subject: [PATCH 12/96] Runnable tests --- .../neural_networks/circuit_qnn.py | 1 - .../neural_networks/sampler_qnn.py | 147 +++++--------- test/neural_networks/test_sampler_qnn.py | 182 ++++++++++++++++++ test/primitives/test_sampler_qnn.py | 74 ------- 4 files changed, 228 insertions(+), 176 deletions(-) create mode 100644 test/neural_networks/test_sampler_qnn.py delete mode 100644 test/primitives/test_sampler_qnn.py diff --git a/qiskit_machine_learning/neural_networks/circuit_qnn.py b/qiskit_machine_learning/neural_networks/circuit_qnn.py index 21d029157..ff64ed1ea 100644 --- a/qiskit_machine_learning/neural_networks/circuit_qnn.py +++ b/qiskit_machine_learning/neural_networks/circuit_qnn.py @@ -490,7 +490,6 @@ def _probability_gradients( num_grad_vars = self._num_inputs + self._num_weights else: num_grad_vars = self._num_weights - # construct gradients for sample in range(num_samples): for i in range(num_grad_vars): diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 3ab503531..6d5cb0905 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -21,23 +21,27 @@ from qiskit import QuantumCircuit from qiskit.circuit import Parameter +from qiskit.primitives import BaseSampler +from qiskit.algorithms.gradients import BaseSamplerGradient from qiskit_machine_learning.exceptions import QiskitMachineLearningError, QiskitError +from .neural_network import NeuralNetwork logger = logging.getLogger(__name__) -class SamplerQNN: +class SamplerQNN(NeuralNetwork): """A Neural Network implementation based on the Sampler primitive.""" def __init__( self, + sampler: BaseSampler, circuit: QuantumCircuit, input_params: List[Parameter] | None = None, weight_params: List[Parameter] | None = None, interpret: Callable[[int], int | Tuple[int, ...]] | None = None, output_shape: int | Tuple[int, ...] | None = None, - sampler_factory: Callable | None = None, - gradient_factory: Callable | str | None = None, + gradient: BaseSamplerGradient | None = None, + input_gradients: bool = False )-> None: """ @@ -57,74 +61,43 @@ def __init__( Raises: QiskitMachineLearningError: Invalid parameter values. """ - - self._circuit = circuit - - self._gradient_factory = gradient_factory - self._sampler_factory = sampler_factory - - self._sampler = None - self._gradient = None + # set sampler --> make property? + self.sampler = sampler + # use given gradient or default + self.gradient = gradient self._input_params = list(input_params or []) self._weight_params = list(weight_params or []) - self.output_shape = None - self._num_inputs = len(self._input_params) - self._num_weights = len(self._weight_params) + # initialize gradient properties + self.input_gradients = input_gradients # TODO - self.num_weights = self._num_weights + # sparse = False --> Hard coded TODO: look into sparse - # the circuit must always have measurements... - # add measurements in case none are given + self._circuit = circuit.copy() if len(self._circuit.clbits) == 0: self._circuit.measure_all() + # self._circuit_transpiled = False TODO: look into transpilation - self._interpret = interpret - self._original_interpret = interpret + # these original values may be re-used when a quantum instance is set, + # but initially it was None + self._original_output_shape = output_shape + self._output_shape = output_shape - # set interpret and compute output shape self.set_interpret(interpret, output_shape) + # next line is required by pylint only + # self._interpret = interpret + self._original_interpret = interpret - # not implemented yet - # self._input_gradients = None - - def __enter__(self): - """ - QNN used with context managers. - """ - self.open() - return self - - def __exit__(self, *exc_info) -> None: - """ - QNN used with context managers. - """ - self.close() - - def open(self) -> None: - """ - Open sampler/gradient session. - """ - # we should delay instantiation of the primitives until they are really required - self._sampler = self._sampler_factory( - circuits=self._circuit, parameters=[self._input_params + self._weight_params] + # init super clas + super().__init__( + len(self._input_params), + len(self._weight_params), + False, # sparse + self._output_shape, + self._input_gradients, ) - if self._gradient_factory is not None: - # if gradient method -> sampler with gradient functionality - # self._gradient = ParamShiftSamplerGradient( - # circuit = self._circuit, - # sampler = self._sampler_factory - # ) - pass # waiting for gradients - - def close(self) -> None: - """ - Close sampler/gradient session. - """ - self._sampler.__exit__() - def set_interpret( self, interpret: Callable[[int], int| Tuple[int, ...]] | None = None, @@ -147,7 +120,7 @@ def set_interpret( # derive target values to be used in computations self._output_shape = self._compute_output_shape(interpret, output_shape) self._interpret = interpret if interpret is not None else lambda x: x - self.output_shape = self._output_shape + # self.output_shape = self._compute_output_shape(self._interpret, output_shape) def _compute_output_shape( self, @@ -181,18 +154,6 @@ def _compute_output_shape( return output_shape_ - def forward( - self, - input_data: List[float] | np.ndarray | float | None, - weights: List[float] | np.ndarray | float | None, - ) -> np.ndarray: - """ - Forward pass of the network. Returns the probabilities. - Format depends on the set interpret function. - """ - result = self._forward(input_data, weights) - return result - def _preprocess( self, input_data: List[float] | np.ndarray | float | None, @@ -223,7 +184,7 @@ def _postprocess(self, num_samples, result): prob = np.zeros((num_samples, *self._output_shape)) for i in range(num_samples): - counts = result.quasi_dists[i] + counts = result[i] print(counts) shots = sum(counts.values()) @@ -242,26 +203,14 @@ def _forward( """ parameter_values, num_samples = self._preprocess(input_data, weights) - # sampler allows batching (gradient doesn't) - results = self._sampler([0] * num_samples, parameter_values) + # sampler allows batching + job = self.sampler.run([self._circuit] * num_samples, parameter_values) + results = job.result().quasi_dists result = self._postprocess(num_samples, results) return result - def backward( - self, - input_data: Optional[Union[List[float], np.ndarray, float]], - weights: Optional[Union[List[float], np.ndarray, float]], - ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: - """Backward pass of the network. Returns (None, None) when no gradient is - provided and the corresponding here probability gradients otherwise. - """ - if self._gradient: - return self._backward(input_data, weights) - else: - return None, None - def _preprocess_gradient(self, input_data, weights): """ Pre-processing during backward pass of the network. @@ -276,7 +225,6 @@ def _preprocess_gradient(self, input_data, weights): parameters = [] for i in range(num_samples): - param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] parameters.append(param_values) @@ -287,7 +235,7 @@ def _postprocess_gradient(self, num_samples, results): """ Post-processing during backward pass of the network. """ - input_grad = np.zeros((num_samples, 1, self._num_inputs)) if self._input_gradients else None + input_grad = np.zeros((num_samples, *self._output_shape, self._num_inputs)) if self._input_gradients else None weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) if self._input_gradients: @@ -298,9 +246,9 @@ def _postprocess_gradient(self, num_samples, results): for sample in range(num_samples): for i in range(num_grad_vars): - grad = results[sample].quasi_dists[i + self._num_inputs] + grad = results.gradients[sample][i] for k in grad.keys(): - val = results[sample].quasi_dists[i + self._num_inputs][k] + val = results.gradients[sample][i][k] # get index for input or weights gradients if self._input_gradients: grad_index = i if i < self._num_inputs else i - self._num_inputs @@ -335,17 +283,14 @@ def _backward( # prepare parameters in the required format parameter_values, num_samples = self._preprocess_gradient(input_data, weights) - results = [] - for sample in range(num_samples): - if self._input_gradients: - result = self._gradient(parameter_values[sample]) - else: - result = self._gradient( - parameter_values[sample], - partial=self._sampler._circuit.parameters[self._num_inputs :], - ) + if self._input_gradients: + job = self.gradient.run([self._circuit] * num_samples, parameter_values) + else: + job = self.gradient.run([self._circuit] * num_samples, parameter_values, + parameters=[self._circuit.parameters[self._num_inputs:]]) + + results = job.result() - results.append(result) input_grad, weights_grad = self._postprocess_gradient(num_samples, results) - return None, weights_grad # `None` for gradients wrt input data, see TorchConnector + return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py new file mode 100644 index 000000000..8fa01c3bd --- /dev/null +++ b/test/neural_networks/test_sampler_qnn.py @@ -0,0 +1,182 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Test Sampler QNN with Terra primitives.""" +import numpy as np +from test import QiskitMachineLearningTestCase + +from qiskit.primitives import Sampler +from qiskit.algorithms.gradients import ParamShiftSamplerGradient, FiniteDiffSamplerGradient +from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap +from qiskit.utils import QuantumInstance, algorithm_globals +from qiskit import Aer +from qiskit.utils import QuantumInstance + +from qiskit_machine_learning.neural_networks import CircuitQNN +from qiskit_machine_learning.neural_networks.sampler_qnn import SamplerQNN + +algorithm_globals.random_seed = 42 +from test.connectors.test_torch import TestTorch +import os + +os.environ['KMP_DUPLICATE_LIB_OK']='True' + +class TestSamplerQNN(QiskitMachineLearningTestCase): + """Sampler QNN Tests.""" + + def setUp(self): + super().setUp() + algorithm_globals.random_seed = 12345 + + # define test circuit + num_qubits = 3 + self.qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) + self.qi_qasm = QuantumInstance(Aer.get_backend("aer_simulator")) + self.sampler = Sampler() + + def test_forward_pass(self): + + parity = lambda x: "{:b}".format(x).count("1") % 2 + output_shape = 2 # this is required in case of a callable with dense output + + circuit_qnn = CircuitQNN( + self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sparse=False, + interpret=parity, + output_shape=output_shape, + quantum_instance=self.qi_qasm, + ) + + sampler_qnn = SamplerQNN( + sampler=self.sampler, + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + interpret=parity, + output_shape=output_shape, + ) + + inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + weights = algorithm_globals.random.random(circuit_qnn._num_weights) + + circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) + sampler_qnn_fwd = sampler_qnn.forward(inputs, weights) + + np.testing.assert_array_almost_equal( + np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 + ) + + def test_backward_pass(self): + + parity = lambda x: "{:b}".format(x).count("1") % 2 + output_shape = 2 # this is required in case of a callable with dense output + from qiskit.opflow import Gradient + circuit_qnn = CircuitQNN( + self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sparse=False, + interpret=parity, + output_shape=output_shape, + quantum_instance=self.qi_qasm, + gradient=Gradient("param_shift"), + ) + + sampler_qnn = SamplerQNN( + sampler=self.sampler, + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + interpret=parity, + output_shape=output_shape, + gradient=ParamShiftSamplerGradient(self.sampler), + ) + + inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + weights = algorithm_globals.random.random(circuit_qnn._num_weights) + + circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) + sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + + print(circuit_qnn_fwd) + print(sampler_qnn_fwd) + np.testing.assert_array_almost_equal( + np.asarray(sampler_qnn_fwd[1]), np.asarray(circuit_qnn_fwd[1]), 0.1 + ) + + def test_input_gradients(self): + + parity = lambda x: "{:b}".format(x).count("1") % 2 + output_shape = 2 # this is required in case of a callable with dense output + from qiskit.opflow import Gradient + circuit_qnn = CircuitQNN( + self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sparse=False, + interpret=parity, + output_shape=output_shape, + quantum_instance=self.qi_qasm, + gradient=Gradient("param_shift"), + input_gradients=True + ) + + sampler_qnn = SamplerQNN( + sampler=self.sampler, + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + interpret=parity, + output_shape=output_shape, + gradient=ParamShiftSamplerGradient(self.sampler), + input_gradients=True + + ) + + inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + weights = algorithm_globals.random.random(circuit_qnn._num_weights) + + circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) + sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + + print(circuit_qnn_fwd) + print(sampler_qnn_fwd) + np.testing.assert_array_almost_equal( + np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 + ) + + from qiskit_machine_learning.connectors import TorchConnector + import torch + + model = TorchConnector(sampler_qnn) + func = TorchConnector._TorchNNFunction.apply # (input, weights, qnn) + input_data = ( + torch.randn( + model.neural_network.num_inputs, + dtype=torch.double, + requires_grad=True, + ), + torch.randn( + model.neural_network.num_weights, + dtype=torch.double, + requires_grad=True, + ), + model.neural_network, + False, + ) + test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) # type: ignore + self.assertTrue(test) + + # def test_torch_connector(self): + # from qiskit_machine_learning.connectors import TorchConnector diff --git a/test/primitives/test_sampler_qnn.py b/test/primitives/test_sampler_qnn.py deleted file mode 100644 index 544f356a2..000000000 --- a/test/primitives/test_sampler_qnn.py +++ /dev/null @@ -1,74 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -"""Test Sampler QNN with Terra primitives.""" -import numpy as np -from test import QiskitMachineLearningTestCase - -from qiskit.primitives import Sampler -from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap -from qiskit.utils import QuantumInstance, algorithm_globals -from qiskit import Aer -from qiskit.utils import QuantumInstance - -from qiskit_machine_learning.neural_networks import CircuitQNN -from qiskit_machine_learning.primitives.sampler_qnn import SamplerQNN - -algorithm_globals.random_seed = 42 - - -class TestSamplerQNN(QiskitMachineLearningTestCase): - """Sampler QNN Tests.""" - - def setUp(self): - super().setUp() - algorithm_globals.random_seed = 12345 - - # define test circuit - num_qubits = 3 - self.qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) - self.qi_qasm = QuantumInstance(Aer.get_backend("aer_simulator"), shots=10) - - def test_forward_pass(self): - - parity = lambda x: "{:b}".format(x).count("1") % 2 - output_shape = 2 # this is required in case of a callable with dense output - - circuit_qnn = CircuitQNN( - self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sparse=False, - interpret=parity, - output_shape=output_shape, - quantum_instance=self.qi_qasm, - ) - - inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - weights = algorithm_globals.random.random(circuit_qnn._num_weights) - circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) - - sampler_factory = Sampler - with SamplerQNN( - circuit=self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sampler_factory=sampler_factory, - interpret=parity, - output_shape=output_shape, - ) as qnn: - - sampler_qnn_fwd = qnn.forward(inputs, weights) - - np.testing.assert_array_almost_equal( - np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 - ) From 9c11a3c0f25011a5d805bd4005a60909b906fac2 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 14 Sep 2022 20:22:31 +0900 Subject: [PATCH 13/96] wip estimator qnn --- .../neural_networks/estimator_qnn.py | 315 ++++++++++++++++++ 1 file changed, 315 insertions(+) create mode 100644 qiskit_machine_learning/neural_networks/estimator_qnn.py diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py new file mode 100644 index 000000000..aa96cbbaa --- /dev/null +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -0,0 +1,315 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2020, 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""An Opflow Quantum Neural Network that allows to use a parametrized opflow object as a +neural network.""" +import logging +from typing import List, Optional, Union, Tuple, Dict + +import numpy as np +from qiskit.circuit import Parameter +from qiskit.opflow import ( + Gradient, + CircuitSampler, + ListOp, + OperatorBase, + ExpectationBase, + OpflowError, + ComposedOp, +) +from qiskit.primitive import BaseEstimator +from qiskit.providers import Backend +from qiskit.utils import QuantumInstance +from qiskit.utils.backend_utils import is_aer_provider +import qiskit_machine_learning.optionals as _optionals +from .neural_network import NeuralNetwork +from ..exceptions import QiskitMachineLearningError, QiskitError + +if _optionals.HAS_SPARSE: + # pylint: disable=import-error + from sparse import SparseArray +else: + + class SparseArray: # type: ignore + """Empty SparseArray class + Replacement if sparse.SparseArray is not present. + """ + + pass + + +logger = logging.getLogger(__name__) + + +class EstimatorQNN(NeuralNetwork): + """A Neural Network implementation based on the Sampler primitive.""" + + def __init__( + self, + operator: OperatorBase, + input_params: Optional[List[Parameter]] = None, + weight_params: Optional[List[Parameter]] = None, + exp_val: Optional[ExpectationBase] = None, + gradient: Optional[Gradient] = None, + quantum_instance: Optional[Union[QuantumInstance, Backend]] = None, + input_gradients: bool = False, + estimator: BaseEstimator = None, + ): + """ + Args: + operator: The parametrized operator that represents the neural network. + input_params: The operator parameters that correspond to the input of the network. + weight_params: The operator parameters that correspond to the trainable weights. + exp_val: The Expected Value converter to be used for the operator. + gradient: The Gradient converter to be used for the operator's backward pass. + quantum_instance: The quantum instance to evaluate the network. + input_gradients: Determines whether to compute gradients with respect to input data. + Note that this parameter is ``False`` by default, and must be explicitly set to + ``True`` for a proper gradient computation when using ``TorchConnector``. + """ + self._input_params = list(input_params) or [] + self._weight_params = list(weight_params) or [] + self._set_quantum_instance(quantum_instance) + self._operator = operator + self._forward_operator = exp_val.convert(operator) if exp_val else operator + self._gradient = gradient + + # initialize gradient properties + self.input_gradients = input_gradients + + output_shape = self._compute_output_shape(operator) + super().__init__( + len(self._input_params), + len(self._weight_params), + sparse=False, + output_shape=output_shape, + input_gradients=input_gradients, + ) + + def _construct_gradient_operator(self): + if self._gradient_operator_constructed: + return + + self._gradient_operator: OperatorBase = None + try: + gradient = self._gradient or Gradient() + if self._input_gradients: + params = self._input_params + self._weight_params + else: + params = self._weight_params + + self._gradient_operator = gradient.convert(self._operator, params) + except (ValueError, TypeError, OpflowError, QiskitError): + logger.warning("Cannot compute gradient operator! Continuing without gradients!") + + self._gradient_operator_constructed = True + + def _compute_output_shape(self, op: OperatorBase) -> Tuple[int, ...]: + """Determines the output shape of a given operator.""" + # TODO: the whole method should eventually be moved to opflow and rewritten in a better way. + # if the operator is a composed one, then we only need to look at the first element of it. + if isinstance(op, ComposedOp): + return self._compute_output_shape(op.oplist[0].primitive) + # this "if" statement is on purpose, to prevent sub-classes. + # pylint:disable=unidiomatic-typecheck + if type(op) == ListOp: + shapes = [self._compute_output_shape(op_) for op_ in op.oplist] + if not np.all([shape == shapes[0] for shape in shapes]): + raise QiskitMachineLearningError( + "Only supports ListOps with children that return the same shape." + ) + if shapes[0] == (1,): + out = op.combo_fn(np.zeros((len(op.oplist)))) + else: + out = op.combo_fn(np.zeros((len(op.oplist), *shapes[0]))) + return out.shape + else: + return (1,) + + @property + def operator(self): + """Returns the underlying operator of this QNN.""" + return self._operator + + @property + def input_gradients(self) -> bool: + """Returns whether gradients with respect to input data are computed by this neural network + in the ``backward`` method or not. By default such gradients are not computed.""" + return self._input_gradients + + @input_gradients.setter + def input_gradients(self, input_gradients: bool) -> None: + """Turn on/off computation of gradients with respect to input data.""" + self._input_gradients = input_gradients + + # reset gradient operator + self._gradient_operator = None + self._gradient_operator_constructed = False + + @property + def quantum_instance(self) -> QuantumInstance: + """Returns the quantum instance to evaluate the operator.""" + return self._quantum_instance + + @quantum_instance.setter + def quantum_instance(self, quantum_instance: Optional[Union[QuantumInstance, Backend]]) -> None: + """Sets the quantum instance to evaluate the operator.""" + self._set_quantum_instance(quantum_instance) + + def _set_quantum_instance( + self, quantum_instance: Optional[Union[QuantumInstance, Backend]] + ) -> None: + """ + Internal method to set a quantum instance and compute/initialize a sampler. + + Args: + quantum_instance: A quantum instance to set. + + Returns: + None. + """ + + if isinstance(quantum_instance, Backend): + quantum_instance = QuantumInstance(quantum_instance) + self._quantum_instance = quantum_instance + + if quantum_instance is not None: + self._circuit_sampler = CircuitSampler( + self._quantum_instance, + param_qobj=is_aer_provider(self._quantum_instance.backend), + caching="all", + ) + else: + self._circuit_sampler = None + + def _forward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> Union[np.ndarray, SparseArray]: + # combine parameter dictionary + # take i-th column as values for the i-th param in a batch + param_values = {p: input_data[:, i].tolist() for i, p in enumerate(self._input_params)} + param_values.update( + {p: [weights[i]] * input_data.shape[0] for i, p in enumerate(self._weight_params)} + ) + + # evaluate operator + if self._circuit_sampler: + op = self._circuit_sampler.convert(self._forward_operator, param_values) + result = np.real(op.eval()) + else: + op = self._forward_operator.bind_parameters(param_values) + result = np.real(op.eval()) + result = np.array(result) + return result.reshape(-1, *self._output_shape) + + def _backward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> Tuple[Optional[Union[np.ndarray, SparseArray]], Optional[Union[np.ndarray, SparseArray]],]: + + self._construct_gradient_operator() + + # check whether gradient circuit could be constructed + if self._gradient_operator is None: + return None, None + + num_samples = input_data.shape[0] + if self._input_gradients: + num_params = self._num_inputs + self._num_weights + else: + num_params = self._num_weights + + param_values = { + input_param: input_data[:, j] for j, input_param in enumerate(self._input_params) + } + param_values.update( + { + weight_param: np.full(num_samples, weights[j]) + for j, weight_param in enumerate(self._weight_params) + } + ) + + if self._circuit_sampler: + converted_op = self._circuit_sampler.convert(self._gradient_operator, param_values) + # if statement is a workaround for https://github.com/Qiskit/qiskit-terra/issues/7608 + if len(converted_op.parameters) > 0: + # rebind the leftover parameters and evaluate the gradient + grad = self._evaluate_operator(converted_op, num_samples, param_values) + else: + # all parameters are bound by CircuitSampler, so we evaluate the operator directly + grad = np.asarray(converted_op.eval()) + else: + # we evaluate gradient operator for each sample separately, so we create a list of operators. + grad = self._evaluate_operator( + [self._gradient_operator] * num_samples, num_samples, param_values + ) + + grad = np.real(grad) + + # this is another workaround to fix output shape of the invocation result of CircuitSampler + if self._output_shape == (1,): + # at least 3 dimensions: batch, output, num_parameters, but in this case we don't have + # output dimension, so we add a dimension that corresponds to the output + grad = grad.reshape((num_samples, 1, num_params)) + else: + # swap last axis that corresponds to parameters and axes correspond to the output shape + last_axis = len(grad.shape) - 1 + grad = grad.transpose([0, last_axis, *(range(1, last_axis))]) + + # split into and return input and weights gradients + if self._input_gradients: + input_grad = grad[:, :, : self._num_inputs].reshape( + -1, *self._output_shape, self._num_inputs + ) + + weights_grad = grad[:, :, self._num_inputs :].reshape( + -1, *self._output_shape, self._num_weights + ) + else: + input_grad = None + weights_grad = grad.reshape(-1, *self._output_shape, self._num_weights) + + return input_grad, weights_grad + + def _evaluate_operator( + self, + operator: Union[OperatorBase, List[OperatorBase]], + num_samples: int, + param_values: Dict[Parameter, np.ndarray], + ) -> np.ndarray: + """ + Evaluates an operator or a list of operators for the samples in the dataset. If an operator + is passed then it is considered as an iterable that has `num_samples` elements. Usually such + operators are obtained as an output from `CircuitSampler`. If a list of operators is passed + then each operator in this list is evaluated with a set of values/parameters corresponding + to the sample index in the `param_values` as the operator in the list. + + Args: + operator: operator or list of operators to evaluate. + num_samples: a total number of samples + param_values: parameter values to use for operator evaluation. + + Returns: + the result of operator evaluation as an array. + """ + # create an list of parameter bindings, each element corresponds to a sample in the dataset + param_bindings = [ + {param: param_values[i] for param, param_values in param_values.items()} + for i in range(num_samples) + ] + + grad = [] + # iterate over gradient vectors and bind the correct parameters + for oper_i, param_i in zip(operator, param_bindings): + # bind or re-bind remaining values and evaluate the gradient + grad.append(oper_i.bind_parameters(param_i).eval()) + + return np.asarray(grad) From e9ff1ca73ab165b88e3ce13252f78a38d73d451b Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 16 Sep 2022 14:36:27 +0900 Subject: [PATCH 14/96] wip --- .../neural_networks/estimator_qnn.py | 421 ++++++++++-------- 1 file changed, 247 insertions(+), 174 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index aa96cbbaa..17dad2ba8 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -16,7 +16,8 @@ from typing import List, Optional, Union, Tuple, Dict import numpy as np -from qiskit.circuit import Parameter +from qiskit.circuit import Parameter, QuantumCircuit, ParameterExpression +from qiskit.algorithms.gradients import BaseEstimatorGradient from qiskit.opflow import ( Gradient, CircuitSampler, @@ -26,7 +27,7 @@ OpflowError, ComposedOp, ) -from qiskit.primitive import BaseEstimator +from qiskit.primitives import BaseEstimator from qiskit.providers import Backend from qiskit.utils import QuantumInstance from qiskit.utils.backend_utils import is_aer_provider @@ -34,6 +35,11 @@ from .neural_network import NeuralNetwork from ..exceptions import QiskitMachineLearningError, QiskitError +from qiskit.opflow import PauliSumOp +from qiskit.quantum_info import SparsePauliOp, Statevector +from qiskit.quantum_info.operators.base_operator import BaseOperator +from qiskit.quantum_info.operators.symplectic.base_pauli import BasePauli + if _optionals.HAS_SPARSE: # pylint: disable=import-error from sparse import SparseArray @@ -55,14 +61,13 @@ class EstimatorQNN(NeuralNetwork): def __init__( self, + estimator: BaseEstimator, + circuit: QuantumCircuit, operator: OperatorBase, input_params: Optional[List[Parameter]] = None, weight_params: Optional[List[Parameter]] = None, - exp_val: Optional[ExpectationBase] = None, - gradient: Optional[Gradient] = None, - quantum_instance: Optional[Union[QuantumInstance, Backend]] = None, + gradient: Optional[BaseEstimatorGradient] = None, input_gradients: bool = False, - estimator: BaseEstimator = None, ): """ Args: @@ -76,11 +81,11 @@ def __init__( Note that this parameter is ``False`` by default, and must be explicitly set to ``True`` for a proper gradient computation when using ``TorchConnector``. """ + self._estimator = estimator + self._circuit = circuit + self._operator = operator self._input_params = list(input_params) or [] self._weight_params = list(weight_params) or [] - self._set_quantum_instance(quantum_instance) - self._operator = operator - self._forward_operator = exp_val.convert(operator) if exp_val else operator self._gradient = gradient # initialize gradient properties @@ -95,26 +100,31 @@ def __init__( input_gradients=input_gradients, ) - def _construct_gradient_operator(self): - if self._gradient_operator_constructed: - return + @property + def operator(self): + """Returns the underlying operator of this QNN.""" + return self._operator - self._gradient_operator: OperatorBase = None - try: - gradient = self._gradient or Gradient() - if self._input_gradients: - params = self._input_params + self._weight_params - else: - params = self._weight_params + @property + def input_gradients(self) -> bool: + """Returns whether gradients with respect to input data are computed by this neural network + in the ``backward`` method or not. By default such gradients are not computed.""" + return self._input_gradients - self._gradient_operator = gradient.convert(self._operator, params) - except (ValueError, TypeError, OpflowError, QiskitError): - logger.warning("Cannot compute gradient operator! Continuing without gradients!") + @input_gradients.setter + def input_gradients(self, input_gradients: bool) -> None: + """Turn on/off computation of gradients with respect to input data.""" + self._input_gradients = input_gradients - self._gradient_operator_constructed = True + # reset gradient operator + self._gradient_operator = None + self._gradient_operator_constructed = False def _compute_output_shape(self, op: OperatorBase) -> Tuple[int, ...]: """Determines the output shape of a given operator.""" + + + # TODO: the whole method should eventually be moved to opflow and rewritten in a better way. # if the operator is a composed one, then we only need to look at the first element of it. if isinstance(op, ComposedOp): @@ -135,181 +145,244 @@ def _compute_output_shape(self, op: OperatorBase) -> Tuple[int, ...]: else: return (1,) - @property - def operator(self): - """Returns the underlying operator of this QNN.""" - return self._operator - - @property - def input_gradients(self) -> bool: - """Returns whether gradients with respect to input data are computed by this neural network - in the ``backward`` method or not. By default such gradients are not computed.""" - return self._input_gradients - - @input_gradients.setter - def input_gradients(self, input_gradients: bool) -> None: - """Turn on/off computation of gradients with respect to input data.""" - self._input_gradients = input_gradients - - # reset gradient operator - self._gradient_operator = None - self._gradient_operator_constructed = False - - @property - def quantum_instance(self) -> QuantumInstance: - """Returns the quantum instance to evaluate the operator.""" - return self._quantum_instance - - @quantum_instance.setter - def quantum_instance(self, quantum_instance: Optional[Union[QuantumInstance, Backend]]) -> None: - """Sets the quantum instance to evaluate the operator.""" - self._set_quantum_instance(quantum_instance) - - def _set_quantum_instance( - self, quantum_instance: Optional[Union[QuantumInstance, Backend]] - ) -> None: - """ - Internal method to set a quantum instance and compute/initialize a sampler. + def _preprocess(self, input_data, weights): + """Pre-processing during forward pass of the network.""" + if len(input_data.shape) == 1: + input_data = np.expand_dims(input_data, 0) + num_samples = input_data.shape[0] + # quick fix for 0 inputs + if num_samples == 0: + num_samples = 1 - Args: - quantum_instance: A quantum instance to set. + parameter_values = [] + for i in range(num_samples): + param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] + param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] + parameter_values.append(param_values) - Returns: - None. - """ + return parameter_values, num_samples - if isinstance(quantum_instance, Backend): - quantum_instance = QuantumInstance(quantum_instance) - self._quantum_instance = quantum_instance + def _postprocess(self, num_samples, results): + """Post-processing during forward pass of the network.""" + res = np.zeros((num_samples, 1)) + for i in range(num_samples): + res[i, 0] = results.values[i] + return res - if quantum_instance is not None: - self._circuit_sampler = CircuitSampler( - self._quantum_instance, - param_qobj=is_aer_provider(self._quantum_instance.backend), - caching="all", - ) - else: - self._circuit_sampler = None def _forward( self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> Union[np.ndarray, SparseArray]: # combine parameter dictionary # take i-th column as values for the i-th param in a batch - param_values = {p: input_data[:, i].tolist() for i, p in enumerate(self._input_params)} - param_values.update( - {p: [weights[i]] * input_data.shape[0] for i, p in enumerate(self._weight_params)} - ) + parameter_values, num_samples = self._preprocess(input_data, weights) - # evaluate operator - if self._circuit_sampler: - op = self._circuit_sampler.convert(self._forward_operator, param_values) - result = np.real(op.eval()) - else: - op = self._forward_operator.bind_parameters(param_values) - result = np.real(op.eval()) - result = np.array(result) - return result.reshape(-1, *self._output_shape) + print(f'parameter_values: {parameter_values}') - def _backward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - ) -> Tuple[Optional[Union[np.ndarray, SparseArray]], Optional[Union[np.ndarray, SparseArray]],]: + job = self._estimator.run([self._circuit]*num_samples, [self._operator]*num_samples, parameter_values) + results = job.result() + return self._postprocess(num_samples, results) - self._construct_gradient_operator() - # check whether gradient circuit could be constructed - if self._gradient_operator is None: - return None, None + # def _preprocess_gradient(self, input_data, weights): + # """ + # Pre-processing during backward pass of the network. + # """ + # if len(input_data.shape) == 1: + # input_data = np.expand_dims(input_data, 0) - num_samples = input_data.shape[0] - if self._input_gradients: - num_params = self._num_inputs + self._num_weights - else: - num_params = self._num_weights - - param_values = { - input_param: input_data[:, j] for j, input_param in enumerate(self._input_params) - } - param_values.update( - { - weight_param: np.full(num_samples, weights[j]) - for j, weight_param in enumerate(self._weight_params) - } - ) + # num_samples = input_data.shape[0] + # # quick fix for 0 inputs + # if num_samples == 0: + # num_samples = 1 - if self._circuit_sampler: - converted_op = self._circuit_sampler.convert(self._gradient_operator, param_values) - # if statement is a workaround for https://github.com/Qiskit/qiskit-terra/issues/7608 - if len(converted_op.parameters) > 0: - # rebind the leftover parameters and evaluate the gradient - grad = self._evaluate_operator(converted_op, num_samples, param_values) - else: - # all parameters are bound by CircuitSampler, so we evaluate the operator directly - grad = np.asarray(converted_op.eval()) - else: - # we evaluate gradient operator for each sample separately, so we create a list of operators. - grad = self._evaluate_operator( - [self._gradient_operator] * num_samples, num_samples, param_values - ) + # parameters = [] + # for i in range(num_samples): + # param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] + # param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] + # parameters.append(param_values) - grad = np.real(grad) + # return parameters, num_samples - # this is another workaround to fix output shape of the invocation result of CircuitSampler - if self._output_shape == (1,): - # at least 3 dimensions: batch, output, num_parameters, but in this case we don't have - # output dimension, so we add a dimension that corresponds to the output - grad = grad.reshape((num_samples, 1, num_params)) - else: - # swap last axis that corresponds to parameters and axes correspond to the output shape - last_axis = len(grad.shape) - 1 - grad = grad.transpose([0, last_axis, *(range(1, last_axis))]) + def _postprocess_gradient(self, num_samples, results): + """ + Post-processing during backward pass of the network. + """ + input_grad = np.zeros((num_samples, *self._output_shape, self._num_inputs)) if self._input_gradients else None + weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) - # split into and return input and weights gradients if self._input_gradients: - input_grad = grad[:, :, : self._num_inputs].reshape( - -1, *self._output_shape, self._num_inputs - ) - - weights_grad = grad[:, :, self._num_inputs :].reshape( - -1, *self._output_shape, self._num_weights - ) + num_grad_vars = self._num_inputs + self._num_weights else: - input_grad = None - weights_grad = grad.reshape(-1, *self._output_shape, self._num_weights) + num_grad_vars = self._num_weights + + for sample in range(num_samples): + for i in range(num_grad_vars): + if self._input_gradients: + if i < self._num_inputs: + input_grad[sample, 0, i] = results.values[sample][i] + else: + weights_grad[sample, 0, i - self._num_inputs] = results.values[sample][i] + else: + weights_grad[sample, 0, i] = results.values[sample][i] return input_grad, weights_grad - def _evaluate_operator( - self, - operator: Union[OperatorBase, List[OperatorBase]], - num_samples: int, - param_values: Dict[Parameter, np.ndarray], - ) -> np.ndarray: + def _backward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + + """Backward pass of the network. """ - Evaluates an operator or a list of operators for the samples in the dataset. If an operator - is passed then it is considered as an iterable that has `num_samples` elements. Usually such - operators are obtained as an output from `CircuitSampler`. If a list of operators is passed - then each operator in this list is evaluated with a set of values/parameters corresponding - to the sample index in the `param_values` as the operator in the list. + # prepare parameters in the required format + parameter_values, num_samples = self._preprocess(input_data, weights) + print(parameter_values) + if self._input_gradients: + job = self._gradient.run([self._circuit]*num_samples, [self._operator]*num_samples, parameter_values) + else: + job = self._gradient.run([self._circuit]*num_samples, [self._operator]*num_samples, parameter_values, + parameters=[self._circuit.parameters[self._num_inputs:]] *num_samples) - Args: - operator: operator or list of operators to evaluate. - num_samples: a total number of samples - param_values: parameter values to use for operator evaluation. + results = job.result() + print(results) - Returns: - the result of operator evaluation as an array. - """ - # create an list of parameter bindings, each element corresponds to a sample in the dataset - param_bindings = [ - {param: param_values[i] for param, param_values in param_values.items()} - for i in range(num_samples) - ] - - grad = [] - # iterate over gradient vectors and bind the correct parameters - for oper_i, param_i in zip(operator, param_bindings): - # bind or re-bind remaining values and evaluate the gradient - grad.append(oper_i.bind_parameters(param_i).eval()) - - return np.asarray(grad) + # input_grad, weights_grad = self._postprocess_gradient(num_samples, results) + + # return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector + +def _init_observable(observable: BaseOperator | PauliSumOp) -> SparsePauliOp: + """Initialize observable by converting the input to a :class:`~qiskit.quantum_info.SparsePauliOp`. + + Args: + observable: The observable. + + Returns: + The observable as :class:`~qiskit.quantum_info.SparsePauliOp`. + + Raises: + TypeError: If the observable is a :class:`~qiskit.opflow.PauliSumOp` and has a parameterized + coefficient. + """ + if isinstance(observable, SparsePauliOp): + return observable + elif isinstance(observable, PauliSumOp): + if isinstance(observable.coeff, ParameterExpression): + raise TypeError( + f"Observable must have numerical coefficient, not {type(observable.coeff)}." + ) + return observable.coeff * observable.primitive + elif isinstance(observable, BasePauli): + return SparsePauliOp(observable) + elif isinstance(observable, BaseOperator): + return SparsePauliOp.from_operator(observable) + elif isinstance(observable, ListOp): + #TODO: ListOP? or simply use list of operators + pass + else: + return SparsePauliOp(observable) + + + + + # def _backward( + # self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + # ) -> Tuple[Optional[Union[np.ndarray, SparseArray]], Optional[Union[np.ndarray, SparseArray]],]: + + # self._construct_gradient_operator() + + # # check whether gradient circuit could be constructed + # if self._gradient_operator is None: + # return None, None + + # num_samples = input_data.shape[0] + # if self._input_gradients: + # num_params = self._num_inputs + self._num_weights + # else: + # num_params = self._num_weights + + # param_values = { + # input_param: input_data[:, j] for j, input_param in enumerate(self._input_params) + # } + # param_values.update( + # { + # weight_param: np.full(num_samples, weights[j]) + # for j, weight_param in enumerate(self._weight_params) + # } + # ) + + # if self._circuit_sampler: + # converted_op = self._circuit_sampler.convert(self._gradient_operator, param_values) + # # if statement is a workaround for https://github.com/Qiskit/qiskit-terra/issues/7608 + # if len(converted_op.parameters) > 0: + # # rebind the leftover parameters and evaluate the gradient + # grad = self._evaluate_operator(converted_op, num_samples, param_values) + # else: + # # all parameters are bound by CircuitSampler, so we evaluate the operator directly + # grad = np.asarray(converted_op.eval()) + # else: + # # we evaluate gradient operator for each sample separately, so we create a list of operators. + # grad = self._evaluate_operator( + # [self._gradient_operator] * num_samples, num_samples, param_values + # ) + + # grad = np.real(grad) + + # # this is another workaround to fix output shape of the invocation result of CircuitSampler + # if self._output_shape == (1,): + # # at least 3 dimensions: batch, output, num_parameters, but in this case we don't have + # # output dimension, so we add a dimension that corresponds to the output + # grad = grad.reshape((num_samples, 1, num_params)) + # else: + # # swap last axis that corresponds to parameters and axes correspond to the output shape + # last_axis = len(grad.shape) - 1 + # grad = grad.transpose([0, last_axis, *(range(1, last_axis))]) + + # # split into and return input and weights gradients + # if self._input_gradients: + # input_grad = grad[:, :, : self._num_inputs].reshape( + # -1, *self._output_shape, self._num_inputs + # ) + + # weights_grad = grad[:, :, self._num_inputs :].reshape( + # -1, *self._output_shape, self._num_weights + # ) + # else: + # input_grad = None + # weights_grad = grad.reshape(-1, *self._output_shape, self._num_weights) + + # return input_grad, weights_grad + + # def _evaluate_operator( + # self, + # operator: Union[OperatorBase, List[OperatorBase]], + # num_samples: int, + # param_values: Dict[Parameter, np.ndarray], + # ) -> np.ndarray: + # """ + # Evaluates an operator or a list of operators for the samples in the dataset. If an operator + # is passed then it is considered as an iterable that has `num_samples` elements. Usually such + # operators are obtained as an output from `CircuitSampler`. If a list of operators is passed + # then each operator in this list is evaluated with a set of values/parameters corresponding + # to the sample index in the `param_values` as the operator in the list. + + # Args: + # operator: operator or list of operators to evaluate. + # num_samples: a total number of samples + # param_values: parameter values to use for operator evaluation. + + # Returns: + # the result of operator evaluation as an array. + # """ + # # create an list of parameter bindings, each element corresponds to a sample in the dataset + # param_bindings = [ + # {param: param_values[i] for param, param_values in param_values.items()} + # for i in range(num_samples) + # ] + + # grad = [] + # # iterate over gradient vectors and bind the correct parameters + # for oper_i, param_i in zip(operator, param_bindings): + # # bind or re-bind remaining values and evaluate the gradient + # grad.append(oper_i.bind_parameters(param_i).eval()) + + # return np.asarray(grad) From 72dbe9ab10df462de6ee95f017b2adc3776c3f30 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 21 Sep 2022 17:40:43 +0900 Subject: [PATCH 15/96] added estimator qnn --- .../neural_networks/estimator_qnn.py | 324 ++++-------------- .../add-estimator-qnn-270b31662988bef9.yaml | 16 + 2 files changed, 92 insertions(+), 248 deletions(-) create mode 100644 releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 17dad2ba8..d6494d2f7 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -13,32 +13,18 @@ """An Opflow Quantum Neural Network that allows to use a parametrized opflow object as a neural network.""" import logging -from typing import List, Optional, Union, Tuple, Dict +from typing import Optional, Sequence, Tuple, Union import numpy as np -from qiskit.circuit import Parameter, QuantumCircuit, ParameterExpression from qiskit.algorithms.gradients import BaseEstimatorGradient -from qiskit.opflow import ( - Gradient, - CircuitSampler, - ListOp, - OperatorBase, - ExpectationBase, - OpflowError, - ComposedOp, -) +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.opflow import PauliSumOp from qiskit.primitives import BaseEstimator -from qiskit.providers import Backend -from qiskit.utils import QuantumInstance -from qiskit.utils.backend_utils import is_aer_provider +from qiskit.quantum_info.operators.base_operator import BaseOperator + import qiskit_machine_learning.optionals as _optionals -from .neural_network import NeuralNetwork -from ..exceptions import QiskitMachineLearningError, QiskitError -from qiskit.opflow import PauliSumOp -from qiskit.quantum_info import SparsePauliOp, Statevector -from qiskit.quantum_info.operators.base_operator import BaseOperator -from qiskit.quantum_info.operators.symplectic.base_pauli import BasePauli +from .neural_network import NeuralNetwork if _optionals.HAS_SPARSE: # pylint: disable=import-error @@ -63,9 +49,9 @@ def __init__( self, estimator: BaseEstimator, circuit: QuantumCircuit, - operator: OperatorBase, - input_params: Optional[List[Parameter]] = None, - weight_params: Optional[List[Parameter]] = None, + observables: Sequence[Union[BaseOperator, PauliSumOp]], + input_params: Optional[Sequence[Parameter]] = None, + weight_params: Optional[Sequence[Parameter]] = None, gradient: Optional[BaseEstimatorGradient] = None, input_gradients: bool = False, ): @@ -83,27 +69,26 @@ def __init__( """ self._estimator = estimator self._circuit = circuit - self._operator = operator + self._observables = observables self._input_params = list(input_params) or [] self._weight_params = list(weight_params) or [] self._gradient = gradient - # initialize gradient properties self.input_gradients = input_gradients - output_shape = self._compute_output_shape(operator) super().__init__( len(self._input_params), len(self._weight_params), sparse=False, - output_shape=output_shape, + output_shape=len(observables), input_gradients=input_gradients, ) + print(self.output_shape[0]) @property def operator(self): """Returns the underlying operator of this QNN.""" - return self._operator + return self._observables @property def input_gradients(self) -> bool: @@ -116,35 +101,6 @@ def input_gradients(self, input_gradients: bool) -> None: """Turn on/off computation of gradients with respect to input data.""" self._input_gradients = input_gradients - # reset gradient operator - self._gradient_operator = None - self._gradient_operator_constructed = False - - def _compute_output_shape(self, op: OperatorBase) -> Tuple[int, ...]: - """Determines the output shape of a given operator.""" - - - - # TODO: the whole method should eventually be moved to opflow and rewritten in a better way. - # if the operator is a composed one, then we only need to look at the first element of it. - if isinstance(op, ComposedOp): - return self._compute_output_shape(op.oplist[0].primitive) - # this "if" statement is on purpose, to prevent sub-classes. - # pylint:disable=unidiomatic-typecheck - if type(op) == ListOp: - shapes = [self._compute_output_shape(op_) for op_ in op.oplist] - if not np.all([shape == shapes[0] for shape in shapes]): - raise QiskitMachineLearningError( - "Only supports ListOps with children that return the same shape." - ) - if shapes[0] == (1,): - out = op.combo_fn(np.zeros((len(op.oplist)))) - else: - out = op.combo_fn(np.zeros((len(op.oplist), *shapes[0]))) - return out.shape - else: - return (1,) - def _preprocess(self, input_data, weights): """Pre-processing during forward pass of the network.""" if len(input_data.shape) == 1: @@ -162,69 +118,68 @@ def _preprocess(self, input_data, weights): return parameter_values, num_samples - def _postprocess(self, num_samples, results): + def _forward_postprocess(self, num_samples, results): """Post-processing during forward pass of the network.""" - res = np.zeros((num_samples, 1)) + res = np.zeros((num_samples, *self._output_shape)) for i in range(num_samples): - res[i, 0] = results.values[i] + for j in range(self.output_shape[0]): + res[i, j] = results.values[i * self.output_shape[0] + j] return res - def _forward( self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> Union[np.ndarray, SparseArray]: # combine parameter dictionary # take i-th column as values for the i-th param in a batch - parameter_values, num_samples = self._preprocess(input_data, weights) - - print(f'parameter_values: {parameter_values}') - - job = self._estimator.run([self._circuit]*num_samples, [self._operator]*num_samples, parameter_values) + parameter_values_, num_samples = self._preprocess(input_data, weights) + parameter_values = [ + param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) + ] + # print(f"parameter_values_: {parameter_values_}") + # print(f"parameter_values : {parameter_values}") + # print(self._observables * num_samples) + job = self._estimator.run( + [self._circuit] * num_samples * self.output_shape[0], + self._observables * num_samples, + parameter_values, + ) results = job.result() - return self._postprocess(num_samples, results) - - - # def _preprocess_gradient(self, input_data, weights): - # """ - # Pre-processing during backward pass of the network. - # """ - # if len(input_data.shape) == 1: - # input_data = np.expand_dims(input_data, 0) - - # num_samples = input_data.shape[0] - # # quick fix for 0 inputs - # if num_samples == 0: - # num_samples = 1 - - # parameters = [] - # for i in range(num_samples): - # param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] - # param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] - # parameters.append(param_values) - - # return parameters, num_samples + print(results) + return self._forward_postprocess(num_samples, results) - def _postprocess_gradient(self, num_samples, results): + def _backward_postprocess(self, num_samples, results): """ Post-processing during backward pass of the network. """ - input_grad = np.zeros((num_samples, *self._output_shape, self._num_inputs)) if self._input_gradients else None - weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) + print(f"self._output_shape {self._output_shape}") + input_grad = ( + np.zeros((num_samples, *self.output_shape, self._num_inputs)) + if self._input_gradients + else None + ) + weights_grad = np.zeros((num_samples, *self.output_shape, self._num_weights)) + + print(f"input_grad {input_grad}") + print(f"weights_grad {weights_grad}") if self._input_gradients: num_grad_vars = self._num_inputs + self._num_weights else: num_grad_vars = self._num_weights - for sample in range(num_samples): - for i in range(num_grad_vars): - if self._input_gradients: - if i < self._num_inputs: - input_grad[sample, 0, i] = results.values[sample][i] + print(f"results {results}") + for i in range(num_samples): + for j in range(self.output_shape[0]): + for k in range(num_grad_vars): + if self._input_gradients: + if k < self._num_inputs: + input_grad[i, j, k] = results.gradients[i * self.output_shape[0] + j][k] + else: + weights_grad[i, j, k - self._num_inputs] = results.gradients[ + i * self.output_shape[0] + j + ][k] else: - weights_grad[sample, 0, i - self._num_inputs] = results.values[sample][i] - else: - weights_grad[sample, 0, i] = results.values[sample][i] + weights_grad[i, j, k] = results.gradients[i * self.output_shape[0] + j][k] return input_grad, weights_grad @@ -232,157 +187,30 @@ def _backward( self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: - """Backward pass of the network. - """ + """Backward pass of the network.""" # prepare parameters in the required format - parameter_values, num_samples = self._preprocess(input_data, weights) - print(parameter_values) + parameter_values_, num_samples = self._preprocess(input_data, weights) + parameter_values = [ + param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) + ] + print(f"parameter_values_: {parameter_values_}") + print(f"parameter_values : {parameter_values}") if self._input_gradients: - job = self._gradient.run([self._circuit]*num_samples, [self._operator]*num_samples, parameter_values) + job = self._gradient.run( + [self._circuit] * num_samples * self.output_shape[0], + self._observables * num_samples, + parameter_values, + ) else: - job = self._gradient.run([self._circuit]*num_samples, [self._operator]*num_samples, parameter_values, - parameters=[self._circuit.parameters[self._num_inputs:]] *num_samples) - - results = job.result() - print(results) - - # input_grad, weights_grad = self._postprocess_gradient(num_samples, results) - - # return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector - -def _init_observable(observable: BaseOperator | PauliSumOp) -> SparsePauliOp: - """Initialize observable by converting the input to a :class:`~qiskit.quantum_info.SparsePauliOp`. - - Args: - observable: The observable. - - Returns: - The observable as :class:`~qiskit.quantum_info.SparsePauliOp`. - - Raises: - TypeError: If the observable is a :class:`~qiskit.opflow.PauliSumOp` and has a parameterized - coefficient. - """ - if isinstance(observable, SparsePauliOp): - return observable - elif isinstance(observable, PauliSumOp): - if isinstance(observable.coeff, ParameterExpression): - raise TypeError( - f"Observable must have numerical coefficient, not {type(observable.coeff)}." + job = self._gradient.run( + [self._circuit] * num_samples * self.output_shape[0], + self._observables * num_samples, + parameter_values, + parameters=[self._circuit.parameters[self._num_inputs :]] + * num_samples + * self.output_shape[0], ) - return observable.coeff * observable.primitive - elif isinstance(observable, BasePauli): - return SparsePauliOp(observable) - elif isinstance(observable, BaseOperator): - return SparsePauliOp.from_operator(observable) - elif isinstance(observable, ListOp): - #TODO: ListOP? or simply use list of operators - pass - else: - return SparsePauliOp(observable) - - - - - # def _backward( - # self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - # ) -> Tuple[Optional[Union[np.ndarray, SparseArray]], Optional[Union[np.ndarray, SparseArray]],]: - - # self._construct_gradient_operator() - # # check whether gradient circuit could be constructed - # if self._gradient_operator is None: - # return None, None - - # num_samples = input_data.shape[0] - # if self._input_gradients: - # num_params = self._num_inputs + self._num_weights - # else: - # num_params = self._num_weights - - # param_values = { - # input_param: input_data[:, j] for j, input_param in enumerate(self._input_params) - # } - # param_values.update( - # { - # weight_param: np.full(num_samples, weights[j]) - # for j, weight_param in enumerate(self._weight_params) - # } - # ) - - # if self._circuit_sampler: - # converted_op = self._circuit_sampler.convert(self._gradient_operator, param_values) - # # if statement is a workaround for https://github.com/Qiskit/qiskit-terra/issues/7608 - # if len(converted_op.parameters) > 0: - # # rebind the leftover parameters and evaluate the gradient - # grad = self._evaluate_operator(converted_op, num_samples, param_values) - # else: - # # all parameters are bound by CircuitSampler, so we evaluate the operator directly - # grad = np.asarray(converted_op.eval()) - # else: - # # we evaluate gradient operator for each sample separately, so we create a list of operators. - # grad = self._evaluate_operator( - # [self._gradient_operator] * num_samples, num_samples, param_values - # ) - - # grad = np.real(grad) - - # # this is another workaround to fix output shape of the invocation result of CircuitSampler - # if self._output_shape == (1,): - # # at least 3 dimensions: batch, output, num_parameters, but in this case we don't have - # # output dimension, so we add a dimension that corresponds to the output - # grad = grad.reshape((num_samples, 1, num_params)) - # else: - # # swap last axis that corresponds to parameters and axes correspond to the output shape - # last_axis = len(grad.shape) - 1 - # grad = grad.transpose([0, last_axis, *(range(1, last_axis))]) - - # # split into and return input and weights gradients - # if self._input_gradients: - # input_grad = grad[:, :, : self._num_inputs].reshape( - # -1, *self._output_shape, self._num_inputs - # ) - - # weights_grad = grad[:, :, self._num_inputs :].reshape( - # -1, *self._output_shape, self._num_weights - # ) - # else: - # input_grad = None - # weights_grad = grad.reshape(-1, *self._output_shape, self._num_weights) - - # return input_grad, weights_grad - - # def _evaluate_operator( - # self, - # operator: Union[OperatorBase, List[OperatorBase]], - # num_samples: int, - # param_values: Dict[Parameter, np.ndarray], - # ) -> np.ndarray: - # """ - # Evaluates an operator or a list of operators for the samples in the dataset. If an operator - # is passed then it is considered as an iterable that has `num_samples` elements. Usually such - # operators are obtained as an output from `CircuitSampler`. If a list of operators is passed - # then each operator in this list is evaluated with a set of values/parameters corresponding - # to the sample index in the `param_values` as the operator in the list. - - # Args: - # operator: operator or list of operators to evaluate. - # num_samples: a total number of samples - # param_values: parameter values to use for operator evaluation. - - # Returns: - # the result of operator evaluation as an array. - # """ - # # create an list of parameter bindings, each element corresponds to a sample in the dataset - # param_bindings = [ - # {param: param_values[i] for param, param_values in param_values.items()} - # for i in range(num_samples) - # ] - - # grad = [] - # # iterate over gradient vectors and bind the correct parameters - # for oper_i, param_i in zip(operator, param_bindings): - # # bind or re-bind remaining values and evaluate the gradient - # grad.append(oper_i.bind_parameters(param_i).eval()) - - # return np.asarray(grad) + results = job.result() + input_grad, weights_grad = self._backward_postprocess(num_samples, results) + return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml new file mode 100644 index 000000000..13e7db0a0 --- /dev/null +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -0,0 +1,16 @@ +--- +features: + - | + New quantum neural network class using :class:`~qiskit.primitives.BaseEstimator` has been added. + It internally uses the estimator to calculate the forward pass and it requires + :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to calculate the backward pass. + + Example:: + .. code-block:: python + + estimator = Estimator(...) + gradient = ParamShiftEstimatorGradient(estimator) + estimator_qnn = EstimatorQNN(estimator, qc, [op], [input_param], [weight_param], gradient=gradient) + res = estimator_qnn.forward(inputs, weights) + input_grad, weights_grad = estimator_qnn.backward(inputs, weights) + From c32704f396ba758c0a6e16d7b8e5fbf0af61381f Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Tue, 4 Oct 2022 18:52:04 +0900 Subject: [PATCH 16/96] wip added unittests --- test/neural_networks/test_estimator_qnn.py | 374 +++++++++++++++++++++ 1 file changed, 374 insertions(+) create mode 100644 test/neural_networks/test_estimator_qnn.py diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py new file mode 100644 index 000000000..3d19830a9 --- /dev/null +++ b/test/neural_networks/test_estimator_qnn.py @@ -0,0 +1,374 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" Test EstimatorQNN """ + +from test import QiskitMachineLearningTestCase + +import unittest +from ddt import ddt, data + +import numpy as np + +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.opflow import PauliExpectation, Gradient, StateFn, PauliSumOp, ListOp +from qiskit.utils import QuantumInstance, algorithm_globals, optionals +from qiskit.quantum_info import SparsePauliOp +from qiskit.primitives import Estimator +from qiskit.algorithms.gradients import ParamShiftEstimatorGradient +from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN + + +@ddt +class TestEstimatorQNN(QiskitMachineLearningTestCase): + """EstimatorQNN Tests.""" + + def test_estimator_qnn_1_1(self): + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1.0)]) + estimator = Estimator() + g = ParamShiftEstimatorGradient(estimator) + estimator_qnn = EstimatorQNN(estimator, qc, [op], [params[0]], [params[1]], gradient=g) + weights = np.array([1]) + + test_data = [ + np.array(1), + np.array([1]), + np.array([[1], [2]]), + np.array([[[1], [2]], [[3], [4]]]), + ] + correct_results = [ + np.array([[0.08565359]]), + np.array([[0.08565359]]), + np.array([[0.08565359], [-0.90744233]]), + np.array([[[0.08565359], [-0.90744233]], + [[-1.06623996], [-0.24474149]]]) + ] + + # test forward pass + for i, inputs in enumerate(test_data): + res = estimator_qnn.forward(inputs, weights) + print(f"res = {res}") + np.testing.assert_allclose(res, correct_results[i], atol=1e-3) + # @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test") + # def setUp(self): + # super().setUp() + + # algorithm_globals.random_seed = 12345 + # from qiskit_aer import Aer, AerSimulator + + # # specify quantum instances + # self.sv_quantum_instance = QuantumInstance( + # Aer.get_backend("aer_simulator_statevector"), + # seed_simulator=algorithm_globals.random_seed, + # seed_transpiler=algorithm_globals.random_seed, + # ) + # # pylint: disable=no-member + # self.qasm_quantum_instance = QuantumInstance( + # AerSimulator(), + # shots=100, + # seed_simulator=algorithm_globals.random_seed, + # seed_transpiler=algorithm_globals.random_seed, + # ) + # np.random.seed(algorithm_globals.random_seed) + + # def validate_output_shape(self, qnn: OpflowQNN, test_data: List[np.ndarray]) -> None: + # """ + # Asserts that the opflow qnn returns results of the correct output shape. + + # Args: + # qnn: QNN to be tested + # test_data: list of test input arrays + + # Raises: + # QiskitMachineLearningError: Invalid input. + # """ + + # # get weights + # weights = np.random.rand(qnn.num_weights) + + # # iterate over test data and validate behavior of model + # for x in test_data: + + # # evaluate network + + + # forward_shape = qnn.forward(x, weights).shape + # input_grad, weights_grad = qnn.backward(x, weights) + # if qnn.input_gradients: + # backward_shape_input = input_grad.shape + # backward_shape_weights = weights_grad.shape + + # # derive batch shape form input + # batch_shape = x.shape[: -len(qnn.output_shape)] + # if len(batch_shape) == 0: + # batch_shape = (1,) + + # # compare results and assert that the behavior is equal + # self.assertEqual(forward_shape, (*batch_shape, *qnn.output_shape)) + # if qnn.input_gradients: + # self.assertEqual( + # backward_shape_input, + # (*batch_shape, *qnn.output_shape, qnn.num_inputs), + # ) + # else: + # self.assertIsNone(input_grad) + # self.assertEqual( + # backward_shape_weights, + # (*batch_shape, *qnn.output_shape, qnn.num_weights), + # ) + + + # def test_opflow_qnn_1_1(self, config): + # """Test Opflow QNN with input/output dimension 1/1.""" + # q_i, input_grad_required = config + + # if q_i == STATEVECTOR: + # quantum_instance = self.sv_quantum_instance + # elif q_i == QASM: + # quantum_instance = self.qasm_quantum_instance + # else: + # quantum_instance = None + + # # specify how to evaluate expected values and gradients + # expval = PauliExpectation() + # gradient = Gradient() + + # # construct parametrized circuit + # params = [Parameter("input1"), Parameter("weight1")] + # qc = QuantumCircuit(1) + # qc.h(0) + # qc.ry(params[0], 0) + # qc.rx(params[1], 0) + # qc_sfn = StateFn(qc) + + # # construct cost operator + # cost_operator = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)])) + + # # combine operator and circuit to objective function + # op = ~cost_operator @ qc_sfn + + # # define QNN + # qnn = OpflowQNN( + # op, + # [params[0]], + # [params[1]], + # expval, + # gradient, + # quantum_instance=quantum_instance, + # ) + # qnn.input_gradients = input_grad_required + + # test_data = [ + # np.array(1), + # np.array([1]), + # np.array([[1], [2]]), + # np.array([[[1], [2]], [[3], [4]]]), + # ] + + # # test model + # self.validate_output_shape(qnn, test_data) + + # # test the qnn after we set a quantum instance + # if quantum_instance is None: + # qnn.quantum_instance = self.qasm_quantum_instance + # self.validate_output_shape(qnn, test_data) + + # @data( + # (STATEVECTOR, True), + # (STATEVECTOR, False), + # (QASM, True), + # (QASM, False), + # (None, True), + # (None, False), + # ) + # def test_opflow_qnn_2_1(self, config): + # """Test Opflow QNN with input/output dimension 2/1.""" + # q_i, input_grad_required = config + + # # construct QNN + # if q_i == STATEVECTOR: + # quantum_instance = self.sv_quantum_instance + # elif q_i == QASM: + # quantum_instance = self.qasm_quantum_instance + # else: + # quantum_instance = None + + # # specify how to evaluate expected values and gradients + # expval = PauliExpectation() + # gradient = Gradient() + + # # construct parametrized circuit + # params = [ + # Parameter("input1"), + # Parameter("input2"), + # Parameter("weight1"), + # Parameter("weight2"), + # ] + # qc = QuantumCircuit(2) + # qc.h(0) + # qc.ry(params[0], 0) + # qc.ry(params[1], 1) + # qc.rx(params[2], 0) + # qc.rx(params[3], 1) + # qc_sfn = StateFn(qc) + + # # construct cost operator + # cost_operator = StateFn(PauliSumOp.from_list([("ZZ", 1.0), ("XX", 1.0)])) + + # # combine operator and circuit to objective function + # op = ~cost_operator @ qc_sfn + + # # define QNN + # qnn = OpflowQNN( + # op, + # params[:2], + # params[2:], + # expval, + # gradient, + # quantum_instance=quantum_instance, + # ) + # qnn.input_gradients = input_grad_required + + # test_data = [np.array([1, 2]), np.array([[1, 2]]), np.array([[1, 2], [3, 4]])] + + # # test model + # self.validate_output_shape(qnn, test_data) + + # # test the qnn after we set a quantum instance + # if quantum_instance is None: + # qnn.quantum_instance = self.qasm_quantum_instance + # self.validate_output_shape(qnn, test_data) + + # @data( + # (STATEVECTOR, True), + # (STATEVECTOR, False), + # (QASM, True), + # (QASM, False), + # (None, True), + # (None, False), + # ) + # def test_opflow_qnn_2_2(self, config): + # """Test Opflow QNN with input/output dimension 2/2.""" + # q_i, input_grad_required = config + + # if q_i == STATEVECTOR: + # quantum_instance = self.sv_quantum_instance + # elif q_i == QASM: + # quantum_instance = self.qasm_quantum_instance + # else: + # quantum_instance = None + + # # construct parametrized circuit + # params_1 = [Parameter("input1"), Parameter("weight1")] + # qc_1 = QuantumCircuit(1) + # qc_1.h(0) + # qc_1.ry(params_1[0], 0) + # qc_1.rx(params_1[1], 0) + # qc_sfn_1 = StateFn(qc_1) + + # # construct cost operator + # h_1 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)])) + + # # combine operator and circuit to objective function + # op_1 = ~h_1 @ qc_sfn_1 + + # # construct parametrized circuit + # params_2 = [Parameter("input2"), Parameter("weight2")] + # qc_2 = QuantumCircuit(1) + # qc_2.h(0) + # qc_2.ry(params_2[0], 0) + # qc_2.rx(params_2[1], 0) + # qc_sfn_2 = StateFn(qc_2) + + # # construct cost operator + # h_2 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)])) + + # # combine operator and circuit to objective function + # op_2 = ~h_2 @ qc_sfn_2 + + # op = ListOp([op_1, op_2]) + + # qnn = OpflowQNN( + # op, + # [params_1[0], params_2[0]], + # [params_1[1], params_2[1]], + # quantum_instance=quantum_instance, + # ) + # qnn.input_gradients = input_grad_required + + # test_data = [np.array([1, 2]), np.array([[1, 2], [3, 4]])] + + # # test model + # self.validate_output_shape(qnn, test_data) + + # # test the qnn after we set a quantum instance + # if quantum_instance is None: + # qnn.quantum_instance = self.qasm_quantum_instance + # self.validate_output_shape(qnn, test_data) + + # def test_composed_op(self): + # """Tests OpflowQNN with ComposedOp as an operator.""" + # qc = QuantumCircuit(1) + # param = Parameter("param") + # qc.rz(param, 0) + + # h_1 = PauliSumOp.from_list([("Z", 1.0)]) + # h_2 = PauliSumOp.from_list([("Z", 1.0)]) + + # h_op = ListOp([h_1, h_2]) + # op = ~StateFn(h_op) @ StateFn(qc) + + # # initialize QNN + # qnn = OpflowQNN(op, [], [param]) + + # # create random data and weights for testing + # input_data = np.random.rand(2, qnn.num_inputs) + # weights = np.random.rand(qnn.num_weights) + + # qnn.forward(input_data, weights) + # qnn.backward(input_data, weights) + + # def test_delayed_gradient_initialization(self): + # """Test delayed gradient initialization.""" + # qc = QuantumCircuit(1) + # input_param = Parameter("x") + # qc.ry(input_param, 0) + + # weight_param = Parameter("w") + # qc.rx(weight_param, 0) + + # observable = StateFn(PauliSumOp.from_list([("Z", 1)])) + # op = ~observable @ StateFn(qc) + + # # define QNN + # qnn = OpflowQNN(op, [input_param], [weight_param]) + # self.assertIsNone(qnn._gradient_operator) + + # qnn.backward(np.asarray([1]), np.asarray([1])) + # grad_op1 = qnn._gradient_operator + # self.assertIsNotNone(grad_op1) + + # qnn.input_gradients = True + # self.assertIsNone(qnn._gradient_operator) + # qnn.backward(np.asarray([1]), np.asarray([1])) + # grad_op2 = qnn._gradient_operator + # self.assertIsNotNone(grad_op1) + # self.assertNotEqual(grad_op1, grad_op2) + + +if __name__ == "__main__": + unittest.main() From d1df03128999ebd9efe2eb05a4b6654f30cf45b4 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 5 Oct 2022 10:14:41 +0900 Subject: [PATCH 17/96] added unittests --- .../neural_networks/__init__.py | 3 + .../neural_networks/estimator_qnn.py | 44 +- test/neural_networks/test_estimator_qnn.py | 475 ++++++------------ 3 files changed, 178 insertions(+), 344 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/__init__.py b/qiskit_machine_learning/neural_networks/__init__.py index f1b86c5c1..e0c0186fe 100644 --- a/qiskit_machine_learning/neural_networks/__init__.py +++ b/qiskit_machine_learning/neural_networks/__init__.py @@ -46,6 +46,7 @@ OpflowQNN TwoLayerQNN CircuitQNN + EstimatorQNN Neural Network Metrics ====================== @@ -61,6 +62,7 @@ from .circuit_qnn import CircuitQNN from .effective_dimension import EffectiveDimension, LocalEffectiveDimension +from .estimator_qnn import EstimatorQNN from .neural_network import NeuralNetwork from .opflow_qnn import OpflowQNN from .sampling_neural_network import SamplingNeuralNetwork @@ -74,4 +76,5 @@ "CircuitQNN", "EffectiveDimension", "LocalEffectiveDimension", + "EstimatorQNN", ] diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index d6494d2f7..8d4c48242 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -1,6 +1,6 @@ # This code is part of Qiskit. # -# (C) Copyright IBM 2020, 2022. +# (C) Copyright IBM 2022. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory @@ -10,8 +10,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""An Opflow Quantum Neural Network that allows to use a parametrized opflow object as a -neural network.""" +"""Estimator quantum neural network class""" import logging from typing import Optional, Sequence, Tuple, Union @@ -43,7 +42,7 @@ class SparseArray: # type: ignore class EstimatorQNN(NeuralNetwork): - """A Neural Network implementation based on the Sampler primitive.""" + """A Neural Network implementation based on the Estimator primitive.""" def __init__( self, @@ -57,12 +56,12 @@ def __init__( ): """ Args: - operator: The parametrized operator that represents the neural network. - input_params: The operator parameters that correspond to the input of the network. - weight_params: The operator parameters that correspond to the trainable weights. - exp_val: The Expected Value converter to be used for the operator. - gradient: The Gradient converter to be used for the operator's backward pass. - quantum_instance: The quantum instance to evaluate the network. + estimator: The estimator used to compute neural network's results. + circuit: The quantum circuit to represent the neural network. + observables: The observables for outputs of the neural network. + input_params: The parameters that correspond to the input of the network. + weight_params: The parameters that correspond to the trainable weights. + gradient: The estimator gradient to be used for the backward pass. input_gradients: Determines whether to compute gradients with respect to input data. Note that this parameter is ``False`` by default, and must be explicitly set to ``True`` for a proper gradient computation when using ``TorchConnector``. @@ -73,7 +72,6 @@ def __init__( self._input_params = list(input_params) or [] self._weight_params = list(weight_params) or [] self._gradient = gradient - # initialize gradient properties self.input_gradients = input_gradients super().__init__( @@ -83,11 +81,10 @@ def __init__( output_shape=len(observables), input_gradients=input_gradients, ) - print(self.output_shape[0]) @property - def operator(self): - """Returns the underlying operator of this QNN.""" + def observables(self): + """Returns the underlying observables of this QNN.""" return self._observables @property @@ -129,29 +126,21 @@ def _forward_postprocess(self, num_samples, results): def _forward( self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> Union[np.ndarray, SparseArray]: - # combine parameter dictionary - # take i-th column as values for the i-th param in a batch + """Forward pass of the neural network.""" parameter_values_, num_samples = self._preprocess(input_data, weights) parameter_values = [ param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) ] - # print(f"parameter_values_: {parameter_values_}") - # print(f"parameter_values : {parameter_values}") - # print(self._observables * num_samples) job = self._estimator.run( [self._circuit] * num_samples * self.output_shape[0], self._observables * num_samples, parameter_values, ) results = job.result() - print(results) return self._forward_postprocess(num_samples, results) def _backward_postprocess(self, num_samples, results): - """ - Post-processing during backward pass of the network. - """ - print(f"self._output_shape {self._output_shape}") + """Post-processing during backward pass of the network.""" input_grad = ( np.zeros((num_samples, *self.output_shape, self._num_inputs)) if self._input_gradients @@ -159,15 +148,11 @@ def _backward_postprocess(self, num_samples, results): ) weights_grad = np.zeros((num_samples, *self.output_shape, self._num_weights)) - print(f"input_grad {input_grad}") - print(f"weights_grad {weights_grad}") - if self._input_gradients: num_grad_vars = self._num_inputs + self._num_weights else: num_grad_vars = self._num_weights - print(f"results {results}") for i in range(num_samples): for j in range(self.output_shape[0]): for k in range(num_grad_vars): @@ -186,15 +171,12 @@ def _backward_postprocess(self, num_samples, results): def _backward( self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: - """Backward pass of the network.""" # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) parameter_values = [ param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) ] - print(f"parameter_values_: {parameter_values_}") - print(f"parameter_values : {parameter_values}") if self._input_gradients: job = self._gradient.run( [self._circuit] * num_samples * self.output_shape[0], diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 3d19830a9..1e9a23a1b 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -15,33 +15,32 @@ from test import QiskitMachineLearningTestCase import unittest -from ddt import ddt, data import numpy as np from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.opflow import PauliExpectation, Gradient, StateFn, PauliSumOp, ListOp -from qiskit.utils import QuantumInstance, algorithm_globals, optionals from qiskit.quantum_info import SparsePauliOp from qiskit.primitives import Estimator from qiskit.algorithms.gradients import ParamShiftEstimatorGradient from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN -@ddt class TestEstimatorQNN(QiskitMachineLearningTestCase): """EstimatorQNN Tests.""" def test_estimator_qnn_1_1(self): + """Test Estimator QNN with input/output dimension 1/1.""" params = [Parameter("input1"), Parameter("weight1")] qc = QuantumCircuit(1) qc.h(0) qc.ry(params[0], 0) qc.rx(params[1], 0) - op = SparsePauliOp.from_list([("Z", 1), ("X", 1.0)]) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) estimator = Estimator() - g = ParamShiftEstimatorGradient(estimator) - estimator_qnn = EstimatorQNN(estimator, qc, [op], [params[0]], [params[1]], gradient=g) + gradient = ParamShiftEstimatorGradient(estimator) + estimator_qnn = EstimatorQNN( + estimator, qc, [op], [params[0]], [params[1]], gradient=gradient + ) weights = np.array([1]) test_data = [ @@ -50,324 +49,174 @@ def test_estimator_qnn_1_1(self): np.array([[1], [2]]), np.array([[[1], [2]], [[3], [4]]]), ] - correct_results = [ + correct_forwards = [ np.array([[0.08565359]]), np.array([[0.08565359]]), np.array([[0.08565359], [-0.90744233]]), - np.array([[[0.08565359], [-0.90744233]], - [[-1.06623996], [-0.24474149]]]) + np.array([[[0.08565359], [-0.90744233]], [[-1.06623996], [-0.24474149]]]), + ] + correct_weight_backwards = [ + np.array([[[0.70807342]]]), + np.array([[[0.70807342]]]), + np.array([[[0.70807342]], [[0.7651474]]]), + np.array([[[[0.70807342]], [[0.7651474]]], [[[0.11874839]], [[-0.63682734]]]]), + ] + correct_input_backwards = [ + np.array([[[-1.13339757]]]), + np.array([[[-1.13339757]]]), + np.array([[[-1.13339757]], [[-0.68445233]]]), + np.array([[[[-1.13339757]], [[-0.68445233]]], [[[0.39377522]], [[1.10996765]]]]), ] # test forward pass - for i, inputs in enumerate(test_data): - res = estimator_qnn.forward(inputs, weights) - print(f"res = {res}") - np.testing.assert_allclose(res, correct_results[i], atol=1e-3) - # @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test") - # def setUp(self): - # super().setUp() - - # algorithm_globals.random_seed = 12345 - # from qiskit_aer import Aer, AerSimulator - - # # specify quantum instances - # self.sv_quantum_instance = QuantumInstance( - # Aer.get_backend("aer_simulator_statevector"), - # seed_simulator=algorithm_globals.random_seed, - # seed_transpiler=algorithm_globals.random_seed, - # ) - # # pylint: disable=no-member - # self.qasm_quantum_instance = QuantumInstance( - # AerSimulator(), - # shots=100, - # seed_simulator=algorithm_globals.random_seed, - # seed_transpiler=algorithm_globals.random_seed, - # ) - # np.random.seed(algorithm_globals.random_seed) - - # def validate_output_shape(self, qnn: OpflowQNN, test_data: List[np.ndarray]) -> None: - # """ - # Asserts that the opflow qnn returns results of the correct output shape. - - # Args: - # qnn: QNN to be tested - # test_data: list of test input arrays - - # Raises: - # QiskitMachineLearningError: Invalid input. - # """ - - # # get weights - # weights = np.random.rand(qnn.num_weights) - - # # iterate over test data and validate behavior of model - # for x in test_data: - - # # evaluate network - - - # forward_shape = qnn.forward(x, weights).shape - # input_grad, weights_grad = qnn.backward(x, weights) - # if qnn.input_gradients: - # backward_shape_input = input_grad.shape - # backward_shape_weights = weights_grad.shape - - # # derive batch shape form input - # batch_shape = x.shape[: -len(qnn.output_shape)] - # if len(batch_shape) == 0: - # batch_shape = (1,) - - # # compare results and assert that the behavior is equal - # self.assertEqual(forward_shape, (*batch_shape, *qnn.output_shape)) - # if qnn.input_gradients: - # self.assertEqual( - # backward_shape_input, - # (*batch_shape, *qnn.output_shape, qnn.num_inputs), - # ) - # else: - # self.assertIsNone(input_grad) - # self.assertEqual( - # backward_shape_weights, - # (*batch_shape, *qnn.output_shape, qnn.num_weights), - # ) - - - # def test_opflow_qnn_1_1(self, config): - # """Test Opflow QNN with input/output dimension 1/1.""" - # q_i, input_grad_required = config - - # if q_i == STATEVECTOR: - # quantum_instance = self.sv_quantum_instance - # elif q_i == QASM: - # quantum_instance = self.qasm_quantum_instance - # else: - # quantum_instance = None - - # # specify how to evaluate expected values and gradients - # expval = PauliExpectation() - # gradient = Gradient() - - # # construct parametrized circuit - # params = [Parameter("input1"), Parameter("weight1")] - # qc = QuantumCircuit(1) - # qc.h(0) - # qc.ry(params[0], 0) - # qc.rx(params[1], 0) - # qc_sfn = StateFn(qc) - - # # construct cost operator - # cost_operator = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)])) - - # # combine operator and circuit to objective function - # op = ~cost_operator @ qc_sfn - - # # define QNN - # qnn = OpflowQNN( - # op, - # [params[0]], - # [params[1]], - # expval, - # gradient, - # quantum_instance=quantum_instance, - # ) - # qnn.input_gradients = input_grad_required - - # test_data = [ - # np.array(1), - # np.array([1]), - # np.array([[1], [2]]), - # np.array([[[1], [2]], [[3], [4]]]), - # ] - - # # test model - # self.validate_output_shape(qnn, test_data) - - # # test the qnn after we set a quantum instance - # if quantum_instance is None: - # qnn.quantum_instance = self.qasm_quantum_instance - # self.validate_output_shape(qnn, test_data) - - # @data( - # (STATEVECTOR, True), - # (STATEVECTOR, False), - # (QASM, True), - # (QASM, False), - # (None, True), - # (None, False), - # ) - # def test_opflow_qnn_2_1(self, config): - # """Test Opflow QNN with input/output dimension 2/1.""" - # q_i, input_grad_required = config - - # # construct QNN - # if q_i == STATEVECTOR: - # quantum_instance = self.sv_quantum_instance - # elif q_i == QASM: - # quantum_instance = self.qasm_quantum_instance - # else: - # quantum_instance = None - - # # specify how to evaluate expected values and gradients - # expval = PauliExpectation() - # gradient = Gradient() - - # # construct parametrized circuit - # params = [ - # Parameter("input1"), - # Parameter("input2"), - # Parameter("weight1"), - # Parameter("weight2"), - # ] - # qc = QuantumCircuit(2) - # qc.h(0) - # qc.ry(params[0], 0) - # qc.ry(params[1], 1) - # qc.rx(params[2], 0) - # qc.rx(params[3], 1) - # qc_sfn = StateFn(qc) - - # # construct cost operator - # cost_operator = StateFn(PauliSumOp.from_list([("ZZ", 1.0), ("XX", 1.0)])) - - # # combine operator and circuit to objective function - # op = ~cost_operator @ qc_sfn - - # # define QNN - # qnn = OpflowQNN( - # op, - # params[:2], - # params[2:], - # expval, - # gradient, - # quantum_instance=quantum_instance, - # ) - # qnn.input_gradients = input_grad_required - - # test_data = [np.array([1, 2]), np.array([[1, 2]]), np.array([[1, 2], [3, 4]])] - - # # test model - # self.validate_output_shape(qnn, test_data) - - # # test the qnn after we set a quantum instance - # if quantum_instance is None: - # qnn.quantum_instance = self.qasm_quantum_instance - # self.validate_output_shape(qnn, test_data) - - # @data( - # (STATEVECTOR, True), - # (STATEVECTOR, False), - # (QASM, True), - # (QASM, False), - # (None, True), - # (None, False), - # ) - # def test_opflow_qnn_2_2(self, config): - # """Test Opflow QNN with input/output dimension 2/2.""" - # q_i, input_grad_required = config - - # if q_i == STATEVECTOR: - # quantum_instance = self.sv_quantum_instance - # elif q_i == QASM: - # quantum_instance = self.qasm_quantum_instance - # else: - # quantum_instance = None - - # # construct parametrized circuit - # params_1 = [Parameter("input1"), Parameter("weight1")] - # qc_1 = QuantumCircuit(1) - # qc_1.h(0) - # qc_1.ry(params_1[0], 0) - # qc_1.rx(params_1[1], 0) - # qc_sfn_1 = StateFn(qc_1) - - # # construct cost operator - # h_1 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)])) - - # # combine operator and circuit to objective function - # op_1 = ~h_1 @ qc_sfn_1 - - # # construct parametrized circuit - # params_2 = [Parameter("input2"), Parameter("weight2")] - # qc_2 = QuantumCircuit(1) - # qc_2.h(0) - # qc_2.ry(params_2[0], 0) - # qc_2.rx(params_2[1], 0) - # qc_sfn_2 = StateFn(qc_2) - - # # construct cost operator - # h_2 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)])) - - # # combine operator and circuit to objective function - # op_2 = ~h_2 @ qc_sfn_2 - - # op = ListOp([op_1, op_2]) - - # qnn = OpflowQNN( - # op, - # [params_1[0], params_2[0]], - # [params_1[1], params_2[1]], - # quantum_instance=quantum_instance, - # ) - # qnn.input_gradients = input_grad_required - - # test_data = [np.array([1, 2]), np.array([[1, 2], [3, 4]])] - - # # test model - # self.validate_output_shape(qnn, test_data) - - # # test the qnn after we set a quantum instance - # if quantum_instance is None: - # qnn.quantum_instance = self.qasm_quantum_instance - # self.validate_output_shape(qnn, test_data) - - # def test_composed_op(self): - # """Tests OpflowQNN with ComposedOp as an operator.""" - # qc = QuantumCircuit(1) - # param = Parameter("param") - # qc.rz(param, 0) - - # h_1 = PauliSumOp.from_list([("Z", 1.0)]) - # h_2 = PauliSumOp.from_list([("Z", 1.0)]) - - # h_op = ListOp([h_1, h_2]) - # op = ~StateFn(h_op) @ StateFn(qc) - - # # initialize QNN - # qnn = OpflowQNN(op, [], [param]) - - # # create random data and weights for testing - # input_data = np.random.rand(2, qnn.num_inputs) - # weights = np.random.rand(qnn.num_weights) - - # qnn.forward(input_data, weights) - # qnn.backward(input_data, weights) + with self.subTest("forward pass"): + for i, inputs in enumerate(test_data): + forward = estimator_qnn.forward(inputs, weights) + np.testing.assert_allclose(forward, correct_forwards[i], atol=1e-3) + # test backward pass without input_gradients + with self.subTest("backward pass without input gradients"): + for i, inputs in enumerate(test_data): + input_backward, weight_backward = estimator_qnn.backward(inputs, weights) + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + self.assertIsNone(input_backward) + # test backward pass with input_gradients + with self.subTest("backward bass with input gradients"): + estimator_qnn.input_gradients = True + for i, inputs in enumerate(test_data): + input_backward, weight_backward = estimator_qnn.backward(inputs, weights) + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + + def test_estimator_qnn_2_1(self): + """Test Estimator QNN with input/output dimension 2/1.""" + params = [ + Parameter("input1"), + Parameter("input2"), + Parameter("weight1"), + Parameter("weight2"), + ] + qc = QuantumCircuit(2) + qc.h(0) + qc.ry(params[0], 0) + qc.ry(params[1], 1) + qc.rx(params[2], 0) + qc.rx(params[3], 1) + op = SparsePauliOp.from_list([("ZZ", 1), ("XX", 1)]) + estimator = Estimator() + gradient = ParamShiftEstimatorGradient(estimator) + estimator_qnn = EstimatorQNN(estimator, qc, [op], params[:2], params[2:], gradient=gradient) + weights = np.array([1, 2]) + + test_data = [np.array([1, 2]), np.array([[1, 2]]), np.array([[1, 2], [3, 4]])] + correct_forwards = [ + np.array([[0.41256026]]), + np.array([[0.41256026]]), + np.array([[0.41256026], [0.72848859]]), + ] + correct_weight_backwards = [ + np.array([[[0.12262287, -0.17203964]]]), + np.array([[[0.12262287, -0.17203964]]]), + np.array([[[0.12262287, -0.17203964]], [[0.03230095, -0.04531817]]]), + ] + correct_input_backwards = [ + np.array([[[-0.81570272, -0.39688474]]]), + np.array([[[-0.81570272, -0.39688474]]]), + np.array([[[-0.81570272, -0.39688474]], [[0.25229775, 0.67111573]]]), + ] - # def test_delayed_gradient_initialization(self): - # """Test delayed gradient initialization.""" - # qc = QuantumCircuit(1) - # input_param = Parameter("x") - # qc.ry(input_param, 0) + # test forward pass + with self.subTest("forward pass"): + for i, inputs in enumerate(test_data): + forward = estimator_qnn.forward(inputs, weights) + np.testing.assert_allclose(forward, correct_forwards[i], atol=1e-3) + # test backward pass without input_gradients + with self.subTest("backward pass without input gradients"): + for i, inputs in enumerate(test_data): + input_backward, weight_backward = estimator_qnn.backward(inputs, weights) + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + self.assertIsNone(input_backward) + # test backward pass with input_gradients + with self.subTest("backward bass with input gradients"): + estimator_qnn.input_gradients = True + for i, inputs in enumerate(test_data): + input_backward, weight_backward = estimator_qnn.backward(inputs, weights) + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + + def test_estimator_qnn_1_2(self): + """Test Estimator QNN with input/output dimension 1/2.""" + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) - # weight_param = Parameter("w") - # qc.rx(weight_param, 0) + op1 = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + op2 = SparsePauliOp.from_list([("Z", 2), ("X", 2)]) - # observable = StateFn(PauliSumOp.from_list([("Z", 1)])) - # op = ~observable @ StateFn(qc) + estimator = Estimator() + gradient = ParamShiftEstimatorGradient(estimator) + # construct QNN + estimator_qnn = EstimatorQNN( + estimator, qc, [op1, op2], [params[0]], [params[1]], gradient=gradient + ) + weights = np.array([1]) - # # define QNN - # qnn = OpflowQNN(op, [input_param], [weight_param]) - # self.assertIsNone(qnn._gradient_operator) + test_data = [ + np.array([1]), + np.array([[1], [2]]), + np.array([[[1], [2]], [[3], [4]]]), + ] - # qnn.backward(np.asarray([1]), np.asarray([1])) - # grad_op1 = qnn._gradient_operator - # self.assertIsNotNone(grad_op1) + correct_forwards = [ + np.array([[0.08565359, 0.17130718]]), + np.array([[0.08565359, 0.17130718], [-0.90744233, -1.81488467]]), + np.array( + [ + [[0.08565359, 0.17130718], [-0.90744233, -1.81488467]], + [[-1.06623996, -2.13247992], [-0.24474149, -0.48948298]], + ] + ), + ] + correct_weight_backwards = [ + np.array([[[0.70807342], [1.41614684]]]), + np.array([[[0.70807342], [1.41614684]], [[0.7651474], [1.5302948]]]), + np.array( + [ + [[[0.70807342], [1.41614684]], [[0.7651474], [1.5302948]]], + [[[0.11874839], [0.23749678]], [[-0.63682734], [-1.27365468]]], + ] + ), + ] + correct_input_backwards = [ + np.array([[[-1.13339757], [-2.26679513]]]), + np.array([[[-1.13339757], [-2.26679513]], [[-0.68445233], [-1.36890466]]]), + np.array( + [ + [[[-1.13339757], [-2.26679513]], [[-0.68445233], [-1.36890466]]], + [[[0.39377522], [0.78755044]], [[1.10996765], [2.2199353]]], + ] + ), + ] - # qnn.input_gradients = True - # self.assertIsNone(qnn._gradient_operator) - # qnn.backward(np.asarray([1]), np.asarray([1])) - # grad_op2 = qnn._gradient_operator - # self.assertIsNotNone(grad_op1) - # self.assertNotEqual(grad_op1, grad_op2) + # test forward pass + with self.subTest("forward pass"): + for i, inputs in enumerate(test_data): + forward = estimator_qnn.forward(inputs, weights) + np.testing.assert_allclose(forward, correct_forwards[i], atol=1e-3) + # test backward pass without input_gradients + with self.subTest("backward pass without input gradients"): + for i, inputs in enumerate(test_data): + input_backward, weight_backward = estimator_qnn.backward(inputs, weights) + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + self.assertIsNone(input_backward) + # test backward pass with input_gradients + with self.subTest("backward bass with input gradients"): + estimator_qnn.input_gradients = True + for i, inputs in enumerate(test_data): + input_backward, weight_backward = estimator_qnn.backward(inputs, weights) + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) if __name__ == "__main__": From a490bbc338d48925d8cf6e4fce94daefdac1e339 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 5 Oct 2022 10:26:47 +0900 Subject: [PATCH 18/96] reno --- .../add-estimator-qnn-270b31662988bef9.yaml | 29 +++++++++++++++---- 1 file changed, 23 insertions(+), 6 deletions(-) diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 13e7db0a0..f83ec11e7 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -1,16 +1,33 @@ --- features: - | - New quantum neural network class using :class:`~qiskit.primitives.BaseEstimator` has been added. - It internally uses the estimator to calculate the forward pass and it requires - :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to calculate the backward pass. + New quantum neural network class, `~qiskit_machine_learning.neural_networks.EstimatorQNN`, + has been added. It internally uses :class:`~qiskit.primitives.Estimator` to calculate the + forward pass and it requires :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to + calculate the backward pass. Example:: .. code-block:: python + import numpy as np - estimator = Estimator(...) + from qiskit.algorithms.gradients import ParamShiftEstimatorGradient + from qiskit.circuit import QuantumCircuit, Parameter + from qiskit.primitives import Estimator + from qiskit.quantum_info import SparsePauliOp + from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN + + estimator = Estimator() + gradient = ParamShiftEstimatorGradient(estimator) + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1.0)]) gradient = ParamShiftEstimatorGradient(estimator) - estimator_qnn = EstimatorQNN(estimator, qc, [op], [input_param], [weight_param], gradient=gradient) + + estimator_qnn = EstimatorQNN(estimator, qc, [op], [params[0]], [params[1]], gradient=gradient) + inputs = np.array([1]) + weights = np.array([2]) res = estimator_qnn.forward(inputs, weights) input_grad, weights_grad = estimator_qnn.backward(inputs, weights) - From 97129b4e20f214c9ac9b30cef40121853fe8d7ca Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 5 Oct 2022 12:45:54 +0900 Subject: [PATCH 19/96] fix reno --- releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index f83ec11e7..7f9186625 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -7,7 +7,9 @@ features: calculate the backward pass. Example:: + .. code-block:: python + import numpy as np from qiskit.algorithms.gradients import ParamShiftEstimatorGradient From 800dcceca14a277173f72a68ed93c07881abf371 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Thu, 6 Oct 2022 13:34:42 +0900 Subject: [PATCH 20/96] support estimator qnn in two_layer_qnn --- .../neural_networks/two_layer_qnn.py | 107 ++++++++++++++++-- 1 file changed, 96 insertions(+), 11 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/two_layer_qnn.py b/qiskit_machine_learning/neural_networks/two_layer_qnn.py index 4df9583e4..cc4686b0d 100644 --- a/qiskit_machine_learning/neural_networks/two_layer_qnn.py +++ b/qiskit_machine_learning/neural_networks/two_layer_qnn.py @@ -15,19 +15,40 @@ be trained to solve a particular tasks.""" from __future__ import annotations +import warnings +from typing import Optional, Sequence, Tuple, Union + +import numpy as np from qiskit import QuantumCircuit -from qiskit.opflow import PauliSumOp, StateFn, OperatorBase, ExpectationBase +from qiskit.algorithms.gradients import BaseEstimatorGradient +from qiskit.opflow import ExpectationBase, OperatorBase, PauliSumOp, StateFn +from qiskit.primitives import BaseEstimator from qiskit.providers import Backend from qiskit.utils import QuantumInstance -from .opflow_qnn import OpflowQNN +import qiskit_machine_learning.optionals as _optionals + from ..utils import derive_num_qubits_feature_map_ansatz +from .estimator_qnn import EstimatorQNN +from .neural_network import NeuralNetwork +from .opflow_qnn import OpflowQNN +if _optionals.HAS_SPARSE: + # pylint: disable=import-error + from sparse import SparseArray +else: + class SparseArray: # type: ignore + """Empty SparseArray class + Replacement if sparse.SparseArray is not present. + """ + + pass -class TwoLayerQNN(OpflowQNN): +class TwoLayerQNN(NeuralNetwork): """Two Layer Quantum Neural Network consisting of a feature map, a ansatz, and an observable. """ + #TODO: inherit from EstimatorQNN after deprecation of OpflowQNN def __init__( self, @@ -38,6 +59,8 @@ def __init__( exp_val: ExpectationBase | None = None, quantum_instance: QuantumInstance | Backend | None = None, input_gradients: bool = False, + estimator: BaseEstimator | None = None, + gradient: BaseEstimatorGradient | None = None, ): r""" Args: @@ -63,6 +86,7 @@ def __init__( QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz can't be adjusted to ``num_qubits``. + ValueError: If both ``quantum_instance`` and ``estimator`` are given. """ num_qubits, feature_map, ansatz = derive_num_qubits_feature_map_ansatz( @@ -81,22 +105,83 @@ def __init__( self._circuit.append(self._ansatz, range(num_qubits)) # construct observable - self.observable = ( + self._observable = ( observable if observable is not None else PauliSumOp.from_list([("Z" * num_qubits, 1)]) ) - # combine all to operator - operator = StateFn(self.observable, is_measurement=True) @ StateFn(self._circuit) + if quantum_instance is not None and estimator is not None: + raise ValueError("Only one of quantum_instance or sampler can be passed, not both!") + + # # check positionally passing the sampler in the place of quantum_instance + # # which will be removed in future + # if isinstance(quantum_instance, BaseSampler): + # sampler = quantum_instance + # quantum_instance = None + + self._quantum_instance = None + if quantum_instance is not None: + warnings.warn( + "The quantum_instance argument has been superseded by the sampler argument. " + "This argument will be deprecated in a future release and subsequently " + "removed after that.", + category=PendingDeprecationWarning, + stacklevel=2, + ) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=PendingDeprecationWarning) + self.quantum_instance = quantum_instance + + self._estimator = estimator + if estimator is not None: + # if estimator is passed, use ``EstimatorQNN`` + self._estimator_qnn = EstimatorQNN( + estimator=estimator, + circuit=self._circuit, + observables=self._observable, + input_params=input_params, + weight_params=weight_params, + gradient=gradient, + input_gradients=input_gradients, + ) + output_shape = self._estimator_qnn.output_shape + else: + # Otherwise, use ``OpflowQNN`` + # combine all to operator + operator = StateFn(self._observable, is_measurement=True) @ StateFn(self._circuit) + self._opflow_qnn = OpflowQNN( + operator=operator, + input_params=input_params, + weight_params=weight_params, + exp_val=exp_val, + quantum_instance=quantum_instance, + input_gradients=input_gradients, + ) + output_shape = self._opflow_qnn.output_shape super().__init__( - operator=operator, - input_params=input_params, - weight_params=weight_params, - exp_val=exp_val, - quantum_instance=quantum_instance, + len(input_params), + len(weight_params), + sparse=False, + output_shape=output_shape, input_gradients=input_gradients, ) + def _forward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> Union[np.ndarray, SparseArray]: + if self._estimator is not None: + return self._estimator_qnn.forward(input_data, weights) + else: + return self._opflow_qnn.forward(input_data, weights) + + def _backward( + self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + if self._estimator is not None: + return self._estimator_qnn.backward(input_data, weights) + else: + return self._opflow_qnn.backward(input_data, weights) + @property def feature_map(self) -> QuantumCircuit: """Returns the used feature map.""" From 7963cbc05f59374c7f569b3e42bacac336d0ad62 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 10:56:38 +0200 Subject: [PATCH 21/96] Update typehints, refactor --- .../neural_networks/__init__.py | 11 +-- .../neural_networks/sampler_qnn.py | 81 +++++++++---------- 2 files changed, 40 insertions(+), 52 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/__init__.py b/qiskit_machine_learning/neural_networks/__init__.py index 2a5794ac5..2f26e75e5 100644 --- a/qiskit_machine_learning/neural_networks/__init__.py +++ b/qiskit_machine_learning/neural_networks/__init__.py @@ -46,6 +46,7 @@ OpflowQNN TwoLayerQNN CircuitQNN + SamplerQNN Neural Network Metrics ====================== @@ -56,16 +57,6 @@ EffectiveDimension LocalEffectiveDimension - -Neural Networks using Primitives -================================ - -.. autosummary:: - :toctree: ../stubs/ - :nosignatures: - - SamplerQNN - """ from .circuit_qnn import CircuitQNN diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 6d5cb0905..fc9b17597 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -14,16 +14,16 @@ from __future__ import annotations import logging + from numbers import Integral -from typing import Optional, Union, List, Tuple, Callable, cast, Iterable +from typing import Callable, cast, Iterable, Sequence import numpy as np - -from qiskit import QuantumCircuit -from qiskit.circuit import Parameter -from qiskit.primitives import BaseSampler from qiskit.algorithms.gradients import BaseSamplerGradient +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.primitives import BaseSampler from qiskit_machine_learning.exceptions import QiskitMachineLearningError, QiskitError + from .neural_network import NeuralNetwork logger = logging.getLogger(__name__) @@ -36,16 +36,17 @@ def __init__( self, sampler: BaseSampler, circuit: QuantumCircuit, - input_params: List[Parameter] | None = None, - weight_params: List[Parameter] | None = None, - interpret: Callable[[int], int | Tuple[int, ...]] | None = None, - output_shape: int | Tuple[int, ...] | None = None, + *, + input_params: Sequence[Parameter] | None = None, + weight_params: Sequence[Parameter] | None = None, + interpret: Callable[[int], int | tuple[int, ...]] | None = None, + output_shape: int | tuple[int, ...] | None = None, gradient: BaseSamplerGradient | None = None, input_gradients: bool = False - )-> None: + ): """ - Args: + sampler: The sampler primitive used to compute neural network's results. circuit: The parametrized quantum circuit that generates the samples of this network. input_params: The parameters of the circuit corresponding to the input. weight_params: The parameters of the circuit corresponding to the trainable weights. @@ -54,39 +55,31 @@ def __init__( sparse) output array. If no interpret function is passed, then an identity function will be used by this neural network. output_shape: The output shape of the custom interpretation - sampler_factory: Factory for sampler primitive - gradient_factory: String indicating pre-implemented gradient method or factory for - gradient class - input_gradients: to be added + gradient: An optional sampler gradient to be used for the backward pass. + input_gradients: Determines whether to compute gradients with respect to input data. + Note that this parameter is ``False`` by default, and must be explicitly set to + ``True`` for a proper gradient computation when using ``TorchConnector``. Raises: QiskitMachineLearningError: Invalid parameter values. """ - # set sampler --> make property? self.sampler = sampler - # use given gradient or default self.gradient = gradient + self._circuit = circuit.copy() + if len(self._circuit.clbits) == 0: + self._circuit.measure_all() + self._input_params = list(input_params or []) self._weight_params = list(weight_params or []) - # initialize gradient properties - self.input_gradients = input_gradients # TODO + self._input_gradients = input_gradients # sparse = False --> Hard coded TODO: look into sparse - - self._circuit = circuit.copy() - if len(self._circuit.clbits) == 0: - self._circuit.measure_all() # self._circuit_transpiled = False TODO: look into transpilation - # these original values may be re-used when a quantum instance is set, - # but initially it was None - self._original_output_shape = output_shape self._output_shape = output_shape self.set_interpret(interpret, output_shape) - # next line is required by pylint only - # self._interpret = interpret self._original_interpret = interpret # init super clas @@ -100,8 +93,8 @@ def __init__( def set_interpret( self, - interpret: Callable[[int], int| Tuple[int, ...]] | None = None, - output_shape: int | Tuple[int, ...] | None = None + interpret: Callable[[int], int| tuple[int, ...]] | None = None, + output_shape: int | tuple[int, ...] | None = None ) -> None: """Change 'interpret' and corresponding 'output_shape'. @@ -120,17 +113,16 @@ def set_interpret( # derive target values to be used in computations self._output_shape = self._compute_output_shape(interpret, output_shape) self._interpret = interpret if interpret is not None else lambda x: x - # self.output_shape = self._compute_output_shape(self._interpret, output_shape) def _compute_output_shape( self, - interpret: Callable[[int], int | Tuple[int, ...]] | None = None, - output_shape: int | Tuple[int, ...] | None = None - ) -> Tuple[int, ...]: + interpret: Callable[[int], int | tuple[int, ...]] | None = None, + output_shape: int | tuple[int, ...] | None = None + ) -> tuple[int, ...]: """Validate and compute the output shape.""" # this definition is required by mypy - output_shape_: Tuple[int, ...] = (-1,) + output_shape_: tuple[int, ...] = (-1,) if interpret is not None: if output_shape is None: @@ -156,9 +148,9 @@ def _compute_output_shape( def _preprocess( self, - input_data: List[float] | np.ndarray | float | None, - weights: List[float] | np.ndarray | float | None, - ) -> Tuple[List[float], int]: + input_data: list[float] | np.ndarray | float | None, + weights: list[float] | np.ndarray | float | None, + ) -> tuple[list[float], int]: """ Pre-processing during forward pass of the network. """ @@ -196,7 +188,9 @@ def _postprocess(self, num_samples, result): return prob def _forward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] + self, + input_data: np.ndarray | None, + weights: np.ndarray | None ) -> np.ndarray: """ Forward pass of the network. @@ -211,7 +205,7 @@ def _forward( return result - def _preprocess_gradient(self, input_data, weights): + def _preprocess_gradient(self, input_data: np.ndarray, weights: np.ndarray): """ Pre-processing during backward pass of the network. """ @@ -275,8 +269,10 @@ def _postprocess_gradient(self, num_samples, results): return input_grad, weights_grad def _backward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + self, + input_data: np.ndarray | None, + weights: np.ndarray | None + ) -> tuple[np.ndarray | None, np.ndarray | None]: """Backward pass of the network. """ @@ -294,3 +290,4 @@ def _backward( input_grad, weights_grad = self._postprocess_gradient(num_samples, results) return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector + From 8248138393b33c9af337169d7d7c2bc4605a1dbd Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 13:24:27 +0200 Subject: [PATCH 22/96] Add new unittests, fix code --- __init__.py | 0 .../neural_networks/__init__.py | 2 +- .../neural_networks/sampler_qnn.py | 96 +++-- test/neural_networks/test_sampler_qnn.py | 367 ++++++++++++------ 4 files changed, 310 insertions(+), 155 deletions(-) delete mode 100644 __init__.py diff --git a/__init__.py b/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/qiskit_machine_learning/neural_networks/__init__.py b/qiskit_machine_learning/neural_networks/__init__.py index 2f26e75e5..d897be5a8 100644 --- a/qiskit_machine_learning/neural_networks/__init__.py +++ b/qiskit_machine_learning/neural_networks/__init__.py @@ -75,5 +75,5 @@ "CircuitQNN", "EffectiveDimension", "LocalEffectiveDimension", - "SamplerQNN" + "SamplerQNN", ] diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index fc9b17597..245ad79d0 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -20,9 +20,10 @@ import numpy as np from qiskit.algorithms.gradients import BaseSamplerGradient +from qiskit.algorithms.gradients import ParamShiftSamplerGradient from qiskit.circuit import Parameter, QuantumCircuit from qiskit.primitives import BaseSampler -from qiskit_machine_learning.exceptions import QiskitMachineLearningError, QiskitError +from qiskit_machine_learning.exceptions import QiskitMachineLearningError from .neural_network import NeuralNetwork @@ -42,7 +43,7 @@ def __init__( interpret: Callable[[int], int | tuple[int, ...]] | None = None, output_shape: int | tuple[int, ...] | None = None, gradient: BaseSamplerGradient | None = None, - input_gradients: bool = False + input_gradients: bool = False, ): """ Args: @@ -62,8 +63,12 @@ def __init__( Raises: QiskitMachineLearningError: Invalid parameter values. """ + # set primitive self.sampler = sampler - self.gradient = gradient + + # set gradient + # TODO: provide default gradient? + self.gradient = gradient or ParamShiftSamplerGradient(self.sampler) self._circuit = circuit.copy() if len(self._circuit.clbits) == 0: @@ -72,29 +77,50 @@ def __init__( self._input_params = list(input_params or []) self._weight_params = list(weight_params or []) - self._input_gradients = input_gradients - - # sparse = False --> Hard coded TODO: look into sparse - # self._circuit_transpiled = False TODO: look into transpilation + # the final output shape will depend on the + # interpret method, and it must be set before + # applying the default to the latter + self.set_interpret_out_shape(interpret, output_shape) - self._output_shape = output_shape + self._input_gradients = input_gradients - self.set_interpret(interpret, output_shape) - self._original_interpret = interpret + # TODO: will primitives ever support sparse? + # TODO: look into custom transpilation + # TODO: sampling?? - # init super clas super().__init__( len(self._input_params), len(self._weight_params), - False, # sparse + False, # sparse self._output_shape, self._input_gradients, ) - def set_interpret( + @property + def circuit(self) -> QuantumCircuit: + """Returns the underlying quantum circuit.""" + return self._circuit + + @property + def input_params(self) -> Sequence: + """Returns the list of input parameters.""" + return self._input_params + + @property + def weight_params(self) -> Sequence: + """Returns the list of trainable weights parameters.""" + return self._weight_params + + @property + def interpret(self) -> Callable[[int], int | tuple[int, ...]] | None: + """Returns interpret function to be used by the neural network. If it is not set in + the constructor or can not be implicitly derived, then ``None`` is returned.""" + return self._interpret + + def set_interpret_out_shape( self, - interpret: Callable[[int], int| tuple[int, ...]] | None = None, - output_shape: int | tuple[int, ...] | None = None + interpret: Callable[[int], int | tuple[int, ...]] | None = None, + output_shape: int | tuple[int, ...] | None = None, ) -> None: """Change 'interpret' and corresponding 'output_shape'. @@ -106,10 +132,6 @@ def set_interpret( for more details. """ - # save original values - self._original_output_shape = output_shape - self._original_interpret = interpret - # derive target values to be used in computations self._output_shape = self._compute_output_shape(interpret, output_shape) self._interpret = interpret if interpret is not None else lambda x: x @@ -117,7 +139,7 @@ def set_interpret( def _compute_output_shape( self, interpret: Callable[[int], int | tuple[int, ...]] | None = None, - output_shape: int | tuple[int, ...] | None = None + output_shape: int | tuple[int, ...] | None = None, ) -> tuple[int, ...]: """Validate and compute the output shape.""" @@ -177,21 +199,19 @@ def _postprocess(self, num_samples, result): for i in range(num_samples): counts = result[i] - print(counts) shots = sum(counts.values()) # evaluate probabilities for b, v in counts.items(): - key = (i, int(self._interpret(b))) # type: ignore + key = self._interpret(b) + if isinstance(key, Integral): + key = (cast(int, key),) + key = (i, *key) # type: ignore prob[key] += v / shots return prob - def _forward( - self, - input_data: np.ndarray | None, - weights: np.ndarray | None - ) -> np.ndarray: + def _forward(self, input_data: np.ndarray | None, weights: np.ndarray | None) -> np.ndarray: """ Forward pass of the network. """ @@ -229,7 +249,11 @@ def _postprocess_gradient(self, num_samples, results): """ Post-processing during backward pass of the network. """ - input_grad = np.zeros((num_samples, *self._output_shape, self._num_inputs)) if self._input_gradients else None + input_grad = ( + np.zeros((num_samples, *self._output_shape, self._num_inputs)) + if self._input_gradients + else None + ) weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) if self._input_gradients: @@ -238,7 +262,6 @@ def _postprocess_gradient(self, num_samples, results): num_grad_vars = self._num_weights for sample in range(num_samples): - for i in range(num_grad_vars): grad = results.gradients[sample][i] for k in grad.keys(): @@ -269,25 +292,24 @@ def _postprocess_gradient(self, num_samples, results): return input_grad, weights_grad def _backward( - self, - input_data: np.ndarray | None, - weights: np.ndarray | None + self, input_data: np.ndarray | None, weights: np.ndarray | None ) -> tuple[np.ndarray | None, np.ndarray | None]: - """Backward pass of the network. - """ + """Backward pass of the network.""" # prepare parameters in the required format parameter_values, num_samples = self._preprocess_gradient(input_data, weights) if self._input_gradients: job = self.gradient.run([self._circuit] * num_samples, parameter_values) else: - job = self.gradient.run([self._circuit] * num_samples, parameter_values, - parameters=[self._circuit.parameters[self._num_inputs:]]) + job = self.gradient.run( + [self._circuit] * num_samples, + parameter_values, + parameters=[self._circuit.parameters[self._num_inputs :]] * num_samples, + ) results = job.result() input_grad, weights_grad = self._postprocess_gradient(num_samples, results) return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector - diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index 8fa01c3bd..cccd08f80 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -11,9 +11,14 @@ # that they have been altered from the originals. """Test Sampler QNN with Terra primitives.""" +import itertools +import unittest import numpy as np from test import QiskitMachineLearningTestCase +from ddt import ddt, data, idata, unpack + +from qiskit.circuit import QuantumCircuit, Parameter from qiskit.primitives import Sampler from qiskit.algorithms.gradients import ParamShiftSamplerGradient, FiniteDiffSamplerGradient from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap @@ -28,8 +33,16 @@ from test.connectors.test_torch import TestTorch import os -os.environ['KMP_DUPLICATE_LIB_OK']='True' +os.environ["KMP_DUPLICATE_LIB_OK"] = "True" + +DEFAULT = "default" +SHOTS = "shots" +SAMPLING = [True, False] # TODO +SAMPLERS = [DEFAULT, SHOTS] +INTERPRET_TYPES = [0, 1, 2] +BATCH_SIZES = [1, 2] +@ddt class TestSamplerQNN(QiskitMachineLearningTestCase): """Sampler QNN Tests.""" @@ -37,146 +50,266 @@ def setUp(self): super().setUp() algorithm_globals.random_seed = 12345 - # define test circuit - num_qubits = 3 - self.qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) - self.qi_qasm = QuantumInstance(Aer.get_backend("aer_simulator")) - self.sampler = Sampler() + # # define test circuit + # num_qubits = 3 + # self.qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) - def test_forward_pass(self): + # define feature map and ansatz + num_qubits = 2 + feature_map = ZZFeatureMap(num_qubits, reps=1) + var_form = RealAmplitudes(num_qubits, reps=1) - parity = lambda x: "{:b}".format(x).count("1") % 2 - output_shape = 2 # this is required in case of a callable with dense output + # construct circuit + self.qc = QuantumCircuit(num_qubits) + self.qc.append(feature_map, range(2)) + self.qc.append(var_form, range(2)) - circuit_qnn = CircuitQNN( - self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sparse=False, - interpret=parity, - output_shape=output_shape, - quantum_instance=self.qi_qasm, - ) + # store params + self.input_params = list(feature_map.parameters) + self.weight_params = list(var_form.parameters) - sampler_qnn = SamplerQNN( - sampler=self.sampler, - circuit=self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - interpret=parity, - output_shape=output_shape, - ) + # define interpret functions + def interpret_1d(x): + return sum((s == "1" for s in f"{x:0b}")) % 2 - inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - weights = algorithm_globals.random.random(circuit_qnn._num_weights) + self.interpret_1d = interpret_1d + self.output_shape_1d = 2 # takes values in {0, 1} - circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) - sampler_qnn_fwd = sampler_qnn.forward(inputs, weights) + def interpret_2d(x): + return np.array([self.interpret_1d(x), 2 * self.interpret_1d(x)]) - np.testing.assert_array_almost_equal( - np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 - ) + self.interpret_2d = interpret_2d + self.output_shape_2d = ( + 2, + 3, + ) # 1st dim. takes values in {0, 1} 2nd dim in {0, 1, 2} + + # define sampler primitives + self.sampler = Sampler() + self.sampler_shots = Sampler(options={"shots":100}) + + def _get_qnn(self, sampler_type, interpret_id): + """Construct QNN from configuration.""" - def test_backward_pass(self): + # get quantum instance + if sampler_type == SHOTS: + sampler = self.sampler_shots + elif sampler_type == DEFAULT: + sampler = self.sampler + else: + sampler = None - parity = lambda x: "{:b}".format(x).count("1") % 2 - output_shape = 2 # this is required in case of a callable with dense output - from qiskit.opflow import Gradient - circuit_qnn = CircuitQNN( + # get interpret setting + interpret = None + output_shape = None + if interpret_id == 1: + interpret = self.interpret_1d + output_shape = self.output_shape_1d + elif interpret_id == 2: + interpret = self.interpret_2d + output_shape = self.output_shape_2d + + # construct QNN + qnn = SamplerQNN( + sampler, self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sparse=False, - interpret=parity, + input_params=self.input_params, + weight_params=self.weight_params, + interpret=interpret, output_shape=output_shape, - quantum_instance=self.qi_qasm, - gradient=Gradient("param_shift"), ) + return qnn - sampler_qnn = SamplerQNN( - sampler=self.sampler, - circuit=self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - interpret=parity, - output_shape=output_shape, - gradient=ParamShiftSamplerGradient(self.sampler), - ) + def _verify_qnn( + self, + qnn: CircuitQNN, + sampler_type: str, + batch_size: int, + ) -> None: + """ + Verifies that a QNN functions correctly - inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - weights = algorithm_globals.random.random(circuit_qnn._num_weights) + Args: + qnn: a QNN to check + sampler_type: + batch_size: - circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) - sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + Returns: + None. + """ + input_data = np.zeros((batch_size, qnn.num_inputs)) + weights = np.zeros(qnn.num_weights) - print(circuit_qnn_fwd) - print(sampler_qnn_fwd) - np.testing.assert_array_almost_equal( - np.asarray(sampler_qnn_fwd[1]), np.asarray(circuit_qnn_fwd[1]), 0.1 - ) + # evaluate QNN forward pass + result = qnn.forward(input_data, weights) + self.assertTrue(isinstance(result, np.ndarray)) + # check forward result shape + self.assertEqual(result.shape, (batch_size, *qnn.output_shape)) - def test_input_gradients(self): + # evaluate QNN backward pass + input_grad, weights_grad = qnn.backward(input_data, weights) - parity = lambda x: "{:b}".format(x).count("1") % 2 - output_shape = 2 # this is required in case of a callable with dense output - from qiskit.opflow import Gradient - circuit_qnn = CircuitQNN( - self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sparse=False, - interpret=parity, - output_shape=output_shape, - quantum_instance=self.qi_qasm, - gradient=Gradient("param_shift"), - input_gradients=True + self.assertIsNone(input_grad) + # verify that input gradients are None if turned off + self.assertEqual( + weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights) ) - sampler_qnn = SamplerQNN( - sampler=self.sampler, - circuit=self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - interpret=parity, - output_shape=output_shape, - gradient=ParamShiftSamplerGradient(self.sampler), - input_gradients=True - - ) + # verify that input gradients are not None if turned on + qnn.input_gradients = True + input_grad, weights_grad = qnn.backward(input_data, weights) - inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - weights = algorithm_globals.random.random(circuit_qnn._num_weights) + self.assertEqual(input_grad.shape, (batch_size, *qnn.output_shape, qnn.num_inputs)) + self.assertEqual( + weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights) + ) - circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) - sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + @idata(itertools.product(SAMPLERS, INTERPRET_TYPES, BATCH_SIZES)) + @unpack + def test_sampler_qnn( + self, sampler_type, interpret_type, batch_size + ): + """Sampler QNN Test.""" + qnn = self._get_qnn(sampler_type, interpret_type) + self._verify_qnn(qnn, sampler_type, batch_size) - print(circuit_qnn_fwd) - print(sampler_qnn_fwd) - np.testing.assert_array_almost_equal( - np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 - ) - from qiskit_machine_learning.connectors import TorchConnector - import torch - - model = TorchConnector(sampler_qnn) - func = TorchConnector._TorchNNFunction.apply # (input, weights, qnn) - input_data = ( - torch.randn( - model.neural_network.num_inputs, - dtype=torch.double, - requires_grad=True, - ), - torch.randn( - model.neural_network.num_weights, - dtype=torch.double, - requires_grad=True, - ), - model.neural_network, - False, - ) - test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) # type: ignore - self.assertTrue(test) + # + # def test_forward_pass(self): + # + # parity = lambda x: "{:b}".format(x).count("1") % 2 + # output_shape = 2 # this is required in case of a callable with dense output + # + # circuit_qnn = CircuitQNN( + # self.qc, + # input_params=self.qc.parameters[:3], + # weight_params=self.qc.parameters[3:], + # sparse=False, + # interpret=parity, + # output_shape=output_shape, + # quantum_instance=self.qi_qasm, + # ) + # + # sampler_qnn = SamplerQNN( + # sampler=self.sampler, + # circuit=self.qc, + # input_params=self.qc.parameters[:3], + # weight_params=self.qc.parameters[3:], + # interpret=parity, + # output_shape=output_shape, + # ) + # + # inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + # weights = algorithm_globals.random.random(circuit_qnn._num_weights) + # + # circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) + # sampler_qnn_fwd = sampler_qnn.forward(inputs, weights) + # + # np.testing.assert_array_almost_equal( + # np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 + # ) + # + # def test_backward_pass(self): + # + # parity = lambda x: "{:b}".format(x).count("1") % 2 + # output_shape = 2 # this is required in case of a callable with dense output + # from qiskit.opflow import Gradient + # + # circuit_qnn = CircuitQNN( + # self.qc, + # input_params=self.qc.parameters[:3], + # weight_params=self.qc.parameters[3:], + # sparse=False, + # interpret=parity, + # output_shape=output_shape, + # quantum_instance=self.qi_qasm, + # gradient=Gradient("param_shift"), + # ) + # + # sampler_qnn = SamplerQNN( + # sampler=self.sampler, + # circuit=self.qc, + # input_params=self.qc.parameters[:3], + # weight_params=self.qc.parameters[3:], + # interpret=parity, + # output_shape=output_shape, + # gradient=ParamShiftSamplerGradient(self.sampler), + # ) + # + # inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + # weights = algorithm_globals.random.random(circuit_qnn._num_weights) + # + # circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) + # sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + # + # print(circuit_qnn_fwd) + # print(sampler_qnn_fwd) + # np.testing.assert_array_almost_equal( + # np.asarray(sampler_qnn_fwd[1]), np.asarray(circuit_qnn_fwd[1]), 0.1 + # ) + # + # def test_input_gradients(self): + # + # parity = lambda x: "{:b}".format(x).count("1") % 2 + # output_shape = 2 # this is required in case of a callable with dense output + # from qiskit.opflow import Gradient + # + # circuit_qnn = CircuitQNN( + # self.qc, + # input_params=self.qc.parameters[:3], + # weight_params=self.qc.parameters[3:], + # sparse=False, + # interpret=parity, + # output_shape=output_shape, + # quantum_instance=self.qi_qasm, + # gradient=Gradient("param_shift"), + # input_gradients=True, + # ) + # + # sampler_qnn = SamplerQNN( + # sampler=self.sampler, + # circuit=self.qc, + # input_params=self.qc.parameters[:3], + # weight_params=self.qc.parameters[3:], + # interpret=parity, + # output_shape=output_shape, + # gradient=ParamShiftSamplerGradient(self.sampler), + # input_gradients=True, + # ) + # + # inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + # weights = algorithm_globals.random.random(circuit_qnn._num_weights) + # + # circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) + # sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + # + # print(circuit_qnn_fwd) + # print(sampler_qnn_fwd) + # np.testing.assert_array_almost_equal( + # np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 + # ) + # + # from qiskit_machine_learning.connectors import TorchConnector + # import torch + # + # model = TorchConnector(sampler_qnn) + # func = TorchConnector._TorchNNFunction.apply # (input, weights, qnn) + # input_data = ( + # torch.randn( + # model.neural_network.num_inputs, + # dtype=torch.double, + # requires_grad=True, + # ), + # torch.randn( + # model.neural_network.num_weights, + # dtype=torch.double, + # requires_grad=True, + # ), + # model.neural_network, + # False, + # ) + # test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) # type: ignore + # self.assertTrue(test) # def test_torch_connector(self): # from qiskit_machine_learning.connectors import TorchConnector From f4f1771f534d0f03f1c1bd570645e665daaf8dab Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 13:33:31 +0200 Subject: [PATCH 23/96] Add gradient unit test --- test/neural_networks/test_sampler_qnn.py | 64 ++++++++++++++++++++---- 1 file changed, 53 insertions(+), 11 deletions(-) diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index cccd08f80..26b25a56a 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -37,11 +37,12 @@ DEFAULT = "default" SHOTS = "shots" -SAMPLING = [True, False] # TODO +SAMPLING = [True, False] # TODO SAMPLERS = [DEFAULT, SHOTS] INTERPRET_TYPES = [0, 1, 2] BATCH_SIZES = [1, 2] + @ddt class TestSamplerQNN(QiskitMachineLearningTestCase): """Sampler QNN Tests.""" @@ -86,7 +87,7 @@ def interpret_2d(x): # define sampler primitives self.sampler = Sampler() - self.sampler_shots = Sampler(options={"shots":100}) + self.sampler_shots = Sampler(options={"shots": 100}) def _get_qnn(self, sampler_type, interpret_id): """Construct QNN from configuration.""" @@ -151,28 +152,69 @@ def _verify_qnn( self.assertIsNone(input_grad) # verify that input gradients are None if turned off - self.assertEqual( - weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights) - ) + self.assertEqual(weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)) # verify that input gradients are not None if turned on qnn.input_gradients = True input_grad, weights_grad = qnn.backward(input_data, weights) self.assertEqual(input_grad.shape, (batch_size, *qnn.output_shape, qnn.num_inputs)) - self.assertEqual( - weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights) - ) + self.assertEqual(weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)) @idata(itertools.product(SAMPLERS, INTERPRET_TYPES, BATCH_SIZES)) @unpack - def test_sampler_qnn( - self, sampler_type, interpret_type, batch_size - ): + def test_sampler_qnn(self, sampler_type, interpret_type, batch_size): """Sampler QNN Test.""" qnn = self._get_qnn(sampler_type, interpret_type) self._verify_qnn(qnn, sampler_type, batch_size) + @idata(itertools.product(INTERPRET_TYPES, BATCH_SIZES)) + def test_sampler_qnn_gradient(self, config): + """Circuit QNN Sampler Test.""" + + # get configuration + interpret_id, batch_size = config + + # get QNN + qnn = self._get_qnn(DEFAULT, interpret_id) + + # set input gradients to True + qnn.input_gradients = True + input_data = np.ones((batch_size, qnn.num_inputs)) + weights = np.ones(qnn.num_weights) + input_grad, weights_grad = qnn.backward(input_data, weights) + + # test input gradients + eps = 1e-2 + for k in range(qnn.num_inputs): + delta = np.zeros(input_data.shape) + delta[:, k] = eps + + f_1 = qnn.forward(input_data + delta, weights) + f_2 = qnn.forward(input_data - delta, weights) + + grad = (f_1 - f_2) / (2 * eps) + input_grad_ = input_grad.reshape((batch_size, -1, qnn.num_inputs))[:, :, k].reshape( + grad.shape + ) + diff = input_grad_ - grad + self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3) + + # test weight gradients + eps = 1e-2 + for k in range(qnn.num_weights): + delta = np.zeros(weights.shape) + delta[k] = eps + + f_1 = qnn.forward(input_data, weights + delta) + f_2 = qnn.forward(input_data, weights - delta) + + grad = (f_1 - f_2) / (2 * eps) + weights_grad_ = weights_grad.reshape((batch_size, -1, qnn.num_weights))[ + :, :, k + ].reshape(grad.shape) + diff = weights_grad_ - grad + self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3) # # def test_forward_pass(self): From 7bf715d993449703315fcbd1b0676242234f8d9a Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 13:52:12 +0200 Subject: [PATCH 24/96] Add torch tests --- test/connectors/test_torch_networks.py | 32 +++- test/neural_networks/test_sampler_qnn.py | 194 +++++++---------------- 2 files changed, 82 insertions(+), 144 deletions(-) diff --git a/test/connectors/test_torch_networks.py b/test/connectors/test_torch_networks.py index c3c2cbf48..d6c7a707f 100644 --- a/test/connectors/test_torch_networks.py +++ b/test/connectors/test_torch_networks.py @@ -19,9 +19,10 @@ from qiskit import QuantumCircuit from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap -from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN, NeuralNetwork -from qiskit_machine_learning.connectors import TorchConnector +from qiskit.primitives import Sampler +from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN, NeuralNetwork, SamplerQNN +from qiskit_machine_learning.connectors import TorchConnector @ddt class TestTorchNetworks(TestTorch): @@ -86,7 +87,29 @@ def _create_opflow_qnn(self) -> TwoLayerQNN: ) return qnn - @idata(["opflow", "circuit_qnn"]) + def _create_sampler_qnn(self) -> SamplerQNN: + output_shape, interpret = 2, lambda x: f"{x:b}".count("1") % 2 + num_inputs = 2 + + feature_map = ZZFeatureMap(num_inputs) + ansatz = RealAmplitudes(num_inputs, entanglement="linear", reps=1) + + qc = QuantumCircuit(num_inputs) + qc.append(feature_map, range(num_inputs)) + qc.append(ansatz, range(num_inputs)) + + qnn = SamplerQNN( + Sampler(), + qc, + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + input_gradients=True, # for hybrid qnn + interpret=interpret, + output_shape=output_shape, + ) + return qnn + + @idata(["opflow", "circuit_qnn", "sampler_qnn"]) def test_hybrid_batch_gradients(self, qnn_type: str): """Test gradient back-prop for batch input in a qnn.""" import torch @@ -100,6 +123,9 @@ def test_hybrid_batch_gradients(self, qnn_type: str): elif qnn_type == "circuit_qnn": qnn = self._create_circuit_qnn() output_size = 2 + elif qnn_type == "sampler_qnn": + qnn = self._create_sampler_qnn() + output_size = 2 else: raise ValueError("Unsupported QNN type") diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index 26b25a56a..b437da6ee 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -39,7 +39,7 @@ SHOTS = "shots" SAMPLING = [True, False] # TODO SAMPLERS = [DEFAULT, SHOTS] -INTERPRET_TYPES = [0, 1, 2] +INTERPRET_TYPES = [2] BATCH_SIZES = [1, 2] @@ -170,7 +170,7 @@ def test_sampler_qnn(self, sampler_type, interpret_type, batch_size): @idata(itertools.product(INTERPRET_TYPES, BATCH_SIZES)) def test_sampler_qnn_gradient(self, config): - """Circuit QNN Sampler Test.""" + """Sampler QNN Gradient Test.""" # get configuration interpret_id, batch_size = config @@ -216,142 +216,54 @@ def test_sampler_qnn_gradient(self, config): diff = weights_grad_ - grad self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3) - # - # def test_forward_pass(self): - # - # parity = lambda x: "{:b}".format(x).count("1") % 2 - # output_shape = 2 # this is required in case of a callable with dense output - # - # circuit_qnn = CircuitQNN( - # self.qc, - # input_params=self.qc.parameters[:3], - # weight_params=self.qc.parameters[3:], - # sparse=False, - # interpret=parity, - # output_shape=output_shape, - # quantum_instance=self.qi_qasm, - # ) - # - # sampler_qnn = SamplerQNN( - # sampler=self.sampler, - # circuit=self.qc, - # input_params=self.qc.parameters[:3], - # weight_params=self.qc.parameters[3:], - # interpret=parity, - # output_shape=output_shape, - # ) - # - # inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - # weights = algorithm_globals.random.random(circuit_qnn._num_weights) - # - # circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) - # sampler_qnn_fwd = sampler_qnn.forward(inputs, weights) - # - # np.testing.assert_array_almost_equal( - # np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 - # ) - # - # def test_backward_pass(self): - # - # parity = lambda x: "{:b}".format(x).count("1") % 2 - # output_shape = 2 # this is required in case of a callable with dense output - # from qiskit.opflow import Gradient - # - # circuit_qnn = CircuitQNN( - # self.qc, - # input_params=self.qc.parameters[:3], - # weight_params=self.qc.parameters[3:], - # sparse=False, - # interpret=parity, - # output_shape=output_shape, - # quantum_instance=self.qi_qasm, - # gradient=Gradient("param_shift"), - # ) - # - # sampler_qnn = SamplerQNN( - # sampler=self.sampler, - # circuit=self.qc, - # input_params=self.qc.parameters[:3], - # weight_params=self.qc.parameters[3:], - # interpret=parity, - # output_shape=output_shape, - # gradient=ParamShiftSamplerGradient(self.sampler), - # ) - # - # inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - # weights = algorithm_globals.random.random(circuit_qnn._num_weights) - # - # circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) - # sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) - # - # print(circuit_qnn_fwd) - # print(sampler_qnn_fwd) - # np.testing.assert_array_almost_equal( - # np.asarray(sampler_qnn_fwd[1]), np.asarray(circuit_qnn_fwd[1]), 0.1 - # ) - # - # def test_input_gradients(self): - # - # parity = lambda x: "{:b}".format(x).count("1") % 2 - # output_shape = 2 # this is required in case of a callable with dense output - # from qiskit.opflow import Gradient - # - # circuit_qnn = CircuitQNN( - # self.qc, - # input_params=self.qc.parameters[:3], - # weight_params=self.qc.parameters[3:], - # sparse=False, - # interpret=parity, - # output_shape=output_shape, - # quantum_instance=self.qi_qasm, - # gradient=Gradient("param_shift"), - # input_gradients=True, - # ) - # - # sampler_qnn = SamplerQNN( - # sampler=self.sampler, - # circuit=self.qc, - # input_params=self.qc.parameters[:3], - # weight_params=self.qc.parameters[3:], - # interpret=parity, - # output_shape=output_shape, - # gradient=ParamShiftSamplerGradient(self.sampler), - # input_gradients=True, - # ) - # - # inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - # weights = algorithm_globals.random.random(circuit_qnn._num_weights) - # - # circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) - # sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) - # - # print(circuit_qnn_fwd) - # print(sampler_qnn_fwd) - # np.testing.assert_array_almost_equal( - # np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 - # ) - # - # from qiskit_machine_learning.connectors import TorchConnector - # import torch - # - # model = TorchConnector(sampler_qnn) - # func = TorchConnector._TorchNNFunction.apply # (input, weights, qnn) - # input_data = ( - # torch.randn( - # model.neural_network.num_inputs, - # dtype=torch.double, - # requires_grad=True, - # ), - # torch.randn( - # model.neural_network.num_weights, - # dtype=torch.double, - # requires_grad=True, - # ), - # model.neural_network, - # False, - # ) - # test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) # type: ignore - # self.assertTrue(test) - - # def test_torch_connector(self): - # from qiskit_machine_learning.connectors import TorchConnector + + def test_circuit_vs_sampler_qnn(self): + """Circuit vs Sampler QNN Test. To be removed once CircuitQNN is deprecated""" + from qiskit.opflow import Gradient + import importlib + aer = importlib.import_module("qiskit.providers.aer") + + parity = lambda x: "{:b}".format(x).count("1") % 2 + output_shape = 2 # this is required in case of a callable with dense output + + qi_qasm = QuantumInstance( + aer.AerSimulator(), + shots=100, + seed_simulator=algorithm_globals.random_seed, + seed_transpiler=algorithm_globals.random_seed, + ) + + circuit_qnn = CircuitQNN( + self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sparse=False, + interpret=parity, + output_shape=output_shape, + quantum_instance=qi_qasm, + gradient=Gradient("param_shift"), + input_gradients=True, + ) + + sampler_qnn = SamplerQNN( + sampler=self.sampler, + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + interpret=parity, + output_shape=output_shape, + gradient=ParamShiftSamplerGradient(self.sampler), + input_gradients=True, + ) + + inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) + weights = algorithm_globals.random.random(circuit_qnn._num_weights) + + circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) + sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) + + print(circuit_qnn_fwd) + print(sampler_qnn_fwd) + np.testing.assert_array_almost_equal( + np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 + ) From aeb05f075a46915d654f4b8a6723cd87fc134206 Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Mon, 10 Oct 2022 13:53:51 +0200 Subject: [PATCH 25/96] Remove unwanted change circuitQNN --- qiskit_machine_learning/neural_networks/circuit_qnn.py | 1 + 1 file changed, 1 insertion(+) diff --git a/qiskit_machine_learning/neural_networks/circuit_qnn.py b/qiskit_machine_learning/neural_networks/circuit_qnn.py index ff64ed1ea..21d029157 100644 --- a/qiskit_machine_learning/neural_networks/circuit_qnn.py +++ b/qiskit_machine_learning/neural_networks/circuit_qnn.py @@ -490,6 +490,7 @@ def _probability_gradients( num_grad_vars = self._num_inputs + self._num_weights else: num_grad_vars = self._num_weights + # construct gradients for sample in range(num_samples): for i in range(num_grad_vars): From f727ea052d8805a42439e2635402054193270651 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 13:55:30 +0200 Subject: [PATCH 26/96] Remove utils --- qiskit_machine_learning/utils/utils.py | 20 -------------------- 1 file changed, 20 deletions(-) delete mode 100644 qiskit_machine_learning/utils/utils.py diff --git a/qiskit_machine_learning/utils/utils.py b/qiskit_machine_learning/utils/utils.py deleted file mode 100644 index 901658f3c..000000000 --- a/qiskit_machine_learning/utils/utils.py +++ /dev/null @@ -1,20 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2022. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -import numpy as np - - -def make_2d(array: np.ndarray, n_copies: int): - """ - Takes a 1D numpy array and copies n times it along a second axis. - """ - return np.repeat(array[np.newaxis, :], n_copies, axis=0) From 0a104ae199ed7343f2245fde2896ac3a4e24d2ed Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 14:11:59 +0200 Subject: [PATCH 27/96] Fix style, lint --- test/connectors/test_torch_networks.py | 8 ++++++- test/neural_networks/test_sampler_qnn.py | 27 ++++++++---------------- 2 files changed, 16 insertions(+), 19 deletions(-) diff --git a/test/connectors/test_torch_networks.py b/test/connectors/test_torch_networks.py index d6c7a707f..d942f3c1f 100644 --- a/test/connectors/test_torch_networks.py +++ b/test/connectors/test_torch_networks.py @@ -21,9 +21,15 @@ from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap from qiskit.primitives import Sampler -from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN, NeuralNetwork, SamplerQNN +from qiskit_machine_learning.neural_networks import ( + CircuitQNN, + TwoLayerQNN, + NeuralNetwork, + SamplerQNN, +) from qiskit_machine_learning.connectors import TorchConnector + @ddt class TestTorchNetworks(TestTorch): """Base class for hybrid PyTorch network tests.""" diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index b437da6ee..50fb41a78 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -11,29 +11,24 @@ # that they have been altered from the originals. """Test Sampler QNN with Terra primitives.""" + +from test import QiskitMachineLearningTestCase + import itertools -import unittest import numpy as np -from test import QiskitMachineLearningTestCase -from ddt import ddt, data, idata, unpack +from ddt import ddt, idata, unpack -from qiskit.circuit import QuantumCircuit, Parameter +from qiskit.circuit import QuantumCircuit from qiskit.primitives import Sampler -from qiskit.algorithms.gradients import ParamShiftSamplerGradient, FiniteDiffSamplerGradient +from qiskit.algorithms.gradients import ParamShiftSamplerGradient from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap from qiskit.utils import QuantumInstance, algorithm_globals -from qiskit import Aer -from qiskit.utils import QuantumInstance from qiskit_machine_learning.neural_networks import CircuitQNN from qiskit_machine_learning.neural_networks.sampler_qnn import SamplerQNN algorithm_globals.random_seed = 42 -from test.connectors.test_torch import TestTorch -import os - -os.environ["KMP_DUPLICATE_LIB_OK"] = "True" DEFAULT = "default" SHOTS = "shots" @@ -124,7 +119,6 @@ def _get_qnn(self, sampler_type, interpret_id): def _verify_qnn( self, qnn: CircuitQNN, - sampler_type: str, batch_size: int, ) -> None: """ @@ -132,8 +126,7 @@ def _verify_qnn( Args: qnn: a QNN to check - sampler_type: - batch_size: + batch_size: batch size Returns: None. @@ -166,7 +159,7 @@ def _verify_qnn( def test_sampler_qnn(self, sampler_type, interpret_type, batch_size): """Sampler QNN Test.""" qnn = self._get_qnn(sampler_type, interpret_type) - self._verify_qnn(qnn, sampler_type, batch_size) + self._verify_qnn(qnn, batch_size) @idata(itertools.product(INTERPRET_TYPES, BATCH_SIZES)) def test_sampler_qnn_gradient(self, config): @@ -216,11 +209,11 @@ def test_sampler_qnn_gradient(self, config): diff = weights_grad_ - grad self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3) - def test_circuit_vs_sampler_qnn(self): """Circuit vs Sampler QNN Test. To be removed once CircuitQNN is deprecated""" from qiskit.opflow import Gradient import importlib + aer = importlib.import_module("qiskit.providers.aer") parity = lambda x: "{:b}".format(x).count("1") % 2 @@ -262,8 +255,6 @@ def test_circuit_vs_sampler_qnn(self): circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) - print(circuit_qnn_fwd) - print(sampler_qnn_fwd) np.testing.assert_array_almost_equal( np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 ) From c9abd9182626a51be0785fe1edb232d65c7192c0 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 17:47:14 +0200 Subject: [PATCH 28/96] Add VQC --- .../algorithms/classifiers/vqc.py | 36 ++++-- .../neural_networks/sampler_qnn.py | 11 +- test/algorithms/classifiers/test_vqc.py | 115 ++++++++++++++---- 3 files changed, 124 insertions(+), 38 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index d08748fc8..5f57f9998 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -20,8 +20,9 @@ from qiskit.providers import Backend from qiskit.utils import QuantumInstance from qiskit.algorithms.optimizers import Optimizer, OptimizerResult +from qiskit.primitives import BaseSampler -from ...neural_networks import CircuitQNN +from ...neural_networks import CircuitQNN, SamplerQNN from ...utils import derive_num_qubits_feature_map_ansatz from ...utils.loss_functions import Loss @@ -47,6 +48,7 @@ class VQC(NeuralNetworkClassifier): def __init__( self, + sampler: BaseSampler = None, num_qubits: int | None = None, feature_map: QuantumCircuit | None = None, ansatz: QuantumCircuit | None = None, @@ -100,16 +102,28 @@ def __init__( self._circuit.compose(self.feature_map, inplace=True) self._circuit.compose(self.ansatz, inplace=True) - # construct circuit QNN - neural_network = CircuitQNN( - self._circuit, - input_params=self.feature_map.parameters, - weight_params=self.ansatz.parameters, - interpret=self._get_interpret(2), - output_shape=2, - quantum_instance=quantum_instance, - input_gradients=False, - ) + if sampler is None: + # construct circuit QNN + neural_network = CircuitQNN( + self._circuit, + input_params=self.feature_map.parameters, + weight_params=self.ansatz.parameters, + interpret=self._get_interpret(2), + output_shape=2, + quantum_instance=quantum_instance, + input_gradients=False, + ) + else: + # construct sampler QNN + neural_network = SamplerQNN( + sampler, + self._circuit, + input_params=self.feature_map.parameters, + weight_params=self.ansatz.parameters, + interpret=self._get_interpret(2), + output_shape=2, + input_gradients=False, + ) super().__init__( neural_network=neural_network, diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 245ad79d0..e9149d41b 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -19,8 +19,7 @@ from typing import Callable, cast, Iterable, Sequence import numpy as np -from qiskit.algorithms.gradients import BaseSamplerGradient -from qiskit.algorithms.gradients import ParamShiftSamplerGradient +from qiskit.algorithms.gradients import BaseSamplerGradient, ParamShiftSamplerGradient from qiskit.circuit import Parameter, QuantumCircuit from qiskit.primitives import BaseSampler from qiskit_machine_learning.exceptions import QiskitMachineLearningError @@ -80,7 +79,7 @@ def __init__( # the final output shape will depend on the # interpret method, and it must be set before # applying the default to the latter - self.set_interpret_out_shape(interpret, output_shape) + self.set_interpret(interpret, output_shape) self._input_gradients = input_gradients @@ -117,7 +116,7 @@ def interpret(self) -> Callable[[int], int | tuple[int, ...]] | None: the constructor or can not be implicitly derived, then ``None`` is returned.""" return self._interpret - def set_interpret_out_shape( + def set_interpret( self, interpret: Callable[[int], int | tuple[int, ...]] | None = None, output_shape: int | tuple[int, ...] | None = None, @@ -143,8 +142,8 @@ def _compute_output_shape( ) -> tuple[int, ...]: """Validate and compute the output shape.""" - # this definition is required by mypy - output_shape_: tuple[int, ...] = (-1,) + # # this definition is required by mypy + # output_shape_: tuple[int, ...] = (-1,) if interpret is not None: if output_shape is None: diff --git a/test/algorithms/classifiers/test_vqc.py b/test/algorithms/classifiers/test_vqc.py index 4895327c4..cdef75ea1 100644 --- a/test/algorithms/classifiers/test_vqc.py +++ b/test/algorithms/classifiers/test_vqc.py @@ -31,11 +31,12 @@ from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap, ZFeatureMap from qiskit.utils import QuantumInstance, algorithm_globals, optionals +from qiskit.primitives import Sampler from qiskit_machine_learning.algorithms import VQC from qiskit_machine_learning.exceptions import QiskitMachineLearningError -QUANTUM_INSTANCES = ["statevector", "qasm"] +QUANTUM_INSTANCES = ["statevector", "sampler", "qasm"] NUM_QUBITS_LIST = [2, None] FEATURE_MAPS = ["zz_feature_map", None] ANSATZES = ["real_amplitudes", None] @@ -90,11 +91,12 @@ def setUp(self): seed_simulator=algorithm_globals.random_seed, seed_transpiler=algorithm_globals.random_seed, ) - + sampler = Sampler() # We want string keys to ensure DDT-generated tests have meaningful names. self.properties = { "statevector": statevector, "qasm": qasm, + "sampler": sampler, "bfgs": L_BFGS_B(maxiter=5), "cobyla": COBYLA(maxiter=25), "real_amplitudes": RealAmplitudes(num_qubits=2, reps=1), @@ -119,8 +121,13 @@ def test_VQC(self, q_i, num_qubits, f_m, ans, opt, d_s): self.skipTest( "At least one of num_qubits, feature_map, or ansatz must be set by the user." ) + if q_i != "sampler": + sampler = None + quantum_instance = self.properties.get(q_i) + else: + sampler = self.properties.get(q_i) + quantum_instance = None - quantum_instance = self.properties.get(q_i) feature_map = self.properties.get(f_m) optimizer = self.properties.get(opt) ansatz = self.properties.get(ans) @@ -129,6 +136,7 @@ def test_VQC(self, q_i, num_qubits, f_m, ans, opt, d_s): initial_point = np.array([0.5] * ansatz.num_parameters) if ansatz is not None else None classifier = VQC( + sampler=sampler, quantum_instance=quantum_instance, num_qubits=num_qubits, feature_map=feature_map, @@ -148,27 +156,45 @@ def test_VQC(self, q_i, num_qubits, f_m, ans, opt, d_s): # the predicted value should be in the labels self.assertTrue(np.all(predict == unique_labels, axis=1).any()) - def test_VQC_non_parameterized(self): + @idata(QUANTUM_INSTANCES[:-1]) + def test_VQC_non_parameterized(self, test): """ Test VQC without an optimizer set. """ + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + classifier = VQC( + sampler=sampler, num_qubits=2, optimizer=None, - quantum_instance=self.properties.get("statevector"), + quantum_instance=quantum_instance, ) dataset = self.properties.get("binary") classifier.fit(dataset.x, dataset.y) score = classifier.score(dataset.x, dataset.y) self.assertGreater(score, 0.5) - @idata(DATASETS) - def test_warm_start(self, d_s): + @idata(itertools.product(DATASETS, QUANTUM_INSTANCES[:-1])) + @unpack + def test_warm_start(self, d_s, test): """Test VQC when training from a warm start.""" + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + classifier = VQC( + sampler=sampler, feature_map=self.properties.get("zz_feature_map"), - quantum_instance=self.properties.get("statevector"), + quantum_instance=quantum_instance, warm_start=True, ) dataset = self.properties.get(d_s) @@ -198,19 +224,28 @@ def wrapper(num_classes): return wrapper - def test_batches_with_incomplete_labels(self): + @idata(QUANTUM_INSTANCES[:-1]) + def test_batches_with_incomplete_labels(self, test): """Test VQC when targets are one-hot and some batches don't have all possible labels.""" + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + # Generate data with batches that have incomplete labels. x = algorithm_globals.random.random((6, 2)) y = np.asarray([0, 0, 1, 1, 2, 2]) y_one_hot = OneHotEncoder().fit_transform(y.reshape(-1, 1)) classifier = VQC( + sampler=sampler, feature_map=self.properties.get("zz_feature_map"), ansatz=self.properties.get("real_amplitudes"), warm_start=True, - quantum_instance=self.properties.get("statevector"), + quantum_instance=quantum_instance, ) classifier._get_interpret = self._get_num_classes(classifier._get_interpret) @@ -229,29 +264,43 @@ def test_batches_with_incomplete_labels(self): with self.subTest("Check correct number of classes is used to build CircuitQNN."): self.assertTrue((np.asarray(self.num_classes_by_batch) == 3).all()) - def test_multilabel_targets_raise_an_error(self): + @idata(QUANTUM_INSTANCES[:-1]) + def test_multilabel_targets_raise_an_error(self, test): """Tests VQC multi-label input raises an error.""" + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + # Generate multi-label data. x = algorithm_globals.random.random((3, 2)) y = np.asarray([[1, 1, 0], [1, 0, 1], [0, 1, 1]]) - classifier = VQC(num_qubits=2, quantum_instance=self.properties.get("statevector")) + classifier = VQC(sampler=sampler, num_qubits=2, quantum_instance=quantum_instance) with self.assertRaises(QiskitMachineLearningError): classifier.fit(x, y) - def test_changing_classes_raises_error(self): + @idata(QUANTUM_INSTANCES[:-1]) + def test_changing_classes_raises_error(self, test): """Tests VQC raises an error when fitting new data with a different number of classes.""" + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + targets1 = np.asarray([[0, 0, 1], [0, 1, 0]]) targets2 = np.asarray([[0, 1], [1, 0]]) features1 = algorithm_globals.random.random((len(targets1), 2)) features2 = algorithm_globals.random.random((len(targets2), 2)) classifier = VQC( - num_qubits=2, - warm_start=True, - quantum_instance=self.properties.get("statevector"), + sampler=sampler, num_qubits=2, warm_start=True, quantum_instance=quantum_instance ) classifier.fit(features1, targets1) with self.assertRaises(QiskitMachineLearningError): @@ -261,6 +310,9 @@ def test_changing_classes_raises_error(self): @unpack def test_sparse_arrays(self, q_i, loss): """Tests VQC on sparse features and labels.""" + if q_i == "sampler": + self.skipTest("skipping test because SamplerQNN does not support sparse arrays") + quantum_instance = self.properties.get(q_i) classifier = VQC(num_qubits=2, loss=loss, quantum_instance=quantum_instance) x = scipy.sparse.csr_matrix([[0, 0], [1, 1]]) @@ -271,12 +323,22 @@ def test_sparse_arrays(self, q_i, loss): score = classifier.score(x, y) self.assertGreaterEqual(score, 0.5) - def test_categorical(self): + @idata(QUANTUM_INSTANCES[:-1]) + def test_categorical(self, test): """Test VQC on categorical labels.""" + + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + classifier = VQC( + sampler=sampler, num_qubits=2, optimizer=COBYLA(25), - quantum_instance=self.properties.get("statevector"), + quantum_instance=quantum_instance, ) dataset = self.properties.get("no_one_hot") features = dataset.x @@ -291,14 +353,24 @@ def test_categorical(self): predict = classifier.predict(features[0, :]) self.assertIn(predict, ["A", "B"]) - def test_circuit_extensions(self): + @idata(QUANTUM_INSTANCES[:-1]) + def test_circuit_extensions(self, test): """Test VQC when the number of qubits is different compared to the feature map/ansatz.""" + + if test != "sampler": + sampler = None + quantum_instance = self.properties.get(test) + else: + sampler = self.properties.get(test) + quantum_instance = None + num_qubits = 2 classifier = VQC( + sampler=sampler, num_qubits=num_qubits, feature_map=ZFeatureMap(1), ansatz=RealAmplitudes(1), - quantum_instance=self.properties.get("statevector"), + quantum_instance=quantum_instance, ) self.assertEqual(classifier.feature_map.num_qubits, num_qubits) self.assertEqual(classifier.ansatz.num_qubits, num_qubits) @@ -306,10 +378,11 @@ def test_circuit_extensions(self): qc = QuantumCircuit(1) with self.assertRaises(QiskitMachineLearningError): _ = VQC( + sampler=sampler, num_qubits=num_qubits, feature_map=qc, ansatz=qc, - quantum_instance=self.properties.get("statevector"), + quantum_instance=quantum_instance, ) From 16b2ee3e20c5c5eb0ea5911f638563b790c7c5ac Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 19:01:44 +0200 Subject: [PATCH 29/96] Fix mypy --- .../algorithms/classifiers/vqc.py | 12 ++- .../connectors/torch_connector.py | 4 +- .../neural_networks/sampler_qnn.py | 80 +++++++++---------- test/connectors/test_torch_connector.py | 2 +- test/connectors/test_torch_networks.py | 2 +- test/neural_networks/test_sampler_qnn.py | 7 -- 6 files changed, 49 insertions(+), 58 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 5f57f9998..db573ff19 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -102,6 +102,8 @@ def __init__( self._circuit.compose(self.feature_map, inplace=True) self._circuit.compose(self.ansatz, inplace=True) + # needed for mypy + neural_network: SamplerQNN | CircuitQNN = None if sampler is None: # construct circuit QNN neural_network = CircuitQNN( @@ -168,9 +170,13 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: """ X, y = self._validate_input(X, y) num_classes = self._num_classes - cast(CircuitQNN, self._neural_network).set_interpret( - self._get_interpret(num_classes), num_classes - ) + + if isinstance(self._neural_network, SamplerQNN): + self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) + else: + cast(CircuitQNN, self._neural_network).set_interpret( + self._get_interpret(num_classes), num_classes + ) return super()._minimize(X, y) diff --git a/qiskit_machine_learning/connectors/torch_connector.py b/qiskit_machine_learning/connectors/torch_connector.py index 789fd1677..dd85d1e85 100644 --- a/qiskit_machine_learning/connectors/torch_connector.py +++ b/qiskit_machine_learning/connectors/torch_connector.py @@ -55,7 +55,7 @@ class TorchConnector(Module): class _TorchNNFunction(Function): # pylint: disable=arguments-differ @staticmethod - def forward( # type: ignore + def forward( ctx: Any, input_data: Tensor, weights: Tensor, @@ -117,7 +117,7 @@ def forward( # type: ignore return result_tensor @staticmethod - def backward(ctx: Any, grad_output: Tensor) -> Tuple: # type: ignore + def backward(ctx: Any, grad_output: Tensor) -> Tuple: """Backward pass computation. Args: ctx: context diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index e9149d41b..dbb2f4c63 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -19,9 +19,13 @@ from typing import Callable, cast, Iterable, Sequence import numpy as np -from qiskit.algorithms.gradients import BaseSamplerGradient, ParamShiftSamplerGradient +from qiskit.algorithms.gradients import ( + BaseSamplerGradient, + ParamShiftSamplerGradient, + SamplerGradientResult, +) from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.primitives import BaseSampler +from qiskit.primitives import BaseSampler, SamplerResult from qiskit_machine_learning.exceptions import QiskitMachineLearningError from .neural_network import NeuralNetwork @@ -142,8 +146,8 @@ def _compute_output_shape( ) -> tuple[int, ...]: """Validate and compute the output shape.""" - # # this definition is required by mypy - # output_shape_: tuple[int, ...] = (-1,) + # this definition is required by mypy + output_shape_: tuple[int, ...] = (-1,) if interpret is not None: if output_shape is None: @@ -154,7 +158,7 @@ def _compute_output_shape( output_shape = int(output_shape) output_shape_ = (output_shape,) else: - output_shape_ = output_shape + output_shape_ = cast(tuple[int, ...], output_shape) else: if output_shape is not None: # Warn user that output_shape parameter will be ignored @@ -169,35 +173,35 @@ def _compute_output_shape( def _preprocess( self, - input_data: list[float] | np.ndarray | float | None, - weights: list[float] | np.ndarray | float | None, - ) -> tuple[list[float], int]: + input_data: list[float] | np.ndarray | float, + weights: list[float] | np.ndarray | float, + ) -> tuple[np.ndarray, int]: """ Pre-processing during forward pass of the network. """ + + if not isinstance(input_data, np.ndarray): + input_data = np.asarray(input_data) if len(input_data.shape) == 1: input_data = np.expand_dims(input_data, 0) - num_samples = input_data.shape[0] - # quick fix for 0 inputs - if num_samples == 0: - num_samples = 1 - parameters = [] - for i in range(num_samples): - param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] - param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] - parameters.append(param_values) + if not isinstance(weights, np.ndarray): + weights = np.asarray(weights) + + num_samples = max(input_data.shape[0], 1) + weights = np.broadcast_to(weights, (num_samples, len(weights))) + parameters = np.concatenate((input_data, weights), axis=1) return parameters, num_samples - def _postprocess(self, num_samples, result): + def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray: """ Post-processing during forward pass of the network. """ prob = np.zeros((num_samples, *self._output_shape)) for i in range(num_samples): - counts = result[i] + counts = result.quasi_dists[i] shots = sum(counts.values()) # evaluate probabilities @@ -210,7 +214,11 @@ def _postprocess(self, num_samples, result): return prob - def _forward(self, input_data: np.ndarray | None, weights: np.ndarray | None) -> np.ndarray: + def _forward( + self, + input_data: list[float] | np.ndarray | float, + weights: list[float] | np.ndarray | float, + ) -> np.ndarray: """ Forward pass of the network. """ @@ -218,33 +226,15 @@ def _forward(self, input_data: np.ndarray | None, weights: np.ndarray | None) -> # sampler allows batching job = self.sampler.run([self._circuit] * num_samples, parameter_values) - results = job.result().quasi_dists + results = job.result() result = self._postprocess(num_samples, results) return result - def _preprocess_gradient(self, input_data: np.ndarray, weights: np.ndarray): - """ - Pre-processing during backward pass of the network. - """ - if len(input_data.shape) == 1: - input_data = np.expand_dims(input_data, 0) - - num_samples = input_data.shape[0] - # quick fix for 0 inputs - if num_samples == 0: - num_samples = 1 - - parameters = [] - for i in range(num_samples): - param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] - param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] - parameters.append(param_values) - - return parameters, num_samples - - def _postprocess_gradient(self, num_samples, results): + def _postprocess_gradient( + self, num_samples: int, results: SamplerGradientResult + ) -> tuple[np.ndarray | None, np.ndarray]: """ Post-processing during backward pass of the network. """ @@ -291,12 +281,14 @@ def _postprocess_gradient(self, num_samples, results): return input_grad, weights_grad def _backward( - self, input_data: np.ndarray | None, weights: np.ndarray | None + self, + input_data: list[float] | np.ndarray | float, + weights: list[float] | np.ndarray | float, ) -> tuple[np.ndarray | None, np.ndarray | None]: """Backward pass of the network.""" # prepare parameters in the required format - parameter_values, num_samples = self._preprocess_gradient(input_data, weights) + parameter_values, num_samples = self._preprocess(input_data, weights) if self._input_gradients: job = self.gradient.run([self._circuit] * num_samples, parameter_values) diff --git a/test/connectors/test_torch_connector.py b/test/connectors/test_torch_connector.py index 729b0e7d2..31811aadf 100644 --- a/test/connectors/test_torch_connector.py +++ b/test/connectors/test_torch_connector.py @@ -107,7 +107,7 @@ def _validate_backward_pass(self, model: TorchConnector) -> None: model.neural_network, False, ) - test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) # type: ignore + test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) self.assertTrue(test) @data("sv", "qasm") diff --git a/test/connectors/test_torch_networks.py b/test/connectors/test_torch_networks.py index d942f3c1f..98e7163cf 100644 --- a/test/connectors/test_torch_networks.py +++ b/test/connectors/test_torch_networks.py @@ -122,7 +122,7 @@ def test_hybrid_batch_gradients(self, qnn_type: str): from torch.nn import MSELoss from torch.optim import SGD - qnn: Optional[Union[CircuitQNN, TwoLayerQNN]] = None + qnn: Optional[Union[CircuitQNN, TwoLayerQNN, SamplerQNN]] = None if qnn_type == "opflow": qnn = self._create_opflow_qnn() output_size = 1 diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index 50fb41a78..f49a9b7a3 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -123,13 +123,6 @@ def _verify_qnn( ) -> None: """ Verifies that a QNN functions correctly - - Args: - qnn: a QNN to check - batch_size: batch size - - Returns: - None. """ input_data = np.zeros((batch_size, qnn.num_inputs)) weights = np.zeros(qnn.num_weights) From c36cbc2fa52a51553be4f56d1446d4ccedd08dcf Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Mon, 10 Oct 2022 19:16:25 +0200 Subject: [PATCH 30/96] fix mypy --- qiskit_machine_learning/connectors/torch_connector.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/connectors/torch_connector.py b/qiskit_machine_learning/connectors/torch_connector.py index dd85d1e85..bc134ecc0 100644 --- a/qiskit_machine_learning/connectors/torch_connector.py +++ b/qiskit_machine_learning/connectors/torch_connector.py @@ -117,7 +117,7 @@ def forward( return result_tensor @staticmethod - def backward(ctx: Any, grad_output: Tensor) -> Tuple: + def backward(ctx: Any, grad_output: Tensor) -> Tuple: # type: ignore """Backward pass computation. Args: ctx: context From cde487727b34cfa74fec289776dd9dda1d7b5914 Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Mon, 10 Oct 2022 19:17:03 +0200 Subject: [PATCH 31/96] fix mypy --- qiskit_machine_learning/connectors/torch_connector.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/connectors/torch_connector.py b/qiskit_machine_learning/connectors/torch_connector.py index bc134ecc0..789fd1677 100644 --- a/qiskit_machine_learning/connectors/torch_connector.py +++ b/qiskit_machine_learning/connectors/torch_connector.py @@ -55,7 +55,7 @@ class TorchConnector(Module): class _TorchNNFunction(Function): # pylint: disable=arguments-differ @staticmethod - def forward( + def forward( # type: ignore ctx: Any, input_data: Tensor, weights: Tensor, From 551c7acf37a0a98033e8a4a799aff052f32c5ced Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Mon, 10 Oct 2022 19:17:49 +0200 Subject: [PATCH 32/96] fix mypy --- test/connectors/test_torch_connector.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/connectors/test_torch_connector.py b/test/connectors/test_torch_connector.py index 31811aadf..729b0e7d2 100644 --- a/test/connectors/test_torch_connector.py +++ b/test/connectors/test_torch_connector.py @@ -107,7 +107,7 @@ def _validate_backward_pass(self, model: TorchConnector) -> None: model.neural_network, False, ) - test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) + test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3) # type: ignore self.assertTrue(test) @data("sv", "qasm") From f9d11e68f49512229129126d0f5712fcbf220a7f Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 10 Oct 2022 19:30:53 +0200 Subject: [PATCH 33/96] Restore workflow --- .github/workflows/main.yml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index d177615be..333ca15fe 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -16,16 +16,17 @@ on: push: branches: - main - - primitives - 'stable/**' pull_request: branches: - main - - primitives - 'stable/**' + schedule: + # run every day at 1AM + - cron: '0 1 * * *' concurrency: - group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }}-${{ github.workflow }} + group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }} cancel-in-progress: true jobs: From 3e4613758015a6078befd1f64d87531df6e8fba1 Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Mon, 10 Oct 2022 19:31:34 +0200 Subject: [PATCH 34/96] Restore workflow --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 333ca15fe..cf01d7050 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -22,7 +22,7 @@ on: - main - 'stable/**' schedule: - # run every day at 1AM + # run every day at 1AM - cron: '0 1 * * *' concurrency: From af88a141bdde05491d0ccba16c86ecfc4e1ad552 Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Mon, 10 Oct 2022 19:32:18 +0200 Subject: [PATCH 35/96] Update .github/workflows/main.yml --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index cf01d7050..5f3f93eeb 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -23,7 +23,7 @@ on: - 'stable/**' schedule: # run every day at 1AM - - cron: '0 1 * * *' + - cron: '0 1 * * *' concurrency: group: ${{ github.repository }}-${{ github.ref }}-${{ github.head_ref }} From 328485183b4143c80fd6bba232f4db76c2fd18a3 Mon Sep 17 00:00:00 2001 From: ElePT Date: Tue, 11 Oct 2022 09:02:07 +0200 Subject: [PATCH 36/96] Fix mypy --- qiskit_machine_learning/neural_networks/sampler_qnn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index dbb2f4c63..c7353e13b 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -158,7 +158,7 @@ def _compute_output_shape( output_shape = int(output_shape) output_shape_ = (output_shape,) else: - output_shape_ = cast(tuple[int, ...], output_shape) + output_shape_ = output_shape # type: ignore else: if output_shape is not None: # Warn user that output_shape parameter will be ignored @@ -188,7 +188,7 @@ def _preprocess( if not isinstance(weights, np.ndarray): weights = np.asarray(weights) - num_samples = max(input_data.shape[0], 1) + num_samples = max(input_data.shape[0], 1) # type: ignore weights = np.broadcast_to(weights, (num_samples, len(weights))) parameters = np.concatenate((input_data, weights), axis=1) From 13b8c8995e54bc9e3839bba04af787d1a700a02d Mon Sep 17 00:00:00 2001 From: ElePT Date: Tue, 11 Oct 2022 10:12:51 +0200 Subject: [PATCH 37/96] Fix CI (hopefully) --- qiskit_machine_learning/neural_networks/sampler_qnn.py | 4 ++-- test/neural_networks/test_sampler_qnn.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index c7353e13b..f17214b71 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -158,7 +158,7 @@ def _compute_output_shape( output_shape = int(output_shape) output_shape_ = (output_shape,) else: - output_shape_ = output_shape # type: ignore + output_shape_ = output_shape # type: ignore else: if output_shape is not None: # Warn user that output_shape parameter will be ignored @@ -188,7 +188,7 @@ def _preprocess( if not isinstance(weights, np.ndarray): weights = np.asarray(weights) - num_samples = max(input_data.shape[0], 1) # type: ignore + num_samples = max(input_data.shape[0], 1) # type: ignore weights = np.broadcast_to(weights, (num_samples, len(weights))) parameters = np.concatenate((input_data, weights), axis=1) diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index f49a9b7a3..917a9f231 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -209,7 +209,7 @@ def test_circuit_vs_sampler_qnn(self): aer = importlib.import_module("qiskit.providers.aer") - parity = lambda x: "{:b}".format(x).count("1") % 2 + parity = lambda x: f"{x:b}".count("1") % 2 output_shape = 2 # this is required in case of a callable with dense output qi_qasm = QuantumInstance( From 9b350ba39c3931b8ea3564c8642abd142b4ffb3e Mon Sep 17 00:00:00 2001 From: ElePT Date: Tue, 11 Oct 2022 10:21:01 +0200 Subject: [PATCH 38/96] Update requirements --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 53eca70fe..32e96ecd5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -qiskit-terra>=0.20.0 +qiskit-terra>=0.22.* scipy>=1.4 numpy>=1.17 psutil>=5 From 0252925c8a3e3b327f1fc5883197fe274f41deaf Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 12 Oct 2022 10:28:46 +0200 Subject: [PATCH 39/96] Add sparse support --- .../neural_networks/sampler_qnn.py | 79 ++++++++++++++----- test/neural_networks/test_sampler_qnn.py | 45 ++++++++--- 2 files changed, 95 insertions(+), 29 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index f17214b71..2acf74e37 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -27,9 +27,23 @@ from qiskit.circuit import Parameter, QuantumCircuit from qiskit.primitives import BaseSampler, SamplerResult from qiskit_machine_learning.exceptions import QiskitMachineLearningError +import qiskit_machine_learning.optionals as _optionals from .neural_network import NeuralNetwork +if _optionals.HAS_SPARSE: + # pylint: disable=import-error + from sparse import SparseArray +else: + + class SparseArray: # type: ignore + """Empty SparseArray class + Replacement if sparse.SparseArray is not present. + """ + + pass + + logger = logging.getLogger(__name__) @@ -43,6 +57,7 @@ def __init__( *, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, + sparse: bool = False, interpret: Callable[[int], int | tuple[int, ...]] | None = None, output_shape: int | tuple[int, ...] | None = None, gradient: BaseSamplerGradient | None = None, @@ -54,6 +69,7 @@ def __init__( circuit: The parametrized quantum circuit that generates the samples of this network. input_params: The parameters of the circuit corresponding to the input. weight_params: The parameters of the circuit corresponding to the trainable weights. + sparse: Returns whether the output is sparse or not. interpret: A callable that maps the measured integer to another unsigned integer or tuple of unsigned integers. These are used as new indices for the (potentially sparse) output array. If no interpret function is @@ -80,21 +96,19 @@ def __init__( self._input_params = list(input_params or []) self._weight_params = list(weight_params or []) - # the final output shape will depend on the - # interpret method, and it must be set before - # applying the default to the latter + if sparse: + _optionals.HAS_SPARSE.require_now("DOK") + self.set_interpret(interpret, output_shape) self._input_gradients = input_gradients - # TODO: will primitives ever support sparse? # TODO: look into custom transpilation - # TODO: sampling?? super().__init__( len(self._input_params), len(self._weight_params), - False, # sparse + sparse, self._output_shape, self._input_gradients, ) @@ -158,7 +172,7 @@ def _compute_output_shape( output_shape = int(output_shape) output_shape_ = (output_shape,) else: - output_shape_ = output_shape # type: ignore + output_shape_ = output_shape else: if output_shape is not None: # Warn user that output_shape parameter will be ignored @@ -188,7 +202,7 @@ def _preprocess( if not isinstance(weights, np.ndarray): weights = np.asarray(weights) - num_samples = max(input_data.shape[0], 1) # type: ignore + num_samples = max(input_data.shape[0], 1) weights = np.broadcast_to(weights, (num_samples, len(weights))) parameters = np.concatenate((input_data, weights), axis=1) @@ -198,7 +212,13 @@ def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray: """ Post-processing during forward pass of the network. """ - prob = np.zeros((num_samples, *self._output_shape)) + if self._sparse: + # pylint: disable=import-error + from sparse import DOK + + prob = DOK((num_samples, *self._output_shape)) + else: + prob = np.zeros((num_samples, *self._output_shape)) for i in range(num_samples): counts = result.quasi_dists[i] @@ -212,13 +232,16 @@ def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray: key = (i, *key) # type: ignore prob[key] += v / shots - return prob + if self._sparse: + return prob.to_coo() + else: + return prob def _forward( self, input_data: list[float] | np.ndarray | float, weights: list[float] | np.ndarray | float, - ) -> np.ndarray: + ) -> np.ndarray | SparseArray: """ Forward pass of the network. """ @@ -234,16 +257,27 @@ def _forward( def _postprocess_gradient( self, num_samples: int, results: SamplerGradientResult - ) -> tuple[np.ndarray | None, np.ndarray]: + ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray]: """ Post-processing during backward pass of the network. """ - input_grad = ( - np.zeros((num_samples, *self._output_shape, self._num_inputs)) - if self._input_gradients - else None - ) - weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) + if self._sparse: + # pylint: disable=import-error + from sparse import DOK + + input_grad = ( + DOK((num_samples, *self._output_shape, self._num_inputs)) + if self._input_gradients + else None + ) + weights_grad = DOK((num_samples, *self._output_shape, self._num_weights)) + else: + input_grad = ( + np.zeros((num_samples, *self._output_shape, self._num_inputs)) + if self._input_gradients + else None + ) + weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights)) if self._input_gradients: num_grad_vars = self._num_inputs + self._num_weights @@ -253,6 +287,7 @@ def _postprocess_gradient( for sample in range(num_samples): for i in range(num_grad_vars): grad = results.gradients[sample][i] + for k in grad.keys(): val = results.gradients[sample][i][k] # get index for input or weights gradients @@ -268,6 +303,7 @@ def _postprocess_gradient( # if key is an array-type, cast to hashable tuple key = tuple(cast(Iterable[int], key)) key = (sample, *key, grad_index) + # store value for inputs or weights gradients if self._input_gradients: # we compute input gradients first @@ -278,13 +314,18 @@ def _postprocess_gradient( else: weights_grad[key] += np.real(val) + if self._sparse: + if self._input_gradients: + input_grad = input_grad.to_coo() + weights_grad = weights_grad.to_coo() + return input_grad, weights_grad def _backward( self, input_data: list[float] | np.ndarray | float, weights: list[float] | np.ndarray | float, - ) -> tuple[np.ndarray | None, np.ndarray | None]: + ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray]: """Backward pass of the network.""" # prepare parameters in the required format diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index 917a9f231..b35e37a74 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -15,6 +15,7 @@ from test import QiskitMachineLearningTestCase import itertools +import unittest import numpy as np from ddt import ddt, idata, unpack @@ -27,12 +28,13 @@ from qiskit_machine_learning.neural_networks import CircuitQNN from qiskit_machine_learning.neural_networks.sampler_qnn import SamplerQNN +import qiskit_machine_learning.optionals as _optionals algorithm_globals.random_seed = 42 DEFAULT = "default" SHOTS = "shots" -SAMPLING = [True, False] # TODO +SPARSE = [True, False] SAMPLERS = [DEFAULT, SHOTS] INTERPRET_TYPES = [2] BATCH_SIZES = [1, 2] @@ -84,7 +86,7 @@ def interpret_2d(x): self.sampler = Sampler() self.sampler_shots = Sampler(options={"shots": 100}) - def _get_qnn(self, sampler_type, interpret_id): + def _get_qnn(self, sparse, sampler_type, interpret_id): """Construct QNN from configuration.""" # get quantum instance @@ -111,6 +113,7 @@ def _get_qnn(self, sampler_type, interpret_id): self.qc, input_params=self.input_params, weight_params=self.weight_params, + sparse=sparse, interpret=interpret, output_shape=output_shape, ) @@ -124,22 +127,36 @@ def _verify_qnn( """ Verifies that a QNN functions correctly """ + # pylint: disable=import-error + from sparse import SparseArray + input_data = np.zeros((batch_size, qnn.num_inputs)) weights = np.zeros(qnn.num_weights) # evaluate QNN forward pass result = qnn.forward(input_data, weights) - self.assertTrue(isinstance(result, np.ndarray)) + + # make sure forward result is sparse if it should be + if qnn.sparse: + self.assertTrue(isinstance(result, SparseArray)) + else: + self.assertTrue(isinstance(result, np.ndarray)) + # check forward result shape self.assertEqual(result.shape, (batch_size, *qnn.output_shape)) # evaluate QNN backward pass input_grad, weights_grad = qnn.backward(input_data, weights) - self.assertIsNone(input_grad) # verify that input gradients are None if turned off + self.assertIsNone(input_grad) self.assertEqual(weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)) + if qnn.sparse: + self.assertTrue(isinstance(weights_grad, SparseArray)) + else: + self.assertTrue(isinstance(weights_grad, np.ndarray)) + # verify that input gradients are not None if turned on qnn.input_gradients = True input_grad, weights_grad = qnn.backward(input_data, weights) @@ -147,22 +164,30 @@ def _verify_qnn( self.assertEqual(input_grad.shape, (batch_size, *qnn.output_shape, qnn.num_inputs)) self.assertEqual(weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)) - @idata(itertools.product(SAMPLERS, INTERPRET_TYPES, BATCH_SIZES)) + if qnn.sparse: + self.assertTrue(isinstance(weights_grad, SparseArray)) + self.assertTrue(isinstance(input_grad, SparseArray)) + else: + self.assertTrue(isinstance(weights_grad, np.ndarray)) + self.assertTrue(isinstance(input_grad, np.ndarray)) + + @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.") + @idata(itertools.product(SPARSE, SAMPLERS, INTERPRET_TYPES, BATCH_SIZES)) @unpack - def test_sampler_qnn(self, sampler_type, interpret_type, batch_size): + def test_sampler_qnn(self, sparse: bool, sampler_type, interpret_type, batch_size): """Sampler QNN Test.""" - qnn = self._get_qnn(sampler_type, interpret_type) + qnn = self._get_qnn(sparse, sampler_type, interpret_type) self._verify_qnn(qnn, batch_size) - @idata(itertools.product(INTERPRET_TYPES, BATCH_SIZES)) + @idata(itertools.product(SPARSE, INTERPRET_TYPES, BATCH_SIZES)) def test_sampler_qnn_gradient(self, config): """Sampler QNN Gradient Test.""" # get configuration - interpret_id, batch_size = config + sparse, interpret_id, batch_size = config # get QNN - qnn = self._get_qnn(DEFAULT, interpret_id) + qnn = self._get_qnn(sparse, DEFAULT, interpret_id) # set input gradients to True qnn.input_gradients = True From d5e18e506589ef7ae69420ef46f11ffc54841dd8 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 12 Oct 2022 10:53:12 +0200 Subject: [PATCH 40/96] Fix style etc --- .../neural_networks/sampler_qnn.py | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 2acf74e37..b2353f1ea 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -172,7 +172,7 @@ def _compute_output_shape( output_shape = int(output_shape) output_shape_ = (output_shape,) else: - output_shape_ = output_shape + output_shape_ = cast(tuple[int, ...], output_shape) else: if output_shape is not None: # Warn user that output_shape parameter will be ignored @@ -194,14 +194,11 @@ def _preprocess( Pre-processing during forward pass of the network. """ - if not isinstance(input_data, np.ndarray): - input_data = np.asarray(input_data) + input_data = np.asarray(input_data) + weights = np.asarray(weights) if len(input_data.shape) == 1: input_data = np.expand_dims(input_data, 0) - if not isinstance(weights, np.ndarray): - weights = np.asarray(weights) - num_samples = max(input_data.shape[0], 1) weights = np.broadcast_to(weights, (num_samples, len(weights))) parameters = np.concatenate((input_data, weights), axis=1) @@ -308,15 +305,15 @@ def _postprocess_gradient( if self._input_gradients: # we compute input gradients first if i < self._num_inputs: - input_grad[key] += np.real(val) + input_grad[key] += val else: - weights_grad[key] += np.real(val) + weights_grad[key] += val else: - weights_grad[key] += np.real(val) + weights_grad[key] += val if self._sparse: if self._input_gradients: - input_grad = input_grad.to_coo() + input_grad = input_grad.to_coo() # pylint: disable=no-member weights_grad = weights_grad.to_coo() return input_grad, weights_grad From e40c893701c10c16bcc8e2089bfe0e1f933c3a97 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 12 Oct 2022 10:58:34 +0200 Subject: [PATCH 41/96] Add type ignore --- qiskit_machine_learning/neural_networks/sampler_qnn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index b2353f1ea..c963dfda7 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -199,7 +199,7 @@ def _preprocess( if len(input_data.shape) == 1: input_data = np.expand_dims(input_data, 0) - num_samples = max(input_data.shape[0], 1) + num_samples = max(input_data.shape[0], 1) # type: ignore weights = np.broadcast_to(weights, (num_samples, len(weights))) parameters = np.concatenate((input_data, weights), axis=1) From 16441a6a9447006d43274c41ed9e82ab6281c181 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 12 Oct 2022 14:56:37 +0200 Subject: [PATCH 42/96] Fix style? --- qiskit_machine_learning/neural_networks/sampler_qnn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index c963dfda7..9c9c1992b 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -172,7 +172,7 @@ def _compute_output_shape( output_shape = int(output_shape) output_shape_ = (output_shape,) else: - output_shape_ = cast(tuple[int, ...], output_shape) + output_shape_ = output_shape # type: ignore else: if output_shape is not None: # Warn user that output_shape parameter will be ignored @@ -199,7 +199,7 @@ def _preprocess( if len(input_data.shape) == 1: input_data = np.expand_dims(input_data, 0) - num_samples = max(input_data.shape[0], 1) # type: ignore + num_samples = max(input_data.shape[0], 1) weights = np.broadcast_to(weights, (num_samples, len(weights))) parameters = np.concatenate((input_data, weights), axis=1) From ca9e1c534e8a211645c656894d33ae2d60fbb01e Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 12 Oct 2022 14:58:02 +0200 Subject: [PATCH 43/96] skip test if not sparse --- test/neural_networks/test_sampler_qnn.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index b35e37a74..c4b0428d0 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -179,6 +179,7 @@ def test_sampler_qnn(self, sparse: bool, sampler_type, interpret_type, batch_siz qnn = self._get_qnn(sparse, sampler_type, interpret_type) self._verify_qnn(qnn, batch_size) + @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.") @idata(itertools.product(SPARSE, INTERPRET_TYPES, BATCH_SIZES)) def test_sampler_qnn_gradient(self, config): """Sampler QNN Gradient Test.""" From 8fc31d0cd093d51de3d9ddec778bb43d5a418bfd Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 12 Oct 2022 15:09:05 +0200 Subject: [PATCH 44/96] Add type ignore --- qiskit_machine_learning/neural_networks/sampler_qnn.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 9c9c1992b..51e27d836 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -180,7 +180,6 @@ def _compute_output_shape( "No interpret function given, output_shape will be automatically " "determined as 2^num_qubits." ) - output_shape_ = (2**self._circuit.num_qubits,) return output_shape_ @@ -200,7 +199,7 @@ def _preprocess( input_data = np.expand_dims(input_data, 0) num_samples = max(input_data.shape[0], 1) - weights = np.broadcast_to(weights, (num_samples, len(weights))) + weights = np.broadcast_to(weights, (num_samples, len(weights))) # type: ignore parameters = np.concatenate((input_data, weights), axis=1) return parameters, num_samples From 82c96137d14004278f3d6e6c128f5dc2ea9b45a3 Mon Sep 17 00:00:00 2001 From: Manoel Marques Date: Wed, 12 Oct 2022 10:14:26 -0400 Subject: [PATCH 45/96] Fix mypy --- .../neural_networks/sampler_qnn.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 51e27d836..9ee51fd2d 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -193,14 +193,14 @@ def _preprocess( Pre-processing during forward pass of the network. """ - input_data = np.asarray(input_data) - weights = np.asarray(weights) - if len(input_data.shape) == 1: - input_data = np.expand_dims(input_data, 0) - - num_samples = max(input_data.shape[0], 1) - weights = np.broadcast_to(weights, (num_samples, len(weights))) # type: ignore - parameters = np.concatenate((input_data, weights), axis=1) + np_input_data: np.ndarray = np.asarray(input_data) + np_weights: np.ndarray = np.asarray(weights) + if len(np_input_data.shape) == 1: + np_input_data = np.expand_dims(np_input_data, 0) + + num_samples = max(np_input_data.shape[0], 1) + np_weights = np.broadcast_to(np_weights, (num_samples, len(np_weights))) + parameters = np.concatenate((np_input_data, np_weights), axis=1) return parameters, num_samples From b15d380efef7044197281c7c849f29123206cf1e Mon Sep 17 00:00:00 2001 From: ElePT Date: Thu, 13 Oct 2022 10:41:11 +0200 Subject: [PATCH 46/96] Make keyword args --- qiskit_machine_learning/algorithms/classifiers/vqc.py | 1 + qiskit_machine_learning/neural_networks/sampler_qnn.py | 2 +- test/neural_networks/test_sampler_qnn.py | 4 ++-- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index db573ff19..4295683d0 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -48,6 +48,7 @@ class VQC(NeuralNetworkClassifier): def __init__( self, + *, sampler: BaseSampler = None, num_qubits: int | None = None, feature_map: QuantumCircuit | None = None, diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 51e27d836..c091b29ed 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -52,9 +52,9 @@ class SamplerQNN(NeuralNetwork): def __init__( self, + *, sampler: BaseSampler, circuit: QuantumCircuit, - *, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, sparse: bool = False, diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index c4b0428d0..e4f2a7a14 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -109,8 +109,8 @@ def _get_qnn(self, sparse, sampler_type, interpret_id): # construct QNN qnn = SamplerQNN( - sampler, - self.qc, + sampler=sampler, + circuit=self.qc, input_params=self.input_params, weight_params=self.weight_params, sparse=sparse, From 108255f3f23f722207ebb3e6452ef74f30df6360 Mon Sep 17 00:00:00 2001 From: ElePT Date: Thu, 13 Oct 2022 10:53:23 +0200 Subject: [PATCH 47/96] Make keyword args --- qiskit_machine_learning/algorithms/classifiers/vqc.py | 4 ++-- test/connectors/test_torch_networks.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 4295683d0..2522583a4 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -119,8 +119,8 @@ def __init__( else: # construct sampler QNN neural_network = SamplerQNN( - sampler, - self._circuit, + sampler=sampler, + circuit=self._circuit, input_params=self.feature_map.parameters, weight_params=self.ansatz.parameters, interpret=self._get_interpret(2), diff --git a/test/connectors/test_torch_networks.py b/test/connectors/test_torch_networks.py index 98e7163cf..f690051a2 100644 --- a/test/connectors/test_torch_networks.py +++ b/test/connectors/test_torch_networks.py @@ -105,8 +105,8 @@ def _create_sampler_qnn(self) -> SamplerQNN: qc.append(ansatz, range(num_inputs)) qnn = SamplerQNN( - Sampler(), - qc, + sampler=Sampler(), + circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters, input_gradients=True, # for hybrid qnn From a9f0179ca37f22829d86c2d763c0a5769721e706 Mon Sep 17 00:00:00 2001 From: ElePT Date: Fri, 14 Oct 2022 18:54:14 +0200 Subject: [PATCH 48/96] Apply review comments --- .../algorithms/classifiers/vqc.py | 25 ++- .../neural_networks/sampler_qnn.py | 157 +++++++------ test/neural_networks/test_sampler_qnn.py | 209 +++++++++--------- 3 files changed, 209 insertions(+), 182 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 2522583a4..0375a6cb4 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -48,8 +48,6 @@ class VQC(NeuralNetworkClassifier): def __init__( self, - *, - sampler: BaseSampler = None, num_qubits: int | None = None, feature_map: QuantumCircuit | None = None, ansatz: QuantumCircuit | None = None, @@ -59,6 +57,8 @@ def __init__( quantum_instance: QuantumInstance | Backend | None = None, initial_point: np.ndarray | None = None, callback: Callable[[np.ndarray, float], None] | None = None, + *, + sampler: BaseSampler = None, ) -> None: """ Args: @@ -85,6 +85,7 @@ def __init__( On each iteration an optimizer invokes the callback and passes current weights as an array and a computed value as a float of the objective function being optimized. This allows to track how well optimization / training process is going on. + sampler: The sampler primitive used to compute neural network's results. Raises: QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz @@ -105,26 +106,26 @@ def __init__( # needed for mypy neural_network: SamplerQNN | CircuitQNN = None - if sampler is None: - # construct circuit QNN - neural_network = CircuitQNN( - self._circuit, + if quantum_instance is not None: + # construct sampler QNN + neural_network = SamplerQNN( + sampler=sampler, + circuit=self._circuit, input_params=self.feature_map.parameters, weight_params=self.ansatz.parameters, interpret=self._get_interpret(2), output_shape=2, - quantum_instance=quantum_instance, input_gradients=False, ) else: - # construct sampler QNN - neural_network = SamplerQNN( - sampler=sampler, - circuit=self._circuit, + # construct circuit QNN + neural_network = CircuitQNN( + self._circuit, input_params=self.feature_map.parameters, weight_params=self.ansatz.parameters, interpret=self._get_interpret(2), output_shape=2, + quantum_instance=quantum_instance, input_gradients=False, ) @@ -174,7 +175,7 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: if isinstance(self._neural_network, SamplerQNN): self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) - else: + elif isinstance(self._neural_network, CircuitQNN): cast(CircuitQNN, self._neural_network).set_interpret( self._get_interpret(num_classes), num_classes ) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 68c1b1856..44b4db37c 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -1,6 +1,6 @@ # This code is part of Qiskit. # -# (C) Copyright IBM 2020, 2022. +# (C) Copyright IBM 2022. # # This code is licensed under the Apache License, Version 2.0. You may # obtain a copy of this license in the LICENSE.txt file in the root directory @@ -25,7 +25,7 @@ SamplerGradientResult, ) from qiskit.circuit import Parameter, QuantumCircuit -from qiskit.primitives import BaseSampler, SamplerResult +from qiskit.primitives import BaseSampler, SamplerResult, Sampler from qiskit_machine_learning.exceptions import QiskitMachineLearningError import qiskit_machine_learning.optionals as _optionals @@ -53,8 +53,8 @@ class SamplerQNN(NeuralNetwork): def __init__( self, *, - sampler: BaseSampler, - circuit: QuantumCircuit, + sampler: BaseSampler | None = None, + circuit: QuantumCircuit | None = None, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, sparse: bool = False, @@ -82,19 +82,27 @@ def __init__( Raises: QiskitMachineLearningError: Invalid parameter values. """ - # set primitive + # set primitive, provide default + if sampler is None: + sampler = Sampler() self.sampler = sampler # set gradient - # TODO: provide default gradient? - self.gradient = gradient or ParamShiftSamplerGradient(self.sampler) + if gradient is None: + gradient = ParamShiftSamplerGradient(self.sampler) + self.gradient = gradient self._circuit = circuit.copy() if len(self._circuit.clbits) == 0: self._circuit.measure_all() - self._input_params = list(input_params or []) - self._weight_params = list(weight_params or []) + if input_params is None: + input_params = [] + self._input_params = list(input_params) + + if weight_params is None: + weight_params = [] + self._weight_params = list(weight_params) if sparse: _optionals.HAS_SPARSE.require_now("DOK") @@ -106,11 +114,11 @@ def __init__( # TODO: look into custom transpilation super().__init__( - len(self._input_params), - len(self._weight_params), - sparse, - self._output_shape, - self._input_gradients, + num_inputs=len(self._input_params), + num_weights=len(self._weight_params), + sparse=sparse, + output_shape=self._output_shape, + input_gradients=self._input_gradients, ) @property @@ -119,12 +127,12 @@ def circuit(self) -> QuantumCircuit: return self._circuit @property - def input_params(self) -> Sequence: + def input_params(self) -> Sequence[Parameter]: """Returns the list of input parameters.""" return self._input_params @property - def weight_params(self) -> Sequence: + def weight_params(self) -> Sequence[Parameter]: """Returns the list of trainable weights parameters.""" return self._weight_params @@ -186,28 +194,39 @@ def _compute_output_shape( def _preprocess( self, - input_data: list[float] | np.ndarray | float, - weights: list[float] | np.ndarray | float, - ) -> tuple[np.ndarray, int]: + input_data: np.ndarray | None, + weights: np.ndarray | None, + ) -> tuple[np.ndarray | None, int | None]: """ Pre-processing during forward pass of the network. """ - np_input_data: np.ndarray = np.asarray(input_data) - np_weights: np.ndarray = np.asarray(weights) - if len(np_input_data.shape) == 1: - np_input_data = np.expand_dims(np_input_data, 0) - - num_samples = max(np_input_data.shape[0], 1) - np_weights = np.broadcast_to(np_weights, (num_samples, len(np_weights))) - parameters = np.concatenate((np_input_data, np_weights), axis=1) + if input_data is not None: + num_samples = input_data.shape[0] + if weights is not None: + weights = np.broadcast_to(weights, (num_samples, len(weights))) + parameters = np.concatenate((input_data, weights), axis=1) + else: + parameters = input_data + else: + if weights is not None: + num_samples = 1 + parameters = np.broadcast_to(weights, (num_samples, len(weights))) + else: + return None, None return parameters, num_samples - def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray: + def _postprocess( + self, num_samples: int | None, result: SamplerResult | None + ) -> np.ndarray | SparseArray | None: """ Post-processing during forward pass of the network. """ + + if result is None: + return None + if self._sparse: # pylint: disable=import-error from sparse import DOK @@ -233,30 +252,15 @@ def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray: else: return prob - def _forward( - self, - input_data: list[float] | np.ndarray | float, - weights: list[float] | np.ndarray | float, - ) -> np.ndarray | SparseArray: - """ - Forward pass of the network. - """ - parameter_values, num_samples = self._preprocess(input_data, weights) - - # sampler allows batching - job = self.sampler.run([self._circuit] * num_samples, parameter_values) - results = job.result() - - result = self._postprocess(num_samples, results) - - return result - def _postprocess_gradient( - self, num_samples: int, results: SamplerGradientResult - ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray]: + self, num_samples: int | None, results: SamplerGradientResult | None + ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray | None]: """ Post-processing during backward pass of the network. """ + if num_samples is None or results is None: + return None, None + if self._sparse: # pylint: disable=import-error from sparse import DOK @@ -268,6 +272,7 @@ def _postprocess_gradient( ) weights_grad = DOK((num_samples, *self._output_shape, self._num_weights)) else: + input_grad = ( np.zeros((num_samples, *self._output_shape, self._num_inputs)) if self._input_gradients @@ -283,14 +288,13 @@ def _postprocess_gradient( for sample in range(num_samples): for i in range(num_grad_vars): grad = results.gradients[sample][i] - - for k in grad.keys(): - val = results.gradients[sample][i][k] + for k, val in grad.items(): # get index for input or weights gradients if self._input_gradients: grad_index = i if i < self._num_inputs else i - self._num_inputs else: grad_index = i + # interpret integer and construct key key = self._interpret(k) if isinstance(key, Integral): @@ -317,26 +321,53 @@ def _postprocess_gradient( return input_grad, weights_grad + def _forward( + self, + input_data: np.ndarray | None, + weights: np.ndarray | None, + ) -> np.ndarray | SparseArray | None: + """ + Forward pass of the network. + """ + parameter_values, num_samples = self._preprocess(input_data, weights) + + if num_samples is not None and np.prod(parameter_values.shape) > 0: + # sampler allows batching + job = self.sampler.run([self._circuit] * num_samples, parameter_values) + results = job.result() + else: + results = None + + result = self._postprocess(num_samples, results) + + return result + def _backward( self, - input_data: list[float] | np.ndarray | float, - weights: list[float] | np.ndarray | float, - ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray]: + input_data: np.ndarray | None, + weights: np.ndarray | None, + ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray | None]: """Backward pass of the network.""" # prepare parameters in the required format parameter_values, num_samples = self._preprocess(input_data, weights) - if self._input_gradients: - job = self.gradient.run([self._circuit] * num_samples, parameter_values) + if num_samples is not None and np.prod(parameter_values.shape) > 0: + if self._input_gradients: + job = self.gradient.run([self._circuit] * num_samples, parameter_values) + results = job.result() + else: + if len(parameter_values[0]) is not self._num_inputs: + job = self.gradient.run( + [self._circuit] * num_samples, + parameter_values, + parameters=[self._circuit.parameters[self._num_inputs :]] * num_samples, + ) + results = job.result() + else: + results = None else: - job = self.gradient.run( - [self._circuit] * num_samples, - parameter_values, - parameters=[self._circuit.parameters[self._num_inputs :]] * num_samples, - ) - - results = job.result() + results = None input_grad, weights_grad = self._postprocess_gradient(num_samples, results) diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py index e4f2a7a14..b723a1843 100644 --- a/test/neural_networks/test_sampler_qnn.py +++ b/test/neural_networks/test_sampler_qnn.py @@ -18,26 +18,36 @@ import unittest import numpy as np -from ddt import ddt, idata, unpack +from ddt import ddt, idata from qiskit.circuit import QuantumCircuit from qiskit.primitives import Sampler -from qiskit.algorithms.gradients import ParamShiftSamplerGradient from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap -from qiskit.utils import QuantumInstance, algorithm_globals +from qiskit.utils import algorithm_globals -from qiskit_machine_learning.neural_networks import CircuitQNN from qiskit_machine_learning.neural_networks.sampler_qnn import SamplerQNN import qiskit_machine_learning.optionals as _optionals -algorithm_globals.random_seed = 42 +if _optionals.HAS_SPARSE: + # pylint: disable=import-error + from sparse import SparseArray +else: + + class SparseArray: # type: ignore + """Empty SparseArray class + Replacement if sparse.SparseArray is not present. + """ + + pass + DEFAULT = "default" SHOTS = "shots" SPARSE = [True, False] SAMPLERS = [DEFAULT, SHOTS] -INTERPRET_TYPES = [2] -BATCH_SIZES = [1, 2] +INTERPRET_TYPES = [0, 1, 2] +BATCH_SIZES = [2] +INPUT_GRADS = [True, False] @ddt @@ -48,10 +58,6 @@ def setUp(self): super().setUp() algorithm_globals.random_seed = 12345 - # # define test circuit - # num_qubits = 3 - # self.qc = RealAmplitudes(num_qubits, entanglement="linear", reps=1) - # define feature map and ansatz num_qubits = 2 feature_map = ZZFeatureMap(num_qubits, reps=1) @@ -84,9 +90,13 @@ def interpret_2d(x): # define sampler primitives self.sampler = Sampler() - self.sampler_shots = Sampler(options={"shots": 100}) + self.sampler_shots = Sampler(options={"shots": 100, "seed": 42}) + + self.array_type = {True: SparseArray, False: np.ndarray} - def _get_qnn(self, sparse, sampler_type, interpret_id): + def _get_qnn( + self, sparse, sampler_type, interpret_id, input_params, weight_params, input_grads + ): """Construct QNN from configuration.""" # get quantum instance @@ -111,73 +121,103 @@ def _get_qnn(self, sparse, sampler_type, interpret_id): qnn = SamplerQNN( sampler=sampler, circuit=self.qc, - input_params=self.input_params, - weight_params=self.weight_params, + input_params=input_params, + weight_params=weight_params, sparse=sparse, interpret=interpret, output_shape=output_shape, + input_gradients=input_grads, ) return qnn def _verify_qnn( - self, - qnn: CircuitQNN, - batch_size: int, + self, qnn: SamplerQNN, batch_size: int, input_data: np.ndarray, weights: np.ndarray ) -> None: """ Verifies that a QNN functions correctly """ - # pylint: disable=import-error - from sparse import SparseArray - - input_data = np.zeros((batch_size, qnn.num_inputs)) - weights = np.zeros(qnn.num_weights) - # evaluate QNN forward pass result = qnn.forward(input_data, weights) - # make sure forward result is sparse if it should be - if qnn.sparse: - self.assertTrue(isinstance(result, SparseArray)) - else: - self.assertTrue(isinstance(result, np.ndarray)) + if input_data is None: + batch_size = 1 + self.assertTrue(isinstance(result, self.array_type[qnn.sparse])) # check forward result shape self.assertEqual(result.shape, (batch_size, *qnn.output_shape)) # evaluate QNN backward pass input_grad, weights_grad = qnn.backward(input_data, weights) - # verify that input gradients are None if turned off - self.assertIsNone(input_grad) - self.assertEqual(weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)) - - if qnn.sparse: - self.assertTrue(isinstance(weights_grad, SparseArray)) - else: - self.assertTrue(isinstance(weights_grad, np.ndarray)) - - # verify that input gradients are not None if turned on - qnn.input_gradients = True - input_grad, weights_grad = qnn.backward(input_data, weights) - - self.assertEqual(input_grad.shape, (batch_size, *qnn.output_shape, qnn.num_inputs)) - self.assertEqual(weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)) + if qnn.input_gradients: + if input_data is not None: + self.assertEqual(input_grad.shape, (batch_size, *qnn.output_shape, qnn.num_inputs)) + self.assertTrue(isinstance(input_grad, self.array_type[qnn.sparse])) + else: + # verify that input gradients are None if turned off + self.assertIsNone(input_grad) + if weights is not None: + self.assertEqual( + weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights) + ) + self.assertTrue(isinstance(weights_grad, self.array_type[qnn.sparse])) + else: + # verify that input gradients are None if turned off + self.assertIsNone(weights_grad) - if qnn.sparse: - self.assertTrue(isinstance(weights_grad, SparseArray)) - self.assertTrue(isinstance(input_grad, SparseArray)) else: - self.assertTrue(isinstance(weights_grad, np.ndarray)) - self.assertTrue(isinstance(input_grad, np.ndarray)) + # verify that input gradients are None if turned off + self.assertIsNone(input_grad) + if weights is not None: + self.assertEqual( + weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights) + ) + self.assertTrue(isinstance(weights_grad, self.array_type[qnn.sparse])) @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.") - @idata(itertools.product(SPARSE, SAMPLERS, INTERPRET_TYPES, BATCH_SIZES)) - @unpack - def test_sampler_qnn(self, sparse: bool, sampler_type, interpret_type, batch_size): + @idata(itertools.product(SPARSE, SAMPLERS, INTERPRET_TYPES, BATCH_SIZES, INPUT_GRADS)) + def test_sampler_qnn(self, config): """Sampler QNN Test.""" - qnn = self._get_qnn(sparse, sampler_type, interpret_type) - self._verify_qnn(qnn, batch_size) + + sparse, sampler_type, interpret_type, batch_size, input_grads = config + # Test QNN with input and weight params + qnn = self._get_qnn( + sparse, + sampler_type, + interpret_type, + input_params=self.input_params, + weight_params=self.weight_params, + input_grads=True, + ) + input_data = np.zeros((batch_size, qnn.num_inputs)) + weights = np.zeros(qnn.num_weights) + self._verify_qnn(qnn, batch_size, input_data, weights) + + # Test QNN with no input params + qnn = self._get_qnn( + sparse, + sampler_type, + interpret_type, + input_params=None, + weight_params=self.weight_params + self.input_params, + input_grads=input_grads, + ) + input_data = None + weights = np.zeros(qnn.num_weights) + self._verify_qnn(qnn, batch_size, input_data, weights) + + # Test QNN with no weight params + qnn = self._get_qnn( + sparse, + sampler_type, + interpret_type, + input_params=self.weight_params + self.input_params, + weight_params=None, + input_grads=input_grads, + ) + input_data = np.zeros((batch_size, qnn.num_inputs)) + weights = None + self._verify_qnn(qnn, batch_size, input_data, weights) @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.") @idata(itertools.product(SPARSE, INTERPRET_TYPES, BATCH_SIZES)) @@ -188,10 +228,15 @@ def test_sampler_qnn_gradient(self, config): sparse, interpret_id, batch_size = config # get QNN - qnn = self._get_qnn(sparse, DEFAULT, interpret_id) + qnn = self._get_qnn( + sparse, + DEFAULT, + interpret_id, + input_params=self.input_params, + weight_params=self.weight_params, + input_grads=True, + ) - # set input gradients to True - qnn.input_gradients = True input_data = np.ones((batch_size, qnn.num_inputs)) weights = np.ones(qnn.num_weights) input_grad, weights_grad = qnn.backward(input_data, weights) @@ -227,53 +272,3 @@ def test_sampler_qnn_gradient(self, config): ].reshape(grad.shape) diff = weights_grad_ - grad self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3) - - def test_circuit_vs_sampler_qnn(self): - """Circuit vs Sampler QNN Test. To be removed once CircuitQNN is deprecated""" - from qiskit.opflow import Gradient - import importlib - - aer = importlib.import_module("qiskit.providers.aer") - - parity = lambda x: f"{x:b}".count("1") % 2 - output_shape = 2 # this is required in case of a callable with dense output - - qi_qasm = QuantumInstance( - aer.AerSimulator(), - shots=100, - seed_simulator=algorithm_globals.random_seed, - seed_transpiler=algorithm_globals.random_seed, - ) - - circuit_qnn = CircuitQNN( - self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - sparse=False, - interpret=parity, - output_shape=output_shape, - quantum_instance=qi_qasm, - gradient=Gradient("param_shift"), - input_gradients=True, - ) - - sampler_qnn = SamplerQNN( - sampler=self.sampler, - circuit=self.qc, - input_params=self.qc.parameters[:3], - weight_params=self.qc.parameters[3:], - interpret=parity, - output_shape=output_shape, - gradient=ParamShiftSamplerGradient(self.sampler), - input_gradients=True, - ) - - inputs = np.asarray(algorithm_globals.random.random(size=(1, circuit_qnn._num_inputs))) - weights = algorithm_globals.random.random(circuit_qnn._num_weights) - - circuit_qnn_fwd = circuit_qnn.backward(inputs, weights) - sampler_qnn_fwd = sampler_qnn.backward(inputs, weights) - - np.testing.assert_array_almost_equal( - np.asarray(sampler_qnn_fwd), np.asarray(circuit_qnn_fwd), 0.1 - ) From b2db7b89e7a796b3b8610b3936fd5e33eb342493 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 17 Oct 2022 13:54:28 +0200 Subject: [PATCH 49/96] Fix tests, final refactor, add docstring --- .../algorithms/classifiers/vqc.py | 23 ++-- .../neural_networks/sampler_qnn.py | 20 +++- test/algorithms/classifiers/test_vqc.py | 113 ++++++------------ .../test_circuit_vs_sampler_qnn.py | 111 +++++++++++++++++ 4 files changed, 176 insertions(+), 91 deletions(-) create mode 100644 test/neural_networks/test_circuit_vs_sampler_qnn.py diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 0375a6cb4..8a7994968 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -12,7 +12,7 @@ """An implementation of variational quantum classifier.""" from __future__ import annotations -from typing import Callable, cast +from typing import Callable import numpy as np @@ -107,25 +107,25 @@ def __init__( # needed for mypy neural_network: SamplerQNN | CircuitQNN = None if quantum_instance is not None: - # construct sampler QNN - neural_network = SamplerQNN( - sampler=sampler, - circuit=self._circuit, + # construct circuit QNN only if qi is provided + neural_network = CircuitQNN( + self._circuit, input_params=self.feature_map.parameters, weight_params=self.ansatz.parameters, interpret=self._get_interpret(2), output_shape=2, + quantum_instance=quantum_instance, input_gradients=False, ) else: - # construct circuit QNN - neural_network = CircuitQNN( - self._circuit, + # construct sampler QNN by default + neural_network = SamplerQNN( + sampler=sampler, + circuit=self._circuit, input_params=self.feature_map.parameters, weight_params=self.ansatz.parameters, interpret=self._get_interpret(2), output_shape=2, - quantum_instance=quantum_instance, input_gradients=False, ) @@ -173,12 +173,11 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: X, y = self._validate_input(X, y) num_classes = self._num_classes + # instance check required by mypy (alternative to cast) if isinstance(self._neural_network, SamplerQNN): self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) elif isinstance(self._neural_network, CircuitQNN): - cast(CircuitQNN, self._neural_network).set_interpret( - self._get_interpret(num_classes), num_classes - ) + self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) return super()._minimize(X, y) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 44b4db37c..3c6a4ea1e 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -48,7 +48,20 @@ class SparseArray: # type: ignore class SamplerQNN(NeuralNetwork): - """A Neural Network implementation based on the Sampler primitive.""" + """A Neural Network implementation based on the Sampler primitive. + + The ``Sampler QNN`` is a neural network that takes in a parametrized quantum circuit + with the combined network's feature map (input parameters) and ansatz (weight parameters) + and outputs its measurements for the forward and backward passes. + The output can be set up in different formats, and an optional post-processing step + can be used to interpret the sampler's output in a particular context (e.g. mapping the + resulting bitstring to match the number of classes). + + Attributes: + + sampler (BaseSampler): The sampler primitive used to compute the neural network's results. + gradient (BaseSamplerGradient): An optional sampler gradient to be used for the backward pass. + """ def __init__( self, @@ -65,7 +78,7 @@ def __init__( ): """ Args: - sampler: The sampler primitive used to compute neural network's results. + sampler: The sampler primitive used to compute the neural network's results. circuit: The parametrized quantum circuit that generates the samples of this network. input_params: The parameters of the circuit corresponding to the input. weight_params: The parameters of the circuit corresponding to the trainable weights. @@ -108,11 +121,8 @@ def __init__( _optionals.HAS_SPARSE.require_now("DOK") self.set_interpret(interpret, output_shape) - self._input_gradients = input_gradients - # TODO: look into custom transpilation - super().__init__( num_inputs=len(self._input_params), num_weights=len(self._weight_params), diff --git a/test/algorithms/classifiers/test_vqc.py b/test/algorithms/classifiers/test_vqc.py index 1141db3be..5c98bd978 100644 --- a/test/algorithms/classifiers/test_vqc.py +++ b/test/algorithms/classifiers/test_vqc.py @@ -36,7 +36,7 @@ from qiskit_machine_learning.algorithms import VQC from qiskit_machine_learning.exceptions import QiskitMachineLearningError -QUANTUM_INSTANCES = ["statevector", "sampler", "qasm"] +RUN_METHODS = ["statevector", "sampler", "qasm"] NUM_QUBITS_LIST = [2, None] FEATURE_MAPS = ["zz_feature_map", None] ANSATZES = ["real_amplitudes", None] @@ -93,9 +93,6 @@ def setUp(self): sampler = Sampler() # We want string keys to ensure DDT-generated tests have meaningful names. self.properties = { - "statevector": statevector, - "qasm": qasm, - "sampler": sampler, "bfgs": L_BFGS_B(maxiter=5), "cobyla": COBYLA(maxiter=25), "real_amplitudes": RealAmplitudes(num_qubits=2, reps=1), @@ -105,13 +102,19 @@ def setUp(self): "no_one_hot": _create_dataset(6, 2, one_hot=False), } + self.run_methods = { # Tuple of type: (primitive, qi) + "sampler": (sampler, None), + "statevector": (None, statevector), + "qasm": (None, qasm), + } + @idata( itertools.product( - QUANTUM_INSTANCES, NUM_QUBITS_LIST, FEATURE_MAPS, ANSATZES, OPTIMIZERS, DATASETS + RUN_METHODS, NUM_QUBITS_LIST, FEATURE_MAPS, ANSATZES, OPTIMIZERS, DATASETS ) ) @unpack - def test_VQC(self, q_i, num_qubits, f_m, ans, opt, d_s): + def test_VQC(self, run_method, num_qubits, f_m, ans, opt, d_s): """ Test VQC with binary and multiclass data using a range of quantum instances, numbers of qubits, feature maps, and optimizers. @@ -120,12 +123,8 @@ def test_VQC(self, q_i, num_qubits, f_m, ans, opt, d_s): self.skipTest( "At least one of num_qubits, feature_map, or ansatz must be set by the user." ) - if q_i != "sampler": - sampler = None - quantum_instance = self.properties.get(q_i) - else: - sampler = self.properties.get(q_i) - quantum_instance = None + + sampler, quantum_instance = self.run_methods.get(run_method) feature_map = self.properties.get(f_m) optimizer = self.properties.get(opt) @@ -155,17 +154,12 @@ def test_VQC(self, q_i, num_qubits, f_m, ans, opt, d_s): # the predicted value should be in the labels self.assertTrue(np.all(predict == unique_labels, axis=1).any()) - @idata(QUANTUM_INSTANCES[:-1]) - def test_VQC_non_parameterized(self, test): + @idata(RUN_METHODS[:-1]) + def test_VQC_non_parameterized(self, run_method): """ Test VQC without an optimizer set. """ - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) classifier = VQC( sampler=sampler, @@ -178,17 +172,12 @@ def test_VQC_non_parameterized(self, test): score = classifier.score(dataset.x, dataset.y) self.assertGreater(score, 0.5) - @idata(itertools.product(DATASETS, QUANTUM_INSTANCES[:-1])) + @idata(itertools.product(DATASETS, RUN_METHODS[:-1])) @unpack - def test_warm_start(self, d_s, test): + def test_warm_start(self, d_s, run_method): """Test VQC when training from a warm start.""" - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) classifier = VQC( sampler=sampler, @@ -223,16 +212,11 @@ def wrapper(num_classes): return wrapper - @idata(QUANTUM_INSTANCES[:-1]) - def test_batches_with_incomplete_labels(self, test): + @idata(RUN_METHODS[:-1]) + def test_batches_with_incomplete_labels(self, run_method): """Test VQC when targets are one-hot and some batches don't have all possible labels.""" - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) # Generate data with batches that have incomplete labels. x = algorithm_globals.random.random((6, 2)) @@ -263,16 +247,11 @@ def test_batches_with_incomplete_labels(self, test): with self.subTest("Check correct number of classes is used to build CircuitQNN."): self.assertTrue((np.asarray(self.num_classes_by_batch) == 3).all()) - @idata(QUANTUM_INSTANCES[:-1]) - def test_multilabel_targets_raise_an_error(self, test): + @idata(RUN_METHODS[:-1]) + def test_multilabel_targets_raise_an_error(self, run_method): """Tests VQC multi-label input raises an error.""" - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) # Generate multi-label data. x = algorithm_globals.random.random((3, 2)) @@ -282,16 +261,11 @@ def test_multilabel_targets_raise_an_error(self, test): with self.assertRaises(QiskitMachineLearningError): classifier.fit(x, y) - @idata(QUANTUM_INSTANCES[:-1]) - def test_changing_classes_raises_error(self, test): + @idata(RUN_METHODS[:-1]) + def test_changing_classes_raises_error(self, run_method): """Tests VQC raises an error when fitting new data with a different number of classes.""" - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) targets1 = np.asarray([[0, 0, 1], [0, 1, 0]]) targets2 = np.asarray([[0, 1], [1, 0]]) @@ -305,15 +279,16 @@ def test_changing_classes_raises_error(self, test): with self.assertRaises(QiskitMachineLearningError): classifier.fit(features2, targets2) - @idata(itertools.product(QUANTUM_INSTANCES, LOSSES)) + @idata(itertools.product(RUN_METHODS, LOSSES)) @unpack - def test_sparse_arrays(self, q_i, loss): + def test_sparse_arrays(self, run_method, loss): """Tests VQC on sparse features and labels.""" - if q_i == "sampler": - self.skipTest("skipping test because SamplerQNN does not support sparse arrays") - quantum_instance = self.properties.get(q_i) - classifier = VQC(num_qubits=2, loss=loss, quantum_instance=quantum_instance) + sampler, quantum_instance = self.run_methods.get(run_method) + + classifier = VQC( + sampler=sampler, num_qubits=2, loss=loss, quantum_instance=quantum_instance + ) x = scipy.sparse.csr_matrix([[0, 0], [1, 1]]) y = scipy.sparse.csr_matrix([[1, 0], [0, 1]]) @@ -322,16 +297,11 @@ def test_sparse_arrays(self, q_i, loss): score = classifier.score(x, y) self.assertGreaterEqual(score, 0.5) - @idata(QUANTUM_INSTANCES[:-1]) - def test_categorical(self, test): + @idata(RUN_METHODS[:-1]) + def test_categorical(self, run_method): """Test VQC on categorical labels.""" - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) classifier = VQC( sampler=sampler, @@ -352,16 +322,11 @@ def test_categorical(self, test): predict = classifier.predict(features[0, :]) self.assertIn(predict, ["A", "B"]) - @idata(QUANTUM_INSTANCES[:-1]) - def test_circuit_extensions(self, test): + @idata(RUN_METHODS[:-1]) + def test_circuit_extensions(self, run_method): """Test VQC when the number of qubits is different compared to the feature map/ansatz.""" - if test != "sampler": - sampler = None - quantum_instance = self.properties.get(test) - else: - sampler = self.properties.get(test) - quantum_instance = None + sampler, quantum_instance = self.run_methods.get(run_method) num_qubits = 2 classifier = VQC( diff --git a/test/neural_networks/test_circuit_vs_sampler_qnn.py b/test/neural_networks/test_circuit_vs_sampler_qnn.py new file mode 100644 index 000000000..045edafae --- /dev/null +++ b/test/neural_networks/test_circuit_vs_sampler_qnn.py @@ -0,0 +1,111 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Test Sampler QNN vs Circuit QNN.""" + +from test import QiskitMachineLearningTestCase + +import itertools +import unittest +import numpy as np +from ddt import ddt, idata + +from qiskit import BasicAer +from qiskit.algorithms.gradients import ParamShiftSamplerGradient +from qiskit.circuit import QuantumCircuit +from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap +from qiskit.opflow import Gradient +from qiskit.primitives import Sampler +from qiskit.utils import QuantumInstance, algorithm_globals + +from qiskit_machine_learning.neural_networks import CircuitQNN, SamplerQNN +import qiskit_machine_learning.optionals as _optionals + +SPARSE = [True, False] +INPUT_GRADS = [True, False] + + +@ddt +class TestCircuitvsSamplerQNN(QiskitMachineLearningTestCase): + """Circuit vs Sampler QNN Tests. To be removed once CircuitQNN is deprecated""" + + def setUp(self): + super().setUp() + algorithm_globals.random_seed = 10598 + + self.parity = lambda x: f"{x:b}".count("1") % 2 + self.output_shape = 2 # this is required in case of a callable with dense output + + # define feature map and ansatz + num_qubits = 2 + feature_map = ZZFeatureMap(num_qubits, reps=1) + var_form = RealAmplitudes(num_qubits, reps=1) + # construct circuit + self.qc = QuantumCircuit(num_qubits) + self.qc.append(feature_map, range(2)) + self.qc.append(var_form, range(2)) + + # store params + self.input_params = list(feature_map.parameters) + self.weight_params = list(var_form.parameters) + + self.sampler = Sampler() + + @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.") + @idata(itertools.product(SPARSE, INPUT_GRADS)) + def test_new_vs_old(self, config): + """Circuit vs Sampler QNN Test. To be removed once CircuitQNN is deprecated""" + + sparse, input_grads = config + qi_sv = QuantumInstance(BasicAer.get_backend("statevector_simulator")) + + circuit_qnn = CircuitQNN( + self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + sparse=sparse, + interpret=self.parity, + output_shape=self.output_shape, + quantum_instance=qi_sv, + gradient=Gradient("param_shift"), + input_gradients=input_grads, + ) + + sampler_qnn = SamplerQNN( + sampler=self.sampler, + circuit=self.qc, + input_params=self.qc.parameters[:3], + weight_params=self.qc.parameters[3:], + interpret=self.parity, + output_shape=self.output_shape, + gradient=ParamShiftSamplerGradient(self.sampler), + input_gradients=input_grads, + ) + + inputs = np.asarray(algorithm_globals.random.random(size=(3, circuit_qnn._num_inputs))) + weights = algorithm_globals.random.random(circuit_qnn._num_weights) + + circuit_qnn_fwd = circuit_qnn.forward(inputs, weights) + sampler_qnn_fwd = sampler_qnn.forward(inputs, weights) + + diff_fwd = circuit_qnn_fwd - sampler_qnn_fwd + self.assertAlmostEqual(np.max(np.abs(diff_fwd)), 0.0, places=3) + + circuit_qnn_input_grads, circuit_qnn_weight_grads = circuit_qnn.backward(inputs, weights) + sampler_qnn_input_grads, sampler_qnn_weight_grads = sampler_qnn.backward(inputs, weights) + + diff_weight = circuit_qnn_weight_grads - sampler_qnn_weight_grads + self.assertAlmostEqual(np.max(np.abs(diff_weight)), 0.0, places=3) + + if input_grads: + diff_input = circuit_qnn_input_grads - sampler_qnn_input_grads + self.assertAlmostEqual(np.max(np.abs(diff_input)), 0.0, places=3) From f3a79919d5977347383aa3bce9aa385c73fca1c2 Mon Sep 17 00:00:00 2001 From: ElePT Date: Mon, 17 Oct 2022 14:20:14 +0200 Subject: [PATCH 50/96] Add Sampler QNN --- .../add-sampler-qnn-a093431afc1c5441.yaml | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 releasenotes/notes/add-sampler-qnn-a093431afc1c5441.yaml diff --git a/releasenotes/notes/add-sampler-qnn-a093431afc1c5441.yaml b/releasenotes/notes/add-sampler-qnn-a093431afc1c5441.yaml new file mode 100644 index 000000000..a7a8f33bc --- /dev/null +++ b/releasenotes/notes/add-sampler-qnn-a093431afc1c5441.yaml @@ -0,0 +1,54 @@ +--- +features: + - | + Introduced Sampler Quantum Neural Network + (:class:`~qiskit_machine_learning.neural_networks.SamplerQNN`) based on (runtime) primitives. + This implementation leverages the sampler primitive + (see :class:`~qiskit.primitives.BaseSampler`) and the sampler gradients + (see :class:`~qiskit.algorithms.gradients.BaseSamplerGradient`) to enable runtime access and + more efficient computation of forward and backward passes more efficiently. + + The new Sampler QNN exposes a similar interface to the Circuit QNN, with a few differences. + One is the `quantum_instance` parameter. This parameter does not have a direct replacement, + and instead the `sampler` parameter must be used. The `gradient` parameter keeps the same name + as in the Circuit QNN implementation, but it no longer accepts Opflow gradient classes as inputs; + instead, this parameter expects an (optionally custom) primitive gradient. The `sampling` option + has been removed for the time being, as this information is not currently exposed by the `Sampler`, + and might correspond to future lower-level primitives. + + The existing training algorithms such as :class:`~qiskit_machine_learning.algorithms.VQC`, + that were based on the Circuit QNN, are updated to accept both implementations. The implementation + of :class:`~qiskit_machine_learning.algorithms.NeuralNetworkClassifier` has not changed. + + For example a `VQC` using `SamplerQNN` can be trained as follows: + + .. code-block:: python + + from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes + from qiskit.algorithms.optimizers import COBYLA + from qiskit.primitives import Sampler + from sklearn.datasets import make_blobs + + from qiskit_machine_learning.algorithms import VQC + + # generate a simple dataset + num_inputs = 20 + features, labels = make_blobs(n_samples=num_inputs, centers=2, center_box=(-1, 1), cluster_std=0.1) + + # construct feature map + feature_map = ZZFeatureMap(num_inputs) + + # construct ansatz + ansatz = RealAmplitudes(num_inputs, reps=1) + + # construct variational quantum classifier + vqc = VQC( + sampler=sampler, + feature_map=feature_map, + ansatz=ansatz, + loss="cross_entropy", + optimizer=COBYLA(maxiter=30), + ) + + # fit classifier to data + vqc.fit(features, labels) From 349fb8abac75ed7cf79b1b7fc5064317053626c1 Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Wed, 19 Oct 2022 11:25:12 +0200 Subject: [PATCH 51/96] Update qiskit_machine_learning/algorithms/classifiers/vqc.py Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- qiskit_machine_learning/algorithms/classifiers/vqc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 8a7994968..2acb07fd4 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -58,7 +58,7 @@ def __init__( initial_point: np.ndarray | None = None, callback: Callable[[np.ndarray, float], None] | None = None, *, - sampler: BaseSampler = None, + sampler: BaseSampler | None = None, ) -> None: """ Args: From 2da01a7f01bc17832011b6cf8931f414a399bc92 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 19 Oct 2022 18:49:40 +0900 Subject: [PATCH 52/96] updated --- .../neural_networks/estimator_qnn.py | 116 +++++++++--------- .../neural_networks/two_layer_qnn.py | 109 ++-------------- 2 files changed, 73 insertions(+), 152 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 8d4c48242..dca2f97fe 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -11,8 +11,11 @@ # that they have been altered from the originals. """Estimator quantum neural network class""" + +from __future__ import annotations + import logging -from typing import Optional, Sequence, Tuple, Union +from typing import Sequence, Tuple import numpy as np from qiskit.algorithms.gradients import BaseEstimatorGradient @@ -20,24 +23,10 @@ from qiskit.opflow import PauliSumOp from qiskit.primitives import BaseEstimator from qiskit.quantum_info.operators.base_operator import BaseOperator - -import qiskit_machine_learning.optionals as _optionals +from qiskit_machine_learning.exceptions import QiskitMachineLearningError from .neural_network import NeuralNetwork -if _optionals.HAS_SPARSE: - # pylint: disable=import-error - from sparse import SparseArray -else: - - class SparseArray: # type: ignore - """Empty SparseArray class - Replacement if sparse.SparseArray is not present. - """ - - pass - - logger = logging.getLogger(__name__) @@ -48,10 +37,10 @@ def __init__( self, estimator: BaseEstimator, circuit: QuantumCircuit, - observables: Sequence[Union[BaseOperator, PauliSumOp]], - input_params: Optional[Sequence[Parameter]] = None, - weight_params: Optional[Sequence[Parameter]] = None, - gradient: Optional[BaseEstimatorGradient] = None, + observables: Sequence[BaseOperator | PauliSumOp], + input_params: Sequence[Parameter] | None = None, + weight_params: Sequence[Parameter] | None = None, + gradient: BaseEstimatorGradient | None = None, input_gradients: bool = False, ): """ @@ -59,9 +48,12 @@ def __init__( estimator: The estimator used to compute neural network's results. circuit: The quantum circuit to represent the neural network. observables: The observables for outputs of the neural network. - input_params: The parameters that correspond to the input of the network. + input_params: The parameters that correspond to the input data of the network. + If None, the input data is not bound to any parameters. weight_params: The parameters that correspond to the trainable weights. + If None, the weights are not bound to any parameters. gradient: The estimator gradient to be used for the backward pass. + If None, the gradient is not computed. input_gradients: Determines whether to compute gradients with respect to input data. Note that this parameter is ``False`` by default, and must be explicitly set to ``True`` for a proper gradient computation when using ``TorchConnector``. @@ -69,10 +61,10 @@ def __init__( self._estimator = estimator self._circuit = circuit self._observables = observables - self._input_params = list(input_params) or [] - self._weight_params = list(weight_params) or [] + self._input_params = list(input_params) if input_params is not None else [] + self._weight_params = list(weight_params) if weight_params is not None else [] self._gradient = gradient - self.input_gradients = input_gradients + self._input_gradients = input_gradients super().__init__( len(self._input_params), @@ -83,7 +75,7 @@ def __init__( ) @property - def observables(self): + def observables(self) -> Sequence[BaseOperator | PauliSumOp]: """Returns the underlying observables of this QNN.""" return self._observables @@ -99,21 +91,21 @@ def input_gradients(self, input_gradients: bool) -> None: self._input_gradients = input_gradients def _preprocess(self, input_data, weights): - """Pre-processing during forward pass of the network.""" - if len(input_data.shape) == 1: - input_data = np.expand_dims(input_data, 0) - num_samples = input_data.shape[0] - # quick fix for 0 inputs - if num_samples == 0: - num_samples = 1 - - parameter_values = [] - for i in range(num_samples): - param_values = [input_data[i, j] for j, input_param in enumerate(self._input_params)] - param_values += [weights[j] for j, weight_param in enumerate(self._weight_params)] - parameter_values.append(param_values) - - return parameter_values, num_samples + """Pre-processing during the forward pass and backward pass of the network.""" + if input_data is not None: + num_samples = input_data.shape[0] + if weights is not None: + weights = np.broadcast_to(weights, (num_samples, len(weights))) + parameters = np.concatenate((input_data, weights), axis=1) + else: + parameters = input_data + else: + if weights is not None: + num_samples = 1 + parameters = np.broadcast_to(weights, (num_samples, len(weights))) + else: + return None, None + return parameters, num_samples def _forward_postprocess(self, num_samples, results): """Post-processing during forward pass of the network.""" @@ -124,20 +116,27 @@ def _forward_postprocess(self, num_samples, results): return res def _forward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - ) -> Union[np.ndarray, SparseArray]: + self, input_data: np.ndarray | None, weights: np.ndarray | None + ) -> np.ndarray | None: """Forward pass of the neural network.""" parameter_values_, num_samples = self._preprocess(input_data, weights) - parameter_values = [ - param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) - ] - job = self._estimator.run( - [self._circuit] * num_samples * self.output_shape[0], - self._observables * num_samples, - parameter_values, - ) - results = job.result() - return self._forward_postprocess(num_samples, results) + if num_samples is None: + return None + else: + parameter_values = [ + param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) + ] + job = self._estimator.run( + [self._circuit] * num_samples * self.output_shape[0], + self._observables * num_samples, + parameter_values, + ) + try: + results = job.result() + except Exception as exc: + raise QiskitMachineLearningError("Estimator job failed.") from exc + + return self._forward_postprocess(num_samples, results) def _backward_postprocess(self, num_samples, results): """Post-processing during backward pass of the network.""" @@ -169,9 +168,12 @@ def _backward_postprocess(self, num_samples, results): return input_grad, weights_grad def _backward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: + self, input_data: np.ndarray | None, weights: np.ndarray | None + ) -> Tuple[np.ndarray | None, np.ndarray | None]: """Backward pass of the network.""" + # if no gradient is set, return None + if self._gradient is None: + return None, None # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) parameter_values = [ @@ -193,6 +195,10 @@ def _backward( * self.output_shape[0], ) - results = job.result() + try: + results = job.result() + except Exception as exc: + raise QiskitMachineLearningError("Estimator job failed.") from exc + input_grad, weights_grad = self._backward_postprocess(num_samples, results) return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector diff --git a/qiskit_machine_learning/neural_networks/two_layer_qnn.py b/qiskit_machine_learning/neural_networks/two_layer_qnn.py index cc4686b0d..e5ab2d274 100644 --- a/qiskit_machine_learning/neural_networks/two_layer_qnn.py +++ b/qiskit_machine_learning/neural_networks/two_layer_qnn.py @@ -15,40 +15,19 @@ be trained to solve a particular tasks.""" from __future__ import annotations -import warnings -from typing import Optional, Sequence, Tuple, Union - -import numpy as np from qiskit import QuantumCircuit -from qiskit.algorithms.gradients import BaseEstimatorGradient -from qiskit.opflow import ExpectationBase, OperatorBase, PauliSumOp, StateFn -from qiskit.primitives import BaseEstimator +from qiskit.opflow import PauliSumOp, StateFn, OperatorBase, ExpectationBase from qiskit.providers import Backend from qiskit.utils import QuantumInstance -import qiskit_machine_learning.optionals as _optionals - -from ..utils import derive_num_qubits_feature_map_ansatz -from .estimator_qnn import EstimatorQNN -from .neural_network import NeuralNetwork from .opflow_qnn import OpflowQNN +from ..utils import derive_num_qubits_feature_map_ansatz -if _optionals.HAS_SPARSE: - # pylint: disable=import-error - from sparse import SparseArray -else: - class SparseArray: # type: ignore - """Empty SparseArray class - Replacement if sparse.SparseArray is not present. - """ - - pass -class TwoLayerQNN(NeuralNetwork): +class TwoLayerQNN(OpflowQNN): """Two Layer Quantum Neural Network consisting of a feature map, a ansatz, and an observable. """ - #TODO: inherit from EstimatorQNN after deprecation of OpflowQNN def __init__( self, @@ -59,8 +38,6 @@ def __init__( exp_val: ExpectationBase | None = None, quantum_instance: QuantumInstance | Backend | None = None, input_gradients: bool = False, - estimator: BaseEstimator | None = None, - gradient: BaseEstimatorGradient | None = None, ): r""" Args: @@ -86,7 +63,6 @@ def __init__( QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz can't be adjusted to ``num_qubits``. - ValueError: If both ``quantum_instance`` and ``estimator`` are given. """ num_qubits, feature_map, ansatz = derive_num_qubits_feature_map_ansatz( @@ -105,83 +81,22 @@ def __init__( self._circuit.append(self._ansatz, range(num_qubits)) # construct observable - self._observable = ( + self.observable = ( observable if observable is not None else PauliSumOp.from_list([("Z" * num_qubits, 1)]) ) - if quantum_instance is not None and estimator is not None: - raise ValueError("Only one of quantum_instance or sampler can be passed, not both!") - - # # check positionally passing the sampler in the place of quantum_instance - # # which will be removed in future - # if isinstance(quantum_instance, BaseSampler): - # sampler = quantum_instance - # quantum_instance = None - - self._quantum_instance = None - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - stacklevel=2, - ) - with warnings.catch_warnings(): - warnings.simplefilter("ignore", category=PendingDeprecationWarning) - self.quantum_instance = quantum_instance - - self._estimator = estimator - if estimator is not None: - # if estimator is passed, use ``EstimatorQNN`` - self._estimator_qnn = EstimatorQNN( - estimator=estimator, - circuit=self._circuit, - observables=self._observable, - input_params=input_params, - weight_params=weight_params, - gradient=gradient, - input_gradients=input_gradients, - ) - output_shape = self._estimator_qnn.output_shape - else: - # Otherwise, use ``OpflowQNN`` - # combine all to operator - operator = StateFn(self._observable, is_measurement=True) @ StateFn(self._circuit) - self._opflow_qnn = OpflowQNN( - operator=operator, - input_params=input_params, - weight_params=weight_params, - exp_val=exp_val, - quantum_instance=quantum_instance, - input_gradients=input_gradients, - ) - output_shape = self._opflow_qnn.output_shape + # combine all to operator + operator = StateFn(self.observable, is_measurement=True) @ StateFn(self._circuit) super().__init__( - len(input_params), - len(weight_params), - sparse=False, - output_shape=output_shape, + operator=operator, + input_params=input_params, + weight_params=weight_params, + exp_val=exp_val, + quantum_instance=quantum_instance, input_gradients=input_gradients, ) - def _forward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - ) -> Union[np.ndarray, SparseArray]: - if self._estimator is not None: - return self._estimator_qnn.forward(input_data, weights) - else: - return self._opflow_qnn.forward(input_data, weights) - - def _backward( - self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray] - ) -> Tuple[Optional[np.ndarray], Optional[np.ndarray],]: - if self._estimator is not None: - return self._estimator_qnn.backward(input_data, weights) - else: - return self._opflow_qnn.backward(input_data, weights) - @property def feature_map(self) -> QuantumCircuit: """Returns the used feature map.""" @@ -200,4 +115,4 @@ def circuit(self) -> QuantumCircuit: @property def num_qubits(self) -> int: """Returns the number of qubits used by ansatz and feature map.""" - return self._circuit.num_qubits + return self._circuit.num_qubits \ No newline at end of file From 04042bab1f6a54c75e5a422628e301c7e6603800 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 19 Oct 2022 12:34:21 +0200 Subject: [PATCH 53/96] Apply reviews vqc --- .../algorithms/classifiers/vqc.py | 38 ++++++++++--------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 8a7994968..4dcac2335 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -62,30 +62,37 @@ def __init__( ) -> None: """ Args: - num_qubits: The number of qubits for the underlying - :class:`~qiskit_machine_learning.neural_networks.CircuitQNN`. If ``None`` is given, - the number of qubits is derived from the feature map or ansatz. If neither of those - is given, raises an exception. The number of qubits in the feature map and ansatz - are adjusted to this number if required. + num_qubits: The number of qubits for the underlying QNN. + If ``None`` is given, the number of qubits is derived from the + feature map or ansatz. If neither of those is given, raises an exception. + The number of qubits in the feature map and ansatz are adjusted to this + number if required. feature_map: The (parametrized) circuit to be used as a feature map for the underlying - :class:`~qiskit_machine_learning.neural_networks.CircuitQNN`. If ``None`` is given, - the ``ZZFeatureMap`` is used if the number of qubits is larger than 1. For a single - qubit classification problem the ``ZFeatureMap`` is used per default. + QNN. If ``None`` is given, the ``ZZFeatureMap`` is used if the number of qubits + is larger than 1. For a single qubit classification problem the ``ZFeatureMap`` + is used by default. ansatz: The (parametrized) circuit to be used as an ansatz for the underlying - :class:`~qiskit_machine_learning.neural_networks.CircuitQNN`. If ``None`` is given - then the ``RealAmplitudes`` circuit is used. + QNN. If ``None`` is given then the ``RealAmplitudes`` circuit is used. loss: A target loss function to be used in training. Default value is ``cross_entropy``. optimizer: An instance of an optimizer to be used in training. When ``None`` defaults to SLSQP. warm_start: Use weights from previous fit to start next fit. - quantum_instance: The quantum instance to execute circuits on. + quantum_instance: If a quantum instance is sent and ``sampler`` is ``None``, + the underlying QNN will be of type + :class:`~qiskit_machine_learning.neural_networks.CircuitQNN`, and the quantum + instance will be used to compute the neural network's results. If a sampler + instance is also set, it will override the `quantum_instance` parameter and + a :class:`~qiskit_machine_learning.neural_networks.SamplerQNN` + will be used instead. initial_point: Initial point for the optimizer to start from. callback: a reference to a user's callback function that has two parameters and returns ``None``. The callback can access intermediate data during training. On each iteration an optimizer invokes the callback and passes current weights as an array and a computed value as a float of the objective function being optimized. This allows to track how well optimization / training process is going on. - sampler: The sampler primitive used to compute neural network's results. + sampler: If a sampler instance is sent, the underlying QNN will be of type + :class:`~qiskit_machine_learning.neural_networks.SamplerQNN`, and the sampler + primitive will be used to compute the neural network's results. Raises: QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz @@ -106,8 +113,7 @@ def __init__( # needed for mypy neural_network: SamplerQNN | CircuitQNN = None - if quantum_instance is not None: - # construct circuit QNN only if qi is provided + if quantum_instance is not None and sampler is None: neural_network = CircuitQNN( self._circuit, input_params=self.feature_map.parameters, @@ -174,9 +180,7 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: num_classes = self._num_classes # instance check required by mypy (alternative to cast) - if isinstance(self._neural_network, SamplerQNN): - self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) - elif isinstance(self._neural_network, CircuitQNN): + if isinstance(self._neural_network, CircuitQNN|SamplerQNN): self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) return super()._minimize(X, y) From 5c5e705b8da6bbf3b26707bf93593ffe26b8edcc Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 19 Oct 2022 13:00:24 +0200 Subject: [PATCH 54/96] Apply reviews --- .../algorithms/classifiers/vqc.py | 4 +-- .../neural_networks/sampler_qnn.py | 35 ++++++++----------- 2 files changed, 17 insertions(+), 22 deletions(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 4dcac2335..8020a724e 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -58,7 +58,7 @@ def __init__( initial_point: np.ndarray | None = None, callback: Callable[[np.ndarray, float], None] | None = None, *, - sampler: BaseSampler = None, + sampler: BaseSampler | None = None, ) -> None: """ Args: @@ -180,7 +180,7 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: num_classes = self._num_classes # instance check required by mypy (alternative to cast) - if isinstance(self._neural_network, CircuitQNN|SamplerQNN): + if isinstance(self._neural_network, CircuitQNN | SamplerQNN): self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) return super()._minimize(X, y) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 3c6a4ea1e..64f0ffcbe 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -67,7 +67,7 @@ def __init__( self, *, sampler: BaseSampler | None = None, - circuit: QuantumCircuit | None = None, + circuit: QuantumCircuit, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, sparse: bool = False, @@ -79,6 +79,8 @@ def __init__( """ Args: sampler: The sampler primitive used to compute the neural network's results. + If ``None`` is given, a default instance of the reference sampler defined + by :class:`~qiskit.primitives.Sampler` will be used. circuit: The parametrized quantum circuit that generates the samples of this network. input_params: The parameters of the circuit corresponding to the input. weight_params: The parameters of the circuit corresponding to the trainable weights. @@ -89,6 +91,8 @@ def __init__( passed, then an identity function will be used by this neural network. output_shape: The output shape of the custom interpretation gradient: An optional sampler gradient to be used for the backward pass. + If ``None`` is given, a default instance of + :class:`~qiskit.algorithms.gradients.ParamShiftSamplerGradient` will be used. input_gradients: Determines whether to compute gradients with respect to input data. Note that this parameter is ``False`` by default, and must be explicitly set to ``True`` for a proper gradient computation when using ``TorchConnector``. @@ -227,16 +231,11 @@ def _preprocess( return parameters, num_samples - def _postprocess( - self, num_samples: int | None, result: SamplerResult | None - ) -> np.ndarray | SparseArray | None: + def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray | SparseArray: """ Post-processing during forward pass of the network. """ - if result is None: - return None - if self._sparse: # pylint: disable=import-error from sparse import DOK @@ -263,13 +262,11 @@ def _postprocess( return prob def _postprocess_gradient( - self, num_samples: int | None, results: SamplerGradientResult | None - ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray | None]: + self, num_samples: int, results: SamplerGradientResult + ) -> tuple[np.ndarray | SparseArray | None, np.ndarray | SparseArray]: """ Post-processing during backward pass of the network. """ - if num_samples is None or results is None: - return None, None if self._sparse: # pylint: disable=import-error @@ -345,10 +342,9 @@ def _forward( # sampler allows batching job = self.sampler.run([self._circuit] * num_samples, parameter_values) results = job.result() + result = self._postprocess(num_samples, results) else: - results = None - - result = self._postprocess(num_samples, results) + result = None return result @@ -362,23 +358,22 @@ def _backward( # prepare parameters in the required format parameter_values, num_samples = self._preprocess(input_data, weights) + results = None if num_samples is not None and np.prod(parameter_values.shape) > 0: if self._input_gradients: job = self.gradient.run([self._circuit] * num_samples, parameter_values) results = job.result() else: - if len(parameter_values[0]) is not self._num_inputs: + if len(parameter_values[0]) > self._num_inputs: job = self.gradient.run( [self._circuit] * num_samples, parameter_values, parameters=[self._circuit.parameters[self._num_inputs :]] * num_samples, ) results = job.result() - else: - results = None - else: - results = None - input_grad, weights_grad = self._postprocess_gradient(num_samples, results) + if results is None: + return None, None + input_grad, weights_grad = self._postprocess_gradient(num_samples, results) return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector From c2eaf90283560f8e5bca6afb116f617020d77c80 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 19 Oct 2022 13:05:39 +0200 Subject: [PATCH 55/96] Fix neko test --- qiskit_machine_learning/algorithms/classifiers/vqc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 8020a724e..b35d7c1d0 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -180,7 +180,7 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: num_classes = self._num_classes # instance check required by mypy (alternative to cast) - if isinstance(self._neural_network, CircuitQNN | SamplerQNN): + if isinstance(self._neural_network, (CircuitQNN, SamplerQNN)): self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes) return super()._minimize(X, y) From 8dd2d785c684db7218984bedbc502887cb5c7c10 Mon Sep 17 00:00:00 2001 From: ElePT Date: Wed, 19 Oct 2022 13:15:46 +0200 Subject: [PATCH 56/96] Fix spell check --- test/algorithms/classifiers/test_vqc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/algorithms/classifiers/test_vqc.py b/test/algorithms/classifiers/test_vqc.py index 5c98bd978..77c6031b4 100644 --- a/test/algorithms/classifiers/test_vqc.py +++ b/test/algorithms/classifiers/test_vqc.py @@ -102,7 +102,7 @@ def setUp(self): "no_one_hot": _create_dataset(6, 2, one_hot=False), } - self.run_methods = { # Tuple of type: (primitive, qi) + self.run_methods = { # Tuple of type: (primitive, quantum_instance) "sampler": (sampler, None), "statevector": (None, statevector), "qasm": (None, qasm), From dfb54bd040ef5b21d98a3b2ed11404687f00e764 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 21 Oct 2022 15:46:43 +0900 Subject: [PATCH 57/96] make codes simpler with numpy --- .../neural_networks/estimator_qnn.py | 65 +++++++------------ 1 file changed, 25 insertions(+), 40 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index dca2f97fe..6fc9b3da6 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -109,10 +109,9 @@ def _preprocess(self, input_data, weights): def _forward_postprocess(self, num_samples, results): """Post-processing during forward pass of the network.""" - res = np.zeros((num_samples, *self._output_shape)) - for i in range(num_samples): - for j in range(self.output_shape[0]): - res[i, j] = results.values[i * self.output_shape[0] + j] + res = np.zeros((num_samples, self._output_shape[0])) + for i in range(self._output_shape[0]): + res[:, i] = results.values[i * num_samples : (i + 1) * num_samples] return res def _forward( @@ -123,13 +122,10 @@ def _forward( if num_samples is None: return None else: - parameter_values = [ - param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) - ] job = self._estimator.run( [self._circuit] * num_samples * self.output_shape[0], - self._observables * num_samples, - parameter_values, + [op for op in self._observables for _ in range(num_samples)], + np.tile(parameter_values_, (self.output_shape[0], 1)), ) try: results = job.result() @@ -140,31 +136,23 @@ def _forward( def _backward_postprocess(self, num_samples, results): """Post-processing during backward pass of the network.""" - input_grad = ( - np.zeros((num_samples, *self.output_shape, self._num_inputs)) - if self._input_gradients - else None - ) - weights_grad = np.zeros((num_samples, *self.output_shape, self._num_weights)) - if self._input_gradients: - num_grad_vars = self._num_inputs + self._num_weights + input_grad = np.zeros((num_samples, self.output_shape[0], self._num_inputs)) else: - num_grad_vars = self._num_weights - - for i in range(num_samples): - for j in range(self.output_shape[0]): - for k in range(num_grad_vars): - if self._input_gradients: - if k < self._num_inputs: - input_grad[i, j, k] = results.gradients[i * self.output_shape[0] + j][k] - else: - weights_grad[i, j, k - self._num_inputs] = results.gradients[ - i * self.output_shape[0] + j - ][k] - else: - weights_grad[i, j, k] = results.gradients[i * self.output_shape[0] + j][k] - + input_grad = None + + weights_grad = np.zeros((num_samples, self.output_shape[0], self._num_weights)) + gradients = np.array(results.gradients) + for i in range(self._output_shape[0]): + if self._input_gradients: + input_grad[:, i, :] = gradients[i * num_samples : (i + 1) * num_samples][ + :, : self._num_inputs + ] + weights_grad[:, i, :] = gradients[i * num_samples : (i + 1) * num_samples][ + :, self._num_inputs : + ] + else: + weights_grad[:, i, :] = gradients[i * num_samples : (i + 1) * num_samples] return input_grad, weights_grad def _backward( @@ -176,20 +164,17 @@ def _backward( return None, None # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) - parameter_values = [ - param_values for param_values in parameter_values_ for _ in range(self.output_shape[0]) - ] if self._input_gradients: job = self._gradient.run( [self._circuit] * num_samples * self.output_shape[0], - self._observables * num_samples, - parameter_values, + [op for op in self._observables for _ in range(num_samples)], + np.tile(parameter_values_, (self.output_shape[0], 1)), ) else: job = self._gradient.run( [self._circuit] * num_samples * self.output_shape[0], - self._observables * num_samples, - parameter_values, + [op for op in self._observables for _ in range(num_samples)], + np.tile(parameter_values_, (self.output_shape[0], 1)), parameters=[self._circuit.parameters[self._num_inputs :]] * num_samples * self.output_shape[0], @@ -201,4 +186,4 @@ def _backward( raise QiskitMachineLearningError("Estimator job failed.") from exc input_grad, weights_grad = self._backward_postprocess(num_samples, results) - return input_grad, weights_grad # `None` for gradients wrt input data, see TorchConnector + return input_grad, weights_grad From b1332d74d4e2112f826f467ab30c74e8b7709d41 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 21 Oct 2022 15:49:38 +0900 Subject: [PATCH 58/96] fix two_layer_qnn.py --- qiskit_machine_learning/neural_networks/two_layer_qnn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/neural_networks/two_layer_qnn.py b/qiskit_machine_learning/neural_networks/two_layer_qnn.py index e5ab2d274..4df9583e4 100644 --- a/qiskit_machine_learning/neural_networks/two_layer_qnn.py +++ b/qiskit_machine_learning/neural_networks/two_layer_qnn.py @@ -115,4 +115,4 @@ def circuit(self) -> QuantumCircuit: @property def num_qubits(self) -> int: """Returns the number of qubits used by ansatz and feature map.""" - return self._circuit.num_qubits \ No newline at end of file + return self._circuit.num_qubits From 849dca447971786cda8e87aa4de83b0bb7d968f5 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 21 Oct 2022 19:16:10 +0900 Subject: [PATCH 59/96] wip unittests --- .../neural_networks/estimator_qnn.py | 19 +++-- test/neural_networks/test_estimator_qnn.py | 70 ++++++++++--------- 2 files changed, 52 insertions(+), 37 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 6fc9b3da6..5c2edf3e5 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -21,8 +21,10 @@ from qiskit.algorithms.gradients import BaseEstimatorGradient from qiskit.circuit import Parameter, QuantumCircuit from qiskit.opflow import PauliSumOp -from qiskit.primitives import BaseEstimator +from qiskit.primitives import BaseEstimator, Estimator +from qiskit.quantum_info import SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator + from qiskit_machine_learning.exceptions import QiskitMachineLearningError from .neural_network import NeuralNetwork @@ -35,9 +37,10 @@ class EstimatorQNN(NeuralNetwork): def __init__( self, - estimator: BaseEstimator, + *, + estimator: BaseEstimator | None = None, circuit: QuantumCircuit, - observables: Sequence[BaseOperator | PauliSumOp], + observables: Sequence[BaseOperator | PauliSumOp] | None = None, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, gradient: BaseEstimatorGradient | None = None, @@ -58,9 +61,15 @@ def __init__( Note that this parameter is ``False`` by default, and must be explicitly set to ``True`` for a proper gradient computation when using ``TorchConnector``. """ - self._estimator = estimator + if estimator is None: + self._estimator = Estimator() + else: + self._estimator = estimator self._circuit = circuit - self._observables = observables + if observables is None: + self._observables = SparsePauliOp.from_list([("Z" * circuit.num_qubits, 1)]) + else: + self._observables = observables self._input_params = list(input_params) if input_params is not None else [] self._weight_params = list(weight_params) if weight_params is not None else [] self._gradient = gradient diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 1e9a23a1b..1de4e7784 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -26,7 +26,7 @@ class TestEstimatorQNN(QiskitMachineLearningTestCase): - """EstimatorQNN Tests.""" + """EstimatorQNN Tests. The correct references is obtained from OpflowQNN""" def test_estimator_qnn_1_1(self): """Test Estimator QNN with input/output dimension 1/1.""" @@ -39,33 +39,33 @@ def test_estimator_qnn_1_1(self): estimator = Estimator() gradient = ParamShiftEstimatorGradient(estimator) estimator_qnn = EstimatorQNN( - estimator, qc, [op], [params[0]], [params[1]], gradient=gradient + estimator=estimator, + circuit=qc, + observables=[op], + input_params=[params[0]], + weight_params=[params[1]], + gradient=gradient, ) weights = np.array([1]) - test_data = [ - np.array(1), - np.array([1]), - np.array([[1], [2]]), - np.array([[[1], [2]], [[3], [4]]]), - ] + test_data = [1, [1], [[1], [2]], [[[1], [2]], [[3], [4]]]] correct_forwards = [ - np.array([[0.08565359]]), - np.array([[0.08565359]]), - np.array([[0.08565359], [-0.90744233]]), - np.array([[[0.08565359], [-0.90744233]], [[-1.06623996], [-0.24474149]]]), + [[0.08565359]], + [[0.08565359]], + [[0.08565359], [-0.90744233]], + [[[0.08565359], [-0.90744233]], [[-1.06623996], [-0.24474149]]], ] correct_weight_backwards = [ - np.array([[[0.70807342]]]), - np.array([[[0.70807342]]]), - np.array([[[0.70807342]], [[0.7651474]]]), - np.array([[[[0.70807342]], [[0.7651474]]], [[[0.11874839]], [[-0.63682734]]]]), + [[[0.70807342]]], + [[[0.70807342]]], + [[[0.70807342]], [[0.7651474]]], + [[[[0.70807342]], [[0.7651474]]], [[[0.11874839]], [[-0.63682734]]]], ] correct_input_backwards = [ - np.array([[[-1.13339757]]]), - np.array([[[-1.13339757]]]), - np.array([[[-1.13339757]], [[-0.68445233]]]), - np.array([[[[-1.13339757]], [[-0.68445233]]], [[[0.39377522]], [[1.10996765]]]]), + [[[-1.13339757]]], + [[[-1.13339757]]], + [[[-1.13339757]], [[-0.68445233]]], + [[[[-1.13339757]], [[-0.68445233]]], [[[0.39377522]], [[1.10996765]]]], ] # test forward pass @@ -104,26 +104,32 @@ def test_estimator_qnn_2_1(self): op = SparsePauliOp.from_list([("ZZ", 1), ("XX", 1)]) estimator = Estimator() gradient = ParamShiftEstimatorGradient(estimator) - estimator_qnn = EstimatorQNN(estimator, qc, [op], params[:2], params[2:], gradient=gradient) + estimator_qnn = EstimatorQNN( + estimator=estimator, + circuit=qc, + observables=[op], + input_params=params[:2], + weight_params=params[2:], + gradient=gradient, + ) weights = np.array([1, 2]) - test_data = [np.array([1, 2]), np.array([[1, 2]]), np.array([[1, 2], [3, 4]])] + test_data = [[1, 2], [[1, 2]], [[1, 2], [3, 4]]] correct_forwards = [ - np.array([[0.41256026]]), - np.array([[0.41256026]]), - np.array([[0.41256026], [0.72848859]]), + [[0.41256026]], + [[0.41256026]], + [[0.41256026], [0.72848859]], ] correct_weight_backwards = [ - np.array([[[0.12262287, -0.17203964]]]), - np.array([[[0.12262287, -0.17203964]]]), - np.array([[[0.12262287, -0.17203964]], [[0.03230095, -0.04531817]]]), + [[[0.12262287, -0.17203964]]], + [[[0.12262287, -0.17203964]]], + [[[0.12262287, -0.17203964]], [[0.03230095, -0.04531817]]], ] correct_input_backwards = [ - np.array([[[-0.81570272, -0.39688474]]]), - np.array([[[-0.81570272, -0.39688474]]]), - np.array([[[-0.81570272, -0.39688474]], [[0.25229775, 0.67111573]]]), + [[[-0.81570272, -0.39688474]]], + [[[-0.81570272, -0.39688474]]], + [[[-0.81570272, -0.39688474]], [[0.25229775, 0.67111573]]], ] - # test forward pass with self.subTest("forward pass"): for i, inputs in enumerate(test_data): From 976445f2c05aee71b379a891fd7a6e645712c1b6 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 21 Oct 2022 15:40:33 +0100 Subject: [PATCH 60/96] update vqr --- .../algorithms/regressors/vqr.py | 117 +++++++++++++----- .../neural_networks/estimator_qnn.py | 4 +- .../regressors/test_vqr_estimator_qnn.py | 103 +++++++++++++++ 3 files changed, 194 insertions(+), 30 deletions(-) create mode 100644 test/algorithms/regressors/test_vqr_estimator_qnn.py diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 322e059c4..70c05f135 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -15,75 +15,125 @@ from typing import Callable, cast import numpy as np - from qiskit import QuantumCircuit from qiskit.algorithms.optimizers import Optimizer from qiskit.opflow import OperatorBase +from qiskit.primitives import BaseEstimator +from qiskit.quantum_info import SparsePauliOp +from qiskit.quantum_info.operators.base_operator import BaseOperator from qiskit.utils import QuantumInstance from .neural_network_regressor import NeuralNetworkRegressor -from ...neural_networks import TwoLayerQNN +from ...deprecation import warn_deprecated, DeprecatedType +from ...neural_networks import TwoLayerQNN, EstimatorQNN +from ...utils import derive_num_qubits_feature_map_ansatz from ...utils.loss_functions import Loss class VQR(NeuralNetworkRegressor): - """Quantum neural network regressor using TwoLayerQNN""" + """Quantum neural network regressor.""" def __init__( self, num_qubits: int | None = None, feature_map: QuantumCircuit | None = None, ansatz: QuantumCircuit | None = None, - observable: QuantumCircuit | OperatorBase | None = None, + observable: QuantumCircuit | OperatorBase | BaseOperator | None = None, loss: str | Loss = "squared_error", optimizer: Optimizer | None = None, warm_start: bool = False, quantum_instance: QuantumInstance | None = None, initial_point: np.ndarray | None = None, callback: Callable[[np.ndarray, float], None] | None = None, + *, + estimator: BaseEstimator | None = None, ) -> None: r""" Args: - num_qubits: The number of qubits for the underlying - :class:`~qiskit_machine_learning.neural_networks.TwoLayerQNN`. If ``None`` is given, - the number of qubits is derived from the feature map or ansatz. If neither of those - is given, raises an exception. The number of qubits in the feature map and ansatz - are adjusted to this number if required. + num_qubits: The number of qubits for the underlying QNN. + If ``None`` is given, the number of qubits is derived from the + feature map or ansatz. If neither of those is given, raises an exception. + The number of qubits in the feature map and ansatz are adjusted to this + number if required. feature_map: The (parametrized) circuit to be used as a feature map for the underlying - :class:`~qiskit_machine_learning.neural_networks.TwoLayerQNN`. If ``None`` is given, - the ``ZZFeatureMap`` is used if the number of qubits is larger than 1. For a single - qubit regression problem the ``ZFeatureMap`` circuit is used per default. + QNN. If ``None`` is given, the :class:`~qiskit.circuit.library.ZZFeatureMap` + is used if the number of qubits is larger than 1. For a single qubit regression + problem the :class:`~qiskit.circuit.library.ZFeatureMap` is used by default. ansatz: The (parametrized) circuit to be used as an ansatz for the underlying - :class:`~qiskit_machine_learning.neural_networks.TwoLayerQNN`. If ``None`` is given - then the ``RealAmplitudes`` circuit is used. - observable: The observable to be measured in the underlying TwoLayerQNN. If ``None``, - use the default from the TwoLayerQNN, i.e., :math:`Z^{\otimes num\_qubits}`. + QNN. If ``None`` is given then the :class:`~qiskit.circuit.library.RealAmplitudes` + circuit is used. + observable: The observable to be measured in the underlying QNN. If ``None``, + use the default :math:`Z^{\otimes num\_qubits}` observable. loss: A target loss function to be used in training. Default is squared error. optimizer: An instance of an optimizer to be used in training. When ``None`` defaults to SLSQP. warm_start: Use weights from previous fit to start next fit. - quantum_instance: The quantum instance to execute circuits on. + quantum_instance: If a quantum instance is set and ``estimator`` is ``None``, + the underlying QNN will be of type + :class:`~qiskit_machine_learning.neural_networks.TwoLayerQNN`, and the quantum + instance will be used to compute the neural network's results. If an estimator + instance is also set, it will override the `quantum_instance` parameter and + a :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN` + will be used instead. initial_point: Initial point for the optimizer to start from. callback: a reference to a user's callback function that has two parameters and returns ``None``. The callback can access intermediate data during training. On each iteration an optimizer invokes the callback and passes current weights as an array and a computed value as a float of the objective function being optimized. This allows to track how well optimization / training process is going on. + estimator: If an estimator instance is set, the underlying QNN will be of type + :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN`, and the estimator + primitive will be used to compute the neural network's results. Raises: QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz can't be adjusted to ``num_qubits``. """ + # needed for mypy + neural_network: EstimatorQNN | TwoLayerQNN = None + if quantum_instance is not None and estimator is None: + warn_deprecated( + "0.5.0", DeprecatedType.ARGUMENT, old_name="quantum_instance", new_name="estimator" + ) + self._quantum_instance = quantum_instance - # construct QNN - neural_network = TwoLayerQNN( - num_qubits=num_qubits, - feature_map=feature_map, - ansatz=ansatz, - observable=observable, - quantum_instance=quantum_instance, - input_gradients=False, - ) + # construct QNN + neural_network = TwoLayerQNN( + num_qubits=num_qubits, + feature_map=feature_map, + ansatz=ansatz, + observable=observable, + quantum_instance=quantum_instance, + input_gradients=False, + ) + else: + # construct estimator QNN by default + self._estimator = estimator + + num_qubits, feature_map, ansatz = derive_num_qubits_feature_map_ansatz( + num_qubits, feature_map, ansatz + ) + + # construct circuit + self._feature_map = feature_map + self._ansatz = ansatz + self._num_qubits = num_qubits + circuit = QuantumCircuit(self._num_qubits) + circuit.compose(self._feature_map, inplace=True) + circuit.compose(self._ansatz, inplace=True) + + # construct observable + if observable is None: + observable = SparsePauliOp.from_list([("Z" * num_qubits, 1)]) + self._observable = observable + + neural_network = EstimatorQNN( + estimator=estimator, + circuit=circuit, + observables=[self._observable], + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + ) super().__init__( neural_network=neural_network, @@ -97,14 +147,23 @@ def __init__( @property def feature_map(self) -> QuantumCircuit: """Returns the used feature map.""" - return cast(TwoLayerQNN, super().neural_network).feature_map + if self._quantum_instance is not None and self._estimator is None: + return cast(TwoLayerQNN, super().neural_network).feature_map + else: + return self._feature_map @property def ansatz(self) -> QuantumCircuit: """Returns the used ansatz.""" - return cast(TwoLayerQNN, super().neural_network).ansatz + if self._quantum_instance is not None and self._estimator is None: + return cast(TwoLayerQNN, super().neural_network).ansatz + else: + return self._ansatz @property def num_qubits(self) -> int: """Returns the number of qubits used by ansatz and feature map.""" - return cast(TwoLayerQNN, super().neural_network).num_qubits + if self._quantum_instance is not None and self._estimator is None: + return cast(TwoLayerQNN, super().neural_network).num_qubits + else: + return self._num_qubits diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 5c2edf3e5..65161b032 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -18,7 +18,7 @@ from typing import Sequence, Tuple import numpy as np -from qiskit.algorithms.gradients import BaseEstimatorGradient +from qiskit.algorithms.gradients import BaseEstimatorGradient, ParamShiftEstimatorGradient from qiskit.circuit import Parameter, QuantumCircuit from qiskit.opflow import PauliSumOp from qiskit.primitives import BaseEstimator, Estimator @@ -72,6 +72,8 @@ def __init__( self._observables = observables self._input_params = list(input_params) if input_params is not None else [] self._weight_params = list(weight_params) if weight_params is not None else [] + if gradient is None: + gradient = ParamShiftEstimatorGradient(self._estimator) self._gradient = gradient self._input_gradients = input_gradients diff --git a/test/algorithms/regressors/test_vqr_estimator_qnn.py b/test/algorithms/regressors/test_vqr_estimator_qnn.py new file mode 100644 index 000000000..9dc6f8fba --- /dev/null +++ b/test/algorithms/regressors/test_vqr_estimator_qnn.py @@ -0,0 +1,103 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2022. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" Test Neural Network Regressor with EstimatorQNN.""" + +import unittest + +from test import QiskitMachineLearningTestCase + +import numpy as np +from ddt import data, ddt +from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B +from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.primitives import Estimator +from qiskit.utils import algorithm_globals + +from qiskit_machine_learning.algorithms import VQR + + +@ddt +class TestVQR(QiskitMachineLearningTestCase): + """VQR Tests.""" + + def setUp(self): + super().setUp() + + # specify quantum instances + algorithm_globals.random_seed = 12345 + + self.estimator = Estimator() + + num_samples = 20 + eps = 0.2 + + # pylint: disable=invalid-name + lb, ub = -np.pi, np.pi + self.X = (ub - lb) * np.random.rand(num_samples, 1) + lb + self.y = np.sin(self.X[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1) + + @data( + # optimizer, has ansatz + ("cobyla", True), + ("cobyla", False), + ("bfgs", True), + ("bfgs", False), + (None, True), + (None, False), + ) + def test_vqr(self, config): + """Test VQR.""" + + opt, has_ansatz = config + + if opt == "bfgs": + optimizer = L_BFGS_B(maxiter=5) + elif opt == "cobyla": + optimizer = COBYLA(maxiter=25) + else: + optimizer = None + + num_qubits = 1 + # construct simple feature map + param_x = Parameter("x") + feature_map = QuantumCircuit(num_qubits, name="fm") + feature_map.ry(param_x, 0) + + if has_ansatz: + param_y = Parameter("y") + ansatz = QuantumCircuit(num_qubits, name="vf") + ansatz.ry(param_y, 0) + initial_point = np.zeros(ansatz.num_parameters) + else: + ansatz = None + # we know it will be RealAmplitudes + initial_point = np.zeros(4) + + # construct regressor + regressor = VQR( + feature_map=feature_map, + ansatz=ansatz, + optimizer=optimizer, + initial_point=initial_point, + estimator=self.estimator, + ) + + # fit to data + regressor.fit(self.X, self.y) + + # score + score = regressor.score(self.X, self.y) + self.assertGreater(score, 0.5) + + +if __name__ == "__main__": + unittest.main() From 219e7e6127893f7e8053c3b53a88fdaae10820be Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 21 Oct 2022 15:46:40 +0100 Subject: [PATCH 61/96] fix pylint --- test/neural_networks/test_estimator_qnn.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 1de4e7784..75a347e87 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -164,7 +164,12 @@ def test_estimator_qnn_1_2(self): gradient = ParamShiftEstimatorGradient(estimator) # construct QNN estimator_qnn = EstimatorQNN( - estimator, qc, [op1, op2], [params[0]], [params[1]], gradient=gradient + estimator=estimator, + circuit=qc, + observables=[op1, op2], + input_params=[params[0]], + weight_params=[params[1]], + gradient=gradient, ) weights = np.array([1]) From 706c6ba6741f58243ccbec95926e23165f0b6a2e Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 21 Oct 2022 16:00:21 +0100 Subject: [PATCH 62/96] use kwargs --- qiskit_machine_learning/neural_networks/estimator_qnn.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 65161b032..248b095db 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -78,8 +78,8 @@ def __init__( self._input_gradients = input_gradients super().__init__( - len(self._input_params), - len(self._weight_params), + num_inputs=len(self._input_params), + num_weights=len(self._weight_params), sparse=False, output_shape=len(observables), input_gradients=input_gradients, From 3cf8cac2ae8964fd5ef138b23cabecce29c0aa30 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 21 Oct 2022 17:01:29 +0100 Subject: [PATCH 63/96] simplify reno code block --- .../add-estimator-qnn-270b31662988bef9.yaml | 21 +++++++++++-------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 7f9186625..6f4a2c59c 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -10,26 +10,29 @@ features: .. code-block:: python - import numpy as np - - from qiskit.algorithms.gradients import ParamShiftEstimatorGradient from qiskit.circuit import QuantumCircuit, Parameter from qiskit.primitives import Estimator from qiskit.quantum_info import SparsePauliOp + from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN estimator = Estimator() - gradient = ParamShiftEstimatorGradient(estimator) params = [Parameter("input1"), Parameter("weight1")] qc = QuantumCircuit(1) qc.h(0) qc.ry(params[0], 0) qc.rx(params[1], 0) - op = SparsePauliOp.from_list([("Z", 1), ("X", 1.0)]) - gradient = ParamShiftEstimatorGradient(estimator) + op = SparsePauliOp.from_list([("Z", 1)]) + + estimator_qnn = EstimatorQNN( + estimator=estimator, + circuit=qc, + observables=[op], + input_params=[params[0]], + weight_params=[params[1]] + ) - estimator_qnn = EstimatorQNN(estimator, qc, [op], [params[0]], [params[1]], gradient=gradient) - inputs = np.array([1]) - weights = np.array([2]) + inputs = [1] + weights = [2] res = estimator_qnn.forward(inputs, weights) input_grad, weights_grad = estimator_qnn.backward(inputs, weights) From 5938b9dd3fbc0033f4a94101d586c0668f5f50d3 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 21 Oct 2022 23:26:49 +0100 Subject: [PATCH 64/96] refactorings --- .../neural_networks/estimator_qnn.py | 38 ++++++++++++------- 1 file changed, 24 insertions(+), 14 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 248b095db..f72d8446a 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -18,10 +18,14 @@ from typing import Sequence, Tuple import numpy as np -from qiskit.algorithms.gradients import BaseEstimatorGradient, ParamShiftEstimatorGradient +from qiskit.algorithms.gradients import ( + BaseEstimatorGradient, + ParamShiftEstimatorGradient, + EstimatorGradientResult, +) from qiskit.circuit import Parameter, QuantumCircuit from qiskit.opflow import PauliSumOp -from qiskit.primitives import BaseEstimator, Estimator +from qiskit.primitives import BaseEstimator, Estimator, EstimatorResult from qiskit.quantum_info import SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator @@ -101,8 +105,15 @@ def input_gradients(self, input_gradients: bool) -> None: """Turn on/off computation of gradients with respect to input data.""" self._input_gradients = input_gradients - def _preprocess(self, input_data, weights): - """Pre-processing during the forward pass and backward pass of the network.""" + # todo: move to the superclass + def _preprocess( + self, + input_data: np.ndarray | None, + weights: np.ndarray | None, + ) -> tuple[np.ndarray | None, int | None]: + """ + Pre-processing during forward pass of the network. + """ if input_data is not None: num_samples = input_data.shape[0] if weights is not None: @@ -118,12 +129,12 @@ def _preprocess(self, input_data, weights): return None, None return parameters, num_samples - def _forward_postprocess(self, num_samples, results): + def _forward_postprocess(self, num_samples: int, result: EstimatorResult) -> np.ndarray: """Post-processing during forward pass of the network.""" - res = np.zeros((num_samples, self._output_shape[0])) + expectations = np.zeros((num_samples, self._output_shape[0])) for i in range(self._output_shape[0]): - res[:, i] = results.values[i * num_samples : (i + 1) * num_samples] - return res + expectations[:, i] = result.values[i * num_samples : (i + 1) * num_samples] + return expectations def _forward( self, input_data: np.ndarray | None, weights: np.ndarray | None @@ -145,7 +156,9 @@ def _forward( return self._forward_postprocess(num_samples, results) - def _backward_postprocess(self, num_samples, results): + def _backward_postprocess( + self, num_samples: int, result: EstimatorGradientResult + ) -> tuple[np.ndarray | None, np.ndarray]: """Post-processing during backward pass of the network.""" if self._input_gradients: input_grad = np.zeros((num_samples, self.output_shape[0], self._num_inputs)) @@ -153,7 +166,7 @@ def _backward_postprocess(self, num_samples, results): input_grad = None weights_grad = np.zeros((num_samples, self.output_shape[0], self._num_weights)) - gradients = np.array(results.gradients) + gradients = np.asarray(result.gradients) for i in range(self._output_shape[0]): if self._input_gradients: input_grad[:, i, :] = gradients[i * num_samples : (i + 1) * num_samples][ @@ -168,11 +181,8 @@ def _backward_postprocess(self, num_samples, results): def _backward( self, input_data: np.ndarray | None, weights: np.ndarray | None - ) -> Tuple[np.ndarray | None, np.ndarray | None]: + ) -> Tuple[np.ndarray | None, np.ndarray]: """Backward pass of the network.""" - # if no gradient is set, return None - if self._gradient is None: - return None, None # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) if self._input_gradients: From 824de8634773830e5bb62a59407e950062c6ac6c Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Mon, 24 Oct 2022 14:38:22 +0100 Subject: [PATCH 65/96] unit tests, reno, spelling --- .../neural_networks/estimator_qnn.py | 2 +- .../add-estimator-qnn-270b31662988bef9.yaml | 2 +- test/neural_networks/test_estimator_qnn.py | 273 +++++++++--------- 3 files changed, 143 insertions(+), 134 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index f72d8446a..cbb510354 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -105,7 +105,7 @@ def input_gradients(self, input_gradients: bool) -> None: """Turn on/off computation of gradients with respect to input data.""" self._input_gradients = input_gradients - # todo: move to the superclass + # todo: move to the super-class def _preprocess( self, input_data: np.ndarray | None, diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 6f4a2c59c..206715d87 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -6,7 +6,7 @@ features: forward pass and it requires :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to calculate the backward pass. - Example:: + Example: .. code-block:: python diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 75a347e87..103de7f4c 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -12,61 +12,125 @@ """ Test EstimatorQNN """ -from test import QiskitMachineLearningTestCase - import unittest -import numpy as np +from test import QiskitMachineLearningTestCase +import numpy as np from qiskit.circuit import Parameter, QuantumCircuit from qiskit.quantum_info import SparsePauliOp -from qiskit.primitives import Estimator -from qiskit.algorithms.gradients import ParamShiftEstimatorGradient -from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN - - -class TestEstimatorQNN(QiskitMachineLearningTestCase): - """EstimatorQNN Tests. The correct references is obtained from OpflowQNN""" - def test_estimator_qnn_1_1(self): - """Test Estimator QNN with input/output dimension 1/1.""" - params = [Parameter("input1"), Parameter("weight1")] - qc = QuantumCircuit(1) - qc.h(0) - qc.ry(params[0], 0) - qc.rx(params[1], 0) - op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) - estimator = Estimator() - gradient = ParamShiftEstimatorGradient(estimator) - estimator_qnn = EstimatorQNN( - estimator=estimator, - circuit=qc, - observables=[op], - input_params=[params[0]], - weight_params=[params[1]], - gradient=gradient, - ) - weights = np.array([1]) +from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN - test_data = [1, [1], [[1], [2]], [[[1], [2]], [[3], [4]]]] - correct_forwards = [ +CASE_DATA = dict( + shape_1_1=dict( + test_data=[1, [1], [[1], [2]], [[[1], [2]], [[3], [4]]]], + weights=[1], + correct_forwards=[ [[0.08565359]], [[0.08565359]], [[0.08565359], [-0.90744233]], [[[0.08565359], [-0.90744233]], [[-1.06623996], [-0.24474149]]], - ] - correct_weight_backwards = [ + ], + correct_weight_backwards=[ [[[0.70807342]]], [[[0.70807342]]], [[[0.70807342]], [[0.7651474]]], [[[[0.70807342]], [[0.7651474]]], [[[0.11874839]], [[-0.63682734]]]], - ] - correct_input_backwards = [ + ], + correct_input_backwards=[ [[[-1.13339757]]], [[[-1.13339757]]], [[[-1.13339757]], [[-0.68445233]]], [[[[-1.13339757]], [[-0.68445233]]], [[[0.39377522]], [[1.10996765]]]], - ] + ], + ), + shape_2_1=dict( + test_data=[[1, 2], [[1, 2]], [[1, 2], [3, 4]]], + weights=[1, 2], + correct_forwards=[ + [[0.41256026]], + [[0.41256026]], + [[0.41256026], [0.72848859]], + ], + correct_weight_backwards=[ + [[[0.12262287, -0.17203964]]], + [[[0.12262287, -0.17203964]]], + [[[0.12262287, -0.17203964]], [[0.03230095, -0.04531817]]], + ], + correct_input_backwards=[ + [[[-0.81570272, -0.39688474]]], + [[[-0.81570272, -0.39688474]]], + [[[-0.81570272, -0.39688474]], [[0.25229775, 0.67111573]]], + ], + ), + shape_1_2=dict( + test_data=[ + [1], + [[1], [2]], + [[[1], [2]], [[3], [4]]], + ], + weights=[1], + correct_forwards=[ + [[0.08565359, 0.17130718]], + [[0.08565359, 0.17130718], [-0.90744233, -1.81488467]], + [ + [[0.08565359, 0.17130718], [-0.90744233, -1.81488467]], + [[-1.06623996, -2.13247992], [-0.24474149, -0.48948298]], + ], + ], + correct_weight_backwards=[ + [[[0.70807342], [1.41614684]]], + [[[0.70807342], [1.41614684]], [[0.7651474], [1.5302948]]], + [ + [[[0.70807342], [1.41614684]], [[0.7651474], [1.5302948]]], + [[[0.11874839], [0.23749678]], [[-0.63682734], [-1.27365468]]], + ], + ], + correct_input_backwards=[ + [[[-1.13339757], [-2.26679513]]], + [[[-1.13339757], [-2.26679513]], [[-0.68445233], [-1.36890466]]], + [ + [[[-1.13339757], [-2.26679513]], [[-0.68445233], [-1.36890466]]], + [[[0.39377522], [0.78755044]], [[1.10996765], [2.2199353]]], + ], + ], + ), + shape_2_2=dict( + test_data=[[1, 2], [[1, 2], [3, 4]]], + weights=[1, 2], + correct_forwards=[ + [[-0.07873524, 0.4912955]], + [[-0.07873524, 0.4912955], [-0.0207402, 0.74922879]], + ], + correct_weight_backwards=[ + [[[0.12262287, -0.17203964], [0, 0]]], + [[[0.12262287, -0.17203964], [0, 0]], [[0.03230095, -0.04531817], [0, 0]]], + ], + correct_input_backwards=[ + [[[-0.05055532, -0.17203964], [-0.7651474, -0.2248451]]], + [ + [[-0.05055532, -0.17203964], [-0.7651474, -0.2248451]], + [[0.14549777, 0.02401345], [0.10679997, 0.64710228]], + ], + ], + ), +) + + +class TestEstimatorQNN(QiskitMachineLearningTestCase): + """EstimatorQNN Tests. The correct references is obtained from OpflowQNN""" + + def _test_network_passes( + self, + estimator_qnn, + case_data, + ): + test_data = case_data["test_data"] + weights = case_data["weights"] + correct_forwards = case_data["correct_forwards"] + correct_weight_backwards = case_data["correct_weight_backwards"] + correct_input_backwards = case_data["correct_input_backwards"] # test forward pass with self.subTest("forward pass"): @@ -87,6 +151,23 @@ def test_estimator_qnn_1_1(self): np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + def test_estimator_qnn_1_1(self): + """Test Estimator QNN with input/output dimension 1/1.""" + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op], + input_params=[params[0]], + weight_params=[params[1]], + ) + + self._test_network_passes(estimator_qnn, CASE_DATA["shape_1_1"]) + def test_estimator_qnn_2_1(self): """Test Estimator QNN with input/output dimension 2/1.""" params = [ @@ -102,52 +183,14 @@ def test_estimator_qnn_2_1(self): qc.rx(params[2], 0) qc.rx(params[3], 1) op = SparsePauliOp.from_list([("ZZ", 1), ("XX", 1)]) - estimator = Estimator() - gradient = ParamShiftEstimatorGradient(estimator) estimator_qnn = EstimatorQNN( - estimator=estimator, circuit=qc, observables=[op], input_params=params[:2], weight_params=params[2:], - gradient=gradient, ) - weights = np.array([1, 2]) - test_data = [[1, 2], [[1, 2]], [[1, 2], [3, 4]]] - correct_forwards = [ - [[0.41256026]], - [[0.41256026]], - [[0.41256026], [0.72848859]], - ] - correct_weight_backwards = [ - [[[0.12262287, -0.17203964]]], - [[[0.12262287, -0.17203964]]], - [[[0.12262287, -0.17203964]], [[0.03230095, -0.04531817]]], - ] - correct_input_backwards = [ - [[[-0.81570272, -0.39688474]]], - [[[-0.81570272, -0.39688474]]], - [[[-0.81570272, -0.39688474]], [[0.25229775, 0.67111573]]], - ] - # test forward pass - with self.subTest("forward pass"): - for i, inputs in enumerate(test_data): - forward = estimator_qnn.forward(inputs, weights) - np.testing.assert_allclose(forward, correct_forwards[i], atol=1e-3) - # test backward pass without input_gradients - with self.subTest("backward pass without input gradients"): - for i, inputs in enumerate(test_data): - input_backward, weight_backward = estimator_qnn.backward(inputs, weights) - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) - self.assertIsNone(input_backward) - # test backward pass with input_gradients - with self.subTest("backward bass with input gradients"): - estimator_qnn.input_gradients = True - for i, inputs in enumerate(test_data): - input_backward, weight_backward = estimator_qnn.backward(inputs, weights) - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) - np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + self._test_network_passes(estimator_qnn, CASE_DATA["shape_2_1"]) def test_estimator_qnn_1_2(self): """Test Estimator QNN with input/output dimension 1/2.""" @@ -160,74 +203,40 @@ def test_estimator_qnn_1_2(self): op1 = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) op2 = SparsePauliOp.from_list([("Z", 2), ("X", 2)]) - estimator = Estimator() - gradient = ParamShiftEstimatorGradient(estimator) # construct QNN estimator_qnn = EstimatorQNN( - estimator=estimator, circuit=qc, observables=[op1, op2], input_params=[params[0]], weight_params=[params[1]], - gradient=gradient, ) - weights = np.array([1]) - test_data = [ - np.array([1]), - np.array([[1], [2]]), - np.array([[[1], [2]], [[3], [4]]]), - ] + self._test_network_passes(estimator_qnn, CASE_DATA["shape_1_2"]) - correct_forwards = [ - np.array([[0.08565359, 0.17130718]]), - np.array([[0.08565359, 0.17130718], [-0.90744233, -1.81488467]]), - np.array( - [ - [[0.08565359, 0.17130718], [-0.90744233, -1.81488467]], - [[-1.06623996, -2.13247992], [-0.24474149, -0.48948298]], - ] - ), - ] - correct_weight_backwards = [ - np.array([[[0.70807342], [1.41614684]]]), - np.array([[[0.70807342], [1.41614684]], [[0.7651474], [1.5302948]]]), - np.array( - [ - [[[0.70807342], [1.41614684]], [[0.7651474], [1.5302948]]], - [[[0.11874839], [0.23749678]], [[-0.63682734], [-1.27365468]]], - ] - ), - ] - correct_input_backwards = [ - np.array([[[-1.13339757], [-2.26679513]]]), - np.array([[[-1.13339757], [-2.26679513]], [[-0.68445233], [-1.36890466]]]), - np.array( - [ - [[[-1.13339757], [-2.26679513]], [[-0.68445233], [-1.36890466]]], - [[[0.39377522], [0.78755044]], [[1.10996765], [2.2199353]]], - ] - ), + def test_estimator_qnn_2_2(self): + """Test Estimator QNN with input/output dimension 2/2.""" + params = [ + Parameter("input1"), + Parameter("input2"), + Parameter("weight1"), + Parameter("weight2"), ] + qc = QuantumCircuit(2) + qc.h(0) + qc.ry(params[0], 0) + qc.ry(params[1], 1) + qc.rx(params[2], 0) + qc.rx(params[3], 1) + op1 = SparsePauliOp.from_list([("ZZ", 1)]) + op2 = SparsePauliOp.from_list([("XX", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op1, op2], + input_params=params[:2], + weight_params=params[2:], + ) - # test forward pass - with self.subTest("forward pass"): - for i, inputs in enumerate(test_data): - forward = estimator_qnn.forward(inputs, weights) - np.testing.assert_allclose(forward, correct_forwards[i], atol=1e-3) - # test backward pass without input_gradients - with self.subTest("backward pass without input gradients"): - for i, inputs in enumerate(test_data): - input_backward, weight_backward = estimator_qnn.backward(inputs, weights) - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) - self.assertIsNone(input_backward) - # test backward pass with input_gradients - with self.subTest("backward bass with input gradients"): - estimator_qnn.input_gradients = True - for i, inputs in enumerate(test_data): - input_backward, weight_backward = estimator_qnn.backward(inputs, weights) - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) - np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + self._test_network_passes(estimator_qnn, CASE_DATA["shape_2_2"]) if __name__ == "__main__": From c2441622867da869e0f7a3c7c3e1d39ccdcc1dbd Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Mon, 24 Oct 2022 14:49:16 +0100 Subject: [PATCH 66/96] vqr properties test --- .../algorithms/regressors/vqr.py | 2 ++ test/algorithms/regressors/test_vqr.py | 16 +++++++++++++++- .../regressors/test_vqr_estimator_qnn.py | 15 ++++++++++++++- 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 70c05f135..126e56d8c 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -96,6 +96,7 @@ def __init__( "0.5.0", DeprecatedType.ARGUMENT, old_name="quantum_instance", new_name="estimator" ) self._quantum_instance = quantum_instance + self._estimator = None # construct QNN neural_network = TwoLayerQNN( @@ -108,6 +109,7 @@ def __init__( ) else: # construct estimator QNN by default + self._quantum_instance = None self._estimator = estimator num_qubits, feature_map, ansatz = derive_num_qubits_feature_map_ansatz( diff --git a/test/algorithms/regressors/test_vqr.py b/test/algorithms/regressors/test_vqr.py index 93fe981e9..15de0d402 100644 --- a/test/algorithms/regressors/test_vqr.py +++ b/test/algorithms/regressors/test_vqr.py @@ -17,10 +17,11 @@ import numpy as np from ddt import data, ddt - from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes from qiskit.utils import QuantumInstance, algorithm_globals, optionals + from qiskit_machine_learning.algorithms import VQR @@ -120,6 +121,19 @@ def test_vqr(self, config): score = regressor.score(self.X, self.y) self.assertGreater(score, 0.5) + def test_properties(self): + """Test properties of VQR.""" + vqr = VQR(num_qubits=2, quantum_instance=self.qasm_quantum_instance) + self.assertIsNotNone(vqr.feature_map) + self.assertIsInstance(vqr.feature_map, ZZFeatureMap) + self.assertEqual(vqr.feature_map.num_qubits, 2) + + self.assertIsNotNone(vqr.ansatz) + self.assertIsInstance(vqr.ansatz, RealAmplitudes) + self.assertEqual(vqr.ansatz.num_qubits, 2) + + self.assertEqual(vqr.num_qubits, 2) + if __name__ == "__main__": unittest.main() diff --git a/test/algorithms/regressors/test_vqr_estimator_qnn.py b/test/algorithms/regressors/test_vqr_estimator_qnn.py index 9dc6f8fba..24d2437a4 100644 --- a/test/algorithms/regressors/test_vqr_estimator_qnn.py +++ b/test/algorithms/regressors/test_vqr_estimator_qnn.py @@ -12,13 +12,13 @@ """ Test Neural Network Regressor with EstimatorQNN.""" import unittest - from test import QiskitMachineLearningTestCase import numpy as np from ddt import data, ddt from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B from qiskit.circuit import Parameter, QuantumCircuit +from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes from qiskit.primitives import Estimator from qiskit.utils import algorithm_globals @@ -98,6 +98,19 @@ def test_vqr(self, config): score = regressor.score(self.X, self.y) self.assertGreater(score, 0.5) + def test_properties(self): + """Test properties of VQR.""" + vqr = VQR(num_qubits=2) + self.assertIsNotNone(vqr.feature_map) + self.assertIsInstance(vqr.feature_map, ZZFeatureMap) + self.assertEqual(vqr.feature_map.num_qubits, 2) + + self.assertIsNotNone(vqr.ansatz) + self.assertIsInstance(vqr.ansatz, RealAmplitudes) + self.assertEqual(vqr.ansatz.num_qubits, 2) + + self.assertEqual(vqr.num_qubits, 2) + if __name__ == "__main__": unittest.main() From 0d4ad7210b57955acf9ac84365a97be5c4d32b6d Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Mon, 24 Oct 2022 15:34:14 +0100 Subject: [PATCH 67/96] vectorize forward post processing --- qiskit_machine_learning/neural_networks/estimator_qnn.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index cbb510354..4868a9394 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -131,9 +131,7 @@ def _preprocess( def _forward_postprocess(self, num_samples: int, result: EstimatorResult) -> np.ndarray: """Post-processing during forward pass of the network.""" - expectations = np.zeros((num_samples, self._output_shape[0])) - for i in range(self._output_shape[0]): - expectations[:, i] = result.values[i * num_samples : (i + 1) * num_samples] + expectations = np.reshape(result.values, (-1, num_samples)).T return expectations def _forward( From edcee3c168cc53f8da2155ea48c3c03f4794ddd4 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Mon, 24 Oct 2022 23:44:26 +0100 Subject: [PATCH 68/96] some refactorings --- .../neural_networks/estimator_qnn.py | 33 +++++++++---------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 4868a9394..d4c091ea5 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -105,7 +105,7 @@ def input_gradients(self, input_gradients: bool) -> None: """Turn on/off computation of gradients with respect to input data.""" self._input_gradients = input_gradients - # todo: move to the super-class + # todo: move to the super-class once sampler-based network is merged def _preprocess( self, input_data: np.ndarray | None, @@ -158,14 +158,15 @@ def _backward_postprocess( self, num_samples: int, result: EstimatorGradientResult ) -> tuple[np.ndarray | None, np.ndarray]: """Post-processing during backward pass of the network.""" + num_observables = self.output_shape[0] if self._input_gradients: - input_grad = np.zeros((num_samples, self.output_shape[0], self._num_inputs)) + input_grad = np.zeros((num_samples, num_observables, self._num_inputs)) else: input_grad = None - weights_grad = np.zeros((num_samples, self.output_shape[0], self._num_weights)) + weights_grad = np.zeros((num_samples, num_observables, self._num_weights)) gradients = np.asarray(result.gradients) - for i in range(self._output_shape[0]): + for i in range(num_observables): if self._input_gradients: input_grad[:, i, :] = gradients[i * num_samples : (i + 1) * num_samples][ :, : self._num_inputs @@ -183,21 +184,19 @@ def _backward( """Backward pass of the network.""" # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) + + num_observables = self.output_shape[0] + num_circuits = num_samples * num_observables + + circuits = [self._circuit] * num_circuits + observables = [op for op in self._observables for _ in range(num_samples)] + param_values = np.tile(parameter_values_, (num_observables, 1)) + if self._input_gradients: - job = self._gradient.run( - [self._circuit] * num_samples * self.output_shape[0], - [op for op in self._observables for _ in range(num_samples)], - np.tile(parameter_values_, (self.output_shape[0], 1)), - ) + job = self._gradient.run(circuits, observables, param_values) else: - job = self._gradient.run( - [self._circuit] * num_samples * self.output_shape[0], - [op for op in self._observables for _ in range(num_samples)], - np.tile(parameter_values_, (self.output_shape[0], 1)), - parameters=[self._circuit.parameters[self._num_inputs :]] - * num_samples - * self.output_shape[0], - ) + params = [self._circuit.parameters[self._num_inputs :]] * num_circuits + job = self._gradient.run(circuits, observables, param_values, parameters=params) try: results = job.result() From 7d350008d3a0a4130318b0add4167bcc213a8b00 Mon Sep 17 00:00:00 2001 From: Anton Dekusar <62334182+adekusar-drl@users.noreply.github.com> Date: Mon, 24 Oct 2022 23:45:16 +0100 Subject: [PATCH 69/96] Update qiskit_machine_learning/algorithms/regressors/vqr.py Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- qiskit_machine_learning/algorithms/regressors/vqr.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 126e56d8c..afb0739a7 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -52,7 +52,7 @@ def __init__( Args: num_qubits: The number of qubits for the underlying QNN. If ``None`` is given, the number of qubits is derived from the - feature map or ansatz. If neither of those is given, raises an exception. + feature map or ansatz, but if neither of these are given an error is raised. The number of qubits in the feature map and ansatz are adjusted to this number if required. feature_map: The (parametrized) circuit to be used as a feature map for the underlying From 7d31e7865226bb652f64a8d2d485bd6f34829b26 Mon Sep 17 00:00:00 2001 From: Anton Dekusar <62334182+adekusar-drl@users.noreply.github.com> Date: Mon, 24 Oct 2022 23:45:30 +0100 Subject: [PATCH 70/96] Update qiskit_machine_learning/algorithms/regressors/vqr.py Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- qiskit_machine_learning/algorithms/regressors/vqr.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index afb0739a7..0c03b8401 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -51,7 +51,7 @@ def __init__( r""" Args: num_qubits: The number of qubits for the underlying QNN. - If ``None`` is given, the number of qubits is derived from the + If ``None`` then the number of qubits is derived from the feature map or ansatz, but if neither of these are given an error is raised. The number of qubits in the feature map and ansatz are adjusted to this number if required. From 41fb2c3ca4dc0a9fa9f2a4974fa4d5ee803785a4 Mon Sep 17 00:00:00 2001 From: Anton Dekusar <62334182+adekusar-drl@users.noreply.github.com> Date: Mon, 24 Oct 2022 23:45:54 +0100 Subject: [PATCH 71/96] Update qiskit_machine_learning/algorithms/regressors/vqr.py Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- qiskit_machine_learning/algorithms/regressors/vqr.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 0c03b8401..01db665a3 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -68,7 +68,7 @@ def __init__( optimizer: An instance of an optimizer to be used in training. When ``None`` defaults to SLSQP. warm_start: Use weights from previous fit to start next fit. - quantum_instance: If a quantum instance is set and ``estimator`` is ``None``, + quantum_instance: Deprecated: If a quantum instance is set and ``estimator`` is ``None``, the underlying QNN will be of type :class:`~qiskit_machine_learning.neural_networks.TwoLayerQNN`, and the quantum instance will be used to compute the neural network's results. If an estimator From 96f25c2a4354be49ddcdfbb837d9db14b58bd638 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Mon, 24 Oct 2022 23:48:31 +0100 Subject: [PATCH 72/96] docstrings --- qiskit_machine_learning/algorithms/regressors/vqr.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 01db665a3..5fa22ebe5 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -56,11 +56,11 @@ def __init__( The number of qubits in the feature map and ansatz are adjusted to this number if required. feature_map: The (parametrized) circuit to be used as a feature map for the underlying - QNN. If ``None`` is given, the :class:`~qiskit.circuit.library.ZZFeatureMap` + QNN. If ``None`` the :class:`~qiskit.circuit.library.ZZFeatureMap` is used if the number of qubits is larger than 1. For a single qubit regression problem the :class:`~qiskit.circuit.library.ZFeatureMap` is used by default. ansatz: The (parametrized) circuit to be used as an ansatz for the underlying - QNN. If ``None`` is given then the :class:`~qiskit.circuit.library.RealAmplitudes` + QNN. If ``None`` then the :class:`~qiskit.circuit.library.RealAmplitudes` circuit is used. observable: The observable to be measured in the underlying QNN. If ``None``, use the default :math:`Z^{\otimes num\_qubits}` observable. From ff2764e1dff7e689e6d1fb2007558e09d75aec41 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Tue, 25 Oct 2022 18:12:23 +0900 Subject: [PATCH 73/96] added more unittests --- .../neural_networks/estimator_qnn.py | 20 ++- test/neural_networks/test_estimator_qnn.py | 161 +++++++++++++++++- 2 files changed, 171 insertions(+), 10 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index d4c091ea5..0f4d5c2a0 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -85,7 +85,7 @@ def __init__( num_inputs=len(self._input_params), num_weights=len(self._weight_params), sparse=False, - output_shape=len(observables), + output_shape=len(self._observables), input_gradients=input_gradients, ) @@ -131,6 +131,9 @@ def _preprocess( def _forward_postprocess(self, num_samples: int, result: EstimatorResult) -> np.ndarray: """Post-processing during forward pass of the network.""" + print('====',result.values) + if num_samples is None: + num_samples = 1 expectations = np.reshape(result.values, (-1, num_samples)).T return expectations @@ -140,19 +143,19 @@ def _forward( """Forward pass of the neural network.""" parameter_values_, num_samples = self._preprocess(input_data, weights) if num_samples is None: - return None + job = self._estimator.run(self._circuit, self._observables) else: job = self._estimator.run( [self._circuit] * num_samples * self.output_shape[0], [op for op in self._observables for _ in range(num_samples)], np.tile(parameter_values_, (self.output_shape[0], 1)), ) - try: - results = job.result() - except Exception as exc: - raise QiskitMachineLearningError("Estimator job failed.") from exc + try: + results = job.result() + except Exception as exc: + raise QiskitMachineLearningError("Estimator job failed.") from exc - return self._forward_postprocess(num_samples, results) + return self._forward_postprocess(num_samples, results) def _backward_postprocess( self, num_samples: int, result: EstimatorGradientResult @@ -185,6 +188,9 @@ def _backward( # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) + if num_samples is None: + return None, None + num_observables = self.output_shape[0] num_circuits = num_samples * num_observables diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 103de7f4c..87ecb23c0 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -115,6 +115,58 @@ ], ], ), + no_input_parameters=dict( + test_data=[None], + weights=[1, 1], + correct_forwards=[ + [[0.08565359]] + ], + correct_weight_backwards=[ + [[[-1.13339757, 0.70807342]]] + ], + correct_input_backwards=[ + None + ], + ), + no_weight_parameters=dict( + test_data=[[1 , 1]], + weights=None, + correct_forwards=[ + [[0.08565359]] + ], + correct_weight_backwards=[ + None + ], + correct_input_backwards=[ + [[[-1.13339757, 0.70807342]]] + ], + ), + no_parameters=dict( + test_data=[None], + weights=None, + correct_forwards=[ + [[1]] + ], + correct_weight_backwards=[ + None + ], + correct_input_backwards=[ + None + ], + ), + default_observables=dict( + test_data=[[[1], [2]]], + weights=[1], + correct_forwards=[ + [[-0.45464871], [-0.4912955 ]] + ], + correct_weight_backwards=[ + [[[0.70807342]], [[0.7651474 ]]] + ], + correct_input_backwards=[ + [[[-0.29192658]], [[ 0.2248451 ]]] + ], + ), ) @@ -141,15 +193,24 @@ def _test_network_passes( with self.subTest("backward pass without input gradients"): for i, inputs in enumerate(test_data): input_backward, weight_backward = estimator_qnn.backward(inputs, weights) - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + if correct_weight_backwards[i] is None: + self.assertIsNone(weight_backward) + else: + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) self.assertIsNone(input_backward) # test backward pass with input_gradients with self.subTest("backward bass with input gradients"): estimator_qnn.input_gradients = True for i, inputs in enumerate(test_data): input_backward, weight_backward = estimator_qnn.backward(inputs, weights) - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) - np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + if correct_weight_backwards[i] is None: + self.assertIsNone(weight_backward) + else: + np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + if correct_input_backwards[i] is None: + self.assertIsNone(input_backward) + else: + np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) def test_estimator_qnn_1_1(self): """Test Estimator QNN with input/output dimension 1/1.""" @@ -238,6 +299,100 @@ def test_estimator_qnn_2_2(self): self._test_network_passes(estimator_qnn, CASE_DATA["shape_2_2"]) + def test_no_input_parameters(self): + """Test Estimator QNN with no input parameters.""" + params = [Parameter("weight0"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op], + input_params=None, + weight_params=params, + ) + self._test_network_passes(estimator_qnn, CASE_DATA["no_input_parameters"]) + + def test_no_weight_parameters(self): + """Test Estimator QNN with no weight parameters.""" + params = [Parameter("input0"), Parameter("input1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op], + input_params=params, + weight_params=None, + ) + self._test_network_passes(estimator_qnn, CASE_DATA["no_weight_parameters"]) + + def test_no_parameters(self): + """Test Estimator QNN with no parameters.""" + qc = QuantumCircuit(1) + qc.h(0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op], + input_params=None, + weight_params=None, + ) + self._test_network_passes(estimator_qnn, CASE_DATA["no_parameters"]) + + def test_default_observables(self): + """Test Estimator QNN with default observables.""" + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + estimator_qnn = EstimatorQNN( + circuit=qc, + input_params=[params[0]], + weight_params=[params[1]], + ) + self._test_network_passes(estimator_qnn, CASE_DATA["default_observables"]) + + def test_observables_getter(self): + """Test Estimator QNN observables getter.""" + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op], + input_params=[params[0]], + weight_params=[params[1]], + ) + self.assertEqual(estimator_qnn.observables, [op]) + + def test_input_gradients(self): + """Test Estimator QNN input gradients.""" + params = [Parameter("input1"), Parameter("weight1")] + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[op], + input_params=[params[0]], + weight_params=[params[1]], + input_gradients=True + ) + self.assertTrue(estimator_qnn.input_gradients) + estimator_qnn.input_gradients = False + self.assertFalse(estimator_qnn.input_gradients) + if __name__ == "__main__": unittest.main() From 54e2c1a28822bfe69ce28c085fbafdaed6c68566 Mon Sep 17 00:00:00 2001 From: Anton Dekusar <62334182+adekusar-drl@users.noreply.github.com> Date: Wed, 26 Oct 2022 01:14:38 +0100 Subject: [PATCH 74/96] Update releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml Co-authored-by: Steve Wood <40241007+woodsp-ibm@users.noreply.github.com> --- releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 206715d87..35e205edb 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -2,7 +2,7 @@ features: - | New quantum neural network class, `~qiskit_machine_learning.neural_networks.EstimatorQNN`, - has been added. It internally uses :class:`~qiskit.primitives.Estimator` to calculate the + has been added. It uses :class:`~qiskit.primitives.Estimator` to calculate the forward pass and it requires :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to calculate the backward pass. From 5f1377eba303baa4ff75cfb5d860a8a0021cd69c Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Wed, 26 Oct 2022 01:24:19 +0100 Subject: [PATCH 75/96] code review --- .../algorithms/regressors/vqr.py | 63 +++++++++++------- .../neural_networks/estimator_qnn.py | 2 +- .../add-estimator-qnn-270b31662988bef9.yaml | 12 +--- test/algorithms/regressors/test_vqr.py | 10 +++ .../regressors/test_vqr_estimator_qnn.py | 8 +++ test/neural_networks/test_estimator_qnn.py | 64 +++++++------------ 6 files changed, 84 insertions(+), 75 deletions(-) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 5fa22ebe5..ae8ce06d9 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -12,14 +12,13 @@ """An implementation of quantum neural network regressor.""" from __future__ import annotations -from typing import Callable, cast +from typing import Callable import numpy as np from qiskit import QuantumCircuit from qiskit.algorithms.optimizers import Optimizer -from qiskit.opflow import OperatorBase +from qiskit.opflow import OperatorBase, PauliSumOp from qiskit.primitives import BaseEstimator -from qiskit.quantum_info import SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator from qiskit.utils import QuantumInstance @@ -38,7 +37,7 @@ def __init__( num_qubits: int | None = None, feature_map: QuantumCircuit | None = None, ansatz: QuantumCircuit | None = None, - observable: QuantumCircuit | OperatorBase | BaseOperator | None = None, + observable: QuantumCircuit | OperatorBase | BaseOperator | PauliSumOp | None = None, loss: str | Loss = "squared_error", optimizer: Optimizer | None = None, warm_start: bool = False, @@ -63,7 +62,12 @@ def __init__( QNN. If ``None`` then the :class:`~qiskit.circuit.library.RealAmplitudes` circuit is used. observable: The observable to be measured in the underlying QNN. If ``None``, - use the default :math:`Z^{\otimes num\_qubits}` observable. + use the default :math:`Z^{\otimes num\_qubits}` observable. If ``quantum_instance`` + is set and the ``estimator`` is ``None`` then the observable must be of type + :class:`~qiskit.QuantumCircuit` or :class:`~qiskit.opflow.OperatorBase`. Otherwise, + the type must be either + :class:`~qiskit.quantum_info.operators.base_operator.BaseOperator` or + :class:`~qiskit.opflow.PauliSumOp`. loss: A target loss function to be used in training. Default is squared error. optimizer: An instance of an optimizer to be used in training. When ``None`` defaults to SLSQP. @@ -76,18 +80,23 @@ def __init__( a :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN` will be used instead. initial_point: Initial point for the optimizer to start from. - callback: a reference to a user's callback function that has two parameters and + callback: A reference to a user's callback function that has two parameters and returns ``None``. The callback can access intermediate data during training. On each iteration an optimizer invokes the callback and passes current weights as an array and a computed value as a float of the objective function being optimized. This allows to track how well optimization / training process is going on. - estimator: If an estimator instance is set, the underlying QNN will be of type + estimator: An estimator to be used to evaluate expectation values of the observable. + If ``None`` the :class:`qiskit.primitives.BaseEstimator` is used. The underlying QNN + is :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN`. + If an estimator instance is set, the underlying QNN will be of type :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN`, and the estimator primitive will be used to compute the neural network's results. Raises: QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz can't be adjusted to ``num_qubits``. + ValueError: if the type of the observable is not compatible with ``quantum_instance`` or + ``estimator``. """ # needed for mypy neural_network: EstimatorQNN | TwoLayerQNN = None @@ -95,6 +104,15 @@ def __init__( warn_deprecated( "0.5.0", DeprecatedType.ARGUMENT, old_name="quantum_instance", new_name="estimator" ) + + if observable is not None and not isinstance( + observable, (QuantumCircuit, OperatorBase) + ): + raise ValueError( + f"Unsupported type of the observable, expected " + f"'QuantumCircuit | OperatorBase', got {type(observable)}" + ) + self._quantum_instance = quantum_instance self._estimator = None @@ -107,7 +125,16 @@ def __init__( quantum_instance=quantum_instance, input_gradients=False, ) + self._feature_map = neural_network.feature_map + self._ansatz = neural_network.ansatz + self._num_qubits = neural_network.num_qubits else: + if observable is not None and not isinstance(observable, (BaseOperator, PauliSumOp)): + raise ValueError( + f"Unsupported type of the observable, expected " + f"'BaseOperator | PauliSumOp', got {type(observable)}" + ) + # construct estimator QNN by default self._quantum_instance = None self._estimator = estimator @@ -124,15 +151,12 @@ def __init__( circuit.compose(self._feature_map, inplace=True) circuit.compose(self._ansatz, inplace=True) - # construct observable - if observable is None: - observable = SparsePauliOp.from_list([("Z" * num_qubits, 1)]) - self._observable = observable + observables = [observable] if observable is not None else None neural_network = EstimatorQNN( estimator=estimator, circuit=circuit, - observables=[self._observable], + observables=observables, input_params=feature_map.parameters, weight_params=ansatz.parameters, ) @@ -149,23 +173,14 @@ def __init__( @property def feature_map(self) -> QuantumCircuit: """Returns the used feature map.""" - if self._quantum_instance is not None and self._estimator is None: - return cast(TwoLayerQNN, super().neural_network).feature_map - else: - return self._feature_map + return self._feature_map @property def ansatz(self) -> QuantumCircuit: """Returns the used ansatz.""" - if self._quantum_instance is not None and self._estimator is None: - return cast(TwoLayerQNN, super().neural_network).ansatz - else: - return self._ansatz + return self._ansatz @property def num_qubits(self) -> int: """Returns the number of qubits used by ansatz and feature map.""" - if self._quantum_instance is not None and self._estimator is None: - return cast(TwoLayerQNN, super().neural_network).num_qubits - else: - return self._num_qubits + return self._num_qubits diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 0f4d5c2a0..7bb162dd6 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -131,7 +131,7 @@ def _preprocess( def _forward_postprocess(self, num_samples: int, result: EstimatorResult) -> np.ndarray: """Post-processing during forward pass of the network.""" - print('====',result.values) + print("====", result.values) if num_samples is None: num_samples = 1 expectations = np.reshape(result.values, (-1, num_samples)).T diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 35e205edb..938307560 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -3,7 +3,7 @@ features: - | New quantum neural network class, `~qiskit_machine_learning.neural_networks.EstimatorQNN`, has been added. It uses :class:`~qiskit.primitives.Estimator` to calculate the - forward pass and it requires :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to + forward pass and uses :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to calculate the backward pass. Example: @@ -11,28 +11,22 @@ features: .. code-block:: python from qiskit.circuit import QuantumCircuit, Parameter - from qiskit.primitives import Estimator - from qiskit.quantum_info import SparsePauliOp from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN - estimator = Estimator() params = [Parameter("input1"), Parameter("weight1")] qc = QuantumCircuit(1) qc.h(0) qc.ry(params[0], 0) qc.rx(params[1], 0) - op = SparsePauliOp.from_list([("Z", 1)]) estimator_qnn = EstimatorQNN( - estimator=estimator, circuit=qc, - observables=[op], input_params=[params[0]], weight_params=[params[1]] ) - inputs = [1] - weights = [2] + inputs = [1.0] + weights = [2.0] res = estimator_qnn.forward(inputs, weights) input_grad, weights_grad = estimator_qnn.backward(inputs, weights) diff --git a/test/algorithms/regressors/test_vqr.py b/test/algorithms/regressors/test_vqr.py index 15de0d402..6193fa756 100644 --- a/test/algorithms/regressors/test_vqr.py +++ b/test/algorithms/regressors/test_vqr.py @@ -20,6 +20,7 @@ from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B from qiskit.circuit import Parameter, QuantumCircuit from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes +from qiskit.quantum_info import SparsePauliOp from qiskit.utils import QuantumInstance, algorithm_globals, optionals from qiskit_machine_learning.algorithms import VQR @@ -134,6 +135,15 @@ def test_properties(self): self.assertEqual(vqr.num_qubits, 2) + def test_incorrect_observable(self): + """Test VQR with a wrong observable.""" + with self.assertRaises(ValueError): + _ = VQR( + num_qubits=2, + quantum_instance=self.qasm_quantum_instance, + observable=SparsePauliOp.from_list([("Z" * 2, 1)]), + ) + if __name__ == "__main__": unittest.main() diff --git a/test/algorithms/regressors/test_vqr_estimator_qnn.py b/test/algorithms/regressors/test_vqr_estimator_qnn.py index 24d2437a4..e42a621e5 100644 --- a/test/algorithms/regressors/test_vqr_estimator_qnn.py +++ b/test/algorithms/regressors/test_vqr_estimator_qnn.py @@ -19,6 +19,7 @@ from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B from qiskit.circuit import Parameter, QuantumCircuit from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes +from qiskit.opflow import StateFn from qiskit.primitives import Estimator from qiskit.utils import algorithm_globals @@ -111,6 +112,13 @@ def test_properties(self): self.assertEqual(vqr.num_qubits, 2) + def test_incorrect_observable(self): + """Test VQR with a wrong observable.""" + with self.assertRaises(ValueError): + _ = VQR(num_qubits=2, observable=QuantumCircuit(2)) + with self.assertRaises(ValueError): + _ = VQR(num_qubits=2, observable=StateFn(QuantumCircuit(2))) + if __name__ == "__main__": unittest.main() diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 87ecb23c0..0f913c668 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -118,54 +118,30 @@ no_input_parameters=dict( test_data=[None], weights=[1, 1], - correct_forwards=[ - [[0.08565359]] - ], - correct_weight_backwards=[ - [[[-1.13339757, 0.70807342]]] - ], - correct_input_backwards=[ - None - ], + correct_forwards=[[[0.08565359]]], + correct_weight_backwards=[[[[-1.13339757, 0.70807342]]]], + correct_input_backwards=[None], ), no_weight_parameters=dict( - test_data=[[1 , 1]], + test_data=[[1, 1]], weights=None, - correct_forwards=[ - [[0.08565359]] - ], - correct_weight_backwards=[ - None - ], - correct_input_backwards=[ - [[[-1.13339757, 0.70807342]]] - ], + correct_forwards=[[[0.08565359]]], + correct_weight_backwards=[None], + correct_input_backwards=[[[[-1.13339757, 0.70807342]]]], ), no_parameters=dict( test_data=[None], weights=None, - correct_forwards=[ - [[1]] - ], - correct_weight_backwards=[ - None - ], - correct_input_backwards=[ - None - ], + correct_forwards=[[[1]]], + correct_weight_backwards=[None], + correct_input_backwards=[None], ), default_observables=dict( test_data=[[[1], [2]]], weights=[1], - correct_forwards=[ - [[-0.45464871], [-0.4912955 ]] - ], - correct_weight_backwards=[ - [[[0.70807342]], [[0.7651474 ]]] - ], - correct_input_backwards=[ - [[[-0.29192658]], [[ 0.2248451 ]]] - ], + correct_forwards=[[[-0.45464871], [-0.4912955]]], + correct_weight_backwards=[[[[0.70807342]], [[0.7651474]]]], + correct_input_backwards=[[[[-0.29192658]], [[0.2248451]]]], ), ) @@ -196,7 +172,9 @@ def _test_network_passes( if correct_weight_backwards[i] is None: self.assertIsNone(weight_backward) else: - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + np.testing.assert_allclose( + weight_backward, correct_weight_backwards[i], atol=1e-3 + ) self.assertIsNone(input_backward) # test backward pass with input_gradients with self.subTest("backward bass with input gradients"): @@ -206,11 +184,15 @@ def _test_network_passes( if correct_weight_backwards[i] is None: self.assertIsNone(weight_backward) else: - np.testing.assert_allclose(weight_backward, correct_weight_backwards[i], atol=1e-3) + np.testing.assert_allclose( + weight_backward, correct_weight_backwards[i], atol=1e-3 + ) if correct_input_backwards[i] is None: self.assertIsNone(input_backward) else: - np.testing.assert_allclose(input_backward, correct_input_backwards[i], atol=1e-3) + np.testing.assert_allclose( + input_backward, correct_input_backwards[i], atol=1e-3 + ) def test_estimator_qnn_1_1(self): """Test Estimator QNN with input/output dimension 1/1.""" @@ -387,7 +369,7 @@ def test_input_gradients(self): observables=[op], input_params=[params[0]], weight_params=[params[1]], - input_gradients=True + input_gradients=True, ) self.assertTrue(estimator_qnn.input_gradients) estimator_qnn.input_gradients = False From 6fe881672b134341ac66dfe161a758971e263715 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 26 Oct 2022 16:55:54 +0900 Subject: [PATCH 76/96] updated --- .../neural_networks/estimator_qnn.py | 78 +++++++++++++------ .../add-estimator-qnn-270b31662988bef9.yaml | 60 +++++++++----- test/neural_networks/test_estimator_qnn.py | 50 +++++++++--- 3 files changed, 136 insertions(+), 52 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 7bb162dd6..df774dee9 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -14,6 +14,7 @@ from __future__ import annotations +from copy import copy import logging from typing import Sequence, Tuple @@ -37,48 +38,66 @@ class EstimatorQNN(NeuralNetwork): - """A Neural Network implementation based on the Estimator primitive.""" + """A Neural Network implementation based on the Estimator primitive. + + The ``EstimatorQNN`` is a neural network that takes in a parametrized quantum circuit + with the combined network's feature map (input parameters) and ansatz (weight parameters) + and outputs its measurements for the forward and backward passes. + + Attributes: + + estimator (BaseEstimator): The estimator primitive used to compute the neural network's results. + gradient (BaseEstimatorGradient): An optional estimator gradient to be used for the backward pass. + + A Neural Network implementation based on the Estimator primitive.""" def __init__( self, *, estimator: BaseEstimator | None = None, circuit: QuantumCircuit, - observables: Sequence[BaseOperator | PauliSumOp] | None = None, + observables: Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp| None = None, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, gradient: BaseEstimatorGradient | None = None, input_gradients: bool = False, ): - """ + r""" Args: estimator: The estimator used to compute neural network's results. + If ``None``, a default instance of the reference estimator, + :class:`~qiskit.algorithms.Estimator`, will be used. circuit: The quantum circuit to represent the neural network. - observables: The observables for outputs of the neural network. + observables: The observables for outputs of the neural network. If ``None``, + use the default :math:`Z^{\otimes num\_qubits}` observable. input_params: The parameters that correspond to the input data of the network. - If None, the input data is not bound to any parameters. + If ``None``, the input data is not bound to any parameters. weight_params: The parameters that correspond to the trainable weights. - If None, the weights are not bound to any parameters. + If ``None``, the weights are not bound to any parameters. gradient: The estimator gradient to be used for the backward pass. - If None, the gradient is not computed. + If None, a default instance of the estimator gradient, + :class:`~qiskit.algorithms.ParamShiftEstimatorGradient`, will be used. input_gradients: Determines whether to compute gradients with respect to input data. Note that this parameter is ``False`` by default, and must be explicitly set to ``True`` for a proper gradient computation when using ``TorchConnector``. + + Raises: + QiskitMachineLearningError: Invalid parameter values. """ if estimator is None: - self._estimator = Estimator() - else: - self._estimator = estimator + estimator = Estimator() + self.estimator = estimator self._circuit = circuit if observables is None: - self._observables = SparsePauliOp.from_list([("Z" * circuit.num_qubits, 1)]) - else: - self._observables = observables + observables = SparsePauliOp.from_list([("Z" * circuit.num_qubits, 1)]) + if isinstance(observables, (PauliSumOp, BaseOperator)): + observables = (observables,) + self._observables = observables self._input_params = list(input_params) if input_params is not None else [] self._weight_params = list(weight_params) if weight_params is not None else [] if gradient is None: - gradient = ParamShiftEstimatorGradient(self._estimator) - self._gradient = gradient + gradient = ParamShiftEstimatorGradient(self.estimator) + self.gradient = gradient self._input_gradients = input_gradients super().__init__( @@ -90,9 +109,24 @@ def __init__( ) @property - def observables(self) -> Sequence[BaseOperator | PauliSumOp]: + def circuit(self) -> QuantumCircuit: + """The quantum circuit representing the neural network.""" + return copy(self._circuit) + + @property + def observables(self) -> Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp: """Returns the underlying observables of this QNN.""" - return self._observables + return copy(self._observables) + + @property + def input_params(self) -> Sequence[Parameter] | None: + """The parameters that correspond to the input data of the network.""" + return copy(self._input_params) + + @property + def weight_params(self) -> Sequence[Parameter] | None: + """The parameters that correspond to the trainable weights.""" + return copy(self._weight_params) @property def input_gradients(self) -> bool: @@ -105,7 +139,6 @@ def input_gradients(self, input_gradients: bool) -> None: """Turn on/off computation of gradients with respect to input data.""" self._input_gradients = input_gradients - # todo: move to the super-class once sampler-based network is merged def _preprocess( self, input_data: np.ndarray | None, @@ -131,7 +164,6 @@ def _preprocess( def _forward_postprocess(self, num_samples: int, result: EstimatorResult) -> np.ndarray: """Post-processing during forward pass of the network.""" - print("====", result.values) if num_samples is None: num_samples = 1 expectations = np.reshape(result.values, (-1, num_samples)).T @@ -143,9 +175,9 @@ def _forward( """Forward pass of the neural network.""" parameter_values_, num_samples = self._preprocess(input_data, weights) if num_samples is None: - job = self._estimator.run(self._circuit, self._observables) + job = self.estimator.run(self._circuit, self._observables) else: - job = self._estimator.run( + job = self.estimator.run( [self._circuit] * num_samples * self.output_shape[0], [op for op in self._observables for _ in range(num_samples)], np.tile(parameter_values_, (self.output_shape[0], 1)), @@ -199,10 +231,10 @@ def _backward( param_values = np.tile(parameter_values_, (num_observables, 1)) if self._input_gradients: - job = self._gradient.run(circuits, observables, param_values) + job = self.gradient.run(circuits, observables, param_values) else: params = [self._circuit.parameters[self._num_inputs :]] * num_circuits - job = self._gradient.run(circuits, observables, param_values, parameters=params) + job = self.gradient.run(circuits, observables, param_values, parameters=params) try: results = job.result() diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 938307560..e19d4ab21 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -1,32 +1,54 @@ --- features: - | - New quantum neural network class, `~qiskit_machine_learning.neural_networks.EstimatorQNN`, - has been added. It uses :class:`~qiskit.primitives.Estimator` to calculate the - forward pass and uses :class:`qiskit.algorithms.gradients.BaseEstimatorGradient` to - calculate the backward pass. + Introduced Estimator Quantum Neural Network + (class, `~qiskit_machine_learning.neural_networks.EstimatorQNN`) based on (runtime) primitives. + This implementation leverages the estimator primitive + (see :class:`~qiskit.primitives.BaseEstimator`) and the estimator gradients + (see :class:`~qiskit.algorithms.gradients.BaseEstimatorGradient`) to enable runtime access and + more efficient computation of forward and backward passes. + + The new Estimator QNN exposes a similar interface to the Circuit QNN, with a few differences. + One is the `quantum_instance` parameter. This parameter does not have a direct replacement, + and instead the `estimator` parameter must be used. The `gradient` parameter keeps the same name + as in the Opflow QNN implementation, but it no longer accepts Opflow gradient classes as inputs; + instead, this parameter expects an (optionally custom) primitive gradient. + + The existing training algorithms such as :class:`~qiskit_machine_learning.algorithms.VQR`, + that were based on the Opflow QNN, are updated to accept both implementations. The implementation + of :class:`~qiskit_machine_learning.algorithms.NeuralNetworkRegressor` has not changed. + + For example a `VQR` using `EstimatorQNN` can be trained as follows: + Example: .. code-block:: python + import numpy as np + from qiskit.algorithms.optimizers import L_BFGS_B from qiskit.circuit import QuantumCircuit, Parameter + from qiskit.primitives import Estimator - from qiskit_machine_learning.neural_networks.estimator_qnn import EstimatorQNN + from qiskit_machine_learning.algorithms import VQR - params = [Parameter("input1"), Parameter("weight1")] - qc = QuantumCircuit(1) - qc.h(0) - qc.ry(params[0], 0) - qc.rx(params[1], 0) + num_samples = 20 + eps = 0.2 + lb, ub = -np.pi, np.pi + X = (ub - lb) * np.random.rand(num_samples, 1) + lb + Y = np.sin(X[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1) - estimator_qnn = EstimatorQNN( - circuit=qc, - input_params=[params[0]], - weight_params=[params[1]] - ) + params = [Parameter("θ_0"), Parameter("θ_1")] + feature_map = QuantumCircuit(1, name="fm") + feature_map.ry(params[0], 0) + ansatz = QuantumCircuit(1, name="vf") + ansatz.ry(params[1], 0) - inputs = [1.0] - weights = [2.0] - res = estimator_qnn.forward(inputs, weights) - input_grad, weights_grad = estimator_qnn.backward(inputs, weights) + vqr = VQR( + feature_map=feature_map, + ansatz=ansatz, + optimizer=L_BFGS_B(maxiter=5), + initial_point=np.array([0]), + estimator=Estimator() + ) + vqr.fit(X, Y) diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 0f913c668..9cd93d300 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -143,6 +143,28 @@ correct_weight_backwards=[[[[0.70807342]], [[0.7651474]]]], correct_input_backwards=[[[[-0.29192658]], [[0.2248451]]]], ), + single_observable=dict( + test_data=[1, [1], [[1], [2]], [[[1], [2]], [[3], [4]]]], + weights=[1], + correct_forwards=[ + [[0.08565359]], + [[0.08565359]], + [[0.08565359], [-0.90744233]], + [[[0.08565359], [-0.90744233]], [[-1.06623996], [-0.24474149]]], + ], + correct_weight_backwards=[ + [[[0.70807342]]], + [[[0.70807342]]], + [[[0.70807342]], [[0.7651474]]], + [[[[0.70807342]], [[0.7651474]]], [[[0.11874839]], [[-0.63682734]]]], + ], + correct_input_backwards=[ + [[[-1.13339757]]], + [[[-1.13339757]]], + [[[-1.13339757]], [[-0.68445233]]], + [[[[-1.13339757]], [[-0.68445233]]], [[[0.39377522]], [[1.10996765]]]], + ], + ), ) @@ -340,8 +362,8 @@ def test_default_observables(self): ) self._test_network_passes(estimator_qnn, CASE_DATA["default_observables"]) - def test_observables_getter(self): - """Test Estimator QNN observables getter.""" + def test_single_observable(self): + """Test Estimator QNN with single observable.""" params = [Parameter("input1"), Parameter("weight1")] qc = QuantumCircuit(1) qc.h(0) @@ -350,14 +372,14 @@ def test_observables_getter(self): op = SparsePauliOp.from_list([("Z", 1), ("X", 1)]) estimator_qnn = EstimatorQNN( circuit=qc, - observables=[op], + observables=op, input_params=[params[0]], weight_params=[params[1]], ) - self.assertEqual(estimator_qnn.observables, [op]) + self._test_network_passes(estimator_qnn, CASE_DATA["single_observable"]) - def test_input_gradients(self): - """Test Estimator QNN input gradients.""" + def test_setters_getters(self): + """Test Estimator QNN setters/getters.""" params = [Parameter("input1"), Parameter("weight1")] qc = QuantumCircuit(1) qc.h(0) @@ -369,11 +391,19 @@ def test_input_gradients(self): observables=[op], input_params=[params[0]], weight_params=[params[1]], - input_gradients=True, ) - self.assertTrue(estimator_qnn.input_gradients) - estimator_qnn.input_gradients = False - self.assertFalse(estimator_qnn.input_gradients) + with self.subTest("Test circuit getter."): + self.assertEqual(estimator_qnn.circuit, qc) + with self.subTest("Test observables getter."): + self.assertEqual(estimator_qnn.observables, [op]) + with self.subTest("Test input_params getter."): + self.assertEqual(estimator_qnn.input_params, [params[0]]) + with self.subTest("Test weight_params getter."): + self.assertEqual(estimator_qnn.weight_params, [params[1]]) + with self.subTest("Test input_gradients setter and getter."): + self.assertFalse(estimator_qnn.input_gradients) + estimator_qnn.input_gradients = True + self.assertTrue(estimator_qnn.input_gradients) if __name__ == "__main__": From 8c1cea1e0208f5729498fc38062b5c08d14c82ee Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 26 Oct 2022 17:07:23 +0900 Subject: [PATCH 77/96] fix lint --- qiskit_machine_learning/neural_networks/estimator_qnn.py | 5 +++-- test/neural_networks/test_estimator_qnn.py | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index df774dee9..242c0c0f7 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -47,7 +47,8 @@ class EstimatorQNN(NeuralNetwork): Attributes: estimator (BaseEstimator): The estimator primitive used to compute the neural network's results. - gradient (BaseEstimatorGradient): An optional estimator gradient to be used for the backward pass. + gradient (BaseEstimatorGradient): An optional estimator gradient to be used for the backward + pass. A Neural Network implementation based on the Estimator primitive.""" @@ -56,7 +57,7 @@ def __init__( *, estimator: BaseEstimator | None = None, circuit: QuantumCircuit, - observables: Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp| None = None, + observables: Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp | None = None, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, gradient: BaseEstimatorGradient | None = None, diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index 9cd93d300..bf2014c4c 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -379,7 +379,7 @@ def test_single_observable(self): self._test_network_passes(estimator_qnn, CASE_DATA["single_observable"]) def test_setters_getters(self): - """Test Estimator QNN setters/getters.""" + """Test Estimator QNN properties.""" params = [Parameter("input1"), Parameter("weight1")] qc = QuantumCircuit(1) qc.h(0) From 2c29d8b1fbb68696a9901248f3b214580fe599aa Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Wed, 26 Oct 2022 17:15:38 +0900 Subject: [PATCH 78/96] fix --- releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index e19d4ab21..0e745aacb 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -24,6 +24,7 @@ features: Example: .. code-block:: python + import numpy as np from qiskit.algorithms.optimizers import L_BFGS_B From d1f892f8e902906559a20e37f5a1daf349fea417 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Wed, 26 Oct 2022 12:02:23 +0100 Subject: [PATCH 79/96] fix spelling mistake --- test/neural_networks/test_estimator_qnn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py index bf2014c4c..bb80d09ec 100644 --- a/test/neural_networks/test_estimator_qnn.py +++ b/test/neural_networks/test_estimator_qnn.py @@ -199,7 +199,7 @@ def _test_network_passes( ) self.assertIsNone(input_backward) # test backward pass with input_gradients - with self.subTest("backward bass with input gradients"): + with self.subTest("backward pass with input gradients"): estimator_qnn.input_gradients = True for i, inputs in enumerate(test_data): input_backward, weight_backward = estimator_qnn.backward(inputs, weights) From 482e72045435f080ae0a0fb7d5b3315f6b64fd6a Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Thu, 27 Oct 2022 12:42:35 +0900 Subject: [PATCH 80/96] fix backward pass with no weight params --- qiskit_machine_learning/neural_networks/estimator_qnn.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 242c0c0f7..5c7788eaa 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -221,9 +221,8 @@ def _backward( # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) - if num_samples is None: + if num_samples is None or not (self._input_gradients or self._num_weights): return None, None - num_observables = self.output_shape[0] num_circuits = num_samples * num_observables From ff4915b93f47f0a2c0d844d4e3ceaf6349b5f573 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Thu, 27 Oct 2022 12:53:21 +0900 Subject: [PATCH 81/96] fix --- releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 0e745aacb..37d06a862 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -8,7 +8,8 @@ features: (see :class:`~qiskit.algorithms.gradients.BaseEstimatorGradient`) to enable runtime access and more efficient computation of forward and backward passes. - The new Estimator QNN exposes a similar interface to the Circuit QNN, with a few differences. + The new :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN` exposes a similar + interface to the Opflow QNN, with a few differences. One is the `quantum_instance` parameter. This parameter does not have a direct replacement, and instead the `estimator` parameter must be used. The `gradient` parameter keeps the same name as in the Opflow QNN implementation, but it no longer accepts Opflow gradient classes as inputs; From f6014925321bfce4d425b98b11ed51e185cbffd9 Mon Sep 17 00:00:00 2001 From: ElePT <57907331+ElePT@users.noreply.github.com> Date: Thu, 27 Oct 2022 11:09:11 +0200 Subject: [PATCH 82/96] Update qiskit_machine_learning/neural_networks/sampler_qnn.py --- qiskit_machine_learning/neural_networks/sampler_qnn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 64f0ffcbe..431e964fc 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -66,8 +66,8 @@ class SamplerQNN(NeuralNetwork): def __init__( self, *, - sampler: BaseSampler | None = None, circuit: QuantumCircuit, + sampler: BaseSampler | None = None, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, sparse: bool = False, From 2117112ff17b0cfb1d2638c821bcdbfae7fb5c14 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 28 Oct 2022 11:45:50 +0900 Subject: [PATCH 83/96] reflected comments --- .../neural_networks/estimator_qnn.py | 12 ++++++++---- .../notes/add-estimator-qnn-270b31662988bef9.yaml | 5 +---- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 5c7788eaa..62756760e 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -44,10 +44,13 @@ class EstimatorQNN(NeuralNetwork): with the combined network's feature map (input parameters) and ansatz (weight parameters) and outputs its measurements for the forward and backward passes. + The following attributes can be set via the initializer but can also be read and + updated once the EstimatorQNN object has been constructed. + Attributes: estimator (BaseEstimator): The estimator primitive used to compute the neural network's results. - gradient (BaseEstimatorGradient): An optional estimator gradient to be used for the backward + gradient (BaseEstimatorGradient): The estimator gradient to be used for the backward pass. A Neural Network implementation based on the Estimator primitive.""" @@ -67,7 +70,7 @@ def __init__( Args: estimator: The estimator used to compute neural network's results. If ``None``, a default instance of the reference estimator, - :class:`~qiskit.algorithms.Estimator`, will be used. + :class:`~qiskit.primitives.Estimator`, will be used. circuit: The quantum circuit to represent the neural network. observables: The observables for outputs of the neural network. If ``None``, use the default :math:`Z^{\otimes num\_qubits}` observable. @@ -77,10 +80,11 @@ def __init__( If ``None``, the weights are not bound to any parameters. gradient: The estimator gradient to be used for the backward pass. If None, a default instance of the estimator gradient, - :class:`~qiskit.algorithms.ParamShiftEstimatorGradient`, will be used. + :class:`~qiskit.algorithms.gradients.ParamShiftEstimatorGradient`, will be used. input_gradients: Determines whether to compute gradients with respect to input data. Note that this parameter is ``False`` by default, and must be explicitly set to - ``True`` for a proper gradient computation when using ``TorchConnector``. + ``True`` for a proper gradient computation when using + :class:`~qiskit_machine_learning.connectors.TorchConnector`. Raises: QiskitMachineLearningError: Invalid parameter values. diff --git a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml index 37d06a862..9ab515190 100644 --- a/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml +++ b/releasenotes/notes/add-estimator-qnn-270b31662988bef9.yaml @@ -2,7 +2,7 @@ features: - | Introduced Estimator Quantum Neural Network - (class, `~qiskit_machine_learning.neural_networks.EstimatorQNN`) based on (runtime) primitives. + (:class:`~qiskit_machine_learning.neural_networks.EstimatorQNN`) based on (runtime) primitives. This implementation leverages the estimator primitive (see :class:`~qiskit.primitives.BaseEstimator`) and the estimator gradients (see :class:`~qiskit.algorithms.gradients.BaseEstimatorGradient`) to enable runtime access and @@ -21,9 +21,6 @@ features: For example a `VQR` using `EstimatorQNN` can be trained as follows: - - Example: - .. code-block:: python import numpy as np From 923f80b257a5a6a1d0c6d238eb18501be32e282b Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 28 Oct 2022 16:57:18 +0900 Subject: [PATCH 84/96] fix spell --- qiskit_machine_learning/neural_networks/estimator_qnn.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 62756760e..3dd91f9fe 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -44,7 +44,7 @@ class EstimatorQNN(NeuralNetwork): with the combined network's feature map (input parameters) and ansatz (weight parameters) and outputs its measurements for the forward and backward passes. - The following attributes can be set via the initializer but can also be read and + The following attributes can be set via the constructor but can also be read and updated once the EstimatorQNN object has been constructed. Attributes: From a0d92ecb5bd46e51e3ea266583c3c8a88ce779b6 Mon Sep 17 00:00:00 2001 From: ElePT Date: Fri, 28 Oct 2022 11:46:38 +0200 Subject: [PATCH 85/96] Add try-catch --- .../neural_networks/sampler_qnn.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 431e964fc..07286da94 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -341,7 +341,10 @@ def _forward( if num_samples is not None and np.prod(parameter_values.shape) > 0: # sampler allows batching job = self.sampler.run([self._circuit] * num_samples, parameter_values) - results = job.result() + try: + results = job.result() + except Exception as exc: + raise QiskitMachineLearningError("Sampler job failed.") from exc result = self._postprocess(num_samples, results) else: result = None @@ -362,7 +365,6 @@ def _backward( if num_samples is not None and np.prod(parameter_values.shape) > 0: if self._input_gradients: job = self.gradient.run([self._circuit] * num_samples, parameter_values) - results = job.result() else: if len(parameter_values[0]) > self._num_inputs: job = self.gradient.run( @@ -370,7 +372,10 @@ def _backward( parameter_values, parameters=[self._circuit.parameters[self._num_inputs :]] * num_samples, ) - results = job.result() + try: + results = job.result() + except Exception as exc: + raise QiskitMachineLearningError("Sampler job failed.") from exc if results is None: return None, None From 090ffd841f3bbf47f7469c75893d1e74a1235e03 Mon Sep 17 00:00:00 2001 From: a-matsuo Date: Fri, 28 Oct 2022 19:33:34 +0900 Subject: [PATCH 86/96] fix --- .../neural_networks/estimator_qnn.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index 3dd91f9fe..e56aa49af 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -14,15 +14,15 @@ from __future__ import annotations -from copy import copy import logging -from typing import Sequence, Tuple +from copy import copy +from typing import Sequence import numpy as np from qiskit.algorithms.gradients import ( BaseEstimatorGradient, - ParamShiftEstimatorGradient, EstimatorGradientResult, + ParamShiftEstimatorGradient, ) from qiskit.circuit import Parameter, QuantumCircuit from qiskit.opflow import PauliSumOp @@ -58,8 +58,8 @@ class EstimatorQNN(NeuralNetwork): def __init__( self, *, - estimator: BaseEstimator | None = None, circuit: QuantumCircuit, + estimator: BaseEstimator | None = None, observables: Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp | None = None, input_params: Sequence[Parameter] | None = None, weight_params: Sequence[Parameter] | None = None, @@ -220,12 +220,12 @@ def _backward_postprocess( def _backward( self, input_data: np.ndarray | None, weights: np.ndarray | None - ) -> Tuple[np.ndarray | None, np.ndarray]: + ) -> tuple[np.ndarray | None, np.ndarray]: """Backward pass of the network.""" # prepare parameters in the required format parameter_values_, num_samples = self._preprocess(input_data, weights) - if num_samples is None or not (self._input_gradients or self._num_weights): + if num_samples is None or (self._input_gradients is False and self._num_weights == 0): return None, None num_observables = self.output_shape[0] num_circuits = num_samples * num_observables From 68018db15423b835cbb3f0c5e18ab441c7b06af4 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 28 Oct 2022 12:12:13 +0100 Subject: [PATCH 87/96] add torch tests --- test/connectors/test_torch_networks.py | 32 +++++++++++++++++++++++--- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/test/connectors/test_torch_networks.py b/test/connectors/test_torch_networks.py index c3c2cbf48..a424068b6 100644 --- a/test/connectors/test_torch_networks.py +++ b/test/connectors/test_torch_networks.py @@ -19,7 +19,12 @@ from qiskit import QuantumCircuit from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap -from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN, NeuralNetwork +from qiskit_machine_learning.neural_networks import ( + CircuitQNN, + TwoLayerQNN, + NeuralNetwork, + EstimatorQNN, +) from qiskit_machine_learning.connectors import TorchConnector @@ -86,20 +91,41 @@ def _create_opflow_qnn(self) -> TwoLayerQNN: ) return qnn - @idata(["opflow", "circuit_qnn"]) + def _create_estimator_qnn(self) -> EstimatorQNN: + num_inputs = 2 + + feature_map = ZZFeatureMap(num_inputs) + ansatz = RealAmplitudes(num_inputs, entanglement="linear", reps=1) + + qc = QuantumCircuit(num_inputs) + qc.append(feature_map, range(num_inputs)) + qc.append(ansatz, range(num_inputs)) + + qnn = EstimatorQNN( + circuit=qc, + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + input_gradients=True, # for hybrid qnn + ) + return qnn + + @idata(["opflow", "circuit_qnn", "estimator_qnn"]) def test_hybrid_batch_gradients(self, qnn_type: str): """Test gradient back-prop for batch input in a qnn.""" import torch from torch.nn import MSELoss from torch.optim import SGD - qnn: Optional[Union[CircuitQNN, TwoLayerQNN]] = None + qnn: Optional[Union[CircuitQNN, TwoLayerQNN, EstimatorQNN]] = None if qnn_type == "opflow": qnn = self._create_opflow_qnn() output_size = 1 elif qnn_type == "circuit_qnn": qnn = self._create_circuit_qnn() output_size = 2 + elif qnn_type == "estimator_qnn": + qnn = self._create_estimator_qnn() + output_size = 1 else: raise ValueError("Unsupported QNN type") From 60f5f9234dd79d2d5c5b291090651c2d0a77aeba Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 28 Oct 2022 15:47:38 +0100 Subject: [PATCH 88/96] convert two first tutorials --- docs/tutorials/01_neural_networks.ipynb | 647 +++--------------- ...ral_network_classifier_and_regressor.ipynb | 200 +++--- 2 files changed, 209 insertions(+), 638 deletions(-) diff --git a/docs/tutorials/01_neural_networks.ipynb b/docs/tutorials/01_neural_networks.ipynb index 8fb1477e5..03b73e85b 100644 --- a/docs/tutorials/01_neural_networks.ipynb +++ b/docs/tutorials/01_neural_networks.ipynb @@ -13,9 +13,8 @@ "The following different available neural networks will now be discussed in more detail:\n", "\n", "1. `NeuralNetwork`: The interface for neural networks.\n", - "2. `OpflowQNN`: A network based on the evaluation of quantum mechanical observables.\n", - "3. `TwoLayerQNN`: A special `OpflowQNN` implementation for convenience. \n", - "3. `CircuitQNN`: A network based on the samples resulting from measuring a quantum circuit." + "2. `EstimatorQNN`: A network based on the evaluation of quantum mechanical observables.\n", + "3. `SamplerQNN`: A network based on the samples resulting from measuring a quantum circuit.\n" ] }, { @@ -25,38 +24,14 @@ "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", - "\n", "from qiskit import QuantumCircuit\n", - "from qiskit_aer import Aer\n", "from qiskit.circuit import Parameter\n", - "from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap\n", - "from qiskit.opflow import StateFn, PauliSumOp, AerPauliExpectation, ListOp, Gradient\n", - "from qiskit.utils import QuantumInstance, algorithm_globals\n", + "from qiskit.circuit.library import RealAmplitudes\n", + "from qiskit.utils import algorithm_globals\n", "\n", "algorithm_globals.random_seed = 42" ] }, - { - "cell_type": "code", - "execution_count": 2, - "id": "single-likelihood", - "metadata": {}, - "outputs": [], - "source": [ - "# set method to calculcate expected values\n", - "expval = AerPauliExpectation()\n", - "\n", - "# define gradient method\n", - "gradient = Gradient()\n", - "\n", - "# define quantum instances (statevector and sample based)\n", - "qi_sv = QuantumInstance(Aer.get_backend(\"aer_simulator_statevector\"))\n", - "\n", - "# we set shots to 10 as this will determine the number of samples later on.\n", - "qi_qasm = QuantumInstance(Aer.get_backend(\"aer_simulator\"), shots=10)" - ] - }, { "cell_type": "markdown", "id": "roman-lindsay", @@ -78,43 +53,38 @@ "id": "billion-uniform", "metadata": {}, "source": [ - "## 2. `OpflowQNN`\n", + "## 2. `EstimatorQNN`\n", "\n", - "The `OpflowQNN` takes a (parametrized) operator from Qiskit and leverages Qiskit's gradient framework to provide the backward pass. \n", - "Such an operator can for instance be an expected value of a quantum mechanical observable with respect to a parametrized quantum state. The Parameters can be used to load classical data as well as represent trainable weights.\n", - "The `OpflowQNN` also allows lists of operators and more complex structures to construct more complex QNNs." + "The `EstimatorQNN` takes in a parametrized quantum circuit with the combined network's feature map (input parameters) and ansatz (weight parameters), as well as an optional quantum mechanical observable, and outputs expectation value computations for the forward pass. The quantum circuit parameters can be used to load classical data as well as represent trainable weights.\n", + "The `EstimatorQNN` also allows lists of observables to construct more complex QNNs." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "separate-presence", "metadata": {}, "outputs": [], "source": [ - "from qiskit_machine_learning.neural_networks import OpflowQNN" + "from qiskit_machine_learning.neural_networks import EstimatorQNN" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "popular-artwork", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "ComposedOp([\n", - " OperatorMeasurement(1.0 * Z\n", - " + 1.0 * X),\n", - " CircuitStateFn(\n", - " ┌───┐┌────────────┐┌─────────────┐\n", - " q: ┤ H ├┤ Ry(input1) ├┤ Rx(weight1) ├\n", - " └───┘└────────────┘└─────────────┘\n", - " )\n", - "])\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -124,14 +94,35 @@ "qc1.h(0)\n", "qc1.ry(params1[0], 0)\n", "qc1.rx(params1[1], 0)\n", - "qc_sfn1 = StateFn(qc1)\n", - "\n", - "# construct cost operator\n", - "H1 = StateFn(PauliSumOp.from_list([(\"Z\", 1.0), (\"X\", 1.0)]))\n", + "qc1.draw(\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "crucial-aquatic", + "metadata": {}, + "source": [ + "We create an observable manually. If it is set, then The default observable $Z^{\\otimes n}$, where $n$ is the number of qubits, is created automatically." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "encouraging-magnitude", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit.quantum_info import SparsePauliOp\n", "\n", - "# combine operator and circuit to objective function\n", - "op1 = ~H1 @ qc_sfn1\n", - "print(op1)" + "observable1 = SparsePauliOp.from_list([(\"Y\" * qc1.num_qubits, 1)])" + ] + }, + { + "cell_type": "markdown", + "id": "still-modeling", + "metadata": {}, + "source": [ + "Construct EstimatorQNN with the observable, input parameters, and weight parameters." ] }, { @@ -141,9 +132,9 @@ "metadata": {}, "outputs": [], "source": [ - "# construct OpflowQNN with the operator, the input parameters, the weight parameters,\n", - "# the expected value, gradient, and quantum instance.\n", - "qnn1 = OpflowQNN(op1, [params1[0]], [params1[1]], expval, gradient, qi_sv)" + "qnn1 = EstimatorQNN(\n", + " circuit=qc1, observables=observable1, input_params=[params1[0]], weight_params=[params1[1]]\n", + ")" ] }, { @@ -167,7 +158,7 @@ { "data": { "text/plain": [ - "array([[0.08242345]])" + "array([[0.2970094]])" ] }, "execution_count": 7, @@ -189,8 +180,8 @@ { "data": { "text/plain": [ - "array([[0.08242345],\n", - " [0.08242345]])" + "array([[0.2970094],\n", + " [0.2970094]])" ] }, "execution_count": 8, @@ -212,7 +203,7 @@ { "data": { "text/plain": [ - "(None, array([[[0.2970094]]]))" + "(None, array([[[0.63272767]]]))" ] }, "execution_count": 9, @@ -235,9 +226,9 @@ "data": { "text/plain": [ "(None,\n", - " array([[[0.2970094]],\n", + " array([[[0.63272767]],\n", " \n", - " [[0.2970094]]]))" + " [[0.63272767]]]))" ] }, "execution_count": 10, @@ -255,7 +246,7 @@ "id": "completed-dressing", "metadata": {}, "source": [ - "Combining multiple observables in a `ListOp` also allows to create more complex QNNs" + "Combining multiple observables in a list allows to create more complex QNNs." ] }, { @@ -265,8 +256,14 @@ "metadata": {}, "outputs": [], "source": [ - "op2 = ListOp([op1, op1])\n", - "qnn2 = OpflowQNN(op2, [params1[0]], [params1[1]], expval, gradient, qi_sv)" + "observable2 = SparsePauliOp.from_list([(\"Z\" * qc1.num_qubits, 1)])\n", + "\n", + "qnn2 = EstimatorQNN(\n", + " circuit=qc1,\n", + " observables=[observable1, observable2],\n", + " input_params=[params1[0]],\n", + " weight_params=[params1[1]],\n", + ")" ] }, { @@ -278,7 +275,7 @@ { "data": { "text/plain": [ - "array([[0.08242345, 0.08242345]])" + "array([[ 0.2970094 , -0.63272767]])" ] }, "execution_count": 12, @@ -301,8 +298,8 @@ "data": { "text/plain": [ "(None,\n", - " array([[[0.2970094],\n", - " [0.2970094]]]))" + " array([[[0.63272767],\n", + " [0.2970094 ]]]))" ] }, "execution_count": 13, @@ -315,248 +312,69 @@ "qnn2.backward(input1, weights1)" ] }, - { - "cell_type": "markdown", - "id": "bound-hypothesis", - "metadata": {}, - "source": [ - "## 3. `TwoLayerQNN`\n", - "\n", - "The `TwoLayerQNN` is a special `OpflowQNN` on $n$ qubits that consists of first a feature map to insert data and second an ansatz that is trained. The default observable is $Z^{\\otimes n}$, i.e., parity." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "ready-accounting", - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit_machine_learning.neural_networks import TwoLayerQNN" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "twelve-south", - "metadata": {}, - "outputs": [], - "source": [ - "# specify the number of qubits\n", - "num_qubits = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "artificial-mileage", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# specify the feature map\n", - "fm = ZZFeatureMap(num_qubits, reps=2)\n", - "fm.draw(output=\"mpl\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "greater-latex", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAANgAAACoCAYAAACCAiAsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYyUlEQVR4nO3de1zO9//H8UcnHaSSEDlV0oiaMoeG6ufUjDHTnA+t4Vu278hszDKGnMrY5mzDbLJl2dchx9GFGXOYrB0kokURlUoHdPX7Iy4uV1HxmbLX/Xbb7Vbv9+fzfr8/167n9flcH12vS6+oqKgIIYQi9J/2AoR4lknAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQBEwIBUnAhFCQ4dNewNN2ei9kX3naqxCVXY064Px/5d/vXx+w7CuQmfy0VyGeVXKJKISCJGBCKEgCJoSCJGBCKEgCJoSCJGBCKEgCJoSCJGBCKEgCJoSCKnXA1Go1YWFhODk5YWJigpubGyqVCmdnZ0aPHq3o3IXqQlZsnUj/abV55cMaTF/7GtdvXFV0TvHsqdQBCwgIYMaMGYwZM4bt27fz+uuvM2jQIM6dO4eHh4eic2/YN4dDv/+Pz94+QsSU4r+lmhsxTNE5xbOn0v4tYkREBGvWrCEmJgYvLy8AfHx8OHHiBFFRUbi7uys6f/ThFQztNpV6tRwAGPXyPEbMbcrljAvUrdlY0bnFs6PSnsFCQ0Px9fXVhOuupk2bYmRkhKurKwDnz5/Hy8uLZs2a0apVKw4cOPDYc+fkZXIlMwknu3tnyfo2jpiZWHD2Uuxjjy/+PSplwJKTk4mLi8PPz0+nLykpCRcXF4yNjQEYM2YMAwYMID4+nuXLlzNw4EBu3rz5yDn09PTQ09NDpYrR6cstyAaguqmlVru5iRW5+VkVOCJR1alUMZrnTHlU2oAB2NraarXn5eWhUqk0l4dXr17l4MGDBAQEAODp6Un9+vXZt2/fY81vZlwDgBt517Xac/IzMTOxeKyxxb9LpQyYjY0NAPHx8Vrt8+bNIyUlRXODIykpibp162rOZgD29vZcuHDhkXMUFRVRVFSEl5e3Tp+5qRV1rBqRcPGEpi3l2jly87NwqOdakUMSVZyXl7fmOVMelfImh4ODA66uroSGhmJtbY2dnR0bN24kOjoaQPE7iAA924/m25i5uDX1wcKsFiuj36dNsx7YWjdRfG7x7KiUZzB9fX0iIyNxcXEhMDAQf39/bGxsGDt2LAYGBpobHI0aNeLy5csUFBRo9k1MTKRx48e/yzfQZxLtm/fmrUUvMGimHWp1IZMGf/3Y44p/F72i8p7znqJhw4YRGxvLqVOnNG3du3enb9++BAUFcejQIfr378/58+epVq1amcY8tkFKBohHs2oAbQaWf79KeYlYmmPHjtG+fXuttmXLljFy5EgWLlxItWrViIiIKHO4hFBalQlYTk4O8fHxBAUFabU7ODiwf//+p7QqIR6uygTM3NycwsLCp70MIcqlUt7kEOJZIQETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAGr4nYeXcOIOU2f9jKYsNSbb/bM1Pzee4o5f5z/+YnOkZaZTLeJeqSmn3+i4ypJAvYPmLDUm56TjOk9xZw+IZaMWfA8qthIRef88cQ3dJuox7pd0xWdpzRbZuXQokkHAGLPxtDj/SrzTVlPlATsHzKkawhbZuUQNe0aPV4Yyez1g7l4NUGx+bYdXk4NM2u2H/2CQrV8r9rTUqkDplarCQsLw8nJCRMTE9zc3FCpVDg7OzN69OinvbwKMTAw5KV2oyhU3+bspZMA/BT3A0ELPegbYsUb85vz44lvNNunZSYzeaUv/afVpk+IJeOXdCI++fhD57hw+U9+SzzAewPWkp6VwtG/tmv1Dw1twjd7ZvLuMh96TzFnVHgrzl06xd5fIxgxpyl9QiwJj3yTwsLbAKSmn6fbRD2ij6xi5Nxm9AmxZOrqPmTkXCl1Dd0m6hGXeJCr1y/xwaqXUKsL6T3FnN5TzNl1bK1mzLT7viD7wcvd9KxUQla/Qp8QS0bObcbR0zt05ok+spJRYS3pE2LJfz5pzbHTuzR9CRd/ZdzijvQJsaTfVGve+dyT7NyMhz52T1qlPm8HBAQQFRVFSEgIHh4eHDp0iEGDBpGWlkZwcLCic+87uYHNhxZz7lIs+bdy2Tn39hMZ99btm2w9tBSABjbNOB6/m/DIAKaP+AGXJi8Sn3yMyat6UNuqIa4OnSkqUtPbMwh3p67o6emxKnoS09f2Y+2kBAwNjEqcI/rIChzqudK+RS/aPteTbYeX075FL61tdh1fy8cjN2Nn05Swb/2ZtvZVWjt1YVlwLNk3rjF2URtiHH3o4j5Es8+e41+xIHA/xtXMmL9hBHPWD2Xu6F0PTq/FxrI+oW9u570VXdkyK0fTXpb3UbMjhlDd2IL1HyRRcCuPj9f1f+A4V/LtvrlMHf499ratOHp6B9O/6sey8Sexs2nKZ5vG0sbZl/BAFUVFauKTj2No+M9+f3elPYNFRESwZs0aNm/ezLvvvouPjw9TpkyhQ4cO3L59G3d3d0XnNzetSe8OQQS+svCJjLf+x1n0DbGi1wemrN75IcF+q3Co78qmg4t4teM7tHLohL6+Ps81aksX96HsPv4VAHVqNsLT5RVMqplhbGSKf4+ZXMlM4uLVMyXOc/NWPruPf0WPF/wB8G0bwC+nt2udKQBebjeaxnWbY2hghE/rwaSkn8Pfdxam1apTp2YjXB29iU8+prXP0G4fYW1hS3UTC0b1ms+JM7u5ev3SE3l8HnT1+kVOJuxldK8wqptaYm1hy7BuH2lts+nAIoZ2nYpjfTf09fVp17wnzzv6EHNyAwCGBtW4kplEWubfGBoY0aJxe0yrVVdkvaWptGew0NBQfH198fLy0mpv2rQpRkZGuLq6AjB16lQ2bNhAQkIC3333Hf379y9puHJ7wbkHUPwG/UkY3GUKQ7p+SHZuBuGRAcQm7OOltgGkpicSm7CP7/cv0GyrLiqkpX0nAK7fuMqyzcHEnovhRl4menrFr4mZOWk0rqs7j+pUJPkFOXRxHwpAu+d6YlW9Ntt/WcXw7tM021nXqKf52aSaGfr6BliZ19a0GRuZkVuQrTW2bc0mOj9fvZ6MjWX9Cj0mD5N2vfgFoW7NxvfmtLbX2iY1PZHPfhjL4v/9V9NWqL6NjWUDAN4dsJpv9sxg/JKOGOob0cV9KMO6fYSBwT/3tK+UAUtOTiYuLo7x48fr9CUlJeHi4oKxsTEAvr6+jBw5kjfeeKNcc+jp6QEQ9p99uDl6P/aay6qGWU2C/VYxYo4jh+L+R52ajeneZiSve08scfsvoieTnp3CZ28foZZFPXLzs+kTYgEUlbh99JEVFBYVMiqspaYtJz+THb98wZCuIRjoG1R47akZ56lv46j5GdA8mR/m7ovC/cyMawCQf/OGpu1a1r2zoY2FHQCXMy5o5rz8wGVlnZqNGd59Ol5ufiXOW8/anndf/xKAxJTfmLSyO7bW9vi2Ld9zBUCliuGFQT4AFBWV/NiXpFJeIiYnF7962draarXn5eWhUqm0Lg89PT1xcHD4R9f3uCzMrHmtUzBf7viAfh3H8f2BT/jt3AEK1YXcun2T+OTjnP67+PIstyALYyMzapjWJK8gh1XR75c67oXLfxCXeJBpIzaxbPxJzX+fv/0L6dmp/PJX9GOt+5s9M8jIvsyN/CxWbXsfd6euZTp7WdewRa0uJCU98d5jUL0WdWs2ZsfRLylUF5KY8hvbj6zU9Ne2aoCbozcrt73HjfwsMrIv8/Wej7XGfa3zeNbtnkbCxZMUFRVRcCuPuMSDJF35C4Bdx9ZqLmGrm1phoG+I/mO8wFREpQyYjY0NAPHx8Vrt8+bNIyUlBQ8Pj8eeo6ioiKKiIry8vB97rIp4tdM7pGelcC3rEsH9V7Ji20T6T7NhwIx6LNs8nvybxTcERnT/mMycK7z2US1GL3ClRWPPUp8kWw8vx8nOnQ4temNtYav5z6G+K51d/dh2ePljrbmL+1DGL+nE4FkNuV14k/cHrivTfg1qN6N3h0De/rQtfUOs2H28eL+JA9Zy5M+t9A2xZNmWYHzbBmjtN3nwem4VFjB4VkPGL+lEV4/hWv09243ide/3CPvOn1en1mTIrEZ8vWcGhYW3ADiZsJexizzo/UF13vm8Az6tB9PVfViFjt3Ly1vznCkPvaLy7vEPUKvVtG7dmpSUFMLCwrCzs2Pjxo1ER0eTlJTE4cOHadeundY+3t7evPXWW+V+D3ZsAzzw/l9L7NkY3lvR9YndRayKUtPPM2y2Peun/E1tq0dfEj6LrBpAm4Hl369SnsH09fWJjIzExcWFwMBA/P39sbGxYezYsRgYGGhucCipUF3IzVv53Lp9Eyi+O3fzVn65X8HEv1ulvMkB0KxZM/bt26fVNmzYMFq0aIGpqani8+85vo6w7/w1v7/8QfGc6yYnYmvdRPH5xbOhUl4ilqZ58+a0b9+e1atXa9pCQkJYvXo1aWlpmJubY2pqikqlwtHRsUxjPuoSUQh4xi4RS5KTk0N8fLzOPzDPmDGD5ORkCgoKuHbtGsnJyWUOlxBKq7SXiA8yNzensFD+aFVULVXmDCZEVSQBE0JBEjAhFCQBE0JBEjAhFCQBE0JBEjAhFCQBE0JBEjAhFCQBE0JBErAK+iJ6MsFLOvNF9GSguOSY/zxnYs+qAPguZj7jFndk9voh3C68RV5BDm9/1p4564eWOub+UxsZt7gj09b2I/9mLqnp5/GbXpeoA4sA+DQqiP7TahN9ZJVmn/DINx9a2Tc5LZ7gpV4EL+lMclrxB1j95zkz/9viTwqs2zWd/37Wgf9+1oETZ37UrGNoaBNOxO8pcUy1Wk145JuMX9KJTQc/BeCrXdMYs8CNv6+cJjE1jnc+92T8kk7M/9afoqIiLl5NYMyC51m948NS17rp4KeMX9KJ8O8CUKvVxJ6NYcisxsSc/FazzZnkE3SbqKcpKffhl70Yt7hjqWPGJf7EuMUdeX9Fd02ZuT4hlpr/b/M2jOTtT9sxYak3e39dD8APP33O69Ntn0jdSglYBSSmxnEjP4sFQfvJyr3G+dTfAfDzmoiboxcZOVc4eXYfC8cexL6eKz/F/YCpsTlThmwodcxCdSHbDq8gPFBFZ9f+7Dxa/IkBD6du9Ov0DlBcvHTUy/O19pvgt4qaNWx1xrtr7a6P+GBwBJMGfc3anVMBsKxem4kDisfv2mY4n779M6Fvbufr3cVVgDu79qd7m5GljvnLX9E0rO3MJ0EHOBG/m6zcdADG9AqnYR1nGtZ2ZtFbh/gk6AAA8cnHsLNpSlCfhaWOmZWbTmzCPj4JOkC9Wo4cPV1cy7GrxzC8nx+g2W7zz0twsrv3B98z39ha6pgAEXtDmT1qJ8O7TyMypvixs7dtRUDP2ZptJg3+hvDAGP6v9WAA+r74Fm2cfR86bllJwCogLvEgbZp1B8DdqRu/JR7Q6o//+xhuDt53+rvy54VH12i/ePUMTWxdMNA3wN2pG3EPjAlQy6JeCXs+XE5uBjaW9alTsxGZN9J0+uvdqdRkZGgMdwoBPUrc+YN43Dn+Vg6dOZ30i1b//fUajQyNqW3Z8JFjnk76Bdc7xYc8muk+pgDnU3+ntmUDTO8UzHmUglt5GBlUw7RadVyaeHLm4gmdbfT09Ji3YTghX/bmcsaFMo1bHlXmr+krk+zcdLb+vIzvD3xCTl4mXm6vU8viXvGXG/mZmJlYAFDdxJKc/MwyjflT3CYSLv4KFNf0exISLp5gwlJvAJIu/1Hqdl/tmkav9mPKNGZ2bjoLvx9DNUMTMrJTGdptqs42h37fzOrtH2Bn44RF9VqPHjMvna0/L+WnuE3cvJ2PQz3dT61HHVhIQM/ZZS6ll52bwR8XftYcf/adM+39xvQOx8LMmrjEgyzfMoGpwzeWaeyykjNYBdQws2ZEj48JD4zB33cmNcystfqrm1iSm58FQG5+FuYmVmUas2PLfoQHxjDzja1YPDBmRTk18CA8MIbwwBicG7UtcZuDv20iK/ea5hKpLGsd/9oKwgNjeOXFt6hhqrtWT5dXWPluHDZWDTj8x8Mv4wBqmFrT2zOI8MAYgv1W6TymyWlnMDOxwLK6TZnWWLzOmrRo4qk5/jo1G+lsc/dxbmnfkfTs1DKPXVYSsApoad+R387tB4qL4rS6UyT0rmYNX+DUueKbHSfO7KF54/Y6Y1y9flHrdzsbJy5ePaN5c9/ygTHLIis3nYJbeVptFma1yMxJIzMnrcQgnLt0is2HFvP2q4tLHLOw8DYZ2Ze12lo26cipxOLj//PCzzrBvXm7QPOzmbEFxka6JR4ePH7nRm3588JhoOTHNDH1N+L/Psrklb4kppxiYdR/dMbMyLnC7TsVpQCMjUwpKlJTcCuPxNQ4GtVprrPPjTsvhH9fOY25qZVO/+OSgFWAvW1LDA2MmLDUG0MDI5rYumj11zSvQyuHzoxb3JGzl07i6dJXZ4y5G4ajVqs1vxvoG9CtzQgmLPNi59HVmtLX9/vmx1lEqubz/f4FrNv9sU7/9/sXcCZZ+33GkK4hzFjnx4x1fgzuMkVnnxXbJpKRc5nJK3swdXUfnf7UjPM6d/7aPteTs5dOErzUi+catdM52x77a0fxnculXmTkXNa8X7vf7PVDtH63MLOmeeP2BC/14uylk7zg/JJWf6dW/VgQtJ/Zo3ZgX8+Vcf2W6Yy5fHMwmQ98IYWf10QmrezO8i0T8CuhuOuc9UMYt7gjCza+SUDPOTr9j0veg1XQ/XehAEyNzdmwbw52Nk64OXox0Od9BvrcKxKaV5DDnIihODd8AbVaTeO6LdDX13596+zan86u98rOGegbcvbSSaIOLKJfp3cY0mUKQx4ISXjkm5oqxTfyr9OicQet/oZ1nAkPjNFqM9A3ZP63/kwcsJo5o3bqHNv+Uxv5Ke4H3J26ce5SLD6tB2n16+vrM8FvlVabuakVq3d+SG2rhni27INnS+2wXryawKroSXR29eP6jau4OmiXRAd4teN/ebXjvTLYRoYmHP5jK/a2rbTuJN5/PB9+2QvrOzd/zEwssLG00xqzpf2LmruZd2XduMoX0ZMJ6DmbGW9s0VnHDz99zpnkY6V+uUZ5VKmiN0qQojeiLJ75ojdCVEUSMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkESMCEUJAETQkGVOmBqtZqwsDCcnJwwMTHBzc0NlUqFs7Mzo0ePftrLE+KRKvXnwQICAoiKiiIkJAQPDw8OHTrEoEGDSEtLIzg4WNG5V257nyN/biUt829MjM1p99zLvPny3Cf2UX7x71BpAxYREcGaNWuIiYnBy6v4w3k+Pj6cOHGCqKgone9qftL09Q2YNOhrmti2JCcvk3kbhjP/25HM8N+s6Lzi2VJpLxFDQ0Px9fXVhOuupk2bYmRkhKurKxkZGfTq1YtmzZrh5uZG9+7dSUh4/GKRAAEvhdLUrjWGBkZYmdfm1Y7vcKqM1YyEuKtSBiw5OZm4uDj8/Px0+pKSknBxccHY2Bg9PT3GjRtHfHw8sbGx9OrVC39/3VoWT8KvCT/iUN9NkbHFs6vSBgzA1la7Ym1eXh4qlUpzeWhlZUXXrl01/Z6eniQmJpZpDj09PfT09FCpYh657YFT37P18DKCXllUxiMQzxqVKkbznCmPShkwG5vi2nfx8fFa7fPmzSMlJQUPD48S91u4cCF9+/Z9omtRxUbyycZRfDxyM04NlH3fJ549lfImh4ODA66uroSGhmJtbY2dnR0bN24kOjoaoMSATZ8+nYSEBPbu3VumOe7W+nlY0ZsdR1ezYssEPvbfQkv7Fyt2MOKZ4OXlTdHS8teHqpRnMH19fSIjI3FxcSEwMBB/f39sbGwYO3YsBgYGuLpql1WeOXMmW7duZceOHZiZmT2RNWw6+Ckrtr7L7FE7JVyiwqpU2bZhw4YRGxvLqVOnNG3Tp08nOjqanTt3YmVlVe4xSzuDdZuoh4G+YfGXItxny6yccs8hqr6Klm2rlJeIpTl27Bjt298rQ/37778zbdo0HB0d8fb21rSfPHnysefaPb/KvO6ISqzKBCwnJ4f4+HiCgoI0bS4uLlShE7D4F6oyATM3N6ewsPBpL0OIcqmUNzmEeFZIwIRQkARMCAVJwIRQkARMCAVJwIRQkARMCAVVmX8HU0qNOk97BaIqqOjzpEr9LaIQVY1cIgqhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAqSgAmhIAmYEAr6f71EINA3WBvJAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# specify the ansatz\n", - "ansatz = RealAmplitudes(num_qubits, reps=1)\n", - "ansatz.draw(output=\"mpl\")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "anonymous-illness", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0 * ZZZ\n" - ] - } - ], - "source": [ - "# specify the observable\n", - "observable = PauliSumOp.from_list([(\"Z\" * num_qubits, 1)])\n", - "print(observable)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "novel-ownership", - "metadata": {}, - "outputs": [], - "source": [ - "# define two layer QNN\n", - "qnn3 = TwoLayerQNN(\n", - " num_qubits, feature_map=fm, ansatz=ansatz, observable=observable, quantum_instance=qi_sv\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "patient-protocol", - "metadata": {}, - "outputs": [], - "source": [ - "# define (random) input and weights\n", - "input3 = algorithm_globals.random.random(qnn3.num_inputs)\n", - "weights3 = algorithm_globals.random.random(qnn3.num_weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "sweet-complement", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.18276559]])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN forward pass\n", - "qnn3.forward(input3, weights3)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "golden-worcester", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(None,\n", - " array([[[ 0.10231208, 0.10656571, 0.41017902, 0.16528909,\n", - " -0.27780262, 0.41365763]]]))" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN backward pass\n", - "qnn3.backward(input3, weights3)" - ] - }, { "cell_type": "markdown", "id": "according-watch", "metadata": {}, "source": [ - "## 4. `CircuitQNN`\n", + "## 4. `SamplerQNN`\n", "\n", - "The `CircuitQNN` is based on a (parametrized) `QuantumCircuit`.\n", - "This can take input as well as weight parameters and produces samples from the measurement. The samples can either be interpreted as probabilities of measuring the integer index corresponding to a bitstring or directly as a batch of binary output. In the case of probabilities, gradients can be estimated efficiently and the `CircuitQNN` provides a backward pass as well. In case of samples, differentiation is not possible and the backward pass returns `(None, None)`.\n", + "The `SamplerQNN` is based on a (parametrized) `QuantumCircuit`.\n", + "This can take input as well as weight parameters and produces samples from the measurement. The samples are interpreted as probabilities of measuring the integer index corresponding to a bitstring. Gradients can be estimated efficiently and the `SamplerQNN` provides a backward pass as well.\n", "\n", - "Further, the `CircuitQNN` allows to specify an `interpret` function to post-process the samples. This is expected to take a measured integer (from a bitstring) and map it to a new index, i.e. non-negative integer. In this case, the output shape needs to be provided and the probabilities are aggregated accordingly.\n", + "Further, the `SamplerQNN` allows to specify an `interpret` function to post-process the samples. This is expected to take a measured integer (from a bitstring) and map it to a new index, i.e. non-negative integer. In this case, the output shape needs to be provided and the probabilities are aggregated accordingly.\n", "\n", - "A `CircuitQNN` can be configured to return sparse as well as dense probability vectors. If no `interpret` function is used, the dimension of the probability vector scales exponentially with the number of qubits and a sparse recommendation is usually recommended. In case of an `interpret` function it depends on the expected outcome. If, for instance, an index is mapped to the parity of the corresponding bitstring, i.e., to 0 or 1, a dense output makes sense and the result will be a probability vector of length 2." + "If no `interpret` function is used, the dimension of the probability vector scales exponentially with the number of qubits. In case of an `interpret` function it depends on the expected outcome. If, for instance, an index is mapped to the parity of the corresponding bitstring, i.e., to 0 or 1, a dense output makes sense and the result will be a probability vector of length 2." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "id": "posted-shoot", "metadata": {}, "outputs": [], "source": [ - "from qiskit_machine_learning.neural_networks import CircuitQNN" + "from qiskit.primitives import Sampler\n", + "from qiskit_machine_learning.neural_networks import SamplerQNN" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 15, "id": "acceptable-standing", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 24, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "qc = RealAmplitudes(num_qubits, entanglement=\"linear\", reps=1)\n", + "qc = RealAmplitudes(2, entanglement=\"linear\", reps=1)\n", "qc.draw(output=\"mpl\")" ] }, - { - "cell_type": "markdown", - "id": "extra-ebony", - "metadata": {}, - "source": [ - "### 4.1 Output: sparse integer probabilities" - ] - }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 16, "id": "indoor-disorder", "metadata": {}, "outputs": [], "source": [ - "# specify circuit QNN\n", - "qnn4 = CircuitQNN(qc, [], qc.parameters, sparse=True, quantum_instance=qi_qasm)" + "# specify sampler-based QNN\n", + "qnn4 = SamplerQNN(sampler=Sampler(), circuit=qc, input_params=[], weight_params=qc.parameters)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 17, "id": "beneficial-summary", "metadata": {}, "outputs": [], @@ -568,321 +386,64 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 18, "id": "jewish-elements", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[0.3, 0.1, 0. , 0. , 0.3, 0. , 0.1, 0.2]])" + "array([[0.37369597, 0.00083983, 0.42874976, 0.19671444]])" ] }, - "execution_count": 27, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# QNN forward pass\n", - "qnn4.forward(input4, weights4).todense() # returned as a sparse matrix" + "qnn4.forward(input4, weights4)" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "id": "entitled-reaction", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "text/plain": [ - "(None, )" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN backward pass, returns a tuple of sparse matrices\n", - "qnn4.backward(input4, weights4)" - ] - }, - { - "cell_type": "markdown", - "id": "happy-glossary", - "metadata": {}, - "source": [ - "### 4.2 Output: dense parity probabilities" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "potential-database", - "metadata": {}, - "outputs": [], - "source": [ - "# specify circuit QNN\n", - "parity = lambda x: \"{:b}\".format(x).count(\"1\") % 2\n", - "output_shape = 2 # this is required in case of a callable with dense output\n", - "qnn6 = CircuitQNN(\n", - " qc,\n", - " [],\n", - " qc.parameters,\n", - " sparse=False,\n", - " interpret=parity,\n", - " output_shape=output_shape,\n", - " quantum_instance=qi_qasm,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "pending-series", - "metadata": {}, - "outputs": [], - "source": [ - "# define (random) input and weights\n", - "input6 = algorithm_globals.random.random(qnn6.num_inputs)\n", - "weights6 = algorithm_globals.random.random(qnn6.num_weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "driven-stomach", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[0.6, 0.4]])" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN forward pass\n", - "qnn6.forward(input6, weights6)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "lightweight-federation", - "metadata": { - "scrolled": true - }, "outputs": [ { "data": { "text/plain": [ "(None,\n", - " array([[[-3.00000000e-01, 3.50000000e-01, -2.50000000e-01,\n", - " -2.50000000e-01, 5.55111512e-17, -4.00000000e-01],\n", - " [ 3.00000000e-01, -3.50000000e-01, 2.50000000e-01,\n", - " 2.50000000e-01, -4.16333634e-17, 4.00000000e-01]]]))" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN backward pass\n", - "qnn6.backward(input6, weights6)" - ] - }, - { - "cell_type": "markdown", - "id": "limited-blast", - "metadata": {}, - "source": [ - "### 4.3 Output: Samples" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "apart-algebra", - "metadata": {}, - "outputs": [], - "source": [ - "# specify circuit QNN\n", - "qnn7 = CircuitQNN(qc, [], qc.parameters, sampling=True, quantum_instance=qi_qasm)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "laughing-techno", - "metadata": {}, - "outputs": [], - "source": [ - "# define (random) input and weights\n", - "input7 = algorithm_globals.random.random(qnn7.num_inputs)\n", - "weights7 = algorithm_globals.random.random(qnn7.num_weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "everyday-norwegian", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[[7.],\n", - " [1.],\n", - " [0.],\n", - " [7.],\n", - " [0.],\n", - " [7.],\n", - " [0.],\n", - " [0.],\n", - " [0.],\n", - " [5.]]])" + " array([[[-0.16667913, -0.42400024, 0.0177156 , -0.40027747],\n", + " [ 0.00403062, -0.0110119 , -0.0177156 , 0.0128533 ],\n", + " [-0.22984019, 0.39671924, -0.29041568, 0.40027747],\n", + " [ 0.3924887 , 0.0382929 , 0.29041568, -0.0128533 ]]]))" ] }, - "execution_count": 35, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# QNN forward pass, results in samples of measured bit strings mapped to integers\n", - "qnn7.forward(input7, weights7)" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "balanced-korea", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(None, None)" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN backward pass\n", - "qnn7.backward(input7, weights7)" - ] - }, - { - "cell_type": "markdown", - "id": "biological-thunder", - "metadata": {}, - "source": [ - "### 4.4 Output: Parity Samples" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "broke-jonathan", - "metadata": {}, - "outputs": [], - "source": [ - "# specify circuit QNN\n", - "qnn8 = CircuitQNN(qc, [], qc.parameters, sampling=True, interpret=parity, quantum_instance=qi_qasm)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "satisfied-graph", - "metadata": {}, - "outputs": [], - "source": [ - "# define (random) input and weights\n", - "input8 = algorithm_globals.random.random(qnn8.num_inputs)\n", - "weights8 = algorithm_globals.random.random(qnn8.num_weights)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "promotional-trash", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[[1.],\n", - " [0.],\n", - " [0.],\n", - " [1.],\n", - " [0.],\n", - " [1.],\n", - " [0.],\n", - " [1.],\n", - " [0.],\n", - " [0.]]])" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN forward pass, results in samples of measured bit strings\n", - "qnn8.forward(input8, weights8)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "freelance-alfred", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(None, None)" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# QNN backward pass\n", - "qnn8.backward(input8, weights8)" + "# QNN backward pass, returns a tuple of matrices, None for the gradients with respect to input data.\n", + "qnn4.backward(input4, weights4)" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 20, "id": "appointed-shirt", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0.dev0+4749eb5
qiskit-aer0.11.0
qiskit-nature0.5.0
qiskit-finance0.4.0
qiskit-optimization0.5.0
qiskit-machine-learning0.5.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Mar 28 2022 06:16:26
OSDarwin
CPUs2
Memory (Gb)12.0
Thu Sep 15 13:53:44 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Fri Oct 28 15:23:17 2022 GMT Daylight Time
" ], "text/plain": [ "" @@ -910,14 +471,6 @@ "%qiskit_version_table\n", "%qiskit_copyright" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "extensive-prescription", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -936,7 +489,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.7.9" } }, "nbformat": 4, diff --git a/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb b/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb index d71cc33d6..d6ec15cbd 100644 --- a/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb +++ b/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb @@ -13,13 +13,13 @@ "\n", "\n", "1. [Classification](#Classification) \n", - " * Classification with an `OpflowQNN`\n", - " * Classification with a `CircuitQNN`\n", + " * Classification with an `EstimatorQNN`\n", + " * Classification with a `SamplerQNN`\n", " * Variational Quantum Classifier (`VQC`)\n", " \n", " \n", "2. [Regression](#Regression)\n", - " * Regression with an `OpflowQNN`\n", + " * Regression with an `EstimatorQNN`\n", " * Variational Quantum Regressor (`VQR`)" ] }, @@ -30,45 +30,22 @@ "metadata": {}, "outputs": [], "source": [ - "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "\n", + "import numpy as np\n", + "from IPython.display import clear_output\n", "from qiskit import QuantumCircuit\n", - "from qiskit_aer import Aer\n", - "from qiskit.opflow import Z, I, StateFn\n", - "from qiskit.utils import QuantumInstance, algorithm_globals\n", + "from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B\n", "from qiskit.circuit import Parameter\n", "from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap\n", - "from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B\n", + "from qiskit.utils import algorithm_globals\n", "\n", - "from qiskit_machine_learning.neural_networks import TwoLayerQNN, CircuitQNN\n", "from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC\n", "from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor, VQR\n", - "\n", - "from typing import Union\n", - "\n", - "from qiskit_machine_learning.exceptions import QiskitMachineLearningError\n", - "\n", - "from IPython.display import clear_output\n", + "from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN\n", "\n", "algorithm_globals.random_seed = 42" ] }, - { - "cell_type": "code", - "execution_count": 2, - "id": "whole-grain", - "metadata": {}, - "outputs": [], - "source": [ - "quantum_instance = QuantumInstance(\n", - " Aer.get_backend(\"aer_simulator\"),\n", - " shots=1024,\n", - " seed_simulator=algorithm_globals.random_seed,\n", - " seed_transpiler=algorithm_globals.random_seed,\n", - ")" - ] - }, { "cell_type": "markdown", "id": "compact-divide", @@ -81,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "short-pierre", "metadata": { "tags": [ @@ -91,7 +68,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -126,20 +103,57 @@ "id": "religious-history", "metadata": {}, "source": [ - "### Classification with the an `OpflowQNN`\n", + "### Classification with the an `EstimatorQNN`\n", "\n", - "First we show how an `OpflowQNN` can be used for classification within a `NeuralNetworkClassifier`. In this context, the `OpflowQNN` is expected to return one-dimensional output in $[-1, +1]$. This only works for binary classification and we assign the two classes to $\\{-1, +1\\}$. For convenience, we use the `TwoLayerQNN`, which is a special type of `OpflowQNN` defined via a feature map and an ansatz." + "First we show how an `EstimatorQNN` can be used for classification within a `NeuralNetworkClassifier`. In this context, the `EstimatorQNN` is expected to return one-dimensional output in $[-1, +1]$. This only works for binary classification and we assign the two classes to $\\{-1, +1\\}$." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "recognized-musician", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# construct QNN\n", - "opflow_qnn = TwoLayerQNN(num_inputs, quantum_instance=quantum_instance)" + "qc = QuantumCircuit(2)\n", + "feature_map = ZZFeatureMap(2)\n", + "ansatz = RealAmplitudes(2)\n", + "qc.compose(feature_map, inplace=True)\n", + "qc.compose(ansatz, inplace=True)\n", + "qc.draw(output=\"mpl\")" + ] + }, + { + "cell_type": "markdown", + "id": "formed-animal", + "metadata": {}, + "source": [ + "Create a quantum neural network" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "determined-hands", + "metadata": {}, + "outputs": [], + "source": [ + "estimator_qnn = EstimatorQNN(\n", + " circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters\n", + ")" ] }, { @@ -151,7 +165,7 @@ { "data": { "text/plain": [ - "array([[0.1640625]])" + "array([[0.23521988]])" ] }, "execution_count": 5, @@ -161,7 +175,7 @@ ], "source": [ "# QNN maps inputs to [-1, +1]\n", - "opflow_qnn.forward(X[0, :], algorithm_globals.random.random(opflow_qnn.num_weights))" + "estimator_qnn.forward(X[0, :], algorithm_globals.random.random(estimator_qnn.num_weights))" ] }, { @@ -198,8 +212,8 @@ "outputs": [], "source": [ "# construct neural network classifier\n", - "opflow_classifier = NeuralNetworkClassifier(\n", - " opflow_qnn, optimizer=COBYLA(maxiter=60), callback=callback_graph\n", + "estimator_classifier = NeuralNetworkClassifier(\n", + " estimator_qnn, optimizer=COBYLA(maxiter=60), callback=callback_graph\n", ")" ] }, @@ -211,7 +225,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAGDCAYAAAACpSdYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABaiElEQVR4nO3deZxcZZX/8c+p7q7e1/SWdGchOyE7QQERcAdFEUXcl3FBHfXnjDqO2+iogyNuM47OqKgIbiiCuKKALIJsEhIgISEL2XtPet+Xen5/3FudSqeXqu6urqru7/v1qldX3Xvr3lNVnc7pp89zHnPOISIiIiIi0QkkOgARERERkVSiBFpEREREJAZKoEVEREREYqAEWkREREQkBkqgRURERERioARaRERERCQGSqBFZExm9u9m9tNx9j9tZhfH4brxOu8VZnbUzDrNbNN0n3+c677ZzO6cqetFw8xuMLP/SHQcsTCzP5nZ22fLdSaIodPMliYyBhEZmxJokTnMzN5hZjvMrNvM6s3sO2ZWFO3znXNnOefum2IMpyVy03HeMXwN+KBzLs85tz0O58fMlpiZM7P08Dbn3M+ccy+Nx/XmEufcpc65G6dyDv97/m/RXiea46fKzO4zs3ePiCHPOXcgntcVkclTAi0yR5nZR4FrgX8BCoFzgcXAXWYWTGRscbQYeDrRQcjcEfmLlIjMHkqgReYgMysAPg98yDn3Z+fcgHPuEHAVsAR4S8ThWWb2SzPrMLNtZrYh4jyHzOzF/v2AmX3CzJ41sxNmdrOZlUQce4GZPWRmrX4ZxTvM7GrgzcDH/T9Z/z7yvGa2wMx6Rpxnk5kdN7MM//E7zWy3mbWY2R1mtniU15tpZp1AGvCkmT3rb3dmtjziuOHRcDO72MyOmdlHzazRzOrM7B8ijs02s6+b2WEzazOzv5lZNnC/f0ir/5rOGzmKaWbnm9lj/vMeM7PzI/bdZ2ZfNLMH/ff8TjMrHeNz3G1ml0U8TjezJjPb7D/+lf+XhTYzu9/MzhrjPKeNska+N/779zUzO2JmDWb2Xf+1jnauZWZ2j/89cNzMfhb5Vw0z22xm2/3X9iv/eyv8nheb2R/819Di368e8d68OzJmP64WMztoZpeOeE0H/OscNK+M5kzgu8B5/mfTOsZruM/M3j3W8eO9HxHfN/9qZvXAj8Z7XWZ2DfB84Nv+Nb49yvtfaGY/9p9/2Mw+Y2aBaN4HEYkPJdAic9P5QBbw68iNzrlO4HbgJRGbLwd+BZQAPwd+Y37yOsKHgFcDFwELgBbgfwHMS2r/BHwLKAM2Ak84564DfgZ8xf+T9StHxFMLPAy8NmLzm4BbnHMDZnY58CngNf55HwBuGhmYc67POZfnP9zgnFs21hszQiXe6HwV8C7gf82s2N/3NeBsvPeyBPg4EAIu9PcX+a/p4cgTmvfLwB+B/wHmAd8A/mhm80a8xn8AyoEg8LEx4rsJeGPE45cBx51z2/zHfwJW+OfZhvdeT8aXgZV4n9tyvPfjs2Mca8B/4n0PnAksBP4dwLy/bNwG3ID3nt0EXBHx3ADwI7y/FCwCeoBvjxPXc4E9QCnwFeCH5snFe38vdc7l431GTzjndgPvAx72P5ui8V70OMdP9H5U+q9vMXD1eK/LOfdpvO/bcGnRB0cJ5Vt434dL8f59vQ3v+2Pc92G81yYiU6MEWmRuKsVLtAZH2Vfn7w973Dl3i3NuAC/Zy8Ir9xjpfcCnnXPHnHN9eEnTleb9CftNwF+cczf5o90nnHNPRBnrz/GTRD8peIO/LXzN/3TO7fZfy5eAjTbKKPQkDQBf8GO+HegEVvmjf+8EPuycq3HODTnnHvJf90ReAexzzv3EOTfonLsJeAaI/OXhR865vc65HuBmvERtND8HXmVmOf7jNxHxC4Rz7nrnXEfE57HBzAqjffEw/J5fDfyzc67ZOdeB9z6/YbTjnXP7nXN3+b+0NOF9z1zk7z4XSAf+x39Pfw38PeK5J5xztzrnuv3rXBPx3NEcds593zk3BNwIzAcq/H0hYK2ZZTvn6pxz01K6E+X7EQI+578HPZN4XZHXS/PP/Un/szwEfB14a8Rh470PIhIHSqBF5qbjQKmNXp85398fdjR8xzkXAo7hjS6OtBi4zbwSjVZgNzCE9x/5QuDZScZ6K96f0Ofjje6G8Ebswtf8ZsQ1m/FGQKsmea2RToz4JaMbyMP7BSOLyb2mBcDhEdsOc2rM9aNc8zTOuf147/Mr/ST6Vfi/XJhZmpl92bySmnbgkP+0UctBxlEG5ACPR7zPf/a3n8bMKszsF2ZW41/3pxHXXADUOOdcxFOORjw3x8y+55cptOOVwxT5SeRoht8n51y3fzfPOdcFvB7vF6w6M/ujma2O8XWPJZr3o8k51zuF1xWpFMjg1O+ZMb9fIt+HGF6TiMRICbTI3PQw0IdX+jDMzPKAS4G7IzYvjNgfAKqB2lHOeRTvT+ZFEbcs51yNv2+ssgk3xnZvp3MtwJ14CdGbgF9EJGBHgfeOuGa2c+6h8c4ZoRsvGQqrjPJ5x4FeRn9N474evPdu5Aj5IqAmymuPFC7juBzY5SfV4L1XlwMvxvvz/xJ/+2h/2u8i4n0ws8j34TheycFZEe9xYURJzEhfwnsP1jnnCvDq6cPXrAOqRpQXLIy4/1FgFfBc/7nhcpiYyxGcc3c4516C9wvhM8D3w7tiPdWIx9G8HyOfM9HrGi+m43h/CYn8npnK94uITAMl0CJzkHOuDW8S4bfM7BIzyzCzJXjlAseAn0QcfraZvcYfrf4nvMT7kVFO+13gmnD5hJmV+TXK4NXevtjMrjJvots8M9vo72vAq+0cz8/x6j6v5GT5RvianzR/cpw/2ep1E78Dw54A3uSP1l5ClH9W90firwe+Yd5ExzTzJgtmAk14o+RjvabbgZVm9ib/vXg9sAb4QwxxR/oF8FLg/Zz63uTjfVYn8JLjL41zjieBs8xso5ll4dcsw/Br/T7wX2ZWDmBmVWb2sjHOlY9X6tJmZlV4XV7CHsb7q8QH/dd+OfCcEc/twZuAWQJ8brwXPhZ/FPxyvxa6z48n5O9uAKot+k4zpxw/ifcDJn5dY/4b8Msybsb7t5Xv//v6CN7IvogkiBJokTnKOfcVvAl4XwPagUfxRnRfNKKW97d4o78teHWXr/HroUf6JvA74E4z68BLsp/rX+sI8HK8kbhmvMQ13M3jh8Aa/8/hvxkj3N/hTYard849GfEabsNrxfcL/0/jO/FG0KP1Ybza41a8biBjXX80HwN2AI/hvaZrgYD/J/RrgAf913RKvbhz7gRwGd57cQJv8uFlzrnIspmoOefq8BLT84FfRuz6Md6f+muAXYz+S0/4HHuBLwB/AfYBI/se/yuwH3jEf5//gjeiOprPA5uBNrzJksMTVZ1z/Xh/9XgX3nv+FrxfHMLfb/8NZOONuj6CVxoxGQG8JLMW77O5CO8XDIB78FoZ1ptZNO/5aMfH8n7AxK/rm3jzBVrM7H9Gef6H8P5KcADvs/k53i9wIpIgdmopmohI9MzsCPAW59z9Ex4sMgozexT4rnPuR4mORUQkWhqBFpFJMbMyvIlThxIciqQQM7vIzCr9Eo63A+uZ/EiziEhCaIUkEYmZmZ0D3AV8yy/PEInWKrya3ly8koQr/TIUEZGUEbcSDjO7Hq/Or9E5t3aU/Rfj1VYe9Df92jn3hbgEIyIiIiIyTeI5An0D3kpLPx7nmAecc5eNs19EREREJKnErQban1TUHK/zi4iIiIgkQqJroM8zsyfxWg19bKylVs3sarylU8nNzT179erpWlBKRERERGR0jz/++HHn3GkrryYygd4GLHbOdZrZy/H6r64Y7UDn3HXAdQBbtmxxW7dunbEgRURERGRuMrPDo21PWBs751y7c67Tv387kGFmpYmKR0REREQkGglLoP0+oObff44fy4lExSMiIiIiEo24lXCY2U3AxUCpmR0DPgdkADjnvgtcCbzfzAaBHuANTssiioiIiEiSi1sC7Zx74wT7v43X5k5EREREJGVoKW8RERERkRgogRYRERERiYESaBERERGRGCiBFhERERGJgRJoEREREZEYKIEWEREREYmBEmgRERERkRgogZZxPVPfjta3ERERETlJCbSM6d49jVzy3w/w0LNaYV1EREQkTAm0jOn6vx0E4NCJrgRHIiIiIpI8lEDLqPY3dvDAvuMANLT1JjgaERERkeSRnugAJDnd8NAhgukBstID1LcrgRYREREJ0wi0nKatZ4BbH6/hVRsWcEZpLnUagRYREREZpgRaTvOrrUfpGRjiHecvoaIgiwaNQIuIiIgMUwItpxgKOW58+BDPWVLC2qpCKguzqJ/GEeie/iEalZCLiIhIClMCLae4e3cDR5t7eMfzlgBQUZBFe+8gPf1D03L+/757L1f830PTci4RERGRRFACLae44aFDzC/M4qVrKgCYX5gFMG0TCfc3dFLb1sNQSIuziIiISGpSAi3D9tR38NCzJ3jreYtJT/O+NSoL/AR6mso4att6cc6bqCgiIiKSipRAy7AbHjpEZnqAN56zaHhbhT8CPV0TCevaegBo7uqflvOJiIiIzDQl0AJAa3c/t20/xhWbqijODQ5vHx6BnoYEurt/kNZub+S5pVsJtIiIiKQmJdACwC8eO0rvQIi3n7/klO25menkZ6ZPSwlHbevJc2gEWkRERFKVEmhhcCjETx4+zLlLSzhzfsFp+yumqZVduHwDoEUJtIiIiKQoJdDCX3Y3UNPawzvOP2PU/ZUFWdNSwlEXOQKtEg4RERFJUUqghR89eIiqomxe4reuG2m6ViOs9Uegg+kBjUCLiIhIylICPcc9XdvGowebefv5i0kL2KjHVBZm0tjRN+XezXWtvZTlZ1KWl0lzl9rYiYiISGpSAj3H3fjQIbIz0nj9lkVjHlNZmM1QyHGis29K16pt62FBYRbFuRnqwiEiIiIpSwl0ggwMhRK+mEhzVz+/eaKWKzZXUZiTMeZx09XKrra1h/mF2RTnBJVAi4iISMpSAj3DuvsHueHBg1z81fvY/MW7+Pzvn6a9NzGJ9E1/P0L/YIh3jGhdN9J0rEbonKOurZf5RVmU5AZVAy0iIiIpKz3RAcwVLV393PjwIW586BAt3QOcs6SY85fN44aHDvH7J+v45KWrec3mKsxGr0OebgNDIX76yGEuWF7Kyor8cY+tKMwEprYaYXvPIN39Q1QVZeOc+kCLiIhI6lICHWc1rT384IED/OLvR+kZGOLFZ5bzvouWsWVJCQBvO28J//bbnXz0V09y09+P8IXL17Jmwem9mKfbHU/XU9fWyxcvXzvhsaW5maQHjLopjEDXtHodOOYXZtPdP0R77yADQyEy0vRHEBEREUktSqDjZG9DB9/967P87olaAF61cQHvvXAZqypPHe1dV13Ir99/Prc8fowv//kZLvvWA7z13MV85KWrKMweuy55qm548BCLSnJ4weryCY8NBIzy/Mwp1UCHF1GZX5RFc5c3GbG1e4Cy/MxJn1NEREQkEZRAT7M99R189Y5n+MvuRrIz0njreYt59/OXUlWUPeZzAgHjqnMW8rKzKvn6XXv4ySOH+cNTdXzi0tW8dnM1gTHay03WjmNtbD3cwmdeceaYretGqiicWi/oWn/0ekFhNrX+aHRLd78SaBEREUk5cfv7uZldb2aNZrZzguPOMbNBM7syXrHMpP9303YeO9TCP714BQ994oV87pVnjZs8RyrMyeALl6/ldx+8gMXzcviXW57iyu8+xM6atmmL70BTJx+8aRv5mem8bsvCqJ9XWTC15bzrWntIDxhl+ZmU5AQB1UGLiIhIaopnAeoNwCXjHWBmacC1wJ1xjGPGtHUPsKehg6svXMo/vXglxbnBSZ1nbVUht7zvfL72ug0cae7mVd/+G1+/cw+DQ6Epxbf1UDOv+c5DdPQOcuO7nhNTiUhlYRYN7ZPvA13X1ktFQRZpARt+X9SJQ0RERFJR3BJo59z9QPMEh30IuBVojFccM2n70RYANi0qmvK5AgHjyrOrufujF/OazdV86579vOkHj056FPgPT9Xyph88SnFOkNv+8Xw2LyqO6fmVBVl09g3S2Tc4qevXtPawoMhrh1fiJ9DN6gUtIiIiKShhLRDMrAq4AvhOomKYbtuPtBIwWF9dNG3nLMzO4Guv28B/vX4DO2vauPSb93PvM9H/vuGc47t/fZYP/nw766u8CYuL5+XGHEdl4dR6Qde1eYuoABT5i7a0dms5bxEREUk9iewh9t/AvzrnJqxLMLOrzWyrmW1tamqKf2STtP1oKysr8snLnP65mVdsqub3H7qAioIs/uGGx/jP23czMEFJx+BQiM/8Zidf/tMzvGL9fH767udOuqykwl9MZTITCUMhR72/iApAZnoaeZnpqoEWERGRlJTIBHoL8AszOwRcCfyfmb16tAOdc9c557Y457aUlZXNYIjRC4Uc24+0sHlxbKURsVhWlsdvPvA83vzcRXzv/gNc9b2HOdrcPeqxXX2DXP2Tx/nZo0d470VL+dYbNpGVkTbpa4dXI5xML+jjXX0MDLlTJlMW52aoBlpERERSUsISaOfcGc65Jc65JcAtwD86536TqHim6sDxTjp6B9m0sCiu18nKSOOaK9bx7TdtYn9DJ6/4nwe44+n6U45pbO/l9dc9zH17GvmPV6/lk5eeOeVWeOESjsmMQNe2es8Jl3AAFOcEVQMtIiIiKSlufaDN7CbgYqDUzI4BnwMyAJxz343XdRNl25FWADbFODlvsi5bv4B1VYV88Ofbee9PHucd5y/hky9fzeET3fzDjx6jpbufH779nKgWSolGVkYahdkZk6qBrhtehTBreFtxTlAj0CIiIpKS4pZAO+feGMOx74hXHDNl+5EWCrMzWFoa+wS9yVo8L5db3n8e1/5pD9c/eJBHDzZzrKWbrIw0bn7veaytKpzW61UWZE1qNcLhRVQiSjhKcoMcON45bbGJiIiIzJRE1kDPKtuPtLJxYdG0rxo4kcz0ND77yjVc99azqWnpZn5hFr/5wPOmPXmGya9GWNfaQ1ZGgOKck32nvRFodeEQERGR1KOlvKdBZ98gexo6uGRtZcJieOlZlTy4bB6Z6WkE0+Pze9H8giyeqWuP+Xl1bb0sKMzG7OQvFyW5GXT2DdI3OERm+uQnN4qIiIjMNI1AT4Mnj7biHDEvTjLd8rMy4pY8gzcCfbyzL+YVEWtae4Zb2IWF2+mpF7SIiIikGiXQ02D7EW8Fwg1x7sCRaJUFWYQcNHXGtqR35CIqYSU5/nLe6sQhIiIiKUYJ9DTYdqSVFeV5FGZnTHxwCqsszARi6wU9MBSisaPvlAmEcHIEWoupiIiISKpRAj1FznkLqGxaVJToUOJueDXCGBLohvZenIMFhaeWcJT4CbQmEoqIiEiqUQI9RYdPdNPSPTBj/Z8TKbwaYSyt7IYXURkxAl3kd+TQYioiIiKSapRAT9E2v/450RMIZ0JJbpBgWiCmBLquzVtEZeQIdHG4BlolHCIiIpJilEBP0fYjreRlprO8PC/RocSdmVFekBlTCcdYI9AZaQHys9JVAy0iIiIpRwn0FG0/2sKGhYWkzfACKokyvzC21Qjr2nooyEonL/P0luMluUF14RAREZGUowR6Crr7B9ld1zEnyjfCKgqyaGiPvo1dbWvvaR04wopzghqBFhERkZSjBHoKdhxrYyjk5kQHjrDKgizq23pxzkV1fG1rD/NH1D+HleQGtZCKiIiIpBwl0FOw/WgrABsXzp0R6MrCLHoGhmjvGYzq+Lq2Ho1Ai4iIyKyiBHoKth1u4YzS3OGexnNBRQyt7Hr6h2jpHhgzgS7JzVANtIiIiKQcJdCT5Jxj+9FWNs3y5btHqiyMPoEOt7Abq4SjKCdId/8QvQND0xegiIiISJwpgZ6kmtYemjr65lT9M5xcTCWaVnbDLewKxxqB9ntBaxRaREREUogS6EnadqQVYE6sQBipvCATiG4Euja8iErR6CPQ4cVUVActIiIiqUQJ9CRtP9JCVkaA1ZX5iQ5lRmWmp1GSG4yuhMMfga4cpwsHQEuXOnGIiIhI6lACPUnbjrSyvrqI9LS59xZWFmRFVcJR19ZDaV4mmelpo+4vyc0AoFklHCIiIpJC5l72Nw16B4bYVds2pxZQiVQZ5WqENa09Y5ZvwMkSjhaVcIiIiEgKUQI9CU/XtjMwNLcWUIlU4S+mMpG6tt4xO3AAFGZnYKZJhCIiIpJalEBPwvYjLQBzNoGuLMjiRFc/fYNjt59zzlHXOvYiKgDpaQEKszM0Ai0iIiIpRQn0JGw/0kp1cTbl+WOPrs5mlYVeJ47G9r4xj2nvHaSrf4gFY7SwCyvOCdKs5bxFREQkhSiBnoTtR1rmXPu6SOHVCBvGqYMeXkRlnBpogOIcjUCLiIhIalECHaP6tl5q23rn3AqEkaJZjbC2NbwK4fgj0CW5QfWBFhERkZSiBDpG4frnzYvn7gh0eDXC8SYShlchrBqnBhq8Eg5NIhQREZFUogQ6RtuPthJMD7BmfkGiQ0mYwuwMsjICE5ZwpAeMsvzMcc8VHoF2zk13mCIiIiJxoQQ6RtsOt7CuqpBg+tx968yMyoIs6seZRFjX2ktFQRZpARv3XMW5QfoGQ/QMjN3RQ0RERCSZzN0scBL6B0PsqGmb0/XPYV4v6J4x99e09ozbAzqsxF9MRXXQIiIikiqUQMdgd107fYOhOd2BI2yi1Qjr2nrH7QEdVpzrJdCtamUnIiIiKUIJdAxOTiAsSmwgSaCyIIuG9r5Ra5dDIUd9W++ELezAa2MHGoEWERGR1KEEOgbbj7ZSWZA1YWu2uaCiIIv+wRAto4wcn+jqp38oNOEiKnByBFqdOERERCRVxC2BNrPrzazRzHaOsf9yM3vKzJ4ws61mdkG8Ypku2460zNnlu0ca7gU9Siu74UVUVAMtIiIis1A8R6BvAC4ZZ//dwAbn3EbgncAP4hjLlDV19HG0uYfNqn8Gxl+NMLyISjQ10AXZGQQMrUYoIiIiKSNuCbRz7n6geZz9ne5kAW0ukNSNgJ842gqgEWjfeKsRhhdRiSaBTgsYRTlBmlXCISIiIikioTXQZnaFmT0D/BFvFDppbTvSQnrAWFtVmOhQkkJ5fiZmY5dwZKYHhicITqQ4J4OWLnXhEBERkdSQ0ATaOXebc2418Grgi2MdZ2ZX+3XSW5uammYsvkjbj7Rw1oICsjLSEnL9ZJORFqA0L3PUBLrWb2FnNv4iKmHh1QhFREREUkFSdOHwyz2WmlnpGPuvc85tcc5tKSsrm+HoYHAoxFPH2tT/eQRvNcLRa6AXRNHCLqw4J6guHCIiIpIyEpZAm9ly84cozWwzkAmcSFQ84znS3M3AUEj1zyNUFGSNOomwrrU3plZ/SqBFREQklaTH68RmdhNwMVBqZseAzwEZAM657wKvBd5mZgNAD/B6N9qqHElgaVkeO/79ZYkOI+lUFmay9fCp80QHh0I0dvSyIIoWdmHFuUFaugZwzkVd9iEiIiKSKHFLoJ1zb5xg/7XAtfG6/nRT7fPpKguyaO0eoHdgaPj9aejoI+RgfhQdOMJKcjPoHwrR1T9EXmbcviVFREREpkVS1EBLahqtF3Rda/SLqIQV+4upqBe0iIiIpAIl0DJpo61GWOMn0FUxjUBrNUIRERFJHUqgZdLmj7KYSp2fTMdSwlEcTqA1kVBERERSgBJombRwCUfkCHRdaw/5Wekx1TKXqIRDREREUogSaJm0/KwMcoNpp4xA17b1siCGFnYQMQKtBFpERERSgBJomZKKwlN7Qce6iApAQVY6aQGjtVvLeYuIiEjyUwItU1JZkHVqCUdbb0z1zwBmRnFOhmqgRUREJCUogZYpqSzIoqG9D4DegSGau/pjWkQlrDgnqBpoERERSQlKoGVKwiUcoZA72YEjxhpo8OqgVQMtIiIiqUAJtExJZUEWgyHHia7+4UVUFsRYwgFeJ44WlXCIiIhIClACLVMSuRphzXACPYkSjtwgzV2aRCgiIiLJTwm0TEl4MZW6tt7hEo7KSdRAl+Rm0NLdj3NuWuMTERERmW5KoGVKKiNWI6xr66E0L0hmelrM5ynOCTIUcrT3Dk53iCIiIiLTSgm0TElpXiZpAaOhrZfa1t5J1T8DlORqNUIRERFJDUqgZUrSAkZZXib17b3UtvYMl3TEqji8nLcmEoqIiEiSiyqBNrPFZvZi/362meXHNyxJJeFWdnVtvZNqYQcnl/NWAi0iIiLJbsIE2szeA9wCfM/fVA38Jo4xSYqpLMhkf2MnnX2Dk+rAAV4bO0CdOERERCTpRTMC/QHgeUA7gHNuH1Aez6AktVQWZA134JhsDXRxbgagGmgRERFJftEk0H3OueGsxszSAfUak2EVEXXPky3hyMtMJyPNaFYJh4iIiCS5aBLov5rZp4BsM3sJ8Cvg9/ENS1JJ5MTByZZwmBnFOUGNQIuIiEjSiyaB/gTQBOwA3gvcDnwmnkFJagmvRpgWMMrzJ5dAg9fKrlkJtIiIiCS59IkOcM6FgO/7N5HTVPoJdGVBFmkBm/R5inOC6sIhIiIiSW/CBNrMDjJKzbNzbmlcIpKUE16NcLI9oMOKczPY29A5HSGJiIiIxM2ECTSwJeJ+FvA6oCQ+4Ugqygmmk5+VzvxJduAIUw20iIiIpIJoSjhOjNj032b2OPDZ+IQkqeiLl6/ljNLcKZ2jJNcr4QiFHIEplIKIiIiIxFM0JRybIx4G8Eakoxm5ljnk1ZuqpnyO4pwgIQftvQMU+QuriIiIiCSbaBLhr0fcHwQOAVfFJRqZ00pyw6sR9iuBFhERkaQVTQnHC2YiEJFiP4FWJw4RERFJZmMm0Gb2kfGe6Jz7xvSHI3NZSU54BHogwZGIiIiIjG28Eej8GYtCBK+NHaBOHCIiIpLUxkygnXOfn8lARIrDI9Aq4RAREZEkFk0XjizgXcBZeH2gAXDOvTOOcckclBNMI5geUA20iIiIJLVAFMf8BKgEXgb8FagGOiZ6kpldb2aNZrZzjP1vNrOnzGyHmT1kZhtiCVxmHzOjRIupiIiISJKLJoFe7pz7N6DLOXcj8ArguVE87wbgknH2HwQucs6tA74IXBfFOWWWK84NahKhiIiIJLVoEuhwNtNqZmuBQqB8oic55+4HmsfZ/5BzrsV/+AjeyLbMcSW5GSrhEBERkaQWTQJ9nZkVA/8G/A7YBVw7zXG8C/jTNJ9TUlCxSjhEREQkyUWzEuGPnHNDePXPS6c7ADN7AV4CfcE4x1wNXA2waNGi6Q5BkkhJblBdOERERCSpRTMCfdDMrjOzF5mZTefFzWw98APgcufcibGOc85d55zb4pzbUlZWNp0hSJIpzgnS1jPA4FAo0aGIiIiIjCqaBHo18BfgA8AhM/u2mY05WhwtM1sE/Bp4q3Nu71TPJ7NDcU4GzkFbjyYSioiISHKasITDOdcN3Azc7NdCfxOvnCNtvOeZ2U3AxUCpmR0DPgdk+Of8LvBZYB7wf/7A9qBzbsukX4nMCsW53mIqLd39zMvLTHA0IiIiIqeLpgYaM7sIeD1eW7qtwFUTPcc598YJ9r8beHc015e5o2Q4gdYItIiIiCSnaFYiPARsxxuF/hfnXFe8g5K5a3g5b3XiEBERkSQVzQj0eudce9wjESFiBFoJtIiIiCSpCScRKnmWmTQ8Aq1WdiIiIpKkounCITJjsoNpZGekaQRaREREkpYSaEk6JblBmrs0iVBERESSUzSTCDOB1wJLIo93zn0hfmHJXFacm0GLSjhEREQkSUUzAv1b4HJgEOiKuInERXFOMKFdOI6c6OYjNz9BZ99gwmIQERGR5BVNF45q59wlcY9ExFecE+Roc3dCru2c4+O3PskjB5p55YYFvGBVeULiEBERkeQVzQj0Q2a2Lu6RiPi8GujEjEDfuq2GRw40A7C/oTMhMYiIiEhyi2YE+gLgHWZ2EOgDDHDOufVxjUzmrOKcIO29gwwMhchIm7l5rs1d/Vzzx12cvbiYwye62dvQMWPXFhERkdQRTQJ9adyjEIlQkpsBQGv3AGX5mTN23S/dvpuO3kG+dMU6Pv/7p9nbqBFoEREROV00C6kcBoqAV/q3In+bSFwUh1cjnMFOHA8/e4JbHj/G1RcuZVVlPisr8tnf0IFzbsZiEBERkdQwYQJtZh8GfgaU+7efmtmH4h2YzF0l4dUIZ6gOum9wiE/ftoNFJTl86IUrAFhenkdX/xC1bb0zEoOIiIikjmhKON4FPNc51wVgZtcCDwPfimdgMncNj0DPUAL9nfue5cDxLm5853PIDqYBsLIiH4C9DR1UFWXPSBwiIiKSGqKZoWXAUMTjIX+bSFwUh0egZ6CE49mmTv7v3md51YYFXLSybHj7ivI8QJ04RERE5HTRjED/CHjUzG7zH78a+GHcIpI5ryjHm0QY7xFo5xyfvm0HWRkBPnPZmafsK84NUpqXqU4cIiIicpoJE2jn3DfM7D68dnYA/+Cc2x7XqGROy8pIIzeYRkv3QFyvE+75/KUr1lGen3Xa/pUVeerEISIiIqcZM4E2swLnXLuZlQCH/Ft4X4lzrjn+4clcVZwbjOsIdGTP5zecs3DUY1ZW5POrrUdxzmGmqiURERHxjDcC/XPgMuBxILKXl/mPl8YxLpnjSnKDca2Bjuz5HAiMnhxHduLQREIREREJGzOBds5d5n89Y+bCEfEU58RvBDrc8/kfL17Gqsr8MY8Ld+LYp04cIiIiEiGaPtB3R7NNZDrFawR6tJ7PYwl34tinThwiIiISYbwa6CwgByg1s2JOtq4rAKpmIDaZw7wR6OmfRDhaz+cxY1AnDhERERnFeDXQ7wX+CViAVwcdTqDbgW/HNyyZ64pzMujsG6RvcIjM9PET3WiN1fN5PCsr8tinThwiIiISYcwSDufcN/36548555Y6587wbxucc0qgJa7CqxG2TlMru7buAT7ws22j9nwez4ryPPY3duKcm/hgERERmROiWYkwZGZF4QdmVmxm/xi/kES8Gmjw2s1NVXf/IO+88TEONHXxf28+e9Sez2NZUZFPZ98gtW29U45DREREZodoEuj3OOdaww+ccy3Ae+IWkQhwRmku4LWb6+wbnPR5+gdDvO+n29h+pIX/eeNGLlhRGtPzIztxiIiIiEB0CXSaRawiYWZpQDB+IYnAmfML+MqV63no2RO88bpHaOroi/kcQyHHP9/8BPfvbeLLr1nPJWvnx3wOdeIQERGRkaJJoP8M/NLMXmRmLwJu8reJxNVVWxby/bedzb7GDq787kMcPtEV9XOdc3zmNzv541N1fPrlZ3LVGKsNTiTciWNfo0agRURExBNNAv2vwL3A+/3b3cDH4xmUSNgLV1dw03vOpb1ngNd+5yF2HGuL6nlfvWMPN/39CP948TLec+HUFs1cWZHHXo1Ai4iIiG/CBNo5F3LOfcc5d6V/+55zbmgmghMB2LSomFvefz5ZGWm8/rqHuX9v07jHf++vz/J/9z3Lm567iH952aopX1+dOERERCRSNCsRPs/M7jKzvWZ2wMwOmtmBmQhOJGxZWR6/fv/5LJ6XyztveIzbth8b9bhf/P0I//mnZ7hs/Xy+ePlaIsr3Jy3ciaNOnThERESE6Eo4fgh8A7gAOAfY4n8VmVHlBVn88r3ncs6SEv75l09y3f3PnjIq/KcddXzqth1ctLKMb1y1kbTA1JNnODmRUCsSioiICESXQLc55/7knGt0zp0I3+IemcgoCrIyuOGd5/CK9fP50u3P8B9/3E0o5HhgXxMf/sUTbFpUzHfesplgejTf2tE52cpOddAiIiIy/lLeYfea2VeBXwPDvcScc9vGe5KZXQ9cBjQ659aOsn818CNgM/Bp59zXYglc5q7M9DS+9YZNlOVl8sO/HeRAUyePHmxmaVku17/9HHKC0XxbR0+dOERERCRSNJnGc/2vWyK2OeCFEzzvBuDbwI/H2N8M/D/g1VHEIHKKQMD43CvXUFmYxZf/9AyL5+Xw43c+h8KcjLhcb0W5OnGIiIiIZ8IE2jn3gsmc2Dl3v5ktGWd/I9BoZq+YzPlFzIz3XbSMc5YUs6gkl7L8zLhda2VFHrduq8E5Ny0TE0VERCR1TZhAm9lnR9vunPvC9IczZgxXA1cDLFq0aKYuKyni7MUlcb9GZCeOBUXZcb+eiIiIJK9oZlp1RdyGgEuBJXGM6TTOueucc1ucc1vKyspm8tIigDpxiIiIyEnRlHB8PfKxmX0NuCNuEYkkoXAnjv2NnVy8qjzB0YiIiEgiTabXVw5QPd2BiCSzcCcOjUCLiIhINDXQO/C6bgCkAWXAhPXPZnYTcDFQambHgM8BGQDOue+aWSWwFSgAQmb2T8Aa51x77C9DJP7UiUNERERgnATazM5wzh3E6+UcNgg0OOcGJzqxc+6NE+yvRyPZkkLUiUNERERg/BKOW/yv1zvnDvu3mmiSZ5HZaHlEJw4RERGZu8Yr4QiY2aeAlWb2kZE7nXPfiF9YIslnZUQnDrWyExERmbvGG4F+A17bunQgf5SbyJwS2YlDRERE5q4xR6Cdc3uAa83sKefcn2YwJpGk5HXiCKoTh4iIyBw3YRs7Jc8iJ60oz1cnDhERkTluMn2gReaslRV57G/sxDk38cEiIiIyKymBFomBOnGIiIjIhAm0meWY2b+Z2ff9xyvM7LKJnicyG4U7cezTREIREZE5K5oR6B8BfcB5/uMa4D/iFpFIElvhd+LYp4mEIiIic1Y0CfQy59xXgAEA51w3oGXYZE4qUScOERGROS+aBLrfzLIBB2Bmy/BGpEXmpBXl+SrhEBERmcOiSaD/HfgzsNDMfgbcDXw8nkGJJLMVFXnsb1AnDhERkblqvKW8AXDO3WlmjwPn4pVufNg5dzzukYkkqRUV+XT4nTi0pLeIiMjcE00Xjt8DLwXuc879QcmzzHWztROHc46e/qFEhyEiIpL0oinh+BrwfGCXmd1iZleaWVac4xJJWrO1E8cdTzew5T/uoqWrP9GhiIiIJLVolvL+q3PuH4GlwPeAq4DGeAcmkqxmayeOXXXtdPUPsauuPdGhiIiIJLWoViL0u3C8FngfcA5wYzyDEkl2s7ETR31bD8Cs+8VARERkukVTA30zsBt4IfBtvL7QH4p3YCLJbDZ24ggvT763YXb9YiAiIjLdJuzCAfwQeKNzTrOLRHzhThz17b3ML5wdnThOJtAagRYRERnPmAm0mb3QOXcPkAtcbnbq4oPOuV/HOTaRpLXC78Sxt6Fz1iTQ9REJtHOOkf/mRURExDPeCPRFwD3AK0fZ5wAl0DJnrYzoxHHRyrIERzN1Hb0DdPYNsrAkm6PNPTS091FZqGY7IiIioxkzgXbOfc6/+wXn3MHIfWZ2RlyjEkly4U4c+2ZJvXC4fOPCFWX87NEj7GnoUAItIiIyhmi6cNw6yrZbpjsQkVSzvDyPvY2zo154OIH2R9NnW49rERGR6TReDfRq4Cyg0MxeE7GrANDQlMx5KyvyuW1bzayoFw63sDtrQQGleZnsqVcCLSIiMpbxaqBXAZcBRZxaB90BvCeOMYmkhNnUiaO2tRczKM/PYmVFHntnWY9rERGR6TReDfRvgd+a2XnOuYdnMCaRlDCbOnHUt/VSmpdJMD3Ayop8frX1KKGQIxBI7ZF1ERGReIimBvp9ZlYUfmBmxWZ2ffxCEkkN4U4cT9e2JTiSqatr72WBP2lwZUU+Xf1D1LT2JDgqERGR5BRNAr3eOdcafuCcawE2xS0ikRRRkhvk7MXF/OCBgzR39Sc6nCmpa+0Z7rqxssIbWd83SyZIioiITLdoEuiAmRWHH5hZCdGtYCgy633pinV09A7wxT/sSnQoU1LfdrKOe4U/sq4lvUVEREYXTQL9deBhM/uimX0ReAj4SnzDEkkNqyrzef/Fy7ltew337WlMdDiT0tE7QEff4PAIdGF2BpUFWexVJw4REZFRTZhAO+d+DLwGaPBvr3HO/STegYmkig+8YBnLy/P49G076eobTHQ4MWto93pAz49YOGVFxezpcS0iIjLdohmBBigBupxz3waatBKhyEmZ6Wlc+9p11Lb18NU79iQ6nJjVtoYT6JOdRFZV5LOvoZOhkEtUWCIiIklrwgTazD4H/CvwSX9TBvDTKJ53vZk1mtnOMfabmf2Pme03s6fMbHMsgYskk7MXl/DWcxdz48OH2HakJdHhxKS+7fQR6JUV+fQNhjja3J2osERERJJWNCPQVwCvAroAnHO1QH4Uz7sBuGSc/ZcCK/zb1cB3ojinSNL6+CWrqSzI4hO3PkX/YCjR4UQtvIx3RcGpJRwAe7Wkt4iIyGmiSaD7nXMOcABmlhvNiZ1z9wPN4xxyOfBj53kEKDKz+dGcWyQZ5WWmc80Va9nb0Ml37ns20eFEra6tZ3gRlbCTnTiUQIuIiIwUTQJ9s5l9Dy/BfQ/wF+D703DtKuBoxONj/rbTmNnVZrbVzLY2NTVNw6VF4uOFqyt41YYFfPvefexLkeSzrq33lPIN8H4ZqCrKVis7ERGRUUTTheNrwC3ArcAq4LPOuW/FO7ARMVznnNvinNtSVlY2k5cWidlnX7mG3Mx0/vXWp1JiEl79KAk0eAuqaARaRETkdFF14XDO3eWc+xfn3Mecc3dN07VrgIURj6v9bSIprTQvk89etoZtR1r56SOHEx3OhGrbekZPoCvzOdDUxeBQ6tRzi4iIzIQxE2gz+5v/tcPM2ke5HTSzf5zCtX8HvM3vxnEu0Oacq5vC+USSxhWbqrhwZRlf+fMz1LT2JDqcMXX2DdLRO0hlRAu7sJXl+fQPhTh0Qp04REREIo2ZQDvnLvC/5jvnCkbegC3Ah8d6vpndBDwMrDKzY2b2LjN7n5m9zz/kduAAsB+vpnoqybhIUjEzrnn1Whzwmdt24M3DTT6jtbALW1WpiYQiIiKjSY/mIL9H8wV4nTj+5pzb7pw7YWYXj/Uc59wbxzun39njA9GHKpJaFpbk8LGXruILf9jF756s5fKNo86RTajxEuhlZXmYeQn0y9epQY6IiEhYNAupfBa4EZgHlAI3mNlnAFRyITK+t5+/hI0Li/j873fR3NWf6HBOU9vmlZfMH6WEIzuYxqKSHPapE4eIiMgpoplE+GbgHOfc55xznwPOBd4a37BEZoe0gHHta9fT3jPAl27fnehwThMega4ozBx1/8qKfPaohENEROQU0STQtUDk33czUbcMkaitqszntZur+fPO+qRra1fX1ktpXpDM9LRR96+syOPQ8S76BodmODIREZHkNV4Xjm+Z2f8AbcDTZnaDmf0I2Am0zlB8IrPCc84oobNvkH2NyTWaW9fWQ+Uo9c9hKyvyGQw5Dh7vmsGoREREktt4kwi3+l8fB26L2H5f3KIRmaU2Ly4GYPuRVlZXFiQ4mpPq23qpLs4Zc//K4SW9O5MqbhERkUQaM4F2zt0IYGZZwHJ/837nXO9MBCYymyyZl0NxTgbbDrfwxucsSnQ4w+raennOGSVj7l9alktawFJmWXIREZGZMF4JR7qZfQU4hteF48fAUTP7ipllzFSAIrOBmbFpUTHbjrQkOpRh3f2DtPUMjFvCkZmexuJ5OeypVwItIiISNt4kwq8CJcAZzrmznXObgWVAEfC1GYhNZFbZvKiIZ5u6aOseSHQogDf6DKP3gI60qiKffY1qZSciIhI2XgJ9GfAe59zw0JNzrh14P/DyeAcmMttsWuTXQR9NjlHocAu7yoLTe0BHWlGRz+ETXfQOqBOHiIgIjJ9AOzfK+sPOuSG8FQlFJAYbFhYRMG8iYTIIj0AvKJp4BDrkYL9GoUVERIDxE+hdZva2kRvN7C3AM/ELSWR2ystMZ2VFftLUQde1eqsQVhSMn0CvrMgDSLoWfCIiIokyXhu7DwC/NrN34rWyA9gCZANXxDswkdlo06Ji/vBULaGQIxCwhMZS195LSW6QrIzRF1EJW1KaS0aasadeI9AiIiIwzgi0c67GOfdc4AvAIf/2Befcc5xzWolQZBI2Lyqio3eQZ5sSn4zWt/VOOIEQICMtwNLSPLWyExER8Y03Ag2Ac+4e4J4ZiEVk1gtPJNx2pIUV/iIliVLb2kN18fgTCMNWVOTx5LHW+AYkIiKSIsargRaRaba0NJfC7IykmEhY3947bg/oSCsr8jna3ENX32CcoxIREUl+SqBFZlAgYGxaVJTwiYQ9/UO0dg8wvzC6Eejwkt7qxCEiIqIEWmTGbVpYzL7GTtp7E7egSn17dIuohIU7cexVHbSIiIgSaJGZtnlxEc7Bk0dbExZDuIVdtCUci+flEkwPxJRAO+d4/08f53O/3TmpGEVERJKVEmiRGbZhYRFmsO1wa8JiOLmMd3QlHGkBY3lZHnsboi/h+N2TtfxpZz1/frp+UjGKiIgkKyXQIjOsICuDFeV5CV3SO9YSDvDKOKIdgW7rGeCLf9hFesBoaO+j0b+eiIjIbKAEWiQBNi8qZvuRVkIhl5Dr17b2UJyTMeEiKpFWVuZT19YbVe321+7YQ3NXP595xZkA7Khpm3SsIiIiyUYJtEgCbFpURFvPAAeOdyXk+vVtvVRGWb4RtrLc68Sxb4IyjieOtvLTRw/z9vOX8LotCzFTAi0iIrOLEmiRBNjsL6iyPUHt7OraelkQQ/kGnGxlN14Zx+BQiE/ftoPy/Ew+8pKV5Gams7wsjx3HlECLiMjsoQRaJAGWleWRn5XOtgQtqFLX1hN1B46w6uJssjPSxk2gf/zwYZ6ubeezl51FflYGAOuqCjUCLSIis4oSaJEECASMjQuLEjIC3TswREv3QEwTCMGLecU4Ewnr23r5+p17uGhlGS9fVzm8fW1VIY0dfTRoIqGIiMwSSqBFEmTzomL2NnTQOcPLY9fH2MIu0ory/DFb2X3xD7sYDDm+cPlZmNnw9vXVhQAq4xARkVlDCbRIgmxaVEQoAQuqnOwBHdsINMCqyjyaOvpo6eo/Zfu9exr54446PvTC5Syel3vKvjULCghoIqGIiMwiSqBFEmTTwsRMJKxri20VwkgrRplI2DswxGd/u5NlZbm858Klpz0nJ5jO8vI8diqBFhGRWUIJtEiCFOZksLw8b8YnEsa6CmGk4U4cjSfLOL59z36ONvfwH69eR2b66H2l11YV8pQSaBERmSWUQIsk0CZ/IqFzM7egSn1bL0U5GWQHo19EJWxBYRZ5mens80eg9zd28L37n+U1m6o4b9m8MZ+3rqqQJk0kFBGRWUIJtEgCbV5cTEv3AIdOdM/YNevaeqgsiL18A8DM68Sxp74D5xyf+c1OsjPS+JS/4uBYNJFQRERmEyXQIgm0aVERANsOz1wddF1b76QmEIatqshnb0MHv95WwyMHmvnEpWdSmpc57nPWzC8kYKiMQ0REZoW4JtBmdomZ7TGz/Wb2iVH2Lzazu83sKTO7z8yq4xmPSLJZUZ5PXmY624/OXAJd39bL/KLY65/DVlTk09I9wOd//zSbFhXxhnMWTvic7GCaJhKKiMisEbcE2szSgP8FLgXWAG80szUjDvsa8GPn3HrgC8B/xisekWSU5i+osu1w64xcr3dgiBNd/cyfZAkHwMqKPAC6+oe45tXrCARsgmd41lUV8dSxthmt9xYREYmHeI5APwfY75w74JzrB34BXD7imDXAPf79e0fZLzLrbVpUxDP17XT3x39BlfAkvsm0sAs7c34B6QHjnc9bwpoFBVE/b11VAcc7+2ho75v0tUVERJJBPBPoKuBoxONj/rZITwKv8e9fAeSb2WlT+c3sajPbamZbm5qa4hKsSKJsXlTsL6gS//KGcAu7BVMo4SjNy+Suj1zEJy4df+LgSOvCEwlVxiEiIiku0ZMIPwZcZGbbgYuAGmBo5EHOueucc1ucc1vKyspmOkaRuNq4sAiAbTOwoEp4Ge+pjEADnFGaS1qUpRth4YmEO461TunaIiIiiZYex3PXAJGzi6r9bcOcc7X4I9Bmlge81jnXGseYRJJOcW6QpaW5bJ+BBVVq/VUIp9KFY7Kyg2msKM/XCLSIiKS8eI5APwasMLMzzCwIvAH4XeQBZlZqZuEYPglcH8d4RJLWpkXFM7KgSn1bL4XZGeQE4/m789jWVhWyo6ZdEwlFRCSlxS2Bds4NAh8E7gB2Azc75542sy+Y2av8wy4G9pjZXqACuCZe8Ygks02LijjR1c/R5p64XmeqPaCnan11Icc7+6jXioQiIpLC4joM5Zy7Hbh9xLbPRty/BbglnjGIpILNi4oBrw560bycuF2nrq1nyvXPU7G26uSKhPMLJz+RMRrf++uzlOQGed2WiftUJ8oPHjjAzx89wt0fvQiz2GrKRUQkcRI9iVBE8Hor5wTT4j6RsD7BI9Br5hcQMOK+oEpX3yBfv2sv1/75GQaGQnG91lTcuauBA8e7ZnQpdxERmTol0CJJID0twIbqorhOJOwbHOJ4Z3/cR37Hkx1MY2VFftyX9H5gXxP9gyGOd/Zz357kbH3ZNzjEk0dbAYa/iohIalACLZIkNi8uYnddOz39p3VynBYNbd4CJoks4QCvjGNnTXxXJLxzVwOF2RmU5gW55fGjEz8hAXbWtNM36I2OP6nWfiIiKUUJtEiS2LSwmMGQi1ubt7oEtrCLtK6qkOOd/cOLuky3waEQ9zzTyAtXl/PqjVXcvbuRE53Jt/rh44ebAVhalqsRaBGRFKMEWiRJbFpUBMRvQZVw54tElnBA/Fck3Hq4hdbuAV66poLXnl3NYMjxuydr43KtqXjsUAtnlObywlXl7KxtT+pabREROZUSaJEkMS8vkyXzcth2ePwE2jnHic4+9tR3xJR01U3TKoRTtWZ+AWkBi9tEwrt2NRBMD3DhyjLOnF/A2qoCbnn8WFyuNVnOOR4/3MLZi4vZsLCI/sEQe+o7Eh2WiIhEKTGrKYjIqDYtKuaBfcfZWdNGbWsP9e291LX1Ut/We8rjfr929r0XLeWTl54Z1bnrWnvIz0onLzOx/+yzMtJYUZ7HU8emP4F2znHnrnqet2weuf7rvHJzNf/++13sqm1nzYKCab/mZBw43kVzVz/nLCkeXsr9iaOtw23+REQkuSmBFkkimxcXc9v2Gi771t+Gt2WkGRUFWcwvzGJDdRGXnJVFZWEWf9t3nBsePMQ7zl8SVVlGXVsvCxJcvhG2rqqQe55pxDk3rf2P9zR0cLS5h/dftHx426s2VnHN7bu5ddsx1ixYM23Xmoqth7z65y1LSqguzqYkN8iTR1t5y7mLExyZiIhEQwm0SBJ57eYqMtMCFOZkML8wi/mF2czLDRIInJ5kvvjMCl709b/yzb/s48uvXT/huevbexNevhG2rrqQXz1+zEvqi6Yvqb/r6QYAXnxm+fC2ktwgL1pdwW+21/CJS1eTkZb4yrXHDrVQkhtkaWkuZsaG6kJ14hARSSGJ/59ERIblBNO56pyFvOysStZXF1GWnzlq8gywsCSHN5+7iJu3HmV/Y+eE565tTewiKpHW+aUK013GcdfuBjYtKqK84NTX+bot1ZzoSp6e0OH65/Do+/rqIvY1dtLZN5jgyEREJBpKoEVS2AdesJzsjDS+cdeecY/zFhXpS5oR6DPjMJGwrq2Hp4618ZI1Faftu3BlGaV5mUnRE7qpo4+Dx7s4Z0nx8LaNC4twLv4rNIqIyPRQAi2SwkrzMnn385dy+476cXsJN/gt7JKlBjo8kXA6W9n9ZZdXvvHSURLojLQAV2xakBQ9ocP9n89eXDK8bb3f2k/9oEVEUoMSaJEU9+7nn0FJbpCv3jH2KHS4B3SyjECDlzTumMYVCe/c1cAZpbksK8sbdX+y9ITeeqiFzPQAa6tOdgSZl5fJwpJs1UGLiKQIJdAiKS4/K4MPvGA5f9t/nL/tOz7qMbWtybEKYaR1VYU0d/VTOw0rErb3DvDIgRO8ZE3FmF09VlcWsK6qkF9tTWxP6McOt7BhYRGZ6WmnbN9QXcSTR1XCISKSCpRAi8wCb37uIqqKsvnKHc+MOqJb7yep86ex48VUhXse75iGUde/7mliYMiNWv8c6cqzq9lV187TtYlJVHv6h3i6po0ti4tP27dxYRE1rT00dsRniXMREZk+SqBFZoGsjDT+6cUreOpYG3/eWX/a/rq2XvIzE7+ISqQz5xeQHrBpqYO+a1cD83KDbF50emIa6VUbFpCRZtz6eM2UrzkZTxxtZTDkOGdJyWn7NvgLqjylUWgRkaSnBFpklnjN5mpWlOfx1Tv3MDhiie+6tp6kqn8GfyJhRT47atqndJ7+wRD37mnkRWeWkzZGy7+w4twgLz6zgt88UTO8muNM2nqoGTNGTfTPWuB1JlEdtIhI8lMCLTJLpAWMj71sFQeaurh126l1vvVtvUlVvhG2rqqAHcdapzSR8NGDJ+joHeQlayqjOv7Ks6tp7urnvj2Nk77mZD12uIWV5fkU5mScti8nmM7KinyejMMS5yIiMr2UQIvMIi9dU8HGhUX891/20TswNLy9rq2X+QXJNQINsK66iJbuAWr8SY6TcdeuBrIyAlywvDSq4y8a7gk9s5MJh0KO7Ydb2LJk7DKTDdWFPHl0ar9QiIhI/CmBFplFzIx/vWQ1dW29/OThw4BX4tCURIuoRAqvSDjZBUScc/xlVwPPX1FGdjBt4icA6WkBXrO5inuemdme0HvqO+joGxy1/jlsw8Ii2noGOHyie8biEhGR2CmBFpllzls2jwtXlvG/9+2nvXeAxo5enEuuFnZhqyvzSQ/YpJf0frq2ndq23gm7b4z02s1eT+jfPjFzPaG3Di+gMt4IdBGA6qBFRJKcEmiRWejjL1tFa/cA37//QFK2sAvLykhjZUX+pDtx3LmrgYDBi1aXx/S8VZX5rK8unNEyjq2HWqgsyKK6eOzPYWVFHlkZAZ7QioQiIklNCbTILLS2qpDL1s/nBw8cHE5Ok3EEGrwyjp2TXJHwzqfr2bK4hHl5mTE/d6Z7Qm891MyWJcVjLvQCXnnJuqpCLektIpLklECLzFIffekq+odC/Ndde4HkWsY70trqQlq6BzjWEttEwqPN3TxT3xFz+UbYK9cvIJgWmJGe0DWtPdS29Y66gMpIG6qL2FnbzsDQzLfZExGR6CiBFpmlzijN5fXnLKS9d5C8zHQKsk5vnZYM1k9yIuFduxoAJp1AF+cGefGa8hnpCb31kFf/vGWcCYRhGxYW0T8YYk99R1xjEhGRyVMCLTKLffhFK8hMDyTt6DN49ciTWZHwrl0NrCjPY0lp7qSvHe4JfW+ce0JvPdRCbjCN1ZX5Ex670V+RUBMJRUSSlxJokVmsoiCLL12xjvc8/4xEhzKmyUwkbO3u5++HmnnpWZMbfQ67cEUZZfmZ/OzRI363kvj0X37sUDObFxeTnjbxj9zq4myKczJUBy0iksTSEx2AiMTXa8+uTnQIE1pfXcifdtbT1NFHWf7EEwLveaaRoZCLevXBsaSnBXjDOQv51j37ec41d5Oflc6ysjzvVp7r389lUUkuwfTJjTe09Qywp6GDS9fOj+p4M2PDwiKePKoVCUVEkpUSaBFJuJetreTmrUd5/lfu4a3nLubqC5eNm0jftauB8vzM4frpqfjnF6/kuWfMY39jB882dfFsUyd/2990ynLoaQFjcUkOq+fn8+lXrKEqhpaA24+04BzjrkA40obqIv66dx+dfV79uoiIJBf9ZBaRhHvBqnL+8pGL+Pa9+/nh3w7yk0cO85bnLubqi5ZSnn9q/XbvwBB/3dvEqzdVEQiM3RIuWoGAccGKUi5YcepS4B29Axw87iXUzzZ6X+/b00Rj+3Z++d7zSIvy2lsPtZAWsOHa5mhsXFiEc97EynOXzovl5YiIyAxQAi0iSWFpWR7fuGojH3rhCr51zz6uf/AgP3309ET64WdP0N0/NOnuG9HKz8pgfXUR6/3VAQF+ve0YH7n5Sa67/wDvv3hZVOd57FAzZy0oIDeGkeT11d7I+pNHW5VAi4gkIU0iFJGkckZpLt+4aiN3f/RiXrFuAdc/eJDnX3svX/zDLho7erlzVwO5wTTOXzbzieUVm6p4+bpKvnHXnqgWYOkfDPHksdZxl+8ezby8TBaWZKsTh4hIkoprAm1ml5jZHjPbb2afGGX/IjO718y2m9lTZvbyeMYjIqnjjNJcvn7VBu7+6MVctn4BNzx0iOdfey+/faKGi1eVk5meNuMxmRnXvHodxTlB/vmXT9A7MDTu8U/XttE7EOKcKPo/j7ShWhMJRUSSVdwSaDNLA/4XuBRYA7zRzNaMOOwzwM3OuU3AG4D/i1c8IpKahhPpj1zEZesX0DcY4opNVQmLpzg3yLVXrmdvQydfv3PPuMduPdQCENUKhCNtXFhETWsPTR19k4pTRETiJ54j0M8B9jvnDjjn+oFfAJePOMYBBf79QqA2jvGISApb4ifSe754CS+Oc/3zRF6wqpy3nLuIH/ztIA89e3zM47YebmZRSQ7lBbEvZLPBn3T4lMo4RESSTjwT6CrgaMTjY/62SP8OvMXMjgG3Ax+KYzwiMgtEsxjJTPjUy89kybxcPnbzk7T3Dpy23znH1kMtMbWvi3TWggIChhZUERFJQon+n+iNwA3OuWrg5cBPzOy0mMzsajPbamZbm5qaZjxIEZGRcoLpfOOqDTR09PHvv336tP0Hj3dxoqt/UvXP4fOvrMjniWOqgxYRSTbxTKBrgIURj6v9bZHeBdwM4Jx7GMgCSkccg3PuOufcFufclrKysjiFKyISm02LivnAC5bz6+013L6j7pR9Ww9Pvv45bOPCIp482hq3JcZFRGRy4plAPwasMLMzzCyIN0nwdyOOOQK8CMDMzsRLoDXELCIp40MvXM766kI+ddsOGtt7h7dvPdRMUU4Gy8ryJn3uDQuLaOsZ4PCJ7ukIVUREpkncEmjn3CDwQeAOYDdet42nzewLZvYq/7CPAu8xsyeBm4B3OA21iEgKyUgL8I2rNtLTP8THb31qeLR466EWtiwuntJqiRv8RVzUD1pEJLnEtQbaOXe7c26lc26Zc+4af9tnnXO/8+/vcs49zzm3wTm30Tl3ZzzjERGJh+XleXzq5Wdy354mfvboEU509nHgeBdnL55c/XPYyoo8sjIC6gctIpJktJS3iMg0eOu5i/nL7gau+eNuOvsGAThnkh04wtLTAqyrKtQItIhIkkl0Fw4RkVkhEDC+euUGgukBrv3zMwTTA6yrLpzyeTdUF7Gzpo2BodA0RCkiItNBCbSIyDSpLMziP169FudgfVXhtCw3vn5hEX2DIfbUd0xDhCIiMh1UwiEiMo1euWEBR5q7WV2ZPy3n2xgxkXBt1dRHtEVEZOo0Ai0iMs0+8ILlvOjM6VlufGFJNsU5GVqRUEQkiWgEWkQkiZkZGxYWzclOHH2DQ+ysaWNhSQ7l+Vkzck3nHDtq2vjzznr2NnRy2fr5vHzdfILpGm8SkZOUQIuIJLkN1UXcv3cfXX2D5GYm34/ttp4Bnq5pY1ddO8vL83j+ijLSptD/ur13gJ89coTrHzxIU0cfAKV5Qc6cX+Df8lldWcDy8jwy0qae2A6FHFsPNfPnp+u5Y2c9tW29pAWMsrxM/rK7gS/dvpu3nLuYNz13EaV5mVO+noikPku1dUu2bNnitm7dmugwRERmzL17GvmHHz1GcU4Gi+flsnheDotLclhYkjP8uDw/E7PJJ63RauseYGdtGztqvNvOmrbTVkpcUJjFlVsW8rqzq1lYkhP1uRvbe/nhgwf5+SNH6Ogb5ILlpbz+nIU0dfSxu66d3fXt7G3opH/Q60iSkWYsL8/nzPn5rJlfQFVRNqX5mZTmZVKaFyQvM33M96R/MMRDzx7njqfrufPpBk509RNMD3DhijIuWVvJi88spyArg7/ua+JHDx7i/r1NBNMDvGrDAv7heUs4a4Hq0UXmAjN73Dm35bTtSqBFRJLbwFCInzx8mH2NnRxp7uLwiW5qW3sIRfz4zsoIsKgkh0UlOSwrz2PN/AJWVxawtCx3UqO0QyHHsZZu9jd2srehk51+wnyk+WSyXF2czbqqQtZWFbKuqpDVlflsPdzCLx87yv37mgC4YHkpV21ZyEvPqhizK8mzTZ18//4D/HpbDYOhEC9fN5/3XbRs1EmTg0MhDhzvYnddO7vq2tld18HuuvbhkepImemB4WTa+5pJaX6QmpYe7t7dSEffILnBNF54ZgWXnFXJxavKxhzh39/YwQ0PHeLWx2voGRjiOWeU8M7nLeElayqnNNouIslNCbSIyCzSPxiitrWHw83dHDnhJdVHmrs5fKKbg8e76Pf7RgfTAiwvz2P1/HzOrCzwvs4vGC5F6B8McfhEF/saO9nf2Dn89UBTJ32DJ3tPLyw5NVleu6CQ4tzgmPHVtPbwq61H+dXWY9S09lCUk8EVm6p4/TkLWV1ZAMD2Iy1896/PcueuBoJpAV63pZr3PH8pi+flxvx+nOjso769l+Od/Zzo7ON4Zx/HO/s53tFHU/h+Zx/NXf0UZKXzkjUVXLK2kvOXlZKVEX27wbbuAX659Qg3PnSYmtYeqoqyedt5i1lRkUfAjIAZaYHIr16P8DT/cWVhlspARFKIEmgRkTliYCjEgaYunqn3Rmi9r+00tJ8cpS3Ny6QgK53Dzd0MRQxlVxdns7w8jxXleSwP38ryKczJmFQsQyHHg/uP88utR7nz6XoGhhwbFhaRmR7g7webKchK523nLeEdz1syI4llyH+tgSmOGg8OhfjL7gauf/AQfz/YHNNz11YVcPHKci5eVcbGhUWkT0Mdt4jEhxJoEZE5rrmrn2fq23nGT6o7egdZVnYyUV5alktOMH6TFJu7+rltew03P3aU7oFB3n7eEt7wnEXkJeHEyFgcPtFFS/cAQyFHyDlCIceQc4RCeF/D20KOvQ0d3LeniW1HWgg5KMhK5/kry7hoZRkXryyjvGBmuo2ISHSUQIuIiCSJtu4BHtjfxF/3NPHXvU00+jXca+YXcPGqMs5dOo/inCC5mWnkZaWTl5lOdkbauBNFB4ZCHO/so7G9j4b2Xho7+rybf79/MER6mpGRFiAjzUgPBE7eH94eIC8znVWV+Zy1wJuYOROTU2dK3+AQbT0DtHUPeF/9W2v3AGawsiKfVZX5KrORYUqgRUREkpBzjl117dznJ9OPH245pawmLGCQG0wnLyud3EzvlpORRmvPAE0dvZzo6mfkf+lmMC83SFl+FtkZAQZDjoEhx+BQiIGhkHc/5H0dGAoxOOToHRwaPk9BVjprFhSwZn4hZy0oYM2C8dsHdvUN0uTXnTd1nLwNhEJkpqeRmR7wbhkR99PTyMzw7ucE0ynOyaAoJ0hB1thdVEZ7D5s6+zja3MOxlm6ONndztLmHoy3dnOjs95Lknn56B0ITnwzvPVtV6SXTq/ykemVFflK2kZT4UgItIiKSAtp7B9hZ00Zn7yBd/YN09g3R1TdIZ+8gnX2DdPWd3N7TP0hhdgZl+VmU52dSXpBJRX4W5QWZlOdnMS8vGHMXlu7+QfbUd/B0rdfpZFdtO8/Utw8nn8G0ACsr81hZnk/v4BBN/kh3U0cf3f1Dp50vLWCkB+yUSanRSA8YRTkZFOcEKc4JUpSTQUlukKKcIPlZ6TS093qJcouXNI9MjkvzMllYkk15fiaF2RkUZvuJeXYGRf5jb5v3tX8oxL6GTp6p72BPfTt7GjrZW99Bz8DJ17SwJJtVFflUF+dQVZRNVXE2C4qyWVCURWlu5pRr62PRPxjyvi/6BunuH/K/+t8ffUOYMfxXhWD6yb8wZKQFCKYFyPC35QbTJ/V9MlcogRYREZFJGRwKcehEl5dU+4n1voZOcjPTKM/Poiw/8+Qt7+T98vxMinOCBAKGc47+oRB9gyH6BkL0DQ6ddr+7f5CWrgFauvtp6e6nuWuA1u5+mrv6ae0eoLm7n9bufgaGHPmZ6VSX5LCwOJtFfl/0hSXZLCzOobo4h+xg9N1VxhIKOY62dLOnvoM99R0809DB/oZOjrV00zXil4VgeoAFhVl+Qu3dcoNpBMww81YVNby/CozcFnKOrr4huvu9ZNhLhE8+7uoforsvfN9LkgeGpjd/K8kNUj7KZxi+leQGSQ8ETnaX8TvLpAW81xLuNGNm9A4M0dE7QEfvIB3+L37hx9597xdCM++6Jbleq8mS3CDz8oLMy/XuJ8MKoEqgRUREJOU55+gdCJGVEUhYfbZzjvbeQWpaeqht7aG2rYea1p6Tj1t7aejoPa2kZiJmkJORRk5mOrnBNHKC6eRmnvyanZFOXqa3Py8znZxgGrkR972v3rHg1cX3Dzq/XCdEv1+2MzB48nFH7yDHI0tu/Dr6ps6+4UWLpltuMI38rAyGnKOlq5/BUUqWAPKz0pmXG2ReXib/9+bNVCRgku1YCbSKeURERCRlmNm0jC5PNYZwCciaBQWjHuMlryEc3gizc17iHYr8irc9YEZuZhpZ6WkzWgYynvAvCeHEuqXbS3TDHWVCfoeZoXC3mVD4sSPbT5DzM9PJz/Lq9vOzMsjzk/3IxYdCIUd77wAnury/NJzo7ONEVz8nOr3H4f7tsfRrnwlKoEVERESmWbjeOFVF/pKwvDwvbtcJBIyiHK+2fVlZ3C4z7VL3kxURERERSQAl0CIiIiIiMVACLSIiIiISAyXQIiIiIiIxUAItIiIiIhIDJdAiIiIiIjFQAi0iIiIiEgMl0CIiIiIiMVACLSIiIiISAyXQIiIiIiIxUAItIiIiIhIDJdAiIiIiIjFQAi0iIiIiEgNzziU6hpiYWRNwOEGXLwWOJ+jaMj59NslLn03y0meTvPTZJDd9Pslruj+bxc65spEbUy6BTiQz2+qc25LoOOR0+mySlz6b5KXPJnnps0lu+nyS10x9NirhEBERERGJgRJoEREREZEYKIGOzXWJDkDGpM8meemzSV76bJKXPpvkps8nec3IZ6MaaBERERGRGGgEWkREREQkBkqgo2Bml5jZHjPbb2afSHQ8c52ZXW9mjWa2M2JbiZndZWb7/K/FiYxxLjKzhWZ2r5ntMrOnzezD/nZ9NknAzLLM7O9m9qT/+Xze336GmT3q/3z7pZkFEx3rXGVmaWa23cz+4D/WZ5MEzOyQme0wsyfMbKu/TT/XkoCZFZnZLWb2jJntNrPzZuqzUQI9ATNLA/4XuBRYA7zRzNYkNqo57wbgkhHbPgHc7ZxbAdztP5aZNQh81Dm3BjgX+ID/b0WfTXLoA17onNsAbAQuMbNzgWuB/3LOLQdagHclLsQ578PA7ojH+mySxwuccxsj2qPp51py+CbwZ+fcamAD3r+fGflslEBP7DnAfufcAedcP/AL4PIExzSnOefuB5pHbL4cuNG/fyPw6pmMScA5V+ec2+bf78D7QVaFPpuk4Dyd/sMM/+aAFwK3+Nv1+SSImVUDrwB+4D829NkkM/1cSzAzKwQuBH4I4Jzrd861MkOfjRLoiVUBRyMeH/O3SXKpcM7V+ffrgYpEBjPXmdkSYBPwKPpskoZfIvAE0AjcBTwLtDrnBv1D9PMtcf4b+DgQ8h/PQ59NsnDAnWb2uJld7W/Tz7XEOwNoAn7klz79wMxymaHPRgm0zDrOay2j9jIJYmZ5wK3APznn2iP36bNJLOfckHNuI1CN99e11YmNSADM7DKg0Tn3eKJjkVFd4JzbjFfK+QEzuzByp36uJUw6sBn4jnNuE9DFiHKNeH42SqAnVgMsjHhc7W+T5NJgZvMB/K+NCY5nTjKzDLzk+WfOuV/7m/XZJBn/z5z3AucBRWaW7u/Sz7fEeB7wKjM7hFcm+EK82k59NknAOVfjf20EbsP75VM/1xLvGHDMOfeo//gWvIR6Rj4bJdATewxY4c+GDgJvAH6X4JjkdL8D3u7ffzvw2wTGMif5NZs/BHY7574RsUufTRIwszIzK/LvZwMvwatTvxe40j9Mn08COOc+6Zyrds4twfs/5h7n3JvRZ5NwZpZrZvnh+8BLgZ3o51rCOefqgaNmtsrf9CJgFzP02WghlSiY2cvx6tPSgOudc9ckNqK5zcxuAi4GSoEG4HPAb4CbgUXAYeAq59zIiYYSR2Z2AfAAsIOTdZyfwquD1meTYGa2Hm9CTRre4MnNzrkvmNlSvFHPEmA78BbnXF/iIp3bzOxi4GPOucv02SSe/xnc5j9MB37unLvGzOahn2sJZ2Yb8SbeBoEDwD/g/3wjzp+NEmgRERERkRiohENEREREJAZKoEVEREREYqAEWkREREQkBkqgRURERERioARaRERERCQGSqBFRJKQmXX6X5eY2Zum+dyfGvH4oek8v4jIbKcEWkQkuS0BYkqgI1avG8spCbRz7vwYYxIRmdOUQIuIJLcvA883syfM7J/NLM3Mvmpmj5nZU2b2XvAW4DCzB8zsd3ircWFmvzGzx83saTO72t/2ZSDbP9/P/G3h0W7zz73TzHaY2esjzn2fmd1iZs+Y2c/8lSdFROakiUYpREQksT6BvzIdgJ8ItznnzjGzTOBBM7vTP3YzsNY5d9B//E7nXLO/dPdjZnarc+4TZvZB59zGUa71GmAjsAFvpc/HzOx+f98m4CygFngQeB7wt+l+sSIiqUAj0CIiqeWlwNvM7Am8ZdLnASv8fX+PSJ4B/p+ZPQk8AiyMOG4sFwA3OeeGnHMNwF+BcyLOfcw5FwKewCstERGZkzQCLSKSWgz4kHPujlM2ml0MdI14/GLgPOdct5ndB2RN4bp9EfeH0P8fIjKHaQRaRCS5dQD5EY/vAN5vZhkAZrbSzHJHeV4h0OInz6uBcyP2DYSfP8IDwOv9Ousy4ELg79PyKkREZhGNIIiIJLengCG/FOMG4Jt45RPb/Il8TcCrR3nen4H3mdluYA9eGUfYdcBTZrbNOffmiO23AecBTwIO+Lhzrt5PwEVExGfOuUTHICIiIiKSMlTCISIiIiISAyXQIiIiIiIxUAItIiIiIhIDJdAiIiIiIjFQAi0iIiIiEgMl0CIiIiIiMVACLSIiIiISAyXQIiIiIiIx+P9pmN+m76gsEAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -238,13 +252,13 @@ "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", "\n", "# fit classifier to data\n", - "opflow_classifier.fit(X, y)\n", + "estimator_classifier.fit(X, y)\n", "\n", "# return to default figsize\n", "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", "\n", "# score classifier\n", - "opflow_classifier.score(X, y)" + "estimator_classifier.score(X, y)" ] }, { @@ -255,7 +269,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -268,7 +282,7 @@ ], "source": [ "# evaluate data points\n", - "y_predict = opflow_classifier.predict(X)\n", + "y_predict = estimator_classifier.predict(X)\n", "\n", "# plot results\n", "# red == wrongly classified\n", @@ -288,7 +302,7 @@ "id": "japanese-seattle", "metadata": {}, "source": [ - "Now, when the model is trained, we can explore the weights of the neural network. Please note, in the case of `TwoLayerQNN` the number of weights is defined by ansatz. And when no ansatz is passed, it defaults internally to using a `RealAmplitudes` quantum circuit of `reps=3`." + "Now, when the model is trained, we can explore the weights of the neural network. Please note, the number of weights is defined by ansatz." ] }, { @@ -300,8 +314,8 @@ { "data": { "text/plain": [ - "array([ 1.10460048, -0.39046092, -0.95712798, -1.15454919, 1.7284252 ,\n", - " 0.0817311 , 3.10199653, -0.61927078])" + "array([ 0.86209107, -1.06526254, -0.10663602, -0.39086371, 1.0894299 ,\n", + " 0.59368219, 2.22731471, -1.04769663])" ] }, "execution_count": 10, @@ -310,7 +324,7 @@ } ], "source": [ - "opflow_classifier.weights" + "estimator_classifier.weights" ] }, { @@ -318,9 +332,10 @@ "id": "determined-standing", "metadata": {}, "source": [ - "### Classification with a `CircuitQNN`\n", + "### Classification with a `SamplerQNN`\n", "\n", - "Next we show how a `CircuitQNN` can be used for classification within a `NeuralNetworkClassifier`. In this context, the `CircuitQNN` is expected to return $d$-dimensional probability vector as output, where $d$ denotes the number of classes. Sampling from a `QuantumCircuit` automatically results in a probability distribution and we just need to define a mapping from the measured bitstrings to the different classes. For binary classification we use the parity mapping." + "Next we show how a `SamplerQNN` can be used for classification within a `NeuralNetworkClassifier`. In this context, the `SamplerQNN` is expected to return $d$-dimensional probability vector as output, where $d$ denotes the number of classes. \n", + "The underlying `Sampler` primitive returns quasi-distributions of bit strings and we just need to define a mapping from the measured bitstrings to the different classes. For binary classification we use the parity mapping." ] }, { @@ -331,7 +346,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAB7CAYAAABKB1qgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZpElEQVR4nO3deVwV1f/H8RcXkEV2UVFcETE3SDC3n4qmKJnmkmZuuZDyVbNcslzCJZfcUMvcLTUz3C1LXAtQM/dEaZFUkFBRDBARELiX3x/I1etFQBDmqp/n48HjgXNmzj0zc3zfYZYzRtnZ2dkIIYQodSqlGyCEEC8qCWAhhFCIBLAQQihEAlgIIRQiASyEEAqRABZCCIVIAAshhEIkgIUQQiESwEIIoRAJYCGEUIgEsBBCKEQCWAghFCIBLIQQCpEAFkIIhUgACyGEQiSAhRBCIRLAQgihEAlgIYRQiASwEEIoRAJYCCEUIgEshBAKkQAWQgiFSAALIYRCJICFEEIhEsBCCKEQCWAhhFCIidINeFZd+AXu3FS6FeJJWVeAOq8+/XqlPzyfSqq/5JIALqI7NyEpVulWCEMh/UEUhZyCEEIIhUgACyGEQiSAhRBCIRLAQgihEAlgIYRQiASwEEIoRAJYCCEUIgEshBAKkQAWQgiFGHQAazQaFixYQO3atTE3N8fDw4OwsDDq1KnDsGHDlG5entQaNat+Gk/PaeV54xNrpq9/k9t3byndLKEQ6Q8iPwYdwH5+fsyYMQN/f3/27NnDW2+9RZ8+fbh8+TJeXl5KNy9Pm0LmcPSPH1gy6jhBk3OeTZ0bNEDhVgmlSH8Q+THYsSCCgoJYt24doaGheHt7A9C2bVvOnDnDjh078PT0VLiFeQs+tor+PlOoVM4FgKGvz2PgXFduJF6hon11hVsnSpv0B5Efgz0Cnj17Nr6+vtrwzeXq6oqpqSnu7u4AREdH4+3tjZubGw0bNuTw4cNKNBeAlLQkbibFUNv5wdF5ZcdaWJrbcOlauGLtEsqQ/iAKYpABHBsbS0REBL169dIri4mJoX79+piZmQHg7+9P7969iYyMZOXKlbz99ttkZGQU+BlGRkbF+gkLC9WrM/XeHQDKWtjqTLcytyM1PbkIW0I8bWFhocXe99IfXhxF7S+FZbABDODk5KQzPS0tjbCwMO3ph1u3bnHkyBH8/PwAaNGiBZUrVyYkJKR0G3yfpZk1AHfTbutMT0lPwtLcRokmCQVJfxAFMcgAdnR0BCAyMlJn+rx587h+/br2AlxMTAwVK1bUHg0D1KxZkytXrhT4GdnZ2cX68fZuo1enlYUdFeyqcfHqGe206/9dJjU9GZdK7kXZFOIp8/ZuU+x9L/3hxVHU/lJYBnkRzsXFBXd3d2bPno2DgwPOzs5s27aN4OBgAIO9AwKgU7NhbA6di4drW2wsy7E6+GMau3XEyaGG0k0TCpD+IPJjkEfAKpWKrVu3Ur9+fYYPH87gwYNxdHRk5MiRGBsbay/AVatWjRs3bnDv3j3tslFRUVSvrtzV5bfbTqBZ3S689/kr9JnpjEajZkLfbxVrj1CW9AeRH6PsJzleVtiAAQMIDw/n3Llz2mkdOnSgW7dujBgxgqNHj9KzZ0+io6MpU6ZMibbl1CZ5Bc2zyK4KNH776dcr/eH5VFL9JZdBnoJ4nFOnTtGsWTOdaStWrGDQoEEsXryYMmXKEBQUVOLhK4QQT8MzE8ApKSlERkYyYsQInekuLi4cOnRIoVYJIUTRPTMBbGVlhVqtVroZQgjx1BjkRTghhHgRSAALIYRCJICFeI7tO7mOgXNclW4G45a3YePBmdp/d5lsxZ/Rvz3Vz4hPisVnvBFxCdFPtd6S9MycA35enL98mElfvaY3Xa3JIjPrHguHHyqwvKFLK8Ytb8NfV37D2NhUO0+bl99mXK81xWpfXEI0Az6ryXeT/6W8XZVi1VWQfSfXsWDLYF556TVm+wXrlPnNr0fMzb9Y8L8QPGq1KdF2KO3hfalSGeNkX5O+7Sbj7aE/FsrT8vOZjcwJ6s87PtMY0GFqiX3O4/w4K0X7e/ilUD5a1Z59c7NKvR1KkwAuZQ1dWul0PoCMzHTGLffGzqoC9Wv8X4Hlufq1D6Bf+09Kpd1PKkudiclDXw6PU86mMn9fOcbNxBgq2FcDICLqCGpNFiqVcUk302Dk7ku1Oosfjn7JZ9/1xdW5Ec6OJXP0uvvYSqwtHdhz8iv6tv8E4xdoWxsSOQVhABZsGcK9zDQm9QtCpdLfJQWVPyoqLoIJqzvSc1p5+s6qxlfBE8lSZ2rL528eTN+ZVXnjE2v85tfjl9+/05b5L/IAYMi8OnSZbMW3B2YA4DPeiIioI9r5wi+F0vHjB9/f45a3YdkPo5m6rhtdP7FhW1ggAMHHVzN0QQO6Btjyv0WNOHVhv05bzUwtaPPy2+w9+bV2WvDx1XRqOlRnvvikWCau9qXntPJ0DbBlzLJWRMae1pZ/s38a41e2Y/muMfSYWo4+M6uw6Zc5BW4rQ2NsbMJrTYei1mRx6dpZAH6N+J4Ri73oFmDHkPl1+fnMRu38BW2XvFy58Rfnow7zUe/1JCRf5+Tfe3TK+8+uwcaDM/lwRVu6TLZiaGBDLl87xy+/BzFwjitdA2wJ3PouanXOEWtcQjQ+440IPr6GQXPd6Bpgy5S1XUlMufnYNuT2p1u3rzFpzWtoNGq6TLaiy2Qr9p9ar60z/qGnWx49nZKQHEfA2jfoGmDLoLlunLywV+9z8ut/F6/+zuilLekaYEuPKQ588GUL7qQm5rvtnjYJYIVtOPApv1/8mRlDfsTCzOqJyx+VmHKTccu9admgB0GfXOWL937j9D8HCPrlM+08DWq2ZMWYs+z8NIn+PlOYv3kQV278CcDKMTnj1H790QV+nJVCf5+AQq/LvpNf063l+3w/4zbdWr5P8PHVbA6Zy4S+G9k5PZHBvrOY/k0Prt66qLNcp6ZD2XvyazQaDSlpSRz94wd8Gg/UmSc7W0OXFiP4dtIVtkyJw9XZk+nre+h8sZy/fAh7q4psDrjO9EE/sP3QQp0vl2dBZlYGPx1dDkAVRzdORx4gcKsfw99YzI7pCXzUez1ffv8e5y7n3PtemO3yqODjq3Cp5E6zep1p8lIndh9bqTfP/tPrGdV9GTs/TaRWJQ+mre9O+KUQVowNZ/XY8xz7Yxeh4Zt1ljl4+hsWDj/Ed5P/RWWkYs53/QtcX0fbysx+dw8qlTE/zkrhx1kpdHhk3z/OZ0H9MDYy5rtJMSwcfoj9p9Y9sp75978lO0fi5daBHdMT2DL1Bv5dFmJiUroPcUkAKygsfCubQ+YwfeD3eb4doaDy736eRbcAO+3Pn1eOcfDUN9Sq5EHn5v6YmpTB0daZPm0ncvD0N9rlXmvih03ZchirjGn78tvUrORO+KXQYq9PK/eeNHJ9FSMjI8zLWLLz8Of0bz+FWpU9UKlUNK3biZdrtSX07Cad5VydG2FnVYGTF/Zw8My3eLr5YG9VQWeeCvbVaFH/DczLWGJmasHgjjO5mRTD1Vv/aOdxsKlE77YfY2pSBrcqXnRqNox9J9cVe71KQ+6+7DzJgrX7PmFsrzW4VHZn55HP6d7yAxq6tEKlUvFStSa08+zPgfv7szDb5WEZmekcOP0NHV8ZDIBvEz9OXNijc6QJ8HrTYVSvWBcTY1PaNurL9YTLDPadhUWZslSwr4Z7rTZExp7SWaa/z1QcbJwoa27D0M7zOfPPAW7dvlYCWwtu3b7K2Yu/MKzzAspa2OJg48QAH91z2QX1PxPjMtxMiiE+6V9MjE2pV70ZFmXKlkh7H0fOASvkwr+nWLB5EGN6rqZejeZPXA7Qt91kvXPAB09v4I/oX+kWYKedlk02Gk3OQywajYZvDkwjLHwzCXfiMMKI9Iy73E6JL/Y6VbSvofPvuIQolnw/kqU/vK+dptZk4Wirf3GvU5OhBB9fTVxCFENfn69XfvvuLVbsGkv45VDupiVhZJRz7JCUEk/1irmfX11nMOyK9jU4cn5HsderNOTuyzupiQRu9SP8YgivNfEjLiGK8IshbD+0UDuvJltNg5qtgMJtl4eFndtK+r0U2nnmHJ02fakTdmXLs+fEGt7pME07n4N1Je3v5mUsUamMsbMqr51mZmqpHXA+l9ND+z/391u3Y3G0rVykbZKf+Ns5XxgPH5g4OdTUmaeg/vdh77VsPDiDMctaYqIypZ1nfwb4TMXYuPRiUQJYAbduX2Xquq682Xos7Tz7PXF5firaV6dR7fbM8tudZ3nI2SD2nFjDnKH7qV6hHiqVihGfNyabnDGZVEZ5/1FkYWZFWsZd7b//S9Y/snl02Qr21Xmnw/RCXc1/tVFfVu8ej01ZR7zcfPTKvwqeSMKd6ywZdZxyNpVITb9D1wAb4MFYUjcSr5Cdna0N4RuJ0XmGvSGztrRnbK81DJxTi6MRP1DBvjodGg/irTbj85y/MNvlYcHHV6HOVjN0QQPttJT0JPae+Ip+7QOKdTEuLjGayo61tL8Dhdr+Rnn0udzB7NMf0+ccbZyBnH2e+5k3Hrn9rKD+V8mhJh++lXPtIer6eSas7oCTQ018mwwpsM1Pi5yCKGXpGalMWdeVejVaMLDjp09cXhAfr3eIjD3F3hNfk5GZjkaj4fp/lzn5d84FitT0ZIxVJtiVLU92toa9J77m8kPvJ7O1Ko/KSKX3J2xtZy8OnFpPZlYGcQnRbHvoiOxx3mw9hg0HpnHx6lmys7O5l5lGRNQRYm7+rTevpbk18/8XwswhP+X5SpfUe8mYmVpibWFP2r0U1gR/rDdPQvJ1toTOJ0udycWrvxN8fHWhzycaEhtLB95sNZav906iR8vRbD+8iPOXD6PWqMnMyiAy9jQX/s35878w2yXXlRt/EhF1hGkDd7JizFntz5ejTpBwJ44Tfwc/dtnC2HhwBol3bnA3PZk1uz/Gs3b7Qh39Olg7odGouZ4Q9WAblC1HRfvq7D35NWqNmqjr59lzfLW2vLxdFTxqtWH17o+4m55M4p0bfHtQ9/9LQf1v/6n12lMkZS3sMFaZlPqdN3IEXMoOn9/OP7GnibnxJ298Yq1XPqr70nzLR7+5Mt+jYgcbJxb8L4Q1wRP4es8k7mWl4WRfg9eb+QPg03ggv1/6hYFzXTEztaS95wAa3v9zFnLuShjYcQazN/YhIyudXm3G06/dZN7r/iWBW4bQY6oD1SvWo0PjQSzfNTrfde3UdCgmxmVYsGUwcQlRmBib4ursiX/nBXnO71bl8QPtD+zwKfM3D+LNqeWws67IwA6fsvv4Kp15GtZsRcKd67z1qRNlTMzp3vIDXm3UN982GqrurT5gx+FF/Jd8jbE9V7Nq93hi4y9gZKSiRsX62i/nwmyXXD8dW0ltZ0+a1+uiM93BxonW7r3YfWylXtmTaOfZnzHLWpGYcgP3mq35+O0NhVquSnk3ujQfzqgvmpClzmRktyX4eA1gfO/1LNk5gl1Hl1KvenN8m/jpXGib2Pc7Fm0bSt9ZVbG3qshbbT7ifNSDl/IW1P/OXvyFr4InkJqejJWlPa826kd7zwFFXv+ieKbGAzYkMv6rYflm/zQioo4wz/9gvvPJeMBPX2k+vFPaSno8YDkFIYQQCpEAFkIIhcg5YPFcePgWKlG6nBxqcGC+nMksCjkCFkIIhUgACyGEQiSAhRBCIRLAL6B5mwYx6oum3E27jVqdxZygAYxe2lI7elhE1BGGzHuJ4OOFH1v44TovXv2doYEN6T+7hra8KHUKfV8FT2TsstZ8FTwRyBkhbPC8OoRfCgNgS+h8Ri9tyWff9SNLnUnavRRGLWmW78A4h85tY/TSlkxb34P0jFTiEqLpNb0iOw5/DsAXO0bQc1p5nX0XuPXdfAd6j42PZOxyb8Yua01sfCQAg+fVYf7mnDEoNuyfzvtLmvP+kuac+ednbTv6z67Bmci8byXUaDQEbn2XMctasfPIF0DO7Yf+Cz349+YFouIi+ODLFoxZ1or5mweTnZ3N1VsX8V/4Mmv3GuawrRLAL6gJfTdS1sKWo3/uomqFl1g88ggR0UdISI6jQc2W9G47och1Vi7nyhejjuk8hlrUOsUDUXER3E1PZuGIQySn/kd03B8A9PIej0ctbxJTbnL2UgiLRx6hZiV3fo34HgszKyb32/TYOtUaNbuPrSJweBit3Xuy7+RaALxq+9Cj1QdAzljFj47PMa7XGuytnR5b7/r9U5nUN4gJfb5l/b4pANiWLc/43jn1t2/8Dl+M+o3Z7+7h2wPTAWjt3pMOjQc9ts4TfwdTtXwdFo04zJnIAySnJgDg3zmQqhXqULV8HT5/7yiLRuQ8jBEZewpnR1dGdF382DqVJgH8nDv250+s+mk8Go2Giat9uZkYo1P+95VjeNXOGXvBo1Zb/v73RLHrtDS3LvVRpV4EEVFHaOzWAQDP2j46T30BRP57Cg+XNvfL2/PXlYJf+XP11j/UcKqPscoYz9o+RDxSJ0A5m0p5LJm/lNREHG0rU8G+Gkl39Qd6qnR/4BxTEzPI49HzvEREH8Hr/vo3dGnNhRjdvvrwCwBMTcwob1v1idtd2uQ2tOdcs3qdCQvfwqLtw2hWr4v2rRO5UtKTsDS3AaCsuS1305KKXacoGXdSE/jptxVsP7yIlLQkvD3eopzNg7EW7j6yL1PSkwpV568RO7l49XcgZ4jGp+Hi1TOMW94GgJj7Y03n5Zv90+h8/zH5gtxJTWDxdn/KmJiTeCeO/j5T9OY5+scu1u6ZhLNjbWzKlitS20uTHAG/AF5v5s+h8C281vRdvbKy5rakpicDOQP1lLWwK3adomRYWzowsOOnBA4PZbDvTKwtHXTKH92XVuZ2haqzZYMeBA4PZeaQn7B5pM6iql3Fi8DhoQQOD6VOtSZ5znPk/E6SU/8r9Hgd1pYOjHlzFYHDQ3nj/97D2kK/rS3qv8HqDyNwtKvCsT9/KtY6lAYJ4OecRqNh48EZ9PeZyuY8XtFTt3pzfr+YcxEk/FIIdaq+ojfPrdtXn6hOUTIa1GzJ+ftvwgi/FKoziBKAW9VXOHc552LcmX8OUrd6M706Ht2Xzo61uXrrHzQaDeGXQrXjDD+J5NQE7mWm6UyzsSxHUko8SSnxeQbl5Wvn2HV0KaO6L82zTrU6i8Q7N3SmNajRknNROev/15Xf9II9I+ue9ndLMxvMTC2eeF1KmwTwc+77X7/g/xp0p5f3OKLizmsv3ORqXq8L0XERjF7akrrVm+ud71Ors5i/edAT1Xkz6V8+Wtme6LgIPlrZ/pl6Tbghq+nUABNjU8Ytb4OJsSk1nOrrlNtbVaChS2tGL23JpWtnaVG/m14dcze9g0aj0f7bWGWMT+OBjFvhzb6Ta7VvynjYxp9nsTVsPtsPLWTDAf0hUrcfWsg/sWd0pvVrH8CMDb2YsaEXfdtN1ltm1e7xJKbcYOLqjkxZ21WvPC4xWu/OhSYvdeLStbOMXe7NS9Wa6h2tn/p7b86dF8u9SUy5oT1fbMhkNLQiepZHv1r544f8FXOMWUN2U9bCVq88IuoIy3aN5i3v8VR2dOXytfACB6l+kjrbvNz7qa3Lk3reRkM7dG4bm0Lm4N85EI9a3nrlafdSmLjGlzpVX8G/cyDLdn3Ae92W5FtnfFIsk9b48lrTodo7IR4VuPVdYuMvsGjEYb78fhQj3vi8wBfGjlveBieHmto7IfJal40HZzKq+1IS78RhZWlPI9dX861zx+HFhJzdxEe911O1Qh298qu3LjInqD+t3XvRy3tcvnXlpaRHQ5MALqJnOYBfZM9bAIuSJcNRCiHEc0oCWAghFCIBLIQQCpEAFkIIhRh0AGs0GhYsWEDt2rUxNzfHw8ODsLAw6tSpw7Bhw5RunhBCFItBP4rs5+fHjh07CAgIwMvLi6NHj9KnTx/i4+MZO3as0s3TE3J2E7uOLuXytXDSM1PZNzdL6SYJhUmfEPkx2AAOCgpi3bp1hIaG4u2dc39j27ZtOXPmDDt27MDT01PhFuqzsrCnS/MRZGSmsWi7HKEL6RMifwZ7CmL27Nn4+vpqwzeXq6srpqamuLu7AzBlyhTc3NxQqVRs27ZNiaZqvVKnI6826kOlci6KtkMYDukTIj8GGcCxsbFERETQq1cvvbKYmBjq16+PmZkZAL6+vuzdu5fWrVuXdjOFEKJYDDaAAZycdAd8TktLIywsTOf0Q4sWLXBxefKjCyMjo2L9hIWFFmsdhTLCwkKLve+lP7w4itpfCssgA9jR0RGAyMhInenz5s3j+vXreHl5KdEsIYR4qgzyIpyLiwvu7u7Mnj0bBwcHnJ2d2bZtG8HBwQBPJYCLOwSGPPv/bPL2bkP28qc//In0h+dTSfWXXAZ5BKxSqdi6dSv169dn+PDhDB48GEdHR0aOHImxsbH2ApyhUWvUZGSmk5mVAUBGZjoZmenFDnvx7JI+IfJjkEfAAG5uboSEhOhMGzBgAPXq1cPCwjAHWj54egMLtjwYT/X1STnt3DAxCieHGgq1SihJ+oTIzzM1HGXdunVp1qwZa9c+GE80ICCAtWvXEh8fj5WVFRYWFoSFhVGrVq0SbYv8yflskuEoxZOQ4SjvS0lJITIyUu8BjBkzZhAbG8u9e/f477//iI2NLfHwFUKIp8FgT0E8ysrKCrVarXQzhBDiqXlmjoCFEOJ5IwEshBAKkQAWQgiFSAALIYRCJICFEEIhEsBCCKEQCWAhhFDIM3MfsKGxrqB0C0RRlNR+k/7wfCrp/fpMPYoshBDPEzkFIYQQCpEAFkIIhUgACyGEQiSAhRBCIRLAQgihEAlgIYRQiASwEEIoRAJYCCEUIgEshBAKkQAWQgiFSAALIYRCJICFEEIhEsBCCKEQCWAhhFCIBLAQQihEAlgIIRQiASyEEAqRABZCCIX8P2ADkuzEY8P3AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -378,13 +393,12 @@ "outputs": [], "source": [ "# construct QNN\n", - "circuit_qnn = CircuitQNN(\n", + "sampler_qnn = SamplerQNN(\n", " circuit=qc,\n", " input_params=feature_map.parameters,\n", " weight_params=ansatz.parameters,\n", " interpret=parity,\n", " output_shape=output_shape,\n", - " quantum_instance=quantum_instance,\n", ")" ] }, @@ -396,8 +410,8 @@ "outputs": [], "source": [ "# construct classifier\n", - "circuit_classifier = NeuralNetworkClassifier(\n", - " neural_network=circuit_qnn, optimizer=COBYLA(maxiter=30), callback=callback_graph\n", + "sampler_classifier = NeuralNetworkClassifier(\n", + " neural_network=sampler_qnn, optimizer=COBYLA(maxiter=30), callback=callback_graph\n", ")" ] }, @@ -409,7 +423,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -422,7 +436,7 @@ { "data": { "text/plain": [ - "0.65" + "0.7" ] }, "execution_count": 15, @@ -436,13 +450,13 @@ "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", "\n", "# fit classifier to data\n", - "circuit_classifier.fit(X, y01)\n", + "sampler_classifier.fit(X, y01)\n", "\n", "# return to default figsize\n", "plt.rcParams[\"figure.figsize\"] = (6, 4)\n", "\n", "# score classifier\n", - "circuit_classifier.score(X, y01)" + "sampler_classifier.score(X, y01)" ] }, { @@ -453,7 +467,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -466,7 +480,7 @@ ], "source": [ "# evaluate data points\n", - "y_predict = circuit_classifier.predict(X)\n", + "y_predict = sampler_classifier.predict(X)\n", "\n", "# plot results\n", "# red == wrongly classified\n", @@ -498,7 +512,7 @@ { "data": { "text/plain": [ - "array([ 0.7606431 , 1.21870089, -0.42915461, -0.20929796])" + "array([ 1.67198565, 0.46045402, -0.93462862, -0.95266092])" ] }, "execution_count": 17, @@ -507,7 +521,7 @@ } ], "source": [ - "circuit_classifier.weights" + "sampler_classifier.weights" ] }, { @@ -517,7 +531,7 @@ "source": [ "### Variational Quantum Classifier (`VQC`)\n", "\n", - "The `VQC` is a special variant of the `NeuralNetworkClassifier` with a `CircuitQNN`. It applies a parity mapping (or extensions to multiple classes) to map from the bitstring to the classification, which results in a probability vector, which is interpreted as a one-hot encoded result. By default, it applies this the `CrossEntropyLoss` function that expects labels given in one-hot encoded format and will return predictions in that format too." + "The `VQC` is a special variant of the `NeuralNetworkClassifier` with a `SamplerQNN`. It applies a parity mapping (or extensions to multiple classes) to map from the bitstring to the classification, which results in a probability vector, which is interpreted as a one-hot encoded result. By default, it applies this the `CrossEntropyLoss` function that expects labels given in one-hot encoded format and will return predictions in that format too." ] }, { @@ -537,7 +551,6 @@ " ansatz=ansatz,\n", " loss=\"cross_entropy\",\n", " optimizer=COBYLA(maxiter=30),\n", - " quantum_instance=quantum_instance,\n", " callback=callback_graph,\n", ")" ] @@ -550,7 +563,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -594,7 +607,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0RklEQVR4nO3deXgUVfbw8e9JIEBcGMAojEBCEJGADEjYRAQE2VRAxRFERUUiis6gw6hMdHBw8MVlBpdRf8QgokRRQBREDJuMOhhN2CGKhiUIbiiKS1jDef+oSmxCQpbuTnXS5/M8/XTXraVPKkmfvnVv3SuqijHGmPAV4XUAxhhjvGWJwBhjwpwlAmOMCXOWCIwxJsxZIjDGmDBXw+sAKuK0007TuLg4r8MwxpgqZfXq1d+pakzR8iqZCOLi4sjKyvI6DGOMqVJEJLe4crs0ZIwxYc4SgTHGhDlLBMYYE+YsERhjTJizRGCMMWEuIIlARJ4XkW9FZFMJ60VEnhSRHBHZICLn+awbKSKfu4+RgYjHGGNM2QWqRvAC0P8E6wcALdxHEvAsgIjUByYCnYFOwEQRqRegmIwxxpRBQBKBqr4H7D3BJoOBF9WRAfxORBoB/YClqrpXVX8AlnLihOK37OxsbOhtY4z5TWW1EZwJfOGzvMstK6n8OCKSJCJZIpK1Z8+eCgWRk5ND+/btufTSS/niiy9K38EYY8JAlWksVtUUVU1U1cSYmOPukC6TZs2a8cgjj7By5Upat27Ns88+y9GjRwMcqTHGVC2VlQh2A018lhu7ZSWVB0VkZCR//vOf2bRpE507d+a2226jT58+HDlyJCjvl7YxjbjH44j4RwRxj8eRtjEtKO9jjDH+qKxEsAC43u091AXYp6pfAelAXxGp5zYS93XLgqpZs2YsWbKE559/np49e1KjhjPkUiDbDtI2ppG0MIncfbkoSu6+XJIWJlkyMMaEnEB1H30F+BBoKSK7RGSUiIwRkTHuJm8D24Ac4DngNgBV3Qs8CGS6j0luWdCJCDfeeCN///vfAXj33Xfp3LkzGzZsCMjxk5cnk3c475iyvMN5JC9PDsjxjamqrKYcegIy+qiqDi9lvQJjS1j3PPB8IOLwx/79+8nNzaVDhw5MmDCB5ORkatWqVeHj7dy3s1zlxoSDgppywZekgpoywIhzR3gZWlirMo3FwTZw4ECys7O55pprePDBB2nfvj0ZGRkVPl7Tuk3LVW5MOLCacmiyROCjQYMGzJw5k7fffptffvmFzMzMCh9rcu/JRNeMPqYsumY0k3tP9jdMY6osqymHpio5MU2wDRgwgM2bNxMd7XyQz58/n5NPPpmLL764zMcoqOYmL09m576dNK3blMm9J1v114S1pnWbkrvv+LlRrKbsLamKd9kmJiZqZc1Qpqp069aNDz/8kJtuuonHHnuMevVsFAxjKqJoGwE4NeWUy1LsS1IlEJHVqppYtNwuDZVCRFixYgUTJkxg5syZJCQkMH/+fK/DMqZKGnHuCFIuSyG2biyCEFs31pJACLAaQTmsWbOGUaNGsW7dOjIyMujcuXOlx2CMMRVlNYIAOO+88/j444+ZN29eYRLYtGmTDWJXSaz/uTHBYYmgnGrWrMkVV1wBOIPYdejQgYEDB7Jzp/V6CCa7U9uY4LFE4If4+Hgee+wx3n//fVq3bs3TTz9tg9gFifU/NyZ4LBH4ISIigjvuuINNmzbRtWtXbr/9di666KKgDWIXzqz/uTHBY/cRBEBcXBzp6enMnDmTL774onAQu6NHjxIRYbk2EKz/uTHBY59SASIi3HDDDdx///0ArFixgo4dO7J27VqPI6se7E5tY4LHEkGQHDp0iC+//JKOHTvyt7/9jQMHDngdUpVm/c9NdRUKveHsPoIg+uGHH/jLX/7CjBkzaNmyJdOnT6dbt25eh2WMCRGVfae13UfggXr16vH888+Tnp7OgQMHWLdundchGWNCSKj0hrPG4krQt29fNm3aVDiI3euvv85JJ51Ev379PI7MGOOlUOkNF6gZyvqLyBYRyRGRe4tZP1VE1rmPz0TkR591+T7rFgQinlB08sknExERgary73//m/79+3PDDTewd2+lTMhmjAlBoTJvid+JQEQigaeBAUACMFxEEny3UdU7VbWdqrYDngJe91m9v2Cdqg7yN55QJyIsW7aM5ORkZs2aRUJCAvPmzfM6LGOMB0KlN1wgagSdgBxV3aaqh4DZwOATbD8ceCUA71tl1a5dm3/+859kZWXx+9//nqFDh/LRRx95HZYxppKFSm84v3sNichQoL+q3uwuXwd0VtXbi9k2FsgAGqtqvlt2BFgHHAGmqOobJbxPEpAE0LRp0w65ucffXFQVHTlyhLfeeoshQ4YAsGHDBs4991xExNvAjDHVTqj0GhoGzC1IAq5YN7BrgMdFpHlxO6pqiqomqmpiTExMZcRaKWrUqFGYBHJycujYsSP9+vVjx44dnsZljAkfgUgEu4EmPsuN3bLiDKPIZSFV3e0+bwNWAu0DEFOVFB8fz9SpU/nwww9p06YNTz75JPn5+aXvaIwxfghEIsgEWohIMxGJwvmwP673j4icA9QDPvQpqycitdzXpwHdgOwAxFQlRUREcNttt7F582YuvPBC/vznP9OrVy8bxM4YE1R+30egqkdE5HYgHYgEnlfVzSIyCchS1YKkMAyYrcc2SrQCponIUZykNEVVwzYRFGjatCmLFi0iLS2NnTt32iB2xpigsiEmqojly5czfvx4pk+fznnnned1OMaYKihUGotNBeXn5/PNN9/QqVMn7r33Xvbv3+91SMaYasISQRXRt29fNm/ezA033MDDDz9Mu3bteP/9970Oy1RRoTDipQkdlgiqkHr16pGamsqyZcs4fPgwGzZs8DokUwXZ/M+mKGsjqKJ+/fVX6tSpQ0REBPPmzaNOnToMHDjQ67BMFRD3eFyxs73F1o1lx7gdlR+QqTTWRlDNnHTSSYWD2D3++ONccsklXHfddXz33Xdeh2ZCXKiMeGlChyWCKq5gELv777+f2bNnk5CQwGuvvUZVrOmZyhEqI16a0GGJoBqoVasWkyZNYvXq1cTGxnL11VfbIHamRKEy4qUJHZYIqpG2bdvy4YcfsmDBArp06QLAunXrrHZgjhEqI16a0GGNxdVYTk4OCQkJdO/eneeee474+HivQzLGeMgai8NQfHw8Tz31FJmZmZx77rk8/vjjNoidCUl2X4O3LBFUYxEREdxyyy1kZ2fTq1cv7rzzTnr06GGD2JmQYvc1eM8SQRho3LgxCxcuJC0tjUsuueSYQeyM8Vry8mTyDucdU5Z3OI/k5ckeRRR+LBGECRHhmmuuYcKECYAziF379u3JzMz0ODIT7uy+Bu9ZIghTqsr3339Ply5d+Otf/0peXl7pOxkTBHZfg/csEYSpPn36sHnzZm6++WYee+wx2rZty3//+1+vwzJhyO5r8J4lgjBWt25dpk2bxooVKwDIzg77OYGMB+y+Bu8F5D4CEekPPIEzQ1mqqk4psv4G4FF+m8v4P6qa6q4bCdznlv9TVWeW9n52H0Hg5eXlUbt2bSIiIpg7dy61a9fm0ksv9TosY0wABe0+AhGJBJ4GBgAJwHARSShm01dVtZ37KEgC9YGJQGegEzBRROr5G5Mpv+jo6MJB7J588kkuu+wyRowYwZ49e7wOzRgTZIG4NNQJyFHVbap6CJgNDC7jvv2Apaq6V1V/AJYC/QMQk6mggkHsHnjgAebMmUNCQgKzZ8+2YSqMqcYCkQjOBL7wWd7llhV1pYhsEJG5ItKknPsiIkkikiUiWfYtNbiioqKYOHEia9asIT4+nuHDh9sgdsZUY5XVWLwQiFPVtjjf+kttByhKVVNUNVFVE2NiYgIeoDlemzZtWLVqFW+99VbhIHZr1qyx2oEx1UwgEsFuoInPcmN+axQGQFW/V9WD7mIq0KGs+xpvRUZGcskllwDOIHZdunShd+/e5OTkeByZMSZQApEIMoEWItJMRKKAYcAC3w1EpJHP4iDgE/d1OtBXROq5jcR93TITgpo3b87TTz/N6tWradu2Lf/6179s3CJjqgG/E4GqHgFux/kA/wR4TVU3i8gkERnkbvYnEdksIuuBPwE3uPvuBR7ESSaZwCS3zPjatw8+/9x57NvnWRgiwujRo8nOzubiiy9m/PjxXHjhhZYMjKnibD6CUJWfD++8A888A4sXQ8HvSQQGDIDbboP+/SEy0pPwVJU5c+awfft27rnnHjfkfCI9iscYU7qS7iOwRBCKdu2CQYNg7VpnuWZNaOI2pXzxBRw+7Lxu1w4WLoTGjT0J09eyZcu48847SU1NpXPnzl6HY4wphk1MU1V8+SV06+YkgSZN4JFHnLKtW53Hl186ZU2awLp1zra7K9C+vmePU9v429/gnnvg0UedS08VJCL8+OOPdO3albvuuotff/21wscypjLYZDg+VLXKPTp06KDV0tGjql27qoJq586q331X8rbff+9sA6pdujj7lsWmTarXXacaFeXsW/TRt6/qkiUVCn/fvn166623KqDx8fG6YsWKCh3HmGCbtWGWRk+OVh6g8BE9OVpnbZjldWhBBWRpMZ+pViMIJatWwYcfQkwMvPUWNGhQ8rb16zvbxMRARgb873+lH3/RIujUCV56ybm8NHAgPPggPPQQXH891K4NS5ZA374wZUrpxyvi1FNP5ZlnnmHlypVERkby6aeflvsYxlQGmwznWJYIQskzzzjPo0fDaacVFqelQVwcREQ4z2kFNdjTTnO29d23JO+9B1dcAXl5cM01zmWmRYvgvvtgwgSYOdO5xDRxotMgPWECPPVUhX6MHj16sH79em655RYAXnvtNRYsWFDKXsZUHpsM51iWCEKFKsyf77xOSiosTktzFnNznU1yc53lwmTgftjy+uu/9Swq6uhRuPFGOHQIxo6FWbOgWbPjt6tfHx54AGbMcJbvuqti7Q9AnTp1Cgexe+aZZxg8eDDDhg3j22+/rdDxjAkkmwznWJYIQsWvv8L+/VCnDsTGFhYnJztf4n3l5TnlADRtCtHRcPAg/PJL8cdOT4dt25zqxBNPON/4T2TkSLjySjhyBFJTK/wjgdOIvGTJEh588EHmz59Pq1atmDVrlg1TYTxlk+EcyxJBqCjof5+ff8w3+50l1FSPKc/Pd57dSemP8+yzzvOYMcfcd1DiJSdwag4AKSm/Hb+CoqKiuO+++1i7di0tW7bkuuuuIyMjw69jGuMPmwyniOJakEP9UW17DTVo4PTcWb26sCg2tvjOPbGx7gZr1zoF9eqVfNyGDZ1ttm8vLJo1SzU6+thjRkc75arq9EKKiXFW7NwZsB/xyJEj+vbbbxcuZ2Zman5+fsCOb4wpGdZrqAq47jrnueAbPDB5snPlx1d0tFMOwNNPO8/XX1/ycX/+2XmuX7+wqNRLTiK/bV+wfwBERkYyYMAAwBnE7vzzz6dXr1587sc9DMYY/1giCCVjxjjPaWmwaRMAI0Y4V2diY53P5thYZ3nECJxtCq7n3Hprycc9+WTn+YcfCotKveSk+tv2p5xSsZ+nFM2bN2fatGls2LCBtm3b8sgjj9i4RcZ4wBJBKGnZEq691mk07tcP1q8HnA/9HTuczj87drhJYMMGZ5v9+53uoC1blnzcDu6o33PmFBY1LaFzRGH5++/Dt99Cw4bQqFHxG/tJRLjxxhvJzs5mwIAB3HPPPXTv3t2SgTGVzBJBqElJgZ49naEkOnSAq66C5cvh++9h715YscIpO+88Z5sePUrv2VNQW3j22cKG3zJfcho9uuRG6ABp1KgR8+bNY86cOVxxxRXUcN8v389GamNMGRXXcBDqj2rbWFxg/37Vm29WjYwsvqUYnHWjRjnblubIEdW4OGe/O+8sHI5i1iyn0VnEeS5sKH755d/e44svgvVTntCSJUu0VatWumrVKk/e35jqCGssrkJq14bnnnPuHnvgATjnHKhb13m0bOmU5eY6NYHatUs/XmQkTJ/ujGI6dSrcdBPs2nX8JadL9znDTVx7rbPfI494NrJpjRo1+PXXX+nWrRvjxo3jl5LukTCmGDagXPkEZBhqEekPPAFEAqmqOqXI+ruAm4EjwB7gJlXNddflAxvdTXeq6iBKUe2HoQ6WN96A4cPhwAEnOVx2GXTt6rz+9FN45RXnxjaAf/wD7r+/9JvPgujnn39mwoQJPP3008TFxZGamkrv3r09i8dUDWkb00hamHTMWELRNaPD+z4BV9DmIxCRSOAz4GJgF85MY8NVNdtnm17AR6qaJyK3Aj1V9Wp33S+qenJ53tMSgR/WrXMGlJs3z7lzuKheveAvfwF3nuJQ8P7773PzzTdz1113FY5fZExJ4h6PI3df7nHlsXVj2TFuR+UHFEJKSgSBaAXsBOSo6jb3jWYDg4HCRKCq7/psnwFcG4D3NRXRrh3Mng1ff+0879rlNCDHxMCQIZCQ4HWEx+nevTvr168nKioKgNmzZxMVFcUVV1zhcWQmFNmAcuUXiERwJvCFz/Iu4ERTVI0CFvss1xaRLJzLRlNU9Y3idhKRJCAJoGlJfR9N2TVsCOPGeR1FmdV220JUlZSUFN59912GDh3KU089RcOGDT2OzoSSpnWbFlsjCNcB5cqiUhuLReRaIBF41Kc41q2qXAM8LiLNi9tXVVNUNVFVE2NiYiohWhOKRIT09HQeeughFi5cSEJCAi+++KINYmcK2YBy5ReIRLAbaOKz3NgtO4aI9AGSgUGqerCgXFV3u8/bgJVA+wDEZKqxmjVrMmHCBNatW0erVq0YOXIkH330kddhmRBhA8qVXyAai2vgNBb3xkkAmcA1qrrZZ5v2wFygv6p+7lNeD8hT1YMichrwITDYt6G5ONZYbAocPXqUpUuX0q9fPwA+/vhjEhMTiYiwntHGFBW0yetV9QhwO5AOfAK8pqqbRWSSiBR0BX0UOBmYIyLrRKRguqpWQJaIrAfexWkjOGESMMZXREREYRLIycmhW7du9OjRgy1btngcmTFVR0DuI6hsViMwxVFVXnzxRe68807y8vKYOHEi48ePp2bNml6HZkxICFqNwJhQISKMHDmS7OxsLr30Uv72t7/RrVs3G8TOmFIEdzQxYzzQsGFD5s6dy7x589i+fXvhIHZHjhwpfG2M+Y3VCEy1deWVVzJ+/HgAlixZwrnnnsv//vc/j6MyJvRYIjBhoVatWhw4cIDu3btzxx138HMAZ10zpqqzRGDCQo8ePdi4cSN33HEHTz/9NG3atGHp0qVeh2VMSLBEYMLGySefzBNPPMEHH3xAdHQ027Zt8zokY0KCtZyZsHP++eezbt26wm6lr7zyCjVr1mTo0KEeR2aMN6xGYMJSrVq1iIiIQFVJTU3lqquu4sorr+Srr77yOjRjKp0lAhPWCgaxmzJlCosWLSIhIYEZM2bYIHYmrFgiMGGvRo0a3HPPPWzYsIFzzz2Xm266iYyMDK/DMqbSWCIwxnX22WezcuVKlixZQteuXQHIyMggPz/f48iMCS5LBMb4iIiI4OKLLwZg69atdO/ene7du/PJJ594HJkxwWOJwJgSxMfHM2PGDLZs2UK7du2YPHkyhw8f9josYwLOEoExJRARrr32Wj755BOGDBnCfffdx/nnn2+D2Jlqx+4jMKYUp59+Oq+++irDhw8/ZhC7w4cP2xDXplqwGoExZTRkyBDuvPNOANLT02nTpg3vvfeex1EZ47+AJAIR6S8iW0QkR0TuLWZ9LRF51V3/kYjE+ayb4JZvEZF+gYjHmGCrU6cOhw8fpkePHowdO5affvrJ65CMqTC/E4GIRAJPAwOABGC4iCQU2WwU8IOqngVMBR52900AhgGtgf7AM+7xjAlpF154IRs3bmTcuHE8++yztGnThvT0dK/DMqZCAlEj6ATkqOo2VT0EzAYGF9lmMDDTfT0X6C0i4pbPVtWDqrodyHGPZ0zIO+mkk5g6dSqrVq3ilFNOYefOnV6HZEyFBKKx+EzgC5/lXUDnkrZR1SMisg9o4JZnFNn3zOLeRESSgCSApk2bBiBsYwKjS5curFmzhqioKADS0tKoUaMGf/zjH3G+7xgT2qpMY7GqpqhqoqomxsTEeB2OMceoVasWIoKq8sILLzBs2DAuv/xyvvzyS69DM6ZUgUgEu4EmPsuN3bJitxGRGkBd4Psy7hsW0tIgLg4iIpzntDSvIzIVISIsXryYRx99lPT0dBISEkhNTbVB7ExIC0QiyARaiEgzEYnCafxdUGSbBcBI9/VQYIU6/xkLgGFur6JmQAvg4wDEVKWkpUFSEuTmgqrznJRkyaCqqlGjBuPHj2fjxo20a9eO0aNH2yB2JqT5nQhU9QhwO5AOfAK8pqqbRWSSiAxyN5sONBCRHOAu4F53383Aa0A28A4wVlXDboSv5GTIyzu2LC/PKTdV11lnncWKFStYvnx54SB2q1atskHsTMiRqlhlTUxM1KysLK/DCJiICKcmUJQIHD1a+fGY4Ni6dSvnnHMOHTp0YPr06bRu3drrkEyYEZHVqppYtLzKNBZXZyV1grLOUdVLfHw8L774Ilu3bqV9+/ZMmjSJQ4cOeR2WMZYIQsHAgc63f1/R0TB5sjfxmOAQEYYPH052djZDhw5l4sSJdO3a1UY0NZ6zQec8lpYGM2cee2lIBEaOhBEjvIvLBE9MTAwvv/wyw4cPZ+vWrYUD19kgdsYrViPwWHENxarw9tvexGMqz2WXXca4ceMAWLx4Ma1atWLlypWexhQq0jamEfd4HBH/iCDu8TjSNloXumCyROCxkkYlsNEKwsspp5wCQK9evbjlllvYt2+fxxF5J21jGkkLk8jdl4ui5O7LJWlhkiWDILJE4DFrKDYAF1xwARs2bGD8+PGkpqbSunVrFi9e7HVYnkhenkze4WOryXmH80hebv2pg8USgccmT3Yahn1ZQ3F4io6O5tFHHyUjI4P69euze3dY3mTPzn3FV4dLKjf+s8ZijxU0CCcnO5eDmjZ1koA1FIevjh07kpWVVdhwPGvWLCIjIxk2bFhYDGLXtG5TcvflFltugsNqBCFgxAjYscO5eWzHDksCBqKiogoHsXvppZe45pprGDRoELt27fI6tKCb3Hsy0TWPrSZH14xmcm+rJgeLJQJjQpiI8Pbbb/Pvf/+b5cuX07p1a1JSUjhajW85H3HuCFIuSyG2biyCEFs3lpTLUhhxrn1DChYbYsKYKmLr1q2MHj2ad999l1WrVhWOX2RMWZU0xIS1EZjKpQqZmbBtGxw6BA0awAUXQN26XkcW8po3b87y5cv573//W5gEPvjgA7p06UKNGvavbCrO/npM5fj1V3jhBXjmGcjOPnbdSSfBtdfC7bdDmzaehFdViAg9e/YEnBpCr169aNeuHdOnT6dt27beBmeqLGsjMMGXmwudOjkf9NnZ0LAhXHWV0yp+/vlOkpg2Ddq1g+ee8zraKiM+Pp60tDRyc3Pp0KEDEydO5ODBg16HZaogayMwwfXNN9C1K2zfDuecA5MmwZAh4DumTnY2TJ0KqanO8vTpcNNNnoRbFX3//feMGzeOWbNm0a5dOz7++OOqM2bR0aOQkwN790JUlNN/+rTTvI6q2rJhqI03br3VSQKJifDhh05NoOiHVEKCUxN48kln+ZZbnH60pkwaNGjASy+9xKJFi7jxxhsLk0BID3G9dy/8619w9tnQsqXzZaFDB6e2eOWVsHx58ZN0mOBQ1Qo/gPrAUuBz97leMdu0Az4ENgMbgKt91r0AbAfWuY92ZXnfDh06qKkCduxQjYhQrVlTddeusu0zbJgqqN57b3Bjq+YWLVqk8fHxumzZMq9DOV56uuqppzq/Z1A94wzVjh1V27ZVrVHjt/L+/VX37fM62moFyNJiPlP9rRHcCyxX1RbAcne5qDzgelVtDfQHHheR3/ms/6uqtnMf6/yMx4SSlBSn6n/VVXDmmYXFaWkQF+fMzBYXV2Ru5j/9yXlOTQW73l1hdevWJTIykj59+jB69Gh+/PFHr0NyvPMOXHIJ/PQT9OwJCxbA7t3w8cewfr1ze/2kSU5vsnfegX79jh+e1wRecdmhrA9gC9DIfd0I2FKGfdYDLfS3GsHQ8r6v1QiqiC5dnG926emFRbNmqUZH//alD5zlWbPcDY4eVT37bGdFZqY3cVcTeXl5evfdd2tERIQ2atRI33rrLW8D+vpr1VNOcX6348ap5ueXvG1OjmrTps62Y8ZUXozVHEGqEZyhql+5r78GzjjRxiLSCYgCtvoUTxaRDSIyVURqnWDfJBHJEpGsPXv2+Bm2qRQ//OA8N25cWFTc/At5eU454MzKU1B7CJVvsVVUnTp1ePjhh/noo4+IiYnh66+/9jag1FT4+Wfo29dpH4g4wcdP8+awcKHz+oUXnDYFEzSlJgIRWSYim4p5DPbdzs02JbbuiEgj4CXgRlUtuD9+AnAO0BGnveGekvZX1RRVTVTVxJiYmNJ/MuO9OnWcZ59P/jLNv1CwfcH+xi+JiYlkZWVxk9sT68UXX2TWrFkFNfTKceSI00UYYPz4Y5JAiZPQtG3rXBo6cMBJBiZoSk0EqtpHVdsU83gT+Mb9gC/4oP+2uGOIyKnAIiBZVTN8jv2VW2M5CMwAOgXihzIhomVL59lnXP1S51/4+mtYs8b5oGjePLjxhZGaNWsWDmL38ssvc91113HJJZews7JmQFq/Hr74wmkU6t27sLjUSWhGj3aeFyyonDjDlL+XhhYAI93XI4E3i24gIlHAfOBFVZ1bZF1BEhFgCLDJz3hMKCn4J542zflGSBnmX5g+HQ4fhkGDnK6EJqBEhEWLFvHEE0/w3//+l9atW/Pss88GfxC77793nps3P6Y2UOokNC1aOM/ffRfc+MKcv4lgCnCxiHwO9HGXEZFEEXHvDuKPwIXADSKyzn20c9elichGYCNwGvBPP+MxoeSii5xawe7dTk8QnJuJU1IgNtZpDoiNdZZHjAA+/dS5dgxw223exV3NRUZG8qc//YlNmzbRtWtXbrvtNj766KPgvmnBWEjuF4ICpU5Cc/iw81xVbpCrovwaa0hVvwd6F1OeBdzsvp4FzCph/4v8eX8T4kScO4YvvRQefND5p77/fkaMiD5+zoX334c//tFpYB40CPr08STkcNKsWTPS09P54IMPCgexe++99zj//PMDP4hdbKzzvGYN/PILnHwyUIZJaN5//9j9TVDYncUmuAYMgOefh8hImDLF6UH0l7/AW2/B0qXOZaOOHeHCC532gYsugpdfdpKICToRoXv37oAziN1FF11E586dWb9+fWDfqHlzZ5TZn38+5saRE05Cc/SoM0ghwA03BDYec6zi+pSG+sPuI6iCli1T7dTp2BsIfB/16qlOmKB68KDXkYato0eP6pw5c/T000/XGjVq6H333acHDhwI3Bu88orzu46LU/3228LiWRtmaezUWJUHRGOnxuqsDe5NJdOmOds3bqx6+HDg4ghjlHAfgQ06ZypXVpZTQ9ixw7lzuH59GDgQhg2z7qIhYu/evdx1113MnDmTP/zhD2RmZgZmELtDh5wxhdasgT/8wakV+txjUkjV+Ru55RbIz4cZM6xGECA2MY0JDYmJzsOErPr16/PCCy8wfPhwPvvss8IkcPDgQWrVKvGez9JFRTkf/j16ON1JzzrLaRcaNQqaNXO+GCxf7lwO2rjR2WfiREsClcBqBMaYUi1atIixY8eSkpJC3759/TvYd99BUhK88UbJI4yefrrTp/jmm/17L3MMG4baGFNhDRo0oHbt2vTr148bb7yRHwqGD6mI006D11+HrVvh7rudO4jPPBPi453eYi+/7Nxqbkmg0liNwBhTJgcOHGDSpEk88sgjxMTEMG3aNAYNGuR1WKYcrEZgjPFL7dq1eeihh8jMzKRhw4Z8Z3f7VhvWWGyMKZf27dvz8ccfF950NnPmTACuv/56xO7/qJKsRmCMKTffQexee+01brjhBgYMGEBu7vF3CZvQZ4nAGFNhIsLChQt56qmn+OCDD2jdujX/+c9/gj+InQkoSwTGGL9ERERw++23s3nzZi644ALuuOOO4A9iZwLKEoExJiBiY2NZvHjxMYPYrVy5ksMFI4iakGWJwBgTMCJCt27dANi2bRt9+vShU6dOrF271uPIzIlYIjDGBEV8fDxz5szh66+/pmPHjkyYMIEDBw54HZYphl+JQETqi8hSEfncfa5Xwnb5PpPSLPApbyYiH4lIjoi86s5mZoypJi6//HKys7MZOXIkU6ZMoVOnTnapKAT5WyO4F1iuqi2A5e5ycfarajv34Xsr4sPAVFU9C/gBGOVnPMaYEFOvXj2mT5/O0qVLGTNmTOEgdlY7CB3+JoLBwEz39UyceYfLxJ2n+CKgYB7jcu1vjKla+vTpw23uFKRvvfUWLVu2JD093eOoDPifCM5Q1a/c118DZ5SwXW0RyRKRDBEZ4pY1AH5U1YJJTHcBZ5b0RiKS5B4ja8+ePX6GbYzxUkxMDNHR0fTv35+RI0eyd+9er0MKa6UmAhFZJiKbinkM9t3Onf2mpBHsYt2Bjq4BHheR5uUNVFVTVDVRVRNjYmLKu7sxJoR07tyZtWvXct999/Hyyy/TqlUr3nzzTa/DClulJgJV7aOqbYp5vAl8IyKNANznb0s4xm73eRuwEmgPfA/8TkQKxjtqDOz2+ycyppzS0iAuDiIinGefKXVNENWuXZsHH3yQrKwsmjRpYrUCD/k76NwCYCQwxX0+LqW7PYnyVPWgiJwGdAMeUVUVkXeBocDskvY3JpjS0pw5UvLynOXcXGcZYMQI7+IKJ3/4wx/IyMggMjISgBkzZqCq3HjjjTaIXSXxt41gCnCxiHwO9HGXEZFEEUl1t2kFZInIeuBdYIqqZrvr7gHuEpEcnDaD6X7GY0y5JCf/lgQK5OU55aby1KhRo3AQu9dff51Ro0bRt29ftm/f7nVoYcEmpjFhLSKi+NkSRcDGTfPG0aNHSUlJ4e677yY/P5+HHnqI22+/vbDGYCrOJqYxphhNm5av3ARfREQEY8aMYfPmzfTo0YNx48bx8ccfex1WtWaJwIS1yZMhOvrYsuhop9x4q0mTJixatIhVq1YVDmK3YsUKuzM5CCwRmLA2YgSkpEBsrHM5KDbWWbaGYu+lpUGzZkK3bl2Ji4OpU7fRt29fEhMTWb16tdfhVSuWCEzYGzECduxw2gR27Dg+CVj30spX0JsrN9dpw8nNhfvui+dPf5rHnj176NSpE/fccw/79+/3OtRqwRKBMSdQ3AdSUpIlg2ArqTfX668PJjs7m5tuuolHHnmEjh072qWiALBeQ8acQFyc8+FfVGysU3swwVGW3lzLly/ns88+49ZbbwVg//791KlTpxKjrHqs15AxFbBzZ/nKTWCUpTdX7969C5PAwoULOfvss1m0aFElRFf9WCIw5gSse6k3ytubq2HDhtStW5dLL72Ua6+9lu+++y74QVYjlgiMOQHrXuqN8vbm6tixI2vWrGHixIm8+uqrtGrVitdff71yg67CLBEYcwLWvdQ7pfXmKioqKooHHniANWvWEBcXx08//VQZYVYL1lhsjKl28vPziYiIQESYMWMGR44c4eabbw77QeyssdgYEzYiIyMLB7F74403SEpKok+fPmzbts3r0EKSJQJjTLUlIsyfP59p06aRlZVFmzZtmDp1Kvn5+V6HFlIsERhjqrWIiAiSkpLYvHkzvXv35q677rJB7IqwRGCMCQuNGzdmwYIFZGRkFA5it2zZMg4dOuRxZN6zRGCMCRsiQufOnQHYtm0b/fv3p0OHDmFfQ/ArEYhIfRFZKiKfu8/1itmml4is83kcEJEh7roXRGS7z7p2/sRjjDFlFR8fzxtvvMEPP/xA165dGT9+PHlFBzgKE/7WCO4FlqtqC2C5u3wMVX1XVdupajvgIiAPWOKzyV8L1qvqOj/jMcaYMrv00kvZvHkzo0eP5l//+lfYDmLn7+T1g4Ge7uuZwEqceYhLMhRYrKrhmXaNMSGnbt26/N///R/Dhg1jy5Yt1KxZEwivQez8rRGcoapfua+/Bs4oZfthwCtFyiaLyAYRmSoitUraUUSSRCRLRLL27NnjR8jGGHO8nj17cssttwCwYMECWrRowcKFCz2OqnKUmghEZJmIbCrmMdh3O3VuUS7xNmURaQScC6T7FE8AzgE6AvU5QW1CVVNUNVFVE2NiYkoL2xhjKuzMM8+kfv36DBo0iGuuuYbq/uWz1ESgqn1UtU0xjzeBb9wP+IIP+m9PcKg/AvNVtfACnKp+pY6DwAygk38/jjHG+K9Dhw5kZWXxj3/8g7lz59KqVSvmzZvndVhB4++loQXASPf1SODNE2w7nCKXhXySiABDgE1+xmOMMQERFRXF3//+d9auXctZZ53FL7/84nVIQePXoHMi0gB4DWgK5AJ/VNW9IpIIjFHVm93t4oD/AU1U9ajP/iuAGECAde4+pZ5tG3TOGFOZfAexS01N5ciRIyQlJRERUbVuxSpp0DkbfdQYY8pIVbn88st588036dGjB8899xwtWrTwOqwys9FHjTHGTwWD2KWmprJu3Tratm3Lo48+ypEjR7wOzS+WCIwxphxEhFGjRpGdnU2/fv24++67yczM9Dosv1giMMaYCvj973/P/PnzyczMLBzEbsmSJRw8eNDjyMrPEoExISItDeLiICLCeU5L8zoiUxoRITHRueS+fft2Bg4cyHnnnUdGRobHkZWPJQJjQkBaGiQlQW4uqDrPSUmWDKqSZs2asXDhQn7++WfOP/987rzzTn799VevwyoT6zVkTAiIi3M+/IuKjXUmbjdVx08//cS9997Ls88+yznnnMOGDRsKxy/yWkm9hvwddM4YEwA7d5av3ISuU089lWeeeYZhw4bx6aefFiaBvLw8oqOjPY6ueHZpyJgTqKzr9k2blq/chL4LL7yQpKQkAN58803OOuss3nzzRIMveMcSgTElqMzr9pMnQ9Evi9HRTrmp+po2bcrpp5/OkCFDuPrqq/nmm2+8DukYlgiMKUFyMhSdsCovzykPtBEjICXFaRMQcZ5TUpxyU/W1b9+ezMxM/vnPf/LGG2+QkJDAnDlzvA6rkCUCY0pQ2dftR4xwGoaPHnWeLQlULzVr1iQ5OZl169bRsmVLDhw44HVIhayx2JgSNG1afE8eu25v/NGqVSs++OADnEGXITU1lUOHDjFmzBjPBrGzGoExJbDr9iZYCkYyVVUWL17M2LFj6dmzJ5999pk38XjyrsZUAXbd3gSbiDB37lxmzJjBxo0badu2LQ8//HClD2JnN5QZY0wI+Oqrrxg7dizz589n1apVheMXBZINQ22MMSGsUaNGvP7666xevbowCbzzzjuV0qjsVyIQkatEZLOIHHVnJStpu/4iskVEckTkXp/yZiLykVv+qohE+ROPMcZUdeeddx7gDGJ3ySWX0L59e1atWhXU9/S3RrAJuAJ4r6QNRCQSeBoYACQAw0UkwV39MDBVVc8CfgBG+RmPMcZUC82aNePtt98mLy+PCy64gD//+c9BmzfZr0Sgqp+o6pZSNusE5KjqNlU9BMwGBrsT1l8EzHW3m4kzgb0xxhigX79+bNq0ibFjx/LUU0/x17/+NSjvUxn3EZwJfOGzvAvoDDQAflTVIz7lZ5Z0EBFJApLAuV3bGGPCwSmnnMJTTz3F1VdfTfPmzYPyHqUmAhFZBjQsZlWyqlbaCEqqmgKkgNNrqLLe1xhjQsEFF1wQtGOXmghUtY+f77EbaOKz3Ngt+x74nYjUcGsFBeXGGGMqUWV0H80EWrg9hKKAYcACdW5geBcY6m43EgjNMVqNMaYa87f76OUisgvoCiwSkXS3/Pci8jaA+23/diAd+AR4TVU3u4e4B7hLRHJw2gym+xOPMcaY8rM7i40xJkzYncXGGGOKZYnAGGPCnCUCY4wJc5YIjDEmzFXJxmIR2QMUM3dUmZwGfBfAcALF4iofi6t8LK7yqa5xxapqTNHCKpkI/CEiWcW1mnvN4iofi6t8LK7yCbe47NKQMcaEOUsExhgT5sIxEaR4HUAJLK7ysbjKx+Iqn7CKK+zaCIwxxhwrHGsExhhjfFgiMMaYMFctE4GIXCUim0XkqIiU2NVKRPqLyBYRyRGRe33Km4nIR275q+7w2YGIq76ILBWRz93nesVs00tE1vk8DojIEHfdCyKy3Wddu8qKy90u3+e9F/iUe3m+2onIh+7ve4OIXO2zLqDnq6S/F5/1tdyfP8c9H3E+6ya45VtEpJ8/cVQgrrtEJNs9P8tFJNZnXbG/00qK6wYR2ePz/jf7rBvp/t4/F5GRlRzXVJ+YPhORH33WBeV8icjzIvKtiGwqYb2IyJNuzBtE5Dyfdf6fK1Wtdg+gFdASWAkklrBNJLAViAeigPVAgrvuNWCY+/r/gFsDFNcjwL3u63uBh0vZvj6wF4h2l18AhgbhfJUpLuCXEso9O1/A2UAL9/Xvga+A3wX6fJ3o78Vnm9uA/3NfDwNedV8nuNvXApq5x4msxLh6+fwN3VoQ14l+p5UU1w3Af4rZtz6wzX2u576uV1lxFdn+DuD5SjhfFwLnAZtKWD8QWAwI0AX4KJDnqlrWCFT1E1XdUspmnYAcVd2mqoeA2cBgERHgImCuu91MYEiAQhvsHq+sxx0KLFbVvAC9f0nKG1chr8+Xqn6mqp+7r78EvgWOu3MyAIr9ezlBvHOB3u75GQzMVtWDqrodyHGPVylxqeq7Pn9DGTizAQZbWc5XSfoBS1V1r6r+ACwF+nsU13DglQC9d4lU9T2cL30lGQy8qI4MnNkdGxGgc1UtE0EZnQl84bO8yy1rAPyozoQ6vuWBcIaqfuW+/ho4o5Tth3H8H+Fkt2o4VURqVXJctUUkS0QyCi5XEULnS0Q64XzL2+pTHKjzVdLfS7HbuOdjH875Kcu+wYzL1yicb5YFivudVmZcV7q/n7kiUjClbUicL/cSWjNghU9xsM5XaUqKOyDnqtQ5i0OViCwDGhazKllVPZvy8kRx+S6oqopIiX133Wx/Ls7MbgUm4HwgRuH0J74HmFSJccWq6m4RiQdWiMhGnA+7Cgvw+XoJGKmqR93iCp+v6khErgUSgR4+xcf9TlV1a/FHCLiFwCuqelBEbsGpTV1USe9dFsOAuaqa71Pm5fkKmiqbCFS1j5+H2A008Vlu7JZ9j1PtquF+qyso9zsuEflGRBqp6lfuB9e3JzjUH4H5qnrY59gF344PisgMYHxlxqWqu93nbSKyEmgPzMPj8yUipwKLcL4EZPgcu8Lnqxgl/b0Ut80uEakB1MX5eyrLvsGMCxHpg5Nce6jqwYLyEn6ngfhgKzUuVf3eZzEVp02oYN+eRfZdGYCYyhSXj2HAWN+CIJ6v0pQUd0DOVThfGsoEWojT4yUK55e+QJ0WmHdxrs8DjAQCVcNY4B6vLMc97tqk+2FYcF1+CFBsD4NgxCUi9QourYjIaUA3INvr8+X+7ubjXD+dW2RdIM9XsX8vJ4h3KLDCPT8LgGHi9CpqBrQAPvYjlnLFJSLtgWnAIFX91qe82N9pJcbVyGdxEM6c5uDUgvu68dUD+nJszTiocbmxnYPT+PqhT1kwz1dpFgDXu72HugD73C86gTlXwWgB9/oBXI5zrewg8A2Q7pb/HnjbZ7uBwGc4GT3Zpzwe5x81B5gD1ApQXA2A5cDnwDKgvlueCKT6bBeHk+kjiuy/AtiI84E2Czi5suICznffe737PCoUzhdwLXAYWOfzaBeM81Xc3wvOpaZB7uva7s+f456PeJ99k939tgADAvz3Xlpcy9z/g4Lzs6C032klxfX/gM3u+78LnOOz703uecwBbqzMuNzlB4ApRfYL2vnC+dL3lfu3vAunLWcMMMZdL8DTbswb8ekNGYhzZUNMGGNMmAvnS0PGGGOwRGCMMWHPEoExxoQ5SwTGGBPmLBEYY0yYs0RgjDFhzhKBMcaEuf8P0dphLUv6+d8AAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -672,7 +685,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 22, @@ -681,7 +694,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -744,7 +757,6 @@ "vqc = VQC(\n", " num_qubits=2,\n", " optimizer=COBYLA(maxiter=30),\n", - " quantum_instance=quantum_instance,\n", " callback=callback_graph,\n", ")" ] @@ -765,7 +777,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtEAAAGDCAYAAADtZ0xmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABatUlEQVR4nO3dd3hb5fn/8fct7z3ildgh00nIIoSwE1ZZAVrKKB10DwqF0n47vh2/7n67aEtboC0dUDoYZRUoYe8EwsjekxBixxlOvOJt6/n9ISkYx0O2Ne3P67p0STo6OueWjpXcenSf+zHnHCIiIiIiEjxPtAMQEREREYk3SqJFRERERAZISbSIiIiIyAApiRYRERERGSAl0SIiIiIiA6QkWkRERERkgJREi0ivzOwHZvavPh5fb2ZnhGG/4druJWa2y8wOmdmxod5+H/u90syeitT+gmFmd5jZ/0U7joEws8fN7BPDZT/9xHDIzCZGMwYR6ZuSaJERzMw+aWZrzazJzPaY2R/NLDfY5zvnZjjnXhhiDEckc6HYbi9+BVznnMt0zq0Mw/Yxs/Fm5swsMbDMOXenc+7ccOxvJHHOLXTO/X0o2/D/zS8Jdj/BrD9UZvaCmX22WwyZzrk3w7lfERkaJdEiI5SZfRX4BfB1IAc4CRgHPG1mydGMLYzGAeujHYSMHF2/TInI8KIkWmQEMrNs4IfAF51zTzjn2p1zbwFXAOOBj3ZZPdXM/m1mDWa2wsyO6bKdt8zsbP9tj5l908y2m9kBM7vXzPK7rDvfzF4xs1p/ScUnzewq4Ergf/0/X/+363bNbIyZNXfbzrFmVm1mSf77nzazjWZWY2ZPmtm4Hl5vipkdAhKA1Wa23b/cmdnkLusdHhU3szPMrMLMvmpm+8ysysw+1WXdNDP7tZntNLM6M1tiZmnAS/5Vav2v6eTuo5lmdoqZveF/3htmdkqXx14wsx+b2cv+9/wpMyvo5ThuNLOLutxPNLP9ZjbXf/8+/y8MdWb2kpnN6GU7R4y2dn1v/O/fr8zsbTPba2a3+l9rT9uaZGbP+f8Gqs3szq6/bpjZXDNb6X9t9/n/tgLveZ6ZPep/DTX+22Xd3pvPdo3ZH1eNme0ws4XdXtOb/v3sMF9JzdHArcDJ/mNT28treMHMPtvb+n29H13+br5hZnuAv/X1uszsJ8AC4Bb/Pm7p4f3PMbN/+J+/08y+Y2aeYN4HEQkfJdEiI9MpQCrwYNeFzrlDwGPAOV0WXwzcB+QDdwEPmT+B7eaLwPuB04ExQA3wewDzJbaPAzcDhcAcYJVz7s/AncAN/p+v39stnt3AUuCyLos/AtzvnGs3s4uBbwOX+re7GLi7e2DOuVbnXKb/7jHOuUm9vTHdlOAbpS8FPgP83szy/I/9CjgO33uZD/wv4AVO8z+e639NS7tu0HxfCBYBNwGjgBuBRWY2qttr/BRQBCQDX+slvruBD3e5fx5Q7Zxb4b//OFDu384KfO/1YPwcmILvuE3G9358r5d1DfgZvr+Bo4GxwA8AzPcLx3+AO/C9Z3cDl3R5rgf4G75fDI4CmoFb+ojrRGAzUADcANxmPhn43t+FzrksfMdolXNuI3A1sNR/bHL7etF9rN/f+1Hif33jgKv6el3Ouf+H7+82UGZ0XQ+h3Izv73Aivs/Xx/H9ffT5PvT12kRk6JREi4xMBfiSrY4eHqvyPx6w3Dl3v3OuHV/Cl4qv9KO7q4H/55yrcM614kucLjffz9kfAZ5xzt3tH/U+4JxbFWSsd+FPFP2JwYf8ywL7/JlzbqP/tfwUmGM9jEYPUjvwI3/MjwGHgKn+UcBPA19yzlU65zqdc6/4X3d/LgS2Ouf+6ZzrcM7dDWwCun6B+Jtzbotzrhm4F1+y1pO7gPeZWbr//kfo8iXCOXe7c66hy/E4xsxygn3xcPg9vwr4H+fcQedcA773+UM9re+c2+ace9r/xWU/vr+Z0/0PnwQkAjf539MHgde7PPeAc+4B51yTfz8/6fLcnux0zv3FOdcJ/B0YDRT7H/MCM80szTlX5ZwLSRlPkO+HF/i+/z1oHsTr6rq/BP+2v+U/lm8BvwY+1mW1vt4HEQkTJdEiI1M1UGA912uO9j8esCtwwznnBSrwjTJ2Nw74j/nKNWqBjUAnvv/MxwLbBxnrA/h+Th+Nb5TXi2/kLrDP33XZ50F8I6Glg9xXdwe6fdFoAjLxfclIZXCvaQyws9uynbw75j097PMIzrlt+N7n9/oT6ffh/4JhZglm9nPzldfUA2/5n9ZjaUgfCoF0YHmX9/kJ//IjmFmxmd1jZpX+/f6ryz7HAJXOOdflKbu6PDfdzP7kL1mox1cak+tPJHty+H1yzjX5b2Y65xqBD+L7klVlZovMbNoAX3dvgnk/9jvnWobwuroqAJJ4999Mr38vXd+HAbwmERkEJdEiI9NSoBVfGcRhZpYJLASe7bJ4bJfHPUAZsLuHbe7C9/N5bpdLqnOu0v9YbyUUrpflvgedqwGewpcUfQS4p0sStgv4fLd9pjnnXulrm1004UuIAkqCfF410ELPr6nP14Pvves+Un4UUBnkvrsLlHRcDGzwJ9bge68uBs7GVwow3r+8p5/5G+nyPphZ1/ehGl/5wYwu73FOl/KY7n6K7z2Y5ZzLxldfH9hnFVDardRgbJfbXwWmAif6nxsojRlwaYJz7knn3Dn4vhRuAv4SeGigm+p2P5j3o/tz+ntdfcVUje8Xka5/M0P5exGREFESLTICOefq8J1YeLOZnW9mSWY2Hl/pQAXwzy6rH2dml/pHrb+ML/l+tYfN3gr8JFBKYWaF/ppl8NXinm1mV5jv5LdRZjbH/9hefLWefbkLXx3o5bxTyhHY57fMf8Kc/wSsD/T/Dhy2CviIf9T2fIL8id0/In87cKP5Tn5MMN8JhCnAfnyj5b29pseAKWb2Ef978UFgOvDoAOLu6h7gXOAa3v3eZOE7VgfwJcg/7WMbq4EZZjbHzFLx1zDD4df6F+A3ZlYEYGalZnZeL9vKwlf2Umdmpfi6vwQsxffrxHX+134xcEK35zbjOykzH/h+Xy+8N/7R8Iv9tdGt/ni8/of3AmUWfAead60/iPcD+n9dvX4G/CUa9+L7bGX5P19fwTfCLyJRpCRaZIRyzt2A76S8XwH1wGv4Rnbf062292F8o8A1+OowL/XXR3f3O+AR4Ckza8CXaJ/o39fbwAX4RuQO4kteA10+bgOm+38af6iXcB/Bd4LcHufc6i6v4T/42vTd4/+ZfB2+kfRgfQlfLXItvi4hve2/J18D1gJv4HtNvwA8/p/TfwK87H9N76ofd84dAC7C914cwHdC4kXOua4lNEFzzlXhS05PAf7d5aF/4PvZvxLYQM9ffALb2AL8CHgG2Ap074v8DWAb8Kr/fX4G38hqT34IzAXq8J1AefjkVedcG75fPz6D7z3/KL4vD4G/t98CafhGX1/FVyYxGB58ieZufMfmdHxfMgCew9fmcI+ZBfOe97T+QN4P6P91/Q7f+QM1ZnZTD8//Ir5fC97Ed2zuwvclTkSiyN5dmiYiEjwzexv4qHPupX5XFumBmb0G3Oqc+1u0YxERGQiNRIvIoJhZIb6Tqd6KcigSR8zsdDMr8ZdzfAKYzeBHnEVEokYzKYnIgJnZ8cDTwM3+Ug2RYE3FV+Obga884XJ/SYqISFxROYeIiIiIyACpnENEREREZICURIuIiIiIDFDc1UQXFBS48ePHRzsMERERERnmli9fXu2c63GG1rhLosePH8+yZcuiHYaIiIiIDHNmtrO3x1TOISIiIiIyQEqiRUREREQGSEm0iIiIiMgAKYkWERERERkgJdEiIiIiIgOkJFpEREREZICURIuIiIiIDJCSaBERERGRAVISLSIiIiIyQEqiRUREREQGSEm0iIiIiMgAKYkeZrbvP0RbhzfaYYiIiIgMa0qih5GNVfWcfeOLfPSvr3HgUGu0wxEREREZtpREDyP/Xb0bjxmrKmq5+Pcvs3lPQ7RDEhERERmWlEQPE845Fq2t4pRJo7j38yfT2uHl0j+8zLMb90Y7NBEREZFhR0n0MLF+dz07DzRx0ezRzBmbyyPXncqEwgw++49l/OnF7Tjnoh2iiIiIyLChJHqYeHRNFYke49zpJQCMzknjvs+fwgUzR/OzxzfxtfvW0NrRGeUoRURERIaHxGgHIEPnK+XYzamTC8jLSD68PC05gZs/fCzlxZn89pmtvHWgkT997DgKMlOiGK2IiIhI/NNI9DCwtrKOXQebuXD26CMe83iML589hd9/ZC7rd9dx8S0vs7GqPgpRioiIiAwfSqKHgUVrqkhKMM7zl3L05MLZo7nv86fQ4fVy2R9f4an1eyIYoYiIiMjwoiQ6zjnneHRNFfMnF5CTntTnurPKcnjkuvmUF2Xy+X8t5/fPb9MJhyIiIiKDoCQ6zq2uqKOytpkLZ48Jav3i7FT+/fmTuWj2GH755Gb+59+raGnXCYciIiIiA6ETC+PcojW7SUowzpleHPRzUpMSuOlDc5hSlMmvn97CWwea+PPHj6MoKzWMkYqIiIgMHxqJjmPOORatqeK08kJy0vou5ejOzPjie8r545Vz2byngYtveZl1lXVhilRERERkeFESHcdW7qpld10LF8w6sitHsBbOGs19V5+MAR+4dSmPr60KXYAiIiIiw5SS6Di2aE0VyQkezh5AKUdPZpbm8NB1pzJtdBbX3LmCm57dqhMORURERPqgJDpOeb2Ox9ZWcdqUggGXcvSkKCuVuz93EpccW8qNT2/h+nt0wqGIiIhIb5REx6mVu2qoqmvpcYKVwUpNSuDGK47hf8+fyqNrdvPBPy1lb31LyLYvIiIiMlwoiY5Tj66pIjnRw9lHD62Uozsz4wtnTOZPHz2OrfsO8b5blrCmojak+xjpNu9pULmMiIhInFMSHYcCpRynTykkK3XopRw9OXdGCQ9ccwqJHg8fuHWpOneEyLZ9hzjvty/x8Krd0Q5FREREhkBJdBxa/nYNe+tbuSiEpRw9OXp0Ng9deyrOwcOrKsO6r5Fi+/5DADy6Rkm0iIhIPFMSHYcW+Us53hPiUo6eFGalcPyEPF7aUh32fY0EFTXNALy0pZqGlvYoRyMiIiKDpSQ6znT6SznOnFpIZkpkJpxcUF7I5r0NOskwBCr9SXRbp5fnNu2LcjQiIiIyWEqi48yytw6yr6GVC2ePidg+F5QXALB4q0ajh6qiponJRZkUZaXwxLo90Q5HREREBilsSbSZjTWz581sg5mtN7Mv9bDOGWZWZ2ar/JfvhSue4WLR2ipSEj28Z1pRxPZ5dEk2BZnJLN66P2L7HK4qapo5Kj+d82aU8PzmfTS1dUQ7JBERERmEcI5EdwBfdc5NB04CrjWz6T2st9g5N8d/+VEY44l7vlKOPZw1rYiMCJVyAHg8xvzJBSzZWo3Xq9ZsQ1FZ20xpbhoLZ5bQ0u7lxc36YiIiIhKPwpZEO+eqnHMr/LcbgI1Aabj2NxK8vuMg1YdaQzrBSrAWlBdyoLGNDVX1Ed/3cFHf0k5dcztleWmcMCGf/IxkHldJh4iISFyKSE20mY0HjgVe6+Hhk81stZk9bmYzenn+VWa2zMyW7d8/ckfuFq3dTWqSh7MiWMoREKiLfkklHYMWOKmwLC+dxAQP504v5tmNezW9uoiISBwKexJtZpnAA8CXnXPdhzFXAOOcc8cANwMP9bQN59yfnXPznHPzCgsLwxpvrOro9PLEuj28Z1ox6cmRK+UIKMpOZVpJFovV6m7QAkl0aV4aAOfPLKGxrZMlOmFTREQk7oQ1iTazJHwJ9J3OuQe7P+6cq3fOHfLffgxIMrOCcMYUr3ylHG1RKeUIOG1KIct2HtTJcINUUdMEQJk/iT5lUgHZqYkq6RAREYlD4ezOYcBtwEbn3I29rFPiXw8zO8Efz4FwxRTPHl1bRVpSAmdOjXwpR8CC8gLaOx2vvXkwajHEs8raZlKTPIzKSAYgOdHD2dOLeXrDHto6vFGOTkRERAYinCPRpwIfA87q0sLuAjO72syu9q9zObDOzFYDNwEfcs6p/UM3HZ1enly3h/ccXURackLU4jh+fD4piR7VRQ9SRY2vM4f/eyMAC2eOpr6lg6Vv6rujiIhIPAlbca1zbglg/axzC3BLuGIYLl7bcZADjW1cFMVSDoDUpAROmJCvSVcGqaKmmbK89HctW1BeQEZyAk+sq+L0KSOz3l9ERCQeacbCOPDomirSkxM4I4qlHAGnTylk275D7K5tjnYocaeytvnwSYUBqUkJnHV0MU+t30tHp0o6RERE4oWS6Bjn68pRxdlHF5OaFL1SjoAF5b7RUs1eODBNbR0cbGw7fFJhVwtnlnCgsY3X31KtuYiISLxQEh3jlr55gJqm9qh25ehqSnEmRVkpvKSSjgE53N4u98gk+oyphaQmeXhCXTpERETihpLoGLdoTRUZyQkxUy9rZiwoL+TlbdV0agrwoFV0mWilu/TkRM6YUsQT6/ZoWnUREZE4oSQ6hrV3enli/R7OmR4bpRwBp00poLapnXWVddEOJW4EekSP7aGcA2DhrBL2NbSy4u2aSIYlIiIig6QkOoa9sv0AtU3tXDh7TLRDeZf5k33z4aguOngVtc0kJ3goyEzp8fGzphWRnODRxCsiIiJxQkl0DFu0ZjdZKYksKI+tSRxHZaYwszSblzQFeNAqanydOTyenrs+ZqUmsaC8gCfW7UGt0kVERGKfkugY1dbh5cn1e2OulCNgQXkhK96uoaGlPdqhxAVfj+ieSzkCzp9ZQmVtM2sqVCYjIiIS65REx6iXt1dT1xw7XTm6W1BeQIfX8aqmAA9KpX+2wr6cM72YRI+ppENERCQOKImOUYvWVJGVmsj8GCvlCDhuXB5pSQmqiw5CS3sn1Yda+x2Jzk1P5uRJo3hiXZVKOkRERGKckugY5Cvl2MO500tISYy9Ug6AlMQETpqoKcCDUemf3bH7bIU9WThzNG8daGJjVUO4wxIREZEhUBIdg5Zs209DSwcXxWgpR8BpUwrZUd3IroNN0Q4lpvXVI7q7c2cU4zF4Yl1VuMMSERGRIVASHYMeXVNFdmoip06OzVKOgMAU4C+ppKNPgR7R/ZVzABRkpnDChHzVRYuIiMQ4JdExprWjk6fX7+W8GSUkJ8b24ZlUmMGYnFQWq9Vdnyprmkn0GEVZqUGtv3DmaLbuO8S2fSrpEBERiVWxnaWNQIu3VNPQ2hGzXTm6OjwF+PZqOjq90Q4nZlXUNDMmN42EXnpEd3fejBIAHl+r0WgREZFYpSQ6xixaW0VOWlLMl3IELJhSQENLB6vV27hXlbX9t7frqiQnlePG5amkQ0REJIYpiY4hLe2dPL1hL+fPKCEpIT4OzamTCjDTFOB9qahpCqoeuquFM0vYUFXPzgONYYpKREREhiI+MrUR4qUt+zkUJ6UcAXkZycwuy1Wru160dnSyt741qM4cXR0u6dBotIiISExSEh1DFq2tIi89iZMnjYp2KANyWnkBq3bVUtesKcC7q6ptAYLrEd3V2Px0ZpflKIkWERGJUUqiY0RLeyfPbNjL+TPjp5QjYEF5IZ1ex9LtGo3u7p0e0QNLogHOn1nC6l21hydrERERkdgRX9naMPbC5v00tnVy4awx0Q5lwI49KpeM5AReUknHEQbSI7q7hTN9ZT1PaDRaREQk5iiJjhGL1laRn5HMSRPzox3KgCUleDh5UgEvbdmPcy7a4cSUytpmEjxGSXZwPaK7mlCQwbSSLM1eKCIiEoOURMeA5rZOnt3oK+VIjLNSjoDTphRQUdPMzgOaAryrippmSrJTB31cF84czbKdNeyrbwlxZCIiIjIU8ZmxDTMvbN5HU1snF82Kn64c3Z3mnwJcre7erbKmecAnFXa1cFYJzsGT61XSISIiEkuURMeAR9dWUZCZzAkT4q+UI2DcqHTG5qfxoqYAf5fB9Ijuqrwok4mFGerSISIiEmOUREdZU1sHz23cF9elHPDOFOBLt1fTrinAAWjv9LKnvmXAPaK7MjMumDmaV988wIFDrSGMTkRERIYifrO2YeL5Tftpbo/PrhzdnVZeQGNbJyvfro12KDFhT10LXgdlA5jyuyfnzyzB6+DpDXtDFJmIiIgMlZLoKFu0djcFmSlxXcoRcPKkAjyaAvywXUNob9fVjDHZjM1PU0mHiIhIDFESHUWNrR08t2kfF8wqIcFj0Q5nyHLSkpgzNlf9ov0CE60M5cRCeKek4+Vt1dQ1aVZIERGRWKAkOoqe27SPlnYvF8ZxV47uTptSyJqKWmqb2qIdStRV1jRjBqNzhpZEg6+ko8PreGajSjpERERigZLoKFq0poqirBTmjY//Uo6ABeWFOAdLtmk0OtAjOjlx6B+zY8pyGZ2TqpIOERGRGKEkOkpe3lbN85v3ccGs0cOilCPgmLIcslITWaxWd1TWNlE6xJMKAzwe4/yZJby0dT+HWjtCsk0REREZPCXREfZWdSOf/fsyrvzraxRlp/CJU8ZHO6SQSkzwcOqkAhZv1RTgFTXNQz6psKuFM0fT1uHluU37QrZNERERGRwl0RHS0NLOzx7byDm/eZGl26v5xvnTePp/TmdCQUa0Qwu5BVMK2F3Xwvb9jdEOJWo6Or1U1bUM+aTCro4bl0dBZgpPrKsK2TZFRERkcBKjHcBw1+l13LdsF796ajMHGtv4wHFlfO28qRRlpUY7tLDpOgX45KLMKEcTHXsbWun0uiFNtNJdgsc4f2YxDyyvpLmtk7TkhJBtW0RERAZGI9Fh9NqbB3jvzUv45oNrGT8qg0eunc8Nlx8zrBNogLH56UwoyGDxCG51V3EwND2iu1s4czTN7Z28uEUlHSIiItGkkegw2HWwiZ89vpHH1u6hNDeNmz98LBfNHo3Z8DmBsD8Lygu4b1kFrR2dpCSOvBHTylp/j+gQnVgYcOKEfPLSk3h83R7Onzl8WiOKiIjEGyXRIdTY2sEfXtjGXxbvIMGMr5wzhatOm0hq0shLIheUF/KPpTtZvrOGUyYVRDuciAtMtDImxEl0YoKHc6eXsGht1Yj9giIiIhILVM4RAl6v4/7lFZz5qxf4/fPbuXDWaJ772ulc/57yEZlAA5w0MZ9Ej43Yko6KmiaKslLCcvzPn1XCodYOlozQ91ZERCQWKIkeouU7D3LJH17ma/etZkxuGg9+4RR+88E5IZmlLp5lpSYx96g8Fm/dH+1QoqKytjmknTm6OnVSAVmpiZp4RUREJIpUzjFIu2ub+fnjm3hk9W6Ks1P4zQeP4eJjSvEMo4lThmpBeQG/fnoLBw61MiozJdrhRFRFTTOzy3LDsu3kRA/nHF3M0xv20t7pJSlB34VFREQiTf/7DlBzWye/eXoLZ/36BZ5cv4frz5rM8187g0uOLVMC3c1pU3yt7kbaFOBer2N3bXPITyrs6vyZJdQ1t7N0+4Gw7UNERER6p5HoIDnneGT1bn7++Caq6lq4cPZovrVwWkj7AA83M0tzyE1PYvHWai6eUxrtcCJmX0Mr7Z0u5O3tujptSiHpyQk8vm7P4S8rIiIiEjlKooOw62ATX/73KpbvrGFmaTa/+9CxnDAhP9phxbwEj3Hq5HemAB8pLf4qasLTI7qr1KQEzppWxFPr9/B/759Jgn4FERERiSiVcwQhLyOZ5rZObrhsNo9cO18J9ACcVl7A3vpWtuw9FO1QIibQIzqcSTT4Jl450NjG6zsOhnU/IiIiciQl0UHITElk0fXzueL4sap7HqD5XaYAHykCPaJLc8Nb6nPG1EJSEj08sa4qrPsRERGRIymJDtJIKUUItdLcNCYVZvDSCOppXFHTxKiMZNKSw9sjPCMlkdOnFPLE+j14vS6s+xIREZF3UxItYXfalEJee/MALe2d0Q4lIipqmsNeyhFwwazR7K1vZeWumojsT0RERHyUREvYnVZeSGuHl2VvjYxEr7KmOWJdW846uoikBOPxtZp4RUREJJKUREvYnTgxn6QE46URUBftnAvrbIXdZacmMX9yAY+v24NzKukQERGJFCXREnbpyYnMG5fPS1uGfxK9/1ArrR3eiJVzACycNZrK2mbWVdZHbJ8iIiIjnZJoiYgFUwrYtKeBffUt0Q4lrAKdOSKZRJ80YRQAG6uURIuIiESKkmiJiNPKR8YU4JURam/XVUlOKh6DCn9/ahEREQk/JdESEdNHZzMqI5nFw7zV3eEe0REciU5O9FCcnXp4pkQREREJPyXREhEejzG/vIDFW6uHdU/jipomctOTyExJjOh+y/LSDo+Ci4iISPgpiZaIWVBeSPWhVjbuGb61u5W1kesR3VVpbtrhUXAREREJPyXREjELygsAhnVJR0VNM2URrIcOKMtLZ099Cx2d3ojvW0REZCRSEi0RU5ydytTiLBYP037RzjkqayLXI7qr0rw0Or2OPcO8+4mIiEisCCqJNrNxZna2/3aamWWFNywZrhaUF/DGjhqa24bfFOAHG9tobu+MSjlHYJ+qixYREYmMfpNoM/sccD/wJ/+iMuChMMYkw9hpUwpp6/Ty2o4D0Q4l5A535siNTk101xhEREQkvIIZib4WOBWoB3DObQWKwhmUDF8nTMgnOdEzLOuiK2sDE61EviZ6jD+JrlSvaBERkYgIJoludc61Be6YWSIwfHuUSVilJiVw4oThOQV4oE9zNGqiU5MSKMxKUa9oERGRCAkmiX7RzL4NpJnZOcB9wH/DG5YMZwvKC9i67xBVdcNr1LSyppms1ERy0pKisv+yvDSNRIuIiERIMEn0N4H9wFrg88BjwHf6e5KZjTWz581sg5mtN7Mv9bCOmdlNZrbNzNaY2dyBvgCJP2dO9VUDXXfXymGV9FXUNEellCNAvaJFREQip98k2jnndc79xTn3Aefc5f7bwZRzdABfdc5NB04CrjWz6d3WWQiU+y9XAX8cYPwSh8qLs7jpw8eyeU8DC3/7Ek+sq4p2SCHhS6IjX8oRUJaXzu7a5mE9I6SIiEisCKY7xw4ze7P7pb/nOeeqnHMr/LcbgI1AabfVLgb+4XxeBXLNbPQgXofEmfcdM4ZF189nfEEGV/9rBd95aC0t7fHb9s45R2Vtc1Q6cwSU5qXR3unY19AatRhERERGisQg1pnX5XYq8AEgfyA7MbPxwLHAa90eKgV2dblf4V/2rqFJM7sK30g1Rx111EB2LTFs3KgM7r/6FH711Gb+/NKbLHurhls+ciyTi+KvDXldczuHWjuiPBId6NDRRElOatTiEBERGQmCKec40OVS6Zz7LXBhsDsws0zgAeDLzrn6wQTpnPuzc26ec25eYWHhYDYhMSo50cO3LziaOz51PPsbWrno5iXc8/rbBFcxFDsCtchRTaLVK1pERCRiginnmNvlMs/Mria4EWzMLAlfAn2nc+7BHlapBMZ2uV/mXyYjzBlTi3j8Sws4blwe33xwLV+8eyX1Le3RDito7yTRUTyxME9JtIiISKQEkwz/usvtDuAt4Ir+nmRmBtwGbHTO3djLao8A15nZPcCJQJ1zbnicZSYDVpSdyj8/fSJ/fHE7Nz69hdUVtdz84bnMGZsb7dD6FejPHM2R6PTkRPIzkpVEi4iIREC/SbRz7sxBbvtU4GPAWjNb5V/2beAo/3Zvxdcu7wJgG9AEfGqQ+5JhwuMxrj1zMidNzOf6u1dx+R9f4WvnTeWqBRPxeCza4fWqsraZjOSEqPWIDlCvaBERkcjoNYk2s6/09cQ+RpcDjy8B+sx6/K3yru1rHRmZjhuXz2NfWsA3H1jDzx/fxMvbqrnxijkUZqVEO7QeBXpE+36AiZ7S3DQ2722IagwiIiIjQV810Vn9XETCKictiT9cOZefXDKT13ccZOHvFrN4a2xOF15R0xyV6b67K8tLo7KmOe5OzBQREYk3vY5EO+d+GMlARHpiZlx54jjmjcvnurtW8LHbXufq0yfx1XOnkJQQzISbkVFZ08Tx4/OiHQaluWm0dnipPtQWs6P2IiIiw0G/NdFmlgp8BpiBr080AM65T4cxLpF3mVqSxSPXzedHj27g1he389qOA9z0oWMZmx+9bhgB9S3t1LdEt0d0QKA7SGVts5JoERGRMApmKO+fQAlwHvAivjZ0KrqUiEtLTuBnl87i9x+Zy7Z9h7jgd4t5dM3uaIdFpb8bRmlu9BP6d9rcNUU5EhERkeEtmCR6snPuu0Cjc+7v+CZaOTG8YYn07sLZo3ns+gVMKsrkurtW8q0H19DcFr0pw2NhopWAQBJdqTZ3IiIiYRVMEh2Y8aLWzGYCOUBR+EIS6d/Y/HTuu/pkrjljEve8sYv33bKEzXui8wNJLPSIDshOTSI7NVG9okVERMIsmCT6z2aWB3wX3+QoG4BfhDUqkSAkJXj4xvnT+MenT6CmqZ333bKEdZV1EY+jsqaZ1CQP+RnJEd93T8ry0tUrWkREJMyCSaL/5pyrcc696Jyb6Jwrcs79KeyRiQRpQXkhj10/H69z/Hd15GukY6VHdEBpXppqokVERMIsmCR6h5n92czeY7GSJYh0U5SdynHj8li8tTri+66obaI0N/qlHAHqFS0iIhJ+wSTR04Bn8M0s+JaZ3WJm88MblsjALSgvZENVPdWHWiO638qa5piohw4ozU2jsa2T2qb2/lcWERGRQek3iXbONTnn7nXOXQrMAbLxtboTiSnzJxcA8PK2yI1GN7Z2UNPUfrg/cyzo2itaREREwiOoKd/M7HQz+wOwHN+EK1eENSqRQZhZmkNOWlJESzoCiWosTPkdUKZe0SIiImEXzIyFbwErgXuBrzvnGsMdlMhgJHiM+ZMLWLK1GudcRE70i6X2dgHvJNEaiRYREQmXfpNoYLZzrj7skYiEwPzyAhatrWL7/kNMLsoK+/4OT7QSQycW5qQlkZGcoCRaREQkjIKpiVYCLXEjUBf90pbIlHRU1jSTnOihIDMlIvsLhpmpV7SIiEiYBVUTLRIvxuanM35UOksidHJhRU0zZblpeDyx1f3R1ytaSbSIiEi4KImWYWdBeSGvvnmAtg5v2PdVUdscUycVBpTmplGpEwtFRETCJpgTC1OAy4DxXdd3zv0ofGGJDN788gL++epOVr5dw4kTR4V1X5U1TUyfXhzWfQxGWV4a9S0d1Le0k52aFO1wREREhp1gRqIfBi4GOoDGLheRmHTypFEkeCzsre6a2zqpPtQWUz2iAwKj45Uq6RAREQmLYLpzlDnnzg97JCIhkp2axDFlOSzeVs3Xzpsatv0c7hEdQ505Ag5PuFLTzNGjs6McjYiIyPATzEj0K2Y2K+yRiITQgvJC1lbUUhfGqa9jsUd0QCCx14QrIiIi4RFMEj0fWG5mm81sjZmtNbM14Q5MZCgWlBfgdfDK9vCVdAS6X8TiiYUFmcmkJHrU5k5ERCRMginnWBj2KERC7JixuWSmJPLS1moWzhodln1U1jaTlGAUZaWGZftDYWZqcyciIhJGwUy2shPIBd7rv+T6l4nErKQEDydNHMWSbfvDto+KmmbG5KaREGM9ogM04YqIiEj49JtEm9mXgDuBIv/lX2b2xXAHJjJUp00pYNfBZnYeCE8zmcqappg8qTCgNFcj0SIiIuESTE30Z4ATnXPfc859DzgJ+Fx4wxIZusAU4OFqdVdR0xyTJxUGlOWlcbCxjaa2jmiHIiIiMuwEk0Qb0Nnlfqd/mUhMm1CQQWluGou3hr6ko6W9k30NrZTmxl6P6IAy9YoWEREJm2BOLPwb8JqZ/cd///3AbWGLSCREzIwF5QUsWltFR6eXxITQzXJfVdcCxGZ7u4BAbBW1zZQXZ0U5GhERkeElmBMLbwQ+BRz0Xz7lnPttmOMSCYn55QU0tHSwprIupNuN5R7RAYFRctVFi4iIhF6vI9Fmlu2cqzezfOAt/yXwWL5z7mD4wxMZmlMnFWAGi7dUM/eovJBttzKGe0QHFGWlkJRgKucQEREJg75Gou/yXy8HlnW5BO6LxLy8jGRmjskJeau7ippmEjxGSXbs9YgO8HiMMblpmrVQREQkDHodiXbOXeS/nhC5cERCb0F5AX9+6U0OtXaQmRLMaQD9q6hpYnROakjrrMOhLC9NvaJFRETCIJg+0c8Gs0wkVs0vL6DD63h1+4GQbbOytjmme0QHqFe0iIhIePSaRJtZqr8eusDM8sws338ZD5RGLEKRITpuXB5pSQkhbXXn6xEdu+3tAsry0tnf0EpLe2f/K4uIiEjQ+vpt+/PAl4Ex+OqgA72h64FbwhuWSOikJCZwwoR8Fm8LzaQrbR1e9tS3xPRJhQGB0fLdtc1MLMyMcjQiIiLDR68j0c653/nrob/mnJvonJvgvxzjnFMSLXFlQXkBb+5vZHcI6oP31LXgXGy3tws4POGK6qJFRERCKpizorxmlhu44y/t+EL4QhIJvQXlhQAsCcEU4PHQIzogMFquumgREZHQCiaJ/pxzrjZwxzlXA3wubBGJhMGU4kyKslJ4KQR10RX+Ud2yGJ7yO6AkO5UEj3pFi4iIhFowSXSCmQXqoTGzBCA5fCGJhJ6ZMX9yAa9sP4DX64a0rYqaZjwGJTmx2yM6IDHBQ0l2qnpFi4iIhFgwSfQTwL/N7D1m9h7gbv8ykbiyYEoBBxvb2FBVP6TtVNQ0UZydSnJibPeIDlCvaBERkdALJgv4BvA8cI3/8izwv+EMSiQcTp1cAMDiIdZFV9Y0x0U9dEBpnnpFi4iIhFq/SbRzzuuc+6Nz7nL/5U/OOTWdlbhTlJXKtJKsIfeLjpce0QFleensrW+hrcMb7VBERESGjWBmLDzVzJ42sy1m9qaZ7TCzNyMRnEiozZ9cwLK3amhuG9z3wI5Of4/oOJitMKAsNw2v87XmExERkdAIppzjNuBGYD5wPDDPfy0SdxZMKaSt08vrbx0c1PP31LfQ6XVxVc4RiLWiVicXioiIhEowSXSdc+5x59w+59yBwCXskYmEwQnj80lO8LBkkCUdgdrieJitMEC9okVEREKvr2m/A543s18CDwKtgYXOuRVhi0okTNKSE5g3Pm/QJxcG+i3HU0306Jw0zFCvaBERkRAKJok+0X89r8syB5wV+nBEwm9+eQE3PLGZfQ0tFGUNrNdzYDR3TG7s94gOSE70UJyVqpFoERGREAqmO8eZPVyUQEvcOs0/BfjL2wY+Gl1R00RRVgopiQmhDiusfL2iVRMtIiISKv2ORJvZ93pa7pz7UejDEQm/6aOzyc9IZvHWai45tmxAz62sja8e0QGleWks31kT7TBERESGjWBOLGzscukEFgLjwxiTSFh5PMYpk0axZGs1zg1sCvB46xEdUJaXxp66Fjo61StaREQkFIIp5/h1l8tPgDOAiWGPTCSMFpQXsK+hlS17DwX9nE6vo6quOa46cwSU5qbT4XXsbWjtf2URERHpVzAj0d2lAwP7DVwkxsz310UPZPbCfQ0ttHfGV4/ogEDM6tAhIiISGsHMWLjWzNb4L+uBzcBvwx6ZSBiV5qYxsTBjQK3uDveIjqPZCgPe6RWtkwtFRERCodcTC81sgnNuB3BRl8UdwF7nXEfYIxMJswWTC/j3sl20dnQG1W0jHntEBwQSf41Ei4iIhEZfI9H3+69vd87t9F8qlUDLcDG/vJCWdm/QXSsCo7jxWM6RmpRAQWaKekWLiIiESF8t7jxm9m1gipl9pfuDzrkbwxeWSPidNDGfRI+xZGs1p0wq6Hf9ytpmCjKTSU2Krx7RAb5e0UqiRUREQqGvkegP4Wtplwhk9XARiWtZqUkce1Ru0HXRFTXNlMZhKUdAaV6aaqJFRERCpNeRaOfcZuAXZrbGOfd4BGMSiZj5kwv57bNbqGlsIy8juc91K2qamT46O0KRhV5ZXhpPr9+L1+vweCza4YiIiMS1YPpEK4GWYWt+eQHOwcvb+x6N9npd3M5WGFCWm0Zbp5f9h9QrWkREZKgG0ydaZNg4piyHrNRElvRT0lF9qJW2Dm98J9H+UhSdXCgiIjJ0SqJlREtM8HDKpFEs7mcK8F2BHtFxnESrV7SIiEjoBDPZSrqZfdfM/uK/X25mF/X3PJF4Mb+8kMraZnZUN/a6TqCrRTz2iA443CtaHTpERESGLJiR6L8BrcDJ/vuVwP+FLSKRCFsw2dfebsm23ks6AqO38ThbYUBGSiJ56Ukq5xAREQmBYJLoSc65G4B2AOdcE9Dvqf1mdruZ7TOzdb08foaZ1ZnZKv/lewOKXCRExo1KZ2x+Wp+t7iprmslLTyIjpa/W6rGvLC9dsxaKiIiEQDBJdJuZpQEOwMwm4RuZ7s8dwPn9rLPYOTfHf/lRENsUCTkzY/7kQpZuP0B7p7fHdSpqmuO6lCOgNFcTroiIiIRCMEn0D4AngLFmdifwLPC//T3JOfcScHBI0YlEyILyAg61drB6V22Pj1fUNMV1KUdAmX/Clb5OohQREZH+BdMn+ingUuCTwN3APOfcCyHa/8lmttrMHjezGb2tZGZXmdkyM1u2f//+EO1a5B2nTBqFx+ixpMO5+O8RHVCal0ZLu5eDjW3RDkVERCSuBdOd47/AucALzrlHnXPBzZHcvxXAOOfcMcDNwEO9reic+7Nzbp5zbl5hYWGIdi/yjtz0ZGaV5fZ4cuGBxjZa2uO7R3SAekWLiIiERjDlHL8CFgAbzOx+M7vczFKHumPnXL1z7pD/9mNAkpkVDHW7IoO1YHIBq3bVUt/S/q7llYd7RA+PmmhQmzsREZGhCqac40Xn3BeAicCfgCuAfUPdsZmVmJn5b5/gj+XAULcrMljzywvo9DqWbn/3n2Fg1HY4jERrwhUREZHQCKpfl787x3uBDwJzgb8H8Zy7gTOAAjOrAL4PJAE4524FLgeuMbMOoBn4kNPZThJFc4/KIz05gSVbqzlvRsnh5Yd7RA+DJDonLYms1ES1uRMRERmifpNoM7sXOAFfh45bgBedcz33AevCOffhfh6/xb89kZiQnOjhpImjjqiLrqxtJjs1kezUpChFFlpleemqiRYRERmiYGqib8M34crVzrnng0mgReLV/MkF7KhuZNfBd8odhkuP6AD1ihYRERm6XpNoMzvLfzMDuNjMLu16iUx4IpG1oPzIKcArapqGRSlHgK9XdLN6RYuIiAxBXyPRp/uv39vD5aIwxyUSFZOLMinJTmWJv1+0c47KmuHRIzqgLC+NQ60d1Dd3RDsUERGRuNVrTbRz7vv+mz9yzu3o+piZTQhrVCJRYmbMLy/g6Q176fQ66pvbaWzrHHblHAC7aprISc+JcjQiIiLxKZia6Ad6WHZ/qAMRiRULyguoa25nXWXd4drh4TDld0DgC4HqokVERAav15FoM5sGzAByutVAZwNDnmxFJFadOvmduuhJhRnA8OgRHfBOr2gl0SIiIoPVV4u7qfhqn3Px1UEHNACfC2NMIlFVkJnC9NHZLN66n5RE3481wymJzktPIj05Qb2iRUREhqCvmuiHgYfN7GTn3NIIxiQSdQvKC7j95R0clZ9OZkoiOWnDo0c0+Oq+S3PTNGuhiIjIEARTE321meUG7phZnpndHr6QRKJvfnkB7Z2Ox9fuoSwvDf8M9cNGWZ56RYuIiAxFMEn0bOdcbeCOc64GODZsEYnEgOPH55Oc6KGhtWNYnVQYUOrvFS0iIiKDE0wS7TGzvMAdM8sniOnCReJZalICJ07IB4ZXPXRAWV46dc3tNLS0RzsUERGRuBRMEv1rYKmZ/djMfgy8AtwQ3rBEom++v0vHcJqtMCAwuq6SDhERkcHpN4l2zv0DuBTY679c6pz7Z7gDE4m2s6YVkeAxppVkRzuUkAuMrqtDh4iIyOAEW5aRDzQ65/5mZoVmNqH7LIYiw015cRavfus9FGQmRzuUkFOvaBERkaHpdyTazL4PfAP4ln9REvCvcAYlEisKs1KGXWcOgMLMFFISPSrnEBERGaRgaqIvAd4HNAI453YDWeEMSkTCS72iRUREhiaYJLrNOecAB2BmGeENSUQioTQvTTXRIiIigxRMEn2vmf0JyDWzzwHPAH8Jb1giEm5l6hUtIiIyaP2eWOic+5WZnQPUA1OB7znnng57ZCISVmV56RxobKO5rZO05IRohyMiIhJXgurO4U+alTiLDCPv9IpuYnKRTnMQEREZiF7LOcxsif+6wczqe7jsMLMvRC5UEQmlMrW5ExERGbReR6Kdc/P91z0OUZnZKHyzF/4hPKGJSDipV7SIiMjgBVXOYWZzgfn4OnQscc6tdM4dMLMzwhibiIRRUVYqSQmmXtEiIiKDEMxkK98D/g6MAgqAO8zsOwDOuarwhici4ZLgMUbnqEOHiIjIYAQzEn0lcIxzrgXAzH4OrAL+L4xxiUgElOWlUakJV0RERAYsmD7Ru4HULvdTgMrwhCMikeSbtVAj0SIiIgPV60i0md2Mrwa6DlhvZk/7758DvB6Z8EQknMry0tnX0EprRycpieoVLSIiEqy+yjmW+a+XA//psvyFsEUjIhEV6NCxu7aFCQUZUY5GREQkfvTV4u7vAGaWCkz2L94WqI0WkfgX6BVdWdOsJFpERGQA+ppsJdHMbgAq8HXn+Aewy8xuMLOkSAUoIuETmLWwQicXioiIDEhfJxb+EsgHJjjnjnPOzQUmAbnAryIQm4iE2eicVBI86hUtIiIyUH0l0RcBn3PONQQWOOfqgWuAC8IdmIiEX2KCh5LsVHXoEBERGaC+kmjnnHM9LOzE16VDRIaB0rw0KpVEi4iIDEhfSfQGM/t494Vm9lFgU/hCEpFIKstNU020iIjIAPXV4u5a4EEz+zS+NncA84A04JJwByYikVGWl8ae+hbaO70kJQQz/5KIiIj01eKuEjjRzM4CZvgXP+acezYikYlIRJTmpeF1sKeuhbH56dEOR0REJC70NRINgHPuOeC5CMQiIlFQludLnCtqmpVEi4iIBEm/3YqMcIFe0WpzJyIiEjwl0SIj3OjcVMw04YqIiMhAKIkWGeFSEhMoykpRmzsREZEBUBItIpTlpWvCFRERkQFQEi0ilOamqSZaRERkAJREiwhleWnsrm2m06vJSEVERIKhJFpEKM1Lo8Pr2NfQEu1QRERE4oKSaBF5V69oERER6Z+SaBF5p1e0kugRra65nZ8+tpGGlvZohyIiEvOURIsIZXm+JFq9oke2e15/mz+/9CYPr9od7VBERGKekmgRITUpgYLMZHXoGMGcc9y/vAKAJ9fviXI0IiKxT0m0iABQql7RI9rayjq27jvEmJxUlm4/QF2zSjpERPqiJFpEACjLTVNN9Ah2//IKUhI9/OTSWXR4HS9s3hftkEREYpqSaBEBfHXRFbXNeNUresRp7ejk4VW7OW9GCaeXF1KYlaKSDhGRfiiJFhHA1yu6rcNLdWNrtEORCHt24z7qmtu5/LgyPB7jnOnFvLB5Py3tndEOTUQkZimJFhGga4eO8JR0tHV4eWT1bpraOsKyfRm8B5ZXUJKdyqmTCwA4b0YJTW2dLNlaHeXIRERil5JoEQGgNNc34Uo46qKdc3zzgTVcf/dKrr97laYXjyH7Glp4Yct+LplbSoLHADh54iiyUhJ5aoNKOkREeqMkWkQAXzkHhGck+nfPbuXBlZWcMmkUz2zcy88e2xjyfcjgPLxyN51ex2Vzyw4vS070cOa0Ip7ZuI+OTm8UoxMRiV1KokUEgMyURHLTk6isDe2EKw+uqOC3z2zlsrll3PnZE/nkKeP565Id/OvVnSHdjwxcoDf0sUflMrko812PnTejhIONbSzbWROl6EREYpuSaBE5rCwvLaQj0Uu3H+AbD6zh5Imj+NmlszAzvnvRdM6aVsT3H1nPi1v2h2xfMnDrd9ezeW/Du0ahA86YWkhyokddOkREeqEkWkQOKw1hr+ht+w7x+X8u46j8dG796HEkJ/r+uUnwGDd9+FimFGdx3Z0r2LynIST7C6X6lpEx0cj9yytITvTw3tljjngsIyWRBZMLeGr9XpxTDbuISHdKokXksDL/rIVDTZoOHGrl03e8QXKihzs+dQI56UnvejwzJZHbPjGPtOQEPn3HG+xviI22es45bn52K8f88Cnuef3taIcTVq0dnTy0qpJzpxcfcXwCzp1RTGVtM+t310c4OhGR2KckWkQOK81No7m9k5qmwY/EtrR38tl/LGNvfQt/+fg8xuan97jemNw0bvvE8RxsbONz/1gW9Z7EXq/jR49u4NdPbyE3LYnvPbKedZV1UY0pnJ7ftI/aJl9v6N6cfXQxHoOnVNIhInIEJdEictg7HToGd3Kh1+v4yr2rWLWrlt99aA7HHpXX5/qzynL47YfmsLqilq/euzpqsyW2d3r56n2r+dvLb/GZ+RN4+iunk5+ezBfuXEFd8/As7bh/eSVFWSksKC/sdZ1RmSnMG5/Pk+v3RjAyEZH4oCRaRA4LTLgy2LroXzy5icfW7uHbC4/m/Jmjg3rOeTNK+NbCaSxaW8WNT28Z1H6Hormtk8//czn/WVnJ18+byncuPJqCzBR+f+Wx7K5t5uv3rR52NcH7G1p5fvO+d/WG7s15M0rYvLeBt6obIxSdiEh8UBItIoeV+SdcGUyHjrtee5s/vfgmHz3pKD67YMKAnvu5BRP58AljueX5bdy/vGLA+x6suuZ2Pnbbazy/eR8/vWQW1545GTNfUnncuHy+uXAaT23Yy18X74hYTJHw8KpKOr2Oy3voytHdudOLATTxiohIN2FLos3sdjPbZ2brennczOwmM9tmZmvMbG64YhGR4GSnJZKVkkhl7cCS6Bc27+O7D6/jzKmF/OC9Mw4nosEyM3508UxOnTyKbz24hlffPDCg5w/GvvoWPvinpayuqOWWD8/lIycedcQ6n5k/gfNnlPDzJzbxxlsHwx5TpNy/vIJjynIoL87qd92x+elMH52tkg4RkW7CORJ9B3B+H48vBMr9l6uAP4YxFhEJgplRmpc2oJrojVX1XHfXSqYWZ3HzR+aSmDC4f1aSEjz84crjOCo/nc//czlv7j80qO0EY+eBRi6/dSlvH2zi9k8ez4Wzey49MTNu+MBsyvLSuO6uFVQfio0uIkOxfncdm/Y09HlCYXfnzShhxds17GtoCWNkIiLxJWxJtHPuJaCvoZuLgX84n1eBXDMLrohSRMJmIBOu7K1v4dN3vEFmSiK3f/J4MlMSh7TvnLQk/vbJE0jwGJ++4w1qGtuGtL2ebNhdz2V/XEp9Szt3fe6kPk+sA8hOTeIPV86lpqmdL9+zis4onfwYKvcvryA5wcN7jzmyN3RvzptZjHPw9AaNRouIBESzJroU2NXlfoV/mYhEUbATrjS2dvDpO96gvrmd2z95PCU5qSHZ/1Gj0vnLx49jd10Ln//nclo7Qtf67o23DvLBPy8lKcG4/+qTmTM2N6jnzRiTw48vnsGSbdX87tmtIYsn0to6vDy8ajfnTC8mNz056OdNLc5i3Kh0nlJJh4jIYXFxYqGZXWVmy8xs2f79miZYJJzK8tJpaO3os7VbR6eXL969ko1V9dxy5Vymj8kOaQzHjcvnl5fP5vW3DvKtB9eGpDvGc5v28tG/vkZhVgr3X3MKk4v6rwfu6op5Y7lsbhk3P7c1bqcrf37zPg42tnHZcQMbrzAzzp1ezCvbq0fMbI4iIv2JZhJdCYztcr/Mv+wIzrk/O+fmOefmFRb2/dOriAxNf72infNNSvLcpn388OKZnDm1KCxxXDynlK+cM4UHV1Ty++e3DWlbD66o4HP/WM6U4izu+/zJlOamDXgbZsb/vX8mU4uz+PI9K9k9wJMvY8EDyysoyEzhtH5KWHpy3owS2jsdz2/aF4bIRETiTzST6EeAj/u7dJwE1DnnqqIYj4jQf6/o25bs4B9Ld/K5BRP42EnjwhrLF8+azCXHlvKrp7bw39W7B7WN25fs4Cv3ruaE8fnc9bkTGZWZMuh40pIT+P2Vc2nr8HLdXSto6/AOeluRduBQK89t2selc0sHdfLn3KPyKMhMUUmHiIhfOFvc3Q0sBaaaWYWZfcbMrjazq/2rPAa8CWwD/gJ8IVyxiEjwAqO0PZ1c+MS6PfzksY2cP6OEby08OuyxmBk/v2wWx4/P46v3rWb5zpqgn+uc48anNvOjRzdw3oxi/vap48lKTRpyTJMKM/nF5bNZ8XYtP39805C3FykPr9pNh9dxWRC9oXvi8RjnTC/mhc37oj5Fu4hILAhnd44PO+dGO+eSnHNlzrnbnHO3Oudu9T/unHPXOucmOedmOeeWhSsWEQlefkYyaUkJR/SKXrWrli//eyWzy3L5zQfn4OlnprtQSUlM4E8fm8fonFSu+scydh3sv/1ep9fxnYfWcdNz2/jgvLH8/iNzSU1KCFlMF80ewydPGc/tL+/g8bXx8QPa/csrmFWaw9SSgdWCd3XejGIa2zp5ZXt1CCMTEYlPcXFioYhETk+9oncdbOKzf3+DgswU/vrxeaQlhy4hDUZ+RjK3f/J42ju9vo4gfZzc1tbh5fp7VnLna29z9emT+Pllswbdu7ov377gaOaMzeXr969hR4xPib1hdz0bquoH1Bu6JydPGkVmSiJPrlNJh4iIkmgROUJZXtrhkei65nY+dccbtHV4ueNTx1OYNfia4qGYVJjJrR87jh3VjVx75wraO4+sR25s7eAzf3+DRWuq+PYF0/jmwmkDnj0xWMmJHn5/5VwSE4xr/rU8pkscHlhRQVKC8b4B9IbuSUpiAmdOK+KZjXvjvl+2iMhQKYkWkSOU5vomXGnr8HLNv5az80Ajt37suAG3hQu1UyYV8NNLZ7F4azXff2T9u1rf1TS2ceVfX+PlbdXccPlsrjptUtjjKc1N4zcfnMOmPQ187+F1Yd/fYLR3enloZSVnH11MXkbwvaF7c96MYg40trFsGE2DLiIyGEqiReQIZXnp1Da185V7V/HK9gP87NLZnDKpINphAb5+zdecMYm7Xnub25bsAKCqrpkP/GkpG6rq+eNHj+OKeWP72UronDm1iOvOnMy9yyq4d9mu/p8QYS9s3s+BxrZBn1DY3RlTi0hO8PCUZi8UkRFuaHP0isiwFOgV/eiaKq5/T/mQa2lD7evnTuWt6kZ+8thGzIzbl+ygrrmdOz51fFSS/f85Zwor3q7huw+tY1ZpDkePDu3kM0Ph6w2dzOlTQ9NjPzMlkVMnj+LJ9Xv4zoVHh61cRkQk1mkkWkSOMGFUBgCXHFvK/5xdHuVojuTxGDdeMYfZpTn8+NENtLR3cs9VJ0VttDzBY/zuQ8eSk5bEF+5cQUOMzOp3sLGNZzft5f1zSkkK4cmV580ooaKmmQ1V9SHbpohIvFESLSJHmFmazV2fPZFfXDY7Zkca05IT+Msn5vGJk8dx39UnM7M0J6rxFGalcPOHj+Xtg01844E1IZmqfKgeWVVJe6fjshD/knD29GI8Bk9q4hURGcGURIvIEcyMUyYXkJwY2/9EFGWl8sOLZzKxMDPaoQBw4sRRfP28qTy2dg93vPJWtMPh/hUVzBiTHfLykoLMFOaNy+ep9XtCul0RkXgS2/9DiojEmasWTOTso4v56WMbWfF28DMshtqmPfWsqxx6b+jenDujmE17Gth5ILZ7ZIuIhIuSaBGREPJ4jF9/4BiKs1O57s4V1DS2RSWOB5b7ekNfPKc0LNs/b0YJAE+ppENERigl0SIiIZaTnsQfrzyO6kNtfPnfq/BGeGKS9k4v/1m5m7OmFZEfgt7QPRmbn87Ro7N5UiUdIjJCKYkWEQmDWWU5fO+903lxy35+//y2iO77pS37qT7UGrLe0L05b0Yxy9+uYX9Da1j3IyISi5REi4iEyZUnHsX754zhN89s4eVt1RHb7wMrKhiVkcyZ04rCup/zZpTgHDyzUSUdIjLyKIkWEQkTM+Mnl8xiYmEmX7pnJdv2HQr7Pmsa23hmwz4uDnFv6J5MK8libH6aSjpEZERSEi0iEkYZKYnc+tG5OAcX37KER9fsDuv+/rtmN22d3ojMMmlmnDe9hFe2HYiZCWZERCJFSbSISJhNLsri0evnM210NtfdtZIfPLKetg5vWPZ1//IKjh6dzfQxkZl6/LyZJbR1enl+8/6I7E9EJFYoiRYRiYDROWncc9VJfPrUCdzxylt88M9LqaprDuk+tuxtYE1FXURGoQPmHpVHQWayJl4RkRFHSbSISIQkJXj43nun8/uPzGXLngYuvGkJi7eGbgT3geUVJHqMi+eMCdk2+5PgMc6ZXswLm/fT2tEZsf2KiESbkmgRkQi7cPZoHvnifAoyk/n47a9z07Nbh9xLuqPTy4MrKzlzWhEFmSkhijQ4504v4VBrB69sOxDR/YqIRJOSaBGRKJhUmMlD157KJXNKufHpLXzqjjeGNLvh4q3V7G8If2/onpwyeRSZKYnq0iEiI4qSaBGRKElPTuTXVxzDTy6ZydLtB7jo5iWs2lU7qG3dv6KCvPQkzgpzb+iepCQmcMbUQp7esJfOCM/OKCISLUqiRUSiyMy48sRx3H/NyQB84NZX+OfSt3Au+GS0rqmdp9fv5eI5pSQnRuef9fNmlHCgsY0Vb9dEZf8iIpGmJFpEJAbMLstl0fXzmT+5gO8+vJ4v/3sVTW0dQT33kQj2hu7NGVMLSU7w8OS6+C3pGGpduoiMLEqiRURiRG56Mrd94ni+du4U/rt6Nxff8nJQsxzev7yCaSVZzIhQb+ieZKUmccrkUTy5Yc+ARtFjwa6DTXzl36s4+ntP8Pvnt6kkRUSCoiRaRCSGeDzGdWeV88/PnMjBxrZ+Zznctq+B1btqufy4MswsgpEe6bwZJew62MzGqoaoxhGs6kOt/OCR9Zz16xdYtLaKY8py+eWTm/nIX15ld21oe3iLyPCjJFpEJAadOrmARdcv6HeWw/uXV5LgMS6eUxqFKN/t7KOLMYOnNsR2SUdDSzu/eXoLp9/wPP98dSeXH1fGC18/g39//iR+/YFjWFdZx8LfLebxtVXRDlVEYpiSaBGRGFWSk8o9V53EZ+a/M8th1xHSTq/jPysrOHNqIYVZke0N3ZPCrBTmjcvjyfV7ox1Kj1o7OrltyQ5O/+UL/O7ZrZw+tZCn/uc0fnbpbEbnpGFmXHZcGYuuX8C4Uelcc+cKvvXgmqBr00VkZFESLSISw5ISPHz3oun84cq5bN17iItufmeWw8Vb97O3Pjq9oXtz7vQSNlbVs+tgU7RDOazT67h/eQVn/epFfvzoBqaVZPHwtafyhyuPY1Jh5hHrjy/I4P6rT+GaMyZxzxu7uOjmJayrrItC5CISyyzeTgCZN2+eW7ZsWbTDEBGJuDf3H+Kaf61gy74G/ufsKWze28DL26p57dvvISUxIdrhAfD2gSZO++XzfOfCo/nsgolRjcU5xzMb9/HLJzexZe8hZpXm8I3zpzG/vCDobbyyvZqv/Hs1Bxpb+cb50/j0qRPweKJbez6ceb2OA41t7K1vYU9dC3vqW951u6Glg6nFWcwqy2F2WQ5TS7Ji5m9fhiczW+6cm9fjY0qiRUTiR1NbB9/5zzoeXFkJwCdOHscPL54Z5aje7fzfvkR2ahL3Xn1y1GJ4fcdBfvHEJpbvrGFCQQZfO3cqC2eWDCoBrmls4xsPrOGpDXtZUF7Arz9wDEXZqWGIenhrae/sITlu9V37l+9raKG98915icd8pUIl2amkJyeyaU89NU3tACQlGNNKsn1JdWkOs8pymFKcRVKCfmiX0FASLSIyjDjnuPv1Xdz64nb++ol5TCnOinZI7/Kbp7dw03NbeeP/nU1BZmRrtTdW1fPLJzfz3KZ9FGen8KX3TOED88qGnFQF3vMfPbqe9OREfnn5bN5zdHGIoo5/ja0dVNU1U1XXQlVtC7vrmg8ny3vqfAlzIPHtKj05gZLsVIqzUynJ8V9np1CSk0ZJTiol2akUZCaT2OX4OeeoqGlmbWUdayrqWFtZy5qKOhpafLXryYkepo/OZnZZDrNKc5hdlsukwox3bUMkWEqiRUQkYtbvruPCm5bw80tn8aETjorIPncdbOLGp7fw0KpKslISueaMyXzylPGkJYf2p/5t+xr44t2r2FhVzydOHse3Ljia1KThXU7Q1NZxRHLcPWEOJLBdFWQmH06EfclxKsX++6NzfLezUhJD0prROcfOA02sqaxjbYUvqV5XWUdjWycAaUkJzBiTfbgMZFZpLhMLMlSaI/1SEi0iIhHjnGPBDc9TXpTJ3z51Qlj3tb+hld8/v407X9uJx4xPnTqBa06fRE56Utj22dLeyQ1PbOb2l3cwtTiLmz58LFNLYuvXgGC0dXipbWrjYFMbBw61+ZPiZqrq/dd1LVTVtVDXfOQIciBBHp2TxpicVEpy0hiT60uQx+SmUZSdEvVaZa/X8WZ1I+u6jFivq6ynud2XWGckJzCzNIe54/L43IKJ5GckRzVeiU1KokVEJKJ+/OgG/rl0J8u/ezZZqaFPaBta2vnL4h38dfGbtHZ4+eDxY7n+rHJKciJXq/zC5n187b7VNLR08P8uPJqPnTQuahPeeL2OhpYODjS2UtPUxsHGdg42tnKwsd1//51L4H5Po8cAozLeSZBH56QyOtc3cuxLmH0JcryOvnd6Hdv3H/Il1RW1/pHrOnLSkvjB+2Zw0ezRUZ+0SGKLkmgREYmo13cc5Io/LeWWjxzLRbPHhGSbBw61smRbNYu3VvPMxr3UNrVz4ezRfPWcKUzsoVVdJOxvaOXr96/mhc37ec+0Im64fDajQlwH7pyj+lAbW/Y2sHlPA9v3HzoiKa5pau91uvKURA+jMpLJy0gm33/JS3/nduD+6BxfXXK8JsiDtWlPPd+4fw2rK+o4++hi/u/9MyP6ZUxim5JoERGJqE6v44SfPMMpkwu4+cPHDmobrR2dLN9Zw+Kt1Szeup91lfUA5KQlsaC8gKtOm8jsstwQRj04zjnueOUtfvbYJnLSk7jximNYUF44qG3Vt7SzdW8Dm/ccYsveBjbtqWfLXl/SHJCTlkRRVoovKU5PJj/Td+1LkpPIz0jx309iVEZKyOvCh6NOr+P2JTv49dObSfJ4+NYFR/Oh48eqZlqURIuISOR94/41LFpbxfLvnh1Ufaxzvp/aX9riS5pfffMgze2dJHqMuUflsaC8gAVTCplVmkNCDCY3G3bXc/09K9m27xBXnTaRr507leTEnjtCtLR3sm2fL1He7B9h3rKngd11LYfXyUhOYEpJFlOLs5hSnMXUEt91LMxOOVy9Vd3INx9cw6tvHuSkifn8/NLZjC/IiHZYEkVKokVEJOKe27SXT9+xjL996njOnFrU4zo1jW3+Eo39LN5aTZU/iZxYkOFLmssLOWnSKDJTEiMZ+qA1t3Xyf4s2cOdrbzOzNJvfXDEHMztcihG4futAI4Hqi+QED5OKMplanPmupLk0N00joVHgnOOeN3bx00Ubaev08tVzp/DpUyeoRd4IpSRaREQirqW9k+N+/DTvm1PKzy6dBfg6Qqx4u+Zw0ry2sg7nIDs1kfn+pHn+5ALG5qdHOfqheXL9Hr7xwBpqu/RGNoPxozJ8SbI/WZ5aksm4URmaHCQG7alr4TsPreOZjXuZXZbDLy6bzdGjs6MdlkSYkmgREYmKa+9awWtvHuS6MyexeGs1S988QFNbJwkeY+5RuSwoL2RBeQGzy3JjskRjKPbUtfDAigpKslOZWpLF5KLMEXfSXrxzzrFobRXff3g9dc3tfOGMSVx71uSot++TyFESLSIiUfHf1bv54t0rARg/Kv1w0nzSpFFkh6H1nUg41DS28eNHN/DgykomF2Xyi8tmc9y4vGiHJRGgJFpERKLC63U8s3Ev00qyOWpUfJdoiDy/eR//78G1VNW38MlTxvO1c6eSESf1+jI4SqJFREREQuBQawc3PLGJfyzdSVleGj+7dNagWxpK7OsridaZDCIiIiJBykxJ5EcXz+Tez59McoKHj932Ol+/bzV1TUdOjy7Dm5JoERERkQE6YUI+j31pAV84YxIPrqzk7N+8yBPrqqIdlkSQyjlEREREhmBdZR3feGAN63fXs3BmCT+8eAZFWZo6vC/OOVo7vDS3ddLc7r+0vXPd1NZJi395U1snHz5hLOnJka8/76ucQ9XwIiIiIkMwszSHh649lb8u3sFvntnCsxv3kZWaSHKih5REDymJCe/cTvKQnNDTsoR3Hkvq9niih/TkREbnpFKWl0ZOWhJmsdESsrapjbcPNh2+VNW20NjW4UuAe0iGW7oky94BjOOeN6M4Kkl0X2IrGhEREZE4lJTg4ZozJnHujGLufWMXjW0dtLZ7ae3w0tbhpbWjk7ZOL63tXuqbOw4ve+dx3/32zv4zy4zkBErz0ijNTfNfpx++X5aXRmFmSshmu2zv9FJV28LOg42HE+VdgaT5QBP1LR3vWj8nLYnMlETSkhNIS/JdctOTGZ2UQHpyAqn+5enJCaQmvXM7zX8/PfC8LtfpSYlkpcZeyhp7EYmIiIjEqUmFmXzrgqMH/Xyv1/mS7UCS3e6lrdPLoZYOquqaqahpprK2mUr/9cpdte+aGRN8U8mPzk31JdmHE23fdVluOiU5qSQnvnNaXF1T++EEeefBxneS5INN7K5tobPLkHFygoey/DSOyk9n7lF5HJWfztj89MPXmSOo5d/IeaUiIiIiMc7jMVI9Cf7ZLd89IdExY3N7fM6h1g52+xPrii4JdmVNEy9t3c++hla6ngJnBsVZqeSmJ7G7tvmI0eRRGcmM9SfJ75/zTpJ8VH46xdmpw2520cFSEi0iIiISxzJTEplSnMWU4qweH2/t6GRPXcsRSXZtUxvHj8/3JcijRuZo8lDoXRIREREZxlISExg3KoNxozKiHcqwoj7RIiIiIiIDpCRaRERERGSAlESLiIiIiAyQkmgRERERkQFSEi0iIiIiMkBKokVEREREBkhJtIiIiIjIACmJFhEREREZICXRIiIiIiIDpCRaRERERGSAlESLiIiIiAyQkmgRERERkQFSEi0iIiIiMkDmnIt2DANiZvuBnVHafQFQHaV9S3B0jGKfjlFs0/GJfTpGsU/HKPYFe4zGOecKe3og7pLoaDKzZc65edGOQ3qnYxT7dIxim45P7NMxin06RrEvFMdI5RwiIiIiIgOkJFpEREREZICURA/Mn6MdgPRLxyj26RjFNh2f2KdjFPt0jGLfkI+RaqJFRERERAZII9EiIiIiIgOkJDoIZna+mW02s21m9s1oxyNHMrO3zGytma0ys2XRjkfAzG43s31mtq7Lsnwze9rMtvqv86IZ40jXyzH6gZlV+j9Lq8zsgmjGONKZ2Vgze97MNpjZejP7kn+5Pksxoo9jpM9SjDCzVDN73cxW+4/RD/3LJ5jZa/787t9mljyg7aqco29mlgBsAc4BKoA3gA875zZENTB5FzN7C5jnnFNfzhhhZqcBh4B/OOdm+pfdABx0zv3c/4U0zzn3jWjGOZL1cox+ABxyzv0qmrGJj5mNBkY751aYWRawHHg/8En0WYoJfRyjK9BnKSaYmQEZzrlDZpYELAG+BHwFeNA5d4+Z3Qqsds79MdjtaiS6fycA25xzbzrn2oB7gIujHJNIzHPOvQQc7Lb4YuDv/tt/x/cfjURJL8dIYohzrso5t8J/uwHYCJSiz1LM6OMYSYxwPof8d5P8FwecBdzvXz7gz5GS6P6VAru63K9AH45Y5ICnzGy5mV0V7WCkV8XOuSr/7T1AcTSDkV5dZ2Zr/OUeKhOIEWY2HjgWeA19lmJSt2ME+izFDDNLMLNVwD7gaWA7UOuc6/CvMuD8Tkm0DBfznXNzgYXAtf6fqSWGOV8tmerJYs8fgUnAHKAK+HVUoxEAzCwTeAD4snOuvutj+izFhh6OkT5LMcQ51+mcmwOU4asymDbUbSqJ7l8lMLbL/TL/MokhzrlK//U+4D/4PiASe/b66wcDdYT7ohyPdOOc2+v/z8YL/AV9lqLOX8P5AHCnc+5B/2J9lmJIT8dIn6XY5JyrBZ4HTgZyzSzR/9CA8zsl0f17Ayj3n8GZDHwIeCTKMUkXZpbhP5kDM8sAzgXW9f0siZJHgE/4b38CeDiKsUgPAomZ3yXosxRV/hOibgM2Oudu7PKQPksxordjpM9S7DCzQjPL9d9Ow9csYiO+ZPpy/2oD/hypO0cQ/G1pfgskALc7534S3YikKzObiG/0GSARuEvHKPrM7G7gDKAA2At8H3gIuBc4CtgJXOGc04ltUdLLMToD38/PDngL+HyX2luJMDObDywG1gJe/+Jv46u51WcpBvRxjD6MPksxwcxm4ztxMAHfAPK9zrkf+fOHe4B8YCXwUedca9DbVRItIiIiIjIwKucQERERERkgJdEiIiIiIgOkJFpEREREZICURIuIiIiIDJCSaBERERGRAVISLSISg8zskP96vJl9JMTb/na3+6+EcvsiIiOBkmgRkdg2HhhQEt1lBq7evCuJds6dMsCYRERGPCXRIiKx7efAAjNbZWb/Y2YJZvZLM3vDzNaY2ecBzOwMM1tsZo8AG/zLHjKz5Wa23syu8i/7OZDm396d/mWBUW/zb3udma01sw922fYLZna/mW0yszv9s7SJiIxY/Y1WiIhIdH0T+Jpz7iIAfzJc55w73sxSgJfN7Cn/unOBmc65Hf77n3bOHfRPc/uGmT3gnPummV3nnJvTw74uxTfD2jH4ZjF8w8xe8j92LDAD2A28DJwKLAn1ixURiRcaiRYRiS/nAh83s1X4pn4eBZT7H3u9SwINcL2ZrQZeBcZ2Wa8384G7nXOdzrm9wIvA8V22XeGc8wKr8JWZiIiMWBqJFhGJLwZ80Tn35LsWmp0BNHa7fzZwsnOuycxeAFKHsN/WLrc70f8fIjLCaSRaRCS2NQBZXe4/CVxjZkkAZjbFzDJ6eF4OUONPoKcBJ3V5rD3w/G4WAx/0110XAqcBr4fkVYiIDDMaSRARiW1rgE5/WcYdwO/wlVKs8J/ctx94fw/PewK42sw2ApvxlXQE/BlYY2YrnHNXdln+H+BkYDXggP91zu3xJ+EiItKFOeeiHYOIiIiISFxROYeIiIiIyAApiRYRERERGSAl0SIiIiIiA6QkWkRERERkgJREi4iIiIgMkJJoEREREZEBUhItIiIiIjJASqJFRERERAbo/wObOXPC9pBsYwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -819,7 +831,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Predicted labels: ['A' 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'A' 'A']\n", + "Predicted labels: ['A' 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'A' 'B']\n", "Ground truth: ['A' 'A' 'B' 'C' 'C' 'A' 'B' 'B' 'A' 'C']\n" ] } @@ -848,7 +860,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -879,9 +891,9 @@ "id": "talented-capitol", "metadata": {}, "source": [ - "### Regression with an `OpflowQNN`\n", + "### Regression with an `EstimatorQNN`\n", "\n", - "Here we restrict to regression with an `OpflowQNN` that returns values in $[-1, +1]$. More complex and also multi-dimensional models could be constructed, also based on `CircuitQNN` but that exceeds the scope of this tutorial." + "Here we restrict to regression with an `EstimatorQNN` that returns values in $[-1, +1]$. More complex and also multi-dimensional models could be constructed, also based on `SamplerQNN` but that exceeds the scope of this tutorial." ] }, { @@ -901,8 +913,15 @@ "ansatz = QuantumCircuit(1, name=\"vf\")\n", "ansatz.ry(param_y, 0)\n", "\n", + "# construct a circuit\n", + "qc = QuantumCircuit(1)\n", + "qc.compose(feature_map, inplace=True)\n", + "qc.compose(ansatz, inplace=True)\n", + "\n", "# construct QNN\n", - "regression_opflow_qnn = TwoLayerQNN(1, feature_map, ansatz, quantum_instance=quantum_instance)" + "regression_estimator_qnn = EstimatorQNN(\n", + " circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters\n", + ")" ] }, { @@ -914,7 +933,7 @@ "source": [ "# construct the regressor from the neural network\n", "regressor = NeuralNetworkRegressor(\n", - " neural_network=regression_opflow_qnn,\n", + " neural_network=regression_estimator_qnn,\n", " loss=\"squared_error\",\n", " optimizer=L_BFGS_B(maxiter=5),\n", " callback=callback_graph,\n", @@ -929,7 +948,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtEAAAGDCAYAAADtZ0xmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABAOklEQVR4nO3dd5hU5fn/8c+9jV3a0hap0mHFgsqKYgEURVAjiRqjRk3svTfMN9X8Egv2EhVj7y0ak0hRBMEgymJHei/Se99y//6Ys2RYt8zCzp7ZnffruubaPf1zziwX9zzznPOYuwsAAABA7FLCDgAAAADUNhTRAAAAQBVRRAMAAABVRBENAAAAVBFFNAAAAFBFFNEAAABAFVFEAyiXmf3RzF6qYPk0MxsQh+PGa78/M7PFZrbZzA6p7v1XcNxfmtmYmjpeLMzsOTP7f2HnqAozG2lmv6orx6kkw2Yz6xxmBgAVo4gGkpiZ/drMvjWzrWa23MweN7MmsW7v7vu7+/i9zPCjYq469luOeyVd7e4N3f3LOOxfZtbRzNzM0krmufvL7j4oHsdLJu4+xN2f35t9BH/zn8R6nFjW31tmNt7MLi6VoaG7z4vncQHsHYpoIEmZ2U2S7pZ0i6RsSUdI6iDpAzPLCDNbHHWQNC3sEEge0R+mANQtFNFAEjKzxpL+JOkadx/l7gXuvkDSmZI6Sjo3avVMM3vdzDaZ2Rdm1itqPwvM7Pjg9xQzG2Zmc81sjZm9YWbNotY92swmmdn6oEvFr83sUkm/lHRr8PX1v6L3a2ZtzGxbqf0cYmarzSw9mL7QzKab2TozG21mHco433pmtllSqqSvzWxuMN/NrGvUertaxc1sgJktMbObzGylmf1gZhdErZtlZveZ2UIz22Bmn5hZlqQJwSrrg3PqW7o108yONLMpwXZTzOzIqGXjzezPZvbf4JqPMbMW5byP083slKjpNDNbZWaHBtNvBt8wbDCzCWa2fzn7+VFra/S1Ca7fvWa2yMxWmNkTwbmWta8uZvZR8Dew2sxejv52w8wONbMvg3N7M/jbKrnmTc3s38E5rAt+b1fq2lwcnTnItc7M5pvZkFLnNC84znyLdKnZT9ITkvoG7836cs5hvJldXN76FV2PqL+b28xsuaRnKzovM/uLpGMkPRoc49Eyrn+2mb0QbL/QzH5rZimxXAcA8UMRDSSnIyVlSvpH9Ex33yzpfUknRM0eKulNSc0kvSLpXQsK2FKukfRTSf0ltZG0TtJjkmSRwnakpEck5Ug6WNJX7j5C0suS7gm+vv5JqTzLJH0q6fSo2edIesvdC8xsqKTfSDot2O9ESa+WDubuO9y9YTDZy927lHdhSmmlSCt9W0kXSXrMzJoGy+6V1FuRa9lM0q2SiiX1C5Y3Cc7p0+gdWuQDwX8kPSypuaT7Jf3HzJqXOscLJLWUlCHp5nLyvSrp7KjpEyWtdvcvgumRkroF+/lCkWu9J+6S1F2R962rItfj9+Wsa5LuVORvYD9J7SX9UZIs8g3HO5KeU+SavSrpZ1Hbpkh6VpFvDPaVtE3SoxXkOlzSTEktJN0j6WmLaKDI9R3i7o0UeY++cvfpki6X9Gnw3jSp6KQrWL+y69EqOL8Oki6t6Lzc/f8U+bst6WZ0dRlRHlHk77CzIv++zlfk76PC61DRuQHYexTRQHJqoUixVVjGsh+C5SWmuvtb7l6gSMGXqUjXj9Iul/R/7r7E3XcoUjidYZGvs8+R9KG7vxq0eq9x969izPqKgkIxKAzOCuaVHPNOd58enMtfJR1sZbRG76ECSXcEmd+XtFlSj6AV8EJJ17n7UncvcvdJwXlX5mRJs939RXcvdPdXJc2QFP0B4ll3n+Xu2yS9oUixVpZXJJ1qZvWD6XMU9SHC3Z9x901R70cvM8uO9eSlXdf8Ukk3uPtad9+kyHU+q6z13X2Ou38QfHBZpcjfTP9g8RGS0iQ9HFzTf0j6PGrbNe7+trtvDY7zl6hty7LQ3Z9y9yJJz0tqLWmfYFmxpAPMLMvdf3D3aunGE+P1KJb0h+AabNuD84o+Xmqw79uD93KBpPsknRe1WkXXAUCcUEQDyWm1pBZWdn/N1sHyEotLfnH3YklLFGllLK2DpHcs0l1jvaTpkooU+c+8vaS5e5j1bUW+Tm+tSCtvsSItdyXHfCjqmGsVaQltu4fHKm1NqQ8aWyU1VORDRqb27JzaSFpYat5C7Z55eRnH/BF3n6PIdf5JUEifquADhpmlmtldFules1HSgmCzMruGVCBHUn1JU6Ou86hg/o+Y2T5m9pqZLQ2O+1LUMdtIWuruHrXJ4qht65vZk0GXhY2KdI1pEhSSZdl1ndx9a/BrQ3ffIukXinzI+sHM/mNmuVU87/LEcj1Wufv2vTivaC0kpWv3v5ly/16ir0MVzgnAHqCIBpLTp5J2KNINYhczayhpiKSxUbPbRy1PkdRO0rIy9rlYka/Pm0S9Mt19abCsvC4UXs78yEL3dZLGKFIUnSPptagibLGky0odM8vdJ1W0zyhbFSmISrSKcbvVkrar7HOq8HwUuXalW8r3lbQ0xmOXVtKlY6ik74PCWopcq6GSjlekK0DHYH5ZX/NvUdR1MLPo67Bake4H+0dd4+yo7jGl/VWRa3CguzdWpH99yTF/kNS2VFeD9lG/3ySph6TDg21LusZUuWuCu4929xMU+VA4Q9JTJYuquqtS07Fcj9LbVHZeFWVarcg3ItF/M3vz9wKgmlBEA0nI3TcocmPhI2Y22MzSzayjIl0Hlkh6MWr13mZ2WtBqfb0ixffkMnb7hKS/lHSlMLOcoM+yFOmLe7yZnWmRm9+am9nBwbIVivT1rMgrivQDPUP/68pRcszbLbhhLrgB6+eVX4FdvpJ0TtBqO1gxfsUetMg/I+l+i9z8mGqRGwjrSVqlSGt5eef0vqTuZnZOcC1+IamnpH9XIXe01yQNknSFdr82jRR5r9YoUiD/tYJ9fC1pfzM72MwyFfRhlnad61OSHjCzlpJkZm3N7MRy9tVIkW4vG8ysrSJPfynxqSLfTlwdnPtQSX1KbbtNkZsym0n6Q0UnXp6gNXxo0Dd6R5CnOFi8QlI7i/0JNLutvwfXQ6r8vMr9NxB00XhDkX9bjYJ/Xzcq0sIPIEQU0UCScvd7FLkp715JGyV9pkjL7sBSfXv/qUgr8DpF+mGeFvSPLu0hSe9JGmNmmxQptA8PjrVI0kmKtMitVaR4LXnKx9OSegZfjb9bTtz3FLlBbrm7fx11Du8o8pi+14Kvyb9TpCU9Vtcp0hd5vSJPCSnv+GW5WdK3kqYock53S0oJvk7/i6T/Bue0W/9xd18j6RRFrsUaRW5IPMXdo7vQxMzdf1CkOD1S0utRi15Q5Gv/pZK+V9kffEr2MUvSHZI+lDRbUunnIt8maY6kycF1/lCRltWy/EnSoZI2KHID5a6bV919pyLfflykyDU/V5EPDyV/bw9KylKk9XWyIt0k9kSKIoXmMkXem/6KfMiQpI8UeczhcjOL5ZqXtX5VrodU+Xk9pMj9A+vM7OEytr9GkW8L5iny3ryiyIc4ACGy3bumAUDszGyRpHPdfUKlKwNlMLPPJD3h7s+GnQUAqoKWaAB7xMxyFLmZakHIUVCLmFl/M2sVdOf4laSDtOctzgAQmrgV0Wb2jEUGKPiunOW/NLNvLDLk8CSLGsABQGIzs8MU+dr/kaCrBhCrHor0wV6vSJeWM4IuKQBQq8StO4eZ9VPkZo4X3P2AMpYfKWm6u6+zyOhKf3T3w+MSBgAAAKhGZT0jtlq4+4Tgbv/ylkc/gmqyIo/NAgAAABJeovSJvkiR4WkBAACAhBe3luhYmdmxihTRR1ewzqWKDLOqBg0a9M7Nra6BpwAAAICyTZ06dbW7lzlCa6hFtJkdJOnvioxytqa89dx9hKQRkpSXl+f5+fk1lBAAAADJyswWlrcstO4cZravIg/hPy940D8AAABQK8StJdrMXpU0QFILM1uiyDCn6ZLk7k9I+r2k5pL+ZmaSVOjuefHKAwAAAFSXeD6d4+xKll8s6eJ4HR8AAACIl0R5OgcAAABQa1BEAwAAAFVEEQ0AAABUEUU0AAAAUEUU0QAAAEAVUUQDAAAAVUQRDQAAAFQRRTQAAABQRRTRMXB3jZ62XJu2F4QdBQAAAAmAIjoGs1Zs1mUvTtVTE+aFHQUAAAAJgCI6Bj1aNdIpB7XWUxPna+XG7WHHAQAAQMgoomN0y4k9VFhcrAfHzg47CgAAAEJGER2jDs0b6JeHd9DrUxZr7qrNYccBAABAiCiiq+Ca47oqKz1V94yaEXYUAAAAhIgiugqaN6yny/p11uhpKzR14dqw4wAAACAkFNFVdNExndSyUT3d+f4MuXvYcQAAABACiugqqp+RpuuP7678hev0wfcrwo4DAACAEFBE74Ez89qpS04D3T1qhgqLisOOAwAAgBpGEb0H0lJTdOvgXM1dtUVvTl0SdhwAAADUMIroPTSo5z7q3aGpHvhglrbuLAw7DgAAAGoQRfQeMjP95qRcrdy0Q898Mj/sOAAAAKhBFNF7oXeHZhrUcx898fE8rdm8I+w4AAAAqCEU0Xvp1sG52lZQpEc+mhN2FAAAANQQiui91LVlQ52Z114vf7ZQi9ZsDTsOAAAAagBFdDW44fhuSktJ0fAxM8OOAgAAgBpAEV0NWjbO1MXHdNK/vl6mb5asDzsOAAAA4owiuppc2q+zmjXI0F0jGQ4cAACgrqOIriaNMtN17XFdNWnuGn08a1XYcQAAABBHFNHV6JzDO6hD8/q6a+QMFRXTGg0AAFBXUURXo4y0FN08qIdmLN+kd79cGnYcAAAAxAlFdDU7+cDWOqhdtu7/YJa2FxSFHQcAAABxQBFdzVJSTMOG5Grp+m164dMFYccBAABAHFBEx8GRXVpoQI8cPTZurjZsLQg7DgAAAKoZRXSc3DY4Vxu3F+hv4xkOHAAAoK6hiI6T/Vo31s8OaatnJy3Q0vXbwo4DAACAakQRHUc3DeohSbp/zKyQkwAAAKA6UUTHUdsmWfr1kR31jy+XaPoPG8OOAwAAgGpCER1nVw7ookb10nT3qBlhRwEAAEA1oYiOsyb1M3TVsV01fuYqTZq7Ouw4AAAAqAYU0TXgV0d2VJvsTN01coaKGQ4cAACg1qOIrgGZ6am6cVAPfbNkg/7z7Q9hxwEAAMBeooiuIT87pK1yWzXS8NEztbOwOOw4AAAA2AsU0TUkNcV025BcLVq7Va98tjDsOAAAANgLFNE1aED3HPXt3FwPfzRHm7YzHDgAAEBtFbci2syeMbOVZvZdOcvNzB42szlm9o2ZHRqvLInCzHT7Sblau2WnRkyYF3YcAAAA7KF4tkQ/J2lwBcuHSOoWvC6V9HgcsySMg9o10SkHtdbfJ87Xyo3bw44DAACAPRC3ItrdJ0haW8EqQyW94BGTJTUxs9bxypNIbjmxhwqLi/XAh7PDjgIAAIA9EGaf6LaSFkdNLwnm/YiZXWpm+WaWv2rVqhoJF08dmjfQLw/voDfyF2vOys1hxwEAAEAV1YobC919hLvnuXteTk5O2HGqxTXHdVVWeqruYThwAACAWifMInqppPZR0+2CeUmhecN6uqxfZ435foXyF1TU6wUAAACJJswi+j1J5wdP6ThC0gZ3T6rh/C46ppNaNqqnO0fOkDvDgQMAANQW8XzE3auSPpXUw8yWmNlFZna5mV0erPK+pHmS5kh6StKV8cqSqOpnpOn647tr6sJ1GvP9irDjAAAAIEZp8dqxu59dyXKXdFW8jl9bnJnXTk9/Mk/3jJqhgbktlZZaK7qpAwAAJDUqtpClpabo1sG5mrtqi97IXxJ2HAAAAMSAIjoBDOq5j3p3aKoHPpylrTsLw44DAACASlBEJwAz029OytWqTTv09MT5YccBAABAJSiiE0TvDs00qOc+enLCPK3ZvCPsOAAAAKgARXQCuXVwrrYVFOmRj+aEHQUAAAAVoIhOIF1bNtSZee318mcLtXDNlrDjAAAAoBwU0QnmhuO7KS0lRcNHzww7CgAAAMpBEZ1gWjbO1MXHdNK/v/lBXy9eH3YcAAAAlIEiOgFd2q+zmjXI0F0MBw4AAJCQKKITUKPMdF17XFd9Om+Nxs9aFXYcAAAAlEIRnaDOObyDOjSvr7tHzlBRMa3RAAAAiYQiOkFlpKXo5kE9NGP5Jr3z5dKw4wAAACAKRXQCO/nA1jqoXbbuHzNT2wuKwo4DAACAAEV0AktJMQ0bkqtlG7br+UkLwo4DAACAAEV0gjuySwsN6JGjx8bN0fqtO8OOAwAAAFFE1wq3Dc7Vph2F+tv4uWFHAQAAgCiia4X9WjfWaYe003OTFmjp+m1hxwEAAEh6FNG1xI2DukuS7hvDcOAAAABho4iuJdo2ydIFR3bUO18u1ffLNoYdBwAAIKlRRNciVw7oqsaZ6bp71IywowAAACQ1iuhaJLt+uq46tos+nrVKk+asDjsOAABA0qKIrmXO79tRbZtk6c6RM1TMcOAAAAChoIiuZTLTU3XjCd317dIN+ve3P4QdBwAAIClRRNdCPz2krXJbNdK9o2dqZ2Fx2HEAAACSDkV0LZQaDAe+aO1WvfzZwrDjAAAAJB2K6Fqqf/ccHdmluR75aI42bS8IOw4AAEBSoYiupcxMtw/ZT2u37NSTH88LOw4AAEBSoYiuxQ5sl62f9Gqjv38yTys2bg87DgAAQNKgiK7lbhnUQ0XFrgc/nBV2FAAAgKRBEV3L7du8vn55eAe9PmWx5qzcFHYcAACApEARXQdcc1xX1c9I092jZoYdBQAAIClQRNcBzRvW0+X9O+uD71cof8HasOMAAADUeRTRdcSFR3dSy0b19Nf3p8ud4cABAADiiSK6jqifkaYbTuiuLxat1+hpK8KOAwAAUKdRRNchP+/dTl1yGuie0TNUWMRw4AAAAPFCEV2HpKWm6LbBuZq3aotez18cdhwAAIA6iyK6jjmh5z7K69BUD344W1t3FoYdBwAAoE6iiK5jzEy3n5SrVZt26O8T54cdBwAAoE6iiK6DendophP330dPfjxXqzfvCDsOAABAnUMRXUfdOjhX2wuL9cjY2WFHAQAAqHMoouuoLjkN9YvD2uvlzxZpweotYccBAACoUyii67DrB3ZTemqKho9hOHAAAIDqRBFdh7VsnKlLjumk/3zzg75evD7sOAAAAHVGXItoMxtsZjPNbI6ZDStj+b5mNs7MvjSzb8zspHjmSUaX9u+i5g0ydOdIhgMHAACoLnEros0sVdJjkoZI6inpbDPrWWq130p6w90PkXSWpL/FK0+yalgvTdcO7KbJ89Zq/MxVYccBAACoE2Iqos2sg5kdH/yeZWaNYtisj6Q57j7P3XdKek3S0FLruKTGwe/ZkpbFFhtVcXaffdWheX3dNXKGioppjQYAANhblRbRZnaJpLckPRnMaifp3Rj23VZS9NjTS4J50f4o6VwzWyLpfUnXxLBfVFFGWopuObGHZq7YpH98sSTsOAAAALVeLC3RV0k6StJGSXL32ZJaVtPxz5b0nLu3k3SSpBfN7EeZzOxSM8s3s/xVq+iSsCdOPrC1erXL1v0fzNL2gqKw4wAAANRqsRTRO4LuGJIkM0tTpBtGZZZKah813S6YF+0iSW9Ikrt/KilTUovSO3L3Ee6e5+55OTk5MRwapZmZhg3ZTz9s2K7nJi0IOw4AAECtFksR/bGZ/UZSlpmdIOlNSf+KYbspkrqZWSczy1DkxsH3Sq2zSNJASTKz/RQpomlqjpO+XZrr2B45+tu4OVq/dWflGwAAAKBMsRTRwxQpbL+VdJkifZd/W9lG7l4o6WpJoyVNV+QpHNPM7A4zOzVY7SZJl5jZ15JelfRr5zlscXXbkFxt2lGox8bNCTsKAABArWW1rWbNy8vz/Pz8sGPUaje/+bXe+2qZPrq5v9o1rR92HAAAgIRkZlPdPa+sZbE8nWO+mc0r/ar+mKgpN57QXWbS/WNmhR0FAACgVkqLYZ3o6jtT0s8lNYtPHNSENk2y9OujOmrEhHm6+JjO6tmmceUbAQAAYJdKW6LdfU3Ua6m7Pyjp5PhHQzxd2b+rGmem665RM8KOAgAAUOvE0p3j0KhXnpldrthasJHAsuun6+pju2rCrFX675zVYccBAACoVWJ5Osd9Ua87JfWWdGY8Q6FmnNe3g9o2ydKdI6ermOHAAQAAYlZpi7K7H1sTQVDzMtNTddOg7rrxja/1r2+WaejBpUdlBwAAQFnKLaLN7MaKNnT3+6s/DmraTw9uq6cmzte9Y2Zq8AGtVC8tNexIAAAACa+i7hyNKnmhDkhJMQ0bkqvFa7fp5cmLwo4DAABQK5TbEu3uf6rJIAhPv24tdFTX5nrko9k6I6+dGmemhx0JAAAgocXydI5MM7vKzP5mZs+UvGoiHGqGmWnY4P20bmuBnvx4bthxAAAAEl4sT+d4UVIrSSdK+lhSO0mb4hkKNe/Adtk6tVcbPf3JfC3fsD3sOAAAAAktliK6q7v/TtIWd39ekYFWDo9vLIThlhN7qKjY9eCHDAcOAABQkViK6ILg53ozO0BStqSW8YuEsLRvVl/nHtFBb+Qv1uwVfNkAAABQnliK6BFm1lTS7yS9J+l7SXfHNRVCc81x3dQgI013j5oZdhQAAICEFUsR/ay7r3P3j929s7u3dPcn454MoWjWIEOXD+iiD6ev0JQFa8OOAwAAkJBiKaLnm9kIMxtoZhb3RAjdhUd10j6N6+mv70+XO8OBAwAAlBZLEZ0r6UNJV0laYGaPmtnR8Y2FMGVlpOqG47vry0XrNXra8rDjAAAAJJxKi2h33+rub7j7aZIOltRYkUfdoQ47o3c7dW3ZUPeMmqmCouKw4wAAACSUWFqiZWb9zexvkqZKypR0ZlxTIXRpqSm6bXCu5q3eotenLA47DgAAQEKJZcTCBZKulzRR0oHufqa7vx3nXEgAx+/XUod1bKoHP5ytLTsKw44DAACQMGJpiT7I3X/m7q+6+5a4J0LCMDMNG7KfVm/eob9PnB92HAAAgIQRS5/ojTURBImpd4emGrx/K42YMFerN+8IOw4AAEBCiKlPNJLbLYN7aHthsR4eOzvsKAAAAAmBIhqV6pLTUGcd1l6vfLZI81fTowcAACCWGwvrmdk5ZvYbM/t9yasmwiFxXHd8N2Wkpeje0QwHDgAAEEtL9D8lDZVUKGlL1AtJpGWjTF18TGf959sf9NXi9WHHAQAACFVaDOu0c/fBcU+ChHdpv8565bOFuvP96Xrt0iPEKPAAACBZxdISPcnMDox7EiS8hvXSdO3Abvps/lqNm7ky7DgAAAChiaWIPlrSVDObaWbfmNm3ZvZNvIMhMZ3dZ191bF5fd4+cqaJiDzsOAABAKGIpoodI6iZpkKSfSDol+IkklJ6aoltOzNXMFZv09hdLwo4DAAAQilgGW1koqYkihfNPJDUJ5iFJnXRgK/Vq30QPfDBL2wuKwo4DAABQ42J5xN11kl6W1DJ4vWRm18Q7GBKXmen2Ibn6YcN2PfvfBWHHAQAAqHGxdOe4SNLh7v57d/+9pCMkXRLfWEh0R3RuruNyW+pv4+do3ZadYccBAACoUbEU0SYp+jv7omAektxtg3O1ZUehHhs3J+woAAAANSqWIvpZSZ+Z2R/N7I+SJkt6Oq6pUCv0aNVIpx/aTi98ulCL124NOw4AAECNieXGwvslXSBpbfC6wN0fjHMu1BI3DuouM+n+D2aFHQUAAKDGlFtEm1nj4GczSQskvRS8FgbzALXOztIFR3XSu18t1bRlG8KOAwAAUCMqaol+Jfg5VVJ+1KtkGpAkXTGgi7Kz0nXXyBlhRwEAAKgR5RbR7n5K8LOTu3eOenVy9841FxGJLjsrXVcf21UTZ6/WJ7NXhx0HAAAg7mJ5TvTYWOYhuZ3Xt4PaNsnSnSOnq5jhwAEAQB1XUZ/ozKDvcwsza2pmzYJXR0ltaywhaoV6aam6+cTumrZso/71zbKw4wAAAMRVRS3RlynS/zk3+Fny+qekR+MfDbXN0F5t1bN1Yw0fPVM7ChkOHAAA1F0V9Yl+yN07Sbo5qi90J3fv5e4U0fiRlBTTsCG5WrJum16avCjsOAAAAHETy2ArxWbWpGQi6NpxZfwioTbr1z1HR3dtoUc/mq2N2wvCjgMAABAXsRTRl7j7+pIJd18n6ZJYdm5mg81sppnNMbNh5axzppl9b2bTzOyVstZB7TJsSK7WbS3QE+Pnhh0FAAAgLmIpolPNzEomzCxVUkZlGwXrPSZpiKSeks42s56l1ukm6XZJR7n7/pKujz06EtUBbbM19OA2eua/87V8w/aw4wAAAFS7WIroUZJeN7OBZjZQ0qvBvMr0kTTH3ee5+05Jr0kaWmqdSyQ9FrRuy91Xxh4diezmQT1UXCw9wHDgAACgDoqliL5N0jhJVwSvsZJujWG7tpIWR00v0Y8fjdddUncz+6+ZTTazwWXtyMwuNbN8M8tftWpVDIdG2No3q69zj+igN6cu1uwVm8KOAwAAUK0qLaLdvdjdH3f3M4LXk+5eXc8vS5PUTdIASWdLeir6JsaoDCPcPc/d83Jycqrp0Ii3q4/rqgYZabp7FMOBAwCAuiWWEQuPMrMPzGyWmc0zs/lmNi+GfS+V1D5qul0wL9oSSe+5e4G7z5c0S5GiGnVAswYZunxAF304faU+n7827DgAAADVJpbuHE9Lul/S0ZIOk5QX/KzMFEndzKyTmWVIOkvSe6XWeVeRVmiZWQtFunfEUqCjlrjwqE5q1ThTd46cLneGAwcAAHVDLEX0Bncf6e4r3X1Nyauyjdy9UNLVkkZLmi7pDXefZmZ3mNmpwWqjJa0xs+8V6Xd9Syz7Ru2RlZGqG07opi8Xrdeo75aHHQcAAKBaWGWtg2Z2l6RUSf+QtKNkvrt/Ed9oZcvLy/P8/PwwDo09VFhUrCEPTVRhsWvMDf2UnhrLZzcAAIBwmdlUd88ra1laDNsfHvyM3oFLOm5vgyE5pKWm6LbBubr4hXy9NmWxzjuiQ9iRAAAA9kqlRbS7H1sTQVC3DdyvpQ7r2FQPfThbpx3SVg3qxfL5DQAAIDFVWsmY2e/Lmu/ud1R/HNRVZqZhQ/bT6Y9P0lMT5+n647uHHQkAAGCPxdI5dUvUq0iRYbw7xjET6qjeHZpq8P6tNGLCPK3atKPyDQAAABJULIOt3Bf1+osij6TrHPdkqJNuGdxDOwqL9fDY2WFHAQAA2GN78piE+ooMnAJUWZechjrrsPZ69fNFmr96S9hxAAAA9kgsIxZ+a2bfBK9pkmZKejDuyVBnXXd8N2WkpWj4aIYDBwAAtVO5NxaaWadgKO5TomYXSloRDKQC7JGWjTJ18TGd9fDY2fpy0Todsm/TsCMBAABUSUUt0W8FP59x94XBaykFNKrDpf06q0XDDN05cgbDgQMAgFqnokfcpZjZbyR1N7MbSy909/vjFwt1XcN6abp2YDf9/p/T9NGMlRq43z5hRwIAAIhZRS3RZynySLs0SY3KeAF75ew++6pj8/q6e9QMFRXTGg0AAGqPclui3X2mpLvN7Bt3H1mDmZAk0lNTdMuJubrqlS/09tQlOvOw9mFHAgAAiEksz4mmgEbcnHRgK/Vq30T3fzBL23YWhR0HAAAgJnvynGig2piZbh+Sq+Ubt+vZSfPDjgMAABATimiE7ojOzXVcbks9Pn6u1m3ZGXYcAACASsUy2Ep9M/udmT0VTHczs1Mq2w6oitsG52rLjkI9Om5O2FEAAAAqFUtL9LOSdkjqG0wvlfT/4pYISalHq0Y6/dB2evHThVq8dmvYcQAAACoUSxHdxd3vkVQgSe6+VZLFNRWS0o2DustMum/MzLCjAAAAVCiWInqnmWVJckkysy6KtEwD1ap1dpYuOKqT3v1qmb5buiHsOAAAAOWKpYj+o6RRktqb2cuSxkq6NZ6hkLyuGNBFTeqn6+5RM8KOAgAAUK5YnhM9RtJpkn4t6VVJee4+Pr6xkKyys9J19bFdNXH2ak2cvSrsOAAAAGWK5ekc/5I0SNJ4d/+3u6+Ofywks/P6dlDbJlm6a+QMFTMcOAAASECxdOe4V9Ixkr43s7fM7Awzy4xzLiSxemmpuvnE7pq2bKPe+3pZ2HEAAAB+JJbuHB+7+5WSOkt6UtKZklbGOxiS29BebdWzdWPdO2amdhQyHDgAAEgsMY1YGDyd43RJl0s6TNLz8QwFpKSYhg3J1ZJ12/TipwvDjgMAALCbWPpEvyFpuqTjJD2qyHOjr4l3MKBf9xwd3bWFHh03Rxu2FYQdBwAAYJdYWqKfVqRwvtzdx7l7cbxDASWGDcnV+q0FeuLjuWFHAQAA2CWtvAVmdpy7fySpgaShZrsPUuju/4hzNkAHtM3W0IPb6JlP5uv8vh3UOjsr7EgAAAAVtkT3D37+pIzXKXHOBexy86Aecpce+GBW2FEAAAAkVdAS7e5/CH69w93nRy8zs05xTQVEad+svs49ooOemzRfFx/TWd33aRR2JAAAkORi6RP9dhnz3qruIEBFrj6uqxpkpOnukQwHDgAAwldRn+hcSftLyjaz06IWNZbEYCuoUc0aZOjyAV00fPRMfTZvjQ7v3DzsSAAAIIlV1BLdQ5G+z020e3/oQyVdEvdkQCkXHtVJrRpn6s6RM+TOcOAAACA8FfWJ/qekf5pZX3f/tAYzAWXKykjVDSd0021vf6uR3y3XSQe2DjsSAABIUrH0ib7czJqUTJhZUzN7Jn6RgPKdfmg7dWvZUMNHz1RBEY8sBwAA4YiliD7I3deXTLj7OkmHxC0RUIG01BTdNjhX81dv0WufLwo7DgAASFKxFNEpZta0ZMLMmqmCbiBAvA3cr6X6dGymh8bO1uYdhWHHAQAASSiWIvo+SZ+a2Z/N7M+SJkm6J76xgPKZmYadlKvVm3fqqQnzwo4DAACSUKVFtLu/IOk0SSuC12nu/mK8gwEVOXTfphpyQCs9NXGeVm7aHnYcAACQZGJpiZakZpK2uPujklYxYiESwS0n9tCOwmI9PHZ22FEAAECSqbSINrM/SLpN0u3BrHRJL8UzFBCLzjkNdXaf9nr188Wat2pz2HEAAEASiaUl+meSTpW0RZLcfZmkRvEMBcTquoHdVS8tRcNHzww7CgAASCKxFNE7PTI8nEuSmTWIbyQgdjmN6umSYzpr5HfL9cWidWHHAQAASSKWIvoNM3tSUhMzu0TSh5KeimXnZjbYzGaa2RwzG1bBeqebmZtZXmyxgf+5pF9ntWiYobveZzhwAABQM2J5Ose9kt6S9LakHpJ+7+6PVLadmaVKekzSEEk9JZ1tZj3LWK+RpOskfVa16EBEw3ppum5gN32+YK0+mrEy7DgAACAJxPR0Dnf/wN1vcfeb3f2DGPfdR9Icd5/n7jslvSZpaBnr/VnS3ZJ4Thn22Fl99lWnFg1096gZKiqmNRoAAMRXuUW0mX0S/NxkZhvLeM03sysr2HdbSYujppcE86KPcaik9u7+n704B0DpqSm65cQemrVis96euiTsOAAAoI4rt4h296ODn43cvXHpl6Q8Rbph7BEzS5F0v6SbYlj3UjPLN7P8VatW7ekhUccNOaCVDm7fRPd/MEvbdhaFHQcAANRhMXXnMLNDzexaM7vGzA6RJHdfI2lABZstldQ+arpdMK9EI0kHSBpvZgskHSHpvbJuLnT3Ee6e5+55OTk5sURGEjIz3T4kV8s3btezk+aHHQcAANRhsQy28ntJz0tqLqmFpOfM7LeS5O4/VLDpFEndzKyTmWVIOkvSeyUL3X2Du7dw947u3lHSZEmnunv+Hp8Nkt7hnZtrYG5LPT5+rtZt2Rl2HAAAUEfF0hL9S0mHufsf3P0PirQYn1fZRu5eKOlqSaMlTZf0hrtPM7M7zOzUvQkNVOS2IbnasqNQj46bE3YUAABQR6XFsM4ySZn639Mz6mn3bhnlcvf3Jb1fat7vy1l3QCz7BCrTfZ9GOqN3O7346UL9+siOat+sftiRAABAHVPR0zkeMbOHJW2QNM3MnjOzZyV9J2l9DeUD9sgNJ3SXmXTfGIYDBwAA1a+iluiSvslTJb0TNX983NIA1aR1dpYuPLqTHh8/Vxcf01kHtM0OOxIAAKhDyi2i3f15STKzTEldg9lz3J1BUVArXN6/i179fJHuHjVDL150eNhxAABAHVJRd440M7tHkUFSnpf0gqTFZnaPmaXXVEBgT2VnpevqY7tq4uzVmjib54sDAIDqU9HTOYZLaiapk7v3dvdDJXWR1ETSvTWQDdhr5/XtoHZNs3TXyBkqZjhwAABQTSoqok+RdIm7byqZ4e4bJV0h6aR4BwOqQ720VN08qIemLduo975eFnYcAABQR1RURLu7/6jpzt2LJNGkh1rj1F5ttH+bxrp3zEztKGQ4cAAAsPcqKqK/N7PzS880s3MlzYhfJKB6paSYhg3J1ZJ12/TipwvDjgMAAOqAih5xd5Wkf5jZhYo85k6S8iRlSfpZvIMB1emYbjk6plsLPTpujn6e117ZWdwbCwAA9ly5LdHuvtTdD5d0h6QFwesOd+/j7jGNWAgkktsG52r91gI98fHcsKMAAIBartJhv939I0kf1UAWIK4OaJutnx7cRs98Ml/n9+2g1tlZYUcCAAC1VEV9ooE656ZBPeQuPfDBrLCjAACAWowiGkmlfbP6Oq9vB701dYlmrdhU+QYAAABloIhG0rn62K5qUC9Nd4/kITMAAGDPUEQj6TRtkKErBnTR2Bkr9dm8NWHHAQAAtRBFNJLShUd1UqvGmbpz5AyVMaYQAABAhSiikZQy01N14wnd9dXi9Rr53fKw4wAAgFqGIhpJ6/Te7dR9n4YaPnqmCoqKw44DAABqEYpoJK3UFNNtg3M1f/UWvfb5orDjAACAWoQiGkntuNyW6tOpmR4aO1ubdxSGHQcAANQSFNFIamam24fkavXmnXpqwryw4wAAgFqCIhpJ75B9m+qkA1vpqYnztHLT9rDjAACAWoAiGpB0y4m52llYrIfHzg47CgAAqAXSwg4AJIJOLRro7D776pXPFykrPVVXH9tN2fXTw44FAAASFEU0ELh1cA9tLyjS3z+Zrzfyl+ia47rqvL4dVC8tNexoAAAgwdCdAwg0ykzX8J/30n+uOUYHtcvW//vPdJ1w/wT9+5tljGoIAAB2QxENlNKzTWO9eNHhev7CPqqfkaqrX/lSpz0+SfkL1oYdDQAAJAiKaKAc/bvn6D/XHqN7Tj9Iy9Zv0xlPfKrLX5yq+au3hB0NAACEjD7RQAVSU0xnHtZep/Rqrb9PnK8nPp6rD6ev0LlHdNC1A7upWYOMsCMCAIAQWG3r65mXl+f5+flhx0CSWrlpux78cLZe+3yRGmSk6cpju+qCozoqM52bDwEAqGvMbKq755W1jO4cQBW0bJSpv/7sQI2+vp/6dGqmu0fN0HH3jtc7Xy5RcXHt+kAKAAD2HEU0sAe67dNIT//6ML16yRFq3rCebnj9a5362CeaNGd12NEAAEANoIgG9kLfLs31z6uO0oO/OFjrthTonL9/pgufm6LZKzaFHQ0AAMQRRTSwl1JSTD89pK3G3tRfw4bkasr8tTrxwQm6/R/fauWm7WHHAwAAccCNhUA1W7tlpx4eO1svTV6ojLQUXdaviy7p10n1M3gYDgAAtQk3FgI1qFmDDP3x1P31wY391b97jh74cJYGDB+v16csUhE3HwIAUCdQRANx0qlFAz1+bm+9dXlftW2apdve/lYnPzxRH89aFXY0AACwlyiigTjL69hM/7jiSD12zqHaurNIv3rmc5339Gf6ftnGsKMBAIA9RBEN1AAz08kHtdYHN/bT707pqW+XbtDJj0zUzW9+rR82bAs7HgAAqCJuLARCsGFrgR4bP0fP/XeBUlKki4/urMsHdFHDetx8CABAouDGQiDBZNdP129O2k9jb+qvQT1b6dFxczRg+Di9OHmhCouKw44HAAAqQRENhKh9s/p6+OxD9M+rjlLnnIb63bvf6cQHJ+iD71eotn1LBABAMqGIBhJAr/ZN9PqlR+ip8/Pkki55IV+/GDFZXy9eH3Y0AABQBopoIEGYmU7ouY9GX99Pf/7pAZq7crOGPvZfXffal1q8dmvY8QAAQJS4FtFmNtjMZprZHDMbVsbyG83sezP7xszGmlmHeOYBaoP01BSdd0QHjb9lgK4+tqtGfbdcA+/7WHe+P10bthWEHQ8AACiORbSZpUp6TNIQST0lnW1mPUut9qWkPHc/SNJbku6JVx6gtmmUma6bT+yh8bcM0E96tdGIifPUf/g4PfPJfO0s5OZDAADCFM+W6D6S5rj7PHffKek1SUOjV3D3ce5e8j31ZEnt4pgHqJVaZ2fpvjN76d/XHK0D2mTrjn9/rxMe+Fjvf/sDNx8CABCSeBbRbSUtjppeEswrz0WSRpa1wMwuNbN8M8tftYohk5Gc9m+TrRcv6qPnLjhMmWmpuvLlL3T645M0deHasKMBAJB0EuLGQjM7V1KepOFlLXf3Ee6e5+55OTk5NRsOSCBmpgE9Wur9647R3acfqCXrtun0xz/VFS9N1YLVW8KOBwBA0ojn8GhLJbWPmm4XzNuNmR0v6f8k9Xf3HXHMA9QZqSmmXxy2r37Sq42emjBfT06Yqw+nr9C5R3TQtcd1U9MGGWFHBACgTotnS/QUSd3MrJOZZUg6S9J70SuY2SGSnpR0qruvjGMWoE6qn5Gm647vpvG3DNAZvdvr+UkL1G/4OD3x8VxtLygKOx4AAHVW3Ipody+UdLWk0ZKmS3rD3aeZ2R1mdmqw2nBJDSW9aWZfmdl75ewOQAVaNsrUnacdqFHX99NhHZvprpEzNPC+j/Xul0tVXMzNhwAAVDerbXf35+XleX5+ftgxgIQ2ac5q/eX96Zq2bKMObJut35y0n/p2aR52LAAAahUzm+rueWUtS4gbCwFUryO7ttC/rj5a95/ZS2s279DZT03Wxc9P0ZyVm8KOBgBAnUARDdRRKSmm0w5tp49uHqBbB/fQZ/PW6sQHJ+r/3vlWqzZxDy8AAHuD7hxAklizeYce+WiOXpq8UPXSUnR5/y66+JjOyspIDTsaAAAJie4cANS8YT398dT9NeaGfjqmW47u+2CWBtw7Tm/kL1YRNx8CAFAlFNFAkumc01BPnNdbb17eV62zs3TrW9/o5IcnasIsRgMFACBWFNFAkjqsYzO9c+WRevScQ7RlZ6HOf+Zznf/M55r+w8awowEAkPAoooEkZmY65aA2+vDG/vrtyfvp68XrddLDE3XLm19r+YbtYccDACBhcWMhgF02bC3Qo+Nm6/lJC5WSIl1yTGdd1r+LGtZLCzsaAAA1jhsLAcQku366/u/knhp7U3+d0LOVHvlojgYMH6eXJi9UYVFx2PEAAEgYFNEAfqR9s/p65OxD9O5VR6lzi4b67bvfafBDEzV2+grVtm+vAACIB4poAOU6uH0TvX7ZERpxXm8VF7suej5fZz81Wd8u2RB2NAAAQkURDaBCZqZB+7fS6Bv66c9D99esFZv1k0c/0fWvfakl67aGHQ8AgFBwYyGAKtm4vUBPjJ+rpz+ZL5d0wVEddeWArsrOSg87GgAA1aqiGwspogHskWXrt+neMTP1zpdL1SQrXdcO7KZfHt5BGWl8wQUAqBt4OgeAatemSZbuP/Ng/evqo9WzTWP96V/fa9ADH2vktz9w8yEAoM6jiAawVw5om62XLjpcz15wmDLSUnTFy1/ojCc+1ReL1oUdDQCAuKGIBrDXzEzH9mip9689RneddqAWrd2q0/42SVe9/IUWrtkSdjwAAKodfaIBVLstOwr11MR5GjFhngqKinXeER11zXFd1bRBRtjRAACIGTcWAgjFyo3b9cCHs/T6lMVqUC9N1xzXVef37ajM9NSwowEAUCluLAQQipaNM3XnaQdp1PX9lNehqf76/gwNvO9j/fOrpSourl0f4AEAiEYRDSDuuu/TSM9e0EcvX3y4srPSdd1rX+mnf/uvJs9bE3Y0AAD2CEU0gBpzVNcW+vc1R+u+n/fSqk07dNaIybr4+XzNWbk57GgAAFQJRTSAGpWSYjq9dzuNu3mAbjmxhybPW6MTH5yg3737nVZv3hF2PAAAYsKNhQBCtXrzDj08drZe/myRstJTdcWALrrwqE7KyuDmQwBAuLixEEDCatGwnu4YeoDG3NBPR3ZpruGjZ+rYe8frralLVMTNhwCABEURDSAhdMlpqBHn5+mNy/pqn+xM3fzm1zrlkU80cfaqsKMBAPAjFNEAEkqfTs307pVH6pGzD9Gm7QU67+nP9atnPteM5RvDjgYAwC4U0QASjpnpJ73aaOxN/fXbk/fTl4vW6aSHJuq2t77Rio3bw44HAAA3FgJIfOu37tSjH83R858uUFpKii7p11mX9eusBvXSwo4GAKjDuLEQQK3WpH6GfntKT429cYAG7tdSD4+drf7Dx+uVzxapsKg47HgAgCREEQ2g1ti3eX09es6heufKI9WpRX395p1vNeShifpoxgrVtm/VAAC1G0U0gFrnkH2b6o3L+uqJc3ursNh14XP5+uXfP9N3SzeEHQ0AkCQoogHUSmamwQe00pgb+ulPp+6vGcs36ZRHPtGNr3+lpeu3hR0PAFDHcWMhgDph4/YCPT5+rp75ZL5c0kVHd9IVA7qocWZ62NEAALUUNxYCqPMaZ6brtsG5+ujmATrlwNZ6fPxcDRg+Xs9PWqACbj4EAFQzimgAdUrbJlm6/xcH69/XHK3cVo30h/emadADEzTqu+XcfAgAqDYU0QDqpAPaZuvliw/Xs78+TGkppstfmqqfP/Gpvly0LuxoAIA6gD7RAOq8wqJivTl1ie4bM0urN+/Qofs2UXZWujLTU5WVnqrMjFRlpqUqKyMlMh28Sn7PykjZbV5W9PKMFGWkpsjMwj5NAEA1q6hPNMN9Aajz0lJTdHaffXVqrzZ6auI8TZqzRmu27NS2nUXaVlCk7QXF2l4Q+b2ouOoNC2barbjOTE9R1q7CPLooL1WkZ6QqMy2l1DqpUdum/KigT02hWAeAREBLNABEKSgqjhTWOyPF9baCkkK76H/zC4u0bWfxrvnbC4q0LWr+9qj1dyvSd61TpB2Fe3azY0Zqyv+K9NKFe1QBnplRsuzHreuRbVN2b23fbVta1wFAoiUaAGKWnpqi9NSUuD8ar7jYtaOwVJG+s6Qo333+/5aVKtx3FebF2r6zSKs37/xfsR/sZ+vOQu1B47pSTD8u0jNSy+juklKqS8z/5u/eJabs+bSuA6itKKIBIAQpKRYpLDNS43ocd1dBkWt7YaQVfVt0kR60jJeeH124l+7usr2gSJt3FGrVph2RDwE7/zd/j1vX01J2dWsps0gv3d0luhgvVbzXi2qRT9tVnJvMJJN2ta5HfpcsWFbCLLKORU9HbV+ysVWyz5KVo9cpa5+q4Dgl25RkApBYKKIBoA4zM2WkmTLSaqZ1fXthqSI9uitMQXGpLjHld3fZVlCkHQXFWr15Z5mF/Z60rtcVlRXvFX0A2FXMl55Xzj4VVeyX9cFjt212++BQ8XEr/zBjURnK+zCz+zqo20acl6ecRvXCjrGbuBbRZjZY0kOSUiX93d3vKrW8nqQXJPWWtEbSL9x9QTwzAQDiIyXFVD8jTfUz4nucktb1SKG9e9/zksK95CZRD9aPbBdsL5d7ZNqj9umRhQp+27Xc/X/bBKtI7ruWRW9fep+K2r6sfar0PqKOEdNxS86l1D61a17F+yydvax97prrlZ/Lbsfdtf9S88p8H368T/1oXtn7RHJIxF5fcSuizSxV0mOSTpC0RNIUM3vP3b+PWu0iSevcvauZnSXpbkm/iFcmAEDtF926riyGdQcQjngOttJH0hx3n+fuOyW9JmloqXWGSno++P0tSQONjl8AAABIcPEsottKWhw1vSSYV+Y67l4oaYOk5nHMBAAAAOy1WjHst5ldamb5Zpa/atWqsOMAAAAgycWziF4qqX3UdLtgXpnrmFmapGxFbjDcjbuPcPc8d8/LycmJU1wAAAAgNvEsoqdI6mZmncwsQ9JZkt4rtc57kn4V/H6GpI+cW20BAACQ4OL2dA53LzSzqyWNVuQRd8+4+zQzu0NSvru/J+lpSS+a2RxJaxUptAEAAICEFtfnRLv7+5LeLzXv91G/b5f083hmAAAAAKpbrbixEAAAAEgkFNEAAABAFVFEAwAAAFVEEQ0AAABUEUU0AAAAUEUU0QAAAEAVWW0b28TMVklaGNLhW0haHdKxUTN4j5MD73Ny4H1ODrzPdV+Y73EHdy9zuOxaV0SHyczy3T0v7ByIH97j5MD7nBx4n5MD73Pdl6jvMd05AAAAgCqiiAYAAACqiCK6akaEHQBxx3ucHHifkwPvc3Lgfa77EvI9pk80AAAAUEW0RAMAAABVRBEdAzMbbGYzzWyOmQ0LOw+qn5k9Y2Yrzey7sLMgfsysvZmNM7PvzWyamV0XdiZULzPLNLPPzezr4D3+U9iZED9mlmpmX5rZv8POgvgwswVm9q2ZfWVm+WHniUZ3jkqYWaqkWZJOkLRE0hRJZ7v796EGQ7Uys36SNkt6wd0PCDsP4sPMWktq7e5fmFkjSVMl/ZR/z3WHmZmkBu6+2czSJX0i6Tp3nxxyNMSBmd0oKU9SY3c/Jew8qH5mtkBSnrsn3LPAaYmuXB9Jc9x9nrvvlPSapKEhZ0I1c/cJktaGnQPx5e4/uPsXwe+bJE2X1DbcVKhOHrE5mEwPXrQW1UFm1k7SyZL+HnYWJCeK6Mq1lbQ4anqJ+E8XqPXMrKOkQyR9FnIUVLPgK/6vJK2U9IG78x7XTQ9KulVSccg5EF8uaYyZTTWzS8MOE40iGkDSMbOGkt6WdL27bww7D6qXuxe5+8GS2knqY2Z00apjzOwUSSvdfWrYWRB3R7v7oZKGSLoq6H6ZECiiK7dUUvuo6XbBPAC1UNBP9m1JL7v7P8LOg/hx9/WSxkkaHHIUVL+jJJ0a9Jd9TdJxZvZSuJEQD+6+NPi5UtI7inSzTQgU0ZWbIqmbmXUyswxJZ0l6L+RMAPZAcNPZ05Kmu/v9YedB9TOzHDNrEvyepchN4TNCDYVq5+63u3s7d++oyP/LH7n7uSHHQjUzswbBTeAyswaSBklKmKdoUURXwt0LJV0tabQiNyG94e7Twk2F6mZmr0r6VFIPM1tiZheFnQlxcZSk8xRptfoqeJ0UdihUq9aSxpnZN4o0gnzg7jz+DKid9pH0iZl9LelzSf9x91EhZ9qFR9wBAAAAVURLNAAAAFBFFNEAAABAFVFEAwAAAFVEEQ0AAABUEUU0AAAAUEUU0QCQgMxsc/Czo5mdU837/k2p6UnVuX8ASAYU0QCQ2DpKqlIRbWZplayyWxHt7kdWMRMAJD2KaABIbHdJOiYYGOYGM0s1s+FmNsXMvjGzyyTJzAaY2UQze0/S98G8d81sqplNM7NLg3l3ScoK9vdyMK+k1duCfX9nZt+a2S+i9j3ezN4ysxlm9nIw+iMAJK3KWisAAOEaJulmdz9FkoJieIO7H2Zm9ST918zGBOseKukAd58fTF/o7muD4a+nmNnb7j7MzK5294PLONZpkg6W1EtSi2CbCcGyQyTtL2mZpP8qMvrjJ9V9sgBQW9ASDQC1yyBJ55vZV5I+k9RcUrdg2edRBbQkXRsMlztZUvuo9cpztKRX3b3I3VdI+ljSYVH7XuLuxZK+UqSbCQAkLVqiAaB2MUnXuPvo3WaaDZC0pdT08ZL6uvtWMxsvKXMvjrsj6vci8f8HgCRHSzQAJLZNkhpFTY+WdIWZpUuSmXU3swZlbJctaV1QQOdKOiJqWUHJ9qVMlPSLoN91jqR+kj6vlrMAgDqGlgQASGzfSCoKumU8J+khRbpSfBHc3LdK0k/L2G6UpMvNbLqkmYp06SgxQtI3ZvaFu/8yav47kvpK+lqSS7rV3ZcHRTgAIIq5e9gZAAAAgFqF7hwAAABAFVFEAwAAAFVEEQ0AAABUEUU0AAAAUEUU0QAAAEAVUUQDAAAAVUQRDQAAAFQRRTQAAABQRf8fNB4lVGmD5egAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -942,7 +961,7 @@ { "data": { "text/plain": [ - "0.977064014713864" + "0.9769994291935521" ] }, "execution_count": 30, @@ -973,7 +992,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1014,7 +1033,7 @@ { "data": { "text/plain": [ - "array([-1.58985802])" + "array([-1.58870599])" ] }, "execution_count": 32, @@ -1033,7 +1052,7 @@ "source": [ "### Regression with the Variational Quantum Regressor (`VQR`)\n", "\n", - "Similar to the `VQC` for classification, the `VQR` is a special variant of the `NeuralNetworkRegressor` with a `OpflowQNN`. By default it considers the `L2Loss` function to minimize the mean squared error between predictions and targets." + "Similar to the `VQC` for classification, the `VQR` is a special variant of the `NeuralNetworkRegressor` with a `EstimatorQNN`. By default it considers the `L2Loss` function to minimize the mean squared error between predictions and targets." ] }, { @@ -1047,7 +1066,6 @@ " feature_map=feature_map,\n", " ansatz=ansatz,\n", " optimizer=L_BFGS_B(maxiter=5),\n", - " quantum_instance=quantum_instance,\n", " callback=callback_graph,\n", ")" ] @@ -1060,7 +1078,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1073,7 +1091,7 @@ { "data": { "text/plain": [ - "0.9771028080602604" + "0.9769955693935385" ] }, "execution_count": 34, @@ -1104,7 +1122,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1137,7 +1155,7 @@ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0.dev0+4749eb5
qiskit-aer0.11.0
qiskit-nature0.5.0
qiskit-finance0.4.0
qiskit-optimization0.5.0
qiskit-machine-learning0.5.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Mar 28 2022 06:16:26
OSDarwin
CPUs2
Memory (Gb)12.0
Thu Sep 15 13:55:18 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Fri Oct 28 15:44:56 2022 GMT Daylight Time
" ], "text/plain": [ "" @@ -1183,7 +1201,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.7.9" }, "toc": { "base_numbering": 1, From 012222b1fd53e80c1ec204e4e20d67c50069139f Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 28 Oct 2022 23:37:57 +0100 Subject: [PATCH 89/96] update 02a --- ...ng_a_quantum_model_on_a_real_dataset.ipynb | 108 +++++++++--------- 1 file changed, 51 insertions(+), 57 deletions(-) diff --git a/docs/tutorials/02a_training_a_quantum_model_on_a_real_dataset.ipynb b/docs/tutorials/02a_training_a_quantum_model_on_a_real_dataset.ipynb index 2ce59f14c..a409793c3 100644 --- a/docs/tutorials/02a_training_a_quantum_model_on_a_real_dataset.ipynb +++ b/docs/tutorials/02a_training_a_quantum_model_on_a_real_dataset.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "valued-leeds", "metadata": {}, "outputs": [], @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "everyday-commission", "metadata": {}, "outputs": [ @@ -140,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "mobile-dictionary", "metadata": {}, "outputs": [], @@ -161,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "alternative-preliminary", "metadata": {}, "outputs": [], @@ -181,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "whole-exhaust", "metadata": { "tags": [ @@ -192,16 +192,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -240,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "pursuant-survival", "metadata": {}, "outputs": [], @@ -264,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "proved-reviewer", "metadata": {}, "outputs": [], @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "veterinary-proxy", "metadata": {}, "outputs": [ @@ -332,18 +332,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "optional-pocket", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -369,18 +369,18 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "elder-interaction", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -404,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "intimate-doubt", "metadata": {}, "outputs": [], @@ -419,25 +419,19 @@ "id": "integral-compound", "metadata": {}, "source": [ - "In the next step, we define where to train our classifier. We can train on a simulator or a real quantum computer. Here, we will use a simulator. We fix the seeds for reproducibility. By their nature, quantum computers are noisy and probabilistic, so we set shots to 1024 to sample results from many runs or ''shots'' of the same circuit." + "In the next step, we define where to train our classifier. We can train on a simulator or a real quantum computer. Here, we will use a simulator. We create an instance of the `Sampler` primitive. This is the reference implementation that is statevector based. Using qiskit runtime services you can create a sampler that is backed by a quantum computer." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "unauthorized-footwear", "metadata": {}, "outputs": [], "source": [ - "from qiskit_aer import AerSimulator\n", - "from qiskit.utils import QuantumInstance\n", + "from qiskit.primitives import Sampler\n", "\n", - "quantum_instance = QuantumInstance(\n", - " AerSimulator(),\n", - " shots=1024,\n", - " seed_simulator=algorithm_globals.random_seed,\n", - " seed_transpiler=algorithm_globals.random_seed,\n", - ")" + "sampler = Sampler()" ] }, { @@ -450,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "connected-reach", "metadata": {}, "outputs": [], @@ -479,20 +473,20 @@ "source": [ "Now we are ready to construct the classifier and fit it. \n", "\n", - "`VQC` stands for \"variational quantum classifier.\" It takes a feature map and an ansatz and constructs a quantum neural network automatically. In the simplest case it is enough to pass the number of qubits and a quantum instance to construct a valid classifier.\n", + "`VQC` stands for \"variational quantum classifier.\" It takes a feature map and an ansatz and constructs a quantum neural network automatically. In the simplest case it is enough to pass the number of qubits and a quantum instance to construct a valid classifier. You may omit the `sampler` parameter, in this case a `Sampler` instance will be created for you in the way we created it earlier. We created it manually for illustrative purposes only.\n", "\n", "Training may take some time. Please, be patient." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "multiple-garbage", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAIjCAYAAAB/OVoZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACyJklEQVR4nOzdeXhTZfYH8O9N0iTd91K6l7Lv+74qKig4gIoLKogO+lNHR1wZRwUXUHDUwcFxXMEdFMFxXFABKatQ9h1KV7rve9Mmub8/khu6JG1umzZp+/08T5+hN/fevEkL48k57zmCKIoiiIiIiIiIiMjpFM5eABERERERERGZMEgnIiIiIiIichEM0omIiIiIiIhcBIN0IiIiIiIiIhfBIJ2IiIiIiIjIRTBIJyIiIiIiInIRDNKJiIiIiIiIXASDdCIiIiIiIiIXwSCdiIiIiIiIyEUwSCci6qCWL18OQRCQn5/f7LkxMTFYtGhR2y+qgfXr10MQBKSkpLT7cx86dAjjx4+Hp6cnBEHAsWPH2n0N9nDWz8bRnPmzdiZBELB8+XJnLwNAx/wZSP+OERHRFQzSiYhcyOnTp3HnnXciPDwcGo0GYWFhWLBgAU6fPu3spTVp5cqV2Lp1q7OXYVFbW4tbbrkFhYWFePPNN/Hpp58iOjraaevZt28fli9fjuLiYqetgTqezMxMLF++vFUfML3zzjtYv369w9bUEpWVlVi+fDl+//13p66DiKijEERRFJ29CCIiAr799lvcfvvtCAgIwL333ovY2FikpKTgww8/REFBAb766ivMnTvXcv7y5cuxYsUK5OXlISgoqMl763Q6KBQKuLm5tcnavby8cPPNNzcKBgwGA2pra6HRaNo1W3bu3Dn069cP77//Pu677752e15bXn/9dTz55JNITk5GTExMvcfa+mfTXtavX4977rnH6mvszKqrq6FSqaBSqRx+74SEBIwaNQoff/yxXdUW1v6+DRw4EEFBQU4NkPPz8xEcHIwXXnihUdWBXq+HXq+HVqt1zuKIiFyQ4/8fhYiIZLt06RLuuusu9OjRA/Hx8QgODrY89uijj2LSpEm46667cOLECfTo0UP2/TUajSOXazelUgmlUtnuz5ubmwsA8PPza/fnlstZPxtyDFcKLtvr75ter4fRaIRarW71vdrqAw4ioo6M5e5ERC5gzZo1qKysxHvvvVcvQAeAoKAg/Oc//0FFRQVWr17d6Nr8/HzMnz8fPj4+CAwMxKOPPorq6up651jb91xcXIy//vWviIyMhEajQc+ePfHaa6/BaDTWO89oNOKf//wnBg0aBK1Wi+DgYMyYMQMJCQkATHtyKyoqsGHDBgiCAEEQLM/VcI/srFmzbH7IMG7cOIwcObLesc8++wwjRoyAu7s7AgICcNtttyE9Pb3J93LRokWYMmUKAOCWW26BIAiYOnUqAGDq1KmWPze8pm72NyUlBYIg4PXXX8d7772HuLg4aDQajBo1CocOHWp0/blz5zB//nwEBwfD3d0dffr0wbPPPgvAVPHw5JNPAgBiY2Mt75H0nlj72SQlJeGWW25BQEAAPDw8MHbsWPzwww/1zvn9998hCAI2bdqEV155BREREdBqtbj66quRmJjY5Hv0zTffQBAE7Nq1q9Fj//nPfyAIAk6dOgUAOHHiBBYtWoQePXpAq9UiNDQUixcvRkFBQZPPAdjer92a30drvvvuO9xwww0ICwuDRqNBXFwcXnrpJRgMhkbnrlu3Dj169IC7uztGjx6N3bt3N/q9qKmpwfPPP48RI0bA19cXnp6emDRpEnbu3Nnsa5T2WCcmJmLRokXw8/ODr68v7rnnHlRWVta79tdff8XEiRPh5+cHLy8v9OnTB3/7298AmH6+o0aNAgDcc889lt+bpkrXG/59i4mJwenTp7Fr1y7L9XVfpz3ved2/C2+99Zbl78KZM2fsep9SUlIs/6atWLHCsg7pPbO2J12v1+Oll16yPFdMTAz+9re/QafT1TsvJiYGs2bNwp49ezB69GhotVr06NEDn3zyic33iIioI+BHl0RELuD7779HTEwMJk2aZPXxyZMnIyYmplGgBgDz589HTEwMVq1ahQMHDmDt2rUoKipq8j9UKysrMWXKFGRkZOD+++9HVFQU9u3bh2XLliErKwtvvfWW5dx7770X69evx8yZM3HfffdBr9dj9+7dOHDgAEaOHIlPP/0U9913H0aPHo0lS5YAAOLi4qw+76233oq7774bhw4dsgQgAJCamooDBw5gzZo1lmOvvPIKnnvuOcyfPx/33Xcf8vLy8Pbbb2Py5Mk4evSozSz5/fffj/DwcKxcuRKPPPIIRo0ahW7dutl8L5ryxRdfoKysDPfffz8EQcDq1asxb948JCUlWcrTT5w4gUmTJsHNzQ1LlixBTEwMLl26hO+//x6vvPIK5s2bhwsXLuDLL7/Em2++adma0PDDGElOTg7Gjx+PyspKPPLIIwgMDMSGDRtw44034ptvvqm35QEAXn31VSgUCjzxxBMoKSnB6tWrsWDBAvzxxx82X9cNN9wALy8vbNq0yfKBhmTjxo0YMGAABg4cCMAUSCYlJeGee+5BaGgoTp8+jffeew+nT5/GgQMHHLKNQc7vozXr16+Hl5cXli5dCi8vL+zYsQPPP/88SktL6/1O/fvf/8bDDz+MSZMm4bHHHkNKSgrmzJkDf39/REREWM4rLS3FBx98gNtvvx1//vOfUVZWhg8//BDXXXcdDh48iKFDhzb7mubPn4/Y2FisWrUKR44cwQcffICQkBC89tprAEz9J2bNmoXBgwfjxRdfhEajQWJiIvbu3QsA6NevH1588UU8//zzWLJkieXfhvHjx9v9vr711lv4y1/+Ai8vL8uHRtLfBbnv+ccff4zq6mosWbIEGo0GAQEBdr1PwcHB+Pe//43/+7//w9y5czFv3jwAwODBg22u+7777sOGDRtw88034/HHH8cff/yBVatW4ezZs9iyZUu9cxMTE3HzzTfj3nvvxcKFC/HRRx9h0aJFGDFiBAYMGGD3e0VE5FJEIiJyquLiYhGA+Kc//anJ82688UYRgFhaWiqKoii+8MILIgDxxhtvrHfegw8+KAIQjx8/bjkWHR0tLly40PL9Sy+9JHp6eooXLlyod+0zzzwjKpVKMS0tTRRFUdyxY4cIQHzkkUcarcdoNFr+7OnpWe/+ko8//lgEICYnJ4uiKIolJSWiRqMRH3/88XrnrV69WhQEQUxNTRVFURRTUlJEpVIpvvLKK/XOO3nypKhSqRodb2jnzp0iAPHrr7+ud3zKlCnilClTGp2/cOFCMTo62vJ9cnKyCEAMDAwUCwsLLce/++47EYD4/fffW45NnjxZ9Pb2tqxdUvf9WbNmTb33oa6GP5u//vWvIgBx9+7dlmNlZWVibGysGBMTIxoMhnqvsV+/fqJOp7Oc+89//lMEIJ48edL6m2N2++23iyEhIaJer7ccy8rKEhUKhfjiiy9ajlVWVja69ssvvxQBiPHx8ZZjDX/WoiiKAMQXXnih2dds7++jLdbWeP/994seHh5idXW1KIqiqNPpxMDAQHHUqFFibW2t5bz169eLAOr9Xuj1+nrvqSiKYlFRkditWzdx8eLF9Y43fI3S38uG582dO1cMDAy0fP/mm2+KAMS8vDybr+vQoUMiAPHjjz+2eU5d1n4GAwYMsPo7b+97Lv1d8PHxEXNzc+uda+/7lJeXZ/N3QXq/JMeOHRMBiPfdd1+985544gkRgLhjxw7Lsejo6Ea/h7m5uVb/jSEi6khY7k5E5GRlZWUAAG9v7ybPkx4vLS2td/yhhx6q9/1f/vIXAMCPP/5o815ff/01Jk2aBH9/f+Tn51u+pk+fDoPBgPj4eADA5s2bIQgCXnjhhUb3aEkG1cfHBzNnzsSmTZsg1ulbunHjRowdOxZRUVEATE30jEYj5s+fX299oaGh6NWrl9Wy47Zw6623wt/f3/K9lM1MSkoCAOTl5SE+Ph6LFy+2rF3S0gzzjz/+iNGjR2PixImWY15eXliyZAlSUlJw5syZeuffc8899fYGN1yjLbfeeityc3PrNRT75ptvYDQaceutt1qOubu7W/5cXV2N/Px8jB07FgBw5MgR+S/QCnt/H22pu8aysjLk5+dj0qRJqKysxLlz5wCYmrAVFBTgz3/+c7090AsWLKj3MwZMe7ul99RoNKKwsBB6vR4jR460+zU/8MAD9b6fNGkSCgoKLH9/pUqQ7777zq6SfkeT+57fdNNNjao/HPE+NST9u7V06dJ6xx9//HEAaFRN1L9//3oVSMHBwejTp0+zv/9ERK6M5e5ERE4mBd9SsG6LrWC+V69e9b6Pi4uDQqFoclbyxYsXceLECZsl11LjtUuXLiEsLAwBAQFNrk2OW2+9FVu3bsX+/fsxfvx4XLp0CYcPH65XXnvx4kWIotjotUnaqxN6w8BbCuaKiooAXAmEpdJwR0hNTcWYMWMaHe/Xr5/l8brP19wabZkxYwZ8fX2xceNGXH311QBMH5YMHToUvXv3tpxXWFiIFStW4KuvvrL8XkhKSkpkvDLb7P19tOX06dP4+9//jh07djT6EEtaY2pqKgCgZ8+e9R5XqVRWu9Fv2LAB//jHP3Du3DnU1tZajsfGxjb7eoCmfy4+Pj649dZb8cEHH+C+++7DM888g6uvvhrz5s3DzTffDIWi7XMoct9zW6+7te9TQ6mpqVAoFI1+TqGhofDz87P8HCUN32fA9F439/tPROTKGKQTETmZr68vunfvjhMnTjR53okTJxAeHg4fH58mz7Mng2s0GnHNNdfgqaeesvp43SDN0WbPng0PDw9s2rQJ48ePx6ZNm6BQKHDLLbfUW58gCPjpp5+sdqv28vJq0XMLglAvgy+x1mAMgM1O2dbu4SwtXaNGo8GcOXOwZcsWvPPOO8jJycHevXuxcuXKeufNnz8f+/btw5NPPomhQ4fCy8sLRqMRM2bMaHEGuOH73Zrfx+LiYkyZMgU+Pj548cUXERcXB61WiyNHjuDpp59u0Ro/++wzLFq0CHPmzMGTTz6JkJAQKJVKrFq1CpcuXbLrHs39XNzd3REfH4+dO3fihx9+wM8//4yNGzfiqquuwi+//NLmXdrlvud1qxUkjnifbLG3EqUj/B0lIpKLQToRkQuYNWsW3n//fezZs6dembNk9+7dSElJwf3339/osYsXL9bLWiUmJsJoNDY5qzouLg7l5eWYPn16k+uKi4vDtm3bUFhY2GQ2XU5pt6enJ2bNmoWvv/4ab7zxBjZu3IhJkyYhLCys3vOKoojY2FiHfmDg7+9vtQy2YXbOXlKneqkTui1y3p/o6GicP3++0XGpbDs6OlrGCpt26623YsOGDdi+fTvOnj0LURTrlboXFRVh+/btWLFiBZ5//nnL8YsXL9p1f39/fxQXF9c7VlNTg6ysrHrH7P19tOb3339HQUEBvv32W0yePNlyPDk5ud550vuWmJiIadOmWY7r9XqkpKTUa2T2zTffoEePHvj222/r/eysbftoDYVCgauvvhpXX3013njjDaxcuRLPPvssdu7cienTpzukKZ+te7TmPZfY+z7J/f03Go24ePGipXoEMDVULC4udujvPxGRq+KedCIiF/Dkk0/C3d0d999/f6PRVoWFhXjggQfg4eFhGeVV17p16+p9//bbbwMAZs6cafP55s+fj/3792Pbtm2NHisuLoZerwdg2ocqiiJWrFjR6Ly6mSpPT89GwVhTbr31VmRmZuKDDz7A8ePH6wWGADBv3jwolUqsWLGiUUZMFEW7xn9ZExcXh3PnziEvL89y7Pjx45aO2nIFBwdj8uTJ+Oijj5CWltZonRJPT08AsOs9uv7663Hw4EHs37/fcqyiogLvvfceYmJi0L9//xat1Zrp06cjICAAGzduxMaNGzF69Oh6H/hIWcqGP4Pmuq1L4uLiGu1tfu+99xpl0u39fbTG2hpramrwzjvv1Dtv5MiRCAwMxPvvv1/vfp9//nmj0mhr9/zjjz/q/Uxaq7CwsNExqWu8NGpMzu+NLbb+brbmPZfY+z55eHhY7tuc66+/HkDj37E33ngDgGkyARFRZ8dMOhGRC+jVqxc2bNiABQsWYNCgQbj33nsRGxuLlJQUfPjhh8jPz8eXX35pdbRZcnIybrzxRsyYMQP79+/HZ599hjvuuANDhgyx+XxPPvkk/vvf/2LWrFmWcUUVFRU4efIkvvnmG6SkpCAoKAjTpk3DXXfdhbVr1+LixYuWEufdu3dj2rRpePjhhwEAI0aMwG+//YY33ngDYWFhiI2NtbqvWnL99dfD29sbTzzxBJRKJW666aZ6j8fFxeHll1/GsmXLLGOyvL29kZycjC1btmDJkiV44oknZL/PixcvxhtvvIHrrrsO9957L3Jzc/Huu+9iwIABjfYy22vt2rWYOHEihg8fjiVLllh+bj/88AOOHTsGwPT+AMCzzz6L2267DW5ubpg9e7YlCKvrmWeewZdffomZM2fikUceQUBAADZs2IDk5GRs3rzZofuV3dzcMG/ePHz11VeoqKjA66+/Xu9xHx8fTJ48GatXr0ZtbS3Cw8Pxyy+/NMpS23LffffhgQcewE033YRrrrkGx48fx7Zt2yxj6CT2/j5aM378ePj7+2PhwoV45JFHIAgCPv3000YfLKjVaixfvhx/+ctfcNVVV2H+/PlISUnB+vXrERcXVy/bO2vWLHz77beYO3cubrjhBiQnJ+Pdd99F//79UV5ebtdrb86LL76I+Ph43HDDDYiOjkZubi7eeecdREREWKpp4uLi4Ofnh3fffRfe3t7w9PTEmDFjZO33HjFiBP7973/j5ZdfRs+ePRESEoKrrrqqVe+5xN73yd3dHf3798fGjRvRu3dvBAQEYODAgVZ7OQwZMgQLFy7Ee++9Z9nKcPDgQWzYsAFz5sypVwVBRNRptXM3eSIiasKJEyfE22+/Xezevbvo5uYmhoaGirfffrvVcVrS6KIzZ86IN998s+jt7S36+/uLDz/8sFhVVVXv3IYjr0TRNNZr2bJlYs+ePUW1Wi0GBQWJ48ePF19//XWxpqbGcp5erxfXrFkj9u3bV1Sr1WJwcLA4c+ZM8fDhw5Zzzp07J06ePFl0d3cXAViey9pIKMmCBQtEAOL06dNtvh+bN28WJ06cKHp6eoqenp5i3759xYceekg8f/58k++jrRFsoiiKn332mdijRw9RrVaLQ4cOFbdt22ZzBNuaNWsaXQ8ro6ROnTolzp07V/Tz8xO1Wq3Yp08f8bnnnqt3zksvvSSGh4eLCoWi3nti7Wdz6dIl8eabb7bcb/To0eL//vc/u16jtHZ7x3b9+uuvIgBREAQxPT290eOXL1+2vDZfX1/xlltuETMzMxu9D9Z+1gaDQXz66afFoKAg0cPDQ7zuuuvExMTEVv0+WrN3715x7Nixoru7uxgWFiY+9dRT4rZt20QA4s6dO+udu3btWjE6OlrUaDTi6NGjxb1794ojRowQZ8yYYTnHaDSKK1eutJw3bNgw8X//+1+j3xNRtD2CreFotYbvz/bt28U//elPYlhYmKhWq8WwsDDx9ttvbzQS7bvvvhP79+8vqlSqZn+u1n4G2dnZ4g033CB6e3s3GjVnz3ve1N8FOe/Tvn37xBEjRohqtbree9ZwBJsoimJtba24YsUKMTY2VnRzcxMjIyPFZcuWWcbpSaKjo8Ubbrih0bpsjVokIuooBFFkZw0ios4uMjIS1113HT744ANnL4XIpRiNRgQHB2PevHl4//33nb0cIiIi7kknIursamtrUVBQ0GzpKlFnV11d3agM/pNPPkFhYSGmTp3qnEURERE1wD3pRESd2LZt2/DVV1+hqqrKMgubqKs6cOAAHnvsMdxyyy0IDAzEkSNH8OGHH2LgwIH1RgASERE5E4N0IqJO7NVXX0ViYiJeeeUVXHPNNc5eDpFTxcTEIDIyEmvXrrWMFbz77rvx6quvQq1WO3t5REREAADuSSciIiIiIiJyEdyTTkREREREROQiGKQTERERERERuYgutyfdaDQiMzMT3t7eEATB2cshIiIiIiKiTk4URZSVlSEsLAwKRdO58i4XpGdmZiIyMtLZyyAiIiIiIqIuJj09HREREU2e0+WCdG9vbwCmN8fHx8fJqyEiIiIiIqLOrrS0FJGRkZZ4tCldLkiXStx9fHwYpBMREREREVG7sWfLNRvHEREREREREbkIBulERERERERELoJBOhEREREREZGLYJBORERERERE5CIYpBMRERERERG5CAbpRERERERERC6CQToRERERERGRi2CQTkREREREROQiGKQTERERERERuQgG6UREREREREQugkE6ERERERERkYtgkE5ERERERETkIhikExEREREREbkIBulERERERERELoJBOhEREREREZGLYJBORERERERE5CJUzl4AWZdTWo3j6cXw1rphXFygs5dDRERERERE7YCZdBf1y5kcLPn0MD7ck+TspRAREREREVE7YZDuoqIDPAAAaYWVTl4JERERERERtRcG6S4qqk6QLoqik1dDRERERERE7YFBuosK83OHQgCqa43IK9M5ezlERERERETUDhikuyi1SoHuvu4AWPJORERERETUVTBId2HRga3bl15da8Cyb09i+9kcRy6LiIiIiIiI2giDdBcW1crmcb+fz8OXB9Pw+i8XHLksIiIiIiIiaiMM0l1YpBSkF7QsSE/KLwcA5JZWO2xNRERERERE1HYYpLuw1mbSk/MqAAAFFTWoNRgdti4iIiIiIiJqGwzSXVirg/T8CsufC8prHLImIiIiIiIiajsM0l2Y1Dgut0yHqhqD7OtTCq4E6bllLHknIiIiIiJydQzSXZivuxu8tSoAQHqRvGx6aXUt8utkz3NLOWudiIiIiIjI1TFId2GCIFwpeZfZPC6lTqk7AOSVM0gnIiIiIiJydQzSXVxL96UnNwjSmUknIiIiIiJyfQzSXVxUoIOCdO5JJyIiIiIicnkM0l2clElPb2GQHuHvDgDIK2MmnYiIiIiIyNUxSHdxUpCeKjNIl/akj44NAGDqEE9ERERERESujUG6i6ubSTcaRbuuEUURSeYgfYw5SGcmnYiIiIiIyPUxSHdxYX7uUCoE6PRGuzu0F1bUoKxaD0EARkRfCdJF0b4gn4iIiIiIiJyDQbqLc1MqEOanBWB/8zhpP3qYr7tlT3qNwYiSqtq2WSQRERERERE5BIP0DkDurHQpSO8R7AmtmxI+WhUAlrwTERERERG5OgbpHYDc5nFSkB4T6AkACPExZeLZPI6IiIiIiMi1MUjvAKICTMG2vWPYUgpMQXpskDlI99YAYCadiIiIiIjI1TFI7wAs5e52BulJefWD9GBzkJ5bVt0GqyMiIiIiIiJHcWqQHh8fj9mzZyMsLAyCIGDr1q1Nnr9o0SIIgtDoa8CAAe2zYCeRE6QbjaLNTHpuKTPpRERERERErsypQXpFRQWGDBmCdevW2XX+P//5T2RlZVm+0tPTERAQgFtuuaWNV+pcUpCeV6ZDZY2+yXNzyqpRXWuESiFYOrtLmXR7R7gRERERERGRc6ic+eQzZ87EzJkz7T7f19cXvr6+lu+3bt2KoqIi3HPPPW2xPJfh6+EGH60KpdV6pBdWoU+ot81zk82l7lEBHlApTZ/BhHibG8cxk05EREREROTSOvSe9A8//BDTp09HdHS0zXN0Oh1KS0vrfXVE0eZO7c2VvCebS91jzKXuQJ1yd+5JJyIiIiIicmkdNkjPzMzETz/9hPvuu6/J81atWmXJwPv6+iIyMrKdVuhY9u5LT27QNA6oU+7O7u5EREREREQurcMG6Rs2bICfnx/mzJnT5HnLli1DSUmJ5Ss9Pb19FuhgkeYgvbkxbClWM+mmcvfSaj2qaw1ttEIiIiIiIiJqLafuSW8pURTx0Ucf4a677oJarW7yXI1GA41G004raztSJj3VHITbkpRverxHnSDdx10FtUqBGr0ReWU6S8BPRERERERErqVDZtJ37dqFxMRE3Hvvvc5eSruJDmy+3F1vMFoy7XUz6YIgINhL2pfOknciIiIiIiJX5dQgvby8HMeOHcOxY8cAAMnJyTh27BjS0tIAmErV77777kbXffjhhxgzZgwGDhzYnst1KimTnl5UBaNRtHpORnEVag0iNCoFuvto6z0W4iPtS2fzOCIiIiIiIlfl1CA9ISEBw4YNw7BhwwAAS5cuxbBhw/D8888DALKysiwBu6SkpASbN2/uUll0AOjuq4VSIaBGb7SZDU82l7rHBHpCoRDqPRbC5nFEREREREQuz6l70qdOnQpRtJ4VBoD169c3Oubr64vKyqabp3VGKqUC4X7uSCusRGpBBUJ9tY3OkYL0up3dJcHeLHcnIiIiIiJydR1yT3pX1dy+9JT8xp3dJVKH99xSBulERERERESuikF6B9LcGDZrnd0lllnp5QzSiYiIiIiIXBWD9A5Eah5nM5NuZUa6JMRS7s7GcURERERERK6KQXoH0lSQrtMbcLmoCoD1PelSuTsbxxEREREREbkuBukdSFNBelpBJUQR8NKoEOSlbvS4VO6eX14Dg40RbkRERERERORcDNI7kChz47j88hpU6PT1Hqvb2V0QhEbXBnmpIQiAwSiisKKm7RdLREREREREsjFI70B8tG7w83ADAKQX1c+mJzfR2R0wjXAL9DRl2FnyTkRERERE5JoYpHcwlpL3gvpButQ0ztp+dEmQF5vHERERERERuTIG6R1MpI196Ul5UpDuYfPaEB/zrHRm0omIiIiIiFwSg/QOJtpGkH4lk+5l89pgcyad5e5ERERERESuiUF6B2Otw3uFTo+cUlPgHRtou9w9xIdBOhERERERkStjkN7BWAvSpSx6gKcavubGctaEeDNIJyIiIiIicmUM0jsYaU/65cIqGM3zzi2d3QNt70cHrsxKZ+M4IiIiIiIi18QgvYMJ83OHSiGgxmBEdqkp2E7Jb34/OgCEeLNxHBERERERkStjkN7BKBUCIvzdAVwpeU/Kb76zO8BydyIiIiIiIlfHIL0DajiGzd5MulTuXlljQLlO34YrJCIiIiIiopZgkN4BSc3j0s1BumVPejOZdE+NCp5qJQAgt5T70omIiIiIiFwNg/QOKNrcIC61oBLFlTUoqqwFAMQ0MX5NEsySdyIiIiIiIpfFIL0DqjuGTcqid/PRwFOjavZaZzSPq6ox4Pb3DmDZtyfa7TmJiIiIiIg6IgbpHVBknXL3ZMt+9Oaz6AAQ7NP+mfRfzmRjf1IBNh5Kt4yNIyIiIiIiosYYpHdAUpBeUFGDUxmlAGQE6V7SrPT2C9L/eywTAGAUgeKq2nZ7XiIiIiIioo6GQXoH5KN1g7+HGwAg/mIeAPuD9BAfKUhvn8ZxhRU12HUhr8733AtPRERERERkC4P0DirK3CQuMbccgH1N44Are9Lbq9z9h5NZ0NcpcS8or2mX5yUiIiIiIuqIGKR3UFLzOEmPYDvL3du5u/t/j2XU+76wgkE6ERERERGRLQzSO6ioAHfLnxXClX3qzQlpxyD9clElDqUUQRCAIRG+AIB8BulEREREREQ2MUjvoOpm0sP93aFRKe26TgrSCypqUGswtsnaJN+ZG8aNjQ1E/zAfAEAhy92JiIiIiIhsYpDeQUUFXClvt3c/OgD4e6ihUggAgPzyts2mS13d5wwLQ4CnGgAbxxERERERETWFQXoHFRV4JZPew87O7gCgUAgI8mr7kvezWaU4n1MGtVKBGQO7I8DzSgafiIiIiIiIrGOQ3kGF+mjhpjRlxO0dvyaRmsfllrZdkL7V3DBuWt9g+Lq7IdCSSWeQTkREREREZAuD9A5KqRAQbS5zjwvxknWttC89t40y6UajiO+lUveh4QBQp9ydQToREREREZEtKmcvgFpuxY0D8EdSAcbHBcm6LsSnbcvdD6UUIrOkGt4aFab1DQFwJUhnuTsREREREZFtDNI7sAk9gzChp7wAHQCCvaRMerWjlwQA2GrOos8YGAqtm6nrvLQPvqiiBqIoQhCENnluIiIiIiKijozl7l1QsI8WQNtk0mv0Rvx4MgsAMGdYuOW4v6cbAEBvFFFapXf48xIREREREXUGDNK7oLbck77rQh5KqmoR4q3B2B6BluMalRLeGlPhRj7HsBEREREREVnFIL0Lkrq7t0Um/TtzV/fZQ8KgVNQvaQ/wYvM4IiIiIiKipjBI74JC6gTpoig67L7lOj1+O5sD4EpX97oszePKGaQTERERERFZwyC9C5KauNUYjCipqnXYfbedykZ1rRE9gjwxMNyn0eOclU5ERERERNQ0BuldkNZNCV93UyM3R+5L/+64qav7n4aGW+3efmVWOvekExERERERWcMgvYsKcfC+9LwyHfZczAMA/GlomNVzAjxNz8lZ6URERERERNYxSO+igr0dOyv9fycyYRSBIZF+iAnytHpOEBvHERERERERNYlBehfl6Ez6d8dMpe5zbGTRgbrl7gzSiYiIiIiIrGGQ3kWF+GgBALmlrQ/SU/IrcCy9GAoBmDW4+SA9n93diYiIiIiIrGKQ3kUFe0nl7q0P0v9rbhg3oWeQpYzemkDznnQ2jiMiIiIiIrKOQXoXFeLjuHL3+AumhnGzBndv8ryAOnvSHTmfnYiIiIiIqLNgkN5FOapxnE5vwImMEgDA6NjAJs+V5qTXGkSU6fStel4iIiIiIqLOiEF6FxXi7Zhy99OZpajRGxHgqUZMoEeT52rdlPBQKwEAhdyXTkRERERE1AiD9C4q2NvUOK6sWo/qWkOL73MktQgAMDzKH4IgNHu+1DyOs9KJiIiIiIgac2qQHh8fj9mzZyMsLAyCIGDr1q3NXqPT6fDss88iOjoaGo0GMTEx+Oijj9p+sZ2Mj1YFtcr042/NvvTD5iB9RLS/XecHcgwbERERERGRTSpnPnlFRQWGDBmCxYsXY968eXZdM3/+fOTk5ODDDz9Ez549kZWVBaPR2MYr7XwEQUCItwaXi6qQW6ZDZEDTperWiKKIBLlBuhc7vBMREREREdni1CB95syZmDlzpt3n//zzz9i1axeSkpIQEBAAAIiJiWnyGp1OB53uSkBYWlraorV2RlKQntfC5nGma3VQKQQMjvC16xqWuxMREREREdnWofak//e//8XIkSOxevVqhIeHo3fv3njiiSdQVVVl85pVq1bB19fX8hUZGdmOK3Ztwa1sHnckzZRFHxDmA62b0q5rpHL3AjaOIyIiIiIiasSpmXS5kpKSsGfPHmi1WmzZsgX5+fl48MEHUVBQgI8//tjqNcuWLcPSpUst35eWljJQNwsxN49r6Z50S9M4O0vdgSuZdO5JJyIiIiIiaqxDBelGoxGCIODzzz+Hr6+pvPqNN97AzTffjHfeeQfu7u6NrtFoNNBoNO291A7BMoattGVB+uE0efvRAZa7ExERERERNaVDlbt3794d4eHhlgAdAPr16wdRFHH58mUnrqxjulLuLn9PeoVOj7NZZQDkBemBXlImnY3jiIiIiIiIGupQQfqECROQmZmJ8vJyy7ELFy5AoVAgIiLCiSvrmEJ8TEF6Xrn8gPn45WIYjCLCfLXo7tu4gsGWAE9zd3fuSSciIiIiImrEqUF6eXk5jh07hmPHjgEAkpOTcezYMaSlpQEw7Se/++67LeffcccdCAwMxD333IMzZ84gPj4eTz75JBYvXmy11J2aFuxl2pPeknL3luxHB+o0jquogSiKsp+XiIiIiIioM3NqkJ6QkIBhw4Zh2LBhAIClS5di2LBheP755wEAWVlZloAdALy8vPDrr7+iuLgYI0eOxIIFCzB79mysXbvWKevv6KRMekFFDQxGeQHzYZnz0SVSubtOb0RljUHWtURERERERJ2dUxvHTZ06tcls6vr16xsd69u3L3799dc2XFXXEeiphiAABqOIwooayx715hiNIo6kFQOQH6R7qFXQuilQXWtEYUUNPDUdqnchERERERFRm+pQe9LJsVRKhaX8XE7zuKT8cpRU1ULrpkC/7j6ynzfQvC89vwV74YmIiIiIiDozBuldXLC3/H3pR1KLAQCDI/zgppT/K8RZ6URERERERNYxSO/ienfzAgDsOJdr9zUt3Y8u4ax0IiIiIiIi6xikd3G3jowEAGw5moEKnd6uaw6nmYP0qJYF6YGdPJOeXVKN2W/vwaZD6c5eChERERERdTAM0ru4cXGB6BHkiXKdHluPZTR7fnFlDRJzTXPq5Y5fk3T2cvddF3JxMqMEGxMYpBMRERERkTwM0rs4QRBwx5goAMBnB9KanV1+1NzVvUeQpyXYlivAPIatoLxzBun55tfFxnhERERERCQXg3TCzSMioFEpcDar1DJazRZpP3pLs+hA3XL3zhnE5pWZXld+Wed8fURERERE1HYYpBP8PNSYPSQMAPD5H6lNntvapnHAlRFsnbXcXcqgV9QYUFVjcPJqiIiIiIioI2GQTgCAO8dGAwD+dyILRTaCZ73BiGPpxQCA4S1sGgfUKXfv5EF6wz8TERERERE1h0E6AQCGRPhiQJgPavRGfHP4stVzzmWXoarWAG+NCr1CvFr8XFK5e2ffkw503g8iiIiIiIiobTBIJwCmBnJSNv3zP1JhNDZuIHfEPHptWLQ/FAqhxc8lNZyrqu2c5eAFdTPp3JdOREREREQyMEgniz8NDYO3RoWUgkrsvZTf6HHLfvRWlLoDgJdGBbXS9KtX0Mmax9UajCiqrLV8z3J3IiIiIiKSg0E6WXioVZg3PBwA8PmBtEaPO6JpHGDK2nfWWekNXw/L3YmIiIiISA4G6VTPAnPJ+69nc5BdUm05nlNajctFVVAIwJBI31Y/jxSku2IQW1pd2/xJNuQ1KG9v+D0REREREVFTGKRTPb27eWN0TAAMRhFfHbqSTT9izqL3CfWBt9at1c8TaO7wXuhizePiL+Rh8PJf8Pb2iy26vmF5O8vdiYiIiIhIDgbp1MiCsVEAgK8OpkNvMAKoW+ru55DnCHTRcved53MBAAdTClt0fX6DDx06awd7IiIiIiJqGwzSqZEZA0MR6KlGdmk1fjtrClqlzu6tmY9eV4CnBoDrlbufySwFAOSWtiwDLnV27+Zjen3MpBMRERERkRwM0qkRjUqJ+aMiAZjGsVXXGnAqwxS8trZpnEQqdy9woSBWFEWczTIH6WXVzZxtnRSU9wn1qfc9ERERERGRPRikk1V3jI6CIAC7L+bjhxNZqDEYEeSlRlSAh0Pu74rd3TOKq1BarQcAFFXWQqeXP8NdKnfvF+ptuY+0ZYCIiIiIiKg5DNLJqsgAD0zpHQwAeOXHswBMpe6CIDjk/q7Y3V0qdZe0pORdypzHhXhBYX6rXOmDCCIiIiIicm0M0smmO8eYxrFJQaajSt0B12wcdyarQZDegpJ3aeRaiLfGsu8+jyXvRERERERkJwbpZNO0viEI89VavndkkO6K5e6OyaSbXk+QlwZBln33rvMaiYiIiIjItTFIJ5uUCgG3jzaNY3NTChgY7uuweweas8zlOn2L9n63BSmTLmX5c0rlZdINRhGFFabAPthbg2BvdngnIiIiIiJ5GKRTk+4YE4W+od64fXQUtG5Kh93Xx10FlXnTtitk00uqanG5qAoAMNm8Fz+nTF5wXVxZA6No+nOAp9oS7DNIJyIiIiIie6mcvQBybYFeGvz818kOv68gCAjwVCO3TIeC8hp093V3+HPIIY1eC/dzR69uXgDkZ9KlUnd/Dze4KRUI8jLPgme5OxERERER2YmZdHIaV9qXLgXp/cN80M3btA8/T2YmXcqYB5qD8yBvNo4jIiIiIiJ5GKST0wRKjdUqnB/ESk3j+nX3QTcfU5AuP5Nueh1Sw7gr5e7O/xCCiIiIiIg6Bgbp5DTSiDJXKAeXmsb17+6DEB/TunJkdneXMu9BDTLpBS3IpNcajHj+u1PYdjpb9rVERERERNRxMUgnp3GVWek1eiMu5pQDAAbUKXcvqapFda39nefrjl8DgCDPlnd3330xD5/sT8WTXx9HVY1rdL8nIiIiIqK2xyCdnMZV9qRfyitHjcEIb40KEf7u8HFXQaMy/dWQsy9dyphLo9eCvK/MSTdKbd/tJHWaL63W48eTWbKuJSIiIiKijotBOjmNFKQXODlIt+xHD/OBIAgQBKFOybv9+9Ib70k33UNvFFFaXStrTRnmIB0AvjyYJutaIiIiIiLquBikk9O4Srl73f3oEqnkXc6+9Ibl7mqVAj5alfkxeSXvGcVXgvSE1CJcyCmTdT0REREREXVMDNLJaaRRZc4O0uuOX5O0pMN7wxFsQJ0xbGXyXmOmOUj31piC/K8Opsu6noiIiIiIOiYG6eQ0lnJ3J84RF0XRaiZdKnfPtXNPuiiKli71Urm76c/mDu8yx8xlFps+HLh3UiwAYPORy7Ka2NnL2IJSfCIiIiIiajsM0slppHL30mo9avRGp6whq6QaxZW1UCkE9OrmZTkeYi53z7Uzk15apUeNwfQagupm0s0Be76MBnS1BiNyykzPe9uoKIT7uaOkqhY/n3L8OLZ/77qEwct/wb7EfIffm4iIiIiI5GtRkL57927ceeedGDduHDIyMgAAn376Kfbs2ePQxVHn5uvuBqVCAAAUVTqn5F1qGtczxAsaldJyvJvUOK7MviA935wp99aooHW7ch8pYM+XMQs+u6QaogiolQqEeGswf2QkgLZpIPffY5kAgF0X8xx+byIiIiIikk92kL5582Zcd911cHd3x9GjR6HTmYKTkpISrFy50uELpM5LoRDg7+EGAJZS8fZmrdQduLInPdfOxnFSplzagy5pSbm71DQuzE8LhULA/FERUAjAH8mFuJRXbvd9mlNSVYsLuaaGdCn5FQ67LxERERERtZzsIP3ll1/Gu+++i/fffx9ubm6W4xMmTMCRI0ccujjq/Jw9K13KpNdtGgfUyaTbWe6eb2U/OgAEmr+X0zgu0xKkuwMAuvu646q+IQCArxyYTT+SVgTRPL49Jb/SYfclIiIiIqKWkx2knz9/HpMnT2503NfXF8XFxY5YE3UhV2alO6d5nK1MerB5T3pptR5VNc03bLN0dve0nkmXM4KtYZAOmPamA8DmIxnQ6R3TQO5IapHlz6mFFTAaRYfcl4iIiIiIWk52kB4aGorExMRGx/fs2YMePXo4ZFHUdUhBrTMy6WXVtUgrNGWQ+zUI0n20KmjdTH89cu3Yly4F4UHe9TPprSt3vxKkT+0TjFAfLQoravDL6Ry779WUhJQrQXp1rdHu/fdERERERNR2VHIv+POf/4xHH30UH330EQRBQGZmJvbv348nnngCzz33XFuskToxe8vd9QYjFnzwB05nlqKbjwbdfd0R6qtFd1+t5X+7+WgR4ecBXw+3Ju8lOZdt2o8d5quFv2f94FoQBHTz0SK1oBK5ZTpEB3o2eS9LkO7VMJMudXe3/0OIDPP4tYg6QbpKqcD8UZFYu/0ivjyYhtlDwuy+nzW1BiOOpRcDADQqBXR6I5LzK9Dd173pC4mIiIiIqE3JDtKfeeYZGI1GXH311aisrMTkyZOh0WjwxBNP4C9/+UtbrJE6MWnPdkEzQfqexHz8kVwIACjP0+NSnu1GZ6/MHYgFY6KbfW5b+9El3bxNQbo9+9KlPeeNg3TT91W1BlTo9PDUNP9Xzlq5OwDMHxmBt3dcxL5LBUjJr0BMUNMfHDTlbFYpqmoN8NGqMCzKH7su5CG1oBLj41p8SyIiIiIicgDZQbogCHj22Wfx5JNPIjExEeXl5ejfvz+8vLyav5ioAWlWemEz3d23HDWN+ps3PBw3D49AVkk1skurkVVShewSHbJLq5BZXI3Cihqs3X4RN4+IqDdSzRopSG9Y6i4JtjSPa75UXSpnbxike2pUcHdToqrWgILymmaDdFEU6wTp2nqPRfh7YErvYPx+Pg9fHUrHMzP7NrsuW6RS9xHR/ogO9MSuC3ns8E5ERERE5AJkB+kStVqN/v37O3It1AUFeDa/Z7tcp8e209kAgLvGRmNYlL/V82r0RkxavQM5pTp8dyzTMl/cFltN4yTdvKUxbPbvSQ9usCcdMFULXC6qQl65DlGBHk3ep6SqFpXmRnUNM+kAcPvoKPx+Pg/fHE7H0mt6Q62S3VYCAHA49UqQ7mX+4CCZQToRERERkdPJDtKnTZsGQRBsPr5jx45WLYi6livd3W1n0redykZ1rRGxQZ4YGuln8zy1SoF7J8Zi5Y/n8F58Em4eHgGFwvrvaq3BiPM5pj3pNsvdzZn03LLmM+n5NsrdpWOXi6rs6vB+uajKfI0aWrfGlQBX9Q1BsLcGeWU6/HY2B9cP6t7sPRsSRREJqaatAyOiAyzd4lMLOIaNiIiIiMjZZKfhhg4diiFDhli++vfvj5qaGhw5cgSDBg1qizVSJybtSW+qcZxU6j53WHiTHxABpkyzt0aFxNxy7Dyfa/O8pLwK1OiN8NKoEOlvPbvdzceUSW9uT3qFTo+qWlOgG2g1SDd/ENFMST9gez+6xE2pwPyREQCAL1s4M/1yURVySnVQKQQMjfRDrHlve0oBx7ARERERETmb7Ez6m2++afX48uXLUV5eLute8fHxWLNmDQ4fPoysrCxs2bIFc+bMsXn+77//jmnTpjU6npWVhdDQUFnPTa5ByqQXV9ZCbzBCpaz/uVF2STX2XsoHYArSm+OtdcMdY6Pwn11J+M+uJFzdr5vV885klQAA+nX3tpltD/GW9qQ3HaRLGXKtmwKe6sbZbzmz0i1BehNd1m8bFYV1Oy9h98V8pBdWIjKg6RL6hqRS9wFhPnBXKxHu5w6VQoBOb0R2abXNDwiIiIiIiKjttWxDqxV33nknPvroI1nXVFRUYMiQIVi3bp2s686fP4+srCzLV0hIiKzryXX4e6ghJceLKmsbPf7dsQyIIjAqxt/uYHTxhFi4KQUcTCnEkbQiq+dYOrvb2I8OACE+0p70poPruuPXrGX6ZQXpJaYPBJoKlCMDPDCpVxAA4KtD8rPpV/ajBwAwjXeT3ls2jyMiIiIici6HBen79++HVqtt/sQ6Zs6ciZdffhlz586VdV1ISAhCQ0MtXwqFw14GtTOlQoCfu2muubWS9yul7hF237ObjxZzhpqy7u/tSrJ6ztmspvejm+5jCq7LdHpU1uhtnpdfbns/OlBnzJwd5e4ZRdY7uzd0++goAMDXCZdRazA2e9+6EsxB+siYKw34YswN7VK4L52IiIiIyKlkl7vPmzev3veiKCIrKwsJCQl47rnnHLawpgwdOhQ6nQ4DBw7E8uXLMWHCBJvn6nQ66HRXMpilpaXtsUSSIdBLg6LKWnOHd2/L8TOZpTiXXQa1UoEbZDZIWzK5B74+fBnbzmQjKa8cPYKvjAgURbFOZ3dfm/fwqjM+LbdUh5gg639d6mbSrZGO59mRSc8wl7tH+Dddcj69XzcEeamRW6bDjnO5uG6Afds9yqprcT7b9NpHRl8J0qMDPQHkIaWAmXQiIiIiImeSnYL29fWt9xUQEICpU6fixx9/xAsvvNAWa7To3r073n33XWzevBmbN29GZGQkpk6diiNHjti8ZtWqVfXWGxnZ9Fguan/SvvSGmfStx0xZ9Kv6hsDXw03WPXt188b0fiEQReCDPcn1Hssp1aGwogZKhYBe3bxs3AEQBMGSTW9qX7rU2d3a+DXgSpBeIGdPejP7wtUqBW4abqou2HQovdn7So6mFcMoApEB7pZyfgCW5nEcw0ZERERE5FyyM+kff/xxW6zDLn369EGfPn0s348fPx6XLl3Cm2++iU8//dTqNcuWLcPSpUst35eWljJQdzGBno3LwQ1GEd+Zg/S5w5tvGGfNkslx+O1sLr45fBmPTe+NYHMjOKlpXFywp9UxZ3WF+GiRUlCJnCbGsDWfSVebz2u63F2nN1jGvdnTvO2WkZH4T3wSdp7PRU5ptaUbfVOkUvcRDWbNx5iD9FRm0omIiIiInKrDb+YePXo0EhMTbT6u0Wjg4+NT74tci7VZ6fsu5SOnVAc/DzdM69OyxoCjYvwxLMoPNXojPtmfYjluT9M4STdL87gmMunmIF36sKEhKXgvqapFjd72/vGcEtN9NCqFzXvV1TPECyOi/WEUgW+PZDR7PgAcluajxwTUOy7tSU8tqOQYNiIiIiIiJ7IrSPf390dAQIBdX+3t2LFj6N5d3n5lci2BlnL3K9nqLeagc9bg7lCrWvZZkiAIuH9yDwDAJ/tTUaEzNX+z7EdvommcRBrDlmtPJt3beibd190NKvOYt6bmwV8uNjVtC/dzb3YevOTWkaaqkK8T0iGKTQfXeoMRR9OKAdTfjy49pzSGLauZkXNERERERNR27Cp3f+utt9rkycvLy+tlwZOTk3Hs2DEEBAQgKioKy5YtQ0ZGBj755BPLOmJjYzFgwABUV1fjgw8+wI4dO/DLL7+0yfqofTTck15Zo8fPp7MByOvqbs01/UMRG+SJ5PwKbDyUjsUTY+tk0m03jZPYsye9oJnu7gqFgABPU5O3/HIdQn2tl6VnFjc/fq2hGwZ3x/LvTyMpvwIJqUUYFWP7g7Jz2WWorDHAW6NC727e9R5TKRWICvBAUn4FUvMrEM5Z6URERERETmFXkL5w4cI2efKEhARMmzbN8r20d3zhwoVYv349srKykJZ2ZQ50TU0NHn/8cWRkZMDDwwODBw/Gb7/9Vu8e1PEEWBqrmYLdbaezUVljQEygB4ZH+bXq3kqFgD9P6oG/bTmJD/ck46bhEUgtNGWs+3X3bubqK+XuTQXpec3sSZceyy3TNdnh/UrTOPtHGXpqVJg1uDs2JVzGxkPpTQbpCSmmUvdh0f5QKhpn6qMDTUF6ckEFxvcMsnsNRERERETkOLIbx9VVXV2Nmpr65bty9nxPnTq1yRLd9evX1/v+qaeewlNPPSVrjeT6Ahtk0rcczQQAzBkWbnfZd1PmDQ/HG7+eR0ZxFf7x63mIIhDqo0VgE0G1JMTbvCfdRrl7da0BZdWmMvrgpoJ0bw2Q1fSsdHs7uzd066hIbEq4jB9OZGH5jQPgpbH+1/qwjVJ3SUyQJ3A+Dyns8E5ERERE5DSyN/tWVFTg4YcfRkhICDw9PeHv71/vi0iuuuXuuaXV2HMxDwAwZ2jLuro3pHVTYtH4GACmvemAffvRASDEXO6eW2o9SJea3amVCvi42/7MK8hT6vBuO5MuzUiXW2o+PMofPYI9UVVrwP+OZ9o877A5k24rSJfGsKUUVMp6fiIiIiIichzZQfpTTz2FHTt24N///jc0Gg0++OADrFixAmFhYZa940RyBJpHlBVV1mDrsQwYRWB4lJ9lLJgj3Dk2Gh7qK+PW7OnsDlwpdy/X6VFubjxXV745wx7opW4y6y81lctvogFdS4N0QRAsDeQ2JVifmZ5ZXIXMkmooFQKG2thCEB1oDtKZSSciIiIichrZQfr333+Pd955BzfddBNUKhUmTZqEv//971i5ciU+//zztlgjdXL+HqYg3SgCG/aZMt1zh7euYVxDfh5q3Doq0vJ9PzuDdC+NCp7m4N7aGDbL+DWvpkemBVoZM1eXKIotLncHTLPklQoBR9KKkZhb1uhxaT56/+4+8FBbz/jHmoP01EKOYSMiIiIichbZQXphYSF69DCNtfLx8UFhoamEduLEiYiPj3fs6qhLcFMq4OvuBsCUTXZTCpg1yPFj9e6dGGtpmDYw3P7eCZZZ6Vay4Pl2NI2r+7itcveiylpU15pmqNvq/t6UEG8truprmie/KeFyo8elUvcRNkrdAVPDOjelgBqOYSMiIiIichrZQXqPHj2QnJwMAOjbty82bdoEwJRh9/Pzc+jiqOuQMs0AMK1PCPw9m85Mt0SEvwfevXME1tw82FLabY9gb9tj2PKbGb8mkcrd82yUu0tZ9CAvDbRuSqvnNGe+ueT92yOXUWsw1ntMyqQ3FaSrlApE+nsAYMk7EREREZGzyA7S77nnHhw/fhwA8Mwzz2DdunXQarV47LHH8OSTTzp8gdQ1BNQJyucNd0zDOGuu6d8Nt4yMbP7EOiyZdCvN4+zNpDdX7n65yLwf3b/l88mn9QlGsLcG+eU12HEu13K8XKfH2SzTbPiRMU03d5T6ACQzSCciIiIicgrZI9gee+wxy5+nT5+Oc+fO4fDhw+jZsycGDx7s0MVR1yEF6T5aFaaZy7ZdRTepw3tZU5n0pjP/Uja+sKIGRqMIRYM55ZmWpnHyS90lKqUC84aH4z+7krDpUDquGxAKADiWVgyjaGpI19236Q8BYqR96QUM0omIiIiInEF2Jj09vX736OjoaMybN48BOrVKd/M+7BsGh0Gjalm5d1uRMuk51jLp5vJ1KQi3RfoQwmAUUVTZOJtuaRrXTBDdHKnkfef5XEt5fkJq8/vRJTFBpnL35HyOYSMiIiIicgbZQXpMTAymTJmC999/H0VFRW2xJuqC/jy5Bx6cGoenZ/Rx9lIaaXpPun3l7m5KBfw8TM3xrJW8Z5a0vLN7XXHBXhgZ7Q+jCGw+Ymogd9i8H725UnfgSiY9hZl0IiIiIiKnkB2kJyQkYPTo0XjxxRfRvXt3zJkzB9988w10Otvzn4maE+Hvgadm9IWfh+MbxrWWPd3dmxvBBtTp8G7lPhnFpg8AWrMnXTLfPGru64TL0BuMOJpWDMC+THqseU96WkElDBzDRkRERETU7mQH6cOGDcOaNWuQlpaGn376CcHBwViyZAm6deuGxYsXt8UaiZzqSuO4+pl0vcGIospaAM1n0k3nmAL5PCtj2DKkxnGtzKQDwA2DusNTrURyfgW+OJiGcp0enmol+oY2P3auu695DJvBiCxzdp+IiIiIiNqP7CBdIggCpk2bhvfffx+//fYbYmNjsWHDBkeujcglhJjL3StqDCjX6S3HC81l6woB8LejAiDQHMgXlNcvd6+uNVgy8q0tdwcAT40KswaHAQDW/HweADAsyt8yI74pKqUCkQHSGDbuSyciIiIiam8tDtIvX76M1atXY+jQoRg9ejS8vLywbt06R66NyCV4alTw0pgGIdTdly5lxAM8NXYFwMFSuXuDTHp2iemeWjcF/M371ltr/qgIAECZ+UMFe0rdJbHmfenJ3JdORERERNTuZI9g+89//oMvvvgCe/fuRd++fbFgwQJ89913iI6Obov1EbmEEB8NyvP0yCmtRlywFwD7x69JpPMaBulXxq+5QxCaD/btMTzKH3HBnriUZwq07WkaJ4mWxrBxVjoRERERUbuTnUl/+eWXMWbMGBw+fBinTp3CsmXLGKBTp9fN27QvPa9O0zd7x69JbJW7ZxQ7prN7XYIgWMaxKQRTubu9Ys1j2NjhnYiIiIio/cnOpKelpTks20fUUYT4NB7DZuns7mlvJt16uXtGseOaxtV1y8hIbDyUjqFRfpZyfXvEmDu8JzOTTkRERETU7mQH6QzQqSuSOrznlNbJpNs5I11ypdy9fiY9sw0y6QAQ4KnGjiemyr5OmpWeXlgFg1G0a789ERERERE5RosbxxF1JVKH97qZdKlsPcjOcve6mXRRvDKDPNM8I93RQXpLhfm5Q61UoMZgtHyAQERERERE7YNBOpEdLLPS6+xJz5OZSQ80Z9J1emO9UW6ZbVTu3lJKhYDIANNauC+diIiIiKh9MUgnsoOUSc+ttyddXnd3D7UKHmplvWtFUWyzPemtIZW8pxRwVjoRERERUXtikE5kh7p70qVSdbl70uueW2C+tqCiBjq9EYIAdPO1/z5tTWoel8LmcURERERE7Up2kJ6Tk4O77roLYWFhUKlUUCqV9b6IOiOpu3tVrQFlOj2MRhGFFaZsuL0j2IDGs9KlUvdgLw00Ktf5+8MgnYiIiIjIOWR3d1+0aBHS0tLw3HPPoXv37uz2Tl2Ch1oFb60KZdV65JbqUOthhMFoyqgH2DmCDbgyKz3PXO5u2Y/u7zql7gAQE8hZ6UREREREziA7SN+zZw92796NoUOHtsFyiFxXiLfGHKRXw2gueffzcIOb0v6ClIbl7hku1tldwjFsRERERETOIbvcPTIyst74KKKuwrIvvawa+WXy96MDQHCDcveMItdrGgdwDBsRERERkbPIDtLfeustPPPMM0hJSWmD5RC5rrrN466MX7O/1B24Uu6eX1a/3D3MV+uoZToEx7ARERERETmH7HL3W2+9FZWVlYiLi4OHhwfc3NzqPV5YWOiwxRG5Eql5XG6pzlLiLjeTbil3rzA3jiuR9qR7OGqZDhMb5IlLeRVIya/ApF7Bzl4OEREREVGXIDtIf+utt9pgGUSuL8T7Srm7xq2lQbpU7t4gk+7nWpl04Mq+9OR8zkonIiIiImovsoP0hQsXtsU6iFxeN0smvRoebqZxaXLGrwF1y911qK41WIJ1V9uTDgDR5jFsqSx3JyIiIiJqN7KDdAAwGAzYunUrzp49CwAYMGAAbrzxRs5Jp06t7p50b61pm0egjPFrgGkeOgCU6fRINs8g91Ar4evu1tRlThErZdIZpBMRERERtRvZQXpiYiKuv/56ZGRkoE+fPgCAVatWITIyEj/88APi4uIcvkgiVxBizprnllXDz8MUVMstd/dxV8FNKaDWIOLk5RIApk7qguB6I85igkz75NMLK6E3GKGSMWqOiIiIiIhaRvZ/dT/yyCOIi4tDeno6jhw5giNHjiAtLQ2xsbF45JFH2mKNRC5B2pNeXWtEcp4puxwks9xdEAQEepquOX65GIBrlroDQHdf0xi2WoOITPM8dyIiIiIialuyg/Rdu3Zh9erVCAgIsBwLDAzEq6++il27djl0cUSuxF2thI/WVHxSptMDkD+CDQCCvE3XnMy4kkl3RUqFgKhAUzadY9iIiIiIiNqH7CBdo9GgrKys0fHy8nKo1fIDFqKORNqXLpFb7l73mrNZpQCAcBfs7C6ROrwzSCciIiIiah+yg/RZs2ZhyZIl+OOPPyCKIkRRxIEDB/DAAw/gxhtvbIs1ErkMaVY6AHhrVNC6yW+WKJW71xpEAK6bSQeAGHMmXWpyR0REREREbUt2kL527VrExcVh3Lhx0Gq10Gq1mDBhAnr27Il//vOfbbFGIpfRzftK1lvufvQr19WvOHHVPekAEGMZw8ZZ6URERERE7UF2d3c/Pz989913uHjxIs6dOwcA6NevH3r27OnwxRG5mpA65e5yx69JgjzrB/eunEmPNQfpKcykExERERG1ixbNSQeAXr16oVevXo5cC5HL61an3L0l+9GB+pl0QQBCfV13T3pcsBcA0570s1ml6Nfdx8krIiIiIiLq3OwK0pcuXYqXXnoJnp6eWLp0aZPnvvHGGw5ZGJErCqlX7t7CTHqd4L6btxZuLjx/PNRXixkDQvHz6Wy88N1pbLx/rEvOdCciIiIi6izsCtKPHj2K2tpay5+JuipHZNID65S7h/u7bqm75O+z+uH3C7k4mFKI/x7PxJ+Ghjt7SUREREREnZZdQfrOnTut/pmoq6k7gs0R5e6uvB9dEuHvgYem9sQ/fr2AV344i6v6hsBb6+bsZRERERERdUqy62wXL15sdU56RUUFFi9e7JBFEbmqYO/WZ9IDPNSQKsbDXHhGel1/ntwD0YEeyC3T4e0dic5eDhERERFRpyU7SN+wYQOqqqoaHa+qqsInn3zikEURuSqtmxJ+HqYscnAL96SrlAr4e5iudeXxa3Vp3ZRYPnsAAOCjPcm4mNP4gzoiIiIiImo9u4P00tJSlJSUQBRFlJWVobS01PJVVFSEH3/8ESEhIW25ViKX8OdJPTCtTzAGhfu1+B5S2Xykv4eDVtX2pvUNwfR+IdAbRSz//jREUXT2koiIiIiIOh27R7D5+flBEAQIgoDevXs3elwQBKxYscKhiyNyRQ9N69nqezwzsy92nc/DhJ5BDlhR+3l+1gDEX8zH3sQC/HgyGzcM7u7sJRERERERdSqCaGc6bNeuXRBFEVdddRU2b96MgIAAy2NqtRrR0dEICwtrs4U6SmlpKXx9fVFSUgIfH858JpLrzV8v4J/bL6K7rxa/LZ0CT43dn/UREREREXVJcuJQu8vdp0yZgqlTpyI5ORlz5szBlClTLF/jxo1rUYAeHx+P2bNnIywsDIIgYOvWrXZfu3fvXqhUKgwdOlT28xJRy/3f1DhE+Lsjq6Qa63ayiVxDRqOIdTsTcSCpwNlLISIiIqIOSHbjuB07duCbb75pdPzrr7/Ghg0bZN2roqICQ4YMwbp162RdV1xcjLvvvhtXX321rOuIqPW0bko8P6s/AOD93UlIyit38opcy57EfKzZdh7Pbjnp7KUQERERUQckO0hftWoVgoIa76MNCQnBypUrZd1r5syZePnllzF37lxZ1z3wwAO44447MG7cOFnXEZFjXNO/G6b2CUatQcTy78+wiVwdJzNKAACpBZXQG4xOXg0RERERdTSyg/S0tDTExsY2Oh4dHY20tDSHLKopH3/8MZKSkvDCCy/Ydb5Op6vXib60tLSNV0jU+QmCgBdmD4BaqUD8hTz8cibH2UtyGafMQbreKCKzuNrJqyEiIiKijkZ2kB4SEoITJ040On78+HEEBgY6ZFG2XLx4Ec888ww+++wzqFT2NatatWoVfH19LV+RkZFtukairiI2yBN/nmz6wO7F78+gutbg5BW5hlOZJZY/pxRUOHElRERERNQRyQ7Sb7/9djzyyCPYuXMnDAYDDAYDduzYgUcffRS33XZbW6wRAGAwGHDHHXdgxYoVVkfA2bJs2TKUlJRYvtLT09tsjURdzUPTeiLMV4uM4ip8tDfZ2ctxupLKWqQXVlm+T2WQTkREREQyyZ6d9NJLLyElJQVXX321JZttNBpx9913y96TLkdZWRkSEhJw9OhRPPzww5bnFUURKpUKv/zyC6666qpG12k0Gmg0mjZbF1FX5qFW4Ynr+mDppuNYvzcF903sAbVK9md/ncbprJJ636cUVDppJURERETUUckO0tVqNTZu3IiXXnoJx48fh7u7OwYNGoTo6Oi2WJ+Fj48PTp6s3y35nXfesXSbt7ZPnoja3qzBYXj1p3PILdPhfycyMW94hLOX5DSnM0w9LwQBEEVm0omIiIhIPtlBuqR3796yys6tKS8vR2LilTnLycnJOHbsGAICAhAVFYVly5YhIyMDn3zyCRQKBQYOHFjv+pCQEGi12kbHiaj9qFUKLBwfgzXbzuPDPcmYOywcgiA4e1lOcdq8H31UTAAOJhcyk05EREREsskO0g0GA9avX4/t27cjNzcXRmP9EUM7duyw+14JCQmYNm2a5fulS5cCABYuXIj169cjKyurXTrGE1Hr3DE6Cm/vuIjTmaX4I7kQY3u0bRNJV3Uq05RJnzW4Ow4mFyKtoBIGowilomt+aEFERERE8gmizAHHDz/8MNavX48bbrgB3bt3b5Qxe/PNNx26QEcrLS2Fr68vSkpK4OPj4+zlEHUaz245ic//SMM1/bvh/btHOns57a6yRo+BL2yDUQT2L7sKk1fvRK1BxN5nrkK4n7uzl0dERERETiQnDpWdSf/qq6+wadMmXH/99S1eIBF1PosnxuLzP9Lw29kcpORXICbI09lLaldns8pgFIFgbw26+7oj0t8DSfkVSM2vYJBORERERHaT3YZZrVajZ8+ebbEWIurA4oK9MK1PMEQR+LgLjmOT9qMPDDN9Mhod6AGAHd6JiIiISB7ZQfrjjz+Of/7zn5BZJU9EXcC9E3sAAL4+fBklVbVOXk37kjq7Dwz3BQBEB5oqCVIL2eGdiIiIiOwnu9x9z5492LlzJ3766ScMGDAAbm5u9R7/9ttvHbY4IupYJvQMRN9Qb5zLLsNXB9Nw/5Q4Zy+p3ZwyZ9IHmDPpMeZMemo+M+lEREREZD/ZmXQ/Pz/MnTsXU6ZMQVBQEHx9fet9EVHXJQgCFk+MBQBs2JeCWoOxmSs6hxq9ERdyygAAA8LMmXTznvwUzkonIiIiIhlkZ9I//vjjtlgHEXUSNw4Jw+qfzyGzpBo/ncrGjUPCnL2kNnchpwy1BhG+7m6I8Dc1iYuRyt0LKiGKYpedHU9ERERE8sjOpBMRNUXrpsSdY6MBAB/uSe4S/StO1yl1l4LxcD93KBUCqmoNyCvTOXN5RERERNSByM6kx8bGNpkRSkpKatWCiKjju3NsNN75/RKOpxfjSFoRRkQHOHtJbepUg6ZxAKBWKRDu5460wkqkFFQixEfrrOURERERUQciO0j/61//Wu/72tpaHD16FD///DOefPJJR62LiDqwIC8N5gwNw6aEy/hwT3KnD9JPN2gaJ4kO9DAH6RUYHdu53wMiIiIicgzZQfqjjz5q9fi6deuQkJDQ6gURUedw78Qe2JRwGT+fykZ6YSUiAzycvaQ2YTCKOJNlyqRLTeMk0YEe2H0RSGXzOCIiIiKyk8P2pM+cORObN2921O2IqIPrE+qNSb2CYBSB9ftSnL2cNpOUV47qWiM81ErEmju6S6TmcSkFHMNGRERERPZxWJD+zTffICCA5ZxEdIU0jm3joXSUVdc6eTVt43SmKYver7sPlIr6/TqiLR3emUknIiIiIvvILncfNmxYvcZxoigiOzsbeXl5eOeddxy6OCLq2Kb0CkZcsCcu5VVgU8Jl3GsO2l1Zblk1/NzVUKvs+wzzVIZpP/rABvvRASAm0FTin5rPMWxEREREZB/ZQfqcOXPqfa9QKBAcHIypU6eib9++jloXEXUCCoWAxRNj8eyWU/hoTzLuGB0Fd7XS2cuy6UhaEW55dz9mD+6Ot24bZtc1UiZ9QLhvo8ciAzwgCECZTo/CihoEemkcul4iIiIi6nzsCtKXLl2Kl156CZ6enpg2bRrGjRsHNze3tl4bEXUC84ZF4J+/XURGcRX+vvUUXr9lsMtmlL9OSIfBKOK745l4/No+zTa7E0URp2x0dgdMM+O7+2iRWVKNlIJKBulERERE1Cy76jnffvttlJeXAwCmTZuGoqKiNl0UEXUe7mol3rptKBQCsPnIZWxKSG/RfapqDMgv1zl4dVfoDUZsO50DABBF4IuDac1ek15YhbJqPdRKBXqFeFs9h/vSiYiIiEgOuzLpMTExWLt2La699lqIooj9+/fD39/f6rmTJ0926AKJqOMbHxeEx6/tgzXbzuO5705jYLhvo3FlTTmfXYYFH/yBqho9vn1wAvqEWg+IW+NgciEKK2ogCKYgfeOhdPx1ei9oVLbL86X56L1DvWzuYY8J8sD+pAJ2eCciIiIiu9gVpK9ZswYPPPAAVq1aBUEQMHfuXKvnCYIAg8Hg0AUSUefwf1PicDi1CDvO5eL/PjuC7/8yEb7uzW+bOZddijve/wOFFTUAgKe+OY7N/zceKqXDhlMAAH48lQXAVJ6/NzEf2aXV+OlkNuYMC7d5jVTqPrCJDxyYSSciIiIiOez6r9w5c+YgOzsbpaWlEEUR58+fR1FRUaOvwsLCtl4vEXVQCoWAN+YPQYS/O9IKK/HE18chimKT15zJLMXt7x1AYUUNBob7wFurwvHLJfhgT7JD12YwipZS99lDuuOOMVEAgE8PpDZ53akM203jJFKHd2bSiYiIiMgeslJRXl5e2LlzJ2JjY+Hr62v1i4jIFj8PNd5ZMBxqpQK/nsnB+7uTbJ57KqMEd3xwAEWVtRgS6YfP7xuL527oDwB449cLuJRX7rB1HU4tQl6ZDt5aFcbHBeG2UZFQKQQcTi2ylLQ3JIqi5TFrTeMkzKQTERERkRyy60WnTJkClUr25DYiIgDA4Ag/PD/bFGy/9vN5/JFU0Oick5dLsOCDP1BcWYthUX749N7R8HV3wy0jIzC5dzBq9EY89c0JGIxNZ+Lt9eNJU6n7Nf27Qa1SIMRHi+sGhgIAPjtgvYFcbpkO+eU1UAhAv9CmgnRTJr24shbFlTUOWS8RERERdV6O3dRJRGSHBWOiMGdoGAxGEQ9/eRS5ZdWWx46nF2PBBwdQUlWL4VF++GTxaPhoTXvXBUHAqnmD4KVR4XBqETbsS2n1WoxGET+fygYAXD+wu+X43WOjAQBbj2agtLq20XWnMkxZ9J4hXk3OfvdQqxDibRq9lsqSdyIiIiJqBoN0Imp3giBg5bxB6N3NC3llOjz65THoDUYcTSvCnR/+gdJqPUZG++OTe8fAW1u/uVy4nzuWXd8XALB627lWl5EfTS9Gdmk1vDQqTOwVZDk+OjYAvbt5oarWgG8PX2503elM8350O7rUx0gl74UM0omIiIioaQzSicgpPNQqvLNgBDzUSuxPKsBjm47j7g8Poqxaj9ExAVi/eDS8NNa31tw+KgrjegSiutZU9m5sRdn7T+ZS96v7hUDrdiUjLggC7jJn0z89kNqoyZ2USW9qP7okylzynprPfelERERE1LQWB+mJiYnYtm0bqqqqAKDZLs1ERA31DPHCqzcNBgB8fzwTZTo9xsQG4ON7RtkM0AFTp/jXbhoMdzcl/kguxOcHre8bb44oivjJXOo+s06pu2TOsHB4qpW4lFeB/Q32zkuZ9IFNdHaXsMM7EREREdlLdpBeUFCA6dOno3fv3rj++uuRlWXKQt177714/PHHHb5AIurcbhwShkXjYwAA43oE4uN7RsGziQBdEhXogadn9AEAvPrjWVwukh8An8woQUZxFdzdlJjSO7jR495aN8wdbpqT/lmdcWxFFTXIKDZ9QNnfjkw6O7wTERERkb1kB+mPPfYYVCoV0tLS4OHhYTl+66234ueff3bo4oioa3hhdn/89OgkfHrvaHio7Z8ecfe4GIyOCUBFjQHLvj0pu6Lnx5OmLPpVfUNsNn+701zyvu10DnJKTQ3upCx6dKCHpaldU6Q96cykExEREVFzZAfpv/zyC1577TVERETUO96rVy+kpqbauIqIyDZBENCvuw9USnn/JCkUAl67eTA0KgV2X8zHpoR0u681lbqbKoFmDgq1eV7fUB+MjgmAwSjiS3NZ/SnzfPSBdjSNA67sSc8v16Fcp7d7jURERETU9cgO0isqKupl0CWFhYXQaDQOWRQRkb1igzzxxLWmsveX/3cWWSVVdl13JqsUqQWV0KgUmNYnpMlz7xxnyqZ/eTANtQajJZNuT6k7APi6uyHAUw2AJe9ERERE1DTZQfqkSZPwySefWL4XBAFGoxGrV6/GtGnTHLo4IiJ7LJ4Yi2FRfijT6fHoV8dQozc2e400G31qn+Bm98DPGBCKIC81ckp1+O1MDk6bO7vb0zROEi11eGfJOxERERE1QXaQvnr1arz33nuYOXMmampq8NRTT2HgwIGIj4/Ha6+91hZrJCJqklIh4PVbhsBLo8LB5EL8fWvT+9NFUcQP5tFr1w9q3NW9IbVKgdtGRQEA/hOfhGRzNtye8WuSK/vSmUknIiIiIttkB+kDBw7EhQsXMHHiRPzpT39CRUUF5s2bh6NHjyIuLq4t1khE1Ky4YC+8fccwKARgU8JlvL87yea5F3PLkZRXAbVSgav6Nl3qLrl9TBQUAnAsvRiiCIT6aBHkZf8WH0smPZ+ZdCIiIiKyzf42ynX4+vri2WefdfRaiIhaZVqfEDw3qz9WfH8Gq346h9ggL1zTv1uj8340Z9En9QqCtx3d2QEg3M8dV/frhl/P5AAABobbn0UHmEknIiIiIvvIzqT37NkTy5cvx8WLF9tiPURErbJofAwWjImCKAKPfnUUZ8xN3ur6yTx6baYdpe513WUexwYA/e3s7C7hnnQiIiIisofsIP2hhx7CDz/8gD59+mDUqFH45z//iezs7LZYGxGRbIIgYPmNAzChZyAqawy4b8Mh5JZVWx6/lFeO8zllUCkEXNOvcZa9KRN7BiE2yJQRHx7lJ+taKZOeXVqNqhqDrGuJiIiIqOuQHaQ/9thjOHToEM6dO4frr78e69atQ2RkJK699tp6Xd+JiJzFTanAO3eMQI9gT2SWVOPPnxxGda0pMJa6uk/oGQRfD/tK3SUKhYAPF47EG/OHYErvYFnX+nm4wUdr2mGUVshsOhERERFZJztIl/Tu3RsrVqzAhQsXsHv3buTl5eGee+5x5NqIiFrM18MNHy0cBT8PNxxPL8YTXx+HKIqW/ejXDwpt0X17BHth3vAICIIg6zpBEBATxH3pRERERNS0FjWOkxw8eBBffPEFNm7ciNLSUtxyyy2OWhcRUavFBHni3wtG4K4P/8D/TmTBQ63E6cxSKBUCrunfsiC9NaIDPXHicglSGaQTERERkQ2yM+kXLlzACy+8gN69e2PChAk4e/YsXnvtNeTk5OCrr75qizUSEbXYuLhAvDJ3IADTaDYAGNsjAAGe6nZfS3SAqXlcCpvHEREREZENsjPpffv2xahRo/DQQw/htttuQ7du8hovERG1t1tHReFSXgXeizfNTp85UF5Xd0e50uGdmXQiIiIisk52kH7+/Hn06tWrLdZCRNRmnp7RF0UVNTidWYrZg8OcsgbLnvR8ZtKJiIiIyDrZQToDdCLqiJQKAWtuGeLUNUiZ9KySKuj0BmhUSqeuh4iIiIhcj11BekBAAC5cuICgoCD4+/s32dW4sLDQYYsjIupMgr008FArUVljwOWiKsQFezl7SURERETkYuwK0t988014e3tb/ix39BAREZnGsEUHeuJsVilSCyoYpBMRERFRI3YF6QsXLrT8edGiRW21FiKiTi8m0ANns0q5L52IiIiIrJI9gk2pVCI3N7fR8YKCAiiV3F9JRNSU6EBT8zh2eCciIiIia2QH6aIoWj2u0+mgVrf/3GEioo4kJpCz0omIiIjINru7u69duxaAaU/lBx98AC+vK3spDQYD4uPj0bdvX1lPHh8fjzVr1uDw4cPIysrCli1bMGfOHJvn79mzB08//TTOnTuHyspKREdH4/7778djjz0m63mJiJzFnky6wSjidGYJRNHUEd7Pgx+AEhEREXUVdgfpb775JgBTJv3dd9+tV9quVqsRExODd999V9aTV1RUYMiQIVi8eDHmzZvX7Pmenp54+OGHMXjwYHh6emLPnj24//774enpiSVLlsh6biIiZ4gJMmXSLxdVodZghJvSVNBUUlWL+At52HkuF79fyENhRY3lGl93N0QHeiA60BPRAR6IDvRATJAnegR5ItBL45TXQURERERtQxBt1a/bMG3aNHz77bfw9/d37EIEodlMujXz5s2Dp6cnPv30U7vOLy0tha+vL0pKSuDj49OClRIRtZzRKKLf8z9Dpzfio0UjcTGnHDvO5SIhtQgG45V/jr21Kniolcgp1dm8lyAA6+4YjusHdW+PpRMRERFRC8mJQ+3OpEt27tzZ4oU52tGjR7Fv3z68/PLLNs/R6XTQ6a78R25paWl7LI2IyCqFQkB0oAcu5JRj8fqEeo/1DPHC1X1DMK1vCEZE+8NNqUBljR5phZVILahEakEFUgoqkVZQicTccmSXVuOVH87i6n4h0KjYuJOIiIioM5AdpN90000YPXo0nn766XrHV69ejUOHDuHrr7922OJsiYiIQF5eHvR6PZYvX4777rvP5rmrVq3CihUr2nxNRET2GhHtjws55VArFRgbF4ir+4bgqr4hiAzwaHSuh1qFvqE+6Bta/xPXyho9pq75HRnFVfjsQBrunRjbXssnIiIiojYku9w9ODgYO3bswKBBg+odP3nyJKZPn46cnJyWLURGuXtycjLKy8tx4MABPPPMM/jXv/6F22+/3eq51jLpkZGRLHcnIqep0OlxLrsM/bp7w0Mt+7NSiy8PpmHZtyfh7+GGXU9Ng4/WzYGrJCIiIiJHadNy9/Lycquj1tzc3NqtlDw21pQxGjRoEHJycrB8+XKbQbpGo4FGw8ZKROQ6PDUqjIhufV+PW0ZE4P3dSUjKq8B7u5LwxHV9HLA6IiIiInIm2XPSBw0ahI0bNzY6/tVXX6F///4OWZQcRqOxXqaciKirUCkVeOo60+jLD/YkIbe02skrIiIiIqLWkp1Jf+655zBv3jxcunQJV111FQBg+/bt+PLLL2XvRy8vL0diYqLl++TkZBw7dgwBAQGIiorCsmXLkJGRgU8++QQAsG7dOkRFRVnmscfHx+P111/HI488IvdlEBF1CtcN6IZhUX44mlaMt7ZfxMq5g5q/iIiIiIhcluwgffbs2di6dStWrlyJb775Bu7u7hg8eDB+++03TJkyRda9EhISMG3aNMv3S5cuBQAsXLgQ69evR1ZWFtLS0iyPG41GLFu2DMnJyVCpVIiLi8Nrr72G+++/X+7LICLqFARBwDMz+uLW9w5g46F03DsxFnHBXs5eFhERERG1kOzGcR0d56QTUWd07/pD2H4uFzMHhuLfd45w9nKIiIiIqA45cajsPekAUFxcjA8++AB/+9vfUFhYCAA4cuQIMjIyWnI7IiJqpadm9IUgAD+dysaRtCJnL4eIiIiIWkh2kH7ixAn07t0br732GtasWYPi4mIAwLfffotly5Y5en1ERGSHPqHeuGl4BADg1Z/OoYsVSRERERF1GrKD9KVLl2LRokW4ePEitFqt5fj111+P+Ph4hy6OiIjst/Sa3lCrFDiYXIjfz+c5ezlERERE1AKyg/RDhw5ZbdQWHh6O7OxshyyKiIjkC/Nzxz3jYwAAr/18DgYjs+lEREREHY3sIF2j0aC0tLTR8QsXLiA4ONghiyIiopb5v6lx8NGqcC67DFuPsk8IERERUUcjO0i/8cYb8eKLL6K2thaAafxPWloann76adx0000OXyAREdnPz0ONB6f1BAC88esFVNcanLwiIiIiIpJDdpD+j3/8A+Xl5QgJCUFVVRWmTJmCnj17wtvbG6+88kpbrJGIiGRYND4GoT5aZBRX4bMDqc5eDhERERHJ0OI56Xv27MGJEydQXl6O4cOHY/r06Y5eW5vgnHQi6go2HUrHU5tPwFujwuYHx6N3N29nL4mIiIioy5ITh7Y4SO+oGKQTUVdgMIq47b39OJRShHA/d3z74Hh089E2fyEREREROZzDg/S1a9diyZIl0Gq1WLt2bZPnenl5YcCAARgzZoy8VbcTBulE1FUUVdTgpnf3ISmvAv27+2DTA+PgpVE5e1lEREREXY7Dg/TY2FgkJCQgMDAQsbGxTZ6r0+mQm5uLxx57DGvWrJG38nbAIJ2IupK0gkrM+/de5JfXYHLvYHy4cCTclLLbkRARERFRKzi93P3XX3/FHXfcgby8PEffutUYpBNRV3M8vRi3vXcAVbUGzB8ZgdduGgxBEJy9LCIiIqIuQ04c2ibplIkTJ+Lvf/97W9yaiIhkGhLph3/dMQwKAdiUcBlrtyc6e0lEREREZEOLgvTt27dj1qxZiIuLQ1xcHGbNmoXffvvN8ri7uzseffRRhy2SiIha5+p+3fDinwYCAN787QK+Tkh38oqIiIiIyBrZQfo777yDGTNmwNvbG48++igeffRR+Pj44Prrr8e6devaYo1EROQAd46Nxv9NjQMALPv2JOIvuN6WJCIiIqKuTvae9IiICDzzzDN4+OGH6x1ft24dVq5ciYyMDIcu0NG4J52IujKjUcRjm47hu2OZ8NKosOn+cegfxn8LiYiIiNpSm+5JLy4uxowZMxodv/baa1FSUiL3dkRE1I4UCgGrbx6MsT0CUK7T4571B5FVUuXsZRERERGRmewg/cYbb8SWLVsaHf/uu+8wa9YshyyKiIjajkalxH/uGone3byQU6rDf3YlOXtJRERERGSmsuektWvXWv7cv39/vPLKK/j9998xbtw4AMCBAwewd+9ePP74422zSiIicihfdzcsvaYPHvjsMOIvcm86ERERkauwa096bGysfTcTBCQluXZGhnvSiYhMSqpqMezFX2AUgX3PXIUwP3dnL4mIiIioU5ITh9qVSU9OTnbIwoiIyHX4urthSKQfjqYVY8/FfMwfFensJRERERF1eS2akw4A+fn5yM/Pd+RaiIionU3qGQQA2J3If8+JiIiIXIGsIL24uBgPPfQQgoKC0K1bN3Tr1g1BQUF4+OGHUVxc3EZLJCKitjKxVzAAYG9iPoxGWRM5iYiIiKgN2FXuDgCFhYUYN24cMjIysGDBAvTr1w8AcObMGaxfvx7bt2/Hvn374O/v32aLJSIixxoW5QdPtRKFFTU4k1WKgeG+zl4SERERUZdmd5D+4osvQq1W49KlS+jWrVujx6699lq8+OKLePPNNx2+SCIiahtuSgXG9gjE9nO52H0xn0E6ERERkZPZXe6+detWvP76640CdAAIDQ3F6tWrrc5PJyIi1zaxl2lf+p5EjmIjIiIicja7g/SsrCwMGDDA5uMDBw5Edna2QxZFRETtZ5I5SD+UUoTqWoPD759RXIVz2aUOvy8RERFRZ2R3kB4UFISUlBSbjycnJyMgIMARayIionYUF+yFUB8tavRGHEwudOi9DUYR89/djxvf3ov0wkqH3puIiIioM7I7SL/uuuvw7LPPoqamptFjOp0Ozz33HGbMmOHQxRERUdsTBKFOybtjR7EdTi1CRnEVagxG/H6B5fREREREzZHVOG7kyJHo1asXHnroIfTt2xeiKOLs2bN45513oNPp8Omnn7blWomIqI1M6hWEbw5fxu6Ljg3St52+sg1q78V83DU22qH3JyIiIups7A7SIyIisH//fjz44INYtmwZRNE0T1cQBFxzzTX417/+hcjIyDZbKBERtZ0JPU2Z9LNZpcgr0yHYW9Pqe4qiWC9I33cpHwajCKVCaPW9iYiIiDoru4N0AIiNjcVPP/2EoqIiXLx4EQDQs2dP7kUnIurggrw06NfdB2ezSrHvUj7+NDS81fc8m1WGy0VV0KgUUKsUKK3W42RGCYZG+rV+wURERESdlN170uvy9/fH6NGjMXr0aAboRESdhNTl3VEl71IWfXLvYIyPCwQA7HXwnnciIiKizqZFQToREXU+E80l73su5lu2NLWGFKRfNyC03r2JiIiIyDYG6UREBAAYHRsAtUqB7NJqXMorb9W90goqcS67DEqFgKv7hlj2vB9OLUJVjeNnsbeXTYfScdXrvyOple8PERERkS0M0omICACgdVNidIxpC1NrS95/OWPKoo+OCYC/pxqxQZ4I93NHjcGIgymOncXent6Nv4Sk/ApsOZrh7KUQERFRJ8UgnYiILCzz0lsZpF8pde8GwDQJZELPjr0vPbO4Ckl5FQCAo2nFzl0MERERdVoM0omIyELaO34gqQA1emOL7pFXpkNCahEA4NoBoZbjEzr4vvQ9dT5cOJ5eDKOx9fv2iYiIiBpikE5ERBb9u/sg0FONihoDjqYVtege28/mQBSBwRG+CPNztxyXgvQzWaXIL9c5ZL115ZXpWvzBgj3qfrhQptO3et8+ERERkTUM0omIyEKhEDBeyni3sCxdKnW/tn+3eselWewAsO9SQStW2djv53MxbtV2PPzFEYfeV2I0ipYyfW+tCgBL3omIiKhtMEgnIqJ6JvVs+bz0supa7E00BeDX1Sl1l0yU9qU7sOS9tLoWz2w+Cb1RxC9ncnA41fGN6c5ll6GgogYeaiXmj4wEABxNb1mlAREREVFTGKQTEVE9UvO4E5eLUVJZK+va38/nocZgRI8gT/QM8Wr0+IQ6WXpHzGIHgJU/nEV2abXl+zd/veiQ+9a1JzEPADAmNgCjY00d8JlJJyIiorbAIJ2IiOoJ83NHj2BPGEVgf5K8jPcvZ3IAmBrGCYLQ6PHRsQFQKxXIKK5CSkFlq9e6+2IevjqUDgD4xy1DoFII2JOYj0MOHvMmVRVM7BWMYZF+AIDzOWUo1+kd+jxEREREDNKJiKiRlpS86/QG7DyXCwC4dkA3q+d4qFUYHu0HoOV73iXlOj2e2XwSAHD3uGjcNCICt4yMAAC89duFVt27rupagyXon9gzCCE+WoT7uUMUgRPpxQ57HiIiIiKAQToREVkxsVcwAHmB9L5LBSjX6RHircHQCD/b9zZ/ANDafemv/XQOGcVViPB3x9Mz+gIAHprWE25KAXsTC3Aw2THZ9COpRaiuNSLEW4Pe3Uwl/MOi/AAARxmkExERkYMxSCciokbG9giAUiEgtaAS6YX2laX/cloqde8GhaJxqbtE+gBg36V8GFo4a3z/pQJ8eiAVAPDaTYPhqTF1XI/w98At5sZub/7qmGz6bvMHFRN7BllK+IdF+QPgvnQiIiJyPKcG6fHx8Zg9ezbCwsIgCAK2bt3a5PnffvstrrnmGgQHB8PHxwfjxo3Dtm3b2mexRERdiLfWzbL32p6Sd4NRxK/m/ejWurrXNSjcF95aFUqr9TiZUSJ7bZU1ejy9+QQA4PbRUZZmdBIpm74/qQAHklo/6k0avVb3eYaa35tj6UUOa4BHREREBDg5SK+oqMCQIUOwbt06u86Pj4/HNddcgx9//BGHDx/GtGnTMHv2bBw9erSNV0pE1PVIXd6lzuZNOZpWhPxyHby1KoyJDWzyXKVCwPg48yi2FuxLf33bBaQVVqK7rxZ/u75vo8fD/dxx6yjHZNOLKmosHyRI7wcADAjzgZtSQH55DS4XVbXqOYiIiIjqcmqQPnPmTLz88suYO3euXee/9dZbeOqppzBq1Cj06tULK1euRK9evfD999+38UqJiLqeSb2uNI+7mFPW5LnbTmcDAK7uGwK1qvn/a7HseZe5Lz0hpRAf70sGAKyaNwjeWjer5z04tSfUSgX+SC7E/kstz6bvu1QAUQR6d/NCNx+t5bjWTYn+Yb4AgCNpnJdOREREjtOh96QbjUaUlZUhICDA5jk6nQ6lpaX1voiIqHlDIvwQFeCBsmo9bli7B+t2JqLWYGx0niiKltFrzZW6S6TmcYdTi1BVY7DrmupaA5765gREEbh5RASm9gmxeW5Y3Wz6bxdaXJIuVRFM7Bnc6DFpOwD3pRMREZEjdegg/fXXX0d5eTnmz59v85xVq1bB19fX8hUZGdmOKyQi6rhUSgU23T8OV/UNQY3BiDXbzmPOur04k1n/w87zOWVILaiERqXAlD6Ng1lrYgI9EO7njhqDEQftnGn+5m8XkJRfgRBvDZ67oX+z5z84LQ5qpQIHW5FNl7rbT+zVuISfHd6JiIioLXTYIP2LL77AihUrsGnTJoSE2M6mLFu2DCUlJZav9PT0dlwlEVHHFuqrxYcLR+LNW4fA190NpzNLceO/9uCNXy+gRm/Kqm87ZcqiT+oVBA+1yq77CoKACT3t35d+LL0Y78cnAQBWzh0EXw/rZe51dfd1x+2jW55NTy2oQHphFdyUgtV99sPNHd7PZJaguta+agAiIiKi5nTIIP2rr77Cfffdh02bNmH69OlNnqvRaODj41Pvi4iI7CcIAuYOi8CvSydjxoBQ6I0i1m6/iNlv78Hx9GL8csa0H/1aO0vdJfbuSz9xuRgPfHoYRhGYMzQM0/t3s/s5HpzWE2qVAodSirA3UV42XepqPyzK3zLira4If3cEeqpRaxBxJotbqYiIiMgxOlyQ/uWXX+Kee+7Bl19+iRtuuMHZyyEi6jJCvLX4953Dse6O4Qj0VON8ThnmvrMXpzNLoRCA6f3sD54BWDq8n8kqRX65zuo53x65jJvf3Y/s0mrEBXvihdkDZD1HNx8t7hgdBUB+Nn1vnfno1giCcKXknfvSiYiIyEGcGqSXl5fj2LFjOHbsGAAgOTkZx44dQ1paGgBTqfrdd99tOf+LL77A3XffjX/84x8YM2YMsrOzkZ2djZIS+XN2iYhIPkEQcMPg7vh16RTcOCQMRnPMOzo2AAGealn3CvLSoF93U3XTvgZ7xvUGI1763xks3XQcNXojpvcLwZaHJsBf5nMAwINT46BRKXA4tciyx7w5BqNoWVPd0WsNDTOXvB9lh3ciIiJyEKcG6QkJCRg2bBiGDRsGAFi6dCmGDRuG559/HgCQlZVlCdgB4L333oNer8dDDz2E7t27W74effRRp6yfiKirCvBUY+3tw/DeXSMwvV83PDOzX4vuI41521un5L2oogZ3f3QQH+4xjVp75KqeeO+ukfCxMW6tOSE+WiwYEw3ANDfdnmz6yYwSlFTVwlurwuBwX5vnscM7EREROZp9HX7ayNSpU5v8j6X169fX+/73339v2wUREZEs1w4Ilb0Xva4JPYPwXnwS9iTmQxRFnM0qw5JPE3C5qAoeaiXemD8EMwZ2b/U6H5jSA5//kYojacX4+vBlzB/Z9KQPqdR9fFwgVErbn2cPjvSDIAAZxVXILa1GSJ1Z6kREREQt0eH2pBMRUecxOiYAaqUCGcVVeHdXEm769z5cLqpCVIAHtjw4wSEBOmDKpj80rScA4NktJ/FHUtNN5HZflOaj2y51BwAvjQp9unkD4Cg2IiIicgwG6URE5DTuaiVGRJv2db/28zlU1RowqVcQ/vvwBPQJ9Xbocz08rSeuHxSKWoOI+z87jJT8CqvnVdbocTjVtMdc6kDflKEseSciIiIHYpBOREROVbcx2/2Te+DjRaPg5yG/QVxzFAoB/7hlKIZE+KK4shaL1x9CSWVto/MOJhei1iAi3M8dMYEezd5X6vB+LJ3N44iIiKj1GKQTEZFT3TYqEnOGhmHdHcOx7Pp+Te4Bby13tRLvLxyJMF8tkvIr8H+fH0atwVjvHGlu+8SeQRAEodl7Sh3eT1wugb7BvYiIiIjkYpBOREROFeilwVu3DcMNgx2z/7w5Id5afLhoFDzVSuy7VIC/bzlVr4mpNKatqdFrdfUM9oK3RoXKGgMu5JS3yZqJiIio62CQTkREXU6/7j741x3DoRCAjQnpeC8+CQCQW1aNc9llEART53l7KBQChkj70lnyTkRERK3EIJ2IiLqkaX1D8Nys/gCAV38+h22ns7Ev0dT1fUCYDwI87d8XL+1LZ/M4IiIiai2nzkknIiJypkXjY5CUV4FPD6Tir18dQ/8wHwD2Z9ElV4J0ZtKJiIiodZhJJyKiLksQBLwwuz8m9w5GVa3BMnptUs/mR6/VNSTCDwBwKa/Casd4iSiKWLv9Isav2o7fz+e2eN1ERETUeTFIJyKiLk2lVOBfdwxDrxAvAIBGpcDIGH9Z9wj00iDaPK7t2OViq+eIooiX/ncWb/x6AZkl1XjymxNNBvRERETUNTFIJyKiLs9H64aPFo3CkAhf/HlSD2jdlLLvMczcPO6YlX3pRqOIv205hY/2JgMAAj3VyCvT4ZUfz7Rm2URERNQJMUgnIiICEBngge8enognruvTouuleekNO7zrDUY8/vVxfHkwDQoBWH3zYPznrhEQBGBTwmXLXHYiIiIigEE6ERGRQ9Tt8C7NXa/RG/GXL49iy9EMKBUC3rptGOaPjMTImADcPTYaALBsywlU1uidtWwiIiJyMQzSiYiIHKBvqA80KgVKqmqRnF+B6loD7v80AT+dyoZaqcC/FwzHjUPCLOc/OaMvwny1SC+swhu/XHDiyomIiMiVMEgnIiJyALVKgYHhvgCAvYn5WLz+EHaez4PWTYH3F47EtQNC653vpVHhlXmDAAAf7U3GsfTi9l4yERERuSAG6URERA4iNY9b8f0Z7LtUAE+1EhvuGY0pva2PdJvWJwRzh4XDKAJPf3MCNXpjO66WiIiIXBGDdCIiIgeRmsfpjSJ8tCp8dt8YjOkR2OQ1z83qjwBPNc7nlOHdXZfaY5nUCaQWVKDWwA91iIg6IwbpREREDjI6NgBaNwUCPNX4cslYS9DelABPNV6Y3R8A8PaOi7iYU9bWy6QO7tczOZiy5ne8/st5Zy+FiIjaAIN0IiIiBwn21mD741Ox84mpGBDma/d1Nw4Jw9V9Q1BrEPH05hMwGMU2XCV1dNtOZwMAvjuaaZkkQEREnQeDdCIiIgcK93OHr7ubrGsEQcDLcwfCS6PCkbRifLo/pW0W10EZjSKqaw3OXobLOJxaBADILq3GuWxWXhARdTYM0omIiFxAd193PD2zLwBg9bbzuFxU6eQVuY4X/3cGg1f8gjOZpc5eitPll+uQnF9h+f7383lOXA0REbUFBulEREQuYsHoKIyOCUBljQHPbD4JfQsbg4miiM8OpGLdzkTo9B07A11rMOKbw5dRozfi+xOZzl6O00lZdMnv53OdtBIiImorDNKJiIhchEIh4NWbBkGjUmBPYj6e+Pq47P3poiji9V/O4+9bT2HNtvO47b0DyC6pbqMVt72jacUo1+kBAHsu5jt5Nc4nBekTewZZvi+rrnXmkoiIyMEYpBMREbmQHsFe+Ncdw6FSCNh6LBPPbjkpqznY2u2JWLfTNMrNU63E0bRizHp7Nw4kFbTVktvUrgtXMsWnMktQVFHjxNU4nxSkzx0WjtggT+iNIvYm8sMLIqLOhEE6ERGRi7mmfze8ddtQKATgq0PpWPH9GbsC9Xd+T8Sbv10AAPz9hn748dFJ6BvqjfzyGiz44A98uCe5w3UD33Xhyp5rUQT2XmpZQLr1aAZmvBWP05kljlpau6uuNeDkZdP6R8b4Y0rvYADcl05E1NkwSCciInJBswaHYc3NQwAA6/el4NWfzzUZYH+wOwmrfzbNzX5qRh/cN6kHogM9seXBCZgzNAwGo4iX/ncGj351DJU1+iafu6y6FpsPX8bi9Ydwz8cHUVLlnHLqvDIdTmWYmsX9aWgYALQ4a/z2jos4l12G57ae6nAfVEhOZZSgxmBEkJcaUQEemNrnSpDeUV8TERE1xiCdiIjIRd00IgKvzB0IAPjPriSs3Z5o9bwN+1Lw8g9nAQCPTe+NB6f2tDzmrlbizVuHYvns/lApBPz3eCbmvbMPqQUV9e5RVWPADyey8MCnhzHi5d/w+NfHseNcLnaez8NT3xx3ShC4J9GUIR4Q5oM5Q8MBALsv5steS1JeOS7lmV7vkbRi/Hgy27ELbScJ5lL3EdH+EAQBY3sEQqNSILu0Ghdyyp28OiIichQG6URERC5swZhoPDerPwDgzd8u4D+7LtV7/Is/0vDCf08DAB6aFodHru7Z6B6CIGDRhFh88eexCPLS4Fx2GWa/vQe/nM7G9rM5ePSroxjx8q946Isj+Pl0Nmr0RvQI9sSfJ8XCTSlg2+kcrN+X0uavtaFd5jLuKb2DMaZHANyUAi4XVSG1QN54ul/P5AAA3JQCAOC1n891yK73CSmmIH1kdAAAQOumxLi4QADs8k5E1JkwSCciInJx906MxZPX9QEArPrpHDaYA+ZNCen425aTAIAlk3vgiWv7QBAEm/cZHRuAHx6ZiOFRfiit1mPJp4dx74YEfHcsE5U1BoT7ueOBKXH48ZFJ2L50Cp69oT+evb4fAGDlj2dxLL24TV9nXUajiHhzN/cpvYPhoVZheJQ/AGCPzJJ3KUh//No+CPHWIK2wEp/uT3XsgtuYKIo4kmbOpMf4W45P5b50IqJOh0E6ERFRB/DQtJ74y1WmLPkL/z2NJ78+jqc3nwAALBofg2Uz+zYZoEu6+Wjx1ZJxuHNsFAAg2FuDeybE4NsHx2PP09PwzMy+6B/mY7nXwvExmDkwFLUGEQ99fgQlle2zP/10ZikKK2rgpVFheLQpKJXGjskZxZZXpsNhc3B745AwPHGt6cOOt3ckoriy43SKT86vQGFFDdQqBQaG+VqOT+kTAgBISC20jKojIqKOjUE6ERFRB7H0mt64b2IsAODrw5chisCCMVF4YXZ/uwJ0iVqlwMtzBuHg367GgWVX44XZAzA8yt/qPQRBwGs3D0ZUgAcyiqvwRDvtT5dGr42PC4Sb0vSfKxN7mYL0fZfy7Z4fv+NcDkQRGBTuizA/d9w0IgJ9Q71RUlWLt3dY3+PviqT96EMifKFWXfnPt9ggT0QHeqDWwFFsRESdBYN0IiKiDkIQBDx7Qz8sHBcNALh9dCRe+tNAWQF6XSE+WigVzV/ro3XDOwuGQ61U4NczOfhwT3KLnk8OafTaFHMHcwAYHOEHH60KpdV6nLhcbNd9pFL3a/p3AwAoFQL+Zi7h/2R/SqMGeq7qcIrUNC6g0WMseSci6lwYpBMREXUggiBgxZ8G4vDfp2PVvMFQ2BFkO8LAcF88N8sU3L760znL/ui2UFpdiyNpxQCAyb2uBOlKhYDxcaZsuj1Z48oaPXabS+OlIB0AJvcOxuTewag1iJaxda4uIbUQADAy2r/RY1PNJe+7zudyFBsRUSfAIJ2IiKgDCvTStPtz3jk2GjcM6g69UcRfvjjaZnu69yWaytl7BHsiMsCj3mMTzCXvu+3Yl777Yj50eiMi/N3RN9S73mN/u74vFALww8ksHDYHwK6qqKLGMkJuhJUgfWyPQKhVCmSWVONiLkexERF1dAzSiYiIyC6CIODVmwYhJtC8P/3rttmfbil17x3c6LFJ5uZxR9KKUNFMo7RfTl8pdW+4JaBvqA/mj4wEALz8w1mXzkAfNu9Hjwv2hL+nutHj7molxvbgKDYios6CQToRERHZzVvrhn/dMRxqlQK/nc3FB7sduz9dFMV689Ebig70QIS/O2oNIg6m2M6A6w1G7DhnCtKv7R9q9Zyl1/SGu5sSR9OK8ePJbAesvm1I3elHWtmPLpH2pUsfcBARUcfFIJ2IiIhkGRjui+dn9QcAvPbzOYeWi1/KK0dmSTXUKgXGxAY2elwQBEzq1fwotsOpRSiqrIWfhxtGxTQuEQdMjfPun9IDAPDqz2eh0xsc8Aoc70rTOOuvAwCmmhvsHUpuvsKAiIhcG4N0IiIikm3BmCjMHhIGvVHE45uOo7rWMQGu1KF8TGwA3NVKq+dMsGNeutTV/ao+IVApbf/nzpLJPRDirUF6YRU+3Z/a0mW3mRq9EcfNnexH2PiwATCNYosK8ECNwYh9lwraaXVERNQWGKQTERGRbIIgYOXcgejmo0FKQSXe2emYmeNN7UeXTIgLgiAA53PKkFta3ehxURTxS4PRa7Z4qFV4/NreAIC12y+2qhme3mDEg58fxiNfHoXRzjnuzTmVWQKd3ogATzV6BHnaPE8QBMt7xn3pREQdG4N0IiIiahFvrRtemD0AAPDvXZeQ2MrO4lU1BvyRbCqdn9rHdpDu76nGwDBfAMDeS42z6RdyypFWWAm1SoHJTQT7kptHRKJvqDdKq/VYu73lHzZ8ffgyfjyZjf8ez3TY3nCp1H14lH+j5ncNSe/Z7+fzXLoRHhERNY1BOhEREbXYzIGhmNbHNHP82S0nWxUc/pFcgBq9EWG+WsQFezV57sQmRrH9esbUBG5izyB4alTNPq9SIeBv15tmwH+yP6VFHzZU1ujx5q8XLN9/tNcxDfUs89GbKHWXjIsLhFqpQEZxFS7lcRQbEVFHxSCdiIiIWkwQBLz4p4HQuinwR3Ihvjl8ucX3spS69wluNms8sc6+9IYfDPxqZ6l7XZN7B+PqviHQG0Us/+9p2R82fLg7GbllOnTz0UAQTB8eXMwpk3WPhkRRxOHUYgDAyCaaxkk81CqM6WHqAC/t7Scioo6HQToRERG1SmSAB/463bSve+WPZ1FY0bJ93fbsR5eMiPaHRqVAbpmuXuY7u6Qaxy+XQBCAq/uFyHr+52f3h1qlwJ7EfPx8yv6RbAXlOvwnPgkA8Lfr++GafqYPBz7elyLr+RtKK6xEfrkOaqUCA8N97brmyr50BulERB0Vg3QiIiJqtXsnxqJvqDeKKmux6sezsq9PL6xEUl4FlAoB481Z8qZo3ZQYHWvKGtctef/1rCmLPjTSDyHeWllriA70xAOTTSPZXvrfGVTV2Nex/u0diSjX6TEo3BezB4fhngmxAIBvj1xuVSO6BPN+9IHhPtC6We9039DUPqYPJg4mF9ocxWY0ith1IQ/Pf3cKCU3MmiciIudgkE5ERESt5qZU4JW5AwGYGqgdSJI3Biz+oinzOzzKDz5aN7uusZS8J9YJ0ltQ6l7X/03tiXA/d2SWVGOdHR3rU/Ir8NkB0+i2ZTP7QqEQMLZHAPp190F1rRFfHkxv0ToAICHVFKSPjAmw+5q4YE9E+LujxmBs9DPIKa3Gv3ZcxOQ1O7Hwo4P4ZH8qlm467rBO9ERE5BgM0omIiMghRkQH4I4xUQCAZ7echE5v/+z0XeftL3WXSM3jDiSZGs6VVddiv7nb+7X9Q+2+T13uaiWem9UfAPBefBJS8iuaPH/NL+ehN4qY0jvYUgEgCALumRADwNSIrtZgbNFaDpubxo2wYz+6RBCEel3eDUYRv5/Pxf2fJmD8qzvw+i8XcLmoCj5aFdzdlEgrrLTaIZ+IiJyHQToRERE5zNPX9UWQlxqX8irw3q4ku66pNRix75Ip6zult/37yPuF+iDQU43KGgOOpRdj14U81BpE9AjyRM+QprvDN+W6Ad0wqVcQagxGvPi/MzbPO5ZejB9OZEEQgGdm9q332I1DwhDoqUZWSTW2nbZ/f7ukpLIWF3JMe+3lBOkAMNX8Hv7vRCYmr96JRR8fwrbTOTAYRYyM9sc/bhmCP/42HbeOigQAfH4gTfb6iIio7Tg1SI+Pj8fs2bMRFhYGQRCwdevWJs/PysrCHXfcgd69e0OhUOCvf/1ru6yTiIiI7OPr4WbJRL+9M7HZTDQAHEktQrlOj0BPNQaE+dj9XAqFgAmWLu95+OV060rdJYIgYPmNA+CmFLDjXC5+M5fQ1yWKomXv/bxhEejXvf66tW5KLDBXFXy8N0X2Go6km0rdYwI9EOSlkXWtNIqtqLIWGcWmrPmi8TH45bHJ+Ob/xuOmERFwVystVQ+/ns1BTmm17DUSEVHbcGqQXlFRgSFDhmDdunV2na/T6fD/7d15XNVV/sfx12XfL7KDgKjgjoSg5tJiWmbmVFZaY6a2T9pkTtPUtM5MZTaj055ZmdVoZTVt9qvGzCU3RBRzX0EQBQRkl+3e7+8P9CapCC7cq7yfj8d9KN/1c+/jPJT3Ped7TnBwME888QQJCQnnuDoRERE5Hb9LiGBgbBA1dVae/GrTKZczOzqr+yVxQTg5Nb702m8dfS598faDLN6eD5x5SAfoGOzDnQPrJ5H724LNVNU2HLq/eHs+KRlFuLk4MeWqTie8xm0Xt8PV2UTa3kNsyC5u1v3Tjkwal9Su6c+jH+Xt7sIjV3fmii4hzBiVwJrHh/DM77rTKdS3wXGdQn3pHdMGi9VgfurpPzsvIiJnl11D+rBhw3j22We54YYbmnR8TEwML7/8Mrfffjtmc9OWIqmurqa0tLTBS0RERM4dk8nEs9f3wM3FiZ93FvD1hv2NHn/s+ujNdfS59I05JZRV1ffGJ0Y3b3j4yTxwRSxhfh5kFx1m1rJfh+5brAYvfLcNgAn9Y2jr73nC80P8PLi2ZwQA763IaNa91x55Hj055vTey12XdGD2+N6M7BXZ6MzwR3vTP1qThUUTyImIOIQL/pn0qVOnYjabba+oqCh7lyQiInLBiwny5oFBsQA88cUmRr6xglFvreL3b69m7LspTHhvDXe9v5b7Pkxj8/76L9AviWt+SI/w96RDsLft5yFdQ3FuZm/8yXi7u/D48K4AvL54F9lFlQB8nraPHXnlmD1duf/y2EavcceR5dgW/HKgyUPKay1W0o/0vCc383n05hrWIxx/L1f2l1SxdEf+Ob2XiIg0zQUf0h977DFKSkpsr+xsDecSERFpCfdc1oFOoT6UVdexLquYNRlFrNxdyM87C1i8/SA/bs3j+yOTql0U5d/sZ6+PuuSYddXPxlD3Y13bM5x+HQKprrPy7Lf1a6fPWLgDgEmDYjF7Nb5cXHykmeR2baizGral2k5ly/5SqmqtmD1d6Rh8+hPgNYWHqzM39YoENIGciIijcLF3Aeeau7s77u6n95++iIiInD53F2c+uacf67MPUWsxsFgNai1WLFaDOqth+9MwDAZ1bvqs7r81IDaI91ftxdPV2Tb8/WwxmUz87bruDHv5Z37YnMfEeevILa2irb8nY/u1a9I17hjYnrV7DzE3JYuJg2IbHX4Ov66PntSuTbOf0T8dt/aN5p3lGSzenk9O8eGTDt93VFarwdyUvQT6uHNNfLi9yxEROWMXfEgXERER+2nj7cYVXc5u7/ZvDeoSwu392hHf1nzKAHw6OoX6Mr5/DO8uz+CnbfVDwh8e2qnJ97qqWyht/T3JKT7M1+n7GdW78Ufv1h0T0ltCx2Af+nUIZNWeQj5Zk8WUqzq3yH3Plld+2slLP+4E4KO7L6Zfx0A7VyQicmYu+OHuIiIicmFzdXbi79f14ObkczfvzOQhcbbh+N3C/bguoW2Tz3VxdrL1us9ekXHS2e6LKmp4ddFO2yz1LRXSAcZcXD+B3Mep2dRarGfturvyy3h98S4+WpPF4m35bNlfSlFFzSln/G+q7zYesAV0gEc+30BFdd1ZubaIiL3YtSe9vLycXbt22X7OyMggPT2dgIAAoqOjeeyxx8jJyeGDDz6wHZOenm479+DBg6Snp+Pm5ka3bt1aunwRERFpJXw9XPnXzT2ZsXAHf7+uR7OHod/SO4qXf9zJttwyVu0ppH/HX4fl78ovZ/aKDD5P20d1XX1A7hlpJjHa/2y+hUZd1S2MIB838suqWbQ1n6t7hJ3xNTMLKhj91moKK2qO2+fm4kSonzvhfp6Emj0Y1iOs2UPVt+wvZcr8DUD9LPVLtx8ku+gwL36/jb9d1+OM6xcRsReTcba+yjwNS5YsYdCgQcdtHzduHHPmzGH8+PFkZmayZMkS2z6T6fj/FNu1a0dmZmaT7llaWorZbKakpAQ/P7/TLV1ERESkWR7/YiNzU7K4slsos8YmsXJ3Ie/8vIfF2w/ajunR1o+7Bnbgmvhw3FxadsDjtO+38eaS3VwSF8SHd/Y9o2sVlldz45srySyspEOwN+0CvMgtrSa/tOqEoR3g/ss78vBVnZv0BUhheTW/e20FOcWHuSQuiPfG92bVnkLGvrsG0LB3EXE8zcmhdg3p9qCQLiIiIvawK7+MITOWYTJBpxBftueVAWAy1S8dd9fA9vRpH3DCDomWkFVYyWX/WoxhwLI/DyI60Ou0rnO4xsKtb68mPbuYyDae/Pf+/oT4etj2V9dZyC+tJq+0itzSKlIzinh/Vf3M99f2DOdfNyc0+rx/TZ2V295NYU1GETGBXnw1caBtlv3H/ruRj9ZkERXgyQ+TL8XLTdMviYhjaE4O1TPpIiIiIi0gNsSXSzsFYxiwPa8MT1dnxvVrx+I/Xc7btyfTt0Og3QI6QHSgl22t+nlrTm85NovV4IGP1pOeXYzZ05U5E/o0COhQP+t/VIAXyTEBXNszgr9d14N/3tQTFycTC345wG3vpHDoJL3thmHw9NebWZNRhK+7C++MS26wDN5fr+lCW3/PI8Pet5/WexARsTeFdBEREZEW8sTwrgzqHMyjw7qw+rHB/O26HsQEedu7LJsxfesnkPt0bTY1dc2bQK4+QG/ix615uLk48c64ZGJDmrbO+83JUbx/Rx98PVxYu/cQI99cSWZBxXHH/Wf1Xj5ak4XJBK/cmkhsiG+D/b4errxwYzwAc1ZmsnpPYbPeg4iII1BIFxEREWkhnUJ9eW9CH+67rGODHmBHMbhLCKF+7hRW1PDD5txmnTtz6R7+s7o+QL88+iJ6xwQ06/wBsUH89w/9aevvSUZBBTe8sYK0vUW2/St3FfDMN1sAePTqLgzqEnLC61wSF8ytfepn+n/ks1+orNFs7yJyflFIFxERERGgfrm40b3re9Pnpuxt8nlfrs9h2vfbAHhyeDeGNXOm9qPiQn35YmJ/ekaaOVRZy61vp7Dgl/1kFVZy/7x1WKwGNyS25Z5LOzR6nb9e05UIswdZRZUa9i4i5x2FdBERERGxuaV3FE4mWL2niF355ac8fuWuAv78Wf1SaHcNbM8dA9uf0f1DfD34+J6LubJbKDV1VibNW89NM1dSXFlLQpQ/U0fGn/LZ/fph7z2B+mHvKRr2LiLnEYV0EREREbGJ8PfkiiNDyT86xQRy23JLuffDNGotBsN7hvPXa7qelRq83FyYeVsSEwbEAJBfVk2IrzuzxiY1OvP7sS7tFMwtvY8Me/9cw95F5PyhdSlEREREpIHf943mx635zF+bTUV1HdV1VqpqLVTXWamus1Bda6W6zsrewgrKquvoExPA9JsTmrTGeVM5O5l4ekR3Ogb78M2G/TwxvBuhfh6nPvEYjw/vyrIdB9lbWMk/f9jO0yO6n7X6RETOFa2TLiIiIiINWKwGl764mJziw6c8tlOoD/Pv7Ye/l1sLVNZ8S3ccZNzsNZhM8NdhXfl932i83dVPJSItqzk5VCFdRERERI6zeX8J/9tcv5yau+3ljLvrr396uDjTq50/7i5NG4JuL4/99xc+WpMNgNnTlbEXt2Nc/xiCfd3tXFlDtRYrz//fVjbuK+HanuFcn9jWYb/8EJHmUUhvhEK6iIiISOtSZ7Hyydps3vk5g4wj66+7uThxU1Ikd1/SgfYOsFZ9RXUd989dx9IdB23b3FycGNo9jNHJUfTvGHhWHycQkZalkN4IhXQRERGR1sliNVi4JZeZS/eQnl0MgMkEQ7uFce9lHUiMbmOXug6WVXPHnFQ25pTg4erEHQPas3j7QbYeKLUd09bfk5uTI7k5OYq2/p52qVNETp9CeiMU0kVERERaN8MwSM08xFtLd7NoW75t+6Wdgnlp9EUEeLfcEPM9B8sZ994asosOE+DtxrvjkkmMboNhGGzKKWX+2my+TM+hrKp+dnqTCQbGBvGXq7vQo625xeoUkTOjkN4IhXQREREROWpHXhmzlu3hq/Qcai0G7QK9mD2+Nx2DfZp9rZW7CthfUsVV3UPx83A95fHrsg5x55xUDlXW0i7QizkT+pxw6H1VrYXvN+XySWo2q46s+R7q586iP12OjybBEzkvKKQ3QiFdRERERH5rR14Zd8xJZd+hw/h5uDBzbBL9OwY16dzy6jqeXbCFj1PrJ6dzd3Hi6h5h3JQUSf+OQTif4FnyhVvyeOCjdVTVWukZaWb2+N4E+Zx6IruswkrGzk5hb2Eld1/SnseHd2veGxURu1BIb4RCuoiIiIicSEF5NXd/sJb1WcW4OJl4fmQ8o5KjGj0nZU8hf/p0A/sOHcZkgugAL/YWVtr2h/l5MLJXW25MirT1zs9N2cuTX27CasCgzsG89vtezVoWbvH2fCa8l4qzk4lv/ziQLmH6nVbE0SmkN0IhXUREREROpqrWwsOfbmDBLwcAuP/yjjx8VefjZlavqrUwY+EO3v55D4YBkW08mX5zAn3aB7Axp4TP0vbxVfp+Sg7X2s7pFe1Ph2AfPkvbB8Do5Cieu6EHLs5Oza7z3g/X8sPmPPrEBPDJvRdjMmnmdxFHppDeCIV0EREREWmM1Wrw0o87eOWnXQBcEx/GjFEX4eFavx78ppwSpsxPZ0deOVAftp+4tiu+v3kOvbrOwqKt+XyWto8l2/OxHvNb94OD45g8JO60w3VO8WGGTF/K4VoL029O4MakyNO6joi0DIX0Riiki4iIiEhTfJ62j0f/+wu1FoOEKH/eui2Jz9ft46Ufd1BrMQjyceOFkT0Z0i30lNfKL63iy/QcFm87yI1Jkdx0FkL1m0t2M+37bQT5uLFoyuWYvU49WZ2I2IdCeiMU0kVERESkqVL2FHLvf9IorqzFxclE3ZHu8Ku7h/HcDT0IbMJkb+dKTZ2Va175mV355Yy9uB3/uL6H3WoRkcY1J4c2/wEYEREREZFWom+HQL64fwAdgrypsxr4erjw79EJvHlbL7sGdAA3Fyf+fl13AP6TspeN+0rsWo+InB3qSRcREREROYWSylq+3XiAyzsHE+Hvae9yGvjjR+v5esN+EqL8+eIP/Y+b5E5E7E896SIiIiIiZ5HZy5Xf9412uIAO8MTwrvi4u7Ahu9i2VvuplFTWUlVrOceVicjpaPqCjCIiIiIi4nBC/DyYcmUn/r5gC9O+38bQ7qEnHIpvGAYrdhUyZ2UGi7bl4+rkRFK7NgyIDWRAbBDxbc2NLgdnGAaZhZWkZhaxNrOI9VnFxEeamToyHncX53P5FkVaFQ13FxERERE5z9VZrIx4bQVbD5QyKjmSF29KsO2rrKnji/U5zFmRyc788pNew9fdhYs7BjIwNogBsYG0C/Rmy/7SI6H8EGv3FlFQXnPceZfEBTFrbDKebgrqIiej2d0boZAuIiIiIheitL1F3PjmKgA+/0M/Qnw9+HD1Xj5ek0VpVR0A3m7O3JQUybj+MQCs2FXAil2FrNxdYDvmKGcnExZrw6jg5uxEQpSZ5JgAIswePP9/2zhca6FPTADvjk8+bq14EamnkN4IhXQRERERuVA98tkG5q/dh7+XK6WHazmasdsFejGuXww3JUfid4IgbbEabN5fwvJdBazcVUhqZhHVdVbMnq4kt2tDckwAvWPa0KOtGQ/XX3vM12YWMeG9VMqq60iINPP+HX3w93Jrcr2GYVBjsWIYYDUMrEf+NKxHfzZwcXLSGvBy3lNIb4RCuoiIiIhcqArLq7li+lJKDtcC9UPRx/eP4fLOITg3Y9b3qloLB8uqaevvecrZ4jfllDD23RQOVdbSJcyXD+/sS7Bv48vTVdVa+CQ1m7eW7mZ/SdUp6+ka7sc1PcIYFh9GbIhvk9+HiKNQSG+EQrqIiIiIXMjWZhaxbMdBRiREEBfaMoF2R14ZY95J4WBZNR2CvJl7d1/CzcfPhH80nL+xZBd5pdWnda+4EB+GxYdzTXwYnUN9MZnOfMm57KJKDlXW0DPS/4yvJXIiCumNUEgXERERETn7MgsqGPNOCjnFh4ls48ncu/rSLtAbqA/nH6/J4s2lu23hPMLswf2DYhnRMwIXZxNOJhMmEziZTDgd+dNkguLKWhZuzeO7jQdYvquAWsuv8aVDkDfD4sO4IbHtafew/29zLn/8eD1VtVYeuCKWh4Z0ssta84cqapi3Jou9hRX8eWiXU45GkPOLQnojFNJFRERERM6NnOLDjHl7NZmFlYT6ufPuuN6szSw6LpxPvCKWm5Iim710W8nhWhZtzeP/NuaybOdBauqsALg4mXjk6s7cNbBDswL2nBUZ/G3BFo5NREO7hzJj1EV4u7fMatW78suZvSKD/67bR1Vt/fuJC/Hho3suJugES+nJ+UkhvREK6SIiIiIi505+aRW3vZvCjryGy72dSTg/kbKqWn7als9nafv4eWcBAFd0CWH6zQm08W588jqL1eC5b7cye0UGALf2iSYxyp8nvtxEjcVK13A/3hmXTFv/44fsnw2GYbB8VwHvLs9gyfaDtu3dI/woLK8ht7RKQf0Co5DeCIV0EREREZFz61BFDbfPXsPGnBJbOL85KQo3F6ezfi/DMJibksXfF2yhps5KuNmDV25NpHdMwAmPP1xjYfIn6/lhcx4Af7m6C/dd1gGTyUTa3iLu/TCNgvIagnzceGtsEkntTnyd01FVa+Gr9BxmL89ke14ZACYTDOkayp0D29O3fQCZhZXcOmu1gvoFRiG9EQrpIiIiIiLnXlWthfVZxSS1a3NOwvlvbdlfyqR569hTUIGzk4kpV3biD5d1bDD8vaC8mrveX0t6djFuzk78a1QCv0uIaHCdfYcqufuDNLYeKMXN2YmpI+O5MSnyjGorr67jw1V7eXf5HgrKawDwcnNmVHIU4/vHEBPk3eD4jIKKVh/U6yxWvt14gO825nJjUiRXdgu1d0lnRCG9EQrpIiIiIiIXpvLqOp74YiNfpu8H4NJOwcwYlUCQjzu7D5Yz4b1UsooqMXu68vbtyfRpf+Je8orqOqbMT7f1tt97WQceGdqlWcvYQf0z9HNWZDJ7RYZtWby2/p6M69+O0b2jMXuefP33Y4N6p1Af5t3dOoJ6ZU0dn6Rm887PGeQUH7Ztf3BwHA8OjrPLpH5ng0J6IxTSRUREREQuXIZh8OnafTz19Saqaq2E+LozcVAs//5xB8WVtUQFeDJnQh86Bvs0eh2r1eDfP+7g1Z92ATC4SwhPXNuNdgFepwyKRRU1zF6ewfsrMymrrgPqZ6KfOCiW310Ugatz00YWZBRUcMusVeSVVjtUUC+tquXnHQV4uDpxaafgJr+fxhSUV/PBykw+WL2X4sr6LzQCvd3o1a4NC7fUf1lyZbdQZoxKwNfj5F9uOCqF9EYopIuIiIiIXPi255Yxcd46duX/OoFdQpQ/745LblbQ/So9hz9/9ottJnlPV2fiQn3oHOpL57BfX8E+7hSU1/DOz3v4cPVeKmssAHQK9WHSFXEMjw9vdk88OE5QP1RRY1sKb8WuQmos9Z9HsK87o5OjGN07iqgAr2ZfN7OggneW7+HTtfuoPvIZtwv04u5LOnBTUiQers7MX5vNE1/UT+oXG+LD27cn0/43jwg4OoX0Riiki4iIiIi0DpU1dTz11WY+S9vH1d3D+Pfoi/B0a/7M8unZxfxjwRY25ZTYguRvtfFypbLGYtvfPcKPB66I46puoWc8RPu3QX3qyJ5YDYOqWguHayxU1VmpqrXYXi5OTlzZLfS0QvOx8suq+N/mPL7flMuqPYVYrMesUR/sTenhOgrK65fWM5ng0rhgxvSN5oouIbicpHc9v6yKX7JL2LCvmPVZxazcXcDRyyZEmrn3so4M7R523Bca67MOcd9/0sgrrcbPw4VXbk3k8s4hZ/T+WpJCeiMU0kVEREREWpdDFTX4e7liMp1ZWLZYDfYWVrA9t4xtuWXsyCtje24ZmYUVtqB5UZQ/fxwcy6DOIWd8v2MdG9Sbqk/7AG7s1ZZr4sObNETcMAy2HCjl550F/LQ1n9S9RQ3WkO8a7sewHmEM6xFGXKgvNXVWFm7JY96avazYVWg7LtSvvnf9usS25JdWs2FfMRuyi/llX0mD58yPGtQ5mHsu7cjFHQIa/czyS6u47z9prMsqxskEj1zdhXsv7XBWP+dzRSG9EQrpIiIiIiJyNlXVWmzD6rtH+J2z0JhRUMGf5qezv7gKTzdn3F2c8HB1xtPVGQ/XX/+eV1bFyt2FtoDt4erE0O5h3NgrkgGxQQ16qQvKq/l550F+3lHAsp0Ftp7xoxIizQyLD+fq7mHHzUJ/rMyCCj5KzeKztfsorKg56XEmE8SF+JAQ6U/PKH/6dQgkNqTx+QGOVV1n4emvNvNxajYAv0uIYNqNPU9rhERLUkhvhEK6iIiIiIhc6A6UHOaL9Tl8nraP3QcrbNtD/dy5PrEtJkz8vPMgm/eXNjjP09WZfh0DuTQuiCu7h9HW37NZ962us/C/zXnMS8li1Z5C2vp7khBlrg/lkf7ER5rxcXc5o/dmGAb/Wb2Xv32zhTqrQbdwP2bdnkRkmzMb3n8uKaQ3QiFdRERERERaC8Mw+GVfCZ+v28fXG/bbZk4/VvcIPy6JC+bSTkEktWuDu8vZ6ZWus1hP+mz62ZCyp5D7566j5HAtc+/qS98OgefsXmdKIb0RCukiIiIiItIaVddZWLwtn2835uLqZOKSTkEMjA0m2Nf+y7qdrpziw6RnFTO8Z7i9S2mUQnojFNJFRERERESkJTUnh567sQciIiIiIiIi0iwK6SIiIiIiIiIOQiFdRERERERExEHYNaQvW7aMESNGEBERgclk4ssvvzzlOUuWLKFXr164u7sTGxvLnDlzznmdIiIiIiIiIi3BriG9oqKChIQEXn/99SYdn5GRwfDhwxk0aBDp6elMnjyZu+66ix9++OEcVyoiIiIiIiJy7p3ZKvJnaNiwYQwbNqzJx8+cOZP27dszffp0ALp27cry5cv597//zdChQ89VmSIiIiIiIiIt4rx6Jn3VqlUMGTKkwbahQ4eyatWqk55TXV1NaWlpg5eIiIiIiIiIIzqvQnpubi6hoaENtoWGhlJaWsrhw4dPeM7UqVMxm822V1RUVEuUKiIiIiIiItJs51VIPx2PPfYYJSUltld2dra9SxIRERERERE5Ibs+k95cYWFh5OXlNdiWl5eHn58fnp6eJzzH3d0dd3f3lihPRERERERE5IycVz3p/fr1Y9GiRQ22LVy4kH79+tmpIhEREREREZGzx64hvby8nPT0dNLT04H6JdbS09PJysoC6oeq33777bbj77vvPvbs2cMjjzzCtm3beOONN5g/fz4PPfSQPcoXEREREREROavsGtLXrl1LYmIiiYmJAEyZMoXExESeeuopAA4cOGAL7ADt27fn22+/ZeHChSQkJDB9+nTeeecdLb8mIiIiIiIiFwSTYRiGvYtoSaWlpZjNZkpKSvDz87N3OSIiIiIiInKBa04OPa+eSRcRERERERG5kCmki4iIiIiIiDgIhXQRERERERERB6GQLiIiIiIiIuIgXOxdQEs7Ok9eaWmpnSsRERERERGR1uBo/mzKvO2tLqSXlZUBEBUVZedKREREREREpDUpKyvDbDY3ekyrW4LNarWyf/9+fH19MZlM9i6nUaWlpURFRZGdna3l4sRhqZ3K+UJtVc4XaqtyvlBblfOFI7RVwzAoKysjIiICJ6fGnzpvdT3pTk5OREZG2ruMZvHz89M/fOLw1E7lfKG2KucLtVU5X6ityvnC3m31VD3oR2niOBEREREREREHoZAuIiIiIiIi4iAU0h2Yu7s7Tz/9NO7u7vYuReSk1E7lfKG2KucLtVU5X6ityvnifGurrW7iOBERERERERFHpZ50EREREREREQehkC4iIiIiIiLiIBTSRURERERERByEQrqIiIiIiIiIg1BId1Cvv/46MTExeHh40LdvX9asWWPvkqSVmzp1Kr1798bX15eQkBCuv/56tm/f3uCYqqoqJk6cSGBgID4+Ptx4443k5eXZqWIReOGFFzCZTEyePNm2Te1UHEVOTg633XYbgYGBeHp6Eh8fz9q1a237DcPgqaeeIjw8HE9PT4YMGcLOnTvtWLG0RhaLhSeffJL27dvj6elJx44d+cc//sGxc0+rrYo9LFu2jBEjRhAREYHJZOLLL79ssL8p7bKoqIgxY8bg5+eHv78/d955J+Xl5S34Lk5MId0BffLJJ0yZMoWnn36adevWkZCQwNChQ8nPz7d3adKKLV26lIkTJ7J69WoWLlxIbW0tV111FRUVFbZjHnroIb755hs+/fRTli5dyv79+xk5cqQdq5bWLDU1lbfeeouePXs22K52Ko7g0KFDDBgwAFdXV7777ju2bNnC9OnTadOmje2YF198kVdeeYWZM2eSkpKCt7c3Q4cOpaqqyo6VS2szbdo03nzzTV577TW2bt3KtGnTePHFF3n11Vdtx6itij1UVFSQkJDA66+/fsL9TWmXY8aMYfPmzSxcuJAFCxawbNky7rnnnpZ6CydniMPp06ePMXHiRNvPFovFiIiIMKZOnWrHqkQays/PNwBj6dKlhmEYRnFxseHq6mp8+umntmO2bt1qAMaqVavsVaa0UmVlZUZcXJyxcOFC47LLLjMefPBBwzDUTsVx/OUvfzEGDhx40v1Wq9UICwsz/vnPf9q2FRcXG+7u7sZHH33UEiWKGIZhGMOHDzfuuOOOBttGjhxpjBkzxjAMtVVxDIDxxRdf2H5uSrvcsmWLARipqam2Y7777jvDZDIZOTk5LVb7iagn3cHU1NSQlpbGkCFDbNucnJwYMmQIq1atsmNlIg2VlJQAEBAQAEBaWhq1tbUN2m6XLl2Ijo5W25UWN3HiRIYPH96gPYLaqTiOr7/+muTkZG6++WZCQkJITEzk7bfftu3PyMggNze3QVs1m8307dtXbVVaVP/+/Vm0aBE7duwAYMOGDSxfvpxhw4YBaqvimJrSLletWoW/vz/Jycm2Y4YMGYKTkxMpKSktXvOxXOx6dzlOQUEBFouF0NDQBttDQ0PZtm2bnaoSachqtTJ58mQGDBhAjx49AMjNzcXNzQ1/f/8Gx4aGhpKbm2uHKqW1+vjjj1m3bh2pqanH7VM7FUexZ88e3nzzTaZMmcJf//pXUlNT+eMf/4ibmxvjxo2ztccT/T6gtiot6dFHH6W0tJQuXbrg7OyMxWLhueeeY8yYMQBqq+KQmtIuc3NzCQkJabDfxcWFgIAAu7ddhXQRabaJEyeyadMmli9fbu9SRBrIzs7mwQcfZOHChXh4eNi7HJGTslqtJCcn8/zzzwOQmJjIpk2bmDlzJuPGjbNzdSK/mj9/PnPnzmXevHl0796d9PR0Jk+eTEREhNqqyDmi4e4OJigoCGdn5+NmGs7LyyMsLMxOVYn8atKkSSxYsIDFixcTGRlp2x4WFkZNTQ3FxcUNjlfblZaUlpZGfn4+vXr1wsXFBRcXF5YuXcorr7yCi4sLoaGhaqfiEMLDw+nWrVuDbV27diUrKwvA1h71+4DY25///GceffRRbrnlFuLj4xk7diwPPfQQU6dOBdRWxTE1pV2GhYUdNzF3XV0dRUVFdm+7CukOxs3NjaSkJBYtWmTbZrVaWbRoEf369bNjZdLaGYbBpEmT+OKLL/jpp59o3759g/1JSUm4uro2aLvbt28nKytLbVdazODBg9m4cSPp6em2V3JyMmPGjLH9Xe1UHMGAAQOOW8Zyx44dtGvXDoD27dsTFhbWoK2WlpaSkpKitiotqrKyEienhpHB2dkZq9UKqK2KY2pKu+zXrx/FxcWkpaXZjvnpp5+wWq307du3xWs+loa7O6ApU6Ywbtw4kpOT6dOnDy+99BIVFRVMmDDB3qVJKzZx4kTmzZvHV199ha+vr+1ZHbPZjKenJ2azmTvvvJMpU6YQEBCAn58fDzzwAP369ePiiy+2c/XSWvj6+trmSTjK29ubwMBA23a1U3EEDz30EP379+f5559n1KhRrFmzhlmzZjFr1iwATCYTkydP5tlnnyUuLo727dvz5JNPEhERwfXXX2/f4qVVGTFiBM899xzR0dF0796d9evXM2PGDO644w5AbVXsp7y8nF27dtl+zsjIID09nYCAAKKjo0/ZLrt27crVV1/N3XffzcyZM6mtrWXSpEnccsstRERE2OldHWHXueXlpF599VUjOjracHNzM/r06WOsXr3a3iVJKwec8PXee+/Zjjl8+LBx//33G23atDG8vLyMG264wThw4ID9ihYxjAZLsBmG2qk4jm+++cbo0aOH4e7ubnTp0sWYNWtWg/1Wq9V48sknjdDQUMPd3d0YPHiwsX37djtVK61VaWmp8eCDDxrR0dGGh4eH0aFDB+Pxxx83qqurbceorYo9LF68+IS/m44bN84wjKa1y8LCQuPWW281fHx8DD8/P2PChAlGWVmZHd5NQybDMAw7fT8gIiIiIiIiIsfQM+kiIiIiIiIiDkIhXURERERERMRBKKSLiIiIiIiIOAiFdBEREREREREHoZAuIiIiIiIi4iAU0kVEREREREQchEK6iIiIiIiIiINQSBcRERERERFxEArpIiIiclbFxMTw0ksv2bsMERGR85JCuoiIyHls/PjxXH/99QBcfvnlTJ48ucXuPWfOHPz9/Y/bnpqayj333NNidYiIiFxIXOxdgIiIiDiWmpoa3NzcTvv84ODgs1iNiIhI66KedBERkQvA+PHjWbp0KS+//DImkwmTyURmZiYAmzZtYtiwYfj4+BAaGsrYsWMpKCiwnXv55ZczadIkJk+eTFBQEEOHDgVgxowZxMfH4+3tTVRUFPfffz/l5eUALFmyhAkTJlBSUmK73zPPPAMcP9w9KyuL6667Dh8fH/z8/Bg1ahR5eXm2/c888wwXXXQRH374ITExMZjNZm655RbKysrO7YcmIiLigBTSRURELgAvv/wy/fr14+677+bAgQMcOHCAqKgoiouLueKKK0hMTGTt2rV8//335OXlMWrUqAbnv//++7i5ubFixQpmzpwJgJOTE6+88gqbN2/m/fff56effuKRRx4BoH///rz00kv4+fnZ7vfwww8fV5fVauW6666jqKiIpUuXsnDhQvbs2cPo0aMbHLd7926+/PJLFixYwIIFC1i6dCkvvPDCOfq0REREHJeGu4uIiFwAzGYzbm5ueHl5ERYWZtv+2muvkZiYyPPPP2/bNnv2bKKiotixYwedOnUCIC4ujhdffLHBNY99vj0mJoZnn32W++67jzfeeAM3NzfMZjMmk6nB/X5r0aJFbNy4kYyMDKKiogD44IMP6N69O6mpqfTu3RuoD/Nz5szB19cXgLFjx7Jo0SKee+65M/tgREREzjPqSRcREbmAbdiwgcWLF+Pj42N7denSBajvvT4qKSnpuHN//PFHBg8eTNu2bfH19WXs2LEUFhZSWVnZ5Ptv3bqVqKgoW0AH6NatG/7+/mzdutW2LSYmxhbQAcLDw8nPz2/WexUREbkQqCddRETkAlZeXs6IESOYNm3acfvCw8Ntf/f29m6wLzMzk2uvvZY//OEPPPfccwQEBLB8+XLuvPNOampq8PLyOqt1urq6NvjZZDJhtVrP6j1ERETOBwrpIiIiFwg3NzcsFkuDbb169eLzzz8nJiYGF5em/7eflpaG1Wpl+vTpODnVD7ybP3/+Ke/3W127diU7O5vs7Gxbb/qWLVsoLi6mW7duTa5HRESktdBwdxERkQtETEwMKSkpZGZmUlBQgNVqZeLEiRQVFXHrrbeSmprK7t27+eGHH5gwYUKjATs2Npba2lpeffVV9uzZw4cffmibUO7Y+5WXl7No0SIKCgpOOAx+yJAhxMfHM2bMGNatW8eaNWu4/fbbueyyy0hOTj7rn4GIiMj5TiFdRETkAvHwww/j7OxMt27dCA4OJisri4iICFasWIHFYuGqq64iPj6eyZMn4+/vb+shP5GEhARmzJjBtGnT6NGjB3PnzmXq1KkNjunfvz/33Xcfo0ePJjg4+LiJ56B+2PpXX31FmzZtuPTSSxkyZAgdOnTgk08+OevvX0RE5EJgMgzDsHcRIiIiIiIiIqKedBERERERERGHoZAuIiIiIiIi4iAU0kVEREREREQchEK6iIiIiIiIiINQSBcRERERERFxEArpIiIiIiIiIg5CIV1ERERERETEQSiki4iIiIiIiDgIhXQRERERERERB6GQLiIiIiIiIuIgFNJFREREREREHMT/Aw6HLnuy6QeDAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -504,7 +498,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training time: 72 seconds\n" + "Training time: 303 seconds\n" ] } ], @@ -513,10 +507,10 @@ "from qiskit_machine_learning.algorithms.classifiers import VQC\n", "\n", "vqc = VQC(\n", + " sampler=sampler,\n", " feature_map=feature_map,\n", " ansatz=ansatz,\n", " optimizer=optimizer,\n", - " quantum_instance=quantum_instance,\n", " callback=callback_graph,\n", ")\n", "\n", @@ -540,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "formed-mineral", "metadata": {}, "outputs": [ @@ -548,8 +542,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Quantum VQC on the training dataset: 0.82\n", - "Quantum VQC on the test dataset: 0.83\n" + "Quantum VQC on the training dataset: 0.85\n", + "Quantum VQC on the test dataset: 0.87\n" ] } ], @@ -587,7 +581,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "painted-montreal", "metadata": {}, "outputs": [ @@ -597,13 +591,13 @@ "" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -631,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "naval-agriculture", "metadata": {}, "outputs": [ @@ -668,7 +662,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "electric-novel", "metadata": {}, "outputs": [], @@ -689,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "younger-louisiana", "metadata": {}, "outputs": [], @@ -707,13 +701,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "varied-capital", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+kAAAIjCAYAAAB/OVoZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACVn0lEQVR4nOzdd3iUVfrG8XvSe0+AQEhCaNIRQelgQUBRxK4rYncXFLuyVmzY1sKuvQAWBMX2s4EovYl06TWEFiAJ6X3m/f2RzEBIIQMzmUny/VxXLsk7b3kyCeqdc85zTIZhGAIAAAAAAC7n4eoCAAAAAABAGUI6AAAAAABugpAOAAAAAICbIKQDAAAAAOAmCOkAAAAAALgJQjoAAAAAAG6CkA4AAAAAgJsgpAMAAAAA4CYI6QAAAAAAuAlCOgDUU88884xMJpPS0tJOeW5CQoLGjBnj/KJOMnXqVJlMJiUnJ9f5s//66y/16dNHgYGBMplMWrduXZ3XUBuu+t44miu/165kMpn0zDPPuLoMSfXze2D99xgA4DhCOgC4kU2bNukf//iHmjdvLl9fX8XGxurGG2/Upk2bXF1ajV588UV9//33ri7DpqSkRFdffbUyMjL0xhtv6LPPPlN8fLzL6lm2bJmeeeYZZWZmuqwG1D8HDx7UM888c0a/YHrnnXc0depUh9V0OvLz8/XMM89owYIFLq0DAOoLk2EYhquLAABI3377ra6//npFRETotttuU2JiopKTk/Xxxx8rPT1dM2bM0BVXXGE7/5lnntHEiRN19OhRRUVF1XjvoqIieXh4yNvb2ym1BwUF6aqrrqoUBsxms0pKSuTr61uno2Vbt27VWWedpQ8//FC33357nT23Oq+99poefvhh7dmzRwkJCRVec/b3pq5MnTpVt9xyS5VfY0NWWFgoLy8veXl5Ofzeq1atUs+ePTVlypRazbao6u9bp06dFBUV5dKAnJaWpujoaD399NOVZh2UlpaqtLRUfn5+rikOANyQ4/+LAgCw265du3TTTTepVatWWrRokaKjo22vjR8/Xv3799dNN92kDRs2qFWrVnbf39fX15Hl1pqnp6c8PT3r/LlHjhyRJIWFhdX5s+3lqu8NHMOdwmVd/X0rLS2VxWKRj4/PGd/LWb/gAID6jOnuAOAGXn31VeXn5+uDDz6oENAlKSoqSu+//77y8vL0yiuvVLo2LS1N11xzjUJCQhQZGanx48ersLCwwjlVrXvOzMzUfffdp7i4OPn6+qp169Z6+eWXZbFYKpxnsVj01ltvqXPnzvLz81N0dLSGDh2qVatWSSpbk5uXl6dp06bJZDLJZDLZnnXyGtlLL7202l8y9O7dW+ecc06FY59//rl69Oghf39/RURE6LrrrtO+fftqfC/HjBmjgQMHSpKuvvpqmUwmDRo0SJI0aNAg259PvubE0d/k5GSZTCa99tpr+uCDD5SUlCRfX1/17NlTf/31V6Xrt27dqmuuuUbR0dHy9/dXu3bt9Pjjj0sqm/Hw8MMPS5ISExNt75H1Panqe7N7925dffXVioiIUEBAgM477zz9/PPPFc5ZsGCBTCaTvvrqK73wwgtq0aKF/Pz8dMEFF2jnzp01vkezZs2SyWTSwoULK732/vvvy2QyaePGjZKkDRs2aMyYMWrVqpX8/PzUtGlT3XrrrUpPT6/xGVL167XP5OexKj/88IMuueQSxcbGytfXV0lJSXruuedkNpsrnfv222+rVatW8vf3V69evbR48eJKPxfFxcV66qmn1KNHD4WGhiowMFD9+/fX/PnzT/k1WtdY79y5U2PGjFFYWJhCQ0N1yy23KD8/v8K1c+fOVb9+/RQWFqagoCC1a9dO//73vyWVfX979uwpSbrllltsPzc1TV0/+e9bQkKCNm3apIULF9quP/HrrM17fuLfhTfffNP2d2Hz5s21ep+Sk5Nt/06bOHGirQ7re1bVmvTS0lI999xztmclJCTo3//+t4qKiiqcl5CQoEsvvVRLlixRr1695Ofnp1atWunTTz+t9j0CgPqAX10CgBv48ccflZCQoP79+1f5+oABA5SQkFApqEnSNddco4SEBE2aNEkrVqzQ5MmTdezYsRr/RzU/P18DBw7UgQMHdNddd6lly5ZatmyZJkyYoEOHDunNN9+0nXvbbbdp6tSpGjZsmG6//XaVlpZq8eLFWrFihc455xx99tlnuv3229WrVy/deeedkqSkpKQqn3vttddq9OjR+uuvv2wBRJL27t2rFStW6NVXX7Ude+GFF/Tkk0/qmmuu0e23366jR4/qv//9rwYMGKC1a9dWO0p+1113qXnz5nrxxRd17733qmfPnmrSpEm170VNpk+frpycHN11110ymUx65ZVXNGrUKO3evds2PX3Dhg3q37+/vL29deeddyohIUG7du3Sjz/+qBdeeEGjRo3S9u3b9eWXX+qNN96wLU04+ZcxVocPH1afPn2Un5+ve++9V5GRkZo2bZouu+wyzZo1q8KSB0l66aWX5OHhoYceekhZWVl65ZVXdOONN+rPP/+s9uu65JJLFBQUpK+++sr2Cw2rmTNnqmPHjurUqZOksiC5e/du3XLLLWratKk2bdqkDz74QJs2bdKKFSscsozBnp/HqkydOlVBQUF64IEHFBQUpHnz5umpp55SdnZ2hZ+pd999V+PGjVP//v11//33Kzk5WSNHjlR4eLhatGhhOy87O1sfffSRrr/+et1xxx3KycnRxx9/rIsvvlgrV65Ut27dTvk1XXPNNUpMTNSkSZO0Zs0affTRR4qJidHLL78sqaz/xKWXXqouXbro2Wefla+vr3bu3KmlS5dKks466yw9++yzeuqpp3TnnXfa/t3Qp0+fWr+vb775pu655x4FBQXZfmlk/btg73s+ZcoUFRYW6s4775Svr68iIiJq9T5FR0fr3Xff1T//+U9dccUVGjVqlCSpS5cu1dZ9++23a9q0abrqqqv04IMP6s8//9SkSZO0ZcsWfffddxXO3blzp6666irddtttuvnmm/XJJ59ozJgx6tGjhzp27Fjr9woA3IoBAHCpzMxMQ5Jx+eWX13jeZZddZkgysrOzDcMwjKefftqQZFx22WUVzvvXv/5lSDLWr19vOxYfH2/cfPPNts+fe+45IzAw0Ni+fXuFax977DHD09PTSElJMQzDMObNm2dIMu69995K9VgsFtufAwMDK9zfasqUKYYkY8+ePYZhGEZWVpbh6+trPPjggxXOe+WVVwyTyWTs3bvXMAzDSE5ONjw9PY0XXnihwnl///234eXlVen4yebPn29IMr7++usKxwcOHGgMHDiw0vk333yzER8fb/t8z549hiQjMjLSyMjIsB3/4YcfDEnGjz/+aDs2YMAAIzg42Fa71Ynvz6uvvlrhfTjRyd+b++67z5BkLF682HYsJyfHSExMNBISEgyz2VzhazzrrLOMoqIi27lvvfWWIcn4+++/q35zyl1//fVGTEyMUVpaajt26NAhw8PDw3j22Wdtx/Lz8ytd++WXXxqSjEWLFtmOnfy9NgzDkGQ8/fTTp/yaa/vzWJ2qarzrrruMgIAAo7Cw0DAMwygqKjIiIyONnj17GiUlJbbzpk6dakiq8HNRWlpa4T01DMM4duyY0aRJE+PWW2+tcPzkr9H69/Lk86644gojMjLS9vkbb7xhSDKOHj1a7df1119/GZKMKVOmVHvOiar6HnTs2LHKn/navufWvwshISHGkSNHKpxb2/fp6NGj1f4sWN8vq3Xr1hmSjNtvv73CeQ899JAhyZg3b57tWHx8fKWfwyNHjlT57xgAqE+Y7g4ALpaTkyNJCg4OrvE86+vZ2dkVjo8dO7bC5/fcc48k6Zdffqn2Xl9//bX69++v8PBwpaWl2T4uvPBCmc1mLVq0SJL0zTffyGQy6emnn650j9MZQQ0JCdGwYcP01VdfyTihb+nMmTN13nnnqWXLlpLKmuhZLBZdc801Fepr2rSp2rRpU+W0Y2e49tprFR4ebvvcOpq5e/duSdLRo0e1aNEi3XrrrbbarU53hPmXX35Rr1691K9fP9uxoKAg3XnnnUpOTtbmzZsrnH/LLbdUWBt8co3Vufbaa3XkyJEKDcVmzZoli8Wia6+91nbM39/f9ufCwkKlpaXpvPPOkyStWbPG/i+wCrX9eazOiTXm5OQoLS1N/fv3V35+vrZu3SqprAlbenq67rjjjgproG+88cYK32OpbG239T21WCzKyMhQaWmpzjnnnFp/zXfffXeFz/v376/09HTb31/rTJAffvihVlP6Hc3e9/zKK6+sNPvDEe/Tyaz/3nrggQcqHH/wwQclqdJsog4dOlSYgRQdHa127dqd8ucfANwZ090BwMWs4dsa1qtTXZhv06ZNhc+TkpLk4eFR417JO3bs0IYNG6qdcm1tvLZr1y7FxsYqIiKixtrsce211+r777/X8uXL1adPH+3atUurV6+uML12x44dMgyj0tdmVVed0E8O3tYwd+zYMUnHg7B1argj7N27V+eee26l42eddZbt9ROfd6oaqzN06FCFhoZq5syZuuCCCySV/bKkW7duatu2re28jIwMTZw4UTNmzLD9XFhlZWXZ8ZVVr7Y/j9XZtGmTnnjiCc2bN6/SL7GsNe7du1eS1Lp16wqve3l5VdmNftq0afrPf/6jrVu3qqSkxHY8MTHxlF+PVPP3JSQkRNdee60++ugj3X777Xrsscd0wQUXaNSoUbrqqqvk4eH8MRR73/Pqvu4zfZ9OtnfvXnl4eFT6PjVt2lRhYWG276PVye+zVPZen+rnHwDcGSEdAFwsNDRUzZo104YNG2o8b8OGDWrevLlCQkJqPK82I7gWi0UXXXSRHnnkkSpfPzGkOdqIESMUEBCgr776Sn369NFXX30lDw8PXX311RXqM5lM+vXXX6vsVh0UFHRazzaZTBVG8K2qajAmqdpO2VXdw1VOt0ZfX1+NHDlS3333nd555x0dPnxYS5cu1YsvvljhvGuuuUbLli3Tww8/rG7duikoKEgWi0VDhw497RHgk9/vM/l5zMzM1MCBAxUSEqJnn31WSUlJ8vPz05o1a/Too4+eVo2ff/65xowZo5EjR+rhhx9WTEyMPD09NWnSJO3atatW9zjV98Xf31+LFi3S/Pnz9fPPP2v27NmaOXOmzj//fP32229O79Ju73t+4mwFK0e8T9Wp7UyU+vB3FADsRUgHADdw6aWX6sMPP9SSJUsqTHO2Wrx4sZKTk3XXXXdVem3Hjh0VRq127twpi8VS417VSUlJys3N1YUXXlhjXUlJSZozZ44yMjJqHE23Z2p3YGCgLr30Un399dd6/fXXNXPmTPXv31+xsbEVnmsYhhITEx36C4Pw8PAqp8GePDpXW9ZO9dZO6NWx5/2Jj4/Xtm3bKh23TtuOj4+3o8KaXXvttZo2bZr++OMPbdmyRYZhVJjqfuzYMf3xxx+aOHGinnrqKdvxHTt21Or+4eHhyszMrHCsuLhYhw4dqnCstj+PVVmwYIHS09P17bffasCAAbbje/bsqXCe9X3buXOnBg8ebDteWlqq5OTkCo3MZs2apVatWunbb7+t8L2ratnHmfDw8NAFF1ygCy64QK+//rpefPFFPf7445o/f74uvPBChzTlq+4eZ/KeW9X2fbL3599isWjHjh222SNSWUPFzMxMh/78A4C7Yk06ALiBhx9+WP7+/rrrrrsqbW2VkZGhu+++WwEBAbatvE709ttvV/j8v//9ryRp2LBh1T7vmmuu0fLlyzVnzpxKr2VmZqq0tFRS2TpUwzA0ceLESuedOFIVGBhYKYzV5Nprr9XBgwf10Ucfaf369RWCoSSNGjVKnp6emjhxYqURMcMwarX9V1WSkpK0detWHT161HZs/fr1to7a9oqOjtaAAQP0ySefKCUlpVKdVoGBgZJUq/do+PDhWrlypZYvX247lpeXpw8++EAJCQnq0KHDadValQsvvFARERGaOXOmZs6cqV69elX4hY91lPLk78Gpuq1bJSUlVVrb/MEHH1QaSa/tz2NVqqqxuLhY77zzToXzzjnnHEVGRurDDz+scL8vvvii0tToqu75559/VvienKmMjIxKx6xd461bjdnzc1Od6v5unsl7blXb9ykgIMB231MZPny4pMo/Y6+//rqksp0JAKChYyQdANxAmzZtNG3aNN14443q3LmzbrvtNiUmJio5OVkff/yx0tLS9OWXX1a5tdmePXt02WWXaejQoVq+fLk+//xz3XDDDeratWu1z3v44Yf1f//3f7r00ktt2xXl5eXp77//1qxZs5ScnKyoqCgNHjxYN910kyZPnqwdO3bYpjgvXrxYgwcP1rhx4yRJPXr00O+//67XX39dsbGxSkxMrHJdtdXw4cMVHByshx56SJ6enrryyisrvJ6UlKTnn39eEyZMsG2TFRwcrD179ui7777TnXfeqYceesju9/nWW2/V66+/rosvvli33Xabjhw5ovfee08dO3astJa5tiZPnqx+/frp7LPP1p133mn7vv38889at26dpLL3R5Ief/xxXXfddfL29taIESNsIexEjz32mL788ksNGzZM9957ryIiIjRt2jTt2bNH33zzjUPXK3t7e2vUqFGaMWOG8vLy9Nprr1V4PSQkRAMGDNArr7yikpISNW/eXL/99lulUerq3H777br77rt15ZVX6qKLLtL69es1Z84c2zZ0VrX9eaxKnz59FB4erptvvln33nuvTCaTPvvss0q/WPDx8dEzzzyje+65R+eff76uueYaJScna+rUqUpKSqow2nvppZfq22+/1RVXXKFLLrlEe/bs0XvvvacOHTooNze3Vl/7qTz77LNatGiRLrnkEsXHx+vIkSN655131KJFC9tsmqSkJIWFhem9995TcHCwAgMDde6559q13rtHjx5699139fzzz6t169aKiYnR+eeff0bvuVVt3yd/f3916NBBM2fOVNu2bRUREaFOnTpV2cuha9euuvnmm/XBBx/YljKsXLlS06ZN08iRIyvMggCABquOu8kDAGqwYcMG4/rrrzeaNWtmeHt7G02bNjWuv/76KrfTsm5dtHnzZuOqq64ygoODjfDwcGPcuHFGQUFBhXNP3vLKMMq29ZowYYLRunVrw8fHx4iKijL69OljvPbaa0ZxcbHtvNLSUuPVV1812rdvb/j4+BjR0dHGsGHDjNWrV9vO2bp1qzFgwADD39/fkGR7VlVbQlndeOONhiTjwgsvrPb9+Oabb4x+/foZgYGBRmBgoNG+fXtj7NixxrZt22p8H6vbgs0wDOPzzz83WrVqZfj4+BjdunUz5syZU+0WbK+++mql61XFVlIbN240rrjiCiMsLMzw8/Mz2rVrZzz55JMVznnuueeM5s2bGx4eHhXek6q+N7t27TKuuuoq2/169epl/PTTT7X6Gq2113bbrrlz5xqSDJPJZOzbt6/S6/v377d9baGhocbVV19tHDx4sNL7UNX32mw2G48++qgRFRVlBAQEGBdffLGxc+fOM/p5rMrSpUuN8847z/D39zdiY2ONRx55xJgzZ44hyZg/f36FcydPnmzEx8cbvr6+Rq9evYylS5caPXr0MIYOHWo7x2KxGC+++KLtvO7duxs//fRTpZ8Tw6h+C7aTt1Y7+f35448/jMsvv9yIjY01fHx8jNjYWOP666+vtCXaDz/8YHTo0MHw8vI65fe1qu9BamqqcckllxjBwcGVtpqrzXte098Fe96nZcuWGT169DB8fHwqvGcnb8FmGIZRUlJiTJw40UhMTDS8vb2NuLg4Y8KECbbt9Kzi4+ONSy65pFJd1W21CAD1hckw6KwBAA1dXFycLr74Yn300UeuLgVwKxaLRdHR0Ro1apQ+/PBDV5cDAABr0gGgoSspKVF6evopp64CDV1hYWGlafCffvqpMjIyNGjQINcUBQDASViTDgAN2Jw5czRjxgwVFBTY9sIGGqsVK1bo/vvv19VXX63IyEitWbNGH3/8sTp16lRhC0AAAFyJkA4ADdhLL72knTt36oUXXtBFF13k6nIAl0pISFBcXJwmT55s21Zw9OjReumll+Tj4+Pq8gAAkCSxJh0AAAAAADfBmnQAAAAAANwEIR0AAAAAADfR6NakWywWHTx4UMHBwTKZTK4uBwAAAADQwBmGoZycHMXGxsrDo+ax8kYX0g8ePKi4uDhXlwEAAAAAaGT27dunFi1a1HhOowvpwcHBksrenJCQEBdXAwAAAABo6LKzsxUXF2fLozVxaUifNGmSvv32W23dulX+/v7q06ePXn75ZbVr167G69588029++67SklJUVRUlK666ipNmjRJfn5+p3ymdYp7SEgIIR0AAAAAUGdqs+TapY3jFi5cqLFjx2rFihWaO3euSkpKNGTIEOXl5VV7zfTp0/XYY4/p6aef1pYtW/Txxx9r5syZ+ve//12HlQMAAAAA4HguHUmfPXt2hc+nTp2qmJgYrV69WgMGDKjymmXLlqlv37664YYbJEkJCQm6/vrr9eeffzq9XgAAAAAAnMmttmDLysqSJEVERFR7Tp8+fbR69WqtXLlSkrR792798ssvGj58eJXnFxUVKTs7u8IHAAAAAADuyG0ax1ksFt13333q27evOnXqVO15N9xwg9LS0tSvXz8ZhqHS0lLdfffd1U53nzRpkiZOnOissgEAAAAAcBi3GUkfO3asNm7cqBkzZtR43oIFC/Tiiy/qnXfe0Zo1a/Ttt9/q559/1nPPPVfl+RMmTFBWVpbtY9++fc4oHwAAAACAM2YyDMNwdRHjxo3TDz/8oEWLFikxMbHGc/v376/zzjtPr776qu3Y559/rjvvvFO5ubmn3Bg+OztboaGhysrKors7AAAAAMDp7MmhLp3ubhiG7rnnHn333XdasGDBKQO6JOXn51cK4p6enrb7AQAAAABQX7k0pI8dO1bTp0/XDz/8oODgYKWmpkqSQkND5e/vL0kaPXq0mjdvrkmTJkmSRowYoddff13du3fXueeeq507d+rJJ5/UiBEjbGEdAAAAAID6yKUh/d1335UkDRo0qMLxKVOmaMyYMZKklJSUCiPnTzzxhEwmk5544gkdOHBA0dHRGjFihF544YW6KhsAAAAAAKdwizXpdYk16QAAAACAumRPDnWb7u4AAAAAADR2hHQAAAAAANwEIR0AAAAAADdBSAcAAAAAwE0Q0gEAAAAAcBOEdAAAAAAA3AQhvZEpLDHr7/1ZamQ77wEAAABAvUBIb2Qe/26jRvxviRbtSHN1KQAAAACAkxDSG5G8olL9tOGgJGnLoWwXVwMAAAAAOBkhvRGZt/WIikotkqSMvGIXVwMAAAAAOBkhvRH5ecMh25/TcwnpAAAAAOBuCOmNRF5RqeZvO2L7PCOvyIXVAAAAAACqQkhvJP44Yaq7JKUz3R0AAAAA3A4hvZH4ubxhXJ+kSElMdwcAAAAAd0RIbwRyi0o1f9tRSdLo3gmSaBwHAAAAAO6IkN4I/LHlsIpLLWoVFai+rctG0gtKzCooNru4MgAAAADAiQjpjYC1q/slXZopyNdLPp5l3/Z0mscBAAAAgFshpDdwOYUlWrC9bKr7JV2ayWQyKSLQRxJT3gEAAADA3RDSG7g/thwpm+oeHah2TYIlyRbS6fAOAAAAAO6FkN7A/fx32VT3SzuXjaJLUmRQ+Ug6Hd4BAAAAwK0Q0huwnMISLdxmneoeazvOdHcAAAAAcE+E9Abs9y2HVWy2KCk6UG2bBNmOM90dAAAAANwTIb0B+3lDqqSyUXTrVHdJirSG9Fy6uwMAAACAOyGkN1DZhSVaVN7V/dIuzSq8FhHoK4np7gAAAADgbgjpDdTvm8umureOCVLb8q7uVtbGcUx3BwAAAAD3QkhvoH4p7+p+SedmlV6LpHEcAAAAALglQnoDlFVQokXb0yRJl3SpHNLp7g4AAAAA7omQ3gBZp7q3qWKquyRFlq9Jzy0qVVGpua7LAwAAAABUg5DeANmmulcxii5JIf5e8vIo6/bOaDoAAAAAuA9CegOTVVCiRTvKurpXtR5dkkwmk8Jt27AR0gEAAADAXRDSG5i5mw+rxGyobZMgtaliqrsVzeMAAAAAwP0Q0huYnzcclCRd0jm2xvNoHgcAAAAA7oeQ3oBk5ZdoyU5rV/emNZ5rDenslQ4AAAAA7oOQ3oD8tjlVJWZD7ZoEq3VM9VPdpePT3dNzi+qiNAAAAABALRDSG5CfT9HV/USRQWXbsDHdHQAAAADcByG9gcjKL9GSHWVT3YdX09X9REx3BwAAAAD3Q0hvIOZsTlWpxVD7psFqHRN0yvPp7g4AAAAA7oeQ3kD8vKF8qnstRtElursDAAAAgDsipDcAmfnFWlre1X14LdajS1JkEI3jAAAAAMDdENIbgN82HVapxdBZzUKUFH3qqe6SFBFY1jguu7BUJWaLM8sDAAAAANQSIb0B+Mna1b1zzXujnyjM31seprI/H2PKOwAAAAC4BUJ6PXcsr1jLdta+q7uVh4dJ4QF0eAcAAAAAd0JIr+d+K+/q3qFZiFrVcqq7Fc3jAAAAAMC9ENLruZ+sXd1r2TDuRNaQnkbzOAAAAABwC4T0euxYXrGW7UqXZN9Udytrh3dG0gEAAADAPRDS67E5m1JlthjqGBuixKhAu6+PLO/wTkgHAAAAAPfg0pA+adIk9ezZU8HBwYqJidHIkSO1bdu2U16XmZmpsWPHqlmzZvL19VXbtm31yy+/1EHF7uXn8q7upzOKLh2f7k7jOAAAAABwD16ufPjChQs1duxY9ezZU6Wlpfr3v/+tIUOGaPPmzQoMrHpkuLi4WBdddJFiYmI0a9YsNW/eXHv37lVYWFjdFu9iGSdMdb/kNEO6bbp7LiEdAAAAANyBS0P67NmzK3w+depUxcTEaPXq1RowYECV13zyySfKyMjQsmXL5O3tLUlKSEhwdqluxzrVvVPzECWcxlR3ie7uAAAAAOBu3GpNelZWliQpIiKi2nP+7//+T71799bYsWPVpEkTderUSS+++KLMZnOV5xcVFSk7O7vCR0Pw84Yzm+ounTjdne7uAAAAAOAO3CakWywW3Xffferbt686depU7Xm7d+/WrFmzZDab9csvv+jJJ5/Uf/7zHz3//PNVnj9p0iSFhobaPuLi4pz1JdSZ9NwiLduVJun0p7pLNI4DAAAAAHfjNiF97Nix2rhxo2bMmFHjeRaLRTExMfrggw/Uo0cPXXvttXr88cf13nvvVXn+hAkTlJWVZfvYt2+fM8qvU3M2HZbFkDo3D1V85OlNdZeOj6RnFpTIbDEcVR4AAAAA4DS5dE261bhx4/TTTz9p0aJFatGiRY3nNmvWTN7e3vL09LQdO+uss5Samqri4mL5+PhUON/X11e+vr5OqdtVfv77oKQzm+ouSeEBZWv6DUM6ll+sqKCG9T4BAAAAQH3j0pF0wzA0btw4fffdd5o3b54SExNPeU3fvn21c+dOWSwW27Ht27erWbNmlQJ6Q5SWW6TlZ9jV3crL00Nh5UE9nQ7vAAAAAOByLg3pY8eO1eeff67p06crODhYqampSk1NVUFBge2c0aNHa8KECbbP//nPfyojI0Pjx4/X9u3b9fPPP+vFF1/U2LFjXfEl1Lk5m1JlMaQuLULVMjLgjO9H8zgAAAAAcB8une7+7rvvSpIGDRpU4fiUKVM0ZswYSVJKSoo8PI7/LiEuLk5z5szR/fffry5duqh58+YaP368Hn300boq26Uc0dX9RFGBvtp9NI/mcQAAAADgBlwa0g3j1M3KFixYUOlY7969tWLFCidU5N7Scou0YrdjprpbsVc6AAAAALgPt+nujlObvbFsqnvXFqGKizjzqe6SFBFUPt2dNekAAAAA4HKE9HrE0VPdJSmSkXQAAAAAcBuE9HriaE6R/txTNtXdkSGd6e4AAAAA4D4I6fXE7PKu7l3jwhw21V2iuzsAAAAAuBNCej3x84aDkqRLOjd16H0jA30lMZIOAAAAAO6AkF4PHMkp1J97MiQ5dqq7xHR3AAAAAHAnhPR6YPbGVBmG1C0uTC3CHTfVXZIig46HdIvl1FviAQAAAACch5BeD1i7ujtqb/QThQeUhXSLIWUWlDj8/gAAAACA2iOku7kj2YVamVw21X2Yg9ejS5KPl4eC/bwkSRk0jwMAAAAAlyKku7lfy6e6d2/p+KnuVlFBZc3j0nNZlw4AAAAArkRId3M//+28qe5WNI8DAAAAAPdASHdjh7ML9ZdtqrvzQ3o6IR0AAAAAXIqQ7sZ+/fuQDEM6u2WYmof5O+05kYykAwAAAIBbIKS7sV/+TpUkXdIl1qnPYbo7AAAAALgHQrqbSs0q1F97y6a6D3dCV/cTMd0dAAAAANwDId1N/bqxbKp7j/hwNQt13lR3SYoMso6kswUbAAAAALiSl6sLQNX6tY7SXQNbqV2TYKc/KyKQLdgAAAAAwB0Q0t1UmybBmjDsrDp5ViTT3QEAAADALTDdHbY16cfyimUYhourAQAAAIDGi5AOW0gvtRjKLih1cTUAAAAA0HgR0iE/b08F+ZatfEineRwAAAAAuAwhHZLYKx0AAAAA3AEhHZLYKx0AAAAA3AEhHZKOd3hnJB0AAAAAXIeQDklMdwcAAAAAd0BIhyQpIqh8unsuIR0AAAAAXIWQDkknTnenuzsAAAAAuAohHZKkiEBfSTSOAwAAAABXIqRD0vGRdKa7AwAAAIDrENIhSYoMonEcAAAAALgaIR2SKnZ3NwzDxdUAAAAAQONESIckKbJ8TXqx2aLcolIXVwMAAAAAjRMhHZIkfx9P+Xt7SmLKOwAAAAC4CiEdNtYp73R4BwAAAADXIKTDxtY8jg7vAAAAAOAShHTYnNg8DgAAAABQ9wjpsGG6OwAAAAC4FiEdNpHWkJ5b5OJKAAAAAKBxIqTDJqJ8GzamuwMAAACAaxDSYRPJdHcAAAAAcClCOmxs3d0J6QAAAADgEoR02NDdHQAAAABci5AOm8jyNenpeTSOAwAAAABXIKTDJqJ8unthiUX5xaUurgYAAAAAGh9COmwCfTzl41X2I5Gey5R3AAAAAKhrhHTYmEwmW4d31qUDAAAAQN1zaUifNGmSevbsqeDgYMXExGjkyJHatm1bra+fMWOGTCaTRo4c6bwiGxmaxwEAAACA67g0pC9cuFBjx47VihUrNHfuXJWUlGjIkCHKy8s75bXJycl66KGH1L9//zqotPGwhvS0XJrHAQAAAEBd83Llw2fPnl3h86lTpyomJkarV6/WgAEDqr3ObDbrxhtv1MSJE7V48WJlZmY6udLGg+nuAAAAAOA6brUmPSsrS5IUERFR43nPPvusYmJidNttt53ynkVFRcrOzq7wgepFlG/DRkgHAAAAgLrnNiHdYrHovvvuU9++fdWpU6dqz1uyZIk+/vhjffjhh7W676RJkxQaGmr7iIuLc1TJDVJk+TZs6YR0AAAAAKhzbhPSx44dq40bN2rGjBnVnpOTk6ObbrpJH374oaKiomp13wkTJigrK8v2sW/fPkeV3CAx3R0AAAAAXMela9Ktxo0bp59++kmLFi1SixYtqj1v165dSk5O1ogRI2zHLBaLJMnLy0vbtm1TUlJShWt8fX3l6+vrnMIbIGvjOEbSAQAAAKDuuTSkG4ahe+65R999950WLFigxMTEGs9v3769/v777wrHnnjiCeXk5Oitt95iKrsDWKe7Z+TR3R0AAAAA6ppLQ/rYsWM1ffp0/fDDDwoODlZqaqokKTQ0VP7+/pKk0aNHq3nz5po0aZL8/PwqrVcPCwuTpBrXsaP2bI3jchlJBwAAAIC65tKQ/u6770qSBg0aVOH4lClTNGbMGElSSkqKPDzcZul8g2ed7p5XbFZhiVl+3p4urggAAAAAGg+XT3c/lQULFtT4+tSpUx1TDCRJIX5e8vY0qcRsKCOvWLFh/q4uCQAAAAAaDYaoUYHJZFJ4AB3eAQAAAMAVCOmoxDrlPS2X5nEAAAAAUJcI6ajkeId3RtIBAAAAoC4R0lGJrcM7IR0AAAAA6hQhHZVElk93TyekAwAAAECdIqSjEmtIZ690AAAAAKhbhHRUEhHESDoAAAAAuAIhHZXYRtLz6O4OAAAAAHWJkI5KaBwHAAAAAK5BSEclETSOAwAAAACXIKSjEut095zCUhWXWlxcDQAAAAA0HoR0VBLq7y1PD5MkprwDAAAAQF0ipKMSDw+TwgO8JUnpNI8DAAAAgDpDSEeVImwd3hlJBwAAAIC6QkhHlSLp8A4AAAAAdY6QjipFBJV3eM8lpAMAAABAXSGko0qRTHcHAAAAgDpHSEeV2CsdAAAAAOoeIR1VOj6STnd3AAAAAKgrhHRUKYLGcQAAAABQ5wjpqBLT3QEAAACg7p1WSF+8eLH+8Y9/qHfv3jpw4IAk6bPPPtOSJUscWhxcJ5Lu7gAAAABQ5+wO6d98840uvvhi+fv7a+3atSoqKluznJWVpRdffNHhBcI1rCPpWQUlKjFbXFwNAAAAADQOdof0559/Xu+9954+/PBDeXt724737dtXa9ascWhxcJ3wAB+ZTGV/PpbPaDoAAAAA1AW7Q/q2bds0YMCASsdDQ0OVmZnpiJrgBjw9TAoPYK90AAAAAKhLdof0pk2baufOnZWOL1myRK1atXJIUXAP1invGaxLBwAAAIA6YXdIv+OOOzR+/Hj9+eefMplMOnjwoL744gs99NBD+uc//+mMGuEidHgHAAAAgLrlZe8Fjz32mCwWiy644ALl5+drwIAB8vX11UMPPaR77rnHGTXCRSIDme4OAAAAAHXJ7pBuMpn0+OOP6+GHH9bOnTuVm5urDh06KCgoyBn1wYUYSQcAAACAumV3SLfy8fFRhw4dHFkL3MzxkfQiF1cCAAAAAI2D3SF98ODBMln35qrCvHnzzqgguI8IprsDAAAAQJ2yO6R369atwuclJSVat26dNm7cqJtvvtlRdcENRAT5SpLS6e4OAAAAAHXC7pD+xhtvVHn8mWeeUW5u7hkXBPcRyZp0AAAAAKhTdm/BVp1//OMf+uSTTxx1O7gBprsDAAAAQN1yWEhfvny5/Pz8HHU7uAHrSPqx/GKZLYaLqwEAAACAhs/u6e6jRo2q8LlhGDp06JBWrVqlJ5980mGFwfXCy0O6YUiZ+cWKLF+jDgAAAABwDrtDemhoaIXPPTw81K5dOz377LMaMmSIwwqD63l7eijU31tZBSXKyCOkAwAAAICz2R3Sp0yZ4ow64KYiA32UVVCi9LxitXF1MQAAAADQwDlsTToaJprHAQAAAEDdqdVIenh4uEwmU61umJGRcUYFwb1EsA0bAAAAANSZWoX0N99808llwF1FBpWPpOcS0gEAAADA2WoV0m+++WZn1wE3dXy6e5GLKwEAAACAhs/uxnEnKiwsVHFxxRHWkJCQMyoI7iUisKyjexrT3QEAAADA6exuHJeXl6dx48YpJiZGgYGBCg8Pr/CBhiUykOnuAAAAAFBX7A7pjzzyiObNm6d3331Xvr6++uijjzRx4kTFxsbq008/dUaNcCG6uwMAAABA3bF7uvuPP/6oTz/9VIMGDdItt9yi/v37q3Xr1oqPj9cXX3yhG2+80Rl1wkWsjePo7g4AAAAAzmf3SHpGRoZatWolqWz9uXXLtX79+mnRokV23WvSpEnq2bOngoODFRMTo5EjR2rbtm01XvPhhx+qf//+tun1F154oVauXGnvl4Faiixfk34sv1gWi+HiagAAAACgYbM7pLdq1Up79uyRJLVv315fffWVpLIR9rCwMLvutXDhQo0dO1YrVqzQ3LlzVVJSoiFDhigvL6/aaxYsWKDrr79e8+fP1/LlyxUXF6chQ4bowIED9n4pqIXwQG9JktliKLuwxMXVAAAAAEDDZjIMw67h0TfeeEOenp6699579fvvv2vEiBEyDEMlJSV6/fXXNX78+NMu5ujRo4qJidHChQs1YMCAWl1jNpsVHh6u//3vfxo9evQpz8/OzlZoaKiysrLoRF9LnZ+eo5yiUv3x4EAlRQe5uhwAAAAAqFfsyaF2r0m///77bX++8MILtXXrVq1evVqtW7dWly5d7K/2BFlZWZKkiIiIWl+Tn5+vkpKSaq8pKipSUdHxPb6zs7PPqMbGKCLIRzlFpcrIK1ZStKurAQAAAICGy+7p7vv27avweXx8vEaNGnXGAd1isei+++5T37591alTp1pf9+ijjyo2NlYXXnhhla9PmjRJoaGhto+4uLgzqrMxsnZ4T2cbNgAAAABwKrtDekJCggYOHKgPP/xQx44dc1ghY8eO1caNGzVjxoxaX/PSSy9pxowZ+u677+Tn51flORMmTFBWVpbt4+RfMuDUItmGDQAAAADqhN0hfdWqVerVq5eeffZZNWvWTCNHjtSsWbMqTCm317hx4/TTTz9p/vz5atGiRa2uee211/TSSy/pt99+q3EU39fXVyEhIRU+YJ/jI+mn/z0GAAAAAJya3SG9e/fuevXVV5WSkqJff/1V0dHRuvPOO9WkSRPdeuutdt3LMAyNGzdO3333nebNm6fExMRaXffKK6/oueee0+zZs3XOOefY+yXAThHl27CxVzoAAAAAOJfdId3KZDJp8ODB+vDDD/X7778rMTFR06ZNs+seY8eO1eeff67p06crODhYqampSk1NVUFBge2c0aNHa8KECbbPX375ZT355JP65JNPlJCQYLsmNzf3dL8UnALT3QEAAACgbpx2SN+/f79eeeUVdevWTb169VJQUJDefvttu+7x7rvvKisrS4MGDVKzZs1sHzNnzrSdk5KSokOHDlW4pri4WFdddVWFa1577bXT/VJwChGEdAAAAACoE3Zvwfb+++9r+vTpWrp0qdq3b68bb7xRP/zwg+Lj4+1+eG22aF+wYEGFz5OTk+1+Ds5MZFD5mnRCOgAAAAA4ld0h/fnnn9f111+vyZMnq2vXrs6oCW4msnxNekYejeMAAAAAwJnsDukpKSkymUzOqAVuKiLo+HR3wzD4/gMAAACAk9i9Jp2A1vhYG8eVmA3lFJW6uBoAAAAAaLhOu3EcGg8/b08F+HhKkjJyWZcOAAAAAM5CSEetWDu80zwOAAAAAJyHkI5asU55T8+leRwAAAAAOAshHbXCXukAAAAA4Hx2h/TDhw/rpptuUmxsrLy8vOTp6VnhAw1TRPk2bEx3BwAAAADnsXsLtjFjxiglJUVPPvmkmjVrRrf3RiIyiJF0AAAAAHA2u0P6kiVLtHjxYnXr1s0J5cBdRTLdHQAAAACczu7p7nFxcTIMwxm1wI3R3R0AAAAAnM/ukP7mm2/qscceU3JyshPKgbs6Pt2d7u4AAAAA4Cx2T3e/9tprlZ+fr6SkJAUEBMjb27vC6xkZGQ4rDu7D2jguI5eRdAAAAABwFrtD+ptvvumEMuDuIk+Y7m4YBg0DAQAAAMAJ7A7pN998szPqgJuzrkkvKrUov9isQF+7f3QAAAAAAKdwWknLbDbr+++/15YtWyRJHTt21GWXXcY+6Q1YgI+nfL08VFRqUUZeMSEdAAAAAJzA7qS1c+dODR8+XAcOHFC7du0kSZMmTVJcXJx+/vlnJSUlObxIuJ7JZFJkoI8OZhUqLbdIcREBri4JAAAAABocu7u733vvvUpKStK+ffu0Zs0arVmzRikpKUpMTNS9997rjBrhJiKC2CsdAAAAAJzJ7pH0hQsXasWKFYqIiLAdi4yM1EsvvaS+ffs6tDi4F2uHd/ZKBwAAAADnsHsk3dfXVzk5OZWO5+bmysfHxyFFwT1FBTKSDgAAAADOZHdIv/TSS3XnnXfqzz//lGEYMgxDK1as0N13363LLrvMGTXCTUQQ0gEAAADAqewO6ZMnT1ZSUpJ69+4tPz8/+fn5qW/fvmrdurXeeustZ9QIN2Fdk56eS0gHAAAAAGewe016WFiYfvjhB+3YsUNbt26VJJ111llq3bq1w4uDe4m0jaQXubgSAAAAAGiYTnuz6zZt2qhNmzaOrAVuzto4junuAAAAAOActQrpDzzwgJ577jkFBgbqgQceqPHc119/3SGFwf1Y16TT3R0AAAAAnKNWIX3t2rUqKSmx/RmNUySN4wAAAADAqWoV0ufPn1/ln9G4WBvH5RebVVBslr+Pp4srAgAAAICGxe7u7rfeemuV+6Tn5eXp1ltvdUhRcE/Bvl7y9jRJktJpHgcAAAAADmd3SJ82bZoKCgoqHS8oKNCnn37qkKLgnkwmE3ulAwAAAIAT1bq7e3Z2tgzDkGEYysnJkZ+fn+01s9msX375RTExMU4pEu4jItBXh7OLaB53ErPF0BPf/62cwlJNvq67PDxMri4JAAAAQD1U65AeFhYmk8kkk8mktm3bVnrdZDJp4sSJDi0O7ieqfF16Ri4h/UST/9ihL1fukySNv6CN2jQJdnFFAAAAAOqjWof0+fPnyzAMnX/++frmm28UERFhe83Hx0fx8fGKjY11SpFwH0x3r2zJjjRNnrfD9vne9HxCOgAAAIDTUuuQPnDgQEnSnj171LJlS5lMTOdtjNgrvaIj2YW6b+ZaGYbk6WGS2WJob0a+q8sCAAAAUE/Z3Thu3rx5mjVrVqXjX3/9taZNm+aQouC+ju+VTnf3UrNF93y5Vmm5xWrfNFg3nRcvSUpJz3NxZQAAAADqK7tD+qRJkxQVFVXpeExMjF588UWHFAX3FRHoK4np7pL01h879OeeDAX6eOrtG89Wu6ZlU9wZSQcAAABwumo93d0qJSVFiYmJlY7Hx8crJSXFIUXBfTHdvcyi7Uf1v/k7JUkvjuqspOggHc4ulCSlpBPSAQAAAJweu0fSY2JitGHDhkrH169fr8jISIcUBfcVWd7dPb0Rd3dPzSrUfTPXyTCkG85tqcu7NZckxUcGSpL2HcuX2WK4skQAAAAA9ZTdIf3666/Xvffeq/nz58tsNstsNmvevHkaP368rrvuOmfUCDfS2Lu7l5otuvfLtcrIK1aHZiF66tIOtteahvjJx9NDJWZDh7IKXFglAAAAgPrK7unuzz33nJKTk3XBBRfIy6vscovFotGjR7MmvRGwNo7LLSpVUalZvl6eLq6obv1n7natTM5QkK+X3rnxbPl5H//6PT1MahHhr91H85SSnq8W4QEurBQAAABAfWR3SPfx8dHMmTP13HPPaf369fL391fnzp0VHx/vjPrgZkL8vG1bjWXkFatZqL+rS6oz87ce0bsLdkmSXrqysxKiAiudEx8RoN1H87Q3I1996rpAAAAAAPWe3SHdqm3btmrbtq0ja0E94OFhUkSgj47mFCk9t/GE9IOZBbr/q3WSpJvOi9elXWKrPK9sXfpR7aV5HAAAAIDTYHdIN5vNmjp1qv744w8dOXJEFoulwuvz5s1zWHFwT5HlIb2xrEsvMVs0bvoaZeaXqFPzED1x6VnVntsyomyKe0oGe6UDAAAAsJ/dIX38+PGaOnWqLrnkEnXq1Ekmk8kZdcGNNbbmca/O2aY1KZkK9vXS2zecXeM6/PjIspDOSDoAAACA02F3SJ8xY4a++uorDR8+3Bn1oB5oTHul/775sD5YtFuS9MpVXWzbrFXnxJBuGAa/xAIAAABgF7u3YPPx8VHr1q2dUQvqiUjbSHqRiytxrv3H8vXg1+slSWP6JGhY52anvKZFeIBMprLu941lpgEAAAAAx7E7pD/44IN66623ZBiGM+pBPRAR6CupYU93Ly61aNz0tcoqKFHXFqH69/Dq16GfyM/bU01D/CRJezOY8g4AAADAPnaH9CVLluiLL75QUlKSRowYoVGjRlX4sMekSZPUs2dPBQcHKyYmRiNHjtS2bdtOed3XX3+t9u3by8/PT507d9Yvv/xi75eBMxARVDaSnpbbcEP6y7O3at2+TIX4eel/N5wtH6/a/1WxNY9jXToAAAAAO9kd0sPCwnTFFVdo4MCBioqKUmhoaIUPeyxcuFBjx47VihUrNHfuXJWUlGjIkCHKy6u+M/ayZct0/fXX67bbbtPatWs1cuRIjRw5Uhs3brT3S8FpimzgjePmbErVx0v2SJJeu7qr4spDd23RPA4AAADA6bK7cdyUKVMc9vDZs2dX+Hzq1KmKiYnR6tWrNWDAgCqveeuttzR06FA9/PDDkqTnnntOc+fO1f/+9z+99957DqsN1WvI3d33ZeTrofJ16Lf3S9SQjk3tvoe1udxetmEDAAAAYCe7R9KdKSsrS5IUERFR7TnLly/XhRdeWOHYxRdfrOXLl1d5flFRkbKzsyt84MxYR9LTcxtW47iiUrPGTl+jnMJSdW8ZpkeHtT+t+zDdHQAAAMDpsnskPTExscZtpXbv3n1ahVgsFt13333q27evOnXqVO15qampatKkSYVjTZo0UWpqapXnT5o0SRMnTjytmlC1yKCyxnHZhaUqMVvk7elWv+s5bZN+2aoN+7MU6u+t/17f/bS/Ltt0dxrHAQAAALCT3SH9vvvuq/B5SUmJ1q5dq9mzZ9umoJ+OsWPHauPGjVqyZMlp36MqEyZM0AMPPGD7PDs7W3FxcQ59RmMT5u8tD5NkMaRjecWKKe9mXp/98vchTV2WLEl6/ZquahFu3zr0E8VHlE13P5pTpPziUgX42P3XDAAAAEAjZXd6GD9+fJXH3377ba1ateq0ihg3bpx++uknLVq0SC1atKjx3KZNm+rw4cMVjh0+fFhNm1a9dtjX11e+vr6nVReq5uFhUniAj9LzipXeAEL63vQ8PTprgyTprgGtdMFZTU5xRc1CA7wV6u+trIISpWTkq33TEEeUCQAAAKARcNg85WHDhumbb76x6xrDMDRu3Dh99913mjdvnhITE095Te/evfXHH39UODZ37lz17t3brmfjzDSU5nGFJWb964s1yikqVY/4cD10cTuH3JcO7wAAAABOh8NC+qxZs2ps+FaVsWPH6vPPP9f06dMVHBys1NRUpaamqqCgwHbO6NGjNWHCBNvn48eP1+zZs/Wf//xHW7du1TPPPKNVq1Zp3LhxjvpSUAvWkJ5ez0P68z9v1qaD2QoP8Nb/bjj9degns3Z4p3kcAAAAAHvYPd29e/fuFRrHGYah1NRUHT16VO+8845d93r33XclSYMGDapwfMqUKRozZowkKSUlRR4ex4NTnz59NH36dD3xxBP697//rTZt2uj777+vsdkcHC8yqHwkvR53eP9x/UF9viJFkvT6td3ULNTfYfeOj7A2j2MbNgAAAAC1Z3dIHzlyZIXPPTw8FB0drUGDBql9e/u2rDIM45TnLFiwoNKxq6++WldffbVdz4Jj1ffp7nvS8jTh278lSf8alKTB7WIcev+WTHcHAAAAcBpqFdIfeOABPffccwoMDNTgwYPVu3dveXt7O7s2uLGIwLJmfGn1MKRb16HnFpWqV2KEHriorcOfYR1JT2EbNgAAAAB2qNUC3P/+97/Kzc2VJA0ePFjHjh1zalFwf5HWkfTc+hXSS8wWPfjVem05lK3IQB/99/ru8nLCPu/WNekHjhWo1Gxx+P0BAAAANEy1GklPSEjQ5MmTNWTIEBmGoeXLlys8PLzKcwcMGODQAuGe6uN096JSs8ZNX6u5mw/L29Okt67rriZO2j4uJthXvl4eKiq16GBmoW36OwAAAADUpFYh/dVXX9Xdd9+tSZMmyWQy6YorrqjyPJPJJLPZ7NAC4Z4ibd3d60fjuIJis+76fLUWbT8qHy8Pvf+PHurXJsppz/PwMKllRIB2HMnV3ow8QjoAAACAWqnVPN+RI0cqNTVV2dnZMgxD27Zt07Fjxyp9ZGRkOLteuInIoLI16fVhJD2vqFS3TF2pRduPyt/bU1PG9NTg9o5tFFcV9koHAAAAYC+7ursHBQVp/vz5SkxMlJeX3Y3h0YBYp7tnFpTIbDHk6WE6xRWukV1YojGfrNSalEwF+Xppyi091TMhok6e3TKibF363nS2YQMAAABQO3Z3zBo4cCABHQoPKOvubxjSsXz3HE0/llesGz/8U2tSMhXq760vbj+3zgK6xEg6AAAAAPs5vq01GgUvTw+FlQd1d5zyfjSnSNd9sEJ/H8hSRKCPvrzjPHWNC6vTGqzr0NmGDQAAAEBtEdJx2qxT3tPdbBu2Q1kFuvb95dp2OEcxwb6aeed56hAbUud1nLhXumEYdf58AAAAAPUPIR2nLdINt2Hbl5Gva95frt1peWoe5q+v7uqtNk2CXVJLi/AAeZik/GKzjubWjy74AAAAAFzrtEP6zp07NWfOHBUUFEgSI4WNUISbbcO2Jy1P17y/XPsyCtQyIkAz7zpPCVGBLqvHx8tDzUL9JUkprEsHAAAAUAt2h/T09HRdeOGFatu2rYYPH65Dhw5Jkm677TY9+OCDDi8Q7isisGwbNneY7r79cI6ueX+5DmUVKik6UF/d1Vstwl2/NznN4wAAAADYw+6Qfv/998vLy0spKSkKCDgegq699lrNnj3bocXBvbnLdPeNB7J03QcrdDSnSO2bBmvmXb3VNNTPpTVZ2UI6zeMAAAAA1ILde6n99ttvmjNnjlq0aFHheJs2bbR3716HFQb3F+EGIX1tyjHd/MlKZReWqkuLUH16ay+FBfi4rJ6TWfdKT2GvdAAAAAC1YHdIz8vLqzCCbpWRkSFfX1+HFIX6ITLItWvS/9ydrlun/qW8YrPOiQ/XJ7f0VIift0tqqQ4j6QAAAADsYfd09/79++vTTz+1fW4ymWSxWPTKK69o8ODBDi0O7i2yfE26K0bSl+xI081TViqv2Kw+SZGadmsvtwvo0vGQTuM4AAAAALVh90j6K6+8ogsuuECrVq1ScXGxHnnkEW3atEkZGRlaunSpM2qEm3LVdPc/thzWP79Yo+JSiwa1i9Z7/+ghP2/POq2htuIjy6a7p+cVK7eoVEG+dv+VAwAAANCI2D2S3qlTJ23fvl39+vXT5Zdfrry8PI0aNUpr165VUlKSM2qEm7JOdz+WXyKLpW624Pvl70O667PVKi616OKOTfT+Te4b0CUpyNfL1mBvL+vSAQAAAJzCaQ3rhYaG6vHHH3d0LahnwssbtJkthrIKShQe6NyGbd+t3a8Hv1oviyFd1jVW/7mmq7w97f49U51rGRmg9LxipaTnq2NsqKvLAQAAAODG7E44rVu31jPPPKMdO3Y4ox7UIz5eHgr2K/s9T7qTp7zPWJmiB8oD+tU9WuiNa7vVi4AuSfERNI8DAAAAUDt2p5yxY8fq559/Vrt27dSzZ0+99dZbSk1NdUZtqAesU7nTc53X4X3q0j167Nu/ZRjSTefF6+Uru8jTw+S05zlay/J16XtpHgcAAADgFOwO6ffff7/++usvbd26VcOHD9fbb7+tuLg4DRkypELXdzQOzm4e997CXXrmx82SpDv6J+rZyzvKox4FdOn4SHpKBmvSAQAAANTstOcLt23bVhMnTtT27du1ePFiHT16VLfccosja0M9EFG+DZujp7sbhqHX5mzTS79ulSTde35r/Xv4WTKZ6ldAl07YK52RdAAAAACncEb7Qa1cuVLTp0/XzJkzlZ2drauvvtpRdaGeiHTCSLrZYujJHzZq+p8pkqRHhrbTvwa1dtj961rL8pB+MLNAxaUW+XjVj7X0AAAAAOqe3Wlh+/btevrpp9W2bVv17dtXW7Zs0csvv6zDhw9rxowZzqgRbiwiyLEhvajUrHu/XKvpf6bIZJJevKJzvQ7okhQd5KsAH09ZDGn/MUbTAQAAAFTP7pH09u3bq2fPnho7dqyuu+46NWnSxBl1oZ6wNY5zQEjPKyrV3Z+v1uIdafL2NOmt67preOdmZ3xfVzOZTGoZEaCtqTnam5GvVtFBri4JAAAAgJuyO6Rv27ZNbdq0cUYtqIcibSPpZ9bd/VhescZM/Uvr92UqwMdT79/UQ/3bRDuiRLdgDekprEsHAAAAUAO7QzoBHSeyNY7LPf2R9ENZBbrp45XaeSRXYQHemnpLL3WLC3NQhe6B5nEAAAAAaqNWIT0iIkLbt29XVFSUwsPDa+ywnZGR4bDi4P7OtHHc7qO5uunjlTqQWaCmIX767LZeatMk2JElugXrXulswwYAAACgJrUK6W+88YaCg4Ntf66P22DBOaz7pB/LL5ZhGHb9bGw8kKWbP1mp9LxitYoK1Ke39VKL8ABnlepS1r3SGUkHAAAAUJNahfSbb77Z9ucxY8Y4qxbUQ9aQXmI2lF1YqlB/71pdt3xXuu74dJVyi0rVqXmIpt7SS1FBvs4s1aWs091TMvJlsRjy8OAXXQAAAAAqs3sLNk9PTx05cqTS8fT0dHl6ejqkKNQfft6eCvQp+76n59auedycTam6ecpK5RaV6rxWEfryjvMadECXpNgwf3l6mFRUatGRnDNrsgcAAACg4bI7pBuGUeXxoqIi+fj4nHFBqH/s2Sv9q1X79M/PV6u41KIhHZpo6i29FOxXu9H3+szb00PNw/wlSXvTWZcOAAAAoGq17u4+efJkSWV7Pn/00UcKCjq+17PZbNaiRYvUvn17x1cItxcR6Kt9GQWn3Cv9w0W79cIvWyRJV/dooUmjOsvL0+7fE9Vb8ZEBSsnI196MfJ3bKtLV5QAAAABwQ7UO6W+88YakspH09957r8LUdh8fHyUkJOi9995zfIVwe6fq8G4Yhl6Zs03vLtglSbpzQCtNGNa+0TUgjI8M0OIdYq90AAAAANWqdUjfs2ePJGnw4MH69ttvFR4e7rSiUL/UFNLNFkOPf/e3Zvy1T5L06ND2+uegpDqtz13ER5Rtw7Y3g5AOAAAAoGq1DulW8+fPd0YdqMesa9LTcyuG9KJSs+6bsU6/bkyVh0l64YrOur5XS1eU6BZaWju8syYdAAAAQDXsXhB85ZVX6uWXX650/JVXXtHVV1/tkKJQvxwfST/etTy3qFS3Tv1Lv25MlY+nh96+4exGHdCl49uwMZIOAAAAoDp2h/RFixZp+PDhlY4PGzZMixYtckhRqF8iAsu2T7M2jsvIK9aNH67Q0p3pCvTx1JRbempY52auLNEttIwoC+mZ+SXKKihxcTUAAAAA3JHdIT03N7fKrda8vb2VnZ3tkKJQv5y4Jv1gZoGufm+Z1u/PUniAt6bfcZ76to5ycYXuIcDHS9HBZb/QoHkcAAAAgKrYHdI7d+6smTNnVjo+Y8YMdejQwSFFoX6JKA/p+zLyddW7y7TraJ6ahfrp67t7q2tcmGuLczPxEdYp76xLBwAAAFCZ3Y3jnnzySY0aNUq7du3S+eefL0n6448/9OWXX+rrr792eIFwf9aQnl1YquzCUrWKDtRnt52r5mH+Lq7M/bSMDNCqvce0l5F0AAAAAFWwO6SPGDFC33//vV588UXNmjVL/v7+6tKli37//XcNHDjQGTXCzUUGHV/+0Ll5qKbe0lORQb4urMh92bZho8M7AAAAgCrYHdIl6ZJLLtEll1zi6FpQTwX4eOmuga2UllOsiZd3VJDvaf1YNQq2Du+MpAMAAACowmmlqczMTM2aNUu7d+/WQw89pIiICK1Zs0ZNmjRR8+bNHV0j6oEJw85ydQn1gm2vdLZhAwAAAFAFuxvHbdiwQW3bttXLL7+sV199VZmZmZKkb7/9VhMmTLDrXosWLdKIESMUGxsrk8mk77///pTXfPHFF+ratasCAgLUrFkz3XrrrUpPT7f3ywBcwto4LjW7UIUlZhdXAwAAAMDd2B3SH3jgAY0ZM0Y7duyQn5+f7fjw4cPt3ic9Ly9PXbt21dtvv12r85cuXarRo0frtttu06ZNm/T1119r5cqVuuOOO+x6LuAqEYE+CvL1kmFI+48xmg4AAACgIrunu//11196//33Kx1v3ry5UlNT7brXsGHDNGzYsFqfv3z5ciUkJOjee++VJCUmJuquu+7Syy+/bNdzAVcxmUxqGRGgzYeytTc9X61jgl1dEgAAAAA3YvdIuq+vr7Kzsysd3759u6Kjox1SVHV69+6tffv26ZdffpFhGDp8+LBmzZql4cOHV3tNUVGRsrOzK3wArkTzOAAAAADVsTukX3bZZXr22WdVUlIiqWxkMCUlRY8++qiuvPJKhxd4or59++qLL77QtddeKx8fHzVt2lShoaE1TpefNGmSQkNDbR9xcXFOrRE4FZrHAQAAAKiO3SH9P//5j3JzcxUTE6OCggINHDhQrVu3VnBwsF544QVn1GizefNmjR8/Xk899ZRWr16t2bNnKzk5WXfffXe110yYMEFZWVm2j3379jm1RuBU2CsdAAAAQHXsXpMeGhqquXPnasmSJdqwYYNyc3N19tln68ILL3RGfRVMmjRJffv21cMPPyxJ6tKliwIDA9W/f389//zzatasWaVrfH195evr6/TagNqyTXdnJB0AAADASU5rn3RJ6tevn/r16+fIWk4pPz9fXl4VS/b09JQkGYZRp7UAp8sa0vdnFMhsMeTpYXJxRQAAAADcRa1C+uTJk3XnnXfKz89PkydPrvHcoKAgdezYUeeee+4p75ubm6udO3faPt+zZ4/WrVuniIgItWzZUhMmTNCBAwf06aefSpJGjBihO+64Q++++64uvvhiHTp0SPfdd5969eql2NjY2nwpgMs1C/WXt6dJxWaLUrML1TzM39UlAQAAAHATtQrpb7zxhm688Ub5+fnpjTfeqPHcoqIiHTlyRPfff79effXVGs9dtWqVBg8ebPv8gQcekCTdfPPNmjp1qg4dOqSUlBTb62PGjFFOTo7+97//6cEHH1RYWJjOP/98tmBDveLpYVJceIB2p+Vpb3oeIR0AAACAjclwwjzxuXPn6oYbbtDRo0cdfeszlp2drdDQUGVlZSkkJMTV5aCRGjNlpRZsO6qXRnXWdb1aurocAAAAAE5kTw61u7t7bfTr109PPPGEM24NNAjxETSPAwAAAFDZaYX0P/74Q5deeqmSkpKUlJSkSy+9VL///rvtdX9/f40fP95hRQINTcvIsm3YUtIJ6QAAAACOszukv/POOxo6dKiCg4M1fvx4jR8/XiEhIRo+fLjefvttZ9QINDjHR9LZKx0AAADAcXZvwfbiiy/qjTfe0Lhx42zH7r33XvXt21cvvviixo4d69ACgYbItld6er4Mw5DJxDZsAAAAAE5jJD0zM1NDhw6tdHzIkCHKyspySFFAQxdXPpKeU1iqzPwSF1cDAAAAwF3YHdIvu+wyfffdd5WO//DDD7r00ksdUhTQ0Pl5e6ppiJ8kKTmdKe8AAAAAytRquvvkyZNtf+7QoYNeeOEFLViwQL1795YkrVixQkuXLtWDDz7onCqBBqhlZIBSswuVkpGv7i3DXV0OAAAAADdQq33SExMTa3czk0m7d+8+46KciX3S4S4e/nq9vl69Xw9c1Fb3XtCmTp+9+WC2PlqyW48Nba+Y8hF9AAAAAM5hTw6t1Uj6nj17HFIYgONObB5X1174ZbOW7kxXmL+PnhrRoc6fDwAAAKBqp7VPuiSlpaUpLS3NkbUAjYptr/Q63obtWF6xVuzOkCQt2Xm0Tp8NAAAAoGZ2hfTMzEyNHTtWUVFRatKkiZo0aaKoqCiNGzdOmZmZTioRaJhse6XX8Uj63C2HZbaUrXLZfjhXqVmFdfp8AAAAANWr9T7pGRkZ6t27tw4cOKAbb7xRZ511liRp8+bNmjp1qv744w8tW7ZM4eE0wAJqwzrd/UhOkQqKzfL38ayT587emFrh88U7jurqc+Lq5NkAAAAAalbrkP7ss8/Kx8dHu3btUpMmTSq9NmTIED377LN64403HF4k0BCFBfgoxM9L2YWlSsnIV7umwU5/Zk5hiZbsKFumMrRjU83elKrFO9II6QAAAICbqPV09++//16vvfZapYAuSU2bNtUrr7xS5f7pAKoXX74ufW8d7ZU+b+sRFZstSooO1K39ynZtWLIzTRbLKTd5AAAAAFAHah3SDx06pI4dO1b7eqdOnZSamlrt6wAqa1k+5T0lo27WpVunug/t1FTdW4Yp0MdTGXnF2nQwu06eDwAAAKBmtQ7pUVFRSk5Orvb1PXv2KCIiwhE1AY1GQh1uw1ZQbNaCbWXd3Id1aiZvTw/1ToqSJC3aQZd3AAAAwB3UOqRffPHFevzxx1VcXFzptaKiIj355JMaOnSoQ4sDGrr4iPLp7nUwkr5w+1EVlJjVItxfHWNDJEkD2paF9MWEdAAAAMAt2NU47pxzzlGbNm00duxYtW/fXoZhaMuWLXrnnXdUVFSkzz77zJm1Ag2Obbp7HaxJn7OpfKp7x6YymUySpP5toiVJq/ceU15RqQJ9a/2vBAAAAABOUOv/I2/RooWWL1+uf/3rX5owYYIMo6zRlMlk0kUXXaT//e9/ioujQzRgD+s2bPuPFajUbJGXZ60nt9iluNSi37ccliQN69zUdjwhMkAtwv21/1iB/tyTrvPbV24MCQAAAKDu2DVslpiYqF9//VXHjh3Tjh07JEmtW7dmLTpwmpoE+8nHy0PFpRYdyipUXESAU56zdFeacgpLFRPsq+5x4bbjJpNJ/dtE68uVKVq0PY2QDgAAALjYaQ3bhYeHq1evXurVqxcBHTgDHh4mtYxwfvO4OeVd3S/u2FQeHqYKrw1ow7p0AAAAwF04Z24tgFqLt4b0DOesSy81W/Tb5vKp7p2aVnq9T1KUPEzSrqN5OpBZ4JQaAAAAANQOIR1wsePN45wzkr4yOUMZecUKD/BWr8TKM19CA7zVNS5MkrSE0XQAAADApQjpgIvFO3m6u3Wq+0UdmlTbmM7a5X3RjjSn1AAAAACgdgjpgIvFR5btlZ7shG3YLBZDs61br1Ux1d3Kui596c40mS2Gw+sAAAAAUDuEdMDFbNPdM/JtWxs6ytp9mTqcXaRgXy/1bR1V7Xld48IU7OulzPwSbTyQ5dAaAAAAANQeIR1wsRbh/jKZpPxis9Jyix167znlo+jnnxUjXy/Pas/z9vRQn9aRkujyDgAAALgSIR1wMV8vT8WG+kuSUhzY4d0wDP268ZAkaWjH6qe6W7EuHQAAAHA9QjrgBpyxV/rmQ9nal1EgP28PDWwXfcrzB5SH9DV7jym3qNRhdQAAAACoPUI64AbiIx0f0meXd3Uf2DZaAT5epzy/ZWSA4iMDVGoxtHxXusPqAAAAAFB7hHTADZzYPM5Rfi0P6cM6Nav1Nf3Lu7yzLh0AAABwDUI64AbiI8q2YdvroG3Ydh7J0c4jufL2NOn8s2JqfZ11Xfpi1qUDAAAALkFIB9xAvINH0q1T3fu2jlKIn3etr+udFClPD5P2pOVpnwNH9QEAAADUDiEdcAPW6e5pucUOadp2fKr7qbu6nyjEz1vd48IkMZoOAAAAuAIhHXADIX7eigj0kSSlnGHzuH0Z+dp0MFseJunCs5rYff3xKe+sSwcAAADqGiEdcBPWbdjOdK9061T3cxMjFRnka/f1/duWNY9bujNNpWbLGdUCAAAAwD6EdMBNOGobttmbyqe6d7ZvqrtVl+ahCvHzUnZhqTYcyDqjWgAAAADYh5AOuIn48pH0vWfQsO1wdqFW7z0mSRrS4fRCupenh/q2Lt+KbTvr0gEAAIC6REgH3ETLyLJt2M5kTfqc8lH0s1uGqWmo32nfh3XpAAAAgGsQ0gE3YZvufgZr0q3r0Yfa2dX9ZP3blI2kr92XqezCkjO6FwAAAIDaI6QDbsI63f1gZqFKTqNhW0Zesf7ckyFJGtap2RnVEhcRoFZRgTJbDC3flX5G9wIAAABQe4R0wE1EB/vK39tTZouhA8cK7L5+7uZUmS2GOsaGKK488J8J62g6U94BAACAukNIB9yEyWSybcOWnG7/lHfbVPeOZzbV3er4unSaxwEAAAB1hZAOuJGWkda90u1rHpddWKIlO8vC9OluvXay85Ii5eVh0t70fO09jV8aAAAAALAfIR1wI7Zt2Ozs8D5vyxGVmA21jglS65hgh9QS5Ouls+PDJUmLGE0HAAAA6gQhHXAjtg7vdoZ0R091txpgXZe+nXXpAAAAQF1waUhftGiRRowYodjYWJlMJn3//fenvKaoqEiPP/644uPj5evrq4SEBH3yySfOLxaoA7a90u3Yhi2/uFQLth+RdOZbr53Mui59+a700+o4DwAAAMA+Xq58eF5enrp27apbb71Vo0aNqtU111xzjQ4fPqyPP/5YrVu31qFDh2SxEB7QMFinu6dk5MswDJlMplNes2j7URWWWNQi3F8dY0McWk+n5qEKC/BWZn6J1u/L1DkJEQ69PwAAAICKXBrShw0bpmHDhtX6/NmzZ2vhwoXavXu3IiLKwkJCQoKTqgPqXvNwf3l6mFRYYtGRnCI1CfE75TW/lk91H9apaa1CvT08PUzq2zpKP284pEU70gjpAAAAgJPVqzXp//d//6dzzjlHr7zyipo3b662bdvqoYceUkFB9XtKFxUVKTs7u8IH4K68PT0UG1YWzGuzLr2o1Kx5W6xT3Zs5paYB7JcOAAAA1Jl6FdJ3796tJUuWaOPGjfruu+/05ptvatasWfrXv/5V7TWTJk1SaGio7SMuLq4OKwbsFx9Rti69NtueLduZrpyiUjUJ8VX3uDCn1NOvfF36+n2ZysovccozAAAAAJSpVyHdYrHIZDLpiy++UK9evTR8+HC9/vrrmjZtWrWj6RMmTFBWVpbtY9++fXVcNWAfe/ZK/3XjIUnSxR2bysPDsVPdrZqH+SspOlAWQ1q2i63YAAAAAGeqVyG9WbNmat68uUJDQ23HzjrrLBmGof3791d5ja+vr0JCQip8AO4soZbbsJWaLZq7+bAkx2+9djJrl3f2SwcAAACcq16F9L59++rgwYPKzc21Hdu+fbs8PDzUokULF1YGOE5L63T3U4ykr9yToWP5JQoP8FavROc2dBvQtmxd+qLtR2UYhlOfBQAAADRmLg3pubm5WrdundatWydJ2rNnj9atW6eUlBRJZVPVR48ebTv/hhtuUGRkpG655RZt3rxZixYt0sMPP6xbb71V/v7+rvgSAIeLt053P8WadGtX9yEdmsrL07l/lc9rFSlvT5MOZBYouRYN7QAAAACcHpeG9FWrVql79+7q3r27JOmBBx5Q9+7d9dRTT0mSDh06ZAvskhQUFKS5c+cqMzNT55xzjm688UaNGDFCkydPdkn9gDO0LN8r/Vh+ibILq27UZrEYmrOpLKQP7eTcqe6SFODjpXPiy0br6fIOAAAAOI9L90kfNGhQjVNnp06dWulY+/btNXfuXCdWBbhWoK+XooJ8lZZbpJT0fHVqHlrpnLX7julITpGCfb3Up3VkndTVv22Ulu9O16LtaRrdO6FOnilJhmHot82H1a5JsBKiAuvsuQAAAIAr1Ks16UBjEX+K5nG//l02in7+WTHy9fKsk5oGlDePW74rTcWlljp5piR9sjRZd322Wjd98qdKzHX3XAAAAMAVCOmAG4ovn/K+N6PyunTDMDS7fKr7sDqY6m7VoVmIIgJ9lFds1tqUY3XyzI0HsvTSr1skSfsyCvR/6w7WyXMBAAAAVyGkA27Itld6FSPpmw5ma/+xAvl5e2hg25g6q8nDw6R+rcu6vC+ug63Y8opKde+Xa1ViNhQR6CNJemfBTlksdJcHAABAw0VIB9xQTdPdf914SJI0qG2M/H3qZqq7Vf821pDu/OZxE3/cpN1peWoa4qcfxvZViJ+Xdh3N02+bU53+bAAAAMBVCOmAG7LtlV7FNmyzy7deG9a57qa6W/UvX5e+4UCWjuUVO+05P64/qK9W7ZfJJL1xbTfFRQRoTJ8ESdL/5u9kr3YAAAA0WIR0wA1ZR9IPZReqqNRsO77jcI52Hc2Tt6dJg9vX3VR3q6ahfmrbJEiGIS3d5Zwp7/sy8vXvb/+WJI0b3Fq9k8q614/pmyh/b09tPJCtRXUw3R4AAABwBUI64IYiA30U6OMpwyhrmGb1a/koer/WUQrx83ZJbdbR9MXbHR+US80WjZ+xVjlFpTq7ZZjGX9DG9lpEoI9uOLelJOnt+Tsd/mwAAADAHRDSATdkMpnUMrJsynvKCR3ebVPdOzVzSV1SxXXpjp52/tYfO7QmJVPBvl5667ru8vKs+K+oO/q3ko+nh1buydBfyRkOfTYAAADgDgjpgJuybcNW3jwuJT1fmw9ly9PDpAs7NHFZXecmRsrH00MHswq162jlNfOna/mudP2vfIT8xVGdFVf+9Z+oaaifruzRQhKj6QAAAGiYCOmAmzq5w/vsTWVd3c9NjLBtSeYK/j6e6pkYLslxXd6P5RXr/pnrZBjS1T1aaETX2GrP/efAJHmYpAXbjmrjgSyHPB8AAABwF4R0wE3Z9krPKAvp1vXoQzvVfVf3k9nWpTuggZthGHr0mw1KzS5Uq6hAPXNZxxrPbxkZoMvKQ/w7CxhNBwAAQMNCSAfcVPwJ27AdyirQ2pRMSdLFHV0f0geUh/Tlu9IrdJ8/HZ//maLfNh+Wt6dJk6/vrkBfr1Ne889BrSWV/eJi55HcM3o+AAAA4E4I6YCbsk5333eswNYwrkd8uJqE+LmyLElS+6bBigryVUGJWWv2Zp72fbal5uj5nzZLkh4d2l6dmofW6rp2TYM1pEMTGYb07oJdp/18AAAAwN0Q0gE31SzUT96eJhWXWvTZ8r2SpKFuMIouSR4epgpd3k9HYYlZ93y5RkWlFg1sG61b+ybadf2/BpeNpn+/7oD2lS8JAAAAAOo7Qjrgprw8PdQivGw0fXdaWRd1d1iPbnU8pJ/euvQXft6i7YdzFRXkq9eu7ioPD5Nd13eLC1O/1lEyWwx9uHj3adUAAAAAuBtCOuDGWp6wDVmn5iFVbkvmKv1al4X0jQezlJ5bZNe1czal6rMVZbMDXr+mq6KDfU+rhrHlo+kz/tqnIzmFp3UPAAAAwJ0Q0gE3Zl2XLrnPVHermBA/tW8aLMOQluys/Wj6oawCPfrNBknSnQNaaUDb6NOu4bxWETq7ZZiKSy36eMme074PAAAA4C4I6YAbO3EkfWinZi6spGrWgF3bKe9mi6H7Z65TZn6JOjcP1UND2p3R800mk200/fPle5WZX3xG9wMAAABcjZAOuLH2TUMkSe2aBKt1TJCLq6nsxOZxhmGc8vx3F+zUit0ZCvDx1OTru8vH68z/FXR++xi1bxqsvGKzpi3be8b3AwAAAFyJkA64sb6tI/Xa1V31zj/OdnUpVeqZECFfLw8dzi7SjlPsV7567zG98fsOSdKzl3dSYlSgQ2o4cTR9yrI9yisqdch9GwveLwAAAPdCSAfcmMlk0lU9Wigp2v1G0SXJz9tTvRIjJEmLtle/FVt2YYnGz1grs8XQ5d1ideXZzR1ax/DOzZQYFajM/BJN/zPFofduiApLzJq1er9Gvr1UHZ+eowdmrlNWQYmry6pRZn6xXp+7XXM2pbq6FAAAAKcipAM4IwPa1Lwu3TAM/fvbv7X/WIHiIvz1/MhOMpns227tVDw9TPrnwCRJ0oeLd6uwxOzQ+zcUe9Ly9PxPm3XepD/00NfrtW5fpiTp27UHNPTNRVpymtvpOdvvmw/rojcWafIfO3TP9LXal5Hv6pIAAACchpAO4Iz0b1u2Lv3PPelVhuOvV+/XTxsOycvDpMnXdVewn7dT6hjZvbliQ/10JKdI36zZ75Rn1EelZotmb0zVTR//qcGvLdBHS/YoM79EzcP89fDF7TTllp5KiAzQoaxC/ePjP/XM/21SQbF7/JIjM79Y989cp9s/XaWjOUXyMEnFZovemLvd1aUBAAA4DSEdwBlp1yRYMcG+KiyxaPXeYxVe23U0V8/83yZJ0v0XtVX3luFOq8PHy0N3DmglSXpv4S6Vmi1Oe1Z9cDi7UG/9vkP9Xp6vuz9frcU70mQySYPbRevjm8/RokcGa+zg1hrcLka/jO+vm86LlyRNXZasSyYvto2yu4p19Py7tQfkYZLuGthKX93VW5L03boD2nww26X1AQAAOAshHcAZMZlM6l8+5X3RjuPr0otKzbr3y7XKLzarT1Kk7i6fju5M1/ZsqchAH+3LKNCPGw46/XnuxjAMLd2Zpn9+vlp9XpqnN37frtTsQkUE+uifg5K06OHBmnJLL11wVhN5ehxfchDg46XnRnbStFt7qUmIr3an5enKd5fp9d+2qaSOf9lx8uh5UnSgZv2zjyYMO0vnJERoRNdYGYb08uytdVoXAABAXSGkAzhjA8qnvC/efnxN86uzt2nTwWyFB3jrjWu7VQiFzuLv46lb+yVKkt6Zv0sWy6m3hWsIsvJL9PGSPbrg9YW68aM/9evGVJkthnomhOut67pp+YTz9ejQ9oqLCKjxPgPbRuu3+wbq8m6xMlsMTZ63U1e8s1TbD+fUyddR1ej5z/f219knzMB4aEhbeXmYtHD7US3b6Z5r6AEAAM6El6sLAFD/9W1dFtI3H8rW0ZwibTqYpY+W7JEkvXpVVzUJ8auzWm7qHa/3Fu7SjiO5+m3zYQ3t1LTOnl3XNuzP1GfL9+rHDQdVWFI24h3o46krzm6uf5wXr/ZNQ+y+Z2iAt966rrsu6tBET3y/URsPZOvS/y7RIxe30619E+XhhF+2ZOYXa+KPm/Xd2gOSpKToQL16ddcK4dwqPjJQN57bUtOW79VLs7fq+3/1dUpNAAAArkJIB3DGooJ81TE2RJsOZuv7tQf0/qJdkqSbe8frwg5N6rSWED9v3dw7Qf+bv1PvLNipizs2cXg3eVcqKDbrx/UH9fmfe7Vhf5btePumwfrHefEa2b25gnzP/F/tl3aJVa+ECD36zQbN33ZUz/+8RXM3H9ZrV3c95Yi8PX7ffFgTvvvb1hjujgGtdP+FbeXn7VntNfdc0EazVu/Xhv1Z+mXjIV3aJdZh9QAAALiayTCMxjEftFx2drZCQ0OVlZWlkBD7R5kAVO2lX7fqvYW7ZDJJhlEWGr8f27fGsOUs6blF6vfyfBWUmPXprb00oG10ndfgSBaLoe1HcvTVX/s1a/U+ZReWSpJ8PD00vHNT/eO8ePWID3fKLyMMw9CMv/bpuZ82K7/YrEAfTz09oqOuPqfFGT3PntHzqrz1+w698ft2xUcG6PcHBsrbk9VbAADAfdmTQwnpABxi2c403fDRn5IkP28P/Tiun9o0CXZZPc/+uFmfLN2jcxMjNLO8K3h9YBiGDmQWaMP+rPKPTP19IEs55cFckuIi/HXjufG6ukcLRQb51kldKen5evDrdforuayD/4VnxejFUZ0VE2z/UoZKo+f9W+n+i2oePT9ZXlGpBr66QGm5RXr28o4a3TvB7joAAADqCiG9BoR0wDmKSs06+9m5yis268UrOuuGc1u6tJ5DWQUa8Mp8lZgNzbq7t85JiHBpPdU5mlOkDfszbYF8w/4specVVzrP18tD/dtE6cbz4jWwTbRL1mGbLYY+Wrxb//ltu4rNFoUHeOvFKzprWOdmtbr+5NHzVtGBes2O0fOTfbZir578fqOigny04OHBDpnmDwAA4AyE9BoQ0gHnWbozTQczC3RVjzObCu0oj32zQTP+2qfB7aI15ZZeri5HWQUl+nt/ljYcyNSGfWWh/GBWYaXzvDxMatc0WF1ahKpLizB1aRGqtk2C3WZK99bUbN0/c722HCrbq/yK7s31zGUdFervXe01jhg9P1mJ2aKLXl+o5PR83XdhG913YdvTvhcAAIAzEdJrQEgHGo/ktDyd/58FshjSz/f2U8fY0Dp7dn5xqTYdzNb6fWXT1Tfsz9KetLxK55lMUlJ0UFkgbx6qLnFh6tAsxCVr+e1RXGrRW39s17sLdsliSM1C/fTqVV3Vr01UhfMcPXp+sp83HNLY6WsU4OOphQ8PVnRw3Uz/BwAAsAchvQaEdKBxuffLtfq/9Qd1SedmevvGs536rKyCEn20eLfmbj6s7YdzVNU27S0jAtS5Rai6lo+Sd4wNUbBf9SPQ7m713mN68Kt1Sk7Pl1TW0f+xYWfJ38fTKaPnJzMMQyPfWab1+zI1une8nr28k8PuDQAA4CiE9BoQ0oHGZWtqtoa+uVgmk/T7AwOVFB3k8GcUlpj16fJkvT1/l7IKSmzHm4T4lk1XLx8h79I8VOGBPg5/vqvlF5dq0i9b9dmKvZKkVlGB6hAbop82HCr73MGj5ydbvitd13+4Ql4eJv3+wEAlRAU65TkAAACni5BeA0I60PjcPm2Vft9yWFf3aKFXr+7qsPuaLYa+WbNfb87dbltb3iYmSOPOb63zWkWqSYj9nc/rs0Xbj+qRWRuUml32Xjhr9LwqY6as1IJtR3VJl2Z6+wbnzpgAAACwFyG9BoR0oPFZm3JMV7yzTF4eJi14eJBahAec0f0Mw9DvW47o1Tlbtf1wriQpNtRP913UVlee3UKeLui87i6y8kv04i9btOtorv59yVlOGz0/2ZZD2Ro+ebEMQ/phbF91jQurk+cCAADUBiG9BoR0oHG68aMVWrozXTf3jtfEM1i3/Fdyhl7+datW7S3bLzzU31vjBrfWTb3j3b7ZW0P3wFfr9O2aA+rdKlLT7zjXLXYYAAAAkOzLoe6xnw8AONnYQa0lSTP+2qejOUV2X78tNUe3T/tLV7+3XKv2HpOft4f+NShJix4ZrDsGtCKgu4EHLmorH08PLd+droXbj7q6HAAAgNNCSAfQKPROilS3uDAVlVr08ZI9tb7uQGaBHvxqvYa+tUi/bzkiTw+Tru/VUgsfHqxHhravcW9w1K0W4QG6uU+8JOmlX7fKUlV7fQAAADdHSAfQKJhMJo0bXDaa/vmKvcrKL6nx/GN5xXr+p80a/NoCfbNmvwxDGt65qX67f4Amjerc6JrC1Rf/GtRawX5e2pqaox/WH3B1OQAAAHYjpANoNM5vH6P2TYOVW1SqacuTqzwnv7hUb8/fqQGvzNdHS/aouNSi3q0i9f3Yvnrnxh5O2cINjhMe6KN/DkqSJL02Z7sKS8wurggAAMA+hHQAjYaHh8kW4D5Zukd5RaW210rMFn3x514NfHWBXp2zTTlFpTqrWYim3dpL0+84V93oFl5v3No3UU1D/HQgs0Cfl+/dDgAAUF8Q0gE0Kpd2iVVCZIAy80v05coUGYahnzcc0pA3Funx7zbqaE6R4iL89dZ13fTzPf00sG00XcLrGT9vT91/URtJ0v/m71R2Yc1LGxo7i8XQun2ZzDoAAMBNENIBNCqeHibdPbBsNP39Rbs18u2lGjt9jfak5Sky0EfPjOigPx4YpMu7NZdHI97vvL678uwWah0TpMz8Er23YJery3FbhmFowrd/a+TbSzV88mJt2J/p6pIAAGj0COkAGp0rzm6upiF+OppTpPX7sxTo46n7LmyjhY8M1pi+ifLx4l+N9Z2Xp4ceHdpeUtnShtSsQhdX5J7eXbhLM1ftkyTtPpqnUe8s03//2KFSs8XFlQEA0Hi59P9EFy1apBEjRig2NlYmk0nff/99ra9dunSpvLy81K1bN6fVB6Bh8vXy1JOXdlBMsK/G9EnQwkcG674L2yrI18vVpcGBLjwrRufEh6uwxKK3/tju6nLczk8bDuqV2dskSQ9f3E7DOzdVqcXQf+Zu1zXvL9fe9DwXVwgAQOPk0pCel5enrl276u2337bruszMTI0ePVoXXHCBkyoD0NBd0qWZVj5+oZ65rKOignxdXQ6cwGQyacLwstH0mX/t084juS6uyH2s3ntMD3y1XpJ0S98EjR3cWm/fcLZev6argn29tCYlU8PeWqwZ5X0bAABA3XFpSB82bJief/55XXHFFXZdd/fdd+uGG25Q7969nVQZAKAh6BEfoSEdmshiSK/M3urqctxCSnq+7vh0lYpLLbrwrCZ64pIOksp+qTHq7Bb69b7+6pUYofxisx779m/d8elqpeUWubhqAAAaj3q38HLKlCnavXu3nn766VqdX1RUpOzs7AofAIDG45Gh7eRhkn7bfFir92a4uhyXysov0ZipK5WRV6xOzUM0+fpu8jypQWKL8AB9ecd5mjCsvbw9Tfp9y2ENfXOR/thy2EVVAwDQuNSrkL5jxw499thj+vzzz+XlVbu1o5MmTVJoaKjtIy4uzslVAgDcSeuYYF1zTtm/+1/6davTp29bLIb+2HJYn6/YqxI3asBWXGrRXZ+v0u6jeYoN9dPHN/dUgE/V/y319DDproFJ+mFsP7VtEqS03GLdNm2VJnz7t/KLS+u4cgAAGpd6E9LNZrNuuOEGTZw4UW3btq31dRMmTFBWVpbtY9++fU6sEgDgju67sK38vD30V/Ix/b7liFOeUVRq1ld/7dNFbyzUbdNW6YnvN2rMlJXKKnD9Pu3WrdZW7M5QkK+XPh7TU01C/E55XYfYEP3fuH66vV+iJOnLlSka/tZirU055uySAQBotEyGm3SEMZlM+u677zRy5MgqX8/MzFR4eLg8PT1txywWiwzDkKenp3777Tedf/75p3xOdna2QkNDlZWVpZCQEEeVDwBwc6/M3qp3FuxSm5gg/Tq+v7w8HfN76uzCEk3/M0WfLNmjIzlla7eD/bxkthjKLzYrKTpQU8b0UsvIAIc873RM/mOHXp+7XZ4eJn0ypqcGto22+x7Ldqbpwa/X61BWoTw9TBo3uLXGnd9a3g56HwEAaMjsyaH15r+sISEh+vvvv7Vu3Trbx91336127dpp3bp1Ovfcc11dIgDAjd01MElhAd7acSRX3645cMb3S80q1KRftqjPpHl66detOpJTpKYhfnp8+Fla9tj5+vru3moW6qddR/M08p2lWpXsmvXw3689oNfnlm1B9+zlHU8roEtSn9ZRmj1+gC7rGiuzxdBbf+zQVe8t1+6jdM0HAMCRXBrSc3NzbYFbkvbs2aN169YpJSVFUtlU9dGjR0uSPDw81KlTpwofMTEx8vPzU6dOnRQYGOiqLwMAUA+E+ntr3ODWkqTX525XQbH5tO6z43COHv56vfq/Mk/vL9qt3KJStW0SpNeu7qpFjwzWHQNaKdjPWx1jQ/X92L7q3DxUGXnFuuHDP/XDujP/5YA9Vu7J0COzNkiS7hzQSjeeG39G9wsN8Nbk67vrreu6KcTPS+v3ZeqSyUv0+Yq9bNUGAICDuDSkr1q1St27d1f37t0lSQ888IC6d++up556SpJ06NAhW2AHAOBM3dQ7Xs3D/JWaXaipy5JrfZ1hGFq5J0O3Tf1LF72xSF+v3q8Ss6FeiRH6ZMw5mj1+gK7q0UI+XhX/s9okxE8z7zpPQzo0UbHZovEz1unN37fXSaDdk5anOz9bpWKzRUM7NtVjQ9s77N6Xd2uu2fcNUJ+kSBWUmPXE9xt127RVOpJT6LBnAADQWLnNmvS6wpp0AGjcvl2zXw98tV7Bfl5a/MhghQX4VHuuxWLot82H9f6iXVqbkilJMpmkizs01Z0DW+nsluG1eqbFYujlOVv1/sLdkqTLu8Xq5Su7yM/b8xRXnp5jecW64p2lSk7PV9e4MM244zz5+zj+WRaLoU+W7tErc7apuNSiiEAfvTSqs4Z0bOrwZwEAUJ/Zk0MJ6QCARsViMXTJf5doy6Fs3dE/UY9f0qHSOYUlZn239oA+XLRbu9PyJEk+Xh66qkcL3d4vUa2ig07r2TNWpuiJ7zeq1GKoR3y4PriphyKDfM/o6zlZUalZ//joT/2VfEzNw/z1/di+ig527DNOti01R/fNXKcth7IlSdeeE6cnR3RQkG/ttksFAKChI6TXgJAOAFiw7YjGTPlLPp4emvfQQLUIL+u8npVfos//3KspS5OVllvWqT3Ez0ujeyfo5j4JDgm7S3em6e7PVyunsFRxEf6aMqanWscEn/F9pbJp+ffNXKcf1h1UsJ+Xvv1nH7Vp4ph7n0pRqVmvz92uDxbtlmFILSMC9Ma1XdUjPqJOng8AgDsjpNeAkA4AMAxDN3z4p5bvTteVZ7fQg0Pa6pMle/TlyhTllTeUiw310239W+nannEOHxHeeSRXt079SykZ+Qr289K7N/ZQvzZRZ3zf1+du1+Q/dsjLw6Spt/RyyD3t9efudD3w1XodyCyQh0m6pW+iHhzSVgE+jKoDABovQnoNCOkAAElavy9Tl7+9VCaT5GkyqdRS9p/D9k2DddfAVrq0S6xT9wDPyCvWnZ+u0qq9x+TpYdLzIzvp+l4tT/t+36zerwe/Xi9JevnKzrq25+nf60xlF5Zo4v9t1jdr9kuSWoT764UrOp/29m8AANR3hPQaENIBAFZjp6/RzxsOSZJ6t4rUXQNbaWDbaJlMpjp5flGpWY9987e+W1u2NdudA1rp0aHt5elh3/OX70rX6E/+VInZ0L8GJekRB3ZyPxMLth3R499t1IHMAknSqO7N9cSlHRQRWH2zPgAAGiJCeg0I6QAAq6z8En35V4p6t4pU17gwl9RgGIb+O2+nXp+7XZJ0UYcmeuu6brWeHr7zSK5GvbNU2YWluqRLM/33uu7ysDPkO1NeUan+89t2TVm2R4YhRQT66OkRHXRZ19g6+2UIAACuRkivASEdAOCO/m/9QT309XoVl1rUqXmIPhrdU01D/Wq8Jj23SCPfWap9GQU6u2WYpt9xntO2dTtTa1OO6bFv/ta2wzmSpEHtovX8yE62pn0AADRk9uRQ5y22AwAAtXZZ11h9ecd5igz00cYD2Rr59lJtPJBV7fmFJWbd8ekq7csoUMuIAH04+hy3DeiS1L1luH68p58eGtJWPp4eWrDtqIa8sUhTlu6R2dKoxgsAAKgRIR0AADfRIz5c34/tqzYxQUrNLtQ17y/X75sPVzrPYjH04NfrtSYlU6H+3vpkTE+H77fuDD5eHhp3fhv9Mr6/eiVEKL/YrIk/btaV7y7TttQcV5cHAIBbIKQDAOBG4iIC9M2/+qh/myjlF5t1x2er9NHi3Tpxddprv23TzxsOydvTpPf+0UOtY4JcWLH9WscEacad5+mFKzop2NdL6/Zl6tL/Ltbrv21TUanZ1eUBAOBShHQAANxMiF/Z6PgN57aUYUjP/7xFj3+/USVmi2b+laJ3FuySJL00qot6J0W6uNrT4+Fh0o3nxmvuAwN1UYcmKjEbmjxvp4a/tVh/JWe4ujwAAFyGxnEAALgpwzD08ZI9euGXLTIMqVtcmDYeyFKpxdC9F7TRAxe1dXWJDmEYhmZvTNVT/7dJR3OKJEn/OK+lHh3aXsF+3k55psViaHdartbvy9KG/ZnafjhXEUE+SogMUHxkoBIiAxUfGaCYYF+XdqHPKSxRclq+ktPzlJyWp+T0fO1Nz1OpxVBkoI8iAn0UEeRT/mdfRdr+7KPIQF/5+7hvnwIAaEzo7l4DQjoAoL6Zu/mwxs9Yq/zisqngl3eL1ZvXdmtwW5hl5ZfoxV+2aOaqfZKkpiF+em5kJ13UockZ3dcwDB3ILNCG/Vlavz9TG/ZlaeOBLOUUlZ7yWn9vT8VHBig+MqA8uAeWBfmoQDUL8XPIdnfZhSXHA3hanvak52lver6S0/KUnld8Rvf29/YsC+xBx4O79c9ln1c8Huhbu63/AAD2IaTXgJAOAKiPNh7I0gNfrVNCZKD+e0N3+Xo13BHSZbvS9O9v/1Zyer4k6ZLOzfT0ZR0UE1zzlnRW6blFtkC+fl+mNuzPqjLs+nt7qlPzEHVpEaazmoUoM7+4LByXh+T9x/JVU+N5Hy8PtYwIOGH0/fgofGyYn7w8j68qzCoo0d70PO1JOx7Ak9PLgnnGKYJ4VJCvEiIDlBB1/Bk+Xh7KyCtWRl6x0nOLlZFXpHTbn8s+is2WWr1fJ+qVEKHRfeJ1ccem8vZkVSQAOAohvQaEdAAA3F9hiVlv/r5DHy7eLbPFUIifl564pIOuPqdFhRkEuUWl+ts6Qr4/U+v3ZelAZkGl+3l5mNS+WbC6tAhT1xah6tIiTG1igioE6ZMVl1p0ILOgLLSfMNV8b3q+9h3LV4m5+v+F8vIwKS4iQCF+Xtp3rKBWQTwxqiyAJ0YFnjByH3BaU/4Nw1BuUWlZiM8rVkZ5eE/LK7L9OT3veKBPzytSYcnxUB8T7Ksbzm2pG3q1VExI7X45AgCoHiG9BoR0AADqj40HsvTYtxu08UC2JKlPUqSGdGiiDQeytGF/lnYdzVVV/yeTFB2ori3C1KVFqLrEhalDsxCH7iNfarboUFahbTS8QojPyFdxaeVRbGsQT4gMLB8VLw/jUYEKcoNp5oeyCvTlyn2a/meK0nLLegN4eZg0tFNT3dwnQefEhze4JRYAUFcI6TUgpAMAUL+Umi36ZOkevT53e4XRXqvmYf5lYbx8lLxTi1CFOKnhXG1YLIZSs8sCfHZBiVqEu08Qr43iUotmb0rVp8uStWrvMdvx9k2DdXOfBF3eLVYBPvXjawEAd0FIrwEhHQCA+mlvep5en7tdWQUlFaatRwf7urq0BmvTwSx9tnyvvl93wPYLkmA/L11zTpxuOi9eCVGBLq4QAOoHQnoNCOkAAAD2ycov0der9+mzFXu1t7yhnyQNbBut0b3jNahdjDwd0OkeABoqQnoNCOkAAACnx2IxtHDHUX22fK/mbzti6wcQF+Gvf5wbr2vOiVN4oI9riwQAN0RIrwEhHQAA4MztTc/T5yv26qtV+5VVUCJJ8vXy0OXdYjW6d4I6NQ91cYXVM4yyvgE7j+Rq55Fc7Tpa9s99GQWKjwxQn6RI9U6KVJcWYWxFB8AhCOk1IKQDAAA4TkGxWT+uP6ipy5K1+VC27fjZLcM0uneChnVuKl8vx3XWt0eJ2aK96fm2IL7rSK52lv8zr9h8yusDfDzVMyFCfZIi1ScpSh1iQ5jWj9Nmthj8/DRihPQaENIBAAAczzAMrUk5pk+X79Uvfx+y7SMf5Oul6GBfhfh7K8zfW6FVfQRUPhbg41nrLd9yi0q1u3w0/MSR8b3p+Sq1VP2/up4eJsVHBigpOkitY4LUOjpILcL9te1wjpbvStfy3enKzC+pcE2In5fObRWp3q0i1ad1pNrGBMuD0FWnDMNQWm6xdhzO0fbDOfL0MKl3UqSSooPcbovAErNFfyVnaMG2o5q39Yh2Hc1V5+ahGtg2WoPaRatrizB5MVOj0SCk14CQDgAA4FxHcgo1c+U+ffFnilKzC0/rHt6eJoX6eyukmmCfU1hqC+OHsqp/RoCPp5Kig5QUHVgWxmOClBQdpPjIQPl4VR+QLBZDW1NztGxXmpbvStfKPRnKKSqtcE5EoI96tyqbGt87KVKtogLdLijWZxl5xdp+OEc7Dudo2+EcbT+cqx2Hc3TspF+eSFLTED/1bR2lfm0i1bd1lGKC/VxQsXQ0p0gLth3R/G1HtHh7WqWfmROF+Hmpf5toDWwbrQFto9U01DU1o24Q0mtASAcAAKgbpWaLdh3NU2Z+sbIKSmwf2Sf8ObOK49ZReHtEBfmUhfHyUfHWMWV/bhbi55DR7lKzRRsPZmv5rnQt25WmVcnHVFBSccp8kxDfslH2pCj1TopUXETAGT+3ruQXl2pralkg9vTwUJi/t8IDvRXq76Pw8pkOzhr1zcov0fYjOdpW/vzth3O140iO0nKLqzzfZJLiIwLUpkmw8otL9VfyMRWXWiqc065JsPq2jlL/NlHqlRihQF8vp9RusRj6+0CW5m0tC+Yb9mdVeD0i0EeD2kZrcPsYdWoeqtV7j2nBtiNavCPN1svBqn3TYA1sWxbaeySEu2yZCJyDkF4DQjoAAID7MgxDBSVmZeaXVAj21hBvPe7n7VFhZDwsoG67yheXWrR+f6aW7UzX8t1pWrM3U8XmikGxRbi/ereK1LmtItU6JkgJkQF1XmdV0nOLtOlgtjYfyi7758Es7UnLUzUrA2yC/bwUHuCjsABvhQWUhfcw/xP+fPJrAT4K9vWy/ZIku7DEFsLLRsjL/nkkp6jaZ8ZF+KttTLDaNAlWu6ZBahMTrNYxQfLzPh5gC0vMWpV8TEt2pmnpzjRtPJilExOOl4dJZ7cMLx9pj1LXFqFn9AuH7MISLdmRpnlbj2jBtqNKy61Yf6fmITq/XYwGt49RlxZhVa5DN1sMrd+fqYXbjmrh9qNavz+zQs0BPp7qkxSlge2iNahtdL36hQ+qRkivASEdAAAAjlZYYtaavce0rHykfcP+rCrXw4f6eyshMkAtIwOVEBmg+BP+GRXk49Dp8oZhaF9GgTYdzDohlGfpcHbVoTg62FftmwbLZDIpK79Yx/JLlJlfrOzC6qdsn4qHSQoL8JGXh6nGMN48zF9tmgSpbZPg8o+yX8AE+Ng/Ap6RV6zlu9K1ZGealuw8qn0ZBRVeD/Yt6y3Qr3Wk+rWJVlJ0zcsUDMPQrqO5mrf1iOZtPaJVyccqfG8DfTzVv020zm8fo0HtohUTYv+09WN5xVq8M00Lth3Rou1plYJ/q6hADWgbrYHtonVeYqT8fRhlr28I6TUgpAMAAMDZcotK9VdyhlbsStfafZlKSc8/5fr8QB/PstAeVTG8J0QGKibYt8Zp+8WlFu04klM+Ml4WyLcczK5yTbTJJCVGBuqs2BB1jA1Rh2Yh6hAbUu067lKzxbY0ITO/WMfyjv85M79Ex8r/mVlQ9lpWQdmx/Co66DcN8bOF8XZNgtWmSZDaNAlWkJOmo0tSSnq+LbAv3ZleaZp5VevZC0vMWr47XfPLp7GfHPRbRQfaRst7JkTU2N/AXhbL/7d390FRnWcfx3+7wKICCyLIS+RFo9GgSIlGSjI1RogvTRltMiNJHYvGmjHBjsSx6diZRJ1JirFtRk1t006nNclETWyjTp221hLBxscYxNCosSYSLTSiVI28qYC79/MHsnFVUBPxnJXvZ2Znd+9zH/Zir7kGrnPuPWv0cW2Dyj5pP8te8Z8v5LnkoEBosFNZg/r5lsZf6yBDdzLGqNXjVeuF9lvLxftWj1ctbV61ejxquWS8zeOVx2vk8Rpd8Bp5vUYec/Hea+Qx8o11zPN4jbwdz31zJY/Xe3Fe+z4LJtyluK9wgORWoUnvAk06AAAArHCu1aPq02d19FSz/nOqWUdPnW2/P3lWx+rPqav/ynuFOJUSHaaUfn2UGtN+33rB62vKP61rvOpn+V1BTg2Nj1BaglvD72hvyofGu7u1Ke7QcsGj+rNt+uJsm1oueJTSL0yRvUO6/XW74vEafXysQf88/D/tPHzyqp9nHxQTpmP153S+7ctxV5BTWYOiNX5Yf40f1l8p/cJuWcwN59v0f4dPqeyTOpUd+p+OXXahxD6uIAU7HXI6HQpyXHLvUPvji88djvZvNXA62m9Bvn3UPnZxXpCzfa7Ha75sui941XLB49eAt1xszu1ia9FYDY2PsDqMTtGkd4EmHQAAAHbTcsGjmtPnfM179SVNfM0X5/zOpHbG3StYaYluDU+M9DXld8aGK4Sv+erU+TaPyo+e9n2e/cCxBt/Bknh3Lz14sSm/f3C/r7T0/mYzxuhwXZPvLPvuz05fcS0EK4UEORQaHCRXsFOhwU65gp1yBTkVGtJ+HxLkVHBQ+0GC4IsHEPwPGHw55jvw4JTfwYeOucGX7BvkdCj/3iTFhIda/RZ0iia9CzTpAAAACCRtHq+OnTnnd+b9P6ea5XA4Ljbl7UvWB/TtzVfAfU2nm1v1YfUXSojsrbsTImz/fp5r9aiu8fwlS8LlWxp+6b3XtJ8Zv3Qpubk45ltCfnFex9Lz4CCHr9HuaLwvbbhDQ4LkCnJ+2ZAHOW/KNyncrmjSu0CTDgAAAAC4lW6kD2XtCwAAAAAANkGTDgAAAACATdCkAwAAAABgEzTpAAAAAADYBE06AAAAAAA2QZMOAAAAAIBN0KQDAAAAAGATNOkAAAAAANgETToAAAAAADZBkw4AAAAAgE3QpAMAAAAAYBM06QAAAAAA2ARNOgAAAAAANkGTDgAAAACATVjapO/YsUN5eXlKTEyUw+HQpk2bupz/zjvv6KGHHlJsbKzcbreys7O1devWWxMsAAAAAADdzNImvbm5WRkZGVq9evV1zd+xY4ceeugh/eUvf1FFRYUefPBB5eXl6cMPP+zmSAEAAAAA6H4OY4yxOghJcjgc2rhxo6ZOnXpD+w0fPlz5+fl6/vnnr2t+Q0ODIiMjVV9fL7fb/RUiBQAAAADg+t1IHxp8i2LqFl6vV42NjYqOju50TktLi1paWnzPGxoabkVoAAAAAADcsIBu0n/+85+rqalJ06ZN63ROcXGxli5desU4zToAAAAA4Fbo6D+vZyF7wC53X7t2rebMmaPNmzcrNze303mXn0n//PPPlZaW9nXDBQAAAADghtTU1GjAgAFdzgnIM+nr16/XD37wA23YsKHLBl2SQkNDFRoa6nseHh6umpoaRUREyOFwdHeoX0tDQ4OSkpJUU1PD5+cDAPkKLOQr8JCzwEK+Ag85CyzkK7CQr8Bzs3NmjFFjY6MSExOvOTfgmvR169bpiSee0Pr16/Xwww/f8P5Op/OaRy7sxu12U8wBhHwFFvIVeMhZYCFfgYecBRbyFVjIV+C5mTmLjIy8rnmWNulNTU06fPiw7/mRI0dUWVmp6OhoJScna9GiRfr888/1+uuvS2pf4l5QUKCVK1cqKytLx48flyT17t37un9hAAAAAADsytLvSd+zZ48yMzOVmZkpSVqwYIEyMzN9X6dWW1ur6upq3/zf/va3unDhggoLC5WQkOC7zZ8/35L4AQAAAAC4mSw9kz5u3Lgur263Zs0av+elpaXdG5DNhIaGavHixX6fqYd9ka/AQr4CDzkLLOQr8JCzwEK+Agv5CjxW5sw2V3cHAAAAAKCns3S5OwAAAAAA+BJNOgAAAAAANkGTDgAAAACATdCkAwAAAABgEzTpNrV69WqlpqaqV69eysrK0gcffGB1SOjEkiVL5HA4/G7Dhg2zOixctGPHDuXl5SkxMVEOh0ObNm3y226M0fPPP6+EhAT17t1bubm5+vTTT60JFpKunbOZM2deUXOTJk2yJtgerri4WPfee68iIiLUv39/TZ06VYcOHfKbc/78eRUWFqpfv34KDw/Xo48+qhMnTlgUMa4nZ+PGjbuixubOnWtRxD3br3/9a40cOVJut1tut1vZ2dn661//6ttOfdnPtXJGfdnbsmXL5HA4VFRU5Buzos5o0m3orbfe0oIFC7R48WLt3btXGRkZmjhxourq6qwODZ0YPny4amtrfbf33nvP6pBwUXNzszIyMrR69eqrbl++fLlWrVqlV199Vbt371ZYWJgmTpyo8+fP3+JI0eFaOZOkSZMm+dXcunXrbmGE6FBWVqbCwkK9//772rZtm9ra2jRhwgQ1Nzf75jzzzDP685//rA0bNqisrEzHjh3TI488YmHUPdv15EyS5syZ41djy5cvtyjinm3AgAFatmyZKioqtGfPHo0fP15TpkzRgQMHJFFfdnStnEnUl12Vl5frN7/5jUaOHOk3bkmdGdjOmDFjTGFhoe+5x+MxiYmJpri42MKo0JnFixebjIwMq8PAdZBkNm7c6Hvu9XpNfHy8+dnPfuYbO3PmjAkNDTXr1q2zIEJc7vKcGWNMQUGBmTJliiXxoGt1dXVGkikrKzPGtNdTSEiI2bBhg2/OwYMHjSSza9cuq8LEJS7PmTHGPPDAA2b+/PnWBYUu9e3b1/zud7+jvgJIR86Mob7sqrGx0QwZMsRs27bNL0dW1Rln0m2mtbVVFRUVys3N9Y05nU7l5uZq165dFkaGrnz66adKTEzUoEGDNH36dFVXV1sdEq7DkSNHdPz4cb96i4yMVFZWFvVmc6Wlperfv7+GDh2qp556SqdOnbI6JEiqr6+XJEVHR0uSKioq1NbW5ldjw4YNU3JyMjVmE5fnrMObb76pmJgYjRgxQosWLdLZs2etCA+X8Hg8Wr9+vZqbm5WdnU19BYDLc9aB+rKfwsJCPfzww371JFn3dyy4234yvpKTJ0/K4/EoLi7ObzwuLk7//ve/LYoKXcnKytKaNWs0dOhQ1dbWaunSpfrWt76l/fv3KyIiwurw0IXjx49L0lXrrWMb7GfSpEl65JFHNHDgQFVVVeknP/mJJk+erF27dikoKMjq8Hosr9eroqIi3X///RoxYoSk9hpzuVyKiorym0uN2cPVciZJ3/ve95SSkqLExER99NFH+vGPf6xDhw7pnXfesTDanmvfvn3Kzs7W+fPnFR4ero0bNyotLU2VlZXUl011ljOJ+rKj9evXa+/evSovL79im1V/x2jSga9p8uTJvscjR45UVlaWUlJS9Pbbb2v27NkWRgbcnh577DHf4/T0dI0cOVJ33nmnSktLlZOTY2FkPVthYaH279/PNTkCSGc5e/LJJ32P09PTlZCQoJycHFVVVenOO++81WH2eEOHDlVlZaXq6+v1xz/+UQUFBSorK7M6LHShs5ylpaVRXzZTU1Oj+fPna9u2berVq5fV4fiw3N1mYmJiFBQUdMUVA0+cOKH4+HiLosKNiIqK0l133aXDhw9bHQquoaOmqLfANmjQIMXExFBzFpo3b562bNmi7du3a8CAAb7x+Ph4tba26syZM37zqTHrdZazq8nKypIkaswiLpdLgwcP1qhRo1RcXKyMjAytXLmS+rKxznJ2NdSXtSoqKlRXV6d77rlHwcHBCg4OVllZmVatWqXg4GDFxcVZUmc06Tbjcrk0atQolZSU+Ma8Xq9KSkr8PssC+2pqalJVVZUSEhKsDgXXMHDgQMXHx/vVW0NDg3bv3k29BZD//ve/OnXqFDVnAWOM5s2bp40bN+rdd9/VwIED/baPGjVKISEhfjV26NAhVVdXU2MWuVbOrqayslKSqDGb8Hq9amlpob4CSEfOrob6slZOTo727dunyspK32306NGaPn2677EVdcZydxtasGCBCgoKNHr0aI0ZM0YrVqxQc3OzZs2aZXVouIqFCxcqLy9PKSkpOnbsmBYvXqygoCA9/vjjVocGtR80ufTo9JEjR1RZWano6GglJyerqKhIL7zwgoYMGaKBAwfqueeeU2JioqZOnWpd0D1cVzmLjo7W0qVL9eijjyo+Pl5VVVV69tlnNXjwYE2cONHCqHumwsJCrV27Vps3b1ZERITv83mRkZHq3bu3IiMjNXv2bC1YsEDR0dFyu9364Q9/qOzsbH3zm9+0OPqe6Vo5q6qq0tq1a/Xtb39b/fr100cffaRnnnlGY8eOveJridD9Fi1apMmTJys5OVmNjY1au3atSktLtXXrVurLprrKGfVlPxEREX7X5JCksLAw9evXzzduSZ1123Xj8bW88sorJjk52bhcLjNmzBjz/vvvWx0SOpGfn28SEhKMy+Uyd9xxh8nPzzeHDx+2OixctH37diPpiltBQYExpv1r2J577jkTFxdnQkNDTU5Ojjl06JC1QfdwXeXs7NmzZsKECSY2NtaEhISYlJQUM2fOHHP8+HGrw+6RrpYnSeYPf/iDb865c+fM008/bfr27Wv69Oljvvvd75ra2lrrgu7hrpWz6upqM3bsWBMdHW1CQ0PN4MGDzY9+9CNTX19vbeA91BNPPGFSUlKMy+UysbGxJicnx/z973/3bae+7KernFFfgeHyr8mzos4cxhjTfYcAAAAAAADA9eIz6QAAAAAA2ARNOgAAAAAANkGTDgAAAACATdCkAwAAAABgEzTpAAAAAADYBE06AAAAAAA2QZMOAAAAAIBN0KQDAAAAAGATNOkAAOCmSk1N1YoVK6wOAwCAgESTDgBAAJs5c6amTp0qSRo3bpyKiopu2WuvWbNGUVFRV4yXl5frySefvGVxAABwOwm2OgAAAGAvra2tcrlcX3n/2NjYmxgNAAA9C2fSAQC4DcycOVNlZWVauXKlHA6HHA6Hjh49Kknav3+/Jk+erPDwcMXFxWnGjBk6efKkb99x48Zp3rx5KioqUkxMjCZOnChJevnll5Wenq6wsDAlJSXp6aefVlNTkySptLRUs2bNUn19ve/1lixZIunK5e7V1dWaMmWKwsPD5Xa7NW3aNJ04ccK3fcmSJfrGN76hN954Q6mpqYqMjNRjjz2mxsbG7n3TAACwIZp0AABuAytXrlR2drbmzJmj2tpa1dbWKikpSWfOnNH48eOVmZmpPXv26G9/+5tOnDihadOm+e3/2muvyeVyaefOnXr11VclSU6nU6tWrdKBAwf02muv6d1339Wzzz4rSbrvvvu0YsUKud1u3+stXLjwiri8Xq+mTJmi06dPq6ysTNu2bdNnn32m/Px8v3lVVVXatGmTtmzZoi1btqisrEzLli3rpncLAAD7Yrk7AAC3gcjISLlcLvXp00fx8fG+8V/+8pfKzMzUT3/6U9/Y73//eyUlJemTTz7RXXfdJUkaMmSIli9f7vczL/18e2pqql544QXNnTtXv/rVr+RyuRQZGSmHw+H3epcrKSnRvn37dOTIESUlJUmSXn/9dQ0fPlzl5eW69957JbU382vWrFFERIQkacaMGSopKdGLL7749d4YAAACDGfSAQC4jf3rX//S9u3bFR4e7rsNGzZMUvvZ6w6jRo26Yt9//OMfysnJ0R133KGIiAjNmDFDp06d0tmzZ6/79Q8ePKikpCRfgy5JaWlpioqK0sGDB31jqampvgZdkhISElRXV3dDvysAALcDzqQDAHAba2pqUl5enl566aUrtiUkJPgeh4WF+W07evSovvOd7+ipp57Siy++qOjoaL333nuaPXu2Wltb1adPn5saZ0hIiN9zh8Mhr9d7U18DAIBAQJMOAMBtwuVyyePx+I3dc889+tOf/qTU1FQFB1//n/2Kigp5vV794he/kNPZvvDu7bffvubrXe7uu+9WTU2NampqfGfTP/74Y505c0ZpaWnXHQ8AAD0Fy90BALhNpKamavfu3Tp69KhOnjwpr9erwsJCnT59Wo8//rjKy8tVVVWlrVu3atasWV022IMHD1ZbW5teeeUVffbZZ3rjjTd8F5S79PWamppUUlKikydPXnUZfG5urtLT0zV9+nTt3btXH3zwgb7//e/rgQce0OjRo2/6ewAAQKCjSQcA4DaxcOFCBQUFKS0tTbGxsaqurlZiYqJ27twpj8ejCRMmKD09XUVFRYqKivKdIb+ajIwMvfzyy3rppZc0YsQIvfnmmyouLvabc99992nu3LnKz89XbGzsFReek9qXrW/evFl9+/bV2LFjlZubq0GDBumtt9666b8/AAC3A4cxxlgdBAAAAAAA4Ew6AAAAAAC2QZMOAAAAAIBN0KQDAAAAAGATNOkAAAAAANgETToAAAAAADZBkw4AAAAAgE3QpAMAAAAAYBM06QAAAAAA2ARNOgAAAAAANkGTDgAAAACATdCkAwAAAABgE/8P6stU6XbRIlkAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -725,16 +719,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training time: 20 seconds\n" + "Training time: 58 seconds\n" ] } ], "source": [ "vqc = VQC(\n", + " sampler=sampler,\n", " feature_map=feature_map,\n", " ansatz=ansatz,\n", " optimizer=optimizer,\n", - " quantum_instance=quantum_instance,\n", " callback=callback_graph,\n", ")\n", "\n", @@ -754,7 +748,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "developmental-crazy", "metadata": {}, "outputs": [ @@ -762,7 +756,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Quantum VQC on the training dataset using RealAmplitudes: 0.57\n", + "Quantum VQC on the training dataset using RealAmplitudes: 0.58\n", "Quantum VQC on the test dataset using RealAmplitudes: 0.63\n" ] } @@ -785,13 +779,13 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "convinced-seven", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/IAAAIjCAYAAACgdyAGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAADGq0lEQVR4nOzdd3yT9fYH8M+TtEn33nvRMgpl7ykoQ0RABXEgOHCA4r5yve6B4ub+HFdQwQlO3KBC2ZuyR/feezdtk+f3R5pA6SBpM9vP+/Xq60WfPHlykgboyfd8zxFEURRBRERERERERFZBYu4AiIiIiIiIiEh3TOSJiIiIiIiIrAgTeSIiIiIiIiIrwkSeiIiIiIiIyIowkSciIiIiIiKyIkzkiYiIiIiIiKwIE3kiIiIiIiIiK8JEnoiIiIiIiMiKMJEnIiIiIiIisiJM5ImIerDnn38egiCgpKTkiueGhYVhyZIlxg/qMhs2bIAgCMjIyDD5Yx85cgRjx46Fo6MjBEHAiRMnTB6DLsz1szE0c/6szUkQBDz//PPmDgOAdf4MNP+OERHRRUzkiYiszNmzZ3HbbbchMDAQcrkcAQEBuPXWW3H27Flzh9apV199FVu2bDF3GFpNTU246aabUFZWhnfeeQdffPEFQkNDzRbP/v378fzzz6OiosJsMZD1ycvLw/PPP9+tD6E++OADbNiwwWAxdUVdXR2ef/557Ny506xxEBFZC0EURdHcQRARkW5+/PFHLFq0CB4eHrjrrrsQHh6OjIwMfPLJJygtLcWmTZswb9487fnPP/88XnjhBRQXF8PLy6vTaysUCkgkEtja2holdicnJ9x4441tEgalUommpibI5XKTrrpduHAB/fr1w7p163D33Xeb7HE78uabb+KJJ55Aeno6wsLCWt1m7J+NqWzYsAFLly5t9zn2ZA0NDbCxsYGNjY3Br3306FGMGDECn332mU5VG+39fYuNjYWXl5dZk+iSkhJ4e3vjueeea1O90NzcjObmZtjZ2ZknOCIiC2T4/1GIiMgoUlNTcfvttyMiIgK7d++Gt7e39raVK1diwoQJuP3223Hq1ClERETofX25XG7IcHUmlUohlUpN/rhFRUUAADc3N5M/tr7M9bMhw7CkBNRUf9+am5uhUqkgk8m6fS1jfQhCRGTNWFpPRGQl3njjDdTV1eHjjz9ulcQDgJeXF/73v/+htrYWa9asaXPfkpISLFiwAC4uLvD09MTKlSvR0NDQ6pz29mFXVFTg4YcfRnBwMORyOaKiovD6669DpVK1Ok+lUuG9997DwIEDYWdnB29vb8yYMQNHjx4FoN4jXFtbi40bN0IQBAiCoH2sy/fszp49u8MPIsaMGYPhw4e3Ovbll19i2LBhsLe3h4eHB26++WZkZ2d3+louWbIEkyZNAgDcdNNNEAQBkydPBgBMnjxZ++fL73PpKnJGRgYEQcCbb76Jjz/+GJGRkZDL5RgxYgSOHDnS5v4XLlzAggUL4O3tDXt7e8TExODpp58GoK6ceOKJJwAA4eHh2tdI85q097NJS0vDTTfdBA8PDzg4OGD06NH4/fffW52zc+dOCIKAb7/9Fq+88gqCgoJgZ2eHqVOnIiUlpdPX6Pvvv4cgCNi1a1eb2/73v/9BEAScOXMGAHDq1CksWbIEERERsLOzg5+fH+68806UlpZ2+hhAx/vHu/N+bM/PP/+Ma6+9FgEBAZDL5YiMjMRLL70EpVLZ5tz3338fERERsLe3x8iRI7Fnz54274vGxkY8++yzGDZsGFxdXeHo6IgJEyYgPj7+is9Rs+c7JSUFS5YsgZubG1xdXbF06VLU1dW1uu/ff/+N8ePHw83NDU5OToiJicG///1vAOqf74gRIwAAS5cu1b5vOiuTv/zvW1hYGM6ePYtdu3Zp73/p89TlNb/078K7776r/btw7tw5nV6njIwM7b9pL7zwgjYOzWvW3h755uZmvPTSS9rHCgsLw7///W8oFIpW54WFhWH27NnYu3cvRo4cCTs7O0RERODzzz/v8DUiIrIG/HiTiMhK/PrrrwgLC8OECRPavX3ixIkICwtrk8wBwIIFCxAWFobVq1fj4MGDWLt2LcrLyzv9Zbaurg6TJk1Cbm4u7r33XoSEhGD//v1YtWoV8vPz8e6772rPveuuu7BhwwbMnDkTd999N5qbm7Fnzx4cPHgQw4cPxxdffIG7774bI0eOxLJlywAAkZGR7T7uwoULsXjxYhw5ckSbpABAZmYmDh48iDfeeEN77JVXXsEzzzyDBQsW4O6770ZxcTH++9//YuLEiTh+/HiHq+333nsvAgMD8eqrr+Khhx7CiBEj4Ovr2+Fr0Zmvv/4a1dXVuPfeeyEIAtasWYP58+cjLS1NWwp/6tQpTJgwAba2tli2bBnCwsKQmpqKX3/9Fa+88grmz5+PpKQkfPPNN3jnnXe02yAu/8BGo7CwEGPHjkVdXR0eeugheHp6YuPGjZgzZw6+//77VtsrAOC1116DRCLB448/jsrKSqxZswa33norDh061OHzuvbaa+Hk5IRvv/1W+6GHxubNmzFgwADExsYCUCebaWlpWLp0Kfz8/HD27Fl8/PHHOHv2LA4ePGiQLRP6vB/bs2HDBjg5OeHRRx+Fk5MTduzYgWeffRZVVVWt3lMffvghVqxYgQkTJuCRRx5BRkYG5s6dC3d3dwQFBWnPq6qqwvr167Fo0SLcc889qK6uxieffILp06fj8OHDGDx48BWf04IFCxAeHo7Vq1cjISEB69evh4+PD15//XUA6n4Ys2fPxqBBg/Diiy9CLpcjJSUF+/btAwD069cPL774Ip599lksW7ZM+2/D2LFjdX5d3333XTz44INwcnLSfrCk+bug72v+2WefoaGhAcuWLYNcLoeHh4dOr5O3tzc+/PBD3H///Zg3bx7mz58PABg0aFCHcd99993YuHEjbrzxRjz22GM4dOgQVq9ejfPnz+Onn35qdW5KSgpuvPFG3HXXXbjjjjvw6aefYsmSJRg2bBgGDBig82tFRGRRRCIisngVFRUiAPH666/v9Lw5c+aIAMSqqipRFEXxueeeEwGIc+bMaXXeAw88IAIQT548qT0WGhoq3nHHHdrvX3rpJdHR0VFMSkpqdd+nnnpKlEqlYlZWliiKorhjxw4RgPjQQw+1iUelUmn/7Ojo2Or6Gp999pkIQExPTxdFURQrKytFuVwuPvbYY63OW7NmjSgIgpiZmSmKoihmZGSIUqlUfOWVV1qdd/r0adHGxqbN8cvFx8eLAMTvvvuu1fFJkyaJkyZNanP+HXfcIYaGhmq/T09PFwGInp6eYllZmfb4zz//LAIQf/31V+2xiRMnis7OztrYNS59fd54441Wr8OlLv/ZPPzwwyIAcc+ePdpj1dXVYnh4uBgWFiYqlcpWz7Ffv36iQqHQnvvee++JAMTTp0+3/+K0WLRokejj4yM2Nzdrj+Xn54sSiUR88cUXtcfq6ura3Pebb74RAYi7d+/WHrv8Zy2KoghAfO655674nHV9P3akvRjvvfde0cHBQWxoaBBFURQVCoXo6ekpjhgxQmxqatKet2HDBhFAq/dFc3Nzq9dUFEWxvLxc9PX1Fe+8885Wxy9/jpq/l5efN2/ePNHT01P7/TvvvCMCEIuLizt8XkeOHBEBiJ999lmH51yqvZ/BgAED2n3P6/qaa/4uuLi4iEVFRa3O1fV1Ki4u7vC9oHm9NE6cOCECEO++++5W5z3++OMiAHHHjh3aY6GhoW3eh0VFRe3+G0NEZE1YWk9EZAWqq6sBAM7Ozp2ep7m9qqqq1fHly5e3+v7BBx8EAPzxxx8dXuu7777DhAkT4O7ujpKSEu3XtGnToFQqsXv3bgDADz/8AEEQ8Nxzz7W5RldWYl1cXDBz5kx8++23EC/px7p582aMHj0aISEhANSN/1QqFRYsWNAqPj8/P/Tp06fdEmdjWLhwIdzd3bXfa1ZF09LSAADFxcXYvXs37rzzTm3sGl1dqf7jjz8wcuRIjB8/XnvMyckJy5YtQ0ZGBs6dO9fq/KVLl7baq3x5jB1ZuHAhioqKWjVB+/7776FSqbBw4ULtMXt7e+2fGxoaUFJSgtGjRwMAEhIS9H+C7dD1/diRS2Osrq5GSUkJJkyYgLq6Oly4cAGAunFcaWkp7rnnnlZ7sm+99dZWP2NAvddc85qqVCqUlZWhubkZw4cP1/k533fffa2+nzBhAkpLS7V/fzUVJT///LNO2wcMTd/X/IYbbmhTRWKI1+lymn+3Hn300VbHH3vsMQBoU5XUv3//VpVM3t7eiImJueL7n4jIkrG0nojICmgSdE1C35GOEv4+ffq0+j4yMhISiaTTWdLJyck4depUh+XdmmZxqampCAgIgIeHR6ex6WPhwoXYsmULDhw4gLFjxyI1NRXHjh1rVcqbnJwMURTbPDcNU3V4vzw51yR85eXlAC4my5oydEPIzMzEqFGj2hzv16+f9vZLH+9KMXZkxowZcHV1xebNmzF16lQA6g9UBg8ejOjoaO15ZWVleOGFF7Bp0ybt+0KjsrJSj2fWMV3fjx05e/Ys/vOf/2DHjh1tPujSxJiZmQkAiIqKanW7jY1Nu132N27ciLfeegsXLlxAU1OT9nh4ePgVnw/Q+c/FxcUFCxcuxPr163H33XfjqaeewtSpUzF//nzceOONkEiMvxaj72ve0fPu7ut0uczMTEgkkjY/Jz8/P7i5uWl/jhqXv86A+rW+0vufiMiSMZEnIrICrq6u8Pf3x6lTpzo979SpUwgMDISLi0un5+myEqxSqXD11VfjySefbPf2SxM5Q7vuuuvg4OCAb7/9FmPHjsW3334LiUSCm266qVV8giDgzz//bLcLt5OTU5ceWxCEVpUAGu01RQPQYQfw9q5hLl2NUS6XY+7cufjpp5/wwQcfoLCwEPv27cOrr77a6rwFCxZg//79eOKJJzB48GA4OTlBpVJhxowZXV5Jvvz17s77saKiApMmTYKLiwtefPFFREZGws7ODgkJCfjXv/7VpRi//PJLLFmyBHPnzsUTTzwBHx8fSKVSrF69GqmpqTpd40o/F3t7e+zevRvx8fH4/fffsXXrVmzevBlXXXUV/vrrL6N3n9f3Nb+06kHDEK9TR3StaLGGv6NERPpiIk9EZCVmz56NdevWYe/eva1KqjX27NmDjIwM3HvvvW1uS05ObrX6lZKSApVK1eks78jISNTU1GDatGmdxhUZGYlt27ahrKys01V5fcrIHR0dMXv2bHz33Xd4++23sXnzZkyYMAEBAQGtHlcURYSHhxv0QwV3d/d2S24vX+XTlaYDv6bDe0f0eX1CQ0ORmJjY5rimRDw0NFSPCDu3cOFCbNy4Edu3b8f58+chimKrsvry8nJs374dL7zwAp599lnt8eTkZJ2u7+7ujoqKilbHGhsbkZ+f3+qYru/H9uzcuROlpaX48ccfMXHiRO3x9PT0VudpXreUlBRMmTJFe7y5uRkZGRmtmq99//33iIiIwI8//tjqZ9feFpPukEgkmDp1KqZOnYq3334br776Kp5++mnEx8dj2rRpBmkk2NE1uvOaa+j6Oun7/lepVEhOTtZWoQDqJpAVFRUGff8TEVkq7pEnIrISTzzxBOzt7XHvvfe2GetVVlaG++67Dw4ODtoxZpd6//33W33/3//+FwAwc+bMDh9vwYIFOHDgALZt29bmtoqKCjQ3NwNQ74sVRREvvPBCm/MuXfFydHRsk7B1ZuHChcjLy8P69etx8uTJVskjAMyfPx9SqRQvvPBCm5U1URR1Gn3WnsjISFy4cAHFxcXaYydPntR2CteXt7c3Jk6ciE8//RRZWVlt4tRwdHQEAJ1eo1mzZuHw4cM4cOCA9lhtbS0+/vhjhIWFoX///l2KtT3Tpk2Dh4cHNm/ejM2bN2PkyJGtPhTSrHZe/jO4Uhd5jcjIyDZ7rT/++OM2K/K6vh/b016MjY2N+OCDD1qdN3z4cHh6emLdunWtrvfVV1+1KcNu75qHDh1q9TPprrKysjbHNN3wNWPW9HnfdKSjv5vdec01dH2dHBwctNe9klmzZgFo+x57++23AagnLhAR9XRckScishJ9+vTBxo0bceutt2LgwIG46667EB4ejoyMDHzyyScoKSnBN9980+5Yt/T0dMyZMwczZszAgQMH8OWXX+KWW25BXFxch4/3xBNP4JdffsHs2bO1o5pqa2tx+vRpfP/998jIyICXlxemTJmC22+/HWvXrkVycrK2nHrPnj2YMmUKVqxYAQAYNmwY/vnnH7z99tsICAhAeHh4u/u8NWbNmgVnZ2c8/vjjkEqluOGGG1rdHhkZiZdffhmrVq3SjghzdnZGeno6fvrpJyxbtgyPP/643q/znXfeibfffhvTp0/HXXfdhaKiInz00UcYMGBAm73Vulq7di3Gjx+PoUOHYtmyZdqf2++//44TJ04AUL8+APD000/j5ptvhq2tLa677jptonapp556Ct988w1mzpyJhx56CB4eHti4cSPS09Pxww8/GHT/tK2tLebPn49NmzahtrYWb775ZqvbXVxcMHHiRKxZswZNTU0IDAzEX3/91Wa1uyN333037rvvPtxwww24+uqrcfLkSWzbtk07gk9D1/dje8aOHQt3d3fccccdeOihhyAIAr744os2Hz7IZDI8//zzePDBB3HVVVdhwYIFyMjIwIYNGxAZGdlq1Xj27Nn48ccfMW/ePFx77bVIT0/HRx99hP79+6Ompkan534lL774Inbv3o1rr70WoaGhKCoqwgcffICgoCBtVU5kZCTc3Nzw0UcfwdnZGY6Ojhg1apRe+8+HDRuGDz/8EC+//DKioqLg4+ODq666qluvuYaur5O9vT369++PzZs3Izo6Gh4eHoiNjW23t0RcXBzuuOMOfPzxx9ptE4cPH8bGjRsxd+7cVtUUREQ9lom75BMRUTedOnVKXLRokejv7y/a2tqKfn5+4qJFi9odJaYZ23Tu3DnxxhtvFJ2dnUV3d3dxxYoVYn19fatzLx/3JYrqkWarVq0So6KiRJlMJnp5eYljx44V33zzTbGxsVF7XnNzs/jGG2+Iffv2FWUymejt7S3OnDlTPHbsmPacCxcuiBMnThTt7e1FANrHam8clsatt94qAhCnTZvW4evxww8/iOPHjxcdHR1FR0dHsW/fvuLy5cvFxMTETl/HjsbPiaIofvnll2JERIQok8nEwYMHi9u2betw/Nwbb7zR5v5oZ4zWmTNnxHnz5olubm6inZ2dGBMTIz7zzDOtznnppZfEwMBAUSKRtHpN2vvZpKamijfeeKP2eiNHjhR/++03nZ6jJnZdR5b9/fffIgBREAQxOzu7ze05OTna5+bq6iredNNNYl5eXpvXob2ftVKpFP/1r3+JXl5eooODgzh9+nQxJSWlW+/H9uzbt08cPXq0aG9vLwYEBIhPPvmkuG3bNhGAGB8f3+rctWvXiqGhoaJcLhdHjhwp7tu3Txw2bJg4Y8YM7TkqlUp89dVXtecNGTJE/O2339q8T0Sx4/Fzl4+Vu/z12b59u3j99deLAQEBokwmEwMCAsRFixa1GQf3888/i/379xdtbGyu+HNt72dQUFAgXnvttaKzs3ObMXu6vOad/V3Q53Xav3+/OGzYMFEmk7V6zS4fPyeKotjU1CS+8MILYnh4uGhraysGBweLq1at0o4S1AgNDRWvvfbaNnF1NGaSiMhaCKLITh9ERAQEBwdj+vTpWL9+vblDIbIoKpUK3t7emD9/PtatW2fucIiIiLhHnoiIgKamJpSWll6xTJaop2toaGhTcv/555+jrKwMkydPNk9QREREl+EeeSKiXm7btm3YtGkT6uvrtbPCiXqrgwcP4pFHHsFNN90ET09PJCQk4JNPPkFsbGyr8YdERETmxESeiKiXe+2115CSkoJXXnkFV199tbnDITKrsLAwBAcHY+3atdqRiosXL8Zrr70GmUxm7vCIiIgAANwjT0RERERERGRFuEeeiIiIiIiIyIowkSciIiIiIiKyItwj3w6VSoW8vDw4OztDEARzh0NEREREREQ9nCiKqK6uRkBAACSSztfcmci3Iy8vD8HBweYOg4iIiIiIiHqZ7OxsBAUFdXoOE/l2ODs7A1C/gC4uLmaOhoiIiIiIiHq6qqoqBAcHa/PRzjCRb4emnN7FxYWJPBEREREREZmMLtu72eyOiIiIiIiIyIowkSciIiIiIiKyIkzkiYiIiIiIiKwIE3kiIiIiIiIiK8JEnoiIiIiIiMiKMJEnIiIiIiIisiJM5ImIiIiIiIisCBN5IiIiIiIiIivCRJ6IiIiIiIjIijCRJyIiIiIiIrIiTOSJiIiIiIiIrAgTeSIiIiIiIiIrwkSeiIiIiIiIyIowkSciIiIiIiKyIkzkiYiIiIiIiKwIE3kiIiIiIiIiK8JEnqxafaMSJ7MrzB0GERERERGRyTCRJ6v24DfHcf37+/DX2QJzh0JERERERGQSTOTJap3KqcA/5wsBAL+dyjdzNERERERERKbBRJ6s1vvxKdo/70wsQrNSZcZoiIiIiIiITIOJPFmlpMJqbDtbCEEAHGRSVDU0IyGrwtxhERERERERGR0TebJKH7Ssxs8Y4Ier+/sCAHZcKDJnSERERERERCbBRJ6sTkZJLX45mQcAWD4lClf19QEAxDORJyIiIiKiXsDG3AEQ6eujXalQicCUGG/EBroiyN0eEgFILKxGTnkdgtwdzB0iERERERGR0XBFnqxKXkU9fkjIAQCsuCoKAODmIMPQEHcAXJUnIiIiIqKej4k8WZWPd6ehSSliTIQnhoV6aI9f1U9dXs998kRERERE1NMxkSerUVytwDeHswBcXI3X0OyT359aivpGpcljIyIiIiIiMhUm8mQ1PtmbDkWzCoOD3TA20rPVbTG+zghwtYOiWYUDaSVmipCIiIiIiMj4mMiTVaioa8QXBzIAACumREEQhFa3C4KAKX1ZXk9ERERERD0fE3myChv2Z6C2UYl+/i6Y2rIf/nKa8vod54sgiqIpwyMiIiIiIjIZJvJk8WoUzfhsXwYAYPmUyDar8RpjI70gt5Egr7IBiYXVJoyQiIiIiIjIdJjIk8X76mAmKuubEOHtiJmx/h2eZy+TavfOs7yeiIiIiIh6KibyZNEampRYtycdAHD/pEhIJe2vxmtoyus5T56IiIiIiHoqJvJk0TYfyUZJjQKBbvaYOyTwiudrGt4dyyxHRV2jscMjIiIiIiIyOSbyZLEam1X4365UAMB9kyNhK73y2zXI3QHRvk5QicCupGJjh0hERERERGRyTOTJYm05nou8ygb4OMtx07Agne93VV9fANwnT0REREREPRMTebJISpWID3amAADumRABO1upzvfV7JPflVQMpYpj6IiIiIiIqGdhIk8W6bdTecgorYO7gy1uGRWi132HhrjB1d4WFXVNOJ5VbqQIiYiIiIiIzIOJPFkclUrEB/HqvfF3jguHo9xGr/vbSCWYGO0NgOX1RERERETU8zCRJ4vzz/lCJBZWw1lug8Vjw7p0jav6MpEnIiIiIqKeyayJ/OrVqzFixAg4OzvDx8cHc+fORWJiYqf32bBhAwRBaPVlZ2fX6hxRFPHss8/C398f9vb2mDZtGpKTk435VMhARFHE+/HqvfGLx4bC1d62S9eZFO0DiQBcKKhGbkW9IUMkIiIiIiIyK7Mm8rt27cLy5ctx8OBB/P3332hqasI111yD2traTu/n4uKC/Px87VdmZmar29esWYO1a9fio48+wqFDh+Do6Ijp06ejoaHBmE+HDGBPcglO5lTC3laKO8eFd/k6Ho4yDAlxBwDEc1WeiIiIiIh6EP02HxvY1q1bW32/YcMG+Pj44NixY5g4cWKH9xMEAX5+fu3eJooi3n33XfznP//B9ddfDwD4/PPP4evriy1btuDmm29ucx+FQgGFQqH9vqqqqitPhwzg/1pW4xeNDIGnk7xb17qqrw+OZZYj/kIRbhsdaojwiIiIiIiIzM6i9shXVlYCADw8PDo9r6amBqGhoQgODsb111+Ps2fPam9LT09HQUEBpk2bpj3m6uqKUaNG4cCBA+1eb/Xq1XB1ddV+BQcHG+DZkL4Op5fhcHoZZFIJlk2M6Pb1psSox9DtSy1BQ5Oy29cjIiIiIiKyBBaTyKtUKjz88MMYN24cYmNjOzwvJiYGn376KX7++Wd8+eWXUKlUGDt2LHJycgAABQUFAABfX99W9/P19dXedrlVq1ahsrJS+5WdnW2gZ0X60KzG3zg8CH6udlc4+8r6+TvD39UODU0qHEgr7fb1iIiIiIiILIFZS+svtXz5cpw5cwZ79+7t9LwxY8ZgzJgx2u/Hjh2Lfv364X//+x9eeumlLj22XC6HXN69Mm7qnlM5FdidVAypRMD9kyINck1BEDClrw++PpSFHeeLtCv0RERERERE1swiVuRXrFiB3377DfHx8QgKCtLrvra2thgyZAhSUtSruZq984WFha3OKyws7HBfPZmfplP99XEBCPZwMNh1r2pJ3ndcKIIoiga7LhERERERkbmYNZEXRRErVqzATz/9hB07diA8XP8u5UqlEqdPn4a/vz8AIDw8HH5+fti+fbv2nKqqKhw6dKjVSj5ZjqTCamw7WwhBAB6YYpjVeI2xUZ6Q2UiQW1GP5KIag16biIiIiIjIHMyayC9fvhxffvklvv76azg7O6OgoAAFBQWor78493vx4sVYtWqV9vsXX3wRf/31F9LS0pCQkIDbbrsNmZmZuPvuuwGoy6kffvhhvPzyy/jll19w+vRpLF68GAEBAZg7d66pnyLpQLMaPzPWD1E+zga9toPMBmMiPAGoV+WJiIiIiIisnVn3yH/44YcAgMmTJ7c6/tlnn2HJkiUAgKysLEgkFz9vKC8vxz333IOCggK4u7tj2LBh2L9/P/r3768958knn0RtbS2WLVuGiooKjB8/Hlu3boWdXfcbqJFhZZTU4teTeQCAByZHGeUxrurrg11JxdhxoQj3GWj/PRERERERkbkIIjcOt1FVVQVXV1dUVlbCxcXF3OH0aE/9cAqbjmRjSow3Pls60iiPkV1Whwlr4iGVCEj4z9VwdbA1yuMQERERERF1lT55qEU0u6PeKa+iHj8kqMcGrrjKOKvxABDs4YA+Pk5QqkTsSi422uMQERERERGZAhN5MpuPd6ehSSliTIQnhoV6GPWxruqr7l4fz33yRERERERk5ZjIk1kUVyvwzeEsAMZdjdeY0pLI70wsglLF3SRERERERGS9mMiTWXyyNx2KZhUGB7thbKSn0R9vWKg7nO1sUF7XhBPZFUZ/PCIiIiIiImNhIk8mV1HXiC8OZAAAHrwqCoIgGP0xbaUSTIr2BgDsuFBo9McjIiIiIiIyFibyZHIb9megtlGJfv4u2r3rpqB5rB0X2PCOiIiIiIisFxN5MqkaRTM+25cBAFg+JdIkq/Eak6K9IQjA+fwq5FfWm+xxiYiIiIiIDImJPJnUVwczUVnfhAhvR8yM9TfpY3s6yTE42A0AEM9VeSIiIiIislJM5MlkGpqUWLcnHQDwwOQoSCWmW43XmKotr+cYOiIiIiIisk5M5MlkNh/JRkmNAkHu9rh+cIBZYtCModuXUoKGJqVZYiAiIiIiIuoOJvJkEo3NKvxvVyoA4N5JkbCVmuet19/fBX4udqhvUuJgWqlZYiAiIiIiIuoOJvJkEuv2pCGvsgE+znLcNCzIbHEIgoApfdVj6OJZXk9ERERERFaIiTwZ3cG0Urz1VyIA4PHpMbCzlZo1nikxLfvkE4sgiqJZYyEiIiIiItIXE3kyqqLqBjz4zXGoRGD+0ECzrsZrjIvygsxGguyyeqQW15g7HCIiIiIiIr0wkSejUapErPzmBIqrFYj2dcLLc2NNOje+I45yG4yO8AQAbD/P8noiIiIiIrIuTOTJaN75OwkH0krhKJPig1uHwUFmY+6QtK6KUe+T5xg6IiIiIiKyNkzkySjiE4vwf/EpAIDVNwxClI+TmSNq7aq+vgCAo5nlqKxvMnM0REREREREumMiTwaXW1GPRzafAADcPjoUc+LMMzO+MyGeDoj0doRSJWJPcrG5wyEiIiIiItIZE3kyqMZmFZZ/lYCKuiYMCnLFf2b3M3dIHZraT70qz/J6IiIiIiKyJkzkyaBW/3keJ7Ir4GJng/dvGQq5jXlHzXVGM4ZuZ2IxlCqOoSMiIiIiIuvARJ4M5o/T+fhsXwYA4O0FgxHs4WDegK5geJg7nO1sUFbbiJM5FeYOh4iIiIiISCdM5Mkg0ktq8eT3pwAA906KwLT+vmaO6MpspRJM7KPuXh/P8noiIiIiIrISTOSp2xqalLj/y2OoUTRjRJg7Hr8mxtwh6WxKX3V5PffJExERERGRtWAiT9323M9ncaGgGp6OMvx30VDYSq3nbTU5xhuCAJzNq0JhVYO5wyEiIiIiIroi68m4yCJ9fywHm49mQxCA924eAj9XO3OHpBcvJznigtwAsLyeiIiIiIisAxN56rILBVX4z5bTAICHp0ZjfB8vM0fUNVe1lNdvZyJPRERERERWgIk8dUmNohkPfJWAhiYVJvTxwoNXRZk7pC7TJPL7UkqgaFaaORoiIiIiIqLOMZEnvYmiiFU/nkZacS38XOzw7sLBkEgEc4fVZQMCXODjLEddoxKH0srMHQ4REREREVGnmMiT3r48mIlfT+bBRiLg/VuHwNNJbu6QukUQBO2qPLvXExERERGRpWMiT3o5lVOBl347DwB4amZfDAv1MHNEhnHpGDpRFM0cDRERERERUceYyJPOKuua8MBXCWhUqnBNf1/cNT7c3CEZzPgoL8ikEmSV1SG1uNbc4RAREREREXWIiTzpRKUS8dh3J5BTXo8QDwe8cVMcBMF698VfzlFug1ER6uoCjqEjY0oqrMa7/yTheFa5uUMhIiIiIivFRJ508vGeNPxzvggyGwk+uHUoXO1tzR2SwU2J4T55Mg6lSsS2swW4Zd1BXPPObrz7TzIe2XyC2ziIiIiIqEtszB0AWb5DaaV4Y1siAOC56/ojNtDVzBEZx9R+Pnjxt3M4klGGqoYmuNj1vA8ryLTKaxux6Ug2vjyYidyKegCAZsBDRmkd0ktqEeHtZMYIiYiIiMgaMZGnThVXK/DgN8ehVImYOzgAt4wMMXdIRhPq6YgIb0ekFddib3IJZg30N3dIZKXO5lVi4/4M/HwiD4pmFQDA3cEWN48MwW2jQ/Gv709hb0oJ4hOLmcgTERERkd6YyFOHlCoRKzcdR1G1AlE+Tnhl3sAetS++PVfF+CCtOB3bzxcxkSe9NClV2Ha2ABv3Z+BIxsX97wMCXHDH2DDMiQuAna0UADA5xht7U0qwM7GoRzWNJCIiIiLTYCJPHXrvnyTsTy2Fva0UH946FI7ynv92uaqvD9bvTceupCKoVCIkkp79wQV1X0mNAt8cysJXh7JQUNUAALCRCJgR64clY8MwLNS9zQdgk2N88PLv53EorQy1iuZe8XeLiIiIiAyHvz1Su3YlFeO/8SkAgNXzB6KPr7OZIzKN4WEecJLboKSmEadyKzE42M3cIZGFOpFdgY37M/D7qXw0KtXl815OMtwyMgS3jg6Fr4tdh/eN9HZEsIc9ssvqcSC1FNP6+5oqbCIiIiLqAZjIUxt5FfV4eNNxiCJwy6gQzB0SaO6QTEZmI8HEaC/8cboAOy4UMZGnVhTNSvxxOh8b9mfiZHaF9vjgYDcsGRuGmQP9ILeRXvE6giBgSowPPj+QifjEIibyRERERKQXJvLUSpNShRVfJ6C8rgmxgS54dnZ/c4dkclNifPDH6QJsP1+IR6b16fF9AejKCqsa8NXBTHx9OAslNY0AAJlUgtmD/HHH2DDEdeEDH00ivzOxGKIo8n1GRERERDpjIk+tvPtPEhKyKuBsZ4MPbhmmbc7Vm0yO8YFEAM7mVWHphiNYc8Mg+HRSJk09U0OTEofSy/Dd0WxsPVOAZpV65ruvixy3jQrFolEh8HKSd/n6oyM8IbORILeiHslFNYjuJdtXiIiIiKj7mMiT1v7UEnywMxWAel98iKeDmSMyD29nOV6dNxDP/nIWOxOLMf3d3Vg9fyBmxLKLfU+mUok4l1+FPckl2JtSjCMZ5WhsGR0HACPDPHDH2DBcM8AXtlJJtx/PXibFmAhP7Eoqxs7EIibyRERERKQzJvIEACivbcSjm09CFIEFw4Mwe1CAuUMyq5tHhmBoqDse3nQC5/KrcN+XCbhxWBCeu64/nO1szR2eSWw7W4CahmbcMCzI3KEYTU55HfYml2BPSgn2p5SgvK6p1e1+LnaY0tcHt40OwYAAV4M//pQYb+xKKkb8hWIsmxhp8OsTERERUc/ERJ4giiL+9cMpFFQ1IMLLEc/PGWDukCxCtK8ztiwfh3f/ScKHu1Lx/bEcHEgtxdsL4jAqwtPc4RlVUXUDHvgqAUqViHBvRwwNcTd3SAZRWd+EA6ml2JtSjH0ppUgvqW11u6NMijGRnhgf5YXxfbwR6e1o1L3rk2N8gF/P4UhGGaobmnrNh0RERERE1D1M5AlfHcrCX+cKYSsVsHbREDjI+LbQkNlI8OSMvpjS1wePbD6BnPJ63LzuIJZNjMCjV0fr1KHcGv16Mh/Klj3h6/ek4YNbh5k5oq5pbFbheFY59qWoV91PZleg5WkBAKQSAYOD3VoSdy8MDnYzSNm8rsK8HBHu5Yj0klrsSynh9g0iIiIi0gkztl4uqbAaL/12DgDwrxl9ERto+PLhnmBEmAf+XDkBL/12Dt8ezcH/dqVhd1IJ3l04GDF+PW9v85bjudo/bz1TgKzSOqvomSCKIpKLarA3uQR7U0pwMK0UdY3KVudEeDtiQpQXxkV5YXSkJ1zMvAo+OcYb6SW1iL9QzESeiIiIiHTCRL4Xa2hS4qFvjkPRrMLEaG/cOS7c3CFZNGc7W6y5MQ5X9fXFv386jfP5Vbjuv3vx5IwY3DkuHBJJzxgfllJUjdO5lbCRCBgU5IqErAp8ui/dordcFFQ24M2/ErEnuRiFVYpWt3k6yjAuygvjo7wwro8XAt3szRRl+6bE+OCzfRnYmVTEMXREREREpBMm8r3Y6j/O40JBNbycZHjrprgek4ga24xYPwwNdcNTP5zGjgtFePn389h+vghvLoizuCSxK7YczwMATIr2xp3jw3Hr+kPYfCQbD0/rAzcHmZmja0sURSz/OgHHMssBAHIbCUaGe2jL5fv5uVj0e3tkuAfsbaUorFLgfH41+ge4mDskIiIiIrJwptsMShbln3OF2HggEwDw5k1x8Hbu+jzs3sjH2Q6f3DEcr84bCHtbKQ6klWLGu7ux5XguRFG88gUslEolYssJdVn9vKGBGBvpif7+LqhvUuKrQ1lmjq59+1NLcSyzHHIbCTYsHYGTz12DL+4ahXsnRWJAgKtFJ/EAYGcrxdhIdfPE+MQiM0dDRERERNaAiXwvVFjVgCe+PwkAuGt8uLpzNulNEATcMioEf6ycgMHBbqhuaMbDm09gxTfHUVHXaO7wuuRYVjlyyuvhJLfBtH6+EAQByyZGAAA+25cBRbPyClcwLVEU8d4/yQCARSNDMDnGB3a21teAcHJf9d/BnUzkiYiIiEgHTOR7GZVKxKPfnkB5XRMGBLjgyRkx5g7J6oV7OeL7+8bg0aujIZUI+P1UPqa/uxt7kovNHZrefkxQr8bPjPXTJsTXDvKHv6sdSmoU+Lml7N5SHEwrw+GMMshsJLh/svXOYZ8c7Q0ASMiqQOVls+yJiIiIiC5n1kR+9erVGDFiBJydneHj44O5c+ciMTGx0/usW7cOEyZMgLu7O9zd3TFt2jQcPny41TlLliyBIAitvmbMmGHMp2I1/rc7DftSSmFvK8XaRUN67Pg0U7ORSvDQ1D748f6xiPB2RGGVArd/chjP/3IW9Y2WtYrdEUWzEr+fUifq84YEao/bSiXaRogf70mDSmU5Wwfe254EALh5RDB8XezMHE3XBXs4oI+PE5QqEXtSrO8DICIiIiIyLbMm8rt27cLy5ctx8OBB/P3332hqasI111yD2traDu+zc+dOLFq0CPHx8Thw4ACCg4NxzTXXIDc3t9V5M2bMQH5+vvbrm2++MfbTsXgnsivw1l/qD0qen9Mfkd5OZo6o54kLdsPvD07A4jGhAIAN+zMw+797cDqn0syRXVn8hWJUNTTDz8UOoyI8W91288hgOMttkFJUg11JlpFoHkorxcG0Msik1r0arzGlpbw+/oJlvL5EREREZLnMmshv3boVS5YswYABAxAXF4cNGzYgKysLx44d6/A+X331FR544AEMHjwYffv2xfr166FSqbB9+/ZW58nlcvj5+Wm/3N3dO7ymQqFAVVVVq6+epkbRjJWbjqNZJeLagf5YMDzY3CH1WPYyKV68PhYblo6Aj7McqcW1mPfBPvzfjmQ0K1XmDq9Dmtnx1w8OgPSyBnHOdra4eaT6PfPx7jSTx9aetTvUe+NvGh4Ef1frnxagKa/flVRkUVUPRERERGR5LGqPfGWletXSw8ND5/vU1dWhqampzX127twJHx8fxMTE4P7770dpaWmH11i9ejVcXV21X8HBPS/JfXbLGWSW1iHQzR6vzh/IWdUmMDnGB9senohZA/3QrBLx5l9JWPC/A8gprzN3aG1U1jVhxwV1o7W5l5TVX2rpuHDYSAQcSCs1e4XB0Ywy7Espha1UwANToswai6EMD/OAo0yKkppGnM3reR8mEhEREZHhWEwir1Kp8PDDD2PcuHGIjY3V+X7/+te/EBAQgGnTpmmPzZgxA59//jm2b9+O119/Hbt27cLMmTOhVLa/V3nVqlWorKzUfmVnZ3f7+ViSLcdz8ePxXEgE4L2bB8PV3tbcIfUa7o4yvH/LULy9IA7OchskZFXgoW+OW9yIuj/O5KNRqUJfP2f0829/jnmAmz1mD/IHAKzbY95V+fe2q1fjbxwWjEA361+NBwCZjQTj+3gB4Bg6IiIiIuqcxSTyy5cvx5kzZ7Bp0yad7/Paa69h06ZN+Omnn2Bnd7HR1c0334w5c+Zg4MCBmDt3Ln777TccOXIEO3fubPc6crkcLi4urb56iqzSOvxnyxkAwENT+2B4mO7VDmQYgiBg/tAg/PbQeMhsJEjIqsCxzHJzh9XKTy1l9R2txmvcPUE9iu730/lmqyxIyCrHnuQS2EgEPNAD9sZfakrLKEgm8kRERETUGYtI5FesWIHffvsN8fHxCAoK0uk+b775Jl577TX89ddfGDRoUKfnRkREwMvLCykpKYYI12o0KVV4cNNx1CiaMSLMHSt6SAmytQr1dMT8lkTZ3Cval8opr8Ph9DIIAjAnLqDTc2MDXTEuyhNKlYjP9mWYJsDLrG1Zjb9haBCCPRzMEoOxTIpR75M/kV2BstpGM0dDRERERJbKrIm8KIpYsWIFfvrpJ+zYsQPh4eE63W/NmjV46aWXsHXrVgwfPvyK5+fk5KC0tBT+/v7dDdmqvPN3Ek5mV8DZzgbvLBwMG6lFfG7Tq909Qf0e/+tcIdJLOp7OYEo/n1CPnBsd7okAHcrU72lZld90OAuV9aadeX4iuwI7E4shlQhY3gM/mPJ3tUdfP2eIIrAnmd3riYiIiKh9Zs3sli9fji+//BJff/01nJ2dUVBQgIKCAtTX12vPWbx4MVatWqX9/vXXX8czzzyDTz/9FGFhYdr71NTUAABqamrwxBNP4ODBg8jIyMD27dtx/fXXIyoqCtOnTzf5czSX/Skl+HBXKgDgtfmDEOTes1YurVWUjzOmxHhDFIFP96abOxyIoqgtq593hbJ6jUnR3ojxdUZtoxKbDmcZM7w2NKvx84YEIsSzZ76nL46hs4zy+i8PZuLVP86zkz4RERGRBTFrIv/hhx+isrISkydPhr+/v/Zr8+bN2nOysrKQn5/f6j6NjY248cYbW93nzTffBABIpVKcOnUKc+bMQXR0NO666y4MGzYMe/bsgVwuN/lzNIey2kY88u0JiCKwcHgwrh3UuyoRLN09E9Ur2t8dy0a5mcunz+ZVIaWoBjIbCWYM9NPpPoIgaCsLPtuXgcZm04zUO51TiR0XiiAR0CNX4zU0++R3JRVDaebkObO0Fs/+fAYf707DiZwKs8ZCRERERBfZmPPBdencfXmDuoyMjE7Pt7e3x7Zt27oRlXUTRRFPfn8KhVUKRHg74rk5/c0dEl1mTIQnBgS44GxeFb48mIkHp/YxWyya2fFX9/OFi53u0wzmDA7AG9sSUVDVgN9O5WH+UN16W3SHplP93MGBCPdyNPrjmcvQEDc429mgvK4JJ3MqMDTE3WyxrN+TDs1nCWdzK80aCxERERFdxE3TPcyXBzPxz/lCyKQSrL15CBxkZv2shtohCAKWtazKbzyQiYam9sciGptSJeLnk+r98bqW1WvIbaRYMi4MAPDx7jSjj9M7k1uJf84Xqlfjr+q5q/EAYCOVYGIfddO7nWYsry+rbcR3xy6O4jyTy9n2RERERJaCiXwPklhQjZd/Pw8AeHJGDGIDXc0cEXVk1kB/+LvaoaRGgV9ams2Z2r6UEhRXK+DuYIuJ0d563//WkaFwkElxoaAae1NKjBDhRf/doV6Nvy4uAJHeTkZ9LEswuaV7/c4k8zW8+/xABhqaVJDbqP+bOJNXabZYiIiIiKg1JvI9REOTEg9+kwBFswqTor1x5zjdJgCQedhKJVjasqK9bo/xV7Tboymrnz0oADIb/f8pcHWwxYLhwQDUq/LGcj6/CtvOFkIQgAd7+Gq8hmYM3amcShRXK0z++PWNSnx+IBMA8MjV0QCApMJqKJrNUz1CRERERK0xke8hXvn9PJIKa+DlJMebN8VBIhHMHRJdwc0jQ+Akt0FyUY3JV17rGpux9WwBAGCunmX1l7prfDgkArAnuQTn841Teq1Zjb92oD+ifJyN8hiWxsfZDrGBLgDUTe9M7ftj2SirbUSQuz3uHh8ONwdbNClFJBfWmDwWIiIiImqLiXwP8NfZAnxxUL169taCOHg7947u/NbOxc4WN49Qr2ivM+KKdnv+PleIukYlQjwcMDTErcvXCfZwwMyB6qkI6/YY/jkkFlTjj9PqDxweMmNTQHPQdK+PTzTtPnmlSsT6ltGId48Ph41UgtgA9TadM7ksryciIiKyBEzkrVxBZQOe/OEUAPUv3ZO6sNeZzGfp+HBIJQL2p5birAn3IGtmx88dEghB6F71xrIJ6sZ9v5zIQ35lfbdju5RmNX7WQD9E+/aO1XiNyS2J/J6kYjQrTTPiDwC2nS1AZmkd3BxssaDlg6YBLdUBp5nIExEREVkEJvJWTKkS8ei3J1BR14QBAS54YkaMuUMiPQW62ePalhXt9XvSTfKYxdUK7ElWN6ebOzig29eLC3bDyHAPNKtEbNif0e3raSQXVuP30/kAet9qPAAMDnaDm4MtqhqacTy7wiSPKYoi/tdSHbJ4dKh26oV2RT6PneuJiIiILAETeSv2v92p2J9aCntbKdYuGgK5jdTcIVEX3NOyov3rScOvaLfnt1N5UKpExAW7IcJAHeA1q/JfH8xCdUOTQa75f/EpEEVgxgA/9PVzMcg1rYlUImjH0MWbaAzd4fQynMyugNxGgsVjw7THNRMwzudXocmE1QFERERE1D4m8lZK0azE90dzAAAvzBnQK0Zy9VQDg1wxOqJlRXtfhtEfT9Otfp4BVuM1rurrgwhvR1QrmrH5SPaV73AFqcU1+LVlxv2DU3tHp/r2TOnbksgnmqbhnWb6wA3DguDldLHXRqiHA5zkNmhsViG1mA3viIiIiMyNibyVkttIsWXFOLx4/QDcNDzI3OFQN2lW5b8+ZLgV7fakFtfgZE4lpBIBs+MMl8hLJIL2OXy2L6Pbe7r/b0cKVCJwdX9fDGgp6+6NJvbxhiCoV8ILKhuM+ljJhdXYfqEIgnDx/aghkQgYEKCuijiTy/J6IiIiInNjIm/FXOxssXhMWLeblZH5TYkx7Ip2R35uWY2f2Mer1YqrIcwbEggvJxlyK+rxx5mCLl8nvaQWP59Qx/nQVb1vb/ylPJ3kiAtyAwDsSjJueb1m6sA1/X0R7uXY5nZNeT071xMRERGZHxN5Igtg6BXt9oiiiJ9OXOxWb2h2tlIsHhMGAPh4dypEUezSdTSr8VP7+mBgUO9djdeYHKPZJ2+88vrCqgZsOa7eyrBsYmS752jm2ptyugIRERERtY+JPJGFmDckEJ6O3V/R7khCVjmyy+rhKJPimv5+Br8+ANw2OhR2thKcya3CwbQyve+fWVqLLZrV+F7Yqb49mnnye1NK0NhsnEZzn+3LQKNSheGh7hgW6t7uOZrO9WfzqqBSde1DGiIiIiIyDCbyRBbi0hXt9XvSuryi3ZEfE9QJ8oxYf9jLjDPhwMNRhhuHqXs2aEq19fF+fAqUKhGTY7wRF+xm4Ois08BAV3g6ylCjaMbRTP0/HLmSGkUzvjqUCQC4d1L7q/EAEOHtBDtbCeoalUgvrTV4HERERESkOybyRBbkttEhkNtIcCqnEofTDZe0NTar8Nsp9Uz2eUYoq7/UXeMjIAjAjgtFSC6s1vl+2WV12g8buBp/kUQiYFJLef0uI3Sv33Q4C9UNzYj0dsTUvj4dnieVCOjvr2l4x/J6IiIiInNiIk9kQTyd5LihGyvaHdmZWITK+ib4OMsxJtLTYNdtT7iXI67p7wsAWL8nXef7fbAzBc0qERP6eGFoSPvl3b3V5Jby+vhEwza8a1Kq8Ole9c/ongkRkEg6b5zJhndEREREloGJPJGFuWt8OAQB+Od8kcFmdmv2nV8/OADSKyRrhrBsorpx30/Hc1FUfeWxaTnldfjuaA4A4OFpXI2/3MQ+XpAIQFJhDXLK6wx23d9O5SGvsgFeTnKdGiBq9slzBB0RERGReTGRJ7Iwkd5OmNpXvaL9yV7dV7Q7UlnfhH/Oq1dyjdGtvj3DQj0wNMQNjUoVPt+fecXzP9yZimaViHFRnhgW6mGCCK2Lm4NMW6Ww00Dl9aIo4n+71FUfS8eFwc72yn0TBrR0rj+TV2nwHg5EREREpDsm8kQWSLOi/cOxHJTWKLp1ra1n8tHYrEK0r5N2j7MpaJ7DFwczUdfY3OF5eRX1+PZoNgBg5dRok8Rmjaa07F83VCK/J7kEFwqq4SCT4rZRoTrdp4+PM2RSCaobmpFdVm+QOIiIiIhIf0zkiSzQiDB3xAW5QtGswhcHr7yi3Zmfjl+cHS8Ixi+r17i6vx9CPR1QWd+kLZtvz0e7UtGkFDE6wgMjw7ka35FJ0eqGd/tSSqBoVnb7eh/vVq/GLxwRDFcHW53uI7ORIMbPGYB6VZ6IiIiIzIOJPJEFEgQBd09Qr2h/fiATDU1dS9xyK+q189yvH2yasnoNqUTA3ePDAQDr96ZB2c7s8YLKBmw6zNV4XQwIcIGPsxz1TcpuTzQ4k1uJvSklkEoE3NXyM9IVG94RERERmR8TeSILNTPWD4Fu9iirbdSOZdPXLyfyAACjwj0Q6GZvyPB0cuOwYLg72CK7rB7bzha0uf2jXaloVKowMtzD6N30rZ0gCJjcMoYu/kL3yus1q/GzB/kjyN1Br/vGavfJs+EdERERkbkwkSeyUDZSCe68ZEVb1c6KdmdEUcRPx9Ul7caeHd8Re5kUt49W77/+eHdaqwZpRVUN+OZwFgBgJefG62RKyxi6nUldH0OXU16H30/nA7jYx0Afms71Z3PZ8I6IiIjIXJjIE1mwhSOC4Wxng7TiWuy4oF/ydj6/GkmFNZBJJZg50N9IEV7Z7WPCILOR4ER2BY5llmuPf7QrDYpmFYaHumMsV+N1Mq6PF2wkAtKKa5FZWtula3yyNx1KlYjxUV4Y0JKU6yPGzxlSiYDS2kYUVF15tCARERERGR4TeSIL5iS3wS2jQgAA6/ak6XVfzez4qf184GqvWzMzY/B2lmN+S0WApqS7qLoBXx1SN/F7aGofkzbhs2YudrYYFtr1MXSVdU3YfETdk6Arq/EAYGcrRR8fJwCcJ09ERERkLkzkiSzckrFhsJEIOJRehlM5FTrdR6kS8fOJi93qze3uCeotAn+fL0RacQ3W7Vavxg8JccOEPl5mjs66aMbQxSfqX17/5aFM1DUq0c/fpVuvu6bh3Wk2vCMiIiIyCybyRBbO39Uec+ICAADr9qTrdJ8DqaUorFLA1d5W2yDNnKJ8nDG1rw9EEXhjWyK+PKjeG8/VeP1p9skfSC3Va5pBQ5MSn+3LAAAsmxjerdc9NkDd8O4sE3kiIiIis2AiT2QFNKPo/jidj5zyuiuer5kdP3uQP+Q2UqPGpqt7Wkq5/zxTgPomJeKCXDE52vwfMlibaF8n+LvaQdGswoG0Up3vt+V4LkpqFAhwtcPsQQHdikE7go6z5ImIiIjMgok8kRXoH+CCcVGeUKpE7apqR+obldh6Rt2V3Fzd6tszKtwDg4IuNldbOY2r8V2hHkPX0r1exwaIKpWIj1t6LNw5Phy20u7909/P3wWCABRWKVBUzYZ3RERERKbGRJ7IStzTsiq/+Ug2qhqaOjzv7/OFqG1UIsjdXtsYzRIIgoD7J0UCAOKC3bQl4qS/KZp58onFOo2A++d8IdKKa+FsZ4ObR4Z0+/Ed5TaI8HIEAJzlPHkiIiIik2MiT2QlJkV7I9rXCTWKZmxqmb/eni0tZfXzhgRa3Ir3zIH+2LxsND5bMsLiYrMm46K8YCsVkFVWh7SSK4+h00wLuG10KJzkNgaJQVNez33yRERERKbHRJ7ISgiCoN0r/9m+DDQpVW3OKa1RYFeSeizZ9YMtp6z+UqMiPOHhKDN3GFbNUW6DUeGeAK48hu5YZjmOZpZDJpVg6dgwg8UwULNPniPoiIiIiEyuS4n8nj17cNttt2HMmDHIzVWv/n3xxRfYu3evQYMjotauHxwAb2c58isb8Pup/Da3/3YqH0qViEFBrohqmfVNPZNmGsHOK4yh+3h3KgBg7pAA+LjYGezxBwSw4R0RERGRueidyP/www+YPn067O3tcfz4cSgUCgBAZWUlXn31VYMHSEQXyW2kuGNMKAB1ufTl+6M13ernWuhqPBmOpuHdobQy1Cqa2z0nrbgGf50rBAAsa5kaYCj9W0bQ5ZTXo6Ku0aDXJiIiIqLO6Z3Iv/zyy/joo4+wbt062Nraao+PGzcOCQkJBg2OiNq6dVQo7G2lOJdfhQOpF8ePpZfU4kR2BaQSAdfFdW+8GFm+SG9HBHvYo1Gpwv7U9sfQrd+bDlEEpvb1QZSPs0Ef39XeFqGeDgDY8I6IiIjI1PRO5BMTEzFx4sQ2x11dXVFRUWGImIioE+6OMtw0PAgAsK5lpBhwscnd+CgveDvLzRIbmY4gCNrO/+2V15fUKPD9sRwAhl+N14htKa8/zYZ3RERERCaldyLv5+eHlJSUNsf37t2LiAjj/LJIRK3dOS4cgqAeP5ZcWA1RFLHlxMVu9dQ7XNwn33YM3ef7M9DYrMLgYDeMDPcwyuMPCFSX159hIk9ERERkUnon8vfccw9WrlyJQ4cOQRAE5OXl4auvvsLjjz+O+++/3xgxEtFlwrwcMb2/HwBg/Z50HM+uQGZpHRxkUlwzwNfM0ZGpjInwgsxGgtyKeiQX1WiP1zU24/ODmQCAeydGGG3Un2ZFnqX1RERERKal90Dhp556CiqVClOnTkVdXR0mTpwIuVyOxx9/HA8++KAxYiSidtwzMRxbzxbgp+O5qFY0AQCmD/CDg8wwc8LJ8tnLpBgT4YldScWIv1CEaF/1Pvhvj2Sjoq4JYZ4OuGaAn9Eef0BLw7v0klpUNzTB2c72CvcgIiIiIkPQe0VeEAQ8/fTTKCsrw5kzZ3Dw4EEUFxfjpZdeMkZ8RNSBYaEeGBrihkalCn+cLgAAzGVZfa8z5ZLyegBoVqqwfm86AOCuCRGQSoyzGg8Ank5yBLiqR9qd46o8ERERkcl0aY48AMhkMvTv3x8jR46EkxPnVROZwz0TLval8HaWY1ykpxmjIXPQjKE7klGG6oYm/HmmADnl9fBwlOGmYUFGf/wBgZp58kzkiYiIiExF7xrcKVOmdLrfcseOHd0KiIh0d80AP4R4OCCrrA5z4gJgI+3yZ3NkpcK8HBHu5Yj0klrsTS7Bx7vVkwwWjwmFna3U6I8fG+CKv88V4iwb3hERERGZjN6J/ODBg1t939TUhBMnTuDMmTO44447DBUXEelAKhHw+g2D8OWhTNw7iVMjeqvJMd5IL6nFu/8kI7GwGna2EiweE2aSxx4Y1NK5Po+JPBEREZGp6J3Iv/POO+0ef/7551FTU9PubURkPGMiPTGGJfW92pQYH3y2LwOJhdUAgJuGBcPDUWaSx9Z0rk8pqkF9oxL2MuNXARARERH1dgarw73tttvw6aefGupyRESko5HhHrBvKaOXCMDdE8JN9tg+LnbwdpZDJQLnC7hPnoiIiMgUDJbIHzhwAHZ2doa6HBER6cjOVoqxLVUZM2P9EerpaNLHj20ZQ3eG++SJiIiITELv0vr58+e3+l4UReTn5+Po0aN45plnDBYYERHp7okZMfBwlOGRq6NN/tixga6ITyxmIk9ERERkInon8q6urq2+l0gkiImJwYsvvohrrrnGYIEREZHu+vq54I2b4szy2ANa9smfyWVpPREREZEp6J3If/bZZ8aIg4iIrFRsoLq0PqmwGopmJeQ2bHhHREREZEwcOk1ERN0S6GYPNwdbNKtEJBVwegkRERGRsem0Iu/u7g5BEHS6YFlZWbcCIiIi6yIIAmIDXLE3pQRn8ioxMMj1ynciIiIioi7TKZF/9913jfLgq1evxo8//ogLFy7A3t4eY8eOxeuvv46YmJhO7/fdd9/hmWeeQUZGBvr06YPXX38ds2bN0t4uiiKee+45rFu3DhUVFRg3bhw+/PBD9OnTxyjPg4iotxsQ6KJO5NnwjoiIiMjodErk77jjDqM8+K5du7B8+XKMGDECzc3N+Pe//41rrrkG586dg6Nj++OT9u/fj0WLFmH16tWYPXs2vv76a8ydOxcJCQmIjY0FAKxZswZr167Fxo0bER4ejmeeeQbTp0/HuXPnOCKPiMgIYjUN7/LY8I6IiIjI2ARRFMWu3rmhoQGNjY2tjrm4uHQ5mOLiYvj4+GDXrl2YOHFiu+csXLgQtbW1+O2337THRo8ejcGDB+Ojjz6CKIoICAjAY489hscffxwAUFlZCV9fX2zYsAE333xzm2sqFAooFArt91VVVQgODkZlZWW3ng8RUW+RUVKLyW/uhMxGgrMvTIetlC1YiIiIiPRRVVUFV1dXnfJQvX/Tqq2txYoVK+Dj4wNHR0e4u7u3+uqOykp1SaaHh0eH5xw4cADTpk1rdWz69Ok4cOAAACA9PR0FBQWtznF1dcWoUaO051xu9erVcHV11X4FBwd363kQEfU2IR4OcJbboLFZhdRiNrwjIiIiMia9E/knn3wSO3bswIcffgi5XI7169fjhRdeQEBAAD7//PMuB6JSqfDwww9j3Lhx2hL59hQUFMDX17fVMV9fXxQUFGhv1xzr6JzLrVq1CpWVldqv7OzsLj8PIqLeSCIR0D9A/cnx6RzukyciIiIyJr3nyP/666/4/PPPMXnyZCxduhQTJkxAVFQUQkND8dVXX+HWW2/tUiDLly/HmTNnsHfv3i7dvzvkcjnkcrnJH5eIqCeJDXTFofQynM2rwk3mDoaIiIioB9N7Rb6srAwREREA1PvhNePmxo8fj927d3cpiBUrVuC3335DfHw8goKCOj3Xz88PhYWFrY4VFhbCz89Pe7vmWEfnEBGR4cUGqlfk2bmeiIiIyLj0TuQjIiKQnp4OAOjbty++/fZbAOqVejc3N72uJYoiVqxYgZ9++gk7duxAeHj4Fe8zZswYbN++vdWxv//+G2PGjAEAhIeHw8/Pr9U5VVVVOHTokPYcIiIyPE3n+nP5VVCqutxHlYiIiIiuQO9EfunSpTh58iQA4KmnnsL7778POzs7PPLII3jiiSf0utby5cvx5Zdf4uuvv4azszMKCgpQUFCA+vp67TmLFy/GqlWrtN+vXLkSW7duxVtvvYULFy7g+eefx9GjR7FixQoAgCAIePjhh/Hyyy/jl19+wenTp7F48WIEBARg7ty5+j5dIiLSUYS3E+xsJahrVCK9pNbc4RARERH1WHrvkX/kkUe0f542bRouXLiAY8eOISoqCoMGDdLrWh9++CEAYPLkya2Of/bZZ1iyZAkAICsrCxLJxc8bxo4di6+//hr/+c9/8O9//xt9+vTBli1bWjXIe/LJJ1FbW4tly5ahoqIC48ePx9atWzlDnojIiKQSAf39XZCQVYGzeZWI8nEyd0hEREREPZLec+Szs7N7/Hg2feb3ERHRRc/+fAafH8jEPRPC8fS1/c0dDhEREZHVMOoc+bCwMEyaNAnr1q1DeXl5l4MkIqKeR7NP/kxulZkjISIiIuq59E7kjx49ipEjR+LFF1+Ev78/5s6di++//x4KhcIY8RERkRUZoOlcn1cJPQu+iIiIiEhHeifyQ4YMwRtvvIGsrCz8+eef8Pb2xrJly+Dr64s777zTGDESEZGViPZ1hkwqQXVDM7LL6q98ByIiIiLSm96JvIYgCJgyZQrWrVuHf/75B+Hh4di4caMhYyMiIitjK5Wgr78zAOA058kTERERGUWXE/mcnBysWbMGgwcPxsiRI+Hk5IT333/fkLEREZEVGqDZJ5/HRJ6IiIjIGPQeP/e///0PX3/9Nfbt24e+ffvi1ltvxc8//4zQ0FBjxEdERFYmVrNPnivyREREREahdyL/8ssvY9GiRVi7di3i4uKMERMREVkxTef6s3lVEEURgiCYOSIiIiKinkXvRD4rK4u/lBERUYdi/JwhlQgoq21EfmUDAtzszR0SERERUY+i9x55JvFERNQZO1sp+vg4AWB5PREREZExdLnZHRERUUdiAzUN76rMHAkRERFRz8NEnoiIDC42QN3w7ixX5ImIiIgMjok8EREZ3MUVeSbyRERERIbGRJ6IiAyun78LBAEorFKgqLrB3OEQERER9Sh6J/KFhYW4/fbbERAQABsbG0il0lZfREREjnIbRHqrG96dzeU+eSIiIiJD0nv83JIlS5CVlYVnnnkG/v7+7GJPRETtig1wQUpRDc7kVmJKXx9zh0NERETUY+idyO/duxd79uzB4MGDjRAOERH1FLGBrthyIo/75ImIiIgMTO/S+uDgYIiiaIxYiIioBxkQ0NLwjqX1RERERAaldyL/7rvv4qmnnkJGRoYRwiEiop6if8sIutyKepTXNpo5GiIiIqKeQ+/S+oULF6Kurg6RkZFwcHCAra1tq9vLysoMFhwREVkvV3tbhHo6ILO0DmfzqjC+j5e5QyIiIiLqEfRO5N99910jhEFERD1RbIArMkvrcCavkok8ERERkYHoncjfcccdxoiDiIh6oAGBLvj9dD7O5LLhHREREZGh6J3IA4BSqcSWLVtw/vx5AMCAAQMwZ84czpEnIqJWYlsa3p3NY8M7IiIiIkPRO5FPSUnBrFmzkJubi5iYGADA6tWrERwcjN9//x2RkZEGD5KIiKzTgJaGd+kltahuaIKzne0V7kFEREREV6J31/qHHnoIkZGRyM7ORkJCAhISEpCVlYXw8HA89NBDxoiRiIislKeTHAGudgC4Kk9ERERkKHqvyO/atQsHDx6Eh4eH9pinpydee+01jBs3zqDBERGR9YsNdEVeZQPO5FZidISnucMhIiIisnp6r8jL5XJUV1e3OV5TUwOZTGaQoIiIqOeIDeQ+eSIiIiJD0juRnz17NpYtW4ZDhw5BFEWIooiDBw/ivvvuw5w5c4wRIxERWbHYQPU+eXauJyIiIjIMvRP5tWvXIjIyEmPGjIGdnR3s7Owwbtw4REVF4b333jNGjEREZMU0netTi2tQ19hs5miIiIiIrJ/ee+Td3Nzw888/Izk5GRcuXAAA9OvXD1FRUQYPjoiIrJ+Pix28neUorlbgfH41hoW6mzskIiIiIqvWpTnyANCnTx/06dPHkLEQEVEPFRvggvjEYpzNq2QiT0RERNRNOiXyjz76KF566SU4Ojri0Ucf7fTct99+2yCBERFRzxEb6Ir4xGLukyciIiIyAJ0S+ePHj6OpqUn7ZyIiIn0MaNknfyaXneuJiIiIukunRD4+Pr7dPxMREelC07k+qbAaimYl5DZSM0dEREREZL307lp/5513tjtHvra2FnfeeadBgiIiop4l0M0ebg62aFaJSCxo+38IEREREelO70R+48aNqK+vb3O8vr4en3/+uUGCIiKinkUQBO0YOpbXExEREXWPzl3rq6qqIIoiRFFEdXU17OzstLcplUr88ccf8PHxMUqQRERk/WIDXbE3pQRn8tjwjoiIiKg7dE7k3dzcIAgCBEFAdHR0m9sFQcALL7xg0OCIiKjn0OyTP8vO9URERETdonMiHx8fD1EUcdVVV+GHH36Ah4eH9jaZTIbQ0FAEBAQYJUgiIrJ+mtL68wXVaFKqYCvVe3cXEREREUGPRH7SpEkAgPT0dISEhEAQBKMFRUREPU+IhwOc5TaoVjQjpagG/fxdzB0SERERkVXSezlkx44d+P7779sc/+6777Bx40aDBEVERD2PRCKgf4A6eT/D8noiIiKiLtM7kV+9ejW8vLzaHPfx8cGrr75qkKCIiKhnig1Ul9efzWPneiIiIqKu0juRz8rKQnh4eJvjoaGhyMrKMkhQRETUM2ka3nFFnoiIiKjr9E7kfXx8cOrUqTbHT548CU9PT4MERUREPZOm4d25/CooVaKZoyEiIiKyTnon8osWLcJDDz2E+Ph4KJVKKJVK7NixAytXrsTNN99sjBiJiKiHiPB2gp2tBHWNSqSX1Jg7HCIiIiKrpHPXeo2XXnoJGRkZmDp1Kmxs1HdXqVRYvHgx98gTEVGnpBIB/f1dkJBVgTO5VYjycTZ3SERERERWR+8VeZlMhs2bN+PChQv46quv8OOPPyI1NRWffvopZDKZMWIkIqIeRNPwjvvkyZq8+Os5jF29HQWVDeYOhYiISP8VeY3o6GhER0cbMhYiIuoFNIn8p/vS8cXBTDNHo5twL0d8d98YONvZmjsUMgOlSsTmI1mobVRi29kC3DE2zNwhERFRL6d3Iq9UKrFhwwZs374dRUVFUKlUrW7fsWOHwYIjIqKeZ3yUFxxlUtQ2KqFoVl35DhbgQkE19qWUYkasn7lDITNIKqxGbaMSAHAwrZSJPBERmZ3eifzKlSuxYcMGXHvttYiNjYUgCMaIi4iIeqgAN3scfnoaKuqbzB2KTt76KxE/JuTiWGYZE/leKiGrXPvnQ+llEEWRv/8QEZFZ6Z3Ib9q0Cd9++y1mzZpljHiIiKgXcJTbwFHe5d1dJjU+yqslkS+/8snUIx3PqtD+uay2EclFNYj2ZaNGIiIyny41u4uKijJGLERERBZneKgHAOBMbhUampRmjobMQbMi7yCTAgAOpZWaMxwiIiL9E/nHHnsM7733HkRR7PaD7969G9dddx0CAgIgCAK2bNnS6flLliyBIAhtvgYMGKA95/nnn29ze9++fbsdKxER9U7BHvbwcpKjUalip/1eqKKuEWnFtQCAm0eEAAAOppWZMyQiIiL9S+v37t2L+Ph4/PnnnxgwYABsbVt38P3xxx91vlZtbS3i4uJw5513Yv78+Vc8/7333sNrr72m/b65uRlxcXG46aabWp03YMAA/PPPP9rvNfPuiYiI9CUIAoaFumHb2UIcyyzH8DAPc4dEJnQ8uwIAEOHliBmxfvh0XzoOpZdynzwREZmV3hmum5sb5s2bZ5AHnzlzJmbOnKnz+a6urnB1ddV+v2XLFpSXl2Pp0qWtzrOxsYGfn+4NiRQKBRQKhfb7qqoqne9LREQ93/BQD2w7W4ijmeW419zBkEkdb+mNMDjEDXHBrpDbSFBS04jU4hpE+XCfPBERmYfeifxnn31mjDi65JNPPsG0adMQGhra6nhycjICAgJgZ2eHMWPGYPXq1QgJCenwOqtXr8YLL7xg7HCJiMhKDQ11BwAkZJZzJbaX0azIDw1xh9xGiqEh7jiQVooDaWVM5ImIyGz03iNvKfLy8vDnn3/i7rvvbnV81KhR2LBhA7Zu3YoPP/wQ6enpmDBhAqqrqzu81qpVq1BZWan9ys7ONnb4RERkRWIDXSCzkaC0thEZpXXmDodMRKUScaKlY/2QEDcAwOgITwBseEdEROal94p8eHh4pysRaWlp3QpIVxs3boSbmxvmzp3b6vilpfqDBg3CqFGjEBoaim+//RZ33XVXu9eSy+WQy+XGDJeIiKyY3EaKQYGuOJpZjmOZ5Qj3cjR3SGQCKcU1qFY0w0EmRUzLuLlREeoeCQfTOE+eiIjMR+9E/uGHH271fVNTE44fP46tW7fiiSeeMFRcnRJFEZ9++iluv/12yGSyTs91c3NDdHQ0UlJSTBIbERH1TMPC3LWJ/I3DgswdDplAQsv++LggN9hI1UWMg4PdILORoKRGgbSSWkR6O5kzRCIi6qX0TuRXrlzZ7vH3338fR48e7XZAuti1axdSUlI6XGG/VE1NDVJTU3H77bebIDIiIuqphoWo98kfy+Tosd5CMz9eU1YPAHa2UgwNccPBtDIcTCtlIk9ERGZhsD3yM2fOxA8//KDXfWpqanDixAmcOHECAJCeno4TJ04gKysLgHrv+uLFi9vc75NPPsGoUaMQGxvb5rbHH38cu3btQkZGBvbv34958+ZBKpVi0aJF+j8pIiKiFpqGd0mFNaisbzJzNGQKx1v2xw9t+RBHY1S4Zp88P9QhIiLzMFgi//3338PDQ7/ZukePHsWQIUMwZMgQAMCjjz6KIUOG4NlnnwUA5Ofna5N6jcrKSvzwww8drsbn5ORg0aJFiImJwYIFC+Dp6YmDBw/C29u7C8+KiIhIzctJrt0br1mppZ6rsr4JyUU1ANSj5y6laXh3ME09T56IiMjU9C6tHzJkSKvGLqIooqCgAMXFxfjggw/0utbkyZM7/Q9ww4YNbY65urqirq7jjsGbNm3SKwYiIiJdDQ1xR3pJLRIyyzElxsfc4ZARnWgZOxfq6QAvp9YNcYeEuEEmlaCoWoH0klpEsLyeiIhMTO9E/vIu8RKJBN7e3pg8eTL69u1rqLiIiIgszvAwd/yQkIOjGVyR7+mOt1RdXF5WD6j3yQ8OccPh9DIcSi9jIk9ERCanUyL/6KOP4qWXXoKjoyOmTJmCMWPGwNbW1tixERERWZRhLfvkT2RXoFmp0nYytxQ1imZsPVOA6QN84WzH/6e7I+Gy+fGXGx3ugcPp6oZ3i0aGmC4wIiIi6LhH/r///S9qatT7xKZMmYLycq5EEBFR7xPl7QQXOxvUNylxoaDa3OG08X87UvD4dydx7xfHoFRx73ZXqVQiTnSyIg9c3Cd/qGWePBERkSnptCIfFhaGtWvX4pprroEoijhw4ADc3dv/j23ixIkGDZCIiMhSSCQChoa6Y2diMY5mlCE20NXcIbWy/XwhAGB/ainej0/BQ1P7mDki65RWUoOqhmbY2UoQ4+fc7jlDQtwhk0pQUNWAzNI6hLU0QiQiIjIFnRL5N954A/fddx9Wr14NQRAwb968ds8TBAFKpdKgARIREVmSYSHqRP5YVgWWjDN3NBflVdRru6wDwLv/JGFUuAdGtawcWxqVSsRXhzIR4e2EcVFe5g6nlYTMCgDAoCA32HawfcJeJkVcsCuOZJTjUHopE3kiIjIpnUrr586di4KCAlRVVUEURSQmJqK8vLzNV1kZ56kSEVHPNixMXZF2LMOy/s/bnVQMABga4oYbhgZBJQIPbTqO0hqFmSNr3zv/JOGZn8/ivi+PoUmpMnc4rRzP7rysXuPiGDrLei8QEVHPp1eXHicnJ8THxyM8PByurq7tfhEREfVkg4PdIJUIyKtsQF5FvbnD0drVkshPjPbGi9cPQKS3IwqrFHj8u5NQWdh++V9P5uG/O1IAANUNzUjItKzeO5oV+Y4a3WmMCtfsk+c8eSIiMi292+1OmjQJNjZ6T60jIiLqERxkNujv7wIAOGYhCWizUoW9KSUAgEnR3nCU2+D/bhkKmY0E8YnF+GRvupkjvOhMbiWe+P4kAMBZrv59YmfLhxCWoLqhCUlF6kaGV0rkh4a6wVaq/lAnu8xyPtQhIqKez7Lm5hAREVkBzRg6S0nkT2RXoLqhGW4OthgU5AYA6Ofvgueu6w8AeH3rBe1cdHMqqm7APZ8fRUOTClNivPHcnAEAgF2JlpPIn8yuhCgCQe728HG26/RcB5mN9vU+mFZqguiIiIjUmMgTERHpydISec3++PFRXpBKBO3xW0aG4NpB/mhWiXjwm+OorG8yV4hQNCtx3xfHkF/ZgEhvR7y3aAgmx3gDAM7lV6GoqsFssV0q4Qpj5y43OsIDAHAwnYk8ERGZDhN5IiIiPWkS+XP5VahrbDZzNBf3x0+K9m51XBAErJ4/ECEeDsgpr8dTP5wyy15uURTx9E9nkJBVARc7G6y/YwRc7Gzh5STHoCDXVs/B3I5rE3k3nc6/dJ48ERGRqXQ5kU9JScG2bdtQX6/eE8YmL0RE1FsEuNnD39UOSpWIk9mVZo2lrLYRp3LVMUy8LJEHABc7W/x30RDYSgX8eaYAXx7MNHWI+GRvOr4/lgOpRMD7tw5F+CWj2jQfPljCPnlRFHE8uwKAek68LoaFusNGIiC3oh7ZZXVGjI6IiOgivRP50tJSTJs2DdHR0Zg1axby8/MBAHfddRcee+wxgwdIRERkiS6W15t3JXZPcjFEEejr5wxfl/b3dMcFu+Gpmf0AAC/9fh5n80z34cPOxCK8+sd5AMB/ru2HCX1af9igKa/fm1yCZjOPoUsvqUVFXRPkNhL0a2loeCXqffLqqgLukyciIlPRO5F/5JFHYGNjg6ysLDg4OGiPL1y4EFu3bjVocERERJbKUvbJa8vqY9quxl/qznFhmNbPB43NKjz49XHUKIy/JSC1uAYPfnMcKhFYODwYS8aGtTknLsgNLnY2qKxvwsmcCqPH1JmELPXjDwx0hcxG91+RRmnK69NZXk9ERKahdyL/119/4fXXX0dQUFCr43369EFmpunL9YiIiMxheKi6ydmxzHKzzWlXqUTsTmoZO9en80ReEAS8cWMc/F3tkFZSi2e2nDHqtrjKuibcs/EoqhuaMSLMHS/NjYUgCG3Os5FKMKGlvN7c3eu1je5CdSur19Dsk+eKPBERmYreiXxtbW2rlXiNsrIyyOVygwRFRERk6fr6O8PeVoqqhmakFteYJYbzBVUoqVHAQSbFsLArJ5/ujjKsXTQEUomAn47n4vtjOUaJq1mpwoObjiOtpBYBrnb48LZhna5wW8o++eMtK/K6NrrTGBbqDqlEQE55PXLKuU+eiIiMT+9EfsKECfj888+13wuCAJVKhTVr1mDKlCkGDY6IiMhS2UolGBzsBgA4aqbyek1Z/dhIT8htpDrdZ0SYBx69OhoA8OzPZ5FcWG3wuFb/eQG7k4phbyvFujuGw8up8w/6J7ck8qdyKlFSozB4PLqoUTQjsaAKgO6N7jSc5DYYGKjeJ8/u9UREZAp6J/Jr1qzBxx9/jJkzZ6KxsRFPPvkkYmNjsXv3brz++uvGiJGIiMgimXufvKYUvb1u9Z25f1IkJvTxQn2TEiu+Po6GJqXBYvr2aDY+2ZsOAHh7QRwGBLhe8T4+Lnba5nJ7ks2zKn8qpwIqEQh0s++waWBnRmnmybO8noiITEDvRD42NhZJSUkYP348rr/+etTW1mL+/Pk4fvw4IiMjjREjERGRRdIk8glmSORrFM3aDxAunx9/JRKJgLcXDIaXkxyJhdV44ddzBonpWGYZ/vPTGQDAyql9MHOgv8731XSvN9c+eU1Z/RA9y+o1RrPhHRERmZBNV+7k6uqKp59+2tCxEBERWZWhLSXYaSW1KK1RwPMKJeSGtD+lBM0qEWGeDgj1dLzyHS7j7SzHezcPxm2fHMI3h7MwJtITc+ICuhxPbkU97v3iGBqVKsyM9cPKqX30uv+kaG98uDMVu5NLoFKJkEjaNsYzJs2HMfqW1WsMb9knn1VWh7yKegS42RsyPCIiolb0XpGPiorC888/j+TkZGPEQ0REZDVcHWzRx8cJwMXRZaai2R+vb1n9pcZFeWHFlCgAwL9/PI2MktouXae+UYllnx9FSU0j+vm74K0FcXon4sNC3eEkt0FZbSNO55puzj0AiKKI49kVAPRvdKfhbGeL2AD19oBD6SyvJyIi49I7kV++fDl+//13xMTEYMSIEXjvvfdQUFBgjNiIiIgs3vCWbvFHM01XUi2K4sX58d1I5AF1CfzIMA/UKJrx4DfHoWjWb7+8KIp4/PuTOJtXBU9HGdYtHgYHmf4Ff7ZSCcZFqcvTd5q4vD6ztA5ltY2QSSXo35KMd4V2DF0qy+uJiMi49E7kH3nkERw5cgQXLlzArFmz8P777yM4OBjXXHNNq272REREvYGmvN6U++TTS2qRU14PW6mgTR67ykYqwXuLBsPdwRancyvx2p8X9Lr//+1Iwe+n8mErFfDR7cMQ5N52RK2uJsf4AAB2JRV1+RpdoZkfHxvoonP3//ZoGt5xRZ6IiIxN70ReIzo6Gi+88AKSkpKwZ88eFBcXY+nSpYaMjYiIyOIND1MnbydzKvVeze6q3S2r8SPCPOAo71K7m1b8Xe3x1oI4AMBn+zLw11ndKu22ninAW38nAQBeuj4WI1pei67SVBecyK5ARV1jt66lj4vz47u2P15jeJgHJAKQUVqHgsoGA0RGRETUvi4n8gBw+PBhPPzww5g3bx6SkpJw0003GSouIiIiqxDm6QAPRxkam1U4m1dlksc0VFn9pa7q64t7JoQDAJ74/hRyK+o7Pf98fhUe/fYEAGDJ2DDcPDKk2zEEuNkj2tcJKhHYk1zS7evpSrMi39VGdxoudrbacXtclSciImPSO5FPSkrCc889h+joaIwbNw7nz5/H66+/jsLCQmzatMkYMRIREVksQRBMWl7f0KTEgZZZ5d1pdNeeJ6b3RVywGyrrm/DQN8fRpFS1e15pjQJ3bzyKukYlxkd54T/X9jNYDJoPJ0y1T76usRkXCqoBAEND3bp9vdGcJ09ERCagdyLft29fbN26FcuXL0dOTg62bduGxYsXw8nJyRjxERERWTxtw7sM4yfyRzPK0dCkgo+zHH39nA16bZmNBP+3aAic7WxwLLMcb7eUzV+qsVmF+79KQG5FPcI8HfB/twyBjbRbBX6tXNwnXwyVSjTYdTtyKqcSSpUIPxc7+Lt2f2SctuFdGhveERGR8ej9P29iYiIOHTqElStXwtfX1xgxERERWZVhoepE/lhWOUTRuMmnphHcpGhvCILhZ60Hezjg9RsGAQA+3JmqLeMH1B3qn/vlLA6nl8FJboP1dwyHm4PMoI8/PMwdDjIpSmoUOJdv/K0KmrJ6Q6zGA+p98oKgbkhYWMV98ldSo2jG7P/uwdLPDhv97w4RUU+idyLfp08fY8RBRERktQYGusJWKqC4WoHsss73lneXIebHX8msgf64bbR6z/ujm0+gqCUh/eJgJr45nAVBANYuGowoH8NWBACA3EaKsZHqVe1LP0QwFkM1utNwtbfFgJYRdiyvv7J1u9NwJrcK8YnFOJ1bae5wiIishk6JvIeHB0pK1E1n3N3d4eHh0eEXERFRb2NnK0VsoLrJ2bEs45VU51fWI6mwBhIBGB/lZbTHAYD/XNsfff2cUVrbiJWbTmBPcjFe+PUcAOBfM/riqr7Gq8rT7JPfZeR98qIo4ri20Z2bwa47Klz9QcShdJbXd6a4WoF1e9K03/9yIs+M0RARWRedZta88847cHZ21v7ZGKV8RERE1mx4qDuOZ1XgaEY55g0JMspjaMbOxQW7wd3RsCXtl7OzleL9W4fiuv/uxYG0UhzOKINSJWLekEDcOzHCqI89KdoHwFkcyypHVUMTXOxsjfI4OeX1KKlphK1U0HabN4TREZ74ZG86V+Sv4P92JKOuUQkXOxtUNTTjt1P5+PesfpBI+HsmEdGV6JTI33HHHdo/L1myxFixEBERWa1hoe5Ytycdx4zYuV5bVt/HeGX1l4r0dsLLc2Px6LcnoVSJiAt2w+r5A43+gX6IpwMivByRVlKLfcklmDnQ3yiPo9kf3z/AFXa2UoNdd2TLPvm04loUVTfAx9nOYNfuKTJLa/H14SwAwNpFQ/DgN8dRUNWAwxll2oaBRETUMb33yEulUhQVFbU5XlpaCqnUcP8JEhERWZOhLQ3vEgurUdXQZPDrNytV2NsyW31SjGkSeQCYPzQIj14djYnR3vj49mEGTXg7o3mOxtwnrxkXONSAZfUA4Opgi35+6n3yh9i9vl1v/ZWEJqWIidHemBzjgxkD/AAAv55keT0RkS70TuQ76iiqUCggkxm3zI+IiMhS+TjbIcTDAaIInGhpoGZIJ3MqUNXQDFd7W8QFuRn8+p15aGoffH7nSPi6mG5lWbtPPqnYaN3Mj2dXADBco7tLXRxDx/L6y53JrcQvLQn7v2bEAACuiwsAAPxxOh9NSpXZYiMishY6ldYDwNq1awEAgiBg/fr1rebGK5VK7N69G3379jV8hERERFZiWKg7ssrqcCyz3OBd5TWN38b38YK0F+whHh3hCbmNBPmVDUgqrEGMn2E75Dc0KXEuTz3ezpCN7jRGRXjg033pbHjXjte3XgAAXD84QNubYGykJ7ycZCipacTelBJMifExZ4hERBZP50T+nXfeAaBekf/oo49aldHLZDKEhYXho48+MnyEREREVmJYqDt+Op5rlH3yuzRl9UYcO2dJ7GylGB3hiV1JxdiVVGTwRP50biWaVSJ8nOUIdLM36LUBYFS4ep98SlENiqsV8HaWG/wxrNH+lBLsSS6BrVTAY1fHaI/bSCWYNdAfnx/IxK8n8pjIExFdgc6l9enp6UhPT8ekSZNw8uRJ7ffp6elITEzEtm3bMGrUKGPGSkREZNGGteyTP55VDqXKcOXgZbWNOJVTAcB0je4sweSWffI7jTCGTrM/fkiIm1Ga97k5yBDjq/7w4TBX5QGoF4Nea1mNv3VUKEI8HVrdPqelvH7b2QI0NClNHh8RkTXRe498fHw83N0Nv5eMiIjI2kX7OsNZboPaRiUuFFQZ7Lp7koshikBfP2f4ufaeDuia6oMjGWWoVTQb9NqajvXG2B+vwX3yrf1xugCncirhKJNixVVRbW4fGuKOQDd71DYqEX+hbWNlIiK6SO9E/oYbbsDrr7/e5viaNWtw0003GSQoIiIiaySVCBjcst86wYDl9buTeldZvUa4lyNCPBzQpBSxP9VwybAoikhoaUiomTZgDKMjPAAAh9KZyDcpVXjzr0QAwN0TIuDl1HargUQiYPYg9ajBX9i9noioU3on8rt378asWbPaHJ85cyZ2795tkKCIiIislaa8/qiBEnlRFLE7uWV+fC9L5AVBuKR7veFWaHMr6lFcrYCNRMDAQFeDXfdyI8PVK/JJhTUorVEY7XGswbdHs5FeUgtPRxnumRjR4Xma7vXbLxSh2ghjHImIegq9E/mampp2x8zZ2tqiqspwZYRERETWaHioehXWUA3vzudXo7haAXtbKYaH9b6tbZfukzfUGLrjLavx/QNcYGcr7fzkbvBwlKGvH/fJ1zU2491/kgEAD14VBSd5x72WBwS4IMLbEY3NKvx1ttBUIRIRWR29E/mBAwdi8+bNbY5v2rQJ/fv3N0hQRERE1mpwiBskApBTXo/CqoZuX29Xkno1fmykJ+Q2xks6LdWYSE/IpBLklNcjraTWINfU7I8fEuxmkOt1ZlS4+oOd3rxP/rN9GSiuViDYwx63jArt9FxBELRN7349xfL63uRMbiXO5FaaOwwiq6Hz+DmNZ555BvPnz0dqaiquuuoqAMD27dvxzTff4LvvvjN4gERERNbESW6Dvn4uOJdfhWOZ5Zg10L9b19OUlPe2snoNB5kNRoZ7YG9KCXYmFiPS26nb1zTF/niN0RGe2HggEwfTeueKfHltIz7amQoAePyaGMhsrryGdF1cAN79Jxl7k0tQVtsID8e2laDUszQ0KXHzxwehEkUc+8/VsJf1vg8tifSl94r8ddddhy1btiAlJQUPPPAAHnvsMeTk5OCff/7B3LlzjRAiERGRddHsk+9ueX2Noll7jd7W6O5SF/fJd38MXUOTEufy1Kt+xuxYrzGyZUU+sbAaZbWNRn88S/N+fAqqFc3o7++C6wYF6HSfSG8nDAhwQbNKxB+n840cIVmC7LI61CiaUdeoRGaZYSpviHo6vRN5ALj22muxb98+1NbWoqSkBDt27MCkSZMMHRsREZFV0uxl727DuwOppWhSigj1dECYl6MhQrNKmn3yB9NKUd/YvfniZ/Mq0aQU4eUkQ5C7vSHC65SnkxzRvuoqgsO9rHt9TnkdPj+QCQD418y+kEgEne+rKa9n9/reIbO0rt0/E1HHupTIV1RUYP369fj3v/+NsjJ1qVhCQgJyc3MNGhwREZE10qz0ns2tRENT1xNPbVl9n967Gg8AUT5OCHC1Q2OzCge7mQwnZFYAAIaEuEMQdE8su2NUuGaefO8qr3/n72Q0KlUYE+GJiX289Lrv7JZE/khGGfIr640RHlmQzLKLyXsWE3kineidyJ86dQrR0dF4/fXX8cYbb6CiogIA8OOPP2LVqlWGjo+IiMjqBLnbw8dZjmaViJPZFV26hiiK2lLy3lxWD7SMoWtZld+V2L3y+uPZ6ioJU5TVa4yO0CTyvWdFPrGgGj8ezwGgXo3X90OTQDd7jAhzhygCv59ieX1Pl1V6sZyepfVEutE7kX/00UexZMkSJCcnw87OTnt81qxZnCNPREQEdeKpKa8/ltW18vqM0jpkl9XDVipgTKSnIcOzSpOifQB0f5/8xRV5t25GpLtL98lX1PWOffJvbLsAUQRmDfTD4C5OB7iO5fW9xqUr8iyttw51jc3YcaEQKpVhxoKS/vRO5I8cOYJ77723zfHAwEAUFBQYJCgiIiJrp1nxTejiPvldieqy+uGhHnDsZO52bzEuyhM2EgHpJbXILO3ail1+ZT0KqhoglQgYFORq4Ag75u0sR5SPE0QRONQL5skfySjDP+eLIJUIePyamC5fZ9ZAf0glAk7lVCLdQKMHyTJdWk6fVcZE3hqs+vE07txwFN8fyzF3KL2W3om8XC5HVVVVm+NJSUnw9u7dpX9EREQaw8PUq7DHMsshivqvWOxOLgEAbUl5b+dsZ6udBtDVVXnNanxfP2c4yEz74cjoCPX74VAP3ycviiJe+/MCAGDB8GBEdGNcoJeTHGNbqlF+5ap8j6VUicguv5i855TXo0mpMmNEdCVF1Q3aLS/7U0vMHE3vpXciP2fOHLz44otoamoCoC4fzMrKwr/+9S/ccMMNBg+QiIjIGvX3d4HcRoLyuiak6bma2NCkxIFU9X7q3t7o7lKaDzV2dnGffEKW6ffHa1xseNez98n/fa4QxzLLYWcrwcPT+nT7epd2r+/KB2Jk+fIq6tGkFCGTSiC3kUCpEpFXwQaHluy7ozlobimpP5VTaeZoei+9E/m33noLNTU18PHxQX19PSZNmoSoqCg4OzvjlVde0etau3fvxnXXXYeAgAAIgoAtW7Z0ev7OnTshCEKbr8tL+t9//32EhYXBzs4Oo0aNwuHDh/V9mkRERN0is5EgrmVv8LEM/crrj2aUo75JCW9nOfr5OxshOus0uWWf/IHU0i5NAziuSeRD3QwZlk5GtazIny+oQmVdk8kf3xSUKhFvbEsEANw5Lhy+LnZXuMeVTY/1g0wqQUpRDS4UVHf7emR5NKX0QR72CPFwAMB98pZMpRKx6UiW9vu0klpU1vfMf9Msnd6JvKurK/7++2/8+uuvWLt2LVasWIE//vgDu3btgqOjfjNua2trERcXh/fff1+v+yUmJiI/P1/75ePjo71t8+bNePTRR/Hcc88hISEBcXFxmD59OoqKivR6DCIiou7SlIIf03Of/O7ki93qTTUizRr083eGj7Mc9U1KHMnQr0Rd0azEmVz11sAhwaZfkfdxtkOEtyNEETisZ+zW4oeEHCQX1cDV3hb3Too0yDVd7GwxuaUSg03veiZN0h7q4YBQz5ZEnvvkLdaelBJkl9XDxc4GAa7qD+tOc1XeLLo0Rx4Axo8fjwceeABPPvkkpk2b1qVrzJw5Ey+//DLmzZun1/18fHzg5+en/ZJILj6Nt99+G/fccw+WLl2K/v3746OPPoKDgwM+/fTTDq+nUChQVVXV6ouIiKi7hrWUcB/N1C9x04xYm9jLx85dThAE7Sg+fcfQncurQqNSBQ9HmTZZMLWePIauoUmJd/5OAgCsmBIFV3tbg117zmB1ef2vLK/vkTTj5kI9HRHioV4UzOpiQ0syvq8PZQIA5g8NwrCWXjAncyrMGFHvpVOnl7Vr12LZsmWws7PD2rVrOz3XyckJAwYMwKhRowwSYHsGDx4MhUKB2NhYPP/88xg3bhwAoLGxEceOHWs1z14ikWDatGk4cOBAh9dbvXo1XnjhBaPFS0REvdPQlhX51OJalNc2wt1RdsX7FFQ2ILGwGoIATIjyMnaIVmdSjDe+O5aDnUnF+I8e90vIqgAADAl2M1uVw6hwD3x9KAuH0nteIv/5gQzkVzYgwNUOt48JNei1p/b1haNMipzyehzPrjBLjwMyHk3H+hAPB0gl6r+bLK23TIVVDfjnvLrK+dZRIdiVVIxfT+bhRHaFeQPrpXRK5N955x3ceuutsLOzwzvvvNPpuQqFAkVFRXjkkUfwxhtvGCRIDX9/f3z00UcYPnw4FAoF1q9fj8mTJ+PQoUMYOnQoSkpKoFQq4evr2+p+vr6+uHDhQofXXbVqFR599FHt91VVVQgODjZo7ERE1Pt4OMoQ4e2ItOJaJGSVY2o/3yveZ3dLR/a4IDedEv/eZkKUNyQCkFJUg5zyOgS567a6rm10F2q+JFCzIn82rwqV9U0GXbU2p8r6JrwfnwoAeOTqaNjZSg16fXuZFFf398WWE3n45UQeE/keRlta7+kASUsizxF0lmnzkWwoVSJGhLmjj68zKlr2xp/iirxZ6JTIp6ent/vnjvz999+45ZZbDJ7Ix8TEICbm4jzSsWPHIjU1Fe+88w6++OKLLl9XLpdDLpcbIkQiIqJWhoe6I624FscydUvkNaPVWFbfPlcHWwwJccexzHLsSirGraN0W/09oVmRD3EzXnBX4OtihwgvR6SV1OJoRplO7wdr8NGuVFTWNyHa1wnzhwYZ5THmDA7AlhN5+P10Pp6Z3V+7ckvWTRRFbdIe6ukAiXAxkRdFkT1CLIhSJWLTYXWTu1tGhQAABgS4QCIAhVUKFFQ2wM+1+w0uSXdd3iPfmfHjx+M//9Gn4K3rRo4ciZSUFACAl5cXpFIpCgsLW51TWFgIPz8/k8RDRER0KX0a3jUrVdib0jI/nol8hybruU++sKoBuRX1kAjqSgdz0nSv7yn75AsqG/DZPvUizxPT+xotwR4f5Q1Xe1sUVyt6zGtHQGltI2oUzRAEIMjdAUHuDpAIQF2jEsU1CnOHR5fYlVSEvMoGuDnYYmasPwDAQWaDaF/1ZBXukze9LiXy27dvx+zZsxEZGYnIyEjMnj0b//zzj/Z2e3t7rFy50mBBdubEiRPw91e/mWQyGYYNG4bt27drb1epVNi+fTvGjBljkniIiIguNSz0YjOgJqWq03NP5lRqS67jglxNEZ5V0syT35dSgsbmzl9T4OLYuRg/FzjKdSpGNBpNef2h9J7Ruf697UloaFJheKg7pvXzufIdukhmI8GsgepFmV9OsHt9T6Epq/d3sYOdrRQyGwn8Xe1b3UaW4etD6tX4G4YGtdo+o/lw9CT3yZuc3on8Bx98gBkzZsDZ2RkrV67EypUr4eLiglmzZuk9Rq6mpgYnTpzAiRMnAKjL9k+cOIGsLPUbZdWqVVi8eLH2/HfffRc///wzUlJScObMGTz88MPYsWMHli9frj3n0Ucfxbp167Bx40acP38e999/P2pra7F06VJ9nyoREVG3RXg5ws3BFg1NKpzL63wqiqasfnyUF2ykRima6xFiA1zh6ShDbaNSp0qHBAsoq9cYFa5O5M/kVqKqwbpnL6cW1+DbozkAgKdm9jV6GfR1ceru9X+eydfpAxyyfFktHetDLpkkEebFWfKWJq+iHjsuqJvcLRoZ0uq2uGA3AMApjqAzOb0/ln711VfxzjvvYMWKFdpjDz30EMaNG4dXX321VVJ9JUePHsWUKVO032sazt1xxx3YsGED8vPztUk9oO5K/9hjjyE3NxcODg4YNGgQ/vnnn1bXWLhwIYqLi/Hss8+ioKAAgwcPxtatW9s0wCMiIjIFiUTA0BB37LhQhKOZ5dpfetqjaXTHsvrOSSQCJkZ746fjudiZVIQxkZ6dnp/QkuxbQpM0P1c7hHk6IKO0DkczynBVX+v9/eTNbYlQqkRM6+eD4S1jqIxpVLgnfJzlKKpWYHdSMab1t97XjtQuzpB31B4L8XDEPpRyBJ0F2XwkGypRPXkjysep1W1xwerqsZM5FVCpRG3DQjI+vT/ur6iowIwZM9ocv+aaa1BZqd8nMZMnT4Yoim2+NmzYAADYsGEDdu7cqT3/ySefREpKCurr61FaWor4+PhWSbzGihUrkJmZCYVCgUOHDhl1FB4REdGVaPbJJ3Syelxe26jdYzghmmPnrmRyjG775BubVTidq/79ZKgFrMgDF1flD6VZb3n98axy/HmmABJBvTfeFKQSAbMHqVflfznJ8vqeQDt67pIV+dCWP2eyc71FaFaqsPlINgDg1tFtm4tG+zpDbiNBdUMzMvjhi0npncjPmTMHP/30U5vjP//8M2bPnm2QoIiIiHoSTSJ/NLMMoii2e86elBKIIhDj66zdI0odm9DHG4IAXCioRkFlQ4fnnc+vgqJZBTcHW4R7OXZ4nimNjrTuhneiKOK1P9VjfecPDUKMn7PJHvu6OHVfpL/PFaKusdlkj0vGkXlJx3qNUA+W1luS+MRiFFQ1wMNRhukD2lbB2EoliA28uCpPpqNTaf3atWu1f+7fvz9eeeUV7Ny5U9tA7uDBg9i3bx8ee+wx40RJRERkxeKC3GAjEVBYpUBuRX27s8+1ZfUxLKvXhYejDIOC3HAyuwK7k4qxYERwu+dpGt0NCXazmFFW2n3yeVWobmiCs511zZPfmVSMQ+llkNlI8MjV0SZ97MHBbgjxcEBWWR22ny/S7psn69RuaX1LUs9Z8pbh60OZAICbhgVBbiNt95xBQa44llmOk9mVmDfEOCMoqS2dEvl33nmn1ffu7u44d+4czp07pz3m5uaGTz/91GRj54iIiKyFvUyKAQEuOJlTiWOZ5W0SeVEUL86P78NEXleTor1xMrsCuzpJ5C82ujP//niNADd7bTJ6NLMcU2KM1+3d0FQqEWu2JgIA7hgTikA301aPCIKA6+L88X58Kn45mcdE3orVKppR0jJirnVpvTqpL6tttMoPunqSnPI67Gz5v+nyJneXGtzS+4Ur8qalU2l9enq6Tl9paWnGjpeIiMgqacbQtddl/Xx+NYqrFbC3lWJ4mOUknJZOs09+T3IxmjsY7ZeQZTmN7i41umWevLXtk//lZB7O51fBWW6DByZHmSWGOXGBANT9ESrrrbvzf2+mWXF3c7CFq/3FZN1JbgNPRxkAlteb26bD2RBFYFyUJ8I62Zo0qGUE3dm8Kk6UMKEuz7YpKSlBSUmJIWMhIiLqsTT75NtL5Hcnq1c8xkR6tprPS52LC3KDm4MtqhqacaKdGcZF1Q3IKa+HIFzsrGwpNOX11rRPXtGsxJt/qVfj75scCfeWZMvUYvycEe3rhEalCtvOFJglBuq+zJbGaJo98Zdieb35NSlV2HxU3eTulpFtm9xdKszTAS52NmhsViGpsNoU4RH0TOQrKiqwfPlyeHl5wdfXF76+vvDy8sKKFStQUVFhpBCJiIisnyaRP59fhRpF6yZdms7rE/uwW70+pBIBE1q2Iuxsp3v98Zay+mgfZ4srzx3VsiJ/OreyzfvBElXUNeKNrYnIKa+Hj7Mcd44LN2s8c+LYvd7aaffHe7Zd6dUk9+yCbj7bzxeiuFoBLycZrr7CqEdBELSjVdv7UJWMQ+dEvqysDKNGjcLGjRtxww034K233sJbb72F+fPnY8OGDRgzZgzKyzseq0NERNSb+bnaIdDNHioROHnJLzq1imYczVSXV0+yor3SlmJSdMsYuqS2iby2rD7UzZQh6STI3QFB7vZQqsR2qzQsQWOzCn+fK8T9Xx7DyFe2Y/3edADAyml9YC8zb+WIZm/8/tQSFFcrzBoLdU17Hes1NMl9FkvrzearQ1kAgJuGB0Nmc+WUMa6lvP4U98mbjE7N7gDgxRdfhEwmQ2pqKnx9fdvcds011+DFF19s0xiPiIiI1IaFuiO3oh5HM8oxLkq9+n4gtRRNShEhHg4Ia+cXWurcxGj163g6txLF1Qp4O8u1t2lW5IcEW9b+eI3REZ74/lgODqaVaj+QMDdRFHE6txI/JuTil5N5KKtt1N7W188Zt44KwS2dNL0ylVBPR8QFq6cW/HE6H3eMDTN3SKQn7Qz5dkrrtbPkmcibRVZpHfYkq7dQLxqh2993zYr8yexKY4VFl9F5RX7Lli1488032yTxAODn54c1a9a0O1+eiIiI1DSN7I5lXVyB1Xarj/aymPFo1sTH2Q4DAlwAqJveaTQpVdqVIUtckQeAUeHq8vrfTuXh60NZSC6shkolmiWWvIp6fLAzBVe/sxtz/m8fNuzPQFltI7yc5Lh7fDj+eGgCtj48EbePCbOY9ynL661bZlnLHvn2Suu5R96svjmiXo2fGO3daqJAZ+KC1H1IkouqUWsF24V6Ap1X5PPz8zFgwIAOb4+NjUVBARuOEBERdUTTOf14ZjlUKhESiaBtdDcpmmX1XTU5xhtn86qwM7EY84eqZxgnFlSjoUkFFzsbRHg5mTnC9o2L8oJUIiC7rB7//uk0AMDdwRbDQj0wIswdw8M8MDDQVaey1q6oVTRj65kC/Hg8B/tTSyG2fIYgt5HgmgF+mD80EBOivGAjNc7jd9fsQf54+fdzOJZZjpzyujZjHclyNSlVyKtoANB+aX1Iy1z5vMp6KJqVHc4vJ8NrbFbhO22TO92rb3xc7ODvaof8ygacya3EqAhPY4VILXRO5L28vJCRkYGgoKB2b09PT4eHh4fBAiMiIupp+vo5w1EmRbWiGUlF1bCzkSKztA62UgFjIvlLT1dNivbB+/Gp2JNcDKVKhFQiaPfHDw5xh0RiGSvIlwtws8eP94/F9vOFOJJRjuPZ5Siva8I/5wvxz/lCAOqkOi7YTZvYDw1xbzWqS19KlYgDqaX4MSEHf54pQH2TUnvbyHAP3DA0EDMH+sPFwpoDtsfXxQ6jwj1wMK0Mv53Kx32TIs0dEukot7weSpUIO1sJfC7ZDqPh5SSDg0yKukYlcsrrEeltmR/G9UR/nytESU0jfJzlmNpPvw+YBwW5Ir+yASdzKpjIm4DOifz06dPx9NNP4++//4ZM1nrciEKhwDPPPIMZM2YYPEAiIqKewkYqweAQN+xLKcWxzHI0K9VLoMNC3eEk1/m/ZLrM0BA3ONvZoLyuCadyKjAkxB0JmeXa2yxZXLCbdm9pk1KFs3lVOJJehiMZZTiaWY6y2kYcTi/D4fQyAKkQBKCvn4s2sR8R5g5/V/srPk5yYTV+PJ6LLcdzkV/ZoD0e5umA+UODMG9IIILb2ats6ebEBeJgWhl+OZHHRN6KaBrdhXg4tLtVQxAEhHg44EJBNbJK65jIm9DXhzMBAAtHBMNWz2qcuGA3bDtbiJM53CdvCno1uxs+fDj69OmD5cuXo2/fvhBFEefPn8cHH3wAhUKBL774wpixEhERWb1hIe7qRD6jHJX1TQBYVt9dNlIJxkd54c8zBdiVVIwhIe443jIZYEiIZTa6a4+tVILBwW4YHOyGeyZGQBRFpJXU4mhGGY5klONoRhkySutwPr8K5/Or8PkB9S/cgW72lyT2Hujj4wSJREBpjQK/nszDj8dzceqSX6xd7GxwXVwA5g8NwtAQN4vZ894VM2P98OzPZ3AuvwopRTWI8mHCZw2yWsbKaUro2xPqqU7kMzmCzmTSS2qxL6UUgqBO5PWl6Vx/kiPoTELnRD4oKAgHDhzAAw88gFWrVkFs2UglCAKuvvpq/N///R+Cg/X/gRMREfUmw8LU29AOpZdpO4JrOq9T102O8cafZwqwM7EYt40O1Xa7/v/27jw6qjrNG/j31pqtKvu+EhIIYQl7jDaboIg2g1sL6LjQLqNCTyPHcV7nfd1m7Ma2W0dtselupxvHIyja7u3SyBJckD2sCZCQUNlDElLZU6mq+/5RdSsJhJClqm7dyvdzTs6BSqXqgcs9+tTvWaY6T7uVSBAEjI0OwdjoECx3To6ua+7EgXMXHCf2ZRdwosqMyqYOVBZ04OMCx9C30EAtxkYH42iFGVbn8DyNSsD88TG4bXoiFmTFIEDrHz3H4cE6zB0XjR1Fdfj0SBXWXTdO7pBoEMoaLr96TiINwTvHgXdes2WfY8jd/HHRw5o5Mdk58K7iQgcaWrsQGXJp2wS5z5Dq+MaMGYMvv/wSFy5cwJkzZwAAGRkZ7I0nIiIapGkpYRAEoLKpAwAQbdAjO94oc1TKN9e5vu1IRRN2FtUBADJjQkbUT+6LYowBuHFyPG6cHA8AaO2yosDUhH1ljThQ1ojDpiaYO7pxyLl6b0pSKG6dloilOQl++z/VS3PisaOoDp8fqcJjizIVXWEwWkgftA20clNaS8cVdN7RZbXhg4MVAIA7c1OH9RrGAC3So4Nx9nwbjlaYsSCL1WaeNKyGvPDwcMyePdvdsRAREfk9Y4AW42MNKKppAQDMzYxm4uEG8aGByIpz/L1u2FkMwPGhib8L0Wvwk8wo/CTTUdXRbbPjZFUzTtW2YGpyGMbFGmSO0POuy46DXnMMZ+vbcKKqGZMSQ+UOia7A5Fw9l9LP6jlJzy55ltZ7w1fHa9DYZkGcMQALxkcP+3WmJoXh7Pk2HKloYiLvYb65T4SIiMiPTU/t6dtmWb37zHOeyktlu9MV1B/vLlq1Y8r9HTOTR0USDzg+zFg0IRYAd8orgSiKrv3wqQMMWExzJvnlFzpgd7aIkOds3usoq18+K3lEKyel4Z3sk/c8JvJEREReNtOZyAsCMCdz+Ccf1Ne8i06Ren9gQv5taU4CAOCzI1VM+nxcXUsXOrvtUKsEJIZffuNCfGgANCoBFqsdNc2dl30ejVxxXSv2ljZCJQArZo9s5tkUZ5/80Qqza6YaeQYTeSIiIi+bOy4a0QY9bpocj4hg3ZV/gAZlZmoEgnWOIW4GvQYZXFk1aswfHw2DXoNqs2MYIPkuqec9ISxgwPVmGrUKSc5En33yniUNubs2K3ZQ6ywHMiHeCK1aQEObBRUXOtwRHl0GE3kiIiIviwrRY///XYTX75wudyh+RadR4eoMR6vC1JQwqFScPTBaBGjVuH5iHADHqbySdHbbsGzD97j7f/aOihNMqec9dYDVcxKph17qqSf36+y24W+HHEPu7spNGfHrBWjVyIpzDHA9yn3yHsVEnoiIiPzGP1+VigCtCrfPSJI7FPKyf5rqKK//4lg1rDa7zNEM3pZ9Jhwpb8K3Z+pRZfb/EnKpPz5lgIn1klROrve4L49Xo6m9G4lhga7tHyOVk+worz9S0eSW16P+MZEnIiIivzFvXDSK/msJlk1NlDsU8rJrxkYiMliHhjYLvi9pkDucQenstmFjfonr94VVzTJG4x1SUj7QoDuJa3I9d8l7jDTkbsWsZKjdVMU0JSkMAFDAgXcexUSeiIiIiBRPo1bhxsnxAIBPC5RRXv/+wQrUNne5fl9YPRoSeWdp/SBO5KVd8iaeyHvE6doW7C+7ALVKwB2zRjbkrrepzsn1xyvNsHH4pMcwkSciIiIivyCV1//jRA06u20yRzMwi9WOjbscp/Hp0Y5e8MKaUZDIS6vnBtghL5GeU9bQNirmB3ibdBq/aEIMYo0BbnvdsdEhCNKp0W6xobiu1W2vS30xkSciIiIivzAjJRzxoQFo6bJi16nzcoczoA8PVaCyqQPRBj2eXDIBAFBU3SJzVJ5l7uhGU3s3gJ7T9oFIz2nptLp+jtyjw9Iz5O7O3FS3vrZaJWByIvvkPY2JPBERERH5BZVK6LNT3ld12+zYsKsYAPAvc9NdpcilDW1ot1hljMyzpBL5qBA9gvWaKz4/UKdGjEEPgH3y7vb50Sq0dFqRHBGIOc5tH+4k/Zs+wj55j2EiT0RERER+45+cifw3hbVo7fLNpPiTgiqUN3YgMliHu3JTEW3QIypED1EETtX476n8ucbB98dL0pzl9VJvPbnH5n3SkLsUj6zqlAbecQWd5zCRJyIiIiK/MTHBiPSoYHRZ7dh2skbucC5hs4t4Y6fjNP6BOekI1KkBABPiDQCAQj8urx/KxHqJtKaOA+/cp7C6GYdNTdCoBPxspmdWdUor6Aqrm31+XoVSMZEnIiIiIr8hCD3l9W9+W+pzU7M/P1qFs/VtCAvS4u68nt7k7HgjAKDIjwfeScn4YHbIS1y75Fla7zbSkLvFE+MQY3DfkLveEsMCERmsg9UujoptDHJgIk9EREREfuXuvFQYAzQ4UdWMd/aekzscF7tdxOs7HKfx918zBiG9+sSzXCfy/pv0DKe0nify7tVuseLjw5UAgDtzUzz2PoIgIId98h7FRJ6IiIiI/EpUiB7/tng8AOC3X5/C+ZauK/yEd3x1ogZn6lphCNDg3mvS+nxvgnQiX93it6vWXCfyEVdePSeRVtBJHwLQyHx2pAotXVakRQYhLz3So+81JUmaXM8+eU9gIk9EREREfufO3FRMTgxFS6cV678olDsc2O0iXtt+BgCw6poxMAZo+3x/bHQIdGoVWrqsqLjQIUeIHtXZbUN1cyeAoZ3IS6X1tc1d6LCw13qkpLL6lbM9M+SuN9eJPFfQeQQTeSIiIiLyO2qVgP+6eRIEAfjwcCX2nm2QNZ5vCmtRVNOCEL0GP7/oNB4AtGoVMmJCAPhneX3FhXaIIhCi1yAyWDfonwsL0sIQ4GhBMLFPfkSOV5pxpMIMnVqF22d4ZshdbznOyfVnz7fB3NHt8fcbbZjIExEREZFfmpochpWzHX3AT31yHN02uyxxiKKI13Y4TuPvyUtFWFD/iWyWH0+uP+cqqw+CIAz+JFgQBNcJPlfQjcw70pC7SXGIDNF7/P0ignVIjggE4PgQgdyLiTwRERER+a0nFo9HRLAOp2tb8dfvS2WJYdep8zhe2YwgnRoPzEm/7POkyfX+eCLvWj03hLJ6Saqzp54n8sPX2mXFpwXOIXezPTfk7mLSqXwBB965HRN5IiIiIvJbYUE6/J8lWQCAV745g2qzd/vPRVHEq87e+H++KhURA5SVSwPvCv1wBZ2UhA9l9Zyk50SeifxwfVJQiTaLDenRwbgqPcJr7ysl8kfZJ+92TOSJiIiIyK/dPj0JM1LD0W6x4b8+P+nV9/6uuB4F5U3Qa1R4YM6YAZ+bFecorT/X0I62Lqs3wvMaqSw+dQgT6yWuRJ4n8sMiiqJryN2ds1OG1NowUj0r6Fha725M5ImIiIjIr6lUAp6/eRLUKgFfHKvB7tPnvfK+otgzqf7O3BTEGAIGfH5kiB4xBkfvclGNf/XJS0n4cErrpXV1JvbID8vRCjNOVDVDp1HhtumeH3LX26REI1QCUNPciVrn1gJyDybyREREROT3JsQbcW9eGgDg6U+Oo7Pb86vMfjzbiP1lF6BTq/Avc8cO6mcm+GGfvM0uoqLR0dKQEjH80vqKCx2wyjSwUMmk0/ibJscjfAgbA9whSKfBuFhHpckR9sm7FRN5IiIiIhoVHrsuEzEGPcoa2vGn3Wc9/n6/d06qXz4rGXGhA5/GS/wxka82d8Bis0OrFpAQFjjkn48zBkCnUcFqF1Ft5qnuUDR3duPTI1UAHFUhcpiSFAqA++TdjYk8EREREY0KhgAt/t9PswEAG3YWo9yDPdcHyhrxQ0kDtGoBD88f3Gk8AExwrqDzp9J6k3NIXVJ4ENSqofdnq1QCksMdHwBw4N3QbDtRi45uGzJiQjAzNVyWGKQ++aMV7JN3JybyRERERDRqLJ0Sj6vHRqLLasczn56AKIoeeZ/XdhQDAG6fkYTEIZxCSyfyRdXNsNs9E5u3jaQ/XpIaGex8LfbJD0W+cx7EDRPjvDrkrjdpcv2R8iaP3W+jERN5IiIiIho1BEHAfy6bBK1awI6iOmw7Wev29ygob8Lu0+ehVgl4ZF7GkH42PSoYOo0KbRYbyi/4x+mza4f8MPrjJVJvPU/kB89uF/FdcT0AYE5mlGxxjI8zQKdRobnTijJeP7dhIk9EREREo0pGTAgenJMOAHjus5PosLh38N3vnZPqb5mWOOS96Rq1CuNiQwD4T5+8yXmKnhI59NVzkp5d8jyRH6wTVc1obLMgRK/BdJnK6gFAq1ZhUoKj0oQD79yHiTwRERERjTprrs1AYlggKps68PrOM2573eOVZmwvqoNKAFYvGNppvGRCnDTwzj/65N1xIt+TyPNEd7B2n3GU1eeNjYRWLW/aN0Uqr+fAO7dhIk9EREREo06QToNnljoG3/1p91kU17W65XWlSfVLcxIwJmp4J9BZfjS5XhRF17A7d/TImxrb2Wc9SLud/fFzx0XLHAkw1Tnwjify7sNEnoiIiIhGpeuyY3FtVgy6bSKe+fT4iBPEwupmfH2iFoIArBnmaTzQM7m+sEb5ifyF9m60dFkBAMkjOJFPCg+EIADtFhvqWy3uCs9vtXZZcfDcBQDAXBn74yXSCroTVc3ottlljsY/MJEnIiIiolFJEAQ8u3Qi9BoVvi9uwGdHq0f0eq/vdEyqv3FSPDJjDcN+nWzniXx5YwdaOrtHFJPcpJ72OGMAArTqYb+OXqNGQqhj+r+Jk+uvaE9JA6x2EamRQa5qBjmlRQbDGKBBl9WOU360WlFOTOSJiIiIaNRKiQxy9bI///nJYSfOxXUt+OKY44OANdcO/zQeAMKCdIgPDQAAxSc9Uk/7UIf+9YeT6wfvW2d//NxM+cvqAUClElx98twn7x5M5ImIiIhoVHtobjrSIoNQ19KFV74Z3uC713cUQxSB67NjXbvgRyIrzller/A+eXcMupNw4N3gSf3xcq6du1hOsqO8nn3y7sFEnoiIiIhGtQCtGs8tmwQA2PRD2ZCT59L6Nnx6pAoA8K8LM90Sk/RhwEmFT64/5yyDTxvm4L/epFN9UyMT+YGYGtpR1tAOjUpA3thIucNx4eR695I1kd+9ezeWLl2KhIQECIKAjz/+eMDnf/jhh7juuusQHR0No9GIvLw8fP31132e8+yzz0IQhD5fWVlZHvxTEBEREZHSzRsXjRsnx8FmF/HUx8dhtw9+8N2GncWwi8C1WTGYlBjqlngm+MnkemlifYo7TuQjHB8GlHGX/IDynWX101PDYQjQyhxND2ly/enaFrRbrPIG4wdkTeTb2tqQk5ODDRs2DOr5u3fvxnXXXYcvvvgCBw8exIIFC7B06VIcPny4z/MmTpyI6upq19d3333nifCJiIiIyI889dNsBOnUOHDuAv52qGJQP1Pe2I6PDlcCAH4xwt743qRE/lRNy5A+VPA15xpHvnpOIr2GiaX1A/pWWjvnQ2X1ABBrDECcMQB2ETheqewPqHyBRs43X7JkCZYsWTLo57/yyit9fv/rX/8an3zyCT777DNMmzbN9bhGo0FcXNygX7erqwtdXV2u3zc38x8WERER0WgTHxqItYsy8esvirD+yyJclx2LsCDdgD/zxq5i2Owi5mRGYVpKuNtiSYsMgl6jQke3Deca24e9k15O7RYrzrc4/h9bOk0fCam0vqHNgtYuK0L0sqYyPqnbZscPJQ0AfGN//MWmJIWi5mQnjlY0YfaYCLnDUTRF98jb7Xa0tLQgIqLvP4IzZ84gISEB6enpuOuuu2AymQZ8nfXr1yM0NNT1lZyc7MmwiYiIiMhHrbpmDMbFhqCxzYLffn1qwOdWNnXgg4OOk3t39cZLNGoVxit84J3Uyx4aqEVo0MhLvI0BWkQEOz5YOcfy+n4dNjWhtcuK8CAtJiW4p83DnXKc5fUFHHg3YopO5H/3u9+htbUVd9xxh+ux3NxcbNq0CV999RX+8Ic/oLS0FHPmzEFLy+UHhTz55JMwm82ur/Lycm+ET0REREQ+RqtW4T+dg+827zMNOGF7464SdNtE5KVHYlaa+08XJ8Qpu0/eNbHeDWX1EqnXnuX1/ZPWzv0kMxoqlSBzNJfK4Qo6t1FsIr9582Y899xz2Lp1K2JiYlyPL1myBD/72c8wZcoULF68GF988QWampqwdevWy76WXq+H0Wjs80VEREREo9NV6ZG4dVoiRBH4fx8fh62fHvXa5k68d8Bx+POLhe7rje9tQrx0Iq/MyfXuHHQnca2g4+T6fu320f54yeQkR5WAqbEdjW0WmaNRNkUm8u+++y4eeOABbN26FYsWLRrwuWFhYRg3bhyKi4u9FB0RERERKd2TN06AIUCDY5VmbN53aZvmH/PPwmK1Y1ZaOPLSPbPiK0vhk+ul6fLuPJGX9tFzl/ylGtssOFrpOOn2xf54wNFmke6c93CUa+hGRHGJ/JYtW7Bq1Sps2bIFN9100xWf39raipKSEsTHx3shOiIiIiLyB9EGPR6/fjwA4LdfFaG+tWcw8vmWLryz9xwA4BfXZkIQPFPCLJXWVzZ1wNzR7ZH38CSpR94dg+4kKZHBztdmj/zFvi+uhygCWXEGxBoD5A7nsqQ++SPlLK8fCVkT+dbWVhQUFKCgoAAAUFpaioKCAtdwuieffBL33HOP6/mbN2/GPffcg5deegm5ubmoqalBTU0NzOaefwSPP/448vPzUVZWhh9++AG33HIL1Go1Vq5c6dU/GxEREREp2z9flYqJCUY0d1qx/osi1+NvfnsWXVY7piaHYY4HS5hDg7RIDAsEABQp8FTeEz3yrtJ6nshfQiqr9+S/SXeY4iyvP8IT+RGRNZE/cOAApk2b5lodt27dOkybNg1PP/00AKC6urrPxPk//elPsFqtWL16NeLj411fv/zlL13PqaiowMqVKzF+/HjccccdiIyMxI8//ojoaN8sLyEiIiIi36RWCXj+5kkQBOBvhyqwr7QRjW0WvP2j4zT+XxdmeOw0XiL1yRfVKKtPvttmR2VTBwAgNdJ9J/JSaX1VUwcsVrvbXlfpRFHEbuegO18tq5dIJ/JHK5ogipfOn6DBkXX54vz58we8eJs2berz+127dl3xNd99990RRkVERERE5DAtJRwrZqVgyz4Tnvr4OOaPj0a7xYZJiUYsGB9z5RcYoaw4I74prFNcn3xVUwdsdhF6jQoxBr3bXjfaoEegVo2ObhsqLrQjPTrEba+tZKdrW1Hb3AW9RuWRDQrulB1vhEYloL7VgsqmDiSFu69iYzRRXI88EREREZE3PbF4PMKDtDhV24I/7j4LwLO98b1NUOjAu3O9Jta7cw2aIAiuKficXN9DWjuXmx6JAK1a5mgGFqBVI8tZacI1dMPHRJ6IiIiIaADhwTr8nyVZrt9nxRlw3YRYr7y3VFp/qral3zV4vkpKst3ZHy9JiZR3l/zJqmb86u8n0dzpOwMI83187dzFpH3yR8qbZI1DyZjIExERERFdwc9mJGO2s2T5sevGufWUeSCpkcEI1KrR2W13rXNTApMz1hQ3TqyXpMk88O7ZT0/gz9+W4o2dJbK8/8U6u23YV9oIAJjn4/3xElciz4F3w8ZEnoiIiIjoClQqAX9dNQtf/OscLJ4Y57X3VasEjItznMorqbzeExPrJXKuoDO3d+Og6QIA4IOD5T4xcG9faSO6rHbEGQOQEaOMmQHSwLtjFWZFVZr4EibyRERERESDEKzXIDvB6PX3zY5XbiKf4oFEXppcL8eJfP6Z867Es77Vgu2FtV6P4WLS2rm546K8MrfBHTJiQhCkU6PNYsPZ861yh6NITOSJiIiIiHxYz8A7ZaygE0URJqlHPsIDibzUI9/YDruXT3N3FdUBAAx6x/KvLfvLvfr+/VHK2rne1CoBkxId++QL2Cc/LEzkiYiIiIh8mJTIFynkRP58Sxc6um1QCfDIarGEsECoVQK6rHbUtXS5/fUvx2YXsct5+v3U0mwAjmnx5TJOz68xd+J0bSsEAbhmrDIG3UlykhyJPPvkh4eJPBERERGRDxvv7JGvMneiqd0iczRXJk2sTwgLhE7j/nRDq1YhMSwQALw6APBIRRMa2ywwBGhwy7REzMmMgigC78l4Ki+dxk9JCkN4sE62OIZD6pPnCrrhYSJPREREROTDjAFaJIU7ElcllNd7ctCdJFWGFXRSWf3czGho1SqsnJ0CANh6oBxWmzxD76T++HkKWTvXmzS5vrC6GV1Wm7zBKBATeSIiIiIiH9fTJ+/75fWeXD0nSZEG3nlxcv2OU45Efv54Ry/6ogmxiAzWoa6lCzucSb432ewiviuuB6Cs/nhJUnggIoJ16LaJiviAytcwkSciIiIi8nGuPvka30/kpdJ6b5zIe2tyfV1zJ45XOv7u54+PAQDoNCrcPjMJALBln8krcfR2vNKMpvZuGPQaV5m6kgiC0NMnz4F3Q8ZEnoiIiIjIx01w7ZL3/ZNLV2m9BybWS1Jdu+S9k8jvOuUoYc9JCkW0Qe96fMUsR3l9/unzqGzq8EosEqms/uqMSGjVykzrpjjL6znwbuiUecWJiIiIiEYR6UT+VG2LbP3YgyUl157YIS/x9om8VDovncZLxkQFIy89EnYR2OrloXdKXDt3sanOSgKeyA8dE3kiIiIiIh+XEhGEYJ0aFqsdpfXe6wsfqubObjS2OSbrS6fmniD1yJs7umFu7/bY+wCAxWp39aJfmxVzyfdX5vYMvbN5aa99S2c3DpmaADiG7ynVFGdp/dn6NjR3evY6+hsm8kREREREPk6lElxr6AprfLe8XpoiHxmsQ4he47H3CdJpXCXunh54d6CsEa1dVkSF6DA5MfSS7y+eGIvwIC2qzZ3IP+2doXc/lDTAZhcxJioYyR5sYfC0yBA9ksIDIYrAca6hGxIm8kRERERECpClgMn13lg9J5F68D1dXi+V1c8bFwOVSrjk+3qNGrdNdwy927zXO+X1Un/8XAWunbtYjqtPnon8UDCRJyIiIiJSACWsoJNOxz1ZVi9JcfXJe/ZEfqdz7Vx/ZfWSFc6d8juKalFj7vRoPKIouvrj5yi4rF6Sk8zJ9cPBRJ6IiIiISAGy46XJ9b6byEul9SleKPdOde6p9+SJvKmhHSXn26BWCZgz7vKn3xkxIZidFgG7CLx/wLOn8uca2lHe2AGtWkDe2EiPvpc35HBy/bAwkSciIiIiUoDxcY4T+drmLtdAOV/j1dJ66UTegyvodhTVAgBmpobDGKAd8Lkrc5MBAO/u9+zQO+k0fkZqOII9OIfAWyYlhkIlANXmTtQ1e7aawZ8wkSciIiIiUoAQvcZ10l3ko6fy0uo5byTyUmm9yYMn8jud++MHKquXLJkUj9BALSqbOvCtM9n2BKk/3h/K6gEgWK9BZoyj2oR98oPHRJ6IiIiISCEmOMvrT/pgIt9ltaHK3AEASInwfI+8NOyuprkTnd02t79+u8WKPWcbAAwukQ/QqnHLtEQAwLv7PFNeb7HasafEEdM8Be+Pv5i0hu4oy+sHjYk8EREREZFC9Ay8870VdOWNHRBFIEinRlSIzuPvFxGsg8FZWl7ugfL6H4obYLHakRgWiIyYkEH9zErn0LtvCms9UiZ+yHQBbRYbIoN1yHb+W/AHOclhAIACDrwbNCbyREREREQK4cuT603OifUpEUEQhEvXtLmbIAi9Jte7P5HvPa1+sH+e8XEGzEgNh9Uu4v2DFW6PqaesPqrfVXhKJQ28O1phhih6br6AP2EiT0RERESkEBOcA++K61rRbbPLHE1f3hx0J/HUwDtRFLGz6Mpr5/qzYpZj6N17+8thd/PQu2/P1APwn/54yfg4A3QaFcwd3R7dQuBPmMgTERERESlEUnggQvQaWGx2nD3v2f3pQyUlYGle2CEvkXrxTW7eJX+qtgVV5k7oNSpclT60FW8/nZIAQ4AGpsZ2/ODsZ3eHhtYuHK9yDIMbaBWeEuk0KlerANfQDQ4TeSIiIiIihVCpBGTF+eY+eWlifYoMJ/Jlbj7F3VnkKGG/emwkAnXqIf1soK5n6N2WfSa3xfRdcT1E0dFeEWMIcNvr+oqpzj75I+WcXD8YTOSJiIiIiBTEV/vkzzlPxVO9MLFeIk2uN7m5tH64ZfWSFbMcQ+/+cbIG9a1dbokp39kfPzfTv07jJTnJjsn1PJEfHCbyREREREQKkuVcQVdY4zuT6+12EeUXHKvnvNkjL53+V1xoh81N/ejm9m4cNF0AAMwfP7xEPjvBiJzkMHTbRPzNDUPvRFF09cfP9aO1c71NcQ68O15p9rn5D76IiTwRERERkYL44ol8TXMnLFY7NCoB8aHeK/uODw2EVi2g2yaiqqnDLa+5+8x52OwiMmNCkBwx/A8l7pztGHr37v7yEU9iL6ppwfmWLgRoVZiZFj6i1/JVYyKDERGsQ5fVjq9P1Mgdjs9jIk9EREREpCBZcQYIAnC+pcttZdsjJQ26SwoPhEbtvRRDrRKQHO7e8vqRltVLfjolAcE6NUrr2/Dj2cYRvZa0du6q9EjoNUPr2VcKlUrAPXmpAIANO0u4hu4KmMgTERERESlIkE7jmgzvK6fyUn98ihcn1kvcuUveZhexy5k0D7esXhKs12CZm4beucrq/Wzt3MXuuzoNwTo1CqubscP5gQr1j4k8EREREZHCSJPri6p9o09e2uOeOoJS9OGSPtQ41zjyFXRHK5rQ2GaBIUDjlhL2O2c7ht59dbwGjW2WYb1Gh8WGfWWOE31/7Y+XhAXp8M9XOU7lX99ZzFP5ATCRJyIiIiJSGF/rkzc5T8O9OehOkiJNrnfDibxUVj83MxpaN7QITEoMxaREIyw2Oz48NLyhdz+WNsBitSMhNABjo71f8eBt988ZA51GhcOmJuw52yB3OD6LiTwRERERkcJIifxJH0nkpdPwVBlK61PdWFq/85RUVu++k++VzlP5LftMwzph/vZ0z7R6QRDcFpevijEEYMUsx6DADTuLZY7GdzGRJyIiIiJSmAnOFXQl51thscq7qksURVcSLceJfE8i3zaiUuy65k4cqzQDGHl/fG//lJOAIJ0aJefbsL/swpB/fvcZ5/54Py+r7+2huenQqAR8X9yAw6ah/52NBkzkiYiIiIgUJjEsEIYADbptIkrOt8oaS1N7N1o6rQB6yty9KSk8CIIAtFlsaBhmHzoA7HKexuckhSLaoHdXeDAEaLF0SgIA4N0hDr2raupAcV0rVAJwzdgot8Xk65LCg3Czc1Dghp0lMkfjm5jIExEREREpjCAImBDnG33y0qC7WKMeAVrvr0YL0KoRZ3Tsrh9Jef3OU47+eHeexktW5jrK6z8/Vo2m9sF/2CCtnctJDkNokNbtcfmyR+aPhSAA3xTWoqjGN1pIfAkTeSIiIiIiBZLK62VP5J2r51Ij5BvE5hp4N8zJ9Rar3bXibaT74/uTkxSKCfFGWKx2fHS4ctA/N1rWzvVnbHQIbpwcD4Cn8v1hIk9EREREpEA9k+vlXUEnTYtPkaE/XjLSgXcHyhrR2mVFVIgOkxND3RkaAEcFxcrZjgFu7+4rH1Qvv80u4rvinkF3o9Gj88cCAP5+tAql9SNfL+hPmMgTERERESlQljORl7vsuKxBvh3yEmla/nBX0Ell9fPGxUCl8sxk+GVTExGgVeFUbQsOmZqu+PwjFU0wd3TDEKBBTpL7P1xQgokJobg2KwZ2Edi4i6fyvTGRJyIiIiJSoPGxBqgEoL7VgrqWTtnikMrZfeJEvnF4ifwO5/54T5TVS0IDtbhp8uCH3klr536SEQWNG3baK9XqBRkAgA8PV6CqqUPmaHzH6P0XQURERESkYIE6NdKiHCfRcpbX96yek69HXurPH05pvamhHSXn26BWCZgzzrOT4e/MdZTXf3a0Cs2d3QM+dzSunevPjNRw5KVHotsm4k+7z8odjs9gIk9EREREpFA9ffLylNd3WGyoa+kCAKTJeCIvVQPUt3ahrcs6pJ+VyupnpobDGODZyfDTU8IxLjYEnd12fDLA0DtzRzcKypsAAHMyR8/aucuRTuW37DOhvrVL5mh8AxN5IiIiIiKFmhDnmFxfJFMib3KWshsDNAgL0skSA+AoWw9zrmcb6qm8N8rqJYIgYMUsxyq6zQMMvdtTUg+bXUR6dDCSwuX7gMRXXJMRiZzkMHRZ7fif70rlDscnMJEnIiIiIlIouSfXu1bPyVhWL0kdxgq6dosVe842APBOIg8At05PhE6jQmF1M45WmPt9Tv7p0bt2rj+CIGCN81T+7T3nYG4fuC1hNGAiT0RERESkUFIiX3K+FV1Wm9ffXzqRl3PQnSQlcuh98ntKGmCx2pEYFoiMmBBPhdZHWJAONzn3o2/pZ+idKIrYfdrRHz9vlPfH97YwKwbjYw1o7bLif/eUyR2O7JjIExEREREpVHxoAEIDtbDaRZypbfX6+5/zgdVzEimGoUyu711WLwieWTvXnxWzHEPvPj1ShdaLevrP1rehsqkDOrUKuekRXovJ16lUAh5d4Ngr/5fvS4c8C8HfMJEnIiIiIlIoQRCQJfXJ13i/vF5KmlN94kTeWVo/yBN5URSx04v98b3NHhOB9OhgtFts+LSgqs/3vnWexs9MC0eQTuPVuHzdT6ckIC0yCBfau/utZhhNmMgTERERESmYnJPrpR75lAjf6ZE/N8ge+dO1ragyd0KvUeGq9EhPhnYJQRBw52zH0LuLE9LdZ5z98Syrv4RaJeDheY5T+T/tPitLO4mvYCJPRERERKRg2TIl8labHZUXOgD4xom8NHCvqqkT3Tb7FZ8vldVfPTYSgTq1R2Prz63Tk6BTq3Cs0ozjlY6hd11WG/aUOIbvce1c/26dnoT40ADUtXThg4MVcocjGybyREREREQKlhXvKK0vrG6+7DozT6hq6oTVLkKnUSHOGOC1972cGIMeAVoVbHbR9QHDQKT98Qu8XFYviQjWYfGkOAA9p/IHz11AR7cNUSF6TIgzyhKXr9NpVHhobjoAYGN+CayD+NDGH8mayO/evRtLly5FQkICBEHAxx9/fMWf2bVrF6ZPnw69Xo+MjAxs2rTpkuds2LABaWlpCAgIQG5uLvbt2+f+4ImIiIiIfMC4WANUAnChvRt1LV1ee1+phD0lIggqlfcGxV2OSiUgZZAD78zt3Th47gIAYMF4eRJ5AFg52zH07pOCKrR1WbHbtXYuyif+Tn3VilkpiAzWobyxA58eqbryD/ghWRP5trY25OTkYMOGDYN6fmlpKW666SYsWLAABQUFWLt2LR544AF8/fXXrue89957WLduHZ555hkcOnQIOTk5WLx4Merq6jz1xyAiIiIikk2AVo30aMfqtJNeLK/3pYn1EqlX39QwcJ/87jPnYbOLyIwJQbKM8eelRyItMgitXVb8/Wi1a+3cnHEsqx9IoE6Nn/9kDADgjV0lsNu9V4niK2RN5JcsWYLnn38et9xyy6Cev3HjRowZMwYvvfQSJkyYgDVr1uD222/Hf//3f7ue8/LLL+PBBx/EqlWrkJ2djY0bNyIoKAh/+ctfLvu6XV1daG5u7vNFRERERKQUcgy886Ud8hKpV7/sCpPr5S6rlwiCgBXOoXd/3F3i+iBmTiYH3V3J3XmpMARoUFzXin+crJE7HK9TVI/8nj17sGjRoj6PLV68GHv27AEAWCwWHDx4sM9zVCoVFi1a5HpOf9avX4/Q0FDXV3Jysmf+AEREREREHiCtoCus9t4KOmlivS+dyEuJ/LkBEnm7XUT+KcfJt5xl9ZLbZyRBqxZQct7x9zkxwYioEL3MUfk+Y4AW912dBgB4fWexV+dD+AJFJfI1NTWIjY3t81hsbCyam5vR0dGB+vp62Gy2fp9TU3P5T2mefPJJmM1m11d5eblH4iciIiIi8gRpcn2RHKX1kfKvnpNIPfKmAVbQHaloQkObBQa9BjPTwr0V2mVFhehxXXZP/sLT+MFbdc0YBGrVOF7Z7FrbN1ooKpH3FL1eD6PR2OeLiIiIiEgppNL6s/Vt6Oz2/G5tURR9tLTe2SPf2H7ZE9qdp3r60LVq30iHVjrL6wFgLvvjBy0iWIc7cx1/dxt2FMscjXf5xr/cQYqLi0NtbW2fx2pra2E0GhEYGIioqCio1ep+nxMXF+fNUImIiIiIvCbWqEd4kBY2u4gzta0ef7/zrV1ot9ggCEBSeKDH32+wEsMCoRKAzm77ZSf473Tuj/eFsnrJNWOjMCczCjNTwzEzNULucBTlwTnp0KlV2FfWiH2ljXKH4zWKSuTz8vKwffv2Po9t27YNeXl5AACdTocZM2b0eY7dbsf27dtdzyEiIiIi8jeCICArznsD70zOsvqE0EDoNWqPv99g6TQqJIQ5Pljor0++rrkTxyrNAID5PpTIq1QC3r4/Fx88cjV0GkWlaLKLCw3AbTOSAAAbdo6eU3lZ/5W0traioKAABQUFABzr5QoKCmAymQA4etfvuece1/MffvhhnD17Fk888QSKiorwxhtvYOvWrXjsscdcz1m3bh3+/Oc/46233kJhYSEeeeQRtLW1YdWqVV79sxEREREReZNrcn2N5xN5KUlO8aFBd5I0Z3n9uX5W0O1yrnebkhSKaAMHyvmLR+aNhVolIP/0eRyrMMsdjlfImsgfOHAA06ZNw7Rp0wA4kvBp06bh6aefBgBUV1e7knoAGDNmDP7+979j27ZtyMnJwUsvvYQ333wTixcvdj1n+fLl+N3vfoenn34aU6dORUFBAb766qtLBuAREREREfmTCfHS5HovJPLO/vi0KN9L5KWefamHvzdfLKunkUuJDMI/5SQAGD2n8ho533z+/PkDrgnYtGlTvz9z+PDhAV93zZo1WLNmzUjDIyIiIiJSjJ5d8i0QRRGCIHjsvUzO0+6UCN+ZWC+R1uFdXFpvsdrxrXOy+bUy748n93t0/lh8dLgSX52owZnaFmTGGuQOyaPYgEFERERE5AcyYkKgVgkwd3Sj2tzp0feSTuRTfWhivaRnl3zf0voD5xrR2mVFVIgOkxND5QiNPCgz1oDFEx1V2H/YVSJzNJ7HRJ6IiIiIyA8EaNUYG+04IS/ycJ+8yYd75KUqgXMXldZLZfXzxsVApfJctQLJZ82CTADAJ0eqXP9G/RUTeSIiIiIiP9G7vN5TWrusaGizAPDNE3mpR76pvRvmjm7X4zuciTzL6v3X5KRQzB0XDZtdxMbd/n0qz0SeiIiIiMhPSIn8SQ8OvJNK1iOCdTAEaD32PsMVotcgKkQHoKdywNTQjpLzbVCrBPwkM0rO8MjDVs8fCwD44EAFaps922IiJybyRERERER+IivO85PrfXn1nESK7Vyj40OHnaccp/EzU8MRGuh7Hz6Q++SmR2JWWjgsNjv+vPus3OF4DBN5IiIiIiI/ke08kS+rb0OHxeaR95ASeV8sq5ekunbJO2KVEnmW1Y8OqxdkAADe2WtCo7MNxN8wkSciIiIi8hPRBj0ig3Wwi8DpWs/0yZucp9ypCjiRNzW0o8Niw56SBgDAAibyo8K8cdGYlGhER7cNm74vlTscj2AiT0RERETkJwRB6DXwzjPl9T0n8r63Q16SFtVTWv9DST26rHYkhgUiMyZE5sjIGwRBwOr5jlP5TT+UoaWz+wo/oTxM5ImIiIiI/Iin++SVUFovraAzNbT3KasXBK6dGy0WT4xDRkwImjutePvHc3KH43ZM5ImIiIiI/IjrRL7G/aX1Fqsd1eYOAD1r3nyR9CFDdXMntp2sBQAsyIqWMyTyMpVKwKPOCfb/822px2ZGyIWJPBERERGRH+ldWi+Koltfu+JCO+wiEKRTIzpE79bXdqfIYB2CdWqIIlDb3AW9RoW8dK6dG22W5iQgKTwQDW0WvLffJHc4bsVEnoiIiIjIj2TEhECjEtDSaUVlU4dbX/tcY8/qOV8uUxcEASm9evivHhuJQJ1axohIDlq1Cg/Pc5zK/3H3WVisdpkjch8m8kREREREfkSnUSHDOdStsNq95fXn6h0T6315h7yk91R9TqsfvW6fkYRFE2LxX8smQaPy3Q+fhkojdwBEREREROReE+KNKKppwZfHqmGzu+8U8nvnGjdfHnQn6R3jgvFM5EerAK0ab947U+4w3I6JPBERERGRn8mON+Kjw5X40Pnlbr68ek6SFuWIMTMmBMkKqCAgGgom8kREREREfubmaYnYW9qIpnaL2187IliHGyfHu/113W1pTgL2lzXi1mlJcodC5HaC6O5Rln6gubkZoaGhMJvNMBqNcodDREREREREfm4oeSiH3REREREREREpCBN5IiIiIiIiIgVhIk9ERERERESkIEzkiYiIiIiIiBSEiTwRERERERGRgjCRJyIiIiIiIlIQJvJERERERERECsJEnoiIiIiIiEhBmMgTERERERERKQgTeSIiIiIiIiIFYSJPREREREREpCBM5ImIiIiIiIgUhIk8ERERERERkYIwkSciIiIiIiJSECbyRERERERERArCRJ6IiIiIiIhIQZjIExERERERESkIE3kiIiIiIiIiBdHIHYAvEkURANDc3CxzJERERERERDQaSPmnlI8OhIl8P1paWgAAycnJMkdCREREREREo0lLSwtCQ0MHfI4gDibdH2XsdjuqqqpgMBggCILc4VxWc3MzkpOTUV5eDqPRKHc4NAi8ZsrC66UsvF7Kw2umLLxeysNrpiy8XsriiesliiJaWlqQkJAAlWrgLnieyPdDpVIhKSlJ7jAGzWg08mZXGF4zZeH1UhZeL+XhNVMWXi/l4TVTFl4vZXH39brSSbyEw+6IiIiIiIiIFISJPBEREREREZGCMJFXML1ej2eeeQZ6vV7uUGiQeM2UhddLWXi9lIfXTFl4vZSH10xZeL2URe7rxWF3RERERERERArCE3kiIiIiIiIiBWEiT0RERERERKQgTOSJiIiIiIiIFISJPBEREREREZGCMJFXsA0bNiAtLQ0BAQHIzc3Fvn375A6J+vHss89CEIQ+X1lZWXKHRb3s3r0bS5cuRUJCAgRBwMcff9zn+6Io4umnn0Z8fDwCAwOxaNEinDlzRp5g6YrX67777rvknrvhhhvkCZawfv16zJo1CwaDATExMbj55ptx6tSpPs/p7OzE6tWrERkZiZCQENx2222ora2VKWIazDWbP3/+JffZww8/LFPEo9sf/vAHTJkyBUajEUajEXl5efjyyy9d3+f95VuudL14b/m2F154AYIgYO3ata7H5LrHmMgr1HvvvYd169bhmWeewaFDh5CTk4PFixejrq5O7tCoHxMnTkR1dbXr67vvvpM7JOqlra0NOTk52LBhQ7/ff/HFF/Haa69h48aN2Lt3L4KDg7F48WJ0dnZ6OVICrny9AOCGG27oc89t2bLFixFSb/n5+Vi9ejV+/PFHbNu2Dd3d3bj++uvR1tbmes5jjz2Gzz77DO+//z7y8/NRVVWFW2+9VcaoR7fBXDMAePDBB/vcZy+++KJMEY9uSUlJeOGFF3Dw4EEcOHAA1157LZYtW4YTJ04A4P3la650vQDeW75q//79+OMf/4gpU6b0eVy2e0wkRZo9e7a4evVq1+9tNpuYkJAgrl+/XsaoqD/PPPOMmJOTI3cYNEgAxI8++sj1e7vdLsbFxYm//e1vXY81NTWJer1e3LJliwwRUm8XXy9RFMV7771XXLZsmSzx0JXV1dWJAMT8/HxRFB33k1arFd9//33XcwoLC0UA4p49e+QKk3q5+JqJoijOmzdP/OUvfylfUDSg8PBw8c033+T9pRDS9RJF3lu+qqWlRczMzBS3bdvW5xrJeY/xRF6BLBYLDh48iEWLFrkeU6lUWLRoEfbs2SNjZHQ5Z86cQUJCAtLT03HXXXfBZDLJHRINUmlpKWpqavrcb6GhocjNzeX95sN27dqFmJgYjB8/Ho888ggaGhrkDomczGYzACAiIgIAcPDgQXR3d/e5x7KyspCSksJ7zEdcfM0k77zzDqKiojBp0iQ8+eSTaG9vlyM86sVms+Hdd99FW1sb8vLyeH/5uIuvl4T3lu9ZvXo1brrppj73EiDvf8M0Hn118oj6+nrYbDbExsb2eTw2NhZFRUUyRUWXk5ubi02bNmH8+PGorq7Gc889hzlz5uD48eMwGAxyh0dXUFNTAwD93m/S98i33HDDDbj11lsxZswYlJSU4D/+4z+wZMkS7NmzB2q1Wu7wRjW73Y61a9fimmuuwaRJkwA47jGdToewsLA+z+U95hv6u2YAcOeddyI1NRUJCQk4evQo/v3f/x2nTp3Chx9+KGO0o9exY8eQl5eHzs5OhISE4KOPPkJ2djYKCgp4f/mgy10vgPeWL3r33Xdx6NAh7N+//5LvyfnfMCbyRB62ZMkS16+nTJmC3NxcpKamYuvWrbj//vtljIzIP61YscL168mTJ2PKlCkYO3Ysdu3ahYULF8oYGa1evRrHjx/nnBAFudw1e+ihh1y/njx5MuLj47Fw4UKUlJRg7Nix3g5z1Bs/fjwKCgpgNpvxwQcf4N5770V+fr7cYdFlXO56ZWdn897yMeXl5fjlL3+Jbdu2ISAgQO5w+mBpvQJFRUVBrVZfMg2xtrYWcXFxMkVFgxUWFoZx48ahuLhY7lBoEKR7ivebcqWnpyMqKor3nMzWrFmDzz//HDt37kRSUpLr8bi4OFgsFjQ1NfV5Pu8x+V3umvUnNzcXAHifyUSn0yEjIwMzZszA+vXrkZOTg1dffZX3l4+63PXqD+8teR08eBB1dXWYPn06NBoNNBoN8vPz8dprr0Gj0SA2Nla2e4yJvALpdDrMmDED27dvdz1mt9uxffv2Pv015JtaW1tRUlKC+Ph4uUOhQRgzZgzi4uL63G/Nzc3Yu3cv7zeFqKioQENDA+85mYiiiDVr1uCjjz7Cjh07MGbMmD7fnzFjBrRabZ977NSpUzCZTLzHZHKla9afgoICAOB95iPsdju6urp4fymEdL36w3tLXgsXLsSxY8dQUFDg+po5cybuuusu16/lusdYWq9Q69atw7333ouZM2di9uzZeOWVV9DW1oZVq1bJHRpd5PHHH8fSpUuRmpqKqqoqPPPMM1Cr1Vi5cqXcoZFTa2trn0+6S0tLUVBQgIiICKSkpGDt2rV4/vnnkZmZiTFjxuCpp55CQkICbr75ZvmCHsUGul4RERF47rnncNtttyEuLg4lJSV44oknkJGRgcWLF8sY9ei1evVqbN68GZ988gkMBoOrZzA0NBSBgYEIDQ3F/fffj3Xr1iEiIgJGoxG/+MUvkJeXh6uuukrm6EenK12zkpISbN68GTfeeCMiIyNx9OhRPPbYY5g7d+4la5nI85588kksWbIEKSkpaGlpwebNm7Fr1y58/fXXvL980EDXi/eW7zEYDH3mgwBAcHAwIiMjXY/Ldo95dCY+edTvf/97MSUlRdTpdOLs2bPFH3/8Ue6QqB/Lly8X4+PjRZ1OJyYmJorLly8Xi4uL5Q6Letm5c6cI4JKve++9VxRFxwq6p556SoyNjRX1er24cOFC8dSpU/IGPYoNdL3a29vF66+/XoyOjha1Wq2YmpoqPvjgg2JNTY3cYY9a/V0rAOJf//pX13M6OjrERx99VAwPDxeDgoLEW265RayurpYv6FHuStfMZDKJc+fOFSMiIkS9Xi9mZGSI//Zv/yaazWZ5Ax+lfv7zn4upqamiTqcTo6OjxYULF4r/+Mc/XN/n/eVbBrpevLeU4eIVgXLdY4IoiqJnPyogIiIiIiIiIndhjzwRERERERGRgjCRJyIiIiIiIlIQJvJERERERERECsJEnoiIiIiIiEhBmMgTERERERERKQgTeSIiIiIiIiIFYSJPREREREREpCBM5ImIiIiIiIgUhIk8EREReV1aWhpeeeUVucMgIiJSJCbyREREfu6+++7DzTffDACYP38+1q5d67X33rRpE8LCwi55fP/+/XjooYe8FgcREZE/0cgdABERESmPxWKBTqcb9s9HR0e7MRoiIqLRhSfyREREo8R9992H/Px8vPrqqxAEAYIgoKysDABw/PhxLFmyBCEhIYiNjcXdd9+N+vp618/Onz8fa9aswdq1axEVFYXFixcDAF5++WVMnjwZwcHBSE5OxqOPPorW1lYAwK5du7Bq1SqYzWbX+z377LMALi2tN5lMWLZsGUJCQmA0GnHHHXegtrbW9f1nn30WU6dOxdtvv420tDSEhoZixYoVaGlp8exfGhERkQ9iIk9ERDRKvPrqq8jLy8ODDz6I6upqVFdXIzk5GU1NTbj22msxbdo0HDhwAF999RVqa2txxx139Pn5t956CzqdDt9//z02btwIAFCpVHjttddw4sQJvPXWW9ixYweeeOIJAMDVV1+NV155BUaj0fV+jz/++CVx2e12LFu2DI2NjcjPz8e2bdtw9uxZLF++vM/zSkpK8PHHH+Pzzz/H559/jvz8fLzwwgse+tsiIiLyXSytJyIiGiVCQ0Oh0+kQFBSEuLg41+Ovv/46pk2bhl//+teux/7yl78gOTkZp0+fxrhx4wAAmZmZePHFF/u8Zu9++7S0NDz//PN4+OGH8cYbb0Cn0yE0NBSCIPR5v4tt374dx44dQ2lpKZKTkwEA//u//4uJEydi//79mDVrFgBHwr9p0yYYDAYAwN13343t27fjV7/61cj+YoiIiBSGJ/JERESj3JEjR7Bz506EhIS4vrKysgA4TsElM2bMuORnv/nmGyxcuBCJiYkwGAy4++670dDQgPb29kG/f2FhIZKTk11JPABkZ2cjLCwMhYWFrsfS0tJcSTwAxMfHo66ubkh/ViIiIn/AE3kiIqJRrrW1FUuXLsVvfvObS74XHx/v+nVwcHCf75WVleGnP/0pHnnkEfzqV79CREQEvvvuO9x///2wWCwICgpya5xarbbP7wVBgN1ud+t7EBERKQETeSIiolFEp9PBZrP1eWz69On429/+hrS0NGg0g/9fg4MHD8Jut+Oll16CSuUo8tu6desV3+9iEyZMQHl5OcrLy12n8idPnkRTUxOys7MHHQ8REdFowdJ6IiKiUSQtLQ179+5FWVkZ6uvrYbfbsXr1ajQ2NmLlypXYv38/SkpK8PXXX2PVqlUDJuEZGRno7u7G73//e5w9exZvv/22awhe7/drbW3F9u3bUV9f32/J/aJFizB58mTcddddOHToEPbt24d77rkH8+bNw8yZM93+d0BERKR0TOSJiIhGkccffxxqtRrZ2dmIjo6GyWRCQkICvv/+e9hsNlx//fWYPHky1q5di7CwMNdJe39ycnLw8ssv4ze/+Q0mTZqEd955B+vXr+/znKuvvhoPP/wwli9fjujo6EuG5QGOEvlPPvkE4eHhmDt3LhYtWoT09HS89957bv/zExER+QNBFEVR7iCIiIiIiIiIaHB4Ik9ERERERESkIEzkiYiIiIiIiBSEiTwRERERERGRgjCRJyIiIiIiIlIQJvJERERERERECsJEnoiIiIiIiEhBmMgTERERERERKQgTeSIiIiIiIiIFYSJPREREREREpCBM5ImIiIiIiIgUhIk8ERERERERkYL8fxYDqtcyngJFAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -803,7 +797,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Training time: 22 seconds\n" + "Training time: 74 seconds\n" ] } ], @@ -814,10 +808,10 @@ "optimizer = COBYLA(maxiter=40)\n", "\n", "vqc = VQC(\n", + " sampler=sampler,\n", " feature_map=feature_map,\n", " ansatz=ansatz,\n", " optimizer=optimizer,\n", - " quantum_instance=quantum_instance,\n", " callback=callback_graph,\n", ")\n", "\n", @@ -884,10 +878,10 @@ "text": [ "Model | Test Score | Train Score\n", "SVC, 4 features | 0.99 | 0.97\n", - "VQC, 4 features, RealAmplitudes | 0.82 | 0.83\n", + "VQC, 4 features, RealAmplitudes | 0.85 | 0.87\n", "----------------------------------------------------------\n", "SVC, 2 features | 0.97 | 0.90\n", - "VQC, 2 features, RealAmplitudes | 0.57 | 0.63\n", + "VQC, 2 features, RealAmplitudes | 0.58 | 0.63\n", "VQC, 2 features, EfficientSU2 | 0.78 | 0.80\n" ] } @@ -923,7 +917,7 @@ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0.dev0+4749eb5
qiskit-aer0.11.0
qiskit-nature0.5.0
qiskit-finance0.4.0
qiskit-optimization0.5.0
qiskit-machine-learning0.5.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Mar 28 2022 06:16:26
OSDarwin
CPUs2
Memory (Gb)12.0
Thu Sep 15 13:58:23 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Fri Oct 14 14:33:06 2022 GMT Daylight Time
" ], "text/plain": [ "" @@ -970,7 +964,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.7.9" }, "vscode": { "interpreter": { From 178831eb107d58c246486ed0af1a25dd7b5a24f6 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Sat, 29 Oct 2022 00:41:29 +0100 Subject: [PATCH 90/96] update 05 --- docs/tutorials/05_torch_connector.ipynb | 305 ++++++++---------------- 1 file changed, 100 insertions(+), 205 deletions(-) diff --git a/docs/tutorials/05_torch_connector.ipynb b/docs/tutorials/05_torch_connector.ipynb index 08ee43e4f..ec29941ff 100644 --- a/docs/tutorials/05_torch_connector.ipynb +++ b/docs/tutorials/05_torch_connector.ipynb @@ -16,10 +16,10 @@ "The first part of this tutorial shows how quantum neural networks can be trained using PyTorch's automatic differentiation engine (`torch.autograd`, [link](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html)) for simple classification and regression tasks. \n", "\n", "1. [Classification](#1.-Classification)\n", - " 1. Classification with PyTorch and `OpflowQNN`\n", - " 2. Classification with PyTorch and `CircuitQNN`\n", + " 1. Classification with PyTorch and `EstimatorQNN`\n", + " 2. Classification with PyTorch and `SamplerQNN`\n", "2. [Regression](#2.-Regression)\n", - " 1. Regression with PyTorch and `OpflowQNN`\n", + " 1. Regression with PyTorch and `SamplerQNN`\n", "\n", "[Part 2: MNIST Classification, Hybrid QNNs](#Part-2:-MNIST-Classification,-Hybrid-QNNs)\n", "\n", @@ -46,28 +46,16 @@ "\n", "from qiskit import QuantumCircuit\n", "from qiskit_aer import Aer\n", - "from qiskit.utils import QuantumInstance, algorithm_globals\n", - "from qiskit.opflow import AerPauliExpectation\n", + "from qiskit.utils import algorithm_globals\n", "from qiskit.circuit import Parameter\n", "from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap\n", - "from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN\n", + "from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN\n", "from qiskit_machine_learning.connectors import TorchConnector\n", "\n", "# Set seed for random generators\n", "algorithm_globals.random_seed = 42" ] }, - { - "cell_type": "code", - "execution_count": 2, - "id": "educational-cocktail", - "metadata": {}, - "outputs": [], - "source": [ - "# declare quantum instance\n", - "qi = QuantumInstance(Aer.get_backend(\"aer_simulator_statevector\"))" - ] - }, { "cell_type": "markdown", "id": "unique-snapshot", @@ -88,13 +76,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "secure-tragedy", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtPUlEQVR4nO3deXxU5fX48c9JIEBcEDB1QxKiVAlLQcIuIoJsoqCiBqMFRSMFcfviQqNFUfy5tAX3GlFEjSKLSChQlgBVipEEWbJQJIDBBRUVaTWy5vz+mJt0wIQQZrkzmfN+veY1c59779zDzTBnnrucR1QVY4wxkSvK7QCMMca4yxKBMcZEOEsExhgT4SwRGGNMhLNEYIwxEa6O2wEcj1NPPVUTEhLcDsMYY8LK2rVrv1PVuCPbwzIRJCQkkJeX53YYxhgTVkSkpLJ2OzRkjDERzhKBMcZEOEsExhgT4SwRGGNMhLNEYIwxEc4viUBEXhORb0WkoIr5IiLPikixiGwUkQu85g0XkS3OY7g/4jHGGHPs/NUjeB3of5T5A4AWziMNeAlARBoDE4DOQCdggog08lNMxhhjjoFfEoGqfgD8cJRFBgNvqEcOcIqInAH0A5aq6g+quhtYytETis+Kioqw0tvGGPM/wTpHcBbwudf0F05bVe2/IiJpIpInInm7du06riCKi4tp3749gwYN4vPPP69+BWOMiQBhc7JYVTNUNVlVk+PifnWH9DFp3rw5Tz31FCtXrqRVq1a89NJLlJWV+TlSY4wJL8FKBF8CZ3tNN3XaqmoPiOjoaO68804KCgro3Lkzo0ePpk+fPhw8eDAg28vMhIQEiIryPGdmBmQzxhjjk2Algizg987VQ12APaq6E1gM9BWRRs5J4r5OW0A1b96cJUuW8Nprr3HxxRdTp46n5JI/zx1kZkJaGpSUgKrnOS3NkoExJvT46/LRd4CPgPNE5AsRGSkio0RklLPIQmAbUAy8AowGUNUfgEeBXOcx0WkLOBHhpptu4k9/+hMAK1asoHPnzmzcuNEv75+eDqWlh7eVlnrajYlk1lMOPX6pPqqqw6qZr8CYKua9Brzmjzh88csvv1BSUkKHDh0YP3486enp1KtX77jfb8eOmrUbEwnKe8rlP5LKe8oAqanuxRXpwuZkcaANHDiQoqIirr/+eh599FHat29PTk7Ocb9fs2Y1azcmElhPOTRZIvDSpEkTpk+fzsKFC/npp5/Izc097veaNAliYw9vi431tBsTqaynHJrCcmCaQBswYACFhYXEOt/kc+fO5cQTT+TSSy895vco7+amp3s+5M2aeZKAdX9NJGvWzHM4qLJ24x7rEVThpJNOIjo6GlXl6aefpm/fvowcOZLdu3cf83ukpsJnn0FZmefZkoCJdNZTDk2WCKohIixfvpzx48czffp0kpKSmDt3rtthGROWUlMhIwPi40HE85yRYT+S3CbhWHcnOTlZ3Riz+JNPPmHkyJGsX7+enJwcOnfuHPQYjDHmeInIWlVNPrLdegQ1cMEFF7BmzRrmzJlTkQQKCgqsiF2Q2PXnxgSGJYIaqlu3LldddRXgKWLXoUMHBg4cyA677CGg7E5tYwLHEoEPEhMT+fOf/8yHH35Iq1ateOGFF6yIXYDY9efGBI4lAh9ERUUxduxYCgoK6Nq1K7fffjuXXHJJwIrYRTK7/tyYwLH7CPwgISGBxYsXM336dD7//POKInZlZWVERVmu9Qe7/tyYwLFvKT8REUaMGMFDDz0EwPLly+nYsSPr1q1zObLawa4/NyZwLBEEyP79+/nqq6/o2LEjf/zjH9m7d6/bIYU1u/7c1FahcDWc3UcQQLt37+b//u//mDZtGueddx6vvvoq3bt3dzssY0yIOLIaK3h6uoH6kWP3EbigUaNGvPbaayxevJi9e/eyfv16t0MyxoSQULkazk4WB0Hfvn0pKCioKGL33nvvccIJJ9CvXz+XIzPGuClUrobz1whl/UVks4gUi8gDlcyfLCLrncenIvKj17xDXvOy/BFPKDrxxBOJiopCVfnrX/9K//79GTFiBD/8EJQB2YwxIShUxi3xORGISDTwAjAASAKGiUiS9zKqereqtlPVdsBzwHtes38pn6eqV/gaT6gTEZYtW0Z6ejpvvfUWSUlJzJkzx+2wjDEuCJWr4fzRI+gEFKvqNlXdD8wABh9l+WHAO37YbtiqX78+jz32GHl5eZx55pkMHTqUjz/+2O2wjDFBFipXw/kjEZwFfO41/YXT9isiEg80B5Z7NdcXkTwRyRGRIVVtRETSnOXydu3a5Yew3deuXTvWrFnD3LlzK4rYbdy40YrYGRNBQmHckmBfNZQCzFbVQ15t8c7lTNcDU0TknMpWVNUMVU1W1eS4uLhgxBoUderUYciQIYCniF3Hjh3p168fn332matxGWMihz8SwZfA2V7TTZ22yqRwxGEhVf3Sed4GrATa+yGmsJSYmMjkyZP56KOPaN26Nc8++yyHDh2qfkVjjPGBPxJBLtBCRJqLSAyeL/tfXf0jIucDjYCPvNoaiUg95/WpQHegyA8xhaWoqChGjx5NYWEhF110EXfeeSe9evWyInbGmIDy+T4CVT0oIrcDi4Fo4DVVLRSRiUCeqpYnhRRghh5+ALwl8LKIlOFJSk+oasQmgnLNmjVjwYIFZGZmsmPHDitiZ4wJKCsxESays7MZN24cr776KhdccIHb4RhjwpCVmAhzhw4d4ptvvqFTp0488MAD/PLLL26HZIypJSwRhIm+fftSWFjIiBEjePLJJ2nXrh0ffvih22GZMBUKFS9N6LBEEEYaNWrE1KlTWbZsGQcOHGDjxo1uh2TCkI3/bI5k5wjC1M8//0yDBg2Iiopizpw5NGjQgIEDB7odlgkDCQmVj/YWH++5ocnUXnaOoJY54YQTKorYTZkyhcsuu4wbb7yR7777zu3QTIgLlYqXJnRYIghz5UXsHnroIWbMmEFSUhIzZ860MhWmSqFS8dKEDksEtUC9evWYOHEia9euJT4+nuuuu86K2JkqhUrFSxM6LBHUIm3btuWjjz4iKyuLLl26ALB+/XrrHZjDhErFSxM67GRxLVZcXExSUhI9evTglVdeITEx0e2QjDEuspPFESgxMZHnnnuO3Nxc2rRpw5QpU6yInQlJdl+DuywR1GJRUVHcdtttFBUV0atXL+6++2569uxpRexMSLH7GtxniSACNG3alPnz55OZmclll112WBE7Y9yWng6lpYe3lZZ62k1wWCKIECLC9ddfz/jx4wFPEbv27duTm5vrcmQm0tl9De6zRBChVJXvv/+eLl26cO+991J65E8yY4LE7mtwnyWCCNWnTx8KCwu55ZZb+POf/0zbtm355z//6XZYJgLZfQ3us0QQwRo2bMjLL7/M8uXLASgqivgxgYwL7L4G9/nlPgIR6Q88g2eEsqmq+sQR80cAT/O/sYyfV9WpzrzhwINO+2OqOr267dl9BP5XWlpK/fr1iYqKYvbs2dSvX59Bgwa5HZYxxo8Cdh+BiEQDLwADgCRgmIgkVbLou6raznmUJ4HGwASgM9AJmCAijXyNydRcbGxsRRG7Z599lssvv5zU1FR27drldmjGmADzx6GhTkCxqm5T1f3ADGDwMa7bD1iqqj+o6m5gKdDfDzGZ41RexO7hhx9m1qxZJCUlMWPGDCtTYUwt5o9EcBbwudf0F07bka4WkY0iMltEzq7huohImojkiUie/UoNrJiYGCZMmMAnn3xCYmIiw4YNsyJ2xtRiwTpZPB9IUNW2eH71V3se4EiqmqGqyaqaHBcX5/cAza+1bt2a1atX8/e//72iiN0nn3xivQNjahl/JIIvgbO9ppvyv5PCAKjq96q6z5mcCnQ41nWNu6Kjo7nssssATxG7Ll260Lt3b4qLi12OzBjjL/5IBLlACxFpLiIxQAqQ5b2AiJzhNXkFsMl5vRjoKyKNnJPEfZ02E4LOOeccXnjhBdauXUvbtm35y1/+YnWLjKkFfE4EqnoQuB3PF/gmYKaqForIRBG5wlnsDhEpFJENwB3ACGfdH4BH8SSTXGCi02ZCkIhw6623UlRUxKWXXsq4ceO46KKLLBkYE+ZsPAJzXFSVWbNmsX37du6//34ADh06RHR0tMuRGWOqYuMRGL8SEa699tqKJLBs2TLatWtnVxcZE4YsERi/EBF+/PFHunbtyj333MPPP//sdkjGHJUNhvM/lgiMX/Tu3ZvCwkJGjRrF5MmTadu2LStWrHA7LGMqZYPhHM4SgfGbk08+mRdffJGVK1cSHR3Nv//9b7dDMqZSNhjO4SwRhIHM/EwSpiQQ9UgUCVMSyMwP7Z8tPXv2ZMOGDdx2220AzJw5k6ysrGrWMiZ4bDCcw1kiCHGZ+ZmkzU+jZE8JilKyp4S0+WkhnwwaNGhQUcTuxRdfZPDgwaSkpPDtt9+6HZoxNhjOESwRhLj07HRKDxzehy09UEp6dnj0YUWEJUuW8OijjzJ37lxatmzJW2+9ZWUqjKtsMJzDWSIIcTv2VN5Xraq9JoJ1yCkmJoYHH3yQdevWcd5553HjjTeSk5MTkG0ZcyxsMJzDWSIIcc0aVt5Xrar9WLlxyCkpKYkPP/yQhQsX0rVrVwDy8vIoKysL2DaNqUpqKnz2GZSVeZ4jNQmAJYKQN6n3JGLrHt6Hja0by6TevvVh3TrkFB0dzYABAwBPEbtu3brRq1cvtmzZEtDtGmOqZokgxKW2SSXj8gziG8YjCPEN48m4PIPUNr79fAnkIadjdc455/Dyyy+zceNG2rZty1NPPWV1i4xxgdUailAJUxIo2VPyq/b4hvF8dtdnQY1l586djBkzhrlz59KlSxc+/PBD6tSpE9QYjIkEVmvIHCZQh5yOxxlnnMGcOXOYNWsWV111VUUSOHToUNBjMSYSWSKIUIE65HS8RIShQ4dy7733ArB06VLatGnDRx995Eo8xkQSSwQRLLVNKp/d9RllE8r47K7PXEsClalTpw4///wz3bt356677uKnn35yOyQTRqygXM34JRGISH8R2SwixSLyQCXz7xGRImfw+mwRifead0hE1jsPq0NgAOjVqxcFBQWMHj2aZ555hjZt2pCdne12WCYMWEG5mvM5EYhINPACMABIAoaJSNIRi60Dkp3B62cDT3nN+0VV2zmPKzDGcdJJJ/H888/zwQcfEBMTY+Mkm2NiBeVqzh+XZnQCilV1G4CIzAAGA0XlC6iqdz3iHOAGP2zXRIgePXqwYcMGYmJiAJgxYwYxMTFcddVVLkdmQpEVlKs5fxwaOgv43Gv6C6etKiOBRV7T9UUkT0RyRGRIVSuJSJqzXN6uXbt8CtiEn/r161cUscvIyODqq6/mmmuu4euvv3Y7NBNirKBczQX1ZLGI3AAkA097Ncc717VeD0wRkXMqW1dVM1Q1WVWT4+LighCtCUUiwuLFi3n88ceZP38+SUlJvPHGG1bEzlSwgnI1549E8CVwttd0U6ftMCLSB0gHrlDVfeXtqvql87wNWAm090NMpharW7cu48ePZ/369bRs2ZLhw4fbWMmmghWUqzmf7ywWkTrAp0BvPAkgF7heVQu9lmmP5yRxf1Xd4tXeCChV1X0icirwETBYVYs4Cruz2JQrKytj6dKl9OvXD4A1a9aQnJxMVJRdGW3MkQJ2Z7GqHgRuBxYDm4CZqlooIhNFpPwqoKeBE4FZR1wm2hLIE5ENwArgieqSgDHeoqKiKpJAcXEx3bt3p2fPnmzevNnlyIwJH1ZryNQaqsobb7zB3XffTWlpKRMmTGDcuHHUrVvX7dCMCQlWa8jUeiLC8OHDKSoqYtCgQfzxj3+ke/fuVtHUmGpYiUdT65x++unMnj2bOXPmsH379ooidgcPHrSqpsZUwnoEpta6+uqrGTduHABLliyhTZs2/Otf/3I5KmNCjyUCExHq1avH3r176dGjB2PHjuW///2v2yEZEzIsEZiI0LNnT/Lz8xk7diwvvPACrVu3ZunSpW6HZUxIsERgIsaJJ57IM888w6pVq4iNjWXbtm1uh2RMSLAzZybidOvWjfXr11dcVvrOO+9Qt25dhg4d6nJkxrjDegQmItWrV6+iiN3UqVO55ppruPrqq9m5c6fboRkTdJYITEQrL2L3xBNPsGDBApKSkpg2bZoVsTMRxRKBiXh16tTh/vvvZ+PGjbRp04abb76ZnJwct8MyJmgsERjj+O1vf8vKlStZsmQJXbt2BSAnJ4dDhw65HJkxgWWJwBgvUVFRXHrppQBs3bqVHj160KNHDzZt2uRyZMYEjiUCY6qQmJjItGnT2Lx5M+3atWPSpEkcOHDA7bCM8TtLBMZUQUS44YYb2LRpE0OGDOHBBx+kW7duVsTO1Dp2H4Ex1fjNb37Du+++y7Bhww4rYnfgwAErcW1qBesRGHOMhgwZwt133w3A4sWLad26NR988IHLURnjO78kAhHpLyKbRaRYRB6oZH49EXnXmf+xiCR4zRvvtG8WkX7+iMeYQGvQoAEHDhygZ8+ejBkzhv/85z9uh2TMcfM5EYhINPACMABIAoaJSNIRi40EdqvqucBk4Eln3SQgBWgF9AdedN7PmJB20UUXkZ+fz1133cVLL71E69atWbx4sdthGXNc/NEj6AQUq+o2Vd0PzAAGH7HMYGC683o20FtExGmfoar7VHU7UOy8nzEh74QTTmDy5MmsXr2ak046iR07drgdkjHHxR8ni88CPvea/gLoXNUyqnpQRPYATZz2nCPWPauyjYhIGpAG0KxZMz+EbYx/dOnShU8++YSYmBgAMjMzqVOnDtdeey2e3zvGhLawOVmsqhmqmqyqyXFxcW6HY8xh6tWrh4igqrz++uukpKRw5ZVX8tVXX7kdmjHV8kci+BI422u6qdNW6TIiUgdoCHx/jOtGhMz8TBKmJBD1SBQJUxLIzM90OyRzHESERYsW8fTTT7N48WKSkpKYOnWqFbEzIc0fiSAXaCEizUUkBs/J36wjlskChjuvhwLL1fM/IwtIca4qag60ANb4IaawkpmfSdr8NEr2lKAoJXtKSJufZskgTNWpU4dx48aRn59Pu3btuPXWW62InQlpPicCVT0I3A4sBjYBM1W1UEQmisgVzmKvAk1EpBi4B3jAWbcQmAkUAf8AxqhqxFX4Ss9Op/RA6WFtpQdKSc9Odyki4w/nnnsuy5cvJzs7u6KI3erVq62InQk5Eo5d1uTkZM3Ly3M7DL+JeiQK5dd/B0Eom1DmQkQmELZu3cr5559Phw4dePXVV2nVqpXbIZkIIyJrVTX5yPawOVlcmzVrWPlVUFW1m/CUmJjIG2+8wdatW2nfvj0TJ05k//79bodljCWCUDCwxUCEwy8zjK0by6Tek1yKyASCiDBs2DCKiooYOnQoEyZMoGvXrlbR1LjOis65LDM/k+kbph92aEgQhv9uOKltUl2MzARKXFwcb7/9NsOGDWPr1q0VheusiJ1xi/UIXFbZiWJFWbhloUsRmWC5/PLLueuuuwBYtGgRLVu2ZOXKla7GFCoyMyEhAaKiPM+ZdgFdQFkicNmOPZWXJaiq3dROJ510EgC9evXitttuY8+ePS5H5J7MTEhLg5ISUPU8p6VZMggkSwQusxPFBuDCCy9k48aNjBs3jqlTp9KqVSsWLVrkdliuSE+H0sM7yZSWetpNYFgicNmk3pOIrRt7WJudKI5MsbGxPP300+Tk5NC4cWO+/DIib7Knqtp9VtMvcOxkscvKTwinZ6ezY88OmjVsxqTek+xEcQTr2LEjeXl5FSeO33rrLaKjo0lJSYmIInbNmnkOB1XWbgLDbigzJoSpKv3792fJkiUMGjSIl156iaZNm7odVkCVnyPwPjwUGwsZGZBqv498YjeUGROGRISFCxfy17/+lezsbFq1akVGRgZlZbX3jvPUVM+Xfnw8iHieLQkElvUIjAkTW7du5dZbb2XFihWsXr26on6RMcfKegTGhLlzzjmH7OxsVqxYUZEEVq1axcGDB12OzIQ7SwTGhBER4eKLLwY8PYRevXrRtWtXNm7c6G5gJqxZIjAmTCUmJpKZmUlJSQkdOnRgwoQJ7Nu3z+2wTBiyRGBMmBIRrr32WjZt2kRKSgoTJ06kS5cuVsTO1JjdR2BMmGvSpAlvvvkmw4YNo7i4uOL+g/379xMTE+NydCYc+NQjEJHGIrJURLY4z40qWaadiHwkIoUislFErvOa97qIbBeR9c6jnS/xGBPJBg4cyB133AHAwoULadmyJdnZ2S5HZcKBr4eGHgCyVbUFkO1MH6kU+L2qtgL6A1NE5BSv+feqajvnsd7HeEwYyMzPJGFKAlGPRJEwJcHGZg6Ahg0bEh0dTZ8+fbj11lv58ccf3Q7JhDBfE8FgYLrzejow5MgFVPVTVd3ivP4K+BaI83G7Jkxl5meSNj+Nkj0lKErJnhLS5qdZMvCz7t27s2HDBu677z5ee+01kpKSWLBggdthmRDlayI4TVV3Oq+/Bk472sIi0gmIAbZ6NU9yDhlNFpF6R1k3TUTyRCRv165dPoZt3FLZ+AulB0pJz7bSkv7WoEEDnnzyST7++GPi4uL4+uuv3Q7JhKhqE4GILBORgkoeg72XU88tylXepiwiZwBvAjepavn98eOB84GOQGPg/qrWV9UMVU1W1eS4OOtQhCsbfyH4kpOTycvL4+abbwbgjTfe4K233iJUqgrYIDTuqzYRqGofVW1dyWMe8I3zBV/+Rf9tZe8hIicDC4B0Vc3xeu+d6rEPmAZ08sc/yoQuG3/BHXXr1kVEUFXefvttbrzxRi677DJ2uFzb2QahCQ2+HhrKAoY7r4cD845cQERigLnAG6o6+4h55UlE8JxfKPAxHhPibPwFd4kICxYs4JlnnuGf//wnrVq14qWXXnKtiJ0NQhMafE0ETwCXisgWoI8zjYgki8hUZ5lrgYuAEZVcJpopIvlAPnAq8JiP8ZgQl9omlYzLM4hvGI8gxDeMJ+PyDBt/IYiio6O54447KCgooGvXrowePZqPP/7YlVhsEJrQYNVHjYlgqsqqVavo0aMHAB988AHdunWjTp3g3GuakFD5IDTx8fDZZ0EJIaJY9VFjzK+ISEUS2Lp1K5dccgmdO3dmw4YNQdn+pEmeQWe8xcZ62k3wWCIwxgCeInYzZszgiy++IDk5mYceeijgRexsEJrQYIeGjDGH+eGHH7jnnnuYPn06v/vd78jNza2oX2TCW1WHhqzonDHmMI0bN+b1119n2LBhfPrppxVJYN++fdSrV+U9nyaM2aEhY0yl+vXrx9ixYwFYsGAB5513HkuWLHE5KhMIlgiMMdVq0qQJ9evXp1+/ftx0003s3r3b7ZCMH1kiMMZUq0uXLqxfv57x48fz5ptvkpSURFZWltthGT+xRGCMOSb169fn8ccfJzc3l9NPP53vvvvO7ZCMn9jJYmNMjbRv3541a9ZU3HQ2fbqnEv3vf/97PNViTLixHoExpsa8i9jNnDmTESNGMGDAAEoqu03YhDxLBMaY4yYizJ8/n+eee45Vq1bRqlUrnn/+edeK2JnjY4nAGOOTqKgobr/9dgoLC7nwwgsZO3asa0XszPGxRGCM8Yv4+HgWLVrEqlWr6Nq1KwArV67kwIEDLkdmqmOJwBjjNyJC9+7dAdi2bRt9+vShU6dOrFu3zuXIzNFYIjDGBERiYiKzZs3i66+/pmPHjowfP569e/e6HZaphE+JQEQai8hSEdniPDeqYrlDXoPSZHm1NxeRj0WkWETedUYzM8bUEldeeSVFRUUMHz6cJ554gk6dOtmhohDka4/gASBbVVsA2c50ZX5R1XbO4wqv9ieByap6LrAbGOljPMaYENOoUSNeffVVli5dyqhRoyqK2FnvIHT4mggGA9Od19PxjDt8TJxxii8ByscxrtH6xpjw0qdPH0aPHg3A3//+d8477zwWL17sclQGfE8Ep6nqTuf118BpVSxXX0TyRCRHRIY4bU2AH1X1oDP9BXBWVRsSkTTnPfJ27drlY9jGGDfFxcURGxtL//79GT58OD/88IPbIUW0ahOBiCwTkYJKHoO9l1PPCDdVjXIT7wyGcD0wRUTOqWmgqpqhqsmqmhwXF1fT1Y0xIaRz586sW7eOBx98kLfffpuWLVsyb948t8OKWNUmAlXto6qtK3nMA74RkTMAnOdvq3iPL53nbcBKoD3wPXCKiJTXO2oKfOnzv8iYGsrMzyRhSgJRj0SRMCWBzPxMt0OKCPXr1+fRRx8lLy+Ps88+23oFLvK16FwWMBx4wnn+VUp3riQqVdV9InIq0B14SlVVRFYAQ4EZVa1vTCBl5meSNj+N0gOlAJTsKSFtfhoAqW1s4Nxg+N3vfkdOTg7R0dEATJs2DVXlpptusiJ2QeLrOYIngEtFZAvQx5lGRJJFZKqzTEsgT0Q2ACuAJ1S1yJl3P3CPiBTjOWfwqo/xGFMj6dnpFUmgXOmBUtKz012KKDLVqVOnoojde++9x8iRI+nbty/bt293O7SIYIPXm4gW9UgUWsmpLUEom2CF09xQVlZGRkYG9913H4cOHeLxxx/n9ttvr+gxmONX1eD1dmexiWjNGjarUbsJvKioKEaNGkVhYSE9e/bkrrvuYs2aNW6HVatZIjARbVLvScTWjT2sLbZuLJN6T3IpIlPu7LPPZsGCBaxevbqiiN3y5cvtzuQAsERgIlpqm1QyLs8gvmE8ghDfMJ6MyzPsRHEIyMzPpPkzzem+pDsJUxKYvGgyffv2JTk5mbVr17odXq1i5wiMqUZmfibp2ens2LODZg2bMan3JEsUAXbk1Vzg6andduJtzHhiBt988w3jxo3j4YcfpkGDBi5GGl7sHIExx6H8C6lkTwmKVlxeavcaBFZVV3O9V/YeRUVF3HzzzTz11FN07NjRDhX5gSUCY47CLi91x449O6psP+WUU3jllVdYtmwZY8aMqShi98svvwQzxFrFEoExR3G0LyQTOMdyNVfv3r35wx/+AMD8+fP57W9/y4IFC4ISX21jicCYo7DLS91R06u5Tj/9dBo2bMigQYO44YYb+O6774IRZq1hicCYo7DLS91R06u5OnbsyCeffMKECRN49913admyJe+9916Qow5fvtYaMqZWK//isauGgi+1TWqN9nNMTAwPP/wwV199NTfffDP/+c9/Ahhd7WKXjxpjap1Dhw4RFRWFiDBt2jQOHjzILbfcEvFF7OzyUWNMxIiOjq4oYvf++++TlpZGnz592LZtm9uhhSRLBMaYWktEmDt3Li+//DJ5eXm0bt2ayZMnc+jQIbdDCymWCIwxtVpUVBRpaWkUFhbSu3dv7rnnHitidwRLBMaYiNC0aVOysrLIycmpKGK3bNky9u/f73Jk7rNEYIyJGCJC586dAdi2bRv9+/enQ4cOEd9D8CkRiEhjEVkqIluc50aVLNNLRNZ7PfaKyBBn3usist1rXjtf4jHGmGOVmJjI+++/z+7du+natSvjxo2jtLS0+hVrIV97BA8A2araAsh2pg+jqitUtZ2qtgMuAUqBJV6L3Fs+X1XX+xiPMcYcs0GDBlFYWMitt97KX/7yl4gtYufrDWWDgYud19OBlXjGIa7KUGCRqkZm2jXGhJyGDRvyt7/9jZSUFDZv3nxYEbtIKXHta4/gNFXd6bz+GjitmuVTgHeOaJskIhtFZLKI1KtqRRFJE5E8EcnbtWuXDyEbY8yvXXzxxdx2220AZGVl0aJFC+bPn+9yVMFRbSIQkWUiUlDJY7D3cuq5RbnK25RF5AygDbDYq3k8cD7QEWjMUXoTqpqhqsmqmhwXF1dd2MYYc9zOOussGjduzBVXXMH1119Pbf/xWW0iUNU+qtq6ksc84BvnC778i/7bo7zVtcBcVa04AKeqO9VjHzAN6OTbP8cYY3zXoUMH8vLyeOSRR5g9ezYtW7Zkzpw5bocVML4eGsoChjuvhwPzjrLsMI44LOSVRAQYAhT4GI8xxvhFTEwMf/rTn1i3bh3nnnsuP/30k9shBYxPRedEpAkwE2gGlADXquoPIpIMjFLVW5zlEoB/AWerapnX+suBOECA9c461e5tKzpnjAkm7yJ2U6dO5eDBg6SlpREVFV63YlVVdM6qjxpjzDFSVa688krmzZtHz549eeWVV2jRooXbYR0zqz5qjDE+Ki9iN3XqVNavX0/btm15+umnOXjwoNuh+cQSgTHG1ICIMHLkSIqKiujXrx/33Xcfubm5boflE0sExhhzHM4880zmzp1Lbm5uRRG7JUuWsG/fPpcjqzlLBMaEiMz8TBKmJBD1SBQJUxLIzM90OyRTDREhOdlzyH379u0MHDiQCy64gJycHJcjqxlLBMaEgMz8TNLmp1GypwRFKdlTQtr8NEsGYaR58+bMnz+f//73v3Tr1o27776bn3/+2e2wjoklAmNCQHp2OqUHDi/BVXqglPTsdJciMsdjwIABFBQUMGrUKKZMmUJycnJYFLHzteicMcYPduzZUaN2E7pOPvlkXnzxRVJSUvj3v/9dUcSutLSU2NhYl6OrnPUIjDmKYB23b9awWY3aTei76KKLSEtLA2DevHmce+65zJt3tOIL7rFEYEwVgnncflLvScTWPfzXYmzdWCb1nuT3bZnga9asGb/5zW8YMmQI1113Hd98843bIR3GEoExVQjmcfvUNqlkXJ5BfMN4BCG+YTwZl2eQ2ibV79sywde+fXtyc3N57LHHeP/990lKSmLWrFluh1XBzhEYU4VgH7dPbZNqX/y1WN26dUlPT+eqq65i5MiR7N271+2QKlgiMKYKzRo2o2RPSaXtxhyvli1bsmrVKjxFl2Hq1Kns37+fUaNGuVbEzg4NGVMFO25vAqW8kqmqsmjRIsaMGcPFF1/Mp59+6k48rmzVmDBgx+1NoIkIs2fPZtq0aeTn59O2bVuefPLJoBexszLUxhgTAnbu3MmYMWOYO3cuq1evrqhf5E9WhtoYY0LYGWecwXvvvcfatWsrksA//vGPoJxU9ikRiMg1IlIoImXOqGRVLddfRDaLSLGIPODV3lxEPnba3xWRGF/iMcaYcHfBBRcAniJ2l112Ge3bt2f16tUB3aavPYIC4Crgg6oWEJFo4AVgAJAEDBORJGf2k8BkVT0X2A2M9DEeY4ypFZo3b87ChQspLS3lwgsv5M477wzYuMk+JQJV3aSqm6tZrBNQrKrbVHU/MAMY7AxYfwkw21luOp4B7I0xxgD9+vWjoKCAMWPG8Nxzz3HvvfcGZDvBuI/gLOBzr+kvgM5AE+BHVT3o1X5WVW8iImlAGnhu1zbGmEhw0kkn8dxzz3HddddxzjnnBGQb1SYCEVkGnF7JrHRVDVoFJVXNADLAc9VQsLZrjDGh4MILLwzYe1ebCFS1j4/b+BI422u6qdP2PXCKiNRxegXl7cYYY4IoGJeP5gItnCuEYoAUIEs9NzCsAIY6yw0HQrNGqzHG1GK+Xj56pYh8AXQFFojIYqf9TBFZCOD82r8dWAxsAmaqaqHzFvcD94hIMZ5zBq/6Eo8xxpiaszuLjTEmQtidxcYYYyplicAYYyKcJQJjjIlwlgiMMSbCheXJYhHZBfx66KhjcyrwnR/D8ReLq2YsrpqxuGqmtsYVr6pxRzaGZSLwhYjkVXbW3G0WV81YXDVjcdVMpMVlh4aMMSbCWSIwxpgIF4mJIMPtAKpgcdWMxVUzFlfNRFRcEXeOwBhjzOEisUdgjDHGiyUCY4yJcLUyEYjINSJSKCJlIlLlpVYi0l9ENotIsYg84NXeXEQ+dtrfdcpn+yOuxiKyVES2OM+NKlmml4is93rsFZEhzrzXRWS717x2wYrLWe6Q17azvNrd3F/tROQj5++9UUSu85rn1/1V1efFa349599f7OyPBK954532zSLSz5c4jiOue0SkyNk/2SIS7zWv0r9pkOIaISK7vLZ/i9e84c7ffYuIDA9yXJO9YvpURH70mheQ/SUir4nItyJSUMV8EZFnnZg3isgFXvN831eqWuseQEvgPGAlkFzFMtHAViARiAE2AEnOvJlAivP6b8Af/BTXU8ADzusHgCerWb4x8AMQ60y/DgwNwP46priAn6pod21/Ab8FWjivzwR2Aqf4e38d7fPitcxo4G/O6xTgXed1krN8PaC58z7RQYyrl9dn6A/lcR3tbxqkuEYAz1eybmNgm/PcyHndKFhxHbH8WOC1IOyvi4ALgIIq5g8EFgECdAE+9ue+qpU9AlXdpKqbq1msE1CsqttUdT8wAxgsIgJcAsx2lpsODPFTaIOd9zvW9x0KLFLVUj9tvyo1jauC2/tLVT9V1S3O66+Ab4Ff3TnpB5V+Xo4S72ygt7N/BgMzVHWfqm4Hip33C0pcqrrC6zOUg2c0wEA7lv1VlX7AUlX9QVV3A0uB/i7FNQx4x0/brpKqfoDnR19VBgNvqEcOntEdz8BP+6pWJoJjdBbwudf0F05bE+BH9Qyo493uD6ep6k7n9dfAadUsn8KvP4STnK7hZBGpF+S46otInojklB+uIoT2l4h0wvMrb6tXs7/2V1Wfl0qXcfbHHjz751jWDWRc3kbi+WVZrrK/aTDjutr5+8wWkfIhbUNifzmH0JoDy72aA7W/qlNV3H7ZV9WOWRyqRGQZcHols9JV1bUhL48Wl/eEqqqIVHntrpPt2+AZ2a3ceDxfiDF4rie+H5gYxLjiVfVLEUkElotIPp4vu+Pm5/31JjBcVcuc5uPeX7WRiNwAJAM9vZp/9TdV1a2Vv4PfzQfeUdV9InIbnt7UJUHa9rFIAWar6iGvNjf3V8CEbSJQ1T4+vsWXwNle002dtu/xdLvqOL/qytt9jktEvhGRM1R1p/PF9e1R3upaYK6qHvB67/Jfx/tEZBowLphxqeqXzvM2EVkJtAfm4PL+EpGTgQV4fgTkeL33ce+vSlT1ealsmS9EpA7QEM/n6VjWDWRciEgfPMm1p6ruK2+v4m/qjy+2auNS1e+9JqfiOSdUvu7FR6y70g8xHVNcXlKAMd4NAdxf1akqbr/sq0g+NJQLtBDPFS8xeP7oWeo5A7MCz/F5gOGAv3oYWc77Hcv7/urYpPNlWH5cfghQ6RUGgYhLRBqVH1oRkVOB7kCR2/vL+dvNxXP8dPYR8/y5vyr9vBwl3qHAcmf/ZAEp4rmqqDnQAljjQyw1iktE2gMvA1eo6rde7ZX+TYMY1xlek1fgGdMcPL3gvk58jYC+HN4zDmhcTmzn4zn5+pFXWyD3V3WygN87Vw91AfY4P3T8s68CcQbc7QdwJZ5jZfuAb4DFTvuZwEKv5QYCn+LJ6Ole7Yl4/qMWA7OAen6KqwmQDWwBlgGNnfZkYKrXcgl4Mn3UEesvB/LxfKG9BZwYrLiAbs62NzjPI0NhfwE3AAeA9V6PdoHYX5V9XvAcarrCeV3f+fcXO/sj0WvddGe9zcAAP3/eq4trmfP/oHz/ZFX3Nw1SXP8PKHS2vwI432vdm539WAzcFMy4nOmHgSeOWC9g+wvPj76dzmf5CzznckYBo5z5ArzgxJyP19WQ/thXVmLCGGMiXCQfGjLGGIMlAmOMiXiWCIwxJsJZIjDGmAhnicAYYyKcJQJjjIlwlgiMMSbC/X/yMOvl8jZ4LAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -114,8 +102,8 @@ "\n", "# Generate random input coordinates (X) and binary labels (y)\n", "X = 2 * algorithm_globals.random.random([num_samples, num_inputs]) - 1\n", - "y01 = 1 * (np.sum(X, axis=1) >= 0) # in { 0, 1}, y01 will be used for CircuitQNN example\n", - "y = 2 * y01 - 1 # in {-1, +1}, y will be used for OplowQNN example\n", + "y01 = 1 * (np.sum(X, axis=1) >= 0) # in { 0, 1}, y01 will be used for SamplerQNN example\n", + "y = 2 * y01 - 1 # in {-1, +1}, y will be used for EstimatorQNN example\n", "\n", "# Convert to torch Tensors\n", "X_ = Tensor(X)\n", @@ -137,49 +125,57 @@ "id": "hazardous-rehabilitation", "metadata": {}, "source": [ - "#### A. Classification with PyTorch and `OpflowQNN`\n", + "#### A. Classification with PyTorch and `EstimatorQNN`\n", "\n", - "Linking an `OpflowQNN` to PyTorch is relatively straightforward. Here we illustrate this using the `TwoLayerQNN`, a sub-case of `OpflowQNN` introduced in previous tutorials." + "Linking an `EstimatorQNN` to PyTorch is relatively straightforward. Here we illustrate this by using the `EstimatorQNN` constructed from a feature map and an ansatz." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "fewer-desperate", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Set up a circuit\n", + "feature_map = ZZFeatureMap(num_inputs)\n", + "ansatz = RealAmplitudes(num_inputs)\n", + "qc = QuantumCircuit(num_inputs)\n", + "qc.compose(feature_map, inplace=True)\n", + "qc.compose(ansatz, inplace=True)\n", + "qc.draw(\"mpl\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "humanitarian-flavor", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ComposedOp([\n", - " OperatorMeasurement(1.0 * ZZ),\n", - " CircuitStateFn(\n", - " ┌──────────────────────────┐»\n", - " q_0: ┤0 ├»\n", - " │ ZZFeatureMap(x[0],x[1]) │»\n", - " q_1: ┤1 ├»\n", - " └──────────────────────────┘»\n", - " « ┌──────────────────────────────────────────────────────────┐\n", - " «q_0: ┤0 ├\n", - " « │ RealAmplitudes(θ[0],θ[1],θ[2],θ[3],θ[4],θ[5],θ[6],θ[7]) │\n", - " «q_1: ┤1 ├\n", - " « └──────────────────────────────────────────────────────────┘\n", - " )\n", - "])\n", "Initial weights: [-0.01256962 0.06653564 0.04005302 -0.03752667 0.06645196 0.06095287\n", " -0.02250432 -0.04233438]\n" ] } ], "source": [ - "# Set up QNN\n", - "# Note: we are not providing them explicitly in this examples,\n", - "# but TwoLayerQNN requires a feature_map and ansatz to work.\n", - "# By default, these parameters are set to ZZFeatureMap\n", - "# and RealAmplitudes (respectively).\n", - "qnn1 = TwoLayerQNN(num_qubits=num_inputs, quantum_instance=qi)\n", - "print(qnn1.operator)\n", + "# Setup QNN\n", + "qnn1 = EstimatorQNN(circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters)\n", "\n", "# Set up PyTorch module\n", "# Note: If we don't explicitly declare the initial weights\n", @@ -224,7 +220,7 @@ "\n", "\n", "**💡 Clarification :** \n", - "In classical machine learning, the general rule of thumb is to apply a Cross-Entropy loss to classification tasks, and MSE loss to regression tasks. However, this recommendation is given under the assumption that the output of the classification network is a class probability value in the [0,1] range (usually this is achieved through a Softmax layer). Because the following example for `TwoLayerQNN` does not include such layer, and we don't apply any mapping to the output (the following section shows an example of application of parity mapping with `CircuitQNNs`), the QNN's output can take any value in the range [-1,1]. In case you were wondering, this is the reason why this particular example uses MSELoss for classification despite it not being the norm (but we encourage you to experiment with different loss functions and see how they can impact training results). " + "In classical machine learning, the general rule of thumb is to apply a Cross-Entropy loss to classification tasks, and MSE loss to regression tasks. However, this recommendation is given under the assumption that the output of the classification network is a class probability value in the $[0, 1]$ range (usually this is achieved through a Softmax layer). Because the following example for `EstimatorQNN` does not include such layer, and we don't apply any mapping to the output (the following section shows an example of application of parity mapping with `SamplerQNN`s), the QNN's output can take any value in the range $[-1, 1]$. In case you were wondering, this is the reason why this particular example uses MSELoss for classification despite it not being the norm (but we encourage you to experiment with different loss functions and see how they can impact training results). " ] }, { @@ -311,7 +307,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -357,14 +353,14 @@ "id": "typical-cross", "metadata": {}, "source": [ - "#### B. Classification with PyTorch and `CircuitQNN`\n", + "#### B. Classification with PyTorch and `SamplerQNN`\n", "\n", - "Linking an `CircuitQNN` to PyTorch requires a bit more attention than `OpflowQNN`. Without the correct setup, backpropagation is not possible. \n", + "Linking a `SamplerQNN` to PyTorch requires a bit more attention than `EstimatorQNN`. Without the correct setup, backpropagation is not possible. \n", "\n", "In particular, we must make sure that we are returning a dense array of probabilities in the network's forward pass (`sparse=False`). This parameter is set up to `False` by default, so we just have to make sure that it has not been changed.\n", "\n", "**⚠️ Attention:** \n", - "If we define a custom interpret function ( in the example: `parity`), we must remember to explicitly provide the desired output shape ( in the example: `2`). For more info on the initial parameter setup for `CircuitQNN`, please check out the [official qiskit documentation](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html)." + "If we define a custom interpret function ( in the example: `parity`), we must remember to explicitly provide the desired output shape ( in the example: `2`). For more info on the initial parameter setup for `SamplerQNN`, please check out the [official qiskit documentation](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html)." ] }, { @@ -389,20 +385,18 @@ "# Define quantum circuit of num_qubits = input dim\n", "# Append feature map and ansatz\n", "qc = QuantumCircuit(num_inputs)\n", - "qc.append(feature_map, range(num_inputs))\n", - "qc.append(ansatz, range(num_inputs))\n", + "qc.compose(feature_map, inplace=True)\n", + "qc.compose(ansatz, inplace=True)\n", "\n", - "\n", - "# Define CircuitQNN and initial setup\n", + "# Define SamplerQNN and initial setup\n", "parity = lambda x: \"{:b}\".format(x).count(\"1\") % 2 # optional interpret function\n", "output_shape = 2 # parity = 0, 1\n", - "qnn2 = CircuitQNN(\n", - " qc,\n", + "qnn2 = SamplerQNN(\n", + " circuit=qc,\n", " input_params=feature_map.parameters,\n", " weight_params=ansatz.parameters,\n", " interpret=parity,\n", " output_shape=output_shape,\n", - " quantum_instance=qi,\n", ")\n", "\n", "# Set up PyTorch module\n", @@ -433,24 +427,24 @@ "text": [ "0.6925069093704224\n", "0.6881508231163025\n", - "0.6516684293746948\n", - "0.6485998630523682\n", - "0.6394742727279663\n", - "0.7055229544639587\n", - "0.6669195890426636\n", - "0.6841748952865601\n", - "0.6759487390518188\n", - "0.7435884475708008\n", - "0.6976056694984436\n", - "0.7234093546867371\n", - "0.7342726588249207\n", - "0.6505677700042725\n", - "0.6626021265983582\n", - "0.6289684772491455\n", - "0.624589204788208\n", - "0.6193334460258484\n", - "0.6175348162651062\n", - "0.6172662973403931\n" + "0.6516683101654053\n", + "0.6485998034477234\n", + "0.6394743919372559\n", + "0.7057444453239441\n", + "0.669085681438446\n", + "0.766187310218811\n", + "0.7188469171524048\n", + "0.7919709086418152\n", + "0.7598814964294434\n", + "0.7028256058692932\n", + "0.7486447095870972\n", + "0.6890242695808411\n", + "0.7760348916053772\n", + "0.7892935276031494\n", + "0.7556288242340088\n", + "0.7058126330375671\n", + "0.7203161716461182\n", + "0.7030722498893738\n" ] } ], @@ -486,12 +480,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.75\n" + "Accuracy: 0.5\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -539,7 +533,7 @@ "source": [ "### 2. Regression \n", "\n", - "We use a model based on the `TwoLayerQNN` to also illustrate how to perform a regression task. The chosen dataset in this case is randomly generated following a sine wave. " + "We use a model based on the `EstimatorQNN` to also illustrate how to perform a regression task. The chosen dataset in this case is randomly generated following a sine wave. " ] }, { @@ -550,7 +544,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -581,7 +575,7 @@ "id": "protected-genre", "metadata": {}, "source": [ - "#### A. Regression with PyTorch and `OpflowQNN`" + "#### A. Regression with PyTorch and `EstimatorQNN`" ] }, { @@ -589,7 +583,7 @@ "id": "lovely-semiconductor", "metadata": {}, "source": [ - "The network definition and training loop will be analogous to those of the classification task using `TwoLayerQNN`. In this case, we define our own feature map and ansatz, instead of using the default values." + "The network definition and training loop will be analogous to those of the classification task using `EstimatorQNN`. In this case, we define our own feature map and ansatz, but let's do it a little different." ] }, { @@ -597,22 +591,7 @@ "execution_count": 12, "id": "brazilian-adapter", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ComposedOp([\n", - " OperatorMeasurement(1.0 * Z),\n", - " CircuitStateFn(\n", - " ┌───────┐┌───────┐\n", - " q: ┤ fm(x) ├┤ vf(y) ├\n", - " └───────┘└───────┘\n", - " )\n", - "])\n" - ] - } - ], + "outputs": [], "source": [ "# Construct simple feature map\n", "param_x = Parameter(\"x\")\n", @@ -624,9 +603,12 @@ "ansatz = QuantumCircuit(1, name=\"vf\")\n", "ansatz.ry(param_y, 0)\n", "\n", + "qc = QuantumCircuit(1)\n", + "qc.compose(feature_map, inplace=True)\n", + "qc.compose(ansatz, inplace=True)\n", + "\n", "# Construct QNN\n", - "qnn3 = TwoLayerQNN(1, feature_map, ansatz, quantum_instance=qi)\n", - "print(qnn3.operator)\n", + "qnn3 = EstimatorQNN(circuit=qc, input_params=[param_x], weight_params=[param_y])\n", "\n", "# Set up PyTorch module\n", "# Reminder: If we don't explicitly declare the initial weights\n", @@ -702,7 +684,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -791,78 +773,7 @@ "execution_count": 16, "id": "worthy-charlotte", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "3.6%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.0%\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.0%\n", - "35.8%" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n", - "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100.0%\n", - "100.0%\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n", - "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# Train Dataset\n", "# -------------\n", @@ -905,7 +816,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -975,7 +886,7 @@ "id": "super-tokyo", "metadata": {}, "source": [ - "This second step shows the power of the `TorchConnector`. After defining our quantum neural network layer (in this case, a `TwoLayerQNN`), we can embed it into a layer in our torch `Module` by initializing a torch connector as `TorchConnector(qnn)`.\n", + "This second step shows the power of the `TorchConnector`. After defining our quantum neural network layer (in this case, a `EstimatorQNN`), we can embed it into a layer in our torch `Module` by initializing a torch connector as `TorchConnector(qnn)`.\n", "\n", "**⚠️ Attention:**\n", "In order to have an adequate gradient backpropagation in hybrid models, we MUST set the initial parameter `input_gradients` to TRUE during the qnn initialization." @@ -986,43 +897,27 @@ "execution_count": 19, "id": "urban-purse", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ComposedOp([\n", - " OperatorMeasurement(1.0 * ZZ),\n", - " CircuitStateFn(\n", - " ┌──────────────────────────┐┌──────────────────────────────────────┐\n", - " q_0: ┤0 ├┤0 ├\n", - " │ ZZFeatureMap(x[0],x[1]) ││ RealAmplitudes(θ[0],θ[1],θ[2],θ[3]) │\n", - " q_1: ┤1 ├┤1 ├\n", - " └──────────────────────────┘└──────────────────────────────────────┘\n", - " )\n", - "])\n" - ] - } - ], + "outputs": [], "source": [ "# Define and create QNN\n", "def create_qnn():\n", " feature_map = ZZFeatureMap(2)\n", " ansatz = RealAmplitudes(2, reps=1)\n", + " qc = QuantumCircuit(2)\n", + " qc.compose(feature_map, inplace=True)\n", + " qc.compose(ansatz, inplace=True)\n", + " \n", " # REMEMBER TO SET input_gradients=True FOR ENABLING HYBRID GRADIENT BACKPROP\n", - " qnn = TwoLayerQNN(\n", - " 2,\n", - " feature_map,\n", - " ansatz,\n", + " qnn = EstimatorQNN(\n", + " circuit=qc,\n", + " input_params=feature_map.parameters,\n", + " weight_params=ansatz.parameters,\n", " input_gradients=True,\n", - " exp_val=AerPauliExpectation(),\n", - " quantum_instance=qi,\n", " )\n", " return qnn\n", "\n", "\n", - "qnn4 = create_qnn()\n", - "print(qnn4.operator)" + "qnn4 = create_qnn()" ] }, { @@ -1128,7 +1023,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1256,7 +1151,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1311,7 +1206,7 @@ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0.dev0+4749eb5
qiskit-aer0.11.0
qiskit-nature0.5.0
qiskit-finance0.4.0
qiskit-optimization0.5.0
qiskit-machine-learning0.5.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Mar 28 2022 06:16:26
OSDarwin
CPUs2
Memory (Gb)12.0
Thu Sep 15 14:04:43 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Sat Oct 29 00:40:42 2022 GMT Daylight Time
" ], "text/plain": [ "" @@ -1357,7 +1252,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.7.9" }, "toc": { "base_numbering": 1, From 7dabe68e0bc7563d31885988b579e22d6e7af1af Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Sat, 29 Oct 2022 11:03:26 +0100 Subject: [PATCH 91/96] update 05 --- docs/tutorials/05_torch_connector.ipynb | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/tutorials/05_torch_connector.ipynb b/docs/tutorials/05_torch_connector.ipynb index ec29941ff..ca49107a3 100644 --- a/docs/tutorials/05_torch_connector.ipynb +++ b/docs/tutorials/05_torch_connector.ipynb @@ -175,7 +175,9 @@ ], "source": [ "# Setup QNN\n", - "qnn1 = EstimatorQNN(circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters)\n", + "qnn1 = EstimatorQNN(\n", + " circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters\n", + ")\n", "\n", "# Set up PyTorch module\n", "# Note: If we don't explicitly declare the initial weights\n", @@ -906,7 +908,7 @@ " qc = QuantumCircuit(2)\n", " qc.compose(feature_map, inplace=True)\n", " qc.compose(ansatz, inplace=True)\n", - " \n", + "\n", " # REMEMBER TO SET input_gradients=True FOR ENABLING HYBRID GRADIENT BACKPROP\n", " qnn = EstimatorQNN(\n", " circuit=qc,\n", From d121e9ea92401b05e7067239cac7d5e5a94429d3 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Sun, 30 Oct 2022 14:46:41 +0000 Subject: [PATCH 92/96] update 09 --- .../09_saving_and_loading_models.ipynb | 109 ++++++++---------- 1 file changed, 50 insertions(+), 59 deletions(-) diff --git a/docs/tutorials/09_saving_and_loading_models.ipynb b/docs/tutorials/09_saving_and_loading_models.ipynb index e5f32c4fd..b9232b8fe 100644 --- a/docs/tutorials/09_saving_and_loading_models.ipynb +++ b/docs/tutorials/09_saving_and_loading_models.ipynb @@ -28,17 +28,17 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "exposed-cholesterol", "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "from qiskit_aer import Aer\n", "from qiskit.algorithms.optimizers import COBYLA\n", "from qiskit.circuit.library import RealAmplitudes\n", - "from qiskit.utils import QuantumInstance, algorithm_globals\n", + "from qiskit.primitives import Sampler\n", + "from qiskit.utils import algorithm_globals\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import OneHotEncoder, MinMaxScaler\n", "\n", @@ -54,28 +54,19 @@ "id": "rural-mileage", "metadata": {}, "source": [ - "We will be using two quantum simulators. We'll start training on the QASM simulator then will resume training on the statevector simulator. The approach shown in this tutorial can be used to train a model on a real hardware available on the cloud and then re-use the model for inference on a local simulator." + "We will be using two quantum simulators, in particular, two instances of the `Sampler` primitive. We'll start training on the first one, then will resume training on the second one. The approach shown in this tutorial can be used to train a model on a real hardware available on the cloud and then re-use the model for inference on a local simulator." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "charming-seating", "metadata": {}, "outputs": [], "source": [ - "qi_qasm = QuantumInstance(\n", - " Aer.get_backend(\"aer_simulator\"),\n", - " shots=1024,\n", - " seed_simulator=algorithm_globals.random_seed,\n", - " seed_transpiler=algorithm_globals.random_seed,\n", - ")\n", + "sampler1 = Sampler()\n", "\n", - "qi_sv = QuantumInstance(\n", - " Aer.get_backend(\"aer_simulator_statevector\"),\n", - " seed_simulator=algorithm_globals.random_seed,\n", - " seed_transpiler=algorithm_globals.random_seed,\n", - ")" + "sampler2 = Sampler()" ] }, { @@ -90,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "ceramic-florida", "metadata": {}, "outputs": [], @@ -111,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "dirty-director", "metadata": {}, "outputs": [ @@ -121,7 +112,7 @@ "(40, 2)" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -141,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "thorough-script", "metadata": {}, "outputs": [ @@ -155,7 +146,7 @@ " [0.10351936, 0.45754615]])" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -174,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "understood-ukraine", "metadata": {}, "outputs": [ @@ -184,7 +175,7 @@ "(40, 2)" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -204,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "german-agreement", "metadata": {}, "outputs": [ @@ -218,7 +209,7 @@ " [1., 0.]])" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -237,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "about-ordinary", "metadata": {}, "outputs": [ @@ -247,7 +238,7 @@ "(30, 2)" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -269,13 +260,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "fifty-scottish", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -355,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "brief-lending", "metadata": {}, "outputs": [], @@ -373,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "integrated-palestinian", "metadata": {}, "outputs": [], @@ -391,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "periodic-apparel", "metadata": {}, "outputs": [], @@ -433,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "electronic-impact", "metadata": {}, "outputs": [], @@ -449,18 +440,18 @@ "id": "separated-classroom", "metadata": {}, "source": [ - "We create a model and set a quantum instance to the QASM simulator we created earlier." + "We create a model and set a sampler to the first sampler we created earlier." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "id": "revolutionary-freeze", "metadata": {}, "outputs": [], "source": [ "original_classifier = VQC(\n", - " ansatz=ansatz, optimizer=original_optimizer, callback=callback_graph, quantum_instance=qi_qasm\n", + " ansatz=ansatz, optimizer=original_optimizer, callback=callback_graph, sampler=sampler1\n", ")" ] }, @@ -474,13 +465,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "suited-appointment", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -493,10 +484,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -515,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "id": "greek-memphis", "metadata": {}, "outputs": [ @@ -524,7 +515,7 @@ "output_type": "stream", "text": [ "Train score 0.8\n", - "Test score 0.8\n" + "Test score 0.9\n" ] } ], @@ -543,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "id": "broadband-interview", "metadata": {}, "outputs": [], @@ -563,7 +554,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "id": "steady-europe", "metadata": {}, "outputs": [], @@ -581,13 +572,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "accessible-cowboy", "metadata": {}, "outputs": [], "source": [ "loaded_classifier.warm_start = True\n", - "loaded_classifier.neural_network.quantum_instance = qi_sv\n", + "loaded_classifier.neural_network.sampelr = sampler2\n", "loaded_classifier.optimizer = COBYLA(maxiter=80)" ] }, @@ -601,7 +592,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "metric-cyprus", "metadata": { "nbsphinx-thumbnail": { @@ -611,7 +602,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtAAAAGDCAYAAAACpSdYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAAsTAAALEwEAmpwYAABgQElEQVR4nO3deXxcdb3/8dcnkz1tki7pvlJKgZbVsgkCisgiAoqyiXjdcP95vXqvXu+9uHu9Xq9XryBeuO6yCAiyL8oiIiClLAUKhdKF7i1tkqZJJpnl+/vjnJNMkpnJTHImk0nez8djHrOdzPnOpIFPPnl/v19zziEiIiIiIrkpK/YARERERERKiQpoEREREZE8qIAWEREREcmDCmgRERERkTyogBYRERERyYMKaBERERGRPKiAFpGMzOxrZvbbLM+/aGYnF+C8hXrdd5vZJjPbZ2ZHhP36Wc77fjO7f6TOlwsz+6WZfavY48iHmd1jZh8cK+cZZAz7zGy/Yo5BRDJTAS0yjpnZ35nZ82bWYWbbzewqM2vM9eudc0udcw8PcwwDCrkwXjeD7wOfcc5NcM49U4DXx8wWmJkzs/LgMefctc65dxTifOOJc+4M59yvhvMa/r/5R3M9Ty7HD5eZPWxmH+03hgnOuXWFPK+IDJ0KaJFxysy+APwH8I9AA3AsMB/4o5lVFnNsBTQfeLHYg5DxI/UXKREZO1RAi4xDZlYPfB34rHPuXudczDm3ATgfWABcknJ4tZn9zszazOxpMzss5XU2mNnb/dtlZvZlM3vNzHab2Y1mNjnl2BPM7DEza/FjFH9nZpcB7wf+yf+T9R2pr2tms8yss9/rHGFmb5hZhX//w2b2kpk1m9l9ZjY/zfutMrN9QAR4zsxe8x93ZrZ/ynE93XAzO9nMNpvZF8xsp5ltM7MPpRxbY2b/ZWYbzazVzB41sxrgEf+QFv89Hde/i2lmbzazFf7XrTCzN6c897CZfdPM/up/5veb2dQM38eXzOyslPvlZrbLzI7079/k/2Wh1cweMbOlGV5nQJc19bPxP7/vm9nrZrbDzH7qv9d0r7XIzB70/w28YWbXpv5Vw8yONLNn/Pd2k/9vK/jMJ5nZnf57aPZvz+n32Xw0dcz+uJrNbL2ZndHvPa3zz7PevBjNQcBPgeP8701LhvfwsJl9NNPx2T6PlH83XzKz7cAvsr0vM/s28BbgCv8cV6T5/BvM7Nf+1280s381s7JcPgcRKQwV0CLj05uBauCW1Aedc/uAu4FTUx4+B7gJmAxcB/zB/OK1n88C5wInAbOAZuBKAPOK2nuAHwNNwOHAs865q4Frge/5f7J+V7/xbAUeB85Lefhi4GbnXMzMzgG+ArzHf92/ANf3H5hzrss5N8G/e5hzblGmD6afGXjd+dnAR4ArzWyS/9z3gTfhfZaTgX8CksCJ/vON/nt6PPUFzftl4C7gf4ApwA+Au8xsSr/3+CFgGlAJfDHD+K4HLkq5fxrwhnPuaf/+PcBi/3Wexvush+K7wAF437f98T6PyzMca8C/4/0bOAiYC3wNwLy/bNwK/BLvM7seeHfK15YBv8D7S8E8oBO4Isu4jgHWAFOB7wE/M08d3ud7hnNuIt736Fnn3EvAJ4DH/e9NY7Y3neX4wT6PGf77mw9clu19Oef+Be/fbRAt+kyaofwY79/hfng/X5fi/fvI+jlke28iMjwqoEXGp6l4hVY8zXPb/OcDK51zNzvnYnjFXjVe3KO/TwD/4pzb7Jzrwiua3mven7AvBv7knLve73bvds49m+NYr8MvEv2i4EL/seCc/+6ce8l/L98BDrc0XeghigHf8Md8N7APWOJ3/z4MfM45t8U5l3DOPea/78G8E3jVOfcb51zcOXc98DKQ+svDL5xzrzjnOoEb8Qq1dK4DzjazWv/+xaT8AuGc+7lzri3l+3GYmTXk+uah5zO/DPi8c26Pc64N73O+MN3xzrm1zrk/+r+07ML7N3OS//SxQDnwP/5negvwZMrX7nbO/d451+Gf59spX5vORufcNc65BPArYCYw3X8uCSwzsxrn3DbnXCjRnRw/jyTwVf8z6BzC+0o9X8R/7X/2v5cbgP8CPpByWLbPQUQKQAW0yPj0BjDV0uczZ/rPBzYFN5xzSWAzXnexv/nAreZFNFqAl4AE3v/I5wKvDXGsv8f7E/pMvO5uEq9jF5zzRynn3IPXAZ09xHP1t7vfLxkdwAS8XzCqGdp7mgVs7PfYRvqOeXuacw7gnFuL9zm/yy+iz8b/5cLMImb2XfMiNXuBDf6XpY2DZNEE1AIrUz7ne/3HBzCz6WZ2g5lt8c/725RzzgK2OOdcypdsSvnaWjP7Xz+msBcvDtPoF5Hp9HxOzrkO/+YE51w7cAHeL1jbzOwuMzswz/edSS6fxy7nXHQY7yvVVKCCvv9mMv57Sf0c8nhPIpInFdAi49PjQBde9KGHmU0AzgAeSHl4bsrzZcAcYGua19yE9yfzxpRLtXNui/9cptiEy/C496RzzcD9eAXRxcANKQXYJuDj/c5Z45x7LNtrpujAK4YCM3L8ujeAKOnfU9b3g/fZ9e+QzwO25Hju/oIYxznAar+oBu+zOgd4O96f/xf4j6f70347KZ+DmaV+Dm/gRQ6WpnzGDSmRmP6+g/cZHOKcq8fL0wfn3AbM7hcvmJty+wvAEuAY/2uDOEzecQTn3H3OuVPxfiF8GbgmeCrfl+p3P5fPo//XDPa+so3pDby/hKT+mxnOvxcRCYEKaJFxyDnXijeJ8MdmdrqZVZjZAry4wGbgNymHv8nM3uN3q/8er/B+Is3L/hT4dhCfMLMmP6MMXvb27WZ2vnkT3aaY2eH+czvwsp3ZXIeX+3wvvfGN4Jz/bP7kOH+y1fsG/wR6PAtc7HdrTyfHP6v7nfifAz8wb6JjxLzJglXALrwueab3dDdwgJld7H8WFwAHA3fmMe5UNwDvAD5J389mIt73ajdecfydLK/xHLDUzA43s2r8zDL0vNdrgP82s2kAZjbbzE7L8FoT8aIurWY2G2+Vl8DjeH+V+Iz/3s8Bju73tZ14EzAnA1/N9sYz8bvg5/hZ6C5/PEn/6R3AHMt9pZk+xw/h84DB31fGnwE/lnEj3s/WRP/n6x/wOvsiUiQqoEXGKefc9/Am4H0f2Av8Da+je0q/LO9teN3fZrzc5Xv8PHR/PwJuB+43sza8IvsY/1yvA2fideL24BWuwWoePwMO9v8c/ocMw70dbzLcdufccynv4Va8pfhu8P80/gJeBz1Xn8PLHrfgrQaS6fzpfBF4HliB957+Ayjz/4T+beCv/nvqkxd3zu0GzsL7LHbjTT48yzmXGpvJmXNuG15h+mbgdylP/RrvT/1bgNWk/6UneI1XgG8AfwJeBfqve/wlYC3whP85/wmvo5rO14EjgVa8yZI9E1Wdc914f/X4CN5nfgneLw7Bv7cfAjV4Xdcn8KIRQ1GGV2RuxfvenIT3CwbAg3hLGW43s1w+83TH5/N5wODv60d48wWazex/0nz9Z/H+SrAO73tzHd4vcCJSJNY3iiYikjszex24xDn3yKAHi6RhZn8Dfuqc+0WxxyIikit1oEVkSMysCW/i1IYiD0VKiJmdZGYz/AjHB4FDGXqnWUSkKLRDkojkzcyOAv4I/NiPZ4jkagleprcOL5LwXj+GIiJSMhThEBERERHJgyIcIiIiIiJ5UAEtIiIiIpKHkstAT5061S1YsKDYwxARERGRMW7lypVvOOcG7LxacgX0ggULeOqpp4o9DBEREREZ48xsY7rHFeEQEREREcmDCmgRERERkTyogBYRERERyYMKaBERERGRPKiAFhERERHJgwpoEREREZE8qIAWEREREcmDCmgRERERkTyogBYRERERyYMKaBERERGRPKiAFhERERHJgwpo8bS+BM4VexQiIiIio54KaIHW1XDXwbDr0WKPRERERGTUUwEtEN3lX+8o7jhERERESoAKaIFE1L/uLO44REREREqACmiBZJd3rQJaREREZFAqoKW3Ax3vKO44REREREqACmhRhENEREQkDyqgRREOERERkTyogBZ1oEVERETyoAJalIEWERERyYMKaFEHWkRERCQPKqBFGWgRERGRPKiAFnWgRURERPKgAlqUgRYRERHJgwpogaQ60CIiIiK5UgEtkFAGWkRERCRXKqBFGWgRERGRPKiAFmWgRURERPKgAlq0jJ2IiIhIHlRAiyIcIiIiInlQAS2KcIiIiIjkQQW09C5j5+KQjBd3LCIiIiKjnApo6V3GDhTjEBERERmECmjpjXCACmgRERGRQaiAFi/CUVbp3VYOWkRERCQrFdDiRTgqJ/m31YEWERERyUYFtHgRDhXQIiIiIjlRAT3eOedtpKICWkRERCQnKqDHu2AXwqCAVgZ6TNm7ZS/OuWIPQ0REZExRAT3eJfoV0OpAjxnN65r577n/zeuPvl7soYiIiIwpKqDHu2AJOxXQY86+HfvAwb5t+4o9FBERkTFFBfR4l+xXQCvCMWYkuhIAxKPaXVJERCRMKqDHO3Wgx6ygcFYBLSIiEi4V0ONdkIGuaPTvq4AeK+Jd8T7XIiIiEg4V0OOdOtBjliIcIiIihaECerwLMtAVE8HKlYEeQ3o60CqgRUREQqUCerwLIhxlVRCpUQd6DFEGWkREpDAKVkCb2c/NbKeZvZDh+feb2Soze97MHjOzwwo1FskiiHBEqqFcBfRYEkQ4gmsREREJRyE70L8ETs/y/HrgJOfcIcA3gasLOBbJJJlSQEdqVUCPIYpwiIiIFEZ5oV7YOfeImS3I8vxjKXefAOYUaiySRWoHOlKjDPQYokmEIiIihTFaMtAfAe7J9KSZXWZmT5nZU7t27RrBYY0DykCPWUHhrAiHiIhIuIpeQJvZW/EK6C9lOsY5d7VzbrlzbnlTU9PIDW486JOBVoRjLFGEQ0REpDAKFuHIhZkdCvwfcIZzbncxxzJuJftFOGJtxR2PhEYRDhERkcIoWgfazOYBtwAfcM69UqxxjHtBB1oRjjFHOxGKiIgURsE60GZ2PXAyMNXMNgNfBSoAnHM/BS4HpgA/MTOAuHNueaHGIxkkugCDsgoV0GNMIqoOtIiISCEUchWOiwZ5/qPARwt1fslRMurFN8yUgR5jlIEWEREpjKJPIpQiS/gFNPgdaC1jN1ZoIxUREZHCUAE93iW6vPwz+OtAqwM9VqgDLSIiUhgqoMe7AR3oTnCuuGOSUASFswpoERGRcKmAHu+SKQV0eS3gINld1CFJOLSMnYiISGGogB7v+negQTnoMULL2ImIiBSGCujxrn8GGpSDHiPUgRYRESkMFdDjXTJdB1oF9FgQFM6JrgROuXYREZHQqIAe7xL9M9CogB4jUqMbiW4tZSciIhIWFdDjXSKaJsKhDPRYkLr+s2IcIiIi4VEBPd4luxThGKPiXXEsYt5tFdAiIiKhUQE93qVdhUMF9FgQj8apqvf+uqDdCEVERMKjAnq8S5uBVoRjLEh0Jahu9L636kCLiIiERwX0eKdl7MakZDyJSzqqG1RAi4iIhE0F9HinZezGpGAFjqqGqj73RUREZPhUQI9nzmkZuzEq6DgHGWh1oEVERMKjAno8S3Z719rKe8wJJg0qAy0iIhI+FdDjWbLLu+7JQPuFtDLQJW9AhEMFtIiISGhUQI9niah3HRTOVuYV04pwlLygA61l7ERERMKnAno8619Ag5eDVgFd8oKOs1bhEBERCZ8K6PEsEUQ4UgroSI0y0GOAIhwiIiKFowJ6PEsGHeiq3sciNcpAjwE9kwiDDrSWsRMREQmNCujxLF2EI1KjCMcYoA60iIhI4aiAHs8yZqAV4Sh1AzrQKqBFRERCowJ6POu/jB2oAz1GBAVz5YRKMK3CISIiEiYV0ONZpgiHMtAlL4hwlFeXU15drg60iIhIiFRAj2fKQI9ZQcc5UhVRAS0iIhIyFdDjWVBAlykDPdb0dKCryimvUgEtIiISJhXQ41mQge6/jJ060CUvKJiDCIcy0CIiIuFRAT2eKQM9ZinCISIiUjgqoMczZaDHrNQIR6QqogJaREQkRCqgx7Nkmq28y2u9x5P6k38pS3QlKCsvw8rM60BrJ0IREZHQqIAez3omEVb0Phap8a6Dbb6lJMWjccqrywEU4RAREQmZCujxLBH14htmvY8FBbRy0CUt3hUnUhUB0CocIiIiIVMBPZ4lon3jG+BFOEBL2ZW4RFeC8qreDrRW4RAREQmPCujxLNnVdwk76O1AayJhSUt0JXo70IpwiIiIhEoF9HgWRDhSqYAeE5SBFhERKRwV0ONZtgJaGeiSFu+K90Q4IlURrcIhIiISIhXQw5WMgXPFHsXQKAM9ZinCISIiUjgqoIfrvmPg8UtLs4hWBnrMSu1Aq4AWEREJlwro4Wp7BTb8FjZeX+yR5E8Z6DErNQMd7EToSvGXPBERkVFIBfRwuCTE273bKz4F7ZuKO558pYtwKAM9JvSPcOAgGU8WeVQiIiJjgwro4Yjv8673/wS4ODzxIa+oLhXJroEdaGWgx4T+EQ5AMQ4REZGQqIAejlibdz3pcDjyv2HHA7Dmx0UdUl4SUWWgx6g+HegqFdAiIiJhUgE9HEEBXTERFn0UZp0Fz34JWlcXd1y5yhbhUAFd0vqvAw1oN0IREZGQ5FRAm9l8M3u7f7vGzCYWdlglIu4X0OUTwQyO+T+vmH7sEkh0F3dsuUg3ibCsEjBloEtcvCveNwONOtAiIiJhGbSANrOPATcD/+s/NAf4QwHHVDpSO9AANdPh6Gug+Rl44evFG1eu0i1jZ+bloJWBLmmJrkSfjVRABbSIiEhYculAfxo4HtgL4Jx7FZhWyEGVjHi/Ahpg7rmw34dh9Xdh12NFGVbO0nWgwYtxKMJR0tJ2oLUboYiISChyKaC7nHM9eQQzKwe0oCz0dqDL+yVa3vRDqJ0Lz/zjiA8pZ86lz0CDCugS55KOZCw5IAOtDrSIiEg4cimg/2xmXwFqzOxU4CbgjsIOq0Sk60AH92eeAXtfHvkx5SoZA1zmDnRcEY5SFXSatYydiIhIYeRSQH8Z2AU8D3wcuBv410IOqmRk6kAD1M2D7j0Q2zeyY8pVssu77p+BBj8DrQ50qQpW2+i/jJ1W4RAREQlH+WAHOOeSwDX+RVLF2gCD8rqBz9XN9647XoeGg0d0WDlJRL1rRTjGHHWgRURECmvQAtrM1pMm8+yc268gIyol8TYon+CtXNFfUEC3bxzdBbQmEY45QaGsDLSIiEhhDFpAA8tTblcD7wMmF2Y4JSbWBhX16Z+rneddt78+cuPJR0+EI10BXQvdzSM7HglN/wiHlrETEREJ16AZaOfc7pTLFufcD4F3Fn5oJSDeNnACYaBmFli514EejXo60Oky0OpAl7KMEQ4tYyciIhKKXCIcR6bcLcPrSOfSuR77Ym3pJxAClEWgds7oL6CVgR5zBkwiVIRDREQkVLkUwv+VcjsObADOL8hoSk22DjR4K3F0jNIIhzLQY9aADHSVCmgREZEw5bIKx1uH8sJm9nPgLGCnc25ZmucN+BFwJtAB/J1z7umhnKtoYm0wYWrm52vnw86HR2w4ecm2jF2kVutAl7D+EY6gE61l7ERERMKRsYA2s3/I9oXOuR8M8tq/BK4Afp3h+TOAxf7lGOAq/7p0ZItwgLcSR+cWb9OSsoqRG1cuskU4lIEuaf0jHGZGpCqiDrSIiEhIsk0inDjIJSvn3CPAniyHnAP82nmeABrNbGauAx8VcolwuCR0bh25MeVqsAiHS/i7FUqp6d+BDm6rgBYREQlHxg60c+7rBT73bGBTyv3N/mPb+h9oZpcBlwHMmzevwMPKQy4daPAmEga3R4usy9jVeNfxDqhsGLkxSSj6Z6CD21qFQ0REJBy5rMJRDXwEWIq3DjQAzrkPF3BcfTjnrgauBli+fPmATV2KItHtFaFZO9ApBfRok3UZu1r/mE5ABXSp6R/hAK+ATkSVgRYREQnDoOtAA78BZgCnAX8G5gBtIZx7CzA35f4c/7HSEPc/gmwd6Fr/7Y3GzVQGW8YOlIMuUWkjHNWKcIiIiIQllwJ6f+fcvwHtzrlf4W2iEsZkv9uBS81zLNDqnBsQ3xi1Yn4Bna0DXV4LVU2jvAOtAnqsSdeBjlRFFOEQEREJSS4FdDCTrMXMluH9TX/aYF9kZtcDjwNLzGyzmX3EzD5hZp/wD7kbWAesBa4BPpX36IspnkMBDV6MYzgFdDIG9x0HW+8b+mukfd0cM9BScjJmoNWBFhERCUUuG6lcbWaTgH/D6xpP8G9n5Zy7aJDnHfDpXAY5KsVyiHCAtxJH6+qhnye6C3Y/AVtug1mnDf11+uuJcFQOfK5PBlpKjSIcIiIihZVLAf0L51wCL/+8X4HHUzpyiXCAt5nK1nvAOTAbwnlavOuWVfl/bTaJKJRVpR+TIhwlLdGVwMqMsvLePzCVV5XT3d5dxFGJiIiMHblEONab2dVmdoq/e6BAbpMIwYtwJDqh642hnae7xbtuXuWtKR2WRDR9fANUQJe4eFe8T/4Z/FU4tBOhiIhIKHIpoA8E/oQXt9hgZleY2QmFHVYJyLUDXeevW90xxJU4ggI63hbuZMRkV/ol7EAZ6BIXj8b75J9BEQ4REZEwDVpAO+c6nHM3OufeAxwO1OPFOca3fDrQMPTiN4hwADQ/N7TXSCcRTb+EHSgDXeISXYk++WdAW3mLiIiEKJcONGZ2kpn9BFiJt5nK+QUdVSnIuQM9zAI66EBDuDloRTjGrERXIm2EQ8vYiYiIhCOXnQg3AM8ANwL/6JxrL/SgSkK8DcoqMscgApWTobxu6JupBB3o2rnQEmIHOtmlAnqMinfFB3SgFeEQEREJTy6rcBzqnNtb8JGUmljb4PEN8Fa5qJ03vA50pBqmHA3Nzw7tNdIJVuFIRxnokpYuA60Ih4iISHhyyUCreE4n1jZ4fCMwnM1UulugohEaD4N9r0Fs39Bep79sEY6ycq+7rg50ScoU4dAqHCIiIuHIKQMtacRz7ECDV0APdRWOWAtUNsKkQ737Lc8P7XX6y1ZAg9eFVgFdkjJFOJLxJMl4iEshioiIjFMqoIcqrw70PG8d6PgQ4uOpHWgIbyJhtgw0eAW0IhwlKVMHGtBEQhERkRDkMomwCjgPWJB6vHPuG4UbVgmIt3mFbS5qg5U4XoeGg/I7T6zVm4hYNx8q6sObSJgtAw0QqVUHukTFo3GqJ/X95SjoSMejcSrr0mzfLiIiIjnLpQN9G3AOEAfaUy7jW74ZaBjaShzdLV6EwwwaDw1vLejBIhzlinCUqkwRDkA5aBERkRDksgrHHOfc6QUfSamJt3kd4Vz07EY4hImEsZbeTnfjYbD+196W3jbM9E1SGeixKmuEQytxiIiIDFsuVdhjZnZIwUdSanJdxg6gZhZYJP+VOJzr7UCDN5Ew3gbtG/J7nXQSXYNEOJSBLlXpOtBBQa0CWkREZPhyKaBPAFaa2RozW2Vmz5tZiFvilSDn/A50jgV0WTnUzsk/wpGIQrK7t4AOJhI2h/DxD7oKhzLQpSoejROp1iRCERGRQsklwnFGwUdRahKdXowi1wIahraZSrALYUWDd924DDBvIuHcc/N7rf4Gi3CU10B0+/DOIUWR6EpkzECrAy0iIjJ8uWykshFoBN7lXxr9x8avWJt3nWuEA4a2mUp3i3cdZKDL62Di/sOfSJiMe78AKAM9JsW74gMz0FUqoEVERMIyaAFtZp8DrgWm+ZffmtlnCz2wUS3uF9D5dKDr5kPnFq94zVVQQAcRDvBiHMNdCzoR9a6VgR5znHNZO9BahUNERGT4cslAfwQ4xjl3uXPucuBY4GOFHdYoN6QO9DxwCejcmsd5WrzrPgX0of6W3m25v05/QQGtDPSYk+j2CuSgYA4owiEiIhKeXApoA1LbVgn/sfErtte7zisDHawFnUeMo3+EA2BSsCPhC7m/Tn/JHAporQNdkoIOs5axExERKZxcJhH+Avibmd3q3z8X+FnBRlQK4kPMQEN+K3Fk6kCDN5Gw6bjcXytVosu7ziUD7Zy3iYuUhGCVjYzL2GkVDhERkWEbtIB2zv3AzB7GW84O4EPOuWcKOqrRLjaUDPRc7zqfzVTSZaDr5nurcgwnB51rBjo4trxm6OeSEaUOtIiISOFlLKDNrN45t9fMJgMb/Evw3GTn3J7CD2+UGsokwvI6qJqaX4Qj1uoVuamd4jC29M4lwhGp9a4TnSqgS0hQICsDLSIiUjjZOtDXAWcBKwGX8rj59/cr4LhGt6FMIgR/Kbs8IhypuxCmajwU1v9q6Ft65zKJMCialYMuKZkiHFrGTkREJDwZC2jn3Fn+9cKRG06J6CmgJ+T3dbXzYO/LuR+fqYCedBi8us/b0nvCEH6PCTLQuUQ4tJRdSckU4Qjuaxk7ERGR4ctlHegHcnlsXIm3eRGHssjgx6YKNlNxbvBjwZtEmLoCR6BnS+8hxjhyXcYO1IEuMZk60GWRMsoqytSBFhERCUHGAtrMqv3881Qzm2Rmk/3LAmD2iI1wNIq15Zd/DtTNh0QHdOcYH88Y4ViKt6X3ECcS5pSBVoSjFGXKQINXVKuAFhERGb5sGeiPA38PzMLLQQdrme0FrijssEa5eFv++WfwNlMBrwtdNWXw42MtvcvfpSqvg4mLh9GBzmEZO2WgS1KmCAd4RbWWsRMRERm+bBnoHwE/MrPPOud+PIJjGv2G04EGr4CefOTgx2fqQIO/EsfT+Y8B8lvGThnonDjncElHWWQIkzpDlCnCAX4BrQ60iIjIsOXyf/ukmTUGd/w4x6cKN6QSEB9iAV2b52Yq3S3pM9DgTSTct25oW3rnu4ydDOq5Xz/HD2b9oGcr7WLJ1oGOVEVIRDWJUEREZLhyKaA/5pxrCe4455qBjxVsRKUgNsQIR9UUr7Oby1rQiSgku7J0oIMtvZ/Pfxw5TSJUhCMfa+9ZS/vOdjqbi/t5Zc1AK8IhIiISilwK6IhZ717OZhYBKgs3pBIw1AiHmRfjyGU3wnS7EKaaFGzpPYSJhHlloBXhyMXWp7YC0NXaVdRxKMIhIiJSeLkU0PcCvzOzU8zsFOB6/7Hxa6iTCCH3zVSCAjpThKN2nrel94br8tvdEFIy0Fl+D+rJQKsDPZjOPZ00v9YMQNfe4hbQg04iVAEtIiIybLkU0F8CHgI+6V8eAP6pkIMa9YbagQav8M2l4I21eNeZOtBmsOxy2P03uGMxrPgUdGzJbQzJqFc8Z9vFUBnonAXdZ4Boa7SIIxmkA11Vro1UREREQjBoAe2cSzrnrnLOvde//K9zbvz+XziZ8GINQ+5Az4OuXYN3drtbvetMHWiAg/4Bzn4N9vsIvPZ/cPsiWPn30Lk9+2snurLHN6D3eRXQg9qyovcXl6JHOAbLQKsDLSIiMmy57ER4vJn90cxeMbN1ZrbezNaNxOBGpfg+73qoHeiaWd51dEf24wbrQAdq58DRV8FZr8CC98MrV8Dt+8ErV2b+mkQ0+xJ24HW4I9XKQOdg21PbqKitAEZPhKOsYuCPtgpoERGRcOQS4fgZ8APgBOAoYLl/PT7F/WXjhlxAz/SuO7dlP26wSYT9TVgAx/4MznrZWyP6+a9nPjYZHbwDDV4OWhnoQW1ZsYX5J3pLFI6GCEekKkLKvN8ekaqICmgREZEQ5FJAtzrn7nHO7XTO7Q4uBR/ZaBWsu1xeP7Svr57hXUcHKaCDDnS2CEc6E/eHWWd4MZFEd/pjErkW0LWKcAyibVsbbVvaWHjKQqD4EY5EVyJt/hm0jJ2IiEhYsm3lHXjIzP4TuAXoqQ6cc0PcBq/ExUawA11WkVuhO+Acs73r6Pbe7cNT5ZKBBq8DrQI6q60rvAmEc46bQ0VtRdEjHPFoPG3+GRThEBERCUsuBfQx/vXylMcc8Lbwh1MChhvhqGryVr8YbKJfsAthmj/FDyrIWXduzVBA55CBBm8taGWgs9qyYgsWMWYeMZOq+qqiRzgSXYm0S9iBIhwiIiJhGbSAds69dSQGUjJ6IhxDLKDLIlA1LbcIR6755/5q/Q50pmXtlIEe1K6XdlE7tZa6prqsx217ahvTlk6joraCqoaqokc44l3xrBEOLWMnIiIyfIMW0GZ2ebrHnXPfCH84JWC4HWjwYhy5RDjyzT/3vH5KBzqdRBTKsxeGwLjOQF9/1vVMP3Q6F9x6QcZjnHNsWbGFJecsAaC6obroEY5sHejy6nIS3Qlc0mFlQ/jLhoiIiAC5RTjaU25XA2cBLxVmOCUgtte7HmoHGnIvoIfaga6a4uWnOzN0oBNdUDll8NeJ1HiTEcehtm1t7N28l2hLlOrG9N36lg0tdO7uZPZRXse/qn4UdKCzZaD9znS8K05FTcVIDktERGRMyWUjlf9KuXwbOBnYr+AjG62GO4kQvAI6OkgGejgRDivzutAdGTrQyShElIHOJN4VJ94ZJ9GdYM3tazIeF0wgnHWU1/Gvaih+BnqwCAegGIeIiMgw5bKMXX+1wJywB1Iy4m1egRqpGfprVM/wNlJJZilkhhPhAK+AzhbhyHUZu3GYgY629BbBL/7uxYzHbX1qK5HKCNMPmQ4wKjLQg0U4AE0kFBERGaZcMtDP4626ARABmoDxmX8GrwNdPnFoq2MEamaCS3rxiJoZGc7TOvQONHhL2bW+kP45LWOXVbTZK6Dr59bz2v2v0dncSc2kgb8wbV2xlemHTSdS6RWsVfVVRc9Ax7vi1E6oTfucCmgREZFwZOxAm9lC/+ZZwLv8yzuAWc65K0ZgbKNTvG148Q0YfC3oRJdXuA6rgM7SgU7muIxdZHxGOIIO9JEfPZJkPMnLt7484BiXdGxdubUnvgHeJMLufd0kE8kRG2t/2TLQQWdaBbSIiMjwZItw3Oxf/9w5t9G/bHHOje//+wYd6OGo9gvoTDnoWKt3PZwIR+1sb8JjbN/A53KNcJSPzw50Z7P3nvc7dT8aFzby4o0DYxxvrHmD7rbungmE4EU4gKJ2oXOKcGg3QhERkWHJFuEoM7OvAAeY2T/0f9I594PCDWsUi4XRgfZjG5k60N0t3vVwO9DgdaErDuj7XD4Z6GTMy2qXpS/KxqIgwlEzqYal5y/lse8/RsfuDmqn9EYjtj7VdwIheB1o8ArodJGPkZDLJEJ1oEVERIYnWwf6QiCBV2RPTHMZn+IhdKAHi3AEBfRwJxHCwKXsknFwCSjLMQMN464LHUQ4qidVs/T8pbiE46Vb+q7cuHXFVirqKph64NSex6rq/Q50EScSZu1AV6mAFhERCUPGDrRzbg3wH2a2yjl3zwiOaXSLtUH19OG9RqTaK44zFdCxFu+6smHo5+jZjbBfDjrpF3e5LGPXU0B3QMWEoY+lxAQRjurGauqm1TF5/8msvnE1b/rYm3qO2bpiKzOPnElZpPd30CDCUcyl7OJdWdaB1jJ2IiIiochlHWgVz6nC6EBD9rWgQ+1A9yugE35xl2sGGsZfB7o5SnlNOeVV5ZgZB59/MOsfXE/7Tm9PoUQswfZnt/eJb0DfCEexxKNxLWMnIiJSYENZB3p8CyMDDV4OetAOdOPQX79iolfo949w5FNAR/zM7zhbCzraEu2TYV52wTJcsjfGsfOFncSj8T4TCGH0RDgyZaC1CoeIiEg4VEDnK4xl7MBbiaOQkwgBatMsZRdEOJSBzijaHKV6Uu/nM+2QaUxZMqVnU5WeCYTL+3agix3hSMaTuKTTKhwiIiIFNmgBbWa1ZvZvZnaNf3+xmZ1V+KGNQokub1WK0CIc28C5gc91t4CV93aAh3yOWdCRqQOdZwZ6HIm2RKlu7C2gzYylFyxlw583sG/7Prau2Er1pGomLZrU5+uKHeEICuPBMtDqQIuIiAxPLh3oXwBdwHH+/S3Atwo2otEs1uZdhxXhSES9tZoHnKfF6z4PZ7dD8HYjVAY6b+l2Hlx6/lJwsPrm1WxdsZVZy2dh/b4/5TXlWMSKFuEICmMtYyciIlJYuRTQi5xz3wNiAM65DiCnys7MTjezNWa21sy+nOb5eWb2kJk9Y2arzOzMvEY/0uJ+AR1GB7o6y1J23S3Dm0AYCHYjTO1yJ/KJcIzTDHS/CAfAtKXTaFraxHO/eo6dL+wcMIEQvE51dUN10SIcweoagy1jp1U4REREhieXArrbzGoAB2Bmi/A60lmZWQS4EjgDOBi4yMwO7nfYvwI3OueOwFt3+id5jH3khdqBDnYjTFNAx1qHn38Gbym7ZDd07e59LJnPJEJFOFItvWApW5/aSjKeHDCBMFDVUEX33u5CDzGtngiHOtAiIiIFlUsB/TXgXmCumV0LPAD8Uw5fdzSw1jm3zjnXDdwAnNPvGAfU+7cbgH55g1EmzA50z2YqaZay624Jp4BOt5RdPhnocRjhcElHtHVgBxr8GIev/wTCwGjoQGfKQJeVl2ERUwEtIiIyTNm28gbAOXe/ma0EjsWLbnzOOfdGDq89G9iUcn8zcEy/Y74G3G9mnwXqgLeneyEzuwy4DGDevHk5nLpAws5AQ/oIR6ylt/gd1jn8LmnnFph0qHc7r2Xsxl8BHW2NgiNtB3rqkqlMP2w67TvamTg7/b+BqvqqomegM0U4wOtOq4AWEREZnlxW4bgDeAfwsHPuzhyL51xdBPzSOTcHOBP4jZkNGJNz7mrn3HLn3PKmpqYQT5+neIgFdEUjlFWlj3CE1YGuTdeBVgY6m2Ab7/6TCAPvuuZdnPurcwdMIAxUNVQVrAP94o0v8scv/THj84NFOMDrTmsZOxERkeHJJcLxfeAtwGozu9nM3mtmOVRfbAHmptyf4z+W6iPAjQDOuceBamBqDq9dHLEQIxxmXowj4yTCYWzjHQgmKqYuZZccwjJ28fbhj6VERJu9zyddhANg9lGzWfSORRm/vrqhumDL2L1w/Qs8ffXTGZ8fbBIh+AW0OtAiIiLDkstW3n92zn0K2A/4X+B8YGcOr70CWGxmC82sEm+S4O39jnkdOAXAzA7CK6B35T78EdYT4ajPflyuamYOzEAnur1Je2F0oCOVUNWUIQOdw+9AZRUw8QDYckf69arHoM5mr9ueLsKRi8r6yoJFOFo3tRJtiZKIpV9FY7B1oMErrhNRrcIhIiIyHDntROivwnEe8AngKOBXg32Ncy4OfAa4D3gJb7WNF83sG2Z2tn/YF4CPmdlzwPXA3zk3iiu1MCMcANUzBkY4Yq3+ORrDOUf/zVTyKaDN4MDPw54VsPORcMYzyg0W4RhMMImwEP+M92721gzv3J0+UjPYOtCgCIeIiEgYBp1EaGY34q2ocS9wBfBn51wylxd3zt0N3N3vsctTbq8Gjs9nwEUVa/Nyy2UV4bxezUzY+XDfx8LaxjtQ228zlXy28gZY+EFY9W/w0vdh+knhjGkUGyzCMZiqhipcwhHvjFNRG9K/E7zucvsOL0rTvqudCTMmDDhGEQ4REZGRkUsH+md4m6l8wjn3UK7F85gU2xte9xm8Arq7ubcrDN4KHBBeAR1sphLIZxk78JayO+AzsPVOaH0pnDGNYkEHeqgRjqp673MNeyJh29a2ntsdu9Kvy53TJEKtwiEiIjJsGQtoM3ubf7MOOMfM3pN6GZnhjTLxtnAmEAZ6NlPZ0ftY0IEOLcIx23v9ZMy7n4h6HfSBi51ktvjTXuTj5f8KZ0yjWGdzJxYxKidUDunrqxu8wjvsHPTeTb1bvne8kb6AHmwd6OA57UQoIiIyPNmqqODv9e9KczmrwOManWJt4Xagq9OsBR12B7p2FuB6i/REV+7xjUD1VNjvQ7D+N+k3fhlDos3eLoSZlqkbTFWD14EOeyWOIP8MXoQjnZzWgVaEQ0REZNgytqqcc1/1b37DObc+9TkzW1jQUY1W8ZAL6J7dCFMK6LAz0MGGLB1boHaOt4xdLhMI+1vyeXj1p/DKj+Gwb4cztlEo2hId8gRC6O1Ahx3hSC2ghxXhUAEtIiIybLn8Hf/3aR67OeyBlIRYgSIcfTrQYa/CEexG6OegE9Hc88+p6hfD3HfDq1dBbF84YxuFos3pt/HOVZCBDjvC0bqplerGaqonVQ8a4cjWgY5URbQKh4iIyDBlbFWZ2YHAUqChX+a5Hm+95vEn3gYTQmy+VzUBBtGUWER3C1gEyuvCOUdNv90IE9H8IxyBA78Im26Bdb+AJZ8NZ3yjTGdz55AnEELhIhxtm9uon1NPojuhDrSIiEiRZVvGbgle1rkRL/ccaAM+VsAxjV5hd6DLyqF62sAIR2WjtwZzGKqbwMp714JOdg0twgHQdBw0HQ8v/wAWf9Ib/xgTbYnSOL9xyF9fqAhH66ZW6ufU07W3K2sGuqyiDCvL/G9HBbSIiMjwZctA3wbcZmbH+dtsS9iTCGHgdt6xlvDiG+CttlEzc/gRjsCBX4S/vNvrRM8/P5wxjiLDjXBUTvRW7wh9FY7Ne5l55Ezad7bTvK457TGJrkTW7jP4EQ4V0CIiIsOSSwb6E2bWGNwxs0lm9vPCDWmUcg7i+8LtQANUzxzYga5oCPccNbOg0+9AJ4Y4iTAw+10wcTG89J9jbntv5xzRluiwIhxlkTIqJ1SGGuFIdCdo39FO/Zx6aptqs0Y4suWfQcvYiYiIhCGXAvpQ51xLcMc51wwcUbARjVbxdsAVoAM9o28GOtYS3gocgdTdCJNDWMYuVVkEDvwC7HlqzG3vHe+Mk+hODKsDDV4OOswIx94t3goc9XPrqZ1aS8cbHWm3Ck90JbKuAQ29EY5CbDUuIiIyXuRSQJeZ2aTgjplNJoctwMecuL8TXCEiHNEdkPS7gkEGOtRzzOrNQA+3Aw2w8FJvAuSqf4Xk2IkDdDZ3AgxrGTvwctBhRjiCJezq59RT11RHMp5M+/rxaHzQCEfwfKJbXWgREZGhyqWA/i/gcTP7ppl9E3gM+F5hhzUKxfwCuhARDpeArje8+90t4WagwVvKLtbqddGHm4EGb3vvI74Pux6FF74RzhhHgeFu4x2oqq8Kt4D2dyFsmNtAbVMtkH4zlURXIqcIR3CsiIiIDM2gBbRz7tfAe4Ad/uU9zrnfFHpgo04hO9DQG+MoRISjZym7bcNbxi7Vfpd6uxO+8C3Y9sfhv94oEG32C+gQIhxhZqCDDvTE2ROpneoV0Oly0PGuHDrQfgGtiYQiIiJDl0sHGmAy0O6cuwLYNS53IixUB7omZTvvZMzrEofdga71N1Pp2DK8Zez6W34FNBwMj70fOraG85pFFEQ4htuBrm6oDjUD3bqplaqGKqomVlHX5K0Pnm4zlVwy0EGHWgW0iIjI0A1aQJvZV4EvAf/sP1QB/LaQgxqVYgXuQHdug25/F8KCdaC3hpOBDpTXwgk3eUX/YxeXfB46iHAMNwNdWV8ZaoSjbXMbDXO9lVmyRTji0dxW4QC0G6GIiMgw5NKBfjdwNtAO4JzbCoRcRZaAeAEz0ADRbb3beBesgN7iRziGmYFO1XAQHHUV7PwzPP/18F63CMKKcFQ3VIce4aifUw+gCIeIiMgokEsB3e28Na8cgJmFtMd0iSlUB7q8xlv3uXO7l3+G8CMcFfXe1uAdIXegA/tdCvt9GF78Nmy7P9zXHkE9EY6G4WegYx0xErFwJuq1bmqlfq5XQFfWVVJeU54xwpFzB1oFtIiIyJDlUkDfaGb/CzSa2ceAPwHXFHZYo1ChJhGCl4Pu3OatwAHhd6DN/KXsNoGLh19AAyz/sZ+HvqRk89DRliiVEyspK891akB6VfVehz+MLnTqJiqBuqa6zB3owdaBrtIqHCIiIsOVyyoc3wduBn4PLAEud879uNADG3V6JhFOCP+1q2d6EY5CFdDgLWW3b513e7jL2KWTmod+/NLwX38ERJujw84/Q28HO4wCumcTlZQCunZqbcYMtCIcIiIihZfThijOuT8CY2OtsqGKtXkxCBtedzKtmpmw+2+Fi3CA14Fufta7HcYyduk0HASHfgOe+SK0vAiNSwtzngIZ7jbegaoGvwMdwkTCnk1U5qYU0E21inCIiIgUUcZq0Mwe9a/bzGxvmst6M/vUyA21yOJt4U8gDFTP8DLQ3c3e/cqG8M9RO6u3QC9EhCOw8ANgEdhQekuFR5ujw55ACL0d6DCWsgs2Uck1wjFYAa1l7ERERIYvYwHtnDvBv57onKvvfwGWA58bqYEWXazNm4xXCDUzIdEB7Zu8DnchYiI1s3tvF7KArp4GM8+A9b/t3Z68RHQ2d4bTgQ4xA526jXegZmpNxp0Ic45waBk7ERGRIcspj2BmR5rZ/zOzz5rZEQDOud3AyYUc3KgSbyvMBELoXQt670veihwFiYnM6r0d5jJ26Sz8gLdk3s6HC3uekEVbwslAhx3hCDZRCdQ11RFrjxHrjPU5Nh7NYRKhIhwiIiLDlstGKpcDvwKmAFOBX5rZvwI457YVdnijSGxv4SIcfQroxsKco3aEOtAAs9/ldevX/7qw5wnZaI1wBJuoBILNVFJz0C7pSMaTg2egq1RAi4iIDFcurc73A0c5577qnPsqcCzwgcIOaxSKFbADXe1v592xuTArcEDfDnShC+jyGph3Pmz6vbcqRwlIxBJ07+selRGO1PgGpN9MJYhk5Brh0DJ2IiIiQ5dLAb0VSK0qqoAthRnOKFbISYRBBxrGRgENXowj3g6bbi38uUIQxC3C6ECXV5cTqYyEEuFo3dTKxDl9/93VNXl7GaV2oIOCWKtwiIiIFF62VTh+bGb/A7QCL5rZL83sF8ALQMsIjW/0KGQHunJSby65UBGOSBVUTfFuFzoDDdB0AtQtgPWlsRpHsAthGBlo8HLQ2SIcyXiSX5/ya9beuzbjMcEmKpkiHKkTCYOCeLAMdFlFGZgKaBERkeHI9n/bp/zrlUBqG/Hhgo1mNCvkJEIzbzfC9o2F60CD14Xu2j0yHWgrgwWXwOrveDsT1s4a/GuKKNriFbthRDjAi3Fk60C3bGxh/YPrqZtex/6n75/2mHSbqMDwIhxmRnlVuVbhEBERGYaM/7d1zv0KwMyqgeD/8Gudc8OfGVVqknFIRAsX4QAvB92+sXAdaPCWsmt5fmQKaPBiHC9+CzZeBwd9cWTOOUTRZr+ADiHCAd5EwmwZ6OZ13prfGx7egHMOMxtwTLpNVMDrklvEhhThAK9LrQ60iIjI0GWLcJSb2feAzXircPwa2GRm3zOzipEa4KgQ97fxLlQHGnpz0IXuQENhtvJOp/4AmHJMScQ4ChHhyNaBbn7NK6D3bdvHnrV70h6Tbg1oACszaqf03c471w40qIAWEREZrmyTCP8TmAwsdM69yTl3JLAIaAS+PwJjGz1ifgFdyA70SBTQwVJ2hdrKO52FH4CWVdD83MidcwjCjnBUN1RnzUDvea23aN7w8Ia0x6TbhTBQO7W2b4Qjxww0eF3qRFSrcIiIiAxVtgL6LOBjzrm24AHn3F7gk8CZhR7YqFI1Bd5yK8x4e+HOUe0X0BUF2MY7MPU4mLAIqiYX7hz9zbsAyipGfRc67AhHVX1V1ghHy7oWph44lbrpdWz888a0x6TbRCVQ21Q7vAiHMtAiIiJDlq2Ads45l+bBBDDg8TGtvA7mngsTFhTuHDX+WtCF7EDPOgPOXjtyGWiA6qkw60zYcK2XJR+lOps7iVRGcurg5mKwCMee1/YwadEkFpy0oCcH3d/eTQPXgA7UNdUNaRIhKMIhIiIyXNkK6NVmdmn/B83sEuDlwg1pnKqd411XTinuOAph4aUQ3Q7bHyj2SDKKtni7EKabzDcUVQ1eBzpdYeyco3ldM5P2m8T8k+bTtqWtZ1Jhqr2bB+5CGKiZWtMnA51XB7pKBbSIiMhwZGtXfRq4xcw+jLeUHcByoAZ4d6EHNu7MeAe8+TpoenOxRxK+We/01rpe/2uYdVqxR5NWtDka2gRC8CIcLumItceonFDZ57mONzrobuv2OtAnLwBg4583MnlR32hN66ZWph8+Pe3r1zXV0bmnk2QiSVmkLK8MdHl1uXYiFBERGYaMHWjn3Bbn3DHAN4AN/uUbzrmjnXPjbyfCQiuLwIKLvPWTx5pIlZeF3nwrbL4d0nRliy3aHA1tAiF4kwiBtBMJg27zpP0mMfWgqdQ21Q6YSJhpE5VAbVMtOOjc460eogiHiIjIyBm0WnPOPeic+7F/Gb1/g5fR7cB/8JbRe+QcuHc5bL5jVBXSQYQjLFUN3sS/dDnoYAm7yYsmY2YsOGkBG/+8sU/co22rN3c3Uwa6/2Yq+UQ4IlURFdAiIiLDMAbbnTIq1S+Gs16GY38BsVZ45OxRVUh3NneGHuEA0q7EEXSgGxc2AjD/5Pm0vt5Ky4aWnmNaN7UCmQvouqY6gJ6VOPLuQGsVDhERkSFTAS0jp6wc9vu7lEK6xSuk7zsKOjYXdWjRlihVjeFtMJM1wvFaMxNnTaSixtuPaMFJCwD6LGeXaRfCQNCBDiYS5puBVgdaRERk6FRAy8hLLaSP+bm30crLPyzacJxzRFtCnkSYJcKx57U9TNpvUs/9poObqJ3aNwedbRMV8DPQDC3CoQJaRERkeFRAS/GUVcCiD3mrdGz4bdHWie5u68YlXEEmEWaKcExa1FtAW5kx/8T5AzrQmTZRgZQM9BAiHJGqiFbhEBERGQYV0FJ8Cz8I0R2w7f6inL5nG+8wJxH6Gej+EY5YZ4y2LW19OtDg5aBbNrTQsrEFyL6JCniFcuXEyp4IR6IrgZUZZeWD/0irAy0iIjI8KqCl+Gad6W2Xvv7XRTl9Z7O3FFyYEY7KCZVgAyMcwUTB1A40DMxB792cvYCGvrsRxqPxnHdRDArodJu8iIiIyOBUQEvxRSph/kWw+Q/Q3TLip482+x3oECMcVmZU1VcN6EAHS9j170BPWzaNmsk1PTnovZv3ZpxAGKhtqu0T4cgl/wxe99olHcl4MqfjRUREpC8V0DI6LLwUkl3w+k0jfupCRDjAi3F07+3u81iwhF3/XQdTc9CJ7gT7duwbtANdO7W2zyTCXPLP0LtSh3LQIiIiQ6MCWkaHycuh/iBY/6sRP3UhIhzgTSTs34He89oeKidU9qyikWr+yfNpXtfM5r9tBkfGXQgDdU11fTLQOXeg/QJaOWgREZGhUQEto4OZ14Xe9VdoWzuip+7pQIcY4QBvKbsBGeh1LUzabxJmNuD4IAe96rergMxL2AWCCIdzLq8MdFBoq4AWEREZGhXQMnosvAQwWP+bET1ttDkK1rtyRliq6qsGLGO357U9AyYQBqYfOp3qSdWsvnE1kHkTlUDt1FoSXQm693UT74rnHeHQboQiIiJDowJaRo/aOTDj7d5qHG7kJrh1NndS3VCNlQ3sCg9H/wiHSzpa1rcMmEAYsDJj/lvm93TEc+lAg7eZiiIcIiIiI0cFtIwuCy+F9g2w8y8jdsqulq7QJxDCwAhH27Y24tF4xg40eDlo8LrXmTZRCdQ11QHeZip5daCrVECLiIgMhwpoGV3mvhvKJ4zomtCdzZ2hTyAEv4BOiXBkWsIuVZCDHiy+Ab27Ebbvas97HWjQKhwiIiJDpQJaRpfyOpj3Xm85u3jHiJwy2hwNfQIheF3keDROotsrVDMtYZdq+mHTqWqoGjS+AYpwiIiIFIsKaBl9Fn4Q4m3exiojINoSLUiEo7rBe80gB73ntT1YmdEwL/PydGWRMs766Vkc/6XjB339IUc4VECLiIgMiwpoGX2mnQh182HdyKwJ3dncWbAMNNAT42hZ10LDvAYildk7xcsuXMbCty4c9PUrJ1ZSVlFG+672vDrQPcvYaRUOERGRIVEBLaOPlcGCD8COP0HHloKfrpARDqBnIuGe1/ZkzT/ny8yoa6qjY1fHkDLQ6kCLiIgMjQpoGZ0WXuotZVfgnQnj0TjxaLwgkwj7Rzia1zVnXYFjKILNVOJdcWWgRURERkhBC2gzO93M1pjZWjP7coZjzjez1Wb2opldV8jxSAmpX+ytCb3mRxBvL9hpenYhLHCEo6uti45dHaF2oMFbiSOYRKhl7EREREZGwQpoM4sAVwJnAAcDF5nZwf2OWQz8M3C8c24p8PeFGo+UoGVfhehOePWnBTtFobbxhr4RjmAFjrA70HVNdd4ydkPoQGsZOxERkaEpZAf6aGCtc26dc64buAE4p98xHwOudM41AzjndhZwPFJqpp3gdaFf+l7ButCdzZ0ABY9w5LIG9FDUNqV0oJWBFhERGRGFLKBnA5tS7m/2H0t1AHCAmf3VzJ4ws9PTvZCZXWZmT5nZU7t27SrQcGVUKnAXOtpcwA50SoQjlzWgh6J2am3PKh+5RjiCVUBinbFQxyIiIjJeFHsSYTmwGDgZuAi4xswa+x/knLvaObfcObe8qalpZEcoxVXgLnQhM9CRigjlNeV0tXax57U9VE+qDr1QDzZTAXKOcFiZ0XRwE8//9nliHSqiRURE8lXIAnoLMDfl/hz/sVSbgdudczHn3HrgFbyCWqTXIV8rWBe6kBEO8HLQQYQj7O4z9G6mArl3oAHOvPJMmtc18+dv/Dn0MYmIiIx1hSygVwCLzWyhmVUCFwK39zvmD3jdZ8xsKl6kY10BxySlqOl4mHFqQbrQhYxwgJeDDiYRhp1/Bi/CEcg1Aw2w4OQFHPGRI3js+4+x/bntoY9LRERkLCtYAe2ciwOfAe4DXgJudM69aGbfMLOz/cPuA3ab2WrgIeAfnXO7CzUmKWGHBFnoq0J92WhLlIraikF3BxyqqoYqOvd00rqxNfQVOGBoEY7Aqd87ldoptdzxsTtIJpJhD01ERGTMKmgG2jl3t3PuAOfcIufct/3HLnfO3e7fds65f3DOHeycO8Q5d0MhxyMlLOhCr87ShXYu75ct1Dbegar6Kna+sJNkPFmQDvRQIxwANZNrOP1Hp7N1xVaevOLJsIcmIiIyZhV7EqFI7g75GnTtGtiFjrfD2qvhnsPglpmw9d6cX7Krpatg8Q3wIhz7tu0Dwl8DGrwiOJBvBxpg6QVL2f+M/XnwXx6k9fXWMIcmIiIyZqmAltLR9GaY8Y7eLvTeV2Hl5+HW2fDkx4EyqJoKD58JL3zL2wo8m0SUzi2vUNNQuB+DYCk7CH8JO4Cy8rKeIjqfDHTAzHjnVe8EB3d96i7cELr4IiIi440KaCkth3zV60Lf+ya48wB45QqYdQac+iic8Qyc9jdYcDGs+jd45FzoTtNVTcZg7TVwx2Ki2zdTXVm42H2wG2FZRRkTZ08syDmCHHS+EY5A4/xG3vqtt/LqXa+y+qbVYQ5NRERkTFIBLaWl6c0w51yI7YVDvg7nvg7HX+9lpM2gvBaO+w286X9g6z1w31HQ8oL3tS4JG66DOw+GJy+D2rlEkwuonntw1lMOR9CBnrRwEmWRwvy4BStxDCXCETjms8cw800zuef/3UNncyfOOTr3dLLrpV2sf2g9L9zwAhv/sjHn1+vY3cFtH7mNJ370BPt27BvyuEREREajobWsRIrpLbd4xXImZrDkszDpCHj0fXDfMXDwl2HTTdDyPDQeCifdAbPeSefe/yjoJMJgO+9CTCAMBBMJh9qBBi8K8q5r3sU1R13D/+z3P3S3d5OMDYzAnHX1WbzpY2/K+lrd+7q57szr2LJiCzi4/wv3s+jURRzy/kM48NwDqZxQOeRxioiIjAYqoKX0ZCueU007Ac542iuin78cJi6G42+Aee8DKyOZSNLVWthJhD0d6AJMIAz0RDiGkIFONfOImZz107N4/dHXmTBjAhNmTKBueh0Tpk+gblodf/rSn7jz43cSqYxw+AcPT/sa8a44N5x7A1tXbuWCWy9gyuIprLp2Fc9f+zy3fuBWKmorOPDcAznqM0cx97i5aV8jDFtWbGHa0mlU1FYU7BwiIjJ+qYCWsa1mJrztQXjjcS/mUdb7T75rb5d3SIF2IYTeDHQhO9BhRDgCR370SI786JFpnzv/9+dz/buu5/YP3055VTnLLlzW5/lkPMktF9/C+gfWc+6vzuXAcw4E4JRvn8Lbvvk2Nj22iVXXruLF373I89c9z4HnHsjbvvM2mg5qGva4U628eiV3fvxO5p0wj/ff8351vEVEJHTKQMvYF6mE6Sf1KZ7BK/gWnbaIKQdMKdipg+52QQvokDrQgymvLufC2y5k3lvmccslt7D6970TDp1z3HHZHbx0y0uc9sPTOOzSw/p8rZUZ806Yx1lXncXnN32et37rrax7YB1XLbuK2z96O3s37w1ljK/e/Sp3feouZhwxg02Pb+L6d11PrCMWymuLiIgErNSWrVq+fLl76qmnij0MkZzEOmP85Tt/4S3//JaCxQnatrbx7K+e5YQvn4DlGm8Zhu593fz2tN+y5cktnH/L+Rxw1gHc/8X7eeIHT3DSV0/i5K+dnNPrtO9q5y/f+QsrrlxBWaSMYz53DMd/6fgh/0Vg29Pb+MWJv2DKAVP40CMfYs0da7j1kltZ8NYFXHTHRVTUKM4hIiL5MbOVzrnlAx5XAS0i+Yq2RvnNqb9hx3M7WHr+Ulb9dhVHf/ZoTv/R6XkX8c3rm3n48odZde0qaqfWctp/n8YhFx+S1+u0bGzhZ8f+jEhlhI88/hEmzvKWDHzuN8/xhw/+gUWnLuLC2y4seJdeRETGlkwFtCIcIpK36oZqLrnvEpqWNrHqt6s49JJDOf2H+RfP4C3x9+7fvJvLVl7GpIWTuPWSW7n29GtpXtec09dHW6Jcd+Z1xDpjXHz3xT3FM8BhHziMs392Nq/d/xo3nncj8a543uMTERHpTx1oERmyzj2drLljDYdcfAiRiuFPYkwmkjx11VM88JUHSMaTnPy1kzn288dmfO1Ed4Lfnv5bXn/0dS657xIWvnVh2uNWXrOSOy+7kyVnL+F9N72PSOXwxyoiImOfIhwiUjL2bt7LPf/vHl6+9WWmHzqdU/79lJ4ty1M9ecWTPH/t87z7N+/m0EsOzfqaK36ygrs/fTeLz1zMe3/3Xq3OISIig1IBLSIl5+U/vMzdn7mbti1tGY956zffyon/emJOr7fy6pXc9am7mH7IdC668yLqZ9eHNVQRERmDVECLSEnqauti8+ObccmB/62qbqxm9jGz88per713LTe97yaqGqq4+K6LmXHYjDCHKyIiY4gKaBER3/bntnPdO6+jq7WL9974XhafsbjP8y7peP3R13n+uufZ/sx2phwwhWmHTGPaMu9SP7d+RJYMFBGR4lIBLSKSYu+WvVz/ruvZsWoHZ15xJm/6+JvY/ux2nr/ueV684UX2bt5LRW0Fs5bPYs9re/rESKrqq5hx+Aze/h9vZ86xc4r4LkREpJBUQIuI9NO9r5ubL7yZV+96lfq59ezdtJey8jL2P31/ll28jCVnL6Gyzpts2Nncya4Xd7HzhZ3sfGEnr9zxCm3b2jj9h6ez/JPLR3VHevuz28FQXEVEJE8qoEVE0kjGkzx0+UNse3obB73nIA467yBqp9QO+nWdzZ3c+oFbefWuVzn0kkN550/f2VNsjyZt29r4ycE/wcqMz6z5DLVTB39vIiLiUQEtIhIyl3T85Tt/4aHLH2La0mmcf8v5TFk8pdjD6uOm993EmjvW4BKOwz54GGf/39nFHpKISMnQToQiIiGzMuPEfz2RS+69hLZtbVyz/Bpe/sPLxR5Wj5dve5nVN6/mpMtP4tjPH8szP3uGTY9tKvawRERKnjrQIiIhaNnYwk3vvYmtT21lypIpNMxrGHCZcfiMtBvCFEK0NcpPDv4JNVNquGzlZSS6Elx50JXe/acuo6xc/RMRkcFk6kCXF2MwIiJjTeP8Rj706Id4/L8eZ/uz22l9vZVX736Vfdv29RxTVl7GotMWseyiZRx4zoEF3Q3xgX9+gH3b93HBrRcQqYgQqYhw2g9P46b33sSTVz7JsZ87tmDnFhEZ61RAi4iEpLyqnLd85S19Hot3xWnb0kbLhhbW3ruWF254gVfvepXymnKWnL2EZRctY//T96e8Krz/HL/+6Os8ddVTHPv5Y5l99Oyexw96z0Hsf/r+PPRvD7H0/KVMnDkxtHOKiIwninCIiIwgl3S8/tfXeeH6F1h902o63uigtqmWYz53DEd/+miqG6szfm2sI8aqa1ex5rY1LDptEUd+9Egqair6HBOPxvnfI/6XWGeMT73wqQFd7j1r9/CTZT/hoPccxHnXnVeQ9ygiMlZoFQ4RkVEmEUuw7k/rePLHT7L2nrVUTqxk+SeXc9znj2PCjAk9x7VuamXFT1bw9NVP07mnk7rpdbTvaGfCjAm8+R/fzJs+/qaeJfQeuvwhHvnmI7z/nvez/+n7pz3vQ199iEe+8QiXPnApC9+2cETeq4hIKVIBLSIyim1/djuPfvdRVt+0mrKKMg7/0OEccNYBrPr1Klb/fjU4WHLOEo753DHMP3E+G/+8kUe++QjrH1xPbVMtx/3Dccw/aT6/PPGXLLtwGe/+zbsznivWGeOqZVcRqYzwiec+QaQykvM4t67cyvRDpuf1NSIipUoFtIhICdizdg9//c+/8twvnyPRnaC6sZojPnoER3/6aBoXNA44ftNjm3jkm4+w9t61ANROreXTL3160A1TXr37Va5753Wc8u+ncMKXT8hpbH/597/w4FceZOkFSznv+vNG9e6LIiJhUAEtIlJC2ra2seXJLez39v1yWq1jy4otPPnjJ1l24TIWn7k4p3P87j2/45U7X+Hsn53NYR84LOuxT/zoCe77+/uYetBU3njpDU757imc8KXcCm8RkVKlAlpERProbO7kxvfcyIaHN3Dy10/mxH87MW1XeeXVK7nz43dy0HkHcd7153HrB27lxRtf5OI7L865WBcRKUXaiVBERPqomVTDJfddwqEfOJSHv/owt3/4dhLdiT7HPPeb57jzE3ey+MzFnHfdeUQqIpz9s7OZfuh0fn/x79n9yu4ijV5EpHhUQIuIjGORygjn/upcTvrqSTz7y2e59sxribZEAVh982pu+7vbWPjWhZz/+/N7Jg5W1lVy4R8uJFIR4YZzbiDaGi3mWxARGXEqoEVExjkz4+Svncw5vzyHjY9s5Ocn/JyV16zk9xf9njnHzeHC2y6kvLrvRi+NCxp5303vY/eru7n1kltxyYFxQOccu17axRtr3hiptyIiMiKUgRYRkR7rH1rP7979O7pau5i1fBYf+NMHqG7IvLnLk1c+yT2fuYe3/MtbeNu33kbr662se2Ad6x9Yz/oH1/dsZT5r+SwO+7vDOOSiQ6iZXJPx9aKtUVrWt9C0tIlIhZbKE5Hi0iRCERHJya6XdvH0/z3Nif9yYtZiF7wu8x0fu4NnfvYMk/abRPO6ZgDqptWx8G0LWXjKQrr3dfPsL59lx3M7iFRGWHLOEg7/u8OZf+J8djy/g60rtrJ1xVa2rNjC7jVeprp6UjVLzl7CQe85iEXvWDSgAy4iMhJUQIuISEHEu+LcesmtxDpj7Pf2/Vh4ykKmLZs2YEWP7c9u59lfPsvz1z5PxxsdfZ6bMHMCs4+azayjZtG4oJF1f1zHmtvXEG2JUjmhksVnLuag8w5iyTlLKK9SMS0iI0MFtIiIjAqJ7gSv3v0q25/bzozDZjDrqFnUz65Pe9yGhzew+verWfOHNbTvbGfqgVM56+qzmP+W+UUYuYiMNyqgRUSkZCUTSV6961Xu/dy9tGxo4ciPHcnb/+Pt1EzKHjERERkOrQMtIiIlqyxSxpKzl/DJFz7JcV88jmd+/gxXHnQlL/zuBUqtESQipU8daBERKTnbntnGHR+7g20rt7H4zMUc9emjqJlcQ/WkaqobvYuy0iIyXIpwiIjImJKMJ3nyiid58F8fJNYeG/B8eXU5NVNqqJtWx4TpE6ibXkfdtDrqptfRuKCR/U/fn8q6yiKMPD2XdFjZwK3URaR4MhXQ+vVcRERKUll5Gcf+/bEcesmh7H51N9GWKNHmqHfdEqWzuZPO3Z2072ynfUc7O1/cSfuO9p7tyisnVHLQeQdx2KWHseDkBSNWvDrnaH29le3PbmfHczvY8dwOtj+3ndaNrRx66aG84z/fMejygSJSXOpAi4jIuOGco2tvF9uf3c6q365i9Y2r6drbRf3ceg695FAOft/BxDvjNK9rpnl9My3rWmhe30zrxlYq6ipomNtA/dx66ufUUz+3noa5DVROqCQZTw64dO/rZt/2fbRta2Pftn3s276Pfdv20bqpla7WLm9ABpMXTWbG4TOorK/kuV89R+2UWk774Wksu3DZgKUARWRkKcIhIiLST6wzxprb17Dq16tYe99aXKLv/xMnzppI48JGGuc3EuuI0bqplb2b9tK+sz3nc0QqI0yYMcG7zJzAxNkTmX7IdKYfNp3ph0ynckJvjGT7c9u542N3sHXFVvY/fX/eedU7aVzQGNbbFZE8qYAWERHJYt+Ofaz74zpqJtcwab9JNMxvoKKmIu2x8a44bVvaaN3USrwzTll52YBLeU05E2dOpHpSdV6d5GQiyYorV/DgvzyISzpO/sbJHP3po7Ubo0gRqIAWEREpIa2bWrn703fzyh2vYGXGpEWTaDq4iakHTaXp4CaaDm5i2tJpKqxFCkiTCEVEREpIw9wGLrztQtb9aR2vP/o6b7z0BrtW7+LVu18lGUsCUFFbwaJ3LGLJuUs44KwDqJ1SW+RRi4wPKqBFRERGKTNj0amLWHTqop7HErEEza81s/PFnax/cD1rblvDy394GSsz5r1lHkvOWcLCty6koq6C8qpyIlWRPtdaKk9k+BThEBERKWHOObat3MbLt73MmtvWsPP5nVmPr6iroKq+yrtM9K8bqph7/FyWnL2EKYunjNDIRUY/ZaBFRETGgeZ1zWx7ehvxaJx4V5xEV6LnOtYZo7utm662Lrr3etdde7vo2NXB7ld2AzD1wKkccPYBLDl7CXOOnUNZpKzI70ikeFRAi4iISEYtG1t45Y5XWHPbGjY8vIFkPEnt1FoWnrKQuW+ey9zj5zL90OlEKiLFHqrIiFEBLSIiIjmJtkZZe+9aXrn9FTb8eQNtW9oAb9Li7KNnM+fNc5hx2Azqpvduk17dmN9yfbmKdcbo3N1J555OOnZ30Lmnk4qaCuYeP5fqhuqsX5voTrDp8U1sXbGVqQdNZd4J8wb9GpFUKqBFRERkSFo3tbLpsU3e5a+b2P7s9gGbzkQqI9RNq6N6UrW3G2MsSSKW6L2OJzEzrMy7YPTedl6WGwcu6Xpud+/rJh6Npx2TlRkzj5zJ/JPns+DkBcw7YR5V9VXsfmU3r93/GuvuX8f6h9YTa4/1/Zo3zWTByQv6fE0u2nd628HHOmLMOWYOtVO14sl4oAJaREREQtHd3k3zumbad7Szb8e+nuuOnR1EW6LeZjIVZUQqIpRVeLfLyr0stUu6ngvO2zjGLKWgDm6bUVFXQe2UWmom13iXKd51555ONv55Ixse3sDmxzeT6E5gZUbt1NqeXSIn7z+Z/U7dj0XvWMSc4+awa/UuNjy0wfuaJzaTjCWxMqN+Tj0TZ01k4qyJTJg1oed2rD3Gzhd3suvFXex6cRcdb3T0+QymHjiVucfPZd4J85h7/Fwm7z8Zl3B07O6gY1cH7bva6djldcytzIhURgZcMHp/afB/cXBJR3lVOdWN1d5lknddXuUtnJZMJOlq7aKz2evKR5ujxDpjTFk8hSkHTOn5nCUcKqBFRERkzIl1xtjyty1seHgDza81M/eEuSw6dRGT9puU+Ws6Ymx+YjMbH9lI87pm2ra29Vy6Wrt6jquqr6JpaRNNS71Na5oObqK8upxNj23i9UdfZ9Njm4g2RwEv3hLrjEGByqryam8pwq69XRnPEamKMG3pNG+b+EO9S+3UWipqK6ioq/CuayuUY8+DCmgRERGRQXS3d9O2tY2Kmgomzp6YNdftko5dL+1i0183sWv1Lqobq6ltqqV2ai11TXXebX9zm0R3os8l3hUHx8BIixnxrjjRlqh3aY723I5H41RPqqZmkteJD25HKiO88fIb7Fi1w7s8t6OnE59O8BcCoKfj33M7eG9Bfej63U95DLwx1zbVMnHmRCbMmMCEmf5lxgQA4p1xYp0xYh2xntuRikif7nrNpJoBtytqKnL9lhVUUQpoMzsd+BEQAf7POffdDMedB9wMHOWcy1odq4AWERERyW7fjn3sfGEnXa1ddLd3E+vwithYe4zu9m5cojdrDv0K5v4FdZoCO3gsGU/SsauDfdv20batjX3b9tG5pzPtmMqryymvKScZS9K9rzvr+CNVkZ5iumZSDe+76X1MnDVxCJ/E8Iz4Vt5mFgGuBE4FNgMrzOx259zqfsdNBD4H/K1QYxEREREZTyZMn8CE6ROKcu54V5z2He1YmVFeU05FTQXl1X13wUzEEj1Z7qDT3tncOeC6q8U7prxmdG2eXcjRHA2sdc6tAzCzG4BzgNX9jvsm8B/APxZwLCIiIiIyAsqrymmY15D1mEhFhNqptSW7mkkhp2rOBjal3N/sP9bDzI4E5jrn7sr2QmZ2mZk9ZWZP7dq1K/yRioiIiIjkqGhrnZhZGfAD4AuDHeucu9o5t9w5t7ypqanwgxMRERERyaCQBfQWYG7K/Tn+Y4GJwDLgYTPbABwL3G5mA4LaIiIiIiKjRSEL6BXAYjNbaGaVwIXA7cGTzrlW59xU59wC59wC4Ang7MFW4RARERERKaaCFdDOuTjwGeA+4CXgRufci2b2DTM7u1DnFREREREppIKuCeKcuxu4u99jl2c49uRCjkVEREREJAzaMF1EREREJA8qoEVERERE8qACWkREREQkDyqgRURERETyoAJaRERERCQPKqBFRERERPKgAlpEREREJA/mnCv2GPJiZruAjQU8xVTgjQK+vow++p6PL/p+jy/6fo8v+n6PP4X+ns93zjX1f7DkCuhCM7OnnHPLiz0OGTn6no8v+n6PL/p+jy/6fo8/xfqeK8IhIiIiIpIHFdAiIiIiInlQAT3Q1cUegIw4fc/HF32/xxd9v8cXfb/Hn6J8z5WBFhERERHJgzrQIiIiIiJ5UAGdwsxON7M1ZrbWzL5c7PFIuMxsrpk9ZGarzexFM/uc//hkM/ujmb3qX08q9lglPGYWMbNnzOxO//5CM/ub/3P+OzOrLPYYJTxm1mhmN5vZy2b2kpkdp5/xscvMPu//9/wFM7vezKr1Mz52mNnPzWynmb2Q8ljan2fz/I//fV9lZkcWcmwqoH1mFgGuBM4ADgYuMrODizsqCVkc+IJz7mDgWODT/vf4y8ADzrnFwAP+fRk7Pge8lHL/P4D/ds7tDzQDHynKqKRQfgTc65w7EDgM73uvn/ExyMxmA/8PWO6cWwZEgAvRz/hY8kvg9H6PZfp5PgNY7F8uA64q5MBUQPc6GljrnFvnnOsGbgDOKfKYJETOuW3Ouaf92214/2Odjfd9/pV/2K+Ac4syQAmdmc0B3gn8n3/fgLcBN/uH6Ps9hphZA3Ai8DMA51y3c64F/YyPZeVAjZmVA7XANvQzPmY45x4B9vR7ONPP8znAr53nCaDRzGYWamwqoHvNBjal3N/sPyZjkJktAI4A/gZMd85t85/aDkwv1rgkdD8E/glI+venAC3Oubh/Xz/nY8tCYBfwCz+2839mVod+xsck59wW4PvA63iFcyuwEv2Mj3WZfp5HtI5TAS3jjplNAH4P/L1zbm/qc85blkZL04wBZnYWsNM5t7LYY5ERUw4cCVzlnDsCaKdfXEM/42OHn309B+8Xp1lAHQP/3C9jWDF/nlVA99oCzE25P8d/TMYQM6vAK56vdc7d4j+8I/gzj3+9s1jjk1AdD5xtZhvwIllvw8vHNvp/7gX9nI81m4HNzrm/+fdvxiuo9TM+Nr0dWO+c2+WciwG34P3c62d8bMv08zyidZwK6F4rgMX+7N1KvIkItxd5TBIiP//6M+Al59wPUp66Hfigf/uDwG0jPTYJn3Pun51zc5xzC/B+nh90zr0feAh4r3+Yvt9jiHNuO7DJzJb4D50CrEY/42PV68CxZlbr//c9+H7rZ3xsy/TzfDtwqb8ax7FAa0rUI3TaSCWFmZ2Jl5mMAD93zn27uCOSMJnZCcBfgOfpzcR+BS8HfSMwD9gInO+c6z9pQUqYmZ0MfNE5d5aZ7YfXkZ4MPANc4pzrKuLwJERmdjjepNFKYB3wIbxmkX7GxyAz+zpwAd4qS88AH8XLvepnfAwws+uBk4GpwA7gq8AfSPPz7P8SdQVejKcD+JBz7qmCjU0FtIiIiIhI7hThEBERERHJgwpoEREREZE8qIAWEREREcmDCmgRERERkTyogBYRERERyYMKaBGRUcjM9vnXC8zs4pBf+yv97j8W5uuLiIx1KqBFREa3BUBeBXTKLmyZ9CmgnXNvznNMIiLjmgpoEZHR7bvAW8zsWTP7vJlFzOw/zWyFma0ys4+Dt1mMmf3FzG7H240NM/uDma00sxfN7DL/se8CNf7rXes/FnS7zX/tF8zseTO7IOW1Hzazm83sZTO71t+0QERkXBqsSyEiIsX1ZfxdFAH8QrjVOXeUmVUBfzWz+/1jjwSWOefW+/c/7O/QVQOsMLPfO+e+bGafcc4dnuZc7wEOBw7D2/lrhZk94j93BLAU2Ar8FTgeeDTsNysiUgrUgRYRKS3vAC41s2fxtqGfAiz2n3sypXgG+H9m9hzwBDA35bhMTgCud84lnHM7gD8DR6W89mbnXBJ4Fi9aIiIyLqkDLSJSWgz4rHPuvj4Pmp0MtPe7/3bgOOdch5k9DFQP47xdKbcT6P8fIjKOqQMtIjK6tQETU+7fB3zSzCoAzOwAM6tL83UNQLNfPB8IHJvyXCz4+n7+Alzg56ybgBOBJ0N5FyIiY4g6CCIio9sqIOFHMX4J/AgvPvG0P5FvF3Bumq+7F/iEmb0ErMGLcQSuBlaZ2dPOufenPH4rcBzwHOCAf3LObfcLcBER8ZlzrthjEBEREREpGYpwiIiIiIjkQQW0iIiIiEgeVECLiIiIiORBBbSIiIiISB5UQIuIiIiI5EEFtIiIiIhIHlRAi4iIiIjkQQW0iIiIiEge/j8BrECi+n+JsQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -624,10 +615,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -638,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "bronze-spread", "metadata": {}, "outputs": [ @@ -666,7 +657,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "catholic-norway", "metadata": {}, "outputs": [], @@ -685,23 +676,23 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "id": "tested-handling", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAecAAAD4CAYAAADW+i6uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABEHElEQVR4nO3deVhV1frA8e8CQcVZMTWVwUQZHXG8WKFWWqml2U+iHNJITUu9ebOwTIwsvaY5pZhpJtJgdrPBJrWUbnXTVBRQcwLH0lRyQgTW748NCApyhAObc877eR6ec8466+z9bgfes/dea71Ka40QQgghKg4nswMQQgghREGSnIUQQogKRpKzEEIIUcFIchZCCCEqGEnOQgghRAVTyawdu7u7ay8vL7N2L4QQNmnr1q2ntNb1S7mNWypVqvQ2EIicpJkhG9iVmZk5on379n8W1sG05Ozl5cWWLVvM2r0QQtgkpVRKabdRqVKltxs2bOhXv379M05OTjKftpxlZ2erkydP+p84ceJtoG9hfeQbkxBCOJ7A+vXr/y2J2RxOTk66fv36aRhXLgrvU47xCCGEqBicJDGbK+fPv8gcLMlZCCGEqGAkOQshhCh3bm5ubS3tO2HChFtfeumlBtbY/urVq2t6eXkFenh4BL7wwgsNC+szd+7ceocOHXK5mf0BzJgxo/78+fPr3eznCmPagDAhhBCiPGVmZjJ+/HiPr7/+em+zZs2utG7d2m/AgAFn27dvn56/38qVK93btGlzycvL60ph26hUqfDU+a9//euktWIt9sxZKfWOUupPpdSuIt5XSqm5Sql9SqkEpVQ7awVXHmJjwcsLnJyMx9hYsyMSQoiKZdEi6t56K0FOTrS/9VaCFi2iblnsZ9WqVbVatWrl6+fn59+1a9cWhw8fzsuCCQkJbm3atPH19PQMnDVrlntu+4svvtggMDDQr0WLFv7jx4+/9Ubb//7776t5enpe9vf3z6hSpYru37//6dWrV9fO32fZsmV1du3a5TZ48OBmvr6+/ufPn1eNGzcOGjVqVGN/f3+/d955p86sWbPcAwMD/Vq2bOl/zz333Hbu3DknKHiG37Fjx5ajRo1qHBQU5Ofl5RX41VdfVb+ZPwtLLmsvB3rd4P3egE/OTwTw1s0EYKbYWIiIgJQU0Np4jIiQBC2EELkWLaLu+PF4Hj+Oq9Zw/Diu48fjWRYJ+q677jq/ffv23cnJyUkPPfTQ6aioqLzLzsnJyVXj4+P3/Pzzz7tnzpx566FDh1zWrFlTc9++fVUSEhKSk5OTk7Zv3+62bt26IpPg4cOHXRs3bpyR+7pJkyYZR48edc3fZ9iwYWcCAwMvrlix4sDu3buTqlevrgHq1auXmZSUlBwREXEmPDz8zK5du5L37NmT1LJly0tz5851v3ZfAJmZmWrnzp3Jr7/++uGoqKgbfnG4VrHJWWu9CTh9gy79gBXa8DNQWynV6GaCuFn79+8nPT29+I7FiIyEixcLtl28aLQLISwXFweBgeDsbDzGxZkdkbCWqCgap6cXzBXp6ThFRdHY2vs6ePCga7du3XxatGjhP3fu3Ia7d++umvte7969z1avXl03atQos0uXLn9v3ry52ldffVVz06ZNNf39/f0DAgL89+/fX2X37t1VrB0XwODBg8/kPt+6dWvV9u3bt2zRooX/xx9/XC8xMbHQfQ4cOPAMQNeuXS8cOXLEtbA+RbHGgLDGwOF8r4/ktF1HKRWhlNqilNpy8mTJLs1nZmZy33330aZNG3788ccSbSNXaurNtQshrhcXZ3yhnTcP0tONx8hISdD24sQJCk0qRbWXxpgxYzxGjx795969e5Pmz5+fcvny5bwcpZQq0FcphdaacePGHd+9e3fS7t27k1JTU3eNHz/+VFHbb9q0aYEz5SNHjhQ4k76RGjVqZOc+j4iI8J4/f37q3r17k5577rlj+ePMr0qVKhqgUqVKZGVlqcL6FKVcR2trrWO01sFa6+D69Uu2+lylSpV48803SU9Pp1u3bjz99NOcP3++RNvy8Li5diHE9aKjYelSCA0FFxfjcelSo13YvoYNKTR5FdVeGufOnXP28PC4ArB8+fICo57XrVtX++LFi+rEiRPOP//8c42QkJALvXv3/vu9995zT0tLcwI4ePCgy9GjR4sc6HzHHXdcOHToUJXdu3e7pqenqzVr1tQdMGDA2Wv7Va9ePSstLc25qO1cvHjRycPD48rly5fV+++/Xyb3362RnI8CTfO9bpLTVmbuuecedu3axZgxY5g/fz6hoaFoffPz6aOjwc2tYJubm/xSEeJmJCdDSEjBtpAQo13Yvpde4miVKmTnb6tSheyXXird7/n09HSnBg0atMr9efnllxtERkYeCwsLuy0gIMCvXr16mfn7+/n5XezatWvLTp06+T377LPHvby8rvTv3//vgQMHnu7QoYNvixYt/B988MHbzp49W2RSdXFxYdasWam9evVq4ePjE/DAAw+cDg4Ovu4e6eDBg0+NHTvWM3dA2LXvT5o06VjHjh39goODfX18fEp/j7UQypKkppTyAj7XWl+31JhS6j5gDHAv0AmYq7XuWNw2g4ODtTXW1v7xxx85e/Ys9913H1lZWfz999/UqVPH4s/HxhqX4FJTjTPm6GgIDy91WEI4jMBA41J2aOjVto0bYexY2FXoHA9RGkqprVrr4NJsY8eOHYdat25d5OXfay1aRN2oKBqfOIFrw4ZkvPQSR0eOvOFYJGGBHTt2uLdu3dqrsPeKneeslIoD7gTclVJHgCmAC4DWehHwJUZi3gdcBIZZJWoL/eMf/8h7/uabbzJjxgwWLFjAgAEDLPp8eLgkYyFKIzIShg83LmWHhEB8vPFarkDZj5EjOS3JuHwVm5y11mHFvK+Bp6wWUSl0796dlStX8tBDDzFgwADmz59Pw4aFLgAjhLCSsJzfEGPHGpey/fyMxBx2w98cQogbsavlO9u0acMvv/zCa6+9xueff46/vz+ffPKJ2WEJYffCwoxL2FlZxqMkZiFKx66SMxg3/J977jl27NhBUFAQJR0VLqxHVmETQoibY7dra7ds2ZLvv/8+b25cZGQkDRs25KmnnsLJye6+k1RYuauw5S72krsKG8i9fiGEKIpdZ6ncxJyVlcX27dt5+umnuf3229m9e7fJkTkOWYVNCCFunl0n51zOzs58/vnnrFixguTkZFq3bs2rr77KlSvXFRwRViarsAkhCmNWyciBAwd61a1bt7WPj09AUZ997733am/duvWmlwGNjY2tVVQZypvlEMkZjLPoxx57jKSkJPr168e0adM4fPhw8R8UpSKrsAkhKpLHH3/81Nq1a3+/UZ///Oc/tRMSEqoW9t6NTurCw8PTXn311ROlDBFwoOScq0GDBnz44YckJibSrFkztNasWLGCS5cumR2aXZJV2ISwfYt+XVT31lm3BjlNdWp/66xbgxb9usgmS0YC9O7d+3z9+vUzi3r/22+/rfbdd9/Vnjx5chNfX1//xMTEyh07dmz5+OOPNw0MDPR75ZVXGhQV59y5c+sNHjzYA2DAgAFeQ4cObdq2bVvfJk2aBC1btszy1bFwwOScq1mzZgBs3bqVIUOG0KZNG+Lj402Oyv6Eh0NMDHh6glLGY0yMDAYTwlYs+nVR3fHfjPc8fv64q0Zz/Pxx1/HfjPcsiwRd1iUjLYzhQs+ePc++8sorR3bv3p0UEBBwGSAjI0Pt2rUreerUqX/cKM78/vjjD5ctW7bs/vTTT3+fMmXKTVXxctjknCs4OJhvv/2WjIwMunXrxpgxYzh37pzZYdmV8HA4dAiys41HSczCUdnitMKoTVGN0zPTC5aMzEx3itoU5VAlI8PCwvJWSLtRnPn17dv3rLOzM+3bt0//66+/XG5mfw6fnAF69uzJrl27GDduHAsXLqR79+4lKqQhhBBFyZ1WmJICWl+dVljRE/SJ8ycKLxlZRHtplHXJyNLIXzLyRnHml1syErjpnCLJOUe1atWYPXs2P/74I1FRUSilyMrK4vRpWU5WCFF6tjqtsGH1hoWXjCyivTTKumSkpapXr571999/F5kfbxSntUhyvkaXLl3o3bs3AHPmzMHPz4+PPvpIzqSFEKViq9MKX7r9paNVKlUpWDKyUpXsl25/yeZKRgL06dPHOyQkxPfgwYOVGzRo0Gr27Nnu1/YJDw8/PXfu3IZ+fn7+iYmJla99/0ZxWotFJSPLgrVKRpalHTt2MHz4cLZu3coDDzzAggULuPXWYgcDCiHEdby8jEvZ1/L0NMZiWMqUkpG/LqobtSmq8YnzJ1wbVm+Y8dLtLx0d2WGkXFYspRuVjJQz5xto3bo1P//8MzNmzOCrr77C39+fNWvWmB2WEMIG2fK0wpEdRp4+9s9jO7OnZG899s9jOyUxlz1JzsWoVKkSEydOJCEhgXbt2tGgwU0tUiOEEIBMKxQ3x24LX1ibj48P69evzxsxOGnSJBo2bMjYsWNxdr7hLQ4hhACMRCzJWFhCzpxvQv5CGomJiYwfP56QkBCSkpJMjkwIIYQ9keRcAs7Ozqxdu5aVK1fy+++/07ZtW6ZNm0ZGhtVnFgghhHBAkpxLSClFeHg4SUlJ9O/fn1dffVUKaQghhLAKSc6ldMsttxAXF0dSUhK33XYbWmuWL18uhTSEEOIGzCoZuXr16ppeXl6BHh4egUWVd5w7d269Q4cO3dRym7k+//zzGt9++221knw2P0nOVuLt7Q0YhTSGDRtGq1at+OGHH0yOyr7Z4jrFQgjzZGZmMn78eI8vv/xy7969exM//vjjuoXVbV65cqV7ampqiZLzhg0bamzevLlUxTdAkrPVBQcHs379erKzs7nzzjsZOXIkaWlpZodld2x1nWIhbNHixdRt2ZIgZ2fat2xJ0OLF2GTJyO+//76ap6fnZX9//4wqVaro/v37n169enXt/H2WLVtWZ9euXW6DBw9u5uvr63/+/Hm1efNmtw4dOrQMCAjwCwkJ8UlJSXEBeOWVV2657bbbAlq0aOF///33N9uzZ4/rihUr6i9atKiBr6+v/1dffVXiJC3JuQx0796dhIQEJkyYwJIlS6SQRhmw1XWKy0pcHAQGgrOz8RgXZ3ZEwl4sXkzd6dPxXLQI1/R0WLQI1+nT8SyLBF3WJSMPHz7s2rhx47yRu02aNMk4evRogQIew4YNOxMYGHhxxYoVB3bv3p3k4uLC008/7fHpp5/uT0xMTB4yZMipZ599tjHA3LlzG+7atStp7969ScuXL09p2bJlxuDBg0+OHDnyj927dyf16tXrfEn/LGSecxmpVq0as2bN4uGHH+bMmTMopcjMzCQtLY169cpknXSHYqvrFJeFuDjjS8nSpRASAvHxMHy48V5YmLmxCdv3xhs0XrYMp9BQ43VoKCxbhtPIkTR+8kmsulLYwYMHXR944IEmJ0+edMnIyHBq2rTp5dz3cktGVq9ePa9k5ObNm6vnlowEuHjxotPu3bur9O7du8RJ8VoJCQmVf//996rdu3dvAZCdnU39+vWvALRs2fLSgw8+6N23b9+z4eHhZ621T5Az5zLXqVMnevXqBRiFNHx9fXn//fflTLqUPDxurt2eRUcbiTk0FFxcjMelS21jWUhR8e3bh2tISMG2kBCj3dr7KuuSkU2bNi1wpnzkyJECZ9KF0Vqr5s2bX8rdx969e5N+/PHH3wE2btz4+1NPPXXyt99+c2vbtq3flStXSnzs15LkXI569epFs2bNCAsLo1+/fhw9WqqiLg7NltcptrbkZOOXZX4hIUa7EKXVvDkZ8fEF2+LjjXZr76usS0becccdFw4dOlRl9+7drunp6WrNmjV1BwwYcPbaftWrV89KS0tzBmjVqlX66dOnK3333XfVAC5fvqy2bNlSJSsri/3797v26dPn3IIFC46eP3/eOS0tzblGjRpZ586dK/WykZKcy1FgYCD//e9/mTVrFt999x3+/v6sXr3a7LBskqxTfJWfn/HLMr/4eKPdnslo/fIxYQJHhw0je+NGuHIFNm6EYcPInjABmysZ6eLiwqxZs1J79erVwsfHJ+CBBx44HRwcnH5tv8GDB58aO3asp6+vr39mZibvv//+/kmTJjVp2bKlf0BAgP8PP/xQPTMzUz3yyCPeLVq08A8MDPQfMWLEn+7u7lkDBgw4+8UXX9Qu7YAwKRlpkv379/Pkk08SFRVF165dzQ5H2LCi7jlHR9vvPefc0fr5BwW6uTnGFzQzSkYuXkzdN96g8b59uDZvTsaECRy19v1mR3SjkpGSnCuI5557jgYNGvDMM89IIQ1x0+LijGScnGycMUdG2m9iBuvVRrZFZiRnUTaknnMFl5WVxZ49e/jnP/9J165d2bVrl9khCRsTFga7dkFWlvFoz4kZZLS+sH+SnCsAZ2dnPvnkE+Li4jhw4ADt2rVj6tSpUkjDhsm8Y0NZ3ReW0frC3lmUnJVSvZRSe5RS+5RSkwp530MptVEptU0plaCUutf6odo3pRSDBg0iOTmZgQMH8vrrr3PkyBGzwxIlkHsPeN48SE83HiMjbStBW+PLRVmu4iaj9YW9KzY5K6WcgQVAb8AfCFNK+V/TbTLwoda6LTAIWGjtQB2Fu7s7sbGxJCcn06xZM7TWLF26lIvXLoclKixbn3dsrS8XZbmKm4zWF/bOkjPnjsA+rfUBrXUG8D7Q75o+GqiZ87wWcMx6ITomT09PAH777TdGjBhBUFAQGzduNDkqYQlbn3dsrS8XZX1fODzcGPyVnW08SmIW9sSS5NwYyF+o+EhOW34vA48qpY4AXwJjC9uQUipCKbVFKbXl5MmTJQjX8bRv357vv/8eJycnunfvTkREhBTSqOCKmndcs6ZtzMW11pcLuS8sbsSskpEDBw70qlu3bmsfH5+Aoj773nvv1S6sWpUl/vvf/1b94IMPapXks/lZa0BYGLBca90EuBd4Tyl13ba11jFa62CtdXD9+vWttGv7d8cdd5CQkMDEiRNZunSpFNKo4CIjjXnG+RdtCAuDs2dto3KWtRY1kfvCoiJ6/PHHT61du/b3G/X5z3/+UzshIaFqSba/ZcsWty+++KJckvNRoGm+101y2vIbDnwIoLX+CagCuCOspmrVqsyYMYNffvmF6dOn5xXSOHVKpipWNGFhRgLq3x8qV4a+feGPP4z3bKFyVmFfLoYPv/m45b6w/Vi8dXHdlvNbBjlHObdvOb9l0OKti22yZCRA7969z9evXz+zqPe//fbbat99913tyZMnN/H19fVPTEysnJiYWLlbt24+AQEBfu3bt2+5bdu2KgDvvPNOHR8fn4CWLVv6BwcHt0xPT1fTp0+/9bPPPqvj6+vrv2TJkjol/bOwpCrVr4CPUsobIykPAh65pk8q0ANYrpTyw0jOct26DAQHX1174I033mDGjBnMnTuXsLCw6xaGF+YJCzOSkNZw/pr6OBV9Lm7uHOmxY68ualLS1cbCwyUZ27rFWxfXnb55uueyfsucQjxCiE+Ndx326TBPgCfbP2nVVcLuuuuu84MGDdrt5OTEG2+84R4VFdVwyZIlR8AoGbl169bkc+fOObdt29Z/wIABab/99lvV3JKRWmt69uzZfN26ddVLU5XqrrvuutCzZ8+z999/f9qwYcPOAHTp0qVFTExMSlBQ0OUNGzZUGzVqlMfPP/+897XXXmv0zTff7PX29r5y6tQp5ypVqujnn3/+2JYtW6qtWLGiVP/Ti03OWutMpdQY4GvAGXhHa52olIoCtmit1wL/BJYopcZjDA4bquW6a5m77777WLNmDeHh4axatYq33nqLpk2bFv9BUS48PApfxcoW7rmGhdn/QibCMm/89EbjZf2WOYV6GzUjQ71DWdZvmdPIL0Y2tnZyroglI9PS0py2bdtWfeDAgbfltmVkZCiA4ODg8+Hh4V4DBgw4Ex4efsZa+wQL6zlrrb/EGOiVv+2lfM+TgH9YMzBRvICAAH788UfmzZtHZGQkAQEBLF26lIEDB5odmsA42yxs/We55ypsyb7T+1xDPAqOEAzxCGHf6X1lUjLymWeeOREeHp72+eef14iKisq7TH2jkpETJ04ss/t7WVlZ1KhRI3P37t1J1763atWq1A0bNlRbu3Ztrfbt2/tv3br1uj4lJSuE2ThnZ2fGjRvHzp076dy5M02aNDE7JJFD7rkKe9C8bvOM+NSCIwTjU+NpXre5zZWMtFT16tWz/v77byeAunXrZjdp0iTjnXfeqQOQnZ3NTz/9VBUgMTGxcvfu3S/MmTPnWJ06dTIPHDjgWrNmzazz58+XOrdKcrYTzZo145tvvqFLly4ATJw4kZkzZ5KZWeS4B1EOZC6usHUTukw4OuzTYdkbD27kStYVNh7cyLBPh2VP6DLB5kpGAvTp08c7JCTE9+DBg5UbNGjQavbs2dcNXg4PDz89d+7chn5+fv6JiYmV4+LiDixbtsy9ZcuW/j4+PgEff/xxbYDx48c3adGihb+Pj09Ahw4dznfu3PlS7969z+3du7dqaQeESVUqO5SVlcXDDz/MmjVraN++PUuXLqV169ZmhyWEsAJTSkZuXVz3jZ/eaLzv9D7X5nWbZ0zoMuGote83O6IbVaUq9em/qHicnZ1ZvXo1q1evZsyYMQQHBzNp0iQmT55M5cqVzQ5PCGFjnmz/5GlJxuVLLmvbKaUUAwcOJCkpiUceeYRZs2Zx9GiprkIJIYQoJ5KcrUlrOHcOTp6EClLusV69erz77rvs2bMnr5DGkiVLuHDhgtmhCSHMk52dnS0LI5go588/u6j3JTlbQ2qqsXxSo0bGAsq33GIsDXXnnfDRR8YySybLnf/822+/ERERQVBQEN99953JUQkhTLLr5MmTtSRBmyM7O1udPHmyFrCrqD5yz7k0srNh0iSYNct4DsZE1ipVIC0NfvjB+GnaFD7+GDp0MDdejEIamzZtYvjw4dx11108/vjjzJo1i9q1a5sdmhCinGRmZo44ceLE2ydOnAhETtLMkA3syszMHFFUBxmtXVJaw9ChsGIFVKoEAwfC6NHwj38Yk1r//hveew/mz4fdu42k/e230LVryfZ39ixs2gR//QWurtCsGXTubOyrBC5dukRUVBQzZ84kKCiI3377TZb/FHYlNta4oJWaaqzKFh1tH1PZrDFaW9gArbUpP+3bt9c2beZMrUHratW0Xr++6H6XL2v96KNG33r1tP7jj5vbT0KC1k88obWbm7GN/D8tW2o9Z47Wf/9d4sPYunWr/vrrr7XWWl+5ckX/cbPxCVEBrVx5/X8ZNzej3dZhLJts2u9u+SmfHzlzLomMDOOr+B9/wJo18OCDN+6fmQk9exqXuKOj4YUXLNtPTAyMGnX1knlIiHHGnJFhnEUfO2a0t2wJ69aBt/fNHUdyMixZAjt3wsWLzPjrL15LTWXO66/z2JgxciYtbJaXV+Hrmnt6GovB2DI5c3YQZn0rsOkz5/ff1xq0DgzUOjs7r3llwkrtOdtTq5eV9pztqVcm5Pua/vXXxmeaNtU6M7P4fbz9ts77yh8RoXVycsH3MzK0/vhjrQMCjD4eHlofO2ZZ/Nu2aR0aqq89E08G3dUoXKJ7NWqkU7ZutWx7QlQwSl33z1uD0W7rkDNnh/iRgQAl8eGHxuPIkXn3fGN3xhLxWQQpaSloNClpKUR8FkHszlijb8+ecNttcPgw/Pzzjbd/6JCxbYB582DxYvD1LdjHxcUoGPzf/xr3nlNTr37mRjZsMM7AN26EatXgySfhiy9g0yZ8P/qIzX37MlcpNh8/TkBwMB/Mn2/5n4sQFURRlb9soSKYECCj9ErmxAnjsVWrvKbI9ZFcvHKxQLeLVy4SuT6nQr2TEwQGGs//+OPG21+0yLgUPmgQjBlz4741a8InnxhTtz77DA4eLLrvrl3Qrx9cuGCMjDl61NjXvfdCt27w0EM4ffopYw8cYFdgICFa4/nvfxuD24SwIdHRxhjM/KQimLAlkpxLIvderL56vz41rfC62gXac/vf6F5uejosXWo8f+aZAm/F7YwjcGEgzlHOBC4MJG5nnPFGw4bw8MPG9hcvLnrbL74I58/D//2fMcq8Vq3C+3l54RUfz7qAADqnpMDixTz77LO89tprUkhD2ASpCCZsnSTnkrg1p8Tob7/lNXnUKvx6WV57Vhbs2GE8b9So6G0nJsKpU+DjA5065TXH7YwjckMk83rPIz0ynXm95xG5IfJqgh4yxHjcuLHw7R4+DGvXGpfD58wxzuQxLsd7zfHCaaoTXnO8rl6Gr1ULXn/dCH3hQlJTUnj++efp1KkT27dvLzp+IW5CXJxxQcnZ2XiMi7PetqUimLBlkpxLIizMeHzrrbyz4ege0bi5FLyO5ubiRnSPnOto69YZw0ebNYOOHYve9tmzxmPjxgXOsKM3R7O071JCvUNxcXYh1DuUpX2XEr05Z/u5XxjOnCl8u8uXG7+lBgwwzrSx4D55r17g5YXzoUN8OHIkq1ev5ujRowQHBxMZGUl6erolf1pCFCouzpiHPG+eccFo3jzjtTUTtBC2SpJzSfTpYyTPvXvzfpOEB4UT0ycGz1qeKBSetTyJ6RNDeFC4MfXp1VeNz44alXfWWqiqVY3HiwXvXyefSibEI6RAW4hHCMmnkgv2v/ZGW669e43He+7Jayr2PrmzM9x1V97nBwwYQFJSEo8++ihz5szh+PHjRR+HEMWIjjbu4ISGGhd0QkON13JfWAhJziVTqRI8/7zxfPhwYyAWRoI+NO4Q2VOyOTTukJGYL10yBnb99JNxxvr44zfe9m23GUnxt98gX/Lzc/cjPjW+QNf41Hj83P2MF19+aTxeO6o7V+5Zbm7yx8L75Ln9cz5ft25dli9fzp49e/D29kZrzaJFizh37tyNj0uIayQnGxMH8gsJMdqFcHSSnEtq9GjjJz3dGAF9//1GgszMNC51nzhhnC37+hqjqWvWNKYs1a174+02aGBsLzMT3n47rzmyWyTD1w5n48GNXMm6wsaDGxm+djiR3SKNvrkDwZ54ovDt5u738OG8pmLvk+fvX6dOgT5NmjQBjEIao0ePJjAwkK+//vrGxyZEPn5+EF/w+ybx8Ua7EA7PrAnWNr0ISa7sbK2nTdPa1VUXWOmgUqWCr319td650/Ltfved8blatbROTMxrXpWwSgcsCNBOU510wIIAvSphlfHG5Mk6bznPfIuiFPDBB0afgIC8PisTVmq3aDfNy+T9uEW7XV085Y8/jGNTSutDh4oMNz4+Xvv6+mpADxkyRP/111+WH6twWKtWae3trfWGDcaaOhs2GK9XrTI7sooNWYTEIX5M27FdJOdcf/6p9euva+3jc3VpoqpVte7TR+uvvtI6K+vmtpedrXX//sZ2brnF+K1VWNI9f17rf/3L6OfkpPW6dUVv8/JlrRs2NPp++21e8w1XNZs61ejfp0+xIV+6dElHRkZqZ2dn3aZNG51d1JcEIfJZtcr4vujkZDxakphXrtTa09P4r+bpaR/rZd8MSc6O8SNra1tbdrZRv7ly5dJt59Il6NsXcmsut21rXLL29jYGmG3cCMuWGaUpnZ3hnXdg8OAbbzMqCqZMMS6db9oELVoU3ffzz+GBB4wpYN98c3VgWDG2b9/OqVOn6NmzJ1euXOH06dM0aNDAsmMWohixsRARUXC8pJubY81hlrW1HYRZ3wrs6sy5rFy+bFyyrldPF7pQMGjdufONq2Jdu70ePYzP1a2r9ezZWp8+XbDPgQNaT5yotbOz0e+550oc/muvvabr1Kmjly1bJmfSwio8PQv/b+DpaXZk5Qc5c3aIHzlztgXp6fDRR8aAstOnjbNyLy8YNgzatbu5bV24YIwe//xz43XVqnDHHVCjhjGILT7+6kpmkZEwbVqJa0bv2bOHESNGEB8fz913383ixYvx8vIq0baEAGMWYmG/spS6WrzN3smZs2OQ5OyIsrPh00+NRVS+/bbge66uxlKgTz1lFNQo9a6yWbRoEc899xxaa95++20GDRpU6u0Kx2TPpSAtJcnZMVQyOwBhAicnowb1gw/C/v2QlGScUdeqBR06gLu7FXflxOjRo7n//vsZPXo03jdbc1qIfKKjC7/nLAuXCHsjZ87CFOPHj8fd3Z1//etfuLi4mB2OsCGxscYdl9RUowRkdLTjDAYDOXN2FLIIiSh3WVlZnDhxgsmTJ9OhQwd+y1dARIjiSEEL4QgkOYty5+zsTFxcHJ988gl//vknHTt2ZNKkSVy6dMns0IQQokKwKDkrpXoppfYopfYppSYV0edhpVSSUipRKbXKumEKe/TAAw+QlJTE0KFDmT9/PidOnDA7JCGEqBCKTc5KKWdgAdAb8AfClFL+1/TxAZ4H/qG1DgDGWT9UYY9q167N22+/zd69e/MKaSxcuFAKaQghHJolZ84dgX1a6wNa6wzgfaDfNX2eABZorc8AaK3/tG6Ywt7dmlOPetu2bYwZM4aAgADWrVtnclRCCGEOS5JzY+BwvtdHctryawG0UEr9qJT6WSnVq7ANKaUilFJblFJbTp48WbKIhV1r164dP/74I9WrV+fee+9l8ODB/PXXX2aHJYQQ5cpaA8IqAT7AnUAYsEQpVfvaTlrrGK11sNY6uH79+lbatbA3Xbp0Ydu2bbz44ovExcXRo0cPbnbKX2yssWCFk5PxGBtbJqEKIUSZsGQRkqNA03yvm+S05XcE+EVrfQU4qJTai5Gsf7VKlMLhVK5cmaioKB566CFOnjyJUoorV65w6tQpGjVqdMPPXlscISXFeA0y7UYIYRssOXP+FfBRSnkrpVyBQcDaa/r8B+OsGaWUO8Zl7gPWC1M4qlatWtGjRw8AZs2ahZ+fH0uXLr3hmXRkZMEVpMB4HRlZlpEKIYT1FJuctdaZwBjgayAZ+FBrnaiUilJK9c3p9jXwl1IqCdgITNRay41CYVUPPfQQbdq0YcSIEfTs2ZMDBwr//peaWvjni2q3VXLpXgj7Jct3CpuSnZ3NkiVLmDhxIllZWSxZsoRHHnmkQB9HKI4gdY0dlyzf6RhkhTBhU5ycnHjyySdJSkqiZ8+eNG/e/Lo+0dFGosrP3oojyKV7IeybVKUSNqlJkyZ8+umnea/HjRtH3bp1mTRpEuHhroB9F0dwlEv3QjgqOXMWNi8rK4s///yTKVOmEBwczK+//mr3xRE8PG6uXQhhWyQ5C5vn7OzMqlWr+PTTT/nrr7/o3Lkz//rXv7h47XVfO+IIl+6FcGSSnIXd6Nu3L0lJSQwfPpy33nqLP/+031Vkw8ONwV+enqCU8SiDwYSwHzJaW9il48eP06hRI7TWzJ8/n8GDB1OrVi2zwxKi1GS0tmOQM2dhl3JXEdu2bRvjxo0jICCAL774wuSohBDCMpKchV1r164dP/30E3Xq1OH+++8nPDwcKboihKjoJDkLu9exY0e2bt3Kyy+/zEcffUTPnj1vupCGEEKUJ5nnLByCq6srU6ZMYcCAAQUKaZw8eTKvlrQQQlQUcuYsHEpgYCChoaEA/Pvf/8bPz48lS5bImbQQokKR5Cwc1sMPP0z79u2JiIigR48e7N+/3+yQhBACkOQsHNhtt93G+vXriYmJYevWrQQFBbFy5UqzwxJCCEnOwrEppXjiiSdISkrinnvuoUWLFmaHJIQQkpxvRuzOWLzmeOE01QmvOV7E7pQCuvaicePGfPLJJ3Ts2BGAsWPHMmXKFC5fvmxyZEIIRyTJ2UKxO2OJ+CyClLQUNJqUtBQiPouQBG2HsrKySEtLIyoqivbt2/PLL7+YHVKpxcYada6dnIzHWPlnK0SFJsnZQpHrI7l4pWAhhYtXLhK5Xgro2htnZ2dWrFjB559/TlpaGl26dGHChAlcuHDB7NBKJDYWIiIgJQW0Nh4jIiRBC1GRSXK2UGpa4YVyi2oXtu++++4jMTGRkSNHsmTJEptdWSwyEq4t0HXxotEuhKiYJDlbyKNW4YVyi2oX9qFmzZosXLiQffv24eXlhdaauXPncvbsWbNDs1hqEd8fi2oXQphPkrOFontEU9m5MtVdq6NQVHetTmXnykT3kAK6jqBBgwYAbN++nfHjxxMQEMDatWtNjsoyHkV8fyyqXQhhPknOFnLCiVuq3cLaQWu5PPkyawet5ZZqt+Akf4QOpW3btvzyyy/Uq1ePfv36MWjQoApfNzo6GtzcCra5uRntQoiKSTKLhaI3R/PuA+8S6h2Ki7MLod6hvPvAu0Rvlt9wjiY4OJgtW7Ywbdo0PvnkkwpfSCM8HGJiwNMTlDIeY2KMdiFExWRTydnMecbJp5IJ8Qgp0BbiEULyqeRyi0FUHK6urkyePJlt27Yxd+7cvEIaR44cMTu0QoWHw6FDkJ1tPJqVmGVKlxCWsZnkbPY8Yz93P+JT4wu0xafG4+fuVy77FxWTv78/d955J2AU0vD39+ett94iOzvb3MAqIJnSJYTlbCY5mz3POLJbJMPXDmfjwY1cybrCxoMbGb52OJHdZD6KMAwaNIhOnToxevRoQkND+f33380OqUKRKV1CWM5m6jmbPc84LCgMgLHrxpJ8Khk/dz+iu0fntQvh7e3NN998w/Lly5kwYQKtWrUiJiaGxx57zOzQKgSZ0iWE5WwmOXvU8iAlLaXQ9vISFhQmyVjckFKKYcOG0atXL55++mn8/IzbHlprlFImR2cuDw/jUnZh7UKIgmzmsnZ0j2jcXArOB3FzcZN5xqJCatSoER999BHBwcEAjBkzhhdffNGhC2nIlC4hLGczyTk8KJyYPjF41vJEofCs5UlMnxjCg+x3PohUwbIPWVlZXLhwgVdeeYW2bdvy008/mR2SKWRKlxCWU2bNzwwODtZbtmwxZd+2IHd0ev5BcG4ubnb/hcSerVu3jieffJIjR47w9NNPEx0dTbVq1cwOS9gYpdRWrXWw2XGIsmUzZ86OxuzR6cL6evfuTWJiIqNHj+add97h1KlTZockhKigLErOSqleSqk9Sql9SqlJN+g3QCmllVLyra6UzB6dLspGjRo1mD9/Pvv378fT0xOtNbNnz+bMmTNmhyaEqECKTc5KKWdgAdAb8AfClFL+hfSrATwD2H5l+gpAqmDZt/r16wNGIY2JEyfi7+/PJ598YnJUQoiKwpIz547APq31Aa11BvA+0K+QftOA14F0K8bnsGR0umNo27Yt//vf/2jYsCH9+/dn4MCBnDhxwuywhBAmsyQ5NwYO53t9JKctj1KqHdBUa/3FjTaklIpQSm1RSm2x1cL15cURR6c7qnbt2vG///2PV199lc8++4y77767QhfSEEKUvVIvQqKUcgLeAIYW11drHQPEgDFau7T7tnfhQeGSjB2Ei4sLzz//PA8++CB//vknSikyMjL4448/aNq0qdnhCSHKmSVnzkeB/L8dmuS05aoBBALfK6UOAZ2BtTIozP7E7YwjcGEgzlHOBC4MJG5nnNkh2R1fX19uv/124GohjQULFkghDSEcjCXJ+VfARynlrZRyBQYBa3Pf1Fqnaa3dtdZeWmsv4Gegr9ZaJjHbkbidcURuiGRe73mkR6Yzr/c8IjdESoIuQ4888ghdu3ZlzJgx3HHHHezZs8fskIQQ5aTY5Ky1zgTGAF8DycCHWutEpVSUUqpvWQcoKobozdEs7buUUO9QXJxdCPUOZWnfpURvlgFqZcXLy4uvvvqK5cuXk5iYSOvWrXn33XfNDksIUQ4smuestf5Sa91Ca32b1jo6p+0lrfXaQvreKWfN9if5VDIhHiEF2kI8Qkg+lWxSRI5BKcWQIUNISkqiX79+BAQEANjEgLHYWPDyAicn41HqNgthOVkhTFjEz92P+NT4Am3xqfH4ufuZFJFjadiwIR988EFeIY3Ro0fzwgsvkJ5eMWcuxsZCRIRRhUpr4zEiQhK0EJaS5CwsEtktkuFrh7Px4EauZF1h48GNDF87nMhuspxoecvOziYjI4Pp06fTpk0b4uPji/9QOYuMhIsFV5/l4kWjXQhRPEnOwiJhQWFEd49m7LqxVImuwth1Y4nuHi31rU3g5OTE0qVL+eabb0hPT6dbt26MGTOGc+fOmR1antQiVpktql0IUZBUpRLChp0/f57IyEiWL19OQkICnp6eZocEGPeYU1Kub/f0hEOHyjsa+yJVqRyDnDkLYW0nTsD06RAWBv36wWOPweLFUAZnttWrV+fNN98sUEhj1qxZnD592ur7uhnR0eBWcPVZ3NyMdiFE8eTMWQhrOXAAnn8e1qyBzMzr369RA4YOhWnToFatMglh+/btdOjQgXr16rFgwQIGDBhQJvuxRGyscY85NRU8PIzEHC4L3pWanDk7BknOQljD1q3QqxecOmXMHerXDx54wEjIf/5pZKrNm42+gYHwzTfQqFGZhLJ9+3aGDx/Ob7/9Rv/+/Zk/fz6NymhfovxJcnYMkpyFKK2DB6FTJzh5Eu65B95+G5o0ub7fjh0waBDs3g1t2xrJulq1MgkpMzOTWbNmMWXKFHx8fEhISEApVSb7EuVLkrNjkHvOQpTWSy8Zifnuu+GzzwpPzACtW8OmTdC8OWzbBjExZRZSpUqVeO6550hISGDhwoV5hTRSChullY8sHCJExSDJWYjSOHkSPvwQlDIGfbm4ABC7MxavOV44TXXCa44XsTtzslz9+jBzpvH8rbegjAtatGjRgm7dugFXC2nMnTuXrKys6/rKwiFCVBySnIUojRUrICMD7rvPONXESMwRn0WQkpaCRpOSlkLEZxFXE/T99xtn17//Dj/8UG6hPvroo9x+++0888wzdOvWjeTkgkuvysIhQlQckpyFKI3EROOxT5+8psj1kVy8UjDLXbxykcj1OVmuUiUjmQMkJZVHlAB4eHjw5Zdf8t5777Fnzx7atGnDsmXL8t6XhUOEqDgkOQtRGrmnmtWr5zWlphWezQq05/a/cKGsIiuUUopHH32U5ORkBgwYQOvWrQGjkIaHR+GfKapdCFF2JDkL0xR5X9aW5M5XPnEir8mjVuHZrED78ePGY+3aZRTYjd1yyy2sWrWKdu3aATBq1CiCgiZRteqlAv1k4RAhzGF3yTluZxyBCwNxjnImcGEgcTvjzA5JFKLY+7K24vbbjcf33jNGUQHRPaJxcym4PJabixvRPXKyXFoafPqp8TxnsJaZsrOzycrK4vPPX6dWrdY0aLAJpYylNmNiZOEQIcxgV8k5bmcckRsimdd7HumR6czrPY/IDZGSoCugYu/L2oqHHjJGYG/fDjnVocKDwonpE4NnLU8UCs9ansT0iSE8KCfLLV9uXM4ODQU/80tuOjk5sWTJEr777juqVs3kjz/uYNSop0hI+FsSsxAmsatFSAIXBjKv9zxCvUPz2jYe3MjYdWPZNXqXVfclSsdpqhOa6//tKRTZU8p2epHVTZ5sXPv18DASdNOmRff973+hZ0+4dAk+/hj69y+/OC1w4cIFJk+ezLJly0hISMBDbjhXOLIIiWOwqzPn5FPJhHiEFGgL8Qgh+VRyEZ8QZrHovqyteOEFY4Ww1FTo3Nm4xJ2eXrDPmTMwa9bVxPz44/Dgg+bEewPVqlVj9uzZ7N+/Hw8PD7TWzJw5k7/++svs0IRwKHaVnP3c/YhPLVh4Pj41Hj938y8dioKKvS9rS9zc4MsvjfvHx47B4MHGPObHHoOnnjIufTduDM8+ayTm4cNh0SJj4ZIKql69egDs2LGDF154AT8/Pz788EPMutImhMPRWpvy0759e21tqxJWae853nrDgQ06IzNDbziwQXvP8darElZZfV+i9FYmrNSesz21ellpz9meemXCSrNDKp3Ll7VeskTrtm21NoaHFfy5+26tP/1U6+xssyO9KTt27NDBwcEa0P369dNHjx41OySHBmzRJv3elp/y+7Gre85gDAqL3hxN8qlk/Nz9iOwWSVhQmNX3I0SRtIYtW2DnTmPgV61a0KUL+PiYHVmJZWZmMmfOHF588UWaN28uhTRMJPecHYPdJWchRNnZt28fJ06cICQkhIyMDI4ePYq3t7fZYTkUSc6Owa7uOQshylbz5s0JCTEGXc6YMYPAwEBmz55daCENIUTJSXIWQpTI0KFDCQ0NZcKECfzjH/8gMXedcSFEqUlyFkKUSJMmTfjss89YtWoV+/fvp23btrzzzjtmhwVIXWph+yQ5C5tnF2t02yilFGFhYSQlJfHwww/Tpk0bwJgFYhapSy3sgQwIEzYtd43u/EuBurm4FVwuU5S7J598kpo1azJ16lTc3ArOZycx0fi5eNEYyd65MzRqZLV9e3kZCflanp5w6JDVdmMaGRDmGOTMWdg0u1mj245kZxvLr/773/+mVatWfP/995CZCatWQUgIBAbC//0fDBtmLF/q4QEPPwybNlll/1KXWtgDSc7CpllUO1mUKycnJxYvXsyGDRsACA0N5UlPT9LCw+HHH6FmTWPp0sceg7vuMq49f/QR3HEHTJwI2aVbW13qUgt7IMlZ2DS7WqPbzoSGhpLwv//x7K238uGxY/zt7g6LF8PRo7BmDaxYAd98Y1yDnjwZKlWCf//bSNClEB1trKian9SlFrbGouSslOqllNqjlNqnlJpUyPsTlFJJSqkEpdR6pZSn9UMV4np2tUa3HXJ74w1mHjvGgVtvpemvv6KfeILX5s/n5MmTVzs1bgzTpsFnnxkJ+o03jKRdQuHhRh1qT0+kLrWwXcWt7wk4A/uBZoArsAPwv6ZPKOCW83wU8EFx2y2LtbWFY7K7NbrtRXq61u7uWoPWP/ygtdZ6+/bt2sXFRbu7u+tVq1bp7GvXGZ82zeh///0mBGwbkLW1HeLHkjPnjsA+rfUBrXUG8D7Q75oEv1FrnTsq52egSWm/NAhhqfCgcA6NO0T2lGwOjTsko7QritWr4dQpaNvWqNgFtG7dmlfef4UL1S7wyCOPULNVTeZ/O//qZ558Elxd4Ysv7GNotRAlZElybgwczvf6SE5bUYYD6wp7QykVoZTaopTaUuCylhBlSOZBm2T9euNxyJC88phxO+NYdHgRa79by8x/z+TKvitMGDyBVQmrjL7168N99xmDxH74waTAhTCfVQeEKaUeBYKBmYW9r7WO0VoHa62D69evb81dC1Go3HnQKWkpaDQpaSlEfBYhCbo8nD1rPDa++l0+enM0S/supWfznjz7z2dJ3JXIrHmzeDX+VTIyMjhw4MDV/rmfF8IBWZKcjwJN871uktNWgFKqJxAJ9NVaX7ZOeEKUjsyDNlHVqsbjxat//smnkgnxCMl7fdtttzHywZEkn0rOK6Qx65dfyMz/eSEckCXJ+VfARynlrZRyBQYBa/N3UEq1BRZjJOY/rR+mECUj86BN1LKl8fjll3lNfu5+xKfGF+gWnxqPn7sfw4YN466ePXn211/pCux0cSnHYIWoWIpNzlrrTGAM8DWQDHyotU5USkUppfrmdJsJVAc+UkptV0qtLWJzQpQrmQdtomHDjMoTH38MJ04AENktkuFrh7Px4EauZF1h48GNDF87nMhukTRu3Jj/DB3K+8AhZ2faRUTw9ttvm3sMQpikkiWdtNZfAl9e0/ZSvuc9rRyXEFYR3SO60LW3ZR50OWjaFPr1g08+gbFj4YMPCAsKA2DsurEkn0rGz92P6O7RRvvp06jnn+f/gB4vv8w/f/+d4GBjCWmtNSpnUJkQjkAKXwi7F7szlsj1kaSmpeJRy4PoHtEy3aq8JCVBly7w99/GetoLFkC9etf327MHBg6EnTuhVStjmc/q1fPeHjFiBDVr1mTatGlUq1atHA+g4pHCF45BkrMQomz98AP06QPnzkGVKjBoEPTtCzVqGJe733vv6opgvr7w3XcFRnhnZ2czduxYFi5cSLNmzViyZAndu3c36WDMJ8nZMUhyFkKUvV27jDWzv/qq8PerVIFHH4XXX4e6dQvtsmnTJkaMGMHvv//OiBEjmDlzJrVr1y67mCsoSc6OQZKzEKL87N8PS5YY9ZwvXDDqOd9+OwwdCnXqFPvxS5cu8fLLL7NkyRJ27NhB06ZNi/2MvZHk7BgkOQvhgGz9PvzZs2epXbs2WmumT5/OiBEjuOWWW8wOq1xIcnYMUjJSCAdjD6um5V7OTkhIYOrUqfj5+bFy5UrMOtkQwtokOQvhYOxp1bTWrVuzbds2WrRowWOPPcb999/P4cOHi/+gEBWcJGchHIy9rZrm7+9PfHw8c+bM4fvvv6dXr15kZ2ebHZYQpSLJWQgHY4+rpjk7O/PMM8+wa9cu3n77bZycnLh8+TL79u0zOzQhSkSScylIKUJhi6J7ROPm4lagzV5WTfP29qZLly4AzJgxg6CgIGbMmEFmZqbJkQlxcyQ5l5A9DKoRjik8KJyYPjF41vJEofCs5UlMnxibGq1tiREjRtC7d2+ee+45OnXqxI4dO8wOSQiLyVSqEvKa40VKWsp17Z61PDk07lD5BySEuI7Wmo8//pinnnqK06dPs2DBAiIiIswOq1RkKpVjkDPnErK3QTVC2COlFA899BBJSUk8+uijdOzYEUCmXIkKT5JzCdnjoBoh7FW9evVYtmwZbdq0AYxL3uPGjeP8+fPmBiZEESQ5l5A9D6oRwp5lZ2fj5ubGm2++SVBQEN9++63ZIQlxHUnOJeQog2qEsDdOTk7MmzePTZs24erqyt13383w4cM5c+aM2aEJkUcGhAkhHFZ6ejpTp04lJiaGHTt20KRJE7NDKpYMCHMMcuYshHBYVapUYfr06Rw4cIAmTZqgtWbatGmcOHHC7NCEg5PkLIRweLVq1QJg586dREdH4+/vz7vvviujuoVpJDkLYWWycpztatWqFdu3b8ff35+hQ4fSu3dvUlKuX89AiLImyVkIK5KV42yfr68vmzZtYt68ecTHx3PvvfdKIQ1R7mRAmBBWJCvH2ZeUlBSOHz9O586duXz5MikpKbRo0cLUmGRAmGOQM2chrEhWjrMvnp6edO7cGTAKabRq1Yrp06dz5coVkyMT9k6Ss7Br5X3/V1aOs19PPPEEffr04YUXXqBTp05s27bN7JCEHZPkLOyWGfd/ZeU4+9WwYUM++ugjPv74Y44dO0aHDh1YvHix2WEJOyXJWdityPWRXLxysUDbxSsXiVwfWWb7lJXj7F///v1JTk5myJAhdOrUCUAGjAmrkwFhwm45TXVCc/2/b4Uie4r8MhXWM3ToUKpXr8706dOpUaNGme5LBoQ5BjlzFnZL7v+K8pCdnU2tWrVYuHAhgYGBfP3112aHJOyAJGdht+T+rygPTk5OvPnmm8THx+Pm5kavXr0YMmQIp0+fNjs0YcMkOQu7Jfd/RXnq2rUr27dvZ/LkyXz55ZdcunTJ7JCEDZN7zkIIYWXnzp2jRo0aaK2JiooiIiKCRo0aWWXbcs/ZMVh05qyU6qWU2qOU2qeUmlTI+5WVUh/kvP+LUsrL6pHaOVmPWQj7kTsobOfOnUyfPh1/f3+WLVsmhTSExYpNzkopZ2AB0BvwB8KUUv7XdBsOnNFaNwdmA69bO1B7JusxC2GfWrVqRUJCAkFBQTz++OPcc889HDx40OywhA2w5My5I7BPa31Aa50BvA/0u6ZPP+DdnOergR5KKWW9MO2bGfNxhRDlo0WLFnz//fcsXLiQn376ifvuu0/mRYtiVbKgT2PgcL7XR4BORfXRWmcqpdKAesCp/J2UUhFABICHh0xnySXrMQth35ycnBg1ahT33Xcfx48fx8lJxuKKGyvXfyFa6xitdbDWOrh+/frluesKTebjCuEYPDw88lYVE+JGLEnOR4Gm+V43yWkrtI9SqhJQC/jLGgE6ApmPK4QQIj9LkvOvgI9Sylsp5QoMAtZe02ctMCTn+UPABi3DEi0m83GFEELkV+w955x7yGOArwFn4B2tdaJSKgrYorVeCywF3lNK7QNOYyRwcRPCg8IlGQshhAAsGxCG1vpL4Mtr2l7K9zwdGGjd0IQQQgjHJEMGhRBCiApGkrMQQghRwUhyFkIIISoYSc5CCCFEBWNaVSql1EkgpYQfd+ea1cccgByzY5BjdgylOWZPrbWs4mTnTEvOpaGU2uJoJdPkmB2DHLNjcMRjFjdHLmsLIYQQFYwkZyGEEKKCsdXkHGN2ACaQY3YMcsyOwRGPWdwEm7znLIQQQtgzWz1zFkIIIeyWJGchhBCigqnQyVkp1UsptUcptU8pNamQ9ysrpT7Ief8XpZSXCWFalQXHPEEplaSUSlBKrVdKeZoRpzUVd8z5+g1QSmmllM1PQbHkmJVSD+f8XScqpVaVd4zWZsG/bQ+l1Eal1Lacf9/3mhGntSil3lFK/amU2lXE+0opNTfnzyNBKdWuvGMUFZjWukL+YJSn3A80A1yBHYD/NX1GA4tyng8CPjA77nI45lDALef5KEc45px+NYBNwM9AsNlxl8Pfsw+wDaiT8/oWs+Muh2OOAUblPPcHDpkddymP+XagHbCriPfvBdYBCugM/GJ2zPJTcX4q8plzR2Cf1vqA1joDeB/od02ffsC7Oc9XAz2UUqocY7S2Yo9Za71Ra30x5+XPQJNyjtHaLPl7BpgGvA6kl2dwZcSSY34CWKC1PgOgtf6znGO0NkuOWQM1c57XAo6VY3xWp7XehFHfvij9gBXa8DNQWynVqHyiExVdRU7OjYHD+V4fyWkrtI/WOhNIA+qVS3Rlw5Jjzm84xjdvW1bsMedc7muqtf6iPAMrQ5b8PbcAWiilflRK/ayU6lVu0ZUNS475ZeBRpdQRjPrxY8snNNPc7P934UAqmR2AKBml1KNAMHCH2bGUJaWUE/AGMNTkUMpbJYxL23diXB3ZpJQK0lqfNTOoMhYGLNdaz1JKdQHeU0oFaq2zzQ5MiPJWkc+cjwJN871uktNWaB+lVCWMS2F/lUt0ZcOSY0Yp1ROIBPpqrS+XU2xlpbhjrgEEAt8rpQ5h3Jtba+ODwiz5ez4CrNVaX9FaHwT2YiRrW2XJMQ8HPgTQWv8EVMEoEGGvLPr/LhxTRU7OvwI+SilvpZQrxoCvtdf0WQsMyXn+ELBBa23Lq6oUe8xKqbbAYozEbOv3IaGYY9Zap2mt3bXWXlprL4z77H211lvMCdcqLPm3/R+Ms2aUUu4Yl7kPlGOM1mbJMacCPQCUUn4YyflkuUZZvtYCg3NGbXcG0rTWx80OSlQMFfayttY6Uyk1BvgaY6TnO1rrRKVUFLBFa70WWIpx6WsfxsCLQeZFXHoWHvNMoDrwUc7Yt1StdV/Tgi4lC4/Zrlh4zF8DdyulkoAsYKLW2mavCll4zP8EliilxmMMDhtqy1+2lVJxGF+w3HPuo08BXAC01osw7qvfC+wDLgLDzIlUVESyfKcQQghRwVTky9pCCCGEQ5LkLIQQQlQwkpyFEEKICkaSsxBCCFHBSHIWQgghKhhJzkIIIUQFI8lZCCGEqGD+Hzg6r8gdmbTBAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -773,14 +764,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "persistent-combine", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0.dev0+4749eb5
qiskit-aer0.11.0
qiskit-nature0.5.0
qiskit-finance0.4.0
qiskit-optimization0.5.0
qiskit-machine-learning0.5.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Mar 28 2022 06:16:26
OSDarwin
CPUs2
Memory (Gb)12.0
Thu Sep 15 14:08:35 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Sun Oct 30 14:46:07 2022 GMT Standard Time
" ], "text/plain": [ "" @@ -827,7 +818,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.7.9" } }, "nbformat": 4, From 8dbbff566787012fd3a4f2265fc6be553c85072a Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Sun, 30 Oct 2022 15:42:11 +0000 Subject: [PATCH 93/96] update 11 --- ...uantum_convolutional_neural_networks.ipynb | 65 ++++++++----------- 1 file changed, 27 insertions(+), 38 deletions(-) diff --git a/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb b/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb index 38c3f0d40..f03991312 100644 --- a/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb +++ b/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb @@ -47,14 +47,13 @@ "import numpy as np\n", "from IPython.display import clear_output\n", "from qiskit import QuantumCircuit\n", - "from qiskit_aer import Aer\n", "from qiskit.algorithms.optimizers import COBYLA\n", "from qiskit.circuit import ParameterVector\n", "from qiskit.circuit.library import ZFeatureMap\n", - "from qiskit.opflow import AerPauliExpectation, PauliSumOp\n", - "from qiskit.utils import QuantumInstance, algorithm_globals\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit.utils import algorithm_globals\n", "from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier\n", - "from qiskit_machine_learning.neural_networks import TwoLayerQNN\n", + "from qiskit_machine_learning.neural_networks import EstimatorQNN\n", "from sklearn.model_selection import train_test_split\n", "\n", "algorithm_globals.random_seed = 12345" @@ -244,7 +243,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -297,7 +296,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -373,7 +372,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -421,7 +420,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -577,7 +576,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -636,7 +635,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -709,8 +708,6 @@ }, "outputs": [], "source": [ - "quantum_instance = QuantumInstance(Aer.get_backend(\"aer_simulator\"), shots=1024)\n", - "\n", "feature_map = ZFeatureMap(8)\n", "\n", "ansatz = QuantumCircuit(8, name=\"Ansatz\")\n", @@ -738,15 +735,13 @@ "circuit.compose(feature_map, range(8), inplace=True)\n", "circuit.compose(ansatz, range(8), inplace=True)\n", "\n", - "observable = PauliSumOp.from_list([(\"Z\" + \"I\" * 7, 1)])\n", + "observable = SparsePauliOp.from_list([(\"Z\" + \"I\" * 7, 1)])\n", "\n", - "qnn = TwoLayerQNN(\n", - " num_qubits=8,\n", - " feature_map=feature_map,\n", - " ansatz=ansatz,\n", - " observable=observable,\n", - " exp_val=AerPauliExpectation(),\n", - " quantum_instance=quantum_instance,\n", + "qnn = EstimatorQNN(\n", + " circuit=circuit,\n", + " observables=observable,\n", + " input_params=feature_map.parameters,\n", + " weight_params=ansatz.parameters,\n", ")" ] }, @@ -760,7 +755,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABMAAAAMlCAYAAACVZI8pAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAACtmUlEQVR4nOzdeZyVVeE/8M/MsAoCIiqKW4hQkKBQiWYB5oK7lWtFSiQE5C9FTVMxTeVriGZWrpVkGRZIpYVbCqNGLrhTKbkiioq7KIjMzO8PcnJklGGdO0/v9+t1XzDnee45584995w7n/s8zy2rqampCQAAAAAUVHljdwAAAAAA1iYBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNCaNXYHGtujtyZvvtjYvYC1Y/2Nkx671i0z5gGgtNS3Xq+I9Rxg3VuV+ZrS8T8fgL35YvLavMbuBaw7xjwANH3WcwBYOU6BBAAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIVW0gFYdXV1JkyYkG233TatWrVKnz59UllZmR49emT48OFrte2q6qpc9ucTctDpG2X/U9fPGb/6cl5/66W12iY0JmMeAJo+6zkA1K+kA7Bhw4blzDPPzIgRI3L99dfnkEMOyeGHH54nnngi/fr1W6ttXz39nMz8x5/yk6PvyqRT5iVJfjhpyFptExqTMQ8ATZ/1HADqV7IB2KRJkzJx4sRce+21Of744zNo0KCccsop2WmnnbJ06dL07dt3rbY/7c7LcuigE7Pphl3TpnX7HLXP+Nzz6A154dWn12q70FiMeQBo+qznAFC/kg3Axo0bl8GDB2fAgAF1yrt165bmzZund+/eSZKnnnoqAwYMSPfu3bPddtvl9ttvX+22Fy56LS++NjfbdvnvUWabddom67Vql8efe3C164dSY8wDQNNnPQeAD1eSAdi8efMye/bsHHzwwcttmzt3bnr16pWWLVsmSUaMGJFDDz00c+bMyaWXXprDDjssS5YsWWEbZWVlKSsrS2XljOW2vf3Om0mSNq3b1ylv26pD3l78xio8ImgclZUzase6MQ8Apam+9XpFN+s5wLq3KvO129q9rYySDcCSpHPnznXKFy1alMrKytrTH1966aXccccdGTZsWJJk5513zmabbZbp06evVvvrtVw/SfLWotfrlC9c/FrWa9VuteqGUmTMA0DTZz0HgA9XkgFYp06dkiRz5sypUz5+/PjMnz+/9gL4c+fOzSabbFJ7NFiSfOxjH8vTT6/4Ggc1NTWpqanJgAEDl9vWtnWHbNxhyzz27H21ZfNffiJvL34jXTftvSoPCRrFgAEDa8e6MQ8Apam+9XpFN+s5wLq3KvO129q5DRgwYLlLZq1Is7U0LlZL165d07t374wbNy4dO3ZMly5dMmXKlEybNi1J1vo3QCbJ3v2H53czfpg+3Qal3Xob5vJpJ+ZT3fdM545br/W2oTEY8wDQ9FnPAaB+JRmAlZeXZ/LkyRkxYkRGjhyZDTfcMEcccURGjx6dk08+ufYC+FtuuWVeeOGFvPPOO7VHgT355JPZaqutVrsPhw06KQvffjXf/vGn827VO+m77e456Su/We16oVQZ8wDQ9FnPAaB+ZTU1NTWN3YmGGjJkSB588ME89NBDtWV77LFHDjzwwIwaNSozZ87MQQcdlKeeeiotWrRoUJ2zrk5em7e2egyNq8PmyacOq1tmzANAaalvvV4R6znAurcq8zVrx8CBA5MkM2bMaPB9SvIIsA8za9as9O/fv07ZJZdckiOPPDIXXHBBWrRokUmTJjU4/AIAAACg+JpMALZw4cLMmTMno0aNqlPetWvX3HbbbY3UKwAAAABKXZMJwNq2bZuqqqrG7gYAAAAATUx5Y3cAAAAAANYmARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKGVdABWXV2dCRMmZNttt02rVq3Sp0+fVFZWpkePHhk+fHhjdw8AAACAJqBZY3fgowwbNixTp07N2LFj069fv8ycOTOHH354FixYkDFjxqy1dqc/cHWunfmzPPHcg1n87tu58YdL11pbUAqMeQBo+qznAPDhSjYAmzRpUiZOnJgZM2ZkwIABSZJBgwblvvvuy9SpU9O3b9+11nbb1htkv51GZcm7i/KjaxxpRvEZ8wDQ9FnPAeDDlewpkOPGjcvgwYNrw6/3dOvWLc2bN0/v3r2TJKeddlq6d++e8vLyTJkyZY20/ekee2bXHQ7Ppht2XSP1Qakz5gGg6bOeA8CHK8kAbN68eZk9e3YOPvjg5bbNnTs3vXr1SsuWLZMkgwcPzg033JDPf/7z67qbAAAAADQBJRuAJUnnzp3rlC9atCiVlZV1Tn/ceeed07Xryn/KVVZWlrKyslRWzlitvkIpq6ycUTvWjXkAKE31rdcrulnPAda9VZmv3dbOrbKyMpWVlSv1/JVkANapU6ckyZw5c+qUjx8/PvPnz0+/fv0ao1sAAAAANEEleRH8rl27pnfv3hk3blw6duyYLl26ZMqUKZk2bVqSrJEArKamJkky6+rktXmrXR2UpAEDBqbm4po6ZcY8AJSW+tbrFbGeA6x7qzJfs3YMHDhwpe9TkkeAlZeXZ/LkyenVq1dGjhyZoUOHplOnThk9enQqKipqL4C/tlRVV2XJu4vz7tIlSZIl7y7OkncX14ZmUDTGPAA0fdZzAPhwJXkEWJJ0794906dPr1M2ZMiQ9OzZM61bt16rbf/13l9nwu+H1v68z8nL2vv1955M545br9W2oTEY8wDQ9FnPAeDDlWwAVp9Zs2alf//+dcrGjh2bK664IgsWLMjDDz+cY445JpWVldlmm21WuZ09P31k9vz0kavZW2g6jHkAaPqs5wDw4UryFMj6LFy4MHPmzKnzDZBJcuaZZ2bevHl555138vLLL2fevHmrFX4BAAAAUCxN5giwtm3bpqqqqrG7AQAAAEAT02SOAAMAAACAVSEAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAotJIOwKqrqzNhwoRsu+22adWqVfr06ZPKysr06NEjw4cPb+zuAQAAANAENGvsDnyUYcOGZerUqRk7dmz69euXmTNn5vDDD8+CBQsyZsyYtdbu5X85MXf9689Z8NozadWybXb8+D755j4/TLv1Oq61NqExGfMA0PRZzwHgw5XsEWCTJk3KxIkTc+211+b444/PoEGDcsopp2SnnXbK0qVL07dv37XWdnl5RU46/De55oyXc+mxD+al1+fl3N8dudbag8ZmzANA02c9B4APV7IB2Lhx4zJ48OAMGDCgTnm3bt3SvHnz9O7dO6+++mr23XffdO/ePX369Mkee+yRxx57bLXbHrbXuHTrskOaVTRPh7Yb5Yu7fCcPPT5jteuFUmXMA0DTZz0HgA9XkgHYvHnzMnv27Bx88MHLbZs7d2569eqVli1bpqysLMccc0zmzJmTBx98MPvuu2+GDh26xvtz/2O3pOtmfdZ4vVCqjHkAaPqs5wDwXyUbgCVJ586d65QvWrQolZWVtac/dujQIbvttlvt9p133jlPPvlkg9ooKytLWVlZKitnfOR+tz90Tf585yUZtf+PV+IRQGmorJxRO9aNeQAoTfWt1yu6Wc8B1r1Vma/d1s6tsrIylZWVK/X8lWQA1qlTpyTJnDlz6pSPHz8+8+fPT79+/eq93wUXXJADDzxwjfWj8sHJ+dGUo/KDI6/NtpuvvWuOQakw5gGg6bOeA8DySvJbILt27ZrevXtn3Lhx6dixY7p06ZIpU6Zk2rRpSVJvAHbGGWfksccey6233tqgNmpqapIks65OXpu3/PYb7rkil113XH4w9Lp88mOfXfUHA41owICBqbm4pk6ZMQ8ApaW+9XpFrOcA696qzNesHQMHDlzp+5TkEWDl5eWZPHlyevXqlZEjR2bo0KHp1KlTRo8enYqKivTu3bvO/meddVb+/Oc/54Ybbsh666232u3/4Y4Lc9mfj8//HXWjNw78TzDmAaDps54DwIcrySPAkqR79+6ZPn16nbIhQ4akZ8+ead26dW3ZGWeckWnTpuXmm29Ohw4d1kjbF/3pO6kob5bjLxlUp/y6sxeukfqh1BjzAND0Wc8B4MOVbABWn1mzZqV///61P//jH//I6aefnm222abO4W8PPPDAarVz87kOaeR/izEPAE2f9RwAPlyTCcAWLlyYOXPmZNSoUbVlvXr1qr2WFwAAAADUp8kEYG3btk1VVVVjdwMAAACAJqYkL4IPAAAAAGuKAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUWrPG7sBHqa6uzvnnn59LL700zzzzTHr06JELL7www4cPz4ABA3LZZZettbZ/ef0pmX7/b/PG2y+nRbNW2a7r5/Ot/c7PxhtsudbahMZkzANA02c9B4D6lfQRYMOGDcuZZ56ZESNG5Prrr88hhxySww8/PE888UT69eu3Vtverd+QXHLsA/nTWW/k1yc/lY07bJmzrzpsrbYJjcmYB4Cmz3oOAPUr2SPAJk2alIkTJ2bGjBkZMGBAkmTQoEG57777MnXq1PTt23ettr/lxh+v/X9NalJWVp5nFjy6VtuExmTMA0DTZz0HgPqVbAA2bty4DB48uDb8ek+3bt3SvHnz9O7dO0ly4IEH5oknnkhFRUWaN2+ecePGZbfddlsjfbj1/t/mx1NH5u3Fb6SivFm+td/5a6ReKFXGPAA0fdZzAFheSQZg8+bNy+zZs3Pssccut23u3Lnp1atXWrZsmSSZOHFiOnTokCS5//77M3DgwLzyyiupqKhY7X7susNXsusOX8krbzyf6+/5RT626XarXSeUMmMeAJo+6zkALK8krwE2b968JEnnzp3rlC9atCiVlZV1Tn98L/xKktdffz1lZWWpqalZYRtlZWUpKytLZeWMFe7bsV3n7L3jUTn1l/vmjbdfadiDgBJQWTmjdqwb8wBQmupbr1d0s54DrHurMl+7rZ1bZWVlKisrV+r5K8kArFOnTkmSOXPm1CkfP3585s+fv9wF8EePHp2uXbvmy1/+cq655po0a7bmD2yrqlqaxUveystvPLfG64ZSZMwDQNNnPQeAZUryFMiuXbumd+/eGTduXDp27JguXbpkypQpmTZtWpIsF4D97Gc/S5JUVlbm2GOPzW233Za2bdt+ZBvvHSU26+rktXl1t1VXV+fav1+UAX0OyQZtN86C1+blZ388Op032DpbbvTxemqD0jRgwMDUXFz3iEhjHgBKS33r9YpYzwHWvVWZr1k7Bg4cuNL3KckArLy8PJMnT86IESMycuTIbLjhhjniiCMyevTonHzyybUXwP+gAQMGpLy8PH/729+y5557rlYf7n5kWq66+QdZvOSttGndIX22GZgfDv9rKipK8lcGq82YB4Cmz3oOAPUr2ZWwe/fumT59ep2yIUOGpGfPnmndunWSZOHChXn55Zez1VZbJVl2EfzHH388n/jEJ1ar7fLy8owbNm216oCmxJgHgKbPeg4AH65kA7D6zJo1K/3796/9+a233sqhhx6ahQsXplmzZmnVqlV+85vfZMstt2zEXgIAAABQSppMALZw4cLMmTMno0aNqi3bZJNNcueddzZirwAAAAAodU0mAGvbtm2qqqoauxsAAAAANDHljd0BAAAAAFibBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAOvY+KuPzHmTv7laddxy31UZcX6fNdSjFbvyptPz3Ut3W2ftAVDabrxnYo44p1vtzxdc86385A/fbsQeAXy0Zo3dAdaeh5+4PSf/Yq/lyquql+bdpe/k/JG3ZeKNY/Ovp/+eiormtdsHbn9Yjjv456vV9vOvPJUh//ex/PaUZ7JRh81Xq64VufGeiZnw+6H59Mf3yrhh0+psG3Zuz8x98V+Z8K3p6bPNwLXaD6B0PPrMrPz2lrPyj6f+lneXvpMN1u+cz3x87xw66MRs2G7Txu7eSht/9ZGpqGhWZ27+Qt+v5gt9v9qIvaqrvj4C0LiOu3hg7Xv98vKKbNqxa776hVPzud5fXuNtHfPlS9Z4ne/34OMz8t3LdsuNP1y6VtsBiksAVmDbdf1crjt7YZ2yJe8uznEXD0iHthun19afTZJ8dbex+epupzZGF1doadW7afa+cO7DbNhuszzy9J158dW52XiDLZMks5+8I1XVS1NeXrG2uwmUkHvn3JyxV+yXL+7ynRz9xZ+lU/suefmN+bn+rp/noScqM2j7wxq7i6xlDV07AP4XvPdev6pqaabcdn7OuurQ/GLTf2bzjbo3dteaLOsMNE0lfQpkdXV1JkyYkG233TatWrVKnz59UllZmR49emT48OGN3b0macLvv5F33l2Uk786KeXlH/30P/n87Jx0+Z456PSN8pWzt8wvpn0vS6verd1+7u+G5itnbZH9T10/w87tmVvv/23tthE/WnZazjfG98h+p7TNb24+M0my+wllmf3kHbX7Pfj4jOx54n9z2OMuHpiL/nRMvj/xwBxwartMqTwvSTLtrstz1IRP5oCx7fOtH+2QWY/eVKevLZu3zsDtD8sN9/yytmzaXZdn7x2PqrPfgtfm5XuXD85Bp2+UA8a2z7EXfS5z5t1bu/3Km07PCZd+IRdfe2y+9P0Nc/hZm+fqW8/56F8qUFIu/MOo7LrDV3LUPj9Mp/ZdkiQbtts0X9t9bG34tXjJ2/nZn76Tr5y1Rb78/U75/sQD8+Krc2vrOO7igbnkuuNyxq++nP1PXT9f/79tMnP2n5Ikb7z9Svb+Xqs89uwDddo97uKB+fVNZzSo/g/6qLnxd9PH59b7r8rNs36V/U5pm/1OaZuq6qrlTj1ZnceUJI8/92DGXDwgX/5+p3zxtA1y8s/3ynMvPb5Sv/sPc9+/b8nRF+6YL562QQ46faOc/ZvD8urCF5Mkdz9yfQ46faO8u3RJ7f5vL34z+53SNg8/cXuS5I23Xs55vx+Wr5y1RQ46faOc+etD8uqbL9Tu/7VxW+fXN/8gx18yKPud0ja3P3zNGuk3QJFUVDTL/juPSnV1VZ6c/3CS5LqZF2fo+B45YGz7HP2T/rXz7ntWtP39Pnh6/+4nlOXamRdl9I8/nf1PXT9H/6R/5r74SO32txe/mR9O+nq+dFrHfPXsrXLzrCuz54nN8uDjM1b6sS1e8nZO/9WXcsgZnXPAqe0y8oK+uXfOzUmSquqqHHZml9zx8B/q3OeHk76e834/rPbnj/p748qbTs8Jl+yaS687PgefsUlOu2L/le4j0PhKOgAbNmxYzjzzzIwYMSLXX399DjnkkBx++OF54okn0q9fv7XefnV1db7z052z+wllWfDavLXe3tr265t/kPsfuyVnfuO6tG7Z9iP3fXXhiznu4gHZ5ZNfyqRTn82F3/577v33zZl06//V7vPJj+2SS459IH/4wWv52u6n5dzfHZmnX/hnkuTSYx9Mkvzyu4/murMX5mu7j21wP2+855c5cJf/lz+e+XoO3OX/Zdpdl+d303+Yk75yVf5wxqsZOvjsnHHll/LsS4/Vud/eOx6VG+75Zaqrq7Nw0WuZ+Y8/ZfdPHVFnn5qa6uy386j85uSn8/vTnk+3Ln1zxq++VCfYe/iJ27JB203yu7Hzc8aRf8o1t51fJ9wruqKNe/63zFswJ8+99Fh23f4rH7nfJdcem0eevjMXHn1nfnPK02nXplPGXrFfqqqrave5edavctCA4/LHH7yeAz777Yz/3RFZvOTttFuvY3bquX9umjWxdt/5Lz+R2U/dkT0+fWSD62+oQwd9N7vu8NXs/qkjct3ZC3Pd2QtTUc+RravzmJKkLGX5+u6nZ9LYZ/Ob7z2VVi3b5pxJX1vp/tanRbOW+fYXf5op31+Qy8Y8nJffeC4X/ek7SZJPdd8zrVq0ycx//DeMm/7ApGzUYYts1/Vzqampyfd/dWBSVpbLj5ud35z8dNZruX7G/bbuc3z9XZfnW/udn2vPejM79zpgjfQbmiprOfV5d+mS/Gnmz9Ksonm6btYnt94/KRNvHJvvHnZlpp7+cvbe8aic/PPBeeHVp5Nkhdsb4qZZE/P9r1+TKae/lI06bJGf/fHo2m0XXfudzH/lifziu4/ksuMezl2P/CXVq7BOJsve4+/yyS9l4on/zjVnvJxB2x+eH1z55by2cEEqyisy+DPDcv3d/z1F/61Fr+f2h6dkr/98WN6QvzceevK2dGy3aX57yjM57es+aIGmqGQDsEmTJmXixIm59tprc/zxx2fQoEE55ZRTstNOO2Xp0qXp27fvWu/DNbf/KC2br7fW21kXKh+cnN9NPydnHPHHbLLBVnW2/faWs3Pg2A61t38+fWf+OuvKbLNpn+y704g0b9Yindp3yeGDvpe/3ntl7f32+sywtGuzYSrKKzJo+8PysU17r9InNh/0ud4HZYduu6asrCytWqyXP9z+43xtt9OyzWZ9Ul5enh0/sXe232ZQZjxwdZ37deuyQzq03Tj3PHp9/nrfb9K3++7ZoO3GdfbZeIMts3Ov/dOqxXpp2bx1hu55Vl58bW6efenftft0bLdpDh10Ypo3a5Hum/fL3v2H58Z7Jq7242oqijTu+d/z2sIFSZIN/3PkV32qq6tz072/ypGDz0qn9l3SukWbjNr/gsx98V95dO7dtfsN6HNoem29c8rLy7N3/+F5a/HrtXPFnp8emlvvv6o2PL9x1sRsv82gbLLBVg2uf01aE4+p62a9s323QWnRrGXatG6fIbt/P/+ae2dtQLY6PvmxXdJji0+noqJZOrbrnEMGfjcP/PuWJEl5eXn2+sw3c8Pdv6jd/4a7f5G9PrPsKII58+7Nv+fdm6O/+LO0ad0+rVqsl6P2GZ8HHru1zh/2e+14VLp12SFlZWVp2bz1avcZmjJrOe/33nv9r5y1ef7+jz/ltK9fky6duuXGe67IPv1H5BNb7piKimbZ6zPD8rFNe9d+8Lui7Q1x8IATsvEGW6ZFs5bZ81NHZs68WUmWHZV1631X5Yg9f5AN2m6cNq3a5RuDx63yY2zdsm126/e1rNdq/TSraJ5DBp6QZhUt8ugz9yRJ9v7MN3Pfv2/OS68/myS59f7fZtMNt0nPrfonSYP+3tikw1Y5eMBxad6sRVq18PqCpqhkrwE2bty4DB48OAMGDKhT3q1btzRv3jy9e/euU37ZZZdlxIgRmTx5cg466KDVbn/egjm5buZFOe3r12TkBTusdn2N6dFnZmXC747MsQddnp5b77Tc9q984ZTlrgH213t/nX889bccOLZDbVlNamo/lamurs6VN5+eygd/l1fefD5lKcviJW/l9f/88bk6Ntlg6zo/P//Kk/nJH0fnZ3/6f7VlVdVL06n98hfX3/szR2XaXZfn+VeezFH7nLvc9tffeimXXDsmDz4xI28tei1lZcsy4NcWLshWm7zX/lYpKyur0587Hp662o+rKSjSuOd/U4e2GyVJXn792Wy1ySfq3ef1txbk3aXvpHPHj9WWtW7ZNh3abpwFrz+TZNk8+f6L5bdu0SZJsuidN5Mk/brvkWYVLfL3f16XXT75xdw861cZtvc5K1X/mrQmHtNzLz2ey/5yQh6Ze9eysv/Mg6+/tSCtWtT94GRlzZl3b355/cl54rkH8867b6cmNVn0zn+vUTn4M8Ny1V/PzIuvzs1bi1/P4889kLOG/SXJsjXg3aXv5JAzNqlTZ4tmrfLia3Nrv2il8wfWDvhfZS3ng+p7r58kC15/JgP6HFKnbLMNt8mC155p0PaGeP+606pFm7z9nzXnjbdeyrtVS7JJh/+uLx/8kH5lvPPuolz25xNy9yPT8sZbL6WsrDyL3nkzr7+17G+TjTfYMn233T033nNFvrrbqbn+7p/XuVRKQ/7eWJ3+AaWhJAOwefPmZfbs2Tn22GOX2zZ37tz06tUrLVu2rC3797//nSuuuCL9+/dfI+1XV1dnwu+/keH7Tkjb1h3WSJ2N5aXXn833Jx6QL39+zEp9W9gmG2yVHbbdLWf/5w+QD5r+wKRcf/fPc85RN2WrjXumvLw8o378qdSkJklSXlb/wYWtW7bNoiVv1f788hvPLbfPB++78QZb5et7nJEBfQ5eYb933eErufwvJ6Rdm07p13335bb/Ytr38sqb8/OTo+/Khu02zduL38wBY9sl/+l3krzw6tOpqampDcFeePWpesO2oinSuOd/1+Ybdc9mnbpl+gOT0rf7bvXu077NRmnerGVeeOWpdOm07Bpai95ZmNcWvpiN2m/RoHYqyiuye7+v56ZZE9OmVfu8/c4b2eWTX1zl+lc0N67omo1r4jH9eOq3smG7zXLZmIfSrs2GefL52Rl+3napqalZ8Z1X4OyrDsvntzsoY4dMTptW7XLnP/+csVfsV7t9w3ab5jOf2Cc33nNF3lz0anb+5IFp36ZTkmXrUasWbTL1jFc+8vdQ9iHrDvwvsZazMjZqv0VeePWpOmXzX3ki/Xvu16Dtq6Ndm05pXtEiL7z2dDbrtE2S5MXXPvxamSsy5bbz8/ATt2X8iFvSeYOtU1ZWli9/v1OdNWyf/iNyybXHZsdP7JOnX/hndus7pHZbQ/7esM5A01eSr+J585ad0tC5c+c65YsWLUplZWWd0x+XLl2ab3zjG7n44ovrhGIrUlZWlrKyslRWzlhu2x/u+HE6rt85u2z3xVV7ACVi8ZK3c9rEA9Jz651zxJ4/WKn77t7v65kzb1ZuuPuXWfLu4lRXV2f+y0/knkduSJK8vfiNVJQ3S4c2G6Wmpjo33P3LPPHcg7X3b992o5SXldc5tTBJtu3SLzfP+lXeXbokz7/yVKbcdv4K+/Llzx+bX998eh579oHU1NTknXcXZfaTd9S5iOZ71mu1fs791vSc9Y0/1zmK6z1vv/NGWjZfL+u33iCL3lmYn087cbl9Xnljfn4/49wsrXo3jz17f6bddXn2+MC1xJqKysoZtWP9o8Z8UpxxD//vixfllvuvyi+uPzkvvb4sSHr1zRcy6db/y/QHrk55eXl27/f1TLxxbF56/bksXvJ2Lr3uuGyx0cfTY8vPNLidPT51ZO555Pr8bvoPM2j7w9OieaskWaX6VzQ3brB+5zz/8hOprq6u9/5r4jG9vfiNtGrRJm1ad8jrb72UX914WoN/F++prq7KkncX17nV1NTk7cVvpE2r9lmv5fp58dW5uXr68l8uss+Ow3PDPb/MLff9Jnt/5r+fynff/FPpulmf/OxP/y9vvPVykmVH7U7/wGnw0JTVt16v6Fbk97CsG3t++sj85c5L88jcu1NVtTQ33HNFHn/ugey6w1catH11VJRXZNAOX8mvbzo9ry1ckLcXv5lf3nBKg+77wXWmqmpp3l78Rpo3a5l2622Yd6uW5Nc3/yALF79W5347fmKfvFv1Ts6bPCyf2+7LWX+9DWq3rczfG/xvW5X52m3t3CorK1NZWblSz19JHgHWqdOyT33nzJmTvffeu7Z8/PjxmT9/fp0L4J955pnZa6+9sv3226+Rtp996bFMue28/Oz/zVoj9TWm2x++Jv+ed2/mvvDP7H/q+sttP+bLl37ofTu265wJ35qen087Kb+8/uS8s3RROm+wdfbpPyJJsvunjsj9j9+aI37YLS2br5fd+g7Jdh/7XO39WzZvnSP2PDPjrjo8S5YuzsEDT8hXv3BKvv3Fn+a8338jX/p+x2y1Sc/s8akjc/G1x3zk49h7x6PSrKJFJvx+aJ5/5ck0q2iebl36ZsS+E+rdv/vmH/4FCUfs8YOc+7sj8+Xvb5gO62+SI/b4Qf5y12V19tnuY5/LK2/OzyE/6JwWzVrli7t8Z40s9KWsSOMe+nXfPT8adUd+e8tZGX7+dllatSQbrN85/T+xb/b81NAkybf2/1F+Me2kfPvCT+fdpe+k59Y75wdDr6334vIfZouNe6THFp/Jff++Od/Yq+51S1a2/hXNjXt/5pt54N+35Munb5iamppcc8bLy9Wxuo/pW/v/KBdcMyIHntouG22wZQ4ZcEL+NvsPK77j+9w0a2KdLwdIkh9/++859suX5dI/H5erbjkrW2z88ezWd0j+8dTf6uzXr/seKS8rT5tW7bPDtl+oLS8vL88ZR/4pE28Ym1E/7pc33n45HdpsnL7dd6/9Vk/AWs7K23WHr+SNt1/JOZO+llcXvpAtNuqRs4dNqz3Vb0XbV9eoA36cn0wdlaHju2e9lu0yZPfvp/LB36V5xYcf1FBdXZV9Tq57ncd9+o/IEXuckceevS+HnblZ2rbukC/tcsxyp8ZXlFdk8KeH5Td//UG+td+P6mxb2b83gKaprGZNnNuwhlVXV2eHHXbI/PnzM2HChHTp0iVTpkzJtGnTMnfu3Nx5553Zcccdc9ddd+X444/PjBkzUlFRkYEDB+bb3/72Sl0DbNbVyfu/HOfGeybmx9eMSOuWywKjmprqvLno1azfeoMcOfis7L/zqDX9cCkhV950emY/eUfGj/hrY3dljeiwefKpD/x9+MExnxj3QGk47uKB6dd9j3zlCyc3dldgnapvvV4R72EpmmdefDTfOPfjmXTqs+nUfrO10saN90zM1dP/L1d899G1Uj/FtyrzNWvHwIEDkyQzZsxo8H1K8giw8vLyTJ48OSNGjMjIkSOz4YYb5ogjjsjo0aNz8skn114Af/r06Xn88cezzTbLzht//vnn889//jNPP/10jjvuuFVqe0CfQ9J32/9eN2bB6/PynZ/ulP876qZsufHHV//BQQky7oHG9tATt2XOM/dk7JDJjd0VaJKs5TQ1819+Iq+8+Xw+vuWOeeOtl3Lxdcdmu66fX2vh19uL38wf7vhxDvzs/1vxzkAhlWQAliTdu3fP9OnT65QNGTIkPXv2TOvWyw57Pemkk3LSSSfVbl+VI8A+qFWL9ep8rW1V9dIkScf1O6d1y7arXC+UMuMeaEyjf/zpPPfyYxl94E9qv8kTWDnWcpqaJUsX54Ipw/P8q0+lVfP1sl3Xz2fMQZevlbam3n5Bfnn9yenXfY/s03/4WmkDKH0lG4DVZ9asWWvsmx4bqnPHrXPzuSV3lihrydf3OL2xu1ASjHtgXfrZd+5p7C5A4VjLKXVbbdIzlx8/e5209aXPHZMvfe6YddIWULqaTAC2cOHCzJkzJ6NGffj1C1bm3E8AAAAA/jc0mQCsbdu2qaqqauxuAAAAANDElDd2BwAAAABgbRKAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEJr1tgd+CjV1dU5//zzc+mll+aZZ55Jjx49cuGFF2b48OEZMGBALrvssrXS7virj8yt91+V5s1a1pYdtc/47L/zqLXSHjQ2Yx4Amj7rOQB8uJIOwIYNG5apU6dm7Nix6devX2bOnJnDDz88CxYsyJgxY9Zq27t/6ogcd/DP12obUEqMeQBo+qznAFC/kg3AJk2alIkTJ2bGjBkZMGBAkmTQoEG57777MnXq1PTt27eRewgAAABAU1CyAdi4ceMyePDg2vDrPd26dUvz5s3Tu3fvJMnAgQPz9NNPp3379kmSwYMH55xzzlnt9u94+Jr87eGpademU3budUCG7P79tG7ZdrXrhVJlzANA02c9B4D6lWQANm/evMyePTvHHnvsctvmzp2bXr16pWXL/17b4Nxzz81BBx20xto/cJejc9Q+P0z7Nhtl7ov/yoTfD835U47KKV+dtMbagFJizANA02c9B4APV5LfAjlv3rwkSefOneuUL1q0KJWVlWvk9MeysrKUlZWlsnLGctu6b94vG6y/ScrLy7N151751n4/yu0PTcmSpe+sdruwLlVWzqgd68Y8AJSm+tbrFd2s5wDr3qrM125r51ZZWZnKysqVev5KMgDr1KlTkmTOnDl1ysePH5/58+enX79+dcpPOeWUbLfddjnggAPy0EMPrfH+lJf959dUU7PG64ZSZMwDQNNnPQeA/yrJUyC7du2a3r17Z9y4cenYsWO6dOmSKVOmZNq0aUlSJwC78sors8UWW6SsrCxXX3119txzzzz22GNp06bNR7ZR8583ArOuTl6bV3fb9Aeuzqd7DE7b1h0yb8G/c+mfj8tOPfdPi+at1uwDhbVswICBqbm47pteYx4ASkt96/WKWM8B1r1Vma9ZOwYOHLjS9ynJAKy8vDyTJ0/OiBEjMnLkyGy44YY54ogjMnr06Jx88sm1F8BPki233LL2/4cddlhOPPHEPProo6t1muSf/35JfjJ1VN5d+k46tN04n/3kFzNkj9NX5yFBSTPmAaDps54DwIcryQAsSbp3757p06fXKRsyZEh69uyZ1q1bJ0kWL16chQsX1p4yecstt+TNN99Mt27dVqvt80bOWK37Q1NjzANA02c9B4APV7IBWH1mzZqV/v371/78xhtvZK+99sqSJUtSXl6edu3a5dprr027du0asZcAAAAAlJImE4AtXLgwc+bMyahRo2rLNt5449x7772N2CsAAAAASl2TCcDatm2bqqqqxu4GAAAAAE1MeWN3AAAAAADWJgEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgBbw8ZffWSOvnDHvLXo9VRVLc05k4bkmJ/tkqtvPSdJMvvJO/KN8R/PtLt+vkp1Pvbs/TnqvO3ytXFb125f3Tr//s/rcvRP+uf//WSnTK48L0ny7EuPZcT52+eKG05tcJ1X3nR6RpzfJ8+8+GiefH52vvPTnXPsRZ/Lub8bmpqamtWu8z3X3PajHPOzXdZIP59/5akcfMYmOe7igTnxsj2SJIveWZijf9I/5/z2aw2u88Z7Jmbo+B558PHKJMm9c27OCZfsmuMuHpg58+5d7Tofe/aBHHfxwBx38cAMGfexTL39giTJqb/ct/Z3UcquuuXsHHrmZnWep6Hje+Tc3w1Nkrz0+nM54ZJd852f7pz75vw1SfLHv/00h5zROc++9FiD2zntigNy4NgOtXW89/xOvf3HSZILp47KQadvVOe1ct7kb+aIc7o1uI2XXn8uIy/om72/1ypVVUuT1H2u5r/yZI696HMZc9HnM+6qr6SquirJyj9X9b3W18Zr7Ia7f5kh4z5WZ2wed/HAfO/ywXX2O+2KA2rrve2hKfnauK1rf88NUd/v/oCx7fOLad9L8t856biLB+bW+3+bZO2MgRdefTqn/nLfHH/JoFx/9y+SrPkxsKZerysaA4uXvJ1TfrFPjrt4YE674oAsWfrOWhkDL746NydcsmvGXPT5VD74+ySrtu6saB6orx+NOTesi/liadW7+X8/2Sn7ndK29vGsqzmkvr6tq3nl7keuzzfGf7zex7O255r6xuGamn+KqL4x+uDjM/LVs7fKjAd+lyS55b6r8p2f7pxTf7lv3lr8RpJVe3+yKnPEqjxPK3pt/GvuXfnOT3fOMT/bJRdfe2ySVXtvmKx4PP7sT9/JmIsH5OgLd8zsJ/+WJLnihlNz4NgOta/LhqjvNfX+9/rv+dmfvlP7GFZlHm/IeBg6vkftGvj0C/9MsvJzZ7LieaS6ujqXXnd8vnvpbvnBrw9Osmpzxrpa05MVj/EHH6/M0RfumKN/0j/X/f2SJGtnjFdVLc3Zvzksx18yKJf/+btJ1t4Yr+8xP/n87Bzzs13ynZ9+Nk8891CStTPu6/s9rKm/pWm6BGBrwUlfuSptWrfPzH9emy02/nguGH1HZj91R1554/l88mO75NBBJ61ynZtt2C0XHn1nOrXfvHbb6ta5zaZ9csHov+XH356Zv//z2ry16PV06dQtow64YKXrHLHvedli4x7ZYqMe+fG3Z+ZHo25PksyZN2u160ySJUvfyePPPVC7bU3U2W/b3XPeyBn54fCbkiStW7bNKV+9eqXrPHjACemzzYC88+6i/OXOS3PO8Jtz3sgZ6b55v9Wus1uX7XPeyBk5b+SMfGzT3tnxE/smSc76xp9Xus7GsPdnvpnvHX5VnbL2bTbKCYdekST53fRzcsSeZ+aco27KVbeclSQ58LPfzqd6DF6uro/ynS9fki997pg6Zf223T1f+tx3kiRf3W1sjtrn3Drbjzv459lg/c4NbqPdeh0zfvgt+cSW/euUv/dctW3VIWcN/XPOH3VbOnf8WO5+ZFqSlX+u6nutJ2v+NbZTr/1zzvCblyt/f3+feO6hvPPuotqfP9/7oOzxqSNXqp36fvcf67xdhu39f7U/n/SVq3LeyBnZdYevJFk7Y+CK60/J8YdckQnfmp69PjMsyZofA2vq9bqiMXDPozfk41vumPNGzkiPLT+TWY/csFbGwNXTf5ihg8/Oud+anml3/TxVVUtXad1Z0TxQXz8ac25YF/NFRXmznHHkH/O57Q6q3bau5pD6+rau5pVPbNk/l4x5cLnt62KuqW8cJmtm/imi+sZokuzWb0gGbn9olla9mz/feUnOH3lbdus7JH+589Ikq/b+ZFXmiFV5nlb02tikw1Y5d8StuWD0HXlt4Yt5cv7Dq/w+bkXjccS+E3L+yMqcOuT3mXTruCTJ0MFnZZvNtl+pdj7sNfXee/0kefXNF/L8K0/WbluVeXxF4yFZ9py9twZutUnPJCs/dyYrnkduf3hKttzkExk/4q85bcjkJKs2Z6yrNT1Z8Rifctt5GTtkcn48emZuumdZ2doY43fM/kO6btYnE741Pe8sXZTHn3twrY3x+h7zr24Ym5O/Oiljh/w+E28cm2TtjPv6fg9r8m9pmiYB2Gq4859/zmV/PiHV1dX53uWD8+Krc+tsf+TpO9Nv292TJH22GZRHnrl7tetcr9X6ad2izRrt58YbbJmK8oqUlZWlorxZyspWPCwee/b+nH3V4UmSc377tTz6zKw625tVNK/9f/NmLbNR+y1Wu84kueHuX2T3Tx2xwrpWps4HHp+eYy/6XK657UcNqvOl15/NSZfvmarqqvxi2vdyx8N/qLP9n0//PWVl5Tn553vlnElDsmjJW6td53sWLXkrr775fLp0WrlP0dal6urqnDf5mxlz8YCc/PO9kiQbrL9JysrKPvQ+Tz7/cHptvXNat2yb9VquX/sJ8kd55Y3nc/LP98pxFw+s/ZRpw3abfuR9VrS9PrOf/Fu+89PP5riLB2bGA79Li+atsv56G3zo/uuvt0Htm81mFc1TXlbRoHb+NvuPOfon/XP8JYPy4OOVK3ytr8prLFn2CdsxP9slJ1yyaxYuei3t23RKRXmzj7zPH/52YfbfeVSD6k+WjdMfXHlQxlw8oPZTzRX97svKyjL+6q9n7C/3ywuvPt2gdlZ2DCytejcvvPZ0LrhmRE66fM/MWzCnQe2s7Bh4z8q+Xld2DGy24TZZ/J/55a1Fr6Vdmw0b1M7KjoHnX3kiH9usdyrKK7LB+ptk3kv/XmEbqzIP1NePxpwb1sV8UVZWlg3W36RO2bqaQ+rr27qaV9Zfb4O0aNZyufJ1MdfUNw5XZf4pogcfn5ETL9sjJ/98r5xwya554+1X6h2j7/fsS//Oxzpvl4qKZum77W7559N/b1BbR/+kf8ZffWRG/fhTufOfy4KEVZkjVuTKm07P2Vcdnu9eulvO+/2yDz1W9Nro2K5zWjRvlSSpKG+e8vKGvQaPmvDJ/ODXB2fUBf3y6DP3JFnxeHzvNbfonYXpulmfBrUz/uojc97vh2XMRZ/PxBtPS/Lhr6n3m3r7BTnws0c3qI1k1cZDkrz59isZc9Hnc8GUEVny7uIGtXXcxQPz0z8enaN/0j9/ufOyJCt+vu/855/z9PP/yHEXD8y0uy5vUDs33jMxp11xQE66fM+cdsUBeXfpkrW2pq/KGN9iox55a/HrebfqnbRq4N97qzLG57/yRLpu2jtJss1m2+efT81sUFurMsbre8xvLno1G3fYIp3ad8nCxa81qO1VGff1/R5W5W9pimXlVhHq6N9z31Q++Pv86Jrh6d9zv2y8wZZ1ti9c/FrWa9UuSdKmVfu8tei11a5zbfTzPXc/cn0223CbrNdq/RXW2a3LDtm0Y9f8aMrwbNhus/TY4lO56191PwmZ+Y9rc8X1J6dLp20b9IfZiupcWvVuHnx8RvbfeVR+9Z+Jb3Xr7Nhu01xx4py0qGiZ0yYekB26fSFdN+v9kXV2at8ln+99UH405agseXdxhu39f7nxnom1219984W88ub8TPjWjEy787L85e+X5qABY1arzvfc88j1Jf+J9Mx//Ckd2m6c4w7+eaqrqxt0n+rqqtrF8b3XSpv/vHY+zKTp/5cvfe7YfKrHHg1uZ1X88vrv5QdD/5T2bTqtVDsvvf5c7p1zc776hRWfNlRdXZ3f3nJ2zh91W1o2b93gdlb2NfbYs/dn/stP5ILRd6SmpqZBbcx98ZF0aLNR2rbu0KD9k2TanZelX/c9sk//4Q1+LCP2Oy/t1uuY2U/ekUuvOy6nfX3KCu+zsmPg9bdeyhPzH8qvTnwsry18MZf/5bs548g/rvB+qzoGVub1uipjoEunbfOvp/+eb07olQ5tN8439/7hCu+zKmNg84165KHHK9Nnm4H519w7G7SWrco8UJ9Snhvqs6pjpT7rYg6pz7qYV+qzruaa+qzK/FNcNRn3zesz44HfZdqdl+WwXT/6qIiFi1b+vW6SvL5wQcZ+7fdZv82GOemyPdK/576r2/EPtXXnT+arXzglP75mZP759J3puVX/Fd8py45IfP2tBbVHMa3Iy288lwuPvjNvLX49F1wzosFHCJ0+8Yt55Jm7c+Lhv27Q/kmyfbddc9whv8ipv9w3L73+bDq17/KR+7/x9it57a0F6dJp2wa3sczKjYck+dHoO9JuvY757S3j8pe7LssXd/l/DWppYJ/DMnL/CzLmos9lj08dmebNWnzk/q8ufCGf/NguOWqf8fnuZbtlp577rzCcS5IObTfOmIMvz9XTf5g7Zk/NoO0Pa1D/VvY9+KqM8c9+8os5+Rd7pbysIkN2/36D21rZMb7Ff9b1HT+xTx58bHq26tyrQe2s6hj/oJqa6vf/0OD7rey4h/o4Amw17dN/RG578PfZa8dvLretTav2efs/n1a/vfiNtGngm7qPqnNt9DNJ5r/8RH4/Y3y+tX/DjoJKkn13+lZuuOeX+eJ/TiH5oJ177Z/Lj5+dTh02r/3kY3Xq/Ou9v649NWFlfFSdLZq1TOsWbVJR0Sz9P7FvnnphdoPq/ELfr+X2h6bU+0lam1bt88mtd0lFeUW277Zr5r74r9Wu8z1/m/2H7LLdlxpUX2OZ99Kc9Npq5yRJeXnDppj3H3X41jsNe608u2BOem29cu2siprUpH2bTivVzpKl7+Tc3x2RMQdfnoqKFX/O8PpbC7LJBlulZfPWK9XOyr7G5i2Yk57/+Z2VlZV95KeQ77nmtvPzxV3qf403pJ2GPpZ263VMsuww9FfefL5B91nZMdCmVftstXHPdGi7Ubbu3CtvvP1yg9pZlTGQrNzrdVXGwM2zfpX+PffLz4//R3b8+D655b7frPA+qzIGDt/1e5l212U589cHZ8uNPt6gPzBWZR6oTynPDfVZ1bHyQetqDqnPuphX6rOu5pr6rMr8U1TdNtshybKjQp59ecXXHHr/e92GvkaTpF2bDbPxBlsuew/WwCOsVtX7H9NzDbyO0htvv5Kf/vHbOe7gXzS4nc06dUvrlm3TqX2XvLX49RXf4T9OP/IP+cnRd+WX15/c4Pt067LsMX2s83Z1Tmv8MH+4/cc5YOfRDa6/tp2VHA/Jf19Pn/3kF/PU8w17X50se0wV5RXZeIOt8trCF1e4f5tW7dO764BUVDRLz612avA1st773a3MeEhW/j34qozxX0w7KT/+9t8z8cR/56Z7f5XFS95u0P1Wdoz377lf3lm6KCdc+oU0b9YyG7Rd8bqerPoYX8771omGnHn0npUd91AfAdhqqK6uzlV/PTNf2/37+d1/LnL/fp/Yaqfc/9gtSZIHH5+eHlt8erl9Xnr92ZWqsyFWts63F7+Zc393ZI47+BcfekjoB+tMlk3So/b/cb1HYy1Z+k7t/9dr2a72Tfnq1PnMgkdz3d8vzvcuH5ynX/hH/njHT1a7zrcXv1n7/3889bdsuuE2DarzyptOzxF7nll7vYb367HFp2tDr8efeyCdO35stetMlh0BN/fFf2WbBh4i31i22KhH/jX3ziRp8CfyXTftnX8+9fcsWvLWsrD4A0d4vPPuorzx9it1yjbfqEf+9fTKtbMib7z9Sp3rzyRJWcryxlsvr1Q7F0wZnv13Hv2hnxq/uvDFLK16t/bn9m02youvza09VaAh7azKa2zzjXrkkf/8zpI06GiNF159Ouf+7shc/pfvZvr9k2q/6OE9VVVL8+qbL9Qp22LjlX9u3ju17ZkXH633CJA1MQZatVgvrVu2zeIlb+el15/Nei2XP5JoTY2BFb1e18QYqElN1v/PHxrt2nSq983omhgDG6y/Sc448o857etT0rxZywbNaasyD9SnVOaG+qypsVKfdTGH1GddzSv1WVdzTX1WZf4pqsfnL7uezhPzH8xm9bwn+qDNN+qep56fnarqqtz/778udx2lZPnxmiw7TW7Ba/OyeMnbtV/0sLo+7Hl6YiUf07Ivsfpahu87IR3b1X/dqvrexz330mNZtOStvPT6c/WuL/V57zXXumXbek95e3vxm/We+v34c8se01PPz84mG2y9wnaef+XJ/GLa9zL+d0fk/sdvrf1Ck/er7zGt7Hh4d+mS2sf0Ye+r65s7k+SJ5x5MVXVVXnz16XRou/EK2+q19c55Yv6yC6g/+fzD2WSDrepsr2/OeK+d9/6tr3/1Wdk1PVm1MV5eXpG2rTqkebMWKS8rT9UH6lxTY7yivCLfPvAnOXfELSkvr8ineuy53D5raozXp13rjlnw2rxl9dRzVPeaGvdQHwHYavjj3y7MZz/5xRw84Lg8+fzDeer5f9TZvlPP/fLUf77l4hNb7bTcOdJVVUtz7u+OXKk6X3ztmXz30t3y1POz891Ld8vzrzy12nX+aeZP8/wrT2bC77+R4y4emPn1JOr/99uv1vn5b7P/mI032CoHfHZ0WrVsm3vn1L1I5axHbsiYiwdkzMUD8urCF9Kv+x6rXedR+/ww5xx1Y/7vqBuy1Sa9cuAuyx8ptbJ1Pvzk7Rl1Qb9856c7Z8P2XfKJLXdcrs4fXv31Om+sH31mVl5+47l86XPfSZ9tBi133YEObTdK764DMuaiz+fGe67Ivjt9a7XrTJL7H7s122+z63LlpWannvvnlTfmZ8xFn8+pVyw73Pv6u3+RS687Lrfed1UunLr8J5CHDPxurrjhlJx46W45fNflPwH9x5N/y3V/v7hO2WGDTsrvK8/NcRcPzBU3LjtF6Gd//H+5+d4rc/m079ZeQ+L9rrrl7EyuPDfX3HZ+fn3zD5bbfs1t5+ff8+6rU/aNvf4vY6/YL8dfMii3PTQ5S6vezXcv3S1PzH8wJ/18z/xr7l119v/nU3/PHbOnZurtF+S4iwfWez23S68dU+fTzfLy8hw26Hs57uIBOeGSXfPwk7ev8LW+Kq+xbl22z8YbbJXv/PSzOeGSXfPW4tdz5z//nHMmfS33P3ZLzvjVl5er473X3FH7jM+gHQ5Pn20G1Nn+/KtPLfftcHvteFTueeT6jLl4QM6fsuyo0xX97s/57VdzzM92yflTvplhey8f1K+pMfCVL5ya7/18z/zgyoPy9T3OWG77mhgDyYpfr2tiDOy6w1dS+eDv//PNdVdl175fzQetiTFw17/+kuMvGZSxv9wvh+36veWO8Klv3VmVeaC+fjTm3LAu5oskOfPXh+Tef9+U8VcfkZmz/7TO5pD6+rau5pVHn5lVp29L3l28zuaa+sbhqsw/9zxyQ+7611+SJD/949HLlTVVzSqa53uXD861My/KPjsOT7L8GP3g/nvteFTGXPS53DTrV9m3/4jl6vzgeE2WhfZX3nx6xlz8+Rw66MQkqzZHvF99z1OSzH3hXznh0i/knXcXpefWO63wtVH50OTMeeaeXP6X7+a4iwfmn08tf12zD76PS5KNOmyR837/jZx2xX752u7LPnRd0Xg8+zeH5riLB2bsFfvliHrWpBkP/i53/vO65cofeqIyx170uXTdrE826rB5va+p9zvx8Cvzf0fdkO8e+qvssM2uGdDnkDrb65vHk5UfDwsXvZrv/HSnjLno87nzn9dl/52Wv6ZffXNnktz20OQc89Ods1u/r6d5sxYrfL4Hf3pYpj8wKd/56WfTY4vPZKMOdS/4Xt+ckSRvvP1yTrxsj8x+6o7sst2X1sqanqzaGD904Ik58bLd8v9+slP6bDOo9nqQ71lTY/yl15/NcRcPzAmX7JqeW+1c76mEa2qM1/eYv77HGTnrN4fmzF8fnCP2WP4+a2rc1/d7WNHvhuIrq1mdCzYUwKyrk9fmrbn6Lr3u+Pxr7p05+xt/WW7SSpZ9zepF1x6TQwackM06dcsTzz2YwZ/5RsnV+exLj+WcSV/L53sfnD0+dUT+eMdPcsSeyy/M7zf19gsy/YGr891Df1X7DYtNsc5F7yzM934+OD22+HRG7HteLrr2O/n2gcsfbfZ+tz00JVdPPycj9j1vuTfta6vOZNlXMLdo3rr2228+qMPmyac+cGmDNT3mV9VxFw9M544fq/3mmw/6499+mr/8/ZKcNewvuePhqenfc7+Vvvj/gtfm5eSfD85eOx5V+21vH3Te5G9m3oJH86NRt+enfzw6o/b/8UqfSrOyz9WFU0fl/33popVqI1k7r4f6nP2bw/LW4tcz7pvX17v9toem5Kq/npWjv/izvPrm82m73gbZodvKh7PfGP/xfPaTX6zzTZDvZwwsr1TGwKqsO/VZ0TxQn3U1LuqzrsZKfdbF+KnPuhpT9VlXc0191sQ4Wxn1rdcrsqbX8wcfn5H7/v3XDB181kfu98+n78yPr/lWDt/1e7Xf/PdBKxqvx/xsl1ww+o4V9ml13ytcedPp+eTWu6Rv990+sp018d6woY9pRePxihtOze0PTcnlx/8jE284NYft+r06R7+Ov/rIfHW3U1c4Hlf374c1OR5WNHced/HAjB/+1xWe8r26709uvGdiqqqXZu8VXGZmTazpxvjKzbnratzX5/2vhQ8bw++3KvM1a8fAgQOTJDNmzGjwfQRgJRIGwNpQygEYALBMUwrA1oSG/iG9uhoaDqwJ6+oxNTQIWF3rcjw0NABbXQ0NwNYEY3zNWlfjviEEYKVDALYKhAEUmQAMAEpfKQRgAKyYAKx0rEoA5hpgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAAqtpAOw6urqTJgwIdtuu21atWqVPn36pLKyMj169Mjw4cMbu3sAAAAANAHNGrsDH2XYsGGZOnVqxo4dm379+mXmzJk5/PDDs2DBgowZM2att3/fnL/mihtPzVPPz06LZq0yoM8h+X9fumittwuNxZgHgKbPeg4AyyvZAGzSpEmZOHFiZsyYkQEDBiRJBg0alPvuuy9Tp05N375912r7Dz4+Iz/49UEZc/DP07/nfklNTZ5+4Z9rtU1oTMY8ADR91nMAqF/JBmDjxo3L4MGDa8Ov93Tr1i3NmzdP7969kyRLlizJSSedlOuuuy6tWrXKBhtskNtuu2212//FtO9l352+lc/3Pqi2bNvN127oBo3JmAeAps96DgD1K8kAbN68eZk9e3aOPfbY5bbNnTs3vXr1SsuWLZMkJ598ct5888088sgjqaioyPz581e7/UVL3sqjz9ydXlt/NiMv6JsXX52brTt/MsP3nZAeW3xqteuHUmPMA0DTZz0HgA9XkhfBnzdvXpKkc+fOdcoXLVqUysrK2tMf33777Vx66aU599xzU1FRkSTZdNNNG9RGWVlZysrKUlk5Y7ltC99+NdU11Zn+wKSccMjEXD32ufTrvkdO/cXeWbjotVV/YLCOVVbOqB3rxjwAlKb61usV3aznAOveqszXbmvnVllZmcrKypV6/koyAOvUqVOSZM6cOXXKx48fn/nz56dfv35Jksceeyzt27fP+eefn8985jPp379/fv/73692++u1XD9Jsuenh6brZr3TvFmLHL7r97K0+t3846mZq10/lBpjHgCaPus5AHy4kjwFsmvXrundu3fGjRuXjh07pkuXLpkyZUqmTZuWJLUB2NKlS/Pss89m0003zd13352nnnoqO++8c7bddtvssMMOH9lGTU1NkmTW1clr8+pua9O6fTpvsHXKUlanvCzLkkZoKgYMGJiai2vqlBnzAFBa6luvV8R6DrDurcp8zdoxcODAlb5PSR4BVl5ensmTJ6dXr14ZOXJkhg4dmk6dOmX06NGpqKiovQD+lltumSQ54ogjkiRbb711PvvZz+buu+9e7T7st/Oo3Djrijz9wj9TVbU0v59xbpo3a5leW+282nVDKTLmAaDps54DQP1K8giwJOnevXumT59ep2zIkCHp2bNnWrdunWTZqZKDBw/OX/7ylxx88MF5+eWXc/fdd+e4445b7fYPHnB83n7nzZxwya5ZsnRxunXZIWcPuz5tWrdf7bqhFBnzAND0Wc8BoH5lNe+dC9gEfOITn0j//v1zxRVX1JY9/fTTGTZsWF544YXU1NRk9OjRGTlyZIPrrO/wcSiKDpsnnzqsbpkxDwClpb71ekWs5wDr3qrM16wd750COWPGjAbfp2SPAPughQsXZs6cORk1alSd8q222ip//etfG6lXAAAAAJS6JhOAtW3bNlVVVY3dDQAAAACamJK8CD4AAAAArCkCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBozRq7Ax+luro6559/fi699NI888wz6dGjRy688MIMHz48AwYMyGWXXbZW2v3mhF554dWn39ePqixZujgXfefebLt537XSJjQmYx4Amj7rOQB8uJIOwIYNG5apU6dm7Nix6devX2bOnJnDDz88CxYsyJgxY9Zauz8//h91fv7l9adk5j/+6I0DhWXMA0DTZz0HgA9XsgHYpEmTMnHixMyYMSMDBgxIkgwaNCj33Xdfpk6dmr59181CXlW1NDfe88sctuv31kl70NiMeQBo+qznAFBXyQZg48aNy+DBg2vDr/d069YtzZs3T+/evfPaa69l4MCBtduWLFmSf/3rX3nooYey3XbbrZF+/O0ff8xbi1/P7v2+vkbqg1JnzANA02c9B4C6SvIi+PPmzcvs2bNz8MEHL7dt7ty56dWrV1q2bJkOHTrkgQceqL2ddNJJ6dOnT4PCr7KyspSVlaWycsZH7veXOy/NgD6Hpm3rDqv4aKDxVFbOqB3rxjwAlKb61usV3aznAOveqszXbmvnVllZmcrKypV6/ko2AEuSzp071ylftGhRKisrP/T0x8svvzzDhw9fY/147qXHc/9jt2Tfnb61xuqEUmbMA0DTZz0HgOWVZADWqVOnJMmcOXPqlI8fPz7z589Pv379lrvPI488kvvuuy9f/epXG9RGTU1NampqMmDAwA/d5y93Xpqum/bJJ7bcseGdhxIyYMDA2rFuzANAaapvvV7RzXoOsO6tynzttnZvK6MkrwHWtWvX9O7dO+PGjUvHjh3TpUuXTJkyJdOmTUuSegOwyy67LIccckjat2+/Rvrw7tIluWnWxByx55lrpD4odcY8ADR91nMAqF9JHgFWXl6eyZMnp1evXhk5cmSGDh2aTp06ZfTo0amoqEjv3r3r7P/OO+/kyiuvXKOnP94xe2qWLF2cL/Rt2BFl0NQZ8wDQ9FnPAaB+ZTUre8xYIxoyZEgefPDBPPTQQ3XKr7766px99tl5+OGHV7rOWVcnr81bUz2E0tJh8+RTh9UtM+YBoLTUt16viPUcYN1blfma0lGSR4B9mFmzZtV7+uPll1+eo446qhF6BAAAAECpK8lrgNVn4cKFmTNnTkaNGrXctltuuaURegQAAABAU9BkArC2bdumqqqqsbsBAAAAQBPTpE6BBAAAAICVJQADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoTVr7A40tvU3buwewNpT3/g25gGgtKzK2mw9B1j3zL1NW1lNTU1NY3cCAAAAANYWp0ACAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhVbSAVh1dXUmTJiQbbfdNq1atUqfPn1SWVmZHj16ZPjw4Y3dPQAAAACagGaN3YGPMmzYsEydOjVjx45Nv379MnPmzBx++OFZsGBBxowZ09jdAwAAAKAJKNkAbNKkSZk4cWJmzJiRAQMGJEkGDRqU++67L1OnTk3fvn0buYcAAAAANAUlewrkuHHjMnjw4Nrw6z3dunVL8+bN07t37yTJU089lQEDBqR79+7ZbrvtcvvttzdGdwEAAAAoUSV5BNi8efMye/bsHHvsscttmzt3bnr16pWWLVsmSUaMGJFDDz00o0aNysyZM3PwwQfnySefTIsWLT6yjbKysrXSdwAAAADWvpqamgbvW5JHgM2bNy9J0rlz5zrlixYtSmVlZe3pjy+99FLuuOOODBs2LEmy8847Z7PNNsv06dPXbYcBAAAAKFkleQRYp06dkiRz5szJ3nvvXVs+fvz4zJ8/P/369Uuy7GiwTTbZpPZosCT52Mc+lqeffnqFbbx3auWMGTPWYM8BAAAAKDUlGYB17do1vXv3zrhx49KxY8d06dIlU6ZMybRp05KkNgADAAAAgBUpyVMgy8vLM3ny5PTq1SsjR47M0KFD06lTp4wePToVFRW1F8Dfcsst88ILL+Sdd96pve+TTz6ZrbbaqrG6DgAAAECJKckjwJKke/fuy13La8iQIenZs2dat26dZNmpkp/97Gfzi1/8ovYi+M8++2wGDRrUGF0GAAAAoASVbABWn1mzZqV///51yi655JIceeSRueCCC9KiRYtMmjRphd8ACQAAAMD/jiYTgC1cuDBz5szJqFGj6pR37do1t912WyP1CgAAAIBS12QCsLZt26aqqqqxuwEAAABAE1OSF8EHAAAAgDVFAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGglHYBVV1dnwoQJ2XbbbdOqVav06dMnlZWV6dGjR4YPH97Y3QMAAACgCWjW2B34KMOGDcvUqVMzduzY9OvXLzNnzszhhx+eBQsWZMyYMY3dPQAAAACagJINwCZNmpSJEydmxowZGTBgQJJk0KBBue+++zJ16tT07du3kXsIAAAAQFNQsqdAjhs3LoMHD64Nv97TrVu3NG/ePL17906SnHbaaenevXvKy8szZcqUxugqAAAAACWsJAOwefPmZfbs2Tn44IOX2zZ37tz06tUrLVu2TJIMHjw4N9xwQz7/+c+v624CAAAA0ASU5CmQ8+bNS5J07ty5TvmiRYtSWVmZvfbaq7Zs5513XqU2KisrkyRlZWWr2EsAAAAAGktNTU2D9y3JI8A6deqUJJkzZ06d8vHjx2f+/Pnp169fY3QLAAAAgCaoJI8A69q1a3r37p1x48alY8eO6dKlS6ZMmZJp06YlyRoJwN67ttiMGTNWuy4AAAAASldJHgFWXl6eyZMnp1evXhk5cmSGDh2aTp06ZfTo0amoqKi9AD4AAAAArEhJHgGWJN27d8/06dPrlA0ZMiQ9e/ZM69atG6lXAAAAADQ1JXkE2IeZNWvWcqc/jh07Nptvvnn+/ve/Z8SIEdl8883z+OOPN1IPAQAAACg1TSYAW7hwYebMmZO+ffvWKT/zzDMzb968vPPOO3n55Zczb968bLPNNo3USwAAAABKTcmeAvlBbdu2TVVVVWN3AwAAAIAmpskcAQYAAAAAq0IABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAAqtpAOw6urqTJgwIdtuu21atWqVPn36pLKyMj169Mjw4cMbu3sAAAAANAHNGrsDH2XYsGGZOnVqxo4dm379+mXmzJk5/PDDs2DBgowZM6axuwcAAABAE1CyAdikSZMyceLEzJgxIwMGDEiSDBo0KPfdd1+mTp2avn37NnIPAQAAAGgKSvYUyHHjxmXw4MG14dd7unXrlubNm6d379559dVXs++++6Z79+7p06dP9thjjzz22GON1GMAAAAASlFJHgE2b968zJ49O8cee+xy2+bOnZtevXqlZcuWWbRoUY455pjstttuSZILL7wwQ4cOze23377CNiorK5MkZWVla7bzAAAAAKx1NTU1Dd63JI8AmzdvXpKkc+fOdcoXLVqUysrK2tMfO3ToUBt+JcnOO++cJ598ct11FAAAAICSV5JHgHXq1ClJMmfOnOy999615ePHj8/8+fPTr1+/eu93wQUX5MADD2xQG++dWjljxozV6isAAAAApa0kA7CuXbumd+/eGTduXDp27JguXbpkypQpmTZtWpLUG4CdccYZeeyxx3Lrrbeu6+4CAAAAUMJK8hTI8vLyTJ48Ob169crIkSMzdOjQdOrUKaNHj05FRUV69+5dZ/+zzjorf/7zn3PDDTdkvfXWa6ReAwAAAFCKSvIIsCTp3r17pk+fXqdsyJAh6dmzZ1q3bl1bdsYZZ2TatGm5+eab06FDh3XcSwAAAABKXckGYPWZNWtW+vfvX/vzP/7xj5x++unZZpttMnDgwNryBx54YN13DgAAAICS1GQCsIULF2bOnDkZNWpUbVmvXr1W6isvAQAAAPjf02QCsLZt26aqqqqxuwEAAABAE1OSF8EHAAAAgDVFAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGglHYBVV1dnwoQJ2XbbbdOqVav06dMnlZWV6dGjR4YPH97Y3QMAAACgCWjW2B34KMOGDcvUqVMzduzY9OvXLzNnzszhhx+eBQsWZMyYMY3dPQAAAACagJINwCZNmpSJEydmxowZGTBgQJJk0KBBue+++zJ16tT07du3kXsIAAAAQFNQsqdAjhs3LoMHD64Nv97TrVu3NG/ePL17906SHHjggendu3d22GGHfOYzn8lf//rXxuguAAAAACWqJI8AmzdvXmbPnp1jjz12uW1z585Nr1690rJlyyTJxIkT06FDhyTJ/fffn4EDB+aVV15JRUXFuuwyAAAAACWqZAOwJOncuXOd8kWLFqWysjJ77bVXbdl74VeSvP766ykrK0tNTc0K26isrEySlJWVrYEeAwAAALAuNST/eU9JngLZqVOnJMmcOXPqlI8fPz7z589Pv3796pSPHj06Xbt2zZe//OVcc801adasJHM9AAAAABpBWc3KxGXrSHV1dXbYYYfMnz8/EyZMSJcuXTJlypRMmzYtc+fOzZ133pkdd9xxuftVVlbm2GOPzW233Za2bdt+ZBsDBw5MksyYMWMtPAIAAAAASkVJHgFWXl6eyZMnp1evXhk5cmSGDh2aTp06ZfTo0amoqKi9AP4HDRgwIOXl5fnb3/62jnsMAAAAQKkq2XMFu3fvnunTp9cpGzJkSHr27JnWrVsnSRYuXJiXX345W221VZJlF8F//PHH84lPfGKd9xcAAACA0lSyAVh9Zs2alf79+9f+/NZbb+XQQw/NwoUL06xZs7Rq1Sq/+c1vsuWWWzZiLwEAAAAoJU0mAFu4cGHmzJmTUaNG1ZZtsskmufPOOxuxVwAAAACUuiYTgLVt2zZVVVWN3Q0AAAAAmpiSvAg+AAAAAKwpAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0Jo1dgeaikdvTd58sbF7AVBM62+c9Nh15e9nbqapWdWxDgDA6hGANdCbLyavzWvsXgDwfuZmAACgIZwCCQAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAAqtpAOw6urqTJgwIdtuu21atWqVPn36pLKyMj169Mjw4cMbu3sAAAAANAHNGrsDH2XYsGGZOnVqxo4dm379+mXmzJk5/PDDs2DBgowZM6axu5ckqaquyi+mnZSbZk3MkqWL02/bPXLMQZemfZtOjd01gP9Z5mYAAOD9SvYIsEmTJmXixIm59tprc/zxx2fQoEE55ZRTstNOO2Xp0qXp27dvY3cxSXL19HMy8x9/yk+OviuTTpmXJPnhpCGN3CuA/23mZgAA4P1KNgAbN25cBg8enAEDBtQp79atW5o3b57evXvXKb/ssstSVlaWKVOmrMtuZtqdl+XQQSdm0w27pk3r9jlqn/G559Eb8sKrT6/TfgDwX+ZmAADg/UoyAJs3b15mz56dgw8+eLltc+fOTa9evdKyZcvasn//+9+54oor0r9//3XZzSxc9FpefG1utu3Sr7Zss07bZL1W7fL4cw+u074AsIy5GQAA+KCSvAbYvHnLTlfp3LlznfJFixalsrIye+21V23Z0qVL841vfCMXX3xxjjnmmAa3UVlZmSQpKytr0P4TvjU9fbYZWKfs7XfeTJK0ad2+TnnbVh3y9uI3GtwXgP91lZUz8unDB630/czNNDWrOtYBAFheTU1Ng/ctySPAOnVadpHiOXPm1CkfP3585s+fn379/vup/plnnpm99tor22+//brsYpJkvZbrJ0neWvR6nfKFi1/Leq3arfP+AGBuBgAAlleSR4B17do1vXv3zrhx49KxY8d06dIlU6ZMybRp05KkNgC76667cuutt2bGjBkr3cZ71xZr6H1nXZ28Nq9uWdvWHbJxhy3z2LP3pVuX7ZMk819+Im8vfiNdN+29fCUA1GvAgIGpubjhn968x9xMU7OqYx0AgNVTkkeAlZeXZ/LkyenVq1dGjhyZoUOHplOnThk9enQqKipqL4A/ffr0PP7449lmm22y9dZb584778yoUaNy3nnnrbO+7t1/eH4344eZ/8qTeWvxG7l82on5VPc907nj1uusDwDUZW4GAADerySPAEuS7t27Z/r06XXKhgwZkp49e6Z169ZJkpNOOiknnXRS7faBAwfm29/+dg466KB11s/DBp2UhW+/mm//+NN5t+qd9N1295z0ld+ss/YBWJ65GQAAeL+SDcDqM2vWrHX+TY8rUlFekRH7TciI/SY0dlcA+A9zMwAA8H5NJgBbuHBh5syZk1GjRn3oPqtyLTAAAAAAiq3JBGBt27ZNVVVVY3cDAAAAgCamJC+CDwAAAABrigAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAAMAAACg0ARgAAAAABSaAAwAAACAQhOAAQAAAFBoAjAAAAAACk0ABgAAAEChCcAAAAAAKDQBGAAAAACFJgADAAAAoNAEYAAAAAAUmgAMAAAAgEITgAEAAABQaAIwAAAAAApNAAYAAABAoQnAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFFpJB2DV1dWZMGFCtt1227Rq1Sp9+vRJZWVlevTokeHDhzd295Ik0x+4Osde9LkccGq77Hlis8buDsD/PPMyAADwQSX9l8GwYcMyderUjB07Nv369cvMmTNz+OGHZ8GCBRkzZkxjdy9J0rb1Btlvp1FZ8u6i/Oia0gjlAP6XmZcBAIAPKtkAbNKkSZk4cWJmzJiRAQMGJEkGDRqU++67L1OnTk3fvn0buYfLfLrHnkmSBx+f0bgdASCJeRkAAFheyQZg48aNy+DBg2vDr/d069YtzZs3T+/evZMkAwcOzNNPP5327dsnSQYPHpxzzjlnnfcXAAAAgNJUkgHYvHnzMnv27Bx77LHLbZs7d2569eqVli1b1pade+65Oeigg9ZlFwEAAABoIko2AEuSzp071ylftGhRKisrs9dee612G5WVlUmSsrKyBu0/4VvT02ebgavdLgDLq6yckU8fPmil72dupqlZ1bEOAMDyampqGrxvSX4LZKdOnZIkc+bMqVM+fvz4zJ8/P/369atTfsopp2S77bbLAQcckIceemid9RMAAACA0leSR4B17do1vXv3zrhx49KxY8d06dIlU6ZMybRp05KkTgB25ZVXZosttkhZWVmuvvrq7LnnnnnsscfSpk2bj2zjvWuLzZgxo0F9mnV18tq85curqqtSVfVu3l26JEmy5N3FSZLmzVo2+OgygP91AwYMTM3FDf/05j31zc3mZUrZqo51AABWT0keAVZeXp7JkyenV69eGTlyZIYOHZpOnTpl9OjRqaioqL0AfpJsueWWtX/QHHbYYWnRokUeffTRddbXv9776+xzcut87+d7prq6Kvuc3Dr7nNw6L7z69DrrAwD/ZV4GAAA+qCSPAEuS7t27Z/r06XXKhgwZkp49e6Z169ZJksWLF2fhwoW1p0zecsstefPNN9OtW7d11s89P31k9vz0keusPQA+mnkZAAD4oJINwOoza9as9O/fv/bnN954I3vttVeWLFmS8vLytGvXLtdee23atWvXiL0EAAAAoJQ0mQBs4cKFmTNnTkaNGlVbtvHGG+fee+9txF4BAAAAUOqaTADWtm3bVFVVNXY3AAAAAGhiSvIi+AAAAACwpgjAAAAAACg0ARgAAAAAhSYAAwAAAKDQBGAAAAAAFJoADAAAAIBCE4ABAAAAUGgCMAAAAAAKTQAGAAAAQKEJwAAAAAAoNAEYAAAAAIUmAIMSM/7qI3Pe5G+uVh233HdVRpzfZw31aMWuvOn0fPfS3dZZe0DD3HjPxBxxTrfany+45lv5yR++3Yg9AgCAxtGssTsA69qjz8zKb285K/946m95d+k72WD9zvnMx/fOoYNOzIbtNm3s7q208VcfmYqKZjnu4J/Xln2h71fzhb5fbcRe1VVfH4Fljrt4YP719N9TUdE85eUV2bRj13z1C6fmc72/vMbbOubLl6zxOt/vwcdn5LuX7ZYbf7h0rbYDAAAryxFg/E+5d87NOfaiXbL5Rj1yybEP5E9nvZHzRlam3Xob5qEnKhu7e6wDS6vebewuwHK+utvYXHf2wkw9/eUM2v7wnHXVoZm3YE5jd6tJ81oHAOD9BGD8T7nwD6Oy6w5fyVH7/DCd2ndJkmzYbtN8bfexGbT9YUmSxUvezs/+9J185awt8uXvd8r3Jx6YF1+dW1vHcRcPzCXXHZczfvXl7H/q+vn6/22TmbP/lCR54+1Xsvf3WuWxZx+o0+5xFw/Mr286o0H1f9DuJ5Rl9pN31P784OMzsueJyw7e/N308bn1/qty86xfZb9T2ma/U9qmqrpqudOeVucxJcnjzz2YMRcPyJe/3ylfPG2DnPzzvfLcS4+v1O/+w9z371ty9IU75ounbZCDTt8oZ//msLy68MUkyd2PXJ+DTt8o7y5dUrv/24vfzH6ntM3DT9yeJHnjrZdz3u+H5StnbZGDTt8oZ/76kLz65gu1+39t3Nb59c0/yPGXDMp+p7TN7Q9fs0b6DWtDRUWz7L/zqFRXV+XJ+Q8nSa6beXGGju+RA8a2z9E/6V879t+zou3v98FTrHc/oSzXzrwoo3/86ex/6vo5+if9M/fFR2q3v734zfxw0tfzpdM65qtnb5WbZ12ZPU9slgcfn7HSj23xkrdz+q++lEPO6JwDTm2XkRf0zb1zbk6SVFVX5bAzu+SOh/9Q5z4/nPT1nPf7YbU/T7vr8hw14ZM5YGz7fOtHO2TWozfVbrvyptNzwiW75tLrjs/BZ2yS067Yf6X7CABAcQnA+J8xb8GcPPfSY9l1+6985H6XXHtsHnn6zlx49J35zSlPp12bThl7xX6pqq6q3efmWb/KQQOOyx9/8HoO+Oy3M/53R2TxkrfTbr2O2ann/rlp1sTafee//ERmP3VH9vj0kQ2uv6EOHfTd7LrDV7P7p47IdWcvzHVnL0xFecUafUxJUpayfH330zNp7LP5zfeeSquWbXPOpK+tdH/r06JZy3z7iz/NlO8vyGVjHs7LbzyXi/70nSTJp7rvmVYt2mTmP/4bxk1/YFI26rBFtuv6udTU1OT7vzowKSvL5cfNzm9OfjrrtVw/435b9zm+/q7L8639zs+1Z72ZnXsdsEb6DWvDu0uX5E8zf5ZmFc3TdbM+ufX+SZl449h897ArM/X0l7P3jkfl5J8PzguvPp0kK9zeEDfNmpjvf/2aTDn9pWzUYYv87I9H12676NrvZP4rT+QX330klx33cO565C+pXoW5Kklqaqqzyye/lIkn/jvXnLHsSLcfXPnlvLZwQSrKKzL4M8Ny/d3/PU36rUWv5/aHp2SvHY9Ksiz8+t30H+akr1yVP5zxaoYOPjtnXPmlPPvSY7X3eejJ29Kx3ab57SnP5LSvC7sBAPgvARj/M15buCBJsuF/jvyqT3V1dW6691c5cvBZ6dS+S1q3aJNR+1+QuS/+K4/Ovbt2vwF9Dk2vrXdOeXl59u4/PG8tfj3PvvTvJMmenx6aW++/qvb0mxtnTcz22wzKJhts1eD616Q18Zi6btY723cblBbNWqZN6/YZsvv386+5d9YGZKvjkx/bJT22+HQqKpqlY7vOOWTgd/PAv29JkpSXl2evz3wzN9z9i9r9b7j7F9nrM8uOYJkz7978e969OfqLP0ub1u3TqsV6OWqf8XngsVuz4LV5tffZa8ej0q3LDikrK0vL5q1Xu8+wpv32lrNz4NgO+cpZm+fv//hTTvv6NenSqVtuvOeK7NN/RD6x5Y6pqGiWvT4zLB/btHduvf+3SbLC7Q1x8IATsvEGW6ZFs5bZ81NHZs68WUmWHZV1631X5Yg9f5AN2m6cNq3a5RuDx63yY2zdsm126/e1rNdq/TSraJ5DBp6QZhUt8ugz9yRJ9v7MN3Pfv2/OS68/myS59f7fZtMNt0nP/9/efcfXfP1xHH/l3kyJJEjsPUvtUaNIKKpWS2uUWlXUqpJSlJb+UKXUjtGiwyqlqF2VWFXUqqJ27REkkT1/f4TLdUNuQmR4Px+P+3i43/U553vP98T93PM930I1AFi5fQrvNPiUYnkrYDAYqF66CRWL1cPv4BJTjFzuhWjt5YOdrT2O9llSXFYRERERyXw0Cb48N9xdPAG4GXSJQrlKJ7pNUOgNomMiyZ29iGmZk4ML7i45uRF0AagJYDZZvpO9MwDhkXcAqFKyEbZGe/44uobaZVuyed93dGsyLlnHf5qeRp0uB5xmztpBHD//Z8IyGxvTsR3tCz1R+U5c/It564dx5vIhIqPDiCee8MgQ0/rGL3Vj4W//4/rt84RGBHH68kFGd1sLwNVbZ4mOiaTNqFxmx7S3deR64Hk83fMDkDtb4Scqo0hqa//KJ3RoMNxi+Y2gC3hVaGO2LG+OYtwIvGDVems8eO072jsTdve6Dw4NIDo2ilzu96/xXNlSfr1HRocz59dB7Dm+juDQAGxsDIRH3iEoNOHHiZzZClK5REM27p1PhwbDWb/nG5rcHf0FCdf7tF/6MGPVB6ZlsXExeLjlfyrlExEREZHMTQkweW7k9yxJXo/ibD24mMolGyS6jZuzJ3a2Dly7dY58HglzaIVHhhAYch1PtwJWxTEajDSs0olN+xbg7OhGWGQwtcu2TPHxnRxcCI8KNb2/GXzZbL3B8PiBnE+jTlNWvE8O17zMGXgYV+ccnL16hB4TyxEfH2/V/o8zZmE76pZ7ixEdl+Hs6Mruo78yYn5z0/ocrnl4qXRTNu6dz53w29Qq+wZuzh5AwpddR3tnVoy69djzYGOjwa6SMXm6FeDa7XNmy67cOkONMs2tWv8kXJ09sDPacy3wP/J6FAPgeuCj5ytMyvJtk/j7zDbG99xC7myFsbGx4c3PPMz6kaY1ejJr9QCql27Kf9eO0qByR9O6nNkK0anRKLwqtH5kDF3rIiIiIvIo+p+iPFc+aDmTLQcW8u36YQQEJSSSbt+5xuLfv2DrwSUYDAYaVunEgo0jCAi6TERUGLPX+FDA8wVKFXzJ6jiNqnZh7/H1LN36JfUqvo29nSNAio5fIl8VNu/7juiYKK7eOsfybZPM1mfLmpurN88QFxeX6P5Po05hEcE42jvj7OROUGgA32381OpzcU9cXCxR0RFmr/j4eMIignF2dCOLQ1au3z7Pkq3jLPZtWr0HG/bOY8v+H2ny0v0RISXzV6Vo3grMWPUBwaE3gYRbXbc+cEuUSEb2arUurN09m+Pn9xAbG8OGvfM5ffkg9Su1t2r9kzAajNSr1J4fNo0kMOQGYRF3mLfhE6v2ffhaj42NISwiGDtbB1yz5CA6NoofNn9OSESg2X7VSzclOjaSicu6Uafcm2TNks207s26A/hh80hOXTpIfHw8kdHhHDm7w2zSfhERERGRR9EIMHmuVCnZkK9772DRltH0mFSOmNgosmXNTY3SzXi1alcA3m/xNd+uG0LfqdWIjomkTOFafN51daKTyz9KgZylKFXgJfaf3My7r5nPmZPc4/dtOZ2JP71Lq8+yUyhXGRpV7YLv6g9N65u89B4HT27hzZE5iI+P5+dRNy2O8aR1er/F10z+uSdvDHfFM1tB2ngNYueRlUnv+IBN+xaYPRwAYErfPxjw5hxm/+rDwi2jKZDzBRpU7sg/53aabVelZCMMNgacHd2oVOIV03KDwcCoLqtYsGEEvadUITjsJu7OOalcsqHpqZ4iGVn9Su0JDrvFuMXvcDvkGgU8SzGm2zrTrX5JrX9SvV+fwrQVvek6viRZHFzp2PAz/A8txc7o8Mh94uJiaTrMfK69pjV60rnRKE5d2k+7/+XFxcmdVrU/tLg92Wgw0rhaN3787XPeb/612bom1btja7Tnq5+6cvXWWWyNdhTPV5mezb56KnUVERERkczNJv5p3MOUAXl7ewPg5+dn1fb7lsADc2qLyDPm4+tNlZKNaP/KsLQuiqQC9/xQNQU5S/XNz9aF6//y7oQXWDz8Eh5ueVMlxsa9C1iy9QvmD/43VY6f1lLa1kVERETkyWgEmIike4fPbOPEhb2M6LgsrYsi8ly5cvMMt+5c5YWC1QkODcB3zQDKFa2basmvsIg7rNwxhTde/iDpjZ8D//4Od66ndSlEHi1rTihVP3WOrfaffqXm5y4ikpqUABORdK3PlGpcvnmKPm9MMz3JU0SejaiYCCYv78HV2+dwtMtCuaJ1GfjW3FSJtWL7ZOatH0aVko1oWqNHqsTIaO5c1whHeX6p/YuIyNOmBJiIpGsz+u9N6yKIPLcK5SrD3I+OPJNYrep8SKs6Hz6TWCIiIiLy/NFTIEVEREREREREJFNTAkxERERERERERDI1JcBERERERERERCRTUwJMREREREREREQyNSXAREREREREREQkU1MCTEREREREREREMjUlwEREREREREREJFNL1wmwuLg4vvrqK0qUKIGjoyMVKlTA39+fUqVK0aNHj7QunoiIiIiIiIiIZAC2aV2Ax+nWrRsrVqxgxIgRVKlShV27dvH2229z48YNBg4cmNbFY+7aj/nz2K/cCLyAo4ML1V9oyntNv8Q1S/a0LpqIyHNLfbNkdrFxsXy7bgib9i0gKiaCKiUa8eFbs3Fz9kjroomkOrV/ERFJqXQ7Amzx4sUsWLCA1atX89FHH1GvXj0++eQTatasSUxMDJUrV07rImIwGBny9o/8POomswccIiDoIhOWdknrYomIPNfUN0tmt2TrOHb9s4pp/f5k8ScXAfhyccc0LpXIs6H2LyIiKZVuE2Bjx46lcePGeHl5mS0vXrw4dnZ2lC9fHoCoqCgGDhxIiRIlKFeuHHXr1n1mZez22liK56uErdEOdxdPWtbuz+HTfs8svoiIWFLfLJndut1zaFvvY/LkKIqzkxvdm45n778buHb7v7QumkiqU/sXEZGUSpe3QF68eJEjR44wYMAAi3Xnz5/nxRdfxMHBAYBhw4Zx584djh8/jtFo5MqVK8+6uCYHTm2haN4KaRZfREQsqW+WzCQkPJDrgecpka+KaVlej2JkcXTl9OVD5MpWKA1LJ5K61P5FRORJpMsRYBcvJgxnzp07t9ny8PBw/P39Tbc/hoWFMXv2bCZMmIDRaAQgT548VsXw9/fH398fGxsbq17+/n6PPd72wz/z6+5Z9G4xJZm1FRERf38/q/tj9c2SkSWnrSfWvsMi7wDg7ORmttzF0Z2wiOBnUQURk5T23Wr/GVtqfu566aWXXsl9JUe6TIB5eCRMYnnixAmz5ePHj+fKlStUqZLwq8+pU6dwc3Nj0qRJvPTSS9SoUYOffvrpmZfX/9Ayvl7enc+7rKZE/rSfm0xERNQ3S+aUxSErAKHhQWbLQyICyeLomhZFEnlm1P5FRORJpMtbIIsWLUr58uUZO3Ys2bNnJ1++fCxfvpx169YBmBJgMTExXLp0iTx58rBnzx7OnTtHrVq1KFGiBJUqVXpsjHtzi/n5+VlVpn1LIPCi5fINe+czZ40Pn3ddQ9kiL1tfSRERMfHy8ibeNz7Z+6lvlowmOW09sfbt4uROTveCnLq0n+L5KgJw5eYZwiKCKZqn/FMurcjjpbTvtobaf/qVmp+7iEhqSpcjwAwGA8uWLePFF1+kV69edO3aFQ8PD/r06YPRaDRNgF+wYEEAOnfuDEDhwoV5+eWX2bNnzzMp58odU5nz60d80X2jvmCJiKQT6psls2tSowdL/b7kyq2zhEYEM3fdx1Qt+Sq5sxdO66KJpDq1fxERSal0OQIMoGTJkmzdutVsWceOHSlTpgxOTk5Awq2SjRs3Zu3atbRu3ZqbN2+yZ88efHx8nkkZZ67qj9Fgy0ez6pktXzMm5JnEFxERS+qbJbNrV28IIWG36TulGtGxkVQu0ZAh7X9M62KJPBNq/yIiklLpNgGWmH379lGjRg2zZbNmzaJbt258/vnnxMfHM2TIEIttUsvmCRr6KyKS3qhvlszOaDDSs/lX9Gz+VVoXReSZU/sXEZGUyjAJsJCQEE6cOEHv3r3NlhcqVIjffvstjUolIiIiIiIiIiLpXYZJgLm4uBAbG5vWxRARERERERERkQwmXU6CLyIiIiIiIiIi8rQoAZaOTF7ek/7TX+bDGbU5c/kwAD6+3gyd2xiAsIg7jJjXnP7TX2bzvu8B2HZ4Oe+MLcz+E9bfBjpiXnMGzKzDoNmvcOPu86W7ji/FhKVdAdiwZx4dxxZh3KJ3TPv8snM6bUbl5lLAKatihEXcYdDsVxg4sy7D5zUjLOIOAK+PcOPbdUMfWd/UiDNjVX8G+nrRb2p1jpzdCcD8DcN5Y4Q7sbExVsW5cussA2bWYeDMuoxd2J7YuFiu3jpH61G5WLF9imm7m8FXaDrUyVT+icveo/O44lbFADh2/k/6T6/FhzNq47t6AACHTvvRYUwh/A4uBRI+Kx9fb3x8vfnv2tFUi3Pq0gE+ntOQj2bV489jawEYPq8ZH86obXWcP46uod+0GnwwrSbL/CcCsHHvArqOL8Wh0/6cunTQVJeOY4uwYvvkVIkTFxfHuEXvMHBmXQbPbkBQaADhkSH0m1bDrJ0nZe3uOfSbVoN+02rw+4FFAHy/aSQ9J1XgwvV/iY2NYcyP7fhoVj3m/joYIFXiBARdptfkyjQZ6mjWhn1XD2DAzDrMWNUfgEsBp+g5qSLzNwy3OvYPm0bxwbSafDCtJvtPbgFg/JIu9JtandDwIE5dOkD3ieV4Z2xh0z6JLTtydgfvjn+BdX9+Y3Xs9MCaa/3Aqd/5YFpNPppVz9SHJvcahJSd65ScV2vqlNjfheT2k5B02z179Qj9p9diwMw6TFjalfj4+BS1U2v6foDI6HDajMpt+huZGnW6dy59fL35eE4jIGXXvYiIiIikLiXA0pG29Ycwpe9OPmoznx82jzItH/3urwCs+3Mu3hXbMan3Ntbv+YbomCjqln+LRlW7JCtO7zem8nXv7bSrN4Sft38NgJuzJ4Pazgeg5ostGNdjs9k+b7zcl6qlGlsdw9Zox5C3f2RS723UevF1Nu1bAECR3OXo1uSLR9Y3NeL0bPYVk3r5M7zjTyz+fSwAXRuPpljeilbHcXF0Z3TXX5nUexu5sxdhz/F1AFQp0ZBWdfqbtluxfTIvFKxueu/T+huyZc1tdZxc7oWY0PN3JvfZQWDIdc5e+RuABlU64l2xLZDwWU3s5cfEXn4UylUm1eL8+Nv/GNVlFV+9v5XqpZsC99uitYrlqcDkPjuZ0ncXfxxdTWh4EACtvQZRoZgXxfNVNNWlSJ7yVC/dLFXinL58EFtbeyb13sar1bqyZf9CnBxc+KTDkmTFqVKyEdP67ebr3ttZfjfRBtCz2UQK5CzFjiMrKZq3Al+9v5XImHBOXz6UKnFcs2RnfI8tlC54/4EfJy/uJzwyhK97bycmJop/L+wln0dxer8+OVmxG1TtxNR+fzD2vfX8+EA/NKT9Qpyd3MibozhT++3Gwy2/aV1iy8oWqU3bekOSFTs9sOZaX/jb/xjXfRPdmoxj8e8J/Uxyr0FI2blOyXm1pk6J/V1Ibj8JSbfdAp6lmNJ3F1/33g7AiYv7UtROren7Adb/+Q1F8pQzvU+NOkHCuZzYy48ve2wCSNF1L482fkkXJi5774mOsWX/QnpOqvCUSpS07zeNZPDsBs8snjwbG/cuMPuxY/LP7zNtZd80LJGIiCRHhpkDLLOJi4vj6597cCngJI52WRj73nryZC8CJPzH3mAwWuxz7Pxu+racjtFgpGjeCly4fpyiecs/Nk54VCgTlnQmMPQGebIXZVDb+WZxjDaWcdycPQiPDElWfW4FX+Wrn7oSGR1OmUI16dbkC3LY5QHAaLDDYIi22Cep+j6tOLZGOyDhF/miea37z+/568eZ8vP7ALxctqVZksvWaIchkfMWFBpAWEQwubIVtioGwJGzO5m7djC2Rjua1+xlSj7dr49lnDthtxg4sy4Fc5am9+tTsLdzfOpxrtw8Q1RMBJ//8BZ2Rns+fHM22bLmSjLOziO/sGTrOBzsnOjYcCQVink9EMcWG5vEc+7hUaHcvnOVfB7WjaBJbhwPt3zExSXMIRgSHohrlhxWxVmzy5dNf32Hg50T/VvNMn3ZNRpsMRosu88rt85QNE/CNVksb0WOnttFMSvaXHLj2Ns5Wnzux87vpkrJhgBULtGAo//9QakC1ZKMPX/DcA6d9sPOaM9nnVeYrks7WwewsbHYPotjVquWZQSHTvuxaMtYjAYj0TGRjOi0HNcs2U3rE7vWI6LCsLdzIotjVkoXrM43az+2KpaPrzdF8pTj3wt7aVztXZrW6JGic50adQKS/LuQmPFLumA0GLkUcJLyxbzp8urn5M5eGHh0273XH0NCvT3dCiQZ5+qtc3yxqAOuzjkIDLnOsA6LyZO9SJJ9f3RMFMfO7+bFwi9bVZ+U1gng4OmtDJhZh9plW/Fm3QFWx0sv/r2wj0VbRvPPuZ1Ex0SSLWtuXnqhCW3rfUwO1zxpXbxkG7+kC0ajLT6t74+UfKVyB16p3CENS2UusTLK0+Hj682x//7AePf/l3myF6XDK8OpU/7Npx7rwzdnPfVjPujQaT8Gz2nAxi+tH7UqIiKPpgRYGtn1zyrcXXLi0/ob4uLizNZ9u34oLWt/YLFPSHggzg6uADg7uhESEZhknHW751ClZCOa1uhhFic2LpaFv43mwzdnP1lF7lq89Qta1RlA1VKNzOKER4awdvdsxr63/pH7Pqq+TzPOyAUtOX5hDx+//YNVceatG0r/N2dRMOcLZnECgi7z14nNdHhlODeCLprts2L7ZF5/uS8/+U2wKgbAvPVD+bzrKtycPczinLl8mKDQGxTKVYbAkOtm+3zdZweuWbKzaMtY1v45x6pzl9w4t+9c49KNE8weeJjDZ/xZtGUMfd6Y+tgYcXFxLNoyhkm9t+Fg52QWZ8/x9eTNUeyRX+j3Hl9v9ci/lMRxdfYgMjqcdyeUxmhjZNoHe5KMczvkOtsOL2Nyn50YDUazOL/+MYuaL75usU8Bz1IcPu1P9dJNOXRqK4Vyv5gqcRITEh5InuxFgYT+4dy1f5Lc59SlA1y5eYbJfXYQHx9vtu77TSNpVqOnVbEztnjGvrcev4NLWbd7Du3qJ4yuetS1/mA/DBAXb/3DWbwrtKNXi8kMnFmHRlW7YGdrD6TGuU5ene5Jyd+FisXr49PmW4bPa0ZA0CU83PIBj2+7u/5Zzfz1w8jnUQJXZ+uS0XfCbzGplz8nLv3F0q1fmr50Pq7v37RvAa9Ufofj5/+0uj4pqVN21zzM//gE9kYHPl3wOpWKv5Lkj1PpyV8nNjNifnNa1u5Pv5Yz8HDLx83gK6z/8xsOn/GnXsV2aV1ESWUxsdFmyenMoEODEXRoMJzY2BiWb5vE6IVt+TbPUfJ7lkzromVYmbGdiMjzR7dAppGLASd4sVAtAAyG+x/Diu2TKZSzDGWLWM5/5OzkRmhkMABhEcG4OLonHefGCcoUtowze40PDat0Iq9HsSephsmlGyd48aE48fHxfPXTu3R9bQwuTomX9XH1fZpxRnZZybR+fzJv/TCr4gSFBVAw5wtmcaJiIpmwtDMDW8/FaDTPHYeEB3Ij8AKFrUh4PCieeNycPcziBIfdYvovffFp/W2i+9wbzfFy2Zacu3okVeI4O7lRskA1HO2zULF4fc5fP5ZkjKDQG+TKVggHOyezOFdunuEnv/G83+LrR+6788hKapdrZVVdUhLnrxObcHP2ZN6gY3RsNJJl/l8lGefqrbMUz1cZ493RcffiHDv/J3uOr6NtPcuRPzXKNCcyJpxBs1/BztaBbC5Jj5pLSZzEODu6EXa3fwiNDH7ktfCgB/sHGxsbbO6OQtrx90qCw25Sv1J7q2JnZMXzVgISRuxdupkwd9/jrvUH+2Eg0dFUj4yVrxJGg5Gc2QqZEs6pca6TW6d7UvJ3oXi+hFhFcpfj6q2zQNJtt9aLLZj70RE83POz+6h1tzsXyV0Oo9GWYnkrcvnuHIuP6/tjY2PY9+9GXnrhNavrktI62ds64GTvjNFoS43SzTh3zbp+Ob2YurI39Su1p3vTL03JvhyueXin4QhT8isiKowZq/rTfnQB3vzMg88WvMH12+dNx/Dx9WbWGh9GffcmLYZnpdMXxdh1ZBWQ8LemyVBHTl06aBbXx9ebHzaNsur4D2s4yIYjZ3eY3h867cerHye066Vbx/P7gYVs3vcdzT9xofknLsTGxVrcuvYkdQI4ffkQA329ePMzD1p+mo1h37zG5YDTyTr3j7L/5Bb6Ta1Oy0+z8dZIT8b82I7bd/uMPcfX89ZIT6Jjokzbh0XcofknLvx9JuHW4uDQm0z8qRvtRxfgrZGe/O+HNty+c820/TtjC/PD5s/5aFY9mn/iwva/f34q5U6PjEZbWtTqTVxcrGm6hzW7fOk6vhSvj3Cj37QapvN2T1LrH/Tw7bkNB9mwetdM+kypRovhWek3rQbnrx83rQ+LuMOXizvR6tPsdBhTiM37vufVj205dNov2XWLiApj5HetaDMqN68Pd6XX5Mr8dSJhCpPYuFja/S8fO/5eabbPl4s7MfGnbqb36/6cS/evyvL6CDfe/7oS+/7dZFr3/aaRDJpVn9lrPqL1qFx8Or9FsssoIpLeKAGWRgp4luLY+d0AphEf+/7dxD/ndtGhQeITAZcpWJMDJ7cQGxfL6csHKXA3QXNPbGyM2X9wAArkLMWx/8zjrN/zLTY2NjSs2ilFZY+MDic47JbZsvyelnG+2/gpLxZ+mUrF6yd6nKTq+7TiRMVEAglzsjjaO1usD4u4Q2hEsNkyN2dPLt44YRZn8vIetKjVxzTv1oMu3PiXizdOMHRuY/af3Gy6ffJBwWG3iIwON1tmgw3BoTdNcWJjYxi3+B16NPuK7K6W8wlFx0SZ6vPPuZ3kyWH5RfVpxMnnUYLAkOumtpb77u1RD7odcp2Y2Pu3Hbk5e3I98DxR0RGmOGERd5iwtAs+rb/FKZFzDwm/KJ6/fuyRtwo+jTjx8fGmxKGbswehEUEW2wQEXTJ7nyd7UU5dPmD6/OPi4ggIusTsNT4MavedKWH1IKPBSN83pjGh5xYMBiNVS72aKnESU6ZQQv8AcODkb2bzgz0qdn7PUhy/ez1Bwnk6c/kwq3fNoF/LGVbFzehOXzkEwJkrh8h793p63LXuZO9MVHQ44ZEhHD+/J9FtErsGAc5cPkRsXCzXb/+Hu0vOp3KuH/5MU1InSPrvQmL9JCQkAQDOXT1CrmyFk2y79/ovgCwOrqZEdlJ1Onf1CLFxsZy5fL9Oj+v7b4dc43rgeYbObcyW/T/y7fqh3Am7nSp1ujcBPzy6X06vLt44weWAU9Sv+PgE7KzVAzj+326m9tvNj5/8h6uzByPmNyc27v4IyM37vuMtLx9++TyI11/uy/ilnYmICsM1S3ZqlmlhmqcNEn6wOHJuB42qdbH6+NZqW28w9St1oGHVzqwZE8KaMSGJfm5PUidI+LvaqeFIFo+4xI9Dz+Ho4MK4xU/noQf2tg70bTmd5Z/dYM7Av7kZfJmZdx9uUrXkqzjaO7Prn/vJuK0HF+PpXoByResQHx/PZ9+9ATY2zPU5wo/D/iOLQ1bGLjL/jNf/OZf3m09i9eg71LJypHFGFB0TxapdM7A12lE0bwV+P7CYBRtHMLjd96wYeZMm1bsz7JvGXLv9H0CS662xad8CPuv0M8tHBuDpXoAZv/QzrZu5uj9Xbp3h28HHmePzN38eX2uaoiG54uPjqF22FQs+PsnPo25Sr+LbfP79mwSG3MBoMNL4pW6s33P/FtvQ8CC2/72c16p3BxKSX0u3fsmQ9gtZOeo2XRuPYdT3rcweRHX47Dayu+Zh0ScX+LRT5k2UisjzQwmwNFKzTAtuBV9JeILV/ISJv2es6sfVW2f5aFY9Ji+3vB3mterv8fuBhQycWYdXq71run3mnqu3z1k8Reu16t3Ze3w9A329mLQ84ReqaSt6c+LiPnx8vflu42cWcXYf/ZVxi9/hwKktjPrOcr6Ef87uZM0fvmbL2tUbwk/+E/Dx9Wb+xuEEBF1mqd+X7DyyEh9fb9bs8rU4TlL1fVpxxvzYFh9fb0bMb07nRqMs1vsdWsruo2vMlr372lgmLe+Oj683v+ycxtFzf7DjyApWbJ+Mj6+3xS9qpQtWZ2q/P/ii+wYql2hI/0TmhPh52yROXtz/UJwvGDG/OR/Nqse2w8vwP7yMExf2MnftYHx8vTl67g+z7UPCb9N/ek0GzqzL7qNraFGzd6rEsTXa0aR6dz6a5c3ctYNpV38oD5u9eqDZbZMGg4F29Ybi4+vFoFn1+fvsdlbtms7VW2f56qd38fH15srd0RQPOnDqdyoWSzx5+bTiVC3ZiPPXj91t858met6+XNLJ7PZDdxdP6pR7k/4zavHRrHpcCjjJj5s/53bINUZ91wofX2+LJEdA0CV8fL0ZNKs+ZQrVMo2meNpxYmKjGTy7AWeuHGLIN69y7PyflMhfGTs7RwbMrIPBYOSFgi9ZxP5ikfn8N8XzVSRntkL0n/4yg2bVJzQiiDlrB3E75BpD577Kp/MtvxRdD7zA4NkNOHf1CINnN+DqrXOJLssobI12DJ3bmNW7ZtK0eo8kr3WA9vU/4eM5Dflm3ce0S2RC+sSuQYBth5fx4fRaNKjSCTtb+xSd6wfFxsYwYWmXp1KnpP4uJNZPAhw+48+AmXUomrcCnu75k2y7+45vYKCvFwN9vbgdco0qJRtZHPPhdgrg7pKTkQveYMaqD2jjPTjJvt/DLR8z+u/li+4beKXyO3R77QuyZsmWKnX6++x2ek+uQv/ptcjhlo/SDzwIJb0LDLkBQI5E+qp74uLi2PTXd3RpPBoPt3w42TvTu8Vkzl8/xr/n799O7lWhLS8WroXBYKBJjR6ERgRxKeAkAK9W68rvBxaafszYuG8BFYvVI1e2QlYf/2l6GnUqmrc8FYvXw97WAWcnNzo2/Ixj53ebEmRPomyR2pQqUA2j0Zbsrrlp4z2Yg3d/4DAYDLz20nts2HN/9PaGPd/y2ksJ/8c7cfEvTl78i34tZ+Ds5IajfRa6Nx3PwVO/m57wCgn/PyyerxI2NjaJJqIzukVbxvDGCHfaj87PH/+s4tNOP5PPozgb986naY2elC5YHaPRltde6kaRPOVNT3hNar01WnsNIme2gtjbOvBq1S6cuLgPSBiV9fv+hXR+9XOyueTE2dGVdxuPTXEdnRxcaFDlHbI4ZsXWaEcb70HYGu3598JeAJq89B77T242/ajw+4FF5MlRjDKFEn4gW7l9Cu80+JRieStgMBioXroJFYvVw+/g/Qd45HIvRGsvH+xs7XG0z5LisoqIpBeaAyyNGAwGfNqY33o2f/C/Fttlz5qbEfObM/a99Tg7ulo8HW/b4eXsPPILlUs05MzlQ9Sr9LbZeid7Zz7rbP6LzbpxkTzMaLBlwtKuDGo7nxplmlGjTDOz9b/snM7Ji/uwNdpx9urfeFdoa7Y+u2tuxnXfaLZs/bgoHhYcGsC364bSrckXidY3NeKM6vKLxfr5G4Zz+85VsLHhys3TFgmegjlfYFIvf7Nlq0ffMXt/I/Aipy8fZMX2KWaT5A9ut8D074nL3jPdVhYaEUSZQjXNjlG2yMtM6bvLbFn9hz7Do//tZvfRXymSuxzeFdvi+6HlF+vUiFOvYjuLuV+Gz2tG9rsTImdxdLVI8NQu15La5Vqa3lco5sXbD53bkxf/YsnWceTzKEGFYl5UK/Uq1R4aKZUacT7ttNxsfXhkCOMWv0OpAtWIi4ujUK4yZrcJA7So1ZsWte4nyz58y3JuJBcnd+ZvHI6newEK5CzFxF5+zyTO+J6/WWzT5/UpZu8vBZzim3VDqFu+NUGhAZQv6mWxz7uvjTF7//D1BQmj5iYs7cKYd9eS071AorEfXnbk7A5W7ZpOG69BFtumJ8XyVqRr49Gm92WcayZ5rVcu2YDKJc2f7pbUNQjQvel4s9sPU3KuHzyvp68col7Fty2OkZI6JfZ3Ial+EqC110dmD69Iqu3WKvs6tcqaJ/usaaeebvkZ0v5Hs2VJ9f33dGo0MlXrVL10E6qXbmK2/sHrPj1zd/EE4GbQJQrlKp3oNkGhN4iOiTQbCezk4IK7S05uBF0AEtr6g5Pl3xuJGx6Z0O6qlGyErdGeP46uoXbZlmze9x3dmoxL1vGfpqdRp8sBp5mzdhDHz/+ZsOzu9R8UegNH+0JPVL4TF/9i3vphnLl8iMjoMOKJN3s4UeOXurHwt/9x/fZ5QiOCOH35IKO7rQUSbquPjomkzSjzW/DtbR25HngeT/eEp8rmTsYDezKi9q98kugdBjeCLuBVoY3Zsrw5inEj8IJV663xYLtxtHcm7G6bCQ4NIDo2ilzu99tHrmwpbyuR0eHM+XUQe46vIzg0ABsbA+GRdwgKTUhs58xWkMolGrJx73w6NBjO+j3f0OTu6C9IaCvTfunDjFX355KNjYsxe/Lwk5RPRCQ9UgIsnfvkncc/Rr1u+beoW/6tJ47z8Jf2h73xcl/eeDnhMc9P8oSreYOPP3b9s4rTtfFo0xfEB78oJYene37mfvT4uV4efLpT3zempShOmUI1mD3wYLqI82AC9oNWM1MUx5o2+yziODm4MLnP/TlkUnreWtX5kFZ1PkzzOInJ51Gcaf3u3+LY+VXLEZDW6Nk86TnTHla2SG1m9t+XonjpzbO61iHpc/3weS2Zv0qK4lhTp6fRT0LSbfdptVN4Nn0/JP+6T6/ye5Ykr0dxth5cbJHUvcfN2RM7Wweu3TpnSgyGR4YQGHLdqqd4QsLt4Q2rdGLTvgWm+Qprl22Z4uM7ObgQHhVqen8z+LLZ+od/ZEiNOk1Z8T45XPMyZ+BhXJ1zcPbqEXpMLGfxQJGUGLOwHXXLvcWIjstwdnRl99FfGTG/uWl9Dtc8vFS6KRv3zudO+G1qlX3DNM9nrmyFcLR3ZsWoW489D496KnNm5+lWgGu3z5ktu3LrDDXKNLdq/ZNwdfbAzmjPtcD/THMtXg989Fx3SVm+bRJ/n9nG+J5byJ2tMDY2Nrz5mYdZG2xaoyezVg+geumm/HftKA0qdzSty5mtEJ0ajcKrQutHxnhe24mIZF7q1URE5LlUoZi32Uip1DSxl98jJ59/mp5lnQa3W2A2Uiq15M5e2GL0V2p5VnVKTz5oOZMtBxby7fphBAQlJJJu37nG4t+/YOvBJRgMBhpW6cSCjSMICLpMRFQYs9f4UMDzBUolcqv1ozSq2oW9x9ezdOuX1Kv4NvZ2jgApOn6JfFXYvO87omOiuHrrHMu3TTJbny1rbq7ePGPxlO17nkadwiKCcbR3xtnJnaDQAL7b+KnV5+KeuLhYoqIjzF7x8fGERQTj7OhGFoesXL99niVbx1ns27R6DzbsnceW/T/S5KX7o3pK5q9K0bwVmLHqA9Pcn4EhN9h68PE/qD4vXq3WhbW7Z3P8/B5iY2PYsHc+py8fND2IJKn1T8JoMFKvUnt+2DSSwJAbhEXcYd6GT6za9+F2EhsbQ1hEMHa2DrhmyUF0bBQ/bP7c4gnx1Us3JTo2konLulGn3Jtmt4K/WXcAP2weyalLB4mPjycyOpwjZ3eYTdovIpLZaASYiIiIyHOqSsmGfN17B4u2jKbHpHLExEaRLWtuapRuxqtVuwLwfouv+XbdEPpOrUZ0TCRlCtfi866rrX5IByQ8lKdUgZfYf3Iz775mPu9Rco/ft+V0Jv70Lq0+y06hXGVoVLULvqs/NK1v8tJ7HDy5hTdH5iA+Pp6fR920OMaT1un9Fl8z+eeevDHcFc9sBWnjNYidRyzn13ucTfsWmD0cAGBK3z8Y8OYcZv/qw8ItoymQ8wUaVO7IP+d2mm1XpWQjDDYGnB3dqFTiFdNyg8HAqC6rWLBhBL2nVCE47CbuzjmpXLKhxbQGz6P6ldoTHHaLcYvf4XbINQp4lmJMt3WmW/2SWv+ker8+hWkretN1fEmyOLjSseFn+B9aip3R4ZH7xMXF0nSY+TxtTWv0pHOjUZy6tJ92/8uLi5M7rWp/aHFrq9FgpHG1bvz42+e839z8KdlNqnfH1mjPVz915eqts9ga7SierzI9myV/1LeISEZhE/80xmpnQN7e3gD4+flZtf2+JfDA3KEiIvIUueeHqin4bqa+WTKa5LR1tW95HB9fb6qUbET7V4alWRlS2ndb43lo/xeu/8u7E15g8fBLeLjlTZUYG/cuYMnWxOfeTanU/NxFRFKTboEUEREREclADp/ZxokLe80mNZf078rNM/xzbhexcbHcvnMN3zUDKFe0bqolv8Ii7rByxxTeePmDpDcWEXkO6BZIEREREZEMos+Ualy+eYo+b0wzPclTMoaomAgmL+/B1dvncLTLQrmidRn41txUibVi+2TmrR9GlZKNaFqjR6rEEBHJaJQAExERERHJIGb035vWRZAUKpSrTJJP4H1aUvL0aBGRzE63QIqIiIiIiIiISKamBJiIiIiIiIiIiGRqSoCJiIiIiIiIiEimpgSYiIiIyHNgxqr+DPT1ot/U6hw5uxOAruNLMWFpVwACgi4zaFZ9+k+vxf4TvwHwy87ptBmVm0sBp6yOM3BmXQb6ejFo9ivcDrnO1VvnaD0qFyu2TwFg6orevDXSk3V/fmPaZ+Ky9+g8rrjVMc5ePUL/6bUYMLMOE5Z2JT4+no17F9B1fCkOnfbnyq2zDJhZh4Ez6zJ2YXti42IBGD6vGR/OqG11nH3/buLDGbXpN60G89Z/AsD3m0bSc1IFLlz/N9FyXAo4Rc9JFZm/YbjVcZb8Po6Bvl70mVKNHX+vBMDH15uhcxubbffp/NdNx912eDnvjC1s+qys8b8f2jDQ14sPZ9TmwvV/AXh9hBvfrhsKwPglXeg3tTo+vt78fmARkLI2kFEEhQbQf3otBvp6MWJ+CyKjwzl02o8OYwrhd3ApAFv2L6T/9FoMn9eM0IhgIPntCJK+/jbsmUfHsUUYt+gd0z4pOfdJtdlj5/+k//RafDijNr6rBwAQHhlCv2k1zGKLiGRGmgRfRERE5DnQs9lX2BrtuHb7P6au6M2Ybmtxc/ZkUNv5ACzdOo7Or/6PYnkrMHxeMyqXbMAbL/flxIV9yYozvucWbI12bNr3HZv3fUfd8q2pUqIhrer0B6BDgxGUKvASsXExpn18Wn+TrIRCAc9STOm7C4AJS7ty4mJCGVt7DaJCMS/uhN1mdNdfcXZyY976T9hzfB01yzRn9Lu/JitOxeL1qFqqEQAfzapHYMgNAHo2m0iBnKWIiY22KEepAtXo/fpk9p+0PjH1lpcP7eoPITwyhMFzGlC7XEsARr/7q2mbM5cPExkdbnpft/xbnLuavAnVh7ZfiK3RjkOn/Vm5YyoftJpBkdzl6NbkC9M2Q9ovJJ/H/WRkStpARuHilI2ve+/AYDDww6ZR7D76K+4unjSo0hHvim2JiY3m192zmNRrG9v//pm1u2fTxntQstsRJH391XyxBeWK1uWHTSNN+6Tk3CfVZm8FX2VCz9+xt3Pki0UdOHvlb4rkKccnHZawIBlJWxGRjEgJMBEREZFMJi4ujq9/7sGlgJM42mVh7HvrsTXaAQmjPYrmrWCxz9mrf9P79SnY2NiQxSEroRHBODu6PjbOreCrfPVTVyKjwylTqCbdmnxhihMZHU6hXC9a7JPDNU+y63Pk7E7mrh2MrdGO5jV74V2xrWmdna0Dnm4FOHf1H9OyrFmymf5ta7TDYGO0Ks7OI7+wZOs4HOyc6NhwJBWKeQEQGxdLtqy5yfLQ+bhX1wfLYY35G4Zz6LQfdkZ7Puu8AhcndyDhnBXOXTbRfVbunEqLWr1Nyb6khEeFMmFJZwJDb5Ane1EGtZ1vKm9EVAhF85S32MfGxobxSzrhmiUHfVtOJ1e2QlbFyggOnfZj0ZaxGA1GomMiGdFpOa5ZspvWx8bHks+jBKERgaZllwJOUiR3OYxGWyqXaMCk5d2titVvWg0KeL7AuWtH6NRwJDXKNEvy+nNz9iA8MiRZdfp+00gu3PiXoJAb5MpWCJ8235riPKrNZnfNbfq30WCHwWDdtSEikhkoASYiIiKSyez6ZxXuLjnxaf0NcXFxpuUjF7Tk+IU9fPz2Dxb7xMXFYmNjA4Czoxuh4YFJJsAWb/2CVnUGULVUI1Oc67fPM/rHtoRH3mHMe+uJu3v74ZOYt34on3ddhZuzhynOrn9WM3/9MPJ5lMDVOUei+wUEXeavE5vp8ErSI1vi4uJYtGUMk3pvw8HOyRRn7e45/OQ3nqqlGmNv62CxnzXleNCpSwe4cvMMk/vsID4+3rR86ore7Dyykp7NJ1rsc/76cdydPU2JMmus2z2HKiUb0bRGD1NdomOiGDS7PjeDLzOy80qLfXo2n4hrluwcObuD2Wt8+LTTcqvjZQzxjH1vPX4Hl7Ju9xza1R/C8fN7mLqyN/a2jrSu68OpywdMW4eEB5oSSPeuCWsEhdxgxDs/kdU5B0PmNKJGmWbA46+/lCqcuywdXvmEKT/34uh/uylTqEaSbRYSRhQGhd6gUK4yT60sIiLpneYAExEREclkLgac4MVCtQAwGO7/d29kl5VM6/cn89YPs9jHxub+dqGRwThbkWy5dOMELxY2j5MzW0Gm9vuDTo1Gscz/qyephkk88bg5e5jFqfViC+Z+dAQP9/zsPvqrxT5RMZFMWNqZga3nYjQm/ZtvUGjCKBoHOyezOE1r9GD+4BMEBF3k1KUDFvslVY6HXbxxgjJ3z5mNjY0p6fhBq5nMG3ScRVvGWOzz87ZJtKzdP8ljPyrOvbrY2dozuc8ORnRcxncbP7XY596IqLJFanPrztVkxcsIiuetBECxvBW5dDNhXq0XCr7EzP77eLlsSzbsnWe2vbOjG2F35/2y9poAcHXOQc5sBXGyd8b4wAirx11/KfVgnS7fnSssqTYbHHaL6b/0xaf1t0+tHCIiGYESYCIiIiKZTAHPUhw7vxvANPonKiYSACcHFxztnS32KZqnPEfP/UF4VChhidz+GBkdTnDYLbNl+T1Lcey/+3FiYqNNo5qyOLqakknJERx2y2yuKwAbbAgOvWmKc68uAFkcEo8zeXkPWtTq88gRLrdDrhMTG2167+bsyfXA80RFR1jEMRgMONo7Y/9QHGvKERB0yex9fs9SHL97zgDi4+NNx7G3cyKLg+Wou2u3/2PC0i7MXTuYrQcWc+i0v9n62NgYbt+5ZrasQE7zzyY+Pt5U30eV9d4k7xeu/5us0WYZxekrhwA4c+UQeXMUIzomyrTO2dHV4vPN71mSc1ePEBsXy4GTv1G6YA2LYz7cjgDuhN3iRuBFIqLCTA9gSOr6S0pi19+9ujxYp6TabGxsDOMWv0OPZl+Z3Q4pIvI80C2QIiIiIplMzTIt2H10DQNn1sXRwYWx3dYx5se2hIQHEhcfS7fXvrDYp433YMYv6URkdDidGo2yWP/P2Z0cu/AnHV75xLSsXb0hjF/amYVbRlOmcC2a13ifcUs6YrAxYGd0YFDbBUTFRJgdZ+GWMWw9sIj4+HhuBl+mY0PzkUg/b5tEtVKvUbbIy6Zl7772BSPmN8fO1oFmNd7H3taR5dsnAZDPowRVSjZi81/fm7Y/eu4PdhxZwbXb/7Fi+2Ra1u5vmlj+ntmrB/Je0y/xcMsHJCQM2tUbio+vF472zrzT8DPOXz+G38ElxMXHUqGoNwVzvmB2jH3HN1iU42FfLOrAxF5+pvfF81UkZ7ZC9J/+Mva2DnzWeQXfrBvChevHiYmNorX3IItjjOu+EUiYx2r/yd9Mc5Pdc/X2OZZu/ZKBreealr1WvTvjF3fit/0/kDdHMT5oOZOh3zROGHWGDX1bzrCMs6gDd8JvY2NjwwetfC3WZ3S2RjuGzm1MVEwEn3X6mdOXDzJn7SAMNgayOmXn47d/4N8Le8y2f616dwbOrIOLUzaGtV9kccyH2xGAq7MH328eyenLB3mnQUL7Tur62330V5ZsHceVm6cZ9d2bfNb5Z7P1iV1/AOevHWPQ7FfI6V6QMoVrsuaPWY9ts/6Hl3Hiwl7mrh0MQLfXvqBM4ZrJPJMiIhmTEmAiIiIimYzBYMCnjfntTaO6/GKxndFgy4SlXRnUdj6e7vmZ8P7vZut/2Tmdkxf3YWu04+zVv/Gu0NZsfXbX3KbkzD2TepmPTroReJHTlw+yYvsUWtXpT4dXPrH4Ej9x2XumWwFDI4IoU8j8C3nZIi+bnrZ4T62yr5u9d3JwYcnWceTzKEGFYl6sHn3Hor7D5zUj+91J+LM4upolLQBql2tpliirUMyL5jXfN9vGxcmd+RuH4+legFplX7cox6WAU3yzbgh1y7cmKDSA8kXNk1UA775mfpvjh2/Ostgme9bcjJjfnLHvrX+gPN5UKOYNwLbDy9l55Bcql2jImcuHqFfpbfPzYe9skUR5MBF3T3BoAN+uG0q3Jl/wv3fXWKx/sA1kdMXyVqRr49Gm967OOSzaq52tI7uP/kqR3OXwrtiWhlU60rBKR7NtkmpHRoMtPq2/MVuW1PVXo0wz01xh9yR1/QE0rNKJyiUbmN43r/n+Y9ts/UpvU/+hthIeGcK4xe9QqkA1i+OLiGQmNvEPzr75HPH29gbAz8/Pqu33LYHAi6lXHhGR55l7fqjaLvn7qW+WjCY5bV3tW9K7lPbd1nja7f/e6LkHE2Cp5cMZtZncZ0eqx/l+00jKFq5tlgB7FlLzcxcRSU0aASYiIiIiIpnag6PnUtuzSH4BdGo08pnEERHJLDQJvoiIiIiIiIiIZGpKgImIiIiIiIiISKamBJiIiIiIiIiIiGRqSoCJiIiIiIiIiEimlq4nwY+Li2PSpEnMnj2bCxcuUKpUKaZOnUqPHj3w8vJizpw5aV1E5q3/hK0HFhEcdhN7W0fKFa3L+80nkTNbwbQumojIc0t9s2RWWw8uYfWuGZy5fIiI6DA2fhmT1kUSeWbU/kVE5Emk6xFg3bp143//+x89e/Zk/fr1tGnThrfffpszZ85QpUqVtC4eAA2qdGTWgIOsGh3MD8POkdO9IGMW6rnAIiJpSX2zZFYuTtloXrM3vVpMTuuiiDxzav8iIvIk0u0IsMWLF7NgwQL8/Pzw8vICoF69euzfv58VK1ZQuXLlNC5hgoI5XzD9O554bGwMXLjxbxqWSERE1DdLZlWt1KsAHDrtl7YFEUkDav8iIvIk0m0CbOzYsTRu3NiU/LqnePHi2NnZUb58eQIDA/H29jati4qK4tixYxw+fJhy5co9s7L+fmARU1b0IiwiGKPBlvebT3pmsUVEJHHqm0VERERE5J50mQC7ePEiR44cYcCAARbrzp8/z4svvoiDgwMODg4cPHjQtO77779n0qRJzzT5BVC/UnvqV2rPreCrrN/7LUXyPNv4IiJiSX2ziIiIiIjcky7nALt48SIAuXPnNlseHh6Ov7//I29/nDt3Lj169LAqhr+/P/7+/tjY2Fj18vf3S/KY2V1z06R6d4bPa0Zw2C2ryiEiIuDv72d1f6y+WTKy5LR1a9q3SFpKad+t9p+xpebnrpdeeumV3FdypMsEmIeHBwAnTpwwWz5+/HiuXLmS6AT4x48fZ//+/XTo0OGZlPFRYmNjiIgK5Wbw5TQth4iI3Ke+WURERETk+ZYub4EsWrQo5cuXZ+zYsWTPnp18+fKxfPly1q1bB5BoAmzOnDm0adMGNzc3q2LEx8cnq0z7lkDgRfNlcXFxrP5jJl4V2pDNJSc3Ai8y45d+5M5WmIKeLyR+IBERseDl5U28b/L6ZVDfLBlPctp6Yu07Ni6W2NhoomOiAIiKjgDAztYh2b+CijyplPbd1lD7T79S83MXEUlN6TIBZjAYWLZsGT179qRXr17kyJGDzp0706dPH4YNG0b58uXNto+MjOT7779nzZo1z7yse46vY+Hmz4mICsXZyZ0Kxbz5ssdvGI3p8tSKiDwX1DdLZvXbXz/w1U9dTe+bDnMC4IehZ8mdvXAalUrk2VD7FxGRJ5FuvwmULFmSrVu3mi3r2LEjZcqUwcnJyWz5ypUryZMnDzVr1nyWRcRgMDC227pnGlNERB5PfbNkZq9W68Kr1bqkdTFE0oTav4iIPIl0OQfYo+zbty/R2x/nzp1L9+7d06BEIiIiIiIiIiKS3qXbEWAPCwkJ4cSJE/Tu3dti3ZYtW9KgRCIiIiIiIiIikhFkmASYi4sLsbGxaV0MERERERERERHJYDLULZAiIiIiIiIiIiLJpQSYiIiIiIiIiIhkakqAiYiIiIiIiIhIpqYEmIiIiIiIiIiIZGpKgImIiIiIiIiISKamBJiIiIiIiIiIiGRqSoCJiIiIiIiIiEimZpvWBcgosuZM6xKIiGReKe1j1TdLRpOcNqv2LeldarZRtf/0S5+NiGRUNvHx8fFpXQgREREREREREZHUolsgRUREREREREQkU1MCTEREREREREREMjUlwEREREREREREJFNTAkxERERERERERDI1JcBERERERERERCRTUwJMREREREREREQyNSXAREREREREREQkU1MCTEREREREREREMjUlwEREREREREREJFNTAkxERERERERERDI1JcBERERERERERCRTUwJMREREREREREQyNSXAREREREREREQkU1MCTEREREREREREMjUlwEREREREREREJFNTAkxERERERERERDI1JcBERERERERERCRTUwJMREREREREREQytf8DuwgT6MHD/acAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -820,7 +815,7 @@ }, "outputs": [], "source": [ - "opflow_classifier = NeuralNetworkClassifier(\n", + "classifier = NeuralNetworkClassifier(\n", " qnn,\n", " optimizer=COBYLA(maxiter=400), # Set max iterations here\n", " callback=callback_graph,\n", @@ -848,7 +843,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -862,7 +857,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy from the train data : 88.57%\n" + "Accuracy from the train data : 91.43%\n" ] } ], @@ -872,10 +867,10 @@ "\n", "objective_func_vals = []\n", "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", - "opflow_classifier.fit(x, y)\n", + "classifier.fit(x, y)\n", "\n", "# score classifier\n", - "print(f\"Accuracy from the train data : {np.round(100 * opflow_classifier.score(x, y), 2)}%\")" + "print(f\"Accuracy from the train data : {np.round(100 * classifier.score(x, y), 2)}%\")" ] }, { @@ -917,12 +912,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy from the test data : 86.67%\n" + "Accuracy from the test data : 60.0%\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -932,10 +927,10 @@ } ], "source": [ - "y_predict = opflow_classifier.predict(test_images)\n", + "y_predict = classifier.predict(test_images)\n", "x = np.asarray(test_images)\n", "y = np.asarray(test_labels)\n", - "print(f\"Accuracy from the test data : {np.round(100 * opflow_classifier.score(x, y), 2)}%\")\n", + "print(f\"Accuracy from the test data : {np.round(100 * classifier.score(x, y), 2)}%\")\n", "\n", "# Let's see some examples in our dataset\n", "fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={\"xticks\": [], \"yticks\": []})\n", @@ -976,12 +971,6 @@ "[3] Vatan, Farrokh, and Colin Williams. \"Optimal quantum circuits for general two-qubit gates.\" Physical Review A 69.3 (2004): 032315." ] }, - { - "cell_type": "markdown", - "id": "52fccc02", - "metadata": {}, - "source": [] - }, { "cell_type": "code", "execution_count": 16, @@ -993,7 +982,7 @@ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0.dev0+4749eb5
qiskit-aer0.11.0
qiskit-nature0.5.0
qiskit-finance0.4.0
qiskit-optimization0.5.0
qiskit-machine-learning0.5.0
System information
Python version3.8.13
Python compilerClang 12.0.0
Python builddefault, Mar 28 2022 06:16:26
OSDarwin
CPUs2
Memory (Gb)12.0
Thu Sep 15 14:13:57 2022 EDT
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Sun Oct 30 15:41:34 2022 GMT Standard Time
" ], "text/plain": [ "" @@ -1040,7 +1029,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13" + "version": "3.7.9" }, "vscode": { "interpreter": { From 3898b27c1bcab320bb9dd9fc8d139ab00ed0ba39 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Thu, 3 Nov 2022 11:38:10 +0000 Subject: [PATCH 94/96] code review --- docs/tutorials/01_neural_networks.ipynb | 18 ++++- docs/tutorials/05_torch_connector.ipynb | 3 +- .../09_saving_and_loading_models.ipynb | 76 +++++++++---------- 3 files changed, 53 insertions(+), 44 deletions(-) diff --git a/docs/tutorials/01_neural_networks.ipynb b/docs/tutorials/01_neural_networks.ipynb index 03b73e85b..9d7fb428e 100644 --- a/docs/tutorials/01_neural_networks.ipynb +++ b/docs/tutorials/01_neural_networks.ipynb @@ -12,9 +12,11 @@ "Depending on the application, a particular type of network might more or less suitable and might require to be set up in a particular way.\n", "The following different available neural networks will now be discussed in more detail:\n", "\n", - "1. `NeuralNetwork`: The interface for neural networks.\n", + "1. `NeuralNetwork`: The interface for neural networks. This is an abstract class.\n", "2. `EstimatorQNN`: A network based on the evaluation of quantum mechanical observables.\n", - "3. `SamplerQNN`: A network based on the samples resulting from measuring a quantum circuit.\n" + "3. `SamplerQNN`: A network based on the samples resulting from measuring a quantum circuit.\n", + "\n", + "Each implementation, `EstimatorQNN` and `SamplerQNN`, takes in an optional instance of the corresponding Qiskit primitive, namely `BaseEstimator` and `BaseSampler`. The latter two define two interfaces of the primitives. Qiskit provides the reference implementation as well as a backend-based implementation of the primitives. The primitives is a frontend to either a simulator or a real quantum hardware. By default, if no instance is passed to a network, an instance of the Qiskit reference primitive is created automatically by the network. For more information about primitives please refer to [Qiskit primitives](https://qiskit.org/documentation/apidoc/primitives.html)." ] }, { @@ -122,7 +124,7 @@ "id": "still-modeling", "metadata": {}, "source": [ - "Construct EstimatorQNN with the observable, input parameters, and weight parameters." + "Construct EstimatorQNN with the observable, input parameters, and weight parameters. We don't set the `estimator` parameter, the network will create an instance of the reference `Estimator` primitive for us." ] }, { @@ -361,6 +363,14 @@ "qc.draw(output=\"mpl\")" ] }, + { + "cell_type": "markdown", + "id": "olympic-coral", + "metadata": {}, + "source": [ + "As in the previous example, we don't set the `sampler` parameter, the network will create an instance of the reference `Sampler` primitive for us." + ] + }, { "cell_type": "code", "execution_count": 16, @@ -369,7 +379,7 @@ "outputs": [], "source": [ "# specify sampler-based QNN\n", - "qnn4 = SamplerQNN(sampler=Sampler(), circuit=qc, input_params=[], weight_params=qc.parameters)" + "qnn4 = SamplerQNN(circuit=qc, input_params=[], weight_params=qc.parameters)" ] }, { diff --git a/docs/tutorials/05_torch_connector.ipynb b/docs/tutorials/05_torch_connector.ipynb index ca49107a3..58b39087b 100644 --- a/docs/tutorials/05_torch_connector.ipynb +++ b/docs/tutorials/05_torch_connector.ipynb @@ -45,7 +45,6 @@ "from torch.optim import LBFGS\n", "\n", "from qiskit import QuantumCircuit\n", - "from qiskit_aer import Aer\n", "from qiskit.utils import algorithm_globals\n", "from qiskit.circuit import Parameter\n", "from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap\n", @@ -1208,7 +1207,7 @@ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Sat Oct 29 00:40:42 2022 GMT Daylight Time
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.1
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Thu Nov 03 09:57:38 2022 GMT Standard Time
" ], "text/plain": [ "" diff --git a/docs/tutorials/09_saving_and_loading_models.ipynb b/docs/tutorials/09_saving_and_loading_models.ipynb index b9232b8fe..084e67800 100644 --- a/docs/tutorials/09_saving_and_loading_models.ipynb +++ b/docs/tutorials/09_saving_and_loading_models.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "exposed-cholesterol", "metadata": {}, "outputs": [], @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "charming-seating", "metadata": {}, "outputs": [], @@ -81,7 +81,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "ceramic-florida", "metadata": {}, "outputs": [], @@ -102,7 +102,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "dirty-director", "metadata": {}, "outputs": [ @@ -112,7 +112,7 @@ "(40, 2)" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -132,7 +132,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "thorough-script", "metadata": {}, "outputs": [ @@ -146,7 +146,7 @@ " [0.10351936, 0.45754615]])" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "understood-ukraine", "metadata": {}, "outputs": [ @@ -175,7 +175,7 @@ "(40, 2)" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -195,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "german-agreement", "metadata": {}, "outputs": [ @@ -209,7 +209,7 @@ " [1., 0.]])" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -228,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "about-ordinary", "metadata": {}, "outputs": [ @@ -238,7 +238,7 @@ "(30, 2)" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -260,7 +260,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "fifty-scottish", "metadata": {}, "outputs": [ @@ -346,7 +346,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "brief-lending", "metadata": {}, "outputs": [], @@ -364,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "integrated-palestinian", "metadata": {}, "outputs": [], @@ -382,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "periodic-apparel", "metadata": {}, "outputs": [], @@ -424,7 +424,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "electronic-impact", "metadata": {}, "outputs": [], @@ -445,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "revolutionary-freeze", "metadata": {}, "outputs": [], @@ -465,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "suited-appointment", "metadata": {}, "outputs": [ @@ -484,10 +484,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -506,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "id": "greek-memphis", "metadata": {}, "outputs": [ @@ -534,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "broadband-interview", "metadata": {}, "outputs": [], @@ -554,7 +554,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "steady-europe", "metadata": {}, "outputs": [], @@ -567,18 +567,18 @@ "id": "reverse-shaft", "metadata": {}, "source": [ - "Next, we want to alter the model in a way it can be trained further and on another simulator. To do so, we set the `warm_start` property. When it is set to `True` and `fit()` is called again the model uses weights from previous fit to start a new fit. We also set quantum instance of the underlying network to the statevector simulator we created in the beginning of the tutorial. Finally, we create and set a new optimizer with `maxiter` is set to `80`, so the total number of iterations is `100`." + "Next, we want to alter the model in a way it can be trained further and on another simulator. To do so, we set the `warm_start` property. When it is set to `True` and `fit()` is called again the model uses weights from previous fit to start a new fit. We also set the `sampler` property of the underlying network to the second instance of the `Sampler` primitive we created in the beginning of the tutorial. Finally, we create and set a new optimizer with `maxiter` is set to `80`, so the total number of iterations is `100`." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "accessible-cowboy", "metadata": {}, "outputs": [], "source": [ "loaded_classifier.warm_start = True\n", - "loaded_classifier.neural_network.sampelr = sampler2\n", + "loaded_classifier.neural_network.sampler = sampler2\n", "loaded_classifier.optimizer = COBYLA(maxiter=80)" ] }, @@ -592,7 +592,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "metric-cyprus", "metadata": { "nbsphinx-thumbnail": { @@ -615,10 +615,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -629,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "bronze-spread", "metadata": {}, "outputs": [ @@ -657,7 +657,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "catholic-norway", "metadata": {}, "outputs": [], @@ -676,17 +676,17 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "id": "tested-handling", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 24, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, @@ -764,14 +764,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "id": "persistent-combine", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Sun Oct 30 14:46:07 2022 GMT Standard Time
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.1
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Thu Nov 03 10:21:38 2022 GMT Standard Time
" ], "text/plain": [ "" From 7098caefe88779c0ad4c0efe5e86a348e9b78483 Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 4 Nov 2022 00:39:24 +0000 Subject: [PATCH 95/96] update qcnn --- docs/tutorials/11_qcnn_initial_point.json | 1 + ...uantum_convolutional_neural_networks.ipynb | 45 +++++++++++-------- 2 files changed, 27 insertions(+), 19 deletions(-) create mode 100644 docs/tutorials/11_qcnn_initial_point.json diff --git a/docs/tutorials/11_qcnn_initial_point.json b/docs/tutorials/11_qcnn_initial_point.json new file mode 100644 index 000000000..142b3c452 --- /dev/null +++ b/docs/tutorials/11_qcnn_initial_point.json @@ -0,0 +1 @@ +[1.930057091422052, 0.2829424508139703, 0.35555636265939633, 0.1750006532903061, 0.3002103666790018, 0.6641911912373437, 1.3310981300850042, 0.5022717197547227, 0.44912874128880675, 0.40236963192983266, 0.3459537084665159, 0.9786311288435154, 0.48716712269991697, -0.007081389738930712, 0.21570815199311827, 0.07334182375267477, 0.6907887498355103, 0.21771166428570735, 1.087665977608006, 1.2571463700739218, 1.0866597360102666, 2.126145551821481, 0.8914518096731741, 1.5053260036617715, 0.44798876926441555, 0.9498701675467225, 0.15490304396579338, 0.1338674031994701, -0.6938374500039391, 0.029396385425104116, -0.09785818314088227, -0.31198441382224246, 0.20004568516690807, 1.848494069662786, -0.028371899054628447, -0.15229494459622284, 0.7653870524298326, 0.6881492316484289, 0.6759011152318357, 1.6028387103546868, 0.47711915171800057, -0.26162053028790294, -0.12898443497061718, 0.5281303751714184, 0.4957555866394333, 1.6095784010055925, 0.5685823964468215, 1.2812276175594062, 0.3032325725579015, 1.4291081956286258, 0.7081163438891277, 1.8291375321912147, -0.11047287562207528, 0.2751308409529747, 0.2834764252747557, 0.29668607404725605, 0.008300790063532154, 0.6707732056265118, 0.5325267632509095, 0.7240676576317691, 0.08123934531343553, -0.0038536767244725153, -0.1001165849018211] \ No newline at end of file diff --git a/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb b/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb index f03991312..0cfad3076 100644 --- a/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb +++ b/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb @@ -43,6 +43,7 @@ }, "outputs": [], "source": [ + "import json\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from IPython.display import clear_output\n", @@ -576,7 +577,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -701,7 +702,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "id": "cc478975", "metadata": { "scrolled": true @@ -737,8 +738,9 @@ "\n", "observable = SparsePauliOp.from_list([(\"Z\" + \"I\" * 7, 1)])\n", "\n", + "# we decompose the circuit for the QNN to avoid additional data copying\n", "qnn = EstimatorQNN(\n", - " circuit=circuit,\n", + " circuit=circuit.decompose(),\n", " observables=observable,\n", " input_params=feature_map.parameters,\n", " weight_params=ansatz.parameters,\n", @@ -747,7 +749,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "id": "a4f6b6e7", "metadata": { "scrolled": false @@ -760,7 +762,7 @@ "
" ] }, - "execution_count": 11, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -779,7 +781,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "id": "d97cc662", "metadata": { "scrolled": true @@ -803,23 +805,28 @@ "source": [ "In this example, we will use the COBYLA optimizer to train our classifier, which is a numerical optimization method commonly used for classification machine learning algorithms.\n", "\n", - "We then place the the callback function, optimizer and operator of our QCNN created above into Qiskit's built in Neural Network Classifier, which we can then use to train our model. " + "We then place the the callback function, optimizer and operator of our QCNN created above into Qiskit's built in Neural Network Classifier, which we can then use to train our model. \n", + "\n", + "Since model training may take a long time we have already pre-trained the model for some iterations and saved the pre-trained weights. We'll continue training from that point by setting `initial_point` to a vector of pre-trained weights." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "id": "f2949fc6", "metadata": { "scrolled": true }, "outputs": [], "source": [ + "with open(\"11_qcnn_initial_point.json\", \"r\") as f:\n", + " initial_point = json.load(f)\n", + "\n", "classifier = NeuralNetworkClassifier(\n", " qnn,\n", - " optimizer=COBYLA(maxiter=400), # Set max iterations here\n", + " optimizer=COBYLA(maxiter=200), # Set max iterations here\n", " callback=callback_graph,\n", - " initial_point=algorithm_globals.random.random(qnn.num_weights),\n", + " initial_point=initial_point,\n", ")" ] }, @@ -835,7 +842,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "id": "0219ff4a", "metadata": { "scrolled": false @@ -843,7 +850,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -857,7 +864,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy from the train data : 91.43%\n" + "Accuracy from the train data : 88.57%\n" ] } ], @@ -878,7 +885,7 @@ "id": "e95d1100", "metadata": {}, "source": [ - "As we can see from above, the QCNN converges after approximately 400 iterations. The next step is to determine whether our QCNN can classify data seen in our test image data set. " + "As we can see from above, the QCNN converges slowly, hence our `initial_point` was already close to an optimal solution. The next step is to determine whether our QCNN can classify data seen in our test image data set. " ] }, { @@ -899,7 +906,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "id": "7f2a34ae", "metadata": { "scrolled": false, @@ -912,12 +919,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy from the test data : 60.0%\n" + "Accuracy from the test data : 80.0%\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAFoCAYAAACxJDqfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAhdklEQVR4nO3dedRdVX3/8c8HkpCBAEkILIIhkVGZSlERKVniAn5UJrUuQaGI1FSjq2oVLEpBwkzVpdb6K7rASgTKUHWhhVAhlggyCMQyN8xDgAAhCUmYA/n2j70fcnJzx2fIfZ6d92utu9a995yzz973nrvv5+yz7/M4IgQAAFCqDbpdAQAAgIFE2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAULR1HnZsz7R98breb2ls72f7qcrj+2zv18061Fn+Y9un9KLcl2xv27fadZftk2xf0McyptoO28M63G6a7Qf6su9S0N/0D/qbwcf2NbaP7XY9qnJ/tX2H22yT34MNB6pe0gCEnVzpntsq269WHh89APvbx/Z/215he5nt39h+V806m9j+ge0ncz0eyY83z8sft/287TGVbabbnlt5HLbvsb1B5bkzbV/Y323qjYjYJSLmtlqvNwdjb7eNiBkRcUan+4mIjSPi0U63a5ft+bb/ps7zX7F9Ry/KW6sTjoizI2J6X+rZxn4ft31A7fMRcWNE7DSQ+x4s6G+6g/6mM/Xa0tcgHhEfjohZfa9dfa3CZS/Km2t7rT4xIp7M78Fb/bWvevo97ORKbxwRG0t6UtJhlecu6c992f6ApGsl/VrSJEnvlHS3pJtsT83rjJD0O0m7SPpLSZtI+oCkxZL2qhS3oaSvtNjlJEmf7L8WrDbQqRZrmCXp03WePyYva1unoy7oX/Q3vUN/M3Q5YQpKh7r1go2w/fN8dnSf7ff2LLA9yfYvbS+y/ZjtLzcp59uSfh4R/xwRKyJiSUScLOk2SafmdT4taRtJH4uI+yNiVUQ8HxFnRMTsSlnfkXSC7c1a7O+0dr7gelKx0+WMF/LZ3NGV5RfaPs/2bNsvS/pQs7bbHpW3WWr7fknvq9nf22f5tjfM+30kv8bzbE+2fUNe/a58xnmk7c1tX2X7RdtLbN9Y74NUb9vKsuPzmepC28fVtPHMfL+t/eR13z4Lsn2w7ftzO562fUKDbbbLZ9yL8+t9SZP38iJJ+9qeUtl+Z0m7S7rU9ka2v5vPzJ9zGh4fldfreV9PtP2spEslXSNpklePKEyqPWuzva/tm3P7F9j+TH7+ENv/Y3t5fn5mgzq3rfaMLB8bJ9i+22k04nLbIyvLD7V9Z67bzbZ372sdBhn6G/qbbvY3bXEaNbw9f0Zvt71PZdlc22fZvknSK5K2dWWkxHbP69RzC+fLjLYPz8f9i3mbd1fKrds3OI061uvX9rJ9Sy5roe0fOQX8vrR7qiuX63Mdz7B9U34frnUeFc3L9/bqvvQut3s5NSIG7CbpcUkH1Dw3U9Jrkg5WOrs5R9KtedkGkuZJ+pakEZK2lfSopIPqlD1a0luSPlRn2XGSns73L5M0q516SvqVpDPzc9Mlza2sE5J2yPWbnp87U9KFDcrcT9Kbkr4naSNJH5T0sqSd8vILJS2T9Be53aObtV3SuZJulDRe0mRJ90p6qt5rLenrku6RtJMkS/ozSRMq7di+st05kn4saXi+TZPkBm2q3banjafnbQ9W+iCOq7TxzL7sR9JCSdPy/XGS9mywzfaSDsyv9URJN0j6QZP3/DpJJ9e8Dlfm+9+X9Jv8Wo+V9J+Szqlp8z/lfY3Kzz1VU/5MSRfn+1MkrZD0qdz2CZL2qJS3Wz4Gdpf0nKSP5mVT82sxrN3PV6XM2mPjNqWRgvGS/lfSjLzszyU9L+n9Sp/HY/P6Gw1k3zAQt3qvh+hv6G8GR3+zRlvq9BHjJS1VGl0eptRXLK28jnOVRi53ycuH5+em19nX5yTNVxpV3DEfBwfmbf5B0sOSRrTRN+yntfu190jaO9dhal7/75u1s7KsUX2nqtLP5fUeyXUflR+fm5dtrTRKerDScXxgfjyxVf/QrZGdP0TE7EjX6C5S+nBI6exhYkScHhFvRLqOer7qD+WOV2rswjrLFiodgFL6Yqm3Tj3fkvQl2xMbLA9Jp0g6pYM0e0pEvB4Rv5d0taQjKst+HRE3RcQqpS+8Zm0/QtJZkc4mF0j6YZN9Tlf6In8gkrsiYnGDdVdK2krSlIhYGWm+Ryf/MG2lpNPztrMlvaTU6fXXflZK2tn2JhGxNCL+VG+liHg4Iq7Lr/UipU7/g03KnaXUsSif8R0taZZtK3UWX82v9QpJZ2vNY3CVpFPzvl5tow1HSZoTEZfmti+OiDtzvedGxD2RRgDuVhopalbv3vphRDwTEUuUwtse+fnPSfpJRPwxIt6KNAfgdaUOrRT0Nwn9TXvlD0R/I0l/yqMRL9p+UdI3KssOkfRQRFwUEW9GxKVKgeWwyjoXRsR9efnKejuwva9SKD48IpZLOlLS1bmuKyV9VylA7FPZrFHfUK/d8yLi1lyHxyX9pI1298bPIuLB3L9eUanTX0uanT/PqyLiOkl3KIWfproVdp6t3H9F0sg8hDVFadisekCcJGnLOmUsVfrS2arOsq0kvZDvL26wzloi4l5JV2nNg7B2ndmSnpL0+TaKXBoRL1ceP6GUoHssqNxv1fZJNes/0WS/k5WScTu+o5T0r7X9qO2GbW9gcUS8WXn8iqSN+3E/H1c6kJ+w/XuneRNrsb2l7cvy0PNySRdL2rzeutmvJG1le2+lM5jRSl8OE/P9eZX34b+0+stMkhZFxGtt1l9q8n7Yfr/t650uJSyTNKNFvXur9jPX8x5NkXR8zXE3WWsep0Md/U1Cf9PaQPU3Uhol2qznpjR61mOS1n6Nn1AayeixQE3YnqwUDI6NiAfrlZuD7oKachv1DfX2saPT5cFnc7vP1rrvrz5Rc9zuqzY+c4NtktMCSY9VD4iIGBsRa6W2/KG+RdIn6pRzhNLQlyTNkXSQK798aOFUSX+rNQ+GWv+o1DGMblHWuJr9biPpmcrj6plGq7YvVOpUqmU1skDSdi3qliqQ5h4cHxHbSjpc0tds79/Otp3o7X4i4vaI+IikLSRdqfRhrudspddzt4jYROkMwE3KfUXSL5TmWBwj6bKIeEPpS+tVSbtU3odNI02AfXvz2uJaNKPZ+/HvSpfMJkfEpkpD7w3rPQAWKJ3BV4+70fnMsnT0N/Q3tdsNSH/ThmeUvsirtpH0dLV6jTZ2mlN4pdKltGsalZtHrifXlNtIvf2dpzTitENu90la9/3VRTXH7ZiIOLfVhoMt7NwmaYXT5M9RThPfdrX9vgbrf0PSsba/bHus7XFOE9SmKR2MUhq2XiDpl7bfZXsD2xOcJtTV69QelnS5pIYTFSP95PJepfkNrZxme4TtaZIOlfQfDdZr1fYrJH0zt/Edkr7UZJ8XSDrD9g5Odrc9IS97Tun6vKS3J6dunz8Ey5TmJaxqUO4a23aiw/30bDPC9tG2N81DsMubbDNWaUh7me2tleYRtDJLaZj34/l+z5nP+ZK+b3uLXI+tbR/UpJznJE2wvWmD5ZdIOsD2EbaH5eNvj0q9l0TEa7b3Urrk1YnhThMKe26d/jrsfEkz8giTbY9xmjQ9tsNyhiL6G/qb6jYD3d80M1vSjraPyn3EkZJ2Vhr5a8e/SZofEd+uef4KSYfY3t/2cEnHK12mvrmNMuv1a2OVXpeXnP7kwhfarF+PYTX91fAOt79Y0mG2D8rH7EinyfnvaLXhoAo7ka6pH6p0fe4xpbPsCyTV/RKJiD9IOkjSXymdiSxR6hD2z0PEiojXlSYDzlealLpc6YO+uaQ/NqjK6ZJanZmdrHQdv5lnlYa/n1H6wpsREfMbtKVV209TGo58TOnnrxc12e/3lA7ya5Xa+1Ol67RSmhQ3y2kI8AilSZBzlD64t0j614i4vkG5tdt2opP9VB0j6XGnIdMZSnNr6jlN0p5KHdvVSpepWrkhr/9URNxeef5EpSHwW/N+56j+vABJUn5PL5X0aH5tJtUsf1JpaPx4pWP0Tq2eN/JFSafbXqE0h6PRmWQjs5VGonpuMzvZOCLuUBpZ+JHSsfqwpM90WIchif6G/qaOgexvGoo0x+lQpT5isdJE4kMj4oWmG672SUkf85q/yJoWEQ8ojTr9i9J7fJjSn2d4o4061evXTlA6IVuhdKJ0eUcNTSND1f7qZ51sHGn+2EeURpQWKZ1YfF1tZBlHR3PDBjenn8xeL+moiPhtl+uyn9JM+5aJE8DQQ38DDB2DamSnryL9muWjknbrxXA+ALSN/gYYOor7gEbEjUp/HwIABhT9DTA0FHUZCwAAoFZRl7EAAABqEXYAAEDROpqzM3zEmBg5ctxA1WVIeGvkuvz7SYPTsEUvt15pPRCbtvobb+V7adnTL0REo393MKA2HD0mhm/W6tfYheN0VbtOWNTtKgwKDzw2EH/IeGh5aUXj/qijsDNy5Di9d6+/659aDVFL3r1Rt6vQdVv8/3b+HlX5Xp/W6G/PrT9uvOrEZv9GYEAN32y8pnz+a93a/aCwagRzLm877rxuV2FQ2P+Yz3a7Cl03d843G/ZHnBcAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAijask5V3eucL+t3FPx2oumCI2POtL3S7CoPClrcu63YV1msbvCmNei66XY2uGrV4VbergEFi2O/mdbsKgxojOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBojoj2V7YXSXpi4KoDYIiZEhETu7Fj+iMANRr2Rx2FHQAAgKGGy1gAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICi9XvYsT3T9sX9Xe76xvZ+tp+qPL7P9n7drEOd5T+2fUovyn3J9rZ9q926Z/sa28d2ux5VtsP29h1us01+DzYcqHoNFfRX/YP+anCzfZLtC/pYxtTc3wzrcLtpth/oy777Q8dhJ7/xPbdVtl+tPD66vytoex/b/217he1ltn9j+10162xi+we2n8z1eCQ/3jwvf9z287bHVLaZbntu5XHYvsf2BpXnzrR9YX+3qTciYpeImNtqvd58+fV224iYERFndLqfiNg4Ih7tdLtO1GtLX7/YIuLDETGr77Wrr1Vn3Yvy5tqeXvt8RDyZ34O3+mtfgxX9VXfQX7XP9nzbf1Pn+a/YvqMX5a3Vj0TE2RGxVl/Qn/Jxe0Dt8xFxY0TsNJD7bkfHYSe/8RtHxMaSnpR0WOW5S/qzcrY/IOlaSb+WNEnSOyXdLekm21PzOiMk/U7SLpL+UtImkj4gabGkvSrFbSjpKy12OUnSJ/uvBatxFj10OeGS7xBEf9U79Ffr1CxJn67z/DF5Wds6HXVZnwxUBz7C9s/z2c19tt/bs8D2JNu/tL3I9mO2v9yknG9L+nlE/HNErIiIJRFxsqTbJJ2a1/m0pG0kfSwi7o+IVRHxfEScERGzK2V9R9IJtjdrsb/T2jlgetJzHh58IafaoyvLL7R9nu3Ztl+W9KFmbbc9Km+z1Pb9kt5Xs7+3U7PtDfN+H8mv8Tzbk23fkFe/K58xHml7c9tX2X7R9hLbN9b74q63bWXZ8flMc6Ht42raeGa+39Z+8rpvn5HZPtj2/bkdT9s+ocE22+Uz5sX59b6kxXvZktNZ+O1OZ+C3296nsmyu7bNs3yTpFUnbujJSYrvndeq5hfOwve3D83H/Yt7m3ZVyH7d9gu27834vtz3S6Sz+GkmTKmVOsr2X7VtyWQtt/yh/Yfal3WsMR+c6nmH7pvw+XOs8ypCX72375lyHu7yOL0+sA/RX9Ffd7K8ukrSv7SmV7XeWtLukS21vZPu7TiOBzzldjhuV1+t5X0+0/aykS1W/H1ljVNv2vpXP9ALbn8nPH2L7f2wvz8/PbFDntnntS5x1+8DK8kNt35nrdrPt3ftaB0lSRPT6JulxSQfUPDdT0muSDlY6OzlH0q152QaS5kn6lqQRkraV9Kikg+qUPVrSW5I+VGfZcZKezvcvkzSrnXpK+pWkM/Nz0yXNrawTknbI9ZuenztT0oUNytxP0puSvidpI0kflPSypJ3y8gslLZP0F7ndo5u1XdK5km6UNF7SZEn3Snqq3mst6euS7pG0kyRL+jNJEyrt2L6y3TmSfixpeL5Nk+QGbardtqeNp+dtD1b64h9XaeOZfdmPpIWSpuX74yTt2WCb7SUdmF/riZJukPSDJu/5Gm2pHJsX5/vjJS1VOnsaJulT+XHP6zhXaSRgl7x8eH5uep19fU7SfKWz9B3zcXBg3uYfJD0saUTlfbxN6ax8vKT/lTSj8no/VVP2eyTtneswNa//983aWVnWqL5T83bDKus9kus+Kj8+Ny/bWmnU4WCl4/jA/HhiX/qObtxEf0V/NXj7q+sknVzzOlyZ739f0m/yaz1W0n9KOqemzf+U9zVK9fuRmVrd902RtEKpzxsuaYKkPSrl7ZaPgd0lPSfpo/X6jXY+X5Uya4+NRn3gn0t6XtL7lT6Px+b1N+rr53+gRnb+EBGzI80JuEjp4JZS+p8YEadHxBuRroOer/pDseOVXvCFdZYtVDqApPRG1Vunnm9J+pLtiQ2Wh6RTJJ3i9s+eT4mI1yPi95KulnREZdmvI+KmiFildAA1a/sRks6KdDa4QNIPm+xzutIH44FI7oqIxQ3WXSlpK0lTImJlpOun0WbberY/PW87W9JLSp1Wf+1npaSdbW8SEUsj4k/1VoqIhyPiuvxaL1LqtD/Youw/5bODF22/KOkblWWHSHooIi6KiDcj4lKlwHJYZZ0LI+K+vHxlvR3Y3lfpS+bwiFgu6UhJV+e6rpT0XaUOaJ/KZj+MiGciYolSx7VHowZExLyIuDXX4XFJP2mj3b3xs4h4MCJelXRFpU5/LWl2/jyviojrJN2h9EVSCvqrhP6qvfIHor+apXTipTzCdLSkWbatdDL11fxar5B0ttY8BldJOjXv69U22nCUpDkRcWlu++KIuDPXe25E3JM/63crjRQNRH/TqA/8nKSfRMQfI+KtSHMkX1c64euTgQo7z1buvyJpZB5qnaI0vFb9AjpJ0pZ1yliq9CZuVWfZVpJeyPcXN1hnLRFxr6SrtOaXXu06syU9JenzbRS5NCJerjx+Qimt9lhQud+q7ZNq1n+iyX4nK52Jt+M7SiML19p+1HbDtjewOCLerDx+RdLG/bifjyt9cT5h+/dO8x7WYntL25floePlki6WtHm9dSv2jIjNem5KZ6M9Jmnt1/gJpZGMHgvUhO3JSsHg2Ih4sF65+YtjQU25tZ+Peq9nzz52zMPtz+Z2n63W7e6NRnWaIukTNcftvmrzMzdE0F8l9FetDVR/9StJW9neW2kkZLRSGJ2Y78+rvA//pdXhWZIWRcRrbdZfavJ+2H6/7eudLl0ukzSjRb17q1l/c3zNcTdZax6nvbKuJ10ukPRY9QsoIsZGxFpniflDeYukT9Qp5wiloXZJmiPpIFd+udDCqZL+Vmt++dT6R6UP9ugWZY2r2e82kp6pPK6eKbRq+0KlN7VaViMLJG3Xom6pAmnuwPERsa2kwyV9zfb+7Wzbid7uJyJuj4iPSNpC0pVK4aGes5Vez90iYhOlEQf3ocrPKH2wqraR9HS1eo02ztfMr1Qamr6mUbn5zGxyTbmN1NvfeUojTjvkdp+kvrW7UwskXVRz3I6JiHNbbjn00V/RX9VuNyD9VUS8IukXSnO6jpF0WUS8oRSSX5W0S+V92DTShPu3N68trkUzmr0f/650yWxyRGyqdKlvXfc3Z9Ucd6Mjjbz3yboOO7dJWpEnU41ymri2q+33NVj/G5KOtf1l22Ntj3OaYDZN6WCS0rDzAkm/tP0u2xvYnuA0Ia5ep/SwpMslNZxoGOknk/cqXS9s5TTbI2xPk3SopP9osF6rtl8h6Zu5je+Q9KUm+7xA0hm2d3Cyu+0JedlzStfXJb092Wv7/KW7TGlewaoG5a6xbSc63E/PNiNsH21700iXfJY32Was0pD0MttbK80D6IvZkna0fZTtYU4THHdWOpNux79Jmh8R3655/gpJh9je3/ZwSccrDcPe3EaZz0maYHvTynNjlV6Xl5x+wvyFNuvXY5jTBOie2/AOt79Y0mG2D8rH7EinCYfv6LCcoYj+iv6qus1A91ezlC6Dfzzf7xkZPl/S921vkeuxte2DmpRTrx+pukTSAbaPyH3fBNt7VOq9JCJes72X0iWvTgyv6W86/XXY+ZJmOI0w2fYYp0nTYzssZy3rNOxEuiZ+qNL1uceUUusFkuq+KRHxB0kHSforpTOJJUof6P3zEK8i4nWlyXzzlSZ5LVf6oG4u6Y8NqnK6pFZnVicrXYdv5lml4etnlA6gGRExv0FbWrX9NKWh4MeUfr56UZP9fk+ps7lWqb0/VZoXIqWJaLOchgCPUJrEOEfpg3eLpH+NiOsblFu7bSc62U/VMZIedxrqnaF0rbqe0yTtqdQxXa007NtrkeYMHKoURhYrTSQ+NCJeaLrhap+U9DGv+YusaRHxgNJZ3L8ovceHKf3c+Y026jRf6Rr5o/k9mCTpBKUOZ4VSR3B5Rw1NI0OvVm4/62TjSPMxPqI0crBI6Yv661oP/vo6/RX9VR0D2V/dkNd/KiJurzx/otIlt1vzfueo/jwkSQ37keryJ5UuxR2vdIzeqdXz1L4o6XTbK5TmjDUauWpkttbsb2Z2snFE3KE0kvkjpWP1YUmf6bAOdTk6mvvVXU4/Qbte0lER8dsu12U/pdnt68MZLoAO0V8Bg8eQOjuLNDv8o5J268XwGACsM/RXwOAx5D6AEXGj0t93AIBBjf4KGByG1GUsAACATg2py1gAAACdIuwAAICidTRnZ/PxG8bUyZ3+mQ6U5qGHWv3Cdf0Qr3byR0vLtEJLX4iIRv/OYEBtOGZMDN9s/T4Wd918Uber0HUPPTiu21UYFGJDxi5WvPxMw/6oo7AzdfJw3fbbya1XRNE+/P/q/Wug9c+qe+v+iZL1ypz4RbN/EzCghm82XpO/+NVu7X5QuO2z53W7Cl138IFHtl5pPfDW2I26XYWum3PLtxr2R0RBAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIN62Tlh+7dWB/eadpA1WVIeP5Tu3a7Cl038YF53a7CoLDygPd0uwrdd90vurbrjZa8qe0uW9K1/Q8Kn+12BbrvzU1HdrsKg4JvvqvbVRjUGNkBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABFI+wAAICiEXYAAEDRCDsAAKBohB0AAFA0wg4AACgaYQcAABSNsAMAAIpG2AEAAEUj7AAAgKIRdgAAQNEIOwAAoGiEHQAAUDTCDgAAKBphBwAAFI2wAwAAikbYAQAARXNEtL+yvUjSEwNXHQBDzJSImNiNHdMfAajRsD/qKOwAAAAMNVzGAgAARSPsAACAohF2AABA0Qg7AACgaIQdAABQNMIOAAAoGmEHAAAUjbADAACKRtgBAABF+z9MTtfl8RjLOwAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -973,7 +980,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "id": "220ffdcf", "metadata": { "scrolled": false @@ -982,7 +989,7 @@ { "data": { "text/html": [ - "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.0
qiskit-aer0.11.0
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Sun Oct 30 15:41:34 2022 GMT Standard Time
" + "

Version Information

Qiskit SoftwareVersion
qiskit-terra0.22.1
qiskit-aer0.11.1
qiskit-ignis0.7.0
qiskit0.33.0
qiskit-machine-learning0.5.0
System information
Python version3.7.9
Python compilerMSC v.1916 64 bit (AMD64)
Python builddefault, Aug 31 2020 17:10:11
OSWindows
CPUs4
Memory (Gb)31.837730407714844
Fri Nov 04 00:37:45 2022 GMT Standard Time
" ], "text/plain": [ "" From 06c9336c70a5b06ae0ef6d2b843a3ec65c90f73f Mon Sep 17 00:00:00 2001 From: Anton Dekusar Date: Fri, 4 Nov 2022 00:53:18 +0000 Subject: [PATCH 96/96] fix spell --- .pylintdict | 1 + 1 file changed, 1 insertion(+) diff --git a/.pylintdict b/.pylintdict index 84865b87c..badc7dc32 100644 --- a/.pylintdict +++ b/.pylintdict @@ -70,6 +70,7 @@ expressibility farrokh fidelities formatter +frontend func gambetta gaussian