sproutml 0.1.1

A simple Machine Learning Library built 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

use crate::{activation::{Activation, ActivationFunction}, conv_params::PaddingType, layer::Layer};

pub struct LayerBuilder {
    kernels: Vec<usize>,
    paddings: Vec<PaddingType>,
    strides: Vec<usize>,
    activations: Vec<ActivationFunction>,
    cn_layers: usize,
    img: [usize; 2],
    dense_layers: Vec<usize>,
}

impl LayerBuilder {
    pub fn new() -> Self {
        LayerBuilder {
            kernels: vec![],
            paddings: vec![],
            strides: vec![],
            activations: vec![],
            cn_layers: 0,
            img: [0; 2],
            dense_layers: vec![],
        }
    }

    pub fn set_kernels(&mut self, kernels: Vec<usize>) {
        self.kernels = kernels;
    }

    pub fn set_paddings(&mut self, paddings: Vec<PaddingType>) {
        self.paddings = paddings;
    }

    pub fn set_strides(&mut self, strides: Vec<usize>) {
        self.strides = strides;
    }

    pub fn set_activations(&mut self, activations: Vec<ActivationFunction>) {
        self.activations = activations;
    }

    pub fn set_cn_layers(&mut self, cn_layers: usize) {
        self.cn_layers = cn_layers;
    }

    pub fn set_img(&mut self, img: [usize; 2]) {
        self.img = img;
    }

    pub fn set_dense_layers(&mut self, dense_layers: Vec<usize>) {
        self.dense_layers = dense_layers;
    }

    pub fn cnn(&self) -> Vec<Layer> {
        let width = self.img[0];
        let width = self.img[1];
        let mut layers = vec![
            Layer::conv(self.kernels[0].clone(), self.paddings[0].clone(), self.strides[0].clone(), self.activations[0].clone())
        ];
        let layer_count = self.cn_layers + self.dense_layers.len();
        let mut switch = false;
        for i in 1..layer_count {
            if i == self.cn_layers {
                switch = true;
            }
            if !switch {
                layers.push(
                    Layer::conv(self.kernels[i].clone(), self.paddings[i].clone(), self.strides[i].clone(), self.activations[i].clone())
                );
            } else {
                let nodes = [self.dense_layers[i - 1], self.dense_layers[i]];
                layers.push(
                    Layer::dense(nodes, self.activations[i].clone())
                );
            }
        }

        vec![]
    }
}