use ndarray::{s, Array1, Array2};
use solow_core::error::{Error, Result};
use solow_linalg::svd;
#[derive(Clone, Debug)]
pub struct Pca {
data: Array2<f64>,
ncomp: Option<usize>,
standardize: bool,
demean: bool,
normalize: bool,
}
impl Pca {
pub fn new(data: Array2<f64>) -> Self {
Pca {
data,
ncomp: None,
standardize: true,
demean: true,
normalize: true,
}
}
pub fn ncomp(mut self, ncomp: usize) -> Self {
self.ncomp = Some(ncomp);
self
}
pub fn standardize(mut self, standardize: bool) -> Self {
self.standardize = standardize;
self
}
pub fn demean(mut self, demean: bool) -> Self {
self.demean = demean;
self
}
pub fn normalize(mut self, normalize: bool) -> Self {
self.normalize = normalize;
self
}
pub fn fit(&self) -> Result<PcaResults> {
let (nobs, nvar) = self.data.dim();
if nobs == 0 || nvar == 0 {
return Err(Error::Shape("data must be non-empty".into()));
}
let min_dim = nobs.min(nvar);
let ncomp = match self.ncomp {
None => min_dim,
Some(c) => {
if c == 0 {
return Err(Error::Shape("ncomp must be positive".into()));
}
c.min(min_dim)
}
};
let mut mu = Array1::<f64>::zeros(nvar);
let mut sigma = Array1::<f64>::ones(nvar);
for j in 0..nvar {
let col = self.data.column(j);
let m = col.sum() / nobs as f64;
mu[j] = m;
let var = col.iter().map(|&x| (x - m) * (x - m)).sum::<f64>() / nobs as f64;
sigma[j] = var.sqrt();
}
let mut transformed = self.data.clone();
if self.standardize {
for j in 0..nvar {
let s = sigma[j];
for i in 0..nobs {
transformed[[i, j]] = (transformed[[i, j]] - mu[j]) / s;
}
}
} else if self.demean {
for j in 0..nvar {
for i in 0..nobs {
transformed[[i, j]] -= mu[j];
}
}
}
let (_u, s, vt) = svd(&transformed)?;
let eig_all = s.mapv(|x| x * x);
let k = s.len();
let mut order: Vec<usize> = (0..k).collect();
order.sort_by(|&a, &b| eig_all[b].total_cmp(&eig_all[a]));
let mut eigenvals = Array1::<f64>::zeros(ncomp);
let mut eigenvecs = Array2::<f64>::zeros((nvar, ncomp));
for (c, &idx) in order.iter().take(ncomp).enumerate() {
eigenvals[c] = eig_all[idx];
for r in 0..nvar {
eigenvecs[[r, c]] = vt[[idx, r]];
}
}
let mut factors = transformed.dot(&eigenvecs);
let loadings = eigenvecs.clone();
let mut coeff = eigenvecs.t().to_owned();
if self.normalize {
for c in 0..ncomp {
let sc = eigenvals[c].sqrt();
for j in 0..nvar {
coeff[[c, j]] *= sc;
}
let inv = 1.0 / sc;
for i in 0..nobs {
factors[[i, c]] *= inv;
}
}
}
let scores = factors.clone();
let tss_indiv: Array1<f64> = (0..nvar)
.map(|j| transformed.column(j).iter().map(|&x| x * x).sum::<f64>())
.collect();
let tss: f64 = tss_indiv.sum();
let mut rsquare = Array1::<f64>::zeros(ncomp + 1);
for i in 0..=ncomp {
let proj = project(&factors, &coeff, i);
let rss: f64 = proj.iter().map(|&x| x * x).sum::<f64>();
let ess = tss - rss;
rsquare[i] = 1.0 - ess / tss;
}
let explained_variance_ratio = eigenvals.mapv(|v| v / tss);
Ok(PcaResults {
eigenvals,
eigenvecs,
loadings,
factors,
scores,
coeff,
rsquare,
explained_variance_ratio,
mu,
sigma,
ncomp,
nobs,
nvar,
standardize: self.standardize,
demean: self.demean,
})
}
}
fn project(factors: &Array2<f64>, coeff: &Array2<f64>, ncomp: usize) -> Array2<f64> {
let f = factors.slice(s![.., 0..ncomp]);
let c = coeff.slice(s![0..ncomp, ..]);
f.dot(&c)
}
#[derive(Clone, Debug)]
pub struct PcaResults {
pub eigenvals: Array1<f64>,
pub eigenvecs: Array2<f64>,
pub loadings: Array2<f64>,
pub factors: Array2<f64>,
pub scores: Array2<f64>,
pub coeff: Array2<f64>,
pub rsquare: Array1<f64>,
pub explained_variance_ratio: Array1<f64>,
pub mu: Array1<f64>,
pub sigma: Array1<f64>,
pub ncomp: usize,
pub nobs: usize,
pub nvar: usize,
standardize: bool,
demean: bool,
}
impl PcaResults {
pub fn project(&self, ncomp: usize) -> Result<Array2<f64>> {
if ncomp > self.ncomp {
return Err(Error::Shape(
"ncomp must not exceed the number of fitted components".into(),
));
}
let mut projection = project(&self.factors, &self.coeff, ncomp);
if self.standardize {
for j in 0..self.nvar {
for i in 0..self.nobs {
projection[[i, j]] *= self.sigma[j];
}
}
}
if self.standardize || self.demean {
for j in 0..self.nvar {
for i in 0..self.nobs {
projection[[i, j]] += self.mu[j];
}
}
}
Ok(projection)
}
}
#[cfg(test)]
mod tests {
use super::*;
use ndarray::array;
fn check_close(a: &Array1<f64>, b: &[f64], tol: f64) {
assert_eq!(a.len(), b.len());
for i in 0..a.len() {
assert!((a[i] - b[i]).abs() <= tol, "idx {i}: {} vs {}", a[i], b[i]);
}
}
#[test]
fn eigenvals_descending() {
let data = array![
[1.0, 2.0, 0.5],
[2.0, 1.0, 1.5],
[3.0, 0.0, 2.5],
[4.0, 1.0, 0.0],
[2.0, 3.0, 1.0],
];
let res = Pca::new(data).fit().unwrap();
for c in 1..res.eigenvals.len() {
assert!(res.eigenvals[c - 1] >= res.eigenvals[c]);
}
}
#[test]
fn rsquare_monotone_and_full() {
let data = array![
[1.0, 2.0, 0.5],
[2.0, 1.0, 1.5],
[3.0, 0.0, 2.5],
[4.0, 1.0, 0.0],
[2.0, 3.0, 1.0],
];
let res = Pca::new(data).fit().unwrap();
assert!((res.rsquare[0]).abs() < 1e-12);
for i in 1..res.rsquare.len() {
assert!(res.rsquare[i] >= res.rsquare[i - 1] - 1e-12);
}
let last = res.rsquare[res.rsquare.len() - 1];
assert!((last - 1.0).abs() < 1e-9);
}
#[test]
fn explained_variance_sums_to_one_full_rank() {
let data = array![
[1.0, 2.0, 0.5],
[2.0, 1.0, 1.5],
[3.0, 0.0, 2.5],
[4.0, 1.0, 0.0],
[2.0, 3.0, 1.0],
];
let res = Pca::new(data).fit().unwrap();
let total: f64 = res.explained_variance_ratio.sum();
assert!((total - 1.0).abs() < 1e-9);
}
#[test]
fn standardize_demeans_and_scales() {
let data = array![[1.0, 5.0], [2.0, 3.0], [3.0, 4.0], [4.0, 1.0],];
let res = Pca::new(data).fit().unwrap();
let sum: f64 = res.eigenvals.sum();
assert!((sum - (res.nobs * res.nvar) as f64).abs() < 1e-9);
}
#[test]
fn reconstruction_recovers_data_full_rank() {
let data = array![
[1.0, 2.0, 0.5],
[2.0, 1.0, 1.5],
[3.0, 0.0, 2.5],
[4.0, 1.0, 0.0],
[2.0, 3.0, 1.0],
];
let res = Pca::new(data.clone()).fit().unwrap();
let recon = res.project(res.ncomp).unwrap();
for i in 0..data.nrows() {
for j in 0..data.ncols() {
assert!((recon[[i, j]] - data[[i, j]]).abs() < 1e-7);
}
}
}
#[test]
fn no_standardize_no_demean() {
let data = array![[2.0, 0.0], [0.0, 2.0], [1.0, 1.0]];
let res = Pca::new(data)
.standardize(false)
.demean(false)
.normalize(false)
.fit()
.unwrap();
let v = &res.eigenvecs;
let mut dot = 0.0;
for r in 0..v.nrows() {
dot += v[[r, 0]] * v[[r, 0]];
}
check_close(&array![dot], &[1.0], 1e-9);
}
}