File size: 4,887 Bytes
c2f861b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fc1c423
c2f861b
 
 
fc1c423
 
 
 
 
 
 
 
c2f861b
 
fc1c423
 
 
 
 
c2f861b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
#!/usr/bin/env python3
"""Generate notebooks/NOEON_TRAIN_GPU.ipynb — the GPU-host (Colab) run book.

Kept as a generator so the notebook is reproducible and diff-stable, exactly like
the NOEON_LAB notebooks. The notebook is honest: the first cell refuses to
proceed without a GPU, and it never prints a training result it did not produce.
"""

from __future__ import annotations

import json
from pathlib import Path

OUT = Path(__file__).resolve().parent.parent / "notebooks" / "NOEON_TRAIN_GPU.ipynb"
KERNEL = {"display_name": "Python 3", "language": "python", "name": "python3"}


def md(t):
    return {"cell_type": "markdown", "metadata": {}, "source": t.splitlines(True)}


def code(t):
    return {"cell_type": "code", "execution_count": None, "metadata": {},
            "outputs": [], "source": t.strip("\n").splitlines(True)}


CELLS = [
    md("""# NOEON — unified training on a GPU host (Colab)

This run book trains **NOEON's own parameters** — the bridge adapters, the
FusionCore and the GenerationHead — against the three **frozen** sources. The
sources are never modified.

It is honest by construction:

* the first cell **refuses to proceed without a GPU** (NOEON has no GPU in its
  development environment; this notebook is where the real training runs);
* it never prints a training result it did not produce;
* the frozen sources are loaded in eval mode with every parameter frozen.

If a cell prints "NO GPU DETECTED", nothing was trained — run this notebook on a
GPU runtime (Runtime â–¸ Change runtime type â–¸ GPU)."""),
    code("""# 1. Verify the GPU. This is the gate: no GPU, no training.
!nvidia-smi | head -12 || echo "NO GPU DETECTED"
import torch
print("cuda available:", torch.cuda.is_available())
if not torch.cuda.is_available():
    raise SystemExit("NO GPU DETECTED — switch the Colab runtime to a GPU and re-run.")
print("device:", torch.cuda.get_device_name(0))"""),
    code("""# 2. Dependencies
!pip -q install "torch>=2.2" transformers safetensors huggingface_hub pyyaml accelerate bitsandbytes"""),
    code("""# 3. Get NOEON from Hugging Face. The repo is PUBLIC — no token needed.
import os, pathlib, subprocess
ROOT = pathlib.Path("/content/NOEON")
if not ROOT.exists():
    # Skip the LFS smudge so the ~43.5 GB of weights are NOT pulled here:
    # this fetches code, configs and LFS *pointers* only (a few MB).
    env = dict(os.environ, GIT_LFS_SKIP_SMUDGE="1")
    subprocess.run(
        ["git", "clone", "https://huggingface.co/Frankenstein-Labs/NOEON", str(ROOT)],
        check=True, env=env,
    )
    subprocess.run(["git", "-C", str(ROOT), "lfs", "install", "--local"], check=False)
print("repo:", ROOT.exists())
os.chdir(ROOT)
# Fetch only the weights this run needs, e.g.:
#   !git lfs pull --include="weights/noeon-init/*"
#   !git lfs pull --include="weights/upstream/vision/*"
print("cwd:", os.getcwd())
!git lfs ls-files | wc -l"""),
    code("""# 4. Resource + dependency check before any big download
!python scripts/attach_sources.py | tail -25"""),
    code("""# 5. Run the real training.
# Sources are frozen; only NOEON's 698M parameters move.
# --amp and --grad-accum keep it inside a single T4/L4.
!python scripts/train_unified.py --steps 200 --batch 1 --grad-accum 4 --amp --resume"""),
    code("""# 6. Inspect the checkpoint that was written (if any)
import json, pathlib
steps = sorted(pathlib.Path("weights/checkpoints").glob("step-*")) if pathlib.Path("weights/checkpoints").exists() else []
print("checkpoints:", [p.name for p in steps])
run = pathlib.Path("reports/training_run.json")
if run.exists():
    print(json.dumps(json.loads(run.read_text()), indent=2)[:800])"""),
    code("""# 7. (Optional) push the checkpoint back to the Hub — never paste tokens inline.
# import subprocess
# subprocess.run(["python", "scripts/publish_to_hf.py", "--repo",
#                 "Frankenstein-Labs/NOEON"], check=True)"""),
    md("""## After a successful run

* `UnifiedBrain.status(state_dir="weights/checkpoints")` reports
  `trained@step-N` instead of `initialized-untrained`.
* The evaluation suite's *quality* checks become meaningful (there is now a
  trained model to answer); today only mechanism checks are reported.
* Re-run `scripts/run_alignment_experiment.py` with last-layer hidden states
  (now that the trunks can run) to move from the embedding-row probe to full
  hidden-state alignment."""),
]


def main() -> int:
    doc = {"cells": CELLS,
           "metadata": {"kernelspec": KERNEL,
                        "language_info": {"name": "python", "version": "3.11"}},
           "nbformat": 4, "nbformat_minor": 5}
    for i, c in enumerate(doc["cells"]):
        c["id"] = f"cell-{i}"
    OUT.write_text(json.dumps(doc, indent=1, ensure_ascii=False) + "\n")
    print("wrote", OUT, "cells:", len(CELLS))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())