| """Training identities, synchronized failure checks, and balanced FSDP probes.""" |
| import json |
| import math |
| from pathlib import Path |
| import torch |
| import torch.distributed as dist |
| from common.data_contracts import resolve, identity, sha256_file |
|
|
| |
| RESUME_KEYS = ('model', 'vocab_size', 'seq_len', 'micro_bsz', 'global_tokens', |
| 'max_steps', 'lr', 'min_lr_ratio', 'warmup', 'decay_frac', 'wd', |
| 'beta1', 'beta2', 'clip', 'seed', 'compile', 'sampler_version') |
|
|
|
|
| def training_contract(config, world, hold_files): |
| mix_path = resolve(config['mix']) |
| mix = json.loads(mix_path.read_text()) |
| paths = [p for source in mix['sources'].values() for p in source['files']] + list(hold_files) |
| records = {} |
| |
| for name in paths: |
| path = resolve(name).resolve() |
| records[str(path)] = dict(bytes=path.stat().st_size, sha256=sha256_file(path)) |
| value = dict(version=1, world_size=world, |
| config={k: config[k] for k in RESUME_KEYS}, mix=mix, |
| source_order=list(mix['sources']), holdout=list(hold_files), files=records, |
| code={p: sha256_file(resolve(p)) for p in |
| ('model/model.py', 'train/__init__.py', 'train/train.py', 'train/data.py', 'train/runtime.py')}) |
| value['id'] = identity(value) |
| return value |
|
|
|
|
| def validate_resume(metadata, contract): |
| previous = metadata.get('training_contract') |
| if previous is None: |
| raise ValueError('Checkpoint lacks training identity; use a new run directory (sampler version alone is insufficient)') |
| if previous != contract: |
| raise ValueError('Training identity mismatch: data/tokenizer/mix/config/world/code changed') |
|
|
|
|
| def complete_checkpoints(directory): |
| return sorted(p for p in Path(directory).glob('ckpt_[0-9]*') |
| if p.is_dir() and (p / '.complete').is_file()) |
|
|
|
|
| def local_tensor(value): |
| return value.to_local() if hasattr(value, 'to_local') else value |
|
|
|
|
| def require_finite(value, label, device): |
| bad = (~torch.isfinite(local_tensor(value))).any().to(device=device, dtype=torch.int32) |
| dist.all_reduce(bad, op=dist.ReduceOp.MAX) |
| if bad.item(): |
| raise FloatingPointError(f'non-finite {label}: abort before optimizer update on all ranks') |
|
|
|
|
| def ensure_finite_gradients(model, device): |
| flags = [torch.isfinite(local_tensor(p.grad)).all() for p in model.parameters() if p.grad is not None] |
| valid = torch.stack(flags).all() if flags else torch.ones((), dtype=torch.bool, device=device) |
| require_finite(torch.where(valid, 0.0, float('nan')), 'gradient', device) |
|
|
|
|
| def evaluation_indices(count, world, rank): |
| if count < 1 or world < 1 or not 0 <= rank < world: |
| raise ValueError('Evaluation requires targets and a valid rank/world') |
| return [(min(i, count - 1), i < count) for i in range(rank, math.ceil(count / world) * world, world)] |
|
|
|
|
| @torch.no_grad() |
| def evaluate_holdout(model, fwd, hold, device): |
| if hold is None: |
| return None |
| rank, world = dist.get_rank(), dist.get_world_size() |
| indices = evaluation_indices(len(hold), world, rank) |
| previous = model.training |
| model.eval() |
| totals = torch.zeros(2, dtype=torch.float64, device=device) |
| try: |
| for index, valid in indices: |
| w = hold.wins[index:index + 1].to(device) |
| with torch.autocast('cuda', dtype=torch.bfloat16): |
| loss = fwd(w[:, :-1].contiguous(), w[:, 1:].contiguous()) |
| require_finite(loss, 'evaluation loss', device) |
| if valid: |
| count = w.shape[1] - 1 |
| totals[0] += loss.double() * count |
| totals[1] += count |
| dist.all_reduce(totals) |
| finally: |
| model.train(previous) |
| nll, count = totals.tolist() |
| if count == 0: |
| raise ValueError('Evaluation has no valid targets') |
| return dict(holdout_loss=nll/count, nll_sum=nll, valid_tokens=int(count), |
| windows=len(hold), forwards_per_rank=len(indices)) |
|
|
