squlearn 0.7.2__tar.gz → 0.7.4__tar.gz

{squlearn-0.7.2 → squlearn-0.7.4}/CITATION.cff

@@ -27,11 +27,15 @@ preferred-citation:
       given-names: Frederic
       orcid: https://orcid.org/0009-0008-6240-8390
       affiliation: Fraunhofer Institute for Manufacturing Engineering and Automation IPA
+    - family-names: Hagelüken
+      given-names: Manuel
+      orcid: https://orcid.org/0009-0007-9852-3190
+      affilliation: Fraunhofer Institute for Manufacturing Engineering and Automation IPA
     - family-names: Roth
       given-names: Marco
       orcid: https://orcid.org/0000-0002-1276-5655
       affiliation: Fraunhofer Institute for Manufacturing Engineering and Automation IPA
   year: 2023
   month: 11
-  doi: 10.48550/arXiv.2311.08990
+  doi: 10.48550/arXiv.2311.08990 
   url: https://arxiv.org/abs/2311.08990

{squlearn-0.7.2 → squlearn-0.7.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: squlearn
-Version: 0.7.2
+Version: 0.7.4
 Summary: A library for quantum machine learning following the scikit-learnstandard.
 Keywords: quantum,machine learning,qml
-Author-email: David Kreplin <david.kreplin@ipa.fraunhofer.de>, Frederic Rapp <frederic.rapp@ipa.fraunhofer.de>, Marco Roth <marco.roth@ipa.fraunhofer.de>, Jan Schnabel <jan.schnabel@ipa.fraunhofer.de>, Moritz Willmann <moritz.willmann@ipa.fraunhofer.de>
+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>
 Maintainer-email: David Kreplin <david.kreplin@ipa.fraunhofer.de>, Moritz Willmann <moritz.willmann@ipa.fraunhofer.de>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -20,7 +20,7 @@ Requires-Dist: qiskit-machine-learning>=0.6.1
 Requires-Dist: pennylane>=0.34.0
 Requires-Dist: scipy>=1.5
 Requires-Dist: scikit-learn>=1.0
-Requires-Dist: scikit-optimize>=0.8
+Requires-Dist: bayesian-optimization>=1.4.3
 Requires-Dist: tqdm>=4.0
 Requires-Dist: black ; extra == "dev"
 Requires-Dist: flit ; extra == "dev"
@@ -97,7 +97,7 @@ sQUlearn is released under the [Apache License 2.0](https://github.com/sQUlearn/
 ## Cite sQUlearn
 If you use sQUlearn in your work, please cite our paper:
 
-> Kreplin, D. A., Willmann, M., Schnabel, J., Rapp, F., & Roth, M. (2023). sQUlearn - A Python Library for Quantum Machine Learning. [https://doi.org/10.48550/arXiv.2311.08990](https://doi.org/10.48550/arXiv.2311.08990)
+> Kreplin, D. A., Willmann, M., Schnabel, J., Rapp, F., Hagelüken, M., & Roth, M. (2023). sQUlearn - A Python Library for Quantum Machine Learning. [https://doi.org/10.48550/arXiv.2311.08990](https://doi.org/10.48550/arXiv.2311.08990)
 
 ## Contact
 This project is maintained by the quantum computing group at the Fraunhofer Institute for Manufacturing Engineering and Automation IPA.

{squlearn-0.7.2 → squlearn-0.7.4}/README.md

@@ -49,7 +49,7 @@ sQUlearn is released under the [Apache License 2.0](https://github.com/sQUlearn/
 ## Cite sQUlearn
 If you use sQUlearn in your work, please cite our paper:
 
-> Kreplin, D. A., Willmann, M., Schnabel, J., Rapp, F., & Roth, M. (2023). sQUlearn - A Python Library for Quantum Machine Learning. [https://doi.org/10.48550/arXiv.2311.08990](https://doi.org/10.48550/arXiv.2311.08990)
+> Kreplin, D. A., Willmann, M., Schnabel, J., Rapp, F., Hagelüken, M., & Roth, M. (2023). sQUlearn - A Python Library for Quantum Machine Learning. [https://doi.org/10.48550/arXiv.2311.08990](https://doi.org/10.48550/arXiv.2311.08990)
 
 ## Contact
 This project is maintained by the quantum computing group at the Fraunhofer Institute for Manufacturing Engineering and Automation IPA.

{squlearn-0.7.2 → squlearn-0.7.4}/pyproject.toml

@@ -7,10 +7,11 @@ name = "squlearn"
 readme = "README.md"
 authors = [
     {name = "David Kreplin", email = "david.kreplin@ipa.fraunhofer.de"},
+    {name = "Moritz Willmann", email = "moritz.willmann@ipa.fraunhofer.de"},
+    {name = "Jan Schnabel", email = "jan.schnabel@ipa.fraunhofer.de"},
     {name = "Frederic Rapp", email = "frederic.rapp@ipa.fraunhofer.de"},
+    {name = "Manuel Hagelüken", email = "manuel.hagelueken@ipa.fraunhofer.de"},
     {name = "Marco Roth", email = "marco.roth@ipa.fraunhofer.de"},
-    {name = "Jan Schnabel", email = "jan.schnabel@ipa.fraunhofer.de"},
-    {name = "Moritz Willmann", email = "moritz.willmann@ipa.fraunhofer.de"},
 ]
 maintainers = [
     {name = "David Kreplin", email = "david.kreplin@ipa.fraunhofer.de"},
@@ -34,7 +35,7 @@ dependencies = [
     "pennylane>=0.34.0",
     "scipy>=1.5",
     "scikit-learn>=1.0",
-    "scikit-optimize>=0.8",
+    "bayesian-optimization>=1.4.3",
     "tqdm>=4.0",
 ]
 requires-python = ">=3.9"

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/__init__.py

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

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/encoding_circuit/layered_encoding_circuit.py

@@ -1,14 +1,15 @@
+import numpy as np
+from typing import Union, Callable
+import copy
+
+import sympy as sp
+
 from qiskit import QuantumCircuit
 from qiskit.circuit import ParameterVector
 from qiskit.circuit.library import RXGate, RYGate, RZGate, PhaseGate, UGate
 from qiskit.circuit.library import CPhaseGate, CHGate, CXGate, CYGate, CZGate
 from qiskit.circuit.library import SwapGate, CRXGate, CRYGate, CRZGate, RXXGate
 from qiskit.circuit.library import RYYGate, RZXGate, RZZGate, CUGate
-from typing import Union, Callable
-import copy
-
-# is needed for making encoding circuits with numpy functions using strings:
-import numpy as np
 
 from .encoding_circuit_base import EncodingCircuitBase
 
@@ -1268,15 +1269,31 @@ class LayeredPQC:
         """initializes a encoding circuit through a given string of gates"""
 
         def generate_function(map_string, args):
-            """Translates a string into a function"""
-            function_string = """\
-def math_function({var}):
-    return {func}
-            """.format(
-                func=map_string, var=args
-            )
-            exec(function_string, globals())
-            return math_function  # pylint: disable=undefined-variable
+            """Function for creating a callable function from a string
+
+            Args:
+                map_string (str): The string representation of the function
+                args (str): The string representation of the arguments of the function
+
+            Returns:
+                callable_function (function): The function that can be called with the arguments
+            """
+            # Split the argument string into individual variable names
+            arg_names = args.split(",")
+
+            # Remove "np." prefix
+            map_string = map_string.replace("np.", "")
+
+            # Create symbols for each variable
+            symbols = [sp.Symbol(arg) for arg in arg_names]
+
+            # Parse the map_string into a SymPy expression
+            expr = sp.sympify(map_string, evaluate=False)
+
+            # Create the function
+            callable_function = sp.lambdify(symbols, expr, modules=np)
+
+            return callable_function
 
         def get_closing_bracket_index(word, index):
             """gives to an open round bracket '(' the location of the closing bracket. This works especially, if there are more than one open brackets."""

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/optimizers/sglbo.py

@@ -1,7 +1,6 @@
 from collections import deque
 import numpy as np
-from skopt import gp_minimize
-from scipy.optimize import minimize
+from bayes_opt import BayesianOptimization, UtilityFunction
 
 from .approximated_gradients import FiniteDiffGradient
 from .optimizer_base import OptimizerBase, SGDMixin, default_callback, OptimizerResult
@@ -19,13 +18,9 @@ class SGLBO(OptimizerBase, SGDMixin):
     * **num_average** (int): Number of gradients to average (default: 1)
     * **bo_n_calls** (int): Number of iterations for the Bayesian Optimization (default: 20)
     * **bo_bounds** (List): Lower and upper bound for the search space for the Bayesian Optimization for each dimension. Each bound should be provided as a tupel (default: (0.0, 0.3))
-    * **bo_bounds_fac** (float): Factor to adapt the bounds based on the gradient information (default: None)
     * **bo_n_initial_points** (int): Number of initial points for the Bayesian Optimization (default: 10)
-    * **bo_x0_points** (list of lists): Initial input points (default: None)
-    * **bo_aqc_optimizer** (str): Method to minimize the acquisition function. "sampling" or "lbfgs" (default: "lbfgs")
-    * **bo_acq_func** (str): Acquisition function for the Bayesian Optimization (default: "EI"). Valid values are: "LCB", "EI", "PI", "gp_hedge"
-    * **bo_noise** (float): Noise for noisy observations (default: "gaussian")
-    * **min_surrogate** (bool): If True, the surrogate model is minimized to find the optimal step size (default: False)
+    * **bo_acq_func** (str): Acquisition function for the Bayesian Optimization (default: "ei"). Valid values are: "ucb", "ei", "poi"
+    * **bo_xi** (float): Exploration-exploitation trade-off parameter for the Bayesian Optimization (default: 0.01)
     * **log_file** (str): File to log the optimization (default: None)
 
     Args:
@@ -44,15 +39,11 @@ class SGLBO(OptimizerBase, SGDMixin):
         self.maxiter_total = options.get("maxiter_total", self.maxiter)
         self.eps = options.get("eps", 0.01)
         self.bo_n_calls = options.get("bo_n_calls", 20)
-        self.bo_bounds = options.get("bo_bounds", [(0.0, 0.3)])
-        self.bo_aqc_func = options.get("bo_aqc_func", "EI")
-        self.bo_aqc_optimizer = options.get("bo_aqc_optimizer", "lbfgs")
+        self.bo_bounds = options.get("bo_bounds", (0.0, 0.3))
+        self.bo_aqc_func = options.get("bo_aqc_func", "ei")
+        self.bo_xi = options.get("bo_xi", 0.01)
         self.bo_n_initial_points = options.get("bo_n_initial_points", 10)
-        self.bo_x0_points = options.get("bo_x0_points")
-        self.bo_noise = options.get("bo_noise", "gaussian")
-        self.bo_bounds_fac = options.get("bo_bounds_fac", None)
         self.log_file = options.get("log_file", None)
-        self.min_surrogate = options.get("min_surrogate", False)
         self.num_average = options.get("num_average", 1)
 
         self.callback = callback
@@ -68,9 +59,7 @@ class SGLBO(OptimizerBase, SGDMixin):
                 f"bo_n_calls: {self.bo_n_calls}\n"
                 f"bo_bounds: {self.bo_bounds}\n"
                 f"bo_aqc_func: {self.bo_aqc_func}\n"
-                f"bo_aqc_optimizer: {self.bo_aqc_optimizer}\n"
                 f"bo_n_initial_points: {self.bo_n_initial_points}\n"
-                f"bo_x0_points: {self.bo_x0_points}\n"
             )
             output = " %9s  %13s  %13s  %13s \n" % ("Iteration", "f(x)", "Gradient", "Step")
             f.write(header)
@@ -116,16 +105,6 @@ class SGLBO(OptimizerBase, SGDMixin):
             self.gradient_deque.append(grad(self.x))
             gradient = np.average(self.gradient_deque, axis=0)
 
-            # adapt bounds and x0 based on the gradient
-            if (
-                self.bo_bounds is not None
-                and self.bo_x0_points is not None
-                and self.bo_bounds_fac is not None
-            ):
-                self.bo_bounds, self.bo_x0_points = self.__adapt_bounds(
-                    self.bo_bounds, self.bo_x0_points, gradient
-                )
-
             x_updated = self.step(x=self.x, grad=gradient)
 
             # check termination
@@ -178,72 +157,34 @@ class SGLBO(OptimizerBase, SGDMixin):
 
             return func(updated_point)
 
-        # bayesian optimization to estimate the step size in one dimension
-        res = gp_minimize(
-            step_size_cost,
-            self.bo_bounds,
-            n_calls=self.bo_n_calls,
-            acq_func=self.bo_aqc_func,
-            acq_optimizer=self.bo_aqc_optimizer,
-            x0=self.bo_x0_points,
-            n_jobs=-1,
-            random_state=0,
-            noise=self.bo_noise,
-            n_initial_points=self.bo_n_initial_points,
-        )
-
-        # minimize the surrogate model to find the optimal step size
-        if self.min_surrogate:
-
-            def func_surrogate(x):
-                reg = res.models[-1]
-                x = res.space.transform(x.reshape(1, -1))
-                return reg.predict(x.reshape(1, -1))[0]
-
-            res_surr = minimize(
-                func_surrogate, x0=res.x[0], method="Nelder-Mead", tol=1e-6, bounds=self.bo_bounds
-            )
-            x_val = res_surr.x
-        else:
-            x_val = res.x
-
-        return x_val
-
-    def __adapt_bounds(
-        self, current_bounds: list, current_x0: list, gradient: np.ndarray
-    ) -> tuple:
-        """
-        Function to adapt the bounds and initial points for gp_minimize based on the gradient information.
+        # Convert the minimization problem into a maximization problem
+        def neg_step_size_cost(x):
+            return -step_size_cost(x)
 
-        Args:
-            current_bounds (List): Current bounds for the search space.
-            current_x0 (List): Current initial points.
-            gradient (np.ndarray): Gradient of the objective function.
+        # Define the bounds for Bayesian Optimization
+        pbounds = {"x": self.bo_bounds}
 
-        Returns:
-            Tuple: Updated bounds for the search space and initial points.
-        """
+        acquisition_function = UtilityFunction(kind=self.bo_aqc_func, xi=self.bo_xi)
 
-        # Compute the magnitude of the gradient
-        grad_magnitude = np.linalg.norm(gradient)
-
-        # Update the bounds based on the gradient magnitude
-        updated_bounds = []
-        for bound in current_bounds:
-            lower = max(bound[0] - self.bo_bounds_fac * grad_magnitude, 0.0)
-            upper = bound[1] + self.bo_bounds_fac * grad_magnitude
-            updated_bounds.append((lower, upper))
+        # Initialize Bayesian Optimization
+        bo = BayesianOptimization(
+            f=neg_step_size_cost,
+            pbounds=pbounds,
+            verbose=0,
+            random_state=0,
+            allow_duplicate_points=True,
+        )
 
-        # Update the initial points based on the updated bounds and maintaining distribution
-        updated_x0 = []
+        # Perform the optimization
+        bo.maximize(
+            init_points=self.bo_n_initial_points,
+            n_iter=self.bo_n_calls,
+            acquisition_function=acquisition_function,
+        )
 
-        # Distribute the x0 points evenly within the updated bounds
-        for i in range(len(current_x0)):
-            t = i / len(current_x0)  # t goes from 0 to 1
-            updated_x0_point = [lower + t * (upper - lower) for (lower, upper) in updated_bounds]
-            updated_x0.append(updated_x0_point)
+        x_val = bo.max["params"]["x"]
 
-        return updated_bounds, updated_x0
+        return x_val
 
     def _log(self, fval, gradient, dx):
         """Function for creating a log entry of the optimization."""

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/qnn/loss.py

@@ -450,7 +450,7 @@ class SquaredLoss(LossBase):
         and ground_truth as
 
         .. math::
-           \sum_j \sum_i w_i \left(f\left(x_i\right)-f_ref\left(x_i\right)\right) \frac{\partial f(x_i)}{\partial p_j}
+           2\sum_j \sum_i w_i \left(f\left(x_i\right)-f_ref\left(x_i\right)\right) \frac{\partial f(x_i)}{\partial p_j}
 
         Args:
             value_dict (dict): Contains calculated values of the model

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/qnn/qnnc.py

@@ -138,6 +138,7 @@ class QNNClassifier(BaseQNN, ClassifierMixin):
             **kwargs,
         )
         self._label_binarizer = None
+        self.classes_ = None
 
     def predict(self, X: np.ndarray) -> np.ndarray:
         """Predict using the QNN.
@@ -189,13 +190,17 @@ class QNNClassifier(BaseQNN, ClassifierMixin):
         """
         if not self._is_fitted:
             self._label_binarizer = LabelBinarizer()
-            self._label_binarizer.fit(y)
-
-        if len(y.shape) == 1:
-            y = self._label_binarizer.transform(y).ravel()
+            y = self._label_binarizer.fit_transform(y)
+            self.classes_ = self._label_binarizer.classes_
         else:
             y = self._label_binarizer.transform(y)
 
+        if isinstance(self.operator, list) and len(self.operator) == 2 and y.shape[1] == 1:
+            y = np.hstack([1 - y, y])
+
+        if y.shape[1] == 1:
+            y = self._label_binarizer.transform(y).ravel()
+
         loss = self.loss
         if self.variance is not None:
             loss = loss + VarianceLoss(alpha=self.variance)

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/util/data_preprocessing.py

@@ -53,12 +53,12 @@ def _adjust_input(
     error = False
     shape = np.shape(x)
 
-    if sum(shape) == 0 and x_length > 0:
-        # Empty array although x_length not zero
-        error = True
-    elif shape == () and x_length == 1:
+    if shape == () and x_length == 1:
         # Single floating point number
         xx = np.array([[x]])
+    elif sum(shape) == 0 and x_length > 0:
+        # Empty array although x_length not zero
+        error = True
     elif len(shape) == 1:
         if x_length == 1:
             xx = np.array([np.array([xx]) for xx in x])

{squlearn-0.7.2 → squlearn-0.7.4}/src/squlearn/util/executor.py

@@ -554,7 +554,7 @@ class Executor:
                 if self._caching:
 
                     # Generate hash value for caching
-                    hash_value = self._cache.hash_variable(
+                    hash_value_adjusted = self._cache.hash_variable(
                         [
                             "pennylane_execute",
                             hash_value,
@@ -563,22 +563,27 @@ class Executor:
                         ]
                     )
 
-                    result = self._cache.get_file(hash_value)
+                    result = self._cache.get_file(hash_value_adjusted)
                     cached = True
+                else:
+                    hash_value_adjusted = None
 
                 if result is None:
                     cached = False
-                    # Execute the circuit todo: implement restart
-                    self._logger.info(
-                        f"Executor start execution of pennylane circuit with hash value: {{}}".format(
-                            hash_value
+                    if self._caching:
+                        self._logger.info(
+                            f"Execution of pennylane circuit function with hash value: {{}}".format(
+                                hash_value_adjusted
+                            )
                         )
-                    )
+                    else:
+                        self._logger.info(f"Execution of pennylane circuit function")
+                    # Execution of pennylane circuit function
                     result = function()
                     self._logger.info(f"Execution of pennylane circuit successful")
-                else:
+                elif self._caching:
                     self._logger.info(
-                        f"Cached result found with hash value: {{}}".format(hash_value)
+                        f"Cached result found with hash value: {{}}".format(hash_value_adjusted)
                     )
 
                 success = True
@@ -621,7 +626,7 @@ class Executor:
             )
 
         if self._caching and not cached:
-            self._cache.store_file(hash_value, copy.copy(result))
+            self._cache.store_file(hash_value_adjusted, copy.copy(result))
 
         return result