精华内容
下载资源
问答
  • bagging算法

    2019-02-11 08:01:45
    Bagging的策略: 从样本集中用Bootstrap采样选出n个样本 在所有属性上 对这n个样本建立分类器(CART or SVM or ) 重复以上两步m次 i e build m个分类器(CART or SVM or ) 将数据放在这m个分类器上跑 最后vote看...
  • bagging

    2021-07-21 23:04:14
    tree(sample, max_depth, min_size) trees.append(tree) predictions = [bagging_predict(trees, row) for row in test] return(predictions) # Test bagging on the sonar dataset seed(1) # load and prepare ...

    1.什么是 bootstraps?

    bootstraps中文名称为自助法,是一种有放回的采样方法。其具体采样操作为:在m个样本组成的样本集合内,每次只抽取一个样本,有放回地抽取m次,这样就得到了m个样本组成的采样集合。

    引理:D 中的某个样本在自助法采样中不被采到的概率约是 36.8%. 也就是说, 在 D 中大约有 36.8% 的样本未出现在采样数据集 D 中。
    证明对其中任意一个样本,它每次采样都不被抽中的概率为 p = m − 1 m p=\frac{m-1}{m} p=mm1,因此m次抽样它都不被抽中的概率为 ( 1 − 1 m ) m (1-\frac{1}{m})^m (1m1)m,取极限得 1 / e = 36.8 % 1/e=36.8\% 1/e=36.8%

    自助法在数据集较小, 难以划分训练/验证集时很有用, 训练集大小仍是m. 然而, 自助法产生的数据集 改变了初始数据集分布, 会引入估计偏差. 因此, 当初始数据量足够时, 交叉验证和留出法更常用.

    2. bootstraps与 bagging的联系

    bootstraps采样是bagging其中必不可少的步骤。

    3.什么是 bagging?

    Bagging 的基本思路:一种朴素地增加基分类器多样性的方案是用训练集 D 的不同子集训练不同的个体学习器. 但是, 我们同时希望个体学习器不能太差. 如果每个子集互不相交, 则每个集学习器只用到了一小
    部分训练数据, 甚至不足以有效学习. 因此, Bagging(boostrap aggregating) 从训练集 D 采样相互有交叠的采样子集。

    Bagging 的具体过程包括如下三步.

    1. 从训练集 D 中由自助法采样得到 T 个采样集 D 1 , D_1, D1,
    2. 基于自助采样集 D t D_t Dt 训练基学习器 h t h_t ht.
    3. 使用相对多数投票 (分类任务) 或简单平均 (回归任务) 得到 H H H

    4.随机森林与 bagging的联系与区别。

    随机森林 (random forest)是在以决策树为集学习器构建 Bagging 集成 的基础上, 进一步在单变量决策树的训练过程中引入了随机属性选择.
    具体地说, 经典单变量决策树是在选择划分属性时是在当前结点的属性集合 (假设有 d 个属性) 中选择一个属性, 而在随机森林中, 对基决策树的每个结点, 先从该结点的属性集合中随机选择一个包含 d ^ \hat{d} d^ 个属性的子集, 然后再从这个子集中选择一个最优属性用于划分. 这里的参数 d ^ \hat{d} d^ 控制了随机性的引入程度:若 d ^ = d \hat{d}= d d^=d, 基决策树的构建和经典单变量决策树相同; 若 d ^ = 1 \hat{d} = 1 d^=1, 则是随机选一个属性用于划分. 一般情况下, 推荐值 d ^ = l g d \hat{d}= lg d d^=lgd

    5.使用偏差与方差理论阐述为什么 bagging能提升模型的预测精度

    6.请尝试使用 bagging与基本分类模型或者回归模型做对比,观察 bagging是否相对于基础模型的精度有所提高?(必做)

    7.假如让你来实现 bagging.你会使用 python+numpy+ sklearn的基础模型来实现 bagging吗?(拓展)

    # Bagging Algorithm on the Sonar dataset
    from random import seed
    from random import randrange
    from csv import reader
     
    # Load a CSV file
    def load_csv(filename):
    	dataset = list()
    	with open(filename, 'r') as file:
    		csv_reader = reader(file)
    		for row in csv_reader:
    			if not row:
    				continue
    			dataset.append(row)
    	return dataset
     
    # Convert string column to float
    def str_column_to_float(dataset, column):
    	for row in dataset:
    		row[column] = float(row[column].strip())
     
    # Convert string column to integer
    def str_column_to_int(dataset, column):
    	class_values = [row[column] for row in dataset]
    	unique = set(class_values)
    	lookup = dict()
    	for i, value in enumerate(unique):
    		lookup[value] = i
    	for row in dataset:
    		row[column] = lookup[row[column]]
    	return lookup
     
    # Split a dataset into k folds
    def cross_validation_split(dataset, n_folds):
    	dataset_split = list()
    	dataset_copy = list(dataset)
    	fold_size = int(len(dataset) / n_folds)
    	for i in range(n_folds):
    		fold = list()
    		while len(fold) < fold_size:
    			index = randrange(len(dataset_copy))
    			fold.append(dataset_copy.pop(index))
    		dataset_split.append(fold)
    	return dataset_split
     
    # Calculate accuracy percentage
    def accuracy_metric(actual, predicted):
    	correct = 0
    	for i in range(len(actual)):
    		if actual[i] == predicted[i]:
    			correct += 1
    	return correct / float(len(actual)) * 100.0
     
    # Evaluate an algorithm using a cross validation split
    def evaluate_algorithm(dataset, algorithm, n_folds, *args):
    	folds = cross_validation_split(dataset, n_folds)
    	scores = list()
    	for fold in folds:
    		train_set = list(folds)
    		train_set.remove(fold)
    		train_set = sum(train_set, [])
    		test_set = list()
    		for row in fold:
    			row_copy = list(row)
    			test_set.append(row_copy)
    			row_copy[-1] = None
    		predicted = algorithm(train_set, test_set, *args)
    		actual = [row[-1] for row in fold]
    		accuracy = accuracy_metric(actual, predicted)
    		scores.append(accuracy)
    	return scores
     
    # Split a dataset based on an attribute and an attribute value
    def test_split(index, value, dataset):
    	left, right = list(), list()
    	for row in dataset:
    		if row[index] < value:
    			left.append(row)
    		else:
    			right.append(row)
    	return left, right
     
    # Calculate the Gini index for a split dataset
    def gini_index(groups, classes):
    	# count all samples at split point
    	n_instances = float(sum([len(group) for group in groups]))
    	# sum weighted Gini index for each group
    	gini = 0.0
    	for group in groups:
    		size = float(len(group))
    		# avoid divide by zero
    		if size == 0:
    			continue
    		score = 0.0
    		# score the group based on the score for each class
    		for class_val in classes:
    			p = [row[-1] for row in group].count(class_val) / size
    			score += p * p
    		# weight the group score by its relative size
    		gini += (1.0 - score) * (size / n_instances)
    	return gini
     
    # Select the best split point for a dataset
    def get_split(dataset):
    	class_values = list(set(row[-1] for row in dataset))
    	b_index, b_value, b_score, b_groups = 999, 999, 999, None
    	for index in range(len(dataset[0])-1):
    		for row in dataset:
    		# for i in range(len(dataset)):
    		# 	row = dataset[randrange(len(dataset))]
    			groups = test_split(index, row[index], dataset)
    			gini = gini_index(groups, class_values)
    			if gini < b_score:
    				b_index, b_value, b_score, b_groups = index, row[index], gini, groups
    	return {'index':b_index, 'value':b_value, 'groups':b_groups}
     
    # Create a terminal node value
    def to_terminal(group):
    	outcomes = [row[-1] for row in group]
    	return max(set(outcomes), key=outcomes.count)
     
    # Create child splits for a node or make terminal
    def split(node, max_depth, min_size, depth):
    	left, right = node['groups']
    	del(node['groups'])
    	# check for a no split
    	if not left or not right:
    		node['left'] = node['right'] = to_terminal(left + right)
    		return
    	# check for max depth
    	if depth >= max_depth:
    		node['left'], node['right'] = to_terminal(left), to_terminal(right)
    		return
    	# process left child
    	if len(left) <= min_size:
    		node['left'] = to_terminal(left)
    	else:
    		node['left'] = get_split(left)
    		split(node['left'], max_depth, min_size, depth+1)
    	# process right child
    	if len(right) <= min_size:
    		node['right'] = to_terminal(right)
    	else:
    		node['right'] = get_split(right)
    		split(node['right'], max_depth, min_size, depth+1)
     
    # Build a decision tree
    def build_tree(train, max_depth, min_size):
    	root = get_split(train)
    	split(root, max_depth, min_size, 1)
    	return root
     
    # Make a prediction with a decision tree
    def predict(node, row):
    	if row[node['index']] < node['value']:
    		if isinstance(node['left'], dict):
    			return predict(node['left'], row)
    		else:
    			return node['left']
    	else:
    		if isinstance(node['right'], dict):
    			return predict(node['right'], row)
    		else:
    			return node['right']
     
    # Create a random subsample from the dataset with replacement
    def subsample(dataset, ratio):
    	sample = list()
    	n_sample = round(len(dataset) * ratio)
    	while len(sample) < n_sample:
    		index = randrange(len(dataset))
    		sample.append(dataset[index])
    	return sample
     
    # Make a prediction with a list of bagged trees
    def bagging_predict(trees, row):
    	predictions = [predict(tree, row) for tree in trees]
    	return max(set(predictions), key=predictions.count)
     
    # Bootstrap Aggregation Algorithm
    def bagging(train, test, max_depth, min_size, sample_size, n_trees):
    	trees = list()
    	for i in range(n_trees):
    		sample = subsample(train, sample_size)
    		tree = build_tree(sample, max_depth, min_size)
    		trees.append(tree)
    	predictions = [bagging_predict(trees, row) for row in test]
    	return(predictions)
     
    # Test bagging on the sonar dataset
    seed(1)
    # load and prepare data
    filename = 'sonar.all-data.csv'
    dataset = load_csv(filename)
    # convert string attributes to integers
    for i in range(len(dataset[0])-1):
    	str_column_to_float(dataset, i)
    # convert class column to integers
    str_column_to_int(dataset, len(dataset[0])-1)
    # evaluate algorithm
    n_folds = 5
    max_depth = 6
    min_size = 2
    sample_size = 0.50
    for n_trees in [1, 5, 10, 50]:
    	scores = evaluate_algorithm(dataset, bagging, n_folds, max_depth, min_size, sample_size, n_trees)
    	print('Trees: %d' % n_trees)
    	print('Scores: %s' % scores)
    	print('Mean Accuracy: %.3f%%' % (sum(scores)/float(len(scores))))
    
    
    展开全文
  • 主要为大家详细介绍了基于sklearn实现Bagging算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 包含基于决策树桩进行集成的AdaBoost、Bagging算法,并实现对学习结果的可视化。“*”表示支撑超平面边界的点,“+”、“-”分别表示正反例数据点,青色线条为集学习器(决策树桩)分类边界。
  • 基于Bagging的集成学习:随机森林的原理及其实现引入Bagging装袋随机森林随机森林分类随机森林回归python实现随机森林分类随机森林回归 引入 “三个臭皮匠赛过诸葛亮”——弱分类器组合成强分类器。 Q1.什么是随机...
  • 论文研究-基于Bagging与决策树算法的在线拍卖成交价格预测模型.pdf, 通过分析在线拍卖出价特点,利用决策树和Bagging算法建立了一种全新的在线拍卖成交价格预测模型.作者...
  • Bagging

    万次阅读 2018-04-11 00:00:00
    上海站 | 高性能计算之GPU ...Bagging是Bootstrap Aggregating的英文缩写,刚接触的童鞋不要误认为bagging是一种算法,Bagging和Boosting都是ensemble learing 中的学习框架,代表着不同的思想。boosting派系,它的特点

    上海站 | 高性能计算之GPU CUDA培训

    4月13-15日
    三天密集式学习  快速带你晋级
    阅读全文
    >


    正文共4133个字,3张图,预计阅读时间10分钟。


    Bagging是Bootstrap Aggregating的英文缩写,刚接触的童鞋不要误认为bagging是一种算法,Bagging和Boosting都是ensemble learing 中的学习框架,代表着不同的思想。


    • boosting派系,它的特点是各个弱学习器之间有依赖关系。

    • bagging流派,它的特点是各个弱学习器之间没有依赖关系,可以并行拟合。


    Bagging远离


    从上图可以看出,Bagging的弱学习器之间的确没有boosting那样的联系。它的特点在“随机采样”。那么什么是随机采样?


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


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


    对于一个样本,它在某一次含m个样本的训练集的随机采样中,每次被采集到的概率是$\frac { 1 }{ m } $,不被采集到的概率为1-$\frac { 1 }{ m } $,如果m次都没被采样到的概率为$({ 1-\frac { 1 }{ m } ) }^{ m }$,当$m\rightarrow \infty  $时,$lim_{ m\rightarrow \infty  }{ (1-\frac { 1 }{ m } ){  }^{ m\  } } $约定于$ \frac { 1 }{ e } $=0.368,也就是说,在bagging的每轮随机采样中,训练集中大约有36.8%的数据没有被采样集采集中。自助采样会改变数据的初始分布导致引入估计偏差。


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


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


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


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


    Bagging算法流程



    上一节我们对bagging算法的原理做了总结,这里就对bagging算法的流程做一个总结。相对于Boosting系列的Adaboost和GBDT,bagging算法要简单的多。


    输入为样本集D={(x,y1),(x2,y2),...(xm,ym  )}      ,弱学习器算法, 弱分类器迭代次数T。


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


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

    • a)对训练集进行第t次随机采样,共采集m次,得到包含m个样本的采样集Dm

    • b)用采样集Dm训练第m个弱学习器Gm(x)


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


    随机森林算法


    理解了bagging算法,随机森林(Random Forest,以下简称RF)就好理解了。它是Bagging算法的进化版,也就是说,它的思想仍然是bagging,但是进行了独有的改进。我们现在就来看看RF算法改进了什么。


    首先,RF使用了CART决策树作为弱学习器,这让我们想到了梯度提升树GBDT。第二,在使用决策树的基础上,RF对决策树的建立做了改进,对于普通的决策树,我们会在节点上所有的n个样本特征中选择一个最优的特征来做决策树的左右子树划分,但是RF通过随机选择节点上的一部分样本特征,这个数字小于n,假设为${ {  }{ n }{ sub } } $,然后在这些随机选择的${ {  }{ n }{ sub } } $个样本特征中,选择一个最优的特征来做决策树的左右子树划分。这样进一步增强了模型的泛化能力。


    如果${ {  }{ n }{ sub } } $=n,则此时RF的CART决策树和普通的CART决策树没有区别。${ {  }{ n }{ sub } } $越小,则模型越健壮,当然此时对于训练集的拟合程度会变差。也就是说${ {  }{ n }{ sub } } $越小,模型的方差会减小,但是偏倚会增大。在实际案例中,一般会通过交叉验证调参获取一个合适的${ {  }{ n }{ sub } } $值。


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


    • 输入为样本集D={(x,y1),(x2,y2),...(xm,ym)} ,弱分类器迭代次数T。

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

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


    a)对训练集进行第t次随机采样,共采集m次,得到包含m个样本的采样集Dm。


    b)用采样集Dm训练第m个决策树模型Gm(x),在训练决策树模型的节点的时候, 在节点上所有的样本特征中选择一部分样本特征, 在这些随机选择的部分样本特征中选择一个最优的特征来做决策树的左右子树划分。


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

    随机森林的推广


    由于RF在实际应用中的良好特性,基于RF,有很多变种算法,应用也很广泛,不光可以用于分类回归,还可以用于特征转换,异常点检测等。下面对于这些RF家族的算法中有代表性的做一个总结。


    extra trees


    extra trees是RF的一个变种, 原理几乎和RF一模一样,仅有区别有:


    1) 对于每个决策树的训练集,RF采用的是随机采样bootstrap来选择采样集作为每个决策树的训练集,而extra trees一般不采用随机采样,即每个决策树采用原始训练集。


    2) 在选定了划分特征后,RF的决策树会基于信息增益,基尼系数,均方差之类的原则,选择一个最优的特征值划分点,这和传统的决策树相同。但是extra trees比较的激进,他会随机的选择一个特征值来划分决策树。


    从第二点可以看出,由于随机选择了特征值的划分点位,而不是最优点位,这样会导致生成的决策树的规模一般会大于RF所生成的决策树。也就是说,模型的方差相对于RF进一步减少,但是偏倚相对于RF进一步增大。在某些时候,extra trees的泛化能力比RF更好。


    totally random trees embedding


    Totally Random Trees Embedding(以下简称 TRTE)是一种非监督学习的数据转化方法。它将低维的数据集映射到高维,从而让映射到高维的数据更好的运用于分类回归模型。我们知道,在支持向量机中运用了核方法来将低维的数据集映射到高维,此处TRTE提供了另外一种方法。


    TRTE在数据转化的过程也使用了类似于RF的方法,建立T个决策树来拟合数据。当决策树建立完毕以后,数据集里的每个数据在T个决策树中叶子节点的位置也定下来了。比如我们有3颗决策树,每个决策树有5个叶子节点,某个数据特征x划分到第一个决策树的第2个叶子节点,第二个决策树的第3个叶子节点,第三个决策树的第5个叶子节点。则x映射后的特征编码为(0,1,0,0,0,     0,0,1,0,0,     0,0,0,0,1), 有15维的高维特征。这里特征维度之间加上空格是为了强调三颗决策树各自的子编码。


    映射到高维特征后,可以继续使用监督学习的各种分类回归算法了。


    isolation forest


    Isolation Forest(以下简称IForest)是一种异常点检测的方法。它也使用了类似于RF的方法来检测异常点。


    对于在T个决策树的样本集,IForest也会对训练集进行随机采样,但是采样个数不需要和RF一样,对于RF,需要采样到采样集样本个数等于训练集个数。但是IForest不需要采样这么多,一般来说,采样个数要远远小于训练集个数?为什么呢?因为我们的目的是异常点检测,只需要部分的样本我们一般就可以将异常点区别出来了。


    对于每一个决策树的建立, IForest采用随机选择一个划分特征,对划分特征随机选择一个划分阈值。这点也和RF不同。


    另外,IForest一般会选择一个比较小的最大决策树深度max_depth,原因同样本采集,用少量的异常点检测一般不需要这么大规模的决策树。


    对于异常点的判断,则是将测试样本点x拟合到T颗决策树。计算在每颗决策树上该样本的叶子节点的深度ht(x)。,从而可以计算出平均高度h(x)。此时我们用下面的公式计算样本点x的异常概率。


    随机森林小结


    RF的算法原理也终于讲完了,作为一个可以高度并行化的算法,RF在大数据时候大有可为。 这里也对常规的随机森林算法的优缺点做一个总结。


    RF的主要优点有:


    • 训练可以高度并行化,对于大数据时代的大样本训练速度有优势。个人觉得这是的最主要的优点。

    • 由于可以随机选择决策树节点划分特征,这样在样本特征维度很高的时候,仍然能高效的训练模型。

    • 在训练后,可以给出各个特征对于输出的重要性

    • 由于采用了随机采样,训练出的模型的方差小,泛化能力强。

    • 相对于Boosting系列的Adaboost和GBDT, RF实现比较简单。

    • 对部分特征缺失不敏感。


    RF的主要缺点有:


    • 在某些噪音比较大的样本集上,RF模型容易陷入过拟合。

    • 取值划分比较多的特征容易对RF的决策产生更大的影响,从而影响拟合的模型的效果


    参考链接:

    http://blog.csdn.net/sun_shengyun/article/details/54616386
    我的github链接:https://github.com/TracyMcgrady6


    原文链接:https://www.jianshu.com/p/d270af43f043
    源码github地址:https://github.com/TracyMcgrady6/Distribute_MNIST
    个人博客地址:
    http://mcgrady.cn


    查阅更为简洁方便的分类文章以及最新的课程、产品信息,请移步至全新呈现的“LeadAI学院官网”:

    www.leadai.org


    请关注人工智能LeadAI公众号,查看更多专业文章

    大家都在看

    LSTM模型在问答系统中的应用

    基于TensorFlow的神经网络解决用户流失概览问题

    最全常见算法工程师面试题目整理(一)

    最全常见算法工程师面试题目整理(二)

    TensorFlow从1到2 | 第三章 深度学习革命的开端:卷积神经网络

    装饰器 | Python高级编程

    今天不如来复习下Python基础

    展开全文
  • Iterative Bagging和MultiBoosting 算法实现。并且比较了bias和variance的值。
  • 基于基分类器自身的Bagging基分类器权重设置策略,崔恺旭,刘知青,Bagging算法是一种有效的提高分类任务中分类器性能的集成学习算法。文章提出一种Bagging算法中加权投票法权重的设置策略,该策略基于�
  • MultiBoosting、Iterative Bagging的python实现,代码通俗易懂。
  • 在 Matlab 中实现的 Bagging、Boosting 和随机森林。 工具箱 使用以下工具箱: 37steps 制作的模式识别工具箱(PRTools): ://www.37steps.com/prtools/ 科学论文 这些算法基于以下研究论文: 新提升算法的实验:...
  • bagging算法python组件

    2015-04-19 20:22:54
    bagging 是bootstrap aggregating的缩写,它首次介绍是在L. Breiman, Bagging predictors, Mach. Learn. 24 (2) (1996) 123--140 ,是第一批用于多分类器集成算法。该集成方法包括在一个训练集合上重复训练得到的多...
  • 前面博客分享,我们已经讲解了不少分类算法,有knn、决策树、朴素贝叶斯、逻辑回归、svm。我们知道,当坐重要决定时,大家可能都会考虑吸取多个专家而不是一个人的意见。机器学习处理问题时同样如此。...
  • 基于Bagging的概率神经网络集成分类算法
  • 针对字符识别对象的多样性,提出了一种基于Bagging集成的字符识别模型,解决了识别模型对部分字符识别的偏好现象。采用Bagging采样策略形成不同的数据子集,在此基础上用决策树算法训练形成多个基分类器,用多数投票...
  • bagging算法代码matlab
  • online Bagging and Boosting

    2019-03-26 19:31:56
    Bagging and boosting are well-known ensemble learning methods. we present simple online bagging and boosting algorithms that we claim perform as well as their batch counterparts.
  • 一种基于特征选择的SVM Bagging集成方法
  • 集成学习05-Bagging

    2021-07-22 15:58:27
    集成学习属于模型融合的一部分,常见的集成学习包括Bagging、Boosting、Stacking等。 集成学习 Bagging bootstrap自助采样 Boosting 叠加式算法 Stacking 一个学习器输出作为下一个学习器输入 1....

    集成学习属于模型融合的一部分,常见的集成学习包括Bagging、Boosting、Stacking等。

    集成学习Baggingbootstrap自助采样
    Boosting叠加式算法
    Stacking一个学习器输出作为下一个学习器输入

    1. 什么是模型融合

    模型融合: 先产生一组”个体学习器” ,再用某种策略将它们结合起来,加强模型效果。

    模型融合策略: 基本学习器学习完后,需要将各个模型进行融合,常见的策略有:

    (1)平均法: 平均法有一般的评价和加权平均,这个好理解。对于平均法来说一般用于回归预测模型中,在Boosting系列融合模型中,一般采用的是加权平均融合。

    (2)投票法:有绝对多数投票(得票超过一半),相对多数投票(得票最多),加权投票。这个也好理解,一般用于分类模型。在bagging模型中使用。

    (3)学习法:一种更为强大的结合策略是使用”学习法”,即通过另一个学习器来进行结合,把个体学习器称为初级学习器,用于结合的学习器称为次级学习器或元学习器。常见的有Stacking和Blending两种。

    • Stacking方法: Stacking 先从初始数据集训练出初级学习器,然后”生成”一个新数据集用于训练次级学习器。在这个新数据集中,初级学习器的输出被当作样例输入特征,而初始样本的标记仍被当作样例标记。
    • Blending方法: Blending与Stacking大致相同,只是Blending的主要区别在于训练集不是通过K-Fold的CV策略来获得预测值从而生成第二阶段模型的特征,而是建立一个Holdout集,例如说10%的训练数据,第二阶段的stacker模型就基于第一阶段模型对这10%训练数据的预测值进行拟合。说白了,就是把Stacking流程中的K-Fold CV 改成 HoldOut CV。

    2. 投票法

            投票法是一种遵循少数服从多数原则的集成学习模型,通过多个模型的集成降低方差,从而提高模型的鲁棒性。在理想情况下,投票法的预测效果应当优于任何一个基模型的预测效果。

    (1)投票法在回归模型与分类模型上均可使用:

    • 回归投票法:预测结果是所有模型预测结果的平均值。
    • 分类投票法:预测结果是所有模型种出现最多的预测结果。

    (2)分类投票法又可以被划分为硬投票与软投票:

    • 硬投票:预测结果是所有投票结果最多出现的类。
    • 软投票:预测结果是所有投票结果中概率加和最大的类。

            在投票法中,我们还需要考虑到不同的基模型可能产生的影响。理论上,基模型可以是任何已被训练好的模型。但在实际应用上,想要投票法产生较好的结果,需要满足两个条件:1)基模型之间的效果不能差别过大。当某个基模型相对于其他基模型效果过差时,该模型很可能成为噪声。2)基模型之间应该有较小的同质性。例如在基模型预测效果近似的情况下,基于树模型与线性模型的投票,往往优于两个树模型或两个线性模型。

         当投票合集中使用的模型能预测出清晰的类别标签时,适合使用硬投票。当投票集合中使用的模型能预测类别的概率时,适合使用软投票。软投票同样可以用于那些本身并不预测类成员概率的模型,只要他们可以输出类似于概率的预测分数值(例如支持向量机、k-最近邻和决策树)。

      投票法的局限性在于,它对所有模型的处理是一样的,这意味着所有模型对预测的贡献是一样的。如果一些模型在某些情况下很好,而在其他情况下很差,这是使用投票法时需要考虑到的一个问题。

    3. Bagging

            与投票法不同的是,Bagging不仅仅集成模型最后的预测结果,同时采用一定策略来影响基模型训练,保证基模型可以服从一定的假设。在上一章中我们提到,希望各个模型之间具有较大的差异性,而在实际操作中的模型却往往是同质的,因此一个简单的思路是通过不同的采样增加模型的差异性

            原理:采用自助采样法(Bootstap sampling),即对于m个样本的原始训练集,我们每次先随机采集一个样本放入采样集,接着把该样本放回,也就是说下次采样时该样本仍有可能被采集到,这样采集m次,最终可以得到m个样本的采样集,由于是随机采样,这样每次的采样集是和原始训练集不同的,和其他采样集也是不同的,这样得到多个不同的弱学习器。

            对回归问题的预测是通过预测取平均值来进行的。对于分类问题的预测是通过对预测取多数票预测来进行的。

            Bagging方法之所以有效,是因为每个模型都是在略微不同的训练数据集上拟合完成的,这又使得每个基模型之间存在略微的差异,使每个基模型拥有略微不同的训练能力。Bagging同样是一种降低方差的技术,因此它在不剪枝决策树、神经网络等易受样本扰动的学习器上效果更加明显。在实际的使用中,加入列采样的Bagging技术对高维小样本往往有神奇的效果。

    4. 随机森林

            随机森林是一种bagging算法的应用。“森林”是由许多“树”bagging组成的。在具体实现上,用于每个决策树训练的样本和构建决策树的特征都是通过随机采样得到的,随机森林的预测结果是多个决策树输出的组合(投票)。

            对bagging算法的改进包括:改进一:基本学习器限定为决策树,改进二:除了bagging的在样本上加上扰动,同时在属性上也加上扰动,即是在决策树学习的过程中引入了随机属性选择,对基决策树的每个结点,先从该结点的属性集合中随机选择一个包含k个属性的子集,然后再从这个子集中选择一个最优属性用于划分。

    作业:(任选四道题目)

    1.什么是bootstraps?

    bootstrap(自助采样)指有放回的从数据集中进行采样,也就是说,同样的一个样本可能被多次进行采样。
    2.bootstraps与bagging的联系。

    bootstraps是Bagging从数据集中进行采样的方式,通过不同的采样增加各个样本形成模型的差异性,降低了整体模型的方差。
    3.什么是bagging?

    Bagging思想的实质是:通过Bootstrap 的方式对全样本数据集进行抽样得到抽样子集,对不同的子集使用同一种基本模型进行拟合,然后投票得出最终的预测。
    4.随机森林与bagging的联系与区别。

    联系:随机森林使用了bagging的自助采样方法,“森林”是由许多“树”bagging组成的。

    区别:1)随机森林的基本学习器限定为决策树,2)随机森林除了bagging的在样本上加上扰动,同时引入了随机属性选择,进一步降低模型的误差方差。
    5.使用偏差与方差理论阐述为什么bagging能提升模型的预测精度?

    bagging通过有放回的多次取样,抽样的样本数量越多,样本均值的方差越低,降低的误差方差>增加的误差偏差平方,所以bagging能提升模型的预测精度。
    6.请尝试使用bagging与基本分类模型或者回归模型做对比,观察bagging是否相对于基础模型的精度有所提高?(必做)

    使用bagging与逻辑回归处理分类问题,bagging的精度稍高。

    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import datasets
    from sklearn.model_selection import train_test_split
    from sklearn.linear_model import LogisticRegression
    
    X, y = datasets.make_moons(n_samples=500, noise=0.3, random_state=42)
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
    
    plt.scatter(X[y==0, 0], X[y==0, 1])
    plt.scatter(X[y==1, 0], X[y==1, 1])
    # plt.show()
    
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import BaggingClassifier
    
    # 使用bagging+决策树分类
    bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                                   n_estimators=500, max_samples=200,
                                   bootstrap=True)
    bagging_clf.fit(X_train, y_train)
    score1 = bagging_clf.score(X_test, y_test)
    print("使用Bagging分类的准确率:", score1)
    
    # 使用逻辑回归分类
    logreg_clf = LogisticRegression(C=1e5)
    logreg_clf.fit(X_train, y_train)
    score2 = logreg_clf.score(X_test, y_test)
    print("使用逻辑回归分类的准确率:",score2)


    7.假如让你来实现bagging,你会使用python+numpy+sklearn的基础模型来实现bagging吗?(拓展)

    参考链接:

    https://github.com/datawhalechina/ensemble-learning
    https://blog.csdn.net/u014248127/article/details/78993753

    展开全文
  • 集成学习Boosting和Bagging综述,非常好的参考资料,推荐

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,130
精华内容 8,452
关键字:

bagging