use crate::graph::network::Network;
use crate::trainer::{StepContext, StepReport, Trainer};
use crate::utils::race_steps::{eval_one_step, seed_step_randomness, train_one_step};
use flodl::nn::optim::Optimizer;
use flodl::tensor::Result;
use flodl::{Tensor, Variable};
pub struct TabularTrainer {
pub loss_fn: Box<dyn Fn(&Variable, &Variable) -> Result<Variable> + Send + Sync>,
pub learning_rate: f32,
pub grad_clip: f32,
pub batch_size: usize,
pub eval_batch_size: usize,
pub lr_schedule: Option<Box<dyn Fn(usize) -> f64 + Send + Sync>>,
}
impl TabularTrainer {
pub fn new(
loss_fn: impl Fn(&Variable, &Variable) -> Result<Variable> + Send + Sync + 'static,
) -> Self {
Self {
loss_fn: Box::new(loss_fn),
..Self::default()
}
}
pub fn with_learning_rate(mut self, lr: f32) -> Self {
self.learning_rate = lr;
self
}
pub fn with_grad_clip(mut self, clip: f32) -> Self {
self.grad_clip = clip;
self
}
pub fn with_batch_size(mut self, size: usize) -> Self {
self.batch_size = size;
self
}
pub fn with_eval_batch_size(mut self, size: usize) -> Self {
self.eval_batch_size = size;
self
}
pub fn with_lr_schedule(
mut self,
schedule: impl Fn(usize) -> f64 + Send + Sync + 'static,
) -> Self {
self.lr_schedule = Some(Box::new(schedule));
self
}
}
impl Default for TabularTrainer {
fn default() -> Self {
Self {
loss_fn: Box::new(|pred, y| crate::utils::score::cross_entropy_onehot_loss(pred, y)),
learning_rate: crate::engine::config::DEFAULT_LR,
grad_clip: 1.0,
batch_size: 16,
eval_batch_size: 16,
lr_schedule: None,
}
}
}
pub struct RlTrainer {
_private: (),
}
impl RlTrainer {
pub fn new() -> Self {
Self { _private: () }
}
}
impl Default for RlTrainer {
fn default() -> Self {
Self::new()
}
}
impl Trainer for RlTrainer {
fn loss(&self) -> Option<crate::trainer::LossFn<'_>> {
None
}
fn stream_shape(&self) -> Option<crate::trainer::StreamShape> {
None }
fn make_optimizer(&self, net: &Network) -> Box<dyn Optimizer> {
use flodl::nn::Module;
Box::new(flodl::nn::Adam::new(&net.parameters(), 1e-3_f64))
}
fn train_step(
&mut self,
_net: &mut Network,
_optimizer: &mut dyn Optimizer,
_step: usize,
_ctx: &StepContext<'_>,
) -> Result<StepReport> {
let fitness = 0.0_f32; Ok(StepReport {
train_loss: 0.0,
eval_loss: None, fitness,
informative: Vec::new(),
})
}
}
pub struct ImageTrainer {
_private: (),
}
impl ImageTrainer {
pub fn new() -> Self {
Self { _private: () }
}
}
impl Default for ImageTrainer {
fn default() -> Self {
Self::new()
}
}
impl Trainer for ImageTrainer {
fn loss(&self) -> Option<crate::trainer::LossFn<'_>> {
None }
fn stream_shape(&self) -> Option<crate::trainer::StreamShape> {
Some(crate::trainer::StreamShape {
batch_size: 32,
eval_batch_size: 64,
})
}
fn make_optimizer(&self, net: &Network) -> Box<dyn Optimizer> {
use flodl::nn::Module;
Box::new(flodl::nn::Adam::new(&net.parameters(), 1e-3_f64))
}
fn train_step(
&mut self,
_net: &mut Network,
_optimizer: &mut dyn Optimizer,
_step: usize,
_ctx: &StepContext<'_>,
) -> Result<StepReport> {
let fitness = 0.0_f32; Ok(StepReport {
train_loss: 0.0,
eval_loss: None,
fitness,
informative: Vec::new(),
})
}
}
pub struct NlpTrainer {
_private: (),
}
impl NlpTrainer {
pub fn new() -> Self {
Self { _private: () }
}
}
impl Default for NlpTrainer {
fn default() -> Self {
Self::new()
}
}
impl Trainer for NlpTrainer {
fn loss(&self) -> Option<crate::trainer::LossFn<'_>> {
None }
fn stream_shape(&self) -> Option<crate::trainer::StreamShape> {
Some(crate::trainer::StreamShape {
batch_size: 16,
eval_batch_size: 16,
})
}
fn make_optimizer(&self, net: &Network) -> Box<dyn Optimizer> {
use flodl::nn::Module;
Box::new(flodl::nn::Adam::new(&net.parameters(), 1e-3_f64))
}
fn train_step(
&mut self,
_net: &mut Network,
_optimizer: &mut dyn Optimizer,
_step: usize,
_ctx: &StepContext<'_>,
) -> Result<StepReport> {
let fitness = 0.0_f32; Ok(StepReport {
train_loss: 0.0,
eval_loss: None,
fitness,
informative: Vec::new(),
})
}
}
impl Trainer for TabularTrainer {
fn loss(&self) -> Option<crate::trainer::LossFn<'_>> {
Some(&*self.loss_fn)
}
fn scheduled_lr(&self, step: usize) -> Option<f64> {
self.lr_schedule.as_ref().map(|f| f(step))
}
fn stream_shape(&self) -> Option<crate::trainer::StreamShape> {
Some(crate::trainer::StreamShape {
batch_size: self.batch_size,
eval_batch_size: self.eval_batch_size,
})
}
fn make_optimizer(&self, net: &Network) -> Box<dyn Optimizer> {
use flodl::nn::Module;
Box::new(flodl::nn::Adam::new(
&net.parameters(),
self.learning_rate as f64,
))
}
fn describe(&self) -> Option<serde_json::Value> {
Some(serde_json::json!({
"trainer": "tabular",
"optimizer": "adam",
"learning_rate": self.learning_rate,
"grad_clip": self.grad_clip,
"batch_size": self.batch_size,
"eval_batch_size": self.eval_batch_size,
"lr_schedule": self.lr_schedule.is_some(),
}))
}
fn train_step(
&mut self,
net: &mut Network,
optimizer: &mut dyn Optimizer,
step: usize,
ctx: &StepContext<'_>,
) -> Result<StepReport> {
let data = ctx
.data
.expect("TabularTrainer requires the run's shared data (stream + dataset)");
let fitness = ctx
.fitness
.expect("TabularTrainer requires a fitness function");
let loss_fn: crate::trainer::LossFn<'_> = &*self.loss_fn;
let h: u64 = ctx
.net_hash
.bytes()
.fold(0u64, |a, b| a.wrapping_add(b as u64));
seed_step_randomness(ctx.net_seed, step as u64, h);
let batch: (Tensor, Tensor) = data.train_batch(step as u64)?;
if let Some(lr) = self.scheduled_lr(step) {
optimizer.set_lr(lr);
}
let train_loss = train_one_step(net, optimizer, loss_fn, &batch, self.grad_clip)?;
let eval_batch: (Tensor, Tensor) = data.eval_batch(step as u64)?;
let report = eval_one_step(net, loss_fn, fitness, ctx.metrics, &eval_batch)?;
Ok(StepReport {
train_loss,
eval_loss: report.eval_loss,
fitness: report.fitness,
informative: report.metrics,
})
}
}