机器学习---决策树

简介: 机器学习---决策树

日常生活中我们往往根据事物的一些特征对他们进行分类,比如饭菜的外观好不好看,咸度合不合适……那决策树也是这个原理,它会根据事物的每一个属性进行一次测试,然后分类,最后在叶子节点上就是最终分出的类。


决策树原理

image.png


类似于上面的图,决策树就是将事物的每一种属性都拿来进行一次测试分类。决策树的分类过程


  • 读取数据集
  • 计算数据集的信息熵
  • 遍历所有属性,选择信息熵最小的属性作为最好的分类特征
  • 根据上一步的属性对数据集进行分类,并且除去已经作为分类特征的属性
  • 递归,直到分类结束


其中很重要的就是信息熵的概念 香农在信息论中提出熵可以作为判断数据携带信息量的大小,并且还给了熵的计算公式。最基本的是信息的定义,如果事务在多分类中,符号xix_ixi的信息为$$l(x_i)=-log_2p(x_i)$$$p(x_i)$是选择该分类的概率

熵就是所有的信息总和Entropy(S)=−∑i=1cpilog2piEntropy(S)=-\sum_{i=1}^cp_ilog_2p_iEntropy(S)=i=1cpilog2pi

信息增益的定义是数据划分前后熵的变化Gain(S,A)=Entropy(S)−∑v∈Values(A)∣Sv∣SEntropy(Sv)Gain(S,A)=Entropy(S)-\sum_{v\in{Values(A)}}\frac{|S_v|}{S}Entropy(S_v)Gain(S,A)=Entropy(S)vValues(A)SSvEntropy(Sv)有了这些我们就可以计算信息增益从而得到最好的分类特征


知道了上面这些,我们就可以写个简单的函数来计算一下熵值


from math import log
def calcshan(dataset):
    length=len(dataset)
    p={}
    H=0.0
    for data in dataset:
        currentlabel=data[-1]
        if currentlabel not in p.keys():
            p[currentlabel]=0
        p[currentlabel]+=1
    for key in p:
        px=float(p[key])/float(length)
        H-=px*log(px,2)
    return H
data=[[1,1,'yes'],[1,1,'yes'],[1,0,'no'],[0,1,'no'],[0,1,'no']]
shannon=calcshan(data)
shannon
复制代码


image.png


当然我们也还有利用基尼系数来代替信息增益作为最佳分类判断条件的算法,以及一些防止过拟合的预剪枝方法,在这里就不过多介绍了,等以后我碰到了类似的例子我再来补充。


利用sklearn的决策树写几个例子


使用决策树对iris数据集分类


from sklearn.datasets import load_iris
from sklearn import tree
import matplotlib.pyplot as plt
import pydotplus
import numpy as np
from IPython.display import Image
import os
os.environ["PATH"] += os.pathsep + 'F:/graphviz-2.38/bin'
iris=load_iris()
X = iris.data[:, [0, 2]]
y = iris.target
clf=tree.DecisionTreeClassifier()
clf=clf.fit(X,y)
#分类结果及概率
result=clf.predict(iris.data[:1,[0,2]])
result_prob=clf.predict_proba(iris.data[:1,[0,2]])
print("分类结果:",result,"对应的概率:",result_prob)

image.png


#画出决策树
dot_data = tree.export_graphviz(clf, out_file=None)  
graph = pydotplus.graph_from_dot_data(dot_data)  
graph.write_png('iris.png')    #保存图像
Image(graph.create_png())
复制代码


image.png


这里补充一下:如果想绘制出决策树的图可以下载安装graphviz,导入环境变量,并且pip graphviz和pydotplus,这样就可以保存显示决策树的图片啦(当然也可以自己写决策树利用pyplot绘制,在下面我会给出例子的)


#分类结果
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])#np.c_按行连接矩阵,注意一维向量默认是列向量
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X[:, 0], X[:, 1], c=y, alpha=0.8)
plt.show()


image.png

还有个类似的简单例子,我就直接贴图了

image.png

image.png

image.png

image.png

对西瓜书上的西瓜数据集利用决策树进行分类


import numpy as np
import pandas as pd
import math
import copy
import matplotlib.pyplot as plt
import matplotlib as mpl      #解决中文乱码问题
mpl.rcParams[u'font.sans-serif'] = ['simhei']   
mpl.rcParams['axes.unicode_minus'] = False
#输入数据
dataset = pd.read_excel('D:/python/WaterMelon_3.0.xlsx',encoding = 'gbk')  # 读取数据
Attributes = dataset.columns        #所有属性的名称
print("所有属性名称为:")
print(Attributes,"\n")
m,n = np.shape(dataset)   # 得到数据集大小
dataset = np.matrix(dataset)
attributeList = []       # 属性列表,每一个属性的取值,列表中元素是集合
for i in range(n):
    curSet = set()      # 使用集合是利用了集合里面元素不可重复的特性,从而提取出了每个属性的取值
    for j in range(m):
        curSet.add(dataset[j,i])
    attributeList.append(curSet)
print("每一项属性的值为:")
print(attributeList,"\n")
D = np.arange(0,m,1)     # 表示每一个样本编号
A = list(np.ones(n))    # 表示每一个属性是否被使用,使用过了标为 -1
A[-1] = -1              # 将数据里面的标签和编号列标记为 -1
A[0] = -1
EPS = 0.00000001      #规定差异值,小于这个值则可说明属于同一类
class Node(object):            # 创建一个类,用来表示节点的信息
    def __init__(self,title):
        self.title = title     # 上一级指向该节点的线上的标记文字
        self.v = 1              # 节点的信息标记
        self.children = []     # 节点的孩子列表
        self.deep = 0         # 节点深度
        self.ID = -1         # 节点编号
def isSameY(D):                  # 判断所有样本是否属于同一类
    curY = dataset[D[0],n-1]
    for i in range(1,len(D)):
        if dataset[D[i],n-1] != curY:
            return  False
    return True
def isBlankA(A):              # 判断 A 是否是空,是空则返回true
    for i in range(n):
        if A[i]>0: return False
    return True
def isSameAinD(D,A):       # 判断在D中,是否所有的未使用过的样本属性均相同
    for i in range(n):
        if A[i]>0:
            for j in range(1,len(D)):
                if not isSameValue(dataset[D[0],i],dataset[D[j],i],EPS):
                    return False
    return True
def isSameValue(v1,v2,EPS):            # 判断v1、v2 是否相等
    if type(v1)==type(dataset[0,8]):
        return abs(v1-v2)<EPS
    else: return  v1==v2
def mostCommonY(D):             # 寻找D中样本数最多的类别
    res = dataset[D[0],n-1]     # D中第一个样本标签
    maxC = 1
    count = {}
    count[res] = 1              # 该标签数量记为1
    for i in range(1,len(D)):
        curV = dataset[D[i],n-1]   # 得到D中第i+1个样本的标签
        if curV not in count:      # 若之前不存在这个标签
            count[curV] = 1        # 则该标签数量记为1
        else:count[curV] += 1      # 否则 ,该标签对应的数量加一
        if count[curV]>maxC:       # maxC始终存贮最多标签对应的样本数量
            maxC = count[curV]     # res 存贮当前样本数最多的标签类型
            res = curV
    return res             # 返回的是样本数最多的标签的类型
def entropyD(D):       # 参数D中所存的样本的交叉熵
    types = []         # 存贮类别标签
    count = {}         # 存贮每个类别对应的样本数量
    for i in range(len(D)):           # 统计D中存在的每个类型的样本数量
        curY = dataset[D[i],n-1]
        if curY not in count:
            count[curY] = 1
            types.append(curY)
        else:
            count[curY] += 1
    ans = 0
    total = len(D)                # D中样本总数量
    for i in range(len(types)):   # 计算交叉熵
        ans -= count[types[i]]/total*math.log2(count[types[i]]/total)
    return ans
#对于离散型属性的信息增益函数
def gain(D,p):        # 属性 p 上的信息增益
    if type(dataset[0,p])== type(dataset[0,8]):   # 判断若是连续属性,则调用另一个函数
        res,divideV = gainFloat(D,p)
    else:
        types = []
        count = {}
        for i in range(len(D)):  # 得到每一个属性取值上的样本编号
            a = dataset[D[i],p]
            if a not in count:
                count[a] = [D[i]]
                types.append(a)
            else:
                count[a].append(D[i])
        res = entropyD(D)              # D的交叉熵
        total = len(D)
        for i in range(len(types)):    # 计算出每一个属性取值分支上的交叉熵,再计算出信息增益
            res -= len(count[types[i]])/total*entropyD(count[types[i]])
        divideV = -1000              # 这个只是随便给的一个值,没有实际意义
    return res,divideV
#对于连续型属性的信息增益函数
def gainFloat(D,p):            # 获得在连续属性上的最大信息增益及对应的划分点
    a = []
    for i in range(len(D)):    # 得到在该属性上的所有取值
        a.append(dataset[D[i],p])
    a.sort()     # 排序
    T = []
    for i in range(len(a)-1):       # 计算每一个划分点
        T.append((a[i]+a[i+1])/2)
    res = entropyD(D)               # D的交叉熵
    ans = 0
    divideV = T[0]
    for i in range(len(T)):         # 循环根据每一个分割点进行划分
        left = []
        right = []
        for j in range(len(D)):     # 根据特定分割点将样本分成两部分
            if (dataset[D[j],p]<=T[i]):
                left.append(D[j])
            else:right.append(D[j])
        temp = res-entropyD(left)-entropyD(right)    # 计算特定分割点下的信息增益
        if temp>ans:
            divideV = T[i]     # 始终存贮产生最大信息增益的分割点
            ans = temp         # 存贮最大的信息增益
    return ans,divideV
def treeGenerate(D,A,title):
    node = Node(title)
    if isSameY(D):             # D中所有样本是否属于同一类
        node.v = dataset[D[0],n-1]
        return node
    # 是否所有属性全部使用过  或者  D中所有样本的未使用的属性均相同
    if isBlankA(A) or isSameAinD(D,A):
        node.v = mostCommonY(D)  # 此时类别标记为样本数最多的类别(暗含可以处理存在异常样本的情况)
        return node              # 否则所有样本的类别应该一致
    entropy = 0
    floatV = 0
    p = 0
    for i in range(len(A)):      # 循环遍历A,找可以获得最大信息增益的属性
        if(A[i]>0):
            curEntropy,divideV = gain(D,i)
            if curEntropy > entropy:
                p = i                     # 存贮属性编号
                entropy = curEntropy
                floatV = divideV
    if isSameValue(-1000,floatV,EPS):   # 说明是离散属性
        node.v = Attributes[p]+"=?"     # 节点信息
        curSet = attributeList[p]       # 该属性的所有取值
        for i in curSet:
            Dv = []
            for j in range(len(D)):     # 获得该属性取某一个值时对应的样本标号
                if dataset[D[j],p]==i:
                    Dv.append(D[j])
            # 若该属性取值对应没有符合的样本,则将该分支作为叶子,类别是D中样本数最多的类别
            # 其实就是处理在没有对应的样本情况下的问题。那就取最大可能性的一类。
            if Dv==[]:
                nextNode = Node(i)
                nextNode.v = mostCommonY(D)
                node.children.append(nextNode)
            else:     # 若存在对应的样本,则递归继续生成该节点下的子树
                newA = copy.deepcopy(A)    # 注意是深度复制,否则会改变A中的值
                newA[p]=-1
                node.children.append(treeGenerate(Dv,newA,i))
    else:   # 若对应的是连续的属性
        Dleft = []
        Dright = []
        node.v = Attributes[p]+"<="+str(floatV)+"?"     # 节点信息
        for i in range(len(D)):       # 根据划分点将样本分成左右两部分
            if dataset[D[i],p]<=floatV: Dleft.append(D[i])
            else: Dright.append(D[i])
        node.children.append(treeGenerate(Dleft,A[:],"是"))    # 左边递归生成子树,是 yes 分支
        node.children.append(treeGenerate(Dright,A[:],"否"))    # 同上。 注意,在此时没有将对应的A中值变成 -1
    return node                                                # 因为连续属性可以使用多次进行划分
def countLeaf(root,deep):
    root.deep = deep
    res = 0
    if root.v=='好瓜' or root.v=='坏瓜':   # 说明此时已经是叶子节点了,所以直接返回
        res += 1
        return res,deep
    curdeep = deep             # 记录当前深度
    for i in root.children:    # 得到子树中的深度和叶子节点的个数
        a,b = countLeaf(i,deep+1)
        res += a
        if b>curdeep: curdeep = b
    return res,curdeep
def giveLeafID(root,ID):         # 给叶子节点编号
    if root.v=='好瓜' or root.v=='坏瓜':
        root.ID = ID
        ID += 1
        return ID
    for i in root.children:
        ID = giveLeafID(i,ID)
    return ID
def plotNode(nodeTxt,centerPt,parentPt,nodeType):     # 绘制节点
    plt.annotate(nodeTxt,xy = parentPt,xycoords='axes fraction',xytext=centerPt,
                 textcoords='axes fraction',va="center",ha="center",bbox=nodeType,
                 arrowprops=arrow_args)
def dfsPlot(root):
    if root.ID==-1:          # 说明根节点不是叶子节点
        childrenPx = []
        meanPx = 0
        for i in root.children:
            cur = dfsPlot(i)
            meanPx += cur
            childrenPx.append(cur)
        meanPx = meanPx/len(root.children)
        c = 0
        for i in root.children:
            nodetype = leafNode
            if i.ID<0: nodetype=decisionNode
            plotNode(i.v,(childrenPx[c],0.9-i.deep*0.8/deep),(meanPx,0.9-root.deep*0.8/deep),nodetype)
            plt.text((childrenPx[c]+meanPx)/2,(0.9-i.deep*0.8/deep+0.9-root.deep*0.8/deep)/2,i.title)
            c += 1
        return meanPx
    else:
        return 0.1+root.ID*0.8/(cnt-1)
myDecisionTreeRoot = treeGenerate(D,A,"root")        # 生成决策树
cnt,deep = countLeaf(myDecisionTreeRoot,0)     # 得到树的深度和叶子节点的个数
giveLeafID(myDecisionTreeRoot,0)
print("决策树根的属性为:",myDecisionTreeRoot.v)
# 绘制决策树
decisionNode = dict(boxstyle = "sawtooth",fc = "0.9",color='black')
leafNode = dict(boxstyle = "round4",fc="0.9",color='red')
arrow_args = dict(arrowstyle = "<-",color='green')
fig = plt.figure(1,facecolor='white')
rootX = dfsPlot(myDecisionTreeRoot)
plotNode(myDecisionTreeRoot.v,(rootX,0.9),(rootX,0.9),decisionNode)
plt.show()
复制代码


image.png

总结


决策树比较贴近日常生活所以还算是比较好理解的一种分类算法,最重要的就是找到最合适的分类特征。但是决策树也有它的缺点,容易过拟合、容易受数据波动影响、对于一些异或问题无法做出判断、对于决定性因素的偏差……所以还是那句话,对于不同的分类问题先考虑最合适的分类模型,不要盲目使用。BTW,本来之前还有个贝叶斯分类的,但是它的核心就是贝叶斯公式,这个只要理解了公式写起代码来其实并不难,所以我就偷了个懒跳过去啦,嘻嘻嘻。

目录
相关文章
|
2月前
|
机器学习/深度学习 存储 算法
决策树和随机森林在机器学习中的应用
在机器学习领域,决策树(Decision Tree)和随机森林(Random Forest)是两种非常流行且强大的分类和回归算法。它们通过模拟人类决策过程,将复杂的数据集分割成易于理解和处理的子集,从而实现对新数据的准确预测。
102 10
|
2月前
|
机器学习/深度学习 数据采集 监控
探索机器学习:从数据到决策
【9月更文挑战第18天】在这篇文章中,我们将一起踏上一段激动人心的旅程,穿越机器学习的世界。我们将探讨如何通过收集和处理数据,利用算法的力量来预测未来的趋势,并做出更加明智的决策。无论你是初学者还是有经验的开发者,这篇文章都将为你提供新的视角和思考方式。
|
2月前
|
机器学习/深度学习 算法 Python
从菜鸟到大师:一棵决策树如何引领你的Python机器学习之旅
【9月更文挑战第9天】在数据科学领域,机器学习如同璀璨明珠,吸引无数探索者。尤其对于新手而言,纷繁复杂的算法常让人感到迷茫。本文将以决策树为切入点,带您从Python机器学习的新手逐步成长为高手。决策树以其直观易懂的特点成为入门利器。通过构建决策树分类器并应用到鸢尾花数据集上,我们展示了其基本用法及效果。掌握决策树后,还需深入理解其工作原理,调整参数,并探索集成学习方法,最终将所学应用于实际问题解决中,不断提升技能。愿这棵智慧之树助您成为独当一面的大师。
45 3
|
2月前
|
机器学习/深度学习 算法 Python
决策树下的智慧果实:Python机器学习实战,轻松摘取数据洞察的果实
【9月更文挑战第7天】当我们身处数据海洋,如何提炼出有价值的洞察?决策树作为一种直观且强大的机器学习算法,宛如智慧之树,引领我们在繁复的数据中找到答案。通过Python的scikit-learn库,我们可以轻松实现决策树模型,对数据进行分类或回归分析。本教程将带领大家从零开始,通过实际案例掌握决策树的原理与应用,探索数据中的秘密。
48 1
|
3月前
|
机器学习/深度学习 算法 数据挖掘
【白话机器学习】算法理论+实战之决策树
【白话机器学习】算法理论+实战之决策树
|
3月前
|
机器学习/深度学习 算法 自动驾驶
揭秘机器学习模型的决策之道
【8月更文挑战第22天】本文将深入浅出地探讨机器学习模型如何从数据中学习并做出预测。我们将一起探索模型背后的数学原理,了解它们是如何被训练以及如何对新数据进行预测的。文章旨在为初学者提供一个清晰的机器学习过程概述,并启发读者思考如何在自己的项目中应用这些技术。
|
3月前
|
机器学习/深度学习 算法 搜索推荐
基于机器学习的用户行为分析:深入洞察与精准决策
【8月更文挑战第3天】基于机器学习的用户行为分析为企业提供了深入了解用户需求、优化产品设计和制定精准营销策略的有力工具。随着人工智能和大数据技术的不断发展,用户行为分析将更加智能化和个性化。未来,我们可以期待更加高效、精准的机器学习算法和模型的出现,以及更多创新性的应用场景的拓展。同时,也需要关注数据隐私和安全性问题,确保用户数据的安全和合规使用。
|
3月前
|
机器学习/深度学习 数据可视化 算法
决策树VS世界:掌握Python机器学习中的这棵树,决策从此不再迷茫
【8月更文挑战第2天】在数据驱动时代,决策树作为一种直观且易于解释的机器学习方法,因其强大的分类与回归能力备受青睐。本文介绍决策树的基础概念:通过属性测试划分数据,优化选择以提高预测准确度。使用Python的scikit-learn库,我们演示了如何加载鸢尾花数据集,构建并训练决策树模型,评估其准确性,以及利用`plot_tree`函数可视化决策过程,从而更好地理解模型的工作原理。掌握这些技能,你将在面对复杂决策时更加自信。
28 2
|
3月前
|
机器学习/深度学习 算法 Python
决策树下的智慧果实:Python机器学习实战,轻松摘取数据洞察的果实
【8月更文挑战第3天】在数据的海洋中探寻真知,决策树犹如智慧之树,以其直观易懂的强大功能,引领我们逐步缩小决策范围,轻松获取数据洞察。本篇将带您踏上Python机器学习之旅,从理解决策树为何受青睐开始,通过scikit-learn库实现鸢尾花数据集分类,解析其决策机制,并掌握调参技巧,最终优化模型性能,共同摘取数据科学的甜美果实。
50 1
|
3月前
|
机器学习/深度学习 算法 Python
从菜鸟到大师:一棵决策树如何引领你的Python机器学习之旅
【8月更文挑战第1天】在数据科学领域,机器学习如同璀璨明珠,而决策树则以其直观易懂成为入门利器。本文引导初学者利用Python的`scikit-learn`库构建决策树模型。以鸢尾花数据集为例,展示了从加载数据、划分训练/测试集、创建`DecisionTreeClassifier`、训练模型到评估准确率的全过程。掌握这些基本操作后,还需深入理解信息增益、基尼不纯度等原理,学会调参优化,并探索集成学习方法如随机森林和梯度提升树,最终将理论应用于实践,成长为真正的机器学习大师。
36 2