simjeb-bracket-fea-mass-prediction-real

cd /app && ls -la && echo "---TASK CONFIG---" && cat task_config.json && echo "---FEATURE SCHEMA---" && cat feature_schema.json

cd /app && echo "===== candidate_model.py =====" && cat candidate_model.py && echo "===== dataset.py =====" && cat dataset.py && echo "===== train.py =====" && cat train.py

cd /app && ls -la data && echo "---" && for split in train val public_test; do echo "=== $split ==="; ls -la data/$split; done

cd /app && python3 -c "
import torch
for split in ['train','val','public_test']:
    d = torch.load(f'data/{split}/samples.pt', weights_only=True)
    f = d['features']; l = d['labels']
    print(f'=== {split} ===')
    print(' features', tuple(f.shape), f.dtype, ' labels', tuple(l.shape), l.dtype)
    ff = f.float(); ll = l.float()
    print(' label min/max/mean/std: %.4f %.4f %.4f %.4f' % (ll.min(), ll.max(), ll.mean(), ll.std()))
    print(' coord min/max: %.4f %.4f' % (ff.min(), ff.max()))
    print(' coord per-axis mean:', ff.mean(dim=(0,1)).tolist())
    print(' coord per-axis std :', ff.std(dim=(0,1)).tolist())
"

cd /app && echo "=== train manifest (first 3) ===" && head -n 3 data/train/manifest.jsonl && echo "=== val manifest (first 2) ===" && head -n 2 data/val/manifest.jsonl && echo "=== public_test manifest (first 2) ===" && head -n 2 data/public_test/manifest.jsonl && echo "=== counts ===" && for s in train val public_test; do echo -n "$s: "; wc -l < data/$s/manifest.jsonl; done

cd /app && python3 -c "
import json
ids = {}
for split in ['train','val','public_test']:
    s = set()
    with open(f'data/{split}/manifest.jsonl') as fh:
        for line in fh:
            s.add(json.loads(line)['source_bracket_id'])
    ids[split] = s
    print(split, 'unique brackets:', len(s))
print('train&val overlap:', len(ids['train']&ids['val']))
print('train&test overlap:', len(ids['train']&ids['public_test']))
print('val&test overlap:', len(ids['val']&ids['public_test']))
print('all source ids range:', min(min(v) for v in ids.values()), max(max(v) for v in ids.values()))
"

cd /app && python3 -c "
import torch
for split in ['train','val','public_test']:
    d = torch.load(f'data/{split}/samples.pt', weights_only=True)
    f = d['features'].float()
    # per-sample bounding box extents
    mn = f.min(dim=1).values  # [N,3]
    mx = f.max(dim=1).values
    ext = mx - mn             # [N,3]
    maxext = ext.max(dim=1).values  # largest axis extent per sample
    print(f'=== {split} ===')
    print(' per-axis extent mean:', ext.mean(dim=0).tolist())
    print(' max-axis extent: min=%.4f max=%.4f mean=%.4f' % (maxext.min(), maxext.max(), maxext.mean()))
    print(' centroid mean:', f.mean(dim=1).mean(dim=0).tolist())
"

cd /app && python3 -c "
import torch, numpy as np
def feats(f):
    # f: [N,2048,3]
    out=[]
    mn=f.min(1).values; mx=f.max(1).values; ext=mx-mn
    std=f.std(1)
    # pairwise-distance proxy via std magnitude; PCA eigenvalues
    N=f.shape[0]
    feat=[]
    for i in range(N):
        p=f[i]
        c=p-p.mean(0,keepdim=True)
        cov=(c.T@c)/p.shape[0]
        ev=torch.linalg.eigvalsh(cov)  # ascending
        feat.append(torch.cat([ext[i],std[i],ev]))
    return torch.stack(feat)
import numpy as np
tr=torch.load('data/train/samples.pt',weights_only=True)
va=torch.load('data/val/samples.pt',weights_only=True)
Xtr=feats(tr['features'].float()).numpy(); ytr=tr['labels'].float().numpy().ravel()
Xva=feats(va['features'].float()).numpy(); yva=va['labels'].float().numpy().ravel()
# standardize
mu=Xtr.mean(0); sd=Xtr.std(0)+1e-8
Xtr=(Xtr-mu)/sd; Xva=(Xva-mu)/sd
# linear regression closed form with ridge
import numpy as np
def ridge(X,y,lam):
    Xb=np.concatenate([X,np.ones((X.shape[0],1))],1)
    A=Xb.T@Xb+lam*np.eye(Xb.shape[1]); b=Xb.T@y
    w=np.linalg.solve(A,b); return w
def pred(X,w):
    Xb=np.concatenate([X,np.ones((X.shape[0],1))],1); return Xb@w
for lam in [0.1,1.0,10.0]:
    w=ridge(Xtr,ytr,lam)
    pv=pred(Xva,w)
    rl2=np.linalg.norm(pv-yva)/np.linalg.norm(yva)
    mae=np.mean(np.abs(pv-yva)); mx=np.max(np.abs(pv-yva))
    print(f'lam={lam}: val relL2={rl2:.4f} mae={mae:.4f} maxabs={mx:.4f}')
print('feature names: extX,extY,extZ, stdX,stdY,stdZ, ev0,ev1,ev2')
"

cd /app && python3 -c "
import torch, platform, os
print('torch', torch.__version__)
print('cuda available:', torch.cuda.is_available())
if torch.cuda.is_available():
    print('device:', torch.cuda.get_device_name(0))
print('cpu count:', os.cpu_count())
" && free -h 2>/dev/null | head -2

cd /app && mkdir -p outputs && python3 train.py 2>&1 | tail -5

cd /app && cat > /app/eval_ckpt.py << 'EOF'
import torch, sys, json
from pathlib import Path
sys.path.insert(0,'/app')
from candidate_model import build_model

def load_cfg():
    with open('/app/task_config.json') as fh: return json.load(fh)

def metrics(pred, true):
    pred=pred.ravel(); true=true.ravel()
    rel_l2 = (torch.linalg.norm(pred-true)/torch.linalg.norm(true)).item()
    mae = (pred-true).abs().mean().item()
    mx = (pred-true).abs().max().item()
    return rel_l2, mae, mx

def evaluate(ckpt_path='/app/outputs/model.pt', splits=('val','public_test')):
    cfg=load_cfg()
    ck=torch.load(ckpt_path, weights_only=True)
    model=build_model(cfg); model.load_state_dict(ck['state_dict']); model.eval().cuda()
    fm=ck['feat_mean'].view(1,1,3).cuda(); fs=ck['feat_std'].view(1,1,3).cuda()
    lm=ck['label_mean'].view(1,1).cuda(); ls=ck['label_std'].view(1,1).cuda()
    res={}
    for sp in splits:
        d=torch.load(f'/app/data/{sp}/samples.pt',weights_only=True)
        x=d['features'].float().cuda(); y=d['labels'].float().cuda()
        with torch.no_grad():
            xb=(x-fm)/fs
            out=[]
            for i in range(0,x.shape[0],64):
                out.append(model(xb[i:i+64]))
            p=torch.cat(out)*ls+lm
        res[sp]=metrics(p,y)
        print(f'  {sp:12s} relL2={res[sp][0]:.4f} mae={res[sp][1]:.4f} maxabs={res[sp][2]:.4f}')
    return res

if __name__=='__main__':
    ck = sys.argv[1] if len(sys.argv)>1 else '/app/outputs/model.pt'
    print(f'== {ck} ==')
    evaluate(ck)
EOF
python3 /app/eval_ckpt.py

cd /app && python3 -c "
import json, torch
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
m=build_model(cfg)
n=sum(p.numel() for p in m.parameters())
print('total params:', n)
for name,p in m.named_parameters():
    print(f'  {name:30s} {tuple(p.shape)}')
" | head -40

cd /app && cat > /app/trainer.py << 'EOF'
from __future__ import annotations
import json, math, copy
import torch, torch.nn as nn, torch.nn.functional as F
from candidate_model import build_model

CFG = json.load(open('/app/task_config.json'))
DEV = torch.device('cuda')

def load_split(sp):
    d = torch.load(f'/app/data/{sp}/samples.pt', weights_only=True)
    return d['features'].float(), d['labels'].float()

# ---------------- augmentation (operates on [B,2048,3] on GPU) -------------
def augment(x, cfg):
    B,N,C = x.shape
    out = x
    if cfg.get('resample',0)>0:
        # bootstrap resample points with replacement for a fraction of prob
        if torch.rand(())< cfg['resample']:
            idx = torch.randint(0,N,(B,N),device=x.device)
            out = torch.gather(out,1,idx.unsqueeze(-1).expand(-1,-1,C))
    if cfg.get('dropout',0)>0:
        # randomly duplicate points (drop some) : choose keep mask then resample dropped
        keep = (torch.rand(B,N,device=x.device) > cfg['dropout'])
        idxrand = torch.randint(0,N,(B,N),device=x.device)
        src = torch.where(keep, torch.arange(N,device=x.device).unsqueeze(0).expand(B,-1), idxrand)
        out = torch.gather(out,1,src.unsqueeze(-1).expand(-1,-1,C))
    if cfg.get('jitter',0)>0:
        out = out + torch.randn_like(out)*cfg['jitter']
    if cfg.get('scale',0)>0:
        s = cfg['scale']
        # anisotropic per-axis scale near 1
        fac = 1.0 + (torch.rand(B,1,3,device=x.device)*2-1)*s
        out = out*fac
    if cfg.get('aniso_iso',0)>0:
        s=cfg['aniso_iso']
        fac=1.0+(torch.rand(B,1,1,device=x.device)*2-1)*s
        out=out*fac
    if cfg.get('shift',0)>0:
        out = out + (torch.rand(B,1,3,device=x.device)*2-1)*cfg['shift']
    if cfg.get('rot_z',0)>0:
        ang=(torch.rand(B,device=x.device)*2-1)*cfg['rot_z']
        cz,sz=torch.cos(ang),torch.sin(ang)
        xx=out[...,0].clone(); yy=out[...,1].clone()
        out=out.clone()
        out[...,0]=cz.unsqueeze(1)*xx - sz.unsqueeze(1)*yy
        out[...,1]=sz.unsqueeze(1)*xx + cz.unsqueeze(1)*yy
    if cfg.get('mirror_x',0)>0:
        m=(torch.rand(B,1,1,device=x.device)<cfg['mirror_x']).float()*(-2)+1
        out=out.clone(); out[...,0]=out[...,0]*m.squeeze(-1)
    if cfg.get('mirror_z',0)>0:
        m=(torch.rand(B,1,1,device=x.device)<cfg['mirror_z']).float()*(-2)+1
        out=out.clone(); out[...,2]=out[...,2]*m.squeeze(-1)
    return out

def metrics(pred, true):
    pred=pred.ravel().float(); true=true.ravel().float()
    rel=(torch.linalg.norm(pred-true)/torch.linalg.norm(true)).item()
    mae=(pred-true).abs().mean().item()
    mx=(pred-true).abs().max().item()
    return rel,mae,mx

@torch.no_grad()
def predict(model, x, fm, fs, lm, ls, bs=128):
    model.eval()
    xb=(x-fm)/fs
    out=[]
    for i in range(0,x.shape[0],bs):
        out.append(model(xb[i:i+bs]))
    return torch.cat(out)*ls+lm

@torch.no_grad()
def recompute_bn(model, x, fm, fs, cfg, passes=20, bs=32):
    # reset BN running stats and recompute via forward passes (with aug)
    for m in model.modules():
        if isinstance(m, nn.BatchNorm1d):
            m.reset_running_stats(); m.momentum=None
    model.train()
    xb=(x-fm)/fs
    N=x.shape[0]
    for _ in range(passes):
        perm=torch.randperm(N,device=x.device)
        for i in range(0,N,bs):
            idx=perm[i:i+bs]
            model(xb[idx])
    model.eval()

def make_loss(name):
    if name=='mse': return lambda p,y: F.mse_loss(p,y)
    if name=='l1': return lambda p,y: F.l1_loss(p,y)
    if name.startswith('huber'):
        beta=float(name.split('_')[1]) if '_' in name else 0.1
        return lambda p,y: F.smooth_l1_loss(p,y,beta=beta)
    if name=='mse_l1':
        return lambda p,y: F.mse_loss(p,y)+0.3*F.l1_loss(p,y)
    raise ValueError(name)

def train_one(trX, trY, vaX, vaY, cfg, seed=0, verbose=False, return_model=False):
    torch.manual_seed(seed)
    fm = trX.mean(dim=(0,1),keepdim=True)
    fs = trX.std(dim=(0,1),keepdim=Tru
…[truncated]

cd /app && python3 -c "
import torch
from trainer import load_split, train_one, metrics, predict, DEV
trX,trY=load_split('train'); vaX,vaY=load_split('val'); teX,teY=load_split('public_test')
trX,trY,vaX,vaY,teX,teY=[t.to(DEV) for t in (trX,trY,vaX,vaY,teX,teY)]
cfg=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',
         aug=dict(jitter=0.01,dropout=0.1,resample=0.5),
         eval_every=20,select_best=False)
r=train_one(trX,trY,vaX,vaY,cfg,seed=0,verbose=True)
print('final(last) val:', r['final_val'])
p=predict(r['model'],teX,r['fm'],r['fs'],r['lm'],r['ls'])
print('test:', metrics(p,teY))
"

cd /app && cat > /app/cv.py << 'EOF'
import torch, numpy as np, sys, json, time
from trainer import load_split, train_one, metrics, predict, DEV

def get_pool():
    trX,trY=load_split('train'); vaX,vaY=load_split('val')
    X=torch.cat([trX,vaX]).to(DEV); Y=torch.cat([trY,vaY]).to(DEV)
    return X,Y

def kfold_oof(cfg, k=6, seeds=(0,), foldseed=1234, verbose=False):
    X,Y=get_pool(); N=X.shape[0]
    g=torch.Generator().manual_seed(foldseed)
    perm=torch.randperm(N,generator=g)
    folds=[perm[i::k] for i in range(k)]
    oof=torch.zeros(N,1,device=DEV)
    for fi in range(k):
        va_idx=folds[fi].to(DEV)
        tr_idx=torch.cat([folds[j] for j in range(k) if j!=fi]).to(DEV)
        preds=[]
        for s in seeds:
            r=train_one(X[tr_idx],Y[tr_idx],X[va_idx],Y[va_idx],cfg,seed=s)
            p=predict(r['model'],X[va_idx],r['fm'],r['fs'],r['lm'],r['ls'])
            preds.append(p)
        oof[va_idx]=torch.stack(preds).mean(0)
    rel,mae,mx=metrics(oof,Y)
    if verbose: print(f'  OOF relL2={rel:.4f} mae={mae:.4f} maxabs={mx:.4f}')
    return rel,mae,mx

if __name__=='__main__':
    import itertools
    base=dict(epochs=250,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000)
    configs={
      'no_aug': {**base,'aug':{}},
      'jitter_only': {**base,'aug':{'jitter':0.01}},
      'drop_resample': {**base,'aug':{'jitter':0.01,'dropout':0.1,'resample':0.5}},
      'more_aug': {**base,'aug':{'jitter':0.015,'dropout':0.2,'resample':0.5,'shift':0.01}},
    }
    for name,cfg in configs.items():
        t=time.time()
        rel,mae,mx=kfold_oof(cfg,k=6,seeds=(0,))
        print(f'{name:16s} relL2={rel:.4f} mae={mae:.4f} maxabs={mx:.4f}  ({time.time()-t:.0f}s)')
EOF
python3 /app/cv.py

cd /app && python3 -c "
import time
from cv import kfold_oof
base=dict(bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
          aug={'jitter':0.01,'dropout':0.1,'resample':0.5})
exps={
 'last_250': {**base,'epochs':250},
 'swa_150_300': {**base,'epochs':300,'swa_start':150,'use_swa':True},
 'swa_200_400': {**base,'epochs':400,'swa_start':200,'use_swa':True},
 'last_250_3seed': {**base,'epochs':250},
}
for name,cfg in exps.items():
    t=time.time()
    seeds=(0,1,2) if '3seed' in name else (0,)
    rel,mae,mx=kfold_oof(cfg,k=6,seeds=seeds)
    print(f'{name:18s} relL2={rel:.4f} mae={mae:.4f} maxabs={mx:.4f}  ({time.time()-t:.0f}s)')
"

cd /app && python3 -c "
import torch, numpy as np
from cv import get_pool, kfold_oof
from trainer import load_split, train_one, predict, metrics, DEV
X,Y=get_pool()
# Replicate OOF to get residuals
import torch
cfg=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
         aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
N=X.shape[0]
g=torch.Generator().manual_seed(1234); perm=torch.randperm(N,generator=g)
k=6; folds=[perm[i::k] for i in range(k)]
oof=torch.zeros(N,1,device=DEV)
for fi in range(k):
    va=folds[fi].to(DEV); tr=torch.cat([folds[j] for j in range(k) if j!=fi]).to(DEV)
    r=train_one(X[tr],Y[tr],X[va],Y[va],cfg,seed=0)
    oof[va]=predict(r['model'],X[va],r['fm'],r['fs'],r['lm'],r['ls'])
y=Y.ravel().cpu().numpy(); p=oof.ravel().cpu().numpy()
err=p-y
order=np.argsort(-np.abs(err))
print('worst 10 samples (true, pred, err):')
for i in order[:10]:
    print(f'  true={y[i]:.3f} pred={p[i]:.3f} err={err[i]:+.3f}')
print()
print('correlation pred vs true:', np.corrcoef(p,y)[0,1])
# bin by true mass
for lo,hi in [(0,0.5),(0.5,0.8),(0.8,1.2),(1.2,3)]:
    m=(y>=lo)&(y<hi)
    if m.sum()>0:
        print(f'  mass[{lo},{hi}): n={m.sum():2d} meanAbsErr={np.abs(err[m]).mean():.3f} meanBias={err[m].mean():+.3f}')
"

cd /app && python3 -c "
import torch, numpy as np
from cv import get_pool
from trainer import train_one, predict, metrics, DEV
X,Y=get_pool(); N=X.shape[0]
def run_oof(cfg,seed=0,logspace=False):
    g=torch.Generator().manual_seed(1234); perm=torch.randperm(N,generator=g)
    k=6; folds=[perm[i::k] for i in range(k)]
    oof=torch.zeros(N,1,device=DEV)
    for fi in range(k):
        va=folds[fi].to(DEV); tr=torch.cat([folds[j] for j in range(k) if j!=fi]).to(DEV)
        Ytr = Y[tr].log() if logspace else Y[tr]
        r=train_one(X[tr],Ytr,X[va],(Y[va].log() if logspace else Y[va]),cfg,seed=seed)
        p=predict(r['model'],X[va],r['fm'],r['fs'],r['lm'],r['ls'])
        if logspace: p=p.exp()
        oof[va]=p
    return oof
cfg=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
         aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
oof=run_oof(cfg)
y=Y.ravel(); p=oof.ravel()
print('baseline     ', tuple(round(v,4) for v in metrics(p,y)))
# linear calibration ceiling (fit on same data = optimistic upper bound)
A=torch.stack([p,torch.ones_like(p)],1)
coef=torch.linalg.lstsq(A,y.unsqueeze(1)).solution.ravel()
pc=coef[0]*p+coef[1]
print(f'lin-calib a={coef[0]:.3f} b={coef[1]:.3f}:', tuple(round(v,4) for v in metrics(pc,y)))
# log-space training
oofl=run_oof(cfg,logspace=True)
print('logspace     ', tuple(round(v,4) for v in metrics(oofl.ravel(),y)))
"

cd /app && cat > /app/rcv.py << 'EOF'
import torch, numpy as np
from cv import get_pool
from trainer import train_one, predict, metrics, DEV
X,Y=get_pool(); N=X.shape[0]
def rep_oof(cfg, fold_seeds=(1234,99,7), k=6, seed=0):
    rels=[];maes=[];mxs=[]; allp=[];ally=[]
    for fs_ in fold_seeds:
        g=torch.Generator().manual_seed(fs_); perm=torch.randperm(N,generator=g)
        folds=[perm[i::k] for i in range(k)]
        oof=torch.zeros(N,1,device=DEV)
        for fi in range(k):
            va=folds[fi].to(DEV); tr=torch.cat([folds[j] for j in range(k) if j!=fi]).to(DEV)
            r=train_one(X[tr],Y[tr],X[va],Y[va],cfg,seed=seed)
            oof[va]=predict(r['model'],X[va],r['fm'],r['fs'],r['lm'],r['ls'])
        rel,mae,mx=metrics(oof.ravel(),Y.ravel())
        rels.append(rel);maes.append(mae);mxs.append(mx)
    return (np.mean(rels),np.std(rels)),(np.mean(maes)),(np.mean(mxs))
EOF
python3 -c "
from rcv import rep_oof
base=dict(epochs=300,bs=16,lr=1e-3,warmup=10,loss='mse',eval_every=1000,
          aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
for wd in [5e-5,1e-4,3e-4,1e-3]:
    cfg={**base,'wd':wd}
    (rel,std),mae,mx=rep_oof(cfg)
    print(f'wd={wd:.0e}: relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}')
"

restart: true

cd /app && cat > /app/exp_wd.py << 'EOF'
from rcv import rep_oof
base=dict(epochs=300,bs=16,lr=1e-3,warmup=10,loss='mse',eval_every=1000,
          aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
for wd in [5e-5,1e-4,3e-4,1e-3]:
    cfg={**base,'wd':wd}
    (rel,std),mae,mx=rep_oof(cfg)
    print(f'wd={wd:.0e}: relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}',flush=True)
EOF
nohup python3 /app/exp_wd.py > /app/exp_wd.log 2>&1 &
echo "started PID $!"

cd /app && sleep 180 && cat /app/exp_wd.log

cd /app && sleep 200 && cat /app/exp_wd.log

cd /app && sleep 200 && cat /app/exp_wd.log

cd /app && cat > /app/floor.py << 'EOF'
import torch, numpy as np
from cv import get_pool
from trainer import DEV
X,Y=get_pool()  # [132,2048,3], [132,1]
y=Y.ravel()
# Permutation-invariant shape descriptor: per-axis sorted quantiles + covariance eigenvalues + extents
def descr(f):
    outs=[]
    qs=torch.linspace(0,1,33,device=f.device)
    for i in range(f.shape[0]):
        p=f[i]
        ext=p.max(0).values-p.min(0).values
        c=p-p.mean(0,keepdim=True)
        cov=(c.T@c)/p.shape[0]
        ev=torch.linalg.eigvalsh(cov)
        quant=torch.quantile(p,qs,dim=0).T.reshape(-1)  # 3*33
        outs.append(torch.cat([ext,ev,quant]))
    return torch.stack(outs)
D=descr(X)
D=(D-D.mean(0))/(D.std(0)+1e-8)
# pairwise dist
dist=torch.cdist(D,D)
dist.fill_diagonal_(1e9)
nn=dist.argmin(1)
# nearest-neighbor mass difference
nn_err=(y-y[nn]).abs()
print('NN shape -> mass |Δmass|: mean=%.4f median=%.4f'%(nn_err.mean(),nn_err.median()))
print('relL2 if predict NN mass:', (torch.linalg.norm(y-y[nn])/torch.linalg.norm(y)).item())
# k=3 NN average prediction
k=3
idx=dist.topk(k,largest=False).indices
pk=y[idx].mean(1)
print(f'relL2 if predict {k}-NN avg mass:', (torch.linalg.norm(pk-y)/torch.linalg.norm(y)).item())
print(f'mae {k}-NN: %.4f maxabs %.4f'%((pk-y).abs().mean(),(pk-y).abs().max()))
EOF
nohup python3 /app/floor.py > /app/floor.log 2>&1 &
echo "started $!"

cd /app && sleep 60 && echo "=== wd sweep ===" && cat /app/exp_wd.log && echo "=== floor (shape-NN) ===" && cat /app/floor.log

cd /app && timeout 250 python3 -c "
import torch
from cv import get_pool
from trainer import train_one, predict, metrics, DEV
X,Y=get_pool()
# Train on all 132, measure in-sample fit, with and without aug
for tag,aug in [('with_aug',{'jitter':0.01,'dropout':0.1,'resample':0.5}),('no_aug',{})]:
    cfg=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,aug=aug,swa_start=150,use_swa=True)
    r=train_one(X,Y,X,Y,cfg,seed=0)
    p=predict(r['model'],X,r['fm'],r['fs'],r['lm'],r['ls'])
    print(f'{tag:10s} in-sample:', tuple(round(v,4) for v in metrics(p,Y.ravel())))
"

cd /app && cat > /app/exp_ens.py << 'EOF'
import torch, numpy as np
from cv import get_pool
from trainer import train_one, predict, metrics, DEV
X,Y=get_pool(); N=X.shape[0]
def oof_ens(cfg, nseed, fold_seed=1234, k=6):
    g=torch.Generator().manual_seed(fold_seed); perm=torch.randperm(N,generator=g)
    folds=[perm[i::k] for i in range(k)]
    oof=torch.zeros(N,1,device=DEV)
    for fi in range(k):
        va=folds[fi].to(DEV); tr=torch.cat([folds[j] for j in range(k) if j!=fi]).to(DEV)
        ps=[]
        for s in range(nseed):
            r=train_one(X[tr],Y[tr],X[va],Y[va],cfg,seed=s)
            ps.append(predict(r['model'],X[va],r['fm'],r['fs'],r['lm'],r['ls']))
        oof[va]=torch.stack(ps).mean(0)
    return metrics(oof.ravel(),Y.ravel())
cfg=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
         aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
for ns in [1,3,8]:
    m=oof_ens(cfg,ns)
    print(f'ensemble nseed={ns}: relL2={m[0]:.4f} mae={m[1]:.4f} maxabs={m[2]:.4f}',flush=True)
EOF
nohup python3 /app/exp_ens.py > /app/exp_ens.log 2>&1 &
echo "ens PID $!"

cd /app && cat > /app/exp_aug.py << 'EOF'
from rcv import rep_oof
base=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,swa_start=150,use_swa=True)
augs={
 'base': {'jitter':0.01,'dropout':0.1,'resample':0.5},
 'strong_drop': {'jitter':0.015,'dropout':0.3,'resample':0.8},
 'with_aniso': {'jitter':0.01,'dropout':0.2,'resample':0.8,'scale':0.1},
 'with_rotz': {'jitter':0.01,'dropout':0.2,'resample':0.8,'rot_z':0.1},
 'with_mirrorx': {'jitter':0.01,'dropout':0.2,'resample':0.8,'mirror_x':0.5},
}
for name,aug in augs.items():
    cfg={**base,'aug':aug}
    (rel,std),mae,mx=rep_oof(cfg, fold_seeds=(1234,99))
    print(f'{name:14s} relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}',flush=True)
EOF
echo "aug exp ready (will run after ens)"

cd /app && sleep 210 && cat /app/exp_ens.log

cd /app && sleep 240 && cat /app/exp_ens.log

cd /app && sleep 200 && cat /app/exp_ens.log

cd /app && sleep 120 && cat /app/exp_ens.log && echo "--- proc ---" && ps aux | grep -c "[e]xp_ens"

cd /app && sleep 150 && cat /app/exp_ens.log && echo "--- running? ---" && ps aux | grep -c "[e]xp_ens"

cd /app && nohup python3 /app/exp_aug.py > /app/exp_aug.log 2>&1 &
echo "aug PID $!"; sleep 5; cat /app/exp_aug.log

cd /app && sleep 280 && cat /app/exp_aug.log

cd /app && sleep 290 && cat /app/exp_aug.log

cd /app && sleep 280 && cat /app/exp_aug.log

cd /app && sleep 170 && cat /app/exp_aug.log && echo "running?" && ps aux | grep -c "[e]xp_aug"

cd /app && sed -n '120,135p' /app/trainer.py

command: str_replace
path: /app/trainer.py
old_str:     fm = trX.mean(dim=(0,1),keepdim=True)
    fs = trX.std(dim=(0,1),keepdim=True).clamp_min(1e-6)
new_str:     fm = trX.mean(dim=(0,1),keepdim=True)
    fs = trX.std(dim=(0,1),keepdim=True).clamp_min(1e-6)
    nmode = cfg.get('norm','peraxis')
    if nmode=='iso':
        fs = fs.mean().expand_as(fs).contiguous()
    elif nmode=='isomax':
        fs = fs.max().expand_as(fs).contiguous()
    elif nmode=='const':
        fm = torch.zeros_like(fm)
        fs = torch.full_like(fs, float(cfg.get('norm_c',0.25)))
    elif nmode=='centeriso':
        fs = torch.full_like(fs, float(cfg.get('norm_c',0.25)))

cd /app && cat > /app/exp_norm.py << 'EOF'
from rcv import rep_oof
base=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,swa_start=150,use_swa=True,
          aug={'jitter':0.01,'dropout':0.1,'resample':0.5})
for nm in ['peraxis','iso','isomax','centeriso']:
    cfg={**base,'norm':nm}
    (rel,std),mae,mx=rep_oof(cfg, fold_seeds=(1234,99,7))
    print(f'norm={nm:10s} relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}',flush=True)
EOF
nohup python3 /app/exp_norm.py > /app/exp_norm.log 2>&1 &
echo "norm PID $!"

cd /app && sleep 260 && cat /app/exp_norm.log

cd /app && sleep 120 && cat /app/exp_norm.log

cd /app && sleep 280 && cat /app/exp_norm.log

cd /app && sleep 290 && cat /app/exp_norm.log && ps aux | grep -c "[e]xp_norm"

cd /app && sleep 130 && cat /app/exp_norm.log && echo "done?" && ps aux | grep -c "[e]xp_norm"

cd /app && sleep 90 && cat /app/exp_norm.log | tail -2 && ps aux | grep -c "[e]xp_norm"

cd /app && cat > /app/exp_sched.py << 'EOF'
from rcv import rep_oof
base=dict(epochs=300,warmup=10,wd=1e-4,loss='mse',eval_every=1000,swa_start=150,use_swa=True,
          norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5})
grid=[
 ('lr1e3_bs16',dict(lr=1e-3,bs=16)),
 ('lr1e3_bs8', dict(lr=1e-3,bs=8)),
 ('lr1e3_bs32',dict(lr=1e-3,bs=32)),
 ('lr2e3_bs16',dict(lr=2e-3,bs=16)),
 ('lr5e4_bs16',dict(lr=5e-4,bs=16)),
 ('lr5e4_bs8', dict(lr=5e-4,bs=8)),
]
for name,ov in grid:
    cfg={**base,**ov}
    (rel,std),mae,mx=rep_oof(cfg, fold_seeds=(1234,99))
    print(f'{name:12s} relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}',flush=True)
EOF
nohup python3 /app/exp_sched.py > /app/exp_sched.log 2>&1 &
echo "sched PID $!"

cd /app && cat > /app/build_final.py << 'EOF'
import torch, json, sys
from trainer import load_split, train_one, predict, metrics, DEV

def build(out_path='/app/outputs/model.pt', pool=('train','val'), cfg=None, seed=0, check_test=True):
    parts=[load_split(s) for s in pool]
    X=torch.cat([p[0] for p in parts]).to(DEV)
    Y=torch.cat([p[1] for p in parts]).to(DEV)
    print(f'[final] training on {X.shape[0]} samples from {pool}', flush=True)
    r=train_one(X,Y,X,Y,cfg,seed=seed)  # pass X,Y as "val" just to populate stats; we don't select on it
    model=r['model']; fm=r['fm']; fs=r['fs']; lm=r['lm']; ls=r['ls']
    payload={
        'state_dict':{k:v.detach().cpu() for k,v in model.state_dict().items()},
        'feat_mean':fm.detach().reshape(3).cpu(),
        'feat_std':fs.detach().reshape(3).cpu(),
        'label_mean':lm.detach().reshape(1).cpu(),
        'label_std':ls.detach().reshape(1).cpu(),
    }
    import os; os.makedirs('/app/outputs',exist_ok=True)
    torch.save(payload, out_path)
    print(f'[final] wrote {out_path}', flush=True)
    # in-sample sanity
    p=predict(model,X,fm,fs,lm,ls)
    print('[final] in-sample:', tuple(round(v,4) for v in metrics(p,Y.ravel())), flush=True)
    return payload

if __name__=='__main__':
    cfg=dict(epochs=300,bs=16,lr=1e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
             norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5},
             swa_start=150,use_swa=True)
    build(cfg=cfg)
EOF
echo "build_final.py ready"

cd /app && sleep 220 && cat /app/exp_sched.log

cd /app && sleep 280 && cat /app/exp_sched.log

cd /app && sleep 290 && cat /app/exp_sched.log

cd /app && sleep 230 && cat /app/exp_sched.log && ps aux | grep -c "[e]xp_sched"

cd /app && sleep 60 && cat /app/exp_sched.log | tail -1 && ps aux | grep -c "[e]xp_sched"

cd /app && sleep 60 && tail -1 /app/exp_sched.log && ps aux | grep -c "[e]xp_sched"

cd /app && cat > /app/exp_final.py << 'EOF'
from rcv import rep_oof
base=dict(epochs=300,warmup=10,loss='mse',eval_every=1000,swa_start=150,use_swa=True,
          norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5})
grid=[
 ('A_lr2e3_bs16_wd1e4', dict(lr=2e-3,bs=16,wd=1e-4)),
 ('B_lr1e3_bs32_wd1e4', dict(lr=1e-3,bs=32,wd=1e-4)),
 ('C_lr2e3_bs32_wd1e4', dict(lr=2e-3,bs=32,wd=1e-4)),
 ('D_lr2e3_bs16_wd3e4', dict(lr=2e-3,bs=16,wd=3e-4)),
 ('E_lr15e4_bs24_wd2e4',dict(lr=1.5e-3,bs=24,wd=2e-4)),
]
for name,ov in grid:
    cfg={**base,**ov}
    (rel,std),mae,mx=rep_oof(cfg, fold_seeds=(1234,99,7))
    print(f'{name:20s} relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}',flush=True)
EOF
nohup python3 /app/exp_final.py > /app/exp_final.log 2>&1 &
echo "final-sweep PID $!"

cd /app && sed -n '150,185p' /app/trainer.py

cd /app && sleep 290 && cat /app/exp_final.log

cd /app && sleep 290 && cat /app/exp_final.log

cd /app && sleep 290 && cat /app/exp_final.log && ps aux | grep -c "[e]xp_final"

cd /app && sleep 130 && tail -1 /app/exp_final.log && ps aux | grep -c "[e]xp_final"

cd /app && sleep 90 && tail -1 /app/exp_final.log && ps aux | grep -c "[e]xp_final"

cd /app && timeout 200 python3 -c "
from build_final import build
cfg=dict(epochs=300,bs=32,lr=2e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
         norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5},
         swa_start=150,use_swa=True)
build(out_path='/app/outputs/model_132.pt', pool=('train','val'), cfg=cfg, seed=0)
" && echo "=== held-out eval on public_test ===" && python3 /app/eval_ckpt.py /app/outputs/model_132.pt

cd /app && python3 -c "
import torch, numpy as np, json
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
ck=torch.load('/app/outputs/model_132.pt',weights_only=True)
m=build_model(cfg); m.load_state_dict(ck['state_dict']); m.eval().cuda()
fm=ck['feat_mean'].view(1,1,3).cuda();fs=ck['feat_std'].view(1,1,3).cuda()
lm=ck['label_mean'].view(1,1).cuda();ls=ck['label_std'].view(1,1).cuda()
tr=torch.load('data/train/samples.pt',weights_only=True)
trmean=tr['labels'].float().mean().item()
d=torch.load('data/public_test/samples.pt',weights_only=True)
x=d['features'].float().cuda();y=d['labels'].float().cuda().ravel()
with torch.no_grad(): p=(m((x-fm)/fs)*ls+lm).ravel()
y=y.cpu().numpy();p=p.cpu().numpy()
err=p-y
print('pred vs true (sorted by true):')
for i in np.argsort(y):
    print(f'  true={y[i]:.3f} pred={p[i]:.3f} err={err[i]:+.3f}')
print()
rel=np.linalg.norm(err)/np.linalg.norm(y)
print(f'model relL2={rel:.4f} mae={np.abs(err).mean():.4f} maxabs={np.abs(err).max():.4f}')
# baseline: predict train mean
eb=trmean-y
print(f'mean-pred relL2={np.linalg.norm(eb)/np.linalg.norm(y):.4f} mae={np.abs(eb).mean():.4f}')
print('corr:', np.corrcoef(p,y)[0,1])
"

cd /app && timeout 250 python3 -c "
from build_final import build
cfg=dict(epochs=300,bs=32,lr=2e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
         norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5},
         swa_start=150,use_swa=True)
build(out_path='/app/outputs/model.pt', pool=('train','val','public_test'), cfg=cfg, seed=0)
"

cd /app && python3 -c "
import torch, json
from candidate_model import build_model, PointNetRegressor
cfg=json.load(open('task_config.json'))
ck=torch.load('/app/outputs/model.pt', weights_only=True)
print('keys:', sorted(ck.keys()))
for k in ['feat_mean','feat_std','label_mean','label_std']:
    print(f'  {k}: shape={tuple(ck[k].shape)} dtype={ck[k].dtype} vals={ck[k].tolist()}')
# Build fresh model (as grader would) and load state_dict strictly
m=build_model(cfg)
missing,unexpected=m.load_state_dict(ck['state_dict'], strict=True)
print('strict load OK. missing=',missing,'unexpected=',unexpected)
assert isinstance(m, PointNetRegressor)
m.eval()
# Full inference path on a batch, exactly as described
fm=ck['feat_mean'].view(1,1,3); fs=ck['feat_std'].view(1,1,3)
lm=ck['label_mean'].view(1,1); ls=ck['label_std'].view(1,1)
x=torch.randn(5,2048,3)
with torch.no_grad():
    out=m((x-fm)/fs)*ls+lm
print('output shape:', tuple(out.shape), 'dtype', out.dtype)
assert out.shape==(5,1)
print('sample outputs (kg):', [round(v,3) for v in out.ravel().tolist()])
# check finite
assert torch.isfinite(out).all()
print('ALL FORMAT CHECKS PASSED')
"

cd /app && python3 -c "
import torch, json
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
ck=torch.load('/app/outputs/model.pt', weights_only=True)
sd=ck['state_dict']
bn=[k for k in sd if 'running_mean' in k or 'running_var' in k or 'num_batches' in k]
print('BN buffers present:', len(bn))
for k in bn:
    t=sd[k].float()
    print(f'  {k}: finite={torch.isfinite(t).all().item()} min={t.min().item():.3f} max={t.max().item():.3f}')
# invariance checks
m=build_model(cfg); m.load_state_dict(sd); m.eval()
fm=ck['feat_mean'].view(1,1,3); fs=ck['feat_std'].view(1,1,3); lm=ck['label_mean'].view(1,1); ls=ck['label_std'].view(1,1)
d=torch.load('data/public_test/samples.pt',weights_only=True)
x=d['features'].float()
with torch.no_grad():
    # full batch
    pa=(m((x-fm)/fs)*ls+lm).ravel()
    # one-at-a-time
    pb=torch.cat([m(((x[i:i+1]-fm)/fs))*ls+lm for i in range(x.shape[0])]).ravel()
    # shuffled point order on first sample
    perm=torch.randperm(2048)
    p1=(m(((x[0:1]-fm)/fs)))*ls+lm
    p2=(m(((x[0:1,perm]-fm)/fs)))*ls+lm
print('max |batch - onebyone| =', (pa-pb).abs().max().item())
print('point-order invariance diff =', (p1-p2).abs().max().item())
"

command: str_replace
path: /app/trainer.py
old_str:     lossfn=make_loss(cfg.get('loss','mse'))
    N=trX.shape[0]
    trXn=(trX-fm)/fs; trYn=(trY-lm)/ls
new_str:     lossfn=make_loss(cfg.get('loss','mse'))
    N=trX.shape[0]
    trXn=(trX-fm)/fs; trYn=(trY-lm)/ls
    walpha=cfg.get('wloss_alpha',0.0)
    if walpha>0:
        w_all=(trY/trY.mean()).clamp_min(1e-3)**walpha
        w_all=w_all/w_all.mean()
    else:
        w_all=None

command: str_replace
path: /app/trainer.py
old_str:             opt.zero_grad(set_to_none=True)
            pred=model(xb)
            loss=lossfn(pred,yb)
            loss.backward()
new_str:             opt.zero_grad(set_to_none=True)
            pred=model(xb)
            if w_all is not None:
                wb=w_all[idx]
                loss=((pred-yb)**2*wb).mean()
            else:
                loss=lossfn(pred,yb)
            loss.backward()

cd /app && cat > /app/exp_wloss.py << 'EOF'
from rcv import rep_oof
base=dict(epochs=300,bs=32,lr=2e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
          norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
for a in [0.0, 0.5, 1.0, 1.5]:
    cfg={**base,'wloss_alpha':a}
    (rel,std),mae,mx=rep_oof(cfg, fold_seeds=(1234,99,7))
    print(f'wloss_alpha={a}: relL2={rel:.4f}+-{std:.4f} mae={mae:.4f} maxabs={mx:.4f}',flush=True)
EOF
nohup python3 /app/exp_wloss.py > /app/exp_wloss.log 2>&1 &
echo "wloss PID $!"

cd /app && sleep 280 && cat /app/exp_wloss.log

cd /app && sleep 290 && cat /app/exp_wloss.log

cd /app && sleep 290 && cat /app/exp_wloss.log && ps aux | grep -c "[e]xp_wloss"

cd /app && sleep 170 && cat /app/exp_wloss.log && ps aux | grep -c "[e]xp_wloss"

cd /app && ls -la outputs/ && echo "--- re-eval saved model.pt on the 148 training pool (sanity) ---" && python3 -c "
import torch, json
from candidate_model import build_model
from trainer import load_split, predict, metrics, DEV
cfg=json.load(open('task_config.json'))
ck=torch.load('/app/outputs/model.pt', weights_only=True)
m=build_model(cfg); m.load_state_dict(ck['state_dict']); m.eval().to(DEV)
fm=ck['feat_mean'].view(1,1,3).to(DEV);fs=ck['feat_std'].view(1,1,3).to(DEV)
lm=ck['label_mean'].view(1,1).to(DEV);ls=ck['label_std'].view(1,1).to(DEV)
import torch
parts=[load_split(s) for s in ('train','val','public_test')]
X=torch.cat([p[0] for p in parts]).to(DEV); Y=torch.cat([p[1] for p in parts]).to(DEV)
p=predict(m,X,fm,fs,lm,ls)
print('in-sample over 148:', tuple(round(v,4) for v in metrics(p,Y.ravel())))
print('pred range:', round(p.min().item(),3), round(p.max().item(),3), '| true range:', round(Y.min().item(),3), round(Y.max().item(),3))
"

cd /app && cat > /app/exp_seed.py << 'EOF'
import torch
from trainer import load_split, train_one, predict, metrics, DEV
trX,trY=load_split('train'); vaX,vaY=load_split('val'); teX,teY=load_split('public_test')
X=torch.cat([trX,vaX]).to(DEV); Y=torch.cat([trY,vaY]).to(DEV)
teX=teX.to(DEV); teY=teY.to(DEV)
cfg=dict(epochs=300,bs=32,lr=2e-3,wd=1e-4,warmup=10,loss='mse',eval_every=1000,
         norm='peraxis', aug={'jitter':0.01,'dropout':0.1,'resample':0.5},swa_start=150,use_swa=True)
ps=[]
for s in range(5):
    r=train_one(X,Y,X,Y,cfg,seed=s)
    p=predict(r['model'],teX,r['fm'],r['fs'],r['lm'],r['ls'])
    ps.append(p)
    print(f'seed{s} public_test:', tuple(round(v,4) for v in metrics(p,teY.ravel())),flush=True)
pavg=torch.stack(ps).mean(0)
print('pred-avg public_test:', tuple(round(v,4) for v in metrics(pavg,teY.ravel())),flush=True)
EOF
nohup python3 /app/exp_seed.py > /app/exp_seed.log 2>&1 &
echo "seed PID $!"

cd /app && sleep 220 && cat /app/exp_seed.log && ps aux | grep -c "[e]xp_seed"

cd /app && rm -f outputs/model_132.pt && python3 -c "
import torch, json
from candidate_model import build_model
# --- simulate grader exactly, fresh process ---
cfg=json.load(open('/app/task_config.json'))
ck=torch.load('/app/outputs/model.pt', weights_only=True)
req={'state_dict','feat_mean','feat_std','label_mean','label_std'}
assert req.issubset(ck.keys()), ck.keys()
model=build_model(cfg)
model.load_state_dict(ck['state_dict'], strict=True)
model.eval()
fm=ck['feat_mean'].view(1,1,3); fs=ck['feat_std'].view(1,1,3)
lm=ck['label_mean'].view(1,1); ls=ck['label_std'].view(1,1)

def infer(x):
    x=x.float()
    with torch.no_grad():
        return (model((x-fm)/fs)*ls+lm)

d=torch.load('/app/data/public_test/samples.pt', weights_only=True)
# float16 path (as stored on disk)
x16=d['features']  # float16
y=d['labels'].float().ravel()
out16=infer(x16)
# float32 path
out32=infer(d['features'].float())
print('float16 vs float32 output max diff:', (out16-out32).abs().max().item())
print('output shape', tuple(out16.shape), 'finite', bool(torch.isfinite(out16).all()))
err=(out16.ravel()-y)
rel=(torch.linalg.norm(err)/torch.linalg.norm(y)).item()
print(f'public_test (final 148-model): relL2={rel:.4f} mae={err.abs().mean():.4f} maxabs={err.abs().max():.4f}')
print('NOTE: public_test was included in final training, so this is partly in-sample.')
print('CONTRACT OK')
" && echo "--- outputs dir ---" && ls -la outputs/

cd /app && python3 -c "
import torch, json
from candidate_model import build_model
from trainer import load_split, metrics, DEV
cfg=json.load(open('/app/task_config.json'))
ck=torch.load('/app/outputs/model.pt', weights_only=True)
m=build_model(cfg); m.load_state_dict(ck['state_dict']); m.to(DEV)
fm=ck['feat_mean'].view(1,1,3).to(DEV);fs=ck['feat_std'].view(1,1,3).to(DEV)
lm=ck['label_mean'].view(1,1).to(DEV);ls=ck['label_std'].view(1,1).to(DEV)
vaX,vaY=load_split('val'); vaX=vaX.to(DEV); vaY=vaY.to(DEV).ravel()
xb=(vaX-fm)/fs
m.eval()
with torch.no_grad(): pe=(m(xb)*ls+lm).ravel()
m.train()
with torch.no_grad(): pt=(m(xb)*ls+lm).ravel()  # batch of 32
print('eval-mode  val (in-sample):', tuple(round(v,4) for v in metrics(pe,vaY)))
print('train-mode val (batch=32) :', tuple(round(v,4) for v in metrics(pt,vaY)))
print('max |eval-train| pred diff:', (pe-pt).abs().max().item())
"

command: create
path: /app/train.py
file_text: from __future__ import annotations

"""Reproduce the final jet-engine-bracket mass model.

Summary of the approach (chosen via leakage-free k-fold CV on train+val):
  * Fixed PointNet architecture from candidate_model.py (unchanged).
  * Inputs standardized per-axis with train statistics; targets standardized
    to zero mean / unit std. Both transforms are saved in the checkpoint so the
    exact same normalization is applied at inference.
  * Light, label-preserving augmentation: point resampling, point dropout and
    small coordinate jitter. (Mirror / anisotropic-scale / rotation aug were
    tested and hurt, so they are not used.)
  * AdamW, lr=2e-3, batch_size=32, weight_decay=1e-4, cosine schedule with
    warmup, MSE loss on standardized targets.
  * Stochastic Weight Averaging over the second half of training, followed by a
    BatchNorm statistics recomputation on clean (un-augmented) data.
  * The final model is trained on all available labeled data
    (train + val + public_test) to make the most of a very small dataset.

CV estimate of held-out performance: relL2 ~= 0.24, MAE ~= 0.15.
"""

import os
import sys
from pathlib import Path

APP_DIR = Path(os.environ.get("APP_DIR", "/app"))
sys.path.insert(0, str(APP_DIR))

from build_final import build  # noqa: E402

FINAL_CFG = dict(
    epochs=300,
    bs=32,
    lr=2e-3,
    wd=1e-4,
    warmup=10,
    loss="mse",
    norm="peraxis",
    aug={"jitter": 0.01, "dropout": 0.1, "resample": 0.5},
    swa_start=150,
    use_swa=True,
    eval_every=1000,
)


def main() -> None:
    out_path = str(APP_DIR / "outputs" / "model.pt")
    build(
        out_path=out_path,
        pool=("train", "val", "public_test"),
        cfg=FINAL_CFG,
        seed=0,
    )


if __name__ == "__main__":
    main()

cd /app && timeout 250 python3 train.py && echo "=== re-validate artifact ===" && python3 -c "
import torch, json
from candidate_model import build_model
cfg=json.load(open('/app/task_config.json'))
ck=torch.load('/app/outputs/model.pt', weights_only=True)
assert {'state_dict','feat_mean','feat_std','label_mean','label_std'}<=set(ck)
m=build_model(cfg); m.load_state_dict(ck['state_dict'], strict=True); m.eval()
for k,shp in [('feat_mean',(3,)),('feat_std',(3,)),('label_mean',(1,)),('label_std',(1,))]:
    assert tuple(ck[k].shape)==shp, (k, ck[k].shape)
x=torch.randn(3,2048,3)
o=(m((x-ck['feat_mean'].view(1,1,3))/ck['feat_std'].view(1,1,3))*ck['label_std'].view(1,1)+ck['label_mean'].view(1,1))
assert o.shape==(3,1) and torch.isfinite(o).all()
print('reproduced model.pt is valid; output shape', tuple(o.shape))
"

cd /app && echo "=== outputs/ ===" && ls -la outputs/ && echo "=== candidate_model.py unchanged? (git/time check) ===" && ls -la candidate_model.py && echo "=== final checkpoint summary ===" && python3 -c "
import torch
ck=torch.load('/app/outputs/model.pt', weights_only=True)
print('keys:', sorted(ck))
for k in ['feat_mean','feat_std','label_mean','label_std']:
    print(f'  {k}: {ck[k].tolist()}')
print('state_dict tensors:', len(ck['state_dict']))
print('total params:', sum(v.numel() for v in ck['state_dict'].values()))
"