集成学习值Adaboost算法原理和代码小结(转载)

在集成学习原理小结中，我们讲到了集成学习按照个体学习器之间是否存在依赖关系可以分为两类：

• 第一个是个体学习器之间存在强依赖关系；
• 另一类是个体学习器之间不存在强依赖关系。

前者的代表算法就是提升(boosting)系列算法。在boosting系列算法中， Adaboost是最著名的算法之一。Adaboost既可以用作分类，也可以用作回归。本文就对Adaboost算法做一个总结。

一 回顾boosting算法的基本原理

AdaBoost是典型的Boosting算法，属于Boosting家族的一员。在说AdaBoost之前，先说说Boosting提升算法。Boosting算法是将“弱学习算法“提升为“强学习算法”的过程，主要思想是“三个臭皮匠顶个诸葛亮”。一般来说，找到弱学习算法要相对容易一些，然后通过反复学习得到一系列弱分类器，组合这些弱分类器得到一个强分类器。Boosting算法要涉及到两个部分，加法模型和前向分步算法。加法模型就是说强分类器由一系列弱分类器线性相加而成。一般组合形式如下：$$f(x;P)=\sum_{k=1}^Kβ_kh(x;\gamma_k)$$

其中，$h(x;\gamma_k)$ 就是一个个的弱分类器，$\gamma_k$是弱分类器学习到的最优参数，$β_k$ 就是弱学习在强分类器中所占比重，$P$ 是所有$\gamma_k$和$\beta_k$ 的组合。这些弱分类器线性相加组成强分类器。

前向分步就是说在训练过程中，下一轮迭代产生的分类器是在上一轮的基础上训练得来的。也就是可以写成这样的形式：

$$f _k(x)=f_{k-1}(x)+ β_kh_k(x;\gamma_k)$$

由于采用的损失函数不同，Boosting算法也因此有了不同的类型，AdaBoost就是损失函数为指数损失的Boosting算法。

在前面一节，我们已经讲到了boosting算法系列的基本思想，如下图：

从图中可以看出，Boosting算法的工作机制是首先从训练集用初始权重D(1)训练出一个弱学习器1，根据弱学习的学习误差率表现来更新训练样本的权重，使得之前弱学习器1学习误差率高的训练样本点的权重变高，使得这些误差率高的点在后面的弱学习器2中得到更多的重视。然后基于调整权重后的训练集来训练弱学习器2.，如此重复进行，直到弱学习器数达到事先指定的数目T，最终将这T个弱学习器通过集合策略进行整合，得到最终的强学习器。

在上图中有几个具体的问题我们没有详细说明。

• 如何计算分类误差率e?
• 如何得到弱学习器权重系数$\alpha$(即上式中的$β_k$)？
• 如何更新训练数据的样本权重D?
• 使用何种结合策略？

只要是boosting大家族的算法，都要解决这4个问题。那么Adaboost是怎么解决的呢？

二 Adaboost算法的基本思想

我们这里讲解Adaboost是如何解决上面4个问题的。

假设我们的训练集样本是：$$T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$$

训练集的在第k个弱学习器的样本权重系数为：$$D(k) = (w_{k1}, w_{k2}, ...w_{km}) ;\;\;\sum\limits_{i=1}^{m}w_{ki}=1;\;\;w_{1i}=\frac{1}{m};\;\; i =1,2...m$$

注意：在初始化第一个弱分类器输出权重时，我们假设训练集样本具有均匀的权值分布，即每个训练样本在第一个弱分类器的学习中作用相同，这一假设保证可以在训练集样本上学习第一个弱分类器$G_1(x)$。

首先我们看看Adaboost的分类问题。

分类问题的误差率很好理解和计算。由于多元分类是二元分类的推广，这里假设我们是二元分类问题，输出为{-1，1}，则第k个弱分类器$G_k(x)$在训练集上的分类误差率为：$$e_k = P(G_k(x_i) \neq y_i) = \sum\limits_{i=1}^{m}w_{ki}I(G_k(x_i) \neq y_i)$$

接着我们看弱学习器权重系数,对于二元分类问题，第k个弱分类器$G_k(x)$的权重系数为：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$$

为什么这样计算弱学习器权重系数？从上式可以看出，如果分类误差率$e_k$越大，则对应的弱分类器权重系数$\alpha_k$越小。也就是说，误差率小的弱分类器权重系数越大。具体为什么采用这个权重系数公式，我们在讲Adaboost的损失函数优化时再讲。

第三个问题，如何更新样本权重D。假设第k个弱分类器的样本集权重系数为$D(k) = (w_{k1}, w_{k2}, ...w_{km})$，则对应的第k+1个弱分类器的样本权重系数为：$$w_{k+1,i} = \frac{w_{ki}}{Z_K}exp(-\alpha_ky_iG_k(x_i))$$

这里$Z_k$是规范化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}exp(-\alpha_ky_iG_k(x_i))$$

从$w_{k+1,i}$计算公式可以看出，如果第i个样本分类错误，则$y_iG_k(x_i) < 0$，导致样本的权重在第k+1个弱分类器中增大，如果分类正确，则权重在第k+1个弱分类器中减少.不改变所给的训练集数据，通过不断的改变训练样本的权重，使得训练集数据在弱分类器的学习中起不同的作用。具体为什么采用这个样本权重更新公式，我们在讲Adaboost的损失函数优化时再讲。

最后一个问题是集合策略。Adaboost分类采用的是加权平均法，最终的强分类器为：$$f(x) = sign(\sum\limits_{k=1}^{K}\alpha_kG_k(x))$$

系数$\alpha_k$表示了弱分类器$G_k(x)$的重要性，这里所有$\alpha$之和并不为1，$f(x)$的符号决定实例$x$的类，$f(x)$的绝对值表示分类的置信度。

接着我们看看Adaboost的回归问题。由于Adaboost的回归问题有很多变种，这里我们以Adaboost R2算法为准。

我们先看看回归问题的误差率的问题，对于第k个弱学习器，计算他在训练集上的最大误差：$$E_k= max|y_i - G_k(x_i)|\;i=1,2...m$$

然后计算每个样本的相对误差$$e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$$

这里是误差损失为线性时的情况，如果我们用平方误差，则$e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$,如果我们用的是指数误差，则$e_{ki}= 1 - exp（\frac{-y_i + G_k(x_i))}{E_k}）$

最终得到第k个弱学习器的 误差率：$$e_k =  \sum\limits_{i=1}^{m}w_{ki}e_{ki}$$

我们再来看看如何得到弱学习器权重系数$\alpha$。这里有：$$\alpha_k =\frac{e_k}{1-e_k}$$

对于更新更新样本权重D，第k+1个弱学习器的样本集权重系数为：$$w_{k+1,i} = \frac{w_{ki}}{Z_k}\alpha_k^{1-e_{ki}}$$

这里$Z_k$是规范化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}\alpha_k^{1-e_{ki}}$$

最后是结合策略，和分类问题稍有不同，采用的是对加权的弱学习器取中位数的方法，最终的强回归器为：$$f(x) = \sum\limits_{k=1}^{K}(ln\frac{1}{\alpha_k})g(x)$$

其中，$g(x)$是所有$\alpha_kG_k(x), k=1,2,....K$的中位数。　

三 AdaBoost分类问题的损失函数优化

上面我们讲到了分类Adaboost的弱学习器权重系数公式和样本权重更新公式。但是没有解释选择这个公式的原因，让人觉得是魔法公式一样。其实它可以从Adaboost的损失函数推导出来。

从另一个角度讲，Adaboost是模型为加法模型，学习算法为前向分步学习算法，损失函数为指数函数的分类问题。

模型为加法模型好理解，我们的最终的强分类器是若干个弱分类器加权平均而得到的。

前向分步学习算法也好理解，我们的算法是通过一轮轮的弱学习器学习，利用前一个弱学习器的结果来更新后一个弱学习器的训练集权重。也就是说，第k-1轮的强学习器为：$$f_{k-1}(x) = \sum\limits_{i=1}^{k-1}\alpha_iG_{i}(x)$$

而第k轮的强学习器为：$$f_{k}(x) = \sum\limits_{i=1}^{k}\alpha_iG_{i}(x)$$

上两式一比较可以得到：$$f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x) $$

可见强学习器的确是通过前向分步学习算法一步步而得到的。

Adaboost损失函数为指数函数，即定义损失函数为：$$loss=\sum\limits_{i=1}^{m}exp(-y_if_{k}(x_i))$$

利用前向分步学习算法的关系可以得到损失函数为：$$loss=\sum\limits_{i=1}^{m}exp[-y_i(f_{k-1}(x_i) + \alpha_kG_k(x_i))]$$

假设已经经过了$k-1$次迭代，$f_{k-1}(x)$已知，令$w_{ki}^{’} = exp(-y_if_{k-1}(x_i))$, $w_{ki}^{’}$依赖于$f_{k-1}(x_i)$。

将$w_{ki}^{’}$带入损失函数,损失函数转化为：$$loss=\sum\limits_{i=1}^{m}w_{ki}^{’}exp[-y_i\alpha_k G_k(x_i)]$$我们继续化简$loss$:$$loss=\sum\limits_{y_i=G_k(x_i)}w_{ki}^{'}exp(-\alpha_k)+\sum\limits_{y_i \neq G_k(x_i)}w_{ki}^{'}exp(\alpha_k)$$

$$=(exp(\alpha_k)-exp(-\alpha_k))\sum\limits_{i=1}^{m}w_{ki}^{'}I(y_i \neq G_k(x_i))+exp(-\alpha_k)\sum\limits_{i=1}^{m}w_{ki}^{'}$$

并对$\alpha$求导，使其等于0，则就得到了：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$$

其中，$e_k$即为我们前面的分类误差率。$$e_k = \frac{\sum\limits_{i=1}^{m}w_{ki}^{’}I(y_i \neq G(x_i))}{\sum\limits_{i=1}^{m}w_{ki}^{’}} = \sum\limits_{i=1}^{m}w_{ki}I(y_i \neq G(x_i))$$

最后看样本权重的更新。利用$f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x) $和$w_{ki}^{’} = exp(-y_if_{k-1}(x))$，即可得：$$w_{k+1,i}^{’} = w_{ki}^{’}exp[-y_i\alpha_kG_k(x)]$$

这与我们上面说到的样本权重的更新只差一个规范化因子$Z_k$，两者是等价的。

四 AdaBoost二元分类问题算法流程

这里我们对AdaBoost二元分类问题算法流程做一个总结。

输入为样本集$T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$，输出为{-1, +1}，弱分类器算法, 弱分类器迭代次数K。

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

1) 初始化样本集权重为：$$D(1) = (w_{11}, w_{12}, ...w_{1m}) ;\;\; w_{1i}=\frac{1}{m};\;\; i =1,2...m$$

2) 对于k=1,2，...K:

a) 使用具有权重$D_k$的样本集来训练数据，得到弱分类器$G_k(x)$

b)计算$G_k(x)$的分类误差率：$$e_k = P(G_k(x_i) \neq y_i) = \sum\limits_{i=1}^{m}w_{ki}I(G_k(x_i) \neq y_i)$$

c) 计算弱分类器的系数：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k}$$

d) 更新样本集的权重分布：$$w_{k+1,i} = \frac{w_{ki}}{Z_K}exp(-\alpha_ky_iG_k(x_i)) \;\; i =1,2,...m$$

这里$Z_k$是规范化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}exp(-\alpha_ky_iG_k(x_i))$$

3) 构建最终分类器为：$$f(x) = sign(\sum\limits_{k=1}^{K}\alpha_kG_k(x))$$　　　　

对于Adaboost多元分类算法，其实原理和二元分类类似，最主要区别在弱分类器的系数上。比如Adaboost SAMME算法，它的弱分类器的系数：$$\alpha_k = \frac{1}{2}log\frac{1-e_k}{e_k} + log(R-1)$$

其中R为类别数。从上式可以看出，如果是二元分类，R=2，则上式和我们的二元分类算法中的弱分类器的系数一致。

五 Adaboost回归问题的算法流程

这里我们对AdaBoost回归问题算法流程做一个总结。AdaBoost回归算法变种很多，下面的算法为Adaboost R2回归算法过程。

输入为样本集$T=\{(x_,y_1),(x_2,y_2), ...(x_m,y_m)\}$，，弱学习器算法, 弱学习器迭代次数K。

输出为最终的强学习器$f(x)$

1) 初始化样本集权重为：$$D(1) = (w_{11}, w_{12}, ...w_{1m}) ;\;\; w_{1i}=\frac{1}{m};\;\; i =1,2...m$$

2) 对于k=1,2，...K:

a) 使用具有权重$D_k$的样本集来训练数据，得到弱学习器$G_k(x)$

b) 计算训练集上的最大误差：$$E_k= max|y_i - G_k(x_i)|\;i=1,2...m$$

c) 计算每个样本的相对误差:

如果是线性误差，则$e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$；

如果是平方误差，则$e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$

如果是指数误差，则$e_{ki}= 1 - exp（\frac{-|y_i -G_k(x_i)|}{E_k}）$　　　　　　　　

d) 计算回归误差率：$$e_k =  \sum\limits_{i=1}^{m}w_{ki}e_{ki}$$

e) 计算弱学习器的系数：$$\alpha_k =\frac{e_k}{1-e_k}$$

f) 更新样本集的权重分布为：$$w_{k+1,i} = \frac{w_{ki}}{Z_k}\alpha_k^{1-e_{ki}}$$

这里$Z_k$是规范化因子：$$Z_k = \sum\limits_{i=1}^{m}w_{ki}\alpha_k^{1-e_{ki}}$$

3) 构建最终强学习器为：$$f(x) = \sum\limits_{k=1}^{K}(ln\frac{1}{\alpha_k})g(x)$$

其中，$g(x)$是所有$\alpha_kG_k(x), k=1,2,....K$的中位数。　

六 Adaboost算法的正则化

为了防止Adaboost过拟合，我们通常也会加入正则化项，这个正则化项我们通常称为步长(learning rate)。定义为$\nu$,对于前面的弱学习器的迭代：$$f_{k}(x) = f_{k-1}(x) + \alpha_kG_k(x) $$

如果我们加上了正则化项，则有：$$f_{k}(x) = f_{k-1}(x) + \nu\alpha_kG_k(x) $$

$\nu$的取值范围为$0 < \nu \leq 1 $。对于同样的训练集学习效果，较小的$\nu$意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。

七 Adaboost的例子

给定如下表所示训练数据，假设弱分类器由$x<v$或$x>v$产生，可以看做由一个根节点直接连接两个叶节点的简单决策树，其阈值$v$使该分类器在训练数据集上的分类误差率最低，试用Adaboost算法学习一个强分类器。

序号	1	2	3	4	5	6	7	8	9	10
$x$	0	1	2	3	4	5	6	7	8	9
$y$	1	1	1	-1	-1	-1	1	1	1	-1

解：初始化样本权重系数：$$D_1={w_{11},w_{12},...,w_{110}};\;\;w_{1i}=0.1,i=1,2,...,10$$

对于$k$=1：

a、在权重为$D_1$的训练数据上、阈值$v$取2.5时分类误差率最低，故弱分类器为：$$G_1(x)=\begin{cases}1,   { x<2.5}\\ - 1,   {x>2.5 }\end{cases}$$

b、$G_1(x)$在训练数据集上的分类误差率$e_1=P(G_1(x_i) \neq y_i) = 0.3$

c、计算$G_1(x)$的系数:$\alpha_1=\frac{1}{2}log\frac{1-e_1}{e_1}=0.4236$

d、更新样本的权重分布:$$D_2={w_{21},...,w_{2i},...,w_{210}};\;\;w_{2i}=\frac{w_{1i}}{Z_1}exp(-\alpha_1 y_i G_1(x_i)), i=1,2,...,10$$ $$D_2=(0.07143,0.07143,0.07143,0.07143,0.07143,0.07143,0.16667,0.16667,0.16667,0.07143)$$ $$f_1(x)=0.4236G_1(x)$$

分类器$sign[f_1(x)]$在训练数据集上有3个误分类点。

对于$k$=2：

a、在权重为$D_2$的训练数据上、阈值$v$取8.5时分类误差率最低，故弱分类器为：$$G_2(x)=\begin{cases}1,   { x<8.5}\\ - 1,   {x>8.5 }\end{cases}$$

b、$G_2(x)$在训练数据集上的分类误差率$e_2=P(G_2(x_i) \neq y_i) = 0.2143$

c、计算$G_2(x)$的系数:$\alpha_2=\frac{1}{2}log\frac{1-e_2}{e_2}=0.6496$

d、更新样本的权重分布:$$D_3={w_{31},...,w_{3i},...,w_{310}};\;\;w_{3i}=\frac{w_{2i}}{Z_2}exp(-\alpha_2 y_i G_2(x_i)), i=1,2,...,10$$ $$D_3=(0.0455,0.0455,0.0455,0.1667,0.1667,0.1667,0.1060,0.1060,0.1060,0.0455)$$ $$f_2(x)=0.4236G_1(x)+0.6496G_2(x)$$

分类器$sign[f_2(x)]$在训练数据集上有3个误分类点。

对于$k$=3：

a、在权重为$D_3$的训练数据上、阈值$v$取5.5时分类误差率最低，故弱分类器为：$$G_3(x)=\begin{cases}1,   { x>5.5}\\ - 1,   {x<5.5 }\end{cases}$$

b、$G_3(x)$在训练数据集上的分类误差率$e_3=P(G_3(x_i) \neq y_i) = 0.1820$

c、计算$G_3(x)$的系数:$\alpha_3=\frac{1}{2}log\frac{1-e_3}{e_3}=0.7514$

d、更新样本的权重分布:$$D_4={w_{41},...,w_{4i},...,w_{410}};\;\;w_{4i}=\frac{w_{3i}}{Z_3}exp(-\alpha_3 y_i G_3(x_i)), i=1,2,...,10$$ $$D_4=(0.125,0.125,0.125,0.102,0.102,0.102,0.065,0.065,0.065,0.125)$$ $$f_3(x)=0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)$$

分类器$sign[f_3(x)]$在训练数据集上有0个误分类点。

于是最终分类器为：$$G(x)=sign[f_3(x)]=sign[0.4236G_1(x)+0.6496G_2(x)+0.7514G_3(x)]$$

八 scikit-learn Adaboost类库使用小结

1. Adaboost类库概述

scikit-learn中Adaboost类库比较直接，就是AdaBoostClassifier和AdaBoostRegressor两个，从名字就可以看出AdaBoostClassifier用于分类，AdaBoostRegressor用于回归。

AdaBoostClassifier使用了两种Adaboost分类算法的实现，SAMME和SAMME.R。而AdaBoostRegressor则使用了讲到的Adaboost回归算法的实现，即Adaboost.R2。

当我们对Adaboost调参时，主要要对两部分内容进行调参，第一部分是对我们的Adaboost的框架进行调参， 第二部分是对我们选择的弱分类器进行调参。两者相辅相成。下面就对Adaboost的两个类：AdaBoostClassifier和AdaBoostRegressor从这两部分做一个介绍。

2. AdaBoostClassifier和AdaBoostRegressor框架参数

我们首先来看看AdaBoostClassifier和AdaBoostRegressor框架参数。两者大部分框架参数相同，下面我们一起讨论这些参数，两个类如果有不同点我们会指出。

1）base_estimator：AdaBoostClassifier和AdaBoostRegressor都有，即我们的弱分类学习器或者弱回归学习器。理论上可以选择任何一个分类或者回归学习器，不过需要支持样本权重。我们常用的一般是CART决策树或者神经网络MLP。默认是决策树，即AdaBoostClassifier默认使用CART分类树DecisionTreeClassifier，而AdaBoostRegressor默认使用CART回归树DecisionTreeRegressor。另外有一个要注意的点是，如果我们选择的AdaBoostClassifier算法是SAMME.R，则我们的弱分类学习器还需要支持概率预测，也就是在scikit-learn中弱分类学习器对应的预测方法除了predict还需要有predict_proba。

2）algorithm：这个参数只有AdaBoostClassifier有。主要原因是scikit-learn实现了两种Adaboost分类算法，SAMME和SAMME.R。两者的主要区别是弱学习器权重的度量，SAMME使用了和我们的原理篇里二元分类Adaboost算法的扩展，即用对样本集分类效果作为弱学习器权重，而SAMME.R使用了对样本集分类的预测概率大小来作为弱学习器权重。由于SAMME.R使用了概率度量的连续值，迭代一般比SAMME快，因此AdaBoostClassifier的默认算法algorithm的值也是SAMME.R。我们一般使用默认的SAMME.R就够了，但是要注意的是使用了SAMME.R， 则弱分类学习器参数base_estimator必须限制使用支持概率预测的分类器。SAMME算法则没有这个限制。

3）loss：这个参数只有AdaBoostRegressor有，Adaboost.R2算法需要用到。有线性‘linear’, 平方‘square’和指数 ‘exponential’三种选择, 默认是线性，一般使用线性就足够了，除非你怀疑这个参数导致拟合程度不好。这个值的意义在原理中我们也讲到了，它对应了我们对第k个弱分类器的中第i个样本的误差的处理，即：如果是线性误差，则$e_{ki}= \frac{|y_i - G_k(x_i)|}{E_k}$；如果是平方误差，则$e_{ki}= \frac{(y_i - G_k(x_i))^2}{E_k^2}$，如果是指数误差，则$e_{ki}= 1 - exp（\frac{-y_i + G_k(x_i))}{E_k}）$，$E_k$为训练集上的最大误差$E_k= max|y_i - G_k(x_i)|\;i=1,2...m$

4) n_estimators： AdaBoostClassifier和AdaBoostRegressor都有，就是我们的弱学习器的最大迭代次数，或者说最大的弱学习器的个数。一般来说n_estimators太小，容易欠拟合，n_estimators太大，又容易过拟合，一般选择一个适中的数值。默认是50。在实际调参的过程中，我们常常将n_estimators和下面介绍的参数learning_rate一起考虑。

5) learning_rate:  AdaBoostClassifier和AdaBoostRegressor都有，即每个弱学习器的权重缩减系数$\nu$，在原理中的正则化小节我们也讲到了，加上了正则化项，我们的强学习器的迭代公式为$f_{k}(x) = f_{k-1}(x) + \nu\alpha_kG_k(x) $。$\nu$的取值范围为$0 < \nu \leq 1 $。对于同样的训练集拟合效果，较小的$\nu$意味着我们需要更多的弱学习器的迭代次数。通常我们用步长和迭代最大次数一起来决定算法的拟合效果。所以这两个参数n_estimators和learning_rate要一起调参。一般来说，可以从一个小一点的$\nu$开始调参，默认是1。

3. AdaBoostClassifier和AdaBoostRegressor弱学习器参数

这里我们再讨论下AdaBoostClassifier和AdaBoostRegressor弱学习器参数，由于使用不同的弱学习器，则对应的弱学习器参数各不相同。这里我们仅仅讨论默认的决策树弱学习器的参数。即CART分类树DecisionTreeClassifier和CART回归树DecisionTreeRegressor。

DecisionTreeClassifier和DecisionTreeRegressor的参数基本类似，在scikit-learn决策树算法类库使用小结这篇文章中我们对这两个类的参数做了详细的解释。这里我们只拿出调参数时需要尤其注意的最重要几个的参数再拿出来说一遍：

1) 划分时考虑的最大特征数max_features: 可以使用很多种类型的值，默认是"None",意味着划分时考虑所有的特征数；如果是"log2"意味着划分时最多考虑log2N

个特征；如果是"sqrt"或者"auto"意味着划分时最多考虑$log_2N$个特征。如果是整数，代表考虑的特征绝对数。如果是浮点数，代表考虑特征百分比，即考虑（百分比xN）取整后的特征数。其中N为样本总特征数。一般来说，如果样本特征数不多，比如小于50，我们用默认的"None"就可以了，如果特征数非常多，我们可以灵活使用刚才描述的其他取值来控制划分时考虑的最大特征数，以控制决策树的生成时间。

2) 决策树最大深max_depth: 默认可以不输入，如果不输入的话，决策树在建立子树的时候不会限制子树的深度。一般来说，数据少或者特征少的时候可以不管这个值。如果模型样本量多，特征也多的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。常用的可以取值10-100之间。

3) 内部节点再划分所需最小样本数min_samples_split: 这个值限制了子树继续划分的条件，如果某节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分。 默认是2.如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。

4) 叶子节点最少样本数min_samples_leaf: 这个值限制了叶子节点最少的样本数，如果某叶子节点数目小于样本数，则会和兄弟节点一起被剪枝。 默认是1,可以输入最少的样本数的整数，或者最少样本数占样本总数的百分比。如果样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值。

5）叶子节点最小的样本权重和min_weight_fraction_leaf：这个值限制了叶子节点所有样本权重和的最小值，如果小于这个值，则会和兄弟节点一起被剪枝。 默认是0，就是不考虑权重问题。一般来说，如果我们有较多样本有缺失值，或者分类树样本的分布类别偏差很大，就会引入样本权重，这时我们就要注意这个值了。

6) 最大叶子节点数max_leaf_nodes: 通过限制最大叶子节点数，可以防止过拟合，默认是"None”，即不限制最大的叶子节点数。如果加了限制，算法会建立在最大叶子节点数内最优的决策树。如果特征不多，可以不考虑这个值，但是如果特征分成多的话，可以加以限制，具体的值可以通过交叉验证得到。

4. AdaBoostClassifier实战

这里我们用一个具体的例子来讲解AdaBoostClassifier的使用。

首先我们载入需要的类库：

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_gaussian_quantiles

接着我们生成一些随机数据来做二元分类，如果对如何产生随机数据不熟悉，在另一篇文章机器学习算法的随机数据生成中有比较详细的介绍。

# 生成2维正态分布，生成的数据按分位数分为两类，500个样本,2个样本特征，协方差系数为2
X1, y1 = make_gaussian_quantiles(cov=2.0,n_samples=500, n_features=2,n_classes=2, random_state=1)
# 生成2维正态分布，生成的数据按分位数分为两类，400个样本,2个样本特征均值都为3，协方差系数为2
X2, y2 = make_gaussian_quantiles(mean=(3, 3), cov=1.5,n_samples=400, n_features=2, n_classes=2, random_state=1)
#讲两组数据合成一组数据
X = np.concatenate((X1, X2))
y = np.concatenate((y1, - y2 + 1))

我们通过可视化看看我们的分类数据，它有两个特征，两个输出类别，用颜色区别。

plt.scatter(X[:, 0], X[:, 1], marker='o', c=y,s=10)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXMAAAD2CAMAAAATbpd/AAAAAXNSR0IArs4c6QAAANVQTFRF////TQ5c/ekwRgRWSQhZ/ecr/ecnRABU/eckMjIyWBxl/ecu///6/fz9/eo9/etJ/e1W//zi//3r//3zbDh4/vWg0cHU+Pb5Yipv//rP/fGH/vOU/fB48+/z4dfj//vY//nGyLXN/e5i2czb5+Dp7efv/ve0/vWrsZi4qYqwdUOBkGeY//e9/e9sfU+JhlqQmHKhuqLAoH6owKvEGRkZKioqTQ1RTExMvr294sc2p3xCnZqaxaM9YGBg9d0qfUlJjYeGdHR07OzrzbWUQEBAdkJyQiw5v4gZcwAAIABJREFUeNrtXQdb28oSVbdRtyzZcu+924QEQiC5yfv/f+ntzK6aC7EdTDDRfvc9gsGFo9HMmTOzsxyXrnSlK13pSle60pWudJ2zbm/S9Yrr9hjMb1Kze811k2KeYv4vY/7906dvxRTzt8S8e1vkPn9NMX9bzP8zPn9JMX9b33J7+y3152+K+X+//itS3/L1SEL5d1ZtMi58FMyHxMi/fnv/dj6WMnz3g2Be+FTkvl1BDFUzGb7wQTDnflwHV1zyklpLc6K3Xa1hL81D05VinmKerhTzFPMU8xTzFPMU83SlmKeYpyvFPMU8xTzFPMU8xTzFPMU8xTxdKeYp5ulKMU8xTzFPMU8xTzFPV4r5h8S89vnTp6vrPzcmvNu7Xsy/feWKtWvDfC1mxMXVYl67vULf0pMymcz4ajEv3Hy7+YZ2/r57/hOrDpgXrhfz2wL348eV2bnh89LkemNol9j2l8/X5s+Lm9Y185ZfHe77tdn5K67aqvD2mBduPn3+7xUx142rglzl+dG150RVRSi9H0rpL2DbTm+5PETmW3wm41855iUtm7X+OtbD8Rrutg2fkZbkqy+KqnGQAUnzFPM/XwRrdBgjQikJoEUxkxEP7f/auIvatfuWmaI1T81wCuf81bXlorPFIEcLymbWhL1Dltrledzf6ErS7/xHca5OjGvFnMvrJz6hwPPqGdoJbNJNXqs1cSV4GTq8JCH6vVYdL89o9LuruiSvtrpazE9e80xGOoM6kODHJw19TF5oSL30sDX2h9u303pUPPhqC+J+Rv8O5mBim9OftuAlNYnhkLjxenAhRWbzkedRRYlJNN0WMftuJ+5LOsQNdf8dzGtzdXm0K62PfZbDGKvRtkdqrUOYfXIXsFS1O5n00LkTL+8CnyHOjO+tJN4t/nFQuVbMT1qAJQPH2KyKEWJbboNAyraqE/sWIYIWyVcxI7or6sz8+PyA2mhYvGLecuFF2J9UD5wL77P7oxAiHN0QLfYA6r4G2rtL/kX82AScmRtzPoYvSeMU84POn+ddI4Q/cN8EzATrWKv+ohAD1A0YEmHqmSU4M67rqmHMDC9Livl+ZtkKvIAvhm5mIYbeO0joo3Aacxx1Eq+l4GJ067HwKvqpnR+xuvNx4Bx6rrqMExgJfUjS1xTQkAvrQvhLEqvuFcaLxaSXYv5SZj9evhTwjM2wrhIfInU5o1APhPahFPqkiN/TyEAIzYUklw+DeYe4h5dqRBPC27sTEiFXhkv+yfP4y/ExR/VhgT4i9aiXz2TUFPOX1opARGKi0enulU0kYuL8CGNlB9w6yS9ZlA34Tp2XJOJ3CipPM9WaKvHrFPMX3TiBbMgZY17ao4+Akijifxmx0JUQc4yOdVdFhI0iBxck4Ut6wwsV+j4M5sQsCfXoJB1CnUXTNThyat3EdIeqv3LH9Tjr4cUFYTXS6E0+6tVi3lLVWMVy5LsStLZAt0VI7+q+yKJgV83QJS2iiNmjqK/8cQ+zzxWtaDAtwd2uh9ZbxX8c8yLoh0aMeYu0hWvI+/XYrxCr7zK/nZHAwYxjMoA0N7AiJI797YmBamZbEd7s5rT/GuY1cM/FOPNW1TFiMhGZllunsZKg3BphNgRhNjPJx0hhh9ITnoTYZMsdJZVcYRhGZDdG7Qst45/0LZN4+1CP56VW4JqRv4R2TjAf8qIoiXy3hh7maYo/zd1lMnf3U67oY+afFHhrLvL2IS/xQVI0F8NbYcLz438Sc64T+JDepsvVWnUuwpx69CLxGCIYPRQtFqDwgoDynM3aULLy7u/uHrI2p5e+ZO4eH78H9MeHS+lLIojwfkyv6Y1DIYbdBP8wb6mz6maQb84l+u0aNFoeAt9aCrTClnqXJWtAIJezSjarzHRbkx/us9knnXMm/ogbw3MCxzWRtiscobMv/lOYryUVcOgM6xEPTDjjHuLRw4i5gWam8tNjyLSrgLnHcQIBvG3aDjQkmOQh2fEe7kDLhWIciFvQhVGcjNGFG8ngWXf9wmV8i3Hz+T1izthgQZKYEriK8erNehX4X8CcJ4jbiiBntUr4/HY2q5EwCjhbXt5pE2u32ppmc/IzgXsOBIfv1XmRX8buJHH8mrWLw3B+//YuMWdZzwSyeGKJw2Fx6U+KUbrJr9x5l9o/pPIDDQw7W+VyXjNX9gwu3x8Ac5kqYNyWRb6Ysmz1dU54vLuTMHHiC0mtZZw5ozJbG66MUzHv/vryLjHn5iiLQGF5hS0qbvQjLPgQns6rIJQU4W+mmMulnCBrBF/bVDCCcnkBHldkYvUm/JzjmsL9z6WIYbfW5eNMfn4G5oYv8fNTMf9ceKeYc130rqPxiOsVkq1YFDI0VeLA9WmTYAuWLPcDeyeBUxtwulfONdqaAkuzTBpVA51rwfOj1sJdRMp5XRXHBk1OO8dHdqainYD5l29B+/n73WdR4Am1jrccGmuVnyMJF1dcztS0donT24pSxuY9maIuD7iqpggO51TBwqt54uGVwN/XhwWfamEJdIsn8xWSHBysMR3C/MftbXSIyDvlisC73cU2U54j5r0cGrbWr5AI6nF927bLZcTc7nvErwj9UsmxkMP0icH3E0wQ1nzXG5/Ey+vzRe90GvhefUuEbrLcGXJJAvn3clWhCBOglXKDWPmMeBuTuJYKgZiQc3Qr5Gce17AUWSvFdBgeEliMwKG2gPIX8TpuyEW7y9G5XOaaMe+5fLIyZEzURdFYu+OfBGN0JXKVwJ2t9AVsC9YhEyLfazMLr4ipZbWSjtG0HHvZOpUhpSB+jFUJG3qN1qYIORfIDEVePLty96Fq0EMJqPpmvAQvYmPak8fsp0FYS9k0LUpisloDcSZOp9rkHLg42iB6Fcc2vRo0zDDv4mNUXnBrFNGYtgCUlb82zL324PVTVNANCRrShBhw3wZ3znFg0TNNlqmvIUtoT7k2/Q6t2yYRlcRQvcE6h8nPtNJakoJmUgl14BboxQsKNsG8xotn9xv9LczJXa71LyG9dLAwOq1O9SnJLnW9SciJImQDpgg2DfS8XLXhe3Djep9kRFxO0EwHX4V4eWHK1XpjiYrDS573h52g4EoIKWrF3eW6eF2Y5+SkDz1+FceSW+vN3RZX96VJybKagTMHV9zqQWEUqsglQbYbhm4LMkkz7QByEjg19rYD9Ojh65aVgDH2NcHKU7JP5QXar1RTJXETvNGFcv+LYl5RmJGdvEh+L63HImFtkJI/ErPVmdTFD3modnL1h0c731DQs4CEJTiGFdh4NtsO3lWHCyGEr0s5DDWIJrwkqAuZWJK7lfNeH+Z9LatUz/PZJA1aYluKSzGXnUD6glXnSsQfy94MguUU7ieFEBa4q2TIO4GrhyxnJstlU+ije0Ej0LeDQxzzF7cfXYU/L5tV/awn9lRe7Y6Iiy0WeOl/Nsk1uTjmKw9kFbkyA3GFeIG+aedgpyRQk1l1Zpbpu+bL8Hiur9Br1oYnBY7G8aZNU5guIXQOY45EFUV+Ur9izM9fxTrxroUNsbj+fVYrNxkqC0ki1i/WQT1RrHzOVNrRRSUQy8SNe5os4F3RJIav2Bxw96yc43T0OwohUk0v5xBeSX4sd3hCTVCnMuqYUXYX6s5epX+Kn8Pe8AqKtAFnKdTqY3/DgZeW4TpEiJc8U9AqTfTZSJY8zJcsZOnExek5E/mM3a6QizKgJEfOd1e0XET7lFb+vMe/zoGCV4o57g0vaQ/P35mZL0mAk8QHue8BjvTBfhk5zQDMluSfM68tZ+UG3axKQPXw8pS5vKnQXyCsBtIoGQlOtV8yaN6Dij22ZCwkMbTz7vk9u1eBeW7KGiT0wHhbWFSAvHMYBjgQSZ4EKyShHmb2zYYdJEMyCaI258wwHbWpB6k4uQolNZA0UfARelPTvI4L4i1Wpjbwf8XROtC4sHz3gTEnhNnMUw4dbOwFs5tzEOao4mKwvs8nExCmyVYbILUEzZaz0ZI9ixixhlkqYe7tgSxjBCCMxpZlu6ywi2OS6/KcoQ0cI96v++TV4fIGe2NAHBCLHw5zAgeVB1gSz4E8GyQxLdgbDptsmX8tqOqS+BatCSSx2uznqZ2Dczar6EtMCj3SxkoOM/xpzouuhtCWFSGPF2BWLTe17GNM5yqiPkzeVgo2Cvvns/X3i7kOtz76khkIIORrQ4snjmjuwwR3M3SMk1niFyzyz0G1SS4TcSdTGfyN154pLDHSGhwhNlUuL0eSgAmqegW/Jz6/2TYB83A7EZvHEO3vrQ2HfyX3zzX+CNTKbLpHiKmyB/UwS3Hapsfyc3n6u1edYTQkEJYBrnyV8PA8wRr4ja6FRg0evzGr5iK3IzQFJSuYNFeFMKu172I5UY3OHYG9dX/cIf0nmA9klpCcmf9rWW0n/QeHwHx2RZYrWz89YmiAY8lVK8vkWd3StLJuIQvXq2bMkVhCRVBkuxI5emLmcgOfmbVQm5hVHobb2kptrh7ol+6MOm+BuYA36dkLYpwXAyvHHgxkDy6f172Ks+cGaTi/iQTgLJRKs1oBuaUk054hLZtYMhQvEHNFULKUJ+olUNvJp2pqgaReXM+PMexW2G9zWcxNTOLOj5GaErtknixX8cG48c9kxdwx7Twx3ubuyzXoa3VWXTDvrCb0yf/JWWQgIHRV43ou3AemrCFzz87gZ4qtEboiz/I5D158Wu0HxH9v/9z2Yv02F8e8ZAreyU48ZqPTSuwu0dgFnFZKiQeF6HcM6EYUfWibsB16KTyrqhOn3W5yVSrSEmLB1zm9VPIakG3alkXdhVJpaEi7Kw28CWTNdrwKTY5ymNHOsM1IEexG4ipv7+s9sKDfZvMGmJ8TN21Nmx5yVPKOy7CBvgXmbSt2fsUTXk64iCDjtZhqkEjeP95rDZlG3DGdQKK3NbkCmiIxZVDNwYu1mX5sKoowsyp60Fhko8ypVcLcKXaZueJcFI+abDEaD98pV2wmZkT1qxH+TSGMmPmqPQ20qWr49xMI5Qo098/LAvgLzWqgcNIu3N3d3f98QjF8A4WGxypt/bRpWcgSyrZst9smbW7hcrMZYZ8KeJAG+RUQvwiPrAiRq48xgzFJ9+vc6643xryEfDkS0SPHPNW0wLtX5X2xGQo55ZoPrgOeidprThC06YLuFLo3m7h5Qnwg5t0G9mGi89bw7jEVTO7lRhCJsjN6JS2mKeepC8LMSYi8C2xx7L7yfIu3zonKYJ5sQVSrxHk1+wYKkiSC5dp2tZKPeI0JBUsDlFxOnyFA5Hf6DWxoCUQA2FF7T0lItllFD273AXTA25vNmlzOoewoXhl08jR2INmBWwgswRiu61AcEtUiyznPLMrtjID5m3lows6BrU8Djo4yN3YaxobV6Tmd/BfE07amMR13TVsUcf9sgRfXJAvF+nJT92YApAYvNtNkE4IzfDUH0DEaubUqfgNSC3kmXC38VBPiVXrQB6126HyLkXhWOtTZmSv2V3P/aTnifHrZDklQcwDGiDxOycfzHWLqATnVm6VQ7srcgeiHf6Cq/sx5fUd7egKf4gjoXQbkniGRk0DZYEylokSUtIFEPYflJRpH8VZUsdN0KWZEvI86rKH95LU7V+wvYG7k8kf9HrgGJaGvEKQUy9oq6oG8fXd/Tz0WAeruyeGKrkiLC42qJQO6pkIzfprsa2DT6Mly5XbbU7JML1Da1MFABymQRLEXOC4Cf/dMzCc7o+sOzoX+9enT94tgDnSx+btfaljmlNwGCnSLG95s2rDbDboJKFFGxrWQ7h6zAn1JsPl7D3tRxiEJGtDGItzTggCjuis3GVmM56csYRKmnEFLzjUXzVwit9FSklbLuH/pHrU5vTbeHtF4EPMCV/vUuQTm09+PFM07kOI6uomuFSQYDS2eUPT7h8eoHsdN22W9uJ781ASLGv9IunsmznkDNJ66o5LO5SysZGShJxrygCzW5DxGXeHFIReijV7A3WXgOgZ0zxVZWj+GuV4TkV/F5F2ux0vnzTF+Cc7PFzlDpMnoot48pNV42OgmTyGeEb/QDsQQDlvp7x7CRJV44qefwCwazcDf1O/NCqSrGdX1J62GpWhWHkg4VpvJTxoys2ZUUxz4l1CyNMvLe8DQlUppzD9iUrAJpzXUuoEPw97R4N1X584xfgHO+u1lzlaoKmYDJD9B268coIhL0keNbgRCXYb4o1nwd7rQKuu2UJx5uruLz3uKBQ2Ah3/AFnRyuwiDsim381xJoSRco0lCHt4qvPQNQTadJa33tcaqmJyNiXuMpJi8W//NxJgzMK/dDC/pz0s7BYgQLkjjZwIWJlHhmlYaen+KllynI519MSM9WY4jPALkoronY0H++IzEry8TO+7r0AlQpiTcG7D7wpJly3CCmK4PiRvByaE4dTHRxUU3ntbWo8g3t16ejHQ65sVf31+Dt8TTe/irBhXQVG0stEUZKbE4Twg3mPRpSz7hKLMd2bIwGRnNClIVZcblfkoE8WU3eHEvUmzGANqDhhtbINXXTFmxHAyhsXBCPIrTloOYXgQfjnS6sIt50Ox/wTz024/X4IqDKNMJ+B/EQxA0aIdVqM/CXV6lkGFRUrOIdzHjrHJgzfIsIDxIvEplkaE6DhMOyHdCHkkSGdE1plPCgCqPD4yVlPUyaGntxG0XdXBhe1yvU6QNoRm+M+LVDvfq6+AerttPNzd/HkOrW+23wETaskXB1ulWTapwISbUAKfwjQmsRZnpcalGRp8O/uHn8vlhp8gkJ2ooG3dSo0LC493dE8ZNJC59a+Zwg3LwZGjpylqr8dLgWiovBulLbdVai7x0kZFcF86JEuk9FiGY5kTtUmMUj9IJ5CZG2ZoBM3RQe5Xvw+JLhYD30GIC7v0dHdWfVH6VLCi/hJH3ExrxM3Hs923ChczBzDMCoaFRXMLOcogrynfYSAGehY+ydDZCSqIjSgr8682HvnQeGk/vwbQr1cg6gQoG7gW7lUFdAW80s9oOsvGH5wcpaK23iL1Cw0mvM6gKD/H6MGfg7VJqW5A4DWCjVrz+pD1K8LzSoAEVN88o1LF7YwAJYgdp1DMEXAknBMTyW3DuksjIifqHsyz+Uu6f629FRIskIMzOoU6szUBFhOovS3pyyEqg61ldc73Hp2eof+EoerDzu2HE8ZSZwTk0KKPMK8QMPVfSN5NWoB1kZy4vjdDOwwoQHUSncnM+tsm/SLiRuKmzcxhwws71Yd7QhC1VPDdr0wccC1rVaMBsCELoqOdU61BJOBvy/N0D2CvwEb6cJfkoPLffruhotU0OyscC9faKubdIbZRIBP8JPtoYkNsNJuJ0ueJyjjNdpQJndDpJOs5j6zUqNyuJcXHaT/ceMXdmrNQTcl8E48BuljJJFKsDh5HBn+HtsGD6EvkPBiEON+NJbYFt4SZqIhB5tTJgLvf7hGqDutvUFLm8F/KWJK4rUzUTZo8tmPy0gI6V+W6/Zxd4DwTTAv1RjX7BvlHDeI+Yk3CGrroa9L/RzpUo8dT1rRIQkPPaZD4kEAwjlHAq4kri/QX5hw+zQMH+pIUoPpi4DZFw/RxIXwKQFmxnLHmlXXWYY+6hN8Sx0UveDxyFmjnQJdTyx3ucCY7TcTM+7Uj3z5p6eSHMwQ6bdKuWEArkVlmPVFnF9DinYTBdXEZvMKdUIdrruplDfdPoFoo1OpUyQ/yBKEHDZuY/WtqRyxrgTbfgJjLboAoSlFcRc1C/FoXY2IolL/K7Tc0QaA/I4TzvE1OYQFPHWDyrH/1CmFeoe3YY5vk2bWULXQ/ug63IWttBN6DT1gm61R7GgU7USYvEOq4FZoXPdKmfEdn/MpkudpHaTZt21ZoCwB4XLINq34yWV6H6sCSmKfoAfMatszMAVqPInGvLCX5juCR67N9KabRaI8B8xRPwM2d10l0qhmJnLNgzCtvlrd2gFHNICRU55uOXuNF+RDfHAbJrXgzPXFGhBMe7rIZAcxXo/aKJvZeflsrJ89WCqjYtr9KSAx1pXvQJQyEOayeXd+nsM1oHkQ91i9V8Se1CgFluHX7xjnhLrrnVJoesTaaiNu1qqQ87NHeU8GCEZTD2k9K57gLMr4e+RVRxNh82gy8ltc45sAFLUSynUt3ioo1BjgYSaBGlpTU6ur8zXPX22GitjlV+lg+ph/sCjZ6B5Z9Cr2Nw7xLzqSaY5L+k1eilvlNSgoonYWISVNm7Lo+n79XpjYuw14M9DZRGSwgX3g0dFHbr/iNeOihz7BT9SiBHQkCfciORJEZwMo6Ls7zG8VNz6Nx5npeYnXMb9fnefhHP4sQ997CoN8Ac6LPX3FMDLSHvmNEtxxmABE7wIBiPJq1Wr+OCWi1tigXch+iui75EDRw9UD0Yd+Bnnp8U2suf7e+EFSgg2bRJFxlebz2qwV207LKJ0GDflIfgGMZ1EE+jMsi16S0YyxSmuehbf4UDGrnW6NSYj3bZCHi4bbuglEPeXVN5yZfoRUGnMoJRkxmJpO3GGMZ6kOeoPy3Flh8fnmw7cuilasXRUPVqBntj2BpuVYUhJi4PjYO5Tswd20RlfBBxdRZjG9WZVyKJnopkRFqAj1FrOL5zg5UvlWR/4ECGfCZYBGWqPgHZg9FchL2PDU7nJncgH2oBuDkti1PPsOWiBFe70aZyvCc/PMf1KoMyGmDbb3OY9Nvl/tFeFcolQVIklg8jKeeEL2TEeQ09t4unnnVXxPiAqahAqDsB4qK6YcOHo6HCvTqMn+xAm8VjpG5NaQlfmZLQQfmooNDODSEmrVEWkpHUHvd263TM8+X29Jx3ysd31IM2UuKmsgJdn9IS2wIhhoL3qLVct7OE5AdRHqvjXj3AHCeU1/C4sh7hGUakSPHkAt3dh+Iwl6OQ21zeEjA1An6KG0fNZAcwZKbkRjEWon+qiGWMxqs3wXx/B+cRy5MjvghUwsH+59ycH9cCYoyFmqFEsx6RqS0x5SUD2WFv7vowtrJAHH1gnpDlqPPCtJ8PtBDYPCSDJszmQnGGxWYDlEwhPq5nhbNw6hMpaM+Ie/pwXObeNeLfKCcKNnCfYemxhs825ONCsFGj1sMEsIsMbsSct0ioW1ioMWhVGG4Glx36RMeshiqgOC8s1sVBeGFLllVipTysBXL5QX8PFSnWFuTSdaAklNkePNTi91RG4joAPavh8piHgwpeWgPTaoAXAs3JNA9dIuJbHkGvWNBON9h8uRi3WIGG8BTyPe9HBzyxyMmz5opxJna455IntJuk5FhpS/LSimAd3oGzkiB8YhK21VvBhYcYwyyevW5nI0l85y0wh9kPv808UfoAoSO37T65PrnhK0zu8vEwoAWTV1kRoQWY015bYmY9OP+mx2g0Yj7hadYOzj8+kA8Grqh091aAttnOQ/u1YB/k2jw9jog4GH531lOXjbLvJsd9x0T2Uf1N/PkxizavUJFbS9KEBrnVocgPMouBDa8FiWHORunjsBqeeBDAnbh5OMOJDmUaE7PaLAutVS2oKsQrxIi5yfq1mFeBfWHaC9v7YH9zBq7oyF3vSTu7q3rC3t8zV4TtPAOugl6owlqwgrtEoF2ZJpdvP+FfDPFPBDPqjXG2MF4DqTZZFEDJFTuIrdGC36gZI7aNrebCuJZEB0pdEqWVEvMtA9pJYymxuvc2qGKsGe7g2vzGr78Pfq6XcA8c9vjkGnELypuC1sadU2U5+yxJ42HLDw+jiMpic6waAPrDDh4QQg8rwyoR+PAJ9T3huWWuT35bmuOuL5b7cI6JLDFnW7Zi7Uc9dyeKz4D9Yv6Sl1j7i+K7x/wl9jIt6ZYiNKD35ekZZOhRp5dUjzI4MwI1QCAGIx5ZhchcPe59XYQ8srtYdLEsD+oMl6+UBdYnkx9MpwB+t0UMXpntz5GfHh6eOHoAZjEQyDeXOBz3zTDXB962tgXtuPkS7FFpPD09qcvt5tbWiErkdaojwhHYBWrTanGFh1EWYAA0/pI48tUVnoMAeIv0lWD6hYI3lKZViJd7vOP5+0OYk6QBBf7Y+OEFv33U4pth/uU1ev6JW7cM2iYeQE6yQih/Eupcv3u+kwiMcF6nEVRrhjxjisNVh8TOJex/YpOaJZ9nkEMiCgHW9emRZuJwIoF64HcLBcx9ZixwmATTZ/I7D1psz2eixyasuEnBgcbiK3ZVnIa58ale/OOef4OOdWtQ/hDqtwpt05xg6XPjQqo34XHqUjEowWFGpOJu2BZWj3yVNgAgHCOapmL2BNVJcgGkOWhhhEYugtyHNqGWlQfiNja496s1x6baqpwgUvSTrsLdiH96Ksv5mH/5xXHfv/+pndOuoX5sZwUMPJQp5qBuYRZXG4Nx84W6Ki6WQUJE0/8FuHBwHFioUKFEulTHOG6SsJTRSOLHxTWd7A8MG3hO2WLXt2nPHEcgMUOluSLhQ1impxT24Npz1NwbYT78xnFff5yOOTb5RCGqOmuATi5HXRYD0wbeTB4GsVAFtgBSBzFGSDT51hrHMPNzijkxdZw7bDDbnheh6UJl//PrxCUU2bly9fUKmk/uwu22AV3Ey92wzK8Sze7LOOWf5LXS/LJ++3zMT9pnAR2BlV1GhqMi4oGUCzyE5Lsd2M03XnQwD21huz3J7VXWwQVIQ/7fodY8xi8qLdNN4HSPVc0NJ9t2fP8eJ7IOqs14WoTGfS+J2DqjD3C2A2Gb/OpdYX6mb8EN+C/wmLgOPMoE2wBFql93eDyrozUZ1lCzywTxFE5QJEkoGn4mWgswen5FC6eQs6zV8X+4L84LJ5J4rGkdMrHCKJ4GLMIxT+8Fc+P2rBia0+SXRMdyfDpLnRfDgAn3vDFcd0CpFSWUsFZuhC7MqTXAW/OBv8eZZJDBzmtiQNVhQrk7UBQ7H9vIHhqD1k56kjrP+7V3hfm5XLGx7UYSy05M1O8OlwvCB0V2ODOdGMmK+sZS9SN4M2NVnICe4hbH4YWShnQYvxpgDuU88X+CUt6avEOtobHtvIvJKY7pAAAMI0lEQVRhyUPve857wPwieehAk4UkTTMKaLluZ1jHAnSRnS4EPW6ZxOIh9Vyo7FEJTjCns1V7k8UcT/zAsyrFJ1C0+tX4eIbk6my2zbuq3T9sPirmSR2YglJ0JWkBSjRx2DyFmu9gxWwL8yHP86G/GUN1Zy1Jvu8uiCeqIaMuUt5CMNdNRbYPKeY7B94KsG1jeN2YN6uD37Mwx2LCk9Eronziridg6yIquz2kJqKfUdF1+LzkFnutbljMgJYrkQldfBgb6+PxTw2ISiAA7Fn+7klmNsmbMuMrwryxo0039hLGnXjKGqCLq/EctzNIqjTmw2ZEVFvWnAGpk7Sudajz5Wnw7BSBikvBvSBK4+iwIB0u5At2Dir9VnHH+XmX4UfXg3k5nKOSIIz7/uCKXTFiEruCxQU4zZYk2y47lpz2DW1iRxsUF+qyIElsVgiGWHiVgu+vxLBVNyO56xgRzLdls7zlz0tVmq3V5v6uG2kthsbVYI4bxfO7du7tC6Dk4UGwPdGWlSz4Ftz9KvXYjOFlEdgJSeJV9Btu5A8yDCjiw0cYBYjDYaeUBeM+ogwHZ3dts9hI9PnL648x18JTPGImVd7H0cv05BTagYLXCjty0Z7BVeA52cDaRfA0/lyKfICKhzJRS+yh2D4Uw2YMvxXsFdDjfqvM6ZVyFLGnwqG97leHOdc0zeZxb1XS8NQIheJgss38MCku0yI8RYKtWq0CHG3IzmWtGewQUHA04mgeb/oZYagNnD86okfY2pLzINHNmRrhpO3YpEDOERStfB5GeeedYX6C/GWa7WzYsJyb0QoaYj6EgR1o6jy2xM2JA0E+NxH5iTtaSyRKDvmoX24kAZ1Rh6KoSlJrCS3p0v9IFDFBTgOn4ilyH9tn4DBWeoZRrjIwYBj0yX57IMvlK8Ucj60xg4FCnFOmu9sMn/XZczR+QprfHY54XiUPboL8B7SXqPiOLfmtLnKXQhH7XPgFzL8xWdMWzNiWcez5AL2fEDvW7OTGP23ftM3rwByPZwpP9jCIb6GaevPxOy3/GsM1j/WCHuoB0CGlRpuIcPsW/KJRr2FDOu/OsU0XGzYyD5o2U4RmQ8Fzj/JKMOepTPsk85H2cHIPmnC9mOt2fEiOw2atJopIQAALVDehoh9jJEvaXtQtgo4lilKL6rq0Kd3FL/eEnuoGjiHxkLjgqCc8F7QKbNbBcjQciHZyK/9UkL1r9eeJYVCGpdDZiUELZ1wQoQV/QtLXFFcs8tPj3vFyUPVLCniLmBF/sqbEcnB8Tj4/0zTTg3c0Bn0O7B/3LeYMqinbrwvj38c8VnOOsfZ2O56xOhUqQgVRD7KVDesxoTn9MsiBwJLpKdjM8t0VZvzBNunVum5UFWxKLGnhABy9T3sOYPql107uHYV9fNMPhXljT/qRawYt9zux1euXrXYl57Tvn1n7Icw3yEij8aIHnfw4eSyoyru0oIc7wru078WFnDboGWp4jd1PkxWqielE3M4+vqvHPHAX+eosELGndKDefnkVpkUpgq1kn+5Y4mn0WkvoC8faKDbJBS3HbtBUhDdGoVdw5z3IcPHAilx5JijbSg9EDjMvKHLsYpCPI+Q+FOZBzbkdDcixcMz7gapdmY7dh7YuSsCLXYOKArQc6krR9vBNrE+cxkXPqsKGf3bE9p6jB/rQlx1N2qXGP/h7kF/Gn9NkkG1gCYlxpX+AMuDkfbmiPd0vapAs3fOSX1iPCTekype4CluOW/MxzJtwoX0wh1NHcOy8hT1D7Hj5BvfO1yV5S1WTgz2Cwd65/QvHkOklPOGMpIrPtL1FmreKC1TAwtQRRhr6qiri7CA6XQer3tSKiZ3DiRQkek6NfxVz49gyI2wRYLnKgPzzWQz2i4Jl87EtO1B09lc0cIIXlyv5khCd1uBUPKc0daxk9/U/hTlKLEcdQNwOtu3iSJYnVYSyZ6xalp9ZWLrGEbXYtrsqmbJtzqaabA8aCZYiwGEsUY3oyCHUHwZzkD2O0k9zlsBkJJOe6tF8VuPHAs1woHbDtqejFk7SGeIRoDncUJaQNas059dY7qi35b9IxC+EeVB9Oegz5BNVGZPwGzgmLqw+wYQXulcPBsphr+e6QM9K9FBASdxJJNvBQymZRtL8/RDqq8McwHlB6JxpRxRGtyWChhMXBAZwVtQA5mIYSig2GXQiRpNrmEri7aeyosBNoTDOWPqAmO9RS5I08DziltPCAgM9K6oEB4FUNS0Y4m0RhiLsuZwwH2fanFUGMsuEyziEmmoBA/1j2LmgnG7Jx8gH5QGtWPeVmJLahGksoJ9UnHI1dygYo6/Zre20Nc1+15j/+PTpc+2YC9OovKBHO38gO1OFEMQSxeOcppPQTzQ2DWfXBmzhgAnoePGm4YTeC85nORPzLwb348cf50Tx4SGnLhN7mqnvohlnyW7nAv2ETcM56QWJNyprGpsc7Z38/LfwLdCB/keYY6bzez45M/cqfFU8g8whGY9HZ67mBXaKC+on0NtcGpQT4SLfb770cWbtBlUj4N5kwwjfGeafv9KvZ5+t4MSGK750M2T3HeNSlRWhqnNOFRrWIeMs5xKpDohmVQ02BoVsFQ9offnNcJwGBGgvGLr5HjD/9QnWF477/vmPcyK2D/A3MCTao+PXSzG4poAtcEbZnDlwYtws/jSYeib0I7bKBua+aAYzu0m3R+dsc8C9Mzv/elN8hdz/iDXdGUkXZLACJDho23qe7QwyEpeqDXYesVUneVrD4bD/ck7x92Lop/+4t8Gca0zze4m/2cSTnIidNzWlCpptfF9tSdOsvFedmbOIysNGuWPesVn19HeI+afbm5szYyibw/oaC05XqOTxQIYGVxbsCNGc14fjbKEFslwZvGvl9g00rmDe8KvcAjZ2YJk7hQhIxTyOnoUYr7x6Ztv5pzCniUtFySove0u9cuIQtaaw/YpsSkhiQD1VtJTZv4Q5+fuhrgttyC9jDpvnTpNhjC1vpU9lFgZpSTQMAtr+xvcPi3mVGnj+4KyUl9nhKcmWqQntfRJyng5s+XcwJwZOe+N+F0I9wjT+KB0pB+6rwjbcRqBPj76Bml7j+jHXZ2b8NFWnf/Bvmv7hnxvsopge2DqRG/y+INjX5L/WIHCp2hzMZepf6DPnbdnOQ2RV9m50zwna79/6b3ZyXQrzy4WzYKc1Hkq3z30Pjnnripb9/Wm9V4Z56VJbpuCMoaBjSd7rpGCWBWVOufLBzdCEsPa568bcaG670MF2fHulVQnms/TlQxd1YNO2YGhSbH9c3jLb3SV6odUOOszxAJHfZAzHCPjXinm4a+Lyy2bHZx8Taz+0neM+qbf5wGEbc27wW65H/Ln+YTGH/YClN/rEjb4TMMIryDnfkrectgYC29jrzKwj6URiCpXTNisp5qclUGHldKYcq38149We8GiYFPNjV9TXaL08+zBh6Ha0UeyPZbN/0LdUNZaID6KjhIKjbY4LrILppJifGBgDeEt9BrkejHc+7k5p5rkU8z/2NzvTnRq23eA+wnq3mOvbO1R0aF8xUswvubaPtskrBzeYpphfarXf+dasj4i5Pp3qKebpel3Mv9/+9z4wzzf30vQ9R2VcO+bdX+8Ecyis7kvrZ5ps6h8L88+dd4L5oYnqcvbvNZBfBvMvP7h3gnn/QGEVjsrIfwzMWc//TS3E/Ox9Fq+0ynhQ367PwaMyPpCdd25hdVPe8sZc8b3wlhTzdKU5UYp5ulLMU8zTlWL+rjG/vdm/Dj3+4jrrSW/4Vpf/fLcXv2Cvc9PcfMTPl2KeYp5ivn99fbMnveFbveHnS1e60nVwxcumR67kfLWjVvww06NX99c5z+KMm88nP6f2GecMvc1KlE2PBTAxX+0oGOIH3x//2Qpc7fRncd+/nY75t69c8c3O3E2UTY9fsflqR12l+OHUp32+L6db0ZeTMa+9ZSEtWTY9AYqvJ1+irz/OeJ/67cnW97lwOuaFm2833y5u57tl0+OflJyvdknMazcnH3775Rt3Bua3hVPd5dlrq2x6NJeNz1e7oG8p/jr9OT/gL/p24pO6xLecfqXOX2fE0E+nPiVx8P0Jke080zsDvV8d7vuP94x5cr7a5bjil9tPNzdf3gTzws2nz/9x6UpXutKVrnSlK10fdP0fSuDPcv6FdbcAAAAASUVORK5CYIIA" alt="" />

可以看到数据有些混杂，我们现在用基于决策树的Adaboost来做分类拟合。

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=200, learning_rate=0.8)
bdt.fit(X, y)

这里我们选择了SAMME算法，最多200个弱分类器，步长0.8，在实际运用中你可能需要通过交叉验证调参而选择最好的参数。拟合完了后，我们用网格图来看看它拟合的区域。并把拟合的区域用轮廓绘制出来。

x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                     np.arange(y_min, y_max, 0.02))

Z = bdt.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
cs = plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
plt.scatter(X[:, 0], X[:, 1], marker='o', c=y)
plt.show()

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAWsAAADyCAMAAAC8hhR1AAAAAXNSR0IArs4c6QAAAQVQTFRF/////ecp/ekzrVYv/egtSQhYTQ5cRABU/eckMjIyqFhGsVgo/ecmp1Q7/v78RgRWr2RNqlU3rF1F/epD/e9w//3s//70+Pj5Vhpk/fGEYSlt/e5ecD98SAZSqlhA//vZ/exQ//nE/vOT//rPIyMj/vas8+/ztJm67ejuv6jE5erk/vWg//e4r1gqkmqby7jP5t7n1sfZ+eIl7tMo//zip4iufVCHiFyS4NXhnXmlTQxQtnFW3bwumXJ3cjdJuH1po3Y81c7JjVlD6ufcuY87xr63XB5OyJpySkpKsainzKQ35NhYW1tb3MVlcW1vmZmZhoaGhUZRDAwL39Cc79o9QEBApWJAwBoBVgAAIABJREFUeNrtnXdD2loUwJN4E1BiIiZsKEtWoSzZWlfdzw7bvvf9P8q7M4swIqjQ5v6joiD8cnLu2Zfj/OUvf/nLX/7yl782av3cfb119Jovvpnr5zzWu694HQ/3P/5torvrs/ZZ+6x91j5rn7XP2mfts/ZZ+6xfj/WPo92nmM/6LVh/PIpxT9991m/Duqrc32wB61az2dl2HfL958+nLdDXQymgiv3tZl39txq7f8DQd3ePNpZ1RwrAJVa3mvUDFOrv3zZerpsIdUCqbDXry+3YG8cqZl3zbb7XZz0SMeuy78u8wd5YESVJavl+45vYfNVabbuk2vfRfdY+a5+1z9pn7bP2WfusfdY+a5+1z9pn7bP2WfusfdY+a5+1z9pn7bP2WfusfdY+a5/13846VhnXYtvHuvx0dHSzZazbcTEgJatbx/rpOxcrbxdrJY4Kc9ThtrEuH22fDqkESHXftrG+3H3afdoyuU5vK+ufl9y3H+i7ja4Jtq0kYT3YNtYfId+b++2S6z4upFRXLTkr11qxN2XN/Tvifqy//joaeUXWsTRqMli1kLL26tWYUzgvd3fvq2tmHUnxfC77ejaf0mr2F1l8sXE8Pi5zSm0wcAXafv0q47fwZRSNDwaDQuR9/MbOID7ocEoashSTykCCQJsuf/YG1fNvwToPIOogqL8L6xaSV7HTwg02Up/02YxcWOP9VaxAvV3dYtYlzDqoL806VhtXPG5T7aEU7yuWB6rNeBI9QIyUdF8lXw2iU+JPrkK7OhDFZGdrWReJXJeWZV2NSwEp7km6qnHIUrJ4juU40hkDTiH2oFgjcj0QZ2qKIdIuYy6JLorU3lbWXArC5rXosqwH6OOqnszlsUik0vQlmbKQCOwkuhiBOO2zqaWl9NQO2Ro2O0y8x1vLWiloQiKytB2CeQTU5XRHq2q6jhaTbRigAjymsKW0KKZHXA0adhI2yLEi6QzT43ZtMDSeSOT/dfyiTYypEtbiMu5HWpREZFU0VceeRwRdggZIU6S9kOUy106LarISo45mstMS1YCoilh5kEUEX6z8LayHWOyWCdth9Ys6SttYHJNUNtPJ8Qg9oCZNCyPQh3suViRSOcCWaH5HtocOvgxqvPy3sC4nJVFKLvFxy4QVIlox1SzSGmK8lYQ6AwFUiAuP9AtREGIlHphaZLskl0xsvo7Vt5F5GaXVbynLWB+EdRxJOJHOMntQ7HPVMrlw5Oe0wgIngXFFmmbdsmyxI+7vYb30MpMERAVLkBLxWgJp+idUXasjw4aWarG+6GQtxly3WJ+1aaZJakAVx1WrXGNNbWRpRlSE1XGsyrWT2FFPq+ogSXwbFe6taaZ+lCF5UGz7rF3WaAhpi2KL6+D9FAc6MEaiB6ppQ4Ch+hYh2Hi8SXZNHP+QmpVKlRCGl4nae+JrBcK3PY9O/cFYuZJUpbFCAUt4q6s2LapCpbpiRJS11EJOPPrLNFU/HXpvBIYxn7W71UdADaHImoyqIwW76eq0vaE2mywkolSJTxNnRl+aQfdZz2EtilbHOtbCCZbpDRB7hFSuO32J/l5l5jy7R3zWDGRTUtPMKCtbtURAUsgfqHDHa7HL4LQ3mm0s7mrSeKZYS6piM1ZLxuNiQDSNEKVV6fzdrImrSJyNWNImumoMP0Z+GFO/nV0HZlJL4nhoF3joCpVjHI5si5b8TjUOPap07C9mTeMVY2ugyNj40KM1ClLsj61AHypJuAsSi6NldWVEop9j1FLsDAc14kalVeISodun0qzE/j7Wtjhc0wRmONpDQ8qt0ju50iIcdznBP5zhv85McEB73OZinY4yohEqFIdKK6b/j3zStvd4+p8m160BUyFSpaMydTB009IXwWBQbnBfL66vMpB1Bj3U7R5fibVyO9aSJCnedMZGLP5/2ns8fcNYh/YPFG9PwXtVmulrFpiGvkfHJFMRA58PptfevsvaQ785kSxqnd4L2OdMBqh3pKhLx3g3lPXNh5A3yS4nofylYx1oDidHTO5UVcXBvBiNjMBHxb3Q9NoJT6MOf8K/+Ty1g6pNVATRklDxK4pfqWsqYXs31p61yICYwRJOh7MkF3byYtDyUyEQVWpDm1ra35lMJtfHeCVH1erg9vS4izKePE4xk+/R6h6fTvZsrIneFztpCX5b6zdJUffQ9P9nL0V5AWtl934TWbM7mZgSHRY7QgQG9Hs1WcGsw4HMBaWpyTwvy5QuH3Sux4CDdT8uSWKlgu+ZuGKNp6fnxtPbA1UdVD2z/vH0VqzDN5eXS+/uMZu1zGwMFGJqmwZH/PPnwef9sPgYdFk5YeqhMwfrQBP6nGXTWa9WKtVlvBqc8FHjMY+s2//evBHrA6Qu95bONqVJdsoW4McWg2kuq0RVf7gALqg1fkqu+WunDqlwljD2qIIig8tUQlHvvuaR9dPlW7H+cnJw8Cm8tB5po70qXrNYzVIfC5Ip19J+CJkWp25SHZSnH0qARztrWs5H0CXJCy8zjJi4TWrfG+uHb6wk+JXrr5ke+Ribsab2mnK/WSlztbgZyKAxfayvUS1CfD/cDXpYhWjjYOezZK4BYa0MRVEVW6RWiuXUq5XZgy6pXLe8sf52dGQOG999fdah8Ky1N0P7KUxnGJn22DCgHuDnhMJeUAcFhTuxvYE9Ev+ojuMo30P2XHEgBZItPMB1pj6JkYSP4tnmeysdgtbl4awVCn+Z8Rzqt4hjdjFaogq1xwe0Hj2xBg3uC/xXH9gKffpcwdrKavOQkGttvj6pDiVpuGjreRfW0XpKzy7ULrNYU3vXtAySAWzoobBH1xvrehFXYw0zGQx379NndK8MrSaPSL1/dfUanffwZaIaH5ShTHllzXoBoe+ixk3diKJEjPX1UoyZQcLzAq/DGz9xen0xIaxRYY+tooGFtbaUdYopS0+sy6hYt5KWkrWmKMbvgJAgL9AemawDZ0ux1nRMW0amCUhwXA65PbeYNZTgss2uFInGSourZ9jfgXWRWF+g6I21kRJH7nhg8hgEKRT3S2IYjPXzbMByHRjy3NAALwNihQOFXPzjM8I6MKC9TswzxUmETnP1gz/egXWCfuCeJ9YdR60SlGCQpSF+U4fM3huBzvUKzHPkc416SaffR0mBOJ+jrMUqyhRDf58W8fTjKip+7zTHK9ZDvQNr+hk1b/q65mB9C7VQw3gUsr6dTFgYxG3pilIXDM+R1/KAOjcCuvy8DHeQDGXd5totiJWwDqTXVkf5DqxJ+4ycXWR579nXAb6zB3vu61M4+Ph4zOzm6ShTAu7INjE3giO5nJYi2oTKdaDPtcfNGq25DKhJZXtZczoIynxpUXzb4dqEwjgvfhKa4f1YLBA5L4AgsIU/5HrWHiPh5Wnf/YqyhsY0Cl1LtrJKaENXt5A1l08Usl6fcxh+iEvD/knoLJCB5jDUF3qU4yrUFL42rDisnkp13SHbKWGxedKlrCVHYQlOJLfTK/csvWOuYInV07UcugGUhk70dwexDmDXY1LhjK0x8B/F1UvgXko+J8gLI0/T68CVNQ7fKbRM/s9jndf1BtSSESSc0ABWciB4+OkcrUPE2qjrMIyTa7bfKiD48sVYO7bhYZUFblcz+jaSdQHaCNBG4wpYD/AR1CB5QjOHn24NeTMrfgMX1DkXCvwKrA8J646j70BMxjiSqgk0t5G1ki9N+TLRRgmHJ3qkHzLPHMw8/vp4fQfX861ZmcfR+l+rvyjLK7Cm+royijM1EmdJgI60egv1KqyVBJBT2Rf924gGAEjZOx6LAgA8aqSuE6MwwekYHMjqpqOJ/MQkssZU1EPAtZOQSmaSuQ6uYxk2X6xFfceByHZH0s9uxnmrrdFbstYRE9B7UUiEp6EIetUgdUVgQElPNa9HsJ3Gp6hFril4NEa7jfr5k0Mamui02rWHX7p1G5RX1CGtcb+N23jVOE0CoG24n0RzGtgbRq6lVy9nBdbkVucTL9EgvOGykfsD+nENgUozF6WBClCChjKfiiDFDYCQjeg8/Lupt5FFu2i3211drsnemESRj4rShyZmm5gf0y14pNJy+Gas88RkTXmJppJ4MRe1sSb3R8GcEIB8EUy7p/SwnlF6pYe4ePZohKyyei7RixRSej4Hr0IeqtPJ2X8r0ZZ5xPru9qxvO/K0OlDV9HR0L25paNpIuVYSNF7McTkZawmiu0mAkzjKJKytkKAnHYPR0GThHBGYoKytnMtyKJjBg+Pr62NsOIMs5vO8CmxNA5D1L+PIU2MXjLkBlYxWqDfS1ymP+hrveURJZwWULiD7apbcH1odWXqalkO0qbWHWTfg07oTq7mh49DGRWYyyVw9QsA8yYXPCz0tztEU66mDTze0Wm2RxUFSkcnNtUM0Fi9GaoKHkilkLQpF57IJ7FmDAuRPhBz/HkXyj0mSamJxAk8ztNz3lP02MDuiakY/cvRb4HR6oC5ErFnEadCfJ7SogEL12lnzlvY1YPFiChDqDc74PpgzxBlEEsQmKeBfo++7k+cd4suEWTDvIsNqq7sXamBBtlEz8gR58t94XXPA5hHrz+Ok4cHEy7FWZ1aMrzpON12TNKP+zNFTb8k6ZcatFZqbMWCSa0A4CDmiQeiuix+82Avh9Ppe6JHK6RWDknmk3145SxLcwiENJQGNQpSV4e3hKL5Ygfa1aMZC1AEqOfFoRTdFVZxV2vCWrLMAKen8lNFnsibOC4uGUn1OrOvD8CBeU3LnmDWvAcGIiwTuSEFB5jR4enFx7BY3tSy4BRR1t6gf35CQL+Ps04t7sjXoqJfy+/voWV1LJRIlxbTzSFKMZ/qEJKOoxYe2xmgU2s95pGMPw195oRQlrIVIL28IoFoeMV2SgevaEGLevf6mmHN3dr6K1G+0R/maXrrTm/M21jeOhxThlgTQNKJoCjD7j4vmAA8EbM80BCDLTJHy9RyqKgCgzmPWyFg4D92hWX/R4hfRDC+TeW+Ta6zBM78S8+JPoDQrEnhK8jLTDai064zroCT+Glm3/z06+v56rLEpwmNx7uVNazFfbxDskYI18MyoACzXg8m1rJ+HHqBDn4AXiob4bq8jtEdm8kxYj2P6HC+dz81MFUzc5Jo1zXCk5V2qrE+HfLzkykeXr8WauD9BLZoQtELU5fcCcLXUBPliLzyAkgv19R021B9JvC9zjOpMqL6+oiKpXnVn5wn0mQHu7i1mbdZGmLAxu7SlYXVte+P9q811Jy5iUEOGBshNv+uUieX4xLb2dlC+8TZ5EvpwAH88IBnd59vT419fvoySt5PA5OqUUcpczTb+oo5t8fj4+PQR93tcY7lWO6MmjqgmkybrkcUvX5B1HPUrHmy+0RG+jOuoCVaKjZ7tR8EiW8AII0HDoBAxLXASB3K2F+2jzy6efwq5r71r0DA60DPHsypTo5wlnQ49p2vb6+18xs2/5f6gObL0WKuKKdfiy5tKp1mXdx/Wpa97GrRiE9YANS0TCJpqGwp7DhsfWcP6I/HNnTvrOj+nH/3z+fk5+hGvE6Opbiect6R6Myhw4hL5Q1aksXOiHxoHIWtr3okaEJND6g6aFSmkS7glrji5bwpn7P7H2uwQbFwZRZLm3StYB1EqVNBQFUNCtsj1J/vaiwfg3vd555PrCn3Ab56xhpi7V07Wcq7Okpj4x6/jdszoK1AtTY41GqOWVElMinGmfmtxkY4oWRPrp29rs/noTpijP5rGVooYG+QqNAxro0eSXVSP2npBDw8/hQdnj2eZk1B4b+/w4JDW55jrq1LSE8WBkVbvnk2zBkD7Mh4+6IaRF4hT1qrYtCR0VTTVCDWwjyt2i6K8UlmOE+fNz91dQ4msyDprZ103bt58NkfpGg+fmhXn7isU/nV6ejohNQu/lb4kSn0lqhgvq+PI4S/S6SKgcMmtjTVpa3yciAHpmV7dE/SymLXUH+FEjCUWgtuC1ztX9TV9GcUaQcqWqFwDocSEGWvsPJbxw9D+grUXn0xunzHrCRSGWDWW13iQiOas/jgYDcQ4NLBxuOTa7Bp9zuDYd/DWEqPqhj6hl02S8WfWfjKklkWjfXIrWEOiPPESOUUHaEEYKZSyYvoE7ptQxA9wCdk/ggDIEhLgVjSWJEn4K1HEC2rMhDwLoTxOAoGr0y4y6iB4qOmRaXJKwuD4IhyEQwfwZVU05ILYX1aPkVaYJeHDg3i6tcGsizkhhz51MZWqR400Aa+lUiXFosqhwo4IweNQGN7MB0Lq9Ors4jjI6z1OD8xYmc97s1SMrai7DoTnCaqd+ZXMZG6vcZ6hC21oEoeVrrvd49DOh3NbeMk224Um0AfEExT7VJmsNIf8VVjjyBwEWQAC0HpmmoCns4KL+UgCy7iCLsJp6ATe0BdxCYLI3B4jWtXAnJVxqVAQ9glrTeEaGsgVuUijiGYsK5b5WreZzNmtSloFMpNM6AB3aJhhU+Lpq/gZYofM3+mww2tEPG8A1fSNNos1UaEaRi7DrVGhaS4QoVa3DKU3pxUULnZ3fX0CWfPPIhNcrl3lRvNYB1yKQShraKRj7QTFO5vihYLScpSLSajfHDuAmHW6baYDRrTFboQGyVW42FAUUVOOZAb8BrhpRqpuFGuijOUUdRlw8M4sb6chTf4U3vok2XLC/zKidvG4KIpzUQfOZDfWAnSbFLofB3NYSQG96RwZl25WRlhZQNZ4ikJ1KMVR915FzAToCId2ByuVGIaanJrw198o1hpNr5AvZB9Eie+ixeqmpscecgp/p0wfzRHSVF1m7E2AG+t8I2JGXATiHR5PXzUpWcazdSBrrICRyhAHtGkyc3bj/Cy1qTm3zY1iTe7jAqn4oKkmnoY8uCJzHw/3/4FGR0//7zbeNwpOHWxVyUXGpd9d+yAQzJramdSmJ9f5wuXZ0MtGw92TmHU7rVqnUQaupqtd+m4lwhtkh9QFHprVUQ0EZZl6MAKLNBlVu5A1vCLE+5DYHuYsEXUdZyhdHB8/Xl24sebwBZY1oqiM/K8jGh3rjDqhgxEJcWB+VHz/c+niibXTor1odbPsayWCdpxoPZUyPHDjvIISpt99DIf/Me9yW13ogpWkKV1jvA2UY4O1kgBmmoHY0/Aynj1bFlJbn5+hdd1nV1bqkLFlk1PXyqJYP0nmzalSvFnmNoy1sXSj5Y2Ur2MtkgIyfxAK7f/GMQmbzlgCdYBeDxLv6F5BA/rRkGtUAWhJEFzhk0/EK7co7AHryYWyiqJ4qI9MmFlZVE5DC2a41njIulmTPUrWdGpPY8EWZCF1uHP+FZnVAe+LThubIK8Qu4Tw2/1wxLbxBonuAr+urk7Bw17IzDrQaOzJSZL15Abw9KDyw/VvfV4R16i2YnTkJax79frShWXkwws9S3aA7JxYWwePb1/AWoSaBp2eMUEz9ohGft4P43q0hK1gQQaklBsc7HxF2iQTb9WwK8KGiksem8xjtcroTVnXUcyitOw/aEDfUcia8Q9mEWLWFtRLaA+RWbiSKg3baNaYeHZFWJ/t73y9hOvrKVxds+SDFlJB1qfIbaTtqcYkHXEqvlTtD2eP8+yg0MzL9Yh31rTUbmnJjuaLijWuxxFN+gGx7j4bqOMLUceTtkY4pdYc9yWWYLQO5Ts0WOsFUtwDWaMgFIi62My2pPcIDzqa4RmSM5Tf0uYr8C6n1jkN7JyWiPQSekmJJHDhKcnJkEImzWQdNNT1DNRW23ZgHwrc4syBqpPTO1Mhh8NG6VSuaOgQ0pJOxNN20WwVkGl21oFbKV/HfurEZrBGZhcv4IAqKzwtCoIAFU9R13RcvcEf7p/f3l78xzwYd7dc7FhEkGoQlkBBH5l6IJOL62Oauc3JYD8clHVW+4p6hEHiYOcXAKz0p223KyWLBo6xEZPI24l33p31Yh0SMeuOeJ7F95R8I8oZDfegcbgPZWiSYQc3uBsccXQEVdKOfySaBTLGmPyzLitK03EYCmiszjev63nuYOdSybJ6lKHt0qnWIuoYHctKDyl1KO6Y0TzzZntjAfD8XLHOOysTDZ/RrBdIfNhPT0Xmp/ZHHN5spm1aO25puUPzHi22Nm4ASeGQH2+pP+YQa/PtkRdQ6cTxpE0545cTx2P3owfxiNX0m/qN2cL8dvKsMzbEboKoKfCyjTXJ9alpd6/REiMRTQWOQTDPj8g1amzitH3LMDMtO82avgJJAjhKEKpkQC4ty5uS4Gp/3Hq5O/M68WueOW7YiWOF1LYGZitrtY0UryqNZgVTjShrOm3ujQMpaeRjafENNOAVwlo+vbg4hV+E6BRramdi2SXJ21hlOKbiTcZ50o7oNZ/p8yqsIykeCHU050dI0K45qxdJ7WsTGxTRVjrZrKQXGdvqYMZvbmmhU05JYX0t/zcJZFD/DKmLsLEmAakz83gldA6qaDNHlPSsI5A30EeP9BROwVV7elbn5RxJA/aMQRMylOtvht0cT6MPOlwcd5rp8NxenVLvBSA7hAadoLTD7TKGWP9KAaFAbn/9OTOZ3D4ayVt6ZJit0ShWSQ/WfirYFM6bo6Mf64mH0OOjc2a3mFmr+9iF9nXGcjZMrTIWA6usyQWZUBbErIndPrkOgoe4KvWpfZ2gV/z0+hGURMOAW64ocv2slaNRbHeFmuBI0Sj1LVitvoSZG8Osrw73v97akgLqSqgDz6e4bE2XCesMYc0/Yq18iFkHQSRW67eUXiKnF+ns8paR5hLLb80aDZ388eOlrBUdujB0bh5t4ae9bXh7FCw1/HhvFFeTZcsiRl+il6c6hJS9H/Okq2aPsBYu4+YpnDh5S4wZHBZJc2/N+uGJ475/eylrHKdntncEGJYIjYToxtZ4RVgH1DWhznRpxR6vkZQ6ajQVr+XgxMqaJ2fGsD2v3CZSoQxESUpW35H1C+qvqU3H8khoSIVWRJFrWYiwWgViLkgBm329RGZg/jJr93joy6B/cnx9/QWgye0ma6DPOuVhVOtwHLdVOiRq7VpE7ItZdGC3AHB3r4bjIPVGKldSHKzpRF4PuRlrSky0skapR9JkVkdB80d8Yg+0QzQZJGJW1pFihHvbtd69UZszeSFrzlFAMQkrazGpWjMBXtM0aGc8trJGTWbI6EBv5/FMTFagfd2uKuzcqSFJS/5+vIu9K2vuYRWbD8WWWEv/jChJisbaZusQr3ItGuWQ5K5CqcceFtoiCjXmosi+/iyhU6XxaVN4byyA68lkInXelfVqvgyKmWYj9YLLXFoygYVunPnc4f7n9WyLdPz67dWjhTWzQAs6LtY8QFXWKKIXq4zJmTEC8Xak2FaxjhZ7zqwXL7OwvC2BgGZW5LD5XQQoV1CoSaujVsd0hnLmlNjyVtZsHZKKdosUy/9lXvPI6NdhXYeqMReZll/nrCDoQKRYhTAqroSshXLag0qemejtj5AflHmG1o7sZK2UdOi2cKRTwxojzV2tWMT0DqzzZJyxVawFyx5o2Rn5oMynCvgeKJIcGGiqywGWakbMye0IXbEylOIX0L4ETh2ipFBapk50iC1uV8QGyhs45mtkrVsnIsxhzbpEUbcXriVFrOd6jWLFLO3qtKlxolZcYJ+dxbB9SbNz+2FWUU9TyiCCWdvjdtkzCFsac1vEmtaiFhfpEMM95yNkmgLS1/P3vMrIqAETxfSAHPHncjzj2XH3d76QKkRSRik2qvpBZW5UEuoHOw/JZMUe5Vdqg+EsbZ0tFTeQNalFBVHb3gh4kHC1vJEbXTJYlxc4jKo1IZOuxUVxmHaIdTKdTt/9Q9cv8gXnGxsFAECB9EvKPPRlviyzykzzAPsetBms0ZkazqR6pF7Puhp8lDXVIb/a046iOnM3FKtKNeZE/Tm8M71CH1AUgMzxAqwxdWeptf/FkB9e3zw7JFLIpfJLWCsWHYKHEX3Y/6LQjK6ZJBAZzOlj5KVWZThwKvjzUHhv6hQgfB4Y2R4EZCXhxtTDgyXWp083pr7jlY1jvWQA0DoDqMcTueZIHxb0J5iPbgSxxVkFk07WZ5buGTA9WUjQEgkjNjDlCTjXAWENbDn4DWfdK0an/BisPwQchMLe+oedu0voJ0OH7ytusLIenDMvuzvF+tEyrGx6zIsx1KGBPYHUTC0cuzs/DxPWJH2U47aAdS8HBGdtZdaaT8dRKFp/fXwMDcao8uv8DEquaObBHGjT7l4PZH2GKo5p40aJlfoEgW6fzgJySgNYU/pT6xzPzfhCkmSAzQ7cdNa4YgEUUaUTlaIssa55ZkihKcHd6x3UV0BuV9Dtdh/FdFWZUSDSsgzzsLNGQ1RBluXZivSYAq1hmRJSaKRy0F9N2Vosp/VH6O7ujgY4o3W98AoB1/WzJrFTWc9qQCDpGFabY4wSieKBv4fhX1/N9bt7JZa51gzUnL15Dte3X/13doKmmvEJIs74cCA0cxgqKkuZW7ButTpBdqauvru8/LJNcT5L7BSnBrBLY0wWMs0oNMjaPvlm7/ep1Mknki6skXPXN5pB48O74+5FBnow3bsQZM0zw856EJO1woruHaQ2ZeYpZBYdwnHlL9vBmvqN5vZv+IwOJf7lxGpuhf85Fv/p3ro0bqlldJSz2T6LFS/q6A+eo1JrwC4lKFgyLXhHlIk9T41TXDI7s0a/DN/Nzifa3jjnQMPN0tfIFeC1hpkaoFPa3IZpZZnIH4b/uXgOXk9cLBDUJ9sULd2NhsjiwYggZXTICObAo6iOUjN5PWEKeySRSxWXsfk4LhS62Q7WXD6VK0SjVG0rNAIkC/XozKxZsHsY/nrVNWekmiU217/RsZqWPdMyowyyBqBhHW7I5FbpKZGiZwN5C1lbTWocGCkJwKgacSZyqK6dOv5rmbUfuitF8OkzllPQ8/jWAnREjDfW7E2EXvJuFq2DVVlHCqnEDG+MBH5wdRlpLZ0TKAR3H3ZesPbLxESzTkiF1mYdLOwycV03LLwSCu2sf31YkTWqhuRnnHpJ3AlhwVmvRTbsHQNWWzg/AAAHC0lEQVQ6pZsjKl0tQeG0mG64jyljO3jUsGsK9qHhgvU0hM1ZK7JOzXFniZEFFkWC8zleQLPc6Ei548ezyeTqK70Itjm+46uLx2v7MdDOKCJhTKRcxpcyYbQLbztrOinE9dP0yNyhpd9KRIf3CG3gggog52i6AQUNmIUJPHppxbY1mHKtGeVX+AwEXfkjWM8LP/bsde5L4c5GGDY20UXm+Rxp2LMMWwXFhCAkjJeuW1vQoftEZiDlWZcUn0s16Oail6Ibw/rb0e592QPrOWF11N7LL9qfslnnZTJaxYxTkEAih0zGPG/d/lzCAiCRSAhBjcz0ErApbQg8rqEgw7cjm8L6RuG+ffPAWkEuQyo6MywC5n6yooaKK51+p+spGrJgdbsBqhBUosxHIV2ULlfcmGkJL4QgvPycp9fSIahS1YN93Wu4R3OWaDmlzbyOy1GaNY89JdvPhQbQOWVZOF5z3QKjjrEL72ueTOO8pxM+V5zJTDrB57IuAZc/sdsUFlkuoLAysJ0phXUySa/NiJXmwdQ5x9q7s/53d5cMUv1xvx6/cYkRAfRcy4JbmNApjQhrtFRo8FMH8KTmmvHRRt1uO77En3wluf6+G1uTj14A8vz2XmpBOypJbGa15XhAauDxU0K60IzPo1Z4mkMEbF7MJuyNR9UV4yF4xAKR7EJhQS41hYflOHZb9wOf+TxnTTuwa6HTh3DjwswNPF9USLKoUcpy3KawPjra3f32QtY46EFGLMz54L163fitUsrh8d925YOOJ3UqWVmz7KamFsdZlgYqmQQL8oPo7Mfce4Jea5yvJPAgEQHW6fiumgXex/NDJEq+1MMVpzIla0xlZSeWUkUv03C0zptni8152SjH/SGsia+mC8G5+f7idEma+86a43mNTC7iU9E8VcY9jZokmu2KvlbtzMaypiO/AVOjc+OsS0yLivRw+Mpa3B2l5/ygjlGjbN4Ta+PMoO1mTScBkz0oy0VKrpGH5VlT4vms0x4P8jkceSootoAir0dKC8ar4bOwNsdHfzlr4tUJeMRCg8w6a8zUIS/7vLRQTZMdPglkCH39BvqXcx3wBD+3Gmd7WGdZLgSNWOjNRJpAVnfpRW81m+Kt/o213q5Yz9P0ffGFQcntskOKKSHXsAdD3JgWF1rdcz1681BGoLiEmdBOESloqcYfzDpSSJSUKbVcX+MbZYemU0sn6FQXDVaPEtH4GZ74crbhprM2jmW0q+XeGt8oORolmKLVY7Iz2WK0jhRm6q+IBt+l0Nty1prTg0mgIy/XGuWh6dsc9kxlF71com2VOfvoNJs7U0psUF7mZax7YCpaWUwk1usRF1jqvJeTZVdvu1dIoCtAqqfBO/vjr8aaHcv4MkVcqhepb56fI3R0ImsjIljVcbaUV9zMSj73x/qN5EC7F22FWQE6GCjQiaeAzo6UKCT9otAQKr4q+DQmrTcVmHmVLq5NYY0OanxhaYBGLZboou00AsHqEVtDZZ0dYOO4LNkex/2xrDnlpZFh49zBkiVCCB38mXKpm5VrjtOYNn698Znds1nXzWnkjXnVDkVL24sWXLtp+SezNnSIOWWfzuTK2owa04RroAqfqMU91Tif9ZJuEMqO52hGB9d4lJz5hgIuFDP1VY8pDXSADQ+KPuul3ft6gdhteXoqCu2FTNjVjCtSpfQqDVt/LOsZKtxkW3ew39q1gaxRcalsCS2VFuUwfdYrrGwiYdEYEbBV1saWsXZ47w3bgTbZRKoe/TNY//hZ3RDWReS9Y2c02jB9mwYySrTon8C6fX+0Kaw1t9wOGdkKCn8C66fLTWHtOMne6ja+xsCJt2f98I3bbNZZMGdk65awpjXBu2WD9Yr11ysvUkQ5FaglIwUa2y/Xlz+Pjn4efdyQvRElMadKeHvGqIw/wObbmL0Re+9u16AR4XzW/tpaX8Zn7S+ftc/aXz5rn7XP2l8+a5+1v3zWPmufNV0/dxeso12v629+xs/Xu1L+M9aqJHxyPus/kfV3/xmv+Ax/+euvWNY6qWWWfdri4nVjOSd1qdX+9+jI4/2q7N57/NTlp6MjbyOyfxztPq14MKetTmopdrZpi4sxWM//XWp9vOTKR5feODx5Zf30nYt5Orv+41EMPWmlZauTWnJZpi0uvjTWc62XXvc33u6EG4+sy54rZz4eVZX71YbF2+ukliXx4O26fP/m8R+Mjsre5MUr68vdp90nT/+D+/7z59MLIU/XSS35DPu0xVdhXd598Cgvnln/vOS+ebrbqv9WY/cPq4i1o05quQu862WLeIEOid17+/tv8DN4lLmPR5zH6/Oi+3Nqed0bvf29972Re/L+kbzKNffviPvh6d9crmFv9MzaPm1xCYHwavPd/CSq6lVZX+7u3nv73Guw+fzlL3/5i+P+B771P0R9rqU8AAAAAElFTkSuQmCCAA==" alt="" />

从图中可以看出，我们的样本数据集基本上被轮廓分割开来，Adaboost的拟合效果还是不错的，现在我们看看拟合分数：

print('Score:',bdt.score(X,y))

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAN4AAAAVCAMAAAAelqDyAAAAAXNSR0IArs4c6QAAAE5QTFRF////uXAmRJffbLv/Ehh2lUgmEnC/Ehgm/92bRBgmuf//bBgm/7t2Ekibuf/f//+////fldv/EhhS3f//3f/f3ZdS3f+/y5ebuf+/lUhSP8Pu9AAAAShJREFUWMPtltsOgjAMhtt1DhRQQfHw/i9qW3bA6I3ZLojZAvnpdBtfu3ZAww3+t1W8irdpvP9tFa/ibRxvuAD0vwzjAeddtBzAqWuaaQRki0B/y5SCeMP1x/nsAZvh1gVWfnLt3h6fIy49pt0XkOJ4pGGQWPJ70v2ysjhEmMLF65toOw68Pe4kfAGvLyHFNqcB9Rf1AVZu4j5C++iWd1/j8frUjnPAYyeYc8SzB50tU8qWFgFUCu87Qrl8Wn4kg+nZEzRHE+D+Fj0BzpeSlZPT6Sue++ZKB3NiifmXuvxMmVISj7fjNL5vTgxVxCMlHFlfXRw6J92pKXqLTzKlFJ6TrzPUyi7FxPkKjfHQkOXWePFgMGEYatLINCL8/0ypx3rFq3gVb7vtBUQOaD3wLAG1AAAAAElFTkSuQmCCAA==" alt="" />

也就是说拟合训练集数据的分数还不错。当然分数高并不一定好，因为可能过拟合。

现在我们将最大弱分离器个数从200增加到300。再来看看拟合分数。

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=300, learning_rate=0.8)
bdt.fit(X, y)
print("Score:", bdt.score(X,y))

此时的输出为：Score: 0.962222222222

这印证了我们前面讲的，弱分离器个数越多，则拟合程度越好，当然也越容易过拟合。

现在我们降低步长，将步长从上面的0.8减少到0.5，再来看看拟合分数。

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=300, learning_rate=0.5)
bdt.fit(X, y)
print("Score:", bdt.score(X,y))

此时的输出为：Score: 0.894444444444

可见在同样的弱分类器的个数情况下，如果减少步长，拟合效果会下降。

最后我们看看当弱分类器个数为700，步长为0.7时候的情况：

bdt = AdaBoostClassifier(DecisionTreeClassifier(max_depth=2, min_samples_split=20, min_samples_leaf=5),
                         algorithm="SAMME",
                         n_estimators=600, learning_rate=0.7)
bdt.fit(X, y)
print("Score:", bdt.score(X,y))

此时的输出为：Score: 0.961111111111

此时的拟合分数和我们最初的300弱分类器，0.8步长的拟合程度相当。也就是说，在我们这个例子中，如果步长从0.8降到0.7，则弱分类器个数要从300增加到700才能达到类似的拟合效果。

九 Adaboost小结

到这里Adaboost就写完了，前面有一个没有提到，就是弱学习器的类型。理论上任何学习器都可以用于Adaboost.但一般来说，使用最广泛的Adaboost弱学习器是决策树和神经网络。对于决策树，Adaboost分类用了CART分类树，而Adaboost回归用了CART回归树。

这里对Adaboost算法的优缺点做一个总结。

Adaboost的主要优点有：

• Adaboost作为分类器时，分类精度很高
• 在Adaboost的框架下，可以使用各种回归分类模型来构建弱学习器，非常灵活。
• 作为简单的二元分类器时，构造简单，结果可理解。
• 不容易发生过拟合

Adaboost的主要缺点有：

• 对异常样本敏感，异常样本在迭代中可能会获得较高的权重，影响最终的强学习器的预测准确性。

参考文章

[1]集成学习之Adaboost算法原理小结

[2]scikit-learn Adaboost类库使用小结

[3]AdaBoost原理详解

[4]代码实战之AdaBoost

[5]统计学习方法.李航

[6]python笔记之NUMPY中的meshgrid()——生成以某点为中心指定半径内的