Chapter 4. Training Models

2018-09-01

前面几章在不知道具体原理的情况下，我们已经使用sklearn搭建模型并解决了一些实际问题，这章介绍一些原理，以便我们更好地选择算法模型。

1 Linear Regression

线性回归的基本形式：

$y=\theta_0+\theta_1x_1+\theta_2x_2+...+\theta_nx_n$

它的向量化的形式是：

$y=h_\theta(x)=\theta^T\cdot x$

MSE损失函数：

$MSE(X,h_\theta)=\frac{1}{m}\sum_{i=1}^m(\theta^T\cdot x^{(i)}-y^{(i)})^2$

1.1 The Normal Equation

线性回归是有闭式解使得损失函数的值最小的，它的形式如下：

$\theta=(X^T\cdot X)^{-1}\cdot X^T \cdot y$

使用numpy测试

import numpy as np
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
X_b = np.c_[np.ones((100,1)), X] # add x0 = 1 to each instance
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
>>> theta_best
array([[4.21509616],
        [2.77011339]])

用sklearn测试

from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X, y)
>>> lin_reg.intercept_, lin_reg.coef_
(array([4.21509616]), array([[2.77011339]]))

1.2 Computational Complexity

闭式解的计算需要对矩阵求逆，其复杂度是和实例的数量以及特征的数量成正比的。

2 Gradient Descent

梯度下降是寻找局部最优的一种常见方法，其思想就是迭代参数使得loss下降。关于梯度下降，因为已经了解，不做过多笔记。使用梯度下降的时候，需要保证所有的特征都有相似的尺度。

2.1 Batch Gradient Descent

对线性回归的MSE求梯度，

$\Delta_\theta MSE(\theta)=\frac{2}{m}X^T \cdot (X \cdot \theta - y)$

这是一个向量化的操作，它对整个训练集X求梯度，所以称为Batch Gradient Descent。
参数更新如下：

$\theta^{(next)}=\theta - \eta\Delta_\theta MSE(\theta)$

算法实现

eta = 0.1 
n_iterations = 1000
m = 100
theta = np.random.randn(2,1)
for iteration in range(n_iterations):
    gradients = 2/m*X_b.T.dot(X_b.dot(theta)-y)
    theta = theta - eta * gradients
>>> theta
array([4.21509616],
    [2.77011339])

可见针对线性回归问题，使用梯度下降的方法和闭式解相同。值得注意的是，学习率需要合理设置，过高容易越过最优解，而过低则收敛太慢。合理设置迭代次数也极为重要，通常的好做法是设置比较大的iterations，当参数变化极微弱时即可中断操作，可以认为此时达到了局部最优解。

2.2 Stochastic Gradient Descent

Batch Gradient Descent的一个缺点就是它将训练集作为整体进行训练，当训练集太大时，速度会很慢。随机梯度下降则在训练时随机选择一个实例对其计算梯度，然后进行优化，这样速度很快，当然，由于其每次只用一个实例进行训练，它并不能做到每次迭代都使loss减小，并且即便函数到达全局最优，它还是可以继续运算下去，所以它只能得到一个近似的最优解。它的特点就是可以跳过局部最优，但是同时这也就意味着它也能跳过全局最优。一种解决方案是逐渐减小学习率，叫做simulated annealing
实现

n_epochs = 50
t0, t1 = 5, 50
def learning_schedule(t):
    return t0 / (t + t1)
theta = np.random.randn(2,1)
for epoch in range(n_epochs):
    for i in range(m):
        random_index = np.random.randint(m)
        xi = X_b[random_index:random_index+1]
        yi = y[random_index:random_index+1]
        gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(epoch * m + i)
        theta = theta - eta * gradients

最后计算得到

1
2
3

>>> theta
array([[4.21076011],
    [2.74856079]])

使用sklearn实现如下：

from sklearn.linear_model import SGDRegressor
sgd_reg = SGDRegressor(n_iter=50, penalty=None, eta0=0.1)
sgd_reg.fit(X,y.ravel())
>>> sgd_reg.inercept_,sgd_reg.coef_
(array([4.18380366]), array([2.74285299]))

2.3 Mini-batch Gradient Descent

Mini-batch是前两种方式的折中，不过多笔记了。
几种训练方法比较

$\begin{array}{c|lcr} \text{Algorithm} & \text{Large m} & \text{Out-of-core support} & \text{Large n} & \text{Hyperparams} &\text{Scaling required} &\text{Scikit-Learn} \\\\ Normal &Equation &Fast &No &Slow &0 &No &LinearRegression \\\\ Batch GD & Slow & No & Fast & 2 & Yes & n/a \\\\ SGD & Fast & Yes & Fast & >=2 & Yes & SGDRegressor \\\\ Mini-batch GD & Fast & Yes & Fast & >=2 & Yes & n/a \\\\ \end{array}$

3 Polynomial Regression

多项式回归

m = 100
X = 6 * np.random.rand(m,1) - 3
y = 0.5 * X**2 + X + 2 + np.random.randn(m,1)
#使用sklearn包进行拟合
from sklearn.preprocessing import PolynomialFeatures
poly_features = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly_features.fit_transform(X)
>>> X[0]
array([-0.75275929])
>>> X_poly[0]
array([-0.75275929, 0.56664654])
# 下面进行线性回归
lin_reg = LinearRegression()
lin_reg.fit(X_poly, y)
>>> lin_reg.intercept_,lin_reg.coef_
(array([1.78134581]),array([[0.93366893, 0.56456263]]))

4 Learning Curves

可以通过绘制训练集和验证集的学习曲线来判断模型的拟合情况。
some tricks
1 如果模型在训练集上是欠拟合的，添加更多训练数据并没有用，我们需要做的是使用更复杂的模型或者是利用更多的features。
2 提升一个过拟合模型的性能的一种有效方法是添加更多的训练数据，直到训练误差接近验证误差。
The Bias/Variance Tradeoff
泛化误差的三个主要组成部分：
Bias：来源于错误的假设，比如数据是线性的，假设为二次多项式造成的泛化误差。
Variance：来源于训练过程中，模型对数据中微小变化的敏感性。
Irreducible error：来源于数据的噪声。解决方法只能是数据清洗，如去除outliners等。

5 Regularized Linear Models

介绍线性模型中的一些正则化方法，来抑制过拟合。

5.1 Ridge Regression

在损失函数中添加正则项：

$J(\theta)=MSE(\theta)+\alpha \frac{1}{2} \sum _{i=1}^{n} \theta_i ^2$

Trick：使用Ridge Regression之前先对数据进行scale是很有必要的，因为该模型对输入数据尺度敏感。对于大多数正则化模型来说都是这样。

Ridge Regression的闭式解

$\theta=(X^T \cdot X+\alpha A)^{-1}\cdot X^T\cdot y$

from sklearn.linear_model import Ridge
# 使用闭式解
ridge_reg = Ridge(alpha=1,  solver='cholesky')
ridge_reg.fit(X,y)
# 使用SGD
sgd_reg = SGDRegressor(penalty='l2')
sgd_reg.fit(X,y.ravel())

5.2 Lasso Regression

Least Absolute Shrinkage and Selection Operator Regression
同样是在loss function添加正则项。

$J(\theta)=MSE(\theta)+\alpha \sum _{i=1}^n |\theta_i|$

Lasso倾向于使得不重要的特征的权重接近0，也就是说，它能够自动进行特征选择，并且输出为稀疏矩阵。

1 2	from sklearn.linear_model import Lasso lasso_reg = Lasso(alpha=0.1)

5.3 Elastic Net

对Ridge和Lasso的折中，既惩罚一次项，也惩罚二次项。

$J(\theta)= MSE(\theta)+ra\sum _{i=1}^n|\theta _i|+\frac{1-r}{2}\alpha \sum _{i=1} ^n \theta_i^2$

1 2	from sklearn.linear_model import ElasticNet elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5)

5.4 Early Stopping

训练过程中，验证误差达到某个阈值时停止训练。

6 Logistic Regression

Logistic Regression的作用就是不直接输出预测分数，而是加上一个logistic函数使得输出在0到1之间，作为概率的度量。

6.1 Estimating Probabilities

$p=h_\theta (x) = \sigma (\theta ^T \cdot x)$ $\sigma (t)=\frac{1}{1+exp(-t)}$

6.2 Training and Cost Funtion

$J(\theta)=-\frac{1}{m}\sum _{i=1}^m[y^{(i)}log(p^{(i)})+(1-y^{(i)})log(1-p^{(i)})]$

这个式子没有闭式解，但是其是凸函数，所以可以用梯度下降求出解。
其偏导数如下：

$\frac{\partial}{\partial \theta _j}J(\theta)=\frac{1}{m}\sum _{i=1}^m(\sigma(\theta ^T \cdot x^{(i)})-y^{(i)})x_j^{(i)}$

1 2	log_reg = LogisticRegression() # 也可对Logistic Regression添加正则项

6.3 Decision Boundaries

6.4 Softmax Regression

使得Logistic Regression支持多分类，也叫作Multinomial Logistic Regression。
算法思路
首先对每类计算score

$s_k(x)=\theta_k ^T \cdot x$

然后计算每类的概率：

$p_k=\sigma (s(x))_k=\frac{exp(s_k(x))}{\sum _{j=1}^{K}exp(s_j(x))}$

其类别预测方法：

$y=argmax_k\sigma(s(x))_k=argmax_k s_k(x)=argmax_k(\theta_k^T\cdot x)$

使用Cross Entropy 作为损失函数：

$J(\theta)=-\frac{1}{m}\sum _{i=1}^m \sum _{k=1}^K y_k^{(i)}log(p_k^{(i)})$

偏导数如下计算：

$\Delta_{\theta_k}J(\Theta)=\frac{1}{m}\sum_{i=1}^m(p_k^{(i)}-y_k^{(i)})x^{(i)}$

调包

1 2	softmax_reg = LogisticRegression(multi_class='multinomial', solver='lbfgs',C=10) softmax_reg.fit(X,y)

Fengyang