Struct RidgeFit 

pub struct RidgeFit { /* private fields */ }

A fitted ridge-regression model and its diagnostics.

Ridge solves min ‖y − Xβ‖² + λ‖β_pen‖². This type fits it in closed form via the SVD of the (centered) predictors, which is both numerically stable and hands us the singular values that every ridge diagnostic is expressed in.

Intercept and scaling

If a constant column is detected it is treated as an unpenalized intercept: predictors and response are mean-centered, the penalty is applied only to the slopes, and the intercept is recovered from the means (the same convention as scikit-learn’s Ridge). Ridge is not scale-invariant, so standardize predictors beforehand if that matters for your λ.

What the diagnostics mean

The OLS notions still exist but take their ridge forms: leverage is the diagonal of H_λ, and the parameter count is the effective degrees of freedom df(λ) = Σ dⱼ²/(dⱼ²+λ) (plus one for the intercept), which slides smoothly from p at λ = 0 down toward 1 as λ → ∞.

Implementations

impl RidgeFit

pub fn new(x: Array2<f64>, y: Array1<f64>, lambda: f64) -> Result<Self>

Fit ridge regression of y on X with penalty lambda ≥ 0.

A constant column of X, if present, is auto-detected and used as an unpenalized intercept (see the type docs).

Errors

• RegressionError::EmptyInput / RegressionError::ShapeMismatch as for OlsFit.
• RegressionError::InvalidParameter if lambda < 0.

Unlike OLS, ridge is well-defined even when n ≤ p or the predictors are collinear (that is much of the point), so those are not errors here.

pub fn lambda(&self) -> f64

The penalty λ this model was fit with.

pub fn n_observations(&self) -> usize

Number of observations.

pub fn n_parameters(&self) -> usize

Number of coefficients (design columns, intercept included).

pub fn has_intercept(&self) -> bool

Whether an intercept (constant column) is present and unpenalized.

pub fn design_matrix(&self) -> ArrayView2<'_, f64>

The design matrix as fitted.

pub fn response(&self) -> ArrayView1<'_, f64>

The response vector.

pub fn singular_values(&self) -> &[f64]

Singular values of the centered predictor matrix — the dⱼ that the shrinkage factors dⱼ²/(dⱼ²+λ) and the effective degrees of freedom are expressed in.

pub fn coefficients(&self) -> ArrayView1<'_, f64>

Ridge coefficients, aligned to the design columns.

pub fn fitted_values(&self) -> ArrayView1<'_, f64>

Fitted values ŷ = Xβ.

pub fn residuals(&self) -> ArrayView1<'_, f64>

Residuals y − ŷ.

pub fn residual_sum_of_squares(&self) -> f64

Residual sum of squares.

pub fn leverage(&self) -> ArrayView1<'_, f64>

Ridge leverage — the diagonal of H_λ = X(XᵀX + λI)⁻¹Xᵀ — computed from the SVD without ever forming the n × n hat matrix.

Unlike OLS leverage these do not sum to the number of columns; they sum to the effective degrees of freedom effective_df, which is the ridge analogue of that identity.

pub fn effective_df(&self) -> f64

Effective degrees of freedom df(λ) = base + Σ dⱼ²/(dⱼ²+λ), where base is 1 for the unpenalized intercept (else 0).

This is the parameter count ridge actually spends: it equals p at λ = 0 and shrinks toward 1 (just the intercept) as λ → ∞. It drives the effective residual df and the information criteria below.

pub fn effective_residual_df(&self) -> f64

Effective residual degrees of freedom n − df(λ).

pub fn residual_variance(&self) -> f64

Effective residual variance estimate RSS / (n − df(λ)).

pub fn gcv(&self) -> f64

Generalized Cross-Validation score GCV(λ) = (RSS / n) / (1 − df(λ)/n)².

A rotation-invariant approximation to leave-one-out CV; the λ minimizing it is a standard, data-driven penalty choice (see select_lambda_gcv).

pub fn log_likelihood(&self) -> f64

Gaussian log-likelihood at the fitted residual variance (same form as the OLS log-likelihood, using RSS from the ridge fit).

pub fn aic(&self) -> f64

AIC using the effective degrees of freedom as the parameter count: AIC = −2ℓ + 2·df(λ).

Using df(λ) rather than p is what makes information criteria meaningful under shrinkage — the model is charged for the degrees of freedom it effectively uses, not the nominal column count.

pub fn bic(&self) -> f64

BIC using the effective degrees of freedom: BIC = −2ℓ + ln(n)·df(λ).

pub fn ridge_vif(&self) -> Vec<f64>

Ridge Variance Inflation Factors, aligned to the design columns (intercept slot is NaN).

Computed as the diagonal of (R + λ_c I)⁻¹ R (R + λ_c I)⁻¹ on the standardized predictors, where R is their correlation matrix. This is the exact variance-inflation of the ridge coefficient estimates and it reduces to the ordinary OLS VIF at λ = 0, which is what makes the “VIF before vs after regularization” comparison meaningful: as λ grows these fall, quantifying how ridge tames collinearity. λ_c is the penalty on the correlation scale (λ divided by n, since the correlation matrix uses the 1/n-scaled cross-products).

Trait Implementations

impl Clone for RidgeFit

fn clone(&self) -> RidgeFit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RidgeFit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.