Download LYY/pipeline.py from ChanceuxMJ/Personal_Code: direct link, hf CLI and curl.
- Browser
- Download file 16.3 kB
-
https://huggingface.co/datasets/ChanceuxMJ/Personal_Code/resolve/main/LYY/pipeline.py
- Command line
-
hf download hf://datasets/ChanceuxMJ/Personal_Code/LYY/pipeline.py
-
curl -L -o pipeline.py https://huggingface.co/datasets/ChanceuxMJ/Personal_Code/resolve/main/LYY/pipeline.py
16.3 kB
| import sys | |
| import pandas as pd | |
| import numpy as np | |
| from sklearn.model_selection import KFold | |
| from xgboost import XGBRegressor | |
| 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 | |
| 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: | |
| TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/train.parquet" | |
| TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/test.parquet" | |
| SUBMISSION_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/sample_submission.csv" | |
| # Original features plus additional market features | |
| FEATURES = [ | |
| "X863", "X856", "X598", "X862", "X385", "X852", "X603", "X860", "X674", | |
| "X345", "X855", "X302", "X178", "X168", "X612", "sell_qty", | |
| "bid_qty", "ask_qty", "buy_qty", "volume"] | |
| LABEL_COLUMN = "label" | |
| N_FOLDS = 3 | |
| RANDOM_STATE = 42 | |
| # ===== Model Parameters ===== | |
| # Original XGBoost parameters | |
| XGB_PARAMS = { | |
| "tree_method": "hist", | |
| "device": "gpu", | |
| "colsample_bylevel": 0.4778, | |
| "colsample_bynode": 0.3628, | |
| "colsample_bytree": 0.7107, | |
| "gamma": 1.7095, | |
| "learning_rate": 0.02213, | |
| "max_depth": 20, | |
| "max_leaves": 12, | |
| "min_child_weight": 16, | |
| "n_estimators": 1667, | |
| "subsample": 0.06567, | |
| "reg_alpha": 39.3524, | |
| "reg_lambda": 75.4484, | |
| "verbosity": 0, | |
| "random_state": Config.RANDOM_STATE, | |
| "n_jobs": -1 | |
| } | |
| # Define all learners | |
| LEARNERS = [ | |
| {"name": "xgb_baseline", "Estimator": XGBRegressor, "params": XGB_PARAMS, "need_scale": False}, | |
| {"name": "huber", "Estimator": HuberRegressor, "params": {"epsilon": 1.5, "alpha": 0.01, "max_iter": 500}, "need_scale": True}, | |
| {"name": "ransac", "Estimator": RANSACRegressor, "params": {"min_samples": 0.7, "max_trials": 100, "random_state": Config.RANDOM_STATE}, "need_scale": True}, | |
| {"name": "theilsen", "Estimator": TheilSenRegressor, "params": {"max_subpopulation": 10000, "random_state": Config.RANDOM_STATE}, "need_scale": True}, | |
| {"name": "lasso", "Estimator": Lasso, "params": {"alpha": 0.001, "max_iter": 1000}, "need_scale": True}, | |
| {"name": "elasticnet", "Estimator": ElasticNet, "params": {"alpha": 0.001, "l1_ratio": 0.5, "max_iter": 1000}, "need_scale": True}, | |
| {"name": "pls", "Estimator": PLSRegression, "params": {"n_components": 50}, "need_scale": True}, | |
| ] | |
| # ===== 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() | |
| def load_data(): | |
| """Load and preprocess data""" | |
| train_df = pd.read_parquet(Config.TRAIN_PATH, columns=Config.FEATURES + [Config.LABEL_COLUMN]) | |
| test_df = pd.read_parquet(Config.TEST_PATH, columns=Config.FEATURES) | |
| submission_df = pd.read_csv(Config.SUBMISSION_PATH) | |
| # Apply feature engineering | |
| train_df = feature_engineering(train_df) | |
| test_df = feature_engineering(test_df) | |
| # Update features list with engineered features | |
| engineered_features = [ | |
| "volume_weighted_sell", "buy_sell_ratio", "selling_pressure", | |
| "effective_spread_proxy", "log_volume", "bid_ask_imbalance", | |
| "order_flow_imbalance", "liquidity_ratio" | |
| ] | |
| Config.FEATURES = list(set(Config.FEATURES + engineered_features)) | |
| print(f"Loaded data - Train: {train_df.shape}, Test: {test_df.shape}, Submission: {submission_df.shape}") | |
| print(f"Total features: {len(Config.FEATURES)}") | |
| return train_df.reset_index(drop=True), test_df.reset_index(drop=True), submission_df | |
| # ===== 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"] == "xgb_baseline": | |
| model.fit(X_train_scaled, y_train, sample_weight=sample_weights, | |
| eval_set=[(X_valid_scaled, y_valid)], verbose=False) | |
| elif learner["name"] in ["huber", "lasso", "elasticnet"]: | |
| model.fit(X_train_scaled, y_train, sample_weight=sample_weights) | |
| 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): | |
| """Train all models with cross-validation""" | |
| n_samples = len(train_df) | |
| model_slices = get_model_slices(n_samples) | |
| # Initialize prediction dictionaries | |
| oof_preds = { | |
| learner["name"]: {s["name"]: np.zeros(n_samples) for s in model_slices} | |
| for learner in LEARNERS | |
| } | |
| test_preds = { | |
| learner["name"]: {s["name"]: np.zeros(len(test_df)) for s in model_slices} | |
| for learner in LEARNERS | |
| } | |
| full_weights = create_time_decay_weights(n_samples) | |
| kf = KFold(n_splits=Config.N_FOLDS, shuffle=False) | |
| 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)}") | |
| for learner in LEARNERS: | |
| 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] | |
| X_valid_subset = train_df.iloc[idxs][Config.FEATURES] | |
| if learner["need_scale"]: | |
| scaler = RobustScaler() | |
| scaler.fit(X_train) | |
| valid_pred_subset = learner["Estimator"](**learner["params"]).fit( | |
| scaler.transform(X_train), y_train | |
| ).predict(scaler.transform(X_valid_subset)) | |
| oof_preds[learner["name"]][slice_name][idxs] = valid_pred_subset | |
| else: | |
| 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 learner_name in test_preds: | |
| for slice_name in test_preds[learner_name]: | |
| test_preds[learner_name][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): | |
| """Create multiple submission files for different strategies""" | |
| all_submissions = {} | |
| # 1. Original baseline (XGBoost only) | |
| 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("submission_xgb_baseline.csv", index=False) | |
| all_submissions["xgb_baseline"] = xgb_score | |
| # 2. Robust methods ensemble | |
| robust_methods = ["huber", "ransac", "theilsen"] | |
| robust_oof_list = [] | |
| robust_test_list = [] | |
| for method in robust_methods: | |
| if method in oof_preds: | |
| method_oof = np.mean(list(oof_preds[method].values()), axis=0) | |
| method_test = np.mean(list(test_preds[method].values()), axis=0) | |
| method_score = pearsonr(train_df[Config.LABEL_COLUMN], method_oof)[0] | |
| print(f"{method.upper()} Score: {method_score:.4f}") | |
| if not np.isnan(method_score): | |
| robust_oof_list.append(method_oof) | |
| robust_test_list.append(method_test) | |
| if robust_oof_list: | |
| robust_oof = np.mean(robust_oof_list, axis=0) | |
| robust_test = np.mean(robust_test_list, axis=0) | |
| robust_score = pearsonr(train_df[Config.LABEL_COLUMN], robust_oof)[0] | |
| print(f"\nRobust Ensemble Score: {robust_score:.4f}") | |
| submission_robust = submission_df.copy() | |
| submission_robust["prediction"] = robust_test | |
| submission_robust.to_csv("submission_robust_ensemble.csv", index=False) | |
| all_submissions["robust_ensemble"] = robust_score | |
| # 3. Regularized methods ensemble | |
| regularized_methods = ["lasso", "elasticnet"] | |
| reg_oof_list = [] | |
| reg_test_list = [] | |
| for method in regularized_methods: | |
| if method in oof_preds: | |
| method_oof = np.mean(list(oof_preds[method].values()), axis=0) | |
| method_test = np.mean(list(test_preds[method].values()), axis=0) | |
| method_score = pearsonr(train_df[Config.LABEL_COLUMN], method_oof)[0] | |
| print(f"{method.upper()} Score: {method_score:.4f}") | |
| if not np.isnan(method_score): | |
| reg_oof_list.append(method_oof) | |
| reg_test_list.append(method_test) | |
| if reg_oof_list: | |
| reg_oof = np.mean(reg_oof_list, axis=0) | |
| reg_test = np.mean(reg_test_list, axis=0) | |
| reg_score = pearsonr(train_df[Config.LABEL_COLUMN], reg_oof)[0] | |
| print(f"\nRegularized Ensemble Score: {reg_score:.4f}") | |
| submission_reg = submission_df.copy() | |
| submission_reg["prediction"] = reg_test | |
| submission_reg.to_csv("submission_regularized_ensemble.csv", index=False) | |
| all_submissions["regularized_ensemble"] = reg_score | |
| # 4. Full ensemble (weighted by performance) | |
| all_oof_scores = {} | |
| all_oof_preds = {} | |
| all_test_preds = {} | |
| for learner_name in oof_preds: | |
| learner_oof = np.mean(list(oof_preds[learner_name].values()), axis=0) | |
| learner_test = np.mean(list(test_preds[learner_name].values()), axis=0) | |
| score = pearsonr(train_df[Config.LABEL_COLUMN], learner_oof)[0] | |
| if not np.isnan(score) and score > 0: # Only include positive correlations | |
| all_oof_scores[learner_name] = score | |
| all_oof_preds[learner_name] = learner_oof | |
| all_test_preds[learner_name] = learner_test | |
| # Weighted ensemble | |
| if all_oof_scores: | |
| total_score = sum(all_oof_scores.values()) | |
| weights = {k: v/total_score for k, v in all_oof_scores.items()} | |
| weighted_oof = sum(weights[k] * all_oof_preds[k] for k in weights) | |
| weighted_test = sum(weights[k] * all_test_preds[k] for k in weights) | |
| weighted_score = pearsonr(train_df[Config.LABEL_COLUMN], weighted_oof)[0] | |
| print(f"\nWeighted Full Ensemble Score: {weighted_score:.4f}") | |
| print("Weights:", {k: f"{v:.3f}" for k, v in weights.items()}) | |
| submission_weighted = submission_df.copy() | |
| submission_weighted["prediction"] = weighted_test | |
| submission_weighted.to_csv("submission_weighted_ensemble.csv", index=False) | |
| all_submissions["weighted_ensemble"] = weighted_score | |
| # 6. Simple average of all valid models | |
| simple_oof = np.mean(list(all_oof_preds.values()), axis=0) | |
| simple_test = np.mean(list(all_test_preds.values()), axis=0) | |
| simple_score = pearsonr(train_df[Config.LABEL_COLUMN], simple_oof)[0] | |
| print(f"\nSimple Full Ensemble Score: {simple_score:.4f}") | |
| submission_simple = submission_df.copy() | |
| submission_simple["prediction"] = simple_test | |
| submission_simple.to_csv("submission_simple_ensemble.csv", index=False) | |
| all_submissions["simple_ensemble"] = simple_score | |
| # Print summary | |
| 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)") | |
| print("- submission_robust_ensemble.csv (Huber + RANSAC + TheilSen)") | |
| print("- submission_regularized_ensemble.csv (Lasso + ElasticNet)") | |
| print("- submission_weighted_ensemble.csv (weighted by performance)") | |
| print("- submission_simple_ensemble.csv (simple average)") |