airfoil-self-noise

cd /app && ls -la && echo "---DATA---" && ls -la data/ && echo "---SCRIPT---" && cat train_and_predict.py

cd /app && echo "=== TRAIN HEAD ===" && head -5 data/train.csv && echo "=== VALIDATION HEAD ===" && head -5 data/validation.csv && echo "=== TEST FEATURES ===" && cat data/test_features.csv && echo "=== COUNTS ===" && wc -l data/*.csv

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('--- TRAIN describe ---')
print(tr.describe().T)
print('--- target stats train ---')
print(tr['scaled_sound_pressure_level'].describe())
print('--- target stats val ---')
print(va['scaled_sound_pressure_level'].describe())
for c in ['attack_angle','chord_length','free_stream_velocity']:
    print(c, 'train unique approx:', tr[c].round(2).nunique(), 'val:', va[c].round(2).nunique())
"

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')
all_ = pd.concat([tr,va])
print('chord_length sorted unique rounded 3:')
print(np.sort(all_['chord_length'].round(3).unique()))
print('velocity rounded 0:')
print(np.sort(all_['free_stream_velocity'].round(0).unique()))
print('velocity rounded 1 nunique:', all_['free_stream_velocity'].round(1).nunique())
print('attack_angle rounded 0 unique:')
print(np.sort(all_['attack_angle'].round(0).unique()))
print('freq min max:', all_['frequency'].min(), all_['frequency'].max())
print('thickness min max:', all_['suction_side_displacement_thickness'].min(), all_['suction_side_displacement_thickness'].max())
"

cd /app && python3 -c "
import sklearn; print('sklearn', sklearn.__version__)
import numpy, pandas, scipy; print('numpy', numpy.__version__, 'pandas', pandas.__version__, 'scipy', scipy.__version__)
for m in ['xgboost','lightgbm','catboost','torch','tensorflow']:
    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')
tf = pd.read_csv('data/test_features.csv')
# Is placeholder == validation features?
vm = va[tf.columns].reset_index(drop=True)
print('placeholder equals first 40 val rows:', np.allclose(vm.iloc[:40,1:].values, tf.iloc[:,1:].values))
print('ids match:', list(tf.sample_id[:3]), list(va.sample_id[:3]))
all_=pd.concat([tr,va])
ang=np.sort(all_['attack_angle'].values)
# cluster angles
clusters=[]; cur=[ang[0]]
for a in ang[1:]:
    if a-cur[-1]>0.5: clusters.append(cur); cur=[a]
    else: cur.append(a)
clusters.append(cur)
print('num angle clusters:', len(clusters))
print('angle cluster centers:', [round(np.mean(c),2) for c in clusters])
print('angle cluster spread(max-min):', [round(max(c)-min(c),3) for c in clusters][:20])
"

cd /app && cat > /tmp/cv_harness.py << 'EOF'
import pandas as pd, numpy as np
from sklearn.model_selection import GroupKFold

CHORDS=np.array([0.0254,0.0508,0.1016,0.1524,0.2286,0.3048])
VELS=np.array([31.7,39.6,55.5,71.3])
ANGLES=np.array([0.0,1.5,3.0,4.0,5.3,6.7,7.3,8.9,9.9,11.0,12.3,12.6,15.4,15.6,17.4,19.7,22.2])

def snap(v, grid):
    return grid[np.argmin(np.abs(grid[None,:]-np.asarray(v)[:,None]),axis=1)]

def condition_key(df):
    c=snap(df['chord_length'].values,CHORDS)
    u=snap(df['free_stream_velocity'].values,VELS)
    a=snap(df['attack_angle'].values,ANGLES)
    return pd.Series([f"{ai:.1f}_{ci:.4f}_{ui:.1f}" for ai,ci,ui in zip(a,c,u)],index=df.index)

def metrics(y_true, y_pred, cond):
    y_true=np.asarray(y_true); y_pred=np.asarray(y_pred)
    err=y_pred-y_true
    rmse=np.sqrt(np.mean(err**2)); mae=np.mean(np.abs(err))
    dfm=pd.DataFrame({'c':np.asarray(cond),'e':err})
    cr=dfm.groupby('c')['e'].apply(lambda e: np.sqrt(np.mean(e**2)))
    return dict(rmse=rmse,mae=mae,p90=np.percentile(cr,90),p95=np.percentile(cr,95),maxc=cr.max(),ncond=len(cr))

def group_cv(make_model, X, y, groups, cond, n_splits=5, seed=0):
    gkf=GroupKFold(n_splits=n_splits)
    oof=np.zeros(len(y))
    for tri,tei in gkf.split(X,y,groups):
        m=make_model()
        m.fit(X.iloc[tri],y.iloc[tri])
        oof[tei]=m.predict(X.iloc[tei])
    return metrics(y,oof,cond), oof
EOF
echo "harness written"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *
import pandas as pd, numpy as np
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
all_=pd.concat([tr,va],ignore_index=True)
# check snapping residuals
c=snap(all_['chord_length'].values,CHORDS); u=snap(all_['free_stream_velocity'].values,VELS); a=snap(all_['attack_angle'].values,ANGLES)
print('max chord snap resid %:', np.max(np.abs(c-all_.chord_length)/c)*100)
print('max vel snap resid %:', np.max(np.abs(u-all_.free_stream_velocity)/u)*100)
print('max angle snap resid (deg):', np.max(np.abs(a-all_.attack_angle)))
key=condition_key(all_)
print('num conditions total:', key.nunique(), 'rows:', len(all_))
print('rows per cond: min/median/max', key.value_counts().min(), key.value_counts().median(), key.value_counts().max())
# overlap train/val conditions
ktr=condition_key(tr); kva=condition_key(va)
print('train conds:', ktr.nunique(), 'val conds:', kva.nunique(), 'overlap:', len(set(ktr)&set(kva)))
"

cd /app && cat > /tmp/features.py << 'EOF'
import numpy as np, pandas as pd
RAW=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]

def make_features(df):
    f=df['frequency'].astype(float); a=df['attack_angle'].astype(float)
    c=df['chord_length'].astype(float); u=df['free_stream_velocity'].astype(float)
    d=df['suction_side_displacement_thickness'].astype(float)
    o=pd.DataFrame(index=df.index)
    lf=np.log10(f); ld=np.log10(d); lc=np.log10(c); lu=np.log10(u)
    o['log_freq']=lf; o['attack_angle']=a; o['log_chord']=lc; o['log_vel']=lu; o['log_thick']=ld
    # physics: Strouhal number St = f*delta/U ; Reynolds ~ c*U
    o['log_strouhal']=np.log10(f*d/u)
    o['log_reynolds']=np.log10(c*u)
    o['log_reynolds_d']=np.log10(d*u)
    # interactions
    o['lf_angle']=lf*a
    o['lf_logthick']=lf*ld
    o['lf_logchord']=lf*lc
    o['lf_logvel']=lf*lu
    o['angle_logthick']=a*ld
    o['angle_logchord']=a*lc
    o['lf2']=lf*lf
    o['angle2']=a*a
    o['raw_freq']=f
    return o

def Xy(df):
    return make_features(df), df['scaled_sound_pressure_level']
EOF
python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *; from features import *
import pandas as pd, numpy as np
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
Xtr,ytr=Xy(tr); Xva,yva=Xy(va); condva=condition_key(va)
m=make_pipeline(StandardScaler(),Ridge(alpha=10.0)).fit(Xtr,ytr)
print('Ridge(phys feats) val:',{k:round(v,3) for k,v in metrics(yva,m.predict(Xva),condva).items()})
"

cd /app && cat > /tmp/bench.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *; from features import *
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, RandomForestRegressor, ExtraTreesRegressor, GradientBoostingRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
Xtr,ytr=Xy(tr); Xva,yva=Xy(va); condva=condition_key(va)
alld=pd.concat([tr,va],ignore_index=True)
Xall,yall=Xy(alld); condall=condition_key(alld); groups=condall.values

def ev(name, make):
    m=make(); m.fit(Xtr,ytr)
    mv=metrics(yva,m.predict(Xva),condva)
    cvm,_=group_cv(make,Xall,yall,groups,condall,n_splits=5)
    print(f"{name:28s} VAL rmse={mv['rmse']:.3f} mae={mv['mae']:.3f} p90={mv['p90']:.2f} p95={mv['p95']:.2f} max={mv['maxc']:.2f} | CV rmse={cvm['rmse']:.3f} mae={cvm['mae']:.3f} p90={cvm['p90']:.2f} p95={cvm['p95']:.2f} max={cvm['maxc']:.2f}")

ev('HGB default', lambda: HistGradientBoostingRegressor(random_state=0))
ev('HGB l2=1,lr.05,leaf31', lambda: HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=20,random_state=0))
ev('RF 500', lambda: RandomForestRegressor(n_estimators=500,n_jobs=-1,random_state=0))
ev('ExtraTrees 500', lambda: ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0))
ev('KNN10', lambda: make_pipeline(StandardScaler(),KNeighborsRegressor(n_neighbors=10,weights='distance')))
ev('SVR rbf', lambda: make_pipeline(StandardScaler(),SVR(C=20,gamma='scale',epsilon=0.1)))
ev('MLP', lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=2000,alpha=1e-3,random_state=0)))
EOF
python3 /tmp/bench.py

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *
import pandas as pd, numpy as np
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
key=condition_key(alld)
alld['k']=key; alld['lf']=np.log10(alld.frequency)
res=[]
for k,g in alld.groupby('k'):
    if len(g)<6: continue
    x=g['lf'].values; y=g['scaled_sound_pressure_level'].values
    # fit cubic poly in log-frequency
    deg=min(4,len(g)-2)
    co=np.polyfit(x,y,deg); yp=np.polyval(co,x)
    res.append(y-yp)
res=np.concatenate(res)
print('within-condition residual std (deg<=4 fit): %.3f'%res.std())
print('within-condition residual RMSE: %.3f'%np.sqrt(np.mean(res**2)))
print('mean abs: %.3f'%np.mean(np.abs(res)))
"

cd /app && cat > /tmp/bench2.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *; from features import *
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, ExtraTreesRegressor, RandomForestRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, SplineTransformer
from sklearn.linear_model import Ridge
from sklearn.base import BaseEstimator, RegressorMixin, clone

tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
Xtr,ytr=Xy(tr); Xva,yva=Xy(va); condva=condition_key(va)
alld=pd.concat([tr,va],ignore_index=True)
Xall,yall=Xy(alld); condall=condition_key(alld); groups=condall.values

class Avg(BaseEstimator,RegressorMixin):
    def __init__(self, models, weights=None):
        self.models=models; self.weights=weights
    def fit(self,X,y):
        self.fitted_=[clone(m).fit(X,y) for m in self.models]; return self
    def predict(self,X):
        P=np.column_stack([m.predict(X) for m in self.fitted_])
        w=np.ones(P.shape[1]) if self.weights is None else np.array(self.weights)
        return P@w/w.sum()

def ev(name, make):
    m=make(); m.fit(Xtr,ytr)
    mv=metrics(yva,m.predict(Xva),condva)
    cvm,_=group_cv(make,Xall,yall,groups,condall,n_splits=5)
    print(f"{name:26s} VAL rmse={mv['rmse']:.3f} mae={mv['mae']:.3f} p90={mv['p90']:.2f} p95={mv['p95']:.2f} max={mv['maxc']:.2f} | CV rmse={cvm['rmse']:.3f} mae={cvm['mae']:.3f} p90={cvm['p90']:.2f} p95={cvm['p95']:.2f} max={cvm['maxc']:.2f}")

et=lambda: ExtraTreesRegressor(n_estimators=800,min_samples_leaf=1,max_features=0.6,n_jobs=-1,random_state=0)
hgb=lambda: HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0)
svr=lambda: make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.05))
mlp=lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=3000,alpha=1e-3,random_state=0))
spl=lambda: make_pipeline(StandardScaler(),SplineTransformer(n_knots=5,degree=3),Ridge(alpha=1.0))

ev('ET tuned', et)
ev('HGB tuned', hgb)
ev('SVR tuned', svr)
ev('Spline-Ridge', spl)
ev('ENS ET+HGB', lambda: Avg([et(),hgb()]))
ev('ENS ET+HGB+SVR', lambda: Avg([et(),hgb(),svr()]))
ev('ENS ET+HGB+SVR+MLP', lambda: Avg([et(),hgb(),svr(),mlp()]))
ev('ENS ET2+HGB+SVR', lambda: Avg([et(),hgb(),svr()],weights=[2,1,1]))
EOF
python3 /tmp/bench2.py

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *; from features import *
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
Xtr,ytr=Xy(tr); Xva,yva=Xy(va); condva=condition_key(va)
m=ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=0).fit(Xtr,ytr)
pred=m.predict(Xva)
va['err']=pred-yva; va['k']=condva.values
cr=va.groupby('k').apply(lambda g: pd.Series({'rmse':np.sqrt(np.mean(g.err**2)),'bias':g.err.mean(),'n':len(g),
   'angle':g.attack_angle.mean(),'chord':g.chord_length.mean(),'vel':g.free_stream_velocity.mean()}))
print(cr.sort_values('rmse',ascending=False).round(2).to_string())
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *; from features import *
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.model_selection import KFold
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=Xy(alld); condall=condition_key(alld)
# Random KFold (interpolation: conditions seen)
kf=KFold(5,shuffle=True,random_state=0); oof=np.zeros(len(yall))
for tri,tei in kf.split(Xall):
    m=ExtraTreesRegressor(n_estimators=600,max_features=0.6,n_jobs=-1,random_state=0).fit(Xall.iloc[tri],yall.iloc[tri])
    oof[tei]=m.predict(Xall.iloc[tei])
print('RANDOM KFold (interpolation):',{k:round(v,3) for k,v in metrics(yall,oof,condall).items()})
cvm,_=group_cv(lambda:ExtraTreesRegressor(n_estimators=600,max_features=0.6,n_jobs=-1,random_state=0),Xall,yall,condall.values,condall)
print('GROUP KFold (extrapolation):',{k:round(v,3) for k,v in cvm.items()})
"

cd /app && python3 -c "
import pandas as pd, numpy as np
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
f=alld.frequency; a=alld.attack_angle; c=alld.chord_length; u=alld.free_stream_velocity; d=alld.suction_side_displacement_thickness
y=alld.scaled_sound_pressure_level
St=f*d/u
# BPM-ish base amplitude
base=10*np.log10(d)+50*np.log10(u/340.0)
resid=y-base
import numpy as np
# correlation of resid with log St
lSt=np.log10(St)
print('corr(y, 10log d):', np.corrcoef(y,10*np.log10(d))[0,1].round(3))
print('corr(y, 50log u):', np.corrcoef(y,50*np.log10(u))[0,1].round(3))
print('corr(resid, logSt):', np.corrcoef(resid,lSt)[0,1].round(3))
# fit resid ~ poly(logSt) and check
for deg in [2,3,4,5]:
    co=np.polyfit(lSt,resid,deg); r=resid-np.polyval(co,lSt)
    print(f'resid~poly(logSt) deg{deg}: R2={1-r.var()/resid.var():.3f} rmse={np.sqrt((r**2).mean()):.3f}')
# full: y ~ poly(logSt) deg5 + linear(10logd,50logu,angle,logc)
import numpy as np
from numpy.linalg import lstsq
X=np.column_stack([np.ones_like(y)]+[lSt**k for k in range(1,6)]+[np.log10(d),np.log10(u),a,np.log10(c)])
coef,_,_,_=lstsq(X,y,rcond=None); yp=X@coef; r=y-yp
print('y~poly5(logSt)+phys linear: rmse=%.3f mae=%.3f R2=%.3f'%(np.sqrt((r**2).mean()),np.abs(r).mean(),1-r.var()/y.var()))
"

cd /app && cat > /tmp/ens_oof.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *; from features import *
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, ExtraTreesRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GroupKFold

alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=Xy(alld); condall=condition_key(alld); groups=condall.values

def makers():
    return [
     ('ET',lambda: ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=0)),
     ('HGB',lambda: HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0)),
     ('SVR',lambda: make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.05))),
     ('MLP',lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=3000,alpha=1e-3,random_state=0))),
    ]

gkf=GroupKFold(5)
oofs={n:np.zeros(len(yall)) for n,_ in makers()}
for tri,tei in gkf.split(Xall,yall,groups):
    for n,mk in makers():
        m=mk().fit(Xall.iloc[tri],yall.iloc[tri]); oofs[n][tei]=m.predict(Xall.iloc[tei])
ens=np.mean([oofs[n] for n,_ in makers()],axis=0)
m=metrics(yall,ens,condall)
print('ENSEMBLE group CV:',{k:round(v,3) for k,v in m.items()})
# per-condition rmse distribution
dfm=pd.DataFrame({'c':condall.values,'e':ens-yall.values})
cr=dfm.groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2))).sort_values()
print('num conditions:',len(cr))
print('frac <=2.35:',(cr<=2.35).mean().round(3))
print('count in (2.35,3.5]:',((cr>2.35)&(cr<=3.5)).sum())
print('worst 12:'); print(cr.tail(12).round(2).to_string())
np.save('/tmp/oof_ens.npy',ens); np.save('/tmp/yall.npy',yall.values)
EOF
python3 /tmp/ens_oof.py

cd /app && cat > /tmp/features2.py << 'EOF'
import numpy as np, pandas as pd
def make_features(df):
    f=df['frequency'].astype(float).values; a=df['attack_angle'].astype(float).values
    c=df['chord_length'].astype(float).values; u=df['free_stream_velocity'].astype(float).values
    d=df['suction_side_displacement_thickness'].astype(float).values
    lf=np.log10(f); ld=np.log10(d); lc=np.log10(c); lu=np.log10(u)
    nu=1.5e-5
    o={}
    o['log_freq']=lf; o['attack_angle']=a; o['log_chord']=lc; o['log_vel']=lu; o['log_thick']=ld
    o['log_St_d']=np.log10(f*d/u)       # displacement-thickness Strouhal
    o['log_St_c']=np.log10(f*c/u)       # chord Strouhal
    o['log_Re_c']=np.log10(c*u/nu)      # chord Reynolds
    o['log_Re_d']=np.log10(d*u/nu)      # thickness Reynolds
    o['mach']=u/340.0
    o['d_over_c']=d/c                    # relative BL thickness
    o['log_d_over_c']=np.log10(d/c)
    # interactions
    o['lf_angle']=lf*a; o['lf_ld']=lf*ld; o['lf_lc']=lf*lc; o['lf_lu']=lf*lu
    o['a_ld']=a*ld; o['a_lc']=a*lc; o['a_lu']=a*lu
    o['lf2']=lf*lf; o['angle2']=a*a; o['ld2']=ld*ld
    o['raw_freq']=f; o['raw_thick']=d
    o['sin_a']=np.sin(np.radians(a))
    return pd.DataFrame(o,index=df.index)
def Xy(df):
    return make_features(df), df['scaled_sound_pressure_level']
EOF
python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, ExtraTreesRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=F.Xy(alld); condall=condition_key(alld); groups=condall.values
makers=[
 lambda: ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=0),
 lambda: HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0),
 lambda: make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.05)),
 lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=3000,alpha=1e-3,random_state=0)),
]
gkf=GroupKFold(5); oofs=[np.zeros(len(yall)) for _ in makers]
for tri,tei in gkf.split(Xall,yall,groups):
    for i,mk in enumerate(makers):
        oofs[i][tei]=mk().fit(Xall.iloc[tri],yall.iloc[tri]).predict(Xall.iloc[tei])
ens=np.mean(oofs,axis=0)
m=metrics(yall,ens,condall)
print('ENS richfeat group CV:',{k:round(v,3) for k,v in m.items()})
cr=pd.DataFrame({'c':condall.values,'e':ens-yall.values}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
print('frac<=2.35:',(cr<=2.35).mean().round(3))
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from cv_harness import *
import pandas as pd, numpy as np
ens=np.load('/tmp/oof_ens.npy'); yall=np.load('/tmp/yall.npy')
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
cond=condition_key(alld).values; lf=np.log10(alld.frequency.values)
print('RAW ENS:',{k:round(v,3) for k,v in metrics(yall,ens,cond).items()})
def smooth(pred, deg):
    out=pred.copy()
    for c in np.unique(cond):
        idx=np.where(cond==c)[0]
        if len(idx)<deg+2: continue
        x=lf[idx]; y=pred[idx]; co=np.polyfit(x,y,min(deg,len(idx)-1)); out[idx]=np.polyval(co,x)
    return out
for deg in [2,3,4,5]:
    sm=smooth(ens,deg)
    m=metrics(yall,sm,cond)
    cr=pd.DataFrame({'c':cond,'e':sm-yall}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'SMOOTH deg{deg}:',{k:round(v,3) for k,v in m.items()},'frac<=2.35:',round((cr<=2.35).mean(),3))
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel, ConstantKernel, DotProduct, Matern
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=F.Xy(alld); condall=condition_key(alld); groups=condall.values
def ev(name,make):
    cvm,_=group_cv(make,Xall,yall,groups,condall,5)
    print(f'{name:22s} CV rmse={cvm[\"rmse\"]:.3f} mae={cvm[\"mae\"]:.3f} p90={cvm[\"p90\"]:.2f} p95={cvm[\"p95\"]:.2f} max={cvm[\"maxc\"]:.2f}')
ev('KernelRidge rbf', lambda: make_pipeline(StandardScaler(),KernelRidge(alpha=0.1,kernel='rbf',gamma=0.05)))
ev('KernelRidge rbf2', lambda: make_pipeline(StandardScaler(),KernelRidge(alpha=0.3,kernel='rbf',gamma=0.1)))
k=ConstantKernel(1.0)*Matern(length_scale=np.ones(Xall.shape[1]),nu=2.5)+WhiteKernel(0.5)
ev('GP Matern-ARD', lambda: make_pipeline(StandardScaler(),GaussianProcessRegressor(kernel=k,alpha=1e-6,normalize_y=True,n_restarts_optimizer=0)))
ev('RF tuned', lambda: RandomForestRegressor(n_estimators=600,max_features=0.5,min_samples_leaf=2,n_jobs=-1,random_state=0))
ev('GB', lambda: GradientBoostingRegressor(n_estimators=500,learning_rate=0.03,max_depth=3,subsample=0.8,random_state=0))
"

restart: true

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.kernel_ridge import KernelRidge
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=F.Xy(alld); condall=condition_key(alld); groups=condall.values
def ev(name,make):
    cvm,_=group_cv(make,Xall,yall,groups,condall,5)
    print(f'{name:22s} CV rmse={cvm[\"rmse\"]:.3f} mae={cvm[\"mae\"]:.3f} p90={cvm[\"p90\"]:.2f} p95={cvm[\"p95\"]:.2f} max={cvm[\"maxc\"]:.2f}')
for g,a in [(0.01,0.1),(0.02,0.5),(0.03,1.0),(0.05,2.0)]:
    ev(f'KRR g{g} a{a}', lambda g=g,a=a: make_pipeline(StandardScaler(),KernelRidge(alpha=a,kernel='rbf',gamma=g)))
"

cd /app && cat > /tmp/make_oof.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, ExtraTreesRegressor, RandomForestRegressor, GradientBoostingRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GroupKFold

alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=F.Xy(alld); cond=condition_key(alld); groups=cond.values
Xnr=Xall.drop(columns=['raw_freq','raw_thick'])

learners={
 'ET': (Xall, lambda: ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=0)),
 'ETnr': (Xnr, lambda: ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=1)),
 'HGB': (Xall, lambda: HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0)),
 'RF': (Xall, lambda: RandomForestRegressor(n_estimators=600,max_features=0.5,min_samples_leaf=2,n_jobs=-1,random_state=0)),
 'GB': (Xnr, lambda: GradientBoostingRegressor(n_estimators=500,learning_rate=0.03,max_depth=3,subsample=0.8,random_state=0)),
 'SVR': (Xnr, lambda: make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.05))),
 'MLP0': (Xnr, lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=3000,alpha=1e-3,random_state=0))),
 'MLP1': (Xnr, lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(200,100),max_iter=3000,alpha=3e-3,random_state=1))),
 'MLP2': (Xnr, lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=3000,alpha=1e-3,random_state=2))),
}
gkf=GroupKFold(5)
splits=list(gkf.split(Xall,yall,groups))
oof={}
for name,(Xd,mk) in learners.items():
    p=np.zeros(len(yall))
    for tri,tei in splits:
        p[tei]=mk().fit(Xd.iloc[tri],yall.iloc[tri]).predict(Xd.iloc[tei])
    oof[name]=p
    m=metrics(yall,p,cond)
    print(f'{name:6s} rmse={m["rmse"]:.3f} mae={m["mae"]:.3f} p90={m["p90"]:.2f} p95={m["p95"]:.2f} max={m["maxc"]:.2f}',flush=True)
np.savez('/tmp/oof_all.npz', y=yall.values, cond=cond.values, **oof)
print('DONE')
EOF
nohup python3 /tmp/make_oof.py > /tmp/oof_log.txt 2>&1 &
echo "started pid $!"

sleep 60 && cat /tmp/oof_log.txt

sleep 75 && cat /tmp/oof_log.txt

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
cond=condition_key(alld); y=alld['scaled_sound_pressure_level']
f=alld.frequency.values; a=alld.attack_angle.values; c=alld.chord_length.values
u=alld.free_stream_velocity.values; d=alld.suction_side_displacement_thickness.values
lf=np.log10(f); ld=np.log10(d); lc=np.log10(c); lu=np.log10(u)
feats={
 'freq,d,U(+St,Re)': np.column_stack([lf,ld,lu,np.log10(f*d/u),np.log10(d*u/1.5e-5),u/340]),
 '+angle': np.column_stack([lf,ld,lu,np.log10(f*d/u),np.log10(d*u/1.5e-5),u/340,a]),
 '+angle+chord': np.column_stack([lf,ld,lu,lc,np.log10(f*d/u),np.log10(f*c/u),np.log10(d*u/1.5e-5),np.log10(c*u/1.5e-5),u/340,a]),
 'no_thick(a,c,U,f)': np.column_stack([lf,a,lc,lu,np.log10(f*c/u),np.log10(c*u/1.5e-5)]),
}
for name,Xm in feats.items():
    Xd=pd.DataFrame(Xm)
    cvm,_=group_cv(lambda:ExtraTreesRegressor(n_estimators=600,max_features=0.7,n_jobs=-1,random_state=0),Xd,y,cond.values,cond,5)
    cr=pd.DataFrame({'c':cond.values,'e':_-y.values}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'ET [{name:22s}] rmse={cvm[\"rmse\"]:.3f} mae={cvm[\"mae\"]:.3f} p90={cvm[\"p90\"]:.2f} p95={cvm[\"p95\"]:.2f} max={cvm[\"maxc\"]:.2f} frac<=2.35={ (cr<=2.35).mean():.2f}')
"

cd /app && cat > /tmp/val_eval.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, ExtraTreesRegressor, RandomForestRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
Xtr,ytr=F.Xy(tr); Xva,yva=F.Xy(va); cva=condition_key(va)
defs={
 'ET': lambda: ExtraTreesRegressor(n_estimators=1000,max_features=0.6,n_jobs=-1,random_state=0),
 'HGB': lambda: HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0),
 'RF': lambda: RandomForestRegressor(n_estimators=800,max_features=0.5,min_samples_leaf=2,n_jobs=-1,random_state=0),
 'SVR': lambda: make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.05)),
 'MLP': lambda: make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=(128,128,64),max_iter=3000,alpha=1e-3,random_state=0)),
}
P={}
for n,mk in defs.items():
    P[n]=mk().fit(Xtr,ytr).predict(Xva)
    m=metrics(yva,P[n],cva)
    print(f'{n:5s} VAL rmse={m["rmse"]:.3f} mae={m["mae"]:.3f} p90={m["p90"]:.2f} p95={m["p95"]:.2f} max={m["maxc"]:.2f}')
for combo in [['ET','HGB'],['ET','HGB','RF'],['ET','HGB','SVR','MLP'],['ET','HGB','RF','SVR','MLP']]:
    pr=np.mean([P[n] for n in combo],axis=0); m=metrics(yva,pr,cva)
    print(f'BLEND {"+".join(combo):20s} rmse={m["rmse"]:.3f} mae={m["mae"]:.3f} p90={m["p90"]:.2f} p95={m["p95"]:.2f} max={m["maxc"]:.2f}')
np.savez('/tmp/valP.npz', y=yva.values, cond=cva.values, **P)
EOF
timeout 250 python3 /tmp/val_eval.py

cd /app && timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import numpy as np, pandas as pd
d=np.load('/tmp/valP.npz')
y=d['y']; cond=d['cond']
pred=np.mean([d['ET'],d['HGB'],d['SVR'],d['MLP']],axis=0)
err=pred-y
df=pd.DataFrame({'c':cond,'e':err})
rows=[]
for c,g in df.groupby('c'):
    e=g.e.values; rmse=np.sqrt(np.mean(e**2)); bias=e.mean(); shape=np.sqrt(np.mean((e-bias)**2))
    rows.append((c,len(e),rmse,bias,shape))
r=pd.DataFrame(rows,columns=['c','n','rmse','bias','shape']).sort_values('rmse',ascending=False)
print(r.round(2).to_string(index=False))
print()
print('mean |bias|=%.3f mean shape=%.3f'%(r.bias.abs().mean(),r.shape.mean()))
print('conditions with rmse>2.35: %d of %d'%((r.rmse>2.35).sum(),len(r)))
print('of those, bias-dominated (|bias|>shape):',((r.rmse>2.35)&(r.bias.abs()>r.shape)).sum())
"

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd
d=np.load('/tmp/valP.npz',allow_pickle=True)
y=d['y']; cond=d['cond']
pred=np.mean([d['ET'],d['HGB'],d['SVR'],d['MLP']],axis=0)
err=pred-y
df=pd.DataFrame({'c':cond,'e':err})
rows=[]
for c,g in df.groupby('c'):
    e=g.e.values; rmse=np.sqrt(np.mean(e**2)); bias=e.mean(); shape=np.sqrt(np.mean((e-bias)**2))
    rows.append((c,len(e),rmse,bias,shape))
r=pd.DataFrame(rows,columns=['c','n','rmse','bias','shape']).sort_values('rmse',ascending=False)
print(r.round(2).to_string(index=False))
print('mean |bias|=%.3f mean shape=%.3f'%(r.bias.abs().mean(),r.shape.mean()))
print('conditions with rmse>2.35: %d of %d; bias-dominated:'%((r.rmse>2.35).sum(),len(r)),((r.rmse>2.35)&(r.bias.abs()>r.shape)).sum())
"

cd /app && cat > /tmp/val_eval2.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.ensemble import HistGradientBoostingRegressor, ExtraTreesRegressor
from sklearn.svm import SVR
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
Xtr,ytr=F.Xy(tr); Xva,yva=F.Xy(va); cva=condition_key(va)
P={}
P['ET']=ExtraTreesRegressor(n_estimators=1000,max_features=0.6,n_jobs=-1,random_state=0).fit(Xtr,ytr).predict(Xva)
P['HGB']=HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0).fit(Xtr,ytr).predict(Xva)
P['SVR']=make_pipeline(StandardScaler(),SVR(C=30,gamma='scale',epsilon=0.05)).fit(Xtr,ytr).predict(Xva)
mlps=[]
for s in range(6):
    arch=[(128,128,64),(200,100),(150,150,75),(256,128),(128,96,64,32),(180,120,60)][s]
    pr=make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=arch,max_iter=4000,alpha=1e-3,random_state=s,early_stopping=False)).fit(Xtr,ytr).predict(Xva)
    mlps.append(pr)
P['MLP']=np.mean(mlps,axis=0)
def show(name,pr):
    m=metrics(yva,pr,cva); print(f'{name:24s} rmse={m["rmse"]:.3f} mae={m["mae"]:.3f} p90={m["p90"]:.2f} p95={m["p95"]:.2f} max={m["maxc"]:.2f}')
show('MLPx6',P['MLP'])
for combo in [['ET','HGB','SVR','MLP'],['ET','MLP'],['ET','HGB','MLP'],['ET','SVR','MLP']]:
    show('+'.join(combo),np.mean([P[n] for n in combo],axis=0))
# weight search (coarse) over ET,HGB,SVR,MLP minimizing composite
best=None
import itertools
names=['ET','HGB','SVR','MLP']
for ws in itertools.product([0,1,2,3],repeat=4):
    if sum(ws)==0: continue
    w=np.array(ws)/sum(ws); pr=sum(w[i]*P[names[i]] for i in range(4))
    m=metrics(yva,pr,cva)
    score=(m['p90']/2.35)+(m['mae']/1.55)+(m['rmse']/2.25)+0.3*(m['maxc']/5.6)
    if best is None or score<best[0]: best=(score,ws,m)
print('BEST weights',best[1],{k:round(v,3) for k,v in best[2].items()})
np.savez('/tmp/valP2.npz', y=yva.values, cond=cva.values, **P)
EOF
timeout 280 python3 /tmp/val_eval2.py

cd /app && timeout 120 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import numpy as np, pandas as pd
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
alld['k']=condition_key(alld).values; alld['lf']=np.log10(alld.frequency)
# for each condition find peak freq (argmax SPL) and shape
rows=[]
for k,g in alld.groupby('k'):
    g=g.sort_values('lf')
    i=g.scaled_sound_pressure_level.values.argmax()
    rows.append((k,len(g),g.lf.values[i],g.scaled_sound_pressure_level.max(),g.scaled_sound_pressure_level.min(),
                 g.attack_angle.mean(),g.chord_length.mean(),g.free_stream_velocity.mean(),g.suction_side_displacement_thickness.mean()))
r=pd.DataFrame(rows,columns=['k','n','lf_peak','smax','smin','a','c','u','d'])
# how often is peak at the lowest frequency (monotonic decreasing)?
print('fraction peak at lowest freq bin:', (r.groupby('k').head(1).lf_peak.values==[alld[alld.k==k].lf.min() for k in r.k]).mean().round(2) if False else 'skip')
lfmins=alld.groupby('k').lf.min(); 
r['at_low']= [abs(lp-lfmins[k])<0.05 for k,lp in zip(r.k,r.lf_peak)]
print('frac peak at lowest bin:',r.at_low.mean().round(2))
print('lf_peak range:',r.lf_peak.min().round(2),r.lf_peak.max().round(2))
# regress lf_peak on log features
import numpy as np
X=np.column_stack([np.ones(len(r)),np.log10(r.d),np.log10(r.u),np.log10(r.c),r.a])
b,_,_,_=np.linalg.lstsq(X,r.lf_peak,rcond=None); pr=X@b; resid=r.lf_peak-pr
print('lf_peak regression R2=%.2f resid_std=%.3f'%(1-resid.var()/r.lf_peak.var(),resid.std()))
print('dynamic range (smax-smin) median:',(r.smax-r.smin).median().round(1))
"

cd /app && cat > /tmp/features3.py << 'EOF'
import numpy as np, pandas as pd
import sys; sys.path.insert(0,'/tmp')
from cv_harness import condition_key

def base_feats(df):
    f=df['frequency'].astype(float).values; a=df['attack_angle'].astype(float).values
    c=df['chord_length'].astype(float).values; u=df['free_stream_velocity'].astype(float).values
    d=df['suction_side_displacement_thickness'].astype(float).values
    lf=np.log10(f); ld=np.log10(d); lc=np.log10(c); lu=np.log10(u); nu=1.5e-5
    o={}
    o['log_freq']=lf; o['attack_angle']=a; o['log_chord']=lc; o['log_vel']=lu; o['log_thick']=ld
    o['log_St_d']=np.log10(f*d/u); o['log_St_c']=np.log10(f*c/u)
    o['log_Re_c']=np.log10(c*u/nu); o['log_Re_d']=np.log10(d*u/nu)
    o['mach']=u/340.0; o['d_over_c']=d/c; o['log_d_over_c']=np.log10(d/c)
    o['lf_angle']=lf*a; o['lf_ld']=lf*ld; o['lf_lc']=lf*lc; o['lf_lu']=lf*lu
    o['a_ld']=a*ld; o['a_lc']=a*lc; o['a_lu']=a*lu
    o['lf2']=lf*lf; o['angle2']=a*a; o['ld2']=ld*ld
    o['sin_a']=np.sin(np.radians(a))
    return pd.DataFrame(o,index=df.index), dict(lf=lf,ld=ld,lc=lc,lu=lu,a=a)

from sklearn.base import BaseEstimator, TransformerMixin
class PeakRel(BaseEstimator, TransformerMixin):
    """Adds peak-relative log-frequency features. Fits a peak-location regression from training labels."""
    def fit(self, df, y):
        df=df.reset_index(drop=True); y=np.asarray(y)
        k=condition_key(df).values
        rows=[]; 
        import pandas as pd
        g=pd.DataFrame({'k':k,'lf':np.log10(df['frequency'].astype(float).values),'y':y,
                        'ld':np.log10(df['suction_side_displacement_thickness'].astype(float).values),
                        'lu':np.log10(df['free_stream_velocity'].astype(float).values),
                        'lc':np.log10(df['chord_length'].astype(float).values),
                        'a':df['attack_angle'].astype(float).values})
        feats=[]; targ=[]
        for key,gg in g.groupby('k'):
            if len(gg)<4: continue
            # smooth peak: fit quadratic in lf, take vertex within range
            co=np.polyfit(gg.lf,gg.y,2)
            if co[0]<0:
                lfp=-co[1]/(2*co[0]); lfp=min(max(lfp,gg.lf.min()),gg.lf.max())
            else:
                lfp=gg.lf.values[gg.y.values.argmax()]
            feats.append([1,gg.ld.mean(),gg.lu.mean(),gg.lc.mean(),gg.a.mean(),gg.a.mean()**2]); targ.append(lfp)
        A=np.array(feats); b=np.array(targ)
        self.coef_,_,_,_=np.linalg.lstsq(A,b,rcond=None)
        return self
    def _predict_peak(self, parts):
        A=np.column_stack([np.ones_like(parts['lf']),parts['ld'],parts['lu'],parts['lc'],parts['a'],parts['a']**2])
        # use row-level feature means? peak depends on condition-level; row features give same since condition-constant-ish
        return A@self.coef_
    def transform(self, df):
        base,parts=base_feats(df)
        lfp=self._predict_peak(parts)
        rel=parts['lf']-lfp
        base['rel_lf']=rel; base['rel_lf2']=rel*rel; base['rel_lf3']=rel**3
        base['rel_pos']=np.maximum(rel,0); base['rel_neg']=np.minimum(rel,0)
        return base.values
EOF
echo "written"
timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
from features3 import PeakRel
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.pipeline import make_pipeline
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
ytr=tr['scaled_sound_pressure_level']; yva=va['scaled_sound_pressure_level']; cva=condition_key(va)
for name,mk in [('ET',lambda:ExtraTreesRegressor(n_estimators=1000,max_features=0.6,n_jobs=-1,random_state=0)),
                ('HGB',lambda:HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0))]:
    pipe=make_pipeline(PeakRel(),mk()); pipe.fit(t
…[truncated]

cd /app && cat > /tmp/cv_final.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=F.Xy(alld); cond=condition_key(alld); groups=cond.values
gkf=GroupKFold(5); splits=list(gkf.split(Xall,yall,groups))
def oof(mk,Xd):
    p=np.zeros(len(yall))
    for tri,tei in splits: p[tei]=mk().fit(Xd.iloc[tri],yall.iloc[tri]).predict(Xd.iloc[tei])
    return p
def rep(name,p):
    m=metrics(yall,p,cond); cr=pd.DataFrame({'c':groups,'e':p-yall.values}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'{name:26s} rmse={m["rmse"]:.3f} mae={m["mae"]:.3f} p90={m["p90"]:.2f} p95={m["p95"]:.2f} max={m["maxc"]:.2f} frac<=2.35={(cr<=2.35).mean():.2f}',flush=True)
    return p
et=oof(lambda:ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=0),Xall); rep('ET',et)
etr=oof(lambda:ExtraTreesRegressor(n_estimators=800,max_features=0.6,min_samples_leaf=3,n_jobs=-1,random_state=0),Xall); rep('ET msl3',etr)
hgb=oof(lambda:HistGradientBoostingRegressor(max_iter=800,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0),Xall); rep('HGB',hgb)
mlp=np.mean([oof(lambda s=s:make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=[(128,128,64),(200,100),(150,150,75)][s],max_iter=4000,alpha=1e-3,random_state=s)),Xall) for s in range(3)],axis=0); rep('MLPx3',mlp)
rep('ET+HGB+MLP',(et+hgb+mlp)/3)
rep('1ET+1HGB+3MLP',(et+hgb+3*mlp)/5)
rep('2ET+1HGB+2MLP',(2*et+hgb+2*mlp)/5)
rep('ETr+HGB+MLP',(etr+hgb+mlp)/3)
np.savez('/tmp/oof_final.npz',y=yall.values,cond=groups,et=et,etr=etr,hgb=hgb,mlp=mlp)
print('DONE')
EOF
nohup python3 /tmp/cv_final.py > /tmp/cvf_log.txt 2>&1 &
echo "pid $!"

sleep 120 && cat /tmp/cvf_log.txt

cd /app && timeout 120 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import numpy as np, pandas as pd
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
alld['k']=condition_key(alld).values
for col in ['attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']:
    cv=alld.groupby('k')[col].apply(lambda s: s.std()/ (abs(s.mean())+1e-9))
    print(f'{col:36s} within-cond CoV median={cv.median():.4f} max={cv.max():.4f}')
# is delta* constant within condition (ignoring noise)?
d=alld.groupby('k')['suction_side_displacement_thickness'].agg(['mean','std','min','max'])
print('delta* within-cond relative spread (max-min)/mean median:', ((d['max']-d['min'])/d['mean']).median().round(3))
"

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
from features3 import PeakRel
import features2 as F
import pandas as pd, numpy as np
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
tr=pd.read_csv('data/train.csv'); va=pd.read_csv('data/validation.csv')
ytr=tr['scaled_sound_pressure_level']; yva=va['scaled_sound_pressure_level']; cva=condition_key(va)
# MLP with PeakRel
def mlp_pr(s,arch):
    return make_pipeline(PeakRel(),StandardScaler(),MLPRegressor(hidden_layer_sizes=arch,max_iter=4000,alpha=1e-3,random_state=s))
archs=[(128,128,64),(200,100),(150,150,75)]
prs=[]
for s in range(3):
    p=mlp_pr(s,archs[s]); p.fit(tr,ytr); prs.append(p.predict(va))
mlp_pr_pred=np.mean(prs,axis=0)
m=metrics(yva,mlp_pr_pred,cva); print('MLPx3+PeakRel VAL',{k:round(v,3) for k,v in m.items()})
# compare plain MLP rich
Xtr,_=F.Xy(tr); Xva,_=F.Xy(va)
prs2=[make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=archs[s],max_iter=4000,alpha=1e-3,random_state=s)).fit(Xtr,ytr).predict(Xva) for s in range(3)]
mlp_plain=np.mean(prs2,axis=0)
print('MLPx3 plain VAL',{k:round(v,3) for k,v in metrics(yva,mlp_plain,cva).items()})
" 2>&1 | grep -v Warning

cd /app && timeout 280 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import features2 as F
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('data/train.csv'),pd.read_csv('data/validation.csv')],ignore_index=True)
Xall,yall=F.Xy(alld); cond=condition_key(alld); groups=cond.values
for nf in [5,10,20]:
    gkf=GroupKFold(nf); 
    et=np.zeros(len(yall)); hg=np.zeros(len(yall))
    for tri,tei in gkf.split(Xall,yall,groups):
        et[tei]=ExtraTreesRegressor(n_estimators=600,max_features=0.6,n_jobs=-1,random_state=0).fit(Xall.iloc[tri],yall.iloc[tri]).predict(Xall.iloc[tei])
        hg[tei]=HistGradientBoostingRegressor(max_iter=600,learning_rate=0.04,max_leaf_nodes=31,l2_regularization=1.0,min_samples_leaf=15,random_state=0).fit(Xall.iloc[tri],yall.iloc[tri]).predict(Xall.iloc[tei])
    bl=(et+hg)/2
    m=metrics(yall,bl,cond); cr=pd.DataFrame({'c':groups,'e':bl-yall.values}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'{nf}-fold (train~{int(82*(nf-1)/nf)} conds) ET+HGB: rmse={m[\"rmse\"]:.3f} mae={m[\"mae\"]:.3f} p90={m[\"p90\"]:.2f} p95={m[\"p95\"]:.2f} max={m[\"maxc\"]:.2f} frac<=2.35={(cr<=2.35).mean():.2f}')
"

cd /app && timeout 100 python3 -c "
import numpy as np, pandas as pd, itertools, sys; sys.path.insert(0,'/tmp')
from cv_harness import metrics
d=np.load('/tmp/oof_final.npz',allow_pickle=True)
y=d['y']; cond=d['cond']; et=d['et']; hgb=d['hgb']; mlp=d['mlp']
def sc(p):
    m=metrics(y,p,cond); return m
best=[]
for we,wh,wm in itertools.product(range(0,5),repeat=3):
    if we+wh+wm==0: continue
    p=(we*et+wh*hgb+wm*mlp)/(we+wh+wm); m=sc(p)
    best.append((m['p90'],m['rmse'],m['mae'],m['p95'],m['maxc'],(we,wh,wm)))
best.sort()
print('Top by p90 (5-fold OOF):')
for b in best[:6]:
    print(f'  w={b[5]} p90={b[0]:.3f} rmse={b[1]:.3f} mae={b[2]:.3f} p95={b[3]:.3f} max={b[4]:.3f}')
# balanced score
bal=sorted(best,key=lambda b:max(b[1]/2.25,b[2]/1.55,b[0]/2.35,b[3]/4.75,b[4]/5.6))
print('Top by bottleneck ratio:')
for b in bal[:6]:
    print(f'  w={b[5]} p90={b[0]:.3f} rmse={b[1]:.3f} mae={b[2]:.3f} p95={b[3]:.3f} max={b[4]:.3f} bneck={max(b[1]/2.25,b[2]/1.55,b[0]/2.35):.3f}')
"

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

Trains a physics-informed ensemble (ExtraTrees + HistGradientBoosting + MLP)
on the labeled public data and writes calibrated predictions for the
grader-staged evaluation features.

The task holds out *complete* aerodynamic condition groups
``(attack_angle, chord_length, free_stream_velocity)``, so the model is
designed and blended to generalize to unseen physical regimes rather than to
interpolate nearby rows. Feature engineering follows the Brooks-Pope-Marcolini
(BPM) self-noise scalings (Strouhal/Reynolds numbers, log amplitude terms),
which extrapolate more gracefully than raw coordinates. The ensemble averages a
low-bias tree model, a boosted tree model, and smooth neural nets to shrink the
per-condition error tail that the grader penalizes (p90/p95/max condition RMSE).
"""

from pathlib import Path
import warnings

import numpy as np
import pandas as pd

from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import 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",
]


def make_features(df: pd.DataFrame) -> pd.DataFrame:
    """Physics-informed feature map (BPM self-noise scalings + interactions)."""
    f = np.asarray(df["frequency"], dtype=float)
    a = np.asarray(df["attack_angle"], dtype=float)
    c = np.asarray(df["chord_length"], dtype=float)
    u = np.asarray(df["free_stream_velocity"], dtype=float)
    d = np.asarray(df["suction_side_displacement_thickness"], dtype=float)

    # Guard against non-positive values before taking logs.
    eps = 1e-12
    f = np.clip(f, eps, None)
    c = np.clip(c, eps, None)
    u = np.clip(u, eps, None)
    d = np.clip(d, eps, None)

    lf = np.log10(f)
    ld = np.log10(d)
    lc = np.log10(c)
    lu = np.log10(u)
    nu = 1.5e-5  # kinematic viscosity of air (m^2/s)

    o = {}
    # Primary (log) coordinates.
    o["log_freq"] = lf
    o["attack_angle"] = a
    o["log_chord"] = lc
    o["log_vel"] = lu
    o["log_thick"] = ld
    # Dimensionless BPM-style groups.
    o["log_St_d"] = np.log10(f * d / u)      # displacement-thickness Strouhal
    o["log_St_c"] = np.log10(f * c / u)      # chord Strouhal
    o["log_Re_c"] = np.log10(c * u / nu)     # chord Reynolds
    o["log_Re_d"] = np.log10(d * u / nu)     # thickness Reynolds
    o["mach"] = u / 340.0
    o["d_over_c"] = d / c
    o["log_d_over_c"] = np.log10(d / c)
    # Interactions (let smooth models capture coupled trends).
    o["lf_angle"] = lf * a
    o["lf_ld"] = lf * ld
    o["lf_lc"] = lf * lc
    o["lf_lu"] = lf * lu
    o["a_ld"] = a * ld
    o["a_lc"] = a * lc
    o["a_lu"] = a * lu
    o["lf2"] = lf * lf
    o["angle2"] = a * a
    o["ld2"] = ld * ld
    o["sin_a"] = np.sin(np.radians(a))
    o["raw_freq"] = f
    o["raw_thick"] = d

    out = pd.DataFrame(o, index=df.index)
    return out.replace([np.inf, -np.inf], np.nan).fillna(0.0)


def load_labeled_data() -> pd.DataFrame:
    parts = [pd.read_csv(DATA_DIR / "train.csv")]
    validation_path = DATA_DIR / "validation.csv"
    if validation_path.exists():
        parts.append(pd.read_csv(validation_path))
    data = pd.concat(parts, ignore_index=True)
    # Keep only rows with a usable (finite) target.
    data = data[np.isfinite(pd.to_numeric(data[TARGET], errors="coerce"))]
    return data.reset_index(drop=True)


def load_evaluation_features() -> pd.DataFrame:
    test_path = DATA_DIR / "test_features.csv"
    if test_path.exists():
        return pd.read_csv(test_path)
    # Fallback for local runs without a 
…[truncated]

cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py && echo "---OUTPUT---" && head -5 output/predictions.csv && echo "..." && wc -l output/predictions.csv

cd /app && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv')
tf=pd.read_csv('data/test_features.csv')
assert list(p.columns)==['sample_id','predicted_scaled_sound_pressure_level'], p.columns
assert len(p)==len(tf), (len(p),len(tf))
assert p['sample_id'].astype(str).tolist()==tf['sample_id'].astype(str).tolist(), 'id mismatch/order'
assert np.isfinite(p['predicted_scaled_sound_pressure_level']).all(), 'non-finite'
assert p['predicted_scaled_sound_pressure_level'].nunique()>5, 'looks constant'
print('Format checks PASSED. rows=',len(p))
print('pred range:',p.iloc[:,1].min().round(2),'to',p.iloc[:,1].max().round(2),'std',p.iloc[:,1].std().round(2))
# Compare to known validation labels (same ids) just as a magnitude sanity check
va=pd.read_csv('data/validation.csv').set_index('sample_id')['scaled_sound_pressure_level']
m=p.set_index('sample_id').join(va)
err=m['predicted_scaled_sound_pressure_level']-m['scaled_sound_pressure_level']
print('vs val labels (in-sample-ish) rmse=%.3f mae=%.3f'%(np.sqrt((err**2).mean()),err.abs().mean()))
"

cd /app && cat > /tmp/cv_blend20.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
sys.path.insert(0,'/app')
import train_and_predict as T
import pandas as pd, numpy as np
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
X=T.make_features(alld[T.FEATURES]); y=alld[T.TARGET].to_numpy(float); cond=condition_key(alld); groups=cond.values
gkf=GroupKFold(20); preds=np.zeros(len(y)); tw=0.0
mods=T.build_models()
for est,w in mods: tw+=w
for tri,tei in gkf.split(X,y,groups):
    acc=np.zeros(len(tei))
    for est,w in T.build_models():
        est.fit(X.iloc[tri],y[tri]); acc+=w*est.predict(X.iloc[tei])
    preds[tei]=acc/tw
m=metrics(y,preds,cond); cr=pd.DataFrame({'c':groups,'e':preds-y}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
print('FULL BLEND 20-fold:',{k:round(v,3) for k,v in m.items()},'frac<=2.35=%.2f'%(cr<=2.35).mean())
EOF
nohup python3 /tmp/cv_blend20.py > /tmp/blend20_log.txt 2>&1 &
echo "blend20 pid $!"
# meanwhile: lean vs rich features for ET (10-fold)
timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=alld['scaled_sound_pressure_level'].to_numpy(float); cond=condition_key(alld); groups=cond.values
f=alld.frequency.values;a=alld.attack_angle.values;c=alld.chord_length.values;u=alld.free_stream_velocity.values;d=alld.suction_side_displacement_thickness.values
lf=np.log10(f);ld=np.log10(d);lc=np.log10(c);lu=np.log10(u)
lean=pd.DataFrame(dict(lf=lf,a=a,lc=lc,lu=lu,ld=ld,Std=np.log10(f*d/u),Stc=np.log10(f*c/u),Rec=np.log10(c*u/1.5e-5),Red=np.log10(d*u/1.5e-5),mach=u/340,doc=d/c))
import train_and_predict as T; rich=T.make_features(alld[T.FEATURES])
for name,X in [('lean',lean),('rich',rich)]:
    gkf=GroupKFold(10); p=np.zeros(len(y))
    for tri,tei in gkf.split(X,y,groups):
        p[tei]=ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=0).fit(X.iloc[tri],y[tri]).predict(X.iloc[tei])
    m=metrics(y,p,cond); cr=pd.DataFrame({'c':groups,'e':p-y}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'ET {name:4s} 10fold rmse={m[\"rmse\"]:.3f} mae={m[\"mae\"]:.3f} p90={m[\"p90\"]:.2f} p95={m[\"p95\"]:.2f} max={m[\"maxc\"]:.2f} frac<=2.35={(cr<=2.35).mean():.2f}')
"

sleep 90 && cat /tmp/blend20_log.txt

sleep 120 && cat /tmp/blend20_log.txt

sleep 150 && cat /tmp/blend20_log.txt && echo "---" && ps aux | grep cv_blend20 | grep -v grep | wc -l

sleep 180 && cat /tmp/blend20_log.txt && echo "---running:" && ps aux | grep cv_blend20 | grep -v grep | wc -l

cd /app && cat > /tmp/mlp_test.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
sys.path.insert(0,'/app'); import train_and_predict as T
import pandas as pd, numpy as np
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
X=T.make_features(alld[T.FEATURES]); y=alld[T.TARGET].to_numpy(float); cond=condition_key(alld); groups=cond.values
def cvpred(builder,nf=10):
    gkf=GroupKFold(nf); p=np.zeros(len(y))
    for tri,tei in gkf.split(X,y,groups):
        acc=np.zeros(len(tei)); ms=builder()
        for m in ms: m.fit(X.iloc[tri],y[tri]); acc+=m.predict(X.iloc[tei])
        p[tei]=acc/len(ms)
    return p
def rep(name,p):
    m=metrics(y,p,cond); cr=pd.DataFrame({'c':groups,'e':p-y}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'{name:22s} rmse={m["rmse"]:.3f} mae={m["mae"]:.3f} p90={m["p90"]:.2f} p95={m["p95"]:.2f} max={m["maxc"]:.2f} frac={ (cr<=2.35).mean():.2f}',flush=True)
    return p
def relu(): return [make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=a,alpha=1e-3,max_iter=4000,random_state=s)) for s,a in enumerate([(128,128,64),(200,100),(150,150,75),(256,128,64),(180,120,60)])]
def tanh(): return [make_pipeline(StandardScaler(),MLPRegressor(hidden_layer_sizes=a,activation='tanh',alpha=3e-3,max_iter=4000,random_state=s)) for s,a in enumerate([(128,128,64),(200,100),(150,150,75),(256,128,64),(180,120,60)])]
pr=rep('MLP relu x5',cvpred(relu))
pt=rep('MLP tanh x5',cvpred(tanh))
rep('MLP relu+tanh',(pr+pt)/2)
np.savez('/tmp/mlp_oof.npz',relu=pr,tanh=pt,y=y,cond=groups)
EOF
nohup python3 /tmp/mlp_test.py > /tmp/mlp_log.txt 2>&1 &
echo "pid $!"; sleep 200; cat /tmp/mlp_log.txt

sleep 120 && cat /tmp/mlp_log.txt && echo "running:" && ps aux|grep mlp_test|grep -v grep|wc -l

cd /app && timeout 120 python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from cv_harness import metrics
d=np.load('/tmp/oof_all.npz',allow_pickle=True)
y=d['y']; cond=d['cond']
names=[k for k in d.files if k not in ('y','cond')]
P={n:d[n] for n in names}
def sc(p):
    m=metrics(y,p,cond)
    return m
# greedy forward selection minimizing p90 (tie-break rmse), allow repeats (weights)
sel=[]; 
cur=np.zeros(len(y))
best_metric=1e9
for step in range(8):
    bestn=None; bestm=None; bestp=None
    for n in names:
        p=(cur*len(sel)+P[n])/(len(sel)+1)
        m=sc(p)
        key=(m['p90'],m['rmse'],m['mae'])
        if bestm is None or key<bestm:
            bestm=key; bestn=n; bestp=p; bestmet=m
    sel.append(bestn); cur=bestp
    print(f'step{step+1} add {bestn:5s} -> rmse={bestmet[\"rmse\"]:.3f} mae={bestmet[\"mae\"]:.3f} p90={bestmet[\"p90\"]:.2f} p95={bestmet[\"p95\"]:.2f} max={bestmet[\"maxc\"]:.2f}')
from collections import Counter
print('selection counts:',Counter(sel))
"

command: str_replace
path: /app/train_and_predict.py
old_str: def build_models():
    """(estimator, integer blend weight) pairs."""
    models = []
    # Low-bias randomized trees (two seeds for variance reduction).
    for seed in (0, 1):
        models.append((
            ExtraTreesRegressor(
                n_estimators=1200, max_features=0.6, min_samples_leaf=1,
                n_jobs=-1, random_state=seed,
            ),
            1,
        ))
    # Boosted trees (bias reduction, different inductive bias).
    models.append((
        HistGradientBoostingRegressor(
            max_iter=800, learning_rate=0.04, max_leaf_nodes=31,
            l2_regularization=1.0, min_samples_leaf=15, random_state=0,
        ),
        2,
    ))
    # Smooth neural nets (graceful extrapolation of physical trends).
    archs = [(128, 128, 64), (200, 100), (150, 150, 75)]
    for seed, arch in enumerate(archs):
        models.append((
            make_pipeline(
                StandardScaler(),
                MLPRegressor(
                    hidden_layer_sizes=arch, activation="relu", alpha=1e-3,
                    max_iter=4000, random_state=seed,
                ),
            ),
            1,
        ))
    return models
new_str: def build_models():
    """(estimator, integer blend weight) pairs.

    The ensemble balances total weight between low-variance randomized trees
    (ExtraTrees), bias-correcting boosted trees (HistGBR), and smooth neural
    nets (MLP). Multiple seeds per family reduce variance, which tightens the
    per-condition error tail (p90/p95) on held-out aerodynamic regimes.
    SVR/kernel models are deliberately excluded: they gave occasional large
    single-condition blow-ups that endanger the max-condition-RMSE budget.
    """
    models = []
    # Low-bias randomized trees (several seeds for variance reduction).
    for seed in (0, 1, 2):
        models.append((
            ExtraTreesRegressor(
                n_estimators=1200, max_features=0.6, min_samples_leaf=1,
                n_jobs=-1, random_state=seed,
            ),
            1,
        ))
    # Boosted trees (two complementary configs for diversity).
    models.append((
        HistGradientBoostingRegressor(
            max_iter=800, learning_rate=0.04, max_leaf_nodes=31,
            l2_regularization=1.0, min_samples_leaf=15, random_state=0,
        ),
        1,
    ))
    models.append((
        HistGradientBoostingRegressor(
            max_iter=1000, learning_rate=0.03, max_leaf_nodes=63,
            l2_regularization=2.0, min_samples_leaf=20, random_state=1,
        ),
        1,
    ))
    # Smooth neural nets (graceful extrapolation of physical trends).
    archs = [(128, 128, 64), (200, 100), (150, 150, 75), (256, 128, 64)]
    for seed, arch in enumerate(archs):
        models.append((
            make_pipeline(
                StandardScaler(),
                MLPRegressor(
                    hidden_layer_sizes=arch, activation="relu", alpha=1e-3,
                    max_iter=4000, random_state=seed,
                ),
            ),
            1,
        ))
    return models

cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv'); tf=pd.read_csv('data/test_features.csv')
assert list(p.columns)==['sample_id','predicted_scaled_sound_pressure_level']
assert p['sample_id'].astype(str).tolist()==tf['sample_id'].astype(str).tolist()
assert np.isfinite(p.iloc[:,1]).all() and p.iloc[:,1].nunique()>5
print('OK rows',len(p),'range',round(p.iloc[:,1].min(),2),round(p.iloc[:,1].max(),2))
"

cd /app && cat > /tmp/cv_final2.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
sys.path.insert(0,'/app'); import train_and_predict as T
import pandas as pd, numpy as np
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
X=T.make_features(alld[T.FEATURES]); y=alld[T.TARGET].to_numpy(float); cond=condition_key(alld); groups=cond.values
tw=sum(w for _,w in T.build_models())
for nf in [10]:
    gkf=GroupKFold(nf); preds=np.zeros(len(y))
    for tri,tei in gkf.split(X,y,groups):
        acc=np.zeros(len(tei))
        for est,w in T.build_models():
            est.fit(X.iloc[tri],y[tri]); acc+=w*est.predict(X.iloc[tei])
        preds[tei]=acc/tw
    m=metrics(y,preds,cond); cr=pd.DataFrame({'c':groups,'e':preds-y}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'ENHANCED BLEND {nf}-fold:',{k:round(v,3) for k,v in m.items()},'frac<=2.35=%.2f'%(cr<=2.35).mean())
    tgt=dict(rmse=2.25,mae=1.55,p90=2.35,p95=4.75,maxc=5.60)
    print('pass:',{k:(round(m[k],3),'<=',tgt[k],m[k]<=tgt[k]) for k in tgt})
EOF
nohup python3 /tmp/cv_final2.py > /tmp/cvf2.txt 2>&1 &
echo "pid $!"; sleep 230; cat /tmp/cvf2.txt

sleep 60 && cat /tmp/cvf2.txt && echo "running:" && ps aux|grep cv_final2|grep -v grep|wc -l

sleep 120 && cat /tmp/cvf2.txt && echo "running:" && ps aux|grep cv_final2|grep -v grep|wc -l

sleep 120 && cat /tmp/cvf2.txt && echo "running:" && ps aux|grep cv_final2|grep -v grep|wc -l

command: str_replace
path: /app/train_and_predict.py
old_str:     # Boosted trees (two complementary configs for diversity).
    models.append((
        HistGradientBoostingRegressor(
            max_iter=800, learning_rate=0.04, max_leaf_nodes=31,
            l2_regularization=1.0, min_samples_leaf=15, random_state=0,
        ),
        1,
    ))
    models.append((
        HistGradientBoostingRegressor(
            max_iter=1000, learning_rate=0.03, max_leaf_nodes=63,
            l2_regularization=2.0, min_samples_leaf=20, random_state=1,
        ),
        1,
    ))
    # Smooth neural nets (graceful extrapolation of physical trends).
    archs = [(128, 128, 64), (200, 100), (150, 150, 75), (256, 128, 64)]
new_str:     # Boosted trees (bias correction; a single well-regularized config is used
    # because deeper/larger boosting configs produced occasional large
    # single-condition errors that threatened the max-condition-RMSE budget).
    models.append((
        HistGradientBoostingRegressor(
            max_iter=800, learning_rate=0.04, max_leaf_nodes=31,
            l2_regularization=1.0, min_samples_leaf=15, random_state=0,
        ),
        2,
    ))
    # Smooth neural nets (graceful extrapolation of physical trends).
    archs = [(128, 128, 64), (200, 100), (150, 150, 75), (256, 128, 64)]

cd /app && sed 's/\[10\]/[20]/' /tmp/cv_final2.py > /tmp/cv_final3.py && nohup python3 /tmp/cv_final3.py > /tmp/cvf3.txt 2>&1 & echo "pid $!"

cd /app && cat train_and_predict.py

sleep 60 && cat /tmp/cvf3.txt && echo "running:" && ps aux|grep cv_final3|grep -v grep|wc -l

sleep 200 && cat /tmp/cvf3.txt && echo "running:" && ps aux|grep cv_final3|grep -v grep|wc -l

sleep 200 && cat /tmp/cvf3.txt && echo "running:" && ps aux|grep cv_final3|grep -v grep|wc -l

sleep 180 && cat /tmp/cvf3.txt && echo "running:" && ps aux|grep cv_final3|grep -v grep|wc -l

sleep 120 && cat /tmp/cvf3.txt && echo "running:" && ps aux|grep cv_final3|grep -v grep|wc -l

cd /app && timeout 260 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from cv_harness import *
sys.path.insert(0,'/app'); import train_and_predict as T
import pandas as pd, numpy as np
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.model_selection import GroupKFold
alld=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=alld[T.TARGET].to_numpy(float); cond=condition_key(alld); groups=cond.values
base=T.make_features(alld[T.FEATURES])
a=alld.attack_angle.values; lc=np.log10(alld.chord_length.values); d=alld.suction_side_displacement_thickness.values
stall=base.copy()
stall['stall12']=np.maximum(a-12.5,0); stall['stall17']=np.maximum(a-17,0)
stall['stall12_lc']=np.maximum(a-12.5,0)*lc; stall['stall_doc']=np.maximum(a-10,0)*(d/alld.chord_length.values)
stall['a3']=a**3
def run(name,X):
    gkf=GroupKFold(10); p=np.zeros(len(y))
    for tri,tei in gkf.split(X,y,groups):
        acc=np.zeros(len(tei))
        for s in (0,1):
            acc+=ExtraTreesRegressor(n_estimators=800,max_features=0.6,n_jobs=-1,random_state=s).fit(X.iloc[tri],y[tri]).predict(X.iloc[tei])
        p[tei]=acc/2
    m=metrics(y,p,cond); cr=pd.DataFrame({'c':groups,'e':p-y}).groupby('c')['e'].apply(lambda e:np.sqrt(np.mean(e**2)))
    print(f'{name:12s} rmse={m[\"rmse\"]:.3f} mae={m[\"mae\"]:.3f} p90={m[\"p90\"]:.2f} p95={m[\"p95\"]:.2f} max={m[\"maxc\"]:.2f} frac={ (cr<=2.35).mean():.2f}')
run('rich',base); run('rich+stall',stall)
"

command: str_replace
path: /app/train_and_predict.py
old_str:     # Smooth neural nets (graceful extrapolation of physical trends).
    archs = [(128, 128, 64), (200, 100), (150, 150, 75), (256, 128, 64)]
new_str:     # Smooth neural nets (graceful extrapolation of physical trends).
    archs = [(128, 128, 64), (200, 100), (150, 150, 75), (256, 128, 64),
             (180, 120, 60)]

cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py 2>/tmp/run_err.txt; echo "exit=$?"; echo "--- stderr (filtered) ---"; grep -vi "warn" /tmp/run_err.txt | head; echo "--- validate ---"; python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv'); tf=pd.read_csv('data/test_features.csv')
assert list(p.columns)==['sample_id','predicted_scaled_sound_pressure_level']
assert len(p)==len(tf)
assert p['sample_id'].astype(str).tolist()==tf['sample_id'].astype(str).tolist()
v=p['predicted_scaled_sound_pressure_level'].to_numpy()
assert np.isfinite(v).all() and np.ptp(v)>1
print('VALID: rows=%d range=%.2f..%.2f std=%.2f'%(len(p),v.min(),v.max(),v.std()))
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/app'); import warnings; warnings.filterwarnings('ignore')
import numpy as np, pandas as pd
import train_and_predict as T
# Build a 'hidden-like' eval set: many rows, shuffled column order, some NaN/inf
ev=pd.read_csv('data/train.csv').drop(columns=[T.TARGET]).copy()
ev=ev[['chord_length','frequency','suction_side_displacement_thickness','attack_angle','free_stream_velocity','sample_id']]  # reordered
ev.loc[0,'frequency']=np.nan; ev.loc[1,'suction_side_displacement_thickness']=0.0; ev.loc[2,'attack_angle']=np.inf
Xtr=T.make_features(pd.read_csv('data/train.csv')[T.FEATURES]); ytr=pd.read_csv('data/train.csv')[T.TARGET].to_numpy(float)
Xev=T.make_features(ev[T.FEATURES])
assert np.isfinite(Xev.to_numpy()).all(), 'features not finite!'
print('feature matrix finite with NaN/inf/zero inputs: OK; shape',Xev.shape)
# quick single-model predict to ensure no crash end-to-end on odd eval
from sklearn.ensemble import ExtraTreesRegressor
m=ExtraTreesRegressor(n_estimators=50,random_state=0,n_jobs=-1).fit(Xtr,ytr)
pr=m.predict(Xev)
assert np.isfinite(pr).all()
print('predict on 956 reordered+corrupted rows: OK; range %.2f..%.2f'%(pr.min(),pr.max()))
print('input files untouched (no writes performed here).')
"

cd /app && timeout 200 python3 -c "
import numpy as np, pandas as pd, itertools, sys; sys.path.insert(0,'/tmp')
from cv_harness import metrics
d=np.load('/tmp/oof_all.npz',allow_pickle=True)
y=d['y']; cond=d['cond']
use=['ET','ETnr','HGB','RF','MLP0','MLP1','MLP2']
P=[d[n] for n in use]
def sc(p): return metrics(y,p,cond)
best=None
# limit weights to 0..2 to bound search
for ws in itertools.product(range(3),repeat=len(use)):
    s=sum(ws)
    if s==0: continue
    p=sum(w*P[i] for i,w in enumerate(ws))/s
    m=sc(p)
    if m['maxc']<=5.5 and m['mae']<=1.65 and m['rmse']<=2.35:
        key=m['p90']
        if best is None or key<best[0]:
            best=(key,m,ws)
print('use order:',use)
print('best p90 blend (5-fold, constrained): weights',best[2])
print({k:round(v,3) for k,v in best[1].items()})
# also report my current-style blend equivalent on these oofs: ET+ETnr+HGB + MLPs
cur=(d['ET']+d['ETnr']+2*d['HGB']+d['MLP0']+d['MLP1']+d['MLP2'])/7
print('current-ish blend:',{k:round(v,3) for k,v in sc(cur).items()})
"

cd /app && rm -f output/predictions.csv && python3 train_and_predict.py && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv'); tf=pd.read_csv('data/test_features.csv')
assert list(p.columns)==['sample_id','predicted_scaled_sound_pressure_level'], 'columns'
assert len(p)==len(tf)==p['sample_id'].nunique(), 'row/id count'
assert p['sample_id'].astype(str).tolist()==tf['sample_id'].astype(str).tolist(), 'alignment'
v=p['predicted_scaled_sound_pressure_level'].to_numpy()
assert np.isfinite(v).all(), 'finite'
assert np.ptp(v)>1, 'non-constant'
print('FINAL DELIVERABLE VALID')
print(' rows:',len(p),'| unique ids:',p['sample_id'].nunique())
print(' pred range: %.2f .. %.2f (std %.2f)'%(v.min(),v.max(),v.std()))
print(p.head(3).to_string(index=False))
"

cd /app && echo "=== input files intact ===" && wc -l data/train.csv data/validation.csv data/test_features.csv && head -1 data/train.csv && echo "=== self-contained imports ===" && grep -n "^import\|^from" train_and_predict.py && echo "=== no forbidden path refs ===" && grep -nE "/tests|/grader|/mcp_server|reward|verifier" train_and_predict.py || echo "none found (good)" && echo "=== no writes outside /app/output ===" && grep -nE "to_csv|open\(|\.write" train_and_predict.py

cd /app && sed -n '118,170p' train_and_predict.py