native_neural_network_std 0.2.1

Ergonomic std wrapper for the `native_neural_network` crate (no_std) — std-friendly re-exports and utilities.
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

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LrScheduleStd {
    Constant,
    StepDecay { step_size: u32, gamma: f32 },
    Cosine { total_steps: u32, min_lr_ratio: f32 },
    LinearWarmup { warmup_steps: u32 },
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ScheduleStdError {
    InvalidConfig,
}

impl From<native_neural_network::schedulers::ScheduleError> for ScheduleStdError {
    fn from(e: native_neural_network::schedulers::ScheduleError) -> Self {
        match e {
            native_neural_network::schedulers::ScheduleError::InvalidConfig => {
                ScheduleStdError::InvalidConfig
            }
        }
    }
}

impl From<LrScheduleStd> for native_neural_network::schedulers::LrSchedule {
    fn from(s: LrScheduleStd) -> Self {
        match s {
            LrScheduleStd::Constant => native_neural_network::schedulers::LrSchedule::Constant,
            LrScheduleStd::StepDecay { step_size, gamma } => {
                native_neural_network::schedulers::LrSchedule::StepDecay { step_size, gamma }
            }
            LrScheduleStd::Cosine {
                total_steps,
                min_lr_ratio,
            } => native_neural_network::schedulers::LrSchedule::Cosine {
                total_steps,
                min_lr_ratio,
            },
            LrScheduleStd::LinearWarmup { warmup_steps } => {
                native_neural_network::schedulers::LrSchedule::LinearWarmup { warmup_steps }
            }
        }
    }
}

pub fn compute_learning_rate(
    base_lr: f32,
    step: u32,
    schedule: LrScheduleStd,
) -> Result<f32, ScheduleStdError> {
    let upstream: native_neural_network::schedulers::LrSchedule = schedule.into();
    native_neural_network::schedulers::compute_learning_rate(base_lr, step, upstream)
        .map_err(|e| e.into())
}