File size: 5,480 Bytes
489f5e9
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
"""
scripts/smoke_test.py

The exact checklist from the implementation prompt's Step 15, run end to
end against the REAL brain_0_2_30m.yaml config (not a toy config) and the
tokenizer trained on data/sample_corpus.txt. Every line below prints a
pass/fail rather than assuming success -- "report any failures honestly"
is a direct instruction, not just a nicety.

Run with:  PYTHONPATH=. python3 scripts/smoke_test.py
"""

from __future__ import annotations

import sys
import tempfile
from pathlib import Path

import torch

from brain.core.config import BrainConfig
from brain.model.brain_model import BrainForCausalLM
from brain.tokenizer.tokenizer import BrainTokenizer

REPO_ROOT = Path(__file__).resolve().parents[1]
CORPUS_PATH = str(REPO_ROOT / "data" / "sample_corpus.txt")
CONFIG_PATH = str(REPO_ROOT / "configs" / "model" / "brain_0_2_30m.yaml")

results: list[tuple[str, bool, str]] = []


def check(name: str, condition: bool, detail: str = "") -> None:
    results.append((name, condition, detail))
    status = "PASS" if condition else "FAIL"
    print(f"  [{status}] {name}" + (f" -- {detail}" if detail else ""))


def main() -> int:
    torch.manual_seed(0)

    print("=" * 70)
    print("Brain v0.2 — Smoke Test (Step 15 checklist, run against real config)")
    print("=" * 70)

    # --- Tokenizer ---------------------------------------------------------
    print("\n[Tokenizer]")
    tok = BrainTokenizer.train(CORPUS_PATH, vocab_size=2048, min_frequency=1)
    check("tokenizer trains", tok.vocab_size > 4)

    text = "Hello Brain"
    ids = tok.encode(text, add_special_tokens=False)
    decoded = tok.decode(ids)
    check("tokenizer encode/decode round-trip", decoded == text, f"{text!r} -> {decoded!r}")

    with tempfile.TemporaryDirectory() as tmp:
        tok_path = Path(tmp) / "tok.json"
        tok.save(tok_path)
        reloaded_tok = BrainTokenizer.from_file(tok_path)
        check("tokenizer save/load", reloaded_tok.vocab_size == tok.vocab_size)

    # --- Model instantiation -------------------------------------------------
    print("\n[Model]")
    config = BrainConfig.from_yaml(CONFIG_PATH)
    model = BrainForCausalLM(config)
    check("model instantiates from real brain_0_2_30m.yaml", True)

    param_counts = model.count_parameters()
    check(
        "parameter count matches audit calculation (26,944,896)",
        param_counts["total"] == 26_944_896,
        f"got {param_counts['total']:,}",
    )

    # --- Forward / backward --------------------------------------------------
    print("\n[Forward / backward]")
    prompt_ids = tok.encode(text, add_special_tokens=True)
    input_ids = torch.tensor([prompt_ids])
    out = model(input_ids)
    check(
        "forward pass produces correct logits shape",
        out["logits"].shape == (1, len(prompt_ids), config.vocab_size),
        f"got {tuple(out['logits'].shape)}",
    )

    out = model(input_ids, labels=input_ids.clone())
    check("loss computes and is finite", torch.isfinite(out["loss"]).item(), f"loss={out['loss'].item():.4f}")

    out["loss"].backward()
    grads_ok = all(p.grad is not None for p in model.parameters() if p.requires_grad)
    check("backward pass populates gradients on all trainable params", grads_ok)
    model.zero_grad()

    # --- Checkpointing ---------------------------------------------------------
    print("\n[Checkpointing]")
    with tempfile.TemporaryDirectory() as tmp:
        ckpt_path = Path(tmp) / "brain_v0_2.pt"
        model.save_checkpoint(ckpt_path, tokenizer_path=str(tok_path))
        check("checkpoint saves", ckpt_path.exists())

        reloaded_model = BrainForCausalLM.load_checkpoint(ckpt_path)
        model.eval()
        reloaded_model.eval()
        with torch.no_grad():
            out1 = model(input_ids)["logits"]
            out2 = reloaded_model(input_ids)["logits"]
        check("checkpoint loads with identical output", torch.allclose(out1, out2, atol=1e-6))

    # --- Generation + KV cache ----------------------------------------------
    print("\n[Generation / KV cache]")
    model.eval()
    torch.manual_seed(0)
    gen_nocache = model.generate(input_ids, max_new_tokens=10, temperature=0.0, use_cache=False)
    check("generation (no cache) runs and extends sequence", gen_nocache.shape[1] == input_ids.shape[1] + 10)

    torch.manual_seed(0)
    gen_cache = model.generate(input_ids, max_new_tokens=10, temperature=0.0, use_cache=True)
    check("generation (KV cache) runs and extends sequence", gen_cache.shape[1] == input_ids.shape[1] + 10)

    cache_matches = torch.equal(gen_nocache, gen_cache)
    check(
        "MANDATORY: cached generation token-for-token matches uncached",
        cache_matches,
        "STOP AND DEBUG per Step 10 if this fails" if not cache_matches else "",
    )

    generated_text = tok.decode(gen_cache[0].tolist())
    check("generated output decodes without crashing", isinstance(generated_text, str), repr(generated_text))

    # --- Summary ---------------------------------------------------------------
    print("\n" + "=" * 70)
    n_pass = sum(1 for _, ok, _ in results if ok)
    n_total = len(results)
    print(f"RESULT: {n_pass}/{n_total} checks passed")
    if n_pass != n_total:
        print("\nFAILURES:")
        for name, ok, detail in results:
            if not ok:
                print(f"  - {name}: {detail}")
        return 1
    print("=" * 70)
    return 0


if __name__ == "__main__":
    sys.exit(main())