Merge pull request #376 from sQUlearn/develop

Release 0.10.1

Author: MoritzWillmann

examples/kernel/example_projected_kernel.ipynb

@@ -3,7 +3,7 @@
 from .util import Executor
 from . import observables, encoding_circuit, kernel, optimizers, qnn, util
 
-__version__ = "0.10.0"
+__version__ = "0.10.1"
 
 __all__ = [
     "Executor",

src/squlearn/__init__.py

@@ -36,7 +36,7 @@ class HighDimEncodingCircuit(EncodingCircuitBase):
         cycling_type (str): Defines, how the indices are cycled.\n
                             ``saw``: restarts by 0, e.g. 0,1,2,3,0,1,2,3 (recommended);
                             ``hat``: goes up and then down, e.g. 0,1,2,3,2,1,0,1,2,3
-        number_of_layers (int): Sets the number of layer repetitions. If not given, the number of
+        num_layers (Union[None, int]): Sets the number of layer repetitions. If not given, the number of
                                 layers is determined automatically by the number of features and
                                 qubits. If the given number of layers is to low, a error is thrown.
         layer_type (str): Defines in which directions the features are assigned to the gates.

src/squlearn/encoding_circuit/circuit_library/highdim_encoding_circuit.py

@@ -402,17 +402,7 @@ def set_params(self, **params):
         Args:
             params: Hyper-parameters and their values, e.g. ``num_qubits=2``.
         """
-        valid_params = self.get_params()
-        for key, value in params.items():
-            if key not in valid_params:
-                raise ValueError(
-                    f"Invalid parameter {key!r}. "
-                    f"Valid parameters are {sorted(valid_params)!r}."
-                )
-            try:
-                setattr(self, key, value)
-            except:
-                setattr(self, "_" + key, value)
+        super().set_params(**params)
 
         # Reset the random configuration
         self._is_config_available = False

src/squlearn/encoding_circuit/circuit_library/random_encoding_circuit.py

@@ -22,7 +22,7 @@ class EncodingCircuitBase(ABC):
 
     def __init__(self, num_qubits: int, num_features: int = None) -> None:
         self._num_qubits = num_qubits
-        self._num_features = num_features
+        self._num_features = num_features if num_features != 0 else None
 
         if num_features is not None:
             warnings.warn(
@@ -149,14 +149,16 @@ def draw(
         ):
             feature_vec = ParameterVector(feature_label, self.num_encoding_slots)
 
-        elif self.num_features is not None and num_features is None:
-            feature_vec = ParameterVector(feature_label, self.num_features)
+        elif num_features or self.num_features:
+            feature_vec = ParameterVector(feature_label, num_features or self.num_features)
         else:
             feature_vec = [Parameter(feature_label)]
 
         # ensure random configuration is available
         if hasattr(self, "_is_config_available") and not self._is_config_available:
-            self._gen_random_config(num_features=num_features, seed=self.get_params()["seed"])
+            self._gen_random_config(
+                num_features=num_features or self.num_features or 0, seed=self.get_params()["seed"]
+            )
 
         # ensure that the LayeredEncodingCircuit is built before drawing
         if hasattr(self, "_build_layered_pqc"):
@@ -211,6 +213,8 @@ def set_params(self, **params) -> EncodingCircuitBase:
                     f"Invalid parameter {key!r}. "
                     f"Valid parameters are {sorted(valid_params)!r}."
                 )
+            if key == "num_features" and value == 0:
+                value = None
             try:
                 setattr(self, key, value)
             except:

src/squlearn/encoding_circuit/encoding_circuit_base.py

@@ -2158,23 +2158,8 @@ def get_params(self, deep: bool = True) -> dict:
 
         return params
 
-    def set_params(self, **params) -> None:
-        if "encoding_circuit_str" in params:
-            self._encoding_circuit_str = params["encoding_circuit_str"]
-
-        valid_params = self.get_params()
-        for key, value in params.items():
-            if key not in valid_params:
-                raise ValueError(
-                    f"Invalid parameter {key!r}. "
-                    f"Valid parameters are {sorted(valid_params)!r}."
-                )
-
-        if "num_features" in params:
-            self._num_features = params["num_features"]
-
-        if "num_qubits" in params:
-            self._num_qubits = params["num_qubits"]
+    def set_params(self, **params):
+        super().set_params(**params)
 
         dict_layered_pqc = {}
         for key in params.keys():

src/squlearn/encoding_circuit/layered_encoding_circuit.py

@@ -77,8 +77,7 @@ class ODELoss(KernelLossBase):
             eta=1.2,
         )
 
-    See Also
-    --------
+    See Also:
         squlearn.kernel.QKODE : Quantum Kernel for ODE solving.
 
     References

src/squlearn/kernel/loss/ode_loss.py

@@ -488,7 +488,7 @@ def evaluate_qnn(self, x: np.ndarray) -> np.ndarray:
         Returns:
             The evaluated output of the QNN as numpy array
         """
-        self.__check_num_params()
+        self._initialize_kernel(num_features=extract_num_features(x))
 
         # Copy parameters in QNN form
         if self._parameters is None and self.num_parameters == 0:
@@ -961,10 +961,8 @@ def __call__(
         param = parameters[: qnn.num_parameters]
         param_op = parameters[qnn.num_parameters :]
 
-        if len(param.shape) == 1 and len(param) == 1:
-            param = float(param)
-        if len(param_op.shape) == 1 and len(param_op) == 1:
-            param_op = float(param_op)
+        param = param.item() if param.size == 1 else param
+        param_op = param_op.item() if param_op.size == 1 else param_op
 
         x_result = qnn.evaluate(x, param, param_op, "f")["f"]
         if y is not None:

src/squlearn/kernel/lowlevel_kernel/projected_quantum_kernel.py

@@ -33,8 +33,7 @@ class QGPC(GaussianProcessClassifier, SerializableModelMixin):
             (``num_qubits=``), or (if supported) the number of layers (``num_layers=``)
             of the underlying encoding circuit.
 
-    See Also
-    --------
+    See Also:
         squlearn.kernel.QSVC : Quantum Support Vector classification.
 
     References

src/squlearn/kernel/qgpc.py

@@ -60,8 +60,7 @@ class QGPR(BaseEstimator, RegressorMixin, SerializableModelMixin):
             (``num_qubits=``), or (if supported) the number of layers (``num_layers=``)
             of the underlying encoding circuit.
 
-    See Also
-    --------
+    See Also:
         squlearn.kernel.QKRR : Quantum Gaussian Process regression.
         squlearn.kernel.QSVR : Quantum Support Vector regression.