use tpt_math_autodiff_rev::{GradientTape, Variable};
use crate::PplError;
use crate::nuts::{Target, nuts_with_divergences, randn};
use crate::trace::Trace;
use tpt_math_prob_core::Rng;
struct GradientTarget<F> {
logp_and_grad: F,
}
impl<F> Target for GradientTarget<F>
where
F: Fn(&[f64]) -> Option<(f64, Vec<f64>)>,
{
fn eval<'t>(&self, tape: &'t GradientTape, vars: &'t [Variable<'t>]) -> Variable<'t> {
let theta: Vec<f64> = vars.iter().map(|v| v.value()).collect();
let (value, grad) = match (self.logp_and_grad)(&theta) {
Some((value, grad)) => (value, grad),
None => (f64::NEG_INFINITY, vec![0.0; theta.len()]),
};
let linear_at_theta: f64 = theta.iter().zip(&grad).map(|(t, g)| t * g).sum();
let mut s = tape.constant(value - linear_at_theta);
for (v, g) in vars.iter().zip(&grad) {
s += *v * *g;
}
s
}
}
pub fn fit_with_gradient<F>(
dim: usize,
logp_and_grad: F,
n_chains: usize,
n_samples: usize,
rng: &mut impl Rng,
) -> Result<Trace, PplError>
where
F: Fn(&[f64]) -> Option<(f64, Vec<f64>)>,
{
if n_chains == 0 {
return Err(PplError::InvalidOption("n_chains must be > 0".into()));
}
let target = GradientTarget { logp_and_grad };
let mut chains = Vec::with_capacity(n_chains);
let mut n_div = 0usize;
for _ in 0..n_chains {
let start: Vec<f64> = (0..dim).map(|_| 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))
}
#[cfg(feature = "rayon")]
type ChainResult = (Vec<Vec<f64>>, usize);
#[cfg(feature = "rayon")]
pub fn fit_with_gradient_parallel<F>(
dim: usize,
logp_and_grad: F,
n_chains: usize,
n_samples: usize,
rng: &mut impl Rng,
) -> Result<Trace, PplError>
where
F: Fn(&[f64]) -> Option<(f64, Vec<f64>)> + Sync,
{
use rayon::prelude::*;
use tpt_math_prob_core::SplitMix64;
if n_chains == 0 {
return Err(PplError::InvalidOption("n_chains must be > 0".into()));
}
let seeds: Vec<u64> = (0..n_chains).map(|_| rng.next_u64()).collect();
let results: Result<Vec<ChainResult>, PplError> = seeds
.par_iter()
.map(|&seed| {
let mut chain_rng = SplitMix64::seed_from_u64(seed);
let target = GradientTarget {
logp_and_grad: &logp_and_grad,
};
let start: Vec<f64> = (0..dim).map(|_| 0.1 * randn(&mut chain_rng)).collect();
nuts_with_divergences(&target, &start, &mut chain_rng, n_samples)
})
.collect();
let mut chains = Vec::with_capacity(n_chains);
let mut n_div = 0usize;
for (samples, d) in results? {
n_div += d;
chains.push(samples);
}
Ok(Trace::new(chains, n_div))
}