alter_ego / serving /src /main.rs
geraldaton20's picture
initial upload: source code (no build artifacts)
f4f166e verified
Raw History Blame Contribute Delete
14.1 kB
//! Smoke test / demo for the Alter-Ego serving system.
//!
//! Default: builds a randomly-initialized small SAN (no trained checkpoint or
//! network needed) and runs the real-time loop.
//!
//! With `--ckpt <dir>`: loads a real checkpoint produced by the Kaggle training
//! pipeline (`training/kernels/train.py`) — proving the Python->Rust format
//! compatibility — and runs a few turns against the trained model.
use std::sync::Arc;
use rand::Rng;
use alter_ego_serve::checkpoint::load_checkpoint;
use alter_ego_serve::ecosystem::Ecosystem;
use alter_ego_serve::model::{Judge, MockJudge, Needle2Judge, SanConfig};
#[cfg(not(needle_ffi))]
compile_error!(
"The alter-ego engine is a resident (in-process) model and requires the \
GNU target (x86_64-pc-windows-gnu). It is set as the default in \
.cargo/config.toml — build with `cargo build`, not the MSVC target."
);
#[tokio::main]
async fn main() -> anyhow::Result<()> {
env_logger::init();
let args: Vec<String> = std::env::args().collect();
let get = |flag: &str| {
args.iter()
.position(|a| a == flag)
.and_then(|p| args.get(p + 1).cloned())
};
if let Some(path) = get("--tokenizer") {
// validate early so failures are loud
alter_ego_serve::tokenizer_bpe::HfBpe::from_file(&path)?;
println!("tokenizer OK: {path}");
}
if let Some(n) = get("--calibrate") {
let n: usize = n.parse().unwrap_or(200);
let jd = get("--judge");
return run_calibration(n, jd.as_deref()).await;
}
if let Some(spec) = get("--pack") {
// --pack dir:out.aeg
let (dir, out) = spec.split_once(':').expect("--pack dir:out.aeg");
let n = alter_ego_serve::bundle::pack_dir(dir, out, None)?;
println!("packed {n} files -> {out}");
return Ok(());
}
if let Some(spec) = get("--unpack") {
let (inp, dir) = spec.split_once(':').expect("--unpack in.aeg:dir");
let n = alter_ego_serve::bundle::unpack(inp, dir)?;
println!("unpacked {n} entries -> {dir}");
return Ok(());
}
if let Some(n) = get("--bench") {
alter_ego_serve::bench::run(n.parse().unwrap_or(30));
return Ok(());
}
if args.iter().any(|a| a == "--serve") {
let port: u16 = get("--port").and_then(|p| p.parse().ok()).unwrap_or(8080);
let ckpt = args.iter().position(|a| a == "--ckpt").map(|p| args[p + 1].clone());
let tok = get("--tokenizer");
let jd = get("--judge");
return run_server(port, ckpt.as_deref(), tok.as_deref(), jd.as_deref()).await;
}
for (flag, writer) in [
("--export-safetensors", 0usize),
("--export-gguf", 1usize),
] {
if let Some(path) = get(flag) {
let (params, cfg) = load_params_for_export(
args.iter().position(|a| a == "--ckpt").map(|p| args[p + 1].clone()).as_deref(),
)?;
match writer {
0 => alter_ego_serve::export::write_safetensors(&params, &path)?,
_ => alter_ego_serve::export::write_gguf_gpt2(&params, &cfg, &path)?,
}
println!("exported {flag} -> {path} ({} tensors)", params.len());
return Ok(());
}
}
let judge_dir = get("--judge");
if let Some(pos) = args.iter().position(|a| a == "--ckpt") {
let dir = args.get(pos + 1).expect("missing path after --ckpt");
return run_real_checkpoint(dir, judge_dir.as_deref()).await;
}
run_smoke_test().await
}
fn prod_cfg() -> alter_ego_serve::model::SanConfig {
alter_ego_serve::model::SanConfig {
vocab: 8192,
d_model: 512,
n_layers: 16,
ffn_ratio: 4,
n_heads: 8,
max_seq_len: 256,
tied_embeddings: true,
}
}
fn load_params_for_export(
ckpt: Option<&str>,
) -> anyhow::Result<(std::collections::HashMap<String, ndarray::Array2<f32>>, alter_ego_serve::model::SanConfig)> {
let cfg = prod_cfg();
match ckpt {
Some(dir) => {
let (params, meta) =
alter_ego_serve::checkpoint::load_checkpoint(std::path::Path::new(dir), true)?;
println!("export source: checkpoint step={} tensors={}", meta.step, params.len());
Ok((params, cfg))
}
None => {
println!("export source: deterministic random base (no --ckpt given)");
let s = alter_ego_serve::main_helpers::random_student(&cfg);
Ok((s.params, cfg))
}
}
}
async fn run_calibration(n: usize, judge_dir: Option<&str>) -> anyhow::Result<()> {
use alter_ego_serve::calibration;
use alter_ego_serve::model::{Judge, MockJudge};
let judge: Box<dyn Judge> = match judge_dir {
Some("cactus") => build_cactus_judge()?,
_ => Box::new(MockJudge),
};
calibration::set_judge(judge);
let data = calibration::generate(n);
let (base, best_w, best) = calibration::run(&data);
println!("=== Alter-Ego trust calibration (n={n}) ===");
println!(
"baseline weights: acc={:.3} P={:.3} R={:.3} F1={:.3}",
base.accuracy(), base.precision(), base.recall(), base.f1()
);
println!(
"grid best: sv={:.2} nv={:.2} vf={:.2} | acc={:.3} P={:.3} R={:.3} F1={:.3}",
best_w.safety, best_w.novelty, best_w.verifiability,
best.accuracy(), best.precision(), best.recall(), best.f1()
);
Ok(())
}
async fn run_server(
port: u16,
ckpt_dir: Option<&str>,
tokenizer_path: Option<&str>,
judge_dir: Option<&str>,
) -> anyhow::Result<()> {
use alter_ego_serve::server::{router, AppState};
use alter_ego_serve::tokenizer_bpe::{Detokenizer, HfBpe, StubDetok};
let cfg = prod_cfg();
let mut eco = match ckpt_dir {
Some(dir) => {
let (params, meta) =
alter_ego_serve::checkpoint::load_checkpoint(std::path::Path::new(dir), true)?;
println!("skull online: step={} tensors={}", meta.step, params.len());
Ecosystem::from_checkpoint(params, cfg.clone(), make_judge(judge_dir)?, 1024, 0.01)?
}
None => {
let student = alter_ego_serve::main_helpers::random_student(&cfg);
Ecosystem::new(student, make_judge(judge_dir)?, 1024, 0.01)
}
};
if let Some(tp) = tokenizer_path {
let t = HfBpe::from_file(tp)?;
eco.set_tokenizer(Box::new(t));
println!("tokenizer attached: {tp}");
}
let detok: Box<dyn Detokenizer> = match tokenizer_path {
Some(tp) => Box::new(HfBpe::from_file(tp)?),
None => Box::new(StubDetok),
};
let state = Arc::new(AppState {
eco: tokio::sync::Mutex::new(eco),
model_id: "alter-ego-local".into(),
detok,
});
let app = router(state.clone());
// E3 wiring: background LoRA micro-steps on the VALIDATED backlog +
// ledger re-validation + skill maintenance, strictly between turns.
let bg = state;
tokio::spawn(async move {
let mut iv = tokio::time::interval(std::time::Duration::from_secs(20));
iv.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
iv.tick().await;
let mut eco = bg.eco.lock().await;
let _ = eco.background_micro_steps(8);
let _ = eco.revalidate_queued(8);
let _r = eco.skill_maintenance();
}
});
let addr = format!("0.0.0.0:{port}");
println!("OpenAI-compatible API listening on http://{addr}/v1");
let listener = tokio::net::TcpListener::bind(&addr).await?;
axum::serve(listener, app).await?;
Ok(())
}
/// Load a real Kaggle-trained checkpoint and run the loop against it.
async fn run_real_checkpoint(dir: &str, judge_dir: Option<&str>) -> anyhow::Result<()> {
println!("Loading checkpoint from {dir} ...");
let (params, meta) = load_checkpoint(std::path::Path::new(dir), true)?;
println!(
"checkpoint: step={} tokens={} tensors={}",
meta.step,
meta.tokens,
params.len()
);
// Architecture must match training/kernels/train.py (CFG["student"]).
let cfg = SanConfig {
vocab: 8192,
d_model: 512,
n_layers: 16,
ffn_ratio: 4,
n_heads: 8,
max_seq_len: 256,
tied_embeddings: true,
};
let student = alter_ego_serve::model::San::from_params(params, cfg.clone())?;
// Use the real alter-ego judge if a judge checkpoint is supplied.
let judge: Box<dyn Judge> = match judge_dir.as_deref() {
Some("cactus") => build_cactus_judge()?,
Some(jd) => {
println!("Loading alter-ego judge (San) from {jd} ...");
Box::new(Needle2Judge::from_checkpoint(jd, cfg.clone())?)
}
None => Box::new(MockJudge),
};
let mut orch = Ecosystem::new(student, judge, 1024, 0.01);
let mut rng = rand::thread_rng();
for turn in 0..4 {
let input: Vec<u32> = (0..16).map(|_| rng.gen_range(0..cfg.vocab as u32)).collect();
let res = orch.turn(&input, 8)?;
println!(
"[turn {turn}] verdict={} trust={:.3} out_tokens={}",
res.verdict,
res.score.total,
res.output_ids.len()
);
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
}
println!(
"real-checkpoint memory: episodic={} semantic={} replay={}",
orch.memory.episodic.len(),
orch.memory.semantic.len(),
orch.memory.replay.items.len()
);
println!("real-checkpoint load OK");
Ok(())
}
/// Dependency-free smoke test with a randomly-initialized small model.
async fn run_smoke_test() -> anyhow::Result<()> {
let cfg = SanConfig {
vocab: 512,
d_model: 64,
n_layers: 4,
ffn_ratio: 4,
n_heads: 4,
max_seq_len: 64,
tied_embeddings: true,
};
let student = alter_ego_serve::model::San::from_params(build_random_params(&cfg), cfg.clone())?;
let mut orch = Ecosystem::new(student, Box::new(MockJudge), 1024, 0.01);
println!(
"Alter-Ego serving smoke test | vocab={} d={} layers={}",
cfg.vocab, cfg.d_model, cfg.n_layers
);
let mut rng = rand::thread_rng();
for turn in 0..8 {
let input: Vec<u32> = (0..48).map(|_| rng.gen_range(0..cfg.vocab as u32)).collect();
let res = orch.turn(&input, 6)?;
println!(
"[turn {turn}] verdict={} trust={:.3} (struct={:.2} cons={:.2} verif={:.2} nov={:.2} safe={:.2}) out_tokens={}",
res.verdict,
res.score.total,
res.score.structural,
res.score.consistency,
res.score.verifiability,
res.score.novelty,
res.score.safety,
res.output_ids.len()
);
tokio::time::sleep(std::time::Duration::from_millis(20)).await;
}
println!(
"memory: episodic={} semantic={} replay={}",
orch.memory.episodic.len(),
orch.memory.semantic.len(),
orch.memory.replay.items.len()
);
println!("smoke test OK");
Ok(())
}
fn build_random_params(cfg: &SanConfig) -> std::collections::HashMap<String, ndarray::Array2<f32>> {
let mut rng = rand::thread_rng();
let d = cfg.d_model;
let ffn = cfg.ffn_ratio * d;
let v = cfg.vocab;
let l = cfg.n_layers;
let maxlen = cfg.max_seq_len;
let mut p = std::collections::HashMap::new();
p.insert("tok_emb.weight".into(), rand_arr(v, d, &mut rng));
p.insert("pos".into(), rand_arr(maxlen, d, &mut rng));
p.insert("head.weight".into(), rand_arr(v, d, &mut rng));
for i in 0..l {
p.insert(format!("blocks.{i}.ln1.weight"), rand_arr(1, d, &mut rng));
p.insert(format!("blocks.{i}.ln1.bias"), rand_arr(1, d, &mut rng));
p.insert(format!("blocks.{i}.attn.qkv.weight"), rand_arr(3 * d, d, &mut rng));
p.insert(format!("blocks.{i}.attn.qkv.bias"), rand_arr(1, 3 * d, &mut rng));
p.insert(format!("blocks.{i}.attn.o.weight"), rand_arr(d, d, &mut rng));
p.insert(format!("blocks.{i}.attn.o.bias"), rand_arr(1, d, &mut rng));
p.insert(format!("blocks.{i}.ln2.weight"), rand_arr(1, d, &mut rng));
p.insert(format!("blocks.{i}.ln2.bias"), rand_arr(1, d, &mut rng));
p.insert(format!("blocks.{i}.mlp.0.weight"), rand_arr(ffn, d, &mut rng));
p.insert(format!("blocks.{i}.mlp.0.bias"), rand_arr(1, ffn, &mut rng));
p.insert(format!("blocks.{i}.mlp.2.weight"), rand_arr(d, ffn, &mut rng));
p.insert(format!("blocks.{i}.mlp.2.bias"), rand_arr(1, d, &mut rng));
}
p.insert("ln_f.weight".into(), rand_arr(1, d, &mut rng));
p.insert("ln_f.bias".into(), rand_arr(1, d, &mut rng));
p
}
fn rand_arr(rows: usize, cols: usize, rng: &mut impl Rng) -> ndarray::Array2<f32> {
let data: Vec<f32> = (0..rows * cols).map(|_| (rng.gen::<f32>() - 0.5) * 0.1).collect();
ndarray::Array2::from_shape_vec((rows, cols), data).unwrap()
}
/// Build the Cactus-Needle alter-ego judge as a *resident* model: the engine
/// is loaded in-process (no subprocess, no Python at inference time). This is
/// the alter ego of the unified ecosystem, time-sliced alongside the student.
fn make_judge(judge_dir: Option<&str>) -> anyhow::Result<Box<dyn Judge>> {
match judge_dir {
Some("cactus") => build_cactus_judge(),
Some(p) => Ok(Box::new(Needle2Judge::from_checkpoint(p, prod_cfg())?)),
None => Ok(Box::new(MockJudge)),
}
}
#[allow(dead_code)]
fn build_cactus_judge_unused_marker() {}
fn build_cactus_judge() -> anyhow::Result<Box<dyn Judge>> {
#[cfg(needle_ffi)]
{
println!("Using Cactus-Needle (Needle 2) alter-ego judge [in-process engine]");
Ok(Box::new(alter_ego_serve::NeedleModel::new("needle/needle2.cact")?))
}
#[cfg(not(needle_ffi))]
{
// Unreachable: the compile_error! above fires first on the MSVC target.
anyhow::bail!("needle_ffi not enabled — build with the GNU target")
}
}