import sys import pandas as pd import numpy as np import torch import torch.nn as nn import torch.optim as optim from sklearn.model_selection import KFold from sklearn.preprocessing import RobustScaler from scipy.stats import pearsonr import warnings import pickle warnings.filterwarnings('ignore') # ===== Feature Engineering ===== def feature_engineering(df): # 保持接口一致，实际特征工程已在feature.py完成 return df # ===== Configuration ===== class Config: 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/max_IC_mixed/sample_submission.csv" LABEL_COLUMN = "label" N_FOLDS = 5 # 增加交叉验证折数 RANDOM_STATE = 42 DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu') BATCH_SIZE = 256 # 增加批次大小 EPOCHS = 100 # 增加训练轮数 LEARNING_RATE = 5e-4 # 降低学习率 WEIGHT_DECAY = 1e-3 # 增加L2正则化 PATIENCE = 15 # 增加早停容忍轮数 # ===== MLP Model Definition ===== class MLP(nn.Module): def __init__(self, input_dim): super().__init__() self.net = nn.Sequential( nn.Linear(input_dim, 256), # nn.BatchNorm1d(512), nn.ReLU(), nn.Dropout(0.1), nn.Linear(256, 128), # nn.BatchNorm1d(256), nn.ReLU(), nn.Dropout(0.1), # nn.Linear(256, 128), # nn.BatchNorm1d(128), # nn.ReLU(), # nn.Dropout(0.1), # nn.Linear(128, 64), # nn.BatchNorm1d(64), # nn.ReLU(), # nn.Dropout(0.1), nn.Linear(128, 1) ) # 权重初始化 self.apply(self._init_weights) def _init_weights(self, module): if isinstance(module, nn.Linear): nn.init.xavier_uniform_(module.weight) if module.bias is not None: nn.init.zeros_(module.bias) def forward(self, x): return self.net(x) # ===== Data Loading ===== def load_data(): 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.FEATURES = [col for col in train_df.columns.tolist() if col != Config.LABEL_COLUMN] 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 train_mlp(X_train, y_train, X_valid, y_valid, X_test, scaler): X_train = scaler.transform(X_train) X_valid = scaler.transform(X_valid) X_test = scaler.transform(X_test) X_train = torch.tensor(X_train, dtype=torch.float32, device=Config.DEVICE) y_train = torch.tensor(y_train.values, dtype=torch.float32, device=Config.DEVICE).view(-1, 1) X_valid = torch.tensor(X_valid, dtype=torch.float32, device=Config.DEVICE) y_valid = torch.tensor(y_valid.values, dtype=torch.float32, device=Config.DEVICE).view(-1, 1) X_test = torch.tensor(X_test, dtype=torch.float32, device=Config.DEVICE) model = MLP(X_train.shape[1]).to(Config.DEVICE) optimizer = optim.AdamW(model.parameters(), lr=Config.LEARNING_RATE, weight_decay=Config.WEIGHT_DECAY) criterion = nn.MSELoss() scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=Config.EPOCHS) best_model_state = None best_score = -np.inf patience_counter = 0 for epoch in range(Config.EPOCHS): # 训练阶段 model.train() idx = np.random.permutation(len(X_train)) total_loss = 0 num_batches = 0 for i in range(0, len(X_train), Config.BATCH_SIZE): batch_idx = idx[i:i+Config.BATCH_SIZE] xb = X_train[batch_idx] yb = y_train[batch_idx] optimizer.zero_grad() pred = model(xb) loss = criterion(pred, yb) loss.backward() optimizer.step() total_loss += loss.item() num_batches += 1 avg_loss = total_loss / num_batches scheduler.step() # 验证阶段 model.eval() with torch.no_grad(): val_pred = model(X_valid).cpu().numpy().flatten() val_score = np.corrcoef(val_pred, y_valid.cpu().numpy().flatten())[0, 1] if val_score > best_score: best_score = val_score best_model_state = model.state_dict().copy() patience_counter = 0 else: patience_counter += 1 # 每10轮显示一次进度 if (epoch + 1) % 10 == 0: print(f" Epoch {epoch+1}/{Config.EPOCHS} - Loss: {avg_loss:.4f} - Val Corr: {val_score:.4f} - Best: {best_score:.4f}") # 早停检查 if patience_counter >= Config.PATIENCE: print(f"Early stopping at epoch {epoch+1}, best valid corr: {best_score:.4f}") break # 加载最佳模型 model.load_state_dict(best_model_state) model.eval() # 用最佳模型预测 with torch.no_grad(): valid_pred = model(X_valid).cpu().numpy().flatten() test_pred = model(X_test).cpu().numpy().flatten() return valid_pred, test_pred, best_score def train_and_evaluate(train_df, test_df): """使用k折交叉验证训练MLP模型""" X_train = train_df[Config.FEATURES] y_train = train_df[Config.LABEL_COLUMN] X_test = test_df[Config.FEATURES] # 初始化预测数组 n_samples = len(train_df) oof_preds = np.zeros(n_samples) test_preds = np.zeros(len(test_df)) # 初始化交叉验证 kf = KFold(n_splits=Config.N_FOLDS, shuffle=True, random_state=Config.RANDOM_STATE) fold_scores = [] best_fold_score = -np.inf best_fold_model = None best_fold_scaler = None best_model_state = None print(f"开始 {Config.N_FOLDS} 折交叉验证...") for fold, (train_idx, valid_idx) in enumerate(kf.split(train_df), 1): print(f"\n--- Fold {fold}/{Config.N_FOLDS} ---") # 分割数据 X_fold_train = X_train.iloc[train_idx] y_fold_train = y_train.iloc[train_idx] X_fold_valid = X_train.iloc[valid_idx] y_fold_valid = y_train.iloc[valid_idx] # 数据标准化 scaler = RobustScaler() scaler.fit(X_fold_train) # 训练模型 valid_pred, test_pred, fold_score = train_mlp( X_fold_train, y_fold_train, X_fold_valid, y_fold_valid, X_test, scaler ) # 保存OOF预测 oof_preds[valid_idx] = valid_pred test_preds += test_pred / Config.N_FOLDS fold_scores.append(fold_score) print(f"Fold {fold} 验证集相关系数: {fold_score:.4f}") # 记录最佳模型 if fold_score > best_fold_score: best_fold_score = fold_score best_fold_model = fold best_fold_scaler = scaler # 保存最佳模型状态（这里需要重新训练一次来获取状态） print(f" -> 新的最佳模型 (Fold {fold})") # 计算整体OOF分数 overall_score = pearsonr(y_train, oof_preds)[0] print(f"\n=== 交叉验证结果 ===") print(f"各折验证集相关系数: {[f'{score:.4f}' for score in fold_scores]}") print(f"平均验证集相关系数: {np.mean(fold_scores):.4f} ± {np.std(fold_scores):.4f}") print(f"最佳验证集相关系数: {best_fold_score:.4f} (Fold {best_fold_model})") print(f"整体OOF相关系数: {overall_score:.4f}") # 保存最佳模型信息 model_info = { 'best_fold': best_fold_model, 'best_score': best_fold_score, 'fold_scores': fold_scores, 'overall_score': overall_score, 'config': { 'n_folds': Config.N_FOLDS, 'epochs': Config.EPOCHS, 'learning_rate': Config.LEARNING_RATE, 'batch_size': Config.BATCH_SIZE } } with open('/AI4M/users/mjzhang/workspace/DRW/ZMJ/max_IC_mixed/mlp_best_model_info.pkl', 'wb') as f: pickle.dump(model_info, f) print(f"最佳模型信息已保存: mlp_best_model_info.pkl") return oof_preds, test_preds, fold_scores, best_fold_score # ===== Submission ===== def create_submission(train_df, oof_preds, test_preds, submission_df, fold_scores, best_fold_score): overall_score = pearsonr(train_df[Config.LABEL_COLUMN], oof_preds)[0] print(f"\n=== MLP 最终结果 ===") print(f"各折验证集相关系数: {[f'{score:.4f}' for score in fold_scores]}") print(f"平均验证集相关系数: {np.mean(fold_scores):.4f} ± {np.std(fold_scores):.4f}") print(f"最佳验证集相关系数: {best_fold_score:.4f}") print(f"整体OOF相关系数: {overall_score:.4f}") submission = submission_df.copy() submission["prediction"] = test_preds submission.to_csv("/AI4M/users/mjzhang/workspace/DRW/ZMJ/max_IC_mixed/submission_mlp_cv.csv", index=False) print("Saved: submission_mlp_cv.csv") return overall_score # ===== Main Execution ===== if __name__ == "__main__": print("Loading data...") train_df, test_df, submission_df = load_data() print("\nTraining MLP model...") oof_preds, test_preds, fold_scores, best_fold_score = train_and_evaluate(train_df, test_df) print("\nCreating submission...") score = create_submission(train_df, oof_preds, test_preds, submission_df, fold_scores, best_fold_score) print(f"\nAll done! MLP OOF PearsonR: {score:.4f}")