精华内容
下载资源
问答
  • 一、前言回归随机森林作为一种机器学习和数据分析领域常用且有效的算法,对其原理和代码实现过程的掌握是非常有必要的。为此,本文将着重介绍从零开始实现回归随机森林的过程,对于随机森林和决策树的相关理论原理将...

    d1e51b3ec2095c90340f45f3b7426370.png

    一、前言

    回归随机森林作为一种机器学习和数据分析领域常用且有效的算法,对其原理和代码实现过程的掌握是非常有必要的。为此,本文将着重介绍从零开始实现回归随机森林的过程,对于随机森林和决策树的相关理论原理将不做太深入的描述。本文的目的只是为了演示回归随机森林主要功能的具体实现过程,在实现过程中不会考虑代码性能,会更加注重代码可读性。

    实现语言:Python

    依赖:pandas, numpy

    二、原理介绍

    随机森林属于Bagging类算法,而Bagging 又属于集成学习一种方法(集成学习方法大致分为Boosting和Bagging方法,两个方法的不同请参考[10]),集成学习的大致思路是训练多个弱模型打包起来组成一个强模型,强模型的性能要比单个弱模型好很多(三个臭皮匠顶一个诸葛亮。注意:这里的弱和强是相对的),其中的弱模型可以是决策树、SVM等模型,在随机森林中,弱模型选用决策树。

    在训练阶段,随机森林使用bootstrap采样从输入训练数据集中采集多个不同的子训练数据集来依次训练多个不同决策树;在预测阶段,随机森林将内部多个决策树的预测结果取平均得到最终的结果。本文主要介绍回归随机森林从零实现的过程,实现的RFR(回归随机森林)具有以下功能:

    • 模型训练
    • 模型数据预测
    • 计算feature importance

    2.1 模型训练

    2.1.1 基础理论

    本文实现的RFR是将多个二叉决策树(CART,这也是sklearn,spark内部实现的模型打包组合而成的,训练RFR便是训练多个二叉决策树。在训练二叉决策树模型的时候需要考虑怎样选择切分变量(特征)、切分点以及怎样衡量一个切分变量、切分点的好坏。针对于切分变量和切分点的选择,本实现采用穷举法,即遍历每个特征和每个特征的所有取值,最后从中找出最好的切分变量和切分点;针对于切分变量和切分点的好坏,一般以切分后节点的不纯度来衡量,即各个子节点不纯度的加权和

    ,其计算公式如下:

    (2-1)

    其中,

    为某一个切分变量,
    为切分变量的一个切分值,
    分别为切分后左子节点的训练样本个数、右子节点的训练样本个数以及当前节点所有训练样本个数,
    分为左右子节点的训练样本集合,
    为衡量节点不纯度的函数(impurity function/criterion),分类和回归任务一般采用不同的不纯度函数,在分类和回归常采用的不纯度函数有以下四种:

    7f1a10873db1c6efbde20af4c2123fda.png
    图 1. 四种不同的impurity function
    • 备注1:

    Gini不纯度只适用于分类任务,

    为当前节点的训练样本集合,
    为当前节点训练样本中目标变量取值k(
    )出现的概率。
    • 备注2:

    信息熵只适用于分类任务, 其他同备注1。

    • 备注3

    MSE只适用于回归任务,

    为当前节点样本目标变量的平均值。
    • 备注4

    MAE只适用于回归任务,

    为当前节点样本目标变量的平均值。
    • 备注5

    sklearn内部,DecisionTreeClassifier, RandomForestClassifier等基于决策树的分类模型默认使用'gini'作为impurity function也可通过criterion参数指定为'entropy' DecisionTreeRegressor, RandomForestRegressor等基于决策树的回归模型默认使用'mse'作为impurity function也可通过criterion参数指定为'mae'

    决策树中某一节点的训练过程在数学等价于下面优化问题:

    (2-2)

    即寻找

    最小的切分变量和切分点。

    在本文实现的回归随机森林中,

    选用MSE,即针对某一切分点

    (2-3)

    2.1.2 训练过程

    RFR训练过程示意图如图2所示。

    adb372fc6cf92f041beeea31f6fa723d.png
    图 2. RFR训练示意图

    说明:

    • bootstrap[1]是对输入训练样本集合
      进行
      N次放回重复抽样得到样本集合
      (
      N一般等于
      的大小[2],具体可以查看
      sklearn的实现代码),这暗示了
      中的某些样本会在
      中重复出现多次。在对
      进行bootstrap采样时,
      中每个样本会以
      63.3%的概率被抽中。为什么是63.3%?考虑N次放回重复抽样,每次抽样每个样本被选中的概率为
      ,进行N次抽样,被选中概率为:

    (2-4)

    具体可以参考[3-4]。

    • subsample会根据输入参数sample_sz的大小从
      中采样
      sample_sz个样本组成subsample样本集合
      (在
      sklearn中,subsample大小就是输入训练样本集合
      的大小N,不可以通过输入参数指定subsample的大小,详见这里)。
    • 为什么要进行bootstrap? 集成学习(包括随机森林)的目的是为了使用多个不同的子模型来增加最终模型预测结果的鲁棒性和稳定性(即减小方差),如果多个子模型都采用同样的数据集训练,那么训练得出的子模型都是相同的,集成学习将变得没有意义,为了能从原输入训练数据集得到多个不同的数据集,需要使用bootstrap来从原数据集采样出不同的子数据集来训练子模型。

    图2中n个回归决策树的训练过程如图3所示。

    526ae52cffeb25d65bb2ca098d68946f.png
    图 3. 回归决策树训练过程

    2.2 模型预测

    RFR的预测结果是由内部所有二叉决策树的预测结果取平均值得到的。二叉决策树的预测过程主要分为以下步骤:

    1. 针对某一输入样本,从二叉决策树的根节点起,判断当前节点是否为叶子节点,如果是则返回叶子节点的预测值(即当前叶子中样本目标变量的平均值),如果不是则进入下一步;
    2. 根据当前节点的切分变量的和切分值,将样本中对应变量的值与节点的切分值对比。如果样本变量值小于等于当前节点切分值,则访问当前节点的左子节点;如果样本变量值大于当前节点切分值,则访问当前节点的右子节点;
    3. 循环步骤2,直到访问到叶子节点,并返回叶子节点的预测值。

    2.3 计算feature importance

    特征的重要性表示特征对预测结果影响程度,某一特征重要性越大,表明该特征对预测结果的影响越大,重要性越小,表明该特征对预测结果越小。RFR中某一特征的重要性,是该特征在内部所有决策树重要性的平均值,而在决策树中,计算某一个特征的重要性可以采用以下三种方法:

    方法1

    步骤如下:

    • 使用训练数据训练模型;
    • 计算训练数据在模型上依据某一metric的score,记为
      (在回归中,可以选用r2);
    • 遍历训练数据集中的每一个feature,每次在原训练数据集的基础上将对应的feature进行shuffle操作,然后使用模型得到shuffle后数据集的score,记为
      ,最后通过
      计算出第
      个feature的重要性。

    方法2

    如果一个feature很重要,那么从数据集中去除该feature后,模型的prediction error会增大;相反,如果一个feature不重要,那么从数据集中去除后,模型的prediction error不会变化太大。该方法的步骤如下:

    • 使用原数据集训练模型,并评估模型在训练数据集上的prediction error,记为
      ;
    • 遍历训练数据集中的每一个feature,每次从原训练数据集的基础上去除该feature,然后使用得到数据集训练模型,最终计算出prediction error,记为
      ,最后通过
      计算出第
      个feature的重要性。

    该方法和方法1有点类似,但该方法在计算每个feature的重要性的时候都需要重新训练模型,会增加额外的计算量,在实际应用一般不采用该方法。

    方法3

    该方法是sklearn内部树模型计算feature重要性时采用的方法。即某一节点

    的重要性为

    (2-5)

    其中,

    分别为节点
    以及其左右子节点中训练样本个数与总训练样本数目的比例,
    分为为节点
    以及其左右子节点的不纯度。知道每一个节点的重要性之后,即可通过公式(2-6)得出某一feature的重要性。

    (2-6)

    为了使所有feature的重要性加起来等于1,需要每一feature的重要性进行normalization,即公式(2-7)

    (2-7)

    方法3在sklearn中的实现,请查看_tree.pyx。

    在本文实现的RFR中,同时实现了方法1方法3

    三、回归随机森林实现

    3.1 代码

    代码有点长,不想看的可以直接跳过。

    from 

    3.2 测试

    训练与预测:

    8b5abcd5b4088487023dfde477152d67.png

    使用sklearn内部的RandomForestRegressor的结果:

    111b6206759332090f752b03fef08c00.png

    需要注意的是,上面两次训练的样本不同,所以和实际情况有点出入,但大体趋势是对。

    feature importance:

    RFRegressor采用方法3计算的feature重要性:

    4c8b8964fb9095efffee9836327a33d0.png

    RandomForestRegressor计算的feature重要性:

    ee674f2f416a935d8dc78af0821548d4.png

    RFRegressor采用方法1计算的feature重要性:

    1ed88bdcf388c4f44d76ce82a3809c0b.png

    参考与荐读:

    [1] Bootstrap Sample: Definition, Example
    [2] Number of Samples per-Tree in a Random Forest
    [3] Why on average does each bootstrap sample contain roughly two thirds of observations?
    [4] Random Forests out-of-bag sample size
    [5] Random Forests Leo Breiman and Adele Cutler
    [6] Why is Random Forest with a single tree much better than a Decision Tree classifier?
    [7] Winning the bias-variance tradeoff
    [8] subsample-bootstrapping
    [9] How can SciKit-Learn Random Forest sub sample size may be equal to original training data size?
    [10] the difference between bagging and boosting
    [11] The Mathematics of Decision Trees, Random Forest and Feature Importance in Scikit-learn and Spark
    [12] Sklearn Decision Trees documentation

    展开全文
  • Breiman 发明的随机森林原理并不复杂, 和 bagging 类似, 它对原始数据集做很多次放回抽样, 每次抽取和样本量同样多的观测值, 由于是放回抽样, 每次都有一些观测值没有抽到, 一些观测值会重复抽到, 如此会得到很多...

    决策树

    import pandas as pd
    import numpy as np
    import graphviz
    from sklearn.tree import DecisionTreeRegressor
    from sklearn import tree
    
    X = np.array(data[['C', 'E']])  # Create an array
    y = np.array(data['NOx'])
    
    regt = DecisionTreeRegressor(max_depth=4)
    
    regt = regt.fit(X, y)  # Build a decision tree regressor from the training set (X, y)
    
    dot_data = tree.export_graphviz(regt, out_file=None)  # Export a decision tree in DOT format
    
    graph = graphviz.Source(dot_data)
    
    graph.render("tree")  # Save the source to file

    这里写图片描述
    [注]

    节点属性:

    • X[1]X = np.array(data[['C', 'E']])中的E列,为特征值
    • samples:样本的数量
    • mse:均方误差(mean-square error, MSE)是反映估计量与被估计量之间差异程度的一种
    • value:平均值

    print(regt.score(X, y))
    ------------------------------------
    0.949306568162
    regt1 = regt.fit(X[:, 1].reshape(-1, 1), y)  # reshape(-1, 1) 将数组改为 多行1列
    
    dot_data = tree.export_graphviz(regt, out_file=None)
    
    graph = graphviz.Source(dot_data)
    
    graph.render("tree1")
    
    regt1.score(X[:, 1].reshape(-1, 1), y)

    这里写图片描述

    对比过后,发现 treetree1 完全相同


    u = np.sort(np.unique(X[:, 1]))
    t = np.diff(u)/2+u[:-1]  # diff() 后一个元素减去前一个元素
    
    #
    mse = []
    mse1 = []
    mse2 = []
    for i in t:
        m1 = (y[X[:, 1] < i]-np.mean(y[X[:, 1] < i]))**2  # X[:, 1] 取该二维数组第二列所有数据
        m2 = (y[X[:, 1] > i]-np.mean(y[X[:, 1] > i]))**2
        mse1.append(np.mean(m1))  # “拍脑袋”平方和
        mse2.append(np.mean(m2))  # “拍脑袋”平方和
        mse.append((np.sum(m1)+np.sum(m2))/len(y))
    I = np.argmin(mse)  # 求mse最小值的index
    
    MSE0 = np.mean((y-np.mean(y))**2)
    print("Original total MSE={}\nSplit point={}\nMin mse={}\nLeft mse={}\nRight mse={}".format(MSE0, I, mse[I], mse1[I], mse2[I]))
    -------------------------------------------------------------------------------
    Original total MSE=1.26845241619
    Split point=60
    Min mse=0.854108834661
    Left mse=1.13202721562
    Right mse=0.0686873232514

    上述代码的函数形式

    def spl(X, y):
        u = np.sort(np.unique(X))
        t = np.diff(u)/2+u[:-1]
        mse = []
        mse1 = []
        mse2 = []
        for i in t:
            m1 = (y[X < i]-np.mean(y[X < i]))**2
            m2 = (y[X > i]-np.mean(y[X > i]))**2
            mse1.append(np.mean(m1))
            mse2.append(np.mean(m2))
            mse.append((np.sum(m1)+np.sum(m2))/len(y))
        i = np.argmin(mse)
    
        return mse[i], t[i], mse1[i], mse2[i]
    
    
    print(spl(X[:, 1], y))
    print(spl(X[:,0], y))
    ------------------------------------------------------------------
    (0.8541088346609912, 1.0945, 1.1320272156213018, 0.06868732325141778)
    (1.264189318071551, 13.5, 1.103670472054112, 1.5072607134693878)
    def FCV(x, y, regr, cv=10, seed=2015):
    
        np.random.seed(seed)
        ind = np.arange(len(y))
        np.random.shuffle(ind)  # 随机化下标
    
        X_folds = np.array_split(x[ind], cv)
        y_folds = np.array_split(y[ind], cv)
    
        X2 = np.empty((0, X.shape[1]), float)
        y2 = np.empty((0, y.shape[0]), float)
        yp = np.empty((0, y.shape[0]), float)
    
        for k in range(cv):
            X_train = list(X_folds)  # 只有list才能pop
            X_test  = X_train.pop(k)  # 从中取出第k份
            X_train = np.concatenate(X_train)  # 合并剩下的cv-1份
    
            y_train = list(y_folds)
            y_test = y_train.pop(k)
            y_train = np.concatenate(y_train)
    
            regr.fit(X_train, y_train)  # 拟合选中的regr模型
    
            y2 = np.append(y2, y_test)
            X2 = np.append(X2, X_test)
            yp = np.append(yp, regr.predict(X_test))
    
        nmse = np.sum((y2-yp)**2)/np.sum((y2-np.mean(y2))**2)
        r2 = 1-nmse
        return np.array([nmse, r2])

    求出 线性回归 LinearRegression 和 决策树 DecisionTreeRegressor 所对应的 NMSER^2

    from sklearn.linear_model import LinearRegression
    from sklearn.tree import DecisionTreeRegressor
    names = ["Linear Regression", "Decision Tree"]
    regressors = [LinearRegression(), DecisionTreeRegressor(max_depth=4)]
    
    A = np.empty((0, 2), float)
    
    for reg in regressors:
        tt = np.array(FCV(X, y, reg, 8))
        tt.shape = (1, 2)  # 一行二列
        A = np.append(A, tt, axis=0)  # 把各种方法的回归结果合并
    
    print(A)
    -----------------------------------------------------------------
    [[ 1.06233633 -0.06233633]
     [ 0.15896376  0.84103624]]
    import matplotlib.pyplot as plt
    
    fig = plt.figure(figsize=(20, 10))
    
    ax = fig.add_subplot(121)
    ax.bar(np.arange(np.array(A).shape[0]), np.array(A)[:, 0])
    
    ax.set_xticklabels(names)  # 标注回归方法
    fig.autofmt_xdate()  # 回归方法标注斜放
    
    ax.set_ylabel('NMSE')
    ax.set_title('NMSE')
    ax.set_xticks(np.arange(np.array(A).shape[0]) + 0.35)
    
    bx = fig.add_subplot(122)
    bx.bar(np.arange(np.array(A).shape[0]), np.array(A)[:, 1])
    bx.set_xticklabels(names)
    
    fig.autofmt_xdate()
    
    bx.set_ylabel('Score')
    bx.set_title('Score')
    bx.set_xticks(np.arange(np.array(A).shape[0]) + 0.35)
    
    plt.savefig("examples.jpg")

    这里写图片描述

    Score R2 R 2


    bagging 是由 Breiman 提出的一个简单的组合模型, 它对原始数据集做很多次放回抽样, 每次抽取和样本量同样多的观测值, 放回抽样使得每次都有大约百分之三十多的观测值没有抽到, 另一些观测值则会重复抽到, 如此得到很多不同的数据集, 然后对于每个数据集建立一个决策树, 因此产生大量决策树. 对于回归来说, 一个新的观测值通过如此多的决策树得到很多预测值, 最终结果为这些预测值的简单平均.

    from sklearn.ensemble import BaggingRegressor
    
    regr = BaggingRegressor(n_estimators=100, oob_score=True, random_state=1010)
    regr.fit(X, y.ravel())
    
    print("Score:", regr.score(X, y))  # Score为可决系数R^2
    print("NMSE:", 1-regr.score(X, y))  # 标准化均方误差 NMSE

    Breiman 发明的随机森林的原理并不复杂, 和 bagging 类似, 它对原始数据集做很多次放回抽样, 每次抽取和样本量同样多的观测值, 由于是放回抽样, 每次都有一些观测值没有抽到, 一些观测值会重复抽到, 如此会得到很多不同的数据集, 然后对于每个数据集建立一个决策树, 因此产生大量决策树. 和 bagging 不同的是, 在随机森林每棵树的每个节点, 拆分变量不是由所有变量竞争, 而是由随机挑选的少数变量竞争, 而且每棵树都长到底. 拆分变量候选者的数目限制可以避免由于强势变量主宰而忽略的数据关系中的细节, 因而大大提高了模型对数据的代表性. 随机森林的最终结果是所有树的结果的平均, 也就是说, 一个新的观测值, 通过许多棵树(比如 n 棵)得到 n 个预测值, 最终用这 n 个预测值的平均作为最终结果.

    from sklearn.ensemble import RandomForestRegressor
    from sklearn.datasets import make_regression
    
    regr = RandomForestRegressor(n_estimators=500, oob_score=True, random_state=1010)
    regr.fit(X, y.ravel())
    print("Variable importance:\n", regr.feature_importances_)
    print("Score:\n", regr.oob_score_)
    ---------------------------------------------------------------------]
    ('Variable importance:\n', array([0.03731845, 0.00096088, 0.00580794, 0.00074913, 0.02247829,
           0.43575755, 0.01257118, 0.06612205, 0.00307613, 0.01341358,
           0.01549635, 0.0116068 , 0.37464165]))
    ('Score:\n', 0.8829155069608635)
    
      <font color=red >问题:score 代表的是 可决系数R^2 吗?</font>
    展开全文
  • 使用了三种集成回归模型 git:https://github.com/linyi0604/MachineLearning 代码: 1 from sklearn.datasets import load_boston 2 from sklearn.cross_validation import train_test_split 3 f...

    python3 学习机器学习api

    使用了三种集成回归模型

    git: https://github.com/linyi0604/MachineLearning

    代码:

      1 from sklearn.datasets import load_boston
      2 from sklearn.cross_validation import train_test_split
      3 from sklearn.preprocessing import StandardScaler
      4 from sklearn.ensemble import RandomForestRegressor, ExtraTreesRegressor, GradientBoostingRegressor
      5 from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
      6 import numpy as np
      7 
      8 '''
      9 随机森林回归
     10 极端随机森林回归
     11 梯度提升回归
     12 
     13 通常集成模型能够取得非常好的表现
     14 '''
     15 
     16 # 1 准备数据
     17 # 读取波士顿地区房价信息
     18 boston = load_boston()
     19 # 查看数据描述
     20 # print(boston.DESCR)   # 共506条波士顿地区房价信息,每条13项数值特征描述和目标房价
     21 # 查看数据的差异情况
     22 # print("最大房价:", np.max(boston.target))   # 50
     23 # print("最小房价:",np.min(boston.target))    # 5
     24 # print("平均房价:", np.mean(boston.target))   # 22.532806324110677
     25 
     26 x = boston.data
     27 y = boston.target
     28 
     29 # 2 分割训练数据和测试数据
     30 # 随机采样25%作为测试 75%作为训练
     31 x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state=33)
     32 
     33 # 3 训练数据和测试数据进行标准化处理
     34 ss_x = StandardScaler()
     35 x_train = ss_x.fit_transform(x_train)
     36 x_test = ss_x.transform(x_test)
     37 
     38 ss_y = StandardScaler()
     39 y_train = ss_y.fit_transform(y_train.reshape(-1, 1))
     40 y_test = ss_y.transform(y_test.reshape(-1, 1))
     41 
     42 # 4 三种集成回归模型进行训练和预测
     43 # 随机森林回归
     44 rfr = RandomForestRegressor()
     45 # 训练
     46 rfr.fit(x_train, y_train)
     47 # 预测 保存预测结果
     48 rfr_y_predict = rfr.predict(x_test)
     49 
     50 # 极端随机森林回归
     51 etr = ExtraTreesRegressor()
     52 # 训练
     53 etr.fit(x_train, y_train)
     54 # 预测 保存预测结果
     55 etr_y_predict = rfr.predict(x_test)
     56 
     57 # 梯度提升回归
     58 gbr = GradientBoostingRegressor()
     59 # 训练
     60 gbr.fit(x_train, y_train)
     61 # 预测 保存预测结果
     62 gbr_y_predict = rfr.predict(x_test)
     63 
     64 # 5 模型评估
     65 # 随机森林回归模型评估
     66 print("随机森林回归的默认评估值为:", rfr.score(x_test, y_test))
     67 print("随机森林回归的R_squared值为:", r2_score(y_test, rfr_y_predict))
     68 print("随机森林回归的均方误差为:", mean_squared_error(ss_y.inverse_transform(y_test),
     69                                           ss_y.inverse_transform(rfr_y_predict)))
     70 print("随机森林回归的平均绝对误差为:", mean_absolute_error(ss_y.inverse_transform(y_test),
     71                                              ss_y.inverse_transform(rfr_y_predict)))
     72 
     73 # 极端随机森林回归模型评估
     74 print("极端随机森林回归的默认评估值为:", etr.score(x_test, y_test))
     75 print("极端随机森林回归的R_squared值为:", r2_score(y_test, gbr_y_predict))
     76 print("极端随机森林回归的均方误差为:", mean_squared_error(ss_y.inverse_transform(y_test),
     77                                             ss_y.inverse_transform(gbr_y_predict)))
     78 print("极端随机森林回归的平均绝对误差为:", mean_absolute_error(ss_y.inverse_transform(y_test),
     79                                                ss_y.inverse_transform(gbr_y_predict)))
     80 
     81 # 梯度提升回归模型评估
     82 print("梯度提升回归回归的默认评估值为:", gbr.score(x_test, y_test))
     83 print("梯度提升回归回归的R_squared值为:", r2_score(y_test, etr_y_predict))
     84 print("梯度提升回归回归的均方误差为:", mean_squared_error(ss_y.inverse_transform(y_test),
     85                                             ss_y.inverse_transform(etr_y_predict)))
     86 print("梯度提升回归回归的平均绝对误差为:", mean_absolute_error(ss_y.inverse_transform(y_test),
     87                                                ss_y.inverse_transform(etr_y_predict)))
     88 
     89 '''
     90 随机森林回归的默认评估值为: 0.8391590262557747
     91 随机森林回归的R_squared值为: 0.8391590262557747
     92 随机森林回归的均方误差为: 12.471817322834646
     93 随机森林回归的平均绝对误差为: 2.4255118110236227
     94 
     95 极端随机森林回归的默认评估值为: 0.783339502805047
     96 极端随机森林回归的R_squared值为: 0.8391590262557747
     97 极端随机森林回归的均方误差为: 12.471817322834646
     98 极端随机森林回归的平均绝对误差为: 2.4255118110236227
     99 
    100 GradientBoostingRegressor回归的默认评估值为: 0.8431187344932869
    101 GradientBoostingRegressor回归的R_squared值为: 0.8391590262557747
    102 GradientBoostingRegressor回归的均方误差为: 12.471817322834646
    103 GradientBoostingRegressor回归的平均绝对误差为: 2.4255118110236227
    104 '''

     

    转载于:https://www.cnblogs.com/Lin-Yi/p/8972051.html

    展开全文
  • 随机森林回归算法

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

    展开全文
  • 随机森林(Random Forest)算法原理

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

    千次阅读 2017-07-08 17:21:39
    随机森林原理详解
  • 定义:随机森林指的是利用多棵决策树对样本进行训练并预测的一种分类器。可回归可分类。所以随机森林是基于多颗决策树的一种集成学习算法,常见的决策树算法主要有以下几种:1. ID3:使用信息增益g(D,A)进行特征选择...
  • 随机森林原理

    2020-10-03 19:27:44
    2 随机森林的特点3 随机森林的相关基础知识4 随机森林的生成5 袋外错误率(oob error)6 随机森林工作原理解释的一个简单例子7 随机森林的Python实现8 参考内容 回到顶部 1 什么是随机森林?  作为新兴起的、高度...
  • 上一篇,讲述了如何用决策树进行分类,这一篇,就写一写如何用决策树进行回归 上一篇地址:https://blog.csdn.net/MR_Trustin/article/details/96886157 二)sklearn.tree.DecisionTreeRegressor参数及说明 官方...
  • Matlab TreeBagger随机森林回归实例

    万次阅读 多人点赞 2020-03-12 11:34:33
    本文介绍在Matlab平台如何使用自带函数和测试数据实现回归森林,对于随机森林和决策树的相关理论原理将不做太深入的描述。 算法流程 (1)加载Matlab测试数据集; (2)获取计算机性能,以便最好地利用其性能; (3...
  • 决策树(这里作为一个大类)也包含分类(剪枝决策树分类器、随机森林)和回归回归随机森林)。 1.1 实现原理 这里列举一些比较好的文章 决策树[1,2,3] 随机森林[1,2,3] 回归随机森林[1,2,3] 1.2 在使用决策...
  • 随机森林算法工作原理

    千次阅读 2019-02-27 16:42:55
    在这篇文章中,你将了解到随机森林算法的工作原理以及适用范围。   机器学习算法之随机森林算法工作原理 随机森林是一种有监督学习算法。 就像你所看到的它的名字一样,它创建了一个森林,并使它拥有某种方式...
  • 集成算法 ensemble 通过在数据集上构建多个模型,集成所有模型的建模结果,得到一个综合的结果,以此来获得比单个 ...装袋法的代表模型就是随机森林 提升法boosting: 基评估器是相关的,是按顺序一一...
  • 随机森林基本原理

    万次阅读 2017-01-17 10:48:04
    基础内容:这里只是准备简单谈谈基础的内容,主要参考一下别人的文章,对于随机森林与GBDT,有两个地方比较重要,首先是information gain,其次是决策树。这里特别推荐Andrew Moore大牛的Decision Trees Tutorial,...
  • 用Python实现随机森林回归

    万次阅读 多人点赞 2020-11-02 13:19:38
    这里就对如何进行随机森林回归在算法上进行概述,在参数上进行详述。希望对你的工作有所帮助。 这里,将介绍如何在Python中构建和使用Random Forest回归,而不是仅仅显示代码,同时将尝试了解模型的工作原理。 1.1 ...
  • 随机森林算法原理

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

空空如也

空空如也

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

回归原理随机森林