精华内容
下载资源
问答
  • matlab软件随机森林回归模型代码,可直接matlab打开运行!精简版,包括数据导入、模型建立、误差计算、保存模型,绘制对比图的多个功能!
  • 随机森林回归算法

    千次阅读 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回归树的预测是根据叶子结点的均值,因此随机森林的预测是所有树的预测值的平均值。

    展开全文
  • 机器学习-随机森林回归

    万次阅读 多人点赞 2019-04-13 15:27:27
    一、随机森林回归 RandomForestRegressor class sklearn.ensemble.RandomForestRegressor (n_estimators=’warn’, criterion=’mse’, max_depth=None,min_samples_split=2, min_samples_leaf=1, min_weight_...

    一、随机森林之回归

    RandomForestRegressor
    class sklearn.ensemble.RandomForestRegressor (n_estimators=’warn’, criterion=’mse’, max_depth=None,min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=’auto’,max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False,n_jobs=None, random_state=None, verbose=0,warm_start=False)
    所有的参数,属性与接口,全部和随机森林分类器一致。仅有的不同就是回归树与分类树的不同,不纯度的指标,参数Criterion不一致
    1.1 重要参数,属性与接口
    criterion
    关于这以参数在随机森林的回归里和决策树回归是一样的,可以参见决策树之回归树的博客。最重要的属性和接口,都与随机森林的分类器相一致,还是apply, fit, predict和score最为核心。值得一提的是,随机森林回归并没有predict_proba这个接口,因为对于回归来说,并不存在一个样本要被分到某个类别的概率问题,因此没有predict_proba这个接口。
    随机森林回归用法和决策树完全一致,除了多了参数n_estimators

    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")
    sorted(sklearn.metrics.SCORERS.keys())#sklearn当中的模型评估指标(打分)列表
    # scoring='neg_mean_squared_error'表示返回负的均方误差,如果不加上这个参数,返回的则是R**2
    

    均方误差的负数:

    array([-10.72900447,  -5.36049859,  -4.74614178, -20.84946337,
           -12.23497347, -17.99274635,  -6.8952756 , -93.78884428,
           -29.80411702, -15.25776814])
    

    部分指标:

    ['accuracy',
     'adjusted_mutual_info_score',
     'adjusted_rand_score',
     'average_precision',
     'balanced_accuracy',
     'brier_score_loss',
     'completeness_score',
     'explained_variance',
     'f1',
     'f1_macro',
     'f1_micro',
     'f1_samples',
     'f1_weighted',
     'fowlkes_mallows_score',
     'homogeneity_score',
     'mutual_info_score',
     'neg_log_loss',
    

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

    2.1导入相关的库

    # 1.#导入需要的库
    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
    

    2.2导入波士顿的数据集

    boston=load_boston()
    boston.data.shape
    

    2.3为了不影响原始的数据集,可以先复制一份

    #总共506*13=6578个数据
    x_full,y_full=boston.data,boston.target
    n_samples=x_full.shape[0]
    n_features=x_full.shape[1]
    

    2.4下面为完整的数据集放入缺失值

    #首先确定我们希望放入的缺失数据的比例,在这里我们假设是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)
    missing_samples = rng.randint(0,n_samples,n_missing_samples)
    #missing_samples = rng.choice(dataset.data.shape[0],n_missing_samples,replace=False)
    
    '''我们现在采样了3289个数据,远远超过我们的样本量506,所以我们使用随机抽取的函数randint。但如果我们需要的数据量小于我们的样本量506,那我们可以采用np.random.choice来抽样,choice会随机抽取不重复的随机数,因此可以帮助我们让数据更加分散,确保数据不会集中在一些行中
    '''
    x_missing = x_full.copy()
    y_missing = y_full.copy()
    x_missing[missing_samples,missing_features] = np.nan
    x_missing = pd.DataFrame(x_missing)
    
    #转换成DataFrame是为了后续方便各种操作,numpy对矩阵的运算速度快到拯救人生,但是在索引等功能上却不如pandas来得好用
    

    2.5、使用0和均值补全缺失值

    #使用均值进行填补
    from sklearn.impute import SimpleImputer
    imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')#实例化
    x_missing_mean = imp_mean.fit_transform(x_missing)
    #使用0进行填补
    imp_0 = SimpleImputer(missing_values=np.nan, strategy="constant",fill_value=0)
    x_missing_0 = imp_0.fit_transform(x_missing)
    #训练加导出等价于fit+predict>>>特殊接口fit_transfrom
    pd.DataFrame(x_missing_mean).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
    

    表示已经不存在缺失值了
    2.6、用随机森林回归填补缺失值
    “”"
    使用随机森林回归填补缺失值
    任何回归都是从特征矩阵中学习,然后求解连续型标签y的过程,之所以能够实现这个过程,是因为回归算法认为,特征矩阵和标签之前存在着某种联系。实际上,标签和特征是可以相互转换的,比如说,在一个“用地区,环境,附近学校数量”预测“房价”的问题中,我们既可以用“地区”,“环境”,“附近学校数量”的数据来预测“房价”,也可以反过来,用“环境”,“附近学校数量”和“房价”来预测“地区”。而回归填补缺失值,正是利用了这种思想。
    对于一个有n个特征的数据来说,其中特征T有缺失值,我们就把特征T当作标签,其他的n-1个特征和原本的标签组成新的特征矩阵。那对于T来说,它没有缺失的部分,就是我们的Y_train,这部分数据既有标签也有特征,而它缺失的部分,只有特征没有标签,就是我们需要预测的部分。
    特征T不缺失的值对应的其他n-1个特征 + 本来的标签:X_train
    特征T不缺失的值:Y_train
    特征T缺失的值对应的其他n-1个特征 + 本来的标签:X_test
    特征T缺失的值:未知,我们需要预测的Y_test
    这种做法,对于某一个特征大量缺失,其他特征却很完整的情况,非常适用。
    那如果数据中除了特征T之外,其他特征也有缺失值怎么办?
    答案是遍历所有的特征,从缺失最少的开始进行填补(因为填补缺失最少的特征所需要的准确信息最少)。填补一个特征时,先将其他特征的缺失值用0代替,每完成一次回归预测,就将预测值放到原本的特征矩阵中,再继续填补下一个特征。每一次填补完毕,有缺失值的特征会减少一个,所以每次循环后,需要用0来填补的特征就越来越少。当进行到最后一个特征时(这个特征应该是所有特征中缺失值最多的),已经没有任何的其他特征需要用0来进行填补了,而我们已经使用回归为其他特征填补了大量有效信息,可以用来填补缺失最多的特征。遍历所有的特征后,数据就完整,不再有缺失值了。
    “”"
    下面是实现结果;

    x_missing_reg = x_missing.copy()
    sortindex = np.argsort(x_missing_reg.isnull().sum(axis=0)).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)
        
        #找出我们的训练集和测试集
        y_train = fillc[fillc.notnull()]
        y_test = fillc[fillc.isnull()]
        x_train = df_0[y_train.index,:]
        x_test = df_0[y_test.index,:]
        #用随机森林回归来填补缺失值
        
        rfc = RandomForestRegressor(n_estimators=100)
        rfc = rfc.fit(x_train, y_train)
        y_predict = rfc.predict(x_test)
        
        #将填补好的特征返回到我们的原始的特征矩阵中
        x_missing_reg.loc[x_missing_reg.iloc[:,i].isnull(),i] = y_predict
    

    2.6.1对填补好的数据集进行建模

    #对所有数据进行建模,取得MSE结果
    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)
    print(mse)
    

    结果:

    [21.628604607435442, 40.844054769559293, 49.506570288934171, 19.365935065385358]
    

    2.6.2经结果进行可视化展示

    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)):#barh 表示横向的柱状图
        ax.barh(i, mse[i],color=colors[i], alpha=0.6, align='center')
    ax.set_title('Imputation Techniques with Boston Data')
    ax.set_xlim(left=np.min(mse) * 0.9
                ,right=np.max(mse) * 1.1)
    ax.set_yticks(np.arange(len(mse)))
    ax.set_xlabel('MSE')
    ax.set_yticklabels(x_labels)
    plt.show()
    

    在这里插入图片描述
    从图中的结果可以看出来,随机森林回归方法的缺失值填充效果最好。

    展开全文
  • sklearn实现随机森林回归预测

    千次阅读 2020-05-14 15:55:10
    sklearn实现随机森林回归预测 import numpy as np import matplotlib.pyplot as plt from sklearn import ensemble def gen_data(x1, x2): # 生成数据 y = np.sin(x1) * 0.1 + np.cos(x2) * 0.4 + 0.1 * x1 ...

    sklearn实现随机森林回归预测

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import ensemble
    
    
    def gen_data(x1, x2):
        # 生成数据
        y = np.sin(x1) * 0.1 + np.cos(x2) * 0.4 + 0.1 * x1
        return y
    
    
    def load_data():
        x1_train = np.linspace(0, 50, 500)
        x2_train = np.linspace(-10, 10, 500)
        data_train = np.array(
            [[x1, x2, gen_data(x1, x2) + np.random.random(1) - 0.5] for x1, x2 in zip(x1_train, x2_train)])
        x1_test = np.linspace(0, 50, 100) + np.random.random(100) * 0.5
        x2_test = np.linspace(-10, 10, 100) + 0.02 * np.random.random(100)
        data_test = np.array([[x1, x2, gen_data(x1, x2)] for x1, x2 in zip(x1_test, x2_test)])
        return data_train, data_test
    
    
    train, test = load_data()
    # train的前两列是x1,X2,后一列是y,这里的y有随机噪声
    x_train, y_train = train[:, :2], train[:, 2]
    x_test, y_test = test[:, :2], test[:, 2]  # 测试时y没有噪声
    
    random_forest_regressor = ensemble.RandomForestRegressor(n_estimators=20)  # 随机森林回归,并使用20个决策树
    random_forest_regressor.fit(x_train, y_train)  # 拟合模型
    score = random_forest_regressor.score(x_test, y_test)
    result = random_forest_regressor.predict(x_test)
    plt.figure()
    plt.plot(np.arange(len(result)), y_test, "go-", label="True value")
    plt.plot(np.arange(len(result)), result, "ro-", label="Predict value")
    plt.title(f"RandomForest---score:{score}")
    plt.legend(loc="best")
    plt.show()
    

    结果
    在这里插入图片描述

    展开全文
  • 模型更好的分类或回归表现 装袋法bagging: 构建多个相互独立的基评估器(base estimator),然后对其预测进行平均或多数表决原则来决定 集成评估器的结果。装袋法的代表模型就是随机森林 提升法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
    
    展开全文
  • sklearn学习——随机森林分类和回归 1 分类 class sklearn.ensemble.RandomForestClassifier (n_estimators=’10’, criterion=’gini’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_...
  • 随机森林回归中寻找最佳mtry和ntree.txt
  • (3)float regression_accuracy:表示终止构建回归树的一个条件,回归树的响应值的精度a如果达到该值,则无需再分叉。该值不能小于0,否则报错。 (4)bool use_surrogates:表示是否使用替代分叉节点,false表示...
  • n_estimators2,criterion3,max_depth4,min_samples_leaf5,min_samples_split7,max_features8,class_weight9,max_leaf_nodes10,oob_score11,verbose重要属性重要方法随机森林回归器 随机森林分类器 引入 ...
  • 分类&回归算法-随机森林

    万次阅读 2015-11-03 14:35:46
    随机森林顾名思义,是用随机的方式建立一个森林森林里面有很多的决策树组成,随机森林的每一棵决策树之间是没有关联的。在得到森林之后,当有一个新的输入样本进入的时候,就让森林中的每一棵决策树分别进行一下...
  • 机器学习的回归评价指标

    千次阅读 2020-07-13 18:51:24
    回归类算法的模型评估一直都是回归算法中的一个难点,但不像无监督学习算法中的轮廓系数等等评估指标,回归类与分类型算法的模型评估其实是相似的法则——找真实标签和预测值的差异。只不过在分类型算法中,这个差异...
  • * 森林里面有很多棵数,随机森林回归算法 * 包含N棵数,得到模型中也有N棵树 * 预测时,让所有的数的模型进行预测,获取平局值 * def trainRegressor( * input: RDD[LabeledPoint], * categoricalFeaturesInfo...
  • 随机森林参数选择

    万次阅读 多人点赞 2019-03-13 15:04:25
    基于随机森林回归任务(数据预处理、MAPE指标评估、可视化展示、特征重要性、预测和实际值差异显示图) https://blog.csdn.net/qq_40229367/article/details/88526749 数据与特征对随机森林的影响(特征对比、...
  • 本文的主要内容是基于Python机器学习基础教程决策树部分进行...集成是合并多个机器学习模型来构建更强大模型的方法,目前已经证明随机森林(random forest)作为决策树集成方法对大量分类和回归的数据集都是有效的。...
  • 集成学习—随机森林原理(理解与论文研读)

    千次阅读 多人点赞 2019-08-21 17:44:40
    随机森林(Random forest,简称RF)是由Leo Breiman在2001年在《Machine Learning》(2018年影响因子2.809)正式发表提出。正如上一篇博客中写的,随机森林属于集成学习中Bagging的典型算法。总的来说,随机森林就是...
  • 随机森林特征选择

    千次阅读 2020-07-15 22:33:47
    随机森林非常简单,易于实现,计算开销也很小,更令人惊奇的是它在分类和回归上表现出了十分惊人的性能,因此,随机森林也被誉为“代表集成学习技术水平的方法”。 本文是对随机森林如何用在特征选择上做一个简单的...
  • 随机森林回归应用中遇到的问题

    万次阅读 2017-04-21 11:09:08
    随机森林算法的应用本人在做kaggle的house prices题目时用到了随机森林回归的算法,遇到了一些问题,现在记录下来。 随机森立对于线性相关的特征是否有影响? 特征简化后效果会变好,为什么? 随机森林算法原理见...
  • 随机森林分类和回归python代码 详解

    万次阅读 热门讨论 2019-06-18 11:36:07
    文字部分: ... 数学的东西直接看代码。 ########################################################################## ...下面是给了数据集之后,训练随机森林的过程: 首先,咱们先来看一棵树的成长!确定好这棵...
  • MATLAB随机森林回归模型

    千次阅读 2016-03-06 17:36:00
    MATLAB随机森林回归模型: 调用matlab自带的TreeBagger.m T=textread('E:\datasets-orreview\discretized-regression\10bins\abalone10\matlab\test_abalone10.2'); X=textread('E:\datasets-orreview\...
  • 随机森林算法-中文

    2018-04-08 09:33:55
    spss modeler algorithms guide中的随机森林算法,中文。
  • 转载使用随机森林(R语言)做回归

    万次阅读 多人点赞 2018-06-08 08:58:16
    Corina 学定量 2016-01-25 阅读 2357 评论 0引言1 数据2 步骤2.1 安装randomForest包2.2 使用randomForest包2.3 导入数据2.4 数据的初步处理2.5 多元线性回归分析2.6 随机森林回归引言随机森林( random forest) ...
  • 这里我们将对波士顿房价的原始数据进行处理,在数据中人为添加一些缺失值,然后根据分三种情况:①用0填补缺失值,②均值填补,③用随机森林填补,之后分别构建随机森林回归,计算MSE,并做可视化。 1.导入相应包 ...
  • 随机森林 key: 随机森林 value:基模型 为Decision Tree 的Bagging 进一步增强随机性 value: Decision Tree value:最优维度、最优阈值 更快的训练速度(不用最优化分) from sklearn.ensemble import ...
  • 随机森林&特征选择

    万次阅读 2017-03-04 15:47:39
    根据模型的生成过程,随机森林可分为Forest-RI、Forest-RC等不同类型。这里对Forest-RI、Forest-RC进行简单的介绍。 1、Forest-RI: 在节点分裂时,随机的选择F个特征作为候选分裂特征,然后从这随机选择的F特征中...
  • from sklearn.linear_model import LinearRegression #导入线性回归包 from sklearn.linear_model import LogisticRegression #导入逻辑回归 from sklearn.model_selection import KFold #导入交叉验证包 from sklea...
  • 随机森林模型详解

    万次阅读 多人点赞 2019-03-17 21:43:57
    上世纪八十年代Breiman等人发明分类树算法,通过反复二分数据进行分类或回归,计算量大大降低,2001年Breiman把分类树组合成随机森林,即在变量(列)的使用和数据(行)的使用上进行随机化,生成很多分类树,再汇总分类...
  • 该软件能够对遥感数据应用随机森林分类和回归 档案文件 Classifcation_script.ipynb具有示例输出的jupyter笔记本 Classifcation_script.py -python脚本 准备数据和修改脚本 以tif格式准备遥感影像 训练和验证数据...
  • 随机森林算法

    2017-11-06 13:38:03
    随机森林回归分宜预测,比向量机精度好点随机森林 论文作者写的随机森林代码,采用matlab混合编程,需要安装Fortran compiler。。。 (An interface to the random forest algorithm (version 3.3) written by Leo ...
  • 文章目录随机森林与Adaboost一:随机森林1.1:随即森林思想1.2 随机森林的两个随机1.3:随机森林的步骤1.4 随机森林的优点1.5 随机森林的缺点二:Adaboost2.1: Boosting思想2.2:AdaBoost步骤2.3: AdaBoost优点2.4:...
  • 随机森林matlab代码

    千次下载 热门讨论 2013-07-02 17:27:31
    随机森林matlab代码,可运行。可用于分类和回归

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 602
精华内容 240
关键字:

随即森林回归