Shots and feature map exposure

doc/requirements.txt

@@ -2,7 +2,7 @@ sphinx-gallery
 sphinx-bootstrap_theme
 numpydoc
 cython
-mne
+mne[data]>=0.24
 seaborn
 scikit-learn
 joblib

pyriemann_qiskit/classification.py

@@ -1,10 +1,12 @@
 """Module for classification function."""
 import numpy as np
 
+from .utils.hyper_params_factory import gen_zz_feature_map
+
 from sklearn.base import BaseEstimator, ClassifierMixin
 
 from qiskit import BasicAer, IBMQ
-from qiskit.circuit.library import ZZFeatureMap, TwoLocal
+from qiskit.circuit.library import TwoLocal
 from qiskit.aqua import QuantumInstance, aqua_globals
 from qiskit.aqua.quantum_instance import logger
 from qiskit.aqua.algorithms import QSVM, SklearnSVM, VQC
@@ -45,7 +47,11 @@ class QuanticClassifierBase(BaseEstimator, ClassifierMixin):
         the classification task will be running on a IBM quantum backend
     verbose : bool (default:True)
         If true will output all intermediate results and logs
-
+    shots : int (default:1024)
+        Number of repetitions of each circuit, for sampling
+    gen_feature_map : Callable[[int], Union[QuantumCircuit, FeatureMap]]
+        Generate a feature map.
+        The feature map encodes the data into a quantum state.
     Notes
     -----
     .. versionadded:: 0.0.1
@@ -68,11 +74,14 @@ class QuanticClassifierBase(BaseEstimator, ClassifierMixin):
 
     """
 
-    def __init__(self, quantum=True, q_account_token=None, verbose=True):
+    def __init__(self, quantum=True, q_account_token=None, verbose=True,
+                 shots=1024, gen_feature_map=gen_zz_feature_map()):
         self.verbose = verbose
         self._log("Initializing Quantum Classifier")
         self.q_account_token = q_account_token
         self.quantum = quantum
+        self.shots = shots
+        self.gen_feature_map = gen_feature_map
         # protected field for child classes
         self._training_input = {}
 
@@ -148,8 +157,7 @@ def fit(self, X, y):
 
         feature_dim = get_feature_dimension(self._training_input)
         self._log("Feature dimension = ", feature_dim)
-        self._feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2,
-                                         entanglement='linear')
+        self._feature_map = self.gen_feature_map(feature_dim)
         if self.quantum:
             if not hasattr(self, "_backend"):
                 def filters(device):
@@ -166,7 +174,8 @@ def filters(device):
                 self._log("Quantum backend = ", self._backend)
             seed_sim = aqua_globals.random_seed
             seed_trs = aqua_globals.random_seed
-            self._quantum_instance = QuantumInstance(self._backend, shots=1024,
+            self._quantum_instance = QuantumInstance(self._backend,
+                                                     shots=self.shots,
                                                      seed_simulator=seed_sim,
                                                      seed_transpiler=seed_trs)
         self._classifier = self._init_algo(feature_dim)

pyriemann_qiskit/utils/__init__.py

@@ -0,0 +1,5 @@
+from . import hyper_params_factory
+
+__all__ = [
+    'hyper_params_factory',
+]

pyriemann_qiskit/utils/hyper_params_factory.py

@@ -0,0 +1,23 @@
+from qiskit.circuit.library import ZZFeatureMap
+
+
+def gen_zz_feature_map(reps=2, entanglement='linear'):
+    """Return a callable that generate a ZZFeatureMap.
+    A feature map encodes data into a quantum state.
+    A ZZFeatureMap is a second-order Pauli-Z evolution circuit.
+
+    Parameters
+    ----------
+    reps : int
+        The number of repeated circuits, has a min. value of 1.
+    entanglement : Union[str, List[List[int]], Callable[[int], List[int]]]
+        Specifies the entanglement structure.
+
+    Returns
+    -------
+    ret : ZZFeatureMap
+        An instance of ZZFeatureMap
+    """
+    return lambda dim: ZZFeatureMap(feature_dimension=dim,
+                                    reps=reps,
+                                    entanglement=entanglement)