airfrans-high-reynolds-drag-extrapolation

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

cd /app && python3 -c "
import torch
def stats(name, pts):
    flat = pts.reshape(-1,4)
    print('====', name, '====')
    for i,ch in enumerate(['x','y','vel','aoa']):
        c = flat[:,i]
        print(f'  {ch:4s} min={c.min():.4f} max={c.max():.4f} mean={c.mean():.4f} std={c.std():.4f}')
    # per-case velocity and aoa (broadcast) -> take point 0
    vel = pts[:,0,2]; aoa = pts[:,0,3]
    print('  per-case vel: min=%.4f max=%.4f'%(vel.min(),vel.max()))
    print('  per-case aoa: min=%.4f max=%.4f (rad), deg min=%.3f max=%.3f'%(aoa.min(),aoa.max(), aoa.min()*57.2958, aoa.max()*57.2958))

for split in ['train','val','public_test']:
    p = torch.load(f'data/{split}/split.pt', weights_only=True)
    stats(split, p['points'])
"

cd /app && python3 -c "
import torch
for split in ['train','val']:
    p = torch.load(f'data/{split}/split.pt', weights_only=True)
    t = p['targets']
    print('====', split, '====')
    for i,name in enumerate(['C_D','C_L']):
        c=t[:,i]
        print(f'  {name}: min={c.min():.5f} max={c.max():.5f} mean={c.mean():.5f} std={c.std():.5f}')
    # correlations with vel and aoa
    vel = p['points'][:,0,2]; aoa = p['points'][:,0,3]
    import numpy as np
    for i,name in enumerate(['C_D','C_L']):
        c=t[:,i]
        cv=np.corrcoef(c.numpy(), vel.numpy())[0,1]
        ca=np.corrcoef(c.numpy(), aoa.numpy())[0,1]
        print(f'  corr({name},vel)={cv:.3f}  corr({name},aoa)={ca:.3f}')
"

cd /app && python3 -c "
import torch, numpy as np
p = torch.load('data/train/split.pt', weights_only=True)
t = p['targets'].numpy()
pts = p['points'].numpy()
vel = pts[:,0,2]; aoa = pts[:,0,3]
N = len(t)
# Linear regression of each target on [1, aoa, vel, aoa^2]
def fit(X, y):
    beta, res, *_ = np.linalg.lstsq(X, y, rcond=None)
    pred = X@beta
    ss_res = ((y-pred)**2).sum(); ss_tot=((y-y.mean())**2).sum()
    return beta, 1-ss_res/ss_tot
for i,name in enumerate(['C_D','C_L']):
    y=t[:,i]
    X1=np.column_stack([np.ones(N),aoa])
    X2=np.column_stack([np.ones(N),aoa,vel])
    X3=np.column_stack([np.ones(N),aoa,aoa**2,vel,vel**2, aoa*vel])
    print(name)
    print('  R2 aoa only       :', round(fit(X1,y)[1],3))
    print('  R2 aoa+vel        :', round(fit(X2,y)[1],3))
    print('  R2 quad aoa,vel   :', round(fit(X3,y)[1],3))
"

cd /app && python3 -c "
import torch, numpy as np
p = torch.load('data/train/split.pt', weights_only=True)
pts = p['points'].numpy(); t=p['targets'].numpy()
# shape signature = rounded x,y coords
shapes = pts[:,:,:2].reshape(len(pts),-1)
# hash by rounding
import hashlib
sig = [hashlib.md5(np.round(s,5).tobytes()).hexdigest() for s in shapes]
from collections import defaultdict
groups=defaultdict(list)
for i,s in enumerate(sig): groups[s].append(i)
mult=[g for g in groups.values() if len(g)>1]
print('unique shapes:', len(groups), ' shapes with >1 case:', len(mult))
# distribution of group sizes
from collections import Counter
print('group size counts:', Counter(len(g) for g in groups.values()))
"

cd /app && python3 -c "
import torch, time
print('torch', torch.__version__, 'cuda', torch.cuda.is_available())
print('cpu threads', torch.get_num_threads())
import os; print('cpus', os.cpu_count())
# quick timing of a forward/backward
import sys; sys.path.insert(0,'.')
import json
cfg=json.load(open('task_config.json'))
from candidate_model import build_model
m=build_model(cfg)
x=torch.randn(32,256,4)
t=time.time()
for _ in range(20):
    y=m(x); y.sum().backward()
print('20 fwd/bwd bs32 on cpu: %.3fs'%(time.time()-t))
n=sum(p.numel() for p in m.parameters()); print('params', n)
"

cd /app && python3 -c "
import torch, numpy as np
p = torch.load('data/train/split.pt', weights_only=True)
vel = p['points'][:,0,2].numpy()
print('quantiles of train velocity:')
for q in [0,10,25,50,75,80,85,90,95,100]:
    print(f'  {q:3d}%: {np.percentile(vel,q):.2f}')
# how many above various thresholds
for T in [60,63,65,67,70]:
    print(f'  vel>={T}: {(vel>=T).sum()} cases')
"

command: create
path: /app/exp.py
file_text: """Experiment harness for the airfoil force-coefficient task.

Core idea: the scored set lives ABOVE the training velocity range, but the
provided val split shares the training range. So we build a *velocity
extrapolation* holdout from the training data itself (train on low velocities,
evaluate on the highest) to measure the thing that actually matters.
"""
from __future__ import annotations
import json, os, sys, copy, math
from pathlib import Path
import numpy as np
import torch
import torch.nn.functional as F

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

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


def load_all():
    ptr, ttr = load_split(APP_DIR / 'data' / 'train')
    pva, tva = load_split(APP_DIR / 'data' / 'val')
    return ptr, ttr, pva, tva


def standardize_stats(points, targets):
    flat = points.reshape(-1, points.shape[-1])
    fmean = flat.mean(0); fstd = flat.std(0).clamp_min(1e-8)
    tmean = targets.mean(0); tstd = targets.std(0).clamp_min(1e-8)
    return fmean, fstd, tmean, tstd


def nrmse_metrics(pred, true):
    """pred,true: [N,2] physical units. Returns dict of per-target nrmse etc."""
    pred = pred.numpy() if torch.is_tensor(pred) else pred
    true = true.numpy() if torch.is_tensor(true) else true
    out = {}
    names = ['cd', 'cl']
    nrmse_std = []; nrmse_rng = []
    for i, n in enumerate(names):
        err = pred[:, i] - true[:, i]
        rmse = np.sqrt((err ** 2).mean())
        std = true[:, i].std(); rng = true[:, i].max() - true[:, i].min()
        out[f'{n}_rmse'] = rmse
        out[f'{n}_nrmse_std'] = rmse / (std + 1e-12)
        out[f'{n}_nrmse_rng'] = rmse / (rng + 1e-12)
        out[f'{n}_mae'] = np.abs(err).mean()
        out[f'{n}_nmae'] = np.abs(err).mean() / (np.abs(true[:, i]).mean() + 1e-12)
        nrmse_std.append(rmse / (std + 1e-12)); nrmse_rng.append(rmse / (rng + 1e-12))
    out['mean_nrmse_std'] = float(np.mean(nrmse_std))
    out['worst_nrmse_std'] = float(np.max(nrmse_std))
    out['mean_nrmse_rng'] = float(np.mean(nrmse_rng))
    return out


def augment(xb_phys, cfg, fmean, fstd):
    """xb_phys: [B,256,4] physical units. Returns standardized, augmented batch."""
    B = xb_phys.shape[0]
    x = xb_phys.clone()
    # velocity augmentation (per-case multiplicative)
    vfac = cfg.get('vel_mult', 0.0)
    if vfac > 0:
        f = torch.empty(B, 1).uniform_(1.0 - vfac, 1.0 + cfg.get('vel_mult_hi', vfac))
        x[:, :, 2] = x[:, :, 2] * f
    vadd = cfg.get('vel_add', 0.0)
    if vadd > 0:
        x[:, :, 2] = x[:, :, 2] + torch.randn(B, 1) * vadd
    # geometry jitter on x,y
    gj = cfg.get('geom_jitter', 0.0)
    if gj > 0:
        x[:, :, :2] = x[:, :, :2] + torch.randn(B, 256, 2) * gj
    # aoa jitter
    aj = cfg.get('aoa_jitter', 0.0)
    if aj > 0:
        x[:, :, 3] = x[:, :, 3] + torch.randn(B, 1) * aj
    xs = (x - fmean.view(1, 1, -1)) / fstd.view(1, 1, -1)
    return xs


def train_model(xtr_phys, ytr, cfg, fmean, fstd, tmean, tstd, seed=0, verbose=False):
    torch.manual_seed(seed); np.random.seed(seed)
    device = 'cpu'
    model = build_model(CFG).to(device)
    ys = (ytr - tmean.view(1, -1)) / tstd.view(1, -1)
    epochs = cfg.get('epochs', 80)
    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)
    n = xtr_phys.shape[0]
    sched_type = cfg.get('sched', 'cosine')
    steps_per = max(1, math.ceil(n / bs))
    total_steps = epochs * steps_per
    def lr_at(step):
        warm = cfg.get('warmup_steps', 0)
        if step < warm:
            return lr * (step + 1) / warm
        if sched_type == 'cosine':
            prog = (step - warm) / max(1, total_steps - warm)
            return cfg.get('lr_min', 1e-5) + 0.5 * (lr - cfg.get('lr_min', 1e-5)) * (1 + math.cos(math.pi * prog))
        return lr
    tw = cfg.get(
…[truncated]

command: create
path: /app/run_exp.py
file_text: from __future__ import annotations
import sys, json, time
import numpy as np
import torch
from exp import (load_all, standardize_stats, train_model, recompute_bn,
                 predict, nrmse_metrics)


def pseudo_split(points, targets, thresh):
    vel = points[:, 0, 2]
    tr = vel < thresh
    te = vel >= thresh
    return points[tr], targets[tr], points[te], targets[te]


def run(cfg, thresh=63.0, seeds=(0,), which='final', recompute=True, verbose=True):
    ptr_all, ttr_all, pva, tva = load_all()
    xtr, ytr, xte, yte = pseudo_split(ptr_all, ttr_all, thresh)
    fmean, fstd, tmean, tstd = standardize_stats(xtr, ytr)
    preds = []
    for seed in seeds:
        res, _ = train_model(xtr, ytr, cfg, fmean, fstd, tmean, tstd, seed=seed)
        state = res[which] if which in res else res['final']
        if recompute and which in ('ema', 'swa'):
            state = recompute_bn(state, xtr, fmean, fstd, cfg)
        p = predict(state, xte, fmean, fstd, tmean, tstd)
        preds.append(p)
    pred = torch.stack(preds).mean(0)
    m = nrmse_metrics(pred, yte)
    if verbose:
        print(f"  [thresh={thresh} which={which} seeds={len(seeds)}] "
              f"mean_nrmse_std={m['mean_nrmse_std']:.4f} "
              f"cd_nrmse={m['cd_nrmse_std']:.4f} cl_nrmse={m['cl_nrmse_std']:.4f} "
              f"worst={m['worst_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f}")
    return m


if __name__ == '__main__':
    name = sys.argv[1] if len(sys.argv) > 1 else 'baseline'
    configs = {
        'baseline': dict(epochs=40, lr=1e-3, wd=1e-4, sched='const', loss='mse'),
        'baseline_cos': dict(epochs=80, lr=1e-3, wd=1e-4, sched='cosine', loss='mse'),
    }
    cfg = configs[name]
    t = time.time()
    run(cfg, thresh=63.0, seeds=(0, 1, 2))
    print('  time %.1fs' % (time.time() - t))

cd /app && echo "=== baseline (const lr, MSE, 40ep, no aug) ===" && python3 run_exp.py baseline && echo "=== baseline cosine 80ep ===" && python3 run_exp.py baseline_cos

command: create
path: /app/sweep.py
file_text: from __future__ import annotations
import time, itertools
import numpy as np
from run_exp import run

BASE = dict(epochs=80, lr=1e-3, wd=1e-4, sched='cosine', loss='mse')

def cfg(**kw):
    c = dict(BASE); c.update(kw); return c

EXPS = {
  'cos80':            cfg(),
  'vel_m10_30':       cfg(vel_mult=0.10, vel_mult_hi=0.30),
  'vel_m15_40':       cfg(vel_mult=0.15, vel_mult_hi=0.40),
  'vel_m20_50':       cfg(vel_mult=0.20, vel_mult_hi=0.50),
  'geom002':          cfg(geom_jitter=0.002),
  'vel_m15_40_g002':  cfg(vel_mult=0.15, vel_mult_hi=0.40, geom_jitter=0.002),
  'huber':            cfg(loss='huber', huber_beta=1.0),
  'vel_m15_40_huber': cfg(vel_mult=0.15, vel_mult_hi=0.40, loss='huber', huber_beta=1.0),
}

if __name__ == '__main__':
    import sys
    keys = sys.argv[1:] if len(sys.argv) > 1 else list(EXPS)
    for k in keys:
        t = time.time()
        print(f'### {k}')
        run(EXPS[k], thresh=63.0, seeds=(0, 1, 2))
        print('   (%.1fs)' % (time.time() - t))

cd /app && python3 sweep.py vel_m10_30 vel_m15_40 vel_m20_50 2>&1

cd /app && python3 -c "
import torch, numpy as np
p = torch.load('data/train/split.pt', weights_only=True)
t = p['targets'].numpy(); pts=p['points'].numpy()
vel=pts[:,0,2]; aoa=pts[:,0,3]
cd=t[:,0]; cl=t[:,1]
N=len(cd)
def fit(X,y):
    beta,*_=np.linalg.lstsq(X,y,rcond=None); pred=X@beta
    r2=1-((y-pred)**2).sum()/((y-y.mean())**2).sum(); return beta,r2
# log(cd) ~ 1, aoa, aoa^2, aoa^3, log(vel)
X=np.column_stack([np.ones(N),aoa,aoa**2,aoa**3,np.log(vel)])
b,r2=fit(X,np.log(cd))
print('log(cd) model R2=%.3f, coef log(vel)=%.3f'%(r2,b[-1]))
# cl ~ aoa poly + log vel
X2=np.column_stack([np.ones(N),aoa,aoa**2,aoa**3,np.log(vel)])
b2,r2b=fit(X2,cl)
print('cl model R2=%.3f, coef log(vel)=%.4f'%(r2b,b2[-1]))
# also linear vel coefficient on cd controlling aoa
X3=np.column_stack([np.ones(N),aoa,aoa**2,aoa**3,vel])
b3,r3=fit(X3,cd); print('cd linear-vel coef=%.3e per m/s (cd mean %.4f)'%(b3[-1],cd.mean()))
"

command: str_replace
path: /app/exp.py
old_str: def augment(xb_phys, cfg, fmean, fstd):
    """xb_phys: [B,256,4] physical units. Returns standardized, augmented batch."""
    B = xb_phys.shape[0]
    x = xb_phys.clone()
    # velocity augmentation (per-case multiplicative)
    vfac = cfg.get('vel_mult', 0.0)
    if vfac > 0:
        f = torch.empty(B, 1).uniform_(1.0 - vfac, 1.0 + cfg.get('vel_mult_hi', vfac))
        x[:, :, 2] = x[:, :, 2] * f
    vadd = cfg.get('vel_add', 0.0)
    if vadd > 0:
        x[:, :, 2] = x[:, :, 2] + torch.randn(B, 1) * vadd
    # geometry jitter on x,y
    gj = cfg.get('geom_jitter', 0.0)
    if gj > 0:
        x[:, :, :2] = x[:, :, :2] + torch.randn(B, 256, 2) * gj
    # aoa jitter
    aj = cfg.get('aoa_jitter', 0.0)
    if aj > 0:
        x[:, :, 3] = x[:, :, 3] + torch.randn(B, 1) * aj
    xs = (x - fmean.view(1, 1, -1)) / fstd.view(1, 1, -1)
    return xs
new_str: def augment(xb_phys, yb_phys, cfg, fmean, fstd):
    """xb_phys:[B,256,4] physical, yb_phys:[B,2] physical (C_D,C_L).

    Returns (standardized augmented inputs, physical augmented targets).
    Velocity is scaled multiplicatively; the C_D target is corrected along a
    Reynolds power law  C_D *= f**cd_exp  (cd_exp~-0.21), C_L left unchanged.
    """
    B = xb_phys.shape[0]
    x = xb_phys.clone()
    y = yb_phys.clone()
    # velocity augmentation (per-case multiplicative) with Reynolds target fix
    vfac = cfg.get('vel_mult', 0.0)
    if vfac > 0:
        f = torch.empty(B).uniform_(1.0 - vfac, 1.0 + cfg.get('vel_mult_hi', vfac))
        x[:, :, 2] = x[:, :, 2] * f.view(B, 1)
        cd_exp = cfg.get('cd_exp', -0.21)
        y[:, 0] = y[:, 0] * f.pow(cd_exp)
        cl_exp = cfg.get('cl_exp', 0.0)
        if cl_exp != 0.0:
            y[:, 1] = y[:, 1] * f.pow(cl_exp)
    # geometry jitter on x,y
    gj = cfg.get('geom_jitter', 0.0)
    if gj > 0:
        x[:, :, :2] = x[:, :, :2] + torch.randn(B, 256, 2) * gj
    # aoa jitter
    aj = cfg.get('aoa_jitter', 0.0)
    if aj > 0:
        x[:, :, 3] = x[:, :, 3] + torch.randn(B, 1) * aj
    xs = (x - fmean.view(1, 1, -1)) / fstd.view(1, 1, -1)
    return xs, y

command: str_replace
path: /app/exp.py
old_str:     ys = (ytr - tmean.view(1, -1)) / tstd.view(1, -1)
    epochs = cfg.get('epochs', 80)
new_str:     epochs = cfg.get('epochs', 80)

command: str_replace
path: /app/exp.py
old_str:             idx = perm[s:s + bs]
            xb = augment(xtr_phys[idx], cfg, fmean, fstd)
            yb = ys[idx]
new_str:             idx = perm[s:s + bs]
            xb, yb_phys = augment(xtr_phys[idx], ytr[idx], cfg, fmean, fstd)
            yb = (yb_phys - tmean.view(1, -1)) / tstd.view(1, -1)

cd /app && python3 -c "
from run_exp import run
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine',loss='mse')
def cfg(**kw):
    c=dict(BASE); c.update(kw); return c
exps={
 'no_aug':            cfg(),
 'reyn_m10_30':       cfg(vel_mult=0.10, vel_mult_hi=0.30, cd_exp=-0.21),
 'reyn_m15_40':       cfg(vel_mult=0.15, vel_mult_hi=0.40, cd_exp=-0.21),
 'reyn_m20_60':       cfg(vel_mult=0.20, vel_mult_hi=0.60, cd_exp=-0.21),
}
for k,c in exps.items():
    print('###',k)
    run(c, thresh=63.0, seeds=(0,1,2))
"

restart: true

cd /app && cat > runbg.py << 'EOF'
import sys, time, json
from run_exp import run
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine',loss='mse')
def cfg(**kw):
    c=dict(BASE); c.update(kw); return c
ALL={
 'no_aug':        cfg(),
 'reyn_m10_30':   cfg(vel_mult=0.10, vel_mult_hi=0.30, cd_exp=-0.21),
 'reyn_m15_40':   cfg(vel_mult=0.15, vel_mult_hi=0.40, cd_exp=-0.21),
 'reyn_m20_60':   cfg(vel_mult=0.20, vel_mult_hi=0.60, cd_exp=-0.21),
 'reyn_m10_30_e0':cfg(vel_mult=0.10, vel_mult_hi=0.30, cd_exp=0.0),
}
keys=sys.argv[1:]
out=open('results.txt','a')
for k in keys:
    t=time.time()
    m=run(ALL[k], thresh=63.0, seeds=(0,1,2), verbose=False)
    line=f"{k:18s} mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f} worst={m['worst_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f} ({time.time()-t:.0f}s)"
    print(line); out.write(line+'\n'); out.flush()
out.close()
EOF
echo "written"

cd /app && rm -f results.txt && export OMP_NUM_THREADS=16 && nohup python3 runbg.py no_aug reyn_m10_30 reyn_m15_40 reyn_m20_60 reyn_m10_30_e0 > sweep1.log 2>&1 &
echo "started pid $!"

cd /app && sleep 240 && echo "--- results so far ---" && cat results.txt 2>/dev/null

cd /app && sleep 200 && cat results.txt 2>/dev/null

cd /app && sleep 30 && cat results.txt 2>/dev/null | tail -1
# investigate C_D error structure: no_aug vs reyn, where do errors concentrate?
python3 -c "
import torch, numpy as np
from run_exp import pseudo_split
from exp import load_all, standardize_stats, train_model, predict
ptr,ttr,_,_=load_all()
xtr,ytr,xte,yte=pseudo_split(ptr,ttr,63.0)
fmean,fstd,tmean,tstd=standardize_stats(xtr,ytr)
velte=xte[:,0,2].numpy(); aoate=xte[:,0,3].numpy()
def run1(cfg,seed=0):
    res,_=train_model(xtr,ytr,cfg,fmean,fstd,tmean,tstd,seed=seed)
    return predict(res['final'],xte,fmean,fstd,tmean,tstd).numpy()
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine',loss='mse')
na=run1(BASE)
ra=run1(dict(BASE,vel_mult=0.10,vel_mult_hi=0.30,cd_exp=-0.21))
cd_true=yte[:,0].numpy()
for nm,pr in [('no_aug',na),('reyn',ra)]:
    err=np.abs(pr[:,0]-cd_true)
    order=np.argsort(-err)[:5]
    print(nm,'top5 CD abs err:', np.round(err[order],4), 'at cd_true',np.round(cd_true[order],4),'vel',np.round(velte[order],1),'aoa',np.round(aoate[order],3))
" 2>&1 | tail -8

cd /app && cat > runbg2.py << 'EOF'
import sys, time
from run_exp import run
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine',loss='mse')
def cfg(**kw):
    c=dict(BASE); c.update(kw); return c
ALL={
 'no_aug':        cfg(),
 'reyn_m05_25':   cfg(vel_mult=0.05, vel_mult_hi=0.25, cd_exp=-0.21),
 'reyn_m05_20':   cfg(vel_mult=0.05, vel_mult_hi=0.20, cd_exp=-0.21),
 'reyn_m10_30':   cfg(vel_mult=0.10, vel_mult_hi=0.30, cd_exp=-0.21),
 'reyn_m08_25_hub':cfg(vel_mult=0.08, vel_mult_hi=0.25, cd_exp=-0.21, loss='huber', huber_beta=0.5),
}
thresh=float(sys.argv[1]); keys=sys.argv[2:]
out=open('results.txt','a')
for k in keys:
    t=time.time()
    m=run(ALL[k], thresh=thresh, seeds=(0,1,2), verbose=False)
    line=f"T{thresh:.0f} {k:16s} mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f} worst={m['worst_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f} meanRNG={m['mean_nrmse_rng']:.4f} ({time.time()-t:.0f}s)"
    print(line); out.write(line+'\n'); out.flush()
out.close()
EOF
rm -f results.txt
export OMP_NUM_THREADS=16
nohup python3 runbg2.py 70 no_aug reyn_m05_25 reyn_m10_30 > sweepT70.log 2>&1 &
echo "started T70 pid $!"

cd /app && sleep 290 && cat results.txt 2>/dev/null

cd /app && sleep 130 && cat results.txt 2>/dev/null | tail -2
# launch refinement around gentle aug at T70 and also T67
export OMP_NUM_THREADS=16
nohup python3 runbg2.py 70 reyn_m05_20 reyn_m08_25_hub > sweepT70b.log 2>&1 &
echo "started T70b pid $!"

cd /app && echo "--- sweep1.log (T63, includes cd_exp=0) ---" && cat sweep1.log 2>/dev/null | grep -E "no_aug|reyn" 

cd /app && sleep 280 && grep "T70" results.txt 2>/dev/null

cd /app && cat > runbg3.py << 'EOF'
import sys, time
from run_exp import run
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine')
def cfg(**kw):
    c=dict(BASE); c.update(kw); return c
H=dict(vel_mult=0.08, vel_mult_hi=0.25, cd_exp=-0.21, loss='huber', huber_beta=0.5)
ALL={
 'hub50':     cfg(**H),
 'hub30':     cfg(**{**H,'huber_beta':0.3}),
 'hub100':    cfg(**{**H,'huber_beta':1.0}),
 'hub50_ema': cfg(**{**H,'ema':0.995}),
 'hub50_swa': cfg(**{**H,'swa_start_frac':0.6}),
 'hub50_g002':cfg(**{**H,'geom_jitter':0.002}),
 'hub50_e120':cfg(**{**H,'epochs':120}),
}
thresh=float(sys.argv[1]); which=sys.argv[2]; keys=sys.argv[3:]
out=open('results.txt','a')
for k in keys:
    t=time.time()
    m=run(ALL[k], thresh=thresh, seeds=(0,1,2), which=which)
    line=f"T{thresh:.0f} {which:5s} {k:12s} mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f} ({time.time()-t:.0f}s)"
    out.write(line+'\n'); out.flush()
out.close()
EOF
export OMP_NUM_THREADS=16
nohup python3 runbg3.py 70 final hub30 hub100 > s3a.log 2>&1 &
echo "started pid $!"

cd /app && sleep 290 && grep -E "hub30|hub100" results.txt 2>/dev/null

cd /app && export OMP_NUM_THREADS=16
nohup python3 runbg3.py 70 ema hub50_ema > s3b.log 2>&1 &
nohup python3 runbg3.py 70 swa hub50_swa > s3c.log 2>&1 &
echo "started ema+swa"

cd /app && sleep 295 && grep -E "hub50_ema|hub50_swa" results.txt 2>/dev/null; echo "(still running if empty)"; ps aux | grep -c "[r]unbg3"

command: str_replace
path: /app/exp.py
old_str: def train_model(xtr_phys, ytr, cfg, fmean, fstd, tmean, tstd, seed=0, verbose=False):
    torch.manual_seed(seed); np.random.seed(seed)
    device = 'cpu'
    model = build_model(CFG).to(device)
new_str: def train_model(xtr_phys, ytr, cfg, fmean, fstd, tmean, tstd, seed=0, verbose=False,
                init_seed=None):
    device = 'cpu'
    # Optionally fix the initialization across runs (for weight-averaging soups)
    torch.manual_seed(init_seed if init_seed is not None else seed)
    model = build_model(CFG).to(device)
    torch.manual_seed(seed); np.random.seed(seed)

cd /app && cat > soup_test.py << 'EOF'
import time, torch
import numpy as np
from run_exp import pseudo_split
from exp import load_all, standardize_stats, train_model, recompute_bn, predict, nrmse_metrics

ptr,ttr,pva,tva=load_all()
xtr,ytr,xte,yte=pseudo_split(ptr,ttr,70.0)
fmean,fstd,tmean,tstd=standardize_stats(xtr,ytr)
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine',vel_mult=0.08,vel_mult_hi=0.25,cd_exp=-0.21,loss='huber',huber_beta=0.3)

def avg_states(states):
    out={}
    for k in states[0]:
        if states[0][k].dtype.is_floating_point:
            out[k]=sum(s[k].float() for s in states)/len(states)
        else:
            out[k]=states[0][k].clone()
    return out

# Per-seed (independent init) performance + prediction-ensemble
states_indep=[]; preds_indep=[]
for sd in [0,1,2]:
    res,_=train_model(xtr,ytr,BASE,fmean,fstd,tmean,tstd,seed=sd)
    states_indep.append(res['final'])
    preds_indep.append(predict(res['final'],xte,fmean,fstd,tmean,tstd))
for i,sd in enumerate([0,1,2]):
    m=nrmse_metrics(preds_indep[i],yte)
    print(f"seed{sd} single: mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f}")
m=nrmse_metrics(torch.stack(preds_indep).mean(0),yte)
print(f"PRED-ENSEMBLE(3 indep): mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f}")

# Soup: same init, different noise seeds
states_soup=[]
for sd in [10,11,12,13]:
    res,_=train_model(xtr,ytr,BASE,fmean,fstd,tmean,tstd,seed=sd,init_seed=777)
    states_soup.append(res['final'])
soup=avg_states(states_soup)
soup=recompute_bn(soup,xtr,fmean,fstd,BASE)
m=nrmse_metrics(predict(soup,xte,fmean,fstd,tmean,tstd),yte)
print(f"SOUP(4 same-init): mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f}")
EOF
export OMP_NUM_THREADS=16
nohup python3 soup_test.py > soup.log 2>&1 &
echo "started soup pid $!"

cd /app && sleep 295 && cat soup.log 2>/dev/null; echo "(empty=still running)"

cd /app && sleep 120 && cat soup.log 2>/dev/null; echo "(empty=still running)"

cd /app && cat > runbg4.py << 'EOF'
import sys, time
from run_exp import run
BASE=dict(epochs=80,lr=1e-3,wd=1e-4,sched='cosine',vel_mult=0.08,vel_mult_hi=0.25,cd_exp=-0.21,loss='huber',huber_beta=0.3)
def cfg(**kw):
    c=dict(BASE); c.update(kw); return c
ALL={
 'b30':       cfg(),
 'b20':       cfg(huber_beta=0.2),
 'b30_e120':  cfg(epochs=120),
 'b30_up30':  cfg(vel_mult_hi=0.30),
 'b30_e120_up30': cfg(epochs=120, vel_mult_hi=0.30),
}
thresh=float(sys.argv[1]); keys=sys.argv[2:]
out=open('results.txt','a')
for k in keys:
    t=time.time()
    m=run(ALL[k], thresh=thresh, seeds=(0,1,2))
    line=f"T{thresh:.0f} FIN {k:14s} mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f} ({time.time()-t:.0f}s)"
    out.write(line+'\n'); out.flush()
out.close()
EOF
export OMP_NUM_THREADS=16
nohup python3 runbg4.py 70 b20 b30_e120 b30_up30 > s4a.log 2>&1 &
echo "started pid $!"

cd /app && sleep 295 && grep -E "FIN (b20|b30_e120|b30_up30)" results.txt 2>/dev/null

cd /app && sleep 90 && grep -E "FIN b30_up30" results.txt 2>/dev/null
export OMP_NUM_THREADS=16
cat >> runbg4.py.ignore << 'EOF'
EOF
nohup python3 runbg4.py 70 b30_e120_up30 > s4b.log 2>&1 &
echo "launched e120_up30"

cd /app && cat > runbg5.py << 'EOF'
import sys, time
from run_exp import run
BASE=dict(lr=1e-3,wd=1e-4,sched='cosine',vel_mult=0.08,vel_mult_hi=0.25,cd_exp=-0.21,loss='huber',huber_beta=0.3)
def cfg(**kw):
    c=dict(BASE); c.update(kw); return c
ALL={
 'b30_e160':  cfg(epochs=160),
 'b30_e200':  cfg(epochs=200),
 'b20_e120':  cfg(epochs=120, huber_beta=0.2),
 'b30_e120_wd3':cfg(epochs=120, wd=3e-4),
}
thresh=float(sys.argv[1]); keys=sys.argv[2:]
out=open('results.txt','a')
for k in keys:
    t=time.time()
    m=run(ALL[k], thresh=thresh, seeds=(0,1,2))
    line=f"T{thresh:.0f} FIN {k:14s} mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f} ({time.time()-t:.0f}s)"
    out.write(line+'\n'); out.flush()
out.close()
EOF
export OMP_NUM_THREADS=16
nohup python3 runbg5.py 70 b30_e160 b20_e120 > s5a.log 2>&1 &
echo "started pid $!"

cd /app && sleep 298 && grep -E "FIN (b30_e160|b20_e120|b30_e120_up30)" results.txt 2>/dev/null

cd /app && sleep 90 && grep -E "FIN (b30_e160|b20_e120|b30_e120_up30)" results.txt 2>/dev/null; echo "---tail---"; tail -3 results.txt

cd /app && ps aux | grep "[r]unbg" | awk '{print $2, $11, $12, $13, $14}'; echo "---"; sleep 150 && grep -E "FIN (b30_e160|b20_e120|b30_e120_up30)" results.txt 2>/dev/null

cd /app && sleep 60 && grep -E "FIN b20_e120" results.txt 2>/dev/null; echo "launching robustness checks at T67 and T63"
cat > runbg6.py << 'EOF'
import sys, time
from run_exp import run
CHOSEN=dict(epochs=120,lr=1e-3,wd=1e-4,sched='cosine',vel_mult=0.08,vel_mult_hi=0.30,cd_exp=-0.21,loss='huber',huber_beta=0.3)
NOAUG=dict(epochs=120,lr=1e-3,wd=1e-4,sched='cosine',loss='mse')
ALL={'chosen':CHOSEN,'noaug120':NOAUG}
thresh=float(sys.argv[1]); keys=sys.argv[2:]
out=open('results.txt','a')
for k in keys:
    t=time.time()
    m=run(ALL[k], thresh=thresh, seeds=(0,1,2))
    line=f"T{thresh:.0f} CHK {k:10s} mean={m['mean_nrmse_std']:.4f} cd={m['cd_nrmse_std']:.4f} cl={m['cl_nrmse_std']:.4f} cd_nmae={m['cd_nmae']:.4f} ({time.time()-t:.0f}s)"
    out.write(line+'\n'); out.flush()
out.close()
EOF
export OMP_NUM_THREADS=16
nohup python3 runbg6.py 63 chosen noaug120 > s6a.log 2>&1 &
echo "started T63 check pid $!"

cd /app && sleep 280 && grep -E "FIN b20_e120|T63 CHK" results.txt 2>/dev/null

cd /app && sleep 200 && grep -E "T63 CHK" results.txt 2>/dev/null

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

Strategy (validated on a velocity-extrapolation holdout built from the training
data, since the provided val split shares the training velocity range while the
scored set lies above it):

  * Train on train+val combined for maximum data.
  * Physics-grounded velocity augmentation: multiply each case's inlet velocity
    by f~U(0.92,1.30) and correct the C_D target by f**(-0.21) (the measured
    turbulent Reynolds exponent), leaving C_L unchanged (it is ~velocity
    invariant). This both teaches the correct weak velocity dependence and
    exposes the model to the higher-velocity regime it is scored on.
  * Huber loss (beta=0.3) in standardized target space -> robust to C_D outliers.
  * Cosine LR schedule, 120 epochs; plain final weights (EMA/SWA were worse).
  * Train several seeds and ship the most representative one (closest to the
    seed-ensemble mean on the public_test inputs) to hedge seed variance.
"""
from __future__ import annotations
import json, sys, time
from pathlib import Path
import numpy as np
import torch

APP = Path('/app'); sys.path.insert(0, str(APP))
from exp import (standardize_stats, train_model, predict, nrmse_metrics, CFG)
from dataset import load_split

CONFIG = dict(epochs=120, lr=1e-3, wd=1e-4, sched='cosine', lr_min=1e-5,
              vel_mult=0.08, vel_mult_hi=0.30, cd_exp=-0.21,
              loss='huber', huber_beta=0.3)
SEEDS = [0, 1, 2, 3, 4]


def main():
    t0 = time.time()
    ptr, ttr = load_split(APP / 'data' / 'train')
    pva, tva = load_split(APP / 'data' / 'val')
    points = torch.cat([ptr, pva], 0)
    targets = torch.cat([ttr, tva], 0)
    print(f'[final] combined train+val: {points.shape[0]} cases')

    fmean, fstd, tmean, tstd = standardize_stats(points, targets)
    print('[final] feat_mean', fmean.tolist())
    print('[final] feat_std ', fstd.tolist())
    print('[final] targ_mean', tmean.tolist(), 'targ_std', tstd.tolist())

    ptest, _ = load_split(APP / 'data' / 'public_test')

    # In-distribution val (for a sanity read only; NOT used for selection).
    states, val_preds, test_preds = [], [], []
    for sd in SEEDS:
        res, _ = train_model(points, targets, CONFIG, fmean, fstd, tmean, tstd, seed=sd)
        st = res['final']
        states.append(st)
        vp = predict(st, pva, fmean, fstd, tmean, tstd)
        tp = predict(st, ptest, fmean, fstd, tmean, tstd)
        val_preds.append(vp); test_preds.append(tp)
        m = nrmse_metrics(vp, tva)
        print(f'[final] seed={sd} in-dist val mean_nrmse={m["mean_nrmse_std"]:.4f} '
              f'cd={m["cd_nrmse_std"]:.4f} cl={m["cl_nrmse_std"]:.4f} '
              f'(t={time.time()-t0:.0f}s)', flush=True)

    # Pick the most representative seed: closest to the ensemble-mean prediction
    # on the public_test inputs (uses inputs only -> legitimate, label-free).
    test_stack = torch.stack(test_preds)            # [S, N, 2]
    centroid = test_stack.mean(0)
    # normalize each target channel by its spread so both count equally
    scale = centroid.std(0, keepdim=True).clamp_min(1e-8)
    dists = (((test_stack - centroid[None]) / scale[None]) ** 2).mean(dim=(1, 2))
    best = int(torch.argmin(dists).item())
    print('[final] seed centroid distances:', [round(float(d), 5) for d in dists])
    print(f'[final] selected representative seed = {SEEDS[best]}')

    # Report that seed's in-dist val and ensemble val for context.
    m_sel = nrmse_metrics(val_preds[best], tva)
    m_ens = nrmse_metrics(torch.stack(val_preds).mean(0), tva)
    print(f'[final] selected seed in-dist val mean_nrmse={m_sel["mean_nrmse_std"]:.4f}')
    print(f'[final] ensemble    in-dist val mean_nrmse={m_ens["mean_nrmse_std"]:.4f}')

    state = states[best]
    out_dir = APP / 'outputs'; out_dir.mkdir(parents=True, exist_ok=True)
    torch.save({
        'state_dict': {k: v.cpu() for k, v in state.items()},
        'feat_me
…[truncated]

cd /app && python3 -c "
import final_train as ft
ft.CONFIG['epochs']=2
ft.SEEDS=[0,1]
ft.main()
" 2>&1 | tail -20

command: create
path: /app/verify.py
file_text: """Grader-style verification: load the checkpoint strictly into the pinned
architecture, run a forward pass on public_test, de-standardize, sanity-check."""
from __future__ import annotations
import json, sys
from pathlib import Path
import torch

APP = Path('/app'); sys.path.insert(0, str(APP))
from candidate_model import build_model
from dataset import load_split

cfg = json.load(open(APP / 'task_config.json'))
ckpt = torch.load(APP / 'outputs' / 'model.pt', weights_only=True)

assert set(['state_dict', 'feat_mean', 'feat_std', 'targ_mean', 'targ_std']).issubset(ckpt), 'missing keys'
for k, n in [('feat_mean', 4), ('feat_std', 4), ('targ_mean', 2), ('targ_std', 2)]:
    t = ckpt[k]; assert tuple(t.shape) == (n,), f'{k} shape {t.shape}'
    assert torch.isfinite(t).all(), f'{k} not finite'
assert (ckpt['feat_std'] > 0).all() and (ckpt['targ_std'] > 0).all(), 'non-positive std'

model = build_model(cfg)
missing, unexpected = model.load_state_dict(ckpt['state_dict'], strict=True)
print('strict load OK; missing=', missing, 'unexpected=', unexpected)
model.eval()

fmean = ckpt['feat_mean'].view(1, 1, -1); fstd = ckpt['feat_std'].view(1, 1, -1)
tmean = ckpt['targ_mean'].view(1, -1); tstd = ckpt['targ_std'].view(1, -1)

for split in ['val', 'public_test']:
    pts, tgt = load_split(APP / 'data' / split)
    with torch.no_grad():
        out = model((pts - fmean) / fstd) * tstd + tmean
    print(f'== {split} (n={pts.shape[0]}) ==')
    print('  pred C_D: min=%.4f max=%.4f mean=%.4f' % (out[:, 0].min(), out[:, 0].max(), out[:, 0].mean()))
    print('  pred C_L: min=%.4f max=%.4f mean=%.4f' % (out[:, 1].min(), out[:, 1].max(), out[:, 1].mean()))
    assert torch.isfinite(out).all()
    if tgt is not None:
        import numpy as np
        for i, nm in enumerate(['C_D', 'C_L']):
            err = (out[:, i] - tgt[:, i]).numpy()
            rmse = float((err ** 2).mean() ** 0.5)
            nrmse = rmse / float(tgt[:, i].std())
            print(f'  {nm}: rmse={rmse:.5f} nrmse_std={nrmse:.4f}')
print('VERIFY OK')

cd /app && python3 verify.py 2>&1 | tail -25

cd /app && export OMP_NUM_THREADS=16 && nohup python3 final_train.py > final.log 2>&1 &
echo "started final training pid $!"; sleep 5; cat final.log

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

cd /app && sleep 175 && cat final.log

cd /app && python3 verify.py 2>&1 | tail -25

cd /app && python3 -c "
import json, torch, numpy as np, sys
sys.path.insert(0,'.')
from candidate_model import build_model
from dataset import load_split
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,_=load_split('data/public_test')
def pred(p):
    with torch.no_grad(): return (m((p-fm)/fs)*ts+tm)
# take 8 cases, sweep velocity 70..95, report mean predicted CD, CL trend
base=pts[:8].clone()
print('vel   meanC_D   meanC_L   (sweep on 8 public_test cases)')
cds=[]
for v in [65,70,75,80,85,90,95]:
    p=base.clone(); p[:,:,2]=v
    o=pred(p); cds.append(o[:,0].mean().item())
    print(f'{v:3d}   {o[:,0].mean():.5f}   {o[:,1].mean():.4f}')
# compare CD ratio 75->90 to reynolds f^-0.21
r=(cds[5]/cds[2]); print('CD(90)/CD(75)=%.3f  ideal (90/75)^-0.21=%.3f'%(r,(90/75)**-0.21))
print('check predictions finite & positive CD across sweep:', all(c>0 for c in cds))
"

cd /app && ls -la outputs/ && python3 -c "
import torch
ck=torch.load('outputs/model.pt', weights_only=True)
print('keys:', list(ck.keys()))
for k in ['feat_mean','feat_std','targ_mean','targ_std']:
    print(f'  {k}: shape={tuple(ck[k].shape)} dtype={ck[k].dtype} vals={[round(float(x),4) for x in ck[k]]}')
print('state_dict tensors:', len(ck['state_dict']))
print('total params:', sum(v.numel() for v in ck['state_dict'].values() if v.dtype.is_floating_point))
"