Download serving/src/ecosystem.rs from geraldaton20/alter_ego: direct link, hf CLI and curl.
- Browser
- Download file 32.7 kB
-
https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/ecosystem.rs
- Command line
-
hf download hf://geraldaton20/alter_ego/serving/src/ecosystem.rs
-
curl -L -o ecosystem.rs https://huggingface.co/geraldaton20/alter_ego/resolve/main/serving/src/ecosystem.rs
32.7 kB
| //! Real-time learning loop - the unified in-process ecosystem ("skull"). | |
| //! | |
| //! PRD section 4 execution model, sequential with background learning: | |
| //! 1. (gate) long inputs are digested before anything else | |
| //! 1. student generates (blocking, user-facing) | |
| //! 2. experience captured to Episodic IMMEDIATELY (any verdict) | |
| //! 3. alter ego validates on the TEXT form | |
| //! 4. COMMIT -> semantic triples + replay + queued LoRA micro-steps | |
| //! QUEUE -> ValidationLedger (never replay) | |
| //! REJECT -> logged rationale only | |
| //! 5. skills observe success/staleness; stale rehearsed, rotten archived | |
| //! Background trainer drains the VALIDATED replay backlog only - never the | |
| //! unvalidated current interaction - mutating ONLY the LoRA standby buffer, | |
| //! published atomically between turns. The base stays frozen forever. | |
| use std::sync::Arc; | |
| use std::time::Instant; | |
| use crate::digestion::{self, Embedder, Tokenizer, GATE_TOKENS}; | |
| use crate::error::Result; | |
| use crate::lora::AdapterHandle; | |
| use crate::memory::{Experience, TriMemory}; | |
| use crate::model::{Judge, San}; | |
| use crate::recall::Bm25Index; | |
| use crate::trust::{TrustScore, Verdict}; | |
| use crate::vector_index::VectorIndex; | |
| pub struct TurnResult { | |
| pub output_ids: Vec<u32>, | |
| pub score: TrustScore, | |
| pub verdict: Verdict, | |
| /// All verdicts when digestion produced multiple leaves. | |
| pub verdicts: Vec<(String, Verdict, f32)>, | |
| pub confidence: f32, | |
| pub beam_used: bool, | |
| pub recalled_context: Vec<String>, | |
| /// SCoRe-lite revision episode (when a low-trust first attempt triggered | |
| /// a second pass). | |
| pub revision: Option<RevisionInfo>, | |
| /// What the user actually receives (revision if it scored higher). | |
| pub final_output_ids: Vec<u32>, | |
| /// Wall-clock for the full turn (PRD section 10 latency gate). | |
| pub duration_ms: f32, | |
| } | |
| pub const CONFIDENCE_BEAM_THRESHOLD: f32 = 0.6; | |
| pub const BEAM_CANDIDATES: usize = 3; | |
| const BEAM_TEMPS: [f32; 3] = [0.7, 1.0, 1.3]; | |
| const STALE_SECONDS: f64 = 7.0 * 24.0 * 3600.0; | |
| const ROTTEN_SECONDS: f64 = 30.0 * 24.0 * 3600.0; | |
| struct Rng(u64); | |
| impl Rng { | |
| fn new(seed: u64) -> Self { | |
| Self(seed | 1) | |
| } | |
| fn next_f32(&mut self) -> f32 { | |
| self.0 = self | |
| .0 | |
| .wrapping_mul(6364136223846793005) | |
| .wrapping_add(1442695040888963407); | |
| ((self.0 >> 40) as f32) / ((1u32 << 24) as f32) | |
| } | |
| } | |
| pub struct RevisionInfo { | |
| pub first_trust: f32, | |
| pub revised_trust: f32, | |
| pub accepted: bool, | |
| } | |
| pub struct Ecosystem { | |
| pub student: San, | |
| pub judge: Box<dyn Judge>, | |
| pub memory: TriMemory, | |
| pub adapters: Arc<AdapterHandle>, | |
| pub lr: f32, | |
| pub step: usize, | |
| pub tokenizer: Box<dyn Tokenizer>, | |
| pub embedder: Box<dyn Embedder>, | |
| pub archived_skills: Vec<String>, | |
| pub recall_conditioning: bool, | |
| pub revisions_enabled: bool, | |
| pub sc_attempts: usize, | |
| pub sc_hits: usize, | |
| /// Ingestion-only vector index over digested leaf chunks (E2.7). | |
| pub vector_index: VectorIndex, | |
| /// A7 Phase 2: optional typed-event sink (bridged to OgRune EventHub). | |
| pub event_sink: Option<std::sync::Arc<dyn Fn(&str, &serde_json::Value) + Send + Sync>>, | |
| rng: Rng, | |
| } | |
| impl Ecosystem { | |
| pub fn new( | |
| mut student: San, | |
| judge: Box<dyn Judge>, | |
| replay_max: usize, | |
| lr: f32, | |
| ) -> Self { | |
| let handle = Arc::new(AdapterHandle::new(&student.cfg)); | |
| student.set_adapter(handle.active()); | |
| Self { | |
| student, | |
| judge, | |
| memory: TriMemory::new(replay_max), | |
| adapters: handle, | |
| lr, | |
| step: 0, | |
| tokenizer: Box::new(digestion::WordTokenizer { vocab: 8192 }), | |
| embedder: Box::new(digestion::StubEmbedder { dim: 64 }), | |
| archived_skills: Vec::new(), | |
| recall_conditioning: false, | |
| revisions_enabled: false, | |
| sc_attempts: 0, | |
| sc_hits: 0, | |
| vector_index: VectorIndex::default(), | |
| event_sink: None, | |
| rng: Rng::new(0xDA7A_5EED), | |
| } | |
| } | |
| /// Build from a loaded checkpoint parameter map (plug-in path). | |
| pub fn from_checkpoint( | |
| params: crate::model::ParamMap, | |
| cfg: crate::model::SanConfig, | |
| judge: Box<dyn Judge>, | |
| replay_max: usize, | |
| lr: f32, | |
| ) -> Result<Self> { | |
| let student = San::from_params(params, cfg)?; | |
| Ok(Self::new(student, judge, replay_max, lr)) | |
| } | |
| // ------------------------------------------------------------------ | |
| // step 1: generation (greedy or trust-guided beam) | |
| // ------------------------------------------------------------------ | |
| fn confidence_at_last(&self, ids: &[u32]) -> Result<f32> { | |
| let logits = self.student.forward(ids)?; | |
| let last = logits.row(logits.nrows() - 1); | |
| let m = last.iter().cloned().fold(f32::NEG_INFINITY, f32::max); | |
| let exps: Vec<f32> = last.iter().map(|x| (x - m).exp()).collect(); | |
| let sum: f32 = exps.iter().sum(); | |
| Ok(exps.iter().cloned().fold(0.0f32, f32::max) / sum.max(1e-9)) | |
| } | |
| pub fn generate_greedy(&self, input_ids: &[u32], gen_len: usize) -> Result<Vec<u32>> { | |
| self.student.generate(input_ids, gen_len) | |
| } | |
| /// Temperature-sampled variant (guided beam candidate). | |
| fn generate_sampled(&mut self, input_ids: &[u32], gen_len: usize, temp: f32) -> Result<Vec<u32>> { | |
| let mut seq = input_ids.to_vec(); | |
| for _ in 0..gen_len { | |
| if seq.len() >= self.student.cfg.max_seq_len { | |
| break; | |
| } | |
| let logits = self.student.forward(&seq)?; | |
| let last = logits.row(logits.nrows() - 1); | |
| let inv = 1.0 / temp.max(1e-3); | |
| let m = last.iter().cloned().fold(f32::NEG_INFINITY, f32::max); | |
| let mut acc = 0.0f32; | |
| let mut probs: Vec<f32> = Vec::with_capacity(last.len()); | |
| for x in last.iter() { | |
| let e = ((x - m) * inv).exp(); | |
| probs.push(e); | |
| acc += e; | |
| } | |
| for p in probs.iter_mut() { | |
| *p /= acc; | |
| } | |
| let r = self.rng.next_f32(); | |
| let mut c = 0.0f32; | |
| let mut choice = 0usize; | |
| for (j, p) in probs.iter().enumerate() { | |
| c += p; | |
| if r <= c { | |
| choice = j; | |
| break; | |
| } | |
| } | |
| seq.push(choice as u32); | |
| } | |
| Ok(seq[input_ids.len()..].to_vec()) | |
| } | |
| /// Guided beam search (PRD section 5): triggered by low confidence; | |
| /// candidates scored by the alter ego; highest trust wins. | |
| pub fn generate_guided( | |
| &mut self, | |
| input_ids: &[u32], | |
| gen_len: usize, | |
| ) -> Result<(Vec<u32>, bool)> { | |
| let conf = self.confidence_at_last(input_ids)?; | |
| if conf >= CONFIDENCE_BEAM_THRESHOLD { | |
| let out = self.generate_greedy(input_ids, gen_len)?; | |
| return Ok((out, false)); | |
| } | |
| let mut best: Option<(Vec<u32>, f32)> = None; | |
| for t in BEAM_TEMPS { | |
| let cand = self.generate_sampled(input_ids, gen_len, t)?; | |
| let exp = Experience::with_text( | |
| input_ids.to_vec(), | |
| cand.clone(), | |
| vec![], | |
| String::new(), | |
| "beam", | |
| ); | |
| let s = self.judge.score(&exp); | |
| if best.as_ref().map(|(_, bs)| s.total > *bs).unwrap_or(true) { | |
| best = Some((cand, s.total)); | |
| } | |
| } | |
| Ok((best.map(|(o, _)| o).unwrap_or_default(), true)) | |
| } | |
| // ------------------------------------------------------------------ | |
| // steps 2-4: capture, validate, route | |
| // ------------------------------------------------------------------ | |
| fn capture_and_route(&mut self, mut exp: Experience, gen_len: usize) -> Result<TurnResult> { | |
| let (out, beam) = self.generate_guided(&exp.input, gen_len)?; | |
| let confidence = self.confidence_at_last(&exp.input).unwrap_or(0.0); | |
| exp.output = out.clone(); | |
| // step 2: immediate capture (PRD) - regardless of upcoming verdict | |
| self.memory.episodic.record(exp.clone()); | |
| // B3 accommodation: digest-first judging — long text is ROOT-compressed | |
| // so the 256-token judge window sees the whole meaning, not a truncation. | |
| let est_words = exp.text.split_whitespace().count(); | |
| if est_words > digestion::GATE_TOKENS { | |
| let doc = digestion::digest_document( | |
| &exp.text, | |
| self.tokenizer.as_ref(), | |
| self.embedder.as_ref(), | |
| ); | |
| let mut claims = exp.claims.clone(); | |
| for l in &doc.leaves { | |
| for c in &l.core_claims { | |
| if !claims.contains(c) { | |
| claims.push(c.clone()); | |
| } | |
| } | |
| } | |
| exp.claims = claims; | |
| exp.text = format!("ROOT DIGEST: {}", doc.root.text); | |
| let _ = digestion::LEAF_TOKENS; // window constants documented in module | |
| } | |
| // step 3: validation on the text form | |
| let score = self.judge.score(&exp); | |
| let verdict = score.verdict(); // single evaluation per experience | |
| match verdict { | |
| Verdict::Commit => { | |
| for c in &exp.claims { | |
| self.memory.semantic.add(crate::memory::Triple { | |
| subject: format!("exp:{}", exp.id), | |
| relation: "claims".into(), | |
| object: c.clone(), | |
| source_exp: exp.id.clone(), | |
| }); | |
| } | |
| self.memory.replay.push(exp.clone()); // validated anchor set ONLY | |
| } | |
| Verdict::Queue => { | |
| self.memory.ledger.push(exp.clone(), now_secs()); | |
| } | |
| Verdict::Reject => { | |
| log::info!("REJECT exp {} (trust={:.3})", exp.id, score.total); | |
| } | |
| } | |
| // ---- SCoRe-lite revision turn (PRD §5 extension) ---- | |
| let mut revision = None; | |
| let mut final_out = out.clone(); | |
| if self.revisions_enabled && verdict != Verdict::Commit { | |
| self.sc_attempts += 1; | |
| if let Some((mut e2, s2, v2)) = | |
| self.run_revision(&exp.input, &exp, &score, gen_len)? | |
| { | |
| e2.parent_exp_id = Some(exp.id.clone()); | |
| if v2 == Verdict::Commit { | |
| self.sc_hits += 1; | |
| e2.advantage = (1.0 + (s2.total - score.total)).clamp(1.0, 1.5); | |
| for c in &e2.claims { | |
| self.memory.semantic.add(crate::memory::Triple { | |
| subject: format!("exp:{}", e2.id), | |
| relation: "claims".into(), | |
| object: c.clone(), | |
| source_exp: e2.id.clone(), | |
| }); | |
| } | |
| // train on the full trajectory pair (attempt-1 context too) | |
| self.memory.replay.push(exp.clone()); | |
| self.memory.replay.push(e2.clone()); | |
| } else if v2 == Verdict::Queue { | |
| self.memory.ledger.push(e2.clone(), now_secs()); | |
| } else { | |
| log::info!("revision REJECT exp {} (trust={:.3})", e2.id, s2.total); | |
| } | |
| if s2.total > score.total { | |
| final_out = e2.output.clone(); | |
| } | |
| revision = Some(RevisionInfo { | |
| first_trust: score.total, | |
| revised_trust: s2.total, | |
| accepted: v2 == Verdict::Commit, | |
| }); | |
| } | |
| } | |
| self.step += 1; | |
| let vrow = (exp.id, verdict, score.total); | |
| Ok(TurnResult { | |
| output_ids: out, | |
| score, | |
| verdict, | |
| verdicts: vec![vrow], | |
| confidence, | |
| beam_used: beam, | |
| recalled_context: Vec::new(), | |
| duration_ms: 0.0, | |
| revision, | |
| final_output_ids: final_out, | |
| }) | |
| } | |
| /// One self-correction pass: condition on the prompt + judge feedback + | |
| /// first attempt; regenerate and re-judge. | |
| fn run_revision( | |
| &mut self, | |
| prompt_ids: &[u32], | |
| first: &Experience, | |
| s1: &TrustScore, | |
| gen_len: usize, | |
| ) -> Result<Option<(Experience, TrustScore, Verdict)>> { | |
| let fb = format!( | |
| "prior answer scored low trust {:.2} (consistency={:.2} verifiability={:.2} safety={:.2}); revise it correcting those weaknesses.", | |
| s1.total, s1.consistency, s1.verifiability, s1.safety | |
| ); | |
| let mut rev_input: Vec<u32> = prompt_ids.to_vec(); | |
| rev_input.extend(self.tokenizer.encode(&fb)); | |
| rev_input.extend_from_slice(&first.output); | |
| let budget = self.student.cfg.max_seq_len; | |
| if rev_input.len() > budget { | |
| let skip = rev_input.len() - budget; | |
| rev_input.drain(0..skip); | |
| } | |
| let revised = self.generate_greedy(&rev_input, gen_len)?; | |
| let text2 = format!("{}\n[revision of {}]", first.text, first.id); | |
| let mut e2 = Experience::with_text( | |
| rev_input, | |
| revised, | |
| first.claims.clone(), | |
| text2, | |
| "user", | |
| ); | |
| e2.advantage = 1.0; | |
| let s2 = self.judge.score(&e2); | |
| let v2 = s2.verdict(); | |
| Ok(Some((e2, s2, v2))) | |
| } | |
| /// Plain token-level turn (no document text attached). | |
| pub fn turn(&mut self, input_ids: &[u32], gen_len: usize) -> Result<TurnResult> { | |
| let t0 = Instant::now(); | |
| let exp = Experience::new(input_ids.to_vec(), vec![], vec![], "user"); | |
| let mut r = self.capture_and_route(exp, gen_len)?; | |
| r.duration_ms = t0.elapsed().as_secs_f32() * 1000.0; | |
| Ok(r) | |
| } | |
| /// Deterministic passthrough generation for lm-eval style harnesses: | |
| /// no memory writes, no digestion gate, no beam (E6 eval-mode). | |
| pub fn eval_turn(&self, input_ids: &[u32], gen_len: usize) -> Result<Vec<u32>> { | |
| self.generate_greedy(input_ids, gen_len) | |
| } | |
| /// Full turn with document text: recall -> (digestion gate) -> generate -> | |
| /// capture -> validate -> route. Long inputs (>256 est tokens) are chewed; | |
| /// each leaf is validated separately and commits train on compressed form. | |
| /// Swap in the Stage-3 BPE tokenizer (encode parity) or any Embedder. | |
| pub fn set_tokenizer(&mut self, t: Box<dyn Tokenizer>) { | |
| self.tokenizer = t; | |
| self.recall_conditioning = true; | |
| } | |
| pub fn set_embedder(&mut self, e: Box<dyn Embedder>) { | |
| self.embedder = e; | |
| } | |
| pub fn turn_text( | |
| &mut self, | |
| text: &str, | |
| input_ids: &[u32], | |
| gen_len: usize, | |
| ) -> Result<TurnResult> { | |
| let t0 = Instant::now(); | |
| let index = Bm25Index::rebuild(&self.memory); | |
| let recalled = index.recall_context(&self.memory, text); | |
| // Recall-conditioned generation (PRD step 1): once a real tokenizer is | |
| // attached, retrieved episodes prepend to the conditioning window. | |
| let mut eff_ids: Vec<u32> = input_ids.to_vec(); | |
| if self.recall_conditioning && !recalled.is_empty() { | |
| let ctx_text = recalled.join("\n"); | |
| let ctx_ids = self.tokenizer.encode(&ctx_text); | |
| let budget = self | |
| .student | |
| .cfg | |
| .max_seq_len | |
| .saturating_sub(input_ids.len() + gen_len + 8); | |
| let trimmed: Vec<u32> = ctx_ids | |
| .into_iter() | |
| .rev() | |
| .take(budget) | |
| .collect::<Vec<_>>() | |
| .into_iter() | |
| .rev() | |
| .collect(); | |
| eff_ids.splice(0..0, trimmed); | |
| } | |
| let est_tokens = text.split_whitespace().count(); | |
| let mut result = if est_tokens > GATE_TOKENS { | |
| self.turn_digest(text, &eff_ids, gen_len)? | |
| } else { | |
| let exp = | |
| Experience::with_text(eff_ids, vec![], vec![], text.to_string(), "user"); | |
| self.capture_and_route(exp, gen_len)? | |
| }; | |
| result.recalled_context = recalled; | |
| result.duration_ms = t0.elapsed().as_secs_f32() * 1000.0; | |
| Ok(result) | |
| } | |
| /// Digestion path (PRD section 4 pre-step): chew -> extract -> reduce -> | |
| /// validate each leaf -> commit trains on the compressed form. | |
| fn turn_digest(&mut self, text: &str, doc_ids: &[u32], _gen_len: usize) -> Result<TurnResult> { | |
| let doc = digestion::digest_document(text, self.tokenizer.as_ref(), self.embedder.as_ref()); | |
| let doc_ref = format!("d{}", self.step); | |
| for (leaf_id, vec) in doc.leaves.iter().zip(doc.leaf_vectors.iter()) { | |
| let _ = self.vector_index.add(&leaf_id.chunk_id, vec.clone()); | |
| } | |
| for (subj, rel, obj) in doc.root_triples(&doc_ref) { | |
| self.memory.semantic.add(crate::memory::Triple { | |
| subject: subj, | |
| relation: rel, | |
| object: obj, | |
| source_exp: doc_ref.to_string(), | |
| }); | |
| } | |
| let mut verdicts: Vec<(String, Verdict, f32)> = Vec::new(); | |
| let mut first_score: Option<TrustScore> = None; | |
| let mut first_verdict: Option<Verdict> = None; | |
| for exp in doc.experiences() { | |
| let score = self.judge.score(&exp); | |
| let verdict = score.verdict(); | |
| match verdict { | |
| Verdict::Commit => { | |
| for c in &exp.claims { | |
| self.memory.semantic.add(crate::memory::Triple { | |
| subject: format!("exp:{}", exp.id), | |
| relation: "claims".into(), | |
| object: c.clone(), | |
| source_exp: exp.id.clone(), | |
| }); | |
| } | |
| self.memory.episodic.record(exp.clone()); | |
| self.memory.replay.push(exp.clone()); | |
| } | |
| Verdict::Queue => { | |
| self.memory.ledger.push(exp.clone(), now_secs()); | |
| } | |
| Verdict::Reject => { | |
| log::info!("REJECT leaf {} (trust={:.3})", exp.id, score.total); | |
| } | |
| } | |
| if first_score.is_none() { | |
| first_score = Some(score.clone()); | |
| first_verdict = Some(verdict); | |
| } | |
| verdicts.push((exp.id, verdict, score.total)); | |
| } | |
| let _ = doc_ids; // conditioning ids reserved for BPE-tokenizer parity | |
| Ok(TurnResult { | |
| output_ids: Vec::new(), | |
| score: first_score.unwrap_or_default(), | |
| verdict: first_verdict.unwrap_or(Verdict::Reject), | |
| verdicts, | |
| confidence: 1.0, | |
| beam_used: false, | |
| recalled_context: Vec::new(), | |
| duration_ms: 0.0, | |
| revision: None, | |
| final_output_ids: Vec::new(), | |
| }) | |
| } | |
| // ------------------------------------------------------------------ | |
| // background trainer (step 4 continued): VALIDATED backlog only | |
| // ------------------------------------------------------------------ | |
| /// LoRA micro-steps against the committed replay backlog. Mutates ONLY | |
| /// the standby buffer, then publishes atomically. | |
| pub fn background_micro_steps(&mut self, n: usize) -> Result<Vec<f32>> { | |
| let sample: Vec<Experience> = { | |
| let picked = self.memory.replay.sample(n); | |
| picked.into_iter().cloned().collect() | |
| }; | |
| if sample.is_empty() { | |
| return Ok(vec![]); | |
| } | |
| let mut standby = self.adapters.standby_clone(); | |
| let mut losses = Vec::with_capacity(sample.len()); | |
| for exp in &sample { | |
| if let Some(&target) = exp.output.last() { | |
| let loss = | |
| self.student | |
| .train_step_on(&exp.input, target, &mut standby, self.lr)?; | |
| losses.push(loss); | |
| } | |
| } | |
| self.adapters.publish(standby); | |
| self.student.set_adapter(self.adapters.active()); | |
| Ok(losses) | |
| } | |
| // ------------------------------------------------------------------ | |
| // re-validation pass over queued items (verdict table: QUEUE) | |
| // ------------------------------------------------------------------ | |
| pub fn revalidate_queued(&mut self, k: usize) -> Result<usize> { | |
| let batch = self.memory.ledger.drain(k); | |
| let mut promoted = 0; | |
| for mut exp in batch { | |
| let score = self.judge.score(&exp); | |
| match score.verdict() { | |
| Verdict::Commit => { | |
| self.memory.episodic.record(exp.clone()); | |
| self.memory.replay.push(exp.clone()); | |
| promoted += 1; | |
| } | |
| Verdict::Queue => self.memory.ledger.push(exp, now_secs()), | |
| Verdict::Reject => { | |
| log::info!("REJECT on revalidation (trust={:.3})", score.total); | |
| } | |
| } | |
| } | |
| Ok(promoted) | |
| } | |
| // ------------------------------------------------------------------ | |
| // step 5: skill lifecycle | |
| // ------------------------------------------------------------------ | |
| pub fn observe_skill(&mut self, name: &str, success: bool) { | |
| self.memory.skills.observe(name, success, now_secs()); | |
| } | |
| /// Stale -> rehearsal due-list; rotten -> archived. Pure bookkeeping here; | |
| /// the serving layer schedules synthetic rehearsals for returned skills. | |
| pub fn skill_maintenance(&mut self) -> (Vec<String>, Vec<String>) { | |
| let now = now_secs(); | |
| let mut rehearse = Vec::new(); | |
| let mut rotten = Vec::new(); | |
| let names: Vec<String> = self.memory.skills.skills.keys().cloned().collect(); | |
| for name in names { | |
| let st = self.memory.skills.staleness(&name, now); | |
| if st > ROTTEN_SECONDS { | |
| rotten.push(name.clone()); | |
| } else if st > STALE_SECONDS { | |
| rehearse.push(name.clone()); | |
| } | |
| } | |
| for r in &rotten { | |
| self.archived_skills.push(r.clone()); | |
| self.memory.skills.skills.remove(r); | |
| } | |
| (rehearse, rotten) | |
| } | |
| fn emit(&self, kind: &str, v: serde_json::Value) { | |
| if let Some(f) = &self.event_sink { | |
| f(kind, &v); | |
| } | |
| } | |
| } | |
| fn now_secs() -> f64 { | |
| std::time::SystemTime::now() | |
| .duration_since(std::time::UNIX_EPOCH) | |
| .map(|d| d.as_secs_f64()) | |
| .unwrap_or(0.0) | |
| } | |
| mod tests { | |
| use super::*; | |
| use crate::lora::RANK; | |
| use crate::model::{MockJudge, SanConfig}; | |
| fn cfg() -> SanConfig { | |
| SanConfig { | |
| vocab: 64, | |
| d_model: 16, | |
| n_layers: 2, | |
| ffn_ratio: 2, | |
| n_heads: 2, | |
| max_seq_len: 32, | |
| tied_embeddings: true, | |
| } | |
| } | |
| fn eco() -> Ecosystem { | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| Ecosystem::new(student, Box::new(MockJudge), 64, 0.02) | |
| } | |
| fn reject_is_captured_but_never_replayed() { | |
| struct AlwaysReject; | |
| impl Judge for AlwaysReject { | |
| fn score(&self, _: &Experience) -> TrustScore { | |
| TrustScore::combine(0.0, 0.0, 0.0, 0.0, 0.0) | |
| } | |
| } | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(AlwaysReject), 64, 0.01); | |
| let r = e.turn(&[1, 2, 3, 4], 3).unwrap(); | |
| assert_eq!(r.verdict, Verdict::Reject); | |
| assert_eq!(e.memory.episodic.len(), 1, "captured immediately"); | |
| assert_eq!(e.memory.replay.items.len(), 0, "replay = committed only"); | |
| assert!(e.memory.ledger.is_empty()); | |
| } | |
| fn queue_lands_in_ledger_then_revalidates() { | |
| struct AlwaysQueue; | |
| impl Judge for AlwaysQueue { | |
| fn score(&self, _: &Experience) -> TrustScore { | |
| TrustScore::combine(0.5, 0.5, 0.5, 0.5, 0.5) // total .5 => QUEUE | |
| } | |
| } | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(AlwaysQueue), 64, 0.01); | |
| e.turn(&[5, 6, 7], 2).unwrap(); | |
| assert_eq!(e.memory.ledger.len(), 1); | |
| assert_eq!(e.memory.replay.items.len(), 0, "queue must NOT hit replay"); | |
| struct Promote; | |
| impl Judge for Promote { | |
| fn score(&self, _: &Experience) -> TrustScore { | |
| TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) // COMMIT | |
| } | |
| } | |
| e.judge = Box::new(Promote); | |
| let promoted = e.revalidate_queued(4).unwrap(); | |
| assert_eq!(promoted, 1); | |
| assert_eq!(e.memory.replay.items.len(), 1); | |
| assert!(e.memory.ledger.is_empty()); | |
| } | |
| fn commit_trains_only_the_adapter() { | |
| struct AlwaysCommit; | |
| impl Judge for AlwaysCommit { | |
| fn score(&self, _: &Experience) -> TrustScore { | |
| TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) | |
| } | |
| } | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(AlwaysCommit), 64, 0.05); | |
| let base_before = e.student.params["tok_emb.weight"].clone(); | |
| let ad_before = e.adapters.active().checksum(); | |
| e.turn(&[9, 8, 7, 6], 3).unwrap(); | |
| assert_eq!(e.memory.replay.items.len(), 1); | |
| let losses = e.background_micro_steps(4).unwrap(); | |
| assert!(!losses.is_empty()); | |
| assert_eq!( | |
| e.student.params["tok_emb.weight"], base_before, | |
| "base frozen" | |
| ); | |
| assert_ne!( | |
| e.adapters.active().checksum(), | |
| ad_before, | |
| "adapter trained + published" | |
| ); | |
| assert_eq!(e.adapters.active().param_count() > 0, true); | |
| let _ = RANK; | |
| } | |
| fn digestion_gate_chews_long_inputs() { | |
| let mut e = eco(); | |
| let short = "Short note about cats."; | |
| let r = e.turn_text(short, &[1, 2], 2).unwrap(); | |
| assert!(r.verdicts.len() <= 1, "short input bypasses digestion"); | |
| let filler = "The System implies stability because checks run first. Then set values. "; | |
| let long_doc = filler.repeat(60); // >> 256 words | |
| let r2 = e.turn_text(&long_doc, &[3, 4], 2).unwrap(); | |
| assert!(r2.verdicts.len() > 1, "long input must be chewed into leaves"); | |
| assert!( | |
| e.memory.semantic.triples.iter().any(|t| t.relation == "summarizes"), | |
| "ROOT cluster triples stored" | |
| ); | |
| } | |
| fn recall_surfaces_committed_history() { | |
| let mut e = eco(); | |
| e.turn_text("unique zebra crossing protocol", &[1, 2], 2).unwrap(); | |
| let r = e.turn_text("tell me about the zebra crossing", &[3, 4], 2).unwrap(); | |
| assert!( | |
| r.recalled_context.iter().any(|c| c.contains("zebra")), | |
| "BM25 recall must surface prior episode" | |
| ); | |
| } | |
| fn low_confidence_triggers_guided_beam() { | |
| struct PreferSeven; | |
| impl Judge for PreferSeven { | |
| fn score(&self, exp: &Experience) -> TrustScore { | |
| let hit = exp.output.iter().any(|&t| t % 11 == 7); | |
| TrustScore::combine(1.0, 1.0, if hit { 1.0 } else { 0.2 }, 1.0, 1.0) | |
| } | |
| } | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(PreferSeven), 16, 0.0); | |
| // direct guided call: whatever the init confidence, both paths must work | |
| let (_out, _used) = e.generate_guided(&[1, 2, 3], 4).unwrap(); | |
| let r = e.turn(&[4, 5, 6], 3).unwrap(); | |
| assert!((0.0..=1.0).contains(&r.confidence)); | |
| } | |
| fn skill_lifecycle_stale_and_rotten() { | |
| let mut e = eco(); | |
| e.observe_skill("search", true); | |
| // backdate by rewriting timestamp | |
| let old = now_secs() - (40.0 * 24.0 * 3600.0); | |
| e.memory.skills.skills.get_mut("search").unwrap().last_used_ts = old; | |
| let (rehearse, rotten) = e.skill_maintenance(); | |
| assert!(rotten.contains(&"search".to_string())); | |
| assert!(rehearse.is_empty()); | |
| assert!(e.archived_skills.contains(&"search".to_string())); | |
| assert!(!e.memory.skills.skills.contains_key("search")); | |
| } | |
| } | |
| mod screore_tests { | |
| use super::*; | |
| use crate::model::SanConfig; | |
| fn cfg() -> SanConfig { | |
| SanConfig { vocab: 64, d_model: 16, n_layers: 2, ffn_ratio: 2, n_heads: 2, | |
| max_seq_len: 32, tied_embeddings: true } | |
| } | |
| /// Bare prompts land in the QUEUE band; anything enriched with judge | |
| /// feedback / beam context (tokens beyond the tiny prompt alphabet) | |
| /// is COMMIT-grade. | |
| struct ImproveAfterFirst; | |
| impl Judge for ImproveAfterFirst { | |
| fn score(&self, e: &Experience) -> TrustScore { | |
| let bare = e.input.iter().all(|&t| t < 16); | |
| if e.text.starts_with("[revision") || !e.output.is_empty() && e.input.len() > 8 { | |
| TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) | |
| } else if bare && e.source == "user" { | |
| TrustScore::combine(0.5, 0.5, 0.5, 0.5, 0.5) // 0.50 QUEUE | |
| } else { | |
| TrustScore::combine(1.0, 1.0, 1.0, 1.0, 1.0) | |
| } | |
| } | |
| } | |
| fn revision_promotes_and_links_pair() { | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(ImproveAfterFirst), 64, 0.02); | |
| e.revisions_enabled = true; | |
| let r = e.turn(&[3, 1, 4], 4).unwrap(); | |
| assert!(r.revision.is_some(), "QUEUE must trigger a revision turn"); | |
| let rev = r.revision.unwrap(); | |
| assert_eq!(rev.first_trust, 0.5); | |
| assert!(rev.accepted); | |
| assert_eq!(e.sc_attempts, 1); | |
| assert_eq!(e.sc_hits, 1); | |
| // pair anchored in replay with lineage + advantage | |
| let items: Vec<&Experience> = e.memory.replay.items.iter().collect(); | |
| assert_eq!(items.len(), 2, "attempt-1 context + revision both trained on"); | |
| let child = items.iter().find(|x| x.parent_exp_id.is_some()).unwrap(); | |
| assert_eq!(child.advantage > 1.0, true); | |
| let parent_id = child.parent_exp_id.clone().unwrap(); | |
| assert!(items.iter().any(|x| x.id == parent_id)); | |
| assert!(!r.final_output_ids.is_empty() || !r.output_ids.is_empty()); | |
| } | |
| fn revisions_can_be_disabled() { | |
| struct AlwaysQueue; | |
| impl Judge for AlwaysQueue { | |
| fn score(&self, _: &Experience) -> TrustScore { | |
| TrustScore::combine(0.5,0.5,0.5,0.5,0.5) | |
| } | |
| } | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(AlwaysQueue), 64, 0.01); | |
| e.revisions_enabled = false; | |
| let r = e.turn(&[1, 2], 2).unwrap(); | |
| assert!(r.revision.is_none()); | |
| assert_eq!(e.sc_attempts, 0); | |
| assert_eq!(e.memory.replay.items.len(), 0, "still never replayed"); | |
| assert_eq!(e.memory.ledger.len(), 1); | |
| } | |
| fn advantage_scales_training_lr() { | |
| struct AlwaysCommit; | |
| impl Judge for AlwaysCommit { | |
| fn score(&self, _: &Experience) -> TrustScore { | |
| TrustScore::combine(1.0,1.0,1.0,1.0,1.0) | |
| } | |
| } | |
| let student = crate::main_helpers::random_student(&cfg()); | |
| let mut e = Ecosystem::new(student, Box::new(AlwaysCommit), 64, 0.05); | |
| let base_before = e.student.params["tok_emb.weight"].clone(); | |
| e.turn(&[7, 8, 9], 3).unwrap(); | |
| // two identical experiences, different advantages | |
| for adv in [2.0f32, 0.5f32] { | |
| let mut x = Experience::with_text(vec![11u32, 12], vec![13], vec![], "pair".into(), "s"); | |
| x.advantage = adv; | |
| e.memory.replay.push(x); | |
| } | |
| let losses = e.background_micro_steps(4).unwrap(); | |
| assert_eq!(losses.len(), 3); // 1 committed turn + 2 pair members; // replay had 1 committed + 2 pushed | |
| assert_eq!(e.student.params["tok_emb.weight"], base_before, "base frozen under weighted steps"); | |
| } | |
| } | |