use std::fmt;
use dyn_stack::MemBuffer;
use faer::{Mat, MatMut, MatRef};
use crate::data::{validate_inducing, validate_query, validate_training};
use crate::error::GprError;
use crate::kernel::KernelSpec;
use crate::kernel::{CompiledKernel, DiagAccum, GramInputs, KernelScalar, Triangle, WeightedWalk};
use crate::likelihood::GaussianLikelihood;
use crate::param::{Interval, write_params};
use crate::policy::KernelExp;
use crate::policy::{AdaptiveJitter, JitterPolicy};
use crate::precision::{InverseBuffers, ModelPrecision};
use crate::prediction::{Prediction, PredictiveCovariance};
use crate::transform::{
IdentityInput, IdentityTarget, TargetTransform, Transform, UnfittedTarget, UnfittedTransform,
};
pub(crate) struct SparseSpec {
pub(crate) kernel: KernelSpec,
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 Clone for SparseSpec {
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 fmt::Debug for SparseSpec {
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 SparseSpec {
pub(crate) fn new(kernel: KernelSpec, 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 {
pub(crate) spec: SparseSpec,
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) struct SparseCore {
pub(crate) kernel: KernelSpec,
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,
}
impl Clone for SparseCore {
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,
}
}
}
impl fmt::Debug for SparseCore {
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,
})
}
pub(crate) fn from_persisted(parts: PersistedSparse) -> Result<Self, GprError> {
let PersistedSparse {
spec,
x_transform,
y_transform,
x_obs,
y_obs,
z_obs,
z_train,
n,
m,
d,
} = parts;
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();
x_transform.apply(&mut x_train, n, d)?;
let mut y_train = y_obs.clone();
y_transform.transform(&mut y_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,
})
}
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, 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);
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,
});
}
validate_query(xs, n_rows, n_cols)?;
out.clear();
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 {
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(),
}
}
}
fn theta_len(kernel: &KernelSpec, likelihood: &GaussianLikelihood) -> usize {
kernel.num_params() + likelihood.num_params()
}
fn stage_theta(
kernel: &KernelSpec,
likelihood: &GaussianLikelihood,
params: &[f64],
) -> Result<(KernelSpec, 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))
}
macro_rules! sparse_core_accessors {
() => {
$crate::sparse::sparse_core_accessors!(core);
};
($($core:ident).+) => {
pub fn n(&self) -> usize {
self.$($core).+.n
}
pub fn m(&self) -> usize {
self.$($core).+.m
}
pub fn d(&self) -> usize {
self.$($core).+.d
}
pub fn kernel(&self) -> &$crate::kernel::KernelSpec {
&self.$($core).+.kernel
}
pub fn likelihood(&self) -> &$crate::GaussianLikelihood {
&self.$($core).+.likelihood
}
pub fn jitter_policy(&self) -> $crate::JitterPolicy {
self.$($core).+.jitter
}
pub fn math(&self) -> $crate::KernelExp {
self.$($core).+.math
}
pub fn x(&self) -> &[f64] {
&self.$($core).+.x_obs
}
pub fn z(&self) -> &[f64] {
&self.$($core).+.z_obs
}
pub fn y(&self) -> &[f64] {
&self.$($core).+.y_obs
}
};
}
pub(crate) use sparse_core_accessors;
pub(crate) fn default_k_mm_jitter() -> JitterPolicy {
JitterPolicy::Adaptive(AdaptiveJitter::K_MM_DEFAULT)
}
pub(crate) struct KernelScratch<T> {
scratch: Mat<T>,
nested: Vec<Mat<T>>,
dist: Mat<T>,
square: Vec<Mat<T>>,
cross: Vec<Mat<T>>,
partial: Vec<f64>,
jobs: Vec<f64>,
diag: DiagAccum<T>,
}
impl<T> Clone for KernelScratch<T> {
fn clone(&self) -> Self {
Self {
scratch: Mat::new(),
nested: Vec::new(),
dist: Mat::new(),
square: Vec::new(),
cross: Vec::new(),
partial: Vec::new(),
jobs: Vec::new(),
diag: DiagAccum::new(),
}
}
}
impl<T> std::fmt::Debug for KernelScratch<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("KernelScratch").finish_non_exhaustive()
}
}
impl<T: KernelScalar> Default for KernelScratch<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: KernelScalar> KernelScratch<T> {
pub(crate) fn new() -> Self {
Self {
scratch: Mat::new(),
nested: Vec::new(),
dist: Mat::new(),
square: Vec::new(),
cross: Vec::new(),
partial: Vec::new(),
jobs: Vec::new(),
diag: DiagAccum::new(),
}
}
pub(crate) fn gram<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
inputs: GramInputs<'_, T>,
out: MatMut<'_, T>,
uplo: Triangle,
) -> Result<(), GprError> {
let scratch = view(&mut self.scratch, out.nrows(), out.ncols());
compiled.eval_gram::<M>(inputs, out, uplo, scratch, &mut self.nested)
}
pub(crate) fn grad<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
inputs: GramInputs<'_, T>,
d_k: MatMut<'_, T>,
param_idx: usize,
uplo: Triangle,
) -> Result<(), GprError> {
let scratch = view(&mut self.scratch, d_k.nrows(), d_k.ncols());
compiled.grad_gram::<M>(inputs, d_k, param_idx, uplo, scratch, &mut self.nested)
}
pub(crate) fn hess<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
inputs: GramInputs<'_, T>,
d2_k: MatMut<'_, T>,
pair: (usize, usize),
uplo: Triangle,
) -> Result<(), GprError> {
let scratch = view(&mut self.scratch, d2_k.nrows(), d2_k.ncols());
compiled.hess_gram::<M>(inputs, d2_k, pair, uplo, scratch, &mut self.nested)
}
pub(crate) fn cross_into<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
x: MatRef<'_, T>,
xs: MatRef<'_, T>,
out: MatMut<'_, T>,
) -> Result<(), GprError> {
let (rows, cols) = (out.nrows(), out.ncols());
let dist = view(&mut self.dist, rows, cols);
let scratch = view(&mut self.scratch, rows, cols);
compiled.eval_cross::<M>(x, xs, Some(dist), out, scratch, &mut self.nested, &mut [])
}
pub(crate) fn cross<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
x: MatRef<'_, T>,
xs: MatRef<'_, T>,
) -> Result<Mat<T>, GprError> {
let mut out = Mat::zeros(x.nrows(), xs.nrows());
self.cross_into::<M>(compiled, x, xs, out.as_mut())?;
Ok(out)
}
pub(crate) fn write_square_contraction<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
x: MatRef<'_, T>,
weight: MatRef<'_, T>,
out: &mut [f64],
) -> Result<(), GprError> {
let m = x.nrows();
let reads = compiled.reads_distances()?;
let KernelScratch {
scratch,
nested,
dist,
square,
jobs,
..
} = self;
if reads {
let mut filled = view(dist, m, m);
let mut none: [Mat<T>; 0] = [];
T::write_squared(x, filled.as_mut(), &mut none);
}
let dist_view = reads.then(|| dist.as_ref().submatrix(0, 0, m, m));
let nbuf = compiled.contraction_buffers();
fit_exact(square, nbuf, m, m);
crate::kernel::ensure_nested_levels(nested, compiled, m, m);
let mut walk = WeightedWalk {
inputs: GramInputs {
x,
dist: dist_view,
ard: None,
},
scratch: view(scratch, m, m),
nested,
kept: &[],
kept_products: 0,
fold: jobs,
};
compiled.weighted_grads::<M>(&mut walk, weight, out, &mut square[..nbuf])
}
pub(crate) fn add_cross_contraction<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
x1: MatRef<'_, T>,
x2: MatRef<'_, T>,
weight: MatRef<'_, T>,
coeff: f64,
out: &mut [f64],
) -> Result<(), GprError> {
let n_params = compiled.num_params();
let (rows, cols) = (weight.nrows(), weight.ncols());
let nbuf = compiled.contraction_buffers();
let KernelScratch {
scratch,
nested,
cross,
partial,
jobs,
..
} = self;
if partial.len() < n_params {
partial.resize(n_params, 0.0);
}
fit_exact(cross, nbuf, rows, cols);
crate::kernel::ensure_nested_levels(nested, compiled, rows, cols);
compiled.weighted_cross_grads::<M>(
x1,
x2,
weight,
&mut partial[..n_params],
&mut cross[..nbuf],
view(scratch, rows, cols),
nested,
jobs,
)?;
for (slot, part) in out.iter_mut().zip(partial.iter()) {
*slot += coeff * part;
}
Ok(())
}
pub(crate) fn add_diag_contraction<M: crate::math::KernelMath>(
&mut self,
compiled: &CompiledKernel<T>,
x: MatRef<'_, T>,
coeff: f64,
out: &mut [f64],
) -> Result<(), GprError> {
let n_params = compiled.num_params();
let KernelScratch { partial, diag, .. } = self;
if partial.len() < n_params {
partial.resize(n_params, 0.0);
}
compiled.weighted_diag_sums::<M>(x, &mut partial[..n_params], diag)?;
for (slot, part) in out.iter_mut().zip(partial.iter()) {
*slot += coeff * part;
}
Ok(())
}
pub(crate) fn scratch(&mut self, rows: usize, cols: usize) -> MatMut<'_, T> {
view(&mut self.scratch, rows, cols)
}
}
fn fit_exact<T: KernelScalar>(pool: &mut Vec<Mat<T>>, count: usize, rows: usize, cols: usize) {
if pool.len() < count {
pool.resize_with(count, Mat::new);
}
for mat in &mut pool[..count] {
if mat.nrows() != rows || mat.ncols() != cols {
*mat = Mat::zeros(rows, cols);
}
}
}
pub(crate) fn view<T: KernelScalar>(buf: &mut Mat<T>, rows: usize, cols: usize) -> MatMut<'_, T> {
if buf.nrows() < rows || buf.ncols() < cols {
*buf = Mat::zeros(rows.max(buf.nrows()), cols.max(buf.ncols()));
}
buf.as_mut().submatrix_mut(0, 0, rows, cols)
}
pub(crate) struct KernelPlan<S: KernelScalar>(Option<(KernelSpec, CompiledKernel<S>)>);
impl<S: KernelScalar> KernelPlan<S> {
pub(crate) fn get(&mut self, kernel: &KernelSpec) -> &CompiledKernel<S> {
if !matches!(&self.0, Some((spec, _)) if spec == kernel) {
self.0 = None;
}
&self
.0
.get_or_insert_with(|| (kernel.clone(), kernel.compile_as::<S>()))
.1
}
}
pub(crate) struct PredictBuffers<S: KernelScalar> {
pub(crate) kernel: KernelScratch<S>,
pub(crate) z: Mat<S>,
pub(crate) query: Mat<S>,
pub(crate) k_sz: Mat<S>,
pub(crate) solved: Mat<S>,
pub(crate) kss: Vec<S>,
pub(crate) column: Vec<S>,
}
impl<S: KernelScalar> Default for PredictBuffers<S> {
fn default() -> Self {
Self {
kernel: KernelScratch::new(),
z: Mat::new(),
query: Mat::new(),
k_sz: Mat::new(),
solved: Mat::new(),
kss: Vec::new(),
column: Vec::new(),
}
}
}
pub(crate) fn pack_into<'a, S: KernelScalar>(
buf: &'a mut Mat<S>,
x: &[f64],
rows: usize,
d: usize,
) -> MatMut<'a, S> {
let mut out = view(buf, rows, d);
crate::data::pack_storage(x, rows, d, out.as_mut());
out
}
pub(crate) struct PredictScratch<S: KernelScalar> {
pub(crate) xs: Vec<f64>,
pub(crate) inverse: InverseBuffers,
pub(crate) plan: KernelPlan<S>,
pub(crate) storage: PredictBuffers<S>,
pub(crate) plan64: KernelPlan<f64>,
pub(crate) f64: PredictBuffers<f64>,
pub(crate) k_mm64: Mat<f64>,
pub(crate) k_mm64_backup: Mat<f64>,
pub(crate) llt64: Option<(usize, MemBuffer)>,
pub(crate) b_l64: Mat<f64>,
pub(crate) w64: Vec<f64>,
}
impl<S: KernelScalar> Default for PredictScratch<S> {
fn default() -> Self {
Self {
xs: Vec::new(),
inverse: InverseBuffers::default(),
plan: KernelPlan(None),
storage: PredictBuffers::default(),
plan64: KernelPlan(None),
f64: PredictBuffers::default(),
k_mm64: Mat::new(),
k_mm64_backup: Mat::new(),
llt64: None,
b_l64: Mat::new(),
w64: Vec::new(),
}
}
}
impl<S: KernelScalar> Clone for PredictScratch<S> {
fn clone(&self) -> Self {
Self::default()
}
}
impl<S: KernelScalar> fmt::Debug for PredictScratch<S> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("PredictScratch").finish_non_exhaustive()
}
}
impl<S: KernelScalar> PredictScratch<S> {
pub(crate) fn llt64(llt: &mut Option<(usize, MemBuffer)>, m: usize) -> &mut MemBuffer {
if matches!(llt, Some((size, _)) if *size != m) {
*llt = None;
}
&mut llt
.get_or_insert_with(|| (m, crate::linalg::llt_scratch::<f64>(m)))
.1
}
pub(crate) fn f64_system<M: crate::math::KernelMath>(
&mut self,
kernel: &KernelSpec,
z: &[f64],
m: usize,
d: usize,
jitter: JitterPolicy,
) -> Result<F64System<'_>, GprError> {
let Self {
plan64,
f64: bufs,
k_mm64,
k_mm64_backup,
llt64,
b_l64,
w64,
..
} = self;
let compiled = plan64.get(kernel);
if k_mm64.nrows() != m || k_mm64.ncols() != m {
*k_mm64 = Mat::zeros(m, m);
}
let z64 = pack_into(&mut bufs.z, z, m, d);
bufs.kernel.gram::<M>(
compiled,
GramInputs::points(z64.as_ref()),
k_mm64.as_mut(),
Triangle::Lower,
)?;
crate::linalg::cholesky_lower_with_backup(
k_mm64,
k_mm64_backup,
Self::llt64(llt64, m),
jitter.retry_jitters(),
crate::error::CholeskyStage::Predict,
)?;
Ok(F64System {
compiled,
bufs,
k_mm_l: k_mm64.as_ref(),
b_l64,
w64,
})
}
}
pub(crate) struct F64System<'a> {
pub(crate) compiled: &'a CompiledKernel<f64>,
pub(crate) bufs: &'a mut PredictBuffers<f64>,
pub(crate) k_mm_l: MatRef<'a, f64>,
pub(crate) b_l64: &'a mut Mat<f64>,
pub(crate) w64: &'a mut Vec<f64>,
}
pub(crate) fn reset_prediction<R: KernelScalar>(
out: &mut Prediction<R>,
n_rows: usize,
kind: crate::VarianceKind,
) {
let zero = R::from_f64(0.0);
out.mean.clear();
out.mean.resize(n_rows, zero);
out.variance.clear();
out.variance.resize(n_rows, zero);
out.variance_kind = kind;
}
pub(crate) fn predictive_variance(latent: f64, noise: f64, kind: crate::VarianceKind) -> f64 {
match kind {
crate::VarianceKind::Latent => latent,
crate::VarianceKind::Observation => latent + noise,
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct SparseScratch<S: KernelScalar> {
pub(crate) storage: KernelScratch<S>,
pub(crate) f64: KernelScratch<f64>,
pub(crate) point: Vec<f64>,
pub(crate) predict: PredictScratch<S>,
}