利用sklearn 实现ID3、CART、C4.5 算法挑西瓜
一、ID3算法
1. 基础知识
ID3 算法是建立在奥卡姆剃刀(用较少的东西,同样可以做好事情)的基础上:越是小型的决策树越优于大的决策树。ID3 算法的核心思想就是以信息增益来度量特征选择,选择信息增益最大的特征进行分裂。算法采用自顶向下的贪婪搜索遍历可能的决策树空间(C4.5 也是贪婪搜索)。 其大致步骤为:
1)初始化特征集合和数据集合;
2)计算数据集合信息熵和所有特征的条件熵,选择信息增益最大的特征作为当前决策节点;
3)更新数据集合和特征集合(删除上一步使用的特征,并按照特征值来划分不同分支的数据集合);
4)重复 2,3 两步,若子集值包含单一特征,则为分支叶子节点。
2. 划分标准
ID3算法使用的分类标准是信息增益,它表示得知特征A的信息而使得样本集合不确定性减少的程度。
信息增益的计算过程参考:https://blog.csdn.net/One2332x/article/details/121053735?spm=1001.2014.3001.5501
3. 缺点
- ID3 没有剪枝策略,容易过拟合;
- 信息增益准则对可取值数目较多的特征有所偏好,类似“编号”的特征其信息增益接近于 1;
- 只能用于处理离散分布的特征;
- 没有考虑缺失值。
4. 利用sklearn实现ID3算法
打开Jupyter,新建项目。
# 导入包
import pandas as pd
from sklearn import tree
import numpy as np
from sklearn.model_selection import train_test_split
import graphviz
df = pd.read_csv('C:\\....\\西瓜数据集.txt') # 读取文件
# 将特征值全部转化为数字显示
df['色泽']=df['色泽'].map({
'浅白':1,'青绿':2,'乌黑':3})
df['根蒂']=df['根蒂'].map({
'稍蜷':1,'蜷缩':2,'硬挺':3})
df['敲声']=df['敲声'].map({
'清脆':1,'浊响':2,'沉闷':3})
df['纹理']=df['纹理'].map({
'清晰':1,'稍糊':2,'模糊':3})
df['脐部']=df['脐部'].map({
'平坦':1,'稍凹':2,'凹陷':3})
df['触感'] = np.where(df['触感']=="硬滑",1,2)
df['好瓜'] = np.where(df['好瓜']=="是",1,0)
x_train=df[['色泽','根蒂','敲声','纹理','脐部','触感']]
y_train=df['好瓜']
print(df)
id3=tree.DecisionTreeClassifier(criterion='entropy')
id3=id3.fit(x_train,y_train)
print(id3)
显示结果:
调用sklearn中函数tree.DecisionTreeClassifier()
,其中参数 criterion
表示选择特征的准则,默认是 'gini'
,也就是基尼系数,可以设置为'entropy'
,即信息增益。
id3=tree.DecisionTreeClassifier(criterion='entropy')
id3=id3.fit(x_train,y_train)
labels = ['色泽', '根蒂', '敲击', '纹理', '脐部', '触感']
dot_data = tree.export_graphviz(id3
,feature_names=labels
,class_names=["好瓜","坏瓜"]
,filled=True
,rounded=True
)
graph = graphviz.Source(dot_data)
graph
显示结果:
二、C4.5算法
1. 基础知识
C4.5主要克服ID3使用信息增益进行特征划分对取值数据较多特征有偏好的缺点。使用信息增益率进行特征划分。
C4.5相比ID3进行的改进有如下4点:
- 引入剪枝策略,使用悲观剪枝策略进行后剪枝;
- 使用信息增益率代替信息增益,作为特征划分标准;
- 将连续特征离散化,假设 n 个样本的连续特征 A 有 m 个取值,C4.5 将其排序并取相邻两样本值的平均数共 m-1 个划分点,分别计算以该划分点作为二元分类点时的信息增益,并选择信息增益最大的点作为该连续特征的二元离散分类点;
- 缺失值处理
- 对于具有缺失值的特征,用没有缺失的样本子集所占比重来折算信息增益率,选择划分特征。
- 选定该划分特征,对于缺失该特征值的样本,将样本以不同的概率划分到不同子节点。
2. 划分标准
利用信息增益率可以克服信息增益的缺点,其公式为:
G a i n r a t i o ( D , A ) = G a i n ( D , A ) H A ( D ) Gain_ratio(D,A)=\frac{Gain(D,A)}{H_A(D)} Gainratio(D,A)=HA(D)Gain(D,A)
H A ( D ) = − ∑ i = 1 n ∣ D i ∣ ∣ D ∣ l o g 2 ∣ D i ∣ ∣ D ∣ H_A(D)=-\sum_{i=1}^n\frac{|D_i|}{|D|}log_2\frac{|D_i|}{|D|} HA(D)=−i=1∑n∣D∣∣Di∣log2∣D∣∣Di∣
H A ( D ) H_A(D) HA(D)称为特征A的固有值
这里需要注意,信息增益率对可取值较少的特征有所偏好(分母越小,整体越大),因此 C4.5 并不是直接用增益率最大的特征进行划分,而是使用一个启发式方法:先从候选划分特征中找到信息增益高于平均值的特征,再从中选择增益率最高的。
3 剪枝策略
决策树剪枝的目的是为了防止过拟合。
预剪枝
在节点划分前来确定是否继续增长,及早停止增长的主要方法有:
- 节点内数据样本低于某一阈值;
- 所有节点特征都已分裂;
- 节点划分前准确率比划分后准确率高。
预剪枝不仅可以降低过拟合的风险而且还可以减少训练时间,但另一方面它是基于“贪心”策略,会带来欠拟合风险。
后剪枝
在已经生成的决策树上进行剪枝,从而得到简化版的剪枝决策树。
C4.5 采用的悲观剪枝方法,用递归的方式从低往上针对每一个非叶子节点,评估用一个最佳叶子节点去代替这课子树是否有益。如果剪枝后与剪枝前相比其错误率是保持或者下降,则这棵子树就可以被替换掉。C4.5 通过训练数据集上的错误分类数量来估算未知样本上的错误率。
后剪枝决策树的欠拟合风险很小,泛化性能往往优于预剪枝决策树。但同时其训练时间会大的多。
4. 缺点
- 剪枝策略可以再优化;
- C4.5 用的是多叉树,用二叉树效率更高;
- C4.5 只能用于分类;
- C4.5 使用的熵模型拥有大量耗时的对数运算,连续值还有排序运算;
- C4.5在构造树的过程中,对数值属性值需要按照其大小进行排序,从中选择一个分割点,所以只适合于能够驻留于内存的数据集,当训练集大得无法在内存容纳时,程序无法运行。
5. 用python实现C4.5算法
# 导入包
import numpy as np
import pandas as pd
import math
import collections
#导入数据
def import_data():
data = pd.read_csv('C:\\...\\西瓜数据集.txt') # 数据集存放的路径
data.head(10)
data=np.array(data).tolist()
# 特征值列表
labels = ['色泽', '根蒂', '敲击', '纹理', '脐部', '触感']
# 特征对应的所有可能的情况
labels_full = {
}
for i in range(len(labels)):
labelList = [example[i] for example in data]
uniqueLabel = set(labelList)
labels_full[labels[i]] = uniqueLabel
return data,labels,labels_full
#调用函数获取数据
data,labels,labels_full=import_data()
#计算初始的信息熵,即不分类之前的信息熵值
def calcShannonEnt(dataSet):
"""
计算给定数据集的信息熵(香农熵)
:param dataSet:
:return:
"""
# 计算出数据集的总数
numEntries = len(dataSet)
# 用来统计标签
labelCounts = collections.defaultdict(int)
# 循环整个数据集,得到数据的分类标签
for featVec in dataSet:
# 得到当前的标签
currentLabel = featVec[-1]
# # 如果当前的标签不再标签集中,就添加进去(书中的写法)
# if currentLabel not in labelCounts.keys():
# labelCounts[currentLabel] = 0
#
# # 标签集中的对应标签数目加一
# labelCounts[currentLabel] += 1
# 也可以写成如下
labelCounts[currentLabel] += 1
# 默认的信息熵
shannonEnt = 0.0
for key in labelCounts:
# 计算出当前分类标签占总标签的比例数
prob = float(labelCounts[key]) / numEntries
# 以2为底求对数
shannonEnt -= prob * math.log2(prob)
return shannonEnt
#查看初始信息熵
print(calcShannonEnt(data)) # 输出为:0.9975025463691153
# 获取每个特征值的数量,为后面计算信息增益做准备
def splitDataSet(dataSet, axis, value):
"""
按照给定的特征值,将数据集划分
:param dataSet: 数据集
:param axis: 给定特征值的坐标
:param value: 给定特征值满足的条件,只有给定特征值等于这个value的时候才会返回
:return:
"""
# 创建一个新的列表,防止对原来的列表进行修改
retDataSet = []
# 遍历整个数据集
for featVec in dataSet:
# 如果给定特征值等于想要的特征值
if featVec[axis] == value:
# 将该特征值前面的内容保存起来
reducedFeatVec = featVec[:axis]
# 将该特征值后面的内容保存起来,所以将给定特征值给去掉了
reducedFeatVec.extend(featVec[axis + 1:])
# 添加到返回列表中
retDataSet.append(reducedFeatVec)
return retDataSet
def chooseBestFeatureToSplit_4(dataSet, labels):
"""
选择最好的数据集划分特征,根据信息增益值来计算
:param dataSet:
:return:
"""
# 得到数据的特征值总数
numFeatures = len(dataSet[0]) - 1
# 计算出基础信息熵
baseEntropy = calcShannonEnt(dataSet)
# 基础信息增益为0.0
bestInfoGain = 0.0
# 最好的特征值
bestFeature = -1
# 对每个特征值进行求信息熵
for i in range(numFeatures):
# 得到数据集中所有的当前特征值列表
featList = [example[i] for example in dataSet]
# 将当前特征唯一化,也就是说当前特征值中共有多少种
uniqueVals = set(featList)
# 新的熵,代表当前特征值的熵
newEntropy = 0.0
# 遍历现在有的特征的可能性
for value in uniqueVals:
# 在全部数据集的当前特征位置上,找到该特征值等于当前值的集合
subDataSet = splitDataSet(dataSet=dataSet, axis=i, value=value)
# 计算出权重
prob = len(subDataSet) / float(len(dataSet))
# 计算出当前特征值的熵
newEntropy += prob * calcShannonEnt(subDataSet)
# 计算出“信息增益”
infoGain = baseEntropy - newEntropy
infoGain = infoGain/newEntropy
#print('当前特征值为:' + labels[i] + ',对应的信息增益值为:' + str(infoGain)+"i等于"+str(i))
#如果当前的信息增益比原来的大
if infoGain > bestInfoGain:
# 最好的信息增益
bestInfoGain = infoGain
# 新的最好的用来划分的特征值
bestFeature = i
#print('信息增益最大的特征为:' + labels[bestFeature])
return bestFeature
#创建树的函数
def createTree_4(dataSet, labels):
"""
创建决策树
:param dataSet: 数据集
:param labels: 特征标签
:return:
"""
# 拿到所有数据集的分类标签
classList = [example[-1] for example in dataSet]
# 统计第一个标签出现的次数,与总标签个数比较,如果相等则说明当前列表中全部都是一种标签,此时停止划分
if classList.count(classList[0]) == len(classList):
return classList[0]
# 计算第一行有多少个数据,如果只有一个的话说明所有的特征属性都遍历完了,剩下的一个就是类别标签,或者所有的样本在全部属性上都一致
if len(dataSet[0]) == 1 or judgeEqualLabels(dataSet):
# 返回剩下标签中出现次数较多的那个
return majorityCnt(classList)
# 选择最好的划分特征,得到该特征的下标
bestFeat = chooseBestFeatureToSplit_4(dataSet=dataSet, labels=labels)
print(bestFeat)
# 得到最好特征的名称
bestFeatLabel = labels[bestFeat]
print(bestFeatLabel)
# 使用一个字典来存储树结构,分叉处为划分的特征名称
myTree = {
bestFeatLabel: {
}}
# 将本次划分的特征值从列表中删除掉
del(labels[bestFeat])
# 得到当前特征标签的所有可能值
featValues = [example[bestFeat] for example in dataSet]
# 唯一化,去掉重复的特征值
uniqueVals = set(featValues)
# 遍历所有的特征值
for value in uniqueVals:
# 得到剩下的特征标签
subLabels = labels[:]
subTree = createTree(splitDataSet(dataSet=dataSet, axis=bestFeat, value=value), subLabels)
# 递归调用,将数据集中该特征等于当前特征值的所有数据划分到当前节点下,递归调用时需要先将当前的特征去除掉
myTree[bestFeatLabel][value] = subTree
return myTree
显示决策树
mytree_4=createTree_4(data,labels)
print(mytree_4)
显示结果:
用matplotlib
绘制决策树
# 绘制可视化树
import matplotlib.pylab as plt
import matplotlib
# 能够显示中文
matplotlib.rcParams['font.sans-serif'] = ['SimHei']
matplotlib.rcParams['font.serif'] = ['SimHei']
# 分叉节点,也就是决策节点
decisionNode = dict(boxstyle="sawtooth", fc="0.8")
# 叶子节点
leafNode = dict(boxstyle="round4", fc="0.8")
# 箭头样式
arrow_args = dict(arrowstyle="<-")
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
"""
绘制一个节点
:param nodeTxt: 描述该节点的文本信息
:param centerPt: 文本的坐标
:param parentPt: 点的坐标,这里也是指父节点的坐标
:param nodeType: 节点类型,分为叶子节点和决策节点
:return:
"""
createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',
xytext=centerPt, textcoords='axes fraction',
va="center", ha="center", bbox=nodeType, arrowprops=arrow_args)
def getNumLeafs(myTree):
"""
获取叶节点的数目
:param myTree:
:return:
"""
# 统计叶子节点的总数
numLeafs = 0
# 得到当前第一个key,也就是根节点
firstStr = list(myTree.keys())[0]
# 得到第一个key对应的内容
secondDict = myTree[firstStr]
# 递归遍历叶子节点
for key in secondDict.keys():
# 如果key对应的是一个字典,就递归调用
if type(secondDict[key]).__name__ == 'dict':
numLeafs += getNumLeafs(secondDict[key])
# 不是的话,说明此时是一个叶子节点
else:
numLeafs += 1
return numLeafs
def getTreeDepth(myTree):
"""
得到数的深度层数
:param myTree:
:return:
"""
# 用来保存最大层数
maxDepth = 0
# 得到根节点
firstStr = list(myTree.keys())[0]
# 得到key对应的内容
secondDic = myTree[firstStr]
# 遍历所有子节点
for key in secondDic.keys():
# 如果该节点是字典,就递归调用
if type(secondDic[key]).__name__ == 'dict':
# 子节点的深度加1
thisDepth = 1 + getTreeDepth(secondDic[key])
# 说明此时是叶子节点
else:
thisDepth = 1
# 替换最大层数
if thisDepth > maxDepth:
maxDepth = thisDepth
return maxDepth
def plotMidText(cntrPt, parentPt, txtString):
"""
计算出父节点和子节点的中间位置,填充信息
:param cntrPt: 子节点坐标
:param parentPt: 父节点坐标
:param txtString: 填充的文本信息
:return:
"""
# 计算x轴的中间位置
xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]
# 计算y轴的中间位置
yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]
# 进行绘制
createPlot.ax1.text(xMid, yMid, txtString)
def plotTree(myTree, parentPt, nodeTxt):
"""
绘制出树的所有节点,递归绘制
:param myTree: 树
:param parentPt: 父节点的坐标
:param nodeTxt: 节点的文本信息
:return:
"""
# 计算叶子节点数
numLeafs = getNumLeafs(myTree=myTree)
# 计算树的深度
depth = getTreeDepth(myTree=myTree)
# 得到根节点的信息内容
firstStr = list(myTree.keys())[0]
# 计算出当前根节点在所有子节点的中间坐标,也就是当前x轴的偏移量加上计算出来的根节点的中心位置作为x轴(比如说第一次:初始的x偏移量为:-1/2W,计算出来的根节点中心位置为:(1+W)/2W,相加得到:1/2),当前y轴偏移量作为y轴
cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)
# 绘制该节点与父节点的联系
plotMidText(cntrPt, parentPt, nodeTxt)
# 绘制该节点
plotNode(firstStr, cntrPt, parentPt, decisionNode)
# 得到当前根节点对应的子树
secondDict = myTree[firstStr]
# 计算出新的y轴偏移量,向下移动1/D,也就是下一层的绘制y轴
plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
# 循环遍历所有的key
for key in secondDict.keys():
# 如果当前的key是字典的话,代表还有子树,则递归遍历
if isinstance(secondDict[key], dict):
plotTree(secondDict[key], cntrPt, str(key))
else:
# 计算新的x轴偏移量,也就是下个叶子绘制的x轴坐标向右移动了1/W
plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
# 打开注释可以观察叶子节点的坐标变化
# print((plotTree.xOff, plotTree.yOff), secondDict[key])
# 绘制叶子节点
plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
# 绘制叶子节点和父节点的中间连线内容
plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
# 返回递归之前,需要将y轴的偏移量增加,向上移动1/D,也就是返回去绘制上一层的y轴
plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD
def createPlot(inTree):
"""
需要绘制的决策树
:param inTree: 决策树字典
:return:
"""
# 创建一个图像
fig = plt.figure(1, facecolor='white')
fig.clf()
axprops = dict(xticks=[], yticks=[])
createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
# 计算出决策树的总宽度
plotTree.totalW = float(getNumLeafs(inTree))
# 计算出决策树的总深度
plotTree.totalD = float(getTreeDepth(inTree))
# 初始的x轴偏移量,也就是-1/2W,每次向右移动1/W,也就是第一个叶子节点绘制的x坐标为:1/2W,第二个:3/2W,第三个:5/2W,最后一个:(W-1)/2W
plotTree.xOff = -0.5/plotTree.totalW
# 初始的y轴偏移量,每次向下或者向上移动1/D
plotTree.yOff = 1.0
# 调用函数进行绘制节点图像
plotTree(inTree, (0.5, 1.0), '')
# 绘制
plt.show()
if __name__ == '__main__':
createPlot(mytree)
显示结果:
决策树少了一些标签,需要补全决策树。
def makeTreeFull(myTree, labels_full, default):
"""
将树中的不存在的特征标签进行补全,补全为父节点中出现最多的类别
:param myTree: 生成的树
:param labels_full: 特征的全部标签
:param parentClass: 父节点中所含最多的类别
:param default: 如果缺失标签中父节点无法判断类别则使用该值
:return:
"""
# 这里所说的父节点就是当前根节点,把当前根节点下不存在的特征标签作为子节点
# 拿到当前的根节点
root_key = list(myTree.keys())[0]
# 拿到根节点下的所有分类,可能是子节点(好瓜or坏瓜)也可能不是子节点(再次划分的属性值)
sub_tree = myTree[root_key]
# 如果是叶子节点就结束
if isinstance(sub_tree, str):
return
# 找到使用当前节点分类下最多的种类,该分类结果作为新特征标签的分类,如:色泽下面没有浅白则用色泽中有的青绿分类作为浅白的分类
root_class = []
# 把已经分好类的结果记录下来
for sub_key in sub_tree.keys():
if isinstance(sub_tree[sub_key], str):
root_class.append(sub_tree[sub_key])
# 找到本层出现最多的类别,可能会出现相同的情况取其一
if len(root_class):
most_class = collections.Counter(root_class).most_common(1)[0][0]
else:
most_class = None# 当前节点下没有已经分类好的属性
# print(most_class)
# 循环遍历全部特征标签,将不存在标签添加进去
for label in labels_full[root_key]:
if label not in sub_tree.keys():
if most_class is not None:
sub_tree[label] = most_class
else:
sub_tree[label] = default
# 递归处理
for sub_key in sub_tree.keys():
if isinstance(sub_tree[sub_key], dict):
makeTreeFull(myTree=sub_tree[sub_key], labels_full=labels_full, default=default)
#调用并再次绘制树
makeTreeFull(mytree_4,labels_full,default='未知')
createPlot(mytree_4)
显示结果:
三、CART算法
1. 基础知识
CART 包含的基本过程有分裂,剪枝和树选择。
- 分裂:分裂过程是一个二叉递归划分过程,其输入和预测特征既可以是连续型的也可以是离散型的,CART 没有停止准则,会一直生长下去;
- 剪枝:采用代价复杂度剪枝,从最大树开始,每次选择训练数据熵对整体性能贡献最小的那个分裂节点作为下一个剪枝对象,直到只剩下根节点。CART 会产生一系列嵌套的剪枝树,需要从中选出一颗最优的决策树;
- 树选择:用单独的测试集评估每棵剪枝树的预测性能(也可以用交叉验证)。
CART 在 C4.5 的基础上进行了很多提升。
1)C4.5 为多叉树,运算速度慢,CART 为二叉树,运算速度快;
2)C4.5 只能分类,CART 既可以分类也可以回归;
3)CART 使用 Gini 系数作为变量的不纯度量,减少了大量的对数运算;
4)CART 采用代理测试来估计缺失值,而 C4.5 以不同概率划分到不同节点中;
5)CART 采用“基于代价复杂度剪枝”方法进行剪枝,而 C4.5 采用悲观剪枝方法。
2. 划分标准
熵模型拥有大量耗时的对数运算,基尼指数在简化模型的同时还保留了熵模型的优点。基尼指数代表了模型的不纯度,基尼系数越小,不纯度越低,特征越好。这和信息增益(率)正好相反。 G i n i ( D ) = ∑ k = 1 K ∣ C k ∣ ∣ D ∣ ( 1 − ∣ C k ∣ ∣ D ∣ ) = 1 − ∑ k = 1 K ( ∣ C k ∣ ∣ D ∣ ) 2 Gini(D)=\sum_{k=1}^K\frac{|C_k|}{|D|}(1-\frac{|C_k|}{|D|}) =1-\sum_{k=1}{K}(\frac{|C_k|}{|D|})^2 Gini(D)=k=1∑K∣D∣∣Ck∣(1−∣D∣∣Ck∣)=1−k=1∑K(∣D∣∣Ck∣)2
G i n i ( D ∣ A ) = ∑ i = 1 n ∣ D i ∣ ∣ D ∣ G a i n ( D i ) Gini(D|A)=\sum_{i=1}^n\frac{|D_i|}{|D|}Gain(D_i) Gini(D∣A)=i=1∑n∣D∣∣Di∣Gain(Di)
其中k代表类别。
基尼指数反映了从数据集中随机抽取两个样本,其类别标记不一致的概率。因此基尼指数越小,则数据集纯度越高。基尼指数偏向于特征值较多的特征,类似信息增益。基尼指数可以用来度量任何不均匀分布,是介于 0~1 之间的数,0 是完全相等,1 是完全不相等,
此外,当 CART 为二分类,其表达式为: G i n i ( D ∣ A ) = ∣ D 1 ∣ ∣ D ∣ G i n i ( D 1 ) + ∣ D 2 ∣ ∣ D ∣ G i n i ( D 2 ) Gini(D|A)=\frac{|D_1|}{|D|}Gini(D_1)+\frac{|D_2|}{|D|}Gini(D_2) Gini(D∣A)=∣D∣∣D1∣Gini(D1)+∣D∣∣D2∣Gini(D2)
3.利用sklearn实现CART算法
CART算法与ID3算法相似,唯一不同就是参数 criterion
的选择,默认就是'gini'
。
# 导入包
import pandas as pd
from sklearn import tree
import numpy as np
from sklearn.model_selection import train_test_split
import graphviz
df = pd.read_csv('C:\\...\\西瓜数据集.txt')
df
#将特征值化为数字
df['色泽']=df['色泽'].map({
'浅白':1,'青绿':2,'乌黑':3})
df['根蒂']=df['根蒂'].map({
'稍蜷':1,'蜷缩':2,'硬挺':3})
df['敲声']=df['敲声'].map({
'清脆':1,'浊响':2,'沉闷':3})
df['纹理']=df['纹理'].map({
'清晰':1,'稍糊':2,'模糊':3})
df['脐部']=df['脐部'].map({
'平坦':1,'稍凹':2,'凹陷':3})
df['触感'] = np.where(df['触感']=="硬滑",1,2)
df['好瓜'] = np.where(df['好瓜']=="是",1,0)
x_train=df[['色泽','根蒂','敲声','纹理','脐部','触感']]
y_train=df['好瓜']
#训练得到树,并且可视化
# 构建模型并训练
gini=tree.DecisionTreeClassifier()
gini=gini.fit(x_train,y_train)
#实现决策树的可视化
labels = ['色泽', '根蒂', '敲击', '纹理', '脐部', '触感']
gini_data = tree.export_graphviz(gini
,feature_names=labels
,class_names=["好瓜","坏瓜"]
,filled=True
,rounded=True
)
gini_graph = graphviz.Source(gini_data)
gini_graph
显示结果:
四、总结
ID3,C4.5,CART的区别:
划分标准的差异:ID3 使用信息增益偏向特征值多的特征,C4.5 使用信息增益率克服信息增益的缺点,偏向于特征值小的特征,CART 使用基尼指数克服 C4.5 需要求 log 的巨大计算量,偏向于特征值较多的特征。
使用场景的差异:ID3 和 C4.5 都只能用于分类问题,CART 可以用于分类和回归问题;ID3 和 C4.5 是多叉树,速度较慢,CART 是二叉树,计算速度很快;
样本数据的差异:ID3 只能处理离散数据且缺失值敏感,C4.5 和 CART 可以处理连续性数据且有多种方式处理缺失值;从样本量考虑的话,小样本建议 C4.5、大样本建议 CART。C4.5 处理过程中需对数据集进行多次扫描排序,处理成本耗时较高,而 CART 本身是一种大样本的统计方法,小样本处理下泛化误差较大 ;
样本特征的差异:ID3 和 C4.5 层级之间只使用一次特征,CART 可多次重复使用特征;
剪枝策略的差异:ID3 没有剪枝策略,C4.5 是通过悲观剪枝策略来修正树的准确性,而 CART 是通过代价复杂度剪枝。