Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,59 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+LYY/baseline1/submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/baseline1/submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/baseline1/submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/baseline1/submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/baseline1/submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text
+LYY/submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+LYY/submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/data_processed/correlation_matrix.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/data_processed_7_16/submission_xgb_baseline_59_pca.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/data_processed_7_16/xgb_prediction-2.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/data_processed_7_16/xgb_prediction.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/data_processed_new/sample_submission.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/sample_submission.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_mlp_cv.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_tree_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/max_IC_mixed/submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/old_data/correlation_matrix.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/submission_tree_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/sample_submission.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/submission_tree_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_29/submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_tree_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_xgb_baseline_59.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_xgb_baseline_59_new_v1.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_xgb_baseline_59_old.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_xgb_baseline_59_pca.csv filter=lfs diff=lfs merge=lfs -text
+ZMJ/threshold_6_30/submission_xgb_baseline_all.csv filter=lfs diff=lfs merge=lfs -text
+data/sample_submission.csv filter=lfs diff=lfs merge=lfs -text
+new_data/sample_submission.csv filter=lfs diff=lfs merge=lfs -text
+submission_regularized_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+submission_robust_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+submission_simple_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+submission_tree_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+submission_weighted_ensemble.csv filter=lfs diff=lfs merge=lfs -text
+submission_xgb_baseline.csv filter=lfs diff=lfs merge=lfs -text

DRW/DRW-Crypto/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

DRW/DRW-Crypto/.python-version

@@ -0,0 +1 @@
+3.11

DRW/DRW-Crypto/HyperparameterOptimizer.py

@@ -0,0 +1,351 @@
+# -*- coding: utf-8 -*-
+# @Time : 2025/7/7 11:15
+# @Author : Lukax
+# @Email : Lukarxiang@gmail.com
+# @File : HyperparameterOptimizer.py
+# -*- presentd: PyCharm -*-
+
+
+import os
+import json
+import optuna
+import datetime
+import numpy as np
+import pandas as pd
+from Settings import Config
+import matplotlib.pyplot as plt
+from scipy.stats import pearsonr
+from optuna.samplers import TPESampler
+from optuna.pruners import MedianPruner
+from typing import Dict, Any, List, Callable
+from sklearn.model_selection import cross_val_score, KFold
+
+
+
+class OptunaOptimizer:
+    def __init__(self, model_name: str, config = Config):
+        self.model_name = model_name.lower()
+        self.config = config
+        self.study = None
+        self.best_params = None
+        
+    def create_objective(self, X: np.ndarray, y: np.ndarray, cv_folds: int = 3):
+        def objective(trial):
+            params = self._suggest_parameters(trial)
+            
+            try:
+                model = self._create_model(params)
+                scores = []
+
+                kfold = KFold(n_splits = cv_folds, shuffle = True, random_state = self.config.RANDOM_STATE)
+                for train_idx, val_idx in kfold.split(X):
+                    X_train, X_val = X[train_idx], X[val_idx]
+                    y_train, y_val = y[train_idx], y[val_idx]
+
+                    # 根据模型类型使用不同的训练方式
+                    if self.model_name in ['xgb', 'lgb', 'cat']:
+                        # 梯度提升模型支持早停验证集
+                        if self.model_name == 'xgb':
+                            model.fit(X_train, y_train, eval_set = [(X_val, y_val)], verbose = False)
+                        elif self.model_name == 'lgb':
+                            model.fit(X_train, y_train, eval_set = [(X_val, y_val)])
+                        elif self.model_name == 'cat':
+                            model.fit(X_train, y_train, eval_set = [(X_val, y_val)], verbose = False)
+                    else:
+                        # Random Forest等模型不支持eval_set
+                        model.fit(X_train, y_train)
+                    
+                    y_pred = model.predict(X_val)
+                    score = pearsonr(y_val, y_pred)[0]
+                    scores.append(score)
+
+                    trial.report(score, len(scores) - 1)
+                    if trial.should_prune():
+                        raise optuna.TrialPruned()
+                return np.mean(scores)
+            except Exception as e:
+                print(f"Trial failed: {str(e)}")
+                return -1.0  # 返回很差的分数
+                
+        return objective
+    
+    def _suggest_parameters(self, trial):
+        if self.model_name == 'xgb':
+            return {
+                'n_estimators': trial.suggest_int('n_estimators', 500, 3000),
+                'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.1, log = True),
+                'max_depth': trial.suggest_int('max_depth', 6, 25),
+                'max_leaves': trial.suggest_int('max_leaves', 8, 50),
+                'min_child_weight': trial.suggest_int('min_child_weight', 1, 50),
+                'subsample': trial.suggest_float('subsample', 0.05, 1.0),
+                'colsample_bytree': trial.suggest_float('colsample_bytree', 0.5, 1.0),
+                'colsample_bylevel': trial.suggest_float('colsample_bylevel', 0.3, 1.0),
+                'colsample_bynode': trial.suggest_float('colsample_bynode', 0.3, 1.0),
+                'reg_alpha': trial.suggest_float('reg_alpha', 0.1, 100.0, log = True),
+                'reg_lambda': trial.suggest_float('reg_lambda', 0.1, 100.0, log = True),
+                'gamma': trial.suggest_float('gamma', 0.1, 10.0),
+                'tree_method': 'hist',
+                'device': 'gpu' if hasattr(Config, 'USE_GPU') and Config.USE_GPU else 'cpu',
+                'verbosity': 0,
+                'random_state': self.config.RANDOM_STATE,
+                'n_jobs': -1
+            }
+        elif self.model_name == 'lgb':
+            return {
+                'n_estimators': trial.suggest_int('n_estimators', 500, 3000),
+                'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.1, log = True),
+                'max_depth': trial.suggest_int('max_depth', 6, 25),
+                'num_leaves': trial.suggest_int('num_leaves', 15, 200),
+                'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
+                'subsample': trial.suggest_float('subsample', 0.4, 1.0),
+                'colsample_bytree': trial.suggest_float('colsample_bytree', 0.4, 1.0),
+                'reg_alpha': trial.suggest_float('reg_alpha', 0.1, 100.0, log = True),
+                'reg_lambda': trial.suggest_float('reg_lambda', 0.1, 100.0, log = True),
+                'feature_fraction': trial.suggest_float('feature_fraction', 0.4, 1.0),
+                'bagging_fraction': trial.suggest_float('bagging_fraction', 0.4, 1.0),
+                'bagging_freq': trial.suggest_int('bagging_freq', 1, 7),
+                'objective': 'regression',
+                'metric': 'rmse',
+                'boosting_type': 'gbdt',
+                'verbose': -1,
+                'random_state': self.config.RANDOM_STATE,
+                'n_jobs': -1
+            }
+        elif self.model_name == 'cat':
+            return {
+                'iterations': trial.suggest_int('iterations', 500, 3000),
+                'learning_rate': trial.suggest_float('learning_rate', 0.01, 0.1),
+                'depth': trial.suggest_int('depth', 4, 12),
+                'l2_leaf_reg': trial.suggest_float('l2_leaf_reg', 1, 10),
+                'bootstrap_type': trial.suggest_categorical('bootstrap_type', ['Bayesian', 'Bernoulli', 'MVS']),
+                'random_seed': self.config.RANDOM_STATE,
+                'verbose': False,
+                'allow_writing_files': False
+            }
+        elif self.model_name == 'rf':
+            return {
+                'n_estimators': trial.suggest_int('n_estimators', 100, 1000),
+                'max_depth': trial.suggest_int('max_depth', 5, 30),
+                'min_samples_split': trial.suggest_int('min_samples_split', 2, 20),
+                'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 10),
+                'max_features': trial.suggest_categorical('max_features', ['sqrt', 'log2', None]),
+                'bootstrap': trial.suggest_categorical('bootstrap', [True, False]),
+                'random_state': self.config.RANDOM_STATE,
+                'n_jobs': -1
+            }
+        else:
+            raise ValueError(f"不支持的模型类型: {self.model_name}")
+    
+    def _create_model(self, params):
+        learners = self.config.get_learners()
+        for learner in learners:
+            if learner['name'] == self.model_name:
+                return learner['estimator'](**params)
+        raise ValueError(f"未找到模型: {self.model_name}")
+    
+    def optimize(self, X: np.ndarray, y: np.ndarray, n_trials: int = 100, cv_folds: int = 3, study_name: str = None) -> Dict[str, Any]:
+        study_name = study_name or f"{self.model_name}_optimization"
+        self.study = optuna.create_study(
+            direction = 'maximize',  # 最大化Pearson相关系数
+            sampler = TPESampler(seed = self.config.RANDOM_STATE),
+            pruner = MedianPruner(n_startup_trials = 10, n_warmup_steps = 5),
+            study_name = study_name
+        )
+
+        objective = self.create_objective(X, y, cv_folds)
+        print(f"Optimizing {self.model_name} hyperParameter...")
+        print(f"trail: {n_trials}, fold: {cv_folds}")
+
+        self.study.optimize(objective, n_trials = n_trials, show_progress_bar = True)
+        self.best_params = self.study.best_params
+        best_score = self.study.best_value
+        print(f"Optimized score: {best_score:.3f}\nBest Parameters: {self.best_params}")
+        res = {'best_params': self.best_params, 'best_score': best_score, 'study': self.study, 'n_trials': len(self.study.trials)}
+        return res
+    
+    def save_results(self, save_path: str = None):
+        if self.best_params is None:
+            raise ValueError("Can't save before optimized.")
+            
+        save_path = save_path or os.path.join(Config.RESULTS_DIR, f"{self.model_name}_best_params.json")
+        result = {
+            'model_name': self.model_name,
+            'best_params': self.best_params,
+            'best_score': self.study.best_value,
+            'optimization_time': str(pd.Timestamp.now()),
+            'n_trials': len(self.study.trials)
+        }
+        with open(save_path, 'w', encoding = 'utf-8') as f:
+            json.dump(result, f, indent = 2, ensure_ascii = False)
+            
+        print(f"optimized result saved in {save_path}")
+        return save_path
+
+
+class HyperparameterManager:
+    def __init__(self, config = Config):
+        self.config = config
+        self.optimizers = {}
+        self.results = {}
+        
+    def register_optimizer(self, model_name: str, optimizer_type: str = 'optuna'):
+        if optimizer_type == 'optuna':
+            self.optimizers[model_name] = OptunaOptimizer(model_name, self.config)
+        else:
+            raise ValueError(f"Unsupported optimizer: {optimizer_type}")
+    
+    def optimize_all_models(self, X: np.ndarray, y: np.ndarray, n_trials: int = 50, cv_folds: int = 3) -> Dict[str, Any]:
+        learners = self.config.get_learners()
+        model_names = [learner['name'] for learner in learners]
+        
+        print(f"Starting hyperparameter optimization for {len(model_names)} models")
+        print(f"Model list: {model_names}")
+        
+        for model_name in model_names:
+            print(f"\n{'='*50}")
+            print(f"Optimizing model: {model_name.upper()}")
+            print(f"{'='*50}")
+
+            self.register_optimizer(model_name)
+
+            try:
+                result = self.optimizers[model_name].optimize(X, y, n_trials, cv_folds)
+                self.results[model_name] = result
+
+                self.optimizers[model_name].save_results()
+                
+            except Exception as e:
+                print(f"Model {model_name} optimization failed: {str(e)}")
+                continue
+        
+        return self.results
+    
+    def update_config(self, config_path: str = 'Settings.py'):
+        if not self.results:
+            return
+
+        with open(config_path, 'r', encoding = 'utf-8') as f:
+            config_content = f.read()
+        new_learners_config = self._generate_learners_config()
+
+        backup_path = config_path.replace('.py', f'_backup_{datetime.datetime.today().strftime("%m%d-%H%M")}.py')
+        with open(backup_path, 'w', encoding = 'utf-8') as f:
+            f.write(config_content)
+        print(f"Original config backed up to: {backup_path}")
+
+        updated_content = self._update_learners_in_config(config_content, new_learners_config)
+        
+        with open(config_path, 'w', encoding = 'utf-8') as f:
+            f.write(updated_content)
+            
+        print(f"Config file updated: {config_path}")
+        
+    def _generate_learners_config(self) -> str:
+        config_lines = ["    @classmethod", "    def get_learners(cls):", '        """获取配置好的学习器列表"""', "        return ["]
+        learners = self.config.get_learners()
+        for learner in learners:
+            model_name = learner['name']
+            config_lines.append(f"            {{")
+            config_lines.append(f"                'name': '{model_name}',")
+            config_lines.append(f"                'estimator': {learner['estimator'].__name__},")
+            config_lines.append(f"                'params': {{")
+
+            if model_name in self.results:
+                params = self.results[model_name]['best_params']
+                print(f"  Using optimized parameters for {model_name}")
+            else:
+                params = learner['params']
+                print(f"  Keeping original parameters for {model_name}")
+            
+            # 格式化参数
+            for key, value in params.items():
+                if isinstance(value, str):
+                    config_lines.append(f'                    "{key}": "{value}",')
+                else:
+                    config_lines.append(f'                    "{key}": {value},')
+            
+            config_lines.append(f"                }},")
+            config_lines.append(f"            }},")
+        
+        config_lines.append("        ]")
+        
+        return '\n'.join(config_lines)
+    
+    def _update_learners_in_config(self, content: str, new_config: str) -> str:
+        start_marker = "@classmethod\n    def get_learners(cls):" # 找到get_learners方法的位置
+        end_marker = "        ]"
+        
+        start_idx = content.find(start_marker)
+        if start_idx == -1:
+            print("get_learners method not found, appending new config")
+            return content + "\n\n" + new_config
+
+        temp_content = content[start_idx:] # 找到方法结束位置
+        end_idx = temp_content.find(end_marker)
+        if end_idx == -1:
+            print("get_learners method end position not found")
+            return content
+
+        before = content[:start_idx] # 替换配置
+        after = content[start_idx + end_idx + len(end_marker):]
+        
+        return before + new_config + after
+    
+    def plot_optimization_history(self, save_path: str = None):
+        if not self.results:
+            print("No optimization results to plot")
+            return
+
+        fig, axes = plt.subplots(2, 2, figsize = (15, 10))
+        axes = axes.flatten()
+
+        for i, (model_name, result) in enumerate(self.results.items()):
+            if i >= 4:  # 最多显示4个模型
+                break
+
+            study = result['study']
+            trials = study.trials
+
+            values = [trial.value for trial in trials if trial.value is not None]
+            axes[i].plot(values)
+            axes[i].set_title(f'{model_name.upper()} Optimization History')
+            axes[i].set_xlabel('Trial Number')
+            axes[i].set_ylabel('Pearson Correlation')
+            axes[i].grid(True)
+
+        plt.tight_layout()
+
+        if save_path:
+            plt.savefig(save_path, dpi = 300, bbox_inches = 'tight')
+            print(f"Optimization history plot saved to: {save_path}")
+        else:
+            plt.show()
+                
+
+
+def quick_optimize_single_model(model_name: str, X: np.ndarray, y: np.ndarray, n_trials: int = 100) -> Dict[str, Any]:
+    optimizer = OptunaOptimizer(model_name)
+    result = optimizer.optimize(X, y, n_trials = n_trials)
+    optimizer.save_results()
+    
+    return result
+
+
+# 使用示例
+if __name__ == "__main__":
+    # 测试
+    np.random.seed(42)
+    X = np.random.randn(1000, 10)
+    y = X[:, 0] + 0.5 * X[:, 1] + np.random.randn(1000) * 0.1
+
+    # result = quick_optimize_single_model('xgb', X, y, n_trials = 20)
+
+    manager = HyperparameterManager()
+    results = manager.optimize_all_models(X, y, n_trials = 10)
+
+    # manager.update_config()
+    
+
+    history_path = os.path.join(Config.RESULTS_DIR, 'optimization_history.png') # 绘制优化历史
+    manager.plot_optimization_history(history_path)
+

DRW/DRW-Crypto/README.md

@@ -0,0 +1,37 @@
+## Kaggle ML model (version 1.0)
+参考 sub-sample-vs-super-sample-noisy-rows.ipynb的主要训练流程，以此基础上，拓展了
+- ML 单模型种类
+- ML 单模型的参数搜索
+- ML 多模型集成的权重搜索
+等功能，并让整个工作流完整化。
+
+还需补充方向：
+- 特征的选择（已有 feature_engineering.ipynb可参考，需搜集其他思路）
+- MLP的参数搜索
+
+### 模块介绍
+模型参数搜索: optimize_params + HyperparameterOptimizer
+策略集成工作流： main + Utils + inplemental
+相关配置文件： Settings
+
+
+### 环境安装
+如果自己习惯 conda环境，可以直接按照 pyproject.toml中的依赖进行自行安装，略过下面的内容
+
+下面介绍一种简单快速的环境安装方法 UV
+1. 安装 uv工具 https://github.com/astral-sh/uv
+    windows powershell：powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+    macOS terminal：curl -LsSf https://astral.sh/uv/install.sh | sh
+
+2. powershell 进入项目
+    uv python install 3.11
+    uv sync
+
+    如果是 windows且已经安装了 cuda，执行 setup_cuda.py，卸载 cpu版本的 torch，安装 gpu版本的 torch
+    .venv/bin/activate
+    python setup_cuda.py
+    安装验证
+    python -c "import torch; print(f'PyTorch: {torch.__version__}'); print(f'CUDA: {torch.cuda.is_available()}')"
+    安装的 gpu版本 torch需要参考本机安装的 cuda版本来进行选择
+
+

DRW/DRW-Crypto/Settings.py

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+# @Time : 2025/7/4 18:48
+# @Author : Lukax
+# @Email : Lukarxiang@gmail.com
+# @File : Settings.py
+# -*- presentd: PyCharm -*-
+
+
+import os
+import torch
+from xgboost import XGBRegressor
+from lightgbm import LGBMRegressor
+from catboost import CatBoostRegressor
+from sklearn.ensemble import RandomForestRegressor
+
+
+
+class Config:
+    ROOT_PATH = os.getcwd()
+    DATA_DIR = os.path.join(ROOT_PATH, 'data')
+    SUBMISSION_DIR = os.path.join(ROOT_PATH, 'submission')
+    RESULTS_DIR = os.path.join(ROOT_PATH, 'results')
+
+    os.makedirs(DATA_DIR, exist_ok=True)
+    os.makedirs(SUBMISSION_DIR, exist_ok=True)
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    TRAIN_PATH = os.path.join(DATA_DIR, 'train.parquet')
+    TEST_PATH = os.path.join(DATA_DIR, 'test.parquet')
+    SUBMISSION_PATH = os.path.join(DATA_DIR, 'sample_submission.csv')
+
+    FEATURES = [
+        "bid_qty", "ask_qty", "buy_qty", "sell_qty", "volume",
+        "X598", "X385", "X603", "X674", "X415", "X345", "X174", 
+        "X302", "X178", "X168", "X612", "X421", "X333", "X586", "X292"
+    ]
+
+    MLP_FEATURES = [
+        "bid_qty", "ask_qty", "buy_qty", "sell_qty", "volume",
+        "X344", "X598", "X385", "X603", "X674", "X415", "X345", "X137", 
+        "X174", "X302", "X178", "X532", "X168", "X612"
+    ]
+
+    TARGET = 'label'
+    N_FOLDS = 5
+    RANDOM_STATE = 23
+    OUTLIER_FRACTION = 0.001
+    OUTLIER_STRATEGIES = ['reduce', 'remove', 'double', 'none']
+    
+
+    ENSEMBLE_METHODS = ['grid', 'stacking'] 
+    GRID_SEARCH_STRIDE1 = 0.1 
+    GRID_SEARCH_STRIDE2 = 0.025 
+    
+    SLICE_CONFIGS = [
+        {'name': 'full', 'anchor_ratio': 0, 'after': True, 'adjust_outlier': False},
+        {'name': 'recent_90', 'anchor_ratio': 0.1, 'after': True, 'adjust_outlier': False},
+        {'name': 'recent_85', 'anchor_ratio': 0.15, 'after': True, 'adjust_outlier': False},
+        {'name': 'recent_80', 'anchor_ratio': 0.2, 'after': True, 'adjust_outlier': False},
+        {'name': 'first_25', 'anchor_ratio': 0.25, 'after': False, 'adjust_outlier': False},
+    ]
+    
+    SLICE_WEIGHTS = [
+        1.0,   # full_data
+        1.0,   # last_90pct
+        1.0,   # last_85pct
+        1.0,   # last_80pct
+        0.25,  # oldest_25pct
+        0.9,   # full_data_outlier_adj
+        0.9,   # last_90pct_outlier_adj
+        0.9,   # last_85pct_outlier_adj
+        0.9,   # last_80pct_outlier_adj
+        0.2    # oldest_25pct_outlier_adj
+    ]
+    
+
+    MLP_CONFIG = {
+        'layers': [len(MLP_FEATURES), 128, 64, 1],
+        'activation': 'relu',
+        'last_activation': None,
+        'dropout_rate': 0.6,
+        'learning_rate': 0.001,
+        'batch_size': 1024,
+        'epochs': 100,
+        'patience': 10
+    }
+
+
+    @classmethod
+    def get_learners(cls):
+        return [
+            {
+                'name': 'xgb', 
+                'estimator': XGBRegressor,
+                'params': {
+                    "tree_method": "hist",
+                    "device": "gpu" if torch.cuda.is_available() else "cpu",
+                    "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": cls.RANDOM_STATE,
+                    "n_jobs": -1
+                },
+            },
+            {
+                'name': 'lgb', 
+                'estimator': LGBMRegressor,
+                'params': {
+                    "objective": "regression",
+                    "metric": "rmse",
+                    "boosting_type": "gbdt",
+                    "num_leaves": 31,
+                    "learning_rate": 0.05,
+                    "feature_fraction": 0.9,
+                    "bagging_fraction": 0.8,
+                    "bagging_freq": 5,
+                    "verbose": -1,
+                    "random_state": cls.RANDOM_STATE,
+                    "n_estimators": 1000
+                },
+            },
+            {
+                'name': 'cat', 
+                'estimator': CatBoostRegressor,
+                'params': {
+                    "iterations": 1000,
+                    "learning_rate": 0.03,
+                    "depth": 6,
+                    "l2_leaf_reg": 3,
+                    "random_seed": cls.RANDOM_STATE,
+                    "verbose": False,
+                    "allow_writing_files": False
+                },
+            },
+            {
+                'name': 'rf', 
+                'estimator': RandomForestRegressor,
+                'params': {
+                    "n_estimators": 200,
+                    "max_depth": 15,
+                    "min_samples_split": 5,
+                    "min_samples_leaf": 2,
+                    "random_state": cls.RANDOM_STATE,
+                    "n_jobs": -1
+                },
+            },
+        ]
+    
+    @property 
+    def LEARNERS(self):
+        return self.get_learners()
+
+    @classmethod
+    def print_config_summary(cls):
+        print("=" * 50)
+        print(f"GBDT feature nums: {len(cls.FEATURES)}")
+        print(f"MLP feature nums: {len(cls.MLP_FEATURES)}")
+        print(f"n_cv: {cls.N_FOLDS}")
+        print(f"outlier_fraction: {cls.OUTLIER_FRACTION}")
+        print(f"outlier_strategies: {cls.OUTLIER_STRATEGIES}")
+        print(f"learners: {[l['name'] for l in cls.get_learners()]}")
+        print("=" * 50)
+
+
+
+Config = Config()
+
+
+

DRW/DRW-Crypto/Utils.py

@@ -0,0 +1,655 @@
+# -*- coding: utf-8 -*-
+# @Time : 2025/7/4 19:53
+# @Author : Lukax
+# @Email : Lukarxiang@gmail.com
+# @File : Utils.py
+# -*- presentd: PyCharm -*-
+
+
+import os
+import torch
+import random
+import numpy as np
+import pandas as pd
+import torch.nn as nn
+import torch.optim as optim
+from Settings import Config
+from itertools import product
+from scipy.stats import pearsonr
+from xgboost import XGBRegressor
+from lightgbm import LGBMRegressor
+from sklearn.linear_model import Ridge
+from catboost import CatBoostRegressor
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import cross_val_score
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error as MSE
+from torch.utils.data import DataLoader, TensorDataset
+
+
+
+class MLP(nn.Module):
+    def __init__(self, layers = [128, 64], activation = 'relu', last_activation = None, dropout_rate = 0.6):
+        super(MLP, self).__init__()
+        self.activation = get_activation(activation)
+        self.last_activation = get_activation(last_activation) # 单独设置一下最后一个线性层的激活函数，可能和之前的不同
+
+        self.linears = nn.ModuleList()
+        [self.linears.append(nn.Linear(layers[i], layers[i + 1])) for i in range(len(layers) - 1)]
+        self.dropout = nn.Dropout(dropout_rate) # 跟在映射，激活的后边做 dropout
+
+    def forward(self, x):
+        for i in range(len(self.linears) - 1):
+            x = self.activation(self.linears[i](x))
+            x = self.dropout(x)
+        x = self.linears[-1](x)
+        if self.last_activation is not None:
+            x = self.last_activation(x)
+        return x
+
+
+class CheckPointer:
+    def __init__(self, path = None):
+        if path is None:
+            path = os.path.join(Config.RESULTS_DIR, 'best_model.pt')
+        self.path = path
+        self.best_pearson = -np.inf
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    def load(self, model):
+        model.load_state_dict(torch.load(self.path, map_location = self.device))
+        print(f'load model from {self.path} with Pearson: {self.best_pearson:.4f}')
+        return model
+
+    def __call__(self, pearson_coef, model):
+        if pearson_coef > self.best_pearson:
+            self.best_pearson = pearson_coef
+            torch.save(model.state_dict(), self.path)
+            print(f'save better model with Pearson:{self.best_pearson:.4f}')
+
+
+def set_seed(seed = 23):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.benchmark = False
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    torch.backends.cudnn.deterministic = True
+
+
+def get_activation(func):
+    if func == None: return None
+    func = func.lower()
+    if func == 'relu': return nn.ReLU()
+    elif func == 'tanh': return nn.Tanh()
+    elif func == 'sigmoid': return nn.Sigmoid()
+    else: raise ValueError(f'Unsupported activation function: {func}')
+
+
+def get_model(model): # 用来检测异常值的简单轻量树模型
+    if model == None:  return None
+    model = model.lower()
+    if model == 'rf': return RandomForestRegressor(n_estimators = 100, max_depth = 10, random_state = Config.RANDOM_STATE, n_jobs = -1)
+    elif model == 'xgb': return XGBRegressor(n_estimators = 50, max_depth = 6, random_state = Config.RANDOM_STATE, verbosity = 0, n_jobs = -1)
+    elif model == 'lgb': return LGBMRegressor(n_estimators = 50, max_depth = 6, random_state = Config.RANDOM_STATE, verbose = -1, n_jobs = -1)
+    elif model == 'cat': return CatBoostRegressor(n_estimators = 50, max_depth = 6, random_state = Config.RANDOM_STATE, verbose = -1, allow_writing_files = False)
+    else: raise ValueError(f'Unsupported model: {model}')
+
+
+def get_time_decay_weights(n, k = 0.9):
+    pos = np.arange(n)
+    normalized = pos / (n - 1) if n > 1 else pos
+    weights = k ** (1.0 - normalized)
+    w = weights * n / weights.sum()
+    return w
+
+
+def detect_outlier_weights(X, y, sample_weights, outlier_fraction = 0.001, strategy = 'none', model = 'rf'):
+    if strategy == 'none' or len(y) < 100:
+        return sample_weights, np.zeros(len(y), dtype = bool)
+
+    n_outlier = max(1, int(len(y) * outlier_fraction))
+    model = get_model(model)
+    model.fit(X, y, sample_weight = sample_weights)
+    pred = model.predict(X)
+    residuals = np.abs(y - pred)
+
+    sorted_res = np.sort(residuals)
+    residual_threshold = sorted_res[-n_outlier] if n_outlier <= len(y) else sorted_res[-1]
+    outlier_mask = residuals >= residual_threshold
+
+    # 判断阈值划分后有更多满足条件的记录，即等于划分阈值的记录存在多个
+    if np.sum(outlier_mask) > n_outlier:
+        outlier_idx = np.where(outlier_mask)[0] # outlier_mask 是一个 bool类型数组，np.where 检索其中为 True的位序，返回一个元组，元��第一个元素是 True值的对应索引，使用切片 [0]取出
+        np.random_state(23)
+        select_idx = np.random.choice(outlier_idx, n_outlier, replace = False)
+        outlier_mask = np.zeros(len(y), dtype = bool)
+        outlier_mask[select_idx] = True # 其实也可以制作一个 Series，然后 pandas排序后取前 n_outliers的 index后做同样操作
+
+    adjusted_w = sample_weights.copy()
+    if outlier_mask.any():
+        if strategy == 'reduce':
+            outlier_res = residuals[outlier_mask]
+            min_res, max_res = outlier_res.min(), outlier_res.max()
+            norm_res = (outlier_res - min_res) / (max_res - min_res) if max_res > min_res else np.ones_like(outlier_res)
+            w_factors = 0.8 - 0.6 * norm_res
+            adjusted_w[outlier_mask] *= w_factors
+
+        elif strategy == 'remove': adjusted_w[outlier_mask] = 0
+        elif strategy == 'double': adjusted_w[outlier_mask] *= 2.0
+        print(f"    Strategy '{strategy}': Adjusted {n_outlier} outliers ({outlier_fraction*100:.1f}% of data)")
+
+    return outlier_mask, adjusted_w
+
+
+def get_slices_and_weights(n):
+    base_slices = []
+    for config in Config.SLICE_CONFIGS:
+        slice = config.copy()
+        slice['anchor'] = int(n * config['anchor_ratio']) if config['anchor_ratio'] > 0 else 0
+        base_slices += [slice]
+
+    adjusted_slices = []
+    for bslice in base_slices:
+        slice = bslice.copy()
+        slice['name'] = f"{slice['name']}_adjust_outlier"
+        slice['adjust_outlier'] = True
+        adjusted_slices += [slice]
+
+    weights = np.array(Config.SLICE_WEIGHTS)
+    weights = weights / weights.sum()
+    assert len(base_slices + adjusted_slices) == len(weights)
+
+    return base_slices + adjusted_slices, weights
+
+
+def analyze_outliers(train):
+    X, y = train[Config.FEATURES].values, train[Config.TARGET].values
+    sample_weights = get_time_decay_weights(len(train))
+    outlier_mask, _ = detect_outlier_weights(X, y, sample_weights, outlier_fraction = Config.OUTLIER_FRACTION, strategy = 'remove') # 这里调用只是为了找出 outlier，无需计算权重用于建模，随便选一个简单的策略
+    outlier_idx = np.where(outlier_mask)[0]
+    n_outlier = len(outlier_idx)
+    print(f"outlier detected: {n_outlier} ({n_outlier / len(train) * 100:.2f}%)")
+
+    if n_outlier == 0: print('no outliers detected with current threshold. consider adjusting outlier_fraction value.')
+    else: _ = analyze_outliers_statistical(train, y, outlier_mask, outlier_idx) # 对异常值进行统计性分析
+    return outlier_idx
+
+
+def analyze_outliers_statistical(train, y, outlier_mask, outlier_idx):
+    # analyze outliers y
+    normal_y, outlier_y = y[~outlier_mask], y[outlier_mask]
+    print(f"Normal samples - Min {normal_y.min():.4f} Max {normal_y.max():.4f} Mean {normal_y.mean():.4f} Std {normal_y.std():4f}")
+    print(f"outlier samples - Min {outlier_y.min():.4f} Max {outlier_y.max():.4f} Mean {outlier_y.mean():.4f} Std {outlier_y.std():4f}")
+
+    # analyze outliers x, all features
+    features = Config.FEATURES
+    normal_features, outlier_features = train.iloc[~outlier_mask][features], train.iloc[outlier_idx][features]
+    feature_diffs = []
+    for feat in features:
+        normal_mean, outlier_mean = normal_features[feat].mean(), outlier_features[feat].mean()
+        if normal_mean != 0:
+            relative_diff = abs(outlier_mean - normal_mean) / abs(normal_mean)
+            feature_diffs += [(feat, relative_diff, outlier_mean, normal_mean)]
+
+    feature_diffs.sort(key = lambda x: x[1], reverse = True)
+    print(f"Top 10 most different features:")
+    for feat, diff, _, __ in feature_diffs[:10]:
+        print(f"  {feat}: {diff * 100:.1f}% difference")
+
+    print(f"  Features with >50% difference: {sum(1 for t in feature_diffs if t[1] > 0.5)}")
+    print(f"  Features with >100% difference: {sum(1 for t in feature_diffs if t[1] > 1.0)}")
+    return feature_diffs
+
+
+from sklearn.model_selection import KFold
+import numpy as np
+
+def train2compare_outlier_strategy(train, test, mode='single'):
+    train = train.replace([np.inf, -np.inf], np.nan).dropna(subset=[Config.TARGET]).reset_index(drop=True)
+    n = len(train)
+
+    # 1. 初始化结果容器
+    if mode == 'ensemble':
+        strategy_res = {s: {'oof_scores': [], 'slice_scores': []}
+                        for s in Config.OUTLIER_STRATEGIES}
+    else:
+        strategy_res = {
+            f"{s}_{l['name']}": {'oof_scores': [], 'slice_scores': []}
+            for s in Config.OUTLIER_STRATEGIES
+            for l in Config.get_learners()
+        }
+
+    best_strategy, best_score = 'reduce', -np.inf
+    best_oof_pred = best_test_pred = best_combination = None
+
+    # 2. 统一的全量权重（后面按 slice 再切）
+    base_weight = get_time_decay_weights(n)
+
+    folds = KFold(n_splits=Config.N_FOLDS, shuffle=False)
+
+    for strategy in Config.OUTLIER_STRATEGIES:
+        print(f'Comparing {strategy.upper()}')
+        slices, slice_weights = get_slices_and_weights(n)
+
+        # 3. 初始化 oof / test 缓存（保持你原来的结构）
+        oof_pred = {l['name']: {sl['name']: np.zeros(n) for sl in slices}
+                    for l in Config.get_learners()}
+        test_pred = {l['name']: {sl['name']: np.zeros(len(test)) for sl in slices}
+                     for l in Config.get_learners()}
+
+        for fold, (train_i, valid_i) in enumerate(folds.split(train), 1):
+            print(f'Fold {fold}/{Config.N_FOLDS}')
+            valid_x = train.iloc[valid_i][Config.FEATURES]
+            valid_y = train.iloc[valid_i][Config.TARGET]
+
+            for sl in slices:
+                sl_name, anchor, after, adjust = (
+                    sl['name'], sl['anchor'], sl['after'],
+                    sl.get('adjust_outlier', False)
+                )
+
+                # 4. 生成当前 slice 的 DataFrame 和索引
+                if after:
+                    cut_df = train.iloc[anchor:].reset_index(drop=True)
+                    idx_in_slice = train_i[(train_i >= anchor)] - anchor
+                else:
+                    cut_df = train.iloc[:anchor].reset_index(drop=True)
+                    idx_in_slice = train_i[train_i < anchor]
+
+                if len(idx_in_slice) == 0:
+                    continue   # 空 slice 跳过
+
+                # 5. 同步切片：X, y, weight 三个数组必须同长
+                train_x = cut_df.iloc[idx_in_slice][Config.FEATURES]
+                train_y = cut_df.iloc[idx_in_slice][Config.TARGET]
+                weight  = base_weight[anchor:][idx_in_slice] if after else base_weight[:anchor][idx_in_slice]
+
+                # 6. 异常值策略覆盖权重（返回的新权重同样长度）
+                if adjust and len(train_y) > 100:
+                    _, weight = detect_outlier_weights(
+                        train_x.values, train_y.values, weight,
+                        Config.OUTLIER_FRACTION, strategy)
+
+                # 7. 训练 & 预测
+                for learner in Config.get_learners():
+                    model = learner['estimator'](**learner['params'])
+                    print(learner['name'], type(model))
+                    print(train_x.shape[0], len(train_y), len(weight))
+                    print(type(train_x), train_x.dtypes.unique())
+                    print(type(train_y), train_y.dtype)
+                    print(type(weight), weight.dtype)
+                    fit_kwargs = dict(
+                        X=train_x,
+                        y=train_y,
+                        sample_weight=weight
+                    )
+
+                    # 只对 XGB / CatBoost 加 eval_set 和 verbose
+                    if learner['name'] == 'xgb':
+                        fit_kwargs.update(eval_set=[(valid_x, valid_y)], verbose=False)
+                    elif learner['name'] == 'cat':
+                        fit_kwargs.update(eval_set=[(valid_x, valid_y)], verbose=False)
+                    elif learner['name'] == 'lgb':
+                        fit_kwargs['eval_set'] = [(valid_x, valid_y)]   # LightGBM 不要 verbose
+                    # RandomForest 什么都不加
+
+                    model.fit(**fit_kwargs)
+                    
+                    # 8. oof / test 记录
+                    if after:
+                        mask = valid_i >= anchor
+                        if mask.any():
+                            idx = valid_i[mask]
+                            oof_pred[learner['name']][sl_name][idx] = \
+                                model.predict(train.iloc[idx][Config.FEATURES])
+                        if anchor and (~mask).any():
+                            fallback = 'full_adjust_outlier' if adjust else 'full'
+                            oof_pred[learner['name']][sl_name][valid_i[~mask]] = \
+                                oof_pred[learner['name']][fallback][valid_i[~mask]]
+                    else:
+                        oof_pred[learner['name']][sl_name][valid_i] = \
+                            model.predict(train.iloc[valid_i][Config.FEATURES])
+
+                    test_pred[learner['name']][sl_name] += \
+                        model.predict(test[Config.FEATURES])
+
+        # 9. 对 test 求均值
+        for l_name in test_pred:
+            for sl_name in test_pred[l_name]:
+                test_pred[l_name][sl_name] /= Config.N_FOLDS
+
+        # 10. 评分与最佳策略更新（保持你原来的逻辑）
+        if mode == 'ensemble':
+            ensemble_oof, ensemble_test = evaluate_ensemble_strategy(
+                oof_pred, test_pred, train, strategy, strategy_res, slice_weights)
+            if strategy_res[strategy]['ensemble_score'] > best_score:
+                best_score = strategy_res[strategy]['ensemble_score']
+                best_strategy, best_combination = strategy, f'Ensemble + {strategy}'
+                best_oof_pred, best_test_pred = ensemble_oof, ensemble_test
+        else:
+            best_score, best_strategy, best_oof_pred, best_test_pred, best_combination = \
+                evaluate_single_model_strategy(
+                    oof_pred, test_pred, train, strategy, strategy_res, slice_weights,
+                    best_score, best_strategy, best_oof_pred, best_test_pred, best_combination)
+
+    return best_oof_pred, best_test_pred, strategy_res, best_strategy, best_combination
+
+def evaluate_ensemble_strategy(oof_pred, test_pred, train, strategy, strategy_res, slice_weights, method = 'grid'):
+    print('\nEvaluating ensemble strategy starting...')
+    dic, model_oof_res, model_test_res, model_scores = {}, {}, {}, {}
+    learner_names = [learner['name'] for learner in Config.get_learners()]
+    
+    for learner_name in learner_names:
+        model_oof = pd.DataFrame(oof_pred[learner_name]).values @ slice_weights
+        model_test = pd.DataFrame(test_pred[learner_name]).values @ slice_weights
+        model_score = pearsonr(train[Config.TARGET], model_oof)[0]
+
+        model_oof_res[learner_name], model_test_res[learner_name] = model_oof, model_test
+        model_scores[learner_name] = model_score
+        print(f"\t{learner_name} score: {model_score:.4f}")
+
+    true = train[Config.TARGET].values
+    model_oof_df, model_test_df = pd.DataFrame(model_oof_res)[learner_names], pd.DataFrame(model_test_res)[learner_names]
+    
+    if method == 'grid':
+        print('\nTwo-stage grid search for model weights...')
+        model_weights, ensemble_score, info = weightSearch_grid(model_oof_df, true)
+    elif method == 'stacking':
+        print('\nStacking Ridge fitting model weights...')
+        model_weights, ensemble_weights, info = weightSearch_stacking(model_oof_df, true)
+    else: raise ValueError(f'Unsupport model weight search method: {method}')
+    dic['info'] = info
+
+    ensemble_oof = model_oof_df.values @ pd.Series(model_weights)[learner_names].values
+    ensemble_test = model_test_df.values @ pd.Series(model_weights)[learner_names].values
+    final_score = pearsonr(true, ensemble_oof)[0]
+    print(f"strategy {strategy} final result:\n\tmethod: {method}\n\tscore: {final_score:.4f}")
+
+    dic['ensemble_score'], dic['oof_pred'], dic['test_pred'], dic['weight_method'] = final_score, ensemble_oof, ensemble_test, method
+    dic['info'], dic['model_weights'], dic['model_scores'], dic['slice_weights'] = info, model_weights, model_scores, slice_weights
+    strategy_res[strategy] = dic
+
+    return ensemble_oof, ensemble_test
+
+
+def weightSearch_grid(model_oof_df, true, stride1 = 0.1, stride2 = 0.025):
+    model_names, n_models = model_oof_df.columns.tolist(), len(model_oof_df.columns)
+    print('\nStage 1: Coarse search')
+    ranges = [round(i * stride1, 1) for i in range(int(1 / stride1) + 1)]
+    best_score, best_weights, search_times = -np.inf, None, 0
+    
+    for weights in product(ranges, repeat = n_models):
+        if abs(sum(weights) - 1) > 1e-6: continue  # 权重和为1
+        if all(w == 0 for w in weights): continue
+
+        search_times += 1
+        ensemble_pred = model_oof_df @ weights
+        # score = pearsonr(true, ensemble_pred)[0]
+        score = MSE(true, ensemble_pred)
+        if score > best_score:
+            best_score, best_weights = score, weights
+        if search_times % 1000 == 0:
+            print(f"  Tested {search_times} combinations, current best: {best_score:.4f}")
+    
+    print(f"Stage 1 completed: {best_score:.4f}")
+    print(f"Best weights: {[f'{w:.1f}' for w in best_weights]}")
+
+
+    print('Stage 2 starting...')
+    fine_ranges = []
+    for i in range(n_models):
+        center = best_weights[i]
+        min_val, max_val = max(0.0, center - stride2 * 2), min(1.0, center + stride2 * 2)  # 搜索范围 ±2*fine_step
+        candidates, current = [], min_val
+        while current <= max_val + 1e-6:  # 加小量避免浮点误差
+            candidates += [round(current, 3)]
+            current += stride2
+        fine_ranges += [candidates]
+
+    print("Fine search range:")
+    for model_name, candidates in zip(model_names, fine_ranges):
+        print(f"  {model_name}: {len(candidates)} candidates [{candidates[0]:.3f}, {candidates[-1]:.3f}]")
+
+    best_fine_score, best_fine_weights, fine_times = best_score, list(best_weights), 0
+    for weights_fine in product(*fine_ranges):
+        weights_fine = np.array(weights_fine)
+        weights_sum = sum(weights_fine)
+        if weights_sum < 0.8 or weights_sum > 1.2: continue # 权重和太偏离1，跳过
+        weights_fine = weights_fine / weights_sum  # 标准化
+        fine_times += 1
+
+        ensemble_pred_fine = model_oof_df @ weights_fine
+        # score_fine = pearsonr(true, ensemble_pred_fine)[0]
+        score_fine = MSE(true, ensemble_pred_fine)
+        if score_fine > best_fine_score:
+            best_fine_score, best_fine_weights = score_fine, weights_fine.tolist()
+        if fine_times % 500 == 0:
+            print(f"  Tested {fine_times} combinations, current best: {best_fine_score:.4f}")
+
+    print(f"Fine search completed: {best_fine_score:.4f}")
+    print(f"Performance improvement: {best_fine_score - best_score:.4f}")
+
+    # 构建最终权重字典
+    best_weights_dict = dict(zip(model_names, best_fine_weights))
+    search_info = {"search_times": search_times, "fine_times": fine_times,
+                   "final_score": best_fine_score, "improvement": best_fine_score - best_score}
+    return best_weights_dict, best_fine_score, search_info
+
+
+def weightSearch_stacking(model_oof_df, true):
+    print('\nStacking weight search...')
+    model_names, n_models = model_oof_df.columns.tolist(), len(model_oof_df.columns)
+    meta_learner = Ridge(alpha = 1.0, random_state = Config.RANDOM_STATE)
+    meta_learner.fit(model_oof_df, true)
+    raw_weights = meta_learner.coef_
+    weights = np.maximum(raw_weights, 0)  # 去除负权重
+    weights = weights / weights.sum() if weights.sum() > 0 else np.ones(n_models) / n_models # 权重和为负数，使用均等权重；否则可以归一化
+
+    ensemble_pred = model_oof_df @ weights
+    ensemble_score = pearsonr(true, ensemble_pred)[0]
+
+    cv_scores = cross_val_score(meta_learner, model_oof_df, true, cv = 3, scoring = 'neg_mean_squared_error')
+    cv_std = cv_scores.std()
+    
+    print(f"Stacking result: {ensemble_score:.4f}")
+    print(f"CV stability (std): {cv_std:.4f}")
+    print(f"Model weights: {[f'{w:.3f}' for w in weights]}")
+
+    weight_dict = dict(zip(model_names, weights))
+    search_info = {"method": "stacking", "meta_learner": "Ridge", "cv_stability": cv_std, "ensemble_score": ensemble_score}
+    
+    return weight_dict, ensemble_score, search_info
+
+
+def evaluate_single_model_strategy(oof_pred, test_pred, train, strategy, strategy_res, slice_weights,
+                                   best_score, best_strategy, best_oof_pred, best_test_pred, best_combination):
+    for learner in Config.get_learners():
+        learner_name = learner['name']
+        print(f"{strategy} single model: {learner_name}")
+        key = f"{strategy}_{learner_name}"
+
+        oof = pd.DataFrame(oof_pred[learner_name]).values @ slice_weights
+        test = pd.DataFrame(test_pred[learner_name]).values @ slice_weights
+        score = pearsonr(train[Config.TARGET], oof)[0]
+        print(f"\t score: {score:.4f}")
+
+        strategy_res[key]['ensemble_score'] = score
+        strategy_res[key]['oof_pred'], strategy_res[key]['test_pred'] = oof, test
+        if score > best_score:
+            best_score, best_strategy = score, key
+            best_oof_pred, best_test_pred, best_combination = oof, test, f"{learner_name.upper()} {strategy}"
+
+    return best_score, best_strategy, best_oof_pred, best_test_pred, best_combination
+
+
+def print_strategy_comparison(strategy_res, mode, best_combination):
+    print(f"\nFINAL RESULTS - MODE: {mode.upper()}")
+    if mode == 'ensemble':
+        print("Ensemble Results:")
+        for strategy in Config.OUTLIER_STRATEGIES:
+            score = strategy_res[strategy]['ensemble_score']
+            print(f"\t{strategy}: {score:.4f}")
+
+            for model_name, model_score in strategy_res[strategy]['model_scores'].items():
+                print(f"\t\t{model_name}: {model_score:.4f}")
+    else:
+        print("Single Results:")
+        single_res = [(k, v['ensemble_score']) for k, v in strategy_res.items()]
+        single_res.sort(key = lambda x: x[1], reverse = True)
+
+        for combination, score in single_res[:10]: # Top 10
+            print(f"\t{combination}: {score:.4f}")
+
+    print(f"\nBest Combination: {best_combination}")
+    return single_res if mode != 'ensemble' else None
+
+
+
+
+
+def train_mlp_model(train, test, config = None):
+    if config is None:
+        config = Config.MLP_CONFIG
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    X_train_full = train[Config.MLP_FEATURES].values
+    y_train_full = train[Config.TARGET].values
+    X_train, X_val, y_train, y_val = train_test_split(X_train_full, y_train_full, test_size = 0.2, shuffle = False, random_state = Config.RANDOM_STATE)
+
+    scaler = StandardScaler()
+    X_train = scaler.fit_transform(X_train)
+    X_val = scaler.transform(X_val)
+    X_test = scaler.transform(test[Config.MLP_FEATURES].values)
+
+    train_dataset = TensorDataset(torch.tensor(X_train, dtype = torch.float32), torch.tensor(y_train, dtype = torch.float32).unsqueeze(1))
+    val_dataset = TensorDataset(torch.tensor(X_val, dtype = torch.float32), torch.tensor(y_val, dtype = torch.float32).unsqueeze(1))
+    test_dataset = TensorDataset(torch.tensor(X_test, dtype = torch.float32))
+    train_loader = DataLoader(train_dataset, batch_size = config['batch_size'], shuffle = True)
+    val_loader = DataLoader(val_dataset, batch_size = config['batch_size'], shuffle = False)
+    test_loader = DataLoader(test_dataset, batch_size = config['batch_size'], shuffle = False)
+
+    model = MLP(layers = config['layers'], activation = config['activation'], last_activation = config['last_activation'], dropout_rate = config['dropout_rate']).to(device)
+    criterion = nn.HuberLoss(delta = 5.0, reduction = 'mean')
+    optimizer = optim.Adam(model.parameters(), lr = config['learning_rate'])
+    checkpointer = CheckPointer(path = os.path.join(Config.RESULTS_DIR, 'best_mlp_model.pt'))
+
+    print(f"Starting MLP model training, epochs: {config['epochs']}")
+    best_val_score = -np.inf
+    patience_counter = 0
+    patience = config.get('patience', 10)
+    
+    for epoch in range(config['epochs']):
+        model.train()
+        running_loss = 0.0
+        
+        for inputs, targets in train_loader:
+            inputs, targets = inputs.to(device), targets.to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+            running_loss += loss.item()
+        
+        # 验证
+        model.eval()
+        val_preds, val_trues = [], []
+        with torch.no_grad():
+            for inputs, targets in val_loader:
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                val_preds += [outputs.cpu().numpy()]
+                val_trues += [targets.cpu().numpy()]
+        
+        val_preds = np.concatenate(val_preds).flatten()
+        val_trues = np.concatenate(val_trues).flatten()
+        val_score = pearsonr(val_preds, val_trues)[0]
+        print(f"Epoch {epoch+1}/{config['epochs']}: Train Loss: {running_loss/len(train_loader):.4f}, Val Score: {val_score:.4f}")
+
+        if val_score > best_val_score:
+            best_val_score = val_score
+            patience_counter = 0
+            checkpointer(val_score, model)
+        else: patience_counter += 1
+            
+        if patience_counter >= patience:
+            print(f"Early stopping at epoch {epoch+1}")
+            break
+    
+    # 加载最佳模型并预测
+    model = checkpointer.load(model)
+    model.eval()
+    predictions = []
+    with torch.no_grad():
+        for inputs, in test_loader:
+            inputs = inputs.to(device)
+            outputs = model(inputs)
+            predictions += [outputs.cpu().numpy()]
+    
+    predictions = np.concatenate(predictions).flatten()
+    return predictions, best_val_score
+
+
+def create_ensemble_submission(ml_predictions, mlp_predictions, submission, ml_weight = 0.8, mlp_weight = 0.2, strategy = 'ensemble'):
+    if len(ml_predictions) != len(mlp_predictions):
+        raise ValueError(f"预测长度不匹配: ML({len(ml_predictions)}) vs MLP({len(mlp_predictions)})")
+    
+    ensemble_pred = ml_weight * ml_predictions + mlp_weight * mlp_predictions
+    submission_ensemble = submission.copy()
+    submission_ensemble[Config.TARGET] = ensemble_pred
+
+    ensemble_filename = f"submission_ensemble_{strategy}_{ml_weight:.1f}ml_{mlp_weight:.1f}mlp.csv"
+    ensemble_filepath = os.path.join(Config.SUBMISSION_DIR, ensemble_filename)
+    submission_ensemble.to_csv(ensemble_filepath, index = False)
+    print(f"Ensemble submission file saved: {ensemble_filepath}")
+    
+    return ensemble_pred, ensemble_filepath
+
+
+def save2csv(submission_, predictions, score, models = "ML"):
+    submission = submission_.copy()
+    submission[Config.TARGET] = predictions
+    filename = f"submission_{models}_{score:.4f}.csv"
+    filepath = os.path.join(Config.SUBMISSION_DIR, filename)
+    submission.to_csv(filepath, index = False)
+    print(f"{models} submission saved to {filepath}")
+    return filepath
+
+
+def create_multiple_submissions(train, ml_predictions, mlp_predictions, submission, best_strategy, ml_score, mlp_score):
+    ml_filename = save2csv(submission, ml_predictions, ml_score, 'ML')
+    mlp_filename = save2csv(submission, mlp_predictions, mlp_score, 'MLP')
+
+    ensemble_configs = [
+        (0.9, 0.1, "conservative"),  # 保守：主要依赖ML
+        (0.7, 0.3, "balanced"),     # 平衡
+        (0.5, 0.5, "equal"),        # 等权重
+    ]
+    
+    ensemble_files = []
+    for ml_w, mlp_w, desc in ensemble_configs:
+        ensemble_pred, ensemble_file = create_ensemble_submission(ml_predictions, mlp_predictions, submission, ml_w, mlp_w, f"{best_strategy}_{desc}")
+        ensemble_files += [ensemble_file]
+
+    if ml_score > mlp_score:
+        best_final_pred = ml_predictions
+        best_filename = ml_filename
+        best_type = "ML"
+    else:
+        best_final_pred = mlp_predictions  
+        best_filename = mlp_filename
+        best_type = "MLP"
+    
+    print(f"\nRecommended submission: {best_filename} ({best_type})")
+    print(f"All generated files:")
+    for ef in ensemble_files:
+        print(f"  - {ef}")
+    
+    return best_final_pred, best_filename
+
+
+

DRW/DRW-Crypto/inplemental.py

@@ -0,0 +1,156 @@
+# -*- coding: utf-8 -*-
+# @Time : 2025/7/4 19:42
+# @Author : Lukax
+# @Email : Lukarxiang@gmail.com
+# @File : inplemental.py
+# -*- presentd: PyCharm -*-
+
+
+import torch
+import numpy as np
+import pandas as pd
+from Settings import Config
+from torch.utils.data import DataLoader, TensorDataset
+
+
+def getDataLoader(X, Y, hparams, device, shuffle = True):
+    X = torch.tensor(X, dtype = torch.float32, device = device)
+    if Y is None:
+        dataset = TensorDataset(X)
+    else:
+        Y = torch.tensor(Y.values if hasattr(Y, 'values') else Y,
+                         dtype = torch.float32, device = device).unsqueeze(1) # y need 2 dimensions
+        dataset = TensorDataset(X, Y)
+
+    dataloader = DataLoader(dataset, batch_size = hparams['batch_size'], shuffle = shuffle,
+                            generator = torch.Generator().manual_seed(hparams['seed']))
+    return dataloader
+
+class Config:
+    TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/train.parquet"
+    TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/test.parquet"
+    SUBMISSION_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/sample_submission.csv"
+    
+    # Original features plus additional market features
+    FEATURES = [
+        "X175", "X198", "X179", "X173", "X169", "X181", "X94",
+        "X197", "X137", "X133", "X163", "X196", "sell_qty", 
+        "bid_qty", "ask_qty", "buy_qty", "volume"]
+    EX_FEATURES = [
+        'X598', 'X385', 'X603', 'X674', 'X415', 'X345', 'X174',
+        'X302', 'X178', 'X168', 'X612', 'X421', 'X333', 'X586', 'X292'
+    ]
+    TARGET = "label"
+    N_FOLDS = 3
+    RANDOM_STATE = 42
+
+def add_featrues1(df):
+    # Original features
+    df['bid_ask_interaction'] = df['bid_qty'] * df['ask_qty']
+    df['bid_buy_interaction'] = df['bid_qty'] * df['buy_qty']
+    df['bid_sell_interaction'] = df['bid_qty'] * df['sell_qty']
+    df['ask_buy_interaction'] = df['ask_qty'] * df['buy_qty']
+    df['ask_sell_interaction'] = df['ask_qty'] * df['sell_qty']
+
+    df['volume_weighted_sell'] = df['sell_qty'] * df['volume']
+    df['buy_sell_ratio'] = df['buy_qty'] / (df['sell_qty'] + 1e-10)
+    df['selling_pressure'] = df['sell_qty'] / (df['volume'] + 1e-10)
+    df['log_volume'] = np.log1p(df['volume'])
+
+    df['effective_spread_proxy'] = np.abs(df['buy_qty'] - df['sell_qty']) / (df['volume'] + 1e-10)
+    df['bid_ask_imbalance'] = (df['bid_qty'] - df['ask_qty']) / (df['bid_qty'] + df['ask_qty'] + 1e-10)
+    df['order_flow_imbalance'] = (df['buy_qty'] - df['sell_qty']) / (df['buy_qty'] + df['sell_qty'] + 1e-10)
+    df['liquidity_ratio'] = (df['bid_qty'] + df['ask_qty']) / (df['volume'] + 1e-10)
+
+    # === NEW MICROSTRUCTURE FEATURES ===
+
+    # Price Pressure Indicators
+    df['net_order_flow'] = df['buy_qty'] - df['sell_qty']
+    df['normalized_net_flow'] = df['net_order_flow'] / (df['volume'] + 1e-10)
+    df['buying_pressure'] = df['buy_qty'] / (df['volume'] + 1e-10)
+    df['volume_weighted_buy'] = df['buy_qty'] * df['volume']
+
+    # Liquidity Depth Measures
+    df['total_depth'] = df['bid_qty'] + df['ask_qty']
+    df['depth_imbalance'] = (df['bid_qty'] - df['ask_qty']) / (df['total_depth'] + 1e-10)
+    df['relative_spread'] = np.abs(df['bid_qty'] - df['ask_qty']) / (df['total_depth'] + 1e-10)
+    df['log_depth'] = np.log1p(df['total_depth'])
+
+    # Order Flow Toxicity Proxies
+    df['kyle_lambda'] = np.abs(df['net_order_flow']) / (df['volume'] + 1e-10)
+    df['flow_toxicity'] = np.abs(df['order_flow_imbalance']) * df['volume']
+    df['aggressive_flow_ratio'] = (df['buy_qty'] + df['sell_qty']) / (df['total_depth'] + 1e-10)
+
+    # Market Activity Indicators
+    df['volume_depth_ratio'] = df['volume'] / (df['total_depth'] + 1e-10)
+    df['activity_intensity'] = (df['buy_qty'] + df['sell_qty']) / (df['volume'] + 1e-10)
+    df['log_buy_qty'] = np.log1p(df['buy_qty'])
+    df['log_sell_qty'] = np.log1p(df['sell_qty'])
+    df['log_bid_qty'] = np.log1p(df['bid_qty'])
+    df['log_ask_qty'] = np.log1p(df['ask_qty'])
+
+    # Microstructure Volatility Proxies
+    df['realized_spread_proxy'] = 2 * np.abs(df['net_order_flow']) / (df['volume'] + 1e-10)
+    df['price_impact_proxy'] = df['net_order_flow'] / (df['total_depth'] + 1e-10)
+    df['quote_volatility_proxy'] = np.abs(df['depth_imbalance'])
+
+    # Complex Interaction Terms
+    df['flow_depth_interaction'] = df['net_order_flow'] * df['total_depth']
+    df['imbalance_volume_interaction'] = df['order_flow_imbalance'] * df['volume']
+    df['depth_volume_interaction'] = df['total_depth'] * df['volume']
+    df['buy_sell_spread'] = np.abs(df['buy_qty'] - df['sell_qty'])
+    df['bid_ask_spread'] = np.abs(df['bid_qty'] - df['ask_qty'])
+
+    # Information Asymmetry Measures
+    df['trade_informativeness'] = df['net_order_flow'] / (df['bid_qty'] + df['ask_qty'] + 1e-10)
+    df['execution_shortfall_proxy'] = df['buy_sell_spread'] / (df['volume'] + 1e-10)
+    df['adverse_selection_proxy'] = df['net_order_flow'] / (df['total_depth'] + 1e-10) * df['volume']
+
+    # Market Efficiency Indicators
+    df['fill_probability'] = df['volume'] / (df['buy_qty'] + df['sell_qty'] + 1e-10)
+    df['execution_rate'] = (df['buy_qty'] + df['sell_qty']) / (df['total_depth'] + 1e-10)
+    df['market_efficiency'] = df['volume'] / (df['bid_ask_spread'] + 1e-10)
+
+    # Non-linear Transformations
+    df['sqrt_volume'] = np.sqrt(df['volume'])
+    df['sqrt_depth'] = np.sqrt(df['total_depth'])
+    df['volume_squared'] = df['volume'] ** 2
+    df['imbalance_squared'] = df['order_flow_imbalance'] ** 2
+
+    # Relative Measures
+    df['bid_ratio'] = df['bid_qty'] / (df['total_depth'] + 1e-10)
+    df['ask_ratio'] = df['ask_qty'] / (df['total_depth'] + 1e-10)
+    df['buy_ratio'] = df['buy_qty'] / (df['buy_qty'] + df['sell_qty'] + 1e-10)
+    df['sell_ratio'] = df['sell_qty'] / (df['buy_qty'] + df['sell_qty'] + 1e-10)
+
+    # Market Stress Indicators
+    df['liquidity_consumption'] = (df['buy_qty'] + df['sell_qty']) / (df['total_depth'] + 1e-10)
+    df['market_stress'] = df['volume'] / (df['total_depth'] + 1e-10) * np.abs(df['order_flow_imbalance'])
+    df['depth_depletion'] = df['volume'] / (df['bid_qty'] + df['ask_qty'] + 1e-10)
+
+    # Directional Indicators
+    df['net_buying_ratio'] = df['net_order_flow'] / (df['volume'] + 1e-10)
+    df['directional_volume'] = df['net_order_flow'] * np.log1p(df['volume'])
+    df['signed_volume'] = np.sign(df['net_order_flow']) * df['volume']
+
+    # Replace infinities and NaNs
+    df = df.replace([np.inf, -np.inf], 0).fillna(0)
+
+    return df
+
+
+def load_data():
+    features = list(set(Config.FEATURES + Config.MLP_FEATURES))
+    train = pd.read_parquet(Config.TRAIN_PATH, columns = features + [Config.TARGET])
+    train = train.dropna(subset=[Config.TARGET]).reset_index(drop=True)
+    assert not train[Config.TARGET].isna().any(), "label still has NaN"
+    test = pd.read_parquet(Config.TEST_PATH, columns = features)
+    submission = pd.read_csv(Config.SUBMISSION_PATH)
+    print(f'Origin: train {train.shape}, test {test.shape}, submission {submission.shape}')
+
+    train, test = add_featrues1(train), add_featrues1(test)
+    Config.FEATURES = test.columns.tolist()
+
+    return train.reset_index(drop = True), test.reset_index(drop = True), submission
+
+

DRW/DRW-Crypto/main.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+# @Time : 2025/7/10 20:56
+# @Author : Lukax
+# @Email : Lukarxiang@gmail.com
+# @File : Utils.py
+# -*- presentd: PyCharm -*-
+
+
+import os
+import numpy as np
+import pandas as pd
+from Settings import Config
+from inplemental import load_data
+from Utils import set_seed, train2compare_outlier_strategy, print_strategy_comparison, analyze_outliers, train_mlp_model, create_multiple_submissions, save2csv
+
+
+
+def flow():
+    Config.print_config_summary()
+
+    set_seed(Config.RANDOM_STATE)
+    train, test, submission = load_data()
+    print(f"\ntrain shape: {train.shape}\ntest shape: {test.shape}")
+    breakpoint()
+
+    # if train[Config.TARGET].isnull().any():
+    #     print(f"target has {train[Config.TARGET].isnull().sum()} NA.")
+
+    # analyze_outliers(train) # 单纯的异常值数量检测
+    
+    # ML single training
+    single_oof_pred, single_test_pred, single_strategy_res, single_best_strategy, single_best_combination = train2compare_outlier_strategy(train, test, mode = 'single')
+    print(f"{'='*50}\n\tsingle best: {single_best_combination}")
+
+    # ML ensemble training
+    ensemble_oof_pred, ensemble_test_pred, ensemble_strategy_res, ensemble_best_strategy, ensemble_best_combination = train2compare_outlier_strategy(train, test, mode = 'ensemble')
+    print(f"{'='*50}\n\tensemble best: {ensemble_best_combination}")
+
+    # strategy comparison
+    print_strategy_comparison(single_strategy_res, 'single', single_best_combination)
+    print_strategy_comparison(ensemble_strategy_res, 'ensemble', ensemble_best_combination)
+    
+    single_best_score = single_strategy_res[single_best_strategy]['ensemble_score']
+    ensemble_best_score = ensemble_strategy_res[ensemble_best_strategy]['ensemble_score']
+    if ensemble_best_score > single_best_score: # 比较选出 单模型 和 集成模型 中更好的
+        final_ml_pred, final_ml_strategy = ensemble_test_pred, ensemble_best_combination
+        final_ml_score, strategy_type = ensemble_best_score, "ensemble ml"
+    else:
+        final_ml_pred, final_ml_strategy = single_test_pred, single_best_combination
+        final_ml_score, strategy_type = single_best_score, "single ml"
+    print(f"{'='*50}\n\tBest ML strategy: {strategy_type} - {final_ml_strategy}\nBest score: {final_ml_score:.6f}")
+
+
+    # DL mlp
+    mlp_predictions, mlp_score = train_mlp_model(train, test)
+    print(f"{'='*50}\n\tMLP score: {mlp_score:.5f}")
+
+    # generate submission
+    if mlp_predictions is not None: # mlp和最好的 ml模型进行集成制作 submission
+        best_predictions, best_filename = create_multiple_submissions(
+            train, final_ml_pred, mlp_predictions, submission,
+            final_ml_strategy.replace(' ', '_').lower(), final_ml_score, mlp_score)
+    else: # ML only
+        submission[Config.TARGET] = final_ml_pred
+        best_filename = f"submission_{final_ml_strategy.replace(' ', '_').lower()}_{final_ml_score:.6f}.csv"
+        best_filepath = os.path.join(Config.SUBMISSION_DIR, best_filename)
+        submission.to_csv(best_filepath, index = False)
+        print(f"ML submission saved to {best_filepath}")
+        best_predictions, final_score = final_ml_pred, final_ml_score
+    print(best_predictions, '\n', best_filename, '\n', final_score)
+
+    # summary analysis
+    results_summary = {
+        'ml_single_best': {'strategy': single_best_combination, 'score': single_best_score},
+        'ml_ensemble_best': {'strategy': ensemble_best_combination, 'score': ensemble_best_score},
+        'ml_final': {'strategy': final_ml_strategy, 'score': final_ml_score, 'type': strategy_type},
+        'mlp_score': mlp_score if mlp_predictions is not None else 'N/A',
+        'best_filename': best_filename
+    }
+    results_df = pd.DataFrame([results_summary])
+    summary_filepath = os.path.join(Config.RESULTS_DIR, 'comprehensive_results_summary.csv')
+    results_df.to_csv(summary_filepath, index = False)
+
+
+
+if __name__ == "__main__":
+    flow()
+
+

DRW/DRW-Crypto/optimize_params.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+# @Time : 2025/7
+# @Author : Lukax
+# @Email : Lukarxiang@gmail.com
+# @File : optimize_params.py
+# -*- presentd: PyCharm -*-
+
+
+import os
+import json
+import argparse
+import pandas as pd
+from Utils import set_seed
+from Settings import Config
+from inplemental import load_data
+from HyperparameterOptimizer import HyperparameterManager, quick_optimize_single_model
+
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='超参数优化工具')
+    
+    parser.add_argument('--model', type = str, choices = ['xgb', 'lgb', 'cat', 'rf'], help = '选择要优化的模型')
+    parser.add_argument('--all', action = 'store_true', help = '优化所有模型')
+    parser.add_argument('--trials', type = int, default = 200, help = '搜参尝试次数')
+    parser.add_argument('--cv-folds', type = int, default = 5, help = '交叉验证折数')
+    parser.add_argument('--sample-ratio', type = float, default = None, help = '数据采样比例，用于快速测试 (默认全量)')
+    parser.add_argument('--update-config', action = 'store_true', help = '是否自动更新Config文件')
+    parser.add_argument('--output-dir', type = str, default = os.path.join('results', 'optimization_results'), help = '结果输出目录')
+    return parser.parse_args()
+
+
+def prepare_data(sample_ratio = None):
+    train, test, submission = load_data()
+    X, y = train[Config.FEATURES].fillna(0).values, train[Config.TARGET].values
+
+    if sample_ratio and sample_ratio < 1:
+        sample_size = int(len(X) * sample_ratio)
+        print(f"sample ratio {sample_ratio}, num {sample_size}")
+        indices = pd.Series(range(len(X))).sample(sample_size, random_state = Config.RANDOM_STATE)
+        X, y = X[indices], y[indices]
+
+    return X, y
+
+
+def optimize_single_model(model_name, X, y, trials, cv_folds, output_dir):
+    result = quick_optimize_single_model(model_name, X, y, n_trials = trials)
+    result_path = os.path.join(output_dir, f'{model_name}_optimization_result.json')
+    with open(result_path, 'w', encoding = 'utf-8') as f:
+        json.dump({
+            'model_name': model_name,
+            'best_params': result['best_params'],
+            'best_score': result['best_score'],
+            'n_trials': result['n_trials'],
+            'optimization_time': str(pd.Timestamp.now())
+        }, f, indent = 2, ensure_ascii = False)
+    print(f"{model_name} optimization completed!")
+    print(f"Results saved to: {result_path}")
+
+    return result
+
+
+def optimize_all_models(X, y, trials, cv_folds, output_dir):
+    manager = HyperparameterManager()
+    results = manager.optimize_all_models(X, y, n_trials = trials, cv_folds = cv_folds)
+
+    history_path = os.path.join(output_dir, 'optimization_history.png') # 绘制优化历史
+    manager.plot_optimization_history(history_path)
+
+    summary_path = os.path.join(output_dir, 'optimization_summary.json') # 保存所有结果摘要
+    summary = {}
+    for model_name, result in results.items():
+        summary[model_name] = {
+            'best_score': result['best_score'],
+            'n_trials': result['n_trials'],
+            'best_params': result['best_params']
+        }
+
+    with open(summary_path, 'w', encoding = 'utf-8') as f:
+        json.dump(summary, f, indent = 2, ensure_ascii = False)
+
+    print(f"Optimization summary saved to: {summary_path}")
+    return manager, results
+
+
+def print_optimization_summary(results):
+    if not results:
+        return
+        
+    print("\n" + "="*60)
+    print("Optimization Results Summary")
+    print("="*60)
+
+    sorted_results = sorted(results.items(), key = lambda x: x[1]['best_score'], reverse = True)
+    for model_name, result in sorted_results:
+        print(f"\n{model_name.upper()}")
+        print(f"   Best score: {result['best_score']:.6f}")
+        print(f"   Trials: {result['n_trials']}")
+        print(f"   Key parameters:")
+
+        key_params = ['learning_rate', 'n_estimators', 'max_depth', 'reg_alpha', 'reg_lambda']
+        for param in key_params:
+            if param in result['best_params']:
+                value = result['best_params'][param]
+                if isinstance(value, float):
+                    print(f"     {param}: {value:.5f}")
+                else:
+                    print(f"     {param}: {value}")
+
+
+def flow():
+    args = parse_args()
+    set_seed(Config.RANDOM_STATE)
+    os.makedirs(args.output_dir, exist_ok = True)
+    print(f"Output directory: {args.output_dir}")
+
+    X, y = prepare_data(getattr(args, 'sample_ratio', None))
+    results, manager = None, None
+    if args.model: # 单模型搜参
+        result = optimize_single_model(args.model, X, y, args.trials, args.cv_folds, args.output_dir)
+        if result:
+            results = {args.model: result}
+    elif args.all: # 全模型搜参
+        manager, results = optimize_all_models(X, y, args.trials, args.cv_folds, args.output_dir)
+    else:
+        raise ValueError("Please specify --model or --all parameter")
+
+    if results:
+        print_optimization_summary(results)
+        if args.update_config and manager: # 是否自动更新 Config中的参数
+            try:
+                manager.update_config()
+                print("Config file automatically updated")
+            except Exception as e:
+                print(f"Config file update failed: {str(e)}")
+                print("Please manually copy best parameters to Settings.py")
+    
+    print(f"\nHyperparameter optimization completed! Results saved in: {args.output_dir}")
+
+
+if __name__ == "__main__":
+    flow()
+

DRW/DRW-Crypto/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "drw-crypto"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "catboost>=1.2.8",
+    "hyperopt>=0.2.7",
+    "ipykernel>=6.29.5",
+    "lightgbm>=4.6.0",
+    "matplotlib>=3.10.3",
+    "mlflow>=3.1.1",
+    "numpy>=2.3.0",
+    "optuna>=4.4.0",
+    "optuna-dashboard>=0.19.0",
+    "pandas>=2.3.0",
+    "pandas-stubs>=2.3.0.250703",
+    "pyarrow>=20.0.0",
+    "ray>=2.47.1",
+    "scikit-learn>=1.7.0",
+    "scipy>=1.15.3",
+    "seaborn>=0.13.2",
+    "torch>=2.7.1",
+    "tqdm>=4.67.1",
+    "wandb>=0.21.0",
+    "xgboost>=3.0.2",
+]

DRW/DRW-Crypto/sub-sample-vs-super-sample-noisy-rows.ipynb

@@ -0,0 +1,1676 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "29f93930",
+   "metadata": {
+    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
+    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
+    "execution": {
+     "iopub.execute_input": "2025-06-30T18:33:21.460315Z",
+     "iopub.status.busy": "2025-06-30T18:33:21.459991Z",
+     "iopub.status.idle": "2025-06-30T18:33:22.876157Z",
+     "shell.execute_reply": "2025-06-30T18:33:22.875331Z"
+    },
+    "papermill": {
+     "duration": 1.420892,
+     "end_time": "2025-06-30T18:33:22.877295",
+     "exception": false,
+     "start_time": "2025-06-30T18:33:21.456403",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/kaggle/input/drw-crypto-market-prediction/sample_submission.csv\n",
+      "/kaggle/input/drw-crypto-market-prediction/train.parquet\n",
+      "/kaggle/input/drw-crypto-market-prediction/test.parquet\n"
+     ]
+    }
+   ],
+   "source": [
+    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
+    "# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n",
+    "# For example, here's several helpful packages to load\n",
+    "\n",
+    "import numpy as np # linear algebra\n",
+    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
+    "\n",
+    "# Input data files are available in the read-only \"../input/\" directory\n",
+    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
+    "\n",
+    "import os\n",
+    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
+    "    for filename in filenames:\n",
+    "        print(os.path.join(dirname, filename))\n",
+    "\n",
+    "# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n",
+    "# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "722ea210",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-06-30T18:33:22.882612Z",
+     "iopub.status.busy": "2025-06-30T18:33:22.882260Z",
+     "iopub.status.idle": "2025-07-01T04:45:09.686323Z",
+     "shell.execute_reply": "2025-07-01T04:45:09.685475Z"
+    },
+    "papermill": {
+     "duration": 36706.813726,
+     "end_time": "2025-07-01T04:45:09.693024",
+     "exception": false,
+     "start_time": "2025-06-30T18:33:22.879298",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using device: cpu\n",
+      "Loaded data - Train: (525887, 32), Test: (538150, 31), Submission: (538150, 2)\n",
+      "\n",
+      "=== Outlier Analysis ===\n",
+      "    Strategy 'reduce': Adjusted 525 outliers (0.1% of data)\n",
+      "\n",
+      "Total outliers detected: 525 (0.10%)\n",
+      "\n",
+      "Label statistics:\n",
+      "  Normal samples - Mean: 0.0379, Std: 0.9730\n",
+      "  Outlier samples - Mean: -1.7577, Std: 8.4272\n",
+      "  Label range - Normal: [-15.8988, 20.7403]\n",
+      "  Label range - Outliers: [-24.4166, 13.1532]\n",
+      "\n",
+      "Top features with extreme values in outliers:\n",
+      "  X345: 974.9% difference (outlier: -0.2079, normal: 0.0238)\n",
+      "  X598: 688.8% difference (outlier: -0.1776, normal: 0.0302)\n",
+      "  buy_qty: 367.4% difference (outlier: 613.4614, normal: 131.2453)\n",
+      "  X385: 121.7% difference (outlier: -0.0153, normal: 0.0704)\n",
+      "  X168: 82.7% difference (outlier: 0.0255, normal: 0.1475)\n",
+      "  X603: 82.2% difference (outlier: 0.2858, normal: 0.1568)\n",
+      "  X174: 79.9% difference (outlier: 0.0296, normal: 0.1474)\n",
+      "  X302: 72.7% difference (outlier: 0.0634, normal: 0.2318)\n",
+      "  X415: 61.9% difference (outlier: 0.0684, normal: 0.1798)\n",
+      "  X862: 58.3% difference (outlier: -0.8237, normal: -0.5202)\n",
+      "\n",
+      "=== Training XGBoost Models with Outlier Strategy Comparison ===\n",
+      "\n",
+      "==================================================\n",
+      "Testing outlier strategy: REDUCE\n",
+      "==================================================\n",
+      "\n",
+      "--- Fold 1/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 350591\n",
+      "  Training slice: last_85pct, samples: 350591\n",
+      "  Training slice: last_80pct, samples: 350591\n",
+      "  Training slice: oldest_25pct, samples: 0\n",
+      "    Strategy 'reduce': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "    Strategy 'reduce': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 350591\n",
+      "    Strategy 'reduce': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 350591\n",
+      "    Strategy 'reduce': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 350591\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 0\n",
+      "\n",
+      "--- Fold 2/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 298003\n",
+      "  Training slice: last_85pct, samples: 271708\n",
+      "  Training slice: last_80pct, samples: 245414\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "    Strategy 'reduce': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "    Strategy 'reduce': Adjusted 298 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298003\n",
+      "    Strategy 'reduce': Adjusted 271 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271708\n",
+      "    Strategy 'reduce': Adjusted 245 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245414\n",
+      "    Strategy 'reduce': Adjusted 131 outliers (0.1% of data)\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "--- Fold 3/3 ---\n",
+      "  Training slice: full_data, samples: 350592\n",
+      "  Training slice: last_90pct, samples: 298004\n",
+      "  Training slice: last_85pct, samples: 271709\n",
+      "  Training slice: last_80pct, samples: 245415\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "    Strategy 'reduce': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350592\n",
+      "    Strategy 'reduce': Adjusted 298 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298004\n",
+      "    Strategy 'reduce': Adjusted 271 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271709\n",
+      "    Strategy 'reduce': Adjusted 245 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245415\n",
+      "    Strategy 'reduce': Adjusted 131 outliers (0.1% of data)\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "REDUCE Strategy - Weighted Ensemble Pearson: 0.1101\n",
+      "  full_data_outlier_adj: 0.1077 (weight: 0.112)\n",
+      "  last_90pct_outlier_adj: 0.1096 (weight: 0.112)\n",
+      "  last_85pct_outlier_adj: 0.1010 (weight: 0.112)\n",
+      "  last_80pct_outlier_adj: 0.0992 (weight: 0.112)\n",
+      "  oldest_25pct_outlier_adj: 0.0727 (weight: 0.025)\n",
+      "\n",
+      "==================================================\n",
+      "Testing outlier strategy: REMOVE\n",
+      "==================================================\n",
+      "\n",
+      "--- Fold 1/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 350591\n",
+      "  Training slice: last_85pct, samples: 350591\n",
+      "  Training slice: last_80pct, samples: 350591\n",
+      "  Training slice: oldest_25pct, samples: 0\n",
+      "    Strategy 'remove': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "    Strategy 'remove': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 350591\n",
+      "    Strategy 'remove': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 350591\n",
+      "    Strategy 'remove': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 350591\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 0\n",
+      "\n",
+      "--- Fold 2/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 298003\n",
+      "  Training slice: last_85pct, samples: 271708\n",
+      "  Training slice: last_80pct, samples: 245414\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "    Strategy 'remove': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "    Strategy 'remove': Adjusted 298 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298003\n",
+      "    Strategy 'remove': Adjusted 271 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271708\n",
+      "    Strategy 'remove': Adjusted 245 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245414\n",
+      "    Strategy 'remove': Adjusted 131 outliers (0.1% of data)\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "--- Fold 3/3 ---\n",
+      "  Training slice: full_data, samples: 350592\n",
+      "  Training slice: last_90pct, samples: 298004\n",
+      "  Training slice: last_85pct, samples: 271709\n",
+      "  Training slice: last_80pct, samples: 245415\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "    Strategy 'remove': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350592\n",
+      "    Strategy 'remove': Adjusted 298 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298004\n",
+      "    Strategy 'remove': Adjusted 271 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271709\n",
+      "    Strategy 'remove': Adjusted 245 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245415\n",
+      "    Strategy 'remove': Adjusted 131 outliers (0.1% of data)\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "REMOVE Strategy - Weighted Ensemble Pearson: 0.1107\n",
+      "  full_data_outlier_adj: 0.1092 (weight: 0.112)\n",
+      "  last_90pct_outlier_adj: 0.1140 (weight: 0.112)\n",
+      "  last_85pct_outlier_adj: 0.1009 (weight: 0.112)\n",
+      "  last_80pct_outlier_adj: 0.0978 (weight: 0.112)\n",
+      "  oldest_25pct_outlier_adj: 0.0738 (weight: 0.025)\n",
+      "\n",
+      "==================================================\n",
+      "Testing outlier strategy: DOUBLE\n",
+      "==================================================\n",
+      "\n",
+      "--- Fold 1/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 350591\n",
+      "  Training slice: last_85pct, samples: 350591\n",
+      "  Training slice: last_80pct, samples: 350591\n",
+      "  Training slice: oldest_25pct, samples: 0\n",
+      "    Strategy 'double': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "    Strategy 'double': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 350591\n",
+      "    Strategy 'double': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 350591\n",
+      "    Strategy 'double': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 350591\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 0\n",
+      "\n",
+      "--- Fold 2/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 298003\n",
+      "  Training slice: last_85pct, samples: 271708\n",
+      "  Training slice: last_80pct, samples: 245414\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "    Strategy 'double': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "    Strategy 'double': Adjusted 298 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298003\n",
+      "    Strategy 'double': Adjusted 271 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271708\n",
+      "    Strategy 'double': Adjusted 245 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245414\n",
+      "    Strategy 'double': Adjusted 131 outliers (0.1% of data)\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "--- Fold 3/3 ---\n",
+      "  Training slice: full_data, samples: 350592\n",
+      "  Training slice: last_90pct, samples: 298004\n",
+      "  Training slice: last_85pct, samples: 271709\n",
+      "  Training slice: last_80pct, samples: 245415\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "    Strategy 'double': Adjusted 350 outliers (0.1% of data)\n",
+      "  Training slice: full_data_outlier_adj, samples: 350592\n",
+      "    Strategy 'double': Adjusted 298 outliers (0.1% of data)\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298004\n",
+      "    Strategy 'double': Adjusted 271 outliers (0.1% of data)\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271709\n",
+      "    Strategy 'double': Adjusted 245 outliers (0.1% of data)\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245415\n",
+      "    Strategy 'double': Adjusted 131 outliers (0.1% of data)\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "DOUBLE Strategy - Weighted Ensemble Pearson: 0.1108\n",
+      "  full_data_outlier_adj: 0.1085 (weight: 0.112)\n",
+      "  last_90pct_outlier_adj: 0.1073 (weight: 0.112)\n",
+      "  last_85pct_outlier_adj: 0.1060 (weight: 0.112)\n",
+      "  last_80pct_outlier_adj: 0.1007 (weight: 0.112)\n",
+      "  oldest_25pct_outlier_adj: 0.0684 (weight: 0.025)\n",
+      "\n",
+      "==================================================\n",
+      "Testing outlier strategy: NONE\n",
+      "==================================================\n",
+      "\n",
+      "--- Fold 1/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 350591\n",
+      "  Training slice: last_85pct, samples: 350591\n",
+      "  Training slice: last_80pct, samples: 350591\n",
+      "  Training slice: oldest_25pct, samples: 0\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 350591\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 350591\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 350591\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 0\n",
+      "\n",
+      "--- Fold 2/3 ---\n",
+      "  Training slice: full_data, samples: 350591\n",
+      "  Training slice: last_90pct, samples: 298003\n",
+      "  Training slice: last_85pct, samples: 271708\n",
+      "  Training slice: last_80pct, samples: 245414\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "  Training slice: full_data_outlier_adj, samples: 350591\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298003\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271708\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245414\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "--- Fold 3/3 ---\n",
+      "  Training slice: full_data, samples: 350592\n",
+      "  Training slice: last_90pct, samples: 298004\n",
+      "  Training slice: last_85pct, samples: 271709\n",
+      "  Training slice: last_80pct, samples: 245415\n",
+      "  Training slice: oldest_25pct, samples: 131471\n",
+      "  Training slice: full_data_outlier_adj, samples: 350592\n",
+      "  Training slice: last_90pct_outlier_adj, samples: 298004\n",
+      "  Training slice: last_85pct_outlier_adj, samples: 271709\n",
+      "  Training slice: last_80pct_outlier_adj, samples: 245415\n",
+      "  Training slice: oldest_25pct_outlier_adj, samples: 131471\n",
+      "\n",
+      "NONE Strategy - Weighted Ensemble Pearson: 0.1106\n",
+      "  full_data_outlier_adj: 0.1121 (weight: 0.112)\n",
+      "  last_90pct_outlier_adj: 0.1084 (weight: 0.112)\n",
+      "  last_85pct_outlier_adj: 0.1032 (weight: 0.112)\n",
+      "  last_80pct_outlier_adj: 0.1004 (weight: 0.112)\n",
+      "  oldest_25pct_outlier_adj: 0.0737 (weight: 0.025)\n",
+      "\n",
+      "==================================================\n",
+      "OUTLIER STRATEGY COMPARISON SUMMARY\n",
+      "==================================================\n",
+      "REDUCE: 0.1101 \n",
+      "REMOVE: 0.1107 \n",
+      "DOUBLE: 0.1108 ← BEST\n",
+      "NONE: 0.1106 \n",
+      "\n",
+      "Relative performance vs 'reduce' strategy:\n",
+      "  remove: +0.59%\n",
+      "  double: +0.65%\n",
+      "  none: +0.50%\n",
+      "\n",
+      "XGB Weighted Ensemble Pearson: 0.1108\n",
+      "\n",
+      "Individual slice OOF scores and weights:\n",
+      "  full_data: 0.1121 (weight: 0.124)\n",
+      "  last_90pct: 0.1084 (weight: 0.124)\n",
+      "  last_85pct: 0.1032 (weight: 0.124)\n",
+      "  last_80pct: 0.1004 (weight: 0.124)\n",
+      "  oldest_25pct: 0.0737 (weight: 0.031)\n",
+      "  full_data_outlier_adj: 0.1085 (weight: 0.112)\n",
+      "  last_90pct_outlier_adj: 0.1073 (weight: 0.112)\n",
+      "  last_85pct_outlier_adj: 0.1060 (weight: 0.112)\n",
+      "  last_80pct_outlier_adj: 0.1007 (weight: 0.112)\n",
+      "  oldest_25pct_outlier_adj: 0.0684 (weight: 0.025)\n",
+      "\n",
+      "Saved: submission_xgboost_double.csv\n",
+      "\n",
+      "=== Training MLP Model ===\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10: 100%|██████████| 13/13 [00:07<00:00,  1.68it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 16059.1512\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.93it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.0700 | Loss: 15180.1740\n",
+      "✅ New best model saved with Pearson: 0.0700\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/10: 100%|██████████| 13/13 [00:06<00:00,  2.02it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 15595.0242\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  3.01it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.0838 | Loss: 15198.4545\n",
+      "✅ New best model saved with Pearson: 0.0838\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/10: 100%|██████████| 13/13 [00:06<00:00,  1.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 15456.7179\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  3.01it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.0992 | Loss: 15219.1834\n",
+      "✅ New best model saved with Pearson: 0.0992\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/10: 100%|██████████| 13/13 [00:06<00:00,  2.04it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 15348.7826\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.97it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1021 | Loss: 15224.5020\n",
+      "✅ New best model saved with Pearson: 0.1021\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/10: 100%|██████████| 13/13 [00:06<00:00,  2.01it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 15229.8266\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.84it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1045 | Loss: 15242.1837\n",
+      "✅ New best model saved with Pearson: 0.1045\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/10: 100%|██████████| 13/13 [00:06<00:00,  1.89it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 15138.1736\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.99it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1075 | Loss: 15256.6681\n",
+      "✅ New best model saved with Pearson: 0.1075\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/10: 100%|██████████| 13/13 [00:06<00:00,  1.96it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 15046.1952\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.80it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1046 | Loss: 15321.9877\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/10: 100%|██████████| 13/13 [00:06<00:00,  1.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 14938.4061\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.91it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1099 | Loss: 15279.2798\n",
+      "✅ New best model saved with Pearson: 0.1099\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/10: 100%|██████████| 13/13 [00:06<00:00,  1.89it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 14854.4186\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.88it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1111 | Loss: 15291.8269\n",
+      "✅ New best model saved with Pearson: 0.1111\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/10: 100%|██████████| 13/13 [00:07<00:00,  1.85it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Loss: 14737.5036\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Validation: 100%|██████████| 4/4 [00:01<00:00,  2.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation Pearson Coef: 0.1117 | Loss: 15297.1565\n",
+      "✅ New best model saved with Pearson: 0.1117\n",
+      "Model loaded from best_mlp_model.pt with best Pearson: 0.1117\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Predicting: 100%|██████████| 17/17 [00:04<00:00,  3.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Saved: submission_mlp.csv\n",
+      "\n",
+      "Saved: submission_ensemble_double.csv (XGBoost: 90.0%, MLP: 10.0%)\n",
+      "\n",
+      "============================================================\n",
+      "FINAL SUMMARY\n",
+      "============================================================\n",
+      "\n",
+      "Best outlier strategy: DOUBLE\n",
+      "Best XGBoost CV score: 0.1108\n",
+      "\n",
+      "Strategy comparison (XGBoost ensemble scores):\n",
+      "  reduce: 0.1101\n",
+      "  remove: 0.1107\n",
+      "  double: 0.1108\n",
+      "  none: 0.1106\n",
+      "\n",
+      "Created submission files:\n",
+      "1. submission_xgboost_double.csv - XGBoost with double strategy\n",
+      "2. submission_mlp.csv - MLP only\n",
+      "3. submission_ensemble_double.csv - 90% XGBoost + 10% MLP\n",
+      "\n",
+      "Sample predictions (first 10 rows):\n",
+      "   ID   XGBoost       MLP  Ensemble\n",
+      "0   1  0.035090  0.217608  0.053342\n",
+      "1   2  0.018095 -0.070474  0.009238\n",
+      "2   3  0.136497  0.070964  0.129943\n",
+      "3   4 -0.085066 -0.007894 -0.077348\n",
+      "4   5  0.211597  0.238769  0.214314\n",
+      "5   6 -0.172887 -0.198609 -0.175459\n",
+      "6   7 -0.419656 -0.523997 -0.430090\n",
+      "7   8 -0.154374 -0.422084 -0.181145\n",
+      "8   9  0.222065 -0.204875  0.179371\n",
+      "9  10  0.096913  0.106206  0.097842\n",
+      "\n",
+      "============================================================\n",
+      "RECOMMENDATIONS\n",
+      "============================================================\n",
+      "\n",
+      "1. Outlier Handling Impact:\n",
+      "   ! Doubling outlier weights performs better\n",
+      "   → This suggests outliers contain valuable signal for extreme movements\n",
+      "\n",
+      "2. Overfitting Risk Assessment:\n",
+      "   ✓ Emphasizing outliers improves performance\n",
+      "   → Model benefits from learning extreme patterns\n",
+      "\n",
+      "3. Next Steps:\n",
+      "   • Test different outlier fractions (0.05%, 0.2%, 0.5%)\n",
+      "   • Try adaptive outlier detection per time slice\n",
+      "   • Consider feature-specific outlier handling\n",
+      "   • Monitor LB score vs CV score for overfitting signs\n",
+      "\n",
+      "4. Outlier Insights:\n",
+      "   • Detected 525 outliers (0.10% of data)\n",
+      "   • Consider creating synthetic outliers if 'double' strategy works well\n",
+      "   • Analyze time distribution of outliers for market regime insights\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import KFold, train_test_split\n",
+    "from xgboost import XGBRegressor\n",
+    "from scipy.stats import pearsonr\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from sklearn.ensemble import RandomForestRegressor\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from tqdm import tqdm\n",
+    "import random\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\", category=RuntimeWarning)\n",
+    "\n",
+    "# Deep Learning imports\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import DataLoader, TensorDataset\n",
+    "\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Using device: {device}\")\n",
+    "\n",
+    "# =========================\n",
+    "# Configuration\n",
+    "# =========================\n",
+    "class Config:\n",
+    "    TRAIN_PATH = \"/kaggle/input/drw-crypto-market-prediction/train.parquet\"\n",
+    "    TEST_PATH = \"/kaggle/input/drw-crypto-market-prediction/test.parquet\"\n",
+    "    SUBMISSION_PATH = \"/kaggle/input/drw-crypto-market-prediction/sample_submission.csv\"\n",
+    "\n",
+    "    FEATURES = [\n",
+    "        \"X863\", \"X856\", \"X598\", \"X862\", \"X385\", \"X852\", \"X603\", \"X860\", \"X674\",\n",
+    "        \"X415\", \"X345\", \"X855\", \"X174\", \"X302\", \"X178\", \"X168\", \"X612\", \"bid_qty\",\n",
+    "        \"ask_qty\", \"buy_qty\", \"sell_qty\", \"volume\", \"X888\", \"X421\", \"X333\",\"X817\", \n",
+    "        \"X586\",  \"X292\"\n",
+    "    ]\n",
+    "    \n",
+    "    # Features for MLP (subset)\n",
+    "    MLP_FEATURES = [\n",
+    "        \"X863\", \"X856\", \"X344\", \"X598\", \"X862\", \"X385\", \"X852\", \"X603\", \"X860\", \"X674\",\n",
+    "        \"X415\", \"X345\", \"X137\", \"X855\", \"X174\", \"X302\", \"X178\", \"X532\", \"X168\", \"X612\",\n",
+    "        \"bid_qty\", \"ask_qty\", \"buy_qty\", \"sell_qty\", \"volume\"\n",
+    "    ]\n",
+    "\n",
+    "    LABEL_COLUMN = \"label\"\n",
+    "    N_FOLDS = 3\n",
+    "    RANDOM_STATE = 42\n",
+    "    OUTLIER_FRACTION = 0.001  # 0.1% of records\n",
+    "    \n",
+    "    # Outlier handling strategies to test\n",
+    "    OUTLIER_STRATEGIES = [\"reduce\", \"remove\", \"double\", \"none\"]\n",
+    "\n",
+    "XGB_PARAMS = {\n",
+    "    \"tree_method\": \"hist\",\n",
+    "    \"device\": \"gpu\" if torch.cuda.is_available() else \"cpu\",\n",
+    "    \"colsample_bylevel\": 0.4778,\n",
+    "    \"colsample_bynode\": 0.3628,\n",
+    "    \"colsample_bytree\": 0.7107,\n",
+    "    \"gamma\": 1.7095,\n",
+    "    \"learning_rate\": 0.02213,\n",
+    "    \"max_depth\": 20,\n",
+    "    \"max_leaves\": 12,\n",
+    "    \"min_child_weight\": 16,\n",
+    "    \"n_estimators\": 1667,\n",
+    "    \"subsample\": 0.06567,\n",
+    "    \"reg_alpha\": 39.3524,\n",
+    "    \"reg_lambda\": 75.4484,\n",
+    "    \"verbosity\": 0,\n",
+    "    \"random_state\": Config.RANDOM_STATE,\n",
+    "    \"n_jobs\": -1\n",
+    "}\n",
+    "\n",
+    "LEARNERS = [\n",
+    "    {\"name\": \"xgb\", \"Estimator\": XGBRegressor, \"params\": XGB_PARAMS}\n",
+    "]\n",
+    "\n",
+    "# =========================\n",
+    "# Deep Learning Components\n",
+    "# =========================\n",
+    "def set_seed(seed=42):\n",
+    "    random.seed(seed)\n",
+    "    np.random.seed(seed)\n",
+    "    torch.manual_seed(seed)\n",
+    "    torch.cuda.manual_seed(seed)\n",
+    "    torch.cuda.manual_seed_all(seed)\n",
+    "    torch.backends.cudnn.deterministic = True\n",
+    "    torch.backends.cudnn.benchmark = False\n",
+    "\n",
+    "def get_activation_function(name):\n",
+    "    \"\"\"Return the activation function based on the name.\"\"\"\n",
+    "    if name == None:\n",
+    "        return None\n",
+    "    name = name.lower()\n",
+    "    if name == 'relu':\n",
+    "        return nn.ReLU()\n",
+    "    elif name == 'tanh':\n",
+    "        return nn.Tanh()\n",
+    "    elif name == 'sigmoid':\n",
+    "        return nn.Sigmoid()\n",
+    "    else:\n",
+    "        raise ValueError(f\"Unsupported activation function: {name}\")\n",
+    "\n",
+    "class MLP(nn.Module):\n",
+    "    def __init__(self, dropout_rate=0.6, \n",
+    "                 layers=[128, 64], activation='relu', last_activation=None):\n",
+    "        super(MLP, self).__init__()\n",
+    "        \n",
+    "        self.linears = nn.ModuleList()\n",
+    "        self.activation = get_activation_function(activation)\n",
+    "        self.last_activation = get_activation_function(last_activation)\n",
+    "\n",
+    "        for i in range(len(layers) - 1):\n",
+    "            self.linears.append(nn.Linear(layers[i], layers[i + 1]))\n",
+    "\n",
+    "        self.dropout = nn.Dropout(dropout_rate)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        for k in range(len(self.linears) - 1):\n",
+    "            x = self.activation(self.linears[k](x))\n",
+    "            x = self.dropout(x)\n",
+    "        x = self.linears[-1](x)\n",
+    "        if self.last_activation is not None:\n",
+    "            x = self.last_activation(x)\n",
+    "        return x\n",
+    "\n",
+    "class Checkpointer:\n",
+    "    def __init__(self, path=\"best_model.pt\"):\n",
+    "        self.path = path\n",
+    "        self.best_pearson = -np.inf\n",
+    "\n",
+    "    def load(self, model):\n",
+    "        \"\"\"Load the best model weights.\"\"\"\n",
+    "        model.load_state_dict(torch.load(self.path, map_location=device))\n",
+    "        print(f\"Model loaded from {self.path} with best Pearson: {self.best_pearson:.4f}\")\n",
+    "        return model\n",
+    "\n",
+    "    def __call__(self, pearson_coef, model):\n",
+    "        \"\"\"Call method to save the model if the Pearson coefficient is better than the best one.\"\"\"\n",
+    "        if pearson_coef > self.best_pearson:\n",
+    "            self.best_pearson = pearson_coef\n",
+    "            torch.save(model.state_dict(), self.path)\n",
+    "            print(f\"✅ New best model saved with Pearson: {pearson_coef:.4f}\")\n",
+    "\n",
+    "def get_dataloaders(X, Y, hparams, device, shuffle=True):\n",
+    "    \"\"\"Create DataLoader for training and validation datasets.\"\"\"\n",
+    "    X_tensor = torch.tensor(X, dtype=torch.float32, device=device)\n",
+    "    if Y is not None:\n",
+    "        Y_tensor = torch.tensor(Y.values if hasattr(Y, 'values') else Y, \n",
+    "                                dtype=torch.float32, device=device).unsqueeze(1)\n",
+    "        dataset = TensorDataset(X_tensor, Y_tensor)\n",
+    "    else:\n",
+    "        dataset = TensorDataset(X_tensor)\n",
+    "    \n",
+    "    dataloader = DataLoader(dataset, batch_size=hparams[\"batch_size\"], shuffle=shuffle, \n",
+    "                            generator=torch.Generator().manual_seed(hparams[\"seed\"]))\n",
+    "    return dataloader\n",
+    "\n",
+    "# =========================\n",
+    "# Feature Engineering\n",
+    "# =========================\n",
+    "def add_features(df):\n",
+    "    # Original features\n",
+    "    df['bid_ask_interaction'] = df['bid_qty'] * df['ask_qty']\n",
+    "    df['bid_buy_interaction'] = df['bid_qty'] * df['buy_qty']\n",
+    "    df['bid_sell_interaction'] = df['bid_qty'] * df['sell_qty']\n",
+    "    df['ask_buy_interaction'] = df['ask_qty'] * df['buy_qty']\n",
+    "    df['ask_sell_interaction'] = df['ask_qty'] * df['sell_qty']\n",
+    "\n",
+    "    df['volume_weighted_sell'] = df['sell_qty'] * df['volume']\n",
+    "    df['buy_sell_ratio'] = df['buy_qty'] / (df['sell_qty'] + 1e-10)\n",
+    "    df['selling_pressure'] = df['sell_qty'] / (df['volume'] + 1e-10)\n",
+    "    df['log_volume'] = np.log1p(df['volume'])\n",
+    "\n",
+    "    df['effective_spread_proxy'] = np.abs(df['buy_qty'] - df['sell_qty']) / (df['volume'] + 1e-10)\n",
+    "    df['bid_ask_imbalance'] = (df['bid_qty'] - df['ask_qty']) / (df['bid_qty'] + df['ask_qty'] + 1e-10)\n",
+    "    df['order_flow_imbalance'] = (df['buy_qty'] - df['sell_qty']) / (df['buy_qty'] + df['sell_qty'] + 1e-10)\n",
+    "    df['liquidity_ratio'] = (df['bid_qty'] + df['ask_qty']) / (df['volume'] + 1e-10)\n",
+    "    \n",
+    "    # === NEW MICROSTRUCTURE FEATURES ===\n",
+    "    \n",
+    "    # Price Pressure Indicators\n",
+    "    df['net_order_flow'] = df['buy_qty'] - df['sell_qty']\n",
+    "    df['normalized_net_flow'] = df['net_order_flow'] / (df['volume'] + 1e-10)\n",
+    "    df['buying_pressure'] = df['buy_qty'] / (df['volume'] + 1e-10)\n",
+    "    df['volume_weighted_buy'] = df['buy_qty'] * df['volume']\n",
+    "    \n",
+    "    # Liquidity Depth Measures\n",
+    "    df['total_depth'] = df['bid_qty'] + df['ask_qty']\n",
+    "    df['depth_imbalance'] = (df['bid_qty'] - df['ask_qty']) / (df['total_depth'] + 1e-10)\n",
+    "    df['relative_spread'] = np.abs(df['bid_qty'] - df['ask_qty']) / (df['total_depth'] + 1e-10)\n",
+    "    df['log_depth'] = np.log1p(df['total_depth'])\n",
+    "    \n",
+    "    # Order Flow Toxicity Proxies\n",
+    "    df['kyle_lambda'] = np.abs(df['net_order_flow']) / (df['volume'] + 1e-10)\n",
+    "    df['flow_toxicity'] = np.abs(df['order_flow_imbalance']) * df['volume']\n",
+    "    df['aggressive_flow_ratio'] = (df['buy_qty'] + df['sell_qty']) / (df['total_depth'] + 1e-10)\n",
+    "    \n",
+    "    # Market Activity Indicators\n",
+    "    df['volume_depth_ratio'] = df['volume'] / (df['total_depth'] + 1e-10)\n",
+    "    df['activity_intensity'] = (df['buy_qty'] + df['sell_qty']) / (df['volume'] + 1e-10)\n",
+    "    df['log_buy_qty'] = np.log1p(df['buy_qty'])\n",
+    "    df['log_sell_qty'] = np.log1p(df['sell_qty'])\n",
+    "    df['log_bid_qty'] = np.log1p(df['bid_qty'])\n",
+    "    df['log_ask_qty'] = np.log1p(df['ask_qty'])\n",
+    "    \n",
+    "    # Microstructure Volatility Proxies\n",
+    "    df['realized_spread_proxy'] = 2 * np.abs(df['net_order_flow']) / (df['volume'] + 1e-10)\n",
+    "    df['price_impact_proxy'] = df['net_order_flow'] / (df['total_depth'] + 1e-10)\n",
+    "    df['quote_volatility_proxy'] = np.abs(df['depth_imbalance'])\n",
+    "    \n",
+    "    # Complex Interaction Terms\n",
+    "    df['flow_depth_interaction'] = df['net_order_flow'] * df['total_depth']\n",
+    "    df['imbalance_volume_interaction'] = df['order_flow_imbalance'] * df['volume']\n",
+    "    df['depth_volume_interaction'] = df['total_depth'] * df['volume']\n",
+    "    df['buy_sell_spread'] = np.abs(df['buy_qty'] - df['sell_qty'])\n",
+    "    df['bid_ask_spread'] = np.abs(df['bid_qty'] - df['ask_qty'])\n",
+    "    \n",
+    "    # Information Asymmetry Measures\n",
+    "    df['trade_informativeness'] = df['net_order_flow'] / (df['bid_qty'] + df['ask_qty'] + 1e-10)\n",
+    "    df['execution_shortfall_proxy'] = df['buy_sell_spread'] / (df['volume'] + 1e-10)\n",
+    "    df['adverse_selection_proxy'] = df['net_order_flow'] / (df['total_depth'] + 1e-10) * df['volume']\n",
+    "    \n",
+    "    # Market Efficiency Indicators\n",
+    "    df['fill_probability'] = df['volume'] / (df['buy_qty'] + df['sell_qty'] + 1e-10)\n",
+    "    df['execution_rate'] = (df['buy_qty'] + df['sell_qty']) / (df['total_depth'] + 1e-10)\n",
+    "    df['market_efficiency'] = df['volume'] / (df['bid_ask_spread'] + 1e-10)\n",
+    "    \n",
+    "    # Non-linear Transformations\n",
+    "    df['sqrt_volume'] = np.sqrt(df['volume'])\n",
+    "    df['sqrt_depth'] = np.sqrt(df['total_depth'])\n",
+    "    df['volume_squared'] = df['volume'] ** 2\n",
+    "    df['imbalance_squared'] = df['order_flow_imbalance'] ** 2\n",
+    "    \n",
+    "    # Relative Measures\n",
+    "    df['bid_ratio'] = df['bid_qty'] / (df['total_depth'] + 1e-10)\n",
+    "    df['ask_ratio'] = df['ask_qty'] / (df['total_depth'] + 1e-10)\n",
+    "    df['buy_ratio'] = df['buy_qty'] / (df['buy_qty'] + df['sell_qty'] + 1e-10)\n",
+    "    df['sell_ratio'] = df['sell_qty'] / (df['buy_qty'] + df['sell_qty'] + 1e-10)\n",
+    "    \n",
+    "    # Market Stress Indicators\n",
+    "    df['liquidity_consumption'] = (df['buy_qty'] + df['sell_qty']) / (df['total_depth'] + 1e-10)\n",
+    "    df['market_stress'] = df['volume'] / (df['total_depth'] + 1e-10) * np.abs(df['order_flow_imbalance'])\n",
+    "    df['depth_depletion'] = df['volume'] / (df['bid_qty'] + df['ask_qty'] + 1e-10)\n",
+    "    \n",
+    "    # Directional Indicators\n",
+    "    df['net_buying_ratio'] = df['net_order_flow'] / (df['volume'] + 1e-10)\n",
+    "    df['directional_volume'] = df['net_order_flow'] * np.log1p(df['volume'])\n",
+    "    df['signed_volume'] = np.sign(df['net_order_flow']) * df['volume']\n",
+    "    \n",
+    "    # Replace infinities and NaNs\n",
+    "    df = df.replace([np.inf, -np.inf], 0).fillna(0)\n",
+    "    \n",
+    "    return df\n",
+    "\n",
+    "def create_time_decay_weights(n: int, decay: float = 0.9) -> np.ndarray:\n",
+    "    positions = np.arange(n)\n",
+    "    normalized = positions / (n - 1) if n > 1 else positions\n",
+    "    weights = decay ** (1.0 - normalized)\n",
+    "    return weights * n / weights.sum()\n",
+    "\n",
+    "def detect_outliers_and_adjust_weights(X, y, sample_weights, outlier_fraction=0.001, strategy=\"reduce\"):\n",
+    "    \"\"\"\n",
+    "    Detect outliers based on prediction residuals and adjust their weights.\n",
+    "    \n",
+    "    Strategies:\n",
+    "    - \"reduce\": Current approach - reduce weights to 0.2-0.8x\n",
+    "    - \"remove\": Set outlier weights to 0 (effectively removing them)\n",
+    "    - \"double\": Double the weights of outliers\n",
+    "    - \"none\": No adjustment\n",
+    "    \"\"\"\n",
+    "    if strategy == \"none\":\n",
+    "        return sample_weights, np.zeros(len(y), dtype=bool)\n",
+    "    \n",
+    "    # Ensure we have at least some samples to detect outliers\n",
+    "    n_samples = len(y)\n",
+    "    if n_samples < 100:  # Not enough samples for meaningful outlier detection\n",
+    "        print(f\"    Too few samples ({n_samples}) for outlier detection\")\n",
+    "        return sample_weights, np.zeros(n_samples, dtype=bool)\n",
+    "    \n",
+    "    # Train a simple model to get residuals\n",
+    "    rf = RandomForestRegressor(n_estimators=50, max_depth=10, random_state=42, n_jobs=-1)\n",
+    "    rf.fit(X, y, sample_weight=sample_weights)\n",
+    "    \n",
+    "    # Calculate residuals\n",
+    "    predictions = rf.predict(X)\n",
+    "    residuals = np.abs(y - predictions)\n",
+    "    \n",
+    "    # Find threshold for top outlier_fraction\n",
+    "    # Ensure we have at least 1 outlier\n",
+    "    n_outliers = max(1, int(len(residuals) * outlier_fraction))\n",
+    "    \n",
+    "    # Sort residuals and get threshold\n",
+    "    sorted_residuals = np.sort(residuals)\n",
+    "    threshold = sorted_residuals[-n_outliers] if n_outliers <= len(residuals) else sorted_residuals[-1]\n",
+    "    \n",
+    "    # Create outlier mask\n",
+    "    outlier_mask = residuals >= threshold\n",
+    "    \n",
+    "    # Ensure we have exactly n_outliers (handle ties at threshold)\n",
+    "    if np.sum(outlier_mask) > n_outliers:\n",
+    "        # If we have too many due to ties, randomly select to get exact number\n",
+    "        outlier_indices = np.where(outlier_mask)[0]\n",
+    "        np.random.seed(42)\n",
+    "        selected_indices = np.random.choice(outlier_indices, n_outliers, replace=False)\n",
+    "        outlier_mask = np.zeros(len(y), dtype=bool)\n",
+    "        outlier_mask[selected_indices] = True\n",
+    "    \n",
+    "    # Adjust weights based on strategy\n",
+    "    adjusted_weights = sample_weights.copy()\n",
+    "    \n",
+    "    if outlier_mask.any():\n",
+    "        if strategy == \"reduce\":\n",
+    "            # Original approach: reduce weights proportionally\n",
+    "            outlier_residuals = residuals[outlier_mask]\n",
+    "            min_outlier_res = outlier_residuals.min()\n",
+    "            max_outlier_res = outlier_residuals.max()\n",
+    "            \n",
+    "            if max_outlier_res > min_outlier_res:\n",
+    "                normalized_residuals = (outlier_residuals - min_outlier_res) / (max_outlier_res - min_outlier_res)\n",
+    "            else:\n",
+    "                normalized_residuals = np.ones_like(outlier_residuals)\n",
+    "            \n",
+    "            weight_factors = 0.8 - 0.6 * normalized_residuals\n",
+    "            adjusted_weights[outlier_mask] *= weight_factors\n",
+    "            \n",
+    "        elif strategy == \"remove\":\n",
+    "            # Set outlier weights to 0\n",
+    "            adjusted_weights[outlier_mask] = 0\n",
+    "            \n",
+    "        elif strategy == \"double\":\n",
+    "            # Double the weights of outliers\n",
+    "            adjusted_weights[outlier_mask] *= 2.0\n",
+    "        \n",
+    "        print(f\"    Strategy '{strategy}': Adjusted {n_outliers} outliers ({outlier_fraction*100:.1f}% of data)\")\n",
+    "    \n",
+    "    return adjusted_weights, outlier_mask\n",
+    "\n",
+    "def load_data():\n",
+    "    # Load data with all features available\n",
+    "    all_features = list(set(Config.FEATURES + Config.MLP_FEATURES))\n",
+    "    train_df = pd.read_parquet(Config.TRAIN_PATH, columns=all_features + [Config.LABEL_COLUMN])\n",
+    "    test_df = pd.read_parquet(Config.TEST_PATH, columns=all_features)\n",
+    "    submission_df = pd.read_csv(Config.SUBMISSION_PATH)\n",
+    "    print(f\"Loaded data - Train: {train_df.shape}, Test: {test_df.shape}, Submission: {submission_df.shape}\")\n",
+    "\n",
+    "    # Add features\n",
+    "    train_df = add_features(train_df)\n",
+    "    test_df = add_features(test_df)\n",
+    "\n",
+    "    # Update Config.FEATURES with new features\n",
+    "    Config.FEATURES += [\n",
+    "        \"log_volume\", 'bid_ask_interaction', 'bid_buy_interaction', 'bid_sell_interaction', \n",
+    "        'ask_buy_interaction', 'ask_sell_interaction', 'net_order_flow', 'normalized_net_flow',\n",
+    "        'buying_pressure', 'volume_weighted_buy', 'total_depth', 'depth_imbalance',\n",
+    "        'relative_spread', 'log_depth', 'kyle_lambda', 'flow_toxicity', 'aggressive_flow_ratio',\n",
+    "        'volume_depth_ratio', 'activity_intensity', 'log_buy_qty', 'log_sell_qty',\n",
+    "        'log_bid_qty', 'log_ask_qty', 'realized_spread_proxy', 'price_impact_proxy',\n",
+    "        'quote_volatility_proxy', 'flow_depth_interaction', 'imbalance_volume_interaction',\n",
+    "        'depth_volume_interaction', 'buy_sell_spread', 'bid_ask_spread', 'trade_informativeness',\n",
+    "        'execution_shortfall_proxy', 'adverse_selection_proxy', 'fill_probability',\n",
+    "        'execution_rate', 'market_efficiency', 'sqrt_volume', 'sqrt_depth', 'volume_squared',\n",
+    "        'imbalance_squared', 'bid_ratio', 'ask_ratio', 'buy_ratio', 'sell_ratio',\n",
+    "        'liquidity_consumption', 'market_stress', 'depth_depletion', 'net_buying_ratio',\n",
+    "        'directional_volume', 'signed_volume'\n",
+    "    ]\n",
+    "\n",
+    "    return train_df.reset_index(drop=True), test_df.reset_index(drop=True), submission_df\n",
+    "\n",
+    "def get_model_slices(n_samples: int):\n",
+    "    # Original 5 slices\n",
+    "    base_slices = [\n",
+    "        {\"name\": \"full_data\", \"cutoff\": 0, \"is_oldest\": False, \"outlier_adjusted\": False},\n",
+    "        {\"name\": \"last_90pct\", \"cutoff\": int(0.10 * n_samples), \"is_oldest\": False, \"outlier_adjusted\": False},\n",
+    "        {\"name\": \"last_85pct\", \"cutoff\": int(0.15 * n_samples), \"is_oldest\": False, \"outlier_adjusted\": False},\n",
+    "        {\"name\": \"last_80pct\", \"cutoff\": int(0.20 * n_samples), \"is_oldest\": False, \"outlier_adjusted\": False},\n",
+    "        {\"name\": \"oldest_25pct\", \"cutoff\": int(0.25 * n_samples), \"is_oldest\": True, \"outlier_adjusted\": False},\n",
+    "    ]\n",
+    "    \n",
+    "    # Duplicate slices with outlier adjustment\n",
+    "    outlier_adjusted_slices = []\n",
+    "    for slice_info in base_slices:\n",
+    "        adjusted_slice = slice_info.copy()\n",
+    "        adjusted_slice[\"name\"] = f\"{slice_info['name']}_outlier_adj\"\n",
+    "        adjusted_slice[\"outlier_adjusted\"] = True\n",
+    "        outlier_adjusted_slices.append(adjusted_slice)\n",
+    "    \n",
+    "    return base_slices + outlier_adjusted_slices\n",
+    "\n",
+    "# =========================\n",
+    "# Outlier Analysis Functions\n",
+    "# =========================\n",
+    "def analyze_outliers(train_df):\n",
+    "    \"\"\"Analyze outliers in the training data\"\"\"\n",
+    "    print(\"\\n=== Outlier Analysis ===\")\n",
+    "    \n",
+    "    X = train_df[Config.FEATURES].values\n",
+    "    y = train_df[Config.LABEL_COLUMN].values\n",
+    "    \n",
+    "    # Get base weights\n",
+    "    sample_weights = create_time_decay_weights(len(train_df))\n",
+    "    \n",
+    "    # Detect outliers\n",
+    "    _, outlier_mask = detect_outliers_and_adjust_weights(\n",
+    "        X, y, sample_weights, outlier_fraction=Config.OUTLIER_FRACTION, strategy=\"reduce\"\n",
+    "    )\n",
+    "    \n",
+    "    # Analyze outlier characteristics\n",
+    "    outlier_indices = np.where(outlier_mask)[0]\n",
+    "    n_outliers = len(outlier_indices)\n",
+    "    \n",
+    "    print(f\"\\nTotal outliers detected: {n_outliers} ({n_outliers/len(train_df)*100:.2f}%)\")\n",
+    "    \n",
+    "    if n_outliers > 0:\n",
+    "        # Statistical analysis\n",
+    "        outlier_labels = y[outlier_mask]\n",
+    "        normal_labels = y[~outlier_mask]\n",
+    "        \n",
+    "        print(f\"\\nLabel statistics:\")\n",
+    "        print(f\"  Normal samples - Mean: {normal_labels.mean():.4f}, Std: {normal_labels.std():.4f}\")\n",
+    "        print(f\"  Outlier samples - Mean: {outlier_labels.mean():.4f}, Std: {outlier_labels.std():.4f}\")\n",
+    "        print(f\"  Label range - Normal: [{normal_labels.min():.4f}, {normal_labels.max():.4f}]\")\n",
+    "        print(f\"  Label range - Outliers: [{outlier_labels.min():.4f}, {outlier_labels.max():.4f}]\")\n",
+    "        \n",
+    "        # Feature analysis for outliers\n",
+    "        print(f\"\\nTop features with extreme values in outliers:\")\n",
+    "        feature_names = Config.FEATURES[:20]  # Analyze first 20 features\n",
+    "        outlier_features = train_df.iloc[outlier_indices][feature_names]\n",
+    "        normal_features = train_df.iloc[~outlier_mask][feature_names]\n",
+    "        \n",
+    "        feature_diffs = []\n",
+    "        for feat in feature_names:\n",
+    "            outlier_mean = outlier_features[feat].mean()\n",
+    "            normal_mean = normal_features[feat].mean()\n",
+    "            if normal_mean != 0:\n",
+    "                rel_diff = abs(outlier_mean - normal_mean) / abs(normal_mean)\n",
+    "                feature_diffs.append((feat, rel_diff, outlier_mean, normal_mean))\n",
+    "        \n",
+    "        feature_diffs.sort(key=lambda x: x[1], reverse=True)\n",
+    "        for feat, diff, out_mean, norm_mean in feature_diffs[:10]:\n",
+    "            print(f\"  {feat}: {diff*100:.1f}% difference (outlier: {out_mean:.4f}, normal: {norm_mean:.4f})\")\n",
+    "    else:\n",
+    "        print(\"\\nNo outliers detected with current threshold. Consider adjusting outlier_fraction.\")\n",
+    "    \n",
+    "    return outlier_indices\n",
+    "\n",
+    "# =========================\n",
+    "# XGBoost Training with Outlier Strategy Comparison\n",
+    "# =========================\n",
+    "def train_xgboost_with_outlier_comparison(train_df, test_df):\n",
+    "    \"\"\"Train XGBoost with different outlier handling strategies and compare results\"\"\"\n",
+    "    n_samples = len(train_df)\n",
+    "    \n",
+    "    # Store results for each strategy\n",
+    "    strategy_results = {strategy: {\"oof_scores\": [], \"slice_scores\": {}} \n",
+    "                       for strategy in Config.OUTLIER_STRATEGIES}\n",
+    "    \n",
+    "    # For final ensemble\n",
+    "    best_strategy = \"reduce\"  # Default to current approach\n",
+    "    best_score = -np.inf\n",
+    "    best_oof_preds = None\n",
+    "    best_test_preds = None\n",
+    "    \n",
+    "    for strategy in Config.OUTLIER_STRATEGIES:\n",
+    "        print(f\"\\n{'='*50}\")\n",
+    "        print(f\"Testing outlier strategy: {strategy.upper()}\")\n",
+    "        print(f\"{'='*50}\")\n",
+    "        \n",
+    "        # Get model slices for this strategy\n",
+    "        model_slices = get_model_slices(n_samples)\n",
+    "        \n",
+    "        oof_preds = {\n",
+    "            learner[\"name\"]: {s[\"name\"]: np.zeros(n_samples) for s in model_slices}\n",
+    "            for learner in LEARNERS\n",
+    "        }\n",
+    "        test_preds = {\n",
+    "            learner[\"name\"]: {s[\"name\"]: np.zeros(len(test_df)) for s in model_slices}\n",
+    "            for learner in LEARNERS\n",
+    "        }\n",
+    "        \n",
+    "        full_weights = create_time_decay_weights(n_samples)\n",
+    "        kf = KFold(n_splits=Config.N_FOLDS, shuffle=False)\n",
+    "        \n",
+    "        for fold, (train_idx, valid_idx) in enumerate(kf.split(train_df), start=1):\n",
+    "            print(f\"\\n--- Fold {fold}/{Config.N_FOLDS} ---\")\n",
+    "            X_valid = train_df.iloc[valid_idx][Config.FEATURES]\n",
+    "            y_valid = train_df.iloc[valid_idx][Config.LABEL_COLUMN]\n",
+    "            \n",
+    "            for s in model_slices:\n",
+    "                cutoff = s[\"cutoff\"]\n",
+    "                slice_name = s[\"name\"]\n",
+    "                is_oldest = s[\"is_oldest\"]\n",
+    "                outlier_adjusted = s.get(\"outlier_adjusted\", False)\n",
+    "                \n",
+    "                if is_oldest:\n",
+    "                    subset = train_df.iloc[:cutoff].reset_index(drop=True)\n",
+    "                    rel_idx = train_idx[train_idx < cutoff]\n",
+    "                    sw = np.ones(len(rel_idx))\n",
+    "                else:\n",
+    "                    subset = train_df.iloc[cutoff:].reset_index(drop=True)\n",
+    "                    rel_idx = train_idx[train_idx >= cutoff] - cutoff\n",
+    "                    sw = create_time_decay_weights(len(subset))[rel_idx] if cutoff > 0 else full_weights[train_idx]\n",
+    "                \n",
+    "                X_train = subset.iloc[rel_idx][Config.FEATURES]\n",
+    "                y_train = subset.iloc[rel_idx][Config.LABEL_COLUMN]\n",
+    "                \n",
+    "                # Apply outlier strategy if this is an outlier-adjusted slice\n",
+    "                if outlier_adjusted and len(X_train) > 100:\n",
+    "                    sw, _ = detect_outliers_and_adjust_weights(\n",
+    "                        X_train.values, \n",
+    "                        y_train.values, \n",
+    "                        sw, \n",
+    "                        outlier_fraction=Config.OUTLIER_FRACTION,\n",
+    "                        strategy=strategy\n",
+    "                    )\n",
+    "                \n",
+    "                print(f\"  Training slice: {slice_name}, samples: {len(X_train)}\")\n",
+    "                \n",
+    "                for learner in LEARNERS:\n",
+    "                    model = learner[\"Estimator\"](**learner[\"params\"])\n",
+    "                    model.fit(X_train, y_train, sample_weight=sw, eval_set=[(X_valid, y_valid)], verbose=False)\n",
+    "                    \n",
+    "                    if is_oldest:\n",
+    "                        oof_preds[learner[\"name\"]][slice_name][valid_idx] = model.predict(\n",
+    "                            train_df.iloc[valid_idx][Config.FEATURES]\n",
+    "                        )\n",
+    "                    else:\n",
+    "                        mask = valid_idx >= cutoff\n",
+    "                        if mask.any():\n",
+    "                            idxs = valid_idx[mask]\n",
+    "                            oof_preds[learner[\"name\"]][slice_name][idxs] = model.predict(\n",
+    "                                train_df.iloc[idxs][Config.FEATURES]\n",
+    "                            )\n",
+    "                        if cutoff > 0 and (~mask).any():\n",
+    "                            base_slice_name = slice_name.replace(\"_outlier_adj\", \"\")\n",
+    "                            if base_slice_name == slice_name:\n",
+    "                                fallback_slice = \"full_data\"\n",
+    "                            else:\n",
+    "                                fallback_slice = \"full_data_outlier_adj\"\n",
+    "                            oof_preds[learner[\"name\"]][slice_name][valid_idx[~mask]] = oof_preds[learner[\"name\"]][fallback_slice][\n",
+    "                                valid_idx[~mask]\n",
+    "                            ]\n",
+    "                    \n",
+    "                    test_preds[learner[\"name\"]][slice_name] += model.predict(test_df[Config.FEATURES])\n",
+    "        \n",
+    "        # Normalize test predictions\n",
+    "        for learner_name in test_preds:\n",
+    "            for slice_name in test_preds[learner_name]:\n",
+    "                test_preds[learner_name][slice_name] /= Config.N_FOLDS\n",
+    "        \n",
+    "        # Evaluate this strategy\n",
+    "        learner_name = 'xgb'\n",
+    "        \n",
+    "        # Weights for ensemble\n",
+    "        weights = np.array([\n",
+    "            1.0,   # full_data\n",
+    "            1.0,   # last_90pct\n",
+    "            1.0,   # last_85pct\n",
+    "            1.0,   # last_80pct\n",
+    "            0.25,  # oldest_25pct\n",
+    "            0.9,   # full_data_outlier_adj\n",
+    "            0.9,   # last_90pct_outlier_adj\n",
+    "            0.9,   # last_85pct_outlier_adj\n",
+    "            0.9,   # last_80pct_outlier_adj\n",
+    "            0.2    # oldest_25pct_outlier_adj\n",
+    "        ])\n",
+    "        weights = weights / weights.sum()\n",
+    "        \n",
+    "        oof_weighted = pd.DataFrame(oof_preds[learner_name]).values @ weights\n",
+    "        test_weighted = pd.DataFrame(test_preds[learner_name]).values @ weights\n",
+    "        score_weighted = pearsonr(train_df[Config.LABEL_COLUMN], oof_weighted)[0]\n",
+    "        \n",
+    "        print(f\"\\n{strategy.upper()} Strategy - Weighted Ensemble Pearson: {score_weighted:.4f}\")\n",
+    "        \n",
+    "        # Store individual slice scores\n",
+    "        slice_names = list(oof_preds[learner_name].keys())\n",
+    "        for i, slice_name in enumerate(slice_names):\n",
+    "            score = pearsonr(train_df[Config.LABEL_COLUMN], oof_preds[learner_name][slice_name])[0]\n",
+    "            strategy_results[strategy][\"slice_scores\"][slice_name] = score\n",
+    "            if \"outlier_adj\" in slice_name:\n",
+    "                print(f\"  {slice_name}: {score:.4f} (weight: {weights[i]:.3f})\")\n",
+    "        \n",
+    "        strategy_results[strategy][\"oof_scores\"].append(score_weighted)\n",
+    "        strategy_results[strategy][\"ensemble_score\"] = score_weighted\n",
+    "        strategy_results[strategy][\"oof_preds\"] = oof_weighted\n",
+    "        strategy_results[strategy][\"test_preds\"] = test_weighted\n",
+    "        \n",
+    "        # Track best strategy\n",
+    "        if score_weighted > best_score:\n",
+    "            best_score = score_weighted\n",
+    "            best_strategy = strategy\n",
+    "            best_oof_preds = oof_preds\n",
+    "            best_test_preds = test_preds\n",
+    "    \n",
+    "    # Print comparison summary\n",
+    "    print(f\"\\n{'='*50}\")\n",
+    "    print(\"OUTLIER STRATEGY COMPARISON SUMMARY\")\n",
+    "    print(f\"{'='*50}\")\n",
+    "    \n",
+    "    for strategy in Config.OUTLIER_STRATEGIES:\n",
+    "        score = strategy_results[strategy][\"ensemble_score\"]\n",
+    "        print(f\"{strategy.upper()}: {score:.4f} {'← BEST' if strategy == best_strategy else ''}\")\n",
+    "    \n",
+    "    # Analyze differences\n",
+    "    print(f\"\\nRelative performance vs 'reduce' strategy:\")\n",
+    "    reduce_score = strategy_results[\"reduce\"][\"ensemble_score\"]\n",
+    "    for strategy in Config.OUTLIER_STRATEGIES:\n",
+    "        if strategy != \"reduce\":\n",
+    "            score = strategy_results[strategy][\"ensemble_score\"]\n",
+    "            diff = (score - reduce_score) / reduce_score * 100\n",
+    "            print(f\"  {strategy}: {diff:+.2f}%\")\n",
+    "    \n",
+    "    return best_oof_preds, best_test_preds, model_slices, strategy_results, best_strategy\n",
+    "\n",
+    "# =========================\n",
+    "# MLP Training (unchanged)\n",
+    "# =========================\n",
+    "def train_mlp(train_df, test_df):\n",
+    "    print(\"\\n=== Training MLP Model ===\")\n",
+    "    \n",
+    "    # Hyperparameters\n",
+    "    hparams = {\n",
+    "        \"seed\": 42,\n",
+    "        \"num_epochs\": 10,\n",
+    "        \"batch_size\": 1024 * 8 * 4,\n",
+    "        \"learning_rate\": 0.001,\n",
+    "        \"weight_decay\": 1e-3,\n",
+    "        \"dropout_rate\": 0.6,\n",
+    "        \"layers\": [len(Config.MLP_FEATURES), 256, 64, 1],\n",
+    "        \"hidden_activation\": None,\n",
+    "        \"activation\": \"relu\",\n",
+    "        \"delta\": 5,\n",
+    "        \"noise_factor\": 0.005\n",
+    "    }\n",
+    "    \n",
+    "    set_seed(hparams[\"seed\"])\n",
+    "    \n",
+    "    # Prepare data for MLP\n",
+    "    X_train_full = train_df[Config.MLP_FEATURES].values\n",
+    "    y_train_full = train_df[Config.LABEL_COLUMN].values\n",
+    "    \n",
+    "    # Split for validation\n",
+    "    X_train, X_val, y_train, y_val = train_test_split(\n",
+    "        X_train_full, y_train_full, test_size=0.2, shuffle=False, random_state=42\n",
+    "    )\n",
+    "    \n",
+    "    # Scale data\n",
+    "    scaler = StandardScaler()\n",
+    "    X_train = scaler.fit_transform(X_train)\n",
+    "    X_val = scaler.transform(X_val)\n",
+    "    X_test = scaler.transform(test_df[Config.MLP_FEATURES].values)\n",
+    "    \n",
+    "    # Create dataloaders\n",
+    "    train_loader = get_dataloaders(X_train, y_train, hparams, device, shuffle=True)\n",
+    "    val_loader = get_dataloaders(X_val, y_val, hparams, device, shuffle=False)\n",
+    "    test_loader = get_dataloaders(X_test, None, hparams, device, shuffle=False)\n",
+    "    \n",
+    "    # Initialize model\n",
+    "    model = MLP(\n",
+    "        layers=hparams[\"layers\"],\n",
+    "        dropout_rate=hparams[\"dropout_rate\"],\n",
+    "        activation=hparams[\"activation\"],\n",
+    "        last_activation=hparams[\"hidden_activation\"],\n",
+    "    ).to(device)\n",
+    "    \n",
+    "    criterion = nn.HuberLoss(delta=hparams[\"delta\"], reduction='sum')\n",
+    "    optimizer = optim.Adam(model.parameters(), lr=hparams[\"learning_rate\"], \n",
+    "                          weight_decay=hparams[\"weight_decay\"])\n",
+    "    \n",
+    "    checkpointer = Checkpointer(path=\"best_mlp_model.pt\")\n",
+    "    \n",
+    "    # Training loop\n",
+    "    num_epochs = hparams[\"num_epochs\"]\n",
+    "    for epoch in range(num_epochs):\n",
+    "        model.train()\n",
+    "        running_loss = 0.0\n",
+    "\n",
+    "        for inputs, targets in tqdm(train_loader, desc=f\"Epoch {epoch+1}/{num_epochs}\"):\n",
+    "            inputs, targets = inputs.to(device), targets.to(device)\n",
+    "            \n",
+    "            # Add noise for robustness\n",
+    "            inputs = inputs + torch.randn_like(inputs) * hparams[\"noise_factor\"]\n",
+    "            \n",
+    "            optimizer.zero_grad()\n",
+    "            outputs = model(inputs)\n",
+    "            loss = criterion(outputs, targets)\n",
+    "            \n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            \n",
+    "            running_loss += loss.item() * inputs.size(0)\n",
+    "            \n",
+    "        running_loss = running_loss / len(train_loader.dataset)\n",
+    "        print(f\"Training Loss: {running_loss:.4f}\")\n",
+    "\n",
+    "        # Validation phase\n",
+    "        model.eval()\n",
+    "        val_loss = 0.0\n",
+    "        preds = []\n",
+    "        trues = []\n",
+    "        with torch.no_grad():\n",
+    "            for inputs, targets in tqdm(val_loader, desc=\"Validation\"):\n",
+    "                inputs, targets = inputs.to(device), targets.to(device)\n",
+    "                outputs = model(inputs)\n",
+    "                loss = criterion(outputs, targets)\n",
+    "                val_loss += loss.item() * inputs.size(0)\n",
+    "                preds.append(outputs.cpu().numpy())\n",
+    "                trues.append(targets.cpu().numpy())\n",
+    "\n",
+    "        val_loss /= len(val_loader.dataset)\n",
+    "        preds = np.concatenate(preds).flatten()\n",
+    "        trues = np.concatenate(trues).flatten()\n",
+    "        pearson_coef = pearsonr(preds, trues)[0]\n",
+    "        print(f\"Validation Pearson Coef: {pearson_coef:.4f} | Loss: {val_loss:.4f}\")\n",
+    "\n",
+    "        checkpointer(pearson_coef, model)\n",
+    "    \n",
+    "    # Load best model and make predictions\n",
+    "    model = checkpointer.load(model)\n",
+    "    model.eval()\n",
+    "    predictions = []\n",
+    "    with torch.no_grad():\n",
+    "        for inputs in tqdm(test_loader, desc=\"Predicting\"):\n",
+    "            inputs = inputs[0].to(device)\n",
+    "            outputs = model(inputs)\n",
+    "            predictions.append(outputs.cpu().numpy())\n",
+    "\n",
+    "    predictions = np.concatenate(predictions).flatten()\n",
+    "    \n",
+    "    return predictions\n",
+    "\n",
+    "# =========================\n",
+    "# Ensemble & Submission Functions\n",
+    "# =========================\n",
+    "def create_xgboost_submission(train_df, oof_preds, test_preds, submission_df, strategy=\"reduce\"):\n",
+    "    learner_name = 'xgb'\n",
+    "    \n",
+    "    # Weights for 10 slices\n",
+    "    weights = np.array([\n",
+    "        1.0,   # full_data\n",
+    "        1.0,   # last_90pct\n",
+    "        1.0,   # last_85pct\n",
+    "        1.0,   # last_80pct\n",
+    "        0.25,  # oldest_25pct\n",
+    "        0.9,   # full_data_outlier_adj\n",
+    "        0.9,   # last_90pct_outlier_adj\n",
+    "        0.9,   # last_85pct_outlier_adj\n",
+    "        0.9,   # last_80pct_outlier_adj\n",
+    "        0.2    # oldest_25pct_outlier_adj\n",
+    "    ])\n",
+    "    \n",
+    "    # Normalize weights\n",
+    "    weights = weights / weights.sum()\n",
+    "\n",
+    "    oof_weighted = pd.DataFrame(oof_preds[learner_name]).values @ weights\n",
+    "    test_weighted = pd.DataFrame(test_preds[learner_name]).values @ weights\n",
+    "    score_weighted = pearsonr(train_df[Config.LABEL_COLUMN], oof_weighted)[0]\n",
+    "    print(f\"\\n{learner_name.upper()} Weighted Ensemble Pearson: {score_weighted:.4f}\")\n",
+    "\n",
+    "    # Print individual slice scores and weights for analysis\n",
+    "    print(\"\\nIndividual slice OOF scores and weights:\")\n",
+    "    slice_names = list(oof_preds[learner_name].keys())\n",
+    "    for i, slice_name in enumerate(slice_names):\n",
+    "        score = pearsonr(train_df[Config.LABEL_COLUMN], oof_preds[learner_name][slice_name])[0]\n",
+    "        print(f\"  {slice_name}: {score:.4f} (weight: {weights[i]:.3f})\")\n",
+    "\n",
+    "    # Save XGBoost submission\n",
+    "    xgb_submission = submission_df.copy()\n",
+    "    xgb_submission[\"prediction\"] = test_weighted\n",
+    "    xgb_submission.to_csv(f\"submission_xgboost_{strategy}.csv\", index=False)\n",
+    "    print(f\"\\nSaved: submission_xgboost_{strategy}.csv\")\n",
+    "    \n",
+    "    return test_weighted\n",
+    "\n",
+    "def create_ensemble_submission(xgb_predictions, mlp_predictions, submission_df, \n",
+    "                             xgb_weight=0.9, mlp_weight=0.1, suffix=\"\"):\n",
+    "    # Ensemble predictions\n",
+    "    ensemble_predictions = (xgb_weight * xgb_predictions + \n",
+    "                          mlp_weight * mlp_predictions)\n",
+    "    \n",
+    "    # Save ensemble submission\n",
+    "    ensemble_submission = submission_df.copy()\n",
+    "    ensemble_submission[\"prediction\"] = ensemble_predictions\n",
+    "    filename = f\"submission_ensemble{suffix}.csv\"\n",
+    "    ensemble_submission.to_csv(filename, index=False)\n",
+    "    print(f\"\\nSaved: {filename} (XGBoost: {xgb_weight*100}%, MLP: {mlp_weight*100}%)\")\n",
+    "    \n",
+    "    return ensemble_predictions\n",
+    "\n",
+    "# =========================\n",
+    "# Main Execution\n",
+    "# =========================\n",
+    "if __name__ == \"__main__\":\n",
+    "    # Load data\n",
+    "    train_df, test_df, submission_df = load_data()\n",
+    "    \n",
+    "    # Analyze outliers\n",
+    "    outlier_indices = analyze_outliers(train_df)\n",
+    "    \n",
+    "    # Train XGBoost with outlier comparison\n",
+    "    print(\"\\n=== Training XGBoost Models with Outlier Strategy Comparison ===\")\n",
+    "    best_oof_preds, best_test_preds, model_slices, strategy_results, best_strategy = \\\n",
+    "        train_xgboost_with_outlier_comparison(train_df, test_df)\n",
+    "    \n",
+    "    # Create XGBoost submission with best strategy\n",
+    "    xgb_predictions = create_xgboost_submission(\n",
+    "        train_df, best_oof_preds, best_test_preds, submission_df, strategy=best_strategy\n",
+    "    )\n",
+    "    \n",
+    "    # Train MLP model\n",
+    "    mlp_predictions = train_mlp(train_df, test_df)\n",
+    "    \n",
+    "    # Save MLP submission\n",
+    "    mlp_submission = submission_df.copy()\n",
+    "    mlp_submission[\"prediction\"] = mlp_predictions\n",
+    "    mlp_submission.to_csv(\"submission_mlp.csv\", index=False)\n",
+    "    print(\"\\nSaved: submission_mlp.csv\")\n",
+    "    \n",
+    "    # Create ensemble submission\n",
+    "    ensemble_predictions = create_ensemble_submission(\n",
+    "        xgb_predictions, mlp_predictions, submission_df,\n",
+    "        xgb_weight=0.9, mlp_weight=0.1, suffix=f\"_{best_strategy}\"\n",
+    "    )\n",
+    "    \n",
+    "    # Print final summary\n",
+    "    print(\"\\n\" + \"=\"*60)\n",
+    "    print(\"FINAL SUMMARY\")\n",
+    "    print(\"=\"*60)\n",
+    "    print(f\"\\nBest outlier strategy: {best_strategy.upper()}\")\n",
+    "    print(f\"Best XGBoost CV score: {strategy_results[best_strategy]['ensemble_score']:.4f}\")\n",
+    "    \n",
+    "    print(\"\\nStrategy comparison (XGBoost ensemble scores):\")\n",
+    "    for strategy in Config.OUTLIER_STRATEGIES:\n",
+    "        score = strategy_results[strategy][\"ensemble_score\"]\n",
+    "        print(f\"  {strategy}: {score:.4f}\")\n",
+    "    \n",
+    "    print(\"\\nCreated submission files:\")\n",
+    "    print(f\"1. submission_xgboost_{best_strategy}.csv - XGBoost with {best_strategy} strategy\")\n",
+    "    print(f\"2. submission_mlp.csv - MLP only\")\n",
+    "    print(f\"3. submission_ensemble_{best_strategy}.csv - 90% XGBoost + 10% MLP\")\n",
+    "    \n",
+    "    # Show sample predictions\n",
+    "    print(\"\\nSample predictions (first 10 rows):\")\n",
+    "    comparison_df = pd.DataFrame({\n",
+    "        'ID': submission_df['ID'][:10],\n",
+    "        'XGBoost': xgb_predictions[:10],\n",
+    "        'MLP': mlp_predictions[:10],\n",
+    "        'Ensemble': ensemble_predictions[:10]\n",
+    "    })\n",
+    "    print(comparison_df)\n",
+    "    \n",
+    "    # Provide recommendations\n",
+    "    print(\"\\n\" + \"=\"*60)\n",
+    "    print(\"RECOMMENDATIONS\")\n",
+    "    print(\"=\"*60)\n",
+    "    \n",
+    "    reduce_score = strategy_results[\"reduce\"][\"ensemble_score\"]\n",
+    "    remove_score = strategy_results[\"remove\"][\"ensemble_score\"]\n",
+    "    double_score = strategy_results[\"double\"][\"ensemble_score\"]\n",
+    "    none_score = strategy_results[\"none\"][\"ensemble_score\"]\n",
+    "    \n",
+    "    print(\"\\n1. Outlier Handling Impact:\")\n",
+    "    if best_strategy == \"reduce\":\n",
+    "        print(\"   ✓ Current approach (reduce weights) is optimal\")\n",
+    "    elif best_strategy == \"remove\":\n",
+    "        print(\"   ! Removing outliers completely performs better\")\n",
+    "        print(\"   → This suggests outliers are noise rather than informative extremes\")\n",
+    "    elif best_strategy == \"double\":\n",
+    "        print(\"   ! Doubling outlier weights performs better\")\n",
+    "        print(\"   → This suggests outliers contain valuable signal for extreme movements\")\n",
+    "    else:\n",
+    "        print(\"   ! No outlier adjustment performs better\")\n",
+    "        print(\"   → This suggests the model can handle outliers naturally\")\n",
+    "    \n",
+    "    print(\"\\n2. Overfitting Risk Assessment:\")\n",
+    "    if remove_score > reduce_score and remove_score > double_score:\n",
+    "        print(\"   ⚠ Removing outliers improves CV but may increase overfitting risk\")\n",
+    "        print(\"   → Consider using reduce strategy for better generalization\")\n",
+    "    elif double_score > reduce_score:\n",
+    "        print(\"   ✓ Emphasizing outliers improves performance\")\n",
+    "        print(\"   → Model benefits from learning extreme patterns\")\n",
+    "    \n",
+    "    print(\"\\n3. Next Steps:\")\n",
+    "    print(\"   • Test different outlier fractions (0.05%, 0.2%, 0.5%)\")\n",
+    "    print(\"   • Try adaptive outlier detection per time slice\")\n",
+    "    print(\"   • Consider feature-specific outlier handling\")\n",
+    "    print(\"   • Monitor LB score vs CV score for overfitting signs\")\n",
+    "    \n",
+    "    # Additional insights based on outlier analysis\n",
+    "    if len(outlier_indices) > 0:\n",
+    "        print(f\"\\n4. Outlier Insights:\")\n",
+    "        print(f\"   • Detected {len(outlier_indices)} outliers ({len(outlier_indices)/len(train_df)*100:.2f}% of data)\")\n",
+    "        print(\"   • Consider creating synthetic outliers if 'double' strategy works well\")\n",
+    "        print(\"   • Analyze time distribution of outliers for market regime insights\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "none",
+   "dataSources": [
+    {
+     "databundleVersionId": 11418275,
+     "sourceId": 96164,
+     "sourceType": "competition"
+    }
+   ],
+   "isGpuEnabled": false,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 36715.5898,
+   "end_time": "2025-07-01T04:45:13.424631",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "__notebook__.ipynb",
+   "output_path": "__notebook__.ipynb",
+   "parameters": {},
+   "start_time": "2025-06-30T18:33:17.834831",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

LYY/baseline1/pipeline1.py

@@ -0,0 +1,368 @@
+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 = {'colsample_bylevel': 0.6560588273380593, 'colsample_bynode': 0.6769350579560919, 
+              'colsample_bytree': 0.3510322798718793, 'gamma': 2.595734345886362, 'learning_rate': 0.04113611485673781, 
+              'max_depth': 16, 'max_leaves': 19, 'min_child_weight': 19, 'n_estimators': 733, 
+              'subsample': 0.19361102113761736, 
+              'reg_alpha': 11.540628202315595, 'reg_lambda': 64.64706922056,
+              "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)")

LYY/baseline1/submission_regularized_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ede4ae52eb080351a94bdc12853cfb623b6ca566b87bbe415b43cfe1880e87d
+size 14588439

LYY/baseline1/submission_robust_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29523d3694e9647df3c1d13925d05145c7a4c75d9ff9979f91d69ab5c6598630
+size 14317671

LYY/baseline1/submission_simple_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d011eb51bc219fe4b5d61a713decd9c4d9735a6d68a1effbad01361ddbab41e
+size 14477893

LYY/baseline1/submission_weighted_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:649ec6fa9bb33fef5219b422b243a8e4caa240c2f66d8d4501991a84f4fe5bca
+size 14602456

LYY/baseline1/submission_xgb_baseline.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d55ff5345659500437b59bc653be57981d49964394f1863789263e9983ba3040
+size 14487926

LYY/pipeline.py

@@ -0,0 +1,379 @@
+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)")

LYY/submission_regularized_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5654d21c2c4fd4437c26500d11e96cede3215ca5f84f143d39c5e6288a72aed9
+size 14587831

LYY/submission_robust_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7610b14ed05a3de9a9114e4b467fea0848e37de1df94cb5d4bddb5377ff9cc55
+size 14323736

LYY/submission_simple_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f7e6f77a0c3fb28182580d121e8e2ceb29c5c6f796eb8a4e4f7163f2ef1f39b
+size 14490859

LYY/submission_weighted_ensemble.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fa1c9268a667051893b05ff71e7c79e84d917e15f46854a1412fd7381f1ad16
+size 14619255

LYY/submission_xgb_baseline.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:140b5e22b6b87632d5a0496f60f6db851b91c3e5da1d4942d926fb9754661849
+size 14564582

LYY/xgb_hyper_search.py

@@ -0,0 +1,61 @@
+import optuna
+import pandas as pd
+import numpy as np
+from xgboost import XGBRegressor
+from sklearn.model_selection import KFold, cross_val_score
+from scipy.stats import pearsonr
+
+# 配置
+class Config:
+    TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/train.parquet"
+    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
+
+def pearson_scorer(y_true, y_pred):
+    return pearsonr(y_true, y_pred)[0]
+
+def objective(trial):
+    train_df = pd.read_parquet(Config.TRAIN_PATH, columns=Config.FEATURES + [Config.LABEL_COLUMN])
+    X = train_df[Config.FEATURES]
+    y = train_df[Config.LABEL_COLUMN]
+
+    params = {
+        "tree_method": "hist",
+        "device": "gpu",
+        "colsample_bylevel": trial.suggest_float("colsample_bylevel", 0.2, 1.0),
+        "colsample_bynode": trial.suggest_float("colsample_bynode", 0.2, 1.0),
+        "colsample_bytree": trial.suggest_float("colsample_bytree", 0.2, 1.0),
+        "gamma": trial.suggest_float("gamma", 0, 5),
+        "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.05, log=True),
+        "max_depth": trial.suggest_int("max_depth", 3, 24),
+        "max_leaves": trial.suggest_int("max_leaves", 4, 32),
+        "min_child_weight": trial.suggest_int("min_child_weight", 1, 32),
+        "n_estimators": trial.suggest_int("n_estimators", 300, 2000),
+        "subsample": trial.suggest_float("subsample", 0.05, 1.0),
+        "reg_alpha": trial.suggest_float("reg_alpha", 0, 50),
+        "reg_lambda": trial.suggest_float("reg_lambda", 0, 100),
+        "verbosity": 0,
+        "random_state": Config.RANDOM_STATE,
+        "n_jobs": -1
+    }
+
+    model = XGBRegressor(**params)
+    kf = KFold(n_splits=Config.N_FOLDS, shuffle=True, random_state=Config.RANDOM_STATE)
+    scores = cross_val_score(model, X, y, cv=kf, scoring="r2", n_jobs=-1)
+    mean_score = np.mean(scores)
+    # 限制分数，防止过拟合
+    if mean_score > 0.25:
+        return 0  # 或者 return -1，或者 return 0
+    return mean_score
+
+if __name__ == "__main__":
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=15)  # 可根据算力调整n_trials
+    print("最优参数：", study.best_params)
+    print("最优得分：", study.best_value)

ZMJ/alpha_mixed.py

@@ -0,0 +1,950 @@
+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
+import torch
+import matplotlib.pyplot as plt
+import seaborn as sns
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from itertools import combinations
+import time
+warnings.filterwarnings('ignore')
+
+# 设置中文字体
+plt.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
+plt.rcParams['axes.unicode_minus'] = False
+
+# ===== Configuration =====
+class Config:
+    TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/train.parquet"
+    TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/test.parquet"
+    # SUBMISSION_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/sample_submission_zmj.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"
+    # ]
+    
+    LABEL_COLUMN = "label"
+    N_FOLDS = 3
+    RANDOM_STATE = 42
+    
+    # 相关系数分析配置
+    CORRELATION_THRESHOLD = 0.8  # 相关系数阈值，大于此值的因子将被聚合
+    IC_WEIGHT_METHOD = "abs"     # IC权重计算方法: "abs", "square", "rank"
+    SAVE_RESULTS = True          # 是否保存分析结果
+    CREATE_VISUALIZATIONS = True # 是否创建可视化图表
+    REMOVE_ORIGINAL_FEATURES = True  # 是否删除原始特征
+    
+    # 性能优化配置
+    MAX_WORKERS = 4              # 并行计算的工作线程数
+    USE_SAMPLING = False          # 大数据集是否使用采样计算
+    SAMPLE_SIZE = 10000          # 采样大小
+    USE_GPU = True              # 是否使用GPU加速（需要PyTorch）
+    USE_MATRIX_MULTIPLICATION = True  # 是否使用矩阵乘法优化
+
+# ===== 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
+
+train_df = pd.read_parquet(Config.TRAIN_PATH)
+test_df = pd.read_parquet(Config.TEST_PATH)
+
+train_df = feature_engineering(train_df)
+
+# ===== 相关系数矩阵计算和因子聚合 =====
+def calculate_correlation_matrix_and_ic(train_df, features, label_col='label', correlation_threshold=0.8, max_workers=4, test_df=None):
+    """
+    计算特征间的相关系数矩阵和每个特征与标签的IC值（优化版本）
+    并对IC为负的特征先取反，使所有IC为正
+    """
+    # 确保特征列存在
+    available_features = [f for f in features if f in train_df.columns]
+    print(f"可用特征数量: {len(available_features)}")
+
+    # 1. 先计算IC值
+    ic_values = fast_ic_calculation(train_df, available_features, label_col, max_workers=max_workers)
+    print("初始IC统计：")
+    print(ic_values.describe())
+
+    # 2. 对IC为负的特征取反
+    neg_ic_features = ic_values[ic_values < 0].index.tolist()
+    print(f"IC为负的特征数量: {len(neg_ic_features)}")
+    for f in neg_ic_features:
+        train_df[f] = -train_df[f]
+        if test_df is not None and f in test_df.columns:
+            test_df[f] = -test_df[f]
+
+    # 3. 重新计算IC值（此时全为正）
+    ic_values = fast_ic_calculation(train_df, available_features, label_col, max_workers=max_workers)
+    print("IC取正后统计：")
+    print(ic_values.describe())
+
+    # 4. 计算相关系数矩阵
+    corr_matrix = fast_correlation_matrix(train_df, available_features, method='pearson', max_workers=max_workers)
+
+    # 5. 聚合
+    feature_groups = aggregate_correlated_features(
+        corr_matrix, ic_values, correlation_threshold
+    )
+
+    return corr_matrix, ic_values, feature_groups, train_df, test_df
+
+def aggregate_correlated_features(corr_matrix, ic_values, threshold=0.8):
+    """
+    基于相关系数和IC值对高相关因子进行聚合
+    
+    Parameters:
+    -----------
+    corr_matrix : pd.DataFrame
+        相关系数矩阵
+    ic_values : pd.Series
+        每个特征的IC值
+    threshold : float
+        相关系数阈值
+        
+    Returns:
+    --------
+    feature_groups : list
+        聚合后的特征组，每个组包含特征名和聚合权重
+    """
+    
+    features = list(corr_matrix.columns)
+    used_features = set()
+    feature_groups = []
+    
+    # 按IC值绝对值排序，优先选择IC值高的特征作为代表
+    ic_abs = ic_values.abs().sort_values(ascending=False)
+    
+    for feature in ic_abs.index:
+        if feature in used_features:
+            continue
+            
+        # 找到与当前特征高度相关的其他特征
+        correlated_features = []
+        for other_feature in features:
+            if other_feature != feature and other_feature not in used_features:
+                corr_value = abs(corr_matrix.loc[feature, other_feature])
+                if corr_value > threshold:
+                    correlated_features.append(other_feature)
+        
+        if correlated_features:
+            # 创建特征组，包含主特征和相关特征
+            group_features = [feature] + correlated_features
+            used_features.update(group_features)
+            
+            # 计算基于IC值的权重
+            group_ic_values = ic_values[group_features]
+            weights = calculate_ic_weighted_weights(group_ic_values, Config.IC_WEIGHT_METHOD)
+            
+            feature_groups.append({
+                'features': group_features,
+                'weights': weights,
+                'representative': feature,
+                'group_ic': group_ic_values.mean()
+            })
+            
+            print(f"特征组 {len(feature_groups)}: {feature} (IC={ic_values[feature]:.4f}) "
+                  f"与 {len(correlated_features)} 个特征聚合")
+            print(f"组{len(feature_groups) - 1} 权重: {weights}, 特征: {group_features}")
+            # if len(features) == 1:
+            #     print(f"单特征组: {features[0]}, 权重: {weights[0]}, 非零样本数: {(df[features[0]] != 0).sum()}")
+        else:
+            # 单独的特征
+            used_features.add(feature)
+            feature_groups.append({
+                'features': [feature],
+                'weights': [1.0],
+                'representative': feature,
+                'group_ic': ic_values[feature]
+            })
+    
+    return feature_groups
+
+def calculate_ic_weighted_weights(ic_values, method="abs"):
+    """
+    基于IC值计算特征权重
+    
+    Parameters:
+    -----------
+    ic_values : pd.Series
+        特征IC值
+    method : str
+        权重计算方法: "abs", "square", "rank"
+        
+    Returns:
+    --------
+    weights : list
+        归一化的权重列表
+    """
+    if method == "abs":
+        # 使用IC值的绝对值作为权重基础
+        weights_base = ic_values.abs()
+    elif method == "square":
+        # 使用IC值的平方作为权重基础
+        weights_base = ic_values ** 2
+    elif method == "rank":
+        # 使用IC值排名作为权重基础
+        weights_base = ic_values.abs().rank(ascending=False)
+    else:
+        raise ValueError(f"不支持的权重计算方法: {method}")
+    
+    # 避免零权重
+    weights_base = weights_base + 1e-8
+    
+    # 归一化权重
+    weights = weights_base / weights_base.sum()
+    
+    return weights.tolist()
+
+def calculate_optimal_ic_weights(df, features, label_col):
+    """
+    对于给定特征组，使用最大化IC合成法计算最优权重。
+    参数：
+        df: pd.DataFrame，包含特征和标签
+        features: list，特征名
+        label_col: str，标签名
+    返回：
+        weights: list，归一化权重
+    """
+    if len(features) == 1:
+        return [1.0]
+    Z = df[features].values
+    Z = (Z - Z.mean(axis=0)) / (Z.std(axis=0) + 1e-8)  # 标准化
+    R = df[label_col].values.reshape(-1, 1)
+    # 协方差矩阵
+    cov_ZZ = np.cov(Z, rowvar=False)
+    cov_ZR = np.cov(Z, R, rowvar=False)[:-1, -1]
+    # 防止协方差矩阵奇异，加微小正则项
+    cov_ZZ += np.eye(cov_ZZ.shape[0]) * 1e-6
+    # 求解最优权重
+    try:
+        w = np.linalg.solve(cov_ZZ, cov_ZR)
+    except np.linalg.LinAlgError:
+        w = np.linalg.lstsq(cov_ZZ, cov_ZR, rcond=None)[0]
+    # 归一化（L1范数）
+    if np.sum(np.abs(w)) > 1e-8:
+        w = w / np.sum(np.abs(w))
+    else:
+        w = np.ones_like(w) / len(w)
+    return w.tolist()
+
+def create_aggregated_features(df, feature_groups, remove_original=True, label_col=None):
+    """
+    基于特征组创建聚合特征（只用最大化IC合成法计算权重，并输出与IC加权对比）
+    """
+    aggregated_df = df.copy()
+    aggregated_original_features = set()
+    if label_col is None:
+        label_col = Config.LABEL_COLUMN
+    for i, group in enumerate(feature_groups):
+        features = group['features']
+        representative = group['representative']
+        # 检查所有特征是否都存在
+        missing_features = [f for f in features if f not in df.columns]
+        if missing_features:
+            print(f"警告: 特征组 {i} 中缺少特征: {missing_features}")
+            continue
+        # 最大化IC合成法权重
+        weights = calculate_optimal_ic_weights(df, features, label_col)
+        # IC加权（abs），每个特征和标签单独算皮尔逊相关系数
+        ic_vec = []
+        for f in features:
+            try:
+                ic = np.corrcoef(df[f], df[label_col])[0, 1]
+            except Exception:
+                ic = 0.0
+            ic_vec.append(ic)
+        ic_weights = calculate_ic_weighted_weights(pd.Series(ic_vec, index=features), method='abs')
+        print(f"组{i} features: {features}")
+        print(f"  最大化IC权重: {weights}")
+        print(f"  IC加权权重: {ic_weights}")
+        if len(features) == 1:
+            agg_feature = df[features[0]] * weights[0]
+        else:
+            agg_feature = sum(df[features[j]] * weights[j] for j in range(len(features)))
+        agg_feature_name = f"agg_group_{i}_{representative}"
+        aggregated_df[agg_feature_name] = agg_feature
+        print(f"创建聚合特征: {agg_feature_name} (包含 {len(features)} 个原始特征)")
+        aggregated_original_features.update(features)
+    # 删除原始特征
+    if remove_original:
+        features_to_remove = [f for f in aggregated_original_features if f in aggregated_df.columns]
+        if features_to_remove:
+            aggregated_df = aggregated_df.drop(columns=features_to_remove)
+            print(f"删除了 {len(features_to_remove)} 个原始特征: {features_to_remove}")
+        else:
+            print("没有需要删除的原始特征")
+    return aggregated_df
+
+# ===== 可视化函数 =====
+def visualize_correlation_and_ic(corr_matrix, ic_values, feature_groups, save_plots=True):
+    """
+    Visualize correlation matrix, IC distribution, and feature aggregation results (English version)
+    """
+    fig, axes = plt.subplots(2, 2, figsize=(20, 16))
+    fig.suptitle('Feature Correlation Analysis and IC Distribution', fontsize=16, fontweight='bold')
+    
+    # 1. Correlation matrix heatmap
+    mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
+    sns.heatmap(corr_matrix, mask=mask, annot=False, cmap='RdBu_r', center=0,
+                square=True, linewidths=0.5, cbar_kws={"shrink": .8}, ax=axes[0,0])
+    axes[0,0].set_title('Feature Correlation Matrix', fontsize=14, fontweight='bold')
+    
+    # 2. IC distribution histogram
+    axes[0,1].hist(ic_values.values, bins=30, alpha=0.7, color='skyblue', edgecolor='black')
+    axes[0,1].axvline(ic_values.mean(), color='red', linestyle='--', 
+                      label=f'Mean: {ic_values.mean():.4f}')
+    axes[0,1].axvline(0, color='green', linestyle='-', alpha=0.5, label='IC=0')
+    axes[0,1].set_xlabel('IC Value')
+    axes[0,1].set_ylabel('Frequency')
+    axes[0,1].set_title('Feature IC Value Distribution', fontsize=14, fontweight='bold')
+    axes[0,1].legend()
+    axes[0,1].grid(True, alpha=0.3)
+    
+    # 3. Top 20 highest IC features
+    top_ic_features = ic_values.abs().sort_values(ascending=False).head(20)
+    colors = ['red' if ic_values[feature] < 0 else 'blue' for feature in top_ic_features.index]
+    axes[1,0].barh(range(len(top_ic_features)), top_ic_features.values, color=colors, alpha=0.7)
+    axes[1,0].set_yticks(range(len(top_ic_features)))
+    axes[1,0].set_yticklabels(top_ic_features.index, fontsize=8)
+    axes[1,0].set_xlabel('|IC Value|')
+    axes[1,0].set_title('Top 20 |IC Value| Features', fontsize=14, fontweight='bold')
+    axes[1,0].grid(True, alpha=0.3)
+    
+    # 4. Feature aggregation results
+    group_sizes = [len(group['features']) for group in feature_groups]
+    group_ics = [group['group_ic'] for group in feature_groups]
+    single_features = [i for i, size in enumerate(group_sizes) if size == 1]
+    grouped_features = [i for i, size in enumerate(group_sizes) if size > 1]
+    if single_features:
+        axes[1,1].scatter([group_sizes[i] for i in single_features], 
+                         [group_ics[i] for i in single_features], 
+                         alpha=0.6, label='Single Feature', s=50)
+    if grouped_features:
+        axes[1,1].scatter([group_sizes[i] for i in grouped_features], 
+                         [group_ics[i] for i in grouped_features], 
+                         alpha=0.8, label='Aggregated Feature', s=100, color='red')
+    axes[1,1].set_xlabel('Feature Group Size')
+    axes[1,1].set_ylabel('Group Mean IC Value')
+    axes[1,1].set_title('Feature Aggregation Result', fontsize=14, fontweight='bold')
+    axes[1,1].legend()
+    axes[1,1].grid(True, alpha=0.3)
+    plt.tight_layout()
+    if save_plots:
+        plt.savefig('./max_IC_mixed/feature_analysis.png', dpi=300, bbox_inches='tight')
+        print("Saved feature analysis image: feature_analysis.png")
+    plt.show()
+
+def create_feature_summary_report(corr_matrix, ic_values, feature_groups):
+    """
+    创建特征分析报告
+    
+    Parameters:
+    -----------
+    corr_matrix : pd.DataFrame
+        相关系数矩阵
+    ic_values : pd.Series
+        特征IC值
+    feature_groups : list
+        特征组列表
+    """
+    
+    report = []
+    report.append("=" * 60)
+    report.append("Feature Analysis Report")
+    report.append("=" * 60)
+    
+    # 基本统计
+    report.append(f"\n1. Basic Statistical Information:")
+    report.append(f"    Total Feature Count: {len(ic_values)}")
+    report.append(f"    Average IC Value: {ic_values.mean():.4f}")
+    report.append(f"   IC Value Standard Deviation: {ic_values.std():.4f}")
+    report.append(f"    Maximum IC Value: {ic_values.max():.4f}")
+    report.append(f"    Minimum IC Value: {ic_values.min():.4f}")
+    report.append(f"    Positive IC Value Feature Count: {(ic_values > 0).sum()}")
+    report.append(f"    Negative IC Value Feature Count: {(ic_values < 0).sum()}")
+    
+    # 高相关性分析
+    high_corr_count = 0
+    for i in range(len(corr_matrix.columns)):
+        for j in range(i+1, len(corr_matrix.columns)):
+            if abs(corr_matrix.iloc[i, j]) > Config.CORRELATION_THRESHOLD:
+                high_corr_count += 1
+    
+    report.append(f"\n2. High Correlation Analysis (|Correlation| > {Config.CORRELATION_THRESHOLD}):")
+    report.append(f"    High Correlation Feature Pair Count: {high_corr_count}")
+    report.append(f"    Correlation Matrix Density: {high_corr_count / (len(corr_matrix) * (len(corr_matrix) - 1) / 2):.4f}")
+    
+    # 特征聚合结果
+    report.append(f"\n3. Feature Aggregation Results:")
+    report.append(f"    Feature Group Count: {len(feature_groups)}")
+    
+    single_features = [g for g in feature_groups if len(g['features']) == 1]
+    grouped_features = [g for g in feature_groups if len(g['features']) > 1]
+    
+    report.append(f"    Single Feature Group Count: {len(single_features)}")
+    report.append(f"    Aggregated Feature Group Count: {len(grouped_features)}")
+    
+    if grouped_features:
+        avg_group_size = np.mean([len(g['features']) for g in grouped_features])
+        report.append(f"    Average Aggregated Group Size: {avg_group_size:.2f}")
+    
+    # 前10个最高IC值特征
+    report.append(f"\n4. Top 10 Highest IC Value Features:")
+    top_ic = ic_values.abs().sort_values(ascending=False).head(10)
+    for i, (feature, ic_abs) in enumerate(top_ic.items(), 1):
+        ic_original = ic_values[feature]
+        report.append(f"   {i:2d}. {feature:20s} |IC|={ic_abs:.4f} (IC={ic_original:.4f})")
+    
+    # 特征聚合详情
+    report.append(f"\n5. Feature Aggregation Details:")
+    for i, group in enumerate(grouped_features, 1):
+        report.append(f"    Group {i}: {group['representative']} (IC={group['group_ic']:.4f})")
+        report.append(f"        Contains Features: {', '.join(group['features'])}")
+        report.append(f"        Weights: {[f'{w:.3f}' for w in group['weights']]}")
+    
+    # 保存报告
+    with open('./max_IC_mixed/feature_analysis_report.txt', 'w', encoding='utf-8') as f:
+        f.write('\n'.join(report))
+    
+    print('\n'.join(report))
+    print(f"\nReport Saved to: feature_analysis_report.txt")
+
+# ===== 优化的相关系数计算 =====
+def fast_correlation_matrix(df, features, method='pearson', max_workers=4):
+    """
+    快速计算相关系数矩阵，支持并行计算和多种优化策略
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    method : str
+        相关系数计算方法: 'pearson', 'spearman'
+    max_workers : int
+        并行计算的工作线程数
+        
+    Returns:
+    --------
+    corr_matrix : pd.DataFrame
+        相关系数矩阵
+    """
+    
+    print(f"开始计算相关系数矩阵 (特征数量: {len(features)}, 方法: {method})")
+    start_time = time.time()
+    
+    # 方法1: 使用矩阵乘法优化（最快）
+    if method == 'pearson' and Config.USE_MATRIX_MULTIPLICATION:
+        if Config.USE_GPU and torch.cuda.is_available():
+            corr_matrix = torch_correlation(df, features, use_gpu=True)
+            print(f"GPU矩阵乘法优化耗时: {time.time() - start_time:.2f}秒")
+        else:
+            corr_matrix = matrix_correlation(df, features)
+            print(f"CPU矩阵乘法优化耗时: {time.time() - start_time:.2f}秒")
+        return corr_matrix
+    
+    # 方法2: 对于大数据集，使用采样计算
+    if Config.USE_SAMPLING and len(df) > Config.SAMPLE_SIZE:
+        print(f"数据量较大，使用采样计算 (采样大小: {Config.SAMPLE_SIZE})...")
+        sample_size = min(Config.SAMPLE_SIZE, len(df))
+        sample_df = df.sample(n=sample_size, random_state=42)
+        feature_data = sample_df[features]
+        corr_matrix = feature_data.corr(method=method)
+        print(f"采样计算耗时: {time.time() - start_time:.2f}秒")
+        return corr_matrix
+    
+    # 方法3: 并行计算（适用于中等规模数据）
+    else:
+        print(f"使用并行计算 (线程数: {max_workers})...")
+        return parallel_correlation_matrix(df, features, method, max_workers)
+
+def matrix_correlation(df, features):
+    """
+    使用矩阵乘法计算相关系数矩阵 (A * A^T 方法)
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+        
+    Returns:
+    --------
+    corr_matrix : pd.DataFrame
+        相关系数矩阵
+    """
+    
+    # 提取特征数据
+    feature_data = df[features].values
+    
+    # 标准化数据 (z-score)
+    feature_data_std = (feature_data - feature_data.mean(axis=0)) / feature_data.std(axis=0)
+    
+    # 处理NaN值
+    feature_data_std = np.nan_to_num(feature_data_std, nan=0.0)
+    
+    # 计算相关系数矩阵: (A * A^T) / (n-1)
+    n = feature_data_std.shape[0]
+    corr_matrix_np = np.dot(feature_data_std.T, feature_data_std) / (n - 1)
+    
+    # 确保对角线为1
+    np.fill_diagonal(corr_matrix_np, 1.0)
+    
+    # 转换为DataFrame
+    corr_matrix = pd.DataFrame(corr_matrix_np, index=features, columns=features)
+    
+    return corr_matrix
+
+def torch_correlation(df, features, use_gpu=False):
+    """
+    使用PyTorch张量计算相关系数矩阵（可选GPU加速）
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    use_gpu : bool
+        是否使用GPU加速
+        
+    Returns:
+    --------
+    corr_matrix : pd.DataFrame
+        相关系数矩阵
+    """
+    
+    # 提取特征数据
+    feature_data = df[features].values
+    
+    # 转换为PyTorch张量
+    if use_gpu and torch.cuda.is_available():
+        device = torch.device('cuda')
+        print("使用GPU加速计算...")
+    else:
+        device = torch.device('cpu')
+        print("使用CPU计算...")
+    
+    # 转换为张量并移动到设备
+    X = torch.tensor(feature_data, dtype=torch.float32, device=device)
+    
+    # 标准化数据
+    X_mean = torch.mean(X, dim=0, keepdim=True)
+    X_std = torch.std(X, dim=0, keepdim=True, unbiased=True)
+    X_std = torch.where(X_std == 0, torch.ones_like(X_std), X_std)  # 避免除零
+    X_norm = (X - X_mean) / X_std
+    
+    # 处理NaN值
+    X_norm = torch.nan_to_num(X_norm, nan=0.0)
+    
+    # 计算相关系数矩阵: (X_norm^T * X_norm) / (n-1)
+    n = X_norm.shape[0]
+    corr_matrix_tensor = torch.mm(X_norm.T, X_norm) / (n - 1)
+    
+    # 确保对角线为1
+    torch.diagonal(corr_matrix_tensor)[:] = 1.0
+    
+    # 移回CPU并转换为numpy
+    corr_matrix_np = corr_matrix_tensor.cpu().numpy()
+    
+    # 转换为DataFrame
+    corr_matrix = pd.DataFrame(corr_matrix_np, index=features, columns=features)
+    
+    return corr_matrix
+
+def parallel_correlation_matrix(df, features, method='pearson', max_workers=4):
+    """
+    并行计算相关系数矩阵
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    method : str
+        相关系数计算方法
+    max_workers : int
+        并行计算的工作线程数
+        
+    Returns:
+    --------
+    corr_matrix : pd.DataFrame
+        相关系数矩阵
+    """
+    
+    def calculate_correlation_pair(pair):
+        """计算一对特征的相关系数"""
+        feat1, feat2 = pair
+        if method == 'pearson':
+            corr, _ = pearsonr(df[feat1], df[feat2])
+        else:  # spearman
+            corr = df[feat1].corr(df[feat2], method='spearman')
+        return (feat1, feat2, corr)
+    
+    # 生成所有特征对
+    feature_pairs = list(combinations(features, 2))
+    print(f"需要计算 {len(feature_pairs)} 个特征对的相关系数")
+    
+    # 并行计算
+    results = {}
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_pair = {executor.submit(calculate_correlation_pair, pair): pair for pair in feature_pairs}
+        
+        completed = 0
+        for future in as_completed(future_to_pair):
+            feat1, feat2, corr = future.result()
+            results[(feat1, feat2)] = corr
+            results[(feat2, feat1)] = corr  # 对称矩阵
+            completed += 1
+            
+            if completed % 100 == 0:
+                print(f"已完成: {completed}/{len(feature_pairs)} ({completed/len(feature_pairs)*100:.1f}%)")
+    
+    # 构建相关系数矩阵
+    corr_matrix = pd.DataFrame(index=features, columns=features)
+    for feat1 in features:
+        for feat2 in features:
+            if feat1 == feat2:
+                corr_matrix.loc[feat1, feat2] = 1.0
+            else:
+                corr_matrix.loc[feat1, feat2] = results.get((feat1, feat2), 0.0)
+    
+    return corr_matrix
+
+def fast_ic_calculation(df, features, label_col, max_workers=4):
+    """
+    快速计算特征IC值，支持并行计算
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    label_col : str
+        标签列名
+    max_workers : int
+        并行计算的工作线程数
+        
+    Returns:
+    --------
+    ic_values : pd.Series
+        特征IC值
+    """
+    
+    print(f"开始计算特征IC值 (特征数量: {len(features)})")
+    start_time = time.time()
+    
+    def calculate_ic(feature):
+        """计算单个特征的IC值"""
+        try:
+            ic, _ = pearsonr(df[feature], df[label_col])
+            return feature, ic
+        except:
+            return feature, 0.0
+    
+    # 并行计算IC值
+    ic_dict = {}
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_feature = {executor.submit(calculate_ic, feature): feature for feature in features}
+        
+        completed = 0
+        for future in as_completed(future_to_feature):
+            feature, ic = future.result()
+            ic_dict[feature] = ic
+            completed += 1
+            
+            if completed % 50 == 0:
+                print(f"IC计算进度: {completed}/{len(features)} ({completed/len(features)*100:.1f}%)")
+    
+    ic_values = pd.Series(ic_dict)
+    print(f"IC值计算耗时: {time.time() - start_time:.2f}秒")
+    
+    return ic_values
+
+def benchmark_correlation_methods(df, features, sample_size=1000):
+    """
+    比较不同相关系数计算方法的性能
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    sample_size : int
+        用于测试的样本大小
+        
+    Returns:
+    --------
+    results : dict
+        各方法的性能结果
+    """
+    
+    print("=" * 60)
+    print("相关系数计算方法性能比较")
+    print("=" * 60)
+    
+    # 采样数据用于测试
+    if len(df) > sample_size:
+        test_df = df.sample(n=sample_size, random_state=42)
+    else:
+        test_df = df
+    
+    test_features = features[:min(50, len(features))]  # 限制特征数量用于测试
+    print(f"测试数据: {len(test_df)} 行, {len(test_features)} 个特征")
+    
+    results = {}
+    
+    # 方法1: pandas corr()
+    print("\n1. 测试 pandas corr() 方法...")
+    start_time = time.time()
+    try:
+        feature_data = test_df[test_features]
+        corr_pandas = feature_data.corr()
+        pandas_time = time.time() - start_time
+        results['pandas_corr'] = {'time': pandas_time, 'success': True}
+        print(f"  耗时: {pandas_time:.3f}秒")
+    except Exception as e:
+        results['pandas_corr'] = {'time': float('inf'), 'success': False, 'error': str(e)}
+        print(f"  失败: {e}")
+    
+    # 方法2: 矩阵乘法 (CPU)
+    print("\n2. 测试矩阵乘法 (CPU)...")
+    start_time = time.time()
+    try:
+        corr_matrix = matrix_correlation(test_df, test_features)
+        matrix_time = time.time() - start_time
+        results['matrix_cpu'] = {'time': matrix_time, 'success': True}
+        print(f"  耗时: {matrix_time:.3f}秒")
+    except Exception as e:
+        results['matrix_cpu'] = {'time': float('inf'), 'success': False, 'error': str(e)}
+        print(f"  失败: {e}")
+    
+    # 方法3: PyTorch (CPU)
+    print("\n3. 测试 PyTorch (CPU)...")
+    start_time = time.time()
+    try:
+        corr_torch_cpu = torch_correlation(test_df, test_features, use_gpu=False)
+        torch_cpu_time = time.time() - start_time
+        results['torch_cpu'] = {'time': torch_cpu_time, 'success': True}
+        print(f"  耗时: {torch_cpu_time:.3f}秒")
+    except Exception as e:
+        results['torch_cpu'] = {'time': float('inf'), 'success': False, 'error': str(e)}
+        print(f"  失败: {e}")
+    
+    # 方法4: PyTorch (GPU)
+    if torch.cuda.is_available():
+        print("\n4. 测试 PyTorch (GPU)...")
+        start_time = time.time()
+        try:
+            corr_torch_gpu = torch_correlation(test_df, test_features, use_gpu=True)
+            torch_gpu_time = time.time() - start_time
+            results['torch_gpu'] = {'time': torch_gpu_time, 'success': True}
+            print(f"  耗时: {torch_gpu_time:.3f}秒")
+        except Exception as e:
+            results['torch_gpu'] = {'time': float('inf'), 'success': False, 'error': str(e)}
+            print(f"  失败: {e}")
+    else:
+        print("\n4. GPU不可用，跳过GPU测试")
+        results['torch_gpu'] = {'time': float('inf'), 'success': False, 'error': 'GPU not available'}
+    
+    # 方法5: 并行计算
+    print("\n5. 测试并行计算...")
+    start_time = time.time()
+    try:
+        corr_parallel = parallel_correlation_matrix(test_df, test_features, method='pearson', max_workers=4)
+        parallel_time = time.time() - start_time
+        results['parallel'] = {'time': parallel_time, 'success': True}
+        print(f"  耗时: {parallel_time:.3f}秒")
+    except Exception as e:
+        results['parallel'] = {'time': float('inf'), 'success': False, 'error': str(e)}
+        print(f"  失败: {e}")
+    
+    # 显示比较结果
+    print(f"\n=== 性能比较结果 ===")
+    successful_methods = {k: v for k, v in results.items() if v['success']}
+    
+    if successful_methods:
+        fastest_method = min(successful_methods.items(), key=lambda x: x[1]['time'])
+        print(f"最快方法: {fastest_method[0]} ({fastest_method[1]['time']:.3f}秒)")
+        
+        print(f"\n详细结果:")
+        for method, result in sorted(successful_methods.items(), key=lambda x: x[1]['time']):
+            speedup = fastest_method[1]['time'] / result['time']
+            print(f"  {method:12s}: {result['time']:6.3f}秒 (相对速度: {speedup:.2f}x)")
+    
+    # 显示失败的方法
+    failed_methods = {k: v for k, v in results.items() if not v['success']}
+    if failed_methods:
+        print(f"\n失败的方法:")
+        for method, result in failed_methods.items():
+            print(f"  {method}: {result.get('error', 'Unknown error')}")
+    
+    return results
+
+if __name__ == "__main__":
+    # ===== 主执行流程 =====
+    
+    # 检查是否运行性能测试
+    if len(sys.argv) > 1 and sys.argv[1] == '--benchmark':
+        print("=" * 60)
+        print("运行相关系数计算方法性能测试")
+        print("=" * 60)
+        
+        # 加载数据
+        train_df = pd.read_parquet(Config.TRAIN_PATH)
+        all_features = [col for col in train_df.columns if col != Config.LABEL_COLUMN]
+        
+        # 运行性能测试
+        benchmark_correlation_methods(train_df, all_features)
+        sys.exit(0)
+    
+    print("=" * 60)
+    print("开始特征相关性分析和因子聚合")
+    print("=" * 60)
+    
+    # 1. 加载数据
+    print("\n1. 加载数据...")
+    train_df = pd.read_parquet(Config.TRAIN_PATH)
+    test_df = pd.read_parquet(Config.TEST_PATH)
+    print(f"训练数据形状: {train_df.shape}")
+    print(f"测试数据形状: {test_df.shape}")
+    
+    # 2. 特征工程
+    print("\n2. 执行特征工程...")
+    train_df = feature_engineering(train_df)
+    test_df = feature_engineering(test_df)
+    print(f"特征工程后训练数据形状: {train_df.shape}")
+    print(f"特征工程后测试数据形状: {test_df.shape}")
+    
+    # 2.5 剔除恒定特征
+    print("\n2.5 Remove constant features...")
+    feature_cols = [col for col in train_df.columns if col != Config.LABEL_COLUMN]
+    constant_features = [col for col in feature_cols if train_df[col].std() == 0]
+    if constant_features:
+        print(f"Remove {len(constant_features)} constant features: {constant_features}")
+        train_df = train_df.drop(columns=constant_features)
+        test_df = test_df.drop(columns=[col for col in constant_features if col in test_df.columns])
+    else:
+        print("No constant features found.")
+    
+    # 3. 获取所有特征
+    all_features = [col for col in train_df.columns if col != Config.LABEL_COLUMN]
+    print(f"\n特征数量: {len(all_features)}")
+    
+    # 4. 计算相关系数矩阵和IC值，并自动IC取正
+    print(f"\n3. 计算相关系数矩阵 (阈值: {Config.CORRELATION_THRESHOLD})...")
+    corr_matrix, ic_values, feature_groups, train_df, test_df = calculate_correlation_matrix_and_ic(
+        train_df, all_features, Config.LABEL_COLUMN, Config.CORRELATION_THRESHOLD, Config.MAX_WORKERS, test_df
+    )
+    
+    # 5. 显示基本统计
+    print(f"\n4. 基本统计信息:")
+    print(f"   相关系数矩阵形状: {corr_matrix.shape}")
+    print(f"   平均IC值: {ic_values.mean():.4f}")
+    print(f"   最大IC值: {ic_values.max():.4f}")
+    print(f"   最小IC值: {ic_values.min():.4f}")
+    print(f"   IC值标准差: {ic_values.std():.4f}")
+    
+    # 6. 显示特征聚合结果
+    print(f"\n5. 特征聚合结果:")
+    print(f"   特征组数量: {len(feature_groups)}")
+    
+    single_features = [g for g in feature_groups if len(g['features']) == 1]
+    grouped_features = [g for g in feature_groups if len(g['features']) > 1]
+    
+    print(f"   单独特征组: {len(single_features)}")
+    print(f"   聚合特征组: {len(grouped_features)}")
+    
+    # 7. 创建聚合特征
+    print(f"\n6. 创建聚合特征...")
+    train_df_aggregated = create_aggregated_features(train_df, feature_groups, Config.REMOVE_ORIGINAL_FEATURES)
+    test_df_aggregated = create_aggregated_features(test_df, feature_groups, Config.REMOVE_ORIGINAL_FEATURES)
+    
+    print(f"   聚合前训练特征数量: {len(all_features)}")
+    print(f"   聚合后训练特征数量: {len([col for col in train_df_aggregated.columns if col != Config.LABEL_COLUMN])}")
+    print(f"   聚合后测试特征数量: {len([col for col in test_df_aggregated.columns])}")
+    
+    # 8. 保存结果
+    if Config.SAVE_RESULTS:
+        print(f"\n7. 保存结果...")
+        corr_matrix.to_csv('./max_IC_mixed/correlation_matrix.csv')
+        ic_values.to_csv('./max_IC_mixed/ic_values.csv')
+        train_df_aggregated.to_parquet('./max_IC_mixed/train_aggregated.parquet')
+        test_df_aggregated.to_parquet('./max_IC_mixed/test_aggregated.parquet')
+        print("   相关系数矩阵已保存: correlation_matrix.csv")
+        print("   特征IC值已保存: ic_values.csv")
+        print("   聚合后训练数据已保存: train_aggregated.parquet")
+        print("   聚合后测试数据已保存: test_aggregated.parquet")
+    
+    # 9. 显示高IC值特征
+    print(f"\n8. Top 10 highest IC features:")
+    print(ic_values.abs().sort_values(ascending=False).head(10))
+    
+    # 10. 显示高相关性特征对
+    print(f"\n9. Highly correlated feature pairs (|correlation| > {Config.CORRELATION_THRESHOLD}):")
+    high_corr_pairs = []
+    for i in range(len(corr_matrix.columns)):
+        for j in range(i+1, len(corr_matrix.columns)):
+            corr_val = corr_matrix.iloc[i, j]
+            if abs(corr_val) > Config.CORRELATION_THRESHOLD:
+                high_corr_pairs.append((corr_matrix.columns[i], corr_matrix.columns[j], corr_val))
+    
+    for pair in sorted(high_corr_pairs, key=lambda x: abs(x[2]), reverse=True)[:10]:
+        print(f"   {pair[0]} <-> {pair[1]}: {pair[2]:.4f}")
+    
+    # 11. 生成可视化
+    if Config.CREATE_VISUALIZATIONS:
+        print(f"\n10. Generate visualization...")
+        visualize_correlation_and_ic(corr_matrix, ic_values, feature_groups, Config.SAVE_RESULTS)
+    
+    # 12. 生成报告
+    if Config.SAVE_RESULTS:
+        print(f"\n11. Generate feature analysis report...")
+        create_feature_summary_report(corr_matrix, ic_values, feature_groups)
+    
+    print(f"\n" + "=" * 60)
+    print("Feature correlation analysis and factor aggregation completed!")
+    print("=" * 60)

ZMJ/analyze.py

@@ -0,0 +1,323 @@
+import pandas as pd
+import numpy as np
+from scipy.stats import pearsonr
+import warnings
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import time
+warnings.filterwarnings('ignore')
+
+# ===== Configuration =====
+class Config:
+    # 数据路径配置
+    TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/train.parquet"
+    TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/data/test.parquet"
+    
+    # 如果使用聚合后的数据
+    AGGREGATED_TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/ZMJ/max_IC_mixed/train_aggregated.parquet"
+    AGGREGATED_TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/ZMJ/max_IC_mixed/test_aggregated.parquet"
+    
+    LABEL_COLUMN = "label"
+    
+    # 性能配置
+    MAX_WORKERS = 4  # 并行计算的工作线程数
+    USE_AGGREGATED_DATA = True  # 是否使用聚合后的数据
+    
+    # 输出配置
+    OUTPUT_DIR = "./ic_analysis_results"
+    SAVE_DETAILED_RESULTS = True  # 是否保存详细结果
+
+def fast_ic_calculation(df, features, label_col, max_workers=4):
+    """
+    快速计算特征IC值，支持并行计算
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    label_col : str
+        标签列名
+    max_workers : int
+        并行计算的工作线程数
+        
+    Returns:
+    --------
+    ic_values : pd.Series
+        特征IC值
+    """
+    
+    print(f"开始计算特征IC值 (特征数量: {len(features)})")
+    start_time = time.time()
+    
+    def calculate_ic(feature):
+        """计算单个特征的IC值"""
+        try:
+            ic, p_value = pearsonr(df[feature], df[label_col])
+            return feature, ic, p_value
+        except Exception as e:
+            print(f"计算特征 {feature} 的IC值时出错: {e}")
+            return feature, 0.0, 1.0
+    
+    # 并行计算IC值
+    ic_dict = {}
+    p_value_dict = {}
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        future_to_feature = {executor.submit(calculate_ic, feature): feature for feature in features}
+        
+        completed = 0
+        for future in as_completed(future_to_feature):
+            feature, ic, p_value = future.result()
+            ic_dict[feature] = ic
+            p_value_dict[feature] = p_value
+            completed += 1
+            
+            if completed % 50 == 0:
+                print(f"IC计算进度: {completed}/{len(features)} ({completed/len(features)*100:.1f}%)")
+    
+    ic_values = pd.Series(ic_dict)
+    p_values = pd.Series(p_value_dict)
+    
+    print(f"IC值计算耗时: {time.time() - start_time:.2f}秒")
+    
+    return ic_values, p_values
+
+def calculate_feature_statistics(df, features, label_col):
+    """
+    计算特征的统计信息
+    
+    Parameters:
+    -----------
+    df : pd.DataFrame
+        数据框
+    features : list
+        特征列表
+    label_col : str
+        标签列名
+        
+    Returns:
+    --------
+    stats_df : pd.DataFrame
+        特征统计信息
+    """
+    
+    print("计算特征统计信息...")
+    stats_data = []
+    
+    for feature in features:
+        try:
+            feature_data = df[feature]
+            label_data = df[label_col]
+            
+            # 基本统计
+            mean_val = feature_data.mean()
+            std_val = feature_data.std()
+            min_val = feature_data.min()
+            max_val = feature_data.max()
+            
+            # 缺失值统计
+            missing_count = feature_data.isna().sum()
+            missing_ratio = missing_count / len(feature_data)
+            
+            # 零值统计
+            zero_count = (feature_data == 0).sum()
+            zero_ratio = zero_count / len(feature_data)
+            
+            # 异常值统计（超过3个标准差）
+            outlier_count = ((feature_data - mean_val).abs() > 3 * std_val).sum()
+            outlier_ratio = outlier_count / len(feature_data)
+            
+            stats_data.append({
+                'feature': feature,
+                'mean': mean_val,
+                'std': std_val,
+                'min': min_val,
+                'max': max_val,
+                'missing_count': missing_count,
+                'missing_ratio': missing_ratio,
+                'zero_count': zero_count,
+                'zero_ratio': zero_ratio,
+                'outlier_count': outlier_count,
+                'outlier_ratio': outlier_ratio
+            })
+            
+        except Exception as e:
+            print(f"计算特征 {feature} 统计信息时出错: {e}")
+            stats_data.append({
+                'feature': feature,
+                'mean': np.nan,
+                'std': np.nan,
+                'min': np.nan,
+                'max': np.nan,
+                'missing_count': np.nan,
+                'missing_ratio': np.nan,
+                'zero_count': np.nan,
+                'zero_ratio': np.nan,
+                'outlier_count': np.nan,
+                'outlier_ratio': np.nan
+            })
+    
+    return pd.DataFrame(stats_data)
+
+def create_ic_analysis_report(ic_values, p_values, stats_df, output_dir):
+    """
+    创建IC分析报告
+    
+    Parameters:
+    -----------
+    ic_values : pd.Series
+        IC值
+    p_values : pd.Series
+        P值
+    stats_df : pd.DataFrame
+        统计信息
+    output_dir : str
+        输出目录
+    """
+    
+    print("创建IC分析报告...")
+    
+    # 创建输出目录
+    import os
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 1. 合并所有信息
+    report_df = pd.DataFrame({
+        'feature': ic_values.index,
+        'ic_value': ic_values.values,
+        'ic_abs': ic_values.abs().values,
+        'p_value': p_values.values,
+        'is_significant': p_values < 0.05
+    })
+    
+    # 添加统计信息
+    report_df = report_df.merge(stats_df, on='feature', how='left')
+    
+    # 2. 按IC绝对值排序
+    report_df = report_df.sort_values('ic_abs', ascending=False)
+    
+    # 3. 添加排名
+    report_df['ic_rank'] = report_df['ic_abs'].rank(ascending=False, method='min')
+    
+    # 4. 保存详细报告
+    if Config.SAVE_DETAILED_RESULTS:
+        detailed_path = os.path.join(output_dir, 'detailed_ic_analysis.csv')
+        report_df.to_csv(detailed_path, index=False)
+        print(f"详细IC分析报告已保存: {detailed_path}")
+    
+    # 5. 保存简化报告（只包含重要信息）
+    simple_df = report_df[['feature', 'ic_value', 'ic_abs', 'ic_rank', 'p_value', 'is_significant']].copy()
+    simple_path = os.path.join(output_dir, 'ic_analysis_summary.csv')
+    simple_df.to_csv(simple_path, index=False)
+    print(f"IC分析摘要已保存: {simple_path}")
+    
+    # 6. 保存统计信息
+    stats_path = os.path.join(output_dir, 'feature_statistics.csv')
+    stats_df.to_csv(stats_path, index=False)
+    print(f"特征统计信息已保存: {stats_path}")
+    
+    # 7. 打印摘要信息
+    print("\n" + "="*60)
+    print("IC分析摘要")
+    print("="*60)
+    print(f"总特征数量: {len(ic_values)}")
+    print(f"平均IC值: {ic_values.mean():.4f}")
+    print(f"IC值标准差: {ic_values.std():.4f}")
+    print(f"最大IC值: {ic_values.max():.4f}")
+    print(f"最小IC值: {ic_values.min():.4f}")
+    print(f"显著特征数量 (p < 0.05): {(p_values < 0.05).sum()}")
+    print(f"正IC值特征数量: {(ic_values > 0).sum()}")
+    print(f"负IC值特征数量: {(ic_values < 0).sum()}")
+    
+    print(f"\nTop 10 最高IC值特征:")
+    top_10 = report_df.head(10)
+    for _, row in top_10.iterrows():
+        significance = "***" if row['is_significant'] else ""
+        print(f"  {row['ic_rank']:2.0f}. {row['feature']:20s} IC={row['ic_value']:6.4f} (p={row['p_value']:.4f}) {significance}")
+    
+    print(f"\nBottom 10 最低IC值特征:")
+    bottom_10 = report_df.tail(10)
+    for _, row in bottom_10.iterrows():
+        significance = "***" if row['is_significant'] else ""
+        print(f"  {row['ic_rank']:2.0f}. {row['feature']:20s} IC={row['ic_value']:6.4f} (p={row['p_value']:.4f}) {significance}")
+    
+    return report_df
+
+def main():
+    """主函数"""
+    print("="*60)
+    print("开始IC值分析")
+    print("="*60)
+    
+    # 1. 加载数据
+    print("\n1. 加载数据...")
+    if Config.USE_AGGREGATED_DATA:
+        try:
+            train_df = pd.read_parquet(Config.AGGREGATED_TRAIN_PATH)
+            print(f"使用聚合后的训练数据: {train_df.shape}")
+        except FileNotFoundError:
+            print("聚合数据文件不存在，使用原始数据...")
+            train_df = pd.read_parquet(Config.TRAIN_PATH)
+            print(f"使用原始训练数据: {train_df.shape}")
+    else:
+        train_df = pd.read_parquet(Config.TRAIN_PATH)
+        print(f"使用原始训练数据: {train_df.shape}")
+    
+    # 2. 获取特征列表
+    print("\n2. 获取特征列表...")
+    features = [col for col in train_df.columns if col != Config.LABEL_COLUMN]
+    print(f"特征数量: {len(features)}")
+    
+    # 3. 数据预处理
+    print("\n3. 数据预处理...")
+    # 处理缺失值
+    for col in features + [Config.LABEL_COLUMN]:
+        if train_df[col].isna().any():
+            median_val = train_df[col].median()
+            train_df[col] = train_df[col].fillna(median_val if not pd.isna(median_val) else 0)
+    
+    # 处理无穷值
+    train_df = train_df.replace([np.inf, -np.inf], np.nan)
+    for col in features + [Config.LABEL_COLUMN]:
+        if train_df[col].isna().any():
+            median_val = train_df[col].median()
+            train_df[col] = train_df[col].fillna(median_val if not pd.isna(median_val) else 0)
+    
+    print(f"预处理后数据形状: {train_df.shape}")
+    
+    # 4. 计算IC值
+    print("\n4. 计算IC值...")
+    ic_values, p_values = fast_ic_calculation(train_df, features, Config.LABEL_COLUMN, Config.MAX_WORKERS)
+    
+    # 5. 计算特征统计信息
+    print("\n5. 计算特征统计信息...")
+    stats_df = calculate_feature_statistics(train_df, features, Config.LABEL_COLUMN)
+    
+    # 6. 创建分析报告
+    print("\n6. 创建分析报告...")
+    report_df = create_ic_analysis_report(ic_values, p_values, stats_df, Config.OUTPUT_DIR)
+    
+    # 7. 保存原始IC值
+    print("\n7. 保存原始IC值...")
+    ic_df = pd.DataFrame({
+        'feature': ic_values.index,
+        'ic_value': ic_values.values,
+        'p_value': p_values.values
+    })
+    ic_path = f"{Config.OUTPUT_DIR}/ic_values.csv"
+    ic_df.to_csv(ic_path, index=False)
+    print(f"IC值已保存: {ic_path}")
+    
+    print("\n" + "="*60)
+    print("IC值分析完成！")
+    print("="*60)
+    print(f"所有结果已保存到目录: {Config.OUTPUT_DIR}")
+    print("生成的文件:")
+    print("- ic_values.csv: 原始IC值")
+    print("- ic_analysis_summary.csv: IC分析摘要")
+    print("- detailed_ic_analysis.csv: 详细IC分析报告")
+    print("- feature_statistics.csv: 特征统计信息")
+
+if __name__ == "__main__":
+    main()

ZMJ/data_processed/correlation_matrix.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ec7569d99f29e69f69f43f36ffd87ec5a807ce6b9c6b170def77a1257561bb4
+size 16050677

ZMJ/data_processed/feature_analysis_report.txt

@@ -0,0 +1,576 @@
+============================================================
+特征分析报告
+============================================================
+
+1. 基本统计信息:
+   总特征数量: 903
+   平均IC值: 0.0181
+   IC值标准差: 0.0139
+   最大IC值: 0.0694
+   最小IC值: 0.0000
+   正IC值特征数量: 876
+   负IC值特征数量: 0
+
+2. 高相关性分析 (|相关系数| > 0.8):
+   高相关特征对数量: 2283
+   相关系数矩阵密度: 0.0056
+
+3. 特征聚合结果:
+   特征组数量: 364
+   单独特征组: 184
+   聚合特征组: 180
+   平均聚合组大小: 3.99
+
+4. 前10个最高IC值特征:
+    1. X21                  |IC|=0.0694 (IC=0.0694)
+    2. X20                  |IC|=0.0677 (IC=0.0677)
+    3. X28                  |IC|=0.0641 (IC=0.0641)
+    4. X863                 |IC|=0.0641 (IC=0.0641)
+    5. X29                  |IC|=0.0623 (IC=0.0623)
+    6. X19                  |IC|=0.0623 (IC=0.0623)
+    7. X27                  |IC|=0.0623 (IC=0.0623)
+    8. X22                  |IC|=0.0577 (IC=0.0577)
+    9. X858                 |IC|=0.0573 (IC=0.0573)
+   10. X219                 |IC|=0.0567 (IC=0.0567)
+
+5. 特征聚合详情:
+   组 1: X21 (IC=0.0643)
+       包含特征: X21, X19, X20, X22
+       权重: ['0.270', '0.242', '0.263', '0.224']
+   组 2: X28 (IC=0.0629)
+       包含特征: X28, X27, X29
+       权重: ['0.340', '0.330', '0.330']
+   组 3: X219 (IC=0.0493)
+       包含特征: X219, X217, X218, X225, X226
+       权重: ['0.230', '0.187', '0.218', '0.183', '0.183']
+   组 4: X531 (IC=0.0484)
+       包含特征: X531, X524, X538
+       权重: ['0.387', '0.331', '0.282']
+   组 5: X287 (IC=0.0470)
+       包含特征: X287, X264, X280, X281, X282, X283, X284, X285, X286, X288, X289, X290, X291, X292, X293, X294, X295, X296, X297, X432, X435, X438, X868
+       权重: ['0.052', '0.027', '0.037', '0.044', '0.038', '0.046', '0.041', '0.049', '0.045', '0.045', '0.052', '0.045', '0.051', '0.048', '0.051', '0.047', '0.051', '0.047', '0.049', '0.035', '0.034', '0.031', '0.035']
+   组 6: X298 (IC=0.0505)
+       包含特征: X298, X272, X299, X300, X301, X302, X303
+       权重: ['0.150', '0.120', '0.148', '0.149', '0.145', '0.146', '0.141']
+   组 7: X30 (IC=0.0409)
+       包含特征: X30, X31, X32
+       权重: ['0.404', '0.333', '0.263']
+   组 8: X465 (IC=0.0426)
+       包含特征: X465, X444, X464, X466, X471, X472, X473
+       权重: ['0.166', '0.132', '0.135', '0.165', '0.124', '0.142', '0.135']
+   组 9: X181 (IC=0.0398)
+       包含特征: X181, X95, X131, X137, X139, X169, X173, X175, X179
+       权重: ['0.137', '0.120', '0.113', '0.124', '0.085', '0.107', '0.089', '0.128', '0.096']
+   组 10: X861 (IC=0.0314)
+       包含特征: X861, X525, X532, X539
+       权重: ['0.362', '0.158', '0.244', '0.236']
+   组 11: X23 (IC=0.0394)
+       包含特征: X23, X24
+       权重: ['0.571', '0.429']
+   组 12: X198 (IC=0.0354)
+       包含特征: X198, X196, X197, X204, X205, X211, X212
+       权重: ['0.173', '0.139', '0.162', '0.143', '0.149', '0.116', '0.117']
+   组 13: X277 (IC=0.0389)
+       包含特征: X277, X276, X278, X279
+       权重: ['0.271', '0.212', '0.260', '0.257']
+   组 14: X580 (IC=0.0375)
+       包含特征: X580, X573, X587
+       权重: ['0.371', '0.309', '0.320']
+   组 15: X224 (IC=0.0331)
+       包含特征: X224, X223
+       权重: ['0.629', '0.371']
+   组 16: X758 (IC=0.0389)
+       包含特征: X758, X750, X754
+       权重: ['0.355', '0.293', '0.353']
+   组 17: X612 (IC=0.0342)
+       包含特征: X612, X610, X611
+       权重: ['0.395', '0.270', '0.335']
+   组 18: X89 (IC=0.0315)
+       包含特征: X89, X83, X125, X167, X336, X728
+       权重: ['0.215', '0.189', '0.173', '0.135', '0.164', '0.123']
+   组 19: X269 (IC=0.0377)
+       包含特征: X269, X268, X270, X271
+       权重: ['0.263', '0.225', '0.257', '0.255']
+   组 20: X731 (IC=0.0318)
+       包含特征: X731, X727, X729, X730
+       权重: ['0.309', '0.212', '0.271', '0.208']
+   组 21: X445 (IC=0.0304)
+       包含特征: X445, X443, X450, X451, X452, X457, X458, X459
+       权重: ['0.158', '0.130', '0.118', '0.145', '0.141', '0.089', '0.111', '0.107']
+   组 22: X373 (IC=0.0380)
+       包含特征: X373, X367, X379, X385
+       权重: ['0.251', '0.248', '0.250', '0.251']
+   组 23: X504 (IC=0.0371)
+       包含特征: X504, X511
+       权重: ['0.504', '0.496']
+   组 24: X540 (IC=0.0373)
+       包含特征: X540, X533
+       权重: ['0.502', '0.498']
+   组 25: X186 (IC=0.0346)
+       包含特征: X186, X183, X189
+       权重: ['0.359', '0.305', '0.335']
+   组 26: X361 (IC=0.0365)
+       包含特征: X361, X355
+       权重: ['0.509', '0.491']
+   组 27: X331 (IC=0.0326)
+       包含特征: X331, X325, X337, X343
+       权重: ['0.279', '0.263', '0.246', '0.213']
+   组 28: X517 (IC=0.0341)
+       包含特征: X517, X510
+       权重: ['0.530', '0.470']
+   组 29: X814 (IC=0.0322)
+       包含特征: X814, X806, X810
+       权重: ['0.370', '0.283', '0.347']
+   组 30: X519 (IC=0.0328)
+       包含特征: X519, X512
+       权重: ['0.526', '0.474']
+   组 31: X266 (IC=0.0327)
+       包含特征: X266, X265, X267
+       权重: ['0.348', '0.314', '0.338']
+   组 32: X588 (IC=0.0330)
+       包含特征: X588, X581
+       权重: ['0.515', '0.485']
+   组 33: X44 (IC=0.0295)
+       包含特征: X44, X38, X39, X40, X41, X42, X43, X45, X46, X47, X48, X49, X50, X51, X52, X53, X54
+       权重: ['0.066', '0.056', '0.055', '0.065', '0.057', '0.065', '0.059', '0.056', '0.066', '0.056', '0.065', '0.056', '0.064', '0.050', '0.057', '0.050', '0.056']
+   组 34: X111 (IC=0.0321)
+       包含特征: X111, X105, X117, X153
+       权重: ['0.258', '0.238', '0.248', '0.257']
+   组 35: X77 (IC=0.0239)
+       包含特征: X77, X65, X71, X113, X119, X161
+       权重: ['0.230', '0.176', '0.213', '0.110', '0.152', '0.119']
+   组 36: X238 (IC=0.0260)
+       包含特征: X238, X239, X245, X246, X485, X492
+       权重: ['0.211', '0.197', '0.206', '0.202', '0.092', '0.092']
+   组 37: X773 (IC=0.0244)
+       包含特征: X773, X765, X768, X769, X772, X776, X777, X859
+       权重: ['0.167', '0.118', '0.122', '0.150', '0.134', '0.082', '0.124', '0.103']
+   组 38: X384 (IC=0.0276)
+       包含特征: X384, X342, X372, X378, X420, X426
+       权重: ['0.194', '0.180', '0.151', '0.181', '0.133', '0.161']
+   组 39: X319 (IC=0.0314)
+       包含特征: X319, X313
+       权重: ['0.510', '0.490']
+   组 40: X690 (IC=0.0252)
+       包含特征: X690, X678, X684, X696
+       权重: ['0.316', '0.183', '0.185', '0.316']
+   组 41: X203 (IC=0.0216)
+       包含特征: X203, X195, X202, X209, X210
+       权重: ['0.292', '0.168', '0.159', '0.136', '0.244']
+   组 42: X147 (IC=0.0281)
+       包含特征: X147, X141, X159
+       权重: ['0.374', '0.274', '0.352']
+   组 43: X604 (IC=0.0308)
+       包含特征: X604, X603, X605
+       权重: ['0.340', '0.323', '0.337']
+   组 44: X94 (IC=0.0221)
+       包含特征: X94, X82, X88, X130, X136, X178
+       权重: ['0.236', '0.155', '0.199', '0.145', '0.168', '0.097']
+   组 45: X133 (IC=0.0297)
+       包含特征: X133, X127
+       权重: ['0.519', '0.481']
+   组 46: X274 (IC=0.0300)
+       包含特征: X274, X273, X275
+       权重: ['0.338', '0.331', '0.331']
+   组 47: X163 (IC=0.0270)
+       包含特征: X163, X121, X151, X157
+       权重: ['0.280', '0.259', '0.214', '0.247']
+   组 48: X431 (IC=0.0251)
+       包含特征: X431, X430, X433, X434, X436, X437
+       权重: ['0.200', '0.146', '0.162', '0.185', '0.153', '0.155']
+   组 49: X842 (IC=0.0211)
+       包含特征: X842, X834, X838
+       权重: ['0.451', '0.186', '0.363']
+   组 50: X553 (IC=0.0274)
+       包含特征: X553, X560
+       权重: ['0.513', '0.487']
+   组 51: X330 (IC=0.0250)
+       包含特征: X330, X324
+       权重: ['0.557', '0.443']
+   组 52: X233 (IC=0.0268)
+       包含特征: X233, X232
+       权重: ['0.510', '0.490']
+   组 53: X829 (IC=0.0213)
+       包含特征: X829, X821, X824, X825, X828, X832, X833
+       权重: ['0.183', '0.116', '0.136', '0.152', '0.156', '0.107', '0.151']
+   组 54: X880 (IC=0.0230)
+       包含特征: X880, X878, X879, X881
+       权重: ['0.297', '0.203', '0.266', '0.234']
+   组 55: X56 (IC=0.0257)
+       包含特征: X56, X55
+       权重: ['0.527', '0.473']
+   组 56: X187 (IC=0.0231)
+       包含特征: X187, X33, X34, X35, X184, X185, X188, X190, X191
+       权重: ['0.129', '0.084', '0.115', '0.093', '0.128', '0.099', '0.109', '0.126', '0.117']
+   组 57: X566 (IC=0.0255)
+       包含特征: X566, X559
+       权重: ['0.522', '0.478']
+   组 58: X115 (IC=0.0242)
+       包含特征: X115, X109
+       权重: ['0.542', '0.458']
+   组 59: X237 (IC=0.0192)
+       包含特征: X237, X236, X243, X244, X484, X491
+       权重: ['0.222', '0.175', '0.158', '0.203', '0.126', '0.117']
+   组 60: X36 (IC=0.0242)
+       包含特征: X36, X37
+       权重: ['0.526', '0.474']
+   组 61: X579 (IC=0.0201)
+       包含特征: X579, X572, X586
+       权重: ['0.412', '0.373', '0.215']
+   组 62: X123 (IC=0.0162)
+       包含特征: X123, X129, X135, X165, X171
+       权重: ['0.306', '0.202', '0.094', '0.244', '0.154']
+   组 63: X506 (IC=0.0237)
+       包含特征: X506, X508
+       权重: ['0.519', '0.481']
+   组 64: X247 (IC=0.0151)
+       包含特征: X247, X240, X487, X494
+       权重: ['0.400', '0.365', '0.109', '0.126']
+   组 65: X686 (IC=0.0179)
+       包含特征: X686, X662, X668, X674, X680, X683, X692, X695
+       权重: ['0.169', '0.097', '0.063', '0.148', '0.105', '0.145', '0.123', '0.149']
+   组 66: X602 (IC=0.0203)
+       包含特征: X602, X600, X601
+       权重: ['0.394', '0.279', '0.326']
+   组 67: X216 (IC=0.0157)
+       包含特征: X216, X215, X222
+       权重: ['0.508', '0.229', '0.263']
+   组 68: X79 (IC=0.0215)
+       包含特征: X79, X67, X73, X85
+       权重: ['0.273', '0.233', '0.266', '0.228']
+   组 69: X479 (IC=0.0217)
+       包含特征: X479, X478, X480
+       权重: ['0.360', '0.302', '0.337']
+   组 70: X63 (IC=0.0206)
+       包含特征: X63, X57, X69, X75
+       权重: ['0.276', '0.221', '0.271', '0.232']
+   组 71: X865 (IC=0.0213)
+       包含特征: X865, X17, X25
+       权重: ['0.350', '0.302', '0.349']
+   组 72: X231 (IC=0.0178)
+       包含特征: X231, X230
+       权重: ['0.625', '0.375']
+   组 73: X609 (IC=0.0207)
+       包含特征: X609, X607, X608
+       权重: ['0.356', '0.309', '0.335']
+   组 74: X513 (IC=0.0217)
+       包含特征: X513, X515
+       权重: ['0.503', '0.497']
+   组 75: X653 (IC=0.0181)
+       包含特征: X653, X641, X659, X665
+       权重: ['0.284', '0.276', '0.230', '0.210']
+   组 76: X10 (IC=0.0198)
+       包含特征: X10, X11
+       权重: ['0.513', '0.487']
+   组 77: X366 (IC=0.0160)
+       包含特征: X366, X354, X360, X408
+       权重: ['0.317', '0.224', '0.279', '0.179']
+   组 78: X318 (IC=0.0189)
+       包含特征: X318, X312
+       权重: ['0.523', '0.477']
+   组 79: X428 (IC=0.0140)
+       包含特征: X428, X380, X386, X416, X422
+       权重: ['0.276', '0.198', '0.128', '0.158', '0.240']
+   组 80: X786 (IC=0.0131)
+       包含特征: X786, X778, X782
+       权重: ['0.489', '0.146', '0.365']
+   组 81: X14 (IC=0.0142)
+       包含特征: X14, X9, X12, X13, X15, X16
+       权重: ['0.226', '0.003', '0.195', '0.186', '0.212', '0.177']
+   组 82: X394 (IC=0.0172)
+       包含特征: X394, X388, X400, X406
+       权重: ['0.279', '0.226', '0.268', '0.227']
+   组 83: X764 (IC=0.0147)
+       包含特征: X764, X760, X761
+       权重: ['0.428', '0.262', '0.310']
+   组 84: X677 (IC=0.0176)
+       包含特征: X677, X671, X689
+       权重: ['0.357', '0.288', '0.356']
+   组 85: X352 (IC=0.0157)
+       包含特征: X352, X346, X358, X364
+       权重: ['0.282', '0.264', '0.252', '0.202']
+   组 86: X499 (IC=0.0156)
+       包含特征: X499, X501
+       权重: ['0.565', '0.435']
+   组 87: X726 (IC=0.0132)
+       包含特征: X726, X724, X725
+       权重: ['0.437', '0.192', '0.371']
+   组 88: X145 (IC=0.0158)
+       包含特征: X145, X103
+       权重: ['0.548', '0.452']
+   组 89: X362 (IC=0.0132)
+       包含特征: X362, X356, X368, X398, X404, X410
+       权重: ['0.216', '0.209', '0.201', '0.133', '0.128', '0.113']
+   组 90: X340 (IC=0.0147)
+       包含特征: X340, X328, X334
+       权重: ['0.385', '0.260', '0.355']
+   组 91: X418 (IC=0.0163)
+       包含特征: X418, X412, X424
+       权重: ['0.346', '0.322', '0.332']
+   组 92: X470 (IC=0.0107)
+       包含特征: X470, X442, X449, X456, X463, X469, X476, X477
+       权重: ['0.196', '0.166', '0.162', '0.120', '0.150', '0.090', '0.029', '0.086']
+   组 93: X382 (IC=0.0154)
+       包含特征: X382, X370, X376
+       权重: ['0.360', '0.293', '0.346']
+   组 94: X882 (IC=0.0149)
+       包含特征: X882, X883
+       权重: ['0.557', '0.443']
+   组 95: X124 (IC=0.0106)
+       包含特征: X124, X118, X166, X172
+       权重: ['0.384', '0.192', '0.187', '0.236']
+   组 96: X310 (IC=0.0138)
+       包含特征: X310, X304, X316, X322
+       权重: ['0.296', '0.274', '0.250', '0.180']
+   组 97: X650 (IC=0.0133)
+       包含特征: X650, X638, X656
+       权重: ['0.406', '0.384', '0.209']
+   组 98: X820 (IC=0.0129)
+       包含特征: X820, X816, X817
+       权重: ['0.417', '0.288', '0.295']
+   组 99: X81 (IC=0.0134)
+       包含特征: X81, X87, X93
+       权重: ['0.396', '0.342', '0.262']
+   组 100: X162 (IC=0.0154)
+       包含特征: X162, X150, X156, X168
+       权重: ['0.257', '0.250', '0.253', '0.240']
+   组 101: X2 (IC=0.0115)
+       包含特征: X2, X3, X4
+       权重: ['0.456', '0.355', '0.189']
+   组 102: X746 (IC=0.0079)
+       包含特征: X746, X738, X742
+       权重: ['0.662', '0.055', '0.283']
+   组 103: X688 (IC=0.0146)
+       包含特征: X688, X664, X676, X682, X694
+       权重: ['0.214', '0.170', '0.211', '0.198', '0.206']
+   组 104: X565 (IC=0.0114)
+       包含特征: X565, X558
+       权重: ['0.683', '0.317']
+   组 105: X629 (IC=0.0123)
+       包含特征: X629, X617
+       权重: ['0.628', '0.372']
+   组 106: X520 (IC=0.0139)
+       包含特征: X520, X522
+       权重: ['0.552', '0.448']
+   组 107: X781 (IC=0.0083)
+       包含特征: X781, X780, X784, X785
+       权重: ['0.461', '0.223', '0.069', '0.248']
+   组 108: X837 (IC=0.0094)
+       包含特征: X837, X836, X840, X841
+       权重: ['0.404', '0.218', '0.072', '0.306']
+   组 109: X802 (IC=0.0096)
+       包含特征: X802, X794, X798
+       权重: ['0.518', '0.180', '0.303']
+   组 110: X235 (IC=0.0118)
+       包含特征: X235, X242, X482, X489
+       权重: ['0.316', '0.285', '0.200', '0.198']
+   组 111: X649 (IC=0.0135)
+       包含特征: X649, X625, X637, X643, X655, X661, X667
+       权重: ['0.156', '0.122', '0.152', '0.143', '0.145', '0.148', '0.134']
+   组 112: X427 (IC=0.0109)
+       包含特征: X427, X415, X421
+       权重: ['0.421', '0.253', '0.326']
+   组 113: X673 (IC=0.0122)
+       包含特征: X673, X679, X685, X691
+       权重: ['0.281', '0.258', '0.236', '0.225']
+   组 114: X60 (IC=0.0112)
+       包含特征: X60, X66
+       权重: ['0.594', '0.406']
+   组 115: X110 (IC=0.0113)
+       包含特征: X110, X62, X68, X74, X80, X104, X116, X122, X146, X152, X158, X164, X309, X315, X321, X351, X357, X363, X393, X399, X405
+       权重: ['0.056', '0.054', '0.056', '0.051', '0.034', '0.054', '0.051', '0.034', '0.054', '0.056', '0.051', '0.034', '0.052', '0.048', '0.039', '0.052', '0.048', '0.039', '0.052', '0.048', '0.039']
+   组 116: X91 (IC=0.0085)
+       包含特征: X91, X97
+       权重: ['0.777', '0.223']
+   组 117: X262 (IC=0.0092)
+       包含特征: X262, X256, X260, X261, X263
+       权重: ['0.288', '0.017', '0.148', '0.278', '0.269']
+   组 118: X890 (IC=0.0061)
+       包含特征: X890, X888, X889
+       权重: ['0.714', '0.041', '0.245']
+   组 119: X350 (IC=0.0108)
+       包含特征: X350, X392
+       权重: ['0.602', '0.398']
+   组 120: X766 (IC=0.0103)
+       包含特征: X766, X762, X770, X774
+       权重: ['0.306', '0.264', '0.272', '0.158']
+   组 121: X483 (IC=0.0119)
+       包含特征: X483, X490
+       权重: ['0.514', '0.486']
+   组 122: X155 (IC=0.0094)
+       包含特征: X155, X107, X149
+       权重: ['0.430', '0.342', '0.228']
+   组 123: X460 (IC=0.0048)
+       包含特征: X460, X439, X461, X467
+       权重: ['0.615', '0.035', '0.319', '0.031']
+   组 124: X853 (IC=0.0089)
+       包含特征: X853, X854
+       权重: ['0.656', '0.344']
+   组 125: X353 (IC=0.0085)
+       包含特征: X353, X311, X317, X347, X359, X365, X395, X401
+       权重: ['0.172', '0.152', '0.157', '0.149', '0.165', '0.121', '0.048', '0.037']
+   组 126: X102 (IC=0.0104)
+       包含特征: X102, X108
+       权重: ['0.558', '0.442']
+   组 127: X345 (IC=0.0068)
+       包含特征: X345, X92, X98, X134, X140, X176, X182, X333, X339, X375, X381, X387, X417, X423, X429
+       权重: ['0.111', '0.053', '0.099', '0.053', '0.099', '0.053', '0.099', '0.010', '0.059', '0.010', '0.059', '0.111', '0.010', '0.059', '0.111']
+   组 128: X90 (IC=0.0074)
+       包含特征: X90, X78, X84, X96
+       权重: ['0.384', '0.032', '0.289', '0.295']
+   组 129: X76 (IC=0.0090)
+       包含特征: X76, X64, X70, X112, X160
+       权重: ['0.254', '0.230', '0.231', '0.138', '0.148']
+   组 130: X670 (IC=0.0097)
+       包含特征: X670, X652, X658
+       权重: ['0.388', '0.320', '0.291']
+   组 131: X257 (IC=0.0092)
+       包含特征: X257, X258
+       权重: ['0.610', '0.390']
+   组 132: sell_qty (IC=0.0095)
+       包含特征: sell_qty, buy_qty, volume, X594, X596
+       权重: ['0.235', '0.118', '0.185', '0.232', '0.230']
+   组 133: X326 (IC=0.0094)
+       包含特征: X326, X314, X320, X332
+       权重: ['0.293', '0.196', '0.251', '0.260']
+   组 134: X493 (IC=0.0109)
+       包含特征: X493, X486
+       权重: ['0.505', '0.495']
+   组 135: X631 (IC=0.0080)
+       包含特征: X631, X613, X619
+       权重: ['0.454', '0.285', '0.261']
+   组 136: X174 (IC=0.0079)
+       包含特征: X174, X180
+       权重: ['0.673', '0.327']
+   组 137: X741 (IC=0.0091)
+       包含特征: X741, X736, X737, X740, X744, X745
+       权重: ['0.194', '0.143', '0.163', '0.174', '0.151', '0.174']
+   组 138: X845 (IC=0.0044)
+       包含特征: X845, X214, X722, X723
+       权重: ['0.548', '0.121', '0.024', '0.308']
+   组 139: X718 (IC=0.0060)
+       包含特征: X718, X719, X720, X721
+       权重: ['0.394', '0.317', '0.212', '0.078']
+   组 140: X516 (IC=0.0082)
+       包含特征: X516, X509
+       权重: ['0.573', '0.427']
+   组 141: X448 (IC=0.0057)
+       包含特征: X448, X440, X441, X447, X454, X455, X468, X475
+       权重: ['0.205', '0.116', '0.186', '0.151', '0.114', '0.154', '0.074', '0.001']
+   组 142: X344 (IC=0.0085)
+       包含特征: X344, X338
+       权重: ['0.536', '0.464']
+   组 143: X687 (IC=0.0050)
+       包含特征: X687, X675, X681, X693
+       权重: ['0.444', '0.126', '0.060', '0.370']
+   组 144: X402 (IC=0.0066)
+       包含特征: X402, X396
+       权重: ['0.671', '0.329']
+   组 145: X323 (IC=0.0048)
+       包含特征: X323, X329
+       权重: ['0.904', '0.096']
+   组 146: X248 (IC=0.0079)
+       包含特征: X248, X253, X254, X255
+       权重: ['0.274', '0.216', '0.260', '0.251']
+   组 147: X523 (IC=0.0064)
+       包含特征: X523, X530
+       权重: ['0.673', '0.327']
+   组 148: X801 (IC=0.0059)
+       包含特征: X801, X793, X796, X797, X800, X804, X805
+       权重: ['0.207', '0.093', '0.134', '0.173', '0.158', '0.118', '0.116']
+   组 149: X192 (IC=0.0058)
+       包含特征: X192, X193, X199, X200, X206, X220, X227
+       权重: ['0.205', '0.071', '0.193', '0.073', '0.196', '0.084', '0.178']
+   组 150: X640 (IC=0.0067)
+       包含特征: X640, X628, X634, X646
+       权重: ['0.301', '0.215', '0.201', '0.283']
+   组 151: X818 (IC=0.0072)
+       包含特征: X818, X822
+       权重: ['0.555', '0.445']
+   组 152: X249 (IC=0.0042)
+       包含特征: X249, X250, X251
+       权重: ['0.623', '0.223', '0.154']
+   组 153: X148 (IC=0.0063)
+       包含特征: X148, X106, X142, X154
+       权重: ['0.300', '0.233', '0.167', '0.299']
+   组 154: X58 (IC=0.0055)
+       包含特征: X58, X100
+       权重: ['0.690', '0.310']
+   组 155: X752 (IC=0.0038)
+       包含特征: X752, X748, X749, X753, X756, X757
+       权重: ['0.322', '0.155', '0.009', '0.109', '0.313', '0.092']
+   组 156: X114 (IC=0.0037)
+       包含特征: X114, X120, X126
+       权重: ['0.588', '0.244', '0.168']
+   组 157: order_flow_imbalance (IC=0.0060)
+       包含特征: order_flow_imbalance, selling_pressure
+       权重: ['0.504', '0.496']
+   组 158: X229 (IC=0.0038)
+       包含特征: X229, X228
+       权重: ['0.783', '0.217']
+   组 159: X1 (IC=0.0029)
+       包含特征: X1, X5, X6, X7, X8
+       权重: ['0.411', '0.071', '0.106', '0.177', '0.235']
+   组 160: X409 (IC=0.0045)
+       包含特征: X409, X397, X403
+       权重: ['0.440', '0.283', '0.277']
+   组 161: X733 (IC=0.0055)
+       包含特征: X733, X732
+       权重: ['0.534', '0.466']
+   组 162: X194 (IC=0.0045)
+       包含特征: X194, X201, X207, X208, X221
+       权重: ['0.255', '0.242', '0.159', '0.191', '0.152']
+   组 163: X666 (IC=0.0037)
+       包含特征: X666, X654, X660, X672
+       权重: ['0.384', '0.064', '0.216', '0.336']
+   组 164: X411 (IC=0.0025)
+       包含特征: X411, X86, X128, X170, X327, X369
+       权重: ['0.325', '0.008', '0.008', '0.008', '0.325', '0.325']
+   组 165: X826 (IC=0.0033)
+       包含特征: X826, X830
+       权重: ['0.749', '0.251']
+   组 166: X234 (IC=0.0040)
+       包含特征: X234, X241, X481, X488
+       权重: ['0.298', '0.253', '0.236', '0.213']
+   组 167: X597 (IC=0.0040)
+       包含特征: X597, X595
+       权重: ['0.542', '0.458']
+   组 168: X657 (IC=0.0016)
+       包含特征: X657, X639, X651, X663, X669
+       权重: ['0.520', '0.068', '0.060', '0.108', '0.243']
+   组 169: X413 (IC=0.0017)
+       包含特征: X413, X371, X377, X407, X419, X425
+       权重: ['0.386', '0.025', '0.161', '0.003', '0.210', '0.216']
+   组 170: X808 (IC=0.0016)
+       包含特征: X808, X809, X812, X813
+       权重: ['0.510', '0.373', '0.062', '0.055']
+   组 171: X138 (IC=0.0019)
+       包含特征: X138, X132
+       权重: ['0.830', '0.170']
+   组 172: X446 (IC=0.0022)
+       包含特征: X446, X453, X474
+       权重: ['0.457', '0.320', '0.223']
+   组 173: X792 (IC=0.0013)
+       包含特征: X792, X788, X789
+       权重: ['0.740', '0.118', '0.142']
+   组 174: X624 (IC=0.0026)
+       包含特征: X624, X618
+       权重: ['0.565', '0.435']
+   组 175: X621 (IC=0.0024)
+       包含特征: X621, X615
+       权重: ['0.613', '0.387']
+   组 176: X636 (IC=0.0023)
+       包含特征: X636, X630
+       权重: ['0.577', '0.423']
+   组 177: X616 (IC=0.0024)
+       包含特征: X616, X622
+       权重: ['0.553', '0.447']
+   组 178: X885 (IC=0.0017)
+       包含特征: X885, X884, X886, X887
+       权重: ['0.371', '0.334', '0.242', '0.053']
+   组 179: X874 (IC=0.0019)
+       包含特征: X874, X873
+       权重: ['0.503', '0.497']
+   组 180: X335 (IC=0.0007)
+       包含特征: X335, X341, X383
+       权重: ['0.452', '0.231', '0.318']

ZMJ/data_processed/ic_values.csv

@@ -0,0 +1,904 @@
+,0
+sell_qty,0.011165790013440683
+ask_qty,0.01576156636733563
+buy_qty,0.005617629417558399
+X1,0.006009626297946501
+volume,0.00880928321686586
+X2,0.015751598790973508
+bid_qty,0.013220012317315321
+X3,0.012269485842255193
+X4,0.00654239449422849
+X5,0.0010348928441024636
+X7,0.0025944308821192327
+X8,0.0034300916332591818
+X10,0.020332801489482785
+X9,0.00028580908342140166
+X11,0.01929229926777724
+X6,0.001548050610163923
+X12,0.0165588715634825
+X13,0.015827167242547596
+X14,0.019205324757393307
+X16,0.015038233692562328
+X18,0.0495389286089903
+X19,0.06229317282289419
+X17,0.019308888760557745
+X20,0.06766745905539914
+X15,0.01801380256953214
+X21,0.06940129957714401
+X22,0.057675788985933445
+X26,0.051697030980441185
+X23,0.04495868378089756
+X25,0.02232073770118373
+X27,0.062251351915023165
+X28,0.0640924668700726
+X24,0.033804815625741495
+X29,0.06233881415688355
+X30,0.04959420617388743
+X33,0.017364207888062616
+X31,0.04083370346268456
+X35,0.01935431667141867
+X36,0.025447235242806194
+X34,0.02398556527445634
+X32,0.032325233211784425
+X37,0.022956211669709656
+X38,0.02795916333831952
+X39,0.027772217360705318
+X41,0.028453309524691398
+X42,0.032786534146259996
+X43,0.029359757138521316
+X44,0.03309283242317208
+X40,0.03246273431140262
+X45,0.028187752253932954
+X46,0.032909379715677894
+X47,0.02819078295406666
+X49,0.028018660517079203
+X51,0.025232368496274946
+X50,0.032185682871376534
+X48,0.03270084271421543
+X52,0.028611374031482027
+X53,0.02489357290431081
+X54,0.02805955207026172
+X56,0.02708418198354691
+X57,0.01818910773647039
+X58,0.007577917684088424
+X59,0.01534699169057386
+X60,0.013268220237658888
+X55,0.024265722686556607
+X61,0.012208632097557221
+X63,0.022774806280935023
+X62,0.012693382069210677
+X67,0.020068242180993203
+X65,0.025288687433257757
+X66,0.00907155581211408
+X68,0.01325047827893222
+X64,0.010306872323105442
+X70,0.010362017605785458
+X69,0.022313902534032794
+X73,0.022930617113019382
+X71,0.030534110676999775
+X74,0.012165448248978339
+X77,0.03303197883423314
+X75,0.01914283426334949
+X79,0.023489078739195295
+X78,0.0009420697457429854
+X76,0.011379908702989303
+X72,0.0049679650800335635
+X80,0.008046271001358036
+X81,0.01593323128158368
+X82,0.020462738410646823
+X84,0.008592577364157427
+X86,0.0001202324781391542
+X85,0.0195864031220606
+X83,0.03572965303857348
+X87,0.013768460470153149
+X88,0.026294949922472194
+X89,0.04052014893258882
+X90,0.011400905431695038
+X91,0.013215487591812916
+X92,0.005490030279697772
+X94,0.031305769536799324
+X93,0.010539851904178537
+X95,0.04294833761960832
+X96,0.008760860343302914
+X97,0.0037947174551185435
+X98,0.0101981901114295
+X99,0.02268229774279479
+X100,0.0034113535917924104
+X101,0.0011613177208819278
+X102,0.011608067662744059
+X103,0.014275807197569743
+X104,0.012693382069210677
+X105,0.030543003747560023
+X107,0.00960969580439658
+X108,0.00918454102101371
+X106,0.005899379718680667
+X109,0.022215766640047225
+X111,0.03308689336173107
+X110,0.01325047827893222
+X112,0.006185143977872367
+X114,0.006492917419956656
+X115,0.026277660981014236
+X113,0.015842023978840797
+X116,0.012165448248978339
+X117,0.03181311109313795
+X119,0.021755400323134073
+X118,0.008184800114662124
+X120,0.002694578376939187
+X121,0.02802883003942629
+X122,0.008046271001358036
+X123,0.024687315905733184
+X125,0.03270885085007737
+X124,0.016338076417826544
+X126,0.001858994544980292
+X127,0.028608367876344284
+X128,0.0001202324781391542
+X129,0.016308131485285052
+X131,0.040582262726368695
+X130,0.019223099577685185
+X132,0.0006543664529083002
+X133,0.030838448531144202
+X134,0.005490030279697772
+X135,0.007609332364634602
+X136,0.022301552247880465
+X138,0.0031921652780032457
+X139,0.030552188737768198
+X137,0.04429001859855588
+X140,0.0101981901114295
+X141,0.023042845128059892
+X142,0.004235982613046026
+X145,0.017292792022015235
+X143,0.0019933391640393327
+X144,0.01363650076175092
+X146,0.012693382069210677
+X147,0.031495573785063145
+X150,0.015340435037503288
+X149,0.006417382791704757
+X148,0.007607130695117981
+X152,0.01325047827893222
+X153,0.03298982703124171
+X151,0.023104291599572186
+X154,0.007572777762347976
+X155,0.012104282733329634
+X157,0.026754581806821814
+X156,0.015561773693076462
+X159,0.029654594230513594
+X160,0.006645180613341763
+X162,0.015826905453806918
+X158,0.012165448248978339
+X161,0.01699996064135944
+X164,0.008046271001358036
+X165,0.01969959131962092
+X167,0.025575270174227914
+X166,0.00797484520088552
+X163,0.03029886933487298
+X169,0.03847601071389171
+X170,0.0001202324781391542
+X168,0.014749713182852075
+X171,0.012466512005420378
+X172,0.010055361507981147
+X174,0.010663218662580406
+X176,0.005490030279697772
+X173,0.031776339675040594
+X175,0.04581511374937557
+X177,0.006842485571387934
+X178,0.012840398293201938
+X179,0.034397211073118716
+X180,0.005172808602252609
+X181,0.04916403319775866
+X182,0.0101981901114295
+X185,0.020489574294610912
+X186,0.03734676725079289
+X183,0.031730441381844804
+X184,0.026552091041314445
+X187,0.026794552458108262
+X188,0.022605215393942033
+X191,0.02436859374316991
+X189,0.03485990908002203
+X190,0.02621294178041448
+X192,0.008331880770956143
+X193,0.002882603579195492
+X196,0.03453819898752205
+X194,0.005797419666617228
+X195,0.01813785360358937
+X197,0.040228207552348766
+X198,0.04286448308122376
+X200,0.002956859849027475
+X199,0.00781712350453114
+X201,0.005498581860449145
+X202,0.01717770044299138
+X203,0.03151333070055543
+X205,0.0368172839832081
+X204,0.03554017155796463
+X206,0.00794135047740499
+X208,0.0043338452833440715
+X207,0.003616688561134941
+X209,0.01468297489158659
+X210,0.026244140127870824
+X211,0.028824214825896293
+X213,0.006027340837544057
+X212,0.02893725318341518
+X214,0.0021162782904006455
+X215,0.010741882431978537
+X216,0.02385776743387177
+X217,0.04609159741312273
+X218,0.05367577723545755
+X220,0.003427212211532864
+X221,0.0034532696338179466
+X219,0.05671258349737499
+X223,0.02456730457636394
+X222,0.012361959439243814
+X224,0.04170717675273872
+X225,0.04502749481163463
+X226,0.045167778630829346
+X227,0.007226328108337774
+X229,0.006013905941975985
+X228,0.0016677272943551738
+X231,0.0222024274440164
+X233,0.027319134855787686
+X232,0.026220575462856287
+X230,0.01332799184085372
+X234,0.004802599279103908
+X235,0.014915328427032113
+X236,0.02016651376292459
+X237,0.025646871398892806
+X239,0.030652976130057196
+X238,0.03288083499821081
+X241,0.004080853463394878
+X240,0.022108300720443737
+X242,0.013477383770803065
+X243,0.01821433852582617
+X244,0.023394550818409618
+X245,0.0320808658876768
+X249,0.00781607971112136
+X246,0.031458217776739385
+X247,0.024210763067772034
+X248,0.00863641572532207
+X250,0.0027962684704145946
+X251,0.0019318570757931224
+X252,0.00515208968271676
+X255,0.00789104052422053
+X253,0.006788801858526989
+X254,0.00817527909654802
+X256,0.0007592684874167758
+X257,0.011270578272792906
+X258,0.0071947205377904
+X260,0.0068110323303332086
+X259,0.0053586658138714445
+X261,0.012756228867117175
+X263,0.012351675221826626
+X264,0.029664898637745345
+X262,0.01320555850144599
+X265,0.03083543653798079
+X267,0.033153158810700765
+X266,0.03411762779330201
+X268,0.03388656581803048
+X269,0.03962107379275058
+X271,0.03848886311034982
+X270,0.03875202640359222
+X272,0.04253566247716398
+X274,0.03045878258773289
+X275,0.029810274240332505
+X273,0.029779784480246364
+X276,0.032973727817054405
+X277,0.042090016419938744
+X278,0.04043904861919386
+X279,0.0399028729101604
+X280,0.03952704679369435
+X281,0.04786508179780874
+X282,0.041294235420860345
+X283,0.04983782500741813
+X284,0.04376298279116218
+X285,0.052865461293543504
+X286,0.04866142874455701
+X288,0.04889133105146001
+X287,0.055892868911022124
+X289,0.05589197750170329
+X290,0.048879292680438294
+X293,0.05529117296384762
+X292,0.05150887683057305
+X294,0.05130548343745833
+X291,0.055435097195834934
+X295,0.05463728050716738
+X296,0.05072460123909159
+X297,0.05328322542690132
+X298,0.05310381859226198
+X299,0.05236608777359549
+X301,0.051464941364311
+X300,0.052631468067681736
+X302,0.051736262039276
+X303,0.04988449271900805
+X304,0.015115450772781404
+X306,0.013953873767093956
+X305,0.009297012223438934
+X307,0.026854817464545794
+X308,0.00534034257442587
+X309,0.012227045059450103
+X311,0.010286769745277096
+X310,0.016328941631575146
+X312,0.018049055700084506
+X314,0.007370533776718553
+X313,0.030764854544905008
+X315,0.011343486452670895
+X317,0.010653294584636291
+X316,0.013834108405729954
+X318,0.019755274146099105
+X319,0.03200075360083825
+X320,0.009451915423723607
+X321,0.009330154366034476
+X322,0.009955897654046046
+X324,0.022153922628416256
+X323,0.008713511333356804
+X325,0.03422793548485072
+X326,0.011020616977703792
+X327,0.004964570848726991
+X329,0.0009253743928405479
+X328,0.011480873944642924
+X330,0.027857545963232713
+X331,0.03631603617736357
+X332,0.009786741972240599
+X334,0.015661324167114778
+X333,0.0010543713990520094
+X335,0.000976978174210585
+X336,0.031051559424361136
+X337,0.03201458707345958
+X340,0.016961942354104798
+X339,0.006045303318496352
+X338,0.007851404022343118
+X341,0.000498957878007569
+X343,0.027815697857855277
+X344,0.009060565920824132
+X342,0.02985719161300178
+X346,0.0166218637161054
+X345,0.011438585908311288
+X347,0.010129776444548867
+X348,0.0074992830624918405
+X349,0.029479656398089846
+X350,0.012993672635989183
+X351,0.012227045059450103
+X352,0.017752772506635595
+X353,0.011630740768134407
+X354,0.014360202438445706
+X355,0.035867191399074995
+X356,0.016560404242590143
+X357,0.011343486452670895
+X360,0.01786664297047221
+X358,0.015879653363168204
+X359,0.011193245588155543
+X361,0.037180487197274216
+X362,0.01715178345613917
+X363,0.009330154366034476
+X364,0.01272459215799313
+X365,0.008200552598189624
+X366,0.020283749882732665
+X367,0.03770372684000478
+X369,0.004964570848726991
+X368,0.015954528082885708
+X370,0.013577251202526976
+X371,0.0002580360578592943
+X374,0.014137738874577517
+X372,0.024979062081955748
+X375,0.0010543713990520094
+X373,0.03813565139723776
+X376,0.016019059486055507
+X377,0.0016664007538047315
+X378,0.02996770273994749
+X379,0.03794460211066158
+X380,0.013864904214159049
+X381,0.006045303318496352
+X382,0.016674784452924366
+X383,0.0006869604635523245
+X384,0.032097530928572406
+X385,0.03809464465373621
+X386,0.00892984272760343
+X388,0.015516466610183714
+X387,0.011438585908311288
+X389,0.003239395154835977
+X390,0.0023214346148472
+X391,0.004887673001145214
+X393,0.012227045059450103
+X394,0.019201784813083028
+X392,0.008577188750002959
+X396,0.004336040919130043
+X395,0.00323401260909416
+X397,0.003782817687480835
+X398,0.010554168956545937
+X399,0.011343486452670895
+X400,0.018426861383463364
+X401,0.0024775595714782665
+X403,0.003709282191637838
+X404,0.010157359953035084
+X402,0.008835946809441777
+X406,0.01558222908644609
+X405,0.009330154366034476
+X407,2.792132455082131e-05
+X408,0.01148717057281973
+X409,0.005875428372046327
+X411,0.004964570848726991
+X410,0.008990675307716989
+X412,0.015701086156328908
+X413,0.00398114170937874
+X414,0.01587301353942877
+X415,0.00828652411850645
+X416,0.011032771196386537
+X418,0.016880404757385194
+X417,0.0010543713990520094
+X419,0.0021659062855295045
+X420,0.022010904826082346
+X421,0.010708317086460846
+X423,0.006045303318496352
+X422,0.016800665513200676
+X425,0.0022252818616368296
+X424,0.016176302313515873
+X427,0.013807009745532546
+X426,0.026630274349096702
+X428,0.01927169677538422
+X430,0.021898633029896225
+X429,0.011438585908311288
+X431,0.030079767071827412
+X432,0.03734260767135224
+X433,0.024408452050988606
+X435,0.036952683486087004
+X434,0.027752935329207834
+X436,0.022994963513477556
+X438,0.03311542406361313
+X437,0.0232416623268677
+X439,0.0006674076273566988
+X440,0.0053046727900784435
+X442,0.014225618925895599
+X441,0.008517663726876432
+X443,0.03160692993429311
+X444,0.03945923552438475
+X445,0.03847565190003187
+X446,0.0030565442473429166
+X447,0.006925826553175941
+X448,0.009391731108401406
+X449,0.013879886828492375
+X450,0.028654784568285553
+X452,0.0342146409757117
+X451,0.03532866510146789
+X453,0.0021416103257284294
+X454,0.0052396304757588615
+X456,0.010218912048981867
+X455,0.007056477863367114
+X457,0.02175995826852137
+X458,0.027053100624689966
+X460,0.01179206527007791
+X459,0.02613119302137511
+X461,0.00610544813647415
+X462,0.00043370218338843573
+X463,0.012848357209391894
+X465,0.04953812582425797
+X464,0.04033763404028344
+X466,0.049228334452943945
+X467,0.0005979717119699696
+X468,0.0033881051369683193
+X469,0.007685825483870779
+X471,0.03707210771504421
+X470,0.01673665198093028
+X472,0.04246242914286378
+X474,0.0014884753337954136
+X473,0.04019964914248776
+X475,6.298768554620273e-05
+X476,0.0025105676696775357
+X477,0.007376651961858709
+X478,0.01966994682803971
+X480,0.021931338665365896
+X479,0.023444568662026655
+X481,0.0037933191605447466
+X482,0.009456081492703813
+X483,0.012227628925595592
+X484,0.014504507166841114
+X485,0.014401739806055185
+X486,0.010803910374854175
+X487,0.006573198322241548
+X489,0.00935766397058297
+X488,0.0034270507400633054
+X490,0.011559619845561928
+X492,0.014357170304625369
+X491,0.013454130753045596
+X493,0.011001477913856656
+X495,0.006353651469653068
+X496,0.017572029862777082
+X497,0.02886487059569618
+X494,0.007621631433950686
+X499,0.017589309325062075
+X498,0.022737458238146543
+X500,0.014795334814436397
+X501,0.013516682096938844
+X502,0.007102224662157954
+X503,0.027664784124541267
+X504,0.037431152300813474
+X505,0.02808419401296176
+X506,0.02459729559049703
+X507,0.019694315336865942
+X508,0.022755646248770425
+X509,0.006993292839321513
+X510,0.0320748269109876
+X511,0.0367726500006249
+X512,0.031114046611546257
+X514,0.02168095568693507
+X515,0.021584258837756914
+X513,0.021806087315372404
+X516,0.009398230414242616
+X517,0.03614880523691168
+X518,0.03187091234297883
+X519,0.034542211530895456
+X520,0.015370205031353938
+X521,0.027395803529844
+X522,0.012461414592708657
+X524,0.04802013567400222
+X523,0.00856697789299001
+X525,0.0198212932022529
+X526,0.02925843985586276
+X527,0.005158103286663351
+X529,0.010665814227123746
+X528,0.02498965092507624
+X530,0.004165433245888023
+X531,0.05618361361403625
+X532,0.030601998655923682
+X533,0.03710041831258064
+X534,0.0013293427861043247
+X536,0.012308813330731722
+X535,0.02560570170433261
+X537,0.004721675034502699
+X538,0.04099174076600001
+X540,0.03742205579551493
+X539,0.029653227351439312
+X542,0.03122523701731007
+X541,0.00027286465365741665
+X543,0.010987778309195007
+X544,4.211922161061338e-05
+X546,0.01977980375587412
+X547,0.017076700050764844
+X545,0.012760868988627628
+X548,0.012706293941809875
+X549,0.017839577925667812
+X550,0.013534716268347046
+X551,0.003331454741458525
+X552,0.020890445206327966
+X554,0.029353831462913954
+X553,0.028138617010427358
+X555,0.013475953016055225
+X556,0.026573257956355137
+X559,0.024388436421656685
+X558,0.007205396733588569
+X557,0.010738686134352483
+X560,0.02673470328124766
+X563,0.01813375553299066
+X561,0.026699020419041257
+X562,0.015624952478745171
+X564,0.008757526385577578
+X565,0.015515157101454246
+X566,0.02663574146165673
+X568,0.02508164707594524
+X567,0.021091635071447155
+X569,0.011058995430675529
+X570,0.013973782068801005
+X571,0.004565121121850348
+X572,0.022527184368686552
+X574,0.019503402991749963
+X573,0.03472478182667333
+X575,0.00035972505129474425
+X576,0.03281278968326802
+X578,0.018259220972135323
+X577,0.002515018470042229
+X579,0.024823312205901754
+X580,0.04172458904654195
+X581,0.03201246659649179
+X582,0.012573595321147376
+X583,0.03412015486713785
+X584,0.0027885537822756237
+X585,0.022471794514023598
+X586,0.012969158411920038
+X587,0.035917611827566094
+X588,0.03403859606170242
+X589,0.016362968742996944
+X590,0.02722336239576063
+X591,0.005202253581104186
+X592,0.007565904948598441
+X593,0.01285899740499138
+X594,0.011059213565168187
+X595,0.003707164552688389
+X596,0.01093572782830869
+X597,0.004387906538154478
+X598,0.054527755682121384
+X599,0.01476557221811526
+X600,0.01703685476113392
+X601,0.019903325690859338
+X603,0.029827344475402928
+X602,0.02406277096382
+X604,0.031407057390806056
+X605,0.03115843839837678
+X606,0.01500296831777802
+X608,0.020785439238087827
+X607,0.019171039096985868
+X609,0.022094209449879304
+X610,0.027743705753122874
+X611,0.03438629083472148
+X612,0.04061425206068214
+X613,0.006802600089049049
+X614,0.006787142150752563
+X616,0.0026093316854809328
+X615,0.0018385886722819657
+X617,0.009132872446091286
+X618,0.0022625779022328683
+X621,0.0029094414758438587
+X619,0.006242624221814225
+X622,0.0021052183440793595
+X620,0.004915890948794204
+X623,0.007695518495453411
+X624,0.002941719943783813
+X625,0.0114819783366659
+X626,0.011645601197147457
+X627,0.001535519450341619
+X628,0.005801250491160117
+X629,0.01543437270388279
+X630,0.0019246140380028303
+X631,0.010852816115796951
+X632,0.007455340999907042
+X633,0.0035188671566097297
+X634,0.005431152652918018
+X635,0.014415339705721125
+X636,0.002623010529335238
+X637,0.014338509407605409
+X638,0.015334318974029149
+X642,0.0017286660923145293
+X639,0.0005366782536744723
+X640,0.008108190421653306
+X641,0.019955800139309348
+X644,0.009292651437215617
+X643,0.013462342146901913
+X645,0.004458670578635313
+X646,0.007620914409814536
+X647,0.018207984979476167
+X648,0.0035117669053162403
+X649,0.014671413723246318
+X650,0.016225304317315455
+X651,0.000471530546651396
+X653,0.0205321715801488
+X652,0.009331525441641514
+X654,0.0009390003331521383
+X655,0.013655415543528067
+X656,0.008361579660947844
+X657,0.004085847590628451
+X658,0.008493165881913007
+X659,0.016637821981365535
+X660,0.003166510434759787
+X661,0.013895906541256924
+X662,0.013920014448508287
+X663,0.000851832770835647
+X664,0.012444468000828799
+X665,0.01516206998773945
+X666,0.005635761266991576
+X667,0.012645200876932175
+X668,0.009064909103222833
+X670,0.011322154910258092
+X669,0.0019113035733135239
+X671,0.015210649436339662
+X672,0.004939087142730333
+X673,0.013758620633175686
+X674,0.02116310035929281
+X675,0.002500286021268377
+X676,0.015401799469385894
+X677,0.01883827586871801
+X678,0.01849662220976336
+X679,0.012629660568329582
+X680,0.015036355087687109
+X681,0.001193663120383472
+X683,0.02081787928886514
+X682,0.014446721301616075
+X684,0.01864308164695379
+X687,0.008839154705720768
+X685,0.011565541616818407
+X686,0.024187496831472848
+X688,0.015653600731238008
+X689,0.0187912664629739
+X691,0.011005725163480043
+X690,0.031847808295059
+X692,0.01753162897469928
+X693,0.00736604628624425
+X694,0.015068590870286398
+X695,0.0213795219966739
+X696,0.03182787755083162
+X697,
+X698,
+X699,
+X702,
+X700,
+X701,
+X703,
+X705,
+X704,
+X707,
+X706,
+X708,
+X709,
+X711,
+X712,
+X710,
+X713,
+X717,
+X715,
+X714,
+X716,
+X718,0.009457993754945004
+X721,0.0018671778678267315
+X719,0.007621036759886809
+X720,0.00508266823165767
+X722,0.00041963071776523645
+X724,0.007627076843920589
+X723,0.005400758027977596
+X725,0.01468597088940295
+X726,0.01731113297651062
+X729,0.03451753412793433
+X727,0.026971256166292753
+X730,0.026503842571771456
+X728,0.02321473532495592
+X731,0.03937010303197312
+X732,0.0051023999462277226
+X733,0.005857356282121524
+X734,0.003328231538286187
+X735,0.00662426772030378
+X736,0.007839198951606568
+X737,0.008949104600815203
+X738,0.0013047654972600077
+X740,0.009530445151010395
+X739,0.006731623350020346
+X741,0.01062820202586949
+X742,0.006724758140987537
+X743,0.0054711058912251045
+X745,0.009551997869648518
+X744,0.008281386908726833
+X746,0.015731320601958067
+X747,0.0032029624219608805
+X749,0.0001924354904351321
+X748,0.00351326108957656
+X750,0.03418492048302036
+X751,0.006935654219009256
+X753,0.0024697797572265133
+X752,0.007280034335204959
+X754,0.0411880116098168
+X755,0.02333796146821493
+X756,0.007080643929230414
+X757,0.0020882138653961313
+X758,0.04146452100721608
+X759,0.02745285489486186
+X761,0.013720913256680482
+X760,0.011581769785129696
+X762,0.010917849216945249
+X763,0.011613157040094982
+X765,0.022977757845687723
+X764,0.018921111760867977
+X766,0.012641816745130374
+X770,0.011253824441069213
+X767,0.012958050549466266
+X769,0.029310569862042734
+X768,0.023832472342753996
+X771,0.014719337781706383
+X772,0.026046609163355782
+X773,0.032444108074526544
+X774,0.006525316008111323
+X775,0.013252320015948069
+X776,0.01607020987355814
+X777,0.02410233447444815
+X781,0.01536369088361011
+X780,0.00742579143440711
+X778,0.005747357196470954
+X779,0.004581127423623524
+X782,0.014402362859179056
+X783,0.0010980644199857091
+X784,0.0022990384110193386
+X785,0.008273111762437993
+X786,0.019267153183417943
+X788,0.000478488477540488
+X787,0.0018770626506715718
+X789,0.0005743574756732422
+X792,0.0029899297529808137
+X791,0.0018047978250534404
+X790,0.0010510546274008245
+X793,0.003849497350441939
+X795,0.00018470213595348826
+X794,0.005183910214476209
+X796,0.005514841598927894
+X797,0.007130879694779356
+X801,0.008527292006270948
+X799,0.0017605402318868956
+X800,0.006514482261348192
+X798,0.008742274213048712
+X803,0.0027540251228215444
+X804,0.0048600073997061375
+X805,0.004774387162698313
+X802,0.014937761268070907
+X806,0.027319302825886068
+X808,0.003330071712592306
+X807,0.01826271695630487
+X809,0.0024352638735362676
+X810,0.03354016733145779
+X812,0.00040372169697806045
+X813,0.00035623228846241015
+X814,0.0356869899094025
+X811,0.025866141188072022
+X815,0.023863156009089795
+X817,0.011364233621504353
+X818,0.007985945636623712
+X816,0.011107842211523892
+X819,0.009131988751408571
+X820,0.016100971785304178
+X821,0.017326093455108237
+X823,0.013663647105019952
+X824,0.020283531970469993
+X825,0.02271730794521153
+X826,0.0048985871849534296
+X822,0.006394060379167369
+X828,0.02323950245782004
+X827,0.017393143284950712
+X829,0.02726801505751245
+X831,0.0210970101438473
+X832,0.01603439414243064
+X833,0.022529855772244575
+X834,0.011763352992927667
+X830,0.0016413187138757186
+X835,0.014967848792296998
+X836,0.00821785832133803
+X838,0.022968273208048395
+X839,0.012105941132643051
+X840,0.002704768413188096
+X837,0.015224769791920067
+X841,0.011517471235324499
+X842,0.028516300553349395
+X843,0.0037902397742158797
+X844,0.01449061205816509
+X845,0.009612274245240948
+X846,0.014575365760658883
+X847,0.0030809994038687063
+X848,0.009547639363191663
+X850,0.02771470787289373
+X852,0.04068629885231368
+X851,0.007517190854361444
+X854,0.006138833566092506
+X853,0.01168317532100576
+X849,0.011104578876167524
+X855,0.037702173190174944
+X856,0.04727261815748245
+X857,0.05468596363733885
+X858,0.05732029603524905
+X859,0.02007516421342708
+X860,0.056258822130222125
+X863,0.06405738275143834
+X861,0.045514811573915834
+X862,0.040827642919763804
+X864,
+X865,0.022374691114163715
+X866,0.028888661046387747
+X868,0.03778984343758759
+X871,
+X870,
+X869,
+X867,
+X873,0.001883405226228079
+X874,0.0019070735822866018
+X872,
+X876,0.0105051309323369
+X875,0.01662466300872184
+X877,0.010606541305084056
+X879,0.024398139029589098
+X878,0.018658979685034462
+X881,0.021525129940913657
+X883,0.013195271643438242
+X882,0.016577921420096075
+X884,0.0022380002551989253
+X880,0.027224954783997914
+X885,0.0024919561501807416
+X887,0.0003554317373171134
+X886,0.0016227242980143418
+X889,0.004510706868926807
+X890,0.013163234885488786
+volume_weighted_sell,0.000920180159340804
+buy_sell_ratio,0.0038328322728427722
+X888,0.0007600458032861104
+selling_pressure,0.00598292992874158
+log_volume,0.009152478116209888
+effective_spread_proxy,0.00280868848193676
+bid_ask_imbalance,0.011018573520529186
+order_flow_imbalance,0.006074116379646094
+liquidity_ratio,0.005108214037839909

ZMJ/data_processed/test_aggregated.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78849b15de7197ff26cc84104a045625f4b64308fa9b035883f5b547122a5c49
+size 1254913844

ZMJ/data_processed/train_aggregated.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:616b9c4135e67380ba5b7649d69ec91d1d5e5cca2f47dac3ff6e365020c00222
+size 1216012686

ZMJ/data_processed_7_16/alpha_selected.py

@@ -0,0 +1,154 @@
+import sys
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import KFold
+import xgboost as xgb
+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
+import torch
+import matplotlib.pyplot as plt
+import seaborn as sns
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from itertools import combinations
+import time
+
+train_df = pd.read_pickle('train_df.pkl')
+test_df = pd.read_pickle('test_df.pkl')
+
+length = len(train_df)
+df = pd.concat([train_df, test_df], axis=0)
+LABEL_COLUMN = 'label'
+feature_cols = [col for col in train_df.columns if col != LABEL_COLUMN]
+
+X = train_df[feature_cols].values
+y = train_df[LABEL_COLUMN].values
+
+# 先将X转为numpy数组，再删除全为0的列，并同步更新feature_cols
+X_np = np.asarray(X)
+nonzero_col_idx = np.where((X_np != 0).any(axis=0))[0]
+X = X_np[:, nonzero_col_idx]
+feature_cols = [feature_cols[i] for i in nonzero_col_idx]
+
+X_np = np.asarray(X)
+y_np = np.asarray(y)
+corrs = np.array([np.corrcoef(X_np[:, i], y_np)[0, 1] for i in range(X_np.shape[1])])
+
+# 对于相关性为负的特征，将该列取负
+X_adj = X_np.copy()
+neg_idx = np.where(corrs < 0)[0]
+X_adj[:, neg_idx] = -X_adj[:, neg_idx]
+
+# 找到相关性绝对值大于0.01的特征索引
+selected_idx = np.where(np.abs(corrs) > 0.01)[0]
+
+# 取出这些特征对应的X的列
+X_selected = X_adj[:, selected_idx]
+selected_features = [feature_cols[i] for i in selected_idx]
+
+def max_ic_factor_selection(X, y, feature_cols, threshold=0.9):
+    X = np.asarray(X)
+    n_features = X.shape[1]
+    corr_matrix = np.corrcoef(X, rowvar=False)
+    used = set()
+    selected_idx = []
+    for i in range(n_features):
+        if i in used:
+            continue
+        # 找到与第i个特征高度相关的特征
+        group = [i]
+        for j in range(i+1, n_features):
+            if j not in used and abs(corr_matrix[i, j]) > threshold:
+                group.append(j)
+        # 组内选与y相关性（IC）最大的特征
+        if len(group) == 1:
+            selected_idx.append(group[0])
+        else:
+            ic_list = [abs(pearsonr(X[:, k], y)[0]) for k in group]
+            best_k = group[np.argmax(ic_list)]
+            selected_idx.append(best_k)
+        used.update(group)
+    X_new = X[:, selected_idx]
+    feature_cols_new = [feature_cols[i] for i in selected_idx]
+    return X_new, feature_cols_new
+
+# 在训练前进行最大IC因子合成，减少共线性
+n_train = train_df.shape[0]
+X_selected, selected_features = max_ic_factor_selection(X_selected, y[:n_train], selected_features, threshold=0.9)
+
+X_train = X_selected
+X_test = test_df[selected_features].values
+
+y_train = y
+y_test = test_df[LABEL_COLUMN].values
+breakpoint()
+
+kf = KFold(n_splits=5, shuffle=True, random_state=42)
+
+import math
+
+# 余弦退火调度函数
+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
+
+# XGBoost参数（更复杂的树结构+更强正则+早停机制）
+xgb_params = {
+    'n_estimators': 10000,           # 增加树的数量
+    'learning_rate': 0.01,
+    'max_depth': 10,                # 增加树的深度
+    'subsample': 0.85,              # 增加样本采样比例
+    'colsample_bytree': 0.85,       # 增加特征采样比例
+    'tree_method': 'hist',
+    'device': 'gpu',
+    'predictor': 'gpu_predictor',
+    'random_state': 42,
+    'reg_alpha': 5,                 # 增大L1正则
+    'reg_lambda': 10,               # 增大L2正则
+    'min_child_weight': 5,          # 增大叶子节点最小样本权重和
+    'gamma': 0.2,                   # 增大分裂所需的最小损失减少
+    'early_stopping_round': 100,
+    'verbose_eval': 100,
+    'eval_metric': 'rmse',
+    'callbacks': [
+        xgb.callback.LearningRateScheduler(cosine_annealing)
+    ]
+}
+print("start training")
+val_scores = []
+test_preds = np.zeros(X_test.shape[0])
+
+for train_idx, val_idx in kf.split(X_train):
+    X_tr, X_val = X_train[train_idx], X_train[val_idx]
+    y_tr, y_val = y_train[train_idx], y_train[val_idx]
+    model = XGBRegressor(**xgb_params)
+    model.fit(
+        X_tr, y_tr,
+        eval_set=[(X_val, y_val)],
+        # eval_metric='rmse',
+    )
+    val_pred = model.predict(X_val)
+    val_score = np.sqrt(np.mean((val_pred - y_val) ** 2))  # RMSE
+    val_scores.append(val_score)
+    test_preds += model.predict(X_test) / kf.n_splits
+
+print(f"平均验证RMSE: {np.mean(val_scores):.6f}")
+
+# 保存预测结果到csv
+result_df = pd.DataFrame({
+    'ID': np.arange(1, len(test_preds) + 1),
+    'prediction': test_preds
+})
+result_df.to_csv('xgb_prediction-3.csv', index=False)
+print('预测结果已保存到 xgb_prediction.csv')
+
+
+
+

ZMJ/data_processed_7_16/data_processed.py

@@ -0,0 +1,92 @@
+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
+import torch
+import matplotlib.pyplot as plt
+import seaborn as sns
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from itertools import combinations
+import time
+
+TRAIN_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/train.parquet"
+TEST_PATH = "/AI4M/users/mjzhang/workspace/DRW/new_data/test.parquet"
+
+train_df = pd.read_parquet(TRAIN_PATH)
+test_df = pd.read_parquet(TEST_PATH)
+
+# ===== 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
+
+train_df = feature_engineering(train_df)
+test_df = feature_engineering(test_df)
+LABEL_COLUMN = 'label'
+feature_cols = [col for col in train_df.columns if col != LABEL_COLUMN]
+train_len = len(train_df)
+df = pd.concat([train_df, test_df], axis=0)
+X = train_df[feature_cols].values
+y = train_df[LABEL_COLUMN].values
+
+from sklearn.preprocessing import StandardScaler
+import joblib
+
+def clip_by_median_mad(df, n=3):
+    df_num = df.select_dtypes(include=[np.number])
+    median = df_num.median()
+    mad = (df_num - median).abs().median()
+    lower = median - n * mad
+    upper = median + n * mad
+    df_clipped = df_num.clip(lower=lower, upper=upper, axis=1)
+    # 如果原df有非数值型列，合并回来
+    for col in df.columns:
+        if col not in df_clipped.columns:
+            df_clipped[col] = df[col]
+    return df_clipped
+
+all_features = feature_cols + [LABEL_COLUMN]
+train_df[all_features] = clip_by_median_mad(train_df[all_features])
+test_df[all_features] = clip_by_median_mad(test_df[all_features])
+
+scaler = StandardScaler()
+train_df[all_features] = scaler.fit_transform(train_df[all_features])
+test_df[all_features] = scaler.transform(test_df[all_features])
+
+joblib.dump(scaler, 'scaler.pkl')
+
+train_df.to_pickle('train_df.pkl')
+test_df.to_pickle('test_df.pkl')
+

ZMJ/data_processed_7_16/output.log

@@ -0,0 +1,73 @@
+Loading data...
+Loaded data - Train: (525886, 270), Test: (538150, 270), Submission: (538150, 2)
+Total features: 269
+
+Training models...
+
+--- Fold 1/5 ---
+  Training slice: full_data, samples: 420708
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_75pct, samples: 394415
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_50pct, samples: 262943
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+
+--- Fold 2/5 ---
+  Training slice: full_data, samples: 420709
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_75pct, samples: 315531
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_50pct, samples: 262943
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+
+--- Fold 3/5 ---
+  Training slice: full_data, samples: 420709
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_75pct, samples: 289238
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_50pct, samples: 210354
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+
+--- Fold 4/5 ---
+  Training slice: full_data, samples: 420709
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_75pct, samples: 289238
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_50pct, samples: 157766
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+
+--- Fold 5/5 ---
+  Training slice: full_data, samples: 420709
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_75pct, samples: 289238
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+  Training slice: last_50pct, samples: 157766
+    Error training xgb_baseline: value 100 for Parameter verbosity exceed bound [0,3]
+verbosity: Flag to print out detailed breakdown of runtime.
+
+Creating submissions...
+
+XGBoost Baseline Score: nan
+
+==================================================
+SUBMISSION SUMMARY:
+==================================================
+xgb_baseline             : nan
+
+All submissions created successfully!
+Files created:
+- submission_xgb_baseline.csv (original baseline)

ZMJ/data_processed_7_16/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf51e9e850652ebdfbed065bc240ecccbe722816049ca6b76bb7f558aac04c1b
+size 25495

ZMJ/data_processed_7_16/submission_xgb_baseline_59_pca.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31d3822df5d11aad9004c54ff1125d35e7f83b302da648e9a3b8dda0d27ceb9b
+size 14177262

ZMJ/data_processed_7_16/test_df.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9aef44bd247a8a4f853979aaf0dd0c0961fff68d5a57b1fc2e2f6756ed3bd753
+size 3418382946

ZMJ/data_processed_7_16/train.py

@@ -0,0 +1,282 @@
+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)")

ZMJ/data_processed_7_16/train_df.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8817730be609ad591801562a2415f2eb2db4a507a3bc380da7dbe4a9f2736de1
+size 3344689432

ZMJ/data_processed_7_16/xgb_prediction-2.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdeb23e24591e9bd0cf0961213a5d6dc431312f5fbd429cd7fe67dc99608f39b
+size 14476941

ZMJ/data_processed_7_16/xgb_prediction.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d0131de297b7213dc717883daaa29d065ec6a9832dd210cbb5088449a13886f
+size 14525435