use std::ops::RangeInclusive;
use std::path::PathBuf;
use flodl::tensor::Result;
use serde::Serialize;
use crate::engine::fitness::FitnessLabel;
use crate::evolution::crossover::CrossoverMethod;
use crate::evolution::mutation::MutationMethod;
use crate::evolution::selection::SelectionMethod;
use crate::graph::node::Activation;
use crate::graph::topology::{CombineOp, TopologyOptions};
use crate::utils::error::EngineError;
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct EngineOptions {
pub pop_size: Option<usize>,
pub num_generations: Option<usize>,
pub seed: Option<u64>,
pub topology_options: TopologyOptions,
pub hidden_dim_pool: RangeInclusive<usize>,
pub hidden_dim_stride: usize,
pub combine_op_pool: Vec<CombineOp>,
pub activation_pool: Vec<Activation>,
pub standardize_op_pool: Vec<crate::graph::node::StandardizeOp>,
pub fitness_label: FitnessLabel,
pub num_threads: usize,
pub results_dir: PathBuf,
pub selection: Option<SelectionMethod>,
pub crossover: Option<CrossoverMethod>,
pub mutation: MutationMethod,
pub dropout_prob: f32,
pub dedup_pop_and_fill: bool,
pub elite_count: usize,
pub prior_topology_paths: Vec<PathBuf>,
pub resume_from: Option<PathBuf>,
}
impl Default for EngineOptions {
fn default() -> Self {
EngineOptions {
pop_size: None,
num_generations: None,
mutation: MutationMethod::default(), seed: None, num_threads: 1,
results_dir: PathBuf::from("results"),
dedup_pop_and_fill: false,
elite_count: 2,
prior_topology_paths: vec![],
resume_from: None,
topology_options: TopologyOptions::default(),
hidden_dim_pool: 4..=8,
hidden_dim_stride: 1,
combine_op_pool: vec![], activation_pool: vec![], standardize_op_pool: vec![], fitness_label: FitnessLabel::default(),
dropout_prob: 0.1,
selection: None,
crossover: None,
}
}
}
impl EngineOptions {
pub(crate) fn derive_topology_options(&self, seed: usize) -> TopologyOptions {
let mut t = self.topology_options;
t.seed = seed;
t.dropout_prob = self.dropout_prob;
t
}
pub fn builder() -> EngineOptionsBuilder {
EngineOptionsBuilder {
inner: EngineOptions::default(),
}
}
}
pub struct EngineOptionsBuilder {
inner: EngineOptions,
}
impl EngineOptionsBuilder {
pub fn build(mut self) -> Result<EngineOptions> {
let o = &mut self.inner;
let pop_size = o.pop_size.ok_or_else(|| {
EngineError::InvalidOptions("set_pop_size() is required — must be >= 2".into())
})?;
if pop_size < 2 {
return Err(EngineError::InvalidOptions(
"pop_size must be >= 2 (required for crossover)".into(),
)
.into());
}
let num_generations = o.num_generations.ok_or_else(|| {
EngineError::InvalidOptions("set_num_generations() is required — must be >= 1".into())
})?;
if num_generations < 1 {
return Err(EngineError::InvalidOptions(
"num_generations must be >= 1 (at least one evolution cycle)".into(),
)
.into());
}
if o.elite_count < 1 {
return Err(EngineError::InvalidOptions(
"elite_count must be >= 1 (at least one elite must survive)".into(),
)
.into());
}
if o.selection.is_none() {
return Err(EngineError::InvalidOptions(
"set_selection() is required — choose SelectionMethod::Tournament".into(),
)
.into());
}
if o.crossover.is_none() {
return Err(EngineError::InvalidOptions(
"set_crossover() is required — choose CrossoverMethod::OnePoint or Uniform".into(),
)
.into());
}
if o.mutation.prob() <= 0.0 {
return Err(EngineError::InvalidOptions(
"set_mutation() is required — choose MutationMethod::Activation, CombineOp, or Standardize"
.into(),
)
.into());
}
if o.resume_from.is_some() && !o.prior_topology_paths.is_empty() {
return Err(EngineError::InvalidOptions(
"set_resume_from() and set_prior_topology() are mutually exclusive — resume replaces the population, warm start injects into a fresh one"
.into(),
)
.into());
}
o.pop_size = Some(pop_size);
o.num_generations = Some(num_generations);
if o.hidden_dim_pool.is_empty() {
o.hidden_dim_pool = 4..=8;
}
if o.combine_op_pool.is_empty() {
o.combine_op_pool = crate::evolution::pools::all_combine_ops();
}
if o.activation_pool.is_empty() {
o.activation_pool = crate::evolution::pools::all_activations();
}
if o.standardize_op_pool.is_empty() {
o.standardize_op_pool = crate::evolution::pools::all_standardize_ops();
}
Ok(self.inner)
}
pub fn set_pop_size(mut self, n: usize) -> Self {
self.inner.pop_size = Some(n);
self
}
pub fn set_num_generations(mut self, n: usize) -> Self {
self.inner.num_generations = Some(n);
self
}
pub fn set_seed(mut self, s: Option<u64>) -> Self {
self.inner.seed = s;
self
}
pub fn set_num_threads(mut self, n: usize) -> Self {
self.inner.num_threads = n;
self
}
pub fn set_results_dir(mut self, p: impl Into<PathBuf>) -> Self {
self.inner.results_dir = p.into();
self
}
pub fn set_selection(mut self, method: SelectionMethod) -> Self {
self.inner.selection = Some(method);
self
}
pub fn set_dropout_prob(mut self, p: f32) -> Self {
self.inner.dropout_prob = p.clamp(0.0, 1.0);
self
}
pub fn set_crossover(mut self, kind: CrossoverMethod) -> Self {
self.inner.crossover = Some(kind);
self
}
pub fn set_mutation(mut self, kind: MutationMethod) -> Self {
self.inner.mutation = kind;
self
}
pub fn set_dedup_pop_and_fill(mut self, on: bool) -> Self {
self.inner.dedup_pop_and_fill = on;
self
}
pub fn set_elite_count(mut self, n: usize) -> Self {
self.inner.elite_count = n;
self
}
pub fn set_prior_topology(mut self, path: impl Into<PathBuf>) -> Self {
self.inner.prior_topology_paths.push(path.into());
self
}
pub fn set_prior_topologies(mut self, paths: Vec<impl Into<PathBuf>>) -> Self {
self.inner
.prior_topology_paths
.extend(paths.into_iter().map(|p| p.into()));
self
}
pub fn set_resume_from(mut self, dir: impl Into<PathBuf>) -> Self {
self.inner.resume_from = Some(dir.into());
self
}
pub fn set_topology_options(mut self, t: TopologyOptions) -> Self {
self.inner.topology_options = t;
self
}
pub fn set_hidden_dim(mut self, n: usize) -> Self {
self.inner.topology_options.hidden_dim = n;
self
}
pub fn set_hidden_dim_pool(mut self, r: RangeInclusive<usize>) -> Self {
self.inner.hidden_dim_pool = r;
self
}
pub fn set_hidden_dim_stride(mut self, s: usize) -> Self {
self.inner.hidden_dim_stride = s.max(1);
self
}
pub fn set_combine_op_pool(mut self, ops: Vec<CombineOp>) -> Self {
self.inner.combine_op_pool = ops;
self
}
pub fn set_activation_pool(mut self, acts: Vec<Activation>) -> Self {
self.inner.activation_pool = acts;
self
}
pub fn set_standardize_op_pool(mut self, ops: Vec<crate::graph::node::StandardizeOp>) -> Self {
self.inner.standardize_op_pool = ops;
self
}
pub fn set_min_hidden_num_nodes(mut self, n: usize) -> Self {
self.inner.topology_options.min_hidden_num_nodes = n;
self
}
pub fn set_max_hidden_num_nodes(mut self, n: usize) -> Self {
self.inner.topology_options.max_hidden_num_nodes = n;
self
}
pub fn set_min_hidden_inputs_per_node(mut self, n: usize) -> Self {
self.inner.topology_options.min_hidden_inputs_per_node = n;
self
}
pub fn set_max_hidden_inputs_per_node(mut self, n: usize) -> Self {
self.inner.topology_options.max_hidden_inputs_per_node = n;
self
}
pub fn set_min_hidden_outputs_per_node(mut self, n: usize) -> Self {
self.inner.topology_options.min_hidden_outputs_per_node = n;
self
}
pub fn set_max_hidden_outputs_per_node(mut self, n: usize) -> Self {
self.inner.topology_options.max_hidden_outputs_per_node = n;
self
}
}