机器学习实验五：集成学习

系列文章目录

1. 机器学习实验一：线性回归
2. 机器学习实验二：决策树模型
3. 机器学习实验三：支持向量机模型
4. 机器学习实验四：贝叶斯分类器
5. 机器学习实验五：集成学习
6. 机器学习实验六：聚类

---

---

一、实验目的

（1）掌握集成学习的基本思想；
（2）掌握 boosting 和 bagging 策略；
（3）了解基于 Adaboost 及 bagging 集成器实现多分类任务。

二、实验原理

1.集成学习

集成学习（Ensemble learning）通过构建并结合多个学习器来完成学习任
务，也被称为多分类器系统或基于委员会的学习系统等。
集成学习的一般结构是先构建一组“个体学习器”，随后再利用某种策略将
这些“个体学习器”结合起来得到集成学习的结果。其中的个体学习器一般使用
决策树等较通用的现成算法，使用训练数据集训练得到。
根据个体生成器的生成方式，集成学习方法可以分为两大类。分别为个体学
习器之间存在强依赖关系、必须串行生成的序列化方法，例如 Boosting；以及
个体学习器之间不存在强依赖关系、可以同时生成的并行化方法，例如 Bagging
和随机森林。
由于集成学习是通过将多个学习器进行结合，故常常可以获得比单独某个学
习器更显著和优越的效果。

2.Boosting

Boosting 是一类可以将弱学习器提升为强学习器的算法。
Boosting 的工作机制基本相同：首先从初始训练集中训练出一个基学习器，
随后根据基学习器的性能表现对训练样本的分布进行一定的调整，增强对错误样
本的关注度；随后基于调整后的样本分布来训练下一个基学习器；持续迭代当前
过程，直至基学习器数目达到预先设定的值；最终将全部基学习器进行加权集合，
训练完成。
Boosting 算法中具代表性的算法为 Adaboost 算法。Adaboost 算法可以通过
使得基学习器线性组合后最小化指数损失函数来推导得到。
但标准的 Adaboost 算法只能实现二分类任务，或者说，利用标准 Adaboost
算法直接进行多分类任务很难取得较好的结果。因此要想实现多分类，可以采用
改进的 SAMME 或 SAMME.R 算法1。
SAMME 与标准 Adaboost 非常相似，只是增加了 log(K?1)这一项。因此，当
类别数 K=2 时，SAMME 等同于 Adaboost。
与 SAMME 算法不同，SAMME.R 算法采用加权概率估计（weighted probability
estimates）的方法更新加法模型。相比来说，SAMME.R 算法使用了比 SAMME 算
法更多的信息，也可以获得更高的准确率和鲁棒性。

3.Bagging

在基学习器相互独立的情况下，集成学习器的误差随着学习器数量的增多呈
指数级的下降。但是，使用相同类型的基学习器处理相同的问题，几乎不可能做
到相互独立。因此可以在数据上进行处理，即对相同训练样本进行采样，产生出
若干个不同的子集，再使用每个子集分别训练基学习器。当采样方法恰当时，由
于训练数据不同，获得的基学习器会有比较大的差异，同时可以取得较好的结果。
Bagging 算法基于自助采样法，也可以理解为有放回重新采样法，即给定一
个包含 m 个样本点的数据集，每次取出样本放入采样集中，再把样本放回原始数
据集，使得下次采样时仍然可以选中这个样本。重复上述过程，可以采样出 T
个含 m 个训练样本的采样集，随后对每个采样集训练出一个基学习器，再将基学
习器进行结合。Bagging 中对于分类任务采用简单投票法（少数服从多数），对
于回归任务采用简单平均法（几何平均）。分类任务中出现同票情况时，采用随
机选择或者进一步考察分类器投票置信度来决定。
Bagging 的算法描述如下图所示：

三、实验内容

使用 Python 编写 Adaboost 和 Bagging 算法框架，并利用 sklearn 提供的基
学习器构建 Adaboost 和 Bagging 算法模型，读取 Iris 数据集信息并进行多分类
预测，调整超参数优化模型，并根据精确率、召回率和 F1 值度量模型性能。

四、实验步骤

1. Adaboost-SAMME 算法

SAMME 算法首先初始化权重。随后进行 M 次迭代，每次迭代需要训练基分类
并进行预测，根据预测结果计算错误率，并根据错误率调整样本分布情况，最后
根据处理分类器权重并归一，完成本次迭代。
具体代码实现及注释如下：

def boost_SAMME(self, X, y, sample_weight): # SAMME
 estimator = deepcopy(self.base_estimator_)
 if self.random_state_:
 estimator.set_params(random_state=1)
 # (a)训练基分类器，计算结果
 estimator.fit(X, y, sample_weight=sample_weight)
 y_pred = estimator.predict(X)
 incorrect = y_pred != y
 # (b)计算错误率
 estimator_error = np.dot(incorrect, sample_weight) / np.sum(sample_weight, axis=0)
 # 分类效果比随机数还差，抛弃这种情况
 if estimator_error >= 1 - 1 / self.n_classes_:
 return None, None, None
 # (c)(1)计算当前分类器权重
 estimator_weight = self.learning_rate_ * np.log((1 - estimator_error) / estimator_error) 
+ np.log(
 self.n_classes_ - 1)
 # 权重为负，无意义，抛弃
 if estimator_weight <= 0:
 return None, None, None
 # (d) 更新样本权重
 sample_weight *= np.exp(estimator_weight * incorrect)
 sample_weight_sum = np.sum(sample_weight, axis=0)
 if sample_weight_sum <= 0:
 return None, None, None
 # (e)归一化权重
 sample_weight /= sample_weight_sum
 # 存储当前弱分类器
 self.estimators_.append(estimator)
 return sample_weight, estimator_weight, estimator_error

2. Adaboost-SAMME.R 算法

SAMME.R 算法首先初始化权重。随后进行 M 次迭代，每次迭代需要训练及分
类并进行预测，随后根据预测结果计算加权概率估计 h(x)，再根据 h(x)的值调
整样本分布情况及分类器权重并归一化处理。
具体代码实现及注释如下：

def boost_SAMMER(self, X, y, sample_weight): # SAMME.R
 estimator = deepcopy(self.base_estimator_)
 if self.random_state_:
 estimator.set_params(random_state=1)
 # 训练弱分类器
 estimator.fit(X, y, sample_weight=sample_weight)
 # 计算错误率
 y_pred = estimator.predict(X)
 incorrect = y_pred != y
 estimator_error = np.dot(incorrect, sample_weight) / np.sum(sample_weight, axis=0)
 # 比随机猜还差，抛弃
 if estimator_error >= 1.0 - 1 / self.n_classes_:
 return None, None, None
 # 计算 h(x)
 y_predict_proba = estimator.predict_proba(X)
 y_predict_proba[y_predict_proba < np.finfo(y_predict_proba.dtype).eps] = 
np.finfo(y_predict_proba.dtype).eps
 y_codes = np.array([-1. / (self.n_classes_ - 1), 1.])
 y_coding = y_codes.take(self.classes_ == y[:, np.newaxis])
 # 更新样本权重
 intermediate_variable = (-1. * self.learning_rate_ * (((self.n_classes_ - 1) / 
self.n_classes_) *
 inner1d(y_coding, 
np.log( y_predict
_proba)))) 
 sample_weight *= np.exp(intermediate_variable)
 sample_weight_sum = np.sum(sample_weight, axis=0)
 if sample_weight_sum <= 0:
 return None, None, None
 # 归一化权重
 sample_weight /= sample_weight_sum
 # 存储当前弱分类器
 self.estimators_.append(estimator)
 return sample_weight, 1, estimator_error

3. 手写 Bagging 实现随机森林算法

根据自助采样法定义，每次从 m 个样本中随机有放回的取出 m 个样本构成新
的数据集，得到如下代码实现：

def randomSample(X,y, rate): # 自助采样法,data 为原始数据集，rate 为采样比例（应该为 1）
 X_train = []
 y_train = []
 for i in range(int(len(X)*rate)):
 rand_num = random.randint(0, len(X) - 1)
 X_train.append(X[rand_num])
 y_train.append(y[rand_num])
 return X_train,y_train
#对 Bagging 算法的训练过程其实就是对若干个基分类器使用不同的数据子集进行训练的过程
def bagging(X,y,rate,n_estimators,base_estimator): # 数据 X、y，rate=1，分类器个数
 print("开始训练 Bagging")
 global estimators
 for i in range(n_estimators): # 构建 N 个分类器
 tmp_estimator = deepcopy(base_estimator)
 X_train,y_train = randomSample(X,y,rate)
 tmp_estimator.fit(X_train,y_train)
 estimators.append(tmp_estimator)
 print("弱分类器已完成训练")
#利用 Bagging 对数据进行分类其实就是把数据给全部基分类器进行分类，最后对得到的结果进行投票，少数服从多数得到结果
def predict(X):
 print("开始进行分类")
 global estimators
 result = []
 sample_result = []
 for estimator in estimators: # 求每一个分类器的结果
 result.append(list(estimator.predict(X)))
 n = len(result[0])
 for i in range(n): # 投票过程
 counter = Counter(list(np.array(result)[:,i]))
 tmp = counter.most_common()
 sample_result.append(tmp[0][0])
 return sample_result

4. 使用 sklearn 验证随机森林算法

以决策树作为基学习器，设置随机森林的基学习器个数 n_estimators=4，
使用 Iris 数据集的 80%为训练集，构建随机森林模型。
代码实现上，利用 sklearn 提供的 RandomForestClassifier()方法完成。
sklearn 中的 RandomForestClassifier()方法通过使用多组不同数据子集来训
练多颗决策树，再通过投票法完成分类。常用参数如下：
基分类器数量 n_estimators：默认为 100
最大深度 max_depth：基分类器决策树的最大深度
并行作业数 n_jobs：默认为 1，决定同时并行训练的基分类器个数
其他控制基分类器的参数与决策树 DesicionTreeClassifier()方法相同。
具体实现的核心代码如下：

X, y = datasets.load_iris(return_X_y=True)
X_train,X_test,y_train,y_test = train_test_split(X, y, test_size = 0.2, random_state = 1)
random_forest = RandomForestClassifier(n_estimators=4)
random_forest.fit(X_train,y_train)

总结

以上就是今天要讲的内容，机器学习实验五：集成学习