sarek 0.1.0

A work-in-progress, experimental neural network library utilizing TensorFlow Keras
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use {
    crate::{
        core::{
            data_source::{
                DataSource
            },
            shape::{
                Shape
            },
            split_data_source::{
                SplitDataSource
            }
        }
    }
};

/// A data set used for training.
pub struct DataSet< I, O >
    where I: DataSource,
          O: DataSource
{
    input_data: I,
    expected_output_data: O
}

impl< I, O > DataSet< I, O >
    where I: DataSource,
          O: DataSource
{
    pub fn new( input_data: I, expected_output_data: O ) -> Self {
        assert_eq!(
            input_data.len(),
            expected_output_data.len(),
            "The training input data has {} samples which is not equal to the amount of samples in the expected output data where we have {} samples",
            input_data.len(),
            expected_output_data.len()
        );

        DataSet {
            input_data,
            expected_output_data
        }
    }

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

    pub fn is_empty( &self ) -> bool {
        self.len() == 0
    }

    pub fn input_shape( &self ) -> Shape {
        self.input_data.shape()
    }

    pub fn output_shape( &self ) -> Shape {
        self.expected_output_data.shape()
    }

    pub fn input_data( &self ) -> &I {
        &self.input_data
    }

    pub fn expected_output_data( &self ) -> &O {
        &self.expected_output_data
    }

    /// Clones the data sources and splits the set into two.
    ///
    /// ```rust
    /// # use sarek::{Shape, DataSource, DataSet, SliceSource};
    /// let data: &[f32] = &[ 1.0, 2.0, 3.0, 4.0 ];
    /// let expected_data: &[u32] = &[ 10, 20 ];
    /// let src_in = SliceSource::from( Shape::new_2d( 1, 2 ), data );
    /// let src_out = SliceSource::from( Shape::new_1d( 1 ), expected_data );
    /// let mut src = DataSet::new( src_in, src_out );
    ///
    /// assert_eq!( src.len(), 2 );
    ///
    /// let (src_train, src_test) = src.clone_and_split( 0.5 );
    ///
    /// assert_eq!( src_train.len(), 1 );
    /// assert_eq!( src_test.len(), 1 );
    /// ```
    pub fn clone_and_split( self, split_at: f32 )
        -> (
            DataSet< SplitDataSource< I >, SplitDataSource< O > >,
            DataSet< SplitDataSource< I >, SplitDataSource< O > >
        )
        where I: Clone, O: Clone
    {
        assert!( split_at >= 0.0 );
        assert!( split_at <= 1.0 );

        let left_count = (self.len() as f32 * split_at) as usize;
        let left_range = 0..left_count;
        let right_range = left_count..self.len();

        let right = DataSet {
            input_data: SplitDataSource::new( self.input_data.clone(), right_range.clone() ),
            expected_output_data: SplitDataSource::new( self.expected_output_data.clone(), right_range )
        };

        let left = DataSet {
            input_data: SplitDataSource::new( self.input_data, left_range.clone() ),
            expected_output_data: SplitDataSource::new( self.expected_output_data, left_range )
        };

        (left, right)
    }
}

#[cfg(test)]
mod tests {
    use {
        crate::{
            core::{
                shape::{
                    Shape
                },
                slice_source::{
                    SliceSource
                }
            }
        },
        super::{
            DataSet
        }
    };

    #[test]
    fn test_data_set_basics() {
        let input_data: Vec< u32 > = vec![ 1, 2, 3, 4 ];
        let output_data: Vec< u32 > = vec![ 10, 20 ];
        let inputs = SliceSource::from( Shape::new_2d( 1, 2 ), input_data );
        let outputs = SliceSource::from( Shape::new_1d( 1 ), output_data );
        let data_set = DataSet::new( inputs, outputs );

        assert_eq!( data_set.len(), 2 );
        assert_eq!( data_set.is_empty(), false );
        assert_eq!( data_set.input_shape(), Shape::new_2d( 1, 2 ) );
    }

}