bagging算法_bagging算法应用 - CSDN
精华内容
参与话题
  •   在讲boosting和bagging算法之前,首先需要了解一下集成学习的概念。集成学习是指将若干弱分类器组合之后产生一个强分类器。弱分类器(weak learner)指那些分类准确率只稍好于随机猜测的分类器(error rate )。...

    一、集成学习简介
      在讲boosting和bagging算法之前,首先需要了解一下集成学习的概念。集成学习是指将若干弱分类器组合之后产生一个强分类器。弱分类器(weak learner)指那些分类准确率只稍好于随机猜测的分类器(error rate < 50%)。如今集成学习有两个流派,一种是bagging流派,它的特点是各个弱学习器之间没有依赖关系,可以并行拟合,随机森林算法就属于bagging派系;另一个是boosting派系,它的特点是各个弱学习器之间有依赖关系,Adaboost算法就属于boosting派系。在实现集成学习算法时,很重要的一个核心就是如何实现数据的多样性,从而实现弱分类器的多样性。集成学习的思想如下图所示:

    这里写图片描述

    集成学习有如下的特点:
      (1)将多个分类方法聚集在一起,以提高分类的准确率(这些算法可以是不同的算法,也可以是相同的算法。);
      (2)集成学习法由训练数据构建一组基分类器,然后通过对每个基分类器的预测进行投票来进行分类;
      (3)严格来说,集成学习并不算是一种分类器,而是一种分类器结合的方法;
      (4)通常一个集成分类器的分类性能会好于单个分类器;
      (5)如果把单个分类器比作一个决策者的话,集成学习的方法就相当于多个决策者共同进行一项决策。
    二、bagging算法
    2.1、bagging算法思想
      bagging是bootstrap aggregating的缩写。该算法的思想是让学习算法训练多轮,每轮的训练集由从初始的训练集中随机取出的n个训练样本组成,某个初始训练样本在某轮训练集中可以出现多次或根本不出现(即所谓的有放回抽样),训练之后可得到一个预测函数序列h_1,⋯ ⋯h_n ,最终的预测函数H对分类问题采用投票方式,对回归问题采用简单平均方法对新示例进行判别。上面的算法思想可通过下图来进行理解:

    这里写图片描述

    算法的基本流程为:
      输入为样本集D={(x,y1),(x2,y2),…(xm,ym)}D={(x,y1),(x2,y2),…(xm,ym)},弱学习器算法, 弱分类器迭代次数T。
      输出为最终的强分类器f(x)f(x)
      (1)对于t=1,2…,T:(a)对训练集进行第t次随机采样,共采集m次,得到包含m个样本的采样集Dm;(b)用采样集DmDm训练第m个弱学习器Gm(x);
      (2) 如果是分类算法预测,则T个弱学习器投出最多票数的类别或者类别之一为最终类别。如果是回归算法,T个弱学习器得到的回归结果进行算术平均得到的值为最终的模型输出。
    2.2、bagging算法案例
      为了更好理解bagging的概念,提供下面一个例子。
    X 表示一维属性,Y 表示类标号(1或-1)测试条件:当x<=k时,y=?;当x>k时,y=?;k为最佳分裂点
      下表为属性x对应的唯一正确的y类别。

    这里写图片描述

      现在进行5轮随机抽样,结果如下:

    这里写图片描述

      每一轮随机抽样后,都生成一个分类器。然后再将五轮分类融合。

    这里写图片描述

      对比符号和实际类,我们可以发现:在该例子中,Bagging使得准确率可达90%。由此,总结一下bagging方法:
      (1) Bagging通过降低基分类器的方差,改善了泛化误差;
      (2)其性能依赖于基分类器的稳定性;如果基分类器不稳定,bagging有助于降低训练数据的随机波动导致的误差;如果稳定,则集成分类器的误差主要由基分类器的偏倚引起;
      (3)由于每个样本被选中的概率相同,因此bagging并不侧重于训练数据集中的任何特定实例。

    三、boosting算法
    3.1、boosting算法的基本思想
      boosting算法是Adaptive boosting的缩写,是一种迭代算法。每轮迭代中会在训练集上产生一个新的分类器,然后使用该分类器对所有样本进行分类,以评估每个样本的重要性(informative)。
      具体来说,算法会为每个训练样本赋予一个权值。每次用训练完的新分类器标注各个样本,若某个样本点已被分类正确,则将其权值降低,并以该权重进行下一次数据的抽样(抽中的概率减小);若样本点未被正确分类,则提高其权值,并以该权重进行下一次数据的抽样(抽中的概率增大)。权值越高的样本在下一次训练中所占的比重越大,也就是说越难区分的样本在训练过程中会变得越来越重要。 整个迭代过程直到错误率足够小或达到一定次数才停止。

    这里写图片描述

    3.2、boosting算法的案例
      以下图为例,来说明boosting算法的核心思想:

    这里写图片描述

      由图可以发现,boosting算法在迭代的过程中不断加强识别错误样本的学习比重,从而实现最终的强化学习。

    四、Bagging和Boosting算法的区别
      (1) bagging的训练集是随机的,各训练集是独立的;而boosting训练集的选择不是独立的,每一次选择的训练集都依赖于上一次学习的结果;
      (2) bagging的每个预测函数都没有权重;而boosting根据每一次训练的训练误差得到该次预测函数的权重;
      (3) bagging的各个预测函数可以并行生成;而boosting只能顺序生成。(对于神经网络这样极为耗时的学习方法,bagging可通过并行训练节省大量时间开销)。

    展开全文
  • Bagging算法原理

    千次阅读 2019-03-14 11:36:56
    Bagging是并行式集成学习方法的典型代表,它直接基于自助采样法。给定包含m个样本的数据集,我们先随机取出一个样本放入采样中,再把该样本放回初始数据集,使得下次采样时该样本仍有可能被选中。这样,经过m次随机...

      Bagging是并行式集成学习方法的典型代表,它直接基于自助采样法。给定包含m个样本的数据集,我们先随机取出一个样本放入采样中,再把该样本放回初始数据集,使得下次采样时该样本仍有可能被选中。这样,经过m次随机采样操作,我们得到含m个样本的采样集,初始训练集中有的样本在采样集里多次出现,有的则从未出现。初始训练集中约有63.2%的样本出现在采样集中。

      照这样,我们可采样出T个含m个训练样本的采样集,然后基于每个采样集训练出一个基学习器,再将这些基学习器进行结合。这就是Bagging的基本流程。在对预测输出进行结合时,Bagging通常对分类任务使用简单投票法,对回归任务使用简单平均法。若分类预测时出现两个收到同样票数的情形,则最简单的做法是随机选择一个,也可进一步考察学习器投票的置信度来确定最终胜者。

      与标准AdaBoost只适用于二分类任务不同,Bagging能不经修改地用于多分类、回归等任务。

      值得一提的是,自助采样过程还给Bagging带来了另一个优点:由于每个基学习器只使用了初始训练集中约63.2%的样本,剩下的36.8%的样本可用作验证集对泛化性能进行“包外估计”,为此,记录每个基学习器的训练样本。不妨令\large D_t表示\large h_t实际使用的训练样本集,令\large H^{oob}(x)表示对样本\large x的包外预测,即仅考虑那些未使用\large x训练的基学习器在\large x上的预测,有

    \large H^{oob}(x)=\mathop\arg\max_{y\in Y}\sum_{t=1}^T\mathbb{I}(h_t(x)=y)\mathbb{I}(x\notin D_t)

    则Bagging泛化误差的包外估计为:

    \large \epsilon ^{oob}=\frac{1}{|D|}\sum_{(x,y)\in D}\mathbb{I}(H^{oob}(x)\neq y)

      事实上,包外样本还有许多其他用途,例如当基学习器是决策树时,可使用包外样本来辅助剪枝,或用于估计决策树中各节点的后验概率以辅助对零训练样本节点的处理;当学习器是神经网络时,可使用包外样本来辅助早期停止以减小过拟合风险。

      从偏差-方差的角度来看,Bagging主要关注降低方差,因此它在不剪枝决策树、神经网络等容易受样本扰动的学习器上效果更为明显。

    展开全文
  • 机器学习 —— Bagging算法

    千次阅读 2018-02-18 16:06:42
    Bagging算法 特点: Boosting是一种框架算法,以随机森林(RDF)算法为代表。 采用的是随机有放回的选择训练数据然后构造分类器,最后组合。 从原始样本集中使用Bootstraping方法随机抽取n个训练样本,共进行k...

    Bagging算法

    特点:

    1. Boosting是一种框架算法,以随机森林(RDF)算法为代表。
    2. 采用的是随机有放回的选择训练数据然后构造分类器,最后组合。
    3. 从原始样本集中使用Bootstraping方法随机抽取n个训练样本,共进行k轮抽取,得到k个训练集。(k个训练集之间相互独立,元素可以有重复)
    4. 对于k个训练集,我们训练k个模型(这k个模型可以根据具体问题而定,比如决策树,knn等)
    5. 对于分类问题:由投票表决产生分类结果;对于回归问题:由k个模型预测结果的均值作为最后预测结果。(所有模型的重要性相同)

    图示

    这里写图片描述


    随机森林算法(Random Forests)

    算法的优缺点

    随机森林的主要优点是:

    1. 具有极高的准确率
    2. 随机性的引入,使得随机森林不容易过拟合
    3. 随机性的引入,使得随机森林有很好的抗噪声能力
    4. 能处理很高维度的数据,并且不用做特征选择
    5. 既能处理离散型数据,也能处理连续型数据,数据集无需规范化
    6. 训练速度快,可以得到变量重要性排序
    7. 容易实现并行化

    随机森林的主要缺点是:

    1. 当随机森林中的决策树个数很多时,训练时需要的空间和时间会较大
    2. 随机森林模型还有许多不好解释的地方,有点算个黑盒模型

    算法过程

    1. 从原始训练集中使用Bootstraping方法随机有放回采样选出m个样本,共进行n_tree次采样,生成n_tree个训练集
    2. 对于n_tree个训练集,我们分别训练n_tree个决策树模型
    3. 对于单个决策树模型,假设训练样本特征的个数为n,那么每次分裂时根据信息增益/信息增益比/基尼指数选择最好的特征进行分裂
    4. 每棵树都一直这样分裂下去,直到该节点的所有训练样例都属于同一类。在决策树的分裂过程中不需要剪枝
    5. 将生成的多棵决策树组成随机森林。对于分类问题,按多棵树分类器投票决定最终分类结果;对于回归问题,由多棵树预测值的均值决定最终预测结果

    图示

    这里写图片描述

    展开全文
  • bagging算法

    2020-07-26 23:32:59
    Bagging的策略: 从样本集中用Bootstrap采样选出n个样本 在所有属性上 对这n个样本建立分类器(CART or SVM or ) 重复以上两步m次 i e build m个分类器(CART or SVM or ) 将数据放在这m个分类器上跑 最后vote看...
  • 集成算法中的Bagging

    万次阅读 多人点赞 2018-01-16 14:16:10
    Bagging meta-estimator 基本描述 在集成算法中,bagging 方法会在原始训练集的随机子集上构建一类黑盒估计器的多个实例,然后把这些估计器的预测结果结合起来形成最终的预测结果。 该方法通过在构建模型的过程...

    Bagging meta-estimator

    基本描述

    在集成算法中,bagging 方法会在原始训练集的随机子集上构建一类黑盒估计器的多个实例,然后把这些估计器的预测结果结合起来形成最终的预测结果。 该方法通过在构建模型的过程中引入随机性,来减少基估计器的方差(例如,决策树)。 在多数情况下,bagging 方法提供了一种非常简单的方式来对单一模型进行改进,而无需修改背后的算法。 因为 bagging 方法可以减小过拟合,所以通常在强分类器和复杂模型上使用时表现的很好(例如,完全决策树,fully developed decision trees),相比之下 boosting 方法则在弱模型上表现更好(例如,浅层决策树,shallow decision trees)。

    bagging 方法有很多种,其主要区别在于随机抽取训练子集的方法不同:

    • 如果抽取的数据集的随机子集是样例的随机子集,我们叫做 Pasting 。
    • 如果样例抽取是有放回的,我们称为 Bagging 。
    • 如果抽取的数据集的随机子集是特征的随机子集,我们叫做随机子空间 (Random Subspaces)。
    • 最后,如果基估计器构建在对于样本和特征抽取的子集之上时,我们叫做随机补丁 (Random Patches) 。

    在 scikit-learn 中,bagging 方法使用统一的 BaggingClassifier 元估计器(或者 BaggingRegressor ),输入的参数和随机子集抽取策略由用户指定。max_samples 和 max_features 控制着子集的大小(对于样例和特征), bootstrap 和 bootstrap_features 控制着样例和特征的抽取是有放回还是无放回的。 当使用样本子集时,通过设置 oob_score=True ,可以使用袋外(out-of-bag)样本来评估泛化精度。

    采样概率

    在Bagging中,一个样本可能被多次采样,也可能一直不被采样,假设一个样本一直不出现在采样集的概率为(1-1/N) ** N,那么对其求极限可知,原始样本数据集中约有63.2%的样本出现在了,Bagging使用的数据集中,同时在采样中,我们还可以使用袋外样本(out of Bagging)来对我们模型的泛化精度进行评估.

    最终的预测结果

    • 对于分类任务使用简单投票法,即每个分类器一票进行投票(也可以进行概率平均)
    • 对于回归任务,则采用简单平均获取最终结果,即取所有分类器的平均值

    虽然在Bagging中引入的随机分割增加了偏差,但是因为多个模型的集成平均,同时也使得我们在总体上获取了更好的模型,在本篇文章中,我们称之为Bagging的特性一,在后面我们将会验证这一特性。

    简单的实用

    基于KNN的Bagging算法

    关于参数和方法要注意的是:

    • 首先控制特征子采样与样本子采样是否采用,采用的话是否要注意控制比例(一般而言,不要采取较小的数值,太小的特征子采样和样本子采样都会造成子学习器的性能太差.一般而言特征选择越少,方差越大,这点可以与最后的实验方差偏差分解对比分析).
    • 其次控制Bagging中的随机数参数random_state固定,不然不同实验的结果将不一致,同时要注意的很多时候random_state对于测试误差的影响很大,因此加入你想要在某一个数据集上使用Bagging,那么建议多尝试几个不同的Random_state
    • oob_score = True 对性能有一定的提升(使用袋外样本进行泛化能力的评估,但是很多时候效果并不明显,或者看不出什么效果)
    • 其他参数一般默认即可
    from sklearn.ensemble import BaggingClassifier
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.metrics import accuracy_score
    
    # load data
    from sklearn import datasets,model_selection
    def load_data():
        iris=datasets.load_iris() # scikit-learn 自带的 iris 数据集
        X_train=iris.data
        y_train=iris.target
        return model_selection.train_test_split(X_train, y_train,test_size=0.25,random_state=0,stratify=y_train)
    
    bagging = BaggingClassifier(KNeighborsClassifier(),max_samples=0.1,max_features=0.5,random_state=1)
    
    X_train,X_test,y_train,y_test=load_data()
    
    bagging.fit(X_train,y_train)
    y_pre = bagging.predict(X_test)
    print(accuracy_score(y_test,y_pre))
    0.9473684210526315
    
    bagging = BaggingClassifier(KNeighborsClassifier(),max_samples=0.1,max_features=0.5,random_state=1)
    
    X_train,X_test,y_train,y_test=load_data()
    
    bagging.fit(X_train,y_train)
    y_pre = bagging.predict(X_test)
    print(accuracy_score(y_test,y_pre))
    0.9473684210526315
    
    import matplotlib.pyplot as plt
    import numpy as np
    
    param_range = range(1,11,1)
    sores_list = []
    for i in param_range:
        baggingclf = BaggingClassifier(KNeighborsClassifier(),max_samples = i/10,max_features=0.5,random_state=1000,oob_score=True)
        baggingclf.fit(X_train,y_train)
        y_pre = baggingclf.predict(X_test)
        sores_list.append(accuracy_score(y_test,y_pre,normalize=True))
    
    plt.plot(param_range,sores_list) 
    plt.show()

    样本子采样对于Bagging性能的影响

    sores_list = []
    param_range = range(1,X_train.shape[1]+1)
    for i in param_range:
        baggingclf_2 = BaggingClassifier(KNeighborsClassifier(),max_samples = 0.5,max_features=i,random_state=100,oob_score=True) # 一般而言特征选择越少,方差越大
        baggingclf_2.fit(X_train,y_train)
        y_pre = baggingclf_2.predict(X_test)
        sores_list.append(accuracy_score(y_test,y_pre,normalize=True))
    
    plt.plot(param_range,sores_list)
    plt.show()

    特征选择个数对Bagging的影响

    随机数对训练误差与测试误差的影响

    sores_list = []
    param_range = range(0,101)
    for i in param_range:
        baggingclf_2 = BaggingClassifier(KNeighborsClassifier(),max_samples = 0.8,max_features=0.8,random_state=i)
        baggingclf_2.fit(X_train,y_train)
        y_pre = baggingclf_2.predict(X_test)
        sores_list.append(accuracy_score(y_test,y_pre,normalize=True))
    
    plt.plot(param_range,sores_list)
    plt.show()

    随机数选择对Bagging的影响

    偏差方差分解

    之前我们说过:虽然在Bagging中引入的随机分割增加了偏差,但是因为多个模型的集成平均,同时也使得我们在总体上获取了更好的模型.而下面就是对Bagging误差分解后与单个决策树的对比图。Bagging(Tree)相较于Tree增加了偏差,但是降低了方差,最终得到了优于Tree的模型,而同样的Bagging(Tree)_2进一步大幅度增加了偏差,但是同样的方差也大幅度下降,最终得到了效果优于Bagging(Tree)的最终模型。

    import numpy as np
    import matplotlib.pyplot as plt
    plt.figure(figsize=(20,10))
    
    from sklearn.ensemble import BaggingRegressor
    from sklearn.tree import DecisionTreeRegressor
    
    # Settings
    n_repeat = 50       # Number of iterations for computing expectations
    n_train = 50        # Size of the training set
    n_test = 1000       # Size of the test set
    noise = 0.1         # Standard deviation of the noise
    np.random.seed(0)
    
    # Change this for exploring the bias-variance decomposition of other
    # estimators. This should work well for estimators with high variance (e.g.,
    # decision trees or KNN), but poorly for estimators with low variance (e.g.,
    # linear models).
    estimators = [("Tree", DecisionTreeRegressor()),
                  ("Bagging(Tree)", BaggingRegressor(DecisionTreeRegressor())),
                  ("Bagging(Tree)_2",BaggingRegressor(DecisionTreeRegressor(), max_samples=0.5, random_state=100))]
    
    n_estimators = len(estimators)
    
    # Generate data
    def f(x):
        x = x.ravel()
    
        return np.exp(-x ** 2) + 1.5 * np.exp(-(x - 2) ** 2)
    
    def generate(n_samples, noise, n_repeat=1):
        X = np.random.rand(n_samples) * 10 - 5
        X = np.sort(X)
    
        if n_repeat == 1:
            y = f(X) + np.random.normal(0.0, noise, n_samples)
        else:
            y = np.zeros((n_samples, n_repeat))
    
            for i in range(n_repeat):
                y[:, i] = f(X) + np.random.normal(0.0, noise, n_samples)
    
        X = X.reshape((n_samples, 1))
    
        return X, y
    
    X_train = []
    y_train = []
    
    for i in range(n_repeat):
        X, y = generate(n_samples=n_train, noise=noise)
        X_train.append(X)
        y_train.append(y)
    
    X_test, y_test = generate(n_samples=n_test, noise=noise, n_repeat=n_repeat)
    
    # Loop over estimators to compare
    for n, (name, estimator) in enumerate(estimators):
        # Compute predictions
        y_predict = np.zeros((n_test, n_repeat))
    
        for i in range(n_repeat):
            estimator.fit(X_train[i], y_train[i])
            y_predict[:, i] = estimator.predict(X_test)
    
        # Bias^2 + Variance + Noise decomposition of the mean squared error
        y_error = np.zeros(n_test)
    
        for i in range(n_repeat):
            for j in range(n_repeat):
                y_error += (y_test[:, j] - y_predict[:, i]) ** 2
    
        y_error /= (n_repeat * n_repeat)
    
        y_noise = np.var(y_test, axis=1)
        y_bias = (f(X_test) - np.mean(y_predict, axis=1)) ** 2
        y_var = np.var(y_predict, axis=1)
    
        print("{0}: {1:.4f} (error) = {2:.4f} (bias^2) "
              " + {3:.4f} (var) + {4:.4f} (noise)".format(name,
                                                          np.mean(y_error),
                                                          np.mean(y_bias),
                                                          np.mean(y_var),
                                                          np.mean(y_noise)))
    
        # Plot figures
        plt.subplot(2, n_estimators, n + 1)
        plt.plot(X_test, f(X_test), "b", label="$f(x)$")
        plt.plot(X_train[0], y_train[0], ".b", label="LS ~ $y = f(x)+noise$")
    
        for i in range(n_repeat):
            if i == 0:
                plt.plot(X_test, y_predict[:, i], "r", label="$\^y(x)$")
            else:
                plt.plot(X_test, y_predict[:, i], "r", alpha=0.05)
    
        plt.plot(X_test, np.mean(y_predict, axis=1), "c",
                 label="$\mathbb{E}_{LS} \^y(x)$")
    
        plt.xlim([-5, 5])
        plt.title(name)
    
        if n == 0:
            plt.legend(loc="upper left", prop={"size": 11})
    
        plt.subplot(2, n_estimators, n_estimators + n + 1)
        plt.plot(X_test, y_error, "r", label="$error(x)$")
        plt.plot(X_test, y_bias, "b", label="$bias^2(x)$"),
        plt.plot(X_test, y_var, "g", label="$variance(x)$"),
        plt.plot(X_test, y_noise, "c", label="$noise(x)$")
    
        plt.xlim([-5, 5])
        plt.ylim([0, 0.1])
    
        if n == 0:
            plt.legend(loc="upper left", prop={"size": 11})
    
    plt.show()
    Tree: 0.0255 (error) = 0.0003 (bias^2)  + 0.0152 (var) + 0.0098 (noise)
    Bagging(Tree): 0.0196 (error) = 0.0004 (bias^2)  + 0.0092 (var) + 0.0098 (noise)
    Bagging(Tree)_2: 0.0195 (error) = 0.0020 (bias^2)  + 0.0075 (var) + 0.0098 (noise)
    

    Bagging中的方差偏差分解

    参考

    如果你想了解更多关于其他集成算法,或者Bagging系列算法的其他内容,比如随机森林等,请关注我的博客

    展开全文
  • Bagging

    千次阅读 2018-04-12 09:06:25
    上海站 | 高性能计算之GPU ...Bagging是Bootstrap Aggregating的英文缩写,刚接触的童鞋不要误认为bagging是一种算法Bagging和Boosting都是ensemble learing 中的学习框架,代表着不同的思想。boosting派系,它的特点
  • 在前一篇中,我们介绍了集成学习中的Adaboost算法。本文中,我们将介绍集成学习中另一个很有名的算法----bagging算法
  • Bagging算法

    千次阅读 2019-12-04 23:16:40
    Bagging算法(英语:Bootstrap aggregating,引导聚集算法),又称装袋算法,是机器学习领域的一种团体学习算法。最初由Leo Breiman于1996年提出。Bagging算法可与其他分类、回归算法结合,提高...
  • 快速了解Bagging算法

    2020-05-11 22:28:24
    快速了解Bagging算法Boostrap sampling 自助采样Bagging算法Bagging性能 Boostrap sampling 自助采样  之前已经讲过模型的评估方法中有留一法(将数据集划分为两个互不相交的集合,一个做测试集,一个做训练集)和...
  • 说明R的adabag包对bagging与boosting进行支持,其中对于bagging算法adebag包提供了Breiman bagging算法,在Breiman bagging中首次提出子多版本分类器的理念,得到聚合分类器。
  • Bagging算法的R语言实现

    千次阅读 2016-07-14 10:07:04
    bagging算法如下: 循环K次,每次都从样本集D中有放回地抽取样本集Di,这样总共得到k个样本集,用这K个样本集进行决策树生成,获得K个决策树模型,再将要检测的数据用这K个决策树模型进行多数表决,获得票数多的...
  • 机器学习中Bagging和Boosting的区别

    万次阅读 多人点赞 2017-07-12 22:32:47
    Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来,形成一个性能更加强大的分类器,更准确的说这是一种分类算法的组装方法。即将弱分类器组装成强分类器的方法。 首先介绍Bootstraping,即自助法...
  • 集成算法(Bagging,随机森林)

    千次阅读 2020-05-11 23:54:54
    在这篇博客上只介绍Bagging算法及随机森林,Boosting提升算法及其他高效的算法在下一篇详细讲解。 集成算法就是通过构建多个学习器来完成学习任务,是由多个基学习器或者是个体学习器来完成的。它可以是由决策树,...
  • Boost和bagging算法

    千次阅读 2018-05-12 16:56:50
    boost来到基本的boost算法,同时也遇见了Boost的伙伴Bagging。接下来,稍微看看他们吧。学习Bagging和Boost首先需要了解两个名词“弱分类器”和“强分类器”。“弱分类器”的分类能力不强,但它又比随机选的效果稍微...
  • 基于sklearn实现Bagging算法(python)

    千次阅读 2018-09-12 15:43:07
    本文使用的数据类型是数值型,每一个样本6个特征表示,所用的数据如图所示: ...实现Bagging算法的代码如下: from sklearn.ensemble import BaggingClassifier from sklearn.tree import DecisionTreeClass...
  • 样本不均衡问题--bagging方法

    千次阅读 2016-06-23 17:48:24
    bagging是一种用来提高学习算法准确度的方法,这种方法通过构造一个预测函数系列,然后以一定的方式将它们组合成一个预测函数。 它使用bootstrap抽样, 其基本思想是:将一个弱学习算法使用多次(每次使用一个放回的...
  • EL之Bagging:利用Bagging算法实现回归预测(实数值评分预测)问题 目录 输出结果 设计思路 核心思路 输出结果 设计思路 核心思路 #4.1、当treeDepth=1,对图进行可视化 #(1)、...
  • 集成学习法之bagging方法和boosting方法
  • Bagging是Bootstrap Aggregating 的简称,意思就是再取样 (Bootstrap) 然后在每个样本上训练出来的模型取平均,所以是降低模型的variance. Bagging 比如Random Forest 这种先天并行的算法都有这个效果。Boosting 则...
  • 机器学习中的bagging技巧

    千次阅读 2015-07-10 17:00:03
    bagging的作用bagging是增强原算法的一种手段。神经网络、分类问题、回归问题、线性回归中的子集选择问题、k最近邻算法都可以使用bagging来加强。使用bagging加强后的算法的性能会出现一些有规律的变化。一般而言,...
1 2 3 4 5 ... 20
收藏数 13,952
精华内容 5,580
关键字:

bagging算法