From 92f0c33684d3942b5e4543012976c61feaf64c94 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 25 Jan 2024 17:45:24 +0100 Subject: [PATCH 01/26] Add experts getter --- moe/src/gp_algorithm.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/moe/src/gp_algorithm.rs b/moe/src/gp_algorithm.rs index 6376ebb5..818d5bcd 100644 --- a/moe/src/gp_algorithm.rs +++ b/moe/src/gp_algorithm.rs @@ -472,6 +472,11 @@ impl GpMixture { self.recombination } + /// Experts + pub fn experts(&self) -> &[Box] { + &self.experts + } + /// Gaussian mixture pub fn gmx(&self) -> &GaussianMixture { &self.gmx From 01230ca78bd3a0e0bb775b780d3a028e5fb24666 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 25 Jan 2024 17:57:25 +0100 Subject: [PATCH 02/26] Add experts API --- moe/src/gp_algorithm.rs | 2 +- moe/src/sgp_algorithm.rs | 11 +---------- 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/moe/src/gp_algorithm.rs b/moe/src/gp_algorithm.rs index 818d5bcd..cf95d11e 100644 --- a/moe/src/gp_algorithm.rs +++ b/moe/src/gp_algorithm.rs @@ -472,7 +472,7 @@ impl GpMixture { self.recombination } - /// Experts + /// Selected experts in the mixture pub fn experts(&self) -> &[Box] { &self.experts } diff --git a/moe/src/sgp_algorithm.rs b/moe/src/sgp_algorithm.rs index 6ae22b9d..ce2aebc8 100644 --- a/moe/src/sgp_algorithm.rs +++ b/moe/src/sgp_algorithm.rs @@ -433,20 +433,11 @@ impl SparseGpMixture { self.recombination } + /// Selected experts in the mixture pub fn experts(&self) -> &[Box] { &self.experts } - /// Clustering Recombination - pub fn noise_variance(&self) -> Vec { - self.experts.iter().map(|e| e.noise_variance()).collect() - } - - /// Clustering Recombination - pub fn variance(&self) -> Vec { - self.experts.iter().map(|e| e.variance()).collect() - } - /// Gaussian mixture pub fn gmx(&self) -> &GaussianMixture { &self.gmx From acc56444fa6a87cb05f111f9ee2019ba667f2323 Mon Sep 17 00:00:00 2001 From: relf Date: Fri, 26 Jan 2024 11:19:30 +0100 Subject: [PATCH 03/26] Add sparse method choice in py API --- gp/src/sgp_algorithm.rs | 6 +++--- gp/src/sgp_parameters.rs | 6 +++--- moe/src/sgp_parameters.rs | 20 +++++++++++++++++++- src/lib.rs | 1 + src/sparse_gp_mix.rs | 24 +++++++++++++++++------- src/types.rs | 7 +++++++ 6 files changed, 50 insertions(+), 14 deletions(-) diff --git a/gp/src/sgp_algorithm.rs b/gp/src/sgp_algorithm.rs index 86a6e2e3..b5266f5c 100644 --- a/gp/src/sgp_algorithm.rs +++ b/gp/src/sgp_algorithm.rs @@ -20,7 +20,7 @@ use rand_xoshiro::Xoshiro256Plus; use serde::{Deserialize, Serialize}; use std::fmt; -const N_START: usize = 10; // number of optimization restart (aka multistart) +const N_START: usize = 2; // number of optimization restart (aka multistart) /// Woodbury data computed during training and used for prediction /// @@ -177,7 +177,7 @@ impl> Clone for SparseGaussianProcess Self { Self { corr: self.corr, - method: self.method.clone(), + method: self.method, theta: self.theta.to_owned(), sigma2: self.sigma2, noise: self.noise, @@ -526,7 +526,7 @@ impl, D: Data> )?; Ok(SparseGaussianProcess { corr: *self.corr(), - method: self.method().clone(), + method: self.method(), theta: opt_theta, sigma2: opt_sigma2, noise: opt_noise, diff --git a/gp/src/sgp_parameters.rs b/gp/src/sgp_parameters.rs index 1a7d80af..28e6621f 100644 --- a/gp/src/sgp_parameters.rs +++ b/gp/src/sgp_parameters.rs @@ -38,7 +38,7 @@ impl Default for Inducings { } /// SGP algorithm method specification -#[derive(Clone, Debug, PartialEq, Eq, Default)] +#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)] #[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))] pub enum SparseMethod { #[default] @@ -97,8 +97,8 @@ impl> SgpValidParams { } /// Get used sparse method - pub fn method(&self) -> &SparseMethod { - &self.method + pub fn method(&self) -> SparseMethod { + self.method } /// Get inducing points diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index 9490da6b..779578d0 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -8,7 +8,7 @@ use egobox_gp::correlation_models::{ }; #[allow(unused_imports)] use egobox_gp::mean_models::{ConstantMean, LinearMean, QuadraticMean}; -use egobox_gp::Inducings; +use egobox_gp::{Inducings, SparseMethod}; use linfa::{Float, ParamGuard}; use linfa_clustering::GaussianMixtureModel; use ndarray::{Array1, Array2, Array3}; @@ -33,6 +33,8 @@ pub struct SparseGpMixtureValidParams { /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, + /// Used sparse method + sparse_method: SparseMethod, /// Inducings inducings: Inducings, /// Gaussian Mixture model used to cluster @@ -51,6 +53,7 @@ impl Default for SparseGpMixtureValidPar regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, kpls_dim: None, + sparse_method: SparseMethod::default(), inducings: Inducings::default(), gmm: None, gmx: None, @@ -85,6 +88,11 @@ impl SparseGpMixtureValidParams { self.kpls_dim } + /// The sparse method used + pub fn sparse_method(&self) -> SparseMethod { + self.sparse_method + } + /// Inducings points specification pub fn inducings(&self) -> &Inducings { &self.inducings @@ -143,6 +151,7 @@ impl SparseGpMixtureParams { regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, kpls_dim: None, + sparse_method: SparseMethod::default(), inducings, gmm: None, gmx: None, @@ -179,6 +188,14 @@ impl SparseGpMixtureParams { self } + /// Sets + /// + /// None means no PLS dimension reduction applied. + pub fn sparse_method(mut self, sparse_method: SparseMethod) -> Self { + self.0.sparse_method = sparse_method; + self + } + /// Sets the number of PLS components in [1, nx] where nx is the x dimension /// /// None means no PLS dimension reduction applied. @@ -213,6 +230,7 @@ impl SparseGpMixtureParams { regression_spec: self.0.regression_spec(), correlation_spec: self.0.correlation_spec(), kpls_dim: self.0.kpls_dim(), + sparse_method: self.0.sparse_method(), inducings: self.0.inducings().clone(), gmm: self.0.gmm().clone(), gmx: self.0.gmx().clone(), diff --git a/src/lib.rs b/src/lib.rs index 270ca034..b7fb9e6e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -42,6 +42,7 @@ fn egobox(_py: Python, m: &PyModule) -> PyResult<()> { m.add_class::()?; m.add_class::()?; m.add_class::()?; + m.add_class::()?; // Optimizer m.add_class::()?; diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index 96c78aba..dffd7f15 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -19,7 +19,7 @@ use numpy::{IntoPyArray, PyArray2, PyReadonlyArray2}; use pyo3::prelude::*; use rand_xoshiro::Xoshiro256Plus; -/// Gaussian processes mixture builder +/// Sparse Gaussian processes mixture builder /// /// n_clusters (int >= 0) /// Number of clusters used by the mixture of surrogate experts. @@ -27,11 +27,6 @@ use rand_xoshiro::Xoshiro256Plus; /// 10-points addition (should say 'tentative addition' because addition may fail for some points /// but failures are counted anyway). /// -/// regr_spec (RegressionSpec flags, an int in [1, 7]): -/// Specification of regression models used in mixture. -/// Can be RegressionSpec.CONSTANT (1), RegressionSpec.LINEAR (2), RegressionSpec.QUADRATIC (4) or -/// any bit-wise union of these values (e.g. RegressionSpec.CONSTANT | RegressionSpec.LINEAR) -/// /// corr_spec (CorrelationSpec flags, an int in [1, 15]): /// Specification of correlation models used in mixture. /// Can be CorrelationSpec.SQUARED_EXPONENTIAL (1), CorrelationSpec.ABSOLUTE_EXPONENTIAL (2), @@ -50,6 +45,9 @@ use rand_xoshiro::Xoshiro256Plus; /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. /// +/// method (SparseMethod.FITC or SparseMethod.VFE) +/// Sparse method to be used (default is FITC) +/// /// seed (int >= 0) /// Random generator seed to allow computation reproducibility. /// @@ -59,6 +57,7 @@ pub(crate) struct SparseGpMix { pub kpls_dim: Option, pub nz: Option, pub z: Option>, + pub method: SparseMethod, pub seed: Option, } @@ -70,6 +69,7 @@ impl SparseGpMix { kpls_dim = None, nz = None, z = None, + method = SparseMethod::Fitc, seed = None ))] #[allow(clippy::too_many_arguments)] @@ -78,6 +78,7 @@ impl SparseGpMix { kpls_dim: Option, nz: Option, z: Option>, + method: SparseMethod, seed: Option, ) -> Self { SparseGpMix { @@ -85,6 +86,7 @@ impl SparseGpMix { kpls_dim, nz, z: z.map(|z| z.as_array().to_owned()), + method, seed, } } @@ -115,6 +117,11 @@ impl SparseGpMix { panic!("You must specify inducing points") }; + let method = match self.method { + SparseMethod::Fitc => egobox_gp::SparseMethod::Fitc, + SparseMethod::Vfe => egobox_gp::SparseMethod::Vfe, + }; + let sgp = SparseGpMixture::params(inducings) // .n_clusters(self.n_clusters) // .recombination(recomb) @@ -123,6 +130,7 @@ impl SparseGpMix { egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), ) .kpls_dim(self.kpls_dim) + .sparse_method(method) .with_rng(rng) .fit(&dataset) .expect("Sgp model training"); @@ -146,6 +154,7 @@ impl SparseGpx { kpls_dim = None, nz = None, z = None, + method = SparseMethod::Fitc, seed = None ))] fn builder( @@ -153,9 +162,10 @@ impl SparseGpx { kpls_dim: Option, nz: Option, z: Option>, + method: SparseMethod, seed: Option, ) -> SparseGpMix { - SparseGpMix::new(corr_spec, kpls_dim, nz, z, seed) + SparseGpMix::new(corr_spec, kpls_dim, nz, z, method, seed) } /// Returns the String representation from serde json serializer diff --git a/src/types.rs b/src/types.rs index 4a89a692..25a5be15 100644 --- a/src/types.rs +++ b/src/types.rs @@ -125,3 +125,10 @@ impl XSpec { } } } + +#[pyclass(rename_all = "UPPERCASE")] +#[derive(Debug, Clone, Copy)] +pub(crate) enum SparseMethod { + Fitc = 1, + Vfe = 2, +} From 3a689f6d8441b496990ec8691b9c9e19e24e2c91 Mon Sep 17 00:00:00 2001 From: relf Date: Fri, 26 Jan 2024 20:47:29 +0100 Subject: [PATCH 04/26] Manage traces, Add initial_theta and sparse_method --- gp/src/algorithm.rs | 107 ++++++++++++++++++++++------- gp/src/sgp_algorithm.rs | 88 +++++++++++++----------- moe/src/sgp_algorithm.rs | 16 +++-- moe/src/sgp_parameters.rs | 18 +++++ moe/src/surrogates.rs | 20 ++++-- python/egobox/tests/test_sgpmix.py | 6 +- src/gp_mix.rs | 29 ++++---- src/lib.rs | 6 ++ src/sparse_gp_mix.rs | 47 +++++++++---- 9 files changed, 231 insertions(+), 106 deletions(-) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index af5efbd8..de643b4c 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -23,11 +23,11 @@ use rand_xoshiro::Xoshiro256Plus; use serde::{Deserialize, Serialize}; use std::fmt; -use ndarray_rand::rand_distr::Normal; +use ndarray_rand::rand_distr::{Normal, Uniform}; use ndarray_rand::RandomExt; // const LOG10_20: f64 = 1.301_029_995_663_981_3; //f64::log10(20.); -const N_START: usize = 10; // number of optimization restart (aka multistart) +const N_START: usize = 1; // number of optimization restart (aka multistart) /// Internal parameters computed Gp during training /// used later on in prediction computations @@ -793,7 +793,6 @@ impl, Corr: CorrelationModel, D: Data, _params: &mut ()| -> f64 { let theta = @@ -808,31 +807,48 @@ impl, Corr: CorrelationModel, D: Data unsafe { -(*(&r.0 as *const F as *const f64)) }, Err(_) => f64::INFINITY, } }; - // Multistart: user theta0 + 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 1., 10. - let mut theta0s = Array2::zeros((N_START + 1, theta0.len())); - theta0s.row_mut(0).assign(&theta0.mapv(|v| F::log10(v))); - let mut xlimits: Array2 = Array2::zeros((theta0.len(), 2)); - for mut row in xlimits.rows_mut() { - row.assign(&arr1(&[F::cast(-6), F::cast(2)])); - } - // Use a seed here for reproducibility. Do we need to make it truly random - // Probably no, as it is just to get init values spread over - // [1e-6, 20] for multistart thanks to LHS method. - let seeds = Lhs::new(&xlimits) - .kind(egobox_doe::LhsKind::Maximin) - .with_rng(Xoshiro256Plus::seed_from_u64(42)) - .sample(N_START); - Zip::from(theta0s.slice_mut(s![1.., ..]).rows_mut()) - .and(seeds.rows()) - .par_for_each(|mut theta, row| theta.assign(&row)); - - let bounds = vec![(F::cast(-6.), F::cast(2.)); theta0.len()]; + // // Multistart: user theta0 + 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 1., 10. + // let mut theta0s = Array2::zeros((N_START + 1, theta0.len())); + // theta0s.row_mut(0).assign(&theta0.mapv(|v| F::log10(v))); + + // match N_START.cmp(&1) { + // std::cmp::Ordering::Equal => { + // let mut rng = Xoshiro256Plus::seed_from_u64(42); + // theta0s.row_mut(0).assign(&Array::random_using( + // theta0.len(), + // Uniform::new(F::cast(-6), F::cast(2)), + // &mut rng, + // )) + // } + // std::cmp::Ordering::Greater => { + // let mut xlimits: Array2 = Array2::zeros((theta0.len(), 2)); + // for mut row in xlimits.rows_mut() { + // row.assign(&arr1(&[F::cast(-6), F::cast(2)])); + // } + // // Use a seed here for reproducibility. Do we need to make it truly random + // // Probably no, as it is just to get init values spread over + // // [1e-6, 20] for multistart thanks to LHS method. + + // let seeds = Lhs::new(&xlimits) + // .kind(egobox_doe::LhsKind::Maximin) + // .with_rng(Xoshiro256Plus::seed_from_u64(42)) + // .sample(N_START); + // Zip::from(theta0s.slice_mut(s![1.., ..]).rows_mut()) + // .and(seeds.rows()) + // .par_for_each(|mut theta, row| theta.assign(&row)); + // } + // std::cmp::Ordering::Less => (), + // }; + + // let bounds = vec![(F::cast(-6.), F::cast(2.)); theta0.len()]; + + let (theta0s, bounds) = prepare_multistart(&theta0); let opt_thetas = theta0s.map_axis(Axis(1), |theta| { optimize_params(objfn, &theta.to_owned(), &bounds) @@ -854,6 +870,49 @@ impl, Corr: CorrelationModel, D: Data(theta0: &Array1) -> (Array2, Vec<(F, F)>) { + let limits = (F::cast(-6.), F::cast(2.)); + // let mut bounds = vec![(F::cast(1e-16).log10(), F::cast(1.).log10()); params.ncols()]; + // let limits = (F::cast(-16), F::cast(0.)); + let bounds = vec![limits; theta0.len()]; + + // Multistart: user theta0 + 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 1., 10. + let mut theta0s = Array2::zeros((N_START + 1, theta0.len())); + theta0s.row_mut(0).assign(&theta0.mapv(|v| F::log10(v))); + + match N_START.cmp(&1) { + std::cmp::Ordering::Equal => { + //let mut rng = Xoshiro256Plus::seed_from_u64(42); + let mut rng = Xoshiro256Plus::from_entropy(); + theta0s.row_mut(1).assign(&Array::random_using( + theta0.len(), + Uniform::new(limits.0, limits.1), + &mut rng, + )) + } + std::cmp::Ordering::Greater => { + let mut xlimits: Array2 = Array2::zeros((theta0.len(), 2)); + for mut row in xlimits.rows_mut() { + row.assign(&arr1(&[limits.0, limits.1])); + } + // Use a seed here for reproducibility. Do we need to make it truly random + // Probably no, as it is just to get init values spread over + // [1e-6, 20] for multistart thanks to LHS method. + + let seeds = Lhs::new(&xlimits) + .kind(egobox_doe::LhsKind::Maximin) + .with_rng(Xoshiro256Plus::seed_from_u64(42)) + .sample(N_START); + Zip::from(theta0s.slice_mut(s![1.., ..]).rows_mut()) + .and(seeds.rows()) + .par_for_each(|mut theta, row| theta.assign(&row)); + } + std::cmp::Ordering::Less => (), + }; + + (theta0s, bounds) +} + /// Optimize gp hyper parameters given an initial guess and bounds with NLOPT::Cobyla #[cfg(feature = "nlopt")] pub(crate) fn optimize_params( @@ -919,7 +978,7 @@ where let initial_step = 0.5; let ftol_rel = 1e-4; - let maxeval = 15 * param0.len(); + let maxeval = 10 * param0.len(); let bounds: Vec<_> = bounds .iter() diff --git a/gp/src/sgp_algorithm.rs b/gp/src/sgp_algorithm.rs index b5266f5c..9dc9d009 100644 --- a/gp/src/sgp_algorithm.rs +++ b/gp/src/sgp_algorithm.rs @@ -1,14 +1,15 @@ use crate::algorithm::optimize_params; use crate::errors::{GpError, Result}; +use crate::prepare_multistart; use crate::sgp_parameters::{ Inducings, SgpParams, SgpValidParams, SparseMethod, VarianceEstimation, }; use crate::{correlation_models::*, utils::pairwise_differences}; -use egobox_doe::{Lhs, SamplingMethod}; use linfa::prelude::{Dataset, DatasetBase, Fit, Float, PredictInplace}; use linfa_linalg::{cholesky::*, triangular::*}; use linfa_pls::PlsRegression; -use ndarray::{arr1, s, Array, Array1, Array2, ArrayBase, Axis, Data, Ix2, Zip}; +use log::info; +use ndarray::{s, Array, Array1, Array2, ArrayBase, ArrayView2, Axis, Data, Ix2, Zip}; use ndarray_einsum_beta::*; use ndarray_stats::QuantileExt; @@ -20,8 +21,6 @@ use rand_xoshiro::Xoshiro256Plus; use serde::{Deserialize, Serialize}; use std::fmt; -const N_START: usize = 2; // number of optimization restart (aka multistart) - /// Woodbury data computed during training and used for prediction /// /// Name came from [Woodbury matrix identity](https://en.wikipedia.org/wiki/Woodbury_matrix_identity) @@ -347,6 +346,7 @@ impl, D: Data> &self, dataset: &DatasetBase, ArrayBase>, ) -> Result { + info!("SGP fit with {:?}", self.method()); let x = dataset.records(); let y = dataset.targets(); if let Some(d) = self.kpls_dim() { @@ -360,8 +360,8 @@ impl, D: Data> }; } - let xtrain = x.to_owned(); - let ytrain = y.to_owned(); + let xtrain = x; + let ytrain = y; let mut w_star = Array2::eye(x.ncols()); if let Some(n_components) = self.kpls_dim() { @@ -388,7 +388,6 @@ impl, D: Data> // Initial guess for variance let y_std = ytrain.std_axis(Axis(0), F::one()); let sigma2_0 = y_std[0] * y_std[0]; - //let sigma2_0 = F::cast(1e-2); // Initial guess for noise, when noise variance constant, it is not part of optimization params let (is_noise_estimated, noise0) = match self.noise_variance() { @@ -418,7 +417,7 @@ impl, D: Data> None => Xoshiro256Plus::from_entropy(), }; let z = match self.inducings() { - Inducings::Randomized(n) => make_inducings(*n, &xtrain, &mut rng), + Inducings::Randomized(n) => make_inducings(*n, &xtrain.view(), &mut rng), Inducings::Located(z) => z.to_owned(), }; @@ -453,8 +452,8 @@ impl, D: Data> sigma2, noise, &w_star, - &xtrain, - &ytrain, + &xtrain.view(), + &ytrain.view(), &z, self.nugget(), ) { @@ -463,26 +462,29 @@ impl, D: Data> } }; - // Multistart: user theta0 + LHS samplings - let mut params = Array2::zeros((N_START + 1, params_0.len())); - params.row_mut(0).assign(¶ms_0.mapv(|v| F::log10(v))); - let mut xlimits: Array2 = Array2::zeros((params_0.len(), 2)); - for mut row in xlimits.rows_mut() { - row.assign(&arr1(&[F::cast(-6), F::cast(2)])); - } - // Use a seed here for reproducibility. Do we need to make it truly random - // Probably no, as it is just to get init values spread over - // [1e-6, 20] for multistart thanks to LHS method. - let seeds = Lhs::new(&xlimits) - .kind(egobox_doe::LhsKind::Maximin) - .with_rng(Xoshiro256Plus::seed_from_u64(42)) - .sample(N_START); - Zip::from(params.slice_mut(s![1.., ..]).rows_mut()) - .and(seeds.rows()) - .par_for_each(|mut theta, row| theta.assign(&row)); - - // bounds of theta, variance and optionally noise variance - let mut bounds = vec![(F::cast(1e-6).log10(), F::cast(1e2).log10()); params.ncols()]; + // // Multistart: user theta0 + LHS samplings + // let mut params = Array2::zeros((N_START + 1, params_0.len())); + // params.row_mut(0).assign(¶ms_0.mapv(|v| F::log10(v))); + // let mut xlimits: Array2 = Array2::zeros((params_0.len(), 2)); + // for mut row in xlimits.rows_mut() { + // row.assign(&arr1(&[F::cast(-6), F::cast(2)])); + // } + // // Use a seed here for reproducibility. Do we need to make it truly random + // // Probably no, as it is just to get init values spread over + // // [1e-6, 20] for multistart thanks to LHS method. + // let seeds = Lhs::new(&xlimits) + // .kind(egobox_doe::LhsKind::Maximin) + // .with_rng(Xoshiro256Plus::seed_from_u64(42)) + // .sample(N_START); + // Zip::from(params.slice_mut(s![1.., ..]).rows_mut()) + // .and(seeds.rows()) + // .par_for_each(|mut theta, row| theta.assign(&row)); + + // // bounds of theta, variance and optionally noise variance + // let mut bounds = vec![(F::cast(1e-16).log10(), F::cast(1.).log10()); params.ncols()]; + + let (params, mut bounds) = prepare_multistart(¶ms_0); + // variance bounds bounds[params.ncols() - 1 - is_noise_estimated as usize] = (F::cast(1e-6).log10(), (F::cast(9.) * sigma2_0).log10()); @@ -498,8 +500,11 @@ impl, D: Data> } } + info!("OPTIMIZE hyper params0={:?}", params); let opt_params = params.map_axis(Axis(1), |p| optimize_params(objfn, &p.to_owned(), &bounds)); + info!("END OPTIMIZE hyper parms"); + let opt_index = opt_params.map(|(_, opt_f)| opt_f).argmin().unwrap(); let opt_params = &(opt_params[opt_index]).0.mapv(|v| F::cast(base.powf(v))); // println!("opt_theta={}", opt_theta); @@ -519,8 +524,8 @@ impl, D: Data> opt_sigma2, opt_noise, &w_star, - &xtrain, - &ytrain, + &xtrain.view(), + &ytrain.view(), &z, self.nugget(), )?; @@ -549,8 +554,8 @@ impl> SgpValidParams { sigma2: F, noise: F, w_star: &Array2, - xtrain: &Array2, - ytrain: &Array2, + xtrain: &ArrayView2, + ytrain: &ArrayView2, z: &Array2, nugget: F, ) -> Result<(F, WoodburyData)> { @@ -590,8 +595,8 @@ impl> SgpValidParams { sigma2: F, noise: F, w_star: &Array2, - xtrain: &Array2, - ytrain: &Array2, + xtrain: &ArrayView2, + ytrain: &ArrayView2, z: &Array2, nugget: F, ) -> (F, WoodburyData) { @@ -664,8 +669,8 @@ impl> SgpValidParams { sigma2: F, noise: F, w_star: &Array2, - xtrain: &Array2, - ytrain: &Array2, + xtrain: &ArrayView2, + ytrain: &ArrayView2, z: &Array2, nugget: F, ) -> (F, WoodburyData) { @@ -710,7 +715,6 @@ impl> SgpValidParams { let term6 = -a.diag().sum(); let likelihood = -F::cast(0.5) * (term1 + term2 + term3 + term4 + term5 + term6); - println!("likelihood={}", likelihood); let li_ui = li.dot(&ui); let bi = Array::eye(nz) + li.t().dot(&li); @@ -725,7 +729,7 @@ impl> SgpValidParams { fn make_inducings( n_inducing: usize, - xt: &Array2, + xt: &ArrayView2, rng: &mut Xoshiro256Plus, ) -> Array2 { let mut indices = (0..xt.nrows()).collect::>(); @@ -844,7 +848,7 @@ mod tests { let xplot = Array::linspace(-1., 1., 100).insert_axis(Axis(1)); let n_inducings = 30; - let z = make_inducings(n_inducings, &xt, &mut rng); + let z = make_inducings(n_inducings, &xt.view(), &mut rng); // let file_path = format!("{}/smt_z.npy", test_dir); // let z: Array2 = read_npy(file_path).expect("z read"); @@ -885,7 +889,7 @@ mod tests { let xplot = Array::linspace(-1., 1., 100).insert_axis(Axis(1)); let n_inducings = 30; - let z = make_inducings(n_inducings, &xt, &mut rng); + let z = make_inducings(n_inducings, &xt.view(), &mut rng); // let file_path = format!("{}/smt_z.npy", test_dir); // let z: Array2 = read_npy(file_path).expect("z read"); diff --git a/moe/src/sgp_algorithm.rs b/moe/src/sgp_algorithm.rs index ce2aebc8..33ef0fe7 100644 --- a/moe/src/sgp_algorithm.rs +++ b/moe/src/sgp_algorithm.rs @@ -112,7 +112,7 @@ impl SparseGpMixtureValidParams { let gmx = if self.gmx().is_some() { *self.gmx().as_ref().unwrap().clone() } else { - trace!("GMM training..."); + debug!("GMM training..."); let gmm = GaussianMixtureModel::params(n_clusters) .n_runs(20) .with_rng(self.rng()) @@ -130,7 +130,7 @@ impl SparseGpMixtureValidParams { GaussianMixture::new(weights, means, covariances)?.heaviside_factor(factor) }; - trace!("Train on clusters..."); + debug!("Train on clusters..."); let clustering = Clustering::new(gmx, recomb); self.train_on_clusters(&xt.view(), &yt.view(), &clustering) } @@ -143,13 +143,14 @@ impl SparseGpMixtureValidParams { yt: &ArrayBase, Ix2>, clustering: &Clustering, ) -> Result { + debug!("Clustering prediction"); let gmx = clustering.gmx(); let recomb = clustering.recombination(); let nx = xt.ncols(); let data = concatenate(Axis(1), &[xt.view(), yt.view()]).unwrap(); - let dataset_clustering = gmx.predict(xt); let clusters = sort_by_cluster(gmx.n_clusters(), &data, &dataset_clustering); + debug!("... end Clustering"); check_number_of_points(&clusters, xt.ncols())?; @@ -183,6 +184,7 @@ impl SparseGpMixtureValidParams { // previously trained on data excluding test data (see train method) Ok(sgp) } else { + info!("SparseGpMixture trained"); Ok(SparseGpMixture { recombination: recomb, experts, @@ -224,7 +226,7 @@ impl SparseGpMixtureValidParams { check_allowed!(correlation_spec, Correlation, Matern32, allowed_corrs); check_allowed!(correlation_spec, Correlation, Matern52, allowed_corrs); - debug!("Find best expert"); + debug!("Find best expert..."); let best = if allowed_means.len() == 1 && allowed_corrs.len() == 1 { (format!("{}_{}", allowed_means[0], allowed_corrs[0]), None) // shortcut } else { @@ -240,7 +242,7 @@ impl SparseGpMixtureValidParams { .unwrap(); (map_error[argmin].0.clone(), Some(map_error[argmin].1)) }; - debug!("after Find best expert"); + debug!("...after Find best expert"); let inducings = self.inducings().clone(); let best_expert_params: std::result::Result, MoeError> = match best.0.as_str() { @@ -257,8 +259,12 @@ impl SparseGpMixtureValidParams { let mut expert_params = best_expert_params?; let seed = self.rng().gen(); expert_params.kpls_dim(self.kpls_dim()); + expert_params.initial_theta(self.initial_theta()); + expert_params.sparse_method(self.sparse_method()); expert_params.seed(seed); + debug!("Train best expert..."); let expert = expert_params.train(&xtrain.view(), &ytrain.view()); + debug!("...after best expert training"); if let Some(v) = best.1 { info!("Best expert {} accuracy={}", best.0, v); } diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index 779578d0..c22997e7 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -30,6 +30,8 @@ pub struct SparseGpMixtureValidParams { regression_spec: RegressionSpec, /// Specification of GP correlation models to be used correlation_spec: CorrelationSpec, + /// Initial Guess for GP theta hyperparameters + initial_theta: Option>, /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, @@ -53,6 +55,7 @@ impl Default for SparseGpMixtureValidPar regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, kpls_dim: None, + initial_theta: None, sparse_method: SparseMethod::default(), inducings: Inducings::default(), gmm: None, @@ -88,6 +91,11 @@ impl SparseGpMixtureValidParams { self.kpls_dim } + /// The optional initial guess for GP theta hyperparameters + pub fn initial_theta(&self) -> Option> { + self.initial_theta.clone() + } + /// The sparse method used pub fn sparse_method(&self) -> SparseMethod { self.sparse_method @@ -151,6 +159,7 @@ impl SparseGpMixtureParams { regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, kpls_dim: None, + initial_theta: None, sparse_method: SparseMethod::default(), inducings, gmm: None, @@ -180,6 +189,14 @@ impl SparseGpMixtureParams { self } + /// Sets the initial guess for GP theta hyperparameters + /// + /// Default is 1e-2 for all components + pub fn initial_theta(mut self, initial_theta: Option>) -> Self { + self.0.initial_theta = initial_theta; + self + } + /// Sets the number of PLS components in [1, nx] where nx is the x dimension /// /// None means no PLS dimension reduction applied. @@ -230,6 +247,7 @@ impl SparseGpMixtureParams { regression_spec: self.0.regression_spec(), correlation_spec: self.0.correlation_spec(), kpls_dim: self.0.kpls_dim(), + initial_theta: self.0.initial_theta(), sparse_method: self.0.sparse_method(), inducings: self.0.inducings().clone(), gmm: self.0.gmm().clone(), diff --git a/moe/src/surrogates.rs b/moe/src/surrogates.rs index d8699fc5..c7e0c16a 100644 --- a/moe/src/surrogates.rs +++ b/moe/src/surrogates.rs @@ -1,7 +1,7 @@ use crate::errors::Result; use egobox_gp::{ correlation_models::*, mean_models::*, GaussianProcess, GpParams, SgpParams, - SparseGaussianProcess, + SparseGaussianProcess, SparseMethod, }; use linfa::prelude::{Dataset, Fit}; use ndarray::{Array1, Array2, ArrayView2}; @@ -19,7 +19,7 @@ use std::io::Write; /// A trait for Gp surrogate parameters to build surrogate once fitted. pub trait GpSurrogateParams { /// Set initial theta - fn initial_theta(&mut self, theta: Vec); + fn initial_theta(&mut self, theta: Option>); /// Set the number of PLS components fn kpls_dim(&mut self, kpls_dim: Option); /// Set the nugget parameter to improve numerical stability @@ -31,9 +31,11 @@ pub trait GpSurrogateParams { /// A trait for sparse GP surrogate parameters to build surrogate once fitted. pub trait SgpSurrogateParams { /// Set initial theta - fn initial_theta(&mut self, theta: Vec); + fn initial_theta(&mut self, theta: Option>); /// Set the number of PLS components fn kpls_dim(&mut self, kpls_dim: Option); + /// Set the sparse method + fn sparse_method(&mut self, method: SparseMethod); /// Set random generator seed fn seed(&mut self, seed: Option); /// Train the surrogate @@ -96,8 +98,8 @@ macro_rules! declare_surrogate { } impl GpSurrogateParams for [] { - fn initial_theta(&mut self, theta: Vec) { - self.0 = self.0.clone().initial_theta(Some(theta)); + fn initial_theta(&mut self, theta: Option>) { + self.0 = self.0.clone().initial_theta(theta); } fn kpls_dim(&mut self, kpls_dim: Option) { @@ -210,8 +212,12 @@ macro_rules! declare_sgp_surrogate { } impl SgpSurrogateParams for [] { - fn initial_theta(&mut self, theta: Vec) { - self.0 = self.0.clone().initial_theta(Some(theta)); + fn initial_theta(&mut self, theta: Option>) { + self.0 = self.0.clone().initial_theta(theta); + } + + fn sparse_method(&mut self, method: SparseMethod) { + self.0 = self.0.clone().sparse_method(method); } fn kpls_dim(&mut self, kpls_dim: Option) { diff --git a/python/egobox/tests/test_sgpmix.py b/python/egobox/tests/test_sgpmix.py index 77fb526d..72c74108 100644 --- a/python/egobox/tests/test_sgpmix.py +++ b/python/egobox/tests/test_sgpmix.py @@ -4,7 +4,7 @@ import logging import time -logging.basicConfig(level=logging.INFO) +logging.basicConfig(level=logging.DEBUG) def f_obj(x): @@ -41,4 +41,8 @@ def test_sgp(self): if __name__ == "__main__": + import logging + + logging.basicConfig(level=logging.DEBUG) + unittest.main() diff --git a/src/gp_mix.rs b/src/gp_mix.rs index 4afb04e8..5899837a 100644 --- a/src/gp_mix.rs +++ b/src/gp_mix.rs @@ -101,7 +101,7 @@ impl GpMix { /// Returns Gpx object /// the fitted Gaussian process mixture /// - fn fit(&mut self, xt: PyReadonlyArray2, yt: PyReadonlyArray2) -> Gpx { + fn fit(&mut self, py: Python, xt: PyReadonlyArray2, yt: PyReadonlyArray2) -> Gpx { let dataset = Dataset::new(xt.as_array().to_owned(), yt.as_array().to_owned()); let recomb = match self.recombination { @@ -113,17 +113,22 @@ impl GpMix { } else { Xoshiro256Plus::from_entropy() }; - let moe = GpMixture::params() - .n_clusters(self.n_clusters) - .recombination(recomb) - .regression_spec(egobox_moe::RegressionSpec::from_bits(self.regression_spec.0).unwrap()) - .correlation_spec( - egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), - ) - .kpls_dim(self.kpls_dim) - .with_rng(rng) - .fit(&dataset) - .expect("MoE model training"); + let moe = py.allow_threads(|| { + GpMixture::params() + .n_clusters(self.n_clusters) + .recombination(recomb) + .regression_spec( + egobox_moe::RegressionSpec::from_bits(self.regression_spec.0).unwrap(), + ) + .correlation_spec( + egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), + ) + .kpls_dim(self.kpls_dim) + .with_rng(rng) + .fit(&dataset) + .expect("MoE model training") + }); + Gpx(Box::new(moe)) } } diff --git a/src/lib.rs b/src/lib.rs index b7fb9e6e..524284d5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,7 @@ use sampling::*; use sparse_gp_mix::*; use types::*; +use env_logger::{Builder, Env}; use pyo3::prelude::*; #[doc(hidden)] @@ -19,6 +20,11 @@ use pyo3::prelude::*; fn egobox(_py: Python, m: &PyModule) -> PyResult<()> { pyo3_log::init(); + 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(); + // utils m.add_function(wrap_pyfunction!(to_specs, m)?)?; m.add_function(wrap_pyfunction!(lhs, m)?)?; diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index dffd7f15..d963db14 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -45,6 +45,10 @@ use rand_xoshiro::Xoshiro256Plus; /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. /// +/// initial_theta ([nx] where nx is the dimension of inputs x) +/// Initial guess for GP theta hyperparameters. +/// When None the default is 1e-2 for all components +/// /// method (SparseMethod.FITC or SparseMethod.VFE) /// Sparse method to be used (default is FITC) /// @@ -55,6 +59,7 @@ use rand_xoshiro::Xoshiro256Plus; pub(crate) struct SparseGpMix { pub correlation_spec: CorrelationSpec, pub kpls_dim: Option, + pub initial_theta: Option>, pub nz: Option, pub z: Option>, pub method: SparseMethod, @@ -67,6 +72,7 @@ impl SparseGpMix { #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, kpls_dim = None, + initial_theta = None, nz = None, z = None, method = SparseMethod::Fitc, @@ -76,6 +82,7 @@ impl SparseGpMix { fn new( corr_spec: u8, kpls_dim: Option, + initial_theta: Option>, nz: Option, z: Option>, method: SparseMethod, @@ -84,6 +91,7 @@ impl SparseGpMix { SparseGpMix { correlation_spec: CorrelationSpec(corr_spec), kpls_dim, + initial_theta, nz, z: z.map(|z| z.as_array().to_owned()), method, @@ -100,7 +108,12 @@ impl SparseGpMix { /// Returns Sgp object /// the fitted Gaussian process mixture /// - fn fit(&mut self, xt: PyReadonlyArray2, yt: PyReadonlyArray2) -> SparseGpx { + fn fit( + &mut self, + py: Python, + xt: PyReadonlyArray2, + yt: PyReadonlyArray2, + ) -> SparseGpx { let dataset = Dataset::new(xt.as_array().to_owned(), yt.as_array().to_owned()); let rng = if let Some(seed) = self.seed { @@ -122,19 +135,21 @@ impl SparseGpMix { SparseMethod::Vfe => egobox_gp::SparseMethod::Vfe, }; - let sgp = SparseGpMixture::params(inducings) - // .n_clusters(self.n_clusters) - // .recombination(recomb) - // .regression_spec(egobox_moe::RegressionSpec::from_bits(self.regression_spec.0).unwrap()) - .correlation_spec( - egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), - ) - .kpls_dim(self.kpls_dim) - .sparse_method(method) - .with_rng(rng) - .fit(&dataset) - .expect("Sgp model training"); - + let sgp = py.allow_threads(|| { + SparseGpMixture::params(inducings) + // .n_clusters(self.n_clusters) + // .recombination(recomb) + // .regression_spec(egobox_moe::RegressionSpec::from_bits(self.regression_spec.0).unwrap()) + .correlation_spec( + egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), + ) + .kpls_dim(self.kpls_dim) + .initial_theta(self.initial_theta.clone()) + .sparse_method(method) + .with_rng(rng) + .fit(&dataset) + .expect("Sgp model training") + }); SparseGpx(Box::new(sgp)) } } @@ -152,6 +167,7 @@ impl SparseGpx { #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, kpls_dim = None, + initial_theta = None, nz = None, z = None, method = SparseMethod::Fitc, @@ -160,12 +176,13 @@ impl SparseGpx { fn builder( corr_spec: u8, kpls_dim: Option, + initial_theta: Option>, nz: Option, z: Option>, method: SparseMethod, seed: Option, ) -> SparseGpMix { - SparseGpMix::new(corr_spec, kpls_dim, nz, z, method, seed) + SparseGpMix::new(corr_spec, kpls_dim, initial_theta, nz, z, method, seed) } /// Returns the String representation from serde json serializer From 47fb019873454a5904679c5de44ff85d9050da59 Mon Sep 17 00:00:00 2001 From: relf Date: Sat, 27 Jan 2024 12:32:16 +0100 Subject: [PATCH 05/26] Make GP n_start configurable --- gp/src/algorithm.rs | 52 +++++++++------------------------------- gp/src/parameters.rs | 17 ++++++++++++- gp/src/sgp_algorithm.rs | 2 +- gp/src/sgp_parameters.rs | 8 ++++++- 4 files changed, 35 insertions(+), 44 deletions(-) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index de643b4c..0496c990 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -27,7 +27,7 @@ use ndarray_rand::rand_distr::{Normal, Uniform}; use ndarray_rand::RandomExt; // const LOG10_20: f64 = 1.301_029_995_663_981_3; //f64::log10(20.); -const N_START: usize = 1; // number of optimization restart (aka multistart) +//const N_START: usize = 0; // number of optimization restart (aka multistart) /// Internal parameters computed Gp during training /// used later on in prediction computations @@ -813,42 +813,9 @@ impl, Corr: CorrelationModel, D: Data { - // let mut rng = Xoshiro256Plus::seed_from_u64(42); - // theta0s.row_mut(0).assign(&Array::random_using( - // theta0.len(), - // Uniform::new(F::cast(-6), F::cast(2)), - // &mut rng, - // )) - // } - // std::cmp::Ordering::Greater => { - // let mut xlimits: Array2 = Array2::zeros((theta0.len(), 2)); - // for mut row in xlimits.rows_mut() { - // row.assign(&arr1(&[F::cast(-6), F::cast(2)])); - // } - // // Use a seed here for reproducibility. Do we need to make it truly random - // // Probably no, as it is just to get init values spread over - // // [1e-6, 20] for multistart thanks to LHS method. - - // let seeds = Lhs::new(&xlimits) - // .kind(egobox_doe::LhsKind::Maximin) - // .with_rng(Xoshiro256Plus::seed_from_u64(42)) - // .sample(N_START); - // Zip::from(theta0s.slice_mut(s![1.., ..]).rows_mut()) - // .and(seeds.rows()) - // .par_for_each(|mut theta, row| theta.assign(&row)); - // } - // std::cmp::Ordering::Less => (), - // }; - + // Multistart: user theta0 + 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 1., 10. // let bounds = vec![(F::cast(-6.), F::cast(2.)); theta0.len()]; - - let (theta0s, bounds) = prepare_multistart(&theta0); + let (theta0s, bounds) = prepare_multistart(self.n_start(), &theta0); let opt_thetas = theta0s.map_axis(Axis(1), |theta| { optimize_params(objfn, &theta.to_owned(), &bounds) @@ -870,17 +837,20 @@ impl, Corr: CorrelationModel, D: Data(theta0: &Array1) -> (Array2, Vec<(F, F)>) { +pub(crate) fn prepare_multistart( + n_start: usize, + theta0: &Array1, +) -> (Array2, Vec<(F, F)>) { let limits = (F::cast(-6.), F::cast(2.)); // let mut bounds = vec![(F::cast(1e-16).log10(), F::cast(1.).log10()); params.ncols()]; - // let limits = (F::cast(-16), F::cast(0.)); + //let limits = (F::cast(-16), F::cast(0.)); let bounds = vec![limits; theta0.len()]; // Multistart: user theta0 + 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 1., 10. - let mut theta0s = Array2::zeros((N_START + 1, theta0.len())); + let mut theta0s = Array2::zeros((n_start + 1, theta0.len())); theta0s.row_mut(0).assign(&theta0.mapv(|v| F::log10(v))); - match N_START.cmp(&1) { + match n_start.cmp(&1) { std::cmp::Ordering::Equal => { //let mut rng = Xoshiro256Plus::seed_from_u64(42); let mut rng = Xoshiro256Plus::from_entropy(); @@ -902,7 +872,7 @@ pub(crate) fn prepare_multistart(theta0: &Array1) -> (Array2, Ve let seeds = Lhs::new(&xlimits) .kind(egobox_doe::LhsKind::Maximin) .with_rng(Xoshiro256Plus::seed_from_u64(42)) - .sample(N_START); + .sample(n_start); Zip::from(theta0s.slice_mut(s![1.., ..]).rows_mut()) .and(seeds.rows()) .par_for_each(|mut theta, row| theta.assign(&row)); diff --git a/gp/src/parameters.rs b/gp/src/parameters.rs index 64e6578d..c3824414 100644 --- a/gp/src/parameters.rs +++ b/gp/src/parameters.rs @@ -14,6 +14,8 @@ pub struct GpValidParams, Corr: CorrelationMo pub(crate) corr: Corr, /// Optionally apply dimension reduction (KPLS) or not pub(crate) kpls_dim: Option, + /// Number of optimization restart + pub(crate) n_start: usize, /// Parameter to improve numerical stability pub(crate) nugget: F, } @@ -25,6 +27,7 @@ impl Default for GpValidParams, Corr: CorrelationModel> GpValidParam &self.kpls_dim } + /// Get the number of internal optimization restart + pub fn n_start(&self) -> usize { + self.n_start + } + /// Get number of components used by PLS pub fn nugget(&self) -> F { self.nugget @@ -72,6 +80,7 @@ impl, Corr: CorrelationModel> GpParams, Corr: CorrelationModel> GpParams) -> Self { self.0.kpls_dim = kpls_dim; self } + /// Set the number of internal GP hyperparameter theta optimization restart + pub fn n_start(mut self, n_start: usize) -> Self { + self.0.n_start = n_start; + self + } + /// Set nugget. /// /// Nugget is used to improve numerical stability diff --git a/gp/src/sgp_algorithm.rs b/gp/src/sgp_algorithm.rs index 9dc9d009..45959663 100644 --- a/gp/src/sgp_algorithm.rs +++ b/gp/src/sgp_algorithm.rs @@ -483,7 +483,7 @@ impl, D: Data> // // bounds of theta, variance and optionally noise variance // let mut bounds = vec![(F::cast(1e-16).log10(), F::cast(1.).log10()); params.ncols()]; - let (params, mut bounds) = prepare_multistart(¶ms_0); + let (params, mut bounds) = prepare_multistart(self.n_start(), ¶ms_0); // variance bounds bounds[params.ncols() - 1 - is_noise_estimated as usize] = diff --git a/gp/src/sgp_parameters.rs b/gp/src/sgp_parameters.rs index 28e6621f..b4c5f823 100644 --- a/gp/src/sgp_parameters.rs +++ b/gp/src/sgp_parameters.rs @@ -86,11 +86,16 @@ impl> SgpValidParams { &self.gp_params.corr } - /// Get number of components used by PLS + /// Get the number of components used by PLS pub fn kpls_dim(&self) -> &Option { &self.gp_params.kpls_dim } + /// Get the number of internal GP hyperparameters optimization restart + pub fn n_start(&self) -> usize { + self.gp_params.n_start + } + /// Get number of components used by PLS pub fn nugget(&self) -> F { self.gp_params.nugget @@ -131,6 +136,7 @@ impl> SgpParams { mean: ConstantMean::default(), corr, kpls_dim: None, + n_start: 10, nugget: F::cast(1000.0) * F::epsilon(), }, noise: VarianceEstimation::default(), From 54bb51c3b768df3d39e9fe195d148604ec9c89cc Mon Sep 17 00:00:00 2001 From: relf Date: Sat, 27 Jan 2024 16:21:50 +0100 Subject: [PATCH 06/26] Add n_start argument to control hyperparams optimization restarts --- gp/src/parameters.rs | 2 +- gp/src/sgp_parameters.rs | 6 ++++++ moe/src/gp_algorithm.rs | 1 + moe/src/gp_parameters.rs | 16 +++++++++++++++ moe/src/sgp_algorithm.rs | 3 ++- moe/src/sgp_parameters.rs | 28 ++++++++++++++++++++------ moe/src/surrogates.rs | 24 ++++++++++++++++------ src/gp_mix.rs | 11 ++++++++++ src/sparse_gp_mix.rs | 42 +++++++++++++++++++++++++++++---------- 9 files changed, 108 insertions(+), 25 deletions(-) diff --git a/gp/src/parameters.rs b/gp/src/parameters.rs index c3824414..7d0d5100 100644 --- a/gp/src/parameters.rs +++ b/gp/src/parameters.rs @@ -112,7 +112,7 @@ impl, Corr: CorrelationModel> GpParams Self { self.0.n_start = n_start; self diff --git a/gp/src/sgp_parameters.rs b/gp/src/sgp_parameters.rs index b4c5f823..0dbc2c6b 100644 --- a/gp/src/sgp_parameters.rs +++ b/gp/src/sgp_parameters.rs @@ -168,6 +168,12 @@ impl> SgpParams { self } + /// Set the number of internal hyperparameters optimization restarts + pub fn n_start(mut self, n_start: usize) -> Self { + self.0.gp_params.n_start = n_start; + self + } + /// Set nugget value. /// /// Nugget is used to improve numerical stability diff --git a/moe/src/gp_algorithm.rs b/moe/src/gp_algorithm.rs index cf95d11e..1dc10ef9 100644 --- a/moe/src/gp_algorithm.rs +++ b/moe/src/gp_algorithm.rs @@ -270,6 +270,7 @@ impl GpMixValidParams { }; let mut expert_params = best_expert_params?; expert_params.kpls_dim(self.kpls_dim()); + expert_params.n_start(self.n_start()); let expert = expert_params.train(&xtrain.view(), &ytrain.view()); if let Some(v) = best.1 { info!("Best expert {} accuracy={}", best.0, v); diff --git a/moe/src/gp_parameters.rs b/moe/src/gp_parameters.rs index fd966b61..2b4d403b 100644 --- a/moe/src/gp_parameters.rs +++ b/moe/src/gp_parameters.rs @@ -32,6 +32,8 @@ pub struct GpMixValidParams { /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, + /// Number of GP hyperparameters optimization restarts + n_start: usize, /// Gaussian Mixture model used to cluster gmm: Option>>, /// GaussianMixture preset @@ -48,6 +50,7 @@ impl Default for GpMixValidParams regression_spec: RegressionSpec::ALL, correlation_spec: CorrelationSpec::ALL, kpls_dim: None, + n_start: 10, gmm: None, gmx: None, rng: R::from_entropy(), @@ -81,6 +84,11 @@ impl GpMixValidParams { self.kpls_dim } + /// The number of hypermarameters optimization restarts + pub fn n_start(&self) -> usize { + self.n_start + } + /// An optional gaussian mixture to be fitted to generate multivariate normal /// in turns used to cluster pub fn gmm(&self) -> &Option>> { @@ -135,6 +143,7 @@ impl GpMixParams { regression_spec: RegressionSpec::ALL, correlation_spec: CorrelationSpec::ALL, kpls_dim: None, + n_start: 10, gmm: None, gmx: None, rng, @@ -179,6 +188,12 @@ impl GpMixParams { self } + /// Sets the number of hyperparameters optimization restarts + pub fn n_start(mut self, n_start: usize) -> Self { + self.0.n_start = n_start; + self + } + #[doc(hidden)] /// Sets the gaussian mixture (used to find the optimal number of clusters) pub(crate) fn gmm(mut self, gmm: Option>>) -> Self { @@ -205,6 +220,7 @@ impl GpMixParams { regression_spec: self.0.regression_spec(), correlation_spec: self.0.correlation_spec(), kpls_dim: self.0.kpls_dim(), + n_start: self.0.n_start(), gmm: self.0.gmm().clone(), gmx: self.0.gmx().clone(), rng, diff --git a/moe/src/sgp_algorithm.rs b/moe/src/sgp_algorithm.rs index 33ef0fe7..e56d7e53 100644 --- a/moe/src/sgp_algorithm.rs +++ b/moe/src/sgp_algorithm.rs @@ -258,8 +258,9 @@ impl SparseGpMixtureValidParams { }; let mut expert_params = best_expert_params?; let seed = self.rng().gen(); - expert_params.kpls_dim(self.kpls_dim()); expert_params.initial_theta(self.initial_theta()); + expert_params.kpls_dim(self.kpls_dim()); + expert_params.n_start(self.n_start()); expert_params.sparse_method(self.sparse_method()); expert_params.seed(seed); debug!("Train best expert..."); diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index c22997e7..270a542f 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -35,6 +35,8 @@ pub struct SparseGpMixtureValidParams { /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, + /// Number of GP hyperparameters optimization restarts + n_start: usize, /// Used sparse method sparse_method: SparseMethod, /// Inducings @@ -54,8 +56,9 @@ impl Default for SparseGpMixtureValidPar recombination: Recombination::Smooth(Some(F::one())), regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, - kpls_dim: None, initial_theta: None, + kpls_dim: None, + n_start: 10, sparse_method: SparseMethod::default(), inducings: Inducings::default(), gmm: None, @@ -86,14 +89,19 @@ impl SparseGpMixtureValidParams { self.correlation_spec } + /// The optional initial guess for GP theta hyperparameters + pub fn initial_theta(&self) -> Option> { + self.initial_theta.clone() + } + /// The optional number of PLS components pub fn kpls_dim(&self) -> Option { self.kpls_dim } - /// The optional initial guess for GP theta hyperparameters - pub fn initial_theta(&self) -> Option> { - self.initial_theta.clone() + /// The number of hypermarameters optimization restarts + pub fn n_start(&self) -> usize { + self.n_start } /// The sparse method used @@ -158,8 +166,9 @@ impl SparseGpMixtureParams { recombination: Recombination::Smooth(Some(F::one())), regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, - kpls_dim: None, initial_theta: None, + kpls_dim: None, + n_start: 10, sparse_method: SparseMethod::default(), inducings, gmm: None, @@ -205,6 +214,12 @@ impl SparseGpMixtureParams { self } + /// Sets the number of hyperparameters optimization restarts + pub fn n_start(mut self, n_start: usize) -> Self { + self.0.n_start = n_start; + self + } + /// Sets /// /// None means no PLS dimension reduction applied. @@ -246,8 +261,9 @@ impl SparseGpMixtureParams { recombination: self.0.recombination(), regression_spec: self.0.regression_spec(), correlation_spec: self.0.correlation_spec(), - kpls_dim: self.0.kpls_dim(), initial_theta: self.0.initial_theta(), + kpls_dim: self.0.kpls_dim(), + n_start: self.0.n_start(), sparse_method: self.0.sparse_method(), inducings: self.0.inducings().clone(), gmm: self.0.gmm().clone(), diff --git a/moe/src/surrogates.rs b/moe/src/surrogates.rs index c7e0c16a..281eef64 100644 --- a/moe/src/surrogates.rs +++ b/moe/src/surrogates.rs @@ -16,24 +16,28 @@ use crate::MoeError; use std::fs; #[cfg(feature = "persistent")] use std::io::Write; -/// A trait for Gp surrogate parameters to build surrogate once fitted. +/// A trait for Gp surrogate parameters to build surrogate. pub trait GpSurrogateParams { /// Set initial theta fn initial_theta(&mut self, theta: Option>); /// Set the number of PLS components fn kpls_dim(&mut self, kpls_dim: Option); + /// Set the nuber of internal optimization restarts + fn n_start(&mut self, n_start: usize); /// Set the nugget parameter to improve numerical stability fn nugget(&mut self, nugget: f64); /// Train the surrogate fn train(&self, x: &ArrayView2, y: &ArrayView2) -> Result>; } -/// A trait for sparse GP surrogate parameters to build surrogate once fitted. +/// A trait for sparse GP surrogate parameters to build surrogate. pub trait SgpSurrogateParams { /// Set initial theta fn initial_theta(&mut self, theta: Option>); /// Set the number of PLS components fn kpls_dim(&mut self, kpls_dim: Option); + /// Set the nuber of internal optimization restarts + fn n_start(&mut self, n_start: usize); /// Set the sparse method fn sparse_method(&mut self, method: SparseMethod); /// Set random generator seed @@ -106,6 +110,10 @@ macro_rules! declare_surrogate { self.0 = self.0.clone().kpls_dim(kpls_dim); } + fn n_start(&mut self, n_start: usize) { + self.0 = self.0.clone().n_start(n_start); + } + fn nugget(&mut self, nugget: f64) { self.0 = self.0.clone().nugget(nugget); } @@ -216,14 +224,18 @@ macro_rules! declare_sgp_surrogate { self.0 = self.0.clone().initial_theta(theta); } - fn sparse_method(&mut self, method: SparseMethod) { - self.0 = self.0.clone().sparse_method(method); - } - fn kpls_dim(&mut self, kpls_dim: Option) { self.0 = self.0.clone().kpls_dim(kpls_dim); } + fn n_start(&mut self, n_start: usize) { + self.0 = self.0.clone().n_start(n_start); + } + + fn sparse_method(&mut self, method: SparseMethod) { + self.0 = self.0.clone().sparse_method(method); + } + fn seed(&mut self, seed: Option) { self.0 = self.0.clone().seed(seed); } diff --git a/src/gp_mix.rs b/src/gp_mix.rs index 5899837a..334706af 100644 --- a/src/gp_mix.rs +++ b/src/gp_mix.rs @@ -49,6 +49,9 @@ use rand_xoshiro::Xoshiro256Plus; /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. /// +/// n_start (int >= 0) +/// Number of internal GP hyperpameters optimization restart (multistart) +/// /// seed (int >= 0) /// Random generator seed to allow computation reproducibility. /// @@ -59,6 +62,7 @@ pub(crate) struct GpMix { pub correlation_spec: CorrelationSpec, pub recombination: Recombination, pub kpls_dim: Option, + pub n_start: usize, pub seed: Option, } @@ -71,6 +75,7 @@ impl GpMix { corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, recombination = Recombination::Smooth, kpls_dim = None, + n_start = 10, seed = None ))] #[allow(clippy::too_many_arguments)] @@ -80,6 +85,7 @@ impl GpMix { corr_spec: u8, recombination: Recombination, kpls_dim: Option, + n_start: usize, seed: Option, ) -> Self { GpMix { @@ -88,6 +94,7 @@ impl GpMix { correlation_spec: CorrelationSpec(corr_spec), recombination, kpls_dim, + n_start, seed, } } @@ -124,6 +131,7 @@ impl GpMix { egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), ) .kpls_dim(self.kpls_dim) + .n_start(self.n_start) .with_rng(rng) .fit(&dataset) .expect("MoE model training") @@ -149,6 +157,7 @@ impl Gpx { corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, recombination = Recombination::Smooth, kpls_dim = None, + n_start = 10, seed = None ))] fn builder( @@ -157,6 +166,7 @@ impl Gpx { corr_spec: u8, recombination: Recombination, kpls_dim: Option, + n_start: usize, seed: Option, ) -> GpMix { GpMix::new( @@ -165,6 +175,7 @@ impl Gpx { corr_spec, recombination, kpls_dim, + n_start, seed, ) } diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index d963db14..37f17914 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -41,13 +41,16 @@ use rand_xoshiro::Xoshiro256Plus; /// * Hard: prediction is taken from the expert with highest responsability /// resulting in a model with discontinuities. /// +/// initial_theta ([nx] where nx is the dimension of inputs x) +/// Initial guess for GP theta hyperparameters. +/// When None the default is 1e-2 for all components +/// /// kpls_dim (0 < int < nx where nx is the dimension of inputs x) /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. /// -/// initial_theta ([nx] where nx is the dimension of inputs x) -/// Initial guess for GP theta hyperparameters. -/// When None the default is 1e-2 for all components +/// n_start (int >= 0) +/// Number of internal GP hyperpameters optimization restart (multistart) /// /// method (SparseMethod.FITC or SparseMethod.VFE) /// Sparse method to be used (default is FITC) @@ -58,8 +61,9 @@ use rand_xoshiro::Xoshiro256Plus; #[pyclass] pub(crate) struct SparseGpMix { pub correlation_spec: CorrelationSpec, - pub kpls_dim: Option, pub initial_theta: Option>, + pub kpls_dim: Option, + pub n_start: usize, pub nz: Option, pub z: Option>, pub method: SparseMethod, @@ -71,8 +75,9 @@ impl SparseGpMix { #[new] #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, - kpls_dim = None, initial_theta = None, + kpls_dim = None, + n_start = 10, nz = None, z = None, method = SparseMethod::Fitc, @@ -81,8 +86,9 @@ impl SparseGpMix { #[allow(clippy::too_many_arguments)] fn new( corr_spec: u8, - kpls_dim: Option, initial_theta: Option>, + kpls_dim: Option, + n_start: usize, nz: Option, z: Option>, method: SparseMethod, @@ -90,8 +96,9 @@ impl SparseGpMix { ) -> Self { SparseGpMix { correlation_spec: CorrelationSpec(corr_spec), - kpls_dim, initial_theta, + kpls_dim, + n_start, nz, z: z.map(|z| z.as_array().to_owned()), method, @@ -143,8 +150,9 @@ impl SparseGpMix { .correlation_spec( egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), ) - .kpls_dim(self.kpls_dim) .initial_theta(self.initial_theta.clone()) + .kpls_dim(self.kpls_dim) + .n_start(self.n_start) .sparse_method(method) .with_rng(rng) .fit(&dataset) @@ -166,23 +174,35 @@ impl SparseGpx { #[staticmethod] #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, - kpls_dim = None, initial_theta = None, + kpls_dim = None, + n_start = 10, nz = None, z = None, method = SparseMethod::Fitc, seed = None ))] + #[allow(clippy::too_many_arguments)] fn builder( corr_spec: u8, - kpls_dim: Option, initial_theta: Option>, + kpls_dim: Option, + n_start: usize, nz: Option, z: Option>, method: SparseMethod, seed: Option, ) -> SparseGpMix { - SparseGpMix::new(corr_spec, kpls_dim, initial_theta, nz, z, method, seed) + SparseGpMix::new( + corr_spec, + initial_theta, + kpls_dim, + n_start, + nz, + z, + method, + seed, + ) } /// Returns the String representation from serde json serializer From 4ec0e225e9ab829bd94453787dec2f4e45ff9417 Mon Sep 17 00:00:00 2001 From: relf Date: Mon, 29 Jan 2024 18:17:50 +0100 Subject: [PATCH 07/26] Add theta tuning interface for SGP --- gp/benches/gp.rs | 2 +- gp/src/algorithm.rs | 70 ++++++++++++-------- gp/src/errors.rs | 5 +- gp/src/parameters.rs | 130 +++++++++++++++++++++++++++++++------- gp/src/sgp_algorithm.rs | 60 ++++++++---------- gp/src/sgp_parameters.rs | 67 ++++++++++++++------ moe/src/sgp_algorithm.rs | 2 +- moe/src/sgp_parameters.rs | 62 ++++++++++++------ moe/src/surrogates.rs | 18 +++--- src/sparse_gp_mix.rs | 49 +++++++++++--- 10 files changed, 319 insertions(+), 146 deletions(-) diff --git a/gp/benches/gp.rs b/gp/benches/gp.rs index e31e21b1..b093c136 100644 --- a/gp/benches/gp.rs +++ b/gp/benches/gp.rs @@ -58,7 +58,7 @@ fn criterion_gp(c: &mut Criterion) { SquaredExponentialCorr::default(), ) .kpls_dim(Some(1)) - .initial_theta(Some(vec![1.0])) + .theta_guess(vec![1.0]) .fit(&Dataset::new(xt.to_owned(), yt.to_owned())) .expect("GP fit error"), ) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index 0496c990..efa7aba2 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -15,7 +15,7 @@ use ndarray::{arr1, s, Array, Array1, Array2, ArrayBase, Axis, Data, Ix1, Ix2, Z use ndarray_einsum_beta::*; #[cfg(feature = "blas")] use ndarray_linalg::{cholesky::*, eigh::*, qr::*, svd::*, triangular::*}; -use ndarray_rand::rand::SeedableRng; +use ndarray_rand::rand::{Rng, SeedableRng}; use ndarray_stats::QuantileExt; use rand_xoshiro::Xoshiro256Plus; @@ -23,7 +23,7 @@ use rand_xoshiro::Xoshiro256Plus; use serde::{Deserialize, Serialize}; use std::fmt; -use ndarray_rand::rand_distr::{Normal, Uniform}; +use ndarray_rand::rand_distr::Normal; use ndarray_rand::RandomExt; // const LOG10_20: f64 = 1.301_029_995_663_981_3; //f64::log10(20.); @@ -751,7 +751,7 @@ impl, Corr: CorrelationModel, D: Data x.ncols() { - return Err(GpError::InvalidValue(format!( + return Err(GpError::InvalidValueError(format!( "Dimension reduction {} should be smaller than actual \ training input dimensions {}", d, @@ -786,12 +786,17 @@ impl, Corr: CorrelationModel, D: Data, _params: &mut ()| -> f64 { @@ -815,7 +820,20 @@ impl, Corr: CorrelationModel, D: Data, Corr: CorrelationModel, D: Data( n_start: usize, theta0: &Array1, + bounds: &[(F, F)], ) -> (Array2, Vec<(F, F)>) { - let limits = (F::cast(-6.), F::cast(2.)); - // let mut bounds = vec![(F::cast(1e-16).log10(), F::cast(1.).log10()); params.ncols()]; - //let limits = (F::cast(-16), F::cast(0.)); - let bounds = vec![limits; theta0.len()]; + // Use log10 theta as optimization parameter + let bounds: Vec<(F, F)> = bounds + .iter() + .map(|(lo, up)| (lo.log10(), up.log10())) + .collect(); // Multistart: user theta0 + 1e-5, 1e-4, 1e-3, 1e-2, 0.1, 1., 10. let mut theta0s = Array2::zeros((n_start + 1, theta0.len())); @@ -854,17 +874,17 @@ pub(crate) fn prepare_multistart( std::cmp::Ordering::Equal => { //let mut rng = Xoshiro256Plus::seed_from_u64(42); let mut rng = Xoshiro256Plus::from_entropy(); - theta0s.row_mut(1).assign(&Array::random_using( - theta0.len(), - Uniform::new(limits.0, limits.1), - &mut rng, - )) + let vals = bounds.iter().map(|(a, b)| rng.gen_range(*a..*b)).collect(); + theta0s.row_mut(1).assign(&Array::from_vec(vals)) } std::cmp::Ordering::Greater => { - let mut xlimits: Array2 = Array2::zeros((theta0.len(), 2)); - for mut row in xlimits.rows_mut() { - row.assign(&arr1(&[limits.0, limits.1])); - } + let mut xlimits: Array2 = Array2::zeros((bounds.len(), 2)); + // for mut row in xlimits.rows_mut() { + // row.assign(&arr1(&[limits.0, limits.1])); + // } + Zip::from(xlimits.rows_mut()) + .and(&bounds) + .for_each(|mut row, limits| row.assign(&arr1(&[limits.0, limits.1]))); // Use a seed here for reproducibility. Do we need to make it truly random // Probably no, as it is just to get init values spread over // [1e-6, 20] for multistart thanks to LHS method. @@ -1187,7 +1207,7 @@ mod tests { ConstantMean::default(), SquaredExponentialCorr::default(), ) - .initial_theta(Some(vec![0.1])) + .theta_guess(vec![0.1]) .kpls_dim(Some(1)) .fit(&Dataset::new(xt, yt)) .expect("GP fit error"); @@ -1210,7 +1230,7 @@ mod tests { [<$regr Mean>]::default(), [<$corr Corr>]::default(), ) - .initial_theta(Some(vec![0.1])) + .theta_guess(vec![0.1]) .fit(&Dataset::new(xt, yt)) .expect("GP fit error"); let yvals = gp diff --git a/gp/src/errors.rs b/gp/src/errors.rs index 6edaec01..ae8e677d 100644 --- a/gp/src/errors.rs +++ b/gp/src/errors.rs @@ -21,9 +21,6 @@ pub enum GpError { /// When PLS fails #[error("PLS error: {0}")] PlsError(#[from] linfa_pls::PlsError), - /// When a value is invalid - #[error("PLS error: {0}")] - InvalidValue(String), /// When a linfa error occurs #[error(transparent)] LinfaError(#[from] linfa::error::Error), @@ -36,7 +33,7 @@ pub enum GpError { /// When error during loading #[error("Load error: {0}")] LoadError(String), - /// When error during loading + /// When error dur to a bad value #[error("InvalidValue error: {0}")] InvalidValueError(String), } diff --git a/gp/src/parameters.rs b/gp/src/parameters.rs index 7d0d5100..07879136 100644 --- a/gp/src/parameters.rs +++ b/gp/src/parameters.rs @@ -2,12 +2,71 @@ use crate::correlation_models::{CorrelationModel, SquaredExponentialCorr}; use crate::errors::{GpError, Result}; use crate::mean_models::{ConstantMean, RegressionModel}; use linfa::{Float, ParamGuard}; +use std::convert::TryFrom; + +#[cfg(feature = "serializable")] +use serde::{Deserialize, Serialize}; + +/// A structure to represent a n-dim parameter estimation +#[derive(Clone, Debug, PartialEq, Eq)] +#[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))] +pub struct ParamTuning { + pub guess: Vec, + pub bounds: Vec<(F, F)>, +} + +impl TryFrom> for ThetaTuning { + type Error = GpError; + fn try_from(pt: ParamTuning) -> Result> { + if pt.guess.len() != pt.bounds.len() && (pt.guess.len() != 1 || pt.bounds.len() != 1) { + return Err(GpError::InvalidValueError( + "Bad theta tuning specification".to_string(), + )); + } + // TODO: check if guess in bounds + Ok(ThetaTuning(pt)) + } +} + +/// As structure for theta hyperparameters guess +#[derive(Clone, Debug, PartialEq, Eq)] +#[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))] + +pub struct ThetaTuning(ParamTuning); +impl Default for ThetaTuning { + fn default() -> ThetaTuning { + ThetaTuning(ParamTuning { + guess: vec![F::cast(0.01)], + bounds: vec![(F::cast(1e-6), F::cast(1e2))], + }) + } +} + +impl From> for ParamTuning { + fn from(tt: ThetaTuning) -> ParamTuning { + ParamTuning { + guess: tt.0.guess, + bounds: tt.0.bounds, + } + } +} + +impl ThetaTuning { + pub fn theta0(&self) -> &[F] { + &self.0.guess + } + pub fn bounds(&self) -> &[(F, F)] { + &self.0.bounds + } +} /// A set of validated GP parameters. #[derive(Clone, Debug, PartialEq, Eq)] pub struct GpValidParams, Corr: CorrelationModel> { /// Parameter of the autocorrelation model pub(crate) theta: Option>, + /// Parameter guess of the autocorrelation model + pub(crate) theta_tuning: ThetaTuning, /// Regression model representing the mean(x) pub(crate) mean: Mean, /// Correlation model representing the spatial correlation between errors at e(x) and e(x') @@ -24,6 +83,7 @@ impl Default for GpValidParams GpValidParams { GpValidParams { theta: None, + theta_tuning: ThetaTuning::default(), mean: ConstantMean(), corr: SquaredExponentialCorr(), kpls_dim: None, @@ -34,11 +94,6 @@ impl Default for GpValidParams, Corr: CorrelationModel> GpValidParams { - /// Get starting theta value for optimization - pub fn initial_theta(&self) -> &Option> { - &self.theta - } - /// Get mean model pub fn mean(&self) -> &Mean { &self.mean @@ -49,6 +104,11 @@ impl, Corr: CorrelationModel> GpValidParam &self.corr } + /// Get starting theta value for optimization + pub fn theta_tuning(&self) -> &ThetaTuning { + &self.theta_tuning + } + /// Get number of components used by PLS pub fn kpls_dim(&self) -> &Option { &self.kpls_dim @@ -77,6 +137,7 @@ impl, Corr: CorrelationModel> GpParams GpParams { Self(GpValidParams { theta: None, + theta_tuning: ThetaTuning::default(), mean, corr, kpls_dim: None, @@ -85,14 +146,6 @@ impl, Corr: CorrelationModel> GpParams>) -> Self { - self.0.theta = theta; - self - } - /// Set mean model. pub fn mean(mut self, mean: Mean) -> Self { self.0.mean = mean; @@ -112,6 +165,36 @@ impl, Corr: CorrelationModel> GpParams) -> Self { + self.0.theta_tuning = ParamTuning { + guess: theta_guess, + ..ThetaTuning::default().into() + } + .try_into() + .unwrap(); + self + } + + /// Set theta hyper parameter search space. + pub fn theta_bounds(mut self, theta_bounds: Vec<(F, F)>) -> Self { + self.0.theta_tuning = ParamTuning { + bounds: theta_bounds, + ..ThetaTuning::default().into() + } + .try_into() + .unwrap(); + self + } + + /// Set theta hyper parameter tuning + pub fn theta_tuning(mut self, theta_tuning: ThetaTuning) -> Self { + self.0.theta_tuning = theta_tuning; + self + } + /// Set the number of internal GP hyperparameter theta optimization restarts pub fn n_start(mut self, n_start: usize) -> Self { self.0.n_start = n_start; @@ -136,18 +219,19 @@ impl, Corr: CorrelationModel> ParamGuard fn check_ref(&self) -> Result<&Self::Checked> { if let Some(d) = self.0.kpls_dim { if d == 0 { - return Err(GpError::InvalidValue("`kpls_dim` canot be 0!".to_string())); + return Err(GpError::InvalidValueError( + "`kpls_dim` canot be 0!".to_string(), + )); } - if let Some(theta) = self.0.initial_theta() { - if theta.len() > 1 && d > theta.len() { - return Err(GpError::InvalidValue(format!( - "Dimension reduction ({}) should be smaller than expected + let theta = self.0.theta_tuning().theta0(); + if theta.len() > 1 && d > theta.len() { + return Err(GpError::InvalidValueError(format!( + "Dimension reduction ({}) should be smaller than expected training input size infered from given initial theta length ({})", - d, - theta.len() - ))); - }; - } + d, + theta.len() + ))); + }; } Ok(&self.0) } diff --git a/gp/src/sgp_algorithm.rs b/gp/src/sgp_algorithm.rs index 45959663..ed57c3e7 100644 --- a/gp/src/sgp_algorithm.rs +++ b/gp/src/sgp_algorithm.rs @@ -351,7 +351,7 @@ impl, D: Data> let y = dataset.targets(); if let Some(d) = self.kpls_dim() { if *d > x.ncols() { - return Err(GpError::InvalidValue(format!( + return Err(GpError::InvalidValueError(format!( "Dimension reduction {} should be smaller than actual \ training input dimensions {}", d, @@ -378,12 +378,14 @@ impl, D: Data> }; // Initial guess for theta - let theta0: Array1<_> = self - .initial_theta() - .clone() - .map_or(Array1::from_elem(w_star.ncols(), F::cast(1e-2)), |v| { - Array::from_vec(v) - }); + let theta0_dim = self.theta_tuning().theta0().len(); + let theta0 = if theta0_dim == 1 { + Array1::from_elem(w_star.ncols(), self.theta_tuning().theta0()[0]) + } else if theta0_dim == w_star.ncols() { + Array::from_vec(self.theta_tuning().theta0().to_vec()) + } else { + panic!("Initial guess for theta should be either 1-dim or dim of xtrain (w_star.ncols()), got {}", theta0_dim) + }; // Initial guess for variance let y_std = ytrain.std_axis(Axis(0), F::one()); @@ -462,28 +464,23 @@ impl, D: Data> } }; - // // Multistart: user theta0 + LHS samplings - // let mut params = Array2::zeros((N_START + 1, params_0.len())); - // params.row_mut(0).assign(¶ms_0.mapv(|v| F::log10(v))); - // let mut xlimits: Array2 = Array2::zeros((params_0.len(), 2)); - // for mut row in xlimits.rows_mut() { - // row.assign(&arr1(&[F::cast(-6), F::cast(2)])); - // } - // // Use a seed here for reproducibility. Do we need to make it truly random - // // Probably no, as it is just to get init values spread over - // // [1e-6, 20] for multistart thanks to LHS method. - // let seeds = Lhs::new(&xlimits) - // .kind(egobox_doe::LhsKind::Maximin) - // .with_rng(Xoshiro256Plus::seed_from_u64(42)) - // .sample(N_START); - // Zip::from(params.slice_mut(s![1.., ..]).rows_mut()) - // .and(seeds.rows()) - // .par_for_each(|mut theta, row| theta.assign(&row)); - // // bounds of theta, variance and optionally noise variance // let mut bounds = vec![(F::cast(1e-16).log10(), F::cast(1.).log10()); params.ncols()]; + // Initial guess for theta + let bounds_dim = self.theta_tuning().bounds().len(); + let bounds = if bounds_dim == 1 { + vec![self.theta_tuning().bounds()[0]; params_0.len()] + } else if theta0_dim == params_0.len() { + self.theta_tuning().bounds().to_vec() + } else { + panic!( + "Bounds for theta should be either 1-dim or dim of xtrain ({}), got {}", + w_star.ncols(), + theta0_dim + ) + }; - let (params, mut bounds) = prepare_multistart(self.n_start(), ¶ms_0); + let (params, mut bounds) = prepare_multistart(self.n_start(), ¶ms_0, &bounds); // variance bounds bounds[params.ncols() - 1 - is_noise_estimated as usize] = @@ -500,10 +497,9 @@ impl, D: Data> } } - info!("OPTIMIZE hyper params0={:?}", params); + info!("Optimize with multistart = {:?}", params); let opt_params = params.map_axis(Axis(1), |p| optimize_params(objfn, &p.to_owned(), &bounds)); - info!("END OPTIMIZE hyper parms"); let opt_index = opt_params.map(|(_, opt_f)| opt_f).argmin().unwrap(); let opt_params = &(opt_params[opt_index]).0.mapv(|v| F::cast(base.powf(v))); @@ -813,7 +809,7 @@ mod tests { let sgp = SparseKriging::params(Inducings::Randomized(n_inducings)) .seed(Some(42)) - .initial_theta(Some(vec![0.1])) + .theta_guess(vec![0.1]) .fit(&Dataset::new(xt.clone(), yt.clone())) .expect("GP fitted"); @@ -857,7 +853,7 @@ mod tests { Inducings::Located(z), ) .sparse_method(SparseMethod::Vfe) - .initial_theta(Some(vec![0.01])) + .theta_guess(vec![0.01]) .fit(&Dataset::new(xt.clone(), yt.clone())) .expect("GP fitted"); @@ -899,7 +895,7 @@ mod tests { ) .sparse_method(SparseMethod::Vfe) //.sparse_method(SparseMethod::Fitc) - .initial_theta(Some(vec![0.1])) + .theta_guess(vec![0.1]) .noise_variance(VarianceEstimation::Estimated { initial_guess: 0.02, bounds: (1e-3, 1.), @@ -910,7 +906,7 @@ mod tests { println!("theta={:?}", sgp.theta()); println!("variance={:?}", sgp.variance()); println!("noise variance={:?}", sgp.noise_variance()); - assert_abs_diff_eq!(eta2, sgp.noise_variance(), epsilon = 0.005); + assert_abs_diff_eq!(eta2, sgp.noise_variance(), epsilon = 0.01); assert_abs_diff_eq!(&z, sgp.inducings(), epsilon = 0.0015); let sgp_vals = sgp.predict_values(&xplot).unwrap(); diff --git a/gp/src/sgp_parameters.rs b/gp/src/sgp_parameters.rs index 0dbc2c6b..c0134b47 100644 --- a/gp/src/sgp_parameters.rs +++ b/gp/src/sgp_parameters.rs @@ -2,6 +2,7 @@ use crate::correlation_models::{CorrelationModel, SquaredExponentialCorr}; use crate::errors::{GpError, Result}; use crate::mean_models::ConstantMean; use crate::parameters::GpValidParams; +use crate::{ParamTuning, ThetaTuning}; use linfa::{Float, ParamGuard}; use ndarray::Array2; #[cfg(feature = "serializable")] @@ -76,11 +77,6 @@ impl Default for SgpValidParams { } impl> SgpValidParams { - /// Get starting theta value for optimization - pub fn initial_theta(&self) -> &Option> { - &self.gp_params.theta - } - /// Get correlation corr k(x, x') pub fn corr(&self) -> &Corr { &self.gp_params.corr @@ -91,6 +87,11 @@ impl> SgpValidParams { &self.gp_params.kpls_dim } + /// Get starting theta value for optimization + pub fn theta_tuning(&self) -> &ThetaTuning { + &self.gp_params.theta_tuning + } + /// Get the number of internal GP hyperparameters optimization restart pub fn n_start(&self) -> usize { self.gp_params.n_start @@ -133,6 +134,7 @@ impl> SgpParams { Self(SgpValidParams { gp_params: GpValidParams { theta: None, + theta_tuning: ThetaTuning::default(), mean: ConstantMean::default(), corr, kpls_dim: None, @@ -146,17 +148,39 @@ impl> SgpParams { }) } + /// Set correlation model. + pub fn corr(mut self, corr: Corr) -> Self { + self.0.gp_params.corr = corr; + self + } + /// Set initial value for theta hyper parameter. /// - /// During training process, the internal optimization is started from `initial_theta`. - pub fn initial_theta(mut self, theta: Option>) -> Self { - self.0.gp_params.theta = theta; + /// During training process, the internal optimization is started from `theta_guess`. + pub fn theta_guess(mut self, theta_guess: Vec) -> Self { + self.0.gp_params.theta_tuning = ParamTuning { + guess: theta_guess, + ..(self.0.gp_params.theta_tuning().clone()).into() + } + .try_into() + .unwrap(); self } - /// Set correlation model. - pub fn corr(mut self, corr: Corr) -> Self { - self.0.gp_params.corr = corr; + /// Set theta hyper parameter search space. + pub fn theta_bounds(mut self, theta_bounds: Vec<(F, F)>) -> Self { + self.0.gp_params.theta_tuning = ParamTuning { + bounds: theta_bounds, + ..(self.0.gp_params.theta_tuning()).clone().into() + } + .try_into() + .unwrap(); + self + } + + /// Get starting theta value for optimization + pub fn theta_tuning(mut self, theta_tuning: ThetaTuning) -> Self { + self.0.gp_params.theta_tuning = theta_tuning; self } @@ -220,18 +244,19 @@ impl> ParamGuard for SgpParams { fn check_ref(&self) -> Result<&Self::Checked> { if let Some(d) = self.0.gp_params.kpls_dim { if d == 0 { - return Err(GpError::InvalidValue("`kpls_dim` canot be 0!".to_string())); + return Err(GpError::InvalidValueError( + "`kpls_dim` canot be 0!".to_string(), + )); } - if let Some(theta) = self.0.initial_theta() { - if theta.len() > 1 && d > theta.len() { - return Err(GpError::InvalidValue(format!( - "Dimension reduction ({}) should be smaller than expected + let theta = self.0.theta_tuning().theta0(); + if theta.len() > 1 && d > theta.len() { + return Err(GpError::InvalidValueError(format!( + "Dimension reduction ({}) should be smaller than expected training input size infered from given initial theta length ({})", - d, - theta.len() - ))); - }; - } + d, + theta.len() + ))); + }; } Ok(&self.0) } diff --git a/moe/src/sgp_algorithm.rs b/moe/src/sgp_algorithm.rs index e56d7e53..ca98027f 100644 --- a/moe/src/sgp_algorithm.rs +++ b/moe/src/sgp_algorithm.rs @@ -258,7 +258,7 @@ impl SparseGpMixtureValidParams { }; let mut expert_params = best_expert_params?; let seed = self.rng().gen(); - expert_params.initial_theta(self.initial_theta()); + expert_params.theta_tuning(self.theta_tuning().clone()); expert_params.kpls_dim(self.kpls_dim()); expert_params.n_start(self.n_start()); expert_params.sparse_method(self.sparse_method()); diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index 270a542f..1fbc16ab 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -8,7 +8,7 @@ use egobox_gp::correlation_models::{ }; #[allow(unused_imports)] use egobox_gp::mean_models::{ConstantMean, LinearMean, QuadraticMean}; -use egobox_gp::{Inducings, SparseMethod}; +use egobox_gp::{Inducings, ParamTuning, SparseMethod, ThetaTuning}; use linfa::{Float, ParamGuard}; use linfa_clustering::GaussianMixtureModel; use ndarray::{Array1, Array2, Array3}; @@ -30,11 +30,11 @@ pub struct SparseGpMixtureValidParams { regression_spec: RegressionSpec, /// Specification of GP correlation models to be used correlation_spec: CorrelationSpec, - /// Initial Guess for GP theta hyperparameters - initial_theta: Option>, /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, + /// Theta hyperparameter tuning + theta_tuning: ThetaTuning, /// Number of GP hyperparameters optimization restarts n_start: usize, /// Used sparse method @@ -56,8 +56,8 @@ impl Default for SparseGpMixtureValidPar recombination: Recombination::Smooth(Some(F::one())), regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, - initial_theta: None, kpls_dim: None, + theta_tuning: ThetaTuning::default(), n_start: 10, sparse_method: SparseMethod::default(), inducings: Inducings::default(), @@ -89,16 +89,16 @@ impl SparseGpMixtureValidParams { self.correlation_spec } - /// The optional initial guess for GP theta hyperparameters - pub fn initial_theta(&self) -> Option> { - self.initial_theta.clone() - } - /// The optional number of PLS components pub fn kpls_dim(&self) -> Option { self.kpls_dim } + /// The speified tuning of theta hyperparameter + pub fn theta_tuning(&self) -> &ThetaTuning { + &self.theta_tuning + } + /// The number of hypermarameters optimization restarts pub fn n_start(&self) -> usize { self.n_start @@ -156,7 +156,7 @@ impl SparseGpMixtureParams { } } -impl SparseGpMixtureParams { +impl SparseGpMixtureParams { /// Constructor of Sgp parameters specifying randon number generator for reproducibility /// /// See [`new`](SparseGpMixParams::new) for default parameters. @@ -166,7 +166,7 @@ impl SparseGpMixtureParams { recombination: Recombination::Smooth(Some(F::one())), regression_spec: RegressionSpec::CONSTANT, correlation_spec: CorrelationSpec::SQUAREDEXPONENTIAL, - initial_theta: None, + theta_tuning: ThetaTuning::default(), kpls_dim: None, n_start: 10, sparse_method: SparseMethod::default(), @@ -198,14 +198,6 @@ impl SparseGpMixtureParams { self } - /// Sets the initial guess for GP theta hyperparameters - /// - /// Default is 1e-2 for all components - pub fn initial_theta(mut self, initial_theta: Option>) -> Self { - self.0.initial_theta = initial_theta; - self - } - /// Sets the number of PLS components in [1, nx] where nx is the x dimension /// /// None means no PLS dimension reduction applied. @@ -214,6 +206,36 @@ impl SparseGpMixtureParams { self } + /// Set initial value for theta hyper parameter. + /// + /// During training process, the internal optimization is started from `theta_guess`. + pub fn theta_guess(mut self, theta_guess: Vec) -> Self { + self.0.theta_tuning = ParamTuning { + guess: theta_guess, + ..ThetaTuning::default().into() + } + .try_into() + .unwrap(); + self + } + + /// Set theta hyper parameter search space. + pub fn theta_bounds(mut self, theta_bounds: Vec<(F, F)>) -> Self { + self.0.theta_tuning = ParamTuning { + bounds: theta_bounds, + ..ThetaTuning::default().into() + } + .try_into() + .unwrap(); + self + } + + /// Set theta hyper parameter tuning + pub fn theta_tuning(mut self, theta_tuning: ThetaTuning) -> Self { + self.0.theta_tuning = theta_tuning; + self + } + /// Sets the number of hyperparameters optimization restarts pub fn n_start(mut self, n_start: usize) -> Self { self.0.n_start = n_start; @@ -261,8 +283,8 @@ impl SparseGpMixtureParams { recombination: self.0.recombination(), regression_spec: self.0.regression_spec(), correlation_spec: self.0.correlation_spec(), - initial_theta: self.0.initial_theta(), kpls_dim: self.0.kpls_dim(), + theta_tuning: self.0.theta_tuning().clone(), n_start: self.0.n_start(), sparse_method: self.0.sparse_method(), inducings: self.0.inducings().clone(), diff --git a/moe/src/surrogates.rs b/moe/src/surrogates.rs index 281eef64..ae40c18d 100644 --- a/moe/src/surrogates.rs +++ b/moe/src/surrogates.rs @@ -1,7 +1,7 @@ use crate::errors::Result; use egobox_gp::{ correlation_models::*, mean_models::*, GaussianProcess, GpParams, SgpParams, - SparseGaussianProcess, SparseMethod, + SparseGaussianProcess, SparseMethod, ThetaTuning, }; use linfa::prelude::{Dataset, Fit}; use ndarray::{Array1, Array2, ArrayView2}; @@ -18,8 +18,8 @@ use std::fs; use std::io::Write; /// A trait for Gp surrogate parameters to build surrogate. pub trait GpSurrogateParams { - /// Set initial theta - fn initial_theta(&mut self, theta: Option>); + /// Set theta + fn theta_tuning(&mut self, theta_tuning: ThetaTuning); /// Set the number of PLS components fn kpls_dim(&mut self, kpls_dim: Option); /// Set the nuber of internal optimization restarts @@ -32,8 +32,8 @@ pub trait GpSurrogateParams { /// A trait for sparse GP surrogate parameters to build surrogate. pub trait SgpSurrogateParams { - /// Set initial theta - fn initial_theta(&mut self, theta: Option>); + /// Set theta + fn theta_tuning(&mut self, theta_tuning: ThetaTuning); /// Set the number of PLS components fn kpls_dim(&mut self, kpls_dim: Option); /// Set the nuber of internal optimization restarts @@ -102,8 +102,8 @@ macro_rules! declare_surrogate { } impl GpSurrogateParams for [] { - fn initial_theta(&mut self, theta: Option>) { - self.0 = self.0.clone().initial_theta(theta); + fn theta_tuning(&mut self, theta_tuning: ThetaTuning) { + self.0 = self.0.clone().theta_tuning(theta_tuning); } fn kpls_dim(&mut self, kpls_dim: Option) { @@ -220,8 +220,8 @@ macro_rules! declare_sgp_surrogate { } impl SgpSurrogateParams for [] { - fn initial_theta(&mut self, theta: Option>) { - self.0 = self.0.clone().initial_theta(theta); + fn theta_tuning(&mut self, theta_tuning: ThetaTuning) { + self.0 = self.0.clone().theta_tuning(theta_tuning); } fn kpls_dim(&mut self, kpls_dim: Option) { diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index 37f17914..d6efcc67 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -10,7 +10,7 @@ //! See the [tutorial notebook](https://github.com/relf/egobox/doc/Sgp_Tutorial.ipynb) for usage. //! use crate::types::*; -use egobox_gp::Inducings; +use egobox_gp::{Inducings, ParamTuning, ThetaTuning}; use egobox_moe::{GpSurrogate, SparseGpMixture}; use linfa::{traits::Fit, Dataset}; use ndarray::Array2; @@ -41,10 +41,14 @@ use rand_xoshiro::Xoshiro256Plus; /// * Hard: prediction is taken from the expert with highest responsability /// resulting in a model with discontinuities. /// -/// initial_theta ([nx] where nx is the dimension of inputs x) +/// theta0 ([nx] where nx is the dimension of inputs x) /// Initial guess for GP theta hyperparameters. /// When None the default is 1e-2 for all components /// +/// theta_bounds ([[lower_1, upper_1], ..., [lower_nx, upper_nx]] where nx is the dimension of inputs x) +/// Space search when optimizing theta GP hyperparameters +/// When None the default is [1e-6, 1e2] for all components +/// /// kpls_dim (0 < int < nx where nx is the dimension of inputs x) /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. @@ -61,7 +65,8 @@ use rand_xoshiro::Xoshiro256Plus; #[pyclass] pub(crate) struct SparseGpMix { pub correlation_spec: CorrelationSpec, - pub initial_theta: Option>, + pub theta0: Option>, + pub theta_bounds: Option>>, pub kpls_dim: Option, pub n_start: usize, pub nz: Option, @@ -75,7 +80,8 @@ impl SparseGpMix { #[new] #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, - initial_theta = None, + theta0 = None, + theta_bounds = None, kpls_dim = None, n_start = 10, nz = None, @@ -86,7 +92,8 @@ impl SparseGpMix { #[allow(clippy::too_many_arguments)] fn new( corr_spec: u8, - initial_theta: Option>, + theta0: Option>, + theta_bounds: Option>>, kpls_dim: Option, n_start: usize, nz: Option, @@ -96,7 +103,8 @@ impl SparseGpMix { ) -> Self { SparseGpMix { correlation_spec: CorrelationSpec(corr_spec), - initial_theta, + theta0, + theta_bounds, kpls_dim, n_start, nz, @@ -142,6 +150,24 @@ impl SparseGpMix { SparseMethod::Vfe => egobox_gp::SparseMethod::Vfe, }; + let mut theta_tuning = ThetaTuning::default(); + if let Some(guess) = self.theta0.as_ref() { + theta_tuning = ParamTuning { + guess: guess.to_vec(), + ..ThetaTuning::default().into() + } + .try_into() + .expect("Theta tuning initial guess"); + } + if let Some(bounds) = self.theta_bounds.as_ref() { + theta_tuning = ParamTuning { + bounds: bounds.iter().map(|v| (v[0], v[1])).collect(), + ..ThetaTuning::default().into() + } + .try_into() + .expect("Theta tuning bounds"); + } + let sgp = py.allow_threads(|| { SparseGpMixture::params(inducings) // .n_clusters(self.n_clusters) @@ -150,7 +176,7 @@ impl SparseGpMix { .correlation_spec( egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), ) - .initial_theta(self.initial_theta.clone()) + .theta_tuning(theta_tuning) .kpls_dim(self.kpls_dim) .n_start(self.n_start) .sparse_method(method) @@ -174,7 +200,8 @@ impl SparseGpx { #[staticmethod] #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, - initial_theta = None, + theta0 = None, + theta_bounds = None, kpls_dim = None, n_start = 10, nz = None, @@ -185,7 +212,8 @@ impl SparseGpx { #[allow(clippy::too_many_arguments)] fn builder( corr_spec: u8, - initial_theta: Option>, + theta0: Option>, + theta_bounds: Option>>, kpls_dim: Option, n_start: usize, nz: Option, @@ -195,7 +223,8 @@ impl SparseGpx { ) -> SparseGpMix { SparseGpMix::new( corr_spec, - initial_theta, + theta0, + theta_bounds, kpls_dim, n_start, nz, From 8e1a754bd3d10d2c7cf2ff155c197e1a0d33e424 Mon Sep 17 00:00:00 2001 From: relf Date: Tue, 30 Jan 2024 17:49:07 +0100 Subject: [PATCH 08/26] Fix theta tuning initialization, refactor cobyla params --- gp/src/algorithm.rs | 45 ++++++++++++++++++++++++++++----------- gp/src/parameters.rs | 10 +++++---- gp/src/sgp_algorithm.rs | 23 ++++++++++++++++---- gp/src/sgp_parameters.rs | 5 ++++- moe/src/gp_parameters.rs | 41 +++++++++++++++++++++++++++++++++++ moe/src/sgp_algorithm.rs | 1 + moe/src/sgp_parameters.rs | 4 ++-- src/sparse_gp_mix.rs | 4 ++-- 8 files changed, 108 insertions(+), 25 deletions(-) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index efa7aba2..aa7ac596 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -26,6 +26,22 @@ use std::fmt; use ndarray_rand::rand_distr::Normal; use ndarray_rand::RandomExt; +pub(crate) struct CobylaParams { + pub rhobeg: f64, + pub ftol_rel: f64, + pub maxeval: usize, +} + +impl Default for CobylaParams { + fn default() -> Self { + CobylaParams { + rhobeg: 0.5, + ftol_rel: 1e-4, + maxeval: 25, + } + } +} + // const LOG10_20: f64 = 1.301_029_995_663_981_3; //f64::log10(20.); //const N_START: usize = 0; // number of optimization restart (aka multistart) @@ -836,7 +852,15 @@ impl, Corr: CorrelationModel, D: Data( } std::cmp::Ordering::Less => (), }; - (theta0s, bounds) } @@ -909,6 +932,7 @@ pub(crate) fn optimize_params( objfn: ObjF, param0: &Array1, bounds: &[(F, F)], + cobyla: CobylaParams, ) -> (Array1, f64) where ObjF: Fn(&[f64], Option<&mut [f64]>, &mut ()) -> f64, @@ -928,9 +952,9 @@ where let upper_bounds = bounds.iter().map(|b| into_f64(&b.1)).collect::>(); optimizer.set_upper_bounds(&upper_bounds).unwrap(); - optimizer.set_initial_step1(0.5).unwrap(); - optimizer.set_maxeval(15 * param0.len() as u32).unwrap(); - optimizer.set_ftol_rel(1e-4).unwrap(); + optimizer.set_initial_step1(cobyla.rhobeg).unwrap(); + optimizer.set_maxeval(cobyla.maxeval as u32).unwrap(); + optimizer.set_ftol_rel(cobyla.ftol_rel).unwrap(); match optimizer.optimize(&mut param) { Ok((_, fmin)) => { @@ -955,6 +979,7 @@ pub(crate) fn optimize_params( objfn: ObjF, param0: &Array1, bounds: &[(F, F)], + cobyla: CobylaParams, ) -> (Array1, f64) where ObjF: Fn(&[f64], Option<&mut [f64]>, &mut ()) -> f64, @@ -966,10 +991,6 @@ where let cons: Vec<&dyn Func<()>> = vec![]; let param0 = param0.map(|v| into_f64(v)).into_raw_vec(); - let initial_step = 0.5; - let ftol_rel = 1e-4; - let maxeval = 10 * param0.len(); - let bounds: Vec<_> = bounds .iter() .map(|(lo, up)| (into_f64(lo), into_f64(up))) @@ -981,10 +1002,10 @@ where &bounds, &cons, (), - maxeval, - cobyla::RhoBeg::All(initial_step), + cobyla.maxeval, + cobyla::RhoBeg::All(cobyla.rhobeg), Some(StopTols { - ftol_rel, + ftol_rel: cobyla.ftol_rel, ..StopTols::default() }), ) { diff --git a/gp/src/parameters.rs b/gp/src/parameters.rs index 07879136..5ac755e8 100644 --- a/gp/src/parameters.rs +++ b/gp/src/parameters.rs @@ -18,10 +18,12 @@ pub struct ParamTuning { impl TryFrom> for ThetaTuning { type Error = GpError; fn try_from(pt: ParamTuning) -> Result> { - if pt.guess.len() != pt.bounds.len() && (pt.guess.len() != 1 || pt.bounds.len() != 1) { - return Err(GpError::InvalidValueError( - "Bad theta tuning specification".to_string(), - )); + if pt.guess.len() != pt.bounds.len() && (pt.guess.len() != 1 && pt.bounds.len() != 1) { + return Err(GpError::InvalidValueError(format!( + "Bad theta tuning specification {} {}", + pt.guess.len(), + pt.bounds.len() + ))); } // TODO: check if guess in bounds Ok(ThetaTuning(pt)) diff --git a/gp/src/sgp_algorithm.rs b/gp/src/sgp_algorithm.rs index ed57c3e7..143e6b8f 100644 --- a/gp/src/sgp_algorithm.rs +++ b/gp/src/sgp_algorithm.rs @@ -1,10 +1,10 @@ use crate::algorithm::optimize_params; use crate::errors::{GpError, Result}; -use crate::prepare_multistart; use crate::sgp_parameters::{ Inducings, SgpParams, SgpValidParams, SparseMethod, VarianceEstimation, }; use crate::{correlation_models::*, utils::pairwise_differences}; +use crate::{prepare_multistart, CobylaParams}; use linfa::prelude::{Dataset, DatasetBase, Fit, Float, PredictInplace}; use linfa_linalg::{cholesky::*, triangular::*}; use linfa_pls::PlsRegression; @@ -20,6 +20,7 @@ use rand_xoshiro::Xoshiro256Plus; #[cfg(feature = "serializable")] use serde::{Deserialize, Serialize}; use std::fmt; +use std::time::Instant; /// Woodbury data computed during training and used for prediction /// @@ -497,9 +498,23 @@ impl, D: Data> } } - info!("Optimize with multistart = {:?}", params); - let opt_params = - params.map_axis(Axis(1), |p| optimize_params(objfn, &p.to_owned(), &bounds)); + info!( + "Optimize with multistart theta = {:?} and bounds = {:?}", + params, bounds + ); + let now = Instant::now(); + let opt_params = params.map_axis(Axis(1), |p| { + optimize_params( + objfn, + &p.to_owned(), + &bounds, + CobylaParams { + maxeval: 10 * theta0_dim, + ..CobylaParams::default() + }, + ) + }); + info!("elapsed optim = {:?}", now.elapsed().as_millis()); let opt_index = opt_params.map(|(_, opt_f)| opt_f).argmin().unwrap(); let opt_params = &(opt_params[opt_index]).0.mapv(|v| F::cast(base.powf(v))); diff --git a/gp/src/sgp_parameters.rs b/gp/src/sgp_parameters.rs index c0134b47..a2ab2d69 100644 --- a/gp/src/sgp_parameters.rs +++ b/gp/src/sgp_parameters.rs @@ -18,7 +18,10 @@ pub enum VarianceEstimation { } impl Default for VarianceEstimation { fn default() -> VarianceEstimation { - Self::Constant(F::cast(0.01)) + Self::Estimated { + initial_guess: F::cast(1e-2), + bounds: (F::cast(100.0) * F::epsilon(), F::cast(1e10)), + } } } diff --git a/moe/src/gp_parameters.rs b/moe/src/gp_parameters.rs index 2b4d403b..84f6d62b 100644 --- a/moe/src/gp_parameters.rs +++ b/moe/src/gp_parameters.rs @@ -8,6 +8,7 @@ use egobox_gp::correlation_models::{ }; #[allow(unused_imports)] use egobox_gp::mean_models::{ConstantMean, LinearMean, QuadraticMean}; +use egobox_gp::{ParamTuning, ThetaTuning}; use linfa::{Float, ParamGuard}; use linfa_clustering::GaussianMixtureModel; use ndarray::{Array1, Array2, Array3}; @@ -32,6 +33,8 @@ pub struct GpMixValidParams { /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, + /// Theta hyperparameter tuning + theta_tuning: ThetaTuning, /// Number of GP hyperparameters optimization restarts n_start: usize, /// Gaussian Mixture model used to cluster @@ -50,6 +53,7 @@ impl Default for GpMixValidParams regression_spec: RegressionSpec::ALL, correlation_spec: CorrelationSpec::ALL, kpls_dim: None, + theta_tuning: ThetaTuning::default(), n_start: 10, gmm: None, gmx: None, @@ -84,6 +88,11 @@ impl GpMixValidParams { self.kpls_dim } + /// The speified tuning of theta hyperparameter + pub fn theta_tuning(&self) -> &ThetaTuning { + &self.theta_tuning + } + /// The number of hypermarameters optimization restarts pub fn n_start(&self) -> usize { self.n_start @@ -142,6 +151,7 @@ impl GpMixParams { recombination: Recombination::Smooth(Some(F::one())), regression_spec: RegressionSpec::ALL, correlation_spec: CorrelationSpec::ALL, + theta_tuning: ThetaTuning::default(), kpls_dim: None, n_start: 10, gmm: None, @@ -188,6 +198,36 @@ impl GpMixParams { self } + /// Set initial value for theta hyper parameter. + /// + /// During training process, the internal optimization is started from `theta_guess`. + pub fn theta_guess(mut self, theta_guess: Vec) -> Self { + self.0.theta_tuning = ParamTuning { + guess: theta_guess, + ..self.0.theta_tuning.into() + } + .try_into() + .unwrap(); + self + } + + /// Set theta hyper parameter search space. + pub fn theta_bounds(mut self, theta_bounds: Vec<(F, F)>) -> Self { + self.0.theta_tuning = ParamTuning { + bounds: theta_bounds, + ..self.0.theta_tuning.into() + } + .try_into() + .unwrap(); + self + } + + /// Set theta hyper parameter tuning + pub fn theta_tuning(mut self, theta_tuning: ThetaTuning) -> Self { + self.0.theta_tuning = theta_tuning; + self + } + /// Sets the number of hyperparameters optimization restarts pub fn n_start(mut self, n_start: usize) -> Self { self.0.n_start = n_start; @@ -220,6 +260,7 @@ impl GpMixParams { regression_spec: self.0.regression_spec(), correlation_spec: self.0.correlation_spec(), kpls_dim: self.0.kpls_dim(), + theta_tuning: self.0.theta_tuning().clone(), n_start: self.0.n_start(), gmm: self.0.gmm().clone(), gmx: self.0.gmx().clone(), diff --git a/moe/src/sgp_algorithm.rs b/moe/src/sgp_algorithm.rs index ca98027f..49936385 100644 --- a/moe/src/sgp_algorithm.rs +++ b/moe/src/sgp_algorithm.rs @@ -259,6 +259,7 @@ impl SparseGpMixtureValidParams { let mut expert_params = best_expert_params?; let seed = self.rng().gen(); expert_params.theta_tuning(self.theta_tuning().clone()); + debug!("Theta tuning = {:?}", self.theta_tuning()); expert_params.kpls_dim(self.kpls_dim()); expert_params.n_start(self.n_start()); expert_params.sparse_method(self.sparse_method()); diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index 1fbc16ab..cfb3dd5f 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -212,7 +212,7 @@ impl SparseGpMixtureParams { pub fn theta_guess(mut self, theta_guess: Vec) -> Self { self.0.theta_tuning = ParamTuning { guess: theta_guess, - ..ThetaTuning::default().into() + ..self.0.theta_tuning.into() } .try_into() .unwrap(); @@ -223,7 +223,7 @@ impl SparseGpMixtureParams { pub fn theta_bounds(mut self, theta_bounds: Vec<(F, F)>) -> Self { self.0.theta_tuning = ParamTuning { bounds: theta_bounds, - ..ThetaTuning::default().into() + ..self.0.theta_tuning.into() } .try_into() .unwrap(); diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index d6efcc67..fc689c53 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -154,7 +154,7 @@ impl SparseGpMix { if let Some(guess) = self.theta0.as_ref() { theta_tuning = ParamTuning { guess: guess.to_vec(), - ..ThetaTuning::default().into() + ..theta_tuning.into() } .try_into() .expect("Theta tuning initial guess"); @@ -162,7 +162,7 @@ impl SparseGpMix { if let Some(bounds) = self.theta_bounds.as_ref() { theta_tuning = ParamTuning { bounds: bounds.iter().map(|v| (v[0], v[1])).collect(), - ..ThetaTuning::default().into() + ..theta_tuning.into() } .try_into() .expect("Theta tuning bounds"); From 4c118cdae088ea93883fdcfc96e0c813856b3f4a Mon Sep 17 00:00:00 2001 From: relf Date: Tue, 30 Jan 2024 18:29:16 +0100 Subject: [PATCH 09/26] Renaming sparse_algorithm|parameters --- gp/src/lib.rs | 8 ++++---- gp/src/{sgp_algorithm.rs => sparse_algorithm.rs} | 2 +- gp/src/{sgp_parameters.rs => sparse_parameters.rs} | 0 3 files changed, 5 insertions(+), 5 deletions(-) rename gp/src/{sgp_algorithm.rs => sparse_algorithm.rs} (99%) rename gp/src/{sgp_parameters.rs => sparse_parameters.rs} (100%) diff --git a/gp/src/lib.rs b/gp/src/lib.rs index 683ab528..795f5a9e 100644 --- a/gp/src/lib.rs +++ b/gp/src/lib.rs @@ -14,14 +14,14 @@ mod algorithm; pub mod correlation_models; mod errors; pub mod mean_models; -mod sgp_algorithm; +mod sparse_algorithm; mod parameters; -mod sgp_parameters; +mod sparse_parameters; mod utils; pub use algorithm::*; pub use errors::*; pub use parameters::*; -pub use sgp_algorithm::*; -pub use sgp_parameters::*; +pub use sparse_algorithm::*; +pub use sparse_parameters::*; diff --git a/gp/src/sgp_algorithm.rs b/gp/src/sparse_algorithm.rs similarity index 99% rename from gp/src/sgp_algorithm.rs rename to gp/src/sparse_algorithm.rs index 143e6b8f..b851d46b 100644 --- a/gp/src/sgp_algorithm.rs +++ b/gp/src/sparse_algorithm.rs @@ -1,6 +1,6 @@ use crate::algorithm::optimize_params; use crate::errors::{GpError, Result}; -use crate::sgp_parameters::{ +use crate::sparse_parameters::{ Inducings, SgpParams, SgpValidParams, SparseMethod, VarianceEstimation, }; use crate::{correlation_models::*, utils::pairwise_differences}; diff --git a/gp/src/sgp_parameters.rs b/gp/src/sparse_parameters.rs similarity index 100% rename from gp/src/sgp_parameters.rs rename to gp/src/sparse_parameters.rs From b36c359943b1dbe478718f0d4d79cd3641ea66e3 Mon Sep 17 00:00:00 2001 From: relf Date: Tue, 30 Jan 2024 20:36:58 +0100 Subject: [PATCH 10/26] Renaming theta_init --- gp/benches/gp.rs | 2 +- gp/src/algorithm.rs | 4 ++-- gp/src/parameters.rs | 10 +++------- gp/src/sparse_algorithm.rs | 6 +++--- gp/src/sparse_parameters.rs | 9 ++++----- moe/src/gp_parameters.rs | 28 ++++++++++++++-------------- moe/src/sgp_parameters.rs | 22 +++++++++++----------- src/sparse_gp_mix.rs | 18 +++++++++--------- 8 files changed, 47 insertions(+), 52 deletions(-) diff --git a/gp/benches/gp.rs b/gp/benches/gp.rs index b093c136..65529ad0 100644 --- a/gp/benches/gp.rs +++ b/gp/benches/gp.rs @@ -58,7 +58,7 @@ fn criterion_gp(c: &mut Criterion) { SquaredExponentialCorr::default(), ) .kpls_dim(Some(1)) - .theta_guess(vec![1.0]) + .theta_init(vec![1.0]) .fit(&Dataset::new(xt.to_owned(), yt.to_owned())) .expect("GP fit error"), ) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index aa7ac596..a54081d2 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -1228,7 +1228,7 @@ mod tests { ConstantMean::default(), SquaredExponentialCorr::default(), ) - .theta_guess(vec![0.1]) + .theta_init(vec![0.1]) .kpls_dim(Some(1)) .fit(&Dataset::new(xt, yt)) .expect("GP fit error"); @@ -1251,7 +1251,7 @@ mod tests { [<$regr Mean>]::default(), [<$corr Corr>]::default(), ) - .theta_guess(vec![0.1]) + .theta_init(vec![0.1]) .fit(&Dataset::new(xt, yt)) .expect("GP fit error"); let yvals = gp diff --git a/gp/src/parameters.rs b/gp/src/parameters.rs index 5ac755e8..e4826765 100644 --- a/gp/src/parameters.rs +++ b/gp/src/parameters.rs @@ -65,8 +65,6 @@ impl ThetaTuning { /// A set of validated GP parameters. #[derive(Clone, Debug, PartialEq, Eq)] pub struct GpValidParams, Corr: CorrelationModel> { - /// Parameter of the autocorrelation model - pub(crate) theta: Option>, /// Parameter guess of the autocorrelation model pub(crate) theta_tuning: ThetaTuning, /// Regression model representing the mean(x) @@ -84,7 +82,6 @@ pub struct GpValidParams, Corr: CorrelationMo impl Default for GpValidParams { fn default() -> GpValidParams { GpValidParams { - theta: None, theta_tuning: ThetaTuning::default(), mean: ConstantMean(), corr: SquaredExponentialCorr(), @@ -138,7 +135,6 @@ impl, Corr: CorrelationModel> GpParams GpParams { Self(GpValidParams { - theta: None, theta_tuning: ThetaTuning::default(), mean, corr, @@ -169,10 +165,10 @@ impl, Corr: CorrelationModel> GpParams) -> Self { + /// During training process, the internal optimization is started from `theta_init`. + pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.theta_tuning = ParamTuning { - guess: theta_guess, + guess: theta_init, ..ThetaTuning::default().into() } .try_into() diff --git a/gp/src/sparse_algorithm.rs b/gp/src/sparse_algorithm.rs index b851d46b..8ba7b143 100644 --- a/gp/src/sparse_algorithm.rs +++ b/gp/src/sparse_algorithm.rs @@ -824,7 +824,7 @@ mod tests { let sgp = SparseKriging::params(Inducings::Randomized(n_inducings)) .seed(Some(42)) - .theta_guess(vec![0.1]) + .theta_init(vec![0.1]) .fit(&Dataset::new(xt.clone(), yt.clone())) .expect("GP fitted"); @@ -868,7 +868,7 @@ mod tests { Inducings::Located(z), ) .sparse_method(SparseMethod::Vfe) - .theta_guess(vec![0.01]) + .theta_init(vec![0.01]) .fit(&Dataset::new(xt.clone(), yt.clone())) .expect("GP fitted"); @@ -910,7 +910,7 @@ mod tests { ) .sparse_method(SparseMethod::Vfe) //.sparse_method(SparseMethod::Fitc) - .theta_guess(vec![0.1]) + .theta_init(vec![0.1]) .noise_variance(VarianceEstimation::Estimated { initial_guess: 0.02, bounds: (1e-3, 1.), diff --git a/gp/src/sparse_parameters.rs b/gp/src/sparse_parameters.rs index a2ab2d69..a7088a4a 100644 --- a/gp/src/sparse_parameters.rs +++ b/gp/src/sparse_parameters.rs @@ -136,10 +136,9 @@ impl> SgpParams { pub fn new(corr: Corr, inducings: Inducings) -> SgpParams { Self(SgpValidParams { gp_params: GpValidParams { - theta: None, - theta_tuning: ThetaTuning::default(), mean: ConstantMean::default(), corr, + theta_tuning: ThetaTuning::default(), kpls_dim: None, n_start: 10, nugget: F::cast(1000.0) * F::epsilon(), @@ -159,10 +158,10 @@ impl> SgpParams { /// Set initial value for theta hyper parameter. /// - /// During training process, the internal optimization is started from `theta_guess`. - pub fn theta_guess(mut self, theta_guess: Vec) -> Self { + /// During training process, the internal optimization is started from `theta_init`. + pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.gp_params.theta_tuning = ParamTuning { - guess: theta_guess, + guess: theta_init, ..(self.0.gp_params.theta_tuning().clone()).into() } .try_into() diff --git a/moe/src/gp_parameters.rs b/moe/src/gp_parameters.rs index 84f6d62b..3eaef49e 100644 --- a/moe/src/gp_parameters.rs +++ b/moe/src/gp_parameters.rs @@ -30,11 +30,11 @@ pub struct GpMixValidParams { regression_spec: RegressionSpec, /// Specification of GP correlation models to be used correlation_spec: CorrelationSpec, + /// Theta hyperparameter tuning + theta_tuning: ThetaTuning, /// Number of PLS components, should be used when problem size /// is over ten variables or so. kpls_dim: Option, - /// Theta hyperparameter tuning - theta_tuning: ThetaTuning, /// Number of GP hyperparameters optimization restarts n_start: usize, /// Gaussian Mixture model used to cluster @@ -52,8 +52,8 @@ impl Default for GpMixValidParams recombination: Recombination::Smooth(Some(F::one())), regression_spec: RegressionSpec::ALL, correlation_spec: CorrelationSpec::ALL, - kpls_dim: None, theta_tuning: ThetaTuning::default(), + kpls_dim: None, n_start: 10, gmm: None, gmx: None, @@ -190,20 +190,12 @@ impl GpMixParams { self } - /// Sets the number of PLS components in [1, nx] where nx is the x dimension - /// - /// None means no PLS dimension reduction applied. - pub fn kpls_dim(mut self, kpls_dim: Option) -> Self { - self.0.kpls_dim = kpls_dim; - self - } - /// Set initial value for theta hyper parameter. /// - /// During training process, the internal optimization is started from `theta_guess`. - pub fn theta_guess(mut self, theta_guess: Vec) -> Self { + /// During training process, the internal optimization is started from `theta_init`. + pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.theta_tuning = ParamTuning { - guess: theta_guess, + guess: theta_init, ..self.0.theta_tuning.into() } .try_into() @@ -228,6 +220,14 @@ impl GpMixParams { self } + /// Sets the number of PLS components in [1, nx] where nx is the x dimension + /// + /// None means no PLS dimension reduction applied. + pub fn kpls_dim(mut self, kpls_dim: Option) -> Self { + self.0.kpls_dim = kpls_dim; + self + } + /// Sets the number of hyperparameters optimization restarts pub fn n_start(mut self, n_start: usize) -> Self { self.0.n_start = n_start; diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index cfb3dd5f..b25f545e 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -198,20 +198,12 @@ impl SparseGpMixtureParams { self } - /// Sets the number of PLS components in [1, nx] where nx is the x dimension - /// - /// None means no PLS dimension reduction applied. - pub fn kpls_dim(mut self, kpls_dim: Option) -> Self { - self.0.kpls_dim = kpls_dim; - self - } - /// Set initial value for theta hyper parameter. /// - /// During training process, the internal optimization is started from `theta_guess`. - pub fn theta_guess(mut self, theta_guess: Vec) -> Self { + /// During training process, the internal optimization is started from `theta_init`. + pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.theta_tuning = ParamTuning { - guess: theta_guess, + guess: theta_init, ..self.0.theta_tuning.into() } .try_into() @@ -236,6 +228,14 @@ impl SparseGpMixtureParams { self } + /// Sets the number of PLS components in [1, nx] where nx is the x dimension + /// + /// None means no PLS dimension reduction applied. + pub fn kpls_dim(mut self, kpls_dim: Option) -> Self { + self.0.kpls_dim = kpls_dim; + self + } + /// Sets the number of hyperparameters optimization restarts pub fn n_start(mut self, n_start: usize) -> Self { self.0.n_start = n_start; diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index fc689c53..d3fdd25e 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -41,7 +41,7 @@ use rand_xoshiro::Xoshiro256Plus; /// * Hard: prediction is taken from the expert with highest responsability /// resulting in a model with discontinuities. /// -/// theta0 ([nx] where nx is the dimension of inputs x) +/// theta_init ([nx] where nx is the dimension of inputs x) /// Initial guess for GP theta hyperparameters. /// When None the default is 1e-2 for all components /// @@ -65,7 +65,7 @@ use rand_xoshiro::Xoshiro256Plus; #[pyclass] pub(crate) struct SparseGpMix { pub correlation_spec: CorrelationSpec, - pub theta0: Option>, + pub theta_init: Option>, pub theta_bounds: Option>>, pub kpls_dim: Option, pub n_start: usize, @@ -80,7 +80,7 @@ impl SparseGpMix { #[new] #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, - theta0 = None, + theta_init = None, theta_bounds = None, kpls_dim = None, n_start = 10, @@ -92,7 +92,7 @@ impl SparseGpMix { #[allow(clippy::too_many_arguments)] fn new( corr_spec: u8, - theta0: Option>, + theta_init: Option>, theta_bounds: Option>>, kpls_dim: Option, n_start: usize, @@ -103,7 +103,7 @@ impl SparseGpMix { ) -> Self { SparseGpMix { correlation_spec: CorrelationSpec(corr_spec), - theta0, + theta_init, theta_bounds, kpls_dim, n_start, @@ -151,7 +151,7 @@ impl SparseGpMix { }; let mut theta_tuning = ThetaTuning::default(); - if let Some(guess) = self.theta0.as_ref() { + if let Some(guess) = self.theta_init.as_ref() { theta_tuning = ParamTuning { guess: guess.to_vec(), ..theta_tuning.into() @@ -200,7 +200,7 @@ impl SparseGpx { #[staticmethod] #[pyo3(signature = ( corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, - theta0 = None, + theta_init = None, theta_bounds = None, kpls_dim = None, n_start = 10, @@ -212,7 +212,7 @@ impl SparseGpx { #[allow(clippy::too_many_arguments)] fn builder( corr_spec: u8, - theta0: Option>, + theta_init: Option>, theta_bounds: Option>>, kpls_dim: Option, n_start: usize, @@ -223,7 +223,7 @@ impl SparseGpx { ) -> SparseGpMix { SparseGpMix::new( corr_spec, - theta0, + theta_init, theta_bounds, kpls_dim, n_start, From bff20f56cc9475767bafd312f829b891a79806fe Mon Sep 17 00:00:00 2001 From: relf Date: Tue, 30 Jan 2024 20:42:26 +0100 Subject: [PATCH 11/26] Rename guess in init --- gp/src/parameters.rs | 16 ++++++++-------- gp/src/sparse_parameters.rs | 2 +- moe/src/gp_parameters.rs | 2 +- moe/src/sgp_parameters.rs | 2 +- src/sparse_gp_mix.rs | 6 +++--- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/gp/src/parameters.rs b/gp/src/parameters.rs index e4826765..9da31ba8 100644 --- a/gp/src/parameters.rs +++ b/gp/src/parameters.rs @@ -11,21 +11,21 @@ use serde::{Deserialize, Serialize}; #[derive(Clone, Debug, PartialEq, Eq)] #[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))] pub struct ParamTuning { - pub guess: Vec, + pub init: Vec, pub bounds: Vec<(F, F)>, } impl TryFrom> for ThetaTuning { type Error = GpError; fn try_from(pt: ParamTuning) -> Result> { - if pt.guess.len() != pt.bounds.len() && (pt.guess.len() != 1 && pt.bounds.len() != 1) { + if pt.init.len() != pt.bounds.len() && (pt.init.len() != 1 && pt.bounds.len() != 1) { return Err(GpError::InvalidValueError(format!( "Bad theta tuning specification {} {}", - pt.guess.len(), + pt.init.len(), pt.bounds.len() ))); } - // TODO: check if guess in bounds + // TODO: check if init in bounds Ok(ThetaTuning(pt)) } } @@ -38,7 +38,7 @@ pub struct ThetaTuning(ParamTuning); impl Default for ThetaTuning { fn default() -> ThetaTuning { ThetaTuning(ParamTuning { - guess: vec![F::cast(0.01)], + init: vec![F::cast(0.01)], bounds: vec![(F::cast(1e-6), F::cast(1e2))], }) } @@ -47,7 +47,7 @@ impl Default for ThetaTuning { impl From> for ParamTuning { fn from(tt: ThetaTuning) -> ParamTuning { ParamTuning { - guess: tt.0.guess, + init: tt.0.init, bounds: tt.0.bounds, } } @@ -55,7 +55,7 @@ impl From> for ParamTuning { impl ThetaTuning { pub fn theta0(&self) -> &[F] { - &self.0.guess + &self.0.init } pub fn bounds(&self) -> &[(F, F)] { &self.0.bounds @@ -168,7 +168,7 @@ impl, Corr: CorrelationModel> GpParams) -> Self { self.0.theta_tuning = ParamTuning { - guess: theta_init, + init: theta_init, ..ThetaTuning::default().into() } .try_into() diff --git a/gp/src/sparse_parameters.rs b/gp/src/sparse_parameters.rs index a7088a4a..c58b5c9f 100644 --- a/gp/src/sparse_parameters.rs +++ b/gp/src/sparse_parameters.rs @@ -161,7 +161,7 @@ impl> SgpParams { /// During training process, the internal optimization is started from `theta_init`. pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.gp_params.theta_tuning = ParamTuning { - guess: theta_init, + init: theta_init, ..(self.0.gp_params.theta_tuning().clone()).into() } .try_into() diff --git a/moe/src/gp_parameters.rs b/moe/src/gp_parameters.rs index 3eaef49e..cfa63d5d 100644 --- a/moe/src/gp_parameters.rs +++ b/moe/src/gp_parameters.rs @@ -195,7 +195,7 @@ impl GpMixParams { /// During training process, the internal optimization is started from `theta_init`. pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.theta_tuning = ParamTuning { - guess: theta_init, + init: theta_init, ..self.0.theta_tuning.into() } .try_into() diff --git a/moe/src/sgp_parameters.rs b/moe/src/sgp_parameters.rs index b25f545e..ea4c7c59 100644 --- a/moe/src/sgp_parameters.rs +++ b/moe/src/sgp_parameters.rs @@ -203,7 +203,7 @@ impl SparseGpMixtureParams { /// During training process, the internal optimization is started from `theta_init`. pub fn theta_init(mut self, theta_init: Vec) -> Self { self.0.theta_tuning = ParamTuning { - guess: theta_init, + init: theta_init, ..self.0.theta_tuning.into() } .try_into() diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index d3fdd25e..cc2f6ad2 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -151,13 +151,13 @@ impl SparseGpMix { }; let mut theta_tuning = ThetaTuning::default(); - if let Some(guess) = self.theta_init.as_ref() { + if let Some(init) = self.theta_init.as_ref() { theta_tuning = ParamTuning { - guess: guess.to_vec(), + init: init.to_vec(), ..theta_tuning.into() } .try_into() - .expect("Theta tuning initial guess"); + .expect("Theta tuning initial init"); } if let Some(bounds) = self.theta_bounds.as_ref() { theta_tuning = ParamTuning { From f266045f8a0f65dc202a776278e639d0a1f133ca Mon Sep 17 00:00:00 2001 From: relf Date: Tue, 30 Jan 2024 20:54:13 +0100 Subject: [PATCH 12/26] Add thate_tuning in GP API --- src/gp_mix.rs | 35 +++++++++++++++++++++++++++++++++++ src/sparse_gp_mix.rs | 3 --- 2 files changed, 35 insertions(+), 3 deletions(-) diff --git a/src/gp_mix.rs b/src/gp_mix.rs index 334706af..40ba066d 100644 --- a/src/gp_mix.rs +++ b/src/gp_mix.rs @@ -61,6 +61,8 @@ pub(crate) struct GpMix { pub regression_spec: RegressionSpec, pub correlation_spec: CorrelationSpec, pub recombination: Recombination, + pub theta_init: Option>, + pub theta_bounds: Option>>, pub kpls_dim: Option, pub n_start: usize, pub seed: Option, @@ -74,6 +76,8 @@ impl GpMix { regr_spec = RegressionSpec::CONSTANT, corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, recombination = Recombination::Smooth, + theta_init = None, + theta_bounds = None, kpls_dim = None, n_start = 10, seed = None @@ -84,6 +88,8 @@ impl GpMix { regr_spec: u8, corr_spec: u8, recombination: Recombination, + theta_init: Option>, + theta_bounds: Option>>, kpls_dim: Option, n_start: usize, seed: Option, @@ -93,6 +99,8 @@ impl GpMix { regression_spec: RegressionSpec(regr_spec), correlation_spec: CorrelationSpec(corr_spec), recombination, + theta_init, + theta_bounds, kpls_dim, n_start, seed, @@ -120,6 +128,25 @@ impl GpMix { } else { Xoshiro256Plus::from_entropy() }; + + let mut theta_tuning = ThetaTuning::default(); + if let Some(init) = self.theta_init.as_ref() { + theta_tuning = ParamTuning { + init: init.to_vec(), + ..theta_tuning.into() + } + .try_into() + .expect("Theta tuning initial init"); + } + if let Some(bounds) = self.theta_bounds.as_ref() { + theta_tuning = ParamTuning { + bounds: bounds.iter().map(|v| (v[0], v[1])).collect(), + ..theta_tuning.into() + } + .try_into() + .expect("Theta tuning bounds"); + } + let moe = py.allow_threads(|| { GpMixture::params() .n_clusters(self.n_clusters) @@ -130,6 +157,7 @@ impl GpMix { .correlation_spec( egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), ) + .theta_tuning(theta_tuning) .kpls_dim(self.kpls_dim) .n_start(self.n_start) .with_rng(rng) @@ -156,15 +184,20 @@ impl Gpx { regr_spec = RegressionSpec::CONSTANT, corr_spec = CorrelationSpec::SQUARED_EXPONENTIAL, recombination = Recombination::Smooth, + theta_init = None, + theta_bounds = None, kpls_dim = None, n_start = 10, seed = None ))] + #[allow(clippy::too_many_arguments)] fn builder( n_clusters: usize, regr_spec: u8, corr_spec: u8, recombination: Recombination, + theta_init: Option>, + theta_bounds: Option>>, kpls_dim: Option, n_start: usize, seed: Option, @@ -174,6 +207,8 @@ impl Gpx { regr_spec, corr_spec, recombination, + theta_init, + theta_bounds, kpls_dim, n_start, seed, diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index cc2f6ad2..b9b1b91f 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -170,9 +170,6 @@ impl SparseGpMix { let sgp = py.allow_threads(|| { SparseGpMixture::params(inducings) - // .n_clusters(self.n_clusters) - // .recombination(recomb) - // .regression_spec(egobox_moe::RegressionSpec::from_bits(self.regression_spec.0).unwrap()) .correlation_spec( egobox_moe::CorrelationSpec::from_bits(self.correlation_spec.0).unwrap(), ) From 8ce0dc4794eddd18b7491d2b9dcba4971c6b9c70 Mon Sep 17 00:00:00 2001 From: relf Date: Tue, 30 Jan 2024 21:25:03 +0100 Subject: [PATCH 13/26] Add theta_tuning to GP --- moe/src/gp_algorithm.rs | 1 + src/gp_mix.rs | 9 +++++++++ src/sparse_gp_mix.rs | 8 -------- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/moe/src/gp_algorithm.rs b/moe/src/gp_algorithm.rs index 1dc10ef9..4dd9553a 100644 --- a/moe/src/gp_algorithm.rs +++ b/moe/src/gp_algorithm.rs @@ -269,6 +269,7 @@ impl GpMixValidParams { _ => return Err(MoeError::ExpertError(format!("Unknown expert {}", best.0))), }; let mut expert_params = best_expert_params?; + expert_params.theta_tuning(self.theta_tuning().clone()); expert_params.kpls_dim(self.kpls_dim()); expert_params.n_start(self.n_start()); let expert = expert_params.train(&xtrain.view(), &ytrain.view()); diff --git a/src/gp_mix.rs b/src/gp_mix.rs index 40ba066d..32074ce9 100644 --- a/src/gp_mix.rs +++ b/src/gp_mix.rs @@ -10,6 +10,7 @@ //! See the [tutorial notebook](https://github.com/relf/egobox/doc/Gpx_Tutorial.ipynb) for usage. //! use crate::types::*; +use egobox_gp::{ParamTuning, ThetaTuning}; #[allow(unused_imports)] // Avoid linting problem use egobox_moe::{FullGpSurrogate, GpMixture, GpSurrogate}; use linfa::{traits::Fit, Dataset}; @@ -45,6 +46,14 @@ use rand_xoshiro::Xoshiro256Plus; /// * Hard: prediction is taken from the expert with highest responsability /// resulting in a model with discontinuities. /// +/// theta_init ([nx] where nx is the dimension of inputs x) +/// Initial guess for GP theta hyperparameters. +/// When None the default is 1e-2 for all components +/// +/// theta_bounds ([[lower_1, upper_1], ..., [lower_nx, upper_nx]] where nx is the dimension of inputs x) +/// Space search when optimizing theta GP hyperparameters +/// When None the default is [1e-6, 1e2] for all components +/// /// kpls_dim (0 < int < nx where nx is the dimension of inputs x) /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index b9b1b91f..07b20e90 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -41,14 +41,6 @@ use rand_xoshiro::Xoshiro256Plus; /// * Hard: prediction is taken from the expert with highest responsability /// resulting in a model with discontinuities. /// -/// theta_init ([nx] where nx is the dimension of inputs x) -/// Initial guess for GP theta hyperparameters. -/// When None the default is 1e-2 for all components -/// -/// theta_bounds ([[lower_1, upper_1], ..., [lower_nx, upper_nx]] where nx is the dimension of inputs x) -/// Space search when optimizing theta GP hyperparameters -/// When None the default is [1e-6, 1e2] for all components -/// /// kpls_dim (0 < int < nx where nx is the dimension of inputs x) /// Number of components to be used when PLS projection is used (a.k.a KPLS method). /// This is used to address high-dimensional problems typically when nx > 9. From 79299cdfaac65ce3487f685cd0cc32797886a9d7 Mon Sep 17 00:00:00 2001 From: relf Date: Wed, 31 Jan 2024 14:36:07 +0100 Subject: [PATCH 14/26] Fix cobyla maxeval parameter --- gp/src/algorithm.rs | 2 +- gp/src/sparse_algorithm.rs | 37 ++++++++++++++++++++++++++----------- 2 files changed, 27 insertions(+), 12 deletions(-) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index a54081d2..46fe7df0 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -857,7 +857,7 @@ impl, Corr: CorrelationModel, D: Data, D: Data> // variance bounds bounds[params.ncols() - 1 - is_noise_estimated as usize] = - (F::cast(1e-6).log10(), (F::cast(9.) * sigma2_0).log10()); + (F::cast(1e-12).log10(), (F::cast(9.) * sigma2_0).log10()); // optionally adjust noise variance bounds if let VarianceEstimation::Estimated { initial_guess: _, @@ -497,11 +497,14 @@ impl, D: Data> *noise_bounds = (lo.log10(), up.log10()); } } - info!( "Optimize with multistart theta = {:?} and bounds = {:?}", params, bounds ); + println!( + "Optimize with multistart theta = {:?} and bounds = {:?}", + params, bounds + ); let now = Instant::now(); let opt_params = params.map_axis(Axis(1), |p| { optimize_params( @@ -509,7 +512,7 @@ impl, D: Data> &p.to_owned(), &bounds, CobylaParams { - maxeval: 10 * theta0_dim, + maxeval: (10 * theta0_dim).max(CobylaParams::default().maxeval), ..CobylaParams::default() }, ) @@ -812,39 +815,51 @@ mod tests { #[test] fn test_sgp_default() { - let mut rng = Xoshiro256Plus::seed_from_u64(0); + let mut rng = Xoshiro256Plus::seed_from_u64(42); // Generate training data let nt = 200; // Variance of the gaussian noise on our training data let eta2: f64 = 0.01; let (xt, yt) = make_test_data(nt, eta2, &mut rng); + // let test_dir = "target/tests"; + // let file_path = format!("{}/smt_xt.npy", test_dir); + // let xt: Array2 = read_npy(file_path).expect("xt read"); + // let file_path = format!("{}/smt_yt.npy", test_dir); + // let yt: Array2 = read_npy(file_path).expect("yt read"); - let xplot = Array::linspace(-0.5, 0.5, 100).insert_axis(Axis(1)); + let xplot = Array::linspace(-1.0, 1.0, 100).insert_axis(Axis(1)); let n_inducings = 30; + // let file_path = format!("{}/smt_z.npy", test_dir); + // let z: Array2 = read_npy(file_path).expect("z read"); + // println!("{:?}", z); + let sgp = SparseKriging::params(Inducings::Randomized(n_inducings)) + //let sgp = SparseKriging::params(Inducings::Located(z)) + //.noise_variance(VarianceEstimation::Constant(0.01)) .seed(Some(42)) - .theta_init(vec![0.1]) .fit(&Dataset::new(xt.clone(), yt.clone())) .expect("GP fitted"); + println!("theta={:?}", sgp.theta()); + println!("variance={:?}", sgp.variance()); println!("noise variance={:?}", sgp.noise_variance()); - assert_abs_diff_eq!(eta2, sgp.noise_variance()); + // assert_abs_diff_eq!(eta2, sgp.noise_variance()); let sgp_vals = sgp.predict_values(&xplot).unwrap(); 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); + assert_abs_diff_eq!(errvals, Array2::zeros((xplot.nrows(), 1)), epsilon = 0.5); let sgp_vars = sgp.predict_variances(&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); + assert_abs_diff_eq!(errvars, Array2::zeros((xplot.nrows(), 1)), epsilon = 0.2); save_data(&xt, &yt, sgp.inducings(), &xplot, &sgp_vals, &sgp_vars); } #[test] fn test_sgp_vfe() { - let mut rng = Xoshiro256Plus::seed_from_u64(0); + let mut rng = Xoshiro256Plus::seed_from_u64(42); // Generate training data let nt = 200; // Variance of the gaussian noise on our training data @@ -868,7 +883,7 @@ mod tests { Inducings::Located(z), ) .sparse_method(SparseMethod::Vfe) - .theta_init(vec![0.01]) + .noise_variance(VarianceEstimation::Constant(0.01)) .fit(&Dataset::new(xt.clone(), yt.clone())) .expect("GP fitted"); From b4991ea757e4ec035d7f80e0b274ae89ca9561e6 Mon Sep 17 00:00:00 2001 From: relf Date: Wed, 31 Jan 2024 16:00:28 +0100 Subject: [PATCH 15/26] Parallellize multistart optimizations for SGP --- gp/Cargo.toml | 1 + gp/src/correlation_models.rs | 2 +- gp/src/mean_models.rs | 2 +- gp/src/sparse_algorithm.rs | 59 +++++++++++++++++++++++++----------- 4 files changed, 44 insertions(+), 20 deletions(-) diff --git a/gp/Cargo.toml b/gp/Cargo.toml index 9bafc915..21d7294f 100644 --- a/gp/Cargo.toml +++ b/gp/Cargo.toml @@ -37,6 +37,7 @@ paste = "1.0" num-traits = "0.2" thiserror = "1" log = "0.4" +rayon = "1" serde = { version = "1", features = ["derive"], optional = true } serde_json = { version = "1", optional = true } diff --git a/gp/src/correlation_models.rs b/gp/src/correlation_models.rs index 871ba5c9..30458dd7 100644 --- a/gp/src/correlation_models.rs +++ b/gp/src/correlation_models.rs @@ -16,7 +16,7 @@ use std::convert::TryFrom; use std::fmt; /// A trait for using a correlation model in GP regression -pub trait CorrelationModel: Clone + Copy + Default + fmt::Display { +pub trait CorrelationModel: Clone + Copy + Default + fmt::Display + Sync { /// Compute correlation function matrix r(x, x') given distances `d` between x and x', /// `theta` parameters, and PLS `weights`, where: /// `theta` : hyperparameters (1xd) diff --git a/gp/src/mean_models.rs b/gp/src/mean_models.rs index 781ab163..a0f9a51f 100644 --- a/gp/src/mean_models.rs +++ b/gp/src/mean_models.rs @@ -16,7 +16,7 @@ use std::convert::TryFrom; use std::fmt; /// A trait for mean models used in GP regression -pub trait RegressionModel: Clone + Copy + Default + fmt::Display { +pub trait RegressionModel: Clone + Copy + Default + fmt::Display + Sync { /// Compute regression coefficients defining the mean behaviour of the GP model /// for the given `x` data points specified as (n, nx) matrix. fn value(&self, x: &ArrayBase, Ix2>) -> Array2; diff --git a/gp/src/sparse_algorithm.rs b/gp/src/sparse_algorithm.rs index 6f2675f5..edf1b14a 100644 --- a/gp/src/sparse_algorithm.rs +++ b/gp/src/sparse_algorithm.rs @@ -11,12 +11,11 @@ use linfa_pls::PlsRegression; use log::info; use ndarray::{s, Array, Array1, Array2, ArrayBase, ArrayView2, Axis, Data, Ix2, Zip}; use ndarray_einsum_beta::*; -use ndarray_stats::QuantileExt; - use ndarray_rand::rand::seq::SliceRandom; use ndarray_rand::rand::SeedableRng; use rand_xoshiro::Xoshiro256Plus; +use rayon::prelude::*; #[cfg(feature = "serializable")] use serde::{Deserialize, Serialize}; use std::fmt; @@ -337,7 +336,7 @@ where } } -impl, D: Data> +impl, D: Data + Sync> Fit, ArrayBase, GpError> for SgpValidParams { type Object = SparseGaussianProcess; @@ -505,23 +504,47 @@ impl, D: Data> "Optimize with multistart theta = {:?} and bounds = {:?}", params, bounds ); + + // let opt_params = params.map_axis(Axis(1), |p| { + // let now = Instant::now(); + // let opt_res = optimize_params( + // objfn, + // &p.to_owned(), + // &bounds, + // CobylaParams { + // maxeval: (10 * theta0_dim).max(CobylaParams::default().maxeval), + // ..CobylaParams::default() + // }, + // ); + // info!("elapsed optim = {:?}", now.elapsed().as_millis()); + // opt_res + // }); + // let opt_index = opt_params.map(|(_, opt_f)| opt_f).argmin().unwrap(); + // let opt_params = &(opt_params[opt_index]).0.mapv(|v| F::cast(base.powf(v))); + // println!("Normal opt_params={:?}", opt_params); let now = Instant::now(); - let opt_params = params.map_axis(Axis(1), |p| { - optimize_params( - objfn, - &p.to_owned(), - &bounds, - CobylaParams { - maxeval: (10 * theta0_dim).max(CobylaParams::default().maxeval), - ..CobylaParams::default() - }, - ) - }); + let opt_params = (0..params.nrows()) + .into_par_iter() + .map(|i| { + let opt_res = optimize_params( + objfn, + ¶ms.row(i).to_owned(), + &bounds, + CobylaParams { + maxeval: (10 * theta0_dim).max(CobylaParams::default().maxeval), + ..CobylaParams::default() + }, + ); + + opt_res + }) + .reduce( + || (Array::ones((params.ncols(),)), f64::INFINITY), + |a, b| if b.1 < a.1 { b } else { a }, + ); info!("elapsed optim = {:?}", now.elapsed().as_millis()); - - let opt_index = opt_params.map(|(_, opt_f)| opt_f).argmin().unwrap(); - let opt_params = &(opt_params[opt_index]).0.mapv(|v| F::cast(base.powf(v))); - // println!("opt_theta={}", opt_theta); + let opt_params = opt_params.0.mapv(|v| F::cast(base.powf(v))); + println!("Parallel opt_params={:?}", opt_params); let opt_theta = opt_params .slice(s![..n - 1 - is_noise_estimated as usize]) .to_owned(); From 3029bc5e16b1190d63bd08bf2d44a3af9c2349c4 Mon Sep 17 00:00:00 2001 From: relf Date: Wed, 31 Jan 2024 17:18:18 +0100 Subject: [PATCH 16/26] Add SparseGpx basic tutorial --- doc/SparseGpx_Tutorial.ipynb | 329 +++++++++++++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 doc/SparseGpx_Tutorial.ipynb diff --git a/doc/SparseGpx_Tutorial.ipynb b/doc/SparseGpx_Tutorial.ipynb new file mode 100644 index 00000000..5d2fb4f6 --- /dev/null +++ b/doc/SparseGpx_Tutorial.ipynb @@ -0,0 +1,329 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "4bd147b8", + "metadata": {}, + "source": [ + "# Using _egobox_ surrogate model _SparseGpx_" + ] + }, + { + "cell_type": "markdown", + "id": "ee9afcd0", + "metadata": {}, + "source": [ + "This tutorial is inspired from SGP tutorial from [SMT](https://github.com/SMTOrg/smt/tutorial)." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "3141794e", + "metadata": {}, + "source": [ + "## Installation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "33b7dcca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: egobox in d:\\rlafage\\miniconda3\\lib\\site-packages (0.14.0)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install egobox" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "0fa96b71", + "metadata": {}, + "source": [ + "We import _egobox_ as _egx_ for short" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d502466d-906e-4b64-9968-ea5b642fbadf", + "metadata": {}, + "outputs": [], + "source": [ + "import egobox as egx" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c8e65173-d594-4a1d-8bfb-f5e3a480ce47", + "metadata": { + "tags": [] + }, + "source": [ + "# Example 1 : SparseGpx basics" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "358adf9c-0447-4b16-b3dc-02eb881a7d96", + "metadata": { + "tags": [] + }, + "source": [ + "### Training " + ] + }, + { + "cell_type": "markdown", + "id": "c9572acb", + "metadata": {}, + "source": [ + "#### Benchmark function definition" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d72fd25e-803b-435e-ae81-9aa7175494bc", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "def f_obj(x):\n", + " return np.sin(3*np.pi*x) + 0.3*np.cos(9*np.pi*x) + 0.5*np.sin(7*np.pi*x)" + ] + }, + { + "cell_type": "markdown", + "id": "58035252", + "metadata": {}, + "source": [ + "#### Training data definition" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f4de436a-8319-47f5-bb5a-e68d02419752", + "metadata": {}, + "outputs": [], + "source": [ + "# number of observations\n", + "N = 200\n", + "\n", + "# noise\n", + "eta = 0.01\n", + "\n", + "# Set seed via random generator for reproducibility\n", + "rng = np.random.RandomState(0)\n", + "\n", + "# generate data\n", + "xt = 2*np.random.rand(N, 1) - 1\n", + "yt = f_obj(xt) + rng.normal(loc=0.0, scale=np.sqrt(eta), size=(N,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ed2693b6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABRcAAAH5CAYAAAAbRAmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAADacUlEQVR4nOzdd3hUdfbH8fdMCoHQAgFCIIGEGkILIAqKwYpBWQUU2+paV8DdVbGhru66+1vFjq4i9rJWFLCjYqHbgIQioSYQSiiBQCBA2szvj28mJKQQkpncKZ/X8/Dcm5s7MwcNk7nnnu85NqfT6URERERERERERETkJNmtDkBERERERERERER8k5KLIiIiIiIiIiIiUidKLoqIiIiIiIiIiEidKLkoIiIiIiIiIiIidaLkooiIiIiIiIiIiNSJkosiIiIiIiIiIiJSJ0ouioiIiIiIiIiISJ0EWx2AuzkcDnbs2EGzZs2w2WxWhyMiIiIiIiIiIuJTnE4nBw8eJDo6Gru95tpEv0su7tixg5iYGKvDEBERERERERER8Wlbt26lY8eONZ7jd8nFZs2aAeYv37x5c4ujERERERERERER8S15eXnExMSU5dlq4nfJRddS6ObNmyu5KCIiIiIiIiIiUke1aTmogS4iIiIiIiIiIiJSJ0ouioiIiIiIiIiISJ0ouSgiIiIiIiIiIiJ14nc9F2urpKSEoqIiq8MQPxMSEkJQUJDVYYiIiIiIiIiINIiASy46nU527tzJ/v37rQ5F/FTLli2JioqqVdNTERERERERERFfFnDJRVdisW3btjRp0kQJIHEbp9PJ4cOH2b17NwDt27e3OCIREREREREREc8KqORiSUlJWWKxdevWVocjfqhx48YA7N69m7Zt22qJtIiIiIiIiIj4tYAa6OLqsdikSROLIxF/5vr5Uk9PEREREREREfF3AZVcdNFSaPEk/XyJiIiIiIiISKAIyOSiiIiIiIiIiIiI1J+Si+Jxhw8fZuzYsTRv3hybzWbppO558+ZZHoOIiIiIiIiIiL9QctFHDB8+nNtvv93qMCqobUxvvfUWCxcuZMmSJWRnZ9OiRQvPB0fV8Q0dOrRBYxARERERERER8WcBNS1aoLCwkNDQ0AZ9zU2bNpGQkEDv3r0b9HWrEhoaSlRUlNVhiIiIiIiIiIj4BVUu+oDrrruO+fPn8+yzz2Kz2bDZbGzevJmSkhJuvPFG4uLiaNy4MT169ODZZ5+t9NhLLrmERx99lOjoaLp37w7AkiVL6N+/P2FhYQwaNIhPPvkEm81GWlpa2WPXrFnDyJEjadq0Ke3ateOaa64hJyenxpiON3z4cJ566ikWLFiAzWZj+PDhgBl68sknn1Q4t2XLlrz55psAbN68GZvNxqxZszjrrLNo0qQJ/fr146effqrwmMWLF5OcnEyTJk2IiIhgxIgR5ObmVhtfVcuiZ86cSWJiIo0aNaJz58489dRTFV6jc+fOPPLII9xwww00a9aM2NhYXn755Vr+3xMRERERERER8V9KLjqdUJhvzR+ns1YhPvvsswwZMoSbb76Z7OxssrOziYmJweFw0LFjR2bMmMGaNWt46KGHuP/++5kxY0aFx3///fekp6czd+5cvvjiCw4ePMioUaPo06cPy5cv59///jf33ntvhcdkZ2eTnJxM//79Wbp0KV9//TW7du1i3LhxNcZ0vFmzZnHzzTczZMgQsrOzmTVr1kn973nggQe46667SEtLo3v37lx55ZUUFxcDkJaWxjnnnENiYiI//fQTixYtYtSoUZSUlNQ6vmXLljFu3DiuuOIKVq1axT//+U8efPDBsiSny1NPPcWgQYNITU1l4sSJTJgwgbVr157U30VERERERERExN9oWXTRYXgk2prXvn8HhIaf8LQWLVoQGhpKkyZNKizpDQoK4uGHHy77Oi4ujiVLljBjxoyyJCBAeHg4r776atly6OnTp2Oz2XjllVcICwujV69ebN++nZtvvrnsMS+++CIDBgzgkUceKTv2+uuvExMTw/r16+nevXuVMR2vVatWNGnSpM7Lke+66y4uvPBCAB5++GESExPZuHEjPXv25PHHH2fQoEFMmzat7PzExMSy/drE9/TTT3POOefw4IMPAtC9e3fWrFnDE088wXXXXVd23siRI5k4cSIA9957L8888wzz5s2jZ8+eJ/13EvEnqVm5ZObkExcZTlJshNXhiIiIiIiISANTctHHTZ8+nVdffZUtW7Zw5MgRCgsL6d+/f4Vz+vTpU6HP4rp16+jbty9hYWFlxwYPHlzhMcuWLePHH3+kadOmlV5z06ZNZcurPa1v375l++3btwdg9+7d9OzZk7S0NC677LJ6PX96ejoXX3xxhWOnn346U6dOpaSkhKCgoEpx2Gw2oqKi2L17d71eW8TXTZmTzvT5GWVfj0+OZ3JKgoURiYiIiIiISENTcjGkiakgtOq162HGjBnccccdPPXUUwwZMoRmzZrxxBNP8Msvv1Q4Lzy8YnWk0+nEZrNVOlaew+Fg1KhRPPbYY5Ve15Xkqw+bzVbpNYuKiiqdFxISUuExrtgAGjduXO84avPf4vg4XLG44hAJRKlZuRUSiwDT52cwIjFKFYwiIiIiIiIBRMlFm61WS5OtFhoaSklJSYVjCxcuZOjQoWXLdcFUFZ5Iz549effddykoKKBRo0YALF26tMI5AwYMYObMmXTu3Jng4Kp/TKqKqbbatGlDdnZ22dcbNmzg8OHDJ/Ucffv25fvvv6+wNPxk4+vVqxeLFi2qcGzJkiV07969rGpRRCrLzMmv9riSiyIiIiIiIoFDA118ROfOnfnll1/YvHkzOTk5OBwOunbtytKlS/nmm29Yv349Dz74IL/99tsJn+uqq67C4XDw5z//mfT0dL755huefPJJ4Fh14K233sq+ffu48sor+fXXX8nIyODbb7/lhhtuKEvYVRVTbZ199tk8//zzLF++nKVLlzJ+/PhK1YEnct999/Hbb78xceJEVq5cydq1a3nxxRfLJlrXJr4777yT77//nn//+9+sX7+et956i+eff5677rrrpGIRCTRxkVXflKnuuIiIiIiIiPgnJRd9xF133UVQUBC9evWiTZs2ZGVlMX78eMaMGcPll1/Oqaeeyt69eytUMVanefPmfP7556SlpdG/f38eeOABHnroIYCyPozR0dEsXryYkpISRowYQe/evbntttto0aIFdru92phq66mnniImJoYzzzyTq666irvuuosmTU5umXj37t359ttvWbFiBYMHD2bIkCF8+umnZZWWtYlvwIABzJgxgw8++IDevXvz0EMP8a9//avCMBcRqSwpNoLxyfEVjk1IjlfVooiIiIiISICxOatqMOfD8vLyaNGiBQcOHKB58+YVvnf06FEyMzOJi4urMMxE4N133+X666/nwIEDbullGMj0cyaBpD7TojVpWkRERERExDvVlF87nnouBqi3336b+Ph4OnTowIoVK7j33nsZN26cEosiclKSYiPqlBjUpGkRERERERH/oORigNq5cycPPfQQO3fupH379lx22WX85z//sTosEQkAmjQtIiIiIiLiP5RcDFD33HMP99xzj9VhiEgA0qRpERERERER/6GBLiIi0qA0aVpERERERMR/KLkoIiINSpOmRURERERE/IeWRYuISIObnJLAiMQoTYsWERERERHxcUouioiIJeo6aVpERERERES8h5ZFi4iIiIiIiIiISJ0ouSgiIiIiIiIiIiJ1ouSin5g3bx42m439+/dbHYpb1PXvY7PZ+OSTTzwSk4iIiIiIiIiIVKTkogS0f/7zn/Tv39/qMES8VmpWLrOWbyM1K7f6k5xOcJQ0XFAiIiIiIiLiNTTQReqssLCQ0NBQq8MQEQ+ZMied6fMzyr4enxzP5JSEYyc4SmDZG/DjI1BSDN1HQMIo6HoOhIZbELGIiIiIiHiT1KxcMnPyiYsM1zBHP6bKRR9RUFDA3/72N9q2bUtYWBhnnHEGv/32W6XzFi9eTL9+/QgLC+PUU09l1apVZd/bsmULo0aNIiIigvDwcBITE/nqq6/Kvr9mzRpGjhxJ06ZNadeuHddccw05OTll3x8+fDh/+ctfmDRpEpGRkZx33nlceeWVXHHFFRViKCoqIjIykjfeeAMAp9PJ448/Tnx8PI0bN6Zfv358/PHHFR7z1Vdf0b17dxo3bsxZZ53F5s2bT/jfZMOGDZx55pmEhYXRq1cv5s6dW+mce++9l+7du9OkSRPi4+N58MEHKSoqAuDNN9/k4YcfZsWKFdhsNmw2G2+++SYATz/9NH369CE8PJyYmBgmTpzIoUOHThiTiL9IzcqtkFgEmD4/41gF49bf4JWz4Ms74fBeKDgAq2bAjGvg8S7wwdWw4gMoKSp7vhNWQIqIiIiIiN+YMied0dOWMGnGCkZPW8KUOelWhyQeosrFemjIDPw999zDzJkzeeutt+jUqROPP/44I0aMYOPGjbRq1arsvLvvvptnn32WqKgo7r//fv7whz+wfv16QkJCuPXWWyksLGTBggWEh4ezZs0amjZtCkB2djbJycncfPPNPP300xw5coR7772XcePG8cMPP5Q9/1tvvcWECRNYvHgxTqeTjRs3Mm7cOA4dOlT2XN988w35+fmMHTsWgL///e/MmjWLF198kW7durFgwQL++Mc/0qZNG5KTk9m6dStjxoxh/PjxTJgwgaVLl3LnnXfW+N/D4XAwZswYIiMj+fnnn8nLy+P222+vdF6zZs148803iY6OZtWqVdx88800a9aMe+65h8svv5zVq1fz9ddf89133wHQokULAOx2O8899xydO3cmMzOTiRMncs899zBt2rS6/08U8SGZOflVHt+xPYuk5X+HtHfMgUYt4Oy/Q1QfWPsFpH8O+7eY/dKvpzR/gOkLMsueo1IFpIiIiIiI+JXqihVGJEapgtEPKblYRydcLuhG+fn5vPjii7z55pukpKQA8MorrzB37lxee+017r777rJz//GPf3DeeecBJhHYsWNHZs+ezbhx48jKymLs2LH06dMHgPj4+LLHvfjiiwwYMIBHHnmk7Njrr79OTEwM69evp3v37gB07dqVxx9/vOycLl26EB4ezuzZs7nmmmsAeO+99xg1ahTNmzcnPz+fp59+mh9++IEhQ4aUve6iRYt46aWXSE5O5sUXXyQ+Pp5nnnkGm81Gjx49WLVqFY899li1/02+++470tPT2bx5Mx07dgTgkUceKfvv4/L3v/+9bL9z587ceeedfPjhh9xzzz00btyYpk2bEhwcTFRUVIXHlU9UxsXF8e9//5sJEyYouSgBIy6y8rLmEfbfGPHjeCjMMwf6/xHO/Sc0bWO+7jQEzv8/2LUa1nwGi6eaBGNRU+APZc+jDxUiIiIiIv6tumKFzJz8CtcBWjbtH5RcrIOGzsBv2rSJoqIiTj/99LJjISEhDB48mPT0imXFrgQeQKtWrejRo0fZOX/729+YMGEC3377Leeeey5jx46lb9++ACxbtowff/yxrPrw+Nd3JRcHDRpU4XshISFcdtllvPvuu1xzzTXk5+fz6aef8t577wFmqfXRo0fLEp4uhYWFJCUlAZCens5pp52GzWar8u9RlfT0dGJjY8sSi9U95uOPP2bq1Kls3LiRQ4cOUVxcTPPmzWt8boAff/yRRx55hDVr1pCXl0dxcTFHjx4lPz+f8HD1khP/lxQbwfjk+LL3unjbDp4Pm0ZwYQFE9YULn4KYwZUfaLOZKsaoPtCiA3x+G3cHf8hKZzxLHL3LTjv+Q4WIiIiIiPiPqooVjj/ekEVb4lnquVgHNWXgPcHpdAJUSL65jh9/rCquc2666SYyMjK45pprWLVqFYMGDeK///0vYJYZjxo1irS0tAp/XH0NXapKrF199dV899137N69m08++YSwsLCyCkKHwwHAl19+WeF516xZU9Z30fX3OxlVPeb4/xY///wzV1xxBSkpKXzxxRekpqbywAMPUFhYWONzb9myhZEjR9K7d29mzpzJsmXLeOGFFwDK+jWKBILJKQnMnjiUZy7txecd3ibEUQBxyfDneVUnFo834E/s7TaOIJuT/4b8l/bsLftWUYlDPRhFRERERPyUq1ihvAnJ8WUFBifs8S4+RZWLdVCbDLw7de3aldDQUBYtWsRVV10FmCTX0qVLK/UZ/Pnnn4mNjQUgNzeX9evX07Nnz7Lvx8TEMH78eMaPH899993HK6+8wl//+lcGDBjAzJkz6dy5M8HBJ/djMXToUGJiYvjwww+ZM2cOl112WdkU6V69etGoUSOysrJITk6u8vG9evXik08+qfT3qEmvXr3Iyspix44dREdHA/DTTz9VOGfx4sV06tSJBx54oOzYli1bKpwTGhpKSUlJhWNLly6luLiYp556Crvd5N9nzJhRYzwi/iopNoKkjdMgZyWEtYRLXgR7UO0ebLPRetxz7HxmBVGH1zEt9FkuL3yQXjGR3Dvz2LAp3aEUEREREfE/k1MSGJEYVeWy59oumxbfoMrFOjhRBt7dwsPDmTBhAnfffTdff/01a9as4eabb+bw4cPceOONFc7917/+xffff8/q1au57rrriIyM5JJLLgFMH8FvvvmGzMxMli9fzg8//EBCgrmgv/XWW9m3bx9XXnklv/76KxkZGXz77bfccMMNlZJvx7PZbFx11VVMnz6duXPn8sc//rHse82aNeOuu+7ijjvu4K233mLTpk2kpqbywgsv8NZbbwEwfvx4Nm3axKRJk1i3bh3vvfde2dTm6px77rn06NGDa6+9lhUrVrBw4cIKSUQwSdmsrCw++OADNm3axHPPPcfs2bMrnOMa2JKWlkZOTg4FBQV06dKF4uJi/vvf/5KRkcH//vc/pk+fXmM8In4r6xdY+KTZv+gZs9T5ZIQ0JurmGRSHtiDJvpGvun9F2tYDFU7RHUoREREREf+UFBvBmAEdK+VLGrpoSzxLycU6ci0XfHpcP2ZPHMq9Hq66mTJlCmPHjuWaa65hwIABbNy4kW+++YaIiIhK5912220MHDiQ7OxsPvvss7IqwpKSEm699VYSEhK44IIL6NGjR9mAkujoaBYvXkxJSQkjRoygd+/e3HbbbbRo0aKseq8mV199NWvWrKFDhw4VekMC/Pvf/+ahhx7i0UcfJSEhgREjRvD5558TFxcHQGxsLDNnzuTzzz+nX79+TJ8+vcJgmarY7XZmz55NQUEBgwcP5qabbuI///lPhXMuvvhi7rjjDv7yl7/Qv39/lixZwoMPPljhnLFjx3LBBRdw1lln0aZNG95//3369+/P008/zWOPPUbv3r159913efTRR0/430DE7xQchFk3g9MBfa+A3mPq9jwRnQm+7DXARtesDxljX1DpFE+1lRAREREREe/T0EVb4lk2Z10a3tXSggULeOKJJ1i2bBnZ2dnMnj27rIquKvPmzeOss86qdDw9Pb3C0t6a5OXl0aJFCw4cOFBpcMfRo0fJzMwkLi6OsLCwk/q7iNSWfs7Eb3xyK6S9Ay1iYcIiCGtRv+eb9xjMe4SjzhDOK3ycrc52Zd+aPXGoPkiIiIiIiAQYTYv2XjXl147n0crF/Px8+vXrx/PPP39Sj1u3bh3Z2dllf7p16+ahCEVEpEprPjOJRWww5qX6JxYBzrwbOg8jzFbEjUFzyg7rDqWIiIiISGCqbtm0+BaPDnRJSUkpmxp8Mtq2bUvLli1rdW5BQQEFBQVlX+fl5Z3064mISDkHd8Hnt5n9M26HTkPd87x2O5x5F2xeyDVhC2l97j/pGB2tDxIiIiIiIv6i4BDkrDd/9m+FbudCdJLVUYmHeeW06KSkJI4ePUqvXr34+9//XuVSaZdHH32Uhx9+uAGjExHxc4uehiP7IKoPDL/fvc8dlwztehO0azWjir6B2EnufX4REREREWlYK2fAig9MQvHA1orfm/8YXPIi9L3MmtikQXjVQJf27dvz8ssvM3PmTGbNmkWPHj0455xzWLCgcvN/l/vuu48DBw6U/dm6dWu154qIyAnk58AyM8md8/4NwaHufX6bDYbcavZ/fRmKC937/CIiIiIi0nBWfGiGQG76/lhiMbwNdDoDYoeCowhm3QSLpoLnRn6IxbyqcrFHjx706NGj7OshQ4awdetWnnzySc4888wqH9OoUSMaNWrUUCGKiPi3X16C4iPQvj/ED/fMa/S+FL57GA5mw++zod/lnnkdERERERFxqwoDWBxr4LO/mG8M+BP0uxLa9IAmrcwxhwO+/Tv8/AJ89w/I2w4XTAF7kHV/AfEIr0ouVuW0007jnXfecetzOhwOtz6fSHn6+RKfVXAQfn3J7A+bZKoMPSE4FAbfDD/8G376L/Qd57nXEhERERERt5gyJ53p8zMA6GzLZk74wzQuKYSEP8BFU02P9fLsdrjgEWjRAb55wKxcytsBY1+FkMYN/xcQj/H65GJqairt27d3y3OFhoZit9vZsWMHbdq0ITQ0FJsuaMVNnE4nhYWF7NmzB7vdTmiom5eTinja0jfg6AFo3RV6XuTZ1xp0Ayx4Enaugs0LIa7q6nQREREREbFealZuWWKxJQd5I+RxGhfnkR/Zj/DRL1VOLJY35FZoHg2zboG1X8Bbf4CrP4LGLRsmePE4jyYXDx06xMaNG8u+zszMJC0tjVatWhEbG8t9993H9u3befvttwGYOnUqnTt3JjExkcLCQt555x1mzpzJzJkz3RKP3W4nLi6O7OxsduzY4ZbnFDlekyZNiI2NxV7Tm6uItykugJ9eMPun3+75pQpNWkHS1fDbq+Z1yyUXKyy10CRpERERERHLZebkAxBKES+HPk2cfRfbnJGsGPAcF4Y2OfETJI6Gpu3g/Stg268w71FIeczDUUtD8WhycenSpRUmPU+aZKaC/ulPf+LNN98kOzubrKyssu8XFhZy1113sX37dho3bkxiYiJffvklI0eOdFtMoaGhxMbGUlxcTElJidueVwQgKCiI4OBgVcSK71nxPhzaCc2ioW8D9UA8dQL89hqs/xpyNkBktwpLLQDGJ8czOSWhYeIREREREZEqxUWGA04eC3mZwfZ15Dkbc33hPTzesVPtn6TTULjsTfjfaFj6uqlobBnrqZClAdmcTv8a15OXl0eLFi04cOAAzZs3tzocERHv5yiB5wfBvgwY8cixac5uUmMl4vtXwrqvYOD1pPb7B6OnLan0+NkTh6qCUURERETEYnPf+CfnbXmGImcQ1xXdQ99hF3NvXQoB3hoFmQsg6Y9w8QvuD1Tc4mTya1q3KSIS6NZ8ahKLjSPMlDc3mjInndHTljBpxgpGT1vClDnpFU8YUjpdbsX7bN++rcrncC3BEBERERERixQd4bwcM2x3TZ97uGv8LXVLLAKc/ZDZpr1nVjCJz1NyUUQkkDmdsOgZs3/qeGjU1G1PXb7ps8v0+RmkZuUeO9BpKLTvD8VHGbBndpXPY5ZgiIiIiIiIZZa/Dfl7oGUs/UbfWb+VRTGnQPcUcDrgx/+4L0axjJKLIiKBbNP3sHMlhITD4D+79amrqziscNxmK6tejN7wPuPP7Fzh3AnJ8VoSLSIiIiJipeJCWPys2T/9dggKqf9znv13s/19NmSvrP/ziaU8OtBFRES83KKpZjvwOjPB2Y2qqzisdDxhFIQ2g4M7mNz3CCN6D9W0aBERERERb7HifcjbDs3aQ/+r3fOcUb2h96Ww+mP44f/g6hnueV6xhCoXRUQC1e61sHkh2IPdPsQFICk2gvHJ8RWOVVmJGBIG3c83++mfkRQbwZgBHZVYFBERERGxUGpWLrOXbqZg3pPmwNC/mc/u7nLW/WALgg3fQNbP7nteaXCqXBQRCVQr3jPbbiOgRQePvMTklARGJEaduBKx50Wweiakfw7nPmyWS4uIiIiIiCWmzEln+vwMLrEvYnRoFvnBEYQPdO/wR1p3MROjl78F3/8LrvtS1wE+SpWLIiKBqKQYVnxo9vtf5dGXqlUlYrfzIKgR7MsgfeUvzFq+reLgFxERERERaRCuwYw2HNwa/CkALxw5n9Sdhe5/seR7zHXAlsWw6Qf3P780CCUXRUQCUcaPcGgnNGkN3c63Ohpo1Ay6nAXAnBmvMGnGCkZPW8KUOekWByYiIiIiElhcAxhH2JfSzb6dA84mvF1yXrUDG+ulRUc45Saz//2/wOl0/2uIxym5KCISiNLeNds+4yA41NpYSm1pezYAFwT9VnZs+vwMVTCKiIiIiDQgM4DRyV+CPwHgzZILOESTagc21iQ1K/fEq5KGTYLgxpCdBjuW1ylmsZaSiyIigeZILqz90ux7eEn0yVgVPpRip51e9i3E2HaVHffIHVIREREREalSUmwEj/fbRW/7ZvKdjXijeETVgxlPYMqcdEZPW3LiVUnhkdBzpNlfNbOe0YsVlFwUEQk0q2dCSSG06wPt+1odTZkOHTryq6MnYJZguNTlDqmIiIiIiNSR08m4/PcB2N71Kt6YOILzE6NOqi+6q29jecevSqpQ1dj7UnPw91ngKHHP30MajKZFi4gEmrTSKdFeVLUI5g7pt/EpsGUNI4J+49WSC+t0h1REREREROph21LY9hsEh9H9kvuYsmhnhUTh+OR4Jqck1PgU1a0+yszJJyk2omwatcutwzpyd1gLOJhthrvEnemev4s0CFUuiogEkt1rYfsysAdDn8usjqaS88fcCMAg+wY+v64r95Z+aKlVrxYREREREam/lR+aba9LSM0NPWEFYlWqW30UFxleZVXjCwu3kRObYr5Y9XHd4hbLKLkoIhJIVpRWLXYbAU3bWBtLVVp0gA4DseGkz8FFwEn0ahERERERkfopKYLfZ5v9vpfVWIFYk6TYCMYnx1c45lqVVN1j01ufZ3bWfArFhScXt1hKy6JFRAJFSTGsKL0L6WVLoitIGGWqK9d+QWq7MVXeKR2RGKXl0iIiIiIi7pYxDw7nQHgbiBtO3PaDVZ5Wm77ok1MSGJEYRWZOPnGR4WWf36t7bNMew2FVFBzaCZu+hx4pdfxLSENT5aKISKDI+NH8om7SGrqdb3U01es5ymwzF7Btx44qT9EEaRERERERD1g5w2wTx0BQcI0ViLWRFBvBmAEdK5xf7XN2joTeY8wBLY32KapcFBEJFGnvmm2fcRAcam0sNYnsCm0SYE86fQ7/ArSrdIomSIuIiIiIuFlhPqz90uyX689eXQVifVT7nH0uhZ+nwbqvTDyh+tzvC1S5KCISCI7kHvug4M1Lol0STPVi593f1+tOqYiIiIiI1NK6OVCUDxFx0HFQhW9VVYFYX1U+Z/QA8/pFh0084hNUuSgiEghWz4SSQmjXB9r3tTqaE0u4CBY8Dhu/Z/I9r7j9TqmIiIiIiBzHtSS6z2Vgs1kTg81mqhcXPGGWRve5tNIpqVm5ujbwMkouiogEAlfPkn5XWBtHbUX1hZaxsD8LNn5HUq8/6IODiIiIiIin5O81Q1SgwpJoS/S5DBY8gWPjd3z582o6RncouxaYMie9wsDH8cnxTE5JsCpSKaVl0SIi/i4vG7J+NvuJo62NpbZsNuh5kdnfONfaWERERERE/N2a2eAohvb9oE13a2Np04NdTbphdxSx+PM3GD1tCVPmpJOalVshsQgwfX4GqVm5FgUqLkouioj4u7VfAE7oOBhadLA6mtqLH262mQstDUNERERExO+t/Mhsra5axCx7fv2A6fl4sX0JYJKI89btrvL8zJz8BotNqqbkooiIv/v9E7PtdbGlYZy02CFgC4LcTDiwzepoRERERET8U+4W2PozYIPeY62OhnnrdvN5yRAATrWn0459NZ4fF6mJ0lZTclFExJ8d2g1bFpv9Xn+wNpaTFdYcovubfVUvioiIiIh4xurS/uydz4Dm0ZaGMmVOOs9+v5EdRPKrowd2m5OLgkyLp+E92jI+Ob7C+ROS49Wb3QtooIuIiJ+pMD1t1+eAE6IHmAEpvqbzMNi+DDYvhP5XWh2NiIiIiIh/cTqPLYnuO87SUI7vqfh5yRAG29cxIug3Qs/4C0mxESTFRjAiMUrTor2MkosiIn7k+Olp89q+R2eAxEssiqie4s6ExVMhc4H54GOzWR2RiIiIiIj/2LUa9qRDUCgkWLvS6fjeiT86+gMwMGgjg8/uWHbclWQU76Fl0SIifuL4O32tyKPjgeXmC4s/KNRZ7GlgD4EDWyF3s9XRiIiIiIj4l1WlVYvdzofGLS0N5fjeiducbcl0tCPIWQKbF1kUldSGkosiIn7i+Dt95wUtI9jmYJWjM1N+OWpRVPUUGg4dBpr9zeq7KCIiIiLiNk4n/D7b7HvBlOik2IhKPRVzo043O5t+sCAiqS0tixYR8RPH3+kbaf8FgDklpzJ9fgYjEqN8c/lA3DAzvS5zIQy41upoRERERET8w561sD8LghpBt/OsjgaAySkJFXsq5jvhw1mw6UerQ5MaqHJRRMRPlL/T14JDDLX/DsAcx2CgcmWjz4g702wzF5C6ZR+zlm8jNSvX2phERERERHzd+q/NNu5Ms2LISyTFRjBmQEdTGBE3DGxBsHcD7N9qdWhSDVUuioj4kckpCcRFhvPbJ88TYish3RFLprM9ULmy0Wd0HGzuph7ayZ3TZ5LhjAZgfHI8k1MSLA5ORERERMRHrf/GbLuPsDaOmoS1MG2Stv0KGT9qJZOXUuWiiIifufyUWMa3WQ3AVyWmanFCcrxvLokGCAnjYJskAIbY15Qdnj4/QxWMIiIiIiJ1cXgfbDVtlLw6uQjQ5Wyz1dJor6XkooiIvzl6gK55vwLQ9/xrmT1xKPf6WIVfalZuheXPW1uYoS7lk4vgw0u9RURERESstPF7cDqgbS9oGWt1NDXrcpbZZswDh8PSUKRqWhYtIuJv1s0BRxG06cl5yclWR3PSpsxJZ/r8jLKvxyfHM6ZLMqx7gdPsawAnYAN8eKm3iHiN1KzcY03jfbXCW0RE5GS5+i16e9UimGXRoc3gyD7YuQKik6yOSI6jykUREX+z5lOz7XWxtXHUQWpWboXEIpjlz4fb9KfI3ohIWx7dbdsAH1/qLSJeYcqcdEZPW8KkGSsYPW0JU+ak1+pxx1dXi4iI+JSSYtj4ndnv5gPJxaCQY0MetTTaK6lyUUTEnxzNM0scwCeTi9Utc87ILaJ/56GQ8SOPDzyAc/DlSiyKSL1UdzNjRGJUje8vVVVXa7iUiIj4lG2/wtH90DgCOp5idTS10+UsWPclbPoBhk2yOho5jioXRUT8yca5UFIArbua/ik+prplznGR4RA3DID+xSuVWBSReqvuZkZNvVyrS0g+M3ddnaoYVQEpIiKWcC2J7noeBPlIzZlrqMvWX6BQfde9jZKLIiL+ZN0cs+15Edhs1sZSB0mxEYxPjq9wrGz5c+fSpRCbF6mRs4jUW403M6pRXeLx2e83ntSyaqj7kmwREZF6W/+t2fpCv0WXVvHQIhZKCmHLEqujkeMouSgi4i9KimBD6QeFHiOtjaUeJqckMHviUJ4e16/ipOvoJNPI+eh+2LXK0hhFxPfVeDOjGicaIjV9fkatqhCrq4BUBaOIiHhc7mbYkw62oGPVgL7AZoMuw82++i56HSUXRUT8xZYlcPQANImEjoMA311ylxQbwZgBHSte5AcFQ6chZj9zoTWBiYhfqfZmRjWqSkger6Zl1Sc6pzaPFRERqRdX1WLMqdCklbWxnKzSZOiB37/1uesbf6fkooiIv3Atie5+AdiD/HPJXWfTd5HNSi6KiHtUeTOjBq6E5G3ndK3y+yeqbqzpnNo8VkREpF42fGO2vrQkutTUTe1xOG20OLiBW6Z96R/XN35CyUUREX/gdJrpaQA9R/rvkrs4V3JxMZQUWxuLiASspNgI7jivx0kvqy7/+Lo+VkREpM4KDkHmArPf/QJrYzlJqVm5TF2yl1XOOADOsK/yj+sbP+EjY4FERKRGu9fA/iwIDoP44WSurvqXbGZOvm9fvEb1hUYtoOCA6bsYnWR1RCISwCanJDAiMYrMnHziIsNP6v21Po8VERGpk8z5ZiBKy1ho08PqaE6Kq3XIQkcf+tkzGBa0ilmOM33/+sZPqHJRRMQfrPvKbOOHQ2i4/y65sweV9ZNk21JrYxER4eSXVbvrsSIiIidtvWtJ9AVmQIoPcV3HLHL0AeAM+2rA6fvXN35CyUUREX/g6rfYIwXw8yV3MYPNdttv1sYhIiIiIuIrnM5yyUXf67four5Z7uhGvrMRbWwHeGiQwz+ub/yAlkWLiPi6vGzYvszsd08pO+y3S+7KKheVXBQRERERqZXsFXBoJ4Q0gU5nWB1Nnbiubw5+cQrhuxdxQ8cdVockpVS5KCLi69Z/bbYdBkGzdhW+5ZdL7joMNNt9Gaxcv8naWEREREREfMGGuWYbPxxCwiwNpT6SYiOI6j3cfLH1Z0tjkWOUXBQR8XXHLYn2d1Pm7WSjIxqAqW++x5Q56RZHJCIiIiLi5TJ+NNuu51gbhzvEnGa2Wb+Y5d5iOY8mFxcsWMCoUaOIjo7GZrPxySefnPAx8+fPZ+DAgYSFhREfH8/06dM9GaKIiG8rOAQZ88x+zwstDaUhpGblMn1+Bssd3QBIsm9k+vwMUrOqno4tIiIiIhLwCg7B1l/NfvxZ1sbiDh0Ggj0YDu6AA1utjkbwcHIxPz+ffv368fzzz9fq/MzMTEaOHMmwYcNITU3l/vvv529/+xszZ870ZJgiIr4r40coKYCIztCmp9XReFxmTj4Aqc6uACTZNlQ4LiIiIiIix9myGBxF0DIWWsWf+HxvF9oEovqa/axfrI1FAA8PdElJSSElpfbL9KZPn05sbCxTp04FICEhgaVLl/Lkk08yduxYD0UpIuLDypZEjwSbzdpYGkBcZDgAqaWVi/3tm7DjKDsuIiIiIiLHca10ij/Lf64ZYk+DHcth6y/Q9zKrowl4XtVz8aeffuL888+vcGzEiBEsXbqUoqKiKh9TUFBAXl5ehT8iIgHBUXJsmEuA9FtMio1gfHI8650dOeQMo6ntKA+cgn8NrBER6+Vlw6HdVkchIiLiHptK+y128YMl0S4xp5qthrp4BY9WLp6snTt30q5dxUmn7dq1o7i4mJycHNq3b1/pMY8++igPP/xwQ4UoIuI9tv4Kh/dCWEuIHWJ1NA1mckoCIxKjOPxZP5rm/MKNnfdaHZKI+DJHCexOh6yfTPVD1s/H+jc1bWeWXbXva7bR/U0bChEREV+Rlw170gEbxCVbHY37lCYXnTt/Z+WmrfTrEmNxQIHNq5KLALbjSnSdpZN/jj/uct999zFp0qSyr/Py8oiJ0Q+ViASAdV+ZbbfzISjE2lgaWFJsBCScAQt/gW2/wcDrrA5JRHxNSTHMewR+fRUKDlT8ns1upk8e2gUb55o/Lp1Oh+GTofMw/1laJiIi/su1JLp9P2jSytJQ3GnK4v1c7WhDjH0PT7z2Lr2HXczklASrwwpYXpVcjIqKYufOnRWO7d69m+DgYFq3bl3lYxo1akSjRo0aIjwREe9S1m8xMJZEV9LxFLPd+pu1cYiI7zm4Ez66HrKWmK9Dm5r3lNjTzJ8Og0zicNfvfPP9N+zbuIxE+2YSbFmEbFkMb41SklFERHxDhv8tiU7NymX6/Ax6hHQnhj0Msq9j6vwMRiRGqV2SRbwquThkyBA+//zzCse+/fZbBg0aREhIYFXliIjUKGcD7N0A9hDoeq7V0VjDlVzMWQdH9kPjllZGIyK+InMBfHwj5O+G0GYwair0ugSCKn8sTnV245a1e4ABAESxl/HBn3Nt6DzsFZKM90HcsAb9a4iIiJyQ01lxmIufyMzJB2CZozujgxYz0La+7LiSi9bw6ECXQ4cOkZaWRlpaGgCZmZmkpaWRlZUFmCXN1157bdn548ePZ8uWLUyaNIn09HRef/11XnvtNe666y5Phiki4ntcS6LjhkFYc2tjsUp4JETEmf3ty6yNRUS8n8MBC56Ety82icV2veHP86DPpVUmFuHYxYvLTlrzz+Lr+OacOTD4zxAUClsWw1sXwWd/hYKDDfAXERERqaXd6abFR3BjU5nvJ+IiwwFY6ugBQJJ9I0GUlB2XhufR5OLSpUtJSkoiKSkJgEmTJpGUlMRDDz0EQHZ2dlmiESAuLo6vvvqKefPm0b9/f/7973/z3HPPMXbsWE+GKSLie8qWRI+0Ng6ruaoXty21Ng4R8W4FB+H9y+GHf4PTAf3/CDfOhciuNT6suouUqJguMPIJ+FsaDLoBsMHyt+HF02HLT+6PX0REpC5cS6I7DYVg/2knlxQbwfjkeNY7O5LnbExT21H+PsihqkULeXRZ9PDhw8sGslTlzTffrHQsOTmZ5cuXezAqEREfl59jJpoCdL/A2lis1vEUWDUDtv1qdSQi4q2cTvj8dtjwLQSHwcgnYcA1tXqo6+Jl+vyMsmMTkuOPXby06AAXPQO9x8LsCbB/C843Uljf9XqOnH4v/eOiPPAXEhERqaVN/tdv0WVySgIjEqM48vkAmu9ZzPUxu60OKaB5tHJRREQ8YP03pvImqg+0jLE6GmvFlKtcdDisjUVEvNOKD2D1x2ALgmtm1zqx6DI5JYHZE4fy9Lh+zJ44lHurmkTZ+QyYsJiVkRdiw0mPja/T6I3zeG3m55XPFRER8bDUrFxmL82gZPMicyB+uKXxeEpSbATteg83X7iKL8QSXjXQRUREasHVb7HHhdbG4Q3a9TaVSEf3w75NENnN6ohExJvs3QRflfbuHn6fWRZWB0mxESdcapW6u4TR265mhL07j4S8SoI9i7iV17Ol5aN0OufmOr2uiIjIyZoyJ53p8zM41ZbO6EZHyA+OILxtotVheU7MYLNVctFSqlwUEfElRUdh0w9mv0eKtbF4g6AQiDZ9fdmqpdEiUk5xIcy8EQoPQaczYNgkj76ca/jLN45TuKDgMeaX9CXMVkSnhXeZZdlFRz36+rWVmpXLrOXbSM3KtToUERFxs9Ss3LJWHmcErQJgbkECqdsOWBmWZ3UYZFYnHNgKB7ZbHU3AUnJRRMSXZM6HosPQLBra97M6Gu/QcZDZbvvN2jhExLv8+H+wIxXCWsKYl8Ae5NGXKz/8ZQ8tua7oHp4pGosTGyx7A964APZn1fAMnjdlTjqjpy1h0owVjJ62hClz0i2NR0RE3Mt1owtgmN0kFxc5+lQ47ncaNYWo3mZ/68/WxhLAlFwUEfElZUuiU8BmszYWb9GxdCmEJkaLiMumH2Hxs2b/4uehRUePv6Rr+IuLEzuFZ9yN7eqPoXGESXS+dCZs+M7jsVSlfDWLy/T5GapgFBHxI64bXc05RB+bec9fWNKnwg0wvxRzmtlmaWm0VZRcFBHxFQ4HrPva7PccaW0s3qRj6VCX3b9DwSFrYxER6+XnwOxbzP7A6yFhVIO9dJXDX7qdC7csMC0cjuTCu5fCvCkNPoSquqoVv65mEREJMK4bXUPsawiyOdng6MCY5EEn7Bvs82JPNVtVLlpGyUUREV+RnQqHdkJoU+g8zOpovEfz9tC8o5mgvWO51dGIiNU++ysc2gVtesKIRxr85ZNiIxgzoGPFC7mWsXDDNybZiRPmPQrvXQaH9zVYXNVVrfh9NYuISICZnJLA//XdA0CL3ueZG13+zlW5uHO1ig0souSiiIivWFu6JLrrORDcyNpYvI36LooIwOZFpn1EUCiMfQ1Cm1gd0THBjWDUVLjkRTPlfuN38FIybG+YmyLHL9sGmJAc7//VLCIiAajNriUAtO13gcWRNJAWHaBFDDhLYLtaJVkh2OoARESkltbNMdseF1obhzeKGQxrPoGtSi6KBLQFT5ht0jXHmrt7m/5XQVQf+PAayM2E10dAyuMw8DqP99KdnJLAiMQoMnPyiYsMV2JRRMQf5W4xv1/swdD5DKujaTgxg83E6KxfIH641dEEHFUuioj4gtzNpqegLQi6nWd1NN6nQ2nl4o5Ua+MQEets/Q0y5pmLqTNutzqamkX1gT/PMzeLSgrhi9vhk4kNspQrKTaCuMhwMnPyNcxFRMQPZS01q50ORfaHRs2sDaYhuZZGb9VQFysouSgi4gtcVYuxQ6BJK2tj8UZRfcBmNz0p87KtjkZErLDwSbPtd4XpceilUrNymbV8G6l7nHDFu3Duw+b9a8V7MP0M2PqrR19/ypx0Rk9bwqQZKxg9bQlT5qR79PVERKThTJmTTtqCTwF4bUdsYL3Hu4a6bPutwYemiZKLIiK+YV1pv8UeKdbG4a1Cm0BkD7OfnWZpKCJigewVsP5rk6Q7Y5LV0VSrUmLv67WmyvJPX5heUa5l0j/8H5QUuf31U7NymT4/o8Kx6fMzVMEoIuIHzHv8JobYfwdgcUliYL3Ht02E4MZQkAd7N1odTcBRclFExNsdyYXNi81+z5HWxuLNopPMdkeapWGIiAUWPmW2vcdC6y7WxlKNGhN7nU+HCYuh7+XgdJjeka+dBzkbany+Wcu3ndRFY2ZO/kkdFxGxSl3e4wJdZk4+PWxbaWPL47CzEanObmXHA0JQMLTvZ/a3L7M2lgCk5KKIiLfb+L2ZfNamJ7SKP/H5gSq6v9mq76JIYNm9FtZ8ZvaH3WltLDU4YWIvrAWMeRkufQPCWpr3sunD4KcXKlUx1nVpc1xk+Ekdt4ISCiKi9g11ExcZzumlVYu/OXpQVDq/15ve4z2uwwCz3bHc2jgCkJKLIiLebu2XZqsl0TVzVS5mp4HTaWkoItKAFj4FOCFhFLRNsDqaatU6sdd7DEz8yUy6LD4C39wPL54Om34A6re0OSk2gvHJFW9STUiO95qp0UooiIjaN9RdUmwEV7Ux/+0WOxIB73qPbxAdBprtdiUXG1qw1QGIiEgNigtgw1yz3/Mia2Pxdu16lw512QUHs6F5tNURiYin7d0Eqz82+8PusjaWE3Al9spfNFd70dc8Gv44G1Lfhu//BTnr4H+joedF7OrwlyqfPzMnv1YXkJNTEhiRGEVmTj5xkeH1vuhMzcp1y3NVl1AYkRgVWBfGIgGupipvvRecQEkRXQ+vBODUc8eS0mVQ4P03cxUb7FwFxYUQHGptPAFEyUUREW+WuQAKD0LTKIgeYHU03i20iVk6vnuN6buo5KKI/1v0jOlR2O38Y60RvNhJJfbsdhh4HfS6GOY9Br++DGu/4PwN33JXcAovF19IHk3LTj+ZZW9JsREVXruuCcIpc9IrJATHJ8czOaVu1aNKKIgErvLvQb7QvsFrbV9urhsat+Kc5HPM75FA0yretBY5uh92/34s2Sgep+SiiIg3W/uF2fYcGZgfEE5WdJJJLmanafiNiJ9yXYR2D9tP7xXvm4Nn3m1tULVQ/uJ5zICOtX9g4whImWISjV/fiz1jHn8J/pTrg77mw5KzeL0khVFnnlrnBNzxCcLRSdEM69bmhIlGd1caKqEgEpiquklR6ypvqShzvtnGDQvc6wabzVwPZPxokq1KLjYYJRdFRLyVwwFrvzL7PS+0NhZf0b4/pL2roS4ifqr8Reg/gt+id3AxxCVDzGCLI6uZWyr82vaEaz4xfXjnPUr4rtXcEPw114d8i+3QxbD9r8d6TZU6UUViVQnC2ak7mJ2644RxurvS8KSWjYuIX6juJsXsiUPd2r4hYGS4kovJ1sZhtQ4DTXJxx3LgRqujCRhKLoqIeKvtSyF/NzRqDp3PtDoa31A2MTrNDHWx2ayMRkTcqPxFaAjFXBK0GICN3a6nq5WBnYBbK/xsNki4yNxwyvgRlvwX26Yf4PfZ5k/HUyBxNCT8gSk/HTphQrO6BGFt4vREpaG7+0GKiHer6SbFmAEd9R5wMgoPw7ZfzX78cEtDsZxrYvR2FRs0pACtlRUR8QHpn5ttt/PVjLi22vUGW5BJyh7MtjoaEXGj8hehyfYVRNgOsdvZklWh3r3kqaaL5zqz2aDL2XDNbBi/GPpdCfYQ2PabmS49tTcjfvojNwd9QUfbbqDqaau1SQS64kzNymXW8m1lz+GpydNJsRFKKogECLVDcKOsn6CkEJp3NH0HA5mrT/2edCisx+9aOSmqXBQR8UZOZ7l+i1oSXWtlQ11+N0ujNdRFxG+Uv9gcHbQQgE9LhjKobQurQqoVj188R/WG0dPh3H/Cmk9hzac4tywhyb6RJPtGHuA9MhxRLHX0wLF8EzQZCa27gM1W5VLkquKsblm3Kg1FApc7JsWrHYIbufotxidr5U7z9tCsvSk0yF4BnYZaHVFAUHJRRMQb7VkH+zIgKBS6nmt1ND4jNSuXiEbd6czvZmm0ErMifsN1Efre/FWcazdLnYL7X+H1F6ENdvHcLApOvQVOvYXVa9fx4f9eZKT9F061pxNv30m8fSekzYe0B6FJJMScCu37Mrlzb0bFxrLuaAQLN+aU9Vt0xQnUuKz7+MnTIuL/atVH9sB22LwIjh6AggNme/SAWb7b80LoPQZQOwS3Ub/FiqIHwLovzVAXJRcbhJKLIiLeyFW1GJcMYc2tjcVHuD7oXhPUgn+HwMaVi+h6ttVRiYi7pGbl0r1dM147ZTuNVhVxJKIH14/9g9Vh1UpDXzz36dmDL8+4havmn0dzDjHAvoFbOu9mSPAG2L4MDueYi651XwKQCCQ2as6Ydoncn9SNrSFxhMf2p0ffTsxava/K16jr4BYR8W216iO79Vf43xgoPFj1k6z+GDYvhAumQHAj3aSor8P7TIUemMpFMX0X131ZOtRFGoKSiyIi3mitueAj4SJr4/AR5T/ornbEAdAidzWpW/aR1KmVlaGJiBuUr5L5MPQDsEPjgVf61NKvhr54rpjQPP/YaxcXmMru7Uth52rYtcpUyxfkQdZPtOEn2gCsBL6wMbJ5HKEhbUl1dOVXR0/WODtRQpB6ookEqBNOis/6Bd4ZaxKLkd2hbQKEtTADCsNaQv4e+PVlWPq6SYiNextadGzYv4S/2bwQcJrWQM2irI7GO5QNdVlmbRwBRMlFERFvc2B76V02G3RPsToan1D+g+4aZyeKnXba2PJYui0DlFwU8Wnlbx50tO3hVPtaHE4ba1qPoLfFsXm7KhOawY0g9lTzx6WkCHLWlyYbS//sXA35uwnLy+CioAwuCvoZgHxnI5Y7unHom9PgvNEQOwTsQW6J1x093ETEs2rsI5v1c2li8RB0HgZXfQihVZzf7TyYeZNJ/Lx0Jlz6uiYc14eWRFcWXTrsLXezqexsousBT1NyUUTE26z7ymxjBkOzdtbG4iPKf9AtIJQNzo4k2LLo4dgIDLIuMBGpt/I3Dy62LwbgJ0cvdh1pruSiuwSFQLtE84fLjx0/tBt2rmJH+s+k/zqXQfZ1tLAdZljQati+Gt58FcLbQq+LTf+0mNPAbq9TCLXq4SYilqu2j6xzLbx7KRQe4mD7ofzQ6xlidxaSFFtNcvGW+fDhNbBzJfxvNJz9IJxxh09VpHuN8sNcxGgcYaZm78swRRvqYe9xSi6KiHgbTYk+acd/0F3liCPBnkV80UaLIxOR+jp288DJ6KBFAMx2nMHVWpbreU3bQtdz+DmvB5OK+mPDQXfbNk6xr+MU+zouCPudRvm74bdXzJ9m7aHXJZB0NUT1qfXL1KqHm4h4jUp9ZJ3p8M6lUJTP5uaDuCDzZo5mrgfWV3+jIKIz3PgtfHknpL0L3z9sqqBPv62h/zq+7cB22LsRbHbodLrV0XiXDgNNcnF7qpKLDaButxZFRMQzjuSayXoAPdVv8WRMTklg9sShPD2uH0OGlX6A2JFmaUwiUn+umwd9bJl0te/gqDOEDqeNU9KpAbkSvE7srHPG8k7JedxW9BfWXL0Urv4Y+l0FjVrAwWz45UWYfga8e5npvVYLNfVwExHvlBQbwZgBHUmybypLLOZFD2PE7r9wlEZl502fn0FqVm7VTxLSGC5+Ac77t/n6h/+D3ekNEL0fcVUtRidB45aWhuJ1okv7LmqoS4NQclFExJtsmAuOYmiTAK27WB2Nz3F90I1JHGoO7EgFp9PaoESk3ianJPBakqlEPhJ/AXeMUruDhuRK8JY3ITmepM5tzfLG0S/C3Rvgyg9M5aLNDhu+hdfPhzcuhE0/1PheXGMPNxHxXk6nqTwsyof4s/ghaSoFhFY6rcYbBTYbDP0rdDsfSgph9njTB1Zqp7Tf4romA6pP4gaq8kNddD3gcUouioh4Ey2Jdo92iWAPhsM5kLfd6mhEpL5Kimi72bw/Rgy51uJgAlP56vDZE4dy7/HLHIMbQY8UGPcW/GUpDLgW7CGwZZHpp/bK2bDlpyqfu9rkpapTRbzb2i8hOw1CwmHsq3Rq17rK0054o8Bmg1HPmWnS2Wmw6Bl3R+qfnE4Opc8F4J+/t2X0tCVMmaPKzzJRfcEWBId2Qd4Oq6Pxe0ouioh4i6KjsOE7s6/kYv2ENDbVn6Cl0SL+YNOP5mZBk0jocrbV0XiN1KxcZi3f1mDVKmXLIE+U9GvdBf7wX7gtDU4dD8GNzbK0Ny5gzwe3wtG8Sg85YfJSRLyLwwE/PmL2TxsP4ZH1u1HQvD2MfMLsz38Msle6OWD/k77iZ5oW7eWIM5Rlju7ACZahB5rQJtDWdT2gpdGepoEuIiLeYtMPZllJ8w6mb4rUT3Q/2LXKLI1OUP9KEZ+28gOz7XMpBOnjK/jIdOUWHSHlMZ4r+gNtf32cK4Ln0WbtO+Q99Q3Nxz4HPUdWOD0pNqLGJERqVu6xARKqahSx1ppPYPfv0Kg5DPlL2eFKw15O5t9qn8tgzadmJc8nE+DmHyG48jJrMYrWfw/Az44ECgkpO56Zk6/3SJcOA2DXati+HBJGWR2NX1PlooiIt/h9ttn2utgsD5H6cSVos9MsDUNE6ulonll6B9D3cmtj8RLVTVf2xmqV1Kxcnl6yn8nFf+bKwgfY7GhH86I98MGVMONPcHBXrZ5nypx0Rk9bwqQZK7T0T8RqjhKYN8XsD7kVmrSq8O1aVzkfz2aDi6ZCk9YmITT/MaDhq7R9RecDPwOw0NG3wnH1qy0nulzfRfEoJRdFRLxB0RFY95XZTxxtbSz+on1pcnFHmpo4i/iy9d9A8VFo3U1V3aV8abpy+Zh+ciQyovAxXiwehcMWZCqfpp1qlr3XwJeSqSIBYdXHkLPO9Eg8bYJ7n7tpG7jwKbO/6Bne/GhmpRsLSjYCRUdpvus3ABY6+pQdVr/a47iGuuxIM0v5xWO0rkREpIHUuJxr4/dQeAiad4QOmoLqFuWHuhzYBi1jrI5IROpiw7dmm3CRqrpL+dJ05eNjKiCUx4qv5Kyxt9Dzl/th50p4Zwyc/39w2sQq/x/XlEzVRbRIAyspgnmPmv3TbyN1t4PMnG0VPt/Wu4VB4mhY8xn8PovTVz1IMI9SXJq6mD4/w/tbQjSErJ/Mjbdm7Xn8+svI3HtYLSOq0rYXBIdBwQHYlwGRXa2OyG8puSgi0gBO2BvLtSQ68RKwq6jcLULCTBPnnavM0mglF0V8j6MENpYOuup2vrWxeBHX0ITyv1e8tVqlulh7JiVA77nwxR2w4j345n4zwGHUVDOUqxxfSqaK+L0V70NuJjSJ5KkDyfx32pKyb7mGubgl+XfhUxRs+JFuhdsZHbSIj0qGV3na9PkZjEiM8sr3P4/a9IPZdjmbpE6tSOrUqubzA1VQiJkave1XM9RFyUWP0RWsiIiHnXA5V9ERWDfH7GtJtHu172+22SssDUNE6mj7MjiyD8JaQMfBVkfjVXxpunK1sYaEwSXT4IIpYAsyg3veSIED2ys8vl4TaEXEfYoLYb6Z6Lyt93j+u2hnhW8fX1XoOlan5ctNWpHTzyy5/mvQbIIprvZUb2wJ4XGudhJdzrY2Dl/QQX0XG4IqF0VEPOyEy7k2zDVTolvEQIeBDRydn2vfD1L/p+SiiK9a/43ZdjlHU6KrcKLpyt6k2lhtNtOzrW0CfHQd7EiFl4fDFe9CzLGEcr0m0IqIe6S+DQeyoGkUS9uMBtbV6mF1bWHQ4by/kJ/6IrHFe2qsXgy4KuZDu2HXKrMfP9zSUHxC2ZBHXQ94kioXRUQ87ITLucoviVY/Mfdq389ss1daG4eI1I2r32L3EdbGIZ4XPxz+PA/a9Yb83fD2xZAxr8IpdZ5AKyL1V3QUFpQOWhl2J53ata71Q+uc/AsNJ/zsOwH4Z4uvmD3+FFUxw7H3xqi+EB5paSg+ofz1gKPE2lj8mJKLIiIeVuNyrsLDsP5rc1BLot2vXSJgg0M74eAuq6MRkZORl22GfWAzlYvi/yI6w43fQtdzoegwvDsO1n9rdVQiArDuSzi4A5pFw8A/Vfv51u3Jv0E3Qngbwg9vI2nf1z7VEsJjyvVblFqI7A7Bjc1Ksb2brI7Gb2l9iYhIA6h2OdfGueYCqmUsRA+wNkh/FBpuPlDkrDNJimbnWR2RiNTWxrlm22EANG1jbSzScELD4Yr34KPrTTLjg6vgsjcgYZTVkYkEtlUzAdgZdwlLVu4hLjK82s+3bm1hENoETr8dvn0AFjwB/a70qZYQbud0Krl4suxBENXHDHXJToM23a2OyC+pclFEpIFUuZyrbEn0aC2J9pT2fc02O83SMETkJLmWRHfTkuiAE9wIxr1lfjc6imDGn2DVx1ZHJRK4juwvu+Hzp99imTRjBaOnLWHKnPQqP9+6vYXBoBsgvC3sz4K099zznL5q9xo4tMtU4sWeZnU0viO6PwC71/3CrOXb6jZkSGqk5KKIiFUK848NK9CSaM9R30UR31NcCJvmmf1uqjgOSEEhMOZV6HsFOEtg1s0VkgqpWbm6QBRpKOmfQ0kh6xwdWeeMLTtc50nQJyE1K5dZq/exLfHP5sDCJ83viEDlqlrsfLq5ESO1U3o9kLFqcYXkuLiPlkWLiFhlw7dmSXREZ2jf3+po/FdZclET4kR8RtZPUHjQVKro/TFwBQXDJS+aC+jlb8EnEwCYkp3E9PkZZaeNT45nciD2XRNpKKtN5fBnJUMrfauuk6BrY8qc9LJ/62F0YWmzVjTdnwUr3oOB13nkNb2elkTXSbotngSgl20zNhw4sTN9fgYjEqMCd4m9m6lyUUTEKloS3TCi+pjt/i1wRBUuIj6hbEn0eWDXx9WAZrfDqGdhsKlacn76F9YvrLhEuiGqp0QC1sFdkLkAgM8dQyp9u86ToE8gNSu3wk2EozTi6cMXmi8WPBWY1YtFR2HLErOv5OJJWVvcngJnCM1tR4i17S47npmTb2FU/kWf1kRErFBw6NgETC2J9qzGEdCyk9nfucraWESkdsqSi+dbG4d4XK2WN9tscMFj0O9KbM4SpoU8yyDb2gqn6AJRxEPWfAJOB3QYyMgzKyYX6z0JugZV/Zt+t+QcjjaKhANZkPauR17Xq2X9BMVHoVl7aNPT6mh8Sue2LUkvXdLfx5ZZdtxTyfFApOSiiIgVNnwDxUegVTxE9bU6Gv9XNtRFfRdFvN6+TMhZD7Yg6HKW1dGIB02Zk87oaUtq1//Kboc//JcDMWcTZivitdAn6WHLKvu2LhBFPMQ1TKn3pUxOSWD2xKE8Pa4fsycO5V4PtiOo6t90AaHk9DftEVjyHDgcHnt9r1R+SbRWPZ2UpNgIHKXXXL3tmwHPJscDkZKLIiJW0JLohqW+iyK+Y4OZSErsEAhrYW0s4jHHL3mEWixvDgqhxTXvsq1pH1rYDvN26BQ62vboAlHEU3K3wLZfAVvZSpuk2AjiIsPJzMn3aDuCpNgIxifHVzg2ITmejmePN78b9mUcq3IPFJt+NNt43XiriwGnmv9uY6L2eDw5HogaJLk4bdo04uLiCAsLY+DAgSxcuLDac+fNm4fNZqv0Z+3atdU+RkTEpxzeh2OdmRKd3vpci4MJEFFKLor4DNfFYnctifZn1S1jPuHy5tAmdLz1c45E9KCdbT/ftZnKvcMiPRChiLB6ptl2PgOatwdOsuK4nqqslGzUFAb8yZzw8zSPvbbXObQbdpW294kfbmkoPqu02KDtobUkxbS0NhY/5PHk4ocffsjtt9/OAw88QGpqKsOGDSMlJYWsrKwaH7du3Tqys7PL/nTr1s3ToYqINIhvZkzD7ihkjaMTKR/kevRDmZRyVS7u3QCF6ssl4rUKD8Pm0pvQ6rfo16pbxlyr5c2NI2h8/SfQIpawvEx491K9t4t4giu52OdSoI4Vx/WUFBvBmAEdK1YnD/6zaZ2ROR92/e6x1/YqriXRUX2haRtrY/FVbXuBPQSO7jeDHsWtPJ5cfPrpp7nxxhu56aabSEhIYOrUqcTExPDiiy/W+Li2bdsSFRVV9icoKMjToYqIeFxqVi7tMmYB8HHJmYCmXDaIZu2gaTvTkHzX77UbICAiDW/zQtOsvkWsmtX7ueqWPNZ6eXPzaLhmNjRpDdlpMOvPgdd/TcSTdq+FXatNMibhD0A9Ko7drWUMJFxk9n+uOa/gN9Z/bbbdzrM2Dl8WHArtepl9rWZyO48mFwsLC1m2bBnnn1/xzvP555/PkiVLanxsUlIS7du355xzzuHHH3+s9ryCggLy8vIq/BER8VY5mSvpb99EkTOIT0uGlh3XlMsGUFq9+M333zTYch4ROUnrTcsIup2nfrQBoN7DISK7whXvQVAorP0Cvn/YM4GKBKLVpYNcup4DTVoB9aw4drfTJprtyhmQn9Pwr9+Qigthw3dmv8dIa2Pxde37m+2ONCuj8EseTS7m5ORQUlJCu3btKhxv164dO3furPIx7du35+WXX2bmzJnMmjWLHj16cM4557BgwYIqz3/00Udp0aJF2Z+YmBi3/z1ERNylb85XAMxz9GcvxwYVaMplAyidEJe7cWmFw6ocFfEiG0uHuWhJdMCo93CI2NPg4hfM/uKpkPqOW+MTCUhOZ4Up0S71rjh2p5hTIToJSgpg2RsN//oNacsiKDwI4W0heoDV0fg2DXn0mOCGeBHbcXeenU5npWMuPXr0oEePHmVfDxkyhK1bt/Lkk09y5plnVjr/vvvuY9KkSWVf5+XlKcEoIt7JUUK7zZ8C8HHJsLLDmnLZQEo/TCTaN1f6VmZOvv4fiFgtdwvszwJ7MMQNO/H54hemzEmv0MNtfHI8k0+2grHvOMjZAAseh89vh4jOZgCFiNTNjuWQmwnBjaFHSoVvTU5JYERiFJk5+cRFhlv3+clmM9WLs26GX1+FobeZZa/+aF3pkujuI8DeIDN5/ZercjF7hUmia5WE23j0JzMyMpKgoKBKVYq7d++uVM1Yk9NOO40NGzZU+b1GjRrRvHnzCn9ERLxSxo9wMBsat2LCzRPrvgxM6qa9qVzsYdtKCMUVvqXKUREvsHmR2UYPgFD9mwwEbh0OMfw+SBwNjiL48I+wd5ObohQJQKtKB7n0SDHTmY9T5ZAVK/S6BJpGwaGdsOYTa2PxFKcT1s0x+1oSXX/tEs0woMM5kLfd6mj8ikeTi6GhoQwcOJC5c+dWOD537lyGDh1azaMqS01NpX379u4OT0SkYaW9Z7Z9LqV/XDvv+FAWSFp2grAWhNpK6GbbVnZYlaMiXmLLYrPtfLq1cUiDcetwCLsdLnkROgyEI7nw3uVmKyInx+mE9M/Nfp9Laz7XasGhMPgms//zNBO7v9n1OxzIguAwiB9udTS+LyQM2pYWdmhptFt5fFn0pEmTuOaaaxg0aBBDhgzh5ZdfJisri/HjxwNmWfP27dt5++23AZg6dSqdO3cmMTGRwsJC3nnnHWbOnMnMmTM9HaqIiOcc2Q9rvzT7/a+yNJSAZbOZvoubF/LiOcEsa9XP2uU8IlKRq3Kxk5azBgq3D4cIaQxXvA+vnA17N8BH18HVMyGoQTpBifi81Kxc9mz+nfMPZJlBSfFnWR3SiQ28HhY8CTtSYesvpg+rP1lfWrUYPxxCm1gaij9IzcolIrQbnVlthrr0vNDqkPyGxxfsX3755UydOpV//etf9O/fnwULFvDVV1/RqVMnALKzs8nKyio7v7CwkLvuuou+ffsybNgwFi1axJdffsmYMWM8HaqIiOf8PhuKj0KbhGO9PqThlfZd7FS4UZWjIt7kwDbYv8UsVYo91epopIF4ZDhEs3Zw1QcQ0gQy5sHcB+sXpEiAmDInndHTlrDwm48A2BLexzeSWeGRpu8qmOpFf1O2JDql5vPkhFw/469nmFZ6G1cutjgi/9Igt/EmTpzIxIkTq/zem2++WeHre+65h3vuuacBohIRaUAr3jfb/lepcbCVNCFOxDttLv2A374fNGpmbSzSoDwyHCKqD4yeDjOuNcmGdr0h6er6P6+Inyrf/3SYfRUAH+7tynlZub5xI/bUCbD8bbOcO3cLRHSyOiL3OLgTti8z+90vsDYWH1f+Z3y1Iw6A5rm/k+orP+M+QKOGREQ8LWejWaZhsx+7syrWcCUXd64GR4m1sYjIMVtKl0Sr32JAqu9wiNSsXGYt31ZxEEyviyH5XrP/xe2w9df6Byrip1x9ToMo4TT7GgAWOvrUrf+pFdr1MsuGnQ747VWro3Gf9d+YbfQAaBZlbSw+rvzP8hpnJ0qcNtra9pO9bbN1QfkZJRdFRNygygsbF1fVYtdz9cHAaq27mqVyRfmaJCriTY7rt1jje6pIOa5lbpNmrGD0tCVMmZN+7JvJk6HnRVBSaCZI5+2wLlARL+bqc9rPtonmtiPkOpvyu7Nz3fufWmHwLWa7/G0oPGxtLO6iKdFuU/5n+SiN2OjsAEAPh64H3EXJRRGReqrxwsZRciy52O9KawKUY+xBZnkcwM6V1sYiIkZeNuzLAGwQe1rN76ki5ZRf5uYyfX7GsaS03Q6jX4K2veDQLvjgKig6YkGkIt7N1f/UtSR6sSORW5K7+tZy0e4joGUsHN0Pqz6yOpr6Kzxs+saC+i26wfE9flc7OwPQpVjJRXdRclFEpB5OeGGTuQDytkNYC9119Bbt+5ptdpqlYYhIqS2ufot9Sd3jrPk9VaSc6pZsVjjeqClc8R40jjDTZD/7GzidDRShiO+YnJLAzR02A9D3zEu4NyXB2oBOlj0IBv/Z7P/6su//O8+cD8VHoEUMtEu0Ohq/MDklgdkTh/L0uH6cOvRsc1DXA26j5KKISD2c8MJm6etm2/tSCAlroKikRmVDXVS5KOIVyi2JrlWySKRUdUs2Kx1vFQeXvWWmka+aAUueq/QYLcWXgHf0AE33pAEQO+hCa2Opq6Q/mvY3u1bDliVWR1M/674y2x4pGgbpRq4evx17DTEHNOTRbRpkWrSIiL+q8cJm/1ZY+4U5cMpNDRiV1CjKVbm4wtzV1gc2EWu5Khc7n05ck1omi0Q4tsytfLXrhOT4qpdyxifDBVNgzt0w9x/QthepjQaRmZPPwg17mJ16rB/j+OR4Jvta1ZZIfW1eBM4SaBXvu9OWG0eY4YnL3oRfX/LdIWEOx7FhLj1SSM3KJTMnn7jIcN9aqu7NovoANrPC7NAeaNrG6oh8npKLIiL1UOOFzXfPmql1cWeaKXbiHdomgD3E9OQ5sNX05xERaxzaDTnrMf0Wh5DU5CSSRSKYZW4jEqNqd+E9+GbYtQqWv83RD67jzsP/JMMZXem06fMzGJEYpZ87CSybfjTb+LOsjaO+Bv/ZJBfTv4AD26BFx7Jv+UySbkeq6RMb2ozH10YybeGxKsyzerThb+d08+74fUGjZmbQ494NpuCg27lWR+TzlFwUEamnKi9sio6YDzYAp463ND45TnAjaNsTdq4yHyaUXBSxjqtqsV0iNGkFnGSySARzo69WPyc2G4x8ikPb1tB091JeCXmK0YX/Io/KlbGZOfn62ZPAklGaXOzi48nFdonQeRhsXgi/vQbn/gMwAxjL37jy6grl0iXRudFnMm3h1grf+nHdHn5ct8e74/cV0f1Lk4tpSi66gXouioi4gat/R9mFyKqP4EiuSVx1v8Da4KQy9V0U8Q5l/RYrLl2r9J4q4i7Boczv/xTbna3pYs/muZDnseOodJqW4ktA2b8V9m4Em90k5nyda7DL8reg6OiJBzB6m/VfA7Axovr/F14dv68oux5IszQMf6HkooiIuzmd8MtLZv+Um830OvEuUa4PE2riLGKpzcf6LYo0lOiOnfhz4SSOOEMZHrSCe4I/qPB9LcWXgOOqWuwwEBq3tDQUt+gxEpp3hMN7YfVM3xoWtme9GUhjC6JRwogaT/XK+H1J+/5mq+sBt1ByUUTE3bYsMR8KQprAgGusjkaq4rpTuVOViyKWyd8Le9LNficlF6XhJMVGMOzMc7i76BYAxgd/wX/iV/P0uH7MnjiUe7XUUAJAhQnprn6LXc62Nih3CQqGU240+7++RFzrJlWe1pAVyrWeSL+y9GZH13Pp2z2e8cnx1Z6qCut6al865HF/FhzeZ20sfkA9F0VE3O2X6Wbb93IztU68T7tEwAYHs81AiaZtrY5IJPC4+i22SYDwSGtjkYAzOSWB1MQ7WbfwKD02vMLVu56CyOEQe6rVoYl4XPn+gzYc/N70B5qA7w9zKW/An2DeFMheQZJtg6XDwmrd79HhgJUzzH6/K4BjfYj/+8MGfli7p+xUVVi7QVgLMx19X4apXvT1fqMWU3JRRKQadZoot38rrP3C7J96i+eCk/pp1BQiu5kptdkr1cRZxApbtCRarJUUGwFXPg4f7oB1X8IHV8FN30GrOKtDE/GY4/sP9rJtoUnxfkpCmhLUcZCFkblZeGvocxmkvQO/vsTkS1+3ZFhYdf0eq5xIv2UxHNgKjVpAj5Syw0mxEbx+3WDfmXbtS9r3K00upim5WE9aFi0iUoUpc9IZPW0Jk2asYPS0JUyZk167B/72KjgdEJcMbbWsyqtFlS6FUBNnEWu4+i1qSbRYyW6Hsa+Y3wmHc+C9y+HIfqujEvGY4/v0DbOvAmB3q0EQFGJFSJ5zaulgl98/gf1bLRkWdlL9HleULolOvARCGlf6toadeUB79WF3FyUXRUSOU+eJckVHzFQ6UNWiL1DfRRHrHN5netOCkotivdBwuOpDaBYNOevgoz9BSZHVUYl4xPF9+s4oTS4Wxw1v+GA8rX0/iDsTnCXw8zRLQqiuL2Kl44WHYc0nZr90SbQ0ANdQlx1pVkbhF5RcFBE5Tp0nyq36CI7kQstY6H6BByITt3I1cdadSpGGl/UT4ITW3aBZO6ujEYHm0XDVBxASDhnz4Ms7wem0OioRt0uKjSgbEhJGAafY1wEQM/BCK8PynNNvM9tlb1kytKP8f2+XKvslrvsKCg9By04Qc1oDRhjgXMUGuZmqWq8n9VwUETlOre8wlud0wi8vmf3BfwZ7kAciE7dyLYvO3Ww+TDRuaWEwIgFmyxKzVb9F8Sbt+8Glr8H7V5qVCJHdYOhfrY5KxO1cQ0Ly13xDo5+LoXkH8/Puj7qcA+16m2r5pa/BmXc3eAiu/9419ktc8b7Z9rvCtGuQhtGklSkM2Z8FO1dB3DCrI/JZ+qkVETlOre8wlrdhrvnQEtIEkv7o4QjFLZq0ghaxZn/nKmtjEQk0234z29gh1sYhcrweKTDiEbP/7YOw5jNr4xHxkKTYCLrlpwKwt90QsNksjshDbLZj1Yu/vGTaGFmgxn6JB3fCph/Mft/LGzYwKdd3Mc3SMHydkosiIlWYnJLA7IlDeXpcP2ZPHMq9KTUMZ3E64cf/mP1TboLGarLsM1xLo9V3UcTjUrNymbV8G2mZu471Nup4iqUxiVTptAnm9zlOmHkTZC60OiIRt5syJ53NK+aZ/TWtaj+80BcljoYWMZC/51iFoDdZ9ZEZCNlxMLTuYnU0gcfVd1GtkupFyUURkWrUeiLbujnmTldI+LE7o+IbNCFOpEFMmZPO6GlLmDRjBf94+QMoKTA3YlrFn/jBIg3NZoMLHoOeF5mf1fev1O8J8SupWbm8Nn89/WybAFjm6F674YW+KigEhtxq9pf8Fxwl1sZzPNeUaA1ysYaGuriFkosiIvXhcMCPpcunTr0FwiOtjUdOTllyUZWLIp6SmpXL9PkZZV8n2TcCcKB1f/9dhie+LygYxr4Gnc6AwoPwzljYu8nqqETcIjMnn0TbZsJsReQ6m5LhbF923G8NuNbc1NqXAWu/sDqaY3auMq2VgkJNhaU0PNf1wN6NUHDQ2lh8mJKLIiL1sfYL2LUKQpup6bsvcg11yVkHhYetjUXETx1/sepKLm4PT7QiHJHaCwmDK9+DqD5mOeX/RpveaCI+Li4ynIH29QAsc3QDbGXH/VZoOJxys9lfNLXCNHhX2w5LKjddVYvdLzD9wKXhNW1jhhrhVB/2elByUUSkrhwOmPeo2T9tgj4Q+KJmURDe1vS52b3G6mhE/NLxF6tJtg0AhHY+zYpwRE5OWAv44yyIiIP9W0wF45H9VkclUi9JsRFc1m4HAMscPYBaDC/0B4P/DMFhsGM5bF4EVGzbMXrakobtPVlSbPotAj81O89/l6X7AvVdrDclF0VE6mrNJyYh1agFDJlodTRSFzbbsaEumhAn4hHf/H6s0iuSA8Ta9+DERtekMy2MSuQkNG0L18yGpu3M8sX3r1S1u/g2p5OeRSaJdtrwlBMPL/QXTdtA/6vN/uJnK7XtABq292TGPDi0i33Oply7oEXDJzflGNfSaPVdrDMlF0VE6sJRAvOmmP0ht2pCtC9T30URjzn+wq1/6ZLooy27mYowER+Reqgl3w18keLQZpC1BN4bB4V+3J9O/Nv+LDiYDfZgkpPP9/+KxfKG3Ao2O2ycy95Ny6s8paF6T+5f9AoAn5UMpYhgoIGTm3JMdH+zVeVinSm5KCJSF6tnmT59YS3htPFWRyP14eq7qA8TIm53/AXaALtZEr2reR8rwhGpE9eyyZu+Ocq4g3dSYG8CmxfCe5crwSi+aeuvZhvVF0KbWBtLQ2vdBRL+AMDALa9WeUqD9J7c9Tstt3wNwHsl51T4ll8P1vFWrmID9WGvMyUXRUROVkkxzC+tWhz6V1Xf+DrXh4nda0jdvNu6ht4ifqhyv0VTuWiPOcWKcERO2vHVt8ud3bnyyD0UBYe7PcFo6VAJCSxbfzHb2ADtfZt8D9jsRGz+iv8bkFfhWw3We3L+4wB8WTKY9c6YCt/y68E63qpZFDSNMn3Yd622OhqfFGx1ACIiPmfVR7B3IzRuBafeYnU0Ul8RnU3fzIID3P/Sx6Q7OwEwPjmeyYHQf0jEg5JiIxifHM/0+RkEUUJf+yYAYvsmWxyZSPVSs3LJzMknLjK8ygqi5c7ujMu/h/ebPE7Y5oXw7ji4eoaZRltHU+akV0hi6neQeJQruRgz2No4rNIuEZKugeVv8cf9L5M44WMy9x4hLjK8YRKLu9NhzacA7Oz/N/jt2LcCYrCOt2rfDzbsNKuZAvXfRj0ouSgicjIKDsEP/2f2T78NGjWzNh6pP5uNgxEJNNv5M4n2zaSXmOTi9PkZjEiM0gc8kXqanJLAiMQo9m1aRvj8AmjUHNr0tDoskSodn+QbnRRd5Xmpzm5ccfheZjZ9gqAti+Ddy+CqGdCo6Um/ZnVDJfQ7SDyi4OCxyqyYU62NxUpn/x1Wz4Qdy0na/x1JAy5vuNde8ATghIRR3Dh2FANOOXZDQ//mLRTdHzZ8o6EudaRl0SIiJ2P+FMjbBi07weA/Wx2NuMnOJt0BSLRtrnBcPW9E3CMpNoJzmmWZLzoMALs+gor3qSrJNzt1R7UJxjRnVxac9rKpft+yGN4ZC4f3nfTrVve7Rr+DxCO2LzNLP1vEQvOqf7YDQtO2MGyS2f/+4Ybrs7dnnendDpB8L2B+R44Z0FGJRauVDXlcoTYVdaBPdiIitbVzNfw0zeyPfDLwGmD7sZCOSQAk2jdXOK6eNyJutG2p2XZUv0XxTtUl84Z1a8NjY6seQtSy2xC4drbpv7z1Z3gjBQ5sO6nXre53jX4HiUe4hrlo2SecdqtJsuZth5+eb5jXdFUt9rwIojTczKuUJhdLdq/himnzmDRjBaOnLWHKnHSLA/MNSi6KiNSGwwFf3AHOEjNhrvv5Zd/SnS3f17n3EMBULtpwAOp5I+J2rgtaJRfFS9WU5Lv8lFjGJ8dXOF72e6LDQLj+a2gWDXvWwqvnmZ5qteTqTVrlc4u4W9bPZhvIS6JdQsLg3H+Y/UXPQF62Z18vZ4NZig1mqIx4l+YdKAprTZCzhB62rWWHp8/P0HVeLajnoohIbaT+D7b9CqFN4YIpZYfVgN1PtO4GwY0JLz7CSyNb0qZzb13UibjT4X2wd4PZ7zDI2lhEqlF+AJFL+SSfq39olb3R2vWCm+bC/8ZAzjp4fQRc+QF0Glqr167xuUXcxeGAbaXTQ2KVXASg91j4Zbr57/LD/8ElL3jutRY8YZak9xh5bAmueA+bjX3NetLu6GL62DNZWdKl7FuZOfl6Xz4BVS6KiJzAqnUbKfz67+aLs+6HFh2A6huw686WDwoKNpMDgfMjdunDg4i7bV9utq3iIby1tbGI1GBySgKzJw7l6XH9mD1xKPced8Owxt5oLTrCDV9DzGlw9AC8fQmkf17r11bfNfG4PWuhIA9CwqFtotXReAebDUY8avbT3jWTgj0hZyOs+sjsl1YtavWT93G27w9Aoi2zwnG1qTgxJRdFRGowZU466965g9CiPNY4OvFY7pll31MDdj9TromziLiZq1Kmo3p8iferV5KvSSu49hPocSGUFMCMa+HnF8HpdHucIidt6y9m23GgubEqRswp0PtSwAnfPOCZf68LnzRVi90vgOgkpsxJZ/S0Jerr52WiepqK3j72Y8lFtamoHSUXRUSqkZqVS+qCL7k0aAEOp40Him7gxQVZZXcX1YDdz5QlF9MsDUPEL5UlF7UkWgJASGMY9zYMvN4kE76eDJ/9FYoLrI5MAp0ruRhzmrVxeKNz/wHBYbB5obkh4E47V8PKGWY/+V6tfvJm0aVDHoO3M3VsQpUV7FI1JRdFRKqxeXcu/xfyOgDvl5xNqrMbcKwyUQ3Y/Uzphwl2rFCFiYg7ORywXZOiJcAEBcNFz8CIR8BmN72b374YDu2xOjIJZGXJRfVbrKRlLJzzkNn/9gFY/617njc/Bz640gyF7HEhdBhQ7Sqn577f4J7XlLprEQNNWmN3FHFJ9H5d150EJRdFRKoxdMtLdLNvJ8fZnMeKLy87Xr4y8US9mcSHtE2AoEZQcAD2ZZz4fBGpnb0bTf+54MZlvU1F/EWNPdNsNhhyK1z1ETRqAVk/wStnwc5VDR+oyKE9xz7fqIq8aqdNhAHXmorjj2+AXb/X7/mKC01rhP1ZHGoSw8qB/wdUv8rpx3V7VL1oNZutXMFBqrWx+BglF0VEqrLua9qtmg7A34tuII+mQNWViWrA7ieCQiCqj9nXhwkR99n2q9lGJ5l/ZyJ+otY907qdCzd/D626wIGt8Nr5sOYzDXOQhuWqWmyTAI1bWhqK17LZYORT0HkYFB6E966AQ7vr9lxOJ3w5CbYsJs/ZmItz/8YfXk9nypx0kmIjOLtnmyofpt7tXkDJxTpRclFE5Hj7s2D2LWZ/8C3cMv52VSYGig4DzNY12VZE6k/9FsUPnXTPtMhuJsEYfxYUHYYZ17Dg5UncOSNVwxykYbiSi7FaEl2j4FDTM7VVFziQBR9cBUVHT/55fn4RUv9HidPG34r+yiZnB+DY+8Rfz+5W5cPUu90LlCUX0ywNw9couSgiUl5xIXx0PRzdD9ED4Px/qzIxkOhOpYj7bSvttxijSdHiP6qrLqqx6qhxBFz9MbsTbwTgtuBZvBzyNM04rGEO4nlbS6vI1W/xxJq0gqtmQFhLc4Ps01tPrh/3hu9M30bgkeKrmefoX+HbmTn56t3uzVzXA7vXQOFha2PxIUouioiU990/zOCBsBZw2ZsQ3MjqiKQhRZdWLmavAEeJtbEEGC0P9FMFB82Hc4AOqlwU/1FdddEJq46CglnUZRJ3FE6gwBnCeUHL+ST0QbrYtms5pHhOccGxG6dKLtZOZFdTwWgPhtUfmyXOtRnItGcdfGwmxed0v5zXSlIqneJ6n1Dvdi/VrD00bWeG8OxabXU0PkPJRRERlzWfwc/TzP4l0yGik7XxSMOL7AYh4VCUDznrrY4mYNzxYWrt+paJ79mRZhrjN+8IzdtbHY2I29Sn6iguMpzZjmFcWvgPdjhb0cWezSehD9Hv8E+eClcC3a7VUFIAjVtBq/gTny9GfDJc+LTZX/o6TO0Nn98OezdVPK+k2FQrzrwJXh4OBXkQO5TIcc8zPrlLhVOPf5/QCikvpKEudRJsdQAiIl5hXwZ8+hezP/Rv0HOktfGINexBEN0ftiw2Hyba6g6yp93xYSqzU3dUODZ9fgYjEqP0QdsfuD6Ud0iyNg4RD5icksCIxCgyc/KJiwyv9XuWKzE5fT6MKvgP00Kf5VT7Wpp9dxMUZ8CZd4NdNSDiRq5e0h0GmMSJ1N7AP0F4G1j4JGxfBsvegGVvQsJF0PcK2LzIVDbml6tqbN8PLv8fBIfW+X1CrJOalcvRIzEMAfZu+JnWp95idUg+QclFEfFKqVm5DfdLuOAgzPgTFBwwS0XOecizryfeLTrJJBe3L4f+V1kdjV9LzcqtlFh0cfUjEh/nSi6Wthxo0Pd2kQaQFBtRp5/l8gmH0Fbnwpon4NeXYd4jsHMlXPIihDX3QMQSkFyDKVztX+Tk9BwJPVJgyxJY8hys/xrSPzd/XJpEQu+x0PfySkncur5PSMObMied6fMzOMvekiGhsHf9L7wyJ53JWrJ+QkouiojXcb2pu4xPjvfcG3rRUTMFbudKaNIaLn0DgkI881riG7QMosHU1F9M0xL9RFlyMalh39tFfECFhEPnJ0y10xd3wNov4NUNcMV7pu+bSH3tKK1cjFYVeZ3ZbND5dPNn91pY8l/IXGCGlfW9HLqcpWsIH5ealVv2OWW1Iw6ArrYdvD1/jVbU1ILq7UXEq5R/U3fx2ATFkmKYeaP5YBDaFK7+GFp0cP/riG9xffDeucpMDxePqS6BOCYpWh/g/MGRXMjNBGClI67h3ttFfFXSH+H6OWaYQM46eOVsWP+t1VGJj1uxaTvO3WvNF0ouukfbnnDJC3DHKrj0Neh+vhKLfqD8Te89tGSHsxV2m5NE22YN3KoFJRdFxKtU98bt9jd0pxM+v81UBwQ1givfN0sYRFrFm2nhJQWwR4NFPKmqgQhjkqJ5+nJd/PgF1zK8iDg2Hqx6sYw+rIsck5qVy6zdUay68FPTpqXgAM73xvH7Bw+RumXfyT/X8m1K4Ae4KXPS+ferH2DDwU5nBFMW77c6JBGvdfxN71UO8xm1rz1DK2pqQcuiRcSrVPfG7dY3dKcTvv07pL0DNjtc+jrEnem+5xff5poQlzHPLOls38/qiPyaGp37sXJLohvkvV3EB1TXd/T4tgEThz3JuQVPM2D3bBLXPstHq1P5dugj3DuyzwlfQy0IBI6tBrohyFSQr3LEa2CaSA2ODdsy758rHfGMCFrKmKjdJJb7N6P+0VVrkMrFadOmERcXR1hYGAMHDmThwoU1nj9//nwGDhxIWFgY8fHxTJ8+vSHCFBEvUFUl04TkePe+cS96Gn563uz/4Xkz7a0eVB3gh1zLhlzTFcWjkmIjGDOgoz6g+ZtyycUGeW8X8XJT5qQzetoSJs1YwehpS5gyx1THV9USZtrCrYzJuoz7i26k2GnnsuAFDPzpr6RlVD0Ey6VB28uIV3NVhvexm5+HFaVVWKoYrzt95vd/k1MSmD1xKLed05X4fmcAkOjcVPb96t7HpQEqFz/88ENuv/12pk2bxumnn85LL71ESkoKa9asITY2ttL5mZmZjBw5kptvvpl33nmHxYsXM3HiRNq0acPYsWM9Ha6IeAGPVjL98hJ8/y+zf/5/IOnqej2dqgP8lGuaooa6NAjdAfZTZdNJTbJeVaoSyKpL+o1IjGLeut3VPu69knPY5WzJCyHPcW5QKns/vxJung1NWlV5fk3tZfRvLrC4KsP72szP3SpnfIXjcnL0mT9wlA3bOtwG1vwN9m2CI/tJ3eOs9n1c768NULn49NNPc+ONN3LTTTeRkJDA1KlTiYmJ4cUXX6zy/OnTpxMbG8vUqVNJSEjgpptu4oYbbuDJJ5/0dKgi4kXcXsnkdMIP/4E595ivh90JQ/9Sr6dUdYAfc1Uu7l5jJoqLx+gOsJ/Kz4EDWWa/XGsBValKoKou6ffc9xt49vuNNT72e8dA/lh4HwecTWidmwZvjIQD26s8Vy0IxCUpNoLbTm9LF3s2YAZrqWK8bvSZP0A1aQUtO5n97BUNNxvAR3k0uVhYWMiyZcs4//zzKxw///zzWbJkSZWP+emnnyqdP2LECJYuXUpRUVGl8wsKCsjLy6vwR0SkAkcJfHE7LHjcfD38fjj7wXo/rX7B+LEWHSG8DTiKYddqq6PxW/qw7sdcVb+tu0FYc2tjEfEC1SX3fly3p8rjE5LjK7QSWOrsycd9XzGTpPekw+sjYM/6So9TCwIp747EwwDkN+nA6xMv4F5V2tWJPvMHMFfBwY5U3bw5AY8ui87JyaGkpIR27dpVON6uXTt27txZ5WN27txZ5fnFxcXk5OTQvn37Ct979NFHefjhh90buIj4j6KjMOsmSP8csMGFT8EpN7rlqfULxo+5hrps+Nb0Xew4yOqI/JKW7/mxcv0WRaTyoACAs3u24Ye1lZOLt53TlTvO6wFQuZXA/r7wv9GwdyO8cQFc/zW06V7h8WpBIGVK34vDO5+in4N60Gf+ABadBGs+gR2pJJ1xe6X3cd28OaZBpkXbbLYKXzudzkrHTnR+VccB7rvvPiZNmlT2dV5eHjExMfUJV0T8xdED8P5VsGURBIXC2Feh18Vue/qqLhT0C8aPuJKL6rvoMfqw7seUXBSp5PikH1BlcnF4j7Zl+2W9v1xaxsIN38A7YyB7BfzvEvN1y4rXP5UeJ4FpR+lgOr0X14s+8wewcpWLoJs3NfFocjEyMpKgoKBKVYq7d++uVJ3oEhUVVeX5wcHBtG7dutL5jRo1olGjRu4LWkT8w4Ht8P7lsHMVhDaDK9+DuDPd/jL6BePHNNTF4/Rh3Y8puShSpeOTfnV6DwyPhD/ONpWLOetNJeMNX5vjIuXpvdht9Jk/QLn6Ru/fAof3QZNWunlTDY8mF0NDQxk4cCBz585l9OjRZcfnzp3LxRdXXT00ZMgQPv/88wrHvv32WwYNGkRISIgnwxURf7FlCcy4FvL3QHhb+OPHFQYKuJt+wfgp1wfxnHVQcAgaNbU2Hj+lD+t+KC8bDmaDzQ7t+1odjYhXq/N7YHhruGY2vDYC9m4wlYx/+kI9TuWY/BzYXzpYK7q/paH4C33mD0CNW0KrLmZi9I5U6HqO1RF5LY9Pi540aRKvvvoqr7/+Ounp6dxxxx1kZWUxfvx4wCxrvvbaa8vOHz9+PFu2bGHSpEmkp6fz+uuv89prr3HXXXd5OlQR8XVOJ/z2Krw1yiQW2/WBm+Z6NLEofqxZO2jeAZwO2LnS6mj8miYI+5nsNLNt0xNCtcRd5ETq/B7YoiNc+wk0iTRLpD+4yvSaFgHYkWa2rbuSutvBrOXbNDBNpC6OWxotVfN4z8XLL7+cvXv38q9//Yvs7Gx69+7NV199RadOZqR3dnY2WVlZZefHxcXx1Vdfcccdd/DCCy8QHR3Nc889x9ixYz0dqoj4suIC+PJOSP2f+TpxDFz8vC5spX6ikyBvuxnq0mmo1dGI+AYtwxNpOJHd4I8z4c2LYPNC+Ph6GPc/CGqQ1vrizUrfi1fThdHTlpQdHp8cz2RNjRapvegkWP2xkosn0CC/dSZOnMjEiROr/N6bb75Z6VhycjLLly/3cFQi4jfysmHGNbDtN7MM79x/wtC/mYm/IvURnQRrv9CHCXcpKYLVMyH1HWjUDPpcBj1SIKSx1ZGJOym5KNKwovvDVR/A/8bAuq9gzt1w0TNWRyVWKx3mMmtn2wqHp8/PYERilFYLiNSWKhdrRbe0RMS3Zf1iEouHdkFYS7j0dfXCEPcp+zChG171cjQPlr8FP79oKkFd1n1lBi71uhj6joPOw8Du8Y4t4klOp5KLIlbofAZc9qZZGr30dYgdYt5XJXCVvhevcMRX+lZmTr6SiyK11b4vYDOfYQ/uMq2TpBJ9ghcR37XsTXjzQpNYbNsL/vyjEoviXq7kyL4MOKI+RSft0B6Y+xA8kwjf/t18KGvaDs7+Owy7E1rEQuFBSHsH3v4DTO0DmxdZHbXUR9520/PWHgztEq2ORiSw9BwJyfeY/c9vhz3rLA1HLFQ6WMtps7PG2anSt+Mi1TZIpNYaNYPI7mbf1VdaKlFyUUR8T3Gh+dD8+W3gKDJVTzfOhVaV78yK1EuTVhDR2ey7GqNL7RzaA6+eDYufhYI886HsD/+F21fBmXfDOQ/BbSvg+jkw8DoIawF52+CDq2HvJqujl7pyVS22TdBydxErJN8LcWdCUT7M+BMU5lsdkVih9L3Y1qYnf0ruVeFbE5LjVbUocrI6DDDb7VrNVB0tixYR33JwF8y4Frb+DNjgnAfhjEnqryie02Eg5G6GbUuhy1lWR+Mbio7Ch1fD/ixo2QlSHoNuIyovebbbzaCcTkNhxKOmenHbb/De5XDTd9C4pSXhSz1oSbSItexBMPY1mH4G7EmHL++C0S9aHZU0NFc7l+gBTE5JYERiFJk5+cRFhiuxKFIXHQbCivdh+1KrI/FaqlwUEd+xbRm8nGwSi41awNUfmaWVSiyKJ8WcZrZbf7Y2Dl/hdMJnf4Wtv5hqxKs/JrXxacxK20FqVg1Ly0ObwOXvQvMOsHeDmXhaUtxwcYt7KLkoYr2mbU0PapsdVrxnhmhJYCl7L+4PQFJsBGMGdFRiUaSuOg4y221LweGwNhYvpeSiiPiGlTPgjRQ4mA2RPUx/xW7nWR2VBIKYwWa79Td9mKiNhU/CqhlgC4JxbzNlaQmjpy1h0owVjJ62hClz0qt/bLN2cOX7ENIENv1g+jSK79AwFxHv0fkM098W4Ms7Yedqa+ORhlP+vdi1lFNE6qddbwgOg6P7Ye9Gq6PxSkouioh3c5TA3H/ArJuhpAC6p5jlkq27WB2ZBIp2vSEkHAoOQI6a49fo99nww/+Z/QufIjW4H9PnZ1Q4Zfr8jJorGNv3g9HTzf4vL5rBTeIbcjebwUdBoWbIlohY6/Q7oOt5UHwUPvoTFBy0OiJpCPuz4PBesIeYzzAiUn9BIcdunG77zdpYvJSSiyLivY7mwQdXweKp5uszJsEV70FYc0vDkgATFAwdB5r9LC2Nrtb2ZTB7vNk/bSIMup7MnKoHCVR3vEyvi+GsB8z+l3dqgrSvcFXKtEuE4EbWxiIipq/t6JdK201shB8fsToiaQh6LxbxjI6nmK2Si1VSclFEvNLvq1dw4IWzYP3XpgR9zKtw7j8qD4QQaQgxp5rt1l+tjcNbHdgO719pqmO6jYDzTfViXGR4ladXd7yCM++G3mPBUQwfXgP5e90ZsXiClkSLeJ/w1vCH/5r9X6ZD9gpr4xHPKxvmovdiEbcqSy5qqEtVdJUuIl7n7RkzaP/RSFoc3MguZ0ve7DEN+l5mdVgSyMqSi79YG4e3+noyHNoFbRPh0tfMtFJMA/nxyfEVTp2QHF+7hvI2G1z8gllee2Qf/PS8JyIXdypLLqrHl4hX6XoOJI4BpwO+uMO0nBH/pRs9Ip7hSi7u/h0KDlkbixdSclFEvMqmRR9x2e+30sp2iBWOeEYV/Id/LguruUebiKe5JsTt2wSH9lgbi7fZsgTSPzNTSce+Co2aVfj25JQEZk8cytPj+jF74lDuTUmo/XOHND42kODXl+HwPjcGLm7lcByriCqdTioiXmTEIxDazLSwUC9b/+V06r1YxFOat4fmHc2NGlcSX8oouSgi3mPZW8R/92ca2wr5oaQ/VxT+nd2YCqcT9mgT8aTGEdCmNCm2LbCXRqdm5TJr+TaT8Hc44Ov7zDcG/AnaVT3EIyk2gjEDOtauYvF4PUZCuz5QeAh+eqHqOMR6uZlQkAdBjaBNT6ujEZHjNW8P5zxo9r9/GA7ttjYe8Yz9WXD0gBnm0uYkbuaJSO24Cg7Ud7GSYKsDEBHB6YQFT8CP/8EGzChO5v7iGyku9xZVqx5tIp4UMxj2pJul0T0vtDoaS0yZk15h+vN/e61jVHaaqYY5637PvKjNBsn3wIxr4JeXYMitTJm/q0Ic45PjmXwyFZHifq5KmXaJZqKiiHifU26CtPcgOw2+/TuMednqiMTdXO/FbRMgONTaWET8UcdTYM0n6rtYBVUuioi1HCXw5ST48T/m62F3kTF0SoXEYq17tIl4UoAPdUnNyq2Q0GvMUQZtKh0ScOad0LSt516850Wmn2PhQbK/faZCHADT52eogtFq2Wlmq2V4It7LHgQXPQPYYOWHkDHf6ojE3XauNNv2/ayNQ8RflQ11+dUUyEgZVS76oNSsXDJz8omLDFfCRXxbSRF8fIPp14YNRj4Bg29mMjCid3v9nIt3iT3NbLcvh+ICCG5kbTwN7PjWBDcHfUV72z7ym3Qg/NQJnn1xu91UL370JyJXv05zepNH00rx6b3CQq5qGV3Qingtcw3RlmEJ19Am/W1zc3fCkoD7febX9F4s4lnt+5m2A/l7YP8WiOhsdUReQ8lFH3P8kjQtBROfVVwIH18Pa7+AoFAzCKLXxWXfToqNUKJAvEureGjSGg7vheyVEHOK1RE1qPKtCdqxj/HBnwOwe/B9xIWEeT6AhD9A216E7F7DDcFfM7X40mrjkwZWfoCALmhFvFL5a4jmDGNJsy9ouncjLH4Oku+2ODpxm2xVLop4VEgYtO9rhmNtW6rkYjlaFu1Djl+SBloKJj6quBA+uq40sdgIrni/QmJRxCvZbOWWRv9ibSwWSIqNYHxyPAB3Bc+gia2AbU37EJf8x4YJwG6HM80F8PhG39KcY5WUap1gsf1ZcCTX3MlvW/VQHxGxzvHXEHmEc3/+VeaLhU/CwZ0WRSZudXAXHNoJ2Ez/WxHxjLKl0RrqUp6Siz6kumm5mqIrPsWVWFz3pUksXvkedDvX6qhEaidmsNlu/dnaOCwyOSWBr8c159LghQB0vOJZk3RtKL0ugTY9CSs5xDdD1vD0uH7MnjiUe1XBb60KAwS0vFLE21R1rfCZYwh7I/pB8VFYNLXhgxL3c/VbjOwOoarmF/EYJRerpOSiD6luyZeWgonPKC6Ej/5UMbHYVYlF8SExpX0XtwZWE+fUrFxmLd9G6pZ99FwxBRtO6DMOOg5s2EDKVS+2T3+dMb2aqWLRG2iYi4hXq/pawUbu4LvM7tLXIW9Hg8YkHuB6L27f19IwRPxex0Fmm70Sio5aG4sXUXLRh5RfkuaipWDiM4oLYMa1sO4rCA6DK99XYlF8T3R/s/Tz0C7TxDkATJmTzuhpS5g0YwWPv/QqbFlk/g2f85A1ASWONlUZRw/ALy9bE4NUpH6LIl6tumuIrqeNgtghUFIAC5+u9LiyG0tqweQb1G9RpGG07AThbcBRdKxiWDTQxddMTklgRGKUpuiKb3GUwKybYf2c0sTiB9DlLKujEjl5IY3Nh/btSyHrF79v4nx8n67xQWaIy55ul9OmZYw1QdmDTPXirJth6WswbJI5JtZwOmFHmtlvn2RpKCJSvWqvIc66H94aBcvfgtNvg9L3dg2R9EGuGz1RqlwU8SibzSyNXveVWc3kapsU4FS56IOSYiMYM6CjEoviG5xO+PJOWPOpmQp95fs1JhZ1l1y8XqxrabT/D3Up36crwbaF5KCVlDhtLIu+ysKoMAOgGkfAwWzInG9tLIEubwcczgFbELTTMBcRb1blNUTcmdB5GJQUwsKnAA2R9ElHco+tqNCyaBHPU9/FSpRcFJE6q1Ui8MdHYNkbgA3GvAJdzq721PLLL0dPW8KUOenuD1qkvsqGuvxqbRwNoHyfrj8HfwHAl47TaNeph1UhGcGNoPdYs7/iA2tjCVCu9/+MlYvMgbYJprJXRHzP8PvMNvV/kLtFQyR90c5VZtsy1tx8ExHPKksuLrU2Di+i5KKI1EmtEoG/vAQLHjf7Fz4FiZdU+3y6Sy4+o2NpcnH373A0z9pYPMzVp6sDexhl/wmAff1u8Y7K+X5Xmm3651Bw0NpYAkz59//Pv/naHFSPLxHf1fl0iB8OjmJY8ISGSPoi9VsUaVjRSWCzQ942DcQqpeSiiJy0WiUCV30Mc+4x+2c9AKfcWONz6i65+Izm7U1lgNNhei/6uckpCcwekEawzUFe9Blcd+loq0MyOgyEVl2g6LBJMEqDOP79v7ctE4CtYd2tCklE3GH4/Wab9h5JTXM1RNLXlPVbVHJRpEE0agptE82+qhcBJRdFpA5OmAjc8B3MvsXsD77FDF84Ad0lF58S4+q76P9Lozm8j7YbPgSg+Tl3WhxMOTbbsepFLY1uMMe///e2m+TipuAuVoQjIu4Seyp0PRecJTD/CXNjaeJQnh7Xj9kTh3Kvhrl4t52qXBRpcB0Hma36LgJKLopIHdSYCNyRBjOuMUtrel8KF0wxSYATcC2/LE93ycVrlfVd9P+hLvz2mqkOjOoL8V425b3vOLPNXAAHtlkbS4Ao//7fhlza2fZT4rQRETfAwqhEpDZO2CvbVb248gPI2aghkr6i8DDkrDf7GuYi0nDUd7ECJRd9ze50+PQv8OVdVkciAazaRGDLI/D+FSYREX8WXPIi2Gv/NqO75OIzYk41262/QUmxtbF4UtER+GW62T/9tlrdKGhQEZ2g0xmAE1bOsDqagFD+/b+3fTMAuU06069LBwujEpETqVWv7I4DofsFpu3HomcaPkipm12/m/9nTdtBsyiroxEJHK7k4o5UKCmyNhYvoOSiryk8bCa5rfoIHA6ro5EAVikReHYMvHc5HMyGNj1h3FsQHHrSz6u75OIT2iVCWEsoPAjbl1kdjeekvQuHc0yPyV6XWB1N1fpdYbYrPgCn09pYAoTr/f/uPocBiOx2qsURiUhNTmpo3rDS9herPoL8nAaITuotO81so1S1KNKgWneFsBZQfAR2rbY6Gsspuehr2veD0KZwdL+ZVCpiobJEYMfmMOtm0+8lvA1cNcO80Yr4K3uQmawJkPGjpaF4jKMElvzX7A/5KwQFWxtPdXpdDMFhkLPO3DkudcLlf1IvSbER9GKz+UI9vkS82kkNzet4ipmCWlIAy970bGDiHuq3KGINux3OfhBGvwwtO1kdjeWUXPQ1QcHHluNtXlx2WBdRYqm5D8G6ryCoEVzxvlmqKOLvupT2H9zkp8nF9M8gdzM0bgVJV1sdTfXCmkPPC83+SjN4plbL/6T+XNUy0f2tjEJETuCkhubZbHDqeLP/22ta6ucLXJOi1W9RpOENvhn6XQ5NWlkdieWUXPRFnU832y2LAF1EicV+ew1+et7sj34RYk6xNh6RhuIabrLtNziaZ20snrCk9N/14D9DqJdPbXdNjV71Eambd9d++Z/U3aE9kLfd7Ef1sTYWEanRSQ/NSxxtVqIc3AHpnzdAhFJnxYWmJz+oclFELKXkoi/qdIbZbl5M6pa9uogS62z8Hr662+yf/XfoPdbaeEQaUkQnaBUPzhLYvMjqaNxr2zLYvhSCQuGUm6yO5sTiz4LwtnB4L0fWfFPlKdUtC5Q62llaKdO6KzRqZm0sInJCJzU0L7gRDLze7P/6csMEKHWzZy2UFJp2RFqWKSIWUnLRF0UnQXBjOLKPvZkrqzxFF1HicTkb4aPrTWKl35UwTBPMJQC5qhf9re/iry+Zbe+x0LSNtbHURlAw9B0HQMLur6o8pbplgVJHO9LMtn1/K6MQkZNwUkPzBt0A9mDI+unYv3fxPq5+i1F9zZJ2ERGLKLnoi4JDIWYwAD2OVp1c1EWUeNTRA/D+FVBwwPQAHfWsPtBIYPLHvouHdsPqWWZ/8J+tjeVk9L0cgIit33Hb6ZEVvlXj8j+pm7IeX1qGJ+KXmreHXpeYfVUvei+9F4uIl1By0Vd1HgZATN7yk+uhIlJfjhKYeRPs3QDNO8Dl75jlMyKBqPMwsNnNv4cD26yOxj2WvQmOIjMxtMMAq6Opvag+0DYRSgq5I3pt7Zf/Sd1omIuI/3MNdln1kemzKt4nW5OiRcQ7BFsdgNRR2VCXxUy+qycjEqPIzMknLjJciUXxrO//BRu+heAwuOJdaNrW6ohErNO4JXQYaIa6bPoRBlxjdUT1U1JkhjTBsYtKX2GzQe/R8MPvsO4rkgb+Sb8PPeXwPtifZfajNJ1UxG91HATRA2DHclj+Jpx5t9URSXmOEti5yuzrvVhELKbKRV/VYaBJ7uTvgZwNJ9dDRaSuVn4Ei6ea/YtfMP0/y0nNymXW8m0aKCSBxZ/6Lq75FA7thKbtIOEPVkdz8nqMNNuMeVB42NJQ/JprGV5EnEmwi4h/stng1FvM/m+vmxtQ4j32ZUBRvunFH9nN6mhEJMApueirghuZJWsAW/xsSql4p+3L4bO/mP0z7oA+l1b49pQ56YyetoRJM1YwetoSpsxJtyBIEQu4+i5mzAOHw9JQ6s3VV2vQDaa/r69p2wtaxELxUfP/QzxDPb5EAkfiaAhvAwd3QPrnVkcj5bnei6N6gz3I2lhEJOApuejLOpUujd682No4xP8d3AkfXG0u2LuNgLMfrPDt1Kxcps/PqHBs+vwMVTBKYOh4CoQ2hcN7j01t9EU70mDrLzjsIXwZOsI3//3abNAjxeyvq3pqtLiB+i2KBI7gRuaGE8AvL1kbi1SkGz0i4kWUXPRlrr6LmxeB02ltLOK/igvgw2vMHevI7jD2lUp3RzNz8qt8aHXHRfxKUAh0PsPs+/LS6NKqxc+KTuHWz3b4bgWyK7m4/hvfryT1VrqgFQksg24AezBs/fnYv3+xXlnlovotioj1lFz0ZR1PgaBQ0x9rX8aJzxc5WU4nfDEJtv0KYS3gyg/M9jhxkeFVPry64yJ+x9V3cZOPJhfzc3Cs+giAN4svKDvskxXInU6HRs0hf7cZQiDudfTAsc8c7ftbGoqINJBmUdDzIrOf9p61sYjhdB5bLaEbPSLiBZRc9GUhjaHDILO/WX0XxQN+mQ5p74DNDpe+Aa27VHlaUmwE45PjKxybkByvAUMSOFx9F7N+hqIj1sZSF8vexF5SSJojnjRn1wrf8rkK5OBQ6HqO2dfSaPfLLr2YbRELTVpZG4uIeJxrWN+mDhebA6s+guJCa4MSOLAVjuSaitK2CVZHIyJCsNUBSD11Ph2ylsCWxTDwT1ZHI/5k04//396dx0dVnv0f/0xWkgAhEMgiBBIEwk4A2VyCqEAEF1ARFwptf1Thsdb62Ir1sQ8+rZW21rbWKtpqse4LRKssapXNsoiQsIZFEgh7CIYkBMg25/fHyQwMWciETM4s3/frldc5OXPPzBU4OZm55r6vCz593Ny/4Vfn3qzXY05Gb8b1jSevsIzk2CglFiWwxPaEtpdBySHYv+aivy9epboKvnkVgNeqxtW62SdnIPfMgO2ZsGsZXPdLq6PxL856i5opI+Lv5i3NcdbUDiaEzW060Pr0CdjzGfSeaHF0Ac7xQU+n3mZdTBERi2nmoq87v6mL6i5KczmxF96fAUY1DLwLRv5Xo+6WlhTD5MGdlViUwGOznVsa7Wt1F3d+YiZFozqSeOVdLjf57AzkHjeALRgKtkPRPquj8S+qtygSEC5s1ldNMG+eGWF+s/lti6ISJ2e9RV2LRcQ7KLno67oMM6fDlxyEk/utjkb8wdkSeOduOHvSXHY/8U9m4kREGuZYGr13haVhXIxjiZuzluK6F83tkO/zswkDyZw9imenmNtHM3x0qVVke0gaae7vWmZtLP7mcLa5TUizNAwR8ay6SmIsrL7G3Nm9DMoKWzgicaF6iyLiZbQs2teFRUHiYLPhxr7/QEw3qyMSX2avhsz74PhOaB0Pd74Boa2sjkrENySnm9tjW+FUAbTuZG08dTh/iRvA3CFnmXFgHQSFwhU/BMwZyD45W/FCvcbD/q9g91IYcT9gJlZVuuESlJfCiW/N/QR1JxXxZ3WVxNhtdOF0h/5EntgKWz9wXlvFAs5Z5LoWi4h30MxFf9CtZmn0/v9YG4f4vn/PNRsgBIfD1LegbYLVEYn4jtYdIb6/uZ+70tpY6nDhEjeA6C2vmDv9bjO7gfqTXjea231fwdli5i3NYdILa3j4vc1MemEN85bmWBufLzq6FTCgTaJXJs9FpPnU16wvctj3zG+y37QgKgHMDzBLjwA2iOtndTQiIoCHk4tFRUVMmzaN6OhooqOjmTZtGidPnmzwPjNmzMBms7l8jRgxwpNh+r5uV5nbfautjUN826Z/wprnzP1b/gqdh1gbj4gvctRd3POptXHU4cIlbp0oYmLQOvMbf5x90qE7dOgB9iry1n1UK7E6f2XuuaXh0jiOmTKJgywNQ0RaxpyM3rVLZfS/3ZztfnQLHN1mdYiBydHMpcPlEN7a2lhERGp4NLl49913k52dzbJly1i2bBnZ2dlMmzbtovcbP348R44ccX4tWbLEk2H6vi7DzcL1J/Ph5AGroxFflLcaPvmpuZ/+KAy4w9p4RHxV75vM7c4lUHHa2lgucOESt2khnxNqq+ZU3DBI9NP6eb0yAAiuJ9lbV00xaYCz3qJqfIkEilrN+iLbm2UnQI1drHJUjbVExPt4LLmYk5PDsmXL+Pvf/87IkSMZOXIkf/vb3/jkk0/YtWtXg/cNDw8nPj7e+dW+fXtPhekfwtucm0WgpdHirsJv4d17wV5lLo0c/ZjVEYn4rs5XQLskqCwzC957kfOXuIVTwT3B/wagdfqPrQzLs2qWRiceX0UIVbVurqummDTAWeNrkKVhiIjFBt1jbre8B9WV1sYSiFRvUUS8kMeSi2vXriU6Oprhw4c7j40YMYLo6GjWrFnT4H1XrFhBp06d6NmzJzNnzqSgoKDeseXl5ZSUlLh8BaRuV5vbvcutjUN8y+nv4K0p5zpD3/JXdYYWuRQ2m5mkB9i2sFF3qdW92YMcS9zeGp5Pe9spMxGaOsHjz2uZLsMgoj0hFSX8X1qpy02z0lPU1MUdFaehsObDYc2WEQlsl18PkbFQVgDffmF1NIHniDpFi4j38Vhy8ejRo3TqVLvYd6dOnTh69Gi998vIyODNN9/kyy+/5A9/+AMbNmxgzJgxlJeX1zn+6aefdtZ0jI6OpkuXLs32M/iUHjeY228/B7vd2ljEN1RVwHvfg+/2QnQXuOttCI2wOioR39fvdnO75zM4c7LBoVY0GUnr0o4hR94xvxl2HwQFe/w5LRMUDD3HAXB3u5zatcOk8Y5tA8MOrePU7Esk0AWHwoA7zf3Nb1kbS6A5WwxFeeZ+vGYuioj3cDu5OHfu3FoNVy78+uabbwCw1TEDyjCMOo873HnnnUyYMIF+/fpx0003sXTpUnbv3s3ixYvrHP/YY49RXFzs/DpwIEBrDnYZDuHRcPoEHN5kdTTi7QwDPnnIbAIU1hrufledP0WaQVZ+EYsORXOmXQ+oroCdnzQ41pImI3kroWAHhEZB2r2efS5vUFN3kV1LSOvSzrV2mDTeEdX4EpHzDLrb3O5aaq6EkZZxdKu5jU4y61+KiHiJEHfv8MADDzB16tQGx3Tr1o0tW7Zw7NixWrcdP36cuLi4Rj9fQkICXbt2Zc+ePXXeHh4eTnh4eKMfz28Fh0L3a2HHh+Zsmc5DrY5IvFBWfhF5hWVcmfcccVvfNBsB3f4qxPW1OjQRnzdvaY4zWZgbPIhHQvfA1g/qTeDV10xkxa4Czya/1r1obtPugYh2nnseb9F9jNnZ9LtcOLEXYi+3OiLf5GzmMsjKKETEIo7XkMmxUebfqPh+EN/fTHZtWwjDZlodYmBQvUUR8VJuJxdjY2OJjY296LiRI0dSXFzM119/zbBhwwBYv349xcXFjBo1qtHPd+LECQ4cOEBCgpbgXFSPsWZycfencO0vrI4m4DhedFVW2wkNDjr34stLOBIfM4M/YXJozRKWm59zLhkUkaa7cBbix/aRPML7GHkrsZ0qqHNmcH3NRP78xbeUV9mZ44lluyf2nms0M/z+5n98bxTeBpJGmDO1c5crudhUmrkoErDO//AM4P70FPNv1KB7YNkcs2u0kostQ/UWRcRLeazmYu/evRk/fjwzZ85k3bp1rFu3jpkzZzJx4kR69erlHJeamkpmZiYAp06d4pFHHmHt2rXs27ePFStWcNNNNxEbG8ukSZM8Far/uPx6c3skG0qPtWiTgEB3ft20RxdubdH6aY3hSHzcFrSKx2sSi09X3kVWBz9u5CDSgi6chbjfiCfbnoLNsMP2D+u8z/ndmy/kseXR6+eb257joUP35n98b9X9WnOrpmdNU3kWjtf8PUscZGkoItKyGizh0e92sAXBoY1QtM+aAAONPugRES/lseQiwJtvvkn//v0ZO3YsY8eOZcCAAbz++usuY3bt2kVxcTEAwcHBbN26lVtuuYWePXsyffp0evbsydq1a2nTpo0nQ/UPbeIgMQ2AxZn/bPEmAYGqrhddDi1SP60R8grLGBO0id+GvgzAy1UTeKl6Yr3LMkXEPXXNQvy4umaW/rYP6r3fnIze/OS6umfSNfvvZ9kJyHrT3B8xq3kf29t1H2Nu81ZBdaW1sfiigu1gr4LIDtD2MqujEZEWVN/forzCMmjdEbpdbR6o54M0aUYVp6Fwl7mvZi4i4mU8mlxs3749b7zxBiUlJZSUlPDGG2/Qrl07lzGGYTBjxgwAIiIi+PTTTykoKKCiooL9+/ezYMGCwO0A3RQ9xprbPZ+5HPaWJJc/ulgCwBsSeP2qc/hr6HOE2OwsrL6ap6vuAmz1LssUEffUNQux/bA7ARscWA8n8+u97+hedTdTavbfz7V/gcoy8w1JcnrzPra3ix8IEe2hohQOfmN1NL7n/HqLDTTlExH/U9/fIufxvjWry7ZntlBEAaxgBxh2iOoEbeKtjkZExIVHk4tigR5m/byrg7YSQpXLTd6Q5PJHF0sAWJ7AO5xNzy9+SIStgi+q03i0ciYGQcxKT/GqmpAivm5ORm8yZ4/i2SkDyZw9ilFp/Tneoaa51raF9d6vrsRks/9+lhXCenPmMqMfC7wEUVAQpIw29/d+aWkoPknL8EQC1kX/RvW+yWwQeCTbbJwlnnMk29wmDAi8v+Mi4vXcbugiXi4xjcpWHWh79gRDg3azzt7HeZPlSS4L1Ops5wGOF111LY22PIF3YAO8cRuUF0OX4XS4dgG/O2n3umYzIv4iLSmGtKQYZ/H7u4IH8HToBo6teZO4q35a7/3mZPRmXN94z12v1tTMWkwYCL0ymvexfUX3MbB9kdnUZczjVkfjWxxvaFVvUSQgNfg3KioWkq8xr63bP4SrH7YsTr+nZi4i4sWUXPQ3QUGE9hoLm99mdFC2M7loeZLLAvV2tvOA8190eU236H3/gbemQMUpSBoJd7/HoFZtGWRdRCIB4fw6rEurh/F/IQuIO72HHVs20GfAFfXez5GYbHZlhfD138z9QJy16OBo6nJoI5wpgojA+pvYZFUVcGyHua83tCIBq8G/UX0n1SQXM5Vc9CTHLHLVWxQRL6Tkoj/qcQNsfpvpsbvpdM1A65NcFqivs924vvEencHoNf/Oe5fD23dB1Rnz0+S73oGwwJu5KmKF80tQnKQNq+wDuC44C9u2D6CB5KLHrHmuZtbiILNLdKCK7gyxvcxi+HmroM8tVkfkGwp2gL0SWrWDdl2tjkZEvFHvm+CTn8LRLXBiL3TobnVE/qe60rwegz7oERGvpJqL/qj7GLAFE3FyN5NT7N6T8GpBDXa283e7P4W37jQTi5ffAHe/p8SiSAu6sATFv6pHmsePLgPDaNlgTh3XrMXzFHQyO3gXbl5qcSQ+5Px6iwF+/ohIPSLbn6trq8YunnF8J1RXQHg0xHSzOhoRkVqUXPRHETHQZbi5f0HX6EBx0c52/mrHR/DOPVBdDr0mwNQ3ITTC6qhEAsqFxe8/tw+lMiicViX7IH9tywaz5jmoPA2JadBzXMs+t5eZtzSHn2fHAnAm59/MW7LD4oh8hLOBgGbKiEgDnF2jP7Q0DL/lrLeoZi4i4p2UXPRXPW4wt7sDM7nYIt1XvYlhwKrfw3vTzeVrfSfDlNcgJNzqyEQC0vmdo9+cPYbQQVPNG1Y83XJBnDoOG/5u7gf4rEVHqYz19t5UGMF0CTrO0tVrycovsjo07+eYuahmLiLSkNQJEBQCx7ZC4R6ro/E/qrcoIl5OyUV/5ZihkrcKKs9YG4tFzn9znzl7FI96qJmL5cpPwfvT4ctfAwYM/SHc9ncIDrU6MpGAlpYUQ3JsFHmFZWy7fCYEhZrX5LzVLRPAmj/XzFocDD3GtsxzeilHSYwztGKjvRcAVwdtJa+wjKz8IhZtOqhEY12qK+HoNnM/YZCloYiIl4tsDyk1jbM0e7H5HVWnaBHxbmro4q869YG2l0HJIdj31bmZjAHGq5qseELRPnj7bijYbiYuJjwDQ2Y06aGy8ovIKywLyAZAIp5wYcf6hUk3M6RgISx/Crot9exMwlPH4Wtz1uJ/uswk8sDJgP69Pr8kxmp7f0YG7+CaoC0s3XOch9/b7Lzt/vQU5vjrB1FNcXynWWYjvC3EJFsdjYh4u76T4NvPzbqL6T+zOhr/YbfD0a3mfoJmLoqId9LMRX9ls52bqRKgdRf9Xu4KeHm0mViM6gQzPmlyYnHe0hwmvbCGh9/bzKQX1jBvaU5zRioScOrqWD87/1rswWFm3cW9X3rseRdtOkjBkl9D1Rmy7d25Z2XbgP+9Pr9Uxip7fwCuCc3h46x8l3HzV+ZqBuP5Dm00t4mDIEgvGUXkIlJvND/sLtgOx3dZHY3/OPEtVJyCkAjo0MPqaERE6qRXiv7s/ORiS3coFc+pqoAV8+D1yXCmyGzU8KMVkDSiSQ9XVxJEb7BFLk1dnemP0Z69XWtqL37562a/Ljs+JHj7/XeJ3f4aAM9UTQHMGZKB/nvtKJXxg9tvoSo8hlb20wyyfVtrXF3/dwHr0CZzmzjY2jhExDdExEB3x9JodY1uNs7GWgMgWAsPRcQ7Kbnoz5KvgeAwc+lsgbpiepsm1fk68DW8dI3ZFMKohgFT4ftLIfqyJsdR3xtpvcEWabr6OtOfHf4ghEbC4U2we1mzPZ/jQ4JIzvJM6HyCbAbvVo3mq5pZeg76vQZsQZQmXgXA1cHbat1c3/9dQDpck1y8TMlFEWkkZ9doJRebzeFsc6vatyLixZRc9Gfhrc/NXtzyrrWxiAu3lyGXl8KSn8MrY+F4DkTGwu2vwqT5EBpxSbHU90Zab7BFmq6+jvX9e/WAYT8yDyx/yqyj1AwcScM5IW/TNaiAQ0YHfl11b61xgfx7ff519ze7EwC4vd1ulzGz0lMCujali8ozcKzmg8nLhlgbi4j4jl41S6OP74SCwC3H0awOZ5nbxEGWhiEi0hDNq/Z3A+6EnZ/AlvfhurmqmWSxrPwiVuwqqHMZ8ri+8bXf1BoG7P4UFv83lBw0jw26B8b+2uzK1wwcSZDzY9IbbJFLNyejN+P6xtdulHTlT2DDK2Zx9p0fQ59bLvm5kmOjGBW0je+FfA7Azyt/RCmRLmMC+ff6wvIPX1X3h1BILNvBv37Yl29LQ9TM6kJHt5oz5KM6mQ3iREQaI6IdXH6dOTt/+4fQSU2yLondfq5TdGKatbGIiDRAyUV/13MctIqG0sOwbzWkpFsdUcC6sHPshfIKy869sbXbzRdlq585V1C/XVe46U/QfUyzx1ZvEkRELkmdHesj28OIWbDqd7D8aUidCEHBl/Y8nYJ5sfWrUAGvV13Pf85bDn1tr448eF2PgP69vnA5+BE6sMd+GT2CDjGgcjMDBl96gtfvOP72XDbYs53NRcT/9L7ZfB27czFc+5jV0fg2RzOX0EiI7Wl1NCIi9dI0Nn8XEn6u9omWRlumrqYpF0qOjYLqKtj6Acy/Et65y3xzF9IKRj0Is9d6JLHokJYUw+TBnQM6ASHSYkb+l/nBz/Gc5qlL9ekviK44yqnIzjxddbfLTct3Hb/0x/dxdS0HX+1IwHqoc7fPUzMXEWmqnuPBFgTHtpq136XpHEui4/tf8geRIiKepORiIBhQ0510x0dQcdraWALUxZoo/Gxka9IOvQ3PD4WFPzQb8IS1gat+Cg9thbG/grDArZUm4nci2sGoH5v7nz4OJ/Y2/bF2fwZZrwM2NqY9xWla1RoS6I1c6qqB2abPDeZO7oqWD8gXOJu5qN6iiLgpqgN0vdLc37nE2lh8naNTtJZEi4iX07LoQJA0Atolwcl82LUE+t9udUReKyu/yCNLg+uaNdORk/y2Tx7DylbSOmsDYJg3RLSHEbNh2P+DCM0iFPFbw2eZM5WP74QFE2DGYujQ3b3HKD4IHz9o7o+YRdte6fDFmlrDArmRi0Ot8g9xIfDbR81ZNUX7Iaar1SF6jzMnzaV4oDe0ItI0qRPMkkw7P4GRs62Oxnc5Zi6qU7SIeDklFwOBzWY2dln1e3NptJKLdbqwJuL96SnMyWieItRpSTH819WXseGrf3NF0C6uCtrG8OCdBOWe1ym2y3DofwcMuluzFEUCQXhrmP4xvHazuTz6HzfCjE8gtkfj7p+7Aj74AZw+AR0uhzFPkBYWqQZNDahVA/OyIXBgPeSthJjvWReYt3G8mW3X1ZyBJCLirl43wrI5kL8WygohKtbqiHyPvRqOqJmLiPgGJRcDxYCpZnLx2y/gVAG07mR1RF6lrpqI9XZwbgzDgOIDcHSb+cY1fy0/O5wF4RWu4y4bAn0nQ99bIbpz038AEfFNrTuZCcZ/3myWQ1gwAaZ/Ah0bKNpuGPDVH+HLX4Fhh/gBcOcbEGZ2h1aDJjckp5vX6NyVMFjJRSfnkmjVWxSRJorpatYJPLrVbO6Sdq/VEfmeE99CZRmERjX+g0cREYsouRgoYi83E1mHNsK2hWanUnGqrx6ZSwfn+lSeMZMCR7fBsW012+1QXlx7bOs4SBoJXUeZnbxjul168CLi21p3PDeDsWB7zRLpT6Bjr9pjzxbDh7PNZWYAg+6FCc9AaITLsDq7VEttKelm1+68VWbSVl2RTYdUb1FEmkHqRDO5uHOxkotNoWYuIuJDlFwMJAPuNJOLm99RcvEC9dUjq3X8TBEc/AaObDYTiMe2mZ8qGvbadw4KNZMDiYMgaRR0HQkxyS5vXj1V41FEfExU7LkZjMe2mQnGXhkQ3hZatTM7S4dGmDMWv9sLwWFw4+9h8HQlxC5F5ysgJALKCqAgB+L6WB2Rd3C8oVWnaBG5FKkTYcXTsPdLqChT2R93Hc42t1oSLSI+QMnFQNLvNvj0F2bXseO76p4VE6AcnURd6pRdk0xa21LY8rlZLyZ/nTlDsS6RsRDfD+L6mZ8uxvWF2F4QElbvc3qyxqOI+KCoDucSjEe3wqZ/1j2ubWe485+aVdYcQsLNmeR7vzDrLiq5CKVHoeQQ2IIgYaDV0YiIL4vra9ZuPbnfLM3U52arI/Itzk7Rg6yMQkSkUZRcDCRRsXD59Wbdky3vwnW/tDoirzInozfj+sRx8tv19Dm5nLg9v4Cv99Ue2OFy8xPEOEcysZ+53NmN2UPNXuNRRPxDZHuYsQS2Z5qz6c4Wu35Fd4Hrn1STjeaUkm4mF3NXalY/nFsSHdvLbDokItJUNps5e3HdX82l0UouNp692lwpBeoULSI+QcnFQDPgzprk4ntw7f9AUJDVEVnPMMylzjs+JG3HR2YjFoegEPMPetIIs1Zil+FmfbRLdEk1HkXEv7VqC0OmNzhEJRWaUXK6ud33FVRXQXCAvzQ6rHqLItKMUieYycXdy6C6EoJDrY7INxTugcrTauYiIj4jwF9BBw7HG9GUdiMZFN7WTKDlr4FuV1kdmnWqymHrB7D2edflzqFRZrOVPreYMz09MHOj0TUe66CkgkhgU0mFZhY/ACJi4EwRu7JWsD0oNbCvr85mLqrxJSLNoMtwiOwAp0/A/jXmbHG5OEft24QBauYiIj5BycUAcOEb0Y+6pDPw+Mew+e3ATC6eKYJvXoX1L8GpY+ax0ChIvdFMKHa/DsIiPRpCnTUe01Mu+mZWSQWRwKaSCh4QFATdroacf/Fx5js8Xz0JCNDrq2Gcm7moZi4i0hyCQ6BnBmS/YS6NPi+5qA/M61ewex2dgILWqXSyOhgRkUZQctHP1fVG9NcH03g//GPY8j6M+SW0ibMouhZWVgirnjGbJFTWLEtukwjD74MhMyCiXYuGMyejN+P6xjf6RZWSCiKikgqecaDdFXThX1wZtN2ZXAzI62tRnvkBXHCYWVNYRKQ59J54LrmY8Vuw2fSBeQPmLc3hum1r6BQEv8mOIL5Njv5tRMTrqeCen6vrjegGoxcnYgZBdTms/UvLB9XSqith3Yvw3GBY/6KZWIzrB5Negp9shqseavHEokNaUgyTB3du1JvXhpIKIhIYLqWkgtQvJ8KcpTc4aDetKHceD7jrq2NJdFw/CAmzNhYR8R8poyE0EkoOwpHsej8wz8ovsiY+L5KVX8TLK7+lr20/AFuNZP3biIhPUHLRz9X9htPGyaE/MXc3vAplJ1o0puaUlV/Eok0H6/+Du3c5zL8Kls2B8mKI7w/3LoL7v4KBU33qzZOSCiLiKKlwvsaUVJCGdezah8NGe8JtVQwN2u08HnDXV0eNLzVzEZHmFBoBl19n7u9crA/MG5BXWEZ322EibeWcMlqRZyQ4j4uIeDMlF/1cfW9Eu4+aZBaxrywzZ/P5oHlLc5j0whoefm8zk15Yw7ylOeduLNoH79wDr98Kx3dCRHuY+Cf40UrzxY3NZlHUTaekgoiAWVIhc/Yonp0ykMzZo3hUS6UuWVrX9hR2HAnAlUHbgAC9vjqbuajeoog0s9SJ5nbnYn1g3oDk2Cj628xZnduNbthr3q7r30ZEvJ1qLgaAemv7XfMzeG+a2dhk5AOWLQ1uinrrD/aJI63wX7DsF2bi1BYMw2bC6DlmN1Af526dRhHxT2lJMaQlxThnb+t6cOkGXH0LZC5maodcRtw2KvD+Paur4Ei2ua9mLiLS3HqMNV+XF+wgLeq7JjU2DARpSTFUdzkBx2CbPRnQv42I+AYlFwOE442oi9SJ0LE3HM+BDX8zk40+oq6lAR0oJm7pD+DocvNA1yvhxmcgrk8LR+dZdf5fikjAUTH8ZpZ8DQAxxTuIiTUsDsYChbug8jSEtYbYHlZHIyL+JrI9dLsS8lbB7mXMyfgvfWBej6Fh+QAMGDaazEEB+GGXiPgkLYsOZEFBcM0j5v7aF6D8lLXxuOHCpQHXBW3k0/BHSTy63OxyecOvYPonfpdYFBGB+mdvq+D7JWibALG9AAP2fWV1NC3PsSQ6MQ2Cgq2NRUT8U68bze2upYB7jQ0DRnUVHNkCwBUjx+jfRkR8hpKLga7vJGjfHc58Bxv/YXU0jeaoPxjBWX4T8ndeCfsDsbYS6NQHZi6HKx80k6ciIn5IxfA9JCXd3OattDYOKxw+L7koIuIJPceb2/1r4PR31sbirQp3Q9UZcxZ5h8utjkZEpNGUfQl0QcFw9cPm/pq/QOUZa+Nxw5wrQtgUP4+7Q740D4x8wEwsxvezNjAREQ9TMXwPSa5JLuYGYHLx4DfmVs1cRMRT2iebEwGMatjzudXReCdH7duEgZooISI+RVcsgQF3QnQSnDoGWW9YHY2zQUGDy/u2fwgvjybi5G5oHQ/f+xeMewpCW7VYnCIiVlH3eA/pdhXYguDEHig5bHU0Lae8FI6ZXbLpMtzaWETEvzmXRi+xNg5vdTjL3CYMsjQMERF3qaGLQHAoXPUQLH4YvvoTDJ4OIWGWhHLRBgXVlfDvubD2efP7rlfB7a9Cm7iWDVRExGLqHu8BEe3MZcGHNkLuChh0t9URtYyD34BhNz9obJtodTQi4s963Qirn4Fvv4CqcggJtzoi73Joo7lViQoR8TGauSimQfdAmwQoOQjrX7QkhIYaFGTlF7FkTRanXr7xXGJx1IPwvY+UWBSRgKVi+B6QMtrc7l1uaRgt6sB6c5ukWYsi4mGJadA6DipKYd9qq6PxLpVnnc1c6HKFtbGIiLhJyUUxhbaCa39h7n/xKzic3eIh1NeI4Lkv9vD0i69wxae30PrY15QHRcKU12HsryD43OTbRi2nFhERaUjKteY2dwUYhqWhtJj8deZWS6JFxNOCgs41dqnpGi01jmwGeyVEdYR2Xa2ORkTELUouyjlp06D3TeYftQ9+AOWnWvTp625EYHD5t//grbCn6GgrZqe9C+PP/Iqs1le7jJq3NIdJL6zh4fc2M+mFNcxbmtMyQYuIiH/pMgxCI6GsAAp2WB2N59mrzzVzSRphbSwiEhhSJ5jbXUsD50Ocxji4wdx2HgY2m7WxiIi4SclFOcdmg5ueg7aXwXd7YemjLfr0FzYoaM1pPmj/Io+HvkWIzc6i6quYVPEkeUaCyyzHhpZTi4iIuCUkHLqOMvcDYWn0se3m8sTwtmYXVxERT0u+xvwQp+SQOVtPTM7k4lBr4xARaQIlF8VVZHuY/DJgg+w3YNvCFn36ORm9yZw9ir+Pj+SbTk8x9PRXVBjB/E/l93m4chZnMLtBV1bbnUug61tOXd9xERGRBjmXRgdActFRb7HzUAgKtjYWEQkMoRHQfYy5r6XR5ziTi6q3KCK+R8lFqa3bVXDNI+b+xw9B0f6We27DIO27ZVz/n7tpVZIHbTvzdr+XeaP6BsBcHjCoSzSPLtzqXAK9es/xOh+q7mXWIiIiF9G9Jrm47z9mN1N/5kguqt6iiLSkXhnmdtcSa+PwFsWHzJmctiB1ihYRnxRy8SESkNLnQO5KOPg1LPx/8P2lLs1TPOL0d/DJQ7DjI/P7lGvhtleYHtWBAcPNGYqV1XYeXbjV5W6ZWYeZlJZIZtZh57FZ6SnqnioiIk3TqY/ZzfTUMTP5lnyN1RF5Tr6SiyJigZ7jARsc3QLFByG6s9URWetQTe3buL4Q3traWEREmkAzF6XuLsvBIXDb38waTAe/hhVPezaIPZ/DCyPMxGJQCFz7P3DvQojqAJj1GCcP7kxocN2n7NU9OpI5exTPThlI5uxRPJrR27PxioiI/7LZIGW0uZ+7wspIPKvkMBTnmzNlVONLRFpSVOy5DzW0NFpLokXE5ym5GOAa7LIc0w0m/tHcX/0MLH6k+ZeHlZ8yl16/ebs5QyS2F/y/f0P6z+qs/VTfUufk2ChnAlIzFkVE5JI56i76c1OX/HXmNq4fhLexNhYRCTxaGn3OASUXRcS3KbkYwBrVZbn/7TD6MXN/w9/g1fFwMv/Sn9wwYOcSeOlq2PgP89iI2XDfygbrjFzYURq0BFpERDwgJd3cHs4yy3b4I0e9xaQR1sYhIoEpdYK5zVsNZ0usjcVKVRVwJNvcV3JRRHyUai4GsIa6LLsk60bPMRN+i34EhzfB/Kth8t+g51j3n9QwzKUPK542a6wAFVGJhN02/9wbuYuYk9GbcX3jySssc85YFBERaVZtE6FjKhzfCXmroO+tVkfU/BwzF1VvUUSsENsDOlwOJ76FvV9A30lWR2SNY9ug6iy0amf+e4iI+CCPzlx86qmnGDVqFJGRkbRr165R9zEMg7lz55KYmEhERASjR49m+/btngwzYDW0xLiWnuPg/tWQOBjOnoS37oAv/g+qKxv3ZM6ZitfAO3fB0S2cMlrxfNUtDD3xJPN2dXIrdi2BFhERj3Msjc71w6XR5afgaE2DNM1cFBGrOJZG7wzgpdEHa5q5dL7CrPkrIuKDPJpcrKio4I477mDWrFmNvs/vfvc7nn32WZ5//nk2bNhAfHw8N9xwA6WlpR6MNDC5vcS4XRL8YBlcMdP8fvUf4Lfd4J+3wop5ZtH78lPmbae/M7tNr/kLLJwJfxnsTCpWh0TxfNUtXFX+Z56pupMSomovxxYREbFadz+uu3hoIxjVVEQlsmgv+hssItbodaO53fNp4yct+JuDX5tbLYkWER/m0WXRTz75JAALFixo1HjDMPjTn/7E448/zuTJkwF47bXXiIuL46233uK+++7zVKgBy+0lxiHhMOEZc5bDkp/Bme/MGR2OWR22YGjdCUqP1L5vWGsY9iOWRk3mmY9q122stRxbRETESl2vxLCFYDu5n+3bNtO330CrI2o+B8w3s8tKuvLwe5sBuD89hTkZva2MSkQCTZfhENHefE+Rvw6Sr7Y6opbn6BTdRclFEfFdXlVzMS8vj6NHjzJ27LlafuHh4aSnp7NmzZo6k4vl5eWUl5/rYFxSEsDFgJsoLSnG/aRe/9vNuigFOZC/1nwxcGA9FB84l1iM6QbxAyBhACQMMj+Ni2jHZflFQO3kYn3LtEVERKww78sDXFt9OcODdvLm26/R9qqZfpN8K9m9mrbARntP57H5K3NJjo0iNDhINY1FpGUEBUPP8bD5LbMue6AlF08dh6J9gA0uG2J1NCIiTeZVycWjR48CEBcX53I8Li6O/fv313mfp59+2jlDUlpYUDDE9zO/htUslS4+CCWHoWMvaBVd590cy7HP71Stjs8iIuJNsvKLmL8yl9DgfgwP2slVQVuZvTKXcX3jff/vld1Oq2ObAPjmvOQiwKMLtzr3NZNRRFpEr4ya5OJiGPdUYNUdPFRTb7GB904iIr7A7ZqLc+fOxWazNfj1zTffXFJQtgv+oBiGUeuYw2OPPUZxcbHz68CBA5f03HKJojtDl2EX/eM4J6M3mbNH8eyUgWTOHsWjevMiIiJeJK+wDICv7P0BGBW0nSDszuM+7XgOYVWllBnh7DSS6h2mesgi0iK6j4HgcHMG3/GdVkfTsg446i0OtTYOEZFL5PbMxQceeICpU6c2OKZbt25NCiY+Ph4wZzAmJCQ4jxcUFNSazegQHh5OeHh4k55PrNWk5dgiIiItYPWe4wBsMVIoMSJpZyujvy2X5NirLI6sGeSvA+B4dH+qC4IbHKp6yCLiceGtISUd9nwGu5ZApwCadOCot9h5mLVxiIhcIreTi7GxscTGxnoiFpKTk4mPj+fzzz8nLS0NMDtOr1y5kt/+9rceeU4RERGR82XlF5GZdRiAaoJZY+/L+OAN3Nd5v38k2g6sB6Bb2nVkdh9FXmEZldV2lyXRDqqHLCItoldGTXJxKVz931ZH0zLs1XDILFGhTtEi4uvcXhbtjvz8fLKzs8nPz6e6uprs7Gyys7M5deqUc0xqaiqZmZmAuRz6oYce4je/+Q2ZmZls27aNGTNmEBkZyd133+3JUEVEREQAai19/sreD4Ar7FusCKf51cxcpMtw0pJimDy4M3dekcT96Skuw1QPWURaTM/x5vbgN1B6zNpYWkrBDqgsg7A2Zs1FEREf5tGGLr/85S957bXXnN87ZiMuX76c0aNHA7Br1y6Ki4udY37+859z5swZZs+eTVFREcOHD+ezzz6jTZs2ngxVREREBKg9W291Td3FDkXZUF4K4T78mqT0KJzcj0EQW+jBwPNumpPRm3F948krLFO3aBFpWW0TITENDmfB7mUwZLrVEXmeY0n0ZYPNRpkiIj7MozMXFyxYgGEYtb4ciUUwm7XMmDHD+b3NZmPu3LkcOXKEs2fPsnLlSvr16+fJMEVERESc0pJiXGbx7Tfi+a5VF4LslbB3uYWRXbrMjxYCkGPvwi1/38q8pTkutztmMiqxKCItrtcEc7trqbVxtJSDNU1Qu6jeooj4Po8mF0VERER80ZyM3mTOHsWzUwaSOXsU7QfdZN6w+1NrA7sEWflFlO38AoD19lRAHaFFxIv0yjC3ucuh4rS1sbQEZzMX1VsUEd+n5KKIiIhIHVxm8fUcZx7c8xnY7dYG1kR5hWVcHWQ2bXEs9XYcFxGxXFxfiE6CqrNmgtEPZeUXsWjTQbbsyYPC3ebBy4ZaG5SISDPwaM1FEREREb+QNMosul9WAEey4LIhVkfktl5hJ+gaVEClEcx6e2/ncXWEFhGvYLNB6o2wfj7sWgKpE6yOqFnNW5rD/JW5AIwOymZBGNA+BaI6WBuYiEgz0MxFERERkYsJCYPu15r7uz+zNpYm6nt2IwCbjB6UEQGoI7SIeBnH0uhdy8BebW0szSgrv8iZWAQYEbQDgBMdNGtRRPyDkosiIiIijdFzvLndvczaOJpq75cAdBk6wVlL8tGM3he5k4hIC+p6JYRHw+nCcw1P/MCF5SdG1iQXc1sPtiIcEZFmp+SiiIiISGP0uMHcHsmG0qOWhuI2ezXkrQIgcfCN6ggtIt4pOBR6XG/u71pibSzN6PzyE204TT9bHgARPUdbFJGISPNSclFERESkMVp3OldrcY+PLY0+nAVni6FVNCSmWR2NiEj9et1obnctvehQR4MUb+96n5YUw/3pKQAMC8oh2GbwXasu9Out2eMi4h/U0EVERESksXqMg0MbYfenMPh7VkfTeDVLoklOh6Bga2MREWnI5ddDUAgU7oITe6FD9zqHnd8gBeD+9BTmeHGphzkZvRnXN57WK5ZCLrTve73VIYmINBvNXBQRERFprJ7jzO3e5VBVbm0s7ti73Nx2H2NtHCIiFxPRzqy9CLDzkzqHXNggBWD+ylyfmMHYoyzb/Cb5aktjERFpTkouioiIiDRWwkBokwCVZbDvK6ujaZzyUjj4tbnv6HgtIuLNet9kbnf8q86bL2yQcrHjXuP0d3Bsq7nfTclFEfEfSi6KiIiINJbNdq6xy+5PrY2lsfZ9BfYqiEmGmG5WRyMicnG9bwJscOgbOHmg1s3nN0hpzHGv4fhQqmOqWcdXRMRPKLkoIiIi4o6e483t7mVgGNbG0hhaEi0ivqZNPCSNNPdzPq518/kNUhxmpaeQlhTTEtE1Xd4qc5t8jbVxiIg0MzV0EREREXFHcjoEh8HJ/VC4Gzr2sjqihjmauWhJtIj4kj63QP4a2PERjJxd62ZHg5S8wjKSY6O8P7EIsG+1udWSaBHxM5q5KCIiIuKO8Nbn3hjuXmZtLBdTfBBO7AFbsN7Miohv6XOzuT2wDkoO1zkkLSmGyYM7+0Zi8VQBHN8J2KDbVVZHIyLSrJRcFBEREXGXc2m0l9dddCyJvmwIWccNFm066PXdVEVEAGibCF2Gm/s5dXeN9imOJdFx/SCyvbWxiIg0MyUXRURERNzVc6y5zV8HZ7w4WVezJPoroz+TXljDw+9tZtILa5i3NMfiwEREGqHPLeZ2x4eWhtEsHEuiVW9RRPyQkosiIiIi7orpZnb7NKrh2y+sjqZudjvkrgDgj7mdXW6avzJXMxhFxPv1rlkavX8NlB6zNpZLledILqpEhYj4HyUXRURERJqi5zhzu9NLl+sd3QxnvqMyJIrNRvdaN+cVllkQlIiIG9p1gcuGAAbsrN012mcUH4Lv9oItCLqOsjoaEZFmp+SiiIiISFP0udXc7loG5aWWhlKnmnqLZYmjqCKk1s3JsVEtHZGIiPucS6M/sjaOS+FYEp0wEFpFWxuLiIgHKLkoIiIi0hSJadC+O1SdgZ2LrY6mtlwzudiu3zjuT09xuWlWeopvdFcVEXEsjd73FZQVWhtLU+Wp3qKI+LfaH2OLiIiIyMXZbDBgCqx4Gra8BwOnWh3ROWdLzGYzACnXMmfY5YzrG09eYRnJsVFKLIqI72ifbM74O7LZLEMxZIbVEblvX02n6G5KLoqIf9LMRREREZGm6n+Huc1dDqcKrI3lfDsXQ3UFxPaCDma9xbSkGCYP7qzEooj4HkcZCl9cGl20D07mQ1AIJI2wOhoREY9QclFERESkqTp0h8TBYNhhe6bV0Zyz9X1z2/92c4aliIgvc9RdzF0Jp7+zNhZ3OZZEJw6G8NbWxiIi4iFKLoqIiIhcigFTzO2W96yNw+HUcchdYe73u83SUEREmkWH7hDXH4xq2LXE6mjcs0/1FkXE/ym5KCIiInIp+k4GWxAc+gZO7LU6GtjxofkGPHGwc0m0iIjP88Wu0YYBeTX1FpOvtjYWEREPUnJRRERE5FK0iYOU0eb+toWWhgLA1g/Mbf/brY1DRKQ5OZKLe5f7ztLow5ug9AiERkEX1VsUEf+l5KKIiIjIpXI0dtnynjlTxSon8+HAOsBmzqgUEfEXHXtCfH+wV7p8kJOVX8SiTQfJyi+yMLh65HxsbnvcAKGtrI1FRMSDlFwUERERuVSpEyGkFZzYA0eyrYvD8Ya721XQNsG6OEREPGHQPeY2+00A5i3NYdILa3j4vc1MemEN85bmWBjcBQzjXHKx903WxiIi4mFKLoqIiIhcqlZtoVeGue9YluyGZpt541wSfcelPY6IiDfqfwcEhcDhLHI2r2P+ylyXm+evzPWeGYzHd8GJbyE4DHqMtToaERGPUnJRREREpDk4EnpbPwB7daPv1mwzbwp2wrFtEBQKfW5u2mOIiHizqFjoOR6A4C3v1Dkkr7CsJSOq386aWYspo80PoERE/JiSiyIiIiLN4fIboFU7OHUU9q1u1F2y8ouab+bNtppZi5dfDxEx7t9fRMQXDLobgOTDHxNM7Q9ykmOjWjqiumlJtIgEECUXRURERJpDSBj0vdXc3/p+o+5S3wwbt2feGMa551SXaBHxZz3GQmQsoWcKeXrgcZebZqWnkJbkBR+uFO2HI5vBFgS9brQ6GhERj1NyUURERKS59J9ibnf8CyrPXnR4fTNs3J55c2gTFO2D0MhztR9FRPxRcCgMMK+1U4JXkTl7FM9OGUjm7FE8mtHb4uBq7FxsbpNGmUu5RUT8nJKLIiIiIs0laSS07QzlJY2avZiWFMP96Skux5o088bxXKkTIMxLlgSKiHhKzdJodi0hLdZg8uDO3jFj0UFLokUkwIRYHYCIiIiI3wgKguH3wedPwFfPmm+Ag4IbvMucjN6M6xtPXmEZybFR7r9BtlfD9kXmfj8tiRaRABDf3/w6uhW2LYRhM62O6JxTBZC/1txPnWBtLCIiLUQzF0VERESa09AfmA1VvsuF7ZmNuktaUkzTZ97sWw2njpnNZLqPcf/+IiK+aNA95jb7LWvjuNCuJYBBWewAFuXamtagS0TExyi5KCIiItKcwlvDiNnm/uo/gN3erA+flV/Eok0Hz71hdbyx7nur2VRGRCQQ9L8DgkLg8CYoyLE6mnNqlkT/9UgqD7+3mUkvrGHeUi+KT0TEA5RcFBEREWluw34E4W2hYEfNLJbmMW9pDpNeWON8w/q3RUvO1Vsc/L1mex4REa8XFQs9x5v73jJ78Wwx9tyVAHxqv8J5eP7KXM1gFBG/puSiiIiISHOLaHeuBtjqZ8AwLvkhs/KLmL8y1+VYYtYfwbBD6kS4bMglP4eIiE9xNHbZ8i5UV1kbC8DuzwiyV/KtPZG9xmUuN+UVllkUlIiI5ym5KCIiIuIJI2ZDaCQczoK9XzQ4tNZS5zpc+Ma0ny2XCcFfY2CDax9vlpBFRHxKj7EQGWvWnd37pdXRwE5zSfSy82YtOiTHRrV0NCIiLUbJRRERERFPiIqFId8391c9U++wC5c611eb68I3po+EmMuhi7rfCnF9miVkERGfEhwKA6aY+xsXWBoKlWdgz+cARA2a5HLTrPSUpjXsEhHxEUouioiIiHjKqB9DcBjkr4V9/6l1c11LneurzZWWFMP96SkADLPlMDp4M9W2YNpP+KVnYhcR8QVDZpjbXYvh+C7r4tj7JVSehugufP+2W8mcPYpnpwwkc/YoHs3obV1cIiItQMlFEREREU9pmwBp95r7q35f6+b6anDVd3xORm8yZ43khYTFAAQPmQ7tU5onVhERX9Sxl1l3Fjjx2e8uWmLCYza/bW5TJ4LNRlpSDJMHd9aMRREJCEouioiIiHjSlQ+BLRhyl8PBjS431VeDq6HaXGkVG4n9bhOEtIJrftackYqI+KarfgpA292ZPPPeFw2WmPCI73Ih5xNzf8j0lnteEREvoeSiiIiIiCfFdIWBU839L38FdrvzpvOXOjs0WJvLbocv/s/cHzYT2iZ6ImIREZ+SZe/Omuo+hNqq+X8hS4D6S0x4xPqXAAMuvx46aQm0iAQeJRdFREREPO2qh83ai7nL4Yu5LjfNyejtrM3129v60yOuTf1viHP+BUe3QFgbuPKnLjc1puO0iIg/yiss44XqWwCYGrycGEqcxz3uzEnY9Lq5P/K/PP98IiJeKMTqAERERET8XuzlcMtfYdFM+M+fzTqJjiYEmDMYP91+1KW5y/3pKcw5vwlAdRUsf8rcH/UARHVw3jRvaU7D9xUR8WPJsVF8Ze/HFnsyA4LymBHyGX+sur3BEhPNZuMCqCyDTn0h5VrPP5+IiBfSzEURERGRZlbnLMIBU2D0L8z9Tx42O4ueN77BrtGVZ+CDGVC4GyLaw4jZjb+viIifM0tMdOfFqpsBmB78KT+5Ks7zzVSqK2uWRGPOWrTZPPt8IiJeSslFERERkWY0b2kOk15Yw8Pvba7dVCD95zBgKhjV8N50OLYDuEjX6NPfwT9vhZyPzaXVN/8FWrV1HVPffUVEAsScjN786EcPUhrVjXa2Mn7afq3nn3T7h1B6GFrHkd3uOpWmEJGA5dHk4lNPPcWoUaOIjIykXbt2jbrPjBkzsNlsLl8jRozwZJgiIiIizeKiswhtNrj5Oeh6JZSXwFtToPRYvUv3eoV/B6+MhQProFU0TMuE3hNdxjSl47SIiD9K6xZLm+v+2/xm7V+hqtxjz5W1/zuKvngWgJXtbuXWlzbW/aGSiEgA8GhysaKigjvuuINZs2a5db/x48dz5MgR59eSJUs8FKGIiIhI82nULMKQcLjzDehwORQfgLfvJC04lwevinO5z9yhFfRdchuc2ANtO8MPPoVuV9V6bLc7TouI+LMBd0KbRCg9Apvf8chTzFuaw7z5rxJTvIMzRhgPfZvmcrtKU4hIoPFoQ5cnn3wSgAULFrh1v/DwcOLj4z0QkYiIiIjnNHoWYWR7uPs9+Pv1cDgL/jaGh4EHOiRSFNmNoA4pdNz9IVScgrh+cM8H0Dah3uedk9GbcX3jySssIzk2SolFEQlcIeFm/cPPHjcbaKXdC0HBzfbwjhnqfws1J8AsrL6aItrWGpdXWKZrsYgEDK+subhixQo6depEz549mTlzJgUFBfWOLS8vp6SkxOVLRERExApuzSLs0B3uXWh2F43qBEBY2WHijq+h4843zMRiymj4/tIGE4vnP/fkwZ31ZlZEZMgMaNUOvttrdnNuRnmFZSTbjnBd0CYAXqm+sc5xKk0hIoHEozMXmyIjI4M77riDrl27kpeXxxNPPMGYMWPYuHEj4eHhtcY//fTTzhmSIiIiIlZzaxbhZYPhex8yb2kOb6/cQnfbYXoEHeK2LqcYNqAvDLsPQsJaLngREX8Q3hrSH4VPH4PP/geS0yH28mZ56OTYKH4QvJQgm8Hn1YPJM2p/+KPSFCISaGyGYRju3GHu3LkXTeZt2LCBoUOHOr9fsGABDz30ECdPnnQ7wCNHjtC1a1feeecdJk+eXOv28vJyysvPFeotKSmhS5cuFBcX07Zt7enpIiIiIt4kK7+ISS+sqXU8c/YovTkVEWkqux1evwXyVkHiYPjhZxAceumPW3KYyj8NItReztSK/2GdvQ+z0lMYq9IUIuJnSkpKiI6OblR+ze2Ziw888ABTp05tcEy3bt3cfdh6JSQk0LVrV/bs2VPn7eHh4XXOaBQRERHxBQ01gdEbVBGRJgoKgltfhBdHweFNsOr3cO0vLu0xqyrg/RmE2ssp6ziIKSOm8mjH1s5rta7ZIhKo3E4uxsbGEhsb64lY6nTixAkOHDhAQsLFaw2JiIiI+JpGN4ERERH3RHeGiX+ED34Aq37PrjbD2B6U2vTZhZ8/AQfWQ3g0UXf9g8ntuzR/zCIiPsijDV3y8/PJzs4mPz+f6upqsrOzyc7O5tSpU84xqampZGZmAnDq1CkeeeQR1q5dy759+1ixYgU33XQTsbGxTJo0yZOhioiIiFjCrSYwIiLinn63wYA7wbDT6l+zeOK9dUx6YQ3zlua49zhb3of18839yS9B+5SGx4uIBBCPNnT55S9/yWuvveb8Pi0tDYDly5czevRoAHbt2kVxcTEAwcHBbN26lX/+85+cPHmShIQErr32Wt59913atGnjyVBFRERELONWExgREXHL5gGP02HzF3QNKuCXIa/zaNWPmL8yl3F94xt3vT22HT5+0Ny/5mfQK8OzAYuI+Bi3G7p4O3cKToqIiIiIiIh/W7TpIO++/w5vh/2aIJvBfRU/5VP7FTw7ZSCTB3du+M5ni+Hl0fBdLnQfA/d8AEHBLRK3iIiV3MmveXRZtIiIiIiIiIiVkmOjWG/05qXqiQA8F/oXHg55j5R2F3k7bLdD5iwzsRidBLe9osSiiEgdlFwUERERERERv+Wobfts1R18Xj2YcFsVD4Z8yKCPxkHOx3DhYj67HQ5sgH/9GHYthuAwmPIaRLa35gcQEfFyHq25KCIiIiIiImKVrPwi8grLGNc33qxte3wwuWVfkbLxKSjOh3fvhe7XwbjfwKljZrJx5ydQeuTcg9z4e7hssHU/hIiIl1PNRREREREREfE785bmMH9lrvP7+9NTmJPR2/ym4jSs/gOseQ6qK2rfOawN9BwLA6aaWxGRAONOfk0zF0VERERERMSvZOUXuSQWAdcO0WGRcN0TMOhuWPoofPs5RHaA1AmQehOkpENIuEXRi4j4FiUXRURERERExK/kFZbVezwtKebcgQ7d4Z734fR3ENFODVtERJpAyUURERERERHxK8mxUY0/brNBVAcPRyQi4r/ULVpERERERET8iqND9Plmpae4zloUEZFmoZmLIiIiIiIi4nfmZPQ2O0QXlpEcG6XEooiIhyi5KCIiIiIiIn4pLSlGSUUREQ/TsmgRERERERERERFpEs1cFBEREREREbmIrPwiLbEWEamDkosiIiIiIiIiDZi3NIf5K3Od39+fnsKcjN4WRiQi4j20LFpERERERESkHln5RS6JRYD5K3PJyi+yKCIREe+i5KKIiIiIiIhIPfIKy9w6LiISaJRcFBEREREREalHcmyUW8dFRAKNkosiIiIiIiIi9UhLiuH+9BSXY7PSU9TURUSkhhq6iIiIiIiIiDRgTkZvxvWNV7doEZE6KLkoIiIiIiIichFpSTFKKoqI1EHLokVERERERERERKRJlFwUERERERERERGRJlFyUURERERERERERJpEyUURERERERERERFpEiUXRUREREREREREpEnULVpERERERESkRlZ+EXmFZSTHRqk7tIhIIyi5KCIiIiIiIgLMW5rD/JW5zu/vT09hTkZvCyMSEfF+WhYtIiIiIiIiAS8rv8glsQgwf2UuWflFFkUkIuIblFwUERERERGRgJdXWObWcRERMSm5KCIiIiIiIgEvOTbKreMiImJSclFEREREREQCXlpSDPenp7gcm5WeoqYuIiIXoYYuIiIiIiIiIsCcjN6M6xuvbtEiIm5QclFERERERESkRlpSjJKKIiJu0LJoERERERERERERaRIlF0VERERERERERKRJlFwUERERERERERGRJlFyUURERERERERERJpEyUURERERERERERFpEiUXRUREREREREREpEmUXBQREREREREREZEmUXJRREREREREREREmkTJRREREREREREREWkSJRdFRERERERERESkSZRcFBERERERERERkSZRclFERERERERERESaRMlFERERERERERERaRIlF0VERERERERERKRJlFwUERERERERERGRJgmxOoDmZhgGACUlJRZHIiIiIiIiIiIi4nsceTVHnq0hfpdcLC0tBaBLly4WRyIiIiIiIiIiIuK7SktLiY6ObnCMzWhMCtKH2O12Dh8+TJs2bbDZbFaH4xElJSV06dKFAwcO0LZtW6vDER+gc0bcpXNG3KVzRtyh80XcpXNG3KVzRtylc0bc5e/njGEYlJaWkpiYSFBQw1UV/W7mYlBQEJ07d7Y6jBbRtm1bvzyBxXN0zoi7dM6Iu3TOiDt0voi7dM6Iu3TOiLt0zoi7/PmcudiMRQc1dBEREREREREREZEmUXJRREREREREREREmkTJRR8UHh7O//7v/xIeHm51KOIjdM6Iu3TOiLt0zog7dL6Iu3TOiLt0zoi7dM6Iu3TOnON3DV1ERERERERERESkZWjmooiIiIiIiIiIiDSJkosiIiIiIiIiIiLSJEouioiIiIiIiIiISJMouSgiIiIiIiIiIiJNouSiiIiIiIiIiIiINImSi17oqaeeYtSoUURGRtKuXbtG3ccwDObOnUtiYiIRERGMHj2a7du3u4wpLy/nxz/+MbGxsURFRXHzzTdz8OBBD/wE0tKKioqYNm0a0dHRREdHM23aNE6ePNngfWw2W51fv//9751jRo8eXev2qVOnevinkZbQlHNmxowZtc6HESNGuIzRdcZ/uXvOVFZW8uijj9K/f3+ioqJITEzke9/7HocPH3YZp+uM/3jhhRdITk6mVatWDBkyhNWrVzc4fuXKlQwZMoRWrVqRkpLC/Pnza41ZuHAhffr0ITw8nD59+pCZmemp8MUC7pwzixYt4oYbbqBjx460bduWkSNH8umnn7qMWbBgQZ2vbc6ePevpH0VaiDvnzIoVK+o8H3bu3OkyTtcZ/+bOOVPXa12bzUbfvn2dY3Sd8V+rVq3ipptuIjExEZvNxocffnjR++i1zDlKLnqhiooK7rjjDmbNmtXo+/zud7/j2Wef5fnnn2fDhg3Ex8dzww03UFpa6hzz0EMPkZmZyTvvvMNXX33FqVOnmDhxItXV1Z74MaQF3X333WRnZ7Ns2TKWLVtGdnY206ZNa/A+R44ccfl69dVXsdls3HbbbS7jZs6c6TLupZde8uSPIi2kKecMwPjx413OhyVLlrjcruuM/3L3nDl9+jSbNm3iiSeeYNOmTSxatIjdu3dz88031xqr64zve/fdd3nooYd4/PHHycrK4uqrryYjI4P8/Pw6x+fl5XHjjTdy9dVXk5WVxS9+8QsefPBBFi5c6Byzdu1a7rzzTqZNm8bmzZuZNm0aU6ZMYf369S31Y4kHuXvOrFq1ihtuuIElS5awceNGrr32Wm666SaysrJcxrVt27bWa5xWrVq1xI8kHubuOeOwa9cul/OhR48eztt0nfFv7p4zf/7zn13OlQMHDtC+fXvuuOMOl3G6zvinsrIyBg4cyPPPP9+o8XotcwFDvNY//vEPIzo6+qLj7Ha7ER8fb8ybN8957OzZs0Z0dLQxf/58wzAM4+TJk0ZoaKjxzjvvOMccOnTICAoKMpYtW9bssUvL2bFjhwEY69atcx5bu3atARg7d+5s9OPccsstxpgxY1yOpaenGz/5yU+aK1TxEk09Z6ZPn27ccsst9d6u64z/aq7rzNdff20Axv79+53HdJ3xD8OGDTPuv/9+l2OpqanGnDlz6hz/85//3EhNTXU5dt999xkjRoxwfj9lyhRj/PjxLmPGjRtnTJ06tZmiFiu5e87UpU+fPsaTTz7p/L6xr53FN7l7zixfvtwAjKKionofU9cZ/3ap15nMzEzDZrMZ+/btcx7TdSYwAEZmZmaDY/RaxpVmLvqBvLw8jh49ytixY53HwsPDSU9PZ82aNQBs3LiRyspKlzGJiYn069fPOUZ809q1a4mOjmb48OHOYyNGjCA6OrrR/7fHjh1j8eLF/PCHP6x125tvvklsbCx9+/blkUcecZkNK77pUs6ZFStW0KlTJ3r27MnMmTMpKChw3qbrjP9qjusMQHFxMTabrVbJD11nfFtFRQUbN250+d0HGDt2bL3nx9q1a2uNHzduHN988w2VlZUNjtH1xPc15Zy5kN1up7S0lPbt27scP3XqFF27dqVz585MnDix1sxG8U2Xcs6kpaWRkJDAddddx/Lly11u03XGfzXHdeaVV17h+uuvp2vXri7HdZ0R0GuZC4VYHYBcuqNHjwIQFxfncjwuLo79+/c7x4SFhRETE1NrjOP+4puOHj1Kp06dah3v1KlTo/9vX3vtNdq0acPkyZNdjt9zzz0kJycTHx/Ptm3beOyxx9i8eTOff/55s8Qu1mjqOZORkcEdd9xB165dycvL44knnmDMmDFs3LiR8PBwXWf8WHNcZ86ePcucOXO4++67adu2rfO4rjO+r7CwkOrq6jpfh9R3fhw9erTO8VVVVRQWFpKQkFDvGF1PfF9TzpkL/eEPf6CsrIwpU6Y4j6WmprJgwQL69+9PSUkJf/7zn7nyyivZvHmzy1JY8T1NOWcSEhJ4+eWXGTJkCOXl5bz++utcd911rFixgmuuuQao/1qk64zvu9TrzJEjR1i6dClvvfWWy3FdZ8RBr2VcKbnYQubOncuTTz7Z4JgNGzYwdOjQJj+HzWZz+d4wjFrHLtSYMWKNxp4zUPv/Htz7v3311Ve55557atUKmTlzpnO/X79+9OjRg6FDh7Jp0yYGDx7cqMeWluPpc+bOO+907vfr14+hQ4fStWtXFi9eXCsx7c7jinVa6jpTWVnJ1KlTsdvtvPDCCy636TrjP9x9HVLX+AuPN+W1jfiOpv7/vv3228ydO5ePPvrI5YOPESNGuDQau/LKKxk8eDB/+ctfeO6555ovcLGMO+dMr1696NWrl/P7kSNHcuDAAZ555hlnctHdxxTf09T/3wULFtCuXTtuvfVWl+O6zsj59FrmHCUXW8gDDzxw0e6X3bp1a9Jjx8fHA2bmPCEhwXm8oKDAmSWPj4+noqKCoqIil1lFBQUFjBo1qknPK57V2HNmy5YtHDt2rNZtx48fr/UpSV1Wr17Nrl27ePfddy86dvDgwYSGhrJnzx696fdCLXXOOCQkJNC1a1f27NkD6Drji1rinKmsrGTKlCnk5eXx5ZdfusxarIuuM74nNjaW4ODgWp/Cn/865ELx8fF1jg8JCaFDhw4NjnHnOiXeqSnnjMO7777LD3/4Q95//32uv/76BscGBQVxxRVXOP9Oie+6lHPmfCNGjOCNN95wfq/rjP+6lHPGMAxeffVVpk2bRlhYWINjdZ0JXHot40o1F1tIbGwsqampDX41tcOUYznZ+UvIKioqWLlypfMN/ZAhQwgNDXUZc+TIEbZt26Y3/V6qsefMyJEjKS4u5uuvv3bed/369RQXFzfq//aVV15hyJAhDBw48KJjt2/fTmVlpUsSW7xHS50zDidOnODAgQPO80HXGd/j6XPGkVjcs2cP//73v50vtBqi64zvCQsLY8iQIbWWsn/++ef1nh8jR46sNf6zzz5j6NChhIaGNjhG1xPf15RzBswZizNmzOCtt95iwoQJF30ewzDIzs7W9cQPNPWcuVBWVpbL+aDrjP+6lHNm5cqVfPvtt3XWo7+QrjOBS69lLtDSHWTk4vbv329kZWUZTz75pNG6dWsjKyvLyMrKMkpLS51jevXqZSxatMj5/bx584zo6Ghj0aJFxtatW4277rrLSEhIMEpKSpxj7r//fqNz587Gv//9b2PTpk3GmDFjjIEDBxpVVVUt+vNJ8xs/frwxYMAAY+3atcbatWuN/v37GxMnTnQZc+E5YxiGUVxcbERGRhovvvhircf89ttvjSeffNLYsGGDkZeXZyxevNhITU010tLSdM74AXfPmdLSUuO///u/jTVr1hh5eXnG8uXLjZEjRxqXXXaZrjMBwt1zprKy0rj55puNzp07G9nZ2caRI0ecX+Xl5YZh6DrjT9555x0jNDTUeOWVV4wdO3YYDz30kBEVFeXssDlnzhxj2rRpzvG5ublGZGSk8dOf/tTYsWOH8corrxihoaHGBx984Bzzn//8xwgODjbmzZtn5OTkGPPmzTNCQkJcupaL73L3nHnrrbeMkJAQ469//avL9eTkyZPOMXPnzjWWLVtm7N2718jKyjK+//3vGyEhIcb69etb/OeT5ufuOfPHP/7RyMzMNHbv3m1s27bNmDNnjgEYCxcudI7Rdca/uXvOONx7773G8OHD63xMXWf8V2lpqTP3AhjPPvuskZWVZezfv98wDL2WuRglF73Q9OnTDaDW1/Lly51jAOMf//iH83u73W787//+rxEfH2+Eh4cb11xzjbF161aXxz1z5ozxwAMPGO3btzciIiKMiRMnGvn5+S30U4knnThxwrjnnnuMNm3aGG3atDHuueceo6ioyGXMheeMYRjGSy+9ZERERLi8MHfIz883rrnmGqN9+/ZGWFiY0b17d+PBBx80Tpw44cGfRFqKu+fM6dOnjbFjxxodO3Y0QkNDjaSkJGP69Om1riG6zvgvd8+ZvLy8Ov+Wnf/3TNcZ//LXv/7V6Nq1qxEWFmYMHjzYWLlypfO26dOnG+np6S7jV6xYYaSlpRlhYWFGt27d6vyg6/333zd69eplhIaGGqmpqS5JAfF97pwz6enpdV5Ppk+f7hzz0EMPGUlJSUZYWJjRsWNHY+zYscaaNWta8CcST3PnnPntb39rdO/e3WjVqpURExNjXHXVVcbixYtrPaauM/7N3b9NJ0+eNCIiIoyXX365zsfTdcZ/LV++vMG/M3ot0zCbYdRUnBQRERERERERERFxg2ouioiIiIiIiIiISJMouSgiIiIiIiIiIiJNouSiiIiIiIiIiIiINImSiyIiIiIiIiIiItIkSi6KiIiIiIiIiIhIkyi5KCIiIiIiIiIiIk2i5KKIiIiIiIiIiIg0iZKLIiIiIiIiIiIi0iRKLoqIiIiIiIiIiEiTKLkoIiIiIiIiIiIiTaLkooiIiIiIiIiIiDTJ/wfHlJoLd9i5kgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "x = np.linspace(-1, 1, 201).reshape(-1,1)\n", + "y = f_obj(x)\n", + "\n", + "plt.figure(figsize=(16, 6))\n", + "plt.plot(x, y, \"C1-\", label=\"target function\")\n", + "plt.scatter(xt, yt, marker=\"o\", s=10, label=\"observed data\")\n", + "plt.xlim([-1.1,1.1])\n", + "plt.legend(loc=0)\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "465167dc-424b-4b73-8e1d-28dc6e5e3044", + "metadata": {}, + "source": [ + "#### Building the surrogate" + ] + }, + { + "cell_type": "markdown", + "id": "41bca9a8-bc79-4122-a650-64dd4c37203c", + "metadata": {}, + "source": [ + "In order to ensure the proper convergence of optimization, we take an initial guess for theta based on the data std.\\\n", + "Also, it can be useful to change the allowed bounds for this parameter.\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "87e8237c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "theta0 : [3.15920359]\n" + ] + } + ], + "source": [ + "# Initial guess for lengthscale parameter: standard deviation of training data\n", + "l = np.std(xt, axis=0)\n", + "\n", + "# Transform to theta parameter (inverse of lengthscale)\n", + "theta0 = 1/l**2\n", + "print(\"theta0 :\", theta0)\n", + "\n", + "# Specify bounds for theta\n", + "bounds = [[1e-8, 1e2]] " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f261c2c8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mixture[Smooth(1)]($regr_SquaredExponential)\n" + ] + } + ], + "source": [ + "sgpx = egx.SparseGpMix(theta_init=theta0, theta_bounds=bounds, nz=30, seed=0).fit(xt, yt)\n", + "\n", + "# Print trained surrogate\n", + "print(sgpx)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "a302fb72-aff9-4d92-949f-f77832ab78d6", + "metadata": { + "tags": [] + }, + "source": [ + "### Prediction" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "b4419c24-cb8e-4dd0-893b-8b6b23ad3218", + "metadata": {}, + "source": [ + "#### Using the surrogate for estimation" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "47d51b54-41df-4b78-b10f-f996ec8bf5a2", + "metadata": {}, + "outputs": [], + "source": [ + "hat_y = sgpx.predict_values(x)\n", + "var = sgpx.predict_variances(x)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "4c44d3ba-4540-4e3f-8eb8-35eac1a6c3df", + "metadata": {}, + "source": [ + "#### Plotting results" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "782b0849-ef74-4267-999b-d714065323e7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(14, 6))\n", + "plt.plot(x, y, \"C1-\", label=\"target function\")\n", + "plt.scatter(xt, yt, marker=\"o\", s=10, label=\"observed data\")\n", + "plt.plot(x, hat_y, \"k-\", label=\"Sparse GP\")\n", + "plt.plot(x, hat_y - 3 * np.sqrt(var), \"g--\")\n", + "plt.plot(x, hat_y + 3 * np.sqrt(var), \"g--\", label=\"99% CI\")\n", + "#plt.plot(Z1, -2.9 * np.ones_like(Z1), \"r|\", mew=2, label=\"inducing points - random\")\n", + "plt.ylim([-3, 3])\n", + "plt.legend(loc=0)\n", + "plt.title('FITC method - random inducing points')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 8894fb6b34ffa72dd863a410f0940a6bcfdf3129 Mon Sep 17 00:00:00 2001 From: relf Date: Wed, 31 Jan 2024 17:44:19 +0100 Subject: [PATCH 17/26] Trained Gp model store reduced likelihood value --- gp/src/algorithm.rs | 14 ++++++++++++-- gp/src/sparse_algorithm.rs | 7 ++++++- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index 46fe7df0..992a8d3e 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -176,6 +176,9 @@ impl Clone for GpInnerParams { pub struct GaussianProcess, Corr: CorrelationModel> { /// Parameter of the autocorrelation model theta: Array1, + /// Reduced likelihood value (result from internal optimization) + /// Maybe used to compare different trained models + likelihood: F, /// Regression model #[cfg_attr( feature = "serializable", @@ -218,6 +221,7 @@ impl, Corr: CorrelationModel> Clone fn clone(&self) -> Self { Self { theta: self.theta.to_owned(), + likelihood: self.likelihood, mean: self.mean, corr: self.corr, inner_params: self.inner_params.clone(), @@ -232,7 +236,11 @@ impl, Corr: CorrelationModel> fmt::Display for GaussianProcess { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "GP({}, {})", self.mean, self.corr) + write!( + f, + "GP(mean={}, corr={}, theta={}, variance={})", + self.mean, self.corr, self.theta, self.inner_params.sigma2 + ) } } @@ -866,9 +874,11 @@ impl, Corr: CorrelationModel, D: Data> { sigma2: F, /// Gaussian noise variance noise: F, + /// Reduced likelihood value (result from internal optimization) + /// Maybe used to compare different trained models + likelihood: F, /// Weights in case of KPLS dimension reduction coming from PLS regression (orig_dim, kpls_dim) w_star: Array2, /// Training inputs @@ -180,6 +183,7 @@ impl> Clone for SparseGaussianProcess, D: Data + Sync> }; // Recompute reduced likelihood with optimized params - let (_, w_data) = self.reduced_likelihood( + let (lkh, w_data) = self.reduced_likelihood( &opt_theta, opt_sigma2, opt_noise, @@ -572,6 +576,7 @@ impl, D: Data + Sync> theta: opt_theta, sigma2: opt_sigma2, noise: opt_noise, + likelihood: lkh, w_data, w_star, xtrain: xtrain.to_owned(), From d6da0df4d0d32f21e90cda98a6129bea621df77a Mon Sep 17 00:00:00 2001 From: relf Date: Wed, 31 Jan 2024 19:50:16 +0100 Subject: [PATCH 18/26] Improve display trained model infos --- doc/SparseGpx_Tutorial.ipynb | 20 ++++++++++---------- gp/src/algorithm.rs | 4 ++-- gp/src/sparse_algorithm.rs | 7 ++++++- moe/src/surrogates.rs | 10 ++++++---- python/egobox/tests/test_sgpmix.py | 21 +++++++++++++++++++++ 5 files changed, 45 insertions(+), 17 deletions(-) diff --git a/doc/SparseGpx_Tutorial.ipynb b/doc/SparseGpx_Tutorial.ipynb index 5d2fb4f6..9db365fc 100644 --- a/doc/SparseGpx_Tutorial.ipynb +++ b/doc/SparseGpx_Tutorial.ipynb @@ -132,7 +132,7 @@ "rng = np.random.RandomState(0)\n", "\n", "# generate data\n", - "xt = 2*np.random.rand(N, 1) - 1\n", + "xt = 2*rng.rand(N, 1) - 1\n", "yt = f_obj(xt) + rng.normal(loc=0.0, scale=np.sqrt(eta), size=(N,1))" ] }, @@ -144,7 +144,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -188,7 +188,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "id": "87e8237c", "metadata": {}, "outputs": [ @@ -196,7 +196,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "theta0 : [3.15920359]\n" + "theta0 : [3.10146663]\n" ] } ], @@ -214,7 +214,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 7, "id": "f261c2c8", "metadata": {}, "outputs": [ @@ -222,12 +222,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Mixture[Smooth(1)]($regr_SquaredExponential)\n" + "Mixture[Smooth(1)](SquaredExponentialSGP(corr=SquaredExponential, theta=[35.44704329956747], variance=4.116726430399307, noise variance=0.008454541745122387, likelihood=288.78855659582496))\n" ] } ], "source": [ - "sgpx = egx.SparseGpMix(theta_init=theta0, theta_bounds=bounds, nz=30, seed=0).fit(xt, yt)\n", + "sgpx = egx.SparseGpMix(theta_init=theta0, theta_bounds=bounds, nz=30, seed=42).fit(xt, yt)\n", "\n", "# Print trained surrogate\n", "print(sgpx)" @@ -255,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 8, "id": "47d51b54-41df-4b78-b10f-f996ec8bf5a2", "metadata": {}, "outputs": [], @@ -275,13 +275,13 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 9, "id": "782b0849-ef74-4267-999b-d714065323e7", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index 992a8d3e..dd452a35 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -238,8 +238,8 @@ impl, Corr: CorrelationModel> fmt::Display fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, - "GP(mean={}, corr={}, theta={}, variance={})", - self.mean, self.corr, self.theta, self.inner_params.sigma2 + "GP(mean={}, corr={}, theta={}, variance={}, likelihood={})", + self.mean, self.corr, self.theta, self.inner_params.sigma2, self.likelihood, ) } } diff --git a/gp/src/sparse_algorithm.rs b/gp/src/sparse_algorithm.rs index fd58070c..da490d3a 100644 --- a/gp/src/sparse_algorithm.rs +++ b/gp/src/sparse_algorithm.rs @@ -195,7 +195,11 @@ impl> Clone for SparseGaussianProcess> fmt::Display for SparseGaussianProcess { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "SGP({})", self.corr) + write!( + f, + "SGP(corr={}, theta={}, variance={}, noise variance={}, likelihood={})", + self.corr, self.theta, self.sigma2, self.noise, self.likelihood + ) } } @@ -426,6 +430,7 @@ impl, D: Data + Sync> Inducings::Randomized(n) => make_inducings(*n, &xtrain.view(), &mut rng), Inducings::Located(z) => z.to_owned(), }; + info!("{}", z); // We prefer optimize variable change log10(theta) // as theta is used as exponent in objective function diff --git a/moe/src/surrogates.rs b/moe/src/surrogates.rs index ae40c18d..53537a9d 100644 --- a/moe/src/surrogates.rs +++ b/moe/src/surrogates.rs @@ -173,11 +173,12 @@ macro_rules! declare_surrogate { impl std::fmt::Display for [] { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}_{}{}", stringify!($regr), stringify!($corr), + write!(f, "{}_{}{}{}", stringify!($regr), stringify!($corr), match self.0.kpls_dim() { None => String::from(""), Some(dim) => format!("_PLS({})", dim), - } + }, + self.0.to_string() ) } } @@ -297,11 +298,12 @@ macro_rules! declare_sgp_surrogate { impl std::fmt::Display for [] { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}_{}{}", stringify!($regr), stringify!($corr), + write!(f, "{}{}{}", stringify!($corr), match self.0.kpls_dim() { None => String::from(""), Some(dim) => format!("_PLS({})", dim), - } + }, + self.0.to_string() ) } } diff --git a/python/egobox/tests/test_sgpmix.py b/python/egobox/tests/test_sgpmix.py index 72c74108..fa8ec8a2 100644 --- a/python/egobox/tests/test_sgpmix.py +++ b/python/egobox/tests/test_sgpmix.py @@ -39,6 +39,27 @@ def test_sgp(self): print(elapsed) sgp.save("sgp.json") + def test_sgp_random(self): + # random generator for reproducibility + rng = np.random.RandomState(0) + + # Generate training data + nt = 200 + # Variance of the gaussian noise on our trainingg data + eta2 = [0.01] + gaussian_noise = rng.normal(loc=0.0, scale=np.sqrt(eta2), size=(nt, 1)) + xt = 2 * rng.rand(nt, 1) - 1 + yt = f_obj(xt) + gaussian_noise + + # Pick inducing points randomly in training data + n_inducing = 30 + + start = time.time() + sgp = egx.SparseGpMix(nz=n_inducing, seed=0).fit(xt, yt) + elapsed = time.time() - start + print(elapsed) + print(sgp) + if __name__ == "__main__": import logging From f139e016ae68b3137f005c62133e67be17677fc5 Mon Sep 17 00:00:00 2001 From: relf Date: Wed, 31 Jan 2024 20:46:29 +0100 Subject: [PATCH 19/26] Fix moe display test --- moe/src/gp_algorithm.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/moe/src/gp_algorithm.rs b/moe/src/gp_algorithm.rs index 4dd9553a..60e2f63a 100644 --- a/moe/src/gp_algorithm.rs +++ b/moe/src/gp_algorithm.rs @@ -1207,7 +1207,9 @@ mod tests { #[test] fn test_moe_display() { let rng = Xoshiro256Plus::seed_from_u64(0); - let xt = Lhs::new(&array![[0., 1.]]).sample(100); + let xt = Lhs::new(&array![[0., 1.]]) + .with_rng(rng.clone()) + .sample(100); let yt = f_test_1d(&xt); let moe = GpMixture::params() @@ -1218,6 +1220,6 @@ mod tests { .with_rng(rng) .fit(&Dataset::new(xt, yt)) .expect("MOE fitted"); - assert_eq!("Mixture[Hard](Constant_SquaredExponential, Constant_SquaredExponential, Constant_SquaredExponential)", moe.to_string()); + assert_eq!("Mixture[Hard](Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.03871601282054056], variance=[0.276011431746834], likelihood=454.17113736397033), Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.07903503494417609], variance=[0.0077182164672893756], likelihood=436.39615700140183), Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.050821466014058826], variance=[0.32824998062969973], likelihood=193.19339252734846))", moe.to_string()); } } From 4c9ea541986467072090def80dce7a623e4eadfd Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 11:23:46 +0100 Subject: [PATCH 20/26] Make GP/SGP computation interruptible --- Cargo.toml | 1 + src/gp_mix.rs | 1 + src/sparse_gp_mix.rs | 1 + 3 files changed, 3 insertions(+) diff --git a/Cargo.toml b/Cargo.toml index 60d12d00..386c71ce 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -52,6 +52,7 @@ pyo3 = { version = "0.20.0", features = ["extension-module"] } pyo3-log = "0.9.0" serde = "1" serde_json = "1" +ctrlc = "3.4" [dev-dependencies] criterion = "0.4" diff --git a/src/gp_mix.rs b/src/gp_mix.rs index 32074ce9..e7954b02 100644 --- a/src/gp_mix.rs +++ b/src/gp_mix.rs @@ -156,6 +156,7 @@ impl GpMix { .expect("Theta tuning bounds"); } + ctrlc::set_handler(|| std::process::exit(2)).unwrap(); let moe = py.allow_threads(|| { GpMixture::params() .n_clusters(self.n_clusters) diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index 07b20e90..98ba95f9 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -160,6 +160,7 @@ impl SparseGpMix { .expect("Theta tuning bounds"); } + ctrlc::set_handler(|| std::process::exit(2)).unwrap(); let sgp = py.allow_threads(|| { SparseGpMixture::params(inducings) .correlation_spec( From a5c30846dc1b3e5f2ff1ea3efdc407d892d7c3f6 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 11:24:23 +0100 Subject: [PATCH 21/26] Fix double import --- python/egobox/tests/test_sgpmix.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/python/egobox/tests/test_sgpmix.py b/python/egobox/tests/test_sgpmix.py index fa8ec8a2..4b202111 100644 --- a/python/egobox/tests/test_sgpmix.py +++ b/python/egobox/tests/test_sgpmix.py @@ -62,8 +62,4 @@ def test_sgp_random(self): if __name__ == "__main__": - import logging - - logging.basicConfig(level=logging.DEBUG) - unittest.main() From 36ee40a3665a106f0b8987aa613167f5262bc9b3 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 11:25:45 +0100 Subject: [PATCH 22/26] Cleanup --- gp/src/sparse_algorithm.rs | 23 ----------------------- 1 file changed, 23 deletions(-) diff --git a/gp/src/sparse_algorithm.rs b/gp/src/sparse_algorithm.rs index da490d3a..9ba289df 100644 --- a/gp/src/sparse_algorithm.rs +++ b/gp/src/sparse_algorithm.rs @@ -430,7 +430,6 @@ impl, D: Data + Sync> Inducings::Randomized(n) => make_inducings(*n, &xtrain.view(), &mut rng), Inducings::Located(z) => z.to_owned(), }; - info!("{}", z); // We prefer optimize variable change log10(theta) // as theta is used as exponent in objective function @@ -509,28 +508,6 @@ impl, D: Data + Sync> "Optimize with multistart theta = {:?} and bounds = {:?}", params, bounds ); - println!( - "Optimize with multistart theta = {:?} and bounds = {:?}", - params, bounds - ); - - // let opt_params = params.map_axis(Axis(1), |p| { - // let now = Instant::now(); - // let opt_res = optimize_params( - // objfn, - // &p.to_owned(), - // &bounds, - // CobylaParams { - // maxeval: (10 * theta0_dim).max(CobylaParams::default().maxeval), - // ..CobylaParams::default() - // }, - // ); - // info!("elapsed optim = {:?}", now.elapsed().as_millis()); - // opt_res - // }); - // let opt_index = opt_params.map(|(_, opt_f)| opt_f).argmin().unwrap(); - // let opt_params = &(opt_params[opt_index]).0.mapv(|v| F::cast(base.powf(v))); - // println!("Normal opt_params={:?}", opt_params); let now = Instant::now(); let opt_params = (0..params.nrows()) .into_par_iter() From 726c0879dc80e11f3f429e3a835eef644ee205ca Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 11:49:33 +0100 Subject: [PATCH 23/26] Remove fallible assertion in moe display test --- moe/src/gp_algorithm.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/moe/src/gp_algorithm.rs b/moe/src/gp_algorithm.rs index 60e2f63a..d1dce6ee 100644 --- a/moe/src/gp_algorithm.rs +++ b/moe/src/gp_algorithm.rs @@ -1220,6 +1220,8 @@ mod tests { .with_rng(rng) .fit(&Dataset::new(xt, yt)) .expect("MOE fitted"); - assert_eq!("Mixture[Hard](Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.03871601282054056], variance=[0.276011431746834], likelihood=454.17113736397033), Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.07903503494417609], variance=[0.0077182164672893756], likelihood=436.39615700140183), Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.050821466014058826], variance=[0.32824998062969973], likelihood=193.19339252734846))", moe.to_string()); + // Values may vary depending on the platforms and linalg backends + // assert_eq!("Mixture[Hard](Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.03871601282054056], variance=[0.276011431746834], likelihood=454.17113736397033), Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.07903503494417609], variance=[0.0077182164672893756], likelihood=436.39615700140183), Constant_SquaredExponentialGP(mean=ConstantMean, corr=SquaredExponential, theta=[0.050821466014058826], variance=[0.32824998062969973], likelihood=193.19339252734846))", moe.to_string()); + println!("Display moe: {}", moe); } } From f826103ba5e1301480a1be48124091460d1057a0 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 15:21:49 +0100 Subject: [PATCH 24/26] Avoid ctrlc multiple handlers errors --- src/gp_mix.rs | 4 +++- src/sparse_gp_mix.rs | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/gp_mix.rs b/src/gp_mix.rs index e7954b02..4c39f8a1 100644 --- a/src/gp_mix.rs +++ b/src/gp_mix.rs @@ -156,7 +156,9 @@ impl GpMix { .expect("Theta tuning bounds"); } - ctrlc::set_handler(|| std::process::exit(2)).unwrap(); + if let Err(ctrlc::Error::MultipleHandlers) = ctrlc::set_handler(|| std::process::exit(2)) { + // ignore multiple handlers error + }; let moe = py.allow_threads(|| { GpMixture::params() .n_clusters(self.n_clusters) diff --git a/src/sparse_gp_mix.rs b/src/sparse_gp_mix.rs index 98ba95f9..c7d2b13e 100644 --- a/src/sparse_gp_mix.rs +++ b/src/sparse_gp_mix.rs @@ -160,7 +160,9 @@ impl SparseGpMix { .expect("Theta tuning bounds"); } - ctrlc::set_handler(|| std::process::exit(2)).unwrap(); + if let Err(ctrlc::Error::MultipleHandlers) = ctrlc::set_handler(|| std::process::exit(2)) { + // ignore multiple handlers error + }; let sgp = py.allow_threads(|| { SparseGpMixture::params(inducings) .correlation_spec( From cce24f7ec5f2cd742c7e04ee0e517097ba59ec81 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 15:51:27 +0100 Subject: [PATCH 25/26] Relax sgp noise test tolerance --- gp/src/sparse_algorithm.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gp/src/sparse_algorithm.rs b/gp/src/sparse_algorithm.rs index 9ba289df..e28aff28 100644 --- a/gp/src/sparse_algorithm.rs +++ b/gp/src/sparse_algorithm.rs @@ -946,7 +946,7 @@ mod tests { println!("theta={:?}", sgp.theta()); println!("variance={:?}", sgp.variance()); println!("noise variance={:?}", sgp.noise_variance()); - assert_abs_diff_eq!(eta2, sgp.noise_variance(), epsilon = 0.01); + assert_abs_diff_eq!(eta2, sgp.noise_variance(), epsilon = 0.015); assert_abs_diff_eq!(&z, sgp.inducings(), epsilon = 0.0015); let sgp_vals = sgp.predict_values(&xplot).unwrap(); From ae62ce6c0979fed44b73b9c4022b9d1fd0f9bc10 Mon Sep 17 00:00:00 2001 From: relf Date: Thu, 1 Feb 2024 16:23:37 +0100 Subject: [PATCH 26/26] Add parallel multistart to GP --- gp/src/algorithm.rs | 55 +++++++++++++++++++++++--------------- gp/src/sparse_algorithm.rs | 8 +++--- 2 files changed, 37 insertions(+), 26 deletions(-) diff --git a/gp/src/algorithm.rs b/gp/src/algorithm.rs index dd452a35..8177610d 100644 --- a/gp/src/algorithm.rs +++ b/gp/src/algorithm.rs @@ -16,15 +16,17 @@ use ndarray_einsum_beta::*; #[cfg(feature = "blas")] use ndarray_linalg::{cholesky::*, eigh::*, qr::*, svd::*, triangular::*}; use ndarray_rand::rand::{Rng, SeedableRng}; +use ndarray_rand::rand_distr::Normal; +use ndarray_rand::RandomExt; use ndarray_stats::QuantileExt; +use log::debug; use rand_xoshiro::Xoshiro256Plus; +use rayon::prelude::*; #[cfg(feature = "serializable")] use serde::{Deserialize, Serialize}; use std::fmt; - -use ndarray_rand::rand_distr::Normal; -use ndarray_rand::RandomExt; +use std::time::Instant; pub(crate) struct CobylaParams { pub rhobeg: f64, @@ -857,27 +859,38 @@ impl, Corr: CorrelationModel, D: Data, D: Data + Sync> &self, dataset: &DatasetBase, ArrayBase>, ) -> Result { - info!("SGP fit with {:?}", self.method()); let x = dataset.records(); let y = dataset.targets(); if let Some(d) = self.kpls_dim() { @@ -504,7 +503,7 @@ impl, D: Data + Sync> *noise_bounds = (lo.log10(), up.log10()); } } - info!( + debug!( "Optimize with multistart theta = {:?} and bounds = {:?}", params, bounds ); @@ -528,9 +527,8 @@ impl, D: Data + Sync> || (Array::ones((params.ncols(),)), f64::INFINITY), |a, b| if b.1 < a.1 { b } else { a }, ); - info!("elapsed optim = {:?}", now.elapsed().as_millis()); + debug!("elapsed optim = {:?}", now.elapsed().as_millis()); let opt_params = opt_params.0.mapv(|v| F::cast(base.powf(v))); - println!("Parallel opt_params={:?}", opt_params); let opt_theta = opt_params .slice(s![..n - 1 - is_noise_estimated as usize]) .to_owned();