neuralib 0.0.1

A simple Neural Network Library 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

use fastnum::{dec64, D64};

#[derive(Clone)]
pub struct Neuron {
    weights: Vec<D64>,
    bias: D64,
    //output: dyn Fn(D64) -> D64,
}

impl Neuron {
    pub fn new(input_size: usize) -> Neuron {
        Neuron {
            weights: vec![dec64!(0); input_size],
            bias: dec64!(0),
        }
    }
    
    pub fn activate(&self, inputs: &[D64]) -> crate::error::Result<D64> {
        if inputs.len() != self.weights.len() {
            return Err(crate::error::InputSizeError {
                    inputted: inputs.len(),
                    expected: self.weights.len(),
                    chain_depth: "Neuron".to_owned()
                }.into()
            );
        }
        
        let weighted: D64 = inputs.iter()
                        // Combine weights and inputs
                        .zip(self.weights.iter())
                        // Multiply them together
                        .map(|zipped| (*zipped.0) * (*zipped.1))
                        // Sum them up
                        .sum();
        let biased = weighted + self.bias;

        // TODO: use activation/output function
        
        Ok(biased)
    }
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn basic_neuron() {
        let neuron = Neuron {
            weights: vec![dec64!(1)],
            bias: dec64!(0),
        };


        assert_eq!(neuron.activate(&vec![dec64!(0)]).unwrap(), dec64!(0));
        assert_eq!(neuron.activate(&vec![dec64!(1)]).unwrap(), dec64!(1));
        assert_eq!(neuron.activate(&vec![dec64!(123)]).unwrap(), dec64!(123));
        assert_eq!(neuron.activate(&vec![dec64!(-50)]).unwrap(), dec64!(-50));
        assert_eq!(neuron.activate(&vec![dec64!(-0)]).unwrap(), dec64!(-0));
        assert_eq!(neuron.activate(&vec![dec64!(-1)]).unwrap(), dec64!(-1));
    }

    #[test]
    fn advanced_neuron() {
        let neuron = Neuron {
            weights: vec![dec64!(2), dec64!(3)],
            bias: dec64!(-1),
        };


        assert_eq!(neuron.activate(&vec![dec64!(3), dec64!(2)]).unwrap(), dec64!(11));
        assert_eq!(neuron.activate(&vec![dec64!(8), dec64!(2)]).unwrap(), dec64!(21));
        assert_eq!(neuron.activate(&vec![dec64!(0), dec64!(0)]).unwrap(), dec64!(-1));
        assert_eq!(neuron.activate(&vec![dec64!(1), dec64!(1)]).unwrap(), dec64!(4));
        assert_eq!(neuron.activate(&vec![dec64!(-4), dec64!(-1)]).unwrap(), dec64!(-12));
    }

    #[test]
    fn size_matching() {
        let neuron1 = Neuron {
            weights: vec![dec64!(1)],
            bias: dec64!(0),
        };
        let neuron2 = Neuron {
            weights: vec![dec64!(1), dec64!(1)],
            bias: dec64!(0),
        };

        assert!(neuron1.activate(&vec![dec64!(0), dec64!(0)]).is_err());
        assert!(neuron2.activate(&vec![dec64!(0)]).is_err());

        assert!(neuron1.activate(&vec![dec64!(0)]).is_ok());
        assert!(neuron2.activate(&vec![dec64!(0), dec64!(0)]).is_ok());
    }
}