精华内容
下载资源
问答
  • 实现之前所说的上传Matlab实现随机森林、神经网络、Lasso回归的承诺。 Lasso lasso具有降维的功能,但区别于PCA,lasso直接减少特征数,做的是特征选择,PCA是通过空间转换将特征空间从高维空间转换到低维空间,是...

    实现之前所说的上传Matlab实现随机森林、神经网络、Lasso回归的承诺。

    Lasso

    lasso具有降维的功能,但区别于PCA,lasso直接减少特征数,做的是特征选择,PCA是通过空间转换将特征空间从高维空间转换到低维空间,是降维(PCA的缺点是丢失语意)。当特征有很强的语意的时候,用LASSO更好,后续的分析会更高的保持可解释性,可以给出y=wx表达式(y、w、x均为向量);反之,数据的语意性不强,PCA更好。

    %清空命令窗口
    clc;
    %清空工作区的变量和值
    clear;
    %关闭所有程序运行过程中打开的绘图窗口,此处为绘图窗口。
    close all;
    %读取excel数据,
    x1=xlsread("C:\xxx.xlsx",'C4:J328');
    y1=xlsread("C:\xxx.xlsx",'K4:K328');
    %调用lasso函数,其中参数为(自变量x,因变量y,使用交叉验证,10折交叉验证,α,α=0为岭回归,α=1为lasso回归);返回值为(b:权重系数,fitinfo:模型信息)
    [b,fitinfo] = lasso(x1,y1,'CV',10,'Alpha',1); 
    %画图
    axTrace = lassoPlot(b,fitinfo,'PlotType','Lambda','XScale','log');
    %为图像添加图例,位置在图的右侧外面
    legend('show','Location','EastOutside');
    axCV = lassoPlot(b,fitinfo,'PlotType','CV');
    %寻找最小误差对应的迭代次数
    lam1SE = fitinfo.Index1SE;
    %最小误差的值
    mse_1=fitinfo.MSE(lam1SE);
    %取最小误差对应的系数;b矩阵lam1SE列所有行
    mat=b(:,lam1SE);
    %寻找系数中的非零项(~=0为不等于0)
    [row1SE, ] = find(b(:,lam1SE)~=0);
    %计算原来的最小均方误差
    rhat = x1\y1;
    res = x1*rhat - y1;   
    MSEmin_real= res'*res/325; 
    %最小均方误差对应的迭代次数,上面误差是1se这里是mse
    lamMinMSE = fitinfo.IndexMinMSE;
    %主成分的系数
    matMinMSE = b(:,lamMinMSE);  
    %寻找非零自变量的下标(即主成分的下标)
    [rowMinMSE, ] = find(b(:,lamMinMSE)~=0);
    %两种计算误差方式使得所降成的维度不同,根据自己需求比较两个误差计算方式的差异选择留几个变量。
    

    随机森林RF

    随机森林可以计算对于最后的结果贡献率最高的特征,对于回归可以得出线性模型。

    clc;
    clear;
    in=xlsread("C:\xxx.xlsx",'C4:J328');
    Out=xlsread("C:\xxx.xlsx",'K4:K328');
    %此处未进行归一化,切记,使用归一化的数据进行训练,后面要记得反归一化,且数据多处进行归一化,不可遗漏
    nTree = 80;%树的个数
    %训练模型
    Factor = TreeBagger(nTree, In, Out,'Method','regression','NumPredictorsToSample',122,'OOBpredictorImportance','on','MinLeafSize',5);%
    %性能评估,k-fold交叉验证法
    [Predict_label,Scores] = predict(Factor, In);
    %相关系数
    cct=corrcoef(Out,Predict_label');
    cct=cct(2,1);
    
    plot(Out,Out,'LineWidth',3);
    
    hold on
    scatter(Out,Predict_label,'filled');
    hold off
    grid on
    view(Factor.Trees{1},'Mode','graph')
    %变量重要性直方图
    weights=Factor.OOBPermutedVarDeltaError;
    %重要性降序
    [B,iranked] = sort(weights,'descend');
    figure
    xlabel('变量重要性','FontSize',30,'Interpreter','latex');
    ylabel('排序','FontSize',30,'Interpreter','latex');
    title('变量相对重要性展示','FontSize',17,'Interpreter','latex');
    hold on
    %45个数据为黄色
    barh(weights(iranked(1:45)),'y');
    %15个最重要属性为红色
    barh(weights(iranked(1:15)),'r');
    
    grid on 
    xt = get(gca,'XTick');    %坐标轴刻度
    xt_spacing=unique(diff(xt));
    xt_spacing=xt_spacing(1);    
    yt = get(gca,'YTick');    
    ylim([0 40]); %y轴显示数目上限
    xl=xlim;
    xlim([0 2.5]);
    %为直方图的每个线条添加文字
     for ii=1:40
        text( max([0 weights(iranked(ii))+0.02*max(weights)]),ii,['变量' num2str(iranked(ii))],'Interpreter','latex','FontSize',10);
     end
    
    set(gca,'FontSize',16)
    set(gca,'XTick',0:2*xt_spacing:1.1*max(xl));
    set(gca,'YTick',yt);
    set(gca,'TickDir','out');%坐标轴刻度方向
    set(gca, 'ydir', 'reverse' )%最大值在上方
    set(gca,'LineWidth',2);   %设置线条粗细
    drawnow
    
    %误差变化图
    figure
    plot(Factor.oobError,'LineWidth',2);
    xlabel('生长树数量','FontSize',30)
    ylabel('袋外错误率','FontSize',30)
    title('袋外错误率','FontSize',30)
    set(gca,'FontSize',16)
    set(gca,'LineWidth',2);   
    grid on
    drawnow
    

    神经网络 NN

    神经网络将数据进行糅合,最后所得为模型,具有不可解释性,只可实现输入数据并进行预测。
    搬运工上线,很多解说该程序的博客,就不多bb啦~

    clc;
    clear;
    close all;
    sample=xlsread("C:\Users\CHANG\Desktop\c\sampleR_40.xlsx",'B2:AP326');
    p=sample(:,1:end-1);
    t=sample(:,end);
    p=p';%神经网络输入的行为一个特征的所有样本值
    t=t';%目标应为行向量
    [p1,ps]=mapminmax(p); 
    [t1,ts]=mapminmax(t);
    [trainsample.p1,valsample.p1,testsample.p1] =dividerand(p1,0.7,0.15,0.15); 
    [trainsample.t1,valsample.t1,testsample.t1] =dividerand(t1,0.7,0.15,0.15);
    TF1='tansig';TF2='purelin';
    net=newff(p1,t1,layer,{TF1 TF2},'traingdm');%网络创建
    %网络参数的设置
    net.trainParam.epochs=10000;%训练次数设置   
    net.trainParam.goal=1e-7;%训练目标设置    
    net.trainParam.lr=0.01;%学习率设置,应设置为较少值,太大虽然会在开始加快收敛速度,但临近最佳点时,会产生动荡,而致使无法收敛    
    net.trainParam.mc=0.9;%动量因子的设置,默认为0.9     
    net.trainParam.show=25;%显示的间隔次数       
    net.trainFcn='trainlm';
    [net,tr]=train(net,trainsample.p1,trainsample.t1);
    %计算仿真,其一般用sim函数   
    [normtrainoutput,trainPerf]=sim(net,trainsample.p1,[],[],trainsample.t1);%训练的数据,根据BP得到的结果    
    [normvalidateoutput,validatePerf]=sim(net,valsample.p1,[],[],valsample.t1);%验证的数据,经BP得到的结果    
    [normtestoutput,testPerf]=sim(net,testsample.p1,[],[],testsample.t1);     
    trainoutput=mapminmax('reverse',normtrainoutput,ts);    
    validateoutput=mapminmax('reverse',normvalidateoutput,ts);   
    testoutput=mapminmax('reverse',normtestoutput,ts);
    %正常输入的数据的反归一化的处理,得到其正式值    
    trainvalue=mapminmax('reverse',trainsample.t1,ts);%正常的验证数据
    validatevalue=mapminmax('reverse',valsample.t1,ts);%正常的验证的数据     
    testvalue=mapminmax('reverse',testsample.t1,ts);%正常的测试数据    
    pnew=[159.0     90.2    50.21   0.5680  1019.1993   206.8057    394.2145    102.1239    120.8178    51.6357     69.5808     60.4115     -0.1513     2.0921  -0.3742     49.9826     0.0000  282.6794    921079.3000     131.3584    25.8939     3.8522  24.4931     283.2769    -4.9646     66.4584     139.4476    70.4751     170.5868    0.2601  -5.1580     474.5039    12265800.0000   9.1833  18.7165     56.4848     3.1464  2.2574  31.8697     0.4928 ];   
    pnew=pnew';
    %将输入数据归一化  
    pnewn=mapminmax(pnew);    
    anewn=sim(net,pnewn);    
    anew=mapminmax('reverse',anewn,ts);    
    predictA(layer-layerBegin+1,trainNum)=anew;
    %绝对误差的计算   
    errorSquaresSum=zeros(layerEnd,trainEnd);
    for i=1:(layerBegin-layerEnd+1)    
    	for j=trainBegin:trainEnd       
    		 errorSquaresSum(i,j)=(predictA(i,j)-88.80)^2;  
    	end
    end
    errors=trainvalue-trainoutput;
    %plotregression拟合图
    figure,plotregression(trainvalue,trainoutput)
    %误差图
    figure,plot(1:length(errors),errors,'-b')
    title('误差变化图')
    %误差值的正态性的检验
    figure,hist(errors);%频数直方图 
    figure,normplot(errors);
    figure,normplot(errors);%Q-Q图
    [muhat,sigmahat,muci,sigmaci]=normfit(errors);
    %参数估计 均值,方差,均值的0.95置信区间,方差的0.95置信区间
    [h1,sig,ci]= ttest(errors,muhat);
    %假设检验
    figure, ploterrcorr(errors);
    %绘制误差的自相关图 
    figure, parcorr(errors);
    %绘制偏相关图% %输入数据
    save p.mat; 
    save t.mat;
           
    

    补充

    当系数矩阵和y的维数不呼应时,求x*a=y最小二乘解,使用命令为:左除
    代码:

    x=xlsread("C:\xxx.xlsx",'B2:T326');
    y=xlsread("C:\xxx.xlsx",'U2:U326');
    //组成增广矩阵
    plus=[x y];
    //求x的秩
    rX=rank(x);
    //求增广矩阵的秩
    rP=rank(plus);
    k_Left=x\y;
    y_new_Left=x*k_Left;
    //计算误差。误差平方和
    error_Left=sum((y-y_new_Left).^2);
    
    展开全文
  • 使用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实现

    万次阅读 多人点赞 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);
    

    样本数据

    sample distance duration total_time outdoor angle proportion warning(1 yes 0 no)
    1 20 72 344 148 11 81 1
    2 34 68 263 135 7 50 1
    3 25 98 357 32 12 64 1
    4 37 65 291 157 8 89 0
    5 34 151 162 169 18 63 1
    6 30 178 259 146 32 50 1
    7 20 35 134 37 23 68 0
    8 39 111 169 87 4 52 0
    9 22 44 265 136 14 76 1
    10 39 151 219 140 2 55 0
    11 21 179 184 64 18 60 1
    12 25 41 241 71 16 72 1
    13 18 171 286 131 35 89 1
    14 32 33 236 102 29 50 1
    15 20 133 226 124 17 81 1
    16 17 148 236 66 32 75 1
    17 34 111 214 57 5 88 0
    18 24 85 163 155 14 32 1
    19 32 165 276 146 33 52 1
    20 25 124 359 171 33 70 0
    21 31 51 167 47 25 47 0
    22 31 63 352 58 22 44 1
    23 16 58 164 45 13 73 0
    24 29 37 326 104 33 68 1
    25 34 47 197 59 5 66 0
    26 36 123 185 165 26 70 0
    27 25 126 171 45 23 33 1
    28 31 84 98 37 30 51 1
    29 30 92 153 114 14 48 0
    30 29 178 278 146 27 45 1
    展开全文
  • matlab实现随机森林算法,利用分类器可做回归或预测
  • Matlab TreeBagger随机森林回归实例

    万次阅读 热门讨论 2020-03-12 11:34:33
    本文介绍在Matlab平台如何使用自带函数和测试数据实现回归森林,对于随机森林和决策树的相关理论原理将不做太深入的描述。 算法流程 (1)加载Matlab测试数据集; (2)获取计算机性能,以便最好地利用其性能; (3...

    简介

    在探寻变量之间相关性时,简单线性相关容易实现,对于多元的非线性关系,如果不知道关系式(函数方程)很难建立自变量和因变量之间关系。而机器学习方法为解决这类复杂多元非线性问题提供了很好的思路。
    其中,随机森林回归是一种机器学习和数据分析领域常用且有效的算法。本文介绍在Matlab平台如何使用自带函数(TreeBagger)和测试数据实现回归森林,对于随机森林和决策树的相关理论原理将不做太深入的描述。

    算法流程

    (1)加载Matlab测试数据集;
    (2)训练TreeBagger(随机森林);
    (3)创建散点图;
    (4)估计输入变量的相对重要性;
    (5)检查需要多少棵树。

    TreeBagger介绍

    TreeBagger集成了一组决策树,用于分类或回归。集成中的每棵树都生长在独立绘制的输入数据的引导程序副本上。该副本中未包含的观察结果对于该树而言是“无用之物”。

    TreeBagger将决策树用于分类或回归。TreeBagger依靠ClassificationTree和 RegressionTree功能来生长单个树。ClassificationTree和RegressionTree接受为每个决策拆分随机选择的特征数作为可选输入参数。也就是说, TreeBagger实现了随机森林算法。
    对于回归问题,TreeBagger支持均值和分位数回归(即分位数回归森林)。

    默认情况下,TreeBagger为分类树。要使用回归树,请指定 ‘Method’,‘regression’。

    语法

    Mdl = TreeBagger(NumTrees,Tbl,ResponseVarName)
    Mdl = TreeBagger(NumTrees,Tbl,formula)
    Mdl = TreeBagger(NumTrees,Tbl,Y)
    B = TreeBagger(NumTrees,X,Y)
    B = TreeBagger(NumTrees,X,Y,Name,Value)
    

    描述

    Y是响应数据的数组,对于分类问题, Y是一组类标签。标签可以是数字或逻辑向量等。对于回归问题,Y是一个数值向量。要增长回归树,必须指定名称-值对 ‘Method’,‘regression’。

    若要预测均值响应或估计给定数据的均方误差,请分别传递TreeBagger模型和数据分析。要对袋外观测数据执行类似的操作,请使用oobPredict或oobError。

    要估计给定数据的响应分布的分位数或分位数误差,请将TreeBagger模型和数据分别传递给quantilePredict或quantileError。要对袋外观察执行类似的操作,请使用oobQuantilePredict或oobError。

    测试数据集下载

    https://download.csdn.net/download/wokaowokaowokao12345/12243422
    或者使用Matlab自带测试数据集。

    例子1

    https://www.mathworks.com/help/stats/regression-treeBagger-examples.html

    clear;clc;close all
    
    %%
    % 加载Matlab提供的测试数据——使用1985年汽车进口量数据库,其中包含205个样本数据,25个自变量和1个因变量
    load imports-85;
    Y = X(:,1);
    X = X(:,2:end);
    isCategorical = [zeros(15,1);ones(size(X,2)-15,1)]; % Categorical variable flag
    
    % 设置随机生成器种子,实际运用中可以注释掉,以获得随机性
    rng(1945,'twister')
    
    
    %% 最优leaf选择
    % 对于回归,一般规则是将叶子大小设置为5。通过比较不同叶子数量MSE获得最佳叶子数量
    % 叶子数量越少MSE越小,即使如此也肯定不是越小越好,这里就假设leaf=5是最优了
    leaf = [5 10 20 50 100];
    col = 'rbcmy';
    figure
    for i=1:length(leaf)
        b = TreeBagger(50,X,Y,'Method','R','OOBPrediction','On',...
    			'CategoricalPredictors',find(isCategorical == 1),...
                'MinLeafSize',leaf(i));
        plot(oobError(b),col(i))
        hold on
    end
    xlabel('Number of Grown Trees')
    ylabel('Mean Squared Error') 
    legend({'5' '10' '20' '50' '100'},'Location','NorthEast')
    hold off
    
    %% 树的数量设置,前面用了50棵树(为了收敛速度快),接下来增加到100
    b = TreeBagger(100,X,Y,'Method','R','OOBPredictorImportance','On',...
        'CategoricalPredictors',find(isCategorical == 1),...
        'MinLeafSize',5);
    
    % 绘制误差曲线
    figure
    plot(oobError(b))
    xlabel('Number of Grown Trees')
    ylabel('Out-of-Bag Mean Squared Error')
    
    %% 自变量重要性分析
    % 自变量对RF模型贡献有大有小,RF的预测能力依赖于贡献大的自变量。对于每个自变量,可以观察其重要性,进行取舍组合,并查看MSE是否有改善。
    % OOBPermutedPredictorDeltaError提供了每个自变量的重要性,值越大,变量越重要。
    figure
    bar(b.OOBPermutedPredictorDeltaError)
    xlabel('Feature Number') 
    ylabel('Out-of-Bag Feature Importance')
    
    % 选择重要性大于0.7的变量
    idxvar = find(b.OOBPermutedPredictorDeltaError>0.7)
    idxCategorical = find(isCategorical(idxvar)==1);
    finbag = zeros(1,b.NTrees);
    for t=1:b.NTrees
        finbag(t) = sum(all(~b.OOBIndices(:,1:t),2));
    end
    finbag = finbag / size(X,1);
    figure
    plot(finbag)
    xlabel('Number of Grown Trees')
    ylabel('Fraction of In-Bag Observations')
    
    %% 使用选择的特征重新训练
    b5v = TreeBagger(100,X(:,idxvar),Y,'Method','R',...
        'OOBPredictorImportance','On','CategoricalPredictors',idxCategorical,...
        'MinLeafSize',5);
    figure
    plot(oobError(b5v))
    xlabel('Number of Grown Trees')
    ylabel('Out-of-Bag Mean Squared Error')
    
    figure
    bar(b5v.OOBPermutedPredictorDeltaError)
    xlabel('Feature Index')
    ylabel('Out-of-Bag Feature Importance')
    
    %% 找到样本数据中的异常数据
    b5v = fillProximities(b5v);
    figure
    histogram(b5v.OutlierMeasure)
    xlabel('Outlier Measure')
    ylabel('Number of Observations')
    
    figure(8)
    [~,e] = mdsProx(b5v,'Colors','K');
    xlabel('First Scaled Coordinate')
    ylabel('Second Scaled Coordinate')
    
    figure
    bar(e(1:20))
    xlabel('Scaled Coordinate Index')
    ylabel('Eigenvalue')
    

    例子2

    clear;clc;close all
    
    %%
    % 加载Matlab提供的测试数据——使用1985年汽车进口量数据库,其中包含205个样本数据,25个自变量和1个因变量
    load imports-85;
    Y = X(:,1);
    X = X(:,2:end);
    isCategorical = [zeros(15,1);ones(size(X,2)-15,1)]; % Categorical variable flag
    
    %% 训练随机森林,TreeBagger使用内容,以及设置随机森林参数
    tic
    leaf = 5;
    ntrees = 200;
    fboot = 1;
    disp('Training the tree bagger')
    b = TreeBagger(ntrees, X,Y, 'Method','regression', 'oobvarimp','on', 'surrogate', 'on', 'minleaf',leaf,'FBoot',fboot);
    toc
    
    %% 使用训练好的模型进行预测
    % 这里没有单独设置测试数据集合,如果进行真正的预测性能测试,使用未加入至模型训练的数据进行预测测试。
    disp('Estimate Output using tree bagger')
    x = Y;
    y = predict(b, X);
    toc
    
    % calculate the training data correlation coefficient
    % 计算相关系数
    cct=corrcoef(x,y);
    cct=cct(2,1);
    
    % Create a scatter Diagram
    disp('Create a scatter Diagram')
    
    % plot the 1:1 line
    plot(x,x,'LineWidth',3);
    
    hold on
    scatter(x,y,'filled');
    hold off
    grid on
    
    set(gca,'FontSize',18)
    xlabel('Actual','FontSize',25)
    ylabel('Estimated','FontSize',25)
    title(['Training Dataset, R^2=' num2str(cct^2,2)],'FontSize',30)
    
    drawnow
    
    fn='ScatterDiagram';
    fnpng=[fn,'.png'];
    print('-dpng',fnpng);
    
    %--------------------------------------------------------------------------
    % Calculate the relative importance of the input variables
    tic
    disp('Sorting importance into descending order')
    weights=b.OOBPermutedVarDeltaError;
    [B,iranked] = sort(weights,'descend');
    toc
    
    %--------------------------------------------------------------------------
    disp(['Plotting a horizontal bar graph of sorted labeled weights.']) 
    
    %--------------------------------------------------------------------------
    figure
    barh(weights(iranked),'g');
    xlabel('Variable Importance','FontSize',30,'Interpreter','latex');
    ylabel('Variable Rank','FontSize',30,'Interpreter','latex');
    title(...
        ['Relative Importance of Inputs in estimating Redshift'],...
        'FontSize',17,'Interpreter','latex'...
        );
    hold on
    barh(weights(iranked(1:10)),'y');
    barh(weights(iranked(1:5)),'r');
    
    %--------------------------------------------------------------------------
    grid on 
    xt = get(gca,'XTick');    
    xt_spacing=unique(diff(xt));
    xt_spacing=xt_spacing(1);    
    yt = get(gca,'YTick');    
    ylim([0.25 length(weights)+0.75]);
    xl=xlim;
    xlim([0 2.5*max(weights)]);
    
    %--------------------------------------------------------------------------
    % Add text labels to each bar
    for ii=1:length(weights)
        text(...
            max([0 weights(iranked(ii))+0.02*max(weights)]),ii,...
            ['Column ' num2str(iranked(ii))],'Interpreter','latex','FontSize',11);
    end
    
    %--------------------------------------------------------------------------
    set(gca,'FontSize',16)
    set(gca,'XTick',0:2*xt_spacing:1.1*max(xl));
    set(gca,'YTick',yt);
    set(gca,'TickDir','out');
    set(gca, 'ydir', 'reverse' )
    set(gca,'LineWidth',2);   
    drawnow
    
    %--------------------------------------------------------------------------
    fn='RelativeImportanceInputs';
    fnpng=[fn,'.png'];
    print('-dpng',fnpng);
    
    %--------------------------------------------------------------------------
    % Ploting how weights change with variable rank
    disp('Ploting out of bag error versus the number of grown trees')
    
    figure
    plot(b.oobError,'LineWidth',2);
    xlabel('Number of Trees','FontSize',30)
    ylabel('Out of Bag Error','FontSize',30)
    title('Out of Bag Error','FontSize',30)
    set(gca,'FontSize',16)
    set(gca,'LineWidth',2);   
    grid on
    drawnow
    fn='EroorAsFunctionOfForestSize';
    fnpng=[fn,'.png'];
    print('-dpng',fnpng);
    
    
    

    实验结果

    模型的相关系数
    输入变量的重要性
    展开全文
  • 随机森林MATLAB实现

    2018-03-05 21:12:41
    里面包含随机森林matlab实现代码,并且有简单的训练数据集和测试数据集
  • 此文件为随机森林Matlab实现代码,可用于了解随机森林的实现过程,运行结果等等。
  • 随机森林顾名思义,是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下...
  • (二)bagging 方法 (三)使用Python进行交易的随机森林算法 (四)Python中随机森林的实现与解释 (五)如何用 Python 从头开始实现 Bagging 算法 (六)如何利用Python从头开始实现随机森林算法(当前文章) 介绍 随机森林是...
  • 随机森林实现 MATLAB

    千次阅读 2015-08-22 16:26:00
    matlab随机森林工具箱的下载地址: http://code.google.com/p/randomforest-matlab/downloads/detail?name=Windows-Precompiled-RF_MexStandalone-v0.02-.zip&amp;can=2&amp;q=   %% 基于随机森林...
  • 随机森林是一种有监督学习算法,是以决策树为基学习器的集成学习算法,随机森林非常简单,易于实现,计算开销也很小,但是它在分类和回归上表现出非常惊人的性能,因此,随机森林被誉为“代表集成学习技术水平的方法...
  • 项目所需,研究了随机森林matlab工具包RF_MexStandalone-v0.02-precompiled 另附随机森林其它几种matlab实现方式
  • 随机森林非常简单,易于实现,计算开销也很小,但是它在分类和回归上表现出非常惊人的性能,因此,随机森林被誉为“代表集成学习技术水平的方法”。一,随机森林的随机性体现在哪几个方面?1,数据集的随机选取从...
  • 随机森林原理及其用于分类问题的matlab实现

    万次阅读 热门讨论 2018-11-16 22:03:33
    随机森林 随机森林是多个决策树的集成学习,每个决策树用bagging的方法选数据集,并且在选择最佳属性划分的时候随机划分一些属性进行分类,比单个分类器效果更好,泛化能力更强。 代码解释 1.用结构体的嵌套实现树的...
  • 随机森林MATLAB代码

    2017-11-22 08:44:04
    随机森林分类方法的matlab代码实现,包括分类、重要度打分和回归。
  • 随机森林回归算法 X = S2(1:22,:); % S2为数据集 T = S2(23:end,:); %nTree = round(sqrt(size(X,2)-1)); nTree = 50; train_data = X(:,1:end-1);train_label = X(:,end); test_data = T(:,1:end-1); Factor = ...
  • random forest 随机森林(高亮!用于分类) matlab实现

    万次阅读 多人点赞 2017-09-06 11:02:19
    最近要用到随机森林,于是乎对它的原理了解了一番,并做了一下算法的实现。本次实现是用于分类问题的,如果是回归问题,分裂规则不一样,我还没有实现..... 下面的原理摘自别人的笔记,如果了解决策树CART的构建规则...

空空如也

空空如也

1 2 3 4 5
收藏数 90
精华内容 36
关键字:

matlab实现随机森林

matlab 订阅