Fix bounds parsing in Scipy optimizers and warn when unsupported

qiskit_algorithms/exceptions.py

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2017, 2023.
+# (C) Copyright IBM 2017, 2024.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Exception for errors raised by Algorithms module."""
+"""Exception and warnings for errors raised by Algorithms module."""
 
 from qiskit.exceptions import QiskitError
 
@@ -19,3 +19,22 @@ class AlgorithmError(QiskitError):
     """For Algorithm specific errors."""
 
     pass
+
+
+class QiskitAlgorithmsWarning(UserWarning):
+    """Base class for warnings raised by Qiskit Algorithms."""
+
+    def __init__(self, *message):
+        """Set the error message."""
+        super().__init__(" ".join(message))
+        self.message = " ".join(message)
+
+    def __str__(self):
+        """Return the message."""
+        return repr(self.message)
+
+
+class QiskitAlgorithmsOptimizersWarning(QiskitAlgorithmsWarning):
+    """For Algorithm specific warnings."""
+
+    pass

qiskit_algorithms/optimizers/scipy_optimizer.py

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2018, 2023.
+# (C) Copyright IBM 2018, 2024.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -15,10 +15,12 @@
 
 from collections.abc import Callable
 from typing import Any
+import warnings
 
 import numpy as np
 from scipy.optimize import minimize
 
+from qiskit_algorithms.exceptions import QiskitAlgorithmsOptimizersWarning
 from qiskit_algorithms.utils.validation import validate_min
 from .optimizer import Optimizer, OptimizerSupportLevel, OptimizerResult, POINT
 
@@ -76,6 +78,20 @@ def __init__(
         self._max_evals_grouped = max_evals_grouped
         self._kwargs = kwargs
 
+        # Initialise bounds and re-allocate if definition in options or kwargs
+        self._bounds: list[tuple[float, float]] | None = None
+
+        if "bounds" in self._kwargs:
+            raise RuntimeError(
+                "Optimizer bounds should be parsed in SciPyOptimizer.minimize() and not in "
+                "SciPyOptimizer.__init__()."
+            )
+        if "bounds" in self._options:
+            raise RuntimeError(
+                "Optimizer bounds should be parsed in SciPyOptimizer.minimize() as a kwarg and not as "
+                "options."
+            )
+
     def get_support_level(self):
         """Return support level dictionary"""
         return {
@@ -116,9 +132,27 @@ def minimize(
         jac: Callable[[POINT], POINT] | None = None,
         bounds: list[tuple[float, float]] | None = None,
     ) -> OptimizerResult:
-        # Remove ignored parameters to suppress the warning of scipy.optimize.minimize
-        if self.is_bounds_ignored:
-            bounds = None
+
+        # Overwrite the previous bounds
+        if bounds is not None:
+            self._bounds = bounds
+
+        # Remove ignored bounds to suppress the warning of scipy.optimize.minimize
+        if self.is_bounds_ignored and self._bounds is not None:
+            warnings.warn(
+                f"Optimizer method {self._method} does not support bounds. Bounds ignored.",
+                QiskitAlgorithmsOptimizersWarning,
+            )
+            self._bounds = None
+        elif not self.is_bounds_ignored and self._bounds is None:
+            warnings.warn(
+                f"Optimizer method {self._method} may require defining bounds. "
+                f"Check the Scipy documentation for more info: "
+                f"https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html",
+                QiskitAlgorithmsOptimizersWarning,
+            )
+
+        # Remove ignored gradient to suppress the warning of scipy.optimize.minimize
         if self.is_gradient_ignored:
             jac = None
 
@@ -150,7 +184,7 @@ def minimize(
             x0=x0,
             method=self._method,
             jac=jac,
-            bounds=bounds,
+            bounds=self._bounds,
             options=self._options,
             **self._kwargs,
         )

requirements.txt

@@ -1,3 +1,4 @@
 qiskit>=0.44
 scipy>=1.4
 numpy>=1.17
+scikit-quant

test/optimizers/test_optimizers.py

@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2018, 2023.
+# (C) Copyright IBM 2018, 2024.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -49,6 +49,7 @@
     SciPyOptimizer,
 )
 from qiskit_algorithms.utils import algorithm_globals
+from qiskit_algorithms.exceptions import QiskitAlgorithmsOptimizersWarning
 
 
 @ddt
@@ -149,7 +150,7 @@ def test_gsls(self):
             max_eval=10000,
             min_step_size=1.0e-12,
         )
-        x_0 = [1.3, 0.7, 0.8, 1.9, 1.2]
+        x_0 = np.asarray([1.3, 0.7, 0.8, 1.9, 1.2])
 
         algorithm_globals.random_seed = 1
         res = optimizer.minimize(rosen, x_0)
@@ -183,6 +184,85 @@ def callback(x):
         self.run_optimizer(optimizer, max_nfev=10000)
         self.assertTrue(values)  # Check the list is nonempty.
 
+    def test_scipy_optimizer_parse_bounds(self):
+        """
+        Test the parsing of bounds in SciPyOptimizer.minimize method. Verifies that the bounds are
+        correctly parsed and set within the optimizer object.
+
+        Raises:
+            AssertionError: If any of the assertions fail.
+            AssertionError: If a TypeError is raised unexpectedly while parsing bounds.
+
+        """
+        try:
+            # Initialize SciPyOptimizer instance with SLSQP method
+            optimizer = SciPyOptimizer("SLSQP")
+
+            # Ensure that _bounds attribute is initially present and =None
+            self.assertTrue(hasattr(optimizer, "_bounds"))
+            self.assertTrue(optimizer._bounds is None)
+
+            # Call minimize method with a simple lambda function and bounds
+            optimizer.minimize(lambda x: -x, 1.0, bounds=[(0.0, 1.0)])
+
+            # Assert that _bounds attribute is set after minimize method call
+            self.assertTrue(hasattr(optimizer, "_bounds"))
+
+            # Assert that "bounds" is not present in optimizer options and kwargs
+            self.assertFalse("bounds" in optimizer._options)
+            self.assertFalse("bounds" in optimizer._kwargs)
+
+            # Assert that _bounds attribute is not None after setting bounds
+            self.assertFalse(optimizer._bounds is None)
+
+        except TypeError:
+            # This would give: https://github.com/qiskit-community/qiskit-machine-learning/issues/570
+            self.fail(
+                "TypeError was raised unexpectedly when parsing bounds in SciPyOptimizer.minimize(...)."
+            )
+
+        # Finally, expect exceptions if bounds are parsed incorrectly, i.e. differently than as in Scipy
+        with self.assertRaises(RuntimeError):
+            _ = SciPyOptimizer("SLSQP", bounds=[(0.0, 1.0)])
+        with self.assertRaises(RuntimeError):
+            _ = SciPyOptimizer("SLSQP", options={"bounds": [(0.0, 1.0)]})
+
+    def test_scipy_optimizer_warning(self):
+        """
+        Test warning handling in SciPyOptimizer.minimize method when using unsupported
+        optimizer. Verifies that a warning is raised when attempting to use an
+        optimizer that does not support bounds.
+
+        Raises:
+            AssertionError: If the expected warning is not raised.
+
+        """
+        # Initialize SciPyOptimizer instance with "cobyla" method
+        optimizer = SciPyOptimizer("cobyla")
+
+        # Use assertWarns context manager to check if the expected warning is raised
+        with self.assertWarns(QiskitAlgorithmsOptimizersWarning):
+            # Call minimize method with a simple lambda function and bounds for unsupported optimizer
+            optimizer.minimize(lambda x: -x, 1.0, bounds=[(0.0, 1.0)])
+
+    def test_scipy_optimizer_bounds_required(self):
+        """
+        Test bounds requirement handling in SciPyOptimizer.minimize method for optimizers
+        that require bounds. Verifies that an exception is raised when attempting to use
+        an optimizer that requires bounds without supplying them.
+
+        Raises:
+            AssertionError: If the expected exception is not raised.
+
+        """
+        # Initialize SciPyOptimizer instance with "SLSQP" method
+        optimizer = SciPyOptimizer("SLSQP")
+
+        # Use assertWarns context manager to check if the expected exception is raised
+        with self.assertWarns(QiskitAlgorithmsOptimizersWarning):
+            # Call minimize method with a simple lambda function without supplying required bounds
+            optimizer.minimize(lambda x: -x, 1.0)
+
     # ESCH and ISRES do not do well with rosen
     @data(
         (CRS, True),