精华内容
下载资源
问答
  • 此文件为随机森林Matlab实现代码,可用于了解随机森林实现过程,运行结果等等。
  • 随机森林顾名思义,是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下...
  • matlab实现随机森林算法,利用分类器可做回归或预测
  • 随机森林MATLAB实现

    2018-03-05 21:12:41
    里面包含随机森林matlab实现代码,并且有简单的训练数据集和测试数据集
  • 使用matlab实现随机森林仿真

    千次阅读 2020-09-04 15:48:16
    这几天在网上看到一篇关于随机森林的文章,感觉挺有趣的,就在这简单地总结了一下随机森林,并使用matlab来仿真实现随机森林 随机森林使用了元胞自动机模型,其中每个元胞有三种状态:无树、着火、有树。其中每个...

    这几天在网上看到一篇关于随机森林的文章,感觉挺有趣的,就在这简单地总结了一下随机森林,并使用matlab来仿真实现。
    随机森林
    随机森林使用了元胞自动机模型,其中每个元胞有三种状态:无树、着火、有树。其中每个元胞的演变规则如下:
    (1)表示有树状态的元胞如果四周有一个元胞表示着火状态,则下一时刻这个元胞位置变为着火状态;
    (2)已经着火的元胞下一时刻变为空元宝;
    (3)每一个表示有树状态的元胞以一个很小的概率变为着火状态;
    (4)每一个空元胞以一定的概率变为有树状态(表示种树)
    算法设计策略
    在给出代码之前,我想说一下算法的设计策略,尤其是怎样知道一棵树周围的元胞状态。使用一个n*n的矩阵senlin表示森林,其中认为第一列的元胞与最后一列的元胞是连在一起的,第一行的元胞与最后一行的元胞也是连在一起的。元胞的三种状态表示如下: 0:无树;1:着火 2:有数。在判断一棵树是下一时刻否会着火时,基本的想法是判断每一个有树状态的元胞相邻的四个元胞是否会有表示着火状态的,即是否会有1的元胞,我们的做法是先得到每一个位置上面相邻的元胞的表示矩阵,实现这一步只需要将最后一行拿到第一行的位置,其余行往下移动一行即可,同理,我们可以得到每一个位置下面、左边、右边相邻的元胞的表示矩阵。将这四个矩阵相加起来得到一个矩阵,如果某个位置的元素大于0,则表示这个位置会着火,等于0表示不会着火。
    matlab实现随机森林的代码

    close;
    clc,clear;
    n=300;
    senlin=zeros(300,300);
    pfire=0.000001;%发生火灾的概率
    pplant=0.001;%种树的概率
    up=[n 1:n-1];%这两个矩阵用于计算一棵数是否会发生火灾时使用
    right=[2:n 1];
    img=image(cat(3,senlin,senlin,senlin));
    m=annotation('textbox',[0.1 0.1 0.1 0.1],'LineStyle','-','LineWidth',12,'string','123');
    %状态说明:0;无树 1:着火 3:有树木
    %开始仿真
    for i=1:10000
        temp=(senlin(up,:)==1)+(senlin(right,:)==1)+(senlin(:,up)==1)+(senlin(:,right)==1);%算出每个位置四周是否会有着火的数目
        %更新森林 新的森林=原来的森林-着火的数目+新种的数目
        senlin=2*(senlin==2)-((senlin==2)&(temp>0|rand(n,n)<pfire))+2*((senlin==0)&rand(n,n)<pplant);
        a=find(senlin==2);
        aa=length(a);
        b=find(senlin==1);
        bb=length(b);
        shu(i)=aa;
        fire(i)=50*bb;%乘上一个系数是因为火的数量比树木的数量小大多,这两幅图放在一起时看不出或的趋势,乘上30将火的数量扩大,
        %可以更明显地看出两者
        %定义火灾等级
        if bb>=0&&bb<=10
            str1="森林安全";
        elseif bb>10&&bb<=100
            str1="火灾发展";
        elseif bb>100
            str1="森林大火";
        end
        %定义火灾预警等级
        if aa>48000||bb>=10
            str2="火灾预警:红色预警";
        elseif aa<=48000&&aa>42000
            str2="火灾预警:黄色预警";
        elseif aa>35000&&aa<=42000
            str2="火灾预警:蓝色预警";
        elseif aa>=0&&aa<=35000
            str2="火灾预警:森林安全";
        end
        str=[str1 ; str2];%10是为了在文本框中换行显示str1和str2
        %更新图像
        set(img,'cdata',cat(3,(senlin==1),(senlin==2),zeros(n,n)));
        drawnow;
        figure(2);
        delete(m);%删除之前的文本框
        plot(shu);
        hold on
        plot(fire);
        legend(['绿树的数量:' num2str(aa)],['火的数量'  num2str(bb)]);
        title(['时间T=',num2str(i),'天']);
        m=annotation('textbox',[0.15 0.8 0.1 0.1],'LineStyle','-','LineWidth',1,'string',str);
        hold off
        
    end
    
    
    
    
    
    
    
    

    某时刻的结果

    在这里插入图片描述

    展开全文
  • 根据随机森林的原理实现matlab代码,里面有非常详细的注释,几乎每行都有,针对分类问题,可以运行,可以根据需要,修改到自己的算法中。
  • 随机森林回归matlab代码,可用于回归和分类,简单易用
  • 随机森林matlab代码

    2018-04-10 14:39:08
    随机森林matlab代码,决策树类型算法的常用算法之一。
  • matlab软件随机森林法回归模型代码,可直接matlab打开运行!精简版,包括数据导入、模型建立、误差计算、保存模型,绘制对比图的多个功能!
  • 随机森林的分类中matlab代码,直接可以用,很方便,该算法可以用来机器学习分类研究。
  • matlab软件随机森林法分类模型代码,可直接matlab打开运行!精简版,包括数据导入、模型建立、误差计算、绘制对比图、保存模型等多个功能!
  • 随机森林算法Matlab实现

    万次阅读 多人点赞 2019-05-25 18:26:32
    随机森林算法Matlab实现随机森林算法Matlab实现计算当前自身gini系数求最优划分点及其gini系数对data中按decision属性值从小到大排列生成结点生成随机采样样本数据生成决策树评价函数随机森林样本决策函数正确率计算...

    瞎BB

    1.实现根据样本数据(用眼距离distance、最长持续用眼时长duration、总用眼时长total_time、户外运动时长outdoor、用眼角度angle、健康环境光照用眼比例proportion)判别是否需要近视预警
    2.这个是大一数模校赛写的Matlab实现随机森林算法的代码。那个时候太菜。
    3.代码还有一点bug,在建立决策树时用的是分支,如果样本太少会出bug。
    4.如果不是一定要用Matlab,可以用python中的sklearn库来实现随机森林算法。
    详情:随机森林算法python实现 https://blog.csdn.net/CYBERLIFERK800/article/details/90552735
    5.需改进:用二叉树递归代替分支结构生成决策树,评估函数应改用recall来评判好坏,并交叉验证。等有时间了就改一改。

    代码

    计算当前自身gini系数

    %计算当前自身gini系数
    function gini_now=gini_self(data)
    sample_select=size(data,1)-1;
    decision_select=size(data,2)-1;
    time=0;
    for i=1:sample_select
        if data(i,decision_select+1)
            time=time+1;
        end
    end
    gini_now=1-(time/sample_select)^2-((sample_select-time)/sample_select)^2;
    

    求最优划分点及其gini系数

    %求最优划分点及其gini系数,输入数据和决策属性,输出最优划分点和最优gini系数
    function [boundary_best,gini_best]=gini(data_new,decision)
    sample_select=size(data_new,1)-1;           %选取样本数
    decision_select=size(data_new,2)-1;         %选取决策属性个数
    %初始化
    range=[min(data_new(1:sample_select,decision)) max(data_new(1:sample_select,decision))];%决策属性值范围
    gini_best=1;                    %最优解
    boundary_best=range(1);         %最优边界
    %计算time_lt sum_lt time_ge sum_ge
    for j=range(1)+1:range(2)
        result_temp=[0 0];
        time_lt=0;                      %小于boundary的样本个数
        sum_lt=0;                       %小于boundary的样本中需要预警的个数
        time_ge=0;                      %大于等于boundary的样本个数
        sum_ge=0;                       %大于等于boundary的样本中需要预警的个数
        boundary=j;
        for i=1:sample_select
            if(data_new(i,decision)<boundary)
                time_lt=time_lt+1;
                sum_lt=sum_lt+data_new(i,decision_select+1);
            else
                time_ge=time_ge+1;
                sum_ge=sum_ge+data_new(i,decision_select+1);
            end
        end
        %计算gini系数
        time=[time_lt time_lt time_ge time_ge];
        sum=[sum_lt time_lt-sum_lt sum_ge time_ge-sum_ge];
        rate=sum./time;
        result_temp(1)=1-rate(1)^2-rate(2)^2;
        result_temp(2)=1-rate(3)^2-rate(4)^2;
        result=time_lt/sample_select*result_temp(1)+time_ge/sample_select*result_temp(2);
        if result<gini_best
            gini_best=result;
            boundary_best=boundary;
        end
    end
    

    对data中按decision属性值从小到大排列

    %对data中按decision属性值从小到大排列,输出新数据和划分位置
    function [data_new,index]=BubbleSort(data,decision,boundary)
    sample_select=size(data,1)-1;
    for i=1:sample_select-1
        for j=1:sample_select-i
            if data(j,decision)>data(j+1,decision)
                temp=data(j,:);
                data(j,:)=data(j+1,:);
                data(j+1,:)=temp;
            end
        end
    end
    for i=1:sample_select
        if data(i,decision)>boundary
            break
        end
    end
    index=i-1;
    data_new=data;
    

    生成结点

    %生成结点,输入数据,输出最佳决策属性,最佳划分边界,以及划分后的两组数据及其gini系数和加权gini系数
    function [decision_global_best,boundary_global_best,data_new1,gini_now1,data_new2,gini_now2,gini_new]=generate_node(data_new)
    decision_select=size(data_new,2)-1;
    gini_global_best=1;
    decision_global_best=1;
    boundary_global_best=0;
    for i=1:decision_select
        decision=i;
        [boundary_best,gini_best]=gini(data_new,decision);
        if gini_best<gini_global_best
            gini_global_best=gini_best;
            decision_global_best=decision;
            boundary_global_best=boundary_best;
        end
    end
    %按decision_global_best属性从小到大排列
    [data_nnew,index]=BubbleSort(data_new,decision_global_best,boundary_global_best);
    %生成子结点
    
    data_new1=data_nnew(1:index,:);
    data_new1(index+1,:)=data_nnew(end,:);
    gini_now1=gini_self(data_new1);
    %去除decision_global_best列
    for i=1:decision_select
        if i>=decision_global_best
            data_new1(:,i)=data_new1(:,i+1);
        end
    end
    data_new1(:,i)=[];
    
    data_new2=data_nnew(index+1:end,:);
    gini_now2=gini_self(data_new2);
    %去除decision_global_best列
    for i=1:decision_select
        if i>=decision_global_best
            data_new2(:,i)=data_new2(:,i+1);
        end
    end
    data_new2(:,i)=[];
    
    size1=size(data_new1,1)-1;
    size2=size(data_new2,1)-1;
    gini_new=gini_now1*size1/(size1+size2)+gini_now2*size2/(size1+size2);
    

    生成随机采样样本数据

    %生成随机采样样本数据,对样本有放回采样m组,对决策属性无放回采样n组
    function data_new=select_sample_decision(data,m,n)
    sample_num=size(data,1)-1;      %样本个数
    decision_num=size(data,2)-1;    %决策属性个数
    %随机有放回选取m个样本建立决策树
    data_new1=ones(m+1,decision_num+1);
    data_new1(m+1,:)=data(sample_num+1,:);
    for i=1:m
        k1=ceil(rand*sample_num);
        data_new1(i,:)=data(k1,:);
    end
    %随机选取n个属性进行决策
    k2=randperm(decision_num);
    data_new=ones(m+1,n+1);
    for i=1:n
        data_new(:,i)=data_new1(:,k2(i));
    end
    data_new(:,n+1)=data_new1(:,decision_num+1);
    

    生成决策树

    %生成决策树,输入原始数据,采样样本数,采样决策属性数,预剪枝样本限制
    function [path,boundary,gini,result]=decision_tree(data,sample_select,decision_select,sample_limit)
    score=100;                          %评价函数得分
    while(score>(sample_select*0.05))   %直到找到好树才停止
        data_new=select_sample_decision(data,sample_select,decision_select);
        %计算初始gini系数
        gini_now=gini_self(data_new);
        %主程序
        layer=1;                            %记录决策树当前层数
        leaf_sample=zeros(1,sample_select); %记录子结点样本个数
        leaf_gini=zeros(1,sample_select);   %叶子节点gini系数
        leaf_num=0;                         %记录叶子数
        path=zeros(decision_select,2^(decision_select-1));       %初始化路径
        gini=ones(decision_select,2^(decision_select-1));        %初始化gini
        boundary=zeros(decision_select,2^(decision_select-1));   %初始化划分边界
        result=ones(decision_select,2^(decision_select-1));      %初始化结果
        path(:)=inf;
        gini(:)=inf;
        boundary(:)=inf;
        result(:)=inf;
        %position=[1 0 0 0;1 2 0 0;1 2 3 4];
        %第一层
        [decision_global_best,boundary_global_best,data_new1,gini_now1,data_new2,gini_now2,~]=generate_node(data_new);
        path(layer,1)=data_new(size(data_new,1),decision_global_best);
        boundary(layer,1)=boundary_global_best;
        gini(layer,1)=gini_now;
        layer=layer+1;
        gini(layer,1)=gini_now1;
        gini(layer,2)=gini_now2;
        %第二层
        if ((size(data_new1,1)-1)>=sample_limit)&&(gini(layer,1)>0)
            [decision_global_best,boundary_global_best,data_new1_1,gini_now1_1,data_new1_2,gini_now1_2,~]=generate_node(data_new1);
            path(layer,1)=data_new1(size(data_new1,1),decision_global_best);
            boundary(layer,1)=boundary_global_best;
            layer=layer+1;
            gini(layer,1)=gini_now1_1;
            gini(layer,2)=gini_now1_2;
            %第三层
            if (size(data_new1_1,1)-1)>=sample_limit&&(gini(layer,1)>0)
                [decision_global_best,boundary_global_best,data_new1_1_1,gini_now1_1_1,data_new1_1_2,gini_now1_1_2,~]=generate_node(data_new1_1);
                path(layer,1)=data_new1_1(size(data_new1_1,1),decision_global_best);
                boundary(layer,1)=boundary_global_best;
                layer=layer+1;
    
                gini(layer,1)=gini_now1_1_1;
                temp1=sum(data_new1_1_1);
                temp2=temp1(1,end)-7;
                temp3=size(data_new1_1_1,1)-1;
                temp=temp2>(temp3/2);
                result(layer,1)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now1_1_1;
                leaf_sample(leaf_num)=size(data_new1_1_1,1)-1;
    
                gini(layer,2)=gini_now1_1_2;
                temp1=sum(data_new1_1_2);
                temp2=temp1(1,end)-7;
                temp3=size(data_new1_1_2,1)-1;
                temp=temp2>(temp3/2);
                result(layer,2)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now1_1_2;
                leaf_sample(leaf_num)=size(data_new1_1_2,1)-1;
            else
                temp1=sum(data_new1_1);
                temp2=temp1(1,end)-7;
                temp3=size(data_new1_1,1)-1;
                temp=temp2>(temp3/2);
                result(layer,1)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now1_1;
                leaf_sample(leaf_num)=size(data_new1_1,1)-1;
    
                path(layer,1)=nan;
                boundary(layer,1)=nan;
                gini(layer+1,1:2)=nan;
            end
            layer=3;
            if (size(data_new1_2,1)-1)>=sample_limit&&(gini(layer,2)>0)
                [decision_global_best,boundary_global_best,data_new1_2_1,gini_now1_2_1,data_new1_2_2,gini_now1_2_2,~]=generate_node(data_new1_2);
                path(layer,2)=data_new1_2(size(data_new1_2,1),decision_global_best);
                boundary(layer,2)=boundary_global_best;
                layer=layer+1;
    
                gini(layer,3)=gini_now1_2_1;
                temp1=sum(data_new1_2_1);
                temp2=temp1(1,end)-7;
                temp3=size(data_new1_2_1,1)-1;
                temp=temp2>(temp3/2);
                result(layer,3)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now1_2_1;
                leaf_sample(leaf_num)=size(data_new1_2_1,1)-1;
    
                gini(layer,4)=gini_now1_2_2;
                temp1=sum(data_new1_2_2);
                temp2=temp1(1,end)-7;
                temp3=size(data_new1_2_2,2)-1;
                temp=temp2>(temp3/2);
                result(layer,4)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now1_2_2;
                leaf_sample(leaf_num)=size(data_new1_2_2,1)-1;
            else
                temp1=sum(data_new1_2);
                temp2=temp1(1,end)-7;
                temp3=size(data_new1_2,1)-1;
                temp=temp2>(temp3/2);
                result(layer,2)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now1_2;
                leaf_sample(leaf_num)=size(data_new1_2,1)-1;
    
                path(layer,2)=nan;
                boundary(layer,2)=nan;
                gini(layer+1,3:4)=nan;
            end
        else
            temp1=sum(data_new1);
            temp2=temp1(1,end)-7;
            temp3=size(data_new1,1)-1;
            temp=temp2>(temp3/2);
            result(layer,1)=temp;
            leaf_num=leaf_num+1;
            leaf_gini(leaf_num)=gini_now1;
            leaf_sample(leaf_num)=size(data_new1,1)-1;
    
            path(layer,1)=nan;
            boundary(layer,1)=nan;
            layer=layer+1;
            gini(layer,1:2)=nan;
            %第三层
            path(layer,1:2)=nan;
            boundary(layer,1:2)=nan;
            %gini第四层叶子
            layer=layer+1;
            gini(layer,1:4)=nan;
        end
        layer=2;
        if (size(data_new2,1)-1)>=sample_limit&&(gini(layer,2)>0)
            [decision_global_best,boundary_global_best,data_new2_1,gini_now2_1,data_new2_2,gini_now2_2,~]=generate_node(data_new2);
            path(layer,2)=data_new2(size(data_new2,1),decision_global_best);
            boundary(layer,2)=boundary_global_best;
            layer=layer+1;
            gini(layer,3)=gini_now2_1;
            gini(layer,4)=gini_now2_2;
            %第三层
            if (size(data_new2_1,1)-1)>=sample_limit&&(gini(layer,3)>0)
                [decision_global_best,boundary_global_best,data_new2_1_1,gini_now2_1_1,data_new2_1_2,gini_now2_1_2,~]=generate_node(data_new2_1);
                path(layer,3)=data_new2_1(size(data_new2_1,1),decision_global_best);
                boundary(layer,3)=boundary_global_best;
                layer=layer+1;
    
                gini(layer,5)=gini_now2_1_1;
                temp1=sum(data_new2_1_1);
                temp2=temp1(1,end)-7;
                temp3=size(data_new2_1_1,1)-1;
                temp=temp2>(temp3/2);
                result(layer,5)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now2_1_1;
                leaf_sample(leaf_num)=size(data_new2_1_1,1)-1;
    
                gini(layer,6)=gini_now2_1_2;
                temp1=sum(data_new2_1_2);
                temp2=temp1(1,end)-7;
                temp3=size(data_new2_1_2,1)-1;
                temp=temp2>(temp3/2);
                result(layer,6)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now2_1_2;
                leaf_sample(leaf_num)=size(data_new2_1_2,1)-1;
            else
                temp1=sum(data_new2_1);
                temp2=temp1(1,end)-7;
                temp3=size(data_new2_1,1)-1;
                temp=temp2>(temp3/2);
                result(layer,3)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now2_1;
                leaf_sample(leaf_num)=size(data_new2_1,1)-1;
    
                path(layer,3)=nan;
                boundary(layer,3)=nan;
                gini(layer+1,5:6)=nan;
            end
            layer=3;
            if (size(data_new2_2,1)-1)>=sample_limit&&(gini(layer,4)>0)
                [decision_global_best,boundary_global_best,data_new2_2_1,gini_now2_2_1,data_new2_2_2,gini_now2_2_2,~]=generate_node(data_new2_2);
                path(layer,4)=data_new2_2(size(data_new2_2,1),decision_global_best);
                boundary(layer,4)=boundary_global_best;
                layer=layer+1;
    
                gini(layer,7)=gini_now2_2_1;
                temp1=sum(data_new2_2_1);
                temp2=temp1(1,end)-7;
                temp3=size(data_new2_2_1,1)-1;
                temp=temp2>(temp3/2);
                result(layer,7)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now2_2_1;
                leaf_sample(leaf_num)=size(data_new2_2_1,1)-1;
    
                gini(layer,8)=gini_now2_2_2;
                temp1=sum(data_new2_2_2);
                temp2=temp1(1,end)-7;
                temp3=size(data_new2_2_2,1)-1;
                temp=temp2>(temp3/2);
                result(layer,8)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now2_2_2;
                leaf_sample(leaf_num)=size(data_new2_2_2,1)-1;
            else
                temp1=sum(data_new2_2);
                temp2=temp1(1,end)-7;
                temp3=size(data_new2_2,1)-1;
                temp=temp2>(temp3/2);
                result(layer,4)=temp;
                leaf_num=leaf_num+1;
                leaf_gini(leaf_num)=gini_now2_2;
                leaf_sample(leaf_num)=size(data_new2_2,1)-1;
    
                path(layer,4)=nan;
                boundary(layer,4)=nan;
                gini(layer+1,7:8)=nan;
            end
        else
            temp1=sum(data_new2);
            temp2=temp1(1,end)-7;
            temp3=size(data_new2,1)-1;
            temp=temp2>(temp3/2);
            result(layer,1)=temp;
            leaf_num=leaf_num+1;
            leaf_gini(leaf_num)=gini_now2;
            leaf_sample(leaf_num)=size(data_new2,1)-1;
    
    
            path(layer,2)=nan;
            boundary(layer,2)=nan;
            layer=layer+1;
            gini(layer,3:4)=nan;
            %第三层  
            path(layer,3:4)=nan;
            boundary(layer,3:4)=nan;
            %gini第四层叶子
            layer=layer+1;
            gini(layer,5:8)=nan;
        end
        score=evaluation(leaf_num,leaf_sample,leaf_gini);
    end
    
    

    评价函数

    %评价函数
    function result=evaluation(leaf_num,sample_num,leaf_gini)
    result=0;
    for t=1:leaf_num
        result=result+sample_num(t)*leaf_gini(t);
    end
    

    随机森林

    %随机森林,共有trees_num棵树
    function result=random_forest(sample,trees_num,data,sample_select,decision_select,sample_limit)
    warning_times=0;
    nowarning_times=0;
    conclusion=zeros(1,trees_num);
    for i=1:trees_num
        [path,boundary,~,result]=decision_tree(data,sample_select,decision_select,sample_limit);
        conclusion(i)=decide(sample,path,boundary,result);
        if conclusion(i)==1
            warning_times=warning_times+1;
        else
            if conclusion(i)==0
                nowarning_times=nowarning_times+1;
            end
        end
    end
    if 2*warning_times>(warning_times+nowarning_times)
        result=1;
    else
        result=0;
    end
    

    样本决策函数

    %样本决策函数,输入样本与决策树,输出判断结果
    function conclusion=decide(sample,path,boundary,result)
    if sample(path(1,1))<boundary(1,1)
        if ~isnan(result(2,1))
            conclusion=result(2,1);
        else
            if sample(path(2,1))<boundary(2,1)
                if ~isnan(result(3,1))
                    conclusion=result(3,1);
                else
                    if sample(path(3,1))<boundary(3,1)
                        conclusion=result(4,1);
                    else
                        conclusion=result(4,2);
                    end
                end
            else
                if ~isnan(result(3,2))
                    conclusion=result(3,2);
                else
                    if sample(path(3,2))<boundary(3,2)
                        conclusion=result(4,3);
                    else
                        conclusion=result(4,4);
                    end
                end
            end
        end
    else
        if ~isnan(result(2,2))
            conclusion=result(2,1);
        else
            if sample(path(2,2))<boundary(2,2)
                if ~isnan(result(3,3))
                    conclusion=result(3,3);
                else
                    if sample(path(3,3))<boundary(3,3)
                        conclusion=result(4,5);
                    else
                        conclusion=result(4,6);
                    end
                end
            else
                if ~isnan(result(3,4))
                    conclusion=result(3,4);
                else
                    if sample(path(3,4))<boundary(3,4)
                        conclusion=result(4,7);
                    else
                        conclusion=result(4,8);
                    end
                end
            end
        end
    end
    

    正确率计算函数

    %正确率计算函数
    function rate_average=check_accuracy(data,sample_select,decision_select,trees_num,sample_limit)
    sample_num=size(data,1)-1;
    rate=zeros(1,sample_num);       %初始化正确率数组
    for j=1:sample_num
        result=zeros(1,sample_num); %初始化结果数组
        for i=1:sample_num          %遍历样本
            sample=data(i,:);
            result(i)=random_forest(sample,trees_num,data,sample_select,decision_select,sample_limit);
        end
        result=result';
        t=0;
        data1=data(1:end-1,end);
        m=result-data1;             %机器判断与专家判断对比,0为相同
        for i=1:sample_num
            if m(i)==0
                t=t+1;
            end
        end
        rate(j)=t/sample_num;       %计算正确率
    end
    rate_average=mean(rate);        %计算平均正确率
    

    主函数

    %使用时只需要调整参数设置里的参数以及对原始数据的决策属性进行标识
    clc,clear
    %初始化
    data=xlsread('data.xlsx');      %读数据 最后一行为决策属性标识
                                    %1用眼距离 2最长持续用眼时长 3总用眼时长 4户外运动时长
                                    %5用眼角度 6健康环境光照用眼比例
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%参数设置%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    sample_select=20;               %选取样本数
    decision_select=3;              %选取决策属性个数
    trees_num=40;                   %设置森林规模
    %剪枝
        %预剪枝参数设置
    deep=3;                         %决策树深度限制
    sample_limit=2;                 %叶子结点样本数限制
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    % 计算平均正确率
    tic
    rate_average=check_accuracy(data,sample_select,decision_select,trees_num,sample_limit);
    toc
    
    %检验样本判断
    sample1=[37	33 100	151 5 80];
    sample2=[10 130 290 30 37 20];
    conclusion1=random_forest(sample1,trees_num,data,sample_select,decision_select,sample_limit);
    conclusion2=random_forest(sample2,trees_num,data,sample_select,decision_select,sample_limit);
    

    样本数据

    sampledistancedurationtotal_timeoutdoorangleproportionwarning(1 yes 0 no)
    1207234414811811
    234682631357501
    325983573212641
    437652911578890
    53415116216918631
    63017825914632501
    720351343723680
    839111169874520
    9224426513614761
    10391512191402550
    11211791846418601
    1225412417116721
    131817128613135891
    14323323610229501
    152013322612417811
    16171482366632751
    1734111214575880
    18248516315514321
    193216527614633521
    202512435917133700
    2131511674725470
    2231633525822441
    2316581644513730
    24293732610433681
    253447197595660
    263612318516526700
    27251261714523331
    283184983730511
    29309215311414480
    302917827814627451
    展开全文
  • MATLAB神经网络43个案例分析》中的第30章,基于随机森林思想的组合分类器设计(-乳腺癌诊断)中的随机森林实现 包括威斯康辛大学医学院的乳腺癌数据集,共包括569个病例,其中,良性357例,恶性212例。该次实现...
  • 随机森林MATLAB代码

    2017-11-22 08:44:04
    随机森林分类方法的matlab代码实现,包括分类、重要度打分和回归。
  • 随机森林matlab工具箱,可以实现分类和回归
  • MATLAB自带随机森林用法

    万次阅读 2020-07-14 16:53:07
    Matlab自带随机森林用法示例 Model = TreeBagger(ntree,train_data,train_label,'Method','classification') ntree 树的数量 train_data 训练样本数据 train_label 训练样本数据对应的类别标签 [predict_label...

    Matlab自带随机森林用法示例

    Model = TreeBagger(ntree,train_data,train_label,'Method','classification')
    

    ntree 树的数量
    train_data 训练样本数据
    train_label 训练样本数据对应的类别标签

    [predict_label,scores] = predict(Model, test_data)
    

    test_data 测试数据
    predict_label 分类结果
    scores 概率分布

    view(Model.Trees{n})view(Model.Trees{n},'Mode','graph')
    

    n 树的编号
    可以看到每棵树的决策过程

    以下摘自看到的一篇文档中的对比代码,做个记录
    在这里插入图片描述

    展开全文
  • 随机森林图像matlab代码随机决策森林 我们将RF应用于Caltech101数据集的子集以进行图像分类。 使用提供的Caltech101数据集。 我们使用10个班级,每个班级使用15张图像进行训练,并使用每班其他15张图像进行测试。 给...
  • 项目所需,研究了随机森林matlab工具包RF_MexStandalone-v0.02-precompiled 另附随机森林其它几种matlab实现方式
  • 随机森林MATLAB

    2018-03-06 20:46:48
    随机森林MATLAB包,大家可以交流学习,大家一起进步哈
  • matlab开发-随机森林的简单示例代码和一般功能。随机林的简单示例代码和通用函数(签出包错误)
  • 采用随机森林做为分类器 方法简单 可移植性强 可用于信号分类 图像分类 语音分类等多个分类领域 里面有例子方便看懂代码 亲测有效
  • 随机森林MATLAB

    2018-12-20 12:58:06
    压缩包中包含决策树分类方法,还有随机森林方法的matlab代码。
  • 随机森林matlab实现

    2021-07-06 15:58:17
    疑问:随机森林如何设置需要的分类总数? ... 其实,之前就接触过随机森林,但仅仅是用来做...最近,因为要实现一个idea,想到用随机森林做ensemble learning才具体的来看其理论知识。随机森林主要是用到决策树的理...
    1. 疑问:随机森林如何设置需要的分类总数?

    2. 本文摘自:https://www.cnblogs.com/txg198955/p/4658549.html

                            代码:http://blog.csdn.net/ice110956/article/details/10049149

    其实,之前就接触过随机森林,但仅仅是用来做分类和回归。最近,因为要实现一个idea,想到用随机森林做ensemble learning才具体的来看其理论知识。随机森林主要是用到决策树的理论,也就是用决策树来对特征进行选择。而在特征选择的过程中用到的是熵的概念,其主要实现算法有ID3和C4.5.下面我们先来看看决策树。

        下面我们用一个例子具体的来说明


                                                         image

        我们要选取一个最好的特征来判断是否贷款,上面给出了年龄,工作,房子,信贷四种特征。如果一种特征具有更好的分类能力,或者说,按照这一特征将训练数据集分割成子集,使得各个子集是当前条件下最好的分类,我们就应该选择这个特征。对于这个问题,直观上是否有房子应该是最好的特征。但这也仅仅是从直观上判断,具体上来讲哪个特征最好了,这里我们引入一个概念-信息增益。

        假设X是一个取值无限的离散随机变量,其概率分布为:

    image

        则其熵计算如下,这里我们把image定义为经验熵。

    image

        由于熵只依赖X的分布,而与X的取值无关。所以,我们又把熵定义为: 
                                                                                        image

        假设我们有两个随机变量x,y(generally,X denote the feature vectors,and Y denote labels)。其联合概率分布为:

    image

        这里,假如给定一个X,要我们准确的判断其所属类别,也就是要准确的判断Y。很自然的,我们需要求解给定X下的条件熵:

    image

        假设,特征A 对训练集D的信息增益为image,定义为集合D 的经验熵H(D)与特征A给定条件下D的经验熵H(D|A)之差,那么我们定义信息增益如下:

    image

        一般的,我们把熵H(Y)与条件熵H(Y|X)只差定义为互信息,决策树中的信息增益就是训练数据集中的类与特征的互信息。下面给出计算信息增益的方法:

        image

                                                      image

                                                     image

        如果我们以信息增益为划分训练数据集的特征,存在于选择取值较多的特征的问题。这里我们使用信息增益比(information gain ratio),可以对这一问题进行校正。这是特征选择的另一准则。

    image

        下面来介绍一下ID3算法,该算法的核心就是不断的利用信息增益准则选择特征,最终达到分类的目的。

    image

    image

        C4.5算法其实就是在ID3算法上做了一点的改动,把特征选择的方法改为用信息增益比来计算,而不用ID3中的计算信息增益的方法。其算法流程和ID3差不多,这里就不介绍了。下面来简单的谈一下决策树的剪枝问题,由于决策树是严格的按照一定的规则进行计算,过多的考虑了训练样本的正确性,所以这导致其容易过拟合。所以这里引入剪枝的概念,通过优化损失函数,减少模型的复杂性。具体算法过程可以看课本P-66~P-67页。

     function D = C4_5(train_features, train_targets, inc_node,test_features)
       %http://blog.csdn.net/ice110956/article/details/10049149
       % 1.train_features,为训练集; train_targets,为训练集标签;
       % inc_node为防止过拟合参数,表示样本数小于一定阈值结束递归,可设置为5-10;test_features为测试集。
       % 2.取消离散变量,上面说了,是因为我不知道如何处理Miss value的问题,至于影响,应该就是连贪心也算不上了吧,应该是一个理论上还过得去的处理方法。
       % 3.图怎么画?介绍几个画图软件:http://www.cnblogs.com/damonlan/archive/2012/03/29/2410301.html 
       % 决策树扩展篇:http://blog.csdn.net/ice110956/article/details/29175215 
    
       [Ni, M]		= size(train_features); %输入向量为NI*M的矩阵,其中M表示训练样本个数,Ni为特征维数维数
    inc_node    = inc_node*M/100; 
    
    disp('Building tree') 
    tree        = make_tree(train_features, train_targets, inc_node); 
     
    %Make the decision region according to the tree %根据产生的数产生决策域
    disp('Building decision surface using the tree') 
    [n,m]=size(test_features);
    targets		= use_tree(test_features, 1:m, tree, unique(train_targets)); %target里包含了对应的测试样本分类所得的类别数
     
    D   		= targets; 
    %END 
     
    function targets = use_tree(features, indices, tree,  Uc) %target里包含了对应的测试样本分类所得的类别
     
    
    targets = zeros(1, size(features,2)); %1*M的向量
     
    if (tree.dim == 0) 
       %Reached the end of the tree 
       targets(indices) = tree.child; 
       return %child里面包含了类别信息,indeces包含了测试样本中当前测试的样本索引
    end 
             
    
    dim = tree.dim; %当前节点的特征参数
    dims= 1:size(features,1); %dims为1-特征维数的向量
     
       %Discrete feature 
       in				= indices(find(features(dim, indices) <= tree.split_loc)); %in为左子树在原矩阵的index
    
       targets		= targets + use_tree(features(dims, :), in, tree.child_1, Uc); 
       in				= indices(find(features(dim, indices) >  tree.split_loc)); 
    
       targets		= targets + use_tree(features(dims, :), in, tree.child_2, Uc); 
    return 
          
     
    function tree = make_tree(features, targets, inc_node) 
    
    [Ni, L]    					= size(features); 
    Uc         					= unique(targets); %UC表示类别数
    tree.dim						= 0; %数的维度为0
    %tree.child(1:maxNbin)	= zeros(1,maxNbin); 
     
    if isempty(features), %如果特征为空,退出
       return 
    end 
    
    %When to stop: If the dimension is one or the number of examples is small 
    if ((inc_node > L) | (L == 1) | (length(Uc) == 1)), %剩余训练集只剩一个,或太小,小于inc_node,或只剩一类,退出
       H					= hist(targets, length(Uc)); %返回类别数的直方图
       [m, largest] 	= max(H); %更大的一类,m为大的值,即个数,largest为位置,即类别的位置
       tree.child	 	= Uc(largest); %直接返回其中更大的一类作为其类别
       return
    end 
     
    %Compute the node's I 
    %计算现有的信息量
    for i = 1:length(Uc), 
        Pnode(i) = length(find(targets == Uc(i))) / L; 
    end 
    Inode = -sum(Pnode.*log(Pnode)/log(2)); 
     
    %For each dimension, compute the gain ratio impurity 
    %This is done separately for discrete and continuous features 
    delta_Ib    = zeros(1, Ni); 
    S=[];
    for i = 1:Ni, 
       data	= features(i,:); 
       temp=unique(data); 
          P	= zeros(length(Uc), 2); 
           
          %Sort the features 
          [sorted_data, indices] = sort(data); 
          sorted_targets = targets(indices); 
           %结果为排序后的特征和类别
          %Calculate the information for each possible split 
          I	= zeros(1, L-1); 
          
          for j = 1:L-1, 
             for k =1:length(Uc), 
                P(k,1) = length(find(sorted_targets(1:j) 		== Uc(k))); 
                P(k,2) = length(find(sorted_targets(j+1:end) == Uc(k))); 
             end 
             Ps		= sum(P)/L; %两个子树的权重 
             temp1=[P(:,1)]; 
             temp2=[P(:,2)]; 
             fo=[Info(temp1),Info(temp2)];
             %info	= sum(-P.*log(eps+P)/log(2)); %两个子树的I
             I(j)	= Inode - sum(fo.*Ps);    
          end 
          [delta_Ib(i), s] = max(I); 
          S=[S,s];
       
    end
     
    %Find the dimension minimizing delta_Ib  
    %找到最大的划分方法
    [m, dim] = max(delta_Ib); 
    
    dims		= 1:Ni; 
    tree.dim = dim; 
    
    %Split along the 'dim' dimension 
    %分裂树 
       %Continuous feature 
       [sorted_data, indices] = sort(features(dim,:)); 
       %tree.split_loc		= split_loc(dim); 
       %disp(tree.split_loc);
       S(dim)
       indices1=indices(1:S(dim))
       indices2=indices(S(dim)+1:end)
       tree.split_loc=sorted_data(S(dim))
       tree.child_1		= make_tree(features(dims, indices1), targets(indices1), inc_node); 
       tree.child_2		= make_tree(features(dims, indices2), targets(indices2), inc_node); 
    %D = C4_5_new(train_features, train_targets, inc_node);
    ————————————————
    版权声明:本文为CSDN博主「ice110956」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/ice110956/article/details/10049149

    其实代码不难,下面我给出我的理解。

    P50724-095915

        Here we split the data into two sets,with 300 training samples and 51 testing samples,each data is a 34-dimensional vector. Here, each dimension can  be regarded as a variable,with respect to a kind of “feature”.

        在这个决策树中,对每个节点我们计算它的信息增益比,如果信息增益比小于某个阈值。或者,节点包含的样本数小于18(自己设定),则结束递归。从上图中可以看出,从根节点出发(这个节点包含300个样本),第5维特征最好,所以用这个特征进行划分。得到左子树(57个样本全为“1”),右子树(包含243个样本)。所以左子树结束递归,接着计算右子树的特征,第27维特征最好。一直循环….

        最后我们得到这样的一个决策树,除了叶节点,中间节点都包含一个最佳分类的特征,和这个特征对应的特征值。每个叶节点包含一定数量的样本,叶节点的类别规定为多数样本对应的类别。得到了这样的一个决策树后,我们就可以对测试样本进行分类了。使用中间节点记录的特征对测试样本进行划分,直到测试样本划分到每个叶节点中。叶节点中样本的类别就是该测试样本的类别了。

    展开全文
  • matlab-随机森林的代码-mac_windows,文件夹有详细的英文文档说明,这是2018年的,代码搬运工,如有侵权请联系csdn管理员进行删除。
  • 随机森林可以实现很多的分类问题,我这里面使用的是Iris的数据集,来判断Iris的类别。
  • Matlab实现随机森林、神经网络、Lasso回归

    千次阅读 多人点赞 2020-10-25 20:01:59
    实现之前所说的上传Matlab实现随机森林、神经网络、Lasso回归的承诺。 Lasso lasso具有降维的功能,但区别于PCA,lasso直接减少特征数,做的是特征选择,PCA是通过空间转换将特征空间从高维空间转换到低维空间,是...
  • 本代码含随机森林的分类、回归代码,代码功能相当全面,性能良好,能够支撑项目开发和科研需要。---------
  • 随机森林代码-matlab

    2018-12-22 09:31:57
    随机森林代码-matlab,亲测有效,这是今年的内部包含一份英文文档解说

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,134
精华内容 1,253
关键字:

matlab实现随机森林

matlab 订阅