Download DRW/DRW-Crypto/Utils.py from ChanceuxMJ/Personal_Code: direct link, hf CLI and curl.
- Browser
- Download file 29.5 kB
-
https://huggingface.co/datasets/ChanceuxMJ/Personal_Code/resolve/main/DRW/DRW-Crypto/Utils.py
- Command line
-
hf download hf://datasets/ChanceuxMJ/Personal_Code/DRW/DRW-Crypto/Utils.py
-
curl -L -o Utils.py https://huggingface.co/datasets/ChanceuxMJ/Personal_Code/resolve/main/DRW/DRW-Crypto/Utils.py
29.5 kB
| # -*- 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 | |