airfoil-self-noise

cat /app/train_and_predict.py

cd /app && ls -la data/ && echo "---TRAIN---" && head -5 data/train.csv && echo "..." && wc -l data/train.csv && echo "---VALIDATION---" && head -5 data/validation.csv && wc -l data/validation.csv && echo "---TEST---" && head -5 data/test_features.csv && wc -l data/test_features.csv

cd /app && python3 -c "
import sys
print('python', sys.version)
for m in ['numpy','pandas','sklearn','scipy','xgboost','lightgbm','catboost','torch']:
    try:
        mod=__import__(m)
        print(m, getattr(mod,'__version__','?'))
    except Exception as e:
        print(m, 'NOT AVAILABLE')
"

cd /app && python3 -c "
import pandas as pd, numpy as np
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
print('train shape', tr.shape, 'val shape', va.shape)
print()
print('TRAIN describe:')
print(tr.describe().T)
print()
print('target stats train:', tr['scaled_sound_pressure_level'].min(), tr['scaled_sound_pressure_level'].max(), tr['scaled_sound_pressure_level'].mean(), tr['scaled_sound_pressure_level'].std())
print('target stats val:  ', va['scaled_sound_pressure_level'].min(), va['scaled_sound_pressure_level'].max(), va['scaled_sound_pressure_level'].mean(), va['scaled_sound_pressure_level'].std())
"

cd /app && python3 -c "
import pandas as pd, numpy as np
pd.set_option('display.width',200)
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
feats=['frequency','attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']
for c in feats:
    print(c, 'n_unique train', tr[c].nunique(), 'val', va[c].nunique())
print()
# Condition = (attack_angle, chord_length, free_stream_velocity)
def cond(df):
    return set(zip(np.round(df['attack_angle'],3), np.round(df['chord_length'],5), np.round(df['free_stream_velocity'],2)))
ctr=cond(tr); cva=cond(va)
print('n conditions train (rounded)', len(ctr))
print('n conditions val (rounded)', len(cva))
print('overlap', len(ctr & cva))
"

cd /app && python3 -c "
import pandas as pd, numpy as np
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
alld=pd.concat([tr,va],ignore_index=True)
for c in ['chord_length','free_stream_velocity']:
    v=np.sort(alld[c].values)
    print('===',c,'===')
    # find gaps
    d=np.diff(v)
    # cluster by gap threshold
    thr=(v.max()-v.min())*0.02
    groups=[]; cur=[v[0]]
    for i in range(1,len(v)):
        if v[i]-v[i-1]>thr:
            groups.append(cur); cur=[v[i]]
        else:
            cur.append(v[i])
    groups.append(cur)
    print('n clusters', len(groups))
    for g in groups:
        print(f'  center={np.mean(g):.5f} n={len(g)} min={min(g):.5f} max={max(g):.5f} spread={max(g)-min(g):.6f}')
"

cd /app && python3 -c "
import pandas as pd, numpy as np
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
alld=pd.concat([tr,va],ignore_index=True)
c='attack_angle'
v=np.sort(alld[c].values)
thr=0.2
groups=[]; cur=[v[0]]
for i in range(1,len(v)):
    if v[i]-v[i-1]>thr:
        groups.append(cur); cur=[v[i]]
    else:
        cur.append(v[i])
groups.append(cur)
print('n clusters', len(groups))
for g in groups:
    print(f'  center={np.mean(g):.4f} n={len(g)} spread={max(g)-min(g):.4f}')
"

cd /app && python3 -c "
import pandas as pd, numpy as np
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')

def snap1d(values, thr_rel=0.01, thr_abs=0.15):
    # cluster sorted values, return mapping array of cluster centers
    order=np.argsort(values); v=values[order]
    centers=np.empty_len=len(v)
    labels=np.empty(len(v),dtype=int)
    cur=0; start=0
    rng=v.max()-v.min()
    thr=max(rng*thr_rel, thr_abs)
    for i in range(1,len(v)):
        if v[i]-v[i-1]>thr:
            cur+=1
        labels[i]=cur
    out=np.empty(len(v))
    res=np.empty(len(values))
    for lab in range(cur+1):
        mask=labels==lab
        c=v[mask].mean()
        res[order[mask]]=c
    return res

alld=pd.concat([tr,va],ignore_index=True)
for c,thr in [('attack_angle',0.12),('chord_length',0.005),('free_stream_velocity',0.5)]:
    alld[c+'_s']=snap1d(alld[c].values, thr_rel=0.0, thr_abs=thr)
alld['cond']=list(zip(np.round(alld['attack_angle_s'],3),np.round(alld['chord_length_s'],5),np.round(alld['free_stream_velocity_s'],2)))
ntr=len(tr)
ctr=set(alld['cond'][:ntr]); cva=set(alld['cond'][ntr:])
print('n cond train', len(ctr), 'n cond val', len(cva), 'overlap', len(ctr&cva))
print('total distinct conditions', len(ctr|cva))
# rows per condition in val
from collections import Counter
cc=Counter(alld['cond'][ntr:])
print('val rows per condition: min',min(cc.values()),'max',max(cc.values()),'mean',np.mean(list(cc.values())))
print('n val conditions', len(cc))
"

cd /app && python3 -c "
import pandas as pd, numpy as np
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
def snap1d(values, thr):
    order=np.argsort(values); v=values[order]; labels=np.zeros(len(v),dtype=int); cur=0
    for i in range(1,len(v)):
        if v[i]-v[i-1]>thr: cur+=1
        labels[i]=cur
    res=np.empty(len(values))
    for lab in range(cur+1):
        m=labels==lab; res[order[m]]=v[m].mean()
    return res
alld=pd.concat([tr,va],ignore_index=True)
for c,thr in [('attack_angle',0.12),('chord_length',0.005),('free_stream_velocity',0.5)]:
    alld[c+'_s']=snap1d(alld[c].values,thr)
alld['cond']=list(zip(np.round(alld['attack_angle_s'],3),np.round(alld['chord_length_s'],5),np.round(alld['free_stream_velocity_s'],2)))
# within condition, how much does thickness vary relative to mean?
g=alld.groupby('cond')['suction_side_displacement_thickness']
rel=(g.std()/g.mean()).dropna()
print('within-condition thickness rel-std: median',rel.median(),'max',rel.max())
# how many freq per condition
print('freqs per cond: mean', alld.groupby('cond').size().mean())
# Does thickness map 1:1 to condition? check unique thickness snapped per cond
print()
# range of freq
print('freq range', alld['frequency'].min(), alld['frequency'].max())
"

cd /app && cat > /app/harness.py << 'PY'
import numpy as np, pandas as pd
from pathlib import Path

DATA_DIR = Path("/app/data")
TARGET = "scaled_sound_pressure_level"
FEATURES = ["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]

def snap1d(values, thr):
    order=np.argsort(values); v=values[order]; labels=np.zeros(len(v),dtype=int); cur=0
    for i in range(1,len(v)):
        if v[i]-v[i-1]>thr: cur+=1
        labels[i]=cur
    res=np.empty(len(values))
    for lab in range(cur+1):
        m=labels==lab; res[order[m]]=v[m].mean()
    return res

def add_conditions(df):
    df=df.copy()
    a=snap1d(df['attack_angle'].values,0.12)
    c=snap1d(df['chord_length'].values,0.005)
    v=snap1d(df['free_stream_velocity'].values,0.5)
    df['cond']=list(zip(np.round(a,3),np.round(c,5),np.round(v,2)))
    return df

def metrics(y_true, y_pred, cond):
    y_true=np.asarray(y_true,float); y_pred=np.asarray(y_pred,float)
    err=y_pred-y_true
    rmse=np.sqrt(np.mean(err**2)); mae=np.mean(np.abs(err))
    dfc=pd.DataFrame({'e':err,'c':cond})
    per=dfc.groupby('c')['e'].apply(lambda s: np.sqrt(np.mean(s.values**2)))
    return {
        'rmse':rmse,'mae':mae,
        'p90':np.percentile(per.values,90),
        'p95':np.percentile(per.values,95),
        'max':per.max(),
        'n_cond':len(per),
    }

TARGETS={'rmse':2.25,'mae':1.55,'p90':2.35,'p95':4.75,'max':5.60}

def report(name, m):
    flags=''.join('OK ' if m[k]<=TARGETS[k] else 'XX ' for k in ['rmse','mae','p90','p95','max'])
    print(f"{name:28s} rmse={m['rmse']:.3f} mae={m['mae']:.3f} p90={m['p90']:.3f} p95={m['p95']:.3f} max={m['max']:.3f} | {flags}")

def load():
    tr=pd.read_csv(DATA_DIR/'train.csv'); va=pd.read_csv(DATA_DIR/'validation.csv')
    return tr,va
PY
echo written

cd /app && cat > /app/exp.py << 'PY'
import numpy as np, pandas as pd
from harness import *
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, HistGradientBoostingRegressor, GradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
from sklearn.svm import SVR

def fe(df):
    f=df['frequency'].astype(float); a=df['attack_angle'].astype(float)
    c=df['chord_length'].astype(float); v=df['free_stream_velocity'].astype(float)
    t=df['suction_side_displacement_thickness'].astype(float)
    lf=np.log10(f); lt=np.log10(t); lc=np.log10(c)
    out=pd.DataFrame(index=df.index)
    out['lf']=lf; out['a']=a; out['lc']=lc; out['v']=v; out['lt']=lt
    out['c']=c; out['f']=f; out['t']=t
    # strouhal-like
    out['st']=lf+lt  # log(f*delta)
    out['st2']=lf+lt-np.log10(v)
    out['lf2']=lf**2; out['lf3']=lf**3
    out['a_lf']=a*lf; out['a2']=a**2
    out['lc_lf']=lc*lf; out['lt_lf']=lt*lf
    out['v_lf']=v*lf
    out['mach']=v/340.0
    return out.values

tr,va=load()
va=add_conditions(va)
Xtr=fe(tr); ytr=tr[TARGET].values
Xva=fe(va); yva=va[TARGET].values

models={
 'Ridge': make_pipeline(StandardScaler(),Ridge(alpha=10.0)),
 'RF': RandomForestRegressor(n_estimators=400,min_samples_leaf=2,n_jobs=-1,random_state=0),
 'ExtraTrees': ExtraTreesRegressor(n_estimators=500,min_samples_leaf=1,n_jobs=-1,random_state=0),
 'HGB': HistGradientBoostingRegressor(max_iter=500,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0),
 'GBR': GradientBoostingRegressor(n_estimators=500,learning_rate=0.05,max_depth=3,subsample=0.8,random_state=0),
 'MLP': make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),activation='relu',alpha=1e-3,max_iter=2000,random_state=0)),
 'SVR': make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.1)),
}
for name,mdl in models.items():
    mdl.fit(Xtr,ytr)
    p=mdl.predict(Xva)
    report(name, metrics(yva,p,va['cond'].values))
PY
python3 /app/exp.py

cd /app && python3 -c "
import numpy as np, pandas as pd
from harness import *
from exp import fe
from sklearn.ensemble import ExtraTreesRegressor
tr,va=load(); va=add_conditions(va)
Xtr=fe(tr); ytr=tr[TARGET].values; Xva=fe(va); yva=va[TARGET].values
m=ExtraTreesRegressor(n_estimators=500,min_samples_leaf=1,n_jobs=-1,random_state=0).fit(Xtr,ytr)
p=m.predict(Xva)
va=va.copy(); va['e']=p-yva
per=va.groupby('cond').apply(lambda d: pd.Series({'rmse':np.sqrt(np.mean(d['e']**2)),'n':len(d),'mean_spl':d[TARGET].mean(),'ang':d['attack_angle'].mean(),'chord':d['chord_length'].mean(),'vel':d['free_stream_velocity'].mean()}))
per=per.sort_values('rmse',ascending=False)
pd.set_option('display.width',200)
print(per)
"

cd /app && cat > /app/cv.py << 'PY'
import numpy as np, pandas as pd
from harness import *
from exp import fe
from sklearn.model_selection import GroupKFold

def get_all():
    tr,va=load()
    alld=pd.concat([tr,va],ignore_index=True)
    alld=add_conditions(alld)
    return alld

def cv_eval(make_model, n_splits=10, seed=0, transform=fe, verbose=True):
    alld=get_all()
    X=transform(alld); y=alld[TARGET].values
    groups=alld['cond'].values
    uniq=pd.unique(groups)
    # map conditions to folds
    rng=np.random.RandomState(seed)
    perm=rng.permutation(len(uniq))
    fold_of={c:(i%n_splits) for i,c in enumerate(uniq[perm])}
    folds=np.array([fold_of[c] for c in groups])
    oof=np.zeros(len(y))
    for f in range(n_splits):
        trm=folds!=f; tem=folds==f
        m=make_model()
        m.fit(X[trm],y[trm])
        oof[tem]=m.predict(X[tem])
    mt=metrics(y,oof,groups)
    return mt, oof, alld

if __name__=='__main__':
    from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor, RandomForestRegressor
    mk={
      'ExtraTrees': lambda: ExtraTreesRegressor(n_estimators=500,min_samples_leaf=1,n_jobs=-1,random_state=0),
      'ET_leaf2': lambda: ExtraTreesRegressor(n_estimators=500,min_samples_leaf=2,n_jobs=-1,random_state=0),
      'HGB': lambda: HistGradientBoostingRegressor(max_iter=500,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0),
      'RF': lambda: RandomForestRegressor(n_estimators=400,min_samples_leaf=2,n_jobs=-1,random_state=0),
    }
    for name,f in mk.items():
        mt,_,_=cv_eval(f)
        report(name+' [CV]', mt)
PY
python3 /app/cv.py

cd /app && cat >> /app/harness.py << 'PY'

def fe2(df):
    f=df['frequency'].astype(float).values; a=df['attack_angle'].astype(float).values
    c=df['chord_length'].astype(float).values; v=df['free_stream_velocity'].astype(float).values
    t=df['suction_side_displacement_thickness'].astype(float).values
    lf=np.log10(f); lt=np.log10(t); lc=np.log10(c); lv=np.log10(v)
    out={}
    out['lf']=lf; out['a']=a; out['lc']=lc; out['v']=v; out['lt']=lt
    out['c']=c; out['t']=t
    # physics ratios (logs) -- help tree models that cannot form ratios
    out['st_delta']=lf+lt           # log(f*delta)
    out['st_delta_U']=lf+lt-lv      # log(f*delta/U)  Strouhal
    out['st_chord']=lf+lc           # log(f*c)
    out['st_chord_U']=lf+lc-lv      # log(f*c/U)
    out['delta_c']=lt-lc            # log(delta/c)
    out['Re_c']=lc+lv               # log(c*U)  ~ Reynolds_chord
    out['Re_delta']=lt+lv           # log(delta*U)
    out['mach']=v/340.0
    # nonlinearity in freq & angle
    out['lf2']=lf**2; out['lf3']=lf**3
    out['a2']=a**2; out['a_lf']=a*lf
    out['st_delta_U2']=out['st_delta_U']**2
    out['a_st']=a*out['st_delta_U']
    return np.column_stack([out[k] for k in out])
PY
cat > /app/cv2.py << 'PY'
import numpy as np, pandas as pd
from harness import *
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor, RandomForestRegressor

def get_all():
    tr,va=load(); alld=pd.concat([tr,va],ignore_index=True); return add_conditions(alld)

def cv_eval(make_model, transform, n_splits=10, seed=0):
    alld=get_all(); X=transform(alld); y=alld[TARGET].values; groups=alld['cond'].values
    uniq=pd.unique(groups); rng=np.random.RandomState(seed); perm=rng.permutation(len(uniq))
    fold_of={c:(i%n_splits) for i,c in enumerate(uniq[perm])}
    folds=np.array([fold_of[c] for c in groups]); oof=np.zeros(len(y))
    for f in range(n_splits):
        trm=folds!=f; tem=folds==f
        m=make_model(); m.fit(X[trm],y[trm]); oof[tem]=m.predict(X[tem])
    return metrics(y,oof,groups), oof, alld

if __name__=='__main__':
    for tname,tf in [('fe2',fe2)]:
        for name,f in {
          'ExtraTrees': lambda: ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=0),
          'HGB': lambda: HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0),
          'RF': lambda: RandomForestRegressor(n_estimators=500,min_samples_leaf=2,n_jobs=-1,random_state=0),
        }.items():
            mt,_,_=cv_eval(f,tf); report(f'{name} [{tname}]',mt)
PY
python3 /app/cv2.py

cd /app && cat > /app/cv3.py << 'PY'
import numpy as np, pandas as pd
from harness import *
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor, RandomForestRegressor, GradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR
from sklearn.neighbors import KNeighborsRegressor

def get_all():
    tr,va=load(); alld=pd.concat([tr,va],ignore_index=True); return add_conditions(alld)

ALL=get_all()
GROUPS=ALL['cond'].values
Y=ALL[TARGET].values

def make_folds(n_splits,seed):
    uniq=pd.unique(GROUPS); rng=np.random.RandomState(seed); perm=rng.permutation(len(uniq))
    fold_of={c:(i%n_splits) for i,c in enumerate(uniq[perm])}
    return np.array([fold_of[c] for c in GROUPS])

def cv_oof(builders, transform, n_splits=10, seed=0, weights=None):
    # builders: list of (callable->model, transform) OR use shared transform
    X=transform(ALL); y=Y; folds=make_folds(n_splits,seed)
    preds=np.zeros((len(y),len(builders)))
    for f in range(n_splits):
        trm=folds!=f; tem=folds==f
        for j,b in enumerate(builders):
            m=b(); m.fit(X[trm],y[trm]); preds[tem,j]=m.predict(X[tem])
    if weights is None: weights=np.ones(len(builders))
    weights=np.array(weights,float); weights/=weights.sum()
    oof=preds@weights
    return metrics(y,oof,GROUPS), oof, preds

def et(seed=0,**k): return ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=seed,**k)
def hgb(seed=0,**k): return HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=seed,**k)
def gbr(seed=0,**k): return GradientBoostingRegressor(n_estimators=500,learning_rate=0.05,max_depth=3,subsample=0.8,random_state=seed,**k)
def mlp(seed=0): return make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),alpha=1e-3,max_iter=3000,random_state=seed))
def svr(): return make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.1))
def knn(): return make_pipeline(StandardScaler(),KNeighborsRegressor(n_neighbors=7,weights='distance'))

if __name__=='__main__':
    # single ET baseline
    report('ET', cv_oof([lambda:et(0)], fe2)[0])
    # ET + HGB
    report('ET+HGB', cv_oof([lambda:et(0), lambda:hgb(0)], fe2, weights=[2,1])[0])
    # ET + HGB + GBR
    report('ET+HGB+GBR', cv_oof([lambda:et(0), lambda:hgb(0), lambda:gbr(0)], fe2, weights=[2,1,1])[0])
    # ET + HGB + MLP
    report('ET+HGB+MLP', cv_oof([lambda:et(0), lambda:hgb(0), lambda:mlp(0)], fe2, weights=[2,1,1])[0])
    # ET + HGB + SVR + KNN
    report('ET+HGB+SVR+KNN', cv_oof([lambda:et(0), lambda:hgb(0), svr, knn], fe2, weights=[3,1,1,1])[0])
PY
python3 /app/cv3.py

restart: true

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd
from harness import *
from cv3 import cv_oof, et, hgb, ALL, GROUPS, Y
mt,oof,_=cv_oof([lambda:et(0), lambda:hgb(0)], fe2, weights=[2,1])
report('ET+HGB',mt)
df=ALL.copy(); df['e']=oof-Y
per=df.groupby('cond')['e'].agg(['mean','std','count'])
per['rmse']=np.sqrt(per['mean']**2+per['std']**2)
per['bias2']=per['mean']**2; per['var']=per['std']**2
per=per.sort_values('rmse',ascending=False)
pd.set_option('display.width',200)
print(per.head(12))
# overall: how much of MSE is bias vs variance across worst conditions
top=per.head(12)
print('among worst 12: mean bias^2', top['bias2'].mean(), 'mean var', top['var'].mean())
print('fraction of RMSE^2 from bias (worst12):', top['bias2'].sum()/(top['bias2'].sum()+top['var'].sum()))
"

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd
from harness import *
from cv3 import cv_oof, et, hgb, ALL, GROUPS, Y
mt,oof,_=cv_oof([lambda:et(0), lambda:hgb(0)], fe2, weights=[2,1])
df=ALL.copy(); df['e']=oof-Y
per=df.groupby('cond')['e'].apply(lambda s:np.sqrt(np.mean(s.values**2))).sort_values()
print('n conditions', len(per))
for thr in [1.0,1.5,2.0,2.35,3.0,4.0]:
    print(f'  frac RMSE<= {thr}: {(per<=thr).mean():.3f}  count {(per<=thr).sum()}')
print('percentiles: p50 %.3f p75 %.3f p90 %.3f p95 %.3f'%(np.percentile(per,50),np.percentile(per,75),np.percentile(per,90),np.percentile(per,95)))
# Are the worst conditions the high-angle / edge ones? tabulate by angle bin
df2=ALL.drop_duplicates('cond')[['cond','attack_angle','chord_length','free_stream_velocity']].set_index('cond')
per=per.to_frame('rmse').join(df2)
print()
print('corr rmse vs |angle|:', np.corrcoef(per['rmse'], per['attack_angle'])[0,1])
print('mean rmse angle>12:', per[per['attack_angle']>12]['rmse'].mean(), 'n', (per['attack_angle']>12).sum())
print('mean rmse angle<=12:', per[per['attack_angle']<=12]['rmse'].mean(), 'n', (per['attack_angle']<=12).sum())
"

cd /app && cat >> /app/harness.py << 'PY'

def fe3(df):
    f=df['frequency'].astype(float).values; a=df['attack_angle'].astype(float).values
    c=df['chord_length'].astype(float).values; v=df['free_stream_velocity'].astype(float).values
    t=df['suction_side_displacement_thickness'].astype(float).values
    lf=np.log10(f); lt=np.log10(t); lc=np.log10(c); lv=np.log10(v)
    st=lf+lt-lv     # strouhal (delta)
    stc=lf+lc-lv    # strouhal (chord)
    o={}
    o['lf']=lf; o['a']=a; o['lc']=lc; o['v']=v; o['lt']=lt; o['c']=c; o['t']=t
    o['st_delta']=lf+lt; o['st']=st; o['st_chord']=stc; o['st_chord_abs']=lf+lc
    o['delta_c']=lt-lc; o['Re_c']=lc+lv; o['Re_delta']=lt+lv; o['mach']=v/340.0
    o['lf2']=lf**2; o['lf3']=lf**3
    o['a2']=a**2; o['a3']=a**3
    o['a_lf']=a*lf; o['a_st']=a*st; o['a_stc']=a*stc
    o['a_lc']=a*lc; o['a_lv']=a*lv; o['a_lt']=a*lt
    o['st2']=st**2; o['st3']=st**3
    o['a2_st']=a**2*st
    o['delta_a']=lt*a
    return np.column_stack([o[k] for k in o])
PY
timeout 250 python3 -c "
from harness import *
from cv3 import cv_oof, et, hgb
for nm,tf in [('fe2',fe2),('fe3',fe3)]:
    report('ET '+nm, cv_oof([lambda:et(0)], tf)[0])
    report('ET+HGB '+nm, cv_oof([lambda:et(0),lambda:hgb(0)], tf, weights=[2,1])[0])
"

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd
from harness import *
from cv3 import cv_oof, et, hgb, ALL, GROUPS, Y
mt,oof,_=cv_oof([lambda:et(0),lambda:hgb(0)], fe2, weights=[2,1])
report('raw ET+HGB',mt)
lf=np.log10(ALL['frequency'].values)

def smooth(oof, deg, blend=1.0):
    out=oof.copy()
    for c in pd.unique(GROUPS):
        m=GROUPS==c
        x=lf[m]; yv=oof[m]
        if m.sum()>=deg+2 and x.max()-x.min()>1e-6:
            d=min(deg, m.sum()-1)
            coef=np.polyfit(x,yv,d)
            fit=np.polyval(coef,x)
            out[m]=blend*fit+(1-blend)*yv
    return out

for deg in [2,3,4,5]:
    s=smooth(oof,deg,1.0)
    report(f'smooth deg{deg}', metrics(Y,s,GROUPS))
for bl in [0.5,0.7]:
    s=smooth(oof,3,bl)
    report(f'smooth deg3 blend{bl}', metrics(Y,s,GROUPS))
"

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd
from harness import *
from cv3 import cv_oof, et, hgb, ALL, GROUPS, Y
mt,oof,_=cv_oof([lambda:et(0),lambda:hgb(0)], fe2, weights=[2,1])
report('raw ET+HGB',mt)
lf=np.log10(ALL['frequency'].values)

def smooth(oof, deg, blend=1.0):
    out=oof.copy()
    for c in pd.unique(GROUPS):
        idx=np.where(GROUPS==c)[0]
        x=lf[idx]; yv=oof[idx]
        if len(idx)>=deg+2 and x.max()-x.min()>1e-6:
            coef=np.polyfit(x,yv,deg)
            fit=np.polyval(coef,x)
            out[idx]=blend*fit+(1-blend)*yv
    return out

for deg in [2,3,4,5]:
    report(f'smooth deg{deg}', metrics(Y,smooth(oof,deg,1.0),GROUPS))
for bl in [0.5,0.6,0.75]:
    report(f'smooth deg4 blend{bl}', metrics(Y,smooth(oof,4,bl),GROUPS))
"

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd
from harness import *
from cv3 import cv_oof, et, hgb, ALL, GROUPS, Y
mt,oof,_=cv_oof([lambda:et(0),lambda:hgb(0)], fe2, weights=[2,1])
report('raw ET+HGB',mt)
lf=np.log10(ALL['frequency'].values)
groups_idx=list(pd.Series(range(len(GROUPS))).groupby(ALL['cond'].values).apply(list))

def smooth(oof, deg, blend=1.0):
    out=oof.copy()
    for idx in groups_idx:
        idx=np.array(idx); x=lf[idx]; yv=oof[idx]
        if len(idx)>=deg+2 and x.max()-x.min()>1e-6:
            coef=np.polyfit(x,yv,deg); fit=np.polyval(coef,x)
            out[idx]=blend*fit+(1-blend)*yv
    return out

for deg in [2,3,4,5,6]:
    report(f'smooth deg{deg}', metrics(Y,smooth(oof,deg,1.0),GROUPS))
for bl in [0.5,0.7]:
    report(f'smooth deg4 bl{bl}', metrics(Y,smooth(oof,4,bl),GROUPS))
" 2>&1 | grep -v Warning

cd /app && cat > /app/mlp_test.py << 'PY'
import numpy as np, pandas as pd
from harness import *
from sklearn.base import BaseEstimator, RegressorMixin, clone
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from cv3 import cv_oof, et, hgb

class BaggedMLP(BaseEstimator, RegressorMixin):
    def __init__(self, hidden=(128,64), alpha=1e-3, n=5, activation='relu', max_iter=800, seed=0):
        self.hidden=hidden; self.alpha=alpha; self.n=n; self.activation=activation; self.max_iter=max_iter; self.seed=seed
    def fit(self,X,y):
        self.models_=[]
        for i in range(self.n):
            m=make_pipeline(StandardScaler(), MLPRegressor(hidden_layer_sizes=self.hidden, alpha=self.alpha,
                activation=self.activation, max_iter=self.max_iter, random_state=self.seed+i,
                early_stopping=True, n_iter_no_change=20, validation_fraction=0.1))
            m.fit(X,y); self.models_.append(m)
        return self
    def predict(self,X):
        return np.mean([m.predict(X) for m in self.models_],axis=0)

if __name__=='__main__':
    import sys
    configs=[
      ('MLP relu(128,64) a1e-3', lambda: BaggedMLP((128,64),1e-3,5,'relu')),
      ('MLP tanh(128,64) a1e-3', lambda: BaggedMLP((128,64),1e-3,5,'tanh')),
      ('MLP relu(256,128,64) a1e-3', lambda: BaggedMLP((256,128,64),1e-3,5,'relu')),
    ]
    for nm,b in configs:
        report(nm, cv_oof([b], fe2, n_splits=8)[0])
PY
timeout 280 python3 /app/mlp_test.py 2>&1 | grep -v Warning

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd, time
from harness import *
from mlp_test import BaggedMLP
tr,va=load(); va=add_conditions(va)
Xtr=fe2(tr); ytr=tr[TARGET].values; Xva=fe2(va); yva=va[TARGET].values
for nm,mk in [
  ('relu(128,64) x5', lambda:BaggedMLP((128,64),1e-3,5,'relu',800)),
  ('tanh(128,64) x5', lambda:BaggedMLP((128,64),1e-3,5,'tanh',800)),
  ('relu(200,100) x5', lambda:BaggedMLP((200,100),3e-4,5,'relu',800)),
]:
    t=time.time(); m=mk().fit(Xtr,ytr); p=m.predict(Xva)
    report(nm+f' [{time.time()-t:.0f}s]', metrics(yva,p,va['cond'].values))
" 2>&1 | grep -v Warning

cd /app && timeout 100 python3 -c "
import numpy as np, pandas as pd
from harness import *
tr,va=load(); alld=add_conditions(pd.concat([tr,va],ignore_index=True))
# pick 3 conditions with many rows, show SPL vs freq sorted
cnts=alld['cond'].value_counts()
for c in list(cnts.index[:3]):
    d=alld[alld['cond']==c].sort_values('frequency')
    print('cond',c,'n',len(d))
    spl=d['scaled_sound_pressure_level'].values
    lf=np.log10(d['frequency'].values)
    # smoothness: residual from cubic fit
    coef=np.polyfit(lf,spl,3); res=spl-np.polyval(coef,lf)
    print('  SPL range %.1f..%.1f, cubic-fit resid std %.3f'%(spl.min(),spl.max(),res.std()))
    print('  freqs:', np.round(d['frequency'].values[:8]).astype(int))
    print('  spl  :', np.round(spl[:8],1))
"

cd /app && timeout 280 python3 -c "
import numpy as np, pandas as pd
from harness import *
from sklearn.ensemble import ExtraTreesRegressor
from cv3 import cv_oof
def mk(msl,mf,boot,ms):
    def f():
        kw=dict(n_estimators=500,min_samples_leaf=msl,max_features=mf,n_jobs=-1,random_state=0,bootstrap=boot)
        if boot: kw['max_samples']=ms
        return ExtraTreesRegressor(**kw)
    return f
for msl in [1,2,3]:
    for mf in [0.5,0.7,1.0]:
        report(f'ET msl{msl} mf{mf}', cv_oof([mk(msl,mf,False,None)], fe2)[0])
" 2>&1 | grep -v Warning

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd, time, warnings
warnings.filterwarnings('ignore')
from harness import *
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C, WhiteKernel, Matern
from sklearn.preprocessing import StandardScaler
tr,va=load(); va=add_conditions(va)
Xtr=fe2(tr); ytr=tr[TARGET].values; Xva=fe2(va); yva=va[TARGET].values
sc=StandardScaler().fit(Xtr); Xtr2=sc.transform(Xtr); Xva2=sc.transform(Xva)
ym=ytr.mean()
d=Xtr2.shape[1]
for nm,kern in [
  ('RBF iso', C(50)*RBF(2.0)+WhiteKernel(1.0)),
  ('RBF ard', C(50)*RBF([2.0]*d)+WhiteKernel(1.0)),
  ('Matern1.5 ard', C(50)*Matern([2.0]*d,nu=1.5)+WhiteKernel(1.0)),
]:
    t=time.time()
    gp=GaussianProcessRegressor(kernel=kern,normalize_y=True,n_restarts_optimizer=0,alpha=1e-6)
    gp.fit(Xtr2,ytr); p=gp.predict(Xva2)
    report(nm+f' [{time.time()-t:.0f}s]', metrics(yva,p,va['cond'].values))
"

cd /app && cat > /app/oof_bank.py << 'PY'
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor, RandomForestRegressor, GradientBoostingRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.neighbors import KNeighborsRegressor
from sklearn.kernel_ridge import KernelRidge

tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
GROUPS=ALL['cond'].values; Y=ALL[TARGET].values
uniq=pd.unique(GROUPS)
rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10
fold_of={c:(i%NS) for i,c in enumerate(uniq[perm])}
FOLDS=np.array([fold_of[c] for c in GROUPS])

def oof_for(build, transform):
    X=transform(ALL); oof=np.zeros(len(Y))
    for f in range(NS):
        trm=FOLDS!=f; tem=FOLDS==f
        m=build(); m.fit(X[trm],Y[trm]); oof[tem]=m.predict(X[tem])
    return oof

bank={}
defs={
 'et2': (lambda:ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=0), fe2),
 'et2b':(lambda:ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=1,max_features=0.7), fe2),
 'et3': (lambda:ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=0), fe3),
 'hgb': (lambda:HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0), fe2),
 'rf':  (lambda:RandomForestRegressor(n_estimators=500,min_samples_leaf=2,n_jobs=-1,random_state=0), fe2),
 'gbr': (lambda:GradientBoostingRegressor(n_estimators=500,learning_rate=0.05,max_depth=3,subsample=0.8,random_state=0), fe2),
 'poly2':(lambda:make_pipeline(StandardScaler(),PolynomialFeatures(2),Ridge(alpha=5.0)), fe2),
 'poly3':(lambda:make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)), fe2),
 'knn':  (lambda:make_pipeline(StandardScaler(),KNeighborsRegressor(n_neighbors=10,weights='distance')), fe2),
 'krr':  (lambda:make_pipeline(StandardScaler(),KernelRidge(alpha=0.5,kernel='rbf',gamma=0.05)), fe2),
}
for nm,(b,tf) in defs.items():
    bank[nm]=oof_for(b,tf)
    report(nm, metrics(Y,bank[nm],GROUPS))
pickle.dump({'bank':bank,'Y':Y,'GROUPS':GROUPS}, open('/app/oof.pkl','wb'))
print('saved', list(bank))
PY
timeout 290 python3 /app/oof_bank.py 2>&1 | grep -v Warning

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd, pickle, itertools
from harness import metrics, report, TARGETS
d=pickle.load(open('/app/oof.pkl','rb')); bank=d['bank']; Y=d['Y']; G=d['GROUPS']
keys=['et2','et3','et2b','hgb','rf','gbr','poly3','knn']
M=np.column_stack([bank[k] for k in keys])
rng=np.random.RandomState(0)
best=None
# include zero weights; random Dirichlet-ish search
for _ in range(40000):
    w=rng.rand(len(keys))
    w=np.where(rng.rand(len(keys))<0.5,0,w)  # sparsify
    if w.sum()==0: continue
    w=w/w.sum()
    p=M@w
    m=metrics(Y,p,G)
    # score: must pass all; minimize p90 primarily then rmse
    ok=all(m[k]<=TARGETS[k] for k in TARGETS)
    score=(0 if ok else 1, m['p90'], m['rmse'])
    if best is None or score<best[0]:
        best=(score,w.copy(),m)
print('best weights:')
for k,wv in zip(keys,best[1]):
    if wv>1e-3: print(f'  {k}: {wv:.3f}')
report('BEST BLEND', best[2])
print('all pass:', all(best[2][k]<=TARGETS[k] for k in TARGETS))
"

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from sklearn.preprocessing import StandardScaler, SplineTransformer
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.compose import ColumnTransformer

tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
G=ALL['cond'].values; Y=ALL[TARGET].values
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])

def spfeat(df):
    f=df['frequency'].astype(float).values; a=df['attack_angle'].astype(float).values
    c=df['chord_length'].astype(float).values; v=df['free_stream_velocity'].astype(float).values
    t=df['suction_side_displacement_thickness'].astype(float).values
    lf=np.log10(f); lt=np.log10(t); lc=np.log10(c); lv=np.log10(v)
    st=lf+lt-lv
    return np.column_stack([lf,st,a,lc,lv,lt,v]), lf, st, a, lc, lv, v

def build_model(nk,deg,alpha):
    st_=SplineTransformer(n_knots=nk,degree=deg)
    ct=ColumnTransformer([('sp',st_,[0,1,2,3,4,5,6])])
    return make_pipeline(StandardScaler(), ct, Ridge(alpha=alpha))

def oof(build,transform):
    X=transform(ALL)[0]; o=np.zeros(len(Y))
    for fdx in range(NS):
        trm=FOLDS!=fdx; tem=FOLDS==fdx
        m=build(); m.fit(X[trm],Y[trm]); o[tem]=m.predict(X[tem])
    return o

for nk in [5,7,10]:
    for alpha in [1.0,5.0]:
        o=oof(lambda nk=nk,alpha=alpha: build_model(nk,3,alpha), spfeat)
        report(f'spline nk{nk} a{alpha}', metrics(Y,o,G))
"

cd /app && timeout 290 python3 -c "
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from sklearn.svm import SVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.neighbors import KNeighborsRegressor
d=pickle.load(open('/app/oof.pkl','rb')); bank=d['bank']; Y=d['Y']; G=d['GROUPS']
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
def oof(build,transform):
    X=transform(ALL); o=np.zeros(len(Y))
    for fdx in range(NS):
        trm=FOLDS!=fdx; tem=FOLDS==fdx
        m=build(); m.fit(X[trm],Y[trm]); o[tem]=m.predict(X[tem])
    return o
new={
 'svr1':(lambda:make_pipeline(StandardScaler(),SVR(C=50,gamma=0.03,epsilon=0.05)),fe2),
 'svr2':(lambda:make_pipeline(StandardScaler(),SVR(C=100,gamma=0.02,epsilon=0.1)),fe2),
 'poly2i':(lambda:make_pipeline(StandardScaler(),PolynomialFeatures(2,interaction_only=False),Ridge(alpha=2.0)),fe2),
 'knn2':(lambda:make_pipeline(StandardScaler(),KNeighborsRegressor(n_neighbors=15,weights='distance')),fe3),
}
for nm,(b,tf) in new.items():
    bank[nm]=oof(b,tf); report(nm, metrics(Y,bank[nm],G))
pickle.dump({'bank':bank,'Y':Y,'GROUPS':G}, open('/app/oof.pkl','wb'))
print('updated bank:', list(bank))
"

cd /app && cat > /app/blend_search.py << 'PY'
import numpy as np, pandas as pd, pickle
from harness import metrics, report, TARGETS
d=pickle.load(open('/app/oof.pkl','rb')); bank=d['bank']; Y=d['Y']; G=d['GROUPS']

def blend_metrics(M,w,Y,G):
    return metrics(Y, M@(w/w.sum()), G)

def search(keys, n_iter=60000, seed=0, sparsify=0.5):
    M=np.column_stack([bank[k] for k in keys]); rng=np.random.RandomState(seed); best=None
    for _ in range(n_iter):
        w=rng.rand(len(keys))
        w=np.where(rng.rand(len(keys))<sparsify,0,w)
        if w.sum()==0: continue
        m=blend_metrics(M,w,Y,G)
        ok=all(m[k]<=TARGETS[k] for k in TARGETS)
        score=(0 if ok else 1, m['p90'], m['rmse'])
        if best is None or score<best[0]: best=(score,w/w.sum(),m)
    return best

def bootstrap_check(keys, w, nboot=300, seed=1):
    M=np.column_stack([bank[k] for k in keys]); p=M@w
    df=pd.DataFrame({'e':p-Y}); df['c']=G
    per=df.groupby('c')['e'].apply(lambda s:np.sqrt(np.mean(s.values**2)))
    conds=per.index.values; rng=np.random.RandomState(seed)
    res={k:[] for k in ['rmse','mae','p90','p95','max']}
    # full-data global rmse/mae fixed; bootstrap condition set for tail metrics
    rowerr=df['e'].values
    for _ in range(nboot):
        samp=rng.choice(conds,size=len(conds),replace=True)
        vals=per.loc[samp].values
        res['p90'].append(np.percentile(vals,90)); res['p95'].append(np.percentile(vals,95)); res['max'].append(vals.max())
    return {k:(np.mean(v),np.percentile(v,90)) for k,v in res.items() if v}

if __name__=='__main__':
    for keys in [
      ['et2','et3','hgb','poly3','svr1'],
      ['et2','et3','hgb','poly3','svr1','knn2'],
      ['et2','hgb','poly3'],
      ['et2','et3','et2b','hgb','gbr','poly3','svr1','knn2'],
    ]:
        b=search(keys)
        wd={k:round(float(wv),3) for k,wv in zip(keys,b[1]) if wv>1e-3}
        report('BLEND '+str(wd), b[2])
        bc=bootstrap_check(keys,b[1])
        print('   boot p90(mean,p90):',tuple(round(x,3) for x in bc['p90']),'p95:',tuple(round(x,3) for x in bc['p95']),'max:',tuple(round(x,3) for x in bc['max']))
PY
timeout 290 python3 /app/blend_search.py

cd /app && timeout 100 python3 -c "
import numpy as np, pandas as pd
from harness import *
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lf=np.log10(ALL['frequency'].values)
rows=[]
for c,idx in ALL.groupby('cond').groups.items():
    idx=np.array(idx); 
    if len(idx)<6: continue
    x=lf[idx]; y=ALL[TARGET].values[idx]
    deg=min(4,len(idx)-2)
    res=y-np.polyval(np.polyfit(x,y,deg),x)
    rows.append((ALL.loc[idx,'attack_angle'].mean(), np.std(res), len(idx)))
d=pd.DataFrame(rows,columns=['angle','noise','n'])
print('overall noise-floor std: median %.3f mean %.3f'%(d['noise'].median(),d['noise'].mean()))
print('high angle>12 noise: mean %.3f'%d[d.angle>12]['noise'].mean())
print('low angle<=12 noise: mean %.3f'%d[d.angle<=12]['noise'].mean())
print('noise floor p90 across conditions: %.3f'%np.percentile(d['noise'],90))
"

cd /app && timeout 280 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
G=ALL['cond'].values; Y=ALL[TARGET].values; A=ALL['attack_angle'].values
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
X2=fe2(ALL)
def oofw(build, w):
    o=np.zeros(len(Y))
    for f in range(NS):
        trm=FOLDS!=f; tem=FOLDS==f
        m=build(); m.fit(X2[trm],Y[trm],sample_weight=None if w is None else w[trm]); o[tem]=m.predict(X2[tem])
    return o
def et(): return ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=0)
for k in [0.0,0.05,0.1,0.2]:
    w=1.0+k*np.maximum(0,A-8.0)
    report(f'ET whi k={k}', metrics(Y,oofw(et,w),G))
"

cd /app && timeout 280 python3 -c "
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from sklearn.preprocessing import StandardScaler, SplineTransformer
from sklearn.linear_model import Ridge
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
G=ALL['cond'].values; Y=ALL[TARGET].values
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])

def base(df):
    f=df['frequency'].astype(float).values; a=df['attack_angle'].astype(float).values
    c=df['chord_length'].astype(float).values; v=df['free_stream_velocity'].astype(float).values
    t=df['suction_side_displacement_thickness'].astype(float).values
    lf=np.log10(f); lt=np.log10(t); lc=np.log10(c); lv=np.log10(v); st=lf+lt-lv
    return lf,st,a,lc,lv,lt,v

def make_feats(df, sp_st, sp_lf, fit=False):
    lf,st,a,lc,lv,lt,v=base(df)
    if fit:
        sp_st.fit(st.reshape(-1,1)); sp_lf.fit(lf.reshape(-1,1))
    Bst=sp_st.transform(st.reshape(-1,1)); Blf=sp_lf.transform(lf.reshape(-1,1))
    cond=np.column_stack([a,a**2,lc,lv,lt,v,np.ones_like(a)])
    # interactions: each spline col times each condition feature
    inter=[]
    for j in range(Bst.shape[1]):
        inter.append(Bst[:,[j]]*cond)
    blocks=[Bst,Blf,cond]+inter
    return np.hstack(blocks)

def oof(nk,alpha):
    o=np.zeros(len(Y))
    for f in range(NS):
        trm=FOLDS!=f; tem=FOLDS==f
        sp_st=SplineTransformer(n_knots=nk,degree=3); sp_lf=SplineTransformer(n_knots=nk,degree=3)
        Xtr=make_feats(ALL[trm],sp_st,sp_lf,fit=True)
        sc=StandardScaler().fit(Xtr)
        m=Ridge(alpha=alpha).fit(sc.transform(Xtr),Y[trm])
        Xte=make_feats(ALL[tem],sp_st,sp_lf,fit=False)
        o[tem]=m.predict(sc.transform(Xte))
    return o
for nk in [5,6,8]:
    for alpha in [2.0,10.0]:
        o=oof(nk,alpha); report(f'splineX nk{nk} a{alpha}', metrics(Y,o,G))
        if nk==6 and alpha==10.0:
            pickle.dump(o, open('/app/splineX_oof.pkl','wb'))
"

cd /app && cat > /app/blend_model.py << 'PY'
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import fe2, fe3, TARGET
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge

class Blend:
    def __init__(self, weights=None):
        # weights for [et2, et3, hgb, poly3]
        self.weights = weights or [0.32,0.16,0.22,0.30]
    def fit(self, df, y):
        X2=fe2(df); X3=fe3(df)
        self.et2=ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=0).fit(X2,y)
        self.et3=ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=1).fit(X3,y)
        self.hgb=HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0).fit(X2,y)
        self.poly=make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)).fit(X2,y)
        return self
    def predict(self, df):
        X2=fe2(df); X3=fe3(df)
        ps=np.column_stack([self.et2.predict(X2),self.et3.predict(X3),self.hgb.predict(X2),self.poly.predict(X2)])
        w=np.array(self.weights); w=w/w.sum()
        return ps@w

if __name__=='__main__':
    from harness import load, add_conditions, metrics, report
    tr,va=load(); va=add_conditions(va)
    b=Blend().fit(tr, tr[TARGET].values)
    p=b.predict(va)
    report('BLEND train->val', metrics(va[TARGET].values, p, va['cond'].values))
    # also report individual on val
    from harness import metrics as M
    for nm,pred in [('et2',b.et2.predict(fe2(va))),('poly3',b.poly.predict(fe2(va))),('hgb',b.hgb.predict(fe2(va)))]:
        report(nm+' train->val', M(va[TARGET].values,pred,va['cond'].values))
PY
timeout 200 python3 /app/blend_model.py

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd, warnings, time
warnings.filterwarnings('ignore')
from harness import *
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
tr,va=load(); va=add_conditions(va)
Xtr=fe2(tr); ytr=tr[TARGET].values; Xva=fe2(va); yva=va[TARGET].values
class BagLB:
    def __init__(s,hid,alpha,n): s.hid=hid; s.alpha=alpha; s.n=n
    def fit(s,X,y):
        s.ms=[make_pipeline(StandardScaler(),MLPRegressor(s.hid,solver='lbfgs',alpha=s.alpha,activation='tanh',max_iter=2000,random_state=i)).fit(X,y) for i in range(s.n)]; return s
    def predict(s,X): return np.mean([m.predict(X) for m in s.ms],0)
for hid in [(64,),(128,64),(64,32)]:
    for alpha in [0.01,0.1,1.0]:
        t=time.time(); m=BagLB(hid,alpha,5).fit(Xtr,ytr); p=m.predict(Xva)
        report(f'MLP-lbfgs {hid} a{alpha} [{time.time()-t:.0f}s]', metrics(yva,p,va['cond'].values))
"

cd /app && cat > /app/val_blend.py << 'PY'
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge

def fit_all(tr):
    y=tr[TARGET].values; X2=fe2(tr); X3=fe3(tr)
    M={}
    M['et2']=ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=0).fit(X2,y)
    M['et3']=ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=1).fit(X3,y)
    M['hgb']=HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0).fit(X2,y)
    M['poly3']=make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)).fit(X2,y)
    M['mlpA']=make_pipeline(StandardScaler(),MLPRegressor((128,64),solver='lbfgs',alpha=0.03,activation='tanh',max_iter=2000,random_state=0)).fit(X2,y)
    M['mlpB']=make_pipeline(StandardScaler(),MLPRegressor((64,32),solver='lbfgs',alpha=0.1,activation='tanh',max_iter=2000,random_state=1)).fit(X2,y)
    return M

def preds(M,df):
    X2=fe2(df); X3=fe3(df)
    return {k:(m.predict(X3) if k=='et3' else m.predict(X2)) for k,m in M.items()}

if __name__=='__main__':
    tr,va=load(); va=add_conditions(va)
    M=fit_all(tr); P=preds(M,va); yva=va[TARGET].values; cond=va['cond'].values
    for k in M: report(k, metrics(yva,P[k],cond))
    print('--- blends ---')
    import itertools
    blends={
     'et2+mlpA': {'et2':1,'mlpA':1},
     'et2+et3+mlpA+mlpB': {'et2':1,'et3':1,'mlpA':1,'mlpB':1},
     'et2+et3+hgb+mlpA+mlpB': {'et2':1.5,'et3':1,'hgb':1,'mlpA':1,'mlpB':1},
     'all6': {'et2':1.5,'et3':1,'hgb':1,'mlpA':1,'mlpB':1,'poly3':0.7},
     'trees+mlp+poly': {'et2':2,'hgb':1,'mlpA':1.5,'poly3':1},
    }
    for nm,w in blends.items():
        ks=list(w); ws=np.array([w[k] for k in ks],float); ws/=ws.sum()
        p=sum(ws[i]*P[ks[i]] for i in range(len(ks)))
        report(nm, metrics(yva,p,cond))
PY
timeout 200 python3 /app/val_blend.py

cd /app && cat > /app/robust_blend.py << 'PY'
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.svm import SVR
from sklearn.neighbors import KNeighborsRegressor

KEYS=['et2','et3','hgb','poly3','svr1','knn2']
def build(k):
    if k=='et2': return ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=0),fe2
    if k=='et3': return ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=1),fe3
    if k=='hgb': return HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0),fe2
    if k=='poly3': return make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)),fe2
    if k=='svr1': return make_pipeline(StandardScaler(),SVR(C=50,gamma=0.03,epsilon=0.05)),fe2
    if k=='knn2': return make_pipeline(StandardScaler(),KNeighborsRegressor(n_neighbors=15,weights='distance')),fe3

d=pickle.load(open('/app/oof.pkl','rb')); bank=d['bank']; Ycv=d['Y']; Gcv=d['GROUPS']
tr,va=load(); va=add_conditions(va); yva=va[TARGET].values; cva=va['cond'].values
valp={}
for k in KEYS:
    m,tf=build(k); m.fit(tf(tr),tr[TARGET].values); valp[k]=m.predict(tf(va))

def ev(w):
    ws=np.array([w.get(k,0) for k in KEYS],float); ws=ws/ws.sum()
    pcv=sum(ws[i]*bank[KEYS[i]] for i in range(len(KEYS)))
    pva=sum(ws[i]*valp[KEYS[i]] for i in range(len(KEYS)))
    return metrics(Ycv,pcv,Gcv), metrics(yva,pva,cva)

cands={
 'et2': {'et2':1},
 'et3': {'et3':1},
 'et2+et3': {'et2':1,'et3':1},
 'et2+et3+hgb': {'et2':1,'et3':1,'hgb':1},
 '2et+hgb+poly.3': {'et2':1,'et3':1,'hgb':1,'poly3':0.3},
 '2et+hgb+poly.6': {'et2':1,'et3':1,'hgb':1,'poly3':0.6},
 '2et+hgb+svr.5': {'et2':1,'et3':1,'hgb':1,'svr1':0.5},
 '2et+hgb+poly.4+svr.4': {'et2':1,'et3':1,'hgb':1,'poly3':0.4,'svr1':0.4},
 '2et+hgb+poly.4+knn.4': {'et2':1,'et3':1,'hgb':1,'poly3':0.4,'knn2':0.4},
 'all': {'et2':1,'et3':1,'hgb':1,'poly3':0.4,'svr1':0.4,'knn2':0.3},
}
print('%-22s | %-38s | %-38s'%('blend','CV (82 cond)','VAL (16 cond)'))
for nm,w in cands.items():
    mc,mv=ev(w)
    f=lambda m:'r%.2f a%.2f p90_%.2f p95_%.2f mx%.2f'%(m['rmse'],m['mae'],m['p90'],m['p95'],m['max'])
    print('%-22s | %-38s | %-38s'%(nm,f(mc),f(mv)))
pickle.dump(valp, open('/app/valp.pkl','wb'))
PY
timeout 200 python3 /app/robust_blend.py

cd /app && timeout 250 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor

def canon_levels(values, thr):
    v=np.sort(values); labels=np.zeros(len(v),int); cur=0
    for i in range(1,len(v)):
        if v[i]-v[i-1]>thr: cur+=1
        labels[i]=cur
    return np.array([v[labels==l].mean() for l in range(cur+1)])

def snap_to(values, levels):
    idx=np.argmin(np.abs(values[:,None]-levels[None,:]),axis=1); return levels[idx]

tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
# build canonical levels from ALL (robust)
lv_freq=canon_levels(ALL['frequency'].values, 15.0)
lv_a=canon_levels(ALL['attack_angle'].values,0.12)
lv_c=canon_levels(ALL['chord_length'].values,0.005)
lv_v=canon_levels(ALL['free_stream_velocity'].values,0.5)
print('n levels freq,a,c,v =',len(lv_freq),len(lv_a),len(lv_c),len(lv_v))

def snap_df(df):
    d=df.copy()
    d['frequency']=snap_to(df['frequency'].values,lv_freq)
    d['attack_angle']=snap_to(df['attack_angle'].values,lv_a)
    d['chord_length']=snap_to(df['chord_length'].values,lv_c)
    d['free_stream_velocity']=snap_to(df['free_stream_velocity'].values,lv_v)
    # snap thickness to per-condition mean (denoise)
    d['suction_side_displacement_thickness']=df.groupby(add_conditions(df)['cond'])['suction_side_displacement_thickness'].transform('mean').values if False else df['suction_side_displacement_thickness'].values
    return d

G=ALL['cond'].values; Y=ALL[TARGET].values
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
ALLs=snap_df(ALL)
for nm,Xall in [('raw',fe2(ALL)),('snapped',fe2(ALLs))]:
    o=np.zeros(len(Y))
    for f in range(NS):
        trm=FOLDS!=f; tem=FOLDS==f
        m=ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=0).fit(Xall[trm],Y[trm]); o[tem]=m.predict(Xall[tem])
    report('ET '+nm+' [CV]', metrics(Y,o,G))
# val check
tr2=tr.copy(); va2=va.copy()
trs=snap_df(tr); vas=snap_df(va)
for nm,(Xtr,Xva) in [('raw',(fe2(tr),fe2(va))),('snap',(fe2(trs),fe2(vas)))]:
    m=ExtraTreesRegressor(n_estimators=600,min_samples_leaf=1,n_jobs=-1,random_state=0).fit(Xtr,tr[TARGET].values)
    report('ET '+nm+' [val]', metrics(va[TARGET].values,m.predict(Xva),add_conditions(va)['cond'].values))
"

cd /app && cat > /app/snap_util.py << 'PY'
import numpy as np, pandas as pd
from harness import add_conditions

def canon_levels(values, thr):
    v=np.sort(np.asarray(values,float)); labels=np.zeros(len(v),int); cur=0
    for i in range(1,len(v)):
        if v[i]-v[i-1]>thr: cur+=1
        labels[i]=cur
    return np.array([v[labels==l].mean() for l in range(cur+1)])

def fit_snapper(df):
    return {
      'frequency': canon_levels(df['frequency'].values,15.0),
      'attack_angle': canon_levels(df['attack_angle'].values,0.12),
      'chord_length': canon_levels(df['chord_length'].values,0.005),
      'free_stream_velocity': canon_levels(df['free_stream_velocity'].values,0.5),
    }

def _snap(values, levels):
    idx=np.argmin(np.abs(np.asarray(values,float)[:,None]-levels[None,:]),axis=1); return levels[idx]

def apply_snapper(df, levels, snap_thickness=True):
    d=df.copy()
    for k,lv in levels.items():
        d[k]=_snap(df[k].values, lv)
    if snap_thickness:
        cond=add_conditions(d)['cond']
        d['suction_side_displacement_thickness']=d.groupby(cond)['suction_side_displacement_thickness'].transform('mean').values
    return d
PY
timeout 260 python3 -c "
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge

tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL)
G=ALL['cond'].values; Y=ALL[TARGET].values
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])

def models():
    return {
     'et2':(ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=0),fe2),
     'et3':(ExtraTreesRegressor(n_estimators=700,min_samples_leaf=1,n_jobs=-1,random_state=1),fe3),
     'hgb':(HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0),fe2),
     'poly3':(make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)),fe2),
    }
# snapped feature matrices
ALLs=apply_snapper(ALL,lev)
Xs={k:tf(ALLs) for k,(m,tf) in models().items()}
oofs={}
for k,(m,tf) in models().items():
    o=np.zeros(len(Y)); X=Xs[k]
    from sklearn.base import clone
    for f in range(NS):
        trm=FOLDS!=f; tem=FOLDS==f
        mm=clone(m); mm.fit(X[trm],Y[trm]); o[tem]=mm.predict(X[tem])
    oofs[k]=o
# val
trs=apply_snapper(add_conditions(tr),lev); vas=apply_snapper(va,lev)
valp={}
for k,(m,tf) in models().items():
    from sklearn.base import clone
    mm=clone(m); mm.fit(tf(trs),tr[TARGET].values); valp[k]=mm.predict(tf(vas))
yva=va[TARGET].values; cva=add_conditions(va)['cond'].values
def ev(w):
    ws={k:w.get(k,0) for k in oofs}; s=sum(ws.values())
    pc=sum(ws[k]/s*oofs[k] for k in oofs); pv=sum(ws[k]/s*valp[k] for k in oofs)
    return metrics(Y,pc,G), metrics(yva,pv,cva)
for nm,w in {'et2':{'et2':1},'et3':{'et3':1},'et2+et3':{'et2':1,'et3':1},'2et+hgb':{'et2':1,'et3':1,'hgb':1},'2et+hgb+poly.4':{'et2':1,'et3':1,'hgb':1,'poly3':0.4}}.items():
    mc,mv=ev(w)
    f=lambda m:'r%.2f a%.2f p90_%.2f p95_%.2f mx%.2f'%(m['rmse'],m['mae'],m['p90'],m['p95'],m['max'])
    print('%-16s | CV %-36s | VAL %s'%(nm,f(mc),f(mv)))
pickle.dump({'oofs':oofs,'valp':valp,'Y':Y,'G':G,'yva':yva,'cva':cva}, open('/app/snap_oof.pkl','wb'))
"

cd /app && timeout 260 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL)
trs=apply_snapper(add_conditions(tr),lev); vas=apply_snapper(va,lev)
yva=va[TARGET].values; cva=add_conditions(va)['cond'].values
X2tr,X3tr=fe2(trs),fe3(trs); X2va,X3va=fe2(vas),fe3(vas)
def etbag(nseed2,nseed3,ntrees=700):
    preds=[]
    for s in range(nseed2):
        m=ExtraTreesRegressor(n_estimators=ntrees,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2tr,tr[TARGET].values); preds.append(m.predict(X2va))
    for s in range(nseed3):
        m=ExtraTreesRegressor(n_estimators=ntrees,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(X3tr,tr[TARGET].values); preds.append(m.predict(X3va))
    return np.mean(preds,0)
for n2,n3 in [(1,0),(2,2),(3,2),(4,3)]:
    report(f'ETbag fe2x{n2} fe3x{n3} [val]', metrics(yva,etbag(n2,n3),cva))
# also ETbag + small hgb
hgb=HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,random_state=0).fit(X2tr,tr[TARGET].values)
ph=hgb.predict(X2va); pe=etbag(3,2)
for wh in [0.15,0.3]:
    report(f'ETbag+hgb*{wh} [val]', metrics(yva,(1-wh)*pe+wh*ph,cva))
"

cd /app && timeout 260 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL)
trs=apply_snapper(add_conditions(tr),lev); vas=apply_snapper(va,lev)
yva=va[TARGET].values; cva=add_conditions(va)['cond'].values
X2tr,X3tr=fe2(trs),fe3(trs); X2va,X3va=fe2(vas),fe3(vas)
pe=np.mean([ExtraTreesRegressor(700,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2tr,tr[TARGET].values).predict(X2va) for s in range(3)]+
           [ExtraTreesRegressor(700,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(X3tr,tr[TARGET].values).predict(X3va) for s in range(2)],0)
poly=make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)).fit(X2tr,tr[TARGET].values)
pp=poly.predict(X2va)
ava=vas['attack_angle'].values
report('ETbag', metrics(yva,pe,cva))
for a0,span,cap in [(10,15,0.4),(8,14,0.5),(12,12,0.5),(10,12,0.6)]:
    g=np.clip((ava-a0)/span,0,cap)
    report(f'angleblend a0{a0} span{span} cap{cap}', metrics(yva,(1-g)*pe+g*pp,cva))
"

cd /app && timeout 290 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.ensemble import ExtraTreesRegressor
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL); ALLs=apply_snapper(ALL,lev)
G=ALL['cond'].values; Y=ALL[TARGET].values
X2=fe2(ALLs); X3=fe3(ALLs)
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
oof=np.zeros(len(Y))
for f in range(NS):
    trm=FOLDS!=f; tem=FOLDS==f
    ps=[]
    for s in range(3): ps.append(ExtraTreesRegressor(600,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2[trm],Y[trm]).predict(X2[tem]))
    for s in range(2): ps.append(ExtraTreesRegressor(600,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(X3[trm],Y[trm]).predict(X3[tem]))
    oof[tem]=np.mean(ps,0)
m=metrics(Y,oof,G); report('snapped ETbag [CV]',m)
df=pd.DataFrame({'e':oof-Y,'c':G}); per=df.groupby('c')['e'].apply(lambda s:np.sqrt(np.mean(s.values**2)))
print('n cond',len(per))
for thr in [2.0,2.35,2.5]: print(f'  frac<= {thr}: {(per<=thr).mean():.3f}')
print('percentiles p85 %.3f p88 %.3f p90 %.3f p92 %.3f'%tuple(np.percentile(per,[85,88,90,92])))
"

cd /app && timeout 290 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.ensemble import ExtraTreesRegressor
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL); ALLs=apply_snapper(ALL,lev)
G=ALL['cond'].values; Y=ALL[TARGET].values; A=ALLs['attack_angle'].values
X2=fe2(ALLs); X3=fe3(ALLs)
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
def bag(Xtr,ytr,Xte,seeds,off=0):
    return np.mean([ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=off+s).fit(Xtr,ytr).predict(Xte) for s in range(seeds)],0)
oof_g=np.zeros(len(Y)); oof_s=np.zeros(len(Y))
THR=9.0
for f in range(NS):
    trm=FOLDS!=f; tem=FOLDS==f
    oof_g[tem]=0.5*bag(X2[trm],Y[trm],X2[tem],3)+0.5*bag(X3[trm],Y[trm],X3[tem],2,100)
    # specialist: train on high-angle rows only
    hi=trm&(A>THR)
    oof_s[tem]=0.5*bag(X2[hi],Y[hi],X2[tem],3)+0.5*bag(X3[hi],Y[hi],X3[tem],2,100)
report('global', metrics(Y,oof_g,G))
for w in [0.3,0.5,0.7]:
    blend=oof_g.copy(); m=A>THR
    blend[m]=(1-w)*oof_g[m]+w*oof_s[m]
    report(f'global+spec(a>{THR}) w{w}', metrics(Y,blend,G))
# show high-angle condition improvement
df=pd.DataFrame({'eg':oof_g-Y,'c':G,'a':A}); 
perg=df.groupby('c').apply(lambda d:np.sqrt(np.mean(d['eg']**2)))
print('high-angle cond mean RMSE global:', perg[df.groupby('c')['a'].mean()>THR].mean())
"

cd /app && timeout 290 python3 -c "
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
tr,va=load(); ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL); ALLs=apply_snapper(ALL,lev)
G=ALL['cond'].values; Y=ALL[TARGET].values
X2=fe2(ALLs); X3=fe3(ALLs)
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=10; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
def bag(Xtr,ytr,Xte):
    return np.mean([ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(Xtr,ytr).predict(Xte) for s in range(3)]+
                   [ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(Xtr,ytr).predict(Xte) for s in range(2)],0)
# wait need fe3 too; do separately
oe=np.zeros(len(Y)); op=np.zeros(len(Y))
for f in range(NS):
    trm=FOLDS!=f; tem=FOLDS==f
    pe2=np.mean([ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2[trm],Y[trm]).predict(X2[tem]) for s in range(3)],0)
    pe3=np.mean([ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(X3[trm],Y[trm]).predict(X3[tem]) for s in range(2)],0)
    oe[tem]=0.5*pe2+0.5*pe3
    op[tem]=make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)).fit(X2[trm],Y[trm]).predict(X2[tem])
# val
trs=apply_snapper(add_conditions(tr),lev); vas=apply_snapper(va,lev)
X2t,X3t=fe2(trs),fe3(trs); X2v,X3v=fe2(vas),fe3(vas)
ve=0.5*bag(X2t,tr[TARGET].values,X2v)+0.5*np.mean([ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=200+s).fit(X3t,tr[TARGET].values).predict(X3v) for s in range(2)],0)
vp=make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)).fit(X2t,tr[TARGET].values).predict(X2v)
yva=va[TARGET].values; cva=add_conditions(va)['cond'].values
for w in [0.0,0.1,0.15,0.2,0.3]:
    mc=metrics(Y,(1-w)*oe+w*op,G); mv=metrics(yva,(1-w)*ve+w*vp,cva)
    fo2=lambda m:'r%.2f a%.2f p90_%.2f p95_%.2f mx%.2f'%(m['rmse'],m['mae'],m['p90'],m['p95'],m['max'])
    print('poly w%.2f | CV %-34s | VAL %s'%(w,fo2(mc),fo2(mv)))
"

command: create
path: /app/train_and_predict.py
file_text: #!/usr/bin/env python3
"""Airfoil self-noise surrogate.

Trains on the labeled public data (train + validation) and writes predictions
for the grader-staged evaluation features at /app/data/test_features.csv.

Modeling summary
----------------
* The split holds out complete aerodynamic *conditions*
  (attack_angle, chord_length, free_stream_velocity). The measured inputs are
  small jitters around a discrete physical grid, so we first "snap" the inputs
  back onto the recovered canonical grid levels. This denoises the features and
  removes jitter-induced prediction wiggle within a condition.
* Physics-motivated ratio features (Strouhal, Reynolds, Mach numbers) are added
  because tree models cannot form ratios of raw inputs on their own.
* The estimator is a variance-reduced bag of ExtraTrees over two feature sets,
  blended with a small smooth polynomial-ridge component that regularizes the
  worst (extreme-angle) held-out conditions and keeps the per-condition tail in
  check.

The workflow is fully self-contained (numpy / pandas / scikit-learn only).
"""

from pathlib import Path
import warnings

import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler

warnings.filterwarnings("ignore")

DATA_DIR = Path("/app/data")
OUTPUT_DIR = Path("/app/output")
TARGET = "scaled_sound_pressure_level"
PREDICTION = "predicted_scaled_sound_pressure_level"
FEATURES = [
    "frequency",
    "attack_angle",
    "chord_length",
    "free_stream_velocity",
    "suction_side_displacement_thickness",
]

# Physically plausible clip range for the calibrated SPL target (observed
# labeled range is ~[105, 140]); this is only a safety net against any wild
# extrapolation and is deliberately well outside the observed range.
CLIP_LO, CLIP_HI = 90.0, 150.0

# Gap thresholds used to recover the discrete physical grid for each input.
SNAP_THRESHOLDS = {
    "frequency": 15.0,
    "attack_angle": 0.12,
    "chord_length": 0.005,
    "free_stream_velocity": 0.5,
}


# --------------------------------------------------------------------------- #
# Feature engineering
# --------------------------------------------------------------------------- #
def _raw_cols(df):
    f = df["frequency"].astype(float).values
    a = df["attack_angle"].astype(float).values
    c = df["chord_length"].astype(float).values
    v = df["free_stream_velocity"].astype(float).values
    t = df["suction_side_displacement_thickness"].astype(float).values
    # Guard against non-positive values before taking logs.
    f = np.clip(f, 1e-6, None)
    c = np.clip(c, 1e-9, None)
    v = np.clip(v, 1e-6, None)
    t = np.clip(t, 1e-12, None)
    return f, a, c, v, t


def fe2(df):
    """Primary feature set: raw inputs + physics ratio features."""
    f, a, c, v, t = _raw_cols(df)
    lf, lt, lc, lv = np.log10(f), np.log10(t), np.log10(c), np.log10(v)
    out = {}
    out["lf"] = lf
    out["a"] = a
    out["lc"] = lc
    out["v"] = v
    out["lt"] = lt
    out["c"] = c
    out["t"] = t
    out["st_delta"] = lf + lt            # log10(f * delta)
    out["st_delta_U"] = lf + lt - lv     # log10(f * delta / U)  ~ Strouhal
    out["st_chord"] = lf + lc            # log10(f * c)
    out["st_chord_U"] = lf + lc - lv     # log10(f * c / U)
    out["delta_c"] = lt - lc             # log10(delta / c)
    out["Re_c"] = lc + lv                # log10(c * U)  ~ Reynolds (chord)
    out["Re_delta"] = lt + lv            # log10(delta * U)
    out["mach"] = v / 340.0
    out["lf2"] = lf ** 2
    out["lf3"] = lf ** 3
    out["a2"] = a ** 2
    out["a_lf"] = a * lf
    out["st_delta_U2"] = out["st_delta_U"] ** 2
    out["a_st"] = a * out["st_delta_U"]
    return np.column_stack([out[k] for k in out])


def fe3(df):
    """Secondary feature s
…[truncated]

cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py && echo "---HEAD---" && head -5 output/predictions.csv && echo "---CHECK---" && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv'); t=pd.read_csv('data/test_features.csv')
print('cols', list(p.columns))
print('n_pred', len(p), 'n_test', len(t))
print('ids match (order):', (p['sample_id'].astype(str).values==t['sample_id'].astype(str).values).all())
print('ids match (set):', set(p['sample_id'].astype(str))==set(t['sample_id'].astype(str)))
print('all finite:', np.isfinite(p['predicted_scaled_sound_pressure_level']).all())
print('n unique preds:', p['predicted_scaled_sound_pressure_level'].nunique())
print('range:', p['predicted_scaled_sound_pressure_level'].min(), p['predicted_scaled_sound_pressure_level'].max())
"

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
import train_and_predict as S
from harness import add_conditions, metrics, report, TARGET
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
m=S.AirfoilSurrogate().fit(tr[S.FEATURES], tr[TARGET].values)
pred=m.predict(va[S.FEATURES])
vc=add_conditions(va)
report('FINAL model train->val', metrics(va[TARGET].values, pred, vc['cond'].values))
# per-condition distribution
df=pd.DataFrame({'e':pred-va[TARGET].values,'c':vc['cond'].values})
per=df.groupby('c')['e'].apply(lambda s:np.sqrt(np.mean(s.values**2))).sort_values()
print('val n_cond',len(per),'| frac<=2.35:',round((per<=2.35).mean(),3))
print('worst 3:', [round(x,2) for x in per.values[-3:]])
"

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
import train_and_predict as S
from harness import add_conditions, metrics, report, TARGET
from sklearn.ensemble import ExtraTreesRegressor
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
lev=S.fit_snapper(tr[S.FEATURES]); trs=S.apply_snapper(tr[S.FEATURES],lev); vas=S.apply_snapper(va[S.FEATURES],lev)
X2t,X3t=S.fe2(trs),S.fe3(trs); X2v,X3v=S.fe2(vas),S.fe3(vas)
y=tr[TARGET].values; vc=add_conditions(va)['cond'].values; yv=va[TARGET].values
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
pp=make_pipeline(StandardScaler(),PolynomialFeatures(3),Ridge(alpha=20.0)).fit(X2t,y).predict(X2v)
for msl in [1,2,3]:
    pe=np.mean([ExtraTreesRegressor(700,min_samples_leaf=msl,n_jobs=-1,random_state=s).fit(X2t,y).predict(X2v) for s in range(4)]+
               [ExtraTreesRegressor(700,min_samples_leaf=msl,n_jobs=-1,random_state=1000+s).fit(X3t,y).predict(X3v) for s in range(3)],0)
    for w in [0.10]:
        report(f'msl{msl} poly{w}', metrics(yv,np.clip((1-w)*pe+w*pp,90,150),vc))
"

cd /app && echo "=== imports (should be stdlib/numpy/pandas/sklearn only) ===" && grep -nE "^(import|from)" train_and_predict.py && echo "=== self-contained check: run in isolated dir without dev files on path ===" && mkdir -p /tmp/isotest && cp train_and_predict.py /tmp/isotest/ && cd /tmp/isotest && python3 -c "
import ast,sys
src=open('train_and_predict.py').read()
mods=set()
for n in ast.walk(ast.parse(src)):
    if isinstance(n,ast.Import):
        for a in n.names: mods.add(a.name.split('.')[0])
    elif isinstance(n,ast.ImportFrom):
        mods.add((n.module or '').split('.')[0])
print('top-level imports:',sorted(m for m in mods if m))
local={'harness','exp','cv','cv2','cv3','oof_bank','blend_search','blend_model','val_blend','robust_blend','snap_util','mlp_test'}
print('depends on dev files:', sorted(mods & local) or 'NONE')
"

command: str_replace
path: /app/train_and_predict.py
old_str: from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
new_str: from sklearn.ensemble import ExtraTreesRegressor

cd /tmp/isotest && cp /app/train_and_predict.py . && python3 train_and_predict.py >/dev/null 2>&1 && cp /app/output/predictions.csv /tmp/run1.csv && python3 train_and_predict.py >/dev/null 2>&1 && cp /app/output/predictions.csv /tmp/run2.csv && echo "determinism (identical across runs):" && diff -q /tmp/run1.csv /tmp/run2.csv && echo "IDENTICAL" && md5sum /tmp/run1.csv /tmp/run2.csv

cd /app && echo "input hashes BEFORE (recorded at start via git? no) - verify not writable-modified by timestamps:" && ls -la --time-style=+%H:%M:%S data/*.csv && rm -f /app/*.pkl /app/splineX_oof.pkl && echo "removed pkl scratch" && rm -f output/predictions.csv && python3 train_and_predict.py && echo "=== final validation of output ===" && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv'); t=pd.read_csv('data/test_features.csv')
assert list(p.columns)==['sample_id','predicted_scaled_sound_pressure_level'], p.columns
assert len(p)==len(t)==40
assert (p['sample_id'].astype(str).values==t['sample_id'].astype(str).values).all()
v=p['predicted_scaled_sound_pressure_level'].values
assert np.isfinite(v).all() and p['predicted_scaled_sound_pressure_level'].nunique()>1
print('OK: columns, count, id-alignment, finite, non-constant all pass')
print('pred range [%.2f, %.2f], n_unique=%d'%(v.min(),v.max(),len(np.unique(v))))
"

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper

def build_spectra(dftr, ytr):
    d=dftr.copy(); d['y']=ytr; d=add_conditions(d)
    specs={}; cx=[]; ckeys=[]
    for c,grp in d.groupby('cond'):
        lf=np.log10(grp['frequency'].values); order=np.argsort(lf)
        specs[c]=(lf[order], grp['y'].values[order])
        a=grp['attack_angle'].mean(); c_=np.log10(grp['chord_length'].mean()); v=np.log10(grp['free_stream_velocity'].mean()); t=np.log10(grp['suction_side_displacement_thickness'].mean())
        cx.append([a,c_,v,t]); ckeys.append(c)
    return specs, np.array(cx), ckeys

def predict_struct(dftr,ytr,dfte,K=6,scale=None,power=2.0):
    specs,cx,ckeys=build_spectra(dftr,ytr)
    mu=cx.mean(0); sd=cx.std(0)+1e-9
    if scale is not None: sd=sd/np.array(scale)
    cxn=(cx-mu)/sd
    te=dfte.copy(); 
    A=te['attack_angle'].values; C=np.log10(te['chord_length'].values); V=np.log10(te['free_stream_velocity'].values); T=np.log10(te['suction_side_displacement_thickness'].values)
    Q=(np.column_stack([A,C,V,T])-mu)/sd
    lf_q=np.log10(te['frequency'].values)
    out=np.empty(len(te))
    for i in range(len(te)):
        dist=np.sqrt(((cxn-Q[i])**2).sum(1))
        idx=np.argsort(dist)[:K]
        w=1.0/(dist[idx]**power+1e-6); w/=w.sum()
        val=0.0
        for j,ci in enumerate(idx):
            lf_n,spl_n=specs[ckeys[ci]]
            val+=w[j]*np.interp(lf_q[i], lf_n, spl_n)  # clamps at edges
        out[i]=val
    return out

tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
lev=fit_snapper(pd.concat([tr,va],ignore_index=True))
trs=apply_snapper(tr,lev); vas=apply_snapper(va,lev)
vc=add_conditions(va)['cond'].values; yv=va[TARGET].values
for K in [4,6,8,10]:
    p=predict_struct(trs,tr[TARGET].values,vas,K=K)
    report(f'struct-interp K{K} [val]', metrics(yv,p,vc))
"

cd /app && sed -n '200,260p' train_and_predict.py && echo "=== py compile check ===" && python3 -m py_compile train_and_predict.py && echo "compiles OK" && echo "=== final run ===" && rm -f output/predictions.csv && python3 train_and_predict.py && wc -l output/predictions.csv

cd /app && timeout 260 python3 -c "
import numpy as np, pandas as pd, warnings
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
lev=fit_snapper(pd.concat([tr,va],ignore_index=True))
trs=apply_snapper(tr,lev); vas=apply_snapper(va,lev)
X2t=fe2(trs); X2v=fe2(vas); y=tr[TARGET].values
vc=add_conditions(va)['cond'].values; yv=va[TARGET].values
def bagmlp(hid,alpha,n):
    ps=[make_pipeline(StandardScaler(),MLPRegressor(hid,solver='lbfgs',alpha=alpha,activation='tanh',max_iter=3000,random_state=i)).fit(X2t,y).predict(X2v) for i in range(n)]
    return np.mean(ps,0)
# ET reference (snapped)
pe=np.mean([ExtraTreesRegressor(700,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2t,y).predict(X2v) for s in range(3)],0)
report('ET ref', metrics(yv,pe,vc))
for hid,alpha in [((96,48),3e-3),((96,48),1e-2),((128,64),1e-2),((64,32),3e-3)]:
    pm=bagmlp(hid,alpha,8)
    report(f'MLP snap {hid} a{alpha}', metrics(yv,pm,vc))
    report(f'  0.6ET+0.4MLP', metrics(yv,0.6*pe+0.4*pm,vc))
"

cd /app && timeout 295 python3 -c "
import numpy as np, pandas as pd, warnings, pickle
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL); ALLs=apply_snapper(ALL,lev)
G=ALL['cond'].values; Y=ALL[TARGET].values; X2=fe2(ALLs); X3=fe3(ALLs)
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=8; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
oe=np.zeros(len(Y)); om=np.zeros(len(Y))
for f in range(NS):
    trm=FOLDS!=f; tem=FOLDS==f
    pe=[ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2[trm],Y[trm]).predict(X2[tem]) for s in range(3)]
    pe+=[ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(X3[trm],Y[trm]).predict(X3[tem]) for s in range(2)]
    oe[tem]=np.mean(pe,0)
    pm=[make_pipeline(StandardScaler(),MLPRegressor((96,48),solver='lbfgs',alpha=0.01,activation='tanh',max_iter=2500,random_state=i)).fit(X2[trm],Y[trm]).predict(X2[tem]) for i in range(4)]
    om[tem]=np.mean(pm,0)
pickle.dump({'oe':oe,'om':om,'Y':Y,'G':G},open('/app/etmlp_oof.pkl','wb'))
report('ET only [CV]', metrics(Y,oe,G))
report('MLP only [CV]', metrics(Y,om,G))
for w in [0.3,0.4,0.5]:
    report(f'{1-w:.1f}ET+{w:.1f}MLP [CV]', metrics(Y,(1-w)*oe+w*om,G))
"

cd /app && python3 -c "
import numpy as np, pickle
from harness import metrics, report
d=pickle.load(open('/app/etmlp_oof.pkl','rb')); oe=d['oe']; om=d['om']; Y=d['Y']; G=d['G']
report('ET only [CV]', metrics(Y,oe,G))
report('MLP only [CV]', metrics(Y,om,G))
import numpy as np
for w in [0.25,0.3,0.35,0.4,0.45,0.5]:
    report(f'{1-w:.2f}ET+{w:.2f}MLP [CV]', metrics(Y,(1-w)*oe+w*om,G))
# distribution for best
import pandas as pd
for w in [0.4]:
    p=(1-w)*oe+w*om
    per=pd.DataFrame({'e':p-Y,'c':G}).groupby('c')['e'].apply(lambda s:np.sqrt(np.mean(s.values**2)))
    print('frac<=2.35:',round((per<=2.35).mean(),3),'n_cond',len(per))
"

cd /app && timeout 295 python3 -c "
import numpy as np, pandas as pd, warnings, pickle, time
warnings.filterwarnings('ignore')
from harness import *
from snap_util import fit_snapper, apply_snapper
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
ALL=add_conditions(pd.concat([tr,va],ignore_index=True))
lev=fit_snapper(ALL); ALLs=apply_snapper(ALL,lev)
G=ALL['cond'].values; Y=ALL[TARGET].values; X2=fe2(ALLs); X3=fe3(ALLs)
uniq=pd.unique(G); rng=np.random.RandomState(0); perm=rng.permutation(len(uniq))
NS=5; fo={c:(i%NS) for i,c in enumerate(uniq[perm])}; FOLDS=np.array([fo[c] for c in G])
t0=time.time()
oe=np.zeros(len(Y))
for f in range(NS):
    trm=FOLDS!=f; tem=FOLDS==f
    pe=[ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=s).fit(X2[trm],Y[trm]).predict(X2[tem]) for s in range(3)]
    pe+=[ExtraTreesRegressor(500,min_samples_leaf=1,n_jobs=-1,random_state=100+s).fit(X3[trm],Y[trm]).predict(X3[tem]) for s in range(2)]
    oe[tem]=np.mean(pe,0)
print('ET done %.0fs'%(time.time()-t0))
pickle.dump({'oe':oe,'Y':Y,'G':G},open('/app/et_oof.pkl','wb'))
om=np.zeros(len(Y))
for f in range(NS):
    trm=FOLDS!=f; tem=FOLDS==f
    pm=[make_pipeline(StandardScaler(),MLPRegressor((64,32),solver='lbfgs',alpha=0.01,activation='tanh',max_iter=1500,random_state=i)).fit(X2[trm],Y[trm]).predict(X2[tem]) for i in range(4)]
    om[tem]=np.mean(pm,0)
print('MLP done %.0fs'%(time.time()-t0))
pickle.dump({'oe':oe,'om':om,'Y':Y,'G':G},open('/app/etmlp_oof.pkl','wb'))
report('ET [CV5]',metrics(Y,oe,G)); report('MLP [CV5]',metrics(Y,om,G))
for w in [0.3,0.4,0.5]: report(f'{1-w:.1f}ET+{w:.1f}MLP',metrics(Y,(1-w)*oe+w*om,G))
"

cd /app && rm -f /app/*.pkl && rm -rf /tmp/isotest /tmp/run1.csv /tmp/run2.csv && echo "=== final files in /app ===" && ls -la /app/*.py /app/output/ && echo && echo "=== confirm inputs untouched (original 05:18 timestamps) ===" && ls -la --time-style=+%H:%M data/*.csv && echo && echo "=== final output sanity ===" && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('/app/output/predictions.csv')
print('columns:', list(p.columns))
print('rows:', len(p), '| finite:', bool(np.isfinite(p.iloc[:,1]).all()), '| unique preds:', p.iloc[:,1].nunique())
print('pred range: [%.2f, %.2f]'%(p.iloc[:,1].min(), p.iloc[:,1].max()))
"

cd /app && rm -f harness.py exp.py cv.py cv2.py cv3.py oof_bank.py blend_search.py blend_model.py val_blend.py robust_blend.py snap_util.py mlp_test.py && echo "=== /app/*.py now ===" && ls /app/*.py && echo && echo "=== grader-style re-run: discard output, re-run script ===" && rm -f /app/output/predictions.csv && cd / && python3 /app/train_and_predict.py && echo && echo "=== verify against test_features ===" && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('/app/output/predictions.csv'); t=pd.read_csv('/app/data/test_features.csv')
assert list(p.columns)==['sample_id','predicted_scaled_sound_pressure_level']
assert len(p)==len(t)
assert set(p['sample_id'].astype(str))==set(t['sample_id'].astype(str))
assert np.isfinite(p['predicted_scaled_sound_pressure_level']).all()
assert p['predicted_scaled_sound_pressure_level'].nunique()>1
print('FINAL CHECK PASSED: one finite, non-constant prediction per sample_id; columns exact.')
"

cd /app && sed -n '160,200p' train_and_predict.py