Increase test coverage (#357)

* add tests for `QCNNEncodingCircuit`

* add tests for `QiskitEncodingCircuit`

* add tests for `EncodingCircuitDerivatives`

* extend tests for `PrunedEncodingCircuit` to cover the `automated_pruning` function

* move files in test folders to match the source structure

* add tests for the `SingleProbability` observable

* add tests for `SummedProbabilities` observable

* add tests for `ObservableBase`

* add tests for all qnnLoss classes

* add tests for `FidelityKernelStatevector`

* add tests for `FidelityKernelExpectationValue`

* add tests for `FidelityKernel`

* add tests for `CustomObservable` and `IsingHamiltonian`

* extended tests for `IsingHamiltonian`

* add tests for `SinglePauli` and `SummedPaulis`

* add tests for `Adam` and `ApproximatedGradients`

* add tests for the wrapped optimizers (`SLSQP`, `LBFGSB`, `SPSA`)

* add helper function to check equality of two qiskit circuits

* extend the circuit tests to check the result circuits against a 'ground-truth circuit'

* add tests to test the returned expectation value of the observables

* add expectation value test for `SummedPaulis`

* add expectation value test for `FidelityKerne`

* adapt tests for qnn `ODELoss`:

- adpat tests to the changed API
- extend tests for order2 loss

* Fix handling of optional weights in `SquaredLoss` and `CrossEntropyLoss`

* ensure `NLL` returns a real float scalar instead of an array

* use `.item()` to extract a scalar from an array instead of just `float(param)`

* return list items instead of np arrays in the mocked return value

* fix some loss outputs

* move `qiskit_circuit_equivalence.py` into `/test`

* move the`build_circuit` functions to the top-level as protected

* add other objective function to test bounds clipping

* add additional objective function to test

* Refactor expectation value tests to use parameterized inputs for improved clarity and maintainability

* add expected kernel as parameter

* Standardized verification of the kernel matrix for identity matrix in the tests

* black

---------

Co-authored-by: Dennis Kleinhans <dennis.kleinhans@ipa.fraunhofer.de>
Co-authored-by: Moritz <44642314+MoritzWillmann@users.noreply.github.com>
Co-authored-by: Moritz <moritz.willmann@ipa.fraunhofer.de>

Author: 3 people

src/squlearn/encoding_circuit/encoding_circuit_derivatives.py

@@ -192,7 +192,7 @@ def helper_hash(diff):
             return self._optree_start.copy()
         else:
             # Check if differentiating tuple is already stored in optree_cache
-            if self._optree_caching == True and helper_hash((diff_tuple,)) in self._optree_cache:
+            if self._optree_caching is True and helper_hash((diff_tuple,)) in self._optree_cache:
                 # If stored -> return
                 return self._optree_cache[helper_hash((diff_tuple,))].copy()
             else:
@@ -201,7 +201,7 @@ def helper_hash(diff):
                     self._differentiation_from_tuple(diff_tuple[1:]), diff_tuple[0]
                 )
                 # Store result in the optree_cache
-                if self._optree_caching == True:
+                if self._optree_caching is True:
                     self._optree_cache[helper_hash((diff_tuple,))] = circ
                 return circ
 
@@ -229,7 +229,7 @@ def assign_parameters(
         self, optree: OpTreeElementBase, features: np.ndarray, parameters: np.ndarray
     ) -> OpTreeElementBase:
         """
-        Assigns numerical values to the ParameterVector elements of the encoding circuit circuit.
+        Assigns numerical values to the ParameterVector elements of the encoding circuit.
 
         Args:
             optree (OperatorBase): OpTree object to be assigned.

src/squlearn/kernel/loss/negative_log_likelihood.py

@@ -85,7 +85,6 @@ def compute(
             np.sum(np.log(np.diagonal(L)))
             + 0.5 * labels.T @ S2
             + 0.5 * len(data) * np.log(2.0 * np.pi)
-        )
-        neg_log_lh = neg_log_lh.reshape(-1)
+        ).reshape(-1)
 
         return neg_log_lh

src/squlearn/optimizers/adam.py

@@ -1,4 +1,3 @@
-import abc
 from collections import deque
 import numpy as np
 
@@ -145,7 +144,7 @@ def minimize(
 
             x_updated = self.step(x=self.x, grad=gradient)
 
-            if bounds != None:
+            if bounds is not None:
                 x_updated = np.clip(x_updated, bounds[:, 0], bounds[:, 1])
 
             if self.log_file is not None:

src/squlearn/qnn/loss/cross_entropy_loss.py

@@ -54,7 +54,11 @@ def value(self, value_dict: dict, **kwargs) -> float:
             raise AttributeError("CrossEntropyLoss requires ground_truth.")
 
         ground_truth = kwargs["ground_truth"]
-        weights = kwargs.get("weights") or np.ones_like(ground_truth)
+        weights = (
+            kwargs["weights"]
+            if "weights" in kwargs and kwargs["weights"] is not None
+            else np.ones_like(ground_truth)
+        )
 
         probability_values = np.clip(value_dict["f"], self._eps, 1.0 - self._eps)
         if probability_values.ndim == 1:
@@ -94,7 +98,11 @@ def gradient(
             raise AttributeError("CrossEntropyLoss requires ground_truth.")
 
         ground_truth = kwargs["ground_truth"]
-        weights = kwargs.get("weights") or np.ones_like(ground_truth)
+        weights = (
+            kwargs["weights"]
+            if "weights" in kwargs and kwargs["weights"] is not None
+            else np.ones_like(ground_truth)
+        )
         multiple_output = kwargs.get("multiple_output", False)
 
         probability_values = np.clip(value_dict["f"], self._eps, 1.0 - self._eps)

src/squlearn/qnn/loss/squared_loss.py

@@ -53,7 +53,11 @@ def value(self, value_dict: dict, **kwargs) -> float:
         if "ground_truth" not in kwargs:
             raise AttributeError("SquaredLoss requires ground_truth.")
         ground_truth = kwargs["ground_truth"]
-        weights = kwargs.get("weights") or np.ones_like(ground_truth)
+        weights = (
+            kwargs["weights"]
+            if "weights" in kwargs and kwargs["weights"] is not None
+            else np.ones_like(ground_truth)
+        )
         return np.sum(np.multiply(np.square(value_dict["f"] - ground_truth), weights))
 
     def variance(self, value_dict: dict, **kwargs) -> float:
@@ -76,7 +80,11 @@ def variance(self, value_dict: dict, **kwargs) -> float:
         if "ground_truth" not in kwargs:
             raise AttributeError("SquaredLoss requires ground_truth.")
         ground_truth = kwargs["ground_truth"]
-        weights = kwargs.get("weights") or np.ones_like(ground_truth)
+        weights = (
+            kwargs["weights"]
+            if "weights" in kwargs and kwargs["weights"] is not None
+            else np.ones_like(ground_truth)
+        )
 
         diff_square = np.multiply(weights, np.square(value_dict["f"] - ground_truth))
         return np.sum(4 * np.multiply(diff_square, value_dict["var"]))

tests/encoding_circuit/circuit_library/test_chebyshev_pqc.py

@@ -6,6 +6,76 @@
 from squlearn.encoding_circuit.encoding_circuit_base import EncodingSlotsMismatchError
 from squlearn.kernel.lowlevel_kernel import FidelityKernel
 from squlearn.kernel import QGPR
+from tests.qiskit_circuit_equivalence import assert_circuits_equal
+
+
+def _build_expected_chebyshev_circuit(
+    num_qubits: int,
+    num_layers: int,
+    closed: bool,
+    entangling_gate: str,
+    nonlinearity: str,
+    features: np.ndarray,
+    parameters: np.ndarray,
+):
+    if nonlinearity == "arccos":
+
+        def mapping(a, x):
+            return a * np.arccos(x)
+
+    else:
+
+        def mapping(a, x):
+            return a * np.arctan(x)
+
+    QC = QuantumCircuit(num_qubits)
+    index_offset = 0
+    feature_offset = 0
+
+    if entangling_gate not in ["crz", "rzz"]:
+        raise ValueError("Unknown entangling gate")
+
+    # basis change at beginning
+    for i in range(num_qubits):
+        QC.ry(parameters[index_offset % len(parameters)], i)
+        index_offset += 1
+
+    for _ in range(num_layers):
+        # chebyshev rx encodings
+        for i in range(num_qubits):
+            QC.rx(
+                mapping(
+                    parameters[index_offset % len(parameters)],
+                    features[feature_offset % len(features)],
+                ),
+                i,
+            )
+            index_offset += 1
+            feature_offset += 1
+
+        # even pairs (0,1), (2,3), ...
+        for i in range(0, num_qubits + (1 if closed else 0) - 1, 2):
+            if entangling_gate == "crz":
+                QC.crz(parameters[index_offset % len(parameters)], i, (i + 1) % num_qubits)
+            else:
+                QC.rzz(parameters[index_offset % len(parameters)], i, (i + 1) % num_qubits)
+            index_offset += 1
+
+        # odd pairs (1,2), (3,4), ...
+        if num_qubits > 2:
+            for i in range(1, num_qubits + (1 if closed else 0) - 1, 2):
+                if entangling_gate == "crz":
+                    QC.crz(parameters[index_offset % len(parameters)], i, (i + 1) % num_qubits)
+                else:
+                    QC.rzz(parameters[index_offset % len(parameters)], i, (i + 1) % num_qubits)
+                index_offset += 1
+
+    # final basis change
+    for i in range(num_qubits):
+        QC.ry(parameters[index_offset % len(parameters)], i)
+        index_offset += 1
+
+    return QC
 
 
 class TestChebyshevPQC:
@@ -133,3 +203,45 @@ def test_feature_consistency(self):
 
         with pytest.raises(ValueError):
             circuit.get_circuit(features, params)
+
+    @pytest.mark.parametrize(
+        "num_qubits,num_layers,closed,entangling_gate,nonlinearity",
+        [
+            (2, 1, True, "crz", "arccos"),
+            (3, 1, False, "crz", "arccos"),
+            (3, 2, True, "rzz", "arctan"),
+            (4, 2, False, "rzz", "arccos"),
+        ],
+    )
+    def test_get_circuit_matches_ground_truth(
+        self, num_qubits, num_layers, closed, entangling_gate, nonlinearity
+    ):
+
+        circuit = ChebyshevPQC(
+            num_qubits=num_qubits,
+            num_layers=num_layers,
+            closed=closed,
+            entangling_gate=entangling_gate,
+            nonlinearity=nonlinearity,
+        )
+
+        num_encoding_slots = circuit.num_encoding_slots
+        num_features = min(2, num_encoding_slots) if num_encoding_slots >= 2 else 1
+        features = np.linspace(-0.9, 0.9, num_features)
+
+        rng = np.random.RandomState(42)
+        parameters = rng.uniform(-np.pi, np.pi, size=circuit.num_parameters)
+
+        qc_actual = circuit.get_circuit(features=features, parameters=parameters)
+
+        qc_expected = _build_expected_chebyshev_circuit(
+            num_qubits=num_qubits,
+            num_layers=num_layers,
+            closed=closed,
+            entangling_gate=entangling_gate,
+            nonlinearity=nonlinearity,
+            features=features,
+            parameters=parameters,
+        )
+
+        assert_circuits_equal(qc_actual, qc_expected)

tests/encoding_circuit/circuit_library/test_chebyshev_rx.py

@@ -7,6 +7,58 @@
 from squlearn.encoding_circuit.encoding_circuit_base import EncodingSlotsMismatchError
 from squlearn.kernel.lowlevel_kernel import FidelityKernel
 from squlearn.kernel import QGPR
+from tests.qiskit_circuit_equivalence import assert_circuits_equal
+
+
+def _build_expected_chebyshev_rx_circuit(
+    num_qubits: int,
+    num_layers: int,
+    closed: bool,
+    nonlinearity: str,
+    features: np.ndarray,
+    parameters: np.ndarray,
+):
+    if nonlinearity == "arccos":
+
+        def mapping(a, x):
+            return a * np.arccos(x)
+
+    else:
+
+        def mapping(a, x):
+            return a * np.arctan(x)
+
+    QC = QuantumCircuit(num_qubits)
+    index_offset = 0
+    feature_offset = 0
+
+    def entangle_layer_local(QC_local: QuantumCircuit) -> QuantumCircuit:
+        for i in range(0, num_qubits + (1 if closed else 0) - 1, 2):
+            QC_local.cx(i, (i + 1) % num_qubits)
+        if num_qubits > 2:
+            for i in range(1, num_qubits + (1 if closed else 0) - 1, 2):
+                QC_local.cx(i, (i + 1) % num_qubits)
+        return QC_local
+
+    for _ in range(num_layers):
+        for i in range(num_qubits):
+            QC.rx(
+                mapping(
+                    parameters[index_offset % len(parameters)],
+                    features[feature_offset % len(features)],
+                ),
+                i,
+            )
+            index_offset += 1
+            feature_offset += 1
+
+        for i in range(num_qubits):
+            QC.rx(parameters[index_offset % len(parameters)], i)
+            index_offset += 1
+
+        QC = entangle_layer_local(QC)
+
+    return QC
 
 
 class TestChebyshevRx:
@@ -124,3 +176,43 @@ def test_feature_consistency(self):
 
         with pytest.raises(ValueError):
             circuit.get_circuit(features, params)
+
+    @pytest.mark.parametrize(
+        "num_qubits,num_layers,closed,nonlinearity",
+        [
+            (2, 1, False, "arccos"),
+            (3, 1, True, "arccos"),
+            (3, 2, False, "arctan"),
+            (4, 2, True, "arctan"),
+        ],
+    )
+    def test_chebyshev_rx_get_circuit_matches_ground_truth(
+        self, num_qubits, num_layers, closed, nonlinearity
+    ):
+
+        circuit = ChebyshevRx(
+            num_qubits=num_qubits,
+            num_layers=num_layers,
+            closed=closed,
+            nonlinearity=nonlinearity,
+        )
+
+        num_encoding_slots = circuit.num_encoding_slots
+        num_features = min(2, num_encoding_slots) if num_encoding_slots >= 2 else 1
+        features = np.linspace(-0.9, 0.9, num_features)
+
+        rng = np.random.RandomState(42)
+        parameters = rng.uniform(-np.pi, np.pi, size=circuit.num_parameters)
+
+        qc_actual = circuit.get_circuit(features=features, parameters=parameters)
+
+        qc_expected = _build_expected_chebyshev_rx_circuit(
+            num_qubits=num_qubits,
+            num_layers=num_layers,
+            closed=closed,
+            nonlinearity=nonlinearity,
+            features=features,
+            parameters=parameters,
+        )
+
+        assert_circuits_equal(qc_actual, qc_expected)