Allow to use QAOA-CV optimizer inside classification module

benchmarks/light_benchmark.py

@@ -22,7 +22,9 @@
 from moabb import set_log_level
 from moabb.datasets import bi2012
 from moabb.paradigms import P300
+from qiskit_algorithms.optimizers import SPSA
 from pyriemann_qiskit.utils import distance, mean  # noqa
+from pyriemann_qiskit.utils.hyper_params_factory import create_mixer_rotational_X_gates
 from pyriemann_qiskit.pipelines import (
     QuantumClassifierWithDefaultRiemannianPipeline,
     QuantumMDMWithRiemannianPipeline,
@@ -114,7 +116,6 @@
 pipelines["NCH_MIN_HULL"] = make_pipeline(
     XdawnCovariances(
         nfilter=3,
-        # classes=[labels_dict["Target"]],
         estimator="lwf",
         xdawn_estimator="scm",
     ),
@@ -128,6 +129,26 @@
     ),
 )
 
+
+pipelines["NCH_MIN_HULL_QAOACV"] = make_pipeline(
+    XdawnCovariances(
+        nfilter=3,
+        estimator="lwf",
+        xdawn_estimator="scm",
+    ),
+    QuanticNCH(
+        n_hulls_per_class=1,
+        n_samples_per_hull=3,
+        n_jobs=12,
+        subsampling="min",
+        quantum=True,
+        # Provide create_mixer to force QAOA-CV optimization
+        create_mixer=create_mixer_rotational_X_gates(0),
+        shots=100,
+        qaoa_optimizer=SPSA(maxiter=500),
+    ),
+)
+
 ##############################################################################
 # Compute score
 # --------------

doc/api.rst

@@ -93,6 +93,7 @@ Hyper-parameters generation
     create_mixer_rotational_X_gates
     create_mixer_rotational_XY_gates
     create_mixer_rotational_XZ_gates
+    create_mixer_qiskit_default
 
 Preprocessing
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -169,6 +170,7 @@ Math
     cov_to_corr_matrix
     union_of_diff
     to_xyz
+    is_pauli_identity
 
 Firebase
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

examples/toys_dataset/plot_qaoa_cv.py

@@ -18,12 +18,11 @@
 
 from docplex.mp.model import Model
 import matplotlib.pyplot as plt
-from qiskit.primitives import BackendSampler
-from qiskit_aer import AerSimulator
 from qiskit_algorithms.optimizers import COBYLA, SPSA
 
 from pyriemann_qiskit.utils.docplex import QAOACVOptimizer
 from pyriemann_qiskit.utils.hyper_params_factory import (
+    create_mixer_qiskit_default,
     create_mixer_rotational_X_gates,
     create_mixer_rotational_XY_gates,
     create_mixer_rotational_XZ_gates,
@@ -46,16 +45,16 @@ def run_qaoa_cv(n_reps, optimizer, create_mixer):
     # objective function to minimize
     mdl.minimize((x - 0.83 + y + 2 * z) ** 2)
 
-    # Define the BackendSampler (previously QuantumInstance)
-    backend = AerSimulator(method="statevector", cuStateVec_enable=True)
-    quantum_instance = BackendSampler(
-        backend, options={"shots": 200, "seed_simulator": 42}
+    # Instanciate the QAOA-CV
+    # Note: if quantum_instance is None, it will be created inside the optimizer.
+    qaoa_cv = QAOACVOptimizer(
+        create_mixer, n_reps, quantum_instance=None, optimizer=optimizer
     )
-    quantum_instance.transpile_options["seed_transpiler"] = 42
 
-    # Instanciate the QAOA-CV
-    qaoa_cv = QAOACVOptimizer(create_mixer, n_reps, quantum_instance, optimizer)
-    solution = qaoa_cv.solve(mdl)
+    # reshape is when working with covariance matrices
+    # So the vector of solution is reshaped into a matrix
+    # (this is not the case here)
+    solution = qaoa_cv.solve(mdl, reshape=False)
 
     # print the time, the solution (that it the value for our three variable)
     # and the minimum of the objective function
@@ -96,6 +95,7 @@ def run_qaoa_cv(n_reps, optimizer, create_mixer):
 for angle in range(n_angles):
     angle = math.pi * angle / n_angles
     mixers = [
+        create_mixer_qiskit_default(angle),
         create_mixer_rotational_X_gates(angle),
         create_mixer_rotational_XY_gates(angle),
         create_mixer_rotational_XZ_gates(angle),

pyriemann_qiskit/classification.py

@@ -28,8 +28,10 @@
 from .datasets import get_feature_dimension
 from .utils.docplex import (
     set_global_optimizer,
+    get_global_optimizer,
     ClassicalOptimizer,
     NaiveQAOAOptimizer,
+    QAOACVOptimizer,
 )
 from .utils.distance import (
     distance_functions,
@@ -619,6 +621,37 @@ def parameter_count(self):
         return 0
 
 
+def _get_docplex_optimizer_from_params_bag(
+    logger,
+    quantum,
+    quantum_instance,
+    upper_bound,
+    qaoa_optimizer,
+    classical_optimizer,
+    create_mixer,
+    n_reps,
+):
+    if quantum:
+        if create_mixer:
+            logger._log("Using QAOACVOptimizer")
+            return QAOACVOptimizer(
+                create_mixer=create_mixer,
+                n_reps=n_reps,
+                quantum_instance=quantum_instance,
+                optimizer=qaoa_optimizer,
+            )
+        else:
+            logger._log("Using NaiveQAOAOptimizer")
+            return NaiveQAOAOptimizer(
+                quantum_instance=quantum_instance,
+                upper_bound=upper_bound,
+                optimizer=qaoa_optimizer,
+            )
+    else:
+        logger._log("Using ClassicalOptimizer (COBYLA)")
+        return ClassicalOptimizer(classical_optimizer)
+
+
 class QuanticMDM(QuanticClassifierBase):
 
     """Quantum-enhanced MDM classifier
@@ -639,6 +672,8 @@ class QuanticMDM(QuanticClassifierBase):
         Add classical_optimizer parameter.
     .. versionchanged:: 0.3.0
         Add qaoa_optimizer parameter.
+    .. versionchanged:: 0.4.0
+        Add QAOA-CV optimization.
 
     Parameters
     ----------
@@ -675,6 +710,13 @@ class QuanticMDM(QuanticClassifierBase):
     qaoa_optimizer : SciPyOptimizer, default=SLSQP()
         An instance of a scipy optimizer to find the optimal weights for the
         parametric circuit (ansatz).
+    create_mixer : None | Callable[int, QuantumCircuit], default=None
+        A delegate that takes into input an angle and returns a QuantumCircuit.
+        This circuit is the mixer operatior for the QAOA-CV algorithm.
+        If None and quantum, the NaiveQAOAOptimizer will be used instead.
+    n_reps : int, default=3
+        The number of time the mixer and cost operator are repeated in the QAOA-CV
+        circuit.
 
     See Also
     --------
@@ -709,6 +751,8 @@ def __init__(
         regularization=None,
         classical_optimizer=CobylaOptimizer(rhobeg=2.1, rhoend=0.000001),
         qaoa_optimizer=SLSQP(),
+        create_mixer=None,
+        n_reps=3,
     ):
         QuanticClassifierBase.__init__(
             self, quantum, q_account_token, verbose, shots, None, seed
@@ -718,6 +762,8 @@ def __init__(
         self.regularization = regularization
         self.classical_optimizer = classical_optimizer
         self.qaoa_optimizer = qaoa_optimizer
+        self.create_mixer = create_mixer
+        self.n_reps = n_reps
 
     @staticmethod
     def _override_predict_distance(mdm):
@@ -753,16 +799,16 @@ def _init_algo(self, n_features):
         classifier._predict_distances = QuanticMDM._override_predict_distance(
             classifier
         )
-        if self.quantum:
-            self._log("Using NaiveQAOAOptimizer")
-            self._optimizer = NaiveQAOAOptimizer(
-                quantum_instance=self._quantum_instance,
-                upper_bound=self.upper_bound,
-                optimizer=self.qaoa_optimizer,
-            )
-        else:
-            self._log("Using ClassicalOptimizer (COBYLA)")
-            self._optimizer = ClassicalOptimizer(self.classical_optimizer)
+        self._optimizer = _get_docplex_optimizer_from_params_bag(
+            self,
+            self.quantum,
+            self._quantum_instance if self.quantum else None,
+            self.upper_bound,
+            self.qaoa_optimizer,
+            self.classical_optimizer,
+            self.create_mixer,
+            self.n_reps,
+        )
         set_global_optimizer(self._optimizer)
         return classifier
 
@@ -953,9 +999,15 @@ def _predict_distances(self, X):
                 print("Not running in parallel")
 
         if parallel:
-            dists = Parallel(n_jobs=self.n_jobs)(
-                delayed(self._process_sample)(x) for x in X
-            )
+            # Get global optimizer in this process
+            optimizer = get_global_optimizer(default=None)
+
+            def job(x):
+                # Set the global optimizer inside the new process
+                set_global_optimizer(optimizer)
+                return self._process_sample(x)
+
+            dists = Parallel(n_jobs=self.n_jobs)(delayed(job)(x) for x in X)
 
         else:
             for x in X:
@@ -1018,6 +1070,8 @@ class QuanticNCH(QuanticClassifierBase):
     .. versionadded:: 0.2.0
     .. versionchanged:: 0.3.0
         Add qaoa_optimizer parameter.
+    .. versionchanged:: 0.4.0
+        Add QAOA-CV optimization.
 
     Parameters
     ----------
@@ -1059,6 +1113,13 @@ class QuanticNCH(QuanticClassifierBase):
     qaoa_optimizer : SciPyOptimizer, default=SLSQP()
         An instance of a scipy optimizer to find the optimal weights for the
         parametric circuit (ansatz).
+    create_mixer : None | Callable[int, QuantumCircuit], default=None
+        A delegate that takes into input an angle and returns a QuantumCircuit.
+        This circuit is the mixer operatior for the QAOA-CV algorithm.
+        If None and quantum, the NaiveQAOAOptimizer will be used instead.
+    n_reps : int, default=3
+        The number of time the mixer and cost operator are repeated in the QAOA-CV
+        circuit.
 
     References
     ----------
@@ -1081,6 +1142,8 @@ def __init__(
         n_samples_per_hull=10,
         subsampling="min",
         qaoa_optimizer=SLSQP(),
+        create_mixer=None,
+        n_reps=3,
     ):
         QuanticClassifierBase.__init__(
             self, quantum, q_account_token, verbose, shots, None, seed
@@ -1093,6 +1156,8 @@ def __init__(
         self.n_jobs = n_jobs
         self.subsampling = subsampling
         self.qaoa_optimizer = qaoa_optimizer
+        self.create_mixer = create_mixer
+        self.n_reps = n_reps
 
     def _init_algo(self, n_features):
         self._log("Nearest Convex Hull Classifier initiating algorithm")
@@ -1104,16 +1169,16 @@ def _init_algo(self, n_features):
             subsampling=self.subsampling,
         )
 
-        if self.quantum:
-            self._log("Using NaiveQAOAOptimizer")
-            self._optimizer = NaiveQAOAOptimizer(
-                quantum_instance=self._quantum_instance,
-                upper_bound=self.upper_bound,
-                optimizer=self.qaoa_optimizer,
-            )
-        else:
-            self._log("Using ClassicalOptimizer")
-            self._optimizer = ClassicalOptimizer(self.classical_optimizer)
+        self._optimizer = _get_docplex_optimizer_from_params_bag(
+            self,
+            self.quantum,
+            self._quantum_instance if self.quantum else None,
+            self.upper_bound,
+            self.qaoa_optimizer,
+            self.classical_optimizer,
+            self.create_mixer,
+            self.n_reps,
+        )
 
         # sets the optimizer for the distance functions
         # used in NearestConvexHull class