scripts/preflight.py

from __future__ import annotations

import argparse
import glob
import importlib.util
import json
import math
from pathlib import Path
from typing import Any

import numpy as np
import torch
from transformers import AutoTokenizer

from kawk50m.cli import configure_utf8_stdio
from kawk50m.config import build_llama_config, load_yaml


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Validate model, tokenizer, token binaries, and GPU before training."
    )
    parser.add_argument("--config", default="configs/pretrain_5b_5090.yaml")
    return parser.parse_args()


def binary_info(
    path_value: str | list[str],
    sequence_length: int,
) -> dict[str, Any]:
    values = [path_value] if isinstance(path_value, str) else path_value
    paths: set[Path] = set()
    for value in values:
        matches = [Path(item) for item in glob.glob(value)]
        if matches:
            paths.update(item.resolve() for item in matches if item.is_file())
        else:
            candidate = Path(value)
            if candidate.is_file():
                paths.add(candidate.resolve())
    ordered_paths = sorted(paths)
    if not ordered_paths:
        return {"path": path_value, "exists": False}
    byte_sizes = [path.stat().st_size for path in ordered_paths]
    byte_size = sum(byte_sizes)
    token_count = sum(
        size // np.dtype(np.uint16).itemsize for size in byte_sizes
    )
    sequences = sum(
        max(
            0,
            (size // np.dtype(np.uint16).itemsize - 1) // sequence_length,
        )
        for size in byte_sizes
    )
    return {
        "path": path_value,
        "files": [str(path) for path in ordered_paths],
        "file_count": len(ordered_paths),
        "exists": True,
        "bytes": byte_size,
        "tokens": token_count,
        "sequences": sequences,
        "even_byte_size": all(size % 2 == 0 for size in byte_sizes),
    }


def main() -> None:
    configure_utf8_stdio()
    args = parse_args()
    full_config = load_yaml(args.config)
    data = full_config.get("data")
    training = full_config.get("training")
    if not isinstance(data, dict) or not isinstance(training, dict):
        raise ValueError("Training YAML requires data and training mappings")

    sequence_length = int(data["sequence_length"])
    train_paths = data.get("train_bins", data.get("train_bin"))
    if train_paths is None:
        raise ValueError("data requires train_bin or train_bins")
    train_info = binary_info(train_paths, sequence_length)
    validation_info = binary_info(data["validation_bin"], sequence_length)
    errors: list[str] = []
    warnings: list[str] = []

    tokenizer_path = Path(full_config["tokenizer_dir"])
    tokenizer_info: dict[str, Any] = {
        "path": str(tokenizer_path),
        "exists": tokenizer_path.is_dir(),
    }
    tokenizer = None
    if tokenizer_path.is_dir():
        try:
            tokenizer = AutoTokenizer.from_pretrained(
                tokenizer_path, use_fast=False, legacy=True
            )
            tokenizer_info["vocab_size"] = len(tokenizer)
            tokenizer_info["special_token_ids"] = {
                "bos": tokenizer.bos_token_id,
                "eos": tokenizer.eos_token_id,
                "pad": tokenizer.pad_token_id,
                "unk": tokenizer.unk_token_id,
            }
        except Exception as error:
            errors.append(f"Tokenizer cannot be loaded: {error}")
    else:
        errors.append(f"Missing tokenizer directory: {tokenizer_path}")

    model_config, expected_parameters = build_llama_config(
        load_yaml(full_config["model_config"]),
        tokenizer_vocab_size=len(tokenizer) if tokenizer is not None else None,
    )
    if sequence_length > model_config.max_position_embeddings:
        errors.append("sequence_length exceeds model context length")

    for split, info in (("train", train_info), ("validation", validation_info)):
        if not info["exists"]:
            errors.append(f"Missing {split} token binary: {info['path']}")
        elif not info["even_byte_size"]:
            errors.append(f"{split} binary size is not valid uint16")
        elif info["sequences"] == 0:
            errors.append(f"{split} binary does not contain one full sequence")

    batch_size = int(training["per_device_batch_size"])
    accumulation = int(training["gradient_accumulation_steps"])
    world_size = int(training.get("world_size", 1))
    tokens_per_step = sequence_length * batch_size * accumulation * world_size
    max_steps_value = training.get("max_steps")
    if max_steps_value is None:
        max_tokens = int(training["max_tokens"])
        max_steps = math.ceil(max_tokens / tokens_per_step)
    else:
        max_steps = int(max_steps_value)
        max_tokens = max_steps * tokens_per_step
    if train_info.get("exists") and train_info.get("tokens", 0) < max_tokens:
        warnings.append(
            "The train binary is smaller than the training token budget; "
            "the deterministic sampler will start another pass over the data."
        )

    gpu_info: dict[str, Any] = {
        "available": torch.cuda.is_available(),
        "bf16_supported": (
            torch.cuda.is_available() and torch.cuda.is_bf16_supported()
        ),
        "triton_available": importlib.util.find_spec("triton") is not None,
    }
    if torch.cuda.is_available():
        properties = torch.cuda.get_device_properties(0)
        gpu_info.update(
            {
                "name": properties.name,
                "memory_gib": properties.total_memory / 1024**3,
            }
        )
        if "5090" not in properties.name:
            warnings.append(
                f"Expected an RTX 5090 configuration, detected {properties.name}."
            )
    else:
        warnings.append("No CUDA GPU is visible in this preflight environment.")
    if torch.cuda.is_available() and not gpu_info["bf16_supported"]:
        errors.append("The detected CUDA GPU does not support BF16")
    if not gpu_info["triton_available"]:
        warnings.append("Triton is unavailable; torch.compile will fall back to eager.")

    result = {
        "ok": not errors,
        "config": str(Path(args.config).resolve()),
        "model": {
            "expected_parameters": expected_parameters,
            "vocab_size": model_config.vocab_size,
            "layers": model_config.num_hidden_layers,
            "context_length": model_config.max_position_embeddings,
        },
        "tokenizer": tokenizer_info,
        "data": {"train": train_info, "validation": validation_info},
        "training": {
            "per_device_batch_size": batch_size,
            "gradient_accumulation_steps": accumulation,
            "tokens_per_optimizer_step": tokens_per_step,
            "max_steps": max_steps,
            "planned_tokens": max_steps * tokens_per_step,
        },
        "gpu": gpu_info,
        "warnings": warnings,
        "errors": errors,
    }
    print(json.dumps(result, ensure_ascii=False, indent=2))
    if errors:
        raise SystemExit(1)


if __name__ == "__main__":
    main()