native_neural_network 0.3.1

Lib no_std Rust for native neural network (.rnn)
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

pub fn step_decay(base_lr: f32, step: u32, step_size: u32, gamma: f32) -> Option<f32> {
    if step_size == 0
        || !base_lr.is_finite()
        || base_lr <= 0.0
        || !gamma.is_finite()
        || gamma <= 0.0
    {
        return None;
    }
    let k = (step.max(1) - 1) / step_size;
    Some(base_lr * crate::math::powf(gamma, k as f32))
}

pub fn step_decay_f64(base_lr: f64, step: u32, step_size: u32, gamma: f64) -> Option<f64> {
    if step_size == 0
        || !base_lr.is_finite()
        || base_lr <= 0.0
        || !gamma.is_finite()
        || gamma <= 0.0
    {
        return None;
    }
    let k = (step.max(1) - 1) / step_size;
    Some(base_lr * crate::math::powd(gamma, k as f64))
}

pub fn cosine_decay(base_lr: f32, step: u32, total_steps: u32, min_lr_ratio: f32) -> Option<f32> {
    if total_steps == 0
        || !base_lr.is_finite()
        || base_lr <= 0.0
        || !min_lr_ratio.is_finite()
        || !(0.0..=1.0).contains(&min_lr_ratio)
    {
        return None;
    }

    let s = step.max(1).min(total_steps);
    let progress = s as f32 / total_steps as f32;
    let cosine = 0.5 * (1.0 + crate::math::cosf(core::f32::consts::PI * progress));
    Some(base_lr * (min_lr_ratio + (1.0 - min_lr_ratio) * cosine))
}

pub fn cosine_decay_f64(
    base_lr: f64,
    step: u32,
    total_steps: u32,
    min_lr_ratio: f64,
) -> Option<f64> {
    if total_steps == 0
        || !base_lr.is_finite()
        || base_lr <= 0.0
        || !min_lr_ratio.is_finite()
        || !(0.0..=1.0).contains(&min_lr_ratio)
    {
        return None;
    }
    let s = step.max(1).min(total_steps);
    let progress = s as f64 / total_steps as f64;
    let cosine = 0.5 * (1.0 + crate::math::cosd(core::f64::consts::PI * progress));
    Some(base_lr * (min_lr_ratio + (1.0 - min_lr_ratio) * cosine))
}