精华内容
下载资源
问答
  • 非常适用于初学者,有详细算法实现过程,用于分类的例子,用于回归的例子,可以帮你深入理解随机森林算法哦~
  • 随机森林回归算法

    千次阅读 2019-11-20 16:48:11
    随机森林回归算法原理 随机森林回归模型由多棵回归树构成,且森林中的每一棵决策树之间没有关联,模型的最终输出由森林中的每一棵决策树共同决定。 随机森林的随机性体现在两个方面: 1、样本的随机性,从训练集中...

    随机森林回归算法原理

    随机森林回归模型由多棵回归树构成,且森林中的每一棵决策树之间没有关联,模型的最终输出由森林中的每一棵决策树共同决定。
    随机森林的随机性体现在两个方面:
    1、样本的随机性,从训练集中随机抽取一定数量的样本,作为每颗回归树的根节点样本;

    2、特征的随机性,在建立每颗回归树时,随机抽取一定数量的候选特征,从中选择最合适的特征作为分裂节点。
    算法原理如下:
    (a)从训练样本集S中随机的抽取m个样本点,得到一个新的S1…Sn个子训练集;

    (b)用子训练集,训练一个CART回归树(决策树),这里在训练的过程中,对每个节点的切分规则是先从所有特征中随机的选择k个特征,然后在从这k个特征中选择最优的切分点在做左右子树的划分。(这里的得到决策树都是二叉树)

    (c)通过第二步,可以生成很多个CART回归树模型。

    (d)每一个CART回归树最终的预测结果为该样本点所到叶节点的均值。

    (e)随机森林最终的预测结果为所有CART回归树预测结果的均值。

    随机森林建立回归树的特点:采样与完全分裂

    首先是两个随机采样的过程,随机森林对输入的数据要进行行(样本)、列(特征)的采样。对于样本采样,采用有放回的方式,也就是在采样得到的样本集合中,可能有重复的样本。

    假设输入样本为N个,那么采样的样本也为N个。这样使得在训练的时候,每一棵树的输入样本都不是全部的样本,使得相对不容易出现过拟合over-fitting。

    然后进行特征采样,从M个Features中,选择m个(m << M)。之后就是对采样之后的数据使用完全分裂的方式建立出回归树

    一般情况下,回归树算法都一个重要的步骤 – 剪枝,但是在随机森林思想里不这样干,由于之前的两个随机采样的过程保证了随机性,所以就算不剪枝,也不会出现over-fitting。

    每一棵回归树就是一个精通于某一个窄领域的专家(因为我们从M个feature中选择m让每一棵回归树进行学习),这样在随机森林中就有了很多个精通不同领域的专家,

    对一个新的问题(新的输入数据),可以用不同的角度去看待它,最终由各个专家得出自己的结果,最后将得到结果取均值即可。

    随机森林的基学习器并不是弱学习器而是强学习器,是有很高深度的强决策树组成的。

    CART回归树

    CART回归树,采用的原则是最小均方差(MSE)。即对于任意划分特征A,对应的任意划分点s两边划分成的数据集D1和D2,求出使D1和D2各自集合的均方差最小,同时D1和D2的均方差之和最小所对应的特征和特征值划分点。表达式为:
    在这里插入图片描述
    其中:c1为D1数据集的样本输出均值,c2为D2数据集的样本输出均值。
    CART回归树的预测是根据叶子结点的均值,因此随机森林的预测是所有树的预测值的平均值。

    展开全文
  • 集成算法 ensemble 通过在数据集上构建多个模型,集成所有模型的建模结果,得到一个综合的结果,以此来获得比单个 ...装袋法的代表模型就是随机森林 提升法boosting: 基评估器是相关的,是按顺序一一...

    集成算法 ensemble

    通过在数据集上构建多个模型,集成所有模型的建模结果,得到一个综合的结果,以此来获得比单个
    模型更好的分类或回归表现
    
    装袋法bagging:
        构建多个相互独立的基评估器(base estimator),然后对其预测进行平均或多数表决原则来决定
        集成评估器的结果。装袋法的代表模型就是随机森林
    提升法boosting:
        基评估器是相关的,是按顺序一一构建的。其核心思想是结合弱评估器的力量一次次对难以评估的样本
        进行预测,从而构成一个强评估器。提升法的代表模型有Adaboost和梯度提升树GBDT。
    

    装袋法和提升法对比

    装袋法bagging提升法boosting
    评估器相互独立,同时运行相互关联,按顺序依次构建,后建模型会在先建模型的预测失败的样本上有更多权重
    抽样数集有放回随机抽样有放回抽样,但每次抽样时,会给预测失败的样本更多的权重
    决定集成的结果平均或多数表决加权平均,训练集上表现更好的模型会得到更多的权重
    目标降低方差,提高模型整体稳定性降低偏差,提高模型整体精确度
    单个评估器过拟合问题能一定程度上避免过拟合可能会加剧过拟合
    单个评估器的效力比较弱时不是非常有帮助可能会提升模型表现
    代表算法RFGBDT和adabooost

    随机森林参数

    控制基评估器参数:
        与决策树类似
    n_estimators:
        决策树的数量,越大,模型的效果往往越好。但是相应的,任何模型都有决策边界,n_estimators达到
        一定的程度之后,随机森林的精确性往往不再上升或开始波动
    
    %matplotlib inline
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.datasets import load_wine
    
    wine = load_wine()
    

    决策树与随机深林的对比

    from sklearn.model_selection import train_test_split
    Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)
     
    clf = DecisionTreeClassifier(random_state=0)
    rfc = RandomForestClassifier(random_state=0)
    clf = clf.fit(Xtrain,Ytrain)
    rfc = rfc.fit(Xtrain,Ytrain)
    score_c = clf.score(Xtest,Ytest)
    score_r = rfc.score(Xtest,Ytest)
     
    print("Single Tree:{}".format(score_c)
          ,"Random Forest:{}".format(score_r)
         )
    
    Single Tree:0.9444444444444444 Random Forest:1.0
    

    #交叉验证情况下

    from sklearn.model_selection import cross_val_score
    import matplotlib.pyplot as plt
     
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10)
     
    clf = DecisionTreeClassifier()
    clf_s = cross_val_score(clf,wine.data,wine.target,cv=10)
     
    plt.plot(range(1,11),rfc_s,label = "RandomForest")
    plt.plot(range(1,11),clf_s,label = "Decision Tree")
    plt.legend()
    plt.show()
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传在这里插入图片描述(img-X1SsirVY-1587530490929)(output_12_0.png)]

    # 多次交叉验证

    rfc_l = []
    clf_l = []
     
    for i in range(10):
        rfc = RandomForestClassifier(n_estimators=25)
        rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
        rfc_l.append(rfc_s)
        clf = DecisionTreeClassifier()
        clf_s = cross_val_score(clf,wine.data,wine.target,cv=10).mean()
        clf_l.append(clf_s)
        
    plt.plot(range(1,11),rfc_l,label = "Random Forest")
    plt.plot(range(1,11),clf_l,label = "Decision Tree")
    plt.legend()
    plt.show()
     
    #是否有注意到,单个决策树的波动轨迹和随机森林一致?
    #再次验证了我们之前提到的,单个决策树的准确率越高,随机森林的准确率也会越高
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rGA在这里插入图片描述G65xY-1587530490936)(output_14_0.png)]

    n_estimator 参数曲线

    #####【TIME WARNING: 2mins 30 seconds】#####
    superpa = []
    for i in range(200):
        rfc = RandomForestClassifier(n_estimators=i+1,n_jobs=-1)
        rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
        superpa.append(rfc_s)
    print(max(superpa),superpa.index(max(superpa))+1)#打印出:最高精确度取值,max(superpa))+1指的是森林数目的数量n_estimators
    plt.figure(figsize=[20,5])
    plt.plot(range(1,201),superpa)
    plt.show()
    
    0.9888888888888889 32
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-在这里插入图片描述5ATU1OOh-1587530490942)(output_16_1.png)]

    随机森林为什么准确率高?

    随机森林的本质是一种装袋集成算法(bagging),装袋集成算法是对基评估器的预测结果进行平均
    或用多数表决原则来决定集成评估器的结果。
    
    在刚才的红酒例子中,我们建立了25棵树,对任何一个样本而言,平均或多数表决原则下,当且仅当
    有13棵以上的树判断错误的时候,随机森林才会判断错误。单独一棵决策树对红酒数据集的分类准确
    率在0.85上下浮动,假设一棵树判断错误的可能性为0.2,那13棵树以上都判断错误的可能性是
    
    import numpy as np
    from scipy.special import comb
     
    np.array([comb(25,i)*(0.2**i)*((1-0.2)**(25-i)) for i in range(13,26)]).sum()
    
    
    0.00036904803455582827
    
    
    
    可以看到:远小于一棵树的错误率。同时也注意到,如果随机森林中每棵树都是一样的话,
    那么一棵树判断错误,则整个森林就判读错误,也就和决策树没有区别。
    
    所以随机森林的基分类器是相互独立的,互不相同的
    

    怎样生成不同的树 ------双重随机性

    参数:random_state 控制森林生成的模式

    rfc = RandomForestClassifier(n_estimators=20,random_state=2)
    rfc = rfc.fit(Xtrain, Ytrain)
    
    #重要属性:estimators_ 存储所有树信息的列表
    #查看所有树的random_state
    for i in range(len(rfc.estimators_)):
        print(rfc.estimators_[i].random_state)
    
    2056096140
    1078729000
    602442957
    1514174439
    1458549053
    904046564
    1214918618
    655921571
    139775012
    293793817
    864952371
    2116213231
    963777025
    861270369
    1156416813
    2032972974
    583060530
    1909517413
    1341241096
    2058549495
    533227000
    1803803348
    2056406370
    1190856758
    132094869
    
    
    当random_state固定时,随机森林中生成是一组固定的树,但每棵树依然是不一致的,这是用
    ”随机挑选特征进行分枝“的方法得到的随机性。并且我们可以证明,当这种随机性越大的时
    候,袋装法的效果一般会越来越好。
    
    但这种做法的局限性是很强的,当我们需要成千上万棵树的时候,数据不一定能够提供成千上
    万的特征来让我们构筑尽量多尽量不同的树
    

    参数:bootstrap &oob_score 有放回的随机抽样

    要让基分类器尽量都不一样,一种很容易理解的方法是使用不同的训练集来进行训练,而袋装
    法正是通过有放回的随机抽样技术来形成不同的训练数据。
    
    参数bootstrap默认为True,即默认使用有放回的随机抽样
    
    有放回随机抽样:
        在一个含有n个样本的原始训练集中,我们进行随机采样,每次采样一个样本,并在抽取下
        一个样本之前将该样本放回原始训练集,也就是说下次采样时这个样本依然可能被采集到,
        这样采集n次,最终得到一个和原始训练集一样大的,n个样本组成的自助集
    
    然而,由于是有放回,一些样本可能在同一个自助集中出现多次,而其他一些却可能被忽略,
    因为每一个样本被抽到某个自助集中的概率为:
    
    $1-(1-\frac{1}{n})^n$
    $\displaystyle\lim_{n\to\infty}(1-(1-\frac{1}{n})^n)=(1-\frac{1}{e})=0.632$
    一般来说,一个自助集大约平均会包含63%的原始数据。会有约37%的训练数据被浪费掉,没有
    参与建模,这些数据被称为袋外数据(out of bag data,简写为oob)。除了我们最开始就划分好
    的测试集之外,这些数据也可以被用来作为集成算法的测试集
    
    也就是说,在使用随机森林时,我们可以不划分测试集和训练集,只需要用袋外数据来测试我们
    的模型即可
    
    rfc = RandomForestClassifier(n_estimators=25,oob_score=True) #默认为False
    rfc = rfc.fit(wine.data,wine.target)
    
    #重要属性 oob_score_ 使用袋外数据的模型评分
    rfc.oob_score_
    
    0.9719101123595506
    
    
    
     当然,这也不是绝对的,当n和n_estimators都不够大的时候,很可能就没有数据掉落在袋外
     ,自然也就无法使用oob数据来测试模型了
    

    5个重要接口

    fit:
        训练模型,输入训练集特征和标签
    
    score:
        返回分类准确率,可以是测试集也可以使训练集。注意,指标是不能修改的,如果想使用其他
        衡量指标,则不用score,使用交叉验证。
    
        apply:
            返回每个样本所在叶子节点索引,可以是测试集也可以使训练集
    
        predict:
            返回每个样本的分类结果,可以是测试集也可以使训练集
    
        predict_proba:
            返回每个样本的分类到某一类的概率,可以是测试集也可以使训练集
    
    rfc = RandomForestClassifier(n_estimators=25,random_state=20)
    rfc = rfc.fit(Xtrain, Ytrain)
    rfc.score(Xtest,Ytest)
    
    rfc.apply(Xtest)
    
    array([[10, 16, 16, ...,  8,  4,  6],
           [26, 18, 20, ..., 20, 14, 20],
           [10, 16, 16, ...,  8,  4,  2],
           ...,
           [26, 22, 20, ..., 20, 14, 15],
           [15,  4,  4, ..., 10, 11, 14],
           [19, 16, 16, ..., 19,  7,  2]], dtype=int64)
    
    rfc.predict(Xtest)
    
    array([2, 0, 2, 1, 0, 1, 0, 1, 0, 0, 2, 0, 1, 1, 0, 1, 0, 0, 1, 1, 2, 1,
           0, 0, 0, 1, 0, 1, 2, 0, 0, 2, 0, 0, 1, 1, 2, 0, 1, 2, 2, 1, 2, 2,
           2, 1, 0, 1, 1, 0, 0, 0, 1, 2])
    
    rfc.predict_proba(Xtest)
    
    array([[0.  , 0.  , 1.  ],
           [1.  , 0.  , 0.  ],
           [0.  , 0.  , 1.  ],
           [0.  , 1.  , 0.  ],
           [0.84, 0.16, 0.  ],
           [0.  , 0.96, 0.04],
           [0.88, 0.12, 0.  ],
           [0.12, 0.88, 0.  ],
           [0.96, 0.04, 0.  ],
           [1.  , 0.  , 0.  ],
           [0.04, 0.08, 0.88],
           [1.  , 0.  , 0.  ],
           [0.  , 1.  , 0.  ],
           [0.  , 1.  , 0.  ],
           [0.96, 0.04, 0.  ],
           [0.12, 0.76, 0.12],
           [0.96, 0.04, 0.  ],
           [0.96, 0.04, 0.  ],
           [0.  , 1.  , 0.  ],
           [0.  , 1.  , 0.  ],
           [0.  , 0.  , 1.  ],
           [0.  , 1.  , 0.  ],
           [0.96, 0.04, 0.  ],
           [1.  , 0.  , 0.  ],
           [1.  , 0.  , 0.  ],
           [0.  , 1.  , 0.  ],
           [1.  , 0.  , 0.  ],
           [0.  , 0.88, 0.12],
           [0.  , 0.04, 0.96],
           [1.  , 0.  , 0.  ],
           [1.  , 0.  , 0.  ],
           [0.  , 0.  , 1.  ],
           [1.  , 0.  , 0.  ],
           [0.88, 0.12, 0.  ],
           [0.  , 1.  , 0.  ],
           [0.08, 0.84, 0.08],
           [0.  , 0.04, 0.96],
           [0.96, 0.04, 0.  ],
           [0.  , 1.  , 0.  ],
           [0.  , 0.08, 0.92],
           [0.  , 0.  , 1.  ],
           [0.  , 1.  , 0.  ],
           [0.04, 0.  , 0.96],
           [0.  , 0.08, 0.92],
           [0.  , 0.08, 0.92],
           [0.08, 0.92, 0.  ],
           [0.8 , 0.2 , 0.  ],
           [0.08, 0.92, 0.  ],
           [0.  , 1.  , 0.  ],
           [1.  , 0.  , 0.  ],
           [0.96, 0.04, 0.  ],
           [1.  , 0.  , 0.  ],
           [0.  , 1.  , 0.  ],
           [0.04, 0.04, 0.92]])
    

    属性:feature_importances_ 特征重要性评分

    [*zip(wine.feature_names,rfc.feature_importances_)]
    
    [('alcohol', 0.12198679686258679),
     ('malic_acid', 0.02762880277046342),
     ('ash', 0.020429313443862722),
     ('alcalinity_of_ash', 0.04431583357245361),
     ('magnesium', 0.033968954054681415),
     ('total_phenols', 0.038263957377275275),
     ('flavanoids', 0.1408080229991804),
     ('nonflavanoid_phenols', 0.010215119630325406),
     ('proanthocyanins', 0.005887369287630495),
     ('color_intensity', 0.18147980477356618),
     ('hue', 0.0848840620720855),
     ('od280/od315_of_diluted_wines', 0.14228838485786396),
     ('proline', 0.14784357829802486)]
    

    袋装法的必要条件

    • 基评估器相互独立
    • 基评估器分类准确率大于50%
    import numpy as np
     
    x = np.linspace(0,1,20)
     
    y = []
    for epsilon in np.linspace(0,1,20):
        E = np.array([comb(25,i)*(epsilon**i)*((1-epsilon)**(25-i)) for i in range(13,26)]).sum()      
        y.append(E)
    plt.plot(x,y,"o-",label="when estimators are different")
    plt.plot(x,x,"--",color="red",label="if all estimators are same")
    plt.xlabel("individual estimator's error")
    plt.ylabel("RandomForest's error")
    plt.legend()
    plt.show()
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传在这里插入图片描述(img-5e7eavXS-1587530490955)(output_48_0.png)]

    随机森林回归

    与分类树有两点不同:
    
    • 模型评估指标:回归树用的MSE或R平方,默认接口score返回的是R方,且不能更改,想用MSE就只能使用交叉验证了。
    • 分支质量的不纯度衡量指标:回归树支持三种指标,默认为MSE
    from sklearn.datasets import load_boston#一个标签是连续西变量的数据集
    from sklearn.model_selection import cross_val_score#导入交叉验证模块
    from sklearn.ensemble import RandomForestRegressor#导入随机森林回归系
    
    boston = load_boston()
    regressor = RandomForestRegressor(n_estimators=100,random_state=0)
    cross_val_score(regressor, boston.data, boston.target, cv=10
                   ,scoring = "neg_mean_squared_error"#如果不写scoring,回归评估默认是R平方
                   )
    
    array([-10.72900447,  -5.36049859,  -4.74614178, -20.84946337,
           -12.23497347, -17.99274635,  -6.8952756 , -93.78884428,
           -29.80411702, -15.25776814])
    

    sklearn中回归类模型的评估指标

    import sklearn
    sorted(sklearn.metrics.SCORERS.keys())#这些指标是scoring可选择的参数
    
    ['accuracy',
     'adjusted_mutual_info_score',
     'adjusted_rand_score',
     'average_precision',
     'balanced_accuracy',
     'completeness_score',
     'explained_variance',
     'f1',
     'f1_macro',
     'f1_micro',
     'f1_samples',
     'f1_weighted',
     'fowlkes_mallows_score',
     'homogeneity_score',
     'jaccard',
     'jaccard_macro',
     'jaccard_micro',
     'jaccard_samples',
     'jaccard_weighted',
     'max_error',
     'mutual_info_score',
     'neg_brier_score',
     'neg_log_loss',
     'neg_mean_absolute_error',
     'neg_mean_gamma_deviance',
     'neg_mean_poisson_deviance',
     'neg_mean_squared_error',
     'neg_mean_squared_log_error',
     'neg_median_absolute_error',
     'neg_root_mean_squared_error',
     'normalized_mutual_info_score',
     'precision',
     'precision_macro',
     'precision_micro',
     'precision_samples',
     'precision_weighted',
     'r2',
     'recall',
     'recall_macro',
     'recall_micro',
     'recall_samples',
     'recall_weighted',
     'roc_auc',
     'roc_auc_ovo',
     'roc_auc_ovo_weighted',
     'roc_auc_ovr',
     'roc_auc_ovr_weighted',
     'v_measure_score']
    

    实例:随机森林回归填补缺失值

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from sklearn.datasets import load_boston
    from sklearn.impute import SimpleImputer #填补缺失值的类
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.model_selection import cross_val_score
    
    dataset = load_boston()
    
    dataset.data#数据的特征矩阵,全部为数值类型
    dataset.data.shape#数据的结构 总共506*13=6578个数据
    
    (506, 13)
    

    原始数据是没有缺失值的,需要构造含有缺失值的数据

    X_full, y_full = dataset.data, dataset.target
    n_samples = X_full.shape[0]#506
    n_features = X_full.shape[1]#13
    
    #首先确定我们希望放入的缺失数据的比例,在这里我们假设是50%,那总共就要有3289个数据缺失
     
    rng = np.random.RandomState(0)#设置一个随机种子,方便观察
    missing_rate = 0.5
    n_missing_samples = int(np.floor(n_samples * n_features * missing_rate))
    #np.floor向下取整,返回.0格式的浮点数
    
     #所有数据要随机遍布在数据集的各行各列当中,而一个缺失的数据会需要一个行索引和一个列索引
    #如果能够创造一个数组,包含3289个分布在0~506中间的行索引,和3289个分布在0~13之间的列索引,那我们就可以利用索引来为数据中的任意3289个位置赋空值
    #然后我们用0,均值和随机森林来填写这些缺失值,然后查看回归的结果如何
     
    missing_features = rng.randint(0,n_features,n_missing_samples)
    #randint(下限,上限,n)指在下限和上限之间取出n个整数
    len(missing_features)#3289
    missing_samples = rng.randint(0,n_samples,n_missing_samples)
    len(missing_samples)#3289
    
    3289
    
    X_missing = X_full.copy()
    y_missing = y_full.copy()
    
    #置空
    X_missing[missing_samples,missing_features] = np.nan
    
    #转化为DataFrame
    X_missing = pd.DataFrame(X_missing)
    X_missing.head()
    
    0123456789101112
    0NaN18.0NaNNaN0.538NaN65.24.09001.0296.0NaNNaN4.98
    10.027310.0NaN0.00.469NaN78.94.96712.0NaNNaN396.99.14
    20.02729NaN7.070.0NaN7.18561.1NaN2.0242.0NaNNaNNaN
    3NaNNaNNaN0.00.458NaN45.8NaNNaN222.018.7NaNNaN
    4NaN0.02.180.0NaN7.147NaNNaNNaNNaN18.7NaN5.33

    使用均值和0填补

    #使用均值进行填补
    from sklearn.impute import SimpleImputer
    imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')#实例化
    X_missing_mean = imp_mean.fit_transform(X_missing)#特殊的接口fit_transform = 训练fit + 导出predict
    
    #查看是否含有null
    #布尔值False = 0, True = 1 
    # pd.DataFrame(X_missing_mean).isnull().sum()#如果求和为0可以彻底确认是否有NaN
    
    #使用0进行填补
    imp_0 = SimpleImputer(missing_values=np.nan, strategy="constant",fill_value=0)#constant指的是常数
    X_missing_0 = imp_0.fit_transform(X_missing)
    

    随机森林回归填补

    1. 如果只有一个特征含有缺失值

    • 训练集,特征T未缺失部分样本的其他n-1个特征 +原标签:作为训练集特征矩阵
      特征T未缺失部分样本:作为训练集标签
    • 测试集,特征T缺失部分的样本的其他n-1个特征 +原标签 :作为测试集输入

    2. 如果多个特征含有缺失值

    • 答案是遍历所有的特征,从缺失最少的开始进行填补(因为填补缺失最少的特征所需要的
      准确信息最少)。填补一个特征时,先将其他特征的缺失值用0代替,每完成一次回归
      预测,就将预测值放到原本的特征矩阵中,再继续填补下一个特征
    # 复制数据
    X_missing_reg = X_missing.copy()
    
    #找出数据集中,缺失值从小到大排列的特征们的顺序,并且有了这些的索引
    sortindex = np.argsort(X_missing_reg.isnull().sum()).values#np.argsort()返回的是从小到大排序的顺序所对应的索引
    
     
    for i in sortindex:
        
        #构建我们的新特征矩阵(没有被选中去填充的特征 + 原始的标签)和新标签(被选中去填充的特征)
        df = X_missing_reg
        fillc = df.iloc[:,i]#新标签
        df = pd.concat([df.iloc[:,df.columns != i],pd.DataFrame(y_full)],axis=1)#新特征矩阵
        
        #在新特征矩阵中,对含有缺失值的列,进行0的填补
        df_0 =SimpleImputer(missing_values=np.nan,strategy='constant',fill_value=0).fit_transform(df)
                            
        #找出我们的训练集和测试集
        Ytrain = fillc[fillc.notnull()]# Ytrain是被选中要填充的特征中(现在是我们的标签),存在的那些值:非空值
        Ytest = fillc[fillc.isnull()]#Ytest 是被选中要填充的特征中(现在是我们的标签),不存在的那些值:空值。注意我们需要的不是Ytest的值,需要的是Ytest所带的索引
        Xtrain = df_0[Ytrain.index,:]#在新特征矩阵上,被选出来的要填充的特征的非空值所对应的记录
        Xtest = df_0[Ytest.index,:]#在新特征矩阵上,被选出来的要填充的特征的空值所对应的记录
        
        #用随机森林回归来填补缺失值
        rfc = RandomForestRegressor(n_estimators=100)#实例化
        rfc = rfc.fit(Xtrain, Ytrain)#导入训练集进行训练
        Ypredict = rfc.predict(Xtest)#用predict接口将Xtest导入,得到我们的预测结果(回归结果),就是我们要用来填补空值的这些值
        
        #将填补好的特征返回到我们的原始的特征矩阵中
        X_missing_reg.loc[X_missing_reg.iloc[:,i].isnull(),i] = Ypredict
    
    #检验是否有空值
    X_missing_reg.isnull().sum()
    
    0     0
    1     0
    2     0
    3     0
    4     0
    5     0
    6     0
    7     0
    8     0
    9     0
    10    0
    11    0
    12    0
    dtype: int64
    
    #比较 原数据建模结果 用均值填补结果 用0值填补结果 用随机森林回归填补 4中情况建模的效果
     
    X = [X_full,X_missing_mean,X_missing_0,X_missing_reg]
     
    mse = []
    std = []
    for x in X:
        estimator = RandomForestRegressor(random_state=0, n_estimators=100)#实例化
        scores = cross_val_score(estimator,x,y_full,scoring='neg_mean_squared_error', cv=5).mean()
        mse.append(scores * -1)
    
    [*zip(['Full data','Zero Imputation','Mean Imputation','Regressor Imputation'],mse)]
    
    [('Full data', 21.62860460743544),
     ('Zero Imputation', 40.84405476955929),
     ('Mean Imputation', 49.50657028893417),
     ('Regressor Imputation', 18.255872365734806)]
    

    可视化之:条形图

    x_labels = ['Full data',
                'Zero Imputation',
                'Mean Imputation',
                'Regressor Imputation']
    colors = ['r', 'g', 'b', 'orange']
     
    plt.figure(figsize=(12, 6))#画出画布
    ax = plt.subplot(111)#添加子图
    for i in np.arange(len(mse)):
        ax.barh(i, mse[i],color=colors[i], alpha=0.6, align='center')#bar为条形图,barh为横向条形图,alpha表示条的粗度
    #条形图的一些主要设置
    ax.set_title('Imputation Techniques with Boston Data') #子图的设置加上set_前缀
    ax.set_xlim(left=np.min(mse) * 0.9,
                 right=np.max(mse) * 1.1)#设置x轴取值范围
    ax.set_xlabel('MSE') #x轴的标签
    ax.set_yticks(np.arange(len(mse))) #y轴的刻度,长条的数量构成的整数列表
    ax.set_yticklabels(x_labels) #y轴每个刻度上的标签
    plt.show()
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img在这里插入图片描述-M1rSNYly-1587530490960)(output_74_0.png)]

    实例:随机森林在乳腺癌数据上的调参

    泛化误差:

    • 衡量模型在未知数据上的表现
    • 受模型结构(复杂度)影响。模型太复杂,模型就容易过拟合,泛化能力就不够,所以泛化误差大。当模型太简单,模型就会欠拟合,拟合能力就不够,所以误差也会大。只有当模型的复杂度刚刚好的才能够达到泛化误差最小的目标
    • 对树和树的集成模型来说,树的深度越深,枝叶越多,模型越复杂
    • 树和树的集成模型的学习能力很强,一般都会过拟合,所以都是往减少模型复杂度的方向调整参数

    偏差方差

    一个集成模型(f)在位置数据集(D)上的泛化误差:

    $E(f;D)=biax^2+var(x)+ε^2$

    [外链图片转存失败在这里插入图片描述,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FBkijwdY-1587530490962)(./泛化误差.png)]

    • 偏差:
      模型的预测值与真实值之间的差异,即每一个红点到蓝线的距离。在集成算法中,每个基评估器都会有
      自己的偏差,集成评估器的偏差是所有基评估器偏差的均值。衡量模型的精确性,模型越精确,偏差越低

    • 方差:
      反映的是模型每一次输出结果与模型预测值的平均水平之间的误差,即每一个红点到红色虚线的距离,
      衡量模型的稳定性。模型越稳定,方差越低。

    • 噪声:
      机器学习无法干涉的部分

    一个好的模型应当要对绝大多数未知数据预测的既准又稳

    偏差大偏差小
    方差大模型不适合数据,换模型过拟合,模型很复杂,有的数据预测很准,有的预测很糟糕
    方差小欠拟合,模型相对简单,预测很稳定,但对所有数据预测都不太准确泛化误差小,理想的模型

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(im在这里插入图片描述g-C6g9UKbZ-1587530490965)(./偏差方差.png)]|

    基于经验,根据随机森林参数对模型复杂度的影响程度,调参的顺序为:

    1. n_estimator:理论上越大越好,提升至平稳,该参数不影响单个模型的复杂度—>
    2. max_depth:默认不限制,即最高复杂度。这个参数的难点在于不知道树实际的深度—>
    3. min_samples_leaf:默认为1,即最高复杂度。增大会降低模型复杂度—>
    4. min_samples_split:默认为2,即最高复杂度。增大会降低模型复杂度—>
    5. max_features:默认auto,是特征总数的开平方,位于中间复杂度,增大则增加复杂度,减少会降低复杂度—>
    6. criterion:默认gini
    from sklearn.datasets import load_breast_cancer
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import GridSearchCV
    from sklearn.model_selection import cross_val_score
    import matplotlib.pyplot as plt
    import pandas as pd
    import numpy as np
    
    data = load_breast_cancer()
    
    rfc = RandomForestClassifier(n_estimators=100,random_state=90)
    score_pre = cross_val_score(rfc,data.data,data.target,cv=10).mean()#交叉验证的分类默认scoring='accuracy'
    score_pre
    
    0.9648809523809524
    

    参数:n_estimators

    在这里我们选择学习曲线,可以使用网格搜索吗?可以,但是只有学习曲线,才能看见趋势
    我个人的倾向是,要看见n_estimators在什么取值开始变得平稳,是否一直推动模型整体准
    确率的上升等信息。第一次的学习曲线,可以先用来帮助我们划定范围,我们取每十个数作
    为一个阶段,来观察n_estimators的变化如何引起模型整体准确率的变化
    
    scorel = []
    for i in range(0,200,10):
        rfc = RandomForestClassifier(n_estimators=i+1,
                                     n_jobs=-1,
                                     random_state=90)
        score = cross_val_score(rfc,data.data,data.target,cv=10).mean()
        scorel.append(score)
    print(max(scorel),(scorel.index(max(scorel))*10)+1)
    plt.figure(figsize=[20,5])
    plt.plot(range(1,201,10),scorel)
    plt.show()
    
    0.9631265664160402 71
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-roKwcX8i-1587530490968)(output_89_1.png)]

    scorel = []
    for i in range(65,75):
        rfc = RandomForestClassifier(n_estimators=i,
                                     n_jobs=-1,
                                     random_state=90)
        score = cross_val_score(rfc,data.data,data.target,cv=10).mean()
        scorel.append(score)
    print(max(scorel),([*range(65,75)][scorel.index(max(scorel))]))
    plt.figure(figsize=[20,5])
    plt.plot(range(65,75),scorel)
    plt.show()
    
    0.9666353383458647 73
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mq5Njl6W-1587530490971)(output_90_1.png)]

    1. 有一些参数是没有参照的,很难说清一个范围,这种情况下我们使用学习曲线,看趋势从曲线跑出的结果中选取一个更小的区间,再跑曲线。如
    • param_grid = {‘n_estimators’:np.arange(0, 200, 10)}
    • param_grid = {‘max_depth’:np.arange(1, 20, 1)}
    • param_grid = {‘max_leaf_nodes’:np.arange(25,50,1)}
      对于大型数据集,可以尝试从1000来构建,先输入1000,每100个叶子一个区间,再逐渐缩小范围
      2. 有一些参数是可以找到一个范围的,或者说我们知道他们的取值和随着他们的取值,模型的整体准确率会如何变化,这样的参数我们就可以直接跑网格搜索
    • param_grid = {‘criterion’:[‘gini’, ‘entropy’]}
    • param_grid = {‘min_samples_split’:np.arange(2, 2+20, 1)}
    • param_grid = {‘min_samples_leaf’:np.arange(1, 1+10, 1)}
    • param_grid = {‘max_features’:np.arange(5,30,1)}
    #调整max_depth
     
    param_grid = {'max_depth':np.arange(1, 20, 1)}
     
    #   一般根据数据的大小来进行一个试探,乳腺癌数据很小,所以可以采用1~10,或者1~20这样的试探
    #   但对于像digit recognition那样的大型数据来说,我们应该尝试30~50层深度(或许还不足够
    #   更应该画出学习曲线,来观察深度对模型的影响
     
    rfc = RandomForestClassifier(n_estimators=73
                                 ,random_state=90
                                )
    GS = GridSearchCV(rfc,param_grid,cv=10)#网格搜索
    GS.fit(data.data,data.target)
     
    GS.best_params_#显示调整出来的最佳参数
     
    GS.best_score_#返回调整好的最佳参数对应的准确率
    
    0.9666353383458647
    
    #调整max_features
     
    param_grid = {'max_features':np.arange(5,30,1)} 
     
    rfc = RandomForestClassifier(n_estimators=73
                                 ,random_state=90
                                )
    GS = GridSearchCV(rfc,param_grid,cv=10)
    GS.fit(data.data,data.target)
     
    GS.best_params_
     
    GS.best_score_
    
    0.9666666666666668
    
    #调整min_samples_leaf
     
    param_grid={'min_samples_leaf':np.arange(1, 1+10, 1)}
     
    #对于min_samples_split和min_samples_leaf,一般是从他们的最小值开始向上增加10或20
    #面对高维度高样本量数据,如果不放心,也可以直接+50,对于大型数据,可能需要200~300的范围
    #如果调整的时候发现准确率无论如何都上不来,那可以放心大胆调一个很大的数据,大力限制模型的复杂度
     
    rfc = RandomForestClassifier(n_estimators=39
                                 ,random_state=90
                                )
    GS = GridSearchCV(rfc,param_grid,cv=10)
    GS.fit(data.data,data.target)
     
    GS.best_params_
     
    GS.best_score_
    
    
    f:\Anaconda3\lib\site-packages\sklearn\model_selection\_search.py:841: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.
      DeprecationWarning)
    
    
    
    
    
    0.9718804920913884
    
    #调整min_samples_split
     
    param_grid={'min_samples_split':np.arange(2, 2+20, 1)}
     
    rfc = RandomForestClassifier(n_estimators=39
                                 ,random_state=90
                                )
    GS = GridSearchCV(rfc,param_grid,cv=10)
    GS.fit(data.data,data.target)
     
    GS.best_params_
     
    GS.best_score_
    
    
    f:\Anaconda3\lib\site-packages\sklearn\model_selection\_search.py:841: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal.
      DeprecationWarning)
    
    
    
    
    
    0.9718804920913884
    
    #调整Criterion
     
    param_grid = {'criterion':['gini', 'entropy']}
     
    rfc = RandomForestClassifier(n_estimators=39
                                 ,random_state=90
                                )
    GS = GridSearchCV(rfc,param_grid,cv=10)
    GS.fit(data.data,data.target)
     
    GS.best_params_
     
    GS.best_score_
    
    
    0.9718804920913884
    
    rfc = RandomForestClassifier(n_estimators=39,random_state=90)
    score = cross_val_score(rfc,data.data,data.target,cv=10).mean()
    score
     
    score - score_pre
    
    
    0.005264238181661218
    
    展开全文
  • 随机森林算法原理

    万次阅读 2019-02-22 12:33:54
    决策树与随机森林学习笔记 为什么要用-p*log('p)这个公式? 这个问题先放下,看看下面这些问题 假设我们用了一个只能装8个分子的盒子装了8个分子,当容器中存在空隙时分子会任意乱飞,系统的熵值本来就是表示...

    熵值法介绍

    熵定义:熵值法是计算指标权重的经典算法之一,它是指用来判断某个指标的离散程度的数学方法。其和化学里面的概念是相同的,指物体内部的混乱程度。混乱程度(纯度)低则熵值小,反之!
    查看了很多文献,好像对熵值的解读都很高深,现在说下自己的理解

    熵值法公式的理解

    熵值公式链接
    决策树与随机森林学习笔记

    为什么要用-p*log('p)这个公式?
    这个问题先放下,看看下面这些问题
    假设我们用了一个只能装8个分子的盒子装了8个分子,当容器中存在空隙时分子会任意乱飞,系统的熵值本来就是表示物体内部的混乱程度的,这时我们可以用公式可以求出系统的总熵值为0( 0和log函数相乘无限趋近于0时值为0),同理当盒子中没有分子时总熵值也为0
    这时我们考虑两个系统,一个容积为4个分子的器皿装了2个分子,和一个容积为8个分子的器皿装了4个分子,他们的熵值是不是相同,当然一样。他们的总熵值都为1,也就是他们都处于最极端混乱的状态。
    注:容积为8的器皿装5个分子和装3个分子,他们的混乱状态相同
    同一个系统中,熵值是满足相加性的,熵值只是一个相对属性,不要把不同系统的熵值搞混

    问什么要用-p*log('p)这公式?因为他满足以下条件,自己可以试着去掉一些参数看看它满不满足,熵值公式必须满足了系统以下几个特征:
    1:连续性
    该量度应连续,概率值小幅变化只能引起熵的微小变化
    2:对称性
    符号xi重新排序后,该量度应不变,这也是我们可以归一化、标准化矩阵参数的原因,因为无论怎么变,行向量的混乱程度的都不会变
    3:可加性
    熵的量与该过程如何被划分无关
    4:极值性
    当所有符号有同等机会出现的情况下,熵达到最大值(所有可能的事件同等概率时不确定性最高)

    熵值算法的例子
    在这里插入图片描述
    上面链接中的大神已经为我们做了详细解释,我简单对熵值算法坐下解释:
    我们对比整个表的第一列,可以看出第一列有3个属性:

    indexagebuys_computer
    0[youth,youth,youth,youth,youth][yes,yes,no,no,no]
    1[middle,middle,middle,middle][yes,yes,yes,yes]
    2[senior,senior,senior,senior,senior][yes,yes,yes,no,no]

    我们完全不用看buys_computer的排序,我们可以把age看成一个由3个箱子组成,分别装了[2,4,3]个分子的盒子,最后合并成一个箱子的系统

    系统一开始的熵值:
    在这里插入图片描述
    最后合并成一个系统后的熵值:
    在这里插入图片描述
    在这里插入图片描述
    其余列的增益可以从链接文档中查看。
    简而言之系统的状态变化越大,熵值变化量越大,代表列越复杂,它所包含的信息量也越多,它对输出结果的影响也越大,它在决策树中的层级也就越高。

    决策树的原理及Python实现

    决策树的原理和实现链接1
    决策树的原理和实现链接2

    bagging的原理

    集成学习有两个流派,一个是boosting派系,它的特点是各个弱学习器之间有依赖关系。另一种是bagging流派,它的特点是各个弱学习器之间没有依赖关系,可以并行拟合从下图可以看出,Bagging的弱学习器之间确没有boosting那样的联系。它的特点在于“随机采样”。那么什么是随机采样?

    随机采样(bootsrap)就是从我们的训练集里面采集固定个数的样本,但是每采集一个样本后,都将样本放回。也就是说,之前采集到的样本在放回后有可能继续被采集到。对于我们的Bagging算法,一般会随机采集和训练集样本数m一样个数的样本。这样得到的采样集和训练集样本的个数相同,但是样本内容不同。如果我们对有m个样本训练集做T次的随机采样,则由于随机性,T个采样集各不相同。

    注意到这和GBDT的子采样是不同的。GBDT的子采样是无放回采样,而Bagging的子采样是放回采样。

    对于一个样本,它在某一次含m个样本的训练集的随机采样中,每次被采集到的概率是1/m。不被采集到的概率为1/m−1。如果m次采样都没有被采集中的概率是(1−1/m)^m
       当m→∞时,(1−1/m)^m→1e≃0.368。也就是说,在bagging的每轮随机采样中,训练集中大约有36.8%的数据没有被采样集采集中。

    对于这部分大约36.8%的没有被采样到的数据,我们常常称之为袋外数据(Out Of Bag, 简称OOB)。这些数据没有参与训练集模型的拟合,因此可以用来检测模型的泛化能力。
    在这里插入图片描述

    最小二乘回归树算法实现

    不想看这一堆公式就跳过去看下面内容
    在这里插入图片描述

    一个简单的最小二乘预测器

    我们拿上面图一的简单方程说起,我们构造2组数据:
    两个方程参数分别接近(1,2,3,4,5),(1,2,2,4,5)
    我们可以自己动手加下,只有最后一组数据有些许偏差(16—>15, 15---->14)

    	X1 = np.array([[-2,-1,0,1,2],[-1,0,1,2,3],[1,1,1,0,0],[1,1,0,1,0],[1,0,0,0,1],[1,1,1,1,1]])
    	X2 = np.array([[1,0,0,2,1],[-1,0,2,1,1],[-3,1,2,0,0],[-4,2,0,1,1],[1,1,0,0,0],[1,1,1,1,1]])
    	Y1 = np.array([[10],[25],[6],[7],[6],[16]])
    	Y2 = np.array([[14],[12],[3],[9],[3],[15]])
    	X = np.vstack((X1,X2))
    	Y = np.vstack((Y1,Y2))
    

    这时我们可以得到两个2维(我们用几个下标可以把X表示出来,可以用X.ndim算出) 简单方程,2*6组数据5个系数:

    class Least_square:
        def __init__(self):
            self.param = np.array([])
            self.Y = np.array([])
    
        def fit(self, X, Y):
            X_T = X.transpose()
            self.param = np.dot(np.dot(np.linalg.inv(np.dot(X_T,X)),X_T),Y)
            self.Y = Y
            return self.param
    
        def predict(self,X):
            result = np.dot(X,self.param)
            var = np.var(self.Y - result)
            return result, var
            
    least_instance = Least_square()
    param = least_instance.fit(X,Y)
    result,var = least_instance.predict(X)  
    

    线性回归器简单示例

    from sklearn.linear_model import LinearRegression
    regression = LinearRegression()
    param = regression.fit(X, Y)
    score = regression.score(X,Y)
    result = regression.predict(X)
    

    展开全文
  • 随机森林算法原理解析

    千次阅读 2019-10-15 18:20:45
    集成学习有两个流派,一个是boosting派系,它的...在集成学习原理总结中,给出bagging的原理图。  (1)、Bagging的特点“随机采样”。随机采集跟训练集个数m相同的样本,采集T次。得到采样集。  (注意:GBDT(Gr...


      集成学习有两个流派,一个是boosting派系,它的特点是各个弱学习器之间有依赖关系。另一种是bagging流派,它的特点是各个弱学习器之间没有依赖关系,可以并行拟合。

    1.  bagging的原理

    集成学习原理总结中,给出bagging的原理图。

      (1)、Bagging的特点“随机采样”。随机采集跟训练集个数m相同的样本,采集T次。得到采样集。

      (注意:GBDT(Gradient Boosted Decision Tree)的子采样是无放回采样,而Bagging的子采样是放回采样。)

      

      (2)、对于一个样本,在m个样本的随机采样中,每次被采集到的概率是1/m。

      在m次采样中没有采集到的概率是:

    P(一次都未被采集) = (1-1/m)m

      对m取极限得到:

      也就是说bagging的每轮随机采样中,训练集大约有36.8%的数据没被采集。

      对于大约36.8%没被采样的数据,称为“袋外数据”。这些数据没参与训练集模型的拟合,但可以作为测试集用于测试模型的泛化能力,这样的测试结果称为“外包估计”。

      

      (3)、bagging对于弱学习器没有限制,这和Adaboost一样。但是最常用的一般也是决策树和神经网络。

      (4)、bagging的结合策略也比较简单,对于分类问题,通常使用简单投票法,得到最多票数的类别或者类别之一为最终的模型输出。对于回归问题,通常使用简单平均法,对T个弱学习器得到的回归结果进行算术平均得到最终的模型输出。

      由于Bagging算法每次都进行采样来训练模型,因此泛化能力很强,对于降低模型的方差很有作用。当然对于训练集的拟合程度就会差一些,也就是模型的偏倚会大一些。

     

    2.  bagging算法流程 

      相对于Boosting系列的Adaboost和GBDT,bagging算法简单的多。

      输入样本集,弱学习器算法,迭代次数T。

      输出为最终的强分类器 f(x)

      (1)对于 t = 1,2,...,T:

    •   对训练街进行第t次随机采样,共采集m次,得到包含m个样本的采样集Dt
    •   用采样集Dt训练第 t 个弱学习器Gt(x)

      (2)如果是分类算法预测,则T个弱学习器投出最多票数的类别或者类别之一为最终类别。如果是回归算法,T个弱学习器得到的回归结果进行算术平均得到的值为最终的模型输出。

    3. 随机森林算法

      RF(Random Forest)算法是对Bagging算法进行了改进。

      首先,RF使用了CART决策树作为弱学习器,这让我们想到梯度提升树GBDT。

      第二,在使用决策树的基础上,RF对决策树的建立做了改进,对于普通的决策树,我们会在节点上所有的n个样本特征中选择一个最优的特征来做决策树的左右子树划分,但是RF通过的随机选择节点上的一部分样本特征,这个数字小于n,假设为nsub,然后在这些随机选择的nsub(小于n)个样本特征中,选择一个最优的特征来做决策树的左右子树划分。这样进一步增强了模型的泛化能力。

      除了上面两点,RF和普通的bagging算法没什么不同,下面简单总结下RF的算法。

      输入为样本集,弱分类器迭代次数T。

      输出为最终的强分类器f(x)

      (1)对于t = 1,2,3,...,T;

    • 对训练集进行第t次采样,共采集m次,得到包含m个样本的采样集Dt
    • 用采样集Dt训练第t个决策树模型Gt(x),在训练决策树模型的节点的时候,在节点上所有的样本特征中选择一部分样本特征,在这些随机选择的部分样本特征中选择一个最优的特征来做决策树的左右子树划分。

      (2)如果是分类算法预测,则T个弱学习器投出最多票数的类别或者类别之一为最终类别。如果是回归算法,T个弱学习器得到的回归结果进行算术平均得到的值为最终的模型输出。

    ----------------------------------------------------------------------------------------------------------------------------------------------

     

     随机森林是集成学习中可以和梯度提升树GBDT分庭抗礼的算法,尤其是它可以很方便的并行训练,在如今大数据大样本的的时代很有诱惑力。

      随机森林是一种比较新的机器学习模型,经典的机器学习模型是神经网络。神经网络预测精确,但是计算量很大。

      2001年Breiman把分类树组合成随机森林(Breiman 2001a),即在变量(列)的使用和数据(行)的使用上进行随机化,生成很多分类树,再汇总分类树的结果。随机森林在运算量没有显著提高的前提下提高了预测精度。
    随机森林对多元公线性不敏感,结果对缺失数据和非平衡的数据比较稳健,可以很好地预测多达几千个解释变量的作用(Breiman 2001b),被誉为当前最好的算法之一(Iverson et al. 2008)。

      随机森林顾名思义,是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下判断,看看这个样本应该属于哪一类(对于分类算法),然后看看哪一类被选择最多,就预测这个样本为那一类。

    随机森林算法原理:
      随机森林是从原始训练样本集N中有放回地重复随机抽取k个样本生成新的训练样本集合,然后根据自助样本集生成k个分类树组成随机森林,新数据的分类结果按分类树投票多少形成的分数而定。其实质是对决策树算法的一种改进,将多个决策树合并在一起,每棵树的建立依赖于一个独立抽取的样品,森林中的每棵树具有相同的分布,分类误差取决于每一棵树的分类能力和它们之间的相关性。特征选择采用随机的方法去分裂每一个节点,然后比较不同情况下产生的误差。能够检测到的内在估计误差、分类能力和相关性决定选择特征的数目。单棵树的分类能力可能很小,但在随机产生大量的决策树后,一个测试样品可以通过每一棵树的分类结果经统计后选择最可能的分类。

      在建立每一棵决策树的过程中,有两点需要注意采样与完全分裂。首先是两个随机采样的过程,random forest对输入的数据要进行行、列的采样。对于行采样,采用有放回的方式,也就是在采样得到的样本集合中,可能有重复的样本。假设输入样本为N个,那么采样的样本也为N个。这样使得在训练的时候,每一棵树的输入样本都不是全部的样本,使得相对不容易出现over-fitting。然后进行列采样,从M个feature中,选择m个(m << M)。之后就是对采样之后的数据使用完全分裂的方式建立出决策树,这样决策树的某一个叶子节点要么是无法继续分裂的,要么里面的所有样本的都是指向的同一个分类。一般很多的决策树算法都一个重要的步骤——剪枝,但是这里不这样干,由于之前的两个随机采样的过程保证了随机性,所以就算不剪枝,也不会出现over-fitting。

    关于随机:
    (1)训练每棵树时,从全部训练样本中选取一个子集进行训练(即bootstrap取样)。用剩余的数据进行评测,评估其误差;
    (2)在每个节点,随机选取所有特征的一个子集,用来计算最佳分割方式。

    算法流程:
    (1)训练总样本的个数为N,则单棵决策树从N个训练集中有放回的随机抽取n个作为此单颗树的训练样本(bootstrap有放回取样)。
    (2)令训练样例的输入特征的个数为M,m远远小于M,则我们在每颗决策树的每个节点上进行分裂时,从M个输入特征里随机选择m个输入特征,然后从这m个输入特征里选择一个最好的进行分裂。m在构建决策树的过程中不会改变。
    注意:要为每个节点随机选出m个特征,然后选择最好的那个特征来分裂。
    注意:决策树中分裂属性的两个选择度量:信息增益和基尼指数。
    (3)每棵树都一直这样分裂下去,直到该节点的所有训练样例都属于同一类,不需要剪枝。由于之前的两个随机采样的过程保证了随机性,所以就算不剪枝,也不会出现over-fitting。

    结果判定:
    (1)目标特征为数字类型:取t个决策树的平均值作为分类结果。
    (2)目标特征为类别类型:少数服从多数,取单棵树分类结果最多的那个类别作为整个随机森林的分类结果。

    预测:
      随机森林是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下判断,看看这个样本应该属于哪一类,然后看看哪一类被选择最多,就预测这个样本为那一类。
      说明:通过bagging有放回取样后,大约36.8%的没有被采样到的数据,我们常常称之为袋外数据。这些数据没有参与训练集模型的拟合,因此可以用来检测模型的泛化能力。

    展开全文
  • 随机森林回归 算法介绍:  随机森林是决策树的集成算法。随机森林包含多个决策树来降低过拟合的风险。随机森林同样具有易解释性、可处理类别特征、易扩展到多分类问题、不需特征缩放等性质。  随机森林分别训练...
  • 一文看懂随机森林
  • 随机森林算法工作原理

    千次阅读 2019-02-27 16:42:55
    在这篇文章中,你将了解到随机森林算法的工作原理以及适用范围。   机器学习算法随机森林算法工作原理 随机森林是一种有监督学习算法。 就像你所看到的它的名字一样,它创建了一个森林,并使它拥有某种方式...
  • /** * 使用决策树算法预测 * def trainRegressor( * input: RDD[LabeledPoint], * categoricalFeaturesInfo: Map[Int, Int], * An entry (n to k)ndicates that feature n is categorical ...
  • 随机森林(Random Forest)算法原理

    万次阅读 多人点赞 2018-02-23 23:53:24
    随机森林(Random Forest)算法原理 集成学习(Ensemble)思想、自助法(bootstrap)与bagging 集成学习(ensemble)思想是为了解决单个模型或者某一组参数的模型所固有的缺陷,从而整合起更多的模型,取长补短...
  • 分类&回归算法-随机森林

    万次阅读 2015-11-03 14:35:46
    随机森林顾名思义,是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下...
  • matlab实现的随机森林算法,利用分类器可做回归或预测
  • 针对神经网络算法在当前PM2.5浓度预测领域存在的易过拟合、网络结构复杂、学习效率低等问题,引入RFR(random forest regression,随机森林回归算法,分析气象条件、大气污染物浓度和季节所包含的22项特征因素,...
  • RandomForest,随机森林算法
  • 随机森林算法

    2017-11-06 13:38:03
    随机森林回归分宜预测,比向量机精度好点随机森林 论文作者写的随机森林代码,采用matlab混合编程,需要安装Fortran compiler。。。 (An interface to the random forest algorithm (version 3.3) written by Leo ...
  • 随机森林回归算法 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 = ...
  • 1. 随机森林算法原理        随机森林算法是Bagging集成框架下的一种算法,它同时对训练数据和特征采用随机抽样的方法来构建更加多样化的模型。随机森林具体的算法步骤如下: 1...
  •  ...2)随机森林         4)Out of Bag评价         3)随机森林的应用 计算特征重要性 异常值检测——Isolation Forest 计算样本的相似度   ...
  • 机器学习——随机森林算法原理

    万次阅读 多人点赞 2016-04-29 09:30:03
    随机森林顾名思义,是用随机的方式建立一个森林,森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下...
  • 用Python实现随机森林回归

    万次阅读 多人点赞 2020-11-02 13:19:38
    这里就对如何进行随机森林回归算法上进行概述,在参数上进行详述。希望对你的工作有所帮助。 这里,将介绍如何在Python中构建和使用Random Forest回归,而不是仅仅显示代码,同时将尝试了解模型的工作原理。 1.1 ...
  • 所以随机森林是基于多颗决策树的一种集成学习算法,常见的决策树算法主要有以下几种:1. ID3:使用信息增益g(D,A)进行特征选择2. C4.5:信息增益率 =g(D,A)/H(A)3. CART:基尼系数一个特征的信息增益(或信息增益率,...
  • 随机森林 算法原理详解与实现步骤

    万次阅读 2017-05-19 15:00:10
    最近在研究TLD算法,在做目标检测的时候,用到了随机森林的组合分类器。话说现在的检测问题可以归结为分类问题,丰富了解决问题的手段。废话少说,接着看。 1.随机森林原理介绍 随机森林,指的是利用多棵树对...
  • 随机森林是集成学习bagging类方法的一种,也是最早的集成学习算法之一,Breiman在2001年提出了这种方法。作为一种bagging类的方法,随机森林几乎可以在绝大多数的数据集上表现出比单独的决策树更好的性能,同时随机...
  • 集成学习—随机森林原理(理解与论文研读)

    千次阅读 多人点赞 2019-08-21 17:44:40
    正如上一篇博客中写的,随机森林属于集成学习中Bagging的典型算法。总的来说,随机森林就是在随机子空间中随机组合的自由生长的CART决策树+Bagging得到的。 这里在CART决策树前加入了三个描述词,一个是在随机子...
  • 随机森林算法详解

    万次阅读 多人点赞 2019-06-15 14:40:13
    <div id="post_detail"> [Machine Learning &...2 随机森林的特点3 随机森林的相关基础知识4 随机森林的生成5 袋外错误率(oob error)6 随机森林工作原理解释的一个简单例子7 随机森林...
  • 随机森林算法原理及OpenCV应用

    千次阅读 2016-11-04 23:43:19
    随机森林算法是机器学习、计算机视觉等领域内应用仍为广泛的一个算法、它不仅可以用来做分类(包括二分类和多分类),也可用来做回归预测,也可以作为一种数据降维的手段。 在随机森林中,将生成很多的决策树,并...
  • 算法学习---- 随机森林的基本原理

    千次阅读 2019-10-18 16:34:43
    集成思想 Boosting 通过将弱学习器 提升为强学习器的集成方法来提高预测精度,典型的算法...典型的算法随机森林随机森林(Random Forest) 随机森林是指利用多棵决策树对样本进行训练并预测的一种算法。...
  • 随机森林基本原理算法描述

    万次阅读 2018-08-27 23:17:49
    本篇博文将介绍集成学习的另一大分支bagging方法的代表算法随机森林(Random Forest)算法。 bagging系列的算法原理相较于boosting系列的算法要简单不少。bagging方法各个子树并行的生成,而不像boosting系列算法,...
  • 随机森林原理随机森林是建立在决策树基础上集成方法(决策树中,由于噪声等因素及高方差的影响,可能会产生一些错误的分支,在没有修剪树枝的时候更容易如此)。随机森林通过有放回的方式从原始样本中随机抽取部分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,524
精华内容 4,209
关键字:

随机森林回归算法原理