use super::config::RaceConfig;
use super::core::{CoreEngine, CoreEngineParts, assert_trainer_blob_matches};
use crate::state::RunHeader;
use crate::utils::fitness::Fitness;
use flodl::tensor::Result;
pub struct RlEngine(pub(crate) CoreEngine);
impl std::ops::Deref for RlEngine {
type Target = CoreEngine;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl std::ops::DerefMut for RlEngine {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl RlEngine {
pub fn from_spec(spec: crate::engine::run_spec::RunSpec) -> Result<Self> {
Ok(Self(CoreEngine::from_spec(spec)?))
}
pub fn from_rl_spec<T: crate::trainer::RlStep + 'static>(
spec: crate::engine::run_spec::RLSpec<T>,
) -> Result<Self> {
let crate::engine::run_spec::RLSpec {
config,
fitness,
trainer,
seed,
run_dir,
} = spec;
Ok(Self(CoreEngine::from_spec(
crate::engine::run_spec::RunSpec::rl(config, fitness, trainer, seed, run_dir),
)?))
}
pub fn resume(
run_dir: std::path::PathBuf,
config: RaceConfig,
fitness: Fitness,
trainer: impl crate::trainer::RlStep + 'static,
) -> Result<Self> {
Self::resume_with(
run_dir,
config,
fitness,
crate::trainer::AnyTrainer::rl(trainer),
)
}
pub fn resume_from(
run_dir: impl Into<std::path::PathBuf>,
fitness: Fitness,
trainer: impl crate::trainer::RlStep + 'static,
) -> Result<Self> {
let run_dir = run_dir.into();
let header = crate::state::load_engine_json(&run_dir)?;
let mut config = RaceConfig::from_snapshot(&header.config);
CoreEngine::apply_header_search_space(&mut config, &header);
Self::resume(run_dir, config, fitness, trainer)
}
fn resume_with(
run_dir: std::path::PathBuf,
config: RaceConfig,
fitness: Fitness,
trainer: crate::trainer::AnyTrainer,
) -> Result<Self> {
let header = crate::state::load_engine_json(&run_dir)?;
let persisted_counters = RunHeader {
culls: header.culls,
run_elapsed_secs: header.run_elapsed_secs,
children_born_at_clock: header.children_born_at_clock.clone(),
..header.clone()
};
assert_trainer_blob_matches(&header.trainer, &trainer, "resume_rl")?;
config
.validate_search_pools()
.map_err(crate::utils::error::EngineError::InvalidOptions)?;
if header.engine_mode.as_deref() != Some("rl") {
return Err(crate::utils::error::EngineError::InvalidOptions(format!(
"resume_rl: {} was recorded as mode \"{}\", not \"rl\" — use RaceEngine::resume with its data_dir",
run_dir.display(),
header.config.mode
))
.into());
}
CoreEngine::rewind_csvs_to_manifest(&run_dir)?;
let metrics = config.metrics.clone();
let run_seed = header.run_seed;
let log_level = config.log_level;
let meta_ctx = crate::engine::config::RunMetaCtx {
input_dim: header.input_dim,
output_dim: header.output_dim,
batch_size: None, dropout_prob: header.topology_options.dropout_prob,
fitness_label: header.fitness_label.0.clone(),
direction: format!("{:?}", header.fitness_direction).to_lowercase(),
pop_size: config.pop_size,
run_seed,
};
let mut engine = CoreEngine::assemble(CoreEngineParts {
run_dir: run_dir.clone(),
header,
config,
meta_ctx,
stream: None,
dataset: None,
explicit_test_rows: None,
exam: None,
fitness,
metrics,
trainer,
log_level,
resumed: true,
});
engine.load_live_frontier()?;
engine.culls = persisted_counters.culls;
engine.children_born_at_clock = persisted_counters.children_born_at_clock;
engine.elapsed_base_secs = persisted_counters.run_elapsed_secs;
Ok(Self(engine))
}
}