决策树分类器原理与scikit-learn实战：从基尼系数到客户流失预测

决策树scikit-learn分类算法

于 2026-07-07 15:33:45 修改

·本内容遵循CC 4.0 BY-SA版权协议

在机器学习项目中，分类任务是最常见的应用场景之一。当面对特征复杂、数据量大的分类问题时，决策树算法因其直观易懂、解释性强而备受青睐。本文将深入探讨scikit-learn中的DecisionTreeClassifier，从基础原理到实战应用，帮助读者快速掌握这一重要工具。

1. 决策树基础概念

1.1 什么是决策树？

决策树是一种非参数监督学习算法，可用于分类和回归任务。它具有分层的树形结构，由根节点、分支、内部节点和叶节点组成。决策树从根节点开始，该节点没有任何传入分支。来自根节点的传出分支馈送到内部节点（也称为决策节点），根据可用特征开展评估形成同质子集，最终用叶节点表示所有可能的结果。

决策树学习采用分而治之的策略，通过执行贪心搜索识别最佳分割点，并以自上而下的递归方式重复此过程，直到大多数记录被归类到特定类标签下。这种流程图结构能清晰表示决策过程，让不同技术背景的团队成员都能理解模型的工作原理。

1.2 决策树的核心组件

一个完整的决策树包含以下几个关键组件：

根节点：代表整个数据集的起始点，包含所有样本
内部节点：每个内部节点对应一个特征测试，根据测试结果将数据划分到不同子节点
分支：连接节点的路径，代表特征测试的可能结果
叶节点：最终的决策结果，包含分类标签或回归值

决策树的构建过程就是不断选择最优特征对数据进行划分，直到满足停止条件（如节点纯度达到阈值、达到最大深度等）。

1.3 决策树的类型与发展

决策树算法经过多年发展，形成了几个主要流派：

ID3算法：由Ross Quinlan提出，使用熵和信息增益作为分割标准，只能处理离散特征
C4.5算法：ID3的改进版本，可以处理连续特征和缺失值，使用信息增益比作为分割标准
CART算法：由Leo Breiman提出，使用基尼系数作为分割标准，能够同时处理分类和回归任务

scikit-learn中的DecisionTreeClassifier主要基于CART算法实现，这也是目前应用最广泛的决策树算法之一。

2. 环境准备与工具介绍

2.1 所需软件环境

在使用DecisionTreeClassifier之前，需要确保具备以下环境：

PYTHON

# 检查当前Python环境

import sys

print(f"Python版本: {sys.version}")

# 推荐使用Python 3.7及以上版本

# 安装必要的库

# pip install scikit-learn pandas numpy matplotlib seaborn

2.2 核心库导入

PYTHON

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

from sklearn import tree

import warnings

warnings.filterwarnings('ignore')

# 设置中文字体和图形样式

plt.rcParams['font.sans-serif'] = ['SimHei']

plt.rcParams['axes.unicode_minus'] = False

sns.set_style("whitegrid")

2.3 数据集准备

我们将使用经典的鸢尾花数据集作为示例，该数据集包含3种鸢尾花的4个特征测量值：

PYTHON

from sklearn.datasets import load_iris

# 加载数据集

iris = load_iris()

X = iris.data # 特征矩阵：150个样本 × 4个特征

y = iris.target # 目标变量：3个类别

# 查看数据集基本信息

print(f"特征形状: {X.shape}")

print(f"目标变量形状: {y.shape}")

print(f"特征名称: {iris.feature_names}")

print(f"类别名称: {iris.target_names}")

print(f"类别分布: {np.bincount(y)}")

3. DecisionTreeClassifier核心原理

3.1 分割标准：基尼系数与信息增益

DecisionTreeClassifier支持两种主要的分割标准：

基尼系数（Gini Impurity） 衡量从数据集中随机选取两个样本，其类别标签不一致的概率。基尼系数越小，节点纯度越高。

PYTHON

def gini_impurity(labels):

"""计算基尼系数"""

classes = np.unique(labels)

n = len(labels)

gini = 1.0

for c in classes:

p = np.sum(labels == c) / n

gini -= p**2

return gini

# 示例计算

labels_example = np.array([0, 0, 0, 1, 1, 1])

print(f"基尼系数: {gini_impurity(labels_example):.4f}")

信息增益（Information Gain） 基于信息熵的概念，衡量特征分割前后不确定性的减少程度。

PYTHON

def entropy(labels):

"""计算信息熵"""

classes, counts = np.unique(labels, return_counts=True)

probabilities = counts / len(labels)

entropy_value = -np.sum(probabilities * np.log2(probabilities))

return entropy_value

def information_gain(parent_labels, left_labels, right_labels):

"""计算信息增益"""

parent_entropy = entropy(parent_labels)

n = len(parent_labels)

n_left, n_right = len(left_labels), len(right_labels)

# 计算加权平均熵

weighted_entropy = (n_left/n)*entropy(left_labels) + (n_right/n)*entropy(right_labels)

return parent_entropy - weighted_entropy

# 示例计算

parent = np.array([0,0,0,0,1,1,1,1])

left = np.array([0,0,0,0])

right = np.array([1,1,1,1])

print(f"信息增益: {information_gain(parent, left, right):.4f}")

3.2 决策树的构建过程

决策树的构建是一个递归过程：

选择最佳分割特征：遍历所有特征，找到能最大程度降低不纯度的特征
创建分割规则：根据特征的最佳分割点划分数据
递归构建子树：对每个子节点重复上述过程
停止条件判断：当满足以下条件之一时停止递归：
- 节点样本数小于最小分裂样本数
- 节点纯度达到阈值
- 达到最大深度限制
- 无法找到有效的分割

4. DecisionTreeClassifier基本用法

4.1 基础参数配置

DecisionTreeClassifier提供了丰富的参数来控制树的生长过程：

PYTHON

# 创建基础决策树分类器

dt_classifier = DecisionTreeClassifier(

criterion='gini', # 分割标准：'gini'或'entropy'

max_depth=None, # 树的最大深度

min_samples_split=2, # 内部节点分裂所需最小样本数

min_samples_leaf=1, # 叶节点所需最小样本数

max_features=None, # 考虑的最大特征数

random_state=42 # 随机种子，确保结果可重现

)

print("决策树参数配置:")

for param, value in dt_classifier.get_params().items():

print(f"{param}: {value}")

4.2 模型训练与预测

PYTHON

# 划分训练集和测试集

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.3, random_state=42, stratify=y

)

print(f"训练集大小: {X_train.shape}")

print(f"测试集大小: {X_test.shape}")

# 训练决策树模型

dt_classifier.fit(X_train, y_train)

# 进行预测

y_pred = dt_classifier.predict(X_test)

y_pred_proba = dt_classifier.predict_proba(X_test)

print("预测结果示例:")

print(f"真实标签: {y_test[:10]}")

print(f"预测标签: {y_pred[:10]}")

print(f"预测概率:\n{y_pred_proba[:5]}")

4.3 模型评估

PYTHON

# 计算准确率

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

# 混淆矩阵

cm = confusion_matrix(y_test, y_pred)

plt.figure(figsize=(8, 6))

sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',

xticklabels=iris.target_names,

yticklabels=iris.target_names)

plt.title('决策树分类混淆矩阵')

plt.xlabel('预测标签')

plt.ylabel('真实标签')

plt.show()

5. 决策树可视化与解释

5.1 文本方式可视化

PYTHON

# 文本方式显示决策树

text_representation = tree.export_text(dt_classifier,

feature_names=iris.feature_names)

print("决策树结构:")

print(text_representation)

5.2 图形化可视化

PYTHON

# 图形化显示决策树

plt.figure(figsize=(20, 10))

tree.plot_tree(dt_classifier,

feature_names=iris.feature_names,

class_names=iris.target_names,

filled=True,

rounded=True,

fontsize=10)

plt.title('决策树可视化')

plt.show()

5.3 特征重要性分析

PYTHON

# 获取特征重要性

feature_importance = dt_classifier.feature_importances_

feature_names = iris.feature_names

# 创建特征重要性 DataFrame

importance_df = pd.DataFrame({

'feature': feature_names,

'importance': feature_importance

}).sort_values('importance', ascending=False)

print("特征重要性排序:")

print(importance_df)

# 可视化特征重要性

plt.figure(figsize=(10, 6))

sns.barplot(data=importance_df, x='importance', y='feature')

plt.title('决策树特征重要性')

plt.xlabel('重要性得分')

plt.tight_layout()

plt.show()

6. 参数调优与模型优化

6.1 防止过拟合的关键参数

决策树容易过拟合，需要通过参数调优来控制模型复杂度：

PYTHON

# 优化后的决策树参数

optimized_dt = DecisionTreeClassifier(

criterion='gini',

max_depth=3, # 限制树深度

min_samples_split=5, # 增加分裂所需最小样本数

min_samples_leaf=2, # 增加叶节点最小样本数

max_features='sqrt', # 限制每步考虑的特征数

random_state=42

)

# 训练优化模型

optimized_dt.fit(X_train, y_train)

y_pred_optimized = optimized_dt.predict(X_test)

# 比较性能

original_accuracy = accuracy_score(y_test, y_pred)

optimized_accuracy = accuracy_score(y_test, y_pred_optimized)

print(f"原始模型准确率: {original_accuracy:.4f}")

print(f"优化模型准确率: {optimized_accuracy:.4f}")

6.2 使用交叉验证调优

PYTHON

from sklearn.model_selection import GridSearchCV

# 定义参数网格

param_grid = {

'max_depth': [2, 3, 4, 5, None],

'min_samples_split': [2, 5, 10],

'min_samples_leaf': [1, 2, 4],

'criterion': ['gini', 'entropy']

}

# 网格搜索

grid_search = GridSearchCV(

DecisionTreeClassifier(random_state=42),

param_grid,

cv=5,

scoring='accuracy',

n_jobs=-1

)

grid_search.fit(X_train, y_train)

# 输出最佳参数

print("最佳参数组合:")

for param, value in grid_search.best_params_.items():

print(f"{param}: {value}")

print(f"最佳交叉验证分数: {grid_search.best_score_:.4f}")

# 使用最佳参数创建最终模型

best_dt = grid_search.best_estimator_

7. 实战案例：客户流失预测

7.1 数据集介绍与预处理

PYTHON

# 创建模拟客户流失数据集

np.random.seed(42)

n_samples = 1000

# 生成特征：通话时长、月费用、服务投诉次数、合约期限

call_duration = np.random.normal(300, 100, n_samples)

monthly_charge = np.random.normal(65, 15, n_samples)

complaints = np.random.poisson(0.5, n_samples)

contract_months = np.random.randint(1, 36, n_samples)

# 创建特征矩阵

X_customer = np.column_stack([call_duration, monthly_charge, complaints, contract_months])

# 基于规则生成目标变量（是否流失）

def generate_churn(call_dur, monthly_charge, complaints, contract):

"""模拟客户流失规则"""

risk_score = (monthly_charge > 80) * 0.3 + \

(complaints > 2) * 0.4 + \

(contract < 6) * 0.3 - \

(call_dur > 400) * 0.2

return (risk_score > 0.3).astype(int)

y_customer = generate_churn(call_duration, monthly_charge, complaints, contract_months)

print(f"客户流失数据集形状: {X_customer.shape}")

print(f"流失比例: {np.mean(y_customer):.2%}")

7.2 构建客户流失预测模型

PYTHON

# 划分数据集

X_train_c, X_test_c, y_train_c, y_test_c = train_test_split(

X_customer, y_customer, test_size=0.3, random_state=42, stratify=y_customer

)

# 创建决策树模型

churn_dt = DecisionTreeClassifier(

max_depth=4,

min_samples_split=20,

min_samples_leaf=10,

random_state=42

)

# 训练模型

churn_dt.fit(X_train_c, y_train_c)

# 预测与评估

y_pred_c = churn_dt.predict(X_test_c)

churn_accuracy = accuracy_score(y_test_c, y_pred_c)

print(f"客户流失预测准确率: {churn_accuracy:.4f}")

print("\n详细分类报告:")

print(classification_report(y_test_c, y_pred_c,

target_names=['未流失', '流失']))

7.3 业务解释与决策规则提取

PYTHON

# 可视化决策树

plt.figure(figsize=(15, 8))

tree.plot_tree(churn_dt,

feature_names=['通话时长', '月费用', '投诉次数', '合约期限'],

class_names=['未流失', '流失'],

filled=True,

rounded=True,

fontsize=10)

plt.title('客户流失预测决策树')

plt.show()

# 提取重要决策规则

feature_names = ['通话时长', '月费用', '投诉次数', '合约期限']

importance = churn_dt.feature_importances_

print("客户流失关键因素:")

for name, imp in zip(feature_names, importance):

print(f"{name}: {imp:.3f}")

8. 常见问题与解决方案

8.1 过拟合问题

问题现象：训练集准确率很高，但测试集准确率明显下降

解决方案：

PYTHON

# 1. 增加正则化参数

dt_regularized = DecisionTreeClassifier(

max_depth=5, # 限制树深度

min_samples_split=10, # 增加分裂最小样本数

min_samples_leaf=5, # 增加叶节点最小样本数

max_leaf_nodes=20, # 限制最大叶节点数

random_state=42

)

# 2. 使用剪枝技术

dt_pruned = DecisionTreeClassifier(

ccp_alpha=0.01, # 成本复杂度剪枝参数

random_state=42

)

8.2 类别不平衡问题

问题现象：少数类别样本预测效果差

解决方案：

PYTHON

# 使用类别权重

dt_balanced = DecisionTreeClassifier(

class_weight='balanced', # 自动调整类别权重

random_state=42

)

# 或者手动指定权重

class_weights = {0: 1, 1: 3} # 少数类别权重更高

dt_manual_weight = DecisionTreeClassifier(

class_weight=class_weights,

random_state=42

)

8.3 处理缺失值

PYTHON

# 决策树天然支持缺失值处理，但scikit-learn的实现需要预处理

from sklearn.impute import SimpleImputer

# 创建包含缺失值的数据示例

X_with_missing = X.copy()

X_with_missing[5:10, 0] = np.nan # 模拟缺失值

# 使用中位数填充缺失值

imputer = SimpleImputer(strategy='median')

X_imputed = imputer.fit_transform(X_with_missing)

# 然后训练决策树

dt_missing = DecisionTreeClassifier(random_state=42)

dt_missing.fit(X_imputed, y)

9. 决策树的最佳实践

9.1 数据预处理建议

PYTHON

def preprocess_for_decision_tree(X, y):

"""决策树数据预处理流程"""

# 1. 处理缺失值

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy='median')

X_processed = imputer.fit_transform(X)

# 2. 特征缩放（决策树不需要，但便于可视化）

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X_processed)

# 3. 处理类别特征（如果需要）

# 使用OneHotEncoder或OrdinalEncoder

return X_scaled, y

# 应用预处理

X_preprocessed, y_preprocessed = preprocess_for_decision_tree(X, y)

9.2 模型选择与比较

PYTHON

from sklearn.ensemble import RandomForestClassifier

from sklearn.linear_model import LogisticRegression

from sklearn.svm import SVC

# 比较不同算法

models = {

'决策树': DecisionTreeClassifier(max_depth=5, random_state=42),

'随机森林': RandomForestClassifier(n_estimators=100, random_state=42),

'逻辑回归': LogisticRegression(random_state=42),

'SVM': SVC(random_state=42)

}

# 评估每个模型

results = {}

for name, model in models.items():

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

results[name] = accuracy

print(f"{name}准确率: {accuracy:.4f}")

# 可视化比较结果

plt.figure(figsize=(10, 6))

plt.bar(results.keys(), results.values())

plt.title('不同分类算法性能比较')

plt.ylabel('准确率')

plt.ylim(0.8, 1.0)

plt.show()

9.3 生产环境部署考虑

PYTHON

import joblib

import json

class ProductionDecisionTree:

"""生产环境决策树封装类"""

def __init__(self, model_path=None):

self.model = None

self.feature_names = None

if model_path:

self.load_model(model_path)

def train(self, X, y, feature_names):

"""训练并保存模型"""

self.feature_names = feature_names

self.model = DecisionTreeClassifier(

max_depth=5,

min_samples_split=10,

random_state=42

)

self.model.fit(X, y)

def predict(self, X):

"""预测方法"""

if self.model is None:

raise ValueError("模型未训练或加载")

return self.model.predict(X)

def predict_proba(self, X):

"""预测概率"""

if self.model is None:

raise ValueError("模型未训练或加载")

return self.model.predict_proba(X)

def save_model(self, path):

"""保存模型和元数据"""

joblib.dump(self.model, f"{path}_model.pkl")

metadata = {

'feature_names': self.feature_names,

'n_features': len(self.feature_names)

}

with open(f"{path}_metadata.json", 'w') as f:

json.dump(metadata, f)

def load_model(self, path):

"""加载模型和元数据"""

self.model = joblib.load(f"{path}_model.pkl")

with open(f"{path}_metadata.json", 'r') as f:

metadata = json.load(f)

self.feature_names = metadata['feature_names']

# 使用示例

production_dt = ProductionDecisionTree()

production_dt.train(X_train, y_train, iris.feature_names)

production_dt.save_model('iris_decision_tree')

决策树分类器作为机器学习的基础算法，虽然结构简单但功能强大。通过本文的详细讲解和实战示例，读者应该能够掌握DecisionTreeClassifier的核心用法、参数调优技巧以及实际应用中的注意事项。在实际项目中，建议先从简单的决策树开始，逐步尝试更复杂的集成方法如随机森林和梯度提升树，以获得更好的性能。