Support for V2 primitives

.github/workflows/main.yml

@@ -312,4 +312,4 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: coveralls --service=github
-        shell: bash
+        shell: bash

qiskit_machine_learning/algorithms/inference/qbayesian.py

@@ -15,11 +15,15 @@
 
 import copy
 from typing import Tuple, Dict, Set, List
+
 from qiskit import QuantumCircuit, ClassicalRegister
 from qiskit.quantum_info import Statevector
-from qiskit.circuit.library import GroverOperator
-from qiskit.primitives import BaseSampler, Sampler
 from qiskit.circuit import Qubit
+from qiskit.circuit.library import GroverOperator
+from qiskit.primitives import BaseSampler, Sampler, BaseSamplerV2
+from qiskit.transpiler.passmanager import BasePassManager
+from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
+from qiskit.providers.fake_provider import GenericBackendV2
 
 
 class QBayesian:
@@ -62,7 +66,8 @@ def __init__(
         *,
         limit: int = 10,
         threshold: float = 0.9,
-        sampler: BaseSampler | None = None,
+        sampler: BaseSampler | BaseSamplerV2 | None = None,
+        pass_manager: BasePassManager | None = None,
     ):
         """
         Args:
@@ -83,7 +88,8 @@ def __init__(
         # Test valid input
         for qrg in circuit.qregs:
             if qrg.size > 1:
-                raise ValueError("Every register needs to be mapped to exactly one unique qubit")
+                raise ValueError("Every register needs to be mapped to exactly one unique qubit.")
+
         # Initialize parameter
         self._circ = circuit
         self._limit = limit
@@ -92,6 +98,11 @@ def __init__(
             sampler = Sampler()
         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)
+        self._pass_manager = pass_manager
+
         # Label of register mapped to its qubit
         self._label2qubit = {qrg.name: qrg[0] for qrg in self._circ.qregs}
         # Label of register mapped to its qubit index bottom up in significance
@@ -139,11 +150,34 @@ def _get_grover_op(self, evidence: Dict[str, int]) -> GroverOperator:
 
     def _run_circuit(self, circuit: QuantumCircuit) -> Dict[str, float]:
         """Run the quantum circuit with the sampler."""
-        # Sample from circuit
-        job = self._sampler.run(circuit)
-        result = job.result()
-        # Get the counts of quantum state results
-        counts = result.quasi_dists[0].nearest_probability_distribution().binary_probabilities()
+        counts = {}
+
+        if isinstance(self._sampler, BaseSampler):
+            # Sample from circuit
+            job = self._sampler.run(circuit)
+            result = job.result()
+
+            # Get the counts of quantum state results
+            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])
+            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()}
+
+            # Convert to quasi-probabilities
+            # counts = QuasiDistribution(probabilities)
+            # counts = {k: v for k, v in counts.items()}
+
         return counts
 
     def __power_grover(
@@ -360,12 +394,12 @@ def limit(self, limit: int):
         self._limit = limit
 
     @property
-    def sampler(self) -> BaseSampler:
+    def sampler(self) -> BaseSampler | BaseSamplerV2:
         """Returns the sampler primitive used to compute the samples."""
         return self._sampler
 
     @sampler.setter
-    def sampler(self, sampler: BaseSampler):
+    def sampler(self, sampler: BaseSampler | BaseSamplerV2):
         """Set the sampler primitive used to compute the samples."""
         self._sampler = sampler
 

qiskit_machine_learning/gradients/base/base_estimator_gradient.py

@@ -24,10 +24,12 @@
 
 from qiskit.circuit import Parameter, ParameterExpression, QuantumCircuit
 from qiskit.primitives import BaseEstimator
+from qiskit.primitives.base import BaseEstimatorV2
 from qiskit.primitives.utils import _circuit_key
 from qiskit.providers import Options
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 from qiskit.transpiler.passes import TranslateParameterizedGates
+from qiskit.transpiler.passmanager import BasePassManager
 
 from .estimator_gradient_result import EstimatorGradientResult
 from ..utils import (
@@ -46,13 +48,15 @@ class BaseEstimatorGradient(ABC):
 
     def __init__(
         self,
-        estimator: BaseEstimator,
+        estimator: BaseEstimator | BaseEstimatorV2,
         options: Options | None = None,
         derivative_type: DerivativeType = DerivativeType.REAL,
+        pass_manager: BasePassManager | None = None,
     ):
         r"""
         Args:
             estimator: The estimator used to compute the gradients.
+            pass_manager: pass manager for isa_circuit transpilation.
             options: Primitive backend runtime options used for circuit execution.
                 The order of priority is: options in ``run`` method > gradient's
                 default options > primitive's default setting.
@@ -69,6 +73,7 @@ def __init__(
                 finite difference.
         """
         self._estimator: BaseEstimator = estimator
+        self._pass_manager = pass_manager
         self._default_options = Options()
         if options is not None:
             self._default_options.update_options(**options)

qiskit_machine_learning/gradients/base/base_sampler_gradient.py

@@ -26,6 +26,7 @@
 from qiskit.primitives.utils import _circuit_key
 from qiskit.providers import Options
 from qiskit.transpiler.passes import TranslateParameterizedGates
+from qiskit.transpiler.passmanager import BasePassManager
 
 from .sampler_gradient_result import SamplerGradientResult
 from ..utils import (
@@ -41,7 +42,13 @@
 class BaseSamplerGradient(ABC):
     """Base class for a ``SamplerGradient`` to compute the gradients of the sampling probability."""
 
-    def __init__(self, sampler: BaseSampler, options: Options | None = None):
+    def __init__(
+        self,
+        sampler: BaseSampler,
+        options: Options | None = None,
+        len_quasi_dist: int | None = None,
+        pass_manager: BasePassManager | None = None,
+    ):
         """
         Args:
             sampler: The sampler used to compute the gradients.
@@ -51,6 +58,8 @@ def __init__(self, sampler: BaseSampler, options: Options | None = None):
                 Higher priority setting overrides lower priority setting
         """
         self._sampler: BaseSampler = sampler
+        self._pass_manager = pass_manager
+        self._len_quasi_dist = len_quasi_dist
         self._default_options = Options()
         if options is not None:
             self._default_options.update_options(**options)

qiskit_machine_learning/gradients/param_shift/param_shift_estimator_gradient.py

@@ -17,14 +17,19 @@
 
 from collections.abc import Sequence
 
+import numpy as np
+
 from qiskit.circuit import Parameter, QuantumCircuit
 from qiskit.quantum_info.operators.base_operator import BaseOperator
+from qiskit.primitives.base import BaseEstimatorV2
+from qiskit.primitives import BaseEstimatorV1
+from qiskit.providers.options import Options
 
 from ..base.base_estimator_gradient import BaseEstimatorGradient
 from ..base.estimator_gradient_result import EstimatorGradientResult
 from ..utils import _make_param_shift_parameter_values
 
-from ...exceptions import AlgorithmError
+from ...exceptions import QiskitMachineLearningError
 
 
 class ParamShiftEstimatorGradient(BaseEstimatorGradient):
@@ -97,26 +102,59 @@ def _run_unique(
             job_param_values.extend(param_shift_parameter_values)
             all_n.append(n)
 
-        # Run the single job with all circuits.
-        job = self._estimator.run(
-            job_circuits,
-            job_observables,
-            job_param_values,
-            **options,
-        )
-        try:
+        # Determine how to run the estimator based on its version
+        if isinstance(self._estimator, BaseEstimatorV1):
+            # Run the single job with all circuits.
+            job = self._estimator.run(
+                job_circuits,
+                job_observables,
+                job_param_values,
+                **options,
+            )
             results = job.result()
-        except Exception as exc:
-            raise AlgorithmError("Estimator job failed.") from exc
-
-        # Compute the gradients.
-        gradients = []
-        partial_sum_n = 0
-        for n in all_n:
-            result = results.values[partial_sum_n : partial_sum_n + n]
-            gradient_ = (result[: n // 2] - result[n // 2 :]) / 2
-            gradients.append(gradient_)
-            partial_sum_n += n
-
-        opt = self._get_local_options(options)
+
+            # Compute the gradients.
+            gradients = []
+            partial_sum_n = 0
+            for n in all_n:
+                result = results.values[partial_sum_n : partial_sum_n + n]
+                gradient_ = (result[: n // 2] - result[n // 2 :]) / 2
+                gradients.append(gradient_)
+                partial_sum_n += n
+
+            opt = self._get_local_options(options)
+
+        elif isinstance(self._estimator, BaseEstimatorV2):
+            isa_g_circs = self._pass_manager.run(job_circuits)
+            isa_g_observables = [
+                op.apply_layout(isa_g_circs[i].layout) for i, op in enumerate(job_observables)
+            ]
+            # Prepare circuit-observable-parameter tuples (PUBs)
+            circuit_observable_params = []
+            for pub in zip(isa_g_circs, isa_g_observables, job_param_values):
+                circuit_observable_params.append(pub)
+
+            # For BaseEstimatorV2, run the estimator using PUBs and specified precision
+            job = self._estimator.run(circuit_observable_params)
+            results = job.result()
+            results = np.array([float(r.data.evs) for r in results])
+
+            # Compute the gradients.
+            gradients = []
+            partial_sum_n = 0
+            for n in all_n:
+                result = results[partial_sum_n : partial_sum_n + n]
+                gradient_ = (result[: n // 2] - result[n // 2 :]) / 2
+                gradients.append(gradient_)
+                partial_sum_n += n
+
+            opt = Options(**options)
+
+        else:
+            raise QiskitMachineLearningError(
+                "The accepted estimators are BaseEstimatorV1 and BaseEstimatorV2; got "
+                + f"{type(self._estimator)} instead. Note that BaseEstimatorV1 is deprecated in"
+                + "Qiskit and removed in Qiskit IBM Runtime."
+            )
+
         return EstimatorGradientResult(gradients=gradients, metadata=metadata, options=opt)

qiskit_machine_learning/gradients/param_shift/param_shift_sampler_gradient.py

@@ -20,11 +20,15 @@
 
 from qiskit.circuit import Parameter, QuantumCircuit
 
+from qiskit.primitives import BaseSamplerV1
+from qiskit.primitives.base import BaseSamplerV2
+from qiskit.result import QuasiDistribution
+
 from ..base.base_sampler_gradient import BaseSamplerGradient
 from ..base.sampler_gradient_result import SamplerGradientResult
 from ..utils import _make_param_shift_parameter_values
 
-from ...exceptions import AlgorithmError
+from ...exceptions import AlgorithmError, QiskitMachineLearningError
 
 
 class ParamShiftSamplerGradient(BaseSamplerGradient):
@@ -91,18 +95,52 @@ def _run_unique(
             all_n.append(n)
 
         # Run the single job with all circuits.
-        job = self._sampler.run(job_circuits, job_param_values, **options)
+        if isinstance(self._sampler, BaseSamplerV1):
+            job = self._sampler.run(job_circuits, job_param_values, **options)
+        elif isinstance(self._sampler, BaseSamplerV2):
+            if self._pass_manager is None:
+                raise QiskitMachineLearningError(
+                    "To use ParameterShifSamplerGradient with SamplerV2 you "
+                    + "must pass a gradient with a pass manager"
+                )
+            isa_g_circs = self._pass_manager.run(job_circuits)
+            circ_params = [
+                (isa_g_circs[i], job_param_values[i]) for i in range(len(job_param_values))
+            ]
+            job = self._sampler.run(circ_params)
+        else:
+            raise AlgorithmError(
+                "The accepted estimators are BaseSamplerV1 (deprecated) and BaseSamplerV2; got "
+                + f"{type(self._sampler)} instead."
+            )
+
         try:
             results = job.result()
         except Exception as exc:
-            raise AlgorithmError("Estimator job failed.") from exc
+            raise AlgorithmError("Sampler job failed.") from exc
 
         # Compute the gradients.
         gradients = []
         partial_sum_n = 0
+        opt = None  # Required by PyLint: possibly-used-before-assignment
         for n in all_n:
             gradient = []
-            result = results.quasi_dists[partial_sum_n : partial_sum_n + n]
+
+            if isinstance(self._sampler, BaseSamplerV1):
+                result = results.quasi_dists[partial_sum_n : partial_sum_n + n]
+                opt = self._get_local_options(options)
+            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()
+                    # Normalize the counts to probabilities
+                    total_shots = sum(bitstring_counts.values())
+                    probabilities = {k: v / total_shots for k, v in bitstring_counts.items()}
+                    # Convert to quasi-probabilities
+                    counts = QuasiDistribution(probabilities)
+                    result.append({k: v for k, v in counts.items() if int(k) < self.len_quasi_dist})
+                    opt = options
+
             for dist_plus, dist_minus in zip(result[: n // 2], result[n // 2 :]):
                 grad_dist: dict[int, float] = defaultdict(float)
                 for key, val in dist_plus.items():
@@ -113,5 +151,4 @@ def _run_unique(
             gradients.append(gradient)
             partial_sum_n += n
 
-        opt = self._get_local_options(options)
         return SamplerGradientResult(gradients=gradients, metadata=metadata, options=opt)