use crate::graph::network::Network;
use crate::utils::tabular_data::Dataset;
#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
pub struct StepReport {
pub train_loss: f32,
pub eval_loss: Option<f32>,
pub fitness: f32,
pub informative: Vec<f32>,
#[serde(default)]
pub rl: Option<RlStepMeta>,
}
#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
pub struct TabularStepReport {
pub train_loss: f32,
pub eval_loss: Option<f32>,
pub fitness: f32,
pub informative: Vec<f32>,
}
#[derive(Clone, Debug, Default, serde::Serialize, serde::Deserialize)]
pub struct RlStepReport {
pub train_loss: f32,
pub fitness: f32,
pub informative: Vec<f32>,
pub rl: Option<RlStepMeta>,
}
impl From<TabularStepReport> for StepReport {
fn from(r: TabularStepReport) -> Self {
StepReport {
train_loss: r.train_loss,
eval_loss: r.eval_loss,
fitness: r.fitness,
informative: r.informative,
rl: None, }
}
}
impl From<RlStepReport> for StepReport {
fn from(r: RlStepReport) -> Self {
StepReport {
train_loss: r.train_loss,
eval_loss: None, fitness: r.fitness,
informative: r.informative,
rl: r.rl,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct RlStepMeta {
pub matches: usize,
#[serde(default)]
pub train_turns: usize,
#[serde(default)]
pub eval_turns: usize,
}
impl RlStepMeta {
pub fn turns(&self) -> usize {
self.train_turns + self.eval_turns
}
}
#[derive(Clone, Copy, Debug)]
pub struct StepEnv {
pub step: usize,
pub run_seed: u64,
pub pop_size: usize,
pub live_count: usize,
pub checkpoint_every: usize,
pub smoothing_window: usize,
pub max_steps: Option<usize>,
pub attempt: u64,
}
impl StepEnv {
pub fn progress(&self) -> Option<f32> {
crate::utils::training::run_progress(self.step, self.max_steps)
}
}
pub struct RunData<'a> {
pub dataset: &'a Dataset,
pub stream: &'a crate::trainer::stream::BatchStream,
}
impl RunData<'_> {
pub fn train_batch(&self, step: u64) -> flodl::tensor::Result<(flodl::Tensor, flodl::Tensor)> {
self.stream.train_batch(self.dataset, step)
}
pub fn train_batch_at(
&self,
step: u64,
attempt: u64,
) -> flodl::tensor::Result<(flodl::Tensor, flodl::Tensor)> {
self.stream.train_batch_at(self.dataset, step, attempt)
}
pub fn eval_batch(&self, step: u64) -> flodl::tensor::Result<(flodl::Tensor, flodl::Tensor)> {
self.stream.eval_batch(self.dataset, step)
}
}
pub struct StepCtx<'a> {
pub optimizer: &'a mut dyn flodl::nn::optim::Optimizer,
pub step: usize,
pub fitness: &'a crate::utils::fitness::Fitness,
pub metrics: &'a [crate::utils::fitness::Metric],
pub env: StepEnv,
pub net_hash: &'a str,
pub net_seed: u64,
pub data: Option<&'a RunData<'a>>,
}
pub struct TabularContext<'a> {
pub data: RunData<'a>,
pub fitness: &'a crate::utils::fitness::Fitness,
pub metrics: &'a [crate::utils::fitness::Metric],
pub env: StepEnv,
pub net_hash: &'a str,
pub net_seed: u64,
}
pub struct RlContext<'a> {
pub fitness: &'a crate::utils::fitness::Fitness,
pub metrics: &'a [crate::utils::fitness::Metric],
pub env: StepEnv,
pub net_hash: &'a str,
pub net_seed: u64,
}
#[derive(Clone, Copy, Debug)]
pub struct StreamShape {
pub batch_size: usize,
pub eval_batch_size: usize,
}
impl StreamShape {
pub fn none() -> Self {
Self {
batch_size: 16,
eval_batch_size: 16,
}
}
pub fn uniform(n: usize) -> Self {
Self {
batch_size: n,
eval_batch_size: n,
}
}
}
pub trait TabularStep: Send {
fn make_optimizer(&self, net: &Network) -> Box<dyn flodl::nn::optim::Optimizer>;
fn restore_optimizer(
&self,
_net: &Network,
_path: &std::path::Path,
) -> Option<Box<dyn flodl::nn::optim::Optimizer>> {
None
}
fn state(&self, _net_hash: &str) -> Option<serde_json::Value> {
None
}
fn restore(&mut self, _net_hash: &str, _state: &serde_json::Value) {}
fn describe(&self) -> Option<serde_json::Value> {
None
}
fn loss(&self) -> crate::trainer::LossFn<'_>;
fn scheduled_lr(&self, _step: usize, _max_steps: Option<usize>) -> Option<f64> {
None
}
fn stream_shape(&self) -> Option<StreamShape> {
None
}
fn train_step(
&mut self,
net: &mut Network,
optimizer: &mut dyn flodl::nn::optim::Optimizer,
step: usize,
ctx: &TabularContext<'_>,
) -> flodl::tensor::Result<TabularStepReport>;
}
pub trait RlStep: Send {
fn make_optimizer(&self, net: &Network) -> Box<dyn flodl::nn::optim::Optimizer>;
fn restore_optimizer(
&self,
_net: &Network,
_path: &std::path::Path,
) -> Option<Box<dyn flodl::nn::optim::Optimizer>> {
None
}
fn describe(&self) -> Option<serde_json::Value> {
None
}
fn train_step(
&mut self,
net: &mut Network,
optimizer: &mut dyn flodl::nn::optim::Optimizer,
step: usize,
ctx: &RlContext<'_>,
) -> flodl::tensor::Result<RlStepReport>;
fn pop_phase(&mut self, _nets: &mut [(String, &mut Network)], _step: usize) {}
fn wants_pop_phase(&self) -> bool {
false
}
}
pub enum AnyTrainer {
Tabular(Box<dyn TabularStep>),
Rl(Box<dyn RlStep>),
}
impl AnyTrainer {
pub fn tabular(trainer: impl TabularStep + 'static) -> Self {
Self::Tabular(Box::new(trainer))
}
pub fn rl(trainer: impl RlStep + 'static) -> Self {
Self::Rl(Box::new(trainer))
}
pub fn is_rl(&self) -> bool {
matches!(self, Self::Rl(_))
}
pub fn restore_optimizer(
&self,
net: &Network,
path: &std::path::Path,
) -> Option<Box<dyn flodl::nn::optim::Optimizer>> {
match self {
Self::Tabular(t) => t.restore_optimizer(net, path),
Self::Rl(t) => t.restore_optimizer(net, path),
}
}
pub fn make_optimizer(&self, net: &Network) -> Box<dyn flodl::nn::optim::Optimizer> {
match self {
Self::Tabular(t) => t.make_optimizer(net),
Self::Rl(t) => t.make_optimizer(net),
}
}
pub fn describe(&self) -> Option<serde_json::Value> {
match self {
Self::Tabular(t) => t.describe(),
Self::Rl(t) => t.describe(),
}
}
pub fn trainer_state(&self, net_hash: &str) -> Option<serde_json::Value> {
match self {
Self::Tabular(t) => t.state(net_hash),
Self::Rl(_) => None,
}
}
pub fn restore_trainer_state(&mut self, net_hash: &str, state: &serde_json::Value) {
if let Self::Tabular(t) = self {
t.restore(net_hash, state);
}
}
pub fn pop_phase(&mut self, nets: &mut [(String, &mut Network)], step: usize) {
match self {
Self::Tabular(_) => {}
Self::Rl(t) => t.pop_phase(nets, step),
}
}
pub fn wants_pop_phase(&self) -> bool {
match self {
Self::Tabular(_) => false,
Self::Rl(t) => t.wants_pop_phase(),
}
}
pub fn train_step(
&mut self,
net: &mut Network,
ctx: StepCtx<'_>,
) -> flodl::tensor::Result<StepReport> {
let StepCtx {
optimizer,
step,
fitness,
metrics,
env,
net_hash,
net_seed,
data,
} = ctx;
match self {
Self::Tabular(t) => {
let data = data
.expect("Tabular step without data — engine construction invariant violated");
let ctx = TabularContext {
data: RunData {
dataset: data.dataset,
stream: data.stream,
},
fitness,
metrics,
env,
net_hash,
net_seed,
};
Ok(t.train_step(net, optimizer, step, &ctx)?.into())
}
Self::Rl(t) => {
let ctx = RlContext {
fitness,
metrics,
env,
net_hash,
net_seed,
};
Ok(t.train_step(net, optimizer, step, &ctx)?.into())
}
}
}
pub fn tabular_loss(&self) -> Option<super::LossFn<'_>> {
match self {
Self::Tabular(t) => Some(t.loss()),
Self::Rl(_) => None,
}
}
pub fn stream_shape(&self) -> Option<StreamShape> {
match self {
Self::Tabular(t) => t.stream_shape(),
Self::Rl(_) => None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use flodl::Module;
struct SentinelRl;
impl RlStep for SentinelRl {
fn make_optimizer(&self, net: &Network) -> Box<dyn flodl::nn::optim::Optimizer> {
Box::new(flodl::nn::Adam::new(&net.parameters(), 1e-3_f64))
}
fn train_step(
&mut self,
_net: &mut Network,
_optimizer: &mut dyn flodl::nn::optim::Optimizer,
_step: usize,
_ctx: &RlContext<'_>,
) -> flodl::tensor::Result<RlStepReport> {
unimplemented!("the pop-phase test never trains")
}
}
struct PopPhaseRl;
impl RlStep for PopPhaseRl {
fn make_optimizer(&self, net: &Network) -> Box<dyn flodl::nn::optim::Optimizer> {
Box::new(flodl::nn::Adam::new(&net.parameters(), 1e-3_f64))
}
fn train_step(
&mut self,
_net: &mut Network,
_optimizer: &mut dyn flodl::nn::optim::Optimizer,
_step: usize,
_ctx: &RlContext<'_>,
) -> flodl::tensor::Result<RlStepReport> {
unimplemented!("the pop-phase test never trains")
}
fn pop_phase(&mut self, _nets: &mut [(String, &mut Network)], _step: usize) {}
fn wants_pop_phase(&self) -> bool {
true
}
}
#[test]
fn pop_phase_is_opt_in() {
let tabular = crate::trainer::TabularTrainer::new(
|_pred, _y| -> flodl::tensor::Result<flodl::Variable> {
unimplemented!("the pop-phase test never trains")
},
);
assert!(
!AnyTrainer::tabular(tabular).wants_pop_phase(),
"the tabular arm has no pop-wide phase"
);
assert!(
!AnyTrainer::rl(SentinelRl).wants_pop_phase(),
"an RL scheme that leaves pop_phase alone must not trigger the gather"
);
assert!(
AnyTrainer::rl(PopPhaseRl).wants_pop_phase(),
"a scheme that implements pop_phase must opt in"
);
}
#[test]
fn step_env_progress_reads_the_run_clock() {
let env = StepEnv {
step: 25,
run_seed: 1,
pop_size: 2,
live_count: 2,
checkpoint_every: 10,
smoothing_window: 5,
max_steps: Some(100),
attempt: 0,
};
assert_eq!(env.progress(), Some(0.25));
assert_eq!(StepEnv { step: 400, ..env }.progress(), Some(1.0));
assert_eq!(
StepEnv {
max_steps: None,
..env
}
.progress(),
None
);
}
}