一步一步详解ID3和C4.5的C++实现

1. 关于ID3和C4.5的原理介绍这里不赘述,网上到处都是,可以下载讲义c9641_c001.pdf或者参考李航的《统计学习方法》.

2. 数据与数据处理

  • 本文采用下面的训练数据:

  • 数据处理:本文只采用了"Outlook", "Humidity", "Windy"三个属性,然后根据Humidity的值是否大于75,将Humidity的值归为两类,Play Golf 的值就是类别标签,只有yes 和 no两类
  • 训练集是字符和数字的混合,这会给编程带来麻烦,所以首先把训练集用数字表示出来:

     1 const unsigned att_num = 3;
     2 const unsigned rule_num = 14;
     3 string decision_tree_name("Play Golf ?");
     4 string attribute_names[] = {"Outlook", "Humidity", "Windy"};
     5 string attribute_values[] = {"Sunny", "Overcast", "Rainy", "> 75", "<= 75", "True", "False", "Yes", "No"};
     6 //训练集最后一列为分类标签,所以总列数为属性数加1
     7 unsigned train_data[rule_num][att_num + 1] = {
     8                     {0, 3, 6, 8},{0, 3, 5, 8},{1, 3, 6, 7},
     9                     {2, 3, 6, 7},{2, 3, 6, 7},{2, 4, 5, 8},
    10                     {1, 4, 5, 7},{0, 3, 6, 8},{0, 4, 6, 7},
    11                     {2, 3, 6, 7},{0, 4, 5, 7},{1, 3, 5, 7},
    12                     {1, 4, 6, 7},{2, 3, 5, 8}
    13                                 };

    以train_data的第一行{0, 3, 6, 8}为例解释:前三列值对应的属性与attribute_names中的元素分别对应,最后一列是类别标签的值,0 表示 attribute_values的第1个元素,即”Sunny“,类似3便是attribute_values的第4个元素"> 75",6 是 "False",8 是"No",所以{0, 3, 6, 8} 代表的实例就是:

    

    其他实例都是以这样的方式数字化,方便编程.

3. 编写必要函数

因为ID3和C4.5都需要计算属性的信息增益,C4.5还需要计算属性的信息增益比,所正确编写这两个函数很重要,对比着讲义c9641_c001.pdf或者其他参考资料,编写出这两个函数.(代码最后附上)

4. 确定数据结构

这是最重要的一环,明确目的:构造一个决策树!这就直接决定了编程的正确或者难易,网上有很多例子,但是我觉得不够简洁,这里我采用一种简单且容易理解的方式:

1 struct Tree{
2     unsigned root;//节点属性值
3     vector<unsigned> branches;//节点可能取值
4     vector<Node> children; //孩子节点
5 };

每一个决策树都是由根节点开始,然后有很多分支,分支连接着孩子节点,而每一个孩子节点以及这个孩子节点对应的所有子孙又可以组成一棵树,这是一个不断递归的过程,所以采用了上面的数据结构.

5. 构造决策树

有了上面的基础,开始着手构造决策树,根据规则选出某一属性作为根节点,根据根节点的取值确定分支,然后构造孩子节点,根据上面的陈述可以知道,每一个孩子节点及其后面的子孙又是一棵树,所以这是一个递归操作,即采用前面同样的方式来构造这个子树,以此类推。

6. 打印决策树

因为树的结构是递归的,所以打印决策树同样是一个递归的过程。

7. 代码实现

  1 /*************************************************
  2 Copyright:1.0
  3 Author:太白路上的小混混
  4 Date:2014-11-25
  5 Description:ID3/C4.5 algorithm
  6 **************************************************/
  7
  8 #include <iostream>
  9 #include <cmath>
 10 #include <vector>
 11 #include <string>
 12 #include <algorithm>
 13 using namespace std;
 14
 15
 16 const unsigned att_num = 3;
 17 const unsigned rule_num = 14;
 18 string decision_tree_name("Play Golf ?");
 19 string attribute_names[] = {"Outlook", "Humidity", "Windy"};
 20 string attribute_values[] = {"Sunny", "Overcast", "Rainy", "> 75", "<= 75", "True", "False", "Yes", "No"};
 21 //训练集最后一列为分类标签,所以总列数为属性数加1
 22 unsigned train_data[rule_num][att_num + 1] = {
 23                     {0, 3, 6, 8},{0, 3, 5, 8},{1, 3, 6, 7},
 24                     {2, 3, 6, 7},{2, 3, 6, 7},{2, 4, 5, 8},
 25                     {1, 4, 5, 7},{0, 3, 6, 8},{0, 4, 6, 7},
 26                     {2, 3, 6, 7},{0, 4, 5, 7},{1, 3, 5, 7},
 27                     {1, 4, 6, 7},{2, 3, 5, 8}
 28                                 };
 29
 30
 31
 32
 33 /*************************************************
 34 Function:       unique()
 35 Description:    将vector中重复元素合并,只保留一个
 36 Calls:          无
 37 Input:          vector
 38 Output:         vector
 39 *************************************************/
 40 template <typename T>
 41 vector<T> unique(vector<T> vals)
 42 {
 43     vector<T> unique_vals;
 44     vector<T>::iterator itr;
 45     vector<T>::iterator subitr;
 46
 47     int flag = 0;
 48     while( !vals.empty() )
 49     {
 50         unique_vals.push_back(vals[0]);
 51         itr = vals.begin();
 52         subitr = unique_vals.begin() + flag;
 53         while ( itr != vals.end())
 54         {
 55             if (*subitr == *itr)
 56                 itr = vals.erase(itr);
 57             else
 58                 itr++;
 59         }
 60         flag++;
 61     }
 62     return unique_vals;
 63 }
 64
 65 /*************************************************
 66 Function:       log2()
 67 Description:    计算一个数值得以2为底的对数
 68 Calls:          无
 69 Input:          double
 70 Output:         double
 71 *************************************************/
 72
 73 double log2(double n)
 74 {
 75     return log10(n) / log10(2.0);
 76 }
 77
 78 /*************************************************
 79 Function:       compute_entropy()
 80 Description:    根据属性的取值,计算该属性的熵
 81 Calls:          unique(),log2(),count(),其中count()
 82                 在STL的algorithm库中
 83 Input:          vector<unsigned>
 84 Output:         double
 85 *************************************************/
 86 double compute_entropy(vector<unsigned> v)
 87 {
 88     vector<unsigned> unique_v;
 89     unique_v = unique(v);
 90
 91     vector<unsigned>::iterator itr;
 92     itr = unique_v.begin();
 93
 94     double entropy = 0.0;
 95     auto total = v.size();
 96     while(itr != unique_v.end())
 97     {
 98         double cnt = count(v.begin(), v.end(), *itr);
 99         entropy -= cnt / total * log2(cnt / total);
100         itr++;
101     }
102     return entropy;
103 }
104
105 /*************************************************
106 Function:       compute_gain()
107 Description:    计算数据集中所有属性的信息增益
108 Calls:          compute_entropy(),unique()
109 Input:          vector<vector<unsigned> >
110                 相当于一个二维数组,存储着训练数据集
111 Output:         vector<double> 存储着所有属性的信息
112                 增益
113 *************************************************/
114 vector<double> compute_gain(vector<vector<unsigned> > truths)
115 {
116     vector<double> gain(truths[0].size() - 1, 0);
117     vector<unsigned> attribute_vals;
118     vector<unsigned> labels;
119     for(unsigned j = 0; j < truths.size(); j++)
120     {
121         labels.push_back(truths[j].back());
122     }
123
124     for(unsigned i = 0; i < truths[0].size() - 1; i++)//最后一列是类别标签,没必要计算信息增益
125     {
126         for(unsigned j = 0; j < truths.size(); j++)
127         attribute_vals.push_back(truths[j][i]);
128
129         vector<unsigned> unique_vals = unique(attribute_vals);
130         vector<unsigned>::iterator itr = unique_vals.begin();
131         vector<unsigned> subset;
132         while(itr != unique_vals.end())
133         {
134             for(unsigned k = 0; k < truths.size(); k++)
135             {
136                 if (*itr == attribute_vals[k])
137                 {
138                     subset.push_back(truths[k].back());
139                 }
140             }
141             double A = (double)subset.size();
142             gain[i] += A / rule_num * compute_entropy(subset);
143             itr++;
144             subset.clear();
145         }
146         gain[i] = compute_entropy(labels) - gain[i];
147         attribute_vals.clear();
148     }
149     return gain;
150 }
151
152 /*************************************************
153 Function:       compute_gain_ratio()
154 Description:    计算数据集中所有属性的信息增益比
155                 C4.5算法中用到
156 Calls:          compute_gain();compute_entropy()
157 Input:          训练数据集
158 Output:         信息增益比
159 *************************************************/
160 vector<double> compute_gain_ratio(vector<vector<unsigned> > truths)
161 {
162     vector<double> gain = compute_gain(truths);
163     vector<double> entropies;
164     vector<double> gain_ratio;
165
166     for(unsigned i = 0; i < truths[0].size() - 1; i++)//最后一列是类别标签,没必要计算信息增益比
167     {
168         vector<unsigned> attribute_vals(truths.size(), 0);
169         for(unsigned j = 0; j < truths.size(); j++)
170         {
171             attribute_vals[j] = truths[j][i];
172         }
173         double current_entropy = compute_entropy(attribute_vals);
174         if (current_entropy)
175         {
176             gain_ratio.push_back(gain[i] / current_entropy);
177         }
178         else
179             gain_ratio.push_back(0.0);
180
181     }
182     return gain_ratio;
183 }
184
185 /*************************************************
186 Function:       find_most_common_label()
187 Description:    找出数据集中最多的类别标签
188
189 Calls:          count();
190 Input:          数据集
191 Output:         类别标签
192 *************************************************/
193 template <typename T>
194 T find_most_common_label(vector<vector<T> > data)
195 {
196     vector<T> labels;
197     for (unsigned i = 0; i < data.size(); i++)
198     {
199         labels.push_back(data[i].back());
200     }
201     vector<T>:: iterator itr = labels.begin();
202     T most_common_label;
203     unsigned most_counter = 0;
204     while (itr != labels.end())
205     {
206         unsigned current_counter = count(labels.begin(), labels.end(), *itr);
207         if (current_counter > most_counter)
208         {
209             most_common_label = *itr;
210             most_counter = current_counter;
211         }
212         itr++;
213     }
214     return most_common_label;
215 }
216
217 /*************************************************
218 Function:       find_attribute_values()
219 Description:    根据属性,找出该属性可能的取值
220
221 Calls:          unique();
222 Input:          属性,数据集
223 Output:         属性所有可能的取值(不重复)
224 *************************************************/
225 template <typename T>
226 vector<T> find_attribute_values(T attribute, vector<vector<T> > data)
227 {
228     vector<T> values;
229     for (unsigned i = 0; i < data.size(); i++)
230     {
231         values.push_back(data[i][attribute]);
232     }
233     return unique(values);
234 }
235
236 /*************************************************
237 Function:       drop_one_attribute()
238 Description:    在构建决策树的过程中,如果某一属性已经考察过了
239                 那么就从数据集中去掉这一属性,此处不是真正意义
240                 上的去掉,而是将考虑过的属性全部标记为110,当
241                 然可以是其他数字,只要能和原来训练集中的任意数
242                 字区别开来即可
243 Calls:          unique();
244 Input:          属性,数据集
245 Output:         属性所有可能的取值(不重复)
246 *************************************************/
247 template <typename T>
248 vector<vector<T> > drop_one_attribute(T attribute, vector<vector<T> > data)
249 {
250     vector<vector<T> > new_data(data.size(),vector<T>(data[0].size() - 1, 0));
251     for (unsigned i = 0; i < data.size(); i++)
252     {
253         data[i][attribute] = 110;
254     }
255     return data;
256 }
257
258
259 struct Tree{
260     unsigned root;//节点属性值
261     vector<unsigned> branches;//节点可能取值
262     vector<Tree> children; //孩子节点
263 };
264
265 /*************************************************
266 Function:       build_decision_tree()
267 Description:    递归构建决策树
268
269 Calls:          unique(),count(),
270                 find_most_common_label()
271                 compute_gain()(ID3),
272                 compute_gain_ratio()(C4.5),
273                 find_attribute_values(),
274                 drop_one_attribute(),
275                 build_decision_tree()(递归,
276                 当然要调用函数本身)
277 Input:          训练数据集,一个空决策树
278 Output:         无
279 *************************************************/
280 void build_decision_tree(vector<vector<unsigned> > examples, Tree &tree)
281 {
282     //第一步:判断所有实例是否都属于同一类,如果是,则决策树是单节点
283     vector<unsigned> labels(examples.size(), 0);
284     for (unsigned i = 0; i < examples.size(); i++)
285     {
286         labels[i] = examples[i].back();
287     }
288     if (unique(labels).size() == 1)
289     {
290         tree.root = labels[0];
291         return;
292     }
293
294     //第二步:判断是否还有剩余的属性没有考虑,如果所有属性都已经考虑过了,
295     //那么此时属性数量为0,将训练集中最多的类别标记作为该节点的类别标记
296     if (count(examples[0].begin(),examples[0].end(),110) == examples[0].size() - 1)//只剩下一列类别标记
297     {
298         tree.root = find_most_common_label(examples);
299         return;
300     }
301     //第三步:在上面两步的条件都判断失败后,计算信息增益,选择信息增益最大
302     //的属性作为根节点,并找出该节点的所有取值
303
304     vector<double> standard = compute_gain(examples);
305
306     //要是采用C4.5,将上面一行注释掉,把下面一行的注释去掉即可
307     //vector<double> standard = compute_gain_ratio(examples);
308     tree.root = 0;
309     for (unsigned i = 0; i < standard.size(); i++)
310     {
311         if (standard[i] >= standard[tree.root] && examples[0][i] != 110)
312             tree.root  = i;
313     }
314
315
316     tree.branches = find_attribute_values(tree.root, examples);
317     //第四步:根据节点的取值,将examples分成若干子集
318     vector<vector<unsigned> > new_examples = drop_one_attribute(tree.root, examples);
319     vector<vector<unsigned> > subset;
320     for (unsigned i = 0; i < tree.branches.size(); i++)
321     {
322         for (unsigned j = 0; j < examples.size(); j++)
323         {
324             for (unsigned k = 0; k < examples[0].size(); k++)
325             {
326                 if (tree.branches[i] == examples[j][k])
327                     subset.push_back(new_examples[j]);
328             }
329         }
330         // 第六步:对每一个子集递归调用build_decision_tree()函数
331         Tree new_tree;
332         build_decision_tree(subset,new_tree);
333         tree.children.push_back(new_tree);
334         subset.clear();
335     }
336 }
337
338 /*************************************************
339 Function:       print_tree()
340 Description:    从第根节点开始,逐层将决策树输出到终
341                 端显示
342
343 Calls:          print_tree();
344 Input:          决策树,层数
345 Output:         无
346 *************************************************/
347 void print_tree(Tree tree,unsigned depth)
348 {
349     for (unsigned d = 0; d < depth; d++) cout << "\t";
350     if (!tree.branches.empty()) //不是叶子节点
351     {
352         cout << attribute_names[tree.root] << endl;
353
354         for (unsigned i = 0; i < tree.branches.size(); i++)
355         {
356             for (unsigned d = 0; d < depth + 1; d++) cout << "\t";
357             cout << attribute_values[tree.branches[i]] << endl;
358             print_tree(tree.children[i],depth + 2);
359         }
360     }
361     else //是叶子节点
362     {
363         cout << attribute_values[tree.root] << endl;
364     }
365
366 }
367
368
369 int main()
370 {
371     vector<vector<unsigned> > rules(rule_num, vector<unsigned>(att_num + 1, 0));
372     for(unsigned i = 0; i < rule_num; i++)
373     {
374         for(unsigned j = 0; j <= att_num; j++)
375             rules[i][j] = train_data[i][j];
376     }
377     Tree tree;
378     build_decision_tree(rules, tree);
379     cout << decision_tree_name << endl;
380     print_tree(tree,0);
381     return 0;
382 }

8.运行结果:

前者是采用ID3运行的结果,后者是讲义c9641_c001.pdf给出的构造的决策树,二者一致,验证了程序的正确性.

9.总结

所谓”百鸟在林,不如一鸟在手“, ID3和C4.5的思想都很简单,容易理解,但是在实现的的过程中由于数据结构的确定和递归调用等问题,还是调试了很久,收获很多,实践出真知!

时间: 2024-11-08 22:16:26

一步一步详解ID3和C4.5的C++实现的相关文章

Jfinal源码详解

JFinal的框架我24号的一篇博文写到过,它优秀的地方在精简代码上,那么有两处源码是我觉得是值得我们要好好解析一下,一处是初始化加载—servlet跳转,另一处是DB+ActiveRecord的映射. 那么DB映射相对比较简单,我们这次就先来看看. 首先我们看看代码,还是之前我写过的 dog与cat的故事. // 采用DB+ActiveRecord模式 ActiveRecordPlugin arp = new ActiveRecordPlugin(c3p0Plugin); me.add(arp

一步一步学ios UITextView(多行文本框)控件的用法详解(五5.8)

本文转载至 http://wuchaorang.2008.blog.163.com/blog/static/48891852201232014813990/ 1.创建并初始化 创建UITextView的文件,并在.h文件中写入如下代码: [csharp] view plaincopy #import <UIKit/UIKit.h> @interface TextViewController : UIViewController <UITextViewDelegate> { UITe

一步一步学会puppet(五)--配置文件和常用命令详解

这篇博文主要解析了puppet的配置文件和常用命令,以备以后查阅: =================================================================== 1 配置文件 1.1 组织结构 2 常用命令 2.1 常用命令 2.2 各类命令详解 2.3 帮助类命令 =================================================================== 1 配置文件 1.1 组织结构 配置文件位于/etc/

一步一步造个Ioc轮子(二),详解泛型工厂

一步一步造个Ioc轮子目录 .net core发布了,一步一步造个Ioc轮子,弄点.net魔法,近new的速度(一) 一步一步造个Ioc轮子(二),详解泛型工厂 详解泛型工厂 既然我说Ioc容器就是一个豪华版工厂,自动化装配的工厂,那我们就从工厂入手吧,先造个工厂,然后升级成Ioc容器 首先我们来写一个最最最简单的抽象工厂类,还是以前一篇的短信为例 public class SMSFactory { public static ISMS Get() { return new XSMS(); }

“makefile”写法详解,一步一步写一个实用的makefile,详解 sed &#39;s,$?\.o[ :]*,\1.o [email&#160;protected] : ,g&#39; &lt; [email&#160;protected]

目的:编写一个实用的makefile,能自动编译当前目录下所有.c/.cpp源文件,支持二者混合编译.并且当某个.c/.cpp..h或依赖的源文件被修改后,仅重编涉及到的源文件,未涉及的不编译. 二要达到这个目的,用到的技术有:1-使用wildcard函数来获得当前目录下所有.c/.cpp文件的列表.2-make的多目标规则.3-make的模式规则.4-用gcc -MM命令得到一个.c/.cpp文件include了哪些文件.5-用sed命令对gcc -MM命令的结果作修改.6-用include命

webpack4配置详解之一步一步跟我做

前言 经常会有群友问起webpack.react.redux.甚至create-react-app配置等等方面的问题,有些是我也不懂的,慢慢从大家的相互交流中,也学到了不少. ? 今天就尝试着一起来聊聊Webpack吧,旨在帮大家加深理解.新手更容易上路,都能从0到1搭建配置自定属于自己的脚手架,或对已封装好的脚手架有进一步的巩固,接下来苏南会详细讲解webpack中的每一个配置字段的作用(部分为webpack4新增). 近两年,前端一直在以一个高速持续的过程发展,常常会有网友在调侃老了.学不动

【Devops】【docker】【CI/CD】关于jenkins构建成功后一步,执行的shell命令详解

1.展示这段shell命令 #===================================================================================== #=================================定义初始化变量====================================== #====================================================================

【Linux】一步一步学Linux——Linux系统目录详解(09)

目录 00. 目录 01. 文件系统介绍 02. 常用目录介绍 03. /etc目录文件 04. /dev目录文件 05. /usr目录文件 06. /var目录文件 07. /proc 08. 比较重要的一些目录 09. 参考 00. 目录 [Linux]一步一步学Linux系列教程:https://blog.csdn.net/dengjin20104042056/article/details/94669639 01. 文件系统介绍 Win和Linux文件系统区别 (了解) 在 window

机器学习经典算法详解及Python实现--CART分类决策树、回归树和模型树

摘要: Classification And Regression Tree(CART)是一种很重要的机器学习算法,既可以用于创建分类树(Classification Tree),也可以用于创建回归树(Regression Tree),本文介绍了CART用于离散标签分类决策和连续特征回归时的原理.决策树创建过程分析了信息混乱度度量Gini指数.连续和离散特征的特殊处理.连续和离散特征共存时函数的特殊处理和后剪枝:用于回归时则介绍了回归树和模型树的原理.适用场景和创建过程.个人认为,回归树和模型树