ZMJ/data_processed_7_16/train.py

import sys
import pandas as pd
import numpy as np
from sklearn.model_selection import KFold
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor
from sklearn.linear_model import (
    HuberRegressor, RANSACRegressor, TheilSenRegressor,
    Lasso, ElasticNet, Ridge
)
from sklearn.cross_decomposition import PLSRegression
from sklearn.preprocessing import StandardScaler, RobustScaler
from sklearn.ensemble import RandomForestRegressor
from scipy.stats import pearsonr
import warnings
from sklearn.decomposition import PCA
warnings.filterwarnings('ignore')

# ===== Feature Engineering =====
def feature_engineering(df):
    """Original features plus new robust features"""
    # Original features
    df['volume_weighted_sell'] = df['sell_qty'] * df['volume']
    df['buy_sell_ratio'] = df['buy_qty'] / (df['sell_qty'] + 1e-8)
    df['selling_pressure'] = df['sell_qty'] / (df['volume'] + 1e-8)
    df['effective_spread_proxy'] = np.abs(df['buy_qty'] - df['sell_qty']) / (df['volume'] + 1e-8)
    
    # New robust features
    df['log_volume'] = np.log1p(df['volume'])
    df['bid_ask_imbalance'] = (df['bid_qty'] - df['ask_qty']) / (df['bid_qty'] + df['ask_qty'] + 1e-8)
    df['order_flow_imbalance'] = (df['buy_qty'] - df['sell_qty']) / (df['buy_qty'] + df['sell_qty'] + 1e-8)
    df['liquidity_ratio'] = (df['bid_qty'] + df['ask_qty']) / (df['volume'] + 1e-8)
    
    # Handle infinities and NaN
    df = df.replace([np.inf, -np.inf], np.nan)
    
    # For each column, replace NaN with median for robustness
    for col in df.columns:
        if df[col].isna().any():
            median_val = df[col].median()
            df[col] = df[col].fillna(median_val if not pd.isna(median_val) else 0)
    
    return df

# ===== Configuration =====
class Config:
    ORIGIN_TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/train.parquet"
    ORIGIN_TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/test.parquet"
    TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/ZMJ/max_IC_mixed/train_aggregated.parquet"
    TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/ZMJ/max_IC_mixed/test_aggregated.parquet"
    SUBMISSION_PATH = "/AI4M/users/mjzhang/workspace/DRW/ZMJ/threshold_6_29/sample_submission.csv"
    
    # Original features plus additional market features
    FEATURES = [
        "X863", "X856", "X598", "X862", "X385", "X852", "X603", "X860", "X674",
        "X415", "X345", "X855", "X174", "X302", "X178", "X168", "X612",
        "buy_qty", "sell_qty", "volume", "X888", "X421", "X333",
        "bid_qty", "ask_qty"
    ]
    
    MERGE = False
    LABEL_COLUMN = "label"
    N_FOLDS = 5
    RANDOM_STATE = 42
    # 新增PCA相关配置
    USE_PCA = False  # 是否使用PCA降维
    PCA_N_COMPONENTS = 20  # 降到多少维

def load_data():
    """Load and preprocess data"""
    origin_train_df = pd.read_parquet(Config.ORIGIN_TRAIN_PATH)
    origin_test_df = pd.read_parquet(Config.ORIGIN_TEST_PATH)
    train_df = pd.read_parquet(Config.TRAIN_PATH)
    test_df = pd.read_parquet(Config.TEST_PATH)
    submission_df = pd.read_csv(Config.SUBMISSION_PATH)
    
    Config.AGGREGATE_FEATURES = [col for col in train_df.columns.tolist() if col != 'label']
    
    Config.FEATURES = Config.AGGREGATE_FEATURES
    merged_train_df = train_df
    merged_test_df = test_df
        
    print(f"Loaded data - Train: {merged_train_df.shape}, Test: {merged_test_df.shape}, Submission: {submission_df.shape}")
    print(f"Total features: {len(Config.FEATURES)}")
        
    return merged_train_df.reset_index(drop=True), merged_test_df.reset_index(drop=True), submission_df

# ===== Model Parameters =====
# 只保留XGBoost参数
import math
import xgboost as xgb

train_data, _, _ = load_data()
X_train = train_data[Config.FEATURES].values
y_train = train_data[[Config.LABEL_COLUMN]].values
dtrain = xgb.DMatrix(X_train, label=y_train)

# 余弦退火调度函数
def cosine_annealing(epoch, initial_lr=0.01, T_max=5000, eta_min=1e-4):
    return eta_min + (initial_lr - eta_min) * (1 + math.cos(math.pi * epoch / T_max)) / 2
XGB_PARAMS = {
    "objective": 'reg:squarederror',
    "tree_method": "hist",
    "device": "gpu",
    "colsample_bylevel": 0.4778,
    "colsample_bynode": 0.3628,
    "colsample_bytree": 0.7107,
    "gamma": 1.7095,
    # "learning_rate": 0.04426,
    "learning_rate": 0.2213,
    "max_depth": 20,
    "max_leaves": 12,
    "min_child_weight": 16,
    "n_estimators": 13508,
    "subsample": 0.07567,
    "reg_alpha": 19.3524,
    "reg_lambda": 35.4484,
    'predictor': 'gpu_predictor',
    'random_state': 42,
    'early_stopping_rounds': 50,  # 稍晚早停
    'eval_metric': 'rmse',
    'verbosity': 1
}

# cv_results = xgb.cv(
#     XGB_PARAMS,
#     dtrain,
#     num_boost_round=20000,
#     nfold=5,
#     early_stopping_rounds=50,
#     verbose_eval=True,
#     as_pandas=True
# )
# breakpoint()

# 只保留XGBoost
LEARNERS = [
    {"name": "xgb_baseline", "Estimator": XGBRegressor, "params": XGB_PARAMS, "need_scale": False},
]

# ===== Data Loading =====
def create_time_decay_weights(n: int, decay: float = 0.9) -> np.ndarray:
    """Create time decay weights for more recent data importance"""
    positions = np.arange(n)
    normalized = positions / (n - 1)
    weights = decay ** (1.0 - normalized)
    return weights * n / weights.sum()

# ===== Model Training =====
def get_model_slices(n_samples: int):
    """Define different data slices for training"""
    return [
        {"name": "full_data", "cutoff": 0},
        {"name": "last_75pct", "cutoff": int(0.25 * n_samples)},
        {"name": "last_50pct", "cutoff": int(0.50 * n_samples)},
    ]

def train_single_model(X_train, y_train, X_valid, y_valid, X_test, learner, sample_weights=None):
    """Train a single model with appropriate scaling if needed"""
    if learner["need_scale"]:
        scaler = RobustScaler()  # More robust to outliers than StandardScaler
        X_train_scaled = scaler.fit_transform(X_train)
        X_valid_scaled = scaler.transform(X_valid)
        X_test_scaled = scaler.transform(X_test)
    else:
        X_train_scaled = X_train
        X_valid_scaled = X_valid
        X_test_scaled = X_test
    
    model = learner["Estimator"](**learner["params"])
    
    # Handle different model training approaches
    if learner["name"] in ["xgb_baseline"]:
        model.fit(X_train_scaled, y_train, sample_weight=sample_weights, 
                    eval_set=[(X_valid_scaled, y_valid)], 
                    # eval_metric='rmse',  # 直接在 fit 中指定 eval_metric
                    # early_stopping_rounds=50,
                    verbose=True)
    else:
        # RANSAC, TheilSen, PLS don't support sample weights
        model.fit(X_train_scaled, y_train)
    
    valid_pred = model.predict(X_valid_scaled)
    test_pred = model.predict(X_test_scaled)
    
    return valid_pred, test_pred

def train_and_evaluate(train_df, test_df):
    """只训练XGBoost模型，交叉验证"""
    n_samples = len(train_df)
    model_slices = get_model_slices(n_samples)
    
    # 初始化预测字典
    oof_preds = {
        "xgb_baseline": {s["name"]: np.zeros(n_samples) for s in model_slices}
    }
    test_preds = {
        "xgb_baseline": {s["name"]: np.zeros(len(test_df)) for s in model_slices}
    }
    
    full_weights = create_time_decay_weights(n_samples)
    kf = KFold(n_splits=Config.N_FOLDS, shuffle=True)
    
    for fold, (train_idx, valid_idx) in enumerate(kf.split(train_df), start=1):
        print(f"\n--- Fold {fold}/{Config.N_FOLDS} ---")
        X_valid = train_df.iloc[valid_idx][Config.FEATURES]
        y_valid = train_df.iloc[valid_idx][Config.LABEL_COLUMN]
        X_test = test_df[Config.FEATURES]
        
        for s in model_slices:
            cutoff = s["cutoff"]
            slice_name = s["name"]
            subset = train_df.iloc[cutoff:].reset_index(drop=True)
            rel_idx = train_idx[train_idx >= cutoff] - cutoff
            
            if len(rel_idx) == 0:
                continue
                
            X_train = subset.iloc[rel_idx][Config.FEATURES]
            y_train = subset.iloc[rel_idx][Config.LABEL_COLUMN]
            sw = create_time_decay_weights(len(subset))[rel_idx] if cutoff > 0 else full_weights[train_idx]
            
            print(f"  Training slice: {slice_name}, samples: {len(X_train)}")
            
            # 只训练XGBoost
            learner = LEARNERS[0]
            try:
                valid_pred, test_pred = train_single_model(
                    X_train, y_train, X_valid, y_valid, X_test, learner, sw
                )
                # Store OOF predictions
                mask = valid_idx >= cutoff
                if mask.any():
                    idxs = valid_idx[mask]
                    oof_preds[learner["name"]][slice_name][idxs] = valid_pred[mask]
                if cutoff > 0 and (~mask).any():
                    oof_preds[learner["name"]][slice_name][valid_idx[~mask]] = \
                        oof_preds[learner["name"]]["full_data"][valid_idx[~mask]]
                test_preds[learner["name"]][slice_name] += test_pred
            except Exception as e:
                print(f"    Error training {learner['name']}: {str(e)}")
                continue
    # Normalize test predictions
    for slice_name in test_preds["xgb_baseline"]:
        test_preds["xgb_baseline"][slice_name] /= Config.N_FOLDS
    return oof_preds, test_preds, model_slices

# ===== Ensemble and Submission =====
def create_submissions(train_df, oof_preds, test_preds, submission_df):
    """只生成XGBoost提交文件"""
    all_submissions = {}
    # 只保留XGBoost
    if "xgb_baseline" in oof_preds:
        xgb_oof = np.mean(list(oof_preds["xgb_baseline"].values()), axis=0)
        xgb_test = np.mean(list(test_preds["xgb_baseline"].values()), axis=0)
        xgb_score = pearsonr(train_df[Config.LABEL_COLUMN], xgb_oof)[0]
        print(f"\nXGBoost Baseline Score: {xgb_score:.4f}")
        submission_xgb = submission_df.copy()
        submission_xgb["prediction"] = xgb_test
        submission_xgb.to_csv("/AI4M/users/mjzhang/workspace/DRW/ZMJ/data_processed_7_16/submission_xgb_baseline_59_pca.csv", index=False)
        all_submissions["xgb_baseline"] = xgb_score
    print("\n" + "="*50)
    print("SUBMISSION SUMMARY:")
    print("="*50)
    for name, score in sorted(all_submissions.items(), key=lambda x: x[1], reverse=True):
        print(f"{name:25s}: {score:.4f}")
    return all_submissions

# ===== Main Execution =====
if __name__ == "__main__":
    print("Loading data...")
    train_df, test_df, submission_df = load_data()
    
    print("\nTraining models...")
    oof_preds, test_preds, model_slices = train_and_evaluate(train_df, test_df)
    
    print("\nCreating submissions...")
    submission_scores = create_submissions(train_df, oof_preds, test_preds, submission_df)
    
    print("\nAll submissions created successfully!")
    print("Files created:")
    print("- submission_xgb_baseline.csv (original baseline)")