use std::path::Path;
use crate::error::GprError;
use crate::gpr::{FittedGpr, OnlineGpr};
use crate::kernel::{
DistanceKernel, DistanceOnly, DistanceSlot, DistanceSource, PointUse, WithPoints,
};
use crate::optimizer::Fixed;
use crate::sgpr::{FittedSgpr, FixedInducing, OnlineSgpr};
use crate::svgp::FittedSvgp;
use crate::{
DoublePrecision, MixedPrecision, PointId, PredictOptions, Prediction, ReevaluateKernel,
SinglePrecision,
};
use super::config::{ModelJson, PointsJson};
use super::sparse::{self, SgprVariants};
use super::{PersistRegistry, Variants, load_precision, read_exact_config, widen};
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum LoadedDistanceGpr<C: PointUse = DistanceOnly> {
Double(FittedGpr<Fixed, DoublePrecision, DistanceKernel<C>>),
Single(FittedGpr<Fixed, SinglePrecision, DistanceKernel<C>>),
Mixed(FittedGpr<Fixed, MixedPrecision, DistanceKernel<C>>),
Reevaluate(FittedGpr<Fixed, MixedPrecision<ReevaluateKernel>, DistanceKernel<C>>),
OnlineDouble(OnlineGpr<Fixed, DoublePrecision, DistanceKernel<C>>),
OnlineSingle(OnlineGpr<Fixed, SinglePrecision, DistanceKernel<C>>),
OnlineMixed(OnlineGpr<Fixed, MixedPrecision, DistanceKernel<C>>),
OnlineReevaluate(OnlineGpr<Fixed, MixedPrecision<ReevaluateKernel>, DistanceKernel<C>>),
}
macro_rules! each_model {
($value:expr, $model:ident => $body:expr) => {
match $value {
LoadedDistanceGpr::Double($model) => $body,
LoadedDistanceGpr::Single($model) => $body,
LoadedDistanceGpr::Mixed($model) => $body,
LoadedDistanceGpr::Reevaluate($model) => $body,
LoadedDistanceGpr::OnlineDouble($model) => $body,
LoadedDistanceGpr::OnlineSingle($model) => $body,
LoadedDistanceGpr::OnlineMixed($model) => $body,
LoadedDistanceGpr::OnlineReevaluate($model) => $body,
}
};
}
fn points_of<C: PointUse>() -> PointsJson {
PointsJson::of::<DistanceKernel<C>>()
}
impl<C: PointUse> LoadedDistanceGpr<C> {
pub fn load(dir: impl AsRef<Path>, registry: &PersistRegistry) -> Result<Self, GprError> {
let dir = dir.as_ref();
let config = read_exact_config(dir, Some(points_of::<C>()))?;
by_precision!(config.persist_kind(), Self, |fitted, online| {
load_precision(dir, registry, config, Variants { fitted, online })
})
}
pub fn n(&self) -> usize {
each_model!(self, model => model.n())
}
pub fn is_online(&self) -> bool {
matches!(
self,
Self::OnlineDouble(_)
| Self::OnlineSingle(_)
| Self::OnlineMixed(_)
| Self::OnlineReevaluate(_)
)
}
pub fn slots(&self) -> Vec<DistanceSlot> {
each_model!(self, model => model.slots())
}
pub fn to_kernel(&self) -> DistanceKernel<C> {
each_model!(self, model => model.to_kernel())
}
}
impl LoadedDistanceGpr<DistanceOnly> {
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
q: usize,
) -> Result<Prediction<f64>, GprError> {
self.predict_with(sources, q, PredictOptions::default())
}
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
q: usize,
options: PredictOptions,
) -> Result<Prediction<f64>, GprError> {
each_model!(self, model => model.predict_with(sources, q, options).map(widen))
}
}
impl LoadedDistanceGpr<WithPoints> {
pub fn d(&self) -> usize {
each_model!(self, model => model.d())
}
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
xs: &[f64],
q: usize,
n_cols: usize,
) -> Result<Prediction<f64>, GprError> {
self.predict_with(sources, xs, q, n_cols, PredictOptions::default())
}
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
xs: &[f64],
q: usize,
n_cols: usize,
options: PredictOptions,
) -> Result<Prediction<f64>, GprError> {
each_model!(self, model => model.predict_with(sources, xs, q, n_cols, options).map(widen))
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum LoadedDistanceSgpr<C: PointUse = DistanceOnly> {
Double(FittedSgpr<Fixed, FixedInducing, DoublePrecision, DistanceKernel<C>>),
Single(FittedSgpr<Fixed, FixedInducing, SinglePrecision, DistanceKernel<C>>),
Mixed(FittedSgpr<Fixed, FixedInducing, MixedPrecision, DistanceKernel<C>>),
Reevaluate(
FittedSgpr<Fixed, FixedInducing, MixedPrecision<ReevaluateKernel>, DistanceKernel<C>>,
),
OnlineDouble(OnlineSgpr<Fixed, DoublePrecision, DistanceKernel<C>>),
OnlineSingle(OnlineSgpr<Fixed, SinglePrecision, DistanceKernel<C>>),
OnlineMixed(OnlineSgpr<Fixed, MixedPrecision, DistanceKernel<C>>),
OnlineReevaluate(OnlineSgpr<Fixed, MixedPrecision<ReevaluateKernel>, DistanceKernel<C>>),
}
macro_rules! each_sgpr {
($value:expr, $model:ident => $body:expr) => {
match $value {
LoadedDistanceSgpr::Double($model) => $body,
LoadedDistanceSgpr::Single($model) => $body,
LoadedDistanceSgpr::Mixed($model) => $body,
LoadedDistanceSgpr::Reevaluate($model) => $body,
LoadedDistanceSgpr::OnlineDouble($model) => $body,
LoadedDistanceSgpr::OnlineSingle($model) => $body,
LoadedDistanceSgpr::OnlineMixed($model) => $body,
LoadedDistanceSgpr::OnlineReevaluate($model) => $body,
}
};
}
impl<C: PointUse> LoadedDistanceSgpr<C> {
pub fn load(dir: impl AsRef<Path>, registry: &PersistRegistry) -> Result<Self, GprError> {
let dir = dir.as_ref();
let config = sparse::read_config(
dir,
&[ModelJson::Sgpr, ModelJson::OnlineSgpr],
Some(points_of::<C>()),
)?;
by_precision!(config.persist_kind(), Self, |fitted, online| {
sparse::load_sgpr_as(dir, &config, registry, SgprVariants { fitted, online })
})
}
pub fn n(&self) -> usize {
each_sgpr!(self, model => model.n())
}
pub fn m(&self) -> usize {
each_sgpr!(self, model => model.m())
}
pub fn inducing(&self) -> Option<&[usize]> {
match self {
Self::Double(model) => Some(model.inducing()),
Self::Single(model) => Some(model.inducing()),
Self::Mixed(model) => Some(model.inducing()),
Self::Reevaluate(model) => Some(model.inducing()),
Self::OnlineDouble(_)
| Self::OnlineSingle(_)
| Self::OnlineMixed(_)
| Self::OnlineReevaluate(_) => None,
}
}
pub fn inducing_points(&self) -> Option<impl Iterator<Item = PointId> + '_> {
let ids = match self {
Self::OnlineDouble(model) => Some(model.inducing_point_ids()),
Self::OnlineSingle(model) => Some(model.inducing_point_ids()),
Self::OnlineMixed(model) => Some(model.inducing_point_ids()),
Self::OnlineReevaluate(model) => Some(model.inducing_point_ids()),
Self::Double(_) | Self::Single(_) | Self::Mixed(_) | Self::Reevaluate(_) => None,
};
ids.map(|ids| ids.iter().copied())
}
pub fn is_online(&self) -> bool {
matches!(
self,
Self::OnlineDouble(_)
| Self::OnlineSingle(_)
| Self::OnlineMixed(_)
| Self::OnlineReevaluate(_)
)
}
pub fn slots(&self) -> Vec<DistanceSlot> {
each_sgpr!(self, model => model.slots())
}
pub fn to_kernel(&self) -> DistanceKernel<C> {
each_sgpr!(self, model => model.to_kernel())
}
}
impl LoadedDistanceSgpr<DistanceOnly> {
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
q: usize,
) -> Result<Prediction<f64>, GprError> {
self.predict_with(sources, q, PredictOptions::default())
}
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
q: usize,
options: PredictOptions,
) -> Result<Prediction<f64>, GprError> {
each_sgpr!(self, model => model.predict_with(sources, q, options).map(widen))
}
}
impl LoadedDistanceSgpr<WithPoints> {
pub fn d(&self) -> usize {
each_sgpr!(self, model => model.d())
}
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
xs: &[f64],
q: usize,
n_cols: usize,
) -> Result<Prediction<f64>, GprError> {
self.predict_with(sources, xs, q, n_cols, PredictOptions::default())
}
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
xs: &[f64],
q: usize,
n_cols: usize,
options: PredictOptions,
) -> Result<Prediction<f64>, GprError> {
each_sgpr!(self, model => model.predict_with(sources, xs, q, n_cols, options).map(widen))
}
}
#[derive(Clone, Debug)]
#[non_exhaustive]
pub enum LoadedDistanceSvgp<C: PointUse = DistanceOnly> {
Double(FittedSvgp<DoublePrecision, DistanceKernel<C>>),
Single(FittedSvgp<SinglePrecision, DistanceKernel<C>>),
Mixed(FittedSvgp<MixedPrecision, DistanceKernel<C>>),
Reevaluate(FittedSvgp<MixedPrecision<ReevaluateKernel>, DistanceKernel<C>>),
}
macro_rules! each_svgp {
($value:expr, $model:ident => $body:expr) => {
match $value {
LoadedDistanceSvgp::Double($model) => $body,
LoadedDistanceSvgp::Single($model) => $body,
LoadedDistanceSvgp::Mixed($model) => $body,
LoadedDistanceSvgp::Reevaluate($model) => $body,
}
};
}
impl<C: PointUse> LoadedDistanceSvgp<C> {
pub fn load(dir: impl AsRef<Path>, registry: &PersistRegistry) -> Result<Self, GprError> {
let dir = dir.as_ref();
let config = sparse::read_config(dir, &[ModelJson::Svgp], Some(points_of::<C>()))?;
by_precision!(config.persist_kind(), Self, |fitted| {
sparse::load_svgp_as(dir, &config, registry, fitted)
})
}
pub fn n(&self) -> usize {
each_svgp!(self, model => model.n())
}
pub fn m(&self) -> usize {
each_svgp!(self, model => model.m())
}
pub fn inducing(&self) -> &[usize] {
each_svgp!(self, model => model.inducing())
}
pub fn slots(&self) -> Vec<DistanceSlot> {
each_svgp!(self, model => model.slots())
}
pub fn to_kernel(&self) -> DistanceKernel<C> {
each_svgp!(self, model => model.to_kernel())
}
}
impl LoadedDistanceSvgp<DistanceOnly> {
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
q: usize,
) -> Result<Prediction<f64>, GprError> {
self.predict_with(sources, q, PredictOptions::default())
}
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
q: usize,
options: PredictOptions,
) -> Result<Prediction<f64>, GprError> {
each_svgp!(self, model => model.predict_with(sources, q, options).map(widen))
}
}
impl LoadedDistanceSvgp<WithPoints> {
pub fn d(&self) -> usize {
each_svgp!(self, model => model.d())
}
pub fn predict<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
xs: &[f64],
q: usize,
n_cols: usize,
) -> Result<Prediction<f64>, GprError> {
self.predict_with(sources, xs, q, n_cols, PredictOptions::default())
}
pub fn predict_with<'s>(
&self,
sources: impl IntoIterator<Item = DistanceSource<'s>>,
xs: &[f64],
q: usize,
n_cols: usize,
options: PredictOptions,
) -> Result<Prediction<f64>, GprError> {
each_svgp!(self, model => model.predict_with(sources, xs, q, n_cols, options).map(widen))
}
}