#[allow(
unused_imports,
reason = "a split file takes its parent's imports whole; each uses some"
)]
use super::*;
pub(crate) struct SparseSpec<U: Supply = NoSupply> {
pub(crate) kernel: KernelSpec<U>,
pub(crate) likelihood: GaussianLikelihood,
pub(crate) math: KernelExp,
pub(crate) jitter: JitterPolicy,
pub(crate) x_transform: Box<dyn UnfittedTransform>,
pub(crate) y_transform: Box<dyn UnfittedTarget>,
}
impl<U: Supply> Clone for SparseSpec<U> {
fn clone(&self) -> Self {
Self {
kernel: self.kernel.clone(),
likelihood: self.likelihood,
math: self.math,
jitter: self.jitter,
x_transform: self.x_transform.clone_box(),
y_transform: self.y_transform.clone_box(),
}
}
}
impl<U: Supply> fmt::Debug for SparseSpec<U> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SparseSpec")
.field("kernel", &self.kernel)
.field("likelihood", &self.likelihood)
.field("math", &self.math)
.field("jitter", &self.jitter)
.finish_non_exhaustive()
}
}
impl<U: Supply> SparseSpec<U> {
pub(crate) fn new(kernel: KernelSpec<U>, likelihood: GaussianLikelihood) -> Self {
Self {
kernel,
likelihood,
math: KernelExp::default(),
jitter: default_k_mm_jitter(),
x_transform: Box::new(IdentityInput),
y_transform: Box::new(IdentityTarget),
}
}
pub(crate) fn theta_len(&self) -> usize {
theta_len(&self.kernel, &self.likelihood)
}
pub(crate) fn read_theta(&self, out: &mut [f64]) -> Result<(), GprError> {
write_params(&self.kernel, &self.likelihood, out)
}
pub(crate) fn write_theta(&mut self, params: &[f64]) -> Result<(), GprError> {
crate::data::require_count(params.len(), self.theta_len(), "parameters")?;
let (kernel, likelihood) = stage_theta(&self.kernel, &self.likelihood, params)?;
self.kernel = kernel;
self.likelihood = likelihood;
Ok(())
}
}
pub(crate) struct PersistedSparse<U: Supply = NoSupply> {
pub(crate) spec: SparseSpec<U>,
pub(crate) x_transform: Box<dyn Transform>,
pub(crate) y_transform: Box<dyn TargetTransform>,
pub(crate) x_obs: Vec<f64>,
pub(crate) y_obs: Vec<f64>,
pub(crate) z_obs: Vec<f64>,
pub(crate) z_train: Vec<f64>,
pub(crate) n: usize,
pub(crate) m: usize,
pub(crate) d: usize,
pub(crate) supplied: <U as SupplyViews>::Held<SparseSupplied>,
}
pub(crate) fn squares_of<'a, T: KernelScalar, U: Supply>(
store: <U as SupplyViews>::Held<&'a BlockStore<T>>,
) -> U::Squares<'a, T> {
U::held_squares(store)
}
pub(crate) fn rects_of<'a, T: KernelScalar, U: Supply>(
store: <U as SupplyViews>::Held<&'a BlockStore<T>>,
) -> U::Rects<'a, T> {
U::held_rects(store)
}
#[derive(Clone, Debug, Default)]
pub(crate) struct SparseSupplied {
pub(crate) supply: SparseSupply,
pub(crate) slots: Vec<crate::kernel::DistanceSlot>,
}
pub(crate) struct SparseData<'a, U: Supply> {
pub(crate) x: &'a [f64],
pub(crate) n: usize,
pub(crate) d: usize,
pub(crate) y: &'a [f64],
pub(crate) z: &'a [f64],
pub(crate) m: usize,
pub(crate) supply: <U as SupplyViews>::Held<&'a SparseSupply>,
}
impl<U: Supply> Clone for SparseData<'_, U> {
fn clone(&self) -> Self {
Self {
supply: self.supply.clone(),
..*self
}
}
}
impl<U: Supply> SparseData<'_, U> {
pub(crate) fn validate(&self) -> Result<(), GprError> {
if self.d == 0 && U::held(&self.supply).is_some() {
crate::data::require_nonempty(self.n)?;
crate::data::require_nonempty(self.m)?;
crate::data::require_count(self.x.len(), 0, "feature values")?;
crate::data::require_count(self.z.len(), 0, "inducing feature values")?;
crate::data::require_count(self.y.len(), self.n, "targets")?;
return crate::data::require_finite(self.y);
}
validate_training(self.x, self.n, self.d, self.y)?;
validate_inducing(self.z, self.m, self.d)
}
pub(crate) fn validate_inducing(&self) -> Result<(), GprError> {
if self.d == 0 && U::held(&self.supply).is_some() {
crate::data::require_nonempty(self.m)?;
return crate::data::require_count(self.z.len(), 0, "inducing feature values");
}
validate_inducing(self.z, self.m, self.d)
}
}
pub(crate) struct SparseSets<'a, T: KernelScalar, U: Supply> {
pub(crate) x: MatRef<'a, T>,
pub(crate) z: MatRef<'a, T>,
pub(crate) zz: U::Squares<'a, T>,
pub(crate) xz: U::Rects<'a, T>,
}
impl<T: KernelScalar, U: Supply> Clone for SparseSets<'_, T, U> {
fn clone(&self) -> Self {
*self
}
}
impl<T: KernelScalar, U: Supply> Copy for SparseSets<'_, T, U> {}
impl<'a, T: KernelScalar, U: Supply> SparseSets<'a, T, U> {
pub(crate) fn new<'s: 'a>(
x: MatRef<'a, T>,
z: MatRef<'a, T>,
at: <U as SupplyViews>::Held<&'s SupplyAt<T>>,
) -> Self {
Self {
x,
z,
zz: U::shorter_squares(squares_of::<T, U>(U::map_held(at.clone(), |at| &at.zz))),
xz: U::shorter_rects(rects_of::<T, U>(U::map_held(at, |at| &at.xz))),
}
}
pub(crate) fn k_mm(&self) -> GramInputs<'a, T, U> {
GramInputs::supplied(self.z, self.zz)
}
pub(crate) fn k_nm(&self) -> CrossViews<'a, T, U> {
CrossViews {
x1: self.x,
x2: self.z,
dist: None,
slots: self.xz,
}
}
}
pub(crate) struct SparseCore<U: Supply = NoSupply> {
pub(crate) kernel: KernelSpec<U>,
pub(crate) likelihood: GaussianLikelihood,
pub(crate) math: KernelExp,
pub(crate) jitter: JitterPolicy,
pub(crate) x_unfitted: Box<dyn UnfittedTransform>,
pub(crate) y_unfitted: Box<dyn UnfittedTarget>,
pub(crate) x_transform: Box<dyn Transform>,
pub(crate) y_transform: Box<dyn TargetTransform>,
pub(crate) x_obs: Vec<f64>,
pub(crate) z_obs: Vec<f64>,
pub(crate) y_obs: Vec<f64>,
pub(crate) x_train: Vec<f64>,
pub(crate) z_train: Vec<f64>,
pub(crate) y_train: Vec<f64>,
pub(crate) n: usize,
pub(crate) m: usize,
pub(crate) d: usize,
pub(crate) supplied: <U as SupplyViews>::Held<SparseSupplied>,
}
impl<U: Supply> Clone for SparseCore<U> {
fn clone(&self) -> Self {
Self {
kernel: self.kernel.clone(),
likelihood: self.likelihood,
math: self.math,
jitter: self.jitter,
x_unfitted: self.x_unfitted.clone_box(),
y_unfitted: self.y_unfitted.clone_box(),
x_transform: self.x_transform.clone_box(),
y_transform: self.y_transform.clone_box(),
x_obs: self.x_obs.clone(),
z_obs: self.z_obs.clone(),
y_obs: self.y_obs.clone(),
x_train: self.x_train.clone(),
z_train: self.z_train.clone(),
y_train: self.y_train.clone(),
n: self.n,
m: self.m,
d: self.d,
supplied: self.supplied.clone(),
}
}
}
impl<U: Supply> fmt::Debug for SparseCore<U> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SparseCore")
.field("kernel", &self.kernel)
.field("likelihood", &self.likelihood)
.field("math", &self.math)
.field("jitter", &self.jitter)
.field("n", &self.n)
.field("m", &self.m)
.field("d", &self.d)
.finish_non_exhaustive()
}
}
impl SparseCore {
#[allow(clippy::too_many_arguments)]
pub(crate) fn prepare(
spec: &SparseSpec,
x: &[f64],
n_rows: usize,
n_cols: usize,
y: &[f64],
z: &[f64],
n_inducing: usize,
) -> Result<Self, GprError> {
validate_training(x, n_rows, n_cols, y)?;
validate_inducing(z, n_inducing, n_cols)?;
let x_transform = spec.x_transform.clone_box().fit(x, n_rows, n_cols)?;
let y_transform = spec.y_transform.clone_box().fit(y)?;
let mut x_train = x.to_vec();
x_transform.apply(&mut x_train, n_rows, n_cols)?;
let mut z_train = z.to_vec();
x_transform.apply(&mut z_train, n_inducing, n_cols)?;
let mut y_train = y.to_vec();
y_transform.transform(&mut y_train)?;
Ok(Self {
kernel: spec.kernel.clone(),
likelihood: spec.likelihood,
math: spec.math,
jitter: spec.jitter,
x_unfitted: spec.x_transform.clone_box(),
y_unfitted: spec.y_transform.clone_box(),
x_transform,
y_transform,
x_obs: x.to_vec(),
z_obs: z.to_vec(),
y_obs: y.to_vec(),
x_train,
z_train,
y_train,
n: n_rows,
m: n_inducing,
d: n_cols,
supplied: (),
})
}
}
impl<U: Supply> SparseCore<U> {
pub(crate) fn from_persisted(parts: PersistedSparse<U>) -> Result<Self, GprError> {
let PersistedSparse {
spec,
x_transform,
y_transform,
x_obs,
y_obs,
z_obs,
z_train,
n,
m,
d,
supplied,
} = parts;
if d == 0 {
crate::data::require_nonempty(n)?;
crate::data::require_nonempty(m)?;
crate::data::require_count(x_obs.len(), 0, "feature values")?;
crate::data::require_count(z_obs.len(), 0, "inducing values")?;
crate::data::require_count(z_train.len(), 0, "inducing values")?;
crate::data::require_count(y_obs.len(), n, "targets")?;
crate::data::require_finite(&y_obs)?;
} else {
validate_training(&x_obs, n, d, &y_obs)?;
validate_inducing(&z_obs, m, d)?;
validate_inducing(&z_train, m, d)?;
}
let mut x_train = x_obs.clone();
if d > 0 {
x_transform.apply(&mut x_train, n, d)?;
}
let mut y_train = y_obs.clone();
y_transform.transform(&mut y_train)?;
crate::data::require_finite(&x_train)?;
crate::data::require_finite(&y_train)?;
crate::data::require_finite(&z_train)?;
Ok(Self {
kernel: spec.kernel,
likelihood: spec.likelihood,
math: spec.math,
jitter: spec.jitter,
x_unfitted: spec.x_transform,
y_unfitted: spec.y_transform,
x_transform,
y_transform,
x_obs,
z_obs,
y_obs,
x_train,
z_train,
y_train,
n,
m,
d,
supplied,
})
}
pub(crate) fn prepare_supplied<'s, S: KernelScalar>(
spec: &SparseSpec<U>,
sources: impl IntoIterator<Item = crate::kernel::DistanceSource<'s>>,
n: usize,
(x, n_cols): (&[f64], usize),
y: &[f64],
inducing: &[usize],
) -> Result<Self, GprError> {
crate::data::require_nonempty(n)?;
crate::data::require_nonempty(inducing.len())?;
let m = inducing.len();
if n_cols == 0 {
crate::data::require_count(x.len(), 0, "feature values")?;
crate::data::require_count(y.len(), n, "targets")?;
crate::data::require_finite(y)?;
} else {
validate_training(x, n, n_cols, y)?;
}
let supplied = U::try_hold(|| {
let slots = crate::kernel::spec_slots(&spec.kernel);
let supply = SparseSupply::bind::<S>(&slots, sources, n, inducing)?;
Ok::<_, GprError>(SparseSupplied { supply, slots })
})?;
let mut z_obs = Vec::with_capacity(m * n_cols);
for j in 0..n_cols {
z_obs.extend(inducing.iter().map(|&i| x[j * n + i]));
}
let x_transform: Box<dyn Transform> = if n_cols == 0 {
Box::new(IdentityInput)
} else {
spec.x_transform.clone_box().fit(x, n, n_cols)?
};
let y_transform = spec.y_transform.clone_box().fit(y)?;
let mut x_train = x.to_vec();
let mut z_train = z_obs.clone();
if n_cols > 0 {
x_transform.apply(&mut x_train, n, n_cols)?;
x_transform.apply(&mut z_train, m, n_cols)?;
}
let mut y_train = y.to_vec();
y_transform.transform(&mut y_train)?;
Ok(Self {
kernel: spec.kernel.clone(),
likelihood: spec.likelihood,
math: spec.math,
jitter: spec.jitter,
x_unfitted: spec.x_transform.clone_box(),
y_unfitted: spec.y_transform.clone_box(),
x_transform,
y_transform,
x_obs: x.to_vec(),
z_obs,
y_obs: y.to_vec(),
x_train,
z_train,
y_train,
n,
m,
d: n_cols,
supplied,
})
}
pub(crate) fn data(&self) -> SparseData<'_, U> {
SparseData {
x: &self.x_train,
n: self.n,
d: self.d,
y: &self.y_train,
z: &self.z_train,
m: self.m,
supply: self.supply_held(),
}
}
pub(crate) fn supply(&self) -> Option<&SparseSupply> {
U::held(&self.supplied).map(|held| &held.supply)
}
pub(crate) fn supply_held(&self) -> <U as SupplyViews>::Held<&SparseSupply> {
U::map_held(U::held_ref(&self.supplied), |held| &held.supply)
}
pub(crate) fn supply_mut(&mut self) -> Option<&mut SparseSupply> {
U::held_mut(&mut self.supplied).map(|held| &mut held.supply)
}
pub(crate) fn slots(&self) -> &[crate::kernel::DistanceSlot] {
U::held(&self.supplied).map_or(&[], |held| &held.slots)
}
pub(crate) fn theta_len(&self) -> usize {
theta_len(&self.kernel, &self.likelihood)
}
pub(crate) fn read_theta(&self, out: &mut [f64]) -> Result<(), GprError> {
write_params(&self.kernel, &self.likelihood, out)
}
pub(crate) fn stage_theta(
&self,
params: &[f64],
) -> Result<(KernelSpec<U>, GaussianLikelihood), GprError> {
stage_theta(&self.kernel, &self.likelihood, params)
}
pub(crate) fn theta_intervals(&self, out: &mut [Interval]) -> Result<(), GprError> {
let n_kernel = self.kernel.num_params();
crate::data::require_count(out.len(), self.theta_len(), "intervals")?;
let mut offset = 0;
self.kernel
.write_intervals(&mut out[..n_kernel], &mut offset)?;
out[n_kernel] = self.likelihood.bounds();
Ok(())
}
pub(crate) fn inducing_obs(&self, z: &[f64], rows: usize) -> Result<Vec<f64>, GprError> {
let mut z_obs = z.to_vec();
self.x_transform.inverse_apply(&mut z_obs, rows, self.d)?;
Ok(z_obs)
}
pub(crate) fn map_point(&self, point: &[f64], out: &mut Vec<f64>) -> Result<(), GprError> {
out.clear();
out.extend_from_slice(point);
if self.d == 0 {
return Ok(());
}
self.x_transform.apply(out, 1, self.d)
}
pub(crate) fn map_target(&self, target: f64) -> Result<f64, GprError> {
let mut mapped = [target];
self.y_transform.transform(&mut mapped)?;
Ok(mapped[0])
}
pub(crate) fn map_query_into(
&self,
xs: &[f64],
n_rows: usize,
n_cols: usize,
out: &mut Vec<f64>,
) -> Result<(), GprError> {
if n_cols != self.d {
return Err(GprError::DimensionMismatch {
x_dim: n_cols,
expected_dim: self.d,
});
}
out.clear();
if n_cols == 0 {
crate::data::require_nonempty(n_rows)?;
return crate::data::require_count(xs.len(), 0, "query feature values");
}
validate_query(xs, n_rows, n_cols)?;
out.extend_from_slice(xs);
self.x_transform.apply(out, n_rows, n_cols)
}
pub(crate) fn inverse_prediction_in_place<P: ModelPrecision>(
&self,
prediction: &mut Prediction<P::Refine>,
buffers: &mut InverseBuffers,
) -> Result<(), GprError> {
P::inverse_mean_variance(
self.y_transform.as_ref(),
&mut prediction.mean,
&mut prediction.variance,
buffers,
)
}
pub(crate) fn finish_covariance<P: ModelPrecision, S: KernelScalar>(
&self,
latent: MatRef<'_, S>,
mut pred: Prediction<P::Refine>,
) -> Result<PredictiveCovariance<P::Refine>, GprError> {
let q = pred.mean.len();
let mut covariance = vec![P::Refine::from_f64(0.0); q * q];
for col in 0..q {
for row in 0..q {
covariance[col * q + row] = if row == col {
pred.variance[row]
} else {
P::Refine::from_f64(latent[(row, col)].to_f64())
};
}
}
P::inverse_covariance(self.y_transform.as_ref(), &mut covariance)?;
self.inverse_prediction_in_place::<P>(&mut pred, &mut InverseBuffers::default())?;
for (i, variance) in pred.variance.iter().enumerate() {
covariance[i * q + i] = *variance;
}
Ok(PredictiveCovariance {
mean: pred.mean,
covariance,
variance_kind: pred.variance_kind,
})
}
pub(crate) fn spec(&self) -> SparseSpec<U> {
SparseSpec {
kernel: self.kernel.clone(),
likelihood: self.likelihood,
math: self.math,
jitter: self.jitter,
x_transform: self.x_unfitted.clone_box(),
y_transform: self.y_unfitted.clone_box(),
}
}
}
pub(super) fn theta_len<U: Supply>(
kernel: &KernelSpec<U>,
likelihood: &GaussianLikelihood,
) -> usize {
kernel.num_params() + likelihood.num_params()
}
pub(super) fn stage_theta<U: Supply>(
kernel: &KernelSpec<U>,
likelihood: &GaussianLikelihood,
params: &[f64],
) -> Result<(KernelSpec<U>, GaussianLikelihood), GprError> {
let n_kernel = kernel.num_params();
let n_theta = theta_len(kernel, likelihood);
crate::data::require_count(params.len(), n_theta, "parameters")?;
let mut kernel = kernel.clone();
kernel.set_params(¶ms[..n_kernel])?;
let mut likelihood = *likelihood;
likelihood.set_params(¶ms[n_kernel..])?;
Ok((kernel, likelihood))
}
pub(crate) fn default_k_mm_jitter() -> JitterPolicy {
JitterPolicy::Adaptive(AdaptiveJitter::K_MM_DEFAULT)
}