matrux 0.1.0

Neural network implementation 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

use std::collections::HashMap;

use crate::{Scalar, MatrixPlan, Matrix, Activation};

pub trait Layer<I: Scalar> {
    fn input_shape(&self) -> (usize, usize);

    fn output_shape(&self) -> (usize, usize);

    fn prepare_input(&mut self, id: usize);

    fn assign_input(&self, output: &mut HashMap<String, Matrix<I>>);

    fn set_weights(&mut self, weights: Matrix<I>);

    fn get_weights(&self) -> Option<&Matrix<I>>;

    fn forward(&self, from: Matrix<I>) -> Matrix<I>;

    fn forward_plan(&self, from: MatrixPlan<I>) -> MatrixPlan<I>;

    fn backward_plan(&self, prior: MatrixPlan<I>, layer_value: MatrixPlan<I>, lower_layer_value: MatrixPlan<I>) -> (MatrixPlan<I>, MatrixPlan<I>);
}

pub struct DenseLayer<I: Scalar, A: Activation> {
    weights: Matrix<I>,
    id: Option<usize>,
    input: Option<MatrixPlan<I>>,
    activation: A,
}

impl<I: Scalar, A: Activation> DenseLayer<I, A> {
    pub fn new(weights: Matrix<I>, activation: A) -> Self {
        Self {
            weights,
            id: None,
            input: None,
            activation,
        }
    }
}

impl<I: Scalar, A: Activation> Layer<I> for DenseLayer<I, A> {

    fn input_shape(&self) -> (usize, usize) {
        (self.weights.cols(), 1)
    }

    fn output_shape(&self) -> (usize, usize) {
        (self.weights.rows(), 1)
    }

    fn prepare_input(&mut self, id: usize) {
        self.id = Some(id);
        self.input = Some(MatrixPlan::input(self.weights.rows(), self.weights.cols(), format!("weights_{}", self.id.unwrap())));
    }

    fn assign_input(&self, output: &mut HashMap<String, Matrix<I>>) {
        assert!(self.id.is_some());
        output.insert(format!("weights_{}", self.id.unwrap()), self.weights.clone());
    }

    fn set_weights(&mut self, weights: Matrix<I>) {
        self.weights = weights;
    }

    fn get_weights(&self) -> Option<&Matrix<I>> {
        Some(&self.weights)
    }

    fn forward(&self, from: Matrix<I>) -> Matrix<I> {
        self.activation.forward(self.weights.clone() * from)
    }

    fn forward_plan(&self, from: MatrixPlan<I>) -> MatrixPlan<I> {
        assert!(self.input.is_some());
        self.activation.forward_plan(self.input.clone().unwrap() * from)
    }

    fn backward_plan(&self, prior: MatrixPlan<I>, layer_value: MatrixPlan<I>, lower_layer_value: MatrixPlan<I>) -> (MatrixPlan<I>, MatrixPlan<I>) {
        assert!(self.input.is_some());

        let sigma = prior.hadamard_mul(self.activation.derivative(layer_value));
        (self.input.clone().unwrap().transpose() * &sigma, sigma * lower_layer_value.transpose())
    }
}