merge from gfo_pop, tests, renaming

Author: gauravmanmode

src/optimagic/optimizers/gfo_optimizers.py

@@ -57,7 +57,7 @@ class GFOCommonOptions:
     stopping_maxtime: NonNegativeFloat | None = None
     """Maximum time in seconds before termination."""
 
-    stopping_funval: float | None = None
+    convergence_target_value: float | None = None
     """"Stop the optimization if the objective function is less than this value."""
 
     convergence_iter_noimprove: PositiveInt = 1000000  # do not want to trigger this
@@ -77,8 +77,13 @@ class GFOCommonOptions:
     """Whether to cache evaluated param and function values in a dictionary for
     lookup."""
 
-    extra_start_points: list[PyTree] | None = None
-    """List of additional start points for the optimization run."""
+    extra_start_params: list[PyTree] | None = None
+    """List of additional start points for the optimization run.
+
+    In case of population based optimizers, the initial_population can be provided
+    via `extra_start_params`
+
+    """
 
     warm_start: pd.DataFrame | None = None
     """Pandas dataframe that contains score and paramter information that will be
@@ -604,15 +609,15 @@ def _gfo_internal(
         "tol_rel": common.convergence_ftol_rel,
     }
 
-    # define search space, initial params, population, constraints
+    # define search space, initial params, initial_population and constraints
     opt = optimizer(
         search_space=_get_search_space_gfo(
             problem.bounds,
             common.n_grid_points,
             problem.converter,
         ),
         initialize=_get_initialize_gfo(
-            x0, common.n_init, common.extra_start_points, problem.converter
+            x0, common.n_init, common.extra_start_params, problem.converter
         ),
         constraints=_get_gfo_constraints(),
         random_state=common.seed,
@@ -624,16 +629,18 @@ def objective_function(para: dict[str, float]) -> float | NDArray[np.float64]:
         return -problem.fun(x)
 
     # negate in case of minimize
-    stopping_funval = (
-        -1 * common.stopping_funval if common.stopping_funval is not None else None
+    convergence_target_value = (
+        -1 * common.convergence_target_value
+        if common.convergence_target_value is not None
+        else None
     )
 
     # run optimization
     opt.search(
         objective_function=objective_function,
         n_iter=common.stopping_maxiter,
         max_time=common.stopping_maxtime,
-        max_score=stopping_funval,
+        max_score=convergence_target_value,
         early_stopping=early_stopping,
         memory=common.caching,
         memory_warm_start=common.warm_start,
@@ -683,8 +690,8 @@ def _get_initialize_gfo(
     extra_start_points: list[PyTree] | None,
     converter: Converter,
 ) -> dict[str, Any]:
-    """Set initial params x0, additional start points for the optimization run or the
-    initial_population. Here, warm_start is actually extra_start_points.
+    """Set initial params x0, additional start params for the optimization run or the
+    initial_population. Here, warm_start is actually extra_start_params.
 
     Args:
     x0: initial param

tests/optimagic/optimization/test_many_algorithms.py

@@ -28,7 +28,10 @@
     if algo.algo_info.supports_bounds
 ]
 
-PRECISION_LOOKUP = {"scipy_trust_constr": 3}
+PRECISION_LOOKUP = {
+    "scipy_trust_constr": 3,
+    "iminuit_migrad": 2,
+}
 
 
 @pytest.fixture
@@ -40,7 +43,7 @@ def _get_options(algo):
     options = {}
     "Max time before termination"
     if hasattr(algo, "stopping_maxtime"):
-        options.update({"stopping_maxtime": 200})
+        options.update({"stopping_maxtime": 10})
 
     "Fix seed if algorithm is stochastic"
     if hasattr(algo, "seed"):
@@ -49,10 +52,6 @@ def _get_options(algo):
 
 
 def _get_required_decimals(algorithm, algo):
-    # Do not expect solution if algorithm is experimental
-    if algo.algo_info.experimental:
-        return 0
-
     if algorithm in PRECISION_LOOKUP:
         return PRECISION_LOOKUP[algorithm]
     else:
@@ -65,14 +64,22 @@ def sos(x):
 
 
 def _get_params_and_binding_bounds(algo):
-    params = np.array([3, 2, -3])
-    if algo.algo_info.supports_infinite_bounds:
-        bounds = Bounds(
-            lower=np.array([1, -np.inf, -np.inf]), upper=np.array([np.inf, np.inf, -1])
-        )
+    if algo.algo_info.is_global:
+        params = np.array([0.5, -0.5])
+        bounds = Bounds(lower=np.array([0.25, -1]), upper=np.array([1, -0.25]))
+        expected = np.array([0.25, -0.25])
+
     else:
-        bounds = Bounds(lower=np.array([1, -10, -10]), upper=np.array([10, 10, -1]))
-    expected = np.array([1, 0, -1])
+        params = np.array([3, 2, -3])
+        if algo.algo_info.supports_infinite_bounds:
+            bounds = Bounds(
+                lower=np.array([1, -np.inf, -np.inf]),
+                upper=np.array([np.inf, np.inf, -1]),
+            )
+        else:
+            bounds = Bounds(lower=np.array([1, -10, -10]), upper=np.array([10, 10, -1]))
+        expected = np.array([1, 0, -1])
+
     return params, bounds, expected
 
 
@@ -128,8 +135,8 @@ def test_sum_of_squares_on_local_algorithms(algorithm, algo):
 def _get_params_and_bounds_on_global_and_bounded(algo):
     if algo.algo_info.is_global:
         params = np.array([0.35, 0.35])
-        bounds = Bounds(lower=np.array([0.2, -0.5]), upper=np.array([1, 0.5]))
-        expected = np.array([0.2, 0])
+        bounds = Bounds(lower=np.array([-0.2, -0.5]), upper=np.array([1, 0.5]))
+        expected = np.array([0, 0])
     else:
         params = np.arange(3)
         bounds = Bounds(lower=np.full(3, -10), upper=np.full(3, 10))