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

    use serde_derive::{Deserialize, Serialize};


#[derive(Serialize, Deserialize, PartialEq, Clone)]
pub enum LossType {
    MSE,
    CEL
}

#[derive(Serialize, Deserialize)]
pub struct LossFunction {
    pub loss_type: LossType
}


impl LossFunction {
    pub fn new(loss_type: LossType) -> Self {
        LossFunction {
            loss_type
        }
    }

    pub fn function(&self, outputs: &Vec<f64>, targets: &Vec<f64>, true_index: usize) -> f64 {
        match self.loss_type {
            LossType::MSE => 
                {   
                    let mut cost = 0.0;
                    for i in 0..targets.len() {
                        cost += (outputs[i] -  targets[i]).powf(2.0);
                    }
                    cost
                },
            LossType::CEL => 
            {
                -outputs[true_index].ln()
            },
        }
    }

    pub fn derivative(&self, outputs: &Vec<f64>, targets: &Vec<f64>, true_index: usize) -> Vec<f64> {
        match self.loss_type {
            LossType::MSE => 
                {   
                    let mut loss_gradient: Vec<f64> = vec![0.0; targets.len()];
                    for l in 0..targets.len() {
                        loss_gradient[l] += 2.0 * (outputs[l] - targets[l]);
                    }
                    loss_gradient
                },
            LossType::CEL => 
                {
                    let mut gradients = outputs.clone();
                    gradients[true_index] -= 1.0;
                    gradients
                },
        }
    }
}