Rename GP predict_variance_derivatives in predict_var_derivatives

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.predic_var(&pt) {
+            if let Ok(s) = obj_model.predict_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.predic_var(&pt) {
+            if let Ok(s) = obj_model.predict_var(&pt) {
                 let sigma = s[[0, 0]].sqrt();
                 if sigma.abs() < 1e-12 {
                     Array1::zeros(pt.len())
@@ -59,7 +59,7 @@ impl InfillCriterion for ExpectedImprovement {
                     let arg = (f_min - pred) / sigma;
                     let y_prime = obj_model.predict_derivatives(&pt).unwrap();
                     let y_prime = y_prime.row(0);
-                    let sig_2_prime = obj_model.predict_variance_derivatives(&pt).unwrap();
+                    let sig_2_prime = obj_model.predict_var_derivatives(&pt).unwrap();
 
                     let sig_2_prime = sig_2_prime.row(0);
                     let sig_prime = sig_2_prime.mapv(|v| v / (2. * sigma));

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.predic_var(&xtest11.view()).unwrap()
-            - bgp.predic_var(&xtest12.view()).unwrap())
+        let fdiff1 = (bgp.predict_var(&xtest11.view()).unwrap()
+            - bgp.predict_var(&xtest12.view()).unwrap())
             / (2. * h);
-        let fdiff2 = (bgp.predic_var(&xtest21.view()).unwrap()
-            - bgp.predic_var(&xtest22.view()).unwrap())
+        let fdiff2 = (bgp.predict_var(&xtest21.view()).unwrap()
+            - bgp.predict_var(&xtest22.view()).unwrap())
             / (2. * h);
         println!(
             "gp var fdiff({}) = [[{}, {}]]",
@@ -180,7 +180,7 @@ mod tests {
         println!(
             "GP predict variances derivatives({}) = {}",
             xtest,
-            bgp.predict_variance_derivatives(&basetest.view()).unwrap()
+            bgp.predict_var_derivatives(&basetest.view()).unwrap()
         );
     }
 }

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.predic_var(x)?[[0, 0]];
+            let var = obj_model.predict_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 predic_var(&self, x: &ArrayView2<f64>) -> egobox_moe::Result<Array2<f64>> {
+    fn predict_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.predic_var(&xcast)
+        self.moe.predict_var(&xcast)
     }
 
     /// Save Moe model in given file.
@@ -576,14 +576,14 @@ impl GpSurrogateExt for MixintMoe {
         self.moe.predict_derivatives(&xcast)
     }
 
-    fn predict_variance_derivatives(&self, x: &ArrayView2<f64>) -> egobox_moe::Result<Array2<f64>> {
+    fn predict_var_derivatives(&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_variance_derivatives(&xcast)
+        self.moe.predict_var_derivatives(&xcast)
     }
 
     fn sample(&self, x: &ArrayView2<f64>, n_traj: usize) -> egobox_moe::Result<Array2<f64>> {
@@ -633,7 +633,7 @@ impl<'a, D: Data<Elem = f64>> PredictInplace<ArrayBase<D, Ix2>, Array2<f64>>
 
         let values = self
             .0
-            .predic_var(x)
+            .predict_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
-            .predic_var(&xtest.view())
+            .predict_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
-        .predic_var(&xtest)
+        .predict_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.predic_var(&xtest).expect("Kriging prediction");  
+/// let yvariances = kriging.predict_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 predic_var(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Result<Array2<F>> {
+    pub fn predict_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))
@@ -561,7 +561,7 @@ impl<F: Float, Mean: RegressionModel<F>, Corr: CorrelationModel<F>> GaussianProc
     /// Predict variance derivatives at a point `x` specified as a (nx,) vector where x has nx components.
     /// Returns a (nx,) vector containing variance derivatives at `x` wrt each nx components
     #[cfg(not(feature = "blas"))]
-    pub fn predict_variance_derivatives_single(
+    pub fn predict_var_derivatives_single(
         &self,
         x: &ArrayBase<impl Data<Elem = F>, Ix1>,
     ) -> Array1<F> {
@@ -630,7 +630,7 @@ impl<F: Float, Mean: RegressionModel<F>, Corr: CorrelationModel<F>> GaussianProc
 
     /// See non blas version
     #[cfg(feature = "blas")]
-    pub fn predict_variance_derivatives_single(
+    pub fn predict_var_derivatives_single(
         &self,
         x: &ArrayBase<impl Data<Elem = F>, Ix1>,
     ) -> Array1<F> {
@@ -709,14 +709,11 @@ impl<F: Float, Mean: RegressionModel<F>, Corr: CorrelationModel<F>> GaussianProc
 
     /// Predict variance derivatives at a set of points `x` specified as a (n, nx) matrix where x has nx components.
     /// Returns a (n, nx) matrix containing variance derivatives at `x` wrt each nx components
-    pub fn predict_variance_derivatives(
-        &self,
-        x: &ArrayBase<impl Data<Elem = F>, Ix2>,
-    ) -> Array2<F> {
+    pub fn predict_var_derivatives(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Array2<F> {
         let mut derivs = Array::zeros((x.nrows(), x.ncols()));
         Zip::from(derivs.rows_mut())
             .and(x.rows())
-            .for_each(|mut der, x| der.assign(&self.predict_variance_derivatives_single(&x)));
+            .for_each(|mut der, x| der.assign(&self.predict_var_derivatives_single(&x)));
         derivs
     }
 }
@@ -767,7 +764,7 @@ where
             "The number of data points must match the number of output targets."
         );
 
-        let values = self.0.predic_var(x).expect("GP Prediction");
+        let values = self.0.predict_var(x).expect("GP Prediction");
         *y = values;
     }
 
@@ -1300,12 +1297,12 @@ mod tests {
                     let gpr_vals = gp.predict(&xplot).unwrap();
 
                     let yvars = gp
-                        .predic_var(&arr2(&[[1.0], [3.5]]))
+                        .predict_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.predic_var(&xplot).unwrap();
+                    let gpr_vars = gp.predict_var(&xplot).unwrap();
 
                     let test_dir = "target/tests";
                     std::fs::create_dir_all(test_dir).ok();
@@ -1602,9 +1599,9 @@ 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.predic_var(&x).unwrap();
+                        let y_pred = gp.predict_var(&x).unwrap();
                         println!("variance at [{},{}] = {}", xa, xb, y_pred);
-                        let y_deriv = gp.predict_variance_derivatives(&x);
+                        let y_deriv = gp.predict_var_derivatives(&x);
                         println!("variance deriv at [{},{}] = {}", xa, xb, y_deriv);
 
                         let diff_g = (y_pred[[1, 0]] - y_pred[[2, 0]]) / (2. * e);
@@ -1658,9 +1655,9 @@ mod tests {
                 [xa, xb + e],
                 [xa, xb - e]
             ];
-            let y_pred = gp.predic_var(&x).unwrap();
+            let y_pred = gp.predict_var(&x).unwrap();
             println!("variance at [{xa},{xb}] = {y_pred}");
-            let y_deriv = gp.predict_variance_derivatives(&x);
+            let y_deriv = gp.predict_var_derivatives(&x);
             println!("variance deriv at [{xa},{xb}] = {y_deriv}");
 
             let diff_g = (y_pred[[1, 0]] - y_pred[[2, 0]]) / (2. * e);

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.predic_var(&xplot).unwrap();
+/// let sgp_vars = sgp.predict_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 predic_var(&self, x: &ArrayBase<impl Data<Elem = F>, Ix2>) -> Result<Array2<F>> {
+    pub fn predict_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.predic_var(x).expect("GP Prediction");
+        let values = self.0.predict_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.predic_var(&xplot).unwrap();
+        let sgp_vars = sgp.predict_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.predic_var(&xplot).unwrap();
+        let sgp_vars = sgp.predict_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.predic_var(&xplot).unwrap();
+        let sgp_vars = sgp.predict_var(&xplot).unwrap();
 
         save_data(&xt, &yt, &z, &xplot, &sgp_vals, &sgp_vars);
     }