automl 0.3.0

Automated machine learning for classification and regression
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Utilities for data preprocessing.

use crate::settings::PreProcessing;
use crate::utils::features::{FeatureError, interaction_features, polynomial_features};
use smartcore::{
    decomposition::{
        pca::{PCA, PCAParameters},
        svd::{SVD, SVDParameters},
    },
    linalg::{
        basic::arrays::{Array, Array2},
        traits::{
            cholesky::CholeskyDecomposable, evd::EVDDecomposable, qr::QRDecomposable,
            svd::SVDDecomposable,
        },
    },
    numbers::{floatnum::FloatNumber, realnum::RealNumber},
};

/// Handles optional preprocessing steps.
pub struct Preprocessor<INPUT, InputArray>
where
    INPUT: RealNumber + FloatNumber,
    InputArray: Clone
        + Array<INPUT, (usize, usize)>
        + Array2<INPUT>
        + EVDDecomposable<INPUT>
        + SVDDecomposable<INPUT>
        + CholeskyDecomposable<INPUT>
        + QRDecomposable<INPUT>,
{
    pca: Option<PCA<INPUT, InputArray>>,
    svd: Option<SVD<INPUT, InputArray>>,
}

impl<INPUT, InputArray> Preprocessor<INPUT, InputArray>
where
    INPUT: RealNumber + FloatNumber,
    InputArray: Clone
        + Array<INPUT, (usize, usize)>
        + Array2<INPUT>
        + EVDDecomposable<INPUT>
        + SVDDecomposable<INPUT>
        + CholeskyDecomposable<INPUT>
        + QRDecomposable<INPUT>,
{
    /// Create a new empty preprocessor.
    pub fn new() -> Self {
        Self {
            pca: None,
            svd: None,
        }
    }

    /// Train preprocessing models based on settings.
    pub fn train(&mut self, x: &InputArray, settings: &PreProcessing) {
        match settings {
            PreProcessing::ReplaceWithPCA {
                number_of_components,
            } => {
                self.train_pca(x, *number_of_components);
            }
            PreProcessing::ReplaceWithSVD {
                number_of_components,
            } => {
                self.train_svd(x, *number_of_components);
            }
            _ => {}
        }
    }

    /// Apply preprocessing to data.
    pub fn preprocess(
        &self,
        x: InputArray,
        settings: &PreProcessing,
    ) -> Result<InputArray, FeatureError> {
        Ok(match settings {
            PreProcessing::None => x,
            PreProcessing::AddInteractions => interaction_features(x)?,
            PreProcessing::AddPolynomial { order } => polynomial_features(x, *order)?,
            PreProcessing::ReplaceWithPCA {
                number_of_components: _,
            } => self.pca_features(&x),
            PreProcessing::ReplaceWithSVD {
                number_of_components: _,
            } => self.svd_features(&x),
        })
    }

    fn train_pca(&mut self, x: &InputArray, n: usize) {
        let pca = PCA::fit(
            x,
            PCAParameters::default()
                .with_n_components(n)
                .with_use_correlation_matrix(true),
        )
        .expect("Could not train PCA preprocessor");
        self.pca = Some(pca);
    }

    fn pca_features(&self, x: &InputArray) -> InputArray {
        self.pca
            .as_ref()
            .expect("PCA model not trained")
            .transform(x)
            .expect("Could not transform data using PCA")
    }

    fn train_svd(&mut self, x: &InputArray, n: usize) {
        let svd = SVD::fit(x, SVDParameters::default().with_n_components(n))
            .expect("Could not train SVD preprocessor");
        self.svd = Some(svd);
    }

    fn svd_features(&self, x: &InputArray) -> InputArray {
        self.svd
            .as_ref()
            .expect("SVD model not trained")
            .transform(x)
            .expect("Could not transform data using SVD")
    }
}