shrinkage 0.4.0

Composable regularized statistical models in Rust.
Documentation
use super::tests::matrix::Matrix;
use super::*;
use crate::{Binomial, Normalization};

fn fixture() -> Matrix {
    Matrix::from_rows(&[
        &[-1.0, 0.0001, 0.0002, -0.0001],
        &[1.0, 0.0002, -0.0001, 0.0001],
        &[-1.0, -0.0001, 0.0001, 0.0002],
        &[1.0, 0.0001, -0.0002, -0.0001],
        &[-1.0, 0.0002, -0.0001, 0.0001],
        &[1.0, -0.0001, 0.0001, 0.0002],
    ])
}

fn compare_gaussian<P: ReducedCoordinatePenalty + Clone>(penalty: P) {
    let x = fixture();
    let y = [-3.0, 3.0, -3.0, 3.0, -3.0, 3.0];
    let problem = Problem::new(&x, Gaussian::new(&y), penalty).normalize(Normalization::None);
    let options = HybridCoordinateDescent::<Vec<f64>>::new()
        .tolerance(1e-10)
        .check_every(1);
    let initial = crate::InitialPoint {
        coefficients: &[2.5, 0.0, 0.0, 0.0],
        intercept: 0.0,
    };
    let fit = solve_observed(&problem, &options, Some(initial), &mut NoObserver).unwrap();
    let reference = solve_observed(
        &problem,
        &options.screening(false),
        Some(initial),
        &mut NoObserver,
    )
    .unwrap();
    assert_eq!(fit.termination(), Termination::Converged);
    assert_eq!(reference.termination(), Termination::Converged);
    assert_eq!(
        fit.screening_diagnostics().screened_features,
        3,
        "{}: {:?}",
        std::any::type_name::<P>(),
        fit.screening_diagnostics()
    );
    assert_eq!(fit.screening_diagnostics().active_dimension, 1);
    assert_eq!(
        fit.screening_diagnostics().certificate_passes,
        fit.diagnostic_checks()
    );
    assert!(fit.duality_gap().unwrap() < 1e-9);
    assert!(reference.dual_certificate().is_none());
    assert!((fit.objective() - reference.objective()).abs() < 1e-12);
    assert!((fit.stopping_value() - reference.stopping_value()).abs() < 1e-10);
    for (&actual, &expected) in fit.coefficients().iter().zip(reference.coefficients()) {
        assert!((actual - expected).abs() < 1e-9);
    }
    for (j, &label) in fit.cluster_labels().iter().enumerate() {
        assert_eq!(
            fit.cluster_values()[label].abs(),
            fit.coefficients()[j].abs()
        );
    }
}

#[test]
fn gaussian_screening_retains_complete_penalties_and_full_diagnostics() {
    compare_gaussian(ClusteredLasso::new(0.3, 0.01));
    compare_gaussian(ChainFusedLasso::new(0.3, 0.02));
    compare_gaussian(Slope::new(vec![0.3, 0.25, 0.2, 0.15]));
}

fn compare_binomial<P: ReducedCoordinatePenalty + Clone>(penalty: P) {
    let x = fixture();
    let y = [0.1, 0.9, 0.1, 0.9, 0.1, 0.9];
    let problem = Problem::new(&x, Binomial::new(&y), penalty).normalize(Normalization::None);
    let options = HybridCoordinateDescent::<Vec<f64>>::new()
        .tolerance(1e-9)
        .check_every(1);
    let fit = problem.fit_with(&options).unwrap();
    let reference = problem.fit_with(&options.screening(false)).unwrap();
    assert_eq!(fit.termination(), Termination::Converged);
    assert_eq!(reference.termination(), Termination::Converged);
    assert_eq!(fit.screening_diagnostics().screened_features, 3);
    assert_eq!(
        fit.screening_diagnostics().certificate_passes,
        fit.outer_iterations() + 1
    );
    assert!(fit.duality_gap().unwrap() < 1e-8);
    assert!((fit.objective() - reference.objective()).abs() < 1e-12);
    for (&actual, &expected) in fit.coefficients().iter().zip(reference.coefficients()) {
        assert!((actual - expected).abs() < 1e-7);
    }
    assert!(reference.duality_gap().is_none());
}

#[test]
fn binomial_certificates_use_original_outer_iterates() {
    compare_binomial(ClusteredLasso::new(0.03, 0.001));
    compare_binomial(ChainFusedLasso::new(0.03, 0.002));
    compare_binomial(Slope::new(vec![0.03, 0.025, 0.02, 0.015]));
}

#[test]
fn screened_hybrid_products_and_aggregates_skip_matrix_entries() {
    let x = fixture();
    let y = [-3.0, 3.0, -3.0, 3.0, -3.0, 3.0];
    let penalty = ClusteredLasso::new(0.3, 0.01);
    let datafit = Gaussian::new(&y).fit_intercept(false);
    let problem = Problem::new(&x, datafit, penalty).normalize(Normalization::None);
    let mut design = NativeDesign::<_, Vec<f64>>::new_screenable(problem.prepare(false).unwrap());
    let mut work = Workspace::<ClusteredLasso>::new(y.len(), 4);
    let (objective, _) = work
        .diagnostics(&mut design, datafit, problem.penalty(), 1.0, 0)
        .unwrap();
    assert!(
        work.screening
            .check(
                &mut design,
                &datafit,
                problem.penalty(),
                &work.coefficients,
                &work.product,
                objective,
                0,
                true,
            )
            .unwrap()
    );
    assert_eq!(work.screening.active, [0]);
    x.visits.set(0);
    work.prepare(&mut design, datafit, 0).unwrap();
    let selected = x.visits.get();
    x.visits.set(0);
    work.prepare_with_selection(&mut design, datafit, 0, true)
        .unwrap();
    assert!(selected < x.visits.get());
    work.state.set_screened(&work.screening.zeroed);
    x.visits.set(0);
    work.state
        .rebuild(design.matrix(), &work.coefficients, &work.residual, 0)
        .unwrap();
    assert_eq!(x.visits.get(), y.len());
    work.state
        .sweep::<std::convert::Infallible>(
            &mut work.coefficients,
            &mut work.intercept,
            false,
            problem.penalty(),
            0,
        )
        .unwrap();
    assert_eq!(&work.coefficients[1..], [0.0; 3]);
}