Python案例如何用Scikit-learn做分类决策树

wen python案例 2026-07-16 211

本文目录导读：

基础案例：鸢尾花分类
完整案例：信用卡欺诈检测
决策树可视化
特征重要性分析
超参数调优
完整的数据处理流程
实际应用：客户流失预测
使用建议

我来详细讲解如何使用Scikit-learn构建分类决策树，包含完整的案例和代码示例。

基础案例：鸢尾花分类

# 导入必要的库
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report
import numpy as np
# 1. 加载数据
iris = load_iris()
X = iris.data
y = iris.target
# 2. 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)
# 3. 创建决策树分类器
dt_classifier = DecisionTreeClassifier(
    max_depth=3,  # 限制树的深度，防止过拟合
    random_state=42
)
# 4. 训练模型
dt_classifier.fit(X_train, y_train)
# 5. 预测
y_pred = dt_classifier.predict(X_test)
# 6. 评估模型
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

完整案例：信用卡欺诈检测

# 导入所需库
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score
import matplotlib.pyplot as plt
from sklearn import tree
# 创建示例数据
np.random.seed(42)
n_samples = 1000
# 生成特征
data = {
    'amount': np.random.exponential(100, n_samples),
    'time': np.random.uniform(0, 24, n_samples),
    'merchant_id': np.random.randint(1, 100, n_samples),
    'transaction_type': np.random.randint(0, 3, n_samples),
    'location': np.random.randint(0, 5, n_samples)
}
# 生成标签（欺诈/非欺诈）
# 假设欺诈交易具有某些特征
prob_fraud = 0.02 + 0.05 * (data['amount'] > 200) + \
             0.03 * (data['time'] < 6) + \
             0.02 * (data['transaction_type'] == 2)
fraud = np.random.binomial(1, prob_fraud / prob_fraud.max())
data['is_fraud'] = fraud
df = pd.DataFrame(data)
print("数据集信息:")
print(df.head())
print(f"\n欺诈交易比例: {df['is_fraud'].mean():.2%}")
# 准备特征和目标变量
features = ['amount', 'time', 'merchant_id', 'transaction_type', 'location']
X = df[features]
y = df['is_fraud']
# 数据标准化
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.3, random_state=42, stratify=y
)
# 创建决策树模型（优化参数）
dt_model = DecisionTreeClassifier(
    max_depth=5,
    min_samples_split=20,
    min_samples_leaf=10,
    max_features='sqrt',
    random_state=42
)
# 训练模型
dt_model.fit(X_train, y_train)
# 预测
y_pred = dt_model.predict(X_test)
y_pred_proba = dt_model.predict_proba(X_test)[:, 1]
# 评估模型
print("\n模型评估结果:")
print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
print(f"AUC-ROC: {roc_auc_score(y_test, y_pred_proba):.4f}")
print("\n混淆矩阵:")
print(confusion_matrix(y_test, y_pred))
print("\n分类报告:")
print(classification_report(y_test, y_pred))

决策树可视化

# 可视化决策树
def visualize_decision_tree(model, feature_names, class_names, filename='tree.png'):
    """
    可视化决策树
    """
    plt.figure(figsize=(20, 10))
    # 绘制决策树
    tree.plot_tree(
        model,
        feature_names=feature_names,
        class_names=class_names,
        filled=True,
        rounded=True,
        fontsize=10
    )
    plt.title('决策树可视化', fontsize=16)
    plt.savefig(filename, dpi=100, bbox_inches='tight')
    plt.show()
# 可视化鸢尾花案例的决策树
visualize_decision_tree(
    dt_classifier,
    iris.feature_names,
    iris.target_names,
    'iris_decision_tree.png'
)

特征重要性分析

# 特征重要性分析
def analyze_feature_importance(model, feature_names):
    """
    分析特征重要性并可视化
    """
    importances = model.feature_importances_
    indices = np.argsort(importances)[::-1]
    # 打印特征重要性
    print("特征重要性排序:")
    for i in range(len(feature_names)):
        print(f"{i+1}. {feature_names[indices[i]]}: {importances[indices[i]]:.4f}")
    # 可视化
    plt.figure(figsize=(10, 6))
    plt.title("特征重要性")
    plt.bar(range(len(importances)), importances[indices])
    plt.xticks(range(len(importances)), [feature_names[i] for i in indices], rotation=45)
    plt.tight_layout()
    plt.show()
# 分析信用卡欺诈案例的特征重要性
analyze_feature_importance(dt_model, features)

超参数调优

from sklearn.model_selection import GridSearchCV
# 超参数网格搜索
def optimize_decision_tree(X_train, y_train):
    """
    使用网格搜索优化决策树参数
    """
    # 定义参数网格
    param_grid = {
        'max_depth': [3, 5, 7, 10, None],
        'min_samples_split': [2, 5, 10, 20],
        'min_samples_leaf': [1, 2, 5, 10],
        'max_features': [None, 'sqrt', 'log2'],
        'criterion': ['gini', 'entropy']
    }
    # 创建基础模型
    dt = DecisionTreeClassifier(random_state=42)
    # 网格搜索
    grid_search = GridSearchCV(
        dt,
        param_grid,
        cv=5,
        scoring='accuracy',
        n_jobs=-1,
        verbose=1
    )
    # 执行搜索
    grid_search.fit(X_train, y_train)
    print("最优参数:")
    print(grid_search.best_params_)
    print(f"\n最优交叉验证得分: {grid_search.best_score_:.4f}")
    return grid_search.best_estimator_
# 优化决策树参数
best_dt = optimize_decision_tree(X_train, y_train)
# 评估优化后的模型
y_pred_best = best_dt.predict(X_test)
print(f"\n优化后的模型准确率: {accuracy_score(y_test, y_pred_best):.4f}")

完整的数据处理流程

# 完整的数据处理和分析流程
class DecisionTreePipeline:
    def __init__(self):
        self.model = None
        self.scaler = StandardScaler()
    def preprocess_data(self, X):
        """
        数据预处理
        """
        # 处理缺失值
        X = pd.DataFrame(X).fillna(X.mean())
        # 标准化
        X_scaled = self.scaler.fit_transform(X)
        return X_scaled
    def train(self, X_train, y_train, **params):
        """
        训练决策树模型
        """
        X_processed = self.preprocess_data(X_train)
        # 默认参数
        default_params = {
            'max_depth': 5,
            'min_samples_split': 10,
            'min_samples_leaf': 5,
            'random_state': 42
        }
        # 合并参数
        model_params = {**default_params, **params}
        self.model = DecisionTreeClassifier(**model_params)
        self.model.fit(X_processed, y_train)
        return self.model
    def predict(self, X_test):
        """
        预测
        """
        X_processed = self.scaler.transform(X_test)
        return self.model.predict(X_processed)
    def predict_proba(self, X_test):
        """
        预测概率
        """
        X_processed = self.scaler.transform(X_test)
        return self.model.predict_proba(X_processed)
    def evaluate(self, X_test, y_test):
        """
        评估模型
        """
        y_pred = self.predict(X_test)
        return {
            'accuracy': accuracy_score(y_test, y_pred),
            'classification_report': classification_report(y_test, y_pred),
            'confusion_matrix': confusion_matrix(y_test, y_pred)
        }
# 使用Pipeline
pipeline = DecisionTreePipeline()
# 训练模型
pipeline.train(X_train, y_train, max_depth=7)
# 评估模型
results = pipeline.evaluate(X_test, y_test)
print("Pipeline评估结果:")
print(f"准确率: {results['accuracy']:.4f}")

实际应用：客户流失预测

# 客户流失预测案例
def customer_churn_prediction():
    """
    客户流失预测案例
    """
    # 创建模拟客户数据
    np.random.seed(42)
    n_customers = 2000
    # 客户特征
    customer_data = {
        'tenure_months': np.random.randint(1, 72, n_customers),
        'monthly_charges': np.random.uniform(20, 120, n_customers),
        'total_charges': np.random.uniform(100, 8000, n_customers),
        'contract_type': np.random.randint(0, 3, n_customers),  # 0:月付, 1:年付, 2:两年付
        'payment_method': np.random.randint(0, 4, n_customers),
        'num_services': np.random.randint(1, 8, n_customers),
        'avg_monthly_usage': np.random.uniform(0, 1000, n_customers)
    }
    # 生成流失标签（基于某些特征）
    churn_prob = 0.1 + \
                 0.2 * (customer_data['contract_type'] == 0) + \
                 0.1 * (customer_data['tenure_months'] < 12) + \
                 0.15 * (customer_data['avg_monthly_usage'] < 100)
    customer_data['churn'] = np.random.binomial(1, churn_prob / churn_prob.max())
    df_customers = pd.DataFrame(customer_data)
    # 准备数据
    feature_cols = ['tenure_months', 'monthly_charges', 'total_charges', 
                    'contract_type', 'payment_method', 'num_services', 
                    'avg_monthly_usage']
    X = df_customers[feature_cols]
    y = df_customers['churn']
    # 划分数据集
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42, stratify=y
    )
    # 训练决策树模型
    churn_model = DecisionTreeClassifier(
        max_depth=4,
        min_samples_split=50,
        min_samples_leaf=20,
        class_weight='balanced',  # 处理类别不平衡
        random_state=42
    )
    churn_model.fit(X_train, y_train)
    # 预测
    y_pred = churn_model.predict(X_test)
    y_proba = churn_model.predict_proba(X_test)[:, 1]
    # 评估
    print("客户流失预测模型评估:")
    print(f"准确率: {accuracy_score(y_test, y_pred):.4f}")
    print(f"AUC-ROC: {roc_auc_score(y_test, y_proba):.4f}")
    # 特征重要性
    print("\n影响客户流失的最重要因素:")
    importances = churn_model.feature_importances_
    for i, importance in enumerate(sorted(importances, reverse=True)):
        feature_idx = np.where(importances == importance)[0][0]
        print(f"{feature_cols[feature_idx]}: {importance:.4f}")
    return churn_model, X_train, y_train
# 运行客户流失预测
churn_model, X_train, y_train = customer_churn_prediction()