Create train.py

train.py

@@ -0,0 +1,1846 @@
+# /// script
+# requires-python = ">=3.11,<3.13"
+# dependencies = [
+#   "torch>=2.8,<2.10",
+#   "numpy>=2.0",
+#   "huggingface-hub>=0.34",
+#   "safetensors>=0.5",
+#   "datasets>=2.19",
+#   "tokenizers>=0.20",
+# ]
+# ///
+
+"""
+Smilyai-G1 : Fast Sparse General-Assistant Transformer — FSDP2 EDITION (8xH200)
+~20B total params | ~2B active per token
+
+FIXED EDITION. See the notes at the top of the answer for the full bug list.
+The load-bearing invariant of this file:
+
+    *** EVERY collective must be executed by EVERY rank, in the same order. ***
+
+That means model forwards (validate, sampling), state-dict gathers
+(checkpointing), and the decision to *do* any of those things must never be
+gated behind `if is_master`. Rank 0 may be the only one that WRITES the file
+or PRINTS the line, but all 8 ranks must run the collective that produced it.
+
+RUN:
+    export HF_TOKEN=your_hf_token_here
+    export G1_SESSION_ID=1
+    torchrun --nproc_per_node=8 train_g1_fsdp.py
+  or just:
+    python train_g1_fsdp.py   # self-launches 8 NCCL workers if 8 GPUs visible
+"""
+
+import os, gc, json, time, math, random, logging, threading, queue, contextlib
+from dataclasses import dataclass, asdict
+from typing import Optional, Tuple, List, Iterator
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+import torch.multiprocessing as mp
+from torch.utils.data import Dataset, DataLoader
+
+# ── FSDP2 / DTensor imports ─────────────────────────────────────────────────
+try:
+    from torch.distributed.fsdp import fully_shard, MixedPrecisionPolicy
+except ImportError:
+    from torch.distributed._composable.fsdp import fully_shard, MixedPrecisionPolicy
+
+from torch.distributed.tensor import DTensor, distribute_tensor
+from torch.distributed.checkpoint.state_dict import (
+    get_model_state_dict, set_model_state_dict,
+    get_optimizer_state_dict, set_optimizer_state_dict,
+    StateDictOptions,
+)
+
+import triton
+import triton.language as tl
+
+from huggingface_hub import HfApi, hf_hub_download, upload_file, login as hf_login
+
+try:
+    import bitsandbytes as bnb
+    HAS_BNB = True
+except ImportError:
+    HAS_BNB = False
+
+try:
+    from safetensors.torch import save_file as st_save
+    HAS_ST = True
+except ImportError:
+    HAS_ST = False
+
+try:
+    from flash_attn import flash_attn_func
+    HAS_FLASH = True
+except ImportError:
+    HAS_FLASH = False
+
+try:
+    from torchao.float8 import convert_to_float8_training, Float8LinearConfig
+    HAS_FP8 = True
+except ImportError:
+    HAS_FP8 = False
+    convert_to_float8_training = None
+    Float8LinearConfig = None
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+torch.set_float32_matmul_precision('high')
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+torch.backends.cuda.enable_flash_sdp(True)
+torch.backends.cuda.enable_mem_efficient_sdp(True)
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(message)s', datefmt='%H:%M:%S')
+log = logging.getLogger("smilyai-g1-fsdp")
+log.info(f"[env] flash_attn={HAS_FLASH} | bnb={HAS_BNB}")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  HF SETUP
+# ─────────────────────────────────────────────────────────────────────────────
+HF_TOKEN    = os.environ.get("HF_TOKEN", "")
+SESSION_ID  = int(os.environ.get("G1_SESSION_ID", "1"))
+REPO_PREFIX = "hugging-science/Smilyai-G1-20B-session-"
+HF_MODEL_REPO = f"{REPO_PREFIX}{SESSION_ID:03d}"
+
+if not HF_TOKEN:
+    log.warning("[hf] HF_TOKEN not set — uploads/downloads will fail. export HF_TOKEN=...")
+else:
+    try:
+        hf_login(token=HF_TOKEN)
+        log.info("[hf] logged in")
+    except Exception as e:
+        log.warning(f"[hf] login failed: {e}")
+
+hf_api        = HfApi()
+LOCAL_CACHE   = "/tmp/g1_cache"
+TEMP_CKPT_DIR = "/tmp/g1_ckpts"
+os.makedirs(LOCAL_CACHE, exist_ok=True)
+os.makedirs(TEMP_CKPT_DIR, exist_ok=True)
+
+MAX_HOURS  = float(os.environ.get("MAX_TRAINING_HOURS", "24.0"))
+START_TIME = time.time()
+def elapsed_h():   return (time.time() - START_TIME) / 3600
+def remaining_h(): return MAX_HOURS - elapsed_h()
+def should_stop_local():
+    if elapsed_h() >= MAX_HOURS:
+        log.info("[time] budget done"); return True
+    return False
+def vram_gb():       return torch.cuda.memory_allocated() / 1024**3
+def vram_total_gb(): return torch.cuda.get_device_properties(torch.cuda.current_device()).total_memory / 1024**3
+def vram_str():      return f"{vram_gb():.1f}/{vram_total_gb():.0f}GB"
+
+def ensure_repo():
+    try:
+        hf_api.repo_info(repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN)
+    except Exception:
+        hf_api.create_repo(repo_id=HF_MODEL_REPO, repo_type="model", private=False, token=HF_TOKEN)
+        log.info(f"[hf] created {HF_MODEL_REPO}")
+    log.info(f"[hf] USING REPO: {HF_MODEL_REPO}")
+
+def upload_to_hf(local: str, remote: str) -> bool:
+    try:
+        upload_file(path_or_fileobj=local, path_in_repo=remote,
+                    repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN)
+        log.info(f"[hf] up {remote}")
+        return True
+    except Exception as e:
+        log.error(f"[hf] upload failed: {e}")
+        return False
+
+METRICS_FILE = os.path.join(TEMP_CKPT_DIR, f"metrics_session_{SESSION_ID:03d}.jsonl")
+def log_metrics(**kw):
+    m = {'timestamp': time.time(), 'elapsed_hours': elapsed_h(), 'session_id': SESSION_ID, **kw}
+    with open(METRICS_FILE, 'a') as f:
+        f.write(json.dumps(m) + '\n')
+    return m
+def upload_metrics():
+    if os.path.exists(METRICS_FILE):
+        upload_to_hf(METRICS_FILE, f"metrics_session_{SESSION_ID:03d}.jsonl")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  MOTIVATION / PROGRESS BOARD
+# ─────────────────────────────────────────────────────────────────────────────
+import datetime
+try:
+    import matplotlib; matplotlib.use("Agg"); import matplotlib.pyplot as plt
+    HAS_MPL = True
+except ImportError:
+    HAS_MPL = False
+
+SAMPLES_FILE = os.path.join(TEMP_CKPT_DIR, "samples.md")
+SUMMARY_FILE = os.path.join(TEMP_CKPT_DIR, "summary.jsonl")
+PROGRESS_MD  = os.path.join(TEMP_CKPT_DIR, "PROGRESS.md")
+_step_clock  = []
+_tok         = None
+
+def _real_steps_per_hour():
+    if len(_step_clock) < 2: return None
+    (s0, t0), (s1, t1) = _step_clock[0], _step_clock[-1]
+    if t1 - t0 < 30 or s1 <= s0: return None
+    return (s1 - s0) / (t1 - t0) * 3600
+
+def sessions_left(step, total):
+    sph = _real_steps_per_hour()
+    if sph is None: return None
+    usable_h = max(MAX_HOURS - 0.75, 8.0)
+    return max(math.ceil((total - step) / max(sph * usable_h, 1)), 0)
+
+def session_banner():
+    try:
+        files = hf_api.list_repo_files(repo_id=HF_MODEL_REPO, repo_type="model", token=HF_TOKEN)
+        pts = [f for f in files if f.endswith(".pt")]
+        latest = max([int(f.split("step")[-1].split(".")[0]) for f in pts]) if pts else 0
+    except Exception:
+        pts, latest = [], 0
+    log.info("🌱" * 25)
+    log.info(f"WELCOME BACK — feed #{len(pts)+1}. Smilyai survived {len(pts)} sessions.")
+    log.info(f"Latest checkpoint on the Hub: step {latest:,}")
+    log.info("🌱" * 25)
+
+def _bootstrap_from_hub(local, remote):
+    try:
+        import shutil
+        src = hf_hub_download(HF_MODEL_REPO, remote, cache_dir=TEMP_CKPT_DIR, token=HF_TOKEN)
+        shutil.copy(src, local)
+        log.info(f"[motiv] restored {remote}")
+    except Exception:
+        pass
+
+def _get_tokenizer():
+    global _tok
+    if _tok is None:
+        try:
+            _tok = get_tokenizer(Config())
+        except Exception as e:
+            log.warning(f"[tokenizer] failed: {e}")
+            _tok = None
+    return _tok
+
+DOMAIN_TOKEN = ""
+
+@torch.no_grad()
+def make_sample(model, prompt="def fibonacci(n):", max_new=48, temp=0.8, top_p=0.95):
+    """
+    BUGFIX: this runs a MODEL FORWARD, which under FSDP2 is a collective
+    (all-gather per block). It therefore MUST be called by every rank. The
+    sampling RNG is seeded identically on all ranks so every rank walks the
+    same token sequence and issues an identical collective schedule.
+    """
+    try:
+        tok = _get_tokenizer()
+        if tok is None: return None
+        encoded = tok.encode(DOMAIN_TOKEN + prompt)
+        token_ids = encoded.ids[-128:]
+        if not token_ids: return None
+        device = next(model.parameters()).device
+        ids = torch.tensor([token_ids], device=device)
+    except Exception as e:
+        log.warning(f"[sample] tokenizer error: {e}"); return None
+
+    gen = torch.Generator(device=device)
+    gen.manual_seed(1234)   # identical on all ranks -> identical trajectory
+
+    was_training = model.training
+    model.eval()
+    try:
+        for _ in range(max_new):
+            with torch.amp.autocast('cuda', dtype=model.cfg.dtype):
+                logits, _ = model(ids[:, -model.cfg.max_len:], None)
+            p = F.softmax(logits[:, -1].float() / temp, dim=-1)
+            sp, si = torch.sort(p, descending=True)
+            keep = (torch.cumsum(sp, -1) - sp) < top_p
+            sp = sp * keep
+            sp = sp / sp.sum(-1, keepdim=True).clamp_min(1e-9)
+            nxt = si.gather(-1, torch.multinomial(sp, 1, generator=gen))
+            ids = torch.cat([ids, nxt], dim=1)
+    finally:
+        if was_training: model.train()
+    try:
+        return tok.decode(ids[0].tolist())
+    except Exception as e:
+        log.warning(f"[sample] decode error: {e}")
+        return None
+
+def record_sample(model, step, is_master: bool):
+    """Collective on all ranks; only rank 0 persists the result."""
+    txt = make_sample(model)
+    if not is_master:
+        return
+    with open(SAMPLES_FILE, "a") as f:
+        f.write(f"\n## step {step:,} — {datetime.datetime.now():%d %b %H:%M}\n> {txt or '(skipped)'}\n")
+    upload_to_hf(SAMPLES_FILE, "samples.md")
+    if txt: log.info(f"[motiv] sample » {txt[:120]!r}")
+
+def make_loss_chart():
+    if not (HAS_MPL and os.path.exists(METRICS_FILE)): return
+    tr, va = [], []
+    for line in open(METRICS_FILE):
+        try: m = json.loads(line)
+        except Exception: continue
+        if "loss" in m and "step" in m: tr.append((m["step"], m["loss"]))
+        elif "val_loss" in m and "step" in m: va.append((m["step"], m["val_loss"]))
+    if not tr: return
+    fig, ax = plt.subplots(figsize=(10, 5))
+    ax.plot(*zip(*tr), lw=1, label="train")
+    if va: ax.plot(*zip(*va), "o-", color="tab:red", label="val")
+    ax.set_xlabel("step"); ax.set_ylabel("loss"); ax.grid(alpha=.3); ax.legend()
+    ax.set_title("Smilyai-G1 20B learning curve 🌱")
+    p = os.path.join(TEMP_CKPT_DIR, "loss_curve.png")
+    fig.savefig(p, dpi=110, bbox_inches="tight"); plt.close(fig)
+    upload_to_hf(p, "loss_curve.png"); os.remove(p)
+
+def update_progress_md(cfg, step, epoch, tr_loss, val_loss):
+    rec = {"t": f"{datetime.datetime.now():%d %b %H:%M}", "step": step, "epoch": epoch,
+           "loss": round(tr_loss, 4) if tr_loss is not None else None,
+           "val": round(val_loss, 4) if (val_loss is not None and val_loss == val_loss) else None}
+    with open(SUMMARY_FILE, "a") as f: f.write(json.dumps(rec) + "\n")
+    sl = sessions_left(step, cfg.total_steps); sl = f"~{sl}" if sl is not None else "?"
+    lines = ["# Smilyai-G1 20B · live progress 🌱", "",
+             f"**{100*step/cfg.total_steps:.1f}% trained** · estimated clicks left: **{sl}** 🖱️", "",
+             "| when | step | train loss | val loss |", "|---|---|---|---|"]
+    for line in open(SUMMARY_FILE):
+        try: r = json.loads(line)
+        except Exception: continue
+        lines.append(f"| {r['t']} | {r['step']:,} | {r['loss'] if r['loss'] is not None else '—'} "
+                     f"| {r['val'] if r['val'] is not None else '—'} |")
+    with open(PROGRESS_MD, "w") as f: f.write("\n".join(lines) + "\n")
+    upload_to_hf(PROGRESS_MD, "PROGRESS.md")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  CONFIG
+# ─────────────────────────────────────────────────────────────────────────────
+@dataclass
+class Config:
+    vocab_size: int = 131_072
+
+    d_model:    int   = 2048
+    n_layers:   int   = 32
+    n_heads:    int   = 16
+    n_kv_heads: int   = 4
+    max_len:    int   = 2048
+    rope_theta: float = 500_000.0
+
+    n_experts:          int   = 56
+    top_k:              int   = 2
+    expert_hidden_mult: float = 0.875
+    shared_hidden_mult: float = 2.0
+    n_shared_experts:   int   = 1
+    aux_loss_coef:      float = 0.01
+    bias_update_rate:  float = 0.001
+    bias_update_every: int   = 10   # in OPTIMIZER steps
+    bias_cap:          float = 2.0
+    bias_decay:        float = 0.0005
+    usage_ema_decay:   float = 0.99
+    moe_block_m:        int   = 64
+
+    tie_embeddings:   bool  = True
+
+    muon_lr:     float = 0.008
+    muon_min_lr: float = 0.0008
+    muon_mom:    float = 0.95
+    adamw_lr:    float = 1.5e-4
+    adamw_min_lr:float = 1.5e-5
+    beta1:       float = 0.9
+    beta2:       float = 0.95
+    wd:          float = 0.1
+    grad_clip:   float = 1.0
+    warmup:      int   = 3000
+    total_steps: int   = 300_000
+
+    micro_batch: int = 2
+    grad_accum:  int = 16
+
+    log_every:   int = 10
+    eval_every:  int = 500
+    ckpt_every:  int = 1000
+
+    enable_dpo_bursts: bool = False
+    dpo_start_step:    int  = 250_000
+    dpo_every:         int  = 500
+    dpo_beta:          float= 0.1
+
+    dataset_sources: tuple = (
+        ("HuggingFaceFW/fineweb-edu",                  "train", "text",     200_000_000_000),
+        ("HuggingFaceCode/stack-v3-train",             "train", "content",  100_000_000_000),
+        ("opencsg/chinese-fineweb-edu",                "train", "text",      60_000_000_000),
+        ("hotchpotch/fineweb-2-edu-japanese",          "train", "text",      40_000_000_000),
+        ("KORMo-Team/korean-web-collection",           "train", "text",      30_000_000_000),
+        ("HuggingFaceFW/fineweb-2",                    "train", "text",      70_000_000_000),
+    )
+    tokenizer_repo: str = "Smilyai-labs/Smilyai-U1-B-Tokenizer"
+    # BUGFIX: 18 threads x 6 sources x 8 ranks = 864 concurrent HTTP streams,
+    # which will get you rate-limited and eat enormous host RAM in buffers.
+    # 8 is already plenty to keep a single H200 fed at this token rate.
+    tokenizer_workers: int = 8
+    prefetch_shards: int = 6
+
+    use_compile: bool = False
+    use_fp8: bool = False
+
+    @property
+    def dtype(self): return torch.bfloat16
+    @property
+    def head_dim(self): return self.d_model // self.n_heads
+    def tokens_per_step(self, bs, world_size=1): return bs * self.grad_accum * self.max_len * world_size
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  DISTRIBUTED HELPERS
+# ─────────────────────────────────────────────────────────────────────────────
+def dist_ready() -> bool:
+    return dist.is_available() and dist.is_initialized()
+
+def distributed_mean(value: float, device: torch.device) -> float:
+    t = torch.tensor(float(value), dtype=torch.float64, device=device)
+    if dist_ready():
+        dist.all_reduce(t, op=dist.ReduceOp.SUM)
+        t /= dist.get_world_size()
+    return t.item()
+
+def broadcast_flag(value: bool, device: torch.device) -> bool:
+    """Rank 0 decides, everyone obeys. Used for anything that gates a
+    collective (checkpointing, eval, stopping) so ranks can never diverge."""
+    flag = torch.tensor(int(bool(value)), dtype=torch.int32, device=device)
+    if dist_ready():
+        dist.broadcast(flag, src=0)
+    return bool(flag.item())
+
+def all_ok(ok: bool, device: torch.device) -> bool:
+    """Collective AND. If ANY rank failed (OOM/NaN), every rank must take the
+    same recovery branch, or the next collective deadlocks."""
+    t = torch.tensor(int(bool(ok)), dtype=torch.int32, device=device)
+    if dist_ready():
+        dist.all_reduce(t, op=dist.ReduceOp.MIN)
+    return bool(t.item())
+
+def distributed_should_stop(device: torch.device, is_master: bool, step: int, total_steps: int) -> bool:
+    stop = (should_stop_local() or step >= total_steps) if is_master else False
+    return broadcast_flag(stop, device)
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  TRITON KERNELS
+# ─────────────────────────────────────────────────────────────────────────────
+@triton.jit
+def smilyai_rmsnorm_fwd(X, W, Y, RSTD, stride_row, N, eps, BLOCK_N: tl.constexpr):
+    row = tl.program_id(0)
+    X += row * stride_row; Y += row * stride_row
+    cols = tl.arange(0, BLOCK_N); mask = cols < N
+    x = tl.load(X + cols, mask=mask, other=0.0).to(tl.float32)
+    var = tl.sum(x * x, axis=0) / N
+    rstd = 1.0 / tl.sqrt(var + eps)
+    tl.store(RSTD + row, rstd)
+    w = tl.load(W + cols, mask=mask, other=0.0).to(tl.float32)
+    tl.store(Y + cols, (x * rstd * w).to(Y.dtype.element_ty), mask=mask)
+
+@triton.jit
+def smilyai_rmsnorm_bwd(X, W, DY, DX, DW_PARTIAL, RSTD, stride_row, N, BLOCK_N: tl.constexpr):
+    row = tl.program_id(0)
+    X += row * stride_row; DY += row * stride_row; DX += row * stride_row
+    cols = tl.arange(0, BLOCK_N); mask = cols < N
+    x  = tl.load(X  + cols, mask=mask, other=0.0).to(tl.float32)
+    dy = tl.load(DY + cols, mask=mask, other=0.0).to(tl.float32)
+    w  = tl.load(W  + cols, mask=mask, other=0.0).to(tl.float32)
+    rstd = tl.load(RSTD + row)
+    wdy  = w * dy
+    s    = tl.sum(x * wdy, axis=0)
+    dx   = rstd * wdy - (rstd * rstd * rstd / N) * x * s
+    tl.store(DX + cols, dx.to(DX.dtype.element_ty), mask=mask)
+    tl.store(DW_PARTIAL + row * N + cols, dy * x * rstd, mask=mask)
+
+@triton.jit
+def smilyai_swiglu_fwd(GATE, UP, OUT, N, BLOCK: tl.constexpr):
+    pid  = tl.program_id(0)
+    offs = pid * BLOCK + tl.arange(0, BLOCK); mask = offs < N
+    g = tl.load(GATE + offs, mask=mask, other=0.0).to(tl.float32)
+    u = tl.load(UP   + offs, mask=mask, other=0.0).to(tl.float32)
+    tl.store(OUT + offs, (g * tl.sigmoid(g) * u).to(OUT.dtype.element_ty), mask=mask)
+
+@triton.jit
+def smilyai_swiglu_bwd(GATE, UP, DOUT, DGATE, DUP, N, BLOCK: tl.constexpr):
+    pid  = tl.program_id(0)
+    offs = pid * BLOCK + tl.arange(0, BLOCK); mask = offs < N
+    g    = tl.load(GATE + offs, mask=mask, other=0.0).to(tl.float32)
+    u    = tl.load(UP   + offs, mask=mask, other=0.0).to(tl.float32)
+    dout = tl.load(DOUT + offs, mask=mask, other=0.0).to(tl.float32)
+    s    = tl.sigmoid(g); silu = g * s; dsilu = s * (1.0 + g * (1.0 - s))
+    tl.store(DGATE + offs, (dout * u * dsilu).to(DGATE.dtype.element_ty), mask=mask)
+    tl.store(DUP   + offs, (dout * silu    ).to(DUP.dtype.element_ty),   mask=mask)
+
+class _TritonRMSNormFn(torch.autograd.Function):
+    @staticmethod
+    @torch.compiler.disable
+    def forward(ctx, x, w, eps):
+        orig = x.shape; x2 = x.reshape(-1, orig[-1]).contiguous()
+        M, N = x2.shape; y = torch.empty_like(x2)
+        rstd = torch.empty(M, device=x.device, dtype=torch.float32)
+        BN = triton.next_power_of_2(N)
+        w = w.contiguous()
+        smilyai_rmsnorm_fwd[(M,)](x2, w, y, rstd, x2.stride(0), N, eps, BLOCK_N=BN)
+        ctx.save_for_backward(x2, w, rstd); ctx.BN = BN; ctx.orig = orig
+        return y.view(orig)
+
+    @staticmethod
+    @torch.compiler.disable
+    def backward(ctx, dy):
+        x2, w, rstd = ctx.saved_tensors; M, N = x2.shape
+        dy2 = dy.reshape(M, N).contiguous()
+        dx  = torch.empty_like(x2)
+        dwp = torch.empty(M, N, device=x2.device, dtype=torch.float32)
+        smilyai_rmsnorm_bwd[(M,)](x2, w, dy2, dx, dwp, rstd, x2.stride(0), N, BLOCK_N=ctx.BN)
+        return dx.view(ctx.orig), dwp.sum(0).to(w.dtype), None
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__(); self.eps = eps; self.w = nn.Parameter(torch.ones(dim))
+    def forward(self, x):
+        if x.is_cuda: return _TritonRMSNormFn.apply(x, self.w, self.eps)
+        x32 = x.float()
+        return (x32 * torch.rsqrt(x32.pow(2).mean(-1, keepdim=True) + self.eps) * self.w).to(x.dtype)
+
+class _FusedSwiGLUFn(torch.autograd.Function):
+    @staticmethod
+    @torch.compiler.disable
+    def forward(ctx, gate, up):
+        shape = gate.shape; g = gate.reshape(-1).contiguous(); u = up.reshape(-1).contiguous()
+        N = g.numel(); out = torch.empty_like(g); BLOCK = 1024
+        smilyai_swiglu_fwd[(triton.cdiv(N, BLOCK),)](g, u, out, N, BLOCK=BLOCK)
+        ctx.save_for_backward(g, u); ctx.shape = shape; ctx.BLOCK = BLOCK
+        return out.view(shape)
+
+    @staticmethod
+    @torch.compiler.disable
+    def backward(ctx, dout):
+        g, u = ctx.saved_tensors; N = g.numel()
+        dout_flat = dout.reshape(-1).contiguous()
+        dgate = torch.empty_like(g); dup = torch.empty_like(u)
+        smilyai_swiglu_bwd[(triton.cdiv(N, ctx.BLOCK),)](g, u, dout_flat, dgate, dup, N, BLOCK=ctx.BLOCK)
+        return dgate.view(ctx.shape), dup.view(ctx.shape)
+
+def fused_swiglu(gate, up):
+    return _FusedSwiGLUFn.apply(gate, up) if gate.is_cuda else F.silu(gate) * up
+
+def precompute_rope(head_dim, max_len, theta, device):
+    inv_freq = 1.0 / (theta ** (torch.arange(0, head_dim, 2, device=device, dtype=torch.float32) / head_dim))
+    pos = torch.arange(max_len, device=device, dtype=torch.float32)
+    freqs = torch.outer(pos, inv_freq)
+    return freqs.cos(), freqs.sin()
+
+def apply_rope(x, cos, sin):
+    """Rotation math forced to fp32 — cos/sin tables must stay fp32 too."""
+    dt = x.dtype
+    L = x.shape[1]; h = x.shape[-1] // 2
+    c = cos[:L].unsqueeze(0).unsqueeze(2); s = sin[:L].unsqueeze(0).unsqueeze(2)
+    x32 = x.float()
+    x1, x2 = x32[..., :h], x32[..., h:]
+    return torch.cat([x1 * c - x2 * s, x2 * c + x1 * s], dim=-1).to(dt)
+
+class GQAAttention(nn.Module):
+    def __init__(self, cfg: Config, layer_idx: int):
+        super().__init__()
+        self.n_heads    = cfg.n_heads
+        self.n_kv_heads = cfg.n_kv_heads
+        self.hd         = cfg.head_dim
+        d = cfg.d_model
+
+        self.wq = nn.Linear(d, self.n_heads    * self.hd, bias=False)
+        self.wk = nn.Linear(d, self.n_kv_heads * self.hd, bias=False)
+        self.wv = nn.Linear(d, self.n_kv_heads * self.hd, bias=False)
+        self.wo = nn.Linear(self.n_heads * self.hd, d, bias=False)
+
+        self.q_norm = RMSNorm(self.hd)
+        self.k_norm = RMSNorm(self.hd)
+
+        std = 0.02
+        for m in [self.wq, self.wk, self.wv]: nn.init.normal_(m.weight, std=std)
+        nn.init.normal_(self.wo.weight, std=std / math.sqrt(2 * cfg.n_layers))
+
+    def _attend(self, q, k, v):
+        if HAS_FLASH and q.is_cuda and q.dtype in (torch.bfloat16, torch.float16):
+            return flash_attn_func(q, k, v, causal=True)
+        B, L, Hq, D = q.shape; Hkv = k.shape[2]
+        qt = q.transpose(1,2); kt = k.transpose(1,2); vt = v.transpose(1,2)
+        if Hq != Hkv:
+            rep = Hq // Hkv
+            kt = kt.repeat_interleave(rep, 1); vt = vt.repeat_interleave(rep, 1)
+        out = F.scaled_dot_product_attention(qt, kt, vt, is_causal=True)
+        return out.transpose(1, 2)
+
+    def forward(self, x, cos, sin):
+        B, L, _ = x.shape
+        q = self.wq(x).view(B, L, self.n_heads,    self.hd)
+        k = self.wk(x).view(B, L, self.n_kv_heads, self.hd)
+        v = self.wv(x).view(B, L, self.n_kv_heads, self.hd)
+
+        q, k = self.q_norm(q), self.k_norm(k)
+        q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
+
+        out = self._attend(q, k, v)
+        return self.wo(out.reshape(B, L, -1))
+
+# ─────────────���───────────────────────────────────────────────────────────────
+#  FUSED GROUPED-GEMM MOE DISPATCH
+# ─────────────────────────────────────────────────────────────────────────────
+_moe_autotune_configs = [
+    triton.Config({"BLOCK_N": 64,  "BLOCK_K": 32}, num_warps=4, num_stages=3),
+    triton.Config({"BLOCK_N": 128, "BLOCK_K": 32}, num_warps=8, num_stages=3),
+    triton.Config({"BLOCK_N": 128, "BLOCK_K": 64}, num_warps=8, num_stages=4),
+    triton.Config({"BLOCK_N": 64,  "BLOCK_K": 64}, num_warps=4, num_stages=4),
+]
+
+
+@triton.autotune(configs=_moe_autotune_configs, key=["K", "N"])
+@triton.jit
+def _moe_gemm_kernel(
+    A_ptr, B_ptr, C_ptr, block_expert_ptr,
+    M_padded, K, N,
+    stride_am, stride_ak,
+    stride_be, stride_bk, stride_bn,
+    stride_cm, stride_cn,
+    BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr,
+):
+    pid_m = tl.program_id(0)
+    pid_n = tl.program_id(1)
+    e     = tl.load(block_expert_ptr + pid_m).to(tl.int64)
+
+    offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    offs_k = tl.arange(0, BLOCK_K)
+    m_mask = offs_m < M_padded
+    n_mask = offs_n < N
+
+    a_ptrs = A_ptr + offs_m[:, None] * stride_am + offs_k[None, :] * stride_ak
+    b_ptrs = B_ptr + e * stride_be + offs_k[:, None] * stride_bk + offs_n[None, :] * stride_bn
+
+    acc = tl.zeros((BLOCK_M, BLOCK_N), dtype=tl.float32)
+    for k0 in range(0, K, BLOCK_K):
+        k_mask = (k0 + offs_k) < K
+        a = tl.load(a_ptrs, mask=m_mask[:, None] & k_mask[None, :], other=0.0)
+        b = tl.load(b_ptrs, mask=k_mask[:, None] & n_mask[None, :], other=0.0)
+        acc    = tl.dot(a, b, acc)
+        a_ptrs += BLOCK_K * stride_ak
+        b_ptrs += BLOCK_K * stride_bk
+
+    tl.store(
+        C_ptr + offs_m[:, None] * stride_cm + offs_n[None, :] * stride_cn,
+        acc.to(tl.bfloat16), mask=m_mask[:, None] & n_mask[None, :],
+    )
+
+
+def _grouped_linear_raw(A, W, block_expert, M_padded, transpose, BM):
+    """W is (E, OUT, IN) — nn.Linear convention. transpose=True computes the
+    dA backward pass (A @ W instead of A @ W^T)."""
+    E, OUT, IN = W.shape
+    if not transpose:
+        K, N       = IN, OUT
+        stride_bk  = W.stride(2)
+        stride_bn  = W.stride(1)
+    else:
+        K, N       = OUT, IN
+        stride_bk  = W.stride(1)
+        stride_bn  = W.stride(2)
+
+    C    = torch.empty((M_padded, N), device=A.device, dtype=torch.bfloat16)
+    grid = lambda META: (triton.cdiv(M_padded, BM), triton.cdiv(N, META["BLOCK_N"]))
+    _moe_gemm_kernel[grid](
+        A, W, C, block_expert, M_padded, K, N,
+        A.stride(0), A.stride(1),
+        W.stride(0), stride_bk, stride_bn,
+        C.stride(0), C.stride(1),
+        BLOCK_M=BM,
+    )
+    return C
+
+
+# BUGFIX: this kernel accumulates with tl.atomic_add. triton.autotune runs the
+# kernel once per candidate config to benchmark it, so WITHOUT reset_to_zero
+# the very first call for each new (K,N) key would leave DW containing
+# ~4 extra accumulations of the same gradient. Silent, non-deterministic,
+# and only on the first step of each new shape — the worst kind of bug.
+@triton.autotune(configs=_moe_autotune_configs, key=["K", "N"], reset_to_zero=["DW_ptr"])
+@triton.jit
+def _moe_dw_kernel(
+    A_ptr, DC_ptr, DW_ptr, block_expert_ptr,
+    M_padded, K, N,
+    stride_am, stride_ak,
+    stride_dcm, stride_dcn,
+    stride_dwe, stride_dwn, stride_dwk,
+    BLOCK_M: tl.constexpr, BLOCK_N: tl.constexpr, BLOCK_K: tl.constexpr,
+):
+    pid_m = tl.program_id(0)
+    pid_n = tl.program_id(1)
+    pid_k = tl.program_id(2)
+    e     = tl.load(block_expert_ptr + pid_m).to(tl.int64)
+
+    offs_m = pid_m * BLOCK_M + tl.arange(0, BLOCK_M)
+    offs_n = pid_n * BLOCK_N + tl.arange(0, BLOCK_N)
+    offs_k = pid_k * BLOCK_K + tl.arange(0, BLOCK_K)
+    m_mask = offs_m < M_padded
+    n_mask = offs_n < N
+    k_mask = offs_k < K
+
+    a  = tl.load(A_ptr  + offs_m[:, None] * stride_am  + offs_k[None, :] * stride_ak,
+                 mask=m_mask[:, None] & k_mask[None, :], other=0.0)
+    dc = tl.load(DC_ptr + offs_m[:, None] * stride_dcm + offs_n[None, :] * stride_dcn,
+                 mask=m_mask[:, None] & n_mask[None, :], other=0.0)
+
+    tl.atomic_add(
+        DW_ptr + e * stride_dwe + offs_n[:, None] * stride_dwn + offs_k[None, :] * stride_dwk,
+        tl.dot(tl.trans(dc), a),
+        mask=n_mask[:, None] & k_mask[None, :],
+    )
+
+
+def _grouped_dw_raw(A, dC, block_expert, E, OUT, IN, M_padded, BM):
+    DW   = torch.zeros((E, OUT, IN), device=A.device, dtype=torch.float32)
+    grid = lambda META: (
+        triton.cdiv(M_padded, BM),
+        triton.cdiv(OUT, META["BLOCK_N"]),
+        triton.cdiv(IN,  META["BLOCK_K"]),
+    )
+    _moe_dw_kernel[grid](
+        A, dC, DW, block_expert, M_padded, IN, OUT,
+        A.stride(0), A.stride(1),
+        dC.stride(0), dC.stride(1),
+        DW.stride(0), DW.stride(1), DW.stride(2),
+        BLOCK_M=BM,
+    )
+    return DW
+
+
+class GroupedLinearFn(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, A, W, block_expert, padded_offsets, M_padded, BM):
+        A = A.contiguous().to(torch.bfloat16)
+        W = W.contiguous()
+        C = _grouped_linear_raw(A, W, block_expert, M_padded, False, BM)
+        ctx.save_for_backward(A, W, block_expert, padded_offsets)
+        ctx.M_padded = M_padded
+        ctx.BM       = BM
+        return C
+
+    @staticmethod
+    def backward(ctx, dC):
+        A, W, block_expert, _ = ctx.saved_tensors
+        dC = dC.contiguous().to(torch.bfloat16)
+        dA = _grouped_linear_raw(dC, W, block_expert, ctx.M_padded, True, ctx.BM) \
+             if ctx.needs_input_grad[0] else None
+        dW = _grouped_dw_raw(A, dC, block_expert, W.shape[0], W.shape[1], W.shape[2],
+                             ctx.M_padded, ctx.BM).to(W.dtype) \
+             if ctx.needs_input_grad[1] else None
+        return dA, dW, None, None, None, None
+
+
+def moe_align_block_size(expert_ids, num_experts, block_size, device):
+    """Sort tokens by expert, pad each expert's run up to block_size. No
+    tokens are dropped."""
+    counts        = torch.bincount(expert_ids, minlength=num_experts)
+    padded_counts = ((counts + block_size - 1) // block_size) * block_size
+
+    padded_offsets      = torch.zeros(num_experts + 1, dtype=torch.long, device=device)
+    padded_offsets[1:]  = torch.cumsum(padded_counts, dim=0)
+    orig_offsets        = torch.zeros(num_experts + 1, dtype=torch.long, device=device)
+    orig_offsets[1:]    = torch.cumsum(counts, dim=0)
+
+    total_padded          = int(padded_offsets[-1].item())
+    sort_idx              = torch.argsort(expert_ids, stable=True)
+    num_blocks_per_expert = padded_counts // block_size
+    block_expert          = torch.repeat_interleave(
+        torch.arange(num_experts, device=device), num_blocks_per_expert
+    )
+
+    n_rows               = expert_ids.numel()
+    arange_total         = torch.arange(n_rows, device=device)
+    sorted_expert_of_row = expert_ids[sort_idx]
+    row_within_expert    = arange_total - orig_offsets[sorted_expert_of_row]
+    dest                 = padded_offsets[sorted_expert_of_row] + row_within_expert
+
+    perm       = torch.full((total_padded,), -1, dtype=torch.long, device=device)
+    perm[dest] = sort_idx
+    return perm, block_expert, total_padded, padded_offsets
+
+
+class MoEFFN(nn.Module):
+    def __init__(self, cfg: Config, layer_idx: int):
+        super().__init__()
+        d = cfg.d_model
+        h = int(d * cfg.expert_hidden_mult)
+        E = cfg.n_experts
+        self.E = E; self.d = d; self.h = h
+        self.top_k          = cfg.top_k
+        self.aux_loss_coef  = cfg.aux_loss_coef
+        self.block_m        = cfg.moe_block_m
+
+        self.gate_w = nn.Parameter(torch.empty(E, h, d))   # (E, OUT=h, IN=d)
+        self.up_w   = nn.Parameter(torch.empty(E, h, d))
+        self.down_w = nn.Parameter(torch.empty(E, d, h))   # (E, OUT=d, IN=h)
+        nn.init.normal_(self.gate_w, std=0.02)
+        nn.init.normal_(self.up_w,   std=0.02)
+        nn.init.normal_(self.down_w, std=0.02 / math.sqrt(2 * cfg.n_layers))
+
+        self.router = nn.Linear(d, E, bias=False)
+        nn.init.normal_(self.router.weight, std=0.02)
+
+        sh = int(d * cfg.shared_hidden_mult)
+        self.shared_gate = nn.Linear(d, sh, bias=False)
+        self.shared_up   = nn.Linear(d, sh, bias=False)
+        self.shared_down = nn.Linear(sh, d, bias=False)
+        nn.init.normal_(self.shared_gate.weight, std=0.02)
+        nn.init.normal_(self.shared_up.weight,   std=0.02)
+        nn.init.normal_(self.shared_down.weight, std=0.02 / math.sqrt(2 * cfg.n_layers))
+
+        self.bias_update_rate  = cfg.bias_update_rate
+        self.bias_cap          = cfg.bias_cap
+        self.bias_decay        = cfg.bias_decay
+        self.usage_ema_decay   = cfg.usage_ema_decay
+        # BUGFIX: these MUST stay fp32. model.to(bfloat16) would otherwise
+        # convert them, and expert_usage_ema accumulates token COUNTS (values
+        # in the thousands) — bf16's 8 mantissa bits cannot represent those
+        # increments, so the EMA would stop moving and load balancing would
+        # silently become a no-op. force_fp32_balancing_buffers() re-fixes
+        # them after the .to() in train().
+        self.register_buffer('expert_bias',      torch.zeros(E, dtype=torch.float32))
+        self.register_buffer('expert_usage_ema', torch.zeros(E, dtype=torch.float32))
+        self._bias_capped_warned = False
+
+        self.last_aux_loss = torch.tensor(0.0)
+
+    @torch.no_grad()
+    def accumulate_usage(self, topk_i):
+        counts = F.one_hot(topk_i, self.E).float().sum(dim=(0, 1))
+        self.expert_usage_ema.mul_(self.usage_ema_decay).add_(counts, alpha=1 - self.usage_ema_decay)
+
+    @torch.no_grad()
+    def update_bias(self):
+        """COLLECTIVE — must be called by every rank on the same steps."""
+        if dist_ready():
+            dist.all_reduce(self.expert_usage_ema, op=dist.ReduceOp.AVG)
+
+        usage = self.expert_usage_ema
+        avg   = usage.mean().clamp_min(1e-6)
+        error = ((avg - usage) / avg).clamp(-1.0, 1.0)
+
+        self.expert_bias.add_(self.bias_update_rate * error)
+        self.expert_bias.mul_(1.0 - self.bias_decay)
+        self.expert_bias.clamp_(-self.bias_cap, self.bias_cap)
+
+        if not self._bias_capped_warned and bool((self.expert_bias.abs() >= self.bias_cap * 0.99).any()):
+            log.warning(f"[moe] expert_bias hit cap ({self.bias_cap}) on some expert")
+            self._bias_capped_warned = True
+
+    def dead_expert_count(self, threshold: float = 1e-6) -> int:
+        return int((self.expert_usage_ema < threshold).sum().item())
+
+    def capped_expert_count(self) -> int:
+        return int((self.expert_bias.abs() >= self.bias_cap * 0.99).sum().item())
+
+    def forward(self, x):
+        B, L, D = x.shape; T = B * L
+        x_flat = x.reshape(T, D)
+        E, top_k, BM = self.E, self.top_k, self.block_m
+        device = x.device
+
+        shared_out = self.shared_down(
+            fused_swiglu(self.shared_gate(x_flat), self.shared_up(x_flat)))
+
+        logits = self.router(x_flat).float()
+        probs  = F.softmax(logits, dim=-1)
+
+        biased    = logits + self.expert_bias.detach().float()
+        _, topk_i = torch.topk(biased, top_k, dim=-1)
+        topk_p    = probs.gather(-1, topk_i)
+        topk_p    = topk_p / topk_p.sum(-1, keepdim=True).clamp_min(1e-9)
+
+        with torch.no_grad():
+            f_i = F.one_hot(topk_i, E).float().sum(1).mean(0)
+        p_i = probs.mean(0)
+        self.last_aux_loss = (E * (f_i * p_i).sum()) * self.aux_loss_coef
+
+        if self.training:
+            self.accumulate_usage(topk_i)
+
+        expert_ids_flat = topk_i.reshape(-1)
+        gate_flat       = topk_p.reshape(-1).to(x.dtype)
+        token_idx_flat  = torch.arange(T, device=device).unsqueeze(1).expand(T, top_k).reshape(-1)
+
+        perm, block_expert, total_padded, padded_offsets = moe_align_block_size(
+            expert_ids_flat, E, BM, device
+        )
+
+        valid      = perm >= 0
+        gather_idx = perm.clamp_min(0)
+        src_token  = token_idx_flat[gather_idx]
+        A_padded   = x_flat[src_token] * valid.unsqueeze(1).to(x_flat.dtype)
+
+        gate = GroupedLinearFn.apply(A_padded, self.gate_w, block_expert, padded_offsets, total_padded, BM)
+        up   = GroupedLinearFn.apply(A_padded, self.up_w,   block_expert, padded_offsets, total_padded, BM)
+        down = GroupedLinearFn.apply(fused_swiglu(gate, up), self.down_w, block_expert, padded_offsets, total_padded, BM)
+
+        gate_vals = (gate_flat[gather_idx] * valid.to(gate_flat.dtype)).unsqueeze(1)
+        routed_out = torch.zeros(T, D, dtype=down.dtype, device=device)
+        routed_out.index_add_(0, src_token, (down * gate_vals.to(down.dtype)))
+
+        return (routed_out.to(x.dtype) + shared_out).view(B, L, D)
+
+class Block(nn.Module):
+    def __init__(self, cfg: Config, layer_idx: int):
+        super().__init__()
+        self.norm1 = RMSNorm(cfg.d_model)
+        self.norm2 = RMSNorm(cfg.d_model)
+        self.attn  = GQAAttention(cfg, layer_idx)
+        self.ffn   = MoEFFN(cfg, layer_idx)
+
+    def forward(self, x, cos, sin):
+        x = x + self.attn(self.norm1(x), cos, sin)
+        x = x + self.ffn (self.norm2(x))
+        return x
+
+class SmilyaiG1(nn.Module):
+    def __init__(self, cfg: Config):
+        super().__init__()
+        self.cfg   = cfg
+        self.embed = nn.Embedding(cfg.vocab_size, cfg.d_model)
+        nn.init.normal_(self.embed.weight, std=0.02)
+
+        self.blocks      = nn.ModuleList([Block(cfg, i) for i in range(cfg.n_layers)])
+        self.final_norm  = RMSNorm(cfg.d_model)
+
+        if not cfg.tie_embeddings:
+            self.lm_head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=False)
+            nn.init.normal_(self.lm_head.weight, std=0.02 / math.sqrt(cfg.n_layers))
+        else:
+            self.lm_head = None
+
+        self.register_buffer("rope_cos", torch.zeros(cfg.max_len, cfg.head_dim // 2, dtype=torch.float32), persistent=False)
+        self.register_buffer("rope_sin", torch.zeros(cfg.max_len, cfg.head_dim // 2, dtype=torch.float32), persistent=False)
+        self._rope_ready = False
+        self._step = 0
+        self._last_lm_loss  = None
+        self._last_aux_loss = None
+        self._log_summary()
+
+    # BUGFIX: torch.compile replaces blocks with OptimizedModule, which has no
+    # `.ffn`. Everything that reaches into a block must go through this.
+    def _raw_blocks(self):
+        return [getattr(b, "_orig_mod", b) for b in self.blocks]
+
+    def init_rope(self, device):
+        """BUGFIX: was lazily done inside forward(), which mutates a buffer
+        mid-forward under FSDP/compile. Call this once, explicitly."""
+        c, s = precompute_rope(self.cfg.head_dim, self.cfg.max_len, self.cfg.rope_theta, device)
+        self.rope_cos = c.float()
+        self.rope_sin = s.float()
+        self._rope_ready = True
+
+    def force_fp32_balancing_buffers(self):
+        """Undo the damage of a blanket model.to(bfloat16) on the MoE
+        load-balancing statistics."""
+        for b in self._raw_blocks():
+            b.ffn.expert_bias      = b.ffn.expert_bias.float()
+            b.ffn.expert_usage_ema = b.ffn.expert_usage_ema.float()
+
+    def _log_summary(self):
+        cfg = self.cfg
+        total   = sum(p.numel() for p in self.parameters())
+        attn_p  = sum(p.numel() for n, p in self.named_parameters() if 'attn'   in n)
+        shared_p= sum(p.numel() for n, p in self.named_parameters() if 'shared' in n)
+        h_e     = int(cfg.d_model * cfg.expert_hidden_mult)
+        routed_total  = cfg.n_layers * cfg.n_experts * (2*cfg.d_model*h_e + h_e*cfg.d_model)
+        routed_active = routed_total * (cfg.top_k / cfg.n_experts)
+        active_est    = attn_p + shared_p + routed_active + cfg.d_model * cfg.vocab_size
+        log.info("=" * 70)
+        log.info("Smilyai-G1  20B — plain GQA + Sparse MoE (FSDP2)")
+        log.info(f"  d={cfg.d_model} L={cfg.n_layers} heads={cfg.n_heads} kv={cfg.n_kv_heads}")
+        log.info(f"  MoE: {cfg.n_experts} experts, top_k={cfg.top_k}, shared_mult={cfg.shared_hidden_mult}")
+        log.info(f"  Total params: {total/1e9:.2f}B")
+        log.info(f"  Active/token (estimate): {active_est/1e9:.2f}B  (target ~2B)")
+        log.info(f"  vocab={cfg.vocab_size} | Flash: {HAS_FLASH}")
+        log.info("=" * 70)
+
+    def count_params(self): return sum(p.numel() for p in self.parameters())
+    def collect_aux_loss(self): return sum(b.ffn.last_aux_loss for b in self._raw_blocks())
+    def set_step(self, s: int): self._step = s
+
+    def update_expert_bias(self):
+        for b in self._raw_blocks():
+            b.ffn.update_bias()
+
+    def dead_expert_report(self):
+        raw    = self._raw_blocks()
+        dead   = [b.ffn.dead_expert_count()   for b in raw]
+        capped = [b.ffn.capped_expert_count() for b in raw]
+        return dead, sum(dead), capped, sum(capped)
+
+    def forward(self, tokens, targets=None):
+        B, L  = tokens.shape; device = tokens.device
+        if not self._rope_ready:
+            self.init_rope(device)
+        cos, sin = self.rope_cos[:L], self.rope_sin[:L]
+
+        x = self.embed(tokens)
+        for block in self.blocks:
+            x = block(x, cos, sin)
+
+        x     = self.final_norm(x)
+        logits= F.linear(x, self.embed.weight) if self.lm_head is None else self.lm_head(x)
+
+        if targets is None:
+            return logits, None
+
+        lm_loss  = F.cross_entropy(
+            logits[:, :-1].reshape(-1, self.cfg.vocab_size).float(),
+            targets[:, 1:].reshape(-1), ignore_index=-1)
+        aux_loss   = self.collect_aux_loss()
+        total_loss = lm_loss + aux_loss
+        self._last_lm_loss  = lm_loss.detach()
+        self._last_aux_loss = aux_loss.detach() if torch.is_tensor(aux_loss) \
+                              else torch.tensor(float(aux_loss), device=device)
+
+        return logits, total_loss
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  FP8 (must run BEFORE fully_shard — it swaps nn.Linear modules in place)
+# ─────────────────────────────────────────────────────────────────────────────
+_FP8_SKIP = ("router", "lm_head", "embed")
+
+def fp8_capable_gpu() -> bool:
+    return torch.cuda.is_available() and \
+           torch.cuda.get_device_capability(torch.cuda.current_device())[0] >= 9
+
+def apply_fp8(model: SmilyaiG1, cfg: Config, is_master: bool) -> SmilyaiG1:
+    if not cfg.use_fp8:
+        if is_master: log.info("[fp8] disabled")
+        return model
+    if not HAS_FP8:
+        if is_master: log.warning("[fp8] torchao not installed — staying bf16")
+        return model
+    if not fp8_capable_gpu():
+        if is_master: log.warning("[fp8] pre-Hopper GPU — staying bf16")
+        return model
+    convert_to_float8_training(
+        model,
+        config=Float8LinearConfig.from_recipe_name("rowwise"),
+        module_filter_fn=lambda m, fqn: (
+            isinstance(m, nn.Linear) and not any(s in fqn for s in _FP8_SKIP)
+        ),
+    )
+    if is_master:
+        log.info("[fp8] converted dense nn.Linear layers to float8 (rowwise); MoE stays bf16")
+    return model
+
+def apply_fsdp(model: SmilyaiG1, cfg: Config) -> SmilyaiG1:
+    """
+    BUGFIX: fully_shard requires an initialized process group. Single-GPU
+    debug runs previously died here with an opaque error.
+
+    reduce_dtype is fp32, not bf16: summing gradients across 8 ranks in bf16
+    throws away most of the small-magnitude signal you spent the backward
+    pass computing. The extra memory is a few GB per rank.
+    """
+    if not dist_ready():
+        log.warning("[fsdp] no process group — running unsharded (single GPU)")
+        return model
+    mp_policy = MixedPrecisionPolicy(param_dtype=torch.bfloat16,
+                                     reduce_dtype=torch.float32)
+    for block in model.blocks:
+        fully_shard(block, mp_policy=mp_policy)
+    fully_shard(model, mp_policy=mp_policy)
+    return model
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  MUON — DTensor-aware
+# ─────────────────────────────────────────────────────────────────────────────
+def newton_schulz_5(G: torch.Tensor, steps: int = 5) -> torch.Tensor:
+    a, b, c = 3.4445, -4.7750, 2.0315
+    squeeze  = (G.ndim == 2)
+    X = (G.unsqueeze(0) if squeeze else G).bfloat16()
+    transposed = X.size(-2) < X.size(-1)
+    if transposed: X = X.transpose(-2,-1)
+    X = X / (X.norm(dim=(-2,-1), keepdim=True) + 1e-7)
+    for _ in range(steps):
+        A = X @ X.transpose(-2,-1)
+        X = a*X + (b*A + c*A@A) @ X
+    if transposed: X = X.transpose(-2,-1)
+    return X.squeeze(0) if squeeze else X
+
+@torch.no_grad()
+def stochastic_round_to(dtype: torch.dtype, x_fp32: torch.Tensor) -> torch.Tensor:
+    """Unbiased stochastic rounding fp32 -> bf16."""
+    if dtype != torch.bfloat16:
+        return x_fp32.to(dtype)
+    bits = x_fp32.contiguous().view(torch.int32)
+    noise = torch.randint(0, 1 << 16, bits.shape, device=bits.device, dtype=torch.int32)
+    rounded = (bits + noise) & -65536
+    return rounded.view(torch.float32).to(torch.bfloat16)
+
+
+class Muon(torch.optim.Optimizer):
+    """
+    BUGFIX (the big one): the previous version stored the momentum buffer as a
+    FULL, UNSHARDED fp32 tensor on every rank. For this model that is roughly
+    the entire 20B parameter set, in fp32, replicated 8 times — around 80GB
+    per GPU on top of everything else. It would OOM immediately.
+
+    It was also unnecessary. Momentum is ELEMENTWISE, so it is perfectly
+    correct to run it on the local shard. Only Newton-Schulz needs the whole
+    matrix. So the order is now:
+
+        1. momentum update  -> on the SHARDED gradient (buffer stays sharded)
+        2. all-gather the momentum-adjusted gradient  -> transient, one param
+           at a time, freed immediately
+        3. Newton-Schulz on the full matrix           -> mathematically correct
+        4. scatter the update back to this rank's shard
+        5. stochastic-round and apply, all in local shard space
+
+    Peak extra memory is now one full parameter, not the whole model.
+    """
+    def __init__(self, params, lr=0.01, momentum=0.95, wd=0.0):
+        super().__init__(list(params), dict(lr=lr, momentum=momentum, wd=wd))
+
+    @torch.no_grad()
+    def step(self, closure=None):
+        for g in self.param_groups:
+            lr, mom, wd = g['lr'], g['momentum'], g['wd']
+            for p in g['params']:
+                if p.grad is None:
+                    continue
+
+                grad = p.grad
+                is_dtensor = isinstance(p, DTensor)
+
+                st = self.state[p]
+                if 'buf' not in st:
+                    # zeros_like(grad) keeps the SAME (sharded) layout as the
+                    # gradient — this is the whole memory fix.
+                    st['buf'] = torch.zeros_like(grad, dtype=torch.float32)
+                buf = st['buf']
+
+                # --- step 1: elementwise momentum, on the shard ---
+                buf.mul_(mom).add_(grad.to(torch.float32))
+                gnest = grad.to(torch.float32).add(buf, alpha=mom)
+
+                # --- step 2: gather only what NS actually needs ---
+                if is_dtensor:
+                    full = gnest.full_tensor()
+                else:
+                    full = gnest
+
+                # --- step 3: orthogonalize the complete matrix ---
+                if full.ndim in (2, 3):
+                    u      = newton_schulz_5(full)
+                    scale  = 0.2 * math.sqrt(max(full.shape[-2:]))
+                    update = u.to(torch.float32) * (lr * scale)
+                else:
+                    update = full * lr
+                del full
+
+                # --- steps 4+5: back to shard-local space, then round ---
+                if is_dtensor:
+                    upd_local = distribute_tensor(
+                        update, p.device_mesh, p.placements
+                    ).to_local()
+                    p_local = p.to_local()
+                else:
+                    upd_local = update
+                    p_local   = p.data
+
+                if wd > 0:
+                    p_local.mul_(1.0 - lr * wd)
+                p_local.sub_(stochastic_round_to(p_local.dtype, upd_local.contiguous()))
+
+
+def build_optimizers(model: SmilyaiG1, cfg: Config, is_master: bool):
+    muon_p, adamw_p = [], []
+    for name, p in model.named_parameters():
+        if not p.requires_grad: continue
+        if p.ndim in (2, 3) and 'embed' not in name and 'lm_head' not in name:
+            muon_p.append(p)
+        else:
+            adamw_p.append(p)
+
+    muon_opt = Muon(muon_p, lr=cfg.muon_lr, momentum=cfg.muon_mom, wd=cfg.wd)
+
+    # BUGFIX: the old code built a second param group for 'lambda1'/'lambda2'
+    # parameters that no longer exist in this architecture — an always-empty
+    # group whose LR was then scaled by 5x in the scheduler loop, silently
+    # shifting which group index got which LR.
+    groups = [{'params': adamw_p, 'lr': cfg.adamw_lr}]
+
+    # BUGFIX: neither bitsandbytes' 8-bit optimizers nor the fused AdamW
+    # kernel handle DTensor parameters. Under FSDP2 they either throw or
+    # silently operate on garbage. Use the plain foreach path.
+    if dist_ready():
+        adamw_opt = torch.optim.AdamW(groups, betas=(cfg.beta1, cfg.beta2),
+                                      weight_decay=cfg.wd, foreach=True)
+        if is_master: log.info("[optim] Muon (gather-for-NS) + foreach AdamW (DTensor-safe)")
+    elif HAS_BNB:
+        adamw_opt = bnb.optim.AdamW8bit(groups, betas=(cfg.beta1, cfg.beta2), weight_decay=cfg.wd)
+        if is_master: log.info("[optim] Muon + 8-bit AdamW (single GPU)")
+    else:
+        adamw_opt = torch.optim.AdamW(groups, betas=(cfg.beta1, cfg.beta2),
+                                      weight_decay=cfg.wd, fused=True)
+        if is_master: log.info("[optim] Muon + fused AdamW (single GPU)")
+
+    if is_master:
+        log.info(f"[optim] Muon={sum(p.numel() for p in muon_p)/1e6:.1f}M | "
+                 f"AdamW={sum(p.numel() for p in adamw_p)/1e6:.1f}M")
+    return muon_opt, adamw_opt
+
+def cosine_lr(step, warmup, total, peak, minimum):
+    if step < warmup:  return peak * (step + 1) / warmup
+    if step >= total:  return minimum
+    t = (step - warmup) / (total - warmup)
+    return minimum + 0.5 * (peak - minimum) * (1 + math.cos(math.pi * t))
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  LIVE MULTI-SOURCE STREAMING
+# ─────────────────────────────────────────────────────────────────────────────
+try:
+    from datasets import load_dataset
+    HAS_DATASETS = True
+except ImportError:
+    HAS_DATASETS = False
+
+_g1_tokenizer = None
+
+def get_tokenizer(cfg: Config):
+    global _g1_tokenizer
+    if _g1_tokenizer is not None:
+        return _g1_tokenizer
+    from tokenizers import Tokenizer
+    tok_path = hf_hub_download(
+        repo_id=cfg.tokenizer_repo, filename="tokenizer.json",
+        cache_dir=LOCAL_CACHE, token=HF_TOKEN,
+    )
+    _g1_tokenizer = Tokenizer.from_file(tok_path)
+    got_vocab = _g1_tokenizer.get_vocab_size()
+    if got_vocab != cfg.vocab_size:
+        log.warning(f"[tokenizer] loaded vocab_size={got_vocab} != cfg.vocab_size="
+                    f"{cfg.vocab_size} — fix Config.vocab_size to match the real tokenizer.")
+    return _g1_tokenizer
+
+
+def _resolve_eos(tok) -> int:
+    for cand in ("</s>", "<|endoftext|>", "<|end_of_text|>", "<eos>"):
+        tid = tok.token_to_id(cand)
+        if tid is not None:
+            return tid
+    return 0
+
+
+def _open_source_stream(repo_id: str, split: str, shard_index: int, num_shards: int):
+    ds = load_dataset(repo_id, split=split, streaming=True)
+    if num_shards > 1:
+        ds = ds.shard(num_shards=num_shards, index=shard_index)
+    return ds
+
+
+class LiveStreamingDataset:
+    def __init__(self, cfg: Config, batch_size: int, rank: int, world_size: int):
+        if not HAS_DATASETS:
+            raise RuntimeError("the `datasets` package is required for live streaming")
+        self.cfg          = cfg
+        self.batch_size   = batch_size
+        self.rank         = rank
+        self.world_size   = world_size
+        self.max_len      = cfg.max_len
+        self.n_workers    = max(1, cfg.tokenizer_workers)
+        self.total_shards = world_size * self.n_workers
+        self.tok          = get_tokenizer(cfg)
+        self.eos_id       = _resolve_eos(self.tok)
+
+        weights = np.array([float(s[3]) for s in cfg.dataset_sources], dtype=np.float64)
+        self.probabilities = weights / weights.sum()
+
+        qsize = max(cfg.prefetch_shards, self.n_workers * 2)
+        self._q: queue.Queue = queue.Queue(maxsize=qsize)
+        self._stop = threading.Event()
+        self._workers = [
+            threading.Thread(target=self._fetch_loop, args=(w,), daemon=True)
+            for w in range(self.n_workers)
+        ]
+        for t in self._workers:
+            t.start()
+        log.info(f"[stream] rank={rank}/{world_size}: {self.n_workers} tokenizer threads "
+                 f"({self.total_shards} global shards) | {len(cfg.dataset_sources)} sources")
+
+    def _fetch_loop(self, worker_id: int):
+        shard_index = self.rank * self.n_workers + worker_id
+        try:
+            streams = []
+            for repo_id, split, text_field, w in self.cfg.dataset_sources:
+                try:
+                    streams.append([_open_source_stream(repo_id, split, shard_index, self.total_shards),
+                                    text_field, repo_id, split, float(w)])
+                except Exception as e:
+                    log.warning(f"[stream] rank={self.rank}.w{worker_id} could not open {repo_id}: {e}")
+            if not streams:
+                log.error(f"[stream] rank={self.rank}.w{worker_id} no sources opened")
+                return
+
+            rng   = np.random.default_rng(1234 + shard_index)
+            iters = [iter(s[0]) for s in streams]
+            # BUGFIX: np.random.choice rejects probability vectors that don't
+            # sum to exactly 1.0 in floating point. Renormalize in float64
+            # over only the sources that actually opened.
+            probs = np.array([s[4] for s in streams], dtype=np.float64)
+            probs = probs / probs.sum()
+
+            buf: List[int] = []
+            buf_source = "?"
+            need = self.max_len * self.batch_size
+
+            while not self._stop.is_set():
+                idx = int(rng.choice(len(iters), p=probs))
+                _, text_field, repo_id, split, _w = streams[idx]
+                try:
+                    row = next(iters[idx])
+                except StopIteration:
+                    streams[idx][0] = _open_source_stream(repo_id, split, shard_index, self.total_shards)
+                    iters[idx] = iter(streams[idx][0])
+                    continue
+                except Exception as e:
+                    log.warning(f"[stream] rank={self.rank}.w{worker_id} read error on {repo_id}: {e}")
+                    time.sleep(1.0)
+                    continue
+
+                text = row.get(text_field)
+                if not text:
+                    continue
+
+                try:
+                    ids = self.tok.encode(text).ids
+                except Exception:
+                    continue
+                ids.append(self.eos_id)
+                buf.extend(ids)
+                buf_source = repo_id
+
+                while len(buf) >= need:
+                    chunk = buf[:need]
+                    buf   = buf[need:]
+                    arr = np.array(chunk, dtype=np.int64).reshape(self.batch_size, self.max_len)
+                    if self._stop.is_set():
+                        return
+                    self._q.put((torch.from_numpy(arr), buf_source))
+        except Exception as e:
+            log.error(f"[stream] rank={self.rank}.w{worker_id} fetch loop crashed: {e}")
+
+    def __iter__(self) -> Iterator[Tuple[torch.Tensor, str]]:
+        return self
+
+    def __next__(self) -> Tuple[torch.Tensor, str]:
+        while not self._stop.is_set():
+            try:
+                return self._q.get(timeout=60)
+            except queue.Empty:
+                log.warning(f"[stream] rank={self.rank} queue empty — waiting for data …")
+        raise StopIteration
+
+    def close(self):
+        self._stop.set()
+        # drain so blocked producers can exit
+        try:
+            while True: self._q.get_nowait()
+        except queue.Empty:
+            pass
+        for t in self._workers:
+            t.join(timeout=5)
+
+
+def build_val_loader(cfg: Config) -> Optional[DataLoader]:
+    """
+    BUGFIX: this is now built on EVERY rank, not just rank 0, because
+    validate() runs a model forward (= FSDP collectives) on every rank.
+    The stream is deliberately NOT sharded, so every rank tokenizes the same
+    first N rows and the loaders have identical length — otherwise ranks
+    would issue different numbers of forwards and deadlock.
+    """
+    if not HAS_DATASETS:
+        return None
+    tok = get_tokenizer(cfg)
+    repo_id, split, text_field, _ = max(cfg.dataset_sources, key=lambda s: s[3])
+    try:
+        ds = load_dataset(repo_id, split=split, streaming=True)
+    except Exception as e:
+        log.warning(f"[val] could not open {repo_id}: {e}")
+        return None
+
+    eos_id = _resolve_eos(tok)
+    buf: List[int] = []
+    rows = []
+    n_val_seqs = 128
+    try:
+        for row in ds:
+            text = row.get(text_field)
+            if not text:
+                continue
+            ids = tok.encode(text).ids
+            ids.append(eos_id)
+            buf.extend(ids)
+            while len(buf) >= cfg.max_len:
+                rows.append(np.array(buf[:cfg.max_len], dtype=np.int64))
+                buf = buf[cfg.max_len:]
+                if len(rows) >= n_val_seqs:
+                    break
+            if len(rows) >= n_val_seqs:
+                break
+    except Exception as e:
+        log.warning(f"[val] stream error: {e}")
+
+    if not rows:
+        log.warning(f"[val] got no validation rows from {repo_id}")
+        return None
+    data = np.stack(rows, axis=0)
+
+    class _ValDS(Dataset):
+        def __len__(self):         return len(data)
+        def __getitem__(self, i):  return torch.from_numpy(data[i])
+
+    return DataLoader(_ValDS(), batch_size=min(cfg.micro_batch, 4),
+                      shuffle=False, num_workers=0, pin_memory=True, drop_last=True)
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  CHECKPOINTING
+#  get_/set_model_state_dict and the optimizer equivalents are COLLECTIVE.
+#  Every rank calls them; only rank 0 touches the filesystem.
+# ─────────────────────────────────────────────────────────────────────────────
+def save_ckpt(model, muon, adamw, step, epoch, cfg, loss, is_master: bool):
+    opts = StateDictOptions(full_state_dict=True, cpu_offload=True)
+    model_sd = get_model_state_dict(model, options=opts)
+    try:
+        muon_sd  = get_optimizer_state_dict(model, muon,  options=opts)
+    except Exception as e:
+        log.warning(f"[ckpt] could not gather muon state: {e}"); muon_sd = {}
+    try:
+        adamw_sd = get_optimizer_state_dict(model, adamw, options=opts)
+    except Exception as e:
+        log.warning(f"[ckpt] could not gather adamw state: {e}"); adamw_sd = {}
+
+    if not is_master:
+        return
+    name  = f"g1_s{SESSION_ID:03d}_step{step:07d}"
+    local = os.path.join(TEMP_CKPT_DIR, f"{name}.pt")
+    torch.save({'model': model_sd, 'muon': muon_sd, 'adamw': adamw_sd,
+                'step': step, 'epoch': epoch, 'loss': loss, 'config': asdict(cfg)}, local)
+    upload_to_hf(local, f"{name}.pt")
+    try: os.remove(local)
+    except OSError: pass
+
+def _find_latest_ckpt():
+    for sid in range(SESSION_ID, 0, -1):
+        repo = f"{REPO_PREFIX}{sid:03d}"
+        try:
+            files = hf_api.list_repo_files(repo_id=repo, repo_type="model", token=HF_TOKEN)
+        except Exception:
+            continue
+        ckpts = sorted([f for f in files if f.endswith(".pt") and "step" in f],
+                       key=lambda x: int(x.split("step")[-1].split(".")[0]))
+        if ckpts:
+            return repo, ckpts[-1]
+    return None, None
+
+def load_ckpt(model, muon, adamw, device, is_master: bool):
+    """
+    BUGFIX: the previous version did broadcast_object_list() on the ENTIRE
+    checkpoint dict — pickling a full ~20B-parameter state dict and shipping
+    it to all 8 ranks over the object collective. That's tens of GB of host
+    RAM per rank and would almost certainly die.
+
+    The correct FSDP2 pattern: only rank 0 loads the file, and
+    StateDictOptions(full_state_dict=True, broadcast_from_rank0=True) makes
+    set_*_state_dict broadcast-and-reshard it. Non-master ranks pass {}.
+    Only the three scalars (step/epoch/loss) need a real broadcast.
+    """
+    ckpt = None
+    meta = torch.zeros(3, dtype=torch.float64, device=device)  # [found, step, epoch] + loss
+    loss_t = torch.zeros(1, dtype=torch.float64, device=device)
+
+    if is_master:
+        repo, ckpt_name = _find_latest_ckpt()
+        if repo is None:
+            log.warning("[ckpt] no checkpoint in this or any earlier session repo — fresh start")
+        else:
+            try:
+                path = hf_hub_download(repo, ckpt_name, cache_dir=TEMP_CKPT_DIR, token=HF_TOKEN)
+                ckpt = torch.load(path, map_location="cpu", weights_only=False)
+                meta[0] = 1.0
+                meta[1] = float(ckpt['step'])
+                meta[2] = float(ckpt['epoch'])
+                loss_t[0] = float(ckpt['loss'])
+                if repo != HF_MODEL_REPO:
+                    log.info(f"[ckpt] resuming from an EARLIER session's repo: {repo}/{ckpt_name}")
+            except Exception as e:
+                log.error("=" * 66)
+                log.error(f"[ckpt] FOUND {repo}/{ckpt_name} BUT COULD NOT LOAD IT: {e}")
+                log.error("[ckpt] falling back to fresh start — check this before trusting the run")
+                log.error("=" * 66)
+                ckpt = None
+
+    if dist_ready():
+        dist.broadcast(meta,   src=0)
+        dist.broadcast(loss_t, src=0)
+
+    if meta[0].item() < 0.5:
+        return 0, 0, float('inf')
+
+    # BUGFIX: broadcast_from_rank0 REQUIRES full_state_dict=True. The old code
+    # passed only broadcast_from_rank0 and would raise.
+    opts = StateDictOptions(full_state_dict=True, broadcast_from_rank0=True)
+    set_model_state_dict(model,
+                         model_state_dict=(ckpt['model'] if is_master else {}),
+                         options=opts)
+    try:
+        set_optimizer_state_dict(model, muon,
+                                 optim_state_dict=(ckpt['muon'] if is_master else {}),
+                                 options=opts)
+    except Exception as e:
+        log.warning(f"[ckpt] muon state not restored: {e}")
+    try:
+        set_optimizer_state_dict(model, adamw,
+                                 optim_state_dict=(ckpt['adamw'] if is_master else {}),
+                                 options=opts)
+    except Exception as e:
+        log.warning(f"[ckpt] adamw state not restored: {e}")
+
+    step, epoch, loss = int(meta[1].item()), int(meta[2].item()), float(loss_t[0].item())
+    if is_master:
+        log.info(f"[ckpt] resumed step={step}  loss={loss:.4f}")
+    del ckpt
+    gc.collect()
+    return step, epoch, loss
+
+def save_final(model, cfg, step, epoch, loss, is_master: bool):
+    opts = StateDictOptions(full_state_dict=True, cpu_offload=True)
+    model_sd = get_model_state_dict(model, options=opts)
+    if not is_master:
+        return
+    name  = f"g1_final_s{SESSION_ID:03d}_step{step:07d}"
+    mname = f"{name}.safetensors" if HAS_ST else f"{name}.pt"
+    mpath = os.path.join(TEMP_CKPT_DIR, mname)
+    cpath = os.path.join(TEMP_CKPT_DIR, f"{name}_config.json")
+    if HAS_ST:
+        st_save({k: v.contiguous() for k, v in model_sd.items()}, mpath)
+    else:
+        torch.save(model_sd, mpath)
+    with open(cpath, 'w') as f:
+        json.dump({**asdict(cfg), 'step': step, 'epoch': epoch,
+                   'loss': loss, 'arch': 'Smilyai-G1-20B'}, f, indent=2)
+    upload_to_hf(mpath, mname); upload_to_hf(cpath, os.path.basename(cpath))
+    for p in (mpath, cpath):
+        try: os.remove(p)
+        except OSError: pass
+
+@torch.no_grad()
+def validate(model, val_loader, device, cfg, n=100):
+    """
+    BUGFIX: COLLECTIVE — every rank must call this with an identically-sized
+    loader. Previously it ran on rank 0 only and hung the other 7 on the
+    following barrier while rank 0 waited forever inside an all-gather.
+    """
+    if val_loader is None:
+        return float('nan')
+    was_training = model.training
+    model.eval(); losses = []
+    for i, batch in enumerate(val_loader):
+        if i >= n: break
+        batch = batch.to(device, non_blocking=True)
+        with torch.amp.autocast('cuda', dtype=cfg.dtype):
+            _, loss = model(batch, batch)
+        lm = getattr(model, '_last_lm_loss', None)
+        lm = lm if lm is not None else loss
+        if lm is not None and torch.isfinite(lm):
+            losses.append(lm.item())
+    if was_training: model.train()
+    local = float(np.mean(losses)) if losses else float('nan')
+    if math.isnan(local):
+        return local
+    return distributed_mean(local, device)
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  TRAIN
+# ─────────────────────────────────────────────────────────────────────────────
+def train():
+    if not torch.cuda.is_available():
+        raise RuntimeError("this script requires CUDA GPUs")
+
+    local_rank = int(os.environ.get("LOCAL_RANK", "0"))
+    rank       = int(os.environ.get("RANK", "0"))
+    world_size = int(os.environ.get("WORLD_SIZE", "1"))
+    torch.cuda.set_device(local_rank)
+    device = torch.device("cuda", local_rank)
+    if world_size > 1 and not dist_ready():
+        dist.init_process_group(backend="nccl", init_method="env://", device_id=device)
+    is_master = (rank == 0)
+
+    # keep the log readable: non-master ranks only speak up when something breaks
+    if not is_master:
+        log.setLevel(logging.WARNING)
+
+    torch.manual_seed(42 + rank); np.random.seed(42 + rank); random.seed(42 + rank)
+
+    log.info(f"[env] rank={rank}/{world_size} device={device} | "
+             f"GPU={torch.cuda.get_device_name(local_rank)} | VRAM={vram_total_gb():.0f}GB")
+
+    if is_master:
+        ensure_repo()
+        session_banner()
+        _bootstrap_from_hub(METRICS_FILE, os.path.basename(METRICS_FILE))
+        _bootstrap_from_hub(SAMPLES_FILE, "samples.md")
+        _bootstrap_from_hub(SUMMARY_FILE, "summary.jsonl")
+    if dist_ready():
+        dist.barrier()
+
+    cfg = Config()
+    try:
+        get_tokenizer(cfg)
+    except Exception as e:
+        log.warning(f"[tokenizer] pre-load failed, will retry lazily: {e}")
+
+    model = SmilyaiG1(cfg).to(device).to(cfg.dtype)
+    # BUGFIX: .to(bfloat16) above hits every buffer. RoPE tables and the MoE
+    # load-balancing statistics must be fp32 — put them back before sharding.
+    model.init_rope(device)
+    model.force_fp32_balancing_buffers()
+
+    model = apply_fp8(model, cfg, is_master)   # BEFORE fsdp — swaps nn.Linear in place
+    model = apply_fsdp(model, cfg)
+
+    if cfg.use_compile:
+        try:
+            for i, block in enumerate(model.blocks):
+                model.blocks[i] = torch.compile(block, dynamic=True)
+            log.info(f"[compile] compiled {len(model.blocks)} blocks")
+        except Exception as e:
+            log.warning(f"[compile] failed, running eager: {e}")
+    else:
+        if is_master: log.info("[compile] skipped")
+
+    muon, adamw = build_optimizers(model, cfg, is_master)
+
+    start_step, start_epoch, best_loss = load_ckpt(model, muon, adamw, device, is_master)
+    if dist_ready():
+        dist.barrier()
+
+    last_val = float('nan')
+    bs = cfg.micro_batch
+
+    stream = LiveStreamingDataset(cfg, batch_size=bs, rank=rank, world_size=world_size)
+    # BUGFIX: built on ALL ranks — validate() is collective.
+    val_loader = build_val_loader(cfg)
+
+    if is_master:
+        log.info("=" * 70)
+        log.info(f"Smilyai-G1 | {model.count_params()/1e9:.2f}B total params | "
+                 f"Session {SESSION_ID} | FSDP2 world={world_size}")
+        log.info(f"  micro_batch={bs}/GPU  grad_accum={cfg.grad_accum}  "
+                 f"eff_batch={bs*cfg.grad_accum*world_size}  max_len={cfg.max_len}")
+        log.info(f"  {cfg.tokens_per_step(bs, world_size)/1e6:.1f}M tok/step | "
+                 f"{MAX_HOURS}h budget | streaming=True")
+        log.info("=" * 70)
+
+    step, epoch = start_step, start_epoch
+    losses      = []
+    aux_losses  = []
+    model.train(); model.zero_grad(set_to_none=True)
+    t0 = time.time(); last_ckpt = time.time()
+
+    # BUGFIX: was master-only -> guaranteed hang on the first FSDP all-gather.
+    try:
+        record_sample(model, step, is_master)
+    except Exception as e:
+        log.warning(f"[sample] {e}")
+
+    # NOTE: gradient accumulation now reduce-scatters on EVERY micro-step.
+    # The old code used set_requires_gradient_sync(False) for the first 15 of
+    # 16 micro-steps, which makes FSDP2 keep gradients UNSHARDED for the whole
+    # accumulation window — a full replica of every gradient on every rank
+    # (~40GB at bf16 for this model). Syncing every micro-step costs extra
+    # NVLink traffic but is the only version that fits.
+
+    accum_n = 0
+    while not distributed_should_stop(device, is_master, step, cfg.total_steps):
+        try:
+            batch, folder = next(stream)
+        except StopIteration:
+            log.warning(f"[stream] rank={rank} exhausted — sleeping 60s")
+            time.sleep(60); continue
+        except Exception as e:
+            log.error(f"[data] rank={rank} {e}"); time.sleep(5); continue
+
+        batch = batch.to(device, non_blocking=True)
+
+        micro_ok = True
+        try:
+            with torch.amp.autocast('cuda', dtype=cfg.dtype):
+                _, loss = model(batch, batch)
+                loss_s  = loss / cfg.grad_accum
+
+            if not torch.isfinite(loss):
+                micro_ok = False
+            else:
+                loss_s.backward()
+                lm_only  = getattr(model, '_last_lm_loss', loss)
+                aux_only = getattr(model, '_last_aux_loss', None)
+                losses.append(float(lm_only))
+                aux_losses.append(float(aux_only) if aux_only is not None else 0.0)
+        except RuntimeError as e:
+            if "out of memory" in str(e).lower() or "memory" in str(e).lower():
+                log.error(f"[oom] rank={rank} step={step}: {e}")
+                micro_ok = False
+                torch.cuda.empty_cache()
+            else:
+                raise
+
+        # BUGFIX: OOM/NaN recovery must be a COLLECTIVE decision. Previously
+        # one rank could `continue` while the others walked into the optimizer
+        # step, and the next collective would deadlock the whole job.
+        if not all_ok(micro_ok, device):
+            if is_master: log.error(f"[skip] step={step} micro-batch failed on >=1 rank")
+            model.zero_grad(set_to_none=True); accum_n = 0
+            continue
+
+        accum_n += 1
+        if accum_n < cfg.grad_accum:
+            continue
+
+        mlr = cosine_lr(step, cfg.warmup, cfg.total_steps, cfg.muon_lr, cfg.muon_min_lr)
+        alr = cosine_lr(step, cfg.warmup, cfg.total_steps, cfg.adamw_lr, cfg.adamw_min_lr)
+        for g in muon.param_groups:  g['lr'] = mlr
+        for g in adamw.param_groups: g['lr'] = alr
+
+        norm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.grad_clip)
+        # BUGFIX: with FSDP2 this returns a DTensor; isnan/isinf on it is not
+        # a reliable python bool. Materialize it first.
+        if isinstance(norm, DTensor):
+            norm = norm.full_tensor()
+        if not torch.isfinite(norm):
+            if is_master: log.error("[nan] grad-norm non-finite — skipping step")
+            model.zero_grad(set_to_none=True); accum_n = 0; continue
+
+        muon.step(); adamw.step(); model.zero_grad(set_to_none=True)
+
+        step += 1
+        model.set_step(step)
+        accum_n = 0
+        if len(losses) > 500: losses = losses[-500:]
+        if len(aux_losses) > 500: aux_losses = aux_losses[-500:]
+
+        # collective — every rank, every time it's due
+        if step % cfg.bias_update_every == 0:
+            model.update_expert_bias()
+
+        if step % cfg.log_every == 0 and losses:
+            avg     = distributed_mean(float(np.mean(losses[-50:])), device)
+            avg_aux = distributed_mean(float(np.mean(aux_losses[-50:])), device) if aux_losses else 0.0
+            _step_clock.append((step, time.time()))
+            if len(_step_clock) > 300: _step_clock.pop(0)
+            sph = _real_steps_per_hour()
+            tps = (sph * cfg.tokens_per_step(bs, world_size) / 3600) if sph else \
+                  (max(step - start_step, 1) * cfg.tokens_per_step(bs, world_size) / max(time.time() - t0, 1))
+            if is_master:
+                log_metrics(step=step, loss=avg, aux=avg_aux, tok_s=tps, folder=folder)
+                sl = sessions_left(step, cfg.total_steps)
+                suffix = f" | ~{sl} more sessions" if sl is not None else ""
+                log.info(f"step {step:06d} | ep {epoch+1} | lm {avg:.4f} | aux {avg_aux:.4f} | "
+                         f"ppl {math.exp(min(avg,20)):.1f} | {tps/1e3:.1f}K tok/s | "
+                         f"{vram_str()} | {remaining_h():.1f}h left | {folder}{suffix}")
+
+        # ── eval: COLLECTIVE, all ranks ───────────────────────────────────
+        if step % cfg.eval_every == 0:
+            vl = validate(model, val_loader, device, cfg)
+            if is_master and vl == vl:
+                marker = " *NEW BEST*" if vl < best_loss else ""
+                if vl < best_loss: best_loss = vl
+                last_val = vl
+                log_metrics(step=step, val_loss=vl)
+                log.info(f"  [val] loss={vl:.4f} ppl={math.exp(min(vl,20)):.1f}{marker}")
+
+                dead, total_dead, capped, total_capped = model.dead_expert_report()
+                total_experts = cfg.n_experts * cfg.n_layers
+                if total_dead > 0:
+                    log.info(f"  [experts] dead={total_dead}/{total_experts}")
+                else:
+                    log.info(f"  [experts] all {total_experts} experts alive ✅")
+                if total_capped > 0:
+                    log.info(f"  [experts] bias-capped={total_capped}/{total_experts}")
+
+            try:
+                record_sample(model, step, is_master)   # collective on all ranks
+            except Exception as e:
+                log.warning(f"[sample] {e}")
+            if dist_ready():
+                dist.barrier()
+
+        # ── checkpoint: gate decided by rank 0 and broadcast ──────────────
+        # BUGFIX: `(time.time() - last_ckpt) > 1800` is wall-clock and is NOT
+        # identical across ranks. When it flipped on some ranks and not others,
+        # the ones that entered save_ckpt() blocked forever in the state-dict
+        # all-gather while the rest ran ahead. Rank 0 now decides for everyone.
+        local_due = (step % cfg.ckpt_every == 0) or ((time.time() - last_ckpt) > 1800)
+        if broadcast_flag(local_due if is_master else False, device):
+            save_ckpt(model, muon, adamw, step, epoch, cfg,
+                      losses[-1] if losses else 0.0, is_master)
+            if is_master:
+                update_progress_md(cfg, step, epoch,
+                                   float(np.mean(losses[-50:])) if losses else None, last_val)
+                make_loss_chart(); upload_metrics()
+            if dist_ready():
+                dist.barrier()
+            last_ckpt = time.time()
+
+    log.info(f"[rank {rank}] DONE training loop")
+    stream.close()
+
+    # BUGFIX: final validate is collective too — all ranks, then rank 0 reports.
+    vm = validate(model, val_loader, device, cfg, n=300)
+    if vm != vm:
+        vm = losses[-1] if losses else 0.0
+    save_final(model, cfg, step, epoch, vm, is_master)
+    if is_master:
+        try:
+            update_progress_md(cfg, step, epoch,
+                               float(np.mean(losses[-50:])) if losses else None, vm)
+            make_loss_chart(); upload_metrics()
+        except Exception as e:
+            log.warning(f"[motiv] final refresh failed: {e}")
+        log.info(f"Steps={step:,} | Epochs={epoch+1} | Time={elapsed_h():.2f}h | Final val={vm:.4f}")
+
+    if dist_ready():
+        dist.barrier()
+        dist.destroy_process_group()
+
+
+def _spawn_worker(local_rank: int, world_size: int):
+    os.environ["LOCAL_RANK"] = str(local_rank)
+    os.environ["RANK"]       = str(local_rank)
+    os.environ["WORLD_SIZE"] = str(world_size)
+    train()
+
+
+def launch():
+    if "RANK" in os.environ and "WORLD_SIZE" in os.environ:
+        train()
+        return
+
+    world_size = torch.cuda.device_count()
+    if world_size < 1:
+        raise RuntimeError("No CUDA GPUs are visible")
+    expected_world = int(os.environ.get("EXPECTED_WORLD_SIZE", str(world_size)))
+    if world_size != expected_world:
+        raise RuntimeError(
+            f"Expected {expected_world} visible GPUs, found {world_size}; "
+            "refusing to run with the wrong allocation"
+        )
+
+    os.environ.setdefault("MASTER_ADDR", "127.0.0.1")
+    os.environ.setdefault("MASTER_PORT", "29500")
+    os.environ.setdefault("TORCH_NCCL_ASYNC_ERROR_HANDLING", "1")
+    mp.spawn(_spawn_worker, args=(world_size,), nprocs=world_size, join=True)
+
+
+if __name__ == "__main__":
+    launch()