squlearn 0.8.2__tar.gz → 0.8.3__tar.gz

{squlearn-0.8.2 → squlearn-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squlearn
-Version: 0.8.2
+Version: 0.8.3
 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.8.2 → squlearn-0.8.3}/docs/modules/classes.rst

@@ -168,6 +168,7 @@ Quantum Kernel Core
 
    kernel.lowlevel_kernel.FidelityKernel
    kernel.lowlevel_kernel.ProjectedQuantumKernel
+   kernel.lowlevel_kernel.KernelOptimizer
 
 .. automodule:: squlearn.kernel.loss
     :no-members:

{squlearn-0.8.2 → squlearn-0.8.3}/src/squlearn/__init__.py

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

{squlearn-0.8.2 → squlearn-0.8.3}/src/squlearn/encoding_circuit/encoding_circuit_base.py

@@ -73,7 +73,9 @@ class EncodingCircuitBase:
         parameters: Union[ParameterVector, np.ndarray],
     ) -> QuantumCircuit:
         """
-        Return the circuit encoding circuit (has to be overwritten, otherwise a NotImplementedError is thrown)
+        Return the circuit encoding circuit
+
+        Has to be overwritten, otherwise a NotImplementedError is thrown
 
         Args:
             features Union[ParameterVector,np.ndarray]: Input vector of the features
@@ -154,13 +156,78 @@ class EncodingCircuitBase:
 
         return self
 
+    def inverse(self):
+        """
+        Returns the inverse of the encoding circuit.
+
+        Returns:
+            The inverse of the encoding circuit
+        """
+
+        class InvertedEncodingCircuit(EncodingCircuitBase):
+            def __init__(self, encoding_circuit: EncodingCircuitBase):
+                super().__init__(encoding_circuit.num_qubits, encoding_circuit.num_features)
+                self._encoding_circuit = encoding_circuit
+
+            @property
+            def num_parameters(self) -> int:
+                """Returns the number of trainable parameters of the encoding circuit."""
+                return self._encoding_circuit.num_parameters
+
+            @property
+            def parameter_bounds(self) -> np.ndarray:
+                """Returns the bounds of the trainable parameters of the encoding circuit."""
+                return self._encoding_circuit.parameter_bounds
+
+            @property
+            def feature_bounds(self) -> np.ndarray:
+                """Returns the bounds of the features of the encoding circuit."""
+                return self._encoding_circuit.feature_bounds
+
+            def generate_initial_parameters(self, seed: Union[int, None] = None) -> np.ndarray:
+                """
+                Generates random parameters for the encoding circuit
+
+                Args:
+                    seed (Union[int,None]): Seed for the random number generator
+
+                Return:
+                    Returns the randomly generated parameters
+                """
+                return self._encoding_circuit.generate_initial_parameters(seed)
+
+            def get_circuit(
+                self,
+                features: Union[ParameterVector, np.ndarray],
+                parameters: Union[ParameterVector, np.ndarray],
+            ) -> QuantumCircuit:
+                """
+                Returns the inverse circuit of the encoding circuit
+
+                Args:
+                    features Union[ParameterVector,np.ndarray]: Input vector of the features
+                        from which the gate inputs are obtained
+                    param_vec Union[ParameterVector,np.ndarray]: Input vector of the parameters
+                        from which the gate inputs are obtained
+
+                Return:
+                    Returns the inverse circuit of the encoding circuit in qiskit QuantumCircuit
+                    format
+                """
+                circ = self._encoding_circuit.get_circuit(features, parameters)
+                return circ.inverse()
+
+        return InvertedEncodingCircuit(self)
+
     def __mul__(self, x):
         return self.__add__(x)
 
     def __add__(self, x):
+        return self.compose(x, concatenate_features=False, concatenate_parameters=True)
+
+    def compose(self, x, concatenate_features=True, concatenate_parameters=False):
         """
-        Overwrites the a + b function, such that the addition of
-        encoding circuits returns the composition of both encoding circuits.
+        Composition of encoding circuits with options for handling features and parameters
 
         Number of qubits and features have to be equal in both encoding circuits!
         The special function and properties of the both encoding circuits are lost
@@ -182,7 +249,8 @@ class EncodingCircuitBase:
             Special class for composed encoding circuits.
 
             Args:
-                num_qubits: num qubits for both encoding circuits (necessary for scikit-learn interface)
+                num_qubits (int): num qubits for both encoding circuits
+                    (necessary for scikit-learn interface)
                 ec1 (EncodingCircuitBase): right / first encoding circuit
                 ec2 (EncodingCircuitBase): left / second encoding circuit
             """
@@ -226,7 +294,18 @@ class EncodingCircuitBase:
 
                 Is equal to the sum of both trainable parameters.
                 """
-                return self.ec1.num_parameters + self.ec2.num_parameters
+                if concatenate_parameters:
+                    return self.ec1.num_parameters + self.ec2.num_parameters
+                else:
+                    return max(self.ec1.num_parameters, self.ec2.num_parameters)
+
+            @property
+            def num_features(self) -> int:
+                """The dimension of the features in the encoding circuit."""
+                if concatenate_features:
+                    return self.ec1.num_features + self.ec2.num_features
+                else:
+                    return max(self.ec1.num_features, self.ec2.num_features)
 
             @property
             def parameter_bounds(self) -> np.ndarray:
@@ -234,9 +313,47 @@ class EncodingCircuitBase:
 
                 Is equal to the sum of both bounds.
                 """
-                return np.concatenate(
-                    (self.ec1.parameter_bounds, self.ec2.parameter_bounds), axis=0
-                )
+                if concatenate_parameters:
+                    return np.concatenate(
+                        (self.ec1.parameter_bounds, self.ec2.parameter_bounds), axis=0
+                    )
+                else:
+                    # We compare self.ec1.parameter_bounds and self.ec2.parameter_bounds,
+                    # we return a new array,
+                    # with the shape of the largest array, and the minimum values of the two arrays
+                    # for the first column (lower bound),
+                    # and the maximum values of the two arrays for the second column (upper bound)
+
+                    # Extend parameter bounds to the shape of the largest array with np.pad
+                    parameter_bounds1_extended = np.pad(
+                        self.ec1.parameter_bounds,
+                        ((0, self.num_parameters - self.ec1.num_parameters), (0, 0)),
+                        constant_values=np.nan,
+                    )
+                    parameter_bounds2_extended = np.pad(
+                        self.ec2.parameter_bounds,
+                        ((0, self.num_parameters - self.ec2.num_parameters), (0, 0)),
+                        constant_values=np.nan,
+                    )
+
+                    # Compute the minimum lower bound values for the first column and maximum upper
+                    # bounds for the second column
+                    parameter_bounds3_first_col = np.nanmin(
+                        np.array(
+                            [parameter_bounds1_extended[:, 0], parameter_bounds2_extended[:, 0]]
+                        ),
+                        axis=0,
+                    )
+                    parameter_bounds3_second_col = np.nanmax(
+                        np.array(
+                            [parameter_bounds1_extended[:, 1], parameter_bounds2_extended[:, 1]]
+                        ),
+                        axis=0,
+                    )
+                    # Stack the results into the final array
+                    return np.column_stack(
+                        (parameter_bounds3_first_col, parameter_bounds3_second_col)
+                    )
 
             @property
             def feature_bounds(self) -> np.ndarray:
@@ -274,13 +391,20 @@ class EncodingCircuitBase:
                     Returns the randomly generated parameters
                 """
 
-                return np.concatenate(
-                    (
-                        self.ec1.generate_initial_parameters(seed),
-                        self.ec2.generate_initial_parameters(seed),
-                    ),
-                    axis=0,
-                )
+                if concatenate_parameters:
+                    return np.concatenate(
+                        (
+                            self.ec1.generate_initial_parameters(seed),
+                            self.ec2.generate_initial_parameters(seed),
+                        ),
+                        axis=0,
+                    )
+                else:
+                    if self.num_parameters == 0:
+                        return np.array([])
+                    r = np.random.RandomState(seed)
+                    bounds = self.parameter_bounds
+                    return r.uniform(low=bounds[:, 0], high=bounds[:, 1])
 
             def get_params(self, deep: bool = True) -> dict:
                 """
@@ -291,7 +415,7 @@ class EncodingCircuitBase:
 
                 Args:
                     deep (bool): If True, also the parameters for
-                                 contained objects are returned (default=True).
+                                contained objects are returned (default=True).
 
                 Return:
                     Dictionary with hyper-parameters and values.
@@ -357,14 +481,35 @@ class EncodingCircuitBase:
                         from which the gate inputs are obtained
 
                 Return:
-                    Returns the circuit of the composed encoding circuits in qiskit QuantumCircuit format
+                    Returns the circuit of the composed encoding circuits in qiskit QuantumCircuit
+                    format
                 """
-
-                circ1 = self.ec1.get_circuit(
-                    features[: self.ec1.num_features], parameters[: self.ec1.num_parameters]
-                )
+                if concatenate_features:
+                    features_c1, features_c2 = (
+                        features[: self.ec1.num_features],
+                        features[self.ec1.num_features :],
+                    )
+                else:
+                    features_c1, features_c2 = (
+                        features[: self.ec1.num_features],
+                        features[: self.ec2.num_features],
+                    )
+
+                if concatenate_parameters:
+                    parameters_c1, parameters_c2 = (
+                        parameters[: self.ec1.num_parameters],
+                        parameters[self.ec1.num_parameters :],
+                    )
+                else:
+                    parameters_c1, parameters_c2 = (
+                        parameters[: self.ec1.num_parameters],
+                        parameters[: self.ec1.num_parameters],
+                    )
+
+                circ1 = self.ec1.get_circuit(features_c1, parameters_c1)
                 circ2 = self.ec2.get_circuit(
-                    features[: self.ec2.num_features], parameters[self.ec1.num_parameters :]
+                    features_c2,
+                    parameters_c2,  # Only line that changes, to include the new features
                 )
 
                 return circ1.compose(circ2, range(self.ec1.num_qubits))

{squlearn-0.8.2 → squlearn-0.8.3}/src/squlearn/encoding_circuit/transpiled_encoding_circuit.py

@@ -49,8 +49,8 @@ class TranspiledEncodingCircuit(EncodingCircuitBase):
         self._backend = backend
         self._transpile_func = transpile_func
 
-        self._x = ParameterVector("x", self._encoding_circuit.num_features)
-        self._p = ParameterVector("p", self._encoding_circuit.num_parameters)
+        self._x = ParameterVector("x_", self._encoding_circuit.num_features)
+        self._p = ParameterVector("p_", self._encoding_circuit.num_parameters)
 
         self._circuit = decompose_to_std(self._encoding_circuit.get_circuit(self._x, self._p))
 

{squlearn-0.8.2 → squlearn-0.8.3}/src/squlearn/kernel/lowlevel_kernel/fidelity_kernel.py

@@ -18,10 +18,11 @@ from ...util.executor import Executor, BaseSamplerV2
 from ...util.data_preprocessing import convert_to_float64
 
 from .fidelity_kernel_pennylane import FidelityKernelPennyLane
+from .fidelity_kernel_expectation_value import FidelityKernelExpectationValue
 
 
 class FidelityKernel(KernelMatrixBase):
-    """
+    r"""
     Fidelity Quantum Kernel.
 
     The Fidelity Quantum Kernel is a based on the overlap of the quantum states.
@@ -30,7 +31,7 @@ class FidelityKernel(KernelMatrixBase):
 
     .. math::
 
-        K(x,y) = |\\langle \\phi(x) | \\phi(y) \\rangle|^2
+        K(x,y) = |\langle \phi(x) | \phi(y) \rangle|^2
 
     This class wraps to the respective Quantum Kernel implementations from `Qiskit Machine Learning
     <https://qiskit.org/ecosystem/machine-learning/apidocs/qiskit_machine_learning.kernels.html>`_.
@@ -55,6 +56,12 @@ class FidelityKernel(KernelMatrixBase):
             Option for choosing different regularization techniques (``"thresholding"`` or
             ``"tikhonov"``) after Ref. [4] for the training kernel matrix, prior to  solving the
             linear system in the ``fit()``-procedure.
+        use_expectation (bool, default=False):
+            Option for using the expectation value of a QNN circuit that computes the fidelity
+            as the expectation value of the observable
+            :math:`P_0 = |0\rangle\langle0|^{\otimes n}`.
+            This is not very efficient in simulation, but allows the computation of
+            derivatives of the kernel.
 
     References:
         [1]: `Havlicek et al., Supervised learning with quantum-enhanced feature spaces,
@@ -86,6 +93,8 @@ class FidelityKernel(KernelMatrixBase):
         initial_parameters: Union[np.ndarray, None] = None,
         parameter_seed: Union[int, None] = 0,
         regularization: Union[str, None] = None,
+        use_expectation: bool = False,
+        caching: bool = False,
     ) -> None:
         super().__init__(
             encoding_circuit, executor, initial_parameters, parameter_seed, regularization
@@ -94,72 +103,82 @@ class FidelityKernel(KernelMatrixBase):
         self._quantum_kernel = None
         self._evaluate_duplicates = evaluate_duplicates
         self._mit_depol_noise = mit_depol_noise
+        self._use_expectation = use_expectation
 
         if self.num_parameters > 0:
             self._parameter_vector = ParameterVector("p", self.num_parameters)
         else:
             self._parameter_vector = None
 
-        if self._executor.quantum_framework == "pennylane":
-
-            self._quantum_kernel = FidelityKernelPennyLane(
+        if self._use_expectation:
+            self._quantum_kernel = FidelityKernelExpectationValue(
                 encoding_circuit=self._encoding_circuit,
                 executor=self._executor,
                 evaluate_duplicates=self._evaluate_duplicates,
+                caching=caching,
             )
 
-        elif self._executor.quantum_framework == "qiskit":
+        else:
+            if self._executor.quantum_framework == "pennylane":
 
-            # Underscore necessary to avoid name conflicts with the Qiskit quantum kernel
-            self._feature_vector = ParameterVector("x_", self.num_features)
+                self._quantum_kernel = FidelityKernelPennyLane(
+                    encoding_circuit=self._encoding_circuit,
+                    executor=self._executor,
+                    evaluate_duplicates=self._evaluate_duplicates,
+                )
 
-            self._enc_circ = self._encoding_circuit.get_circuit(
-                self._feature_vector, self._parameter_vector
-            )
+            elif self._executor.quantum_framework == "qiskit":
+
+                # Underscore necessary to avoid name conflicts with the Qiskit quantum kernel
+                self._feature_vector = ParameterVector("x_", self.num_features)
 
-            # Automatic select backend if not chosen
-            if not self._executor.backend_chosen:
-                self._enc_circ, _ = self._executor.select_backend(self._enc_circ)
-
-            if self._executor.is_statevector:
-                if self._parameter_vector is None:
-                    self._quantum_kernel = FidelityStatevectorKernel(
-                        feature_map=self._enc_circ,
-                        shots=self._executor.get_shots(),
-                        enforce_psd=False,
-                    )
+                self._enc_circ = self._encoding_circuit.get_circuit(
+                    self._feature_vector, self._parameter_vector
+                )
+
+                # Automatic select backend if not chosen
+                if not self._executor.backend_chosen:
+                    self._enc_circ, _ = self._executor.select_backend(self._enc_circ)
+
+                if self._executor.is_statevector:
+                    if self._parameter_vector is None:
+                        self._quantum_kernel = FidelityStatevectorKernel(
+                            feature_map=self._enc_circ,
+                            shots=self._executor.get_shots(),
+                            enforce_psd=False,
+                        )
+                    else:
+                        self._quantum_kernel = TrainableFidelityStatevectorKernel(
+                            feature_map=self._enc_circ,
+                            training_parameters=self._parameter_vector,
+                            shots=self._executor.get_shots(),
+                            enforce_psd=False,
+                        )
                 else:
-                    self._quantum_kernel = TrainableFidelityStatevectorKernel(
-                        feature_map=self._enc_circ,
-                        training_parameters=self._parameter_vector,
-                        shots=self._executor.get_shots(),
-                        enforce_psd=False,
-                    )
+                    sampler = self._executor.get_sampler()
+                    if isinstance(sampler, BaseSamplerV2):
+                        raise ValueError(
+                            "Incompatible Qiskit version for Fidelity-Kernel calculation with Qiskit "
+                            "Algorithms. Please downgrade to Qiskit 1.0 or consider using PennyLane."
+                        )
+                    fidelity = ComputeUncompute(sampler=sampler)
+                    if self._parameter_vector is None:
+                        self._quantum_kernel = FidelityQuantumKernel(
+                            feature_map=self._enc_circ,
+                            fidelity=fidelity,
+                            evaluate_duplicates=self._evaluate_duplicates,
+                            enforce_psd=False,
+                        )
+                    else:
+                        self._quantum_kernel = TrainableFidelityQuantumKernel(
+                            feature_map=self._enc_circ,
+                            fidelity=fidelity,
+                            training_parameters=self._parameter_vector,
+                            evaluate_duplicates=self._evaluate_duplicates,
+                            enforce_psd=False,
+                        )
             else:
-                sampler = self._executor.get_sampler()
-                if isinstance(sampler, BaseSamplerV2):
-                    raise ValueError(
-                        "Incompatible Qiskit version for Fidelity-Kernel calculation with Qiskit "
-                        "Algorithms. Please downgrade to Qiskit 1.0 or consider using PennyLane."
-                    )
-                fidelity = ComputeUncompute(sampler=sampler)
-                if self._parameter_vector is None:
-                    self._quantum_kernel = FidelityQuantumKernel(
-                        feature_map=self._enc_circ,
-                        fidelity=fidelity,
-                        evaluate_duplicates=self._evaluate_duplicates,
-                        enforce_psd=False,
-                    )
-                else:
-                    self._quantum_kernel = TrainableFidelityQuantumKernel(
-                        feature_map=self._enc_circ,
-                        fidelity=fidelity,
-                        training_parameters=self._parameter_vector,
-                        evaluate_duplicates=self._evaluate_duplicates,
-                        enforce_psd=False,
-                    )
-        else:
-            raise RuntimeError("Invalid quantum framework!")
+                raise RuntimeError("Invalid quantum framework!")
 
     def get_params(self, deep: bool = True) -> dict:
         """
@@ -263,7 +282,6 @@ class FidelityKernel(KernelMatrixBase):
                     "Parameters have to been set with assign_parameters or as initial parameters!"
                 )
             self._quantum_kernel.assign_training_parameters(self._parameters)
-
         kernel_matrix = self._quantum_kernel.evaluate(x, y)
 
         if self._mit_depol_noise is not None:
@@ -285,6 +303,36 @@ class FidelityKernel(KernelMatrixBase):
             kernel_matrix = self._regularize_matrix(kernel_matrix)
         return kernel_matrix
 
+    def evaluate_derivatives(
+        self, x: np.ndarray, y: np.ndarray = None, values: Union[str, tuple] = "dKdx"
+    ) -> dict:
+        """Evaluates the Fidelity Kernel and its derivatives for the given data points x and y.
+
+        Args:
+            x (np.ndarray): Data points x
+            y (np.ndarray): Data points y, if None y = x is used
+            values (Union[str, tuple]): Values to evaluate. Can be a string or a tuple of strings.
+                Possible values are:
+                ``dKdx``, ``dKdy``, ``dKdxdx``, ``dKdydy``, ``dKdxdy``, ``dKdydx``, ``dKdp``
+                and ``jacobian``.
+        Returns:
+            Dictionary with the evaluated values
+        """
+
+        if self._parameter_vector is not None:
+            if self._parameters is None:
+                raise ValueError(
+                    "Parameters have to been set with assign_parameters or as initial parameters!"
+                )
+            self._quantum_kernel.assign_training_parameters(self._parameters)
+
+        if self._use_expectation:
+            return self._quantum_kernel.evaluate_derivatives(x, y, values)
+        else:
+            raise NotImplementedError(
+                "Derivatives are only implemented for the option use expectation=True"
+            )
+
     def _get_msplit_kernel(self, kernel: np.ndarray) -> np.ndarray:
         """Function to mitigate depolarizing noise using msplit method.