use std::fmt;
use clap::{Arg, clap_app};
use ndarray::{Array, Axis, Ix2, s};
use ndarray_rand::RandomExt;
use num_traits::Float;
use rand::distributions::Uniform;
use saber::matrix_ops::get_gxg_dot_semi_kronecker_z_from_gz_and_ssq;
use saber::program_flow::OrExit;
use saber::simulation::sim_geno::get_gxg_arr;
use saber::trace_estimator::{estimate_gxg_dot_y_norm_sq, estimate_gxg_gram_trace, estimate_gxg_kk_trace};
use saber::util::{extract_numeric_arg, extract_optional_numeric_arg};
use saber::util::matrix_util::generate_plus_minus_one_bernoulli_matrix;
use saber::util::stats_util::{mean, n_choose_2, standard_deviation, sum_of_squares_f32};
use saber::util::timer::Timer;
#[inline]
fn get_error_ratio<T: Float>(estimated_value: T, true_value: T) -> T {
(estimated_value - true_value) / true_value
}
struct ValueTracker<T> {
pub values: Vec<T>
}
impl<T: Float> ValueTracker<T> {
pub fn new() -> ValueTracker<T> {
ValueTracker {
values: Vec::<T>::new()
}
}
#[inline]
pub fn append(&mut self, value: T) {
self.values.push(value);
}
#[inline]
pub fn mean(&self) -> f64 {
mean(self.values.iter())
}
#[inline]
pub fn std(&self) -> f64 {
standard_deviation(self.values.iter(), 0)
}
#[inline]
pub fn abs_mean(&self) -> f64 {
mean(self.values.iter().map(|x| x.abs()).collect::<Vec<T>>().iter())
}
#[inline]
pub fn abs_std(&self) -> f64 {
standard_deviation(self.values.iter().map(|x| x.abs()).collect::<Vec<T>>().iter(), 0)
}
#[inline]
pub fn to_percent_string(&self, sig_fig: usize) -> String {
format!("mean: {:.*}%\nstd: {:.*}%\nabs_mean: {:.*}%\nabs_std: {:.*}%",
sig_fig, self.mean() * 100., sig_fig, self.std() * 100.,
sig_fig, self.abs_mean() * 100., sig_fig, self.abs_std() * 100.)
}
}
impl<T: Float> fmt::Display for ValueTracker<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "mean: {}\nstd: {}\nabs_mean: {}\nabs_std: {}",
self.mean(), self.std(), self.abs_mean(), self.abs_std())
}
}
fn update_tracker_and_print<T: Float + fmt::Display>(real: T, estimate: T, tracker: &mut ValueTracker<T>, name: &str, sig_fig: usize) {
let err_ratio = get_error_ratio(estimate, real);
tracker.append(err_ratio);
println!("\niter: {} {}: {}\nerror ratio: {:.*}%", tracker.values.len(), name, estimate, sig_fig, err_ratio * T::from(100.).unwrap());
}
fn main() {
let mut app = clap_app!(test_gg_trace_estimates =>
(version: "0.1")
(author: "Aaron Zhou")
(@arg num_rows: -r <NUM_ROWS> "Number of rows, i.e. individuals; required")
(@arg num_cols: -c <NUM_COLUMNS> "Number of columns, i.e. SNPs; required")
(@arg num_random_vecs: -n <NUM_RAND_VECS> "Number of random vectors; required")
(@arg num_iter: -i [NUM_ITER] "Number of iterations to run")
);
app = app.arg(
Arg::with_name("num_tr_kk_iter")
.long("num-kk-iter").short("-k").takes_value(true).value_name("NUM_TR_KK_ITER")
.help("Number of iterations to run for tr(KK), being kept separate from -i as this is more time consuming")
);
let matches = app.get_matches();
let num_rows = extract_numeric_arg::<usize>(&matches, "num_rows")
.unwrap_or_exit(Some("failed to parse num_rows"));
let num_cols = extract_numeric_arg::<usize>(&matches, "num_cols")
.unwrap_or_exit(Some("failed to parse num_cols"));
let num_random_vecs = extract_numeric_arg::<usize>(&matches, "num_random_vecs")
.unwrap_or_exit(Some("failed to parse num_random_vecs"));
let num_iter = extract_optional_numeric_arg(&matches, "num_iter")
.unwrap_or_exit(Some("failed to parse num_iter"))
.unwrap_or(100);
let num_tr_kk_iter = extract_optional_numeric_arg(&matches, "num_tr_kk_iter")
.unwrap_or_exit(Some("failed to parse num_tr_kk_iter"))
.unwrap_or(10);
println!("num_rows: {}\nnum_cols: {}\nnum_random_vecs: {}\nnum_iter: {}\nnum_tr_kk_iter: {}",
num_rows, num_cols, num_random_vecs, num_iter, num_tr_kk_iter);
let gxg_basis = Array::random((num_rows, num_cols), Uniform::from(0..3))
.mapv(|e| e as f32);
println!("\n=> generating the GxG matrix");
let gxg = get_gxg_arr(&gxg_basis);
println!("GxG dim: {:?}", gxg.dim());
let gxg_basis2 = Array::random((num_rows, num_cols), Uniform::from(0..3))
.mapv(|e| e as f32);
let gxg2 = get_gxg_arr(&gxg_basis2);
let mut timer = Timer::new();
let percent_sig_fig = 3usize;
{
println!("\n=> calculating tr_kk_true");
let k = gxg.dot(&gxg.t()) / gxg.dim().1 as f32;
println!("k dim: {:?}", k.dim());
let tr_kk_true = sum_of_squares_f32(k.iter()) as f64;
println!("tr_kk_true: {}", tr_kk_true);
timer.print();
let mut err_tracker = ValueTracker::new();
println!("\n=> computing tr_kk_est");
for _ in 0..num_tr_kk_iter {
let tr_kk_est = test_double_vec_tr_gxg_kk_est(&gxg_basis, num_random_vecs);
println!("true: {} tr_kk_est: {}", tr_kk_true, tr_kk_est);
update_tracker_and_print(tr_kk_true, tr_kk_est, &mut err_tracker, "tr_kk_est", percent_sig_fig);
}
println!("\ntr(KK) estimate error ratio stats:\n{}", err_tracker.to_percent_string(percent_sig_fig));
}
timer.print();
{
println!("\n=> calculating tr_ki_kj_true");
let ki = gxg.dot(&gxg.t()) / gxg.dim().1 as f32;
let kj = gxg2.dot(&gxg2.t()) / gxg2.dim().1 as f32;
let mut tr = 0.;
for i in 0..gxg.dim().0 {
tr += ki.slice(s![i, ..]).dot(&kj.slice(s![.., i]));
}
let tr_ki_kj_true = tr as f64;
println!("tr_ki_kj_true: {}", tr_ki_kj_true);
timer.print();
let mut err_tracker = ValueTracker::new();
println!("\n=> computing tr_kk_est");
for _ in 0..num_tr_kk_iter {
let tr_est = test_double_vec_tr_gxg_ki_gxg_kj_est(&gxg_basis, &gxg_basis2, num_random_vecs, num_random_vecs);
println!("true: {} tr_kk_est: {}", tr_ki_kj_true, tr_est);
update_tracker_and_print(tr_ki_kj_true, tr_est, &mut err_tracker, "tr_ki_kj_est", percent_sig_fig);
}
println!("\ntr(Ki Kj) estimate error ratio stats:\n{}", err_tracker.to_percent_string(percent_sig_fig));
}
}
fn test_double_vec_tr_gxg_kk_est(gxg_basis: &Array<f32, Ix2>, num_random_vecs: usize) -> f64 {
let (num_people, num_snps) = gxg_basis.dim();
let m = n_choose_2(num_snps);
let z1 = generate_plus_minus_one_bernoulli_matrix(num_snps, num_random_vecs);
let z2 = generate_plus_minus_one_bernoulli_matrix(num_snps, num_random_vecs);
let ssq: Vec<f32> = gxg_basis.axis_iter(Axis(0)).map(|row| sum_of_squares_f32(row.iter())).collect();
let ssq = Array::from_shape_vec(num_people, ssq).unwrap();
let gz1 = gxg_basis.dot(&z1);
let gz2 = gxg_basis.dot(&z2);
let gz1 = get_gxg_dot_semi_kronecker_z_from_gz_and_ssq(gz1, &ssq);
let gz2 = get_gxg_dot_semi_kronecker_z_from_gz_and_ssq(gz2, &ssq);
sum_of_squares_f32(gz1.t().dot(&gz2).iter()) as f64 / (m * m * num_random_vecs * num_random_vecs) as f64
}
fn test_double_vec_tr_gxg_ki_gxg_kj_est(gxg_basis_1: &Array<f32, Ix2>, gxg_basis_2: &Array<f32, Ix2>,
num_rand_vecs_1: usize, num_rand_vecs_2: usize) -> f64 {
let (num_people, num_basis_snps_1) = gxg_basis_1.dim();
let num_basis_snps_2 = gxg_basis_2.dim().1;
let m1 = n_choose_2(num_basis_snps_1);
let m2 = n_choose_2(num_basis_snps_2);
let z1 = generate_plus_minus_one_bernoulli_matrix(num_basis_snps_1, num_rand_vecs_1);
let z2 = generate_plus_minus_one_bernoulli_matrix(num_basis_snps_2, num_rand_vecs_2);
let ssq_1: Vec<f32> = gxg_basis_1.axis_iter(Axis(0)).map(|row| sum_of_squares_f32(row.iter())).collect();
let ssq_2: Vec<f32> = gxg_basis_2.axis_iter(Axis(0)).map(|row| sum_of_squares_f32(row.iter())).collect();
let ssq_1 = Array::from_shape_vec(num_people, ssq_1).unwrap();
let ssq_2 = Array::from_shape_vec(num_people, ssq_2).unwrap();
let gz1 = gxg_basis_1.dot(&z1);
let gz2 = gxg_basis_2.dot(&z2);
let gz1 = get_gxg_dot_semi_kronecker_z_from_gz_and_ssq(gz1, &ssq_1);
let gz2 = get_gxg_dot_semi_kronecker_z_from_gz_and_ssq(gz2, &ssq_2);
sum_of_squares_f32(gz1.t().dot(&gz2).iter()) as f64 / (m1 * m2 * num_rand_vecs_1 * num_rand_vecs_2) as f64
}