airfoil-self-noise

cat /app/train_and_predict.py

cd /app && echo "=== Directory structure ===" && ls -la && echo "" && echo "=== Data dir ===" && ls -la data/ && echo "" && echo "=== Output dir ===" && ls -la output/ 2>/dev/null || echo "no output dir"

cd /app && echo "=== train.csv head ===" && head -5 data/train.csv && echo "" && echo "=== validation.csv head ===" && head -5 data/validation.csv && echo "" && echo "=== test_features.csv head ===" && head -5 data/test_features.csv && echo "" && echo "=== line counts ===" && wc -l data/*.csv

cd /app && python3 -c "
import pandas as pd
import numpy as np
train = pd.read_csv('data/train.csv')
val = pd.read_csv('data/validation.csv')
test = pd.read_csv('data/test_features.csv')
print('train shape', train.shape)
print('val shape', val.shape)
print('test shape', test.shape)
print()
print('=== train describe ===')
print(train.describe())
print()
print('=== test_features sample_ids ===')
print(test['sample_id'].tolist()[:10])
print('test ids are subset of val ids:', set(test['sample_id']).issubset(set(val['sample_id'])))
"

cd /app && python3 -c "
import pandas as pd
import numpy as np
pd.set_option('display.width', 200)
pd.set_option('display.max_columns', 20)
train = pd.read_csv('data/train.csv')
val = pd.read_csv('data/validation.csv')
test = pd.read_csv('data/test_features.csv')
feats = ['frequency','attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']
print('=== Unique values per feature (train) ===')
for f in feats:
    u = train[f].unique()
    print(f, 'n_unique=', len(u))
print()
print('=== chord_length unique (train) ===', np.sort(train['chord_length'].unique()))
print('=== velocity unique (train) ===', np.sort(train['free_stream_velocity'].unique()))
print('=== attack_angle unique count ===', train['attack_angle'].nunique())
print(np.sort(train['attack_angle'].unique())[:20])
"

cd /app && python3 -c "
import pandas as pd, numpy as np
train = pd.read_csv('data/train.csv')
val = pd.read_csv('data/validation.csv')
# Nominal chord and velocity from UCI
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])
def nearest(x, arr):
    return arr[np.argmin(np.abs(arr[None,:]-np.array(x)[:,None]),axis=1)]
for name,df in [('train',train),('val',val)]:
    c = nearest(df['chord_length'].values, chords)
    v = nearest(df['free_stream_velocity'].values, vels)
    print(name, 'chord counts:', {round(k,4):int((c==k).sum()) for k in chords})
    print(name, 'vel counts:', {round(k,1):int((v==k).sum()) for k in vels})
print()
# attack angle distribution
print('train angle min/max', train['attack_angle'].min(), train['attack_angle'].max())
print('val angle min/max', val['attack_angle'].min(), val['attack_angle'].max())
"

cd /app && python3 -c "
import pandas as pd, numpy as np
train = pd.read_csv('data/train.csv'); val = pd.read_csv('data/validation.csv')
alldf = pd.concat([train,val])
ang = np.sort(alldf['attack_angle'].values)
# find clusters: gaps > 0.3
clusters=[]; cur=[ang[0]]
for a in ang[1:]:
    if a-cur[-1] > 0.3:
        clusters.append(cur); cur=[a]
    else: cur.append(a)
clusters.append(cur)
print('num angle clusters', len(clusters))
for c in clusters:
    print(f'  center={np.mean(c):.3f} min={min(c):.3f} max={max(c):.3f} n={len(c)}')
"

cd /app && python3 -c "
import pandas as pd, numpy as np
train = pd.read_csv('data/train.csv'); val = pd.read_csv('data/validation.csv')
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])
# nominal angles from UCI
angs = np.array([0,1.5,2.0,3.0,3.3,4.0,4.8,5.3,6.7,7.3,8.4,8.9,9.5,9.9,11.2,12.3,12.6,15.4,15.6,17.4,19.7,22.2])
def nn(x, arr): return arr[np.argmin(np.abs(arr[None,:]-np.array(x)[:,None]),axis=1)]
def cond(df):
    c = nn(df['chord_length'].values, chords)
    v = nn(df['free_stream_velocity'].values, vels)
    a = nn(df['attack_angle'].values, angs)
    return set(zip(np.round(c,4),np.round(v,1),np.round(a,2)))
tc, vc = cond(train), cond(val)
print('train conditions:', len(tc))
print('val conditions:', len(vc))
print('overlap:', len(tc & vc))
print('val-only:', len(vc - tc))
"

cd /app && cat > /tmp/evalharness.py << 'EOF'
import pandas as pd, numpy as np

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])
angs = np.array([0,1.5,2.0,3.0,3.3,4.0,4.8,5.3,6.7,7.3,8.4,8.9,9.5,9.9,11.2,12.3,12.6,15.4,15.6,17.4,19.7,22.2])

def nn(x, arr): return arr[np.argmin(np.abs(arr[None,:]-np.array(x)[:,None]),axis=1)]

def cond_ids(df):
    c = nn(df['chord_length'].values, chords)
    v = nn(df['free_stream_velocity'].values, vels)
    a = nn(df['attack_angle'].values, angs)
    return list(zip(np.round(c,4),np.round(v,1),np.round(a,2)))

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))
    df = pd.DataFrame({'c':cond,'e':err})
    crmse = df.groupby('c')['e'].apply(lambda s: np.sqrt(np.mean(s**2)))
    p90 = np.percentile(crmse, 90); p95 = np.percentile(crmse,95); mx = crmse.max()
    return dict(rmse=rmse, mae=mae, p90=p90, p95=p95, mx=mx, ncond=len(crmse))

def report(name, y_true, y_pred, cond):
    m = metrics(y_true,y_pred,cond)
    tgt = dict(rmse=2.25, mae=1.55, p90=2.35, p95=4.75, mx=5.60)
    flags = {k:('OK' if m[k]<=tgt[k] else 'FAIL') for k in tgt}
    print(f'{name}: rmse={m[\"rmse\"]:.3f}[{flags[\"rmse\"]}] mae={m[\"mae\"]:.3f}[{flags[\"mae\"]}] '
          f'p90={m[\"p90\"]:.3f}[{flags[\"p90\"]}] p95={m[\"p95\"]:.3f}[{flags[\"p95\"]}] '
          f'max={m[\"mx\"]:.3f}[{flags[\"mx\"]}] ncond={m[\"ncond\"]}')
    return m
EOF
echo "harness written"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
import pandas as pd, numpy as np
from evalharness import cond_ids, report
import train_and_predict as tp
train = pd.read_csv('data/train.csv'); val = pd.read_csv('data/validation.csv')
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
model = make_pipeline(tp.AirfoilFeatures(), StandardScaler(), Ridge(alpha=10.0))
model.fit(train[tp.FEATURES], train[tp.TARGET])
pred = model.predict(val[tp.FEATURES])
cond = cond_ids(val)
report('Baseline Ridge (train->val)', val[tp.TARGET], pred, cond)
"

cd /app && cat > /tmp/evalharness.py << 'EOF'
import pandas as pd, numpy as np

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])
angs = np.array([0,1.5,2.0,3.0,3.3,4.0,4.8,5.3,6.7,7.3,8.4,8.9,9.5,9.9,11.2,12.3,12.6,15.4,15.6,17.4,19.7,22.2])

def nn(x, arr): return arr[np.argmin(np.abs(arr[None,:]-np.array(x)[:,None]),axis=1)]

def cond_ids(df):
    c = nn(df['chord_length'].values, chords)
    v = nn(df['free_stream_velocity'].values, vels)
    a = nn(df['attack_angle'].values, angs)
    return list(zip(np.round(c,4),np.round(v,1),np.round(a,2)))

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 = float(np.sqrt(np.mean(err**2)))
    mae = float(np.mean(np.abs(err)))
    df = pd.DataFrame({'c':cond,'e':err})
    crmse = df.groupby('c')['e'].apply(lambda s: np.sqrt(np.mean(s**2)))
    return dict(rmse=rmse, mae=mae, p90=float(np.percentile(crmse,90)),
                p95=float(np.percentile(crmse,95)), mx=float(crmse.max()), ncond=len(crmse))

def report(name, y_true, y_pred, cond):
    m = metrics(y_true,y_pred,cond)
    tgt = dict(rmse=2.25, mae=1.55, p90=2.35, p95=4.75, mx=5.60)
    def fl(k): return 'OK' if m[k]<=tgt[k] else 'FAIL'
    print('{0}: rmse={1:.3f}[{2}] mae={3:.3f}[{4}] p90={5:.3f}[{6}] p95={7:.3f}[{8}] max={9:.3f}[{10}] ncond={11}'.format(
        name, m['rmse'],fl('rmse'), m['mae'],fl('mae'), m['p90'],fl('p90'),
        m['p95'],fl('p95'), m['mx'],fl('mx'), m['ncond']))
    return m
EOF
python3 -c "
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import pandas as pd, numpy as np
from evalharness import cond_ids, report
import train_and_predict as tp
train = pd.read_csv('/app/data/train.csv'); val = pd.read_csv('/app/data/validation.csv')
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
model = make_pipeline(tp.AirfoilFeatures(), StandardScaler(), Ridge(alpha=10.0))
model.fit(train[tp.FEATURES], train[tp.TARGET])
pred = model.predict(val[tp.FEATURES])
report('Baseline Ridge (train->val)', val[tp.TARGET], pred, cond_ids(val))
"

cd /app && python3 -c "
import sklearn; print('sklearn', sklearn.__version__)
import numpy; print('numpy', numpy.__version__)
import scipy; print('scipy', scipy.__version__)
import pandas; print('pandas', pandas.__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 sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import pandas as pd, numpy as np
from evalharness import cond_ids, report
import warnings; warnings.filterwarnings('ignore')
train = pd.read_csv('/app/data/train.csv'); val = pd.read_csv('/app/data/validation.csv')
FEAT=['frequency','attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']
TGT='scaled_sound_pressure_level'
def feateng(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)
    X=pd.DataFrame(index=df.index)
    X['logf']=np.log10(f); X['a']=a; X['logc']=np.log10(c); X['v']=v; X['logt']=np.log10(t)
    X['strouhal']=np.log10(f*t/v); X['logfc']=np.log10(f*c)
    return X
Xtr, Xval = feateng(train), feateng(val)
ytr, yval = train[TGT].values, val[TGT].values
cond = cond_ids(val)
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, GradientBoostingRegressor, HistGradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
models = {
 'RF': RandomForestRegressor(n_estimators=400, n_jobs=-1, random_state=0),
 'ET': ExtraTreesRegressor(n_estimators=400, n_jobs=-1, random_state=0),
 'GBR': GradientBoostingRegressor(n_estimators=400, max_depth=3, learning_rate=0.05, random_state=0),
 'HGB': HistGradientBoostingRegressor(max_iter=600, learning_rate=0.05, random_state=0),
}
for name,m in models.items():
    m.fit(Xtr, ytr); p=m.predict(Xval); report(name, yval, p, cond)
# MLP
mlp = make_pipeline(StandardScaler(), MLPRegressor(hidden_layer_sizes=(128,128,64), max_iter=2000, random_state=0, early_stopping=True))
mlp.fit(Xtr,ytr); report('MLP', yval, mlp.predict(Xval), cond)
"

cd /app && python3 -c "
import pandas as pd, numpy as np
train = pd.read_csv('/app/data/train.csv')
# Look at one condition's frequency sweep
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])
sub = train[(np.abs(train.chord_length-0.3048)<0.01)&(np.abs(train.free_stream_velocity-71.3)<1)&(np.abs(train.attack_angle)<0.3)]
sub=sub.sort_values('frequency')
print('Condition chord=0.3048 v=71.3 angle=0, n=',len(sub))
print(sub[['frequency','suction_side_displacement_thickness','scaled_sound_pressure_level']].to_string(index=False))
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import pandas as pd, numpy as np
from evalharness import cond_ids, report
import warnings; warnings.filterwarnings('ignore')
train = pd.read_csv('/app/data/train.csv'); val = pd.read_csv('/app/data/validation.csv')
TGT='scaled_sound_pressure_level'
def feateng(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)
    X=pd.DataFrame(index=df.index)
    X['logf']=np.log10(f); X['a']=a; X['logc']=np.log10(c); X['v']=v; X['logt']=np.log10(t)
    X['strouhal']=np.log10(f*t/v); X['logfc']=np.log10(f*c); X['logft']=np.log10(f*t)
    X['mach']=v/340.0; X['are']=a*np.log10(v*c)
    return X
Xtr, Xval = feateng(train), feateng(val)
ytr, yval = train[TGT].values, val[TGT].values
cond = cond_ids(val)
from sklearn.svm import SVR
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel, ConstantKernel, Matern
from sklearn.neighbors import KNeighborsRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
for C in [10,30,100]:
  for g in ['scale',0.1,0.3]:
    m=make_pipeline(StandardScaler(), SVR(C=C, gamma=g, epsilon=0.05))
    m.fit(Xtr,ytr); report('SVR C=%s g=%s'%(C,g), yval, m.predict(Xval), cond)
m=make_pipeline(StandardScaler(), KernelRidge(kernel='rbf', alpha=0.01, gamma=0.1))
m.fit(Xtr,ytr); report('KRR', yval, m.predict(Xval), cond)
m=make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=7, weights='distance'))
m.fit(Xtr,ytr); report('KNN', yval, m.predict(Xval), cond)
"

cd /app && python3 -c "
import pandas as pd, numpy as np
train = pd.read_csv('/app/data/train.csv')
sub = train[(np.abs(train.chord_length-0.3048)<0.01)&(np.abs(train.free_stream_velocity-71.3)<1)&(np.abs(train.attack_angle)<0.3)].sort_values('frequency')
print(sub[['attack_angle','chord_length','free_stream_velocity']].to_string())
print()
print('unique chord in this group:', sub.chord_length.nunique())
print('unique angle:', sub.attack_angle.nunique(), 'unique vel:', sub.free_stream_velocity.nunique())
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import pandas as pd, numpy as np
from evalharness import cond_ids
import warnings; warnings.filterwarnings('ignore')
train = pd.read_csv('/app/data/train.csv'); val = pd.read_csv('/app/data/validation.csv')
TGT='scaled_sound_pressure_level'
def feateng(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)
    X=pd.DataFrame(index=df.index)
    X['logf']=np.log10(f); X['a']=a; X['logc']=np.log10(c); X['v']=v; X['logt']=np.log10(t)
    X['strouhal']=np.log10(f*t/v); X['logfc']=np.log10(f*c)
    return X
Xtr,Xval=feateng(train),feateng(val)
ytr,yval=train[TGT].values,val[TGT].values
cond=cond_ids(val)
from sklearn.ensemble import ExtraTreesRegressor
m=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0)
m.fit(Xtr,ytr); p=m.predict(Xval)
df=pd.DataFrame({'c':cond,'e':p-yval,'y':yval})
g=df.groupby('c').agg(rmse=('e',lambda s:np.sqrt(np.mean(s**2))), bias=('e','mean'), n=('e','size'), ymean=('y','mean'))
print(g.sort_values('rmse',ascending=False).to_string())
"

cd /app && cat > /tmp/gcv.py << 'EOF'
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
import pandas as pd, numpy as np
from evalharness import cond_ids, metrics
import warnings; warnings.filterwarnings('ignore')
from sklearn.model_selection import GroupKFold

train = pd.read_csv('/app/data/train.csv'); val = pd.read_csv('/app/data/validation.csv')
ALL = pd.concat([train,val], ignore_index=True)
TGT='scaled_sound_pressure_level'
COND = cond_ids(ALL)
# integer group ids
uniq = {c:i for i,c in enumerate(sorted(set(COND)))}
GROUPS = np.array([uniq[c] for c in COND])
print('total conditions:', len(uniq), 'rows:', len(ALL))

def grouped_eval(make_model, feateng, n_splits=10, seed=0):
    y = ALL[TGT].values
    oof = np.full(len(ALL), np.nan)
    gkf = GroupKFold(n_splits=n_splits)
    for tr,te in gkf.split(ALL, y, GROUPS):
        Xtr = feateng(ALL.iloc[tr]); Xte = feateng(ALL.iloc[te])
        m = make_model(); m.fit(Xtr, y[tr]); oof[te] = m.predict(Xte)
    m = metrics(y, oof, COND)
    return m, oof

def pr(name, m):
    tgt = dict(rmse=2.25, mae=1.55, p90=2.35, p95=4.75, mx=5.60)
    def fl(k): return 'OK' if m[k]<=tgt[k] else 'XX'
    print('{0:28s} rmse={1:.3f}[{2}] mae={3:.3f}[{4}] p90={5:.3f}[{6}] p95={7:.3f}[{8}] max={9:.3f}[{10}] nc={11}'.format(
        name, m['rmse'],fl('rmse'), m['mae'],fl('mae'), m['p90'],fl('p90'), m['p95'],fl('p95'), m['mx'],fl('mx'), m['ncond']))
EOF
echo "gcv module written"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
import numpy as np, pandas as pd
def feateng(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)
    X=pd.DataFrame(index=df.index)
    X['logf']=np.log10(f); X['a']=a; X['logc']=np.log10(c); X['v']=v; X['logt']=np.log10(t)
    X['strouhal']=np.log10(f*t/v); X['logfc']=np.log10(f*c)
    return X
from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor, HistGradientBoostingRegressor
pr('ET-600', grouped_eval(lambda:ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0), feateng)[0])
pr('RF-600', grouped_eval(lambda:RandomForestRegressor(n_estimators=600,n_jobs=-1,random_state=0), feateng)[0])
pr('HGB', grouped_eval(lambda:HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,random_state=0), feateng)[0])
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
def fe_rich(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)
    X=pd.DataFrame(index=df.index)
    X['logf']=np.log10(f); X['a']=a; X['logc']=np.log10(c); X['v']=v; X['logt']=np.log10(t)
    X['St']=np.log10(f*t/v); X['logfc']=np.log10(f*c); X['logft']=np.log10(f*t)
    X['Re_c']=np.log10(v*c); X['Re_t']=np.log10(v*t); X['mach']=v/340.0
    X['a_logc']=a*np.log10(c); X['a_v']=a*v; X['St_a']=np.log10(f*t/v)*a
    X['tc']=t/c; X['logtc']=np.log10(t/c)
    return X
for msl in [1,2,3]:
  for mf in [0.6,0.8,1.0]:
    m,_=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0,
                     min_samples_leaf=msl,max_features=mf), fe_rich)
    pr('ET msl=%d mf=%.1f'%(msl,mf), m)
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
def mk(cols):
    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)
        d=dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
               St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
               Re_c=np.log10(v*c), mach=v/340.0, f=f, t=t, c=c)
        return pd.DataFrame({k:d[k] for k in cols}, index=df.index)
    return fe
base=['logf','a','logc','v','logt','St','logfc']
mk_model=lambda:ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0)
pr('base7', grouped_eval(mk_model, mk(base))[0])
pr('base-St', grouped_eval(mk_model, mk([x for x in base if x!='St']))[0])
pr('base-logfc', grouped_eval(mk_model, mk([x for x in base if x!='logfc']))[0])
pr('base-logc', grouped_eval(mk_model, mk([x for x in base if x!='logc']))[0])
pr('base+logft', grouped_eval(mk_model, mk(base+['logft']))[0])
pr('base+Re_c', grouped_eval(mk_model, mk(base+['Re_c']))[0])
pr('core5', grouped_eval(mk_model, mk(['logf','a','logc','v','logt']))[0])
pr('core5+St', grouped_eval(mk_model, mk(['logf','a','logc','v','logt','St']))[0])
"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
import numpy as np, pandas as pd
from sklearn.neural_network import MLPRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t)), index=df.index)
def mk(arch, alpha):
    return make_pipeline(StandardScaler(),
        MLPRegressor(hidden_layer_sizes=arch, alpha=alpha, max_iter=3000,
                     random_state=0, activation='tanh'))
for arch in [(64,64),(128,64),(100,100,50)]:
  for alpha in [1e-3,1e-2]:
    pr('MLP %s a=%.e'%(str(arch),alpha), grouped_eval(lambda arch=arch,alpha=alpha:mk(arch,alpha), fe)[0])
"

restart: true

cd /app && timeout 120 python3 -c "
import pandas as pd, numpy as np
train = pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True)
# Test Strouhal collapse: group by condition, look at spectral shape
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])
angs=np.array([0,1.5,2.0,3.0,3.3,4.0,4.8,5.3,6.7,7.3,8.4,8.9,9.5,9.9,11.2,12.3,12.6,15.4,15.6,17.4,19.7,22.2])
def nn(x,arr): return arr[np.argmin(np.abs(arr[None,:]-np.array(x)[:,None]),axis=1)]
f=ALL.frequency.values; t=ALL.suction_side_displacement_thickness.values; v=ALL.free_stream_velocity.values
St=f*t/v
ALL['St']=St; ALL['logSt']=np.log10(St)
print('log10(St) range:', np.round(np.log10(St).min(),2), np.round(np.log10(St).max(),2))
# For each condition, find peak SPL and peak frequency
c=nn(ALL.chord_length.values,chords); vv=nn(v,vels); a=nn(ALL.attack_angle.values,angs)
ALL['cid']=list(zip(np.round(c,4),np.round(vv,1),np.round(a,2)))
# correlation of SPL with logSt overall
print('corr SPL vs logSt:', np.corrcoef(ALL.logSt, ALL.scaled_sound_pressure_level)[0,1])
" 

cd /app && timeout 280 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
def mk(cols):
    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)
        d=dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
               St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
               a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2)
        return pd.DataFrame({k:d[k] for k in cols}, index=df.index)
    return fe
base=['logf','a','logc','v','logt','St','logfc','logft']
M=lambda:ExtraTreesRegressor(n_estimators=400,n_jobs=-1,random_state=0)
pr('base8', grouped_eval(M, mk(base))[0])
pr('base8+a2', grouped_eval(M, mk(base+['a2']))[0])
pr('base8+asep', grouped_eval(M, mk(base+['asep']))[0])
pr('base8+St2', grouped_eval(M, mk(base+['St2']))[0])
pr('base8+a_logt', grouped_eval(M, mk(base+['a_logt']))[0])
pr('base8+all', grouped_eval(M, mk(base+['a2','asep','a_logt','St2']))[0])
"

cd /app && timeout 280 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
import numpy as np, pandas as pd
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern, RBF, WhiteKernel, ConstantKernel as C
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c)), index=df.index)
def mkgp(ls, nu, noise):
    k = C(50.0)*Matern(length_scale=ls, nu=nu) + WhiteKernel(noise)
    return make_pipeline(StandardScaler(),
        GaussianProcessRegressor(kernel=k, optimizer=None, normalize_y=True, alpha=1e-6))
for ls in [1.0,2.0,3.0]:
  for nu in [1.5,2.5]:
    pr('GP ls=%.1f nu=%.1f'%(ls,nu), grouped_eval(lambda ls=ls,nu=nu:mkgp(ls,nu,1.0), fe, n_splits=5)[0])
"

cd /app && timeout 290 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval, pr
from evalharness import metrics
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor, HistGradientBoostingRegressor, GradientBoostingRegressor
import warnings; warnings.filterwarnings('ignore')
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True)
from evalharness import cond_ids
COND=cond_ids(ALL); y=ALL['scaled_sound_pressure_level'].values
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
models={
 'ET': lambda:ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0),
 'ET2': lambda:ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=7,max_features=0.7),
 'HGB': lambda:HistGradientBoostingRegressor(max_iter=700,learning_rate=0.04,max_leaf_nodes=31,random_state=0,l2_regularization=1.0),
 'GBR': lambda:GradientBoostingRegressor(n_estimators=500,max_depth=3,learning_rate=0.04,subsample=0.8,random_state=0),
}
oofs={}
for name,mk in models.items():
    m,oof=grouped_eval(mk, fe, n_splits=10); oofs[name]=oof; pr(name, m)
# blends
print('--- blends ---')
pr('ET+HGB', metrics(y,(oofs['ET']+oofs['HGB'])/2, COND))
pr('ET+GBR', metrics(y,(oofs['ET']+oofs['GBR'])/2, COND))
pr('ET+ET2+HGB+GBR', metrics(y,(oofs['ET']+oofs['ET2']+oofs['HGB']+oofs['GBR'])/4, COND))
pr('ET2+HGB', metrics(y,(oofs['ET2']+oofs['HGB'])/2, COND))
pr('0.5ET+0.25HGB+0.25GBR', metrics(y,0.5*oofs['ET']+0.25*oofs['HGB']+0.25*oofs['GBR'], COND))
np.save('/tmp/oof_ET.npy',oofs['ET']); np.save('/tmp/oof_HGB.npy',oofs['HGB']); np.save('/tmp/oof_GBR.npy',oofs['GBR']); np.save('/tmp/y.npy',y)
"

cd /app && timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True)
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
m,oof=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0), fe, n_splits=10)
err=oof-ALL['scaled_sound_pressure_level'].values
ALL['err']=err; ALL['abserr']=np.abs(err)
ALL['logf']=np.log10(ALL.frequency)
print('=== mean |err| by freq decile ===')
ALL['fb']=pd.qcut(ALL.logf,6)
print(ALL.groupby('fb',observed=True)['err'].agg(['mean','std','count']).round(3).to_string())
print('=== mean err by angle bin ===')
ALL['ab']=pd.cut(ALL.attack_angle,[-1,2,5,8,11,14,23])
print(ALL.groupby('ab',observed=True)['err'].agg(['mean','std','count']).round(3).to_string())
print('=== by chord ===')
ALL['cb']=pd.cut(ALL.chord_length,[0,0.04,0.07,0.13,0.19,0.26,0.4])
print(ALL.groupby('cb',observed=True)['err'].agg(['mean','std','count']).round(3).to_string())
"

cd /app && timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval
from evalharness import cond_ids
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL)
y=ALL['scaled_sound_pressure_level'].values
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
_,oof=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0), fe, n_splits=10)
df=pd.DataFrame({'c':COND,'e':oof-y})
cr=df.groupby('c')['e'].apply(lambda s:np.sqrt(np.mean(s**2))).sort_values(ascending=False)
print('worst 12 conditions:'); print(cr.head(12).to_string())
print()
print('n conditions > 2.35:', (cr>2.35).sum(), 'of', len(cr))
print('p90=%.3f p95=%.3f'%(np.percentile(cr,90),np.percentile(cr,95)))
"

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL)
y=ALL['scaled_sound_pressure_level'].values
logf=np.log10(ALL.frequency.values)
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
_,oof=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0), fe, n_splits=10)
def pr(n,m):
    print('%-22s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
pr('ET raw', metrics(y,oof,COND))
# smooth within condition: polynomial in logf
cid=pd.Series(COND)
for deg in [2,3,4]:
    sm=oof.copy()
    for c,idx in pd.Series(range(len(COND))).groupby(cid).groups.items():
        idx=np.array(idx); 
        if len(idx)>=deg+2:
            x=logf[idx]; p=np.polyfit(x,oof[idx],deg); sm[idx]=np.polyval(p,x)
    pr('ET poly deg=%d'%deg, metrics(y,sm,COND))
"

cd /app && timeout 120 python3 -c "
import numpy as np, pandas as pd
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True)
# Examine rows near chord 0.1524, vel 39.6, angle ~12.3-12.7
sub=ALL[(np.abs(ALL.chord_length-0.1524)<0.003)&(np.abs(ALL.free_stream_velocity-39.6)<1)&(ALL.attack_angle>11.5)&(ALL.attack_angle<13.5)].sort_values(['attack_angle','frequency'])
print('rows in chord0.1524 v39.6 angle~12:', len(sub))
print(sub[['attack_angle','frequency','suction_side_displacement_thickness','scaled_sound_pressure_level']].round(4).to_string())
"

cd /app && timeout 280 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
from sklearn.preprocessing import SplineTransformer, StandardScaler
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import ExtraTreesRegressor
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL); y=ALL['scaled_sound_pressure_level'].values
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c)), index=df.index)
def pr(n,m): print('%-26s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
# spline model: splines on St and logf, linear on level vars + interactions
def fe_spline(df):
    X=fe(df); return X
def mk_spline(nknots=6, deg=3, alpha=1.0):
    spline_cols=['St','logf','a','logt']
    lin_cols=['logc','v','logt','a','logfc','St']
    ct=ColumnTransformer([
        ('sp', SplineTransformer(n_knots=nknots, degree=deg, include_bias=False), spline_cols),
        ('lin', StandardScaler(), lin_cols)])
    return make_pipeline(ct, StandardScaler(with_mean=False), Ridge(alpha=alpha))
for nk in [6,8,10]:
  for al in [0.5,2.0]:
    m,_=grouped_eval(lambda nk=nk,al=al:mk_spline(nk,3,al), fe_spline, n_splits=10)
    pr('spline nk=%d a=%.1f'%(nk,al), m)
# ET ref + blend
_,oofET=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0), fe, n_splits=10)
_,oofSP=grouped_eval(lambda:mk_spline(8,3,1.0), fe_spline, n_splits=10)
pr('ET', metrics(y,oofET,COND))
pr('spline8', metrics(y,oofSP,COND))
for w in [0.2,0.3,0.4]:
    pr('blend %.1f*SP'%w, metrics(y,(1-w)*oofET+w*oofSP,COND))
np.save('/tmp/oofET.npy',oofET); np.save('/tmp/oofSP.npy',oofSP)
"

cd /app && timeout 60 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from evalharness import cond_ids
import numpy as np, pandas as pd
test=pd.read_csv('/app/data/test_features.csv')
print('placeholder test rows:', len(test))
c=cond_ids(test)
from collections import Counter
cc=Counter(c)
print('n conditions in placeholder:', len(cc))
for k,v in sorted(cc.items()): print('  ',k,v)
"

cd /app && timeout 290 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.base import BaseEstimator, RegressorMixin
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL); y=ALL['scaled_sound_pressure_level'].values
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
def pr(n,m): print('%-24s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
class BasePlusET(BaseEstimator,RegressorMixin):
    def __init__(self, deg=2, alpha=5.0, n_est=500, etw=1.0):
        self.deg=deg; self.alpha=alpha; self.n_est=n_est; self.etw=etw
    def fit(self,X,y):
        self.base=make_pipeline(PolynomialFeatures(self.deg,include_bias=False),StandardScaler(),Ridge(self.alpha))
        self.base.fit(X,y); r=y-self.base.predict(X)
        self.et=ExtraTreesRegressor(n_estimators=self.n_est,n_jobs=-1,random_state=0); self.et.fit(X,r)
        return self
    def predict(self,X): return self.base.predict(X)+self.etw*self.et.predict(X)
for deg in [2,3]:
  for al in [2.0,10.0]:
    m,_=grouped_eval(lambda deg=deg,al=al:BasePlusET(deg,al,500), fe, n_splits=10)
    pr('base(deg%d,a%.0f)+ET'%(deg,al), m)
# compare pure ET
_,oofET=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0), fe, n_splits=10)
pr('pure ET', metrics(y,oofET,COND))
"

cd /app && timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from evalharness import cond_ids
import numpy as np, pandas as pd
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL)
ALL['cid']=COND; y=ALL['scaled_sound_pressure_level'].values
ALL['logSt']=np.log10(ALL.frequency*ALL.suction_side_displacement_thickness/ALL.free_stream_velocity)
# per-condition mean SPL
ALL['cmean']=ALL.groupby('cid')['scaled_sound_pressure_level'].transform('mean')
ALL['resid']=ALL['scaled_sound_pressure_level']-ALL['cmean']
# Does resid collapse vs logSt? bin and look at std
ALL['stb']=pd.cut(ALL.logSt, np.linspace(-2,1,13))
g=ALL.groupby('stb',observed=True)['resid'].agg(['mean','std','count'])
print('residual (SPL - condition_mean) vs logSt:')
print(g.round(3).to_string())
print()
print('overall resid std:', round(ALL.resid.std(),3))
# correlation of condition mean with features
cond_df=ALL.groupby('cid').agg(cmean=('scaled_sound_pressure_level','mean'),
    a=('attack_angle','mean'), logc=('chord_length', lambda s:np.log10(s.mean())),
    v=('free_stream_velocity','mean'), logt=('suction_side_displacement_thickness', lambda s: np.log10(s.mean())))
print('n conditions:', len(cond_df), 'cmean std:', round(cond_df.cmean.std(),3))
"

cd /app && timeout 290 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from gcv import grouped_eval
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.model_selection import GroupKFold
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL); y=ALL['scaled_sound_pressure_level'].values
uniq={c:i for i,c in enumerate(sorted(set(COND)))}; GROUPS=np.array([uniq[c] for c in COND])
def denoise(df):
    # group by inferred condition, replace condition feats with group mean
    d=df.copy(); cid=cond_ids(d)
    d['__c']=cid
    for col in ['attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']:
        d[col]=d.groupby('__c')[col].transform('mean')
    return d.drop(columns='__c')
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
def pr(n,m): print('%-22s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
# CV with denoising applied per fold (both train and test)
def cv_denoise(mk,n_splits=10):
    oof=np.full(len(ALL),np.nan); gkf=GroupKFold(n_splits)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te]))
        m=mk(); m.fit(Xtr,y[tr]); oof[te]=m.predict(Xte)
    return oof
oofD=cv_denoise(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0))
pr('ET denoised', metrics(y,oofD,COND))
_,oofR=grouped_eval(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0), fe, n_splits=10)
pr('ET raw', metrics(y,oofR,COND))
np.save('/tmp/oofD.npy',oofD)
"

cd /app && timeout 290 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.model_selection import GroupKFold
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL); y=ALL['scaled_sound_pressure_level'].values
uniq={c:i for i,c in enumerate(sorted(set(COND)))}; GROUPS=np.array([uniq[c] for c in COND])
NOMF=np.array([200,250,315,400,500,630,800,1000,1250,1600,2000,2500,3150,4000,5000,6300,8000,10000,12500,16000,20000.])
logNOMF=np.log10(NOMF)
def snapf(f):
    lf=np.log10(f.values); idx=np.argmin(np.abs(lf[:,None]-logNOMF[None,:]),axis=1); return NOMF[idx]
def denoise(df, snap=True):
    d=df.copy(); d['__c']=cond_ids(d)
    for col in ['attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']:
        d[col]=d.groupby('__c')[col].transform('mean')
    if snap: d['frequency']=snapf(d['frequency'])
    return d.drop(columns='__c')
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
def pr(n,m): print('%-24s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
def cv(mk,snap,n_splits=10):
    oof=np.full(len(ALL),np.nan); gkf=GroupKFold(n_splits)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr],snap)); Xte=fe(denoise(ALL.iloc[te],snap))
        m=mk(); m.fit(Xtr,y[tr]); oof[te]=m.predict(Xte)
    return oof
pr('denoise+snapF', metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0),True),COND))
pr('denoise only', metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0),False),COND))
"

cd /app && cat > /tmp/dn.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
ALL=pd.concat([train,val],ignore_index=True); COND=cond_ids(ALL); y=ALL['scaled_sound_pressure_level'].values
uniq={c:i for i,c in enumerate(sorted(set(COND)))}; GROUPS=np.array([uniq[c] for c in COND])
NOMF=np.array([200,250,315,400,500,630,800,1000,1250,1600,2000,2500,3150,4000,5000,6300,8000,10000,12500,16000,20000.])
logNOMF=np.log10(NOMF)
def snapf(f):
    lf=np.log10(np.asarray(f,float)); idx=np.argmin(np.abs(lf[:,None]-logNOMF[None,:]),axis=1); return NOMF[idx]
def denoise(df, snap=True):
    d=df.copy(); d['__c']=cond_ids(d)
    for col in ['attack_angle','chord_length','free_stream_velocity','suction_side_displacement_thickness']:
        d[col]=d.groupby('__c')[col].transform('mean')
    if snap: d['frequency']=snapf(d['frequency'].values)
    return d.drop(columns='__c')
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)
    return pd.DataFrame(dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2), index=df.index)
def pr(n,m): print('%-26s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
def cv_oof(mk, snap=True, n_splits=10):
    oof=np.full(len(ALL),np.nan); gkf=GroupKFold(n_splits)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr],snap)); Xte=fe(denoise(ALL.iloc[te],snap))
        m=mk(); m.fit(Xtr,y[tr]); oof[te]=m.predict(Xte)
    return oof
EOF
echo done

cd /app && timeout 290 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import cv_oof, pr, metrics, y, COND
import numpy as np
from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor
oofs={}
oofs['ET0']=cv_oof(lambda:ExtraTreesRegressor(n_estimators=1000,n_jobs=-1,random_state=0))
oofs['ET1']=cv_oof(lambda:ExtraTreesRegressor(n_estimators=1000,n_jobs=-1,random_state=1,max_features=0.7))
oofs['ET2']=cv_oof(lambda:ExtraTreesRegressor(n_estimators=1000,n_jobs=-1,random_state=2,min_samples_leaf=2))
oofs['RF']=cv_oof(lambda:RandomForestRegressor(n_estimators=800,n_jobs=-1,random_state=0,max_features=0.5))
for k in oofs: pr(k, metrics(y,oofs[k],COND))
print('--- blends ---')
pr('ET0+ET1+ET2', metrics(y,(oofs['ET0']+oofs['ET1']+oofs['ET2'])/3,COND))
pr('3ET+RF', metrics(y,(oofs['ET0']+oofs['ET1']+oofs['ET2']+oofs['RF'])/4,COND))
pr('ET0+RF', metrics(y,(oofs['ET0']+oofs['RF'])/2,COND))
import pickle; pickle.dump(oofs, open('/tmp/oofs.pkl','wb'))
"

cd /app && timeout 120 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import cv_oof, metrics, y, COND, ALL
import numpy as np, pandas as pd, pickle
oofs=pickle.load(open('/tmp/oofs.pkl','rb')); oof=oofs['ET0']
df=pd.DataFrame({'c':COND,'e':oof-y,'ang':ALL.attack_angle.values})
g=df.groupby('c').agg(rmse=('e',lambda s:np.sqrt(np.mean(s**2))),bias=('e','mean'),n=('e','size'),
    angmin=('ang','min'),angmax=('ang','max')).sort_values('rmse',ascending=False)
print(g.head(14).round(3).to_string())
print()
print('conditions>2.35:',(g.rmse>2.35).sum(),'/',len(g))
print('conditions>3.0:',(g.rmse>3.0).sum())
"

cd /app && timeout 200 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, denoise, fe
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor, HistGradientBoostingRegressor
# Build condition-level dataset
dd=denoise(ALL, snap=True); dd['cid']=COND; dd['y']=y
clev=dd.groupby('cid').agg(a=('attack_angle','mean'),c=('chord_length','mean'),
   v=('free_stream_velocity','mean'),t=('suction_side_displacement_thickness','mean'),
   ymean=('y','mean')).reset_index()
clev['logc']=np.log10(clev.c); clev['logt']=np.log10(clev.t)
clev['Re']=np.log10(clev.v*clev.c); clev['a_logt']=clev.a*clev.logt
Xcols=['a','logc','v','logt','Re','a_logt']
Xc=clev[Xcols].values; yc=clev.ymean.values
gid=np.arange(len(clev))
gkf=GroupKFold(10)
for name,mk in [('ET',lambda:ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0)),
                ('RF',lambda:RandomForestRegressor(n_estimators=500,n_jobs=-1,random_state=0)),
                ('HGB',lambda:HistGradientBoostingRegressor(max_iter=300,random_state=0))]:
    oof=np.full(len(clev),np.nan)
    for tr,te in gkf.split(Xc,yc,gid):
        m=mk(); m.fit(Xc[tr],yc[tr]); oof[te]=m.predict(Xc[te])
    err=oof-yc
    print('%s level: RMSE=%.3f MAE=%.3f max|e|=%.3f'%(name, np.sqrt(np.mean(err**2)), np.mean(np.abs(err)), np.max(np.abs(err))))
"

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, pr, fe, GROUPS
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
CH=np.array([0.0254,0.0508,0.1016,0.1524,0.2286,0.3048]); VE=np.array([31.7,39.6,55.5,71.3])
ANG=np.array([0,1.5,2.0,3.0,3.3,4.0,4.8,5.3,6.7,7.3,8.4,8.9,9.5,9.9,11.2,12.3,12.6,15.4,15.6,17.4,19.7,22.2])
NOMF=np.array([200,250,315,400,500,630,800,1000,1250,1600,2000,2500,3150,4000,5000,6300,8000,10000,12500,16000,20000.])
def snap(x,grid): x=np.asarray(x,float); return grid[np.argmin(np.abs(x[:,None]-grid[None,:]),axis=1)]
def denoise_grid(df):
    d=df.copy()
    d['chord_length']=snap(d.chord_length,CH); d['free_stream_velocity']=snap(d.free_stream_velocity,VE)
    d['attack_angle']=snap(d.attack_angle,ANG); d['frequency']=snap(d.frequency,NOMF)
    key=list(zip(d.chord_length,d.free_stream_velocity,d.attack_angle))
    d['__k']=key; d['suction_side_displacement_thickness']=d.groupby('__k')['suction_side_displacement_thickness'].transform('mean')
    return d.drop(columns='__k')
def cv(mk,dn,n=10):
    oof=np.full(len(ALL),np.nan); gkf=GroupKFold(n)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(dn(ALL.iloc[tr])); Xte=fe(dn(ALL.iloc[te]))
        m=mk(); m.fit(Xtr,y[tr]); oof[te]=m.predict(Xte)
    return oof
pr('grid-snap denoise', metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=1000,n_jobs=-1,random_state=0),denoise_grid),COND))
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, pr, denoise, GROUPS
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
def make_fe(cols):
    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)
        d=dict(logf=np.log10(f), a=a, logc=np.log10(c), v=v, logt=np.log10(t),
           St=np.log10(f*t/v), logfc=np.log10(f*c), logft=np.log10(f*t),
           a2=a*a, asep=np.maximum(0,a-8.0), a_logt=a*np.log10(t), St2=np.log10(f*t/v)**2,
           Re=np.log10(v*c), aSt=a*np.log10(f*t/v))
        return pd.DataFrame({k:d[k] for k in cols}, index=df.index)
    return fe
def cv(mk,fe,n=10):
    oof=np.full(len(ALL),np.nan); gkf=GroupKFold(n)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te]))
        m=mk(); m.fit(Xtr,y[tr]); oof[te]=m.predict(Xte)
    return oof
f8=['logf','a','logc','v','logt','St','logfc','logft']
sets={'f8':f8, 'f8+a2asep':f8+['a2','asep','a_logt','St2'], 'f8+Re':f8+['Re'], 'f8+aSt':f8+['aSt'], 'f9min':['logf','a','logc','v','logt','St','logfc','logft','a_logt']}
for name,cols in sets.items():
    pr(name, metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0),make_fe(cols)),COND))
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, pr, denoise, fe, GROUPS
from evalharness import cond_ids
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
# multi-seed averaged ET in CV
def cv_multiseed(seeds, n=10):
    gkf=GroupKFold(n); oof=np.zeros(len(ALL))
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te]))
        acc=np.zeros(len(te))
        for s in seeds:
            m=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=s); m.fit(Xtr,y[tr]); acc+=m.predict(Xte)
        oof[te]=acc/len(seeds)
    return oof
pr('ET 5-seed avg', metrics(y,cv_multiseed([0,1,2,3,4]),COND))
# realistic: train on train.csv denoised, predict val.csv denoised
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
Xtr=fe(denoise(train)); Xval=fe(denoise(val))
acc=np.zeros(len(val))
for s in range(5):
    m=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=s); m.fit(Xtr,train['scaled_sound_pressure_level'].values); acc+=m.predict(Xval)
acc/=5
pr('REAL train->val(15cond)', metrics(val['scaled_sound_pressure_level'].values, acc, cond_ids(val)))
"

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp'); import warnings; warnings.filterwarnings('ignore')
from dn import ALL, COND, y, denoise
import numpy as np, pandas as pd
from sklearn.model_selection import LeaveOneGroupOut
from sklearn.svm import SVR
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern, WhiteKernel, ConstantKernel as C
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import Ridge
from sklearn.ensemble import ExtraTreesRegressor
dd=denoise(ALL); dd['cid']=COND; dd['y']=y
clev=dd.groupby('cid').agg(a=('attack_angle','mean'),c=('chord_length','mean'),
   v=('free_stream_velocity','mean'),t=('suction_side_displacement_thickness','mean'),
   ymean=('y','mean')).reset_index()
clev['logc']=np.log10(clev.c); clev['logt']=np.log10(clev.t); clev['Re']=np.log10(clev.v*clev.c)
X=clev[['a','logc','v','logt','Re']].values; yc=clev.ymean.values; gid=np.arange(len(clev))
logo=LeaveOneGroupOut()
def ev(name,mk):
    oof=np.full(len(clev),np.nan)
    for tr,te in logo.split(X,yc,gid):
        m=mk(); m.fit(X[tr],yc[tr]); oof[te]=m.predict(X[te])
    e=oof-yc; print('%-20s RMSE=%.3f MAE=%.3f max=%.3f'%(name,np.sqrt(np.mean(e**2)),np.mean(np.abs(e)),np.max(np.abs(e))))
    return oof
ev('ET', lambda:ExtraTreesRegressor(n_estimators=500,n_jobs=-1,random_state=0))
for C_ in [20,50]:
  for g in ['scale',0.2]:
    ev('SVR C%s g%s'%(C_,g), lambda C_=C_,g=g:make_pipeline(StandardScaler(),SVR(C=C_,gamma=g,epsilon=0.1)))
ev('KRR', lambda:make_pipeline(StandardScaler(),KernelRidge(kernel='rbf',alpha=0.1,gamma=0.2)))
ev('poly2ridge', lambda:make_pipeline(PolynomialFeatures(2),StandardScaler(),Ridge(1.0)))
ev('GP', lambda:make_pipeline(StandardScaler(),GaussianProcessRegressor(kernel=C(30)*Matern(length_scale=2.0,nu=2.5)+WhiteKernel(1.0),optimizer=None,normalize_y=True)))
"

cd /app && timeout 250 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, pr, denoise, fe, GROUPS
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
# thickness distribution
dd=denoise(ALL); dd['cid']=COND
ct=dd.groupby('cid')['suction_side_displacement_thickness'].mean().sort_values()
print('thickness range across conditions: %.5f .. %.5f'%(ct.min(),ct.max()))
print('worst cond (0.1524,39.6,12.6) thickness:', round(ct.get((0.1524,39.6,12.6),-1),5))
print('thickness 95th pct:', round(ct.quantile(0.95),5), ' n cond > 0.05:', (ct>0.05).sum())
print()
def cv(mk,n=10):
    oof=np.full(len(ALL),np.nan); gkf=GroupKFold(n)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te]))
        m=mk(); m.fit(Xtr,y[tr]); oof[te]=m.predict(Xte)
    return oof
pr('ET msl1 (base)', metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0)),COND))
pr('ET bootstrap', metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0,bootstrap=True,max_samples=0.8)),COND))
pr('ET msl2', metrics(y,cv(lambda:ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0,min_samples_leaf=2)),COND))
"

cd /app && timeout 290 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, pr, denoise, fe, GROUPS
from evalharness import cond_ids
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
SEEDS=[0,1,2,3,4,5]; NEST=500
def cv():
    oof=np.zeros(len(ALL)); gkf=GroupKFold(10)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te])); acc=np.zeros(len(te))
        for s in SEEDS:
            m=ExtraTreesRegressor(n_estimators=NEST,n_jobs=-1,random_state=s); m.fit(Xtr,y[tr]); acc+=m.predict(Xte)
        oof[te]=acc/len(SEEDS)
    return oof
pr('FINAL 6seed x500 CV(82cond)', metrics(y,cv(),COND))
# realistic train->val
train=pd.read_csv('/app/data/train.csv'); val=pd.read_csv('/app/data/validation.csv')
Xtr=fe(denoise(train)); Xv=fe(denoise(val)); acc=np.zeros(len(val))
for s in SEEDS:
    m=ExtraTreesRegressor(n_estimators=NEST,n_jobs=-1,random_state=s); m.fit(Xtr,train['scaled_sound_pressure_level'].values); acc+=m.predict(Xv)
pr('FINAL train->val(15cond)', metrics(val['scaled_sound_pressure_level'].values, acc/len(SEEDS), cond_ids(val)))
"

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

Strategy (developed against a grouped, condition-held-out validation that
mirrors the hidden split):

1.  The public features are a *jittered* version of the discrete NASA/UCI
    airfoil experiment grid.  Within one aerodynamic condition
    ``(attack_angle, chord_length, free_stream_velocity)`` the angle, chord,
    velocity and suction-side displacement thickness are physically constant;
    only the 1/3-octave ``frequency`` genuinely varies.  The per-row jitter is
    therefore pure input noise.  We remove it by grouping rows into their
    nominal condition and replacing the condition-constant features with the
    group mean, and by snapping ``frequency`` to its nearest 1/3-octave band.
    This denoising consistently lowered every held-out metric.

2.  Physics-motivated features (log frequency / thickness / chord, the
    Strouhal number ``f*delta/U`` that sets the spectral-peak location, and a
    few interaction / separation terms) are fed to an ExtraTrees regressor.
    Among the available sklearn models ExtraTrees generalised best across
    entirely unseen conditions; smooth global models (SVR/GP/spline-ridge) and
    boosted trees were weaker, and polynomial bases extrapolated catastrophically.

The model is trained on all labelled data (train + validation) so the hidden
conditions are as interior as possible to the training range.
"""

from pathlib import Path

import numpy as np
import pandas as pd
from sklearn.ensemble import ExtraTreesRegressor

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",
]
CONDITION_FEATURES = [
    "attack_angle",
    "chord_length",
    "free_stream_velocity",
    "suction_side_displacement_thickness",
]

# Nominal experiment grids (used only to *group* jittered rows into their
# underlying condition; the denoised feature value is the group mean of the
# actual values, never the nominal value, so genuinely new settings are fine).
NOMINAL_CHORD = np.array([0.0254, 0.0508, 0.1016, 0.1524, 0.2286, 0.3048])
NOMINAL_VELOCITY = np.array([31.7, 39.6, 55.5, 71.3])
NOMINAL_ANGLE = np.array(
    [0.0, 1.5, 2.0, 3.0, 3.3, 4.0, 4.8, 5.3, 6.7, 7.3, 8.4, 8.9,
     9.5, 9.9, 11.2, 12.3, 12.6, 15.4, 15.6, 17.4, 19.7, 22.2]
)
NOMINAL_FREQ = np.array(
    [200.0, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500,
     3150, 4000, 5000, 6300, 8000, 10000, 12500, 16000, 20000]
)
LOG_NOMINAL_FREQ = np.log10(NOMINAL_FREQ)


def _snap(values: np.ndarray, grid: np.ndarray) -> np.ndarray:
    values = np.asarray(values, dtype=float)
    idx = np.argmin(np.abs(values[:, None] - grid[None, :]), axis=1)
    return grid[idx]


def _snap_frequency(freq: np.ndarray) -> np.ndarray:
    logf = np.log10(np.asarray(freq, dtype=float))
    idx = np.argmin(np.abs(logf[:, None] - LOG_NOMINAL_FREQ[None, :]), axis=1)
    return NOMINAL_FREQ[idx]


def _condition_key(frame: pd.DataFrame) -> list:
    """Group jittered rows into their underlying aerodynamic condition."""
    chord = _snap(frame["chord_length"].to_numpy(), NOMINAL_CHORD)
    velocity = _snap(frame["free_stream_velocity"].to_numpy(), NOMINAL_VELOCITY)
    angle = _snap(frame["attack_angle"].to_numpy(), NOMINAL_ANGLE)
    return list(zip(np.round(chord, 4), np.round(velocity, 1), np.round(angle, 2)))


def denoise(frame: pd.DataFrame) -> pd.DataFrame:
    """Remove per-row jitter: condition-constant features -> group mean;
    frequency -> nearest 1/3-octave band."""
    out = frame.copy()
    out["__cond__"] = _condition_key(out)
    for col in CONDITION_FEATURES:
        out[col] = out.groupby("__cond__")[col].transform("mean")
    out["frequency"] = _snap_frequency(out["frequency"].to_numpy())
 
…[truncated]

cd /app && rm -f output/predictions.csv && timeout 200 python3 train_and_predict.py && echo "=== EXIT OK ===" && echo "--- head ---" && head -5 output/predictions.csv && echo "--- rows (incl header) ---" && wc -l output/predictions.csv && echo "--- test_features rows ---" && wc -l data/test_features.csv

cd /app && timeout 60 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
pred=pd.read_csv('output/predictions.csv')
val=pd.read_csv('data/validation.csv'); test=pd.read_csv('data/test_features.csv')
# schema checks
assert list(pred.columns)==['sample_id','predicted_scaled_sound_pressure_level'], pred.columns
assert len(pred)==len(test), (len(pred),len(test))
assert set(pred.sample_id)==set(test.sample_id.astype(str)), 'id mismatch'
assert pred.predicted_scaled_sound_pressure_level.notna().all()
assert np.isfinite(pred.predicted_scaled_sound_pressure_level).all()
assert pred.predicted_scaled_sound_pressure_level.nunique()>5, 'not constant'
print('ALL SCHEMA CHECKS PASSED. n=',len(pred))
print('pred range: %.2f .. %.2f  std=%.2f'%(pred.predicted_scaled_sound_pressure_level.min(),
      pred.predicted_scaled_sound_pressure_level.max(), pred.predicted_scaled_sound_pressure_level.std()))
# metrics vs known val labels
m=pred.merge(val[['sample_id','scaled_sound_pressure_level']],on='sample_id')
assert len(m)==len(pred)
cond=cond_ids(m.rename(columns={}).assign())  # need feature cols
mm=pred.merge(val,on='sample_id')
met=metrics(mm['scaled_sound_pressure_level'], mm['predicted_scaled_sound_pressure_level'], cond_ids(mm))
print('On placeholder (40 rows, subset of val conditions):')
print('  rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f ncond=%d'%(met['rmse'],met['mae'],met['p90'],met['p95'],met['mx'],met['ncond']))
"

cd /app && timeout 60 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from evalharness import cond_ids, metrics
import numpy as np, pandas as pd
pred=pd.read_csv('output/predictions.csv')
val=pd.read_csv('data/validation.csv')
mm=pred.merge(val,on='sample_id')
assert len(mm)==len(pred)
met=metrics(mm['scaled_sound_pressure_level'], mm['predicted_scaled_sound_pressure_level'], cond_ids(mm))
print('On placeholder (40 rows, %d conditions):'%met['ncond'])
print('  rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(met['rmse'],met['mae'],met['p90'],met['p95'],met['mx']))
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, denoise, fe, GROUPS
import numpy as np
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
def cv(seeds, nest):
    oof=np.zeros(len(ALL)); gkf=GroupKFold(10)
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te])); acc=np.zeros(len(te))
        for s in seeds:
            m=ExtraTreesRegressor(n_estimators=nest,max_features=1.0,n_jobs=-1,random_state=s)
            m.fit(Xtr,y[tr]); acc+=m.predict(Xte)
        oof[te]=acc/len(seeds)
    return metrics(y,oof,COND)
for label,seeds,nest in [('single s0 x1200',[0],1200),('3seed x600',[0,1,2],600),('4seed x400',[0,1,2,3],400)]:
    m=cv(seeds,nest)
    print('%-18s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f  [%d cond>2.35]'%(
        label,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx'],-1))
"

command: str_replace
path: /app/train_and_predict.py
old_str: def engineer(frame: pd.DataFrame) -> pd.DataFrame:
    f = frame["frequency"].astype(float)
    a = frame["attack_angle"].astype(float)
    c = frame["chord_length"].astype(float)
    v = frame["free_stream_velocity"].astype(float)
    t = frame["suction_side_displacement_thickness"].astype(float)
new_str: def engineer(frame: pd.DataFrame) -> pd.DataFrame:
    # Positive, finite guards so log10 / ratios never produce NaN/inf even on
    # unexpected hidden inputs (the clean benchmark data never hits these).
    f = frame["frequency"].astype(float).clip(lower=1e-6)
    a = frame["attack_angle"].astype(float)
    c = frame["chord_length"].astype(float).clip(lower=1e-9)
    v = frame["free_stream_velocity"].astype(float).clip(lower=1e-6)
    t = frame["suction_side_displacement_thickness"].astype(float).clip(lower=1e-9)

command: str_replace
path: /app/train_and_predict.py
old_str:     X_train = engineer(denoise(labeled[FEATURES]))
    y_train = labeled[TARGET].to_numpy(dtype=float)
    X_eval = engineer(denoise(evaluation[FEATURES]))

    model = build_model()
new_str:     X_train = engineer(denoise(labeled[FEATURES]))
    y_train = labeled[TARGET].to_numpy(dtype=float)
    X_eval = engineer(denoise(evaluation[FEATURES]))

    # Impute any non-finite engineered values with training-column means so the
    # estimator never receives NaN/inf (clean benchmark data is unaffected).
    X_train = X_train.replace([np.inf, -np.inf], np.nan)
    X_eval = X_eval.replace([np.inf, -np.inf], np.nan)
    col_means = X_train.mean(numeric_only=True)
    X_train = X_train.fillna(col_means)
    X_eval = X_eval.fillna(col_means)

    model = build_model()

cd /app && rm -f output/predictions.csv && timeout 200 python3 train_and_predict.py && cp output/predictions.csv /tmp/run1.csv && timeout 200 python3 train_and_predict.py && cp output/predictions.csv /tmp/run2.csv && echo "=== determinism check ===" && if diff -q /tmp/run1.csv /tmp/run2.csv >/dev/null; then echo "IDENTICAL across runs (deterministic)"; else echo "DIFFERS!"; fi && echo "--- sample ---" && head -3 output/predictions.csv && python3 -c "
import pandas as pd, numpy as np
p=pd.read_csv('output/predictions.csv')
print('rows',len(p),'finite',bool(np.isfinite(p.iloc[:,1]).all()),'nunique',p.iloc[:,1].nunique())
"

cd /app && python3 -c "
import pandas as pd, numpy as np
a=pd.read_csv('/tmp/run1.csv'); b=pd.read_csv('/tmp/run2.csv')
d=np.abs(a.iloc[:,1].values-b.iloc[:,1].values)
print('max abs diff between runs: %.3e'%d.max())
print('mean abs diff: %.3e'%d.mean())
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, denoise, fe
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
conds=sorted(set(COND)); cond_arr=np.array(COND,dtype=object)
rng=np.random.default_rng(42)
import warnings; warnings.filterwarnings('ignore')
res=[]
for rep in range(25):
    rng.shuffle(conds)
    hidden=set(conds[:15]); mask=np.array([c in hidden for c in COND])
    tr=ALL[~mask]; te=ALL[mask]
    Xtr=fe(denoise(tr)); Xte=fe(denoise(te))
    m=ExtraTreesRegressor(n_estimators=300,max_features=1.0,n_jobs=-1,random_state=0)
    m.fit(Xtr, y[~mask]); p=m.predict(Xte)
    met=metrics(y[mask], p, list(cond_arr[mask]))
    res.append([met['rmse'],met['mae'],met['p90'],met['p95'],met['mx']])
res=np.array(res)
names=['rmse','mae','p90','p95','max']; tgt=[2.25,1.55,2.35,4.75,5.60]
print('Monte Carlo over 25 random 15-condition hidden draws (train on other 67):')
for i,(nm,tg) in enumerate(zip(names,tgt)):
    col=res[:,i]; print('  %-4s mean=%.3f median=%.3f p25=%.3f p75=%.3f  frac<=target=%.0f%%'%(
        nm, col.mean(), np.median(col), np.percentile(col,25), np.percentile(col,75), 100*np.mean(col<=tg)))
allpass=np.all(res<=np.array(tgt),axis=1)
print('  ALL 5 metrics pass simultaneously: %.0f%% of draws'%(100*allpass.mean()))
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, denoise, fe
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor
import warnings; warnings.filterwarnings('ignore')
conds=sorted(set(COND)); rng=np.random.default_rng(42)
res=[]
for rep in range(25):
    rng.shuffle(conds)
    hidden=set(conds[:15]); mask=np.array([c in hidden for c in COND])
    Xtr=fe(denoise(ALL[~mask])); Xte=fe(denoise(ALL[mask]))
    m=ExtraTreesRegressor(n_estimators=300,max_features=1.0,n_jobs=-1,random_state=0)
    m.fit(Xtr, y[~mask]); p=m.predict(Xte)
    cte=[c for c,mk in zip(COND,mask) if mk]
    met=metrics(y[mask], p, cte)
    res.append([met['rmse'],met['mae'],met['p90'],met['p95'],met['mx']])
res=np.array(res); names=['rmse','mae','p90','p95','max']; tgt=[2.25,1.55,2.35,4.75,5.60]
print('Monte Carlo: 25 random 15-condition hidden draws (train on other 67):')
for i,(nm,tg) in enumerate(zip(names,tgt)):
    col=res[:,i]; print('  %-4s mean=%.3f median=%.3f p25=%.3f p75=%.3f  frac_pass=%.0f%%'%(
        nm,col.mean(),np.median(col),np.percentile(col,25),np.percentile(col,75),100*np.mean(col<=tg)))
allpass=np.all(res<=np.array(tgt),axis=1)
print('  ALL 5 pass simultaneously: %.0f%% of draws'%(100*allpass.mean()))
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, denoise, fe, GROUPS
import numpy as np
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
import warnings; warnings.filterwarnings('ignore')
def cv_two():
    gkf=GroupKFold(10); oe=np.zeros(len(ALL)); oh=np.zeros(len(ALL))
    for tr,te in gkf.split(ALL,y,GROUPS):
        Xtr=fe(denoise(ALL.iloc[tr])); Xte=fe(denoise(ALL.iloc[te]))
        e=ExtraTreesRegressor(n_estimators=800,max_features=1.0,n_jobs=-1,random_state=0).fit(Xtr,y[tr])
        h=HistGradientBoostingRegressor(max_iter=800,learning_rate=0.03,max_leaf_nodes=15,
             l2_regularization=2.0,min_samples_leaf=15,random_state=0).fit(Xtr,y[tr])
        oe[te]=e.predict(Xte); oh[te]=h.predict(Xte)
    return oe,oh
oe,oh=cv_two()
def pr(n,p): m=metrics(y,p,COND); print('%-16s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
pr('ET',oe); pr('HGB',oh)
for w in [0.15,0.25,0.35]: pr('ET+%.2fHGB'%w,(1-w)*oe+w*oh)
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, denoise, fe
import numpy as np
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
import warnings; warnings.filterwarnings('ignore')
conds=sorted(set(COND)); rng=np.random.default_rng(7)
tgt=np.array([2.25,1.55,2.35,4.75,5.60]); keys=['rmse','mae','p90','p95','mx']
def met_vec(yt,p,c): m=metrics(yt,p,c); return np.array([m[k] for k in keys])
accE=[]; accB=[]
for rep in range(20):
    rng.shuffle(conds); hidden=set(conds[:15]); mask=np.array([c in hidden for c in COND])
    Xtr=fe(denoise(ALL[~mask])); Xte=fe(denoise(ALL[mask])); cte=[c for c,mk in zip(COND,mask) if mk]
    e=ExtraTreesRegressor(n_estimators=500,max_features=1.0,n_jobs=-1,random_state=0).fit(Xtr,y[~mask])
    h=HistGradientBoostingRegressor(max_iter=700,learning_rate=0.03,max_leaf_nodes=15,l2_regularization=2.0,min_samples_leaf=15,random_state=0).fit(Xtr,y[~mask])
    pe=e.predict(Xte); ph=h.predict(Xte)
    accE.append(met_vec(y[mask],pe,cte)); accB.append(met_vec(y[mask],0.85*pe+0.15*ph,cte))
accE=np.array(accE); accB=np.array(accB)
for nm,arr in [('pure ET',accE),('ET+0.15HGB',accB)]:
    passes=arr<=tgt
    print('%-12s p90_pass=%.0f%% mae_pass=%.0f%% rmse_pass=%.0f%% ALL5=%.0f%%'%(
        nm,100*passes[:,2].mean(),100*passes[:,1].mean(),100*passes[:,0].mean(),100*np.all(passes,axis=1).mean()))
    print('             median: rmse=%.3f mae=%.3f p90=%.3f'%(np.median(arr[:,0]),np.median(arr[:,1]),np.median(arr[:,2])))
"

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

command: str_replace
path: /app/train_and_predict.py
old_str: def build_model() -> ExtraTreesRegressor:
    # ExtraTrees generalised best to fully unseen conditions. 1200 trees make
    # the ensemble stable/deterministic for a fixed seed.
    return ExtraTreesRegressor(
        n_estimators=1200,
        max_features=1.0,
        min_samples_leaf=1,
        n_jobs=-1,
        random_state=0,
    )
new_str: # Blend weight for the boosted model. ExtraTrees is the backbone (best
# per-condition generalisation); a light HistGradientBoosting component
# decorrelates the errors and tightened global RMSE / MAE / worst-case on the
# grouped held-out evaluation.
HGB_WEIGHT = 0.15


def build_extratrees() -> ExtraTreesRegressor:
    # 1200 trees make the ensemble stable/deterministic for a fixed seed.
    return ExtraTreesRegressor(
        n_estimators=1200,
        max_features=1.0,
        min_samples_leaf=1,
        n_jobs=-1,
        random_state=0,
    )


def build_hgb() -> HistGradientBoostingRegressor:
    return HistGradientBoostingRegressor(
        max_iter=800,
        learning_rate=0.03,
        max_leaf_nodes=15,
        min_samples_leaf=15,
        l2_regularization=2.0,
        random_state=0,
    )

command: str_replace
path: /app/train_and_predict.py
old_str:     model = build_model()
    model.fit(X_train, y_train)
    predictions = np.asarray(model.predict(X_eval), dtype=float)
new_str:     et = build_extratrees().fit(X_train, y_train)
    hgb = build_hgb().fit(X_train, y_train)
    predictions = (1.0 - HGB_WEIGHT) * np.asarray(et.predict(X_eval), dtype=float) \
        + HGB_WEIGHT * np.asarray(hgb.predict(X_eval), dtype=float)

cd /app && rm -f output/predictions.csv && timeout 200 python3 train_and_predict.py && echo "=== EXIT OK ===" && 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']
assert len(p)==len(t) and set(p.sample_id)==set(t.sample_id.astype(str))
assert np.isfinite(p.iloc[:,1]).all() and p.iloc[:,1].nunique()>5
print('OK: rows=%d finite=True unique=%d range=%.2f..%.2f'%(len(p),p.iloc[:,1].nunique(),p.iloc[:,1].min(),p.iloc[:,1].max()))
" && head -3 output/predictions.csv

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp'); sys.path.insert(0,'/app')
from dn import ALL, COND, y, metrics, denoise, GROUPS
import train_and_predict as tp
import numpy as np
from sklearn.model_selection import GroupKFold
import warnings; warnings.filterwarnings('ignore')
gkf=GroupKFold(10); oof=np.zeros(len(ALL))
for tr,te in gkf.split(ALL,y,GROUPS):
    Xtr=tp.engineer(denoise(ALL.iloc[tr][tp.FEATURES])); Xte=tp.engineer(denoise(ALL.iloc[te][tp.FEATURES]))
    e=tp.build_extratrees().fit(Xtr,y[tr]); h=tp.build_hgb().fit(Xtr,y[tr])
    oof[te]=(1-tp.HGB_WEIGHT)*e.predict(Xte)+tp.HGB_WEIGHT*h.predict(Xte)
m=metrics(y,oof,COND); tgt=dict(rmse=2.25,mae=1.55,p90=2.35,p95=4.75,mx=5.60)
print('=== FINAL pipeline, 10-fold grouped CV (82 held-out conditions) ===')
for k,lbl in [('rmse','rmse'),('mae','mae'),('p90','p90_cond'),('p95','p95_cond'),('mx','max_cond')]:
    print('  %-9s = %.3f   target %.2f   %s'%(lbl,m[k],tgt[k],'PASS' if m[k]<=tgt[k] else 'over'))
"

cd /app && timeout 295 python3 -c "
import sys; sys.path.insert(0,'/tmp')
from dn import ALL, COND, y, metrics, denoise, fe, GROUPS
import numpy as np
from sklearn.model_selection import GroupKFold
from sklearn.ensemble import ExtraTreesRegressor
import warnings; warnings.filterwarnings('ignore')
def cv(wfun):
    gkf=GroupKFold(10); oof=np.zeros(len(ALL))
    for tr,te in gkf.split(ALL,y,GROUPS):
        dtr=denoise(ALL.iloc[tr]); Xtr=fe(dtr); Xte=fe(denoise(ALL.iloc[te]))
        w=wfun(dtr)
        m=ExtraTreesRegressor(n_estimators=600,max_features=1.0,n_jobs=-1,random_state=0).fit(Xtr,y[tr],sample_weight=w)
        oof[te]=m.predict(Xte)
    return metrics(y,oof,COND)
def pr(n,m): print('%-22s rmse=%.3f mae=%.3f p90=%.3f p95=%.3f max=%.3f'%(n,m['rmse'],m['mae'],m['p90'],m['p95'],m['mx']))
pr('w=1 (none)', cv(lambda d: None))
pr('w angle', cv(lambda d: 1+0.05*np.maximum(0,d.attack_angle-6)))
pr('w lowfreq', cv(lambda d: 1+0.5*(np.log10(d.frequency)<3.0)))
pr('w angle+lowfreq', cv(lambda d: (1+0.05*np.maximum(0,d.attack_angle-6))*(1+0.4*(np.log10(d.frequency)<3.0))))
"

cd /app && cat train_and_predict.py

command: str_replace
path: /app/train_and_predict.py
old_str: 2.  Physics-motivated features (log frequency / thickness / chord, the
    Strouhal number ``f*delta/U`` that sets the spectral-peak location, and a
    few interaction / separation terms) are fed to an ExtraTrees regressor.
    Among the available sklearn models ExtraTrees generalised best across
    entirely unseen conditions; smooth global models (SVR/GP/spline-ridge) and
    boosted trees were weaker, and polynomial bases extrapolated catastrophically.

The model is trained on all labelled data (train + validation) so the hidden
conditions are as interior as possible to the training range.
new_str: 2.  Physics-motivated features (log frequency / thickness / chord, the
    Strouhal number ``f*delta/U`` that sets the spectral-peak location, and a
    few interaction / separation terms) are fed to an ExtraTrees regressor.
    Among the available sklearn models ExtraTrees generalised best across
    entirely unseen conditions; smooth global models (SVR/GP/spline-ridge) were
    weaker and polynomial bases extrapolated catastrophically.  A light
    HistGradientBoosting component is blended in: its errors are partially
    decorrelated from the trees', which tightened the global RMSE/MAE and the
    worst-case per-condition errors on the grouped held-out evaluation.

The ensemble is trained on all labelled data (train + validation) so the hidden
conditions are as interior as possible to the measured envelope.  On a 10-fold
grouped (condition-held-out) CV this pipeline reaches roughly
rmse~2.05, mae~1.53, p95/max well inside target; the 90th-percentile
per-condition error is the hardest metric because the worst held-out
conditions are genuine boundary extrapolations (e.g. the single thickest
boundary layer in the whole dataset).

cd /app && rm -f output/predictions.csv && timeout 200 python3 train_and_predict.py && echo "=== FINAL RUN OK ===" && 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']
assert len(p)==len(t) and list(p.sample_id)==list(t.sample_id.astype(str)), 'order/align'
assert np.isfinite(p.iloc[:,1]).all() and p.iloc[:,1].nunique()>5
print('output valid: %d rows aligned & finite, %d unique vals'%(len(p),p.iloc[:,1].nunique()))
"
echo "--- robustness test (synthetic hidden rows, not touching files) ---"
timeout 120 python3 -c "
import sys; sys.path.insert(0,'/app')
import numpy as np, pandas as pd, train_and_predict as tp
# synthetic: arbitrary IDs, a brand-new angle (10.5), single-row condition, extreme freq
df=pd.DataFrame({
 'frequency':[250.0, 8000.0, 19000.0, 500.0],
 'attack_angle':[10.5, 10.48, 0.0, 22.2],
 'chord_length':[0.1016,0.1016,0.3048,0.0254],
 'free_stream_velocity':[55.5,55.5,71.3,39.6],
 'suction_side_displacement_thickness':[0.02,0.02,0.0026,0.04]})
X=tp.engineer(tp.denoise(df[tp.FEATURES]))
print('denoised angle (should group the two 10.5 rows ->mean):', tp.denoise(df[tp.FEATURES])['attack_angle'].tolist())
print('engineered finite:', bool(np.isfinite(X.to_numpy()).all()), 'shape', X.shape)
print('robustness OK')
"

cd /app && echo "=== input row counts (should be unchanged: train 957, val 202, test 41 incl headers) ===" && wc -l data/train.csv data/validation.csv data/test_features.csv && echo "" && echo "=== /app contents ===" && ls -la && echo "" && echo "=== output ===" && ls -la output/ && echo "" && echo "=== header check (inputs not modified) ===" && head -1 data/train.csv

cd /app && rm -rf __pycache__ && ls -la && echo "--- final predictions sample ---" && head -4 output/predictions.csv