Download serving/src/main.rs from geraldaton20/alter_ego: direct link, hf CLI and curl.
- Browser
- Download file 14.1 kB
-
https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/main.rs
- Command line
-
hf download hf://geraldaton20/alter_ego/serving/src/main.rs
-
curl -L -o main.rs https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/main.rs
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}; | |
| 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." | |
| ); | |
| 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(¶ms, &path)?, | |
| _ => alter_ego_serve::export::write_gguf_gpt2(¶ms, &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)), | |
| } | |
| } | |
| fn build_cactus_judge_unused_marker() {} | |
| fn build_cactus_judge() -> anyhow::Result<Box<dyn Judge>> { | |
| { | |
| println!("Using Cactus-Needle (Needle 2) alter-ego judge [in-process engine]"); | |
| Ok(Box::new(alter_ego_serve::NeedleModel::new("needle/needle2.cact")?)) | |
| } | |
| { | |
| // Unreachable: the compile_error! above fires first on the MSVC target. | |
| anyhow::bail!("needle_ffi not enabled — build with the GNU target") | |
| } | |
| } | |