use crate::rng::SeededRng;
use crate::error::GprError;
use crate::objective::{Differentiable, Objective, TwiceDifferentiable};
use crate::param::Interval;
use crate::rng::open_unit;
pub(super) struct LogitMapped<'a, P> {
pub(super) inner: &'a mut P,
pub(super) intervals: &'a [Interval],
pub(super) log_scratch: Vec<f64>,
}
impl<P: Objective> Objective for LogitMapped<'_, P> {
fn num_params(&self) -> usize {
self.inner.num_params()
}
fn value(&mut self, params: &[f64]) -> Result<f64, GprError> {
z_to_log_theta_into(params, self.intervals, &mut self.log_scratch)?;
self.inner.value(&self.log_scratch)
}
}
impl<P: Differentiable> Differentiable for LogitMapped<'_, P> {
fn gradient_into(&mut self, params: &[f64], out: &mut [f64]) -> Result<(), GprError> {
self.value_and_gradient_into(params, out).map(|_| ())
}
fn value_and_gradient_into(
&mut self,
params: &[f64],
out: &mut [f64],
) -> Result<f64, GprError> {
z_to_log_theta_into(params, self.intervals, &mut self.log_scratch)?;
let value = self.inner.value_and_gradient_into(&self.log_scratch, out)?;
chain_logit_grad(params, self.intervals, &self.log_scratch, out);
Ok(value)
}
}
impl<P: TwiceDifferentiable> TwiceDifferentiable for LogitMapped<'_, P> {
fn hessian_into(&mut self, params: &[f64], out: &mut [f64]) -> Result<(), GprError> {
let mut grad = vec![0.0; params.len()];
self.value_gradient_hessian_into(params, &mut grad, out)
.map(|_| ())
}
fn value_gradient_hessian_into(
&mut self,
params: &[f64],
grad: &mut [f64],
hess: &mut [f64],
) -> Result<f64, GprError> {
z_to_log_theta_into(params, self.intervals, &mut self.log_scratch)?;
let n = params.len();
if hess.len() != n * n {
return Err(GprError::LengthMismatch {
reason: format!("expected {} Hessian entries, got {}", n * n, hess.len()),
});
}
let value = self
.inner
.value_gradient_hessian_into(&self.log_scratch, grad, hess)?;
chain_logit_hess(params, self.intervals, &self.log_scratch, grad, hess);
chain_logit_grad(params, self.intervals, &self.log_scratch, grad);
Ok(value)
}
}
pub(crate) fn log_theta_to_z(
log_theta: &[f64],
intervals: &[Interval],
) -> Result<Vec<f64>, GprError> {
let mut z = vec![0.0; log_theta.len()];
for (i, &theta) in log_theta.iter().enumerate() {
let x = if intervals[i].lo() > 0.0 {
theta.exp()
} else {
theta
};
z[i] = user_to_z(x, intervals[i])?;
}
Ok(z)
}
pub(crate) fn z_to_log_theta(z: &[f64], intervals: &[Interval]) -> Result<Vec<f64>, GprError> {
let mut log_theta = vec![0.0; z.len()];
z_to_log_theta_into(z, intervals, &mut log_theta)?;
Ok(log_theta)
}
pub(crate) fn z_to_log_theta_into(
z: &[f64],
intervals: &[Interval],
out: &mut [f64],
) -> Result<(), GprError> {
if z.len() != intervals.len() || out.len() != z.len() {
return Err(GprError::ShapeMismatch {
reason: "logit map length mismatch".to_owned(),
});
}
for i in 0..z.len() {
out[i] = z_to_param(z[i], intervals[i]);
}
Ok(())
}
fn z_to_param(z: f64, interval: Interval) -> f64 {
let u = sigmoid(z / logit_scale(interval));
if interval.lo() > 0.0 {
let ln_lo = interval.lo().ln();
let ln_hi = interval.hi().ln();
ln_lo + u * (ln_hi - ln_lo)
} else {
interval.lo() + u * interval.width()
}
}
pub(crate) fn chain_logit_grad(
z: &[f64],
intervals: &[Interval],
log_theta: &[f64],
grad: &mut [f64],
) {
for i in 0..z.len() {
grad[i] *= dlog_dz(z[i], intervals[i], log_theta[i]);
}
}
fn chain_logit_hess(
z: &[f64],
intervals: &[Interval],
log_theta: &[f64],
grad_theta: &[f64],
hess: &mut [f64],
) {
let n = z.len();
let mut jac = vec![0.0; n];
for i in 0..n {
jac[i] = dlog_dz(z[i], intervals[i], log_theta[i]);
}
for i in 0..n {
for j in 0..n {
hess[i * n + j] *= jac[i] * jac[j];
}
hess[i * n + i] += grad_theta[i] * d2log_dz2(z[i], intervals[i], log_theta[i]);
}
}
fn dlog_dz(z: f64, interval: Interval, log_theta: f64) -> f64 {
let scale = logit_scale(interval);
let t = z / scale;
let s = sigmoid(t);
let ds = s * (1.0 - s);
let dlog_dt = if interval.lo() > 0.0 {
(interval.hi().ln() - interval.lo().ln()) * ds
} else {
let _ = log_theta;
interval.width() * ds
};
dlog_dt / scale
}
fn d2log_dz2(z: f64, interval: Interval, log_theta: f64) -> f64 {
let scale = logit_scale(interval);
let t = z / scale;
let s = sigmoid(t);
let ds = s * (1.0 - s);
if interval.lo() > 0.0 {
4.0 * ds * (1.0 - 2.0 * s) / scale
} else {
let _ = log_theta;
4.0 * ds * (1.0 - 2.0 * s) / scale
}
}
fn user_to_z(x: f64, interval: Interval) -> Result<f64, GprError> {
if !interval.contains(x) {
return Err(GprError::from(crate::param::IntervalError::OutOfRange {
value: x,
lo: interval.lo(),
hi: interval.hi(),
}));
}
let u = unit_from_user(x, interval);
Ok(logit(u.clamp(f64::EPSILON, 1.0 - f64::EPSILON)) * logit_scale(interval))
}
#[cfg(test)]
fn z_to_user(z: f64, interval: Interval) -> f64 {
let t = z / logit_scale(interval);
let u = sigmoid(t);
if interval.lo() > 0.0 {
let ln_lo = interval.lo().ln();
let ln_hi = interval.hi().ln();
(ln_lo + u * (ln_hi - ln_lo)).exp()
} else {
interval.lo() + u * interval.width()
}
}
fn logit_scale(interval: Interval) -> f64 {
let span = if interval.lo() > 0.0 {
interval.hi().ln() - interval.lo().ln()
} else {
interval.width()
};
span / 4.0
}
fn unit_from_user(x: f64, interval: Interval) -> f64 {
if interval.lo() > 0.0 {
let ln_lo = interval.lo().ln();
let ln_hi = interval.hi().ln();
(x.ln() - ln_lo) / (ln_hi - ln_lo)
} else {
(x - interval.lo()) / interval.width()
}
}
fn logit(u: f64) -> f64 {
(u / (1.0 - u)).ln()
}
fn sigmoid(z: f64) -> f64 {
if z >= 0.0 {
let e = (-z).exp();
1.0 / (1.0 + e)
} else {
let e = z.exp();
e / (1.0 + e)
}
}
pub(super) fn sample_log_uniform_z(
intervals: &[Interval],
rng: &mut SeededRng,
) -> Result<Vec<f64>, GprError> {
let mut z = vec![0.0; intervals.len()];
for (slot, interval) in z.iter_mut().zip(intervals.iter().copied()) {
let x = log_uniform_open(rng, interval);
*slot = user_to_z(x, interval)?;
}
Ok(z)
}
fn log_uniform_open(rng: &mut SeededRng, interval: Interval) -> f64 {
let u = open_unit(rng);
if interval.lo() > 0.0 {
let ln_lo = interval.lo().ln();
let ln_hi = interval.hi().ln();
(ln_lo + u * (ln_hi - ln_lo)).exp()
} else {
interval.lo() + u * interval.width()
}
}
#[cfg(test)]
mod tests {
use super::{log_theta_to_z, logit, sigmoid, user_to_z, z_to_log_theta_into, z_to_user};
use crate::gpr::Gpr;
use crate::kernel::{KernelSpec, RbfKernel};
use crate::likelihood::GaussianLikelihood;
use crate::objective::{Differentiable, Objective, TwiceDifferentiable};
use crate::optimizer::Fixed;
use crate::param::Interval;
const TOL: f64 = 1e-6;
use crate::test_check::assert_close;
#[test]
fn logit_mapped_hess_matches_finite_difference() {
let kernel = KernelSpec::from(RbfKernel::new(1.25).expect("valid"));
let likelihood = GaussianLikelihood::new(0.16).expect("valid");
let mut gpr = Gpr::new(kernel, likelihood)
.with_optimizer(Fixed)
.factor(&[0.0, 0.8, 1.7], 3, 1, &[0.4, -0.2, 0.9])
.unwrap_or_else(|(_, e)| panic!("{e}"));
let mut log_theta = [0.0; 2];
gpr.get_params(&mut log_theta).expect("len 2");
let intervals = [Interval::DEFAULT_POSITIVE, Interval::DEFAULT_POSITIVE];
let z = super::log_theta_to_z(&log_theta, &intervals).expect("z");
let mut obj = gpr.objective();
let mut mapped = super::LogitMapped {
inner: &mut obj,
intervals: &intervals,
log_scratch: vec![0.0; 2],
};
let mut hess = [0.0; 4];
mapped.hessian_into(&z, &mut hess).expect("hess");
let h = 1e-6;
let mut g_plus = [0.0; 2];
let mut g_minus = [0.0; 2];
for j in 0..2 {
let mut plus = z.clone();
let mut minus = z.clone();
plus[j] += h;
minus[j] -= h;
mapped
.value_and_gradient_into(&plus, &mut g_plus)
.expect("plus");
mapped
.value_and_gradient_into(&minus, &mut g_minus)
.expect("minus");
for i in 0..2 {
let fd = (g_plus[i] - g_minus[i]) / (2.0 * h);
assert!(
(hess[i * 2 + j] - fd).abs() <= 2e-4 * fd.abs().max(1.0),
"H[{i},{j}] analytic={} fd={}",
hess[i * 2 + j],
fd
);
}
}
}
#[test]
fn logit_mapped_grad_matches_finite_difference() {
let kernel = KernelSpec::from(RbfKernel::new(1.0).expect("valid"));
let likelihood = GaussianLikelihood::new(0.1).expect("valid");
let mut gpr = Gpr::new(kernel, likelihood)
.with_optimizer(Fixed)
.factor(&[0.0, 1.0], 2, 1, &[0.5, -0.25])
.unwrap_or_else(|(_, e)| panic!("{e}"));
let mut log_theta = [0.0; 2];
gpr.get_params(&mut log_theta).expect("len 2");
let intervals = [Interval::DEFAULT_POSITIVE, Interval::DEFAULT_POSITIVE];
let z = super::log_theta_to_z(&log_theta, &intervals).expect("z");
let mut obj = gpr.objective();
let mut mapped = super::LogitMapped {
inner: &mut obj,
intervals: &intervals,
log_scratch: vec![0.0; 2],
};
let mut analytic = [0.0; 2];
let value = mapped
.value_and_gradient_into(&z, &mut analytic)
.expect("grad");
let h = 1e-6;
for i in 0..2 {
let mut plus = z.clone();
let mut minus = z.clone();
plus[i] += h;
minus[i] -= h;
let vp = mapped.value(&plus).expect("plus");
let vm = mapped.value(&minus).expect("minus");
let fd = (vp - vm) / (2.0 * h);
assert!(
(analytic[i] - fd).abs() <= 1e-4 * analytic[i].abs().max(1.0),
"i={i} analytic={} fd={} value={value}",
analytic[i],
fd
);
}
}
#[test]
fn logit_linear_interval_passes_user_units() {
let interval = Interval::new(-0.25, 1.25).expect("linear");
let x = 0.4;
let z = user_to_z(x, interval).expect("inside");
let mut out = [0.0];
z_to_log_theta_into(&[z], &[interval], &mut out).expect("map");
assert_close(out[0], x, TOL);
let back = log_theta_to_z(&out, &[interval]).expect("z");
assert_close(z_to_user(back[0], interval), x, TOL);
}
#[test]
fn logit_roundtrip_stays_inside_interval() {
let interval = Interval::DEFAULT_POSITIVE;
let x = 2.5;
let z = user_to_z(x, interval).expect("inside");
let back = z_to_user(z, interval);
assert_close(back, x, TOL);
assert!(interval.contains(back));
assert_close(sigmoid(logit(0.25)), 0.25, TOL);
}
#[test]
fn z_to_param_is_the_log_of_the_user_value() {
for interval in [
Interval::new(1e-5, 1e5).expect("positive"),
Interval::new(0.3, 7.0).expect("positive"),
Interval::new(-2.0, 3.0).expect("signed"),
] {
for z in [-40.0, -3.0, -0.25, 0.0, 0.5, 2.0, 40.0] {
let user = z_to_user(z, interval);
let want = if interval.lo() > 0.0 { user.ln() } else { user };
let got = super::z_to_param(z, interval);
assert!(
(got - want).abs() <= 4.0 * f64::EPSILON * want.abs().max(1.0),
"{interval:?} z={z}: {got} vs {want}"
);
if z.abs() <= 2.0 {
let theta = if interval.lo() > 0.0 { got.exp() } else { got };
assert!(interval.contains(theta), "{interval:?} z={z}: {theta}");
}
}
}
}
}