决策树模型
决策树是一种基本的分类和回归方法，本文主要讨论用户分类的决策树。决策树模型呈现树桩结构，在分类问题中，它表示基于特征对实例进行分类的过程。它可以认为是if-then的规则的集合也可以认为是定义在特征空间与类空间上的条件概率分布。
决策树学习通常包括3个步骤：特征选择，决策树的生成和决策树的修剪。
- 优点：模型具有可读性，解释性较强，分类速度快，准确性高，可以处理连续和种类字段，不需要任何领域知识和参数假设，适合高维数据。
- 缺点：对于各类别样本数量不一致的数据, 信息增益偏向于那些更多数值的特征，容易过拟合，忽略属性之间的相关性
决策树的生成
划分选择
决策树学习的关键是如何选择最优划分属性。也就是选择每一步具体选择哪个属性进行切分。我们希望决策树的分支结点所包含的样本尽可能属于同一类别。即结点的“纯度”越来越高。
假定当前样本集合D中的第k类样本所占比例为
p
k
(
k
=
1
,
2
,
…
,
∣
Y
∣
)
p_{k}(k=1,2, \ldots,|\mathcal{Y}|)
pk(k=1,2,…,∣Y∣)，
则D的信息熵定义为：
Ent
(
D
)
=
−
∑
k
=
1
∣
y
∣
p
k
log
2
p
k
\operatorname{Ent}(D)=-\sum_{k=1}^{|\mathcal{y |}} p_{k} \log _{2} p_{k}
Ent(D)=−∑k=1∣y∣pklog2pk, 其中
Ent
(
D
)
\operatorname{Ent}(D)
Ent(D)值越小，则D的纯度越高。
而信息增益表示得知特征A的信息后，使得类X的不确定性减少的程度，一般而言，信息增益越大，则意味着使用属性a来进行划分所获得的“纯度提升”越大。因此我们可以用信息增益来进行决策树的划分属性选择。
假定离散数学a有
V
V
V个可能的取值
{
a
1
,
a
2
,
…
,
a
V
}
\left\{a^{1}, a^{2}, \ldots, a^{V}\right\}
{a1,a2,…,aV}，若使用a来对样本集进行切分，则会产生
V
V
V个分支结点，其中第v个分支结点包含了
D
D
D中所有在数学a上取值为
a
v
a^{v}
av的样本，记为
D
v
D^{v}
Dv，我们可由上式计算得来的信息熵，再考虑到不同分支结点所包含的样本数不同，给分支结点赋予不同的权重
∣
D
v
∣
/
∣
D
∣
\left|D^{v}\right| /|D|
∣Dv∣/∣D∣，即样本越多的分支结点的影响越大，于是可计算出用数学a对样本集
D
D
D进行划分所获得的"信息增益"，
信息增益表达式：
Gain
(
D
,
a
)
=
Ent
(
D
)
−
∑
v
=
1
V
∣
D
v
∣
∣
D
∣
Ent
(
D
v
)
\operatorname{Gain}(D, a)=\operatorname{Ent}(D)-\sum_{v=1}^{V} \frac{\left|D^{v}\right|}{|D|} \operatorname{Ent}\left(D^{v}\right)
Gain(D,a)=Ent(D)−∑v=1V∣D∣∣Dv∣Ent(Dv)
Python代码
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter
import math
from math import log
import pprint
# 书上题目5.1
def create_data():
datasets = [['青年', '否', '否', '一般', '否'],
['青年', '否', '否', '好', '否'],
['青年', '是', '否', '好', '是'],
['青年', '是', '是', '一般', '是'],
['青年', '否', '否', '一般', '否'],
['中年', '否', '否', '一般', '否'],
['中年', '否', '否', '好', '否'],
['中年', '是', '是', '好', '是'],
['中年', '否', '是', '非常好', '是'],
['中年', '否', '是', '非常好', '是'],
['老年', '否', '是', '非常好', '是'],
['老年', '否', '是', '好', '是'],
['老年', '是', '否', '好', '是'],
['老年', '是', '否', '非常好', '是'],
['老年', '否', '否', '一般', '否'],
]
labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']
# 返回数据集和每个维度的名称
return datasets, labels
datasets, labels = create_data()
train_data = pd.DataFrame(datasets, columns=labels)
计算信息熵
# 熵
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
# 信息增益
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('特征({}) - info_gain - {:.3f}'.format(labels[c], c_info_gain))
# 比较大小
best_ = max(best_feature, key=lambda x: x[-1])
return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])
# 输入数据集进行测试
info_gain_train(np.array(datasets))
结果
利用ID3算法生成决策树，例5.3
# 定义节点类 二叉树
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,计算最大信息增益 同5.1,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)
显示树结构
tree
运行结果
预测
dt.predict(['老年', '否', '否', '一般'])
预测结果：
利用sklearn实现
# data
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]
X, y = 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
进行拟合
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train,)
拟合结果：
查看分数
clf.score(X_test, y_test)
显示结果
输出图像结果：
tree_pic = export_graphviz(clf, out_file="mytree.pdf")
with open('mytree.pdf') as f:
dot_graph = f.read()
扫一扫
663
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
