shrinkage 0.4.0

Composable regularized statistical models in Rust.
Documentation
use lazymatrix::{ColumnStats, LazyMatrix, RawColumns};

use crate::error::{finite, invalid};
use crate::solver::irls::{Workspace, cold_intercept, iterate, validate_rows};
use crate::{
    CoordinatePenalty, FitError, Irls, IrlsFit, NullModelDatafit, PathFit, PathOptions,
    PathPenalty, PathSolver, PenaltyMaximum, Problem, QuadraticModelDatafit,
    RegularizationPathSolver,
};

impl<M, D, P, Q> PathSolver<Problem<&M, D, P>, Q> for Irls
where
    M: RawColumns<f64> + ColumnStats<f64> + ?Sized,
    D: QuadraticModelDatafit,
    Q: CoordinatePenalty,
{
    type Fit = IrlsFit;
    type Error = FitError<M::Error>;

    fn solve_path(
        &self,
        problem: &Problem<&M, D, P>,
        penalties: Vec<Q>,
    ) -> Result<PathFit<IrlsFit, Q>, Self::Error> {
        self.validate()?;
        validate_rows(problem.design().nrows(), problem.datafit())?;
        let zeros = vec![0.0; problem.design().ncols()];
        let intercept = cold_intercept(problem.datafit())?;
        problem
            .datafit()
            .value(&vec![intercept; problem.design().nrows()])
            .map_err(|e| FitError::from_component(e, 0))?;
        for penalty in &penalties {
            penalty
                .validate_input(&zeros)
                .map_err(|e| FitError::from_component(e, 0))?;
        }
        if penalties.is_empty() {
            return Ok(PathFit::explicit(Vec::new(), penalties));
        }
        let prepared = problem.prepare(problem.datafit().fits_intercept())?;
        let mut work = Workspace::new(prepared.matrix.nrows(), prepared.matrix.ncols());
        work.intercept = intercept;
        work.path = true;
        let solutions = penalties
            .iter()
            .map(|penalty| {
                iterate(
                    &prepared.matrix,
                    problem.datafit(),
                    penalty,
                    self,
                    &mut work,
                )
            })
            .collect::<Result<Vec<_>, _>>()?;
        let preprocessing = prepared.into_preprocessing();
        let fits = solutions
            .into_iter()
            .map(|solution| IrlsFit::from_solution(solution, preprocessing.clone()))
            .collect::<Result<_, _>>()?;
        Ok(PathFit::explicit(fits, penalties))
    }
}

impl<M, D, P> RegularizationPathSolver<Problem<&M, D, P>> for Irls
where
    M: RawColumns<f64> + ColumnStats<f64> + ?Sized,
    D: QuadraticModelDatafit + NullModelDatafit,
    P: PathPenalty,
    P::AtStrength: CoordinatePenalty,
{
    type Fit = IrlsFit;
    type Penalty = P::AtStrength;
    type Error = FitError<M::Error>;

    fn maximum_penalty(&self, problem: &Problem<&M, D, P>) -> Result<PenaltyMaximum, Self::Error> {
        self.validate()?;
        validate_rows(problem.design().nrows(), problem.datafit())?;
        let prepared = problem.prepare(problem.datafit().fits_intercept())?;
        let (_, gradient) = null_state(&prepared.matrix, problem.datafit())?;
        problem
            .penalty()
            .maximum_penalty(&gradient)
            .map_err(|e| FitError::from_component(e, 0))
    }

    fn solve_regularization_path(
        &self,
        problem: &Problem<&M, D, P>,
        options: &PathOptions,
    ) -> Result<PathFit<IrlsFit, P::AtStrength>, Self::Error> {
        options.validate()?;
        self.validate()?;
        validate_rows(problem.design().nrows(), problem.datafit())?;
        let prepared = problem.prepare(problem.datafit().fits_intercept())?;
        let (intercept, gradient) = null_state(&prepared.matrix, problem.datafit())?;
        let mut sequence = options
            .sequence(
                problem.penalty(),
                &gradient,
                prepared.matrix.nrows(),
                prepared.matrix.ncols(),
            )
            .map_err(|e| FitError::from_component(e, 0))?;
        let mut work = Workspace::new(prepared.matrix.nrows(), prepared.matrix.ncols());
        work.path = true;
        work.intercept = intercept;
        let null = super::null_deviance(problem.datafit(), prepared.matrix.nrows())?;
        let solutions = sequence.fit(options, null, |penalty| {
            let solution = iterate(
                &prepared.matrix,
                problem.datafit(),
                penalty,
                self,
                &mut work,
            )?;
            let deviance = problem
                .datafit()
                .deviance(&work.eta)
                .map_err(|e| FitError::from_component(e, 0))?;
            let termination = solution.termination;
            Ok((solution, deviance, termination))
        })?;
        let preprocessing = prepared.into_preprocessing();
        let fits = solutions
            .into_iter()
            .map(|solution| IrlsFit::from_solution(solution, preprocessing.clone()))
            .collect::<Result<_, _>>()?;
        Ok(PathFit::automatic(fits, sequence))
    }
}

fn null_state<M, D, E>(matrix: &LazyMatrix<M>, datafit: &D) -> Result<(f64, Vec<f64>), FitError<E>>
where
    M: RawColumns<f64>,
    D: QuadraticModelDatafit + NullModelDatafit,
{
    let intercepts = datafit
        .null_intercepts()
        .map_err(|e| FitError::from_component(e, 0))?;
    if intercepts.len() != 1
        || !intercepts[0].is_finite()
        || (!datafit.fits_intercept() && intercepts[0] != 0.0)
    {
        return Err(invalid(
            "a vector datafit must return one finite null intercept, zero when disabled",
        ));
    }
    let mut derivative = vec![0.0; matrix.nrows()];
    datafit
        .gradient(&vec![intercepts[0]; matrix.nrows()], &mut derivative)
        .map_err(|e| FitError::from_component(e, 0))?;
    for &value in &derivative {
        finite(value, "checking the null gradient", 0)?;
    }
    let sum = finite(derivative.iter().sum(), "summing the null gradient", 0)?;
    let gradient = (0..matrix.ncols())
        .map(|j| {
            finite(
                matrix.column(j).dot_with_sum(&derivative, sum),
                "computing the null coefficient gradient",
                0,
            )
            .map_err(FitError::from)
        })
        .collect::<Result<Vec<_>, _>>()?;
    Ok((intercepts[0], gradient))
}