eta_model/WTI/Rbob.py

import pandas as pd
import numpy as np
import xgboost as xgb
from xgboost import XGBRegressor
from sklearn.metrics import mean_squared_error, r2_score
import matplotlib.pyplot as plt
from skopt import BayesSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, TimeSeriesSplit
import argparse  
import itertools
import random
from skopt.space import Real, Integer, Categorical
import json

from Dtool import fill_missing_values, reverse_column
from api import fetch_data_by_indicators


# 添加命令行参数解析
def parse_arguments():
    parser = argparse.ArgumentParser(description='RBOB汽油裂解预测模型')
    
    # XGBoost参数
    parser.add_argument('--objective', type=str, default='reg:squarederror', help='XGBoost目标函数')
    parser.add_argument('--learning_rate', type=float, default=0.1, help='学习率')
    parser.add_argument('--max_depth', type=int, default=8, help='最大树深度')
    parser.add_argument('--min_child_weight', type=float, default=3, help='最小子权重')
    parser.add_argument('--gamma', type=float, default=2, help='gamma参数')
    parser.add_argument('--subsample', type=float, default=0.85, help='子样本比例')
    parser.add_argument('--colsample_bytree', type=float, default=0.75, help='每棵树的列采样率')
    parser.add_argument('--eval_metric', type=str, default='rmse', help='评估指标')
    parser.add_argument('--seed', type=int, default=42, help='随机种子')
    parser.add_argument('--reg_alpha', type=float, default=0.45, help='L1正则化')
    parser.add_argument('--reg_lambda', type=float, default=1.29, help='L2正则化')
    parser.add_argument('--booster', type=str, default='gbtree', help='提升器类型')
    parser.add_argument('--tree_method', type=str, default='auto', help='树构建方法')
    parser.add_argument('--max_delta_step', type=int, default=0, help='最大步长')

    # 其他参数
    parser.add_argument('--num_boost_round', type=int, default=1000, help='提升迭代次数')
    parser.add_argument('--use_hyperparam_tuning', type=str, default='False', help='是否使用超参数调优')
    parser.add_argument('--output_prefix', type=str, default='', help='输出文件前缀，如传入1234则生成1234_update.xlsx')

    args = parser.parse_args()
    return args



# 使用示例
INDICATOR_IDS = ["RBWTICKMc1", "C2406121350446455",'USGGBE02 Index', "Cinjcjc4 index",'injcjc4 index','C2201059138_241106232710','C2406036178','C22411071623523660','C2312081670','REFOC-T-EIA_241114135248','C2304065621_241024124344','REFOC-T-EIA_241114135248','C22503031424010431']


# 这些变量将在main函数中从命令行参数更新
NUM_BOOST_ROUND = 1000
RANDOM_STATE = 42
USE_HYPERPARAM_TUNING = False    # 若 False 则直接使用 xgb.train
TARGET_COL = '美国RBOB汽油裂解'
TEST_PERIOD = 20
SEARCH_MODE = 'random'           # 可选 'grid' / 'bayesian' / 'random'
SHOW_PLOTS = True
ADJUST_FULL_PREDICTIONS = True


TARGET_NAME = '美国RBOB汽油裂解'
CLASSIFICATION = '原油'
MODEL_FRAMEWORK = 'XGBoost'
CREATOR = '张立舟'
#PRED_DATE = '2024/11/11'           
FREQUENCY = '月度'
OUTPUT_PATH = 'update.xlsx'     
SIGNIFICANT_DIGITS = 5

# XGBoost默认参数，将在main函数中从命令行参数更新
DEFAULT_PARAMS = {
    'objective': 'reg:squarederror',
    'learning_rate': 0.1,
    'max_depth': 8,
    'min_child_weight': 3,
    'gamma': 2,
    'subsample': 0.85,
    'colsample_bytree': 0.75,
    'eval_metric': 'rmse',
    'seed': 42,
    'reg_alpha': 0.45,
    'reg_lambda': 1.29,
    'max_delta_step': 0,
    'booster': 'gbtree',
    'tree_method': 'auto'
}

# —— 因子预处理相关配置 —— 
FILL_METHODS = {
    '美国2年通胀预期': 'rolling_mean_5',
    '美国首次申领失业金人数/4WMA': 'interpolate',
    '道琼斯旅游与休闲/工业平均指数': 'interpolate',
    '美国EIA成品油总库存(预测/供应需求3年季节性)': 'interpolate',
    '美国成品车用汽油倒推产量（预测/汽油库存维持上年季节性）/8WMA': 'interpolate',
    '美国成品车用汽油炼厂与调和装置净产量/4WMA(预测/上年季节性)超季节性/5年': 'interpolate',
    '美国炼厂可用产能（路透）(预测)': 'interpolate',
    '美国炼厂CDU装置检修量（新）': 'interpolate',
    '美湾单位辛烷值价格(预测/季节性)': 'interpolate',
    '美国汽油调和组分RBOB库存(预测/线性外推)超季节性/3年': 'interpolate'
}

SHIFT_CONFIG = [
    ('美国2年通胀预期', 56, '美国2年通胀预期_提前56天'),
    ('美国首次申领失业金人数/4WMA', 100, '美国首次申领失业金人数/4WMA_提前100天'),
    ('美国首次申领失业金人数/4WMA', 112, '美国首次申领失业金人数/4WMA_提前112天'),
    ('道琼斯旅游与休闲/工业平均指数', 14, '道琼斯旅游与休闲/工业平均指数_提前14天'),
    ('美国EIA成品油总库存(预测/供应需求3年季节性)', 15,
     '美国EIA成品油总库存(预测/供应需求3年季节性)_提前15天'),
    ('美国成品车用汽油炼厂与调和装置净产量/4WMA(预测/上年季节性)超季节性/5年',
     30,
     '美国成品车用汽油炼厂与调和装置净产量/4WMA(预测/上年季节性)超季节性/5年_提前30天'),
    ('美国炼厂CDU装置检修量（新）', 30, '美国炼厂CDU装置检修量（新）_提前30天'),
    ('美国炼厂可用产能（路透）(预测)', 100,
     '美国炼厂可用产能（路透）(预测)_提前100天')
]

REVERSE_CONFIG = [
    ('美国首次申领失业金人数/4WMA',
     '美国首次申领失业金人数/4WMA_逆序'),
    ('美国首次申领失业金人数/4WMA_提前100天',
     '美国首次申领失业金人数/4WMA_提前100天_逆序'),
    ('美国首次申领失业金人数/4WMA_提前112天',
     '美国首次申领失业金人数/4WMA_提前112天_逆序'),
    ('美国EIA成品油总库存(预测/供应需求3年季节性)',
     '美国EIA成品油总库存(预测/供应需求3年季节性)_逆序'),
    ('美国EIA成品油总库存(预测/供应需求3年季节性)_提前15天',
     '美国EIA成品油总库存(预测/供应需求3年季节性)_提前15天_逆序'),
    ('美国炼厂可用产能（路透）(预测)_提前100天',
     '美国炼厂可用产能（路透）(预测)_逆序'),
    ('美国汽油调和组分RBOB库存(预测/线性外推)超季节性/3年',
     '美国汽油调和组分RBOB库存(预测/线性外推)超季节性/3年_逆序')
]

SPECIAL_REVERSE = {
    '美国汽油调和组分RBOB库存(预测/线性外推)超季节性/3年_逆序_2022-01-01': {
        'base_column': '美国汽油调和组分RBOB库存(预测/线性外推)超季节性/3年_逆序',
        'condition_date': pd.Timestamp('2022-01-01')
    }
}

METRICS_JSON = 'model_metrics.json'

# ------------ 数据加载与预处理 ------------
def load_and_preprocess_data():
    # 直接从API获取数据
    df = fetch_data_by_indicators(INDICATOR_IDS)
#    print("Initial DataFrame columns:", df.columns)
    df.index = pd.to_datetime(df.index)
    df_daily = df.copy()
    df_daily['Date'] = df_daily.index
    df_daily = df_daily.reset_index(drop=True)
    
    #预处理流程
    df_daily = fill_missing_values(df_daily, FILL_METHODS, return_only_filled=False)
    for col, days, new_col in SHIFT_CONFIG:
        df_daily[new_col] = df_daily[col].shift(days)

    last_idx = df_daily[TARGET_COL].last_valid_index()
    last_day = df_daily.loc[last_idx, 'Date']

    df_daily = df_daily[(df_daily['Date'] >= '2009-08-01') & (df_daily['Date'] <= last_day + pd.Timedelta(days=30))]
    df_daily = df_daily[df_daily['Date'].dt.weekday < 5]

    for base, new in REVERSE_CONFIG:
        df_daily[new] = reverse_column(df_daily, base)
    for col, cfg in SPECIAL_REVERSE.items():
        df_daily[col] = np.where(df_daily['Date'] >= cfg['condition_date'],
                                df_daily[cfg['base_column']],
                                np.nan)

    df_daily = df_daily[(df_daily['Date'] > last_day)|df_daily[TARGET_COL].notna()]

    return df_daily, last_day


# ------------ 划分与特征构建 ------------
def split_and_build_features(df_daily, last_day):
    train = df_daily[df_daily['Date'] <= last_day].copy()
    test = train.tail(TEST_PERIOD).copy()
    train = train.iloc[:-TEST_PERIOD].copy()
    future = df_daily[df_daily['Date'] > last_day].copy()

    feature_columns = [
        '美湾单位辛烷值价格(预测/季节性)',
        '美国炼厂CDU装置检修量（新）_提前30天',
        '美国EIA成品油总库存(预测/供应需求3年季节性)_提前15天_逆序',
        '美国首次申领失业金人数/4WMA_提前100天_逆序',
        '美国成品车用汽油倒推产量（预测/汽油库存维持上年季节性）/8WMA',
        '美国成品车用汽油炼厂与调和装置净产量/4WMA(预测/上年季节性)超季节性/5年_提前30天',
        '美国汽油调和组分RBOB库存(预测/线性外推)超季节性/3年_逆序_2022-01-01'
    ]

    X_train = train[feature_columns]
    y_train = train[TARGET_COL]
    X_test = test[feature_columns]
    y_test = test[TARGET_COL]
    X_future = future[feature_columns]

    return X_train, y_train, X_test, y_test, X_future, train, test, future


# ------------ 特征缩放与异常值权重 ------------
def scale_and_weight_features(X_train, X_test, X_future):
    scaler = StandardScaler()
    X_tr = scaler.fit_transform(X_train)
    X_te = scaler.transform(X_test)
    X_fu = scaler.transform(X_future)
    return scaler, X_tr, X_te, X_fu


def detect_outliers_weights(X,weight_normal=1.0,weight_outlier=0.05,threshold=3):
    z = np.abs((X - X.mean()) / X.std())
    mask = (z > threshold).any(axis=1)
    return np.where(mask, weight_outlier, weight_normal)


# ------------ 模型训练 ------------
def train_model_with_tuning(X_tr, y_tr, X_te, y_te, weights, use_tuning):
    if use_tuning:
        param_dist = {
            'learning_rate': list(np.arange(0.01, 0.11, 0.01)),
            'max_depth': list(range(4, 11)),
            'min_child_weight': list(range(1, 6)),
            'gamma': list(np.arange(0, 0.6, 0.1)),
            'subsample': list(np.arange(0.5, 1.01, 0.05)),
            'colsample_bytree': list(np.arange(0.5, 1.01, 0.05)),
            'reg_alpha': [0, 0.1, 0.2, 0.3, 0.4, 0.45, 0.5],
            'reg_lambda': list(np.arange(1.0, 1.6, 0.1))
        }
        
        # 将数据转换为DMatrix格式
        dtrain = xgb.DMatrix(X_tr, label=y_tr, weight=weights)
        dtest = xgb.DMatrix(X_te, label=y_te)
        
        # 基础参数设置
        base_params = {
            'objective': 'reg:squarederror',
            'eval_metric': 'rmse',
            'seed': RANDOM_STATE
        }
        
        best_score = float('inf')
        best_params = None
        
        # 网格搜索
        if SEARCH_MODE == 'grid':
            param_combinations = [dict(zip(param_dist.keys(), v)) 
                               for v in itertools.product(*param_dist.values())]
            for params in param_combinations:
                curr_params = {**base_params, **params}
                cv_results = xgb.cv(curr_params, dtrain, 
                                  num_boost_round=NUM_BOOST_ROUND,
                                  nfold=3,
                                  early_stopping_rounds=20,
                                  verbose_eval=False)
                score = cv_results['test-rmse-mean'].min()
                if score < best_score:
                    best_score = score
                    best_params = curr_params
        # 贝叶斯搜索
        elif SEARCH_MODE == 'bayesian':
            search_spaces = {
                'learning_rate': Real(0.01, 0.11, prior='uniform'),
                'max_depth': Integer(4, 11),
                'min_child_weight': Integer(1, 6),
                'gamma': Real(0.0, 0.6, prior='uniform'),
                'subsample': Real(0.5, 1.01, prior='uniform'),
                'colsample_bytree': Real(0.5, 1.01, prior='uniform'),
                'reg_alpha': Real(0.0, 0.5, prior='uniform'),
                'reg_lambda': Real(1.0, 1.6, prior='uniform')
            }
            
            def objective(params):
                curr_params = {**base_params, **params}
                cv_results = xgb.cv(curr_params, dtrain,
                                  num_boost_round=NUM_BOOST_ROUND,
                                  nfold=3,
                                  early_stopping_rounds=20,
                                  verbose_eval=False)
                return cv_results['test-rmse-mean'].min()
            
            # 执行贝叶斯优化
            from skopt import gp_minimize
            result = gp_minimize(
                objective,
                dimensions=[space for space in search_spaces.values()],
                n_calls=50,
                random_state=RANDOM_STATE
            )
            
            best_params = dict(zip(search_spaces.keys(), result.x))
            best_params = {**base_params, **best_params}
            best_score = result.fun

        # 随机搜索    
        else:
            for _ in range(50):  
                params = {k: random.choice(v) for k, v in param_dist.items()}
                curr_params = {**base_params, **params}
                cv_results = xgb.cv(curr_params, dtrain,
                                  num_boost_round=NUM_BOOST_ROUND,
                                  nfold=3,
                                  early_stopping_rounds=20,
                                  verbose_eval=False)
                score = cv_results['test-rmse-mean'].min()
                if score < best_score:
                    best_score = score
                    best_params = curr_params
        
        print("调优后的最佳参数:", best_params)
        print("最佳得分:", best_score)
        
        # 使用最佳参数训练最终模型
        best_model = xgb.train(best_params,
                              dtrain,
                              num_boost_round=NUM_BOOST_ROUND,
                              evals=[(dtrain, 'Train'), (dtest, 'Test')],
                              early_stopping_rounds=20,
                              verbose_eval=False)
    else:
        # 直接使用默认参数训练
        dtrain = xgb.DMatrix(X_tr, label=y_tr, weight=weights)
        dtest = xgb.DMatrix(X_te, label=y_te)
        best_model = xgb.train(DEFAULT_PARAMS,
                              dtrain,
                              num_boost_round=NUM_BOOST_ROUND,
                              evals=[(dtrain, 'Train'),
                                    (dtest, 'Test')],
                              verbose_eval=False)
    return best_model


# ------------ 评估与预测 ------------
def evaluate_and_predict(model, scaler, X_tr, y_tr, X_te, y_te, X_fu, use_tuning):
    X_tr_s = scaler.transform(X_tr)
    X_te_s = scaler.transform(X_te)
    X_fu_s = scaler.transform(X_fu)

    if isinstance(model, xgb.Booster):
        y_tr_pred = model.predict(xgb.DMatrix(X_tr_s))
        y_te_pred = model.predict(xgb.DMatrix(X_te_s))
        y_fu_pred = model.predict(xgb.DMatrix(X_fu_s))
    else:
        y_tr_pred = model.predict(X_tr_s)
        y_te_pred = model.predict(X_te_s)
        y_fu_pred = model.predict(X_fu_s)

    # 计算评估指标并保留4位有效数字
    train_mse = float(f"{mean_squared_error(y_tr, y_tr_pred):.4g}")
    test_mse = float(f"{mean_squared_error(y_te, y_te_pred):.4g}")
    train_r2 = float(f"{r2_score(y_tr, y_tr_pred):.4g}")
    test_r2 = float(f"{r2_score(y_te, y_te_pred):.4g}") if len(y_te) >= 2 else None

    print("Train MSE:", train_mse, "Test MSE:", test_mse)
    if len(y_te) >= 2:
        print("Train R2:", train_r2, "Test R2:", test_r2)
    else:
        print("Test 样本不足，跳过 R² 计算")

    metrics = {
        'train_mse': train_mse,
        'test_mse': test_mse,
        'train_r2': train_r2,
        'test_r2': test_r2
    }

    return y_tr_pred, y_te_pred, y_fu_pred, metrics


# ------------ 结果后处理（生成日度 & 月度 DataFrame） ------------
def merge_and_prepare_df(train, test, future, y_te_pred, y_fu_pred):
    # 合并历史与未来预测
    test = test.copy()
    future = future.copy()
    test['预测值'] = y_te_pred
    future['预测值'] = y_fu_pred

    hist_actual = pd.concat([
        train[train['Date'].dt.year >= 2023][['Date', TARGET_COL]],
        test[['Date', TARGET_COL]]
    ])
    hist_actual.columns = ['Date', '实际值']

    future_pred = future[future['Date'] >= '2022-08-01'][['Date', '预测值']].rename(columns={'预测值': TARGET_COL}).copy()

    last_val = hist_actual.iloc[-1]['实际值']
    future_pred[TARGET_COL] = future_pred[TARGET_COL].astype(last_val.dtype)
    future_pred.iloc[0, 1] = last_val

    # 日度重采样
    merged = pd.merge(hist_actual, future_pred,on='Date', how='outer').sort_values('Date', ascending=False)
    daily_df = merged.copy()

    # 月度重采样
    monthly_df = daily_df.copy()
    monthly_df['Date'] = pd.to_datetime(monthly_df['Date'])
    monthly_df.set_index('Date', inplace=True)
    monthly_df = monthly_df.resample('ME').mean().reset_index()

    # 方向准确率
    pred_dir = np.sign(monthly_df[TARGET_COL].diff())
    true_dir = np.sign(monthly_df['实际值'].diff())
    valid = monthly_df[TARGET_COL].notna() & monthly_df['实际值'].notna()
    monthly_df['方向准确率'] = np.where(valid & (pred_dir == true_dir), '正确',
                                   np.where(valid & (pred_dir != true_dir), '错误', ''))
    
    # 修改绝对偏差计算，转换为百分比
    monthly_df['绝对偏差'] = np.where(
        monthly_df[TARGET_COL].notna() & monthly_df['实际值'].notna(),
        abs((monthly_df[TARGET_COL] - monthly_df['实际值']) / monthly_df['实际值']),  
        np.nan)

    monthly_df = monthly_df.sort_values('Date', ascending=False).reset_index(drop=True)
    
    monthly_df['Date'] = monthly_df['Date'].dt.strftime('%Y-%m-%d')
    daily_df['Date'] = daily_df['Date'].dt.strftime('%Y-%m-%d')
    
    return daily_df, monthly_df



def generate_and_fill_excel(
    daily_df,
    monthly_df,
    metrics,           # 新增参数
    target_name,        # 写入的"预测标的"显示名
    classification,     # 列表页-分类
    model_framework,    # 列表页-模型框架
    creator,            # 列表页-创建人
#    pred_date,          # 列表页-预测日期
    frequency,          # 列表页-预测频度
    significant_digits=5,
    output_path='update.xlsx'
):
    with pd.ExcelWriter(output_path, engine='xlsxwriter') as writer:
        workbook = writer.book

        # 获取monthly_df的第一个日期作为预测日期
        actual_pred_date = pd.to_datetime(monthly_df['Date'].iloc[0]).strftime('%Y/%m/%d')
        
        # 格式化数值的辅助函数 - 用于测试值
        def format_test_value(x, sig_digits=significant_digits):
            if pd.isna(x):
                return ""
            return f"{float(x):.{sig_digits}g}"
            
        # 格式化百分比的辅助函数 - 用于方向准确率和偏差率(3位有效数)
        def format_percentage(x):
            if pd.isna(x):
                return ""
            return f"{float(x*100):.2f}%"
            
        # 格式化训练指标的辅助函数 - 用于训练结果页(6位有效数)
        def format_metrics(x):
            if pd.isna(x) or x == '':
                return ""
            return f"{float(x):.6g}"

        # —— 计算三个汇总值 —— 
        test_value = format_test_value(monthly_df[TARGET_COL].iloc[0])
        
        total = monthly_df['方向准确率'].notna().sum()
        correct = (monthly_df['方向准确率'] == '正确').sum()
        direction_accuracy = format_percentage(correct/total) if total > 0 else ""
        
        absolute_deviation = format_percentage(monthly_df['绝对偏差'].mean())

        # ========= 列表页 =========
        ws_list = workbook.add_worksheet('列表页')
        writer.sheets['列表页'] = ws_list

        headers = ['预测标的','分类','模型框架','创建人','预测日期','测试值','预测频度','方向准确率','绝对偏差']
        ws_list.write_row(0, 0, headers)
        ws_list.write_row(1, 0, [
            target_name,
            classification,
            model_framework,
            creator,
            actual_pred_date,
            test_value,
            frequency,
            direction_accuracy,
            absolute_deviation
        ])

        # ========= 详情页 =========
        detail_df = monthly_df[['Date', '实际值', TARGET_COL, '方向准确率', '绝对偏差']].copy()
        detail_df.columns = ['指标日期','实际值','预测值','方向','偏差率']
        
        # 格式化日期为年/月/日
        detail_df['指标日期'] = pd.to_datetime(detail_df['指标日期']).dt.strftime('%Y/%m/%d')
        
        # 格式化实际值和预测值列(使用传入的significant_digits)
        detail_df['实际值'] = detail_df['实际值'].apply(format_test_value)
        detail_df['预测值'] = detail_df['预测值'].apply(format_test_value)

        detail_df['偏差率'] = detail_df['偏差率'].apply(
            lambda x: f"{float(x*100):.3g}%" if pd.notnull(x) else "")

        detail_df.to_excel(writer,sheet_name='详情页',index=False,header=False,startrow=2)

        ws_detail = writer.sheets['详情页']
        ws_detail.write(0, 0, target_name)
        ws_detail.write_row(1, 0, ['指标日期','实际值','预测值','方向','偏差率'])

        # ========= 日度数据表 =========
        daily_out = daily_df[['Date', '实际值', TARGET_COL]].copy()
        daily_out.columns = ['指标日期','实际值','预测值']
        
        # 格式化日期为年/月/日
        daily_out['指标日期'] = pd.to_datetime(daily_out['指标日期']).dt.strftime('%Y/%m/%d')
        
        # 日度数据表不限制有效数字
        daily_out.to_excel(writer,sheet_name='日度数据表',index=False,header=False,startrow=2)

        ws_daily = writer.sheets['日度数据表']
        ws_daily.write(0, 0, target_name)
        ws_daily.write_row(1, 0, ['指标日期','实际值','预测值'])

        # ========= 训练结果页 =========
        ws_metrics = workbook.add_worksheet('训练结果页')
        writer.sheets['训练结果页'] = ws_metrics
        
        metrics_headers = ['指标名称', '指标值']
        ws_metrics.write_row(0, 0, metrics_headers)
        
        metrics_rows = [
            ['训练集 MSE', format_metrics(metrics['train_mse'])],
            ['测试集 MSE', format_metrics(metrics['test_mse'])],
            ['训练集 R²', format_metrics(metrics['train_r2'])],
            ['测试集 R²', format_metrics(metrics['test_r2']) if metrics['test_r2'] is not None else '']
        ]
        
        for i, row in enumerate(metrics_rows, start=1):
            ws_metrics.write_row(i, 0, row)

    print(f"已生成并填充 {output_path}")



# ------------ 全量训练与预测 ------------
def train_full_model_and_predict(X_train, y_train, X_test, y_test, X_future):
    X_all = pd.concat([X_train, X_test])
    y_all = pd.concat([y_train, y_test])
    scaler_all = StandardScaler().fit(X_all)
    X_all_s = scaler_all.transform(X_all)
    X_fu_s = scaler_all.transform(X_future)

    model = XGBRegressor(**DEFAULT_PARAMS, n_estimators=NUM_BOOST_ROUND)
    model.fit(X_all_s, y_all)
    y_fu_full = model.predict(X_fu_s)

    return model, y_fu_full, scaler_all


# ------------ 可视化 ------------
def plot_final_predictions(train, y_tr, y_tr_pred, test, y_te, y_te_pred,
                           future, last_day):
    plt.figure(figsize=(15, 6))
    plt.plot(train['Date'], y_tr, label='Train True')
    plt.plot(train['Date'], y_tr_pred, label='Train Pred')
    plt.plot(test['Date'], y_te, label='Test True', alpha=0.7)
    plt.plot(test['Date'], y_te_pred, label='Test Pred')
    plt.plot(future['Date'], future['预测值'], label='Future Pred')
    plt.axvline(test['Date'].iloc[0], color='gray', linestyle='--')
    plt.axvline(last_day, color='black', linestyle='--')
    plt.legend()
    plt.xlabel('Date')
    plt.ylabel(TARGET_COL)
    plt.title('Prediction Visualization')
    plt.grid(True)
    plt.show()


# ------------ 主函数 ------------
def main():
    # 解析命令行参数
    args = parse_arguments()
    
    # 更新全局变量
    global NUM_BOOST_ROUND, USE_HYPERPARAM_TUNING, OUTPUT_PATH, DEFAULT_PARAMS
    
    NUM_BOOST_ROUND = args.num_boost_round
    USE_HYPERPARAM_TUNING = args.use_hyperparam_tuning.lower() == 'true'
    
    # 根据前缀生成输出路径
    if args.output_prefix:
        OUTPUT_PATH = f"{args.output_prefix}_update.xlsx"
    
    # 更新XGBoost参数
    DEFAULT_PARAMS = {
        'objective': args.objective,
        'learning_rate': args.learning_rate,
        'max_depth': args.max_depth,
        'min_child_weight': args.min_child_weight,
        'gamma': args.gamma,
        'subsample': args.subsample,
        'colsample_bytree': args.colsample_bytree,
        'eval_metric': args.eval_metric,
        'seed': args.seed,
        'reg_alpha': args.reg_alpha,
        'reg_lambda': args.reg_lambda,
        'max_delta_step': args.max_delta_step,
        'booster': args.booster,
        'tree_method':args.tree_method
    }
    
#    print("使用参数:")
#    print(f"NUM_BOOST_ROUND: {NUM_BOOST_ROUND}")
#    print(f"USE_HYPERPARAM_TUNING: {USE_HYPERPARAM_TUNING}")
#    print(f"OUTPUT_PATH: {OUTPUT_PATH}")
#    print("DEFAULT_PARAMS:", DEFAULT_PARAMS)
    
    df_daily, last_day = load_and_preprocess_data()

    X_tr, y_tr, X_te, y_te, X_fu, train, test, future = split_and_build_features(df_daily, last_day)

    scaler, X_tr_s, X_te_s, X_fu_s = scale_and_weight_features(X_tr, X_te, X_fu)

    weights = detect_outliers_weights(X_tr_s)

    model = train_model_with_tuning(X_tr_s, y_tr, X_te_s, y_te, weights, USE_HYPERPARAM_TUNING)

    y_tr_pred, y_te_pred, y_fu_pred, metrics = evaluate_and_predict(model, scaler, X_tr, y_tr, X_te, y_te, X_fu, USE_HYPERPARAM_TUNING)

    daily_df, monthly_df = merge_and_prepare_df(train, test, future, y_te_pred, y_fu_pred)

#    print(monthly_df)
#    print(daily_df)

    generate_and_fill_excel(
        daily_df,
        monthly_df,
        metrics,           
        target_name=TARGET_NAME,        
        classification=CLASSIFICATION,     
        model_framework=MODEL_FRAMEWORK,    
        creator=CREATOR,            
    #    pred_date=PRED_DATE,    
        frequency=FREQUENCY,
        significant_digits= SIGNIFICANT_DIGITS,  # 设置6位有效数字
        output_path=OUTPUT_PATH     
    )
    
    full_model, y_fu_full, scaler_full = train_full_model_and_predict(X_tr, y_tr, X_te, y_te, X_fu)

    if ADJUST_FULL_PREDICTIONS:
        offset = y_te.iloc[-1] - y_fu_full[0]
        y_fu_full += offset

    if SHOW_PLOTS:
        plot_final_predictions(
            train, y_tr, y_tr_pred, test, y_te, y_te_pred,
            future.assign(预测值=y_fu_full), last_day)

    return daily_df, monthly_df

if __name__ == '__main__':
    daily_df, monthly_df = main()