gmgn 0.2.0

A reinforcement learning environments library for 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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Clips continuous actions to the action space bounds.
//!
//! Mirrors [Gymnasium `ClipAction`](https://gymnasium.farama.org/api/wrappers/action_wrappers/#gymnasium.wrappers.ClipAction).

use crate::env::{Env, RenderFrame, RenderMode, ResetResult, StepResult};
use crate::error::Result;
use crate::space::BoundedSpace;

/// Clips every element of a continuous action to the bounds defined by the
/// environment's [`BoundedSpace`] action space before forwarding to `step`.
///
/// Only applicable to environments whose `ActSpace` is [`BoundedSpace`] and
/// `Act` is `Vec<f32>`.
///
/// # Examples
///
/// ```rust,ignore
/// use gmgn::wrappers::ClipAction;
///
/// let env = SomeContinuousEnv::new(config)?;
/// let mut env = ClipAction::new(env);
/// ```
#[derive(Debug)]
pub struct ClipAction<E>
where
    E: Env<Act = Vec<f32>, ActSpace = BoundedSpace>,
{
    env: E,
}

impl<E> ClipAction<E>
where
    E: Env<Act = Vec<f32>, ActSpace = BoundedSpace>,
{
    /// Wrap `env` so that all actions are clipped to the action space bounds.
    #[must_use]
    pub const fn new(env: E) -> Self {
        Self { env }
    }

    /// Borrow the inner environment.
    #[must_use]
    pub const fn inner(&self) -> &E {
        &self.env
    }

    /// Mutably borrow the inner environment.
    #[must_use]
    pub const fn inner_mut(&mut self) -> &mut E {
        &mut self.env
    }

    /// Unwrap and return the inner environment.
    #[must_use]
    pub fn into_inner(self) -> E {
        self.env
    }

    /// Clip `action` element-wise to `[low, high]`.
    fn clip(&self, action: &[f32]) -> Vec<f32> {
        let space = self.env.action_space();
        action
            .iter()
            .zip(space.low.iter().zip(space.high.iter()))
            .map(|(&a, (&lo, &hi))| a.clamp(lo, hi))
            .collect()
    }
}

impl<E> Env for ClipAction<E>
where
    E: Env<Act = Vec<f32>, ActSpace = BoundedSpace>,
{
    type Obs = E::Obs;
    type Act = Vec<f32>;
    type ObsSpace = E::ObsSpace;
    type ActSpace = BoundedSpace;

    fn step(&mut self, action: &Vec<f32>) -> Result<StepResult<Self::Obs>> {
        let clipped = self.clip(action);
        self.env.step(&clipped)
    }

    fn reset(&mut self, seed: Option<u64>) -> Result<ResetResult<Self::Obs>> {
        self.env.reset(seed)
    }

    fn render(&mut self) -> Result<RenderFrame> {
        self.env.render()
    }

    fn close(&mut self) {
        self.env.close();
    }

    fn observation_space(&self) -> &Self::ObsSpace {
        self.env.observation_space()
    }

    fn action_space(&self) -> &BoundedSpace {
        self.env.action_space()
    }

    fn render_mode(&self) -> &RenderMode {
        self.env.render_mode()
    }
}