pub mod supervised;
pub use supervised::{OptimizerKind, SupervisedTrainer, TrainingConfig};
use flodl::tensor::Result;
use flodl::{DType, Device};
use crate::engine::fitness::Fitness;
use crate::graph::network::Network;
#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct EvalOutcome {
pub score: f32,
pub eval_loss: Option<f32>,
pub param_count: usize,
pub train_losses: Vec<f32>,
pub eval_losses: Vec<f32>,
}
impl EvalOutcome {
pub fn new(score: f32, eval_loss: Option<f32>, param_count: usize) -> Self {
EvalOutcome {
score,
eval_loss,
param_count,
train_losses: Vec::new(),
eval_losses: Vec::new(),
}
}
}
impl From<(f32, Option<f32>, usize)> for EvalOutcome {
fn from((score, eval_loss, param_count): (f32, Option<f32>, usize)) -> Self {
EvalOutcome::new(score, eval_loss, param_count)
}
}
pub trait Trainer: Send + Sync {
fn input_dim(&self) -> usize;
fn output_dim(&self) -> usize;
fn device(&self) -> Device;
fn dtype(&self) -> DType;
fn evaluate(&self, net: Network, fitness: &Fitness, gen_seed: u64) -> Result<EvalOutcome>;
}
impl<T: Trainer + ?Sized> Trainer for Box<T> {
fn input_dim(&self) -> usize {
(**self).input_dim()
}
fn output_dim(&self) -> usize {
(**self).output_dim()
}
fn device(&self) -> Device {
(**self).device()
}
fn dtype(&self) -> DType {
(**self).dtype()
}
fn evaluate(&self, net: Network, fitness: &Fitness, gen_seed: u64) -> Result<EvalOutcome> {
(**self).evaluate(net, fitness, gen_seed)
}
}
pub fn from_fn<F, O>(
input_dim: usize,
output_dim: usize,
device: Device,
dtype: DType,
evaluate_fn: F,
) -> ClosureTrainer
where
F: Fn(Network, u64) -> Result<O> + Send + Sync + 'static,
O: Into<EvalOutcome>,
{
ClosureTrainer::new(input_dim, output_dim, device, dtype, evaluate_fn)
}
pub struct ClosureTrainer {
input_dim: usize,
output_dim: usize,
device: Device,
dtype: DType,
evaluate_fn: Box<dyn Fn(Network, u64) -> Result<EvalOutcome> + Send + Sync>,
}
impl ClosureTrainer {
pub fn new<F, O>(
input_dim: usize,
output_dim: usize,
device: Device,
dtype: DType,
evaluate_fn: F,
) -> Self
where
F: Fn(Network, u64) -> Result<O> + Send + Sync + 'static,
O: Into<EvalOutcome>,
{
ClosureTrainer {
input_dim,
output_dim,
device,
dtype,
evaluate_fn: Box::new(move |net, gen_seed| evaluate_fn(net, gen_seed).map(Into::into)),
}
}
}
impl Trainer for ClosureTrainer {
fn input_dim(&self) -> usize {
self.input_dim
}
fn output_dim(&self) -> usize {
self.output_dim
}
fn device(&self) -> Device {
self.device
}
fn dtype(&self) -> DType {
self.dtype
}
fn evaluate(&self, net: Network, _fitness: &Fitness, gen_seed: u64) -> Result<EvalOutcome> {
(self.evaluate_fn)(net, gen_seed)
}
}