Upload fp8_train.py with huggingface_hub

fp8_train.py

@@ -0,0 +1,668 @@
+#!/usr/bin/env python3
+"""Spider-FLEXITOKENS training pipeline with torchao FP8.
+
+Uses torchao's Float8Linear for FP8 training on Blackwell (sm_120):
+- rowwise_with_gw_hp recipe: row-wise scaling + high-precision grad weight
+- Activations/weights quantized to float8_e4m3fn in forward/backward
+- High-precision accumulation preserved for stability
+- ~2x VRAM reduction vs BF16 on linear layers
+
+Falls back to BF16 if torchao is unavailable.
+
+Architecture: SpiderForConditionalGeneration (RDT, MoE, MLA, FlexiTokens).
+Byte-level vocab 272, pre-tokenized FineWeb-Edu shards at /fineweb_bytelevel/.
+
+Usage:
+python fp8_train.py
+python fp8_train.py --mock_data --max_steps 50
+python fp8_train.py --micro_batch 64 --seq_len 128 --precision fp8
+python fp8_train.py --resume checkpoints-fp8/spider-step50.pt
+"""
+
+import os
+import gc
+import math
+import sys
+import time
+import argparse
+import re
+import enum
+from contextlib import nullcontext
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import CrossEntropyLoss
+from torch.utils.data import IterableDataset, DataLoader, get_worker_info
+
+from datasets import load_dataset
+
+try:
+    import bitsandbytes as bnb
+    AdamW8bit = bnb.optim.AdamW8bit
+    _HAS_8BIT = True
+except ImportError:
+    _HAS_8BIT = False
+    AdamW8bit = None
+
+try:
+    from torchao.float8 import convert_to_float8_training, Float8LinearConfig
+    _HAS_TORCHAO_FP8 = True
+except ImportError:
+    _HAS_TORCHAO_FP8 = False
+
+import importlib
+_fp8_spider = importlib.import_module("fp8-ready-spider")
+SpiderConfig = _fp8_spider.SpiderConfig
+SpiderForConditionalGeneration = _fp8_spider.SpiderForConditionalGeneration
+SENTINEL_TOKENS = _fp8_spider.SENTINEL_TOKENS
+
+try:
+    from loguru import logger
+    logger.remove()
+    logger.add(sys.stderr, format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}")
+    logger.add("train_fp8.log", rotation="100 MB", retention="10 days",
+               format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}")
+except ImportError:
+    import logging
+    logging.basicConfig(level=logging.INFO)
+    class _LoguruShim:
+        def info(self, msg): logging.info(msg)
+        def success(self, msg): logging.info(msg)
+        def warning(self, msg): logging.warning(msg)
+        def error(self, msg): logging.error(msg)
+    logger = _LoguruShim()
+
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+BOS_ID = SENTINEL_TOKENS['BOS']
+EOS_ID = SENTINEL_TOKENS['EOS']
+PAD_ID = SENTINEL_TOKENS['PAD']
+
+
+# ============================================================================
+# Precision Mode
+# ============================================================================
+
+class PrecisionMode(enum.Enum):
+    BF16 = "bf16"
+    FP8 = "fp8"
+
+
+def detect_precision_mode() -> PrecisionMode:
+    if not torch.cuda.is_available():
+        return PrecisionMode.BF16
+    cc = torch.cuda.get_device_capability()
+    if cc[0] >= 12 and _HAS_TORCHAO_FP8:
+        return PrecisionMode.FP8
+    if cc[0] >= 8 and _HAS_TORCHAO_FP8:
+        return PrecisionMode.FP8
+    return PrecisionMode.BF16
+
+
+def configure_fp8_training(model, recipe_name="tensorwise"):
+    base = Float8LinearConfig.from_recipe_name(recipe_name)
+    config = Float8LinearConfig(
+        cast_config_input=base.cast_config_input,
+        cast_config_weight=base.cast_config_weight,
+        cast_config_grad_output=base.cast_config_grad_output,
+        cast_config_input_for_grad_weight=base.cast_config_input_for_grad_weight,
+        cast_config_weight_for_grad_input=base.cast_config_weight_for_grad_input,
+        cast_config_grad_output_for_grad_weight=base.cast_config_grad_output_for_grad_weight,
+        gemm_config_output=base.gemm_config_output,
+        gemm_config_grad_input=base.gemm_config_grad_input,
+        gemm_config_grad_weight=base.gemm_config_grad_weight,
+        enable_fsdp_float8_all_gather=base.enable_fsdp_float8_all_gather,
+        round_scales_to_power_of_2=base.round_scales_to_power_of_2,
+        pad_inner_dim=True,
+    )
+
+    def module_filter_fn(mod, fqn):
+        skip = any(s in fqn for s in (
+            "boundary_predictor",
+            "loop_embedding",
+            "engram",
+            "layernorm",
+            "norm",
+            "embed_tokens",
+            "lm_head",
+            "halt_predictor",
+            "router",
+        ))
+        return not skip
+
+    model = convert_to_float8_training(
+        model,
+        module_filter_fn=module_filter_fn,
+        config=config,
+    )
+    return model
+
+
+# ============================================================================
+# Byte-Level Datasets
+# ============================================================================
+
+class ByteLevelDataset(IterableDataset):
+    def __init__(self, dataset_name="HuggingFaceFW/fineweb-edu",
+                 subset="sample-10BT", split="train",
+                 seq_len=2048, max_bytes=2048, rank=0, world_size=1):
+        self.seq_len = seq_len
+        self.max_bytes = max_bytes
+        self.dataset_name = dataset_name
+        self.subset = subset
+        self.split = split
+        self.rank = rank
+        self.world_size = world_size
+
+    def _encode_sample(self, text):
+        byte_ids = list(text.encode('utf-8'))[:self.max_bytes]
+        return [BOS_ID] + byte_ids + [EOS_ID]
+
+    def __iter__(self):
+        worker = get_worker_info()
+        num_workers = worker.num_workers if worker else 1
+        worker_id = worker.id if worker else 0
+        total_shards = self.world_size * num_workers
+        shard_index = self.rank * num_workers + worker_id
+        ds = load_dataset(self.dataset_name, name=self.subset,
+                          split=self.split, streaming=True
+                          ).shard(num_shards=total_shards, index=shard_index)
+        buf = []
+        for sample in ds:
+            text = sample.get("text", "")
+            if not text:
+                continue
+            byte_ids = self._encode_sample(text)
+            buf.extend(byte_ids)
+            while len(buf) >= self.seq_len + 1:
+                chunk = buf[:self.seq_len + 1]
+                buf = buf[self.seq_len + 1:]
+                x = torch.tensor(chunk[:-1], dtype=torch.long)
+                y = torch.tensor(chunk[1:], dtype=torch.long)
+                y[y == PAD_ID] = -100
+                yield x, y
+
+
+class LocalByteLevelDataset(IterableDataset):
+    def __init__(self, data_dir, seq_len=2048, rank=0, world_size=1):
+        self.seq_len = seq_len
+        self.data_dir = data_dir
+        self.rank = rank
+        self.world_size = world_size
+        self._files = self._discover_files()
+
+    def _discover_files(self):
+        import glob as _glob
+        files = sorted(
+            _glob.glob(os.path.join(self.data_dir, "**/*.bin"), recursive=True)
+        )
+        return [f for i, f in enumerate(files) if i % self.world_size == self.rank]
+
+    def __iter__(self):
+        import numpy as np
+        worker = get_worker_info()
+        num_workers = worker.num_workers if worker else 1
+        worker_id = worker.id if worker else 0
+        files = [f for i, f in enumerate(self._files) if i % num_workers == worker_id]
+        token_buffer = []
+        for filepath in files:
+            if filepath.endswith(".bin"):
+                arr = np.memmap(filepath, dtype=np.uint16, mode='r')
+                pos = 0
+                while pos + self.seq_len + 1 <= len(arr):
+                    chunk = arr[pos:pos + self.seq_len + 1]
+                    pos += self.seq_len + 1
+                    x = torch.tensor(chunk[:-1], dtype=torch.long)
+                    y = torch.tensor(chunk[1:], dtype=torch.long)
+                    y[y == PAD_ID] = -100
+                    yield x, y
+                token_buffer.extend(arr[pos:].tolist())
+
+
+class MockByteLevelDataset(IterableDataset):
+    SAMPLES = [
+        "Hello world, this is a test of the byte-level encoding system.",
+        "The quick brown fox jumps over the lazy dog.",
+        "Spider is a recurrent latent reasoning architecture with engram memory.",
+        "Boundary predictors learn to merge byte sequences into meaningful tokens.",
+        "FineWeb-Edu contains high-quality educational content for pretraining.",
+        "\u042d\u0442\u043e \u0442\u0435\u043a\u0441\u0442 \u043d\u0430 \u0440\u0443\u0441\u0441\u043a\u043e\u043c \u044f\u0437\u044b\u043a\u0435.",
+        "def fibonacci(n): return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)",
+        "The integral of x^2 from 0 to 1 equals 1/3.",
+    ]
+
+    def __init__(self, seq_len=512, max_bytes=512, num_samples=1000):
+        self.seq_len = seq_len
+        self.max_bytes = max_bytes
+        self.num_samples = num_samples
+
+    def __iter__(self):
+        buf = []
+        count = 0
+        while count < self.num_samples:
+            for text in self.SAMPLES:
+                byte_ids = list(text.encode('utf-8'))[:self.max_bytes]
+                ids = [BOS_ID] + byte_ids + [EOS_ID]
+                buf.extend(ids)
+                while len(buf) >= self.seq_len + 1:
+                    chunk = buf[:self.seq_len + 1]
+                    buf = buf[self.seq_len + 1:]
+                    x = torch.tensor(chunk[:-1], dtype=torch.long)
+                    y = torch.tensor(chunk[1:], dtype=torch.long)
+                    y[y == PAD_ID] = -100
+                    yield x, y
+                count += 1
+                if count >= self.num_samples:
+                    return
+
+
+# ============================================================================
+# Checkpointing
+# ============================================================================
+
+def save_step_checkpoint(model, optimizer, step, epoch, cfg, ckpt_dir, master,
+                         ddp=False, current_best_loss=float("inf")):
+    model_state = model.state_dict()
+    optim_state = optimizer.state_dict()
+    if not master:
+        return None, 0
+    os.makedirs(ckpt_dir, exist_ok=True)
+    ckpt_path = os.path.join(ckpt_dir, f"spider-step{step}.pt")
+    tmp_path = ckpt_path + ".tmp"
+    torch.save({
+        "step": step, "epoch": epoch,
+        "model_state_dict": model_state,
+        "optimizer_state_dict": optim_state,
+        "cfg": cfg, "best_loss": current_best_loss,
+    }, tmp_path)
+    os.replace(tmp_path, ckpt_path)
+    size_mb = os.path.getsize(ckpt_path) / (1024 * 1024)
+    step_pattern = re.compile(r"spider-step\d+\.pt$")
+    step_ckpts = sorted(
+        [os.path.join(ckpt_dir, f) for f in os.listdir(ckpt_dir) if step_pattern.search(f)],
+        key=os.path.getmtime,
+    )
+    while len(step_ckpts) > 2:
+        old = step_ckpts.pop(0)
+        os.remove(old)
+    return ckpt_path, size_mb
+
+
+def load_checkpoint(model, optimizer, path, ddp=False):
+    ckpt = torch.load(path, map_location="cpu", weights_only=False)
+    if "model_state_dict" not in ckpt:
+        model.load_state_dict(ckpt, strict=False)
+        return 0, 0, float("inf")
+    model.load_state_dict(ckpt["model_state_dict"])
+    try:
+        optimizer.load_state_dict(ckpt["optimizer_state_dict"])
+    except (ValueError, KeyError, RuntimeError) as e:
+        logger.warning(f"Optimizer state mismatch: {e}. Skipping optimizer state.")
+    saved_best_loss = ckpt.get("best_loss", float("inf"))
+    return int(ckpt["step"]), int(ckpt.get("epoch", 0)), saved_best_loss
+
+
+# ============================================================================
+# LR Schedule
+# ============================================================================
+
+def get_lr(step, warmup, total, max_lr, min_lr):
+    if step < warmup:
+        return max_lr * step / warmup
+    if step >= total:
+        return min_lr
+    decay = (step - warmup) / (total - warmup)
+    return min_lr + 0.5 * (max_lr - min_lr) * (1.0 + math.cos(math.pi * decay))
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Spider-FLEXITOKENS FP8/BF16 training")
+    parser.add_argument("--resume", type=str, default="")
+    parser.add_argument("--reset_steps", action="store_true", help="Load weights but reset step/epoch to 0")
+    parser.add_argument("--max_steps", type=int, default=0)
+    parser.add_argument("--mock_data", action="store_true")
+    parser.add_argument("--seq_len", type=int, default=0)
+    parser.add_argument("--micro_batch", type=int, default=0)
+    parser.add_argument("--grad_accum", type=int, default=0, help="Gradient accumulation steps (0=auto)")
+    parser.add_argument("--n_loops", type=int, default=0)
+    parser.add_argument("--lr", type=float, default=0)
+    parser.add_argument("--ckpt_dir", type=str, default="checkpoints-fp8")
+    parser.add_argument("--data_dir", type=str, default="/home/lamcodealong/fineweb_bytelevel")
+    parser.add_argument("--no_gradient_checkpointing", action="store_true")
+    parser.add_argument("--precision", type=str, default="auto",
+        choices=["auto", "bf16", "fp8"],
+        help="Training precision: auto (detect), bf16, fp8 (torchao)")
+    parser.add_argument("--compile", action="store_true",
+        help="torch.compile the model for optimized kernels")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    ddp = int(os.environ.get("RANK", -1)) != -1
+    if ddp:
+        import torch.distributed as dist
+        dist.init_process_group("nccl")
+        rank = int(os.environ["RANK"])
+        local_rank = int(os.environ["LOCAL_RANK"])
+        world_size = int(os.environ["WORLD_SIZE"])
+        device = f"cuda:{local_rank}"
+        torch.cuda.set_device(device)
+    else:
+        rank = local_rank = 0
+        world_size = 1
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+    master = rank == 0
+
+    seq_len = args.seq_len or int(os.environ.get("SEQ_LEN", "2048"))
+    micro_batch = args.micro_batch or int(os.environ.get("MICRO_BATCH", "64"))
+    target_tokens = int(os.environ.get("TARGET_TOKENS", "10_000_000_000"))
+    grad_accum = args.grad_accum if args.grad_accum and args.grad_accum > 0 else int(os.environ.get("GRAD_ACCUM", "1"))
+    n_loops = args.n_loops or int(os.environ.get("N_LOOPS", "6"))
+    lr = args.lr or float(os.environ.get("LR", "3e-4"))
+    wd = 0.1
+    warmup_steps = 200
+    log_every = 10
+    ckpt_every = int(os.environ.get("CKPT_EVERY", "50"))
+    ckpt_dir = args.ckpt_dir
+
+    global_batch_tok = world_size * micro_batch * grad_accum * seq_len
+    total_steps = target_tokens // global_batch_tok
+    if args.max_steps > 0:
+        total_steps = min(total_steps, args.max_steps)
+
+    cfg = SpiderConfig()
+    bf16_ok = torch.cuda.is_available() and torch.cuda.is_bf16_supported()
+    amp_dtype = torch.bfloat16 if bf16_ok else torch.float16
+
+    if args.precision == "auto":
+        prec_mode = detect_precision_mode()
+    elif args.precision == "fp8":
+        prec_mode = PrecisionMode.FP8
+    else:
+        prec_mode = PrecisionMode.BF16
+
+    if prec_mode == PrecisionMode.FP8 and not _HAS_TORCHAO_FP8:
+        logger.warning("torchao FP8 not available, falling back to BF16")
+        prec_mode = PrecisionMode.BF16
+
+    if master:
+        logger.info(
+            f"[Spider-FLEXITOKENS] hidden=2048 | 6 recurrent | 32 experts top-2 | "
+            f"n_loops={n_loops} | seq_len={seq_len} | micro_batch={micro_batch} | "
+            f"grad_accum={grad_accum} | global_batch_tokens={global_batch_tok:,} | "
+            f"total_steps={total_steps:,}"
+        )
+        logger.info(
+            f"Byte-level vocab: 272 | Precision: {prec_mode.value} | "
+            f"Gradient checkpointing: {'disabled' if args.no_gradient_checkpointing else 'enabled'}"
+        )
+
+    model = SpiderForConditionalGeneration(cfg).to(amp_dtype)
+
+    if prec_mode == PrecisionMode.FP8:
+        try:
+            recipe = "tensorwise"
+            model = configure_fp8_training(model, recipe_name=recipe)
+            if master:
+                n_fp8 = sum(1 for m in model.modules() if m.__class__.__name__ == "Float8Linear")
+                n_linear = sum(1 for m in model.modules() if isinstance(m, nn.Linear))
+                logger.info(f"torchao FP8: {n_fp8} Float8Linear / {n_fp8 + n_linear} total linear layers (recipe={recipe})")
+        except Exception as e:
+            if master:
+                logger.warning(f"FP8 setup failed ({e}), falling back to BF16")
+            prec_mode = PrecisionMode.BF16
+
+    if not args.no_gradient_checkpointing:
+        model.gradient_checkpointing_enable()
+    model.enable_input_require_grads()
+
+    model = model.to(device)
+
+    if args.compile:
+        model = torch.compile(model, mode="default")
+        if master:
+            logger.info("Model compiled with torch.compile (reduce-overhead)")
+
+    if ddp:
+        model = torch.nn.parallel.DistributedDataParallel(
+            model, device_ids=[local_rank], output_device=local_rank,
+        )
+
+    if master:
+        n_params = sum(p.numel() for p in model.parameters())
+        trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
+        logger.info(
+            f"Parameters: {n_params:,} total | {trainable:,} trainable | Precision: {prec_mode.value}"
+        )
+
+    if _HAS_8BIT:
+        optimizer = AdamW8bit(
+            model.parameters(), lr=lr, weight_decay=wd,
+            betas=(0.9, 0.95), eps=1e-8,
+        )
+        if master:
+            logger.info("Optimizer: 8-bit AdamW (saves ~50% optimizer VRAM)")
+    else:
+        optimizer = torch.optim.AdamW(
+            model.parameters(), lr=lr, weight_decay=wd,
+            betas=(0.9, 0.95), foreach=True, eps=1e-8,
+        )
+        if master:
+            logger.info("Optimizer: standard AdamW")
+
+    start_step = 0
+    start_epoch = 1
+    best_loss = float("inf")
+    if args.resume and os.path.exists(args.resume):
+        if master:
+            logger.info(f"Resuming from checkpoint: {args.resume}")
+        start_step, start_epoch, best_loss = load_checkpoint(model, optimizer, args.resume, ddp)
+        if args.reset_steps:
+            if master:
+                logger.info(f"Reset steps: step {start_step} -> 0, epoch {start_epoch} -> 1")
+            start_step = 0
+            start_epoch = 1
+            best_loss = float("inf")
+            for group in optimizer.param_groups:
+                for p in group['params']:
+                    state = optimizer.state.get(p, {})
+                    for k in ('exp_avg', 'exp_avg_sq', 'max_exp_avg_sq'):
+                        if k in state:
+                            state[k].zero_()
+            if master:
+                logger.info("Optimizer state reset (momentum/variance zeroed)")
+        if master:
+            logger.info(f"Resumed at step {start_step}, epoch {start_epoch}, best_loss={best_loss:.4f}")
+    else:
+        existing_ckpts = sorted(
+            [os.path.join(ckpt_dir, f) for f in os.listdir(ckpt_dir)
+             if f.startswith("spider-") and f.endswith(".pt") and not f.endswith(".tmp")]
+        ) if os.path.isdir(ckpt_dir) else []
+        if existing_ckpts:
+            latest = existing_ckpts[-1]
+            if master:
+                logger.info(f"Auto-resuming from: {latest}")
+            start_step, start_epoch, best_loss = load_checkpoint(model, optimizer, latest, ddp)
+    if master:
+        logger.info(f"Resumed at step {start_step}, epoch {start_epoch}, best_loss={best_loss:.4f}")
+
+    if master:
+        logger.info("Running FP8 warmup (2 fwd+bwd passes to compile kernels)...")
+    model.train()
+    for _w in range(2):
+        _wx = torch.randint(4, 256, (2, seq_len), device=device)
+        _wy = torch.randint(4, 256, (2, seq_len), device=device)
+        _wo = model(_wx, labels=_wy, n_loops=n_loops)
+        _wo['loss'].backward()
+        optimizer.zero_grad(set_to_none=True)
+    del _wx, _wy, _wo
+    torch.cuda.synchronize()
+    if master:
+        peak_warmup = torch.cuda.max_memory_allocated() / 1024**3
+        logger.info(f"Warmup done | Peak VRAM: {peak_warmup:.1f}GB")
+
+    if args.mock_data:
+        dataset = MockByteLevelDataset(seq_len=seq_len, num_samples=5000)
+    elif args.data_dir and os.path.isdir(args.data_dir):
+        dataset = LocalByteLevelDataset(
+            data_dir=args.data_dir, seq_len=seq_len,
+            rank=rank, world_size=world_size,
+        )
+    else:
+        dataset = ByteLevelDataset(seq_len=seq_len, rank=rank, world_size=world_size)
+
+    loader = DataLoader(
+        dataset,
+        batch_size=micro_batch,
+        num_workers=4 if not args.mock_data else 0,
+        pin_memory=True,
+        prefetch_factor=4 if not args.mock_data else None,
+        persistent_workers=True if not args.mock_data else False,
+        drop_last=False,
+    )
+
+    class _Prefetcher:
+        def __init__(self, loader, device):
+            self.loader = loader
+            self.device = device
+            self._stream = torch.cuda.Stream()
+            self._next_x = None
+            self._next_y = None
+
+        def _preload(self, data_iter):
+            try:
+                x, y = next(data_iter)
+            except StopIteration:
+                return None, None, data_iter
+            with torch.cuda.stream(self._stream):
+                self._next_x = x.to(self.device, non_blocking=True)
+                self._next_y = y.to(self.device, non_blocking=True)
+            return self._next_x, self._next_y, data_iter
+
+        def next(self, data_iter):
+            if self._next_x is not None:
+                torch.cuda.current_stream().wait_stream(self._stream)
+                x, y = self._next_x, self._next_y
+            else:
+                try:
+                    x, y = next(data_iter)
+                except StopIteration:
+                    return None, None, data_iter
+                x = x.to(self.device, non_blocking=True)
+                y = y.to(self.device, non_blocking=True)
+            self._next_x = None
+            self._next_y = None
+            nx, ny, data_iter = self._preload(data_iter)
+            return x, y, data_iter
+
+    prefetcher = _Prefetcher(loader, device)
+
+    if prec_mode == PrecisionMode.FP8:
+        amp_ctx = nullcontext()
+    else:
+        amp_ctx = (
+            torch.amp.autocast(device_type="cuda", dtype=amp_dtype)
+            if "cuda" in device
+            else nullcontext()
+        )
+
+    if master:
+        logger.info(f"Starting training from step {start_step} to {total_steps}")
+
+    model.train()
+    step = start_step
+    tokens_seen = start_step * global_batch_tok
+    t0_loop = time.time()
+    data_iter = iter(loader)
+
+    for epoch in range(start_epoch, 1000):
+        while step < total_steps:
+            current_lr = get_lr(step, warmup_steps, total_steps, lr, lr * 0.1)
+            for pg in optimizer.param_groups:
+                pg['lr'] = current_lr
+
+            optimizer.zero_grad(set_to_none=True)
+            loss_accum = 0.0
+
+            for micro_step in range(grad_accum):
+                x, y, data_iter = prefetcher.next(data_iter)
+                if x is None:
+                    data_iter = iter(loader)
+                    x, y, data_iter = prefetcher.next(data_iter)
+
+            sync = (
+                nullcontext()
+                if (not ddp or micro_step == grad_accum - 1)
+                else model.no_sync()
+            ) if ddp else nullcontext()
+
+            with sync, amp_ctx:
+                output = model(x, labels=y, n_loops=n_loops)
+                loss = output['loss'] / grad_accum
+                loss.backward()
+
+            loss_accum += loss.item() * grad_accum
+
+            if master and step == start_step and micro_step == 0:
+                peak_vram = torch.cuda.max_memory_allocated() / 1024**3
+                logger.info(f"First forward+backward | Peak VRAM: {peak_vram:.1f}GB")
+
+            nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+            optimizer.step()
+
+            step += 1
+            tokens_seen += global_batch_tok
+
+            if step % 10 == 0:
+                gc.collect()
+                torch.cuda.empty_cache()
+
+            if step % log_every == 0 and master:
+                elapsed = time.time() - t0_loop
+                tps = log_every * global_batch_tok / elapsed if elapsed > 0 else 0
+                loss_val = loss_accum
+                if loss_val < best_loss:
+                    best_loss = loss_val
+                logger.info(
+                    f"Epoch {epoch} | step {step}/{total_steps} | loss {loss_val:.4f} | "
+                    f"lr {current_lr:.2e} | {tps/1e3:.1f}k tok/s | "
+                    f"prec {prec_mode.value} | tokens {tokens_seen/1e6:.2f}M"
+                )
+                t0_loop = time.time()
+
+            if step % ckpt_every == 0 and master:
+                ckpt_path, ckpt_mb = save_step_checkpoint(
+                    model, optimizer, step, epoch, cfg, ckpt_dir, master,
+                    ddp=ddp, current_best_loss=best_loss,
+                )
+                if ckpt_path:
+                    logger.info(f"Checkpoint saved: {ckpt_path} ({ckpt_mb:.0f} MB)")
+
+            if step >= total_steps:
+                break
+
+        if step >= total_steps:
+            break
+
+    if master:
+        final_path = os.path.join(ckpt_dir, "spider-final.pt")
+        os.makedirs(ckpt_dir, exist_ok=True)
+        torch.save({
+            "step": step, "epoch": epoch,
+            "model_state_dict": model.state_dict(),
+            "optimizer_state_dict": optimizer.state_dict(),
+            "cfg": cfg, "best_loss": best_loss,
+        }, final_path)
+        logger.info(f"Final checkpoint saved: {final_path}")
+        logger.info(f"Training complete. Total steps: {step}, Best loss: {best_loss:.4f}")
+
+
+if __name__ == "__main__":
+    main()