rlevo-environments 0.2.0

RL benchmark environments and landscapes for rlevo (internal crate — use `rlevo` for the full API)
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

//! Action type for [`super::InvertedPendulum`].

use burn::prelude::{Backend, Tensor};
use rlevo_core::action::ContinuousAction;
use rlevo_core::base::{Action, TensorConversionError, TensorConvertible};
use serde::{Deserialize, Serialize};

/// 1D continuous action — horizontal force target on the cart, in Gymnasium's
/// pre-gear units. Bounds: `[-3.0, 3.0]`.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct InvertedPendulumAction(pub [f32; 1]);

impl InvertedPendulumAction {
    /// Construct from a scalar convenience.
    #[must_use]
    pub const fn new(force: f32) -> Self {
        Self([force])
    }
}

impl Action<1> for InvertedPendulumAction {
    fn shape() -> [usize; 1] {
        [1]
    }

    fn is_valid(&self) -> bool {
        self.0[0].is_finite() && self.0[0].abs() <= 3.0
    }
}

impl ContinuousAction<1> for InvertedPendulumAction {
    /// Returns the raw force value as a single-element slice.
    fn as_slice(&self) -> &[f32] {
        &self.0
    }

    /// Returns a new action with the force value clamped to `[min, max]`.
    fn clip(&self, min: f32, max: f32) -> Self {
        Self([self.0[0].clamp(min, max)])
    }

    /// Constructs an action from the first element of `values`.
    ///
    /// # Panics
    ///
    /// Panics if `values` is empty.
    fn from_slice(values: &[f32]) -> Self {
        Self([values[0]])
    }

    /// Samples a uniformly random force from `[-3.0, 3.0)` using the
    /// thread-local RNG. Not deterministic; do not use in reproducibility-
    /// sensitive paths.
    fn random() -> Self {
        Self([rand::random::<f32>() * 6.0 - 3.0])
    }
}

impl<B: Backend> TensorConvertible<1, B> for InvertedPendulumAction {
    fn to_tensor(&self, device: &<B as burn::tensor::backend::BackendTypes>::Device) -> Tensor<B, 1> {
        Tensor::from_floats(self.0, device)
    }

    fn from_tensor(tensor: Tensor<B, 1>) -> Result<Self, TensorConversionError> {
        let data = tensor.into_data();
        let slice = data.as_slice::<f32>().map_err(|e| TensorConversionError {
            message: format!("expected f32 action tensor: {e:?}"),
        })?;
        if slice.len() != 1 {
            return Err(TensorConversionError {
                message: format!("expected 1 action element, got {}", slice.len()),
            });
        }
        Ok(Self([slice[0]]))
    }
}