lfa 0.15.0

Native rust implementations of linear function approximators.
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

#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(
    feature = "serde",
    derive(Serialize, Deserialize),
    serde(crate = "serde_crate")
)]
pub struct RationalQuadratic {
    pub variance: f64,
    pub lengthscales: Vec<f64>,

    pub power: f64,
}

impl RationalQuadratic {
    pub fn new(variance: f64, lengthscales: Vec<f64>, power: f64) -> RationalQuadratic {
        RationalQuadratic {
            power,
            variance,
            lengthscales,
        }
    }

    pub fn non_ard(power: f64, variance: f64, lengthscale: f64) -> RationalQuadratic {
        RationalQuadratic::new(variance, vec![lengthscale], power)
    }

    fn kernel_stationary(&self, r: f64) -> f64 {
        self.variance * (-self.power * (r * r / 2.0).ln_1p()).exp()
    }
}

impl Default for RationalQuadratic {
    fn default() -> RationalQuadratic { RationalQuadratic::non_ard(1.0, 1.0, 2.0) }
}

impl super::Kernel<f64> for RationalQuadratic {
    fn kernel(&self, x: f64, y: f64) -> f64 {
        self.kernel_stationary((x - y).abs() / self.lengthscales[0])
    }
}

impl super::Kernel<&[f64]> for RationalQuadratic {
    fn kernel(&self, x: &[f64], y: &[f64]) -> f64 {
        let x = x
            .into_iter()
            .zip(y.into_iter())
            .map(|(x, y)| x - y)
            .zip(self.lengthscales.iter())
            .map(|(d, l)| d / l)
            .fold(0.0, |acc, z| acc + z * z)
            .sqrt();

        self.kernel_stationary(x)
    }
}

impl super::Kernel<&Vec<f64>> for RationalQuadratic {
    fn kernel(&self, x: &Vec<f64>, y: &Vec<f64>) -> f64 {
        super::Kernel::<&[f64]>::kernel(self, x, y)
    }
}