DRW/DRW-Crypto/HyperparameterOptimizer.py

# -*- 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)