airfrans-high-reynolds-drag-extrapolation

cd /app && ls -la && echo "---- CONFIG ----" && cat task_config.json && echo "---- 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 && python3 -c "
import torch
for split in ['train','val','public_test']:
    p = torch.load(f'data/{split}/split.pt', weights_only=True)
    print(f'==== {split} ====')
    print('keys:', list(p.keys()))
    print('points shape/dtype:', p['points'].shape, p['points'].dtype)
    if 'targets' in p:
        print('targets shape/dtype:', p['targets'].shape, p['targets'].dtype)
"

cd /app && python3 -c "
import torch
tr = torch.load('data/train/split.pt', weights_only=True)
va = torch.load('data/val/split.pt', weights_only=True)
pt = torch.load('data/public_test/split.pt', weights_only=True)

def stats(name, pts):
    # channels: x, y, inlet_velocity, angle_of_attack
    ch = pts.reshape(-1,4)
    names=['x','y','vel','aoa']
    print(f'--- {name} per-channel (over all points) ---')
    for i,n in enumerate(names):
        c = ch[:,i]
        print(f'  {n:4s}: min={c.min():.4f} max={c.max():.4f} mean={c.mean():.4f} std={c.std():.4f}')

stats('train', tr['points'])
stats('val', va['points'])
stats('public_test', pt['points'])
"

cd /app && python3 -c "
import torch
tr = torch.load('data/train/split.pt', weights_only=True)
pts, tg = tr['points'], tr['targets']
# verify vel & aoa constant per case
vel = pts[:,:,2]; aoa = pts[:,:,3]
print('vel per-case std max:', vel.std(dim=1).max().item())
print('aoa per-case std max:', aoa.std(dim=1).max().item())
# per-case scalar
v = vel[:,0]; a = aoa[:,0]
cd, cl = tg[:,0], tg[:,1]
print()
print('targets ranges:')
print('  C_D: min=%.5f max=%.5f mean=%.5f std=%.5f' % (cd.min(), cd.max(), cd.mean(), cd.std()))
print('  C_L: min=%.5f max=%.5f mean=%.5f std=%.5f' % (cl.min(), cl.max(), cl.mean(), cl.std()))
print()
def corr(a,b):
    a=a-a.mean(); b=b-b.mean()
    return (a*b).sum()/(a.norm()*b.norm())
print('corr(vel, C_D):', corr(v,cd).item())
print('corr(vel, C_L):', corr(v,cl).item())
print('corr(aoa, C_D):', corr(a,cd).item())
print('corr(aoa, C_L):', corr(a,cl).item())
print('corr(aoa^2, C_D):', corr(a**2,cd).item())
"

cd /app && python3 -c "
import torch, sys
print('torch', torch.__version__)
print('cuda available:', torch.cuda.is_available())
if torch.cuda.is_available():
    print('gpu:', torch.cuda.get_device_name(0))
import os; print('cpus:', os.cpu_count())
" && echo "---- velocity histograms ----" && python3 -c "
import torch, numpy as np
for s in ['train','val','public_test']:
    p=torch.load(f'data/{s}/split.pt',weights_only=True)['points']
    v=p[:,0,2].numpy()
    h,edges=np.histogram(v,bins=[30,40,50,60,70,75,80,85])
    print(f'{s:12s}', dict(zip([f'{int(edges[i])}-{int(edges[i+1])}' for i in range(len(h))],h.tolist())))
"

cd /app && python3 -c "
import torch, numpy as np
tr = torch.load('data/train/split.pt', weights_only=True)
pts=tr['points']
# Look at one case geometry
c0=pts[0]
print('case0 x range', c0[:,0].min().item(), c0[:,0].max().item())
print('case0 y range', c0[:,1].min().item(), c0[:,1].max().item())
# Are points ordered around contour? print first/last few x
print('first 8 x:', np.round(c0[:8,0].numpy(),3))
print('first 8 y:', np.round(c0[:8,1].numpy(),3))
print('last 8 x:', np.round(c0[-8:,0].numpy(),3))
# Check chord line: y at x near 0 and x near 1
import numpy as np
x=c0[:,0].numpy(); y=c0[:,1].numpy()
le=np.argmin(x); te=np.argmax(x)
print('LE point (x,y):', round(x[le],3), round(y[le],3))
print('TE point (x,y):', round(x[te],3), round(y[te],3))
print('mean y:', round(y.mean(),4))
"

cd /app && python3 -c "
import torch, numpy as np
tr = torch.load('data/train/split.pt', weights_only=True)
pts, tg = tr['points'], tr['targets']
N=pts.shape[0]
# geometry signature: sorted rounded coords
def sig(c):
    x=c[:,0].numpy(); y=c[:,1].numpy()
    idx=np.lexsort((y,x))
    return tuple(np.round(np.concatenate([x[idx],y[idx]]),4))
sigs=[sig(pts[i]) for i in range(N)]
uniq=set(sigs)
print('unique geometries:', len(uniq), 'of', N)
aoa=pts[:,0,3].numpy()
vel=pts[:,0,2].numpy()
print('unique aoa (rounded 4):', len(set(np.round(aoa,4))))
print('unique vel (rounded 3):', len(set(np.round(vel,3))))
# group by geometry, see if same geom has multiple velocities
from collections import defaultdict
g=defaultdict(list)
for i,s in enumerate(sigs): g[s].append(i)
multi=[v for v in g.values() if len(v)>1]
print('geometries appearing >1 time:', len(multi))
if multi:
    for grp in multi[:5]:
        print('  grp size',len(grp),'vels',np.round(vel[grp],1),'aoa',np.round(aoa[grp],3),'CD',np.round(tg[grp,0].numpy(),4),'CL',np.round(tg[grp,1].numpy(),3))
"

cd /app && python3 -c "
import importlib
for m in ['sklearn','numpy','scipy','pandas','matplotlib']:
    try:
        mod=importlib.import_module(m); print(m, getattr(mod,'__version__','?'))
    except Exception as e:
        print(m, 'MISSING')
"

cd /app && cat > /tmp/geom.py << 'EOF'
import torch, numpy as np

def geom_feats(pts, nbins=20):
    # pts: [N,256,4] -> geometry descriptors from x,y (unordered)
    N=pts.shape[0]
    X=pts[:,:,0].numpy(); Y=pts[:,:,1].numpy()
    feats=[]
    edges=np.linspace(0,1,nbins+1)
    for i in range(N):
        x=X[i]; y=Y[i]
        row=[]
        # thickness & camber profile per bin
        thick=[]; camber=[]
        for b in range(nbins):
            m=(x>=edges[b])&(x<edges[b+1])
            if m.sum()>=2:
                yb=y[m]
                thick.append(yb.max()-yb.min())
                camber.append((yb.max()+yb.min())/2)
            else:
                thick.append(0.0); camber.append(0.0)
        thick=np.array(thick); camber=np.array(camber)
        row.append(thick.max())            # max thickness
        row.append(edges[:-1][np.argmax(thick)]) # x of max thickness
        row.append(np.abs(camber).max())   # max |camber|
        row.append(camber.mean())          # mean camber
        row.append(camber[nbins//2])       # mid camber
        row.append(y.max()); row.append(y.min())
        row.append(y.mean()); row.append(y.std())
        feats.append(row)
    return np.array(feats)

if __name__=='__main__':
    tr=torch.load('data/train/split.pt',weights_only=True)
    pts,tg=tr['points'],tr['targets']
    G=geom_feats(pts)
    aoa=pts[:,0,3].numpy(); vel=pts[:,0,2].numpy()
    cd=tg[:,0].numpy(); cl=tg[:,1].numpy()
    # build design matrix: geometry + aoa, aoa^2, aoa*thick, velocity terms
    names=[]; cols=[]
    def add(n,c): names.append(n); cols.append(c)
    add('1',np.ones(len(cd)))
    for j in range(G.shape[1]): add(f'g{j}',G[:,j])
    add('aoa',aoa); add('aoa2',aoa**2); add('aoa3',aoa**3)
    add('aoa*maxth',aoa*G[:,0]); add('aoa*camber',aoa*G[:,3])
    # velocity features (standardized)
    vz=(vel-vel.mean())/vel.std()
    add('vel',vz); add('vel2',vz**2)
    A=np.stack(cols,1)
    # standardize columns (except intercept) for conditioning
    for target,name in [(cd,'C_D'),(cl,'C_L')]:
        coef,res,rank,sv=np.linalg.lstsq(A,target,rcond=None)
        pred=A@coef
        ss=1-((target-pred)**2).sum()/((target-target.mean())**2).sum()
        print(f'=== {name} regression R^2={ss:.4f} ===')
        # report velocity coeffs and their magnitude relative to target std
        for n in ['vel','vel2']:
            k=names.index(n); print(f'  coef[{n}]={coef[k]:.5f}')
        # partial effect: change in prediction from vel min->max holding others
        vzr=np.linspace(vz.min(),vz.max(),5)
        base=coef[names.index('vel')]*vzr+coef[names.index('vel2')]*vzr**2
        print('  vel partial effect across range:',np.round(base-base[0],5))
        print('  target std:',round(target.std(),5))
EOF
python3 /tmp/geom.py

cd /app && cat > /tmp/exp.py << 'EOF'
import os, sys, json, time, math
import numpy as np, torch, torch.nn.functional as F
sys.path.insert(0,'/app')
from candidate_model import build_model
CFG=json.load(open('/app/task_config.json'))

def load(split):
    p=torch.load(f'/app/data/{split}/split.pt',weights_only=True)
    return p['points'].float(), (p['targets'].float() if 'targets' in p else None)

def standardize_stats(x):
    flat=x.reshape(-1,x.shape[-1])
    return flat.mean(0), flat.std(0).clamp_min(1e-8)

def nrmse(pred,true):
    # per-target rmse / std(true); returns (cd, cl, mean)
    rmse=torch.sqrt(((pred-true)**2).mean(0))
    std=true.std(0).clamp_min(1e-12)
    n=rmse/std
    return n[0].item(), n[1].item(), n.mean().item()

def metrics(pred,true):
    cd_n,cl_n,mn=nrmse(pred,true)
    cd_mae=(pred[:,0]-true[:,0]).abs().mean().item()
    cd_nmae=cd_mae/true[:,0].abs().mean().item()
    raw_cd=torch.sqrt(((pred[:,0]-true[:,0])**2).mean()).item()
    raw_cl=torch.sqrt(((pred[:,1]-true[:,1])**2).mean()).item()
    return dict(cd_nrmse=cd_n,cl_nrmse=cl_n,mean_nrmse=mn,worst_nrmse=max(cd_n,cl_n),
                cd_nmae=cd_nmae,rmse_cd=raw_cd,rmse_cl=raw_cl)

def train_model(xtr,ytr,cfg,feat_mean,feat_std,targ_mean,targ_std,seed=0,verbose=False):
    torch.manual_seed(seed); np.random.seed(seed)
    model=build_model(CFG)
    ep=cfg.get('epochs',120); bs=cfg.get('bs',32)
    lr=cfg.get('lr',1e-3); wd=cfg.get('wd',1e-4)
    opt=torch.optim.Adam(model.parameters(),lr=lr,weight_decay=wd)
    sched=torch.optim.lr_scheduler.CosineAnnealingLR(opt,T_max=ep)
    n=xtr.shape[0]
    fm=feat_mean.view(1,1,-1); fs=feat_std.view(1,1,-1)
    tm=targ_mean.view(1,-1); ts=targ_std.view(1,-1)
    jit=cfg.get('jitter',0.0); vel_aug=cfg.get('vel_aug',None)
    wcd=cfg.get('wcd',1.0); wcl=cfg.get('wcl',1.0)
    loss_type=cfg.get('loss','mse')
    slope=cfg.get('cd_slope',0.0)  # physical dC_D/dvel (raw units per m/s)
    swa=cfg.get('swa',False); swa_start=int(ep*0.75)
    swa_state=None; swa_n=0
    for e in range(ep):
        model.train()
        perm=torch.randperm(n)
        for s in range(0,n,bs):
            idx=perm[s:s+bs]
            xb=xtr[idx].clone(); yb=ytr[idx].clone()  # raw units
            # ---- augmentation in RAW space ----
            if jit>0:
                xb[:,:,:2]+=torch.randn_like(xb[:,:,:2])*jit
            if vel_aug is not None:
                mode,lo,hi=vel_aug
                B=xb.shape[0]
                newv=torch.empty(B).uniform_(lo,hi)
                oldv=xb[:,0,2].clone()
                xb[:,:,2]=newv.view(-1,1)
                if mode=='physics':
                    yb[:,0]=yb[:,0]+slope*(newv-oldv)  # adjust C_D
                # mode=='invariant' -> keep targets
            # standardize
            xs=(xb-fm)/fs
            ys=(yb-tm)/ts
            opt.zero_grad(set_to_none=True)
            out=model(xs)
            diff=out-ys
            if loss_type=='huber':
                d=0.01
                per=torch.where(diff.abs()<d,0.5*diff**2/d,diff.abs()-0.5*d)
            else:
                per=diff**2
            loss=(wcd*per[:,0]+wcl*per[:,1]).mean()
            loss.backward(); opt.step()
        sched.step()
        if swa and e>=swa_start:
            with torch.no_grad():
                sd={k:v.detach().clone() for k,v in model.state_dict().items()}
                if swa_state is None:
                    swa_state=sd; swa_n=1
                else:
                    swa_n+=1
                    for k in swa_state:
                        if swa_state[k].dtype.is_floating_point:
                            swa_state[k]+=(sd[k]-swa_state[k])/swa_n
    if swa and swa_state is not None:
        model.load_state_dict(swa_state)
        # recompute BN stats
        model.train()
        with torch.no_grad():
            for s in range(0,n,bs):
                xb=xtr[s:s+bs]; xs=(xb-fm)/fs; model(xs)
    model.eval()
    return model

def predict(model,x,feat_mean,feat_std,targ_mea
…[truncated]

cd /app && python3 -c "
import torch,numpy as np
pts=torch.load('data/train/split.pt',weights_only=True)['points']
v=pts[:,0,2].numpy()
for t in [62,64,66,68]:
    print(f'thresh {t}: train(<{t})={int((v<t).sum())}  heldout(>= {t})={int((v>=t).sum())}  heldout vel range [{v[v>=t].min():.1f},{v[v>=t].max():.1f}]')
"

cd /app && cat > /tmp/run1.py << 'EOF'
import sys,time,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope

pts,tg=load('train')
v=pts[:,0,2]
thr=64.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]
xte,yte=pts[tem],tg[tem]
# hardest sub-region: highest velocities
hardm=v[tem]>=70
print(f'train={xtr.shape[0]} heldout={xte.shape[0]} hardest(>=70)={int(hardm.sum())}')

feat_mean,feat_std=standardize_stats(xtr)
targ_mean=ytr.mean(0); targ_std=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
print('estimated C_D slope per m/s:',slope)

def evalcfg(name,cfg,seeds=(0,1,2)):
    accs=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,feat_mean,feat_std,targ_mean,targ_std,seed=sd)
        pred=predict(m,xte,feat_mean,feat_std,targ_mean,targ_std)
        accs.append(metrics(pred,yte))
    # average
    avg={k:float(np.mean([a[k] for a in accs])) for k in accs[0]}
    print(f'{name:22s} mean_nrmse={avg[\"mean_nrmse\"]:.4f} cd_nrmse={avg[\"cd_nrmse\"]:.4f} cl_nrmse={avg[\"cl_nrmse\"]:.4f} cd_nmae={avg[\"cd_nmae\"]:.4f} rmse_cd={avg[\"rmse_cd\"]:.5f}')
    return avg

base={'epochs':120,'bs':32,'lr':1e-3,'wd':1e-4}
t0=time.time()
evalcfg('baseline',base)
print('one config (3 seeds) took %.1fs'%(time.time()-t0))
evalcfg('jitter0.005',{**base,'jitter':0.005})
evalcfg('vel_invariant',{**base,'vel_aug':('invariant',30,90)})
evalcfg('vel_physics',{**base,'vel_aug':('physics',30,90),'cd_slope':slope})
EOF
time python3 /tmp/run1.py

cd /app && sed -i "s/print(f'{name:22s} mean_nrmse.*$/pr=avg; print('%-22s mean_nrmse=%.4f cd_nrmse=%.4f cl_nrmse=%.4f cd_nmae=%.4f rmse_cd=%.5f'%(name,pr['mean_nrmse'],pr['cd_nrmse'],pr['cl_nrmse'],pr['cd_nmae'],pr['rmse_cd']))/" /tmp/run1.py
time python3 /tmp/run1.py

restart: true

cd /app && cat > /tmp/bench.py << 'EOF'
import sys,time; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics
pts,tg=load('train')
v=pts[:,0,2]; trm=v<64; xtr,ytr=pts[trm],tg[trm]
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
for ep in [40]:
    t0=time.time()
    m=train_model(xtr,ytr,{'epochs':ep,'bs':32,'lr':1e-3,'wd':1e-4},fm,fs,tm,ts,seed=0)
    print('epochs=%d took %.1fs (%.2fs/epoch)'%(ep,time.time()-t0,(time.time()-t0)/ep))
EOF
nohup python3 /tmp/bench.py > /tmp/bench.log 2>&1 &
echo "started pid $!"

sleep 45 && cat /tmp/bench.log

cd /app && cat > /tmp/bench2.py << 'EOF'
import sys,time; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch
from exp import load,standardize_stats,train_model
pts,tg=load('train')
v=pts[:,0,2]; trm=v<64; xtr,ytr=pts[trm],tg[trm]
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
for nt,bs in [(4,64),(8,64),(16,64),(8,128)]:
    torch.set_num_threads(nt)
    t0=time.time()
    m=train_model(xtr,ytr,{'epochs':20,'bs':bs,'lr':1e-3,'wd':1e-4},fm,fs,tm,ts,seed=0)
    print('threads=%d bs=%d: %.2fs/epoch'%(nt,bs,(time.time()-t0)/20))
EOF
nohup python3 /tmp/bench2.py > /tmp/bench2.log 2>&1 &
echo started

sleep 60 && cat /tmp/bench2.log

cd /app && cat > /tmp/run1.py << 'EOF'
import sys,time,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope

pts,tg=load('train')
v=pts[:,0,2]; thr=64.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
vte=v[tem]; hardm=vte>=70
feat_mean,feat_std=standardize_stats(xtr)
targ_mean=ytr.mean(0); targ_std=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)

results={}
def log(s):
    open('/tmp/run1.log','a').write(s+'\n')
log('train=%d heldout=%d hard=%d slope=%.2e'%(xtr.shape[0],xte.shape[0],int(hardm.sum()),slope))

def evalcfg(name,cfg,fm=None,seeds=(0,1)):
    fmm=feat_mean if fm is None else fm
    accs=[];accsh=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fmm,feat_std,targ_mean,targ_std,seed=sd)
        pred=predict(m,xte,fmm,feat_std,targ_mean,targ_std)
        accs.append(metrics(pred,yte))
        accsh.append(metrics(pred[hardm],yte[hardm]))
    avg={k:float(np.mean([a[k] for a in accs])) for k in accs[0]}
    avgh={k:float(np.mean([a[k] for a in accsh])) for k in accsh[0]}
    results[name]={'all':avg,'hard':avgh}
    json.dump(results,open('/tmp/run1_results.json','w'),indent=1)
    log('%-20s | ALL mean=%.4f cd=%.4f cl=%.4f nmae=%.4f | HARD mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(
        name,avg['mean_nrmse'],avg['cd_nrmse'],avg['cl_nrmse'],avg['cd_nmae'],
        avgh['mean_nrmse'],avgh['cd_nrmse'],avgh['cl_nrmse'],avgh['cd_nmae']))

base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4}
evalcfg('baseline',base)
# kill velocity via huge std
fm_kill=feat_mean.clone()
fs=feat_std  # note std still used; set huge std on vel channel
feat_std_kill=feat_std.clone(); feat_std_kill[2]=1e6
evalcfg('vel_killed',base,fm=feat_mean)  # placeholder to keep order
# proper killed: temporarily swap
def evalcfg_killed():
    accs=[];accsh=[]
    for sd in (0,1):
        m=train_model(xtr,ytr,base,feat_mean,feat_std_kill,targ_mean,targ_std,seed=sd)
        pred=predict(m,xte,feat_mean,feat_std_kill,targ_mean,targ_std)
        accs.append(metrics(pred,yte)); accsh.append(metrics(pred[hardm],yte[hardm]))
    avg={k:float(np.mean([a[k] for a in accs])) for k in accs[0]}
    avgh={k:float(np.mean([a[k] for a in accsh])) for k in accsh[0]}
    results['vel_killed']={'all':avg,'hard':avgh}; json.dump(results,open('/tmp/run1_results.json','w'),indent=1)
    log('%-20s | ALL mean=%.4f cd=%.4f cl=%.4f nmae=%.4f | HARD mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(
        'vel_killed',avg['mean_nrmse'],avg['cd_nrmse'],avg['cl_nrmse'],avg['cd_nmae'],
        avgh['mean_nrmse'],avgh['cd_nrmse'],avgh['cl_nrmse'],avgh['cd_nmae']))
evalcfg_killed()
evalcfg('vel_invariant',{**base,'vel_aug':('invariant',30,90)})
evalcfg('vel_physics',{**base,'vel_aug':('physics',30,90),'cd_slope':slope})
evalcfg('jitter',{**base,'jitter':0.004})
log('DONE')
EOF
rm -f /tmp/run1.log /tmp/run1_results.json
nohup python3 /tmp/run1.py > /tmp/run1.stdout 2>&1 &
echo "started pid $!"

kill 600 2>/dev/null; cd /app && sed -i "/placeholder to keep order/d" /tmp/run1.py && rm -f /tmp/run1.log /tmp/run1_results.json /tmp/run1.stdout
nohup python3 /tmp/run1.py > /tmp/run1.stdout 2>&1 &
echo "restarted pid $!"

sleep 180 && echo "=== log ===" && cat /tmp/run1.log 2>/dev/null; echo "=== stdout tail ==="; tail -3 /tmp/run1.stdout 2>/dev/null

sleep 210 && cat /tmp/run1.log 2>/dev/null

sleep 150 && cat /tmp/run1.log 2>/dev/null

command: str_replace
path: /tmp/exp.py
old_str:             if vel_aug is not None:
                mode,lo,hi=vel_aug
                B=xb.shape[0]
                newv=torch.empty(B).uniform_(lo,hi)
                oldv=xb[:,0,2].clone()
                xb[:,:,2]=newv.view(-1,1)
                if mode=='physics':
                    yb[:,0]=yb[:,0]+slope*(newv-oldv)  # adjust C_D
                # mode=='invariant' -> keep targets
new_str:             if vel_aug is not None:
                B=xb.shape[0]
                oldv=xb[:,0,2].clone()
                if isinstance(vel_aug,dict):
                    p=vel_aug.get('p',1.0)
                    if vel_aug['kind']=='band':
                        newv=torch.empty(B).uniform_(vel_aug['lo'],vel_aug['hi'])
                    else:  # local: delta around oldv
                        newv=oldv+torch.empty(B).uniform_(vel_aug['dlo'],vel_aug['dhi'])
                        newv=newv.clamp(vel_aug.get('clo',28.0),vel_aug.get('chi',95.0))
                    mask=(torch.rand(B)<p).float()
                    newv=mask*newv+(1-mask)*oldv
                    use_slope=vel_aug.get('slope',slope) if vel_aug.get('physics',True) else 0.0
                    xb[:,:,2]=newv.view(-1,1)
                    yb[:,0]=yb[:,0]+use_slope*(newv-oldv)
                else:
                    mode,lo,hi=vel_aug
                    newv=torch.empty(B).uniform_(lo,hi)
                    xb[:,:,2]=newv.view(-1,1)
                    if mode=='physics':
                        yb[:,0]=yb[:,0]+slope*(newv-oldv)

cd /app && cat > /tmp/run2.py << 'EOF'
import sys,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train'); v=pts[:,0,2]; thr=64.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
hardm=v[tem]>=70
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
results={}
def log(s): open('/tmp/run2.log','a').write(s+'\n')
def ev(name,cfg,seeds=(0,1,2)):
    A=[];H=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); A.append(metrics(pr,yte)); H.append(metrics(pr[hardm],yte[hardm]))
    a={k:float(np.mean([x[k] for x in A])) for k in A[0]}; h={k:float(np.mean([x[k] for x in H])) for k in H[0]}
    results[name]={'all':a,'hard':h}; json.dump(results,open('/tmp/run2_results.json','w'),indent=1)
    log('%-22s | ALL mean=%.4f cd=%.4f cl=%.4f nmae=%.4f | HARD mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(
        name,a['mean_nrmse'],a['cd_nrmse'],a['cl_nrmse'],a['cd_nmae'],h['mean_nrmse'],h['cd_nrmse'],h['cl_nrmse'],h['cd_nmae']))
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope}
log('slope=%.3e'%slope)
ev('baseline',base)
ev('phys_band_p0.5',{**base,'vel_aug':{'kind':'band','lo':35,'hi':90,'p':0.5,'physics':True}})
ev('phys_band_p0.7',{**base,'vel_aug':{'kind':'band','lo':35,'hi':90,'p':0.7,'physics':True}})
ev('phys_local_p1',{**base,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':1.0,'physics':True}})
ev('phys_local_p0.5+jit',{**base,'jitter':0.004,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':0.5,'physics':True}})
ev('phys_band_p0.5+jit',{**base,'jitter':0.004,'vel_aug':{'kind':'band','lo':35,'hi':90,'p':0.5,'physics':True}})
log('DONE')
EOF
rm -f /tmp/run2.log /tmp/run2_results.json
nohup python3 /tmp/run2.py > /tmp/run2.stdout 2>&1 &
echo "started pid $!"

sleep 280 && cat /tmp/run2.log 2>/dev/null; echo '---'; tail -2 /tmp/run2.stdout

sleep 290 && cat /tmp/run2.log 2>/dev/null

sleep 150 && cat /tmp/run2.log 2>/dev/null

cd /app && cat > /tmp/run3.py << 'EOF'
import sys,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train'); v=pts[:,0,2]; thr=62.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
hardm=v[tem]>=68; xhardm=v[tem]>=71
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
results={}
def log(s): open('/tmp/run3.log','a').write(s+'\n')
def ev(name,cfg,seeds=(0,1)):
    H=[];X=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); H.append(metrics(pr[hardm],yte[hardm])); X.append(metrics(pr[xhardm],yte[xhardm]))
    h={k:float(np.mean([x[k] for x in H])) for k in H[0]}; xh={k:float(np.mean([x[k] for x in X])) for k in X[0]}
    results[name]={'hard':h,'xhard':xh}; json.dump(results,open('/tmp/run3_results.json','w'),indent=1)
    log('%-20s | HARD mean=%.4f cd=%.4f cl=%.4f nmae=%.4f | XHARD mean=%.4f cd=%.4f cl=%.4f'%(
        name,h['mean_nrmse'],h['cd_nrmse'],h['cl_nrmse'],h['cd_nmae'],xh['mean_nrmse'],xh['cd_nrmse'],xh['cl_nrmse']))
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope}
log('thr=62 nhard=%d nxhard=%d slope=%.3e'%(int(hardm.sum()),int(xhardm.sum()),slope))
ev('baseline',base)
ev('local_p1_s1.0',{**base,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':1.0}})
ev('local_p1_invariant',{**base,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':1.0,'physics':False}})
ev('local_p1_s1.5',{**base,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':1.0,'slope':slope*1.5}})
ev('local_p1_dhi30',{**base,'vel_aug':{'kind':'local','dlo':-8,'dhi':30,'p':1.0}})
ev('local_p0.8_dhi25',{**base,'vel_aug':{'kind':'local','dlo':-8,'dhi':25,'p':0.8}})
log('DONE')
EOF
rm -f /tmp/run3.log /tmp/run3_results.json
nohup python3 /tmp/run3.py > /tmp/run3.stdout 2>&1 &
echo "started pid $!"

sleep 280 && cat /tmp/run3.log 2>/dev/null

sleep 200 && cat /tmp/run3.log 2>/dev/null

cd /app && cat > /tmp/run4.py << 'EOF'
import sys,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train'); v=pts[:,0,2]; thr=63.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
hardm=v[tem]>=69; xhardm=v[tem]>=71
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
results={}
def log(s): open('/tmp/run4.log','a').write(s+'\n')
def ev(name,cfg,seeds=(0,1,2)):
    H=[];X=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); H.append(metrics(pr[hardm],yte[hardm])); X.append(metrics(pr[xhardm],yte[xhardm]))
    h={k:float(np.mean([x[k] for x in H])) for k in H[0]}; xh={k:float(np.mean([x[k] for x in X])) for k in X[0]}
    results[name]={'hard':h,'xhard':xh}; json.dump(results,open('/tmp/run4_results.json','w'),indent=1)
    log('%-18s | HARD mean=%.4f cd=%.4f cl=%.4f | XHARD mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(
        name,h['mean_nrmse'],h['cd_nrmse'],h['cl_nrmse'],xh['mean_nrmse'],xh['cd_nrmse'],xh['cl_nrmse'],xh['cd_nmae']))
VA={'kind':'local','dlo':-8,'dhi':20,'p':1.0}
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope}
log('thr=63 nhard=%d nxhard=%d slope=%.3e'%(int(hardm.sum()),int(xhardm.sum()),slope))
ev('local_p1',{**base,'vel_aug':VA})
ev('local_huber',{**base,'vel_aug':VA,'loss':'huber'})
ev('local_swa',{**base,'epochs':140,'vel_aug':VA,'swa':True})
ev('local_ep160',{**base,'epochs':160,'vel_aug':VA})
ev('local_s0.85',{**base,'vel_aug':{**VA},'cd_slope':slope*0.85})
ev('local_jit003',{**base,'vel_aug':VA,'jitter':0.003})
log('DONE')
EOF
rm -f /tmp/run4.log /tmp/run4_results.json
nohup python3 /tmp/run4.py > /tmp/run4.stdout 2>&1 &
echo "started pid $!"

sleep 60 && cat /tmp/run4.log 2>/dev/null; echo '(partial)'

command: create
path: /app/final_train.py
file_text: """Final trainer for the airfoil force-coefficient PointNet.

Key idea (see notes): the scored cases live at higher inlet velocity / Reynolds
than training. Physically, C_L is essentially velocity-independent while C_D has
a mild, monotonic decreasing dependence on velocity (Reynolds drag reduction).
We therefore train with a physics-based velocity augmentation: each sample's
inlet velocity is randomly perturbed (biased upward, beyond the test range) and
C_D is shifted by an estimated linear Reynolds slope while C_L is held fixed.
This simultaneously (a) teaches C_L to ignore velocity -> robust extrapolation,
and (b) teaches C_D the correct velocity trend and extends it past the training
ceiling. The architecture and checkpoint contract are unchanged.
"""
from __future__ import annotations
import json, os, sys
from pathlib import Path
import numpy as np, torch, torch.nn.functional as F

APP_DIR = Path(os.environ.get("APP_DIR", "/app"))
sys.path.insert(0, str(APP_DIR))
from candidate_model import build_model
from dataset import load_split

CFG = json.load((APP_DIR / "task_config.json").open())


def estimate_cd_slope(points, cd):
    """Partial slope d(C_D)/d(velocity) controlling for geometry + AoA."""
    X = points[:, :, 0].numpy(); Y = points[:, :, 1].numpy(); N = points.shape[0]
    nb = 12; edges = np.linspace(0, 1, nb + 1); G = []
    for i in range(N):
        x = X[i]; y = Y[i]; th = []
        for b in range(nb):
            m = (x >= edges[b]) & (x < edges[b + 1])
            th.append((y[m].max() - y[m].min()) if m.sum() >= 2 else 0.0)
        G.append(th)
    G = np.array(G)
    aoa = points[:, 0, 3].numpy(); vel = points[:, 0, 2].numpy(); cdn = cd.numpy()
    cols = [np.ones(N)] + [G[:, j] for j in range(nb)] + [aoa, aoa ** 2, aoa ** 3, aoa * G[:, 2], vel]
    A = np.stack(cols, 1)
    coef, *_ = np.linalg.lstsq(A, cdn, rcond=None)
    return float(coef[-1])


def train(points, targets, *, epochs=150, bs=64, lr=1e-3, wd=1e-4, seed=0,
          dlo=-8.0, dhi=20.0, p=1.0, clo=28.0, chi=98.0, swa=True, swa_frac=0.7,
          slope=None, verbose=True):
    torch.manual_seed(seed); np.random.seed(seed)
    fm, fs = _coord_stats(points)
    tm = targets.mean(0); ts = targets.std(0).clamp_min(1e-8)
    if slope is None:
        slope = estimate_cd_slope(points, targets[:, 0])
    model = build_model(CFG)
    opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=epochs)
    n = points.shape[0]
    fmv = fm.view(1, 1, -1); fsv = fs.view(1, 1, -1); tmv = tm.view(1, -1); tsv = ts.view(1, -1)
    swa_start = int(epochs * swa_frac); swa_state = None; swa_n = 0
    for e in range(epochs):
        model.train(); perm = torch.randperm(n)
        for s in range(0, n, bs):
            idx = perm[s:s + bs]
            xb = points[idx].clone(); yb = targets[idx].clone()
            B = xb.shape[0]; oldv = xb[:, 0, 2].clone()
            newv = (oldv + torch.empty(B).uniform_(dlo, dhi)).clamp(clo, chi)
            mask = (torch.rand(B) < p).float()
            newv = mask * newv + (1 - mask) * oldv
            xb[:, :, 2] = newv.view(-1, 1)
            yb[:, 0] = yb[:, 0] + slope * (newv - oldv)
            xs = (xb - fmv) / fsv; ys = (yb - tmv) / tsv
            opt.zero_grad(set_to_none=True)
            loss = F.mse_loss(model(xs), ys)
            loss.backward(); opt.step()
        sched.step()
        if swa and e >= swa_start:
            sd = {k: v.detach().clone() for k, v in model.state_dict().items()}
            if swa_state is None:
                swa_state = sd; swa_n = 1
            else:
                swa_n += 1
                for k in swa_state:
                    if swa_state[k].dtype.is_floating_point:
                        swa_state[k] += (sd[k] - swa_state[k]) / swa_n
    if swa and swa_state is not None:
        model.load_state_dict(swa_state)
        model.train()
        wi
…[truncated]

sleep 230 && cat /tmp/run4.log 2>/dev/null

sleep 240 && cat /tmp/run4.log 2>/dev/null

sleep 240 && cat /tmp/run4.log 2>/dev/null

sleep 180 && cat /tmp/run4.log 2>/dev/null

cd /app && sed -i "s/                d=0.01/                d=cfg.get('huber_delta',0.01)/" /tmp/exp.py && grep -n "huber_delta" /tmp/exp.py

cd /app && cat > /tmp/run5.py << 'EOF'
import sys,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train'); v=pts[:,0,2]; thr=62.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
hardm=v[tem]>=68; xhardm=v[tem]>=71
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
results={}
def log(s): open('/tmp/run5.log','a').write(s+'\n')
def ev(name,cfg,seeds=(0,1,2)):
    H=[];X=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); H.append(metrics(pr[hardm],yte[hardm])); X.append(metrics(pr[xhardm],yte[xhardm]))
    h={k:float(np.mean([x[k] for x in H])) for k in H[0]}; xh={k:float(np.mean([x[k] for x in X])) for k in X[0]}
    results[name]={'hard':h,'xhard':xh}; json.dump(results,open('/tmp/run5_results.json','w'),indent=1)
    log('%-20s | HARD mean=%.4f cd=%.4f cl=%.4f | XHARD mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(
        name,h['mean_nrmse'],h['cd_nrmse'],h['cl_nrmse'],xh['mean_nrmse'],xh['cd_nrmse'],xh['cl_nrmse'],xh['cd_nmae']))
VA={'kind':'local','dlo':-8,'dhi':20,'p':1.0}
base={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'vel_aug':VA,'swa':True}
log('thr=62 nhard=%d nxhard=%d slope=%.3e'%(int(hardm.sum()),int(xhardm.sum()),slope))
ev('mse_swa',{**base})
ev('mae_swa',{**base,'loss':'huber','huber_delta':0.01})
ev('huber0.3_swa',{**base,'loss':'huber','huber_delta':0.3})
ev('huber0.6_swa',{**base,'loss':'huber','huber_delta':0.6})
log('DONE')
EOF
rm -f /tmp/run5.log /tmp/run5_results.json
nohup python3 /tmp/run5.py > /tmp/run5.stdout 2>&1 &
echo "started pid $!"

cd /app && NT=2 python3 -c "
import sys; sys.path.insert(0,'/app')
import torch
torch.set_num_threads(2)
from final_train import train, estimate_cd_slope
from dataset import load_split
pts,tg=load_split('/app/data/train')
s=estimate_cd_slope(pts[:200], tg[:200,0]); print('slope(sample)=',round(s,7))
m,fm,fs,tm,ts,slope=train(pts[:120],tg[:120],epochs=3,swa=True,swa_frac=0.34,verbose=False)
print('smoke ok; slope=',round(slope,7),'fm len',len(fm),'tm',tm.tolist())
import torch
print('fwd check', m((pts[:4]-fm.view(1,1,-1))/fs.view(1,1,-1)).shape)
" 2>&1 | tail -6

sleep 260 && cat /tmp/run5.log 2>/dev/null

sleep 280 && cat /tmp/run5.log 2>/dev/null

sleep 250 && cat /tmp/run5.log 2>/dev/null

cd /app && cat > /tmp/run6.py << 'EOF'
import sys,json; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train'); vpts,vtg=load('val'); v=pts[:,0,2]
def log(s): open('/tmp/run6.log','a').write(s+'\n'); 
# ---- (A) threshold 64 extrapolation confirm ----
thr=64.0; trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
xh=v[tem]>=70
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
VA={'kind':'local','dlo':-8,'dhi':20,'p':1.0}
final={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'vel_aug':VA,'swa':True,'loss':'huber','huber_delta':0.01}
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4}
def run(name,cfg,XtrI,YtrI,FM,FS,TM,TS,Xev,Yev,mask,seeds=(0,1)):
    R=[]
    for sd in seeds:
        m=train_model(XtrI,YtrI,cfg,FM,FS,TM,TS,seed=sd)
        pr=predict(m,Xev,FM,FS,TM,TS); R.append(metrics(pr[mask],Yev[mask]))
    a={k:float(np.mean([x[k] for x in R])) for k in R[0]}
    log('%-22s | mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(name,a['mean_nrmse'],a['cd_nrmse'],a['cl_nrmse'],a['cd_nmae']))
log('== thr64 XHARD(vel>=70, n=%d) slope=%.3e =='%(int(xh.sum()),slope))
run('final_extrap',final,xtr,ytr,fm,fs,tm,ts,xte,yte,xh)
run('baseline_extrap',base,xtr,ytr,fm,fs,tm,ts,xte,yte,xh)
# ---- (B) in-distribution: train on full train, eval on real val ----
fmF,fsF=standardize_stats(pts); tmF=tg.mean(0); tsF=tg.std(0).clamp_min(1e-8)
slopeF=estimate_cd_slope(pts,tg[:,0])
finalF={**final,'cd_slope':slopeF}
allmask=torch.ones(vtg.shape[0],dtype=torch.bool)
log('== in-distribution real val (n=%d) slope=%.3e =='%(vtg.shape[0],slopeF))
run('final_val',finalF,pts,tg,fmF,fsF,tmF,tsF,vpts,vtg,allmask)
run('baseline_val',base,pts,tg,fmF,fsF,tmF,tsF,vpts,vtg,allmask)
log('DONE')
EOF
rm -f /tmp/run6.log
nohup python3 /tmp/run6.py > /tmp/run6.stdout 2>&1 &
echo "started pid $!"

sleep 290 && cat /tmp/run6.log 2>/dev/null

sleep 150 && cat /tmp/run6.log 2>/dev/null

sleep 180 && cat /tmp/run6.log 2>/dev/null

sleep 120 && cat /tmp/run6.log 2>/dev/null; echo '--- stdout ---'; tail -3 /tmp/run6.stdout

cd /app && cat > /tmp/run6b.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train'); vpts,vtg=load('val')
def log(s): open('/tmp/run6.log','a').write(s+'\n')
fmF,fsF=standardize_stats(pts); tmF=tg.mean(0); tsF=tg.std(0).clamp_min(1e-8)
slopeF=estimate_cd_slope(pts,tg)  # fixed: pass 2D targets
VA={'kind':'local','dlo':-8,'dhi':20,'p':1.0}
final={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slopeF,'vel_aug':VA,'swa':True,'loss':'huber','huber_delta':0.01}
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4}
am=torch.ones(vtg.shape[0],dtype=torch.bool)
def run(name,cfg,seeds=(0,1)):
    R=[]
    for sd in seeds:
        m=train_model(pts,tg,cfg,fmF,fsF,tmF,tsF,seed=sd)
        pr=predict(m,vpts,fmF,fsF,tmF,tsF); R.append(metrics(pr,vtg))
    a={k:float(np.mean([x[k] for x in R])) for k in R[0]}
    log('%-22s | mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(name,a['mean_nrmse'],a['cd_nrmse'],a['cl_nrmse'],a['cd_nmae']))
log('== in-distribution real val (n=%d) slope=%.3e =='%(vtg.shape[0],slopeF))
run('final_val',final); run('baseline_val',base)
log('DONE-B')
EOF
nohup python3 /tmp/run6b.py > /tmp/run6b.stdout 2>&1 &
echo "started pid $!"

sleep 260 && cat /tmp/run6.log 2>/dev/null

sleep 90 && cat /tmp/run6.log 2>/dev/null | tail -3

command: str_replace
path: /app/final_train.py
old_str:             xs = (xb - fmv) / fsv; ys = (yb - tmv) / tsv
            opt.zero_grad(set_to_none=True)
            loss = F.mse_loss(model(xs), ys)
            loss.backward(); opt.step()
new_str:             xs = (xb - fmv) / fsv; ys = (yb - tmv) / tsv
            opt.zero_grad(set_to_none=True)
            # MAE-like (Huber with tiny beta) on standardized targets: robust to
            # C_D's right-skewed high-drag outliers, which improves extrapolation.
            loss = F.smooth_l1_loss(model(xs), ys, beta=0.01)
            loss.backward(); opt.step()

cd /app && rm -f outputs/model.pt && NT=8 SEED=0 nohup python3 final_train.py > /tmp/final.log 2>&1 &
echo "started pid $!"

sleep 150 && cat /tmp/final.log 2>/dev/null; echo '---'; ls -la /app/outputs/ 2>/dev/null

cd /app && python3 -c "
import json,torch,sys; sys.path.insert(0,'/app')
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
ck=torch.load('outputs/model.pt',weights_only=True)
print('keys:',sorted(ck.keys()))
for k in ['feat_mean','feat_std','targ_mean','targ_std']:
    t=ck[k]; print(f'  {k}: shape={tuple(t.shape)} dtype={t.dtype} vals={[round(x,5) for x in t.tolist()]}')
# strict load into fresh model
m=build_model(cfg)
missing=m.load_state_dict(ck['state_dict'],strict=True)
print('load_state_dict strict OK:',missing)
m.eval()
# grader-style inference on public_test
pts=torch.load('data/public_test/split.pt',weights_only=True)['points'].float()
fm=ck['feat_mean'].view(1,1,-1); fs=ck['feat_std'].view(1,1,-1)
with torch.no_grad():
    out=m((pts-fm)/fs)
pred=out*ck['targ_std'].view(1,-1)+ck['targ_mean'].view(1,-1)
cd,cl=pred[:,0],pred[:,1]
print()
print('public_test predictions:')
print('  C_D: min=%.5f max=%.5f mean=%.5f  (train C_D mean ~0.0128)'%(cd.min(),cd.max(),cd.mean()))
print('  C_L: min=%.4f max=%.4f mean=%.4f   (train C_L mean ~0.66)'%(cl.min(),cl.max(),cl.mean()))
print('  any NaN:',torch.isnan(pred).any().item(),' any negative C_D:',(cd<0).any().item())
"

cd /app && python3 -c "
import json,torch,sys; sys.path.insert(0,'/app')
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
ck=torch.load('outputs/model.pt',weights_only=True)
m=build_model(cfg); m.load_state_dict(ck['state_dict']); m.eval()
fm=ck['feat_mean'].view(1,1,-1); fs=ck['feat_std'].view(1,1,-1)
tm=ck['targ_mean'].view(1,-1); ts=ck['targ_std'].view(1,-1)
pts=torch.load('data/public_test/split.pt',weights_only=True)['points'].float()
# take 5 cases, sweep velocity 40..90, report C_D and C_L
import numpy as np
idx=[0,10,20,30,40]
vels=[40,55,70,75,80,85]
print('velocity sweep (C_D / C_L) per case:')
for i in idx:
    base=pts[i:i+1].clone()
    row=[]
    for v in vels:
        b=base.clone(); b[:,:,2]=float(v)
        with torch.no_grad(): o=m((b-fm)/fs)*ts+tm
        row.append((o[0,0].item(),o[0,1].item()))
    cds=' '.join('%.4f'%r[0] for r in row)
    cls=' '.join('%+.3f'%r[1] for r in row)
    print(f'  case{i:2d}: vels={vels}')
    print(f'          C_D= {cds}')
    print(f'          C_L= {cls}')
"

cd /app && cat > /tmp/run7.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
ptr,ttr=load('train'); pva,tva=load('val')
pts=torch.cat([ptr,pva],0); tg=torch.cat([ttr,tva],0)
v=pts[:,0,2]; thr=69.5
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
def log(s): open('/tmp/run7.log','a').write(s+'\n')
VA={'kind':'local','dlo':-8,'dhi':20,'p':1.0}
final={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'vel_aug':VA,'swa':True,'loss':'huber','huber_delta':0.01}
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4}
log('train+val pseudo: ntrain=%d ntest(vel>=%.1f)=%d slope=%.3e'%(xtr.shape[0],thr,xte.shape[0],slope))
def run(name,cfg,seeds):
    res=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); res.append(metrics(pr,yte))
    arr={k:np.array([r[k] for r in res]) for k in res[0]}
    log('%-14s seeds=%s mean_nrmse=%.4f+-%.4f cd=%.4f cl=%.4f nmae=%.4f'%(
        name,list(seeds),arr['mean_nrmse'].mean(),arr['mean_nrmse'].std(),
        arr['cd_nrmse'].mean(),arr['cl_nrmse'].mean(),arr['cd_nmae'].mean()))
run('final',final,(0,1,2))
run('baseline',base,(0,1,2))
log('DONE')
EOF
rm -f /tmp/run7.log
nohup python3 /tmp/run7.py > /tmp/run7.stdout 2>&1 &
echo "started pid $!"

sleep 290 && cat /tmp/run7.log 2>/dev/null

sleep 150 && cat /tmp/run7.log 2>/dev/null

cd /app && cat > /tmp/run8.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
ptr,ttr=load('train'); pva,tva=load('val')
pts=torch.cat([ptr,pva],0); tg=torch.cat([ttr,tva],0)
v=pts[:,0,2]; thr=69.5
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
far=v[tem]>=72.0
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
def log(s): open('/tmp/run8.log','a').write(s+'\n')
VAf=lambda p:{'kind':'local','dlo':-8,'dhi':20,'p':p}
F=lambda p:{'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'vel_aug':VAf(p),'swa':True,'loss':'huber','huber_delta':0.01}
base={'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4}
log('NEAR split ntest=%d nfar(>=72)=%d slope=%.3e'%(xte.shape[0],int(far.sum()),slope))
def run(name,cfg,seeds=(0,1)):
    A=[];Fa=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); A.append(metrics(pr,yte)); Fa.append(metrics(pr[far],yte[far]))
    a={k:float(np.mean([x[k] for x in A])) for k in A[0]}; fa={k:float(np.mean([x[k] for x in Fa])) for k in Fa[0]}
    log('%-12s | ALL mean=%.4f cd=%.4f cl=%.4f nmae=%.4f | FAR mean=%.4f cd=%.4f cl=%.4f'%(
        name,a['mean_nrmse'],a['cd_nrmse'],a['cl_nrmse'],a['cd_nmae'],fa['mean_nrmse'],fa['cd_nrmse'],fa['cl_nrmse']))
run('baseline',base); run('p1.0',F(1.0)); run('p0.7',F(0.7)); run('p0.5',F(0.5))
log('DONE')
EOF
rm -f /tmp/run8.log
nohup python3 /tmp/run8.py > /tmp/run8.stdout 2>&1 &
echo "started pid $!"

sleep 295 && cat /tmp/run8.log 2>/dev/null

sleep 260 && cat /tmp/run8.log 2>/dev/null

sleep 60 && cat /tmp/run8.log 2>/dev/null | tail -2

command: str_replace
path: /tmp/exp.py
old_str:             if vel_aug is not None:
                B=xb.shape[0]
                oldv=xb[:,0,2].clone()
                if isinstance(vel_aug,dict):
new_str:             wcd_s=None  # per-sample C_D weight (for decouple mode)
            if vel_aug is not None and vel_aug.get('decouple') if isinstance(vel_aug,dict) else False:
                B=xb.shape[0]; oldv=xb[:,0,2].clone()
                newv=(oldv+torch.empty(B).uniform_(vel_aug['dlo'],vel_aug['dhi'])).clamp(28.0,98.0)
                aug=(torch.rand(B)<vel_aug.get('p',0.5))
                newv=torch.where(aug,newv,oldv)
                xb[:,:,2]=newv.view(-1,1)
                # C_L target stays original (velocity-invariant); C_D slope-adjusted
                yb[:,0]=yb[:,0]+slope*(newv-oldv)
                w0=vel_aug.get('w_cd_aug',0.0)
                wcd_s=torch.where(aug,torch.full((B,),w0),torch.ones(B))
            elif vel_aug is not None:
                B=xb.shape[0]
                oldv=xb[:,0,2].clone()
                if isinstance(vel_aug,dict):

command: str_replace
path: /tmp/exp.py
old_str:             loss=(wcd*per[:,0]+wcl*per[:,1]).mean()
new_str:             if wcd_s is not None:
                loss=(wcd*wcd_s*per[:,0]+wcl*per[:,1]).mean()
            else:
                loss=(wcd*per[:,0]+wcl*per[:,1]).mean()

command: str_replace
path: /tmp/exp.py
old_str:             wcd_s=None  # per-sample C_D weight (for decouple mode)
            if vel_aug is not None and vel_aug.get('decouple') if isinstance(vel_aug,dict) else False:
new_str:             wcd_s=None  # per-sample C_D weight (for decouple mode)
            _decouple=isinstance(vel_aug,dict) and vel_aug.get('decouple',False)
            if _decouple:

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch; torch.set_num_threads(2)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
p,t=load('train'); fm,fs=standardize_stats(p[:100]); tm=t[:100].mean(0); ts=t[:100].std(0).clamp_min(1e-8)
cfg={'epochs':2,'bs':64,'cd_slope':-6e-5,'vel_aug':{'decouple':True,'dlo':-8,'dhi':20,'p':0.5,'w_cd_aug':0.0},'loss':'huber','huber_delta':0.01}
m=train_model(p[:100],t[:100],cfg,fm,fs,tm,ts,seed=0)
print('decouple smoke ok', predict(m,p[:3],fm,fs,tm,ts).shape)
"

cd /app && cat > /tmp/run9.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
ptr,ttr=load('train'); pva,tva=load('val')
pts=torch.cat([ptr,pva],0); tg=torch.cat([ttr,tva],0)
v=pts[:,0,2]; thr=69.5
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
far=v[tem]>=72.0
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
def log(s): open('/tmp/run9.log','a').write(s+'\n')
com={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'swa':True,'loss':'huber','huber_delta':0.01}
def D(p,w): return {**com,'vel_aug':{'decouple':True,'dlo':-8,'dhi':20,'p':p,'w_cd_aug':w}}
def P(p): return {**com,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':p}}
log('NEAR split slope=%.3e'%slope)
def run(name,cfg,seeds=(0,1,2)):
    A=[];Fa=[]
    for sd in seeds:
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); A.append(metrics(pr,yte)); Fa.append(metrics(pr[far],yte[far]))
    a={k:float(np.mean([x[k] for x in A])) for k in A[0]}; fa={k:float(np.mean([x[k] for x in Fa])) for k in Fa[0]}
    log('%-16s | ALL mean=%.4f cd=%.4f cl=%.4f nmae=%.4f | FAR mean=%.4f cd=%.4f cl=%.4f'%(
        name,a['mean_nrmse'],a['cd_nrmse'],a['cl_nrmse'],a['cd_nmae'],fa['mean_nrmse'],fa['cd_nrmse'],fa['cl_nrmse']))
run('decouple_p.5_w0',D(0.5,0.0))
run('decouple_p.5_w.3',D(0.5,0.3))
run('decouple_p.7_w0',D(0.7,0.0))
run('local_p0.3',P(0.3))
log('DONE')
EOF
rm -f /tmp/run9.log
nohup python3 /tmp/run9.py > /tmp/run9.stdout 2>&1 &
echo "started pid $!"

sleep 295 && cat /tmp/run9.log 2>/dev/null

sleep 295 && cat /tmp/run9.log 2>/dev/null

sleep 290 && cat /tmp/run9.log 2>/dev/null

sleep 60 && cat /tmp/run9.log 2>/dev/null | tail -2
cd /app && cat > /tmp/run10.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
pts,tg=load('train')  # train-only -> lower ceiling -> longer extrapolation
v=pts[:,0,2]; thr=64.0
trm=v<thr; tem=v>=thr
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
xh=v[tem]>=70  # 6-11 beyond ceiling
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
def log(s): open('/tmp/run10.log','a').write(s+'\n')
com={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'swa':True,'loss':'huber','huber_delta':0.01}
cfgs={
 'decouple_p.5_w0':{**com,'vel_aug':{'decouple':True,'dlo':-8,'dhi':20,'p':0.5,'w_cd_aug':0.0}},
 'decouple_p.7_w0':{**com,'vel_aug':{'decouple':True,'dlo':-8,'dhi':20,'p':0.7,'w_cd_aug':0.0}},
 'phys_p1.0(old)':{**com,'vel_aug':{'kind':'local','dlo':-8,'dhi':20,'p':1.0}},
 'baseline':{'epochs':100,'bs':64,'lr':1e-3,'wd':1e-4},
}
log('thr64 FAR XHARD(vel>=70,n=%d) slope=%.3e'%(int(xh.sum()),slope))
for name,cfg in cfgs.items():
    R=[]
    for sd in (0,1,2):
        m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
        pr=predict(m,xte,fm,fs,tm,ts); R.append(metrics(pr[xh],yte[xh]))
    a={k:float(np.mean([x[k] for x in R])) for k in R[0]}
    log('%-16s | mean=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(name,a['mean_nrmse'],a['cd_nrmse'],a['cl_nrmse'],a['cd_nmae']))
log('DONE')
EOF
rm -f /tmp/run10.log
nohup python3 /tmp/run10.py > /tmp/run10.stdout 2>&1 &
echo "started guard test pid $!"

cat /tmp/run9.log 2>/dev/null

sleep 250 && echo "run9:"; tail -1 /tmp/run9.log; echo "run10:"; cat /tmp/run10.log 2>/dev/null

sleep 280 && cat /tmp/run10.log 2>/dev/null

sleep 230 && cat /tmp/run10.log 2>/dev/null

command: str_replace
path: /app/final_train.py
old_str: def train(points, targets, *, epochs=150, bs=64, lr=1e-3, wd=1e-4, seed=0,
          dlo=-8.0, dhi=20.0, p=1.0, clo=28.0, chi=98.0, swa=True, swa_frac=0.7,
          slope=None, verbose=True):
    torch.manual_seed(seed); np.random.seed(seed)
    fm, fs = _coord_stats(points)
    tm = targets.mean(0); ts = targets.std(0).clamp_min(1e-8)
    if slope is None:
        slope = estimate_cd_slope(points, targets[:, 0])
    model = build_model(CFG)
    opt = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=epochs)
    n = points.shape[0]
    fmv = fm.view(1, 1, -1); fsv = fs.view(1, 1, -1); tmv = tm.view(1, -1); tsv = ts.view(1, -1)
    swa_start = int(epochs * swa_frac); swa_state = None; swa_n = 0
    for e in range(epochs):
        model.train(); perm = torch.randperm(n)
        for s in range(0, n, bs):
            idx = perm[s:s + bs]
            xb = points[idx].clone(); yb = targets[idx].clone()
            B = xb.shape[0]; oldv = xb[:, 0, 2].clone()
            newv = (oldv + torch.empty(B).uniform_(dlo, dhi)).clamp(clo, chi)
            mask = (torch.rand(B) < p).float()
            newv = mask * newv + (1 - mask) * oldv
            xb[:, :, 2] = newv.view(-1, 1)
            yb[:, 0] = yb[:, 0] + slope * (newv - oldv)
            xs = (xb - fmv) / fsv; ys = (yb - tmv) / tsv
            opt.zero_grad(set_to_none=True)
            # MAE-like (Huber with tiny beta) on standardized targets: robust to
            # C_D's right-skewed high-drag outliers, which improves extrapolation.
            loss = F.smooth_l1_loss(model(xs), ys, beta=0.01)
            loss.backward(); opt.step()
        sched.step()
        if swa and e >= swa_start:
            sd = {k: v.detach().clone() for k, v in model.state_dict().items()}
            if swa_state is None:
                swa_state = sd; swa_n = 1
            else:
                swa_n += 1
                for k in swa_state:
                    if swa_state[k].dtype.is_floating_point:
                        swa_state[k] += (sd[k] - swa_state[k]) / swa_n
    if swa and swa_state is not None:
        model.load_state_dict(swa_state)
        model.train()
        with torch.no_grad():  # refresh BN running stats for the averaged weights
            for _ in range(3):
                for s in range(0, n, bs):
                    xb = points[s:s + bs].clone()
                    xb[:, :, 2] = (xb[:, :, 2] + torch.empty(xb.shape[0], 1).uniform_(dlo, dhi)).clamp(clo, chi)
                    model((xb - fmv) / fsv)
    model.eval()
    return model, fm, fs, tm, ts, slope
new_str: def _augment(xb, yb, *, dlo, dhi, p, clo, chi, slope, w_cd_aug):
    """Decoupled velocity augmentation.

    A fraction ``p`` of samples get their inlet velocity perturbed (biased
    upward, out past the test range). For those samples C_L is kept fixed
    (it is velocity-invariant) and their C_D loss is down-weighted to
    ``w_cd_aug`` (0 by default). Net effect: C_D is learned only from real
    velocities (so the network's own accurate, geometry-dependent Reynolds
    trend is preserved and extends past the ceiling), while C_L is taught to
    ignore velocity across the whole range -> robust high-velocity C_L.
    Returns augmented xb, yb and a per-sample C_D loss weight.
    """
    B = xb.shape[0]; oldv = xb[:, 0, 2].clone()
    aug = torch.rand(B) < p
    newv = (oldv + torch.empty(B).uniform_(dlo, dhi)).clamp(clo, chi)
    newv = torch.where(aug, newv, oldv)
    xb[:, :, 2] = newv.view(-1, 1)
    yb[:, 0] = yb[:, 0] + slope * (newv - oldv)  # only matters if w_cd_aug>0
    wcd = torch.where(aug, torch.full((B,), float(w_cd_aug)), torch.ones(B))
    return xb, yb, wcd


def train(points, targets, *, epochs=150, bs=64, lr=1e-3, wd=1e-4, seed=0,
          dlo=-8.0, dhi=20.0, p=0.5, w_cd_aug=0.0, clo=28.0, chi=98.0,
          swa=True, swa_frac=0.7, slope=None, verbose=True):

…[truncated]

command: str_replace
path: /app/final_train.py
old_str: Key idea (see notes): the scored cases live at higher inlet velocity / Reynolds
than training. Physically, C_L is essentially velocity-independent while C_D has
a mild, monotonic decreasing dependence on velocity (Reynolds drag reduction).
We therefore train with a physics-based velocity augmentation: each sample's
inlet velocity is randomly perturbed (biased upward, beyond the test range) and
C_D is shifted by an estimated linear Reynolds slope while C_L is held fixed.
This simultaneously (a) teaches C_L to ignore velocity -> robust extrapolation,
and (b) teaches C_D the correct velocity trend and extends it past the training
ceiling. The architecture and checkpoint contract are unchanged.
new_str: Key idea (see notes): the scored cases live at higher inlet velocity / Reynolds
than training. Empirically (controlling for geometry + AoA), C_L is essentially
velocity-independent, while C_D has only a mild, monotonic decreasing dependence
on velocity (Reynolds drag reduction) that the network already extrapolates well
from the real data. The failure mode of a plain fit is that C_L latches onto
velocity spuriously and then degrades badly once velocity leaves the training
range.

We fix this with a *decoupled* velocity augmentation. A fraction of samples per
batch have their inlet velocity perturbed far past the test range; for those
samples only the (velocity-invariant) C_L is supervised, while the C_D loss is
switched off. So C_D is learned purely from real-velocity samples -- preserving
the network's own accurate, geometry-dependent Reynolds trend and its smooth
extension past the ceiling -- and C_L is taught to ignore velocity everywhere,
which makes its high-velocity extrapolation robust. Combined with an MAE-like
loss (robust to C_D's high-drag outliers) and SWA, this beats a plain fit on
both coefficients in and beyond the training velocity range. The architecture
and checkpoint contract are unchanged.

cd /app && python3 -c "import ast; ast.parse(open('final_train.py').read()); print('final_train.py syntax OK')" && rm -f outputs/model.pt && NT=8 SEED=0 nohup python3 final_train.py > /tmp/final2.log 2>&1 &
echo "started final training pid $!"

sleep 180 && cat /tmp/final2.log 2>/dev/null; echo '---'; ls -la /app/outputs/model.pt 2>/dev/null

cd /app && python3 -c "
import json,torch,sys; sys.path.insert(0,'/app')
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
ck=torch.load('outputs/model.pt',weights_only=True)
assert sorted(ck)== ['feat_mean','feat_std','state_dict','targ_mean','targ_std'], sorted(ck)
for k,n in [('feat_mean',4),('feat_std',4),('targ_mean',2),('targ_std',2)]:
    t=ck[k]; assert tuple(t.shape)==(n,), (k,t.shape); assert t.dtype==torch.float32
    assert torch.isfinite(t).all() and (ck['feat_std']>0).all() and (ck['targ_std']>0).all()
m=build_model(cfg); m.load_state_dict(ck['state_dict'],strict=True); m.eval()
fm=ck['feat_mean'].view(1,1,-1); fs=ck['feat_std'].view(1,1,-1); tm=ck['targ_mean'].view(1,-1); ts=ck['targ_std'].view(1,-1)
pts=torch.load('data/public_test/split.pt',weights_only=True)['points'].float()
with torch.no_grad(): pred=m((pts-fm)/fs)*ts+tm
cd,cl=pred[:,0],pred[:,1]
print('ALL CHECKS PASS: keys, shapes, dtypes, strict load, positive stds')
print('public_test C_D: min=%.5f max=%.5f mean=%.5f  | C_L: min=%.3f max=%.3f mean=%.3f'%(cd.min(),cd.max(),cd.mean(),cl.min(),cl.max(),cl.mean()))
print('no NaN:',torch.isfinite(pred).all().item(),' C_D>0:',(cd>0).all().item())
# physics sanity: C_D decreasing, C_L flat vs velocity
import numpy as np
mono=0; flat=[]
for i in range(pts.shape[0]):
    b0=pts[i:i+1].clone()
    cds=[]; cls=[]
    for v in [70,75,80,85]:
        b=b0.clone(); b[:,:,2]=float(v)
        with torch.no_grad(): o=m((b-fm)/fs)*ts+tm
        cds.append(o[0,0].item()); cls.append(o[0,1].item())
    if cds[0]>cds[1]>cds[2]>cds[3]: mono+=1
    flat.append(abs(cls[-1]-cls[0]))
print('C_D strictly decreasing with velocity in %d/%d cases'%(mono,pts.shape[0]))
print('median |C_L(85)-C_L(70)| = %.4f (C_L std ~0.58) -> near velocity-invariant'%np.median(flat))
"

cd /app && python3 -c "
import json,torch,numpy as np,sys; sys.path.insert(0,'/app')
from candidate_model import build_model
cfg=json.load(open('task_config.json')); ck=torch.load('outputs/model.pt',weights_only=True)
m=build_model(cfg); m.load_state_dict(ck['state_dict']); m.eval()
fm=ck['feat_mean'].view(1,1,-1); fs=ck['feat_std'].view(1,1,-1); tm=ck['targ_mean'].view(1,-1); ts=ck['targ_std'].view(1,-1)
pts=torch.load('data/public_test/split.pt',weights_only=True)['points'].float()
vels=[50,60,70,75,78,82,88]
avg=[]
for v in vels:
    b=pts.clone(); b[:,:,2]=float(v)
    with torch.no_grad(): o=m((b-fm)/fs)*ts+tm
    avg.append(o[:,0].mean().item())
print('mean C_D vs velocity:')
for v,a in zip(vels,avg): print('  v=%2d  C_D=%.5f'%(v,a))
# fraction non-increasing from 70->82 (the real test band)
def cdv(v):
    b=pts.clone(); b[:,:,2]=float(v)
    with torch.no_grad(): return (m((b-fm)/fs)*ts+tm)[:,0]
c70,c75,c82=cdv(70),cdv(75),cdv(82)
print('within 70->82: non-increasing in %d/100; mean delta(82-70)=%.5f'%(int(((c82<=c70+1e-6)).sum()), (c82-c70).mean().item()))
print('per-case C_D(82) still within training C_D range [0.007,0.046]:', bool(((c82>0.004)&(c82<0.05)).all().item()))
"

cd /app && cat > /tmp/seedchk.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import torch,numpy as np
torch.set_num_threads(8)
from exp import load,standardize_stats,train_model,predict,metrics,estimate_cd_slope
ptr,ttr=load('train'); pva,tva=load('val')
pts=torch.cat([ptr,pva],0); tg=torch.cat([ttr,tva],0)
v=pts[:,0,2]; trm=v<69.5; tem=v>=69.5
xtr,ytr=pts[trm],tg[trm]; xte,yte=pts[tem],tg[tem]
fm,fs=standardize_stats(xtr); tm=ytr.mean(0); ts=ytr.std(0).clamp_min(1e-8)
slope=estimate_cd_slope(xtr,ytr)
cfg={'epochs':150,'bs':64,'lr':1e-3,'wd':1e-4,'cd_slope':slope,'swa':True,'loss':'huber','huber_delta':0.01,
     'vel_aug':{'decouple':True,'dlo':-8,'dhi':20,'p':0.5,'w_cd_aug':0.0}}
def log(s): open('/tmp/seedchk.log','a').write(s+'\n')
for sd in (0,1,2,3):
    m=train_model(xtr,ytr,cfg,fm,fs,tm,ts,seed=sd)
    r=metrics(predict(m,xte,fm,fs,tm,ts),yte)
    log('seed=%d mean_nrmse=%.4f cd=%.4f cl=%.4f nmae=%.4f'%(sd,r['mean_nrmse'],r['cd_nrmse'],r['cl_nrmse'],r['cd_nmae']))
log('DONE')
EOF
rm -f /tmp/seedchk.log
nohup python3 /tmp/seedchk.py > /tmp/seedchk.stdout 2>&1 &
echo "started seed check pid $!"

command: create
path: /app/outputs/NOTES.md
file_text: # Airfoil force-coefficient surrogate , approach notes

## Problem & the core difficulty
Predict `[C_D, C_L]` from a 256-point surface cloud (x, y, inlet_velocity,
angle_of_attack). The scored cases are at **higher inlet velocity / Reynolds**
than training: train/val velocities span ~31–75 m/s, but `public_test` is 75–82
(entirely above the training ceiling). So the task is velocity **extrapolation**.

The provided val split is in-distribution (velocity 31–75) and cannot measure
extrapolation. I therefore built **pseudo-extrapolation splits** from the labeled
data: train on velocities below a ceiling T and test on the held-out higher
velocities. This is the only way to measure (with real labels) what matters.

## What the data says (regression controlling for geometry + AoA)
- **C_L** is ~99% explained by geometry + AoA; velocity contributes ~2% of its
  std. Essentially velocity-independent.
- **C_D** has a real, mild, monotonic *decreasing* dependence on velocity
  (Reynolds drag reduction), ~0.5 std across the velocity range.

## Key findings from the pseudo-extrapolation experiments
- A plain fit (standardize-all + MSE) lets **C_L latch onto velocity
  spuriously**; its C_L extrapolation is poor (NRMSE ~0.11–0.17 beyond ceiling).
- Making the model velocity-invariant fixes C_L but destroys C_D (loses the
  Reynolds trend): the targets pull in opposite directions.
- Injecting a global linear C_D–velocity slope helps far-extrapolation C_D a bit
  but *hurts* near-ceiling C_D, because the network's **own** learned,
  geometry-dependent Reynolds trend (from real data) extrapolates better than any
  crude injected slope.

## Final method (see `/app/final_train.py`) , "decoupled" velocity augmentation
Per batch, a fraction `p=0.5` of samples get their inlet velocity perturbed far
past the test range (Δv ∈ [−8, +20], clamped). For those samples:
- **C_L** is supervised with its original (velocity-invariant) value , teaching
  C_L to ignore velocity across the whole range → robust C_L extrapolation.
- the **C_D** loss is switched off (`w_cd_aug=0`) , so C_D is learned *only* from
  real-velocity samples, preserving the network's accurate Reynolds trend and its
  smooth extension past the ceiling.

Plus: **MAE-like loss** (Huber, β=0.01, on standardized targets) , robust to
C_D's right-skewed high-drag outliers; **SWA** over the last 30% of training
(low seed variance); cosine LR; 150 epochs; trained on **train+val** (710 cases).

The architecture and the checkpoint contract are untouched.

## Validated results (mean over 3 seeds, NRMSE = RMSE / std of true)
Pseudo-split ceiling 69.5 (closest analog to the real ceiling-75 → test gap):

| method                 | mean | C_D  | C_L  | cd_nmae |
|------------------------|------|------|------|---------|
| plain fit (baseline)   | 0.100| 0.124| 0.076| 0.027   |
| decoupled aug (final)  |**0.074**|**0.101**|**0.046**|**0.020**|

The final method also wins on the longer ceiling-64 extrapolation (C_D 0.170 vs
baseline 0.226) and on in-distribution val (mean 0.080 vs 0.097) , i.e. it is
better both in and beyond the training range, on both coefficients.

## Checkpoint `/app/outputs/model.pt`
`state_dict` (loads strict into the fixed PointNet) + `feat_mean/feat_std` (len-4)
+ `targ_mean/targ_std` (len-2). Inference: `out = model((pts-feat_mean)/feat_std)`
then `pred = out*targ_std + targ_mean`. On `public_test`: C_D∈[0.007,0.025]
(mean 0.0118, below train mean 0.0128 as expected at higher Re), C_L∈[-0.57,1.74],
no NaNs; mean C_D decreases monotonically through the 75–82 band; C_L ~invariant.

sleep 200 && cat /tmp/seedchk.log 2>/dev/null

sleep 220 && cat /tmp/seedchk.log 2>/dev/null

cd /app && ls -la outputs/ && echo "--- final grader-style load test ---" && python3 -c "
import json,torch,sys; sys.path.insert(0,'/app')
from candidate_model import build_model
cfg=json.load(open('task_config.json'))
ck=torch.load('outputs/model.pt',weights_only=True)
m=build_model(cfg); r=m.load_state_dict(ck['state_dict'],strict=True); m.eval()
for k in ['feat_mean','feat_std','targ_mean','targ_std']:
    assert k in ck and ck[k].shape[0] in (2,4)
# run on public_test and train for a final sanity snapshot
for split in ['public_test','train']:
    d=torch.load(f'data/{split}/split.pt',weights_only=True); pts=d['points'].float()
    with torch.no_grad():
        pred=m((pts-ck['feat_mean'].view(1,1,-1))/ck['feat_std'].view(1,1,-1))*ck['targ_std'].view(1,-1)+ck['targ_mean'].view(1,-1)
    msg=f'{split:11s} pred C_D mean={pred[:,0].mean():.5f} C_L mean={pred[:,1].mean():.4f}'
    if 'targets' in d:
        t=d['targets'].float(); import torch as T
        cd_n=(T.sqrt(((pred[:,0]-t[:,0])**2).mean())/t[:,0].std()).item()
        cl_n=(T.sqrt(((pred[:,1]-t[:,1])**2).mean())/t[:,1].std()).item()
        msg+=f'  | fit-on-train NRMSE C_D={cd_n:.3f} C_L={cl_n:.3f}'
    print(msg)
print('strict load:',r)
print('FINAL CHECKPOINT OK ->', __import__('os').path.getsize('outputs/model.pt'),'bytes')
"

cd /app && python3 -c "
import json,torch,numpy as np,sys; sys.path.insert(0,'/app')
from candidate_model import build_model
cfg=json.load(open('task_config.json')); ck=torch.load('outputs/model.pt',weights_only=True)
m=build_model(cfg); m.load_state_dict(ck['state_dict']); m.eval()
d=torch.load('data/train/split.pt',weights_only=True); pts=d['points'].float(); t=d['targets'].float()
with torch.no_grad():
    pred=m((pts-ck['feat_mean'].view(1,1,-1))/ck['feat_std'].view(1,1,-1))*ck['targ_std'].view(1,-1)+ck['targ_mean'].view(1,-1)
def corr(a,b):
    a=a-a.mean();b=b-b.mean();return float((a*b).sum()/(a.norm()*b.norm()))
print('train C_D: corr(pred,true)=%.3f  MAE=%.5f  median|err|=%.5f  true std=%.5f'%(
    corr(pred[:,0],t[:,0]),(pred[:,0]-t[:,0]).abs().mean(),(pred[:,0]-t[:,0]).abs().median(),t[:,0].std()))
print('train C_L: corr(pred,true)=%.3f  MAE=%.5f'%(corr(pred[:,1],t[:,1]),(pred[:,1]-t[:,1]).abs().mean()))
# R^2 style
for i,nm in [(0,'C_D'),(1,'C_L')]:
    ss=1-((pred[:,i]-t[:,i])**2).sum()/((t[:,i]-t[:,i].mean())**2).sum()
    print(f'  {nm} R^2={ss.item():.3f}')
"

cd /app && pkill -f 'run[0-9]|bench|seedchk|final_train' 2>/dev/null; sleep 2; echo "running python procs: $(pgrep -fc python || echo 0)"; echo "--- deliverable ---"; ls -la /app/outputs/; python3 -c "import torch;ck=torch.load('/app/outputs/model.pt',weights_only=True);print('keys:',sorted(ck));print('all norm tensors present & finite:', all(torch.isfinite(ck[k]).all() for k in ['feat_mean','feat_std','targ_mean','targ_std']))"

ps aux | grep -E 'python3 /tmp|final_train' | grep -v grep | awk '{print $2, $11, $12, $13}'; echo "done check"