机器学习中的集成方法(2)-- Bagging(装袋法)

一、概念理解

Bagging算法,又称装袋算法,是机器学习领域的一种集成学习算法。最初由Leo Breiman于1994年提出。之所以被称为装袋法,是因为它采用了一种有放回的抽样方法来生成训练数据。通过多轮有放回的对初始训练集进行随机采样,多个训练集被并行化生成,对应可训练出多个基学习器(基学习器间不存在强依赖关系),再将这些基学习器结合,构建出强学习器。其本质是引入了样本扰动,通过增加样本随机性,达到降低方差的效果。

Bagging算法可与其他分类、回归算法结合,提高其准确率、稳定性的同时,通过降低结果的方差,避免过拟合的发生。

二、执行步骤

假设有1000个样本,70%的样本作为训练集,30%的样本作为测试集。
STEP1:从训练集700条里样本随机抽出500条样本,用来训练,于是生成了一个基学习器。
STEP2:然后有放回的再从700条样本在随机抽出500条样本,用来训练,于是又生成了一个基学习器
STEP3:假设以步骤2的方式随机抽取100次,这样就生成了100个基学习器了
STEP4:用这100个基学习器对测试集的每一个样本都进行测试,然后通过投票的方式决定测集样本的预测结果。如果一个样本被这100个基学习器投票,即预测分类,被分为1的票数有80票,被分为0的有20票,显然,这个样本的预测结果为1。

三、使用sklearn库实现Bagging方法

1、BaggingClassifier

决策树是一个可读性很强、分类快,同时不需要对数据进行归一化还有缩放的处理。但是决策树有个不足的地方就是非常容易过拟合,所以必须要采取一些方法进行剪枝。而bagging方法的出现,可以完美地解决了决策树过拟合的问题,同时bagging的使用也会使分类器分类效果得到了显著的提高。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#-*- coding:utf-8 -*-
'''
Bagging方法
'''
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report

#========================================================
# 载入iris数据集
#========================================================

iris = load_iris()
X = iris.data[:,:5]
y = iris.target

print('feature=',X)
print('target=',y)

#========================================================
# 实现Bagging集成
#========================================================

def BaggingMethod(X, y):
'''
Bagging方法实现分类
INPUT -> 特征, 分类标签
'''
scaler = StandardScaler() # 标准化转换
scaler.fit(X) # 训练标准化对象
traffic_feature= scaler.transform(X) # 转换数据集
feature_train, feature_test, target_train, target_test = train_test_split(X, y, test_size=0.3, random_state=0)
tree = DecisionTreeClassifier(criterion='entropy', max_depth=None)

clf = BaggingClassifier(base_estimator=tree,
n_estimators=500, # 生成500个决策树
max_samples=1.0,
max_features=1.0,
bootstrap=True,
bootstrap_features=False,
n_jobs=1,
random_state=1)
clf.fit(feature_train, target_train)

# 模型测试
predict_results = clf.predict(feature_test)
print(accuracy_score(predict_results, target_test))
conf_mat = confusion_matrix(target_test, predict_results)
print(conf_mat)
print(classification_report(target_test, predict_results))

return clf

#========================================================
# 主程序
#========================================================

if __name__ == '__main__':

model = BaggingMethod(X, y)

注意:bagging有两种,一种是用于回归的BaggingRegressor,另一种是用于分类的BaggingClassifier

2、BalancedBaggingClassifier

BalancedBaggingClassifier 允许在训练每个基学习器之前对每个子集进行重抽样。简而言之, 该方法结合了EasyEnsemble采样器与分类器(BaggingClassifier)的结果.

1
2
3
4
5
6
7
8
9
from imblearn.ensemble import BalancedBaggingClassifier
bbc = BalancedBaggingClassifier(base_estimator=DecisionTreeClassifier(),
ratio='auto',
replacement=False,
random_state=0)
bbc.fit(X, y)

y_pred = bbc.predict(X_test)
confusion_matrix(y_test, y_pred)

四、源码实现Bagging方法

下面这个版本的Bagging实现了Sklearn的基础功能,并且在其基础上进一步完善:

  • 基础模型可以为多种(如:300个分类器,可以选100棵决策树、100个SVM 和100个KNN为基础模型进行Bagging),而sklearn中基础模型只能为一种。
  • 可以在框架内定义每个模型的数据集,而不是sklearn中的只有放回取样。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
# -*- coding: utf-8 -*-
import numpy as np
import pandas as pd
from collections import defaultdict
import random
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_score, recall_score
from sklearn.ensemble import IsolationForest

class Bagging(object):

def __init__(self,n_estimators,estimator,rate=1.0):
self.estimator = estimator
self.n_estimators = n_estimators
self.rate = rate

def Voting(self,data): #投票法
term = np.transpose(data) #转置
result =list() #存储结果

def Vote(df): #对每一行做投票
store = defaultdict()
for kw in df:
store.setdefault(kw, 0)
store[kw] += 1
return max(store,key=store.get)

result= map(Vote,term) #获取结果
return result

#随机欠采样函数
def UnderSampling(self,data):
#np.random.seed(np.random.randint(0,1000))
data=np.array(data)
np.random.shuffle(data) #打乱data
newdata = data[0:int(data.shape[0]*self.rate),:] #切片,取总数*rata的个数,删去(1-rate)%的样本
return newdata

def TrainPredict(self,train,test): #训练基础模型,并返回模型预测结果
clf = self.estimator.fit(train[:,0:-1],train[:,-1])
result = clf.predict(test[:,0:-1])
return result

#简单有放回采样
def RepetitionRandomSampling(self,data,number): #有放回采样,number为抽样的个数
sample=[]
for i in range(int(self.rate*number)):
sample.append(data[random.randint(0,len(data)-1)])
return sample

def Metrics(self,predict_data,test): #评价函数
score = predict_data
recall=recall_score(test[:,-1], score, average=None) #召回率
precision=precision_score(test[:,-1], score, average=None) #查准率
return recall,precision


def MutModel_clf(self,train,test,sample_type = "RepetitionRandomSampling"):
print "self.Bagging Mul_basemodel"
result = list()
num_estimators =len(self.estimator) #使用基础模型的数量

if sample_type == "RepetitionRandomSampling":
print "选择的采样方法:",sample_type
sample_function = self.RepetitionRandomSampling
elif sample_type == "UnderSampling":
print "选择的采样方法:",sample_type
sample_function = self.UnderSampling
print "采样率",self.rate
elif sample_type == "IF_SubSample":
print "选择的采样方法:",sample_type
sample_function = self.IF_SubSample
print "采样率",(1.0-self.rate)

for estimator in self.estimator:
print estimator
for i in range(int(self.n_estimators/num_estimators)):
sample=np.array(sample_function(train,len(train))) #构建数据集
clf = estimator.fit(sample[:,0:-1],sample[:,-1])
result.append(clf.predict(test[:,0:-1])) #训练模型 返回每个模型的输出

score = self.Voting(result)
recall,precosoion = self.Metrics(score,test)
return recall,precosoion
0%