Download serving/src/bench.rs from geraldaton20/alter_ego: direct link, hf CLI and curl.
- Browser
- Download file 4.74 kB
-
https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/bench.rs
- Command line
-
hf download hf://geraldaton20/alter_ego/serving/src/bench.rs
-
curl -L -o bench.rs https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/bench.rs
4.74 kB
| //! Speed benchmark (plan E5.3, CPU-representative): measures every hot path | |
| //! of the skull on the current machine — generation tok/s, guided-beam cost, | |
| //! LoRA micro-steps/s, digestion throughput, BM25 rebuild/search, vector | |
| //! search. Run: `alter_ego_serve --bench [turns]` | |
| use std::time::Instant; | |
| use crate::digestion::{self}; | |
| use crate::memory::Experience; | |
| use crate::model::MockJudge; | |
| use crate::recall::Bm25Index; | |
| use crate::vector_index::VectorIndex; | |
| fn cfg_bench() -> crate::model::SanConfig { | |
| // Small-but-honest skull slice for CPU boxes; production GPU numbers come | |
| // from E5 hardware gates later. | |
| crate::model::SanConfig { | |
| vocab: 2048, | |
| d_model: 128, | |
| n_layers: 2, | |
| ffn_ratio: 4, | |
| n_heads: 4, | |
| max_seq_len: 128, | |
| tied_embeddings: true, | |
| } | |
| } | |
| fn row(name: &str, value: String) { | |
| println!("{:<34} {:>14}", name, value); | |
| } | |
| pub fn run(turns: usize) { | |
| let turns = turns.max(5); | |
| let cfg = cfg_bench(); | |
| let student = crate::main_helpers::random_student(&cfg); | |
| let mut eco = crate::ecosystem::Ecosystem::new(student, Box::new(MockJudge), 4096, 0.02); | |
| println!("=== Alter-Ego skull bench (CPU) ==="); | |
| println!("cfg: d={} L={} heads={} seq={}", cfg.d_model, cfg.n_layers, cfg.n_heads, cfg.max_seq_len); | |
| // ---- greedy generation + full turn loop ---- | |
| let gen_len = 32; | |
| let input: Vec<u32> = (0..48).map(|i| (i * 37 % 2000) as u32).collect(); | |
| let t0 = Instant::now(); | |
| let mut out_toks = 0usize; | |
| for i in 0..turns { | |
| let r = eco.turn(&(input[..].iter().map(|x| x + i as u32 % 7).collect::<Vec<u32>>()), gen_len).unwrap(); | |
| out_toks += r.output_ids.len(); | |
| } | |
| let dt = t0.elapsed().as_secs_f32(); | |
| row("turn latency (avg ms)", format!("{:.1}", dt * 1000.0 / turns as f32)); | |
| row("generation tok/s", format!("{:.0}", out_toks as f32 / dt)); | |
| row("beam used in loop", "n/a (conf-gated)".into()); | |
| // ---- guided beam worst case (3 candidates) ---- | |
| let t0 = Instant::now(); | |
| let _ = eco.generate_guided(&input, 16); | |
| row("guided beam (3-cand) ms", format!("{:.1}", t0.elapsed().as_secs_f32() * 1000.0)); | |
| // ---- LoRA micro-steps (background trainer) ---- | |
| let t0 = Instant::now(); | |
| let losses = eco.background_micro_steps(16).unwrap_or_default(); | |
| let n = losses.len().max(1) as f32; | |
| row("LoRA micro-step ms", format!("{:.2}", t0.elapsed().as_secs_f32() * 1000.0 / n)); | |
| // ---- digestion pipeline ---- | |
| let filler = "The system implies stability because checks run first. Then set values. "; | |
| let doc = filler.repeat(120); // ~1300 words => late-gate territory | |
| let tok = digestion::WordTokenizer { vocab: 8192 }; | |
| let emb = digestion::StubEmbedder { dim: 64 }; | |
| let t0 = Instant::now(); | |
| let reps = 20; | |
| for _ in 0..reps { | |
| let d = digestion::digest_document(&doc, &tok, &emb); | |
| std::hint::black_box(d.root.text.len()); | |
| } | |
| let dd = t0.elapsed().as_secs_f32() / reps as f32; | |
| row("digestion ms/doc (~1.3k w)", format!("{:.1}", dd * 1000.0)); | |
| // ---- BM25 recall ---- | |
| for i in 0..1000 { | |
| let mut e = Experience::with_text( | |
| vec![], | |
| vec![], | |
| vec![format!("fact {i}")], | |
| format!("episode {i}: rust memory safety and borrow checking topic {i}"), | |
| "s", | |
| ); | |
| e.id = format!("e{i}"); | |
| eco.memory.episodic.record(e); | |
| } | |
| let t0 = Instant::now(); | |
| let ix = Bm25Index::rebuild(&eco.memory); | |
| row("BM25 rebuild 1k episodes ms", format!("{:.1}", t0.elapsed().as_secs_f32() * 1000.0)); | |
| let t0 = Instant::now(); | |
| let q = 200; | |
| for _ in 0..q { | |
| std::hint::black_box(ix.search("borrow checker safety")); | |
| } | |
| row("BM25 search µs", format!("{:.0}", t0.elapsed().as_secs_f32() * 1e6 / q as f32)); | |
| // ---- vector index ---- | |
| let mut vi = VectorIndex::new(64); | |
| for i in 0..1000 { | |
| let v: Vec<f32> = (0..64).map(|d| ((i * 7 + d * 13) % 97) as f32 / 97.0).collect(); | |
| let _ = vi.add(&format!("leaf-{i}"), v); | |
| } | |
| let qv: Vec<f32> = (0..64).map(|d| ((3 * 7 + d * 13) % 97) as f32 / 97.0).collect(); | |
| let t0 = Instant::now(); | |
| for _ in 0..q { | |
| std::hint::black_box(vi.search(&qv, 5)); | |
| } | |
| row("vector top-5 over 1k µs", format!("{:.0}", t0.elapsed().as_secs_f32() * 1e6 / q as f32)); | |
| // ---- calibration eval rate ---- | |
| use crate::calibration; | |
| calibration::set_judge(Box::new(MockJudge)); | |
| let data = calibration::generate(400); | |
| let t0 = Instant::now(); | |
| let _ = calibration::run(&data); | |
| row("calibration grid+eval ms/400", format!("{:.0}", t0.elapsed().as_secs_f32() * 1000.0)); | |
| println!("=== end bench ==="); | |
| } | |