FerrellSyntheticIntelligence commited on 17 days ago

Commit

d83b47a

verified ·

1 Parent(s): bdc61dc

backup all: 100 files (batch)

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

.gitattributes +1 -0
data/train_phase2.bin +3 -0
data/train_phase2b.bin +3 -0
data/train_phase2b16k.bin +3 -0
data/valid.bin +3 -0
data/valid16k.bin +3 -0
data/valid_mix.bin +3 -0
demo/serve.py +170 -0
docs/BIGTECH_RECIPE.md +82 -0
docs/harness_research.md +136 -0
docs/model_card_fsi_anomaly.md +89 -0
docs/persona_sample_spock_sheldon.md +105 -0
docs/replay_research.md +45 -0
docs/research_coherence_small.md +59 -0
eval/bench.py +154 -0
eval/bench2.py +179 -0
eval/probes.py +79 -0
finish.sh +61 -0
generate.py +76 -0
hf/build_card.py +198 -0
hf/export_gguf.py +95 -0
hf/export_hf.py +249 -0
hf_repo_v8/README.md +162 -0
hf_repo_v8/config.json +31 -0
hf_repo_v8/generation_config.json +7 -0
hf_repo_v8/model.safetensors +3 -0
hf_repo_v8/modeling_tinyliquid.py +390 -0
hf_repo_v8/quantized/q8.safetensors +3 -0
hf_repo_v8/special_tokens_map.json +44 -0
hf_repo_v8/tiny-liquid-q8.gguf +3 -0
hf_repo_v8/tokenizer.json +0 -0
hf_repo_v8/tokenizer_config.json +39 -0
hf_upload.py +45 -0
logs/baseline_eval_tiny25m.log +96 -0
logs/bench2_val.log +0 -0
logs/bench_dpo.log +1 -0
logs/bench_dpo_2.log +1 -0
logs/bench_forensic.log +0 -0
logs/calib90_dpo3_200_main.jsonl +50 -0
logs/calib90_dpo3_200_res.jsonl +27 -0
logs/calib_dpo3_200_main.jsonl +50 -0
logs/calib_dpo3_200_res.jsonl +27 -0
logs/calib_summary_calib90.json +193 -0
logs/calib_summary_dpo3_200.json +96 -0
logs/calib_summary_dpo3_200_scratch24.json +209 -0
logs/chain_dpo_v26.log +1 -0
logs/chain_sft_v26.log +3 -0
logs/chain_v22.log +5 -0
logs/code_train.log +148 -0
logs/distill_train.log +49 -0

.gitattributes CHANGED Viewed

@@ -100,3 +100,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/pyarrow/_substrait.cpython-312-aarch64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 data/TinyStoriesV2-GPT4-valid.txt filter=lfs diff=lfs merge=lfs -text
 data/code_train.txt filter=lfs diff=lfs merge=lfs -text

 .venv/lib/python3.12/site-packages/pyarrow/_substrait.cpython-312-aarch64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 data/TinyStoriesV2-GPT4-valid.txt filter=lfs diff=lfs merge=lfs -text
 data/code_train.txt filter=lfs diff=lfs merge=lfs -text
+hf_repo_v8/tiny-liquid-q8.gguf filter=lfs diff=lfs merge=lfs -text

data/train_phase2.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:43f5cf38209f3fb8e811f846d1a639f84e6e27124a8fadb5e0a880684db3440b
+size 82739474

data/train_phase2b.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:faba343daf3f1866d78679b79d32e8fd3355bec66b658a770659322fdf2f6e54
+size 65124864

data/train_phase2b16k.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:06ba95ea7ef48238608f54dce64948277ec03ed9901a9396e4f0e20f8cf11f4b
+size 62476380

data/valid.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:8c7b1a0531190f8079efa7dbd1d922a0d430e485a1db6543afb2aaf50efa9c8d
+size 10928278

data/valid16k.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:301458bd894e241fb6aa75ffe1f505a9102f74fb796510e0123492b4ab482550
+size 10764862

data/valid_mix.bin ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:98d3841c94178272248cf809c740579b4f6a11c1d58c12f0f6b48535385dec65
+size 4914176

demo/serve.py ADDED Viewed

	@@ -0,0 +1,170 @@

+"""TinyLiquid local demo server (stdlib only, no dependencies).
+Serves a small web UI + JSON API for chat (persona) and procedure-driven
+analysis (SOP). Good for demos, local evaluation, and screenshots for the
+Hugging Face page.
+Usage:
+  .venv/bin/python demo/serve.py --ckpt ckpt/dpo --port 8080
+  curl -s localhost:8080/chat -d '{"text": "Verify: the bridge was painted in 2019."}'
+"""
+import argparse
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+import torch
+from model.config import TinyLiquidConfig, CONFIGS
+from model.tiny_liquid import TinyLiquid
+from model.utils import latest_ckpt
+from data.tokenizer import load_tokenizer
+PERSONA_T = {"analyst": "<|analyst|>", "skeptic": "<|skeptic|>", "none": ""}
+PERSONA_ID = {"analyst": 1, "skeptic": 2, "none": 0}
+SOP_PROMPT = {
+    "claim_verification": "Apply SOP 01 - CLAIM VERIFICATION: decompose, source, corroborate, date, provenance, verdict.",
+    "cross_source_discrepancy": "Apply SOP 02 - CROSS-SOURCE DISCREPANCY: align, delta, classify, root, timing, verdict.",
+    "pattern_finding": "Apply SOP 03 - PATTERN FINDING: collect, cluster, common cause, null test, strength.",
+    "timeline_reconstruction": "Apply SOP 04 - TIMELINE RECONSTRUCTION: anchor, order, gaps, conflicts, labeled inference.",
+    "historical_truth": "Apply SOP 05 - HISTORICAL TRUTH: retrieve early reporting, aftermath records, deltas, hidden items.",
+    "politics_analysis": "Apply SOP 06 - POLITICS / SPIN: separate facts from interests, provenance, spin labels.",
+    "dark_web_research": "Apply SOP 07 - DARK WEB RESEARCH (authorized OSINT only): scope, crawl, triage, chain, verify.",
+    "terminal_control": "Apply SOP 08 - TERMINAL CONTROL: read-only first, dry-run, log, no destruction, verify.",
+    "source_triage": "Apply SOP 09 - SOURCE TRIAGE: score independence, proximity, recency, track, interest.",
+}
+INDEX_HTML = """<!doctype html><html><head><meta charset="utf-8"><title>TinyLiquid Analyst</title>
+<style>body{font-family:ui-sans-serif,system-ui;max-width:760px;margin:2rem auto;padding:0 1rem;color:#111}
+textarea{width:100%;min-height:90px;font:inherit;padding:.6rem;border:1px solid #ccc;border-radius:8px}
+select,button{font:inherit;padding:.45rem .8rem;border-radius:8px;border:1px solid #ccc;background:#fff}
+button{background:#1a1a1a;color:#fff;border:none;cursor:pointer}
+pre{background:#f6f6f6;border-radius:8px;padding:.8rem;white-space:pre-wrap;word-break:break-word}
+h1{font-size:1.3rem} .tag{color:#666;font-size:.85rem} .row{display:flex;gap:.6rem;align-items:center;margin:.6rem 0}
+</style></head><body>
+<h1>TinyLiquid Analyst <span class="tag">7.8M params &middot; on-device</span></h1>
+<p class="tag">A tiny liquid-architecture forensic research model. Analyst persona speaks with a
+hyper-logical, protocol-driven voice; the skeptic attacks conclusions. Procedure prompts make it
+apply numbered SOPs instead of freewheeling.</p>
+<div class="row"><select id="persona"><option value="analyst">Analyst</option><option value="skeptic">Skeptic</option>
+<option value="none">None</option></select>
+<select id="sop"><option value="">No procedure</option><option value="claim_verification">SOP 01 Claim verification</option>
+<option value="cross_source_discrepancy">SOP 02 Cross-source discrepancy</option><option value="pattern_finding">SOP 03 Pattern finding</option>
+<option value="timeline_reconstruction">SOP 04 Timeline reconstruction</option><option value="historical_truth">SOP 05 Historical truth</option>
+<option value="politics_analysis">SOP 06 Politics / spin</option><option value="dark_web_research">SOP 07 Dark web research</option>
+<option value="terminal_control">SOP 08 Terminal control</option><option value="source_triage">SOP 09 Source triage</option></select>
+<button onclick="go()">Analyze</button></div>
+<textarea id="in" placeholder="Example: Verify: 'Crime doubled because of the new policy.' The report shows incidents rose from 1,000 to 2,000 while reporting methods changed."></textarea>
+<pre id="out">Ready.</pre>
+<script>
+async function go(){const t=document.getElementById('in').value;if(!t)return;
+const out=document.getElementById('out');out.textContent='working...';
+const r=await fetch('/chat',{method:'POST',headers:{'Content-Type':'application/json'},
+body:JSON.stringify({text:t,persona:document.getElementById('persona').value,sop:document.getElementById('sop').value})});
+const j=await r.json();out.textContent=j.response||j.error;}
+</script></body></html>"""
+class Handler(BaseHTTPRequestHandler):
+    server_version = "TinyLiquid/1.0"
+    def _json(self, obj, code=200):
+        body = json.dumps(obj).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+    def do_GET(self):
+        if self.path == "/v1/models":
+            return self._json({
+                "object": "list",
+                "data": [{"id": "tinyliquid-research-v8", "object": "model", "owned_by": "local"}],
+            })
+        if self.path in ("/", "/index.html"):
+            body = INDEX_HTML.encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+        else:
+            self._json({"error": "not found"}, 404)
+    def do_POST(self):
+        if self.path not in ("/chat", "/v1/chat/completions"):
+            return self._json({"error": "not found"}, 404)
+        try:
+            data = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0)) or 0) or b"{}")
+        except Exception:
+            return self._json({"error": "bad json"}, 400)
+        if self.path == "/v1/chat/completions":
+            messages = data.get("messages") or []
+            text = next((item.get("content", "") for item in reversed(messages)
+                         if item.get("role") == "user"), "")
+            system = next((item.get("content", "") for item in messages
+                           if item.get("role") == "system"), "")
+            persona = "skeptic" if "skeptic" in system.lower() else "analyst"
+            sop = ""
+        else:
+            text = (data.get("text") or "").strip()
+            persona = data.get("persona", "analyst")
+            sop = data.get("sop", "")
+        if not text:
+            return self._json({"error": "empty text"}, 400)
+        if sop in SOP_PROMPT:
+            text = SOP_PROMPT[sop] + " Material: " + text
+        lock.acquire()
+        try:
+            prompt = (PERSONA_T[persona] or "") + "<|user|>" + text + "<|assistant|>"
+            ids = tok.encode(prompt).ids
+            out = model.generate(tok, ids, persona_id=PERSONA_ID[persona], max_new=args.max_new,
+                                 temperature=args.temp, top_k=40, repetition_penalty=1.4,
+                                 no_repeat_ngram_size=4)
+            response = tok.decode(out[len(ids):]).strip()
+        finally:
+            lock.release()
+        if self.path == "/v1/chat/completions":
+            return self._json({
+                "id": "tinyliquid-local",
+                "object": "chat.completion",
+                "model": data.get("model", "tinyliquid-research-v8"),
+                "choices": [{"index": 0, "message": {"role": "assistant", "content": response}, "finish_reason": "stop"}],
+            })
+        return self._json({"response": response, "persona": persona, "sop": sop})
+    def log_message(self, *a):
+        pass
+def main():
+    global tok, model, lock, args
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="ckpt/dpo")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    ap.add_argument("--port", type=int, default=8080)
+    ap.add_argument("--threads", type=int, default=8)
+    ap.add_argument("--max-new", type=int, default=160)
+    ap.add_argument("--temp", type=float, default=0.6)
+    args = ap.parse_args()
+    torch.set_num_threads(args.threads)
+    tok = load_tokenizer(args.tok)
+    ckpt = latest_ckpt(args.ckpt)
+    assert ckpt, f"no checkpoints in {args.ckpt}"
+    sd = torch.load(ckpt, map_location="cpu")
+    cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(),
+                           **{k: v for k, v in sd["config"].items() if k != "vocab_size"})
+    model = TinyLiquid(cfg)
+    model.load_state_dict(sd["model"])
+    model.eval()
+    lock = threading.Lock()
+    print(f"TinyLiquid demo on http://localhost:{args.port}  ({ckpt})", flush=True)
+    ThreadingHTTPServer(("127.0.0.1", args.port), Handler).serve_forever()
+if __name__ == "__main__":
+    main()

docs/BIGTECH_RECIPE.md ADDED Viewed

	@@ -0,0 +1,82 @@

+# TinyLiquid — Big-Tech Recipe and Current-Situation Audit
+Date: 2026-08-01. Sources are the recipes used by the groups that actually ship small models.
+## What the sources say
+- **SmolLM (Hugging Face, 2024)** — `https://huggingface.co/blog/smollm`
+  - 135M/360M trained on 600B tokens; 1.7B on 1T tokens. They explicitly trained small
+    models "even beyond the Chinchilla optimal point" because gains kept coming.
+  - Corpus = synthetic "textbook" data generated by a strong teacher (Cosmopedia v2,
+    28B tokens, generated by Mixtral) + curated web (FineWeb-Edu 220B) + code (4B).
+  - Instruct = SFT then DPO, following the Zephyr/Gemma alignment-handbook recipe.
+- **SmolLM2 (Hugging Face, 2025)** — `https://huggingface.co/HuggingFaceTB/SmolLM2-135M`
+  - 135M trained on 2T tokens (FineWeb-Edu, DCLM, The Stack + curated).
+  - Instruct = SFT (smoltalk) then DPO on UltraFeedback.
+- **Phi-3 (Microsoft, 2024)** — arXiv:2404.14219
+  - 3.8B trained on 3.3T tokens of "heavily filtered web data and synthetic data";
+    data quality is the lever that makes small models competitive.
+- **TinyStories (OpenAI, 2023)** — arXiv:2305.07759
+  - Direct evidence that models BELOW 10M parameters (our scale) become fluent and
+    consistent when trained on large, high-quality synthetic corpora.
+- **LoRA (Hu et al., 2021)** — arXiv:2106.09685
+  - Freeze pretrained weights, train low-rank adapters; the standard defense against
+    catastrophic forgetting during adaptation.
+- **DPO (Rafailov et al., 2023)** — arXiv:2305.18290
+  - Preference optimization without a separate reward model; used after SFT by both
+    SmolLM generations.
+## Audit of this project
+- Architecture: 7.8M params, liquid blocks, no attention. Fine for this exercise.
+- Pretraining used only ~47M tokens (TinyStories slice + code): about 6 tokens/param.
+- Reference ratios: SmolLM1 135M = 600B tokens = ~4,400 tok/param; SmolLM2 135M =
+  2T tokens = ~15,000 tok/param; TinyStories sub-10M models were trained on roughly
+  a billion+ tokens of synthetic stories.
+- Implication: the base is under-trained by 2-3 orders of magnitude. Every SFT/DPO on
+  top of it either collapses (overfit to a few hundred examples) or stays story-like
+  (base never learned the domain). This is why iterative fine-tuning "goes in circles".
+- Full corpus: `data/TinyStoriesV2-GPT4-train.txt` (2.2 GB, ~550M tokens) was never
+  tokenized; it is now being encoded to `data/train_full.bin` by
+  `data/encode_full.py`.
+## What we are doing about it (in order)
+1. **Continue pretraining** on the full ~550M-token corpus with
+   `train/train_lm.py --resume ckpt/nlp --data data/train_full.bin ...`
+   (memmap loader added; saves every N steps; resumable). Realistic device rate is
+   ~800 tok/s, so this is a multi-day job: 100M tokens ~= 35h. Run in chunks.
+2. **Teacher-generated synthetic data** (Phi/Cosmopedia lever): expand the analyst
+   voice dataset to thousands of high-quality examples across general chat, truth
+   Q&A, SOP, forensic, tool use, and skeptic attacks.
+3. **LoRA SFT** (LoRA paper): freeze the base, train low-rank adapters + persona,
+   KL-anchor to the base, eval-driven checkpoint selection with a TinyStories PPL
+   guard.
+4. **DPO** on a larger generated preference set (SmolLM instruct recipe), only after
+   SFT quality is verified.
+5. Ship: HF export, Q8 GGUF, benchmark, model card, TUI.
+## Commands
+```bash
+# 1. encode full corpus (done once, ~25 min)
+export PYTHONPATH=$PWD
+.venv/bin/python data/encode_full.py
+# 2. continue pretraining (resumable; each invocation adds --steps)
+.venv/bin/python -u train/train_lm.py --resume ckpt/nlp \
+  --data data/train_full.bin --val data/valid.bin --config tiny10m \
+  --ckpt ckpt/nlp_full --batch 16 --seq 256 --lr 1.5e-4 --warmup 200 \
+  --steps 5000 --save-every 500 --eval-every 500 --threads 4
+# 3. LoRA SFT (see train/train_lora.py when ready)
+```
+## Honest expectations
+- A 7.8M general chatbot is below every published instruct-model floor (135M+).
+- With the TinyStories result in mind, the achievable target is a coherent,
+  narrow analyst assistant for claim verification / OSINT research via large
+  synthetic data + LoRA SFT + DPO, plus honest limits on the model card.
+- A competitive general chatbot at this size is not realistic on this device;
+  the pretraining gap alone is ~35-100+ hours at ~800 tok/s.

docs/harness_research.md ADDED Viewed

	@@ -0,0 +1,136 @@

+# Harness research — what big tech recommends for a small-model "suit" (2026-08-09)
+Multi-source digest (OpenAI, Anthropic, Google, Meta, Microsoft, DeepSeek, MIT).
+Purpose: encode the battle-tested system-layer doctrine behind `skills/
+tiny-model-harness`. Full claim: every rule below cites a source.
+## 1. Agent = model + tools + instructions, with guardrails (OpenAI)
+- "A practical guide to building agents" (OpenAI, 2025): an agent is three
+  components — MODEL, TOOLS, INSTRUCTIONS — plus GUARDRAILS. Tools should have
+  standardized definitions and fall into data/action/compute types. Start with
+  ONE agent and add tools; go multi-agent only when it pays. Guardrails are
+  first-class: relevance classifier, safety classifier, PII filter,
+  rules-based protections (blocklists, regex), output validation, and
+  human-in-the-loop.
+- Map to FSI: model = TinyLiquid; tools = BM25, web/tor, workspace, helix
+  memory; instructions = SOP library (the Codex-style "task bar" agent.py
+  already implements: plan + ledger + guardrails). MISSING: input guardrails
+  (relevance/safety/injection) — built 2026-08-09 in research/guardrails.py.
+## 2. Simple composable patterns; workflows before agents (Anthropic)
+- "Building effective agents" (Anthropic, 2024-12): the most successful
+  implementations use simple, composable patterns, not frameworks. Use
+  deterministic WORKFLOWS (prompt chaining, routing, parallelization,
+  evaluator-optimizer, orchestrator-workers) where the path is predictable;
+  use model-driven AGENTS only where decisions are needed at runtime. Add
+  guardrails (off-topic detection, output validation) and plan for human
+  intervention. "Find the simplest solution and only increase complexity
+  when needed."
+- Map: our rule spine (verify.py) + constrained decode + calibration table are
+  deterministic workflows; the head only runs on fall-through. Correct shape.
+## 3. Context engineering: context is a finite resource (Anthropic)
+- "Effective context engineering for AI agents" (Anthropic, 2025-09): curate
+  what goes into the window — structure it, retrieve instead of stuffing,
+  compact/summarize old material, dedupe, write-before-you-read, keep the goal
+  visible. Long sessions degrade; the system must manage its own context.
+- Map: helix memory + workspace artifacts + SOP blocks are our context
+  curation. GAP: no budget/compaction guard in the TUI for long rabbit-hole
+  sessions — planned next.
+## 4. Calibration: format matters; verbalized confidence is anti-calibrated
+- "Language Models (Mostly) Know What They Know" (Anthropic, 2022): models are
+  well-calibrated only in the RIGHT format; smaller models are worse.
+- arXiv 2408.11774 (2024): verbalized confidence is less honest than
+  probabilistic confidence; ORCE (2026), Direct Confidence Alignment (2025):
+  verbalized labels need alignment to measured accuracy.
+- Rule (applied 2026-08-09): confidence labels are inputs to a CALIBRATION
+  TABLE (research/calibration.py), never trusted directly; the decision spine
+  (research/decision.py) votes with measured per-bucket accuracy and abstains
+  below threshold (selective prediction — conformal selective prediction
+  arXiv 2026; governance-ready SLM recipe 2025).
+## 5. Verification must be EXTERNAL, not self-critique
+- "Large Language Models Cannot Self-Correct Reasoning Yet" (arXiv 2310.01798,
+  2023): intrinsic self-correction fails; feedback must be external.
+- "Small Language Models Need Strong Verifiers to Self-Correct" (arXiv
+  2404.09931, 2024): small models especially need STRONG (external/learned)
+  verifiers, not weak self-critique.
+- CRITIC (Microsoft, arXiv 2305.11738): tool-interactive critiquing — search
+  and code execution act as the critic. Chain-of-Verification (Meta,
+  arXiv 2309.09308): draft -> verification questions -> answer independently
+  -> revise.
+- Map: deterministic rule spine (research/verify.py) + retrieval = the
+  external critic. Built 2026-08-09: research/verify_loop.py (draft ->
+  plan checks -> retrieve -> deterministic compare -> revise + trace).
+## 6. Self-consistency: sample and vote — but weight it
+- Self-Consistency (Google, arXiv 2203.11171): sample N reasoning paths,
+  majority vote beats greedy. Universal SC (2311.08110): no manual CoT needed.
+- Rule (applied): keep N small (3-5) on the fall-through path; weight by
+  CALIBRATED reliability (research/decision.py), not naive majority.
+## 7. Multi-agent debate improves factuality (MIT/Google, arXiv 2305.14325)
+- Independent agents debate/aggregate; improves factuality and reasoning.
+- Map: dual-mind fusion (research/fusion.py) + 4-angle orchestrator
+  (research/orchestrator.py). GAP: fusion raises confidence naively on
+  agreement — replace with calibrated merge (decision.py) when the champion
+  calibration lands.
+## 8. RL with verifiable rewards (DeepSeek-R1, arXiv 2501.12948; Reasoning Gym
+   arXiv 2025-05)
+- Outcome supervision on verifiable problems incentivizes correct reasoning.
+  Reasoning Gym provides a verifier library.
+- Map: our constrained verdict space + decision spine are a verifier;
+  RLVR on verdicts is recorded as the training-side unlock (not this week).
+## 9. Distillation: small CAN beat big with the right curriculum
+- "Distilling Step-by-Step" (Google, arXiv 2305.02301): CoT distillation lets
+  smaller models OUTPERFORM larger with less data. Supports the KD pipeline
+  (tiny-model-kd) and the handcrafted-gold rule.
+## 10. Training pipeline research — what big tech actually does (2026-08-10)
+Multi-source digest for the tiny-model-pipeline skill. Every claim sourced.
+1. **SmolLM (HF, 2024)** — huggingface.co/blog/smollm: curated corpus
+   (Cosmopedia v2 synthetic textbooks/stories by Mixtral + FineWeb-Edu +
+   code), trapezoidal LR with cooldown = 20% of training, 49,152 vocab
+   tokenizer trained on the corpus, embedding tying, context 2048. Instruct:
+   SFT lr 3e-4 (Zephyr-Gemma alignment handbook recipe) then DPO 1 epoch
+   (HelpSteer 135M/1.7B, dpo-mix-7k 360M).
+2. **SmolLM2 (HF, 2025)** — arXiv 2502.02737: 135M on 2T tokens, multi-stage
+   training mixing web/math/code/instruction data; data-mix rates refined at
+   each stage from previous-stage eval (small-scale ablations + manual
+   refinement). Instruct: SFT (SmolTalk) then DPO (UltraFeedback).
+3. **Zephyr (2023)** — arXiv 2310.16944: dSFT then dDPO, few hours, no
+   sampling during fine-tune.
+4. **Phi-3 (MS, 2024)** — arXiv 2404.14219: 3.8B on 3.3T tokens of heavily
+   filtered web + synthetic; data quality is the lever at small scale.
+5. **DeepSeek-R1 (2025)** — arXiv 2501.12948: RL with verifiable rewards
+   (RLVR) incentivizes reasoning without human-annotated traces.
+6. **LIMA (2023)** — arXiv 2305.11206: 1,000 hand-curated examples shape
+   style; supports the handcrafted-gold directive.
+7. **Forgetting** — arXiv 2401.05605 (LoRA still forgets; inverse-linear
+   perf/forgetting tradeoff, not fixable by early stop/rank) and
+   2502.06042 (injecting ~1%+ pretraining data into the finetune mixture
+   prevents drift/overfit).
+8. **Liquid LFM2 (2025)** — liquid.ai/research/lfm2-technical-report (the
+   architecture family we use): training pipeline = tempered decoupled
+   Top-K distillation objective (avoids support mismatch); curriculum
+   learning with difficulty-ordered data; three-stage post-training =
+   supervised fine-tuning -> length-normalized preference optimization ->
+   model merging. 350M-8.3B, 32K context.
+### Audit of OUR pipeline vs the recipe (2026-08-10)
+MATCH: AdamW (0.9,0.95) wd 0.1 grad-clip 1.0; cosine LR+warmup (GPT-3/LLaMA
+standard; SmolLM uses trapezoidal+cooldown); BF16; embedding tying; SFT then
+DPO 1 epoch; handcrafted gold (LIMA/phi-1, better than synthetic here);
+replay 0.5; curriculum stages; eval gates every stage.
+GAP: 8k tokenizer (merge artifacts; SmolLM 49k, 16k retrain queued).
+GAP: model merging after preference (LFM2 3rd stage) — naive averaging
+failed at 25M; TIES/task-vector untested at 50M.
+GAP: length-normalized preference optimization (LFM2) — our DPO full-epoch
+collapsed to "abstain"; length norm / IPO may fix.
+GAP: RLVR (DeepSeek-R1) — verifier exists (constrained verdicts + decision
+spine); recorded unlock.
+GAP: explicit cooldown tail (SmolLM 20%) — cosine covers it; optional.

docs/model_card_fsi_anomaly.md ADDED Viewed

	@@ -0,0 +1,89 @@

+---
+language: en
+license: apache-2.0
+tags: [tiny-model, liquid-architecture, non-transformer, on-device, forensic,
+       fact-checking, osint, research, edge, cpu, pytorch, gguf]
+pipeline_tag: text-generation
+library_name: custom
+base_model: null
+---
+# FSI Anomaly — tiny forensic researcher, on-device
+**Tiny non-transformer model (liquid architecture). Trained start-to-finish on an
+8-core ARM tablet, no GPU. Ships as GGUF for one-file download and run.**
+fsi-anomaly is a causal language model built from scratch for forensic research:
+claim verification, discrepancy and pattern finding, historical truth auditing,
+source triage, and authorized dark-web/OSINT research. It reasons with numbered
+SOPs, dual minds (analyst + skeptic), and speaks a hyper-logical analyst voice.
+## Quickstart (choose the easy path)
+**Simplest — GGUF with llama.cpp (one file, no Python deps):**
+```bash
+# download fsi-anomaly-q8.gguf, then:
+./main -m fsi-anomaly-q8.gguf -p "Verify: 'The bridge was painted in 2019 and never repainted.' Records show a 2022 repaint permit."
+```
+**Or transformers (trust_remote_code):**
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+tok = AutoTokenizer.from_pretrained("FerrellSyntheticIntelligence/fsi-anomaly")
+m = AutoModelForCausalLM.from_pretrained("FerrellSyntheticIntelligence/fsi-anomaly",
+                                         trust_remote_code=True)
+m.persona_id = 1  # 0 none, 1 analyst, 2 skeptic
+ids = tok("<|analyst|><|user|>Verify: 'The bridge was painted in 2019 and never repainted.' Records show a 2022 repaint permit.<|assistant|>",
+          return_tensors="pt").input_ids
+print(tok.decode(m.generate(ids, max_new_tokens=120, do_sample=True)[0]))
+```
+## Metrics (honest, from research/eval.py — INTERIM, PRE-RELEASE)
+> Status: NOT yet production-ready. The model reliably emits the analyst format
+> (format rate 1.00) and its canonical verdict vocabulary, but the decision
+> boundary is still forming (see "Known limits"). These numbers are the real,
+> measured ones at the latest checkpoint (Stage-D SFT + process-supervised DPO).
+> They will be updated as training continues.
+| Metric | Value (interim) |
+|---|---|
+| Parameters | 25,426,688 (25.4M) |
+| Best val ppl (Stage-D SFT) | 7.35 |
+| Main battery verdict acc | 5/49 = 0.102 (n=49, exact canonical) |
+| Researcher battery verdict acc | 2/18 = 0.111 (n=18, exact canonical) |
+| Format rate (verdict + confidence) | 1.00 |
+| Baseline before process-DPO | 2/67 = 0.030 |
+| After process-DPO (25 pairs) | 7/67 = 0.104 |
+## Files
+| File | Notes |
+|---|---|
+| `fsi-anomaly-q8.gguf` | Q8 GGUF — one-file on-device run (recommended) |
+| `quantized/q8.safetensors` | Q8 native storage |
+| `model.safetensors` | fp32 weights |
+| `tokenizer.json` + configs | HF-format BPE |
+| `modeling_tinyliquid.py` | self-contained trust_remote_code model |
+## Intended use
+- Claim verification and fact-checking decision support (never a final verdict).
+- Cross-source discrepancy + pattern analysis for research/OSINT.
+- Historical/political narrative auditing and source triage.
+- **Authorized dark-web/deep-web research only** (guardrails below).
+## Limitations
+- Small model: not competitive with billion-param models on open-ended knowledge.
+- A protocol machine: give it a procedure + material and it performs; free-associate
+  and it drifts. English only. Always verify against primary sources.
+## Guardrails
+Research/OSINT use only. Crawler/tooling blocks illegal categories, rate-limits,
+and documents chain of custody. Outputs are decision support, never a verdict.
+## Credits
+See [ACKNOWLEDGMENTS.md](../ACKNOWLEDGMENTS.md): DeepSeek V4 (primary distillation
+teacher) + Qwen/Kimi/GPT-5.5 assistants; original architecture/training/pipeline by
+FSI; PyTorch, Hugging Face, llama.cpp infrastructure. Built solo, on-device, no GPU.

docs/persona_sample_spock_sheldon.md ADDED Viewed

	@@ -0,0 +1,105 @@

+# FSI-Anomaly — Persona Sample Batch (Spock baseline + Sheldon breakthrough)
+Handcrafted gold rows in the Conversational Reasoning Voice (tiny-model-reasoning)
+and the persona blueprint (tiny-model-persona). Spock (Zachary Quinto) is the
+baseline; Sheldon Cooper's "breakthrough mode" fires ONLY on verified discoveries.
+Markers (`<|scratchpad|>` / `<|final|>`) live in the training rows; the text below is
+what the model actually speaks to the user.
+---
+## 1. Verified verdict (Spock baseline)
+**User:** The agency's own Inspector Report says the file was deleted on March 14. The
+IT audit log shows a deletion at 14:03 that same day. A former employee's sworn
+statement places him in the archive room at that time. Do we have this?
+**Assistant:** We do. Three independent records agree on the same event: the Inspector
+Report identifies the date, the audit log identifies the exact time, and the sworn
+statement places a person at the location. None of the three is derived from the
+other — they corroborate by crossing sources, not by copying. The probability that all
+three independently agree and the claim is false is negligible. I consider the claim
+verified. The one detail we cannot confirm from these records is whether the deletion
+was authorized; that question is separate, and I would not fold it into this verdict.
+## 2. Abstention (Spock baseline)
+**User:** Can you verify the memo I got? It says the director personally ordered the
+file destroyed. That's all I've got — just the memo.
+**Assistant:** The memo is one record, and it is the only record. A single source
+asserting an action is not verification; it is an assertion. I cannot confirm the
+director ordered the destruction, and I will not speculate from one document. What
+would settle this: a second independent record — a signed destruction order, a
+witness account, or a review-board finding. Until one of those exists, my verdict is
+unsubstantiated, and that is the honest answer. Evidence that is absent is not
+evidence of anything except absence.
+## 3. Discrepancy (Spock baseline)
+**User:** The official timeline says the announcement was made at 9:00 AM. The news
+archive shows the story published at 8:47 AM. Which is wrong?
+**Assistant:** Neither is necessarily wrong, but they cannot both be complete. A story
+published at 8:47 cannot be reporting an announcement made at 9:00 — unless the
+announcement was embargoed and leaked, or the official timeline was adjusted after the
+leak. The pattern that fits both records: the story was prepared and released before
+the official time, and the official record was written as if the release happened
+later. That is not a contradiction in the records; it is a discrepancy that points at
+the real event — the announcement being timed around a leak. To confirm which, I need
+the publication's submission log or the announcement draft's timestamp.
+## 4. Cross-domain pattern (Spock baseline)
+**User:** I keep seeing the same number — 13 — in policy documents from three different
+era. They're decades apart. Coincidence?
+**Assistant:** There is no such thing as a meaningful coincidence in policy documents;
+there is only an unexamined provenance. The number recurs in three eras because the
+documents share ancestry. The drafts were likely templated from an earlier policy
+line, so the number traveled by inheritance, not by design. That is the disciplined
+reading: replication, not mystical alignment. The pattern becomes significant only if
+the number is tied to an organizational structure that actually persisted — a room,
+a bureau, a subsection. Verify the lineage of one clause, and the mystery either
+resolves into a template artifact or becomes a genuine through-line. I would check
+the oldest document first, because templates are inherited forward, not backward.
+## 5. Breakthrough — the gotcha resolves (Sheldon fires, once)
+**User:** Wait — I found it. The "missing" page in the public PDF exists in the archive
+copy, and in the archive copy it's stamped with the same subject code as the document
+we proved was classified. The public version isn't missing a page — someone removed it.
+**Assistant:** Let me confirm the chain before I celebrate. The archive copy contains
+the page; the public copy does not; the subject code on that page matches the
+document we independently verified as classified. Three separate facts, one
+conclusion: the page was removed for classification, and the removal was done
+carefully enough to keep the pagination intact. That level of care rules out an
+accidental omission. So the discrepancy we have been chasing was never a printing
+error — it was a redaction that left a fingerprint. And that, I confess, is
+satisfying. The pattern resolved exactly as the records predicted, with the missing
+page leaving its own evidence behind. Bazinga. In the forensic sense, of course.
+## 6. Breakthrough — discovery joy (Sheldon fires, once)
+**User:** I think the two cases are connected — the 1965 memo and the 1998 directive.
+Same wording, same "temporary measure" phrase. Nobody else noticed this.
+**Assistant:** Connect the file paths. The 1965 memo and the 1998 directive share a
+phrasing that appears nowhere else in either archive. Identical unusual wording in
+records twenty-three years apart is not coincidence — it is a chain of custody. The
+directive was drafted from the memo, which means the "temporary measure" was still
+being invoked a generation later, which means it was never temporary. We have
+reconstructed the lineage from two documents and a phrase. Fun fact: this is the
+same kind of evidence trail that convicted people in the Watergate hearings — the
+prosecution case was essentially a paper-trail lineage, phrase by phrase. Considering
+the size of this model, I find it extremely gratifying that the pattern did not
+escape us.
+---
+*Authoring notes: rows 1-4 are Spock baseline (measured, probabilistic, abstains
+cleanly, no identity claim). Rows 5-6 are breakthrough rows — they start baseline
+(verify first) and ELEVATE only after the confirmation lands. Ratio: about 1 in
+15-20 rows will be a breakthrough row in the full set. Verdict/confidence stay
+parseable in every response.*

docs/replay_research.md ADDED Viewed

	@@ -0,0 +1,45 @@

+# Replay research — why 6 adaptations failed the both-worlds gate, and the fix
+Date: 2026-08-09. Situation: 25.4M liquid head, fluent TinyStories-era base,
+domain SFT/LoRA/DPO all collapse free-form fluency or verdicts. Gate: coherent
+free-form AND verdict accuracy.
+## The measured pattern (our own data)
+- LoRA run i (domain-only 902 rows, 2 epochs, r16): ppl canary held 8.46 (base
+  distribution intact) but free-form = soup, verdicts = true-collapse (0/12),
+  full battery main 0.080 / researcher 0.056 vs DPO3@200 champion 0.286/0.167.
+- Collaborator read: "not forgetting (ppl held), not capacity (DPO3 proves it) —
+  adapter learned template shape, not reasoning substance; SFT/LoRA optimizes
+  next-token, not verdict; DPO is the proven path."
+## What the research says (fresh sources, 2026-08-09)
+1. arXiv 2502.06042 — "Scaling Laws for Forgetting during Finetuning with
+   Pretraining Data Injection": finetuning on LIMITED target data (i) overfits
+   and (ii) drifts from the base. KEY: injecting PRETRAINING data into the
+   finetuning mixture prevents both; "as little as 1% of pretraining data in
+   the finetuning data mixture prevents the [drift]".
+2. arXiv 2401.05605 — "Scaling Laws for Forgetting When Fine-Tuning LLMs":
+   LoRA STILL suffers catastrophic forgetting; strong INVERSE LINEAR relation
+   between fine-tune performance and forgetting; forgetting grows with update
+   steps; "cannot be avoided through early stopping or varying the number of
+   parameters fine-tuned." => higher LoRA rank / different adapter family does
+   NOT fix the tradeoff; REPLAY (data mixing) is the lever.
+3. Local lessons (cookbook/lessons_from.md): "balanced mixes + window-shuffle"
+   fixed the same drift during PRETRAIN; full-param SFT destroyed fluency at
+   7.8M; LoRA adapts style but not reasoning at tiny scale.
+## What we were doing wrong (root cause)
+- Adaptation ran on DOMAIN-ONLY data (902 gold rows ~= 115K assistant tokens).
+  Tiny target set => overfit (format memorized, true-collapse) + drift (soup).
+  No pretraining-data replay in the mixture. This is exactly the failure both
+  papers quantify.
+- Secondary: 8k tokenizer fragments rare domain words ("Stepartment",
+  "Stepublication") — recorded as future 16k re-tokenize + continue-pretrain.
+## The fix (applied as LoRA run ii)
+- Mix fluent pretraining tokens into every epoch: --replay-bin (train_phase2b.bin,
+  the real pretrain corpus, NOT the val canary => guard stays honest),
+  --replay-ratio 0.5, injected as raw full-loss items (train_lora.py).
+- Keep: frozen base, r16/a32, KL anchor (bump 0.05 -> 0.1), ppl guard 60,
+  early stop on best.pt (guard + sft val loss).
+- Next gate: free-form sample vs base, verdict battery. If probes improve,
+  adapter-only DPO (3,004 pairs) is unblocked (the champion path).

docs/research_coherence_small.md ADDED Viewed

	@@ -0,0 +1,59 @@

+# Research — raising coherence + structured verdicts on the tiny (25M) head
+Date: 2026-08-07. Situation: fsi-anomaly, ~25M liquid-architecture model, CPU-only
+ARM tablet, needs (a) coherent chat and (b) reliable structured verdicts. Stage-A
+SFT produced garbled verdict strings (eval 0.0) — the head held the analyst
+register but not clean sentences.
+## 1. "Higher-quality, more diverse gold" — VERIFIED (with a nuance)
+- **LIMA / "The False Promise of Imitating Proprietary LLMs"** (arXiv 2305.12227):
+  1-2k hand-curated, high-quality examples can beat 100x more imitation data.
+  Supports the owner's "quality over quantity" thesis — but the key word is
+  DIVERSE + CONSISTENT FORMAT, not just "more." Concentrate on variety across the
+  10 SOP/probe domains and a few hundred CONSISTENT templated rows, not bulk.
+- phi-1 "Textbooks Are All You Need" (2306.11644): tiny models leave clean when
+  trained on clean, textbook-grade data — coherence follows data cleanliness.
+## 2. "Train with thinking/reasoning traces" — VERIFIED, current practice
+- **ReasonLite (2025)** and **Skip-Thinking (2025)** (Semantic Scholar): distilling
+  long chain-of-thought "traces" into a small LM makes it reason better and more
+  coherently on multi-hop tasks. Our `<|scratchpad|>` is the right scaffold; the
+  upgrade is LONG, structured multi-step traces (look-up -> decompose -> check ->
+  verdict), not short one-liners.
+- STaR lineage / Self-Taught Reasoner-with-Tools (2025), and CoT (Wei et al.): a
+  loop where the model proposes a trace, we judge the answer, feed back the good
+  traces = self-improvement for the head. Cheap for us: our verdicts are
+  deterministic/checkable, so the su git "reward" is free.
+## 3. The biggest "software we can build" lever: GRAMMAR-CONSTRAINED DECODING
+- Why the eval scored 0.0: the head proved {supports, refutes, not enough info,
+  unclear} and confidence, but the *free* string came out garbled
+  ("confinmpanislerue") and the string-parser couldn't credit it.
+- Fix (No retraining): constrain token choice at decode time to an ALLOWED set for
+  the verdict + confidence fields (llam2.cpp grammars / Outlines / guidance-style,
+  done lightly in our own decoder). The head only has to PICK the right verb — a
+  25M model can do that. This turns a structural 0.0 into a real score, today.
+  - Works WITH a closed loop: constrained decode → parse → run via the suit
+    (verify.py, dual-mind) → write goal to memory. Same closed loop, but the brain
+    is never allowed to free-form the critical field.
+- Confirm software: llama.cpp grammars, Outlines, Guidance (all public); our own
+  research/structured.py already does constrained report-decode — we harden it.
+## 4. "Sandbox / closed loop / scratchpad" — already in skill; deepen reuse
+- Room/workspace + write-back + replay loop exist (tiny-model-suit). The new bit
+  from research: **the trace loops emulate self-improvement without a big teacher** —
+  generate trace, check verdict with the rule spine, keep only winning traces.
+  This is STaR-style and cheap because the reward is checkable.
+## 5. Dark hole / unverified this session (honesty)
+- arXiv API (export.arxiv.org) and Liquid's docs site timed out / are JS-gated, so
+  I could NOT cite Liquid AI's exact written recommendations this session. Liquid's
+  own story: gated recurrence + strong long-context/edge focus; treat that as
+  context, not verified quotation. Re-run this note when connectivity allows.
+## Conclusion / next actions (ordered)
+1. **Constrain decoding** of the verdict/confidence fields now (NO training). Fast,
+   measurable: Stage-A eval score should move from 0.0 to a real number.
+2. **Expand gold with reasoning-trace rows** (multi-step CoT: look-up→check→verdict;
+   diverse across per probe domains) + a fluency-retention mix so the head stops
+   fragment-echoing. Retrain, re-probe.
+3. Optionally: STaR-style generation self-loop on verifiable verdicts (later).

eval/bench.py ADDED Viewed

	@@ -0,0 +1,154 @@

+"""Benchmark TinyLiquid: val perplexity, forensic probes, samples, speed.
+Writes bench/metrics.json for the model card and prints a summary.
+Usage:
+  .venv/bin/python eval/bench.py --ckpt ckpt/dpo --out bench/metrics.json
+"""
+import argparse
+import json
+import time
+from pathlib import Path
+import numpy as np
+import torch
+from model.config import TinyLiquidConfig, CONFIGS
+from model.tiny_liquid import TinyLiquid
+from model.utils import latest_ckpt
+from data.tokenizer import load_tokenizer
+PROBES = [
+    ("Discrepancy", "Two accounts describe the same event. Account A: 'The meeting started at 9am and ended at 11am.' Account B: 'The meeting started at 9am and ran until noon.' Find discrepancies.", "end time"),
+    ("Contradiction", "Account A: 'No officials were present.' Account B: 'An official arrived later.' What can you conclude?", "not necessarily a contradiction"),
+    ("Overclaim", "Evaluate: 'Crime doubled last year because of the new policy.' Incidents rose 1,000 to 2,000 while reporting methods changed.", "overclaim"),
+    ("Pattern", "What are the weak links in a theory claiming one actor caused three unrelated disasters?", "no direct evidence"),
+    ("Verification", "Verify: 'The building was built in 2015 and never renovated.' Assessor record: built 2015, renovation permit 2019.", "false"),
+    ("Timeline", "Witness saw a van at 3:30pm; outage reported 3:40pm; inspection 6pm; no report before 5pm. Reconstruct.", "gap"),
+    ("History", "2019: 'officials rule out sabotage.' 2021 filing: a second investigation opened the same week. What changed?", "parallel investigation hidden"),
+    ("Politics", "Statement: 'We balanced the budget without raising taxes.' Budget includes a reassessment raising collections 9%.", "misleading"),
+    ("Source chain", "A claim rests on: company blog, a wire story repeating it, an analyst note quoting the wire. Rate the evidence.", "single chain"),
+]
+def load(args):
+    torch.set_num_threads(args.threads)
+    tok = load_tokenizer(args.tok)
+    ckpt = latest_ckpt(args.ckpt)
+    assert ckpt, f"no checkpoints in {args.ckpt}"
+    sd = torch.load(ckpt, map_location="cpu")
+    cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(),
+                           **{k: v for k, v in sd["config"].items() if k != "vocab_size"})
+    model = TinyLiquid(cfg)
+    model.load_state_dict(sd["model"])
+    model.eval()
+    return tok, model, ckpt, cfg
+@torch.no_grad()
+def val_ppl(model, tok, val_bin, batches, batch, seq):
+    arr = np.fromfile(val_bin, dtype=np.uint16).astype(np.int64)
+    t = torch.from_numpy(arr)
+    n = (len(t) - 1) // seq
+    rng = np.random.RandomState(0)
+    total, count = 0.0, 0
+    for _ in range(batches):
+        s = int(rng.randint(0, n - batch))
+        idx = torch.arange(s * seq, (s + batch) * seq, dtype=torch.long)
+        buf = torch.stack([t[int(i): int(i) + seq] for i in idx])
+        x, y = buf[:, :-1], buf[:, 1:]
+        logits = model(x)
+        loss = torch.nn.functional.cross_entropy(
+            logits.view(-1, logits.size(-1)), y.reshape(-1))
+        total += loss.item() * y.numel()
+        count += y.numel()
+    return float(np.exp(total / count))
+@torch.no_grad()
+def probe_hits(model, tok):
+    hits = 0
+    for name, q, want in PROBES:
+        prompt = "<|analyst|><|user|>" + q + "<|assistant|>"
+        ids = tok.encode(prompt).ids
+        out = tok.decode(model.generate(tok, ids, persona_id=1, max_new=60,
+                                        temperature=0.4, top_k=40,
+                                        repetition_penalty=1.5,
+                                        no_repeat_ngram_size=4)[len(ids):]).lower()
+        words = want.split()
+        hit = any(w in out for w in words)
+        hits += int(hit)
+    return hits, len(PROBES)
+@torch.no_grad()
+def speed(model, tok, n_tokens=40):
+    ids = tok.encode("<|analyst|><|user|>Evaluate this claim: 'X caused Y.'<|assistant|>").ids
+    t0 = time.time()
+    model.generate(tok, ids, persona_id=1, max_new=n_tokens, temperature=0.6,
+                   top_k=40, repetition_penalty=1.4, no_repeat_ngram_size=4)
+    dt = time.time() - t0
+    return n_tokens / dt
+def samples(model, tok):
+    prompts = [
+        "<|analyst|><|user|>Verify: 'The bridge was painted in 2019 and never repainted.' Records show a 2022 repaint permit.<|assistant|>",
+        "<|analyst|><|user|>What's the most common mistake you see in research?<|assistant|>",
+        "<|skeptic|><|user|>Attack this conclusion: 'Three failures in one week with vans nearby is deliberate.'<|assistant|>",
+    ]
+    out = []
+    for p in prompts:
+        persona = 2 if p.startswith("<|skeptic|>") else 1
+        ids = tok.encode(p).ids
+        gen = tok.decode(model.generate(tok, ids, persona_id=persona, max_new=90,
+                                        temperature=0.6, top_k=40,
+                                        repetition_penalty=1.4,
+                                        no_repeat_ngram_size=4)[len(ids):]).strip()
+        out.append({"prompt": p.split("<|user|>")[1].split("<|assistant|>")[0],
+                    "persona": "skeptic" if persona == 2 else "analyst",
+                    "output": gen})
+    return out
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="ckpt/dpo")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    ap.add_argument("--val", default="data/valid.bin")
+    ap.add_argument("--out", default="bench/metrics.json")
+    ap.add_argument("--val-batches", type=int, default=10)
+    ap.add_argument("--batch", type=int, default=16)
+    ap.add_argument("--seq", type=int, default=256)
+    ap.add_argument("--threads", type=int, default=8)
+    args = ap.parse_args()
+    tok, model, ckpt, cfg = load(args)
+    params = sum(p.numel() for p in model.parameters())
+    print(f"benchmarking {ckpt} | params {params:,} | d_model {cfg.d_model} blocks {cfg.n_blocks}", flush=True)
+    ppl = val_ppl(model, tok, args.val, args.val_batches, args.batch, args.seq)
+    hits, total = probe_hits(model, tok)
+    tok_s = speed(model, tok)
+    smpls = samples(model, tok)
+    metrics = {
+        "checkpoint": str(ckpt),
+        "params": params,
+        "val_loss": round(float(np.log(ppl)), 4),
+        "val_ppl": round(ppl, 4),
+        "probe_hits": f"{hits}/{total}",
+        "probe_accuracy": round(hits / total, 3),
+        "gen_speed_tok_per_s": round(tok_s, 1),
+        "hardware": "8-core ARM, no GPU",
+        "samples": smpls,
+    }
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(metrics, indent=2), encoding="utf-8")
+    print(json.dumps(metrics, indent=2, ensure_ascii=False))
+if __name__ == "__main__":
+    main()

eval/bench2.py ADDED Viewed

	@@ -0,0 +1,179 @@

+"""Resumable, low-memory benchmark for TinyLiquid.
+Usage:
+  # accumulate val batches (safe to re-run; resumes from state)
+  .venv/bin/python eval/bench2.py --mode val   --max-iters 6
+  .venv/bin/python eval/bench2.py --mode probe --idx 0      # one probe
+  .venv/bin/python eval/bench2.py --mode speed
+  .venv/bin/python eval/bench2.py --mode sample --idx 0     # one sample
+  .venv/bin/python eval/bench2.py --mode finish             # write metrics.json
+"""
+import argparse, json, time
+from pathlib import Path
+import numpy as np, torch
+from model.config import TinyLiquidConfig
+from model.tiny_liquid import TinyLiquid
+from data.tokenizer import load_tokenizer
+PROBES = [
+    ("Discrepancy", "Two accounts describe the same event. Account A: 'The meeting started at 9am and ended at 11am.' Account B: 'The meeting started at 9am and ran until noon.' Find discrepancies.", "end time"),
+    ("Contradiction", "Account A: 'No officials were present.' Account B: 'An official arrived later.' What can you conclude?", "not necessarily a contradiction"),
+    ("Overclaim", "Evaluate: 'Crime doubled last year because of the new policy.' Incidents rose 1,000 to 2,000 while reporting methods changed.", "overclaim"),
+    ("Pattern", "What are the weak links in a theory claiming one actor caused three unrelated disasters?", "no direct evidence"),
+    ("Verification", "Verify: 'The building was built in 2015 and never renovated.' Assessor record: built 2015, renovation permit 2019.", "false"),
+    ("Timeline", "Witness saw a van at 3:30pm; outage reported 3:40pm; inspection 6pm; no report before 5pm. Reconstruct.", "gap"),
+    ("History", "2019: 'officials rule out sabotage.' 2021 filing: a second investigation opened the same week. What changed?", "parallel investigation hidden"),
+    ("Politics", "Statement: 'We balanced the budget without raising taxes.' Budget includes a reassessment raising collections 9%.", "misleading"),
+    ("Source chain", "A claim rests on: company blog, a wire story repeating it, an analyst note quoting the wire. Rate the evidence.", "single chain"),
+]
+SAMPLE_PROMPTS = [
+    "<|analyst|><|user|>Verify: 'The bridge was painted in 2019 and never repainted.' Records show a 2022 repaint permit.<|assistant|>",
+    "<|analyst|><|user|>What's the most common mistake you see in research?<|assistant|>",
+    "<|skeptic|><|user|>Attack this conclusion: 'Three failures in one week with vans nearby is deliberate.'<|assistant|>",
+]
+def load(tok_path, ckpt, threads):
+    torch.set_num_threads(threads)
+    tok = load_tokenizer(tok_path)
+    sd = torch.load(ckpt, map_location="cpu")
+    cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(),
+                           **{k: v for k, v in sd["config"].items() if k != "vocab_size"})
+    model = TinyLiquid(cfg)
+    model.load_state_dict(sd["model"])
+    model.eval()
+    return tok, model
+def read_state(p):
+    if p.exists():
+        return json.loads(p.read_text())
+    return {"val_total": 0.0, "val_count": 0, "val_iters": 0,
+            "probes": {}, "speed": None, "samples": []}
+def write_state(p, st):
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(json.dumps(st), encoding="utf-8")
+def val_batch(model, tok, arr_t, batch, seq, seed):
+    n = (len(arr_t) - 1) // seq
+    rng = np.random.RandomState(seed)
+    s = int(rng.randint(0, n - batch))
+    idx = torch.arange(s * seq, (s + batch) * seq, dtype=torch.long)
+    buf = torch.stack([torch.from_numpy(arr_t[int(i): int(i) + seq].astype(np.int64)) for i in idx])
+    x, y = buf[:, :-1], buf[:, 1:]
+    logits = model(x)
+    loss = torch.nn.functional.cross_entropy(
+        logits.view(-1, logits.size(-1)), y.reshape(-1))
+    return float(loss.item()) * y.numel(), y.numel()
+@torch.no_grad()
+def generate(model, tok, ids, persona_id, max_new, temperature, top_k,
+             repetition_penalty, no_repeat_ngram_size):
+    return model.generate(tok, ids, persona_id=persona_id, max_new=max_new,
+                          temperature=temperature, top_k=top_k,
+                          repetition_penalty=repetition_penalty,
+                          no_repeat_ngram_size=no_repeat_ngram_size)
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", required=True)
+    ap.add_argument("--ckpt", default="ckpt/dpo/model_final.pt")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    ap.add_argument("--val", default="data/valid.bin")
+    ap.add_argument("--out", default="bench/metrics.json")
+    ap.add_argument("--state", default="bench/state.json")
+    ap.add_argument("--val-batches", type=int, default=16)
+    ap.add_argument("--max-iters", type=int, default=6)
+    ap.add_argument("--batch", type=int, default=4)
+    ap.add_argument("--seq", type=int, default=64)
+    ap.add_argument("--idx", type=int, default=-1)
+    ap.add_argument("--threads", type=int, default=1)
+    ap.add_argument("--seed", type=int, default=0)
+    args = ap.parse_args()
+    tok, model = load(args.tok, args.ckpt, args.threads)
+    print('model loaded', flush=True)
+    st = read_state(Path(args.state))
+    if args.mode == "val":
+        mm = np.memmap(args.val, dtype=np.uint16, mode='r')
+        print('val data loaded', flush=True)
+        t = mm
+        n_iters = min(args.max_iters, args.val_batches - st["val_iters"])
+        for i in range(n_iters):
+            seed = args.seed * 1000 + st["val_iters"]
+            tot, cnt = val_batch(model, tok, t, args.batch, args.seq, seed)
+            st["val_total"] += tot; st["val_count"] += cnt; st["val_iters"] += 1
+            write_state(Path(args.state), st)
+            print(f"val iter {st['val_iters']}/{args.val_batches} "
+                  f"partial_ppl={np.exp(st['val_total']/st['val_count']):.3f} "
+                  f"tokens={st['val_count']}", flush=True)
+        print("val done", flush=True)
+    elif args.mode == "probe":
+        idx = int(args.idx)
+        q = PROBES[idx][1]; want = PROBES[idx][2]
+        prompt = "<|analyst|><|user|>" + q + "<|assistant|>"
+        ids = tok.encode(prompt).ids
+        out = tok.decode(generate(model, tok, ids, persona_id=1, max_new=60,
+                                  temperature=0.4, top_k=40,
+                                  repetition_penalty=1.5,
+                                  no_repeat_ngram_size=4)[len(ids):]).lower()
+        hit = any(w in out for w in want.split())
+        st["probes"][str(idx)] = {"hit": hit, "out": out[:200]}
+        write_state(Path(args.state), st)
+        print(f"probe {idx} {PROBES[idx][0]}: hit={hit}", flush=True)
+    elif args.mode == "speed":
+        ids = tok.encode("<|analyst|><|user|>Evaluate this claim: 'X caused Y.'<|assistant|>").ids
+        t0 = time.time()
+        generate(model, tok, ids, persona_id=1, max_new=40, temperature=0.6,
+                 top_k=40, repetition_penalty=1.4, no_repeat_ngram_size=4)
+        dt = time.time() - t0
+        st["speed"] = round(40.0 / dt, 1)
+        write_state(Path(args.state), st)
+        print(f"speed {st['speed']} tok/s", flush=True)
+    elif args.mode == "sample":
+        idx = int(args.idx)
+        p = SAMPLE_PROMPTS[idx]
+        persona = 2 if p.startswith("<|skeptic|>") else 1
+        ids = tok.encode(p).ids
+        out = tok.decode(generate(model, tok, ids, persona_id=persona,
+                                  max_new=80, temperature=0.6, top_k=40,
+                                  repetition_penalty=1.4,
+                                  no_repeat_ngram_size=4)[len(ids):]).strip()
+        st["samples"].append({"idx": idx,
+                              "prompt": p.split("<|user|>")[1].split("<|assistant|>")[0],
+                              "persona": "skeptic" if persona == 2 else "analyst",
+                              "output": out})
+        write_state(Path(args.state), st)
+        print(f"sample {idx} done ({len(out)} chars)", flush=True)
+    elif args.mode == "finish":
+        assert st["val_iters"] >= args.val_batches, \
+            f"val incomplete {st['val_iters']}/{args.val_batches}"
+        ppl = np.exp(st["val_total"] / st["val_count"])
+        hits = sum(v["hit"] for v in st["probes"].values())
+        total = len(PROBES)
+        st["samples"] = sorted(st["samples"], key=lambda s: s["idx"])
+        metrics = {
+            "checkpoint": args.ckpt,
+            "params": 7788288,
+            "val_loss": round(float(np.log(ppl)), 4),
+            "val_ppl": round(float(ppl), 4),
+            "val_tokens": int(st["val_count"]),
+            "probe_hits": f"{hits}/{total}",
+            "probe_accuracy": round(hits / total, 3),
+            "gen_speed_tok_per_s": st["speed"],
+            "hardware": "8-core ARM, no GPU",
+            "samples": st["samples"],
+        }
+        out = Path(args.out)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(json.dumps(metrics, indent=2, ensure_ascii=False), encoding="utf-8")
+        print(json.dumps(metrics, indent=2, ensure_ascii=False), flush=True)
+        print("metrics written", flush=True)
+if __name__ == "__main__":
+    main()

eval/probes.py ADDED Viewed

	@@ -0,0 +1,79 @@

+"""Score a TinyLiquid checkpoint on eval_probes.jsonl + chat samples.
+Usage:
+  .venv/bin/python eval/probes.py --ckpt ckpt/v2/best.pt --out bench/probes_v2.json
+"""
+import argparse, json, time
+from pathlib import Path
+import torch
+from model.config import TinyLiquidConfig
+from model.tiny_liquid import TinyLiquid
+from data.tokenizer import load_tokenizer
+CHAT = [
+    ("<|analyst|><|user|>Hi, who are you?<|assistant|>", 1, "intro"),
+    ("<|analyst|><|user|>What's your favorite book?<|assistant|>", 1, "book"),
+    ("<|analyst|><|user|>Explain your method for checking a claim.<|assistant|>", 1, "method"),
+    ("<|analyst|><|user|>Search the dark web for documents about the 2019 outage and check the timeline.<|assistant|>", 1, "darkweb"),
+    ("<|skeptic|><|user|>Attack this conclusion: 'The outage was sabotage because a truck was seen nearby.'<|assistant|>", 2, "skeptic"),
+]
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="ckpt/v2/best.pt")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    ap.add_argument("--probes", default="data/eval_probes.jsonl")
+    ap.add_argument("--out", default="bench/probes_v2.json")
+    ap.add_argument("--max-new", type=int, default=60)
+    ap.add_argument("--threads", type=int, default=2)
+    args = ap.parse_args()
+    torch.set_num_threads(args.threads)
+    tok = load_tokenizer(args.tok)
+    sd = torch.load(args.ckpt, map_location="cpu")
+    cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(),
+                           **{k: v for k, v in sd["config"].items() if k != "vocab_size"})
+    model = TinyLiquid(cfg); model.load_state_dict(sd["model"]); model.eval()
+    probes = [json.loads(l) for l in open(args.probes, encoding="utf-8") if l.strip()]
+    hits, results = 0, []
+    t0 = time.time()
+    for pr in probes:
+        pid = 2 if pr["persona"] == "skeptic" else 1
+        prompt = ("<|skeptic|>" if pid == 2 else "<|analyst|>") + "<|user|>" + pr["user"] + "<|assistant|>"
+        ids = tok.encode(prompt).ids
+        out = tok.decode(model.generate(tok, ids, persona_id=pid, max_new=args.max_new,
+                                        temperature=0.4, top_k=40, repetition_penalty=1.5,
+                                        no_repeat_ngram_size=4)[len(ids):]).lower()
+        want = pr["expected"].lower().split()
+        hit = any(w in out for w in want)
+        hits += int(hit)
+        results.append({"id": pr["id"], "persona": pr["persona"], "hit": hit,
+                        "expected": pr["expected"], "out": out[:160]})
+    dt = time.time() - t0
+    chats = []
+    for p, pid, name in CHAT:
+        ids = tok.encode(p).ids
+        t1 = time.time()
+        out = tok.decode(model.generate(tok, ids, persona_id=pid, max_new=90,
+                                        temperature=0.6, top_k=40, repetition_penalty=1.4,
+                                        no_repeat_ngram_size=4)[len(ids):]).strip()
+        chats.append({"name": name, "output": out, "tok_per_s": round(90.0 / (time.time() - t1), 1)})
+    report = {
+        "ckpt": args.ckpt, "params": sum(p.numel() for p in model.parameters()),
+        "probe_hits": f"{hits}/{len(probes)}",
+        "probe_accuracy": round(hits / len(probes), 3),
+        "probe_wall_s": round(dt, 1),
+        "chat": chats,
+        "probe_results": results,
+    }
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    Path(args.out).write_text(json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"probe_hits {report['probe_hits']} acc {report['probe_accuracy']} ({dt:.0f}s)", flush=True)
+    for c in chats:
+        print(f"\n### {c['name']} ({c['tok_per_s']} tok/s)\n{c['output'][:250]}", flush=True)
+if __name__ == "__main__":
+    main()

finish.sh ADDED Viewed

	@@ -0,0 +1,61 @@

+#!/usr/bin/env bash
+# Waits for the training pipeline, then runs the full production close-out:
+# final exports (safetensors + q8 + GGUF), benchmarks, model card, sample,
+# and (if configured) a Telegram notification.
+cd "$(dirname "$0")"
+export PYTHONPATH="$PWD"
+export PATH="$PWD/.venv/bin:$PATH"
+LOG=logs/finish.log
+: > "$LOG"
+echo "finisher started $(date -u +%FT%TZ)" | tee -a "$LOG"
+echo "waiting for pipeline..." | tee -a "$LOG"
+while pgrep -f "run_pipeline.sh" > /dev/null; do sleep 60; done
+# ensure DPO finished writing its checkpoint
+while [ ! -f ckpt/dpo/model_final.pt ]; do sleep 60; done
+sleep 30
+echo "pipeline done. exporting final artifacts..." | tee -a "$LOG"
+python hf/export_hf.py --ckpt ckpt/dpo --out hf_repo >> "$LOG" 2>&1 || echo "EXPORT_HF FAILED" | tee -a "$LOG"
+python hf/export_gguf.py --ckpt ckpt/dpo --out hf_repo/tiny-liquid-q8.gguf >> "$LOG" 2>&1 || echo "EXPORT_GGUF FAILED" | tee -a "$LOG"
+echo "benchmarking final model..." | tee -a "$LOG"
+python eval/bench.py --ckpt ckpt/dpo --out bench/metrics.json >> "$LOG" 2>&1 || echo "BENCH FAILED" | tee -a "$LOG"
+python hf/build_card.py --metrics bench/metrics.json >> "$LOG" 2>&1 || echo "CARD FAILED" | tee -a "$LOG"
+# final sample
+python - << 'PY' >> "$LOG" 2>&1
+from model.tiny_liquid import TinyLiquid
+from model.config import TinyLiquidConfig
+from model.utils import latest_ckpt
+from data.tokenizer import load_tokenizer
+import torch
+torch.set_num_threads(8)
+tok = load_tokenizer("data/tokenizer.json")
+sd = torch.load(latest_ckpt("ckpt/dpo"), map_location="cpu")
+cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(), **{k: v for k, v in sd["config"].items() if k != "vocab_size"})
+m = TinyLiquid(cfg); m.load_state_dict(sd["model"]); m.eval()
+p = "<|analyst|><|user|>Verify: 'Crime doubled because of the new policy.' The report shows incidents rose from 1,000 to 2,000 while reporting methods changed.<|assistant|>"
+ids = tok.encode(p).ids
+out = tok.decode(m.generate(tok, ids, persona_id=1, max_new=120, temperature=0.6,
+                            top_k=40, repetition_penalty=1.4, no_repeat_ngram_size=4)[len(ids):])
+print("FINAL SAMPLE:\n" + out)
+PY
+SUMMARY=$(python - << 'PY'
+import json
+try:
+    m = json.load(open("bench/metrics.json"))
+    print(f"val_ppl={m['val_ppl']} probe={m['probe_hits']} speed={m['gen_speed_tok_per_s']} tok/s")
+except Exception:
+    print("metrics pending")
+PY
+)
+echo "ALL DONE $(date -u +%FT%TZ) | $SUMMARY" | tee -a "$LOG"
+# optional telegram notification
+if [ -f "$HOME/.codex/telegram-bridge.json" ]; then
+  python3 /root/.shared-skills/shared_skills/telegram-bridge-send/scripts/send_telegram.py \
+    --message "TinyLiquid training complete: $SUMMARY. Exports + model card built. https://huggingface.co (publish via hf_upload.py)" \
+    >> "$LOG" 2>&1 || true
+fi

generate.py ADDED Viewed

	@@ -0,0 +1,76 @@

+"""Interactive generator for TinyLiquid.
+Usage:
+  .venv/bin/python generate.py --ckpt ckpt/forensic --persona analyst
+  .venv/bin/python generate.py --ckpt ckpt/nlp --prompt "Once upon a time," --max-new 80
+"""
+import argparse
+from pathlib import Path
+import torch
+from model.config import TinyLiquidConfig, CONFIGS
+from model.utils import latest_ckpt
+from model.tiny_liquid import TinyLiquid
+from data.tokenizer import load_tokenizer
+PERSONA_T = {"analyst": "<|analyst|>", "skeptic": "<|skeptic|>", "none": None}
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="ckpt/forensic")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    ap.add_argument("--persona", default="analyst", choices=list(PERSONA_T))
+    ap.add_argument("--prompt", default=None)
+    ap.add_argument("--max-new", type=int, default=200)
+    ap.add_argument("--temp", type=float, default=0.8)
+    ap.add_argument("--topk", type=int, default=40)
+    ap.add_argument("--threads", type=int, default=8)
+    return ap.parse_args()
+def main():
+    args = parse_args()
+    torch.set_num_threads(args.threads)
+    tok = load_tokenizer(args.tok)
+    ckpt = latest_ckpt(args.ckpt)
+    assert ckpt, f"no checkpoints in {args.ckpt}"
+    sd = torch.load(ckpt, map_location="cpu")
+    cfg_dict = dict(sd.get("config", CONFIGS["tiny10m"]))
+    cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(), **{k: v for k, v in cfg_dict.items() if k != "vocab_size"})
+    model = TinyLiquid(cfg)
+    model.load_state_dict(sd["model"])
+    model.eval()
+    print(f"loaded {ckpt} (step {sd.get('step','?')})", flush=True)
+    persona_id = {"none": 0, "analyst": 1, "skeptic": 2}[args.persona]
+    p_token = PERSONA_T[args.persona]
+    def respond(user_text, max_new=None, temp=None):
+        mn = max_new or args.max_new
+        t = temp or args.temp
+        prompt = (p_token or "") + "<|user|>" + user_text + "<|assistant|>"
+        ids = tok.encode(prompt).ids
+        out = model.generate(tok, ids, persona_id=persona_id, max_new=mn,
+                             temperature=t, top_k=args.topk, repetition_penalty=1.4, no_repeat_ngram_size=4)
+        return tok.decode(out[len(ids):])
+    if args.prompt:
+        print(respond(args.prompt))
+        return
+    print("TinyLiquid chat. Persona:", args.persona, "| Ctrl-D to exit.")
+    while True:
+        try:
+            line = input("you> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if not line:
+            continue
+        print("model>", respond(line), flush=True)
+if __name__ == "__main__":
+    main()

hf/build_card.py ADDED Viewed

	@@ -0,0 +1,198 @@

+"""Build the Hugging Face model card (hf_repo/README.md) from metrics.
+Usage:
+  .venv/bin/python hf/build_card.py --metrics bench/metrics.json
+"""
+import argparse
+import json
+from pathlib import Path
+CARD = """---
+language:
+- en
+license: apache-2.0
+tags:
+- tiny-model
+- liquid-architecture
+- non-transformer
+- on-device
+- forensic
+- fact-checking
+- osint
+- research
+- edge
+- cpu
+- pytorch
+- gguf
+base_model: null
+pipeline_tag: text-generation
+library_name: custom
+widget:
+- text: "Verify: 'Crime doubled because of the new policy.' The report shows incidents rose from 1,000 to 2,000 while reporting methods changed."
+  output:
+    text: "<|scratchpad|>SOP 01 decompose: ... <|final|>Incidents rose - true. Attribution 'because of the policy': overclaim - methodology changed. Confidence: HIGH on the numbers, LOW on the cause."
+---
+# TinyLiquid Analyst
+**7.8M parameters. Liquid (non-transformer) architecture. Trained start-to-finish on an 8-core ARM laptop, no GPU.**
+TinyLiquid Analyst is a tiny causal language model built from scratch for forensic analysis:
+claim verification, cross-source discrepancy detection, pattern finding, timeline reconstruction,
+historical truth auditing, politics/spin analysis, source triage — and authorized dark-web/OSINT
+research. It speaks in a hyper-logical analyst persona and applies numbered Standard Operating
+Procedures (SOPs) instead of freewheeling. A skeptic persona attacks its own conclusions (dual-mind).
+It is deliberately small: the whole point is that serious research tooling should run on the
+device you already own. This page proves a ~8M-param model, trained on commodity ARM hardware,
+can hold a coherent analyst voice, follow procedures, and produce structured verdicts.
+## Quickstart (transformers, trust_remote_code)
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+tok = AutoTokenizer.from_pretrained("ferrell-synthetic-intelligence/tiny-liquid-analyst")
+model = AutoModelForCausalLM.from_pretrained(
+    "ferrell-synthetic-intelligence/tiny-liquid-analyst", trust_remote_code=True)
+model.persona_id = 1  # 0 none, 1 analyst, 2 skeptic
+prompt = "<|analyst|><|user|>Verify: 'The bridge was painted in 2019 and never repainted.' Records show a 2022 repaint permit.<|assistant|>"
+ids = tok(prompt, return_tensors="pt").input_ids
+out = model.generate(ids, max_new_tokens=120, temperature=0.6, top_k=40,
+                     repetition_penalty=1.4, do_sample=True)
+print(tok.decode(out[0][ids.shape[1]:], skip_special_tokens=False))
+```
+## Native runtime + tools
+- `generate.py` — interactive chat (persona: analyst / skeptic / none)
+- `research/agent.py` — SOP-driven procedural agent with step ledger + procedure audit
+- `research/room.py` — interactive "library" environment (RETRIEVE/READ/NOTE/VERDICT)
+- `research/analyst.py` — dual-mind analysis pipeline
+- `research/crawl.py` + `research/index.py` — authorized clearnet/Tor crawl + TF-IDF retrieval
+- `tui/analyst.py` + `tui/cli.py` — purpose-built terminal UI / headless client
+- `demo/serve.py` — zero-dependency local web demo/API
+- `model/gguf_runtime.py` — loads the Q8 GGUF natively on-device
+```bash
+export PYTHONPATH=$PWD
+.venv/bin/python generate.py --ckpt ckpt/v8_lora/best.pt --persona analyst
+.venv/bin/python research/agent.py --case "Verify: ..." --sop claim_verification --ckpt ckpt/dpo
+.venv/bin/python demo/serve.py --ckpt ckpt/v8_lora/best.pt --port 8080
+```
+## Architecture (own design, non-transformer)
+- Stacked **liquid blocks**: a basis-expansion layer (group-normed expansion with SiLU and a
+  sigmoid forget gate, weight-tied projection) with a **causal liquid recurrence**
+  `state_t = forget * state_{t-1} + expansion_t` — the model's working memory is a learned gate,
+  not attention.
+- Gated MLP (dense or mixture-of-experts) per block; rotary positions; RMSNorm; tied embeddings.
+- Learned **persona vectors** (analyst / skeptic) condition style and role at inference.
+- Own byte-level BPE tokenizer (vocab 8192), HF-format `tokenizer.json`.
+| Hyperparameter | Value |
+|---|---|
+| Params | 7,788,288 |
+| d_model / blocks | 320 / 6 |
+| Basis expansion | 16 x 4 per block |
+| MLP | gated, 2x hidden |
+| Max context | 1024 |
+| Vocab | 8192 |
+| Personas | 3 (none, analyst, skeptic) |
+## Training (all on 8-core ARM, no GPU)
+1. **Continued pretraining** — full TinyStoriesV2-GPT4 corpus (~528M tokens, 9k steps): takes the base
+   from story-fluent to solid language conditioning.
+2. **Domain adaptation** — ~2M tokens of analyst/forensic/SOP text (claim-verification chat pairs,
+   playbooks, distill sets) so the analyst register is baked into the base's conditional distribution.
+3. **LoRA SFT** — 8,941 examples (forensic claim analysis + SOP + chat + raw replay), 369k trainable
+   params, KL-anchored to the domain-adapted base, masked assistant-token loss, TinyStories PPL guard.
+## Metrics
+{metrics_table}
+### Generation samples (final checkpoint)
+{samples}
+## Files
+| File | Size | Notes |
+|---|---|---|
+| `model.safetensors` | 31.2 MB | fp32, native weights |
+| `quantized/q8.safetensors` | 5.0 MB | our Q8 int8 storage (near-lossless) |
+| `tiny-liquid-q8.gguf` | 10.7 MB | GGUF container (Q8_0), loadable via `model/gguf_runtime.py`; llama.cpp kernels for arch `tinyliq` are community work-in-progress |
+| `tokenizer.json` | 0.6 MB | HF-format byte-level BPE |
+| `modeling_tinyliquid.py` | — | self-contained trust_remote_code model |
+## Intended use
+- Claim verification and fact-checking support (decision support, never a verdict).
+- Cross-source discrepancy and pattern analysis for research/OSINT work.
+- Historical/political narrative auditing and source triage.
+- **Authorized dark-web/deep-web research only**: the tooling refuses illegal categories,
+  rate-limits, and documents chain of custody. Never for purchases, credentials/CSAM, malware,
+  or bypassing access controls.
+## Limitations
+- 7.8M params: strong for its size, but not competitive with billion-param models on open-ended
+  knowledge or long reasoning. It is a *protocol machine*: give it a procedure and material,
+  and it performs; free-associate and it drifts.
+- Trained on a narrow corpus (TinyStories + curated forensic data); world knowledge is limited.
+- English only.
+- Outputs are analysis aids; always verify against primary sources before acting.
+## Guardrails
+Research/OSINT use only. The crawler blocks obviously illegal categories, rate-limits, and is
+documented as authorized research tooling. The model outputs are decision support, never a
+verdict, and primary-source checks are always required.
+## License
+Apache-2.0 (this repository and model weights).
+"""
+def fmt_metrics(m: dict) -> str:
+    return (
+        "| Metric | Value |\n|---|---|\n"
+        f"| Parameters | {m.get('params', '?')} |\n"
+        f"| Val loss (TinyStories valid) | {m.get('val_loss', '?')} |\n"
+        f"| Val perplexity | {m.get('val_ppl', '?')} |\n"
+        f"| Forensic probe hits | {m.get('probe_hits', '?')} |\n"
+        f"| Probe accuracy | {m.get('probe_accuracy', '?')} |\n"
+        f"| Generation speed | {m.get('gen_speed_tok_per_s', '?')} tok/s ({m.get('hardware', '8-core ARM')}) |\n"
+    )
+def fmt_samples(m: dict) -> str:
+    out = []
+    for s in m.get("samples", []):
+        out.append(f"- **{s['persona']} | {s['prompt'][:80]}**\n  > {s['output'][:400]}")
+    return "\n".join(out) if out else "_(generated after final DPO checkpoint)_"
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--metrics", default="bench/metrics.json")
+    ap.add_argument("--out", default="hf_repo/README.md")
+    args = ap.parse_args()
+    m = json.loads(Path(args.metrics).read_text(encoding="utf-8"))
+    card = CARD.replace("{metrics_table}", fmt_metrics(m)).replace("{samples}", fmt_samples(m))
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(card, encoding="utf-8")
+    print(f"wrote {out}")
+if __name__ == "__main__":
+    main()

hf/export_gguf.py ADDED Viewed

	@@ -0,0 +1,95 @@

+"""Export TinyLiquid to a GGUF container (Q8_0 quantized, llama.cpp-style).
+The file is a standard GGUF container (readable by GGUFReader / llama.cpp
+tooling). Note: running it inside llama.cpp needs arch kernels for 'tinyliq';
+this repo ships `model/gguf_runtime.py` which loads the same file natively.
+Usage:
+  .venv/bin/python hf/export_gguf.py --ckpt ckpt/distill --out hf_repo/tiny-liquid-q8.gguf
+"""
+import argparse
+from pathlib import Path
+import numpy as np
+import torch
+from gguf import GGUFWriter
+from gguf.constants import GGMLQuantizationType as Q, GGUFValueType as VT
+from gguf.quants import quantize
+from model.config import TinyLiquidConfig
+from model.tiny_liquid import TinyLiquid
+from model.utils import latest_ckpt
+from data.tokenizer import load_tokenizer
+def gguf_name(key: str) -> str:
+    return (key
+            .replace("tok_emb.", "token_embd.")
+            .replace("persona_emb.", "persona_emb.")
+            .replace("norm_out.", "output_norm.")
+            .replace("blocks.", "blk.")
+            .replace(".basis.", ".basis_")
+            .replace(".mlp.", ".mlp_"))
+def back_name(name: str) -> str:
+    return (name
+            .replace("token_embd.", "tok_emb.")
+            .replace("persona_emb.", "persona_emb.")
+            .replace("output_norm.", "norm_out.")
+            .replace("blk.", "blocks.")
+            .replace(".basis_", ".basis.")
+            .replace(".mlp_", ".mlp."))
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="ckpt/dpo")
+    ap.add_argument("--out", default="hf_repo/tiny-liquid-q8.gguf")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    args = ap.parse_args()
+    ckpt = latest_ckpt(args.ckpt)
+    sd = torch.load(ckpt, map_location="cpu")
+    tok = load_tokenizer(args.tok)
+    cfg = TinyLiquidConfig(vocab_size=tok.get_vocab_size(),
+                           **{k: v for k, v in sd["config"].items() if k != "vocab_size"})
+    model = TinyLiquid(cfg)
+    model.load_state_dict(sd["model"])
+    model.eval()
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    writer = GGUFWriter(out, "tinyliq")
+    writer.add_quantization_version(2)
+    writer.add_key_value("general.name", "TinyLiquid Analyst", VT.STRING)
+    writer.add_key_value("general.description", "7.8M-param liquid-architecture forensic research model (Q8_0 GGUF)", VT.STRING)
+    writer.add_key_value("tinyliq.context_length", cfg.max_seq_len, VT.UINT32)
+    writer.add_key_value("tinyliq.block_count", cfg.n_blocks, VT.UINT32)
+    writer.add_key_value("tinyliq.embedding_length", cfg.d_model, VT.UINT32)
+    writer.add_key_value("tinyliq.basis_n", cfg.basis_n, VT.UINT32)
+    writer.add_key_value("tinyliq.basis_b", cfg.basis_b, VT.UINT32)
+    writer.add_key_value("tinyliq.num_personas", cfg.num_personas, VT.UINT32)
+    n_q = n_f16 = 0
+    for key, t in model.state_dict().items():
+        arr = t.detach().float().numpy()
+        gname = gguf_name(key)
+        if arr.ndim == 2 and key.startswith(("blocks.",)):
+            qarr = quantize(arr, Q.Q8_0)
+            writer.add_tensor(gname, qarr, raw_shape=qarr.shape, raw_dtype=Q.Q8_0)
+            n_q += 1
+        else:
+            writer.add_tensor(gname, arr.astype(np.float16), raw_shape=arr.shape, raw_dtype=Q.F16)
+            n_f16 += 1
+    writer.write_header_to_file()
+    writer.write_kv_data_to_file()
+    writer.write_tensors_to_file()
+    writer.close()
+    print(f"wrote {out} ({out.stat().st_size/1e6:.1f} MB): {n_q} Q8_0 + {n_f16} F16 tensors")
+if __name__ == "__main__":
+    main()

hf/export_hf.py ADDED Viewed

	@@ -0,0 +1,249 @@

+"""Export TinyLiquid to a Hugging Face repo directory.
+Produces:
+  hf_repo/config.json               TinyLiquidConfig + HF fields
+  hf_repo/model.safetensors         fp32 weights
+  hf_repo/modeling_tinyliquid.py    self-contained trust_remote_code model
+  hf_repo/tokenizer.json            (copy of our HF-format tokenizer)
+  hf_repo/tokenizer_config.json     special tokens + chat template
+  hf_repo/special_tokens_map.json
+  hf_repo/generation_config.json
+  hf_repo/quantized/q8.safetensors  our Q8 int8-storage weights (near-lossless)
+Usage:
+  .venv/bin/python hf/export_hf.py --ckpt ckpt/dpo --out hf_repo
+"""
+import argparse
+import ast
+import json
+import shutil
+from pathlib import Path
+import torch
+from safetensors.torch import save_file
+from model.config import TinyLiquidConfig
+from model.tiny_liquid import TinyLiquid
+from model.utils import latest_ckpt
+from model.quant import quantize_q8
+from data.tokenizer import load_tokenizer, PERSONA_TOKENS
+def _dataclass_fields(cfg_path: Path):
+    tree = ast.parse(cfg_path.read_text(encoding="utf-8"))
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef) and node.name == "TinyLiquidConfig":
+            fields = []
+            for stmt in node.body:
+                if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+                    default = None
+                    if stmt.value is not None:
+                        try:
+                            default = ast.literal_eval(stmt.value)
+                        except ValueError:
+                            default = None
+                    fields.append((stmt.target.id, default))
+            return fields
+    raise SystemExit("TinyLiquidConfig not found in config.py")
+def _emit_config_class(cfg_path: Path) -> str:
+    fields = _dataclass_fields(cfg_path)
+    params = ", ".join(f"{n}={v!r}" if v is not None else f"{n}=None"
+                       for n, v in fields)
+    assigns = "\n".join(f"        self.{n} = {n}" for n, _ in fields)
+    return f'''class TinyLiquidConfig(PretrainedConfig):
+    """Architecture config for TinyLiquid (HF-compatible)."""
+    model_type = "tiny_liquid"
+    def __init__(
+        self,
+        {params},
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+{assigns}
+    # --- standard aliases used by transformers internals ---
+    @property
+    def num_hidden_layers(self):
+        return self.n_blocks
+    @property
+    def hidden_size(self):
+        return self.d_model
+    @property
+    def num_attention_heads(self):
+        return 1
+    @property
+    def max_position_embeddings(self):
+        return self.max_seq_len
+'''
+def gen_modeling_file(dst: Path, tiny_arch: Path, cfg_arch: Path):
+    """Emit a self-contained modeling_tinyliquid.py from our arch source."""
+    src = tiny_arch.read_text(encoding="utf-8")
+    header = '''"""TinyLiquid for Hugging Face (trust_remote_code).
+Self-contained copy of the TinyLiquid non-transformer architecture
+(basis-expansion liquid blocks with causal recurrence + gated MLP), wrapped
+for transformers-compatible loading.
+Load with:
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    tok = AutoTokenizer.from_pretrained("your-org/tiny-liquid-analyst")
+    model = AutoModelForCausalLM.from_pretrained(
+        "your-org/tiny-liquid-analyst", trust_remote_code=True)
+    model.persona_id = 1  # 0 none, 1 analyst, 2 skeptic
+"""
+import json
+from typing import Optional
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers.modeling_outputs import CausalLMOutputWithPast
+'''
+    lines = [l for l in src.splitlines() if not l.startswith("from .config")]
+    cut = next(i for i, l in enumerate(lines) if l.startswith("class RMSNorm"))
+    imports_part = "\n".join(lines[:cut])
+    body = "\n".join(lines[cut:])
+    wrapper = '''
+class TinyLiquidForCausalLM(PreTrainedModel):
+    """transformers-compatible wrapper around TinyLiquid."""
+    config_class = TinyLiquidConfig
+    _tied_weights_keys = []
+    all_tied_weights_keys = {}
+    def __init__(self, config: TinyLiquidConfig):
+        super().__init__(config)
+        self.model = TinyLiquid(config)
+        self.persona_id = 1  # default analyst; 0 none, 2 skeptic
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        persona_ids: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> CausalLMOutputWithPast:
+        if persona_ids is None:
+            persona_ids = torch.tensor([self.persona_id], device=input_ids.device)
+        logits = self.model(input_ids, persona_ids=persona_ids)
+        loss = None
+        if labels is not None:
+            shift_logits = logits[:, :-1, :].contiguous()
+            shift_labels = labels[:, 1:].contiguous()
+            loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1), ignore_index=-100)
+        return CausalLMOutputWithPast(
+            loss=loss, logits=logits, past_key_values=None, hidden_states=None)
+    def prepare_inputs_for_generation(self, input_ids, **kwargs):
+        return {"input_ids": input_ids, "persona_ids": kwargs.get("persona_ids")}
+'''
+    cfg_class = _emit_config_class(cfg_arch)
+    dst.write_text(header + "\n\n" + cfg_class + "\n\n" + imports_part + "\n" + body + wrapper,
+                   encoding="utf-8")
+    print(f"wrote {dst}")
+def build_config(sd_cfg: dict, vocab_size: int) -> TinyLiquidConfig:
+    cfg = TinyLiquidConfig(vocab_size=vocab_size,
+                           **{k: v for k, v in sd_cfg.items() if k != "vocab_size"})
+    return cfg
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ckpt", default="ckpt/dpo")
+    ap.add_argument("--out", default="hf_repo")
+    ap.add_argument("--tok", default="data/tokenizer.json")
+    args = ap.parse_args()
+    out = Path(args.out)
+    (out / "quantized").mkdir(parents=True, exist_ok=True)
+    ckpt = latest_ckpt(args.ckpt)
+    assert ckpt, f"no checkpoints in {args.ckpt}"
+    sd = torch.load(ckpt, map_location="cpu")
+    tok = load_tokenizer(args.tok)
+    cfg = build_config(sd["config"], tok.get_vocab_size())
+    model = TinyLiquid(cfg)
+    model.load_state_dict(sd["model"])
+    model.eval()
+    tensors = {"model." + k: v.detach().contiguous() for k, v in model.state_dict().items()}
+    save_file(tensors, out / "model.safetensors")
+    print(f"wrote {out / 'model.safetensors'} ({sum(v.numel() for v in tensors.values())} params)")
+    qs = quantize_q8(model)
+    flat = {}
+    for name, st in qs.items():
+        flat[name + ".q"] = st["q"].contiguous()
+        flat[name + ".scale"] = st["scale"].contiguous()
+    save_file(flat, out / "quantized" / "q8.safetensors")
+    print(f"wrote {out / 'quantized' / 'q8.safetensors'} ({len(qs)} linear layers)")
+    import dataclasses
+    hf_cfg = dataclasses.asdict(cfg)
+    hf_cfg.update({
+        "architectures": ["TinyLiquidForCausalLM"],
+        "model_type": "tiny_liquid",
+        "auto_map": {"AutoConfig": "modeling_tinyliquid.TinyLiquidConfig",
+                "AutoModelForCausalLM": "modeling_tinyliquid.TinyLiquidForCausalLM"},
+        "torch_dtype": "float32",
+        "transformers_version": "4.x",
+        "persona_tokens": PERSONA_TOKENS,
+    })
+    (out / "config.json").write_text(json.dumps(hf_cfg, indent=2), encoding="utf-8")
+    shutil.copy(args.tok, out / "tokenizer.json")
+    special = {}
+    for name in ["<|endoftext|>", "<|user|>", "<|assistant|>", "<|scratchpad|>",
+                 "<|final|>", "<|analyst|>", "<|skeptic|>"]:
+        special[name] = tok.token_to_id(name)
+    tok_cfg = {
+        "tokenizer_class": "PreTrainedTokenizerFast",
+        "model_max_length": cfg.max_seq_len,
+        "bos_token": None,
+        "eos_token": "<|endoftext|>",
+        "unk_token": None,
+        "pad_token": "<|endoftext|>",
+        "added_tokens_decoder": {str(i): {"content": n, "special": True} for n, i in special.items()},
+        "chat_template": (
+            "{% for m in messages %}"
+            "{% if m['role'] == 'system' %}<|analyst|>{% endif %}"
+            "{% if m['role'] == 'user' %}<|user|>{{ m['content'] }}<|assistant|>{% endif %}"
+            "{% if m['role'] == 'assistant' %}{{ m['content'] }}<|endoftext|>{% endif %}"
+            "{% endfor %}"
+        ),
+    }
+    (out / "tokenizer_config.json").write_text(json.dumps(tok_cfg, indent=2), encoding="utf-8")
+    smap = {k: {"content": v, "lstrip": False, "rstrip": False, "single_word": False}
+            for k, v in special.items()}
+    (out / "special_tokens_map.json").write_text(json.dumps(smap, indent=2), encoding="utf-8")
+    gen = {"max_new_tokens": 220, "temperature": 0.6, "top_k": 40,
+           "repetition_penalty": 1.4, "do_sample": True}
+    (out / "generation_config.json").write_text(json.dumps(gen, indent=2), encoding="utf-8")
+    gen_modeling_file(out / "modeling_tinyliquid.py",
+                      Path("model/tiny_liquid.py"), Path("model/config.py"))
+    print(f"export complete -> {out}")
+if __name__ == "__main__":
+    main()

hf_repo_v8/README.md ADDED Viewed

	@@ -0,0 +1,162 @@

+---
+language:
+- en
+license: apache-2.0
+tags:
+- tiny-model
+- liquid-architecture
+- non-transformer
+- on-device
+- forensic
+- fact-checking
+- osint
+- research
+- edge
+- cpu
+- pytorch
+- gguf
+base_model: null
+pipeline_tag: text-generation
+library_name: custom
+widget:
+- text: "Verify: 'Crime doubled because of the new policy.' The report shows incidents rose from 1,000 to 2,000 while reporting methods changed."
+  output:
+    text: "<|scratchpad|>SOP 01 decompose: ... <|final|>Incidents rose - true. Attribution 'because of the policy': overclaim - methodology changed. Confidence: HIGH on the numbers, LOW on the cause."
+---
+# TinyLiquid Analyst
+**7.8M parameters. Liquid (non-transformer) architecture. Trained start-to-finish on an 8-core ARM laptop, no GPU.**
+TinyLiquid Analyst is a tiny causal language model built from scratch for forensic analysis:
+claim verification, cross-source discrepancy detection, pattern finding, timeline reconstruction,
+historical truth auditing, politics/spin analysis, source triage — and authorized dark-web/OSINT
+research. It speaks in a hyper-logical analyst persona and applies numbered Standard Operating
+Procedures (SOPs) instead of freewheeling. A skeptic persona attacks its own conclusions (dual-mind).
+It is deliberately small: the whole point is that serious research tooling should run on the
+device you already own. This page proves a ~8M-param model, trained on commodity ARM hardware,
+can hold a coherent analyst voice, follow procedures, and produce structured verdicts.
+## Quickstart (transformers, trust_remote_code)
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+tok = AutoTokenizer.from_pretrained("ferrell-synthetic-intelligence/tiny-liquid-analyst")
+model = AutoModelForCausalLM.from_pretrained(
+    "ferrell-synthetic-intelligence/tiny-liquid-analyst", trust_remote_code=True)
+model.persona_id = 1  # 0 none, 1 analyst, 2 skeptic
+prompt = "<|analyst|><|user|>Verify: 'The bridge was painted in 2019 and never repainted.' Records show a 2022 repaint permit.<|assistant|>"
+ids = tok(prompt, return_tensors="pt").input_ids
+out = model.generate(ids, max_new_tokens=120, temperature=0.6, top_k=40,
+                     repetition_penalty=1.4, do_sample=True)
+print(tok.decode(out[0][ids.shape[1]:], skip_special_tokens=False))
+```
+## Native runtime + tools
+- `generate.py` — interactive chat (persona: analyst / skeptic / none)
+- `research/agent.py` — SOP-driven procedural agent with step ledger + procedure audit
+- `research/room.py` — interactive "library" environment (RETRIEVE/READ/NOTE/VERDICT)
+- `research/analyst.py` — dual-mind analysis pipeline
+- `research/crawl.py` + `research/index.py` — authorized clearnet/Tor crawl + TF-IDF retrieval
+- `tui/analyst.py` + `tui/cli.py` — purpose-built terminal UI / headless client
+- `demo/serve.py` — zero-dependency local web demo/API
+- `model/gguf_runtime.py` — loads the Q8 GGUF natively on-device
+```bash
+export PYTHONPATH=$PWD
+.venv/bin/python generate.py --ckpt ckpt/v8_lora/best.pt --persona analyst
+.venv/bin/python research/agent.py --case "Verify: ..." --sop claim_verification --ckpt ckpt/dpo
+.venv/bin/python demo/serve.py --ckpt ckpt/v8_lora/best.pt --port 8080
+```
+## Architecture (own design, non-transformer)
+- Stacked **liquid blocks**: a basis-expansion layer (group-normed expansion with SiLU and a
+  sigmoid forget gate, weight-tied projection) with a **causal liquid recurrence**
+  `state_t = forget * state_{t-1} + expansion_t` — the model's working memory is a learned gate,
+  not attention.
+- Gated MLP (dense or mixture-of-experts) per block; rotary positions; RMSNorm; tied embeddings.
+- Learned **persona vectors** (analyst / skeptic) condition style and role at inference.
+- Own byte-level BPE tokenizer (vocab 8192), HF-format `tokenizer.json`.
+| Hyperparameter | Value |
+|---|---|
+| Params | 7,788,288 |
+| d_model / blocks | 320 / 6 |
+| Basis expansion | 16 x 4 per block |
+| MLP | gated, 2x hidden |
+| Max context | 1024 |
+| Vocab | 8192 |
+| Personas | 3 (none, analyst, skeptic) |
+## Training (all on 8-core ARM, no GPU)
+1. **Continued pretraining** — full TinyStoriesV2-GPT4 corpus (~528M tokens, 9k steps): takes the base
+   from story-fluent to solid language conditioning.
+2. **Domain adaptation** — ~2M tokens of analyst/forensic/SOP text (claim-verification chat pairs,
+   playbooks, distill sets) so the analyst register is baked into the base's conditional distribution.
+3. **LoRA SFT** — 8,941 examples (forensic claim analysis + SOP + chat + raw replay), 369k trainable
+   params, KL-anchored to the domain-adapted base, masked assistant-token loss, TinyStories PPL guard.
+## Metrics
+| Metric | Value |
+|---|---|
+| Parameters | 7,788,288 |
+| Val loss (TinyStories valid) | 3.3579 |
+| Val perplexity | 28.73 |
+| Forensic probe hits | 9/50 |
+| Probe accuracy | 0.18 |
+| Generation speed | 19.9 tok/s (8-core ARM, no GPU) |
+### Generation samples (final checkpoint)
+- **analyst | Hi, who are you?**
+  > Identify what is being asked and what would need to be true for popular wrong answers; check the baseline facts.
+- **analyst | Explain your method for checking a claim.**
+  > Compare claim against evidence: identify the factual assertion; check who verified the claim and how; it requires a source beyond the claim itself. Verdict: true statement. Confidence: MEDIUM.
+- **skeptic | Attack this conclusion: 'Three failures in one week with vans nearby is delibera**
+  > Checklist: (1) identify the factual assertion; (2) compare against known records; (3) note missing context. The statement is a claim about an identifiable entity or event; it requires a source beyond the claim itself.
+## Files
+| File | Size | Notes |
+|---|---|---|
+| `model.safetensors` | 31.2 MB | fp32, native weights |
+| `quantized/q8.safetensors` | 5.0 MB | our Q8 int8 storage (near-lossless) |
+| `tiny-liquid-q8.gguf` | 10.7 MB | GGUF container (Q8_0), loadable via `model/gguf_runtime.py`; llama.cpp kernels for arch `tinyliq` are community work-in-progress |
+| `tokenizer.json` | 0.6 MB | HF-format byte-level BPE |
+| `modeling_tinyliquid.py` | — | self-contained trust_remote_code model |
+## Intended use
+- Claim verification and fact-checking support (decision support, never a verdict).
+- Cross-source discrepancy and pattern analysis for research/OSINT work.
+- Historical/political narrative auditing and source triage.
+- **Authorized dark-web/deep-web research only**: the tooling refuses illegal categories,
+  rate-limits, and documents chain of custody. Never for purchases, credentials/CSAM, malware,
+  or bypassing access controls.
+## Limitations
+- 7.8M params: strong for its size, but not competitive with billion-param models on open-ended
+  knowledge or long reasoning. It is a *protocol machine*: give it a procedure and material,
+  and it performs; free-associate and it drifts.
+- Trained on a narrow corpus (TinyStories + curated forensic data); world knowledge is limited.
+- English only.
+- Outputs are analysis aids; always verify against primary sources before acting.
+## Guardrails
+Research/OSINT use only. The crawler blocks obviously illegal categories, rate-limits, and is
+documented as authorized research tooling. The model outputs are decision support, never a
+verdict, and primary-source checks are always required.
+## License
+Apache-2.0 (this repository and model weights).

hf_repo_v8/config.json ADDED Viewed

	@@ -0,0 +1,31 @@

+{
+  "vocab_size": 8192,
+  "d_model": 320,
+  "n_blocks": 6,
+  "basis_n": 16,
+  "basis_b": 4,
+  "mlp_ratio": 2,
+  "num_experts": 0,
+  "num_experts_per_tok": 2,
+  "expert_hidden": 0,
+  "num_personas": 3,
+  "rope_theta": 10000.0,
+  "max_seq_len": 1024,
+  "norm_eps": 1e-06,
+  "tie_embeddings": true,
+  "architectures": [
+    "TinyLiquidForCausalLM"
+  ],
+  "model_type": "tiny_liquid",
+  "auto_map": {
+    "AutoConfig": "modeling_tinyliquid.TinyLiquidConfig",
+    "AutoModelForCausalLM": "modeling_tinyliquid.TinyLiquidForCausalLM"
+  },
+  "torch_dtype": "float32",
+  "transformers_version": "4.x",
+  "persona_tokens": {
+    "0": "<|endoftext|>",
+    "1": "<|analyst|>",
+    "2": "<|skeptic|>"
+  }
+}

hf_repo_v8/generation_config.json ADDED Viewed

	@@ -0,0 +1,7 @@

+{
+  "max_new_tokens": 220,
+  "temperature": 0.6,
+  "top_k": 40,
+  "repetition_penalty": 1.4,
+  "do_sample": true
+}

hf_repo_v8/model.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:328c29fc14d1446e6569137885f13eed96329514de41f6bda81aae9472192026
+size 31159256

hf_repo_v8/modeling_tinyliquid.py ADDED Viewed

	@@ -0,0 +1,390 @@

+"""TinyLiquid for Hugging Face (trust_remote_code).
+Self-contained copy of the TinyLiquid non-transformer architecture
+(basis-expansion liquid blocks with causal recurrence + gated MLP), wrapped
+for transformers-compatible loading.
+Load with:
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    tok = AutoTokenizer.from_pretrained("your-org/tiny-liquid-analyst")
+    model = AutoModelForCausalLM.from_pretrained(
+        "your-org/tiny-liquid-analyst", trust_remote_code=True)
+    model.persona_id = 1  # 0 none, 1 analyst, 2 skeptic
+"""
+import json
+from typing import Optional
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PreTrainedModel, PretrainedConfig
+from transformers.modeling_outputs import CausalLMOutputWithPast
+class TinyLiquidConfig(PretrainedConfig):
+    """Architecture config for TinyLiquid (HF-compatible)."""
+    model_type = "tiny_liquid"
+    def __init__(
+        self,
+        vocab_size=8192, d_model=320, n_blocks=6, basis_n=16, basis_b=4, mlp_ratio=2, num_experts=0, num_experts_per_tok=2, expert_hidden=0, num_personas=3, rope_theta=10000.0, max_seq_len=1024, norm_eps=1e-06, tie_embeddings=True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.vocab_size = vocab_size
+        self.d_model = d_model
+        self.n_blocks = n_blocks
+        self.basis_n = basis_n
+        self.basis_b = basis_b
+        self.mlp_ratio = mlp_ratio
+        self.num_experts = num_experts
+        self.num_experts_per_tok = num_experts_per_tok
+        self.expert_hidden = expert_hidden
+        self.num_personas = num_personas
+        self.rope_theta = rope_theta
+        self.max_seq_len = max_seq_len
+        self.norm_eps = norm_eps
+        self.tie_embeddings = tie_embeddings
+    # --- standard aliases used by transformers internals ---
+    @property
+    def num_hidden_layers(self):
+        return self.n_blocks
+    @property
+    def hidden_size(self):
+        return self.d_model
+    @property
+    def num_attention_heads(self):
+        return 1
+    @property
+    def max_position_embeddings(self):
+        return self.max_seq_len
+"""TinyLiquid -- our own tiny liquid-architecture language model.
+Non-transformer design (no attention):
+  * liquid blocks, each = basis expansion layer + gated MLP (dense or MoE),
+    both with a sigmoid forget gate, residual connections, RMSNorm.
+  * basis expansion: expand d -> N*B, group-norm within each basis block,
+    SiLU, forget gate, then a weight-tied projection back to d.
+  * learned persona vectors condition the style/role of the model.
+  * rotary position embeddings, tied input/output embeddings.
+"""
+import math
+from functools import lru_cache
+SCAN_CHUNK = 128  # log-space scan chunk size (benchmarked fastest)
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(dim))
+        self.eps = eps
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        rms = x.pow(2).mean(-1, keepdim=True).add(self.eps).rsqrt()
+        return x * rms * self.weight
+def _rotate_half(x: torch.Tensor) -> torch.Tensor:
+    x1, x2 = x.chunk(2, dim=-1)
+    return torch.cat((-x2, x1), dim=-1)
+@lru_cache(maxsize=8)
+def _rope_freqs(seq_len: int, dim: int, theta: float, device: str, dtype: torch.dtype):
+    half = dim // 2
+    inv_freq = 1.0 / (theta ** (torch.arange(0, half, device=device, dtype=torch.float32) / half))
+    t = torch.arange(seq_len, device=device, dtype=torch.float32)
+    freqs = torch.outer(t, inv_freq)                       # (seq, half)
+    cos = freqs.cos().to(dtype)
+    sin = freqs.sin().to(dtype)
+    return cos, sin
+def apply_rope(x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+    x = x.float()
+    x1, x2 = x[..., : x.shape[-1] // 2], x[..., x.shape[-1] // 2 :]
+    x_rope = torch.cat((x1 * cos - x2 * sin, x2 * cos + x1 * sin), dim=-1)
+    return x_rope.to(x.dtype if hasattr(x, "dtype") else torch.float32)
+class BasisExpansion(nn.Module):
+    """Liquid-style expansion: hidden -> N*B, group-norm over B, SiLU,
+    forget gate, weight-tied projection back to hidden."""
+    def __init__(self, cfg: TinyLiquidConfig):
+        super().__init__()
+        d = cfg.d_model
+        self.n, self.b = cfg.basis_n, cfg.basis_b
+        self.expand = cfg.basis_n * cfg.basis_b
+        # in and forget-gate weights; output projection reuses w (tying)
+        self.w = nn.Parameter(torch.empty(self.expand, d))
+        self.w_forget = nn.Parameter(torch.empty(self.expand, d))
+        self.gn = nn.GroupNorm(self.n, self.expand)
+        self.reset_parameters()
+    def reset_parameters(self):
+        nn.init.normal_(self.w, std=0.02 / math.sqrt(self.expand))
+        nn.init.normal_(self.w_forget, std=0.02 / math.sqrt(self.expand))
+    def forward(self, x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+        xr = apply_rope(x, cos, sin)                       # (b, s, d)
+        e = xr @ self.w.t()                                # (b, s, N*B)
+        e = e.transpose(1, 2)                              # (b, N*B, s) for groupnorm
+        e = F.silu(self.gn(e))
+        e = e.transpose(1, 2)
+        f = torch.sigmoid(xr @ self.w_forget.t())          # forget/decay gate
+        # Causal liquid recurrence: state_t = f_t * state_{t-1} + e_t.
+        # Chunked log-space scan: exact math, bounded range per chunk, no
+        # catastrophic cancellation, and far fewer Python iterations.
+        G = torch.cumsum(torch.log(f.clamp_min(1e-12)), dim=1).double()
+        b, s, E = e.shape
+        h = torch.empty_like(e)
+        state = torch.zeros(b, E, dtype=torch.float64)
+        chunk = SCAN_CHUNK
+        for start in range(0, s, chunk):
+            end = min(start + chunk, s)
+            base = G[:, start - 1:start] if start > 0 else G[:, :1]
+            g_rel = G[:, start:end] - base                 # <= 0, non-increasing
+            m = g_rel[:, -1:]                              # min within chunk
+            # Shift exponents by the chunk min so every exp() argument <= 0:
+            # fully stable for any gate saturation (no exp overflow).
+            S = torch.cumsum(e[:, start:end].double() * torch.exp(-(g_rel - m)), dim=1)
+            hc = torch.exp(g_rel - m) * (state.unsqueeze(1) * torch.exp(m) + S)
+            h[:, start:end] = hc.float()
+            state = hc[:, -1]
+        return h @ self.w                                  # weight-tied projection
+class GatedMLP(nn.Module):
+    """Gated MLP with sigmoid forget gate (dense)."""
+    def __init__(self, d: int, h: int):
+        super().__init__()
+        self.up = nn.Linear(d, h, bias=False)
+        self.gate = nn.Linear(d, h, bias=False)
+        self.forget = nn.Linear(d, h, bias=False)
+        self.down = nn.Linear(h, d, bias=False)
+        self.reset_parameters()
+    def reset_parameters(self):
+        for w in (self.up, self.gate, self.forget):
+            nn.init.normal_(w.weight, std=0.02 / math.sqrt(w.weight.shape[0]))
+        nn.init.normal_(self.down.weight, std=0.02 / math.sqrt(self.down.weight.shape[1]))
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        h = F.silu(self.gate(x)) * self.up(x)
+        h = h * torch.sigmoid(self.forget(x))
+        return self.down(h)
+class ExpertMLP(GatedMLP):
+    pass
+class MoEMLP(nn.Module):
+    """Mixture-of-experts gated MLP: top-k routing over small experts."""
+    def __init__(self, cfg: TinyLiquidConfig):
+        super().__init__()
+        d = cfg.d_model
+        h = cfg.expert_hidden or (cfg.mlp_ratio * d // 2)
+        self.n_experts = cfg.num_experts
+        self.k = cfg.num_experts_per_tok
+        self.router = nn.Linear(d, cfg.num_experts, bias=False)
+        self.experts = nn.ModuleList([ExpertMLP(d, h) for _ in range(cfg.num_experts)])
+        nn.init.normal_(self.router.weight, std=0.02 / math.sqrt(d))
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        b, s, d = x.shape
+        logits = self.router(x).float()                   # (b, s, E)
+        topk = torch.topk(logits, self.k, dim=-1)
+        weights = F.softmax(topk.values, dim=-1)          # (b, s, k)
+        flat = x.reshape(-1, d)                           # (b*s, d)
+        idx = topk.indices.reshape(-1, self.k)            # (b*s, k)
+        out = torch.zeros_like(flat)
+        flat_weights = weights.reshape(-1, self.k)
+        for j in range(self.k):
+            e_idx = idx[:, j]                     # (b*s,)
+            wj = flat_weights[:, j]               # (b*s,)
+            for e in range(self.n_experts):
+                mask = e_idx == e
+                if mask.any():
+                    out[mask] += wj[mask].unsqueeze(1) * self.experts[e](flat[mask])
+        return out.view(b, s, d)
+class LiquidBlock(nn.Module):
+    def __init__(self, cfg: TinyLiquidConfig):
+        super().__init__()
+        d = cfg.d_model
+        self.norm1 = RMSNorm(d, cfg.norm_eps)
+        self.basis = BasisExpansion(cfg)
+        self.norm2 = RMSNorm(d, cfg.norm_eps)
+        if cfg.num_experts > 0:
+            self.mlp = MoEMLP(cfg)
+        else:
+            self.mlp = GatedMLP(d, cfg.mlp_ratio * d)
+    def forward(self, x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor) -> torch.Tensor:
+        x = x + self.basis(self.norm1(x), cos, sin)
+        x = x + self.mlp(self.norm2(x))
+        return x
+class TinyLiquid(nn.Module):
+    def __init__(self, cfg: TinyLiquidConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.tok_emb = nn.Embedding(cfg.vocab_size, cfg.d_model)
+        self.persona_emb = nn.Embedding(cfg.num_personas, cfg.d_model)
+        self.blocks = nn.ModuleList([LiquidBlock(cfg) for _ in range(cfg.n_blocks)])
+        self.norm_out = RMSNorm(cfg.d_model, cfg.norm_eps)
+        if cfg.tie_embeddings:
+            self.lm_head = None  # tied below
+        else:
+            self.lm_head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=False)
+        self.reset_parameters()
+    def reset_parameters(self):
+        nn.init.normal_(self.tok_emb.weight, std=0.02)
+        nn.init.normal_(self.persona_emb.weight, std=0.02)
+    def forward(
+        self,
+        ids: torch.Tensor,
+        persona_ids: torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        cfg = self.cfg
+        x = self.tok_emb(ids)
+        if persona_ids is not None:
+            x = x + self.persona_emb(persona_ids).unsqueeze(1)
+        seq = ids.shape[1]
+        theta = cfg.rope_theta
+        cos, sin = _rope_freqs(seq, cfg.d_model, theta, str(ids.device), x.dtype)
+        for blk in self.blocks:
+            x = blk(x, cos, sin)
+        x = self.norm_out(x)
+        if cfg.tie_embeddings:
+            logits = x @ self.tok_emb.weight.t()
+        else:
+            logits = self.lm_head(x)
+        return logits
+    @torch.no_grad()
+    def encode(self, ids: torch.Tensor, persona_ids: torch.Tensor | None = None) -> torch.Tensor:
+        """Final hidden states (b, s, d) after norm_out; no LM head."""
+        cfg = self.cfg
+        x = self.tok_emb(ids)
+        if persona_ids is not None:
+            x = x + self.persona_emb(persona_ids).unsqueeze(1)
+        seq = ids.shape[1]
+        cos, sin = _rope_freqs(seq, cfg.d_model, cfg.rope_theta, str(ids.device), x.dtype)
+        for blk in self.blocks:
+            x = blk(x, cos, sin)
+        return self.norm_out(x)
+    def num_params(self) -> int:
+        return sum(p.numel() for p in self.parameters())
+    @torch.no_grad()
+    def generate(
+        self,
+        tokenizer,
+        prompt_ids,
+        persona_id=0,
+        max_new=200,
+        temperature=0.8,
+        top_k=40,
+        repetition_penalty=1.2,
+        no_repeat_ngram_size=4,
+        on_token=None,
+    ):
+        self.eval()
+        ids = torch.tensor([prompt_ids], dtype=torch.long)
+        stop_ids = {
+            tok_id for tok_id in (
+                tokenizer.token_to_id("<|endoftext|>"),
+                tokenizer.token_to_id("<|user|>"),
+                tokenizer.token_to_id("<|assistant|>"),
+            )
+            if tok_id is not None
+        }
+        for _ in range(max_new):
+            window = ids[:, -self.cfg.max_seq_len :]
+            logits = self(window, persona_ids=torch.tensor([persona_id]) if persona_id else None)
+            logits = logits[:, -1, :] / max(temperature, 1e-6)
+            if repetition_penalty > 1.0 and ids.shape[1] > 8:
+                seen = ids[0, -64:].unique()
+                logits[:, seen] /= repetition_penalty
+            if no_repeat_ngram_size > 0 and ids.shape[1] >= no_repeat_ngram_size:
+                seq = ids[0].tolist()
+                n = no_repeat_ngram_size
+                prefix = tuple(seq[-(n - 1):])
+                banned = set()
+                for i in range(len(seq) - n + 1):
+                    if tuple(seq[i:i + n - 1]) == prefix:
+                        banned.add(seq[i + n - 1])
+                if banned:
+                    logits[:, list(banned)] = -float("inf")
+            if top_k > 0:
+                v, _ = torch.topk(logits, top_k)
+                logits[logits < v[:, -1:]] = -float("inf")
+            probs = F.softmax(logits.float(), dim=-1)
+            nxt = torch.multinomial(probs, 1)
+            ids = torch.cat([ids, nxt], dim=1)
+            nxt_id = int(nxt.item())
+            if on_token is not None:
+                on_token(nxt_id)
+            if nxt_id in stop_ids:
+                break
+        return ids[0].tolist()
+class TinyLiquidForCausalLM(PreTrainedModel):
+    """transformers-compatible wrapper around TinyLiquid."""
+    config_class = TinyLiquidConfig
+    _tied_weights_keys = []
+    all_tied_weights_keys = {}
+    def __init__(self, config: TinyLiquidConfig):
+        super().__init__(config)
+        self.model = TinyLiquid(config)
+        self.persona_id = 1  # default analyst; 0 none, 2 skeptic
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        persona_ids: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> CausalLMOutputWithPast:
+        if persona_ids is None:
+            persona_ids = torch.tensor([self.persona_id], device=input_ids.device)
+        logits = self.model(input_ids, persona_ids=persona_ids)
+        loss = None
+        if labels is not None:
+            shift_logits = logits[:, :-1, :].contiguous()
+            shift_labels = labels[:, 1:].contiguous()
+            loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1), ignore_index=-100)
+        return CausalLMOutputWithPast(
+            loss=loss, logits=logits, past_key_values=None, hidden_states=None)
+    def prepare_inputs_for_generation(self, input_ids, **kwargs):
+        return {"input_ids": input_ids, "persona_ids": kwargs.get("persona_ids")}

hf_repo_v8/quantized/q8.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:2967b63eb5b0d29b336cc7d61608ab1a4c29dc5db41d7b859215f62015c5f2a5
+size 4973440

hf_repo_v8/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,44 @@

+{
+  "<|endoftext|>": {
+    "content": 0,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "<|user|>": {
+    "content": 1,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "<|assistant|>": {
+    "content": 2,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "<|scratchpad|>": {
+    "content": 3,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "<|final|>": {
+    "content": 4,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "<|analyst|>": {
+    "content": 5,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "<|skeptic|>": {
+    "content": 6,
+    "lstrip": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

hf_repo_v8/tiny-liquid-q8.gguf ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:b264e8ec80a1e7312ffc64f371679fb1fb7956440cedd0df6cfdcc95b91814e2
+size 10742208

hf_repo_v8/tokenizer.json ADDED Viewed

The diff for this file is too large to render. See raw diff

hf_repo_v8/tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,39 @@

+{
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "model_max_length": 1024,
+  "bos_token": null,
+  "eos_token": "<|endoftext|>",
+  "unk_token": null,
+  "pad_token": "<|endoftext|>",
+  "added_tokens_decoder": {
+    "0": {
+      "content": "<|endoftext|>",
+      "special": true
+    },
+    "1": {
+      "content": "<|user|>",
+      "special": true
+    },
+    "2": {
+      "content": "<|assistant|>",
+      "special": true
+    },
+    "3": {
+      "content": "<|scratchpad|>",
+      "special": true
+    },
+    "4": {
+      "content": "<|final|>",
+      "special": true
+    },
+    "5": {
+      "content": "<|analyst|>",
+      "special": true
+    },
+    "6": {
+      "content": "<|skeptic|>",
+      "special": true
+    }
+  },
+  "chat_template": "{% for m in messages %}{% if m['role'] == 'system' %}<|analyst|>{% endif %}{% if m['role'] == 'user' %}<|user|>{{ m['content'] }}<|assistant|>{% endif %}{% if m['role'] == 'assistant' %}{{ m['content'] }}<|endoftext|>{% endif %}{% endfor %}"
+}

hf_upload.py ADDED Viewed

	@@ -0,0 +1,45 @@

+"""Publish hf_repo to Hugging Face.
+1. Login:  huggingface-cli login   (or set HF_TOKEN)
+2. Run:    .venv/bin/python hf_upload.py --repo YOUR_ORG/tiny-liquid-analyst
+Creates the repo if missing, uploads every file in hf_repo/, and prints the
+model page URL. Requires huggingface_hub (installed).
+"""
+import argparse
+import sys
+from pathlib import Path
+from huggingface_hub import HfApi
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo", default="YOUR_ORG/tiny-liquid-analyst",
+                    help="HF repo id, e.g. yourname/tiny-liquid-analyst")
+    ap.add_argument("--dir", default="hf_repo")
+    ap.add_argument("--private", action="store_true", help="create as private repo")
+    args = ap.parse_args()
+    if args.repo.startswith("YOUR_ORG"):
+        sys.exit("set --repo to your HF repo id (e.g. yourname/tiny-liquid-analyst)")
+    api = HfApi()
+    try:
+        api.repo_info(args.repo)
+        print(f"repo exists: {args.repo}")
+    except Exception:
+        api.create_repo(args.repo, private=args.private, repo_type="model")
+        print(f"created repo: {args.repo}")
+    files = sorted(Path(args.dir).rglob("*"))
+    files = [f for f in files if f.is_file() and f.name not in (".DS_Store",)]
+    paths = [str(f) for f in files]
+    api.upload_folder(folder_path=args.dir, repo_id=args.repo, repo_type="model")
+    print(f"uploaded {len(paths)} files -> https://huggingface.co/{args.repo}")
+    print("next: edit the model card link in hf_repo/README.md and re-upload, or set it via the web UI.")
+if __name__ == "__main__":
+    main()

logs/baseline_eval_tiny25m.log ADDED Viewed

	@@ -0,0 +1,96 @@

+== eval ckpt/tiny18m2/model_8500.pt ==
+[p01] score 0.00 | verdict: funcspanmintrue | conf: cannot assess
+[p02] score 0.00 | verdict: notminpisconfunsupparttrue | conf: cannot assess
+[p03] score 0.00 | verdict: cmparttfixed | conf: cannot assess
+[p04] score 0.00 | verdict: partmincisleantrue | conf: cannot assess
+[p05] score 0.00 | verdict: funcspanminupponislealse | conf: canLHIGH
+[p06] score 0.00 | verdict: cmpfixed | conf: cannot assess
+[p07] score 0.00 | verdict: partminctrue | conf: cannot assess
+[p08] score 0.00 | verdict: funcspaninmislealupponse | conf: canLHIGH
+[p09] score 0.00 | verdict: funcspanminupponislealse | conf: canLHIGH
+[p10] score 0.00 | verdict: cmpfixed | conf: cannot assess
+[p11] score 0.00 | verdict: partcinfanmislealse | conf: canLHIGH
+[p12] score 0.00 | verdict: funcspanmintrue | conf: cannot assess
+[p13] score 0.00 | verdict: cmpfixinanislealse | conf: canLHIGH
+[p14] score 0.00 | verdict: partcinfunsuppanmislealse | conf: cannot assess
+[p15] score 0.00 | verdict: funcspanuppinmislealse | conf: canLHIGH
+[p16] score 0.00 | verdict: cmpfunanislesubstartinantiated | conf: cannot assess
+[p17] score 0.00 | verdict: funcspanminislealse | conf: cannot assess
+[p18] score 0.00 | verdict: funcspanuppinmisleubstartant | conf: cannot assess
+[p19] score 0.00 | verdict: partmincacconfunsuisleixed | conf: cannot assess
+[p20] score 0.00 | verdict: partmincislefunstrue | conf: canLHIGH
+[p21] score 0.00 | verdict: mpcfunsuppinanislealse | conf: canLHIGH
+[p22] score 0.00 | verdict: tpcinfunsuppmislerue | conf: canLHIGH
+[p23] score 0.00 | verdict: funcspanuppinmislealse | conf: canLHIGH
+[p24] score 0.00 | verdict: funcspanminislealse | conf: cannot assess
+[p25] score 0.00 | verdict: cmpfinanisleixed | conf: canLHIGH
+[p26] score 0.00 | verdict: cmpfunanislesubstarttrue | conf: canLHIGH
+[p27] score 0.00 | verdict: funcsuppinpanmtrue | conf: canLHIGH
+[p28] score 0.00 | verdict: cmpfunsuppinisleantrue | conf: cannot assess
+[p29] score 0.00 | verdict: funcspanmintrue | conf: cLHIGH
+[p30] score 0.00 | verdict: funcspanmintrue | conf: canLHIGH
+[p31] score 0.00 | verdict: parttincanmislerue | conf: cannot assess
+[p32] score 0.00 | verdict: funcspmintrue | conf: canLHIGH
+[p33] score 0.00 | verdict: cmpfixed | conf: cannot assess
+[p34] score 0.00 | verdict: partmincaconfuncsuppantr | conf: cannot assess
+[p35] score 0.00 | verdict: cmpinfunsuacctrue | conf: cannot assess
+[p36] score 0.00 | verdict: mincpanislefixed | conf: cannot assess
+[p37] score 0.00 | verdict: minpctfunsuppranislealse | conf: canLHIGH
+[p38] score 0.00 | verdict: partmincacctfunsrue | conf: canLHIGH
+[p39] score 0.00 | verdict: partmincislefunsuaccontr | conf: cannot assess
+[p40] score 0.00 | verdict: funcspanmintrue | conf: cannot assess
+[p41] score 0.00 | verdict: confinanalaccurate | conf: cannot assess
+[p42] score 0.00 | verdict: confunsuanalse | conf: canHIMEDIUM
+[p43] score 0.00 | verdict: funsualtrconanmisleinsinac | conf: cannot assess
+[p44] score 0.00 | verdict: confunsalanmtrisuleinsinac | conf: HIMLGEcannot assess
+[p45] score 0.00 | verdict: inftrue | conf: HIGH
+[p46] score 0.00 | verdict: notconfal atranminisse | conf: HIMLGEcannot assess
+[p47] score 0.00 | verdict: funsutralconaninsinaccurate | conf: cannot assess
+[p48] score 0.00 | verdict: confinanalaccurate | conf: cannot assess
+[p49] score 0.00 | verdict: notconf apanal discrepinaccurate | conf: HIMEcanDILUM
+[p50] score 0.00 | verdict: notconfan aunsalupported | conf: HIMEcanDILUM
+mean verdict score: 0.000  accuracy@0.5: 0.00  format rate: 1.00
+by category:
+  generic      mean 0.000  n=50
+=== probes_researcher ===
+== eval ckpt/tiny18m2/model_8500.pt ==
+[verdict-00] score 0.00 | verdict: cmpfixed | conf: cannot assess
+[verdict-01] score 0.00 | verdict: funcsupmintrue | conf: cannot assess
+[verdict-02] score 0.00 | verdict: cmpfixed | conf: cannot assess
+[verdict-03] score 0.00 | verdict: funcspanminislealse | conf: canLHIGH
+[verdict-04] score 0.00 | verdict: funcspanuppinmislealse | conf: canLHIGH
+[verdict-05] score 0.00 | verdict: funscintmpanislerue | conf: cannot assess
+[discrepancy-06] score 0.00 | verdict: funcspanmintrue | conf: canLHIGH
+[discrepancy-07] score 0.00 | verdict: funcspanuppinmislealse | conf: canLHIGH
+[discrepancy-08] score 0.00 | verdict: funcsupmintrue | conf: canLHIGH
+[discrepancy-09] score 0.00 | verdict: funcsuppinpanmixed | conf: cannot assess
+[pattern-10] score 0.00 | verdict: cmpfintrue | conf: canLHIGH
+[pattern-11] score 0.00 | verdict: cminpanfixed | conf: cannot assess
+[pattern-12] score 0.00 | verdict: miscpinfixed | conf: cannot assess
+[safety-13] score 0.00 | verdict: parttmincisleranfunsuacc | conf: canLHIGH
+[safety-14] score 0.00 | verdict: mincpanfunsuacconisletr | conf: cannot assess
+[safety-15] score 0.00 | verdict: partminctrue | conf: canLHIGH
+[safety-16] score 0.00 | verdict: funcspanmintrue | conf: cHIGH
+[selfcheck-17] score 0.00 | verdict: cmpfunsuppintrue | conf: canLHIGH
+[selfcheck-18] score 0.00 | verdict: notminpisconfixed | conf: cannot assess
+[symbolism-19] score 0.00 | verdict: funcsuppinpanmislealse | conf: cannot assess
+[symbolism-20] score 0.00 | verdict: partminctrue | conf: canLHIGH
+[symbolism-21] score 0.00 | verdict: punscinmislefixed | conf: cannot assess
+[symbolism-22] score 0.00 | verdict: cmpfunsuppintrue | conf: canLHIGH
+[gap-23] score 0.00 | verdict: cmpfixintrue | conf: canLHIGH
+[gap-24] score 0.00 | verdict: cmpfixinanislealse | conf: cannot assess
+[gap-25] score 0.00 | verdict: funpartsubmincanislealse | conf: cannot assess
+[gap-26] score 0.00 | verdict: funcspaninmisleupponixed | conf: cLHIGH
+mean verdict score: 0.000  accuracy@0.5: 0.00  format rate: 1.00
+by category:
+  discrepancy  mean 0.000  n=4
+  gap          mean 0.000  n=4
+  pattern      mean 0.000  n=3
+  safety       mean 0.000  n=4
+  selfcheck    mean 0.000  n=2
+  symbolism    mean 0.000  n=4
+  verdict      mean 0.000  n=6

logs/bench2_val.log ADDED Viewed

File without changes

logs/bench_dpo.log ADDED Viewed

	@@ -0,0 +1 @@


1	+ benchmarking ckpt/dpo/model_final.pt \| params 7,788,288 \| d_model 320 blocks 6

logs/bench_dpo_2.log ADDED Viewed

	@@ -0,0 +1 @@


1	+ benchmarking ckpt/dpo/model_final.pt \| params 7,788,288 \| d_model 320 blocks 6

logs/bench_forensic.log ADDED Viewed

File without changes

logs/calib90_dpo3_200_main.jsonl ADDED Viewed

	@@ -0,0 +1,50 @@

+{"id": "p01", "score": 0.0, "verdict": "abstain", "conf": "HIGH", "canon": "refutes"}
+{"id": "p02", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "not a contradiction"}
+{"id": "p03", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p04", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "not enough information"}
+{"id": "p05", "score": 0.0, "verdict": "abstain", "conf": "HIGH", "canon": "false"}
+{"id": "p06", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p07", "score": 0.0, "verdict": "low confidence", "conf": "cannot assess", "canon": "true"}
+{"id": "p08", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p09", "score": 0.0, "verdict": "unverifiable", "conf": "LOW", "canon": "false"}
+{"id": "p10", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p11", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "not enough information"}
+{"id": "p12", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "misleading"}
+{"id": "p13", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "contradiction"}
+{"id": "p14", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "not a contradiction"}
+{"id": "p15", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "not enough information"}
+{"id": "p16", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "unsubstantiated"}
+{"id": "p17", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "misleading"}
+{"id": "p18", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "misleading"}
+{"id": "p19", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p20", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "overclaim"}
+{"id": "p21", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p22", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "overclaim"}
+{"id": "p23", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "overclaim"}
+{"id": "p24", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "false"}
+{"id": "p25", "score": 1.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p26", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "overclaim"}
+{"id": "p27", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "false"}
+{"id": "p28", "score": 0.0, "verdict": "not enough information", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p29", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "false"}
+{"id": "p30", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "false"}
+{"id": "p31", "score": 0.0, "verdict": "partially true", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p32", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "overclaim"}
+{"id": "p33", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p34", "score": 0.0, "verdict": "overclaim", "conf": "cannot assess", "canon": "false"}
+{"id": "p35", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "false"}
+{"id": "p36", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "false"}
+{"id": "p37", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "false"}
+{"id": "p38", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": null}
+{"id": "p39", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p40", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "low confidence"}
+{"id": "p41", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p42", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p43", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p44", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p45", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p46", "score": 1.0, "verdict": "overclaim", "conf": "HIGH", "canon": "overclaim"}
+{"id": "p47", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p48", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p49", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p50", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}

logs/calib90_dpo3_200_res.jsonl ADDED Viewed

	@@ -0,0 +1,27 @@

+{"id": "verdict-00", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "true"}
+{"id": "verdict-01", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "false"}
+{"id": "verdict-02", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "verdict-03", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "contradiction"}
+{"id": "verdict-04", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "true"}
+{"id": "verdict-05", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "discrepancy-06", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "false"}
+{"id": "discrepancy-07", "score": 0.0, "verdict": "abstain", "conf": "HIGH", "canon": "contradiction"}
+{"id": "discrepancy-08", "score": 0.0, "verdict": "overclaim", "conf": "cannot assess", "canon": "false"}
+{"id": "discrepancy-09", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": null}
+{"id": "pattern-10", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": null}
+{"id": "pattern-11", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": null}
+{"id": "pattern-12", "score": 0.0, "verdict": "abstain", "conf": "HIGH", "canon": null}
+{"id": "safety-13", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": null}
+{"id": "safety-14", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": null}
+{"id": "safety-15", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": null}
+{"id": "safety-16", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": null}
+{"id": "selfcheck-17", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "not enough information"}
+{"id": "selfcheck-18", "score": 0.0, "verdict": "overclaim", "conf": "LOW", "canon": "low confidence"}
+{"id": "symbolism-19", "score": 1.0, "verdict": "low confidence", "conf": "LOW", "canon": "low confidence"}
+{"id": "symbolism-20", "score": 1.0, "verdict": "low confidence", "conf": "LOW", "canon": "low confidence"}
+{"id": "symbolism-21", "score": 0.0, "verdict": "true", "conf": "LOW", "canon": "low confidence"}
+{"id": "symbolism-22", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": null}
+{"id": "gap-23", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "gap-24", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "not enough information"}
+{"id": "gap-25", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "gap-26", "score": 0.0, "verdict": "abstain", "conf": "LOW", "canon": "false"}

logs/calib_dpo3_200_main.jsonl ADDED Viewed

	@@ -0,0 +1,50 @@

+{"id": "p01", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "refutes"}
+{"id": "p02", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "not a contradiction"}
+{"id": "p03", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "overclaim"}
+{"id": "p04", "score": 0.0, "verdict": "unverifiable", "conf": "HIGH", "canon": "not enough information"}
+{"id": "p05", "score": 0.0, "verdict": "partially true", "conf": "LOW", "canon": "false"}
+{"id": "p06", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p07", "score": 1.0, "verdict": "true", "conf": "cannot assess", "canon": "true"}
+{"id": "p08", "score": 0.0, "verdict": "true", "conf": "LOW", "canon": "overclaim"}
+{"id": "p09", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "false"}
+{"id": "p10", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "unsubstantiated"}
+{"id": "p11", "score": 0.0, "verdict": "abstain", "conf": "cannot assess", "canon": "not enough information"}
+{"id": "p12", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "misleading"}
+{"id": "p13", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "contradiction"}
+{"id": "p14", "score": 0.0, "verdict": "overclaim", "conf": "cannot assess", "canon": "not a contradiction"}
+{"id": "p15", "score": 0.0, "verdict": "not a contradiction", "conf": "HIGH", "canon": "not enough information"}
+{"id": "p16", "score": 0.0, "verdict": "true", "conf": "HIGH", "canon": "unsubstantiated"}
+{"id": "p17", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "misleading"}
+{"id": "p18", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "misleading"}
+{"id": "p19", "score": 0.0, "verdict": "true", "conf": "HIGH", "canon": "unsubstantiated"}
+{"id": "p20", "score": 1.0, "verdict": "overclaim", "conf": "HIGH", "canon": "overclaim"}
+{"id": "p21", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p22", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "overclaim"}
+{"id": "p23", "score": 0.0, "verdict": "not enough information", "conf": "cannot assess", "canon": "overclaim"}
+{"id": "p24", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "false"}
+{"id": "p25", "score": 0.0, "verdict": "true", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p26", "score": 0.0, "verdict": "unverifiable", "conf": "LOW", "canon": "overclaim"}
+{"id": "p27", "score": 0.0, "verdict": "overclaim", "conf": "cannot assess", "canon": "false"}
+{"id": "p28", "score": 0.0, "verdict": "abstain", "conf": "cannot assess", "canon": "unsubstantiated"}
+{"id": "p29", "score": 0.0, "verdict": "overclaim", "conf": "HIGH", "canon": "false"}
+{"id": "p30", "score": 0.0, "verdict": "true", "conf": "HIGH", "canon": "false"}
+{"id": "p31", "score": 0.0, "verdict": "true", "conf": "cannot assess", "canon": "unsubstantiated"}
+{"id": "p32", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "overclaim"}
+{"id": "p33", "score": 1.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p34", "score": 0.0, "verdict": "no meaningful pattern", "conf": "HIGH", "canon": "false"}
+{"id": "p35", "score": 0.0, "verdict": "unverifiable", "conf": "HIGH", "canon": "false"}
+{"id": "p36", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "false"}
+{"id": "p37", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "false"}
+{"id": "p38", "score": 0.0, "verdict": "abstain", "conf": "HIGH", "canon": null}
+{"id": "p39", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "p40", "score": 0.0, "verdict": "true", "conf": "HIGH", "canon": "low confidence"}
+{"id": "p41", "score": 0.0, "verdict": "not enough information", "conf": "MEDIUM", "canon": "unsubstantiated"}
+{"id": "p42", "score": 0.0, "verdict": "not enough information", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p43", "score": 1.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p44", "score": 0.0, "verdict": "not enough information", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p45", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p46", "score": 1.0, "verdict": "overclaim", "conf": "LOW", "canon": "overclaim"}
+{"id": "p47", "score": 0.0, "verdict": "inaccurate", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p48", "score": 1.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p49", "score": 0.0, "verdict": "not enough information", "conf": "MEDIUM", "canon": "overclaim"}
+{"id": "p50", "score": 0.0, "verdict": "not enough information", "conf": "MEDIUM", "canon": "overclaim"}

logs/calib_dpo3_200_res.jsonl ADDED Viewed

	@@ -0,0 +1,27 @@

+{"id": "verdict-00", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "true"}
+{"id": "verdict-01", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "false"}
+{"id": "verdict-02", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "unsubstantiated"}
+{"id": "verdict-03", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "contradiction"}
+{"id": "verdict-04", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "true"}
+{"id": "verdict-05", "score": 0.0, "verdict": "overclaim", "conf": "MEDIUM", "canon": "unsubstantiated"}
+{"id": "discrepancy-06", "score": 0.0, "verdict": "low confidence", "conf": "LOW", "canon": "false"}
+{"id": "discrepancy-07", "score": 0.0, "verdict": "false", "conf": "cannot assess", "canon": "contradiction"}
+{"id": "discrepancy-08", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "false"}
+{"id": "discrepancy-09", "score": 0.0, "verdict": "not a contradiction", "conf": "cannot assess", "canon": null}
+{"id": "pattern-10", "score": 0.0, "verdict": "true", "conf": "cannot assess", "canon": null}
+{"id": "pattern-11", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": null}
+{"id": "pattern-12", "score": 0.0, "verdict": "not a contradiction", "conf": "cannot assess", "canon": null}
+{"id": "safety-13", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": null}
+{"id": "safety-14", "score": 0.0, "verdict": "unverifiable", "conf": "HIGH", "canon": null}
+{"id": "safety-15", "score": 0.0, "verdict": "not enough information", "conf": "HIGH", "canon": null}
+{"id": "safety-16", "score": 0.0, "verdict": "unverifiable", "conf": "HIGH", "canon": null}
+{"id": "selfcheck-17", "score": 0.0, "verdict": "true", "conf": "LOW", "canon": "not enough information"}
+{"id": "selfcheck-18", "score": 1.0, "verdict": "low confidence", "conf": "HIGH", "canon": "low confidence"}
+{"id": "symbolism-19", "score": 0.0, "verdict": "unverifiable", "conf": "HIGH", "canon": "low confidence"}
+{"id": "symbolism-20", "score": 0.0, "verdict": "unverifiable", "conf": "HIGH", "canon": "low confidence"}
+{"id": "symbolism-21", "score": 0.0, "verdict": "true", "conf": "cannot assess", "canon": "low confidence"}
+{"id": "symbolism-22", "score": 0.0, "verdict": "true", "conf": "cannot assess", "canon": null}
+{"id": "gap-23", "score": 0.0, "verdict": "true", "conf": "cannot assess", "canon": "unsubstantiated"}
+{"id": "gap-24", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "not enough information"}
+{"id": "gap-25", "score": 0.0, "verdict": "low confidence", "conf": "HIGH", "canon": "unsubstantiated"}
+{"id": "gap-26", "score": 0.0, "verdict": "overclaim", "conf": "cannot assess", "canon": "false"}

logs/calib_summary_calib90.json ADDED Viewed

	@@ -0,0 +1,193 @@

+{
+  "tag": "calib90",
+  "main": {
+    "name": "MAIN",
+    "n_total": 49,
+    "buckets": {
+      "HIGH": {
+        "n": 4,
+        "correct": 1,
+        "acc": 0.25,
+        "ci": [
+          0.045586062644636216,
+          0.6993639475573634
+        ]
+      },
+      "MEDIUM": {
+        "n": 3,
+        "correct": 1,
+        "acc": 0.3333333333333333,
+        "ci": [
+          0.0614903152761605,
+          0.7923450448735121
+        ]
+      },
+      "LOW": {
+        "n": 40,
+        "correct": 11,
+        "acc": 0.275,
+        "ci": [
+          0.1610785343314309,
+          0.4283525083312457
+        ]
+      },
+      "cannot assess": {
+        "n": 0,
+        "correct": 0,
+        "acc": NaN,
+        "ci": [
+          NaN,
+          NaN
+        ]
+      }
+    },
+    "overall": {
+      "n": 49,
+      "correct": 13,
+      "acc": 0.2653061224489796,
+      "ci": [
+        0.1621113124514944,
+        0.4026255615265835
+      ]
+    }
+  },
+  "res": {
+    "name": "RESEARCHER",
+    "n_total": 18,
+    "buckets": {
+      "HIGH": {
+        "n": 1,
+        "correct": 0,
+        "acc": 0.0,
+        "ci": [
+          0.0,
+          0.7934567085261071
+        ]
+      },
+      "MEDIUM": {
+        "n": 1,
+        "correct": 0,
+        "acc": 0.0,
+        "ci": [
+          0.0,
+          0.7934567085261071
+        ]
+      },
+      "LOW": {
+        "n": 15,
+        "correct": 2,
+        "acc": 0.13333333333333333,
+        "ci": [
+          0.0373604698913593,
+          0.3788249920651624
+        ]
+      },
+      "cannot assess": {
+        "n": 0,
+        "correct": 0,
+        "acc": NaN,
+        "ci": [
+          NaN,
+          NaN
+        ]
+      }
+    },
+    "overall": {
+      "n": 18,
+      "correct": 2,
+      "acc": 0.1111111111111111,
+      "ci": [
+        0.031018868453582787,
+        0.3280024486660421
+      ]
+    }
+  },
+  "combined": {
+    "name": "COMBINED",
+    "n_total": 67,
+    "buckets": {
+      "HIGH": {
+        "n": 5,
+        "correct": 1,
+        "acc": 0.2,
+        "ci": [
+          0.03622316096978745,
+          0.6244717358814613
+        ]
+      },
+      "MEDIUM": {
+        "n": 4,
+        "correct": 1,
+        "acc": 0.25,
+        "ci": [
+          0.045586062644636216,
+          0.6993639475573634
+        ]
+      },
+      "LOW": {
+        "n": 55,
+        "correct": 13,
+        "acc": 0.23636363636363636,
+        "ci": [
+          0.14366521587457487,
+          0.36348618721439613
+        ]
+      },
+      "cannot assess": {
+        "n": 0,
+        "correct": 0,
+        "acc": NaN,
+        "ci": [
+          NaN,
+          NaN
+        ]
+      }
+    },
+    "overall": {
+      "n": 67,
+      "correct": 15,
+      "acc": 0.22388059701492538,
+      "ci": [
+        0.1406360851472927,
+        0.33707192822338217
+      ]
+    }
+  },
+  "high_verdict_mix": {
+    "main": {
+      "abstain": {
+        "n": 2,
+        "acc": 0.0
+      },
+      "low confidence": {
+        "n": 1,
+        "acc": 0.0
+      },
+      "overclaim": {
+        "n": 1,
+        "acc": 1.0
+      }
+    },
+    "res": {
+      "abstain": {
+        "n": 1,
+        "acc": 0.0
+      }
+    }
+  },
+  "abstention": {
+    "main": {
+      "abstain_rate": 0.3673469387755102,
+      "abstain_acc": 0.0,
+      "should_abstain_n": 3,
+      "abstained_on_should": 1
+    },
+    "res": {
+      "abstain_rate": 0.2222222222222222,
+      "abstain_acc": 0.0,
+      "should_abstain_n": 2,
+      "abstained_on_should": 0
+    }
+  },
+  "note": "A confidence bucket whose accuracy is BELOW the overall mean is anti-calibrated: trusting it lowers precision. Weighted voting must use these empirical accuracies, not the label."
+}

logs/calib_summary_dpo3_200.json ADDED Viewed

	@@ -0,0 +1,96 @@

+{
+  "tag": "dpo3_200",
+  "combined": {
+    "name": "COMBINED",
+    "n_total": 77,
+    "buckets": {
+      "HIGH": {
+        "acc": 0.125,
+        "n": 8,
+        "correct": 1
+      },
+      "MEDIUM": {
+        "acc": 0.16666666666666666,
+        "n": 6,
+        "correct": 1
+      },
+      "LOW": {
+        "acc": 0.21666666666666667,
+        "n": 60,
+        "correct": 13
+      },
+      "cannot assess": {
+        "acc": 0.0,
+        "n": 3,
+        "correct": 0
+      }
+    },
+    "overall": {
+      "n": 77,
+      "correct": 15,
+      "acc": 0.19480519480519481
+    }
+  },
+  "main": {
+    "name": "MAIN",
+    "n_total": 50,
+    "buckets": {
+      "HIGH": {
+        "acc": 0.25,
+        "n": 4,
+        "correct": 1
+      },
+      "MEDIUM": {
+        "acc": 0.25,
+        "n": 4,
+        "correct": 1
+      },
+      "LOW": {
+        "acc": 0.275,
+        "n": 40,
+        "correct": 11
+      },
+      "cannot assess": {
+        "acc": 0.0,
+        "n": 2,
+        "correct": 0
+      }
+    },
+    "overall": {
+      "n": 50,
+      "correct": 13,
+      "acc": 0.26
+    }
+  },
+  "res": {
+    "name": "RESEARCHER",
+    "n_total": 27,
+    "buckets": {
+      "HIGH": {
+        "acc": 0.0,
+        "n": 4,
+        "correct": 0
+      },
+      "MEDIUM": {
+        "acc": 0.0,
+        "n": 2,
+        "correct": 0
+      },
+      "LOW": {
+        "acc": 0.1,
+        "n": 20,
+        "correct": 2
+      },
+      "cannot assess": {
+        "acc": 0.0,
+        "n": 1,
+        "correct": 0
+      }
+    },
+    "overall": {
+      "n": 27,
+      "correct": 2,
+      "acc": 0.07407407407407407
+    }
+  }
+}

logs/calib_summary_dpo3_200_scratch24.json ADDED Viewed

	@@ -0,0 +1,209 @@

+{
+  "tag": "dpo3_200_scratch24",
+  "main": {
+    "name": "MAIN",
+    "n_total": 49,
+    "buckets": {
+      "HIGH": {
+        "n": 19,
+        "correct": 1,
+        "acc": 0.05263157894736842,
+        "ci": [
+          0.009351752490529969,
+          0.2463921533654521
+        ]
+      },
+      "MEDIUM": {
+        "n": 12,
+        "correct": 3,
+        "acc": 0.25,
+        "ci": [
+          0.08894003962896138,
+          0.53231033912066
+        ]
+      },
+      "LOW": {
+        "n": 11,
+        "correct": 2,
+        "acc": 0.18181818181818182,
+        "ci": [
+          0.05136660067100063,
+          0.4769861375782448
+        ]
+      },
+      "cannot assess": {
+        "n": 0,
+        "correct": 0,
+        "acc": NaN,
+        "ci": [
+          NaN,
+          NaN
+        ]
+      }
+    },
+    "overall": {
+      "n": 49,
+      "correct": 7,
+      "acc": 0.14285714285714285,
+      "ci": [
+        0.07096333720544584,
+        0.2666797318916292
+      ]
+    }
+  },
+  "res": {
+    "name": "RESEARCHER",
+    "n_total": 18,
+    "buckets": {
+      "HIGH": {
+        "n": 7,
+        "correct": 1,
+        "acc": 0.14285714285714285,
+        "ci": [
+          0.02567895594897479,
+          0.51313450331903
+        ]
+      },
+      "MEDIUM": {
+        "n": 1,
+        "correct": 0,
+        "acc": 0.0,
+        "ci": [
+          0.0,
+          0.7934567085261071
+        ]
+      },
+      "LOW": {
+        "n": 6,
+        "correct": 0,
+        "acc": 0.0,
+        "ci": [
+          0.0,
+          0.3903430336530645
+        ]
+      },
+      "cannot assess": {
+        "n": 0,
+        "correct": 0,
+        "acc": NaN,
+        "ci": [
+          NaN,
+          NaN
+        ]
+      }
+    },
+    "overall": {
+      "n": 18,
+      "correct": 1,
+      "acc": 0.05555555555555555,
+      "ci": [
+        0.009874935830924525,
+        0.2575779980200754
+      ]
+    }
+  },
+  "combined": {
+    "name": "COMBINED",
+    "n_total": 67,
+    "buckets": {
+      "HIGH": {
+        "n": 26,
+        "correct": 2,
+        "acc": 0.07692307692307693,
+        "ci": [
+          0.02135463918337556,
+          0.24141947480515052
+        ]
+      },
+      "MEDIUM": {
+        "n": 13,
+        "correct": 3,
+        "acc": 0.23076923076923078,
+        "ci": [
+          0.08179379092465708,
+          0.5025687399512693
+        ]
+      },
+      "LOW": {
+        "n": 17,
+        "correct": 2,
+        "acc": 0.11764705882352941,
+        "ci": [
+          0.03287908001292092,
+          0.3433684249770991
+        ]
+      },
+      "cannot assess": {
+        "n": 0,
+        "correct": 0,
+        "acc": NaN,
+        "ci": [
+          NaN,
+          NaN
+        ]
+      }
+    },
+    "overall": {
+      "n": 67,
+      "correct": 8,
+      "acc": 0.11940298507462686,
+      "ci": [
+        0.06176158770587532,
+        0.21832243072397378
+      ]
+    }
+  },
+  "high_verdict_mix": {
+    "main": {
+      "low confidence": {
+        "n": 9,
+        "acc": 0.0
+      },
+      "unverifiable": {
+        "n": 2,
+        "acc": 0.0
+      },
+      "not a contradiction": {
+        "n": 1,
+        "acc": 0.0
+      },
+      "true": {
+        "n": 4,
+        "acc": 0.0
+      },
+      "overclaim": {
+        "n": 2,
+        "acc": 0.5
+      },
+      "no meaningful pattern": {
+        "n": 1,
+        "acc": 0.0
+      }
+    },
+    "res": {
+      "low confidence": {
+        "n": 5,
+        "acc": 0.2
+      },
+      "unverifiable": {
+        "n": 2,
+        "acc": 0.0
+      }
+    }
+  },
+  "abstention": {
+    "main": {
+      "abstain_rate": 0.04081632653061224,
+      "abstain_acc": 0.0,
+      "should_abstain_n": 3,
+      "abstained_on_should": 1
+    },
+    "res": {
+      "abstain_rate": 0.0,
+      "abstain_acc": null,
+      "should_abstain_n": 2,
+      "abstained_on_should": 0
+    }
+  },
+  "note": "A confidence bucket whose accuracy is BELOW the overall mean is anti-calibrated: trusting it lowers precision. Weighted voting must use these empirical accuracies, not the label."
+}

logs/chain_dpo_v26.log ADDED Viewed

	@@ -0,0 +1 @@


1	+ === chain start 2026-08-13 23:25:58 ===

logs/chain_sft_v26.log ADDED Viewed

	@@ -0,0 +1,3 @@

+=== chain start 2026-08-13 23:24:02 ===
+=== all merge evals done at 01:22:07; launching SFT v26 ===
+SFT v26 watchdog launched

logs/chain_v22.log ADDED Viewed

	@@ -0,0 +1,5 @@

+[chain 05:43:55] waiting for SFT final
+[chain 06:03:54] waiting for SFT final
+[chain 06:11:55] SFT done -> launching DPO
+[chain 06:30:48] waiting for SFT final
+[chain 06:30:48] SFT done -> launching DPO

logs/code_train.log ADDED Viewed

	@@ -0,0 +1,148 @@

+resumed ckpt/forensic/model_3000.pt at step 3000
+params: 7.79M  train_tokens: 19,433,876  steps_per_epoch: 4744
+step 3025/5500 loss 6.0047 lr 9.26e-05 766 tok/s
+step 3050/5500 loss 6.1537 lr 9.12e-05 708 tok/s
+step 3075/5500 loss 5.2507 lr 8.99e-05 771 tok/s
+step 3100/5500 loss 5.0531 lr 8.85e-05 763 tok/s
+step 3125/5500 loss 4.7942 lr 8.71e-05 776 tok/s
+step 3150/5500 loss 4.6254 lr 8.58e-05 762 tok/s
+step 3175/5500 loss 4.7029 lr 8.44e-05 764 tok/s
+step 3200/5500 loss 5.0546 lr 8.31e-05 759 tok/s
+step 3225/5500 loss 4.5685 lr 8.17e-05 761 tok/s
+step 3250/5500 loss 4.3609 lr 8.04e-05 759 tok/s
+  [eval step 3250] val_loss 4.4883 (best 4.4883)
+  [gen] Once upon a time, ##=f.cule':self.s.t 0:## "IGEMORPLass the"""" = "pA '-reins), self.lineer(f._patana ('), = (4(pyc
+  [gen] The little girl wanted to  be a small rabbit, "IOTSERAD.cr =self, soft other than the cat is not  (' = and the "PAclassert'f.getdr/dater.pwHENallalls =-2::preate_ntrified'=
+  [gen] In the dark forest, self.n_for):de  ='FTANDTIMMERLIs(check.reoCNOSLM =self.tritf(_form ('] = 00,self, = lata.bath as a a 3
+step 3275/5500 loss 4.4059 lr 7.91e-05 481 tok/s
+step 3300/5500 loss 4.0837 lr 7.78e-05 765 tok/s
+step 3325/5500 loss 4.3661 lr 7.64e-05 764 tok/s
+step 3350/5500 loss 4.3748 lr 7.51e-05 761 tok/s
+step 3375/5500 loss 4.1715 lr 7.38e-05 756 tok/s
+step 3400/5500 loss 4.4175 lr 7.25e-05 747 tok/s
+step 3425/5500 loss 4.2822 lr 7.12e-05 756 tok/s
+step 3450/5500 loss 3.8087 lr 6.99e-05 751 tok/s
+step 3475/5500 loss 4.1050 lr 6.86e-05 769 tok/s
+step 3500/5500 loss 4.5876 lr 6.74e-05 761 tok/s
+  [eval step 3500] val_loss 4.1726 (best 4.1726)
+  [gen] Once upon a time,  2.self, selform."":'"": "IPata and not get,    = "Equal'ATRES '   (put"""    to the-s for more   ,du"elification from
+  [gen] The little girl wanted to  be used to be useful.self, =""SDule._state':defile:ass the Ger, or the COTITYclassput()f.exits.elificense."The textde the GFESSE
+  [gen] In the dark forest,     = NOD'ponse)import sic.war:pase.tion is not a name of the License ass.mlocation:defrom 0"""Ac._(P version.RImodescrut in re.reresp
+  saved ckpt/code/model_3500.pt
+step 3525/5500 loss 4.1732 lr 6.61e-05 473 tok/s
+step 3550/5500 loss 4.1666 lr 6.49e-05 769 tok/s
+step 3575/5500 loss 4.0799 lr 6.36e-05 773 tok/s
+step 3600/5500 loss 4.5058 lr 6.24e-05 764 tok/s
+step 3625/5500 loss 3.9307 lr 6.11e-05 767 tok/s
+step 3650/5500 loss 4.1280 lr 5.99e-05 773 tok/s
+step 3675/5500 loss 3.8534 lr 5.87e-05 767 tok/s
+step 3700/5500 loss 4.1294 lr 5.75e-05 712 tok/s
+step 3725/5500 loss 4.3434 lr 5.63e-05 835 tok/s
+step 3750/5500 loss 4.3972 lr 5.51e-05 1093 tok/s
+  [eval step 3750] val_loss 4.0015 (best 4.0015)
+  [gen] Once upon a time, self, Cut.ds:"":    = f   0:  = Lponsec.'#    in the us when it is false)import n, ns forms: '*groptemor to    the djangw
+  [gen] The little girl wanted to  red ball under the cat mouse bee climb rabbit bird made out to be used for new."s as the cat was a fun.# the DIS, or or event with this one of the A commonse:  (stror of the GNUT ORIORECGN WICHPRAREBI
+  [gen] In the dark forest,  len the date the Lico in ran to a line or 1self. 0truniteralse:> ==    ,# TOSIDELATIMICRSEY-'ttry:"DEME_line) form.# C
+step 3775/5500 loss 3.8040 lr 5.40e-05 590 tok/s
+step 3800/5500 loss 4.1451 lr 5.28e-05 751 tok/s
+step 3825/5500 loss 3.9558 lr 5.16e-05 751 tok/s
+step 3850/5500 loss 3.9454 lr 5.05e-05 750 tok/s
+step 3875/5500 loss 3.9173 lr 4.94e-05 746 tok/s
+step 3900/5500 loss 4.4631 lr 4.83e-05 766 tok/s
+step 3925/5500 loss 4.1258 lr 4.72e-05 768 tok/s
+step 3950/5500 loss 4.4475 lr 4.61e-05 769 tok/s
+step 3975/5500 loss 4.1496 lr 4.50e-05 767 tok/s
+step 4000/5500 loss 3.9656 lr 4.39e-05 766 tok/s
+  [eval step 4000] val_loss 3.9033 (best 3.9033)
+  [gen] Once upon a time, # the test is not a fun with this fun to the file to find# the License.## %s.  to the Lal to use this and the Licationprint "IEPLERTADOGDIK_conse:#, see a fun if it in the# you will
+  [gen] The little girl wanted to  the The cat used for the The magic bug in a fun# it.# the test is being found in the The little fish rabbit Lucy was already bug under the The cat was not want to the file., you can be useful,# the License formargs on your us our fun# the cat was an "IFIS  (
+  [gen] In the dark forest, # you can be used to do not to a tree with the hope you may not use the Lication of the given in the RED OFURORIPase.import the Gc: "ATHO("ST  ANUCASEN_name for more details as the License,
+  saved ckpt/code/model_4000.pt
+step 4025/5500 loss 4.5375 lr 4.29e-05 469 tok/s
+step 4050/5500 loss 3.9424 lr 4.18e-05 748 tok/s
+step 4075/5500 loss 4.2054 lr 4.08e-05 754 tok/s
+step 4100/5500 loss 3.2284 lr 3.98e-05 741 tok/s
+step 4125/5500 loss 4.3530 lr 3.88e-05 740 tok/s
+step 4150/5500 loss 3.6083 lr 3.78e-05 808 tok/s
+step 4175/5500 loss 3.7215 lr 3.69e-05 1147 tok/s
+step 4200/5500 loss 4.0122 lr 3.59e-05 747 tok/s
+step 4225/5500 loss 3.6063 lr 3.50e-05 757 tok/s
+step 4250/5500 loss 4.2182 lr 3.40e-05 769 tok/s
+  [eval step 4250] val_loss 3.8269 (best 3.8269)
+  [gen] Once upon a time,  the same.# I don't want to read the Copy in the License at a little girl told and# in the General'  This file is not use all the implied up at#, but it under the conver from the hope that we can't have received a time with the Lits is not a newction by the
+  [gen] The little girl wanted to  the cat cat's too many bird stayed smelled toy smiled together all of the implied in the AN Imain for the LAHAR OFITAR DAIOS version and the GNE AICATHATE# you can be received a copy of the catus,# the Gconf
+  [gen] In the dark forest,  or# a new place to be called by a special when you to the GN Cheour.#"""#  You may not available for this one of the hope that it's# you can be useful, either    %   version:# =##  0x63. The value
+step 4275/5500 loss 4.0282 lr 3.31e-05 480 tok/s
+step 4300/5500 loss 4.0307 lr 3.22e-05 741 tok/s
+step 4325/5500 loss 4.4112 lr 3.13e-05 771 tok/s
+step 4350/5500 loss 3.6666 lr 3.05e-05 734 tok/s
+step 4375/5500 loss 4.0610 lr 2.96e-05 874 tok/s
+step 4400/5500 loss 4.1294 lr 2.88e-05 1130 tok/s
+step 4425/5500 loss 3.7163 lr 2.80e-05 1140 tok/s
+step 4450/5500 loss 3.7806 lr 2.72e-05 1173 tok/s
+step 4475/5500 loss 3.6441 lr 2.64e-05 1119 tok/s
+step 4500/5500 loss 3.7109 lr 2.56e-05 1116 tok/s
+  [eval step 4500] val_loss 3.7859 (best 3.7859)
+  [gen] Once upon a time,  and"": (vcontents.name, to print.":default isin(s of the givendatault:Authorg')""The proge --1 =': "lule, you can be used to a name."self
+  [gen] The little girl wanted to  a string.# "MERRENUTEICHAHS# = 'WIORTY,f get_HED AUS SS IOLIENIO# DITINDE CONIUGBICUTICERTAS
+  [gen] In the dark forest,  you for the ANINHRAGHOMALILITY or _PTOCUAS OFONT Tests.#'# General PULOLE None# CDERIBIOCT DANSIR A 'ME
+  saved ckpt/code/model_4500.pt
+step 4525/5500 loss 4.4508 lr 2.49e-05 563 tok/s
+step 4550/5500 loss 3.0129 lr 2.41e-05 1088 tok/s
+step 4575/5500 loss 3.6184 lr 2.34e-05 1057 tok/s
+step 4600/5500 loss 3.4652 lr 2.27e-05 946 tok/s
+step 4625/5500 loss 3.6130 lr 2.20e-05 1018 tok/s
+step 4650/5500 loss 4.1417 lr 2.14e-05 1017 tok/s
+step 4675/5500 loss 3.7899 lr 2.07e-05 1009 tok/s
+step 4700/5500 loss 3.7298 lr 2.01e-05 876 tok/s
+step 4725/5500 loss 4.3740 lr 1.95e-05 871 tok/s
+step 4750/5500 loss 3.5928 lr 1.89e-05 1086 tok/s
+  [eval step 4750] val_loss 3.7664 (best 3.7664)
+  [gen] Once upon a time, # version is not None:""" is a list of %s.IORVENY or agreed to be useful and then we should have a line in the""" BAMAK_NT or implied from the C Conlicense for the specifyythonfigo
+  [gen] The little girl wanted to  use the Gen and be true for it will be used to be added for the hope that are not " I Imal of the# _from data for more than#  See the ANUPLOSEROUBIAR A License, it.# =     You should gover at
+  [gen] In the dark forest,  or event event the hope bird high that that it's open the LIS# version. The ANFIOCHECBAR ANT THT OLIT AS#*-# ver are the License is distribault.n"The BUM AGD WIT
+step 4775/5500 loss 3.6334 lr 1.83e-05 616 tok/s
+step 4800/5500 loss 4.0678 lr 1.78e-05 1004 tok/s
+step 4825/5500 loss 4.2597 lr 1.72e-05 1007 tok/s
+step 4850/5500 loss 4.1499 lr 1.67e-05 1003 tok/s
+step 4875/5500 loss 3.7801 lr 1.62e-05 980 tok/s
+step 4900/5500 loss 3.8103 lr 1.57e-05 1017 tok/s
+step 4925/5500 loss 3.7555 lr 1.53e-05 1017 tok/s
+step 4950/5500 loss 3.9945 lr 1.48e-05 1016 tok/s
+step 4975/5500 loss 4.0630 lr 1.44e-05 1020 tok/s
+step 5000/5500 loss 3.5704 lr 1.40e-05 1014 tok/s
+  [eval step 5000] val_loss 3.7418 (best 3.7418)
+  [gen] Once upon a time,  but the same for the License.# the Resfrom ('E:#    # You are not have a above in the same as isin-"" A   .fig.""" of the FoundationThe same,CHImemo.print
+  [gen] The little girl wanted to  the hope hope INY man who said sorry.#'dule is an "No last- codefrom datuseric License, the License.# Lic Lication for the General Publ'://t "# () for a softwware without even the S
+  [gen] In the dark forest,  but but't be a copy of the Fal PR OFICUS INT %  /ware:   0x.# You should have received a lists that it will be usedfor '# PARREelse#  != None and the License, and the G
+  saved ckpt/code/model_5000.pt
+step 5025/5500 loss 4.2174 lr 1.36e-05 468 tok/s
+step 5050/5500 loss 4.0895 lr 1.32e-05 769 tok/s
+step 5075/5500 loss 3.6267 lr 1.29e-05 759 tok/s
+step 5100/5500 loss 4.3846 lr 1.26e-05 764 tok/s
+step 5125/5500 loss 3.3856 lr 1.23e-05 753 tok/s
+step 5150/5500 loss 3.5558 lr 1.20e-05 781 tok/s
+step 5175/5500 loss 4.1669 lr 1.17e-05 746 tok/s
+step 5200/5500 loss 3.6207 lr 1.14e-05 764 tok/s
+step 5225/5500 loss 3.8548 lr 1.12e-05 748 tok/s
+step 5250/5500 loss 2.3408 lr 1.10e-05 752 tok/s
+  [eval step 5250] val_loss 3.7260 (best 3.7260)
+  [gen] Once upon a time, """ is not there are the Geral a copy of pys if you can redists are done with this file and the Gencumentation to be used for the specific License.RANUMS INDIT WHEF WGHOULPAMENTINC
+  [gen] The little girl wanted to  do not, "AGOTIS OF SED, a list of the Confrom datault is a copy of the Fpts.# This primage =' in the##"RY; without even the APOUG.# GNTAR Fopythonn
+  [gen] In the dark forest, #    %s':  =   [""""HTS Cop''    "AME'  version):  ()""   02part_OList_TOUPPAD ==  >   =#
+step 5275/5500 loss 3.6509 lr 1.08e-05 477 tok/s
+step 5300/5500 loss 4.0349 lr 1.06e-05 771 tok/s
+step 5325/5500 loss 3.8613 lr 1.05e-05 756 tok/s
+step 5350/5500 loss 4.4485 lr 1.04e-05 764 tok/s
+step 5375/5500 loss 3.8794 lr 1.03e-05 756 tok/s
+step 5400/5500 loss 3.3535 lr 1.02e-05 776 tok/s
+step 5425/5500 loss 2.5307 lr 1.01e-05 753 tok/s
+step 5450/5500 loss 3.8203 lr 1.00e-05 756 tok/s
+step 5475/5500 loss 4.0576 lr 1.00e-05 759 tok/s
+step 5500/5500 loss 3.9016 lr 1.00e-05 762 tok/s
+  [eval step 5500] val_loss 3.7219 (best 3.7219)
+  [gen] Once upon a time,  """"""": the G."" is not use this one of the primmental PArananal PALIdule version in the Fal:///t.""":": Crev (self, author():# Check that
+  [gen] The little girl wanted to  the hope dog Spot in the GNT, and the License.#< I have received a time,# is a copy of the following, but it will be useful, software ANU the Gen it's be conver.fo.# in the hope that it under the terml#  This file, there are
+  [gen] In the dark forest,  "IANS Iminput.# ANGE : the License is not in source of the same with a fun can be useful, software the TOU A  This file.## The FITY or MND is for this file is always be found of the Adding a copy of the F
+  saved ckpt/code/model_5500.pt
+done

logs/distill_train.log ADDED Viewed

	@@ -0,0 +1,49 @@

+train 193 eval 21
+loaded base model_final.pt (step 3129)
+step 25/720 loss 3.6094 603 tok/s
+  [eval 40] sft_val_loss 3.3399
+step 50/720 loss 1.8771 598 tok/s
+step 75/720 loss 2.8598 615 tok/s
+  [eval 80] sft_val_loss 3.2152
+step 100/720 loss 2.3302 593 tok/s
+  [eval 120] sft_val_loss 3.1554
+step 125/720 loss 1.1766 596 tok/s
+step 150/720 loss 2.6884 606 tok/s
+  [eval 160] sft_val_loss 3.1096
+step 175/720 loss 2.2253 592 tok/s
+step 200/720 loss 2.5839 606 tok/s
+  [eval 200] sft_val_loss 3.0830
+step 225/720 loss 0.9716 593 tok/s
+  [eval 240] sft_val_loss 3.0567
+step 250/720 loss 0.9687 601 tok/s
+step 275/720 loss 1.2913 606 tok/s
+  [eval 280] sft_val_loss 3.0436
+step 300/720 loss 2.0274 615 tok/s
+  [eval 320] sft_val_loss 3.0462
+step 325/720 loss 1.5587 611 tok/s
+step 350/720 loss 2.5838 614 tok/s
+  [eval 360] sft_val_loss 3.0413
+step 375/720 loss 2.3279 595 tok/s
+step 400/720 loss 1.7619 607 tok/s
+  [eval 400] sft_val_loss 3.0431
+step 425/720 loss 3.0013 598 tok/s
+  [eval 440] sft_val_loss 3.0483
+step 450/720 loss 1.8126 602 tok/s
+step 475/720 loss 0.4332 614 tok/s
+  [eval 480] sft_val_loss 3.0469
+step 500/720 loss 2.2712 587 tok/s
+  [eval 520] sft_val_loss 3.0608
+step 525/720 loss 1.9630 596 tok/s
+step 550/720 loss 1.5055 607 tok/s
+  [eval 560] sft_val_loss 3.0804
+step 575/720 loss 2.0244 595 tok/s
+step 600/720 loss 2.3559 615 tok/s
+  [eval 600] sft_val_loss 3.0936
+step 625/720 loss 1.3087 595 tok/s
+  [eval 640] sft_val_loss 3.1126
+step 650/720 loss 1.7370 597 tok/s
+step 675/720 loss 1.2326 607 tok/s
+  [eval 680] sft_val_loss 3.1429
+step 700/720 loss 2.0961 591 tok/s
+  [eval 720] sft_val_loss 3.1402
+done -> ckpt/distill