Struct linfa_linear::TweedieRegressor

pub struct TweedieRegressor { /* fields omitted */ }

Generalized Linear Model (GLM) with a Tweedie distribution

The Regressor can be used to model different GLMs depending on power, which determines the underlying distribution.

Power	Distribution
0	Normal
1	Poisson
(1, 2)	Compound Poisson Gamma
2	Gamma
3	Inverse Gaussian

NOTE: No distribution exists between 0 and 1

Learn more from sklearn’s excellent User Guide

Examples

Here’s an example on how to train a GLM on the diabetes dataset

use linfa::traits::{Fit, Predict};
use linfa_linear::TweedieRegressor;
use linfa::prelude::SingleTargetRegression;

let dataset = linfa_datasets::diabetes();
let model = TweedieRegressor::default().fit(&dataset).unwrap();
let pred = model.predict(&dataset);
let r2 = pred.r2(&dataset).unwrap();
println!("r2 from prediction: {}", r2);

Implementations

impl TweedieRegressor

pub fn new() -> Self

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

Constant that multiplies with the penalty term and thus determines the regularization strenght. alpha set to 0 is equivalent to unpenalized GLM.

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

Specifies whether a bias or intercept should be added to the model

pub fn power(self, power: f64) -> Self

The power determines the underlying target distribution

pub fn link(self, link: Link) -> Self

The link function of the GLM, for mapping from linear predictor x @ coeff + intercept to the prediction. If no value is set, the link will be selected based on the following,

• identity for Normal distribution (power = 0)
• log for Poisson, Gamma and Inverse Gaussian distributions (power >= 1)

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

Maximum number of iterations for the LBFGS solver

pub fn tol(self, tol: f64) -> Self

Stopping criterion for the LBFGS solver

Trait Implementations

impl Default for TweedieRegressor

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TweedieRegressor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<A: Float, D: Data<Elem = A>, T: AsTargets<Elem = A>> Fit<'_, ArrayBase<D, Dim<[usize; 2]>>, T> for TweedieRegressor

type Object = Result<FittedTweedieRegressor<A>>

fn fit(
    &self,
    ds: &DatasetBase<ArrayBase<D, Ix2>, T>
) -> Result<FittedTweedieRegressor<A>>

impl Serialize for TweedieRegressor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.