rsrl 0.8.1

A fast, extensible reinforcement learning framework in Rust
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

#![allow(dead_code)]
use ndarray::Array2;
use rand::{seq::SliceRandom, thread_rng, Rng};
use std::f64;

pub fn argmaxima<I: IntoIterator<Item = f64>>(vals: I) -> (Vec<usize>, f64) {
    let mut max = f64::MIN;
    let mut ixs = vec![];

    for (i, v) in vals.into_iter().enumerate() {
        if (v - max).abs() < 1e-7 {
            ixs.push(i);
        } else if v > max {
            max = v;
            ixs.clear();
            ixs.push(i);
        }
    }

    (ixs, max)
}

pub fn argmax_first<I: IntoIterator<Item = f64>>(vals: I) -> (usize, f64) {
    vals.into_iter().enumerate().fold(
        (0, f64::MIN),
        |(i, x), (j, y)| {
            if y - x > 1e-7 {
                (j, y)
            } else {
                (i, x)
            }
        },
    )
}

pub fn argmax_last<I: IntoIterator<Item = f64>>(vals: I) -> (usize, f64) {
    vals.into_iter().enumerate().fold(
        (0, f64::MIN),
        |(i, x), (j, y)| {
            if y - x > -1e-7 {
                (j, y)
            } else {
                (i, x)
            }
        },
    )
}

pub fn argmax_choose<I: IntoIterator<Item = f64>>(vals: I) -> (usize, f64) {
    let (maxima, value) = argmaxima(vals);

    let maximum = if maxima.len() == 1 {
        maxima[0]
    } else {
        *maxima
            .choose(&mut thread_rng())
            .expect("No valid maxima to choose from in `argmax_choose`.")
    };

    (maximum, value)
}

pub fn argmax_choose_rng<R, I>(rng: &mut R, vals: I) -> (usize, f64)
where
    R: Rng + ?Sized,
    I: IntoIterator<Item = f64>,
{
    let (maxima, value) = argmaxima(vals);

    let maximum = if maxima.len() == 1 {
        maxima[0]
    } else {
        *maxima
            .choose(rng)
            .expect("No valid maxima to choose from in `argmax_choose`.")
    };

    (maximum, value)
}

/// Compute the pseudo-inverse of a real matrix using SVD.
pub fn pinv(m: &Array2<f64>) -> Result<Array2<f64>, ndarray_linalg::error::LinalgError> {
    use ndarray::Axis;
    use ndarray_linalg::svd::SVD;

    let m_dim = m.dim();
    let max_dim = m_dim.0.max(m_dim.1);

    m.svd(true, true).map(|(u, s, vt)| {
        // u: (M x M)
        // s: diag{(M x N)} => (max{M, N} x 1)
        // vt: (N x N)
        let u = u.unwrap();
        let vt = vt.unwrap();

        let threshold = f64::EPSILON
            * max_dim as f64
            * s.fold(
                unsafe { *s.uget(0) },
                |acc, &v| {
                    if v > acc {
                        v
                    } else {
                        acc
                    }
                },
            );

        // (max{M, N} x 1)
        let sinv = s
            .mapv(|v| if v > threshold { 1.0 / v } else { 0.0 })
            .insert_axis(Axis(1));

        vt.t().dot(&(&u.t() * &sinv))
    })
}