use crate::graph::network::Network;
pub trait ChampionScorer: Send {
fn holdout_score(&mut self, net: &mut Network, game_i: usize) -> flodl::tensor::Result<f32>;
}
impl ChampionScorer for dyn crate::trainer::EngineTrainer {
fn holdout_score(&mut self, net: &mut Network, game_i: usize) -> flodl::tensor::Result<f32> {
crate::trainer::EngineTrainer::holdout_score(self, net, game_i)
}
}
#[derive(Clone, Debug)]
pub struct GuardrailVerdict {
pub hash: String,
pub race_smoothed: Option<f32>,
pub scores: Vec<f32>,
}
impl GuardrailVerdict {
pub fn mean(&self) -> Option<f32> {
if self.scores.is_empty() {
return None;
}
Some(self.scores.iter().sum::<f32>() / self.scores.len() as f32)
}
pub fn std(&self) -> Option<f32> {
let mean = self.mean()?;
if self.scores.len() < 2 {
return Some(0.0);
}
let var = self
.scores
.iter()
.map(|s| {
let d = s - mean;
d * d
})
.sum::<f32>()
/ self.scores.len() as f32;
Some(var.sqrt())
}
}
pub fn reload_champion(
run_dir: &std::path::Path,
hash: &str,
device: flodl::Device,
) -> Option<Network> {
let state_raw = std::fs::read_to_string(run_dir.join("nets").join(format!("{hash}.json"))).ok()?;
let topo_json = serde_json::from_str::<serde_json::Value>(&state_raw)
.ok()?
.get("topology")
.and_then(|t| t.as_str())
.map(String::from)?;
let topo = crate::graph::topology::Topology::from_json(&topo_json).ok()?;
let mut net = Network::build(&topo, device).ok()?;
let short = &hash[..8.min(hash.len())];
let elite = run_dir.join(format!("elite-{short}.safetensors"));
let weights = if elite.exists() {
elite
} else {
run_dir.join(format!("checkpoint-elite-{short}.safetensors"))
};
if !weights.exists() {
tracing::warn!(
"guardrail: no trained weights for {short} (looked for elite-*.safetensors and checkpoint-elite-*.safetensors) — refusing to score a fresh-init net"
);
return None;
}
if let Err(e) = crate::utils::safetensors::load_safetensors(&mut net, &weights) {
tracing::warn!("guardrail: loading {} failed ({e}) — refusing to score a partially-loaded net", weights.display());
return None;
}
Some(net)
}
pub fn score_saved(
run_dir: &std::path::Path,
champion_hash: &str,
scorer: &mut dyn ChampionScorer,
matches: usize,
device: flodl::Device,
) -> Option<GuardrailVerdict> {
check_champion(run_dir, champion_hash, None, scorer, matches, device)
}
pub fn score_with<T, F>(
run_dir: &std::path::Path,
champion_hash: &str,
race_smoothed: Option<f32>,
matches: usize,
device: flodl::Device,
trainer: &mut T,
score: F,
) -> Option<GuardrailVerdict>
where
F: Fn(&mut T, &mut Network, usize) -> flodl::tensor::Result<f32>,
{
let mut net = reload_champion(run_dir, champion_hash, device)?;
let mut scores = Vec::with_capacity(matches);
for game_i in 0..matches {
match score(trainer, &mut net, game_i) {
Ok(s) => scores.push(s),
Err(e) => tracing::warn!("guardrail: holdout game {game_i} failed ({e}) — skipped"),
}
}
if scores.is_empty() {
return None;
}
Some(GuardrailVerdict {
hash: champion_hash.to_string(),
race_smoothed,
scores,
})
}
pub fn check_champion(
run_dir: &std::path::Path,
champion_hash: &str,
race_smoothed: Option<f32>,
scorer: &mut dyn ChampionScorer,
matches: usize,
device: flodl::Device,
) -> Option<GuardrailVerdict> {
let mut net = reload_champion(run_dir, champion_hash, device)?;
let mut scores = Vec::with_capacity(matches);
for game_i in 0..matches {
match scorer.holdout_score(&mut net, game_i) {
Ok(s) => scores.push(s),
Err(e) => tracing::warn!("guardrail: holdout game {game_i} failed ({e}) — skipped"),
}
}
if scores.is_empty() {
return None;
}
Some(GuardrailVerdict {
hash: champion_hash.to_string(),
race_smoothed,
scores,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn verdict_mean_and_std() {
let v = GuardrailVerdict {
hash: "abc".into(),
race_smoothed: Some(10.0),
scores: vec![10.0, 500.0, 42.0],
};
let m = v.mean().unwrap();
assert!((m - 552.0 / 3.0).abs() < 1e-5);
let s = v.std().unwrap();
assert!(s > 100.0, "a 10/500/42 batch must have a wide ±, got {s}");
let empty = GuardrailVerdict {
hash: "abc".into(),
race_smoothed: None,
scores: vec![],
};
assert!(empty.mean().is_none() && empty.std().is_none());
}
#[test]
fn reload_refuses_without_weights() {
let dir = std::env::temp_dir().join("gras-guardrail-no-weights");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(dir.join("nets")).unwrap();
std::fs::write(
dir.join("nets/deadbeefdeadbeef.json"),
r#"{"topology":"{}"}"#,
)
.unwrap();
assert!(reload_champion(&dir, "deadbeefdeadbeef", flodl::Device::CPU).is_none());
let _ = std::fs::remove_dir_all(&dir);
}
}