随机森林代码注释（C++版本）

最新推荐文章于 2024-06-12 19:16:01 发布
最新推荐文章于 2024-06-12 19:16:01 发布
阅读量7.7k 收藏 31
点赞数 1
分类专栏： 机器学习 人脸检测

1. 随机森林

随机森林属于非传统式的机器学习算法，由多颗决策树组成，每棵决策树处理的是一个训练样本子集。训练阶段，通过决策树的节点分裂来筛选特征，层层对样本进行细分，直至将每个训练样本子集分类正确，测试阶段，直接基于训练出的特征进行样本分类，所以测试速度较快（但训练速度较慢）。属于“傻瓜式”的策略（这点和adaboost很像很像），以下部分是标准随机森林训练阶段的大致流程。

1. 假如有N个样本，则有放回的随机选择N个样本(每次随机选择一个样本，然后返回继续选择)。这选择好了的N个样本用来训练一个决策树，作为决策树根节点处的样本。

2. 当每个样本有M个属性时，在决策树的每个节点需要分裂时，随机从这M个属性中选取出m个属性，满足条件m << M。然后从这m个属性中采用某种策略（比如说信息增益）来选择1个属性作为该节点的分裂属性。

3. 决策树形成过程中每个节点都要按照步骤2来分裂，一直到不能够再分裂为止（就是收敛）。所谓不能再分裂，就是全部到达叶子节点，如果下一次该节点选出来的那一个属性是刚刚其父节点分裂时用过的属性，则该节点就是叶子节点。

4. 按照步骤1~3建立大量的决策树，便构成了随机森林。


从上面的步骤可以看出，随机森林的随机性体现在每颗数的训练样本是随机的，树中每个节点的分类属性也是随机选择的。有了这2个随机的保证，随机森林就不会产生过拟合的现象了。

值得注意的是，随机森林的基本思想都一样，但是在细节上却有所不同，尤其是在节点分裂所采用规则，叶子节点确定那里，有着很多种变种，也就具有不同的效果。说一个我自己遇到的，在确定叶子节点那块，它不是采用属性和父节点一致来确定，而是属性为空来确定，因为它在每一个节点选择一个属性之后，都会将该属性从候选属性集中删除，这样就会造成叶子节点候选属性集为空的情况。

2. 代码(随机森林代码注释)

</pre><pre name="code"class="cpp">#include <iostream>

#include <fstream>

#include <sstream>

#include "random_forest.h"

 

using namespace std;

 

vector<decision_tree*>  alltrees;               // 森林（决策树集合）

vector<TupleData>       trainAll,train,test; // 样本集

vector<int>                  attributes;            // 属性集（元素为属性序号）

 

int                     trainAllNum = 0;      

int                     testAllNum  = 0;      

int                     MaxAttr;             // 属性总数

int                     *ArrtNum;               // 属性个数集（元素为属性最大值）

unsigned int            F;

int                     tree_num    = 100;     // 决策树个数

const int               leafattrnum = -1;       // 叶子节点的属性序号

int                     TP          = 0,

                        FN          = 0,

                        FP          = 0,

                        TN          = 0,

                        TestP       = 0,

                        TestN       = 0;

 

// 读入数据

void init(char * trainname, char * testname)

{

   trainAllNum     =readData(trainAll, trainname);

   testAllNum      = readData(test,testname);

   calculate_attributes();

   double temp     =(double)trainAllNum;

   temp            =log(temp)/log(2.0);

   F               = (unsigned int)floor(temp+0.5)+1;

   if(F>MaxAttr) F = MaxAttr;

}

 

// 初始化训练样本子集

void sub_init()

{

   // 选取决策树的训练样本集合

   RandomSelectData(trainAll, train);

 

   // 计算样本属性个数

   calculate_ArrtNum();

}

 

// 读数据

int readData(vector<TupleData>&data, const char* fileName)

{

   ifstream fin;

   fin.open(fileName);

   string line;

 

   int datanum=0;

 

   // 每行数据作为一个样本

   while(getline(fin,line))

   {

       TupleData d;

       istringstream stream(line);

       string str;

 

       // 设置每个样本的标签和内容

       while(stream>>str)

       {

           if(str.find('+')==0)

           {

                d.label='+';

           }

           else if(str.find('-')==0)

           {

                d.label='-';

           }

           else

           {

                int j=stringtoint(str);

                d.A.push_back(j);

           }

       }

 

       data.push_back(d);

       datanum++;

   }

 

   fin.close();

   return datanum;

}

 

// 生成根节点的训练样本子集

voidRandomSelectData(vector<TupleData> &data, vector<TupleData>&subdata)

{

   int index;

   subdata.clear();

   int d = 0;

   while (d < trainAllNum)

   {

       index = rand() % trainAllNum;

       subdata.push_back(data.at(index));

       d++;

   }

}

 

// 计算属性序列

void calculate_attributes()

{

   // 每个样本必须具有相同的属性个数

   TupleData d = trainAll.at(0);

   MaxAttr = d.A.size();

   attributes.clear();

 

   // 建立属性集合attributes,元素为属性序号

   for (int i = 0; i < MaxAttr; i++)

   {

       attributes.push_back(i);

   }

 

   // 初始化属性最大值序列，元素为属性最大值

   ArrtNum = new int[MaxAttr];

}

 

// 字符串转化为int

int stringtoint(string s)

{

   int sum=0;

   for(int i=0; s[i]!='\0';i++)

   {

       int j=int(s[i])-48;

       sum=sum*10+j;

   }

   return sum;

}

 

// 计算ArrtNum元素值

void calculate_ArrtNum()

{

   for(int i = 0; i < MaxAttr; i++) ArrtNum[i] = 0;

 

   // ArrtNum元素值为属性最大值

   for (vector<TupleData>::const_iterator it = train.begin(); it !=train.end(); it++)

   {

       int i = 0;

 

       for (vector<int>::const_iterator intt=(*it).A.begin();intt!=(*it).A.end();intt++)

       {

           int valuemax=(*intt)+1;

           if(valuemax>ArrtNum[i]) ArrtNum[i]=valuemax;

           i++;

       }

   }

}

 

// 计算熵

double Entropy(double p, double s)

{

   double n = s - p;

   double result = 0;

   if (n != 0)

       result += - double(n) / s * log(double(n) / s) / log(2.0);

   if (p != 0)

       result += double(-p) / s * log(double(p) / s) / log(2.0);

   return result;

}

 

// 训练一棵决策树

int creat_classifier(decision_tree*&p, const vector<TupleData> &samples, vector<int>&attributes)

{

   if (p == NULL)

       p = new decision_tree();

 

   // 根据样本真实类别，输出叶子节点类别

   if (Allthesame(samples, '+'))

   {

       p->node.label = '+';

       p->node.attrNum = leafattrnum;

       p->childs.clear();

       return 1;

   }

   if (Allthesame(samples, '-'))

   {

       p->node.label = '-';

       p->node.attrNum = leafattrnum;

       p->childs.clear();

       return 1;

   }

   // 如果属性序列为空，当前节点就为叶子节点

   if (attributes.size() == 0)

   {

       p->node.label = Majorityclass(samples);

       p->node.attrNum = leafattrnum;

       p->childs.clear();

       return 1;

   }

 

   // 计算当前节点的最优属性

   p->node.attrNum = BestGainArrt(samples, attributes);

 

   // 中间节点无标签

   p->node.label = ' ';

 

   // 计算子节点候选属性集合，候选集合元素越来越少

   vector<int> newAttributes;

   for (vector<int>::iterator it = attributes.begin(); it !=attributes.end(); it++)

       if ((*it) != p->node.attrNum)

           newAttributes.push_back((*it));

 

   // 初始化样本子集，建立maxvalue个样本子集，也就说明该节点有maxvalue个子节点

   // 为什么不建立一个阈值，进行二分类？

   int maxvalue = ArrtNum[p->node.attrNum];

   vector<TupleData>* subSamples = newvector<TupleData>[maxvalue];

   for (int i = 0; i < maxvalue; i++)

       subSamples[i].clear();

 

   // 将样本集合分为样本子集

   for (vector<TupleData>::const_iterator it = samples.begin(); it !=samples.end(); it++)

   {

       // 对样本进行分类，分别分到maxvalue个子节点中

       // p->node.attrNum是当前节点的最优属性序号

       // (*it).A.at(p->node.attrNum)正是子节点的序号

       // 基于当前节点最优属性，计算当前样本的归类

       subSamples[(*it).A.at(p->node.attrNum)].push_back((*it));

   }

 

   decision_tree *child;

   for (int i = 0; i < maxvalue; i++)

   {

       child = new decision_tree;

 

       if (subSamples[i].size() == 0)

           child->node.label = Majorityclass(samples);

       else

           creat_classifier(child, subSamples[i], newAttributes);

 

       p->childs.push_back(child);

   }

   delete[] subSamples;

   return 0;

}

 

// 计算节点处的信息增益

int BestGainArrt(constvector<TupleData> &samples, vector<int> &attributes)

{

   int attr,

       bestAttr = 0,

       p = 0,

       s = (int)samples.size();

 

   // 计算正样本个数

   for (vector<TupleData>::const_iterator it = samples.begin(); it !=samples.end(); it++)

   {

       if ((*it).label == '+')

           p++;

   }

 

   double infoD;

   double bestResult = 0;

 

   // 计算初始熵

   infoD = Entropy(p, s);

 

   vector<int> m_attributes;

 

   // 随机确定候选属性集

   RandomSelectAttr(attributes, m_attributes);

 

   // 遍历属性（即主题），通过信息增益筛选最优属性

   for (vector<int>::iterator it = m_attributes.begin(); it !=m_attributes.end(); it++)

   {

       attr            = (*it);

       double result   = infoD;

 

       // 第attr个属性的最大属性值

       int maxvalue    = ArrtNum[attr];

 

       // 正负样本集

       int* subN       = newint[maxvalue];

       int* subP       = newint[maxvalue];

       int* sub        = newint[maxvalue];

 

       for (int i = 0; i < maxvalue; i++)

       {

           subN[i] = 0;

           subP[i] = 0;

           sub[i]  = 0;

       }

 

       // 基于特定属性，对当前训练样本进行分类

       // 属性计算这一步的确没有，属性值直接存储在样本中

       for (vector<TupleData>::const_iterator jt = samples.begin(); jt !=samples.end(); jt++)

       {

           if ((*jt).label == '+')

                subP[(*jt).A.at(attr)] ++;

           else

                subN[(*jt).A.at(attr)] ++;

           sub[(*jt).A.at(attr)]++;

       }

 

       // 计算特定属性下信息增益（相对熵）

       double SplitInfo = 0;

       for(int i = 0; i < maxvalue; i++)

       {

           double partsplitinfo;

           partsplitinfo   =-double(sub[i])/s*log(double(sub[i])/s)/log(2.0);

           SplitInfo       =SplitInfo+partsplitinfo;

       }

 

       double infoattr = 0;

       for (int i = 0; i < maxvalue; i++)

       {

           double partentropy;

           partentropy     = Entropy(subP[i],subP[i] + subN[i]);

           infoattr        =infoattr+((double)(subP[i] + subN[i])/(double)(s))*partentropy;

       }

       result = result - infoattr;

       result = result / SplitInfo;

 

       // 寻找最优属性

       if (result > bestResult)

       {

           bestResult      = result;

           bestAttr        = attr;

       }

       delete[] subN;

       delete[] subP;

       delete[] sub;

   }

 

   if (bestResult == 0)

   {

       bestAttr=attributes.at(0);

   }

   return bestAttr;

}

 

void RandomSelectAttr(vector<int>&data, vector<int> &subdata)

{

   int index;

   unsigned int dataNum=data.size();

   subdata.clear();

   if(dataNum<=F)

   {

       for (vector<int>::iterator it = data.begin(); it != data.end();it++)

       {

           int attr = (*it);

           subdata.push_back(attr);

       }

   }

   else

   {

       set<int> AttrSet;

       AttrSet.clear();

       while (AttrSet.size() < F)

       {

           index = rand() % dataNum;

           if (AttrSet.count(index) == 0)

           {

                AttrSet.insert(index);

               subdata.push_back(data.at(index));

           }

       }

   }

}

 

bool Allthesame(constvector<TupleData> &samples, char ch)

{

   for (vector<TupleData>::const_iterator it = samples.begin(); it !=samples.end(); it++)

       if ((*it).label != ch)

           return false;

   return true;

}

 

// 确定节点中哪个类别样本个数最多

char Majorityclass(constvector<TupleData> &samples)

{

   int p = 0, n = 0;

   for (vector<TupleData>::const_iterator it = samples.begin(); it !=samples.end(); it++)

       if ((*it).label == '+')

           p++;

       else

           n++;

   if (p >= n)

       return '+';

   else

       return '-';

}

 

// 测试阶段

char testClassifier(decision_tree *p,TupleData d)

{

   // 抵达叶子节点

   if (p->node.label != ' ')

       return p->node.label;

 

   // 节点处最优属性

   int attrNum = p->node.attrNum;

 

   // 错误样本

   if (d.A.at(attrNum) < 0)

       return ' ';

 

   // 确定分支

   return testClassifier(p->childs.at(d.A.at(attrNum)), d);

}

 

void testData()

{

   for (vector<TupleData>::iterator it = test.begin(); it !=test.end(); it++)

   {

       printf("新样本\n");

       if((*it).label=='+') TestP++;

       else TestN++;

 

       int p = 0, n = 0;

 

       for(int i = 0; i < tree_num; i++)

       {

           if(testClassifier(alltrees.at(i), (*it))=='+')  p++;

           else n++;

       }

 

       if(p>n)

       {

           if((*it).label=='+') TP++;

           else FP++;

       }

       else

       {

           if((*it).label=='+') FN++;

           else TN++;

       }

   }

}

 

void freeClassifier(decision_tree *p)

{

   if (p == NULL)

       return;

   for (vector<decision_tree*>::iterator it = p->childs.begin();it != p->childs.end(); it++)

   {

       freeClassifier(*it);

   }

   delete p;

}

 

void freeArrtNum()

{

   delete[] ArrtNum;

}

 

void showResult()

{

   cout << "Train size:   "<<trainAllNum<<endl;

   cout << "Test size:    "<<testAllNum<<endl;     

   cout << "True positive:        "<< TP << endl;

   cout << "False negative:       "<<FN<<endl;

   cout << "False positive:       "<<FP<<endl;

   cout << "True negative:        "<<TN<<endl;

}

 

int main(int argc, char **argv)

{

   char * trainfile=argv[1];

    char* testfile=argv[2];

 

   srand((unsigned)time(NULL));

 

   // 初始化样本

   init("1.txt", "2.txt");

 

   // 训练阶段

   for(int i = 0; i < tree_num; i++)

   {

       printf("第 %d 棵决策树训练开始\n", i);

 

       // 每棵树的训练样本子集

       sub_init();

 

       // 训练每棵决策树

       decision_tree * root=NULL;

       creat_classifier(root, train, attributes);

 

       // 建立森林

       alltrees.push_back(root);

 

       printf("第 %d 棵决策树训练完毕\n", i);

   }

 

   // 测试阶段

   testData();

 

   for (vector<decision_tree *>::const_iterator it =alltrees.begin(); it != alltrees.end(); it++)

   {

       freeClassifier((*it));

   }

 

   freeArrtNum();

 

   showResult();

 

   system("pause");

   return 0;

}


荪荪
关注
  • 1
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
随机森林c++_随机森林RandomForest挖掘生物标记预测分类
weixin_39838231的博客
12-08 574
随机森林简介如果读者接触过决策树(Decision Tree)的话，那么会很容易理解什么是随机森林。随机森林就是通过集成学习的思想将多棵树集成的一种算法，它的基本单元是决策树，而它的本质属于机器学习的一大分支——集成学习(Ensemble Learning)方法。随机森林的名称中有两个关键词，一个是“随机”，一个就是“森林”。“森林”我们很好理解，一棵叫做树，那么成百上千棵就可以叫做森林...
随机森林 C++ 算法实现
10-09
树类型为ID3.0 分类结果转存到文档 也可显示在dos界面 初级适用
数据结构与算法之随机森林算法
weixin_47225948的博客
09-18 789
数据结构与算法之随机森林算法
随机森林C++实现
07-03
随机森林的C++实现，附实现PPT和实验报告声明
机器学习十大算法（4）随机森林详解（附代码实现）
最新发布
qq_45591302的博客
06-12 1163
随机森林算法是一种集成学习方法，通过构建多个决策树模型来进行分类或回归任务。随机森林算法的基本思想是将多个决策树模型集成在一起，通过投票或平均的方式进行预测。具体步骤如下：1. 随机选择训练数据集中的部分样本进行有放回抽样，构建一个决策树模型。这样可以保证每个决策树的训练数据不完全相同，增加模型的多样性。2. 在每个节点上，随机选择一部分特征进行划分。这样可以保证每个决策树的划分规则不完全相同，增加模型的多样性。3. 重复步骤1和步骤2，构建多个决策树模型。
基于C++的RandomForest随机森林总结
mengjiaoduan的博客
10-26 3171
http://bbs.pinggu.org/thread-3607064-1-1.html
基于C++编写的随机森林算法.zip
11-28
随机森林算法是基于决策树而来。主要有两方面的问题：一是，在决策树中基于同样的数据，同样的特征，按照同样的决策树算法，只能建一颗树，同样的树复制上千万次没有意义，所以建立随机森林的第一个问题就是---怎么建立不同的树。二是，如果建立了不同的树组成的森林后，每个树都会得到自己的分类结果，如何从每棵树的各自决策下得到总体最终的结果
RandomForests:带有详细注释的1500行的RandomForests简单C ++实现
05-17
随机森林带有详细注释的1500行的RandomForests简单C ++实现。 无依赖性，支持回归和分类。快速开始从下载MNIST数据集，并在某些目录中解压缩Train＆test数据git clone cd RandomForests并制作运行以下命令： ./...
机器学习大作业的支撑代码：SVM、随机森林、深度学习+源代码+文档说明
12-23
1、资源内容：机器学习大作业支撑代码：SVM、随机森林、深度学习+源代码+文档说明 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能...
RandomDecisionForest:使用随机决策森林对深度图像中的每个像素进行手解析
05-16
它包括一个约100个带注释的合成深度图像的小样本数据集，一个程序“ SampleGenerator”以准备其中80个训练图像的训练数据，以及一个程序“ RandomForest”用于随机决策森林训练和其余20张图像的测试。 该代码是用C ...
随机森林图像分类分割
06-13
随机森林图像分类分割 jamie 大作 执行效果好，速度快
ma-di-tuan.rar_数值算法/人工智能_Visual_C++_
08-11
【压缩包子文件的文件名称列表】中，"新建文本文档.txt"可能包含了项目介绍、代码注释或者算法描述，而"ma di tuan"可能是一个可执行文件或源代码文件，具体功能需要打开文件才能了解。 综上所述，这个项目结合了...
Random Forest随机森林算法
Marshall的专栏
04-16 2万+
Random Forest是加州大学伯克利分校的Breiman Leo和Adele Cutler于2001年发表的论文中提到的新的机器学习算法，可以用来做分类，聚类，回归，这里只简单介绍该算法在分类上的应用。 Random Forest（随机森林）算法是通过训练多个决策树，生成模型，然后综合利用多个决策树的分类结果进行投票，从而实现分类。随机森林算法只需要两个参数：构建的决策树的个数t，在决策树
随机森林的简单实现
黑暗之神
11-08 3858
近日听了七月天空周博的课。现在对随机森林进行一下，简单的实现。 随机森林（randomforest）是一种利用多个分类树对数据进行判别与分类的方法，它在对数据进行分类的同时，还可以给出各个变量（基因）的重要性评分，评估各个变量在分类中所起的作用。 随机森林是一个最近比较火的算法，它有很多的优点： a. 在数据集上表现良好，两个随机性的引入，使得随机森林不容易陷入过拟合 b. 在当前的很
对于随机森林的通俗理解
热门推荐
xf__mao的博客
10-03 10万+
一、决策树 决策树是机器学习最基本的模型，在不考虑其他复杂情况下，我们可以用一句话来描述决策树：如果得分大于等于60分，那么你及格了。 这是一个最最简单的决策树的模型，我们把及格和没及格分别附上标签，及格（1），没及格（0），那么得到的决策树是这样的 但是我们几乎不会让计算机做这么简单的工作，我们把情况变得复杂一点 引用别的文章的一个例子 这是一张女孩对于不同条件的男性是
OpenCV 随机森林(Random Forest)手势识别应用---样本选择问题
小华同学的学习笔记
03-23 2339
如图，这是打电话手势。在进行背景处理、二值化、统一尺寸后，提取ROI的轮廓得到的20*20图片。 现在要将手势提取出来，用的是基于OpenCV的随机森林(Random Forest)API。 手势识别，本质上就是，将一个模板与另外所有的模板区分开。用过OpenCV的人脸识别训练特征函数HAAR的同学就知道，训练的时候有正模板(Positive samples)和负模板(Negtive
windows下的纯c++版 Faster R-CNN
花泽
11-22 1万+
     效果如下图： 最新的源代码放在github上，https://github.com/huaze555/windows-caffe-faster-rcnn，支持训练和测试，自己下载用VS2013编译即可，编译步骤跟微软版的caffe一模一样。 同时版本经过大幅度性能优化，在GeForce GTX TITAN X显卡上，对于VGG16模型的速度是16.6fps左右。 *******...
c++代码的随机森林例子
07-12
以下是一个使用C++和OpenCV的随机森林示例代码： ```cpp #include #include using namespace cv; using namespace cv::ml; int main() { // 加载训练数据和标签 Mat trainingData = (Mat_(6, 2) , 3.5f, 4.9f...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值