use super::*;
pub(crate) struct RollOutcome {
pub survived: bool,
pub no_slot: bool,
pub detail: String,
}
impl RollOutcome {
pub fn survived(detail: impl Into<String>) -> Self {
Self {
survived: true,
no_slot: false,
detail: detail.into(),
}
}
pub fn spent(detail: impl Into<String>) -> Self {
Self {
survived: false,
no_slot: false,
detail: detail.into(),
}
}
pub fn no_slot(detail: impl Into<String>) -> Self {
Self {
survived: false,
no_slot: true,
detail: detail.into(),
}
}
}
#[derive(Clone, Copy, Default)]
pub(crate) struct StepEvolve {
pub culls: usize,
pub inserts: usize,
pub cross_fired: usize,
pub cross_survived: usize,
pub cross_discarded: usize,
pub mutate_fired: usize,
}
#[derive(Clone, Copy, Debug, Default)]
pub(crate) struct BirthLedger {
pub births: usize,
pub draws: usize,
pub redrawn: usize,
pub draws_max: usize,
pub delta_sum: f64,
pub delta_births: usize,
pub delta_min: Option<f32>,
pub duplicates: usize,
}
impl BirthLedger {
pub(crate) fn record_draw(&mut self, delta: Option<f32>, draws: usize) {
self.births += 1;
self.draws += draws;
self.draws_max = self.draws_max.max(draws);
if draws > 1 {
self.redrawn += 1;
}
if let Some(d) = delta {
self.delta_sum += d as f64;
self.delta_births += 1;
self.delta_min = Some(self.delta_min.map_or(d, |m| m.min(d)));
}
}
pub(crate) fn mean_delta(&self) -> Option<f32> {
(self.delta_births > 0).then(|| (self.delta_sum / self.delta_births as f64) as f32)
}
pub(crate) fn draws_per_birth(&self) -> f32 {
if self.births == 0 {
0.0
} else {
self.draws as f32 / self.births as f32
}
}
}
#[cfg(test)]
mod birth_ledger_tests {
use super::BirthLedger;
#[test]
fn the_ledger_tallies_candidates_and_delta() {
let mut b = BirthLedger::default();
assert_eq!(b.mean_delta(), None, "nothing judged ⇒ no headline");
assert_eq!(b.draws_per_birth(), 0.0, "nothing born ⇒ no rate");
b.record_draw(Some(0.6), 1); b.record_draw(Some(0.3), 3); b.record_draw(None, 1); assert_eq!((b.births, b.draws, b.draws_max), (3, 5, 3));
assert_eq!(
b.redrawn, 1,
"only the draw that spent more than one candidate"
);
assert!(
(b.mean_delta().unwrap() - 0.45).abs() < 1e-6,
"mean over JUDGED births only"
);
assert_eq!(b.delta_min, Some(0.3));
assert!((b.draws_per_birth() - 5.0 / 3.0).abs() < 1e-6);
}
}
pub(crate) struct NoopOptimizer;
impl flodl::nn::optim::Optimizer for NoopOptimizer {
fn step(&mut self) -> flodl::tensor::Result<()> {
Ok(()) }
fn zero_grad(&self) {}
fn lr(&self) -> f64 {
0.0
}
fn set_lr(&mut self, _lr: f64) {}
}
#[derive(Clone, Copy, Debug, Default)]
pub(crate) struct RlVolume {
pub nets: usize,
pub matches: usize,
pub train_turns: usize,
pub eval_turns: usize,
}
impl RlVolume {
pub(crate) fn turns(&self) -> usize {
self.train_turns + self.eval_turns
}
pub(crate) fn label(&self, step_secs: f32) -> String {
if self.nets == 0 || self.matches == 0 {
let none = crate::utils::cfy::NO_VALUE;
return format!(
"episodes {none} │ turns {none} = train {none} + eval {none} │ turns/episode {none} │ ms/turn {none}"
);
}
let turns = self.turns();
let per_turn = if turns == 0 {
crate::utils::cfy::NO_VALUE.to_string()
} else {
fmt_line(step_secs * 1000.0 / turns as f32)
};
format!(
"episodes {} │ turns {} = train {} + eval {} │ turns/episode {} │ {} ms/turn",
self.matches,
turns,
self.train_turns,
self.eval_turns,
fmt_line(turns as f32 / self.matches as f32),
per_turn
)
}
}