Update train.py

train.py

@@ -8,7 +8,7 @@
 #   "datasets>=2.19",
 #   "tokenizers>=0.20",
 #   "bitsandbytes",
-#   "torchao",
+#   "torchao"
 # ]
 # ///
 
@@ -16,30 +16,39 @@
 Smilyai-G1 : Fast Sparse General-Assistant Transformer — FSDP2 EDITION (8xH200)
 ~20B total params | ~2B active per token
 
-FIXED EDITION v2. Changes in this pass:
-
-  1. MUON SCALE BUG (critical): the Newton-Schulz update multiplier was
-     `0.2 * sqrt(max(rows, cols))` — for d_model=2048 matrices that's ~45x
-     too large (sqrt(2048)≈45.25). Correct Muon uses the ASPECT RATIO of the
-     matrix: `max(1, rows/cols)**0.5`, which is ~1.0 for square-ish matrices.
-     Every Muon-optimized weight (attention, MoE experts, router) was getting
-     hammered with ~45x oversized updates every step — this produces fast
-     early "progress" (coarse structure survives noisy updates) followed by a
-     hard plateau because fine-grained learning gets destroyed by the noise
-     floor. Fixed here; muon_lr raised 0.008 -> 0.02 to compensate for the
-     ~45x smaller effective step (standard Muon LR for this model scale).
-
-  2. CHECKPOINT I/O WAS BLOCKING (caused a real NCCL watchdog crash): rank 0's
-     torch.save() + upload_file() for an ~80-100GB checkpoint could take
-     longer than the default 10-minute NCCL collective timeout, while ranks
-     1-7 sat idle at dist.barrier(). Fix: checkpoint save/upload now happens
-     on a background thread on rank 0. All 8 ranks return to training
-     immediately after the (fast) state-dict gather; the slow disk/network
-     work no longer blocks any collective. The barrier that used to follow
-     the checkpoint block has been removed since rank 0 no longer lags.
-
-  3. NCCL timeout raised from the 10-minute default to 60 minutes as a safety
-     net for any other slow collective we haven't found yet.
+FIXED EDITION v3. Changes in this pass on top of v2:
+
+  4. STACK-V3 SILENT DATA LOSS (critical): HuggingFaceCode/stack-v3-train has
+     ONE ROW PER REPOSITORY, with actual code nested under row["files"][i]
+     ["content"] — NOT under a top-level "content" field. The old code did
+     `row.get("content")`, which is None on every row of this dataset, so
+     100% of stack-v3 rows were silently dropped for the entire run. Combined
+     with `if not text: continue`, this meant zero code tokens were ever fed
+     to the model despite stack-v3 being configured for 20% of the sampling
+     weight. Fixed with a dataset-aware _extract_text() that walks files[],
+     filters by language and size, and joins them into one training string.
+
+  5. STREAMING DATASETS DO NOT SHUFFLE BY DEFAULT. `.shard()` just assigns
+     shard FILES to workers; rows within a shard are read in stored order.
+     Since stream position is never checkpointed, every session restart
+     re-reads the same opening rows of the same shard files before reaching
+     new content. Added `.shuffle(buffer_size=..., seed=session-dependent)`
+     to each opened stream so different sessions see different orderings —
+     this reduces (does not eliminate) repeat exposure across restarts.
+
+  6. torch.compile WIRED IN: compiled per-block (after fully_shard, which is
+     the FSDP2-recommended order), dynamic=True to tolerate the MoE routing
+     dispatch's data-dependent shapes, dynamo cache size raised so the many
+     distinct (padded_total, expert-count) shape combinations don't blow the
+     recompile limit, and wrapped in try/except so a compile failure falls
+     back to eager instead of crashing a 6-day run.
+
+  7. RESUME CONFIG-MISMATCH GUARD: on load, the checkpoint's saved config is
+     compared against the live Config() for architecture-critical fields
+     (d_model, n_layers, n_heads, n_kv_heads, n_experts, vocab_size). A
+     mismatch is fatal-loud instead of silently corrupting a load — dataset
+     mix changes are fine and expected across sessions, architecture changes
+     are not resumable.
 
 The load-bearing invariant of this file remains:
 
@@ -47,8 +56,8 @@ The load-bearing invariant of this file remains:
 
 RUN:
     export HF_TOKEN=your_hf_token_here
-    export G1_SESSION_ID=2                 # NEW session — see notes above
-    export MAX_TRAINING_HOURS=144          # 6 days
+    export G1_SESSION_ID=3
+    export MAX_TRAINING_HOURS=144
     torchrun --nproc_per_node=8 train_g1_fsdp.py
 """
 
@@ -115,6 +124,21 @@ torch.backends.cudnn.allow_tf32 = True
 torch.backends.cuda.enable_flash_sdp(True)
 torch.backends.cuda.enable_mem_efficient_sdp(True)
 
+# ── torch.compile / dynamo tuning ───────────────────────────────────────────
+# MoE routing produces data-dependent shapes (total_padded varies with token
+# distribution across experts each step). Automatic dynamic shapes will
+# eventually stabilize these into symbolic dims, but only if we don't hit the
+# recompile cache limit first. Raised well above default; suppress_errors so
+# a rare compile edge case degrades to eager for that call instead of killing
+# a 6-day unattended run.
+try:
+    import torch._dynamo
+    torch._dynamo.config.cache_size_limit = 256
+    torch._dynamo.config.suppress_errors = True
+    torch._dynamo.config.capture_scalar_outputs = True
+except Exception:
+    pass
+
 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}")
@@ -123,8 +147,8 @@ 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", "2"))
-REPO_PREFIX = "hugging-science/Smilyai-G1-20B-v2-session-"
+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:
@@ -142,7 +166,7 @@ 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", "110.0"))
+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()
@@ -245,12 +269,6 @@ DOMAIN_TOKEN = ""
 
 @torch.no_grad()
 def make_sample(model, prompt="def fibonacci(n):", max_new=48, temp=0.8, top_p=0.95):
-    """
-    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
@@ -263,7 +281,7 @@ def make_sample(model, prompt="def fibonacci(n):", max_new=48, temp=0.8, top_p=0
         log.warning(f"[sample] tokenizer error: {e}"); return None
 
     gen = torch.Generator(device=device)
-    gen.manual_seed(1234)   # identical on all ranks -> identical trajectory
+    gen.manual_seed(1234)
 
     was_training = model.training
     model.eval()
@@ -287,7 +305,6 @@ def make_sample(model, prompt="def fibonacci(n):", max_new=48, temp=0.8, top_p=0
         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
@@ -352,7 +369,7 @@ class Config:
     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_update_every: int   = 10
     bias_cap:          float = 2.0
     bias_decay:        float = 0.0005
     usage_ema_decay:   float = 0.99
@@ -360,8 +377,6 @@ class Config:
 
     tie_embeddings:   bool  = True
 
-    # ── FIX #1: Muon LR raised to compensate for the corrected (~45x smaller)
-    # update scale. 0.02 is the standard Muon LR at this model scale.
     muon_lr:     float = 0.02
     muon_min_lr: float = 0.002
     muon_mom:    float = 0.95
@@ -386,6 +401,11 @@ class Config:
     dpo_every:         int  = 500
     dpo_beta:          float= 0.1
 
+    # ── FIX #4: repo name was already correct — the bug was the text field
+    # assumption, not the name. stack-v3-train stores code nested under
+    # row["files"][i]["content"], handled by _extract_text() below. The
+    # "content" placeholder here is now just documentation of what the
+    # extractor looks for at the leaf level.
     dataset_sources: tuple = (
         ("HuggingFaceFW/fineweb-edu",                  "train", "text",     200_000_000_000),
         ("HuggingFaceCode/stack-v3-train",             "train", "content",  100_000_000_000),
@@ -396,9 +416,13 @@ class Config:
     )
     tokenizer_repo: str = "Smilyai-labs/Smilyai-U1-B-Tokenizer"
     tokenizer_workers: int = 8
-    prefetch_shards: int = 6
+    prefetch_shards: int = 20   # raised from 6 — more buffer against network hiccups
+
+    # ── FIX #5: shuffle buffer to reduce restart-repeat exposure ────────────
+    shuffle_buffer: int = 10_000
 
-    use_compile: bool = False
+    # ── FIX #6: compile now on by default, tuned for MoE's dynamic shapes ──
+    use_compile: bool = True
     use_fp8: bool = False
 
     @property
@@ -407,6 +431,19 @@ class Config:
     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
 
+    def arch_fingerprint(self) -> dict:
+        """Fields that MUST match across a checkpoint resume. Dataset mix,
+        LR schedule, batch size etc. are all safe to change between sessions
+        — these are not."""
+        return {
+            "vocab_size": self.vocab_size, "d_model": self.d_model,
+            "n_layers": self.n_layers, "n_heads": self.n_heads,
+            "n_kv_heads": self.n_kv_heads, "n_experts": self.n_experts,
+            "top_k": self.top_k, "expert_hidden_mult": self.expert_hidden_mult,
+            "shared_hidden_mult": self.shared_hidden_mult,
+            "tie_embeddings": self.tie_embeddings,
+        }
+
 # ─────────────────────────────────────────────────────────────────────────────
 #  DISTRIBUTED HELPERS
 # ─────────────────────────────────────────────────────────────────────────────
@@ -421,16 +458,12 @@ def distributed_mean(value: float, device: torch.device) -> float:
     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)
@@ -549,7 +582,6 @@ def precompute_rope(head_dim, max_len, theta, device):
     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)
@@ -650,8 +682,6 @@ def _moe_gemm_kernel(
 
 
 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
@@ -749,8 +779,6 @@ class GroupedLinearFn(torch.autograd.Function):
 
 
 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
 
@@ -788,9 +816,9 @@ class MoEFFN(nn.Module):
         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.gate_w = nn.Parameter(torch.empty(E, h, 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)
+        self.down_w = nn.Parameter(torch.empty(E, d, 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))
@@ -823,7 +851,6 @@ class MoEFFN(nn.Module):
 
     @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)
 
@@ -931,7 +958,14 @@ class SmilyaiG1(nn.Module):
         self._log_summary()
 
     def _raw_blocks(self):
-        return [getattr(b, "_orig_mod", b) for b in self.blocks]
+        """Unwraps BOTH FSDP2 wrapping AND torch.compile's OptimizedModule
+        wrapping, so .ffn / .attn access always works regardless of which
+        wrappers are active."""
+        raw = []
+        for b in self.blocks:
+            m = getattr(b, "_orig_mod", b)   # unwrap compile
+            raw.append(m)
+        return raw
 
     def init_rope(self, device):
         c, s = precompute_rope(self.cfg.head_dim, self.cfg.max_len, self.cfg.rope_theta, device)
@@ -960,7 +994,8 @@ class SmilyaiG1(nn.Module):
         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(f"  Muon LR: {cfg.muon_lr} (aspect-ratio scaling — FIXED)")
+        log.info(f"  Muon LR: {cfg.muon_lr} (aspect-ratio scaling)")
+        log.info(f"  Compile: {cfg.use_compile}")
         log.info("=" * 70)
 
     def count_params(self): return sum(p.numel() for p in self.parameters())
@@ -1045,8 +1080,51 @@ def apply_fsdp(model: SmilyaiG1, cfg: Config) -> SmilyaiG1:
     fully_shard(model, mp_policy=mp_policy)
     return model
 
+def apply_compile(model: SmilyaiG1, cfg: Config, is_master: bool) -> SmilyaiG1:
+    """
+    *** FIX #6 ***
+    Must run AFTER apply_fsdp — FSDP2's recommended composition order is
+    shard-then-compile, applied per transformer block (not the whole model),
+    because compiling the root model would try to trace across FSDP's
+    all-gather/reduce-scatter boundaries.
+
+    dynamic=True because the MoE grouped-GEMM dispatch produces a different
+    `total_padded` token count every step (depends on how tokens route to
+    experts) — without this, every step with a new shape would trigger a
+    full recompile. PyTorch's automatic dynamic shapes will still need a
+    couple of steps to stabilize into symbolic dims; expect the first
+    20-50 steps after enabling compile to be slower (recompiling), then
+    faster than eager once shapes settle.
+
+    Wrapped in try/except per block: a compile failure on one block falls
+    back to eager for that block only, rather than crashing the whole run.
+    The custom Triton autograd Functions (_TritonRMSNormFn, _FusedSwiGLUFn)
+    are already marked @torch.compiler.disable, so compile treats them as
+    opaque black-box calls — correct and intentional, no change needed
+    there.
+    """
+    if not cfg.use_compile:
+        if is_master: log.info("[compile] disabled")
+        return model
+    try:
+        compiled = 0
+        for i, block in enumerate(model.blocks):
+            try:
+                model.blocks[i] = torch.compile(block, dynamic=True, mode="max-autotune-no-cudagraphs")
+                compiled += 1
+            except Exception as e:
+                if is_master:
+                    log.warning(f"[compile] block {i} failed to compile, staying eager: {e}")
+        if is_master:
+            log.info(f"[compile] compiled {compiled}/{len(model.blocks)} blocks "
+                     f"(dynamic=True — expect slower first ~50 steps while shapes stabilize)")
+    except Exception as e:
+        if is_master:
+            log.warning(f"[compile] setup failed entirely, running eager: {e}")
+    return model
+
 # ─────────────────────────────────────────────────────────────────────────────
-#  MUON — DTensor-aware — *** SCALE BUG FIXED HERE ***
+#  MUON — DTensor-aware — CORRECT aspect-ratio scale
 # ─────────────────────────────────────────────────────────────────────────────
 def newton_schulz_5(G: torch.Tensor, steps: int = 5) -> torch.Tensor:
     a, b, c = 3.4445, -4.7750, 2.0315
@@ -1063,7 +1141,6 @@ def newton_schulz_5(G: torch.Tensor, steps: int = 5) -> torch.Tensor:
 
 @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)
@@ -1073,27 +1150,6 @@ def stochastic_round_to(dtype: torch.dtype, x_fp32: torch.Tensor) -> torch.Tenso
 
 
 class Muon(torch.optim.Optimizer):
-    """
-    Memory: momentum buffer stays SHARDED (same layout as the local gradient
-    shard) — only the transient Newton-Schulz step gathers a full parameter,
-    one at a time, freed immediately after use.
-
-    *** SCALE FIX ***
-    The Newton-Schulz output `u` is an (approximately) orthogonalized matrix
-    — its operator norm is ~1 regardless of the gradient's original
-    magnitude. The correct Muon update multiplier is the ASPECT RATIO of the
-    matrix:
-
-        scale = max(1.0, rows / cols) ** 0.5      # ~1.0 for square-ish mats
-
-    NOT `sqrt(max(rows, cols))`, which for a d_model=2048 square-ish matrix
-    evaluates to sqrt(2048) ≈ 45.25 — roughly 45x too large. That bug was
-    silently blowing up every Muon-optimized weight (attention, MoE experts,
-    router) by ~45x every step, which produces fast-looking early loss drops
-    followed by a hard plateau because the true gradient signal gets
-    drowned out by oversized noise. muon_lr has been raised in Config to
-    compensate for the corrected (much smaller) effective step size.
-    """
     def __init__(self, params, lr=0.02, momentum=0.95, wd=0.0):
         super().__init__(list(params), dict(lr=lr, momentum=momentum, wd=wd))
 
@@ -1113,30 +1169,23 @@ class Muon(torch.optim.Optimizer):
                     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 + CORRECT aspect-ratio scale ---
                 if full.ndim in (2, 3):
                     u = newton_schulz_5(full)
                     rows, cols = full.shape[-2], full.shape[-1]
-                    # *** FIX: was `sqrt(max(rows, cols))` — ~45x too large
-                    # for d_model=2048 matrices. Correct Muon scale is the
-                    # matrix aspect ratio, ~1.0 for square-ish weights. ***
                     scale  = max(1.0, rows / cols) ** 0.5
                     update = u.to(torch.float32) * (lr * 0.2 * 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
@@ -1161,13 +1210,12 @@ def build_optimizers(model: SmilyaiG1, cfg: Config, is_master: bool):
             adamw_p.append(p)
 
     muon_opt = Muon(muon_p, lr=cfg.muon_lr, momentum=cfg.muon_mom, wd=cfg.wd)
-
     groups = [{'params': adamw_p, 'lr': cfg.adamw_lr}]
 
     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, FIXED scale) + foreach AdamW (DTensor-safe)")
+        if is_master: log.info("[optim] Muon (FIXED scale) + 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 (FIXED) + 8-bit AdamW (single GPU)")
@@ -1223,10 +1271,60 @@ def _resolve_eos(tok) -> int:
     return 0
 
 
-def _open_source_stream(repo_id: str, split: str, shard_index: int, num_shards: int):
+# ── FIX #4: dataset-aware text extraction ────────────────────────────────────
+_STACK_KEEP_LANGS = {
+    "Python", "JavaScript", "TypeScript", "Java", "C", "C++", "C#",
+    "Go", "Rust", "Ruby", "PHP", "Swift", "Kotlin", "Scala", "Shell",
+    "SQL", "HTML", "CSS", "Markdown", "R", "Julia", "Lua", "Haskell",
+    "Elixir", "Erlang", "Dart", "Zig", "CUDA", "Fortran",
+}
+_MIN_CODE_CHARS = 64
+_MAX_CODE_CHARS = 65536
+
+def _extract_text(row: dict, text_field: str, repo_id: str) -> Optional[str]:
+    """
+    Universal text extractor.
+      - stack-v3-train: row["files"] is a list of {file_path, language,
+        content, license_type, ...}. There is NO top-level "content" field —
+        this was the bug that silently zeroed out all code training data.
+      - everything else: plain row[text_field] string.
+    """
+    if "stack-v3" in repo_id:
+        files = row.get("files")
+        if not files:
+            return None
+        parts = []
+        for f in files:
+            content = f.get("content", "")
+            if not content:
+                continue
+            lang = f.get("language", "")
+            if lang and lang not in _STACK_KEEP_LANGS:
+                continue
+            if len(content) < _MIN_CODE_CHARS or len(content) > _MAX_CODE_CHARS:
+                continue
+            fpath = f.get("file_path", "")
+            parts.append(f"# {fpath}\n{content}")
+        if not parts:
+            return None
+        return "\n\n".join(parts)
+
+    text = row.get(text_field)
+    if not text or not isinstance(text, str):
+        return None
+    return text
+
+
+def _open_source_stream(repo_id: str, split: str, shard_index: int, num_shards: int,
+                        shuffle_buffer: int = 0, shuffle_seed: int = 0):
     ds = load_dataset(repo_id, split=split, streaming=True)
     if num_shards > 1:
         ds = ds.shard(num_shards=num_shards, index=shard_index)
+    # FIX #5: session-seeded shuffle buffer — reduces (does not eliminate)
+    # repeat exposure to the same opening rows every time a session restarts,
+    # since streaming datasets have no persisted read position.
+    if shuffle_buffer > 0:
+        ds = ds.shuffle(buffer_size=shuffle_buffer, seed=shuffle_seed)
     return ds
 
 
@@ -1257,27 +1355,47 @@ class LiveStreamingDataset:
         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")
+                 f"({self.total_shards} global shards) | {len(cfg.dataset_sources)} sources | "
+                 f"shuffle_buffer={cfg.shuffle_buffer} session={SESSION_ID}")
 
     def _fetch_loop(self, worker_id: int):
         shard_index = self.rank * self.n_workers + worker_id
+        # session-dependent seed: different sessions get different shuffle
+        # orderings out of the buffer window, reducing exact repeat-on-resume
+        shuffle_seed = 1234 + shard_index + SESSION_ID * 97
         try:
             streams = []
+            failed  = []
             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)])
+                    streams.append([
+                        _open_source_stream(repo_id, split, shard_index, self.total_shards,
+                                           shuffle_buffer=self.cfg.shuffle_buffer,
+                                           shuffle_seed=shuffle_seed),
+                        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}")
+                    log.error(f"[stream] rank={self.rank}.w{worker_id} "
+                              f"FAILED TO OPEN {repo_id}: {e}")
+                    failed.append(repo_id)
+
+            if failed:
+                log.error(f"[stream] rank={self.rank}.w{worker_id} "
+                          f"MISSING SOURCES (0% contribution, check repo name/access!): {failed}")
             if not streams:
-                log.error(f"[stream] rank={self.rank}.w{worker_id} no sources opened")
+                log.error(f"[stream] rank={self.rank}.w{worker_id} NO SOURCES OPENED — worker is dead")
                 return
 
-            rng   = np.random.default_rng(1234 + shard_index)
+            rng   = np.random.default_rng(shuffle_seed)
             iters = [iter(s[0]) for s in streams]
             probs = np.array([s[4] for s in streams], dtype=np.float64)
             probs = probs / probs.sum()
 
+            if worker_id == 0 and self.rank == 0:
+                log.info("[stream] actual sampling weights after open:")
+                for s, p in zip(streams, probs):
+                    log.info(f"  {s[2]:55s} {p*100:5.1f}%")
+
             buf: List[int] = []
             buf_source = "?"
             need = self.max_len * self.batch_size
@@ -1288,17 +1406,22 @@ class LiveStreamingDataset:
                 try:
                     row = next(iters[idx])
                 except StopIteration:
-                    streams[idx][0] = _open_source_stream(repo_id, split, shard_index, self.total_shards)
+                    streams[idx][0] = _open_source_stream(
+                        repo_id, split, shard_index, self.total_shards,
+                        shuffle_buffer=self.cfg.shuffle_buffer,
+                        shuffle_seed=shuffle_seed + 1)  # vary seed on re-open
                     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}")
+                    log.warning(f"[stream] rank={self.rank}.w{worker_id} "
+                                f"read error on {repo_id}: {e}")
                     time.sleep(1.0)
                     continue
 
-                text = row.get(text_field)
+                # FIX #4: dataset-aware extraction, handles stack-v3's files[]
+                text = _extract_text(row, text_field, repo_id)
                 if not text:
-                    continue
+                    continue   # fast — no I/O, no sleep, just next row
 
                 try:
                     ids = self.tok.encode(text).ids
@@ -1356,7 +1479,7 @@ def build_val_loader(cfg: Config) -> Optional[DataLoader]:
     n_val_seqs = 128
     try:
         for row in ds:
-            text = row.get(text_field)
+            text = _extract_text(row, text_field, repo_id)
             if not text:
                 continue
             ids = tok.encode(text).ids
@@ -1385,18 +1508,11 @@ def build_val_loader(cfg: Config) -> Optional[DataLoader]:
                       shuffle=False, num_workers=0, pin_memory=True, drop_last=True)
 
 # ─────────────────────────────────────────────────────────────────────────────
-#  CHECKPOINTING — *** NOW ASYNC ON RANK 0 ***
+#  CHECKPOINTING — async on rank 0
 # ─────────────────────────────────────────────────────────────────────────────
 _ckpt_thread: Optional[threading.Thread] = None
 
 def _async_save_and_upload(model_sd, muon_sd, adamw_sd, step, epoch, cfg_dict, loss):
-    """
-    Runs entirely on a background thread on rank 0. Does NOT block the main
-    training loop, and since save_ckpt() already returns immediately after
-    kicking this off, it does NOT block any other rank either — the state-
-    dict gather (the actual collective) already finished before this thread
-    was started.
-    """
     name  = f"g1_s{SESSION_ID:03d}_step{step:07d}"
     local = os.path.join(TEMP_CKPT_DIR, f"{name}.pt")
     try:
@@ -1413,33 +1529,23 @@ def _async_save_and_upload(model_sd, muon_sd, adamw_sd, step, epoch, cfg_dict, l
         except OSError: pass
 
 def save_ckpt(model, muon, adamw, step, epoch, cfg, loss, is_master: bool):
-    """
-    COLLECTIVE: get_model_state_dict / get_optimizer_state_dict must run on
-    EVERY rank (they gather DTensor shards into a full state dict on rank 0).
-    That part is fast (NVLINK all-gather). What used to be slow — writing
-    ~80-100GB to disk and uploading it — now happens on a background thread
-    AFTER this function has already returned. No rank blocks on I/O.
-    """
     global _ckpt_thread
     opts = StateDictOptions(full_state_dict=True, cpu_offload=True)
-    model_sd = get_model_state_dict(model, options=opts)          # collective, all ranks
+    model_sd = get_model_state_dict(model, options=opts)
     try:
-        muon_sd  = get_optimizer_state_dict(model, muon,  options=opts)   # collective
+        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)   # collective
+        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   # non-master ranks are done — no I/O, no waiting
+        return
 
-    # If a previous async checkpoint is still uploading, wait for it here
-    # (on rank 0 only, off the collective path — cannot deadlock other ranks).
     if _ckpt_thread is not None and _ckpt_thread.is_alive():
-        log.warning("[ckpt] previous checkpoint still uploading — waiting for it to finish "
-                    "before starting the next one")
+        log.warning("[ckpt] previous checkpoint still uploading — waiting for it to finish")
         _ckpt_thread.join()
 
     _ckpt_thread = threading.Thread(
@@ -1449,7 +1555,6 @@ def save_ckpt(model, muon, adamw, step, epoch, cfg, loss, is_master: bool):
     )
     _ckpt_thread.start()
     log.info(f"[ckpt] step={step} state gathered, upload started in background — training continues")
-    # returns immediately — rank 0 does NOT block on disk/network
 
 def _find_latest_ckpt():
     for sid in range(SESSION_ID, 0, -1):
@@ -1464,10 +1569,18 @@ def _find_latest_ckpt():
             return repo, ckpts[-1]
     return None, None
 
-def load_ckpt(model, muon, adamw, device, is_master: bool):
+def load_ckpt(model, muon, adamw, cfg, device, is_master: bool):
+    """
+    FIX #7: architecture fingerprint check. Dataset mix / LR / batch size are
+    all safe to change between sessions — but if d_model, n_layers, n_heads,
+    n_experts etc. don't match the checkpoint, loading will either crash with
+    a confusing shape-mismatch deep inside FSDP, or worse, partially succeed
+    and silently corrupt the model. Caught loudly here instead.
+    """
     ckpt = None
-    meta = torch.zeros(3, dtype=torch.float64, device=device)  # [found, step, epoch] + loss
+    meta = torch.zeros(3, dtype=torch.float64, device=device)
     loss_t = torch.zeros(1, dtype=torch.float64, device=device)
+    mismatch_flag = torch.zeros(1, dtype=torch.int32, device=device)
 
     if is_master:
         repo, ckpt_name = _find_latest_ckpt()
@@ -1477,12 +1590,31 @@ def load_ckpt(model, muon, adamw, device, is_master: bool):
             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}")
+
+                # ── architecture fingerprint check ──────────────────────────
+                saved_cfg = ckpt.get('config', {})
+                live_fp   = cfg.arch_fingerprint()
+                mismatches = []
+                for k, v in live_fp.items():
+                    if k in saved_cfg and saved_cfg[k] != v:
+                        mismatches.append(f"{k}: ckpt={saved_cfg[k]} vs live={v}")
+                if mismatches:
+                    log.error("=" * 70)
+                    log.error("[ckpt] ARCHITECTURE MISMATCH — cannot safely resume!")
+                    for m in mismatches:
+                        log.error(f"    {m}")
+                    log.error("[ckpt] refusing to load. Fix Config to match the "
+                              "checkpoint, or start a new model from scratch.")
+                    log.error("=" * 70)
+                    mismatch_flag[0] = 1
+                    ckpt = None
+                else:
+                    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}")
@@ -1493,6 +1625,13 @@ def load_ckpt(model, muon, adamw, device, is_master: bool):
     if dist_ready():
         dist.broadcast(meta,   src=0)
         dist.broadcast(loss_t, src=0)
+        dist.broadcast(mismatch_flag, src=0)
+
+    if mismatch_flag.item() > 0:
+        raise RuntimeError(
+            "Checkpoint architecture mismatch — see rank 0 log above for details. "
+            "Refusing to resume with corrupted/incompatible weights."
+        )
 
     if meta[0].item() < 0.5:
         return 0, 0, float('inf')
@@ -1516,14 +1655,12 @@ def load_ckpt(model, muon, adamw, device, is_master: bool):
 
     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}")
+        log.info(f"[ckpt] resumed step={step}  loss={loss:.4f}  (architecture verified ✅)")
     del ckpt
     gc.collect()
     return step, epoch, loss
 
 def save_final(model, cfg, step, epoch, loss, is_master: bool):
-    """Final save stays SYNCHRONOUS on purpose — it's the last thing the
-    process does, there's no more training to protect from blocking."""
     opts = StateDictOptions(full_state_dict=True, cpu_offload=True)
     model_sd = get_model_state_dict(model, options=opts)
     if not is_master:
@@ -1578,10 +1715,6 @@ def train():
     torch.cuda.set_device(local_rank)
     device = torch.device("cuda", local_rank)
     if world_size > 1 and not dist_ready():
-        # *** FIX: raised NCCL collective timeout from the 10-min default to
-        # 60 min as a safety net. This alone would have prevented the crash
-        # you hit, but the real fix is the async checkpoint below — this is
-        # just a backstop for anything else slow we haven't found yet. ***
         dist.init_process_group(
             backend="nccl", init_method="env://", device_id=device,
             timeout=_dt.timedelta(minutes=60),
@@ -1617,20 +1750,11 @@ def train():
 
     model = apply_fp8(model, cfg, is_master)
     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")
+    model = apply_compile(model, cfg, is_master)   # FIX #6 — after FSDP, per-block, dynamic
 
     muon, adamw = build_optimizers(model, cfg, is_master)
 
-    start_step, start_epoch, best_loss = load_ckpt(model, muon, adamw, device, is_master)
+    start_step, start_epoch, best_loss = load_ckpt(model, muon, adamw, cfg, device, is_master)
     if dist_ready():
         dist.barrier()
 
@@ -1647,8 +1771,8 @@ def train():
         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(f"  Muon LR={cfg.muon_lr} (FIXED aspect-ratio scale)")
+                 f"{MAX_HOURS}h budget | streaming=True | compile={cfg.use_compile}")
+        log.info(f"  Muon LR={cfg.muon_lr} | resumed at step={start_step}")
         log.info("=" * 70)
 
     step, epoch = start_step, start_epoch
@@ -1769,10 +1893,6 @@ def train():
             if dist_ready():
                 dist.barrier()
 
-        # ── checkpoint: gate decided by rank 0, broadcast; SAVE IS NOW ASYNC ──
-        # No trailing barrier needed anymore — save_ckpt() returns as soon as
-        # the (fast) state-dict gather finishes; rank 0's disk write + HF
-        # upload happen on a background thread and never block training.
         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,
@@ -1786,8 +1906,6 @@ def train():
     log.info(f"[rank {rank}] DONE training loop")
     stream.close()
 
-    # Make sure any in-flight async checkpoint finishes before final save,
-    # so we don't have two big uploads racing at process exit.
     if is_master and _ckpt_thread is not None and _ckpt_thread.is_alive():
         log.info("[ckpt] waiting for final in-flight checkpoint upload to finish…")
         _ckpt_thread.join()