use flodl::tensor::Result;
pub trait Env: Send {
fn reset(&mut self, seed: u64) -> Result<Vec<f32>>;
fn step(&mut self, action: usize) -> Result<(Vec<f32>, f32, bool)>;
fn action_count(&self) -> usize;
fn max_turns(&self) -> usize;
fn describe(&self) -> serde_json::Value;
}
#[cfg(test)]
pub(crate) mod toy {
use super::Env;
use flodl::tensor::Result;
pub struct ToyEnv {
actions: usize,
max_turns: usize,
turns: usize,
fatal: usize,
seed: u64,
}
impl ToyEnv {
pub fn new(actions: usize, max_turns: usize) -> Self {
Self {
actions,
max_turns,
turns: 0,
fatal: 0,
seed: 0,
}
}
pub fn turns(&self) -> usize {
self.turns
}
pub fn last_seed(&self) -> u64 {
self.seed
}
}
impl Env for ToyEnv {
fn reset(&mut self, seed: u64) -> Result<Vec<f32>> {
let mut rng = fastrand::Rng::with_seed(seed);
self.seed = seed;
self.turns = 0;
self.fatal = rng.usize(..self.actions);
Ok(vec![rng.f32(), rng.f32()])
}
fn step(&mut self, action: usize) -> Result<(Vec<f32>, f32, bool)> {
self.turns += 1;
let done = self.turns >= self.max_turns || action == self.fatal;
Ok((vec![action as f32, 1.0], 1.0, done))
}
fn action_count(&self) -> usize {
self.actions
}
fn max_turns(&self) -> usize {
self.max_turns
}
fn describe(&self) -> serde_json::Value {
serde_json::json!({
"env": "toy",
"actions": self.actions,
"max_turns": self.max_turns,
})
}
}
}
#[cfg(test)]
mod tests {
use super::toy::ToyEnv;
use super::*;
#[test]
fn env_is_send() {
fn assert_send<T: Send>() {}
assert_send::<ToyEnv>();
}
#[test]
fn reset_is_a_pure_function_of_its_seed() {
let mut a = ToyEnv::new(4, 50);
let mut b = ToyEnv::new(4, 50);
let first_a = a.reset(7).unwrap();
let first_b = b.reset(7).unwrap();
assert_eq!(first_a, first_b, "same seed, same first observation");
let play = |env: &mut ToyEnv| {
let mut obs = env.reset(7).unwrap();
let mut trace = vec![obs.clone()];
for action in [0usize, 1, 2, 3, 0, 1] {
let (next, reward, done) = env.step(action).unwrap();
trace.push(vec![reward, done as u8 as f32]);
obs = next;
trace.push(obs.clone());
if done {
break;
}
}
trace
};
assert_eq!(play(&mut a), play(&mut b), "same seed, same episode");
let mut c = ToyEnv::new(4, 50);
assert_ne!(
c.reset(8).unwrap(),
first_a,
"seed 8 must not replay seed 7"
);
}
#[test]
fn step_reports_reward_and_done() {
let mut env = ToyEnv::new(3, 4);
env.reset(1).unwrap();
let (obs, reward, done) = env.step(0).unwrap();
assert_eq!(
obs.len(),
2,
"the observation size is the policy's input dim"
);
assert_eq!(reward, 1.0);
assert!(!done, "one turn into a four-turn cap is not done");
let mut last_done = false;
for _ in 0..3 {
let (_, _, done) = env.step(0).unwrap();
last_done = done;
}
assert!(last_done, "the turn cap must end the episode");
assert_eq!(env.turns(), 4);
}
#[test]
fn a_fatal_action_ends_the_episode_before_the_cap() {
let mut env = ToyEnv::new(3, 100);
let fatal = (0..3)
.find(|&action| {
env.reset(5).unwrap();
env.step(action).unwrap().2
})
.expect("every seed has one fatal action");
env.reset(5).unwrap();
let (_, _, done) = env.step(fatal).unwrap();
assert!(done, "action {fatal} was fatal on its own");
assert!(env.turns() < env.max_turns(), "and it ended before the cap");
}
#[test]
fn describe_names_the_world() {
let env = ToyEnv::new(2, 10);
let blob = env.describe();
assert_eq!(blob["env"], "toy");
assert_eq!(blob["actions"], 2);
assert_eq!(blob["max_turns"], 10);
}
}