七天学完十大机器学习经典算法-09.梯度提升算法：预测艺术的精进之道

for m in range(1, M+1):
    # 1. 计算残差（负梯度）
    r_{im} = - \left[ \frac{\partial L(y_i, F(x_i))}{\partial F(x_i)} \right]_{F(x)=F_{m-1}(x)}
    
    # 2. 用新模型拟合残差
    训练新模型 h_m(x) 使其拟合数据 {(x_i, r_{im})}_{i=1}^n
    
    # 3. 计算最优权重（步长）
    \gamma_m = \arg\min_\gamma \sum_{i=1}^n L(y_i, F_{m-1}(x_i) + \gamma h_m(x_i))
    
    # 4. 更新整体模型
    F_m(x) = F_{m-1}(x) + \nu \gamma_m h_m(x)

# Python中GBDT的树结构控制参数
from sklearn.ensemble import GradientBoostingRegressor

model = GradientBoostingRegressor(
    max_depth=3,           # 单棵树最大深度（通常3-8）
    min_samples_split=20,   # 分裂所需最小样本数
    min_samples_leaf=10,    # 叶节点最小样本数
    max_features='sqrt',    # 考虑的特征比例（防止过拟合）
    random_state=42
)

# 早停法实现示例
from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2)

model = GradientBoostingRegressor(n_estimators=1000, validation_fraction=0.2, 
                                  n_iter_no_change=50, tol=1e-4)

model.fit(X_train, y_train)  # 自动在验证集性能不再提升时停止

print(f"实际使用树数量: {model.n_estimators_}")

import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import roc_auc_score, classification_report
from sklearn.model_selection import train_test_split

# 加载数据
data = pd.read_csv('credit_data.csv')
X = data.drop('default', axis=1)
y = data['default']

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建GBDT模型
gb_model = GradientBoostingClassifier(
    n_estimators=200,
    learning_rate=0.05,
    max_depth=4,
    subsample=0.8,
    random_state=42
)

# 训练与评估
gb_model.fit(X_train, y_train)
y_pred_proba = gb_model.predict_proba(X_test)[:, 1]
y_pred = gb_model.predict(X_test)

print(f"AUC: {roc_auc_score(y_test, y_pred_proba):.4f}")
print(classification_report(y_test, y_pred))

# 特征重要性分析
feature_importance = pd.Series(gb_model.feature_importances_, index=X.columns)
feature_importance.sort_values(ascending=False).plot(kind='bar')
plt.title('特征重要性排序')
plt.show()

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_absolute_percentage_error

# 特征工程（时间特征）
def create_features(df):
    df = df.copy()
    df['dayofweek'] = df.index.dayofweek
    df['quarter'] = df.index.quarter
    df['month'] = df.index.month
    df['year'] = df.index.year
    df['dayofyear'] = df.index.dayofyear
    df['lag7'] = df['sales'].shift(7)  # 7天滞后特征
    return df

# 加载数据
sales_data = pd.read_csv('daily_sales.csv', parse_dates=['date'], index_col='date')
sales_data = create_features(sales_data)
sales_data.dropna(inplace=True)

# 划分训练集/测试集
train = sales_data.loc['2020-01-01':'2022-12-31']
test = sales_data.loc['2023-01-01':'2023-01-31']

X_train, y_train = train.drop('sales', axis=1), train['sales']
X_test, y_test = test.drop('sales', axis=1), test['sales']

# 训练GBDT模型
model = GradientBoostingRegressor(
    n_estimators=500,
    learning_rate=0.01,
    max_depth=5,
    min_samples_leaf=30,
    random_state=42
)
model.fit(X_train, y_train)

# 预测与评估
test['prediction'] = model.predict(X_test)
mape = mean_absolute_percentage_error(y_test, test['prediction'])
print(f"测试集MAPE: {mape:.2%}")

# 可视化结果
plt.figure(figsize=(12, 6))
plt.plot(train.index, train['sales'], label='历史销售')
plt.plot(test.index, test['sales'], label='实际销售', color='blue')
plt.plot(test.index, test['prediction'], label='预测销售', color='red', linestyle='--')
plt.title('销售额预测 vs 实际')
plt.legend()
plt.show()

import lightgbm as lgb  # 使用LightGBM实现
from sklearn.preprocessing import LabelEncoder

# 加载广告点击数据
clicks = pd.read_csv('ad_clicks.csv')

# 类别特征编码
cat_cols = ['device_type', 'os', 'ad_category', 'user_region']
for col in cat_cols:
    lbl = LabelEncoder()
    clicks[col] = lbl.fit_transform(clicks[col].astype(str))

# 准备数据集
X = clicks.drop(['click', 'timestamp'], axis=1)
y = clicks['click']

# 创建LightGBM数据集
train_data = lgb.Dataset(X, label=y, categorical_feature=cat_cols)

# 设置GBDT参数
params = {
    'objective': 'binary',
    'metric': 'auc',
    'learning_rate': 0.05,
    'num_leaves': 31,
    'max_depth': -1,  # 无限制（但受num_leaves约束）
    'min_child_samples': 100,
    'subsample': 0.8,
    'colsample_bytree': 0.7,
    'verbosity': -1
}

# 训练模型
model = lgb.train(
    params,
    train_data,
    num_boost_round=1000,
    valid_sets=[train_data],
    callbacks=[lgb.early_stopping(stopping_rounds=50)]
)

# 模型部署（实时预测）
def predict_ctr(user_features):
    """
    输入用户特征字典，返回CTR预测值
    """
    feature_df = pd.DataFrame([user_features])
    return model.predict(feature_df)[0]

# 示例预测
user_sample = {
    'device_type': 'mobile',
    'os': 'iOS',
    'ad_category': 'electronics',
    'user_region': 'NA',
    'hour_of_day': 14,
    'previous_clicks': 3
}
print(f"预测CTR: {predict_ctr(user_sample):.4f}")

# 三框架使用对比示例
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier

# 创建模型
xgb_model = XGBClassifier(n_estimators=200, learning_rate=0.1, max_depth=5)
lgbm_model = LGBMClassifier(n_estimators=200, learning_rate=0.1, max_depth=5)
cat_model = CatBoostClassifier(iterations=200, learning_rate=0.1, depth=5, verbose=0)

# 训练速度对比
%time xgb_model.fit(X_train, y_train)  # CPU times: 12.3 s
%time lgbm_model.fit(X_train, y_train) # CPU times: 3.8 s
%time cat_model.fit(X_train, y_train)  # CPU times: 8.7 s

# 精度对比
print(f"XGBoost AUC: {roc_auc_score(y_test, xgb_model.predict_proba(X_test)[:,1]):.4f}")
print(f"LightGBM AUC: {roc_auc_score(y_test, lgbm_model.predict_proba(X_test)[:,1]):.4f}")
print(f"CatBoost AUC: {roc_auc_score(y_test, cat_model.predict_proba(X_test)[:,1]):.4f}")