决策树ID3算法的实例解析.
id3算法对天气-打球关系的决策树
ID3算法是一种用于构建决策树的经典机器学习算法，它可以根据给定的数据集，自动构建出一个决策树模型，用于对未知数据进行分类。
在实际应用中，ID3算法被广泛应用于各种领域，包括天气预测和决策制定。
本文将以天气和是否适合打球这一主题为例，具体介绍ID3算法对于天气-打球关系的决策树。
1. 背景介绍天气对于人们的日常生活有着重要的影响，尤其是对于室外活动，比如打球。
在实际生活中，人们往往会根据当天的天气情况来决定是否适合进行打球活动。
而要根据天气来进行决策，就需要建立一个天气-打球的决策模型。
而ID3算法正是用来构建这样的决策模型的利器。
2. 数据采集为了构建天气-打球的决策树模型，首先需要收集一定量的天气相关数据和打球相关数据。
可以记录每天的天气情况（如晴天、阴天、下雨）、温度、湿度等天气指标，以及当天是否适合进行打球活动（是/否）。
通过收集大量的这样的数据，就可以构建出一个合适的数据集。
3. 分析数据在收集到足够的数据后，就可以开始分析这些数据，寻找天气与打球之间的关系。
ID3算法的核心思想是选择最佳的属性来进行划分，以便对数据进行分类。
在本例中，可以将天气指标（如晴天、阴天、下雨）作为属性，将打球活动（是/否）作为分类结果，然后根据ID3算法来选择最佳的属性进行数据划分，从而构建出决策树模型。
4. 构建决策树在进行数据分析后，就可以利用ID3算法来构建天气-打球的决策树。
ID3算法通过计算信息增益来确定最佳的属性，然后进行递归地对数据进行划分，直到构建出完整的决策树模型。
在这个过程中，ID3算法会根据不同的属性值来确定最佳的决策点，从而使得对于未知天气情况的打球决策变得更加准确。
5. 评估和优化构建出决策树模型后，还需要对模型进行评估和优化。
可以利用交叉验证等方法来检验模型的准确性，并根据验证结果对模型进行调整和优化。
这一步骤是非常重要的，可以帮助进一步提高决策树模型的预测能力。
6. 应用和推广构建出决策树模型后，可以将其应用到实际的天气预测和打球决策中。
决策树ID3分类算法
决策树ID3分类算法一、ID3算法介绍决策树学习是一种逼近离散值目标函数的方法，在这种方法中学习到的函数被表示为一颗决策树。
ID3算法的思想就是自顶向下构造决策树，它使用统计测试来确定每一个实例属性单独分类训练样例的能力，继而判断哪个属性是最佳的分类属性，直到建立一棵完整的决策树。
利用这棵决策树，我们可以对新的测试数据进行分类。
二、算法的实现算法实现了对于给定的数据信息, 基于信息增益构造决策树，最后给出决策树和对训练数据集的分类准确率。
程序给定的测试样本如下：实例序号颜色体形毛型类别1黑大卷毛危险2棕大光滑危险3棕中卷毛不危险4黑小卷毛不危险5棕中光滑危险6黑大光滑危险7棕小卷毛危险8棕小光滑不危险9棕大卷毛危险10黑中卷毛不危险11黑中光滑不危险12黑小光滑不危险先对上述数据进行预处理：保存为“data1.txt”再运行程序，读入数据，输出分析过程和决策规则：中间还有一些过程，为了节约资源，不复制过来了，下面是决策规则：根据该规则，树形图如下：三、程序代码及其部分注释其中最核心的部分：void Generate_decision_tree(Tree_Node * & root,vector<int> Samples, vector<int> attribute_list,int class_id)该函数由给定的训练数据产生一棵判定树。
完整代码：#include <stdio.h>#include <iostream>#include <vector>#include <math.h>#include <string.h>using namespace std;typedef struct tnode{char tdata[100];}tnode;typedef struct Tree_Node{char name[100];bool isLeaf; //标记是否叶子节点vector<tnode> att_list;//属性名称列表vector<Tree_Node * > child_list;}Tree_Node,* pTreeNpde;typedef struct dnode{vector<tnode>row;}dnode;typedef struct D_Node{vector<dnode>DB;vector<tnode> attr_name;tnode class_name;}D_Node;D_Node G_DB;pTreeNpde Root = NULL;typedef struct FreeQNode{char name[100];int count;vector<int> Set_ID;}FreeQNode;typedef struct FreeQNodeDouble{char name[100];int count;vector<int> row_id;vector<FreeQNode> classes;//存放分类属性列表及相应的出现次数}FreeQNodeDouble;typedef struct attr_node{int attr_id;vector<tnode> attr_name;vector<int> count_list;}attr_node;vector<attr_node> G_Attr_List;typedef struct binNode{char name[100];int count;vector<int> Set_ID;struct binNode * lchild;struct binNode * rchild;}binNode;typedef struct binNodeDouble{char name[100];int count;vector<int> row_id;struct binNodeDouble * lchild;struct binNodeDouble * rchild;vector<FreeQNode> classes;}binNodeDouble;void insert_tree(binNode * & r, char str[100]){if (NULL == r){binNode * node = new binNode;strcpy(node->name,str);node->count = 1;//printf("[%s,%d]\n",node->name,node->count);node->lchild = node->rchild = NULL;r = node;}else{if (strcmp(r->name,str) == 0){r->count ++;}else if (strcmp(r->name,str) < 0){insert_tree(r->lchild,str);}else{insert_tree(r->rchild,str);}}}void delete_bin_tree(binNode *& r){if (r != NULL){delete_bin_tree(r->lchild);delete_bin_tree(r->rchild);delete(r);r = NULL;}}void Bin_tree_inorder(binNode * r,vector<FreeQNode> & Fq) {if (r != NULL){Bin_tree_inorder(r->lchild,Fq);FreeQNode ft;//printf("%s,%d\n",r->name,r->count);strcpy(,r->name);ft.count = r->count;for (int i= 0;i < r->Set_ID.size();i++){ft.Set_ID.push_back(r->Set_ID[i]); //保存子集对应的ID号}Fq.push_back(ft); //此处少了这条语句，造成结果无法返回Bin_tree_inorder(r->rchild,Fq);}}void Get_attr(binNode * r,attr_node & attr){if (r != NULL){Get_attr(r->lchild,attr);tnode t;strcpy(t.tdata,r->name);//printf("%s,%d\n",r->name,r->count);attr.attr_name.push_back(t);attr.count_list.push_back(r->count);//保存出现次数Get_attr(r->rchild,attr);}}void insert_tree_double(binNodeDouble *& r, int DB_ID,char attr_name[100],char class_name[100]){if (NULL == r){binNodeDouble * node = new binNodeDouble;strcpy(node->name,attr_name);node->count = 1;node->row_id.push_back(DB_ID);node->lchild = node->rchild = NULL;FreeQNode fq;strcpy(,class_name);fq.count = 1;fq.Set_ID.push_back(DB_ID); //保存子集所对应的ID号node->classes.push_back(fq);r= node;}else{if (strcmp(r->name,attr_name) == 0){r->count ++;r->row_id.push_back(DB_ID);//这里也需要保存相应的ID号bool found = false;for (int i = 0; i< r->classes.size();i++){if (strcmp(r->classes[i].name,class_name) == 0){r->classes[i].count ++;r->classes[i].Set_ID.push_back(DB_ID);//保存子集对应的ID号found = true; //发现相同的变量名，计数器增1,break; //并退出循环}}if (!found){FreeQNode fq;strcpy(,class_name);fq.count = 1;fq.Set_ID.push_back(DB_ID);//保存子集所对应的ID号r->classes.push_back(fq);}}else if (strcmp(r->name,attr_name) < 0){insert_tree_double(r->lchild,DB_ID,attr_name,class_name);}else{insert_tree_double(r->rchild,DB_ID,attr_name,class_name);}}void delete_bin_tree_double(binNodeDouble *& r){if (r != NULL){delete_bin_tree_double(r->lchild);delete_bin_tree_double(r->rchild);delete(r);r = NULL;}}void Bin_tree_inorder_double(binNodeDouble *& r,vector<FreeQNodeDouble> &Fq){if (r != NULL){Bin_tree_inorder_double(r->lchild,Fq);FreeQNodeDouble ft;strcpy(,r->name); //保存候属性的名称ft.count = r->count;for (int k = 0;k< r->row_id.size();k++){ft.row_id.push_back(r->row_id[k]);}//printf("doubleTree. %s,%d\n",r->name,r->count);for (int i = 0;i< r->classes.size();i++){FreeQNode fq;strcpy(,r->classes[i].name);fq.count = r->classes[i].count;for (int j = 0;j < r->classes[i].Set_ID.size();j++){fq.Set_ID.push_back( r->classes[i].Set_ID[j]); //保存子集对应的ID号}ft.classes.push_back(fq);}Fq.push_back(ft);ft.classes.erase(ft.classes.begin(),ft.classes.end());//使用完，必须清空Bin_tree_inorder_double(r->rchild,Fq);}}void getFqI(vector<int> S,int class_id,vector<FreeQNode> & Fq){binNode * root = NULL;for (int i = 0;i< S.size();i++){insert_tree(root,G_DB.DB[S[i]].row[class_id].tdata);}Bin_tree_inorder(root,Fq);delete_bin_tree(root);}void getFqIA(vector<int> S,int attr_id,int class_id,vector<FreeQNodeDouble> & Fq){binNodeDouble * root = NULL;for (int i = 0;i< S.size();i++){insert_tree_double(root,S[i],G_DB.DB[S[i]].row[attr_id].tdata,G_DB.DB[S[i]].row[class_id] .tdata);}Bin_tree_inorder_double(root,Fq);delete_bin_tree_double(root);}void readdata(char *filename){char str[1000];FILE * fp;fp = fopen(filename,"r");fgets(str,1000,fp);int len = strlen(str);int attr_no = 0; //属性个数int row_num = 0;if (str != NULL){row_num = 1;}for (int i = 0;i< len;i++){if (str[i] == '\t'){attr_no ++;}}attr_no ++;//最后一个是回车，整个属性值+1printf("%d\n",attr_no);while(fgets(str,1000,fp) != NULL){row_num ++; //统计行数}fclose(fp);fopen(filename,"r");tnode t;for (i = 0;i<attr_no;i++){fscanf(fp,"%s",t.tdata);G_DB.attr_name.push_back(t);printf("%s\n",t.tdata);}strcpy(G_DB.class_name.tdata,G_DB.attr_name[attr_no-1].tdata); for (int j = 1;j< row_num;j++){dnode dt;tnode temp;for (int i = 0;i<attr_no;i++){fscanf(fp,"%s",temp.tdata);dt.row.push_back(temp);}G_DB.DB.push_back(dt);dt.row.erase(dt.row.begin(),dt.row.end());}printf("%d\n",G_DB.DB.size());for (i = 0;i< G_DB.DB.size();i++){for (int j = 0;j< G_DB.DB[i].row.size();j++){printf("%s\t",G_DB.DB[i].row[j].tdata);}printf("\n");}}double Fnc_I(vector<int> S,int class_id){//给定一个子集，计算其按照class_id所对应的分类属性进行分类时的期望I// printf("called Fnc_I(%d)\n ",class_id);vector<FreeQNode> Fq;getFqI(S,class_id,Fq); //调用getFqI获取按照Class_id为分类标准的分类结果,当Fq中为一条数据时，则子集S都属于一个分类//否则，从中找到出现此时最大的，作为返回结果// printf("begin to compute I \n");double total = 0;for (int i = 0;i< Fq.size();i++){total += Fq[i].count;// printf("%s,%d\n",Fq[i].name,Fq[i].count);}double result = 0;if (0 == total){return 0;}for (i = 0;i< Fq.size();i++){double p = Fq[i].count/total;result += -1*(p * log(p)/log(2));}// printf("FNC_I return\n\n");return result;}double Fnc_IA(vector<int> S,int attr_id,int class_id,vector<FreeQNodeDouble> & Fq) {//给定一个子集，计算其按照class_id所对应的分类属性进行分类时的期望I getFqIA(S,attr_id,class_id,Fq);double total = 0;for (int i = 0;i< Fq.size();i++){total += Fq[i].count;}double result = 0;if (0 == total){return 0;}bool pr= false;for (i = 0;i< Fq.size();i++){double stotal = Fq[i].count;double sresult = 0;if (pr) printf("[%s,%d]\n",Fq[i].name,Fq[i].count);for (int j = 0;j < Fq[i].classes.size();j++){if (pr) printf("%s,%d\n",Fq[i].classes[j].name,Fq[i].classes[j].count);for (int k = 0;k < Fq[i].classes[j].count;k++){// printf("%d\t",Fq[i].classes[j].Set_ID[k]+1);}//printf("\n");double sp = Fq[i].classes[j].count/stotal; //计算子集的频率sresult += -1*(sp*log(sp)/log(2));}result += (stotal/total) * sresult;}if (pr) printf("\n");return result;}int SelectBestAttribute(vector<int> Samples,vector<int> attribute_list,int class_id) {//输入训练数据集Samples，候选属性列表attribute_list//分类属性标记class_id//返回best_attributedouble fi = Fnc_I(Samples,5);// printf("%lf\n",fi);double IA = 999999999;int best_attrib = -1;for (int i = 0;i < attribute_list.size();i++){vector<FreeQNodeDouble> fqd;double tfa = Fnc_IA(Samples,attribute_list[i],class_id,fqd);// printf("%d, FIA = %lf\n",i,tfa);if (IA > tfa){IA = tfa;best_attrib = i;}}//printf("%lf\n",IA);printf("gain(%d) = %lf - %lf = %lf\n",best_attrib,fi,IA,fi - IA);return attribute_list[best_attrib];}void fnc_getattr(vector<int> Samples,int att_id,attr_node &at){binNode * root = NULL;for (int i = 0;i< Samples.size();i++){insert_tree(root,G_DB.DB[Samples[i]].row[att_id].tdata);}Get_attr(root,at);delete_bin_tree(root);}void get_class_num_and_name(vector<int> Samples,int class_id,int & class_num,tnode & class_name){attr_node at;binNode * root = NULL;for (int i = 0;i< Samples.size();i++){insert_tree(root,G_DB.DB[Samples[i]].row[class_id].tdata);}Get_attr(root,at);delete_bin_tree(root);//printf("att_size = %d\n",at.attr_name.size());class_num = at.attr_name.size();int num = 0;int id = 0;if (1 == class_num){strcpy(class_name.tdata,at.attr_name[0].tdata);}else{for (int j = 0;j < at.attr_name.size();j++ ){if (at.count_list[j] > num){num = at.count_list[j];id = j;}}}strcpy(class_name.tdata,at.attr_name[id].tdata);//保存最普通的类名}void getAllTheAttribute(vector<int> Samples,vector<int> attribute_list,int class_id){printf("all the attribute are:\n");for (int i = 0;i < attribute_list.size();i++){attr_node at;at.attr_id = attribute_list[i];fnc_getattr(Samples,attribute_list[i],at);G_Attr_List.push_back(at);}for (i = 0;i <G_Attr_List.size();i++){printf("%d\n",G_Attr_List[i].attr_id);for (int j = 0;j< G_Attr_List[i].attr_name.size();j++){printf("%s\t",G_Attr_List[i].attr_name[j].tdata);}printf("\n");}}void Generate_decision_tree(Tree_Node * & root,vector<int> Samples, vector<int>attribute_list,int class_id){/*算法：Generate_decision_tree(samples, attribute)。
仿照例题,使用id3算法生成决策树
标题：使用ID3算法生成决策树一、概述在机器学习领域，决策树是一种常见的分类和回归算法。
它基于一系列属性对数据进行划分，最终生成一棵树状图来表示数据的分类规则。
在本文中，我们将介绍ID3算法，一种经典的决策树生成算法，并演示如何使用ID3算法生成决策树。
二、ID3算法概述ID3算法是一种基于信息论的决策树生成算法，其全称为Iterative Dichotomiser 3。
它由Ross Quinlan于1986年提出，是C4.5算法的前身。
ID3算法的核心思想是在每个节点选择最佳的属性进行划分，使得各个子节点的纯度提高，从而最终生成一棵有效的决策树。
ID3算法的主要步骤包括计算信息增益、选择最佳属性、递归划分数据集等。
在这一过程中，算法会根据属性的信息增益来确定最佳的划分属性，直到满足停止条件为止。
三、使用ID3算法生成决策树的步骤使用ID3算法生成决策树的步骤如下：1. 收集数据集：需要收集一个包含多个样本的数据集，每个样本包含多个属性和一个类别标签。
2. 计算信息增益：对每个属性计算信息增益，信息增益越大表示该属性对分类的贡献越大。
3. 选择最佳属性：选择信息增益最大的属性作为当前节点的划分属性。
4. 划分数据集：根据选择的属性值将数据集划分成若干子集，每个子集对应属性的一个取值。
5. 递归生成子节点：对每个子集递归调用ID3算法，生成子节点，直到满足停止条件。
6. 生成决策树：将所有节点连接起来，生成一棵完整的决策树。
四、使用ID3算法生成决策树的示例为了更好地理解ID3算法的生成过程，我们以一个简单的示例来说明。
假设有一个包含天气、温度和湿度三个属性的数据集，我们希望使用ID3算法生成一个决策树来预测是否适合外出活动。
我们需要计算每个属性的信息增益。
然后选择信息增益最大的属性进行划分，将数据集划分成若干子集。
接着递归调用ID3算法，直到满足停止条件为止。
经过计算和递归划分，最终我们得到一棵决策树，可以根据天气、温度和湿度来预测是否适合外出活动。
机器学习-ID3决策树算法（附matlaboctave代码）
机器学习-ID3决策树算法（附matlaboctave代码）ID3决策树算法是基于信息增益来构建的，信息增益可以由训练集的信息熵算得，这⾥举⼀个简单的例⼦data=[⼼情好天⽓好出门⼼情好天⽓不好出门⼼情不好天⽓好出门⼼情不好天⽓不好不出门]前⾯两列是分类属性，最后⼀列是分类分类的信息熵可以计算得到：出门=3，不出门=1，总⾏数=4分类信息熵 = -(3/4)*log2(3/4)-(1/4)*log2(1/4)第⼀列属性有两类，⼼情好，⼼情不好⼼情好 ,出门=2，不出门=0，⾏数=2⼼情好信息熵=-(2/2)*log2(2/2)+(0/2)*log2(0/2)同理⼼情不好信息熵=-(1/2)*log2(1/2)-(1/2)*log2(1/2)⼼情的信息增益=分类信息熵 - ⼼情好的概率*⼼情好的信息熵 - ⼼情不好的概率*⼼情不好的信息熵由此可以得到每个属性对应的信息熵，信息熵最⼤的即为最优划分属性。
还是这个例⼦，加⼊最优划分属性为⼼情然后分别在⼼情属性的每个具体情况下的分类是否全部为同⼀种，若为同⼀种则该节点标记为此类别，这⾥我们在⼼情好的情况下不管什么天⽓结果都是出门所以，有了⼼情不好的情况下有不同的分类结果，继续计算在⼼情不好的情况下，其它属性的信息增益，把信息增益最⼤的属性作为这个分⽀节点，这个我们只有天⽓这个属性，那么这个节点就是天⽓了，天⽓属性有两种情况，如下图在⼼情不好并且天⽓好的情况下，若分类全为同⼀种，则改节点标记为此类别有训练集可以，⼼情不好并且天⽓好为出门，⼼情不好并且天⽓不好为不出门，结果⼊下图对于分⽀节点下的属性很有可能没有数据，⽐如，我们假设训练集变成data=[⼼情好晴天出门⼼情好阴天出门⼼情好⾬天出门⼼情好雾天出门⼼情不好晴天出门⼼情不好⾬天不出门⼼情不好阴天不出门]如下图：在⼼情不好的情况下，天⽓中并没有雾天，我们如何判断雾天到底是否出门呢？我们可以采⽤该样本最多的分类作为该分类，这⾥天⽓不好的情况下，我们出门=1，不出门=2，那么这⾥将不出门，作为雾天的分类结果在此我们所有属性都划分了，结束递归，我们得到了⼀颗⾮常简单的决策树。
华工人工智能ID3算法问题详解-基于信息熵的ID3算法
华工人工智能ID3算法问题详解基于信息熵的ID3算法 ID3算法是一个典型的决策树学习算法，其核心是在决策树的各级节点上，使用信息增益方法作为属性的选择标准，来帮助确定生成每个节点时所应采用的合适属性。
这样就可以选择具有最高信息增益属性作为当前节点的测试属性，以便使用该属性所划分获得的训练样本子集进行分类所需信息最小。
定义1 设U 是论域，{}n X X ,...,1是U 的一个划分，其上有概率分布)(i i X P p =，则称：∑=-=ni i i p p X H 1log )(为信源X 的信息熵，其中对数取以2为底，而当某个i p 为零时，则可以理解为00log 0=⋅。
定义2 设⎭⎬⎫⎩⎨⎧⋯⋯=n n q q q Y Y Y Y 2121是一个信息源，即{}n Y Y Y ,,,21⋯是U 的另一个划分，j j q Y P =)(，∑==n j j q 11，则已知信息源X 是信息源Y 的条件熵H(Y|X)定义为：∑==ni i i X Y H X P X Y H 1)|()()|(其中∑=-=nj i j i j i X Y P X Y P X Y H 1)|(log )|()|(为事件i X 发生时信息源Y 的条件熵。
在ID3算法分类问题中，每个实体用多个特征来描述，每个特征限于在一个离散集中取互斥的值。
ID3算法的基本原理如下：设n F F F E ⨯⋯⨯⨯=21是n 维有穷向量空间，其中i F 是有穷离散符号集。
E 中的元素>⋯=<n V V V e ,,,21称为样本空间的例子，其中i j F V ∈，),,2,1(n j ⋯=。
为简单起见，假定样本例子在真实世界中仅有两个类别，在这种两个类别的归纳任务中，PE 和NE 的实体分别称为概念的正例和反例。
假设向量空间E 中的正、反例集的大小分别为P 、N ，由决策树的基本思想，ID3算法是基于如下2种假设：（1）在向量空间E 上的一棵正确的决策树对任意样本集的分类概率同E 中的正、反例的概率一致。
决策树ID3算法
决策树ID3算法决策树ID3算法决策树是对数据进行分类，以此达到预测的目的。
该决策树方法先根据训练集数据形成决策树，如果该树不能对所有对象给出正确的分类，那么选择一些例外加入到训练集数据中，重复该过程一直到形成正确的决策集。
决策树代表着决策集的树形结构。
决策树由决策结点、分支和叶子组成。
决策树中最上面的结点为根结点，每个分支是一个新的决策结点，或者是树的叶子。
每个决策结点代表一个问题或决策，通常对应于待分类对象的属性。
每一个叶子结点代表一种可能的分类结果。
沿决策树从上到下遍历的过程中，在每个结点都会遇到一个测试，对每个结点上问题的不同的测试输出导致不同的分支，最后会到达一个叶子结点，这个过程就是利用决策树进行分类的过程，利用若干个变量来判断所属的类别。
2．ID3算法：ID3算法是由Quinlan首先提出的。
该算法是以信息论为基础，以信息熵和信息增益度为衡量标准，从而实现对数据的归纳分类。
以下是一些信息论的基本概念：定义1：若存在n个相同概率的消息，则每个消息的概率p是1/n，一个消息传递的信息量为Log2(n) 定义2：若有n个消息，其给定概率分布为P=(p1,p2…pn)，则由该分布传递的信息量称为P的熵，记为I(p)=-(i=1 to n求和)piLog2(pi)。
定义3：若一个记录集合T根据类别属性的值被分成互相独立的类C1C2..Ck，则识别T的一个元素所属哪个类所需要的信息量为Info(T)=I(p)，其中P为C1C2…Ck的概率分布，即P=(|C1|/|T|,…..|Ck|/|T|)定义4：若我们先根据非类别属性X的值将T分成集合T1,T2…Tn，则确定T中一个元素类的信息量可通过确定Ti的加权平均值来得到，即Info(Ti)的加权平均值为：Info(X, T)=(i=1 to n 求和)((|Ti|/|T|)Info(Ti))定义5：信息增益度是两个信息量之间的差值，其中一个信息量是需确定T的一个元素的信息量，另一个信息量是在已得到的属性X的值后需确定的T一个元素的信息量，信息增益度公式为：Gain(X, T)=Info(T)-Info(X, T)为方便理解，在此举例说明算法过程，具体算法其实很简单，呵呵：某市高中一年级（共六个班）学生上学期期末考试成绩数据库。
决策树ID3算法的实例解析
根据票数排名筛选出10大算法 (如果票数相同，则按字母顺序进行排名)
数据挖掘10大算法产生过程
1 2 3 4
三步鉴定流程 18种通过审核的候选算法 算法陈述 数据挖掘10大算法：一览
5
开放式讨论
18种通过审核的候选算法
§分类(Classification)
1. C4.5: Quinlan, J. R. 1993. C4.5: Programs for Machine Learning. Morgan Kaufmann Publishers Inc. 2. CART: L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification and Regression Trees. Wadsworth, Belmont, CA, 1984. 3. K Nearest Neighbours (kNN): Hastie, T. and Tibshirani, R. 1996. Discriminant Adaptive Nearest Neighbor Classification. IEEE Trans. Pattern Anal. Mach. Intell. (TPAMI). 18, 6 (Jun. 1996), 607-616. 4. Naive Bayes Hand, D.J., Yu, K., 2001. Idiot's Bayes: Not So Stupid After All? Internat. Statist. Rev. 69, 385-398.
共有145人参加了ICDM 2006 Panel (会议的专题讨论),并对18种 候选算法进行投票，选出了数据挖掘10大算法
排名 挖掘主题
机器学习-决策树之ID3算法
机器学习-决策树之ID3算法概述决策树（Decision Tree）是⼀种⾮参数的有监督学习⽅法，它是⼀种树形结构，所以叫决策树。
它能够从⼀系列有特征和标签的数据中总结出决策规则，并⽤树状图的结构来呈现这些规则，以解决分类和回归问题。
决策树算法容易理解，适⽤各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核⼼的各种集成算法，在各个⾏业和领域都有⼴泛的应⽤。
决策树的核⼼有三种算法：ID3：ID3 是最早提出的决策树算法，他就是利⽤信息增益来选择特征的。
C4.5：他是 ID3 的改进版，他不是直接使⽤信息增益，⽽是引⼊“信息增益⽐”指标作为特征的选择依据。
CART：这种算法即可以⽤于分类，也可以⽤于回归问题。
CART 算法使⽤了基尼系数取代了信息熵模型。
ID3算法是本教程的重点要讲的内容，其余两种算法将会后续推出。
数据集下⾯举个例⼦，会使⽤ID3算法帮助我们判断今天的天⽓适不适合出去打球。
进⾏判断之前，需要历史天⽓数据和打球活动数据，以下为历史数据集S。
天数天⽓⽓温湿度风⼒是否打球D1晴朗热湿弱否D2晴朗热湿强否D3⼤⾬热湿弱是D4⼩⾬中等湿弱是D5⼩⾬凉爽正常弱是D6⼩⾬凉爽正常强否D7⼤⾬凉爽正常强是D8晴朗中等湿弱否D9晴朗凉爽正常弱是D10⼩⾬中等正常弱是D11晴朗中等正常强是D12⼤⾬中等湿强是D13⼤⾬热正常弱是D14⼩⾬中等湿强否ID3算法ID3算法会选择当前信息增益最⼤的特征作为树中新的节点。
计算过程如下：步骤1假设S为完整的数据集，数据标签（数据类别）共有n个类别，分别为C1，...，Cn。
Si对应Ci类别下数据⼦集，因此，数据集S的信息熵计算如下：\[Entropy(S)=-\sum_{i=1}^{n}p_{i}\log_{2}{p_{i}} \]其中，pi是数据样本为Ci的概率，因此：\[p_i=\frac{|S_i|}{|S|} \]|Si|是类别Ci在数据集S中的数据数量，|S|是数据集S中的数据数量。
机器学习--决策树(ID3)算法及案例
机器学习--决策树(ID3)算法及案例1基本原理决策树是一个预测模型。
它代表的是对象属性与对象值之间的一种映射关系。
树中每个节点表示某个对象，每个分支路径代表某个可能的属性值，每个叶结点则对应从根节点到该叶节点所经历的路径所表示的对象的值。
一般情况下，决策树由决策结点、分支路径和叶结点组成。
在选择哪个属性作为结点的时候，采用信息论原理，计算信息增益，获得最大信息增益的属性就是最好的选择。
信息增益是指原有数据集的熵减去按某个属性分类后数据集的熵所得的差值。
然后采用递归的原则处理数据集，并得到了我们需要的决策树。
2算法流程检测数据集中的每个子项是否属于同一分类：If 是，则返回类别标签；Else计算信息增益，寻找划分数据集的最好特征划分数据数据集创建分支节点（叶结点或决策结点）for 每个划分的子集递归调用，并增加返回结果到分支节点中return 分支结点算法的基本思想可以概括为：1）树以代表训练样本的根结点开始。
2）如果样本都在同一个类．则该结点成为树叶，并记录该类。
3）否则，算法选择最有分类能力的属性作为决策树的当前结点．4 ）根据当前决策结点属性取值的不同，将训练样本根据该属性的值分为若干子集，每个取值形成一个分枝，有几个取值形成几个分枝。
匀针对上一步得到的一个子集，重复进行先前步骤，递归形成每个划分样本上的决策树。
一旦一个属性只出现在一个结点上，就不必在该结点的任何后代考虑它，直接标记类别。
5）递归划分步骤仅当下列条件之一成立时停止：①给定结点的所有样本属于同一类。
②没有剩余属性可以用来进一步划分样本．在这种情况下．使用多数表决，将给定的结点转换成树叶，并以样本中元组个数最多的类别作为类别标记，同时也可以存放该结点样本的类别分布[这个主要可以用来剪枝]。
③如果某一分枝tc，没有满足该分支中已有分类的样本，则以样本的多数类生成叶子节点。
算法中2)步所指的最优分类能力的属性。
这个属性的选择是本算法种的关键点，分裂属性的选择直接关系到此算法的优劣。
决策树的经典算法ID3与C45
决策树的经典算法ID3与C45决策树是一种常用的机器学习算法，用于分类和回归任务。
决策树算法可以看作是一种基于树结构的分类方法，它将数据集拆分成若干个子集，每个子集对应一个属性测试条件，通过不断递归地划分数据集，最终形成一棵决策树。
经典的决策树算法包括ID3和C5，本文将对这两种算法进行介绍。
ID3（Iterative Dichotomiser 3）是由Ross Quinlan提出的，它是最早的决策树算法之一。
ID3算法采用了信息增益作为属性选择度量，通过计算每个属性的信息增益，选择信息增益最大的属性进行分裂。
我们计算每个属性的信息增益。
信息增益被定义为父节点与子节点之间的信息差异，计算公式为：Gain(S,A)=H(S)-sum(P(a) * H(S_a))其中，H(S)表示节点S的熵，P(a)表示属性A的取值a在节点S中出现的概率，H(S_a)表示子节点S_a的熵。
选择信息增益最大的属性作为当前节点的分裂属性。
根据当前节点的分裂属性将数据集划分成若干个子集，对每个子集递归地执行步骤1和步骤2，直到满足停止条件（例如子集中所有样本都属于同一类别，或每个属性都已使用过）。
C5算法是ID3算法的改进版，它使用了增益率作为属性选择度量，以解决ID3算法中偏好于选择取值较多的属性的问题。
增益率定义为信息增益与分裂信息的比值，分裂信息被定义为：split_info(S,A)=-sum(P(a) * log2(P(a)))其中，P(a)表示属性A 的取值a在节点S中出现的概率。
C5算法的步骤与ID3算法类似，但在选择分裂属性时优先考虑增益率较高的属性。
C5算法还引入了剪枝技术，通过设置一个置信度阈值来避免过拟合，从而生成更加健壮的决策树。
ID3算法和C5算法都是经典的决策树算法，它们在处理分类问题时具有较高的准确率和可解释性。
然而，这两种算法也存在一些局限性，例如对于连续属性和处理缺失值的处理能力有限。
后续的许多研究者对决策树算法进行了改进和优化，如CART、CHD、BOOSTING等，这些算法在处理复杂问题、提高分类准确率和处理连续属性方面做出了更多的探索和实践。
决策树id3算法例题经典
决策树id3算法例题经典一、决策树ID3算法例题经典之基础概念决策树ID3算法就像是一个超级聪明的小侦探，在数据的世界里寻找线索。
它是一种用来分类的算法哦。
比如说，我们要把一群小动物分成哺乳动物和非哺乳动物，就可以用这个算法。
它的基本思想呢，就是通过计算信息增益来选择特征。
就好比是在一堆乱糟糟的东西里，先找到那个最能区分开不同类别的特征。
比如说在判断小动物的时候，有没有毛发这个特征可能就很关键。
如果有毛发，那很可能就是哺乳动物啦。
二、经典例题解析假设我们有这样一个数据集，是关于一些水果的。
这些水果有颜色、形状、是否有籽等特征，我们要根据这些特征来判断这个水果是苹果、香蕉还是橙子。
首先看颜色这个特征。
如果颜色是红色的，那可能是苹果的概率就比较大。
但是仅仅靠颜色可不够准确呢。
这时候就需要计算信息增益啦。
通过计算发现，形状这个特征对于区分这三种水果的信息增益更大。
比如说圆形的可能是苹果或者橙子，弯弯的可能就是香蕉啦。
再考虑是否有籽这个特征。
苹果和橙子有籽，香蕉没有籽。
把这个特征也加入到决策树的构建当中，就可以更准确地判断出到底是哪种水果了。
三、决策树ID3算法的优缺点1. 优点这个算法很容易理解，就像我们平常做选择一样，一步一步来。
它的结果也很容易解释，不像有些复杂的算法，结果出来了都不知道怎么回事。
它不需要太多的计算资源，对于小数据集来说，速度很快。
就像小马拉小车，轻松就能搞定。
2. 缺点它很容易过拟合。
就是在训练数据上表现很好，但是一到新的数据就不行了。
比如说我们只根据训练数据里的几个苹果的特征构建了决策树，新的苹果稍微有点不一样，就可能判断错了。
它只能处理离散型的数据。
如果是连续型的数据，就需要先进行离散化处理，这就多了一道工序，比较麻烦。
四、实际应用场景1. 在医疗领域，可以用来判断病人是否患有某种疾病。
比如说根据病人的症状、年龄、性别等特征来判断是否得了感冒或者其他疾病。
就像医生的小助手一样。
课件08 2第八章机器学习 决策树ID3算法的实例解析
活动 取消 取消 进行 进行 进行 取消 进行 取消 进行 进行 进行 进行 进行 取消
是否进行垒球活动
进行
取消
晴
阴
雨
进行
取消
晴 阴 雨
活动的熵
进行
取消
活动有2个属性值，进行，取消。其熵为：
H(活动) = - (9/14)*log (9/14) - (5/14)*log (5/14) = 0.94
? 例：气象预报
? X ? ? 晴 阴 大雨 小雨?
??p(x)?? ? ??1/ 2 1/ 4 1/ 8
1/
8
? ?
条件自信息量
在事件yj出现的条件下，随机事件xi发生 的条件概率为p(xi | yj) ，则它的条件自信息
量定义为条件概率对数的负值：
I ( xi | y j ) ? ? log p ( xi | y j )
4. 两个独立事件的联合信息量应等于它们分别的信息量之和。
对 信 息 量 的 认 识 理 解
? 信息量的定义
? 若一个消息x出现的概率为p，则这一消息所含的信息量为 I ? ? log p 其中，对数的底大于1
? 信息量单位
? 以2为底时，单位为 bit（binary unit，比特） ? 以e为底时，单位为 nat（natural unit，奈特） ? 以10为底时，单位为 hart（Hartley，哈特）
6 链接挖掘 PageRank
7 集装与推进 AdaBoost
8 分类
kNN
9 分类
Na?ve Bayes
10 分类
CART
得票数 发表时间
作者
61
1993 Quinlan, J.R
id3算法例题构建三层决策树
标题：深入理解ID3算法：通过例题构建三层决策树在机器学习领域，ID3算法是一种经典的分类算法，它可以通过构建决策树来对数据进行分类。
本文将深入解析ID3算法，并通过一个例题，一步步构建三层决策树，让读者更加深入地理解这一算法的原理和应用。
1. ID3算法的基本原理ID3算法是一种基于信息论的分类算法，它以信息增益作为分裂属性的选择标准，希望通过选择能够使得信息增益最大的属性来进行数据的划分。
其基本原理可以用以下几个步骤来概括：- 步骤一：计算数据集的信息熵，以及每个特征属性的信息增益。
- 步骤二：选择信息增益最大的特征作为节点，对数据集进行划分。
- 步骤三：对每个划分后的子数据集递归地应用ID3算法，构建决策树。
2. 例题背景描述假设我们有一个数据集，包含了以下几个属性：芳龄、收入、学历和是否购买电子产品。
我们希望通过这个数据集构建一个决策树模型，来预测一个人是否会购买电子产品。
3. 数据集的信息熵计算我们需要计算整个数据集的信息熵。
在这个过程中，我们需要对每个属性进行划分，并计算每个属性的信息增益，以便选择最佳的划分属性。
我们按照信息增益最大的属性进行数据集的划分，并对子数据集进行递归处理。
4. 构建决策树通过以上步骤，我们逐渐构建出了一个三层决策树。
在这个决策树中，根节点是选择信息增益最大的属性，中间节点是根据不同属性值进行划分，叶节点则表示最终的分类结果。
5. 个人观点和总结通过这个例题的分析，我们可以更深入地理解ID3算法的原理和应用。
ID3算法以信息增益作为属性选择的标准，通过构建决策树来进行分类预测。
在实际应用中，我们可以根据ID3算法构建的决策树模型，对未知数据进行分类预测，从而实现自动化决策。
ID3算法作为一种经典的分类算法，具有较好的解释性和可解释性，在实际应用中具有广泛的应用前景。
希望通过本文的介绍，读者能够更加深入地理解ID3算法，并能够灵活运用于实际问题的解决中。
本文总字数超过3000字，详细探讨了ID3算法的基本原理和应用，通过例题构建了三层决策树，并共享了个人观点和总结。
ID3算法实验报告
一、实验原理决策树通过把实例从根节点罗列到某个叶子节点来分类实例，叶子节点即为实例所属的分类。
树上的每一个节点说明了对实例的某个属性的测试，并且该节点的每一个后继分支对应于该属性的一个可能同样一组例子，可以有不少决策树能符合这组例子。
人们研究出，一般情况下或者具有较大概率地说，树越小则树的预测能力越强。
要构造尽可能小的决策树，关键在于选择恰当的逻辑判断或者属性。
由于构造最小的树是NP-难问题，因此只能采取用启示式策略选择好的逻辑判断或者属性。
用信息增益度量期望熵最低，来选择分类属性。
公式为值，例如下图。
构造好的决策树的关键在于如何选择好的逻辑判断或者属性。
对于ID3 算法创建树的Root 结点如果Examples 都为正，那末返回label=+中的单结点Root如果Examples 都为反，那末返回lable=-单结点树Root如果Attributes 为空，那末返回单节点树Root，lable=Examples 中最普遍的目标属性值否则开始A<-Attributes 中分类能力最好的属性Root 的决策属性<-A对于每一个可能值在Root 下加一个新的分支对应测试A=vi令Example-vi 为Examples 中满足A 属性值为vi 的子集如果Examples-vi 为空在这个新分支下加一个叶子结点，节点的lable=Examples 中最普遍的目标属性值否则在这个新分支下加一个子树ID3(example-vi,target-attribute,attributes-|A|)结束返回Root二、算法实现训练数据存放在Data.txt 中第一行为训练样本数量和每一个样本中属性的数量第二行为每一个属性取值的数量之后n 行为所有样本节点数据结构struct DTNode{int name; //用1,2,3...表示选择的属性，0 表示不用分类，即叶节点int data[D_MAX+1]; //表示此节点包含的数据,data[i]=1,表示包含二维数组data[][]中的第i 条数据int leaf; int c; //leaf=1 正例叶节点；leaf=2 反例叶节点；leaf=0 不是节点//c=1 正类；c=0 反类DTNode *child[P+1]; //按属性值的个数建立子树};定义函数void Read_data() //从数据文件Data.txt 中读入训练数据DT_pointer Create_DT(DT_pointer Tree,int name,int value)//创建决策树int chose(int *da) //选择分类属性float Gain(int *da,int p) //计算以p 属性分类的期望熵float Entropy(int *da) //计算数据的熵int test_leaf(int *da) //测试节点属性void Out_DT(DT_pointer Tree) //用线性表形式输出建立的决策树int Class(int *da) //对输入的测试样本分类全局变量FILE *fp;int p_num; //属性的数量int pi[P_MAX+1]; //每一个属性有几种取值int d_num; //数据的数量int data[P_MAX+1][D_MAX+1];//存储训练数据三、程序不足1.、默认训练数据是正确的，对是否发生错误不予考虑2、没有考虑训练数据可以包含缺少属性值的实例3、只能分正反两类四、程序源码#include <iostream>#include <stdio.h>#include <malloc.h>#include <string.h>#include <math.h>#define P_MAX 10#define D_MAX 50#define P 5//一条数据包括所有属性的取值(1,2,3... )和分类的值(0 或者1) FILE *fp;int p_num; //属性的数量int pi[P_MAX+1]; //每一个属性有几种取值int d_num; //数据的数量int data[P_MAX+1][D_MAX+1];//存储训练数据//定义结点类型struct DTNode{int name; //此节点分类属性的名称int data[D_MAX+1]; //表示此节点包含的数据int leaf;叶节点int c; //leaf=1 正例叶节点；leaf=2 反例叶节点；leaf=0 不是//c=1 正类；c=0 反类DTNode *child[P+1]; //按属性值的个数建立子树};typedef struct DTNode *DT_pointer;DT_pointer DT = NULL;int root = 0;int test_leaf(int *da){int i;int a,b;a = 0; // a=0 表示没有0 类a=1 表示有0 类for(i = 1; i <= d_num; i++){if(*(da+i) ==1 && data[i][0] == 0){a = 1;break;}}b = 0; //b=0 表示没有1 类b=1 表示有1 类for(i = 1;i <= d_num;i++){if(*(da+i) == 1 && data[i][0] == 1){b = 1;break;}}if(a == 0 && b == 1)return 1; //是1 叶节点else if(a == 1 && b == 0)return 2; //是0 叶节点else if(a == 0 && b == 0)return 2; //此节点无数据elsereturn 0; }int test_c(int a) {if(a == 1)return 1;elsereturn 0; } //不是叶节点//给叶节点附属性值float Entropy(int *da) //计算数据的熵{int i;float t,f,s;float e;t = 0; //正例数量f = 0; //反例数量s = 0; //总数量for(i = 1; i <= d_num; i++){if(*(da+i) == 1){s = s + 1;if(data[i][0] == 1){t = t + 1;}elsef = f + 1;}}if(f == 0 || t == 0)return double(0);else{e = -(t/s)*log(t/s)-(f/s)*log(f/s);return e;}}float Gain(int *da,int p) //计算每一个属性的熵改变{float s,si;int i,j;int n;float ni;int ida[D_MAX+1];s = Entropy(da); //分类前的熵n = 0;for(i = 1; i <= d_num; i++){if(*(da+i) == 1)n++;}for(i = 1; i <= pi[p]; i++){si = 0; //计算每一个分支的熵ni = 0;for(j = 1; j <= d_num; j++){if(*(da+j) == 1 && data[j][p] == i){ida[j] = 1;ni = ni + 1;}elseida[j] = 0;}si = Entropy(ida);s = s - (ni/n)*si;}return s;}int chose(int *da) //选择分类属性{int i,r;float g,gi;g = 0;r = 0;for(i = 1; i <= p_num;i++){gi = Gain(da,i); //选择熵变化最大的if(gi > g){g = gi;r = i;}}return r;}DT_pointer Create_DT(DT_pointer Tree,int name,int value)//创建树{int i,j;DT_pointer T;//如果没有根节点建立根节点if(Tree == NULL){T= new DTNode;//全部数据都走到根节点for(i = 1;i <= d_num; i++){T->data[i] = 1;}//测试是不是叶节点即需不需要分类T->leaf = test_leaf(T->data);//是叶节点则不分类标明此节点的类别子树为空if(T->leaf > 0){T->c = test_c(T->leaf);T->name = 0;for(i = 0; i < P+1; i++){T->child[i] = NULL;}}//不是叶节点则选择分类的属性建立子树else{T->name = chose(T->data);for(i = 0; i < P+1; i++) //先全部设为空指针{T->child[i] = NULL;}for(j = 1; j<= pi[T->name]; j++) //根据属性的取值建立子树{T->child[j] = Create_DT(T,T->name,j);}}}else{T= new DTNode;//选出能走到此节点的数据for(i = 1; i <= d_num; i++){if(data[i][name] == value && Tree->data[i] == 1)T->data[i] = 1;elseT->data[i] = 0;}//测试是不是叶节点即需不需要分类T->leaf = test_leaf(T->data);//是叶节点则不分类标明此节点的类别子树为空if(T->leaf > 0){T->c = test_c(T->leaf);T->name = 0;for(i = 0; i < P+1; i++){T->child[i] = NULL;}}//不是叶节点则选择分类的属性建立子树else{T->name = chose(T->data);for(i = 0; i < P+1; i++) //先全部设为空指针{T->child[i] = NULL;}for(j = 1; j <= pi[T->name]; j++) //根据属性的取值建立子树{T->child[j] = Create_DT(T,T->name,j);}}}return T;}void Read_data() //从数据文件Data.txt 中读入训练数据{int i,j;if((fp=fopen("Data.txt","r")) != NULL) //读入数据{fscanf(fp,"%d%d",&d_num,&p_num); //读入数据数量和属性数量if(p_num>0 && d_num>0){for(i = 1; i <= p_num; i++) //读入每一个属性的取值{fscanf(fp,"%d",&pi[i]);}for(i = 1; i <= d_num; i++){for(j = 1; j <= p_num; j++){fscanf(fp,"%d",&data[i][j]);}fscanf(fp,"%d",&data[i][0]);}}elseprintf("Bad date!");}elseprintf("Can't find Data.txt!");printf("数据%d 组每组属性%d 个\n",d_num,p_num);printf("属性用1,2,3,4...表示，每种属性对应的取值个数为\n");for(i = 1; i <= p_num; i++){printf("%d\t",i);}printf("\n");for(i = 1; i <= p_num; i++){printf("%d\t",pi[i]);}printf("\n\n");printf("训练数据为\n");for(i = 1; i <= d_num; i++){for(j = 1; j <= p_num; j++){printf("%d ",data[i][j]);}printf("%d\n",data[i][0]);}printf("\n");}int Class(int *da){int a;DT_pointer T;T = DT;while(!(T->leaf)){a = *(da + T->name);T = T->child[a];}return T->c;}void Out_DT(DT_pointer Tree){printf("%d",Tree->name);int i;for(i = 1;i <= pi[Tree->name] ;i++){printf("(");Out_DT(Tree->child[i]);printf(")");}}int main(){int test_data[P+1];int j;int lei;Read_data();DT = Create_DT(NULL,0,0);printf("线性表形式输出决策树(0 为叶节点其他整数为分类属性) \n");Out_DT(DT);while(1){printf("请输入测试数据\n");//读入测试数据for(j = 1; j <= p_num; j++){scanf("%d",&test_data[j]);}lei = Class(test_data);if(lei)printf("此数据是正类\n");elseprintf("此数据是反类\n");}return 0;}。
决策树之ID3算法
决策树之ID3算法⼀、决策树之ID3算法简述 1976年-1986年，J.R.Quinlan给出ID3算法原型并进⾏了总结，确定了决策树学习的理论。
这可以看做是决策树算法的起点。
1993，Quinlan将ID3算法改进成C4.5算法，称为机器学习的⼗⼤算法之⼀。
ID3算法的另⼀个分⽀是CART(Classification adn Regression Tree, 分类回归决策树)，⽤于预测。
这样，决策树理论完全覆盖了机器学习中的分类和回归两个领域。
本⽂只做了ID3算法的回顾，所选数据的字段全部是有序多分类的分类变量。
C4.5和CART有时间另花篇幅进⾏学习总结。
本⽂需要有⼀定的pandas基础、了解递归函数。
1、ID3算法研究的核⼼思想是if-then，本质上是对数据进⾏分组操作。
下表是包含⽤户信息和购买决策的表。
这张表已经对1024个样本进⾏了分组统计。
依此为例解释if-then(决策)和数据分组。
对于第0条和第7条数据，唯⼀的区别是income不同，于是可以认为，此时income不具有参考价值，⽽应考察student值或reputation的信息。
于是：if-then定义了⼀套规则，⽤于确定各个分类字段包含的信息计算⽅法，以及确定优先按照哪个字段进⾏分类决策。
假如根据if-then，确定优先按照age对数据集进⾏拆分，那么可以确定三个⽔平(青年、中年、⽼年)对应的⼦数据集。
然后，继续对着三个⼦数据集分别再按照剩余的字段进⾏拆分。
如此循环直到除了购买决策之外的所有字段都被遍历。
你会发现，对于每个拆分的⼦数据集，根本不需要关注⾥⾯的值是汉字、字符串或数字，只需要关注有⼏个类别即可。
根据if-then的分类结果，对于⼀个样本，可以根据其各个字段的值和if-then规则来确定它最终属于下表哪个组。
决策树强调分组字段具有顺序性，认为字段层级关系是层层递进的；⽽我们直接看这张表时，所有字段都是并排展开的，存在于同⼀层级。
分类决策树_ID3算法(精华-理论加实例)
学生
否 否 否 否 是 是 是
信誉
良 优 良 良 良 优 优
归类：买计算机？
不买 不买 买 买 买 不买 买 学生？ 否 不买 是 买 买 优 不买 信誉？ 良 买 青
谁在买计算机？
年龄？ 老
中
128
64 132 64 32 32 63 1
青
青 老 青 中 中 老 老
中
低 中 中 中 高 中 中
否
是 是 是 否 是 否 否
分类任务的输入数据是纪录的集合，每条记录也称为实例 或者样例。用元组(X,y)表示，其中，X 是属性集合，y是一个 特殊的属性，指出样例的类标号（也称为分类属性或者目标属性）
第6章 决策树
关于分类问题
名称 人类 海龟 鸽子 鲸 体温 恒温 冷血 恒温 恒温 表皮覆 盖 毛发 鳞片 羽毛 毛发
决策树基本概念
1、Hunt,Marin和Stone 于1966年研制的CLS学习系统，用于学习单个概 念。 2、1979年, J.R. Quinlan 给出ID3算法，并在1983年和1986年对ID3 进行 了总结和简化，使其成为决策树学习算法的典型。 3、Schlimmer 和Fisher 于1986年对ID3进行改造，在每个可能的决策树 节点创建缓冲区，使决策树可以递增式生成，得到ID4算法。 4、1988年，Utgoff 在ID4基础上提出了ID5学习算法，进一步提高了效 率。 1993年，Quinlan 进一步发展了ID3算法，改进成C4.5算法。 5、另一类决策树算法为CART，与C4.5不同的是，CART的决策树由二 元逻辑问题生成，每个树节点只有两个分枝，分别包括学习实例的正 例与反例。
第6章 决策树
决策树算法
CLS算法