squlearn 0.11.0__tar.gz → 0.11.2__tar.gz

{squlearn-0.11.0 → squlearn-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squlearn
-Version: 0.11.0
+Version: 0.11.2
 Summary: A library for quantum machine learning following the scikit-learn standard.
 Keywords: quantum,machine learning,qml
 Author-email: David Kreplin <david.kreplin@ipa.fraunhofer.de>, Moritz Willmann <moritz.willmann@ipa.fraunhofer.de>, Jan Schnabel <jan.schnabel@ipa.fraunhofer.de>, Frederic Rapp <frederic.rapp@ipa.fraunhofer.de>, Manuel Hagelüken <manuel.hagelueken@ipa.fraunhofer.de>, Marco Roth <marco.roth@ipa.fraunhofer.de>

{squlearn-0.11.0 → squlearn-0.11.2}/src/squlearn/__init__.py

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

{squlearn-0.11.0 → squlearn-0.11.2}/src/squlearn/kernel/lowlevel_kernel/fidelity_kernel_statevector.py

@@ -74,47 +74,19 @@ class FidelityKernelStatevector:
                 circuit = transpile(enc_circ, target=qiskit_pennylane_target, optimization_level=0)
                 self._pennylane_circuit = PennyLaneCircuit(circuit, "state")
 
-                @lru_cache(maxsize=self._cache_size)
-                def pennylane_circuit_executor(*args, **kwargs):
-                    args_numpy = [np.array(arg) for arg in args]
-                    return self._executor.pennylane_execute(
-                        self._pennylane_circuit, *args_numpy, **kwargs
-                    )
-
-                self._cached_execution = pennylane_circuit_executor
-
             elif self._executor.quantum_framework == "qulacs":
 
                 enc_circ = self._encoding_circuit.get_circuit(x, self._parameter_vector)
                 self._qulacs_circuit = QulacsCircuit(enc_circ, None)
 
-                @lru_cache(maxsize=self._cache_size)
-                def qulacs_circuit_executor(*args):
-                    args_numpy = [np.array(arg) for arg in args]
-                    if len(args_numpy) == 0:
-                        return self._executor.qulacs_execute(
-                            qulacs_evaluate_statevector, self._qulacs_circuit
-                        )
-                    elif len(args_numpy) == 1:
-                        return self._executor.qulacs_execute(
-                            qulacs_evaluate_statevector, self._qulacs_circuit, x=args_numpy[0]
-                        )
-                    elif len(args_numpy) == 2:
-                        return self._executor.qulacs_execute(
-                            qulacs_evaluate_statevector,
-                            self._qulacs_circuit,
-                            p=args_numpy[0],
-                            x=args_numpy[1],
-                        )
-
-                self._cached_execution = qulacs_circuit_executor
-
             else:
                 raise RuntimeError(
                     "Quantum framework not supported for FidelityKernelStatevector: "
                     f"{self._executor.quantum_framework}"
                 )
 
+            self._build_cached_execution()
+
         else:
 
             # Mode 2 for shot based: calculate the |0> probabilities
@@ -144,6 +116,74 @@ class FidelityKernelStatevector:
                     f"{self._executor.quantum_framework}"
                 )
 
+    def _build_cached_execution(self) -> None:
+        """(Re)create the ``lru_cache``-wrapped circuit executor.
+
+        Only statevector kernels use a cached executor (shot-based kernels do
+        not). The closure is rebuilt from the already-constructed circuit
+        object rather than from the executor's framework, so it survives being
+        deserialized onto a different backend executor (see
+        :meth:`__getstate__`/:meth:`__setstate__`).
+        """
+        if not self._executor.is_statevector:
+            return
+
+        if getattr(self, "_qulacs_circuit", None) is not None:
+
+            @lru_cache(maxsize=self._cache_size)
+            def qulacs_circuit_executor(*args):
+                args_numpy = [np.array(arg) for arg in args]
+                if len(args_numpy) == 0:
+                    return self._executor.qulacs_execute(
+                        qulacs_evaluate_statevector, self._qulacs_circuit
+                    )
+                elif len(args_numpy) == 1:
+                    return self._executor.qulacs_execute(
+                        qulacs_evaluate_statevector, self._qulacs_circuit, x=args_numpy[0]
+                    )
+                elif len(args_numpy) == 2:
+                    return self._executor.qulacs_execute(
+                        qulacs_evaluate_statevector,
+                        self._qulacs_circuit,
+                        p=args_numpy[0],
+                        x=args_numpy[1],
+                    )
+
+            self._cached_execution = qulacs_circuit_executor
+
+        elif getattr(self, "_pennylane_circuit", None) is not None:
+
+            @lru_cache(maxsize=self._cache_size)
+            def pennylane_circuit_executor(*args, **kwargs):
+                args_numpy = [np.array(arg) for arg in args]
+                return self._executor.pennylane_execute(
+                    self._pennylane_circuit, *args_numpy, **kwargs
+                )
+
+            self._cached_execution = pennylane_circuit_executor
+
+    def __getstate__(self) -> dict:
+        """Return a picklable copy of the kernel's state.
+
+        ``self._cached_execution`` is a local closure wrapped in
+        :func:`functools.lru_cache`. Such objects are not picklable by
+        reference: pickle/cloudpickle serialize them via the wrapped function's
+        ``<locals>`` qualname
+        (``FidelityKernelStatevector.__init__.<locals>.qulacs_circuit_executor``),
+        which cannot be resolved on load -> ``AttributeError: Can't get local
+        object ...``. It is a pure memoization cache, so we drop it here and
+        rebuild it in :meth:`__setstate__`; every other attribute (including the
+        circuit objects) is preserved unchanged.
+        """
+        state = self.__dict__.copy()
+        state.pop("_cached_execution", None)
+        return state
+
+    def __setstate__(self, state: dict) -> None:
+        """Restore the kernel and rebuild the dropped executor closure."""
+        self.__dict__.update(state)
+        self._build_cached_execution()
+
     @property
     def num_parameters(self) -> int:
         """Returns the number of trainable parameters."""

{squlearn-0.11.0 → squlearn-0.11.2}/src/squlearn/qnn/base_qnn.py

@@ -118,6 +118,7 @@ class BaseQNN(BaseEstimator, SerializableModelMixin, ABC):
         self.shuffle = shuffle
 
         self.opt_param_op = opt_param_op
+        self._maybe_disable_opt_param_op()
 
         self.caching = caching
         self.pretrained = pretrained
@@ -301,8 +302,33 @@ class BaseQNN(BaseEstimator, SerializableModelMixin, ABC):
         self._is_fitted = False
         self._is_lowlevel_qnn_initialized = not initialize_qnn
 
+        self._maybe_disable_opt_param_op()
+
         return self
 
+    def _maybe_disable_opt_param_op(self) -> None:
+        """Force ``opt_param_op`` off when the observable has no trainable params.
+
+        Optimizing zero parameters is a no-op. Worse, for multi-output QNNs
+        (operator passed as a list), letting the training loop request
+        ``dfdop`` returns an empty (1, 0) sentinel from
+        ``LowLevelQNNPennyLane._evaluate_todo_all_x`` that downstream
+        ``_evaluate`` cannot reshape, crashing with
+        ``ValueError: cannot reshape array of size 0 into shape (k, 1)``.
+
+        Only the ``True -> False`` direction is auto-applied; if the user
+        explicitly disabled observable-parameter optimization, that choice is
+        respected even if the observable does have trainable parameters.
+        """
+        if not self.opt_param_op:
+            return
+        if isinstance(self.operator, list):
+            num_op_parameters = sum(op.num_parameters for op in self.operator)
+        else:
+            num_op_parameters = self.operator.num_parameters
+        if num_op_parameters == 0:
+            self.opt_param_op = False
+
     def _predict(self, X: np.ndarray) -> np.ndarray:
         """Predict using the QNN.
 

{squlearn-0.11.0 → squlearn-0.11.2}/src/squlearn/qnn/lowlevel_qnn/lowlevel_qnn_pennylane.py

@@ -498,7 +498,14 @@ class LowLevelQNNPennyLane(LowLevelQNNBase):
             value = self._executor.pennylane_execute(deriv, *(eval_tuple))
 
         # Convert back to numpy array
-        return np.real_if_close(np.array(value))
+        values = np.array(value)
+        # PennyLane collapses the leading "observable" axis when a multi-output
+        # QNN has only one observable. Restore it so downstream shape logic
+        # (swap_list in _evaluate) sees the (num_obs, ...) layout consistent
+        # with the multi-observable case.
+        if self.multiple_output and self.num_operator == 1:
+            values = values.reshape((1,) + values.shape)
+        return np.real_if_close(values)
 
     def _evaluate_todo_all_x(
         self, todo_class: DirectEvaluation, x: np.array, param: np.array, param_obs: np.array
@@ -584,6 +591,13 @@ class LowLevelQNNPennyLane(LowLevelQNNBase):
 
         # Convert back to numpy format
         values = np.array(value)
+        # PennyLane collapses the leading "observable" axis when a multi-output
+        # QNN has only one observable. Restore it so the sum_t bookkeeping below
+        # (which assumes ioff=1 for multiple_output) and the downstream swap_list
+        # in _evaluate see the (num_obs, ...) layout consistent with the
+        # multi-observable case.
+        if self.multiple_output and self.num_operator == 1:
+            values = values.reshape((1,) + values.shape)
         # sum over zero values entries due to dx differentiation
         if todo_class.return_grad_x:
             sum_t = tuple()

{squlearn-0.11.0 → squlearn-0.11.2}/tests/kernel/lowlevel_kernel/test_fidelity_kernel_statevector.py

@@ -1,7 +1,10 @@
+import pickle
 from unittest.mock import MagicMock
 import numpy as np
 import pytest
+from squlearn.encoding_circuit import ChebyshevPQC
 from squlearn.kernel.lowlevel_kernel.fidelity_kernel_statevector import FidelityKernelStatevector
+from squlearn.util import Executor
 
 
 def make_executor(is_statevector=True, framework="pennylane", shots=None):
@@ -298,3 +301,58 @@ class TestFidelityKernelStatevector:
         x = np.array([[0.1]])
         with pytest.raises(ValueError):
             k.evaluate_kernel_sv(x, x)
+
+
+def _make_statevector_kernel(framework):
+    executor = Executor(framework)
+    encoding_circuit = ChebyshevPQC(num_qubits=2, num_features=2, num_layers=1)
+    kernel = FidelityKernelStatevector(
+        encoding_circuit=encoding_circuit, executor=executor, num_features=2
+    )
+    rng = np.random.default_rng(0)
+    if kernel.num_parameters > 0:
+        kernel.assign_training_parameters(rng.random(kernel.num_parameters))
+    return kernel
+
+
+def test_pickle_roundtrip_preserves_kernel_qulacs():
+    """A qulacs statevector kernel must survive stdlib pickling.
+
+    ``_cached_execution`` is an ``lru_cache``-wrapped local closure that cannot
+    be pickled by reference (the original ``AttributeError: Can't get local
+    object ...``); ``__getstate__``/``__setstate__`` drop and rebuild it. The
+    pennylane circuit holds a sympy lambda that stdlib pickle cannot handle
+    regardless, so that framework is covered by the dill-based ModelPickler
+    serialization tests and by ``test_getstate_setstate_rebuilds_executor``.
+    """
+    kernel = _make_statevector_kernel("qulacs")
+    x = np.random.default_rng(0).random((4, 2))
+    expected = kernel.evaluate(x, x)
+
+    restored = pickle.loads(pickle.dumps(kernel))
+
+    assert "_cached_execution" in vars(restored)
+    np.testing.assert_allclose(restored.evaluate(x, x), expected)
+
+
+@pytest.mark.parametrize("framework", ["qulacs", "pennylane"])
+def test_getstate_setstate_rebuilds_executor(framework):
+    """__getstate__ drops the unpicklable closure; __setstate__ rebuilds it.
+
+    Exercises the mechanism directly (no pickling), so it covers pennylane too,
+    and confirms the rebuilt kernel reproduces the original kernel matrix.
+    """
+    kernel = _make_statevector_kernel(framework)
+    x = np.random.default_rng(0).random((4, 2))
+    expected = kernel.evaluate(x, x)
+
+    state = kernel.__getstate__()
+    assert "_cached_execution" not in state
+
+    restored = FidelityKernelStatevector.__new__(FidelityKernelStatevector)
+    restored.__setstate__(state)
+
+    assert "_cached_execution" in vars(restored)
+    np.testing.assert_allclose(restored.evaluate(x, x), expected)
+    if kernel._parameters is not None:
+        np.testing.assert_allclose(restored._parameters, kernel._parameters)

{squlearn-0.11.0 → squlearn-0.11.2}/tests/qnn/lowlevel_qnn/test_lowlevel_qnn.py

@@ -4,7 +4,7 @@ import numpy as np
 
 from squlearn import Executor
 from squlearn.encoding_circuit import ParamZFeatureMap
-from squlearn.observables import SummedPaulis
+from squlearn.observables import SinglePauli, SummedPaulis
 from squlearn.qnn.lowlevel_qnn import LowLevelQNN
 
 
@@ -63,3 +63,28 @@ def test_backends_consistency():
         values_qiskit[qiskit_param_op_key], values_pennylane[pennylane_param_op_key]
     )
     assert np.allclose(values_qiskit[qiskit_param_op_key], values_qulacs[qulacs_param_op_key])
+
+
+@pytest.mark.parametrize("framework", ["pennylane", "qiskit", "qulacs"])
+@pytest.mark.parametrize("n_obs", [1, 2])
+def test_multiple_output_shape_with_n_observables(framework, n_obs):
+    """Regression: a list-of-one observable must produce the same shape contract
+    as a list of multiple observables. PennyLane otherwise collapses the leading
+    "observable" axis when only one measurement is returned, which previously
+    crashed ProjectedQuantumKernel for num_qubits=1 with a single-Pauli measurement.
+    """
+    pqc = ParamZFeatureMap(4, 2)
+    obs = [SinglePauli(4, i, op_str="X") for i in range(n_obs)]
+    llqnn = LowLevelQNN(pqc, obs, executor=Executor(framework), num_features=2)
+
+    np.random.seed(42)
+    x = np.random.rand(5, 2)
+    param = np.random.rand(llqnn.num_parameters)
+
+    assert llqnn.evaluate(x, param, [], "f")["f"].shape == (5, n_obs)
+    assert llqnn.evaluate(x, param, [], "dfdx")["dfdx"].shape == (5, n_obs, 2)
+    assert llqnn.evaluate(x, param, [], "dfdp")["dfdp"].shape == (
+        5,
+        n_obs,
+        llqnn.num_parameters,
+    )

{squlearn-0.11.0 → squlearn-0.11.2}/tests/qnn/test_qnnc.py

@@ -8,10 +8,10 @@ from sklearn.datasets import make_blobs
 from sklearn.preprocessing import LabelBinarizer, MinMaxScaler
 
 from squlearn import Executor
-from squlearn.observables import SummedPaulis
+from squlearn.observables import SinglePauli, SummedPaulis
 from squlearn.encoding_circuit import ChebyshevPQC
 from squlearn.optimizers import SLSQP, Adam
-from squlearn.qnn import CrossEntropyLoss, QNNClassifier
+from squlearn.qnn import CrossEntropyLoss, QNNClassifier, SquaredLoss
 
 
 class TestQNNClassifier:
@@ -240,3 +240,71 @@ class TestQNNClassifier:
         assert instance_loaded._is_fitted
         assert np.allclose(instance_loaded.param, qnn_classifier.param)
         assert np.allclose(instance_loaded.param_op, qnn_classifier.param_op)
+
+    def _make_opt_param_op_qnnc(self, operator, **overrides) -> QNNClassifier:
+        """QNNClassifier with a parameterless-observable-friendly setup.
+
+        Used by the ``opt_param_op`` auto-correction regression tests below.
+        ``ChebyshevPQC`` carries trainable circuit params (so training would
+        request ``dfdp`` and reach the empty-``dfdop`` early-return on the
+        PennyLane backend), and ``Adam`` exercises the SGD/``train_mini_batch``
+        path where the bug originally surfaced.
+        """
+        kwargs = dict(
+            encoding_circuit=ChebyshevPQC(num_qubits=2, num_features=2, num_layers=2),
+            operator=operator,
+            executor=Executor("pennylane"),
+            loss=SquaredLoss(),
+            optimizer=Adam(options={"lr": 0.05}),
+            batch_size=5,
+            epochs=1,
+            shuffle=False,
+            parameter_seed=0,
+        )
+        kwargs.update(overrides)
+        return QNNClassifier(**kwargs)
+
+    @pytest.mark.parametrize(
+        "operator",
+        [
+            [SinglePauli(2, 0, op_str="X")],
+            [SinglePauli(2, 0, op_str="X"), SinglePauli(2, 1, op_str="X")],
+        ],
+        ids=["list_of_1", "list_of_2"],
+    )
+    def test_opt_param_op_auto_disabled_at_init(self, data, operator):
+        """Regression: ``opt_param_op`` auto-flips to ``False`` at construction
+        when the observable has no trainable parameters.
+
+        Otherwise training requests ``dfdop`` and crashes with
+        ``ValueError: cannot reshape array of size 0 into shape (k, 1)`` for
+        any multi-output QNN (operator passed as a list).
+        """
+        qnnc = self._make_opt_param_op_qnnc(operator)
+        assert qnnc.opt_param_op is False  # at __init__, not deferred to fit
+        X, y = data
+        qnnc.fit(X, y)
+        assert qnnc.predict(X).shape == y.shape
+
+    def test_opt_param_op_left_alone_when_obs_has_params(self, data):
+        qnnc = self._make_opt_param_op_qnnc(SummedPaulis(num_qubits=2))
+        assert qnnc.opt_param_op is True
+        X, y = data
+        qnnc.fit(X, y)
+        assert qnnc.opt_param_op is True
+
+    def test_opt_param_op_explicit_false_is_respected(self):
+        """Observable has trainable params, but user explicitly opted out:
+        auto-correction must only ever flip ``True -> False``, never the
+        other direction."""
+        qnnc = self._make_opt_param_op_qnnc(SummedPaulis(num_qubits=2), opt_param_op=False)
+        assert qnnc.opt_param_op is False
+
+    def test_opt_param_op_re_evaluates_in_set_params(self):
+        """Swap a parameterized observable for one with no params via
+        ``set_params``: ``opt_param_op`` must re-evaluate immediately, not
+        wait for the next ``fit``."""
+        qnnc = self._make_opt_param_op_qnnc(SummedPaulis(num_qubits=2))
+        assert qnnc.opt_param_op is True
+        qnnc.set_params(operator=[SinglePauli(2, 0, op_str="X")])
+        assert qnnc.opt_param_op is False

{squlearn-0.11.0 → squlearn-0.11.2}/tests/qnn/test_qnnr.py

@@ -8,10 +8,10 @@ from sklearn.datasets import make_regression
 from sklearn.preprocessing import MinMaxScaler
 
 from squlearn import Executor
-from squlearn.observables import SummedPaulis
-from squlearn.encoding_circuit import ChebyshevRx
+from squlearn.observables import SinglePauli, SummedPaulis
+from squlearn.encoding_circuit import ChebyshevPQC, ChebyshevRx
 from squlearn.optimizers import SLSQP, Adam
-from squlearn.qnn import QNNRegressor, MeanSquaredError
+from squlearn.qnn import QNNRegressor, MeanSquaredError, SquaredLoss
 
 
 class TestQNNRegressor:
@@ -241,3 +241,74 @@ class TestQNNRegressor:
         assert instance_loaded._is_fitted
         assert np.allclose(instance_loaded.param, qnn_regressor.param)
         assert np.allclose(instance_loaded.param_op, qnn_regressor.param_op)
+
+    def _make_opt_param_op_qnnr(self, operator, **overrides) -> QNNRegressor:
+        """QNNRegressor with a parameterless-observable-friendly setup.
+
+        Used by the ``opt_param_op`` auto-correction regression tests below.
+        ``ChebyshevPQC`` carries trainable circuit params (so training would
+        request ``dfdp`` and reach the empty-``dfdop`` early-return on the
+        PennyLane backend), and ``Adam`` exercises the SGD/``train_mini_batch``
+        path where the bug originally surfaced.
+        """
+        kwargs = dict(
+            encoding_circuit=ChebyshevPQC(num_qubits=2, num_features=1, num_layers=2),
+            operator=operator,
+            executor=Executor("pennylane"),
+            loss=SquaredLoss(),
+            optimizer=Adam(options={"lr": 0.05}),
+            batch_size=3,
+            epochs=1,
+            shuffle=False,
+            parameter_seed=0,
+        )
+        kwargs.update(overrides)
+        return QNNRegressor(**kwargs)
+
+    @pytest.mark.parametrize(
+        "operator",
+        [
+            [SinglePauli(2, 0, op_str="X")],
+            [SinglePauli(2, 0, op_str="X"), SinglePauli(2, 1, op_str="X")],
+        ],
+        ids=["list_of_1", "list_of_2"],
+    )
+    def test_opt_param_op_auto_disabled_at_init(self, data, operator):
+        """Regression: ``opt_param_op`` auto-flips to ``False`` at construction
+        when the observable has no trainable parameters.
+
+        Otherwise training requests ``dfdop`` and crashes with
+        ``ValueError: cannot reshape array of size 0 into shape (k, 1)`` for
+        any multi-output QNN (operator passed as a list).
+        """
+        qnnr = self._make_opt_param_op_qnnr(operator)
+        assert qnnr.opt_param_op is False  # at __init__, not deferred to fit
+        X, y = data
+        # Multi-output regression needs y with matching shape; broadcast the
+        # 1D target across the observable list so fit doesn't fail upstream.
+        y_multi = np.broadcast_to(y[:, None], (y.shape[0], len(operator)))
+        qnnr.fit(X, y_multi)
+        assert qnnr.predict(X).shape == y_multi.shape
+
+    def test_opt_param_op_left_alone_when_obs_has_params(self, data):
+        qnnr = self._make_opt_param_op_qnnr(SummedPaulis(num_qubits=2))
+        assert qnnr.opt_param_op is True
+        X, y = data
+        qnnr.fit(X, y)
+        assert qnnr.opt_param_op is True
+
+    def test_opt_param_op_explicit_false_is_respected(self):
+        """Observable has trainable params, but user explicitly opted out:
+        auto-correction must only ever flip ``True -> False``, never the
+        other direction."""
+        qnnr = self._make_opt_param_op_qnnr(SummedPaulis(num_qubits=2), opt_param_op=False)
+        assert qnnr.opt_param_op is False
+
+    def test_opt_param_op_re_evaluates_in_set_params(self):
+        """Swap a parameterized observable for one with no params via
+        ``set_params``: ``opt_param_op`` must re-evaluate immediately, not
+        wait for the next ``fit``."""
+        qnnr = self._make_opt_param_op_qnnr(SummedPaulis(num_qubits=2))
+        assert qnnr.opt_param_op is True
+        qnnr.set_params(operator=[SinglePauli(2, 0, op_str="X")])
+        assert qnnr.opt_param_op is False