笔记：动手学深度学习pytorch（优化算法进阶，word2vec，词嵌入进阶）

- 优化算法进阶

- Momentum

目标函数有关自变量的梯度代表了目标函数在自变量当前位置下降最快的方向。因此，梯度下降也叫作最陡下降（steepest descent）。在每次迭代中，梯度下降根据自变量当前位置，沿着当前位置的梯度更新自变量。然而，如果自变量的迭代方向仅仅取决于自变量当前位置，这可能会带来一些问题。对于noisy gradient,我们需要谨慎的选取学习率和batch size, 来控制梯度方差和收敛的结果。
${\mathbf{g}}_t={\partial }_{\mathbf{w}}\frac{1}{|{\mathcal{B}}_t|}{\sum }_{i\in {\mathcal{B}}_t}f({\mathbf{x}}_i,{\mathbf{w}}_{t-1})=\frac{1}{|{\mathcal{B}}_t|}{\sum }_{i\in {\mathcal{B}}_t}{\mathbf{g}}_{i,t-1}.$

- An ill-conditioned Problem

Condition Number of Hessian Matrix:
$con{d}_H=\frac{{\lambda }_{max}}{{\lambda }_{min}}$

where ${\lambda }_{max},{\lambda }_{min}$ is the maximum amd minimum eignvalue of Hessian matrix.

让我们考虑一个输入和输出分别为二维向量$\mathbf{x}=[x_1,x_2{]}^{\top }$和标量的目标函数:

$f(\mathbf{x})=0.1x_1^2+2x_2^2$
$con{d}_H=\frac{4}{0.2}=20\to \text{ill-conditioned}$

- Maximum Learning Rate

• For $f(x)$, according to convex optimizaiton conclusions, we need step size $\eta$.
• To guarantee the convergence, we need to have $\eta$.

- Supp: Preconditioning

在二阶优化中，我们使用Hessian matrix的逆矩阵(或者pseudo inverse)来左乘梯度向量$i.e.{\Delta }_x=H^{-1}\mathbf{g}$，这样的做法称为precondition，相当于将 映射为一个单位矩阵，拥有分布均匀的Spectrum，也即我们去优化的等价标函数的Hessian matrix为良好的identity matrix。

%matplotlib inline
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l
import torch

eta = 0.4

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

def gd_2d(x1, x2, s1, s2):
    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)

d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))

可以看到，同一位置上，目标函数在竖直方向（$x_2$轴方向）比在水平方向（$x_1$轴方向）的斜率的绝对值更大。因此，给定学习率，梯度下降迭代自变量时会使自变量在竖直方向比在水平方向移动幅度更大。那么，我们需要一个较小的学习率从而避免自变量在竖直方向上越过目标函数最优解。然而，这会造成自变量在水平方向上朝最优解移动变慢。

下面我们试着将学习率调得稍大一点，此时自变量在竖直方向不断越过最优解并逐渐发散。

- Solution to ill-condition

• Preconditioning gradient vector: applied in Adam, RMSProp, AdaGrad, Adelta, KFC, Natural gradient and other secord-order optimization algorithms.
• Averaging history gradient: like momentum, which allows larger learning rates to accelerate convergence; applied in Adam, RMSProp, SGD momentum.

eta = 0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))

- Momentum Algorithm

动量法的提出是为了解决梯度下降的上述问题。设时间步$t$的自变量为$x_t$，学习率为${\eta }_t$。在时间步$t=0$，动量法创建速度变量m_0，并将其元素初始化成$t>0$。在时间步 ，动量法对每次迭代的步骤做如下修改：
$\begin{array}{rl}{\mathbf{m}}_t& \leftarrow \beta {\mathbf{m}}_{t-1}+{\eta }_t{\mathbf{g}}_t,\\ {\mathbf{x}}_t& \leftarrow {\mathbf{x}}_{t-1}-{\mathbf{m}}_t,\end{array}$

Another version:
$\begin{array}{rl}{\mathbf{m}}_t& \leftarrow \beta {\mathbf{m}}_{t-1}+(1-\beta ){\mathbf{g}}_t,\\ {\mathbf{x}}_t& \leftarrow {\mathbf{x}}_{t-1}-{\alpha }_t{\mathbf{m}}_t,\end{array}$
${\alpha }_t=\frac{{\eta }_t}{1-\beta }$
其中，动量超参数$\beta$满足$0\le \beta <1$，当$\beta =0$时，动量法等价于小批量随机梯度下降
在解释动量法的数学原理前，让我们先从实验中观察梯度下降在使用动量法后的迭代轨迹

def momentum_2d(x1, x2, v1, v2):
    v1 = beta * v1 + eta * 0.2 * x1
    v2 = beta * v2 + eta * 4 * x2
    return x1 - v1, x2 - v2, v1, v2

eta, beta = 0.4, 0.5
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))

可以看到使用较小的学习率$\eta =$和动量超参数$\beta =0.5$时，动量法在竖直方向上的移动更加平滑，且在水平方向上更快逼近最优解。下面使用较大的学习率$\eta =0.6$，此时自变量也不再发散。

eta = 0.6
d2l.show_trace_2d(f_2d, d2l.train_2d(momentum_2d))

- Exponential Moving Average

为了从数学上理解动量法，让我们先解释一下指数加权移动平均（exponential moving average）。给定超参数$0\le \beta <1$，当前时间步$t$的变量$y_t$是上一时间步$t-1$的变量$y_{t-1}$和当前时间步另一变量$x_t$的线性组合：
$y_t=\beta y_{t-1}+(1-\beta )x_t.$
我们将$y_t$进行展开：
$\begin{array}{rl}{y}_t& =(1-\beta )x_t+\beta y_{t-1}\\ & =(1-\beta )x_t+(1-\beta )\cdot \beta x_{t-1}+{\beta }^2{y}_{t-2}\\ & =(1-\beta )x_t+(1-\beta )\cdot \beta x_{t-1}+(1-\beta )\cdot {\beta }^2{x}_{t-2}+{\beta }^3{y}_{t-3}\\ & =(1-\beta )\sum _{i=0}^t{\beta }^i{x}_{t-i}\end{array}$

$(1-\beta ){\sum }_{i=0}^t{\beta }^i=\frac{1-{\beta }^t}{1-\beta }(1-\beta )=(1-{\beta }^t)$

- Supp

Approximate Average of $\frac{1}{1-\beta }$ Steps
令$n=1/(1-\beta )$，由于${\lim }_{n\to \infty }{\left(1-\frac{1}{n}\right)}^n=\exp (-1)\approx 0.3679$
我们可以得到${\left(1-1/n\right)}^n={\beta }^{1/(1-\beta )}$
所以当$\beta \to 1$时，${\beta }^{1/(1-\beta )}=\exp (-1)$，如$0.95^{20}\approx \exp (-1)$，如果把$\exp (-1)$当作一个比较小的数，我们可以在近似中忽略所有含${\beta }^{1/(1-\beta )}$和比${\beta }^{1/(1-\beta )}$更高阶的系数的项。例如，当$\beta =0.95$时，
$y_t\approx 0.05{\sum }_{i=0}^{19}0.95^i{x}_{t-i}.$
因此，在实际中，我们常常将$y_t$看作是对最近$\frac{1}{1-\beta }$个时间步的$x_t$值的加权平均。例如，当$\gamma =0.95$时，$y_t$可以被看作对最近20个时间步的$x_t$值的加权平均；当$\beta =0.9$时， 可以看作是对最近10个时间步的$x_t$值的加权平均。而且，离当前时间步$t$越近的$x_t$值获得的权重越大（越接近1）。

- 由指数加权移动平均理解动量法

动量法的速度变量做变形：
${\mathbf{m}}_t\leftarrow \beta {\mathbf{m}}_{t-1}+(1-\beta )\left(\frac{{\eta }_t}{1-\beta }{\mathbf{g}}_t\right).$

Another version:
${\mathbf{m}}_t\leftarrow \beta {\mathbf{m}}_{t-1}+(1-\beta ){\mathbf{g}}_t.$
$\begin{array}{rl}{\mathbf{x}}_t& \leftarrow {\mathbf{x}}_{t-1}-{\alpha }_t{\mathbf{m}}_t,\end{array}$
${\alpha }_t=\frac{{\eta }_t}{1-\beta }$
由指数加权移动平均的形式可得，速度变量$v_t$实际上对序列 { η t − i g t − i / ( 1 − β ) : i = 0 , … , 1 / ( 1 − β ) − 1 } \{\eta_{t-i}\boldsymbol{g}_{t-i} /(1-\beta):i=0,\ldots,1/(1-\beta)-1\} {ηt−i​gt−i​/(1−β):i=0,…,1/(1−β)−1}做了指数加权移动平均。换句话说，相比于小批量随机梯度下降，动量法在每个时间步的自变量更新量近似于将前者对应的最近$1/(1-\beta )$个时间步的更新量做了指数加权移动平均后再除以$1-\beta$。所以，在动量法中，自变量在各个方向上的移动幅度不仅取决当前梯度，还取决于过去的各个梯度在各个方向上是否一致。在本节之前示例的优化问题中，所有梯度在水平方向上为正（向右），而在竖直方向上时正（向上）时负（向下）。这样，我们就可以使用较大的学习率，从而使自变量向最优解更快移动。

- Implement

相对于小批量随机梯度下降，动量法需要对每一个自变量维护一个同它一样形状的速度变量，且超参数里多了动量超参数。实现中，我们将速度变量用更广义的状态变量states表示。

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)

features, labels = get_data_ch7()

def init_momentum_states():
    v_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
    v_b = torch.zeros(1, dtype=torch.float32)
    return (v_w, v_b)

def sgd_momentum(params, states, hyperparams):
    for p, v in zip(params, states):
        v.data = hyperparams['momentum'] * v.data + hyperparams['lr'] * p.grad.data
        p.data -= v.data

动量超参数momentum设0.5

d2l.train_ch7(sgd_momentum, init_momentum_states(),
              {'lr': 0.02, 'momentum': 0.5}, features, labels)

然后把超参数momentum增大到0.9

d2l.train_ch7(sgd_momentum, init_momentum_states(),
              {'lr': 0.02, 'momentum': 0.9}, features, labels)

- Pytorch Class

在python中torch.optim.SGD已实现了Momentum。

d2l.train_pytorch_ch7(torch.optim.SGD, {'lr': 0.004, 'momentum': 0.9},
                    features, labels)

- AdaGrad

在之前介绍过的优化算法中，目标函数自变量的每一个元素在相同时间步都使用同一个学习率来自我迭代。举个例子，假设目标函数为$f$，自变量为一个二维向量$[x_1,x_2{]}^{\top }$，该向量中每一个元素在迭代时都使用相同的学习率。例如，在学习率为$\eta$的梯度下降中，元素$x_1$和$x_2$都使用相同的学习率$\eta$
来自我迭代：
$x_1\leftarrow x_1-\eta \frac{\partial f}{\partial x_1},x_2\leftarrow x_2-\eta \frac{\partial f}{\partial x_2}.$
由前面动量法，我们可以明白，如果$x_1$和$x_2$的梯度有着比较大的差别的时候，我们需要选择足够小的学习率使得自变量在梯度值较大的维度上不发散。但这样就会导致自变量在梯度值较小的维度上迭代过慢动量法依赖指数加权移动平均使得自变量的更新方向更加一致，从而降低发散的可能。本节我们介绍AdaGrad算法，它根据自变量在每个维度的梯度值的大小来调整各个维度上的学习率，从而避免统一的学习率难以适应所有维度的问题。

- Algorithm

AdaGrad算法会使用一个小批量随机梯度$g_t$按元素平方的累加变量。在时间步0，AdaGrad将$s_0$中每个元素初始化为0。在时间步$t$，首先将小批量随机梯度$g_t$按元素平方后累加到变量$s_t$：
${\mathbf{s}}_t\leftarrow {\mathbf{s}}_{t-1}+{\mathbf{g}}_t\odot {\mathbf{g}}_t,$

其中$\odot$是按元素相乘。接着，我们将目标函数自变量中每个元素的学习率通过按元素运算重新调整一下：
${\mathbf{x}}_t\leftarrow {\mathbf{x}}_{t-1}-\frac{\eta }{\sqrt{{\mathbf{s}}_t+ϵ}}\odot {\mathbf{g}}_t,$

其中$\eta$是学习率是，$ϵ$为了维持数值稳定性而添加的常数，如$10^{-6}$。这里开方、除法和乘法的运算都是按元素运算的。这些按元素运算使得目标函数自变量中每个元素都分别拥有自己的学习率。

- Feature

需要强调的是，小批量随机梯度按元素平方的累加变量出现在学习率的分母项中。因此，如果目标函数有关自变量中某个元素的偏导数一直都较大，那么该元素的学习率将下降较快；反之，如果目标函数有关自变量中某个元素的偏导数一直都较小，那么该元素的学习率将下降较慢。然而，由于$s_t$一直在累加按元素平方的梯度，自变量中每个元素的学习率在迭代过程中一直在降低（或不变）。所以，当学习率在迭代早期降得较快且当前解依然不佳时，AdaGrad算法在迭代后期由于学习率过小，可能较难找到一个有用的解。

下面我们仍然以目标函数$f(\mathbf{x})=0.1x_1^2+2x_2^2$为例观察AdaGrad算法对自变量的迭代轨迹。我们实现AdaGrad算法并使用和上一节实验中相同的学习率0.4。可以看到，自变量的迭代轨迹较平滑。但由于$s_t$的累加效果使学习率不断衰减，自变量在迭代后期的移动幅度较小。

%matplotlib inline
import math
import torch
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l

def adagrad_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6  # 前两项为自变量梯度
    s1 += g1 ** 2
    s2 += g2 ** 2
    x1 -= eta / math.sqrt(s1 + eps) * g1
    x2 -= eta / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

eta = 0.4
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))

同样的，我们把学习率增大到2。但与之前不同的是，这里自变量很快逼近了最优解。

eta = 2
d2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))

- Implement

同动量法一样，AdaGrad算法需要对每个自变量维护同它一样形状的状态变量。我们根据AdaGrad算法中的公式实现该算法。

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)
        
features, labels = get_data_ch7()

def init_adagrad_states():
    s_w = torch.zeros((features.shape[1], 1), dtype=torch.float32)
    s_b = torch.zeros(1, dtype=torch.float32)
    return (s_w, s_b)

def adagrad(params, states, hyperparams):
    eps = 1e-6
    for p, s in zip(params, states):
        s.data += (p.grad.data**2)
        p.data -= hyperparams['lr'] * p.grad.data / torch.sqrt(s + eps)

在这里我们使用更大的学习率来训练我们建立好的模型

d2l.train_ch7(adagrad, init_adagrad_states(), {'lr': 0.1}, features, labels)

- Pytorch Class

通过名称为“adagrad”的Trainer实例，我们便可使用Pytorch提供的AdaGrad算法来训练模型。

d2l.train_pytorch_ch7(torch.optim.Adagrad, {'lr': 0.1}, features, labels)

- RMSProp

因为调整学习率时分母上的变量$s_t$一直在累加按元素平方的小批量随机梯度，所以目标函数自变量每个元素的学习率在迭代过程中一直在降低（或不变）。因此，当学习率在迭代早期降得较快且当前解依然不佳时，AdaGrad算法在迭代后期由于学习率过小，可能较难找到一个有用的解。为了解决这一问题，RMSProp算法对AdaGrad算法做了修改。

- Algorithm

不同于AdaGrad算法里状态$s_t$变量是截至时间步所有小批量随机梯度$g_t$按元素平方和，RMSProp算法将这些梯度按元素平方做指数加权移动平均。具体来说，给定超参数$0\le \gamma 0$计算
${\mathbf{v}}_t\leftarrow \beta {\mathbf{v}}_{t-1}+(1-\beta ){\mathbf{g}}_t\odot {\mathbf{g}}_t.$
和AdaGrad算法一样，RMSProp算法将目标函数自变量中每个元素的学习率通过按元素运算重新调整，然后更新自变量
${\mathbf{x}}_t\leftarrow {\mathbf{x}}_{t-1}-\frac{\alpha }{\sqrt{{\mathbf{v}}_t+ϵ}}\odot {\mathbf{g}}_t,$
其中$\eta$是学习率，$ϵ$是为了维持数值稳定性而添加的常数，如。因为RMSProp算法的状态变量是对平方项${\mathbf{g}}_t\odot {\mathbf{g}}_t$的指数加权移动平均，所以可以看作是最近$1/(1-\beta )$个时间步的小批量随机梯度平方项的加权平均。如此一来，自变量每个元素的学习率在迭代过程中就不再一直降低（或不变）。

%matplotlib inline
import math
import torch
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l

def rmsprop_2d(x1, x2, s1, s2):
    g1, g2, eps = 0.2 * x1, 4 * x2, 1e-6
    s1 = beta * s1 + (1 - beta) * g1 ** 2
    s2 = beta * s2 + (1 - beta) * g2 ** 2
    x1 -= alpha / math.sqrt(s1 + eps) * g1
    x2 -= alpha / math.sqrt(s2 + eps) * g2
    return x1, x2, s1, s2

def f_2d(x1, x2):
    return 0.1 * x1 ** 2 + 2 * x2 ** 2

alpha, beta = 0.4, 0.9
d2l.show_trace_2d(f_2d, d2l.train_2d(rmsprop_2d))

- Implement

接下来我们按照公式来实现RMSProp
我们将初始学习率设为0.01，并将超参数$\gamma$设为0.9。此时，变量$s_t$可看作是最近$1/(1-0.9)=10$个时间步的平方项${\mathbf{g}}_t\odot {\mathbf{g}}_t$的加权平均。

d2l.train_ch7(rmsprop, init_rmsprop_states(), {'lr': 0.01, 'beta': 0.9},
              features, labels)

- Pytorch Class

在python中我们用gluon提供的RMSProp算法来训练模型。注意，超参数$\gamma$通过gammal指定

d2l.train_pytorch_ch7(torch.optim.RMSprop, {'lr': 0.01, 'alpha': 0.9},
                    features, labels)

- AdaDelta

AdaDelta算法针对AdaGrad算法在迭代后期可能较难找到有用解的问题做了改进，但与此同时，AdaDelta没有学习率这一超参数。

- Algorithm

AdaDelta算法使用了小批量随机梯度$g_t$按元素平方的指数加权移动平均变量$s_t$。在时间步0，它的所有元素被初始化为0。给定超参数$0\le \rho 0$

${\mathbf{s}}_t\leftarrow \rho {\mathbf{s}}_{t-1}+(1-\rho ){\mathbf{g}}_t\odot {\mathbf{g}}_t.$

AdaDelta算法维护一个额外的状态变量$\Delta {\mathbf{x}}_t$，其元素同样在时间步0时被初始化为0。我们使用$\Delta {\mathbf{x}}_{t-1}$来计算自变量的变化量：
${\mathbf{g}}_t^{\prime }\leftarrow \sqrt{\frac{\Delta {\mathbf{x}}_{t-1}+ϵ}{{\mathbf{s}}_t+ϵ}}\odot {\mathbf{g}}_t,$

其中是$ϵ$为了维持数值稳定性而添加的常数，如$10^{-5}$。接着更新自变量：
${\mathbf{x}}_t\leftarrow {\mathbf{x}}_{t-1}-{\mathbf{g}}_t^{\prime }.$
最后，我们使用$\Delta {\mathbf{x}}_t$来记录自变量${\mathbf{g}}_t^{\prime }$变化量按元素平方的指数加权移动平均：
$\Delta {\mathbf{x}}_t\leftarrow \rho \Delta {\mathbf{x}}_{t-1}+(1-\rho ){\mathbf{g}}_t^{\prime }\odot {\mathbf{g}}_t^{\prime }.$
可以看到，如不考虑$ϵ$的影响，AdaDelta算法与RMSProp算法的不同之处在于使用$\sqrt{\Delta {\mathbf{x}}_{t-1}}$来替代超参数$\eta$。

- Implement

def init_adadelta_states():
    s_w, s_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    delta_w, delta_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    return ((s_w, delta_w), (s_b, delta_b))

def adadelta(params, states, hyperparams):
    rho, eps = hyperparams['rho'], 1e-5
    for p, (s, delta) in zip(params, states):
        s[:] = rho * s + (1 - rho) * (p.grad.data**2)
        g =  p.grad.data * torch.sqrt((delta + eps) / (s + eps))
        p.data -= g
        delta[:] = rho * delta + (1 - rho) * g * g

d2l.train_ch7(adadelta, init_adadelta_states(), {'rho': 0.9}, features, labels)

- Pytorch Class

使用pytorch提供的AdaDelta算法训练。它的超参数可以通过$\rho$来指定。

d2l.train_pytorch_ch7(torch.optim.Adadelta, {'rho': 0.9}, features, labels)

- Adam

Adam算法在RMSProp算法基础上对小批量随机梯度也做了指数加权移动平均 。

- Algorithm

Adam算法使用了动量变量$m_t$和RMSProp算法中小批量随机梯度按元素平方的指数加权移动平均变量$v_t$，并在时间步0将它们中每个元素初始化为0。给定超参数$0\le {\beta }_1<1$（算法作者建议设为0.9），时间步的动量变量$m_t$即小批量随机梯度$g_t$的指数加权移动平均：
${\mathbf{m}}_t\leftarrow {\beta }_1{\mathbf{m}}_{t-1}+(1-{\beta }_1){\mathbf{g}}_t.$
和RMSProp算法中一样，给定超参数$0\le {\beta }_2<1$（算法作者建议设为0.999）， 将小批量随机梯度按元素平方后的项KaTeX parse error: Expected 'EOF', got '&' at position 40: …boldsymbol{g}_t&̲做指数加权移动平均得到v_t$：
${\mathbf{v}}_t\leftarrow {\beta }_2{\mathbf{v}}_{t-1}+(1-{\beta }_2){\mathbf{g}}_t\odot {\mathbf{g}}_t.$

由于我们将$m_0$和$s_0$中的元素都初始化为0， 在时间步$t$我们得到${\mathbf{m}}_t=(1-{\beta }_1){\sum }_{i=1}^t{\beta }_1^{t-i}{\mathbf{g}}_i$。将过去各时间步小批量随机梯度的权值相加，得到$(1-{\beta }_1){\sum }_{i=1}^t{\beta }_1^{t-i}=1-{\beta }_1^t$。需要注意的是，当较小时，过去各时间步小批量随机梯度权值之和会较小。例如，当${\beta }_1=0.9$时，${\mathbf{m}}_1=0.1{\mathbf{g}}_1$。为了消除这样的影响，对于任意时间步$t$，我们可以将$m_t$再除以$1-{\beta }_1^t$，从而使过去各时间步小批量随机梯度权值之和为1。这也叫作偏差修正。在Adam算法中，我们对变量$m_t$和$v_t$均作偏差修正：
${\hat{\mathbf{m}}}_t\leftarrow \frac{{\mathbf{m}}_t}{1-{\beta }_1^t},$

${\hat{\mathbf{v}}}_t\leftarrow \frac{{\mathbf{v}}_t}{1-{\beta }_2^t}.$

接下来，Adam算法使用以上偏差修正后的变量${\hat{\mathbf{m}}}_t$和${\hat{\mathbf{m}}}_t$，将模型参数中每个元素的学习率通过按元素运算重新调整：

${\mathbf{g}}_t^{\prime }\leftarrow \frac{\eta {\hat{\mathbf{m}}}_t}{\sqrt{{\hat{\mathbf{v}}}_t}+ϵ},$

其中$\eta$是学习率，$ϵ$是为了维持数值稳定性而添加的常数，如$10^{-8}$。和AdaGrad算法、RMSProp算法以及AdaDelta算法一样，目标函数自变量中每个元素都分别拥有自己的学习率。最后，使用$g_t^{\prime }$迭代自变量：
${\mathbf{x}}_t\leftarrow {\mathbf{x}}_{t-1}-{\mathbf{g}}_t^{\prime }.$

- Implement

Adam算法中的公式实现该算法。其中时间步通过hyperparams参数传入adam函数。

- Pytorch Class

%matplotlib inline
import torch
import sys
sys.path.append("/home/kesci/input") 
import d2lzh1981 as d2l

def get_data_ch7():  
    data = np.genfromtxt('/home/kesci/input/airfoil4755/airfoil_self_noise.dat', delimiter='\t')
    data = (data - data.mean(axis=0)) / data.std(axis=0)
    return torch.tensor(data[:1500, :-1], dtype=torch.float32), \
        torch.tensor(data[:1500, -1], dtype=torch.float32)
        
features, labels = get_data_ch7()

def init_adam_states():
    v_w, v_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    s_w, s_b = torch.zeros((features.shape[1], 1), dtype=torch.float32), torch.zeros(1, dtype=torch.float32)
    return ((v_w, s_w), (v_b, s_b))

def adam(params, states, hyperparams):
    beta1, beta2, eps = 0.9, 0.999, 1e-6
    for p, (v, s) in zip(params, states):
        v[:] = beta1 * v + (1 - beta1) * p.grad.data
        s[:] = beta2 * s + (1 - beta2) * p.grad.data**2
        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])
        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])
        p.data -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)
    hyperparams['t'] += 1

d2l.train_ch7(adam, init_adam_states(), {'lr': 0.01, 't': 1}, features, labels)

d2l.train_pytorch_ch7(torch.optim.Adam, {'lr': 0.01}, features, labels)

- word2vec

- 词嵌入基础

如果我们使用 one-hot 向量表示单词，虽然它们构造起来很容易，但通常并不是一个好选择。一个主要的原因是，one-hot 词向量无法准确表达不同词之间的相似度，如我们常常使用的余弦相似度。

Word2Vec 词嵌入工具的提出正是为了解决上面这个问题，它将每个词表示成一个定长的向量，并通过在语料库上的预训练使得这些向量能较好地表达不同词之间的相似和类比关系，以引入一定的语义信息。基于两种概率模型的假设，我们可以定义两种 Word2Vec 模型：

1. Skip-Gram 跳字模型：假设背景词由中心词生成，即建模$P(w_o\mid w_c)$，其中$w_c$为中心词，$w_o$为任一背景词；
2. CBOW (continuous bag-of-words) 连续词袋模型：假设中心词由背景词生成，即建模$P(w_c\mid {\mathcal{W}}_o)$，其中${\mathcal{W}}_o$为背景词的集合。
   

Skip-Gram 模型的实现与CBOW类似，大概由四个部分展开：

1. PTB 数据集
2. Skip-Gram 跳字模型
3. 负采样近似
4. 训练模型

- PTB数据集

Word2Vec 能从语料中学到如何将离散的词映射为连续空间中的向量，并保留其语义上的相似关系。那么为了训练 Word2Vec 模型，我们就需要一个自然语言语料库，模型将从中学习各个单词间的关系，这里我们使用经典的 PTB 语料库进行训练。PTB (Penn Tree Bank) 是一个常用的小型语料库，它采样自《华尔街日报》的文章，包括训练集、验证集和测试集。我们将在PTB训练集上训练词嵌入模型。

- 载入数据集

with open('/home/kesci/input/ptb_train1020/ptb.train.txt', 'r') as f:
    lines = f.readlines() # 该数据集中句子以换行符为分割
    raw_dataset = [st.split() for st in lines] # st是sentence的缩写，单词以空格为分割
print('# sentences: %d' % len(raw_dataset))

# 对于数据集的前3个句子，打印每个句子的词数和前5个词
# 句尾符为 '' ，生僻词全用 '' 表示，数字则被替换成了 'N'
for st in raw_dataset[:3]:
    print('# tokens:', len(st), st[:5])

- 建立词语索引

counter = collections.Counter([tk for st in raw_dataset for tk in st]) # tk是token的缩写
counter = dict(filter(lambda x: x[1] >= 5, counter.items())) # 只保留在数据集中至少出现5次的词

idx_to_token = [tk for tk, _ in counter.items()]
token_to_idx = {tk: idx for idx, tk in enumerate(idx_to_token)}
dataset = [[token_to_idx[tk] for tk in st if tk in token_to_idx]
           for st in raw_dataset] # raw_dataset中的单词在这一步被转换为对应的idx
num_tokens = sum([len(st) for st in dataset])
'# tokens: %d' % num_tokens

- 二次采样

二次采样

文本数据中一般会出现一些高频词，如英文中的“the”“a”和“in”。通常来说，在一个背景窗口中，一个词（如“chip”）和较低频词（如“microprocessor”）同时出现比和较高频词（如“the”）同时出现对训练词嵌入模型更有益。因此，训练词嵌入模型时可以对词进行二次采样。 具体来说，数据集中每个被索引词 $w_i$ 将有一定概率被丢弃，该丢弃概率为
$P(w_i)=\max (1-\sqrt{\frac{t}{f(w_i)}},0)$
其中 $f(w_i)$ 是数据集中词 $w_i$ 的个数与总词数之比，常数 $t$ 是一个超参数（实验中设为 $10^{-4}$）。可见，只有当 $f(w_i)>t$ 时，我们才有可能在二次采样中丢弃词 $w_i$，并且越高频的词被丢弃的概率越大。具体的代码如下：

def discard(idx):
    '''
    @params:
        idx: 单词的下标
    @return: True/False 表示是否丢弃该单词
    '''
    return random.uniform(0, 1) < 1 - math.sqrt(
        1e-4 / counter[idx_to_token[idx]] * num_tokens)

subsampled_dataset = [[tk for tk in st if not discard(tk)] for st in dataset]
print('# tokens: %d' % sum([len(st) for st in subsampled_dataset]))

def compare_counts(token):
    return '# %s: before=%d, after=%d' % (token, sum(
        [st.count(token_to_idx[token]) for st in dataset]), sum(
        [st.count(token_to_idx[token]) for st in subsampled_dataset]))

print(compare_counts('the'))
print(compare_counts('join'))

- 提取中心词和背景词

def get_centers_and_contexts(dataset, max_window_size):
    '''
    @params:
        dataset: 数据集为句子的集合，每个句子则为单词的集合，此时单词已经被转换为相应数字下标
        max_window_size: 背景词的词窗大小的最大值
    @return:
        centers: 中心词的集合
        contexts: 背景词窗的集合，与中心词对应，每个背景词窗则为背景词的集合
    '''
    centers, contexts = [], []
    for st in dataset:
        if len(st) < 2:  # 每个句子至少要有2个词才可能组成一对“中心词-背景词”
            continue
        centers += st
        for center_i in range(len(st)):
            window_size = random.randint(1, max_window_size) # 随机选取背景词窗大小
            indices = list(range(max(0, center_i - window_size),
                                 min(len(st), center_i + 1 + window_size)))
            indices.remove(center_i)  # 将中心词排除在背景词之外
            contexts.append([st[idx] for idx in indices])
    return centers, contexts

all_centers, all_contexts = get_centers_and_contexts(subsampled_dataset, 5)

tiny_dataset = [list(range(7)), list(range(7, 10))]
print('dataset', tiny_dataset)
for center, context in zip(*get_centers_and_contexts(tiny_dataset, 2)):
    print('center', center, 'has contexts', context)

- Skip-Gram 跳字模型

在跳字模型中，每个词被表示成两个 $d$ 维向量，用来计算条件概率。假设这个词在词典中索引为 $i$ ，当它为中心词时向量表示为 ${\mathbf{v}}_i\in {\mathbb{R}}^d$，而为背景词时向量表示为 ${\mathbf{u}}_i\in {\mathbb{R}}^d$ 。设中心词 $w_c$ 在词典中索引为 $c$，背景词 $w_o$ 在词典中索引为 $o$，我们假设给定中心词生成背景词的条件概率满足下式：

$P(w_o\mid w_c)=\frac{\exp ({\mathbf{u}}_o^{\top }{\mathbf{v}}_c)}{{\sum }_{i\in \mathcal{V}}\exp ({\mathbf{u}}_i^{\top }{\mathbf{v}}_c)}$

- PyTorch 预置的 Embedding 层

embed = nn.Embedding(num_embeddings=10, embedding_dim=4)
print(embed.weight)

x = torch.tensor([[1, 2, 3], [4, 5, 6]], dtype=torch.long)
print(embed(x))

- Skip-Gram模型的前向计算

def skip_gram(center, contexts_and_negatives, embed_v, embed_u):
    '''
    @params:
        center: 中心词下标，形状为 (n, 1) 的整数张量
        contexts_and_negatives: 背景词和噪音词下标，形状为 (n, m) 的整数张量
        embed_v: 中心词的 embedding 层
        embed_u: 背景词的 embedding 层
    @return:
        pred: 中心词与背景词（或噪音词）的内积，之后可用于计算概率 p(w_o|w_c)
    '''
    v = embed_v(center) # shape of (n, 1, d)
    u = embed_u(contexts_and_negatives) # shape of (n, m, d)
    pred = torch.bmm(v, u.permute(0, 2, 1)) # bmm((n, 1, d), (n, d, m)) => shape of (n, 1, m)
    return pred

- 负采样近似

由于 softmax 运算考虑了背景词可能是词典 $\mathcal{V}$ 中的任一词，对于含几十万或上百万词的较大词典，就可能导致计算的开销过大。我们将以 skip-gram 模型为例，介绍负采样 (negative sampling) 的实现来尝试解决这个问题。

负采样方法用以下公式来近似条件概率 $P(w_o\mid w_c)=\frac{\exp ({\mathbf{u}}_o^{\top }{\mathbf{v}}_c)}{{\sum }_{i\in \mathcal{V}}\exp ({\mathbf{u}}_i^{\top }{\mathbf{v}}_c)}$：

$P(w_o\mid w_c)=P(D=1\mid w_c,w_o){\prod }_{k=1,w_k\sim P(w)}^{K}P(D=0\mid w_c,w_k)$

其中 $P(D=1\mid w_c,w_o)=\sigma ({\mathbf{u}}_o^{\top }{\mathbf{v}}_c)$，$\sigma (\cdot )$ 为 sigmoid 函数。对于一对中心词和背景词，我们从词典中随机采样 $K$ 个噪声词（实验中设 $K=5$）。根据 Word2Vec 论文的建议，噪声词采样概率 $P(w)$ 设为 $w$ 词频与总词频之比的 $0.75$ 次方。

- 词嵌入进阶

在“Word2Vec的实现”一节中，我们在小规模数据集上训练了一个 Word2Vec 词嵌入模型，并通过词向量的余弦相似度搜索近义词。虽然 Word2Vec 已经能够成功地将离散的单词转换为连续的词向量，并能一定程度上地保存词与词之间的近似关系，但 Word2Vec 模型仍不是完美的，它还可以被进一步地改进：

1. 子词嵌入（subword embedding）：FastText 以固定大小的 n-gram 形式将单词更细致地表示为了子词的集合，而 BPE (byte pair encoding) 算法则能根据语料库的统计信息，自动且动态地生成高频子词的集合；
2. GloVe 全局向量的词嵌入: 通过等价转换 Word2Vec 模型的条件概率公式，我们可以得到一个全局的损失函数表达，并在此基础上进一步优化模型。

实际中，我们常常在大规模的语料上训练这些词嵌入模型，并将预训练得到的词向量应用到下游的自然语言处理任务中。本节就将以 GloVe 模型为例，演示如何用预训练好的词向量来求近义词和类比词。

GloVe 全局向量的词嵌入

GloVe 模型

先简单回顾以下 Word2Vec 的损失函数（以 Skip-Gram 模型为例，不考虑负采样近似）：
$-{\sum }_{t=1}^T{\sum }_{-m\le j\le m,j\ne 0}\log P(w^{(t+j)}\mid w^{(t)})$
其中
$P(w_j\mid w_i)=\frac{\exp ({\mathbf{u}}_j^{\top }{\mathbf{v}}_i)}{{\sum }_{k\in \mathcal{V}}\exp ({\mathbf{u}}_k^{\top }{\mathbf{v}}_i)}$

是 $w_i$ 为中心词，$w_j$ 为背景词时 Skip-Gram 模型所假设的条件概率计算公式，我们将其简写为 $q_{ij}$。

注意到此时我们的损失函数中包含两个求和符号，它们分别枚举了语料库中的每个中心词和其对应的每个背景词。实际上我们还可以采用另一种计数方式，那就是直接枚举每个词分别作为中心词和背景词的情况：

$-{\sum }_{i\in \mathcal{V}}{\sum }_{j\in \mathcal{V}}{x}_{ij}\log q_{ij}$

其中 $x_{ij}$ 表示整个数据集中 $w_j$ 作为 $w_i$ 的背景词的次数总和。
我们还可以将该式进一步地改写为交叉熵 (cross-entropy) 的形式如下：

$-{\sum }_{i\in \mathcal{V}}{x}_i{\sum }_{j\in \mathcal{V}}{p}_{ij}\log q_{ij}$

其中 $x_i$ 是 $w_i$ 的背景词窗大小总和，$p_{ij}=x_{ij}/x_i$ 是 $w_j$ 在 $w_i$ 的背景词窗中所占的比例。

从这里可以看出，我们的词嵌入方法实际上就是想让模型学出 $w_j$ 有多大概率是 $w_i$ 的背景词，而真实的标签则是语料库上的统计数据。同时，语料库中的每个词根据 $x_i$ 的不同，在损失函数中所占的比重也不同。

注意到目前为止，我们只是改写了 Skip-Gram 模型损失函数的表面形式，还没有对模型做任何实质上的改动。而在 Word2Vec 之后提出的 GloVe 模型，则是在之前的基础上做出了以下几点改动：

1. 使用非概率分布的变量 $p_{ij}^{\prime }=x_{ij}$ 和 $q{\prime }_{ij}=\exp ({\mathbf{u}}_j^{\top }{\mathbf{v}}_i)$，并对它们取对数；
2. 为每个词 $w_i$ 增加两个标量模型参数：中心词偏差项 $b_i$ 和背景词偏差项 $c_i$，松弛了概率定义中的规范性；
3. 将每个损失项的权重 $x_i$ 替换成函数 $h(x_{ij})$，权重函数 $h(x)$ 是值域在 $[0,1]$ 上的单调递增函数，松弛了中心词重要性与 $x_i$ 线性相关的隐含假设；
4. 用平方损失函数替代了交叉熵损失函数。

综上，我们获得了 GloVe 模型的损失函数表达式：

${\sum }_{i\in \mathcal{V}}{\sum }_{j\in \mathcal{V}}h(x_{ij})({\mathbf{u}}_j^{\top }{\mathbf{v}}_i+b_i+c_j-\log x_{ij}{)}^2$

由于这些非零 $x_{ij}$ 是预先基于整个数据集计算得到的，包含了数据集的全局统计信息，因此 GloVe 模型的命名取“全局向量”（Global Vectors）之意。