gprx 0.2.0

Gaussian process regression in Rust: exact GPR, sparse GPR (VFE), and SVGP.
Documentation
//! `f32` and `f64` evaluate the same formulas.

use crate::error::GprError;
use crate::kernel::visit_triangle;
use crate::kernel::{
    ConstantKernel, KernelScalar, KernelSpec, KernelTerm, LinearKernel, MaternArdKernel,
    MaternKernel, MaternNu, PeriodicKernel, RationalQuadraticArdKernel, RationalQuadraticKernel,
    RbfArdKernel, RbfKernel, Triangle, WhiteKernel,
};
use crate::param::Interval;
use faer::{Mat, MatMut, MatRef};

fn close(what: &str, got: f32, expect: f64) {
    let tol = 10.0 * f64::from(f32::EPSILON);
    let got = f64::from(got);
    let diff = (got - expect).abs();
    if expect.abs() < tol {
        assert!(diff < tol, "{what} absolute {diff} tol {tol}");
    } else {
        let rel = diff / expect.abs();
        assert!(rel < tol, "{what} relative {rel} got {got} expect {expect}");
    }
}

fn cmp_lower(what: &str, got: MatRef<'_, f32>, expect: MatRef<'_, f64>) {
    let n = expect.nrows();
    visit_triangle(n, Triangle::Lower, |row, col| {
        close(
            &format!("{what} ({row},{col})"),
            got[(row, col)],
            expect[(row, col)],
        );
    });
}

fn points() -> Mat<f64> {
    Mat::from_fn(2, 2, |row, col| [[0.0, 0.0], [1.0, 0.0]][row][col])
}

fn sq_pair(x: MatRef<'_, f64>, i: usize, j: usize) -> (f64, f32) {
    let mut s64 = 0.0;
    let mut s32 = 0.0f32;
    for col in 0..x.ncols() {
        let a = x[(i, col)];
        let b = x[(j, col)];
        s64 += (a - b) * (a - b);
        let a32 = a as f32;
        let b32 = b as f32;
        s32 += (a32 - b32) * (a32 - b32);
    }
    (s64, s32)
}

fn agree(name: &str, spec: &KernelSpec, x: &Mat<f64>, on_dist: bool) {
    let n = x.nrows();
    let k64 = spec.compile();
    let k32 = spec.compile_as::<f32>();
    let mut x32 = Mat::<f32>::zeros(n, x.ncols());
    for col in 0..x.ncols() {
        for row in 0..n {
            x32[(row, col)] = x[(row, col)] as f32;
        }
    }
    let mut o64 = Mat::<f64>::zeros(n, n);
    let mut o32 = Mat::<f32>::zeros(n, n);
    let mut s64 = Mat::<f64>::zeros(n, n);
    let mut s32 = Mat::<f32>::zeros(n, n);
    k64.apply_points::<crate::math::Accurate>(
        x.as_ref(),
        o64.as_mut(),
        Triangle::Lower,
        s64.as_mut(),
    )
    .expect("f64 points");
    k32.apply_points::<crate::math::Accurate>(
        x32.as_ref(),
        o32.as_mut(),
        Triangle::Lower,
        s32.as_mut(),
    )
    .expect("f32 points");
    cmp_lower(&format!("{name} points"), o32.as_ref(), o64.as_ref());
    let p = k64.num_params();
    for idx in 0..p {
        k64.grad_points::<crate::math::Accurate>(
            x.as_ref(),
            o64.as_mut(),
            idx,
            Triangle::Lower,
            s64.as_mut(),
        )
        .expect("f64 grad");
        k32.grad_points::<crate::math::Accurate>(
            x32.as_ref(),
            o32.as_mut(),
            idx,
            Triangle::Lower,
            s32.as_mut(),
        )
        .expect("f32 grad");
        cmp_lower(&format!("{name} grad {idx}"), o32.as_ref(), o64.as_ref());
        for j in 0..=idx {
            k64.hess_points::<crate::math::Accurate>(
                x.as_ref(),
                o64.as_mut(),
                idx,
                j,
                Triangle::Lower,
                s64.as_mut(),
            )
            .expect("f64 hess");
            k32.hess_points::<crate::math::Accurate>(
                x32.as_ref(),
                o32.as_mut(),
                idx,
                j,
                Triangle::Lower,
                s32.as_mut(),
            )
            .expect("f32 hess");
            cmp_lower(
                &format!("{name} hess {idx},{j}"),
                o32.as_ref(),
                o64.as_ref(),
            );
        }
    }
    if !on_dist {
        return;
    }
    let mut d64 = Mat::<f64>::zeros(n, n);
    let mut d32 = Mat::<f32>::zeros(n, n);
    for col in 0..n {
        for row in col..n {
            let (s64v, s32v) = sq_pair(x.as_ref(), row, col);
            d64[(row, col)] = s64v;
            d32[(row, col)] = s32v;
        }
    }
    k64.apply::<crate::math::Accurate>(d64.as_ref(), o64.as_mut(), Triangle::Lower, s64.as_mut())
        .expect("f64 dist");
    k32.apply::<crate::math::Accurate>(d32.as_ref(), o32.as_mut(), Triangle::Lower, s32.as_mut())
        .expect("f32 dist");
    cmp_lower(&format!("{name} dist"), o32.as_ref(), o64.as_ref());
}

#[derive(Clone, Debug)]
struct ScaleLeaf(f64);

impl<T: KernelScalar> KernelTerm<T> for ScaleLeaf {
    fn num_params(&self) -> usize {
        1
    }
    fn get_params(&self, out: &mut [f64]) -> Result<(), GprError> {
        out[0] = self.0.ln();
        Ok(())
    }
    fn set_params(&mut self, params: &[f64]) -> Result<(), GprError> {
        self.0 = params[0].exp();
        Ok(())
    }
    fn bounds_into(&self, out: &mut [Interval]) -> Result<(), GprError> {
        out[0] = Interval::new(1e-6, 1e6).expect("interval");
        Ok(())
    }
    fn apply(
        &self,
        dist: MatRef<'_, T>,
        out: MatMut<'_, T>,
        uplo: Triangle,
    ) -> Result<(), GprError> {
        let _ = dist;
        paint(out, uplo, T::from_f64(self.0));
        Ok(())
    }
    fn apply_cross(&self, dist: MatRef<'_, T>, mut out: MatMut<'_, T>) -> Result<(), GprError> {
        let _ = dist;
        let value = T::from_f64(self.0);
        for col in 0..out.ncols() {
            for row in 0..out.nrows() {
                out[(row, col)] = value;
            }
        }
        Ok(())
    }
    fn fill_diag(&self, out: &mut [T]) -> Result<(), GprError> {
        out.fill(T::from_f64(self.0));
        Ok(())
    }
    fn grad(
        &self,
        dist: MatRef<'_, T>,
        out: MatMut<'_, T>,
        param_idx: usize,
        uplo: Triangle,
    ) -> Result<(), GprError> {
        if param_idx != 0 {
            return Err(GprError::IndexOutOfRange {
                reason: "scale leaf has one parameter".to_owned(),
            });
        }
        self.apply(dist, out, uplo)
    }
    fn hess(
        &self,
        dist: MatRef<'_, T>,
        out: MatMut<'_, T>,
        i: usize,
        j: usize,
        uplo: Triangle,
    ) -> Result<(), GprError> {
        if i != 0 || j != 0 {
            return Err(GprError::IndexOutOfRange {
                reason: "scale leaf has one parameter".to_owned(),
            });
        }
        self.apply(dist, out, uplo)
    }
    fn hess_points(
        &self,
        x: MatRef<'_, T>,
        out: MatMut<'_, T>,
        i: usize,
        j: usize,
        uplo: Triangle,
    ) -> Result<(), GprError> {
        let _ = x;
        self.hess(x, out, i, j, uplo)
    }
}

fn paint<T: KernelScalar>(mut out: MatMut<'_, T>, uplo: Triangle, value: T) {
    visit_triangle(out.nrows(), uplo, |row, col| out[(row, col)] = value);
}

#[test]
fn f32_leaves_match_f64() {
    let x = points();
    let rbf = KernelSpec::from(RbfKernel::new(1.0).expect("rbf"));
    agree("rbf", &rbf, &x, true);
    agree(
        "rbf ard",
        &KernelSpec::from(RbfArdKernel::new(&[1.0, 2.0]).expect("ard")),
        &x,
        false,
    );
    for nu in [MaternNu::Half, MaternNu::ThreeHalves, MaternNu::FiveHalves] {
        agree(
            "matern",
            &KernelSpec::from(MaternKernel::new(1.0, nu).expect("matern")),
            &x,
            true,
        );
    }
    agree(
        "matern ard",
        &KernelSpec::from(
            MaternArdKernel::new(&[1.0, 2.0], MaternNu::ThreeHalves).expect("matern ard"),
        ),
        &x,
        false,
    );
    agree(
        "periodic",
        &KernelSpec::from(PeriodicKernel::new(1.0, 4.0).expect("periodic")),
        &x,
        true,
    );
    agree(
        "rq",
        &KernelSpec::from(RationalQuadraticKernel::new(1.0, 1.0).expect("rq")),
        &x,
        true,
    );
    agree(
        "rq ard",
        &KernelSpec::from(RationalQuadraticArdKernel::new(&[1.0, 1.0], 1.0).expect("rq ard")),
        &x,
        false,
    );
    agree(
        "constant",
        &KernelSpec::from(ConstantKernel::new(1.5).expect("constant")),
        &x,
        true,
    );
    agree(
        "linear",
        &KernelSpec::from(LinearKernel::new(1.0).expect("linear")),
        &x,
        false,
    );
    agree(
        "white",
        &KernelSpec::from(WhiteKernel::new(0.0625).expect("white")),
        &x,
        true,
    );
    let other = KernelSpec::from(RbfKernel::new(2.0).expect("rbf"));
    agree("sum", &(rbf.clone() + other.clone()), &x, true);
    agree("product", &(rbf * other), &x, true);
    agree("custom", &KernelSpec::custom(ScaleLeaf(1.25)), &x, true);
}