XGBoost案例之红酒品质分类-模型评测

GridSearchCV(
    estimator,
    param_grid,
    cv=StratifiedKFold()  # 使用分层交叉验证
)

import pandas as pd
import numpy as np
import xgboost as xgb
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.metrics import accuracy_score, classification_report
from sklearn.utils.class_weight import compute_sample_weight
import joblib

# 1. 加载数据和模型
def load_data_and_model():
    """加载数据和模型"""
    print("=== 加载数据和模型 ===")
    
    # 加载数据
    train_data = pd.read_csv('data/wine_train.csv')
    test_data = pd.read_csv('data/wine_test.csv')
    
    X_train = train_data.iloc[:, :-1]
    y_train = train_data.iloc[:, -1]
    X_test = test_data.iloc[:, :-1]
    y_test = test_data.iloc[:, -1]
    
    # 加载模型
    model = joblib.load('model/xgboost_wine_model.pkl')
    
    print(f"训练集: {X_train.shape}")
    print(f"测试集: {X_test.shape}")
    
    return X_train, X_test, y_train, y_test, model

# 2. 传统交叉验证 vs 分层交叉验证
def compare_cv_methods(X, y):
    """对比传统CV和分层CV"""
    print("\n=== 对比CV方法 ===")
    
    from sklearn.model_selection import KFold, StratifiedKFold
    
    # 传统K折
    kf = KFold(n_splits=5, shuffle=True, random_state=42)
    print("\n传统K折（每折类别分布）:")
    for fold, (train_idx, val_idx) in enumerate(kf.split(X)):
        y_val = y.iloc[val_idx]
        print(f"  折{fold+1}: {dict(y_val.value_counts().sort_index())}")
    
    # 分层K折
    skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
    print("\n分层K折（每折类别分布）:")
    for fold, (train_idx, val_idx) in enumerate(skf.split(X, y)):
        y_val = y.iloc[val_idx]
        print(f"  折{fold+1}: {dict(y_val.value_counts().sort_index())}")

# 3. 网格搜索调参
def grid_search_with_stratified_cv(X_train, y_train, X_test, y_test):
    """使用分层交叉验证的网格搜索"""
    print("\n=== 网格搜索调参（分层CV）===")
    
    # 创建模型
    model = xgb.XGBClassifier(
        objective='multi:softprob',
        num_class=6,
        random_state=22
    )
    
    # 参数网格
    param_grid = {
        'n_estimators': [50, 100, 200],
        'max_depth': [3, 6, 9],
        'learning_rate': [0.01, 0.1, 0.2]
    }
    
    # 分层交叉验证
    stratified_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
    
    # 网格搜索
    grid_search = GridSearchCV(
        estimator=model,
        param_grid=param_grid,
        cv=stratified_cv,  # 使用分层CV
        scoring='accuracy',
        n_jobs=-1,
        verbose=1
    )
    
    # 平衡权重
    sample_weight = compute_sample_weight(class_weight='balanced', y=y_train)
    
    # 训练
    grid_search.fit(X_train, y_train, sample_weight=sample_weight)
    
    # 结果
    print(f"\n最优参数: {grid_search.best_params_}")
    print(f"最优得分: {grid_search.best_score_:.4f}")
    
    # 最优模型评估
    best_model = grid_search.best_estimator_
    y_pred = best_model.predict(X_test)
    acc = accuracy_score(y_test, y_pred)
    print(f"测试集准确率: {acc:.4f}")
    
    return best_model

# 4. 对比不同CV方法的效果
def compare_cv_effects(X_train, y_train, X_test, y_test):
    """对比不同CV方法的效果"""
    print("\n=== 对比不同CV方法的效果 ===")
    
    sample_weight = compute_sample_weight(class_weight='balanced', y=y_train)
    
    # 传统CV
    print("\n--- 传统CV ---")
    model1 = xgb.XGBClassifier(
        n_estimators=100,
        max_depth=6,
        learning_rate=0.1,
        random_state=22
    )
    model1.fit(X_train, y_train, sample_weight=sample_weight)
    y_pred1 = model1.predict(X_test)
    acc1 = accuracy_score(y_test, y_pred1)
    print(f"准确率: {acc1:.4f}")
    
    # 分层CV
    print("\n--- 分层CV ---")
    model2 = xgb.XGBClassifier(
        n_estimators=100,
        max_depth=6,
        learning_rate=0.1,
        random_state=22
    )
    
    stratified_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
    
    # 使用分层CV进行交叉验证评估
    from sklearn.model_selection import cross_val_score
    cv_scores = cross_val_score(
        model2, X_train, y_train,
        cv=stratified_cv,
        scoring='accuracy'
    )
    print(f"交叉验证得分: {cv_scores}")
    print(f"平均得分: {cv_scores.mean():.4f} ± {cv_scores.std():.4f}")
    
    # 训练最终模型
    model2.fit(X_train, y_train, sample_weight=sample_weight)
    y_pred2 = model2.predict(X_test)
    acc2 = accuracy_score(y_test, y_pred2)
    print(f"测试集准确率: {acc2:.4f}")

# 5. 详细评估
def detailed_evaluation(model, X_test, y_test):
    """详细评估"""
    print("\n=== 详细评估 ===")
    
    y_pred = model.predict(X_test)
    
    # 准确率
    acc = accuracy_score(y_test, y_pred)
    print(f"准确率: {acc:.4f}")
    
    # 分类报告
    print("\n分类报告:")
    print(classification_report(y_test, y_pred))
    
    # 混淆矩阵
    from sklearn.metrics import confusion_matrix
    cm = confusion_matrix(y_test, y_pred)
    print("混淆矩阵:")
    print(cm)

# 6. 主函数
def main():
    """主函数"""
    print("=" * 50)
    print("XGBoost - 红酒品质分类（模型评测）")
    print("=" * 50)
    
    # 1. 加载数据和模型
    X_train, X_test, y_train, y_test, model = load_data_and_model()
    
    # 2. 对比CV方法
    compare_cv_methods(X_train, y_train)
    
    # 3. 网格搜索调参
    best_model = grid_search_with_stratified_cv(X_train, y_train, X_test, y_test)
    
    # 4. 对比不同CV效果
    compare_cv_effects(X_train, y_train, X_test, y_test)
    
    # 5. 详细评估
    detailed_evaluation(best_model, X_test, y_test)
    
    # 6. 保存最优模型
    joblib.dump(best_model, 'model/xgboost_wine_best_model.pkl')
    print("\n最优模型已保存")

if __name__ == '__main__':
    main()

stratified_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
grid_search = GridSearchCV(estimator, param_grid, cv=stratified_cv)