pear15-stage3-checkpoints / pear15 /scratch_train.py
coderofpears's picture
publish portable stage runner + frozen sources
970acf9 verified
Raw History Blame Contribute Delete
32.4 kB
"""Offline, random-initialized Llama training with single-writer durable resume.
Run ``python -m pear15.scratch_train --help``. No tokenizer/weights/config are
fetched: LlamaConfig and LlamaForCausalLM are constructed from local JSON.
``run_training`` accepts JSON paths or dictionaries and returns a JSON-safe
session summary. ``model_factory(raw_config)`` is an optional offline test seam.
The schedule horizon is training.total_steps, NOT the session limit. Checkpoints
live directly in run_dir and include the next packed-data position. Step zero
is saved before training. Only fully completed optimizer steps are published;
KeyboardInterrupt discards ALL work since the last durable snapshot, even if
it interrupted optimizer.step itself. Other exceptions propagate without a
final save. SIGTERM requests a stop after the current step. A second runtime
must never write this RunDir concurrently.
training.precision accepts auto (default), fp32 or bf16. Auto uses BF16 autocast
only on native-BF16 CUDA hardware (capability >= 8 and the non-emulation API
check when available); otherwise it uses FP32.
Explicit BF16 requires native CUDA support; CPU uses FP32. CUDA always retains
FP32 master parameters/state and fused AdamW; CPU uses nonfused AdamW, with no
automatic CUDA-error fallback. Resolved precision is part of checkpoint identity.
Session wall limits are checked at step boundaries and can overshoot by a step
plus evaluation/I/O. Zero session limits publish the initial snapshot (or resume
the existing snapshot) without consuming a batch or performing an update.
Elapsed training time counts completed steps/evaluation, not checkpoint I/O or
downtime. Tokens count every B*T target in every accumulation and corpus pass.
Step logs are emitted every training.log_interval_steps (default 50) and at
the final schedule step; checkpoint/session events always retain full counters.
Checkpoint v2 binds the exact source bytes of this trainer, scratch_data.py and
cloud_checkpoint.py. Source/format changes (including a future XLA port) require
matching source/version or an explicit migration into a new run_dir; environment
change permission never overrides implementation identity. V1 cannot auto-resume.
"""
from __future__ import annotations
import argparse
from contextlib import contextmanager, nullcontext
import hashlib
from importlib.metadata import version
import json
import logging
import math
from pathlib import Path
import platform
import random
import signal
import threading
import time
from .cloud_checkpoint import load_latest, save_checkpoint
from .scratch_data import PackedTokenReader, evaluation_batches
_LOG = logging.getLogger(__name__)
_FORMAT = "pear15.scratch-train.v2"
_DEFAULTS = {
"total_steps": 100_000, "warmup_steps": 1_000,
"sequence_length": 1024, "batch_size": 8, "gradient_accumulation_steps": 1,
"learning_rate": 0.0003, "min_lr_ratio": 0.1, "weight_decay": 0.1,
"adam_beta1": 0.9, "adam_beta2": 0.95, "adam_epsilon": 1e-8,
"max_grad_norm": 1.0, "seed": 1337, "gradient_checkpointing": True,
"attention_backend": "sdpa", "loss_chunk_tokens": 1024, "precision": "auto",
"checkpoint_interval_steps": 500, "checkpoint_interval_seconds": 900.0,
"log_interval_steps": 50,
"eval_interval_steps": 500, "eval_targets": 8192,
}
# These controls cannot change the update math/schedule. The backend is checked
# separately as part of the environment and requires explicit permission to change.
_OPERATIONAL = {"checkpoint_interval_steps", "checkpoint_interval_seconds",
"log_interval_steps", "attention_backend"}
_MODEL_FIELDS = {
"model_type", "vocab_size", "hidden_size", "intermediate_size",
"num_hidden_layers", "num_attention_heads", "num_key_value_heads",
"max_position_embeddings", "rope_theta", "rms_norm_eps", "hidden_act",
"attention_bias", "mlp_bias", "attention_dropout", "tie_word_embeddings",
"bos_token_id", "eos_token_id", "pad_token_id", "use_cache",
"initializer_range", "head_dim", "rope_scaling",
}
def _unique(pairs):
result = {}
for key, value in pairs:
if key in result:
raise ValueError(f"duplicate JSON key: {key}")
result[key] = value
return result
def _json(value):
if isinstance(value, dict):
# Detach callers' mutable config and reject non-JSON/nonfinite values.
return json.loads(json.dumps(value, allow_nan=False))
def reject(value):
raise ValueError(f"nonfinite JSON constant: {value}")
return json.loads(Path(value).read_text(encoding="utf-8"),
object_pairs_hook=_unique, parse_constant=reject)
def _fingerprint(value):
raw = json.dumps(value, sort_keys=True, separators=(",", ":"),
ensure_ascii=False, allow_nan=False)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()
def _implementation_fingerprint():
"""Path-independent identity of the exact, required local training sources.
Read bytes, not decoded/normalized text or bytecode. Missing source fails
closed; unrelated package/notebook/config files are deliberately excluded.
"""
root = Path(__file__).resolve().parent
sources = {}
for name in ("scratch_train.py", "scratch_data.py", "cloud_checkpoint.py"):
try:
sources[name] = hashlib.sha256((root / name).read_bytes()).hexdigest()
except OSError as exc:
raise ValueError(f"cannot fingerprint implementation source {name}; refusing training") from exc
return _fingerprint({"format": _FORMAT, "sources": sources})
def _int(value, name, minimum=0):
if type(value) is not int or value < minimum:
raise ValueError(f"{name} must be an integer >= {minimum}")
return value
def _number(value, name, minimum=0, *, positive=False):
if (type(value) not in (int, float) or not math.isfinite(value)
or value < minimum or (positive and value == 0)):
raise ValueError(f"invalid finite {name}")
return value
def _configs(model_config, train_config):
model, raw = _json(model_config), _json(train_config)
if not isinstance(model, dict) or model.get("model_type") != "llama":
raise ValueError("model config must describe a local llama")
if set(model) - _MODEL_FIELDS:
raise ValueError(f"unsupported model config fields: {set(model) - _MODEL_FIELDS}")
if model.get("vocab_size") != 49152:
raise ValueError("packed scratch data requires model vocab_size 49152")
for key in ("hidden_size", "intermediate_size", "num_hidden_layers",
"num_attention_heads", "num_key_value_heads", "max_position_embeddings"):
_int(model.get(key), key, 1)
heads, kv = model["num_attention_heads"], model["num_key_value_heads"]
if model["hidden_size"] % heads or heads % kv:
raise ValueError("invalid Llama attention dimensions")
if model.get("head_dim", model["hidden_size"] // heads) % 2:
raise ValueError("Llama rotary head dimension must be even")
if not isinstance(raw, dict) or set(raw) != {"training"} or not isinstance(raw["training"], dict):
raise ValueError("train config requires a training object")
unknown = set(raw["training"]) - set(_DEFAULTS)
if unknown:
raise ValueError(f"unknown training settings: {unknown}; session limits belong to the invocation")
cfg = {**_DEFAULTS, **raw["training"]}
for key in ("total_steps", "sequence_length", "batch_size", "gradient_accumulation_steps",
"log_interval_steps"):
_int(cfg[key], key, 1)
for key in ("warmup_steps", "seed", "loss_chunk_tokens", "checkpoint_interval_steps",
"eval_interval_steps", "eval_targets"):
_int(cfg[key], key)
if cfg["total_steps"] >= 10**12 or cfg["warmup_steps"] > cfg["total_steps"]:
raise ValueError("invalid fixed schedule horizon/warmup")
if cfg["sequence_length"] > model["max_position_embeddings"]:
raise ValueError("sequence_length exceeds model position limit")
for key in ("learning_rate", "adam_epsilon", "max_grad_norm"):
_number(cfg[key], key, positive=True)
for key in ("weight_decay", "checkpoint_interval_seconds"):
_number(cfg[key], key)
for key in ("adam_beta1", "adam_beta2", "min_lr_ratio"):
_number(cfg[key], key)
if cfg[key] >= 1 and not (key == "min_lr_ratio" and cfg[key] == 1):
raise ValueError(f"{key} outside allowed [0,1] range")
if type(cfg["gradient_checkpointing"]) is not bool:
raise ValueError("gradient_checkpointing must be boolean")
if cfg["attention_backend"] not in {"eager", "sdpa"}:
raise ValueError("attention_backend must be eager or sdpa (no remote implementations)")
if cfg["precision"] not in ("auto", "fp32", "bf16"):
raise ValueError("precision must be auto, fp32 or bf16")
if cfg["eval_interval_steps"] and not cfg["eval_targets"]:
raise ValueError("eval_interval_steps requires positive eval_targets")
return model, cfg
def build_model(raw_config, *, attention_backend="sdpa"):
"""Construct REAL random HF Llama weights; no Auto*/from_pretrained/network."""
from transformers import LlamaConfig, LlamaForCausalLM
config = LlamaConfig(**raw_config)
config.use_cache = False
config._attn_implementation = attention_backend
return LlamaForCausalLM(config)
def shifted_cross_entropy(logits, targets, chunk_tokens=0):
"""All positions are already shifted by PackedTokenReader, including row ends.
Chunk checkpointing recomputes CE during backward instead of retaining a
full FP32 vocab-sized log-softmax for every chunk. HF still emits full logits.
"""
import torch
from torch.nn import functional as F
from torch.utils.checkpoint import checkpoint
flat, labels = logits.reshape(-1, logits.shape[-1]), targets.reshape(-1)
if not chunk_tokens:
return F.cross_entropy(flat.float(), labels)
def summed(chunk, gold):
return F.cross_entropy(chunk.float(), gold, reduction="sum")
loss = logits.new_zeros((), dtype=torch.float32)
for start in range(0, labels.numel(), chunk_tokens):
chunk, gold = flat[start:start + chunk_tokens], labels[start:start + chunk_tokens]
if torch.is_grad_enabled() and chunk.requires_grad:
loss = loss + checkpoint(summed, chunk, gold, use_reentrant=False,
preserve_rng_state=False)
else:
loss = loss + summed(chunk, gold)
return loss / labels.numel()
def _rng(torch, device):
return {"python": random.getstate(), "cpu": torch.get_rng_state(),
"cuda": torch.cuda.get_rng_state_all() if device == "cuda" else []}
def _restore_rng(torch, state, device, *, restore_cuda=True):
random.setstate(state["python"])
torch.set_rng_state(state["cpu"])
if device == "cuda" and restore_cuda and state["cuda"]:
torch.cuda.set_rng_state_all(state["cuda"])
def _cuda_bf16_support(torch):
"""Report the active GPU's API/emulation result separately from native support."""
major, _ = torch.cuda.get_device_capability()
api_supported = bool(torch.cuda.is_bf16_supported())
try:
api_native = bool(torch.cuda.is_bf16_supported(including_emulation=False))
except TypeError: # Older PyTorch lacks the non-emulation keyword.
api_native = None
return {"api_supported_including_emulation": api_supported,
"api_supported_excluding_emulation": api_native,
"native_supported": major >= 8 and (api_supported if api_native is None else api_native)}
def _resolve_precision(torch, device, precision):
if precision == "fp32":
return "fp32"
native = device == "cuda" and _cuda_bf16_support(torch)["native_supported"]
if precision == "bf16" and not native:
raise RuntimeError("precision bf16 requires native CUDA BF16 support (compute capability >= 8); "
"use auto or fp32")
return "bf16" if native else "fp32"
def _autocast(torch, device, precision):
if precision == "fp32":
return nullcontext()
if precision != "bf16" or device != "cuda":
raise ValueError("autocast requires resolved fp32 or CUDA bf16 precision")
return torch.autocast(device, dtype=torch.bfloat16)
def evaluate(model, data, cfg, device):
"""Deterministic finite validation prefix, independent cursor and RNG-neutral."""
import torch
rng, was_training = _rng(torch, device), model.training
total, nll = 0, 0.0
try:
model.eval()
with torch.no_grad():
for x, y, count in evaluation_batches(
data, cfg["batch_size"], cfg["sequence_length"],
eval_targets=cfg["eval_targets"]):
x = torch.tensor(x, dtype=torch.long, device=device)
y = torch.tensor(y, dtype=torch.long, device=device)
with _autocast(torch, device, cfg["precision"]):
logits = model(input_ids=x, use_cache=False).logits
loss = shifted_cross_entropy(logits, y, cfg["loss_chunk_tokens"])
if not torch.isfinite(loss).item():
raise FloatingPointError("nonfinite validation loss")
total += count
nll += loss.item() * count
if not total:
raise ValueError("validation has no targets")
return {"loss": nll / total, "token_count": total}
finally:
model.train(was_training)
_restore_rng(torch, rng, device)
def _lr_factor(completed, cfg):
# LR for the NEXT update: first warmup update uses base_lr/warmup_steps.
if completed < cfg["warmup_steps"]:
return (completed + 1) / cfg["warmup_steps"]
span = max(1, cfg["total_steps"] - cfg["warmup_steps"])
progress = min(1.0, (completed - cfg["warmup_steps"]) / span)
return cfg["min_lr_ratio"] + (1 - cfg["min_lr_ratio"]) * (1 + math.cos(math.pi * progress)) / 2
def _environment(torch, device, cfg, factory):
gpus = []
if device == "cuda":
for index in range(torch.cuda.device_count()):
prop = torch.cuda.get_device_properties(index)
gpus.append({"name": prop.name, "capability": [prop.major, prop.minor],
"total_memory": prop.total_memory})
return {"device": device, "gpus": gpus,
"cuda_device": torch.cuda.current_device() if device == "cuda" else None,
"torch": str(torch.__version__), "cuda_runtime": torch.version.cuda,
"transformers": version("transformers") if factory is None else None,
"python": platform.python_version(), "platform": platform.system(),
"threads": torch.get_num_threads(), "interop_threads": torch.get_num_interop_threads(),
"attention_backend": cfg["attention_backend"], "fused_adamw": device == "cuda",
"precision": cfg["precision"],
"cuda_bf16": _cuda_bf16_support(torch) if device == "cuda" else None,
"deterministic_algorithms": torch.are_deterministic_algorithms_enabled(),
"tf32": bool(torch.backends.cuda.matmul.allow_tf32)}
@contextmanager
def _termination_flag():
flag = threading.Event()
previous = None
installed = threading.current_thread() is threading.main_thread()
if installed:
previous = signal.signal(signal.SIGTERM, lambda *_: flag.set())
try:
yield flag
finally:
if installed:
signal.signal(signal.SIGTERM, previous)
def run_training(data, model_config, train_config, run_dir, *, device="cuda",
max_session_steps=None, max_session_seconds=None,
allow_environment_change=False, model_factory=None,
stop_requested=None):
"""Auto-resume the newest valid snapshot; reject incompatible identities.
max_session_steps counts ADDITIONAL optimizer steps, never changes the LR
horizon. Environment changes require opt-in and are numerical, not bitwise.
Implementation source/format changes cannot use that opt-in: match the saved
source/version or explicitly migrate into a new run_dir instead.
A changed CUDA topology skips CUDA RNG restoration (CPU/Python still restore).
On interruption the returned counters describe the durable checkpoint, not
the abandoned in-memory model/cursor. Other errors are raised to the caller.
"""
import os
import torch
session_start = time.monotonic()
raw_model, cfg = _configs(model_config, train_config)
if device not in {"cpu", "cuda"}:
raise ValueError("device must be cpu or cuda")
if max_session_steps is not None:
_int(max_session_steps, "max_session_steps")
if max_session_seconds is not None:
_number(max_session_seconds, "max_session_seconds")
if device == "cuda" and not torch.cuda.is_available():
raise RuntimeError("CUDA training requires an available GPU; no CPU fallback")
# Resolve before environment reporting and semantic fingerprinting: auto must
# never silently change a resumed run's update precision across GPU families.
cfg["precision"] = _resolve_precision(torch, device, cfg["precision"])
# This must precede CUDA allocations; deterministic CUDA GEMM needs this.
os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8")
torch.use_deterministic_algorithms(True)
torch.backends.cuda.matmul.allow_tf32 = False
torch.backends.cudnn.allow_tf32 = False
torch.backends.cudnn.benchmark = False
env = _environment(torch, device, cfg, model_factory)
factory_name = ("transformers.LlamaForCausalLM" if model_factory is None else
f"{model_factory.__module__}.{model_factory.__qualname__}")
semantic = {key: val for key, val in cfg.items() if key not in _OPERATIONAL}
identity = {"model_fingerprint": _fingerprint(raw_model),
"train_fingerprint": _fingerprint(semantic), "model_factory": factory_name,
"implementation_fingerprint": _implementation_fingerprint()}
root = Path(run_dir)
loaded = load_latest(root)
if loaded is not None:
payload, _ = loaded
saved_identity = payload.get("identity")
if (payload.get("format") != _FORMAT or not isinstance(saved_identity, dict)
or saved_identity.get("implementation_fingerprint") != identity["implementation_fingerprint"]):
# Compatibility is not corruption: never search older snapshots for
# matching code or let allow_environment_change bypass this gate.
raise ValueError("checkpoint implementation mismatch: source bytes or format changed; "
"use matching source/version or explicitly migrate into a new run_dir "
"(allow_environment_change does not override implementation identity)")
del payload
if loaded is None and root.exists():
# Log/info directories from notebook setup do not constitute a prior run.
if any(p.name not in {"logs", "info"} or not p.is_dir() or p.is_symlink()
for p in root.iterdir()):
raise ValueError("nonempty run_dir has no valid checkpoint; use a fresh run_dir or recover it")
with PackedTokenReader(data, split="train") as reader, _termination_flag() as term:
identity.update(dataset_fingerprint=reader.fingerprint,
tokenizer=reader.manifest["tokenizer"])
if raw_model.get("eos_token_id") != identity["tokenizer"]["eos_token_id"]:
raise ValueError("model and dataset tokenizer eos_token_id mismatch")
if cfg["batch_size"] * cfg["sequence_length"] + 1 > reader.total_tokens:
raise ValueError("training corpus is too short for a microbatch")
changed, restore_cuda = False, True
if loaded is not None:
payload, resume_info = loaded
if payload.get("identity") != identity:
raise ValueError("checkpoint dataset/tokenizer/model/train config fingerprint mismatch")
changed = payload["environment"] != env
if changed and not allow_environment_change:
raise ValueError("checkpoint environment changed; pass allow_environment_change explicitly (numerical, not bitwise)")
restore_cuda = (payload["environment"]["gpus"] == env["gpus"]
and payload["environment"]["cuda_device"] == env["cuda_device"])
else:
payload, resume_info = None, None
random.seed(cfg["seed"])
torch.manual_seed(cfg["seed"])
if device == "cuda":
torch.cuda.manual_seed_all(cfg["seed"])
old_dtype = torch.get_default_dtype()
try:
torch.set_default_dtype(torch.float32)
with torch.device("cpu"):
model = (build_model(raw_model, attention_backend=cfg["attention_backend"])
if model_factory is None else model_factory(raw_model))
finally:
torch.set_default_dtype(old_dtype)
model = model.to(device=device, dtype=torch.float32)
model.train()
if cfg["gradient_checkpointing"]:
model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False})
optimizer = torch.optim.AdamW(
model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"],
betas=(cfg["adam_beta1"], cfg["adam_beta2"]), eps=cfg["adam_epsilon"],
fused=device == "cuda", foreach=False)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda n: _lr_factor(n, cfg))
step = token_count = 0
elapsed = 0.0
validation = None
if payload is not None:
step, token_count, elapsed = payload["step"], payload["token_count"], payload["elapsed_training_seconds"]
_int(step, "checkpoint step")
_int(token_count, "checkpoint token_count")
_number(elapsed, "checkpoint elapsed_training_seconds")
expected_tokens = step * cfg["batch_size"] * cfg["sequence_length"] * cfg["gradient_accumulation_steps"]
if step > cfg["total_steps"] or token_count != expected_tokens:
raise ValueError("checkpoint step/token count inconsistent with fixed training budget")
model.load_state_dict(payload["model"], strict=True)
optimizer.load_state_dict(payload["optimizer"])
# Saved param groups override constructor options. Reapply the actual
# backend, including correct scalar-step placement across CPU/CUDA.
for group in optimizer.param_groups:
group.update(fused=device == "cuda", foreach=False)
for state in optimizer.state.values():
if "step" in state:
state["step"] = state["step"].to(device if device == "cuda" else "cpu")
scheduler.load_state_dict(payload["scheduler"])
if scheduler.last_epoch != step:
raise ValueError("checkpoint scheduler step mismatch")
reader.load_state_dict(payload["data_cursor"], fingerprint=payload["identity"]["dataset_fingerprint"], split=payload["data_split"])
cursor = reader.state_dict()
if cursor["epoch"] * reader.total_tokens + cursor["offset_tokens"] != token_count:
raise ValueError("checkpoint cursor/token count mismatch")
validation = payload["validation"]
_restore_rng(torch, payload["rng"], device, restore_cuda=restore_cuda)
# Release the loaded CPU checkpoint before training/saving another copy.
del loaded, payload
(root / "logs").mkdir(parents=True, exist_ok=True)
def emit(event, **fields):
record = {"event": event, **fields}
line = json.dumps(record, sort_keys=True, allow_nan=False)
with (root / "logs" / "train.jsonl").open("a", encoding="utf-8") as stream:
stream.write(line + "\n")
_LOG.info("%s", line)
emit("session_start", resume=resume_info, identity=identity, environment=env,
model_config=raw_model, training_config=cfg, initialization="random; no pretrained weights")
if changed:
emit("environment_change", reproducibility="numerical, not bitwise",
cuda_rng_restored=bool(device == "cuda" and restore_cuda),
note="CUDA RNG skipped for changed topology or CPU/CUDA transition" if not restore_cuda else "compatible CUDA topology")
checkpoint_step = step if resume_info else None
checkpoint_info = resume_info
last_save = time.monotonic()
def save():
nonlocal checkpoint_step, checkpoint_info, last_save
if device == "cuda":
torch.cuda.synchronize()
state = {"format": _FORMAT, "step": step, "token_count": token_count,
"elapsed_training_seconds": elapsed, "identity": identity,
"model_config": raw_model, "training_config": cfg, "environment": env,
"model": model.state_dict(), "optimizer": optimizer.state_dict(),
"scheduler": scheduler.state_dict(), "rng": _rng(torch, device),
"data_cursor": reader.state_dict(), "data_split": "train", "validation": validation}
path = save_checkpoint(root, state, keep_last=2)
checkpoint_step, checkpoint_info = step, {"path": str(path), "step": step}
last_save = time.monotonic()
emit("checkpoint", step=step, token_count=token_count, path=str(path))
if checkpoint_step is None:
save() # Mandatory initialized model/optimizer/RNG/data snapshot.
starting_step = step
last_logged_step = step
status = "completed"
try:
while step < cfg["total_steps"]:
if term.is_set() or (stop_requested is not None and stop_requested()):
status = "stop_requested"
break
if max_session_steps is not None and step - starting_step >= max_session_steps:
status = "session_steps"
break
if max_session_seconds is not None and time.monotonic() - session_start >= max_session_seconds:
status = "session_seconds"
break
tick = time.monotonic()
optimizer.zero_grad(set_to_none=True)
batch_tokens, mean_loss = 0, 0.0
lr_used = optimizer.param_groups[0]["lr"]
for _ in range(cfg["gradient_accumulation_steps"]):
x, y, count = reader.get_batch(cfg["batch_size"], cfg["sequence_length"])
x = torch.tensor(x, dtype=torch.long, device=device)
y = torch.tensor(y, dtype=torch.long, device=device)
with _autocast(torch, device, cfg["precision"]):
logits = model(input_ids=x, use_cache=False).logits
loss = shifted_cross_entropy(logits, y, cfg["loss_chunk_tokens"])
if not torch.isfinite(loss).item():
raise FloatingPointError("nonfinite training loss; no checkpoint published")
mean_loss += loss.item() / cfg["gradient_accumulation_steps"]
(loss / cfg["gradient_accumulation_steps"]).backward()
batch_tokens += count
del logits, loss, x, y
norm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["max_grad_norm"], error_if_nonfinite=True)
if not torch.isfinite(norm).item():
raise FloatingPointError("nonfinite gradient norm")
optimizer.step()
scheduler.step()
if device == "cuda":
torch.cuda.synchronize()
step += 1
token_count += batch_tokens
optimizer.zero_grad(set_to_none=True)
if cfg["eval_interval_steps"] and (step % cfg["eval_interval_steps"] == 0 or step == cfg["total_steps"]):
validation = evaluate(model, data, cfg, device)
elapsed += time.monotonic() - tick
if step % cfg["log_interval_steps"] == 0 or step == cfg["total_steps"]:
emit("step", step=step, steps_since_last_log=step - last_logged_step,
loss=mean_loss, grad_norm=norm.item(),
lr=lr_used, next_lr=optimizer.param_groups[0]["lr"],
token_count=token_count, num_passes=token_count / reader.total_tokens,
elapsed_training_seconds=elapsed, validation=validation)
last_logged_step = step
due_steps = cfg["checkpoint_interval_steps"] and step % cfg["checkpoint_interval_steps"] == 0
due_seconds = cfg["checkpoint_interval_seconds"] and time.monotonic() - last_save >= cfg["checkpoint_interval_seconds"]
if due_steps or due_seconds:
save()
# Only this successful/explicitly stopped path may save final state.
if checkpoint_step != step:
save()
except KeyboardInterrupt:
# Never serialize potentially partially mutated optimizer/cursor/RNG.
recovered = load_latest(root)
if recovered is None:
raise RuntimeError("interrupted and no valid checkpoint remains")
durable, checkpoint_info = recovered
step, token_count = durable["step"], durable["token_count"]
elapsed, validation = durable["elapsed_training_seconds"], durable["validation"]
reader.load_state_dict(durable["data_cursor"], fingerprint=reader.fingerprint, split="train")
status = "interrupted"
emit("interrupted", step=step, token_count=token_count,
checkpoint=checkpoint_info, note="in-memory work discarded; resume from this durable snapshot")
except Exception as exc:
emit("failure", error=f"{type(exc).__name__}: {exc}",
last_checkpoint=checkpoint_info, note="no exception/final checkpoint saved")
raise
result = {"status": status, "step": step, "token_count": token_count,
"session_completed_steps": step - starting_step,
"elapsed_training_seconds": elapsed, "data_cursor": reader.state_dict(),
"num_passes": token_count / reader.total_tokens,
"validation": validation, "checkpoint": checkpoint_info,
"resumed_from": resume_info, "environment_changed": changed}
emit("session_end", **result)
return result
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--data", required=True, help="verified packed BPE dataset directory")
parser.add_argument("--model-config", default="configs/scratch135.json")
parser.add_argument("--train-config", default="configs/scratch-train-a100.json")
parser.add_argument("--run-dir", required=True, help="persistent single-writer checkpoint root")
parser.add_argument("--device", choices=("cuda", "cpu"), default="cuda")
parser.add_argument("--max-session-steps", type=int, help="additional optimizer steps this invocation")
parser.add_argument("--max-session-seconds", type=float)
parser.add_argument("--allow-environment-change", action="store_true", default=False)
args = parser.parse_args(argv)
logging.basicConfig(level=logging.INFO, format="%(message)s")
result = run_training(args.data, args.model_config, args.train_config, args.run_dir,
device=args.device, max_session_steps=args.max_session_steps,
max_session_seconds=args.max_session_seconds,
allow_environment_change=args.allow_environment_change)
print(json.dumps(result, sort_keys=True))
return 130 if result["status"] == "interrupted" else 0
if __name__ == "__main__":
raise SystemExit(main())