Datasets:
File size: 4,156 Bytes
dd0011c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 | """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
# Changing these changes the optimization trajectory; operational stop/log paths do not.
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 = {}
# Only rank 0 calls this; immutable token files are verified once at startup.
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))
|