Upload train_v38_2_pro_v5.py with huggingface_hub

train_v38_2_pro_v5.py

@@ -0,0 +1,1076 @@
+"""
+====================================================================
+V38.2-PRO-V5 MODEL - Admitted Similarity + PS Grok Scores + v7 Matrix
+====================================================================
+Changes from V38.2-PRO-V4:
+1. Use v7 feature matrix (v6 + admitted similarity + PS red flags)
+2. New: act_bert_admit_sim, ps_bert_admit_sim, act_slot_admit_sim (time-respecting)
+3. New: act_bert_sim_contrast, ps_bert_sim_contrast (admit - reject similarity)
+4. New: Grok 4.2 PS scores (originality, reflection, authenticity, overall)
+5. New: PS red flags (is_templated, has_grammar_issues, etc.)
+6. Added admitted_sim features to KEY_STUDENT_FEATURES for residualization
+7. All V4 fixes carried forward
+====================================================================
+"""
+import pandas as pd
+import numpy as np
+import json, os, warnings, sys, time, pickle, gc
+warnings.filterwarnings('ignore')
+from sklearn.model_selection import GroupKFold
+from sklearn.metrics import roc_auc_score, log_loss, brier_score_loss
+from sklearn.preprocessing import LabelEncoder
+from scipy.stats import rankdata
+
+try:
+    from catboost import CatBoostClassifier, Pool
+    import lightgbm as lgb
+    import xgboost as xgb
+    print("All model libraries loaded successfully")
+except ImportError as e:
+    print(f"Missing library: {e}")
+    import subprocess
+    subprocess.check_call([sys.executable, '-m', 'pip', 'install',
+                          'catboost', 'lightgbm', 'xgboost', '-q'])
+    from catboost import CatBoostClassifier, Pool
+    import lightgbm as lgb
+    import xgboost as xgb
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, 'data')
+OUTPUT_DIR = os.path.join(BASE_DIR, 'output')
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+TARGET = 'target'
+SEEDS = [42, 123, 456, 789, 2024]
+N_FOLDS = 10
+FEATURE_SELECT_TOP_N = 150
+start_time = time.time()
+
+def safe_num(v, default=np.nan):
+    """Convert to float, return NaN for missing (was -1 before)."""
+    if isinstance(v, (int, float)):
+        val = float(v)
+        return np.nan if val == -1 else val
+    if isinstance(v, str):
+        try:
+            val = float(v)
+            return np.nan if val == -1 else val
+        except:
+            return default
+    return default
+
+# ============================================================
+# 1. LOAD DATA (v6 feature matrix)
+# ============================================================
+print("=" * 70)
+print("  V38.2-PRO-V5: ADMITTED SIMILARITY + PS GROK SCORES + V7 MATRIX")
+print("=" * 70)
+
+# Try v6 first, fall back to v5, then v4
+v7_path = os.path.join(DATA_DIR, 'v38_2_integrated_features_v7.csv')
+v6_path = os.path.join(DATA_DIR, 'v38_2_integrated_features_v6.csv')
+v5_path = os.path.join(DATA_DIR, 'v38_2_integrated_features_v5.csv')
+v4_path = os.path.join(DATA_DIR, 'v38_2_integrated_features.csv')
+if os.path.exists(v7_path):
+    df_raw = pd.read_csv(v7_path)
+    print(f"V7 features loaded: {df_raw.shape}")
+elif os.path.exists(v6_path):
+    df_raw = pd.read_csv(v6_path)
+    print(f"V6 features loaded (v7 not found): {df_raw.shape}")
+elif os.path.exists(v5_path):
+    df_raw = pd.read_csv(v5_path)
+    print(f"V5 features loaded: {df_raw.shape}")
+else:
+    df_raw = pd.read_csv(v4_path)
+    print(f"V4 features loaded: {df_raw.shape}")
+
+# Load LLM features
+llm_features_loaded = {}
+for fname, varname in [
+    ('llm_activity_scores.json', 'act_scores'),
+    ('llm_supp_quality_all.json', 'supp_scores'),
+    ('llm_major_difficulty.json', 'major_diff'),
+    ('ps_yale_scores.json', 'ps_yale'),
+    ('grok42_ps_scores.json', 'grok_ps_scores'),
+]:
+    fpath = os.path.join(DATA_DIR, fname)
+    if os.path.exists(fpath):
+        with open(fpath) as f:
+            llm_features_loaded[varname] = json.load(f)
+        print(f"  Loaded {fname}: {len(llm_features_loaded[varname])} entries")
+    else:
+        llm_features_loaded[varname] = {}
+
+# Load raw data to get ED2 round info
+import re
+RAW_CSV = os.path.join(DATA_DIR, 'students_with_essays_merged_clean.csv')
+round_lookup = {}
+if os.path.exists(RAW_CSV):
+    print(f"\n  Loading raw CSV for ED2 round info...")
+    try:
+        raw_chunks = pd.read_csv(RAW_CSV, usecols=['student_id', 'school_results_summary'], 
+                                  dtype=str, chunksize=500)
+        for chunk in raw_chunks:
+            for _, row in chunk.iterrows():
+                sid = str(row.get('student_id', '')).replace('.0', '')
+                summary = str(row.get('school_results_summary', ''))
+                entries = re.split(r'(?=\d+\.)', summary)
+                for entry in entries:
+                    m = re.search(r'(Early Decision II|Early Decision|Early Action II|Early Action|Restrictive Early Action|Regular Decision)', entry)
+                    if m:
+                        round_type = m.group(1)
+                        school_m = re.search(r'\d+\.\s*(.+?)(?:\s*[-–]\s*|\s*\()', entry)
+                        if school_m:
+                            school_name = school_m.group(1).strip()
+                            key = f"{sid}_{school_name}"
+                            round_lookup[key] = round_type
+        print(f"  Round lookup built: {len(round_lookup)} entries")
+    except Exception as e:
+        print(f"  Warning: Could not load raw CSV: {e}")
+
+# ============================================================
+# 2. DATA CLEANING & QUALITY FIXES
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  DATA QUALITY FIXES")
+print(f"{'='*70}")
+
+# 2a. Filter years
+df = df_raw[~df_raw['year'].isin([2018, 2019])].copy()
+df = df.reset_index(drop=True)
+print(f"After filtering 2018-2019: {df.shape}")
+
+# 2b. FIX #1: SAT=0 -> NaN + has_sat
+sat_zero = (df['sat'] == 0).sum()
+df['has_sat'] = (df['sat'] > 0).astype(int)
+df.loc[df['sat'] == 0, 'sat'] = np.nan
+print(f"\n  FIX #1: SAT=0 -> NaN: {sat_zero} rows ({sat_zero/len(df)*100:.1f}%)")
+print(f"    has_sat=1: {df['has_sat'].sum()}, has_sat=0: {(df['has_sat']==0).sum()}")
+
+# 2c. FIX #2: TOEFL=0 -> NaN + has_toefl
+toefl_zero = (df['toefl'] == 0).sum()
+df['has_toefl'] = (df['toefl'] > 0).astype(int)
+df.loc[df['toefl'] == 0, 'toefl'] = np.nan
+print(f"  FIX #2: TOEFL=0 -> NaN: {toefl_zero} rows ({toefl_zero/len(df)*100:.1f}%)")
+
+# 2d. FIX #3: GPA=0 -> NaN (v5 already has has_gpa)
+gpa_zero = (df['gpa'] == 0).sum()
+df.loc[df['gpa'] == 0, 'gpa'] = np.nan
+print(f"  FIX #3: GPA=0 -> NaN: {gpa_zero} rows ({gpa_zero/len(df)*100:.1f}%)")
+if 'has_gpa' not in df.columns:
+    df['has_gpa'] = df['gpa'].notna().astype(int)
+print(f"    has_gpa=1: {(df['has_gpa']==1).sum()}, has_gpa=0: {(df['has_gpa']==0).sum()}")
+
+# 2e. FIX #4: -1 -> NaN for sentinel columns
+sentinel_cols = ['taste_yearly_admits_log']
+# v5 removed hs_to_univ_hist_rate, hs_to_univ_hist_rate_smoothed, hs_overall_hist_rate
+# but check if they exist
+for col in ['hs_to_univ_hist_rate', 'hs_to_univ_hist_rate_smoothed', 'hs_overall_hist_rate']:
+    if col in df.columns:
+        sentinel_cols.append(col)
+
+for col in sentinel_cols:
+    if col in df.columns:
+        n_neg1 = (df[col] == -1).sum()
+        df.loc[df[col] == -1, col] = np.nan
+        print(f"  FIX #4: {col}: -1 -> NaN: {n_neg1} rows ({n_neg1/len(df)*100:.1f}%)")
+
+# 2f. FIX #5: has_ps=0 -> ps_bert all NaN
+act_bert_cols = [c for c in df.columns if c.startswith('act_bert_pca_')]
+# ps_bert_pca columns were removed in v5, but check
+ps_bert_cols = [c for c in df.columns if c.startswith('ps_bert_pca_')]
+if ps_bert_cols:
+    no_ps_mask = df['has_ps'] == 0
+    n_fix = no_ps_mask.sum()
+    for col in ps_bert_cols:
+        df.loc[no_ps_mask, col] = np.nan
+    print(f"  FIX #5: ps_bert -> NaN for has_ps=0: {n_fix} rows, {len(ps_bert_cols)} columns")
+else:
+    print(f"  FIX #5: No ps_bert_pca columns in v5 (already removed)")
+
+# 2g. FIX portfolio_size: log transform + cap (from V2)
+print(f"\n  Portfolio size transform:")
+print(f"    Before: mean={df['portfolio_size'].mean():.1f}, max={df['portfolio_size'].max():.0f}")
+df['portfolio_size_raw'] = df['portfolio_size'].copy()
+df['portfolio_size'] = np.log1p(df['portfolio_size'].clip(upper=20))
+print(f"    After log(clip(x,20)): mean={df['portfolio_size'].mean():.2f}, max={df['portfolio_size'].max():.2f}")
+df['portfolio_size_bin'] = pd.cut(df['portfolio_size_raw'], 
+                                   bins=[0, 5, 10, 15, 20, 100],
+                                   labels=[0, 1, 2, 3, 4]).astype(int)
+
+# 2h. ED2 split (from V2)
+def get_detailed_round(row):
+    sid = str(row.get('student_id', '')).replace('.0', '')
+    school = str(row.get('school', ''))
+    key = f"{sid}_{school}"
+    raw_round = round_lookup.get(key, '')
+    if 'Early Decision II' in raw_round:
+        return 'ED2'
+    elif 'Early Decision' in raw_round:
+        return 'ED1'
+    elif 'Restrictive Early Action' in raw_round:
+        return 'REA'
+    elif 'Early Action II' in raw_round or 'Early Action' in raw_round:
+        return 'EA'
+    elif 'Regular Decision' in raw_round:
+        return 'RD'
+    # Fall back to original round_cat
+    orig = str(row.get('round_cat', 'RD'))
+    if orig == 'ED':
+        return 'ED1'
+    return orig
+
+df['round_cat_v2'] = df.apply(get_detailed_round, axis=1)
+print(f"\n  Round distribution (v2):")
+print(df['round_cat_v2'].value_counts().to_string())
+
+df['is_ed1'] = (df['round_cat_v2'] == 'ED1').astype(int)
+df['is_ed2'] = (df['round_cat_v2'] == 'ED2').astype(int)
+df['is_rea'] = (df['round_cat_v2'] == 'REA').astype(int)
+df['is_early'] = df['round_cat_v2'].isin(['ED1', 'ED2', 'EA', 'REA']).astype(int)
+df['round_cat'] = df['round_cat_v2']
+
+# ============================================================
+# 3. PARSE LLM FEATURES
+# ============================================================
+act_scores = {}
+raw = llm_features_loaded.get('act_scores', {})
+if isinstance(raw, list):
+    for item in raw:
+        if isinstance(item, dict) and item.get('success', False):
+            sid_raw = str(item.get('student_id', ''))
+            act_scores[sid_raw] = item
+            parts = sid_raw.split('_')
+            for p in parts:
+                clean = p.replace('.0', '')
+                if clean.isdigit():
+                    act_scores[clean] = item
+elif isinstance(raw, dict):
+    for sid, scores in raw.items():
+        if isinstance(scores, dict):
+            act_scores[sid] = scores
+
+supp_scores = {}
+raw = llm_features_loaded.get('supp_scores', {})
+if isinstance(raw, list):
+    for item in raw:
+        if isinstance(item, dict) and item.get('success', False):
+            sid = str(item.get('student_id', '')).replace('.0', '')
+            school = str(item.get('school', ''))
+            key = f"{sid}_{school}"
+            # FIX: Filter out score=1 entries (no supplement, not real scores)
+            oq = item.get('overall_quality', 0)
+            if isinstance(oq, (int, float)) and oq <= 1:
+                continue  # Skip fake scores
+            supp_scores[key] = item
+elif isinstance(raw, dict):
+    for key, scores in raw.items():
+        if isinstance(scores, dict):
+            oq = scores.get('overall_quality', 0)
+            if isinstance(oq, (int, float)) and oq <= 1:
+                continue  # Skip fake scores
+            supp_scores[key] = scores
+print(f"  Supp scores after filtering score=1: {len(supp_scores)} valid entries")
+
+major_diff = llm_features_loaded.get('major_diff', {})
+if isinstance(major_diff, list):
+    major_diff = {}
+
+ps_yale = {}
+raw = llm_features_loaded.get('ps_yale', {})
+if isinstance(raw, list):
+    for item in raw:
+        if isinstance(item, dict):
+            sid = str(item.get('student_id', '')).replace('.0', '')
+            ps_yale[sid] = item
+elif isinstance(raw, dict):
+    ps_yale = raw
+
+print(f"\nLLM features: Activity={len(act_scores)}, Supp={len(supp_scores)}, MajorDiff={len(major_diff)}, PS={len(ps_yale)}")
+
+ACT_DIMS = ['max_power_index', 'avg_power_index', 'n_high_power',
+            'n_founder', 'n_president', 'max_scope',
+            'has_publication', 'has_patent', 'has_summer_program',
+            'summer_program_tier', 'has_olympiad', 'olympiad_level',
+            'activity_coherence', 'spike_strength']
+
+SUPP_DIMS = ['overall_quality', 'specificity_score', 'enthusiasm_score',
+             'has_imagination_scene', 'mentions_specific_course',
+             'mentions_specific_professor', 'mentions_specific_program',
+             'mentions_specific_facility', 'coherence_with_major', 'has_red_flag']
+
+sample_ps = next(iter(ps_yale.values()), {}) if ps_yale else {}
+PS_DIMS = [k for k in sample_ps.keys() if k not in ['student_id', 'success', 'error', 'note', 'essay_type']
+           and not k.startswith('is_')]
+if not PS_DIMS:
+    PS_DIMS = ['show_not_tell', 'reflection_depth', 'authentic_voice',
+               'coherence_focus', 'overall_effectiveness']
+
+# ============================================================
+# 4. DEFINE FEATURE GROUPS (adapted for v6 = v5 + restored v4 cols)
+# ============================================================
+STUDENT_LEVEL_NUMERIC = [
+    'toefl', 'sat', 'gpa',
+    'act_total_count', 'act_type_diversity',
+    *[f'act_slot_pca_{i}' for i in range(20)],
+    *[f'act_bert_pca_{i}' for i in range(16)],
+    # Restored from v4: ps_bert_pca
+    *[f'ps_bert_pca_{i}' for i in range(16)],
+    'honors_max_score', 'honors_avg_score', 'honors_min_score',
+    'honors_count', 'honors_total_score',
+    'honors_has_top_tier', 'honors_tier1_count', 'honors_tier2_count',
+    'honors_has_national',
+    # NEW: honors quality ratio
+    'honors_quality_ratio',
+    'cuilu_hs_top10_rate', 'cuilu_hs_top20_rate',
+    'cuilu_hs_top10_count', 'cuilu_hs_top20_count',
+    'cuilu_hs_total',
+    'cuilu_feeder_rank', 'cuilu_hs_type_rate', 'cuilu_region_rate',
+    # Restored from v4: hs_to_univ_hist
+    'hs_to_univ_hist_rate', 'hs_to_univ_hist_rate_smoothed', 'hs_to_univ_hist_admits',
+    'hs_overall_hist_rate',
+    # Restored from v4: summer features
+    'summer_max_geili', 'summer_has_elite', 'summer_count',
+    'summer_program_count', 'summer_difficulty_max',
+]
+
+# Add act_type_count columns dynamically
+act_type_cols_in_data = [c for c in df.columns if c.startswith('act_type_count_')]
+STUDENT_LEVEL_NUMERIC.extend(act_type_cols_in_data)
+
+# Filter to only existing columns
+STUDENT_LEVEL_NUMERIC = [c for c in STUDENT_LEVEL_NUMERIC if c in df.columns]
+print(f"\n  Student-level numeric features: {len(STUDENT_LEVEL_NUMERIC)}")
+
+KEY_STUDENT_FEATURES = [
+    'toefl', 'sat', 'gpa',
+    'honors_max_score', 'honors_avg_score', 'honors_count',
+    'honors_quality_ratio',
+    'act_type_diversity', 'act_total_count',
+    # Restored high-value features
+    'hs_to_univ_hist_rate_smoothed',
+    'summer_max_geili',
+    # Admitted similarity features (time-respecting)
+    'act_bert_admit_sim', 'ps_bert_admit_sim', 'act_slot_admit_sim',
+    'ps_bert_sim_contrast',
+    # Grok PS scores
+    'grok_ps_overall', 'grok_ps_originality',
+]
+
+LLM_INTERACTION_FEATURES = [
+    'llm_act_mean', 'llm_act_max', 'llm_act_avg_power_index',
+    'supp_mean', 'supp_max', 'ps_mean',
+    'major_difficulty',
+    # V5 additions
+    'grok_ps_overall', 'grok_ps_originality', 'grok_ps_mean',
+    'act_bert_admit_sim', 'ps_bert_admit_sim', 'ps_bert_sim_contrast',
+]
+
+# ============================================================
+# 5. BUILD FEATURES
+# ============================================================
+def build_features_base(df):
+    """Build base features WITHOUT residualization."""
+    df = df.copy()
+    
+    df['is_partial_year'] = (df['year'] == 2025).astype(int)
+    df['year_cat'] = df['year'].astype(str)
+    df['sid_str'] = df['student_id'].astype(str).str.replace('.0', '', regex=False)
+    
+    # LLM Activity features
+    for dim in ACT_DIMS:
+        col_name = f'llm_act_{dim}'
+        df[col_name] = df['sid_str'].map(
+            lambda s, d=dim: safe_num(act_scores.get(s, {}).get(d, np.nan)))
+    
+    # LLM Supp features
+    def get_supp_score(row, dim):
+        key = f"{row['sid_str']}_{row['school']}"
+        return safe_num(supp_scores.get(key, {}).get(dim, np.nan))
+    for dim in SUPP_DIMS:
+        col_name = f'supp_{dim}'
+        df[col_name] = df.apply(lambda r, d=dim: get_supp_score(r, d), axis=1)
+    
+    # Major difficulty
+    def get_major_diff(row):
+        key = f"{row['school']}_{row['major_cat']}"
+        return safe_num(major_diff.get(key, {}).get('difficulty_score', np.nan))
+    df['major_difficulty'] = df.apply(get_major_diff, axis=1)
+    
+    # PS Yale scores
+    for dim in PS_DIMS:
+        col_name = f'ps_{dim}'
+        df[col_name] = df['sid_str'].map(
+            lambda s, d=dim: safe_num(ps_yale.get(s, {}).get(d, np.nan)))
+    
+    # Grok 4.2 PS scores (NEW in V5)
+    grok_ps = llm_features_loaded.get('grok_ps_scores', {})
+    grok_ps_dims = ['overall_score', 'originality_depth', 'reflection_depth', 'authenticity_structure']
+    for dim in grok_ps_dims:
+        col_name = f'grok_ps_{dim.replace("_score", "").replace("_depth", "")}'
+        df[col_name] = df['sid_str'].map(
+            lambda s, d=dim: safe_num(grok_ps.get(s, {}).get(d, np.nan)) if grok_ps.get(s, {}).get('success') else np.nan)
+    
+    # Grok PS red flags as binary features (from v7 CSV, already present)
+    # ps_flag_* columns are already in v7 matrix
+    
+    # Grok PS aggregates
+    grok_cols = [c for c in df.columns if c.startswith('grok_ps_')]
+    if grok_cols:
+        df['grok_ps_mean'] = df[grok_cols].mean(axis=1)
+        print(f"  Grok PS scores: {len(grok_cols)} dims, {df['grok_ps_mean'].notna().sum()} valid rows")
+    
+    # Aggregates (use NaN-aware operations)
+    llm_act_cols = [f'llm_act_{d}' for d in ACT_DIMS]
+    valid_act = df[llm_act_cols]
+    df['llm_act_mean'] = valid_act.mean(axis=1)
+    df['llm_act_max'] = valid_act.max(axis=1)
+    df['llm_act_n_valid'] = valid_act.notna().sum(axis=1)
+    
+    supp_num_cols = [f'supp_{d}' for d in SUPP_DIMS if d not in ['has_red_flag']]
+    valid_supp = df[supp_num_cols]
+    df['supp_mean'] = valid_supp.mean(axis=1)
+    df['supp_max'] = valid_supp.max(axis=1)
+    
+    ps_cols = [f'ps_{d}' for d in PS_DIMS]
+    valid_ps = df[ps_cols]
+    df['ps_mean'] = valid_ps.mean(axis=1)
+    
+    # Basic interactions (NaN-safe: NaN * anything = NaN, which is fine)
+    df['toefl_x_sat'] = df['toefl'] * df['sat'] / 10000.0
+    df['gpa_x_toefl'] = df['gpa'] * df['toefl'] / 100.0
+    df['llm_act_x_supp'] = df['llm_act_mean'] * df['supp_mean']
+    
+    if 'honors_avg_score' in df.columns:
+        df['honors_x_sat'] = df['honors_avg_score'] * df['sat'] / 1600
+        df['honors_x_toefl'] = df['honors_avg_score'] * df['toefl'] / 120
+    
+    if 'cuilu_hs_top10_rate' in df.columns and 'taste_score_sensitivity' in df.columns:
+        df['cuilu_x_taste'] = df['cuilu_hs_top10_rate'] * df['taste_score_sensitivity']
+    
+    # Categoricals - with round_cat v2 (EA/ED1/ED2/REA/RD)
+    cat_cols = ['school', 'round_cat', 'major_cat', 'hs_cat', 'year_cat', 'hs_name', 'province']
+    cat_cols = [c for c in cat_cols if c in df.columns]
+    
+    if 'round_cat' in df.columns:
+        df['school_round'] = df['school'].astype(str) + '_' + df['round_cat'].astype(str)
+        cat_cols.append('school_round')
+    df['school_major'] = df['school'].astype(str) + '_' + df['major_cat'].astype(str)
+    cat_cols.append('school_major')
+    if 'hs_cat' in df.columns:
+        df['school_hstype'] = df['school'].astype(str) + '_' + df['hs_cat'].astype(str)
+        cat_cols.append('school_hstype')
+    
+    for c in cat_cols:
+        df[c] = df[c].fillna('_MISSING_').astype(str)
+        le = LabelEncoder()
+        df[c] = le.fit_transform(df[c]).astype(int)
+    
+    return df, cat_cols
+
+
+def add_residualized_features(df, train_mask, cat_cols, selected_features=None):
+    """Add residualized + interaction + ED boost features using ONLY training data statistics.
+    KEY FIX: Residualization uses only non-NaN values for school means."""
+    df = df.copy()
+    
+    # Step 1: Bayesian-smoothed school_base_rate
+    train_df = df[train_mask]
+    global_rate = train_df[TARGET].mean()
+    
+    school_stats = train_df.groupby('school').agg(
+        school_raw_rate=(TARGET, 'mean'),
+        school_n_apps=(TARGET, 'count'),
+        school_n_admits=(TARGET, 'sum'),
+    ).reset_index()
+    
+    SMOOTH_STRENGTH = 30
+    school_stats['school_base_rate'] = (
+        (school_stats['school_raw_rate'] * school_stats['school_n_apps'] + global_rate * SMOOTH_STRENGTH) /
+        (school_stats['school_n_apps'] + SMOOTH_STRENGTH)
+    )
+    
+    df = df.merge(school_stats[['school', 'school_base_rate', 'school_n_apps', 'school_n_admits']], 
+                  on='school', how='left')
+    df['school_base_rate'] = df['school_base_rate'].fillna(global_rate)
+    df['school_n_apps'] = df['school_n_apps'].fillna(0)
+    df['school_n_admits'] = df['school_n_admits'].fillna(0)
+    
+    # Step 1b: ED boost per school
+    ed1_mask = train_df['is_ed1'] == 1
+    rd_mask = train_df['is_early'] == 0
+    
+    ed1_school_rates = train_df[ed1_mask].groupby('school')[TARGET].mean()
+    rd_school_rates = train_df[rd_mask].groupby('school')[TARGET].mean()
+    
+    ed_boost_map = {}
+    for school in ed1_school_rates.index:
+        if school in rd_school_rates.index:
+            ed_boost_map[school] = ed1_school_rates[school] - rd_school_rates[school]
+    df['school_ed_boost'] = df['school'].map(ed_boost_map).fillna(0)
+    
+    ed2_mask = train_df['is_ed2'] == 1
+    ed2_school_rates = train_df[ed2_mask].groupby('school')[TARGET].mean()
+    ed2_boost_map = {}
+    for school in ed2_school_rates.index:
+        if school in rd_school_rates.index:
+            ed2_boost_map[school] = ed2_school_rates[school] - rd_school_rates[school]
+    df['school_ed2_boost'] = df['school'].map(ed2_boost_map).fillna(0)
+    
+    # Step 2: Residualize student features
+    # KEY FIX: Use only non-NaN values for school means
+    student_feat_available = [c for c in STUDENT_LEVEL_NUMERIC if c in df.columns]
+    
+    resid_cols = []
+    for col in student_feat_available:
+        resid_col = f'{col}_resid'
+        # Compute school mean using ONLY non-NaN training values
+        school_mean_series = train_df.groupby('school')[col].mean()  # NaN excluded by default
+        col_school_mean = df['school'].map(school_mean_series)
+        # Residual: student value - school mean (NaN if either is NaN)
+        df[resid_col] = df[col] - col_school_mean
+        resid_cols.append(resid_col)
+    
+    # Step 3: Explicit interactions (student feature x school_base_rate)
+    interaction_cols = []
+    for col in KEY_STUDENT_FEATURES:
+        if col in df.columns:
+            int_col = f'{col}_x_school_rate'
+            df[int_col] = df[col] * df['school_base_rate']  # NaN propagates naturally
+            interaction_cols.append(int_col)
+            
+            resid_col = f'{col}_resid'
+            if resid_col in df.columns:
+                int_resid_col = f'{col}_resid_x_rate'
+                df[int_resid_col] = df[resid_col] * df['school_base_rate']
+                interaction_cols.append(int_resid_col)
+    
+    # Step 3b: LLM feature x school_base_rate interactions
+    for col in LLM_INTERACTION_FEATURES:
+        if col in df.columns:
+            int_col = f'{col}_x_school_rate'
+            df[int_col] = df[col] * df['school_base_rate']
+            interaction_cols.append(int_col)
+    
+    # Step 3c: portfolio_size x school_base_rate interaction
+    if 'portfolio_size' in df.columns:
+        df['portfolio_x_school_rate'] = df['portfolio_size'] * df['school_base_rate']
+        interaction_cols.append('portfolio_x_school_rate')
+    
+    # Step 3d: ED flag x school_ed_boost interaction
+    if 'is_ed1' in df.columns:
+        df['ed1_x_ed_boost'] = df['is_ed1'] * df['school_ed_boost']
+        interaction_cols.append('ed1_x_ed_boost')
+    if 'is_ed2' in df.columns:
+        df['ed2_x_ed2_boost'] = df['is_ed2'] * df['school_ed2_boost']
+        interaction_cols.append('ed2_x_ed2_boost')
+    
+    # Step 3e: has_sat/has_toefl/has_gpa interactions with school_base_rate
+    for flag in ['has_sat', 'has_toefl', 'has_gpa']:
+        if flag in df.columns:
+            int_col = f'{flag}_x_school_rate'
+            df[int_col] = df[flag] * df['school_base_rate']
+            interaction_cols.append(int_col)
+    
+    # Step 4: Student percentile within school (NaN-safe)
+    pctile_cols = []
+    for col in ['toefl', 'sat', 'gpa', 'honors_max_score',
+                'llm_act_mean', 'supp_mean']:
+        if col not in df.columns:
+            continue
+        pctile_col = f'{col}_school_pctile'
+        school_distributions = {}
+        for school_id in train_df['school'].unique():
+            vals = train_df[train_df['school'] == school_id][col].dropna().values
+            if len(vals) > 2:
+                school_distributions[school_id] = vals
+        
+        def compute_pctile(row, col=col, sd=school_distributions):
+            school_id = row['school']
+            val = row[col]
+            if pd.isna(val) or school_id not in sd:
+                return np.nan  # Return NaN instead of 0.5
+            dist = sd[school_id]
+            return np.mean(dist <= val)
+        
+        df[pctile_col] = df.apply(compute_pctile, axis=1)
+        pctile_cols.append(pctile_col)
+    
+    # Step 5: Student competitiveness score (NaN-safe)
+    if all(c in df.columns for c in ['toefl', 'sat', 'honors_max_score']):
+        # Use NaN-safe computation
+        components = []
+        weights = []
+        for col, w, scale in [('toefl', 0.3, 120), ('sat', 0.3, 1600), 
+                                ('honors_max_score', 0.2, 10), ('llm_act_mean', 0.2, 10)]:
+            if col in df.columns:
+                components.append(df[col] / scale)
+                weights.append(w)
+        if components:
+            strength_df = pd.DataFrame(components).T
+            df['student_strength'] = strength_df.mean(axis=1)  # NaN-safe mean
+            df['strength_vs_school'] = df['student_strength'] - (1 - df['school_base_rate'])
+    
+    # Build final feature list
+    num_cols = [c for c in df.columns if df[c].dtype in ['float64', 'int64', 'float32', 'int32']
+                and c not in [TARGET, 'student_id', 'year', 'Unnamed: 0']]
+    
+    all_feat = list(set(num_cols + cat_cols))
+    feature_cols = list(dict.fromkeys([c for c in all_feat if c in df.columns]))
+    for remove in [TARGET, 'student_id', 'year', 'sid_str', 'Unnamed: 0', 'portfolio_size_raw']:
+        if remove in feature_cols:
+            feature_cols.remove(remove)
+    
+    # Remove constant columns
+    to_drop = [c for c in feature_cols if df[c].nunique() <= 1]
+    feature_cols = [c for c in feature_cols if c not in to_drop]
+    
+    # Apply feature selection if provided
+    if selected_features is not None:
+        must_keep = set(cat_cols) | {'school_base_rate', 'school_n_apps', 'school_n_admits',
+                                      'student_strength', 'strength_vs_school',
+                                      'school_ed_boost', 'school_ed2_boost',
+                                      'is_ed1', 'is_ed2', 'is_rea', 'is_early',
+                                      'ed1_x_ed_boost', 'ed2_x_ed2_boost',
+                                      'has_sat', 'has_toefl', 'has_gpa',
+                                      'portfolio_size', 'portfolio_size_bin', 'portfolio_x_school_rate'}
+        feature_cols = [c for c in feature_cols if c in selected_features or c in must_keep]
+    
+    # KEY CHANGE: Do NOT fill NaN for CatBoost - it handles NaN natively
+    # Only fill NaN for LGB/XGB later, and only for non-cat columns
+    # For now, just handle inf
+    for c in feature_cols:
+        if df[c].dtype in ['float64', 'float32']:
+            df[c] = df[c].replace([np.inf, -np.inf], np.nan)
+    
+    cat_indices = [feature_cols.index(c) for c in cat_cols if c in feature_cols]
+    
+    new_feat_count = len(resid_cols) + len(interaction_cols) + len(pctile_cols) + 5
+    print(f"    Resid features: {len(resid_cols)} resid + {len(interaction_cols)} interact + {len(pctile_cols)} pctile = {new_feat_count} new, total={len(feature_cols)}")
+    
+    return df, feature_cols, cat_cols, cat_indices
+
+
+# ============================================================
+# 6. BUILD BASE FEATURES
+# ============================================================
+df_base, cat_cols = build_features_base(df)
+print(f"\nBase features built. Shape: {df_base.shape}")
+
+# Quick NaN summary
+print(f"\n  NaN summary after fixes:")
+for col in ['sat', 'toefl', 'gpa']:
+    nan_pct = df_base[col].isna().mean() * 100
+    print(f"    {col}: {nan_pct:.1f}% NaN")
+
+y = df_base[TARGET].values
+groups = df_base['student_id'].values
+
+# ============================================================
+# 7. STAGE 1: FEATURE IMPORTANCE ESTIMATION
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  STAGE 1: FEATURE IMPORTANCE ESTIMATION")
+print(f"{'='*70}")
+
+stage1_fi = []
+gkf_s1 = GroupKFold(n_splits=5)
+for fold, (tr_idx, va_idx) in enumerate(gkf_s1.split(df_base, y, groups)):
+    train_mask = pd.Series(False, index=df_base.index)
+    train_mask.iloc[tr_idx] = True
+    
+    df_fold, feat_cols_f, cat_cols_f, cat_idx_f = add_residualized_features(
+        df_base, train_mask, cat_cols)
+    
+    X_tr = df_fold[feat_cols_f].iloc[tr_idx]
+    X_va = df_fold[feat_cols_f].iloc[va_idx]
+    y_tr = y[tr_idx]
+    y_va = y[va_idx]
+    
+    for c in cat_cols_f:
+        if c in X_tr.columns:
+            X_tr[c] = X_tr[c].astype(int)
+            X_va[c] = X_va[c].astype(int)
+    # CatBoost handles NaN natively - don't fill
+    
+    cb = CatBoostClassifier(
+        iterations=500, depth=6, learning_rate=0.05,
+        l2_leaf_reg=7, random_seed=42, verbose=0,
+        cat_features=cat_idx_f, eval_metric='AUC',
+        early_stopping_rounds=50)
+    pool_tr = Pool(X_tr, y_tr, cat_features=cat_idx_f)
+    pool_va = Pool(X_va, y_va, cat_features=cat_idx_f)
+    cb.fit(pool_tr, eval_set=pool_va, verbose=0)
+    
+    fi = cb.get_feature_importance()
+    stage1_fi.append(fi)
+    
+    auc = roc_auc_score(y_va, cb.predict_proba(Pool(X_va, cat_features=cat_idx_f))[:, 1])
+    print(f"  Fold {fold+1}/5: AUC={auc:.4f}, Features={len(feat_cols_f)}")
+    
+    if fold == 0:
+        all_feature_names = feat_cols_f
+    
+    del cb, pool_tr, pool_va, df_fold; gc.collect()
+
+# Select top features
+avg_fi = np.mean(stage1_fi, axis=0)
+fi_pairs = sorted(zip(all_feature_names, avg_fi), key=lambda x: -x[1])
+
+selected_set = set(cat_cols)
+n_added = 0
+for fname, imp in fi_pairs:
+    if fname not in cat_cols:
+        selected_set.add(fname)
+        n_added += 1
+        if n_added >= FEATURE_SELECT_TOP_N:
+            break
+
+print(f"\n  Feature selection: {len(all_feature_names)} -> {len(selected_set)} features")
+print(f"  Top 20 features:")
+for i, (fname, imp) in enumerate(fi_pairs[:20]):
+    marker = ""
+    if '_resid' in fname: marker = " [R]"
+    elif '_x_school_rate' in fname or '_resid_x_rate' in fname or '_x_ed' in fname: marker = " [I]"
+    elif '_school_pctile' in fname: marker = " [P]"
+    elif 'school_base_rate' in fname: marker = " [S]"
+    elif 'ed_boost' in fname: marker = " [ED]"
+    print(f"    {i+1:3d}. {fname:<50s} {imp:>8.2f}{marker}")
+
+# ============================================================
+# 8. TEMPORAL VALIDATION WITH SELECTED FEATURES
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  TEMPORAL VALIDATION (2020-2023 -> 2024) WITH FEATURE SELECTION")
+print(f"{'='*70}")
+
+mask_train_temporal = df_base['year'].isin([2020, 2021, 2022, 2023])
+mask_test_temporal = df_base['year'] == 2024
+
+temporal_results = {}
+if mask_test_temporal.sum() > 0:
+    df_temporal, feat_cols_t, cat_cols_t, cat_idx_t = add_residualized_features(
+        df_base, mask_train_temporal, cat_cols, selected_features=selected_set)
+    
+    X_t = df_temporal[feat_cols_t].copy()
+    for c in cat_cols_t:
+        if c in X_t.columns:
+            X_t[c] = X_t[c].astype(int)
+    
+    X_tr_t = X_t[mask_train_temporal]
+    X_te_t = X_t[mask_test_temporal]
+    y_tr_t = y[mask_train_temporal]
+    y_te_t = y[mask_test_temporal]
+    
+    # For LGB/XGB: fill NaN with -999 (a value they can split on)
+    X_tr_t_filled = X_tr_t.fillna(-999)
+    X_te_t_filled = X_te_t.fillna(-999)
+    
+    print(f"  Train: {len(X_tr_t)}, Test: {len(X_te_t)}, Features: {len(feat_cols_t)}")
+    
+    for seed in SEEDS:
+        # CatBoost: native NaN handling
+        cb_t = CatBoostClassifier(
+            iterations=1000, depth=6, learning_rate=0.03,
+            l2_leaf_reg=7, random_seed=seed, verbose=0,
+            cat_features=cat_idx_t, eval_metric='AUC',
+            early_stopping_rounds=100, min_data_in_leaf=10)
+        pool_tr = Pool(X_tr_t, y_tr_t, cat_features=cat_idx_t)
+        pool_te = Pool(X_te_t, y_te_t, cat_features=cat_idx_t)
+        cb_t.fit(pool_tr, eval_set=pool_te, verbose=0)
+        cb_pred = cb_t.predict_proba(Pool(X_te_t, cat_features=cat_idx_t))[:, 1]
+        del cb_t; gc.collect()
+        
+        # LGB: use filled data
+        lgb_tr = lgb.Dataset(X_tr_t_filled.values, y_tr_t, categorical_feature=cat_idx_t)
+        lgb_va = lgb.Dataset(X_te_t_filled.values, y_te_t, categorical_feature=cat_idx_t, reference=lgb_tr)
+        lgb_params = {
+            'objective': 'binary', 'metric': 'auc', 'verbosity': -1,
+            'learning_rate': 0.03, 'num_leaves': 63, 'max_depth': 6,
+            'min_child_samples': 25, 'reg_alpha': 0.3, 'reg_lambda': 2.0,
+            'feature_fraction': 0.7, 'bagging_fraction': 0.8, 'bagging_freq': 5,
+            'seed': seed
+        }
+        lgb_model = lgb.train(lgb_params, lgb_tr, num_boost_round=1500,
+                              valid_sets=[lgb_va],
+                              callbacks=[lgb.early_stopping(100), lgb.log_evaluation(0)])
+        lgb_pred = lgb_model.predict(X_te_t_filled.values)
+        del lgb_model; gc.collect()
+        
+        # XGB: use filled data
+        dtrain = xgb.DMatrix(X_tr_t_filled.values, label=y_tr_t, enable_categorical=False)
+        dtest = xgb.DMatrix(X_te_t_filled.values, label=y_te_t, enable_categorical=False)
+        xgb_params = {
+            'objective': 'binary:logistic', 'eval_metric': 'auc',
+            'max_depth': 6, 'learning_rate': 0.03,
+            'subsample': 0.8, 'colsample_bytree': 0.7,
+            'reg_alpha': 0.3, 'reg_lambda': 2.0,
+            'min_child_weight': 5,
+            'seed': seed, 'verbosity': 0
+        }
+        xgb_model = xgb.train(xgb_params, dtrain, num_boost_round=1500,
+                              evals=[(dtest, 'val')],
+                              early_stopping_rounds=100, verbose_eval=False)
+        xgb_pred = xgb_model.predict(dtest)
+        del xgb_model, dtrain, dtest; gc.collect()
+        
+        blend = 0.45 * cb_pred + 0.20 * lgb_pred + 0.35 * xgb_pred
+        temporal_results[seed] = {
+            'cb': float(roc_auc_score(y_te_t, cb_pred)),
+            'lgb': float(roc_auc_score(y_te_t, lgb_pred)),
+            'xgb': float(roc_auc_score(y_te_t, xgb_pred)),
+            'blend': float(roc_auc_score(y_te_t, blend))
+        }
+        print(f"  Seed {seed}: CB={temporal_results[seed]['cb']:.4f} LGB={temporal_results[seed]['lgb']:.4f} XGB={temporal_results[seed]['xgb']:.4f} Blend={temporal_results[seed]['blend']:.4f}")
+    
+    avg_temporal = np.mean([v['blend'] for v in temporal_results.values()])
+    print(f"\n  AVG Temporal Blend: {avg_temporal:.4f} (V37.3: 0.8410, V38.2-PRO-V4: 0.8555)")
+    print(f"  Delta vs V37.3: {avg_temporal - 0.8410:+.4f}")
+    print(f"  Delta vs V38.2-PRO-V4: {avg_temporal - 0.8555:+.4f}")
+    
+    del df_temporal, X_t; gc.collect()
+else:
+    avg_temporal = 0.0
+
+# ============================================================
+# 9. STAGE 2: MULTI-SEED GROUPKFOLD
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  STAGE 2: MULTI-SEED GROUPKFOLD ({len(SEEDS)} seeds x {N_FOLDS} folds)")
+print(f"{'='*70}")
+
+all_cb_oof = []
+all_lgb_oof = []
+all_xgb_oof = []
+all_fi = []
+feature_cols_final = None
+
+for seed_idx, seed in enumerate(SEEDS):
+    print(f"\n  --- Seed {seed} ({seed_idx+1}/{len(SEEDS)}) ---")
+    gkf = GroupKFold(n_splits=N_FOLDS)
+    cb_oof = np.zeros(len(df_base))
+    lgb_oof = np.zeros(len(df_base))
+    xgb_oof = np.zeros(len(df_base))
+    
+    for fold, (tr_idx, va_idx) in enumerate(gkf.split(df_base, y, groups)):
+        train_mask = pd.Series(False, index=df_base.index)
+        train_mask.iloc[tr_idx] = True
+        
+        df_fold, feat_cols_f, cat_cols_f, cat_idx_f = add_residualized_features(
+            df_base, train_mask, cat_cols, selected_features=selected_set)
+        
+        if feature_cols_final is None:
+            feature_cols_final = feat_cols_f
+            print(f"    Total features after selection: {len(feat_cols_f)}")
+        
+        X_fold = df_fold[feat_cols_f].copy()
+        for c in cat_cols_f:
+            if c in X_fold.columns:
+                X_fold[c] = X_fold[c].astype(int)
+        
+        X_tr_df = X_fold.iloc[tr_idx]
+        X_va_df = X_fold.iloc[va_idx]
+        y_tr = y[tr_idx]
+        y_va = y[va_idx]
+        
+        # CatBoost: native NaN
+        cb = CatBoostClassifier(
+            iterations=1500, depth=6, learning_rate=0.03,
+            l2_leaf_reg=7, random_seed=seed, verbose=0,
+            cat_features=cat_idx_f, eval_metric='AUC',
+            early_stopping_rounds=100, min_data_in_leaf=10)
+        pool_tr = Pool(X_tr_df, y_tr, cat_features=cat_idx_f)
+        pool_va = Pool(X_va_df, y_va, cat_features=cat_idx_f)
+        cb.fit(pool_tr, eval_set=pool_va, verbose=0)
+        cb_pred = cb.predict_proba(Pool(X_va_df, cat_features=cat_idx_f))[:, 1]
+        cb_oof[va_idx] = cb_pred
+        
+        if fold == N_FOLDS - 1:
+            all_fi.append(cb.get_feature_importance())
+        del cb, pool_tr, pool_va; gc.collect()
+        
+        # LGB/XGB: fill NaN
+        X_tr_filled = X_tr_df.fillna(-999).values
+        X_va_filled = X_va_df.fillna(-999).values
+        
+        lgb_tr = lgb.Dataset(X_tr_filled, y_tr, categorical_feature=cat_idx_f)
+        lgb_va_ds = lgb.Dataset(X_va_filled, y_va, categorical_feature=cat_idx_f, reference=lgb_tr)
+        lgb_params = {
+            'objective': 'binary', 'metric': 'auc', 'verbosity': -1,
+            'learning_rate': 0.03, 'num_leaves': 63, 'max_depth': 6,
+            'min_child_samples': 25, 'reg_alpha': 0.3, 'reg_lambda': 2.0,
+            'feature_fraction': 0.7, 'bagging_fraction': 0.8, 'bagging_freq': 5,
+            'seed': seed
+        }
+        lgb_model = lgb.train(lgb_params, lgb_tr, num_boost_round=1500,
+                              valid_sets=[lgb_va_ds],
+                              callbacks=[lgb.early_stopping(100), lgb.log_evaluation(0)])
+        lgb_pred = lgb_model.predict(X_va_filled)
+        lgb_oof[va_idx] = lgb_pred
+        del lgb_model; gc.collect()
+        
+        dtrain = xgb.DMatrix(X_tr_filled, label=y_tr)
+        dval = xgb.DMatrix(X_va_filled, label=y_va)
+        xgb_params = {
+            'objective': 'binary:logistic', 'eval_metric': 'auc',
+            'max_depth': 6, 'learning_rate': 0.03,
+            'subsample': 0.8, 'colsample_bytree': 0.7,
+            'reg_alpha': 0.3, 'reg_lambda': 2.0,
+            'min_child_weight': 5,
+            'seed': seed, 'verbosity': 0
+        }
+        xgb_model = xgb.train(xgb_params, dtrain, num_boost_round=1500,
+                              evals=[(dval, 'val')],
+                              early_stopping_rounds=100, verbose_eval=False)
+        xgb_pred = xgb_model.predict(dval)
+        xgb_oof[va_idx] = xgb_pred
+        del xgb_model, dtrain, dval, df_fold, X_fold; gc.collect()
+        
+        if (fold + 1) % 5 == 0:
+            print(f"    Fold {fold+1}/{N_FOLDS} done")
+    
+    cb_auc = roc_auc_score(y, cb_oof)
+    lgb_auc = roc_auc_score(y, lgb_oof)
+    xgb_auc = roc_auc_score(y, xgb_oof)
+    print(f"    CB: {cb_auc:.4f}  LGB: {lgb_auc:.4f}  XGB: {xgb_auc:.4f}")
+    
+    all_cb_oof.append(cb_oof)
+    all_lgb_oof.append(lgb_oof)
+    all_xgb_oof.append(xgb_oof)
+
+# ============================================================
+# 10. ENSEMBLE & BLEND
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  ENSEMBLE RESULTS")
+print(f"{'='*70}")
+
+cb_avg = np.mean(all_cb_oof, axis=0)
+lgb_avg = np.mean(all_lgb_oof, axis=0)
+xgb_avg = np.mean(all_xgb_oof, axis=0)
+
+cb_final_auc = roc_auc_score(y, cb_avg)
+lgb_final_auc = roc_auc_score(y, lgb_avg)
+xgb_final_auc = roc_auc_score(y, xgb_avg)
+
+print(f"  CB  {len(SEEDS)}-seed avg: {cb_final_auc:.4f}")
+print(f"  LGB {len(SEEDS)}-seed avg: {lgb_final_auc:.4f}")
+print(f"  XGB {len(SEEDS)}-seed avg: {xgb_final_auc:.4f}")
+
+best_auc = 0
+best_weights = (0.45, 0.20, 0.35)
+for w_cb in np.arange(0.2, 0.7, 0.05):
+    for w_lgb in np.arange(0.05, 0.5, 0.05):
+        w_xgb = 1.0 - w_cb - w_lgb
+        if w_xgb < 0.05: continue
+        blend = w_cb * cb_avg + w_lgb * lgb_avg + w_xgb * xgb_avg
+        auc = roc_auc_score(y, blend)
+        if auc > best_auc:
+            best_auc = auc
+            best_weights = (w_cb, w_lgb, w_xgb)
+
+print(f"\n  Best 3-model blend: {best_auc:.4f}")
+print(f"  Delta vs V37.3:       {best_auc - 0.8697:+.4f}")
+print(f"  Delta vs V38.2-PRO-V4: {best_auc - 0.8758:+.4f}")
+print(f"  Weights: CB={best_weights[0]:.2f} LGB={best_weights[1]:.2f} XGB={best_weights[2]:.2f}")
+
+rank_blend = (rankdata(cb_avg) + rankdata(lgb_avg) + rankdata(xgb_avg)) / 3
+rank_auc = roc_auc_score(y, rank_blend)
+print(f"  Rank blend: {rank_auc:.4f}")
+
+final_blend_prob = best_weights[0] * cb_avg + best_weights[1] * lgb_avg + best_weights[2] * xgb_avg
+final_auc = roc_auc_score(y, final_blend_prob)
+final_brier = brier_score_loss(y, np.clip(final_blend_prob, 1e-7, 1-1e-7))
+final_logloss = log_loss(y, np.clip(final_blend_prob, 1e-7, 1-1e-7))
+
+print(f"\n  FINAL METRICS:")
+print(f"    AUC:      {final_auc:.4f} (V37.3: 0.8697, V38.2-PRO-V4: 0.8758)")
+print(f"    Brier:    {final_brier:.4f}")
+print(f"    LogLoss:  {final_logloss:.4f}")
+
+# ============================================================
+# 11. FEATURE IMPORTANCE
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  FEATURE IMPORTANCE (avg across seeds)")
+print(f"{'='*70}")
+
+if feature_cols_final and all_fi:
+    avg_fi = np.mean(all_fi, axis=0)
+    fi_pairs = sorted(zip(feature_cols_final, avg_fi), key=lambda x: -x[1])
+    
+    print(f"  {'Rank':<5s} {'Feature':<50s} {'Importance':>10s}")
+    print(f"  {'-'*5} {'-'*50} {'-'*10}")
+    for i, (fname, imp) in enumerate(fi_pairs[:50]):
+        marker = ""
+        if '_resid' in fname: marker = " [RESID]"
+        elif '_x_school_rate' in fname or '_resid_x_rate' in fname or '_x_ed' in fname: marker = " [INTERACT]"
+        elif '_school_pctile' in fname: marker = " [PCTILE]"
+        elif fname.startswith('school_base_rate'): marker = " [SCHOOL_RATE]"
+        elif 'ed_boost' in fname or 'ed2_boost' in fname: marker = " [ED_BOOST]"
+        elif fname.startswith('has_'): marker = " [FLAG]"
+        print(f"  {i+1:<5d} {fname:<50s} {imp:>10.2f}{marker}")
+    
+    resid_in_top30 = sum(1 for f, _ in fi_pairs[:30] 
+                         if '_resid' in f or '_x_school_rate' in f or '_school_pctile' in f or 'school_base_rate' in f)
+    print(f"\n  Residualized/interaction features in top 30: {resid_in_top30}")
+
+# ============================================================
+# 12. SAVE RESULTS
+# ============================================================
+elapsed = time.time() - start_time
+
+results = {
+    'version': 'V38.2-pro-v4',
+    'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
+    'elapsed_minutes': elapsed / 60,
+    'changes': [
+        'Use v5 feature matrix (GPA fixed: 40.3% coverage)',
+        'SAT=0 -> NaN + has_sat flag',
+        'TOEFL=0 -> NaN + has_toefl flag',
+        'GPA=0 -> NaN + has_gpa flag',
+        '-1 -> NaN for sentinel columns',
+        'Residualization uses only non-NaN values',
+        'CatBoost native NaN handling',
+        'LGB/XGB use -999 for NaN',
+        'Percentile returns NaN instead of 0.5 for missing',
+    ],
+    'comparison': {
+        'v37_3': {'auc': 0.8697, 'temporal_auc': 0.8410},
+        'v38_2_pro_v3': {'auc': 0.8743, 'temporal_auc': 0.8528},
+    },
+    'temporal_validation': {
+        'per_seed': temporal_results,
+        'avg_blend': float(avg_temporal),
+    },
+    'groupkfold': {
+        'best_3model_blend': float(best_auc),
+        'best_weights': [float(w) for w in best_weights],
+        'rank_blend': float(rank_auc),
+    },
+    'final_metrics': {
+        'auc': float(final_auc),
+        'brier': float(final_brier),
+        'logloss': float(final_logloss),
+    },
+    'n_features': len(feature_cols_final) if feature_cols_final else 0,
+    'feature_importance': [[f, float(i)] for f, i in fi_pairs[:50]] if feature_cols_final and all_fi else [],
+}
+
+with open(os.path.join(OUTPUT_DIR, 'v38_2_pro_v4_results.json'), 'w') as f:
+    json.dump(results, f, indent=2)
+
+oof_df = df_base[['student_id', 'school', 'year', TARGET]].copy()
+oof_df['cb_pred'] = cb_avg
+oof_df['lgb_pred'] = lgb_avg
+oof_df['xgb_pred'] = xgb_avg
+oof_df['final_pred'] = final_blend_prob
+oof_df.to_csv(os.path.join(OUTPUT_DIR, 'v38_2_pro_v5_oof_predictions.csv'), index=False)
+
+print(f"\n{'='*70}")
+print(f"  V38.2-PRO-V5 COMPLETE")
+print(f"  Total time: {elapsed/60:.1f} minutes")
+print(f"  Features: {len(feature_cols_final) if feature_cols_final else 'N/A'}")
+print(f"  GroupKFold AUC: {final_auc:.4f} (V37.3: 0.8697, V38.2-PRO-V4: 0.8758)")
+print(f"  Temporal AUC:   {avg_temporal:.4f} (V37.3: 0.8410, V38.2-PRO-V4: 0.8555)")
+print(f"{'='*70}")