use ndarray::{Array1, Array2};
use solow_core::error::{Error, Result};
use solow_distributions::{norm_cdf, norm_ppf};
use solow_linalg::{det, inv, solve};
use solow_optimize::{approx_hess, minimize_bfgs};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RemlMethod {
Reml,
Ml,
}
#[derive(Clone, Debug)]
pub struct MixedLm {
endog: Array1<f64>,
exog: Array2<f64>,
groups: Vec<Vec<usize>>,
method: RemlMethod,
}
impl MixedLm {
pub fn new(endog: Array1<f64>, exog: Array2<f64>, group_labels: &[i64]) -> Result<Self> {
let n = endog.len();
if exog.nrows() != n {
return Err(Error::Shape("endog length != exog rows".into()));
}
if group_labels.len() != n {
return Err(Error::Shape("group_labels length != endog length".into()));
}
let mut order: Vec<i64> = Vec::new();
let mut groups: Vec<Vec<usize>> = Vec::new();
for (i, &g) in group_labels.iter().enumerate() {
match order.iter().position(|&x| x == g) {
Some(k) => groups[k].push(i),
None => {
order.push(g);
groups.push(vec![i]);
}
}
}
Ok(MixedLm {
endog,
exog,
groups,
method: RemlMethod::Reml,
})
}
pub fn method(mut self, method: RemlMethod) -> Self {
self.method = method;
self
}
fn n_obs(&self) -> usize {
self.endog.len()
}
fn k_fe(&self) -> usize {
self.exog.ncols()
}
fn reml(&self) -> bool {
self.method == RemlMethod::Reml
}
fn fac(&self) -> f64 {
let n = self.n_obs() as f64;
if self.reml() {
n - self.k_fe() as f64
} else {
n
}
}
fn gls_pieces(&self, psi: f64) -> (Array2<f64>, Array1<f64>) {
let p = self.k_fe();
let mut xtvix = Array2::<f64>::zeros((p, p));
let mut xtviy = Array1::<f64>::zeros(p);
for rows in &self.groups {
let ng = rows.len() as f64;
let c = psi / (1.0 + ng * psi);
let mut xs = Array1::<f64>::zeros(p);
let mut ys = 0.0;
for &i in rows {
ys += self.endog[i];
for j in 0..p {
xs[j] += self.exog[[i, j]];
}
}
for &i in rows {
let yi = self.endog[i];
for a in 0..p {
let xia = self.exog[[i, a]];
xtviy[a] += xia * yi;
for b in 0..p {
xtvix[[a, b]] += xia * self.exog[[i, b]];
}
}
}
for a in 0..p {
xtviy[a] -= c * xs[a] * ys;
for b in 0..p {
xtvix[[a, b]] -= c * xs[a] * xs[b];
}
}
}
(xtvix, xtviy)
}
fn fe_params(&self, psi: f64) -> Result<Array1<f64>> {
let (xtvix, xtviy) = self.gls_pieces(psi);
solve(&xtvix, &xtviy)
}
fn quad_form(&self, psi: f64, beta: &Array1<f64>) -> f64 {
let p = self.k_fe();
let mut qf = 0.0;
for rows in &self.groups {
let ng = rows.len() as f64;
let c = psi / (1.0 + ng * psi);
let mut rsum = 0.0;
let mut rss = 0.0;
for &i in rows {
let mut fitted = 0.0;
for j in 0..p {
fitted += self.exog[[i, j]] * beta[j];
}
let r = self.endog[i] - fitted;
rsum += r;
rss += r * r;
}
qf += rss - c * rsum * rsum;
}
qf
}
fn profile_loglike(&self, psi: f64) -> Result<f64> {
let p = self.k_fe();
let beta = self.fe_params(psi)?;
let qf = self.quad_form(psi, &beta);
let mut logdet_v = 0.0;
for rows in &self.groups {
logdet_v += (1.0 + rows.len() as f64 * psi).ln();
}
let fac = self.fac();
let two_pi = std::f64::consts::TAU;
let mut like = -logdet_v / 2.0;
like -= fac * qf.ln() / 2.0;
like -= fac * two_pi.ln() / 2.0;
like += fac * fac.ln() / 2.0;
like -= fac / 2.0;
if self.reml() {
let (xtvix, _) = self.gls_pieces(psi);
let d = det(&xtvix)?;
like -= d.abs().ln() / 2.0;
}
let _ = p;
Ok(like)
}
fn joint_loglike(&self, packed: &Array1<f64>) -> f64 {
let p = self.k_fe();
let beta = packed.slice(ndarray::s![..p]).to_owned();
let psi = packed[p];
let qf = self.quad_form(psi, &beta);
let mut logdet_v = 0.0;
for rows in &self.groups {
logdet_v += (1.0 + rows.len() as f64 * psi).ln();
}
let fac = self.fac();
let two_pi = std::f64::consts::TAU;
let mut like = -logdet_v / 2.0;
like -= fac * qf.ln() / 2.0;
like -= fac * two_pi.ln() / 2.0;
like += fac * fac.ln() / 2.0;
like -= fac / 2.0;
if self.reml() {
let (xtvix, _) = self.gls_pieces(psi);
if let Ok(d) = det(&xtvix) {
like -= d.abs().ln() / 2.0;
}
}
like
}
pub fn fit(&self) -> Result<MixedLmResults> {
let neg = |theta: &Array1<f64>| -> f64 {
let psi = theta[0].exp();
match self.profile_loglike(psi) {
Ok(v) => -v,
Err(_) => f64::INFINITY,
}
};
let grad = |theta: &Array1<f64>| -> Array1<f64> {
let base = 1e-7;
let h = base * (1.0 + theta[0].abs());
let mut tp = theta.clone();
tp[0] = theta[0] + h;
let fp = neg(&tp);
tp[0] = theta[0] - h;
let fm = neg(&tp);
Array1::from_vec(vec![(fp - fm) / (2.0 * h)])
};
let start = Array1::from_vec(vec![0.0_f64]);
let res = minimize_bfgs(&start, neg, grad, 500, 1e-11)?;
let theta = newton_polish(&res.x[0], |t| {
let psi = t.exp();
self.profile_loglike(psi).map(|v| -v)
});
let psi = theta.exp();
let beta = self.fe_params(psi)?;
let qf = self.quad_form(psi, &beta);
let scale = qf / self.fac();
let cov_re = psi * scale; let llf = self.profile_loglike(psi)?;
let p = self.k_fe();
let mut packed = Array1::<f64>::zeros(p + 1);
for j in 0..p {
packed[j] = beta[j];
}
packed[p] = psi;
let hess = approx_hess(&packed, |x| self.joint_loglike(x));
let neg_hess = hess.mapv(|v| -v);
let pcov = inv(&neg_hess)?;
let mut bse_fe = Array1::<f64>::zeros(p);
for j in 0..p {
bse_fe[j] = pcov[[j, j]].max(0.0).sqrt();
}
Ok(MixedLmResults {
fe_params: beta,
cov_re,
scale,
llf,
bse_fe,
psi,
reml: self.reml(),
})
}
}
fn newton_polish<F>(theta0: &f64, f: F) -> f64
where
F: Fn(f64) -> Result<f64>,
{
let mut t = *theta0;
for _ in 0..50 {
let h = 1e-5 * (1.0 + t.abs());
let (fm, f0, fp) = match (f(t - h), f(t), f(t + h)) {
(Ok(a), Ok(b), Ok(c)) => (a, b, c),
_ => break,
};
let g = (fp - fm) / (2.0 * h);
let hh = (fp - 2.0 * f0 + fm) / (h * h);
if !hh.is_finite() || hh.abs() < 1e-14 {
break;
}
let step = g / hh;
if !step.is_finite() {
break;
}
t -= step;
if step.abs() < 1e-13 {
break;
}
}
t
}
#[derive(Clone, Debug)]
pub struct MixedLmResults {
pub fe_params: Array1<f64>,
pub cov_re: f64,
pub scale: f64,
pub llf: f64,
pub bse_fe: Array1<f64>,
pub psi: f64,
pub reml: bool,
}
impl MixedLmResults {
pub fn tvalues(&self) -> Array1<f64> {
let mut t = Array1::<f64>::zeros(self.fe_params.len());
for j in 0..t.len() {
t[j] = self.fe_params[j] / self.bse_fe[j];
}
t
}
pub fn pvalues(&self) -> Array1<f64> {
self.tvalues().mapv(|z| {
2.0 * (1.0 - norm_cdf(z.abs()))
})
}
pub fn conf_int(&self, alpha: f64) -> Array2<f64> {
let p = self.fe_params.len();
let q = norm_ppf(1.0 - alpha / 2.0);
let mut ci = Array2::<f64>::zeros((p, 2));
for j in 0..p {
ci[[j, 0]] = self.fe_params[j] - q * self.bse_fe[j];
ci[[j, 1]] = self.fe_params[j] + q * self.bse_fe[j];
}
ci
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
#[test]
fn profile_is_maximized_at_solution() {
let groups: Vec<i64> = vec![0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3];
let n = groups.len();
let y = Array1::from_vec(vec![
2.0, 2.4, 1.8, 5.1, 4.8, 5.4, -1.0, -0.6, -1.3, 3.2, 3.6, 2.9,
]);
let mut x = Array2::<f64>::ones((n, 2));
let x1 = [
0.1, 0.5, -0.2, 0.3, -0.4, 0.6, 0.0, 0.2, -0.1, 0.4, -0.3, 0.5,
];
for i in 0..n {
x[[i, 1]] = x1[i];
}
let m = MixedLm::new(y, x, &groups).unwrap();
let r = m.fit().unwrap();
let qf = m.quad_form(r.psi, &r.fe_params);
assert_abs_diff_eq!(r.scale, qf / m.fac(), epsilon = 1e-10);
assert_abs_diff_eq!(r.cov_re, r.psi * r.scale, epsilon = 1e-12);
let f = |t: f64| -m.profile_loglike(t.exp()).unwrap();
let theta = r.psi.ln();
let h = 1e-6;
let g = (f(theta + h) - f(theta - h)) / (2.0 * h);
assert!(g.abs() < 1e-5, "profile gradient {g} not ~0");
}
#[test]
fn ml_scale_uses_full_sample_size() {
let groups: Vec<i64> = vec![0, 0, 1, 1, 2, 2];
let y = Array1::from_vec(vec![1.0, 1.5, 3.0, 2.6, -0.5, 0.1]);
let x = Array2::<f64>::ones((6, 1));
let m = MixedLm::new(y, x, &groups).unwrap().method(RemlMethod::Ml);
let r = m.fit().unwrap();
let qf = m.quad_form(r.psi, &r.fe_params);
assert_abs_diff_eq!(r.scale, qf / 6.0, epsilon = 1e-10);
assert!(!r.reml);
}
}