radiate-gp 1.3.1

Extensions for radiate. Genetic Programming implementations for graphs (neural networks) and trees.
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

use radiate_core::random_provider;
use radiate_utils::{Float, Matrix};

#[derive(Default, Clone)]
pub struct DataSet<T> {
    features: Matrix<T>,
    labels: Matrix<T>,
}

impl<T> DataSet<T> {
    pub fn new(inputs: Vec<Vec<T>>, outputs: Vec<Vec<T>>) -> Self {
        let features = Matrix::from(inputs);
        let labels = Matrix::from(outputs);

        DataSet { features, labels }
    }

    pub fn iter(&self) -> impl Iterator<Item = (&[T], &[T])> {
        self.features.iter().zip(self.labels.iter())
    }

    pub fn len(&self) -> usize {
        self.features.rows()
    }

    pub fn is_empty(&self) -> bool {
        self.features.is_empty()
    }

    pub fn shape(&self) -> (usize, usize, usize) {
        let num_samples = self.features.rows();
        let input_dim = if num_samples > 0 {
            self.features.cols()
        } else {
            0
        };
        let output_dim = if num_samples > 0 {
            self.labels.cols()
        } else {
            0
        };

        (num_samples, input_dim, output_dim)
    }

    pub fn append(mut self, features: Vec<T>, labels: Vec<T>) -> Self {
        self.features.append_row(features);
        self.labels.append_row(labels);
        self
    }
}

impl<T: Clone> DataSet<T> {
    #[inline]
    pub fn features(&self) -> Vec<Vec<T>> {
        (0..self.features.rows())
            .map(|i| self.features.row(i).to_vec())
            .collect()
    }

    #[inline]
    pub fn labels(&self) -> Vec<Vec<T>> {
        (0..self.labels.rows())
            .map(|i| self.labels.row(i).to_vec())
            .collect()
    }

    pub fn shuffle(self) -> Self {
        let mut indices: Vec<usize> = (0..self.len()).collect();
        random_provider::shuffle(&mut indices);

        let features = self.features.sort_by_indices(&indices);
        let labels = self.labels.sort_by_indices(&indices);

        DataSet { features, labels }
    }

    #[inline]
    pub fn split(self, ratio: f32) -> (Self, Self) {
        let ratio = ratio.clamp(0.0, 1.0);
        let split = (self.len() as f32 * ratio).round() as usize;
        let (features_left, features_right) = self.features.split_at_row(split);
        let (labels_left, labels_right) = self.labels.split_at_row(split);

        (
            DataSet {
                features: features_left,
                labels: labels_left,
            },
            DataSet {
                features: features_right,
                labels: labels_right,
            },
        )
    }
}

impl<F: Float> DataSet<F> {
    pub fn standardize(mut self) -> Self {
        self.features.standardize();
        self
    }

    pub fn normalize(mut self) -> Self {
        self.features.normalize();
        self
    }
}

impl<T> From<(Vec<Vec<T>>, Vec<Vec<T>>)> for DataSet<T> {
    fn from(data: (Vec<Vec<T>>, Vec<Vec<T>>)) -> Self {
        DataSet::new(data.0, data.1)
    }
}

impl<T> From<(Matrix<T>, Matrix<T>)> for DataSet<T> {
    fn from(data: (Matrix<T>, Matrix<T>)) -> Self {
        DataSet {
            features: data.0,
            labels: data.1,
        }
    }
}