集成学习的思想是将几个学习器(分类器)&回归器)组合后产生新的学习器。

弱分类器(weak learner)指那些分类精度只比随机猜测好一点的分类器(error rate < 0.5)；

集成算法的成功在于确保弱分类器多样性(Diversity)。而且集成不稳定算法也能得到明显的性能提升。

综合学习的常见思想有： ? Bagging ? Boosting ? Stacking

1. 弱分类器之间存在一定的差异，这将导致不同的分类边界，即可能出现错误。然后，在合并多个弱分类器后，可以获得更合理的边界，降低整体错误率， 取得更好的效果；
2. 对于数据集过大或过小，可以分别划分和放回操作，生成不同的数据子集，然后用数据子集训练不同的分类器，最后合并成大分类器；
3. 若数据划分边界过于复杂，使用线性模型难以描述情况，则可训练多个模型，然后进行模型集成；
4. 当多个异构的特征集难以集成时，可以考虑构建每个数据集 将多个模型集成为一个分类模型。

Bagging方法又叫做自举汇聚法(Bootstrap Aggregating)，思想是：通过原始数据集放回的抽样重新选择S个新数据集来训练S个分类器的集成技术。(确保数据多样性-模型多样性)

Bagging在预测新样本分类/回归时，将使用方法训练的模型多数投票或者求均值统计最终分类/回归结果的方法。

Bagging弱学习器的方法可以是基本的算法模型，eg: Linear、Ridge、Lasso、 Logistic、Softmax、ID3、C4.5、CART、SVM、KNN等。

NOTE1： Bagging方法是放回抽样，每个子集的样本数必须与原样本数相匹配 一致，所以提取的子集中有重复的数据，在模型训练中允许重复数据。 NOTE2： 样本数据几乎有1/3吗？Bagging在每个子模型的训练数据中。（ lim m → ∞ ? ( 1 ? 1 m ) m = 1 e ≈ 0.368 \underset{m\to \infty }{\mathop{\lim }}\,{ {(1-\frac{1}{m})}^{m}}=\frac{1}{e}\approx 0.368 m→∞lim(1?m1​)m=e1​≈0.368）

回归问题

import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import r2_score

''' bagging 回归 '''
###数据
df = pd.DataFrame([[1, 10.56],
                   [2, 27],
                   [3, 39.1],
                   [4, 40.4],
                   [5, 58],
                   [6, 60.5],
                   [7, 79],
                   [8, 87],
                   [9, 90],
                   [10, 95]],
                  columns=['X', 'Y'])
# print(df)
M = []  ###用来存储弱学习器
n_trees = 100  ###构造的弱学习器的数量

for i in range(n_trees):  ##循环训练我们的弱学习器
    ###对样本进行有放回的抽样m次
    ''' sample() 抽样 n=None, 抽样数据的条数 frac=None, 抽样的比例 replace=False, 是否有放回抽样 weights=None, 权重 random_state=None, 随机数种子 axis=None 维度 '''
    tmp = df.sample(frac=1.0, replace=True)  ###不需要设置随机数种子
    # tmp = tmp.drop_duplicates() # ##去重
    X = tmp.iloc[:, :-1]
    Y = tmp.iloc[:, -1]
    model = DecisionTreeRegressor(max_depth=1)
    model.fit(X, Y)

    M.append(model)

###做预测
x = df.iloc[:, :-1]
y = df.iloc[:, -1]

mode01 = DecisionTreeRegressor(max_depth=1)
mode01.fit(x, y)
y_hat_01 = mode01.predict(x)
print(y_hat_01)
print(mode01.score(x, y))
print("-" * 100)
res = np.zeros(df.shape[0])
for j in M:
    res += j.predict(x)
y_hat = res / n_trees
print(y_hat)
print('R2:', r2_score(y, y_hat))

分类问题

import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import f1_score, accuracy_score

df = pd.DataFrame([[0, 1], [1, 1], [2, 1], [3, -1], [4, -1],
                   [5, -1], [6, 1], [7, 1], [8, 1], [9, -1]])
n_tree = 199
models = []

for i in range(n_tree):
    df2 = df.sample(frac=1.0, replace=True)
    X = df2.iloc[:, :-1]
    Y = df2.iloc[:, -1]
    dec = DecisionTreeClassifier(max_depth=1)
    dec.fit(X, Y)
    models.append(dec)

x = df.iloc[:, :-1]
y = df.iloc[:, -1]
total = np.zeros(df.shape[0])
for i in range(n_tree):
    total += np.array(models[i].predict(x))
print(total)
y_hat = np.sign(total)
print(y_hat)
print(accuracy_score(y, y_hat))
print(f1_score(y, y_hat))
print("-" * 100)
model01 = DecisionTreeClassifier(max_depth=1)
model01.fit(x, y)
y_hat_01 = model01.predict(x)
print(y_hat_01)
print(accuracy_score(y, y_hat_01))
print(f1_score(y, y_hat_01))

在Bagging策略的基础上进行修改后的一种算法

1. 从原始样本集(n个样本)中用 Bootstrap采样(有放回重采样) 选出n个样本；
2. 使用抽取出来的子数据集(存在重复数据)来训练决策树；从所有属性中随机选择 K 个属性，从K个属性中选择出最佳分割属性作为当前节点的划分属性，按照这种方式来迭代的创建决策树。
3. 重复以上两步m次，即建立m棵决策树；
4. 这m个决策树形成随机森林，通过投票表决结果决定数据属于那一类

RF的推广算法

RF算法在实际应用中具有比较好的特性，应用也比较广泛，主要应用在：分类、回归、特征转换、异常点检测等。常见的RF变种算法如下： • Extra Tree • Totally Random Trees Embedding(TRTE) • Isolation Forest

Extra Tree是RF的一个变种，原理基本和RF一样，区别如下：

1. RF会随机重采样来作为子决策树的训练集，而Extra Tree每个子决策树采用原始数据集训练；
2. RF在选择划分特征点的时候会和传统决策树一样，会基于信息增益、信息增益率、基尼系数、均方差等原则来选择最优特征值；而Extra Tree会随机的选择一个特征值来划分决策树。

Extra Tree因为是随机选择特征值的划分点，这样会导致决策树的规模一般大于RF所生成的决策树。也就是说Extra Tree模型的方差相对于RF进一步减少。在某些情况下，Extra Tree的泛化能力比RF的强。

TRTE是一种 非监督 的数据转化方式。将低维的数据集映射到高维，从而让映射到高维的数据更好的应用于分类回归模型。

TRTE算法的转换过程类似RF+KDTree算法的方法，建立T个决策树来拟合数据(是类似KD-Tree一样基于特征属性的方差选择划分特征)。当决策树构建完成后，数据集里的每个数据在T个决策树中叶子节点的位置就定下来了，将位置信息转换为向量就完成了特征转换操作

案例： 有3棵决策树，各个决策树的叶子节点数目分别为:5,5,4，某个数据x划分到 第一个决策树的第3个叶子节点，第二个决策树的第一个叶子节点，第三个决策树 的第四个叶子节点，那么最终的x映射特征编码为:(0,0,1,0,0, 1,0,0,0,0, 0,0,0,1)

IForest是一种异常点检测算法，使用类似RF的方式来检测异常点（离群点）；IForest算法和RF算法的区别在于：

1. 在随机采样的过程中，一般只需要少量数据即可；
2. 在进行决策树构建过程中，IForest算法会随机选择一个划分特征，并对划分特征随机选择一个划分阈值；
3. IForest算法构建的决策树一般深度max_depth是比较大的。

区别原因：目的是异常点检测，所以只要能够区分异常的即可， 不需要大量数据；

对于异常点的判断，则是将测试样本x拟合到m棵决策树上。计算在每棵树上该样本的叶子节点的深度ht(x)。从而计算出平均深度h(x)；然后就可以使用下列公式计算样本点x的异常概率值，p(s,m)的取值范围为[0,1]，越接近 于1，则是异常点的概率越大。 备注：如果落在的叶子节点为正常样本点， 那么当前决策树不考虑，如果所有决策树上都是正常样本点，那么直接认为 异常点概率为0.

p ( x , m ) = 2 − h ( x ) c ( m ) , c ( m ) = 2 ln ⁡ ( m − 1 ) + ξ − 2 m − 1 m p(x,m)={ {2}^{-\frac{h(x)}{c(m)}}},c(m)=2\ln (m-1)+\xi -2\frac{m-1}{m} p(x,m)=2−c(m)h(x)​,c(m)=2ln(m−1)+ξ−2mm−1​ 其中m为样本个数， ξ \xi ξ为欧拉常数

RF的主要优点：

1. 训练可以并行化，对于大规模样本的训练具有速度的优势；
2. 由于进行随机选择决策树划分特征列表，这样在样本维度比较高的时候，仍然具有比较高的训练性能；
3. 给以给出各个特征的重要性列表；
4. 由于存在随机抽样，训练出来的模型方差小，泛化能力强，能够缓解过拟合的情况；
5. RF实现简单；
6. 对于部分特征的缺失不敏感。

RF的主要缺点：

1. 在某些噪音比较大的特征上（数据特别异常情况），RF模型容易陷入过拟合；
2. 取值比较多的划分特征对RF的决策会产生更大的影响，从而有可能影响模型的效果。

在随机森林的构建过程中，由于各棵树之间是没有关系的，相对独立的；在构建的过程中，构建第m棵子树的时候，不会考虑前面的m-1棵树。

思考： 如果在构建第m棵子树的时候，考虑到前m-1棵子树的结果，会不会对最终结果产 生有益的影响？（Boosting） 各个决策树组成随机森林后，在形成最终结果的时候能不能给定一种既定的决策顺序呢？(也就是那颗子树先进行决策、那颗子树后进行决策)

提升学习（Boosting）是一种机器学习技术，可以用于回归和分类的问题，它每一步产生弱预测模型(如决策树)，并加权累加到总模型中；如果每一步的弱预测模型的生成都是依据损失函数的梯度方式的，那么就称为梯度提升(Gradient boosting)；

提升技术的意义： 如果一个问题存在弱预测模型，那么可以通过提升技术的办法得到一个强预测模型；

常见的模型有： • Adaboost • Gradient Boosting(GBT/GBDT/GBRT)——（GBDT—XGB/Light GBM）

Adaptive Boosting是一种迭代算法。每轮迭代中会在训练集上产生一个新的学习器，然后使用该学习器对所有训练样本进行预测，以评估每个样本的重要性(Informative)。换句话来讲就是，算法/子模型会为每个样本赋予一个权重，每次用训练好的学习器标注/预测各个样本(训练数据)，如果某个样本点被预测的越正确，则将样本权重降低；否则提高样本的权重。权重越高的样本在下一个迭代训练中所占的权重就越大，也就是说越难区分的样本在训练过程中会变得越重要；

整个迭代过程直到错误率足够小或者达到一定的迭代次数为止——样本权重w、学习器权重a Adaboost算法将基分类器的线性组合作为强分类器，同时给分类误差率较小的基本分类器以大的权值，给分类误差率较大的基分类器以小的权重值； 构建的线性组合为：

f ( x ) = ∑ m = 1 M α m G m ( x ) f(x)=\sum\limits_{m=1}^{M}{ { {\alpha }_{m}}{ {G}_{m}}(x)} f(x)=m=1∑M​αm​Gm​(x)

最终分类器是在线性组合的基础上进行Sign函数转换：

G ( x ) = s i g n ( f ( x ) ) = s i g n [ ∑ m = 1 M α m G m ( x ) ] G(x)=sign(f(x))=sign[\sum\limits_{m=1}^{M}{ { {\alpha }_{m}}{ {G}_{m}}(x)}] G(x)=sign(f(x))=sign[m=1∑M​αm​Gm​(x)]

Sign函数:

AdaBoost算法原理:

最终的强学习器： G ( x ) = s i g n ( f ( x ) ) = s i g n [ ∑ m = 1 M α m G m ( x ) ] G(x)=sign(f(x))=sign[\sum\limits_{m=1}^{M}{ { {\alpha }_{m}}{ {G}_{m}}(x)}] G(x)=sign(f(x))=sign[m=1∑M​αm​Gm​(x)]

损失函数(以错误率作为损失函数)： ∑ i = 1 n w i = 1 ;   l o s s = ∑ i = 1 n w i I ( G ( x i ) ≠ y i ) \sum\limits_{i=1}^{n}{ { {w}_{i}}=1};\text{ }loss=\sum\limits_{i=1}^{n}{ { {w}_{i}}I(G({ {x}_{i}})\ne { {y}_{i}})} i=1∑n​wi​=1; loss=i=1∑n​wi​I(G(xi​)=yi​)