Merge pull request #389 from sQUlearn/develop

sQUlearn version 0.11.2

Author: MoritzWillmann

src/squlearn/__init__.py

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

src/squlearn/kernel/lowlevel_kernel/fidelity_kernel_statevector.py

@@ -74,47 +74,19 @@ def __init__(
                 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 @@ def qulacs_circuit_executor(*args):
                     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."""

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 @@ def test_evaluate_kernel_sv_qulacs_with_parameter_vector_missing_parameters_rais
         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)