scripts/pretrain.py

from __future__ import annotations

import argparse
import contextlib
import importlib.util
import json
import math
import os
import random
import time
from pathlib import Path
from typing import Any

import numpy as np
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel
from transformers import AutoTokenizer, LlamaForCausalLM

from kawk50m.binary_dataset import PackedTokenDataset
from kawk50m.cli import configure_utf8_stdio
from kawk50m.checkpoint import (
    load_training_state,
    resolve_checkpoint,
    restore_rng_state,
    save_checkpoint,
)
from kawk50m.config import build_llama_config, count_unique_parameters, load_yaml


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Pretrain KAWK50M with BF16 and resumable checkpoints."
    )
    parser.add_argument("--config", default="configs/pretrain_5b.yaml")
    parser.add_argument(
        "--resume",
        default=None,
        help="Checkpoint directory or 'latest'.",
    )
    parser.add_argument(
        "--init-from",
        default=None,
        help=(
            "Initialize model weights from a checkpoint/model directory while "
            "resetting optimizer, scheduler, RNG, and step. Use this for CPT "
            "or context-extension stages."
        ),
    )
    parser.add_argument(
        "--allow-cpu",
        action="store_true",
        help="Allow a slow FP32 CPU run for debugging.",
    )
    parser.add_argument(
        "--no-compile", action="store_true", help="Disable torch.compile."
    )
    parser.add_argument(
        "--stop-after-steps",
        type=int,
        default=None,
        help="Stop after this many optimizer steps in the current invocation and save.",
    )
    return parser.parse_args()


def setup_distributed(allow_cpu: bool) -> tuple[torch.device, int, int, int]:
    world_size = int(os.environ.get("WORLD_SIZE", "1"))
    rank = int(os.environ.get("RANK", "0"))
    local_rank = int(os.environ.get("LOCAL_RANK", "0"))

    if torch.cuda.is_available():
        device = torch.device("cuda", local_rank)
        torch.cuda.set_device(device)
    elif allow_cpu and world_size == 1:
        device = torch.device("cpu")
    else:
        raise RuntimeError(
            "CUDA is required for BF16 pretraining. Use --allow-cpu only for debugging."
        )

    if world_size > 1:
        if device.type != "cuda":
            raise RuntimeError("Distributed CPU training is not supported by this script")
        backend = "nccl" if dist.is_nccl_available() else "gloo"
        dist.init_process_group(backend=backend)
    return device, rank, local_rank, world_size


def set_seed(seed: int, rank: int) -> None:
    local_seed = seed + rank
    random.seed(local_seed)
    np.random.seed(local_seed)
    torch.manual_seed(local_seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(local_seed)


def cosine_scheduler(
    optimizer: torch.optim.Optimizer,
    *,
    max_steps: int,
    warmup_ratio: float,
    min_lr_ratio: float,
) -> torch.optim.lr_scheduler.LambdaLR:
    warmup_steps = round(max_steps * warmup_ratio)

    def multiplier(step: int) -> float:
        if warmup_steps > 0 and step < warmup_steps:
            return max(step, 1) / warmup_steps
        progress = (step - warmup_steps) / max(max_steps - warmup_steps, 1)
        progress = min(max(progress, 0.0), 1.0)
        cosine = 0.5 * (1.0 + math.cos(math.pi * progress))
        return min_lr_ratio + (1.0 - min_lr_ratio) * cosine

    return torch.optim.lr_scheduler.LambdaLR(optimizer, multiplier)


def create_optimizer(
    parameters: Any,
    training: dict[str, Any],
    *,
    use_fused: bool,
) -> torch.optim.AdamW:
    kwargs = {
        "lr": float(training["learning_rate"]),
        "betas": (
            float(training.get("adam_beta1", 0.9)),
            float(training.get("adam_beta2", 0.95)),
        ),
        "eps": float(training.get("adam_eps", 1.0e-8)),
        "weight_decay": float(training.get("weight_decay", 0.1)),
    }
    if use_fused:
        try:
            return torch.optim.AdamW(parameters, fused=True, **kwargs)
        except (TypeError, RuntimeError):
            pass
    return torch.optim.AdamW(parameters, **kwargs)


@torch.no_grad()
def evaluate_loss(
    model: Any,
    dataset: PackedTokenDataset,
    *,
    batches: int,
    batch_size: int,
    rank: int,
    world_size: int,
    device: torch.device,
    use_bf16: bool,
) -> float:
    model.eval()
    total_loss = torch.zeros((), device=device, dtype=torch.float64)
    total_batches = torch.zeros((), device=device, dtype=torch.float64)
    for batch_index in range(batches):
        inputs, labels = dataset.evaluation_batch(
            batch_index=batch_index,
            batch_size=batch_size,
            rank=rank,
            world_size=world_size,
            device=device,
        )
        with torch.autocast(
            device_type=device.type,
            dtype=torch.bfloat16,
            enabled=use_bf16,
        ):
            loss = model(input_ids=inputs, labels=labels, use_cache=False).loss
        total_loss += loss.detach().double()
        total_batches += 1
    if world_size > 1:
        dist.all_reduce(total_loss, op=dist.ReduceOp.SUM)
        dist.all_reduce(total_batches, op=dist.ReduceOp.SUM)
    model.train()
    return (total_loss / total_batches).item()


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    if args.resume is not None and args.init_from is not None:
        raise ValueError("--resume and --init-from are mutually exclusive")
    full_config = load_yaml(args.config)
    data_config = full_config.get("data")
    training = full_config.get("training")
    if not isinstance(data_config, dict) or not isinstance(training, dict):
        raise ValueError("Training YAML requires 'data' and 'training' mappings")

    device, rank, local_rank, world_size = setup_distributed(args.allow_cpu)
    is_main = rank == 0
    seed = int(training.get("seed", 42))
    set_seed(seed, rank)

    if device.type == "cuda":
        torch.set_float32_matmul_precision("high")
        torch.backends.cuda.matmul.allow_tf32 = True
    requested_precision = str(training.get("precision", "bf16")).lower()
    if requested_precision not in {"bf16", "fp32"}:
        raise ValueError("precision must be bf16 or fp32")
    use_bf16 = requested_precision == "bf16" and device.type == "cuda"
    if requested_precision == "bf16" and device.type == "cuda":
        if not torch.cuda.is_bf16_supported():
            raise RuntimeError("This GPU does not support BF16")
    if device.type == "cpu" and requested_precision == "bf16" and is_main:
        print("CPU debug mode: falling back from BF16 to FP32")

    tokenizer = AutoTokenizer.from_pretrained(
        full_config["tokenizer_dir"], use_fast=False, legacy=True
    )
    model_yaml = load_yaml(full_config["model_config"])
    model_config, expected_parameters = build_llama_config(
        model_yaml, tokenizer_vocab_size=len(tokenizer)
    )

    output_dir = Path(training["output_dir"])
    resume_path = (
        resolve_checkpoint(args.resume, output_dir) if args.resume is not None else None
    )
    if resume_path is None:
        prior_checkpoints = list(output_dir.glob("checkpoint-*"))
        prior_markers = (
            (output_dir / "latest_checkpoint.txt").exists()
            or (output_dir / "run_config.json").exists()
            or bool(prior_checkpoints)
        )
        if prior_markers:
            raise FileExistsError(
                f"{output_dir} already contains training artifacts. "
                "Use --resume latest or choose a new training.output_dir."
            )
    init_path = Path(args.init_from).resolve() if args.init_from else None
    if init_path is not None and not init_path.exists():
        raise FileNotFoundError(init_path)

    if resume_path is None and init_path is None:
        raw_model = LlamaForCausalLM(model_config)
    elif resume_path is not None:
        raw_model = LlamaForCausalLM.from_pretrained(resume_path / "model")
        for attribute in (
            "vocab_size",
            "hidden_size",
            "intermediate_size",
            "num_hidden_layers",
            "num_attention_heads",
            "num_key_value_heads",
        ):
            expected_value = getattr(model_config, attribute)
            actual_value = getattr(raw_model.config, attribute)
            if expected_value != actual_value:
                raise ValueError(
                    f"Checkpoint model mismatch for {attribute}: "
                    f"config={expected_value}, checkpoint={actual_value}"
                )
    else:
        assert init_path is not None
        source_dir = init_path / "model" if (init_path / "model").is_dir() else init_path
        source_model = LlamaForCausalLM.from_pretrained(source_dir)
        raw_model = LlamaForCausalLM(model_config)
        raw_model.load_state_dict(source_model.state_dict(), strict=True)
        del source_model

    parameter_count = count_unique_parameters(raw_model)
    if expected_parameters is not None and parameter_count != expected_parameters:
        raise RuntimeError(
            f"Expected {expected_parameters} parameters, got {parameter_count}"
        )
    raw_model.config.use_cache = False
    if bool(training.get("gradient_checkpointing", False)):
        raw_model.gradient_checkpointing_enable()
    raw_model.to(device)

    sequence_length = int(data_config["sequence_length"])
    if sequence_length > model_config.max_position_embeddings:
        raise ValueError("sequence_length exceeds max_position_embeddings")
    train_paths = data_config.get("train_bins", data_config.get("train_bin"))
    if train_paths is None:
        raise ValueError("data requires train_bin or train_bins")
    train_dataset = PackedTokenDataset(train_paths, sequence_length)
    training_sample_offset = int(data_config.get("sample_offset", 0))
    if training_sample_offset < 0:
        raise ValueError("data.sample_offset must be non-negative")
    validation_dataset = None
    if int(training.get("eval_every", 0)) > 0:
        validation_dataset = PackedTokenDataset(
            data_config["validation_bin"], sequence_length
        )

    batch_size = int(training["per_device_batch_size"])
    gradient_accumulation = int(training["gradient_accumulation_steps"])
    if batch_size <= 0 or gradient_accumulation <= 0:
        raise ValueError("batch size and gradient accumulation must be positive")
    tokens_per_step = (
        sequence_length * batch_size * gradient_accumulation * world_size
    )
    configured_steps = training.get("max_steps")
    if configured_steps is None:
        max_tokens = int(training["max_tokens"])
        max_steps = math.ceil(max_tokens / tokens_per_step)
    else:
        max_steps = int(configured_steps)
    if max_steps <= 0:
        raise ValueError("max_steps must be positive")
    if args.stop_after_steps is not None and args.stop_after_steps <= 0:
        raise ValueError("--stop-after-steps must be positive")

    compile_enabled = bool(training.get("torch_compile", True)) and not args.no_compile
    if (
        compile_enabled
        and device.type == "cuda"
        and importlib.util.find_spec("triton") is None
    ):
        if is_main:
            print(
                "torch.compile disabled: no working Triton installation was found. "
                "Continuing with eager BF16."
            )
        compile_enabled = False
    train_model: Any = raw_model
    if compile_enabled:
        train_model = torch.compile(
            train_model, mode=str(training.get("compile_mode", "default"))
        )
    if world_size > 1:
        train_model = DistributedDataParallel(
            train_model,
            device_ids=[local_rank],
            broadcast_buffers=False,
            gradient_as_bucket_view=True,
        )

    optimizer = create_optimizer(
        train_model.parameters(), training, use_fused=device.type == "cuda"
    )
    learning_rate = float(training["learning_rate"])
    minimum_learning_rate = float(training.get("min_learning_rate", 0.0))
    scheduler = cosine_scheduler(
        optimizer,
        max_steps=max_steps,
        warmup_ratio=float(training.get("warmup_ratio", 0.02)),
        min_lr_ratio=minimum_learning_rate / learning_rate,
    )

    start_step = 0
    if resume_path is not None:
        state = load_training_state(resume_path / "trainer_state.pt")
        if int(state["world_size"]) != world_size:
            raise ValueError(
                "Resume requires the same world size: "
                f"checkpoint={state['world_size']}, current={world_size}"
            )
        optimizer.load_state_dict(state["optimizer"])
        scheduler.load_state_dict(state["scheduler"])
        restore_rng_state(state["rng"])
        start_step = int(state["step"])
        if start_step >= max_steps:
            raise ValueError(
                f"Checkpoint step {start_step} already reached max_steps {max_steps}"
            )

    if is_main:
        output_dir.mkdir(parents=True, exist_ok=True)
        run_summary = {
            "parameters": parameter_count,
            "device": str(device),
            "world_size": world_size,
            "sequence_length": sequence_length,
            "training_sample_offset": training_sample_offset,
            "tokens_per_optimizer_step": tokens_per_step,
            "max_steps": max_steps,
            "planned_tokens": max_steps * tokens_per_step,
            "start_step": start_step,
            "initialized_from": str(init_path) if init_path is not None else None,
            "precision": "bf16" if use_bf16 else "fp32",
            "compile": compile_enabled,
        }
        print(json.dumps(run_summary, ensure_ascii=False, indent=2))
        run_config_path = output_dir / "run_config.json"
        if not run_config_path.exists():
            with run_config_path.open("w", encoding="utf-8") as handle:
                json.dump(
                    {"summary": run_summary, "config": full_config},
                    handle,
                    ensure_ascii=False,
                    indent=2,
                )
                handle.write("\n")

    train_model.train()
    optimizer.zero_grad(set_to_none=True)
    step = start_step
    log_every = int(training.get("log_every", 10))
    eval_every = int(training.get("eval_every", 0))
    save_every = int(training.get("save_every", 0))
    max_grad_norm = float(training.get("max_grad_norm", 1.0))
    interval_start = time.perf_counter()
    interval_step = step
    run_stop_step = (
        min(max_steps, step + args.stop_after_steps)
        if args.stop_after_steps is not None
        else max_steps
    )

    while step < run_stop_step:
        accumulated_loss = torch.zeros((), device=device)
        for micro_index in range(gradient_accumulation):
            micro_step = step * gradient_accumulation + micro_index
            inputs, labels = train_dataset.training_batch(
                micro_step=micro_step,
                batch_size=batch_size,
                rank=rank,
                world_size=world_size,
                seed=seed,
                sample_offset=training_sample_offset,
                device=device,
            )
            should_sync = micro_index == gradient_accumulation - 1
            sync_context = (
                contextlib.nullcontext()
                if should_sync or world_size == 1
                else train_model.no_sync()
            )
            with sync_context:
                with torch.autocast(
                    device_type=device.type,
                    dtype=torch.bfloat16,
                    enabled=use_bf16,
                ):
                    loss = train_model(
                        input_ids=inputs, labels=labels, use_cache=False
                    ).loss
                (loss / gradient_accumulation).backward()
            accumulated_loss += loss.detach()

        grad_norm = torch.nn.utils.clip_grad_norm_(
            train_model.parameters(), max_grad_norm
        )
        optimizer.step()
        scheduler.step()
        optimizer.zero_grad(set_to_none=True)
        step += 1

        accumulated_loss /= gradient_accumulation
        if world_size > 1:
            dist.all_reduce(accumulated_loss, op=dist.ReduceOp.SUM)
            accumulated_loss /= world_size

        if log_every > 0 and (step % log_every == 0 or step == 1):
            if device.type == "cuda":
                torch.cuda.synchronize(device)
            elapsed = time.perf_counter() - interval_start
            processed_tokens = (step - interval_step) * tokens_per_step
            if is_main:
                log_row = {
                    "step": step,
                    "max_steps": max_steps,
                    "train_loss": round(accumulated_loss.item(), 6),
                    "learning_rate": scheduler.get_last_lr()[0],
                    "grad_norm": float(grad_norm),
                    "tokens_seen": step * tokens_per_step,
                    "tokens_per_second": round(processed_tokens / max(elapsed, 1e-9)),
                }
                print(json.dumps(log_row, ensure_ascii=False))
            interval_start = time.perf_counter()
            interval_step = step

        if eval_every > 0 and step % eval_every == 0:
            assert validation_dataset is not None
            validation_loss = evaluate_loss(
                train_model,
                validation_dataset,
                batches=int(training.get("eval_batches", 50)),
                batch_size=batch_size,
                rank=rank,
                world_size=world_size,
                device=device,
                use_bf16=use_bf16,
            )
            if is_main:
                print(
                    json.dumps(
                        {
                            "step": step,
                            "validation_loss": round(validation_loss, 6),
                            "validation_perplexity": round(
                                math.exp(min(validation_loss, 20.0)), 4
                            ),
                        },
                        ensure_ascii=False,
                    )
                )

        if save_every > 0 and step % save_every == 0:
            if world_size > 1:
                dist.barrier()
            if is_main:
                checkpoint_path = save_checkpoint(
                    output_dir=output_dir,
                    step=step,
                    model=raw_model,
                    tokenizer=tokenizer,
                    optimizer=optimizer,
                    scheduler=scheduler,
                    training_config=full_config,
                    world_size=world_size,
                )
                print(f"Saved checkpoint: {checkpoint_path}")
            if world_size > 1:
                dist.barrier()

    stopped_early = step < max_steps
    if bool(training.get("save_final", True)) or stopped_early:
        if world_size > 1:
            dist.barrier()
        if is_main:
            checkpoint_path = save_checkpoint(
                output_dir=output_dir,
                step=step,
                model=raw_model,
                tokenizer=tokenizer,
                optimizer=optimizer,
                scheduler=scheduler,
                training_config=full_config,
                world_size=world_size,
            )
            label = "Stop checkpoint" if stopped_early else "Final checkpoint"
            print(f"{label}: {checkpoint_path}")
        if world_size > 1:
            dist.barrier()

    if world_size > 1:
        dist.destroy_process_group()


if __name__ == "__main__":
    main()