✨ Minimize added to SciOptimizer

BaptisteDE · BaptisteDE · commit f13af35abef0 · 2026-02-17T11:13:36.000+01:00
diff --git a/corrai/base/model.py b/corrai/base/model.py
@@ -1,11 +1,11 @@
 import datetime as dt
+from abc import ABC, abstractmethod
+from pathlib import Path
 from typing import Union
 
-import pandas as pd
 import numpy as np
-
-from abc import ABC, abstractmethod
-from pathlib import Path
+import pandas as pd
+from scipy.optimize import rosen
 
 from corrai.base.parameter import Parameter
 
@@ -257,6 +257,109 @@ def simulate(
         )
 
 
+class RosenFiveParamDynamic(PyModel):
+    """
+    Example implementation of the Ishigami function.
+
+    The Ishigami function is a standard benchmark for sensitivity analysis:
+        f(x) = sin(x1) + 7 sin^2(x2) + 0.1 x3^4 sin(x1)
+
+    Attributes
+    ----------
+    x1, x2, x3 : float
+        Model parameters controlling the output.
+
+    Methods
+    -------
+    get_property_values(property_list)
+        Retrieve current values of x1, x2, x3.
+    set_property_values(property_dict)
+        Set properties from a dictionary.
+    simulate(property_dict, simulation_options, simulation_kwargs)
+        Evaluate the Ishigami function and return as a time series DataFrame.
+    """
+
+    def __init__(self):
+        super().__init__(is_dynamic=True)
+        self.x1 = 1
+        self.x2 = 2
+        self.x3 = 3
+        self.x4 = 4
+        self.x5 = 5
+
+    def simulate(
+        self,
+        property_dict: dict[str, str | int | float] = None,
+        simulation_options: dict = None,
+        simulation_kwargs: dict = None,
+    ) -> pd.DataFrame:
+        if property_dict is not None:
+            self.set_property_values(property_dict)
+
+        res = rosen([self.x1, self.x2, self.x3, self.x4, self.x5])
+
+        return pd.DataFrame(
+            {"res": [res]},
+            index=pd.date_range(
+                simulation_options["start"],
+                simulation_options["end"],
+                freq=simulation_options["timestep"],
+            ),
+        )
+
+
+class RosenFiveParam(PyModel):
+    """
+    Five-dimensional Rosenbrock benchmark model.
+
+    This class implements the Rosenbrock function, a standard benchmark
+    in numerical optimization, defined as:
+
+        f(x) = sum_{i=1}^{4} [100 (x_{i+1} - x_i^2)^2 + (1 - x_i)^2]
+
+    for x = (x1, x2, x3, x4, x5).
+
+    The global minimum is located at:
+
+        x* = (1, 1, 1, 1, 1),   f(x*) = 0
+
+    Attributes
+    ----------
+    x1, x2, x3, x4, x5 : float
+        Model parameters defining the input vector.
+
+    Methods
+    -------
+    get_property_values(property_list)
+        Retrieve current values of model parameters.
+    set_property_values(property_dict)
+        Set model parameters from a dictionary.
+    simulate(property_dict, simulation_options, simulation_kwargs)
+        Evaluate the Rosenbrock function and return the result.
+    """
+
+    def __init__(self):
+        super().__init__(is_dynamic=False)
+        self.x1 = 1
+        self.x2 = 2
+        self.x3 = 3
+        self.x4 = 4
+        self.x5 = 5
+
+    def simulate(
+        self,
+        property_dict: dict[str, str | int | float] = None,
+        simulation_options: dict = None,
+        simulation_kwargs: dict = None,
+    ) -> pd.Series:
+        if property_dict is not None:
+            self.set_property_values(property_dict)
+
+        res = rosen([self.x1, self.x2, self.x3, self.x4, self.x5])
+
+        return pd.Series({"res": res})
+
+
 class Ishigami(PyModel):
     """
     Example implementation of the Ishigami function.
diff --git a/corrai/optimize.py b/corrai/optimize.py
@@ -3,17 +3,15 @@
 
 import numpy as np
 import pandas as pd
-
-from scipy.optimize import differential_evolution, minimize_scalar
-
 from pymoo.core.problem import ElementwiseProblem
-from pymoo.core.variable import Integer, Real, Choice, Binary
+from pymoo.core.variable import Binary, Choice, Integer, Real
+from scipy.optimize import differential_evolution, minimize_scalar, minimize
 
 from corrai.base.math import METHODS
 from corrai.base.model import Model
+from corrai.base.parameter import Parameter
 from corrai.base.utils import check_indicators_configs
 from corrai.sampling import Sample, SampleMethodsMixin
-from corrai.base.parameter import Parameter
 
 
 def check_duplicate_params(params: list["Parameter"]) -> None:
@@ -724,6 +722,117 @@ def scalar_minimize(
             options=options,
         )
 
+    def minimize(
+        self,
+        indicator_config: str
+        | tuple[str, str | Callable]
+        | tuple[str, str | Callable, pd.Series],
+        simulation_options: dict = None,
+        simulation_kwargs=None,
+        x0: list[float] = None,
+        method=None,
+        jac=None,
+        hess=None,
+        hessp=None,
+        bounds=None,
+        constraints=(),
+        tol=None,
+        callback=None,
+        options=None,
+    ):
+        """
+        This method wraps `scipy.optimize.minimize`
+
+        Parameters
+        ----------
+        indicator_config : str or tuple
+            Indicator configuration passed to `ModelEvaluator.scipy_obj_function`:
+            - If the model is **static**: a string representing the indicator name.
+            - If the model is **dynamic**: a tuple of the form
+              (indicator, func) or (indicator, func, reference) where:
+                * indicator : str
+                  Indicator name in the simulation results.
+                * func : str or Callable
+                  Aggregation function (method name registered in `METHODS`
+                  or a Python callable).
+                * reference : optional
+                  Reference time series if the aggregation function is an
+                  error metric such as nmbe, cv_rmse, or mean_squared_error.
+
+        simulation_options : dict, optional
+            Options for the simulation (e.g., stop time, solver settings).
+
+        simulation_kwargs : dict, optional
+            Additional keyword arguments for simulation.
+
+        x0 : list of float, optional
+            Initial guess for the optimization variables.
+            If None, the initial values are set to the mean of each
+            parameter interval.
+
+        method : str or callable, optional
+            Optimization method to use (e.g., 'BFGS', 'L-BFGS-B', 'SLSQP').
+            Passed directly to `scipy.optimize.minimize`.
+
+        jac : callable or bool, optional
+            Function computing the gradient of the objective, or a boolean
+            indicating whether the objective returns the gradient.
+
+        hess : callable, optional
+            Function computing the Hessian matrix of the objective.
+
+        hessp : callable, optional
+            Function computing the Hessian-vector product.
+
+        bounds : sequence, optional
+            Bounds on variables for bounded optimization methods.
+
+        constraints : sequence, optional
+            Constraints definition for constrained optimization.
+
+        tol : float, optional
+            Tolerance for convergence.
+
+        callback : callable, optional
+            Function called after each iteration.
+
+        options : dict, optional
+            Additional solver-specific options.
+
+        Returns
+        -------
+        scipy.optimize.OptimizeResult
+            Result of the optimization. Accessible also via the `result`
+            attribute.
+
+        Notes
+        -----
+        This method relies on `scipy.optimize.minimize`, which implements
+        gradient-based and derivative-free local optimization algorithms.
+        It is best suited for smooth problems and may converge to a local
+        minimum depending on the initial guess.
+
+        For global optimization, consider using `diff_evo_minimize`.
+        """
+
+        if x0 is None:
+            x0 = [float(np.mean(par.interval)) for par in self.parameters]
+
+        return minimize(
+            self.model_evaluator.scipy_obj_function,
+            x0,
+            args=(indicator_config, simulation_options, simulation_kwargs),
+            method=method,
+            jac=jac,
+            hess=hess,
+            hessp=hessp,
+            bounds=bounds,
+            constraints=constraints,
+            tol=tol,
+            callback=callback,
+            options=options,
+        )
+
     def diff_evo_minimize(
         self,
         indicator_config: str
diff --git a/tests/test_optimize.py b/tests/test_optimize.py
@@ -1,26 +1,31 @@
-import pandas as pd
-import numpy as np
 from pathlib import Path
-import pytest
-
-from corrai.optimize import (
-    MixedProblem,
-    RealContinuousProblem,
-    PymooModelEvaluator,
-    check_duplicate_params,
-    ModelEvaluator,
-    SciOptimizer,
-)
-from corrai.base.parameter import Parameter
-from corrai.base.model import Ishigami, IshigamiDynamic, PyModel
 
+import numpy as np
+import pandas as pd
+import pytest
 from pymoo.algorithms.moo.nsga2 import NSGA2
 from pymoo.algorithms.soo.nonconvex.de import DE
+from pymoo.core.mixed import MixedVariableGA
 from pymoo.operators.sampling.lhs import LHS
 from pymoo.optimize import minimize
-from pymoo.core.mixed import MixedVariableGA
 from pymoo.termination import get_termination
 
+from corrai.base.model import (
+    Ishigami,
+    IshigamiDynamic,
+    PyModel,
+    RosenFiveParam,
+    RosenFiveParamDynamic,
+)
+from corrai.base.parameter import Parameter
+from corrai.optimize import (
+    MixedProblem,
+    ModelEvaluator,
+    PymooModelEvaluator,
+    RealContinuousProblem,
+    SciOptimizer,
+    check_duplicate_params,
+)
 
 PACKAGE_DIR = Path(__file__).parent / "TestLib"
 
@@ -291,6 +296,9 @@ def test_model_evaluator(self):
 
 class TestSciOptimizer:
     def test_sci_optimizer(self):
+        ########################
+        # Differential Evolution
+        ########################
         param_list = [
             Parameter(
                 "par_x1",
@@ -305,9 +313,8 @@ def test_sci_optimizer(self):
             ),
         ]
         # Dynamic optimization
-        sci_opt = SciOptimizer(parameters=param_list, model=IshigamiDynamic())
-
-        opt_res = sci_opt.diff_evo_minimize(
+        sci_opt_dyn = SciOptimizer(parameters=param_list, model=IshigamiDynamic())
+        opt_res = sci_opt_dyn.diff_evo_minimize(
             indicator_config=("res", "mean"),
             simulation_options={
                 "start": "2009-01-01 00:00:00",
@@ -316,20 +323,46 @@ def test_sci_optimizer(self):
             },
             rng=42,
         )
-
         assert round(opt_res.fun, 4) == -10.7409
 
         # Static optimization
-        sci_opt = SciOptimizer(parameters=param_list, model=Ishigami())
-
-        opt_res = sci_opt.diff_evo_minimize(
+        sci_opt_stat = SciOptimizer(parameters=param_list, model=Ishigami())
+        opt_res = sci_opt_stat.diff_evo_minimize(
             indicator_config="res",
             rng=42,
         )
-
         assert round(opt_res.fun, 4) == -10.7409
 
+        ##########
+        # minimize
+        ##########
+        param_list = [
+            Parameter(f"x{i}", (-100, 100), model_property=f"x{i}") for i in range(1, 6)
+        ]
+        x_expected = np.array([1, 1, 1, 1, 1])
+
+        # Dynamic optimization
+        sci_opt_dyn = SciOptimizer(parameters=param_list, model=RosenFiveParamDynamic())
+        opt_res = sci_opt_dyn.minimize(
+            indicator_config=("res", "mean"),
+            simulation_options={
+                "start": "2009-01-01 00:00:00",
+                "end": "2009-01-01 00:00:00",
+                "timestep": "h",
+            },
+        )
+        assert np.allclose(opt_res.x, x_expected, atol=1e-5)
+
+        # Static optimization
+        sci_opt_stat = SciOptimizer(parameters=param_list, model=RosenFiveParam())
+        opt_res = sci_opt_stat.minimize(
+            indicator_config="res",
+        )
+        assert np.allclose(opt_res.x, x_expected, atol=1e-5)
+
+        #####################
         # Scalar optimization
+        #####################
         parameter = Parameter("x_param", interval=(-10, 10), model_property="x")
 
         sci_opt = SciOptimizer(parameters=[parameter], model=X2())
