relayrl_algorithms 0.4.1

Independent / Multi-Agent Proximal Policy Optimization (PPO) Algorithms for the RelayRL framework
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

#[allow(non_snake_case)]
pub mod PPO;

pub mod nn;
pub mod onnx_builder;
#[cfg(feature = "tch-model")]
pub mod torch_builder;

pub use nn::conv_policy;
pub use nn::{
    ActivationKind, ArchLayer, GenericMlp, LayerSpecs, NeuralNetwork, NeuralNetworkError,
    NeuralNetworkForward, NeuralNetworkSpec, ValueFunction, WeightProvider,
    acquire_conv_model_module, acquire_model_module, convert_byte_dtype_to_f32,
    convert_byte_dtype_to_i64, dtype_to_byte_count,
};

#[inline(always)]
pub(crate) fn discounted_cumsum(x: &[f32], discount: f32) -> Vec<f32> {
    let n = x.len();
    let mut result = vec![0.0f32; n];
    let mut running = 0.0f32;
    for i in (0..n).rev() {
        running = x[i] + discount * running;
        result[i] = running;
    }
    result
}

#[inline(always)]
pub(crate) fn scalar_stats(x: &[f32]) -> (f32, f32) {
    let n = x.len() as f32;
    let mean = x.iter().sum::<f32>() / n;
    let variance = x.iter().map(|v| (v - mean).powi(2)).sum::<f32>() / n;
    (mean, variance.sqrt())
}

#[inline(always)]
pub(crate) fn compute_normed_advantages(advantages: &[f32], mean: f32, std: f32) -> Vec<f32> {
    advantages.iter().map(|a| (a - mean) / std).collect()
}