use flodl::nn::Module;
use flodl::tensor::Result;
use flodl::{DType, Device};
use flodl::Variable;
use crate::engine::fitness::Fitness;
use crate::graph::network::Network;
use crate::trainer::{EvalOutcome, Trainer};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum OptimizerKind {
SGD,
#[default]
Adam,
}
#[derive(Clone, Debug, PartialEq)]
pub struct TrainingConfig {
pub optimizer: OptimizerKind,
pub learning_rate: f32,
pub num_epochs: usize,
pub grad_clip: f32,
pub batch_size_train: usize,
pub batch_size_eval: usize,
pub num_batches_train: usize,
pub num_batches_eval: usize,
pub train_y_proportional: bool,
pub test_y_proportional: bool,
pub eval_ratio: f32,
pub device: Device,
pub dtype: DType,
}
impl Default for TrainingConfig {
fn default() -> Self {
TrainingConfig {
optimizer: OptimizerKind::Adam,
learning_rate: 1e-3,
num_epochs: 1,
grad_clip: 0.0,
batch_size_train: 16,
batch_size_eval: 16,
num_batches_train: 16,
num_batches_eval: 16,
train_y_proportional: false,
test_y_proportional: false,
eval_ratio: 0.2,
device: Device::CPU,
dtype: DType::Float32,
}
}
}
pub struct SupervisedTrainer {
pub(crate) dataset: crate::utils::data::Dataset,
input_dim: usize,
output_dim: usize,
config: TrainingConfig,
loss_fn: Box<dyn Fn(&Variable, &Variable) -> Result<Variable> + Send + Sync>,
}
impl SupervisedTrainer {
pub fn new(
data_path: &std::path::Path,
input_dim: usize,
output_dim: usize,
config: TrainingConfig,
loss_fn: impl Fn(&Variable, &Variable) -> Result<Variable> + Send + Sync + 'static,
) -> Result<Self> {
let dataset = crate::utils::data::resolve_dataset(data_path)?
.to_dtype(config.dtype)?
.to_device(config.device)?;
Ok(Self {
dataset,
input_dim,
output_dim,
config,
loss_fn: Box::new(loss_fn),
})
}
}
impl Trainer for SupervisedTrainer {
fn input_dim(&self) -> usize { self.input_dim }
fn output_dim(&self) -> usize { self.output_dim }
fn device(&self) -> Device { self.config.device }
fn dtype(&self) -> DType { self.config.dtype }
fn evaluate(&self, mut net: Network, fitness: &Fitness, gen_seed: u64) -> Result<EvalOutcome> {
let params: usize = net.layers.iter().flat_map(|l| l.parameters()).map(|p| p.variable.numel() as usize).sum();
let n = self.dataset.len();
let eval_ratio = self.config.eval_ratio;
let (train_idx, _) = crate::utils::data::split_indices(
n, 1.0 - eval_ratio, eval_ratio, gen_seed,
);
let (_, eval_idx) = crate::utils::data::split_indices(
n, 1.0 - eval_ratio, eval_ratio, gen_seed.wrapping_add(0xFFFF),
);
let result = crate::utils::supervised::train_network(
&mut net, &self.config, &self.loss_fn, fitness,
&self.dataset, &train_idx, &eval_idx,
gen_seed,
)?;
Ok(EvalOutcome {
score: result.score,
eval_loss: result.eval_loss,
param_count: params,
train_losses: result.loss_curve,
eval_losses: result.eval_loss_curve,
})
}
}