Datawhale 7月学习——李弘毅深度学习：回归

最新推荐文章于 2022-09-15 19:21:57 发布

SheltonXiao

最新推荐文章于 2022-09-15 19:21:57 发布

阅读量238

点赞数 2

分类专栏：学习

本文链接：https://blog.csdn.net/qq_40990057/article/details/118709386

版权

学习专栏收录该内容

59 篇文章 17 订阅

订阅专栏

前情回顾

机器学习简介

1 回归模型

1.1 回归的概念及例子

回归（Regression）的意思就是找到一个函数 $f u n c t i o n$ ，通过输入特征 $x$ ，输出一个数值 $S c a l a r$ 。
李宏毅老师在这里列举了几个回归模型的例子：

股市预测（Stock market forecast）
- 输入：过去10年股票的变动、新闻咨询、公司并购咨询等
- 输出：预测股市明天的平均值
自动驾驶（Self-driving Car）
- 输入：无人车上的各个sensor的数据，例如路况、测出的车距等
- 输出：方向盘的角度
商品推荐（Recommendation）
- 输入：商品A的特性，商品B的特性
- 输出：购买商品B的可能性
Pokemon精灵攻击力预测（Combat Power of a pokemon）
- 输入：进化前的CP值、物种（Bulbasaur）、血量（HP）、重量（Weight）、高度（Height）
- 输出：进化后的CP值

1.2 回归模型的实现

回归模型的步骤主要分为几步

step1：模型假设，选择模型框架（模型种类）
step2：模型评估，如何判断众多模型的好坏（损失函数）
step3：模型优化，如何筛选最优的模型（优化求解）

对应到本次课程具体指

step1：模型假设-线性模型
step2：模型评估-损失函数
step3：模型优化-梯度下降

通俗理解的话，就是在一系列的模型中，去找到一个预测结果最好（误差最小）的模型。这个寻找过程，是先确定一个模型的形式（同时确定模型参数），然后确定衡量误差的方式（模型预测结果与真实标签间的差距），在求解中，采用合适的优化方法根据误差不断调整模型的参数。

针对Pokemon精灵攻击力预测这个问题，有：

1.2.1 Step 1：模型假设 - 线性模型

如果输入只有一个特征 $x_{cp}$ ，可以假设一元线性模型

$y = b + w·x_{cp}$

如果输入有多个特征，例如，进化前的CP值、物种（Bulbasaur）、血量（HP）、重量（Weight）、高度（Height）等，则可以假设多元线性模型

$\sum w_ix_i$

$x_i$ ：就是各种特征(fetrure) $x_{cp},x_{hp},x_w,x_h,···$
$w_i$ ：各个特征的权重 $w_{cp},w_{hp},w_w,w_h,··$
$b$ ：偏移量

确定了模型，则后续的，就是要求得最好的 $w$ 和 $b$ ，使得这个模型最优。

1.2.2 Step 2：模型评估 - 损失函数

针对单个特征 $x_{cp}$ 的情形
在这里插入图片描述
其实简单地讲，就是看函数的输出结果和真实值之间的差距，损失函数是用于量化这个差距的。

这里损失函数用的是最小二乘法的衡量方式

$(\hat y,y)= \dfrac {1}{2} (\hat y - y)^2$

但其实这个函数在很多问题中并不是一个很好的凸函数（在这个线性回归问题当中是凸函数），不易求得全局最优解。所以有一些其他的损失函数，比如交叉熵代价函数（cross-entropy）。

$(\hat y,y)= (y\log {\hat y} + (1-y)\log(1-\hat y ))$

为了方便计算，把模型带入最小二乘法的公式
$\begin{aligned} L(f) & = \sum_{n=1}^{10}\left ( \hat{y}^n - f(x_{cp}^n) \right )^2，将【f(x) = y】, 【y= b + w·x_{cp}】代入 \\ & = \sum_{n=1}^{10}\left ( \hat{y}^n - (b + w·x_{cp}) \right )^2\\ \end{aligned}$

最终定义损失函数 Loss function： $\sum_{n=1}^{10}\left ( \hat{y}^n - (b + w·x_{cp}) \right )^2$

可以将 $w$ , $b$ 在二维坐标图中展示，如图所示：
在这里插入图片描述

图中每一个点代表着一个模型对应的 $w$ 和 $b$
颜色越深代表模型更优

1.2.3 Step 3：最佳模型-梯度下降

这一步是帮助我们筛选最优的模型，借助优化的方法逐步求得最优解，即针对这个数据 $\sum_{n=1}^{10}\left ( \hat{y}^n - (b + w·x_{cp}) \right )^2$ 最佳的 $w$ 和 $b$ 。
在这里插入图片描述
这边用的是最简单的梯度下降法。

简单的说就是求解损失函数对于参数的偏导数，然后改变参数的值，让参数的求解往最陡的地方走一步。

为了避免变化过于激烈，需要引入学习率的概念：移动的步长 $\eta$ 。

则梯度下降法的求解如下：

步骤1：随机选取一个 $w^0$
步骤2：计算微分，也就是当前的斜率，根据斜率来判定移动的方向
步骤3：根据学习率移动
重复步骤2和步骤3，直到找到最低点

逐步求解如下图所示：
在这里插入图片描述
形象地表示如下：

在现实中及别的问题中，梯度下降法会面临：

问题1：当前最优（Stuck at local minima）
问题2：等于0（Stuck at saddle point）
问题3：趋近于0（Very slow at the plateau）

这些问题需要通过调整合理的学习率，选择合理的损失函数等方法确定。

1.3 模型的提升

1.3.1 换用更复杂的模型

在上述例子中，可以选择更复杂的模型，可能可以取得更好的精度。

首先我们尝试增加模型的阶次。
在这里插入图片描述
但也可能出现过拟合。

在训练集上面表现更为优秀的模型，为什么在测试集上效果反而变差了？这就是模型在训练集上过拟合的问题。

将错误率结果图形化展示，发现3次方以上的模型，已经出现了过拟合的现象：

加粗样式
过拟合是机器学习中经常会出现的问题，通俗地讲，过拟合就是模型过度拟合了训练集数据，而在测试集上表现很差。

一般来说，造成过拟合的原因有：

训练集太小
模型过于复杂
过度训练
…

除了增加模型的阶次，还可以增加模型的变量个数，例如将对 Pokemons种类作为变量，输入模型。在此例中，Pokemon共有4类，则将 4个线性模型合并到一个线性模型中。
在这里插入图片描述
具体到某一个例子的求解上，有

效果有提升

还可以将血量（HP）、重量（Weight）、高度（Height）也加入到模型中。

但在此例中依然会导致过拟合。

1.3.2 正则化

一种应对过拟合的方式，是在损失函数中引入正则化（Regularization）项。
在这里插入图片描述
在此例中引入的是L2正则化项

$\lambda \sum{(w_i)^2}$

这一正则化项使得 $w$ 参数越小的模型越受青睐。因为 $w$ 参数越小，说明当 $x$ 变化时，函数所求得的 $y$ 变化越小，也意味着模型更平滑，则过拟合的程度也会有所降低。

正则化项的参数 $\lambda$ 并非一味的越小越好。
在这里插入图片描述
从上图中我们可以看到，随着 $\lambda$ 的增大，损失函数正则化项的影响增大，模型过拟合程度下降。但当正则化项占比太大时，也会影响到损失函数的正常计算，无法求得很好的模型。

需要注意的是，由于参数 $b$ 与模型输入 $x$ 没有直接联系，故正则化项中不需要加入 $b$ 。

2 回归案例的计算

此部分的代码，完整版在本人的GitHub上，此处根据李宏毅机器学习2019P4适当地整理和修改。

2.1 回归案例

现在假设有10个x_data和y_data，x和y之间的关系是y_data= $b$ + $w$ *x_data。 $b$ ， $w$ 都是参数，是需要学习出来的。现在我们来练习用梯度下降找到 $b$ 和 $w$ 。

给定的x_data和y_data如下：

x_data = [338., 333., 328., 207., 226., 25., 179., 60., 208., 606.]
y_data = [640., 633., 619., 393., 428., 27., 193., 66., 226., 1591.]
x_d = np.asarray(x_data)
y_d = np.asarray(y_data)

针对上述代码中使用的np.asarray与本人常用的np.array不同，于是查找官方文档，尝试解决：What is the difference between np.asarray and np.array

根据Numpy Documnetation

np.asarray:

Returns : out: ndarray
Array interpretation of a. No copy is performed if the input is already an ndarray with matching dtype and order. If a is a subclass of ndarray, a base class ndarray is returned.

np.array:

Parameters : copybool: optional
If true (default), then the object is copied. Otherwise, a copy will only be made if array returns a copy, if obj is a nested sequence, or if a copy is needed to satisfy any of the other requirements (dtype, order, etc.).
Returns : out: ndarray
An array object satisfying the specified requirements.

可以看出它们的主要区别在于是否在生成时进行了对象拷贝。

具体到这一案例上

x_d2= np.array(x_data)
print(id(x_data))
print(id(x_d))
print(id(x_d2))

则可以得到结果

3033674123400
3033674166480
3033674167600

三者id不同，这是因为生成np.ndarray所使用的源对象本身不是np.ndarray的缘故。若：

x_d3= np.asarray(x_d2)
x_d4= np.array(x_d2)
print(id(x_d2))
print(id(x_d3))
print(id(x_d4))

则可以得到

3033674167600
3033674167600
3033674168160

可以明显地看出 np.asarray和np.array的不同，前者并未拷贝对象，而后者拷贝了对象。

具体到此例上，由于源对象不是np.ndarray，所以在此处使用np.array和np.asarray并无区别。

2.2 可视化背景等高线图的生成

教程中提供了生成可视化背景等高线图的代码，这段代码非常MATLAB。

x = np.arange(-200, -100, 1)
y = np.arange(-5, 5, 0.1)
Z = np.zeros((len(x), len(y)))
X, Y = np.meshgrid(x, y)

上述代码先生成 $w$ 及 $b$ 的绘图网格，随后进行每个网格点的残差计算。

# loss
for i in range(len(x)):
    for j in range(len(y)):
        b = x[i]
        w = y[j]
        Z[j][i] = 0  # meshgrid吐出结果：y为行，x为列
        for n in range(len(x_data)):
            Z[j][i] += (y_data[n] - b - w * x_data[n]) ** 2
        Z[j][i] /= len(x_data)

上述这段代码是TA提供的代码，事实上这段代码非常不python，用了太多的for loops，这会使得计算效率很低。使用ipython的$$timeitmagic也可以看出其计算效率不高：
在这里插入图片描述
这段代码是可以改写的，可以充分利用numpy的broadcast及矩阵运算来提高运行效率。

此处先使用二维矩阵来实现这一点：

x1 = x[np.newaxis,:]
y1 = y[:,np.newaxis]
Z2 = np.zeros((len(x), len(y)))
for n in range(len(x_data)):
    Z2 += (y_data[n] - x1 - y1 * x_data[n]) ** 2
Z2 /= len(x_data)

速度有了质的飞跃（提速超1000倍）。
在这里插入图片描述
同样地，也可以使用三维矩阵。

x1 = x[np.newaxis,:,np.newaxis]
y1 = y[:,np.newaxis,np.newaxis]
Z3 = np.zeros((len(x), len(y)))
x_data2 = x_d[np.newaxis,np.newaxis,:]#np.expand_dims(x_d[np.newaxis,:], axis=0)
y_data2 = y_d[np.newaxis,np.newaxis,:]
Z3 = np.mean((y_data2 - x1 - y1 * x_data2) ** 2,axis = 2)

速度相较原来也有很大提升，但有趣的是，相较二维反而变慢了。
在这里插入图片描述
可以画出如下的等高线图

2.3 回归模型的建立

可以定义回归模型函数

def train(b, w, lr, iteration):
    b_history = []
    w_history = []
    loss_history = []
    
    for i in range(iteration):
        b_history.append(b)
        w_history.append(w)
        
        m = len(x_d)
        y_hat = w * x_d  + b
        loss = np.dot(y_d - y_hat, y_d - y_hat) / m
        grad_b = -2.0 * np.sum(y_d - y_hat) / m
        grad_w = -2.0 * np.dot(y_d - y_hat, x_d) / m
        # update param
        b -= lr * grad_b
        w -= lr * grad_w

        loss_history.append(loss)
  
    return b_history, w_history, loss_history

及结果绘图函数

def draw(b_history, w_history, loss_history):
    plt.figure(figsize = (8,6))
    plt.contourf(x, y, Z, 50, alpha=0.5, cmap=plt.get_cmap('jet'))  # 填充等高线
    plt.plot([-188.4], [2.67], 'x', ms=12, mew=3, color="orange")
    plt.plot(b_history, w_history, 'o-', ms=3, lw=1.5, color='black')
    plt.xlim(-200, -100)
    plt.ylim(-5, 5)
    plt.xlabel(r'$b$')
    plt.ylabel(r'$w$')
    plt.title("线性回归")
    
    plt.figure(figsize = (8,6))
    plt.plot(range(iteration), np.log(loss_history))
    plt.xlabel(r'$iteration$')
    plt.ylabel(r'$loss(log10)$')
    plt.title("损失函数")
    
    x_predict = np.arange(0,650,1)
    y_predict = b_history[-1] + w_history[-1] * x_predict
    
    plt.figure(figsize = (8,6))
    plt.plot(x_d, y_d, "o")
    plt.plot(x_predict, y_predict)
    plt.xlabel(r'$x$')
    plt.ylabel(r'$y$')
    plt.title("拟合结果")

接下来分别对三组参数进行试验。

学习率0.000001

b=-120
w=-4
lr = 0.000001
iteration = 140000

经过14000次计算后
在这里插入图片描述

并未求得最优解

学习率0.00001（增大十倍）

b=-120
w=-4
lr = 0.00001
iteration = 140000

经过14000次计算后
在这里插入图片描述

更接近最优解了，但出现了一定程度的振荡。

学习率0.0001（再增大十倍）

b=-120
w=-4
lr = 0.0001
iteration = 140000

经过14000次计算后
在这里插入图片描述

振荡相当明显。

由此可以看出，并不是一味增加学习率就可以达到快速学到结果的目的。

2.4 学习率的优化

TA提供了一种动态计算学习率的方法（Adagrad）。

Adagrad是一种基于梯度的优化算法：它将学习速率与参数相适应，对频繁参数的罕见更新和较小更新执行更大的更新。因此，它非常适合处理稀疏数据。

# linear regression
b = -120
w = -4
lr = 1
iteration = 100000

b_history = []
w_history = []
loss_history = []

lr_b=0
lr_w=0

for i in range(iteration):
    b_history.append(b)
    w_history.append(w)
    
    m = len(x_d)
    y_hat = w * x_d  + b
    loss = np.dot(y_d - y_hat, y_d - y_hat) / m
    
    b_grad = -np.sum(2.0 * (y_d - b - w * x_d) * 1.0)
    w_grad = -np.sum(2.0 * (y_d - b - w * x_d) * x_d)
    
    lr_b = lr_b + b_grad ** 2
    lr_w = lr_w + w_grad ** 2
    # update param
    b -= lr / np.sqrt(lr_b) * b_grad
    w -= lr / np.sqrt(lr_w) * w_grad

    loss_history.append(loss)
    
draw(b_history, w_history, loss_history)