Upload train_v38_2_pro_v11.py with huggingface_hub

train_v38_2_pro_v11.py

@@ -0,0 +1,1397 @@
+"""
+====================================================================
+V38.2-PRO-V11 MODEL - Pruning + Hyperparameter Optimization
+====================================================================
+Carries forward all V10 features, PLUS:
+NEW #22: Aggressive feature pruning (150 -> 100 top features)
+NEW #23: Hyperparameter tuning (deeper trees, stronger regularization)
+NEW #24: 3 new domain-specific interaction features
+NEW #25: Wider ensemble weight search with finer granularity
+
+ABLATION EXPERIMENT (controlled by EXPERIMENT_MODE):
+  "A" = Full model with all features (pruned + tuned)
+  "B" = Full model - act_bert_pca (replace with labels)
+  "C" = Baseline (no new labels, control)
+====================================================================
+"""
+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, StandardScaler
+from sklearn.decomposition import PCA
+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 = 100  # V11: Aggressive pruning from 150 -> 100
+start_time = time.time()
+
+# ============================================================
+# EXPERIMENT MODE - controls ablation variant
+# ============================================================
+# "A" = V8 + new labels (keep act_bert_pca)
+# "B" = V8 + new labels - act_bert_pca (replace BERT with labels)
+# "C" = V8 baseline (no new labels, keep BERT) = control
+EXPERIMENT_MODE = os.environ.get('V9_MODE', 'A')
+ABLATE_PS_BERT = False  # Keep PS BERT for now (separate concern)
+
+# Activity LLM label columns
+ACT_LABEL_COLS = [
+    'activity_uniqueness', 'impact_quantifiability', 'academic_depth',
+    'social_impact_depth', 'institutional_prestige', 'activity_diversity',
+    'entrepreneurial_initiative', 'cross_activity_synergy',
+    'intellectual_generosity', 'writing_craft', 'personal_voice',
+    'info_architecture', 'tone_calibration'
+]
+N_ACT_LABEL_PCA = 5  # Reduce 13 labels to 5 PCA components
+
+# Supp V2 expanded columns (pre-computed in V10 CSV)
+SUPP_ROW_COLS = [
+    'supp_school_specific_program_references', 'supp_school_specific_faculty_mentions',
+    'supp_school_specific_campus_features', 'supp_prompt_specific_alignment',
+    'supp_personal_connection_to_school', 'supp_intellectual_engagement_depth',
+    'supp_extracurricular_alignment', 'supp_values_alignment_with_school',
+    'supp_specific_future_contribution', 'supp_unique_personal_context', 'supp_composite',
+]
+SUPP_STUDENT_AVG_COLS = [
+    'supp_avg_school_specific_program_references', 'supp_avg_school_specific_faculty_mentions',
+    'supp_avg_school_specific_campus_features', 'supp_avg_prompt_specific_alignment',
+    'supp_avg_personal_connection_to_school', 'supp_avg_intellectual_engagement_depth',
+    'supp_avg_extracurricular_alignment', 'supp_avg_values_alignment_with_school',
+    'supp_avg_specific_future_contribution', 'supp_avg_unique_personal_context',
+]
+SUPP_STUDENT_MAX_COLS = [
+    'supp_max_school_specific_program_references', 'supp_max_school_specific_faculty_mentions',
+    'supp_max_school_specific_campus_features', 'supp_max_prompt_specific_alignment',
+    'supp_max_personal_connection_to_school', 'supp_max_intellectual_engagement_depth',
+    'supp_max_extracurricular_alignment', 'supp_max_values_alignment_with_school',
+    'supp_max_specific_future_contribution', 'supp_max_unique_personal_context',
+]
+SUPP_STUDENT_AGG_COLS = ['supp_student_avg_composite', 'supp_student_max_composite', 'supp_student_std_composite', 'supp_n_scored']
+SUPP_BINARY_COLS = ['supp_has_campus_feature', 'supp_has_faculty_mention', 'supp_has_future_contribution',
+                    'supp_has_personal_connection', 'supp_has_program_ref', 'supp_has_strong_supp', 'supp_high_specificity']
+SUPP_ALL_COLS = SUPP_ROW_COLS + SUPP_STUDENT_AVG_COLS + SUPP_STUDENT_MAX_COLS + SUPP_STUDENT_AGG_COLS + SUPP_BINARY_COLS
+
+def safe_num(v, default=np.nan):
+    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
+# ============================================================
+print("=" * 70)
+print(f"  V38.2-PRO-V11: PRUNING + HYPERPARAMETER OPTIMIZATION")
+print(f"  EXPERIMENT MODE = {EXPERIMENT_MODE}")
+print("=" * 70)
+mode_desc = {
+    'A': 'V8 + 13 new labels (keep BERT)',
+    'B': 'V8 + 13 new labels - act_bert_pca (replace)',
+    'C': 'V8 baseline (no new labels, control)',
+}
+print(f"  Mode description: {mode_desc.get(EXPERIMENT_MODE, 'UNKNOWN')}")
+
+# Load main feature matrix (V10 includes PS V5 + expanded Supp + act labels)
+v10_path = os.path.join(DATA_DIR, 'v38_2_integrated_features_v10.csv')
+v9_path = os.path.join(DATA_DIR, 'v38_2_integrated_features_v9.csv')
+v8_path = os.path.join(DATA_DIR, 'v38_2_integrated_features_v8.csv')
+if os.path.exists(v10_path):
+    df_raw = pd.read_csv(v10_path)
+    print(f"V10 features loaded (PS V5 + expanded Supp): {df_raw.shape}")
+elif os.path.exists(v9_path):
+    df_raw = pd.read_csv(v9_path)
+    print(f"V9 features loaded: {df_raw.shape}")
+elif os.path.exists(v8_path):
+    df_raw = pd.read_csv(v8_path)
+    print(f"V8 features loaded: {df_raw.shape}")
+else:
+    raise FileNotFoundError("No feature matrix found!")
+
+# Load activity LLM labels
+act_labels_path = os.path.join(DATA_DIR, 'act_labels_v2_results.csv')
+act_labels_df = None
+if EXPERIMENT_MODE in ['A', 'B'] and os.path.exists(act_labels_path):
+    act_labels_df = pd.read_csv(act_labels_path)
+    print(f"Activity LLM labels loaded: {act_labels_df.shape}")
+    print(f"  Labels: {[c for c in act_labels_df.columns if c != 'student_id']}")
+elif EXPERIMENT_MODE in ['A', 'B']:
+    print(f"WARNING: act_labels_v2_results.csv not found! Falling back to mode C")
+    EXPERIMENT_MODE = 'C'
+
+# 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'),
+]:
+    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 for 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. MERGE ACTIVITY LLM LABELS INTO MAIN DATAFRAME
+# ============================================================
+if act_labels_df is not None and EXPERIMENT_MODE in ['A', 'B']:
+    # Merge on student_id
+    n_before = len(df_raw)
+    df_raw = df_raw.merge(act_labels_df, on='student_id', how='left')
+    assert len(df_raw) == n_before, f"Merge changed row count! {n_before} -> {len(df_raw)}"
+    
+    n_with_labels = df_raw[ACT_LABEL_COLS[0]].notna().sum()
+    n_without = df_raw[ACT_LABEL_COLS[0]].isna().sum()
+    print(f"\n  Activity labels merged: {n_with_labels} rows with labels, {n_without} without ({n_without/len(df_raw)*100:.1f}% NaN)")
+
+# ============================================================
+# 3. DATA CLEANING & QUALITY FIXES (same as V8)
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  DATA QUALITY FIXES (V8 inherited)")
+print(f"{'='*70}")
+
+# Filter years
+df = df_raw[~df_raw['year'].isin([2018, 2019])].copy().reset_index(drop=True)
+print(f"After filtering 2018-2019: {df.shape}")
+
+# FIX #1: SAT=0 -> NaN
+sat_zero = (df['sat'] == 0).sum()
+df['has_sat'] = (df['sat'] > 0).astype(int)
+df.loc[df['sat'] == 0, 'sat'] = np.nan
+print(f"  FIX #1: SAT=0 -> NaN: {sat_zero} rows")
+
+# FIX #2: TOEFL=0 -> NaN
+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")
+
+# FIX #3: GPA=0 -> NaN
+gpa_zero = (df['gpa'] == 0).sum()
+df.loc[df['gpa'] == 0, 'gpa'] = np.nan
+if 'has_gpa' not in df.columns:
+    df['has_gpa'] = df['gpa'].notna().astype(int)
+print(f"  FIX #3: GPA=0 -> NaN: {gpa_zero} rows")
+
+# FIX #4: -1 -> NaN
+sentinel_cols = ['taste_yearly_admits_log']
+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
+        if n_neg1 > 0:
+            print(f"  FIX #4: {col}: -1 -> NaN: {n_neg1} rows")
+
+# FIX #5: ps_bert -> NaN for has_ps=0
+ps_bert_cols = [c for c in df.columns if c.startswith('ps_bert_pca_')]
+no_ps_mask = df['has_ps'] == 0
+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: {no_ps_mask.sum()} rows")
+
+# FIX #6: ps2_* -> NaN for has_ps=0
+ps2_score_cols = [c for c in df.columns if c.startswith('ps2_') and c != 'ps2_essay_type']
+for col in ps2_score_cols:
+    df.loc[no_ps_mask, col] = np.nan
+print(f"  FIX #6: ps2_* -> NaN for has_ps=0: {no_ps_mask.sum()} rows")
+
+# FIX #6b: Remove ps2_is_cliche_topic
+if 'ps2_is_cliche_topic' in df.columns:
+    df.drop(columns=['ps2_is_cliche_topic'], inplace=True)
+
+# FIX #16b (V9+PS_V5): ps5_* and ps_* V5 features -> NaN for has_ps=0
+ps5_cols = [c for c in df.columns if c.startswith('ps5_') or c in [
+    'ps_word_count_v5', 'ps_flesch_reading_ease', 'ps_flesch_kincaid_grade',
+    'ps_gunning_fog', 'ps_coleman_liau', 'ps_lexical_diversity',
+    'ps_sentence_count', 'ps_avg_sentence_length', 'ps_sentence_length_std',
+    'ps_max_sentence_length', 'ps_min_sentence_length',
+    'ps_sentiment_compound', 'ps_sentiment_positive', 'ps_sentiment_negative', 'ps_sentiment_neutral',
+    'ps_paragraph_count', 'ps_i_count', 'ps_i_ratio', 'ps_we_count', 'ps_my_count',
+    'ps_question_count', 'ps_exclamation_count', 'ps_has_dialogue', 'ps_quote_count',
+    'ps_avg_word_length', 'ps_long_word_ratio', 'ps_transition_count', 'ps_power_word_count']]
+for col in ps5_cols:
+    if col in df.columns:
+        df.loc[no_ps_mask, col] = np.nan
+print(f"  FIX #16b (PS_V5): {len(ps5_cols)} ps5/ps_v5 features -> NaN for has_ps=0: {no_ps_mask.sum()} rows")
+
+# Ablation: Remove ps_bert if flag set
+if ABLATE_PS_BERT and ps_bert_cols:
+    df.drop(columns=ps_bert_cols, inplace=True)
+    print(f"  ABLATION: Removed {len(ps_bert_cols)} ps_bert_pca columns")
+
+# FIX #8: ps_word_count -> NaN for has_ps=0
+if 'ps_word_count' in df.columns:
+    df.loc[no_ps_mask, 'ps_word_count'] = np.nan
+
+# FIX #9: ps_flag_* -> NaN for has_ps=0
+ps_flag_cols = [c for c in df.columns if c.startswith('ps_flag_')]
+for col in ps_flag_cols:
+    df.loc[no_ps_mask, col] = np.nan
+
+# FIX #10: honors_* -> NaN for honors_count=0
+no_honors_mask = df['honors_count'] == 0
+honors_numeric_cols = [c for c in ['honors_max_score', 'honors_avg_score', 'honors_min_score',
+                       'honors_total_score', 'honors_quality_ratio',
+                       'honors_has_top_tier', 'honors_tier1_count', 'honors_tier2_count',
+                       'honors_has_national'] if c in df.columns]
+for col in honors_numeric_cols:
+    df.loc[no_honors_mask, col] = np.nan
+df['has_honors'] = (df['honors_count'] > 0).astype(int)
+
+# FIX #11: act_bert_pca_* -> NaN for act_total_count=0
+no_act_mask = df['act_total_count'] == 0
+act_bert_cols = [c for c in df.columns if c.startswith('act_bert_pca_')]
+
+# V9 MODE B: Remove act_bert_pca entirely
+if EXPERIMENT_MODE == 'B' and act_bert_cols:
+    df.drop(columns=act_bert_cols, inplace=True)
+    print(f"  V9 MODE B: REMOVED {len(act_bert_cols)} act_bert_pca columns (replaced by LLM labels)")
+    act_bert_cols = []
+else:
+    for col in act_bert_cols:
+        df.loc[no_act_mask, col] = np.nan
+    print(f"  FIX #11: act_bert_pca -> NaN for act_total_count=0: {no_act_mask.sum()} rows")
+
+# FIX #12: act_slot_pca_* -> NaN for act_total_count=0
+act_slot_cols = [c for c in df.columns if c.startswith('act_slot_pca_')]
+for col in act_slot_cols:
+    df.loc[no_act_mask, col] = np.nan
+
+# FIX #13-14: cuilu -> NaN when cuilu_hs_total=0
+no_cuilu_mask = df['cuilu_hs_total'] == 0
+for col in ['cuilu_hs_to_univ', 'cuilu_hs_to_univ_pct', 'cuilu_hs_top10_rate',
+            'cuilu_hs_top20_rate', 'cuilu_hs_top10_count', 'cuilu_hs_top20_count']:
+    if col in df.columns:
+        df.loc[no_cuilu_mask, col] = np.nan
+
+# FIX #15: Remove taste_yearly_admits_log
+if 'taste_yearly_admits_log' in df.columns:
+    df.drop(columns=['taste_yearly_admits_log'], inplace=True)
+
+df['has_act'] = (df['act_total_count'] > 0).astype(int)
+df['has_cuilu'] = (df['cuilu_hs_total'] > 0).astype(int)
+
+# V9 NEW #16: Set activity labels to NaN for act_total_count=0
+if EXPERIMENT_MODE in ['A', 'B']:
+    act_label_cols_in_df = [c for c in ACT_LABEL_COLS if c in df.columns]
+    for col in act_label_cols_in_df:
+        df.loc[no_act_mask, col] = np.nan
+    n_label_nan = no_act_mask.sum()
+    print(f"  V9 NEW #16: Activity labels -> NaN for act_total_count=0: {n_label_nan} rows")
+    
+    # Also create has_act_labels flag
+    df['has_act_labels'] = df[act_label_cols_in_df[0]].notna().astype(int)
+    n_with = df['has_act_labels'].sum()
+    print(f"    has_act_labels=1: {n_with}, =0: {len(df)-n_with}")
+    
+    # Create aggregate features from labels
+    df['act_label_mean'] = df[act_label_cols_in_df].mean(axis=1)
+    df['act_label_max'] = df[act_label_cols_in_df].max(axis=1)
+    df['act_label_min'] = df[act_label_cols_in_df].min(axis=1)
+    df['act_label_std'] = df[act_label_cols_in_df].std(axis=1)
+    df['act_label_range'] = df['act_label_max'] - df['act_label_min']
+    print(f"    Created aggregate features: act_label_mean/max/min/std/range")
+
+print(f"\n  All V8 fixes applied. Shape: {df.shape}")
+
+# Portfolio size transform
+df['portfolio_size_raw'] = df['portfolio_size'].copy()
+df['portfolio_size'] = np.log1p(df['portfolio_size'].clip(upper=20))
+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)
+
+# ED2 split
+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'
+    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)
+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 (same as V8)
+# ============================================================
+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}"
+            oq = item.get('overall_quality', 0)
+            if isinstance(oq, (int, float)) and oq <= 1:
+                continue
+            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
+            supp_scores[key] = scores
+
+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
+# ============================================================
+STUDENT_LEVEL_NUMERIC = [
+    'toefl', 'sat', 'gpa',
+    'act_total_count', 'act_type_diversity',
+    *[f'act_slot_pca_{i}' for i in range(20)],
+    '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', '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',
+    'hs_to_univ_hist_rate', 'hs_to_univ_hist_rate_smoothed', 'hs_to_univ_hist_admits',
+    'hs_overall_hist_rate',
+    'summer_max_geili', 'summer_has_elite', 'summer_count',
+    'summer_program_count', 'summer_difficulty_max',
+    'ps2_character_revelation', 'ps2_reflection_depth', 'ps2_craft_voice', 'ps2_overall', 'ps2_mean',
+    'ps2_is_ai_written', 'ps2_is_consultant_heavy', 'ps2_is_resume_essay',
+    'ps2_is_trauma_porn', 'ps2_has_factual_concerns',
+    'has_honors', 'has_act', 'has_cuilu',
+]
+
+# Conditionally include act_bert_pca (Mode A keeps, Mode B removes)
+if EXPERIMENT_MODE != 'B':
+    STUDENT_LEVEL_NUMERIC.extend([f'act_bert_pca_{i}' for i in range(16)])
+
+# Conditionally include ps_bert_pca
+if not ABLATE_PS_BERT:
+    STUDENT_LEVEL_NUMERIC.extend([f'ps_bert_pca_{i}' for i in range(16)])
+
+# V9: Include activity LLM labels
+if EXPERIMENT_MODE in ['A', 'B']:
+    STUDENT_LEVEL_NUMERIC.extend(ACT_LABEL_COLS)
+    STUDENT_LEVEL_NUMERIC.extend(['act_label_mean', 'act_label_max', 'act_label_min',
+                                   'act_label_std', 'act_label_range', 'has_act_labels'])
+
+# V9+PS_V5: Include PS V5 hybrid features (LLM extraction + programmatic)
+ps5_feature_cols = [c for c in df.columns if c.startswith('ps5_') or c in [
+    'ps_word_count_v5', 'ps_flesch_reading_ease', 'ps_flesch_kincaid_grade',
+    'ps_gunning_fog', 'ps_coleman_liau', 'ps_lexical_diversity',
+    'ps_sentence_count', 'ps_avg_sentence_length', 'ps_sentence_length_std',
+    'ps_max_sentence_length', 'ps_min_sentence_length',
+    'ps_sentiment_compound', 'ps_sentiment_positive', 'ps_sentiment_negative', 'ps_sentiment_neutral',
+    'ps_paragraph_count', 'ps_i_count', 'ps_i_ratio', 'ps_we_count', 'ps_my_count',
+    'ps_question_count', 'ps_exclamation_count', 'ps_has_dialogue', 'ps_quote_count',
+    'ps_avg_word_length', 'ps_long_word_ratio', 'ps_transition_count', 'ps_power_word_count']]
+STUDENT_LEVEL_NUMERIC.extend(ps5_feature_cols)
+print(f"  PS V5 hybrid features added: {len(ps5_feature_cols)} columns")
+
+# PS-related features for special school_mean handling
+PS_RELATED_FEATURES = set([
+    *[f'ps_bert_pca_{i}' for i in range(16)],
+    'ps2_character_revelation', 'ps2_reflection_depth', 'ps2_craft_voice',
+    'ps2_overall', 'ps2_mean',
+    'ps2_is_ai_written', 'ps2_is_consultant_heavy', 'ps2_is_resume_essay',
+    'ps2_is_trauma_porn', 'ps2_has_factual_concerns',
+    'ps_word_count',
+])
+# V9+PS_V5: Add PS V5 features to PS_RELATED_FEATURES for proper residualization
+PS_RELATED_FEATURES.update(set(ps5_feature_cols))
+
+# V10: Include expanded Supp features (pre-computed in CSV)
+supp_in_data = [c for c in SUPP_ALL_COLS if c in df.columns]
+STUDENT_LEVEL_NUMERIC.extend(supp_in_data)
+print(f"  Supp V2 expanded features added: {len(supp_in_data)} columns")
+# Row-level supp features are school-level (student x school)
+# Student-level supp aggregates capture overall supp writing abilityn
+
+# V9: Activity label features need special handling (only has_act_labels=1 for school_mean)
+ACT_LABEL_FEATURES = set(ACT_LABEL_COLS + ['act_label_mean', 'act_label_max', 'act_label_min',
+                                             'act_label_std', 'act_label_range'])
+
+# Add act_type_count columns
+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 existing
+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',
+    'hs_to_univ_hist_rate_smoothed',
+    'summer_max_geili',
+    'ps2_overall', 'ps2_character_revelation', 'ps2_craft_voice',
+]
+
+# V9: Add top activity labels to key features for interactions
+if EXPERIMENT_MODE in ['A', 'B']:
+    KEY_STUDENT_FEATURES.extend(['act_label_mean', 'social_impact_depth',
+                                  'tone_calibration', 'academic_depth'])
+
+LLM_INTERACTION_FEATURES = [
+    'llm_act_mean', 'llm_act_max', 'llm_act_avg_power_index',
+    'supp_mean', 'supp_max', 'supp_composite', 'supp_student_avg_composite',
+    'ps_mean', 'major_difficulty',
+    'ps2_mean', 'ps2_overall',
+]
+
+# ============================================================
+# 5. BUILD FEATURES
+# ============================================================
+def build_features_base(df):
+    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 - V10: already pre-computed in CSV, just compute aggregates
+    # supp_composite and row-level scores are already in the dataframe
+    
+    # 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)))
+    
+    # Aggregates
+    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)
+    
+    # V10: Use pre-computed supp_composite as supp_mean, and compute supp_max from row-level scores
+    supp_row_in_df = [c for c in SUPP_ROW_COLS if c in df.columns and c != 'supp_composite']
+    if supp_row_in_df:
+        valid_supp = df[supp_row_in_df]
+        df['supp_mean'] = valid_supp.mean(axis=1)
+        df['supp_max'] = valid_supp.max(axis=1)
+    elif 'supp_composite' in df.columns:
+        df['supp_mean'] = df['supp_composite']
+        df['supp_max'] = df['supp_composite']
+    else:
+        df['supp_mean'] = np.nan
+        df['supp_max'] = np.nan
+    
+    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
+    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']
+    
+    # V9: Activity label interactions
+    if EXPERIMENT_MODE in ['A', 'B'] and 'act_label_mean' in df.columns:
+        df['act_label_x_supp'] = df['act_label_mean'] * df['supp_mean']
+        df['act_label_x_llm_act'] = df['act_label_mean'] * df['llm_act_mean']
+        if 'ps2_mean' in df.columns:
+            df['act_label_x_ps2'] = df['act_label_mean'] * df['ps2_mean']
+        print(f"    V9: Created activity label interaction features")
+    
+    # V11 NEW #24: Domain-specific interaction features
+    # GPA × summer elite: academic depth in elite programs
+    if 'gpa' in df.columns and 'summer_has_elite' in df.columns:
+        df['gpa_x_summer_elite'] = df['gpa'] * df['summer_has_elite']
+    # Honors × activity label: well-roundedness signal
+    if 'honors_avg_score' in df.columns and 'act_label_mean' in df.columns:
+        df['honors_x_act_label'] = df['honors_avg_score'] * df['act_label_mean']
+    # Portfolio size × supp composite: application completeness × quality
+    if 'portfolio_size' in df.columns and 'supp_student_avg_composite' in df.columns:
+        df['portfolio_x_supp_avg'] = df['portfolio_size'] * df['supp_student_avg_composite']
+    print(f"    V11: Created 3 new domain-specific interaction features")
+    
+    # Categoricals
+    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):
+    df = df.copy()
+    
+    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)
+    
+    # ED boost
+    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)
+    
+    # Residualize student features
+    student_feat_available = [c for c in STUDENT_LEVEL_NUMERIC if c in df.columns]
+    train_has_ps = train_df[train_df['has_ps'] == 1]
+    
+    # V9: Pre-compute has_act_labels=1 subset for activity label features
+    if 'has_act_labels' in train_df.columns:
+        train_has_act_labels = train_df[train_df['has_act_labels'] == 1]
+    else:
+        train_has_act_labels = train_df
+    
+    resid_cols = []
+    for col in student_feat_available:
+        resid_col = f'{col}_resid'
+        
+        if col in PS_RELATED_FEATURES:
+            school_mean_series = train_has_ps.groupby('school')[col].mean()
+        elif col in ACT_LABEL_FEATURES:
+            # V9: Use has_act_labels=1 subset for activity label features
+            school_mean_series = train_has_act_labels.groupby('school')[col].mean()
+        elif col.startswith('honors_') and col != 'honors_count':
+            train_has_honors = train_df[train_df['honors_count'] > 0]
+            school_mean_series = train_has_honors.groupby('school')[col].mean()
+        elif col.startswith('act_bert_pca_') or col.startswith('act_slot_pca_'):
+            train_has_act = train_df[train_df['act_total_count'] > 0]
+            school_mean_series = train_has_act.groupby('school')[col].mean()
+        elif col.startswith('cuilu_hs_to_univ') or col in ['cuilu_hs_top10_rate', 'cuilu_hs_top20_rate', 'cuilu_hs_top10_count', 'cuilu_hs_top20_count']:
+            train_has_cuilu = train_df[train_df['cuilu_hs_total'] > 0]
+            school_mean_series = train_has_cuilu.groupby('school')[col].mean()
+        else:
+            school_mean_series = train_df.groupby('school')[col].mean()
+        
+        col_school_mean = df['school'].map(school_mean_series)
+        df[resid_col] = df[col] - col_school_mean
+        resid_cols.append(resid_col)
+    
+    # V9 NEW #17: Activity label PCA (reduce multicollinearity)
+    act_label_pca_cols = []
+    if EXPERIMENT_MODE in ['A', 'B']:
+        act_label_cols_in_df = [c for c in ACT_LABEL_COLS if c in df.columns]
+        if act_label_cols_in_df:
+            # Fit PCA on training data only
+            train_label_data = train_df[act_label_cols_in_df].dropna()
+            if len(train_label_data) > N_ACT_LABEL_PCA * 2:
+                scaler = StandardScaler()
+                pca = PCA(n_components=N_ACT_LABEL_PCA, random_state=42)
+                
+                train_scaled = scaler.fit_transform(train_label_data)
+                pca.fit(train_scaled)
+                
+                # Transform all data
+                all_label_data = df[act_label_cols_in_df].copy()
+                # Fill NaN with column mean for PCA transform, then set back to NaN
+                has_any_label = all_label_data.notna().any(axis=1)
+                fill_means = train_label_data.mean()
+                all_label_filled = all_label_data.fillna(fill_means)
+                all_scaled = scaler.transform(all_label_filled)
+                pca_result = pca.transform(all_scaled)
+                
+                for i in range(N_ACT_LABEL_PCA):
+                    col_name = f'act_label_pca_{i}'
+                    df[col_name] = pca_result[:, i]
+                    # Set to NaN where original labels were all NaN
+                    df.loc[~has_any_label, col_name] = np.nan
+                    act_label_pca_cols.append(col_name)
+                
+                var_explained = pca.explained_variance_ratio_
+                print(f"    V9 NEW #17: Activity label PCA: {len(act_label_cols_in_df)} -> {N_ACT_LABEL_PCA} components")
+                print(f"      Variance explained: {var_explained.sum():.3f} ({', '.join(f'{v:.3f}' for v in var_explained)})")
+    
+    # ps2_mean_school_pctile
+    pctile_ps_cols = []
+    if 'ps2_mean' in df.columns:
+        ps_pctile_col = 'ps2_mean_school_pctile'
+        school_ps_distributions = {}
+        for school_id in train_has_ps['school'].unique():
+            vals = train_has_ps[train_has_ps['school'] == school_id]['ps2_mean'].dropna().values
+            if len(vals) > 2:
+                school_ps_distributions[school_id] = vals
+        
+        def compute_ps_pctile(row, sd=school_ps_distributions):
+            school_id = row['school']
+            val = row['ps2_mean']
+            if pd.isna(val) or school_id not in sd:
+                return np.nan
+            return np.mean(sd[school_id] <= val)
+        
+        df[ps_pctile_col] = df.apply(compute_ps_pctile, axis=1)
+        pctile_ps_cols.append(ps_pctile_col)
+    
+    # V9 NEW #18: Activity label school percentile
+    act_label_pctile_cols = []
+    if EXPERIMENT_MODE in ['A', 'B'] and 'act_label_mean' in df.columns:
+        al_pctile_col = 'act_label_mean_school_pctile'
+        school_al_distributions = {}
+        for school_id in train_has_act_labels['school'].unique():
+            vals = train_has_act_labels[train_has_act_labels['school'] == school_id]['act_label_mean'].dropna().values
+            if len(vals) > 2:
+                school_al_distributions[school_id] = vals
+        
+        def compute_al_pctile(row, sd=school_al_distributions):
+            school_id = row['school']
+            val = row['act_label_mean']
+            if pd.isna(val) or school_id not in sd:
+                return np.nan
+            return np.mean(sd[school_id] <= val)
+        
+        df[al_pctile_col] = df.apply(compute_al_pctile, axis=1)
+        act_label_pctile_cols.append(al_pctile_col)
+        n_valid = df[al_pctile_col].notna().sum()
+        print(f"    V9 NEW #18: {al_pctile_col}: {n_valid} valid values")
+    
+    # Interactions
+    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']
+            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)
+    
+    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)
+    
+    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')
+    
+    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')
+    
+    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)
+    
+    if 'ps2_mean_school_pctile' in df.columns:
+        df['ps2_pctile_x_school_rate'] = df['ps2_mean_school_pctile'] * df['school_base_rate']
+        interaction_cols.append('ps2_pctile_x_school_rate')
+    
+    # V9 NEW #19: Activity label percentile x school_base_rate
+    if 'act_label_mean_school_pctile' in df.columns:
+        df['act_label_pctile_x_school_rate'] = df['act_label_mean_school_pctile'] * df['school_base_rate']
+        interaction_cols.append('act_label_pctile_x_school_rate')
+    
+    # Student percentile within school
+    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 np.mean(sd[school_id] <= val)
+        
+        df[pctile_col] = df.apply(compute_pctile, axis=1)
+        pctile_cols.append(pctile_col)
+    
+    pctile_cols.extend(pctile_ps_cols)
+    pctile_cols.extend(act_label_pctile_cols)
+    
+    # Student competitiveness
+    if all(c in df.columns for c in ['toefl', 'sat', 'honors_max_score']):
+        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)
+            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)
+    
+    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]
+    
+    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',
+                                      'ps2_mean_school_pctile', 'ps2_pctile_x_school_rate',
+                                      'has_honors', 'has_act', 'has_cuilu'}
+        # V9: Always keep activity label features
+        if EXPERIMENT_MODE in ['A', 'B']:
+            must_keep.update(set(act_label_pca_cols))
+            must_keep.update({'act_label_mean', 'act_label_max', 'act_label_std',
+                             'act_label_mean_school_pctile', 'act_label_pctile_x_school_rate',
+                             'has_act_labels', 'act_label_x_supp', 'act_label_x_llm_act'})
+        feature_cols = [c for c in feature_cols if c in selected_features or c in must_keep]
+    
+    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) + len(act_label_pca_cols) + 5
+    print(f"    Features: {len(resid_cols)} resid + {len(interaction_cols)} interact + {len(pctile_cols)} pctile + {len(act_label_pca_cols)} label_pca = 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}")
+
+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)
+    
+    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()
+
+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 30 features:")
+for i, (fname, imp) in enumerate(fi_pairs[:30]):
+    marker = ""
+    if 'act_label' in fname or fname in ACT_LABEL_COLS: marker = " [ACT_LABEL_V9]"
+    elif '_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]"
+    elif 'ps2_' in fname: marker = " [PS2]"
+    elif 'ps5_' in fname or fname.startswith('ps_') and 'bert' not in fname: marker = " [PS_V5]"
+    elif 'supp_' in fname: marker = " [SUPP_V2]"
+    elif 'act_bert_pca' in fname: marker = " [ACT_BERT]"
+    print(f"    {i+1:3d}. {fname:<55s} {imp:>8.2f}{marker}")
+
+# Count V9 new features in top 50
+v9_in_top50 = sum(1 for f, _ in fi_pairs[:50] if 'act_label' in f or f in ACT_LABEL_COLS)
+ps5_in_top50 = sum(1 for f, _ in fi_pairs[:50] if 'ps5_' in f or (f.startswith('ps_') and 'bert' not in f and f in ps5_feature_cols))
+supp_v2_in_top50 = sum(1 for f, _ in fi_pairs[:50] if 'supp_' in f)
+print(f"  PS V5 features in top 50: {ps5_in_top50}")
+print(f"  Supp V2 features in top 50: {supp_v2_in_top50}")
+bert_in_top50 = sum(1 for f, _ in fi_pairs[:50] if 'act_bert_pca' in f)
+print(f"\n  V9 activity label features in top 50: {v9_in_top50}")
+print(f"  act_bert_pca features in top 50: {bert_in_top50}")
+
+# ============================================================
+# 8. TEMPORAL VALIDATION
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  TEMPORAL VALIDATION (2020-2023 -> 2024)")
+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]
+    
+    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:
+        cb_t = CatBoostClassifier(
+            iterations=1500, depth=8, learning_rate=0.02,
+            l2_leaf_reg=10, random_seed=seed, verbose=0,
+            cat_features=cat_idx_t, eval_metric='AUC',
+            early_stopping_rounds=100, min_data_in_leaf=15,
+            random_strength=2, bagging_temperature=0.8)
+        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_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.02, 'num_leaves': 63, 'max_depth': 7,
+            'min_child_samples': 30, 'reg_alpha': 0.5, 'reg_lambda': 3.0,
+            'feature_fraction': 0.6, 'bagging_fraction': 0.75, 'bagging_freq': 5,
+            'seed': seed
+        }
+        lgb_model = lgb.train(lgb_params, lgb_tr, num_boost_round=2000,
+                              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()
+        
+        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': 7, 'learning_rate': 0.02,
+            'subsample': 0.75, 'colsample_bytree': 0.6,
+            'reg_alpha': 0.5, 'reg_lambda': 3.0,
+            'min_child_weight': 7,
+            'seed': seed, 'verbosity': 0
+        }
+        xgb_model = xgb.train(xgb_params, dtrain, num_boost_round=2000,
+                              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}")
+    print(f"  Delta vs V37.3:        {avg_temporal - 0.8410:+.4f}")
+    print(f"  Delta vs V38.2-PRO-V4: {avg_temporal - 0.8555:+.4f}")
+    print(f"  Delta vs V38.2-PRO-V8: {avg_temporal - 0.8548:+.4f}")
+    print(f"  Delta vs V38.2-PRO-V9:  {avg_temporal - 0.8594:+.4f}")
+    print(f"  Delta vs V38.2-PRO-V10: {avg_temporal - 0.8631:+.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]
+        
+        cb = CatBoostClassifier(
+            iterations=2000, depth=8, learning_rate=0.02,
+            l2_leaf_reg=10, random_seed=seed, verbose=0,
+            cat_features=cat_idx_f, eval_metric='AUC',
+            early_stopping_rounds=100, min_data_in_leaf=15,
+            random_strength=2, bagging_temperature=0.8)
+        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()
+        
+        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.02, 'num_leaves': 63, 'max_depth': 7,
+            'min_child_samples': 30, 'reg_alpha': 0.5, 'reg_lambda': 3.0,
+            'feature_fraction': 0.6, 'bagging_fraction': 0.75, 'bagging_freq': 5,
+            'seed': seed
+        }
+        lgb_model = lgb.train(lgb_params, lgb_tr, num_boost_round=2000,
+                              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': 7, 'learning_rate': 0.02,
+            'subsample': 0.75, 'colsample_bytree': 0.6,
+            'reg_alpha': 0.5, 'reg_lambda': 3.0,
+            'min_child_weight': 7,
+            'seed': seed, 'verbosity': 0
+        }
+        xgb_model = xgb.train(xgb_params, dtrain, num_boost_round=2000,
+                              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 (MODE={EXPERIMENT_MODE})")
+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}")
+
+# V11: Finer granularity weight search (0.02 step)
+best_auc = 0
+best_weights = (0.45, 0.20, 0.35)
+for w_cb in np.arange(0.30, 0.65, 0.02):
+    for w_lgb in np.arange(0.05, 0.40, 0.02):
+        w_xgb = 1.0 - w_cb - w_lgb
+        if w_xgb < 0.05 or w_xgb > 0.55: 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"  Delta vs V38.2-PRO-V8: {best_auc - 0.8753:+.4f}")
+print(f"  Delta vs V38.2-PRO-V9:  {best_auc - 0.8772:+.4f}")
+print(f"  Delta vs V38.2-PRO-V10: {best_auc - 0.8784:+.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}")
+print(f"    Brier:    {final_brier:.4f}")
+print(f"    LogLoss:  {final_logloss:.4f}")
+
+# ============================================================
+# 11. FEATURE IMPORTANCE
+# ============================================================
+print(f"\n{'='*70}")
+print(f"  FEATURE IMPORTANCE (MODE={EXPERIMENT_MODE})")
+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':<55s} {'Importance':>10s}")
+    print(f"  {'-'*5} {'-'*55} {'-'*10}")
+    for i, (fname, imp) in enumerate(fi_pairs[:50]):
+        marker = ""
+        if 'act_label' in fname or fname in ACT_LABEL_COLS: marker = " [ACT_LABEL_V9]"
+        elif '_resid' in fname: marker = " [RESID]"
+        elif '_x_school_rate' in fname or '_resid_x_rate' in fname: marker = " [INTERACT]"
+        elif '_school_pctile' in fname: marker = " [PCTILE]"
+        elif fname.startswith('school_base_rate'): marker = " [SCHOOL_RATE]"
+        elif 'act_bert_pca' in fname: marker = " [ACT_BERT]"
+        elif 'ps2_' in fname: marker = " [PS2]"
+        print(f"  {i+1:<5d} {fname:<55s} {imp:>10.2f}{marker}")
+    
+    v9_in_top30 = sum(1 for f, _ in fi_pairs[:30] if 'act_label' in f or f in ACT_LABEL_COLS)
+    bert_in_top30 = sum(1 for f, _ in fi_pairs[:30] if 'act_bert_pca' in f)
+    print(f"\n  V9 activity label features in top 30: {v9_in_top30}")
+    print(f"  act_bert_pca features in top 30: {bert_in_top30}")
+
+# ============================================================
+# 12. SAVE RESULTS
+# ============================================================
+elapsed = time.time() - start_time
+
+results = {
+    'version': f'V38.2-pro-v11-mode-{EXPERIMENT_MODE}',
+    'experiment_mode': EXPERIMENT_MODE,
+    'mode_description': mode_desc.get(EXPERIMENT_MODE, 'UNKNOWN'),
+    'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
+    'elapsed_minutes': elapsed / 60,
+    'changes': [
+        'All V10 features carried forward',
+        f'EXPERIMENT MODE: {EXPERIMENT_MODE} - {mode_desc.get(EXPERIMENT_MODE)}',
+        'NEW #22: Aggressive feature pruning (150 -> 100)',
+        'NEW #23: Hyperparameter tuning (depth 8, lr 0.02, stronger reg)',
+        'NEW #24: 3 new domain-specific interaction features',
+        'NEW #25: Finer ensemble weight search (0.02 step)',
+    ],
+    'comparison': {
+        'v37_3': {'auc': 0.8697, 'temporal_auc': 0.8410},
+        'v38_2_pro_v4': {'auc': 0.8758, 'temporal_auc': 0.8555},
+        'v38_2_pro_v8': {'auc': 0.8753, 'temporal_auc': 0.8548},
+        'v38_2_pro_v9': {'auc': 0.8772, 'temporal_auc': 0.8594},
+        'v38_2_pro_v10': {'auc': 0.8784, 'temporal_auc': 0.8631},
+    },
+    '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 [],
+}
+
+suffix = f'_mode_{EXPERIMENT_MODE}'
+with open(os.path.join(OUTPUT_DIR, f'v38_2_pro_v11{suffix}_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, f'v38_2_pro_v11{suffix}_oof_predictions.csv'), index=False)
+
+print(f"\n{'='*70}")
+print(f"  V38.2-PRO-V11 MODE={EXPERIMENT_MODE} 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}")
+print(f"  Temporal AUC:   {avg_temporal:.4f}")
+print(f"{'='*70}")