Struct LinearRegression 

pub struct LinearRegression<State = Untrained> { /* private fields */ }

Linear Regression model

Implementations

impl LinearRegression<Untrained>

pub fn new() -> Self

Create a new Linear Regression model

pub fn fit_intercept(self, fit_intercept: bool) -> Self

Set whether to fit intercept

pub fn regularization(self, alpha: f64) -> Self

Set regularization (Ridge/L2)

pub fn lasso(alpha: f64) -> Self

Create a Lasso regression model (L1 penalty)

pub fn elastic_net(alpha: f64, l1_ratio: f64) -> Self

Create an ElasticNet regression model (L1 + L2 penalty)

pub fn penalty(self, penalty: Penalty) -> Self

Set penalty

pub fn solver(self, solver: Solver) -> Self

Set solver

pub fn max_iter(self, max_iter: usize) -> Self

Set maximum iterations

pub fn warm_start(self, warm_start: bool) -> Self

Set whether to use warm start

impl LinearRegression<Untrained>

pub fn fit_with_warm_start( self, x: &Array2<Float>, y: &Array1<Float>, initial_coef: Option<&Array1<Float>>, initial_intercept: Option<Float>, ) -> Result<LinearRegression<Trained>>

Fit the linear regression model with warm start

Uses the provided coefficients and intercept as initialization for iterative solvers

impl LinearRegression<Trained>

pub fn coef(&self) -> &Array1<Float>

Get the coefficients

pub fn intercept(&self) -> Option<Float>

Get the intercept

impl LinearRegression<Untrained>

pub fn fit_with_early_stopping( self, x: &Array2<Float>, y: &Array1<Float>, early_stopping_config: EarlyStoppingConfig, ) -> Result<(LinearRegression<Trained>, ValidationInfo)>

Fit the linear regression model with early stopping based on validation metrics

This method is particularly useful for regularized methods (Lasso, ElasticNet) where early stopping can prevent overfitting.

pub fn fit_with_early_stopping_split( self, x_train: &Array2<Float>, y_train: &Array1<Float>, x_val: &Array2<Float>, y_val: &Array1<Float>, early_stopping_config: EarlyStoppingConfig, ) -> Result<(LinearRegression<Trained>, ValidationInfo)>

Fit the linear regression model with early stopping using pre-split validation data

This gives you more control over the train/validation split compared to fit_with_early_stopping which automatically splits the data.

Trait Implementations

impl<State: Clone> Clone for LinearRegression<State>

fn clone(&self) -> LinearRegression<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug> Debug for LinearRegression<State>

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

Formats the value using the given formatter.

impl Default for LinearRegression<Untrained>

fn default() -> Self

Returns the “default value” for a type.

impl Estimator for LinearRegression<Untrained>

type Config = LinearRegressionConfig

Configuration type for the estimator

type Error = SklearsError

Error type for the estimator

type Float = f64

The numeric type used by this estimator

fn config(&self) -> &Self::Config

Get estimator configuration

fn validate_config(&self) -> Result<(), SklearsError>

Validate estimator configuration with detailed error context

fn check_compatibility( &self, n_samples: usize, n_features: usize, ) -> Result<(), SklearsError>

Check if estimator is compatible with given data dimensions

fn metadata(&self) -> EstimatorMetadata

Get estimator metadata

impl Fit<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>> for LinearRegression<Untrained>

type Fitted = LinearRegression<Trained>

The fitted model type

fn fit(self, x: &Array2<Float>, y: &Array1<Float>) -> Result<Self::Fitted>

Fit the model to the provided data with validation

fn fit_with_validation( self, x: &X, y: &Y, _x_val: Option<&X>, _y_val: Option<&Y>, ) -> Result<(Self::Fitted, FitMetrics), SklearsError>

where Self: Sized,

Fit with custom validation and early stopping

impl ModelValidation for LinearRegression

type Error = SklearsError

fn validate_config(self) -> Result<Self, Self::Error>

Validate the model configuration

impl Predict<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>> for LinearRegression<Trained>

fn predict(&self, x: &Array2<Float>) -> Result<Array1<Float>>

Make predictions on the provided data

fn predict_with_uncertainty( &self, x: &X, ) -> Result<(Output, UncertaintyMeasure), SklearsError>

Make predictions with confidence intervals

impl Score<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>> for LinearRegression<Trained>

type Float = f64

The numeric type for score calculation

fn score(&self, x: &Array2<Float>, y: &Array1<Float>) -> Result<f64>

Calculate the score of the model on the provided data