《李航 统计学习方法》学习笔记——第八章提升方法

8.1提升方法AdaBoost

简单来讲，提升方法在分类问题中，通过改变训练样本的权重，学习多个分类器，并将这些分类器进行线性组合，最终提高分类的性能。

8.1.1提升方法的基本思路

首先需要了解两个概念，强学习算法和弱学习算法。

• 强学习算法：存在一个多项式学习算法学习它且正确率高。
• 弱学习算法：存在一个多项式学习算法学习它但是正确率仅比随机猜测略好。

Schapire证明强学习与弱学习是等价的，这样一来，可以通过对较易发现的弱学习算法进行优化提升成为强学习算法，进而提高学习正确率。

优化具体思想：从弱学习算法出发，反复学习，得到一系列弱分类器，然后重新组合这些弱分类器，构成一个强分类器。

Adaboost提升方法：通过提高被前一轮弱分类器错误分类样本的权值，降低正确分类样本的权值，导致错误分类的数据，由于权值增大而受到后一轮弱分类器的更大关注，从而改变训练数据的概率分布（训练数据的权值分布），针对不同的训练数据分布调用学习算法学习一系列弱分类器。最后采用加权多数表决，加大分类误差率小的弱分类器的权值，减小误差率大的弱分类器的权值，使得正确率高的弱分类器在表决中的比重更大。

8.1.2AdaBoost算法

假定二分类训练集：
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . ( x N , y N ) } T=\left \{\left ( x_{1}, y_{1}\right ),\left ( x_{2}, y_{2}\right ),...\left ( x_{N}, y_{N}\right )\right \} T={(x1​,y1​),(x2​,y2​),...(xN​,yN​)}
y的取值为 -1 和 +1 .

算法8.1 AdaBoost
输入：训练数据集，弱学习算法。
输出：最终分类器。

1. 初始化训练数据的权值分布（这里假设训练集权值分布均匀）
   $$D_1=\left({\omega }_{11},...,{\omega }_{1i},...,{\omega }_{1N}\right),{\omega }_{1i}=\frac{1}{N}$$
2. 对 $m=1,2,...,M$
   （1）使用具有权值分布$D_m$的训练数据集学习，得到弱分类器（基本分类器）
   G m ( x ) = χ → { − 1 , + 1 } {G_{m}(x)}=\chi\rightarrow\left\{-1,+1\right\} Gm​(x)=χ→{−1,+1}
   （2） 计算$G_m(x)$在训练数据集上的分类误差率
   $$e_m=\sum _{i=1}^{N}P(G_m(x_i)\ne y_i)=\sum _{i=1}{\omega }_{mi}I(G_m(x_i)\ne y_i)且\sum _{i=1}^N{w}_{mi}=1$$
   （3）计算$G_m(x)$的系数（由定理8.1得，该系数是通过最小化$Z_m$即最小化误差上界，对${\alpha }_m$求梯度得到的） $${\alpha }_m=\frac{1}{2}\ln (\frac{1-e_m}{e_m})$$
   （4）更新训练数据的权值分布
   $$D_{m+1}=\left({\omega }_{m+1,1},...,{\omega }_{m+1,i},...,{\omega }_{m+1,N}\right)$$
   $${\omega }_{m+1,i}=\frac{w_{mi}}{Z_m}\exp (-{\alpha }_m{y}_i{G}_m(x_i))$$对上式分类讨论化简后可以得到：
   $${\omega }_{m+1,i}=\{\begin{array}{c}\frac{w_{mi}}{Z_m}{e}^{-{\alpha }_m},G_m(x_i)=y_i\\ \frac{w_{mi}}{Z_m}{e}^{{\alpha }_m},G_m(x_i)\ne y_i\end{array}$$
   其中$Z_m={\sum }_{i=1}^N\exp (-{\alpha }_m{y}_i{G}_m(x_i))$为规范化因子，使得$D_{m+1}$成为一个概率分布。可以看出，误分类样本的权值得以扩大，而正确分类样本的权值得以缩小。
3. 构建基本分类器的线性组合（实现加权表决）
   $$f(x)=\sum _{m=1}^M{\alpha }_m{G}_m(x)$$进而得到最终分类器$G(x)=sign(f(x))$，其中${\alpha }_m$表示弱分类器的重要性。

8.1.3AdaBoost的例子（代码实现）

这里我直接用代码模拟书中的计算过程：

import numpy as np
from math import log

#初始数据
W_1 = 0.1 * np.ones(10) # 初始权值0.1
x = np.arange(10)
y = np.array([1,1,1,-1,-1,-1,1,1,1,-1])

定义弱分类器

#弱分类器
def G(x,v):
    if x < v:
        return 1
    else:
        return -1

该分类器有两种分类方式，x < v 分类结果为 1或 -1，这里我们只考虑 x < v 分类结果为 1，因为另一种情况下的误分类概率为 1 -（ x > v 分类结果为1时的误分类概率），即
$$G_1(x)=\{\begin{array}{c}1x<v\\ -1x>v\end{array}{G}_2(x)=\{\begin{array}{c}-1x<v\\ 1x>v\end{array}$$假设$G_1(x)$分类器的分类误差率为 $e_m$，则采用$G_2(x)$分类器的分类误差率为$1-e_m$。
计算分类误差 $e_m$

def e(W, y, G,v):
    e = 0.5 * (abs(y - [G(xi,v) for xi in x]))
    e =  sum(W * e)
    return e

计算$G_m(x)$的系数${\alpha }_m$

def alpha(e):
    return 1 / 2 * log((1-e)/e)

更新训练数据的权值分布

def w(W_i, alpha_i, G, v, y):
 Z_i = np.sum(W_i * np.exp(- alpha_i * y * [G(xi,v) for xi in x]))
 return W_i/Z_i * np.exp(- alpha_i * y *  [G(xi,v) for xi in x])

主函数

if __name__ == '__main__':
    m = 3
    for m in range(1,m+1):
        min = 10000
        index = 0 #表示每次循环得到分类误差率最低的分割点v
        _alpha = 0
        for v in np.arange(0.5,10.5,1):
            e_m = e(W_1,y,G,v)
            if min > e_m or min > 1 - e_m:#判断两种分类函数分类误差率的大小取其中小的作为分类器
                if min > 1 - e_m:
                    min = 1 - e_m
                else:
                    min = e_m
                index = v
                _alpha = alpha(min)
        W_1 = w(W_1, _alpha, G, index, y)
        print(index)#每次循环的分割点
        print(min)#最低分类误差率
        print(W_1)#更新后的权值分布
        print(_alpha)#G的系数

8.2AdaBoost算法的训练误差分析

定理8.1 AdaBoost训练误差界

$$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)\ne y_i)\le \frac{1}{N}\sum _{i=1}^N\exp (-y_{i}f(x_i))=\prod _{i=1}^N{Z}_i$$
证明过程：
（1）$G(x_i)\ne y_i\text{时}，y_{i}f(x_i)<0,所以e^{-y_{i}f(x_i)}>=1=I(G(x_i)\ne y_i),G(x_i)=y_i$时同理可证，直接得出等式的前半部分。
（2）证明后半部分
$$\begin{gathered} \frac{1}{N}\sum _{i=1}^N\exp (-y_{i}f(x_i))=\frac{1}{N}\sum _{i=1}^N\exp (-\sum _{m=1}^M{a}_m{y}_i{G}_m(x_i)) \\ =\sum _{i=1}^N{w}_{1i}\prod _{m=1}^M\exp (-a_m{y}_i{G}_m(x_i)),初始化时假设均匀分布w_{1i}=\frac{1}{N} \\ =Z_1\sum _{i=1}^N{w}_{2i}\prod _{m=2}^M\exp (-a_m{y}_i{G}_m(x_i)) \\ =Z_1{Z}_2\sum _{i=1}^N{w}_{3i}\prod _{m=3}^M\exp (-a_m{y}_i{G}_m(x_i)) \\ ...... \\ =\prod _{m=1}^M{Z}_m \end{gathered}$$
这个定理的意义在于,每一轮选取适当的$G_m$,使得$Z_m$最小，从而使训练误差下降最快。为了降低训练误差上界，应使得$Z_m$最小，$Z_m$公式中$y_i$与$G(x_i)$为定值。$w_m$是通过上一次训练得到的值，所以$Z_m$是关于$\alpha$的函数，通过对$\alpha$求梯度，得
$${\alpha }_m=\frac{1}{2}\ln (\frac{1-e_m}{e_m})$$
即AdaBoost算法中$G(x)$系数的由来

定理8.2 二分类问题AdaBoost训练误差界

$$\begin{gathered} \prod _{m=1}^M{Z}_m=\prod _{m=1}^M[2\sqrt{e_m(1-e_m)}] \\ =\prod _{m=1}^M\sqrt{(1-4{\gamma }_m^2)} \\ \le \exp (-2\sum _{m=1}^M{\gamma }_m^2) \\ {\gamma }_m=\frac{1}{2}-e_m \end{gathered}$$
证明过程
$$\begin{gathered} Z_m=\sum _{i=1}^N{w}_{mi}\exp (-a_m{y}_i{G}_m(x_i)) \\ =\sum _{y_i=G_m(x_i)}{w}_{mi}{e}^{-a_m}+\sum _{y_i\ne G_m(x_i)}{w}_{mi}{e}^{a_m} \\ =(1-e_m)e^{-a_m}+e_m{e}^{a_m} \\ =(1-e_m)e^{-\frac{1}{2}\ln (\frac{1-e_m}{e_m})}+e_m{e}^{\frac{1}{2}\ln (\frac{1-e_m}{e_m})} \\ =2\sqrt{e_m(1-e_m)} \\ =\sqrt{1-4{\gamma }_m^2} \end{gathered}$$
这里涉及到$e^{-\frac{1}{2}x}$和$\sqrt{1-x}$泰勒展开：
$$\begin{gathered} e^{-\frac{1}{2}x}=1-\frac{1}{2}x+\frac{1}{8}{x}^2+o(x^3) \\ \sqrt{1-x}=1-\frac{1}{2}x-\frac{1}{8}{x}^2+o(x^3) \end{gathered}$$
令$x=4{\gamma }_m^2$时
$$\begin{gathered} e^{-2{\gamma }_m^2}=1-2{\gamma }_m^2+2{\gamma }_m^4 \\ \sqrt{1-4{\gamma }_m^2}=1-2{\gamma }_m^2-2{\gamma }_m^4 \end{gathered}$$
通过泰勒展开可以明显看出大小关系，这里仅展开到第三项，由此可得结论。
$$\prod _{m=1}^M\sqrt{(1-4{\gamma }_m^2)}\le \exp (-2\sum _{m=1}^M{\gamma }_m^2)$$
推论8.1
如果存在$\gamma >0$,对于所有$m$有${\gamma }_m>=\gamma$,则
$$\frac{1}{N}\sum _{i=1}^{N}I(G(x_i)\ne y_i)\le \exp (-2M{\gamma }^2)$$
这个推论的证明通过定理8.1和8.2的不等式即可轻易推出。
这个推论表明，通过训练误差上界可知，AdaBoost的训练误差是以指数速率下降的。且Adaboost算法不需要事先知道下界$\gamma$，具有自适应性，它能自适应弱分类器的训练误差,从而提升准确率。

8.3 AdaBoost算法的解释

8.3.1前向分步算法

因为学习是加法模型，如果能够从前向后，每一步只学习一个基函数及其系数，逐步逼近优化目标函数式，则可以简化优化的复杂度。
算法8.2前向分步算法
输入：训练数据集，损失函数$L$，基函数 { b ( x ; γ ) } \left \{b(x;\gamma)\right \} {b(x;γ)}
输出：加法模型

1. 初始化$f_0(x)=0$;
2. 对$m=1,2,...,M$
   （1）极小化损失函数
   $$({\beta }_m,{\gamma }_m)=\underset{\beta ,\gamma }{\mathrm{argmin}}\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+\beta b(x_i;\gamma ))$$
   其中$\gamma$为基函数的参数，$\beta$为基函数的系数。
   （2）更新函数
   $$f_m(x)=f_{m-1}(x)+{\beta }_{m}b(x:{\gamma }_m)$$
3. 得到加法模型
   $$f(x)=f_M(x)=\sum _{m=1}^M{\beta }_{m}b(x:{\gamma }_m)$$

8.3.2前向分步算法与AdaBoost

定理8.3AdaBoost是向前分步加法算法的特例
（1）模型：加法模型
（2）损失函数：指数函数
（3）学习算法：前向分步算法时的二分类学习
证明过程如下：

1. 当基函数为基本分类器时，前向加法模型就等价于AdaBoost的最终分类器。
2. 假设经过$m-1$轮迭代前向前分步算法已经得到的$f_{m-1}(x)$,在第$m$轮迭代得到了${\alpha }_m,G_m(x),f_m(x)$.
   $$f_m(x)=f_{m-1}(x)+{\alpha }_m{G}_m(x)$$
   指数损失函数为：
   $$L(y,f(x))=\exp [-yf(x)]$$
   迭代的目的是使向前分步算法得到${\alpha }_m,G_m(x)$，使得$f_m(x)在训练集上的损失函数最小，若损失函数为指数损失函数：
   $$({\alpha }_m,G_m(x))=\underset{\alpha ,G}{\mathrm{argmin}}\sum _{i=1}^N\exp [-y_i(f_{m-1}(x_i)+\alpha G(x_i)]$$
   在该式子中，对于第$m$次迭代，$y_i$与$f_{m-1}(x_i)$为已知值，不依赖于$\alpha$和$G$,所以令$\widehat{{\omega }_{mi}}=\exp (-y_i{f}_{m-1}(x_i))$,该值与最小化无关，化简后上式得：
   $$({\alpha }_m,G_m(x))=\underset{\alpha ,G}{\mathrm{argmin}}\sum _{i=1}^N\widehat{{\omega }_{mi}}\exp [-y_i\alpha G(x_i)]$$
   因为$y_{i}G(x_i)$的值为有限种可能（这里为+1，-1），所以将上式拆分：
   $$\begin{gathered} ({\alpha }_m,G_m(x))=\underset{\alpha ,G}{\mathrm{argmin}}\sum _{y_i=G(x_i)}^N\widehat{{\omega }_{mi}}\exp (-\alpha )+\sum _{y_i\ne G(x_i)}^N\widehat{{\omega }_{mi}}\exp (\alpha ) \\ =\underset{\alpha ,G}{\mathrm{argmin}}\sum _{y_i=G(x_i)}\widehat{{\omega }_{mi}}\exp (-\alpha )+\sum _{y_i\ne G(x_i)}\widehat{{\omega }_{mi}}\exp (-\alpha )+\sum _{y_i\ne G(x_i)}\widehat{{\omega }_{mi}}[\exp (\alpha )-\exp (-\alpha )] \\ =\underset{\alpha ,G}{\mathrm{argmin}}\exp (-\alpha )\sum _i^N\widehat{{\omega }_{mi}}+[\exp (\alpha )-\exp (-\alpha )]\sum _i^N\widehat{{\omega }_{mi}}I(y_i\ne G(x_i)） \end{gathered}$$
   求解G
   上式中，为了使目标损失函数最小，针对$G$来说，对于任意$\alpha >0$含$G$项的值需最小，即
   $$G_m^{\ast }(x)=\underset{G}{\mathrm{argmin}}\sum _{i=1}^N\widehat{w_{mi}}I(y_i\ne G(x_i))$$因为这里为给定$G(x)$的具体形式，当给形式时，就可以用上式求解其参数。
   求解$\alpha$
   把上式$G_m^{\ast }(x)$带入拆分后的式子得：
   $$\underset{\alpha }{\mathrm{argmin}}\exp (-\alpha )\sum _i^N\widehat{{\omega }_{mi}}+[\exp (\alpha )-\exp (-\alpha )]\sum _i^N\widehat{{\omega }_{mi}}I(y_i\ne G^{\ast }(x_i))$$
   并对$\alpha$进行求导后等于0，令$$e_m=\frac{\sum _{i=1}^N\widehat{w_{mi}}I(y_i\ne G_m(x_i))}{\sum _{i=1}^N\widehat{w_{mi}}}=\sum _{i=1}^N{w}_{mi}I(y_i\ne G(x_i))$$
   即分类误差率, 可以得到
   $${\alpha }_m^{\ast }=\frac{1}{2}\log \frac{1-e_m}{e_m}$$
   这里得到的系数与AdaBoost步骤2.2中一致。
3. 进行样本权值更新时，
   $$\begin{gathered} \widehat{{\omega }_{m+1,i}}=\exp (-y_i{f}_m(x_i)) \\ =\exp (-y_i\sum _{j=1}^m{\alpha }_j{G}_j(x_i)) \\ =\prod _j^m\exp (-y_i{\alpha }_j{G}_j(x_i)) \\ =w_{mi}\exp (-y_i{\alpha }_m{G}_m(x_i)) \end{gathered}$$
   与AdaBoost中相比较，缺少了规范化因子$Z_m$
   $${\omega }_{m+1,i}=\frac{w_{mi}}{Z_m}\exp (-{\alpha }_m{y}_i{G}_m(x_i))$$
   因为$Z_m$当m确定时为定值，对于所有样本点都是相同的作用，所以不影响结果。到此证毕。

8.4提升树

8.4.1提升树模型

提升树被认为是统计学习中最有效的方法之一，以分类树和回归树维基本分类器的提升方法，或者说是是以决策树为基函数的提升方法，其模型为
$$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$
其中$T(x;{\Theta }_m)$表示决策树，${\Theta }_m$为决策树的参数，M为树的个数。

8.4.2提升树算法

算法8.3回归问题的提升树算法
输入：训练数据集
输出：提升树

1. 初始化提升树$f_0(x)=0.$
2. 对$m=1,2,...,M.$
   （1）计算残差
   $$r_{mi}=y_i-f_{m-1}(x_i),i=1,2,...,N$$
   （2）拟合残差$r_{mi}$学习一个回归树，得到$T(x;{\Theta }_m)$.
   $${\hat{\Theta }}_m=\underset{{\Theta }_m}{\mathrm{argmin}}\sum _{i=1}^{N}L(y_i,f_{m-1}(x_i)+T(x;{\Theta }_m))$$
   若损失函数为平方误差函数，则上式子化简为：
   $$\begin{gathered} {\hat{\Theta }}_m=\underset{{\Theta }_m}{\mathrm{argmin}}\sum _{i=1}^N(y-f_{m-1}(x)-T(x;{\Theta }_m)) \\ =\underset{{\Theta }_m}{\mathrm{argmin}}\sum _{i=1}^N(r_{mi}-T(x;{\Theta }_m)) \end{gathered}$$
   （3）更新$f_m(x)=f_{m-1}(x)+T(x;{\Theta }_m)$.
3. 得到回归问题提升树
   $$f_M(x)=\sum _{m=1}^{M}T(x;{\Theta }_m)$$

例8.2 python模拟计算过程

import numpy as np

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = [5.56, 5.70, 5.91, 6.40, 6.80, 7.05, 8.90, 8.70, 9.00, 9.05]


c_1=[] #每次迭代中每个分界点的左值
c_2=[] #每次迭代中每个分界点的右值
_L = [] #每次迭代的损失函数值
new_s=[] #最终的每个分界点

def create(r):
    _c1 = 0
    _c2 = 0
    _s = 0
    _m_s = 10000 #辅助用于取最小的m(s)
    _y = [0 for i in range(len(x))] #辅助计算残差
    for s in np.arange(1.5, 10.5, 1):
        c1 = c2 = 0
        N1 = N2 = 0
        R1 = []
        R2 = []
        L = 0
        for i in range(len(x)):
            if x[i] <= s:
                R1.append((x[i], r[i]))
                c1 = c1 + r[i]
                N1 = N1 + 1
            else:
                R2.append((x[i], r[i]))
                c2 = c2 + r[i]
                N2 = N2 + 1
        c1 = c1 / N1
        c2 = c2 / N2
        m_s = sum((R1[i][1] - c1) * (R1[i][1] - c1) for i in range(len(R1)))) + sum((R2[i][1] - c2) * (R2[i][1] - c2) for i in range(len(R2))))
        if _m_s > m_s:
            _m_s = m_s
            _c1 = c1
            _c2 = c2
            _s = s
    c_1.append(_c1)
    c_2.append(_c2)
    new_s.append(_s)
    for i in range(len(y)):
        if x[i] < _s:
            _y[i] = _c1
        else:
            _y[i] = _c2
        r[i] = y[i] - _y[i]
        L = L + r[i] * r[i]
    _L.append(L)
    print(L)

if __name__ == '__main__':
    r = y
    m = 6
    for i in range(1,m+1):
        create(r)
    print(c_1)
    print(c_2)
    print(new_s)
    print("------")

8.4.3梯度提升

对于一般的损失函数，每一步的优化并不容易，该算法将损失函数的负梯度在当前模型的值回归问题提升树算法中的残差的近似值，拟合回归树
算法8.4 梯度提升算法
输入：训练数据集，损失函数
输出：回归树

1. 初始化$f_0(x)$:
   $$f_0(x)=\arg \underset{c}{\min }\sum _{i=1}^{N}L(y_i,c)$$
   估计使损失函数极小化的常数值，它是只有一个根节点的树。
2. 对$m=1,2,...,M$
   （1）对$i=1,2,...,N$,计算损失函数的负梯度在当前模型的值，将它作为残差的估计（当损失函数为平方损失函数，它就是通常所说的残差）：
   $$r_{mi}=-[\frac{\partial L(y_i,f(x_i))}{\partial f(x_i)}{]}_{f(x)=f_{m-1}(x)}$$
   （2）对$r_{mi}$拟合一个回归树，得到第$m$课树的叶节点区域$R_{mj},j=1,2,...J$
   （3）对$j=1,2,...J,$计算:
   $$c_{mj}=\underset{c}{\mathrm{argmin}}\sum _{x_j\in R_{mj}}L(y_i,f_{m-1}(x_i)+c)$$
   利用线性搜索估计夜间点区域的值，使损失函数极小化。
   （4）更新$f_m(x)=f_{m-1}(x)+\sum _{j=1}^J{c}_{mj}I(x\in R_{mj})$
3. 得到回归树
   $$\hat{f}(x)=f_M(x)=\sum _{m=1}^M\sum _{j=1}^J{c}_{mj}I(x\in R_{mj})$$

习题8.1

解题思路：

1. 初始化训练数据的权值分布,这里依旧假设是均匀分布,样本数量是10。
   $$D_1=\left({\omega }_{11},...,...,{\omega }_{1,10}\right)=(0.1,....0,1)$$
2. 对$m=1,2,...M$，当误分类点为0时，结束循环。
   （1）使用具有权值分布$D_m$的训练数据集学习CART树：

• 在CART树中，需要通过计算$Gini$系数选取特征值，而AdaBoost算法是需要改变样本的权重来实现弱分类器的迭代。怎样将两个参数结合起来，$Gini$系数表示样本集合的不确定性，而$\omega$表示了接下来学习中样本的重要性。采用优化后的$Gini$系数：（假设A表示身体，值为0，1）
  $$Gini（S,A=1)=\frac{\left|S_1\right|}{S}Gini(S_1)\ast \sum _{A_i=1}{\omega }_{mi}+\frac{\left|S_2\right|}{S}Gini(S_2)\ast \sum _{A_i=0}{\omega }_{mi}$$
  这里假设$S_1$为身体为1的样本集，$S_2$为身体为0的样本集，S为全部样本。这样计算后将样本的重要性与不确定性相结合，最终结果可以认为训练数据出现的概率（在原基尼系数中增加了该特点：权重大的数据出现的概率大）
• 选择基尼系数最小的特征和对应的切分点，进行切分，生成决策树桩，作为弱分类器$G_m(x)$。
  （2）计算$G_m(x)$在训练集上的分类误差率$e_m$.
  （3）计算$G_m(x)$的系数${\alpha }_m$
  （4）更新权值分布

3. 构建最终分类器：
   $$f(x)=\sum _{m=1}^M{\alpha }_m{G}_m(x)$$

习题8.2

1. 支持向量机

• 学习策略：当训练数据近似线性可分时，通过软间隔最大化，学习一个线性分类器。
• 学习算法：SMO序列最小最优化算法

2. AdaBoost

• 学习策略：通过极小化加法模型的指数损失，得到一个强分类器。
• 学习算法：前向分步算法。

3. 逻辑斯谛回归模型

• 学习策略：在给定的训练数据条件下对模型进行极大似然估计或正则化的极大似然估计。
• 学习算法：改进的迭代尺度算法（IIS），梯度下降法，牛顿法以及拟牛顿法。

参考

[1] 李航《统计学习方法》
[2] 《机器学习实战》

笔者刚刚入门学习机器学习，因为水平有限，李航老师的书对入门不是特别友好，还在生啃阶段，如果有错误还请之处。