From 3e446fd1df95d79e025fd11badcc8e5490bb16e9 Mon Sep 17 00:00:00 2001 From: "M. Emre Sahin" <40424147+OkuyanBoga@users.noreply.github.com> Date: Mon, 9 Dec 2024 12:03:18 +0000 Subject: [PATCH] [Stable] Pre-release Preparation for 0.8.1 (#874) * Fix StackOverflow formatting typo in `README.md` (#847) * Fix StackOverflow formatting typo * Bump numpy version to 2 * Post release 0.8 (#844) * Change version and activate stable tutorial tests * Bump VERSION.txt * Cleanup and bugfix to support different primitives. (#55) (#855) * Cleanup and bugfix for different primitives support (#55) * Quick fix and lint for unit tests. * Fixed a bug in ComputeUncompute and lint corrections. * Fix formatting for algorithm tests * Reformatting some variables to make lint compliant. * Refactor: Cleanup code, preserve existing formatting, apply minor bug fixes, and update missing documentation * Removing unsupported classes. * Fix for lint * Fix lint errors uncovered during workflow checks * Adjust a unit test to accomodate noise-related variations * Docs 0p8 clean (#857) * Reducing numpy version for deploy-docs.yml to fix numpy 2.0 bug (#851) * Update deploy-docs.yml (#853) - Updated Python version from 3.9 to 3.10. - Removed version constraint on torchvision. - Removed Numpy version constraint. * Update deploy-docs.yml to '3.10' (#854) --------- Co-authored-by: M. Emre Sahin <40424147+OkuyanBoga@users.noreply.github.com> Co-authored-by: Oscar <108736468+oscar-wallis@users.noreply.github.com> * Remove `fastdtw` (#861) * ci(mergify): upgrade configuration to current format (#860) Co-authored-by: Mergify <37929162+mergify[bot]@users.noreply.github.com> * [Docs] Fix TOCs and update QNN derived primitives (#862) * Fix docs and update QNN derived primitives * Fix LearningRate in TOCs * Fix string formatting * Fix spelling * Fix spelling * Fix spelling * Fix copyright * Pin Qiskit to `<1.3` (#865) * Added callback function support for adam-amsgrad optimizer. (#869) * Added callback functionality to ADAM optimiser * Added unittest for callback function * Cumulative update to extend the V2 support for algorithms, updated tutorials, and partial multiclass support for VQC. (#870) * Added migration guide for 0.8 * Added V2 support for algorithms * V2 support added for unit tests of the algorithms and tutorials are updated for V2 * Spell check and lint * Update 02_migration_guide_0.8.rst * Update 02_migration_guide_0.8.rst adding optimisation level * Bugfix for V2 primitives without transpilation * Fix tutorials and release notes * Update 04_torch_qgan.ipynb * Bugfix for Qiskit 1.x register name ambiguity * Restored docs * Typo fix in gradients --------- Co-authored-by: smens <88490989+smens@users.noreply.github.com> Co-authored-by: Oscar <108736468+oscar-wallis@users.noreply.github.com> * Add predict_proba Support to PegasosQSVC and NeuralNetworkClassifier (#871) * Adding a predict_proba function to classifiers. (#57) * Update README.md * Predict proba for NNC and PegQSVC * Rewriting predict proba features and docstring It was very inefficient before and didn't have the validation checks needed. The code is now more clear and docstring has been added. * Tweak documentation for NNC and PegasosQSVC, silence lint E1101 on torch connector * Update test with `QNN.predict_proba` * Update test with `PegasosESVC.predict_proba` * Added a release note and solved conflicts with main --------- Co-authored-by: FrancescaSchiav Co-authored-by: oscar-wallis <108736468+oscar-wallis@users.noreply.github.com> Co-authored-by: Edoardo Altamura <38359901+edoaltamura@users.noreply.github.com> Co-authored-by: smens <88490989+smens@users.noreply.github.com> * Reformatted docs * Fix usage of sklearn --------- Co-authored-by: FrancescaSchiav Co-authored-by: oscar-wallis <108736468+oscar-wallis@users.noreply.github.com> Co-authored-by: Edoardo Altamura <38359901+edoaltamura@users.noreply.github.com> Co-authored-by: smens <88490989+smens@users.noreply.github.com> * Bump version to 0.8.1 Update version for bug-fix release --------- Co-authored-by: Edoardo Altamura <38359901+edoaltamura@users.noreply.github.com> Co-authored-by: Oscar <108736468+oscar-wallis@users.noreply.github.com> Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com> Co-authored-by: smens <88490989+smens@users.noreply.github.com> Co-authored-by: FrancescaSchiav --- .github/workflows/main.yml | 60 +-- .mergify.yml | 22 +- .pylintdict | 2 + .../qiskit_machine_learning.gradients.rst | 6 + .../qiskit_machine_learning.optimizers.rst | 6 + ...skit_machine_learning.state_fidelities.rst | 6 + docs/migration/02_migration_guide_0.8.rst | 396 ++++++++++++++++++ docs/tutorials/01_neural_networks.ipynb | 30 +- ...ral_network_classifier_and_regressor.ipynb | 30 +- ...ng_a_quantum_model_on_a_real_dataset.ipynb | 8 +- docs/tutorials/03_quantum_kernel.ipynb | 22 +- docs/tutorials/04_torch_qgan.ipynb | 9 +- docs/tutorials/05_torch_connector.ipynb | 26 +- docs/tutorials/07_pegasos_qsvc.ipynb | 12 +- .../tutorials/08_quantum_kernel_trainer.ipynb | 16 +- .../09_saving_and_loading_models.ipynb | 12 +- docs/tutorials/10_effective_dimension.ipynb | 15 +- ...uantum_convolutional_neural_networks.ipynb | 27 +- docs/tutorials/12_quantum_autoencoder.ipynb | 18 +- .../13_quantum_bayesian_inference.ipynb | 130 +++--- qiskit_machine_learning/VERSION.txt | 2 +- qiskit_machine_learning/__init__.py | 3 + .../algorithms/__init__.py | 23 +- .../classifiers/neural_network_classifier.py | 57 ++- .../algorithms/classifiers/pegasos_qsvc.py | 59 ++- .../algorithms/classifiers/qsvc.py | 4 +- .../algorithms/classifiers/vqc.py | 35 +- .../algorithms/inference/qbayesian.py | 29 +- .../algorithms/regressors/qsvr.py | 4 +- .../algorithms/regressors/vqr.py | 12 + .../algorithms/trainable_model.py | 6 +- .../circuit/library/__init__.py | 6 +- .../connectors/__init__.py | 4 +- qiskit_machine_learning/datasets/__init__.py | 4 +- qiskit_machine_learning/gradients/__init__.py | 11 +- .../lin_comb/lin_comb_sampler_gradient.py | 6 +- .../param_shift_sampler_gradient.py | 7 +- .../gradients/spsa/spsa_sampler_gradient.py | 6 +- .../neural_networks/__init__.py | 8 +- .../neural_networks/estimator_qnn.py | 33 +- .../neural_networks/sampler_qnn.py | 93 ++-- .../optimizers/__init__.py | 17 +- .../optimizers/adam_amsgrad.py | 9 + .../optimizers/optimizer_utils/__init__.py | 13 +- qiskit_machine_learning/optimizers/spsa.py | 32 +- .../state_fidelities/__init__.py | 10 +- .../state_fidelities/compute_uncompute.py | 5 +- ...dam_amsgrad_callback-e8e1374d72688da4.yaml | 20 + ...pport_for_algorithms-1e257b1c7e8c404f.yaml | 11 + ...lass_support_for_vqc-60baa98528a17a45.yaml | 6 + ...tion-for-classifiers-a752c5154a7c988f.yaml | 5 + requirements.txt | 5 +- .../test_neural_network_classifier.py | 84 +++- .../classifiers/test_pegasos_qsvc.py | 37 +- test/algorithms/classifiers/test_vqc.py | 81 +++- test/algorithms/inference/test_qbayesian.py | 45 ++ test/algorithms/regressors/test_vqr.py | 69 +++ test/optimizers/test_adam_amsgrad.py | 18 + 58 files changed, 1363 insertions(+), 369 deletions(-) create mode 100644 docs/apidocs/qiskit_machine_learning.gradients.rst create mode 100644 docs/apidocs/qiskit_machine_learning.optimizers.rst create mode 100644 docs/apidocs/qiskit_machine_learning.state_fidelities.rst create mode 100644 docs/migration/02_migration_guide_0.8.rst create mode 100644 releasenotes/notes/add-adam_amsgrad_callback-e8e1374d72688da4.yaml create mode 100644 releasenotes/notes/feature-V2_support_for_algorithms-1e257b1c7e8c404f.yaml create mode 100644 releasenotes/notes/feature-partial_multiclass_support_for_vqc-60baa98528a17a45.yaml create mode 100644 releasenotes/notes/feature-predict-proba-function-for-classifiers-a752c5154a7c988f.yaml diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 1e3eeb01f..1eb06c32d 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -225,36 +225,36 @@ jobs: with: name: tutorials${{ matrix.python-version }} path: docs/_build/html/artifacts/tutorials.tar.gz -# - name: Run stable tutorials -# env: -# QISKIT_PARALLEL: False -# QISKIT_DOCS_BUILD_TUTORIALS: 'always' -# run: | -# # clean last sphinx output -# make clean_sphinx -# # get current version -# version=$(pip show qiskit-machine-learning | awk -F. '/^Version:/ { print substr($1,10), $2-1 }' OFS=.) -# # download stable version -# wget https://codeload.github.com/qiskit-community/qiskit-machine-learning/zip/stable/$version -O /tmp/repo.zip -# unzip /tmp/repo.zip -d /tmp/ -# # copy stable tutorials to main tutorials -# cp -R /tmp/qiskit-machine-learning-stable-$version/docs/tutorials/* docs/tutorials -# # run tutorials and zip results -# echo "earliest_version: 0.1.0" >> releasenotes/config.yaml -# # ignore unreleased/untagged notes -# tools/ignore_untagged_notes.sh -# make html -# cd docs/_build/html -# mkdir artifacts -# tar -zcvf artifacts/tutorials.tar.gz --exclude=./artifacts . -# if: ${{ matrix.python-version == 3.9 && !startsWith(github.ref, 'refs/heads/stable') && !startsWith(github.base_ref, 'stable/') }} -# shell: bash -# - name: Run upload stable tutorials -# uses: actions/upload-artifact@v4 -# with: -# name: tutorials-stable${{ matrix.python-version }} -# path: docs/_build/html/artifacts/tutorials.tar.gz -# if: ${{ matrix.python-version == 3.9 && !startsWith(github.ref, 'refs/heads/stable') && !startsWith(github.base_ref, 'stable/') }} + - name: Run stable tutorials + env: + QISKIT_PARALLEL: False + QISKIT_DOCS_BUILD_TUTORIALS: 'always' + run: | + # clean last sphinx output + make clean_sphinx + # get current version + version=$(pip show qiskit-machine-learning | awk -F. '/^Version:/ { print substr($1,10), $2-1 }' OFS=.) + # download stable version + wget https://codeload.github.com/qiskit-community/qiskit-machine-learning/zip/stable/$version -O /tmp/repo.zip + unzip /tmp/repo.zip -d /tmp/ + # copy stable tutorials to main tutorials + cp -R /tmp/qiskit-machine-learning-stable-$version/docs/tutorials/* docs/tutorials + # run tutorials and zip results + echo "earliest_version: 0.1.0" >> releasenotes/config.yaml + # ignore unreleased/untagged notes + tools/ignore_untagged_notes.sh + make html + cd docs/_build/html + mkdir artifacts + tar -zcvf artifacts/tutorials.tar.gz --exclude=./artifacts . + if: ${{ matrix.python-version == 3.9 && !startsWith(github.ref, 'refs/heads/stable') && !startsWith(github.base_ref, 'stable/') }} + shell: bash + - name: Run upload stable tutorials + uses: actions/upload-artifact@v4 + with: + name: tutorials-stable${{ matrix.python-version }} + path: docs/_build/html/artifacts/tutorials.tar.gz + if: ${{ matrix.python-version == 3.9 && !startsWith(github.ref, 'refs/heads/stable') && !startsWith(github.base_ref, 'stable/') }} Deprecation_Messages_and_Coverage: needs: [Checks, MachineLearning, Tutorials] runs-on: ubuntu-latest diff --git a/.mergify.yml b/.mergify.yml index ca27e5964..bcaac7727 100644 --- a/.mergify.yml +++ b/.mergify.yml @@ -1,23 +1,23 @@ queue_rules: - name: automerge - conditions: - - check-success=Deprecation_Messages_and_Coverage (3.9) - -pull_request_rules: - - name: automatic merge on CI success and review - conditions: + queue_conditions: - check-success=Deprecation_Messages_and_Coverage (3.9) - "#approved-reviews-by>=1" - label=automerge - label!=on hold - actions: - queue: - name: automerge - method: squash + merge_conditions: + - check-success=Deprecation_Messages_and_Coverage (3.9) + merge_method: squash + +pull_request_rules: - name: backport conditions: - label=stable backport potential actions: backport: branches: - - stable/0.7 + - stable/0.8 + - name: automatic merge on CI success and review + conditions: [] + actions: + queue: diff --git a/.pylintdict b/.pylintdict index c059dfefa..1217d6ce0 100644 --- a/.pylintdict +++ b/.pylintdict @@ -123,6 +123,7 @@ dp dt dω eda +edaspy egger eigen eigenphase @@ -576,6 +577,7 @@ vatan vec vectorized veeravalli +vicente vicentini vigo ville diff --git a/docs/apidocs/qiskit_machine_learning.gradients.rst b/docs/apidocs/qiskit_machine_learning.gradients.rst new file mode 100644 index 000000000..bdba805ed --- /dev/null +++ b/docs/apidocs/qiskit_machine_learning.gradients.rst @@ -0,0 +1,6 @@ +.. _qiskit-machine-learning-gradients: + +.. automodule:: qiskit_machine_learning.gradients + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_machine_learning.optimizers.rst b/docs/apidocs/qiskit_machine_learning.optimizers.rst new file mode 100644 index 000000000..4974126e6 --- /dev/null +++ b/docs/apidocs/qiskit_machine_learning.optimizers.rst @@ -0,0 +1,6 @@ +.. _qiskit-machine-learning-optimizers: + +.. automodule:: qiskit_machine_learning.optimizers + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/apidocs/qiskit_machine_learning.state_fidelities.rst b/docs/apidocs/qiskit_machine_learning.state_fidelities.rst new file mode 100644 index 000000000..afb674925 --- /dev/null +++ b/docs/apidocs/qiskit_machine_learning.state_fidelities.rst @@ -0,0 +1,6 @@ +.. _qiskit-machine-learning-state_fidelities: + +.. automodule:: qiskit_machine_learning.state_fidelities + :no-members: + :no-inherited-members: + :no-special-members: diff --git a/docs/migration/02_migration_guide_0.8.rst b/docs/migration/02_migration_guide_0.8.rst new file mode 100644 index 000000000..59f7d2a3d --- /dev/null +++ b/docs/migration/02_migration_guide_0.8.rst @@ -0,0 +1,396 @@ +Qiskit Machine Learning v0.8 Migration Guide +============================================ + +This tutorial will guide you through the process of migrating your code +using V2 primitives. + +Introduction +------------ + +The Qiskit Machine Learning 0.8 release focuses on transitioning from V1 to V2 primitives. +This release also incorporates selected algorithms from the now deprecated `qiskit_algorithms` repository. + + +Contents: + +- Overview of the primitives +- Transpilation and Pass Managers +- Algorithms from `qiskit_algorithms` +- 🔪 The Sharp Bits: Common Pitfalls + +Overview of the primitives +-------------------------- + +With the launch of `Qiskit 1.0`, V1 primitives are deprecated and replaced by V2 primitives. Further details +are available in the +`V2 primitives migration guide `__. + +The Qiskit Machine Learning 0.8 update aligns with the Qiskit IBM Runtime’s Primitive Unified Block (PUB) +requirements and the constraints of the instruction set architecture (ISA) for circuits and observables. + +Users can switch between `V1` primitives and `V2` primitives from version `0.8`. + +**Warning**: V1 primitives are deprecated and will be removed in version `0.9`. To ensure full compatibility +with V2 primitives, review the transpilation and pass managers section if your primitives require transpilation, +such as those from `qiskit-ibm-runtime`. + +Usage of V2 primitives is as straightforward as using V1: + +- For kernel based methods: + +.. code:: ipython3 + + from qiskit.primitives import StatevectorSampler as Sampler + from qiskit_machine_learning.state_fidelities import ComputeUncompute + from qiskit_machine_learning.kernels import FidelityQuantumKernel + ... + sampler = Sampler() + fidelity = ComputeUncompute(sampler=sampler) + feature_map = ZZFeatureMap(num_qubits) + qk = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity) + ... + +- For Estimator based neural_network based methods: + +.. code:: ipython3 + + from qiskit.primitives import StatevectorEstimator as Estimator + from qiskit_machine_learning.neural_networks import EstimatorQNN + from qiskit_machine_learning.gradients import ParamShiftEstimatorGradient + ... + estimator = Estimator() + estimator_gradient = ParamShiftEstimatorGradient(estimator=estimator) + + estimator_qnn = EstimatorQNN( + circuit=circuit, + observables=observables, + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + estimator=estimator, + gradient=estimator_gradient, + ) + ... + +- For Sampler based neural_network based methods: + +.. code:: ipython3 + + from qiskit.primitives import StatevectorSampler as Sampler + from qiskit_machine_learning.neural_networks import SamplerQNN + from qiskit_machine_learning.gradients import ParamShiftSamplerGradient + ... + sampler = Sampler() + sampler_gradient = ParamShiftSamplerGradient(sampler=sampler) + + sampler_qnn = SamplerQNN( + circuit=circuit, + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + interpret=parity, + output_shape=output_shape, + sampler=sampler, + gradient=sampler_gradient, + ) + ... + + +Transpilation and Pass Managers +------------------------------- + +If your primitives require transpiled circuits,i.e. `qiskit-ibm-runtime.primitives`, +use `pass_manager` with `qiskit-machine-learning` functions to optimize performance. + +- For kernel based methods: + +.. code:: ipython3 + + from qiskit_ibm_runtime import Session, SamplerV2 + from qiskit.providers.fake_provider import GenericBackendV2 + from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager + + from qiskit_machine_learning.state_fidelities import ComputeUncompute + from qiskit_machine_learning.kernels import FidelityQuantumKernel + + ... + backend = GenericBackendV2(num_qubits=num_qubits) + session = Session(backend=backend) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + + sampler = SamplerV2(mode=session) + fidelity = ComputeUncompute(sampler=sampler, pass_manager=pass_manager) + + feature_map = ZZFeatureMap(num_qubits) + qk = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity) + ... + +- For Estimator based neural_network based methods: + +.. code:: ipython3 + + from qiskit_ibm_runtime import Session, EstimatorV2 + from qiskit.providers.fake_provider import GenericBackendV2 + from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager + + from qiskit_machine_learning.neural_networks import EstimatorQNN + from qiskit_machine_learning.gradients import ParamShiftEstimatorGradient + + ... + backend = GenericBackendV2(num_qubits=num_qubits) + session = Session(backend=backend) + + estimator = Estimator(mode=session) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + estimator_qnn = EstimatorQNN( + circuit=qc, + observables=[observables], + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + estimator=estimator, + pass_manager=pass_manager, + ) + +or with more details: + +.. code:: ipython3 + + backend = GenericBackendV2(num_qubits=num_qubits) + session = Session(backend=backend) + + estimator = Estimator(mode=session) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + estimator_gradient = ParamShiftEstimatorGradient( + estimator=estimator, pass_manager=pass_manager + ) + + isa_qc = pass_manager.run(qc) + observables = SparsePauliOp.from_list(...) + isa_observables = observables.apply_layout(isa_qc.layout) + estimator_qnn = EstimatorQNN( + circuit=isa_qc, + observables=[isa_observables], + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + estimator=estimator, + gradient=estimator_gradient, + ) + +- For Sampler based neural_network based methods: + +.. code:: ipython3 + + from qiskit_ibm_runtime import Session, SamplerV2 + from qiskit.providers.fake_provider import GenericBackendV2 + from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager + + from qiskit_machine_learning.neural_networks import SamplerQNN + from qiskit_machine_learning.gradients import ParamShiftSamplerGradient + + ... + backend = GenericBackendV2(num_qubits=num_qubits) + session = Session(backend=backend) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + sampler = SamplerV2(mode=session) + + sampler_qnn = SamplerQNN( + circuit=qc, + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + interpret=parity, + output_shape=output_shape, + sampler=sampler, + pass_manager=pass_manager, + ) + +or with more details: + +.. code:: ipython3 + + backend = GenericBackendV2(num_qubits=num_qubits) + session = Session(backend=backend) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + + sampler = SamplerV2(mode=session) + sampler_gradient = ParamShiftSamplerGradient(sampler=sampler, pass_manager=self.pass_manager) + isa_qc = pass_manager.run(qc) + sampler_qnn = SamplerQNN( + circuit=isa_qc, + input_params=feature_map.parameters, + weight_params=ansatz.parameters, + interpret=parity, + output_shape=output_shape, + sampler=sampler, + gradient=sampler_gradient, + ) + ... + + +Algorithms from `qiskit_algorithms` +----------------------------------- + +Essential features of Qiskit Algorithms have been integrated into Qiskit Machine Learning. +Therefore, Qiskit Machine Learning will no longer depend on Qiskit Algorithms. +This migration requires Qiskit 1.0 or higher and may necessitate updating Qiskit Aer. +Be cautious during updates to avoid breaking changes in critical production stages. + +Users must update their imports and code references in code that uses Qiskit Machine Leaning and Algorithms: + +- Change `qiskit_algorithms.gradients` to `qiskit_machine_learning.gradients` +- Change `qiskit_algorithms.optimizers` to `qiskit_machine_learning.optimizers` +- Change `qiskit_algorithms.state_fidelities` to `qiskit_machine_learning.state_fidelities` +- Update utilities as needed due to partial merge. + +To continue using sub-modules and functionalities of Qiskit Algorithms that **have not been transferred**, +you may continue using them as before by importing from Qiskit Algorithms. However, be aware that Qiskit Algorithms +is no longer officially supported and some of its functionalities may not work in your use case. For any problems +directly related to Qiskit Algorithms, please open a GitHub issue at +`qiskit-algorithms `__. +Should you want to include a Qiskit Algorithms functionality that has not been incorporated in Qiskit Machine +Learning, please open a feature-request issue at +`qiskit-machine-learning `__, + +explaining why this change would be useful for you and other users. + +Four examples of upgrading the code can be found below. + +Gradients: + +.. code:: ipython3 + + # Before: + from qiskit_algorithms.gradients import SPSA, ParameterShift + # After: + from qiskit_machine_learning.gradients import SPSA, ParameterShift + # Usage + spsa = SPSA() + param_shift = ParameterShift() + +Optimizers: + +.. code:: ipython3 + + # Before: + from qiskit_algorithms.optimizers import COBYLA, ADAM + # After: + from qiskit_machine_learning.optimizers import COBYLA, ADAM + # Usage + cobyla = COBYLA() + adam = ADAM() + +Quantum state fidelities: + +.. code:: ipython3 + + # Before: + from qiskit_algorithms.state_fidelities import ComputeFidelity + # After: + from qiskit_machine_learning.state_fidelities import ComputeFidelity + # Usage + fidelity = ComputeFidelity() + + +Algorithm globals (used to fix the random seed): + +.. code:: ipython3 + + # Before: + from qiskit_algorithms.utils import algorithm_globals + # After: + from qiskit_machine_learning.utils import algorithm_globals + algorithm_globals.random_seed = 1234 + + +🔪 The Sharp Bits: Common Pitfalls +----------------------------------- + +- 🔪 Transpiling without measurements: + +.. code:: ipython3 + + # Before: + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + pass_manager.run(qc) + +This approach causes issues for the transpiler, as it will measure all physical qubits instead +of virtual qubits when the number of physical qubits exceeds the number of virtual qubits. +Always add measurements before transpilation: + + +.. code:: ipython3 + + # After: + qc = QuantumCircuit(1) + qc.h(0) + qc.ry(params[0], 0) + qc.rx(params[1], 0) + qc.measure_all() + pass_manager.run(qc) + +- 🔪 Dynamic Attribute Naming in Qiskit v1.x: + +In the latest version of Qiskit (v1.x), the dynamic naming of attributes based on the +classical register's name introduces potential bugs. +Please use `meas` or `c` for your register names to avoid any issues for SamplerV2. + +.. code:: ipython3 + + # for measue_all(): + dist = result[0].data.meas.get_counts() + +.. code:: ipython3 + + # for cbit: + dist = result[0].data.c.get_counts() + +- 🔪 Adapting observables for transpiled circuits: + +.. code:: ipython3 + + # Wrong: + ... + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + isa_qc = pass_manager.run(qc) + observables = SparsePauliOp.from_list(...) + estimator_qnn = EstimatorQNN( + circuit=isa_qc, + observables=[observables], + ... + + + # Correct: + ... + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + isa_qc = pass_manager.run(qc) + observables = SparsePauliOp.from_list(...) + isa_observables = observables.apply_layout(isa_qc.layout) + estimator_qnn = EstimatorQNN( + circuit=isa_qc, + observables=[isa_observables], + ... + + +- 🔪 Passing gradients without a pass manager: + +Some gradient algorithms may require creation of new circuits, and primitives from +`qiskit-ibm-runtime` require transpilation. Please ensure a pass manager is also provided to gradients. + +.. code:: ipython3 + + # Wrong: + ... + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + gradient = ParamShiftEstimatorGradient(estimator=estimator) + ... + + # Correct: + ... + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + gradient = ParamShiftEstimatorGradient( + estimator=estimator, pass_manager=pass_manager + ) + ... + +- 🔪 Don't forget to migrate if you are using functions from `qiskit_algorithms` instead of `qiskit-machine-learning` for V2 primitives. +- 🔪 Some gradients such as SPSA and LCU from `qiskit_machine_learning.gradients` can be very prone to noise, be cautious of gradient values. diff --git a/docs/tutorials/01_neural_networks.ipynb b/docs/tutorials/01_neural_networks.ipynb index 255aa8c3c..da90b3d68 100644 --- a/docs/tutorials/01_neural_networks.ipynb +++ b/docs/tutorials/01_neural_networks.ipynb @@ -171,15 +171,16 @@ "Together with the quantum circuit defined above, and the observable we have created, the `EstimatorQNN` constructor takes in the following keyword arguments:\n", "\n", "- `estimator`: optional primitive instance\n", + "- `pass_manager`: optional pass_manager instance for primitives that require transpilation\n", "- `input_params`: list of quantum circuit parameters that should be treated as \"network inputs\"\n", "- `weight_params`: list of quantum circuit parameters that should be treated as \"network weights\"\n", "\n", - "In this example, we previously decided that the first parameter of `params1` should be the input, while the second should be the weight. As we are performing a local statevector simulation, we will not set the `estimator` parameter; the network will create an instance of the reference `Estimator` primitive for us. If we needed to access cloud resources or `Aer` simulators, we would have to define the respective `Estimator` instances and pass them to the `EstimatorQNN`." + "In this example, we previously decided that the first parameter of `params1` should be the input, while the second should be the weight. As we are performing a local statevector simulation, we will set the `estimator` parameter from `qiskit.primitives.StatevectorEstimator`. If we needed to access cloud resources or `Aer` simulators, we would have to define the respective `Estimator` instances and pass them to the `EstimatorQNN`. If transpilation is required an estimator such as `qiskit_ibm_runtime.EstimatorV2`, it is required to pass a `pass_manager` to the `EstimatorQNN`. In such case, please do not forget that `observables` might require new layout according to the target." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "italian-clear", "metadata": {}, "outputs": [ @@ -196,9 +197,15 @@ ], "source": [ "from qiskit_machine_learning.neural_networks import EstimatorQNN\n", + "from qiskit.primitives import StatevectorEstimator as Estimator\n", "\n", + "estimator = Estimator()\n", "estimator_qnn = EstimatorQNN(\n", - " circuit=qc1, observables=observable1, input_params=[params1[0]], weight_params=[params1[1]]\n", + " circuit=qc1,\n", + " observables=observable1,\n", + " input_params=[params1[0]],\n", + " weight_params=[params1[1]],\n", + " estimator=estimator,\n", ")\n", "estimator_qnn" ] @@ -288,16 +295,19 @@ "metadata": {}, "source": [ "Similarly to the `EstimatorQNN`, we must specify inputs and weights when instantiating the `SamplerQNN`. In this case, the keyword arguments will be:\n", + "\n", "- `sampler`: optional primitive instance\n", + "- `pass_manager`: optional pass_manager instance for primitives that require transpilation.\n", "- `input_params`: list of quantum circuit parameters that should be treated as \"network inputs\"\n", "- `weight_params`: list of quantum circuit parameters that should be treated as \"network weights\"\n", "\n", - "Please note that, once again, we are choosing not to set the `Sampler` instance to the QNN and relying on the default." + "\n", + "Please note that, once again, we are setting the `StatevectorSampler` instance from `qiskit.primitives` to the QNN and relying on `statevector`." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "5c007d10", "metadata": {}, "outputs": [ @@ -314,8 +324,10 @@ ], "source": [ "from qiskit_machine_learning.neural_networks import SamplerQNN\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "\n", - "sampler_qnn = SamplerQNN(circuit=qc2, input_params=inputs2, weight_params=weights2)\n", + "sampler = Sampler()\n", + "sampler_qnn = SamplerQNN(circuit=qc2, input_params=inputs2, weight_params=weights2, sampler=sampler)\n", "sampler_qnn" ] }, @@ -890,7 +902,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "34e1e2f0", "metadata": {}, "outputs": [], @@ -902,6 +914,7 @@ " observables=[observable1, observable2],\n", " input_params=[params1[0]],\n", " weight_params=[params1[1]],\n", + " estimator=estimator,\n", ")" ] }, @@ -952,7 +965,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "eed68d1a", "metadata": {}, "outputs": [], @@ -966,6 +979,7 @@ " weight_params=weights2,\n", " interpret=parity,\n", " output_shape=output_shape,\n", + " sampler=sampler,\n", ")" ] }, diff --git a/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb b/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb index c15a6b5c6..511988f83 100644 --- a/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb +++ b/docs/tutorials/02_neural_network_classifier_and_regressor.ipynb @@ -136,17 +136,20 @@ "id": "formed-animal", "metadata": {}, "source": [ - "Create a quantum neural network" + "Create a quantum neural network. As we are performing a local statevector simulation, we will set the `estimator` parameter from `qiskit.primitives.StatevectorEstimator`." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "determined-hands", "metadata": {}, "outputs": [], "source": [ - "estimator_qnn = EstimatorQNN(circuit=qc)" + "from qiskit.primitives import StatevectorEstimator as Estimator\n", + "\n", + "estimator = Estimator()\n", + "estimator_qnn = EstimatorQNN(circuit=qc, estimator=estimator)" ] }, { @@ -324,7 +327,7 @@ "### Classification with a `SamplerQNN`\n", "\n", "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. Again we can use the `QNNCircuit` class to set up a parameterized quantum circuit from a feature map and ansatz of our choice." + "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. Again we can use the `QNNCircuit` class to set up a parameterized quantum circuit from a feature map and ansatz of our choice. Please note that, once again, we are setting the `StatevectorSampler` instance from `qiskit.primitives` to the QNN and relying on `statevector`." ] }, { @@ -368,16 +371,20 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "statutory-mercury", "metadata": {}, "outputs": [], "source": [ + "from qiskit.primitives import StatevectorSampler as Sampler\n", + "\n", + "sampler = Sampler()\n", "# construct QNN\n", "sampler_qnn = SamplerQNN(\n", " circuit=qc,\n", " interpret=parity,\n", " output_shape=output_shape,\n", + " sampler=sampler,\n", ")" ] }, @@ -511,7 +518,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "legislative-dublin", "metadata": {}, "outputs": [], @@ -527,6 +534,7 @@ " loss=\"cross_entropy\",\n", " optimizer=COBYLA(maxiter=30),\n", " callback=callback_graph,\n", + " sampler=sampler,\n", ")" ] }, @@ -718,7 +726,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "latin-result", "metadata": {}, "outputs": [], @@ -727,6 +735,7 @@ " num_qubits=2,\n", " optimizer=COBYLA(maxiter=30),\n", " callback=callback_graph,\n", + " sampler=sampler,\n", ")" ] }, @@ -863,7 +872,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "perfect-kelly", "metadata": {}, "outputs": [], @@ -882,7 +891,7 @@ "qc = QNNCircuit(feature_map=feature_map, ansatz=ansatz)\n", "\n", "# construct QNN\n", - "regression_estimator_qnn = EstimatorQNN(circuit=qc)" + "regression_estimator_qnn = EstimatorQNN(circuit=qc, estimator=estimator)" ] }, { @@ -1014,7 +1023,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "id": "offensive-entry", "metadata": {}, "outputs": [], @@ -1024,6 +1033,7 @@ " ansatz=ansatz,\n", " optimizer=L_BFGS_B(maxiter=5),\n", " callback=callback_graph,\n", + " estimator=estimator,\n", ")" ] }, 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 63bf39dbb..94dc0367f 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 @@ -421,17 +421,17 @@ "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 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." + "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 from `StatevectorSampler` instance from `qiskit.primitives`. 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": null, "id": "unauthorized-footwear", "metadata": {}, "outputs": [], "source": [ - "from qiskit.primitives import Sampler\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "\n", "sampler = Sampler()" ] @@ -482,7 +482,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "multiple-garbage", "metadata": {}, "outputs": [ diff --git a/docs/tutorials/03_quantum_kernel.ipynb b/docs/tutorials/03_quantum_kernel.ipynb index 1f5629ce4..a3c144644 100644 --- a/docs/tutorials/03_quantum_kernel.ipynb +++ b/docs/tutorials/03_quantum_kernel.ipynb @@ -208,7 +208,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -240,12 +240,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from qiskit.circuit.library import ZZFeatureMap\n", - "from qiskit.primitives import Sampler\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "from qiskit_machine_learning.state_fidelities import ComputeUncompute\n", "from qiskit_machine_learning.kernels import FidelityQuantumKernel\n", "\n", @@ -323,7 +323,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -504,7 +504,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -542,18 +542,18 @@ "metadata": {}, "source": [ "### 3.2. Defining the Quantum Kernel\n", - "We use an identical setup as in the classification example. We create another instance of the `FidelityQuantumKernel` class with a `ZZFeatureMap`, but you might notice that in this case we do not provide a `fidelity` instance. This is because the `ComputeUncompute` method provided in the previous case is instantiated by default when the fidelity instance is not provided explicitly. " + "We use an identical setup as in the classification example. We create another instance of the `FidelityQuantumKernel` class with a `ZZFeatureMap`." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement=\"linear\")\n", "\n", - "adhoc_kernel = FidelityQuantumKernel(feature_map=adhoc_feature_map)" + "adhoc_kernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=adhoc_feature_map)" ] }, { @@ -577,7 +577,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -678,7 +678,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -802,7 +802,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/tutorials/04_torch_qgan.ipynb b/docs/tutorials/04_torch_qgan.ipynb index eb93decb9..de5e1620a 100644 --- a/docs/tutorials/04_torch_qgan.ipynb +++ b/docs/tutorials/04_torch_qgan.ipynb @@ -288,19 +288,18 @@ "source": [ "### 3.2. Definition of the quantum generator\n", "\n", - "We start defining the generator by creating a sampler for the ansatz. The reference implementation is a statevector-based implementation, thus it returns exact probabilities as a result of circuit execution. We add the `shots` parameter to add some noise to the results. In this case the implementation samples probabilities from the multinomial distribution constructed from the measured quasi probabilities. And as usual we fix the seed for reproducibility purposes." + "We start defining the generator by creating a sampler for the ansatz. The reference implementation is a statevector-based implementation, thus it returns exact probabilities as a result of circuit execution. In this case the implementation samples probabilities from the multinomial distribution constructed from the measured quasi probabilities. " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "from qiskit.primitives import Sampler\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "\n", - "shots = 10000\n", - "sampler = Sampler(options={\"shots\": shots, \"seed\": algorithm_globals.random_seed})" + "sampler = Sampler()" ] }, { diff --git a/docs/tutorials/05_torch_connector.ipynb b/docs/tutorials/05_torch_connector.ipynb index ff419093a..ec964d617 100644 --- a/docs/tutorials/05_torch_connector.ipynb +++ b/docs/tutorials/05_torch_connector.ipynb @@ -157,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "humanitarian-flavor", "metadata": {}, "outputs": [ @@ -171,9 +171,15 @@ } ], "source": [ + "from qiskit.primitives import StatevectorEstimator as Estimator\n", + "\n", + "estimator = Estimator()\n", "# Setup QNN\n", "qnn1 = EstimatorQNN(\n", - " circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters\n", + " circuit=qc,\n", + " input_params=feature_map.parameters,\n", + " weight_params=ansatz.parameters,\n", + " estimator=estimator,\n", ")\n", "\n", "# Set up PyTorch module\n", @@ -363,7 +369,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "present-operator", "metadata": {}, "outputs": [ @@ -386,6 +392,10 @@ "qc.compose(feature_map, inplace=True)\n", "qc.compose(ansatz, inplace=True)\n", "\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", + "\n", + "sampler = Sampler()\n", + "\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", @@ -395,6 +405,7 @@ " weight_params=ansatz.parameters,\n", " interpret=parity,\n", " output_shape=output_shape,\n", + " sampler=sampler,\n", ")\n", "\n", "# Set up PyTorch module\n", @@ -584,7 +595,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "brazilian-adapter", "metadata": {}, "outputs": [], @@ -604,7 +615,9 @@ "qc.compose(ansatz, inplace=True)\n", "\n", "# Construct QNN\n", - "qnn3 = EstimatorQNN(circuit=qc, input_params=[param_x], weight_params=[param_y])\n", + "qnn3 = EstimatorQNN(\n", + " circuit=qc, input_params=[param_x], weight_params=[param_y], estimator=estimator\n", + ")\n", "\n", "# Set up PyTorch module\n", "# Reminder: If we don't explicitly declare the initial weights\n", @@ -960,7 +973,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "urban-purse", "metadata": {}, "outputs": [], @@ -979,6 +992,7 @@ " input_params=feature_map.parameters,\n", " weight_params=ansatz.parameters,\n", " input_gradients=True,\n", + " estimator=estimator,\n", " )\n", " return qnn\n", "\n", diff --git a/docs/tutorials/07_pegasos_qsvc.ipynb b/docs/tutorials/07_pegasos_qsvc.ipynb index 27d91665b..931eaf813 100644 --- a/docs/tutorials/07_pegasos_qsvc.ipynb +++ b/docs/tutorials/07_pegasos_qsvc.ipynb @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "automated-allergy", "metadata": {}, "outputs": [], @@ -114,11 +114,17 @@ "\n", "from qiskit_machine_learning.kernels import FidelityQuantumKernel\n", "\n", + "from qiskit_machine_learning.state_fidelities import ComputeUncompute\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", + "\n", + "sampler = Sampler()\n", + "fidelity = ComputeUncompute(sampler=sampler)\n", + "\n", "algorithm_globals.random_seed = 12345\n", "\n", "feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)\n", "\n", - "qkernel = FidelityQuantumKernel(feature_map=feature_map)" + "qkernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=feature_map)" ] }, { @@ -222,7 +228,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/tutorials/08_quantum_kernel_trainer.ipynb b/docs/tutorials/08_quantum_kernel_trainer.ipynb index 2a7a01435..5ee4d777f 100644 --- a/docs/tutorials/08_quantum_kernel_trainer.ipynb +++ b/docs/tutorials/08_quantum_kernel_trainer.ipynb @@ -99,7 +99,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -232,13 +232,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "a190efef", "metadata": {}, "outputs": [], "source": [ + "from qiskit_machine_learning.state_fidelities import ComputeUncompute\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", + "\n", + "sampler = Sampler()\n", + "fidelity = ComputeUncompute(sampler=sampler)\n", + "\n", "# Instantiate quantum kernel\n", - "quant_kernel = TrainableFidelityQuantumKernel(feature_map=fm, training_parameters=training_params)\n", + "quant_kernel = TrainableFidelityQuantumKernel(\n", + " fidelity=fidelity, feature_map=fm, training_parameters=training_params\n", + ")\n", "\n", "# Set up the optimizer\n", "cb_qkt = QKTCallback()\n", @@ -356,7 +364,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/tutorials/09_saving_and_loading_models.ipynb b/docs/tutorials/09_saving_and_loading_models.ipynb index 0386d6c13..01e4773d8 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": 1, + "execution_count": null, "id": "exposed-cholesterol", "metadata": {}, "outputs": [], @@ -36,7 +36,7 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from qiskit.circuit.library import RealAmplitudes\n", - "from qiskit.primitives import Sampler\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "from qiskit_machine_learning.optimizers import COBYLA\n", "from qiskit_machine_learning.utils import algorithm_globals\n", "from sklearn.model_selection import train_test_split\n", @@ -266,7 +266,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -469,7 +469,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -598,7 +598,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -686,7 +686,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/tutorials/10_effective_dimension.ipynb b/docs/tutorials/10_effective_dimension.ipynb index f3357aa12..03437276d 100644 --- a/docs/tutorials/10_effective_dimension.ipynb +++ b/docs/tutorials/10_effective_dimension.ipynb @@ -59,7 +59,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "slideshow": { "slide_type": "skip" @@ -75,6 +75,8 @@ "from qiskit.circuit.library import ZFeatureMap, RealAmplitudes\n", "from qiskit_machine_learning.optimizers import COBYLA\n", "from qiskit_machine_learning.utils import algorithm_globals\n", + "from qiskit.primitives import StatevectorSampler as Sampler, StatevectorEstimator as Estimator\n", + "\n", "from sklearn.datasets import make_classification\n", "from sklearn.preprocessing import MinMaxScaler\n", "\n", @@ -84,7 +86,9 @@ "from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN\n", "\n", "# set random seed\n", - "algorithm_globals.random_seed = 42" + "algorithm_globals.random_seed = 42\n", + "sampler = Sampler()\n", + "estimator = Estimator()" ] }, { @@ -157,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "pycharm": { "name": "#%%\n" @@ -171,6 +175,7 @@ " interpret=parity,\n", " output_shape=output_shape,\n", " sparse=False,\n", + " sampler=sampler,\n", ")" ] }, @@ -444,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "pycharm": { "name": "#%%\n" @@ -452,7 +457,7 @@ }, "outputs": [], "source": [ - "estimator_qnn = EstimatorQNN(circuit=qc)" + "estimator_qnn = EstimatorQNN(circuit=qc, estimator=estimator)" ] }, { diff --git a/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb b/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb index c57cf3b9f..33bd2090e 100644 --- a/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb +++ b/docs/tutorials/11_quantum_convolutional_neural_networks.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "3ceca583", "metadata": { "scrolled": true @@ -51,13 +51,15 @@ "from qiskit.circuit import ParameterVector\n", "from qiskit.circuit.library import ZFeatureMap\n", "from qiskit.quantum_info import SparsePauliOp\n", + "from qiskit.primitives import StatevectorEstimator as Estimator\n", "from qiskit_machine_learning.optimizers import COBYLA\n", "from qiskit_machine_learning.utils import algorithm_globals\n", "from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier\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" + "algorithm_globals.random_seed = 12345\n", + "estimator = Estimator()" ] }, { @@ -244,7 +246,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -297,7 +299,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -373,7 +375,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -421,7 +423,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -577,7 +579,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAE7CAYAAAAy1eC8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAHpklEQVR4nO3cv4oddQCG4TluNoku0SRkixBCRCvRzkLtBBEkliJeQLpYaW3nBYiVegf2YiFop4LBJioEExQDiaCJQXRD/upY2cQtsuCemcP7POUw8PtY2Nn3zIFdjOM4AABUPDD1AACAZRI/AECK+AEAUsQPAJAifgCAlD07uXltY2NcP3h4t7asjKeOXJl6wmxcOH9o6gmzMK75HDEMw3Dz1u/D7TvXF8s4a+9i37h/2FjGUbM2Hnho6gnMzF8PLuVXcCXc+PXS1XEcN++9vqP4WT94eDh++o3/b9WKOnPqvaknzMbJF1+besIs/HVg39QTZuGrb95f2ln7h43hmcULSztvru48+/TUE2Zj4T+3DMMwDL896Xn0r2/fffPidtd9XAUAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAyp6d3Lzv2t3h8Q+v7daW1XFq6gHzcfeR/VNPmIXFl2ennjAP442lHXX72Mbw0+vPLe28uTrw49QL5uPrt9+begIzs/bu9te9+QEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQshjH8f5vXiyuDMNwcffmACvuxDiOm8s4yPMIuA/bPpN2FD8AAKvO114AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBlz05uPnJ4bXz0+PpubVkZ313ZnHrCbKxvjVNPmIW/9y6mnjALt7auDXdvXl/KD8PziHtd+P7Q1BNmYVz3XuNff279fHUcx//80d5R/Dx6fH0488nx/2/Vinrig9NTT5iNo1/cmnrCLGwd2zv1hFk499E7SzvL84h7nXz+laknzMLdzQNTT5iNzz5/6+J21+UhAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFL2TD1gFZ34+I+pJ8zG2i+/Tz1hFtY/vTT1hFlYG68v7awL5x4eXn76paWdN1eXX31s6gmzcfTy2aknzMLi/A9TT5g9b34AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApIgfACBF/AAAKeIHAEgRPwBAivgBAFLEDwCQIn4AgBTxAwCkiB8AIEX8AAAp4gcASBE/AECK+AEAUsQPAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkCJ+AIAU8QMApCzGcbz/mxeLK8MwXNy9OcCKOzGO4+YyDvI8Au7Dts+kHcUPAMCq87UXAJAifgCAFPEDAKSIHwAgRfwAACniBwBIET8AQIr4AQBSxA8AkPIPaQqLcsJSISEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -636,7 +638,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAGMCAYAAADTKbeBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAzTklEQVR4nO3df1xU973n8dfMiAwKiDy4CuJqRMVUFFLJGi/aAMYaNG4kv1Qkmhq2pPijJlptUiGrEdAHIX24N7pq3SirVdJKppqo101UmJsEjaVcKxjjXKsGUVJJ4g+GnzLD/uF1khOmOsMK53D8PB+P+YPvnDnncz5O3jnnzPlhaGtra0MIIf6TUe0ChBDaIqEghFCQUBBCKEgoCCEUJBSEEAoSCkIIBQkFIYSChIIQQkFCQQihIKEghFCQUBBCKEgoCCEUJBSEEAoSCkIIBQkFIYSChIIQQkFCQQihIKEghFCQUBBCKEgoCCEUJBSEEAoSCkIIBQkFIYSChIIQQkFCQQihIKEghFCQUBBCKPRQuwCts5TBpavqLDu8Lzz9sOfTnzkCdVc6rx5vBfSDERM9n1563XHe9vpOJBTu4tJV+JuG/vHvpO4KXKtWu4qOk15rg+w+CCEUJBSEEAoSCkIIBQkFIYSCHGgULks3JnD6y6OYTD4YjSbCgiNIfSyTn0Q/o3ZpuqPlXsuWglBInZTFBzl2LCu/IfGhFLJ3zqS61qZ2Wbqk1V5LKAi3TKYePBk3H6fTwfmaCrXL0TWt9VpCQbh1s7WFvaUb6GHyIWJAjNrl6JrWeq3pUHA6neTn5zN8+HDMZjMxMTFYrVZGjBhBenq62uW5VZSdwPE92R6Pa82uwzkkZwUxO3sgR0/t5fW57xEeMkztstySXncOTR9oTEtLw2KxkJWVRWxsLKWlpaSkpFBbW8uSJUvULk+XZj+2gtRJmWqXcV/Qaq81GwqFhYUUFBRQUlJCfHw8AImJiZSXl2OxWBgzZozKFQqhT5rdfcjNzSUpKckVCLcNGzYMHx8foqOjAbhw4QLx8fFERkYyevRoPv74YzXKFUI3NBkK1dXVVFZW8txzz7V7r6qqiqioKHx9fQF46aWXmDlzJjabjc2bNzNr1ixaWlruugyDweDRy2ot8br+43tz2JgepHhdtn3i9Xys1hKP6+xorZ2pK+qXXt/iSf2e0uTuQ3X1rcvPQkNDFeONjY1YrVamTJkCwNdff80nn3zC+++/D0BcXBwDBgyguLiYxx9/vGuL/p6x01cwNlm5r1iUnaBOMV54K6NE7RK8Jr2+9zS5pRASEgKAzaY8kSMvL4+amhpiY2OBW1sN/fv3d201AAwZMoQvv/zyrstoa2vz6BUfn3DvVsxL8fEJHtepdq3udKf6u1Ot7nhSv6c0uaUQERFBdHQ0ubm5BAcHEx4eTlFREQcOHABwhYIQ4t7T5JaC0Whk9+7dREVFkZGRwbx58wgJCWHBggWYTCbXQcZBgwbx97//nebmZtdnz58/z+DBg9UqXYhuT5NbCgCRkZEUFxcrxubMmcPIkSPx8/MDbu1mjB8/nnfeeYf58+dTWlrKpUuXSExMVKNkAJ7NLPFqXHSc9LpzaDYU3CkrK2PcuHGKsU2bNvGzn/2MdevW0bNnTwoLC+nZs6dKFQrR/Wly98Edu92OzWZrd9JSREQE//Zv/4bNZqOysrLdeQ33q9NVn7F4fRwvb5jAxvdfUbz39fXLLNs0kcXr4yi3HaKtrY36xuts/3AlDqeDhqY6t/OcntWHdw68BsD5ryp5ecMEFq8fz7nLJwHYdjCT5KwgHI7Wzl05jdFbr7tNKPj7++NwOFi0aJHapXQL/YMG8+ZLR1i34BOu2a8orr77Q/FaXnh8NWt//iE7D2fT6rjJvmObOXWhlJ2HVmNvuuZ2nkNCR5M2dQ0A/+dgFr9JLSRrzh8p+L9ZAMxLymbogIc6e9U0R2+97jahILwTHBhKTx8zACbjrRt53Hb+qwqiHojDz9efXr4BtLQ2tTu5JWdnCmcvneB8TQVv7Gh/Elld41X6Bf0XQvqE/8Mv9v1Cb73uVscUhPfOXT7J9fpaBvcf6RpzOh2uL2Zvcx/sjVd54pF0mlrqSZ2URXNLA/OfXEfurtkYDSaWzSxoN9+2Nuf3/+js1egW9NJrCQUdu9HwLev3LCTz+T8qxg2G7zYQ65tv4O/Xl97mQOZOXglAL3MAvcwBhAVHYDQYCekzoP3Mv/d/u+/P736lp17Lv6ZOORytrC18nvRp+QQHKk8XjwiL5vMLR2lsqaeh6Qa9zYHtPn/u8kkam+u4Zr/CxStn2r0f6BdM7bVqvr5+mV5uPn8/0VuvZUtBp6wnd2O7+Ge27F8OQNqUNRw5sYuFyW8zI2E5ee/OpflmI3Mnr2r3WYfTweZ9S/n1rB20OlpYZ/kFOS/uV0wzd/Iqsn8/E4BFT23o/BXSML312tDmzUnR96G3P1LvUWZD+8Gin3o+fdm7nfsosxfzHmT8qKdcR8V/aNvBTD4+WcSWX53CZDQRNBAenuX5/KXX3+nsXt+JhMJdyBe14yQUus69DAXZfbiL8L7dZ9kB/Tqnjo7yth7pdcfdy3pkS0EIoSC/PgghFCQUhBAKEgpCCAUJBSGEgoSCEEJBQkEIoSChIIRQkFAQQihIKAghFCQUhBAKEgpCCAUJBSGEgoSCEEJBLp2+C0sZXLqqzrLD+8LTD3s+/ZkjUKfS/QjcCegHIyZ6Pr30uuO87fWdSCjcxaWr6t34w1t1V7R14w9vSa+1QXYfhBAKEgpCCAUJBSGEgoSCEEJBDjQKl6UbEzj95VFMplvPQwwLjiD1sUx+Ev2M2qXpjpZ7LVsKQiF1UhYf5NixrPyGxIdSyN45k+pam9pl6ZJWey2hINwymXrwZNx8nE6H4tHq4t7TWq8lFIRbN1tb2Fu6gR4mHyIGxKhdjq5prdeaDgWn00l+fj7Dhw/HbDYTExOD1WplxIgRpKenq12eLu06nENyVhCzswdy9NReXp/7HuEhw9QuS5e02mtNH2hMS0vDYrGQlZVFbGwspaWlpKSkUFtby5IlS9Quz62i7AQGjZrE2ORMj8a1ZvZjK0idpO0ab5Nedw7NhkJhYSEFBQWUlJQQHx8PQGJiIuXl5VgsFsaMGaNyhULok2Z3H3Jzc0lKSnIFwm3Dhg3Dx8eH6OhoAF5//XUiIyMxGo0UFRWpUaoQuqLJUKiurqayspLnnnuu3XtVVVVERUXh6+sLQFJSEgcPHuTRRx/t6jKF0CVN7j5UV9+6/Cw0NFQx3tjYiNVqZcqUKa6xuLi4Di3DYDB4NN0zK4oZ+KMEr+Z9fG8OfzmQrxi72WRn0KhJXs3Hai3hl5MTPZ4+/xfFxAxN8GoZ3/dWRkmHP+uO1VrCf03xvH7pdcd50mtPnyWtyVAICQkBwGazMXXqVNd4Xl4eNTU1xMbGqlWaR8ZOX+H24Je496TX954mdx8iIiKIjo4mNzeX7du3c/jwYTIyMti6dSvAPQmFtrY2j17x8Qn/38vqqPj4BI/rVLtWd7pT/d2pVnc8qd9TmgwFo9HI7t27iYqKIiMjg3nz5hESEsKCBQswmUyug4xCiHtPk7sPAJGRkRQXFyvG5syZw8iRI/Hz81OpKiH0T7Oh4E5ZWRnjxo1TjGVlZbFt2zZqa2upqKjg5Zdfxmq1MnToUFVqfDazxKtx0XHS686hyd0Hd+x2Ozabrd1JS6tXr6a6uprm5ma++eYbqqurVQsELTld9RmL18fx8oYJbHz/FcV7X1+/zLJNE1m8Po5y2yHa2tqob7zO9g9X4nA6aGiqczvP6Vl9eOfAawDsPJzDzNUD2Hbwu4N82w5mkpwVhMPR2nkrpkF663W3CQV/f38cDgeLFi1Su5RuoX/QYN586QjrFnzCNfsVxdV3fyheywuPr2btzz9k5+FsWh032XdsM6culLLz0GrsTdfcznNI6GjSpq4BYOrY/85rKTsV789LymbogIc6a5U0S2+97jahILwTHBhKTx8zACbjrRt53Hb+qwqiHojDz9efXr4BtLQ2tTtvI2dnCmcvneB8TQVv7Gh/ElnfgP4en+uhd3rrdbc6piC8d+7ySa7X1zK4/0jXmNPpcH3Jepv7YG+8yhOPpNPUUk/qpCyaWxqY/+Q6cnfNxmgwsWxmgUrVdy966bWEgo7daPiW9XsWkvn8HxXjBsN3G4j1zTfw9+tLb3MgcyevBKCXOYBe5gDCgiMwGoyE9BnQlWV3S3rqtew+6JTD0crawudJn5ZPcKDydPGIsGg+v3CUxpZ6Gppu0Nsc2O7z5y6fpLG5jmv2K1y8cqaryu6W9NZr2VLQKevJ3dgu/pkt+5cDkDZlDUdO7GJh8tvMSFhO3rtzab7ZyNzJq9p91uF0sHnfUn49awetjhbWWX5Bzov7FdP86/F3+KD0f1HX8C11DVf55dMbumS9tEhvvTa0eXP+433o7Y/Ue5TZ0H6w6KeeT1/2buc+yuzFvAcZP+op11HxH9p2MJOPTxax5VenMBlNBA2Eh2d5Pn/p9Xc6u9d3IqFwF/JF7TgJha5zL0NBjikIIRTkmMJdhPftPssO6Nc5dXSUt/VIrzvuXtYjuw9CCAXZfRBCKEgoCCEUJBSEEAoSCkIIBQkFIYSChIIQQkFCQQihIKEghFCQUBBCKEgoCCEUJBSEEAoSCkIIBQkFIYSCXDp9F5YyuHRVnWWH94WnH/Z8+jNHoE6lm5S4E9APRkz0fHrpdcd52+s7kVC4i0tX1bsbkLfqrmjrbkDekl5rg+w+CCEUJBSEEAoSCkIIBQkFIYSCHGgULks3JnD6y6OYTLcekhoWHEHqY5n8JPoZtUvTHS33WrYUhELqpCw+yLFjWfkNiQ+lkL1zJtW1NrXL0iWt9lpCQbhlMvXgybj5OJ0OztdUqF2Ormmt15oOBafTSX5+PsOHD8dsNhMTE4PVamXEiBGkp6erXZ6u3WxtYW/pBnqYfIgYEKN2ObqmtV5r+phCWloaFouFrKwsYmNjKS0tJSUlhdraWpYsWaJ2eW4VZScwaNQkxiZnejSuNbsO57Dbmo+PqScDQobx+tz3CA8ZpnZZbkmvO4dmQ6GwsJCCggJKSkqIj48HIDExkfLyciwWC2PGjFG5Qn2a/dgKUidp+z8mvdBqrzW7+5Cbm0tSUpIrEG4bNmwYPj4+REdHc/XqVaZNm0ZkZCQxMTFMnjyZs2fPqlSxEPqgyVCorq6msrKS5557rt17VVVVREVF4evri8Fg4OWXX8Zms/HXv/6VadOmMW/ePBUqFkI/NBsKAKGhoYrxxsZGrFara9chKCiISZMmud6Pi4vj/PnzHi3DYDB49LJaS7yu//jeHDamBylel22feD0fq7XE4zo7Wmtn6or6pde3eFK/pzR5TCEkJAQAm83G1KlTXeN5eXnU1NQQGxvr9nPr1q0jOTm5K0q8o7HTV7g9+KV1b2WUqF2C16TX954mQyEiIoLo6Ghyc3MJDg4mPDycoqIiDhw4AOA2FFatWsXZs2c5cuSIR8vw9GHbb3+k3uW88fEJFGV7/lDwsne1dTlvfHwCbRs9r1963XHe9vpONLn7YDQa2b17N1FRUWRkZDBv3jxCQkJYsGABJpOJ6OhoxfTZ2dns27ePgwcP0qtXL5WqFkIfNLmlABAZGUlxcbFibM6cOYwcORI/Pz/X2KpVqzhw4AAfffQRQUFBXVylEPqj2VBwp6ysjHHjxrn+PnXqFCtXrmTo0KEkJCS4xk+cONH1xf2nZzNLvBoXHSe97hzdJhTsdjs2m4358+e7xqKiojw+NiCE8Iwmjym44+/vj8PhYNGiRWqX0i2crvqMxevjeHnDBDa+/4riva+vX2bZpoksXh9Hue0QbW1t1DdeZ/uHK3E4HTQ01bmd5/SsPrxz4DUA1hW9xOL143l5wwTOXT4JwJ5P1zNjVSiXvr6/TiDTW6+7TSgI7/QPGsybLx1h3YJPuGa/orj67g/Fa3nh8dWs/fmH7DycTavjJvuObebUhVJ2HlqNvema23kOCR1N2tQ1AMyc+Cr/c+Gn/GrGNnZ8tAqA5PELeXhEUqevm9bordcSCjoVHBhKTx8zACbjrRt53Hb+qwqiHojDz9efXr4BtLQ2tTu5JWdnCmcvneB8TQVv7Gh/ZmlY8BAAepiU874f6a3X3eaYguiYc5dPcr2+lsH9R7rGnE6H64vZ29wHe+NVnngknaaWelInZdHc0sD8J9eRu2s2RoOJZTML/uH83/nX13hqwi87ezW6Bb30WkJBx240fMv6PQvJfP6PinGD4bsNxPrmG/j79aW3OZC5k1cC0MscQC9zAGHBERgNRkL6DHA7f8vH6xjcbySjhkzotHXoLvTUa9l90CmHo5W1hc+TPi2f4EDlNSQRYdF8fuEojS31NDTdoLc5sN3nz10+SWNzHdfsV7h45Uy798vOfMipC6WavPS3q+mt17KloFPWk7uxXfwzW/YvByBtyhqOnNjFwuS3mZGwnLx359J8s5G5k1e1+6zD6WDzvqX8etYOWh0trLP8gpwX9yum2bB3Eb18A/nVpkT+yz+N4OVnN3fJemmR3nptaJMf+u9IzfPxh/aDRT/1fPrOPh//xbwHGT/qKddR8R/a8+l69h/dRHbafvr3HUzQQHh4lufzl15/p7N7fSeypSA8tnX5F3d8P3n8QpLHL+yiavRNzV5LKNxFeN/us+yAfp1TR0d5W4/0uuPuZT2y+yCEUJBfH4QQChIKQggFCQUhhIKEghBCQUJBCKEgoSCEUJBQEEIoSCgIIRQkFIQQChIKQggFCQUhhIKEghBCQUJBCKEgl07fhaUMLl1VZ9nhfeHphz2f/swRqFPpJiXuBPSDERM9n1563XHe9vpOJBTu4tJV9e4G5K26K9p6ErK3pNfaILsPQggFCQUhhIKEghBCQUJBCKEgBxqFy9KNCZz+8iim/3xmYVhwBKmPZfKT6GfULk13tNxr2VIQCqmTsvggx45l5TckPpRC9s6ZVNfa1C5Ll7TaawkF4ZbJ1IMn4+bjdDoUj1YX957Wei2hINy62drC3tIN9DD5EDEgRu1ydE1rvdZ0KDidTvLz8xk+fDhms5mYmBisVisjRowgPT1d7fLcKspO4PiebI/HtWbX4RySs4KYnT2Qo6f28vrc9wgPGaZ2WW5JrzuHpg80pqWlYbFYyMrKIjY2ltLSUlJSUqitrWXJkiVql6dLsx9bIU+S7iJa7bVmQ6GwsJCCggJKSkqIj48HIDExkfLyciwWC2PGjFG5QiH0SbO7D7m5uSQlJbkC4bZhw4bh4+NDdHQ0AMnJyURHR/PjH/+YsWPHcujQITXKFUI3NLmlUF1dTWVlJa+88kq796qqqoiKisLX1xeAgoICgoKCAPj3f/93EhIS+PbbbzGZTF1ZssLxvTn85UC+Yuxmk51BoyapVJF+Sa/vPU1uKVRX37r8LDQ0VDHe2NiI1WpV7DrcDgSA69evYzAY8OSZuQaDwaOX1Vridf1jp68g43fXFK8BkRO8no/VWuJxnR2t9fveyii5p/u4XVG/9PoWT+r3lCZDISQkBACbTXkiR15eHjU1NcTGxirGFyxYQEREBM888wzvvfcePXpocgNIiG5Bk6EQERFBdHQ0ubm5bN++ncOHD5ORkcHWrVsB2oXChg0bOHfuHBaLhWXLlmG32++6jLa2No9e8fEJnbGKHomPT/C4TrVrdac71d+danXHk/o9pclQMBqN7N69m6ioKDIyMpg3bx4hISEsWLAAk8nkOsj4Q/Hx8RiNRj799NMurlgI/dDsdnZkZCTFxcWKsTlz5jBy5Ej8/PwAsNvtfPPNNwwePBi4daDxb3/7Gz/60Y+6vN7bns0s8WpcdJz0unNoNhTcKSsrY9y4ca6/6+vrmTlzJna7nR49emA2m/n973/PoEGDVKxSiO5Nk7sP7tjtdmw2m+KXh/79+3Ps2DEqKys5ceIEx44d44knnlCxSu04XfUZi9fH8fKGCWx8X/nT7tfXL7Ns00QWr4+j3HaItrY26huvs/3DlTicDhqa6tzOc3pWH9458BoAG/YuZsnGeBb9yyNUnr+1u7btYCbJWUE4HK2du3Iao7ded5stBX9/fxwOh9pldBv9gwbz5ktH6OljZs2uVM7XVDAkbDQAfyheywuPr2bogBgyt05jdMSj7Du2mVMXStl5aDVJY9PoZQ5oN88hoaNJm7oGgJem5dPD5MPfr37Jv1jmk5O2n3lJ2VSe/6RL11ML9NbrbrOlILwTHBhKTx8zACbjrRt53Hb+qwqiHojDz9efXr4BtLQ2tfsdO2dnCmcvneB8TQVv7Hiu3fx7mHwAaGy2a+LKPjXprdfdZktBdMy5yye5Xl/L4P4jXWNOp8P1xext7oO98SpPPJJOU0s9qZOyaG5pYP6T68jdNRujwcSymQVu572y4Cm+uHicX6fs6IpV0Ty99FpCQcduNHzL+j0LyXz+j4pxg+G7DcT65hv4+/WltzmQuZNXAtDLHEAvcwBhwREYDUZC+gxwO/+VP/sTtdeqeWPHs7y96FinrUd3oKdey+6DTjkcrawtfJ70afkEBypPF48Ii+bzC0dpbKmnoekGvc2B7T5/7vJJGpvruGa/wsUrZ9q939LaDICfrz/mnr07ZyW6Cb31WrYUdMp6cje2i39my/7lAKRNWcORE7tYmPw2MxKWk/fuXJpvNjJ38qp2n3U4HWzet5Rfz9pBq6OFdZZfkPPifsU0Ob+fib3xGs42B2lT1nTJOmmV3nptaPPm/Mf70Nsfqfcos6H9YNFPPZ++7N3OfZTZi3kPMn7UU66j4j+07WAmH58sYsuvTmEymggaCA/P8nz+0uvvdHav70RC4S7ki9pxEgpd516Gguw+3EV43+6z7IB+nVNHR3lbj/S64+5lPbKlIIRQkF8fhBAKEgpCCAUJBSGEgoSCEEJBQkEIoSChIIRQkFAQQihIKAghFCQUhBAKEgpCCAUJBSGEgoSCEEJBQkEIoSCXTt+FpQwuXVVn2eF94emHPZ/+zBGoU+l+BO4E9IMREz2fXnrdcd72+k4kFO7i0lX1bvzhrbor2rrxh7ek19oguw9CCAUJBSGEgoSCEEJBQkEIoSAHGoXL0o0JnP7yKCbTrechhgVHkPpYJj+Jfkbt0nRHy72WLQWhkDopiw9y7FhWfkPiQylk75xJda1N7bJ0Sau9llAQbplMPXgybj5Op4PzNRVql6NrWuu1hIJw62ZrC3tLN9DD5HPfP2q+s2mt15oOBafTSX5+PsOHD8dsNhMTE4PVamXEiBGkp6erXZ4u7TqcQ3JWELOzB3L01F5en/se4SHD1C5Ll7Taa00faExLS8NisZCVlUVsbCylpaWkpKRQW1vLkiVL1C7PraLsBAaNmsTY5EyPxrVm9mMrSJ2k7Rpvk153Ds2GQmFhIQUFBZSUlBAfHw9AYmIi5eXlWCwWxowZo3KFQuiTZncfcnNzSUpKcgXCbcOGDcPHx4fo6GjF+O9+9zsMBgNFRUVdWaYQuqPJUKiurqayspLnnnuu3XtVVVVERUXh6+vrGvuP//gPtm3bxrhx47qyTCF0SbOhABAaGqoYb2xsxGq1KnYdWltbefHFF9m4caMiKO7GYDB49LJaS7yu//jeHDamBylel22feD0fq7XE4zo7Wuv3vZVRck/3cbuifun1LZ7U7ylNHlMICQkBwGazMXXqVNd4Xl4eNTU1xMbGusZWr17NlClTeOihh7q6zH9o7PQVbg9+iXtPen3vaTIUIiIiiI6OJjc3l+DgYMLDwykqKuLAgQMArlD47LPPOHLkCCUlJV4vo62tzaPp3v5IvWv84+MTKMr2rE6Asne1dY1/fHwCbRs9r1963XHe9vpONLn7YDQa2b17N1FRUWRkZDBv3jxCQkJYsGABJpPJdZCxuLiYv/3tbwwdOpQHHniAY8eOMX/+fN566y2V10CI7kuTWwoAkZGRFBcXK8bmzJnDyJEj8fPzA+DVV1/l1Vdfdb2fkJDAwoULefbZZ7u0ViH0RLOh4E5ZWZnmf2F4NrPEq3HRcdLrztFtQsFut2Oz2Zg/f/4/nKYjxxaEEEqaPKbgjr+/Pw6Hg0WLFqldSrdwuuozFq+P4+UNE9j4/iuK976+fpllmyayeH0c5bZDtLW1Ud94ne0frsThdNDQVOd2ntOz+vDOgddcfzffbGTGqlDKbYcA2HYwk+SsIByO1s5bMQ3SW6+7TSgI7/QPGsybLx1h3YJPuGa/orgk9w/Fa3nh8dWs/fmH7DycTavjJvuObebUhVJ2HlqNvema23kOCR1N2tQ1rr//9bP/zZCw0a6/5yVlM3TAQ521Spqlt15LKOhUcGAoPX3MAJiMt+7uc9v5ryqIeiAOP19/evkG0NLa1O7klpydKZy9dILzNRW8saP9maU3W1s4XXWMqAfGd+6KdAN663W3OaYgOubc5ZNcr69lcP+RrjGn0+H6YvY298HeeJUnHkmnqaWe1ElZNLc0MP/JdeTumo3RYGLZzIJ28/2wrIDHxjzPF1WfddWqaJ5eei1bCjp2o+Fb1u9ZyNLn3lGMGwzf/bPXN9/A368vvf36MHfySkxGE73MAfQN6E9YcARhwUMI6TNA8XmHo5WyM/+XsQ9O6ZL16A701GsJBZ1yOFpZW/g86dPyCQ5UXkMSERbN5xeO0thST0PTDXqbA9t9/tzlkzQ213HNfoWLV84o3rtq/ztXrlXx2pYkDpf/nnf+9TXqGlR63psG6K3XsvugU9aTu7Fd/DNb9i8HIG3KGo6c2MXC5LeZkbCcvHfn0nyzkbmTV7X7rMPpYPO+pfx61g5aHS2ss/yCnBf3u94P6RPOhsV/BmD7hysZ9cAEAnr17ZoV0yC99drQ5ulFAPcpNc/HH9oPFv3U8+k7+3z8F/MeZPyopxRHxb9v28FMPj5ZxJZfncJkNBE0EB6e5fn8pdff6exe34mEwl3IF7XjJBS6zr0MBdl9uItwFbeKvV12QL/OqaOjvK1Het1x97Ie2VIQQijIrw9CCAUJBSGEgoSCEEJBQkEIoSChIIRQkFAQQihIKAghFCQUhBAKEgpCCAUJBSGEgoSCEEJBQkEIoSChIIRQkEun78JSBpdUutNYeF94+mHPpz9zBOpUuh+BOwH9YMREz6eXXnect72+EwmFu7h0Vb0bf3ir7oq2bvzhLem1NsjugxBCQUJBCKEgoSCEUJBQEEIoyIFG4bJ0YwKnvzyKyXTreYhhwRGkPpbJT6KfUbs03dFyr2VLQSikTsrigxw7lpXfkPhQCtk7Z1Jda1O7LF3Saq8lFIRbJlMPnoybj9PpUDxaXdx7Wuu1hIJw62ZrC3tLN9DD5EPEgBi1y9E1rfVa06HgdDrJz89n+PDhmM1mYmJisFqtjBgxgvT0dLXLc6soO4Hje7I9HteaXYdzSM4KYnb2QI6e2svrc98jPGSY2mW5Jb3uHJo+0JiWlobFYiErK4vY2FhKS0tJSUmhtraWJUuWqF2eLs1+bAWpkzLVLuO+oNVeazYUCgsLKSgooKSkhPj4eAASExMpLy/HYrEwZswYlSsUQp80Gwq5ubkkJSW5AuG2YcOG4ePjQ3R0NAAJCQl8+eWX9OnTB4CkpCTWrl3b5fUKoReaDIXq6moqKyt55ZVX2r1XVVVFVFQUvr6+rrE333yTZ599titLvKPje3P4y4F8xdjNJjuDRk1SqSL9kl7fe5o80Fhdfevys9DQUMV4Y2MjVqv1nuw6GAwGj15Wa4nX8x47fQUZv7umeA2InOD1fKzWEo/r7Git3/dWRsk93cftivql17d4Ur+nNBkKISEhANhsyhM58vLyqKmpITY2VjG+YsUKRo8ezfTp0zl58mSX1SmEHmkyFCIiIoiOjiY3N5ft27dz+PBhMjIy2Lp1K4AiFLZv384XX3xBRUUFKSkpPP7449TX1991GW1tbR694uMTOms17yo+PsHjOtWu1Z3uVH93qtUdT+r3lCZDwWg0snv3bqKiosjIyGDevHmEhISwYMECTCaT6yAjwKBBg1ybRrNmzaJnz56cOXNGrdKF6PY0eaARIDIykuLiYsXYnDlzGDlyJH5+fgA0NTVht9tduxuHDx+mrq6OYcPUOwHk2cwSr8ZFx0mvO4dmQ8GdsrIyxo0b5/r7xo0bTJkyhZaWFoxGI4GBgbz//vsEBgaqWKUQ3Zsmdx/csdvt2Gw2xS8P/fr14y9/+QsVFRX89a9/5eOPP2bCBO+PPOvR6arPWLw+jpc3TGDj+8qfdr++fpllmyayeH0c5bZDtLW1Ud94ne0frsThdNDQVOd2ntOz+vDOgdcAyHv3Zyz6l0dYujGBI/++C4A9n65nxqpQLn19tnNXTmP01utus6Xg7++Pw+FQu4xuo3/QYN586Qg9fcys2ZXK+ZoKhoSNBuAPxWt54fHVDB0QQ+bWaYyOeJR9xzZz6kIpOw+tJmlsGr3MAe3mOSR0NGlT17j+fnX2TsW5+snjF2K7WNb5K6cxeut1t9lSEN4JDgylp48ZAJPx1o08bjv/VQVRD8Th5+tPL98AWlqb2v2OnbMzhbOXTnC+poI3djzXbv4Gg4G8d+eStfW/8ferX3buymic3nrdbbYURMecu3yS6/W1DO4/0jXmdDpcX8ze5j7YG6/yxCPpNLXUkzopi+aWBuY/uY7cXbMxGkwsm1nQbr4v/be3COwVTOX5T9j8wVJen1vUVaukWXrptWwp6NiNhm9Zv2chS597RzFuMHz3z17ffAN/v7709uvD3MkrMRlN9DIH0DegP2HBEYQFDyGkz4B28w7sFQzAqCET+Lbuq85dkW5AT72WUNAph6OVtYXPkz4tn+BA5eniEWHRfH7hKI0t9TQ03aC3uf2vNecun6SxuY5r9itcvNL+vI/6phsAXLxyBn+/oE5Zh+5Cb72W3Qedsp7cje3in9myfzkAaVPWcOTELhYmv82MhOXkvTuX5puNzJ28qt1nHU4Hm/ct5dezdtDqaGGd5RfkvLhfMc3aXanUNV7FYDDwy6c3dsk6aZXeem1o8+b8x/vQ2x+p9yizof1g0U89n77s3c59lNmLeQ8yftRTiqPi37fn0/XsP7qJ7LT99O87mKCB8PAsz+cvvf5OZ/f6TmRLQXhs6/Iv7vh+8viFJI9f2EXV6JuavZZQuIvwvt1n2QH9OqeOjvK2Hul1x93LemT3QQihIL8+CCEUJBSEEAoSCkIIBQkFIYSChIIQQkFCQQihIKEghFCQUBBCKEgoCCEUJBSEEAoSCkIIBQkFIYSChIIQQkEunb4LSxlcuqrOssP7wtMPez79mSNQp9JNStwJ6AcjJno+vfS647zt9Z1IKNzFpavq3Q3IW3VXOvduQJ1Neq0NsvsghFCQUBBCKEgoCCEUJBSEEApyoFG4LN2YwOkvj2Iy3XoeYlhwBKmPZfKT6GfULk13tNxr2VIQCqmTsvggx45l5TckPpRC9s6ZVNfa1C5Ll7TaawkF4ZbJ1IMn4+bjdDo4X1Ohdjm6prVeSygIt262trC3dAM9TD5EDIhRuxxd01qvNR0KTqeT/Px8hg8fjtlsJiYmBqvVyogRI0hPT1e7PF3adTiH5KwgZmcP5Oipvbw+9z3CQ4apXZYuabXXmj7QmJaWhsViISsri9jYWEpLS0lJSaG2tpYlS5aoXZ5bRdkJDBo1ibHJmR6Na83sx1aQOknbNd4mve4cmg2FwsJCCgoKKCkpIT4+HoDExETKy8uxWCyMGTNG5QqF0CfN7j7k5uaSlJTkCoTbhg0bho+PD9HR0QC0tLSwZMkShg8fzujRo3n00UfVKFcI3dDklkJ1dTWVlZW88sor7d6rqqoiKioKX19fAH7zm99QV1fHF198gclkoqampqvLFUJXNBsKAKGhoYrxxsZGrFYrU6ZMAaChoYHNmzdz8eJFTCYTAGFhYR4tw2AweDTdMyuKGfijBA8rv+X43hz+ciBfMXazyc6gUZO8mo/VWsIvJyd6PH3+L4qJGZrg1TK+762Mkg5/1h2rtYT/muJ5/dLrjvOk154+S1qToRASEgKAzWZj6tSprvG8vDxqamqIjY0F4OzZs/Tp04ff/va3HDx4EKPRyJIlS5gxY4Yqdd82dvoKtwe/xL0nvb73NBkKERERREdHk5ubS3BwMOHh4RQVFXHgwAEAVyi0trZy6dIlwsLCOH78OBcuXCAuLo7hw4fz4x//+I7L8DQ13/5IvWv84+MTKMr2rE6Asne1dY1/fHwCbRs9r1963XHe9vpONHmg0Wg0snv3bqKiosjIyGDevHmEhISwYMECTCaT6yDjoEGDAHjhhRcAeOCBBxg/fjzHjx9XrXYhujtNhgJAZGQkxcXF1NfXU1VVxerVq6moqGDkyJH4+fkBt3YzkpKS2L9/PwDffPMNx48fJyZG/bPChOiuNLn78I+UlZUxbtw4xdimTZtIS0vjjTfeoK2tjVdffbXdNF3p2cwSr8ZFx0mvO0e3CQW73Y7NZmP+/PmK8cGDB3Po0CGVqhJCfzS7+/BD/v7+OBwOFi1apHYp3cLpqs9YvD6OlzdMYOP7yvM9vr5+mWWbJrJ4fRzltkO0tbVR33id7R+uxOF00NBU53ae07P68M6B1wC40fAtq3fMYNmmiew8nAPAtoOZJGcF4XC0du7KaYzeet1tthSEd/oHDebNl47Q08fMml2pnK+pYEjYaAD+ULyWFx5fzdABMWRuncboiEfZd2wzpy6UsvPQapLGptHLHNBunkNCR5M2dQ0AOz5axQuPv8Ggfg+63p+XlE3l+U+6ZgU1RG+97jZbCsI7wYGh9PQxA2Ay3rq7z23nv6og6oE4/Hz96eUbQEtrU7uTuXJ2pnD20gnO11Twxo7n2s3/wleVFB7O5VebEvn8wtHOXRmN01uvZUtB585dPsn1+loG9x/pGnM6Ha4vZm9zH+yNV3nikXSaWupJnZRFc0sD859cR+6u2RgNJpbNLGg3388vlPK/Xi4nsFcwq7Y/w7oF998Wwg/ppdcSCjp2o+Fb1u9ZSObzf1SMGwzfbSDWN9/A368vvc2BzJ28EoBe5gB6mQMIC47AaDAS0mdAu3kP/KdIBvf/EQBGg2xw6qnX8q+pUw5HK2sLnyd9Wj7BgcprSCLCovn8wlEaW+ppaLpBb3Ngu8+fu3ySxuY6rtmvcPHKmXbvh/9TJN/cqKGxpR6H8/46sPhDeuu1bCnolPXkbmwX/8yW/csBSJuyhiMndrEw+W1mJCwn7925NN9sZO7kVe0+63A62LxvKb+etYNWRwvrLL8g58X9imlemLyK3J0ptNxs5Pmf/o8uWSet0luvDW2eXgRwn1LzfPyh/WDRTz2fvrPPx38x70HGj3rKdVT8h7YdzOTjk0Vs+dUpTEYTQQPh4Vmez196/Z3O7vWdSCjchXxRO05Coevcy1CQ3Ye7CO/bfZYd0K9z6ugob+uRXnfcvaxHthSEEAry64MQQkFCQQihIKEghFCQUBBCKEgoCCEUJBSEEAoSCkIIBQkFIYSChIIQQkFCQQihIKEghFCQUBBCKEgoCCEU5NLpu7CUwaWr6iw7vC88/bDn0585AnUq3Y/AnYB+MGKi59NLrzvO217fiYTCXVy6qt6NP7xVd0VbN/7wlvRaG2T3QQihIKEghFCQUBBCKEgoCCEU5ECjcFm6MYHTXx7FZLr1PMSw4AhSH8vkJ9HPqF2a7mi517KlIBRSJ2XxQY4dy8pvSHwoheydM6mutaldli5ptdcSCsItk6kHT8bNx+l0cL6mQu1ydE1rvZZQEG7dbG1hb+kGeph8iBgQo3Y5uqa1Xms6FJxOJ/n5+QwfPhyz2UxMTAxWq5URI0aQnp6udnluFWUncHxPtsfjWrPrcA7JWUHMzh7I0VN7eX3ue4SHDFO7LLek151D0wca09LSsFgsZGVlERsbS2lpKSkpKdTW1rJkyRK1y9Ol2Y+tIHVSptpl3Be02mvNhkJhYSEFBQWUlJQQHx8PQGJiIuXl5VgsFsaMGaNyhULok2ZDITc3l6SkJFcg3DZs2DB8fHyIjo7m2rVrJCQkuN5raWnh9OnTnDx5ktGjR3dxxULogyZDobq6msrKSl555ZV271VVVREVFYWvry++vr6cOHHC9d727dv57W9/q3ogHN+bw18O5CvGbjbZGTRqkkoV6Zf0+t7T5IHG6upbl5+FhoYqxhsbG7Farf9w12HLli0eH4A0GAwevazWEq/rHzt9BRm/u6Z4DYic4PV8rNYSj+vsaK3f91ZGyT3dx+2K+qXXt3hSv6c0GQohISEA2GzKEzny8vKoqakhNja23We++OILysvLSU1N7ZIahdArTYZCREQE0dHR5Obmsn37dg4fPkxGRgZbt24FcBsKv/vd75gxYwZ9+vTxaBltbW0eveLjE+7lqnklPj7B4zrVrtWd7lR/d6rVHU/q95QmQ8FoNLJ7926ioqLIyMhg3rx5hISEsGDBAkwmE9HR0Yrpm5ub2b59u2bPXRCiO9HkgUaAyMhIiouLFWNz5sxh5MiR+Pn5Kcb/9Kc/ERYWxj//8z93ZYluPZtZ4tW46DjpdefQ5JbCP1JWVuZ212HLli38/Oc/V6EiIfSn24SC3W7HZrO5/eXh8OHD/PKXv1ShKu06XfUZi9fH8fKGCWx8X/nT7tfXL7Ns00QWr4+j3HaItrY26huvs/3DlTicDhqa6tzOc3pWH9458BoAOb+fxdKNCfzy7X/mpd8+BMCeT9czY1Uol74+26nrpjV667Vmdx9+yN/fH4fDoXYZ3Ub/oMG8+dIRevqYWbMrlfM1FQwJu3X+xh+K1/LC46sZOiCGzK3TGB3xKPuObebUhVJ2HlpN0tg0epkD2s1zSOho0qauAWDF8+8C8EnFn/iPS38BIHn8QmwXy7poDbVDb73uNlsKwjvBgaH09DEDYDLeupHHbee/qiDqgTj8fP3p5RtAS2tTu9+xc3amcPbSCc7XVPDGjuf+4XI+rfwTE0Y93Tkr0U3ordfdZktBdMy5yye5Xl/L4P4jXWNOp8P1xext7oO98SpPPJJOU0s9qZOyaG5pYP6T68jdNRujwcSymQVu593quMn5ryoYPlCuQwH99FpCQcduNHzL+j0LyXz+j4pxg+G7DcT65hv4+/WltzmQuZNXAtDLHEAvcwBhwREYDUZC+gxwO/+//q2EmKEJnVV+t6KnXsvug045HK2sLXye9Gn5BAcqTxePCIvm8wtHaWypp6HpBr3Nge0+f+7ySRqb67hmv8LFK2fcLuPTyj8xftRTnVJ/d6K3Xkso6JT15G5sF//Mlv3LWboxgc8vHGX9nkUAzEhYzraDK/j15kmkTPxNu886nA4271tKxpPrmD/9f7Lxg1fanRHX1tbG518eZdQD3l9noDd667WhzZvzH+9Db3+k3qPMhvaDRT/1fPqydzv3UWYv5j3I+FFPuY6K/9CeT9ez/+gmstP207/vYIIGwsOzPJ+/9Po7nd3rO5FjCsJjW5d/ccf3k8cvJHn8wi6qRt/U7LWEwl2E9+0+yw7o1zl1dJS39UivO+5e1iO7D0IIBTnQKIRQkFAQQihIKAghFCQUhBAKEgpCCAUJBSGEgoSCEEJBQkEIoSChIIRQkFAQQihIKAghFCQUhBAKEgpCCAUJBSGEgoSCEEJBQkEIoSChIIRQkFAQQij8P1+aing0nZT3AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -702,7 +704,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "cc478975", "metadata": { "scrolled": true @@ -744,6 +746,7 @@ " observables=observable,\n", " input_params=feature_map.parameters,\n", " weight_params=ansatz.parameters,\n", + " estimator=estimator,\n", ")" ] }, @@ -757,7 +760,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -850,7 +853,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -924,7 +927,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/tutorials/12_quantum_autoencoder.ipynb b/docs/tutorials/12_quantum_autoencoder.ipynb index e13425c36..2db6a0a19 100644 --- a/docs/tutorials/12_quantum_autoencoder.ipynb +++ b/docs/tutorials/12_quantum_autoencoder.ipynb @@ -1,11 +1,5 @@ { "cells": [ - { - "cell_type": "raw", - "id": "89e72932", - "metadata": {}, - "source": [] - }, { "cell_type": "markdown", "id": "2fa8b1fa", @@ -254,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6497cb31", "metadata": {}, "outputs": [], @@ -269,6 +263,7 @@ "from qiskit import ClassicalRegister, QuantumRegister\n", "from qiskit import QuantumCircuit\n", "from qiskit.circuit.library import RealAmplitudes\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "from qiskit.quantum_info import Statevector\n", "from qiskit_machine_learning.optimizers import COBYLA\n", "from qiskit_machine_learning.utils import algorithm_globals\n", @@ -276,7 +271,8 @@ "from qiskit_machine_learning.circuit.library import RawFeatureVector\n", "from qiskit_machine_learning.neural_networks import SamplerQNN\n", "\n", - "algorithm_globals.random_seed = 42" + "algorithm_globals.random_seed = 42\n", + "sampler = Sampler()" ] }, { @@ -529,7 +525,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "varying-township", "metadata": {}, "outputs": [], @@ -545,6 +541,7 @@ " weight_params=ae.parameters,\n", " interpret=identity_interpret,\n", " output_shape=2,\n", + " sampler=sampler,\n", ")" ] }, @@ -911,7 +908,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "301b80ad", "metadata": {}, "outputs": [], @@ -926,6 +923,7 @@ " weight_params=ae.parameters,\n", " interpret=identity_interpret,\n", " output_shape=2,\n", + " sampler=sampler,\n", ")" ] }, diff --git a/docs/tutorials/13_quantum_bayesian_inference.ipynb b/docs/tutorials/13_quantum_bayesian_inference.ipynb index 9aee06e8a..cc224fd89 100644 --- a/docs/tutorials/13_quantum_bayesian_inference.ipynb +++ b/docs/tutorials/13_quantum_bayesian_inference.ipynb @@ -32,6 +32,10 @@ }, { "cell_type": "markdown", + "id": "f65b0713535b3fd6", + "metadata": { + "collapsed": false + }, "source": [ "### 1.1. Quantum vs. Classical Bayesian Inference\n", "\n", @@ -51,11 +55,7 @@ "For more information about primitives please refer to the [primitives documentation](https://qiskit.org/documentation/apidoc/primitives.html).\n", "\n", "The `QBayesian` class is used for QBI in `qiskit-machine-learning`. It is initialized with a quantum circuit that represents a Bayesian network. This enables the execution of quantum rejection sampling and inference.\n" - ], - "metadata": { - "collapsed": false - }, - "id": "f65b0713535b3fd6" + ] }, { "cell_type": "markdown", @@ -69,6 +69,10 @@ }, { "cell_type": "markdown", + "id": "6adf88f1d249b336", + "metadata": { + "collapsed": false + }, "source": [ "### 2.1. Create Rotations for the Bayesian Networks\n", "In quantum computing, the rotation matrix around the y-axis, denoted as $R_y(\\theta)$, is used to rotate the state of a qubit around the y-axis of the Bloch sphere by an angle $\\theta$. This approach allows for precise control over the quantum state of a qubit, enabling the encoding of specific probabilities in quantum algorithms. When this rotation is applied to a qubit initially in the $|0\\rangle$ state, the resulting state $|\\psi\\rangle$ is:\n", @@ -87,11 +91,7 @@ "\n", "This approach can be extended for conditional probabilities. For example, with the Bayesian network shown above, you can use the following formula to calculate the joint probability distribution:\n", "$$(X\\otimes{I})(I\\otimes{I}+P_1\\otimes{(R_y-I)})(X\\otimes{I})(I\\otimes{I}+P_1\\otimes{(R_y-I)})(R_y\\otimes{I})|00\\rangle$$" - ], - "metadata": { - "collapsed": false - }, - "id": "6adf88f1d249b336" + ] }, { "cell_type": "markdown", @@ -107,13 +107,13 @@ }, { "cell_type": "markdown", - "source": [ - "![Two Node Bayesian Network Example](../images/Two_Node_Bayesian_Network.png)" - ], + "id": "5a1d3cd4b14d9c1e", "metadata": { "collapsed": false }, - "id": "5a1d3cd4b14d9c1e" + "source": [ + "![Two Node Bayesian Network Example](../images/Two_Node_Bayesian_Network.png)" + ] }, { "cell_type": "markdown", @@ -130,11 +130,11 @@ "execution_count": 13, "id": "326c1d2e72f41202", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:43.964092Z", "start_time": "2024-03-15T12:25:43.916109Z" - } + }, + "collapsed": false }, "outputs": [], "source": [ @@ -192,11 +192,11 @@ "execution_count": 14, "id": "a815411b4f10c78c", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:43.977309Z", "start_time": "2024-03-15T12:25:43.922941Z" - } + }, + "collapsed": false }, "outputs": [], "source": [ @@ -238,17 +238,19 @@ "execution_count": null, "id": "4f99dbe56bc6910a", "metadata": { - "collapsed": false, - "is_executing": true, "ExecuteTime": { "start_time": "2024-03-15T12:25:43.936275Z" - } + }, + "collapsed": false, + "is_executing": true }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "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", + "text/plain": [ + "
" + ] }, "execution_count": 15, "metadata": {}, @@ -292,17 +294,19 @@ "execution_count": 16, "id": "79045cc1a7706f87", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:44.289098Z", "start_time": "2024-03-15T12:25:43.993735Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "iVBORw0KGgoAAAANSUhEUgAACHMAAAFvCAYAAADD4xX3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACBRElEQVR4nOzdeXgT5f7+8TstUGgLhbIVKIvs+1IQEVFAVARxQZHliIgcAS0ej8cFBE5BVEQB9XiQVZBFFBdEDyoou6KA7KuIgOxQdiht2do+vz/4ka8VKEmaZCbJ+3VdvZRkJnNPZp7nmUk+mXEYY4wAAAAAAAAAAAAAAABgC2FWBwAAAAAAAAAAAAAAAMD/oZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAboZgDAAAAAAAAAAAAAADARijmAAAAAAAAAAAAAAAAsBGKOQAAAAAAAAAAAAAAAGyEYg4AAAAAAAAAAAAAAAAbyWN1gFBjjFF6errVMdwSGRkph8NhdQwAQJBgLAQQ6ugHASC0MQ4AAAJtLGAcAADAGhRz+Fl6erqio6OtjuGW1NRURUVFWR0DABAkGAsBhDr6QQAIbYwDAIBAGwsYBwAAsAa3WQEAAAAAAAAAAAAAALARrsxhocOHD9u2mjUtLU0lS5a0OgYAIMgxFgIIdfSDABDaGAcAAHYdCxgHAACwHsUcFoqKirLlQRoAAP7CWAgg1NEPAkBoYxwAADAWAACAa+E2KwAAAAAAAAAAAAAAADZCMQcAAAAAAAAAAAAAAICNUMwBAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAAAAA2AjFHAFiyZIlcjgc2f6io6OVkJCgd955RxkZGVZHBAAAAAAAAAAAAAAAXpDH6gBwT5cuXdS2bVsZY5ScnKxp06bpueee09atWzVhwgSr4wEAAAAAAAAAAAAAgFyimCPAJCQkqGvXrs5/JyYmqnr16po4caKGDh2q4sWLW5gOAAAAAAAAAAAAAADkFrdZCXBRUVFq0qSJjDHauXOn1XEAAAAAAAAAAAAAAEAuBX0xx4IFC+RwOK74CwsLU5EiRdSsWTN98MEHMsZYHdVjl4s4YmNjLU4CAAAAAAAAAAAAAAByK+hvs7Ju3TpJUvHixVW1alXn4ykpKdq5c6d+/vln/fzzz9q5c6eGDh1qVUyXpaen69ixYzLGKDk5WePGjdO6devUuHHjbOsHAAAAAAAAAAAAAAACU9AXc6xfv16S1KNHD73xxhvZnjt9+rT+9re/ac6cOXrnnXc0aNAgRUREWJDSdYMHD9bgwYOzPfbggw9q9OjRFiUCrPf7779r8eLFSklJUXR0tJo1a6Y6depYHQt+YozRTz/9pA0bNujs2bMqWrSo2rRpo1KlSlkdDfCbDRs2aNmyZUpNTVWhQoXUqlUrVa5c2epY8JOsrCwtXLhQv/32m86fP68SJUqoXbt2XLUNCCHJycmaM2eOjh8/rgIFCqhu3bq69dZb5XA4rI4GP9myZYuWLl2qM2fOqGDBgmrRooWqV69udSwA8JvVq1dr5cqVSktLU0xMjFq3bq3y5ctbHQt+kpmZqXnz5mn79u26ePGiSpYsqXvvvVcxMTFWRwMAAMgdE+Rq1KhhJJmPP/74qs8vWLDASDKSzL59+3yeJzU11bm81NRUl+dbvHixkWR69epl5s+fb+bMmWPefPNNExsbaxo3bmxOnjzpnLZTp07m4Ycfzjb/8ePHTVxcnJk+fbpPcwL+9P3335s77rjDua/++a9Zs2bmyy+/tDoifCgzM9OMGzfO1KpV64rtnydPHtOxY0ezdu1aq2PiKrw1xvTv399IMpMmTbriuaysLNO8eXOTL18+s2nTJktz+tLMmTNN06ZNr9oPtm7d2ixcuNDqiPChCxcumBEjRpiKFStesf3z589vunfvbrZt22Z1TFwF/SC8Zf369aZTp04mb968V/QDNWrUMKNHjzaZmZlWx4QPzZ4929x2221XPRa4/fbbzdy5c62OiKvwZv/qy7GAcQB2l5WVZaZPn24aNWp0RR/ocDhMu3btzE8//WR1TPjQ2bNnzdChQ025cuWu2AciIyNNr169zK5du6yOeVWBcE7AOAAAgPWCupgjPT3dhIeHG0lmy5YtV51m9uzZRpKJiIgwGRkZPs+U22KOESNGZHv8559/Ng6Hw3Tq1Mn52PHjx03p0qWzFbB07tzZdOjQwec5AX95++23r/qB5V//Bg0aZHVU+MCFCxdMp06drrv98+fPb2bPnm11XPyFt8aY8+fPm9q1a5uYmJgrCjIv9xHDhg2zPKcvZGVlmX79+l23DTgcDjN69Gir48IHUlNTr1nQ+Oe/woULm6VLl1odF39BPwhv+Oabb0yBAgWu2w906NDBnD9/3uq48IEhQ4a4dE40fPhwq6PiL7zZv/pyLGAcgJ1lZWWZxMTE6/aB4eHhZsqUKVbHhQ+cOnXK3HLLLdfdB4oXL25WrVplddwrBMI5AeMAAADWC+pijhUrVji/zLtWoUaHDh2MJPPII4/4JZO3izmMMaZbt25Gkvn555+dj82dO9fExsaaAwcOmM8//9zExcWZY8eO+Twn4A8ffvihSx9aXv7773//a3VkeFnv3r1d3v4RERFm2bJlVkfGn3hzjFmzZo3JkyePueuuu5yP/fbbb6ZAgQLmpptuylWhpp3HwhEjRrjVD3766adWR4YXZWVlmfvuu8/l7R8TE2O2bt1qdWz8Cf0gcuuXX34x+fPnd7kf6NGjh9WR4WWjR49261jggw8+sDoy/sTb/auvxgLGAdhZUlKSy31gWFiY+eabb6yODC/KyMgwt99+u8v7QPHixW13hY5AOCdgHAAAwHphCmLr16+XJNWuXVvh4eHOx0+fPq2VK1eqY8eOmjlzpqpXr67hw4dblDL3kpKSFB4erkGDBjkfu/vuu9WxY0d17dpViYmJmjhxoooWLWphSsA7Ll68qL59+7o1z7///W+lpaX5KBH8bevWrRo/frzL058/f14DBw70YSJYKSEhQf3799e8efM0YcIEZWZmqlu3bjLGaOrUqdnG/2Bx+vRpDR482K15XnzxRWVmZvooEfzthx9+0OzZs12e/vTp03r11Vd9mAhWCsV+ENLAgQN17tw5l6f/4IMPtHnzZh8mgj+lp6e7fXz70ksv6cKFCz5KBKsxFiDUJCcn64033nB5+qysLPXt21fGGB+mgj99++23WrRokcvTHz161K19JtAwDgAAELyCuphj3bp1kqTVq1fL4XA4/woXLqybbrpJCxYs0Ouvv64VK1aodOnSFqf1XOXKldW5c2ctXLhQS5cudT4+cuRI7dixQ23atNE999xjYULAe/73v//p0KFDbs2TkpKijz/+2EeJ4G/jxo1ze57Fixdr69atPkgDO0hKSlK9evX0wgsv6B//+IdWrlypoUOHqlq1alZH84lp06YpPT3drXn27t2rOXPm+CgR/G3MmDFuz/P555/ryJEjPkgDOwi1fjDUbdu2TQsWLHB7vrFjx/ogDazwySef6NSpU27Nc+TIEc2aNcs3gWALjAUIJZMmTdLFixfdmufXX3/Vjz/+6KNE8DdPzommT5+u06dP+yCNPTAOAAAQnIK6mOPylTmqVaumW265xflXs2ZN5c+fXydPntS0adN04MABa4N6wcCBAxUWFpbt6hxRUVGqWLGi6tSpY2EywLtmzJjh1/lgP55uy08++cTLSWAXefPm1dSpU3Xu3DmNHTtWzZo107PPPmt1LJ+hHwxt586d05dffun2fBcvXuRLvCAWav1gqPvss888mo9xIHh4elzLPhDcGAsQSugHQ9uJEyf0/fffuz1fWlqavvnmGx8ksgfGAQAAglMeqwP4SlZWljZt2iRJmjx5sm6++eZsz584cULdunXTt99+q4ceekhbtmxRWJj7tS2NGjVScnKyW7k80aJFixwvBVijRg2fXT69SpUqHr03gC8cPXrUo/mWLl2q+Ph4L6eBvxljPN4HRo4cqUmTJnk5ETzh6ViYk5iYGEVEROjixYtq27at18ctO42F7hx3/NmsWbPoB4NAZmamMjIyPJq3b9++eu2117ycCJ6gH0RuuHtFhstOnjypMmXKyOFweDcQ/O7w4cMezTd37lyOBWzCF+OA5NuxgHEAduLuFVsvmzp1alB/mR8q3L0qy58lJiaqX79+XkzjuUA7J2AcAADAc3FxcVq9erVH8zpMkN4scOvWrapZs6YcDodSUlIUHR19xTTbtm1T9erVJUkbN2706AoW8fHxHl/ZIzU1VVFRUR7N66oWLVqoXbt2euGFF9yaLy0t7arvGQAA3uSNsdAYo9tvv13Lli1TpUqVtGfPHm3cuFGVKlXK1esyFgLwB/pBAAht3vpsyBdjAeMAAPiHXc8JGAcAAPCOMmXKaP/+/R7NG7RX5li3bp0k6YYbbrjmAUeFChWc/3/48GGPijni4uLcmj4rK8vj6nGrlCpViqpb2MbJkyeVnp7u9nz58+dX0aJFfZAI/nb48GGPfpUeExPDCahNeHssHDVqlJYsWaKhQ4fq/vvvV0JCgnr06KElS5Z47dfHdhoLjx8/rnPnzrk9X1RUlAoXLuz9QPArY4ySk5M9+hVXbGysChQo4INUcBf9IHIjNTXVo/u9h4eHu33+Cns6ceKEzp496/Z8kZGRKlKkiA8SwV2++GzI12MB4wDs5OjRo7pw4YLb80VHRysmJsYHieBPxhgdOnQox6tYX0vRokWVP39+H6RyX6CdEzAOAADguVx9HmOC1Isvvmgkmfbt219zmp07dxpJRpLZuHGjX3KlpqY6l5mamuqXZXoiUHIi9Kxatcq5b7rzN2/ePKujw0vefvttt7d//vz5zfHjx62Ojv/Pm2PM77//biIjI82NN95oMjIyjDHGvP7660aSeffdd22T05tmz57tUT/or2Md+N7l41x3/kqUKGHOnTtndXT8f/SDyI2TJ0+ayMhIt/uB4cOHWx0dXrJw4UKPjgWWL19udXT8f97uX301FjAOwK6mT5/udh/ocDjMzp07rY4OL+ndu7fb+0D58uWdfaQdBMI5AeMAAADWC9pSystX5qhbt+41p3n//fclXbq0Se3atf2SC0DuNGrUSDfeeKNb81SpUkWtWrXyUSL4W/fu3d3+ZXmXLl0UGxvro0SwSlZWlrp3767MzExNnTpV4eHhkqS+ffuqUaNG6t+/v3bu3GlxSu9r27atypcv79Y8zZo18+gKZLCnJ5980u1fVj3xxBOKiIjwUSJYJVT7wVBXuHBh/e1vf3NrnoiICD3++OM+SgR/a9mypfOWsa5q0KCBbrrpJh8lgpUYCxCKOnTooOLFi7s1T5s2bVSxYkUfJYK/JSYmuj3Pk08+6ewjgwnjAAAAwS1oiznWr18vSapXr94Vz6WkpGjAgAEaPny4JGnEiBFeu/wwAN+bPHmyy5fFLFCggKZPn85lAINIkSJFNGnSJJenr1y5srO/R3B56623tGzZMr3yyiuqUaOG8/Hw8HBNmTJFGRkZ6tGjh0eXXrWz8PBwTZ8+3eUv5mNjYzVx4kQfp4I/VaxYUW+99ZbL0zdq1EgDBgzwYSJYJVT7QUhvvPGGqlat6vL077//vooVK+bDRPAnh8OhDz/8UJGRkS5NX7BgQU2ZMoXPPYIUYwFCUUREhD788EOXv5iPi4vTmDFjfJwK/lS3bl29/PLLLk9/66236l//+pfvAlmIcQAAgOAWlN9u7t+/X8eOHZMkDRkyRM2aNXP+Va5cWUWLFtWwYcOUL18+jR49Wl26dLE4MQB31KpVSwsXLlTJkiVznK5w4cL67rvv1LhxYz8lg7906dJF06ZNU548eXKcrk6dOlq0aBFfXgShrVu3KikpSU2aNNHzzz9/xfO1atXSyy+/rB9//FGjRo2yIKFvNWvWTN9++60KFSqU43SlS5fWokWLVK1aNT8lg788++yzLhV0NGvWTN99952ioqL8kAr+FOr9YKgrWrSoFi1alOOVKCUpT548+uCDD/Too4/6KRn8pVGjRvr++++ve/W5EiVKaMGCBdfdVxCYGAsQylq3bq2vvvrquoVtN9xwgxYvXuz21Q1hf4MGDdKQIUOuO90dd9yhr7/+OiivVMg4AABA8HOYICzJ/Oabb3Tvvfde8XhYWJgKFSqkypUrq1WrVurdu7duuOEGv2ZLS0tTdHS0JCk1NdW2H6wHSk6EttOnT2vatGkaM2aMfvvtN+fj4eHhGjZsmB5//HG+xA9yu3fv1oQJEzRx4kQdPXrU+XjTpk2VmJioDh06BOXJeqALlDEmEHIePXpUH3zwgcaOHas9e/Y4H69Vq5YSExPVtWvX6xZ8ILD99ttvGjt2rKZMmaKUlBTn43fccYcSExN17733XrfwDf4XCP2LFDg5Q9n58+c1a9YsjRkzRj/99JPz8bCwML344ouWnPPCv44fP64pU6Zo3Lhx2rFjh/PxqlWrKjExUd26dVORIkUsTIirCZT+NVByIrQdOnRIEydO1Pjx43XgwAHn4/Xr11diYqL+9re/se8GuU2bNmns2LH68MMPlZqa6ny8bdu2SkxM1N13323L26sEQh8bCBkBAAh2QVnMYWeBcgAUKDkBSTLG6NChQ2rQoIGOHDmi0qVLZzuBR/C7cOGCypUrp8OHDysuLk6HDh2yOhJyEChjTKDklKTMzEzFx8crOTlZcXFxOnjwIJdSDzHnzp1ThQoVdPjwYZUqVUoHDx60OhJyECj9S6DkxCVHjx5V7dq1OR4OUVlZWSpTpgzHAgEiUPrXQMkJSFJGRobKli1LPxjCzp49qxtuuCFgzokCoY8NhIwAAAS7oLzNSiDavn27mjZtqqpVq+rGG2/Uli1brjrdpEmTVKVKFVWqVEk9e/bUxYsXnc9t2rRJLVq0UI0aNVSjRg3NmjVLkrR8+XLVr19f9evXV61atdS7d2+dP3/+us8BgcLhcKh06dLKmzev898ILfny5XP+8tyOv7YAfC08PNy574eHh9MPhqD8+fM7+8GwMA7xgVBUvHhxjodDWFhYGMcCAEJanjx56AdDXIECBTgnAgAAQYejGpvo3bu3evXqpd9//139+vVT9+7dr5hm165dSkpK0tKlS7Vjxw4dPnxYEyZMkCSlp6fr/vvv12uvvaatW7dq8+bNuvXWWyVJ9erV06pVq7R+/Xpt2rRJR44c0ZgxY677HAAAAAAAAAAAAAAA8D+KOWzgyJEjWr16tbp27SpJeuihh7Rv375s97uVpJkzZ+q+++5TXFycHA6HnnzySc2YMUOS9PHHH6tJkyZq1qyZpEsV6MWLF5ckRUZGOn+hdeHCBZ09e9ZZnZ7TcwAAAAAAAAAAAAAAwP8o5rCBffv2qVSpUs7LwDkcDpUrV0579+7NNt3evXtVvnx5578rVKjgnObXX39VRESE2rVrp/r166tbt246evSoc9rdu3erXr16KlasmGJiYpSYmOjScwAAAAAAAAAAAAAAwL8o5ggSGRkZWrBggcaPH69169apTJkyeuqpp5zPV6hQQRs2bFBycrLOnz+vWbNmufQcAAAAAAAAAAAAAADwL4o5bKBs2bI6dOiQMjIyJEnGGO3du1flypXLNl25cuW0Z88e5793797tnKZcuXJq2bKlypQpI4fDoa5du2rFihVXLCs6OlqdO3fWRx995NZzAAAAAAAAAAAAAADAPyjmsIESJUooISFB06dPlyR98cUXio+PV+XKlbNN99BDD2n27NlKTk6WMUbjxo1T586dJUkdO3bUqlWrlJKSIkmaM2eO6tWrJ0nasWOHLl68KEm6cOGCvvzyS9WtW/e6zwEAAAAAAAAAAAAAAP+jmMMmxo8fr/Hjx6tq1ap64403NHnyZEnSE088odmzZ0uSKlasqCFDhuiWW25R5cqVVbx4cfXu3VvSpStzDBgwQE2bNlXdunW1aNEijRs3TpK0aNEiNWjQQPXq1VODBg1UsmRJJSUlXfc5AAAAAAAAAAAAAADgf3msDoBLqlWrpuXLl1/x+MSJE7P9u2fPnurZs+dVX+PRRx/Vo48+esXjvXr1Uq9eva46z7WeS0tLcyU2AAAAAAAAAAAAAADwMq7MAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIt1mxkJ1vZWLnbACA4GHn8cbO2QAEDzv3NXbOBgDBws59rZ2zAUAwsWt/a9dcAACEEoo5LFSyZEmrIwAAYCnGQgChjn4QAEIb4wAAgLEAAABcC7dZAQAAAAAAAAAAAAAAsBGuzOFnkZGRSk1NtTqGWyIjI62OAAAIIoyFAEId/SAAhDbGAQBAoI0FjAMAAFiDYg4/czgcioqKsjoGAACWYSwEEOroBwEgtDEOAAAYCwAAgCu4zQoAAAAAAAAAAAAAAICNUMwBAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADZCMQcAAAAAAAAAAAAAAICNUMwBAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADZCMQcAAAAAAAAAAAAAAICNUMwBAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADZCMQcAAAAAAAAAAAAAAICNUMwBAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADZCMQcAAAAAAAAAAAAAAICN5LE6AEKPMUbp6elWx3BLZGSkHA6H1TEAAACAgMf5AAAg1MeCUF9/AKAfBADANRRzwO/S09MVHR1tdQy3pKamKioqyuoYAAAAQMDjfAAAEOpjQaivPwDQDwIA4BpuswIAAAAAAAAAAAAAAGAjXJkDljp8+LBtq1nT0tJUsmRJq2MAAAAAQYvzAQBAqI8Fob7+AEA/CADAtVHMAUtFRUXZ9kANAAAAgG9xPgAACPWxINTXHwDoBwEAuDZuswIAAAAAAAAAAAAAAGAjFHMAAAAAAAAAAAAAAADYCMUcAAAAAAAAAAAAAAAANkIxBwAAAAAAAAAAAAAAgI1QzAEAAAAAAAAAAAAAAGAjFHMgYCxZskQOhyPbX3R0tBISEvTOO+8oIyPD6ogAAAAAAAAAAAAAAORaHqsDAO7q0qWL2rZtK2OMkpOTNW3aND333HPaunWrJkyYYHU8AAAAAAAAAAAAAAByhWIOBJyEhAR17drV+e/ExERVr15dEydO1NChQ1W8eHEL0wEAAAAAAAAAAAAAkDtBf5uVBQsWXHFrjmv9bd++3eq48EBUVJSaNGkiY4x27txpdRwAAAAAAAAAAAAAAHIl6K/MsW7dOklSsWLFVK1atWtOlz9/flWuXNlfseBll4s4YmNjLU4CAAAAAAAAAAAAAEDuBH0xx/r16yVJjz/+uIYPH25tGHhFenq6jh07JmOMkpOTNW7cOK1bt06NGzdW1apVrY4Hi1y4cEGZmZlWx4BFjDHKyspy/j8Qii7v+7SB0EQ/CCAjI8N5PEw/EJo4FgAQ6ugHQxvnRAAAIBgF/W1WLl+Zo27duhYngbcMHjxYxYsXV4kSJVS3bl2NGTNGDz74oP73v/9ZHQ1+dv78ec2YMUPNmjVTRESEkpOTJUlHjhzR5MmTdfbsWYsTwtdOnDiht956S1WqVNGhQ4ckSQcPHtR9992n77//3nkSDwSrtLQ0TZw4UQkJCTp48KCkS22gefPm+vTTT3XhwgWLE8LXDh06pFdffVVly5bN1g926dJFS5cu5UNMBL0BAwbI4XDogw8+uOI5Y4xatGihiIgIbd682YJ0vpeVlaV58+bpgQceyHY8fPjwYY0YMULHjx+3OCF87ezZs5o6dapuuummbMcCTZs21UcffaTz589bnBDwrVAfB0J9/SXpzJkzGjt2rOrUqZOtH7zzzjv15ZdfKiMjw+KE8LV9+/YpKSlJpUqVynZO1K1bN61YsYJzoiBHPwgACHomiKWnp5vw8HAjyWzYsMHqOPj/UlNTjSQjyaSmpro83+LFi40k06tXLzN//nwzZ84c8+abb5rY2FjTuHFjc/LkSee0nTp1Mg8//HC2+Y8fP27i4uLM9OnTfZoT/rFt2zZTqVIl5za62l+ZMmXMunXrrI4KH/nmm29MVFRUjvtAs2bNzLFjx6yOCvjEqlWrTFxcXI5toGrVqmbHjh1WR4WPTJ061eTNmzfHfeDee+/lOAa2483j7PPnz5vatWubmJgYs2/fvmzPvf3220aSGTZsmOU5feH48ePmtttuy7EPiIyMNP/73/+sjgof2bhxoylbtmyO+8ANN9xgtm7danVU4Are6mN9OQ54M6evXjdQ199bli5daooWLZpjP1i3bt0r3hsEj9GjRzs//7/WX6dOnczZs2etjoq/oB8EAMA1DmOCtzT1l19+UZMmTZQ3b16lpaUpb968VkeCLv2KODo6WpKUmpqqqKgol+ZbsmSJWrZsqREjRuiFF15wPr5s2TI1a9ZMHTt21CeffCLp0q/169Spo5EjR6pLly6SpC5duigjI0Off/65T3PC93bt2qWbb75Zhw8fvu60MTEx+vnnn1WrVi0/JIO/zJkzR/fdd59Lt9apV6+efvzxRxUqVMgPyQD/WL9+vW677TadOXPmutOWLl1aK1asUNmyZf2QDP4yZcoUPf744y5N27JlS82dO1cRERE+TgW4xtvH2WvXrtVNN92k22+/Xd9//70kadu2bWrQoIHq1q2rn3/+WeHh4Zbn9KYzZ86oefPmzitR5iQsLExffvml7rvvPj8kg79s3bpVt9xyi06ePHndaYsXL67ly5erUqVKfkgGuMabfayvxgFv5/TV6wbi+nvD8uXLdfvtt+vcuXPXnfaGG27Q8uXLVbJkST8kg7+MGjVKzzzzjEvT3nPPPfrqq6+UJ0/Q33U+YNAPAgDgmqC+zcr69eslSdWrV6eQI4g1bdpUjz76qD799FMtW7ZMkhQbG6tJkybp6aef1sGDBzVz5kwtWbJE48aNszgtvOHxxx93qZBDkk6fPq0uXbpwScUgcubMGXXp0sWlQg5J2rBhg/r37+/jVID/ZGVlqXPnzi4VckiXLi/797//3cep4E/79+9Xz549XZ5+8eLFGjFihA8TAdZKSEhQ//79NW/ePE2YMEGZmZnq1q2bjDGaOnWqxx/c2tm///1vlwo5pEvjxiOPPKLTp0/7OBX8xRijRx55xKVCDkk6evSounXr5uNUgHVCcRz4s1Bc/4sXL6pjx44uFXJIl34U1KdPHx+ngj9t27ZN//znP12e/ttvv9Xo0aN9mAhWCsV+EAAQOoK6mOPyh1ubNm2Sw+G45t/LL79sbVDkWlJSksLDwzVo0CDnY3fffbc6duyorl27KjExURMnTlTRokUtTAlv2LRpk3744Qe35/npp598lAj+Nn36dKWkpLg1z7Rp09yeB7CrhQsXatu2bW7NM3/+fP3+++8+SgR/mzBhgtv3/h43bhz3C0dQS0pKUr169fTCCy/oH//4h1auXKmhQ4eqWrVqVkfzutTUVE2ZMsXteaZNm+abQPC7FStWuFzMc9myZcvcngcIJKE0DlxNqK3/119/rf3797s1z1dffeX2PLCvcePGuf3DrTFjxvBjryAWav0gACB0BHUxx+Urc1SrVk233HLLNf9atWplbVDkWuXKldW5c2ctXLhQS5cudT4+cuRI7dixQ23atNE999xjYUJ4y4QJEzyaj6uyBI/x48e7PU9qaqo+/vhjH6QB/M+TNiB53n/CXjIzM/X++++7Pd+BAwf07bff+iARYA958+bV1KlTde7cOY0dO1bNmjXTs88+a3Usn/j00089KlLleDh4eHos4Ol8QCAIpXHgakJt/T3pzzIzMzVp0iQfpIG/nTt3TpMnT3Z7vt9//11LlizxfiDYQqj1gwCA0BG0N4nLysrSpk2bJEkffPCBmjZt6pPlNGrUSMnJyT557WCVlZXlk9cdOHCgZsyYoUGDBmnx4sWSpKioKFWsWFF16tTJ1WtXqVJFYWFBXfsUMI4ePerRfJ9//rnbV/SA/RhjdPDgQY/mfeGFF/Taa695ORHgf67eZuqv3nvvPX3yySdeTgN/y8zM9PjYs1u3bipYsKCXEwHu89X5QExMjCIiInTx4kW1bdvWq8fvdjofOHXqlEfz/frrrypTpowcDod3A8Hvjhw54tF8kydP1jfffOPlNIBnfDEW+HIckLw7FoT6+ufWoUOHPJrvzTff9KgwGvaSkZHh8e3j2rdvr+joaC8ngifoBwEAoSQuLk6rV6/2aF6HCdJri23dulU1a9aUJJ0+fVqFChXyyXLi4+N14MABn7x2KEhNTVVUVJRPl9GiRQu1a9dOL7zwglvzpaWlcXAPAAAA+JC3zgeMMbr99tu1bNkyVapUSXv27NHGjRtVqVIlj1+T8wEA8A9vjAW+GAck/4wFob7+AEA/CAAIdmXKlPH4ln9Be2WOy/eCLV++vM8KOaRLlTRwT1ZWlscV9FYpVaoUVbc2cfz4cZ07d87t+fLly6fixYv7IBH87eDBgx7d4zQ6OloxMTE+SAT415EjR3Tx4kW35ytQoIBiY2N9kAj+lJvjqJiYGD6Egi344nxg1KhRWrJkiYYOHar7779fCQkJ6tGjh5YsWeKVK1HY6XwgJSVFZ86ccXs+h8Oh0qVL+yAR/O3o0aO6cOGC2/NFRESoWLFiPkgEuM/bY4GvxwHJu2NBqK9/bh0+fFgZGRluzxcZGakiRYr4IBH8KTdXKyxSpIgiIyO9nAieoB8EAISSXNUTmCD14osvGkmmXbt2VkfBX6SmphpJRpJJTU31+fKaN29uRowY4fZ8/s4J10ybNs25Xdz5e/fdd62ODi/p2bOnR/vAmjVrrI4OeMWbb77pURv47LPPrI4OL2nXrp3b2z88PNzs27fP6uiAMcb7x9m///67iYyMNDfeeKPJyMgwxhjz+uuv5/oY0K7nAxs2bPBoHHj88cetjg4vGT16tEf7wAcffGB1dMDJm32sr8YBb+f01esG4vrn1r///W+P+sG5c+daHR1e0rx5c7e3f0REhDl27JjV0fH/0Q8CAOCaoL3Nyp133qkFCxZowIABGjp0qNVx8Cd/vjSZP26z4qlAyRlqzp07p7Jly+rYsWMuzxMZGakDBw6ocOHCvgsGv1m/fr0aNGjg1jxNmjTR8uXLfZQI8K9jx44pPj5e58+fd3meuLg47d27V3nz5vVhMvjLd999pzZt2rg1T/v27TVr1iwfJQLc483j7KysLN16661as2aN1q1bpxo1aki69IvNJk2a6Ndff/X48sp2Ph+49dZb9dNPP7k1z6pVq9SoUSMfJYI/paSkqEyZMkpNTXV5niJFimj//v38Ghm24a0+1pfjgDdz+up1A3X9c2vfvn2qUKGCsrKyXJ6nUqVK+v333/lVfZD47LPP1KlTJ7fmeeyxxzRlyhTfBILb6AcBAHBN0B69rl+/XpJUp04da4MA8Kr8+fNryJAhbs3Tv39/CjmCSP369dW5c2eXpw8PD9drr73mw0SAfxUrVkwvvviiW/O8+uqrFHIEkbvuukstWrRwefoCBQooKSnJd4EAC7311ltatmyZXnnlFecHt9Kl8X/KlCnKyMhQjx49PLpFm5298sorypPH9bumPvTQQxRyBJFChQpp4MCBbs0zePBgCjkQlEJ1HLgsVNe/bNmyevrpp92aZ+jQoRRyBJEHHnhAjRs3dnn6QoUK6aWXXvJhIlglVPtBAEDoCMoj2P379zt/tf/666+rWbNm1/wbN26cxWkBuCsxMdHlDy/79Onj9gedsL/Jkyfrrrvuuu504eHhmjx5slq1auWHVID/DBkyRE888YRL077yyisuT4vAEBYWplmzZrn04WWBAgX0xRdfuH1FIyAQbN26VUlJSWrSpImef/75K56vVauWXn75Zf34448aNWqUBQl9p2XLlpo6dapLBR2tWrXStGnT/JAK/tSvXz8988wzXp8WCCShPA5IrP9bb73l8g893nnnHbev4gB7y5cvn77++muXfshZsGBB/e9//1P16tX9kAz+FOr9IAAgNATlbVa++eYb3XvvvS5N+9FHH+lvf/ubjxPhzwLl0mSBkjOUffLJJ3rzzTedV+L5sxo1auj5559Xjx495HA4/B8OPnfx4kUNHz5cY8aM0cGDB694vlWrVkpKSlLz5s0tSAf4njFGEyZM0Ntvv63ff//9iucbNmyol156SR06dLAgHfwhPT1dr776qt5//30dP34823MOh0Pt2rXT4MGD1bBhQ4sSAlcXKMfZgZDzxx9/1KuvvqoFCxZc8VypUqX01FNPqV+/fsqXL58F6eBrxhhNnTpVI0eO1JYtW654vm7duurbt68eeeQRC9IBOQuEPlay/21WfM3uObOysjRq1Cj997//1R9//HHF8zfffLMGDBigdu3aWZAO/pCSkqKXX35ZkydP1qlTp7I9Fx4ervvvv19DhgxR7dq1rQmIa7J7/3JZoOQEAASvoCzmgL0FygFQoOQMdcYYrVixQosWLdIbb7yh1NRUFStWTEeOHKGII0RcvHhR33zzjR577DGdOXNGhQoV0i+//MIvLhAyjDFauHChHnzwQWcbmD9/vluXnEVgO3funL788kv17t3buQ9s2LBBFSpUsDoacFWBcpwdKDkladu2bfrf//6nV199VampqYqNjVVycjK32AoRxhgtXbpU7dq105kzZ1SwYEHNnTtXTZs25ZwIthUofSzFHIGRMysrS99//706derkPB5esmQJV6cLIenp6Zo5c6aefvppnTlzRjExMdq8ebPi4+OtjoZrCJT+JVByAgCCV1DeZgWBZ/v27WratKmqVq2qG2+88aq/KpKkSZMmqUqVKqpUqZJ69uypixcvSrp00vbcc8+pZs2aqlu3rlq2bKkdO3Y45xsxYoRq166tmjVrqn379tkqtR0Oh+rUqaP69eurfv36Wrp0qU/XFd7lcDh08803a+DAgYqJiZEkRURE8KFlCMmbN6/at2+vQoUKSbp0+UwKORBKHA6H7rjjjmxtgEKO0JI/f3516dIl2z5AIQcQWqpVq6a+ffs6j4cLFChAIUcIcTgcuu2225zjQKFChXTLLbdwTgQgZISFhalNmzbZjocp5AgtkZGR6tatm3MfiI6OppADAAAEBYo5YAu9e/dWr1699Pvvv6tfv37q3r37FdPs2rVLSUlJWrp0qXbs2KHDhw9rwoQJkqTZs2fr559/1oYNG7Rx40a1atVKAwYMkCTNnz9fkydP1vLly/Xrr7+qYcOGGjhwYLbXXrp0qdavX6/169fr1ltv9fn6AgAAAAAAAAAAAABwLRRzwHJHjhzR6tWr1bVrV0nSQw89pH379mW7soYkzZw5U/fdd5/i4uLkcDj05JNPasaMGZIu/RLp/PnzOnfunIwxSklJcVZfb9iwQc2aNVPBggUlSW3bttWHH37oxzUEAAAAAAAAAAAAAMB1FHPAcvv27VOpUqWUJ08eSZcKM8qVK6e9e/dmm27v3r0qX768898VKlRwTnPvvfeqRYsWiouLU6lSpbRw4UK98sorkqSGDRtqwYIFSk5OljFGH330kc6cOaMTJ044X6tVq1aqV6+ennvuOaWlpfl6lQEAAAAAAAAAAAAAuCaKORAUVq9erc2bN+vAgQM6ePCgWrVqpSeffFKS1LJlS73wwgtq166dmjRpouLFi0uSs3hkz549WrNmjZYtW6ajR4/qxRdftGw9AAAAAAAAAAAAAACgmAOWK1u2rA4dOqSMjAxJkjFGe/fuVbly5bJNV65cOe3Zs8f57927dzunmTZtmm6//XYVLlxYYWFheuyxx7R48WLntImJiVq9erV++eUXtWjRQvHx8SpUqJDzdSUpKipKiYmJWrp0qU/XFwAAAAAAAAAAAACAnFDMAcuVKFFCCQkJmj59uiTpiy++UHx8vCpXrpxtuoceekizZ8923i5l3Lhx6ty5sySpYsWKWrRokS5cuCBJ+uabb1S7dm3nvIcOHZIkpaena9CgQerbt68k6eTJk0pPT5ckZWVl6dNPP1WDBg18u8IAAAAAAAAAAAAAAOQgj9UBAEkaP368unfvrtdff12FChXS5MmTJUlPPPGE7rvvPt13332qWLGihgwZoltuuUWS1KJFC/Xu3VuS1KdPH23dulX16tVT3rx5FRcXp3Hjxjlf/6677lJWVpYuXLigRx99VE8//bQk6bffflPv3r3lcDiUkZGhhIQEvfvuu35eewAAAAAAAAAAAAAA/g/FHLCFatWqafny5Vc8PnHixGz/7tmzp3r27HnFdBEREXr//fev+fqbNm266uM333yzNm7c6GZaAAAAAAAAAAAAAAB8h9usAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADbCbVZgqbS0NKsjXJOdswEAAADBwM7H3HbOBgDBxM79rT+yhfr6A4Cd+xo7ZwMAhAaKOWCpkiVLWh0BAAAAgEU4HwAAhPpYEOrrDwD0gwAAXBu3WQEAAAAAAAAAAAAAALARrswBv4uMjFRqaqrVMdwSGRlpdQQAAAAgKHA+AAAI9bEg1NcfAOgHAQBwDcUc8DuHw6GoqCirYwAAAACwAOcDAIBQHwtCff0BgH4QAADXcJsVAAAAAAAAAAAAAAAAG6GYAwAAAAAAAAAAAAAAwEYo5gAAAAAAAAAAAAAAALARijkAAAAAAAAAAAAAAABshGIOAAAAAAAAAAAAAAAAG6GYAwAAAAAAAAAAAAAAwEYo5gAAAAAAAAAAAAAAALARijkAAAAAAAAAAAAAAABshGIOAAAAAAAAAAAAAAAAG6GYAwAAAAAAAAAAAAAAwEYo5gAAAAAAAAAAAAAAALARijkAAAAAAAAAAAAAAABshGIOAAAAAAAAAAAAAAAAG6GYAwAAAAAAAAAAAAAAwEYo5gAAAAAAAAAAAAAAALARijkAAAAAAAAAAAAAAABshGIOAAAAAAAAAAAAAAAAG6GYAwAAAAAAAAAAAAAAwEbyWB0ACDXGGKWnp1sdwy2RkZFyOBxWxwhIgbi9XcV+4blA3C/Y3vAm2gDYB4DQFYjt/zL6Ae8JxP2A7Q/AU4HY57mKvhEAPBOIYwN9PryJNuA6ijkAP0tPT1d0dLTVMdySmpqqqKgoq2MEpEDc3q5iv/BcIO4XbG94E20A7ANA6ArE9n8Z/YD3BOJ+wPYH4KlA7PNcRd8IAJ4JxLGBPh/eRBtwHbdZAQAAAAAAAAAAAAAAsBGuzAFY6PDhw7atZExLS1PJkiWtjhFU7Ly9XcV+4X123i/Y3vAH2gDYB4DQZef2fxn9gO/ZeT9g+wPwNjv3ea6ibwQA77Lz2ECfD3+gDeSMYg7AQlFRUbbtoOB9bG9cDfsFQh1tAOwDQOii/UNiPwAQWujzAAB/xdiAUEcbyBm3WQEAAAAAAAAAAAAAALARrswBIKAdPnxYa9as0YEDB5SamipJOnv2rA4cOKDSpUvL4XBYnBC+ZIzRzp07tX79eqWlpUm6dNmrRYsWKSEhQYULF7Y2IOBjxhgdOHBAa9euzdYG5s6dq4YNG6pEiRIWJ4SvZWZm6vfff9eGDRuy7QNLly5VgwYNFB0dbXFCAL52+vRprV27Vn/88Ue24+EdO3aoUqVKHA+HgIMHD15xLPDtt9+qYcOGiouLszgdAPiWMUZ79+69oh+cN2+eGjZsqKJFi1qcEL6WmZmp3377TRs3bsy2Dyxbtkz169dXZGSkxQkBAAA8RzEHgICzZs0ajRkzRt9//70OHDhwxfMnTpxQfHy8SpYsqTvvvFNPPfWUbr75Zj7IDhKZmZmaO3euxo8fr6VLl+r06dPZnj916pRatWolSapUqZLat2+vJ598UpUqVbIiLuB1xhj99NNPGjt2rBYuXKgjR45ke/7UqVNq27atJCk+Pl5t2rRRYmKi6tevb0Fa+MKFCxf05ZdfauLEiVqxYoXzy9vLTp06pdtuu00Oh0PVq1fXww8/rF69eqlMmTIWJQbgbX/88YfGjx+vWbNmaceOHVc8f+LECVWpUkUxMTFq1qyZevXqpXvuuUfh4eEWpIW3GWO0YsUKjR07VvPnz1dycnK250+dOqV27dpJkkqXLq277rpLiYmJuvHGG62ICwBeZ4zRokWLNG7cOC1evFjHjx/P9vypU6fUunVrSVL58uV1zz33KDExUbVq1bIiLnzg3LlzmjlzpiZNmqSVK1cqPT092/OnTp3SLbfcorCwMNWsWVOdO3fWE088Yfk97wEAANzlMMYYq0MAoSQtLc35K9nU1FTb3gfKjjkXLVqk/v37a+XKlW7PW69ePb322mvODzX9xY7vY25YuT5ZWVl6//33NWzYMO3Zs8ft+e+++26NHDnSFh/eBMp+ESg5Q8lXX32lpKQkbd682e15b775Zr3xxhu67bbbfJDMPYGyb9ktZ0ZGht555x29/fbbV3xxdz3h4eFq3769RowYoQoVKvgmoBvs9t5eS6DkROjYunWrXnzxRc2ZM0funsqXK1dOL730knr37q2wMOvuuBpo7cpueefMmaOBAwdq/fr1bs/bqFEjDRs2THfccYf3g7nJbu/rtQRKTiBUGGP0ySefaMiQIdq2bZvb8zdv3lzDhw9X48aNfZDu2oKtL7Fyfc6fP6/hw4frv//9r44dO+bWvHnz5lXHjh315ptvUugOwHKBMjYESk4EnkDZt+yQ07pPcAC4ZcmSJXI4HNn+oqOjlZCQoHfeeUcZGRlWR/SZ1NRUJSYmqlWrVh4VckjShg0bdO+99+qxxx7TyZMnvZzQP0J5H9i1a5fuuOMOPfnkkx4VckjSd999p4SEBA0bNiwg36tQ3v6Qjh07pi5duqh9+/YeFXJI0vLly9W8eXP985//dF56NtCEcjvYvHmzmjRpor59+7pdyCFduqrRzJkzVadOHY0bN87tL4HtIJS3P5CRkaE333xTDRo00LfffutRG967d68SExN1++23648//vBBSt8L5X7g1KlTevzxx3XPPfd4VMghSatXr9add96p3r17KyUlxbsB/SSU9wEg1CUnJ6t9+/b629/+5lEhhyT98MMPuvnmm/XSSy/p3LlzXk7oH6HcD65Zs0aNGjXSoEGD3C7kkKSLFy/qo48+Uq1atTR16tSAPCcCAAChh9usAAGmS5cuatu2rYwxSk5O1rRp0/Tcc89p69atmjBhgtXxvG7Xrl1q3bq1tm/f7pXXmzZtmhYtWqTvv/9eNWvW9Mpr+luo7QPz58/Xgw8+eMVtBDxx4cIFDRgwQN99951mz56tmJgYLyT0r1Db/pA2btyou+++W4cOHfLK6/33v//VvHnzNG/ePJUtW9Yrr+lvodYOPvnkEz322GO6cOFCrl8rNTVVTz31lObNm6ePP/5Y+fPn90JC/wq17Q+kpKTogQce0OLFi73yej/88IPq1q2rmTNn6u677/bKa/pbqPUDv/32m1q3bq29e/d65fUmTJigBQsWaP78+apYsaJXXtPfQm0fAELdypUr1bZt2ytup+KJrKwsvfnmm/r+++/13XffBextN0KtH5w0aZJ69+6tzMzMXL/W6dOn1b17d82fP1+TJ09W3rx5vZAQAADARwwAv0pNTTWSjCSTmprq8nyLFy82ksyIESOueL34+HjjcDjMkSNHLM/pTX/88YcpU6aMM4c3/4oWLWo2b97s83Xw5vvo733gavy9X8yZM8fky5fPJ/tAo0aNzOnTp32+Dlfjyftoxfa3Qz8Q6tatW2cKFy7skzZQvnx5s3fvXkvWi7HQddOmTTMOh8Mn+8Cdd95pzp07Z8l60Q8CrklJSTE33XSTT/qAvHnzmq+//trv65SbdhWK/cDWrVtN8eLFfbIPlCpVyuzYscPv62QMxwIAXLd8+XITHR3tk36watWqJjk52efrwGdDuTNmzBifbH9J5oEHHjAXL170+ToAwF8FynFmoORE4AmUfcsOObnNChDgoqKi1KRJExljtHPnTqvjeM3p06d155136sCBAz55/ePHj+uuu+7S4cOHffL6/hSs+8DatWv10EMPeeWX6FezevVqtW/f3iu/6rBSsG5/SAcOHFDr1q116tQpn7z+nj17dNddd3nlqjdWC9Z2MH/+fD3++OM+u/yvr1/fX4J1+wNZWVnq0KGDfvnlF5+8/sWLF/Xwww9r1apVPnl9fwrWfuDo0aO68847dfToUZ+8/qFDh3THHXcE7G0o/yxY9wEg1O3cuVNt2rTx2TnL77//rrvvvjtgb7nyZ8HaD3711Vfq06ePT1//6aef9tnrAwAA5FbIFXOkpqaqVKlScjgciomJCfgPrwFJzpO02NhYi5N4z/PPP+/2yeeqVau0b98+lz+QPnjwoBITE4OiHwi2feD8+fN67LHHdPbsWZfncXf7S9KiRYs0atQoTyLaSrBtf0jGGPXq1UtHjhxxeR5P2sBvv/2ml156yZOIthNs7eD06dPq0aOHWwVnnuwDM2bM0GeffeZJRFsJtu0PSNLo0aM1b948t+Zxtx84d+6cHnvssaD4EisY+4E+ffpo//79Lk/vyTiwe/du/etf//Iknu0E4z4AhLKsrCz16NHDreJ2T/rB9evXa8iQIR4ktJ9g6wePHDminj17uvW5nSf7wPjx4/Xtt996EhEAAMDnQq6Y44033lBycrKkS/ce3r17t7WBADelp6fr2LFjOnr0qDZt2qQ+ffpo3bp1aty4sapWrWp1PK/47rvvNGnSJLfni4uLU3x8vOLi4lyeZ9asWfr000/dXpaVQmEfePXVV7V582a35vFk+0vSgAEDtH37drfmsVIobH9IU6dO1Zw5c9yax9M2MHr0aC1evNiteawWCu3gueeec+sLPMnzfaBPnz4BdaWqUNj+wM6dOz0qtvOkH9i6datefvllt5dlpVDoBz7//HN9/vnnbs3j6TgwderUgPsSKxT2ASDUjR49Wj/++KNb83jaDw4fPlwrV650ax6rhUI/+PTTT+vYsWNuzePpPtCrVy+fXRUTAAAgV6y4t4tV9u3bZwoUKGDCwsJMoUKFjCTz1VdfWR0LISa39wa+2t+DDz5oDh06ZIucuZWVlWVq1arl0X0u9+3bZ4y51Nbdma9s2bI+uz+mL+6L6q994Gr8sV8kJyebvHnz+m37SzKdOnXyybpciyfvoxXb3w73gwtF58+fNyVLlvRrG0hISDBZWVl+W0fGwpxt3rzZr+OgJPPss8/6bf2MoR8ErueRRx7xaz8QHh5uDhw44Jd1y027CpV+ICMjw1SoUMGv40C1atU4FvBiTgC5k5qaamJiYvzaD7Zo0cKn6+OtviRUPhtasWKFX4+FJJmkpCSfrAvgDwcPHjSvvvqqefjhh829995rHnvsMfPll1/67DNvu7lw4YL57LPPTLdu3cy9995rOnbsaN544w1z5MgRq6Ndk7f60v79+xtJZtKkSVc8l5WVZZo3b27y5ctnNm3aZGlOXzt58qR59913TefOnc29995rHnnkETNlyhSTnp5udTS/yMzMNPPmzTN///vfzX333Wc6dOhgBg4caHbt2mV1tGvy5r7ly3ZghzYQUlfm6N+/v86ePatHHnlEt956qyRp48aNFqcC3NOrVy/Nnz9fc+bM0ZtvvqnY2Fjt379f+fPnd07TuXNndezYMdt8J06cUKlSpfTRRx/5O7Jbli5dqi1btvh1mfv27QuoX6IF+z4wceJEXbx40a/L/OKLL5xXbbK7YN/+kL788ku/XyVh7dq1bl2G1mrB3g7Gjh3r92VOnjxZaWlpfl+uJ4J9+wNHjhxx+4oMuZWZman333/fr8vMjWDvB7777ju/X0V027ZtAXWlrmDfB4BQN2PGDJ0+fdqvy1yyZIl+/fVXvy4zN4K9HxwzZozfl/n+++/7/fMoILdOnDihv/3tbypXrpySkpL0+eef6+uvv9bUqVPVvn17VaxYUR988IHVMX3GGKPRo0erfPny6tixo6ZNm6avv/5an332mV566SXFx8ere/fuSklJsTqqz7z88suqXbv2Va/w+p///Ec//PCDhgwZotq1a1uU0LfOnTunZ555RmXKlNE///lPffLJJ/r666/10UcfqXv37oqPj9fQoUOVlZVldVSfmTVrlqpXr6677rpLkyZN0uzZszVz5kwNHTpUFStW1H333ef21X8DTdC3A0tKSCywevVq43A4TP78+c2ePXtM3759jSTToUMHq6MhxOT2F0gjRozI9vjPP/9sHA5HtisLHD9+3JQuXdp8/PHHzsc6d+7s1v5uVbVZp06dPKq8Vy6r7++8806frI8vfn3hr33gany9X1y8eNGULVvW79tfknnllVe8vj7XkptfpPtz+9uh6jQU3XbbbZa0gW7duvltHRkLry0lJcUULFjQkn3g/fff98s6GkM/CORk2LBhlhwPly5d2ly4cMHn6+eNK3MEez/Qtm1bS8aBBx980C/rZwzHAgBy1qBBA0v6wT59+vhkffhsyD1Hjx41ERERluwDn376qdfXB/CVw4cPm+rVq7u0bw8ePNjquF6XlZVlXnjhBZfWv169eubEiRNWR87Gm33pmjVrTJ48ecxdd93lfOy3334zBQoUMDfddJPJyMiwRU5vS09PN82bN3dpH3j00UdNZmam1ZG9bsyYMS6tf5kyZcyOHTusjpuNt/ctX7UDO7SBkCnmuPzFSL9+/YwxxkydOtVIMlWrVrU4GUKNtz+0MsaYbt26GUnm559/dj42d+5cExsbaw4cOGA+//xzExcXZ44dO+bznLmRmZnp8RdYuT1hCw8P98klt/xxwm6Mb/aBq/H1frF27VpLtr8kc9NNN3l9fa7Fm19iGuO77W+HA5VQc+rUKcvaQNGiRf12eXXGwmv79ttvLdsHHnjgAb+sozH0g0BObrnlFsv6gZUrV/p8/XxRzGFM8PQD586d8+iWg97Y/pGRkbn6oNcdHAsAuJYDBw5YNg5WqFDBJ+vEZ0Pu+eSTTyzbB/z5IwcgN7KyskyTJk3c2r8/+ugjq2N71YQJE9xa/1atWvn1toLX4+2+NCkpyUgy48ePNxkZGaZx48Ymf/785rfffrNVTm969NFH3doHhgwZYnVkr5o/f75xOBwur3/VqlXNuXPnrI7t5It9yxftwA5tICRus/Lll1/qxx9/VNGiRdW/f39JUq1atSRJO3bs0NmzZ62MB+RaUlKSwsPDNWjQIOdjd999tzp27KiuXbsqMTFREydOVNGiRS1MeX3bt2/XmTNnLFl2ZmamNmzYYMmyvSFY9oE1a9ZYtuwNGzYoIyPDsuXnRrBsf0jr1q2zbNnHjx/X3r17LVt+bgVLO7CyH7Ry2bkVLNsfyMzMtHQsoB+w3qZNmyy7xHt6erp+++03S5btDcGyDwChzsqxaPfu3Tp+/Lhly8+tYOkHOScCrm/RokVasWKFW/O89tprMsb4KJF/ZWZmaujQoW7Ns3DhQq1cudJHiayXlJSkevXq6YUXXtA//vEPrVy5UkOHDlW1atWsjuYTu3bt0vTp092a5+233w6YWwy7YtiwYW616d9//10zZ870YSLrBWs7CPpijosXL6pfv36SLm3EmJgYSVLNmjUVFhamrKwsbd682cqIQK5VrlxZnTt31sKFC7V06VLn4yNHjtSOHTvUpk0b3XPPPRYmdM3atWstXX4gn7AFyz5g5TY4d+5cQN0f98+CZfuDfjA3gqUdWLkN9u3bpyNHjli2/NwIlu0PbNu2Tenp6ZYtn3HAelZvA6uXnxvBsg8Aoc7qfsjqc7LcCJZ+0Mp9YOvWrUH1RR+C15gxY9yeZ+vWrfrhhx98kMb/5s6dqz179rg9nyfvW6DImzevpk6dqnPnzmns2LFq1qyZnn32Watj+cy4cePcLk46ffq0ZsyY4aNE/rV161YtWrTI7fmCuQ1IwdsOgr6YY/To0dq+fbsqVqyop556yvl4gQIFdMMNN0iSNm7caFU8wGsGDhyosLCwbNX3UVFRqlixourUqWNhMtdZ/Ytwq5efW+wDgb/83AiG7Q/r90Grl59bwdAOrN4G+/bts3T5uREM2x+gD8idYOgH2AdyJxj2ASDU0Q/mTjD0g1buA1lZWTp48KBlywdc9d1333k039y5c72cxBqhvv7XEhMTo4iICElS27ZtFRYWvF8Bh/o+8P3333s037Jly5SSkuLlNPYSjO0gj9UBfOnEiRN65ZVXJF263Ey+fPmyPV+rVi3t3LkzV7dWaNSokZKTk3OVE6ElKyvLo/latGiRY6VhjRo1lJmZ6WmsHFWpUsUvHV5Og8iqVasUFxeX4/yXn4+Li8vx5Ds5OVk33njjFY+PHj1aH330kYtpXePp9r4aK/eBq/HFfnHs2LFrPne9fcDV7S9dex947LHHVKBAARfTes6T/cLq7e+vfiDUnTp16prP+aMNDB48WCNHjnQtbC4wFl7b4cOHr/mcP/aBu+++23nC40v0g8DV5XQLUH8cDy9evFjx8fEupvVMbo6PQ6EfOH369DWf88c48Oabb2rs2LEupvUcxwIAruXEiRPXfM4f/eBzzz2XrRDCG/hsyD05fdbuj32gWbNmyps3r4tpAf8zxnh8Nb/33nvP659/WyGnsSInR48e9fn5jqu8OTZIl/aLxx9/XBcuXFCNGjX02muvqWPHjqpUqZLXlmGn42FPv5f99ttvbbMP5EZuCjKqVq2qPHmsLw/wdhuQfN8OctMG4uLitHr1ao/mtX5r+dCrr76qkydPqnHjxurYseMVz9eqVUuzZ8/O1ZU5kpOTdeDAgdzEBGzv0KFDVkdQXFycy4Nsnjx5PBqQ09LSuJSiG/y9X7i6D3i6/SXPTwRCgR36gVDnjzaQkpIS9NXZnrJDG/DHPpBTUV2os8M+gNDmj+PhCxcucH6bA6v7AX+MA2fOnNGZM2c8mjfYWb39AfinHzx9+nSOhXXILhg/GwrUW08CrkhPT7f0to52EKznO6NGjdKSJUs0dOhQ3X///UpISFCPHj20ZMkSORwOrywjGI6Hz58/H7T7gKty+iFZoPN1O7CqDQRtMceOHTs0evRoSdLKlStz3EibNm3yeDnX+2UU8FdZWVkBN+iVKlXKLxWXaWlp1/xVuiuVlnFxccqTJ48yMjJynP5azxUqVEgFCxZ0KaurAnF7u8oX+8WJEyeu+YvU6+0Drm7/nF6rWLFifvtFeqDtF/7qB0JdSkrKNb9A8UcbKFKkiCIjI10Lmwu0gWs7duyYzp8/f9Xn/LEPlCxZ0i/V+ewDwNVduHBBR48evepz/jgeLlCggGJjY10L66FAbP+X+aMfOHPmzDULK/0xDhQuXFhRUVGuhc2FQNwPGAcA/zh9+rRSU1Ov+pw/+sHY2FivX7EzEPs8V/mibzxy5IguXrx41ef8sQ/ExcUpPDzctbCARY4ePaoLFy64PZ+/PvfxtZy+R8hJRESEihUr5v1AHvDm2LB9+3b1799fN954o/r166fw8HC9/PLLGjBggEaNGqVnnnnGK8ux0/HwyZMnPSpM8sV3QFY4f/68Rz/ICg8PV8mSJb1W4JMb3j4+8kc7yE0byFU9gQlS7du3N5JMwYIFTcmSJa/6V7x4cSPJSDL79u2zOjJCRGpqqnO/S01NtTrONVmRc82aNc5levJ3uR3v27fPo/kXLFjg9XUKlO3tKl+vz3/+8x/Ltn9YWJhJS0vz+jpdTaDsF4GSM5h88803lrUBSWbLli1+Wc9A2besyNmvXz/L9oHY2FiTlZXll/VkHwCu7uzZsyZPnjyW9QMjR470+ToGWrvyd94lS5ZYeizwyy+/+HwdjQmc/SBQcgLBZMaMGZb2g3v37vX6OgVbX+Lr9UlMTLRsH6hQoYLX1wfwhenTp7u9f5csWdKcP3/e6uhekZaWZmJiYtx+D7766iurozt5qy/NzMw0TZs2NREREebXX391Pp6RkWEaNWpkIiMjzY4dOyzP6W2//PKL29s/b9685tChQ1ZH94qsrCxTq1Ytt98Df5zzu8qb+5Yv24Ed2oA9Sqi87Mcff9SXX36pPHny6JdfflFycvJV/w4ePKh8+fJJUq5utQLAO2rXru1sk1ZISEiwbNm4pGHDhpYtu2bNmkFRmY7AZmUbiIqKUrVq1SxbPi6xch9o2LChLSrzgVCWP39+1a5d27LlW9kH4ZIGDRpYtuw8efKobt26li0fACRrx6LixYt7fGsOeI/V50RAIOjQoYPKlCnj1jx9+vSx9LN3b4qMjFTv3r3dmqdSpUq65557fJTIOm+99ZaWLVumV155RTVq1HA+Hh4erilTpigjI0M9evSQMcbClN5344036uabb3Zrni5dugTN3RYcDof++c9/ujVPoUKF1L17d98Esliwt4OgK+Ywxuj555+XJD355JPZNtpf5cmTR1WrVpVEMQdgB/ny5dMtt9xiybLr16+vIkWKWLJs/J+EhATLLnPWsmVLS5YL/FlcXJyqV69uybJvu+02LiVrA7feeqtl24F+ELAHq9piVFSUGjVqZMmy8X8KFSpk2Xa4+eablT9/fkuWDQCXVapUybKCipYtW1LcbAMtWrSwbNmcEyFQREREaPbs2S5/jtquXTv179/fx6n869VXX1WrVq1cmrZIkSKaPXu2X24r609bt25VUlKSmjRp4vxe9M9q1aqll19+WT/++KNGjRplQULfcTgc+uyzz1w+ZmjQoIHee+89H6fyryeeeEI9evRwadp8+fJp1qxZKlq0qI9T+V8otIOgK+aYPn26Vq9erSJFiujll1++7vS1atWSRDEHYBdPPvlkSC0X2UVGRuqxxx6zZNnuVnMDvkI/GNri4uL0wAMP+H25efPmdfkEEIBvWXVM8uijjyo6OtqSZSM7jgUAhLKwsDDLxkL6QXuoWLGi7rrrLr8vNzIyUl27dvX7cgFPJSQk6Mcff1SlSpWuOY3D4dATTzyhL774IugKGfLly6evv/76uu22evXq+vnnn1WzZk0/JfOfGjVq6Ny5c1q+fPk1fxjUv39/GWP0zDPP+Dmd78XHx2vZsmW68cYbc5zunnvu0eLFiy37EamvOBwOvf/+++rbt2+O7btUqVKaN2+ey8VPgSYU2kFQFXOcPXtWAwYMkCQNGjTIpQojijkAe2nfvr3fL3VVqFAhPfLII35dJq4tMTHR78ts0aKFczwArPbYY4/5/ZY/5cqVC8pLTQaqPn36+H2ZHTp0UMmSJf2+XABXqlatmiUfslhxDIar69Kli2JiYvy6zBIlSuihhx7y6zIB4FqeeOIJv3/pWKNGDUuvCIHsrDgu6dq1q9/HXyC36tevr23btunbb79Vu3btnF9k5smTRy+99JL++OMPvf/++0Fze5W/KlCggD788ENt375dzz//vKpWraqwsEtfe+bPn1/z5s3Tli1bcryCPwJb2bJl9csvv+inn35Sly5dnG0gPDxcTz31lDZu3KhvvvkmaPv3sLAwvfnmm9q7d69eeeUV1a5d29kGIiIi9Pnnn2vPnj1q3ry5xUmRG0FVzFGgQAHt27dPxhg9++yzLs2TlJQkY4w2b97s23AAXJI3b179+9//9usyX3jhBX6FaCM1atRQp06d/LrMQYMG+XV5QE4KFy6sf/3rX35dZlJSErdYsZEWLVrotttu89vy8ubNG3SXWwUCnb+PTR588EHVqVPHr8vEtUVGRqpfv35+XWb//v0VERHh12UCwLXExcXpqaee8usyBw8ezC1WbOSee+5Rw4YN/ba8AgUK6MUXX/Tb8gBvCg8PV9u2bfX11187fyRZsmRJDRs2TBUqVLA2nJ9UrlxZI0eO1LZt21SqVClJUtGiRXXnnXc6v9hG8HI4HLrlllv08ccfO9tAXFycxowZEzLnuaVKlVJSUpI2bdrkbAPFihVThw4dlDdvXovTIbfoxQAb2L59u5o2baqqVavqxhtv1JYtW6463aRJk1SlShVVqlRJPXv21MWLF7M9b4zR7bffrsKFC191/u7du8vhcOjUqVOSpE2bNql+/frOvwoVKig2Ntabq+aRp556ym+Vgg0aNNBLL73kl2XBdaNGjVLx4sX9sqynnnrK1vdEfeaZZ1ShQgU5HA6tX7/+qtMsX77c2Y5r1aql3r176/z585KkRYsWqXHjxqpZs6Zq1aqlvn37Kisry49rAE8kJSX57Woxd911l/7+97/7ZVlwjcPh0AcffOC3K7QkJSXZ7uTWlWOjJUuWqECBAtmOZc6ePet8ftOmTWrRooVq1KihGjVqaNasWZKkrKwsvfDCC6pdu7aqV6+uv//977pw4YLf1g1wxW233aann37aL8sqWrSoxowZ45dlwXUvvvii377EuuWWW/SPf/zDL8vKSW7Pi3M6Jt69e7datGihmJgY1a9f/4rXvNaYAcA6r7/+um644Qa/LOvBBx9Ux44d/bIsuCZPnjyaPHmy376Aev3111W5cmW/LAsAAMAdFHMANtC7d2/16tVLv//+u/r166fu3btfMc2uXbuUlJSkpUuXaseOHTp8+LAmTJiQbZp33nnnmvfImzVr1hUnQHXq1NH69eudf+3atbPF7UbCwsI0adIkt6+WkZycrP379ys5Odml6fPly6cpU6bYsjLR1Q8yXZ1u8uTJcjgc+uqrr6773PHjx7N9MVa1alXlyZNHJ06c8NbqXVfx4sU1duxYt+Zxd/tL0g033KDhw4e7G8+vOnTooJ9++knly5e/5jT16tXTqlWrtH79em3atElHjhxxfilTpEgRffLJJ/r111+1Zs0aLVu2TNOmTfNXfHgoIiJCU6ZMcevSwp60gZiYGL3//vsB9ws0V4qcpEuFKnXr1lX9+vV16623at26dc7nzp07pwceeEBVq1ZVvXr1dOedd2rHjh1+SO+aSpUqud0/ebIPNGzY0JZFja4cG0mXbkfx52OZAgUKSJLS09N1//3367XXXtPWrVu1efNm3XrrrZIufQm4du1arV27Vlu3blVYWJjeffddf60a4LI33njD7S8VPOkHRo8eHRC3WXL1uLdChQqqVq2a81j2008/zfb8+fPn9fTTT6tKlSqqU6dOtntsf/fdd2rUqJHq1q2rJk2aaMOGDT5dp5zkyZNHU6ZMcetqGZ5s/8jISE2ePNkWV+jK7XlxTsfEhQoV0muvvaaPP/74itfMacwAYJ3o6GhNnjzZrV9Ue9IPFitWTGPGjLHlOZG3PhvK6bwop3OrnMZMf6hTp46GDBni1jye7AO33XabnnnmGXfjAQAA+IcB4FepqalGkpFkUlNTzeHDh03BggXNxYsXjTHGZGVlmZIlS5rt27dnm2/48OGmd+/ezn9/++235pZbbnH+e/PmzebWW281O3bsMDExMdnmTU5ONg0bNjQpKSlGkjl58uQVuc6ePWsKFy5s1q1bd9WcVli4cKGJiIhw5vDmX3h4uPnyyy99vg6evo8tW7Y0kydPNsYY8/nnn5tGjRp5PN2uXbvMzTffbJo0aXLFOuf03GUjRoww7dq1y9X6eOqNN97wyfaXZEqUKGG2bdvm83W4Gk/ex/LlyzvbZ07Onj1rWrdubd55552rPt+nTx8zePBgn+WEd3366afG4XD4pA0UKFDA/Pjjj5asV273rR9++MHs27fvuu3iz+PdrFmzTN26dZ3/Pnv2rPn2229NVlaWMcaYUaNGmebNm3s1Z25lZWWZf/7znz7rBytWrGgOHjzo9/UyJuf31tVjo8WLF5t69epd9fXff/9906VLl6s+16dPHzN06FDnv7/44gtTp04dt3MC/rB9+3YTFxfns37g1Vdf9fs6+fr4+Hpjw7PPPmuefvppZ/9/6NAhY4wxJ06cMLGxsWbz5s3GGGN+/PFHU6tWLcv7ga+//trkyZPHJ9s/X758Zt68eX5fJ2N8d1582bWOia82duQ0Zli9/QEYM2nSJJ+NgwULFjSrVq3y+TpY/dlQTudFOZ1bXWvM9GffmJWVZf7+97/7bB+oWbOmOXbsmE/XAfCnMmXKGEmmTJkyVkexTKC8B4FynBkoOS8LlO3vS4HyHgTKvmWHnFyZA7DYvn37VKpUKeevrx0Oh8qVK6e9e/dmm27v3r3ZfplfoUIF5zQXL15Uz549NX78+Kv+oqpnz54aPny4ChYseM0cs2bNUsWKFa96yVmr3H777frmm28UFRXl1dfNly+fZs6cqQceeMCrr+stR44c0erVq52/eHjooYe0b9++K34x7sp0WVlZeuKJJzRq1KgrftWX03N/NmnSJMtuwdCvXz+9+eabXn/d+Ph4LVmyRFWrVvX6a1tl9+7dqlevnooVK6aYmBglJiZeMU1ycrJmzpypdu3aWZAQnujYsaNmzJjh9SsIFSxYUHPnzg3YX53edtttio+Pv+50f77t2OnTp7P92i5//vxq27at87EmTZpo9+7d3o6aKw6HQ++8846ee+45r7929erV9cMPPzjvo2knrh4bSdLOnTuVkJCgG2+8MdttIn799VdFRESoXbt2ql+/vrp166ajR49KunQ1ktmzZyslJUUXL17UZ599ZrttD1xWuXJlLVmyRGXLlvX6a7/++usaOHCg11/XF1w9Pr6etLQ0TZo0SUOHDnX2/5fvqbxz504VLVrUeZuzW2+9VXv37s3xClD+0K5dO33xxRduXaHDFZGRkZo9e7buvPNOr76up7xxXiy5dkz8VzmNGQCs16NHD02aNMmtK3S4IjY2VgsWLFCjRo28+rre4s3PhnI6L7rWuVVOY6Y/ORwOjR8/Xr169fL6a9evX1+LFy9W0aJFvf7aAAAA3kIxBxAEhgwZogcffFA1atS44rmJEyeqXLlyuv3223N8DSu/sM/JHXfcoZUrV3rt5Lp27dpatmyZbQs5JNc/yHRlurffflu33HLLVe+3ndNzly1btkwnT5609Mv/vn376uuvv/baF4733XefVq5cedX2EsgqVKigDRs2KDk5WefPn7/iPt8pKSm699571bdvX9t+WIWr69Spk5YuXarq1at75fWaNGmiVatWqXnz5l55Pbvr1q2bypYtq6SkJH344YfXnO7dd9/V/fff78dkrnE4HBo5cqQ+/PBDFSlSxCuv+dhjj2n58uUuFcTYWUJCgvbv36+1a9fqyy+/1Lhx4/TZZ59JkjIyMrRgwQKNHz9e69atU5kyZfTUU09Jkrp37667775bzZs3V/PmzZ23EwPsqlq1alq1apXat2/vldeLi4vTV199pf79+9vykvJX406Rl3Sp769Tp47+/ve/Z/tSfufOnYqNjdXrr7+uRo0a6dZbb9XChQslSVWqVNHx48e1bNkySdLs2bN15swZ7dmzx8drd3333Xefli9frjp16njl9RISErRixQq1bt3aK69nJ9c7Jr6anMYMAPbQo0cPLVq0SBUrVvTK67Vo0UKrV69W48aNvfJ6vuDNz4Yk18+LLstpzPS38PBwjRs3ThMmTHD7lszX8uSTT+rHH39UiRIlvPJ6AAAAvkIxB2CxsmXL6tChQ8rIyJAkGWO0d+9elStXLtt05cqVy/ZB4u7du53T/PDDDxo1apQqVKigZs2aKSUlRRUqVNDRo0e1ePFi/e9//1OFChVUoUIFSVLdunWz3R9z165dWrFihf72t7/5eG09U7NmTS1fvlyvv/66xydt+fPn18CBA7V69eocixf84eabb1axYsWu+rdv3z6vLWfz5s364osv9O9//9ut5/5s0qRJ6tatm+VfcrVr105btmzRY4895vGvcUqUKKEPP/xQX331lS1/ie4t0dHR6ty5sz766CPnY2fOnNHdd9+t+++/3ye/8Ifv3XTTTVq3bp369u3r8S9zCxYsqBEjRuinn35StWrVvJzQe7zdR06bNk379u3Ta6+9pn79+l11mtdff107duzQsGHDchvfJxwOh7p27aotW7bk6svc8uXL65tvvtGUKVOy/TrPblw9NipUqJBiYmIkXbriUpcuXbR06VJJl46bWrZsqTJlyjjfvxUrVki69H6+/PLLWrdunZYtW6aaNWs6f4kP2FXJkiX1xRdf6OOPP1bJkiU9eo2wsDA9+uij2rJli+2K17zZ9//444/auHGj1q5dq2LFiumxxx5zPpeRkaE9e/aoZs2aWr16tf773/+qU6dOOnz4sGJiYjRz5kz1799fDRs21Lx581SzZk3Lj4Mva9CggVavXq2kpCQVKFDAo9eIiorSq6++qhUrVnitMMRbvHFe/GdXOya+lpzGDAD20bx5c23cuFH/+Mc/PL5yYeHChfXee+9p4cKFuuGGG7yc0D3++mzoMlfOi/4spzHTCg6HQz179tTmzZvVpk0bj1+ncuXKWrBggcaOHZvjFYwBAABsw5KbuwAh7Gr3V2revHm2e1s2bNjwivl27txpSpUqZQ4dOmSysrLMvffea0aNGnXFdLt27TIxMTHXXL6kbPfKNMaYf//73+aRRx65bk47OH36tBk9erSpVauWS/e+rFy5snnrrbfM8ePHLcnryfvo6v2irzfdmDFjTFxcnClfvrwpX768iYiIMMWLFzdjxozJ8bnLzpw5Y6Kjo83WrVtztT7etmfPHjNw4EBTsmRJl/aBW2+91cyYMcOcP3/ekrxX48n7mNP937dv324uXLhgjDHm/PnzpmPHjmbAgAHGmEvbsWnTpmbIkCF+yQnfO3r0qBk+fLipWLGiS22gbt26Zty4cSYlJcXq6E7e2rdyahdXkz9//ivuhzxixAjTsGHDK8ZGb+b0tm3btpl//etfpnDhwi7tA61btzb/+9//nOOFHVzvvXXl2OjgwYMmMzPTGGNMSkqKadq0qZk0aZIx5tJYUb16dXP69GljjDHDhw83bdu2NcYYc/bsWXPixAljzKX2VK9ePTN79myPcgJWOH/+vPnkk09M8+bNXeoDihcvbgYMGGB2795tdXRjjG+Pj//q4MGDJjo62vnvo0ePmrCwMJORkeF8rFGjRmb+/PlXzHvu3DlTuHBhs2HDBtv1AydOnDDvvPOOqVq1qkv7QI0aNcyoUaPMqVOnrI7u5Ivz4pyOiS9bvHixqVevXrbHchozGAcAe0pOTjZDhw41ZcuWdakfTEhIMJMmTTJpaWmW5LXys6Grudp50V/PrXIaM+3QN27evNn06dPHFCxY8Lrb3+FwmHvvvdfMnTvXef4ABKsyZcoYSaZMmTJWR7FMoLwHduhLXREoOS8LlO3vS4HyHgTKvmWHnPb4iQkQ4saPH6/u3bvr9ddfV6FChTR58mRJ0hNPPKH77rtP9913nypWrKghQ4bolltukXTpkpC9e/fO9bKzsrI0ZcoUTZs2Ldev5Q+FChVSYmKinnrqKR04cEBr1qzRmjVrdODAAZ0/f14REREqWbKkGjVqpIYNG6pcuXIBc/noy0qUKKGEhARNnz5d3bt31xdffKH4+HhVrlzZremeeuqpbJcHbtGihZ599lnnLWZyek6SPv30U9WrV89rt3bwlnLlyum1117TK6+8ot9//11r1qzR2rVrdeLECV28eFEFChTQDTfcoEaNGikhIUHFihWzOnKu9O7dW99++62Sk5PVunVrFSxYUDt27MjWPyxatEj//e9/FR4eroyMDLVq1UpJSUmSLt06YuXKlUpLS3NeZvrhhx/WwIEDrVwt5EKxYsX04osv6oUXXtDu3bud/eDhw4d14cIFRUREKD4+3tkPli5d2urIljh16pTS09Od6//VV1+paNGiio2NdU7z9ttva8aMGVqwYIGtr1TxV1WrVtXbb7+t4cOHa+vWrVqzZo3Wr1+vU6dOKTMzUwUKFFCVKlXUqFEjNWjQIKDW7TJXjo2++OILjR07Vnny5FFGRoYefvhhPf7445IujRUDBgxQ06ZNFRYWpjJlymjChAmSLt0nvEWLFgoLC1NWVpb++c9/6t5777VsXQF35cuXT506dVKnTp10/PhxrV27VqtXr9Yff/yhs2fPKm/evIqNjVWDBg3UsGFDVa1aVeHh4VbHzhVXj4/T0tJ08eJFZ783Y8YMNWjQwPl8sWLF1KpVK33//fdq27atdu3apV27djlvv3fo0CHnFdxeffVV3X777apUqZJ/VtINRYoU0bPPPqt//vOf2rt3r/NY4PKtRSIiIlS6dGk1bNhQDRs2VHx8fECcE+X2vDinY+L09HRVrVpV58+f1+nTpxUfH69HH31Uw4YNy3HMAGBPJUuW1IABA9S/f3/t3LnT+bnA0aNHdeHCBeXPn1/lypVz9oNxcXFWR3abtz4bcuW86GquN2ZarVatWnrvvff0zjvvaMuWLVqzZo02bNiglJQUZWZmKjIyUtWqVVPDhg3VoEEDFSpUyOrIAAAAHnEYY4zVIYBQkpaW5rxVSGpqqqKioixOdHWBktPuPH0ft23bpu7du+v48ePODzIvXwr5zx9m5jTdX12tYCOn55o2baqePXs6vxjLzfogu0B5HwMlJwJPbvetPxc5FS1a1FnkJP1fH1mvXj09/PDDOnv2rMLCwlS8eHGNHDlS9evXlyTt379fZcuWVcWKFZ2X142IiNAvv/zitZy4tkB5bwMlJxBIfHl8XLt2bT300EPKzMyUMUYVK1bUu+++67zdpCT98ccf+vvf/65jx44pLCxMgwYN0kMPPSRJ6tmzp5YuXaqMjAzdfPPNGjVqlPLmzUs/4AOB0r8GSk4A9mblZ0N79uzJ8bwop3Ora42Z9I2AfcXHx+vAgQMqU6aM9u/fb3UcSwTKexAofWmg5LwsULa/LwXKexAo+5YdclLMAfiZHRq+KwIlp90F2/sYbOtjlUB5HwMlJwJPoOxbgZIzEAXKexsoOYFAEmjtKtDyBopAeV8DJScAewu2viTY1gcIJoHyJa4vBcp7ECh9aaDkvCxQtr8vBcp7ECj7lh1yhvl9iQAAAAAAAAAAAAAAALimPFYHAEJZWlqa1RGuyc7ZAlUwvKfBsA52Y+f31M7ZEDzsvJ/ZOVswsfP7bOdsQDAIhDYWCBkDnZ3fYztnAxCYgqFfCYZ1AAA7sXO/audsCB523s/skI1iDsBCJUuWtDoC/Ijtjathv0Coow2AfQAIXbR/SOwHAEILfR4A4K8YGxDqaAM54zYrAAAAAAAAAAAAAAAANsKVOQA/i4yMVGpqqtUx3BIZGWl1hIAViNvbVewXngvE/YLtDW+iDYB9AAhdgdj+L6Mf8J5A3A/Y/gA8FYh9nqvoGwHAM4E4NtDnw5toA66jmAPwM4fDoaioKKtjwE/Y3rga9guEOtoA2AeA0EX7h8R+ACC00OcBAP6KsQGhjjbgOm6zAgAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCN5rA4AAAAAAAAAAAAAhAJjjNLT073+ullZWc7/pqWlefW1IyMj5XA4vPqaCG2+aAe0AQQjijkAAAAAAAAAAAAAP0hPT1d0dLTPXv/QoUNef/3U1FRFRUV59TUR2nzZDmgDCCbcZgUAAAAAAAAAAAAAAMBGuDIHAAAAAAAAAAAA4GeHDx+27a/909LSVLJkSatjIATYtR3QBmAHFHMAAAAAAAAAAAAAfhYVFWXLL7EBf6IdANfGbVYAAAAAAAAAAAAAAABshGIOAAAAAAAAAAAAAAAAG6GYAwAAAAAAAAAAAAAAwEYo5gAAAAAAAAAAAAAAALARijkAAAAAAAAAAAAAG1uyZIkcDke2v+joaCUkJOidd95RRkaG1REBn6INIBTlsToAAAAAAAAAAAAAgOvr0qWL2rZtK2OMkpOTNW3aND333HPaunWrJkyYYHU8wOdoAwglFHMAAAAAAAAAAAAAASAhIUFdu3Z1/jsxMVHVq1fXxIkTNXToUBUvXtzCdIDv0QYQSrjNCgAAAAAAAAAAABCAoqKi1KRJExljtHPnTqvjAH5HG0AwC+lijq+++koOh4MKLQAAAAAAAAAAAASky19gx8bGWpwEsAZtAMEqpG+zsmHDBklSvXr1LE4CAAAAAAAAAAAA5Cw9PV3Hjh2TMUbJyckaN26c1q1bp8aNG6tq1apWxwN8jjaAUEIxh6T69etbGwQAAAAAAAAAAAC4jsGDB2vw4MHZHnvwwQc1evRoixIB/kUbQCgJ6duscGUOAAAAAAAAAAAABIpevXpp/vz5mjNnjt58803FxsZq//79yp8/v3Oazp07q2PHjtnmO3HihEqVKqWPPvrI35EBr6INIJSEbDHHmTNntGvXLklcmQMAAAAAAAAAAAD2V6VKFd1xxx1q06aN+vbtq6+//lqrVq3Sk08+6ZxmzJgx+vnnnzVjxgznY3369FGzZs30yCOPWBEb8BraAEJJyBZzbNy4UcYYRUREqHr16lbHAQAAAAAAAAAAANzStGlTPfroo/r000+1bNkySVJsbKwmTZqkp59+WgcPHtTMmTO1ZMkSjRs3zuK0gPfRBhDMQraY4/ItVmrWrKm8efNanAYAAAAAAAAAAABwX1JSksLDwzVo0CDnY3fffbc6duyorl27KjExURMnTlTRokUtTAn4Dm0AwSrkiznq1atncRIAAAAAAAAAAADAM5UrV1bnzp21cOFCLV261Pn4yJEjtWPHDrVp00b33HOPhQkB36INIFiFfDFH/fr1rQ0CAAAAAAAAAAAA5MLAgQMVFhaW7coEUVFRqlixourUqWNhMsA/aAMIRnmsDmCFrKwsbdq0SVLuizkaNWqk5ORkL6QCAAAAAAAAAABAMMvKyvJovhYtWsgYc83na9SooczMTE9j5ahKlSoKC7P/78MPHTrk/G98fLzFaZATT9oBbeD6aAP2FBcXp9WrV3s0b0gWc+zYsUPp6emScn+bleTkZB04cMAbsQAAAAAAAAAAAABbufwFcaDIysriuzt4FW0AVgnJYo7Lt1gpX768ChcunKvXiouL80IiAAAAAAAAAAAABLusrKyA+2K4VKlSAXNVgqysLIWFhalUqVJWx0EOAq0d0AaQG7mpJwjpYo7cXpVDkseXRAEAAAAAAAAAAEBoSUtLU3R0tN+Wt2TJkly/xvbt2xUVFZX7MD4WHx+vAwcOqFSpUtq/f7/VcZADf7YD2gACmf1LiHzgcjFH/fr1rQ0CAAAAAAAAAAAAAADwFyFdzOGNK3MAAAAAAAAAAAAAAAB4U8gVc5w8eVL79u2TxJU5AAAAAAAAAAAAAACA/YRcMcfatWslScWKFdMNN9xgcRoAAAAAAAAAAAAAAIDsQq6Y44cffpAkNW/eXA6Hw+I0AAAAAAAAAAAAAAAA2YVUMUdGRoamT58uSerSpYvFaQAAAAAAAAAAAADXnDt3Tg888ICqVq2qevXq6c4779SOHTuumG737t0KDw9X/fr1nX87d+60IDHgme3bt6tp06aqWrWqbrzxRm3ZsuWa0xpjdPvtt6tw4cLOx3JqA6mpqWrdurWKFSuWbR7AjvJYHcBfzp49qz59+mjXrl2qXbu22rdvb3UkAAAAAAAAAAAAwGW9evVSmzZt5HA49N577+mJJ57QkiVLrpiuYMGCWr9+vd/zAd7Qu3dv9erVS927d9fMmTPVvXt3rVq16qrTvvPOO6pUqZLWrl2b7fFrtYG8efOqX79+io2NVYsWLXyQHvCeoL8yxxdffKGGDRuqePHimjx5sooXL65PPvlEYWFBv+oAAAAAAAAAAAAIEvnz51fbtm3lcDgkSU2aNNHu3butDQV42ZEjR7R69Wp17dpVkvTQQw9p3759V70KzZYtW/TVV1/ppZdecvn1IyIirriSB2BXQV/RMGfOHG3evFklS5ZUnz59tG7dOtWqVcvqWAAAAAAAAAAAAIDH3n33Xd1///1XfS4tLU033nijEhIS9MorrygzM9PP6QDP7Nu3T6VKlVKePJduMOFwOFSuXDnt3bs323QXL15Uz549NX78eIWHh1/xOrQBBIOgL+aYNGmSzp8/r507d+q9995TmTJlrI4EAAAAAAAAAAAAeOz111/Xjh07NGzYsCueK1WqlA4cOKBVq1ZpwYIFWrp0qd566y0LUgK+M2TIED344IOqUaPGFc/RBhAsgr6YAwAAAAAAAAAAAAgWI0eO1KxZszR37lxFRkZe8XxERIRKlCghSYqNjVWPHj20dOlSf8cEPFK2bFkdOnRIGRkZkiRjjPbu3aty5cplm+6HH37QqFGjVKFCBTVr1kwpKSmqUKGCjh49ShtA0KCYAwAAAAAAAAAAAAgAb7/9tmbMmKH58+ercOHCV53myJEjunjxoiTp/PnzmjVrlho0aODHlIDnSpQooYSEBE2fPl2S9MUXXyg+Pl6VK1fONt3SpUu1Z88e7d69Wz/99JMKFSqk3bt3q3jx4rQBBA2KOQAAAAAAAAAAAACb279/v55//nmdOnVKLVu2VP369XXTTTdJkgYNGqRx48ZJkn766Sc1aNBA9erVU0JCguLi4jRw4EArowNuGT9+vMaPH6+qVavqjTfe0OTJkyVJTzzxhGbPnn3d+a/XBurWraubb75ZKSkpio+P16OPPuqzdQFyw2GMMVaHAAAAAAAAAAAAAIJdWlqaoqOjJUmpqamKioqyONHVBUrOP4uPj9eBAwdUpkwZ7d+/3+o4yEEg7F+BkPGvaAPBhytzAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADaSx+oAAAAAAAAAAAAAQKhJS0uzOsI12Tkbgotd9zW75kJooZgDAAAAAAAAAAAA8LOSJUtaHQGwHO0AuDZuswIAAAAAAAAAAAAAAGAjXJkDAAAAAAAAAAAA8IPIyEilpqZaHcMtkZGRVkdAkAm0dkAbgFUo5gAAAAAAAAAAAAD8wOFwKCoqyuoYgKVoB4BruM0KAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjVDMAQAAAAAAAAAAAAAAYCMUcwAAAAAAAAAAAAAAANgIxRwAAAAAAAAAAAAAAAA2QjEHAAAAAAAAAAAAAACAjeSxOgAAAAAAAAAAAACA0GCMUXp6utdfNysry/nftLQ0r752ZGSkHA6HV18ToYs2AFc5jDHG6hAAAAAAAAAAAAAAgl9aWpqio6OtjuGW1NRURUVFWR0DQYI2AFdxmxUAAAAAAAAAAAAAAAAb4TYrAAAAAAAAAAAAAPzu8OHDtv21f1pamkqWLGl1DAQ52gByQjEHAAAAAAAAAAAAAL+Lioqy7RfZgD/QBpATbrMCAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAAAAA2AjFHAAAAAAAAAAAAAAAADZCMQcAAAAAAAAAAAAAAICNUMwBAAAAAAAAAAAAAABgIxRzAAAAAAAAAAAAALCtJUuWyOFwZPuLjo5WQkKC3nnnHWVkZFgdEfA52kHoyWN1AAAAAAAAAAAAAAC4ni5duqht27Yyxig5OVnTpk3Tc889p61bt2rChAlWxwP8gnYQOijmAAAAAAAAAAAAAGB7CQkJ6tq1q/PfiYmJql69uiZOnKihQ4eqePHiFqYD/IN2EDq4zQoAAAAAAAAAAACAgBMVFaUmTZrIGKOdO3daHQewBO0geAVVMceCBQuy3SNo8eLF15zWGKPGjRs7p61Tp44fkwIAAAAAAAAAAADIrctfXsfGxlqcBLAO7SA4BdVtVtatW5ft37/++qtatmx51WlnzJihVatWOf9dv359X0YDAAAAAAAAAAAAkAvp6ek6duyYjDFKTk7WuHHjtG7dOjVu3FhVq1a1Oh7gF7SD0BFUxRzr16+XJNWsWVO//vqrtmzZctXpzp07pwEDBihfvnwqXbq0du/erQYNGvgxKQAAAAAAAAAAAAB3DB48WIMHD8722IMPPqjRo0dblAjwP9pB6Aiq26xcvjJHt27dJOmaxRz/+c9/tGfPHiUmJurMmTOSuDIHAAAAAAAAAAAAYGe9evXS/PnzNWfOHL355puKjY3V/v37lT9/fuc0nTt3VseOHbPNd+LECZUqVUofffSRvyMDXkc7CB1BU8xx9uxZ/f7775KkDh06KDIy8qrFHEePHtWwYcNUpEgRde/eXcePH5dEMQcAAAAAAAAAAABgZ1WqVNEdd9yhNm3aqG/fvvr666+1atUqPfnkk85pxowZo59//lkzZsxwPtanTx81a9ZMjzzyiBWxAa+iHYSOoCnm2LhxozIzMxUTE6NKlSqpVq1aOn78uA4fPpxtusGDByslJUVJSUnau3evJKlcuXKKjY21IjYAAAAAAAAAAAAADzRt2lSPPvqoPv30Uy1btkySFBsbq0mTJunpp5/WwYMHNXPmTC1ZskTjxo2zOC3gG7SD4BU0xRzr16+XJNWrV0+SVLduXUnZb7Xy22+/6f3331elSpXUp08f5zwNGjTwa1YAAAAAAAAAAAAAuZeUlKTw8HANGjTI+djdd9+tjh07qmvXrkpMTNTEiRNVtGhRC1MCvkU7CE5BU8yxbt06Sf93u5SrFXO8+OKLysjI0BtvvKF8+fI5izm4xQoAAAAAAAAAAAAQeCpXrqzOnTtr4cKFWrp0qfPxkSNHaseOHWrTpo3uueceCxMCvkc7CE55rA7gLX8tzPhrMceiRYv0zTffqGnTpurQoYOk/ysAyc2VORo1aqTk5GSP5wcAAAAAAAAAAABCRVZWltdfc+DAgZoxY4YGDRqkxYsXS5KioqJUsWJF1alTJ9evX6VKFYWFBc1v5GExX7QBybftgDbgubi4OK1evdqjeYOimCMrK0ubNm2S9H/FHJd3yC1btigrK0vPP/+8JOmtt96SJKWkpGj37t3Z5vFEcnKyDhw44PH8AAAAAAAAAAAAAK6tRYsWMsZc8/kaNWooMzPTZ8s/dOiQz14bcJWV7YA2YI2gKObYtm2b0tPTlTdvXtWqVUuSVLRoUZUuXVpbtmzRtGnTtH79enXq1ElNmjSRdOlKHsYYFSlSROXLl/d42XFxcV5ZBwAAAAAAAAAAACDYZWVlBdwXw6VKleKqBPAa2kBoyU09QVAUc1y+XUrNmjWVL18+5+N169bVd999pxdeeEEREREaNmzYFfPk5qockjy+JAoAAAAAAAAAAAAQatLS0hQdHW11DLds375dUVFRVsdAkKANwFVBUcyxfv16SVcWZlwu5jh+/LheeOEF3XDDDVfM06BBAz+lBAAAAAAAAAAAAOAvS5YssToCYDnaQeAKimKOa11l4/bbb9eaNWuUN29eDRw4MNtz1yoAAQAAAAAAAAAAAAAAsFJQFHNcqzCjdevWat269RXTX7hwQVu2bJHElTkAAAAAAAAAAAAAAIC9hFkdILf279+vY8eOSXL9Khu//vqrLl68qPz586t69eo+TAcAAAAAAAAAAAAAAOCegC/muHxVjvLly6tw4cJuzVOrVi3lyRMUFycBAAAAAAAAAAAAAABBwmGMMVaHAAAAAAAAAAAAABD80tLSFB0dLUlKTU1VVFSUxYmuLlByIvAEyr4VKDmDWcBfmQMAAAAAAAAAAABAcHrmmWdUoUIFORwO59X3/2r37t1q0aKFYmJiVL9+/Sue37Rpk1q0aKEaNWqoRo0amjVrlm9DAz5y7tw5PfDAA6patarq1aunO++8Uzt27Lhiut27dys8PFz169d3/u3cudOCxMgN7jECAAAAAAAAAAAAwJY6dOigvn37qlmzZtecplChQnrttdd0+vRpDRw4MNtz6enpuv/++zVt2jQ1a9ZMmZmZOnHihK9jAz7Tq1cvtWnTRg6HQ++9956eeOIJLVmy5IrpChYseM0CKAQGrswBAAAAAAAAAAAAwJZuu+02xcfH5zhNbGysmjVrdtXbQHz88cdq0qSJsxgkPDxcxYsX90lWwNfy58+vtm3byuFwSJKaNGmi3bt3WxsKPkMxBwAAAAAAAAAAAICg9OuvvyoiIkLt2rVT/fr11a1bNx09etTqWIBXvPvuu7r//vuv+lxaWppuvPFGJSQk6JVXXlFmZqaf0yG3KOYAAAAAAAAAAAAAEJQyMjK0YMECjR8/XuvWrVOZMmX01FNPWR0LyLXXX39dO3bs0LBhw654rlSpUjpw4IBWrVqlBQsWaOnSpXrrrbcsSIncoJgDAAAAAAAAAAAAQFAqV66cWrZsqTJlysjhcKhr165asWKF1bGAXBk5cqRmzZqluXPnKjIy8ornIyIiVKJECUmXbkPUo0cPLV261N8xkUsUcwAAAAAAAAAAAAAISh07dtSqVauUkpIiSZozZ47q1atncSrAc2+//bZmzJih+fPnq3Dhwled5siRI7p48aIk6fz585o1a5YaNGjgx5TwBoo5AAAAAAAAAAAAANhS7969FR8fr/3796t169aqXLmyJOmJJ57Q7NmzJUnp6emKj4/Xww8/rF9//VXx8fHq37+/pEtX5hgwYICaNm2qunXratGiRRo3bpxl6wPkxv79+/X888/r1KlTatmyperXr6+bbrpJkjRo0CDnvv3TTz+pQYMGqlevnhISEhQXF6eBAwdaGR0ecBhjjNUhAAAAAAAAAAAAAAS/tLQ0RUdHS5JSU1MVFRVlcaKrC5ScCDyBsm8FSs5gxpU5AAAAAAAAAAAAAAAAbCSP1QEAAAD+X3t3bMQgDEVBEKU0QP9FQipXYI+dWDewW8EL9LObEQAAAADwPOd5rp7wVnkb91F+Z+VtTyHmAAAAAAAAAP7uOI7VE2ApN8AnvlkBAAAAAAAAAAgZc865egQAAAAAAABwf3PO7bqu1TN+su/7NsZYPYObcAN8S8wBAAAAAAAAABDimxUAAAAAAAAAgBAxBwAAAAAAAABAiJgDAAAAAAAAACBEzAEAAAAAAAAAECLmAAAAAAAAAAAIEXMAAAAAAAAAAISIOQAAAAAAAAAAQsQcAAAAAAAAAAAhYg4AAAAAAAAAgBAxBwAAAAAAAABAiJgDAAAAAAAAACBEzAEAAAAAAAAAECLmAAAAAAAAAAAIEXMAAAAAAAAAAISIOQAAAAAAAAAAQsQcAAAAAAAAAAAhYg4AAAAAAAAAgBAxBwAAAAAAAABAiJgDAAAAAAAAACBEzAEAAAAAAAAAECLmAAAAAAAAAAAIEXMAAAAAAAAAAISIOQAAAAAAAAAAQsQcAAAAAAAAAAAhYg4AAAAAAAAAgJAX9cxF8AYMZIMAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] }, "execution_count": 16, "metadata": {}, @@ -391,20 +395,22 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "1e602fda98a6356d", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:44.414966Z", "start_time": "2024-03-15T12:25:44.300268Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "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", + "text/plain": [ + "
" + ] }, "execution_count": 17, "metadata": {}, @@ -414,10 +420,12 @@ "source": [ "from qiskit_machine_learning.algorithms import QBayesian\n", "from qiskit.visualization import plot_histogram\n", + "from qiskit.primitives import StatevectorSampler as Sampler\n", "\n", + "sampler = Sampler()\n", "evidence = {\"X\": 1}\n", "# Initialize QBayesian\n", - "qb_2n = QBayesian(circuit=qc_2n)\n", + "qb_2n = QBayesian(circuit=qc_2n, sampler=sampler)\n", "# Sampling\n", "samples = qb_2n.rejection_sampling(evidence=evidence)\n", "plot_histogram(samples)" @@ -438,17 +446,19 @@ "execution_count": 18, "id": "a6fc4d5d394d301a", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:44.544878Z", "start_time": "2024-03-15T12:25:44.427867Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "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", + "text/plain": [ + "
" + ] }, "execution_count": 18, "metadata": {}, @@ -477,11 +487,11 @@ "execution_count": 19, "id": "4f019762e7f6b861", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:44.619555Z", "start_time": "2024-03-15T12:25:44.540091Z" - } + }, + "collapsed": false }, "outputs": [ { @@ -511,20 +521,22 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "8d4904619b35503a", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:44.729578Z", "start_time": "2024-03-15T12:25:44.618613Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "
", - "image/png": "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" + "image/png": "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", + "text/plain": [ + "
" + ] }, "execution_count": 20, "metadata": {}, @@ -533,7 +545,7 @@ ], "source": [ "# Initialize quantum bayesian inference framework\n", - "qb_ba = QBayesian(circuit=qc_ba)\n", + "qb_ba = QBayesian(circuit=qc_ba, sampler=sampler)\n", "# Inference\n", "counts = qb_ba.rejection_sampling(evidence={})\n", "plot_histogram({c_key: c_val for c_key, c_val in counts.items() if c_val > 0.0001})" @@ -580,16 +592,18 @@ "execution_count": 21, "id": "841bce19ea097bf1", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:44.795158Z", "start_time": "2024-03-15T12:25:44.744036Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "0.1004712084149367" + "text/plain": [ + "0.1004712084149367" + ] }, "execution_count": 21, "metadata": {}, @@ -628,16 +642,18 @@ "execution_count": 22, "id": "5468619791203a79", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:45.014942Z", "start_time": "2024-03-15T12:25:44.794874Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "0.0054042995153299" + "text/plain": [ + "0.0054042995153299" + ] }, "execution_count": 22, "metadata": {}, @@ -666,16 +682,18 @@ "execution_count": 23, "id": "a5434c7c7c45040a", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:45.806883Z", "start_time": "2024-03-15T12:25:45.028762Z" - } + }, + "collapsed": false }, "outputs": [ { "data": { - "text/plain": "0.0056128979765628" + "text/plain": [ + "0.0056128979765628" + ] }, "execution_count": 23, "metadata": {}, @@ -703,11 +721,11 @@ "execution_count": 24, "id": "d01e712eb69a686e", "metadata": { - "collapsed": false, "ExecuteTime": { "end_time": "2024-03-15T12:25:45.810056Z", "start_time": "2024-03-15T12:25:45.806688Z" - } + }, + "collapsed": false }, "outputs": [ { diff --git a/qiskit_machine_learning/VERSION.txt b/qiskit_machine_learning/VERSION.txt index a3df0a695..6f4eebdf6 100644 --- a/qiskit_machine_learning/VERSION.txt +++ b/qiskit_machine_learning/VERSION.txt @@ -1 +1 @@ -0.8.0 +0.8.1 diff --git a/qiskit_machine_learning/__init__.py b/qiskit_machine_learning/__init__.py index 3d9dc498a..ef3d105f5 100644 --- a/qiskit_machine_learning/__init__.py +++ b/qiskit_machine_learning/__init__.py @@ -37,8 +37,11 @@ circuit.library connectors datasets + gradients kernels neural_networks + optimizers + state_fidelities utils """ diff --git a/qiskit_machine_learning/algorithms/__init__.py b/qiskit_machine_learning/algorithms/__init__.py index 989d6b98f..9856908a8 100644 --- a/qiskit_machine_learning/algorithms/__init__.py +++ b/qiskit_machine_learning/algorithms/__init__.py @@ -53,18 +53,8 @@ PegasosQSVC QSVC - NeuralNetworkClassifier VQC - -Inference -+++++++++++ -Algorithms for inference. - -.. autosummary:: - :toctree: ../stubs/ - :nosignatures: - - QBayesian + NeuralNetworkClassifier Regressors ++++++++++ @@ -75,9 +65,18 @@ :nosignatures: QSVR - NeuralNetworkRegressor VQR + NeuralNetworkRegressor + +Inference ++++++++++++ +Algorithms for inference. +.. autosummary:: + :toctree: ../stubs/ + :nosignatures: + + QBayesian """ from .trainable_model import TrainableModel from .serializable_model import SerializableModelMixin diff --git a/qiskit_machine_learning/algorithms/classifiers/neural_network_classifier.py b/qiskit_machine_learning/algorithms/classifiers/neural_network_classifier.py index 76f25ad2a..dc94df1ba 100644 --- a/qiskit_machine_learning/algorithms/classifiers/neural_network_classifier.py +++ b/qiskit_machine_learning/algorithms/classifiers/neural_network_classifier.py @@ -140,23 +140,76 @@ def _create_objective(self, X: np.ndarray, y: np.ndarray) -> ObjectiveFunction: return function def predict(self, X: np.ndarray) -> np.ndarray: - self._check_fitted() + """ + Perform classification on samples in X. + + Args: + X (np.ndarray): Input features. For a callable kernel (an instance of + :class:`~qiskit_machine_learning.kernels.BaseKernel`), the shape + should be ``(m_samples, n_features)``. For a pre-computed kernel, the shape should be + ``(m_samples, n_samples)``. Here, ``m_*`` denotes the set to be + predicted, and ``n_*`` denotes the size of the training set. + In the case of a pre-computed kernel, the kernel values in ``X`` must be calculated + with respect to the elements of the set to be predicted and the training set. + + Returns: + np.ndarray: An array of shape ``(n_samples,)``, representing the predicted class labels for + each sample in ``X``. + Raises: + QiskitMachineLearningError: + - If the :meth:`predict` method is called before the model has been fit. + ValueError: + - If the pre-computed kernel matrix has the wrong shape and/or dimension. + """ + self._check_fitted() X, _ = self._validate_input(X) if self._neural_network.output_shape == (1,): - predict = np.sign(self._neural_network.forward(X, self._fit_result.x)) + # Binary classification + raw_output = self._neural_network.forward(X, self._fit_result.x) + predict = np.sign(raw_output) else: + # Multi-class classification forward = self._neural_network.forward(X, self._fit_result.x) predict_ = np.argmax(forward, axis=1) + if self._one_hot: + # Convert class indices to one-hot encoded format predict = np.zeros(forward.shape) for i, v in enumerate(predict_): predict[i, v] = 1 else: predict = predict_ + return self._validate_output(predict) + def predict_proba(self, X: np.ndarray) -> np.ndarray: + """ + Extracts the predicted probabilities for each class based on the output of a neural + network. + + Args: + X (np.ndarray): Input features. For a callable kernel (an instance of + :class:`~qiskit_machine_learning.kernels.BaseKernel`), the shape + should be ``(m_samples, n_features)``. For a pre-computed kernel, the shape should be + ``(m_samples, n_samples)``. Here, ``m_*`` denotes the set to be + predicted, and ``n_*`` denotes the size of the training set. In the case of a + pre-computed kernel, the kernel values in ``X`` must be calculated with respect to + the elements of the set to be predicted and the training set. + + Returns: + np.ndarray: An array of shape ``(n_samples, n_classes)`` representing the predicted class + probabilities (in the range :math:`[0, 1]`) for each sample in ``X``. + """ + self._check_fitted() + X, _ = self._validate_input(X) + + # Assumes an activation function is applied within the forward method + proba = self._neural_network.forward(X, self._fit_result.x) + + return proba + def score(self, X: np.ndarray, y: np.ndarray, sample_weight: np.ndarray | None = None) -> float: return ClassifierMixin.score(self, X, y, sample_weight) diff --git a/qiskit_machine_learning/algorithms/classifiers/pegasos_qsvc.py b/qiskit_machine_learning/algorithms/classifiers/pegasos_qsvc.py index 1b007078f..795fda8be 100644 --- a/qiskit_machine_learning/algorithms/classifiers/pegasos_qsvc.py +++ b/qiskit_machine_learning/algorithms/classifiers/pegasos_qsvc.py @@ -16,6 +16,7 @@ import logging from datetime import datetime from typing import Dict +import warnings import numpy as np from sklearn.base import ClassifierMixin @@ -23,6 +24,7 @@ from ...algorithms.serializable_model import SerializableModelMixin from ...exceptions import QiskitMachineLearningError from ...kernels import BaseKernel, FidelityQuantumKernel +from ...exceptions import QiskitMachineLearningWarning from ...utils import algorithm_globals @@ -97,6 +99,8 @@ def __init__( raise ValueError("'quantum_kernel' has to be None to use a precomputed kernel") else: if quantum_kernel is None: + msg = "No quantum kernel is provided, SamplerV1 based quantum kernel will be used." + warnings.warn(msg, QiskitMachineLearningWarning, stacklevel=2) quantum_kernel = FidelityQuantumKernel() self._quantum_kernel = quantum_kernel @@ -199,7 +203,7 @@ def fit( self.fit_status_ = PegasosQSVC.FITTED - logger.debug("fit completed after %s", str(datetime.now() - t_0)[:-7]) + logger.debug("Fit completed after %s", str(datetime.now() - t_0)[:-7]) return self @@ -209,33 +213,62 @@ def predict(self, X: np.ndarray) -> np.ndarray: Perform classification on samples in X. Args: - X: Features. For a callable kernel (an instance of - :class:`~qiskit_machine_learning.kernels.BaseKernel`) the shape - should be ``(m_samples, n_features)``, for a precomputed kernel the shape should be - ``(m_samples, n_samples)``. Where ``m`` denotes the set to be predicted and ``n`` the - size of the training set. In that case, the kernel values in X have to be calculated - with respect to the elements of the set to be predicted and the training set. + X (np.ndarray): Input features. For a callable kernel (an instance of + :class:`~qiskit_machine_learning.kernels.BaseKernel`), the shape + should be ``(m_samples, n_features)``. For a pre-computed kernel, the shape should be + ``(m_samples, n_samples)``. Here, ``m_*`` denotes the set to be + predicted, and ``n_*`` denotes the size of the training set. In the case of a + pre-computed kernel, the kernel values in ``X`` must be calculated with respect to + the elements of the set to be predicted and the training set. Returns: - An array of the shape (n_samples), the predicted class labels for samples in X. + np.ndarray: An array of shape ``(n_samples,)``, representing the predicted class labels for + each sample in ``X``. Raises: QiskitMachineLearningError: - - predict is called before the model has been fit. + - If the :meth:`predict` method is called before the model has been fit. ValueError: - - Pre-computed kernel matrix has the wrong shape and/or dimension. + - If the pre-computed kernel matrix has the wrong shape and/or dimension. """ t_0 = datetime.now() values = self.decision_function(X) y = np.array([self._label_pos if val > 0 else self._label_neg for val in values]) - logger.debug("prediction completed after %s", str(datetime.now() - t_0)[:-7]) + logger.debug("Prediction completed after %s", str(datetime.now() - t_0)[:-7]) return y + def predict_proba(self, X: np.ndarray) -> np.ndarray: + """ + Extract class prediction probabilities. The decision function values are + not bounded in the range :math:`[0, 1]`. Therefore, these values are + converted into probabilities using the sigmoid activation + function, which maps the real-valued outputs to the :math:`[0, 1]` range. + + Args: + X (np.ndarray): Input features. For a callable kernel (an instance of + :class:`~qiskit_machine_learning.kernels.BaseKernel`), the shape + should be ``(m_samples, n_features)``. For a pre-computed kernel, the shape should be + ``(m_samples, n_samples)``. Here, ``m_*`` denotes the set to be + predicted, and ``n_*`` denotes the size of the training set. In the case of a + pre-computed kernel, the kernel values in ``X`` must be calculated with respect to + the elements of the set to be predicted and the training set. + + Returns: + np.ndarray: An array of shape ``(n_samples, 2)``, representing the predicted class + probabilities (in the range :math:`[0, 1]`) for each sample in ``X``. + """ + values = self.decision_function(X) + + probabilities = 1 / (1 + np.exp(-values)) # Sigmoid activation function + probabilities = np.dstack((1 - probabilities, probabilities))[0] + + return probabilities + def decision_function(self, X: np.ndarray) -> np.ndarray: """ - Evaluate the decision function for the samples in X. + Evaluate the decision function for the samples in ``X``. Args: X: Features. For a callable kernel (an instance of @@ -255,7 +288,7 @@ def decision_function(self, X: np.ndarray) -> np.ndarray: - Pre-computed kernel matrix has the wrong shape and/or dimension. """ if self.fit_status_ == PegasosQSVC.UNFITTED: - raise QiskitMachineLearningError("The PegasosQSVC has to be fit first") + raise QiskitMachineLearningError("The PegasosQSVC has to be fit first.") if np.ndim(X) != 2: raise ValueError("X has to be a 2D array") if self._precomputed and self._n_samples != X.shape[1]: diff --git a/qiskit_machine_learning/algorithms/classifiers/qsvc.py b/qiskit_machine_learning/algorithms/classifiers/qsvc.py index a67cfafd0..292316965 100644 --- a/qiskit_machine_learning/algorithms/classifiers/qsvc.py +++ b/qiskit_machine_learning/algorithms/classifiers/qsvc.py @@ -60,7 +60,9 @@ def __init__(self, *, quantum_kernel: Optional[BaseKernel] = None, **kwargs): warnings.warn(msg, QiskitMachineLearningWarning, stacklevel=2) # if we don't delete, then this value clashes with our quantum kernel del kwargs["kernel"] - + if quantum_kernel is None: + msg = "No quantum kernel is provided, SamplerV1 based quantum kernel will be used." + warnings.warn(msg, QiskitMachineLearningWarning, stacklevel=2) self._quantum_kernel = quantum_kernel if quantum_kernel else FidelityQuantumKernel() if "random_state" not in kwargs: diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py index 7b1926a70..caffee3b4 100644 --- a/qiskit_machine_learning/algorithms/classifiers/vqc.py +++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py @@ -18,6 +18,7 @@ from qiskit import QuantumCircuit from qiskit.primitives import BaseSampler +from qiskit.transpiler.passmanager import BasePassManager from ...neural_networks import SamplerQNN from ...optimizers import Optimizer, OptimizerResult, Minimizer @@ -41,7 +42,8 @@ class VQC(NeuralNetworkClassifier): string labels. One hot encoded labels are also supported. Internally, labels are transformed to one hot encoding and the classifier is always trained on one hot labels. - Multi-label classification is not supported. E.g., :math:`[[1, 1, 0], [0, 1, 1], [1, 0, 1]]`. + Multi-label classification is partially supported. Please refer to `output_shape` and + `interpret` arguments. E.g., :math:`[[1, 1, 0], [0, 1, 1], [1, 0, 1]]`. """ # pylint: disable=too-many-positional-arguments @@ -57,6 +59,9 @@ def __init__( callback: Callable[[np.ndarray, float], None] | None = None, *, sampler: BaseSampler | None = None, + interpret: Callable[[int], int | tuple[int, ...]] | None = None, + output_shape: int | None = None, + pass_manager: BasePassManager | None = None, ) -> None: """ Args: @@ -88,6 +93,14 @@ def __init__( sampler: an optional Sampler primitive instance to be used by the underlying :class:`~qiskit_machine_learning.neural_networks.SamplerQNN` neural network. If ``None`` is passed then an instance of the reference Sampler will be used. + pass_manager: The pass manager to transpile the circuits, if necessary. + Defaults to ``None``, as some primitives do not need transpiled circuits. + 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 a basic parity function will be + used by underlying neural network. + output_shape: The output shape for the underlying neural network, generally equals to + number of classes. Defaults to binary classification, 2. 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 @@ -98,6 +111,15 @@ def __init__( num_qubits, feature_map, ansatz ) + if output_shape is None: + self.output_shape = 2 + self.interpret = self._get_interpret(self.output_shape) + else: + self.output_shape = output_shape + if interpret is None: + self.interpret = self._get_interpret(output_shape) + else: + self.interpret = interpret # construct circuit self._feature_map = feature_map self._ansatz = ansatz @@ -106,14 +128,19 @@ def __init__( self._circuit.compose(self.feature_map, inplace=True) self._circuit.compose(self.ansatz, inplace=True) + if pass_manager: + self._circuit.measure_all() + self._circuit = pass_manager.run(self._circuit) + 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, + interpret=self.interpret, + output_shape=self.output_shape, input_gradients=False, + pass_manager=pass_manager, ) super().__init__( @@ -162,7 +189,7 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult: # 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) + self._neural_network.set_interpret(self.interpret, num_classes) function = self._create_objective(X, y) return self._minimize(function) diff --git a/qiskit_machine_learning/algorithms/inference/qbayesian.py b/qiskit_machine_learning/algorithms/inference/qbayesian.py index 2d3736eac..425f76b5a 100644 --- a/qiskit_machine_learning/algorithms/inference/qbayesian.py +++ b/qiskit_machine_learning/algorithms/inference/qbayesian.py @@ -22,8 +22,7 @@ from qiskit.circuit.library import GroverOperator from qiskit.primitives import BaseSampler, Sampler, BaseSamplerV2, BaseSamplerV1 from qiskit.transpiler.passmanager import BasePassManager -from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager -from qiskit.providers.fake_provider import GenericBackendV2 +from qiskit.result import QuasiDistribution from ...utils.deprecation import issue_deprecation_msg @@ -109,9 +108,14 @@ def __init__( self._sampler = sampler - if pass_manager is None: - _backend = GenericBackendV2(num_qubits=max(circuit.num_qubits, 2)) - pass_manager = generate_preset_pass_manager(optimization_level=1, backend=_backend) + if hasattr(circuit.layout, "_input_qubit_count"): + self.num_virtual_qubits = circuit.layout._input_qubit_count + else: + if pass_manager is None: + self.num_virtual_qubits = circuit.num_qubits + else: + circuit = pass_manager.run(circuit) + self.num_virtual_qubits = circuit.layout._input_qubit_count self._pass_manager = pass_manager # Label of register mapped to its qubit @@ -172,20 +176,23 @@ def _run_circuit(self, circuit: QuantumCircuit) -> Dict[str, float]: counts = result.quasi_dists[0].nearest_probability_distribution().binary_probabilities() elif isinstance(self._sampler, BaseSamplerV2): - # Sample from circuit - circuit_isa = self._pass_manager.run(circuit) - job = self._sampler.run([circuit_isa]) + if self._pass_manager is not None: + circuit = self._pass_manager.run(circuit) + job = self._sampler.run([circuit]) result = job.result() bit_array = list(result[0].data.values())[0] bitstring_counts = bit_array.get_counts() # Normalize the counts to probabilities - total_shots = result[0].metadata["shots"] - counts = {k: v / total_shots for k, v in bitstring_counts.items()} - + total_shots = sum(bitstring_counts.values()) + probabilities = {k: v / total_shots for k, v in bitstring_counts.items()} # Convert to quasi-probabilities + quasi_dist = QuasiDistribution(probabilities) + binary_prob = quasi_dist.nearest_probability_distribution().binary_probabilities() + counts = {k: v for k, v in binary_prob.items() if int(k) < 2**self.num_virtual_qubits} + # counts = QuasiDistribution(probabilities) # counts = {k: v for k, v in counts.items()} diff --git a/qiskit_machine_learning/algorithms/regressors/qsvr.py b/qiskit_machine_learning/algorithms/regressors/qsvr.py index eb059a149..c335cda59 100644 --- a/qiskit_machine_learning/algorithms/regressors/qsvr.py +++ b/qiskit_machine_learning/algorithms/regressors/qsvr.py @@ -57,7 +57,9 @@ def __init__(self, *, quantum_kernel: Optional[BaseKernel] = None, **kwargs): warnings.warn(msg, QiskitMachineLearningWarning, stacklevel=2) # if we don't delete, then this value clashes with our quantum kernel del kwargs["kernel"] - + if quantum_kernel is None: + msg = "No quantum kernel is provided, SamplerV1 based quantum kernel will be used." + warnings.warn(msg, QiskitMachineLearningWarning, stacklevel=2) self._quantum_kernel = quantum_kernel if quantum_kernel else FidelityQuantumKernel() super().__init__(kernel=self._quantum_kernel.evaluate, **kwargs) diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py index 3ece2ca2f..1057223b1 100644 --- a/qiskit_machine_learning/algorithms/regressors/vqr.py +++ b/qiskit_machine_learning/algorithms/regressors/vqr.py @@ -18,6 +18,7 @@ from qiskit import QuantumCircuit from qiskit.primitives import BaseEstimator from qiskit.quantum_info.operators.base_operator import BaseOperator +from qiskit.transpiler.passmanager import BasePassManager from .neural_network_regressor import NeuralNetworkRegressor from ...neural_networks import EstimatorQNN @@ -43,6 +44,7 @@ def __init__( callback: Callable[[np.ndarray, float], None] | None = None, *, estimator: BaseEstimator | None = None, + pass_manager: BasePassManager | None = None, ) -> None: r""" Args: @@ -75,6 +77,8 @@ def __init__( estimator: an optional Estimator primitive instance to be used by the underlying :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN` neural network. If ``None`` is passed then an instance of the reference Estimator will be used. + pass_manager: The pass manager to transpile the circuits, if necessary. + Defaults to ``None``, as some primitives do not need transpiled circuits. 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 @@ -103,12 +107,20 @@ def __init__( observables = [observable] if observable is not None else None + if pass_manager: + circuit.measure_all() + circuit = pass_manager.run(circuit) + observables = ( + [observable.apply_layout(circuit.layout)] if observable is not None else None + ) + neural_network = EstimatorQNN( estimator=estimator, circuit=circuit, observables=observables, input_params=feature_map.parameters, weight_params=ansatz.parameters, + pass_manager=pass_manager, ) super().__init__( diff --git a/qiskit_machine_learning/algorithms/trainable_model.py b/qiskit_machine_learning/algorithms/trainable_model.py index 31af78056..108dcdecd 100644 --- a/qiskit_machine_learning/algorithms/trainable_model.py +++ b/qiskit_machine_learning/algorithms/trainable_model.py @@ -32,7 +32,7 @@ class TrainableModel(SerializableModelMixin): - """Base class for ML model that defines a scikit-learn like interface for Estimators.""" + """Base class for ML model that defines a scikit-learn-like interface for `Estimator` instances.""" # pylint: disable=too-many-positional-arguments def __init__( @@ -46,10 +46,10 @@ def __init__( ): """ Args: - neural_network: An instance of an quantum neural network. If the neural network has a + neural_network: An instance of a quantum neural network. If the neural network has a one-dimensional output, i.e., `neural_network.output_shape=(1,)`, then it is expected to return values in [-1, +1] and it can only be used for binary - classification. If the output is multi-dimensional, it is assumed that the result + classification. If the output is multidimensional, it is assumed that the result is a probability distribution, i.e., that the entries are non-negative and sum up to one. Then there are two options, either one-hot encoding or not. In case of one-hot encoding, each probability vector resulting a neural network is considered diff --git a/qiskit_machine_learning/circuit/library/__init__.py b/qiskit_machine_learning/circuit/library/__init__.py index 4ddaf09e0..a1e317c2e 100644 --- a/qiskit_machine_learning/circuit/library/__init__.py +++ b/qiskit_machine_learning/circuit/library/__init__.py @@ -1,6 +1,6 @@ # This code is part of a Qiskit project. # -# (C) Copyright IBM 2020, 2023. +# (C) Copyright IBM 2020, 2024. # # 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 @@ -19,7 +19,7 @@ .. currentmodule:: qiskit_machine_learning.circuit.library -Feature Maps +Feature maps ------------ .. autosummary:: @@ -29,7 +29,7 @@ RawFeatureVector -Helper Circuits +Helper circuits --------------- .. autosummary:: diff --git a/qiskit_machine_learning/connectors/__init__.py b/qiskit_machine_learning/connectors/__init__.py index 84f539f30..a0fed7b40 100644 --- a/qiskit_machine_learning/connectors/__init__.py +++ b/qiskit_machine_learning/connectors/__init__.py @@ -1,6 +1,6 @@ # This code is part of a Qiskit project. # -# (C) Copyright IBM 2021, 2023. +# (C) Copyright IBM 2021, 2024. # # 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 @@ -14,7 +14,7 @@ Connectors (:mod:`qiskit_machine_learning.connectors`) ====================================================== -Connectors from Qiskit Machine Learning to other frameworks. +"Connector" tools to couple Qiskit Machine Learning to other frameworks. .. currentmodule:: qiskit_machine_learning.connectors diff --git a/qiskit_machine_learning/datasets/__init__.py b/qiskit_machine_learning/datasets/__init__.py index e4d4f1711..2e198db3f 100644 --- a/qiskit_machine_learning/datasets/__init__.py +++ b/qiskit_machine_learning/datasets/__init__.py @@ -1,6 +1,6 @@ # This code is part of a Qiskit project. # -# (C) Copyright IBM 2019, 2023. +# (C) Copyright IBM 2019, 2024. # # 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 @@ -14,7 +14,7 @@ Datasets (:mod:`qiskit_machine_learning.datasets`) ================================================== -A set of sample datasets suitable for machine learning problems +A set of sample datasets to test machine learning algorithms. .. currentmodule:: qiskit_machine_learning.datasets diff --git a/qiskit_machine_learning/gradients/__init__.py b/qiskit_machine_learning/gradients/__init__.py index dcc426ae3..55ea51b38 100644 --- a/qiskit_machine_learning/gradients/__init__.py +++ b/qiskit_machine_learning/gradients/__init__.py @@ -10,10 +10,11 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -""" +r""" Gradients (:mod:`qiskit_machine_learning.gradients`) -============================================== -Algorithms to calculate the gradient of a quantum circuit. +==================================================== + +Algorithms to calculate the gradient of a cost landscape to optimize a given objective function. .. currentmodule:: qiskit_machine_learning.gradients @@ -29,7 +30,7 @@ EstimatorGradientResult SamplerGradientResult -Linear Combination of Unitaries +Linear combination of unitaries ------------------------------- .. autosummary:: @@ -39,7 +40,7 @@ LinCombEstimatorGradient LinCombSamplerGradient -Parameter Shift Rules +Parameter-shift rules --------------------- .. autosummary:: diff --git a/qiskit_machine_learning/gradients/lin_comb/lin_comb_sampler_gradient.py b/qiskit_machine_learning/gradients/lin_comb/lin_comb_sampler_gradient.py index 96e4a65d5..27fa978a8 100644 --- a/qiskit_machine_learning/gradients/lin_comb/lin_comb_sampler_gradient.py +++ b/qiskit_machine_learning/gradients/lin_comb/lin_comb_sampler_gradient.py @@ -165,7 +165,11 @@ def _run_unique( elif isinstance(self._sampler, BaseSamplerV2): result = [] for x in range(partial_sum_n, partial_sum_n + n): - bitstring_counts = results[x].data.meas.get_counts() + if hasattr(results[x].data, "meas"): + bitstring_counts = results[x].data.meas.get_counts() + else: + # Fallback to 'c' if 'meas' is not available. + bitstring_counts = results[x].data.c.get_counts() # Normalize the counts to probabilities total_shots = sum(bitstring_counts.values()) diff --git a/qiskit_machine_learning/gradients/param_shift/param_shift_sampler_gradient.py b/qiskit_machine_learning/gradients/param_shift/param_shift_sampler_gradient.py index 89efe6ec8..d3a5a46a2 100644 --- a/qiskit_machine_learning/gradients/param_shift/param_shift_sampler_gradient.py +++ b/qiskit_machine_learning/gradients/param_shift/param_shift_sampler_gradient.py @@ -132,8 +132,11 @@ def _run_unique( elif isinstance(self._sampler, BaseSamplerV2): result = [] for i in range(partial_sum_n, partial_sum_n + n): - bitstring_counts = results[i].data.meas.get_counts() - + if hasattr(results[i].data, "meas"): + bitstring_counts = results[i].data.meas.get_counts() + else: + # Fallback to 'c' if 'meas' is not available. + bitstring_counts = results[i].data.c.get_counts() # Normalize the counts to probabilities total_shots = sum(bitstring_counts.values()) probabilities = {k: v / total_shots for k, v in bitstring_counts.items()} diff --git a/qiskit_machine_learning/gradients/spsa/spsa_sampler_gradient.py b/qiskit_machine_learning/gradients/spsa/spsa_sampler_gradient.py index 922e3d68c..574cab9ea 100644 --- a/qiskit_machine_learning/gradients/spsa/spsa_sampler_gradient.py +++ b/qiskit_machine_learning/gradients/spsa/spsa_sampler_gradient.py @@ -143,7 +143,11 @@ def _run( elif isinstance(self._sampler, BaseSamplerV2): _result = [] for m in range(partial_sum_n, partial_sum_n + n): - _bitstring_counts = results[m].data.meas.get_counts() + if hasattr(results[i].data, "meas"): + _bitstring_counts = results[m].data.meas.get_counts() + else: + # Fallback to 'c' if 'meas' is not available. + _bitstring_counts = results[m].data.c.get_counts() # Normalize the counts to probabilities _total_shots = sum(_bitstring_counts.values()) _probabilities = {k: v / _total_shots for k, v in _bitstring_counts.items()} diff --git a/qiskit_machine_learning/neural_networks/__init__.py b/qiskit_machine_learning/neural_networks/__init__.py index 288a49162..5e0885c29 100644 --- a/qiskit_machine_learning/neural_networks/__init__.py +++ b/qiskit_machine_learning/neural_networks/__init__.py @@ -1,6 +1,6 @@ # This code is part of a Qiskit project. # -# (C) Copyright IBM 2019, 2023. +# (C) Copyright IBM 2019, 2024. # # 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 @@ -36,7 +36,7 @@ NeuralNetwork -Neural Networks +Neural networks --------------- .. autosummary:: @@ -46,8 +46,8 @@ EstimatorQNN SamplerQNN -Neural Network Metrics ----------------------- +Metrics for neural networks +--------------------------- .. autosummary:: :toctree: ../stubs/ diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py index ca0da35cc..96696a07c 100644 --- a/qiskit_machine_learning/neural_networks/estimator_qnn.py +++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py @@ -120,16 +120,25 @@ def __init__( ): r""" Args: - estimator: The estimator used to compute neural network's results. - If ``None``, a default instance of the reference estimator, - :class:`~qiskit.primitives.Estimator`, will be used. circuit: The quantum circuit to represent the neural network. If a :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is passed, the - `input_params` and `weight_params` do not have to be provided, because these two + ``input_params`` and ``weight_params`` do not have to be provided, because these two properties are taken from the :class:`~qiskit_machine_learning.circuit.library.QNNCircuit`. + estimator: The estimator used to compute neural network's results. + If ``None``, a default instance of the reference estimator, + :class:`~qiskit.primitives.Estimator`, will be used. + + .. warning:: + + The assignment ``estimator=None`` defaults to using + :class:`~qiskit.primitives.Estimator`, which points to a deprecated estimator V1 + (as of Qiskit 1.2). ``EstimatorQNN`` will adopt Estimator V2 as default no later than + Qiskit Machine Learning 0.9. + observables: The observables for outputs of the neural network. If ``None``, - use the default :math:`Z^{\otimes num\_qubits}` observable. + use the default :math:`Z^{\otimes n}` observable, where :math:`n` + is the number of qubits. 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 a :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is provided the @@ -139,9 +148,10 @@ def __init__( If ``None``, the weights are not bound to any parameters. If a :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is provided the `weight_params` value here is ignored. Instead, the value is taken from the - :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` weight_parameters. + `weight_parameters` associated with + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit`. gradient: The estimator gradient to be used for the backward pass. - If None, a default instance of the estimator gradient, + If ``None``, a default instance of the estimator gradient, :class:`~qiskit_machine_learning.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 @@ -200,10 +210,11 @@ def __init__( if isinstance(estimator, BaseEstimatorV1): gradient = ParamShiftEstimatorGradient(estimator=self.estimator) else: - logger.warning( - "No gradient function provided, creating a gradient function." - " If your Estimator requires transpilation, please provide a pass manager." - ) + if pass_manager is None: + logger.warning( + "No gradient function provided, creating a gradient function." + " If your Estimator requires transpilation, please provide a pass manager." + ) gradient = ParamShiftEstimatorGradient( estimator=self.estimator, pass_manager=pass_manager ) diff --git a/qiskit_machine_learning/neural_networks/sampler_qnn.py b/qiskit_machine_learning/neural_networks/sampler_qnn.py index 0596d6030..b6a1eb911 100644 --- a/qiskit_machine_learning/neural_networks/sampler_qnn.py +++ b/qiskit_machine_learning/neural_networks/sampler_qnn.py @@ -143,39 +143,52 @@ def __init__( input_gradients: bool = False, pass_manager: BasePassManager | None = None, ): - """ - 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. If a - :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is passed, - the `input_params` and `weight_params` do not have to be provided, because these two - properties are taken from the :class:`~qiskit_machine_learning.circuit.library.QNNCircuit - `. input_params: The parameters of the circuit corresponding to the input. If a - :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is provided the - `input_params` value here is ignored. Instead, the value is taken from the - :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` input_parameters. - weight_params: The parameters of the circuit corresponding to the trainable weights. If a - :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is provided the - `weight_params` value here is ignored. Instead, the value is taken from the - :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` weight_parameters. 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 passed, - then an identity function will be used by this neural network. output_shape: The output - shape of the custom interpretation. For SamplerV1, it is ignored if no custom interpret - method is provided where the shape is taken to be ``2^circuit.num_qubits``. gradient: An - optional sampler gradient to be used for the backward pass. If ``None`` is given, - a default instance of - :class:`~qiskit_machine_learning.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 - :class:`~qiskit_machine_learning.connectors.TorchConnector`. - pass_manager: The pass manager to transpile the circuits, if necessary. - Defaults to ``None``, as some primitives do not need transpiled circuits. + r""" + Args: + circuit: The parametrized quantum + circuit that generates the samples of this network. If a + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is passed, + the `input_params` and `weight_params` do not have to be provided, because these two + properties are taken from the + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit`. + 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. + + .. warning:: + + The assignment ``sampler=None`` defaults to using + :class:`~qiskit.primitives.Sampler`, which points to a deprecated Sampler V1 + (as of Qiskit 1.2). ``SamplerQNN`` will adopt Sampler V2 as default no later than + Qiskit Machine Learning 0.9. + + input_params: The parameters of the circuit corresponding to the input. If a + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is provided the + `input_params` value here is ignored. Instead, the value is taken from the + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` input_parameters. + weight_params: The parameters of the circuit corresponding to the trainable weights. If a + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` is provided the + `weight_params` value here is ignored. Instead, the value is taken from the + :class:`~qiskit_machine_learning.circuit.library.QNNCircuit` ``weight_parameters``. + 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 passed, then an identity function will be + used by this neural network. + output_shape: The output shape of the custom interpretation. For SamplerV1, it is ignored + if no custom interpret method is provided where the shape is taken to be + ``2^circuit.num_qubits``. + gradient: An optional sampler gradient to be used for the backward pass. If ``None`` is + given, a default instance of + :class:`~qiskit_machine_learning.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 + :class:`~qiskit_machine_learning.connectors.TorchConnector`. + pass_manager: The pass manager to transpile the circuits, if necessary. + Defaults to ``None``, as some primitives do not need transpiled circuits. Raises: - QiskitMachineLearningError: Invalid parameter values. + QiskitMachineLearningError: Invalid parameter values. """ # set primitive, provide default if sampler is None: @@ -216,10 +229,11 @@ def __init__( if isinstance(sampler, BaseSamplerV1): gradient = ParamShiftSamplerGradient(sampler=self.sampler) else: - logger.warning( - "No gradient function provided, creating a gradient function." - " If your Sampler requires transpilation, please provide a pass manager." - ) + if pass_manager is None: + logger.warning( + "No gradient function provided, creating a gradient function." + " If your Sampler requires transpilation, please provide a pass manager." + ) gradient = ParamShiftSamplerGradient( sampler=self.sampler, pass_manager=pass_manager ) @@ -332,8 +346,11 @@ def _postprocess(self, num_samples: int, result: SamplerResult) -> np.ndarray | counts = result.quasi_dists[i] elif isinstance(self.sampler, BaseSamplerV2): - bitstring_counts = result[i].data.meas.get_counts() - + if hasattr(result[i].data, "meas"): + bitstring_counts = result[i].data.meas.get_counts() + else: + # Fallback to 'c' if 'meas' is not available. + bitstring_counts = result[i].data.c.get_counts() # Normalize the counts to probabilities total_shots = sum(bitstring_counts.values()) probabilities = {k: v / total_shots for k, v in bitstring_counts.items()} diff --git a/qiskit_machine_learning/optimizers/__init__.py b/qiskit_machine_learning/optimizers/__init__.py index 6b3f0309e..65102d931 100644 --- a/qiskit_machine_learning/optimizers/__init__.py +++ b/qiskit_machine_learning/optimizers/__init__.py @@ -10,13 +10,12 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -""" +r""" Optimizers (:mod:`qiskit_machine_learning.optimizers`) -================================================ -Classical Optimizers. +====================================================== -This package contains a variety of classical optimizers and were designed for use by -qiskit_algorithm's quantum variational algorithms, such as :class:`~qiskit_machine_learning.VQE`. +Contains a variety of classical optimizers designed for +Qiskit Algorithm's quantum variational algorithms. Logically, these optimizers can be divided into two categories: `Local Optimizers`_ @@ -29,7 +28,7 @@ .. currentmodule:: qiskit_machine_learning.optimizers -Optimizer Base Classes +Optimizer base classes ---------------------- .. autosummary:: @@ -40,7 +39,7 @@ Optimizer Minimizer -Steppable Optimization +Steppable optimization ---------------------- .. autosummary:: @@ -58,7 +57,7 @@ OptimizerState -Local Optimizers +Local optimizers ---------------- .. autosummary:: @@ -92,7 +91,7 @@ https://github.com/qiskit-community/qiskit-algorithms/issues/84. -Global Optimizers +Global optimizers ----------------- The global optimizers here all use `NLOpt `_ for their core function and can only be used if the optional dependent ``NLOpt`` package is installed. diff --git a/qiskit_machine_learning/optimizers/adam_amsgrad.py b/qiskit_machine_learning/optimizers/adam_amsgrad.py index fe0aeb910..1fc6c9823 100644 --- a/qiskit_machine_learning/optimizers/adam_amsgrad.py +++ b/qiskit_machine_learning/optimizers/adam_amsgrad.py @@ -21,6 +21,8 @@ import numpy as np from .optimizer import Optimizer, OptimizerSupportLevel, OptimizerResult, POINT +CALLBACK = Callable[[int, POINT, float], None] + # pylint: disable=invalid-name @@ -69,6 +71,7 @@ def __init__( eps: float = 1e-10, amsgrad: bool = False, snapshot_dir: str | None = None, + callback: CALLBACK | None = None, ) -> None: """ Args: @@ -83,8 +86,11 @@ def __init__( amsgrad: True to use AMSGRAD, False if not snapshot_dir: If not None save the optimizer's parameter after every step to the given directory + callback: A callback function passed information in each iteration step. + The information is, in this order: current time step, the parameters, the function value. """ super().__init__() + self.callback = callback for k, v in list(locals().items()): if k in self._OPTIONS: self._options[k] = v @@ -233,6 +239,9 @@ def minimize( if self._snapshot_dir is not None: self.save_params(self._snapshot_dir) + if self.callback is not None: + self.callback(self._t, params_new, fun(params_new)) + # check termination if np.linalg.norm(params - params_new) < self._tol: break diff --git a/qiskit_machine_learning/optimizers/optimizer_utils/__init__.py b/qiskit_machine_learning/optimizers/optimizer_utils/__init__.py index fb251fe03..7304b2e3f 100644 --- a/qiskit_machine_learning/optimizers/optimizer_utils/__init__.py +++ b/qiskit_machine_learning/optimizers/optimizer_utils/__init__.py @@ -9,18 +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. -"""Utils for optimizers - -Optimizer Utils (:mod:`qiskit_machine_learning.optimizers.optimizer_utils`) -===================================================================== - -.. autosummary:: - :toctree: ../stubs/ - :nosignatures: - - LearningRate - -""" +""" Supplementary tools for optimizers. """ from .learning_rate import LearningRate diff --git a/qiskit_machine_learning/optimizers/spsa.py b/qiskit_machine_learning/optimizers/spsa.py index 03ed45017..08146ed5d 100644 --- a/qiskit_machine_learning/optimizers/spsa.py +++ b/qiskit_machine_learning/optimizers/spsa.py @@ -40,13 +40,13 @@ class SPSA(Optimizer): """Simultaneous Perturbation Stochastic Approximation (SPSA) optimizer. - SPSA [1] is an gradient descent method for optimizing systems with multiple unknown parameters. + SPSA [1] is a gradient descent method for optimizing systems with multiple unknown parameters. As an optimization method, it is appropriately suited to large-scale population models, adaptive modeling, and simulation optimization. .. seealso:: - Many examples are presented at the `SPSA Web site `__. + Many examples are presented at the `SPSA website `__. The main feature of SPSA is the stochastic gradient approximation, which requires only two measurements of the objective function, regardless of the dimension of the optimization @@ -76,7 +76,7 @@ class SPSA(Optimizer): .. note:: This component has some function that is normally random. If you want to reproduce behavior - then you should set the random number generator seed in the algorithm_globals + then you should set the random number generator seed in the ``algorithm_globals`` (``qiskit_machine_learning.utils.algorithm_globals.random_seed = seed``). @@ -105,15 +105,15 @@ def loss(x): spsa = SPSA(maxiter=300) result = spsa.minimize(loss, x0=initial_point) - To use the Hessian information, i.e. 2-SPSA, you can add `second_order=True` to the - initializer of the `SPSA` class, the rest of the code remains the same. + To use the Hessian information, i.e. 2-SPSA, you can add ``second_order=True`` to the + initializer of the ``SPSA`` class, the rest of the code remains the same. .. code-block:: python two_spsa = SPSA(maxiter=300, second_order=True) result = two_spsa.minimize(loss, x0=initial_point) - The `termination_checker` can be used to implement a custom termination criterion. + The ``termination_checker`` can be used to implement a custom termination criterion. .. code-block:: python @@ -214,23 +214,23 @@ def __init__( second_order: If True, use 2-SPSA instead of SPSA. In 2-SPSA, the Hessian is estimated additionally to the gradient, and the gradient is preconditioned with the inverse of the Hessian to improve convergence. - regularization: To ensure the preconditioner is symmetric and positive definite, the + regularization: To ensure the pre-conditioner is symmetric and positive definite, the identity times a small coefficient is added to it. This generator yields that coefficient. hessian_delay: Start multiplying the gradient with the inverse Hessian only after a certain number of iterations. The Hessian is still evaluated and therefore this argument can be useful to first get a stable average over the last iterations before - using it as preconditioner. + using it as pre-conditioner. lse_solver: The method to solve for the inverse of the Hessian. Per default an exact LSE solver is used, but can e.g. be overwritten by a minimization routine. - initial_hessian: The initial guess for the Hessian. By default the identity matrix + initial_hessian: The initial guess for the Hessian. By default, the identity matrix is used. callback: A callback function passed information in each iteration step. The information is, in this order: the number of function evaluations, the parameters, - the function value, the stepsize, whether the step was accepted. + the function value, the step-size, whether the step was accepted. termination_checker: A callback function executed at the end of each iteration step. The arguments are, in this order: the parameters, the function value, the number - of function evaluations, the stepsize, whether the step was accepted. If the callback + of function evaluations, the step-size, whether the step was accepted. If the callback returns True, the optimization is terminated. To prevent additional evaluations of the objective method, if the objective has not yet been evaluated, the objective is estimated by taking the mean of the objective @@ -238,7 +238,7 @@ def __init__( Raises: - ValueError: If ``learning_rate`` or ``perturbation`` is an array with less elements + ValueError: If ``learning_rate`` or ``perturbation`` is an array with fewer elements than the number of iterations. @@ -255,7 +255,7 @@ def __init__( for attr, name in zip([learning_rate, perturbation], ["learning_rate", "perturbation"]): if isinstance(attr, (list, np.ndarray)): if len(attr) < maxiter: - raise ValueError(f"Length of {name} is smaller than maxiter ({maxiter}).") + raise ValueError(f"Length of {name} is smaller than 'maxiter' ({maxiter}).") self.learning_rate = learning_rate self.perturbation = perturbation @@ -306,7 +306,7 @@ def calibrate( loss: The loss function. initial_point: The initial guess of the iteration. c: The initial perturbation magnitude. - stability_constant: The value of `A`. + stability_constant: The value of :math:`A`. target_magnitude: The target magnitude for the first update step, defaults to :math:`2\pi / 10`. alpha: The exponent of the learning rate power series. @@ -628,10 +628,10 @@ def minimize( if self.termination_checker( self._nfev, x_next, fx_check, np.linalg.norm(update), True ): - logger.info("terminated optimization at {k}/{self.maxiter} iterations") + logger.info("Terminated optimization at %s/%s iterations.", k, self.maxiter) break - logger.info("SPSA: Finished in %s", time() - start) + logger.info("SPSA: Finished in %s.", time() - start) if self.last_avg > 1: x = np.mean(np.asarray(last_steps), axis=0) diff --git a/qiskit_machine_learning/state_fidelities/__init__.py b/qiskit_machine_learning/state_fidelities/__init__.py index 19a49ba5a..c56354795 100644 --- a/qiskit_machine_learning/state_fidelities/__init__.py +++ b/qiskit_machine_learning/state_fidelities/__init__.py @@ -9,14 +9,16 @@ # 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""" State Fidelities (:mod:`qiskit_machine_learning.state_fidelities`) -============================================================ -Algorithms that compute the fidelity of pairs of quantum states. +================================================================== + +Algorithms that compute the fidelity of two given quantum states. .. currentmodule:: qiskit_machine_learning.state_fidelities -State Fidelities +State fidelities ---------------- .. autosummary:: diff --git a/qiskit_machine_learning/state_fidelities/compute_uncompute.py b/qiskit_machine_learning/state_fidelities/compute_uncompute.py index dd96f9731..5cd9ebe81 100644 --- a/qiskit_machine_learning/state_fidelities/compute_uncompute.py +++ b/qiskit_machine_learning/state_fidelities/compute_uncompute.py @@ -187,7 +187,10 @@ def _run( sampler_job = self._sampler.run( [(circuits[i], values[i]) for i in range(len(circuits))], **opts.__dict__ ) - _len_quasi_dist = circuits[0].layout._input_qubit_count + if hasattr(circuits[0].layout, "_input_qubit_count"): + _len_quasi_dist = circuits[0].layout._input_qubit_count + else: + _len_quasi_dist = circuits[0].num_qubits local_opts = opts.__dict__ else: raise QiskitMachineLearningError( diff --git a/releasenotes/notes/add-adam_amsgrad_callback-e8e1374d72688da4.yaml b/releasenotes/notes/add-adam_amsgrad_callback-e8e1374d72688da4.yaml new file mode 100644 index 000000000..2d3a0d91f --- /dev/null +++ b/releasenotes/notes/add-adam_amsgrad_callback-e8e1374d72688da4.yaml @@ -0,0 +1,20 @@ + +features: + - | + The :class:`~qiskit_machine_learning.optimizers.ADAM` class now supports a callback function. + This feature allows users to pass a custom callback function that will be called with + information at each iteration step during the optimization process. + The information passed to the callback includes the current time step, the parameters, + and the function value. The callback function should be of the type + `Callable[[int, Union[float, np.ndarray], float], None]`. + + Example of a callback function: + + .. code-block:: python + + def callback(iteration:int, weights:np.ndarray, loss:float): + ... + acc = calculate_accuracy(weights) + print(acc) + print(loss) + ... diff --git a/releasenotes/notes/feature-V2_support_for_algorithms-1e257b1c7e8c404f.yaml b/releasenotes/notes/feature-V2_support_for_algorithms-1e257b1c7e8c404f.yaml new file mode 100644 index 000000000..c5d19e486 --- /dev/null +++ b/releasenotes/notes/feature-V2_support_for_algorithms-1e257b1c7e8c404f.yaml @@ -0,0 +1,11 @@ + +features: + - | + Extended support for V2 primitives across various quantum machine learning algorithms + including :class:`~qiskit_machine_learning.algorithms.VQC`, + :class:`~qiskit_machine_learning.algorithms.VQR`, + :class:`~qiskit_machine_learning.algorithms.QSVC`, + :class:`~qiskit_machine_learning.algorithms.QSVR`, + and :class:`~qiskit_machine_learning.algorithms.QBayesian`. If no version specification is provided, + these algorithms will default to using V1 primitives as a fallback for this release. + A warning is now issued to inform users of this default behavior. \ No newline at end of file diff --git a/releasenotes/notes/feature-partial_multiclass_support_for_vqc-60baa98528a17a45.yaml b/releasenotes/notes/feature-partial_multiclass_support_for_vqc-60baa98528a17a45.yaml new file mode 100644 index 000000000..f22818782 --- /dev/null +++ b/releasenotes/notes/feature-partial_multiclass_support_for_vqc-60baa98528a17a45.yaml @@ -0,0 +1,6 @@ + +features: + - | + Added partial multi-class support for :class:`~qiskit_machine_learning.algorithms.VQC`. + This feature is now enabled when the `output_shape` parameter is set to `num_classes` + and an `interpret` function is defined, allowing for multi-label classification tasks. diff --git a/releasenotes/notes/feature-predict-proba-function-for-classifiers-a752c5154a7c988f.yaml b/releasenotes/notes/feature-predict-proba-function-for-classifiers-a752c5154a7c988f.yaml new file mode 100644 index 000000000..5ec6e9015 --- /dev/null +++ b/releasenotes/notes/feature-predict-proba-function-for-classifiers-a752c5154a7c988f.yaml @@ -0,0 +1,5 @@ +features: + - | + The :class:`~qiskit_machine_learning.algorithms.PegasosQSVC` and algorithms derived + from :class:`~qiskit_machine_learning.algorithms.NeuralNetworkClassifier` module now support `predict_proba` function. + This method can be utilized similarly to other `scikit-learn`-based algorithms. diff --git a/requirements.txt b/requirements.txt index 6436d0e69..b91fc0c22 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,7 +2,6 @@ qiskit>=1.0 scipy>=1.4 numpy>=1.17 psutil>=5 -scikit-learn>=1.2.0 -fastdtw -setuptools>=40.1.0 +scikit-learn>=1.2 +setuptools>=40.1 dill>=0.3.4 diff --git a/test/algorithms/classifiers/test_neural_network_classifier.py b/test/algorithms/classifiers/test_neural_network_classifier.py index 52fcc8271..69655b301 100644 --- a/test/algorithms/classifiers/test_neural_network_classifier.py +++ b/test/algorithms/classifiers/test_neural_network_classifier.py @@ -160,10 +160,58 @@ def parity(x): return qnn, num_inputs, ansatz.num_parameters def _generate_data(self, num_inputs: int) -> tuple[np.ndarray, np.ndarray]: - # construct data + """ + Generates synthetic data consisting of randomly generated features and binary labels. + Each label is determined based on the sum of the corresponding feature values. If the sum of + the feature values for a sample is less than or equal to 1, the label is 1. Otherwise, the + label is 0. + + Args: + num_inputs (int): The number of features for each sample. + + Returns: + tuple[np.ndarray, np.ndarray]: A tuple containing two numpy arrays: + - features: An array of shape ``(6, num_inputs)`` with randomly generated feature values. + - labels: An array of shape ``(6,)`` with binary labels for each sample. + """ + # Fixed number of samples for consistency + num_samples = 6 + + features = algorithm_globals.random.random((num_samples, num_inputs)) + + # Assign binary labels based on feature sums + labels = (np.sum(features, axis=1) <= 1).astype(float) + + return features, labels + + def _generate_data_multiclass(self, num_inputs: int) -> tuple[np.ndarray, np.ndarray]: + """ + Generates synthetic data consisting of randomly generated features and 3 categorical labels. + Each label is determined based on the sum of the corresponding feature values, assigned + as follows: + - Label 0.0 if the sum of features <= 0.5. + - Label 1.0 if 0.5 < sum of features <= 1.0. + - Label 2.0 if sum of features > 1.0. + + Args: + num_inputs (int): The number of features for each sample. + + Returns: + tuple[np.ndarray, np.ndarray]: A tuple containing two numpy arrays: + - features: An array of shape ``(6, num_inputs)`` with randomly generated feature values. + - labels: An array of shape ``(6,)`` with categorical labels (0, 1, or 2) for each + sample. + """ + # Fixed number of samples for consistency num_samples = 6 + features = algorithm_globals.random.random((num_samples, num_inputs)) - labels = 1.0 * (np.sum(features, axis=1) <= 1) + + # Assign categorical labels based on feature sums + sums = np.sum(features, axis=1) + labels = np.full_like(sums, 2.0) + labels[sums <= 0.5] = 0.0 + labels[(sums > 0.5) & (sums <= 1.0)] = 1.0 return features, labels @@ -247,8 +295,13 @@ def test_classifier_with_sampler_qnn_and_cross_entropy(self, opt): (False, "squared_error"), ) def test_categorical_data(self, config): - """Test categorical labels using QNN""" + """ + Tests categorical labels using the QNN classifier with categorical labels. + Args: + config (tuple): Configuration tuple containing whether to use one-hot + encoding and the loss function. + """ one_hot, loss = config optimizer = L_BFGS_B(maxiter=5) @@ -259,20 +312,29 @@ def test_categorical_data(self, config): features, labels = self._generate_data(num_inputs) labels = labels.astype(str) - # convert to categorical + + # Convert to categorical labels labels[labels == "0.0"] = "A" labels[labels == "1.0"] = "B" - # fit to data + # Fit classifier to the data classifier.fit(features, labels) - # score + # Evaluate the classifier score = classifier.score(features, labels) self.assertGreater(score, 0.5) + # Predict a single sample predict = classifier.predict(features[0, :]) self.assertIn(predict, ["A", "B"]) + # Test predict_proba method + probas = classifier.predict_proba(features) + self.assertEqual(probas.shape, (6, 2)) + + for proba in probas: + self.assertAlmostEqual(np.sum(proba), 1.0, places=5) + @idata(L1L2_ERRORS + ["cross_entropy"]) def test_sparse_arrays(self, loss): """Tests classifier with sparse arrays as features and labels.""" @@ -375,7 +437,7 @@ def test_binary_classification_with_multiclass_data(self): """Test that trying to train a binary classifier with multiclass data raises an error.""" optimizer = L_BFGS_B(maxiter=5) - qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=1) + qnn, _, num_parameters = self._create_sampler_qnn(output_shape=1) classifier = self._create_classifier( qnn, num_parameters, @@ -385,11 +447,10 @@ def test_binary_classification_with_multiclass_data(self): # construct data num_samples = 3 - x = algorithm_globals.random.random((num_samples, num_inputs)) - y = np.asarray([0, 1, 2]) + features, labels = self._generate_data_multiclass(num_samples) with self.assertRaises(QiskitMachineLearningError): - classifier.fit(x, y) + classifier.fit(features, labels) def test_bad_binary_shape(self): """Test that trying to train a binary classifier with misshaped data raises an error.""" @@ -435,6 +496,9 @@ def test_untrained(self): with self.assertRaises(QiskitMachineLearningError, msg="classifier.predict()"): classifier.predict(np.asarray([])) + with self.assertRaises(QiskitMachineLearningError, msg="classifier.predict_proba()"): + classifier.predict_proba(np.asarray([])) + with self.assertRaises(QiskitMachineLearningError, msg="classifier.fit_result"): _ = classifier.fit_result diff --git a/test/algorithms/classifiers/test_pegasos_qsvc.py b/test/algorithms/classifiers/test_pegasos_qsvc.py index a6f888f4d..936ca2901 100644 --- a/test/algorithms/classifiers/test_pegasos_qsvc.py +++ b/test/algorithms/classifiers/test_pegasos_qsvc.py @@ -70,15 +70,34 @@ def setUp(self): self.label_test_4d = label_4d[15:] def test_qsvc(self): - """Test PegasosQSVC""" - qkernel = FidelityQuantumKernel(feature_map=self.feature_map) - - pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau) - - pegasos_qsvc.fit(self.sample_train, self.label_train) - score = pegasos_qsvc.score(self.sample_test, self.label_test) - - self.assertEqual(score, 1.0) + """ + Test the Pegasos QSVC algorithm. + """ + quantum_kernel = FidelityQuantumKernel(feature_map=self.feature_map) + classifier = PegasosQSVC(quantum_kernel=quantum_kernel, C=1000, num_steps=self.tau) + classifier.fit(self.sample_train, self.label_train) + + # Evaluate the model on the test data + test_score = classifier.score(self.sample_test, self.label_test) + self.assertEqual(test_score, 1.0) + + # Expected predictions for the given test data + predicted_labels = classifier.predict(self.sample_test) + self.assertTrue(np.array_equal(predicted_labels, self.label_test)) + + # Test predict_proba method (normalization is imposed by definition) + probas = classifier.predict_proba(self.sample_test) + expected_probas = np.array( + [ + [0.67722117, 0.32277883], + [0.35775209, 0.64224791], + [0.36540916, 0.63459084], + [0.64419096, 0.35580904], + [0.35864466, 0.64135534], + ] + ) + self.assertEqual(probas.shape, (self.label_test.shape[0], 2)) + np.testing.assert_array_almost_equal(probas, expected_probas, decimal=5) def test_decision_function(self): """Test PegasosQSVC.""" diff --git a/test/algorithms/classifiers/test_vqc.py b/test/algorithms/classifiers/test_vqc.py index 15beeb049..dfa5ed88f 100644 --- a/test/algorithms/classifiers/test_vqc.py +++ b/test/algorithms/classifiers/test_vqc.py @@ -29,7 +29,10 @@ from qiskit import QuantumCircuit from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap, ZFeatureMap -from qiskit_machine_learning.optimizers import COBYLA, L_BFGS_B +from qiskit.providers.fake_provider import GenericBackendV2 +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager +from qiskit_ibm_runtime import Session, SamplerV2 +from qiskit_machine_learning.optimizers import COBYLA from qiskit_machine_learning.utils import algorithm_globals from qiskit_machine_learning.algorithms import VQC from qiskit_machine_learning.exceptions import QiskitMachineLearningError @@ -37,9 +40,10 @@ NUM_QUBITS_LIST = [2, None] FEATURE_MAPS = ["zz_feature_map", None] ANSATZES = ["real_amplitudes", None] -OPTIMIZERS = ["cobyla", "bfgs", None] +OPTIMIZERS = ["cobyla", None] DATASETS = ["binary", "multiclass", "no_one_hot"] LOSSES = ["squared_error", "absolute_error", "cross_entropy"] +SAMPLERS = ["samplerv1"] @dataclass(frozen=True) @@ -72,22 +76,32 @@ def setUp(self): super().setUp() algorithm_globals.random_seed = 1111111 self.num_classes_by_batch = [] - + self.backend = GenericBackendV2( + num_qubits=3, + calibrate_instructions=None, + pulse_channels=False, + noise_info=False, + seed=123, + ) + self.session = Session(backend=self.backend) # We want string keys to ensure DDT-generated tests have meaningful names. self.properties = { - "bfgs": L_BFGS_B(maxiter=5), "cobyla": COBYLA(maxiter=25), "real_amplitudes": RealAmplitudes(num_qubits=2, reps=1), "zz_feature_map": ZZFeatureMap(2), "binary": _create_dataset(6, 2), "multiclass": _create_dataset(10, 3), "no_one_hot": _create_dataset(6, 2, one_hot=False), + "samplerv1": None, + "samplerv2": SamplerV2(mode=self.session), } # pylint: disable=too-many-positional-arguments - @idata(itertools.product(NUM_QUBITS_LIST, FEATURE_MAPS, ANSATZES, OPTIMIZERS, DATASETS)) + @idata( + itertools.product(NUM_QUBITS_LIST, FEATURE_MAPS, ANSATZES, OPTIMIZERS, DATASETS, SAMPLERS) + ) @unpack - def test_VQC(self, num_qubits, f_m, ans, opt, d_s): + def test_VQC(self, num_qubits, f_m, ans, opt, d_s, smplr): """ Test VQC with binary and multiclass data using a range of quantum instances, numbers of qubits, feature maps, and optimizers. @@ -101,6 +115,20 @@ def test_VQC(self, num_qubits, f_m, ans, opt, d_s): optimizer = self.properties.get(opt) ansatz = self.properties.get(ans) dataset = self.properties.get(d_s) + sampler = self.properties.get(smplr) + + if smplr == "samplerv2": + pm = generate_preset_pass_manager(optimization_level=0, backend=self.backend) + else: + pm = None + + unique_labels = np.unique(dataset.y, axis=0) + # we want to have labels as a column array, either 1D or 2D(one hot) + # thus, the assert works with plain and one hot labels + unique_labels = unique_labels.reshape(len(unique_labels), -1) + # the predicted value should be in the labels + num_classes = len(unique_labels) + parity_n_classes = lambda x: "{:b}".format(x).count("1") % num_classes initial_point = np.array([0.5] * ansatz.num_parameters) if ansatz is not None else None @@ -110,17 +138,56 @@ def test_VQC(self, num_qubits, f_m, ans, opt, d_s): ansatz=ansatz, optimizer=optimizer, initial_point=initial_point, + output_shape=num_classes, + interpret=parity_n_classes, + sampler=sampler, + pass_manager=pm, ) classifier.fit(dataset.x, dataset.y) score = classifier.score(dataset.x, dataset.y) self.assertGreater(score, 0.5) - predict = classifier.predict(dataset.x[0, :]) + + self.assertTrue(np.all(predict == unique_labels, axis=1).any()) + + def test_VQC_V2(self): + """ + Test VQC with binary and multiclass data using a range of quantum + instances, numbers of qubits, feature maps, and optimizers. + """ + num_qubits = 2 + feature_map = self.properties.get("zz_feature_map") + optimizer = self.properties.get("cobyla") + ansatz = self.properties.get("real_amplitudes") + dataset = self.properties.get("binary") + sampler = self.properties.get("samplerv2") + + pm = generate_preset_pass_manager(optimization_level=0, backend=self.backend) + unique_labels = np.unique(dataset.y, axis=0) # we want to have labels as a column array, either 1D or 2D(one hot) # thus, the assert works with plain and one hot labels unique_labels = unique_labels.reshape(len(unique_labels), -1) # the predicted value should be in the labels + num_classes = len(unique_labels) + parity_n_classes = lambda x: "{:b}".format(x).count("1") % num_classes + + initial_point = np.array([0.5] * ansatz.num_parameters) if ansatz is not None else None + + classifier = VQC( + num_qubits=num_qubits, + feature_map=feature_map, + ansatz=ansatz, + optimizer=optimizer, + initial_point=initial_point, + output_shape=num_classes, + interpret=parity_n_classes, + sampler=sampler, + pass_manager=pm, + ) + classifier.fit(dataset.x, dataset.y) + predict = classifier.predict(dataset.x[0, :]) + self.assertTrue(np.all(predict == unique_labels, axis=1).any()) def test_VQC_non_parameterized(self): diff --git a/test/algorithms/inference/test_qbayesian.py b/test/algorithms/inference/test_qbayesian.py index d0b114b8d..6fc75a2a1 100644 --- a/test/algorithms/inference/test_qbayesian.py +++ b/test/algorithms/inference/test_qbayesian.py @@ -20,6 +20,10 @@ from qiskit import QuantumCircuit from qiskit.circuit import QuantumRegister from qiskit.primitives import Sampler +from qiskit.providers.fake_provider import GenericBackendV2 +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager + +from qiskit_ibm_runtime import Session, SamplerV2 from qiskit_machine_learning.utils import algorithm_globals from qiskit_machine_learning.algorithms import QBayesian @@ -207,6 +211,47 @@ def test_trivial_circuit(self): ) ) + def test_trivial_circuit_V2(self): + """Tests trivial quantum circuit for V2 primitives""" + + backend = GenericBackendV2( + num_qubits=2, + calibrate_instructions=None, + pulse_channels=False, + noise_info=False, + seed=123, + ) + session = Session(backend=backend) + _sampler = SamplerV2(mode=session) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + + # Define rotation angles + theta_a = 2 * np.arcsin(np.sqrt(0.2)) + theta_b_a = 2 * np.arcsin(np.sqrt(0.9)) + theta_b_na = 2 * np.arcsin(np.sqrt(0.3)) + # Define quantum registers + qr_a = QuantumRegister(1, name="A") + qr_b = QuantumRegister(1, name="B") + # Define a 2-qubit quantum circuit + qc = QuantumCircuit(qr_a, qr_b, name="Bayes net small") + qc.ry(theta_a, 0) + qc.cry(theta_b_a, control_qubit=qr_a, target_qubit=qr_b) + qc.x(0) + qc.cry(theta_b_na, control_qubit=qr_a, target_qubit=qr_b) + qc.x(0) + # Inference + self.assertTrue( + np.all( + np.isclose( + 0.1, + QBayesian(circuit=qc, sampler=_sampler, pass_manager=pass_manager).inference( + query={"B": 0}, evidence={"A": 1} + ), + atol=0.04, + ) + ) + ) + if __name__ == "__main__": unittest.main() diff --git a/test/algorithms/regressors/test_vqr.py b/test/algorithms/regressors/test_vqr.py index 67dde8c03..926ecd940 100644 --- a/test/algorithms/regressors/test_vqr.py +++ b/test/algorithms/regressors/test_vqr.py @@ -19,6 +19,10 @@ from qiskit.circuit import Parameter, QuantumCircuit from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes from qiskit.primitives import Estimator +from qiskit.providers.fake_provider import GenericBackendV2 +from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager + +from qiskit_ibm_runtime import Session, EstimatorV2 from qiskit_machine_learning.optimizers import COBYLA, L_BFGS_B from qiskit_machine_learning.utils import algorithm_globals @@ -117,6 +121,71 @@ def test_incorrect_observable(self): with self.assertRaises(ValueError): _ = VQR(num_qubits=2, observable=QuantumCircuit(2)) + @data( + # optimizer, has ansatz + ("cobyla", True), + ("cobyla", False), + ("bfgs", True), + ("bfgs", False), + (None, True), + (None, False), + ) + def test_vqr_v2(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 + + backend = GenericBackendV2( + num_qubits=2, + calibrate_instructions=None, + pulse_channels=False, + noise_info=False, + seed=123, + ) + session = Session(backend=backend) + _estimator = EstimatorV2(mode=session) + pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend) + + 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=_estimator, + pass_manager=pass_manager, + ) + + # 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() diff --git a/test/optimizers/test_adam_amsgrad.py b/test/optimizers/test_adam_amsgrad.py index 060accb34..08f752056 100644 --- a/test/optimizers/test_adam_amsgrad.py +++ b/test/optimizers/test_adam_amsgrad.py @@ -79,6 +79,24 @@ def test_settings(self): self.assertEqual(settings["amsgrad"], False) self.assertEqual(settings["snapshot_dir"], None) + def test_callback(self): + """Test using the callback.""" + + history = {"ite": [], "weights": [], "fvals": []} + + def callback(n_t, weight, fval): + history["ite"].append(n_t) + history["weights"].append(weight) + history["fvals"].append(fval) + + adam = ADAM(maxiter=100, tol=1e-6, lr=1e-1, callback=callback) + adam.minimize(self.quadratic_objective, self.initial_point) + + expected_types = [int, np.ndarray, float] + for i, (key, values) in enumerate(history.items()): + self.assertTrue(all(isinstance(value, expected_types[i]) for value in values)) + self.assertEqual(len(history[key]), 100) + if __name__ == "__main__": unittest.main()