squlearn 0.5.2__tar.gz → 0.7.0__tar.gz

{squlearn-0.5.2 → squlearn-0.7.0}/.gitignore

@@ -122,10 +122,10 @@ celerybeat.pid
 *.sage.py
 
 # Environments
-.env
-.venv
-env/
-venv/
+.env*
+.venv*
+env*/
+venv*/
 ENV/
 env.bak/
 venv.bak/

{squlearn-0.5.2 → squlearn-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: squlearn
-Version: 0.5.2
+Version: 0.7.0
 Summary: A library for quantum machine learning following the scikit-learnstandard.
 Keywords: quantum,machine learning,qml
 Author-email: David Kreplin <david.kreplin@ipa.fraunhofer.de>, Frederic Rapp <frederic.rapp@ipa.fraunhofer.de>, Marco Roth <marco.roth@ipa.fraunhofer.de>, Jan Schnabel <jan.schnabel@ipa.fraunhofer.de>, Moritz Willmann <moritz.willmann@ipa.fraunhofer.de>
@@ -14,8 +14,10 @@ Requires-Dist: dill>=0.3
 Requires-Dist: numpy>=1.17
 Requires-Dist: qiskit>=0.43.0
 Requires-Dist: qiskit-aer>=0.12.0
-Requires-Dist: qiskit-ibm-runtime>=0.9.4
+Requires-Dist: qiskit-algorithms>=0.3.0
+Requires-Dist: qiskit-ibm-runtime>=0.15.1
 Requires-Dist: qiskit-machine-learning>=0.6.1
+Requires-Dist: pennylane>=0.34.0
 Requires-Dist: scipy>=1.5
 Requires-Dist: scikit-learn>=1.0
 Requires-Dist: tqdm>=4.0
@@ -48,7 +50,7 @@ Provides-Extra: examples
 
 sQUlearn is a user-friendly, NISQ-ready Python library for quantum machine learning (QML), designed for seamless integration with classical machine learning tools like scikit-learn. The library's dual-layer architecture serves both QML researchers and practitioners, enabling efficient prototyping, experimentation, and pipelining. sQUlearn provides a comprehensive toolset that includes both quantum kernel methods and quantum neural networks, along with features like customizable data encoding strategies, automated execution handling, and specialized kernel regularization techniques. By focusing on NISQ-compatibility and end-to-end automation, sQUlearn aims to bridge the gap between current quantum computing capabilities and practical machine learning applications.
 
-sQUlearn offers scikit-learn compatible high-level interfaces for various kernel methods and QNNs. They build on top of the low-level interfaces of the QNN engine and the quantum kernel engine. The executor is used to run experiments on simulated and real backends in the Qiskit environment.
+sQUlearn offers scikit-learn compatible high-level interfaces for various kernel methods and QNNs. They build on top of the low-level interfaces of the QNN engine and the quantum kernel engine. The executor is used to run experiments on simulated and real backends of the Qiskit or PennyLane frameworks.
 
 <p align="center">
   <img width=500px alt="sQUlearn schematic" src="https://raw.githubusercontent.com/sQUlearn/squlearn/main/docs/_static/schematic.png" />
@@ -103,4 +105,13 @@ This project is maintained by the quantum computing group at the Fraunhofer Inst
 For general questions regarding sQUlearn, use the [GitHub Discussions](https://github.com/sQUlearn/squlearn/discussions) or feel free to contact [sQUlearn@gmail.com](mailto:sQUlearn@gmail.com).
 
 ---
+## Acknowledgements
 
+This project was supported by the German Federal Ministry
+of Economic Affairs and Climate Action through the
+projects AutoQML (grant no. 01MQ22002A) and AQUAS
+(grant no. 01MQ22003D), as well as the German Federal 
+Ministry of Education and Research through the project
+H2Giga Degrad-EL3 (grant no. 03HY110D).
+
+---

{squlearn-0.5.2 → squlearn-0.7.0}/README.md

@@ -4,7 +4,7 @@
 
 sQUlearn is a user-friendly, NISQ-ready Python library for quantum machine learning (QML), designed for seamless integration with classical machine learning tools like scikit-learn. The library's dual-layer architecture serves both QML researchers and practitioners, enabling efficient prototyping, experimentation, and pipelining. sQUlearn provides a comprehensive toolset that includes both quantum kernel methods and quantum neural networks, along with features like customizable data encoding strategies, automated execution handling, and specialized kernel regularization techniques. By focusing on NISQ-compatibility and end-to-end automation, sQUlearn aims to bridge the gap between current quantum computing capabilities and practical machine learning applications.
 
-sQUlearn offers scikit-learn compatible high-level interfaces for various kernel methods and QNNs. They build on top of the low-level interfaces of the QNN engine and the quantum kernel engine. The executor is used to run experiments on simulated and real backends in the Qiskit environment.
+sQUlearn offers scikit-learn compatible high-level interfaces for various kernel methods and QNNs. They build on top of the low-level interfaces of the QNN engine and the quantum kernel engine. The executor is used to run experiments on simulated and real backends of the Qiskit or PennyLane frameworks.
 
 <p align="center">
   <img width=500px alt="sQUlearn schematic" src="https://raw.githubusercontent.com/sQUlearn/squlearn/main/docs/_static/schematic.png" />
@@ -59,3 +59,13 @@ This project is maintained by the quantum computing group at the Fraunhofer Inst
 For general questions regarding sQUlearn, use the [GitHub Discussions](https://github.com/sQUlearn/squlearn/discussions) or feel free to contact [sQUlearn@gmail.com](mailto:sQUlearn@gmail.com).
 
 ---
+## Acknowledgements
+
+This project was supported by the German Federal Ministry
+of Economic Affairs and Climate Action through the
+projects AutoQML (grant no. 01MQ22002A) and AQUAS
+(grant no. 01MQ22003D), as well as the German Federal 
+Ministry of Education and Research through the project
+H2Giga Degrad-EL3 (grant no. 03HY110D).
+
+---

{squlearn-0.5.2 → squlearn-0.7.0}/docs/modules/classes.rst

@@ -65,6 +65,7 @@ Encoding Circuits
    encoding_circuit.ChebyshevRx
    encoding_circuit.ParamZFeatureMap
    encoding_circuit.QiskitEncodingCircuit
+   encoding_circuit.QCNNEncodingCircuit
 
 Encoding Circuit Tools
 ------------------------------------
@@ -190,8 +191,11 @@ QNN Core
    :toctree: generated/
    :template: class.rst
 
-   qnn.qnn.QNN
-   qnn.qnn.Expec
+   qnn.lowlevel_qnn.LowLevelQNN
+   qnn.lowlevel_qnn_qiskit.LowLevelQNNQiskit
+   qnn.lowlevel_qnn_qiskit.Expec
+   qnn.lowlevel_qnn_pennylane.LowLevelQNNPennyLane
+   qnn.lowlevel_qnn_base.LowLevelQNNBase
    qnn.loss.SquaredLoss
    qnn.loss.VarianceLoss
    qnn.loss.ParameterRegularizationLoss
@@ -249,6 +253,18 @@ OpTree Data Structure
     util.optree.OpTreeContainer
     util.optree.OpTreeValue
 
+PennyLane interface
+------------------------------------
+
+.. currentmodule:: squlearn
+
+.. autosummary::
+   :nosignatures:
+   :toctree: generated/
+   :template: class.rst
+
+   util.pennylane.PennyLaneCircuit
+
 
 Base Classes
 ------------------------------------

{squlearn-0.5.2 → squlearn-0.7.0}/docs/user_guide/encoding_circuits.rst

@@ -210,7 +210,7 @@ where it is employed internally.
 .. jupyter-execute::
 
    from squlearn.encoding_circuit import TranspiledEncodingCircuit,ChebyshevRx
-   from qiskit.providers.fake_provider import FakeManilaV2
+   from qiskit_ibm_runtime.fake_provider import FakeManilaV2
 
    fm = TranspiledEncodingCircuit(ChebyshevRx(3,1),backend=FakeManilaV2(),initial_layout=[0,1,4])
    fm.draw(output="mpl")

{squlearn-0.5.2 → squlearn-0.7.0}/docs/user_guide/executor.rst

@@ -11,13 +11,12 @@ Overview
 
 The :class:`Executor <squlearn.Executor>` class is the central component of sQUlearn, responsible
 for running all quantum jobs.
-Both high- and low-level methods utilize the Executor class to execute circuits or other
+Both high- and low-level methods utilize the Executor class to execute circuits or to run other
 quantum jobs.
-The class provides a high-level interface to the Qiskit simulators and access to IBM
-Quantum systems.
-It features a variety of comfort features, such as automatic session handling, result caching,
-restarts and it automatically creates the necessary Qiskit primitives when they are
-required in the sub-program.
+The class provides a high-level interface to the simulators of PennyLane and Qiskit,
+as well as manages access to real QC hardware as for example IBM Quantum.
+It features a variety of comfort features, such as result caching,
+automatic restarts of failed jobs, logging of all actions, and Qiskit Session handling.
 The Executor class is also responsible for handling the execution environment, and can be
 initialized with a variety of objects that specify the execution environment (see figure below).
 The following figure summarizes the structure of the Executor class; ingoing arrows indicate
@@ -33,13 +32,11 @@ Key Features of the Executor
 
 The Executor class provides the following key comfort features when executing a quantum job:
 
-- **Session handling:** Automatically manages the creation and handling of Qiskit sessions.
-  If Sessions are time out, the Executor automatically creates a new session and re-executes the
-  job.
 - **Result caching:** Enables caching of results to avoid redundant job executions, and enable
-  restarts of failed executions. Caching is enabled as default only for remote executions.
+  restarts of failed executions. Caching is enabled as default for remote executions, but can also
+  be manually activated for local execution.
   The cached files are named after the hash out of different properties of the quantum job,
-  that include the backend name, the circuit, the options of the primitive, etc.
+  that include the backend name, the circuit, the execution options, etc.
   Before running a job, the Executor checks if a cached result exists and returns it if it does.
   The caching can be disabled by setting the ``caching`` argument to ``False``; the folder for
   the cached results can be specified by the ``cache_dir`` argument,
@@ -50,46 +47,99 @@ The Executor class provides the following key comfort features when executing a
   between restarts can be adjusted by the ``wait_restart`` argument.
 - **Logging:** The executor automatically logs all actions to a log file that ca be specified
   via the ``log_file`` argument.
+- **Random Seeds for shot-based simulators:** A random seeds can be specified for the PennyLane
+  and Qiskit shot-based simulators to make the computations utilizing this Executor object
+  reproducible. The random seeds can be set manually by specifying the ``seed`` argument.
 - **Modified Qiskit Primitives:** The Executor allows the creation of modified Qiskit Primitives
-  that function similarly to regular primitives but leverage the comfort features mentioned above.
+  that function exactly as the Qiskit primitives but leverage the comfort features mentioned above.
   The primitives can be obtained utilizing the :meth:`get_estimator` and
   :meth:`get_sampler` methods. The modified primitives route all executions through the Executor
   class, and thus benefit from all comfort features. The primitives are fully compatible with
   the Qiskit framework, and can be used in the same way as regular primitives.
   The Executor primitives are automatically utilized in the sQUlearn
   sub-programs.
+- **Qiskit Session handling:** Automatically manages the creation and handling of Qiskit sessions.
+  If Sessions are time out, the Executor automatically creates a new session and re-executes the
+  job.
 
 Initialization of the Executor class
 ------------------------------------
 
-The Estimator can be initialized with various inputs (``execution=``) that specify the 
+The Estimator can be initialized with various inputs (``execution=``) that specify the
 execution environment:
 
-- A string specifying the simulator backend (e.g., ``"statevector_simulator"`` or
-  ``"qasm_simulator"``).
+- Default initialization with no backend specified: If no backend is specified, the Executor
+  class is initialized utilizing the fast PennyLane simulators.
+  If no shots are specified (``shots=None``) the statevector simulator being utilized,
+  which is the default. If shots are specified, the shot-based simulator is utilized.
 
-  .. code-block:: python
+  .. jupyter-execute::
 
       from squlearn import Executor
-      executor = Executor(execution="statevector_simulator")
+      # Initialize the Executor with the PennyLane statevector simulator
+      # as default, shots=None (statevector simulator)
+      executor = Executor()
+
+      # Initialize the Executor with the PennyLane shot-based simulator
+      executor = Executor(shots=1234)
+
+
+- A string specifying the local simulator backend: Qiskit simulators are available by ``"qiskit"``,
+  ``"statevector_simulator"`` and  ``"qasm_simulator"``; PennyLane simulators can be initialized by
+  ``"pennylane"`` or ``"default.qubit"``.
+
+  .. jupyter-execute::
+
+      from squlearn import Executor
+      # Initialize the Executor with the statevector simulator
+      executor = Executor("statevector_simulator")
+
+      # Initialize the Executor with the qasm simulator
+      executor = Executor("qasm_simulator", shots=1234)
+
+      # Initialize the Executor with qiksit is equivalent to "statevector_simulator"
+      executor = Executor("qiskit")
+
+      # Initialize the Executor with the PennyLane statevector simulator
+      executor = Executor("pennylane")
 
-  The argument ``execution`` is omitted in the following examples since it is not necessary,
-  if the environment is specified as the first argument.
+      # Initialize the Executor with the PennyLane shot-based simulator
+      executor = Executor("default.qubit", shots=1234)
 
 - A backend following the Qiskit backend standard, e.g. a Qiskit Aer backend, a fake backend,
-  a real IBM Quantum backend. This allows in principle the utilization
-  of other quantum computing backends as IBM Quantum, as long as they provide a Qiskit backend
+  a real IBM Quantum backend. This allows also the utilization
+  of other quantum computing backends, as long as they provide a Qiskit backend
   class.
 
+  .. jupyter-execute::
+
+    from squlearn import Executor
+    from qiskit_aer import Aer
+    from qiskit_ibm_runtime.fake_provider import FakeManilaV2
+
+    # Executor with the Aer statevector simulator
+    executor = Executor(Aer.get_backend("aer_simulator"))
+
+    # Executor with the FakeManilaV2 backend
+    executor = Executor(FakeManilaV2())
+
+- A PennyLane device of a quantum computing backend. In the following example, the Executor is
+  initialized with a AWS device. Note that this example requires the PennyLane AWS plugin to be
+  installed (``pip install amazon-braket-pennylane-plugin``) and the AWS credentials to be
+  configured.
+
   .. code-block:: python
 
     from squlearn import Executor
-    from qiskit import Aer
+    import pennylane as qml
+
+    # Initialize the Executor with the PennyLane default.qubit device
+    dev = qml.device("braket.aws.qubit", device_arn="arn:aws:braket:::device/quantum-simulator/amazon/sv1", wires=2)
+    executor = Executor(dev, shots = 1234)
 
-    executor = Executor(Aer.get_backend("qasm_simulator"))
 
 - A backend from the Qiskit Runtime Service, which utilizes the execution of quantum jobs on
-  IBM Quantum utilizing Sessions and Primitives.
+  IBM Quantum. Sessions and Primitives are automatically created and managed by the Executor class.
 
   .. code-block:: python
 
@@ -97,7 +147,7 @@ execution environment:
     from qiskit_ibm_runtime import QiskitRuntimeService
 
     service = QiskitRuntimeService(channel="ibm_quantum", token="INSERT_YOUR_TOKEN_HERE")
-    executor = Executor(service.get_backend('ibm_nairobi'))
+    executor = Executor(service.get_backend('ibm_kyoto'))
 
 - A pre-initialized Session object, which can be used to execute quantum jobs on the Qiskit
   Runtime Service
@@ -108,7 +158,7 @@ execution environment:
     from qiskit_ibm_runtime import QiskitRuntimeService
 
     service = QiskitRuntimeService(channel="ibm_quantum", token="INSERT_YOUR_TOKEN_HERE")
-    session = service.create_session()
+    session = service.create_session(backend = service.get_backend('ibm_kyoto'))
     executor = Executor(session)
 
 - Pre-configured Primitive with options for transpiling and error mitigation. The Executor class
@@ -128,12 +178,13 @@ execution environment:
     options.optimization_level = 0  # No optimization in transpilation
     options.resilience_level = 2  # ZNE
 
-    estimator = Estimator(session=service.create_session(), options_estimator=options)
+    session = service.create_session(backend = service.get_backend('ibm_kyoto'))
+    estimator = Estimator(session=session, options_estimator=options)
     executor = Executor(estimator)
 
 - If only the ``backend.run`` execution is wanted, this can be achieved by utilizing the
-  Qiskit IBM Provider package. However, most sQUlearn algorithms a build upon primitives.
-  However, this access is not recommended, since it is likely to be deprecated in the future.
+  Qiskit IBM Provider package. However, most sQUlearn algorithms a build upon primitives,
+  and therefore, this access is not recommended, since it is likely to be deprecated in the future.
 
   .. code-block:: python
 
@@ -144,8 +195,8 @@ execution environment:
     provider = IBMProvider(instance="hub/group/project")
     executor = Executor(provider.get_backend("ibmq_qasm_simulator"))
 
-An example for configuring the Executor class with a backend from the Qiskit Runtime Service
-and setting options for caching, logging and restarts:
+The following code shows an example for configuring the Executor class with a
+backend from the Qiskit Runtime Service and setting options for caching, logging and restarts:
 
 .. code-block:: python
 
@@ -159,7 +210,7 @@ and setting options for caching, logging and restarts:
     options.optimization_level = 0  # No optimization in transpilation
     options.resilience_level = 2  # ZNE
 
-    estimator = Executor(service.get_backend('ibm_nairobi'), # Specify the backend
+    executor = Executor(service.get_backend('ibm_kyoto'), # Specify the backend
                          cache_dir='cache' # Set cache folder to "cache"
                          caching=True, # Enable caching default for remote executions
                          log_file="executor.log", # Set-up logging file
@@ -168,24 +219,28 @@ and setting options for caching, logging and restarts:
                          options_estimator=options # Set options for the Estimator primitive
                          )
 
+    executor.set_shots(1234) # Shots an be adjusted after initialization
+
 
 Utilizing Executor Primitives in Qiskit Routines
 -------------------------------------------------
 
 The Executor class provides an Estimator and Sampler primitive that are compatible with the
-Qiskit framework. The primitives can be obtained by the :meth:`get_estimator` and
-:meth:`get_sampler` methods of the Executor class. The primitives automatically utilized the parent
-Executor class for all executions, and thus benefit from all comfort features of the Executor.
+Qiskit framework. This is only possible, in case the Executor class is initialized with a backend
+compatible with Qiskit (and not PennyLane). The primitives can be obtained by the
+:meth:`get_estimator` and :meth:`get_sampler` methods of the Executor class.
+The primitives automatically utilized the parent Executor class for all executions,
+and thus benefit from all comfort features of the Executor.
 
 The following example shows, how to evaluate the Quantum Fisher Information utilizing the
-Executor primitive (see `QFI in Qiskit <https://qiskit.org/documentation/stubs/qiskit.algorithms.gradients.QFI.html>`_)
+Executor primitive (see `QFI in Qiskit <https://qiskit-community.github.io/qiskit-algorithms/stubs/qiskit_algorithms.gradients.QFI.html>`_)
 
   .. jupyter-execute::
 
       from squlearn import Executor
-      from qiskit.algorithms.gradients import LinCombQGT, QFI
+      from qiskit_algorithms.gradients import LinCombQGT, QFI
       from qiskit.quantum_info import Pauli
-      # Executor intialization (other ways are possible, see above)
+      # Executor initialization (other ways are possible, see above)
       executor = Executor(execution="statevector_simulator")
       # This creates the QFI primitive that utilizes the Estimator of the Executor class
       qfi = QFI(LinCombQGT(executor.get_estimator()))
@@ -199,8 +254,8 @@ not creating or referring to the Executor primitives! Instead they refer to the
 Qiskit Primitives used internally that do not utilize any caching, restarts, etc.
 
 
-Setting Options for Primitives
-------------------------------
+Setting Options for Qiskit Primitives
+--------------------------------------
 
 Options for the Primitives can be provided through the ``options_estimator`` and
 ``options_sampler`` arguments, but they are also automatically copied from inputted primitives.
@@ -217,7 +272,7 @@ Options for the Primitives can be provided through the ``options_estimator`` and
     options.execution.shots = 5000
     options.resilience_level = 0 # No Mitigation
 
-    executor = Executor(service.get_backend("ibm_nairobi"),options_estimator=options)
+    executor = Executor(service.get_backend("ibm_kyoto"),options_estimator=options)
 
 Options can be adjusted by the :meth:`set_options` method of the Primitives that are created by the
 Executor class.
@@ -229,7 +284,7 @@ Executor class.
 
     service = QiskitRuntimeService(channel="ibm_quantum", token="INSERT_YOUR_TOKEN_HERE")
 
-    executor = Executor(service.get_backend("ibm_nairobi"))
+    executor = Executor(service.get_backend("ibm_kyoto"))
     estimator = executor.get_estimator()
     estimator.set_options(resilience_level=2)
 
@@ -238,3 +293,4 @@ Executor class.
    * :class:`Executor <squlearn.Executor>`
    * `Qiskit Runtime <https://quantum-computing.ibm.com/lab/docs/iql/runtime>`_
    * `Qsikit Primitives <https://qiskit.org/documentation/apidoc/primitives.html>`_
+   * `PennyLane Devices <https://docs.pennylane.ai/en/stable/code/api/pennylane.device.html>`_

{squlearn-0.5.2 → squlearn-0.7.0}/docs/user_guide/kernel_methods.rst

@@ -199,7 +199,7 @@ the following example:
     enc_circ = ChebyshevPQC(num_qubits=4, num_features= 1, num_layers=2)
     pqk_instance = ProjectedQuantumKernel(
         encoding_circuit=enc_circ,
-        executor=Executor('statevector_simulator'),
+        executor=Executor(),
         measurement='XYZ',
         outer_kernel='gaussian'
     )
@@ -242,7 +242,7 @@ training and test data and shows how to optimize kernels.
         enc_circ = ChebyshevPQC(num_qubits=4, num_features=1, num_layers=2)
         pqk_instance = ProjectedQuantumKernel(
             encoding_circuit=enc_circ,
-            executor=Executor(Estimator()),
+            executor=Executor(),
             measurement='XYZ',
             outer_kernel='gaussian',
             parameter_seed=0
@@ -274,7 +274,7 @@ training and test data and shows how to optimize kernels.
     enc_circ = ChebyshevPQC(num_qubits=4, num_features=1, num_layers=2)
     pqk_instance = ProjectedQuantumKernel(
         encoding_circuit=enc_circ,
-        executor=Executor(Estimator()),
+        executor=Executor(),
         measurement='XYZ',
         outer_kernel='gaussian',
         parameter_seed=0
@@ -292,8 +292,7 @@ training and test data and shows how to optimize kernels.
 
 *Note:* The same workflow has to be used for FQKs!
 
-*References*
-------------
+.. rubric:: References
 
 [1] `M. Schuld, "Supervised quantum machine learning models are kernel methods". arXiv:2101.11020v2 (2021). <http://arxiv.org/abs/2101.11020v2>`_
 

{squlearn-0.5.2 → squlearn-0.7.0}/docs/user_guide/observables.rst

@@ -99,7 +99,7 @@ The map can be for example obtained in the transpiled encoding circuit.
 
    from squlearn.encoding_circuit import ChebyshevRx,TranspiledEncodingCircuit
    from squlearn.observables import SummedPaulis
-   from qiskit.providers.fake_provider import FakeManilaV2
+   from qiskit_ibm_runtime.fake_provider import FakeManilaV2
    fm = TranspiledEncodingCircuit(ChebyshevRx(3,1),backend=FakeManilaV2(),initial_layout=[0,1,4])
    ob = SummedPaulis(num_qubits=3, op_str="Z")
    print("Observable before mapping:\n",ob,"\n\n")

{squlearn-0.5.2 → squlearn-0.7.0}/docs/user_guide/quantum_neural_networks.rst

@@ -137,7 +137,7 @@ and the Adam optimizer for optimization.
 
     op = SummedPaulis(num_qubits = 4)
     pqc = ChebyshevPQC(num_qubits = 4, num_features = 1, num_layers = 2)
-    qnn = QNNRegressor(pqc, op, Executor("statevector_simulator"), SquaredLoss(), Adam())
+    qnn = QNNRegressor(pqc, op, Executor(), SquaredLoss(), Adam())
 
 The QNN can be trained utilizing the :meth:`fit <squlearn.qnn.QNNRegressor.fit>` method:
 

{squlearn-0.5.2 → squlearn-0.7.0}/examples/encoding_circuits/various_encoding_circuit.ipynb

@@ -217,6 +217,7 @@
     "a sQUlearn EncodingCircuitBase object. The TwoLocal circuit below can be \n",
     "replaced by any other QuantumCircuit\n",
     "\"\"\"\n",
+    "\n",
     "local = TwoLocal(3, \"ry\", \"cx\", \"linear\", reps=2, insert_barriers=True)\n",
     "enc_circ9 = QiskitEncodingCircuit(local)\n",
     "enc_circ9.draw(\"mpl\")"

squlearn-0.5.2/examples/executor/example_executor.ipynb → squlearn-0.7.0/examples/executor/example_executor_qiskit.ipynb

@@ -15,7 +15,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qiskit import Aer\n",
+    "from qiskit_aer import Aer\n",
     "from qiskit.circuit.random import random_circuit\n",
     "from qiskit.primitives import Sampler, Estimator, BackendSampler, BackendEstimator\n",
     "from qiskit.quantum_info import SparsePauliOp\n",
@@ -29,7 +29,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The following cell shows different ways to initialize of the ``Executor`` class from different backends or services."
+    "The following cells shows different ways to initialize of the ``Executor`` class with Qiskit backends or services."
    ]
   },
   {
@@ -44,7 +44,7 @@
     "executor = Executor(\"statevector_simulator\")\n",
     "executor = Executor(\"qasm_simulator\")\n",
     "# from a backend following the Qiskit backend standard:\n",
-    "executor = Executor(Aer.get_backend(\"statevector_simulator\"))"
+    "executor = Executor(Aer.get_backend(\"aer_simulator_statevector\"))"
    ]
   },
   {
@@ -60,13 +60,13 @@
     "# from a backend obtained from the Qiskit IBM runtime service (here, the account has to be set-up previously):\n",
     "service = QiskitRuntimeService(channel=\"ibm_quantum\")\n",
     "# Alternative: service = QiskitRuntimeService(channel=\"ibm_quantum\",token=\"YOUR_TOKEN_HERE\")\n",
-    "executor = Executor(service.get_backend(\"ibm_nairobi\"))\n",
+    "executor = Executor(service.get_backend(\"ibm_kyoto\"))\n",
     "# from a session set-up with the Qiskit IBM runtime service:\n",
-    "session = Session(service, backend=service.get_backend(\"ibm_nairobi\"), max_time=28800)\n",
+    "session = Session(service, backend=service.get_backend(\"ibm_kyoto\"), max_time=28800)\n",
     "executor = Executor(session)\n",
     "\n",
     "# from the Qiskit IBM runtime Estimator primitive:\n",
-    "session = Session(service, backend=service.get_backend(\"ibm_nairobi\"), max_time=28800)\n",
+    "session = Session(service, backend=service.get_backend(\"ibm_kyoto\"), max_time=28800)\n",
     "estimator = RuntimeEstimator(session=session)\n",
     "executor = Executor(estimator)"
    ]
@@ -80,8 +80,8 @@
     "# from a Qiskit simulator primitive:\n",
     "executor = Executor(Estimator())\n",
     "executor = Executor(Sampler())\n",
-    "executor = Executor(BackendEstimator(Aer.get_backend(\"qasm_simulator\")))\n",
-    "executor = Executor(BackendSampler(Aer.get_backend(\"qasm_simulator\")))"
+    "executor = Executor(BackendEstimator(Aer.get_backend(\"aer_simulator\")))\n",
+    "executor = Executor(BackendSampler(Aer.get_backend(\"aer_simulator\")))"
    ]
   },
   {
@@ -133,8 +133,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EstimatorResult(values=array([-0.10483684]), metadata=[{'variance': 0.9890092362820049, 'shots': 4321}])\n",
-      "SamplerResult(quasi_dists=[{0: 0.380859375, 3: 0.5302734375, 2: 0.0498046875, 1: 0.0390625}], metadata=[{'shots': 1024}])\n"
+      "EstimatorResult(values=array([-0.11825966]), metadata=[{'variance': 0.9860146523163866, 'shots': 4321}])\n",
+      "SamplerResult(quasi_dists=[{0: 0.3935546875, 3: 0.541015625, 1: 0.02734375, 2: 0.0380859375}], metadata=[{'shots': 1024}])\n"
      ]
     }
    ],
@@ -169,7 +169,7 @@
     {
      "data": {
       "text/plain": [
-       "Result(backend_name='qasm_simulator', backend_version='0.12.0', qobj_id='', job_id='489c4c9d-b871-4058-a073-627517940b6b', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(), header=QobjExperimentHeader(creg_sizes=[], global_phase=0.0, memory_slots=0, metadata=None, n_qubits=2, name='circuit-163', qreg_sizes=[['q', 2]]), status=DONE, seed_simulator=3039238814, metadata={'batched_shots_optimization': False, 'method': 'stabilizer', 'active_input_qubits': [], 'device': 'CPU', 'remapped_qubits': False, 'num_qubits': 0, 'num_clbits': 0, 'input_qubit_map': [], 'measure_sampling': False, 'parallel_shots': 1, 'parallel_state_update': 12}, time_taken=1.01e-05)], date=2023-11-10T13:16:03.897375, status=COMPLETED, header=None, metadata={'parallel_experiments': 1, 'omp_enabled': True, 'max_memory_mb': 16135, 'max_gpu_memory_mb': 0, 'num_processes_per_experiments': 1, 'mpi_rank': 0, 'num_mpi_processes': 1, 'time_taken_execute': 6.5e-05}, time_taken=0.001001119613647461)"
+       "Result(backend_name='aer_simulator', backend_version='0.13.2', qobj_id='', job_id='3fa1608d-e234-4d64-b957-9c61555f4a89', success=True, results=[ExperimentResult(shots=1024, success=True, meas_level=2, data=ExperimentResultData(), header=QobjExperimentHeader(creg_sizes=[], global_phase=0.0, memory_slots=0, n_qubits=2, name='circuit-158', qreg_sizes=[['q', 2]], metadata={}), status=DONE, seed_simulator=1643401811, metadata={'batched_shots_optimization': False, 'required_memory_mb': 0, 'method': 'stabilizer', 'active_input_qubits': [], 'device': 'CPU', 'remapped_qubits': False, 'num_qubits': 0, 'num_clbits': 0, 'time_taken': 1.84e-05, 'input_qubit_map': [], 'max_memory_mb': 16135, 'measure_sampling': False, 'parallel_shots': 1, 'parallel_state_update': 12, 'runtime_parameter_bind': False, 'num_bind_params': 1}, time_taken=1.84e-05)], date=2024-04-10T17:05:42.732421, status=COMPLETED, header=None, metadata={'omp_enabled': True, 'parallel_experiments': 1, 'max_memory_mb': 16135, 'max_gpu_memory_mb': 0, 'time_taken_execute': 6.57e-05, 'time_taken_parameter_binding': 5.7e-06}, time_taken=0.0)"
       ]
      },
      "execution_count": 7,
@@ -178,7 +178,7 @@
     }
    ],
    "source": [
-    "job = executor.backend_run(circuit)\n",
+    "job = executor.qiskit_execute(circuit)\n",
     "job.result()"
    ]
   },
@@ -198,7 +198,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EstimatorResult(values=array([-0.12566536]), metadata=[{'variance': 0.9842082184919416, 'shots': 4321}])\n"
+      "EstimatorResult(values=array([-0.10807683]), metadata=[{'variance': 0.9883193979382295, 'shots': 4321}])\n"
      ]
     }
    ],
@@ -226,9 +226,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EstimatorResult(values=array([-0.13260819]), metadata=[{'variance': 0.982415067269147, 'shots': 4321}])\n",
+      "EstimatorResult(values=array([-0.11455682]), metadata=[{'variance': 0.9868767360105952, 'shots': 4321}])\n",
       "EstimatorResult(values=array([-0.11345219]), metadata=[{'variance': 0.9871286010365417, 'shots': 1234}])\n",
-      "EstimatorResult(values=array([-0.13260819]), metadata=[{'variance': 0.982415067269147, 'shots': 4321}])\n"
+      "EstimatorResult(values=array([-0.11455682]), metadata=[{'variance': 0.9868767360105952, 'shots': 4321}])\n"
      ]
     }
    ],