use tpt_math_autodiff_rev::{GradientTape, Variable};
use tpt_math_prob_core::Rng;
use crate::error::PplError;
use crate::nuts::{nuts_with_divergences, randn};
use crate::trace::Trace;
use crate::{Beta, Gamma, Gaussian};
type PriorFn = Box<dyn for<'t> Fn(&'t Variable<'t>) -> Variable<'t>>;
type LikelihoodFn = Box<dyn for<'t> Fn(&'t GradientTape, &[Variable<'t>], &[f64]) -> Variable<'t>>;
pub struct ModelBuilder {
dim: usize,
priors: Vec<PriorFn>,
likelihood: Option<LikelihoodFn>,
data: Vec<f64>,
}
impl ModelBuilder {
pub fn new() -> Self {
Self {
dim: 0,
priors: Vec::new(),
likelihood: None,
data: Vec::new(),
}
}
pub fn parameter<F>(&mut self, prior: F) -> &mut Self
where
F: for<'t> Fn(&'t Variable<'t>) -> Variable<'t> + 'static,
{
self.priors.push(Box::new(prior));
self.dim += 1;
self
}
pub fn gaussian_parameter(&mut self, mean: f64, std: f64) -> &mut Self {
self.parameter(move |x: &Variable<'_>| {
let x = *x;
let z = (x - mean) / std;
-0.5 * z * z
})
}
pub fn beta_parameter(&mut self, a: f64, b: f64) -> &mut Self {
self.parameter(move |x: &Variable<'_>| {
let x = *x;
(a - 1.0) * x.ln() + (b - 1.0) * (1.0_f64 - x).ln()
})
}
pub fn gamma_parameter(&mut self, a: f64, b: f64) -> &mut Self {
self.parameter(move |x: &Variable<'_>| {
let x = *x;
(a - 1.0) * x.ln() - b * x
})
}
pub fn gaussian_prior(&mut self, d: Gaussian) -> &mut Self {
let (mean, std) = (d.mean(), d.std());
self.parameter(move |x: &Variable<'_>| {
let x = *x;
let z = (x - mean) / std;
-0.5 * z * z
})
}
pub fn beta_prior(&mut self, d: Beta) -> &mut Self {
let (a, b) = (d.alpha(), d.beta());
self.parameter(move |x: &Variable<'_>| {
let x = *x;
(a - 1.0) * x.ln() + (b - 1.0) * (1.0_f64 - x).ln()
})
}
pub fn gamma_prior(&mut self, d: Gamma) -> &mut Self {
let (a, b) = (d.shape(), d.rate());
self.parameter(move |x: &Variable<'_>| {
let x = *x;
(a - 1.0) * x.ln() - b * x
})
}
pub fn set_data(&mut self, data: Vec<f64>) -> &mut Self {
self.data = data;
self
}
pub fn likelihood<F>(&mut self, f: F) -> &mut Self
where
F: for<'t> Fn(&'t GradientTape, &[Variable<'t>], &[f64]) -> Variable<'t> + 'static,
{
self.likelihood = Some(Box::new(f));
self
}
pub fn build(self) -> Result<Model, PplError> {
if self.dim == 0 {
return Err(PplError::InvalidOption("model has no parameters".into()));
}
Ok(Model {
dim: self.dim,
priors: self.priors,
likelihood: self.likelihood,
data: self.data,
})
}
}
impl Default for ModelBuilder {
fn default() -> Self {
Self::new()
}
}
pub struct Model {
dim: usize,
priors: Vec<PriorFn>,
likelihood: Option<LikelihoodFn>,
data: Vec<f64>,
}
impl Model {
pub fn dim(&self) -> usize {
self.dim
}
pub fn fit(&self, rng: &mut impl Rng, n_samples: usize) -> Result<Trace, PplError> {
self.fit_chains(2, n_samples, rng)
}
pub fn fit_from(
&self,
initial: &[f64],
rng: &mut impl Rng,
n_samples: usize,
) -> Result<Trace, PplError> {
if initial.len() != self.dim {
return Err(PplError::DimensionMismatch {
expected: self.dim,
got: initial.len(),
});
}
let target = ModelTarget {
priors: &self.priors,
likelihood: &self.likelihood,
data: &self.data,
};
let (samples, n_div) = nuts_with_divergences(&target, initial, rng, n_samples)?;
Ok(Trace::new(vec![samples], n_div))
}
pub fn fit_chains(
&self,
n_chains: usize,
n_samples: usize,
rng: &mut impl Rng,
) -> Result<Trace, PplError> {
if n_chains == 0 {
return Err(PplError::InvalidOption("n_chains must be > 0".into()));
}
let base = vec![0.5; self.dim];
let target = ModelTarget {
priors: &self.priors,
likelihood: &self.likelihood,
data: &self.data,
};
let mut chains = Vec::with_capacity(n_chains);
let mut n_div = 0usize;
for _ in 0..n_chains {
let start: Vec<f64> = base.iter().map(|&v| v + 0.1 * randn(rng)).collect();
let (samples, d) = nuts_with_divergences(&target, &start, rng, n_samples)?;
n_div += d;
chains.push(samples);
}
Ok(Trace::new(chains, n_div))
}
}
struct ModelTarget<'a> {
priors: &'a [PriorFn],
likelihood: &'a Option<LikelihoodFn>,
data: &'a [f64],
}
impl<'a> crate::nuts::Target for ModelTarget<'a> {
fn eval<'t>(&self, tape: &'t GradientTape, vars: &'t [Variable<'t>]) -> Variable<'t> {
let mut s = tape.constant(0.0);
for (i, p) in self.priors.iter().enumerate() {
s += p(&vars[i]);
}
if let Some(l) = self.likelihood {
s += l(tape, vars, self.data);
}
s
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
use tpt_math_prob_core::SplitMix64;
#[test]
fn gaussian_model_recovers_posterior_mean() {
let data = [2.0, 3.0, 2.5, 3.5, 3.0];
let mut m = ModelBuilder::new();
m.gaussian_parameter(0.0, 5.0);
m.set_data(data.to_vec());
m.likelihood(|t, v, d| {
let mut s = t.constant(0.0);
for &x in d.iter() {
let z = (v[0] - x) / 1.0;
s += -0.5 * z * z;
}
s
});
let model = m.build().unwrap();
let mut rng = SplitMix64::seed_from_u64(1);
let trace = model.fit(&mut rng, 800).unwrap();
let samples = trace.combined_samples();
let mean: f64 = samples.iter().map(|s| s[0]).sum::<f64>() / samples.len() as f64;
assert_abs_diff_eq!(mean, 2.8, epsilon = 0.6);
assert!(mean > 1.0 && mean < 4.0);
}
#[test]
fn fit_from_rejects_wrong_dimension() {
let mut m = ModelBuilder::new();
m.gaussian_parameter(0.0, 1.0);
let model = m.build().unwrap();
let mut rng = SplitMix64::seed_from_u64(1);
assert!(matches!(
model.fit_from(&[0.0, 0.0], &mut rng, 10),
Err(PplError::DimensionMismatch { .. })
));
}
#[test]
fn typed_gaussian_prior_matches_raw_prior() {
let data = [2.0, 3.0, 2.5, 3.5, 3.0];
let mut m = ModelBuilder::new();
m.gaussian_prior(Gaussian::new(0.0, 5.0));
m.set_data(data.to_vec());
m.likelihood(|t, v, d| {
let mut s = t.constant(0.0);
for &x in d.iter() {
let z = (v[0] - x) / 1.0;
s += -0.5 * z * z;
}
s
});
let model = m.build().unwrap();
let mut rng = SplitMix64::seed_from_u64(1);
let trace = model.fit(&mut rng, 800).unwrap();
let samples = trace.combined_samples();
let mean: f64 = samples.iter().map(|s| s[0]).sum::<f64>() / samples.len() as f64;
assert_abs_diff_eq!(mean, 2.8, epsilon = 0.6);
}
#[test]
fn typed_beta_prior_recovers_posterior() {
let mut m = ModelBuilder::new();
m.beta_prior(Beta::uniform());
m.set_data(vec![7.0, 3.0]);
m.likelihood(|_t, v, d| {
let s = d[0];
let f = d[1];
s * v[0].ln() + f * (1.0_f64 - v[0]).ln()
});
let model = m.build().unwrap();
let mut rng = SplitMix64::seed_from_u64(42);
let trace = model.fit(&mut rng, 2000).unwrap();
let samples = trace.combined_samples();
let mean: f64 = samples.iter().map(|s| s[0]).sum::<f64>() / samples.len() as f64;
assert_abs_diff_eq!(mean, 0.7, epsilon = 0.06);
}
#[test]
fn multi_chain_fit_reports_diagnostics() {
let data = [2.0, 3.0, 2.5, 3.5, 3.0];
let mut m = ModelBuilder::new();
m.gaussian_parameter(0.0, 5.0);
m.set_data(data.to_vec());
m.likelihood(|t, v, d| {
let mut s = t.constant(0.0);
for &x in d.iter() {
let z = (v[0] - x) / 1.0;
s += -0.5 * z * z;
}
s
});
let model = m.build().unwrap();
let mut rng = SplitMix64::seed_from_u64(123);
let trace = model.fit_chains(4, 800, &mut rng).unwrap();
assert_eq!(trace.n_chains(), 4);
assert_eq!(trace.dim(), 1);
let rhat = trace.rhat(0);
assert!(rhat.is_finite() && rhat < 1.1, "rhat = {rhat}");
let ess = trace.ess(0);
assert!(
ess > 0.0 && ess < trace.n_draws() as f64 + 1.0,
"ess = {ess}"
);
assert!((0.0..=1.0).contains(&trace.divergence_rate()));
assert_abs_diff_eq!(trace.mean(0), 2.8, epsilon = 0.6);
}
#[test]
fn fit_chains_rejects_zero_chains() {
let mut m = ModelBuilder::new();
m.gaussian_parameter(0.0, 1.0);
let model = m.build().unwrap();
let mut rng = SplitMix64::seed_from_u64(1);
assert!(matches!(
model.fit_chains(0, 10, &mut rng),
Err(PplError::InvalidOption { .. })
));
}
}