Struct LinearRegressionParameters 

pub struct LinearRegressionParameters {
    pub solver: LinearRegressionSolverName,
}

Parameters for linear regression (re-export from Smartcore) Linear Regression parameters

Fields

solver: LinearRegressionSolverName

Solver to use for estimation of regression coefficients.

Implementations

impl LinearRegressionParameters

pub fn with_solver( self, solver: LinearRegressionSolverName, ) -> LinearRegressionParameters

Solver to use for estimation of regression coefficients.

Examples found in repository

examples/maximal_regression.rs (line 19)

fn main() {
    // Totally customize settings
    let settings = Settings::default_regression()
        .with_number_of_folds(3)
        .shuffle_data(true)
        .verbose(true)
        .with_final_model(FinalModel::Blending {
            algorithm: Algorithm::Linear,
            meta_training_fraction: 0.15,
            meta_testing_fraction: 0.15,
        })
        .skip(Algorithm::RandomForestRegressor)
        .sorted_by(Metric::RSquared)
        .with_preprocessing(PreProcessing::AddInteractions)
        .with_linear_settings(
            LinearRegressionParameters::default().with_solver(LinearRegressionSolverName::QR),
        )
        .with_lasso_settings(
            LassoParameters::default()
                .with_alpha(1.0)
                .with_tol(1e-4)
                .with_normalize(true)
                .with_max_iter(1000),
        )
        .with_ridge_settings(
            RidgeRegressionParameters::default()
                .with_alpha(1.0)
                .with_normalize(true)
                .with_solver(RidgeRegressionSolverName::Cholesky),
        )
        .with_elastic_net_settings(
            ElasticNetParameters::default()
                .with_tol(1e-4)
                .with_normalize(true)
                .with_alpha(1.0)
                .with_max_iter(1000)
                .with_l1_ratio(0.5),
        )
        .with_knn_regressor_settings(
            KNNRegressorParameters::default()
                .with_algorithm(KNNAlgorithmName::CoverTree)
                .with_k(3)
                .with_distance(Distance::Euclidean)
                .with_weight(KNNWeightFunction::Uniform),
        )
        .with_svr_settings(
            SVRParameters::default()
                .with_eps(0.1)
                .with_tol(1e-3)
                .with_c(1.0)
                .with_kernel(Kernel::Linear),
        )
        .with_random_forest_regressor_settings(
            RandomForestRegressorParameters::default()
                .with_m(1)
                .with_max_depth(5)
                .with_min_samples_leaf(1)
                .with_n_trees(10)
                .with_min_samples_split(2),
        )
        .with_decision_tree_regressor_settings(
            DecisionTreeRegressorParameters::default()
                .with_min_samples_split(2)
                .with_max_depth(15)
                .with_min_samples_leaf(1),
        );

    // Save the settings for later use
    settings.save("examples/maximal_regression_settings.yaml");

    // Load a dataset from smartcore and add it to the regressor along with the customized settings
    let mut model = SupervisedModel::new(smartcore::dataset::diabetes::load_dataset(), settings);

    // Run a model comparison with all models at default settings
    model.train();

    // Print the results
    println!("{}", model);

    // Save teh model for later
    model.save("examples/maximal_regression_model.aml");
}

examples/print_settings.rs (line 11)

fn main() {
    let regressor_settings = automl::Settings::default_regression()
        .with_number_of_folds(3)
        .shuffle_data(true)
        .verbose(true)
        .sorted_by(Metric::RSquared)
        .with_preprocessing(PreProcessing::AddInteractions)
        .with_linear_settings(
            LinearRegressionParameters::default().with_solver(LinearRegressionSolverName::QR),
        )
        .with_lasso_settings(
            LassoParameters::default()
                .with_alpha(10.0)
                .with_tol(1e-10)
                .with_normalize(true)
                .with_max_iter(10_000),
        )
        .with_ridge_settings(
            RidgeRegressionParameters::default()
                .with_alpha(10.0)
                .with_normalize(true)
                .with_solver(RidgeRegressionSolverName::Cholesky),
        )
        .with_elastic_net_settings(
            ElasticNetParameters::default()
                .with_tol(1e-10)
                .with_normalize(true)
                .with_alpha(1.0)
                .with_max_iter(10_000)
                .with_l1_ratio(0.5),
        )
        .with_knn_regressor_settings(
            KNNRegressorParameters::default()
                .with_algorithm(KNNAlgorithmName::CoverTree)
                .with_k(3)
                .with_distance(Distance::Euclidean)
                .with_weight(KNNWeightFunction::Uniform),
        )
        .with_svr_settings(
            SVRParameters::default()
                .with_eps(1e-10)
                .with_tol(1e-10)
                .with_c(1.0)
                .with_kernel(Kernel::Linear),
        )
        .with_random_forest_regressor_settings(
            RandomForestRegressorParameters::default()
                .with_m(100)
                .with_max_depth(5)
                .with_min_samples_leaf(20)
                .with_n_trees(100)
                .with_min_samples_split(20),
        )
        .with_decision_tree_regressor_settings(
            DecisionTreeRegressorParameters::default()
                .with_min_samples_split(20)
                .with_max_depth(5)
                .with_min_samples_leaf(20),
        );

    let classifier_settings = automl::Settings::default_classification()
        .with_number_of_folds(3)
        .shuffle_data(true)
        .verbose(true)
        .sorted_by(Metric::Accuracy)
        .with_preprocessing(PreProcessing::AddInteractions)
        .with_random_forest_classifier_settings(
            RandomForestClassifierParameters::default()
                .with_m(100)
                .with_max_depth(5)
                .with_min_samples_leaf(20)
                .with_n_trees(100)
                .with_min_samples_split(20),
        )
        .with_logistic_settings(LogisticRegressionParameters::default())
        .with_svc_settings(
            SVCParameters::default()
                .with_epoch(10)
                .with_tol(1e-10)
                .with_c(1.0)
                .with_kernel(Kernel::Linear),
        )
        .with_decision_tree_classifier_settings(
            DecisionTreeClassifierParameters::default()
                .with_min_samples_split(20)
                .with_max_depth(5)
                .with_min_samples_leaf(20),
        )
        .with_knn_classifier_settings(
            KNNClassifierParameters::default()
                .with_algorithm(KNNAlgorithmName::CoverTree)
                .with_k(3)
                .with_distance(Distance::Hamming)
                .with_weight(KNNWeightFunction::Uniform),
        )
        .with_gaussian_nb_settings(GaussianNBParameters::default().with_priors(vec![1.0, 1.0]))
        .with_categorical_nb_settings(CategoricalNBParameters::default().with_alpha(1.0));

    println!("{}", regressor_settings);
    println!("{}", classifier_settings)
}

Trait Implementations

impl Clone for LinearRegressionParameters

fn clone(&self) -> LinearRegressionParameters

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinearRegressionParameters

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

Formats the value using the given formatter.

impl Default for LinearRegressionParameters

fn default() -> LinearRegressionParameters

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LinearRegressionParameters

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LinearRegressionParameters

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

where __S: Serializer,

Serialize this value into the given Serde serializer.