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

//! Kernel options for support vector machines.

use std::fmt::{Display, Formatter};

use smartcore::error::{Failed, FailedError};
use smartcore::svm::Kernels as SmartcoreKernels;

/// Smartcore kernel conversion result containing both the enum representation and a boxed kernel
/// function suitable for Smartcore APIs.
pub struct SmartcoreKernel {
    /// Smartcore kernel enum configured with validated parameters.
    pub kernel: SmartcoreKernels,
    /// Boxed kernel function implementing [`smartcore::svm::Kernel`].
    pub function: Box<dyn smartcore::svm::Kernel>,
}

/// Kernel options for use with support vector machines
#[derive(serde::Serialize, serde::Deserialize)]
pub enum Kernel {
    /// Linear Kernel
    Linear,

    /// Polynomial kernel
    Polynomial(f64, f64, f64),

    /// Radial basis function kernel
    RBF(f64),

    /// Sigmoid kernel
    Sigmoid(f64, f64),
}

impl Display for Kernel {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Linear => write!(f, "Linear"),
            Self::Polynomial(degree, gamma, coef) => write!(
                f,
                "Polynomial\n    degree = {degree}\n    gamma = {gamma}\n    coef = {coef}"
            ),
            Self::RBF(gamma) => write!(f, "RBF\n    gamma = {gamma}"),
            Self::Sigmoid(gamma, coef) => {
                write!(f, "Sigmoid\n    gamma = {gamma}\n    coef = {coef}")
            }
        }
    }
}

impl Kernel {
    /// Convert the enum variant into Smartcore kernel components.
    ///
    /// # Errors
    ///
    /// Returns [`Failed`] when kernel parameters are invalid (for example, NaN or non-positive
    /// values where Smartcore requires strictly positive parameters).
    pub fn to_smartcore(&self) -> Result<SmartcoreKernel, Failed> {
        match self {
            Self::Linear => {
                let kernel = SmartcoreKernels::linear();
                Ok(SmartcoreKernel {
                    function: Box::new(kernel.clone()),
                    kernel,
                })
            }
            Self::Polynomial(degree, gamma, coef0) => {
                validate_positive(*degree, "polynomial degree")?;
                validate_positive(*gamma, "polynomial gamma")?;
                validate_finite(*coef0, "polynomial coef0")?;
                let kernel = SmartcoreKernels::polynomial()
                    .with_degree(*degree)
                    .with_gamma(*gamma)
                    .with_coef0(*coef0);
                Ok(SmartcoreKernel {
                    function: Box::new(kernel.clone()),
                    kernel,
                })
            }
            Self::RBF(gamma) => {
                validate_positive(*gamma, "RBF gamma")?;
                let kernel = SmartcoreKernels::rbf().with_gamma(*gamma);
                Ok(SmartcoreKernel {
                    function: Box::new(kernel.clone()),
                    kernel,
                })
            }
            Self::Sigmoid(gamma, coef0) => {
                validate_finite(*gamma, "sigmoid gamma")?;
                validate_finite(*coef0, "sigmoid coef0")?;
                let kernel = SmartcoreKernels::sigmoid()
                    .with_gamma(*gamma)
                    .with_coef0(*coef0);
                Ok(SmartcoreKernel {
                    function: Box::new(kernel.clone()),
                    kernel,
                })
            }
        }
    }
}

fn validate_finite(value: f64, name: &str) -> Result<(), Failed> {
    if value.is_finite() {
        Ok(())
    } else {
        Err(Failed::because(
            FailedError::ParametersError,
            &format!("{name} must be finite"),
        ))
    }
}

fn validate_positive(value: f64, name: &str) -> Result<(), Failed> {
    validate_finite(value, name)?;
    if value > 0.0 {
        Ok(())
    } else {
        Err(Failed::because(
            FailedError::ParametersError,
            &format!("{name} must be positive"),
        ))
    }
}