https://blog.csdn.net/jiaoyangwm/article/details/79525237
https://github.com/WordZzzz/ML/blob/master/Ch03/lenses.txt
定义
决策树（decision tree）是一种基本的分类与回归方法
决策树通常有三个步骤：
特征选择、
决策树的生成
决策树的修剪。
决策树学习
目标：根据给定的训练数据集构建一个决策树模型，使它能够对实例进行正确的分类。
本质：从训练集中归纳出一组分类规则，或者说是由训练数据集估计条件概率模型。
损失函数：正则化的极大似然函数
目标：在损失函数的意义下，选择最优决策树的问题
构建决策树
1 特征选择
如果一个特征具有更好的分类能力，那么就更应该选择这个特征。
如果通过一个特征产生的信息变化大，那么他就有更好的分类能力。
这个信息的变化= 信息增益
信息熵计算：
熵 H=−Σ1..n p(xi) log(p(xi))
当p(xi) 为由数据估计(特别是最大似然估计)得到时，例如 n个样本中有k个类别为i 的实体，那么 p(xi)= k/n .这时熵叫做 经验熵。
小于1的概率为负数
>>> log(1)
0.0
>>> log(1.1)
0.09531017980432493
>>> log(0.9)
-0.10536051565782628
条件熵计算：已知随机变量X的条件下随机变量Y的不确定性
H(Y|X)=∑1..n p(xi) H(Y|X=xi)
信息增益 g(D,A) 表示得知特征A的信息而使得类D的信息不确定性减少的程度。
g(D,A)=H(D)−H(D|A)
信息增益比：特征A对训练数据集D的信息增益比gR(D,A)定义为其信息增益g(D,A)与训练数据集D的经验熵之比：
在分类问题困难时，没有哪个特征能够均分，这是可以采用也就是说在训练数据集经验熵大的时候，信息增益值会偏大，反之信息增益值会偏小，使用信息增益比可以对这个问题进行校正，这是特征选择的另一个标准。
gR(D,A)=g(D,A)/H(D)
利用代码计算信息增益
from math import log
"""
函数说明：创建测试数据集
Parameters：无
Returns：
dataSet：数据集
labels：分类属性
Modify：
2018-03-12
"""
def creatDataSet():
# 数据集
dataSet=[[0, 0, 0, 0, 'no'],
[0, 0, 0, 1, 'no'],
[0, 1, 0, 1, 'yes'],
[0, 1, 1, 0, 'yes'],
[0, 0, 0, 0, 'no'],
[1, 0, 0, 0, 'no'],
[1, 0, 0, 1, 'no'],
[1, 1, 1, 1, 'yes'],
[1, 0, 1, 2, 'yes'],
[1, 0, 1, 2, 'yes'],
[2, 0, 1, 2, 'yes'],
[2, 0, 1, 1, 'yes'],
[2, 1, 0, 1, 'yes'],
[2, 1, 0, 2, 'yes'],
[2, 0, 0, 0, 'no']]
#分类属性
labels=['年龄','有工作','有自己的房子','信贷情况']
#返回数据集和分类属性
return dataSet,labels
"""
函数说明：计算给定数据集的经验熵（香农熵）
Parameters：
dataSet：数据集
Returns：
shannonEnt：经验熵
Modify：
2018-03-12
"""
def calcShannonEnt(dataSet):
#返回数据集行数
numEntries=len(dataSet)
#保存每个标签（label）出现次数的字典
labelCounts={}
#对每组特征向量进行统计
for featVec in dataSet:
currentLabel=featVec[-1] #提取标签信息
if currentLabel not in labelCounts.keys(): #如果标签没有放入统计次数的字典，添加进去
labelCounts[currentLabel]=0
labelCounts[currentLabel]+=1 #label计数
shannonEnt=0.0 #经验熵
#计算经验熵
for key in labelCounts:
prob=float(labelCounts[key])/numEntries #选择该标签的概率
shannonEnt-=prob*log(prob,2) #利用公式计算
return shannonEnt #返回经验熵
"""
函数说明：计算给定数据集的经验熵（香农熵）
Parameters：
dataSet：数据集
Returns：
shannonEnt：信息增益最大特征的索引值
Modify：
2018-03-12
"""
def chooseBestFeatureToSplit(dataSet):
#特征数量
numFeatures = len(dataSet[0]) - 1
#计数数据集的香农熵
baseEntropy = calcShannonEnt(dataSet)
#信息增益
bestInfoGain = 0.0
#最优特征的索引值
bestFeature = -1
#遍历所有特征
for i in range(numFeatures):
# 获取dataSet的第i个所有特征
featList = [example[i] for example in dataSet]
#创建set集合{}，元素不可重复
uniqueVals = set(featList)
#经验条件熵
newEntropy = 0.0
#计算信息增益
for value in uniqueVals:
#subDataSet划分后的子集
subDataSet = splitDataSet(dataSet, i, value)
#计算子集的概率
prob = len(subDataSet) / float(len(dataSet))
#根据公式计算经验条件熵
newEntropy += prob * calcShannonEnt((subDataSet))
#信息增益
infoGain = baseEntropy - newEntropy
#打印每个特征的信息增益
print("第%d个特征的增益为%.3f" % (i, infoGain))
#计算信息增益
if (infoGain > bestInfoGain):
#更新信息增益，找到最大的信息增益
bestInfoGain = infoGain
#记录信息增益最大的特征的索引值
bestFeature = i
#返回信息增益最大特征的索引值
return bestFeature
"""
函数说明：按照给定特征划分数据集
Parameters：
dataSet：待划分的数据集
axis：划分数据集的特征
value：需要返回的特征的值
Returns：
shannonEnt：经验熵
Modify：
2018-03-12
"""
def splitDataSet(dataSet,axis,value):
retDataSet=[]
for featVec in dataSet:
if featVec[axis]==value:
reducedFeatVec=featVec[:axis]
reducedFeatVec.extend(featVec[axis+1:])
retDataSet.append(reducedFeatVec)
return retDataSet
#main函数
if __name__=='__main__':
dataSet,features=creatDataSet()
# print(dataSet)
# print(calcShannonEnt(dataSet))
print("最优索引值："+str(chooseBestFeatureToSplit(dataSet)))
2 生成决策树
2.2 算法
2.2.1 ID3算法
具体方法是：
1）从根结点(root node)开始，对结点计算所有可能的特征的信息增益，选择信息增益最大的特征作为结点的特征。
2）由该特征的不同取值建立子节点，再对子结点递归地调用以上方法，构建决策树；直到所有特征的信息增益均很小或没有特征可以选择为止；
3）最后得到一个决策树。
def createTree(dataSet,labels,featLabels):
#取分类标签（是否放贷：yes or no）
classList=[example[-1] for example in dataSet]
#如果类别完全相同，则停止继续划分
if classList.count(classList[0])==len(classList):
return classList[0]
#遍历完所有特征时返回出现次数最多的类标签
if len(dataSet[0])==1:
return majorityCnt(classList)
#选择最优特征
bestFeat=chooseBestFeatureToSplit(dataSet)
#最优特征的标签
bestFeatLabel=labels[bestFeat]
featLabels.append(bestFeatLabel)
#根据最优特征的标签生成树
myTree={bestFeatLabel:{}}
#删除已经使用的特征标签
del(labels[bestFeat])
#得到训练集中所有最优特征的属性值
featValues=[example[bestFeat] for example in dataSet]
#去掉重复的属性值
uniqueVls=set(featValues)
#遍历特征，创建决策树
for value in uniqueVls:
myTree[bestFeatLabel][value]=createTree(splitDataSet(dataSet,bestFeat,value),
labels,featLabels)
return myTree
第0个特征的增益为0.083
第1个特征的增益为0.324
第2个特征的增益为0.420
第3个特征的增益为0.363
第0个特征的增益为0.252
第1个特征的增益为0.918
第2个特征的增益为0.474
{'有自己的房子': {0: {'有工作': {0: 'no', 1: 'yes'}}, 1: 'yes'}}
3 决策树的剪枝 ，
决策树生成算法递归的产生决策树，直到不能继续下去为止，这样产生的树往往对训练数据的分类很准确，但对未知测试数据的分类缺没有那么精确，即会出现过拟合现象。过拟合产生的原因在于在学习时过多的考虑如何提高对训练数据的正确分类，从而构建出过于复杂的决策树，解决方法是考虑决策树的复杂度，对已经生成的树进行简化。
剪枝（pruning）：从已经生成的树上裁掉一些子树或叶节点，并将其根节点或父节点作为新的叶子节点，从而简化分类树模型。
决策树学习的损失函数定义为： Cα(T)=∑1..n NtHt(T)+α|T|
损失函数认为对于每个分类终点（叶子节点）的不确定性程度就是分类的损失因子，而叶子节点的个数是模型的复杂程度，作为惩罚项，损失函数的第一项是样本的训练误差，第二项是模型的复杂度。如果一棵子树的损失函数值越大，说明这棵子树越差，因此我们希望让每一棵子树的损失函数值尽可能得小，损失函数最小化就是用正则化的极大似然估计进行模型选择的过程。
递归地从叶子节点往上计算。
不是所有的子树都要实现, 否则模型太过复杂。
其实目前按照系统硬件的性能，应该可以支持足够大的模型，这个剪枝问题倒也是可有可无
工程
决策树的保存和装载
import pickle
def storeTree(inputTree,filename):
with open(filename,'wb') as fw:
pickle.dump(inputTree,fw)
def grabTree(filename):
fr = open(filename, 'rb')
return pickle.load(fr)
向量化
import pandas as pd
from sklearn.preprocessing import LabelEncoder
# import pydotplus
# from sklearn.externals.six import StringIO
if __name__ == '__main__':
# 加载文件
with open('lenses.txt', 'r') as fr:
# 处理文件
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
# 提取每组数据的类别，保存在列表里
lenses_target = []
for each in lenses:
lenses_target.append(each[-1])
# 特征标签
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
# 保存lenses数据的临时列表
lenses_list = []
# 保存lenses数据的字典，用于生成pandas
lenses_dict = {}
# 提取信息，生成字典
for each_label in lensesLabels:
for each in lenses:
lenses_list.append(each[lensesLabels.index(each_label)])
lenses_dict[each_label] = lenses_list
lenses_list = []
# 打印字典信息
print(lenses_dict)
#生成pandas.DataFrame
lenses_pd = pd.DataFrame(lenses_dict)
# print(lenses_pd)
# 生成pandas.DataFrame
lenses_pd = pd.DataFrame(lenses_dict)
# 打印pandas.DataFrame
print(lenses_pd)
# 创建LabelEncoder()对象，用于序列化
le = LabelEncoder()
# 为每一列序列化
for col in lenses_pd.columns:
lenses_pd[col] = le.fit_transform(lenses_pd[col])
print(lenses_pd)
sklearn 决策树使用
使用sklearn.tree ——提供了决策树模型，用于解决分类和回归问题
class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None, min_samp
# -*- coding: UTF-8 -*-
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.externals.six import StringIO
from sklearn import tree
import pandas as pd
import numpy as np
import pydotplus
if __name__ == '__main__':
with open('lenses.txt', 'r') as fr: #加载文件
lenses = [inst.strip().split('\t') for inst in fr.readlines()] #处理文件
lenses_target = [] #提取每组数据的类别，保存在列表里
for each in lenses:
lenses_target.append(each[-1])
# print(lenses_target)
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate'] #特征标签
lenses_list = [] #保存lenses数据的临时列表
lenses_dict = {} #保存lenses数据的字典，用于生成pandas
for each_label in lensesLabels: #提取信息，生成字典
for each in lenses:
lenses_list.append(each[lensesLabels.index(each_label)])
lenses_dict[each_label] = lenses_list
lenses_list = []
# print(lenses_dict) #打印字典信息
lenses_pd = pd.DataFrame(lenses_dict) #生成pandas.DataFrame
# print(lenses_pd) #打印pandas.DataFrame
le = LabelEncoder() #创建LabelEncoder()对象，用于序列化
for col in lenses_pd.columns: #序列化
lenses_pd[col] = le.fit_transform(lenses_pd[col])
# print(lenses_pd) #打印编码信息
clf = tree.DecisionTreeClassifier(max_depth = 4) #创建DecisionTreeClassifier()类
clf = clf.fit(lenses_pd.values.tolist(), lenses_target) #使用数据，构建决策树
dot_data = StringIO()
tree.export_graphviz(clf, out_file = dot_data, #绘制决策树
feature_names = lenses_pd.keys(),
class_names = clf.classes_,
filled=True, rounded=True,
special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_pdf("tree.pdf") #保存绘制好的决策树，以PDF的形式存储。
print(clf.predict([[1,1,1,0]]))