机器学习_7决策树
决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。
决策树建立的关键是分类依据的属性的选择，根据不同目标函数，建立决策树主要有三种算法： ID3、C4.5、CART
1.决策树原理
2.属性选择的度量
决策树建立的关键是分类依据的属性的选择，根据不同目标函数，建立决策树主要有三种算法：ID3、C4.5、CART
三种算法适用对比：
**样本量上：**小样本建议C4.5，需对数据集进行多次扫描排序，处理成本耗时较高；大样本建议CART，小样本下泛化误差大。
1.ID3算法
ID3算法核心是信息熵，期望的信息越小，信息熵越大，样本纯度越低。
以信息增益作为衡量标准，从而对数据进行归纳分类。计算每个属性的信息增益，选取具有最高增益的属性作为给定的测试属性，即放在决策树的顶部。
信息熵、条件熵、信息增益
这里，类别K=2，“是”和“否”。
2.C4.5算法
C4.5用信息增益率选择属性，在决策树构造过程中有剪枝操作，对非离散数据、不完整数据也能处理。是对ID3算法的改进。
信息增益率
剪枝
通过剪枝处理去掉一些分支来降低过拟合的风险。剪枝的基本策略有“预剪枝”和“后剪枝”。
预剪枝：
后剪枝：
更常用，是在已经生成的决策树上进行剪枝，从而得到简化版的剪枝决策树。
剪枝完成后的决策树：
后剪枝优缺点：
后剪枝决策树通常比预剪枝决策树保留了更多分支。后剪枝欠拟合风险更小，泛化能力优于预剪枝决策树。
3.CART算法
CART算法用的二叉树。
分类：基尼指数选择属性；回归：均方差选择属性。
基尼指数——分类
连续特征处理：
离散特征处理：
基尼指数：
均方差——回归
CART剪枝
信息增益 最大、信息增益比 最大 、基尼指数 最小 ——特征选择的准则。
3.代码实现
计算信息增益并判断最大值对应的特征
import numpy as np
import pandas as pd
import math
from math import log
# 创建数据
def create_data():
datasets = [['青年', '否', '否', '一般', '否'],
['青年', '否', '否', '好', '否'],
['青年', '是', '否', '好', '是'],
['青年', '是', '是', '一般', '是'],
['青年', '否', '否', '一般', '否'],
['中年', '否', '否', '一般', '否'],
['中年', '否', '否', '好', '否'],
['中年', '是', '是', '好', '是'],
['中年', '否', '是', '非常好', '是'],
['中年', '否', '是', '非常好', '是'],
['老年', '否', '是', '非常好', '是'],
['老年', '否', '是', '好', '是'],
['老年', '是', '否', '好', '是'],
['老年', '是', '否', '非常好', '是'],
['老年', '否', '否', '一般', '否'],
]
labels = ['年龄', '有工作', '有自己的房子', '信贷情况', '类别']
# 返回数据集和每个维度的名称
return datasets, labels
datasets, labels = create_data()
train_data = pd.DataFrame(datasets, columns=labels)
print(train_data)
# 年龄 有工作 有自己的房子 信贷情况 类别
# 0 青年 否 否 一般 否
# 1 青年 否 否 好 否
# 2 青年 是 否 好 是
# 3 青年 是 是 一般 是
# 4 青年 否 否 一般 否
# 5 中年 否 否 一般 否
# 6 中年 否 否 好 否
# 7 中年 是 是 好 是
# 8 中年 否 是 非常好 是
# 9 中年 否 是 非常好 是
# 10 老年 否 是 非常好 是
# 11 老年 否 是 好 是
# 12 老年 是 否 好 是
# 13 老年 是 否 非常好 是
# 14 老年 否 否 一般 否
# 熵
def calc_ent(datasets):
data_length = len(datasets)
label_count = {}
for i in range(data_length):
label = datasets[i][-1]
if label not in label_count:
label_count[label] = 0
label_count[label] += 1
ent = -sum([(p / data_length) * log(p / data_length, 2) for p in label_count.values()])
return ent
# 条件熵
def cond_ent(datasets, axis=0):
data_length = len(datasets)
feature_sets = {}
for i in range(data_length):
feature = datasets[i][axis]
if feature not in feature_sets:
feature_sets[feature] = []
feature_sets[feature].append(datasets[i])
cond_ent = sum([(len(p) / data_length) * calc_ent(p) for p in feature_sets.values()])
return cond_ent
print(calc_ent(datasets))
# 0.9709505944546686
# 信息增益
def info_gain(ent, cond_ent):
return ent - cond_ent
def info_gain_train(datasets):
count = len(datasets[0]) - 1
ent = calc_ent(datasets)
best_feature = []
for c in range(count):
c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))
best_feature.append((c, c_info_gain))
print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))
# 比较大小
best_ = max(best_feature, key=lambda x: x[-1])
return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])
print(info_gain_train(np.array(datasets)))
# 特征(年龄) 的信息增益为： 0.083
# 特征(有工作) 的信息增益为： 0.324
# 特征(有自己的房子) 的信息增益为： 0.420
# 特征(信贷情况) 的信息增益为： 0.363
# 特征(有自己的房子)的信息增益最大，选择为根节点特征
ID3算法生成决策树
# 定义节点类 二叉树
class Node:
def __init__(self, root=True, label=None, feature_name=None, feature=None):
self.root = root
self.label = label
self.feature_name = feature_name
self.feature = feature
self.tree = {}
self.result = {'label:': self.label,'feature': self.feature,'tree': self.tree}
def __repr__(self):
return '{}'.format(self.result)
def add_node(self, val, node):
self.tree[val] = node
def predict(self, features):
if self.root is True:
return self.label
return self.tree[features[self.feature]].predict(features)
class DTree:
def __init__(self, epsilon=0.1):
self.epsilon = epsilon
self._tree = {}
# 熵
@staticmethod
def calc_ent(datasets):
data_length = len(datasets)
label_count = {}
for i in range(data_length):
label = datasets[i][-1]
if label not in label_count:
label_count[label] = 0
label_count[label] += 1
ent = -sum([(p / data_length) * log(p / data_length, 2) for p in label_count.values()])
return ent
# 经验条件熵
def cond_ent(self, datasets, axis=0):
data_length = len(datasets)
feature_sets = {}
for i in range(data_length):
feature = datasets[i][axis]
if feature not in feature_sets:
feature_sets[feature] = []
feature_sets[feature].append(datasets[i])
cond_ent = sum([(len(p) / data_length) * self.calc_ent(p) for p in feature_sets.values()])
return cond_ent
# 信息增益
@staticmethod
def info_gain(ent, cond_ent):
return ent - cond_ent
def info_gain_train(self, datasets):
count = len(datasets[0]) - 1
ent = self.calc_ent(datasets)
best_feature = []
for c in range(count):
c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))
best_feature.append((c, c_info_gain))
# 比较大小
best_ = max(best_feature, key=lambda x: x[-1])
return best_
def train(self, train_data):
"""
input:数据集D(DataFrame格式)，特征集A，阈值eta
output:决策树T
"""
_, y_train, features = train_data.iloc[:, : -1], train_data.iloc[:,-1], train_data.columns[: -1]
# 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T
if len(y_train.value_counts()) == 1:
return Node(root=True, label=y_train.iloc[0])
# 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T
if len(features) == 0:
return Node(root=True,label=y_train.value_counts().sort_values(ascending=False).index[0])
# 3,计算最大信息增益,Ag为信息增益最大的特征
max_feature, max_info_gain = self.info_gain_train(np.array(train_data))
max_feature_name = features[max_feature]
# 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T
if max_info_gain < self.epsilon:
return Node(
root=True,
label=y_train.value_counts().sort_values(ascending=False).index[0])
# 5,构建Ag子集
node_tree = Node(root=False, feature_name=max_feature_name, feature=max_feature)
feature_list = train_data[max_feature_name].value_counts().index
for f in feature_list:
sub_train_df = train_data.loc[train_data[max_feature_name] ==f].drop([max_feature_name], axis=1)
# 6, 递归生成树
sub_tree = self.train(sub_train_df)
node_tree.add_node(f, sub_tree)
# pprint.pprint(node_tree.tree)
return node_tree
def fit(self, train_data):
self._tree = self.train(train_data)
return self._tree
def predict(self, X_test):
return self._tree.predict(X_test)
datasets, labels = create_data()
data_df = pd.DataFrame(datasets, columns=labels)
dt = DTree()
tree = dt.fit(data_df)
print(tree)
# {'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}
print(dt.predict(['老年', '否', '否', '一般']))
# 否
Scikit-learn实现实例
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter
# 加载Iris数据集
def create_data():
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
data = np.array(df.iloc[:100, [0, 1, -1]])
# print(data)
return data[:, :2], data[:, -1],iris.feature_names[0:2]
X, y,feature_name= create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
决策树分类
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
import graphviz
from sklearn import tree
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train,)
print(clf.score(X_test, y_test))
# 0.9666666666666667
# 一旦经过训练，就可以用 plot_tree函数绘制树：
print(tree.plot_tree(clf) )
[Text(275.55555555555554, 323.4, 'X[0] <= 5.45\ngini = 0.493\nsamples = 70\nvalue = [39, 31]'), Text(165.33333333333334, 230.99999999999997, 'X[1] <= 2.7\ngini = 0.105\nsamples = 36\nvalue = [34, 2]'), Text(110.22222222222223, 138.6, 'X[0] <= 4.75\ngini = 0.444\nsamples = 3\nvalue = [1, 2]'), Text(55.111111111111114, 46.19999999999999, 'gini = 0.0\nsamples = 1\nvalue = [1, 0]'), Text(165.33333333333334, 46.19999999999999, 'gini = 0.0\nsamples = 2\nvalue = [0, 2]'), Text(220.44444444444446, 138.6, 'gini = 0.0\nsamples = 33\nvalue = [33, 0]'), Text(385.7777777777778, 230.99999999999997, 'X[1] <= 3.45\ngini = 0.251\nsamples = 34\nvalue = [5, 29]'), Text(330.6666666666667, 138.6, 'gini = 0.0\nsamples = 29\nvalue = [0, 29]'), Text(440.8888888888889, 138.6, 'gini = 0.0\nsamples = 5\nvalue = [5, 0]')]
导出树
tree_pic = export_graphviz(clf, out_file="mytree.pdf")
with open('mytree.pdf') as f:
dot_graph = f.read()
print(graphviz.Source(dot_graph))
或者，还可以使用函数 export_text以文本格式导出树。此方法不需要安装外部库，而且更紧凑：
from sklearn.tree import export_text
r = export_text(clf,feature_name)
print(r)
|--- sepal length (cm) <= 5.45
| |--- sepal width (cm) <= 2.80
| | |--- sepal length (cm) <= 4.70
| | | |--- class: 0.0
| | |--- sepal length (cm) > 4.70
| | | |--- class: 1.0
| |--- sepal width (cm) > 2.80
| | |--- sepal length (cm) <= 5.30
| | | |--- class: 0.0
| | |--- sepal length (cm) > 5.30
| | | |--- sepal width (cm) <= 3.20
| | | | |--- class: 1.0
| | | |--- sepal width (cm) > 3.20
| | | | |--- class: 0.0
|--- sepal length (cm) > 5.45
| |--- sepal width (cm) <= 3.35
| | |--- class: 1.0
| |--- sepal width (cm) > 3.35
| | |--- class: 0.0
F:\anaconda\lib\site-packages\sklearn\utils\validation.py:70: FutureWarning: Pass feature_names=['sepal length (cm)', 'sepal width (cm)'] as keyword args. From version 1.0 (renaming of 0.25) passing these as positional arguments will result in an error
warnings.warn(f"Pass {args_msg} as keyword args. From version "
决策树回归
import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
# Create a random dataset
# 先创建一组随机的，分布在0~5上的横坐标轴的取值(x)，
# 然后将这一组值放到sin函数中去生成纵坐标的值(y)，接着再到y上去添加噪声
rng = np.random.RandomState(1)
X = np.sort(5 * rng.rand(80, 1), axis=0)
y = np.sin(X).ravel()
y[::5] += 3 * (0.5 - rng.rand(16))
# Fit regression model
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
regr_1.fit(X, y)
regr_2.fit(X, y)
# Predict
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)
# Plot the results
plt.figure()
plt.scatter(X, y, s=20, edgecolor="black", c="darkorange", label="data")
plt.plot(X_test, y_1, color="cornflowerblue", label="max_depth=2", linewidth=2)
plt.plot(X_test, y_2, color="yellowgreen", label="max_depth=5", linewidth=2)
plt.xlabel("data")
plt.ylabel("target")
plt.title("Decision Tree Regression")
plt.legend()
plt.show()
Scikit-learn 的决策树函数参数
DecisionTreeClassifier(criterion="gini", splitter="best", max_depth=None, min_samples_split=2,
min_samples_leaf=1, min_weight_fraction_leaf=0., max_features=None,random_state=None, max_leaf_nodes=None,
min_impurity_decrease=0., min_impurity_split=None,class_weight=None, presort=False)
参数介绍：
1.criterion:string, optional (default=“gini”)
(1).criterion=‘gini’,分裂节点时评价准则是Gini基尼指数。
(2).criterion=‘entropy’,分裂节点时的评价指标是信息增益。
2.max_depth:int or None, optional (default=None)。指定树的最大深度。
如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点
中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。
3.splitter:string, optional (default=“best”)。指定分裂节点时的策略。
(1).splitter=‘best’,表示选择最优的分裂策略。
(2).splitter=‘random’,表示选择最好的随机切分策略。
4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。
(1).如果为整数，则min_samples_split就是最少样本数。
(2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)
5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。
(1).如果为整数，则min_samples_split就是最少样本数。
(2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)
6.min_weight_fraction_leaf:float, optional (default=0.)
指定叶子节点中样本的最小权重。
7.max_features:int, float, string or None, optional (default=None).
搜寻最佳划分的时候考虑的特征数量。
(1).如果为整数，每次分裂只考虑max_features个特征。
(2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。
(3).如果为’auto’或者’sqrt’,则每次切分只考虑sqrt(n_features)个特征
(4).如果为’log2’,则每次切分只考虑log2(n_features)个特征。
(5).如果为None,则每次切分考虑n_features个特征。
(6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找
下一个特征，直到找到一个有效的切分为止。
8.random_state:int, RandomState instance or None, optional (default=None)
(1).如果为整数，则它指定了随机数生成器的种子。
(2).如果为RandomState实例，则指定了随机数生成器。
(3).如果为None，则使用默认的随机数生成器。
9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。
(1).如果为None,叶子节点数量不限。
(2).如果为整数，则max_depth被忽略。
10.min_impurity_decrease:float, optional (default=0.)
如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。
加权不纯度的减少量计算公式为：min_impurity_decrease=
N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity)
其中，N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数， N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。
11.min_impurity_split:float
树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。
这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。
12.class_weight:dict, list of dicts, “balanced” or None, default=None
类别权重的形式为{class_label: weight}
(1).如果没有给出每个类别的权重，则每个类别的权重都为1。
(2).如果class_weight=‘balanced’，则分类的权重与样本中每个类别出现的频率成反比。
计算公式为：n_samples / (n_classes * np.bincount(y))
(3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。
13.presort:bool, optional (default=False)
指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集
会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。
决策树-寻找最优参数
# 导入库
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeRegressor
from sklearn import metrics
# 导入数据集
X = datasets.load_iris() # 以全部字典形式返回,有data,target,target_names三个键
data = X.data
target = X.target
name = X.target_names
x, y = datasets.load_iris(return_X_y=True) # 能一次性取前2个
print(x.shape, y.shape)
# (150, 4) (150,)
# 将数据集分为训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(x, y,test_size=0.2,random_state=100)
# 用GridSearchCV寻找最优参数（字典）
param = {'criterion': ['gini'],'max_depth': [30, 50, 60, 100],
'min_samples_leaf': [2, 3, 5, 10],'min_impurity_decrease': [0.1, 0.2, 0.5]}
grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)
grid.fit(x_train, y_train)
print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_) # 得到最优的参数和分值
# 最优分类器: {'criterion': 'gini', 'max_depth': 30, 'min_impurity_decrease': 0.2, 'min_samples_leaf': 10} 最优分数: 0.9416666666666665
扫一扫
4470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
