Files
MeltMind/tools/s2_pilot_train.py
T

49 lines
2.5 KiB
Python

"""Bounded pilot training primitives; corpus runs require a frozen ready manifest."""
import math
from pathlib import Path
import numpy as np
import torch
from s2_models.network import weighted_mse
def part_weights(counts, parts_in_component, component_count, learning_parts):
c=np.asarray(counts,dtype=np.float64)
if c.ndim!=1 or not len(c) or np.any(c<=0) or not np.isfinite(c).all():raise ValueError('Invalid common query counts')
if min(parts_in_component,component_count,learning_parts)<=0:raise ValueError('Empty training hierarchy')
# Uniform shuffled part steps estimate the full component-balanced objective.
return c/c.sum()/parts_in_component/component_count*learning_parts
def train_part(model,optimizer,base,ids,gaps,edge,target,weights,*,scaler=None,amp=False):
optimizer.zero_grad(set_to_none=True)
with torch.autocast(device_type=base.device.type,dtype=torch.float16,enabled=amp):
prediction=model(base,ids,gaps,edge if model.arm=='E' else None)
loss=weighted_mse(prediction,target,weights)
if not torch.isfinite(loss):raise FloatingPointError('Nonfinite training loss')
if scaler is None:
loss.backward()
else:
scaler.scale(loss).backward();scaler.unscale_(optimizer)
if any(p.grad is not None and not torch.isfinite(p.grad).all() for p in model.parameters()):
raise FloatingPointError('Nonfinite gradient; no silent retry or precision fallback')
if scaler is None:optimizer.step()
else:scaler.step(optimizer);scaler.update()
if any(not torch.isfinite(p).all() for p in model.parameters()):raise FloatingPointError('Nonfinite updated parameter')
return float(loss.detach())
def component_score(part_errors,component_ids):
if not part_errors or set(part_errors)!=set(component_ids):raise ValueError('Incomplete validation roster')
groups={}
for part,value in part_errors.items():
if value is None or not math.isfinite(value):raise ValueError('Invalid validation part score')
groups.setdefault(component_ids[part],[]).append(value)
return float(np.mean([np.mean(values) for values in groups.values()]))
def select_capacity(scores):
# Exactly four run scores, no choice from an incomplete/failed run matrix.
if set(scores)!={(arm,width) for arm in ['N','E'] for width in [128,256]}:raise ValueError('All four pilot runs required')
if any(v is None or not math.isfinite(v) for v in scores.values()):raise ValueError('All four pilot validation scores must be finite')
return min([128,256],key=lambda w:((scores['N',w]+scores['E',w])/2,w))