PyTorch教程-12.1. 优化和深度学习

在本节中，我们将讨论优化与深度学习之间的关系以及在深度学习中使用优化的挑战。对于一个深度学习问题，我们通常会先定义一个 损失函数。一旦我们有了损失函数，我们就可以使用优化算法来尝试最小化损失。在优化中，损失函数通常被称为优化问题的目标函数。按照传统和约定，大多数优化算法都与最小化有关。如果我们需要最大化目标，有一个简单的解决方案：只需翻转目标上的标志。

12.1.1。优化目标

尽管优化为深度学习提供了一种最小化损失函数的方法，但从本质上讲，优化和深度学习的目标是根本不同的。前者主要关注最小化目标，而后者关注在给定有限数据量的情况下找到合适的模型。在 第 3.6 节中，我们详细讨论了这两个目标之间的区别。例如，训练误差和泛化误差通常不同：由于优化算法的目标函数通常是基于训练数据集的损失函数，因此优化的目标是减少训练误差。然而，深度学习（或更广泛地说，统计推断）的目标是减少泛化误差。为了完成后者，除了使用优化算法来减少训练误差外，我们还需要注意过度拟合。

%matplotlib inline
import numpy as np
import torch
from mpl_toolkits import mplot3d
from d2l import torch as d2l

%matplotlib inline
from mpl_toolkits import mplot3d
from mxnet import np, npx
from d2l import mxnet as d2l

npx.set_np()

%matplotlib inline
import numpy as np
import tensorflow as tf
from mpl_toolkits import mplot3d
from d2l import tensorflow as d2l

为了说明上述不同的目标，让我们考虑经验风险和风险。如第 4.7.3.1 节所述 ，经验风险是训练数据集的平均损失，而风险是整个数据群的预期损失。下面我们定义两个函数：风险函数f和经验风险函数g。假设我们只有有限数量的训练数据。结果，这里g 不如 平滑f。

def f(x):
  return x * torch.cos(np.pi * x)

def g(x):
  return f(x) + 0.2 * torch.cos(5 * np.pi * x)

def f(x):
  return x * np.cos(np.pi * x)

def g(x):
  return f(x) + 0.2 * np.cos(5 * np.pi * x)

def f(x):
  return x * tf.cos(np.pi * x)

def g(x):
  return f(x) + 0.2 * tf.cos(5 * np.pi * x)

下图说明了训练数据集上经验风险的最小值可能与风险的最小值（泛化误差）位于不同的位置。

def annotate(text, xy, xytext): #@save
  d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,
              arrowprops=dict(arrowstyle='->'))

x = torch.arange(0.5, 1.5, 0.01)
d2l.set_figsize((4.5, 2.5))
d2l.plot(x, [f(x), g(x)], 'x', 'risk')
annotate('min ofnempirical risk', (1.0, -1.2), (0.5, -1.1))
annotate('min of risk', (1.1, -1.05), (0.95, -0.5))

def annotate(text, xy, xytext): #@save
  d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,
              arrowprops=dict(arrowstyle='->'))

x = np.arange(0.5, 1.5, 0.01)
d2l.set_figsize((4.5, 2.5))
d2l.plot(x, [f(x), g(x)], 'x', 'risk')
annotate('min ofnempirical risk', (1.0, -1.2), (0.5, -1.1))
annotate('min of risk', (1.1, -1.05), (0.95, -0.5))

def annotate(text, xy, xytext): #@save
  d2l.plt.gca().annotate(text, xy=xy, xytext=xytext,
              arrowprops=dict(arrowstyle='->'))

x = tf.range(0.5, 1.5, 0.01)
d2l.set_figsize((4.5, 2.5))
d2l.plot(x, [f(x), g(x)], 'x', 'risk')
annotate('min ofnempirical risk', (1.0, -1.2), (0.5, -1.1))
annotate('min of risk', (1.1, -1.05), (0.95, -0.5))

12.1.2。深度学习中的优化挑战

在本章中，我们将特别关注优化算法在最小化目标函数方面的性能，而不是模型的泛化误差。在 3.1 节中，我们区分了优化问题中的解析解和数值解。在深度学习中，大多数目标函数都很复杂，没有解析解。相反，我们必须使用数值优化算法。本章的优化算法都属于这一类。

深度学习优化有很多挑战。一些最令人烦恼的是局部最小值、鞍点和梯度消失。让我们来看看它们。

12.1.2.1。局部最小值

对于任何目标函数f(x), 如果值f(x)在 x小于的值f(x)在附近的任何其他点x， 然后f(x)可能是局部最小值。如果值f(x)在x是整个域内目标函数的最小值，则f(x)是全局最小值。

例如，给定函数

(12.1.1)f(x)=x⋅cos(πx)for−1.0≤x≤2.0,

我们可以逼近这个函数的局部最小值和全局最小值。

x = torch.arange(-1.0, 2.0, 0.01)
d2l.plot(x, [f(x), ], 'x', 'f(x)')
annotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))
annotate('global minimum', (1.1, -0.95), (0.6, 0.8))

x = np.arange(-1.0, 2.0, 0.01)
d2l.plot(x, [f(x), ], 'x', 'f(x)')
annotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))
annotate('global minimum', (1.1, -0.95), (0.6, 0.8))

x = tf.range(-1.0, 2.0, 0.01)
d2l.plot(x, [f(x), ], 'x', 'f(x)')
annotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))
annotate('global minimum', (1.1, -0.95), (0.6, 0.8))

深度学习模型的目标函数通常有很多局部最优值。当优化问题的数值解接近局部最优时，随着目标函数解的梯度趋近或变为零，最终迭代得到的数值解可能只会局部最小化目标函数，而不是全局最小化。只有某种程度的噪声可能会使参数超出局部最小值。事实上，这是小批量随机梯度下降的有益特性之一，其中小批量梯度的自然变化能够将参数从局部最小值中移除。

12.1.2.2。鞍点

除了局部最小值，鞍点是梯度消失的另一个原因。鞍点是函数的所有梯度都消失但既不是全局最小值也不是局部最小值的任何位置。考虑函数f(x)=x3. 它的一阶和二阶导数消失为x=0. 优化可能会在此时停止，即使它不是最小值。

x = torch.arange(-2.0, 2.0, 0.01)
d2l.plot(x, [x**3], 'x', 'f(x)')
annotate('saddle point', (0, -0.2), (-0.52, -5.0))

x = np.arange(-2.0, 2.0, 0.01)
d2l.plot(x, [x**3], 'x', 'f(x)')
annotate('saddle point', (0, -0.2), (-0.52, -5.0))

x = tf.range(-2.0, 2.0, 0.01)
d2l.plot(x, [x**3], 'x', 'f(x)')
annotate('saddle point', (0, -0.2), (-0.52, -5.0))

更高维度的鞍点更加隐蔽，如下例所示。考虑函数f(x,y)=x2−y2. 它的鞍点位于(0,0). 这是相对于y和最低限度x. 此外，它看起来像一个马鞍，这就是这个数学性质得名的地方。

x, y = torch.meshgrid(
  torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))
z = x**2 - y**2

ax = d2l.plt.figure().add_subplot(111, projection='3d')
ax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})
ax.plot([0], [0], [0], 'rx')
ticks = [-1, 0, 1]
d2l.plt.xticks(ticks)
d2l.plt.yticks(ticks)
ax.set_zticks(ticks)
d2l.plt.xlabel('x')
d2l.plt.ylabel('y');

x, y = np.meshgrid(
  np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))
z = x**2 - y**2

ax = d2l.plt.figure().add_subplot(111, projection='3d')
ax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(),
         **{'rstride': 10, 'cstride': 10})
ax.plot([0], [0], [0], 'rx')
ticks = [-1, 0, 1]
d2l.plt.xticks(ticks)
d2l.plt.yticks(ticks)
ax.set_zticks(ticks)
d2l.plt.xlabel('x')
d2l.plt.ylabel('y');

x, y = tf.meshgrid(
  tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))
z = x**2 - y**2

ax = d2l.plt.figure().add_subplot(111, projection='3d')
ax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})
ax.plot([0], [0], [0], 'rx')
ticks = [-1, 0, 1]
d2l.plt.xticks(ticks)
d2l.plt.yticks(ticks)
ax.set_zticks(ticks)
d2l.plt.xlabel('x')
d2l.plt.ylabel('y');

我们假设函数的输入是k维向量，它的输出是一个标量，所以它的 Hessian 矩阵有k 特征值。函数的解可以是局部最小值、局部最大值或函数梯度为零的位置处的鞍点：

当函数的 Hessian 矩阵在零梯度位置的特征值都为正时，函数有一个局部最小值。

当函数的 Hessian 矩阵在零梯度位置的特征值全部为负时，我们有函数的局部最大值。

当函数的 Hessian 矩阵在零梯度位置的特征值分别为负和正时，我们就有了函数的鞍点。

对于高维问题，至少某些特征值为负的可能性非常高。这使得鞍点比局部最小值更有可能。我们将在下一节介绍凸性时讨论这种情况的一些例外情况。简而言之，凸函数是那些 Hessian 矩阵的特征值从不为负的函数。但遗憾的是，大多数深度学习问题并不属于这一类。尽管如此，它还是研究优化算法的好工具。

12.1.2.3。消失的渐变

可能遇到的最隐蔽的问题是梯度消失。回忆一下我们在5.1.2 节中常用的激活函数及其派生函数。例如，假设我们要最小化函数f(x)=tanh⁡(x)我们碰巧开始于x=4. 正如我们所见，梯度f接近于零。进一步来说， f′(x)=1−tanh2⁡(x)因此f′(4)=0.0013. 因此，在我们取得进展之前，优化将停滞很长时间。事实证明，这是在引入 ReLU 激活函数之前训练深度学习模型非常棘手的原因之一。

x = torch.arange(-2.0, 5.0, 0.01)
d2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')
annotate('vanishing gradient', (4, 1), (2, 0.0))

x = np.arange(-2.0, 5.0, 0.01)
d2l.plot(x, [np.tanh(x)], 'x', 'f(x)')
annotate('vanishing gradient', (4, 1), (2, 0.0))

x = tf.range(-2.0, 5.0, 0.01)
d2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')
annotate('vanishing gradient', (4, 1), (2, 0.0))

正如我们所见，深度学习的优化充满挑战。幸运的是，存在一系列强大的算法，它们性能良好并且即使对于初学者也易于使用。此外，并不是真的有必要找到最佳解决方案。其局部最优甚至近似解仍然非常有用。

12.1.3。概括

最小化训练误差并不能保证我们找到最佳参数集来最小化泛化误差。

优化问题可能有很多局部极小值。

该问题可能有更多的鞍点，因为通常问题不是凸的。

消失的梯度会导致优化停止。问题的重新参数化通常会有所帮助。参数的良好初始化也可能是有益的。

12.1.4。练习

考虑一个简单的 MLP，它有一个隐藏层，比方说，d 隐藏层中的维度和单个输出。表明对于任何局部最小值，至少有d!行为相同的等效解决方案。

假设我们有一个对称随机矩阵M 条目在哪里Mij=Mji每个都是从一些概率分布中得出的pij. 此外假设 pij(x)=pij(−x)，即分布是对称的（有关详细信息，请参见例如Wigner ( 1958 )）。

证明特征值的分布也是对称的。也就是说，对于任何特征向量v相关特征值的概率λ满足 P(λ>0)=P(λ<0).

为什么上面没有暗示P(λ>0)=0.5？

您还能想到深度学习优化中涉及的其他哪些挑战？

假设您想要在（真实的）鞍座上平衡一个（真实的）球。

为什么这很难？

您能否将这种效应也用于优化算法？