Add API for constraint handling strategy

Author: relf

crates/ego/src/solver/egor_config.rs

@@ -10,7 +10,7 @@ use ndarray::Array2;
 use serde::{Deserialize, Serialize};
 
 /// A structure to handle TREGO method parameterization
-#[derive(Clone, Serialize, Deserialize, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub(crate) struct TregoConfig {
     pub(crate) activated: bool,
     pub(crate) n_local_steps: u64,
@@ -90,6 +90,8 @@ pub struct EgorConfig {
     pub(crate) seed: Option<u64>,
     /// Trego parameterization
     pub(crate) trego: TregoConfig,
+    /// Constraints criterion
+    pub(crate) cstr_strategy: ConstraintStrategy,
 }
 
 impl Default for EgorConfig {
@@ -117,6 +119,7 @@ impl Default for EgorConfig {
             xtypes: vec![],
             seed: None,
             trego: TregoConfig::default(),
+            cstr_strategy: ConstraintStrategy::MeanValue,
         }
     }
 }
@@ -294,6 +297,12 @@ impl EgorConfig {
         self
     }
 
+    /// Sets the infill strategy
+    pub fn cstr_strategy(mut self, cstr_strategy: ConstraintStrategy) -> Self {
+        self.cstr_strategy = cstr_strategy;
+        self
+    }
+
     /// Check whether we are in a discrete optimization context
     pub fn discrete(&self) -> bool {
         crate::utils::discrete(&self.xtypes)

crates/ego/src/solver/solver_computations.rs

@@ -144,8 +144,11 @@ where
                                  params: &mut InfillObjData<f64>|
                       -> f64 {
                     let scale_cstr = params.scale_cstr.as_ref().expect("constraint scaling")[i];
-                    // Self::mean_cstr(&*cstr_models[i], x, gradient, scale_cstr)
-                    Self::upper_trust_bound_cstr(&*cstr_models[i], x, gradient, scale_cstr)
+                    if self.config.cstr_strategy == ConstraintStrategy::MeanValue {
+                        Self::mean_cstr(&*cstr_models[i], x, gradient, scale_cstr)
+                    } else {
+                        Self::upper_trust_bound_cstr(&*cstr_models[i], x, gradient, scale_cstr)
+                    }
                 };
                 #[cfg(feature = "nlopt")]
                 {

crates/ego/src/types.rs

@@ -32,6 +32,15 @@ pub enum InfillStrategy {
     WB2S,
 }
 
+/// Constraint criterion used to select next promising point
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ConstraintStrategy {
+    /// Use the mean value
+    MeanValue,
+    /// Use the upper bound (ie mean + 3*sigma)
+    UpperTrustedBound,
+}
+
 /// Optimizer used to optimize the infill criteria
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum InfillOptimizer {

python/egobox/egobox.pyi

@@ -70,6 +70,10 @@ class Egor:
         infill_strategy (InfillStrategy enum)
             Infill criteria to decide best next promising point.
             Can be either InfillStrategy.EI, InfillStrategy.WB2 or InfillStrategy.WB2S.
+
+        cstr_strategy (ConstraintStrategy enum)
+            Constraint management either use the mean value or upper bound
+            Can be either ConstraintStrategy.MV (default) or ConstraintStrategy.UTB.
     
         q_points (int > 0):
             Number of points to be evaluated to allow parallel evaluation of the function under optimization.
@@ -660,6 +664,10 @@ class InfillStrategy(Enum):
     Wb2 = auto()
     Wb2s = auto()
 
+class ConstraintStrategy(Enum):
+    Mv = auto()
+    Utb = auto()
+
 class ParInfillStrategy(Enum):
     Kb = auto()
     Kblb = auto()

python/egobox/tests/test_egor.py

@@ -150,6 +150,7 @@ def test_g24(self):
             seed=42,
             n_optmod=2,
             n_doe=n_doe,
+            cstr_strategy=egx.ConstraintStrategy.UTB,
         )
         start = time.process_time()
         res = egor.minimize(g24, max_iters=max_iters)

python/src/egor.rs

@@ -103,6 +103,10 @@ pub(crate) fn to_specs(py: Python, xlimits: Vec<Vec<f64>>) -> PyResult<PyObject>
 ///         Infill criteria to decide best next promising point.
 ///         Can be either InfillStrategy.EI, InfillStrategy.WB2 or InfillStrategy.WB2S.
 ///
+///     cstr_strategy (ConstraintStrategy enum)
+///         Constraint management either use the mean value or upper bound
+///         Can be either ConstraintStrategy.MeanValue or ConstraintStrategy.UpperTrustedBound.
+///
 ///     q_points (int > 0):
 ///         Number of points to be evaluated to allow parallel evaluation of the function under optimization.
 ///
@@ -170,6 +174,7 @@ pub(crate) struct Egor {
     pub regression_spec: RegressionSpec,
     pub correlation_spec: CorrelationSpec,
     pub infill_strategy: InfillStrategy,
+    pub cstr_strategy: ConstraintStrategy,
     pub q_points: usize,
     pub par_infill_strategy: ParInfillStrategy,
     pub infill_optimizer: InfillOptimizer,
@@ -209,6 +214,7 @@ impl Egor {
         regr_spec = RegressionSpec::CONSTANT,
         corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL,
         infill_strategy = InfillStrategy::Wb2,
+        cstr_strategy = ConstraintStrategy::Mv,
         q_points = 1,
         par_infill_strategy = ParInfillStrategy::Kb,
         infill_optimizer = InfillOptimizer::Cobyla,
@@ -234,6 +240,7 @@ impl Egor {
         regr_spec: u8,
         corr_spec: u8,
         infill_strategy: InfillStrategy,
+        cstr_strategy: ConstraintStrategy,
         q_points: usize,
         par_infill_strategy: ParInfillStrategy,
         infill_optimizer: InfillOptimizer,
@@ -265,6 +272,7 @@ impl Egor {
             regression_spec: RegressionSpec(regr_spec),
             correlation_spec: CorrelationSpec(corr_spec),
             infill_strategy,
+            cstr_strategy,
             q_points,
             par_infill_strategy,
             infill_optimizer,
@@ -461,6 +469,13 @@ impl Egor {
         }
     }
 
+    fn cstr_strategy(&self) -> egobox_ego::ConstraintStrategy {
+        match self.cstr_strategy {
+            ConstraintStrategy::Mv => egobox_ego::ConstraintStrategy::MeanValue,
+            ConstraintStrategy::Utb => egobox_ego::ConstraintStrategy::UpperTrustedBound,
+        }
+    }
+
     fn qei_strategy(&self) -> egobox_ego::QEiStrategy {
         match self.par_infill_strategy {
             ParInfillStrategy::Kb => egobox_ego::QEiStrategy::KrigingBeliever,
@@ -519,6 +534,7 @@ impl Egor {
         doe: Option<&Array2<f64>>,
     ) -> egobox_ego::EgorConfig {
         let infill_strategy = self.infill_strategy();
+        let cstr_strategy = self.cstr_strategy();
         let qei_strategy = self.qei_strategy();
         let infill_optimizer = self.infill_optimizer();
 
@@ -536,6 +552,7 @@ impl Egor {
                 egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(),
             )
             .infill_strategy(infill_strategy)
+            .cstr_strategy(cstr_strategy)
             .q_points(self.q_points)
             .qei_strategy(qei_strategy)
             .infill_optimizer(infill_optimizer)

python/src/lib.rs

@@ -35,6 +35,7 @@ fn egobox(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<RegressionSpec>()?;
     m.add_class::<CorrelationSpec>()?;
     m.add_class::<InfillStrategy>()?;
+    m.add_class::<ConstraintStrategy>()?;
     m.add_class::<ParInfillStrategy>()?;
     m.add_class::<InfillOptimizer>()?;
     m.add_class::<XType>()?;

python/src/types.rs

@@ -56,6 +56,13 @@ pub(crate) enum InfillStrategy {
     Wb2s = 3,
 }
 
+#[pyclass(eq, eq_int, rename_all = "UPPERCASE")]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) enum ConstraintStrategy {
+    Mv = 1,
+    Utb = 2,
+}
+
 #[pyclass(eq, eq_int, rename_all = "UPPERCASE")]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub(crate) enum ParInfillStrategy {