Struct rusty_machine::learning::lin_reg::LinRegressor

pub struct LinRegressor { /* private fields */ }

Linear Regression Model.

Contains option for optimized parameter.

Implementations

impl LinRegressor

pub fn parameters(&self) -> Option<&Vector<f64>>

Get the parameters from the model.

Returns an option that is None if the model has not been trained.

impl LinRegressor

pub fn train_with_optimization(
    &mut self,
    inputs: &Matrix<f64>,
    targets: &Vector<f64>
)

Train the linear regressor using Gradient Descent.

Examples

use rusty_machine::learning::lin_reg::LinRegressor;
use rusty_machine::learning::SupModel;
use rusty_machine::linalg::Matrix;
use rusty_machine::linalg::Vector;

let inputs = Matrix::new(4,1,vec![1.0,3.0,5.0,7.0]);
let targets = Vector::new(vec![1.,5.,9.,13.]);

let mut lin_mod = LinRegressor::default();

// Train the model
lin_mod.train_with_optimization(&inputs, &targets);

// Now we'll predict a new point
let new_point = Matrix::new(1,1,vec![10.]);
let _ = lin_mod.predict(&new_point).unwrap();

Trait Implementations

impl Debug for LinRegressor

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

Formats the value using the given formatter.

impl Default for LinRegressor

fn default() -> LinRegressor

Returns the “default value” for a type.

impl Optimizable for LinRegressor

type Inputs = Matrix<f64>

The input data type to the model.

type Targets = Vector<f64>

The target data type to the model.

fn compute_grad(
    &self,
    params: &[f64],
    inputs: &Matrix<f64>,
    targets: &Vector<f64>
) -> (f64, Vec<f64>)

Compute the gradient for the model.

impl SupModel<Matrix<f64>, Vector<f64>> for LinRegressor

fn train(
    &mut self,
    inputs: &Matrix<f64>,
    targets: &Vector<f64>
) -> LearningResult<()>

Train the linear regression model.

Takes training data and output values as input.

Examples

use rusty_machine::learning::lin_reg::LinRegressor;
use rusty_machine::linalg::Matrix;
use rusty_machine::linalg::Vector;
use rusty_machine::learning::SupModel;

let mut lin_mod = LinRegressor::default();
let inputs = Matrix::new(3,1, vec![2.0, 3.0, 4.0]);
let targets = Vector::new(vec![5.0, 6.0, 7.0]);

lin_mod.train(&inputs, &targets).unwrap();

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output value from input data.

Model must be trained before prediction can be made.