airfoil-self-noise

cat /app/train_and_predict.py

cd /app && echo "=== Directory structure ===" && ls -la /app && echo "" && echo "=== Data dir ===" && ls -la /app/data && echo "" && echo "=== train.csv head ===" && head -5 /app/data/train.csv && echo "" && echo "=== validation.csv head ===" && head -5 /app/data/validation.csv && echo "" && echo "=== test_features.csv head ===" && head -5 /app/data/test_features.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().T)
print()
print('=== val describe ===')
print(val.describe().T)
"

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')
for name, df in [('train', train), ('val', val), ('test', test)]:
    print('===', name, '===')
    print(df.describe().T[['mean','std','min','max']])
    print()
"

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')
cond = ['attack_angle','chord_length','free_stream_velocity']
# Check if displacement thickness is constant within a condition group
g = train.groupby(cond)['suction_side_displacement_thickness'].nunique()
print('Train: unique thickness per condition group - max:', g.max(), 'min:', g.min())
print('Num train condition groups:', train.groupby(cond).ngroups)
print('Num val condition groups:', val.groupby(cond).ngroups)
# rows per group
gs = train.groupby(cond).size()
print('rows per group train: min', gs.min(), 'max', gs.max(), 'mean', gs.mean())
print()
# Overlap of condition groups between train and val
train_conds = set(map(tuple, train[cond].round(6).values))
val_conds = set(map(tuple, val[cond].round(6).values))
print('train cond groups:', len(train_conds))
print('val cond groups:', len(val_conds))
print('overlap:', len(train_conds & val_conds))
"

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')
allf = pd.concat([train,val,test], ignore_index=True)
# velocity clusters
for col in ['free_stream_velocity','chord_length']:
    v = np.sort(allf[col].values)
    print('===', col, '===')
    print(np.round(np.unique(np.round(v,1) if col=='free_stream_velocity' else np.round(v,4)), 4))
    print()
# attack angle - original grid
va = np.sort(train['attack_angle'].values)
print('attack_angle sample sorted (first 40):', np.round(va[:40],2))
"

cd /app && python3 -c "
import sklearn; print('sklearn', sklearn.__version__)
import numpy, scipy, pandas; print('numpy', numpy.__version__, 'scipy', scipy.__version__, 'pandas', pandas.__version__)
" 2>&1; echo "---xgboost---"; python3 -c "import xgboost; print('xgboost', xgboost.__version__)" 2>&1 | head -1; echo "---lightgbm---"; python3 -c "import lightgbm; print('lightgbm', lightgbm.__version__)" 2>&1 | head -1; echo "---catboost---"; python3 -c "import catboost; print('catboost', catboost.__version__)" 2>&1 | head -1; echo "---torch---"; python3 -c "import torch; print('torch', torch.__version__)" 2>&1 | head -1

cd /app && timeout 30 pip install xgboost 2>&1 | tail -3; echo "exit: done"

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'); test = pd.read_csv('data/test_features.csv')
allf = pd.concat([train,val,test], ignore_index=True)
# Original UCI grids
angles_uci = np.array([0,1.5,3.0,4.0,5.3,6.7,7.3,8.9,9.5,9.9,11.2,12.3,12.6,15.4,15.6,17.4,19.7,22.2])
vel_uci = np.array([31.7,39.6,55.5,71.3])
chord_uci = np.array([0.0254,0.0508,0.1016,0.1524,0.2286,0.3048])
for col, grid in [('attack_angle',angles_uci),('free_stream_velocity',vel_uci),('chord_length',chord_uci)]:
    v = allf[col].values
    nearest = grid[np.abs(v[:,None]-grid[None,:]).argmin(1)]
    dev = v - nearest
    print(col, 'max abs dev from nearest UCI grid:', np.round(np.abs(dev).max(),5), 'mean abs dev:', np.round(np.abs(dev).mean(),5))
"

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'); test = pd.read_csv('data/test_features.csv')
allf = pd.concat([train,val,test], ignore_index=True)
v = np.sort(allf['attack_angle'].values)
# find gaps > 0.3 to separate clusters
gaps = np.diff(v)
breaks = np.where(gaps>0.3)[0]
clusters = np.split(v, breaks+1)
print('num angle clusters:', len(clusters))
for c in clusters:
    print(f'  center={c.mean():.3f}  n={len(c)}  range=[{c.min():.3f},{c.max():.3f}] width={c.max()-c.min():.3f}')
"

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

FEATURES = ["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
TARGET = "scaled_sound_pressure_level"

def load():
    tr = pd.read_csv('/app/data/train.csv')
    va = pd.read_csv('/app/data/validation.csv')
    return pd.concat([tr,va], ignore_index=True)

VEL = np.array([31.7,39.6,55.5,71.3])
CHORD = np.array([0.0254,0.0508,0.1016,0.1524,0.2286,0.3048])

def snap(arr, grid):
    return grid[np.abs(arr[:,None]-grid[None,:]).argmin(1)]

def cond_key(df):
    vel = snap(df['free_stream_velocity'].values, VEL)
    ch = snap(df['chord_length'].values, CHORD)
    # cluster angle via gaps
    a = df['attack_angle'].values
    order = np.argsort(a); asort = a[order]
    gaps = np.diff(asort); breaks = np.where(gaps>0.25)[0]
    lab = np.zeros(len(a),dtype=int); cur=0
    labels_sorted = np.zeros(len(a),dtype=int)
    c=0
    for i in range(len(asort)):
        if i>0 and asort[i]-asort[i-1]>0.25: c+=1
        labels_sorted[i]=c
    angle_lab = np.empty(len(a),dtype=int); angle_lab[order]=labels_sorted
    keys = [f"{v:.1f}_{cc:.4f}_{al}" for v,cc,al in zip(vel,ch,angle_lab)]
    return np.array(keys)

def evaluate(df, pred):
    err = pred - df[TARGET].values
    rmse = np.sqrt(np.mean(err**2))
    mae = np.mean(np.abs(err))
    keys = cond_key(df)
    cond_rmse = []
    for k in np.unique(keys):
        m = keys==k
        cond_rmse.append(np.sqrt(np.mean(err[m]**2)))
    cond_rmse = np.array(cond_rmse)
    return dict(rmse=rmse, mae=mae,
               p90=np.percentile(cond_rmse,90),
               p95=np.percentile(cond_rmse,95),
               mx=cond_rmse.max(),
               ngroups=len(cond_rmse))

def group_cv(make_model, df, n_splits=5, seed=0, feat_fn=None):
    keys = cond_key(df)
    uniq = np.unique(keys)
    gkf = GroupKFold(n_splits=n_splits)
    oof = np.zeros(len(df))
    X = df[FEATURES]; y = df[TARGET].values
    for tri, tei in gkf.split(X, y, groups=keys):
        m = make_model()
        Xtr = feat_fn(X.iloc[tri]) if feat_fn else X.iloc[tri]
        Xte = feat_fn(X.iloc[tei]) if feat_fn else X.iloc[tei]
        m.fit(Xtr, y[tri])
        oof[tei] = m.predict(Xte)
    return evaluate(df, oof)

if __name__=='__main__':
    df = load()
    print('n conditions in labeled data:', len(np.unique(cond_key(df))), 'rows:', len(df))
EOF
python3 /tmp/harness.py

cd /app && cat > /tmp/bench1.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from harness import *
import numpy as np, pandas as pd
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, HistGradientBoostingRegressor, GradientBoostingRegressor
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

df = load()

def raw(X): return X

models = {
 'Ridge_raw': lambda: make_pipeline(StandardScaler(), Ridge(alpha=10.0)),
 'RF': lambda: RandomForestRegressor(n_estimators=400, n_jobs=-1, random_state=0),
 'ExtraTrees': lambda: ExtraTreesRegressor(n_estimators=400, n_jobs=-1, random_state=0),
 'HGB': lambda: HistGradientBoostingRegressor(max_iter=500, learning_rate=0.05, random_state=0),
 'GBR': lambda: GradientBoostingRegressor(n_estimators=500, learning_rate=0.05, max_depth=3, random_state=0),
}
for name, mk in models.items():
    r = group_cv(mk, df, n_splits=5)
    print(f"{name:12s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f}")
EOF
python3 /tmp/bench1.py

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

NU = 1.5e-5  # kinematic viscosity of air
def engineer(X):
    f = X['frequency'].astype(float).values
    a = X['attack_angle'].astype(float).values
    c = X['chord_length'].astype(float).values
    U = X['free_stream_velocity'].astype(float).values
    d = X['suction_side_displacement_thickness'].astype(float).values
    out = {}
    out['log_f'] = np.log10(f)
    out['angle'] = a
    out['log_c'] = np.log10(c)
    out['U'] = U
    out['log_d'] = np.log10(d)
    # physics
    out['strouhal'] = np.log10(f*d/U)            # Strouhal number (log)
    out['Re_c'] = np.log10(U*c/NU)               # chord Reynolds
    out['Re_d'] = np.log10(U*d/NU)               # thickness Reynolds
    out['fd'] = np.log10(f*d)
    out['mach'] = U/340.0
    out['d_over_c'] = np.log10(d/c)
    out['angle_rad'] = np.deg2rad(a)
    out['sin_a'] = np.sin(np.deg2rad(a))
    out['log_f_sq'] = np.log10(f)**2
    return pd.DataFrame(out, index=X.index)
EOF
cat > /tmp/bench2.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from harness import *
from feats import engineer
import numpy as np
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, HistGradientBoostingRegressor, GradientBoostingRegressor
from sklearn.linear_model import Ridge
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neural_network import MLPRegressor

df = load()
models = {
 'Ridge_eng': lambda: make_pipeline(StandardScaler(), Ridge(alpha=1.0)),
 'RF_eng': lambda: RandomForestRegressor(n_estimators=400, n_jobs=-1, random_state=0),
 'ExtraTrees_eng': lambda: ExtraTreesRegressor(n_estimators=400, n_jobs=-1, random_state=0),
 'HGB_eng': lambda: HistGradientBoostingRegressor(max_iter=600, learning_rate=0.05, random_state=0),
 'GBR_eng': lambda: GradientBoostingRegressor(n_estimators=600, learning_rate=0.05, max_depth=3, random_state=0),
 'MLP_eng': lambda: make_pipeline(StandardScaler(), MLPRegressor(hidden_layer_sizes=(128,128,64), max_iter=2000, alpha=1e-3, random_state=0)),
}
for name, mk in models.items():
    r = group_cv(mk, df, n_splits=5, feat_fn=engineer)
    print(f"{name:16s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f}")
EOF
python3 /tmp/bench2.py

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp')
from harness import cond_key
import pandas as pd, numpy as np
tr = pd.read_csv('/app/data/train.csv'); va = pd.read_csv('/app/data/validation.csv')
allf = pd.concat([tr,va], ignore_index=True)
k = cond_key(allf)
ktr = k[:len(tr)]; kva = k[len(tr):]
print('train snapped conditions:', len(np.unique(ktr)))
print('val snapped conditions:', len(np.unique(kva)))
print('overlap:', len(set(ktr)&set(kva)))
print('val-only conditions:', len(set(kva)-set(ktr)))
# rows per val condition
import collections
c = collections.Counter(kva)
print('val rows per condition: min/mean/max', min(c.values()), round(np.mean(list(c.values())),1), max(c.values()))
"

cd /app && cat > /tmp/bench3.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from harness import evaluate, FEATURES, TARGET, cond_key
from feats import engineer
import numpy as np, pandas as pd
from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neural_network import MLPRegressor

tr = pd.read_csv('/app/data/train.csv'); va = pd.read_csv('/app/data/validation.csv')
Xtr, ytr = engineer(tr[FEATURES]), tr[TARGET].values
Xva = engineer(va[FEATURES])

def report(name, pred):
    r = evaluate(va, pred)
    print(f"{name:16s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} ngrp={r['ngroups']}")

models = {
 'RF': lambda: RandomForestRegressor(n_estimators=600, n_jobs=-1, random_state=0),
 'ExtraTrees': lambda: ExtraTreesRegressor(n_estimators=600, n_jobs=-1, random_state=0),
 'HGB': lambda: HistGradientBoostingRegressor(max_iter=600, learning_rate=0.05, random_state=0),
 'MLP': lambda: make_pipeline(StandardScaler(), MLPRegressor(hidden_layer_sizes=(128,128,64), max_iter=3000, alpha=1e-3, random_state=0)),
}
for name, mk in models.items():
    m = mk(); m.fit(Xtr, ytr); report(name, m.predict(Xva))
EOF
python3 /tmp/bench3.py

cd /app && cat > /tmp/diag.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from harness import FEATURES, TARGET, cond_key, VEL, CHORD, snap
from feats import engineer
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor

tr = pd.read_csv('/app/data/train.csv'); va = pd.read_csv('/app/data/validation.csv')
Xtr, ytr = engineer(tr[FEATURES]), tr[TARGET].values
Xva = engineer(va[FEATURES])
m = ExtraTreesRegressor(n_estimators=600, n_jobs=-1, random_state=0); m.fit(Xtr, ytr)
pred = m.predict(Xva)
err = pred - va[TARGET].values
keys = cond_key(va)
rows=[]
for k in np.unique(keys):
    mask = keys==k
    sub = va[mask]
    rmse = np.sqrt(np.mean(err[mask]**2))
    bias = np.mean(err[mask])
    rows.append((k, mask.sum(), rmse, bias, sub['attack_angle'].mean(), sub['chord_length'].mean(), sub['free_stream_velocity'].mean(), sub['frequency'].min(), sub['frequency'].max()))
r = pd.DataFrame(rows, columns=['key','n','rmse','bias','angle','chord','vel','fmin','fmax']).sort_values('rmse',ascending=False)
pd.set_option('display.width',200)
print(r.to_string(index=False))
EOF
python3 /tmp/diag.py

cd /app && cat > /tmp/bench4.py << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from harness import evaluate, FEATURES, TARGET
from feats import engineer
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR
from sklearn.kernel_ridge import KernelRidge
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel, Matern

tr = pd.read_csv('/app/data/train.csv'); va = pd.read_csv('/app/data/validation.csv')
Xtr, ytr = engineer(tr[FEATURES]), tr[TARGET].values
Xva = engineer(va[FEATURES])

def report(name, pred):
    r = evaluate(va, pred)
    print(f"{name:22s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f}")

models = {
 'SVR_rbf': lambda: make_pipeline(StandardScaler(), SVR(C=10, gamma='scale', epsilon=0.1)),
 'SVR_rbf_C30': lambda: make_pipeline(StandardScaler(), SVR(C=30, gamma=0.1, epsilon=0.05)),
 'KRR_rbf': lambda: make_pipeline(StandardScaler(), KernelRidge(alpha=0.1, kernel='rbf', gamma=0.1)),
 'GP_matern': lambda: make_pipeline(StandardScaler(), GaussianProcessRegressor(
     kernel=ConstantKernel(1.0)*Matern(length_scale=np.ones(Xtr.shape[1]), nu=1.5)+WhiteKernel(0.1),
     normalize_y=True, n_restarts_optimizer=0, random_state=0)),
}
for name, mk in models.items():
    m = mk(); m.fit(Xtr, ytr); report(name, m.predict(Xva))
EOF
python3 /tmp/bench4.py

cd /app && cat > /tmp/bench5.py << 'EOF'
import sys, warnings; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET
from feats import engineer
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C, WhiteKernel, Matern

tr = pd.read_csv('/app/data/train.csv'); va = pd.read_csv('/app/data/validation.csv')
Xtr, ytr = engineer(tr[FEATURES]), tr[TARGET].values
Xva = engineer(va[FEATURES])
d = Xtr.shape[1]

def report(name, pred):
    r = evaluate(va, pred)
    print(f"{name:22s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f}")

def gp(nu, wk=0.1):
    return make_pipeline(StandardScaler(), GaussianProcessRegressor(
        kernel=C(1.0)*Matern(length_scale=np.ones(d), nu=nu)+WhiteKernel(wk, (1e-3,10.0)),
        normalize_y=True, n_restarts_optimizer=2, random_state=0, alpha=1e-8))

preds = {}
for nu in [1.5, 2.5]:
    m = gp(nu); m.fit(Xtr,ytr); p = m.predict(Xva); preds[f'GP_nu{nu}']=p; report(f'GP_nu{nu}', p)
# RBF ARD
m = make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*RBF(np.ones(d))+WhiteKernel(0.1,(1e-3,10)), normalize_y=True, n_restarts_optimizer=2, random_state=0, alpha=1e-8))
m.fit(Xtr,ytr); p=m.predict(Xva); preds['GP_rbf']=p; report('GP_rbf', p)
# ExtraTrees
et = ExtraTreesRegressor(n_estimators=800, n_jobs=-1, random_state=0); et.fit(Xtr,ytr); pet=et.predict(Xva); preds['ET']=pet
# blends
for w in [0.2,0.3,0.4,0.5]:
    report(f'GP25*{1-w}+ET*{w}', (1-w)*preds['GP_nu2.5']+w*pet)
EOF
python3 /tmp/bench5.py

restart: true

cd /app && cat > /tmp/bench5.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET
from feats import engineer
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C, WhiteKernel, Matern

tr = pd.read_csv('/app/data/train.csv'); va = pd.read_csv('/app/data/validation.csv')
Xtr, ytr = engineer(tr[FEATURES]), tr[TARGET].values
Xva = engineer(va[FEATURES])
d = Xtr.shape[1]
def report(name, pred):
    r = evaluate(va, pred)
    print(f"{name:22s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f}", flush=True)
def gp(nu, wk=0.1):
    return make_pipeline(StandardScaler(), GaussianProcessRegressor(
        kernel=C(1.0)*Matern(length_scale=np.ones(d), nu=nu)+WhiteKernel(wk,(1e-3,10.0)),
        normalize_y=True, n_restarts_optimizer=0, random_state=0, alpha=1e-8))
preds={}
t=time.time()
for nu in [1.5,2.5]:
    m=gp(nu); m.fit(Xtr,ytr); p=m.predict(Xva); preds[f'GP{nu}']=p; report(f'GP_nu{nu}',p)
m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*RBF(np.ones(d))+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
m.fit(Xtr,ytr); preds['rbf']=m.predict(Xva); report('GP_rbf',preds['rbf'])
et=ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0); et.fit(Xtr,ytr); pet=et.predict(Xva); preds['ET']=pet
for w in [0.2,0.3,0.4]:
    report(f'GP25*{1-w:.1f}+ET*{w}', (1-w)*preds['GP2.5']+w*pet)
print('elapsed', round(time.time()-t,1))
EOF
timeout 250 python3 /tmp/bench5.py

cd /app && cat > /tmp/feats2.py << 'EOF'
import numpy as np, pandas as pd
NU=1.5e-5
def eng_core(X):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    d=X['suction_side_displacement_thickness'].astype(float).values
    out={}
    out['log_f']=np.log10(f); out['angle']=a; out['log_c']=np.log10(c)
    out['U']=U; out['log_d']=np.log10(d); out['strouhal']=np.log10(f*d/U)
    return pd.DataFrame(out,index=X.index)
EOF
cat > /tmp/t_gp.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET
from feats2 import eng_core
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv')
Xtr,ytr=eng_core(tr[FEATURES]),tr[TARGET].values; Xva=eng_core(va[FEATURES]); d=Xtr.shape[1]
t=time.time()
m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
m.fit(Xtr,ytr); p=m.predict(Xva)
r=evaluate(va,p)
print(f"GP_core6 rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} time={time.time()-t:.1f}s")
EOF
timeout 250 python3 /tmp/t_gp.py

cd /app && cat > /tmp/diag_gp.py << 'EOF'
import sys, warnings; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
from feats2 import eng_core
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv')
Xtr,ytr=eng_core(tr[FEATURES]),tr[TARGET].values; Xva=eng_core(va[FEATURES]); d=Xtr.shape[1]
m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
m.fit(Xtr,ytr); pred=m.predict(Xva); err=pred-va[TARGET].values
keys=cond_key(va); rows=[]
for k in np.unique(keys):
    mk=keys==k; sub=va[mk]
    rows.append((k,mk.sum(),np.sqrt(np.mean(err[mk]**2)),np.mean(err[mk]),sub['attack_angle'].mean(),sub['chord_length'].mean(),sub['free_stream_velocity'].mean()))
r=pd.DataFrame(rows,columns=['key','n','rmse','bias','angle','chord','vel']).sort_values('rmse',ascending=False)
pd.set_option('display.width',200); print(r.to_string(index=False))
EOF
timeout 120 python3 /tmp/diag_gp.py

cd /app && cat > /tmp/blend1.py << 'EOF'
import sys, warnings; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET
from feats2 import eng_core
from feats import engineer
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv')
Xc,ytr=eng_core(tr[FEATURES]),tr[TARGET].values; Xvc=eng_core(va[FEATURES]); d=Xc.shape[1]
Xe=engineer(tr[FEATURES]); Xve=engineer(va[FEATURES])
def report(name,pred):
    r=evaluate(va,pred); print(f"{name:20s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f}",flush=True)
gp=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
gp.fit(Xc,ytr); pg=gp.predict(Xvc)
et=ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0); et.fit(Xe,ytr); pe=et.predict(Xve)
hgb=HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,random_state=0); hgb.fit(Xe,ytr); ph=hgb.predict(Xve)
report('GP',pg); report('ET',pe); report('HGB',ph)
for w in [0.15,0.25,0.35]:
    report(f'GP*{1-w:.2f}+ET*{w:.2f}',(1-w)*pg+w*pe)
for w in [0.2,0.3]:
    report(f'GP*{1-2*w:.2f}+ET*{w}+HGB*{w}',(1-2*w)*pg+w*pe+w*ph)
np.save('/tmp/pg.npy',pg); np.save('/tmp/pe.npy',pe); np.save('/tmp/ph.npy',ph)
EOF
timeout 200 python3 /tmp/blend1.py

cd /app && cat > /tmp/detail.py << 'EOF'
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv')
pg=np.load('/tmp/pg.npy'); pe=np.load('/tmp/pe.npy')
pred=0.75*pg+0.25*pe
keys=cond_key(va); y=va[TARGET].values
# show the two worst conditions detail
for key in ['71.3_0.0254_0','55.5_0.0508_0']:
    m=keys==key; sub=va[m].copy(); sub['y']=y[m]; sub['pred']=pred[m]; sub['err']=pred[m]-y[m]
    sub=sub.sort_values('frequency')
    print('===',key,'===')
    print(sub[['frequency','y','pred','err']].to_string(index=False))
    print()
EOF
python3 /tmp/detail.py

cd /app && cat > /tmp/ablate.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv')
def build(X, feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={}
    b['log_f']=np.log10(f); b['angle']=a; b['log_c']=np.log10(c); b['U']=U; b['log_d']=np.log10(dd)
    b['strouhal']=np.log10(f*dd/U); b['str2']=np.log10(f*dd/U)**2; b['Re_c']=np.log10(U*c/NU)
    b['Re_d']=np.log10(U*dd/NU); b['logU']=np.log10(U); b['af']=a*np.log10(f); b['dc']=np.log10(dd/c)
    b['sin_a']=np.sin(np.deg2rad(a)); b['mach']=U/340.0
    return pd.DataFrame({k:b[k] for k in feats}, index=X.index)
def run(feats):
    Xtr=build(tr[FEATURES],feats); Xva=build(va[FEATURES],feats); d=len(feats)
    m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
    m.fit(Xtr,tr[TARGET].values); p=m.predict(Xva); return p, evaluate(va,p)
sets={
 'A_core': ['log_f','angle','log_c','U','log_d','strouhal'],
 'B_str2': ['log_f','angle','log_c','U','log_d','strouhal','str2'],
 'C_nostr': ['log_f','angle','log_c','U','log_d'],
 'D_Re': ['log_f','angle','log_c','U','log_d','strouhal','Re_c'],
 'E_full': ['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
 'F_int': ['log_f','angle','log_c','U','log_d','strouhal','str2','af'],
 'G_sin': ['log_f','sin_a','angle','log_c','U','log_d','strouhal','str2'],
}
for name, feats in sets.items():
    t=time.time(); p,r=run(feats)
    np.save(f'/tmp/p_{name}.npy',p)
    print(f"{name:10s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} ({time.time()-t:.0f}s)",flush=True)
EOF
nohup timeout 280 python3 /tmp/ablate.py > /tmp/ablate.log 2>&1 &
echo "started"; sleep 5; cat /tmp/ablate.log

sleep 120; cat /tmp/ablate.log

sleep 60; cat /tmp/ablate.log

sleep 45; cat /tmp/ablate.log

cd /app && cat > /tmp/blend2.py << 'EOF'
import sys, warnings; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
va=pd.read_csv('/app/data/validation.csv'); y=va[TARGET].values
pg=np.load('/tmp/p_E_full.npy'); pe=np.load('/tmp/pe.npy'); ph=np.load('/tmp/ph.npy')
keys=cond_key(va)
def stats(pred):
    err=pred-y; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    return cr
def report(name,pred):
    r=evaluate(va,pred); cr=stats(pred); nunder=(cr<=2.35).sum()
    print(f"{name:22s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} under2.35={nunder}/{len(cr)}",flush=True)
report('GP_E',pg); report('ET',pe); report('HGB',ph)
for w in [0.15,0.2,0.25,0.3,0.35]:
    report(f'GP*{1-w:.2f}+ET*{w:.2f}',(1-w)*pg+w*pe)
best=0.75*pg+0.25*pe
cr=stats(best); order=np.argsort(cr)[::-1]
print('\nSorted condition RMSE (blend GP*.75+ET*.25):', np.round(np.sort(cr)[::-1],2))
EOF
python3 /tmp/blend2.py

cd /app && cat > /tmp/resgp.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern, DotProduct
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
feats=['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc']
def build(X):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'dc':np.log10(dd/c)}
    return pd.DataFrame(b,index=X.index)[feats]
Xtr=build(tr[FEATURES]); Xva=build(va[FEATURES]); d=len(feats)
keys=cond_key(va)
def report(name,pred):
    r=evaluate(va,pred); err=pred-yv; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:22s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} under={int((cr<=2.35).sum())}/15",flush=True)

# Plain GP constant mean (reference)
gp0=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
gp0.fit(Xtr,y); p0=gp0.predict(Xva); report('GP_const',p0)

# Linear mean via Ridge base + GP on residuals
sc=StandardScaler().fit(Xtr); Xs=sc.transform(Xtr); Xvs=sc.transform(Xva)
for alpha in [1.0, 5.0]:
    base=Ridge(alpha=alpha).fit(Xs,y); rtr=y-base.predict(Xs)
    gpr=GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8)
    gpr.fit(Xs,rtr); pr=base.predict(Xvs)+gpr.predict(Xvs); report(f'Ridge{alpha}+GPres',pr)

# GP with DotProduct (linear) + Matern kernel
gpd=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+C(1.0)*DotProduct(sigma_0=1.0)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
t=time.time(); gpd.fit(Xtr,y); pd_=gpd.predict(Xva); report('GP_Matern+Dot',pd_)
np.save('/tmp/p_gpconst.npy',p0)
EOF
timeout 200 python3 /tmp/resgp.py

cd /app && cat > /tmp/cv_blend.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df)
feats=['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc']
def build(X):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'dc':np.log10(dd/c)}
    return pd.DataFrame(b,index=X.index)[feats]
X=build(df[FEATURES]); d=len(feats)
gkf=GroupKFold(n_splits=6)
oof_g=np.zeros(len(df)); oof_e=np.zeros(len(df))
t=time.time()
for tri,tei in gkf.split(X,y,groups=keys):
    gp=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
    gp.fit(X.iloc[tri],y[tri]); oof_g[tei]=gp.predict(X.iloc[tei])
    et=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0); et.fit(X.iloc[tri],y[tri]); oof_e[tei]=et.predict(X.iloc[tei])
print('cv time',round(time.time()-t),'s; n conditions',len(np.unique(keys)))
def report(name,pred):
    err=pred-y; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:18s} rmse={np.sqrt(np.mean(err**2)):.3f} mae={np.mean(np.abs(err)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f} under2.35={int((cr<=2.35).sum())}/{len(cr)}",flush=True)
report('GP',oof_g); report('ET',oof_e)
for w in [0.2,0.25,0.3]:
    report(f'GP*{1-w:.2f}+ET*{w:.2f}',(1-w)*oof_g+w*oof_e)
np.save('/tmp/oof_g.npy',oof_g); np.save('/tmp/oof_e.npy',oof_e)
EOF
nohup timeout 280 python3 /tmp/cv_blend.py > /tmp/cv_blend.log 2>&1 &
echo started; sleep 90; cat /tmp/cv_blend.log

sleep 60; cat /tmp/cv_blend.log

sleep 30; cat /tmp/cv_blend.log

sleep 45; cat /tmp/cv_blend.log; echo "---proc---"; pgrep -af cv_blend || echo "done"

sleep 50; cat /tmp/cv_blend.log; echo "---proc---"; pgrep -af cv_blend.py | grep -v timeout || echo "done"

cd /app && python3 -c "
import sys; sys.path.insert(0,'/tmp'); import numpy as np, pandas as pd
from harness import cond_key, TARGET
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
keys=cond_key(df)
# For each condition with many points, fit smooth (poly deg 4 in log-f) and compute residual std
resids=[]
for k in np.unique(keys):
    m=keys==k; sub=df[m]
    if m.sum()<8: continue
    lf=np.log10(sub['frequency'].values); sp=sub[TARGET].values
    o=np.argsort(lf); lf=lf[o]; sp=sp[o]
    coef=np.polyfit(lf,sp,min(4,len(lf)-2)); fit=np.polyval(coef,lf)
    resids.append(np.std(sp-fit))
resids=np.array(resids)
print('within-condition smooth-fit residual std: mean %.3f median %.3f p90 %.3f max %.3f'%(resids.mean(),np.median(resids),np.percentile(resids,90),resids.max()))
print('This approximates irreducible label noise (dB).')
"

cd /app && cat > /tmp/gptune.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
feats=['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc']
def build(X):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'dc':np.log10(dd/c)}
    return pd.DataFrame(b,index=X.index)[feats]
Xtr=build(tr[FEATURES]); Xva=build(va[FEATURES]); d=len(feats); keys=cond_key(va)
def report(name,pred):
    r=evaluate(va,pred); err=pred-yv; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:26s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} under={int((cr<=2.35).sum())}/15",flush=True)
configs={
 'nu1.5_r4': (1.5,4,0.1,(1e-3,10.0)),
 'nu2.5_r4': (2.5,4,0.1,(1e-3,10.0)),
 'nu1.5_noisefix0.5': (1.5,0,0.5,'fixed'),
 'nu1.5_noisehi': (1.5,4,0.5,(0.2,5.0)),
}
for name,(nu,rest,wk,wb) in configs.items():
    t=time.time()
    if wb=='fixed':
        from sklearn.gaussian_process.kernels import WhiteKernel as WK
        kern=C(1.0)*Matern(np.ones(d),nu=nu)+WK(wk,'fixed')
    else:
        kern=C(1.0)*Matern(np.ones(d),nu=nu)+WhiteKernel(wk,wb)
    m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=kern,normalize_y=True,n_restarts_optimizer=rest,random_state=0,alpha=1e-8))
    m.fit(Xtr,y); p=m.predict(Xva); report(f'{name}({time.time()-t:.0f}s)',p)
EOF
nohup timeout 290 python3 /tmp/gptune.py > /tmp/gptune.log 2>&1 &
echo started

cd /app && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import TARGET
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
f=df['frequency'].values; U=df['free_stream_velocity'].values; dd=df['suction_side_displacement_thickness'].values
a=df['attack_angle'].values; c=df['chord_length'].values; sp=df[TARGET].values
st=np.log10(f*dd/U)
amp=10*np.log10(dd)+50*np.log10(U/340.0)
resid=sp-amp
# correlation of resid with st, and how tight the collapse is
print('corr(resid, st):', np.corrcoef(resid, st)[0,1])
# Fit resid ~ poly(st) deg 5 and check residual std
coef=np.polyfit(st,resid,6); fit=np.polyval(coef,st)
print('std of SPL-amp around poly(st):', np.std(resid-fit))
print('raw std of SPL:', np.std(sp))
# Now include angle: fit resid ~ poly(st) + angle terms
from numpy.polynomial import polynomial as P
A=np.column_stack([st**i for i in range(7)]+[a, a**2, a*st, np.log10(c)])
coef2,_,_,_=np.linalg.lstsq(A, resid, rcond=None); fit2=A@coef2
print('std SPL-amp around poly(st)+angle+chord:', np.std(resid-fit2))
"

cat /tmp/gptune.log; echo "---"; pgrep -af gptune.py | grep -v timeout || echo done

sleep 120; cat /tmp/gptune.log; echo "---"; pgrep -af gptune.py | grep -v timeout || echo done

sleep 100; cat /tmp/gptune.log; echo "---"; pgrep -af gptune.py | grep -v timeout || echo done

sleep 60; cat /tmp/gptune.log; echo "---"; pgrep -af gptune.py | grep -v timeout || echo done

cd /app && cat > /tmp/battery.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor, RandomForestRegressor
from sklearn.neural_network import MLPRegressor
from sklearn.neighbors import KNeighborsRegressor
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
feats=['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc']
def build(X):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'dc':np.log10(dd/c)}
    return pd.DataFrame(b,index=X.index)[feats]
Xtr=build(tr[FEATURES]); Xva=build(va[FEATURES]); keys=cond_key(va)
def report(name,pred):
    r=evaluate(va,pred); err=pred-yv; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:20s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} under={int((cr<=2.35).sum())}/15",flush=True)
P={}
# MLP ensemble (5 seeds)
t=time.time(); mlps=[]
for s in range(5):
    m=make_pipeline(StandardScaler(), MLPRegressor(hidden_layer_sizes=(200,150,100),activation='tanh',alpha=1e-3,max_iter=4000,early_stopping=True,n_iter_no_change=40,random_state=s))
    m.fit(Xtr,y); mlps.append(m.predict(Xva))
P['MLP']=np.mean(mlps,0); report(f'MLP5({time.time()-t:.0f}s)',P['MLP'])
# KNN in standardized physics space
sc=StandardScaler().fit(Xtr); Xs=sc.transform(Xtr); Xvs=sc.transform(Xva)
for k in [8,15,25]:
    kn=KNeighborsRegressor(n_neighbors=k,weights='distance').fit(Xs,y); P[f'KNN{k}']=kn.predict(Xvs); report(f'KNN{k}',P[f'KNN{k}'])
# ET, HGB, RF
P['ET']=ExtraTreesRegressor(n_estimators=800,n_jobs=-1,random_state=0).fit(Xtr,y).predict(Xva); report('ET',P['ET'])
P['HGB']=HistGradientBoostingRegressor(max_iter=700,learning_rate=0.04,max_leaf_nodes=31,random_state=0).fit(Xtr,y).predict(Xva); report('HGB',P['HGB'])
for n,p in P.items(): np.save(f'/tmp/val_{n}.npy',p)
EOF
nohup timeout 200 python3 /tmp/battery.py > /tmp/battery.log 2>&1 &
echo started; sleep 75; cat /tmp/battery.log

cd /app && cat > /tmp/gpens.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
def build(X,feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats]
keys=cond_key(va)
def report(name,pred):
    r=evaluate(va,pred); err=pred-yv; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:22s} rmse={r['rmse']:.3f} mae={r['mae']:.3f} p90={r['p90']:.3f} p95={r['p95']:.3f} max={r['mx']:.3f} under={int((cr<=2.35).sum())}/15",flush=True)
def fit_gp(feats,nu=1.5):
    Xt=build(tr[FEATURES],feats); Xv=build(va[FEATURES],feats); d=len(feats)
    m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=nu)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
    m.fit(Xt,y); return m.predict(Xv)
sets={
 'E': ['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
 'S': ['strouhal','str2','angle','log_c','logU','Re_d','dc'],
 'M': ['log_f','angle','log_c','mach','log_d','strouhal','Re_c'],
 'F': ['log_f','angle','log_c','U','log_d','strouhal','Re_c','Re_d','dc','str2'],
}
preds={}
t=time.time()
for n,fs in sets.items():
    preds[n]=fit_gp(fs); report(f'GP_{n}',preds[n]); np.save(f'/tmp/val_GP_{n}.npy',preds[n])
print('time',round(time.time()-t))
# ensembles
report('ens E+S+M', (preds['E']+preds['S']+preds['M'])/3)
report('ens E+S+M+F',(preds['E']+preds['S']+preds['M']+preds['F'])/4)
report('ens E+M',(preds['E']+preds['M'])/2)
report('ens E+S',(preds['E']+preds['S'])/2)
pe=np.load('/tmp/val_ET.npy')
ens=(preds['E']+preds['S']+preds['M'])/3
for w in [0.15,0.2,0.25]:
    report(f'ens*{1-w:.2f}+ET*{w}',(1-w)*ens+w*pe)
EOF
nohup timeout 200 python3 /tmp/gpens.py > /tmp/gpens.log 2>&1 &
echo started; sleep 90; cat /tmp/gpens.log

sleep 45; cat /tmp/gpens.log; echo "---"; pgrep -af gpens.py | grep -v timeout || echo done

cd /app && cat > /tmp/cv_ens.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
FEATURES=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df)
def build(X,feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats]
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
      'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],
      'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
def mkgp(d): return make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
gkf=GroupKFold(n_splits=5)
oof={n:np.zeros(len(df)) for n in list(sets)+['ET']}
Xe=build(df[FEATURES],sets['E'])
t=time.time()
for tri,tei in gkf.split(df,y,groups=keys):
    for n,fs in sets.items():
        Xb=build(df[FEATURES],fs); m=mkgp(len(fs)); m.fit(Xb.iloc[tri],y[tri]); oof[n][tei]=m.predict(Xb.iloc[tei])
    et=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0).fit(Xe.iloc[tri],y[tri]); oof['ET'][tei]=et.predict(Xe.iloc[tei])
print('cv time',round(time.time()-t))
def report(name,pred):
    err=pred-y; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:18s} rmse={np.sqrt(np.mean(err**2)):.3f} mae={np.mean(np.abs(err)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f} under={int((cr<=2.35).sum())}/{len(cr)}",flush=True)
ens=(oof['E']+oof['S']+oof['M'])/3
report('GP_E',oof['E']); report('GP_ens',ens)
for w in [0.15,0.2,0.25]:
    report(f'ens*{1-w:.2f}+ET*{w}',(1-w)*ens+w*oof['ET'])
for n in oof: np.save(f'/tmp/cvoof_{n}.npy',oof[n])
EOF
nohup timeout 295 python3 /tmp/cv_ens.py > /tmp/cv_ens.log 2>&1 &
echo started; sleep 120; cat /tmp/cv_ens.log

sleep 120; cat /tmp/cv_ens.log; echo "---"; pgrep -af cv_ens.py | grep -v timeout || echo done

sleep 60; cat /tmp/cv_ens.log; echo "---"; pgrep -af cv_ens.py | grep -v timeout || echo done

cd /app && cat > /tmp/cv_ens2.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.model_selection import GroupKFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
FEATURES=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df)
def build(X,feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats]
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
      'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],
      'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
Xmats={n:build(df[FEATURES],fs).values for n,fs in sets.items()}
def mkgp(d): return make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
gkf=GroupKFold(n_splits=4)
oof={n:np.zeros(len(df)) for n in list(sets)+['ET']}
t=time.time()
for tri,tei in gkf.split(df,y,groups=keys):
    for n in sets:
        X=Xmats[n]; m=mkgp(X.shape[1]); m.fit(X[tri],y[tri]); oof[n][tei]=m.predict(X[tei])
    et=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0).fit(Xmats['E'][tri],y[tri]); oof['ET'][tei]=et.predict(Xmats['E'][tei])
print('cv time',round(time.time()-t),'nconds',len(np.unique(keys)))
def report(name,pred):
    err=pred-y; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f"{name:18s} rmse={np.sqrt(np.mean(err**2)):.3f} mae={np.mean(np.abs(err)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f} under={int((cr<=2.35).sum())}/{len(cr)}",flush=True)
ens=(oof['E']+oof['S']+oof['M'])/3
report('GP_E',oof['E']); report('GP_ens',ens)
for w in [0.15,0.2,0.25]:
    report(f'ens*{1-w:.2f}+ET*{w}',(1-w)*ens+w*oof['ET'])
EOF
nohup timeout 295 python3 /tmp/cv_ens2.py > /tmp/cv_ens2.log 2>&1 &
echo started; sleep 200; cat /tmp/cv_ens2.log; echo "---"; pgrep -af cv_ens2.py | grep -v timeout || echo done

sleep 40; cat /tmp/cv_ens2.log; echo "---"; pgrep -af cv_ens2.py | grep -v timeout || echo done

sleep 45; cat /tmp/cv_ens2.log; echo "---"; pgrep -af cv_ens2.py | grep -v timeout || echo done

sleep 40; cat /tmp/cv_ens2.log; echo "---"; pgrep -af cv_ens2.py | grep -v timeout || echo done

cd /app && sed 's/n_splits=4/n_splits=3/' /tmp/cv_ens2.py > /tmp/cv_ens3.py
nohup timeout 295 python3 /tmp/cv_ens3.py > /tmp/cv_ens3.log 2>&1 &
echo started; sleep 220; cat /tmp/cv_ens3.log; echo "---"; pgrep -af cv_ens3.py | grep -v timeout || echo done

cd /app && python3 -c "
import numpy as np, pandas as pd, sys, glob; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET, evaluate
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
P={}
for f in glob.glob('/tmp/val_*.npy'):
    P[f.split('val_')[1][:-4]]=np.load(f)
print('available:', sorted(P))
def rep(name,pred):
    r=evaluate(va,pred); err=pred-yv; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f'{name:32s} rmse={r[\"rmse\"]:.3f} mae={r[\"mae\"]:.3f} p90={r[\"p90\"]:.3f} p95={r[\"p95\"]:.3f} max={r[\"mx\"]:.3f} under={int((cr<=2.35).sum())}/15')
gpens=(P['GP_E']+P['GP_S']+P['GP_M'])/3
rep('GPens(E,S,M)',gpens)
rep('GPens+ET .8/.2',0.8*gpens+0.2*P['ET'])
# add GP_F
gpens4=(P['GP_E']+P['GP_S']+P['GP_M']+P['GP_F'])/4
rep('GPens4+ET .8/.2',0.8*gpens4+0.2*P['ET'])
# add KNN8 small weight
rep('.72GPe+.18ET+.10KNN',0.72*gpens+0.18*P['ET']+0.10*P['KNN8'])
rep('.7GPe+.2ET+.1KNN',0.7*gpens+0.2*P['ET']+0.1*P['KNN8'])
rep('.75GPe+.15ET+.10KNN',0.75*gpens+0.15*P['ET']+0.10*P['KNN8'])
# ET+HGB tree blend
tree=0.6*P['ET']+0.4*P['HGB']
rep('.8GPe+.2(ET,HGB)',0.8*gpens+0.2*tree)
"

cd /app && cat > /tmp/biggpens.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
def build(X,feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats]
keys=cond_key(va)
def rep(name,pred):
    r=evaluate(va,pred); err=pred-yv; cr=np.array([np.sqrt(np.mean(err[keys==k]**2)) for k in np.unique(keys)])
    print(f'{name:26s} rmse={r["rmse"]:.3f} mae={r["mae"]:.3f} p90={r["p90"]:.3f} p95={r["p95"]:.3f} max={r["mx"]:.3f} under={int((cr<=2.35).sum())}/15',flush=True)
def gp(feats,nu=1.5,wk=0.1):
    Xt=build(tr[FEATURES],feats); Xv=build(va[FEATURES],feats); d=len(feats)
    m=make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=nu)+WhiteKernel(wk,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
    m.fit(Xt,y); return m.predict(Xv)
sets={
 'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
 'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],
 'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c'],
 'core':['log_f','angle','log_c','U','log_d','strouhal'],
 'R':['log_f','angle','log_c','U','log_d','strouhal','Re_c','Re_d'],
 'D':['strouhal','angle','log_c','U','log_d','dc','Re_c'],
}
P={}; t=time.time()
for n,fs in sets.items(): P[n]=gp(fs); np.save(f'/tmp/val_GPx_{n}.npy',P[n])
P['E25']=gp(sets['E'],nu=2.5); np.save('/tmp/val_GPx_E25.npy',P['E25'])
print('time',round(time.time()-t))
rep('ens6',sum(P[n] for n in sets)/len(sets))
rep('ens E,S,M,R,D',(P['E']+P['S']+P['M']+P['R']+P['D'])/5)
rep('ens +E25',(P['E']+P['S']+P['M']+P['R']+P['D']+P['E25'])/6)
et=np.load('/tmp/val_ET.npy'); kn=np.load('/tmp/val_KNN8.npy')
big=(P['E']+P['S']+P['M']+P['R']+P['D']+P['E25'])/6
rep('big*.8+ET*.2',0.8*big+0.2*et)
rep('big*.75+ET*.15+KNN*.10',0.75*big+0.15*et+0.10*kn)
EOF
nohup timeout 290 python3 /tmp/biggpens.py > /tmp/biggpens.log 2>&1 &
echo started; sleep 150; cat /tmp/biggpens.log

sleep 70; cat /tmp/biggpens.log; echo "---"; pgrep -af biggpens.py | grep -v timeout || echo done

cd /app && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, snap, VEL, CHORD
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv')
for name,df in [('train',tr),('val',va)]:
    ch=snap(df['chord_length'].values,CHORD)
    print(name,'chord distribution:',{round(c,4):int((ch==c).sum()) for c in CHORD})
# training conditions at smallest chord
trc=snap(tr['chord_length'].values,CHORD); m=trc==0.0254
sub=tr[m]
k=cond_key(sub)
print()
print('train conditions at chord 0.0254:', len(np.unique(k)))
vel=snap(sub['free_stream_velocity'].values,VEL)
import collections
print('  by velocity:', dict(collections.Counter(np.round(vel,1))))
print('  angle range:', round(sub['attack_angle'].min(),1), round(sub['attack_angle'].max(),1))
print('  angles present:', sorted(set(np.round(sub['attack_angle'].values,0))))
"

cd /app && cat > /tmp/multisplit.py << 'EOF'
import sys, warnings, time, os; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
FEATURES=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df); uniq=np.unique(keys)
def build(X,feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats].values
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
      'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],
      'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
Xm={n:build(df[FEATURES],fs) for n,fs in sets.items()}
def mkgp(d): return make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
def run_seed(seed):
    rng=np.random.RandomState(seed); test_conds=set(rng.choice(uniq,15,replace=False))
    te=np.array([k in test_conds for k in keys]); tri=~te
    preds={}
    for n in sets:
        X=Xm[n]; m=mkgp(X.shape[1]); m.fit(X[tri],y[tri]); preds[n]=m.predict(X[te])
    gpens=(preds['E']+preds['S']+preds['M'])/3
    et=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0).fit(Xm['E'][tri],y[tri]).predict(Xm['E'][te])
    sc=StandardScaler().fit(Xm['E'][tri]); kn=KNeighborsRegressor(8,weights='distance').fit(sc.transform(Xm['E'][tri]),y[tri]).predict(sc.transform(Xm['E'][te]))
    blend=0.75*gpens+0.15*et+0.10*kn
    yt=y[te]; ek=keys[te]
    def metrics(p):
        err=p-yt; cr=np.array([np.sqrt(np.mean(err[ek==k]**2)) for k in np.unique(ek)])
        return np.sqrt(np.mean(err**2)),np.mean(np.abs(err)),np.percentile(cr,90),np.percentile(cr,95),cr.max()
    return metrics(gpens),metrics(blend)
seeds=[int(s) for s in sys.argv[1:]]
for s in seeds:
    t=time.time(); mg,mb=run_seed(s)
    line=f"seed{s} GPens rmse={mg[0]:.3f} mae={mg[1]:.3f} p90={mg[2]:.3f} p95={mg[3]:.3f} max={mg[4]:.3f} | BLEND rmse={mb[0]:.3f} mae={mb[1]:.3f} p90={mb[2]:.3f} p95={mb[3]:.3f} max={mb[4]:.3f} ({time.time()-t:.0f}s)"
    print(line,flush=True); open('/tmp/multisplit_results.txt','a').write(line+'\n')
EOF
nohup timeout 290 python3 /tmp/multisplit.py 1 2 3 4 > /tmp/ms1.log 2>&1 &
echo started; sleep 200; cat /tmp/ms1.log

sleep 30; cat /tmp/ms1.log; echo "=== launching more seeds ==="; cd /app && nohup timeout 295 python3 /tmp/multisplit.py 5 6 7 8 9 10 > /tmp/ms2.log 2>&1 & echo started

sleep 30; cat /tmp/ms1.log | tail -2; echo "---seed3,4 from ms1 should be above; ms2:---"; sleep 0; cat /tmp/ms2.log

sleep 90; echo "=== cumulative results ==="; cat /tmp/multisplit_results.txt 2>/dev/null; echo "=== ms2 ==="; cat /tmp/ms2.log

cd /app && cat > /tmp/cache_seeds.py << 'EOF'
import sys, warnings, time, os; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor, HistGradientBoostingRegressor
from sklearn.neighbors import KNeighborsRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
FEATURES=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df); uniq=np.unique(keys)
def build(X,feats):
    f=X['frequency'].astype(float).values; a=X['attack_angle'].astype(float).values
    c=X['chord_length'].astype(float).values; U=X['free_stream_velocity'].astype(float).values
    dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats].values
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
      'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],
      'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
Xm={n:build(df[FEATURES],fs) for n,fs in sets.items()}
def mkgp(d): return make_pipeline(StandardScaler(), GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
for s in [int(x) for x in sys.argv[1:]]:
    fn=f'/tmp/seedcache_{s}.npz'
    if os.path.exists(fn): continue
    t=time.time(); rng=np.random.RandomState(s); tc=set(rng.choice(uniq,15,replace=False))
    te=np.array([k in tc for k in keys]); tri=~te
    comp={}
    for n in sets:
        X=Xm[n]; m=mkgp(X.shape[1]); m.fit(X[tri],y[tri]); comp[n]=m.predict(X[te])
    comp['ET']=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0).fit(Xm['E'][tri],y[tri]).predict(Xm['E'][te])
    comp['HGB']=HistGradientBoostingRegressor(max_iter=600,learning_rate=0.05,random_state=0).fit(Xm['E'][tri],y[tri]).predict(Xm['E'][te])
    sc=StandardScaler().fit(Xm['E'][tri]); comp['KNN']=KNeighborsRegressor(8,weights='distance').fit(sc.transform(Xm['E'][tri]),y[tri]).predict(sc.transform(Xm['E'][te]))
    np.savez(fn, yt=y[te], ek=keys[te], **comp)
    print(f'seed{s} cached ({time.time()-t:.0f}s)',flush=True)
EOF
nohup timeout 295 python3 /tmp/cache_seeds.py 1 2 3 5 6 7 8 9 10 11 12 13 14 15 > /tmp/cache.log 2>&1 &
echo started; sleep 230; cat /tmp/cache.log

sleep 60; cat /tmp/cache.log; ls /tmp/seedcache_*.npz 2>/dev/null | wc -l

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

Strategy
--------
The hidden evaluation holds out *complete aerodynamic condition groups*
``(attack_angle, chord_length, free_stream_velocity)``, so the model must
generalize across unseen physical regimes rather than interpolate between
nearby rows. Scoring rewards low global error *and* controlled per-condition
failures (p90/p95/max condition RMSE).

The workhorse is an ensemble of ARD-Matern Gaussian Processes built on
physics-informed coordinates (log-frequency, Strouhal number, Reynolds
numbers, ...). GPs extrapolate the smooth self-noise physics across held-out
conditions far better than trees. We average several GPs over different
feature parameterizations (diversity cancels per-condition errors) and blend
in an ExtraTrees model (sharp local frequency structure) plus a small
k-NN term (local spectral shape). All components are trained only on the
provided labeled public data.
"""

from __future__ import annotations

import warnings
from pathlib import Path

import numpy as np
import pandas as pd

warnings.filterwarnings("ignore")

from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C
from sklearn.gaussian_process.kernels import Matern, WhiteKernel
from sklearn.neighbors import KNeighborsRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

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",
]
NU_AIR = 1.5e-5  # kinematic viscosity of air (m^2/s)

# Diverse physics-informed coordinate systems for the GP ensemble.
FEATURE_SETS = {
    "E": ["log_f", "angle", "log_c", "U", "log_d", "strouhal", "str2", "Re_c", "dc"],
    "S": ["strouhal", "str2", "angle", "log_c", "logU", "Re_d", "dc"],
    "M": ["log_f", "angle", "log_c", "mach", "log_d", "strouhal", "Re_c"],
}

# Blend weights (tuned via grouped holdouts that mimic the hidden split).
W_GP_ENSEMBLE = 0.75
W_EXTRATREES = 0.15
W_KNN = 0.10


def build_features(frame: pd.DataFrame, names) -> np.ndarray:
    """Construct physics-informed coordinates, guarding against bad inputs."""
    f = np.asarray(frame["frequency"], dtype=float)
    a = np.asarray(frame["attack_angle"], dtype=float)
    c = np.asarray(frame["chord_length"], dtype=float)
    U = np.asarray(frame["free_stream_velocity"], dtype=float)
    d = np.asarray(frame["suction_side_displacement_thickness"], dtype=float)

    # Physical quantities are strictly positive; clip to keep logs finite even
    # if the hidden feature rows contain degenerate values.
    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)

    cols = {
        "log_f": np.log10(f),
        "angle": a,
        "log_c": np.log10(c),
        "U": U,
        "log_d": np.log10(d),
        "logU": np.log10(U),
        "strouhal": np.log10(f * d / U),
        "str2": np.log10(f * d / U) ** 2,
        "Re_c": np.log10(U * c / NU_AIR),
        "Re_d": np.log10(U * d / NU_AIR),
        "dc": np.log10(d / c),
        "mach": U / 340.0,
    }
    return np.column_stack([cols[n] for n in names])


def make_gp(n_dims: int) -> GaussianProcessRegressor:
    kernel = (
        C(1.0, (1e-3, 1e3))
        * Matern(length_scale=np.ones(n_dims), length_scale_bounds=(1e-2, 1e5), nu=1.5)
        + WhiteKernel(0.1, (1e-3, 10.0))
    )
    return make_pipeline(
        StandardScaler(),
        GaussianProcessRegressor(
            kernel=kernel,
            normalize_y=True,
            n_restarts_optimizer=0,
            alpha=1e-8,
            random_state=0,
       
…[truncated]

cat /tmp/cache.log; echo "cached seeds:"; ls /tmp/seedcache_*.npz 2>/dev/null | wc -l; echo "=== run final script ==="; cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py 2>&1 | tail -5; echo "=== output ==="; head -5 output/predictions.csv; wc -l output/predictions.csv

pgrep -af cache_seeds | grep -v timeout || echo "no cache running"; cd /app && nohup timeout 295 python3 /tmp/cache_seeds.py 3 5 6 7 8 9 10 11 12 > /tmp/cache2.log 2>&1 & echo relaunched

cd /app && cat > /tmp/analyze.py << 'EOF'
import numpy as np, glob, sys
files=sorted(glob.glob('/tmp/seedcache_*.npz'))
seeds=[np.load(f) for f in files]
print(f'{len(seeds)} seeds:', [f.split("_")[1][:-4] for f in files])
def cond_rmse(p, yt, ek):
    err=p-yt; return np.array([np.sqrt(np.mean(err[ek==k]**2)) for k in np.unique(ek)])
def eval_blend(wgp, wet, wknn):
    agg=[]
    for s in seeds:
        gpe=(s['E']+s['S']+s['M'])/3
        p=wgp*gpe+wet*s['ET']+wknn*s['KNN']
        yt,ek=s['yt'],s['ek']; cr=cond_rmse(p,yt,ek); err=p-yt
        agg.append((np.sqrt(np.mean(err**2)),np.mean(np.abs(err)),np.percentile(cr,90),np.percentile(cr,95),cr.max()))
    agg=np.array(agg)
    return agg
combos=[(1,0,0),(0.85,0.15,0),(0.8,0.2,0),(0.75,0.15,0.10),(0.7,0.2,0.10),(0.75,0.25,0),(0.65,0.25,0.10),(0.6,0.3,0.10),(0.7,0.3,0)]
print(f"{'wgp/wet/wknn':16s} {'rmse':>6}{'mae':>6}{'p90':>6}{'p95':>6}{'max':>6} | {'p90max':>7}{'p90>2.35':>9}")
for w in combos:
    agg=eval_blend(*w)
    m=agg.mean(0)
    p90s=agg[:,2]
    print(f"{str(w):16s} {m[0]:6.3f}{m[1]:6.3f}{m[2]:6.3f}{m[3]:6.3f}{m[4]:6.3f} | {p90s.max():7.3f}{int((p90s>2.35).sum()):6d}/{len(seeds)}")
EOF
sleep 120; python3 /tmp/analyze.py

cat /tmp/cache2.log; echo "cached:"; ls /tmp/seedcache_*.npz 2>/dev/null | wc -l; pgrep -af cache_seeds | grep -v timeout >/dev/null && echo "cache running" || echo "cache idle"

sleep 220; cat /tmp/cache2.log; echo "cached:"; ls /tmp/seedcache_*.npz 2>/dev/null | wc -l

pkill -f cache_seeds 2>/dev/null; sleep 2; cd /app && sed '/comp\[.HGB.\]/d' /tmp/cache_seeds.py > /tmp/cache_lean.py && nohup timeout 295 python3 /tmp/cache_lean.py 6 7 8 9 10 11 12 13 > /tmp/cache3.log 2>&1 & echo "relaunched lean cacher"; sleep 3; pgrep -af cache_lean | grep -v timeout || echo none

cd /app && cat > /tmp/analyze2.py << 'EOF'
import numpy as np, glob
files=sorted(glob.glob('/tmp/seedcache_*.npz'), key=lambda f:int(f.split('_')[1][:-4]))
seeds=[np.load(f) for f in files]
print(f'{len(seeds)} seeds:', [f.split("_")[1][:-4] for f in files])
def cr(p,yt,ek):
    e=p-yt; return np.array([np.sqrt(np.mean(e[ek==k]**2)) for k in np.unique(ek)])
def ev(wgp,wet,wknn):
    a=[]
    for s in seeds:
        gpe=(s['E']+s['S']+s['M'])/3; p=wgp*gpe+wet*s['ET']+wknn*s['KNN']
        yt,ek=s['yt'],s['ek']; c=cr(p,yt,ek); e=p-yt
        a.append((np.sqrt(np.mean(e**2)),np.mean(np.abs(e)),np.percentile(c,90),np.percentile(c,95),c.max()))
    return np.array(a)
combos=[(1,0,0),(0.8,0.2,0),(0.7,0.3,0),(0.6,0.4,0),(0.5,0.5,0),(0.65,0.25,0.1),(0.6,0.3,0.1),(0.55,0.35,0.1),(0.5,0.4,0.1)]
print(f"{'w(gp,et,knn)':18s}{'rmse':>6}{'mae':>6}{'p90':>6}{'p95':>6}{'max':>6} | worst: {'rmse':>5}{'mae':>5}{'p90':>5}{'p95':>5}{'max':>5}")
for w in combos:
    a=ev(*w); m=a.mean(0); mx=a.max(0)
    print(f"{str(w):18s}{m[0]:6.3f}{m[1]:6.3f}{m[2]:6.3f}{m[3]:6.3f}{m[4]:6.3f} |        {mx[0]:5.2f}{mx[1]:5.2f}{mx[2]:5.2f}{mx[3]:5.2f}{mx[4]:5.2f}")
EOF
python3 /tmp/analyze2.py

cd /app && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
E=np.load('/tmp/val_GP_E.npy'); S=np.load('/tmp/val_GP_S.npy'); M=np.load('/tmp/val_GP_M.npy')
ET=np.load('/tmp/val_ET.npy'); KNN=np.load('/tmp/val_KNN8.npy')
gpe=(E+S+M)/3
def rep(w):
    p=w[0]*gpe+w[1]*ET+w[2]*KNN; e=p-yv
    cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
    print(f'{str(w):18s} rmse={np.sqrt(np.mean(e**2)):.3f} mae={np.mean(np.abs(e)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f} under={int((cr<=2.35).sum())}/15')
for w in [(1,0,0),(0.8,0.2,0),(0.7,0.3,0),(0.6,0.4,0),(0.5,0.5,0),(0.65,0.25,0.1),(0.6,0.3,0.1),(0.55,0.35,0.1),(0.5,0.4,0.1)]:
    rep(w)
"

cd /app && echo "=== VAL split ===" && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
gpe=(np.load('/tmp/val_GP_E.npy')+np.load('/tmp/val_GP_S.npy')+np.load('/tmp/val_GP_M.npy'))/3
ET=np.load('/tmp/val_ET.npy'); HGB=np.load('/tmp/val_HGB.npy')
def rep(name,p):
    e=p-yv; cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
    print(f'{name:22s} rmse={np.sqrt(np.mean(e**2)):.3f} mae={np.mean(np.abs(e)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f}')
rep('0.7GP+0.3ET', 0.7*gpe+0.3*ET)
rep('0.7GP+0.3(.6ET+.4HGB)', 0.7*gpe+0.3*(0.6*ET+0.4*HGB))
rep('0.7GP+0.15ET+0.15HGB', 0.7*gpe+0.15*ET+0.15*HGB)
"
echo "=== multi-seed (1,2,3 have HGB) ===" && python3 -c "
import numpy as np, glob
seeds=[np.load(f) for f in ['/tmp/seedcache_1.npz','/tmp/seedcache_2.npz','/tmp/seedcache_3.npz']]
def cr(p,yt,ek):
    e=p-yt; return np.array([np.sqrt(np.mean(e[ek==k]**2)) for k in np.unique(ek)])
def ev(fn):
    a=[]
    for s in seeds:
        gpe=(s['E']+s['S']+s['M'])/3; p=fn(s,gpe); yt,ek=s['yt'],s['ek']; c=cr(p,yt,ek); e=p-yt
        a.append((np.sqrt(np.mean(e**2)),np.percentile(c,90),np.percentile(c,95),c.max()))
    return np.array(a).mean(0), np.array(a).max(0)
for name,fn in [('0.7GP+0.3ET',lambda s,g:0.7*g+0.3*s['ET']),
                ('0.7GP+0.3(.6ET+.4HGB)',lambda s,g:0.7*g+0.3*(0.6*s['ET']+0.4*s['HGB']))]:
    m,mx=ev(fn); print(f'{name:24s} mean rmse={m[0]:.3f} p90={m[1]:.3f} p95={m[2]:.3f} max={m[3]:.3f} | worst p90={mx[1]:.3f} max={mx[3]:.3f}')
"

command: str_replace
path: /app/train_and_predict.py
old_str: # Blend weights (tuned via grouped holdouts that mimic the hidden split).
W_GP_ENSEMBLE = 0.75
W_EXTRATREES = 0.15
W_KNN = 0.10
new_str: # Blend weights (tuned on the provided grouped validation split *and* many
# random grouped holdouts that mimic the hidden condition-level split). The
# GP ensemble carries the smooth cross-condition physics; ExtraTrees sharpens
# local frequency structure and curbs worst-case per-condition errors.
W_GP_ENSEMBLE = 0.70
W_EXTRATREES = 0.30

command: str_replace
path: /app/train_and_predict.py
old_str:     # ---- k-NN in standardized physics space (local spectral structure) ----
    try:
        scaler = StandardScaler().fit(X_et_train)
        knn = KNeighborsRegressor(n_neighbors=8, weights="distance")
        knn.fit(scaler.transform(X_et_train), y)
        knn_pred = knn.predict(scaler.transform(X_et_eval))
        if not np.all(np.isfinite(knn_pred)):
            knn_pred = et_pred
    except Exception:
        knn_pred = et_pred

    # ---- Weighted blend ----
    if gp_preds:
        gp_ensemble = np.mean(gp_preds, axis=0)
        predictions = (
            W_GP_ENSEMBLE * gp_ensemble + W_EXTRATREES * et_pred + W_KNN * knn_pred
        )
    else:
        # GP unavailable: fall back to a robust tree/knn blend.
        predictions = 0.8 * et_pred + 0.2 * knn_pred
new_str:     # ---- Weighted blend ----
    if gp_preds:
        gp_ensemble = np.mean(gp_preds, axis=0)
        predictions = W_GP_ENSEMBLE * gp_ensemble + W_EXTRATREES * et_pred
    else:
        # GP unavailable for every parameterization: fall back to ExtraTrees.
        predictions = et_pred

command: str_replace
path: /app/train_and_predict.py
old_str: from sklearn.gaussian_process.kernels import Matern, WhiteKernel
from sklearn.neighbors import KNeighborsRegressor
from sklearn.pipeline import make_pipeline
new_str: from sklearn.gaussian_process.kernels import Matern, WhiteKernel
from sklearn.pipeline import make_pipeline

cat /tmp/cache3.log 2>/dev/null; echo "total cached:"; ls /tmp/seedcache_*.npz 2>/dev/null | wc -l; echo "pausing cache for clean timing"; pkill -f cache_lean 2>/dev/null; sleep 2; cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py 2>&1 | tail -3; echo "exit=$?"; echo "=== validate output ==="; python3 -c "
import pandas as pd, numpy as np
tf=pd.read_csv('/app/data/test_features.csv'); out=pd.read_csv('/app/output/predictions.csv')
print('cols:', list(out.columns))
print('n_out:', len(out), 'n_test:', len(tf))
print('ids match set:', set(out['sample_id'])==set(tf['sample_id'].astype(str)))
print('ids match order:', list(out['sample_id'])==list(tf['sample_id'].astype(str)))
print('all finite:', np.isfinite(out['predicted_scaled_sound_pressure_level']).all())
print('unique preds:', out['predicted_scaled_sound_pressure_level'].nunique())
print('range:', out['predicted_scaled_sound_pressure_level'].min(), out['predicted_scaled_sound_pressure_level'].max())
"

cd /app && echo "=== VAL ===" && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
E=np.load('/tmp/val_GP_E.npy');S=np.load('/tmp/val_GP_S.npy');M=np.load('/tmp/val_GP_M.npy')
ET=np.load('/tmp/val_ET.npy');HGB=np.load('/tmp/val_HGB.npy');KNN=np.load('/tmp/val_KNN8.npy')
gpe=(E+S+M)/3
def rep(name,p):
    e=p-yv; cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
    print(f'{name:28s} rmse={np.sqrt(np.mean(e**2)):.3f} mae={np.mean(np.abs(e)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f}')
rep('0.7gpe+0.3ET (current)', 0.7*gpe+0.3*ET)
rep('median(E,S,M,ET)', np.median(np.vstack([E,S,M,ET]),0))
rep('median(gpe,ET,HGB)', np.median(np.vstack([gpe,ET,HGB]),0))
rep('median(E,S,M,ET,HGB)', np.median(np.vstack([E,S,M,ET,HGB]),0))
rep('0.5*mean(gpe,ET)+0.5*med', 0.5*(0.7*gpe+0.3*ET)+0.5*np.median(np.vstack([E,S,M,ET]),0))
"
echo "=== multi-seed(1,2,3) ===" && python3 -c "
import numpy as np
seeds=[np.load(f) for f in ['/tmp/seedcache_1.npz','/tmp/seedcache_2.npz','/tmp/seedcache_3.npz','/tmp/seedcache_5.npz']]
def cr(p,yt,ek):
    e=p-yt; return np.array([np.sqrt(np.mean(e[ek==k]**2)) for k in np.unique(ek)])
def ev(fn):
    a=[]
    for s in seeds:
        gpe=(s['E']+s['S']+s['M'])/3; p=fn(s,gpe); yt,ek=s['yt'],s['ek']; c=cr(p,yt,ek); e=p-yt
        a.append((np.sqrt(np.mean(e**2)),np.percentile(c,90),np.percentile(c,95),c.max()))
    import numpy as np2; A=np2.array(a); return A.mean(0),A.max(0)
for name,fn in [('0.7gpe+0.3ET',lambda s,g:0.7*g+0.3*s['ET']),
                ('median(E,S,M,ET)',lambda s,g:np.median(np.vstack([s['E'],s['S'],s['M'],s['ET']]),0))]:
    m,mx=ev(fn); print(f'{name:22s} mean rmse={m[0]:.3f} p90={m[1]:.3f} p95={m[2]:.3f} max={m[3]:.3f} | worst p90={mx[1]:.3f} max={mx[3]:.3f}')
"

cd /app && cat > /tmp/noise.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import evaluate, FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
NU=1.5e-5
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
def build(X,feats):
    f=X['frequency'].astype(float).values;a=X['attack_angle'].astype(float).values;c=X['chord_length'].astype(float).values
    U=X['free_stream_velocity'].astype(float).values;dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats].values
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],
      'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],
      'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
keys=cond_key(va); ET=np.load('/tmp/val_ET.npy')
def fit(feats,wk_mode):
    Xt=build(tr[FEATURES],feats);Xv=build(va[FEATURES],feats);d=len(feats)
    if wk_mode=='opt': wk=WhiteKernel(0.1,(1e-3,10))
    else: wk=WhiteKernel(wk_mode,'fixed')
    m=make_pipeline(StandardScaler(),GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+wk,normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
    m.fit(Xt,y); 
    gp=m.named_steps['gaussianprocessregressor']
    return m.predict(Xv), gp.kernel_
def rep(name,p):
    e=p-yv; cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
    print(f'{name:18s} rmse={np.sqrt(np.mean(e**2)):.3f} mae={np.mean(np.abs(e)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f}',flush=True)
for mode in ['opt',0.3,0.6,1.0]:
    ps=[]; 
    for n,fs in sets.items():
        p,k=fit(fs,mode); ps.append(p)
    gpe=np.mean(ps,0)
    rep(f'GPe noise={mode}', gpe); rep(f'  blend 0.7/0.3', 0.7*gpe+0.3*ET)
EOF
nohup timeout 295 python3 /tmp/noise.py > /tmp/noise.log 2>&1 & echo started; sleep 220; cat /tmp/noise.log

cd /app && nohup timeout 295 python3 /tmp/cache_lean.py 6 7 8 9 10 11 12 > /tmp/cache4.log 2>&1 & echo "caching relaunched"; echo "=== final script review ==="; cat -n train_and_predict.py | sed -n '1,60p'

command: str_replace
path: /app/train_and_predict.py
old_str: The workhorse is an ensemble of ARD-Matern Gaussian Processes built on
physics-informed coordinates (log-frequency, Strouhal number, Reynolds
numbers, ...). GPs extrapolate the smooth self-noise physics across held-out
conditions far better than trees. We average several GPs over different
feature parameterizations (diversity cancels per-condition errors) and blend
in an ExtraTrees model (sharp local frequency structure) plus a small
k-NN term (local spectral shape). All components are trained only on the
provided labeled public data.
"""
new_str: The workhorse is an ensemble of ARD-Matern Gaussian Processes built on
physics-informed coordinates (log-frequency, Strouhal number, Reynolds
numbers, ...). GPs extrapolate the smooth self-noise physics across held-out
conditions far better than trees. We average several GPs over different
feature parameterizations (diversity cancels per-condition errors) and blend
in an ExtraTrees model that sharpens local frequency structure and curbs the
worst per-condition failures. All components are trained only on the provided
labeled public data; no external labels or data are used.
"""

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

cd /app && cat > /tmp/holdsize.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
FEATURES=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df); uniq=np.unique(keys)
def build(X,feats):
    f=X['frequency'].astype(float).values;a=X['attack_angle'].astype(float).values;c=X['chord_length'].astype(float).values
    U=X['free_stream_velocity'].astype(float).values;dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats].values
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
Xm={n:build(df[FEATURES],fs) for n,fs in sets.items()}
def mkgp(d): return make_pipeline(StandardScaler(),GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
def one(seed,nhold):
    rng=np.random.RandomState(seed); tc=set(rng.choice(uniq,nhold,replace=False))
    te=np.array([k in tc for k in keys]); tri=~te
    ps=[mkgp(Xm[n].shape[1]).fit(Xm[n][tri],y[tri]).predict(Xm[n][te]) for n in sets]
    gpe=np.mean(ps,0); et=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0).fit(Xm['E'][tri],y[tri]).predict(Xm['E'][te])
    p=0.7*gpe+0.3*et; yt=y[te]; ek=keys[te]; e=p-yt
    cr=np.array([np.sqrt(np.mean(e[ek==k]**2)) for k in np.unique(ek)])
    return np.sqrt(np.mean(e**2)),np.mean(np.abs(e)),np.percentile(cr,90),np.percentile(cr,95),cr.max()
for nhold in [15,10,6]:
    rs=[one(s,nhold) for s in [1,2,3]]; a=np.array(rs)
    m=a.mean(0); print(f'hold={nhold:2d} (train {82-nhold} conds): rmse={m[0]:.3f} mae={m[1]:.3f} p90={m[2]:.3f} p95={m[3]:.3f} max={m[4]:.3f}  per-seed p90={np.round(a[:,2],2)}',flush=True)
EOF
nohup timeout 295 python3 /tmp/holdsize.py > /tmp/holdsize.log 2>&1 & echo started; sleep 280; cat /tmp/holdsize.log

pkill -f cache_lean 2>/dev/null; sleep 1; echo "cached seeds:"; ls /tmp/seedcache_*.npz 2>/dev/null | wc -l; cat /tmp/cache4.log 2>/dev/null; echo "=== holdsize (waiting) ==="; sleep 60; cat /tmp/holdsize.log; pgrep -af holdsize | grep -v timeout || echo "holdsize done"

cd /app && sed -i 's/for nhold in \[15,10,6\]:/for nhold in [6,10]:/' /tmp/holdsize.py && nohup timeout 295 python3 /tmp/holdsize.py > /tmp/holdsize2.log 2>&1 & echo started; sleep 250; cat /tmp/holdsize2.log; pgrep -af holdsize | grep -v timeout || echo done

sleep 45; cat /tmp/holdsize2.log; pgrep -af holdsize | grep -v timeout || echo done

cd /app && cat > /tmp/hs3.py << 'EOF'
import sys, warnings, time; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import ExtraTreesRegressor
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import ConstantKernel as C, WhiteKernel, Matern
FEATURES=["frequency","attack_angle","chord_length","free_stream_velocity","suction_side_displacement_thickness"]
NU=1.5e-5
df=pd.concat([pd.read_csv('/app/data/train.csv'),pd.read_csv('/app/data/validation.csv')],ignore_index=True)
y=df[TARGET].values; keys=cond_key(df); uniq=np.unique(keys)
def build(X,feats):
    f=X['frequency'].astype(float).values;a=X['attack_angle'].astype(float).values;c=X['chord_length'].astype(float).values
    U=X['free_stream_velocity'].astype(float).values;dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'logU':np.log10(U),
       'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'Re_d':np.log10(U*dd/NU),'dc':np.log10(dd/c),'mach':U/340.0}
    return pd.DataFrame(b,index=X.index)[feats].values
sets={'E':['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc'],'S':['strouhal','str2','angle','log_c','logU','Re_d','dc'],'M':['log_f','angle','log_c','mach','log_d','strouhal','Re_c']}
Xm={n:build(df[FEATURES],fs) for n,fs in sets.items()}
def mkgp(d): return make_pipeline(StandardScaler(),GaussianProcessRegressor(kernel=C(1.0)*Matern(np.ones(d),nu=1.5)+WhiteKernel(0.1,(1e-3,10)),normalize_y=True,n_restarts_optimizer=0,random_state=0,alpha=1e-8))
NHOLD=6
for s in [1,2,3,4]:
    rng=np.random.RandomState(s); tc=set(rng.choice(uniq,NHOLD,replace=False))
    te=np.array([k in tc for k in keys]); tri=~te
    ps=[mkgp(Xm[n].shape[1]).fit(Xm[n][tri],y[tri]).predict(Xm[n][te]) for n in sets]
    gpe=np.mean(ps,0); et=ExtraTreesRegressor(n_estimators=600,n_jobs=-1,random_state=0).fit(Xm['E'][tri],y[tri]).predict(Xm['E'][te])
    p=0.7*gpe+0.3*et; yt=y[te]; ek=keys[te]; e=p-yt
    cr=np.array([np.sqrt(np.mean(e[ek==k]**2)) for k in np.unique(ek)])
    print(f'hold6 seed{s}: rmse={np.sqrt(np.mean(e**2)):.3f} mae={np.mean(np.abs(e)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f} nconds={len(cr)}',flush=True)
EOF
nohup timeout 295 python3 /tmp/hs3.py > /tmp/hs3.log 2>&1 & echo started; sleep 200; cat /tmp/hs3.log

sleep 30; echo "=== hs3 ==="; cat /tmp/hs3.log; echo "=== ET tuning on val ==="; cd /app && timeout 120 python3 -c "
import sys, warnings; sys.path.insert(0,'/tmp'); warnings.filterwarnings('ignore')
from harness import FEATURES, TARGET, cond_key
import numpy as np, pandas as pd
from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor
tr=pd.read_csv('/app/data/train.csv'); va=pd.read_csv('/app/data/validation.csv'); y=tr[TARGET].values; yv=va[TARGET].values
NU=1.5e-5
def build(X,feats):
    f=X['frequency'].astype(float).values;a=X['attack_angle'].astype(float).values;c=X['chord_length'].astype(float).values
    U=X['free_stream_velocity'].astype(float).values;dd=X['suction_side_displacement_thickness'].astype(float).values
    b={'log_f':np.log10(f),'angle':a,'log_c':np.log10(c),'U':U,'log_d':np.log10(dd),'strouhal':np.log10(f*dd/U),'str2':np.log10(f*dd/U)**2,'Re_c':np.log10(U*c/NU),'dc':np.log10(dd/c)}
    return pd.DataFrame(b,index=X.index)[feats].values
E=['log_f','angle','log_c','U','log_d','strouhal','str2','Re_c','dc']
Xt=build(tr[FEATURES],E); Xv=build(va[FEATURES],E); keys=cond_key(va)
gpe=(np.load('/tmp/val_GP_E.npy')+np.load('/tmp/val_GP_S.npy')+np.load('/tmp/val_GP_M.npy'))/3
def rep(name,p):
    e=p-yv; cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
    print(f'{name:30s} rmse={np.sqrt(np.mean(e**2)):.3f} p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f}')
for cfg in [dict(n_estimators=800),dict(n_estimators=800,min_samples_leaf=2),dict(n_estimators=800,min_samples_leaf=3),dict(n_estimators=800,max_features=0.7)]:
    et=ExtraTreesRegressor(n_jobs=-1,random_state=0,**cfg).fit(Xt,y).predict(Xv)
    rep(f'blend ET{cfg}', 0.7*gpe+0.3*et)
rf=RandomForestRegressor(n_estimators=800,n_jobs=-1,random_state=0).fit(Xt,y).predict(Xv)
rep('blend RF', 0.7*gpe+0.3*rf)
"

cd /app && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
gpe=(np.load('/tmp/val_GP_E.npy')+np.load('/tmp/val_GP_S.npy')+np.load('/tmp/val_GP_M.npy'))/3
ET=np.load('/tmp/val_ET.npy')
p=0.7*gpe+0.3*ET; e=p-yv; ae=np.abs(e)
print('=== Interpretation 2: per-row |error| (if hidden tuples are unique per row) ===')
print(f'  RMSE={np.sqrt(np.mean(e**2)):.3f} MAE={np.mean(ae):.3f} |err| p90={np.percentile(ae,90):.3f} p95={np.percentile(ae,95):.3f} max={ae.max():.3f}')
print('=== Interpretation 1: grouped by snapped condition (~15 groups) ===')
cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
print(f'  cond p90={np.percentile(cr,90):.3f} p95={np.percentile(cr,95):.3f} max={cr.max():.3f}')
"

cd /app && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
E=np.load('/tmp/val_GP_E.npy');S=np.load('/tmp/val_GP_S.npy');M=np.load('/tmp/val_GP_M.npy')
gpe=(E+S+M)/3; ET=np.load('/tmp/val_ET.npy'); KNN=np.load('/tmp/val_KNN8.npy')
def ae_stats(name,p):
    e=p-yv; ae=np.abs(e)
    print(f'{name:26s} |err| p90={np.percentile(ae,90):.3f} p95={np.percentile(ae,95):.3f} max={ae.max():.3f}  (rows|err|>5: {(ae>5).sum()}, >4.75:{(ae>4.75).sum()})')
ae_stats('GPe', gpe)
ae_stats('0.7GPe+0.3ET', 0.7*gpe+0.3*ET)
ae_stats('0.7GPe+0.2ET+0.1KNN', 0.7*gpe+0.2*ET+0.1*KNN)
ae_stats('0.65GPe+0.25ET+0.1KNN', 0.65*gpe+0.25*ET+0.1*KNN)
# worst rows for the main blend
p=0.7*gpe+0.3*ET; e=p-yv
idx=np.argsort(np.abs(e))[::-1][:6]
sub=va.iloc[idx].copy(); sub['pred']=p[idx]; sub['err']=e[idx]
print(sub[['frequency','attack_angle','chord_length','free_stream_velocity','scaled_sound_pressure_level','pred','err']].to_string(index=False))
"

pkill -f cache_lean 2>/dev/null; pkill -f hs3 2>/dev/null; pkill -f holdsize 2>/dev/null; sleep 2; echo "stray procs:"; pgrep -af 'python3 /tmp' | grep -v timeout || echo "none"; cd /app && rm -f output/predictions.csv && echo "=== clean run ===" && time python3 train_and_predict.py && echo "=== validation ===" && python3 -c "
import pandas as pd, numpy as np
tf=pd.read_csv('/app/data/test_features.csv'); out=pd.read_csv('/app/output/predictions.csv')
assert list(out.columns)==['sample_id','predicted_scaled_sound_pressure_level'], out.columns
assert len(out)==len(tf)==40
assert list(out['sample_id'])==list(tf['sample_id'].astype(str)), 'id mismatch'
v=out['predicted_scaled_sound_pressure_level'].values
assert np.isfinite(v).all()
assert out['sample_id'].is_unique
print('OK: columns, alignment, uniqueness, finiteness all pass')
print('pred range [%.2f, %.2f], nunique=%d'%(v.min(),v.max(),out['predicted_scaled_sound_pressure_level'].nunique()))
"

cd /app && cp data/test_features.csv /tmp/tf_backup.csv && md5sum data/test_features.csv > /tmp/tf.md5
# Build a synthetic hidden-like test set: all 201 validation feature rows, new sample_ids, no target col
python3 -c "
import pandas as pd
va=pd.read_csv('data/validation.csv').drop(columns=['scaled_sound_pressure_level'])
va['sample_id']=['af_test_%04d'%i for i in range(len(va))]
va.to_csv('data/test_features.csv', index=False)
print('synthetic hidden rows:', len(va))
"
rm -f output/predictions.csv && python3 train_and_predict.py && python3 -c "
import pandas as pd, numpy as np
tf=pd.read_csv('data/test_features.csv'); out=pd.read_csv('output/predictions.csv')
assert list(out.columns)==['sample_id','predicted_scaled_sound_pressure_level']
assert len(out)==len(tf)
assert list(out['sample_id'])==list(tf['sample_id'].astype(str))
assert np.isfinite(out['predicted_scaled_sound_pressure_level']).all()
print('SYNTHETIC HIDDEN RUN OK: %d rows, aligned, finite, nunique=%d'%(len(out), out['predicted_scaled_sound_pressure_level'].nunique()))
"
# restore original input exactly
cp /tmp/tf_backup.csv data/test_features.csv && md5sum -c /tmp/tf.md5 && echo "INPUT RESTORED (checksum verified)"

cd /app && rm -f output/predictions.csv && python3 train_and_predict.py && echo "=== final predictions (original placeholder input) ===" && head -4 output/predictions.csv && wc -l output/predictions.csv && md5sum -c /tmp/tf.md5 && echo "input still original"

cd /app && python3 -c "
import numpy as np, glob, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
# multi-seed holdouts
files=sorted(glob.glob('/tmp/seedcache_*.npz'), key=lambda f:int(f.split('_')[1][:-4]))
seeds=[np.load(f) for f in files]
sd=[f.split('_')[1][:-4] for f in files]
# val split
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; vk=cond_key(va)
vE=np.load('/tmp/val_GP_E.npy');vS=np.load('/tmp/val_GP_S.npy');vM=np.load('/tmp/val_GP_M.npy');vET=np.load('/tmp/val_ET.npy')
def cr(p,yt,ek):
    e=p-yt; return np.array([np.sqrt(np.mean(e[ek==k]**2)) for k in np.unique(ek)])
print(f'multi-seed holdouts: {sd}')
print(f\"{'w_et':>5} {'val_p90':>8} {'ms_mean_p90':>12} {'ms_worst_p90':>13} {'ms_mean_max':>12}\")
for wet in [0.20,0.25,0.30,0.35,0.40]:
    wgp=1-wet
    # val
    vp=wgp*(vE+vS+vM)/3+wet*vET; vcr=cr(vp,yv,vk); vp90=np.percentile(vcr,90)
    # multiseed
    p90s=[]; maxs=[]
    for s in seeds:
        p=wgp*(s['E']+s['S']+s['M'])/3+wet*s['ET']; c=cr(p,s['yt'],s['ek'])
        p90s.append(np.percentile(c,90)); maxs.append(c.max())
    print(f'{wet:5.2f} {vp90:8.3f} {np.mean(p90s):12.3f} {np.max(p90s):13.3f} {np.mean(maxs):12.3f}')
"

command: str_replace
path: /app/train_and_predict.py
old_str: W_GP_ENSEMBLE = 0.70
W_EXTRATREES = 0.30
new_str: W_GP_ENSEMBLE = 0.65
W_EXTRATREES = 0.35

cd /app && rm -f output/predictions.csv && time python3 train_and_predict.py && python3 -c "
import pandas as pd, numpy as np
tf=pd.read_csv('data/test_features.csv'); out=pd.read_csv('output/predictions.csv')
assert list(out.columns)==['sample_id','predicted_scaled_sound_pressure_level']
assert len(out)==len(tf) and list(out['sample_id'])==list(tf['sample_id'].astype(str))
assert np.isfinite(out['predicted_scaled_sound_pressure_level']).all() and out['sample_id'].is_unique
print('FINAL OUTPUT OK:', len(out), 'rows, aligned, finite, unique')
print(out.head(3).to_string(index=False))
" && md5sum -c /tmp/tf.md5

cd /app && python3 -c "
import numpy as np, pandas as pd, sys; sys.path.insert(0,'/tmp')
from harness import cond_key, TARGET
va=pd.read_csv('/app/data/validation.csv'); yv=va[TARGET].values; keys=cond_key(va)
gpe=(np.load('/tmp/val_GP_E.npy')+np.load('/tmp/val_GP_S.npy')+np.load('/tmp/val_GP_M.npy'))/3
ET=np.load('/tmp/val_ET.npy')
p=0.65*gpe+0.35*ET; e=p-yv
cr=np.array([np.sqrt(np.mean(e[keys==k]**2)) for k in np.unique(keys)])
print('FINAL model (0.65 GPens + 0.35 ET) on train->validation grouped holdout:')
print('  targets:   rmse<=2.25  mae<=1.55  p90<=2.35  p95<=4.75  max<=5.60')
print('  achieved:  rmse=%.3f  mae=%.3f  p90=%.3f  p95=%.3f  max=%.3f'%(
    np.sqrt(np.mean(e**2)), np.mean(np.abs(e)), np.percentile(cr,90), np.percentile(cr,95), cr.max()))
print('  conditions with RMSE<=2.35: %d/%d'%(int((cr<=2.35).sum()), len(cr)))
"

cd /app && python3 -m py_compile train_and_predict.py && echo "compiles OK" && echo "=== full script ===" && cat train_and_predict.py

cd /app && echo "=== deliverables ===" && ls -la output/ && echo "" && echo "=== predictions.csv validation ===" && python3 -c "
import pandas as pd, numpy as np
out=pd.read_csv('output/predictions.csv')
tf=pd.read_csv('data/test_features.csv')
print('columns exact:', list(out.columns)==['sample_id','predicted_scaled_sound_pressure_level'])
print('one row per test sample_id:', len(out)==len(tf) and set(out.sample_id.astype(str))==set(tf.sample_id.astype(str)))
print('numeric & finite:', np.isfinite(out.predicted_scaled_sound_pressure_level).all())
print('not constant:', out.predicted_scaled_sound_pressure_level.nunique()>1)
print('value range: [%.2f, %.2f]'%(out.predicted_scaled_sound_pressure_level.min(), out.predicted_scaled_sound_pressure_level.max()))
" && echo "" && echo "=== inputs pristine (train/val/test) ===" && md5sum -c /tmp/tf.md5 && git -C /app status --short 2>/dev/null || echo "(no git)"