决策树分类器+C代码

关于决策树的理解和计算过程，http://www.tuicool.com/articles/3EZJBz  这篇文章上有很详细的介绍。

就我完成决策树代码的一些步骤进行介绍：（ID3算法）

1. 获取样本，计算样本的增益值，选择增益值最大的作为下一步分支的根节点；

2. 将被选中的样本属性删除（我这里是将该属性列的值设置为99，即认为删除）；

3. 对被选中的属性列中的子属性进行分类：如：在本例代码中，最先被选中的属性为outlook，将outlook中的子属性：sunny，overcast，rain分为三类s1，s2，s3；

4. 对s1，s2，s3分别进行递归，即将分别以s1，s2，s3为样本执行步骤1；

5. 递归结束的标志为：当前样本全为反例，即全为NO，输出NO并return；或 当前样本全为正例，即全为yes，输出yes并return；当前分支结束遍历。

递归的算法还是很容易编写的，难的是如何找到它的遍历路径和子属性的选择，本例代码在路径记录和选择输出上我感觉不是很完美和正确，希望大家多提提意见和纠正代码的不足。

本代码用例如下：

根据上述表格，对应得到以下数据：

0 0 0 0 0
0 0 0 1 0
1 0 0 0 1
2 1 0 0 1
2 2 1 0 1
2 2 1 1 0
1 2 1 1 1
0 1 0 0 0
0 2 1 0 1
2 1 1 0 1
0 1 1 1 1
1 1 1 1 1
1 0 1 0 1
2 1 0 1 0

c语言代码如下：

#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "string.h"
#include "vector"
using namespace std;


#define INF 99
#define dimNum 5  //样本维数
typedef vector<int> intVector;
vector<intVector> getFileInf(char *File);   //获取样本
void ID3(vector<intVector> sample);   //ID3决策树开始引擎
intVector getYESorNOnum(vector<intVector> sample);   //获取去和不去的数量
vector<double> getEntropy(vector<intVector> sample);  //获取各信息熵
int getGainLaber(double HD, vector<double> Entropy, int num);  //获取增益值最大处的位置
void Iter(vector<intVector> sample, int laber);  //开始迭代
void output();  //路径输出
void save();  //保存路径


struct pathInf
{
int att;    //属性类别
int num;    //使用的属性
int ID;     //调用的顺序
int r;      //结果
};


pathInf path[dimNum];
int ID = 1;
int result;
typedef vector<pathInf> pathVector;
vector<pathVector> savePath;


void main()
{
int i;
vector<intVector> sample;
char *File = "样本.txt";


//初始化路径
for(i=0; i<dimNum-1; i++)
{
path[i].att = INF;
path[i].num = INF;
path[i].ID = INF;
}


printf("天气  温度  湿度  风力   Y/N  （注：99表示未考虑。）\n");
sample = getFileInf(File);
ID3(sample);


output();


}




//ID3决策树开始引擎
void ID3(vector<intVector> sample)
{
int i, j;
intVector yesORno = getYESorNOnum(sample);
vector<double> Entropy;
double HD_Entropy;

if(yesORno.at(0)==0)
{
printf("样本全为不去!!!\n");
exit(0);
}


if(yesORno.at(1)==0)
{
printf("样本全为去!!!\n");
exit(0);
}


HD_Entropy = -((double)yesORno.at(0)/sample.size()) *log10((double)yesORno.at(0)/sample.size())/log10(2) 
  - ((double)yesORno.at(1)/sample.size()) *log10((double)yesORno.at(1)/sample.size())/log10(2);




Entropy = getEntropy(sample);


int laber = getGainLaber(HD_Entropy, Entropy, 0);   //最大增益值所对应的列


Iter(sample, laber);  //开始迭代


}




//迭代函数
void Iter(vector<intVector> sample, int laber)
{
int i, j;
intVector temp;
intVector YorN;
intVector yesORno = getYESorNOnum(sample);
vector<double> Entropy;
double HD_Entropy;
vector<intVector> samp0, samp1, samp2;
int laber0;


if(yesORno[0]==0)
{
result = 0;
save();
return;
}


if(yesORno[1]==0)
{
result = 1;
save();
return;
}




//进行分支
for(i=0; i<sample.size(); i++)
{
if (sample[i][laber]==0)
{
temp = sample[i];
temp[laber] = INF;
samp0.push_back(temp);
}

if (sample[i][laber]==1)
{
temp = sample[i];
temp[laber] = INF;
samp1.push_back(temp);
}

if (sample[i][laber]==2)
{
temp = sample[i];
temp[laber] = INF;
samp2.push_back(temp);
}
}


if(samp0.size()!=0)
{
YorN = getYESorNOnum(samp0);

HD_Entropy = -((double)YorN.at(0)/samp0.size()) *log10((double)YorN.at(0)/samp0.size())/log10(2) 
- ((double)YorN.at(1)/samp0.size()) *log10((double)YorN.at(1)/samp0.size())/log10(2);


Entropy = getEntropy(samp0);

laber0 = getGainLaber(HD_Entropy, Entropy, 0);   //最大增益值所对应的列


Iter(samp0, laber0);
}


if(samp1.size()!=0)
{
YorN = getYESorNOnum(samp1);

HD_Entropy = -((double)YorN.at(0)/samp1.size()) *log10((double)YorN.at(0)/samp1.size())/log10(2) 
- ((double)YorN.at(1)/samp1.size()) *log10((double)YorN.at(1)/samp1.size())/log10(2);


Entropy = getEntropy(samp1);

laber0 = getGainLaber(HD_Entropy, Entropy, 1);   //最大增益值所对应的列

Iter(samp1, laber0);
}


if(samp2.size()!=0)
{
YorN = getYESorNOnum(samp2);

HD_Entropy = -((double)YorN.at(0)/samp2.size()) *log10((double)YorN.at(0)/samp2.size())/log10(2) 
- ((double)YorN.at(1)/samp2.size()) *log10((double)YorN.at(1)/samp2.size())/log10(2);


Entropy = getEntropy(samp2);

laber0 = getGainLaber(HD_Entropy, Entropy, 2);   //最大增益值所对应的列

Iter(samp2, laber0);
}

}


//获取增益值
int getGainLaber(double HD, vector<double> Entropy, int num)
{
int i, l=0;
int laber;
double max;
vector<double> Gain;
for(i=0; i<Entropy.size(); i++)
Gain.push_back(HD-Entropy[i]);

max = Gain[0];
for(i=1; i<Gain.size(); i++)
if(max<Gain[i])
{
max = Gain[i];
l=i;
}



for(i=0; i<Entropy.size(); i++)
if(Entropy[i]>10 && path[i].att==INF)
{
path[i].att = i;
path[i].ID = ID;
path[i].num = num;
ID++;
}


return l;
}




//获取去和不去的数量
intVector getYESorNOnum(vector<intVector> sample)
{
int i;
intVector dst;
int yesNum=0;
int noNum=0;


for(i=0; i<sample.size(); i++)
{
if(sample[i][sample[0].size()-1]==1)
yesNum++;
else
noNum++;
}


dst.push_back(yesNum);
dst.push_back(noNum);


return dst;
}




//获取各信息熵
vector<double> getEntropy(vector<intVector> sample)
{
vector<double> Entropy;
int i, j;
int temp1, temp11, temp12;
int temp2, temp21, temp22;
int temp3, temp31, temp32;
double H1, H2, H3;


for(i=0; i<sample[0].size()-1; i++)
{
H1=H2=H3=0;
temp1 = temp11 = temp12 = temp2 = temp21 = temp22 = temp3 = temp31 = temp32 = 0;
for(j=0; j<sample.size(); j++)
{
//第1种情况
if(sample[j][i]==0)   
{
temp1++;
if(sample[j][i]==0 && sample[j][sample[0].size()-1]==1)  //第1种情况下yes
temp11++;

if(sample[j][i]==0 && sample[j][sample[0].size()-1]==0)  //第1种情况下NO
temp12++;
}


//第2种情况
if(sample[j][i]==1)   
{
temp2++;
if(sample[j][i]==1 && sample[j][sample[0].size()-1]==1)  //第2种情况下yes
temp21++;

if(sample[j][i]==1 && sample[j][sample[0].size()-1]==0)  //第2种情况下NO
temp22++;
}


//第3种情况
if(sample[j][i]==2)   
{
temp3++;
if(sample[j][i]==2 && sample[j][sample[0].size()-1]==1)  //第3种情况下yes
temp31++;

if(sample[j][i]==2 && sample[j][sample[0].size()-1]==0)  //第3种情况下NO
temp32++;
}
}


//计算信息熵
if(temp1!=0)
{
if(temp11==0 || temp12==0)
H1 = 0;
else
H1 = -((double)temp11/temp1)*log10((double)temp11/temp1)/log10(2) - ((double)temp12/temp1)*log10((double)temp12/temp1)/log10(2);
}


if(temp2!=0)
{
if(temp21==0 || temp22==0)
H2 = 0;
else
H2 = -((double)temp21/temp2)*log10((double)temp21/temp2)/log10(2) - ((double)temp22/temp2)*log10((double)temp22/temp2)/log10(2);
}


if(temp3!=0)
{
if(temp31==0 || temp32==0)
H3 = 0;
else
H3 = -((double)temp31/temp3)*log10((double)temp31/temp3)/log10(2) - ((double)temp32/temp3)*log10((double)temp32/temp3)/log10(2);
}


if(sample[0][i]==99)
Entropy.push_back(99);
else
Entropy.push_back(((double)temp1/sample.size())*H1 +((double)temp2/sample.size())*H2 +((double)temp3/sample.size())*H3);


}


return Entropy;
}




//获取样本
vector<intVector> getFileInf(char *File)
{
int i=1;
int num;
vector<intVector> samlpe;
intVector temp;

FILE *fp = fopen(File, "r");

if(fp==NULL)
{
printf("Open file error!\n");
exit(0);
}

while(fscanf(fp, "%d", &num)!=EOF)
{
temp.push_back(num);
if(i%dimNum==0)
{
samlpe.push_back(temp);
temp.clear();
}
i++;
}

return samlpe;
}




//保存路径
void save()
{
pathVector temp;
pathInf swp;
int i, j, l;
int min;
ID = 1;


for(i=0; i<dimNum-1; i++)
{
l=i;
min = path[i].ID;
for(j=i+1; j<dimNum-1; j++)
if(min>path[j].ID)
{
min = path[j].ID;
l = j;
}
swp = path[i];
path[i] = path[l];
path[l] = swp;
}


path[dimNum-2].r = result;


for(i=0; i<dimNum-1; i++)
temp.push_back(path[i]);


savePath.push_back(temp);
temp.clear();


for(i=0; i<dimNum-1; i++)
{
path[i].att = INF;
path[i].num = INF;
path[i].ID = INF;
}

}




//结果输出
void output()
{
int i, j;
int root;
int maxPro;
int Pro[dimNum] = {0};  //优先级


intVector temp(dimNum, INF);
vector<intVector> saveResult(savePath.size(), temp);


for(i=0; i<dimNum; i++)
for(j=0; j<dimNum; j++)
saveResult[i][j] = INF;

//计算优先级的大小
for(i=0; i<savePath.size(); i++)
{
for(j=0; j<dimNum-1; j++)
{
if(savePath[i][j].att==INF)
continue;
Pro[savePath[i][j].att] += abs(j-dimNum);  //累加值越大，说明该节点越深
}
}




//训练结果
for(i=0; i<savePath.size(); i++)
{
for(j=0; j<dimNum-1; j++)
{
if(savePath[i][j].att == INF)
break;


if(j==0)
saveResult[i][savePath[i][j].att] = savePath[i][j].num;


if(j>0)
{ //因为程序是递归的，根据节点深度确定程序的遍历顺序和当前节点所处的节点位置，判断当前子树是否遍历完成
if(Pro[savePath[i][j].att] > Pro[savePath[i][j-1].att])
saveResult[i][savePath[i][j].att] = saveResult[i-1][savePath[i][j].att];
else
saveResult[i][savePath[i][j].att] = savePath[i][j].num;
}
}
saveResult[i][dimNum-1] = savePath[i][dimNum-2].r;
}




//结果输出
for(i=0; i<saveResult.size(); i++)
{
for(j=0; j<dimNum; j++)
printf("%4d  ", saveResult[i][j]);
printf("\n");
}
}

运行结果如下：