分类算法之决策树

最新推荐文章于 2024-07-19 16:27:29 发布
最新推荐文章于 2024-07-19 16:27:29 发布
阅读量223 收藏 1
点赞数
文章标签： 数据结构与算法 python 人工智能
原文链接：https://my.oschina.net/xinyi/blog/116014
版权

一、算法

Key points:

  • 决策树是一个分类算法，分类结果是离散值（对应输出结果是连续值的回归算法）；
  • 有监督的分类算法;
  • 是一种贪婪算法，生成的每一步都是局部最优值
  • 容易over fitting
  • noise影响不大
  • 空间划分，通过递归的方法把特征空间划分成不重叠的矩形

例子 （from Machine Learning in Action）:

    判断是否是Fish,有两个特征Can survive without coming to surface?和 Has flippers?

    最后实现的决策树为：


生成决策树时要考虑的问题：

  • How should the training records be split?

        每次split的时候，都要挑选一个最佳的特征。

The method developed for selecting the best split are often based on the degree of impurity of the child node.

        例如：集合{'yes':10,'no':0}的不纯洁度最低，集合{'yes':5,'no':5}不纯洁度最高，显然要挑不纯度低      的特征；描述不纯度的方法有以下几种：

        信息熵

        

        Gini

Gini impurity is the expected error rate if one of the results from a set is randomly applied to one of the items in the set.(集体智慧编程) ???

         

        计算出每个子集的不纯度后，再计算split以后总不纯度。与split前的不纯度相比较

        信息增益（information gain）就是指信息熵的有效减少量

        选择差值最大的

        例如：原集合为[yes,yes,no,no,no]

        选择“surface”, split后的集合为：[yes,yes,no]和[no,no]

        

        选择"Flippers", split后的集合为:[yes,yes,no,no]和[no]

        最后选择差值最大的，即”surface“

  • How should the splitting procedure stop?

        当所有的records属于同一类，即分类完毕；或者features用完了

        或者information gain=0??       

        当达到以上两种情况时，往往会发生过拟合，见以下


如何处理过拟合的问题：

  • Pre-pruning：

        - 设定一个阈值，该阈值可以是决策树高度，节点实例个数，信息增益值等，该节点成为叶节点

        - 该叶节点持有其数据集中样本最多的类或者其概率分布 

  • Post-pruning：
        -  首先构造完整的决策树，允许决策树过度拟合训练数据

       - 对置信度不够的节点的子树用叶节点或树枝来替代

       - 该叶节点持有其子树的数据集中样本最多的类或者其概率分布

什么时候需要剪枝：

  1. 数据噪音，因此有的分类不准
  2. 训练数据量少，或者不具有代表性
  3. 过拟合

ID3, C4.5, C5.0, CART

ID3 1986年 Quilan

选择具有最高信息增益的属性作为测试属性 

ID3(DataSet, featureList): 
  - 创建根节点R 
  - 如果当前DataSet中的数据都属于同一类，则标记R的类别为该类 
  - 如果当前featureList集合为空，则标记R的类别为当前DataSet中样本最多的类别 
  - 递归情况： 
    # 从featureList中选择属性（选择Gain(DataSet,F)最大的属性） 
    # 根据F的每一个值v,将DataSet划分为不同的子集DS，对每一个Ds:
      - 创建节点C 
      - 如果DS为空，节点C标记为DataSet中样本最多的类别 
      - 如果DS不为空，节点C=ID3（DS,featureList-F） 
      - 将节点C添加为R的子节点


C4.5 1993年 by Quilab(对ID3的改进)

  • 信息增益率（information gain ratio）
  • 连续值属性

           离散化处理：将连续型的属性变量进行离散化处理，形成决策树的训练集

               - 把需要处理的样本按照连续变量的大小从小到大进行排序

               - 假设该属性对应的不同的属性值一共有N个，那么总共有N-1个可能的候选分割阈值点，每个候选的分割阈值点的值为上述排序后的属性值中两两前后元素的中点

               - 用信息增益率选择最佳划分

  • 缺失值
        - 处理缺少属性值的一种策略是赋给它节点t所对应的训练实例中该属性的最常见值


        - 复杂一点的办法是为每个可能值赋一个概率

        - 最简单的办法是丢弃这些样本

  • 后剪枝（基于错误剪枝EBP-Error Based Pruning）
    


C5.0 1998年

加入了Boosting算法框架

CART (Classification and Regression Trees)


  • 二元划分
        - 二叉树不易产生数据碎片，精确度往往会高于多叉树，所以在CART算法中采用二元划分
  • 不纯性度量
        - 分类目标：Gini指标、Towing、order Towing


        - 连续目标：最小平方残差、最小绝对残差

  • 剪枝
        - 用独立的验证数据集对训练集生长的树进行剪枝


分类树：     

CART_classification(DataSet, featureList, alpha,)：
创建根节点R
如果当前DataSet中的数据的类别相同，则标记R的类别标记为该类
如果决策树高度大于alpha，则不再分解，标记R的类别classify(DataSet)
递归情况：
标记R的类别classify(DataSet)
从featureList中选择属性F（选择Gini(DataSet, F)最小的属性划分，连续属性参考C4.5的离散化过程(以Gini最小作为划分标准)）
根据F，将DataSet做二元划分DS_L 和 DS_R：
如果DS_L或DS_R为空，则不再分解
如果DS_L和DS_R都不为空，节点
    C_L= CART_classification(DS_L, featureList, alpha); 
    C_R= CART_classification(DS_R featureList, alpha)
将节点C_L和C_R添加为R的左右子节点
回归树 
CART_regression(DataSet, featureList, alpha, delta)：
创建根节点R
如果当前DataSet中的数据的值都相同，则标记R的值为该值
如果最大的phi值小于设定阈值delta，则标记R的值为DataSet应变量均值
如果其中一个要产生的节点的样本数量小于alpha，则不再分解，标记R的值为DataSet应变量均值
递归情况：
从featureList中选择属性F（选择phi(DataSet, F)最大的属性，连续属性（或使用多个属性的线性组合）参考C4.5的离散化过程 (以phi最大作为划分标准)）
根据F，将DataSet做二元划分DS_L 和 DS_R：
如果DS_L或DS_R为空，则标记节点R的值为DataSet应变量均值
如果DS_L和DS_R都不为空，节点
    C_L= CART_regression(DS_L, featureList, alpha, delta); 
    C_R= CART_regression(DS_R featureList, alpha, delta)
将节点C_L和C_R添加为R的左右子节点
分类树与回归树的差别在于空间划分方法一个是线性一个是非线性

二、python实现

如何在python中存储一棵决策树. 如果每个特征只有两种选择，就是一棵二叉树。但往往不局限于二叉树。

  • 采用字典数据结构，如上例中的决策树最后可以表示成这样：

{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

新建一个结点：{'label':{}}, split以后{'label':{cond1:{},cond2:{},cond3:{}}},如果满足if语句,{}就是一个label,如果不满足，就建结点

  • 一个节点作为一个类       
class decisionNode(object):
	def __init__(self,test_cond=-1,value=None,labels=None,trueBranch=None,falseBranch=None):
		self.test_cond = test_cond #该节点上判断条件
		self.value=value #非叶子节点才有
		self.labels=labels #叶子节点才有
		self.trueBranch=trueBranch #左节点
		self.falseBranch=falseBranch #右节点

            

输入训练样本： 

# This Python file uses the following encoding: utf-8
from math import log
def createDataSet():
    dataSet = [[1, 1, 'yes'],
               [1, 1, 'yes'],
               [1, 0, 'no'],
               [0, 1, 'no'],
               [0, 1, 'no']]
    features = ['no surfacing','flippers']
    #change to discrete values
    return dataSet, features

用递归的方法建造决策树，代码如下：

用字典表示： 

def treeGrowth(dataSet,features):
	classList=[example[-1] for example in dataSet]
	if classList.count(classList[0])==len(classList):  #所有E中只有一种class
		return classList[0]
	if len(dataSet[0])==1: #没有多余的features
		return classify(classList)

	bestFeat=findBestSplit(dataSet)
	bestFeatLabel=features[bestFeat]
	mytree={bestFeatLabel:{}}
	featValues=[example[bestFeat] for example in dataSet]
	uniqueFeatValues=set(featValues)
	del(features[bestFeat])
	for values in uniqueFeatValues:
		subDataSet=splitDataSet(dataSet,bestFeat,values)
		mytree[bestFeatLabel][values] =treeGrowth(subDataSet,features)		
	return mytree

用节点类表示： 

def treeGrowth(dataSet,features):
	classList=[example[-1] for example in dataSet]   #stop condition
	
	if classList.count(classList[0])==len(classList) :
		return decisionNode(labels=classList[0])

	if features==[] :
		return decisionNode(labels=classify(classList))

	root=decisionNode()
	bestFeature = findBestSplit(dataSet)
	
	bestFeatureLabel=features[bestFeature]
	#print bestFeatureLabel
	root.test_cond=bestFeatureLabel

	featureValues=[example[bestFeature] for example in dataSet]
	uniqueFeatureValues =set(featureValues)
	del(features[bestFeature])
	
	for value in uniqueFeatureValues:
		subDataSet=splitDataSet(dataSet,bestFeature,value)
		if value==1:
			trueChild=treeGrowth(subDataSet,features)
			root.trueBranch=trueChild
			root.value=value
		falseChild=treeGrowth(subDataSet,features)
		root.falseBranch=falseChild
	return root

找出子集合中的大多数： 

def classify(classList):
	classCount={}
	for vote in classList:
		if vote not in classCount.keys():
			classCount[vote]=0
		classCount[vote]+=1
	sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
	return sortedClassCount[0][0]
找出最佳特征： 
def findBestSplit(dataSet):
	numFeatures=len(dataSet[0])-1
	baseEntropy = calcShannonEnt(dataSet)
	bestInfoGain = 0.0
	bestFeat=-1
	for i in range(numFeatures):
		featValues=[example[i] for example in dataSet]
		uniqueFeatValues=set(featValues)
		newEntropy=0.0
		for val in uniqueFeatValues:
			subDataSet=splitDataSet(dataSet,i,val)
			prob=len(subDataSet)/float(len(dataSet))
			newEntropy+=prob*calcShannonEnt(subDataSet)
		if (baseEntropy- newEntropy)>bestInfoGain:
			bestInfoGain=baseEntropy- newEntropy
			bestFeat=i

	return bestFeat
def splitDataSet(dataSet,feat,values):
	retDataSet = []
	for featVec in dataSet:
		if featVec[feat]==values:
			reducedFeatVec=featVec[:feat]
			reducedFeatVec.extend(featVec[feat+1:])
			retDataSet.append(reducedFeatVec)
	return retDataSet

def calcShannonEnt(dataSet):
	numEntries = len(dataSet)
	labelCounts = {}
	for featVec in dataSet:
		currentLabel = featVec[-1]
		if currentLabel not in labelCounts.keys(): 
			labelCounts[currentLabel]=0
		labelCounts[currentLabel]+=1	
	shannonEnt=0.0

	for key in labelCounts:
		prob=float(labelCounts[key])/numEntries
		if prob!=0:
			shannonEnt-=prob*log(prob,2)
	return shannonEnt

三、R实现  

creatDataSet<-function(){
  dataSet<-data.frame(c(1,1,1,0,0),c(1,1,0,1,1),c("yes","yes","no","no","no"))
  names(dataSet)<-c("no surfacing","flippers","results")
  return (dataSet)
}

setClass("decisionNode",
         representation(
           test_cond = "ANY",
           value = "ANY",
           labels = "ANY",
           trueBranch = "ANY",
           falseBranch = "ANY"
         ),
         prototype(
           test_cond = NA,
           value = NA,
           labels = NA,
           trueBranch = NA,
           falseBranch = NA 
         )
)

findBestSplit<-function(dataSet){
  classList<-dataSet$result
  numFeatures<-length(dataSet)-1
  baseEntropy<-calcShannonEnt(dataSet)
  bestInfoGain<-0
  for(i in range(1:numFeatures)){
    newEntropy<-0
    for(j in range(unique(dataSet[,i]))){
      subDataSet<-splitDataSet(dataSet,i,j)
      prob<-length(subDataSet[,1])/length(dataSet[,1])
      newEntropy<-newEntropy+prob*calcShannonEnt(subDataSet)
    }
    if((baseEntropy-newEntropy)>bestInfoGain){
      bestInfoGain<-baseEntropy-newEntropy
      bestFeature<-i
    }
  }
  return (bestFeature)
}

calcShannonEnt <- function(dataSet){
  end<-length(dataSet)
  sum<-length(dataSet[,1])
  labelCounts<-as.data.frame(table(dataSet[,end]))
  shannonEnt<-0
  for(i in range(1:length(labelCounts[,1]))){
    prob<- labelCounts[i,-1]/sum
    if(prob!=0){
      shannonEnt<-shannonEnt-prob*log(prob,2)
    }
    
  }
  return (shannonEnt)
}

splitDataSet<- function(dataSet,feature,value){
  subDataSet<-dataSet[which(dataSet[,feature]==value),]
  subDataSet[,feature]<-NULL
  return (subDataSet)
}

treeGrowth<-function(dataSet){
  classList<-dataSet$result
  if(length(which(classList==classList[1]))==length(classList)) return (new("decisionNode",labels=classList[1]))
  if(length(dataSet)==1) return (new("decisonNode",labels=classify(classList)))
  root<-new("decisionNode")
  
  bestFeature<-findBestSplit(dataSet)
  bestFeatureLabel<-names(dataSet)[bestFeature]
  root@test_cond<-bestFeatureLabel
  uniqueValues<-unique(dataSet[bestFeature])
  for(i in range(uniqueValues)){
    root@value<-i
    subDataSet<-splitDataSet(dataSet,bestFeature,i)
    
    if (i==1){
      trueChild<-treeGrowth(subDataSet)
      root@trueBranch<-trueChild
    }else{
      falseChild<-treeGrowth(subDataSet)
      root@falseBranch<-falseChild
    }
  }
  
  return (root)
}

四、与R包函数对比
另：评价分类器的方法：

转载于:https://my.oschina.net/xinyi/blog/116014

chuwen7557
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
决策树（Decision Tree）分类算法原理及应用
张晨光老师的播客
03-30 5910
4.1概述 决策树——是一种被广泛使用的分类算法。相比贝叶斯算法，决策树的优势在于构造过程不需要任何领域知识或参数设置。在实际应用中，对于探测式的知识发现，决策树更加适用。 决策树通常有三个步骤：特征选择、决策树的生成、决策树的修剪。 4.2算法思想 通俗来说，决策树分类的思想类似于找对象。现想象一个女孩的母亲要给这个女孩介绍男朋友，于是有了下面的对话： 女儿：多大年纪了？ ...
python-sklearn数据分析-决策树（CART）分类（实战）
weixin_57501965的博客
08-30 3221
可以看到，该文件大小为61878*95，其中最后一列为目标标签；其中还发现该文件数据没有缺失值和重复值。最后一列是object类型，这里采用字典编码进行转换。相关可视化效果展示如下。
决策树算法梳理
weixin_41940752的博客
04-02 974
信息论基础（熵 联合熵 条件熵 信息增益 基尼不纯度） a. 熵 信息熵 假设集合D中有y类样本，第k类的样本出现频率为Pk,则样本D的熵为 其中，当样本 DD 中 |y|∣y∣ 类样本均匀分布时，这时信息熵最大，纯度最小，熵为 当样本D中只有一类样本，此时信息熵最小，纯度最大，熵为 ** 联合熵** 因此如果在x的基础上加入了一个y，那么联合熵H(x,y) ，一定大于等于H(x)，H(y...
机器学习--决策树
weixin_54645601的博客
11-13 667
决策树（Dicision Tree）
决策树算法应用及结果解读
数据森麟
12-23 2万+
作者：林骥 来源：林骥引言本文是我写的人工智能系列的第 8 篇文章，文末有前面 7 篇文章的链接，推荐你阅读、分享和交流。1. 决策树算法简介决策树是一种应用非常广泛的...
“机器学习实战”刻意练习——分类问题：决策树
nanashi_F的博客
11-14 715
“机器学习实战”刻意练习——分类问题：决策树 | 一、概述 | 二、代码实现（python3） | 三、决策树实战：预测隐形眼镜类型 | 四、总结
决策树分类算法
oucpowerman的博客
12-12 1420
一、决策树模型 决策树是一种对实例进行分类的树形结构，由结点（node）、有向边（directed edge）组成。 结点有2种类型：内部结点和叶子节点，其中内部结点表示实例样本的一个特征（feature），叶子 节点表示实例的类别（class）。一颗典型的决策树如下图所示：       可以将决策树看成是一个“if-then”规则的集合，决策树的每条路径就是一条规则，路径上的内
大数据决策树算法数据挖掘分类算法之决策树
01-15
决策树是一种广泛应用于数据挖掘和机器学习中的分类算法，它通过构建树状模型来做出预测。这个模型由一系列的问题构成，每个问题对应于一个树节点，根据问题的答案，数据会被导向不同的分支，最终到达叶节点，得出...
数据挖掘与数据分析应用案例 数据挖掘算法实践 基于C++的数据挖掘分类算法之决策树算法.doc
06-30
它从一组无次序、无规则的元组中推理出决策树表示形式的分类规则。它采用自顶向下的递归方式，在决策树的内部结点进行属性值的比较，并根据不同的属性值从 该结点向下分支，叶结点是要学习划分的类。从根到叶结点的...
分类算法_决策树
11-27
1.什么是分类算法 2.关于分类算法的问题 3.决策树算法介绍 4.评估模型的准确性 5.应用：决策树算法在python中的实现 6.总结
决策树分类算法原理
08-16
文档为pdf格式，详细描述了决策树算法原理及相关例子说明。
PART5 机器学习分类算法之决策树.ipynb
12-31
PART5 机器学习分类算法之决策树.ipynb
数据分类分析--决策树算法
打工人。。
06-24 2081
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。决策树是一种类似于流程图的树结构，其中每个内部节点表示在一个属性上的测试，每个分支代表该测试的一个输出，而每个叶子节点（终端节点）存放一个分类结果。 上图是一个决策时的示例。 当决策树构建好之后，对检验记录进行分类就很容易，从树的根节点开始，将测试条件用于检验记录，沿着树的分支达到叶子节点，得到分类结果。原则上讲，对于给定的属性集，可以构造的决策树很多，所有如何在合理的时间内构造出具有一
使用决策树实现分类
热门推荐
Gane_Cheng的博客
12-29 4万+
决策树是一种树形结构，为人们提供决策依据，决策树可以用来回答yes和no问题，它通过树形结构将各种情况组合都表示出来，每个分支表示一次选择（选择yes还是no），直到所有选择都进行完毕，最终给出正确答案。
决策树及输出结果解释
nuonuopan8的博客
08-08 1万+
昨天学习了决策树的思想和算法，脑子卡壳了输出结果老是看不懂，一直在验算和猜想，hh后来终于明白了~在此记录巩固一下。 这里学的是ID3算法实现决策树，ID3算法能处理的数据类型是：自变量和因变量都是离散型。 假设自变量有3个：天气情况（好、坏）、是否周末（是、否）、是否有促销（有、没用）。因变量有1个：销售数量（高、低），则我们决策树叶节点都会是高、低这两种情况之一。ID3算法是基于信息熵来选择属性的，它选择当前样本集中具有最大信息增益值的自变量作为测试属性。可以简单的理解为每层的根节点、子节点都能计算
【决策树】深入浅出讲解决策树算法（原理、构建）
程序星空实验室
06-06 3万+
最早的决策树算法是由Hunt等人于1966年提出，Hunt算法是许多决策树算法的基础，包括ID3、C4.5和CART等。决策树算法是一种有监督学习算法，利用分类的思想，根据数据的特征构建数学模型，从而达到数据的筛选，决策的目标。 决策树( Decision Tree) 又称为判定树，是数据挖掘技术中的一种重要的分类与回归方法，它是一种以树结构（包括二叉树和多叉树）形式来表达的预测分析模型。其每个非叶节点表示一个特征属性上的测试，每个分支代表这个特征属性在某个值域上的输出，而每个叶节点存放一个类别。一般，一棵
决策树-特征属性选择划分
数据掘金
09-16 1万+
决策树（Decision tree）是一个树结构（可以是二叉树或非二叉树）。其每个非叶节点表示一个特征属性上的测试，每个分支代表这个特征属性在某个值域上的输出，而每个叶节点存放一个输出类别。使用决策树进行决策的过程就是从根节点开始，测试待分类项中相应的特征属性，并按照其值选择输出分支，直到到达叶子节点，将叶子节点存放的类别作为决策结果。 目的是保证节点的纯度越来越高，划分样本的能力越强 信息熵越小，纯度越高 信息增益越大，纯度越高 基尼系数越小，纯度越高 信息熵（Entro...
代码随想录打卡第二十九天
最新发布
weixin_48013375的博客
07-19 410
day 29 贪心算法第三天。
机器学习分类算法决策树
06-10
决策树是一种基于树状结构的机器学习算法，主要用于分类和回归分析。它通过对数据集进行递归分割，创建一系列简单易懂的规则，形成一个树形模型，用于预测新数据的类别或连续值。决策树算法工作原理如下： 1. **...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值