Fix Egor service in presence of discrete variables (#119)

* Check MoeParams not used with discrete

* Make unfold function public

* Add doc comment

* Fix bug in unfold_with_enum_mask

* Make suggest work in folded space

* Manage LHS optim failure due to bad surrogate

* Rename new_with_xtypes

* Improve comments

* Renaming to_xtypes

* Keep only EgorSolver::new constructor with xtypes

* Refactor no_discrete

* Remove duplication

Author: relf

ego/src/egor.rs

@@ -142,9 +142,13 @@ impl<O: GroupFunc> EgorBuilder<O> {
         } else {
             Xoshiro256Plus::from_entropy()
         };
+        let config = EgorConfig {
+            xtypes: to_xtypes(xlimits),
+            ..self.config.clone()
+        };
         Egor {
             fobj: ObjFunc::new(self.fobj),
-            solver: EgorSolver::new(self.config, xlimits, rng),
+            solver: EgorSolver::new(config, rng),
         }
     }
 
@@ -157,9 +161,13 @@ impl<O: GroupFunc> EgorBuilder<O> {
         } else {
             Xoshiro256Plus::from_entropy()
         };
+        let config = EgorConfig {
+            xtypes: xtypes.into(),
+            ..self.config.clone()
+        };
         Egor {
             fobj: ObjFunc::new(self.fobj),
-            solver: EgorSolver::new_with_xtypes(self.config, xtypes, rng),
+            solver: EgorSolver::new(config, rng),
         }
     }
 }
@@ -189,14 +197,13 @@ impl<O: GroupFunc, SB: SurrogateBuilder> Egor<O, SB> {
 
     /// Runs the (constrained) optimization of the objective function.
     pub fn run(&self) -> Result<OptimResult<f64>> {
-        let no_discrete = self.solver.config.no_discrete;
         let xtypes = self.solver.config.xtypes.clone();
 
         let result = Executor::new(self.fobj.clone(), self.solver.clone()).run()?;
         info!("{}", result);
         let (x_data, y_data) = result.state().clone().take_data().unwrap();
 
-        let res = if no_discrete {
+        let res = if !self.solver.config.discrete() {
             info!("History: \n{}", concatenate![Axis(1), x_data, y_data]);
             OptimResult {
                 x_opt: result.state.get_best_param().unwrap().to_owned(),
@@ -205,7 +212,6 @@ impl<O: GroupFunc, SB: SurrogateBuilder> Egor<O, SB> {
                 y_hist: y_data,
             }
         } else {
-            let xtypes = xtypes.unwrap(); // !no_discrete
             let x_data = cast_to_discrete_values(&xtypes, &x_data);
             let x_data = fold_with_enum_index(&xtypes, &x_data.view());
             info!("History: \n{}", concatenate![Axis(1), x_data, y_data]);

ego/src/egor_config.rs

@@ -54,9 +54,7 @@ pub struct EgorConfig {
     /// If true use `outdir` to retrieve and start from previous results
     pub(crate) hot_start: bool,
     /// List of x types allowing the handling of discrete input variables
-    pub(crate) xtypes: Option<Vec<XType>>,
-    /// Flag for discrete handling, true if mixed-integer type present in xtypes, otherwise false
-    pub(crate) no_discrete: bool,
+    pub(crate) xtypes: Vec<XType>,
     /// A random generator seed used to get reproductible results.
     pub(crate) seed: Option<u64>,
 }
@@ -81,8 +79,7 @@ impl Default for EgorConfig {
             target: f64::NEG_INFINITY,
             outdir: None,
             hot_start: false,
-            xtypes: None,
-            no_discrete: true,
+            xtypes: vec![],
             seed: None,
         }
     }
@@ -237,4 +234,15 @@ impl EgorConfig {
         self.seed = Some(seed);
         self
     }
+
+    /// Define design space with given x types
+    pub fn xtypes(mut self, xtypes: &[XType]) -> Self {
+        self.xtypes = xtypes.into();
+        self
+    }
+
+    /// Check whether we are in a discrete optimization context
+    pub fn discrete(&self) -> bool {
+        crate::utils::discrete(&self.xtypes)
+    }
 }

ego/src/egor_service.rs

@@ -86,9 +86,12 @@ impl EgorServiceBuilder {
         } else {
             Xoshiro256Plus::from_entropy()
         };
+        let config = EgorConfig {
+            xtypes: to_xtypes(xlimits),
+            ..self.config.clone()
+        };
         EgorService {
-            config: self.config.clone(),
-            solver: EgorSolver::new(self.config, xlimits, rng),
+            solver: EgorSolver::new(config, rng),
         }
     }
 
@@ -101,26 +104,23 @@ impl EgorServiceBuilder {
         } else {
             Xoshiro256Plus::from_entropy()
         };
+        let config = EgorConfig {
+            xtypes: xtypes.to_vec(),
+            ..self.config.clone()
+        };
         EgorService {
-            config: self.config.clone(),
-            solver: EgorSolver::new_with_xtypes(self.config, xtypes, rng),
+            solver: EgorSolver::new(config, rng),
         }
     }
 }
 
 /// Egor optimizer service.
 #[derive(Clone)]
 pub struct EgorService<SB: SurrogateBuilder> {
-    config: EgorConfig,
     solver: EgorSolver<SB>,
 }
 
 impl<SB: SurrogateBuilder> EgorService<SB> {
-    pub fn configure<F: FnOnce(EgorConfig) -> EgorConfig>(mut self, init: F) -> Self {
-        self.config = init(self.config);
-        self
-    }
-
     /// Given an evaluated doe (x, y) data, return the next promising x point
     /// where optimum may occurs regarding the infill criterium.
     /// This function inverse the control of the optimization and can used
@@ -130,7 +130,11 @@ impl<SB: SurrogateBuilder> EgorService<SB> {
         x_data: &ArrayBase<impl Data<Elem = f64>, Ix2>,
         y_data: &ArrayBase<impl Data<Elem = f64>, Ix2>,
     ) -> Array2<f64> {
-        self.solver.suggest(x_data, y_data)
+        let xtypes = &self.solver.config.xtypes;
+        let x_data = unfold_with_enum_mask(xtypes, x_data);
+        let x = self.solver.suggest(&x_data, y_data);
+        let x = cast_to_discrete_values(xtypes, &x);
+        fold_with_enum_index(xtypes, &x).to_owned()
     }
 }
 

ego/src/egor_solver.rs

@@ -8,7 +8,7 @@
 //! ```no_run
 //! use ndarray::{array, Array2, ArrayView1, ArrayView2, Zip};
 //! use egobox_doe::{Lhs, SamplingMethod};
-//! use egobox_ego::{EgorBuilder, EgorConfig, InfillStrategy, InfillOptimizer, ObjFunc, EgorSolver};
+//! use egobox_ego::{EgorBuilder, EgorConfig, InfillStrategy, InfillOptimizer, ObjFunc, EgorSolver, to_xtypes};
 //! use egobox_moe::MoeParams;
 //! use rand_xoshiro::Xoshiro256Plus;
 //! use ndarray_rand::rand::SeedableRng;
@@ -25,10 +25,10 @@
 //!     y
 //! }
 //! let rng = Xoshiro256Plus::seed_from_u64(42);
-//! let xlimits = array![[-2., 2.], [-2., 2.]];
+//! let xtypes = to_xtypes(&array![[-2., 2.], [-2., 2.]]);
 //! let fobj = ObjFunc::new(rosenb);
-//! let config = EgorConfig::default();
-//! let solver: EgorSolver<MoeParams<f64, Xoshiro256Plus>> = EgorSolver::new(config, &xlimits, rng);
+//! let config = EgorConfig::default().xtypes(&xtypes);
+//! let solver: EgorSolver<MoeParams<f64, Xoshiro256Plus>> = EgorSolver::new(config, rng);
 //! let res = Executor::new(fobj, solver)
 //!             .configure(|state| state.max_iters(20))
 //!             .run()
@@ -47,7 +47,7 @@
 //! ```no_run
 //! use ndarray::{array, Array2, ArrayView1, ArrayView2, Zip};
 //! use egobox_doe::{Lhs, SamplingMethod};
-//! use egobox_ego::{EgorBuilder, EgorConfig, InfillStrategy, InfillOptimizer, ObjFunc, EgorSolver};
+//! use egobox_ego::{EgorBuilder, EgorConfig, InfillStrategy, InfillOptimizer, ObjFunc, EgorSolver, to_xtypes};
 //! use egobox_moe::MoeParams;
 //! use rand_xoshiro::Xoshiro256Plus;
 //! use ndarray_rand::rand::SeedableRng;
@@ -83,18 +83,20 @@
 //! let rng = Xoshiro256Plus::seed_from_u64(42);
 //! let xlimits = array![[0., 3.], [0., 4.]];
 //! let doe = Lhs::new(&xlimits).sample(10);
+//! let xtypes = to_xtypes(&xlimits);
 //!
 //! let fobj = ObjFunc::new(f_g24);
 //!
 //! let config = EgorConfig::default()
+//!     .xtypes(&xtypes)
 //!     .n_cstr(2)
 //!     .infill_strategy(InfillStrategy::EI)
 //!     .infill_optimizer(InfillOptimizer::Cobyla)
 //!     .doe(&doe)
 //!     .target(-5.5080);
 //!
 //! let solver: EgorSolver<MoeParams<f64, Xoshiro256Plus>> =
-//!   EgorSolver::new(config, &xlimits, rng);
+//!   EgorSolver::new(config, rng);
 //!
 //! let res = Executor::new(fobj, solver)
 //!             .configure(|state| state.max_iters(40))
@@ -112,7 +114,7 @@ use crate::mixint::*;
 use crate::optimizer::*;
 
 use crate::types::*;
-use crate::utils::{compute_cstr_scales, no_discrete, update_data};
+use crate::utils::{compute_cstr_scales, update_data};
 
 use egobox_doe::{Lhs, LhsKind, SamplingMethod};
 use egobox_moe::{ClusteredSurrogate, Clustering, CorrelationSpec, MoeParams, RegressionSpec};
@@ -163,7 +165,12 @@ pub struct EgorSolver<SB: SurrogateBuilder> {
 }
 
 impl SurrogateBuilder for MoeParams<f64, Xoshiro256Plus> {
-    fn new_with_xtypes_rng(_xtypes: &[XType]) -> Self {
+    /// Constructor from domain space specified with types
+    /// **panic** if xtypes contains other types than continuous type `Float`
+    fn new_with_xtypes(xtypes: &[XType]) -> Self {
+        if crate::utils::discrete(xtypes) {
+            panic!("MoeParams cannot be created with discrete types!");
+        }
         MoeParams::new()
     }
 
@@ -213,49 +220,18 @@ impl<SB: SurrogateBuilder> EgorSolver<SB> {
     /// Constructor of the optimization of the function `f` with specified random generator
     /// to get reproducibility.
     ///
-    /// The function `f` should return an objective value but also constraint values if any.
-    /// Design space is specified by the matrix `xlimits` which is `[nx, 2]`-shaped
-    /// the ith row contains lower and upper bounds of the ith component of `x`.
-    pub fn new(
-        config: EgorConfig,
-        xlimits: &ArrayBase<impl Data<Elem = f64>, Ix2>,
-        rng: Xoshiro256Plus,
-    ) -> Self {
-        let env = Env::new().filter_or("EGOBOX_LOG", "info");
-        let mut builder = Builder::from_env(env);
-        let builder = builder.target(env_logger::Target::Stdout);
-        builder.try_init().ok();
-        EgorSolver {
-            config: EgorConfig {
-                xtypes: Some(continuous_xlimits_to_xtypes(xlimits)), // align xlimits and xtypes
-                ..config
-            },
-            xlimits: xlimits.to_owned(),
-            surrogate_builder: SB::new_with_xtypes_rng(&continuous_xlimits_to_xtypes(xlimits)),
-            rng,
-        }
-    }
-
-    /// Constructor of the optimization of the function `f` with specified random generator
-    /// to get reproducibility. This constructor is used  for mixed-integer optimization
-    /// when `f` has discrete inputs to be specified with list of xtypes.
-    ///
     /// The function `f` should return an objective but also constraint values if any.
     /// Design space is specified by a list of types for input variables `x` of `f` (see [`XType`]).
-    pub fn new_with_xtypes(config: EgorConfig, xtypes: &[XType], rng: Xoshiro256Plus) -> Self {
+    pub fn new(config: EgorConfig, rng: Xoshiro256Plus) -> Self {
         let env = Env::new().filter_or("EGOBOX_LOG", "info");
         let mut builder = Builder::from_env(env);
         let builder = builder.target(env_logger::Target::Stdout);
         builder.try_init().ok();
-        let v_xtypes = xtypes.to_vec();
+        let xtypes = config.xtypes.clone();
         EgorSolver {
-            config: EgorConfig {
-                xtypes: Some(v_xtypes),
-                no_discrete: no_discrete(xtypes),
-                ..config
-            },
-            xlimits: unfold_xtypes_as_continuous_limits(xtypes),
-            surrogate_builder: SB::new_with_xtypes_rng(xtypes),
+            config,
+            xlimits: unfold_xtypes_as_continuous_limits(&xtypes),
+            surrogate_builder: SB::new_with_xtypes(&xtypes),
             rng,
         }
     }
@@ -294,7 +270,7 @@ impl<SB: SurrogateBuilder> EgorSolver<SB> {
 /// Build `xtypes` from simple float bounds of `x` input components when x belongs to R^n.
 /// xlimits are bounds of the x components expressed a matrix (dim, 2) where dim is the dimension of x
 /// the ith row is the bounds interval [lower, upper] of the ith comonent of `x`.  
-fn continuous_xlimits_to_xtypes(xlimits: &ArrayBase<impl Data<Elem = f64>, Ix2>) -> Vec<XType> {
+pub fn to_xtypes(xlimits: &ArrayBase<impl Data<Elem = f64>, Ix2>) -> Vec<XType> {
     let mut xtypes: Vec<XType> = vec![];
     Zip::from(xlimits.rows()).for_each(|limits| xtypes.push(XType::Cont(limits[0], limits[1])));
     xtypes
@@ -336,10 +312,12 @@ where
         let doe = hstart_doe.as_ref().or(self.config.doe.as_ref());
 
         let (y_data, x_data) = if let Some(doe) = doe {
+            let doe = unfold_with_enum_mask(&self.config.xtypes, doe);
+
             if doe.ncols() == self.xlimits.nrows() {
                 // only x are specified
                 info!("Compute initial DOE on specified {} points", doe.nrows());
-                (self.eval_obj(problem, doe), doe.to_owned())
+                (self.eval_obj(problem, &doe), doe.to_owned())
             } else {
                 // split doe in x and y
                 info!("Use specified DOE {} samples", doe.nrows());
@@ -991,9 +969,11 @@ where
         pb: &mut Problem<O>,
         x: &Array2<f64>,
     ) -> Array2<f64> {
-        let params = if let Some(xtypes) = &self.config.xtypes {
-            let xcast = cast_to_discrete_values(xtypes, x);
-            fold_with_enum_index(xtypes, &xcast.view())
+        let params = if self.config.discrete() {
+            // When xtypes is specified, we have to cast x to folded space
+            // as EgorSolver works internally in the continuous space
+            let xcast = cast_to_discrete_values(&self.config.xtypes, x);
+            fold_with_enum_index(&self.config.xtypes, &xcast.view())
         } else {
             x.to_owned()
         };

ego/src/lhs_optimizer.rs

@@ -3,7 +3,7 @@ use egobox_doe::{Lhs, LhsKind, SamplingMethod};
 use ndarray::{Array1, Array2, Axis, Zip};
 use ndarray_rand::rand::{Rng, SeedableRng};
 use rand_xoshiro::Xoshiro256Plus;
-use rayon::prelude::*;
+//use rayon::prelude::*;
 
 #[cfg(not(feature = "blas"))]
 use linfa_linalg::norm::*;
@@ -114,9 +114,17 @@ impl<'a, R: Rng + Clone + Sync + Send> LhsOptimizer<'a, R> {
                 })
                 .collect();
             let values = Array1::from_vec(vals.iter().map(|(_, y, _)| *y).collect());
-            let index_min = values
-                .argmin()
-                .unwrap_or_else(|err| panic!("Cannot find min in {}: {:?}", values, err));
+            let index_min = values.argmin().unwrap_or_else(|err| {
+                log::error!(
+                    "LHS optimization failed! Cannot find minimum in {} (Error: {})",
+                    values,
+                    err
+                );
+                if values.is_empty() {
+                    log::error!("No valid output value maybe due to ill-formed surrogate models.");
+                }
+                panic!("Optimization Aborted!")
+            });
             (
                 true,
                 vals[index_min].0.to_owned(),
@@ -142,7 +150,6 @@ impl<'a, R: Rng + Clone + Sync + Send> LhsOptimizer<'a, R> {
 
         // Make n_start optim
         let x_optims = (0..self.n_start)
-            .into_par_iter()
             .map(|_| self.find_lhs_min(lhs.clone()))
             .collect::<Vec<_>>();