【机器学习】从理论到实践：决策树算法在机器学习中的应用与实现

函数 BuildTree(data, features):
    如果 data 中所有实例属于同一类别:
        返回该类别
    如果 features 为空或 data 为空:
        返回 data 中出现次数最多的类别
    选择使信息增益最大的特征 A
    创建节点 node，并将其标记为特征 A
    对于特征 A 的每个可能取值 v:
        子数据集 sub_data = 由 data 中特征 A 的值为 v 的实例构成
        如果 sub_data 为空:
            在 node 上创建叶节点，标记为 data 中出现次数最多的类别
        否则:
            在 node 上创建子节点，并将子节点连接到 BuildTree(sub_data, features \ {A})
    返回 node

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris

# 加载Iris数据集
data = load_iris()
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(df.drop(columns=['target']), df['target'], test_size=0.3, random_state=42)

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 初始化决策树分类器
clf = DecisionTreeClassifier(criterion='entropy', max_depth=3, random_state=42)

# 训练模型
clf.fit(X_train, y_train)

# 预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f'决策树模型的准确率: {accuracy:.2f}')

from sklearn.tree import export_graphviz
import graphviz

# 导出决策树
dot_data = export_graphviz(clf, out_file=None, 
                           feature_names=data.feature_names,  
                           class_names=data.target_names,  
                           filled=True, rounded=True,  
                           special_characters=True)  

# 使用graphviz渲染决策树
graph = graphviz.Source(dot_data)  
graph.render("decision_tree")  # 生成决策树的PDF文件

import matplotlib.pyplot as plt
import numpy as np

feature_importances = clf.feature_importances_
features = data.feature_names

indices = np.argsort(feature_importances)

plt.figure(figsize=(10, 6))
plt.title("Feature Importances")
plt.barh(range(len(indices)), feature_importances[indices], align="center")
plt.yticks(range(len(indices)), [features[i] for i in indices])
plt.xlabel("Relative Importance")
plt.show()

sample_id = 0  # 样本索引
node_indicator = clf.decision_path(X_test)
leaf_id = clf.apply(X_test)

sample_path = node_indicator.indices[node_indicator.indptr[sample_id]:node_indicator.indptr[sample_id + 1]]
print(f'样本 {sample_id} 的决策路径：')
for node_id in sample_path:
    if leaf_id[sample_id] == node_id:
        print(f'--> 叶节点 {node_id}')
    else:
        print(f'--> 节点 {node_id}, 判断特征：{features[clf.tree_.feature[node_id]]}, 阈值：{clf.tree_.threshold[node_id]:.2f}')

from sklearn.datasets import load_wine
from sklearn.metrics import classification_report

# 加载葡萄酒数据集
wine_data = load_wine()
X_wine = wine_data.data
y_wine = wine_data.target

# 划分训练集和测试集
X_train_wine, X_test_wine, y_train_wine, y_test_wine = train_test_split(X_wine, y_wine, test_size=0.3, random_state=42)

# 训练决策树分类器
wine_clf = DecisionTreeClassifier(criterion='gini', max_depth=5, random_state=42)
wine_clf.fit(X_train_wine, y_train_wine)

# 预测
y_pred_wine = wine_clf.predict(X_test_wine)

# 评估模型
print(classification_report(y_test_wine, y_pred_wine, target_names=wine_data.target_names))

from sklearn.datasets import load_boston
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error

# 加载波士顿房价数据集
boston = load_boston()
X_boston = boston.data
y_boston = boston.target

# 划分训练集和测试集
X_train_boston, X_test_boston, y_train_boston, y_test_boston = train_test_split(X_boston, y_boston, test_size=0.3, random_state=42)

# 初始化决策树回归器
regressor = DecisionTreeRegressor(criterion='mse', max_depth=5, random_state=42)

# 训练模型
regressor.fit(X_train_boston, y_train_boston)

# 预测
y_pred_boston = regressor.predict(X_test_boston)

# 计算均方误差
mse = mean_squared_error(y_test_boston, y_pred_boston)
print(f'决策树回归模型的均方误差: {mse:.2f}')

# 计算特征重要性
feature_importances = regressor.feature_importances_
features = boston.feature_names

# 打印特征重要性
for name, importance in zip(features, feature_importances):
    print(f'Feature: {name}, Importance: {importance:.2f}')

from sklearn.ensemble import IsolationForest

# 初始化隔离森林模型
iso_forest = IsolationForest(n_estimators=100, contamination=0.1, random_state=42)

# 训练模型
iso_forest.fit(X_train_boston)

# 预测异常
anomalies = iso_forest.predict(X_test_boston)
print(f'异常样本数量: {sum(anomalies == -1)}')

from sklearn.ensemble import RandomForestRegressor

# 初始化随机森林回归器
rf_regressor = RandomForestRegressor(n_estimators=100, max_depth=5, random_state=42)

# 训练模型
rf_regressor.fit(X_train_boston, y_train_boston)

# 预测
rf_y_pred = rf_regressor.predict(X_test_boston)

# 计算均方误差
rf_mse = mean_squared_error(y_test_boston, rf_y_pred)
print(f'随机森林回归模型的均方误差: {rf_mse:.2f}')

from sklearn.ensemble import GradientBoostingRegressor

# 初始化梯度提升回归器
gb_regressor = GradientBoostingRegressor(n_estimators=100, max_depth=3, random_state=42)

# 训练模型
gb_regressor.fit(X_train_boston, y_train_boston)

# 预测
gb_y_pred = gb_regressor.predict(X_test_boston)

# 计算均方误差
gb_mse = mean_squared_error(y_test_boston, gb_y_pred)
print(f'梯度提升回归模型的均方误差: {gb_mse:.2f}')