Rename GP predict_variances in predict_var

Author: relf

ego/src/criteria/ei.rs

@@ -23,7 +23,7 @@ impl InfillCriterion for ExpectedImprovement {
     ) -> f64 {
         let pt = ArrayView::from_shape((1, x.len()), x).unwrap();
         if let Ok(p) = obj_model.predict(&pt) {
-            if let Ok(s) = obj_model.predict_variances(&pt) {
+            if let Ok(s) = obj_model.predic_var(&pt) {
                 let pred = p[[0, 0]];
                 let sigma = s[[0, 0]].sqrt();
                 let args0 = (f_min - pred) / sigma;
@@ -49,7 +49,7 @@ impl InfillCriterion for ExpectedImprovement {
     ) -> Array1<f64> {
         let pt = ArrayView::from_shape((1, x.len()), x).unwrap();
         if let Ok(p) = obj_model.predict(&pt) {
-            if let Ok(s) = obj_model.predict_variances(&pt) {
+            if let Ok(s) = obj_model.predic_var(&pt) {
                 let sigma = s[[0, 0]].sqrt();
                 if sigma.abs() < 1e-12 {
                     Array1::zeros(pt.len())

ego/src/criteria/wb2.rs

@@ -165,11 +165,11 @@ mod tests {
         let xtest12 = array![[x1 - h, x2]];
         let xtest21 = array![[x1, x2 + h]];
         let xtest22 = array![[x1, x2 - h]];
-        let fdiff1 = (bgp.predict_variances(&xtest11.view()).unwrap()
-            - bgp.predict_variances(&xtest12.view()).unwrap())
+        let fdiff1 = (bgp.predic_var(&xtest11.view()).unwrap()
+            - bgp.predic_var(&xtest12.view()).unwrap())
             / (2. * h);
-        let fdiff2 = (bgp.predict_variances(&xtest21.view()).unwrap()
-            - bgp.predict_variances(&xtest22.view()).unwrap())
+        let fdiff2 = (bgp.predic_var(&xtest21.view()).unwrap()
+            - bgp.predic_var(&xtest22.view()).unwrap())
             / (2. * h);
         println!(
             "gp var fdiff({}) = [[{}, {}]]",

ego/src/egor_solver.rs

@@ -883,7 +883,7 @@ where
         } else {
             let x = &xk.view().insert_axis(Axis(0));
             let pred = obj_model.predict(x)?[[0, 0]];
-            let var = obj_model.predict_variances(x)?[[0, 0]];
+            let var = obj_model.predic_var(x)?[[0, 0]];
             let conf = match self.config.q_ei {
                 QEiStrategy::KrigingBeliever => 0.,
                 QEiStrategy::KrigingBelieverLowerBound => -3.,

ego/src/mixint.rs

@@ -541,14 +541,14 @@ impl GpSurrogate for MixintMoe {
         self.moe.predict(&xcast)
     }
 
-    fn predict_variances(&self, x: &ArrayView2<f64>) -> egobox_moe::Result<Array2<f64>> {
+    fn predic_var(&self, x: &ArrayView2<f64>) -> egobox_moe::Result<Array2<f64>> {
         let mut xcast = if self.work_in_folded_space {
             unfold_with_enum_mask(&self.xtypes, x)
         } else {
             x.to_owned()
         };
         cast_to_discrete_values_mut(&self.xtypes, &mut xcast);
-        self.moe.predict_variances(&xcast)
+        self.moe.predic_var(&xcast)
     }
 
     /// Save Moe model in given file.
@@ -633,7 +633,7 @@ impl<'a, D: Data<Elem = f64>> PredictInplace<ArrayBase<D, Ix2>, Array2<f64>>
 
         let values = self
             .0
-            .predict_variances(x)
+            .predic_var(x)
             .expect("MixintMoE variances prediction");
         *y = values;
     }
@@ -840,7 +840,7 @@ mod tests {
         let xtest = Array::linspace(0.0, 4.0, num).insert_axis(Axis(1));
         let ytest = mixi_moe.predict(&xtest.view()).expect("Predict val fail");
         let yvar = mixi_moe
-            .predict_variances(&xtest.view())
+            .predic_var(&xtest.view())
             .expect("Predict var fail");
         println!("{ytest:?}");
         assert_abs_diff_eq!(

gp/examples/kriging.rs

@@ -24,7 +24,7 @@ fn main() {
     let ypred = kriging.predict(&xtest).expect("Kriging prediction");
     // predict standard deviation
     let ysigma = kriging
-        .predict_variances(&xtest)
+        .predic_var(&xtest)
         .expect("Kriging prediction")
         .map(|v| v.sqrt());
 

gp/src/algorithm.rs

@@ -159,7 +159,7 @@ impl<F: Float> Clone for GpInnerParams<F> {
 /// let ytest = xsinx(&xtest);
 ///
 /// let ypred = kriging.predict(&xtest).expect("Kriging prediction");
-/// let yvariances = kriging.predict_variances(&xtest).expect("Kriging prediction");  
+/// let yvariances = kriging.predic_var(&xtest).expect("Kriging prediction");  
 ///```
 ///
 /// # Reference:
@@ -270,7 +270,7 @@ impl<F: Float, Mean: RegressionModel<F>, Corr: CorrelationModel<F>> GaussianProc
 
     /// Predict variance values at n given `x` points of nx components specified as a (n, nx) matrix.
     /// Returns n variance values as (n, 1) column vector.
-    pub fn predict_variances(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Result<Array2<F>> {
+    pub fn predic_var(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Result<Array2<F>> {
         let (rt, u, _) = self._compute_rt_u(x);
 
         let mut b = Array::ones(rt.ncols()) - rt.mapv(|v| v * v).sum_axis(Axis(0))
@@ -767,7 +767,7 @@ where
             "The number of data points must match the number of output targets."
         );
 
-        let values = self.0.predict_variances(x).expect("GP Prediction");
+        let values = self.0.predic_var(x).expect("GP Prediction");
         *y = values;
     }
 
@@ -1300,12 +1300,12 @@ mod tests {
                     let gpr_vals = gp.predict(&xplot).unwrap();
 
                     let yvars = gp
-                        .predict_variances(&arr2(&[[1.0], [3.5]]))
+                        .predic_var(&arr2(&[[1.0], [3.5]]))
                         .expect("prediction error");
                     let expected_vars = arr2(&[[0.], [0.1]]);
                     assert_abs_diff_eq!(expected_vars, yvars, epsilon = 0.5);
 
-                    let gpr_vars = gp.predict_variances(&xplot).unwrap();
+                    let gpr_vars = gp.predic_var(&xplot).unwrap();
 
                     let test_dir = "target/tests";
                     std::fs::create_dir_all(test_dir).ok();
@@ -1602,7 +1602,7 @@ mod tests {
                         println!("value at [{},{}] = {}", xa, xb, y_pred);
                         let y_deriv = gp.predict_derivatives(&x);
                         println!("deriv at [{},{}] = {}", xa, xb, y_deriv);
-                        let y_pred = gp.predict_variances(&x).unwrap();
+                        let y_pred = gp.predic_var(&x).unwrap();
                         println!("variance at [{},{}] = {}", xa, xb, y_pred);
                         let y_deriv = gp.predict_variance_derivatives(&x);
                         println!("variance deriv at [{},{}] = {}", xa, xb, y_deriv);
@@ -1658,7 +1658,7 @@ mod tests {
                 [xa, xb + e],
                 [xa, xb - e]
             ];
-            let y_pred = gp.predict_variances(&x).unwrap();
+            let y_pred = gp.predic_var(&x).unwrap();
             println!("variance at [{xa},{xb}] = {y_pred}");
             let y_deriv = gp.predict_variance_derivatives(&x);
             println!("variance deriv at [{xa},{xb}] = {y_deriv}");

gp/src/sparse_algorithm.rs

@@ -121,7 +121,7 @@ impl<F: Float> Clone for WoodburyData<F> {
 /// // Predict with our trained SGP
 /// let xplot = Array::linspace(-1., 1., 100).insert_axis(Axis(1));
 /// let sgp_vals = sgp.predict(&xplot).unwrap();
-/// let sgp_vars = sgp.predict_variances(&xplot).unwrap();
+/// let sgp_vars = sgp.predic_var(&xplot).unwrap();
 /// ```
 ///
 /// # Reference
@@ -239,7 +239,7 @@ impl<F: Float, Corr: CorrelationModel<F>> SparseGaussianProcess<F, Corr> {
 
     /// Predict variance values at n given `x` points of nx components specified as a (n, nx) matrix.
     /// Returns n variance values as (n, 1) column vector.
-    pub fn predict_variances(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Result<Array2<F>> {
+    pub fn predic_var(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Result<Array2<F>> {
         let kx = self.compute_k(&self.inducings, x, &self.w_star, &self.theta, self.sigma2);
         let kxx = Array::from_elem(x.nrows(), self.sigma2);
         let var = kxx - (self.w_data.inv.t().clone().dot(&kx) * &kx).sum_axis(Axis(0));
@@ -340,7 +340,7 @@ where
             "The number of data points must match the number of output targets."
         );
 
-        let values = self.0.predict_variances(x).expect("GP Prediction");
+        let values = self.0.predic_var(x).expect("GP Prediction");
         *y = values;
     }
 
@@ -863,7 +863,7 @@ mod tests {
         let yplot = f_obj(&xplot);
         let errvals = (yplot - &sgp_vals).mapv(|v| v.abs());
         assert_abs_diff_eq!(errvals, Array2::zeros((xplot.nrows(), 1)), epsilon = 0.5);
-        let sgp_vars = sgp.predict_variances(&xplot).unwrap();
+        let sgp_vars = sgp.predic_var(&xplot).unwrap();
         let errvars = (&sgp_vars - Array2::from_elem((xplot.nrows(), 1), 0.01)).mapv(|v| v.abs());
         assert_abs_diff_eq!(errvars, Array2::zeros((xplot.nrows(), 1)), epsilon = 0.2);
 
@@ -906,7 +906,7 @@ mod tests {
         assert_abs_diff_eq!(eta2, sgp.noise_variance());
 
         let sgp_vals = sgp.predict(&xplot).unwrap();
-        let sgp_vars = sgp.predict_variances(&xplot).unwrap();
+        let sgp_vars = sgp.predic_var(&xplot).unwrap();
 
         save_data(&xt, &yt, sgp.inducings(), &xplot, &sgp_vals, &sgp_vars);
     }
@@ -953,7 +953,7 @@ mod tests {
         assert_abs_diff_eq!(&z, sgp.inducings(), epsilon = 0.0015);
 
         let sgp_vals = sgp.predict(&xplot).unwrap();
-        let sgp_vars = sgp.predict_variances(&xplot).unwrap();
+        let sgp_vars = sgp.predic_var(&xplot).unwrap();
 
         save_data(&xt, &yt, &z, &xplot, &sgp_vals, &sgp_vars);
     }

moe/src/gp_algorithm.rs

@@ -414,10 +414,10 @@ impl GpSurrogate for GpMixture {
         }
     }
 
-    fn predict_variances(&self, x: &ArrayView2<f64>) -> Result<Array2<f64>> {
+    fn predic_var(&self, x: &ArrayView2<f64>) -> Result<Array2<f64>> {
         match self.recombination {
-            Recombination::Hard => self.predict_variances_hard(x),
-            Recombination::Smooth(_) => self.predict_variances_smooth(x),
+            Recombination::Hard => self.predic_var_hard(x),
+            Recombination::Smooth(_) => self.predic_var_smooth(x),
         }
     }
     /// Save Moe model in given file.
@@ -514,7 +514,7 @@ impl GpMixture {
     /// Gaussian Mixture is used to get the probability of the point to belongs to one cluster
     /// or another (ie responsabilities).
     /// The smooth recombination of each cluster expert responsabilty is used to get the result.
-    pub fn predict_variances_smooth(
+    pub fn predic_var_smooth(
         &self,
         x: &ArrayBase<impl Data<Elem = f64>, Ix2>,
     ) -> Result<Array2<f64>> {
@@ -529,7 +529,7 @@ impl GpMixture {
                 let preds: Array1<f64> = self
                     .experts
                     .iter()
-                    .map(|gp| gp.predict_variances(&x).unwrap()[[0, 0]])
+                    .map(|gp| gp.predic_var(&x).unwrap()[[0, 0]])
                     .collect();
                 *y = (preds * p * p).sum();
             });
@@ -606,7 +606,7 @@ impl GpMixture {
                 let preds: Array1<f64> = self
                     .experts
                     .iter()
-                    .map(|gp| gp.predict_variances(&xii).unwrap()[[0, 0]])
+                    .map(|gp| gp.predic_var(&xii).unwrap()[[0, 0]])
                     .collect();
                 let drvs: Vec<Array1<f64>> = self
                     .experts
@@ -665,7 +665,7 @@ impl GpMixture {
     /// Gaussian Mixture is used to get the cluster where the point belongs (highest responsability)
     /// The expert of the cluster is used to predict variance value.
     /// Returns the variances as a (n, 1) column vector
-    pub fn predict_variances_hard(
+    pub fn predic_var_hard(
         &self,
         x: &ArrayBase<impl Data<Elem = f64>, Ix2>,
     ) -> Result<Array2<f64>> {
@@ -678,7 +678,7 @@ impl GpMixture {
             .for_each(|mut y, x, &c| {
                 y.assign(
                     &self.experts[c]
-                        .predict_variances(&x.insert_axis(Axis(0)))
+                        .predic_var(&x.insert_axis(Axis(0)))
                         .unwrap()
                         .row(0),
                 );
@@ -747,11 +747,8 @@ impl GpMixture {
         <GpMixture as GpSurrogate>::predict(self, &x.view())
     }
 
-    pub fn predict_variances(
-        &self,
-        x: &ArrayBase<impl Data<Elem = f64>, Ix2>,
-    ) -> Result<Array2<f64>> {
-        <GpMixture as GpSurrogate>::predict_variances(self, &x.view())
+    pub fn predic_var(&self, x: &ArrayBase<impl Data<Elem = f64>, Ix2>) -> Result<Array2<f64>> {
+        <GpMixture as GpSurrogate>::predic_var(self, &x.view())
     }
 
     pub fn predict_derivatives(
@@ -829,10 +826,7 @@ impl<'a, D: Data<Elem = f64>> PredictInplace<ArrayBase<D, Ix2>, Array2<f64>>
             "The number of data points must match the number of output targets."
         );
 
-        let values = self
-            .0
-            .predict_variances(x)
-            .expect("MoE variances prediction");
+        let values = self.0.predic_var(x).expect("MoE variances prediction");
         *y = values;
     }
 
@@ -1003,7 +997,7 @@ mod tests {
             .expect("MOE fitted");
         // Smoke test: prediction is pretty good hence variance is very low
         let x = Array1::linspace(0., 1., 20).insert_axis(Axis(1));
-        let variances = moe.predict_variances(&x).expect("MOE variances prediction");
+        let variances = moe.predic_var(&x).expect("MOE variances prediction");
         assert_abs_diff_eq!(*variances.max().unwrap(), 0., epsilon = 1e-10);
     }
 
@@ -1163,7 +1157,7 @@ mod tests {
             assert_rel_or_abs_error(y_deriv[[0, 0]], diff_g);
             assert_rel_or_abs_error(y_deriv[[0, 1]], diff_d);
 
-            let y_pred = moe.predict_variances(&x).unwrap();
+            let y_pred = moe.predic_var(&x).unwrap();
             let y_deriv = moe.predict_variance_derivatives(&x).unwrap();
 
             let diff_g = (y_pred[[1, 0]] - y_pred[[2, 0]]) / (2. * e);

moe/src/sgp_algorithm.rs

@@ -408,10 +408,10 @@ impl GpSurrogate for SparseGpMixture {
         }
     }
 
-    fn predict_variances(&self, x: &ArrayView2<f64>) -> Result<Array2<f64>> {
+    fn predic_var(&self, x: &ArrayView2<f64>) -> Result<Array2<f64>> {
         match self.recombination {
-            Recombination::Hard => self.predict_variances_hard(x),
-            Recombination::Smooth(_) => self.predict_variances_smooth(x),
+            Recombination::Hard => self.predic_var_hard(x),
+            Recombination::Smooth(_) => self.predic_var_smooth(x),
         }
     }
     /// Save Sgp model in given file.
@@ -479,7 +479,7 @@ impl SparseGpMixture {
     /// Gaussian Mixture is used to get the probability of the point to belongs to one cluster
     /// or another (ie responsabilities).
     /// The smooth recombination of each cluster expert responsabilty is used to get the result.
-    pub fn predict_variances_smooth(
+    pub fn predic_var_smooth(
         &self,
         x: &ArrayBase<impl Data<Elem = f64>, Ix2>,
     ) -> Result<Array2<f64>> {
@@ -494,7 +494,7 @@ impl SparseGpMixture {
                 let preds: Array1<f64> = self
                     .experts
                     .iter()
-                    .map(|gp| gp.predict_variances(&x).unwrap()[[0, 0]])
+                    .map(|gp| gp.predic_var(&x).unwrap()[[0, 0]])
                     .collect();
                 *y = (preds * p * p).sum();
             });
@@ -527,7 +527,7 @@ impl SparseGpMixture {
     /// Gaussian Mixture is used to get the cluster where the point belongs (highest responsability)
     /// The expert of the cluster is used to predict variance value.
     /// Returns the variances as a (n, 1) column vector
-    pub fn predict_variances_hard(
+    pub fn predic_var_hard(
         &self,
         x: &ArrayBase<impl Data<Elem = f64>, Ix2>,
     ) -> Result<Array2<f64>> {
@@ -540,7 +540,7 @@ impl SparseGpMixture {
             .for_each(|mut y, x, &c| {
                 y.assign(
                     &self.experts[c]
-                        .predict_variances(&x.insert_axis(Axis(0)))
+                        .predic_var(&x.insert_axis(Axis(0)))
                         .unwrap()
                         .row(0),
                 );
@@ -552,11 +552,8 @@ impl SparseGpMixture {
         <SparseGpMixture as GpSurrogate>::predict(self, &x.view())
     }
 
-    pub fn predict_variances(
-        &self,
-        x: &ArrayBase<impl Data<Elem = f64>, Ix2>,
-    ) -> Result<Array2<f64>> {
-        <SparseGpMixture as GpSurrogate>::predict_variances(self, &x.view())
+    pub fn predic_var(&self, x: &ArrayBase<impl Data<Elem = f64>, Ix2>) -> Result<Array2<f64>> {
+        <SparseGpMixture as GpSurrogate>::predic_var(self, &x.view())
     }
 
     #[cfg(feature = "persistent")]
@@ -611,10 +608,7 @@ impl<'a, D: Data<Elem = f64>> PredictInplace<ArrayBase<D, Ix2>, Array2<f64>>
             "The number of data points must match the number of output targets."
         );
 
-        let values = self
-            .0
-            .predict_variances(x)
-            .expect("Sgp variances prediction");
+        let values = self.0.predic_var(x).expect("Sgp variances prediction");
         *y = values;
     }
 
@@ -675,7 +669,7 @@ mod tests {
         let yplot = f_obj(&xplot);
         let errvals = (yplot - &sgp_vals).mapv(|v| v.abs());
         assert_abs_diff_eq!(errvals, Array2::zeros((xplot.nrows(), 1)), epsilon = 1.0);
-        let sgp_vars = sgp.predict_variances(&xplot).unwrap();
+        let sgp_vars = sgp.predic_var(&xplot).unwrap();
         let errvars = (&sgp_vars - Array2::from_elem((xplot.nrows(), 1), 0.01)).mapv(|v| v.abs());
         assert_abs_diff_eq!(errvars, Array2::zeros((xplot.nrows(), 1)), epsilon = 0.05);
     }