fp8_train.py

#!/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()