数据挖掘分类算法之决策树（zz）

时间  2019-11-11
标签 数据挖掘 分类 算法 决策树 繁體版
原文   原文链接

决策树（Decision tree）html

   决策树是以实例为基础的概括学习算法。算法

数据挖掘分类算法之决策树
    它从一组无次序、无规则的元组中推理出决策树表示形式的分类规则。它采用自顶向下的递归方式，在决策树的内部结点进行属性值的比较，并根据不一样的属性值从 该结点向下分支，叶结点是要学习划分的类。从根到叶结点的一条路径就对应着一条合取规则，整个决策树就对应着一组析取表达式规则。1986年 Quinlan提出了著名的ID3算法。在ID3算法的基础上，1993年Quinlan又提出了C4.5算法。为了适应处理大规模数据集的须要，后来又 提出了若干改进的算法，其中SLIQ(super-vised learning in quest)和SPRINT (scalable parallelizableinduction of decision trees)是比较有表明性的两个算法。
    (1) ID3算法
    ID3算法的核心是：在决策树各级结点上选择属性时，用信息增益（information gain）做为属性的选择标准，以使得在每个非叶结点进行测试时，能得到关于被测试记录最大的类别信息。其具体方法是：检测全部的属性，选择信息增益最大的属性产生决策树结点，由该属性的不一样取值创建分支，再对各分支的子集递归调用该方法创建决策树结点的分支，直到全部子集仅包含同一类别的数据为止。最后获得一棵决策树，它能够用来对新的样本进行分类。
    某属性的信息增益按下列方法计算。经过计算每一个属性的信息增益，并比较它们的大小，就不难得到具备最大信息增益的属性。
    设S是s个数据样本的集合。假定类标号属性具备m个不一样值，定义m个不一样类Ci(i=1,…,m)。设si是类Ci中的样本数。对一个给定的样本分类所需的指望信息由下式给出：
    其中pi=si/s是任意样本属于Ci的几率。注意，对数函数以2为底，其缘由是信息用二进制编码。
    设属性A具备v个不一样值{a1,a2,……,av}。能够用属性A将S划分为v个子集{S1,S2,……,Sv}，其中Sj中的样本在属性A上具备相同的值aj（j=1,2,……,v）。设sij是子集Sj中类Ci的样本数。由A划分红子集的熵或信息指望由下式给出：
    熵值越小，子集划分的纯度越高。对于给定的子集Sj，其信息指望为
    其中pij=sij/sj 是Sj中样本属于Ci的几率。在属性A上分枝将得到的信息增益是
    Gain(A)= I(s1, s2, …,sm)-E(A)
    ID3算法的优势是：算法的理论清晰，方法简单，学习能力较强。其缺点是：只对比较小的数据集有效，且对噪声比较敏感，当训练数据集加大时，决策树可能会随之改变。
    (2) C4.5算法
    C4.5算法继承了ID3算法的优势，并在如下几方面对ID3算法进行了改进：
    1) 用信息增益率来选择属性，克服了用信息增益选择属性时偏向选择取值多的属性的不足；
    2) 在树构造过程当中进行剪枝；
    3) 可以完成对连续属性的离散化处理；
    4) 可以对不完整数据进行处理。
    C4.5算法与其它分类算法如统计方法、神经网络等比较起来有以下优势：产生的分类规则易于理解，准确率较高。其缺点是：在构造树的过程当中，须要对数据集 进行屡次的顺序扫描和排序，于是致使算法的低效。此外，C4.5只适合于可以驻留于内存的数据集，当训练集大得没法在内存容纳时程序没法运行。
    (3) SLIQ算法
    SLIQ算法对C4.5决策树分类算法的实现方法进行了改进，在决策树的构造过程当中采用了“预排序”和“广度优先策略”两种技术。
    1)预排序。对于连续属性在每一个内部结点寻找其最优分裂标准时，都须要对训练集按照该属性的取值进行排序，而排序是很浪费时间的操做。为此，SLIQ算法 采用了预排序技术。所谓预排序，就是针对每一个属性的取值，把全部的记录按照从小到大的顺序进行排序，以消除在决策树的每一个结点对数据集进行的排序。具体实 现时，须要为训练数据集的每一个属性建立一个属性列表，为类别属性建立一个类别列表。
    2)广度优先策略。在C4.5算法中，树的构造是按照深度优先策略完成的，须要对每一个属性列表在每一个结点处都进行一遍扫描，费时不少，为此，SLIQ采用 广度优先策略构造决策树，即在决策树的每一层只需对每一个属性列表扫描一次，就能够为当前决策树中每一个叶子结点找到最优分裂标准。
    SLIQ算法因为采用了上述两种技术，使得该算法可以处理比C4.5大得多的训练集，在必定范围内具备良好的随记录个数和属性个数增加的可伸缩性。
    然而它仍然存在以下缺点：
    1)因为须要将类别列表存放于内存,而类别列表的元组数与训练集的元组数是相同的,这就必定程度上限制了能够处理的数据集的大小。
    2)因为采用了预排序技术，而排序算法的复杂度自己并非与记录个数成线性关系，所以，使得SLIQ算法不可能达到随记录数目增加的线性可伸缩性。网络

    (4)SPRINT算法
    为了减小驻留于内存的数据量，SPRINT算法进一步改进了决策树算法的数据结构，去掉了在SLIQ中须要驻留于内存的类别列表，将它的类别列合并到每一个 属性列表中。这样，在遍历每一个属性列表寻找当前结点的最优分裂标准时，没必要参照其余信息，将对结点的分裂表如今对属性列表的分裂，即将每一个属性列表分红两 个，分别存放属于各个结点的记录。
    SPRINT算法的优势是在寻找每一个结点的最优分裂标准时变得更简单。其缺点是对非分裂属性的属性列表进行分裂变得很困难。解决的办法是对分裂属性进行分 裂时用哈希表记录下每一个记录属于哪一个孩子结点，若内存可以容纳下整个哈希表，其余属性列表的分裂只需参照该哈希表便可。因为哈希表的大小与训练集的大小成 正比，当训练集很大时，哈希表可能没法在内存容纳，此时分裂只能分批执行，这使得SPRINT算法的可伸缩性仍然不是很好。数据结构

 

C4.5算法app

一．背景

最先的决策时算法是由Hunt等人于1966年提出的CLS。当前最有影响的决策树算法是Quinlan于1986年提出的ID3和1993年提出的C4.5。ID3只能处理离散型描述属性，它选择信息增益最大的属性划分训练样本，其目的是进行分枝时系统的熵最小，从而提升算法的运算速度和精确度。ID3算法的主要缺陷是，用信息增益做为选择分枝属性的标准时，偏向于取值较多的属性，而在某些状况下，这类属性可能不会提供太多有价值的信息。C4.5是ID3算法的改进算法，不只能够处理离散型描述属性，还能处理连续性描述属性。C4.5采用了信息增益比做为选择分枝属性的标准，弥补了ID3算法的不足。函数

决策树算法的优势以下：（1）分类精度高；（2）成的模式简单；（3）对噪声数据有很好的健壮性。于是是目前应用最为普遍的概括推理算法之一，在数据挖掘中受到研究者的普遍关注。学习

二．C4.5改进的具体方面

1.ID3算法存在的缺点

（1）ID3算法在选择根节点和各内部节点中的分支属性时，采用信息增益做为评价标准。信息增益的缺点是倾向于选择取值较多的属性，在有些状况下这类属性可能不会提供太多有价值的信息。

（2）ID3算法只能对描述属性为离散型属性的数据集构造决策树。测试

2． C4.5算法作出的改进

(1)用信息增益率来选择属性

克服了用信息增益来选择属性时偏向选择值多的属性的不足。信息增益率定义为：ui

 

其中Gain(S,A)与ID3算法中的信息增益相同，而分裂信息SplitInfo(S,A)表明了按照属性A分裂样本集S的广度和均匀性。编码

 

其中，S1到Sc是c个不一样值的属性A分割S而造成的c个样本子集。

如按照属性A把S集（含30个用例）分红了10个用例和20个用例两个集合

则SplitInfo(S,A)=-1/3*log(1/3)-2/3*log(2/3)

(2)能够处理连续数值型属性

C4.5既能够处理离散型描述属性，也能够处理连续性描述属性。在选择某节点上的分枝属性时，对于离散型描述属性，C4.5的处理方法与ID3相同，按照该属性自己的取值个数进行计算；对于某个连续性描述属性Ac，假设在某个结点上的数据集的样本数量为total，C4.5将做如下处理。

l  将该结点上的全部数据样本按照连续型描述属性的具体数值，由小到大进行排序，获得属性值的取值序列{A1c，A2c，……Atotalc}。

l  在取值序列中生成total-1个分割点。第i（0<i<total）个分割点的取值设置为Vi=（Aic+A（i+1）c）/2,它能够将该节点上的数据集划分为两个子集。

l  从total-1个分割点中选择最佳分割点。对于每个分割点划分数据集的方式，C4.5计算它的信息增益比，而且从中选择信息增益比最大的分割点来划分数据集。

(3)采用了一种后剪枝方法

避免树的高度无节制的增加，避免过分拟合数据，

该方法使用训练样本集自己来估计剪枝先后的偏差，从而决定是否真正剪枝。方法中使用的公式以下：

 

其中N是实例的数量，f=E/N为观察到的偏差率（其中E为N个实例中分类错误的个数），q为真实的偏差率，c为置信度（C4.5算法的一个输入参数，默认值为0.25），z为对应于置信度c的标准差，其值可根据c的设定值经过查正态分布表获得。经过该公式便可计算出真实偏差率q的一个置信度上限，用此上限为该节点偏差率e作一个悲观的估计：

 

经过判断剪枝先后e的大小，从而决定是否须要剪枝。

(4)对于缺失值的处理

在某些状况下，可供使用的数据可能缺乏某些属性的值。假如〈x，c(x)〉是样本集S中的一个训练实例，可是其属性A的值A(x)未知。处理缺乏属性值的一种策略是赋给它结点n所对应的训练实例中该属性的最多见值；另一种更复杂的策略是为A的每一个可能值赋予一个几率。例如，给定一个布尔属性A，若是结点n包含6个已知A=1和4个A=0的实例，那么A(x)=1的几率是0.6，而A(x)=0的几率是0.4。因而，实例x的60%被分配到A=1的分支，40%被分配到另外一个分支。这些片段样例（fractional examples）的目的是计算信息增益，另外，若是有第二个缺乏值的属性必须被测试，这些样例能够在后继的树分支中被进一步细分。C4.5就是使用这种方法处理缺乏的属性值。

3. 　C4.5算法的优缺点

优势：产生的分类规则易于理解，准确率较高。

缺点：在构造树的过程当中，须要对数据集进行屡次的顺序扫描和排序，于是致使算法的低效。此外，C4.5只适合于可以驻留于内存的数据集，当训练集大得没法在内存容纳时程序没法运行。

三．C4.5算法源代码（C++）

// C4.5_test.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "malloc.h"
#include <stdlib.h>
const int MAX = 10;
int** iInput;
int i = 0;//列数
int j = 0;//行数
void build_tree(FILE *fp, int* iSamples, int* iAttribute,int ilevel);//输出规则
int choose_attribute(int* iSamples, int* iAttribute);//经过计算信息增益率选出test_attribute
double info(double dTrue,double dFalse);//计算指望信息
double entropy(double dTrue, double dFalse, double dAll);//求熵
double splitinfo(int* list,double dAll);
int check_samples(int *iSamples);//检查samples是否都在同一个类里
int check_ordinary(int *iSamples);//检查最普通的类
int check_attribute_null(int *iAttribute);//检查attribute是否为空
void get_attributes(int *iSamples,int *iAttributeValue,int iAttribute);
int _tmain(int argc, _TCHAR* argv[])
{
 FILE *fp;
 FILE *fp1;
 char iGet;
 int a = 0;
 int b = 0;//a,b是循环变量
 int* iSamples;
 int* iAttribute;
 fp = fopen("c:\\input.txt","r");
 if (NULL == fp)
 {
  printf("error\n");
  return 0;
 }
 iGet = getc(fp);
 
 while (('\n' != iGet)&&(EOF != iGet))
 {
  if (',' == iGet)
  {
   i++;
  }
  iGet = getc(fp);
 }
 i++;
 
 iAttribute = (int *)malloc(sizeof(int)*i);
 for (int k = 0; k<i; k++)
 {
  iAttribute[k] = (int)malloc(sizeof(int));
  iAttribute[k] = 1;
 }
 while (EOF != iGet)
 {
  if ('\n' == iGet)
  {
   j++;
  }
  iGet = getc(fp);
 }
 j++;
 
 iInput = (int **)malloc(sizeof(int*)*j);
 iSamples = (int *)malloc(sizeof(int)*j);
 for (a = 0;a < j;a++)
 {
  iInput[a] = (int *)malloc(sizeof(int)*i);
  iSamples[a] = (int)malloc(sizeof(int));
  iSamples[a] = a;
 }
 a = 0;
 fclose(fp);
 fp=fopen("c:\\input.txt","r");
 iGet = getc(fp);
 while(EOF != iGet)
 {
  if ((',' != iGet)&&('\n' != iGet))
  {
   iInput[a][b] = iGet - 48;
   b++;
  }
  if (b == i)
  {
   a++;
   b = 0;
  }
  iGet = getc(fp);
 }
 
 fp1 = fopen("d:\\output.txt","w");
 build_tree(fp1,iSamples,iAttribute,0);
 fclose(fp);
 return 0;
}

void build_tree(FILE * fp, int* iSamples, int* iAttribute,int level)//
{
 int iTest_Attribute = 0;
 int iAttributeValue[MAX];
 int k = 0;
 int l = 0;
 int m = 0;
 int *iSamples1;
 for (k = 0; k<MAX; k++)
 {
  iAttributeValue[k] = -1;
 }
 if (0 == check_samples(iSamples))
 {
  fprintf(fp,"result: %d\n",iInput[iSamples[0]][i-1]);
  return;
 }
 if (1 == check_attribute_null(iAttribute))
 {
  fprintf(fp,"result: %d\n",check_ordinary(iSamples));
  return;
 }
 iTest_Attribute = choose_attribute(iSamples,iAttribute);
 iAttribute[iTest_Attribute] = -1;
 get_attributes(iSamples,iAttributeValue,iTest_Attribute);
 k = 0;
 while ((-1 != iAttributeValue[k])&&(k < MAX))
 {
  l = 0;
  m = 0;
  while ((-1 != iSamples[l])&&(l < j))
  {
   if (iInput[iSamples[l]][iTest_Attribute] == iAttributeValue[k])
   {
    m++;
   }
   l++;
  }
  iSamples1 = (int *)malloc(sizeof(int)*(m+1));
  l = 0;
  m = 0;
  while ((-1 != iSamples[l])&&(l < j))
  {
   if (iInput[iSamples[l]][iTest_Attribute] == iAttributeValue[k])
   {
    iSamples1[m] = iSamples[l];
    m++;
   }
   l++;
  }
  iSamples1[m] = -1;
  if (-1 == iSamples1[0])
  {
   fprintf(fp,"result: %d\n",check_ordinary(iSamples));
   return;
  }
  fprintf(fp,"level%d: %d = %d\n",level,iTest_Attribute,iAttributeValue[k]);
  build_tree(fp,iSamples1,iAttribute,level+1);
  k++;
 }
}
int choose_attribute(int* iSamples, int* iAttribute)
{
 int iTestAttribute = -1;
 int k = 0;
 int l = 0;
 int m = 0;
 int n = 0;
 int iTrue = 0;
 int iFalse = 0;
 int iTrue1 = 0;
 int iFalse1 = 0;
 int iDepart[MAX];
 int iRecord[MAX];
 double dEntropy = 0.0;
 double dGainratio = 0.0;
 double test = 0.0;
 
 for (k = 0;k<MAX;k++)
 {
  iDepart[k] = -1;
  iRecord[k] = 0;
 }
 k = 0;
 while ((l!=2)&&(k<(i - 1)))
 {
  if (iAttribute[k] == -1)
  {
   l++;
  }
  k++;
 }
 if (l == 1)
 {
  for (k = 0;k<(k-1);k++)
  {
   if (iAttribute[k] == -1)
   {
    return iAttribute[k];
   }
  }
 }
 for (k = 0;k < (i-1);k++)
 {
  l = 0;
  iTrue = 0;
  iFalse = 0;
  if (iAttribute[k] != -1)
  {
   while ((-1 != iSamples[l])&&(l < j))
   {
    if (0 == iInput[iSamples[l]][i-1])
    {
     iFalse++;
    }
    if (1 == iInput[iSamples[l]][i-1])
    {
     iTrue++;
    }
    l++;    
   }
   for (n = 0;n<l;n++)//计算该属性有多少不一样的值并记录
   {
    m = 0;
    while((iDepart[m]!=-1)&&(m!=MAX))
    {
     if (iInput[iSamples[n]][iAttribute[k]] == iDepart[m])
     {
      break;
     }
     m++;
    }
    if (-1 == iDepart[m])
    {
     iDepart[m] = iInput[iSamples[n]][iAttribute[k]];
    }
   }
   while ((iDepart[m] != -1)&&(m!=MAX))
   {
    for (n = 0;n<l;n++)
    {
     if (iInput[iSamples[n]][iAttribute[k]] == iDepart[m])
     {
      if (1 == iInput[iSamples[n]][i-1])
      {
       iTrue1++;
      }
      if (0 == iInput[iSamples[n]][i-1])
      {
       iFalse1++;
      }
      iRecord[m]++;
     }
    }
    
    dEntropy += entropy((double)iTrue1,(double)iFalse1,(double)l);
    iTrue1 = 0;
    iFalse1 = 0;
    m++;
   }
   double dSplitinfo = splitinfo(iRecord,(double)l);
   if (-1 == iTestAttribute)
   {
    iTestAttribute = k;
    dGainratio = (info((double)iTrue,(double)iFalse)-dEntropy)/dSplitinfo;
   }
   else
   {
    test = (info((double)iTrue,(double)iFalse)-dEntropy)/dSplitinfo;
    if (dGainratio < test)
    {
     iTestAttribute = k;
     dGainratio = test;
    }
   }
  }
 }
 return iTestAttribute;
}
double info(double dTrue,double dFalse)
{
 double dInfo = 0.0;
 dInfo = ((dTrue/(dTrue+dFalse))*(log(dTrue/(dTrue+dFalse))/log(2.0))+(dFalse/(dTrue+dFalse))*(log(dFalse/(dTrue+dFalse))/log(2.0)))*(-1);
 return dInfo;
}
double entropy(double dTrue, double dFalse, double dAll)
{
 double dEntropy = 0.0;
 dEntropy = (dTrue + dFalse)*info(dTrue,dFalse)/dAll;
 return dEntropy;
}
double splitinfo(int* list,double dAll)
{
 int k = 0;
 double dSplitinfo = 0.0;
 while (0!=list[k])
 {
  dSplitinfo -= ((double)list[k]/(double)dAll)*(log((double)list[k]/(double)dAll));
  k++;
 }
 return dSplitinfo;
}
int check_samples(int *iSamples)
{
 int k = 0;
 int b = 0;
 while ((-1 != iSamples[k])&&(k < j-1))
 {
  if (iInput[k][i-1] != iInput[k+1][i-1])
  {
   b = 1;
   break;
  }
  k++;
 }
 return b;
}
int check_ordinary(int *iSamples)
{
 int k = 0;
 int iTrue = 0;
 int iFalse = 0;
 while ((-1 != iSamples[k])&&(k < i))
 {
  if (0 == iInput[iSamples[k]][i-1])
  {
   iFalse++;
  }
  else
  {
   iTrue++;
  }
  k++;
 }
 if (iTrue >= iFalse)
 {
  return 1;
 }
 else
 {
  return 0;
 }
}
int check_attribute_null(int *iAttribute)
{
 int k = 0;
 while (k < (i-1))
 {
  if (-1 != iAttribute[k])
  {
   return 0;
  }
  k++;
 }
 return 1;
}
void get_attributes(int *iSamples,int *iAttributeValue,int iAttribute)
{
 int k = 0;
 int l = 0;
 while ((-1 != iSamples[k])&&(k < j))
 {
  l = 0;
  while (-1 != iAttributeValue[l])
  {
   if (iInput[iSamples[k]][iAttribute] == iAttributeValue[l])
   {
    break;
   }
   l++;
  }
  if (-1 == iAttributeValue[l])
  {
   iAttributeValue[l] = iInput[iSamples[k]][iAttribute];
  }
  k++;
 }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程