Recognize Deeplearning.ai

这篇文章是我在网易云上学习吴恩达深度学习做的一些总结，我是先看了一遍视频才来做的总结，所以很多参考了黄广海博士的翻译和笔记，另外有的知识点与之前吴恩达机器学习上的有所重复，就记录得比较简单，可见这里，还有一篇笔记也我觉得也记得很好。

深度学习符号

此笔记中使用的数学符号参考自《深度学习》和 Deep learning specialization

常用的定义

• 原版符号定义中，$x^{(i)}$ 与 $x_i$ 存在混用的情况，请注意识别

数据标记与上下标

• 上标 $^{(i)}$ 代表第 $i$ 个训练样本
• 上标 $^{[l]}$ 代表第 $l$ 层
• $m$ 数据集的样本数
• 下标 $_x$ 输入数据
• 下标 $_y$ 输出数据
• $n_x$ 输入大小
• $n_y$ 输出大小 (或者类别数)
• $n_h^{[l]}$ 第 $l$ 层的隐藏单元数
• $L$ 神经网络的层数
• 在循环中
  • $n_x = n_h^{[0]}$
  • $n_y = n_h^{[L + 1]}$

神经网络模型

• $X \in \mathbb{R}^{n_x \times m}$ 代表输入的矩阵
• $x^{(i)} \in \mathbb{R}^{n_x}$ 代表第 $i$ 个样本的列向量
• $Y \in \mathbb{R}^{n_y \times m}$ 是标记矩阵
• $y^{(i)} \in \mathbb{R}^{n_y}$ 是第 $i$样本的输出标签
• $W^{[l]} \in \mathbb{R}^{l \times (l-1)}$ 代表第 $[l]$ 层的权重矩阵
• $b^{[l]} \in \mathbb{R}^{l}$ 代表第 $[l]$ 层的偏差矩阵
• $\hat{y} \in \mathbb{R}^{n_y}$ 是预测输出向量
  • 也可以用 $a^{[L]}$ 表示

正向传播方程示例

• $a = g^{[l]}(W_x x^{(i)}_ + b_1) = g^{[l]}(z_1)$.
  • 其中， $g^{[l]}$ 代表第 $l$ 层的激活函数
• $\hat{y} = softmax(W_h h + b_2)$

通用激活公式

• $a_j^{[l]} = g^{[l]}(z_j^{[l]}) = g^{[l]}(\sum_k w_{jk}^{[l]}a_k^{[l-1]} + b_j^{[l]})$.
  • $j$ 当前层的维度
  • $k$ 上一层的维度

损失函数

• $J(x, W, b, y)$ 或者 $J(\hat{y}, y)$
• 常见损失函数示例
  • $J_{CE}(\hat{y}, y) = -\sum_{i=0}^m y^{(i)}log\hat{y}^{(i)}$.
  • $J_1(\hat{y}, y) = -\sum_{i=0}^m |y^{(i)} - \hat{y}^{(i)}|$.

深度学习图示

• 节点：代表输入、激活或者输出
• 边：代表权重或者误差

提供两种等效的示意图

详细的网络

常用于神经网络的表示,为了更好的审美，我们省略了一些在边上的参数的细节(如$w_{ij}^{[l]}$ 和$b_{i}^{[l]}$等)。

简化网络

两层神经网络的更简单的表示。

神经网络和深度学习

神经网络基础

激活函数

为什么神经网络需要非线性激活函数？为了产生非线性映射关系拟合更加丰富的函数。

类型

传统使用的激活函数是sigmoid，与tanh一样可以将值映射到-1到+1之间。结果表明在隐藏层上使用tanh函数效果上往往比sigmoid要好，因为tanh的均值更接近于0而不是0.5。事实上，可以将tanh看作是sigmoid函数向下平移和伸缩后的结果。sigmoid函数和tanh函数两者共同的缺点是，在$z$特别大或者特别小的情况下，导数的梯度或者函数的斜率会变得特别小，最后就会接近于0，导致梯度消失。

后来衍生出了另一个激活函数ReLU(Rectified Linear Unit)，以及另一个版本Leaky ReLU，这个函数通常比ReLU激活效果要好，因为Relu进入负半区的时候，梯度为0，神经元此时不会训练，产生所谓的稀疏性，而Leaky ReLu不会有这问题。但是在实际中Leaky ReLu用的并不多，虽然它的训练效果比较好，但是同样的它会增加计算量。

这两者相比sigmoid和tanh的优点在于：

• 在$z$的区间变动很大的情况下，激活函数的导数或者激活函数的斜率都会远大于0，另外使用ReLu激活函数神经网络通常会比使用sigmoid或者tanh激活函数学习的更快。
• sigmoid和tanh函数的导数在正负饱和区的梯度都会接近于0，这会造成梯度消失，而Relu和Leaky ReLu函数大于0部分都为常数，不会产生梯度消失现象。

选择激活函数的一些经验法则：

• 对于sigmoid如果输出是0、1值（二分类问题），则输出层选择sigmoid函数，然后其它的所有单元都选择Relu函数。
• tanh激活函数：tanh是非常优秀的，几乎适合所有场合。
• ReLu激活函数：最常用的默认函数，，如果不确定用哪个激活函数，就使用ReLu或者Leaky ReLu。

导数

sigmoid

$$\frac{d}{dz}g(z) = \frac{1}{1 + e^{-z}} (1-\frac{1}{1 + e^{-z}})=g(z)(1-g(z))$$

注：

• 当$z$ = 10或$z= -10$ ; $\frac{d}{dz}g(z)\approx 0$

• 当$z $= 0 , $\frac{d}{dz}g(z)=g(z)(1-g(z))=\frac{1}{4}$

tanh

$$g(z) = tanh(z) = \frac{e^{z} - e^{-z}}{e^{z} + e^{-z}} \\ \frac{d}{dz}g(z) = 1 - (tanh(z))^{2}$$

注：

• 当$z$ = 10或$z= -10$ $\frac{d}{dz}g(z)\approx 0$

• 当$z$ = 0, $\frac{d}{dz}g(z)=1-0=1$

ReLU

$$g(z) =max (0,z)\\ g(z)^{'}= \begin{cases} 0& \text{if z < 0}\\ 1& \text{if z > 0}\\ undefined& \text{if z = 0} \end{cases}$$

注：

• 通常在$z = 0$的时候给定其导数

权重初始化

随机初始化：防止相同常数项对称问题（symmetry breaking problem）

前向传播和反向传播

正向传播

步骤：

$$\begin{align} &z^{[l]}=W^{[l]}\cdot a^{[l-1]}+b^{[l]}\\ &a^{[l]}=g^{[l]}\left( z^{[l]}\right) \end{align}$$

向量化：

$$\begin{align} &z^{[l]}=W^{[l]}\cdot A^{[l-1]}+b^{[l]}\\ &A^{[l]}=g^{[l]}(Z^{[l]})\\ \end{align}$$

反向传播

步骤：

$$\begin{align} &dz^{[l]}=da^{[l]}*{g^{[l]}}'(z^{[l]})\\ &dw^{[l]}=dz^{[l]}\cdot a^{[l-1]}\\ &db^{[l]}=dz^{[l]}\\ &da^{[l-1]}=w^{\left[ l \right]T}\cdot dz^{[l]}\\ &dz^{[l]}=w^{[l+1]T}dz^{[l+1]}\cdot{g^{[l]}}'( z^{[l]})~ \end{align}$$

向量化：

$$\begin{align} &dZ^{[l]}=dA^{[l]}*{g^{\left[ l \right]}}'\left(Z^{[l]} \right)~~\\ &dW^{[l]}=\frac{1}{m}dZ^{[l]}\cdot A^{\left[ l-1 \right]T}\\ &db^{[l]}=\frac{1}{m}np.sum(dz^{[l]},axis=1,keepdims=True)\\ &dA^{[l-1]}=W^{\left[ l \right]T}.dZ^{[l]} \end{align}$$

改善深层神经网络：超参数调试、正则化以及优化

深度学习的实践层面

训练，验证，测试集

在机器学习发展的小数据量时代，常见做法是将所有数据三七分，就是人们常说的70%训练集，30%测试集。如果明确设置了验证集，也可以按照60%训练集，20%验证集和20%测试集来划分。

但是在大数据时代，我们现在的数据量可能是百万级别，那么验证集和测试集占数据总量的比例会趋向于变得更小。因为验证集的目的就是验证不同的算法，检验哪种算法更有效，因此，验证集只要足够大到能评估不同的算法。

假设我们有100万条数据，其中1万条作为验证集，1万条作为测试集，100万里取1万，比例是1%，即：训练集占98%，验证集和测试集各占1%。对于数据量过百万的应用，训练集可以占到99.5%，验证和测试集各占0.25%，或者验证集占0.4%，测试集占0.1%。

就算没有测试集也不要紧，测试集的目的是对最终所选定的神经网络系统做出无偏估计，如果不需要无偏估计，也可以不设置测试集。搭建训练验证集和测试集能够加速神经网络的集成，也可以更有效地衡量算法地偏差和方差，从而帮助我们更高效地选择合适方法来优化算法。

偏差，方差

假设这就是数据集，如果给这个数据集拟合一条直线，可能得到一个逻辑回归拟合，但它并不能很好地拟合该数据，这是高偏差（high bias）的情况，我们称为“欠拟合”（underfitting）。

相反的如果我们拟合一个非常复杂的分类器，比如深度神经网络或含有隐藏单元的神经网络，可能就非常适用于这个数据集，但是这看起来也不是一种很好的拟合方式分类器方差较高（high variance），数据过度拟合（overfitting）。

高方差、高偏差示意如上图。

高偏差和高方差见上图的紫线，首先它是高偏差的，因为他几乎是线性的；其次它也是高方差的，因为这条曲线中间部分灵活性非常高，它过度拟合了这两个样本。

需要注意的地方：

高偏差和高方差是两种不同的情况，我们后续要尝试的方法也可能完全不同，我通常会用训练验证集来诊断算法是否存在偏差或方差问题，然后根据结果选择尝试部分方法。举个例子，如果算法存在高偏差问题，准备更多训练数据其实也没什么用处，至少这不是更有效的方法，所以大家要清楚存在的问题是偏差还是方差，还是两者都有问题，明确这一点有助于我们选择出最有效的方法。

在机器学习的初期阶段，关于所谓的偏差方差权衡的讨论屡见不鲜，原因是我们能尝试的方法有很多。可以增加偏差，减少方差，也可以减少偏差，增加方差，但是在深度学习的早期阶段，我们没有太多工具可以做到只减少偏差或方差却不影响到另一方。但在当前的深度学习和大数据时代，只要持续训练一个更大的网络，只要准备了更多数据，只要正则适度，通常构建一个更大的网络便可以，在不影响方差的同时减少偏差，而采用更多数据通常可以在不过多影响偏差的同时减少方差。

正则化

L2正则化

在损失函数中加入L2正则项，最小化该损失函数，让参数变得稀疏，用于削弱某些值较小的隐藏单元的影响，从而使模型变得更加简单，以达到防止过拟合的目的。

dropout 正则化

keep-prob：保留某个隐藏单元的概率

inverted dropout（反向随机失活）方法通过除以keep-prob，确保输出的期望值不变

其他正则化方法

data augmentation

包括：翻转、裁剪、扭曲、旋转、颜色失真(PCA)

early stopping

early stopping代表提早停止训练神经网络。其优点是，只运行一次梯度下降，你可以找出$w$的较小值，中间值和较大值，而无需尝试$L2$正则化超级参数$\lambda$的很多值。 其缺点是，很难再减少方差和预防过拟合之间进行权衡取舍，因为考虑的东西变得更多了。

归一化输入

第一步是零均值化，$\mu = \frac{1}{m}\sum_{i =1}^{m}x^{(i)}$，它是一个向量，$x$等于每个训练数据 $x$减去$\mu$，意思是移动训练集，直到它完成零均值化。

第二步是归一化方差，注意特征$x_{1}$的方差比特征$x_{2}$的方差要大得多，我们要做的是给$\sigma$赋值，$\sigma^{2}= \frac{1}{m}\sum_{i =1}^{m}{({x^{(i)})}^{2}}$，这是节点$y$ 的平方，$\sigma^{2}$是一个向量，它的每个特征都有方差，注意，我们已经完成零值均化，$({x^{(i)})}^{2}$元素$y^{2}$就是方差，我们把所有数据除 以向量$\sigma^{2}$，最后变成上图形式。

归一化可以使得特征的范围映射到相似的范围内，这样有助于提升优化速度。

梯度消失/爆炸

权重初始化

Xavier权重初始化：$W$ ~ $U[-\frac{\sqrt{6}}{\sqrt{n_j+n_{j+1}}}, \frac{\sqrt{6}}{\sqrt{n_j+n_{j+1}}}]$

Relu，方差为$\frac{2}{n}$，权重初始化为$\text{np.}\text{sqrt}(\frac{2}{n^{[l-1]}})$

tanh权重初始化：$\sqrt{\frac{1}{n^{[l-1]}}}$

其他：Yoshua Bengio用的是$\sqrt{\frac{2}{n^{[l-1]} + n^{\left[l\right]}}}$

梯度的数值逼近和检验

见上一篇博客，检查$\varepsilon$为$10^{-7}$下，$\frac{||d\theta_{approx}-d\theta||}{||d\theta_{approx}||_2+||d\theta||_2}$的值，$d\theta\left[i \right]$是代价函数的偏导数，$d\theta_{approx}[i]$是梯度的数值逼近

注意事项：

• 不要在训练的过程中使用，因为这会导致训练速度很慢
• 如果存在bug，需要检查每一项是否出错
• 如果使用了正则化，损失函数的计算也要加上正则项
• 不能dropout同用，这样会很难计算真实的代价函数
• 进行随机初始化；如果随机初始化值比较小，反复训练网络之后，再重新运行梯度检验。

优化算法

Mini-batch 梯度下降

为了提高优化速度，我们把训练集分隔为小一点的子集训练，这些子集被取名为mini-batch，假设每一个子集中有500万个样本，我们把其中的$x^{(1)}$到$x^{(1000)}$取出来，定义为$X^1$，称为将其称为第一个子训练集，也叫做mini-batch，这样一共有5000个mini-batch。mini-batch梯度下降做的就是每次在一个子训练集mini-batch中使用梯度下降法。

因为每次的迭代的方向并不一定朝着梯度减少的方向，所以mini-batch梯度下降的损失函数会有震荡的形状。

如果mini-batch size为n，则mini-batch梯度下降法将变为batch梯度下降法，由于每次迭代需要处理大量训练样本，所以如果样本数据量巨大的时候，单次迭代耗时会很长。

如果mini-batch size为1，则mini-batch梯度下降法将变为随机梯度下降法，随机梯度的是有很多噪声的，从平均来看，它最终会靠近最小值，但它永远不会收敛，而是会一直在最小值附近波动，因此需要根据迭代次数来调整学习率，使随机梯度下降法的结果更加接近最小值。另外使用随机梯度下降法的一个缺点是，将会失去所有向量化带来的加速，因为一次迭代只处理一个训练样本，这样效率非常低下。

如果mini-batch size在区间1到n之间，一方面mini-batch梯度下降法在样本数据量巨大的时候它的迭代速度较batch梯度下降法要更快，当然另一方面，它也不会一直朝着最小值靠近，但是它比随机梯度下降要更持续地靠近最小值的方向，它也不一定在很小的范围内收敛或者波动，同样需要学习率衰减。

指数加权平均数

关键方程$v_t=\beta v_{t-1}+(1-\beta )\theta_t$

$\beta=0.9$大概是10天的平均值，$\beta=0.98$大概是50天的平均值，计算公式$\frac{1}{1-\beta}$，经过$\frac{1}{1-\beta}$天后，原来影响的曲线先下降到$\frac{1}{1-\beta}^{\frac{1}{\beta}}\approx0.34$，换句话说，10天后，曲线的高度下降到$\frac{1}{\beta}$，相当于在峰值的$\frac{1}{e}$。

指数加权平均数公式的好处之一在于，它占用极少内存，电脑内存中只占用一行数字而已，然后把最新数据代入公式，不断覆盖就可以了。但缺点是，如果保存所有最近的温度数据，和过去10天的总和，必须占用更多的内存，执行更加复杂，计算成本也更加高昂。

偏差纠正，由于初始化$v_{0} = 0$，$v_{1} = 0.98v_{0} +0.02\theta_{1}$导致前面的值估测不准。纠正办法就是，在估测初期，不用$v_{t}$，而是用$\frac{v_{t}}{1- \beta^{t}}$，t就是现在的天数。举个具体例子，当$t=2$时，$1 - \beta^{t} = 1 - {0.98}^{2} = 0.0396$，因此对第二天温度的估测变成了$\frac{v_{2}}{0.0396} =\frac{0.0196\theta_{1} + 0.02\theta_{2}}{0.0396}$，也就是$\theta_{1}$和$\theta_{2}$的加权平均数，并去除了偏差。随着$t$增加，$\beta^{t}$接近于0，所以当$t$很大的时候，偏差修正几乎没有作用。不过在开始学习阶段，偏差修正可以帮助你更好预测值。

动量梯度下降法

目标，在横轴上学习得快一点，在纵轴上学习得慢一点。

实现细节：

在第$t$次迭代的过程中，首先计算微分$dW$，$db$。其次，计算$v_{dW}= \beta v_{dW} + \left( 1 - \beta \right)dW$，这跟之前的计算相似，也就是$v = \beta v + \left( 1 - \beta \right)\theta_{t}$，$dW$的移动平均数，接着同样地计算$v_{db}$，$v_{db} = \beta v_ + ( 1 - \beta){db}$，然后重新赋值权重，$W:= W -av_{dW}$，同样$b:= b - a v_{db}$，这样就可以减缓梯度下降的幅度。

动量梯度下降法一共有两个超参数，学习率$\alpha$以及参数$\beta$，$\beta$控制着指数加权平均数，往往取0.9。关于偏差修正，我们要拿$v_{dW}$和$v_{db}$除以$1-\beta^{t}$，在实际操作中往往会忽略偏差的影响。

有些版本会删除$1-\beta$，最后得到$v_{dW}= \beta v_{dW} +dW$，所以$v_{dW}$缩小了$1-\beta$倍，相当于乘以$\frac{1}{1- \beta}$，所以你要用梯度下降最新值的话，$a$要根据$\frac{1}{1 -\beta}$相应变化。实际上，二者效果都不错，只会影响到学习率$a$的最佳值。

RMSprop

全称是root mean square prop算法。回忆一下之前的例子，如果你执行梯度下降，虽然横轴方向正在推进，但纵轴方向会有大幅度摆动，为了分析这个例子，假设纵轴代表参数$b$，横轴代表参数$W$，可能有$W_{1}$，$W_{2}$或者其它重要的参数，为了便于理解，被称为$b$和$W$。所以，如果想减缓$b$方向的学习，即纵轴方向，同时加快，至少不是减缓横轴方向的学习，RMSprop算法可以实现这一点。

实现细节：

在第$t$次迭代中，该算法会照常计算当下mini-batch的微分$dW$，$db$，定义新符号$S_{dW}= \beta S_{dW} + (1 -\beta) {dW}^{2}$，澄清一下，这个平方的操作是针对这一整个符号的，这样做能够保留微分平方的加权平均数，同样$S_{db}= \beta S_{db} + (1 - \beta){db}^{2}$。接着RMSprop会这样更新参数值，$W:= W -a\frac{dW}{\sqrt{S_{dW}}}$，$b:=b -\alpha\frac{db}{\sqrt{S_{db}}}$

我们希望学习速度快，也就是在水平方向，我们希望$S_{dW}$会相对较小，所以我们要除以一个较小的数；我们希望减缓纵轴上的摆动，也就是在垂直方向上，我们希望$S_{db}$会相对较大，所以我们要除以一个较大的数。

RMSprop的影响就是你的更新最后会变成这样（绿色线），纵轴方向上摆动较小，而横轴方向继续推进。还有个影响就是，你可以用一个更大学习率$a$，然后加快学习，而无须在纵轴上垂直方向偏离。在实际中$dW$和$db$可能是一个高维的参数向量，但是目标都是去掉那些有摆动的方向。另外，为了确保算法不会除以0，在实际操作中往往在分母上加入一个很小很小的$\epsilon$，比如$10^{-8}$，这样有助于保证数值的稳定。

Adam 优化算法

Adam代表的是Adaptive Moment Estimation，$\beta_1$用于计算这个微分（$dW$），叫做第一矩，$\beta_2$用来计算平方数的指数加权平均数（$(dW)^2$），叫做第二矩，所以Adam的名字由此而来。

实现细节：

使用Adam算法，首先初始化，$v_{dW} = 0$，$S_{dW} =0$，$v_{db} = 0$，$S_{db} =0$，在第$t$次迭代中，计算微分，用当前的mini-batch计算$dW$，$db$，一般你会用mini-batch梯度下降法。接下来计算Momentum指数加权平均数，所以$v_{dW}= \beta_1v_{dW} + ( 1 - \beta_1)dW$（使用$\beta_1$，这样就不会跟超参数$\beta_2$混淆，因为后面RMSprop要用到$\beta_2$），同样$v_{db}= \beta_{1}v_{db} + ( 1 -\beta_{1} ){db}$。

接着用RMSprop进行更新，即用不同的超参数$\beta_2$，$S_{dW}=\beta_{2}S_{dW} + ( 1 - \beta_{2}){(dW)}^{2}$，再说一次，这里是对整个微分$dW$进行平方处理，$S_{db} =\beta_{2}S_{db} + \left( 1 - \beta_{2} \right){(db)}^{2}$。

相当于Momentum更新了超参数$\beta_1$，RMSprop更新了超参数$\beta_2$。一般使用Adam算法的时候，要计算偏差修正$v_{dW}^{corrected}= \frac{v_{dW}}{1 - \beta_1^t}$，同样$v_{db}^{corrected} =\frac{v_{db}}{1 -\beta_1^t}$。$S$也使用偏差修正，也就是$S_{dW}^{corrected} =\frac{S_{dW}}{1 - \beta_2^t}$，$S_{db}^{corrected} =\frac{S_{db}}{1 - \beta_2^t}$。

最后更新权重，所以$W$更新后是$W:= W - \alpha\frac{ v_{dW}^{corrected}}{\sqrt{S_{dW}^{corrected}} +\varepsilon}$（如果你只是用Momentum，使用$v_{dW}$或者修正后的$v_{dW}$，但现在我们加入了RMSprop的部分，所以我们要除以修正后$S_{dW}$的平方根加上$\varepsilon$）。根据类似的公式更新$b$值，$b:=b - \alpha\frac{v_{db}^{corrected}}{\sqrt{S_{db}^{corrected}} +\varepsilon}$。

本算法中有很多超参数，超参数学习率$a$很重要，也经常需要调试。$\beta_1$常用的缺省值为0.9，这是dW的移动平均数，也就是$dW$的加权平均数，这是Momentum涉及的项。至于超参数$\beta_2$，Adam论文作者，也就是Adam算法的发明者，推荐使用0.999，这是在计算$(dW)^2$以及$(db)^2$的移动加权平均值。关于$\varepsilon$的选择其实没那么重要，Adam论文的作者建议$\varepsilon$为$10^{-8}$，但你并不需要设置它，因为它并不会影响算法表现。

学习率衰减

为了解决mini-batch梯度下降法和随机梯度下降法的收敛问题，需要对学习率进行动态调整。

常规方法：$a=\frac{1}{1+decayRate\;*\;epochNum}a_0$ ，其中decay-rate称为衰减率，epoch-num为迭代数，$\alpha_{0}$为初始学习率，衰减率和初始学习率都是需要调整的超参数。

指数衰减：其中$a$相当于一个小于1的值，如$a ={0.95}^{\text{epoch-num}} a_{0}$，学习率呈指数下降

其它公式有$a =\frac{k}{\sqrt{epoch-num}}a_0$或者$a =\frac{k}{\sqrt{t}}a_0$（$t$为mini-batch的数字）。

离散下降，某个步骤有某个学习率（discrete stair cease），一会之后，学习率减少了一半，一会儿减少一半，一会儿又一半。

局部最优的问题

一个高维的神经网络，通常梯度为零的点并不是这个图中的局部最优点，实际上损失函数的零梯度点，通常是鞍点，因此我们不容易到达局部最优。

局部最优不是问题，问题在于平稳段会减缓学习，平稳段是一块区域，其中导数长时间接近于0，如果你在此处，梯度会从曲面从从上向下下降，因为梯度等于或接近0，曲面很平坦，你得花上很长时间慢慢抵达平稳段的这个点。

超参数调试、Batch正则化

调试处理

尝试使用随机值，而不是用网格搜索。因为在高维空间中，很难知道哪个超参数是相对更重要的，随机能够发现效果更好的那个。

从粗到细的进行搜索。

为超参数选择合适的范围

对搜索空间进行映射，比如在0.0001，0.001，0.01，0.1，1范围内对数轴上均匀随机取点，如果这里使用线性轴进行搜索，那么0.1~1的空间就会占据90%的搜索空间，而0.0001~0.1只有10%的搜索空间，因此使用数标尺搜索超参数的方式会更合理，做法是在-4~0之间随机取样记作$a$，再使用公式$10^a$映射到超参数所在的空间。那么如果我们想在0.9~0.999的区间进行搜索应该怎么做，考虑这个问题的方法是我们要探究的是$1-\beta$，这个值在0.1~0.001区间，这样就可以用前面所述的方法进行。

超参数调试的实践

一种是你照看一个模型，通常是有庞大的数据组，但没有许多计算资源或足够的CPU和GPU的前提下，基本而言，你一次只可以负担起试验一个模型或一小批模型。在这种情况下，即使当它在试验时，你也可以逐渐改良，比如逐渐修改它的学习率。

另一种方法则是同时试验多种模型，你设置了一些超参数，尽管让它自己运行，或者是一天甚至多天，然后你会获得像这样的学习曲线，这可以是损失函数$J$或实验误差或损失或数据误差的损失，但都是你曲线轨迹的度量。

归一化网络的激活函数

在深度学习兴起后，最重要的一个思想是它的一种算法，叫做Batch归一化，由Sergey loffe和Christian Szegedy两位研究者创造。Batch归一化会使你的参数搜索问题变得很容易，使神经网络对超参数的选择更加稳定，超参数的范围会更加庞大，工作效果也很好，也会是你的训练更加容易，甚至是深层网络。

如上，首先计算平均值，强调一下，所有这些都是针对$l$层，但省略了$l$及方括号，然后计算方差，接着，取每个$z^{(i)}$值，使其规范化。方法如下，减去均值再除以标准偏差，为了使数值稳定，通常将$\varepsilon$作为分母，以防$σ=0$的情况。

现在我们已把这些$z$值标准化，化为含平均值0和标准单位方差，所以$z$的每一个分量都含有平均值0和方差1，但我们不想让隐藏单元总是含有平均值0和方差1，也许隐藏单元有了不同的分布会有意义，所以我们所要做的就是计算，我们称之为${\tilde{z}}^{(i)}$，${\tilde{z}}^{(i)}= \gamma z_{\text{norm}}^{(i)} +\beta$，这里$\gamma$和$\beta$是你模型的学习参数，所以我们使用梯度下降或一些其它类似梯度下降的算法，比如Momentum或者Nesterov，Adam，我们将会更新$\gamma$和$\beta$，正如更新神经网络的权重一样。

请注意$\gamma$和$\beta$的作用是，我们可以随意设置${\tilde{z}}^{(i)}$的平均值，事实上，如果$\gamma= \sqrt{\sigma^{2} +\varepsilon}$，如果$\gamma$等于这个分母项（$z_{\text{norm}}^{(i)} = \frac{z^{(i)} -\mu}{\sqrt{\sigma^{2} +\varepsilon}}$中的分母），$\beta$等于$\mu$，这里的这个值是$z_{\text{norm}}^{(i)}= \frac{z^{(i)} - \mu}{\sqrt{\sigma^{2} + \varepsilon}}$中的$\mu$，那么$\gamma z_{\text{norm}}^{(i)} +\beta$的作用在于，如果这些成立（$\gamma =\sqrt{\sigma^{2} + \varepsilon},\beta =\mu$），那么${\tilde{z}}^{(i)} = z^{(i)}$。

从根本来说，这只是计算恒等函数，以构造含其它平均值和方差的隐藏单元值。

将 Batch Norm 拟合进神经网络

如上图所示，$\beta$和$\gamma$的计算介于神经元输入$z$和输出$a$之间，同时在梯度下降法中也需要更新这两值，比如$\beta$为$\beta^{[l]} = \beta^{[l]} - \alpha d\beta^{[l]}$，需要注意区别的就是不要将Batch Norm中的$\beta$与Adam优化算法中的$\beta$弄混。

实践中，Batch归一化通常和训练集的mini-batch一起使用。你应用Batch归一化的方式就是：你用第一个mini-batch($X^1$)，然后计算$z^{[1]}$，这和上张幻灯片上我们所做的一样，应用参数$w^{[1]}$和$b^{[1]}$，使用这个mini-batch($X^1$)。接着，继续第二个mini-batch($X^2$)，接着Batch归一化会减去均值，除以标准差，由${\beta}^{[1]}$和$\gamma^{[1]}$重新缩放，这样就得到了${\tilde{z}}^{[1]}$，而所有的这些都是在第一个mini-batch的基础上，你再应用激活函数得到$a^{[1]}$。然后用$w^{[2]}$和$b^{[2]}$计算$z^{[2]}$，等等，所以你做的这一切都是为了在第一个mini-batch($X^1$)上进行一步梯度下降法。

类似的工作，你会在第二个mini-batch（$X^{\left{2 \right}}$）上计算$z^{[1]}$，然后用Batch归一化来计算${\tilde{z}}^{[1]}$，所以Batch归一化的此步中，你用第二个mini-batch（$X^{\left{2 \right}}$）中的数据使${\tilde{z}}^{[1]}$归一化，这里的Batch归一化步骤也是如此，让我们来看看在第二个mini-batch（$X^{\left{2 \right}}$）中的例子，在mini-batch上计算$z^{[1]}$的均值和方差，重新缩放的$\beta$和$\gamma$得到$z^{[1]}$，等等。然后在第三个mini-batch（$X^{\left{ 3 \right}}$）上同样这样做，继续训练。

澄清此参数的一个细节，即参数$b$的影响。先前提及每层的参数是$w^{[l]}$和$b^{[l]}$，还有${\beta}^{[l]}$和$\gamma^{[l]}$，首先注意计算$z$的方式如下，$z^{[l]} =w^{[l]}a^{\left\lbrack l - 1 \right\rbrack} +b^{[l]}$，而Batch归一化做的是，它要看这个mini-batch，先将$z^{[l]}$归一化，结果为均值0和标准方差，再由$\beta$和$\gamma$重缩放，但这意味着，无论$b^{[l]}$的值是多少，都是要被减去的，因为在Batch归一化的过程中，你要计算$z^{[l]}$的均值，再减去平均值，在此例中的mini-batch中增加任何常数，数值都不会改变，因为加上的任何常数都将会被均值减去所抵消。

所以，如果你在使用Batch归一化，其实你可以消除这个参数（$b^{[l]}$），或者你也可以，暂时把它设置为0，那么，参数变成$z^{[l]} = w^{[l]}a^{\left\lbrack l - 1 \right\rbrack}$，然后你计算归一化的$z^{[l]}$，${\tilde{z}}^{[l]} = \gamma^{[l]}z^{[l]} + {\beta}^{[l]}$，你最后会用参数${\beta}^{[l]}$，以便决定${\tilde{z}}^{[l]}$的取值，这就是原因。

所以总结一下，因为Batch归一化超过了此层$z^{[l]}$的均值，$b^{[l]}$这个参数没有意义，所以，你必须去掉它，由${\beta}^{[l]}$代替，这是个控制参数，会影响转移或偏置条件。

最后，请记住$z^{[l]}$的维数，因为在这个例子中，维数会是$(n^{[l]},1)$，$b^{[l]}$的尺寸为$(n^{[l]},1)$，如果是l层隐藏单元的数量，那${\beta}^{[l]}$和$\gamma^{[l]}$的维度也是$(n^{[l]},1)$，因为这是你隐藏层的数量，你有$n^{[l]}$隐藏单元，所以${\beta}^{[l]}$和$\gamma^{[l]}$用来将每个隐藏层的均值和方差缩放为网络想要的值。

Batch Norm 为什么奏效？

直观而言，BN让输入$x$获得类似的范围，这可以加速学习。另一个原因是，它可以使权重比你的网络更滞后或更深层。

一个形象的理解就是，在左边训练得很好的模块，同样在右边也运行得很好，即使存在运行都很好的同一个函数，因为如果只看左边数据的话，可能是一个线性的分类器，而不是绿色的决策边界。就好比训练出来的分类器能够很好的区分黑猫和其他非猫图片，但是不一定能在非黑猫和非猫图片很好地分类。因为黑猫和非黑猫不在同一个分布中。

所以我们想办法改变数据分布，这个想法被称为“Covariate shift”，想法是这样的，如果你已经学习了$x$到$y$ 的映射，如果$x$ 的分布改变了，那么你可能需要重新训练你的学习算法。这种做法同样适用于，如果真实函数由$x$ 到$y$ 映射保持不变，正如此例中，因为真实函数是此图片是否是一只猫，训练你的函数的需要变得更加迫切，如果真实函数也改变，情况就更糟了。

“Covariate shift”在神经网络的应用就是，神经网络隐藏层的值会受到前面输入的影响，这导致隐藏单元的值不断地改变，所以它就有了“Covariate shift”的问题，Batch归一化做的是其限制了在前层的参数更新，会影响数值分布的程度，这将减少了这些隐藏值分布变化的数量。

Batch归一化还有一个作用，它有轻微的正则化效果，Batch归一化中非直观的一件事是，每个mini-batch，我会说mini-batch$X^$的值为$z^{\lbrack t\rbrack}$，$z^{[l]}$，在mini-batch计算中，由均值和方差缩放的，因为在mini-batch上计算的均值和方差，而不是在整个数据集上，均值和方差有一些小的噪声，因为它只在你的mini-batch上计算，比如64或128或256或更大的训练例子。因为均值和方差有一点小噪音，因为它只是由一小部分数据估计得出的。缩放过程从$z^{[l]}$到${\tilde{z}}^{[l]}$，过程也有一些噪音，因为它是用有些噪音的均值和方差计算得出的。

所以和dropout相似，它往每个隐藏层的激活值上增加了噪音，dropout有增加噪音的方式，它使一个隐藏的单元，以一定的概率乘以0，以一定的概率乘以1，所以你的dropout含几重噪音，因为它乘以0或1。

对比而言，Batch归一化含几重噪音，因为标准偏差的缩放和减去均值带来的额外噪音。这里的均值和标准差的估计值也是有噪音的，所以类似于dropout，Batch归一化有轻微的正则化效果，因为给隐藏单元添加了噪音，这迫使后部单元不过分依赖任何一个隐藏单元，类似于dropout，它给隐藏层增加了噪音，因此有轻微的正则化效果。因为添加的噪音很微小，所以并不是巨大的正则化效果，可以将Batch归一化和dropout一起使用，这将得到dropout更强大的正则化效果。

也许另一个轻微非直观的效果是，如果应用了较大的mini-batch，比如说用了512而不是64，通过应用较大的min-batch，减少了噪音，因此减少了正则化效果，这是dropout的一个奇怪的性质，就是应用较大的mini-batch可以减少正则化效果。

但是不要把Batch归一化当作正则化，虽然有时它会对你的算法有额外的期望效应或非期望效应，应该把它当作归一化隐藏单元激活值并加速学习的方式，而正则化只是一个意想不到的副作用。

测试时的 Batch Norm

Batch归一化将你的数据以mini-batch的形式逐一处理，但在测试时，你可能需要对每个样本逐一处理，我们来看一下怎样调整你的网络来做到这一点。

在测试时，对应这个等式（$z_{\text{norm}}^{(i)} = \frac{z^{(i)} -\mu}{\sqrt{\sigma^{2} +\varepsilon}}$），只需要用$z$值来计算$z_{\text{norm}}^{(i)}$，用$\mu$和$\sigma^{2}$的指数加权平均，用手头的最新数值来做调整，然后就可以用刚算出来的$z_{\text{norm}}$和你在神经网络训练过程中得到的$\beta$和$\gamma$参数来计算测试样本的$\tilde{z}$值。

对于样本则需要逐步处理，方法是根据训练集估算$\mu$和$\sigma^{2}$，估算的方式有很多种，理论上可以在最终的网络中运行整个训练集来得到$\mu$和$\sigma^{2}$，但在实际操作中，通常运用指数加权平均来追踪在训练过程中的$\mu$和$\sigma^{2}$的值。还可以用指数加权平均，有时也叫做流动平均来粗略估算$\mu$和$\sigma^{2}$，然后在测试中使用$\mu$和$\sigma^{2}$的值来进行所需要的隐藏单元$z$值的调整。在实践中，不管用什么方式估算$\mu$和$\sigma^{2}$，这套过程都是比较稳健的，如果使用的是某种深度学习框架，通常会有默认的估算$\mu$和$\sigma^{2}$的方式，应该一样会起到比较好的效果。但在实践中，任何合理的估算隐藏单元$z$值的均值和方差的方式，在测试中应该都会有效。

Softmax 回归

softmax层用于对多分类做预测，计算公式为：$S_i=\frac{e^i}{\sum_je^j}$

直观来讲，它是一个线性分类器

训练一个 Softmax 分类器

举个例子，我们来看看训练集中某个样本的目标输出，真实标签是$\begin{bmatrix} 0 \ 1 \ 0 \ 0 \ \end{bmatrix}$，假设神经网络输出的是$\hat y$，$\hat y$是一个包括总和为1的概率的向量，$y = \begin{bmatrix} 0.3 \ 0.2 \ 0.1 \ 0.4 \ \end{bmatrix}$，在Softmax分类中，我们一般用到的损失函数是$L(\hat y,y ) = - \sum_{j = 1}^{4}{y_{j}log\hat y_{j}}$，在这个例子中，$L\left( \hat y,y \right) = - \sum_{j = 1}^{4}{y_{j}\log \hat y_{j}} = - y_{2}{\ log} \hat y_{2} = - {\ log} \hat y_{2}$，这就意味着，如果你的学习算法试图将它变小，因为梯度下降法是用来减少训练集的损失的，要使它变小的唯一方式就是使$-{\log}\hat y{2}$变小，要想做到这一点，就需要使$\hat y{2}$尽可能大，也就是让真实标签的输出尽可能大。

这是单个训练样本的损失，对于整个训练集的损失$J$而言，就是整个训练集损失的总和，把你的训练算法对所有训练样本的预测都加起来，$J( w^{[1]},b^{[1]},\ldots\ldots) = \frac{1}{m}\sum_{i = 1}^{m}{L( \hat y^{(i)},y^{(i)})}$，接下来要做的就是使用梯度下降法，使这里的损失最小化。

结构化机器学习项目

机器学习（ML）策略（1）

• 常见的ML策略

  • Collect more data
  • Collect more diverse training set
  • Train algorithm longer with gradient descent
  • Try Adam instead of gradient descent
  • Try bigger network
  • Try smaller network
  • Try dropout
  • Add $L_2$ regularization
  • Network architecture
    • Activation functions
    • hidden units

• 正交化，将输入特征转换到彼此之间独立的维度上，互不影响。

• 建立单一数字评估指标来评估模型，比如查全率，查准率、F1 score等

• 满足和优化指标，相当于在有约束的条件下（比如算法运行时间），算法达到的准确率要求。

• 训练/开发/测试集划分，在设立开发集和测试集时，要选择这样的开发集和测试集，能够反映你未来会得到的数据，认为很重要的数据，必须得到好结果的数据，特别是，这里的开发集和测试集可能来自同一个分布。

• 开发集和测试集的大小，全部数据用70/30比例分成训练集和测试集，或者如果你必须设立训练集、开发集和测试集，你会这么分60%训练集，20%开发集，20%测试集，在机器学习的早期，这样分是相当合理的，特别是以前的数据集大小要小得多。但在现代机器学习中，我们更习惯操作规模大得多的数据集，比如说你有1百万个训练样本，这样分可能更合理，98%作为训练集，1%开发集，1%测试集，我们用$D$和$T$缩写来表示开发集和测试集。因为如果你有1百万个样本，那么1%就是10,000个样本，这对于开发集和测试集来说可能已经够了。

• 什么时候该改变开发/测试集和指标？，具体问题具体分析。

• 贝叶斯最优错误率随着时间的推移，当继续训练算法时，可能模型越来越大，数据越来越多，但是性能无法超过某个理论上限，这就是所谓的贝叶斯最优错误率（Bayes optimal error）。贝叶斯最优错误率一般认为是理论上可能达到的最优错误率，就是说没有任何办法设计出一个$x$到$y$的函数，让它能够超过一定的准确度。为什么当你超越人类的表现时，进展会慢下来？一个原因是人类水平在很多任务中离贝叶斯最优错误率已经不远了。第二个原因是，只要你的表现比人类的表现更差，那么实际上可以使用某些工具来提高性能。一旦你超越了人类的表现，这些工具就没那么好用了。思考人类水平错误率最有用的方式之一是，把它作为贝叶斯错误率的替代或估计，但实际的贝叶斯错误率应该在人类水平错误率之下。

• 可避免偏差，贝叶斯错误率或者对贝叶斯错误率的估计和训练错误率之间的差值称为可避免偏差，用于算法在方差问题上还有多少改善空间。

• 改善你的模型表现，想要让一个监督学习算法达到实用，首先，算法对训练集的拟合很好，这可以看成是你能做到可避免偏差很低。其次，在训练集中做得很好，然后推广到开发集和测试集也很好，这就是说方差不是太大。

机器学习（ML）策略（2）

• 进行误差分析，在错误样本中，观察错误标记的样本，看看假阳性（false positives）和假阴性（false negatives），统计属于不同错误类型的错误数量进行分析。

• 清除标注错误的数据

• 快速搭建你的第一个系统，并进行迭代
• 使用来自不同分布的数据，进行训练和测试，如不同分辨率的图像

• 数据分布不匹配时，偏差与方差的分析，原因是，首先算法只见过训练集数据，没见过开发集数据。第二，开发集数据来自不同的分布，因此为了弄清楚哪个因素影响更大，所以需要对偏差和方差进行分析。假设已经设立过这样的训练集、开发集和测试集了，并且开发集和测试集来自相同的分布，但训练集来自不同的分布。接下来要做的是随机打散训练集，然后分出一部分训练集作为训练-开发集（training-dev），就像开发集和测试集来自同一分布，训练集、训练-开发集也来自同一分布。

  • 训练误差是1%，训练-开发集上的误差是9%，开发集误差是10%，这说明算法存在方差问题，因为训练-开发集的错误率是在和训练集来自同一分布的数据中测得的
  • 训练误差为1%，训练-开发误差为1.5%，开发集误差是10%，这说明算法数据分布不匹配。
  • 训练误差是10%，训练-开发误差是11%，开发误差为12%，这说明算法存在偏差问题。
  • 训练集错误率是10%，训练-开发错误率是11%，开发错误率是20%。这说明算法既有偏差问题，又有数据匹配问题。

• 处理数据不匹配问题，如人工合成数据。

• 迁移学习，神经网络可以从一个任务中习得知识，并将这些知识应用到另一个独立的任务中，这就是所谓的迁移学习。迁移学习起作用的场合是，在迁移来源问题中你有很多数据，但迁移目标问题你没有那么多数据。如果你想从任务$A$学习并迁移一些知识到任务$B$，那么当任务$A$和任务$B$都有同样的输入$x$时，迁移学习是有意义的。其次当任务$A$的数据比任务$B$多得多，迁移学习意义更大。

• 多任务学习，在迁移学习中，其步骤是串行的，即从任务$A$里学习只是然后迁移到任务$B$。在多任务学习中，则是同时开始学习的，试图让单个神经网络同时做几件事情，然后希望这里每个任务都能帮到其他所有任务。多任务学习什么时候是有意义的？
  • 第一，如果训练的一组任务，有可以共用低层次特征。对于无人驾驶的例子，同时识别交通灯、汽车和行人是有道理的，这些物体有相似的特征，也许能帮助识别停车标志，因为这些都是道路上的特征。
  • 第二，如果专注于单项任务，如果想要从多任务学习得到很大性能提升，那么其他任务加起来必须要有比单个任务大得多的数据量，这样其他任务的知识才能帮你改善这个任务的性能。
  • 第三，训练一个足够大的神经网络，为每个任务训练一个单独的神经网络。
• 端到端的深度学习，用于学习输入$x$到输出$y$之间的函数映射，优点在于不需要手工设计流水线组件，挑战在于，需要大量数据才能让系统表现良好。

卷积神经网络

卷积神经网络

计算机视觉任务

图片分类、图片识别、目标检测、图片风格迁移

边缘检测

• 垂直边缘：$\begin{bmatrix}1 & 0 & -1\\ 1 & 0 & -1\\ 1 & 0 & -1\end{bmatrix}$
• 水平边缘：$\begin{bmatrix}1 & 1 & 1\\ 0 & 0 & 0\\ -1 & -1 & -1\end{bmatrix}$
• Sobel 过滤器： $\begin{bmatrix}1 & 0 & - 1 \\ 2 & 0 & - 2 \\ 1 & 0 & - 1 \\\end{bmatrix}$
• Scharr 过滤器：$\begin{bmatrix} 3& 0 & - 3 \\ 10 & 0 & - 10 \\ 3 & 0 & - 3 \\\end{bmatrix}$

padding

如果有一个$n×n$的图像，用$f×f$的过滤器做卷积，那么输出的维度就是$(n-f+1)×(n-f+1)$。

这样的话会有两个缺点，第一个缺点是每次做卷积操作，你的图像就会缩小。第二个缺点是角落边缘的像素，这个像素点（绿色阴影标记）只被一个输出所触碰或者使用，因为它位于这个3×3的区域的一角；而中间的像素会有许多3×3的区域与之重叠。所以那些在角落或者边缘区域的像素点在输出中采用较少，意味着你丢掉了图像边缘位置的许多信息。因此需要对像素进行填充，至于选择填充多少像素，通常有两个选择，分别叫做Valid卷积和Same卷积。

• Valid卷积意味着不填充，这样的话，如果你有一个$n×n$的图像，用一个$f×f$的过滤器卷积，它将会给你一个$(n-f+1)×(n-f+1)$维的输出。
• Same卷积意味填充后，你的输出大小和输入大小是一样的。根据这个公式$n-f+1$，当你填充$p$个像素点，$n$就变成了$n+2p$，最后公式变为$n+2p-f+1$。因此如果你有一个$n×n$的图像，用$p$个像素填充边缘，输出的大小就是这样的$(n+2p-f+1)×(n+2p-f+1)$。如果你想让$n+2p-f+1=n$的话，使得输出和输入大小相等，如果你用这个等式求解$p$，那么$p=(f-1)/2$。所以当$f$是一个奇数的时候，只要选择相应的填充尺寸，你就能确保得到和输入相同尺寸的输出。

计算机视觉中，$f$通常是奇数，很少看到一个偶数的过滤器在计算机视觉里使用，这里认为有两个原因。

• 其一，如果$f$是一个偶数，那么只能使用一些不对称填充。只有$f$是奇数的情况下，Same卷积才会有自然的填充，才可以以同样的数量填充四周，而不是左边填充多一点，右边填充少一点，这样不对称的填充。
• 其二，对于奇数维过滤器，它有一个中心点，在计算机视觉里，如果有一个中心像素点会更方便，便于指出过滤器的位置。

卷积步长

如果用一个$f×f$的过滤器卷积一个$n×n$的图像，padding为$p$，步长为$s$，输出将变为$\frac{n+2p - f}{s} + 1 \times \frac{n+2p - f}{s} + 1$，注意垂直和水平方向都是这个步长。如果商不是整数，在这种情况下通常向下取整，这个原则实现的方式是，只有在卷积核完全包括在图像或填充完的图像内部时，才对它进行运算。因此为了正确计算输出维度的方法是向下取整，以免$\frac{n + 2p - f}{s}$不是整数。

三维卷积

如果你有一个$n \times n \times n_{c}$（通道数）的输入图像，这里的$n_{c}$就是通道数目，然后卷积上一个$f×f×n_{c}$，按照惯例，这个（前一个$n_{c}$）和这个（后一个$n_{c}$）必须数值相同，可以得到了$（n-f+1）×（n-f+1）×n_{c^{'}}$，这里$n_{c^{'}}$其实就是下一层的通道数，也等于使用的过滤器的个数。

单层卷积网络

在卷积层，用$f^{[l]}$表示过滤器大小，过滤器大小为$f×f$，上标$\lbrack l\rbrack$表示$l$层中过滤器大小为$f×f$。通常情况下，上标$\lbrack l\rbrack$用来标记$l$层。用$p^{[l]}$来标记padding的数量，padding数量也可指定为一个valid卷积，即无padding。或是same卷积，即选定padding，如此一来，输出和输入图片的高度和宽度就相同了。用$s^{[l]}$标记步幅。

这一层的输入会是某个维度的数据，表示为$n \times n \times n_{c}$，$n_{c}$某层上的颜色通道数。稍作修改增加上标$\lbrack l -1\rbrack$，即$n^{\left\lbrack l - 1 \right\rbrack} \times n^{\left\lbrack l -1 \right\rbrack} \times n_{c}^{\left\lbrack l - 1\right\rbrack}$，因为它是上一层的激活值。图片的高度和宽度分别用上下标$H$和$W$来标记，即$n_{H}^{\left\lbrack l - 1 \right\rbrack} \times n_{W}^{\left\lbrack l - 1 \right\rbrack} \times n_{c}^{\left\lbrack l - 1\right\rbrack}$。那么在第$l$层，图片大小为$n_{H}^{\left\lbrack l - 1 \right\rbrack} \times n_{W}^{\left\lbrack l - 1 \right\rbrack} \times n_{c}^{\left\lbrack l - 1\right\rbrack}$，$l$层的输入就是上一层的输出，因此上标要用$\lbrack l - 1\rbrack$。神经网络这一层中会有输出，它本身会输出图像。其大小为$n_{H}^{[l]} \times n_{W}^{[l]} \times n_{c}^{[l]}$，这就是输出图像的大小。

公式$\lfloor\frac{n+2p - f}{s} + 1\rfloor$（注意：（$\frac{n + 2p - f}{s} +1)$直接用这个运算结果，也可以向下取整）给出了输出图片的高度和宽度。在这个新表达式中，$l$层输出图像的高度，即$n_{H}^{[l]} = \lfloor\frac{n_{H}^{\left\lbrack l - 1 \right\rbrack} +2p^{[l]} - f^{[l]}}{s^{[l]}} +1\rfloor$，同样计算出图像的宽度，用$W$替换参数$H$，即$n_{W}^{[l]} = \lfloor\frac{n_{W}^{\left\lbrack l - 1 \right\rbrack} +2p^{[l]} - f^{[l]}}{s^{[l]}} +1\rfloor$，公式一样，只要变化高度和宽度的参数我们便能计算输出图像的高度或宽度。这就是由$n_{H}^{\left\lbrack l - 1 \right\rbrack}$推导$n_{H}^{[l]}$以及$n_{W}^{\left\lbrack l - 1\right\rbrack}$推导$n_{W}^{[l]}$的过程。

最后过滤器中通道的数量必须与输入中通道的数量一致。因此，输出通道数量就是输入通道数量，所以过滤器维度等于$f^{[l]} \times f^{[l]} \times n_{c}^{\left\lbrack l - 1 \right\rbrack}$。

用偏差和非线性函数之后，这一层的输出等于它的激活值$a^{[l]}$，也就是这个维度（输出维度）。$a^{[l]}$是一个三维体，即$n_{H}^{[l]} \times n_{W}^{[l]} \times n_{c}^{[l]}$。当执行批量梯度下降或小批量梯度下降时，如果有$m$个例子，就是有$m$个激活值的集合，那么输出$A^{[l]} = m \times n_{H}^{[l]} \times n_{W}^{[l]} \times n_{c}^{[l]}$。如果采用批量梯度下降，变量的排列顺序如下，首先是索引和训练示例，然后是其它三个变量。

对于权重参数$W$的确定，由于过滤器的维度已知，为$f^{[l]} \times f^{[l]} \times n_{c}^{[l - 1]}$，这只是一个过滤器的维度，有多少个过滤器，这（$n_{c}^{[l]}$）是过滤器的数量，权重也就是所有过滤器的集合再乘以过滤器的总数量，即$f^{[l]} \times f^{[l]} \times n_{c}^{[l - 1]} \times n_{c}^{[l]}$，损失数量L就是$l$层中过滤器的个数。

对于偏差参数$b$的确定，每个过滤器都有一个偏差参数，它是一个实数。偏差包含了这些变量，它是该维度上的一个向量。为了方便，偏差在代码中表示为一个1×1×1×$n_{c}^{[l]}$的四维向量或四维张量。

卷积有很多种标记方法，这是我们最常用的卷积符号。关于高度，宽度和通道的顺序并没有完全统一的标准卷积。有些作者会采用把通道放在首位的编码标准，有时所有变量都采用这种标准；而在某些架构中，当检索这些图片时，会有一个变量或参数来标识计算通道数量和通道损失数量的先后顺序。只要保持一致，这两种卷积标准都可用。

池化层

如果用一个$f×f$的过滤器池化一个$n×n$的图像，padding为$p$，步长为$s$，输出将变为$\frac{n+2p - f}{s} + 1 \times \frac{n+2p - f}{s} + 1$，和卷积是一样的。大部分情况下，最大池化很少用padding。目前$p$最常用的值是0，即$p=0$。最大池化的输入就是$n_{H} \times n_{W} \times n_{c}$，假设没有padding，则输出$\lfloor\frac{n_{H} - f}{s} +1\rfloor \times \lfloor\frac{n_{w} - f}{s} + 1\rfloor \times n_{c}$，输入通道与输出通道个数相同，需要注意的一点是，池化过程中没有需要学习的参数。

常用的池化层有最大池化max-pooling和平均池化average-pooling

使用卷积的原因

与只使用全连接层相比，卷积层的两个主要优势在于参数共享和稀疏连接。

全连接层存在的问题是参数非常庞大，卷积网络映射这么少参数有两个原因：

• 一是参数共享。观察发现，特征检测如垂直边缘检测如果适用于图片的某个区域，那么它也可能适用于图片的其他区域。每个特征检测器以及输出都可以在输入图片的不同区域中使用同样的参数，以便提取垂直边缘或其它特征。它不仅适用于边缘特征这样的低阶特征，同样适用于高阶特征，例如提取脸上的眼睛，猫或者其他特征对象。
• 二是稀疏连接。图中绿色框框住的0是通过3×3的卷积计算得到的，它只依赖于这个3×3的输入的单元格，右边这个红色框框住的输出单元0仅与36个输入特征中9个相连接。而且其它像素值都不会对输出产生任影响，这就是稀疏连接的概念。

神经网络可以通过这两种机制减少参数，以便我们用更小的训练集来训练它，从而预防过度拟合。

深度卷积网络：实例探究

经典网络

LeNet-5

结构如下：

layer	filter	padding	stripe	output	neuron
输入层	-	-	-	32x32x1	-
卷积层	5x5@6	0	1	28x28x6	-
池化层	2x2@6	0	2	14x14x6	-
卷积层	5x5@16	0	1	10x10x16	-
池化层	2x2@16	0	2	5x5x16	400
全连接层	-	-	-	-	120
全连接层(输出层)	-	-	-	-	84

• 激活函数使用sigmoid和tanh
• 池化层使用average pooling
• 先卷积后池化的套路
• 现在版本的LeNet-5输出层一般采用softmax激活函数，在原论文的不是，但其现在不常用。

AlexNet

结构如下：

layer	fileter	padding	stripe	output	neuron
输入层	-	-	-	227x227x3	-
卷积层	11x11@96	0	4	55x55x96	-
池化层	3x3@1	0	2	27x27x96	-
卷积层	5x5@256	same	1	27x27x256	-
池化层	3x3@1	0	2	13x13x256	-
卷积层	3x3@384	same	1	13x13x384	-
卷积层	3x3@384	same	1	13x13x384	-
卷积层	3x3@256	same	1	13x13x256	-
池化层	3x3@1	0	2	6x6x256	9216
全连接层	-	-	-	-	4096
全连接层	-	-	-	-	4096
全连接层(softmax)	-	-	-	-	1000

• 大约 60 million 个参数
• 使用ReLU作为激活函数
• LRN层后来被发现用处不大

VGGNet

vgg-16结构如下：

layer	filter	paddding	stride	output	neuron
输入层	-	-	-	224x224x3	-
卷积层x2	3x3@64	same	1	224x224x64	-
池化层	2x2@1	0	2	112x112x64	-
卷积层x2	3x3@128	same	1	112x112x128	-
池化层	2x2@1	0	2	56x56x128	-
卷积层x3	3x3@256	same	1	56x56x256	-
池化层	2x2@1	0	2	28x28x256	-
卷积层x3	3x3x512	same	1	28x28x512	-
池化层	2x2@1	0	2	14x14x512	-
卷积层x3	3x3@512	same	1	14x14x512	-
池化层	2x2@1	0	2	7x7x512	25088
全连接层x2	-	-	-	-	4096
全连接层(softmax)	-	-	-	-	1000

• 计算层数的时候不把池化层考虑进去

• 总参数1.38亿个

• 由于VGG-16的表现几乎和VGG-19不分高下，所以很多人还是会使用VGG-16

残差网络ResNet

网络结构：

• 实线的Connection部分都是执行3x3x64的卷积，他们的channel个数一致，所以采用计算方式：$Y = F(x) + x $
• 虚线的Connection部分是3x3x64和3x3x128的卷积操作，他们的channel个数不同，所以采用计算方式：$ y=F(x)+Wx $。其中$W$是卷积操作，用来调整$x$的channel维度。

Residual block:

• 计算表达式为$a^{\left\lbrack l + 2\right\rbrack} = g(z^{\left\lbrack l + 2 \right\rbrack} + a^{\left\lbrack l\right\rbrack})$

InceptionNet

1x1卷积

• 将多通道的信息归一
• 既可扩充通道数，也可减少通道数
• 用于降低计算量

Inception

• Inception网络或Inception层的作用就是代替人工来确定卷积层中的过滤器类型，或者确定是否需要创建卷积层或池化层。

结合1x1和inception

• 1x1其作为瓶颈层(bottleneck layer)用以降低计算量，如果直接使用5x5卷积，总参数会达到1.2亿，如果先使用1x1卷积，再使用5x5卷积，总参数仅仅为1240万。

• 结合1x1和inception构造出来inception module，将模块化的思想引入神经网络

• 不同inception module可能有max-pooling进行连接
• 不同分支的softmax用来做预测

目标检测

目标定位

图像分类、目标定位、目标检测：

目标标签$y$的定义如下：$y= \ \begin{bmatrix} p_{c} \\ b_{x} \\ b_{y} \\ b_{h} \\ b_{w} \\ c_{1} \\ c_{2}\\ c_{3} \\\end{bmatrix}$，第一个组件$p_{c}$表示是否含有对象，如果对象属于前三类（行人、汽车、摩托车），则$p_{c}= 1$，如果是背景，则图片中没有要检测的对象，则$p_{c} =0$。我们可以这样理解$p_{c}$，它表示被检测对象属于某一分类的概率，背景分类除外。如果检测到对象，就输出被检测对象的边界框参数$b_{x}$、$b_{y}$、$b_{h}$和$b_{w}$。最后，如果存在某个对象，那么$p_{c}=1$，同时输出$c_{1}$、$c_{2}$和$c_{3}$，表示该对象属于1-3类中的哪一类，是行人，汽车还是摩托车。边界框参数示意图如下

特征点检测

对于特征点检测，若有64个特征点，则目标标签有129个单元，第一个单元输出1或0，1表示有人脸，0表示没有人脸，然后输出（$l_{1x}$，$l_{1y}$）……直到（$l_{64x}$，$l_{64y}$）。对于人体姿态检测也是同样的道理，可以定义一些关键特征点，如胸部的中点，左肩，左肘，腰等等， 比如说，从胸部中心点($l_{1x}$，$l_{1y}$)一直往下，直到($l_{32x}$，$l_{32y}$)。。然后通过神经网络标注人物姿态的关键特征点，再输出这些标注过的特征点，就相当于输出了人物的姿态动作。

目标检测

简单滑动窗口目标检测，通过改变步长和滑动窗口大小检测目标，存在的问题：计算成本过高

滑动窗口的卷积实现

参考论文：Sermanet, Pierre, et al. “OverFeat: Integrated Recognition, Localization and Detection using Convolutional Networks.” Eprint Arxiv (2013).

回顾将全连接层转化为卷积层的过程：

动机，在滑动窗口卷积操作中存在很多重复计算，所以滑动窗口卷积操作的原理是我们不需要把输入图像分割成四个子集，分别执行前向传播，而是把它们作为一张图片输入给卷积网络进行计算，其中的公共区域可以共享很多计算。这样可以一次得到所有预测值的同时，又能提高整个算法的效率。

不过这种算法仍然存在一个缺点，就是边界框的位置可能不够准确

Bounding Box预测

上述算法存在的问题是，不能够预先知道目标物体的长宽，因此在设定边框的时候恨不准确。一个能得到更精准边界框的算法是YOLO算法，YOLO(You only look once)意思是你只看一次，这是由Joseph Redmon，Santosh Divvala，Ross Girshick和Ali Farhadi提出的算法，论文名字叫You Only Look Once: Unified, Real-Time Object Detection.

输出标签是$y= \ \begin{bmatrix} p_{c} \\ b_{x} \\ b_{y} \\ b_{h} \\ b_{w} \\ c_{1} \\ c_{2}\\ c_{3} \\\end{bmatrix}$，$p_{c}$等于0或1取决于这个绿色格子中是否有图像。然后$b_{x}$、$b_{y}$、$b_{h}$和$b_{w}$作用就是，如果那个格子里有对象，那么就给出边界框坐标。然后$c_{1}$、$c_{2}$和$c_{3}$就是想要识别的三个类别。

把对象分配到一个格子的过程是，观察对象的中点，然后将这个对象分配到其中点所在的格子，所以即使对象可以横跨多个格子，也只会被分配到9个格子其中之一，就是3×3网络的其中一个格子，或者19×19网络的其中一个格子。在19×19网格中，两个对象的中点（图中蓝色点所示）处于同一个格子的概率就会更低。

（我的理解）然后用神经网络来做回归。

交并比

交并比是一个用来评估对象检测算法的指标，交并比（loU）函数做的是计算两个边界框交集和并集之比。以下图为例，两个边界框的并集是包含两个边界框区域（绿色阴影表示区域），而交集就是这个比较小的区域（橙色阴影表示区域），那么交并比就是交集的大小，这个橙色阴影面积，然后除以绿色阴影的并集面积。

一般约定，在计算机检测任务中，如果$loU≥0.5$，就说检测正确，如果预测器和实际边界框完美重叠，loU就是1，因为交集就等于并集，所以，loU越高，边界框越精确。

非极大值抑制

到目前为止学到的对象检测中的一个问题是，算法可能对同一个对象做出多次检测，所以算法不是对某个对象检测出一次，而是检测出多次。非极大值抑制这个方法可以确保你的算法对每个对象只检测一次。

具体上，这个算法做的是，首先看看每次报告每个检测结果相关的概率$p_{c}$，实际上是$p_{c}$乘以$c_{1}$、$c_{2}$或$c_{3}$。找到概率最大的检测结果，然后定义其是最可靠的检测，之后，非极大值抑制就会逐一审视剩下的矩形，所有和这个最大的边框有很高交并比，高度重叠的其他边界框，那么这些输出就会被抑制。

如果尝试同时检测三个对象，比如说行人、汽车、摩托，那么输出向量就会有三个额外的分量。事实证明，正确的做法是独立进行三次非极大值抑制，对每个输出类别都做一次。

Anchor Boxes

到目前为止，对象检测中存在的一个问题是每个格子只能检测出一个对象，如果想让一个格子检测出多个对象，就是使用anchor box这个概念。

anchor box的思路是，这样子，预先定义两个不同形状的anchor box，或者anchor box形状，接下来要做的是把预测结果和这两个anchor box关联起来。

重新定义类别标签$y= \begin{bmatrix} p_{c} & b_{x} & b_{y} &b_{h} & b_{w} & c_{1} & c_{2} & c_{3} & p_{c} & b_{x} & b_{y} & b_{h} & b_{w} &c_{1} & c_{2} & c_{3} \\\end{bmatrix}^{T}$，前面的$p_{c},b_{x},b_{y},b_{h},b_{w},c_{1},c_{2},c_{3}$（绿色方框标记的参数）是和anchor box 1关联的8个参数，后面的8个参数（橙色方框标记的元素）是和anchor box 2相关联。

缺点：如果有两个anchor box，但在同一个格子中有三个对象，这种情况算法处理不好，而且archor box的形状需要人工指定。

YOLO 算法

YOLO算法的思想就是Bounding Box预测和Archor Boxes等上述几个概念的结合。

特殊应用：人脸识别和神经风格转换

人脸识别

One-Shot学习

目标是学习Similarity函数，该函数以两张图片作为输入，然后输出这两张图片的差异值，如果这两张图片的差一只小于某个阈值$\tau$，它是一个超参数，那么这时就能预测这两张图片是同一个人，如果差异值大于τ，就能预测这是不同的两个人，这就是解决人脸验证问题的一个可行办法。

• One-Shot Imitation Learning
• One-Shot Visual Imitation Learning via Meta-Learning
• One-Shot Imitation from Observing Humans via Domain-Adaptive Meta-Learning

Siamese 网络

对于两个不同的输入，运行相同的卷积神经网络，然后比较它们，这一般叫做Siamese网络架构。

神经网络的参数定义了一个编码函数$f(x^{(i)})$，如果给定输入图像$x^{(i)}$，这个网络会输出$x^{(i)}$的128维的编码。接下来需要做的就是学习参数，使得如果两个图片$x^{( i)}$和$x^{( j)}$是同一个人，那么你得到的两个编码的距离就小。相反，如果$x^{(i)}$和$x^{(j)}$是不同的人，那么你会想让它们之间的编码距离大一点。

Triplet 损失

要想通过学习神经网络的参数来得到优质的人脸图片编码，方法之一就是定义三元组损失函数然后应用梯度下降。三元组损失意味着你需要看Anchor图片、Positive图片(同一个人)、Negative图片(非同一个人)。

目标就是希望Anchor与Positive的距离尽可能的近，使Anchor与Negative的距离尽可能的远，用公式表达即

$$|| f(A) - f(P)||^{2} \leq ||f(A) - f(N)||^{2}$$

其中（$|| f(A) - f(P) ||^{2}$）=$d(A,P)$，（$|| f(A) - f(N) ||^{2}$）=$d(A,N)$。在实际中为了避免$0-0\le0$的情况出现，这样$f$实际没有学习到东西，而公式却成立了，所以往往将公式重新定义为

$$|| f(A) - f(P)||^{2} -||f(A) - f(N)||^{2} \leq -a$$

$a$说是一个间隔超参数，即$d(A,N)$必须要比$d(A,P)$大很多才成立，那么损失函数将定义为：

$$L( A,P,N) = max(|| f( A) - f( P)||^{2} -|| f( A) - f( N)||^{2} + a,0)$$

人脸验证与二分类

一个训练神经网络的方法是选取一对神经网络，选取Siamese网络，使其同时计算这些嵌入，比如说128维的嵌入，然后将其输入到逻辑回归单元，然后进行预测，如果是相同的人，那么输出是1，若是不同的人，输出是0。这就把人脸识别问题转换为一个二分类问题，训练这种系统时可以替换Triplet loss的方法。

定义$\hat y = \sigma(\sum_{k = 1}^{128}{w_{i}| f( x^{( i)})_{k} - f( x^{( j)})_{k}| + b})$，其中符号$f( x^{( i)})_{k}$代表图片$x^{(i)}$的编码，下标$k$代表选择这个向量中的第$k$个元素，$| f(x^{( i)})_{k} - f( x^{( j)})_{k}|$对这两个编码取元素差的绝对值。接下来可以把这128个元素当作特征，然后把他们放入逻辑回归中，最后的逻辑回归可以增加参数$w_{i}$和$b$，就像普通的逻辑回归一样。然后在这128个单元上训练合适的权重，用来预测两张图片是否是一个人，这是一个很合理的方法来学习预测0或者1，即是否是同一个人。

还有其他不同的形式来计算绿色标记的这部分公式（$| f( x^{( i)})_{k} - f( x^{( j)})_{k}|$），比如说，公式可以是$\frac{(f( x^{( i)})_{k} - f(x^{( j)})_{k})^{2}}{f(x^{( i)})_{k} + f( x^{( j)})_{k}}$，这个公式也被叫做$\chi^{2}$公式，是一个希腊字母$\chi$，也被称为$\chi$平方相似度。

总结一下，把人脸验证当作一个监督学习，创建一个只有成对图片的训练集，不是三个一组，而是成对的图片，目标标签是1表示一对图片是一个人，目标标签是0表示图片中是不同的人。利用不同的成对图片，使用反向传播算法去训练神经网络，训练Siamese神经网络。

神经风格迁移

给定一个内容图像$C$，给定一个风格图片$S$，而目标是生成一个新图片$G$。为了实现神经风格迁移，我们需要定义一个关于$G$的代价函数$J$用来评判某个生成图像的好坏，然后使用梯度下降法去最小化$J(G)$，以便于生成这个图像。

怎么判断生成图像的好坏呢？我们把这个代价函数定义为两个部分。

第一部分被称作内容代价$J_{\text{content}}(C,G)$，这是一个关于内容图片和生成图片的函数，它是用来度量生成图片$G$的内容与内容图片$C$的内容有多相似。然后我们会把结果加上一个风格代价函数$J_{\text{style}}(S,G)$，也就是关于$S$和$G$的函数，用来度量图片$G$的风格和图片$S$的风格的相似度。然后我们会把结果加上一个风格代价函数，得到

$$J( G) = a J_{\text{content}}( C,G) + \beta J_{\text{style}}(S,G)$$

也就是关于$S$和$G$的函数，用来度量图片$G$的风格和图片$S$的风格的相似度。

算法的运行是这样的，对于代价函数$J(G)$，为了生成一个新图像，你接下来要做的是随机初始化生成随机尺寸的图像$G$。然后使用上述定义的代价函数$J(G)$，使用梯度下降的方法将其最小化，更新$G:= G - \frac{\partial}{\partial G}J(G)$。逐步处理像素，这样慢慢得到一个生成图片（编号4、5、6），越来越像用风格图片的风格画出来的内容图片。

内容代价函数

假如需要衡量一个内容图片和一个生成图片在内容上的相似度，我们令这个$a^{[l][C]}$和$a^{[l][G]}$，代表这两个图片$C$和$G$的$l$层的激活函数值。如果这两个激活值相似，那么就意味着两个图片的内容相似。我们定义

$$J_{\text{content}}( C,G) = \frac{1}{2}|| a^{[l][C]} - a^{[l][G]}||^{2}$$

为两个激活值不同或者相似的程度，我们取$l$层的隐含单元的激活值，按元素相减，内容图片的激活值与生成图片相比较，然后取平方，也可以在前面加上归一化或者不加，比如$\frac{1}{2}$或者其他的，都影响不大,因为这都可以由这个超参数$a$来调整。

风格代价函数

为了测量生成的图像的风格与输入的风格图像的相似程度，我们设$a_{i,\ j,\ k}^{[l]}$，设它为隐藏层l中$(i,j,k)$位置的激活项，$i$，$j$，$k$分别代表该位置的高度、宽度以及对应的通道数。现在要做的就是去计算一个关于$l$层和风格图像的矩阵，即$G^{[l](S)}$（$l$表示层数，$S$表示风格图像），这（$G^{[l]( S)}$）是一个$n_{c} \times n_{c}$的矩阵，同样地，我们也对生成的图像进行这个操作。

现在先来定义风格图像，设这个关于$l$层和风格图像的，$G$是一个矩阵，这个矩阵的高度和宽度都是$l$层的通道数。在这个矩阵中$k$和$k’$元素被用来描述$k$通道和$k’$通道之间的相关系数。具体地：

$$G_{kk^{'}}^{[l]( S)} = \sum_{i = 1}^{n_{H}^{[l]}}{\sum_{j = 1}^{n_{W}^{[l]}}{a_{i,\ j,\ k}^{[l](S)}a_{i,\ j,\ k^{'}}^{[l](S)}}}$$

用符号$i$，$j$表示下界，对$i$，$j$，$k$位置的激活项$a_{i,\ j,\ k}^{[l]}$，乘以同样位置的激活项，也就是$i$,$ j$,$k’$位置的激活项，即$a_{i,j,k^{'}}^{[l]}$，将它们两个相乘。然后$i$和$j$分别加到l层的高度和宽度，即$n_{H}^{[l]}$和$n_{W}^{[l]}$，将这些不同位置的激活项都加起来。$(i,j,k)$和$(i,j,k’)$中$x$坐标和$y$坐标分别对应高度和宽度，将$k$通道和$k’$通道上这些位置的激活项都进行相乘。

这就是输入的风格图像所构成的风格矩阵，然后，再对生成图像做同样的操作:

$$G_{kk^{'}}^{[l]( G)} = \sum_{i = 1}^{n_{H}^{[l]}}{\sum_{j = 1}^{n_{W}^{[l]}}{a_{i,\ j,\ k}^{[l](G)}a_{i,\ j,\ k^{'}}^{[l](G)}}}$$

其中，$a_{i,\ j,\ k}^{[l](S)}$和$a_{i, j,k}^{[l](G)}$中的上标$(S)$和$(G)$分别表示在风格图像$S$中的激活项和在生成图像$G$的激活项。之所以用大写字母$G$来代表这些风格矩阵，是因为在线性代数中这种矩阵有时也叫Gram矩阵，但在这里叫做风格矩阵。

最后，如果我们将$S$和$G$代入到风格代价函数中去计算，这将得到这两个矩阵之间的误差，因为它们是矩阵，所以在这里加一个$F$（Frobenius范数，编号1所示），这实际上是计算两个矩阵对应元素相减的平方的和，将这个式子展开，从$k$和$k’$开始作它们的差，把对应的式子写下来，然后把得到的结果都加起来，作者在这里使用了一个归一化常数，也就是$\frac{1}{2n_{H}^{[l]l}n_{W}^{[l]}n_{C}^{[l]}}$，再在外面加一个平方，但是一般情况下不用写这么多，一般只要将它乘以一个超参数$\beta$就行。

最后，这是对$l$层定义的风格代价函数，这是两个矩阵间一个基本的Frobenius范数，也就是$S$图像和$G$图像之间的范数再乘上一个归一化常数。实际上，如果对各层都使用风格代价函数，会让结果变得更好。如果要对各层都使用风格代价函数 ，可以这么定义代价函数，把各个层的结果（各层的风格代价函数）都加起来，这样就能定义它们全体了。另外，还需要对每个层定义权重，也就是一些额外的超参数，这用$\lambda^{[l]}$来表示，这样将使你能够在神经网络中使用不同的层，包括之前的一些可以测量类似边缘这样的低级特征的层，以及之后的一些能测量高级特征的层，使得神经网络在计算风格时能够同时考虑到这些低级和高级特征的相关系数。

为了把这些东西封装起来，定义一个全体代价函数：

$$J(G) = a J_{\text{content}( C,G)} + \beta J_(S,G)$$

之后用梯度下降法，或者更复杂的优化算法来找到一个合适的图像$G$，并计算$J(G)$的最小值。

序列模型

循环序列模型

数学符号

• $x^{<t>}$用来来索引这个序列中的第$t$个位置
• $T_{x}$表示输入序列的长度
• $T_{y}$表示输出序列的长度
• $x^{\left(i \right) <t>}$表示训练样本$i$的序列中第$t$个元素
• $T_{x}^{(i)}$表示第$i$个训练样本的输入序列长度
• $y^{\left( i \right) < t>}$表示第$i$个训练样本中第$t$个元素
• $T_{y}^{(i)}$就是第$i$个训练样本的输出序列的长度

想要表示一个句子里的单词，第一件事是做一张词表，有时也称为词典，意思是列一列你的表示方法中用到的单词。使用的是one-hot编码。

循环神经网络模型

标准神经网络的问题

• 是输入和输出数据在不同例子中可以有不同的长度，不是所有的例子都有着同样输入长度$T_{x}$或是同样输出长度的$T_{y}$。
• 一个像这样单纯的神经网络结构，它并不共享从文本的不同位置上学到的特征。

前向传播

一般开始先输入$a^{<0>}$，它是一个零向量。接着就是前向传播过程，先计算激活值$a^{<1>}$，然后再计算$y^{<1>}$。

$$a^{<1>} = g_{1}(W_{aa}a^{< 0 >} + W_{ax}x^{< 1 >} + b_{a})\\ \hat y^{< 1 >} = g_{2}(W_{ya}a^{< 1 >} + b_{y})$$

更一般的，在$t$时刻，有

$$a^{< t >} = g_{1}(W_{aa}a^{< t - 1 >} + W_{ax}x^{< t >} + b_{a})\\ \hat y^{< t >} = g_{2}(W_{ya}a^{< t >} + b_{y})$$

为了简化符号，将$a^{<t>}$表达为$a^{<t>} =g(W_{a}\left\lbrack a^{< t-1 >},x^{<t>} \right\rbrack +b_{a})$，定义$W_{a}$的方式是将矩阵$W_{aa}$和矩阵$W_{ax}$水平并列放置，$[ {W_{aa}}\vdots {W_{ax}}]=W_{a}$。举个例子，如果$a$是100维的，然后延续之前的例子，$x$是10,000维的，那么$W_{aa}$就是个$（100，100）$维的矩阵，$W_{ax}$就是个$（100，10,000）$维的矩阵，因此如果将这两个矩阵堆起来，$W_{a}$就会是个$（100，10,100）$维的矩阵。用这个符号（$\left\lbrack a^{< t - 1 >},x^{< t >}\right\rbrack$）的意思是将这两个向量堆在一起，堆叠方式为纵向，即$\begin{bmatrix}a^{< t-1 >} \\ x^{< t >} \\\end{bmatrix}$，它是一个($10,100，100$)维的矩阵，此时矩阵$[ {W_{aa}}\vdots {W_{ax}}]$乘以$\begin{bmatrix} a^{< t - 1 >} \\ x^{< t >} \\ \end{bmatrix}$，刚好等于$W_{aa}a^{<t-1>} + W_{ax}x^{<t>}$。

RNN前向传播示意图：

反向传播（通过时间的）

为了计算反向传播，首先需要定义一个元素损失函数：

$$L^{<t>}( \hat y^{<t>},y^{<t>}) = - y^{<t>}\log\hat y^{<t>}-( 1- y^{<t>})log(1-\hat y^{<t>})$$

它对应的是序列中一个具体的词，如果它是某个人的名字，那么$y^{<t>}$的值就是1，然后神经网络将输出这个词是名字的概率值，比如0.1。其被定义为标准逻辑回归损失函数，也叫交叉熵损失函数（Cross Entropy Loss），这是关于单个位置上或者说某个时间步$t$上某个单词的预测值的损失函数。那么整个序列的损失函数$L$定义为

$$L(\hat y,y) = \ \sum_{t = 1}^{T_x}{L^{< t >}(\hat y^{< t >},y^{< t >})}$$

RNN反向传播示意图：

不同类型的循环神经网络

• 多对多：机器翻译
• 多对一：情感分类
• 一对多：音乐生成
• 一对一：标准神经网络

语言模型和序列生成

语言模型所做的就是，判断某个特定的句子它出现的概率是多少。构建一个语言模型首先需要将句子标记化，比如EOS它表示句子的结尾，UNK的代表未知词的标志，将输入的句子都映射到了各个标志上。

然后通过构建一个RNN来构建这些序列的概率模型，即将上一时间步输出作为下一时间步的输入，即将$x^{}$设为$y^{}$。

对新序列采样

第一步要做的就是对想要模型生成的第一个词进行采样，于是输入$x^{<1>} =0$，$a^{<0>} =0$，现在第一个时间步得到的是所有可能的输出是经过softmax层后得到的概率，然后根据这个softmax的分布进行随机采样。Softmax分布给出的信息就是第一个词a的概率是多少，第一个词是aaron的概率是多少，第一个词是zulu的概率是多少，还有第一个词是UNK（未知标识）的概率是多少，这个标识可能代表句子的结尾，然后对这个向量使用例如numpy命令，np.random.choice，来根据向量中这些概率的分布进行采样，这样就能对第一个词进行采样了。

然后继续下一个时间步，记住第二个时间步需要$\hat y^{<1>}$作为输入，而现在要做的是把刚刚采样得到的$\hat y^{<1>}$放到$a^{<2>}$，作为下一个时间步的输入，所以不管在第一个时间步得到的是什么词，都要把它传递到下一个位置作为输入，然后softmax层就会预测$\hat y^{<2>}$是什么。举个例子，假如说对第一个词进行抽样后，得到的是The，The作为第一个词的情况很常见，然后把The当成$x^{<2>}$，现在$x^{<2>}$就是$\hat y^{<1>}$，现在要计算出在第一词是The的情况下，第二个词应该是什么，然后得到的结果就是$\hat y^{<2>}$，然后再次用这个采样函数来对$\hat y^{<2>}$进行采样。

然后再到下一个时间步，无论得到什么样的用one-hot码表示的选择结果，都把它传递到下一个时间步，然后对第三个词进行采样。不管得到什么都把它传递下去，一直这样直到最后一个时间步（EOS标识）。另一种情况是，如果字典中没有这个词，可以决定从20个或100个或其他个单词进行采样，然后一直将采样进行下去直到达到所设定的时间步。

如果建立一个基于字符的语言模型，比起基于词汇的语言模型，序列$\hat y^{<1>}$，$\hat y^{<2>}$，$\hat y^{<3>}$在训练数据中将会是单独的字符，而不是单独的词汇。所以对于前面的例子来说，那个句子（上图编号3所示），“Cats average 15 hours of sleep a day.”，在该例中C就是$\hat y^{<1>}$，a就是$\hat y^{<2>}$，t就是$\hat y^{<3>}$，空格符就是$\hat y^{<4>}$等等。

循环序列模型单元

梯度消失和梯度爆炸问题

对于RNN，首先从左到右前向传播，然后反向传播。但是反向传播会很困难，因为同样的梯度消失的问题，后面层的输出误差很难影响前面层的计算。这就意味着，实际上很难让一个神经网络能够意识到它要记住看到的是单数名词还是复数名词，然后在序列后面生成依赖单复数形式的was或者were。其受到区域的影响要更大。

尽管梯度爆炸也是会出现，但是梯度爆炸很明显，因为指数级大的梯度会让参数变得极其大，以至于网络参数崩溃。所以梯度爆炸很容易发现，因为参数会大到崩溃，将会看到很多NaN，这意味着网络计算出现了数值溢出。一个解决方法就是用梯度修剪。意思就是观察你的梯度向量，如果它大于某个阈值，缩放梯度向量，保证它不会太大，这就是通过一些最大值来修剪的方法。

GRU(Gated Recurrent Unit)单元

传统的RNN隐藏层单元可视化如下：

（GRU）单元将会有个新的变量称为$c$，代表记忆细胞。

对于GRU，$c^{}$的值等于$a^{}$的激活值。

在每个时间步，我们将用一个候选值重写记忆细胞，即${\tilde{c}}^{} =tanh(W_{c}\left\lbrack c^{},x^{} \right\rbrack +b_{c})$,所以${\tilde{c}}^{}$的值就是个替代值，代替表示$c^{}$的值。

$\Gamma{u}= \sigma(W{u}\left\lbrack c^{},x^{} \right\rbrack +b_{u})$是一个更新门，用来决定什么时候更新$c^{}$。

记忆细胞更新的公式是$c^{<t>} = \Gamma_{u}*{\tilde{c}}^{<t>} +\left( 1- \Gamma_{u} \right)*c^{<t-1>}$，如果更新值$\Gamma_{u} =1$，也就是把新值设为候选值，即$c^{} = {\tilde{c}}^{}$，如果$\Gamma_{u} =0$，则不更后选址，即$c^{} =c^{}$，这样即使你一直处理句子到上图编号4所示，$c^{}$应该会一直等$c^{}$，于是它仍然记得主语的单复数。

所以总体步骤就是：

输入上层时间步记忆细胞$c^{<t-1>}$和当前时间步序列$x^{<x>}$，然后把这两个用合适的权重结合在一起，再用tanh还算得到${\tilde{c}}^{}$，${\tilde{c}}^{} =tanh(W_{c}\left\lbrack c^{},x^{} \right\rbrack +b_{c})$，即$c^{<t>}$的替代值。再用一个不同的参数集，通过sigmoid激活函数算出$\Gamma_{u}= \sigma(W_{u}\left\lbrack c^{<t-1>},x^{<t>} \right\rbrack +b_{u})$，即更新门。最后所有的值通过另一个运算符结合产生记忆细胞新值$c^{<t>} = \Gamma_{u}*{\tilde{c}}^{<t>} +\left( 1- \Gamma_{u} \right)*c^{<t-1>}$，另外，也可以把这个代入softmax来预测$y^{<t>}$。

GRU的优点就是通过门来决定更新和不更新记忆细胞的值，并且因为$\Gamma_{u}$很接近0，这样就不会有梯度消失问题，同时$c^{}$几乎就等于$c^{}$，所以$c^{}$的值也很好地被维持了。上述介绍的仅仅是简化的GRU单元，而完整的GRU单元还需要添加一个门，这个$\Gamma_{r}= \sigma(W_{r}\left\lbrack c^{<t-1>},x^{<t>} \right\rbrack + b_{r})$，$\Gamma_{r}$门告诉你计算出的下一个$c^{}$的候选值${\tilde{c}}^{}$跟$c^{}$有多大的相关性。

长短期记忆 LSTM(long short term memory) unit

• 在LSTM中不再有$a^{} = c^{}$的情况，所以与GRU不同，原本的符号$c^{<T>}$需要换成$a^{<t-1>}$。并且也没有了相关门$\Gamma_r$。

LSTM前向传播图：

LSTM反向传播计算：

门求偏导：

$$d \Gamma_o^{\langle t \rangle} = da_{next}*\tanh(c_{next}) * \Gamma_o^{\langle t \rangle}*(1-\Gamma_o^{\langle t \rangle})\tag{1}$$ $$d\tilde c^{\langle t \rangle} = dc_{next}*\Gamma_i^{\langle t \rangle}+ \Gamma_o^{\langle t \rangle} (1-\tanh(c_{next})^2) * i_t * da_{next} * \tilde c^{\langle t \rangle} * (1-\tanh(\tilde c)^2) \tag{2}$$ $$d\Gamma_u^{\langle t \rangle} = dc_{next}*\tilde c^{\langle t \rangle} + \Gamma_o^{\langle t \rangle} (1-\tanh(c_{next})^2) * \tilde c^{\langle t \rangle} * da_{next}*\Gamma_u^{\langle t \rangle}*(1-\Gamma_u^{\langle t \rangle})\tag{3}$$ $$d\Gamma_f^{\langle t \rangle} = dc_{next}*\tilde c_{prev} + \Gamma_o^{\langle t \rangle} (1-\tanh(c_{next})^2) * c_{prev} * da_{next}*\Gamma_f^{\langle t \rangle}*(1-\Gamma_f^{\langle t \rangle})\tag{4}$$

参数求偏导 ：

$$dW_f = d\Gamma_f^{\langle t \rangle} * \begin{pmatrix} a_{prev} \\ x_t\end{pmatrix}^T \tag{5}$$ $$dW_u = d\Gamma_u^{\langle t \rangle} * \begin{pmatrix} a_{prev} \\ x_t\end{pmatrix}^T \tag{6}$$ $$dW_c = d\tilde c^{\langle t \rangle} * \begin{pmatrix} a_{prev} \\ x_t\end{pmatrix}^T \tag{7}$$ $$dW_o = d\Gamma_o^{\langle t \rangle} * \begin{pmatrix} a_{prev} \\ x_t\end{pmatrix}^T \tag{8}$$

为了计算$db_f, db_u, db_c, db_o$ 需要各自对$d\Gamma_f^{\langle t \rangle}, d\Gamma_u^{\langle t \rangle}, d\tilde c^{\langle t \rangle}, d\Gamma_o^{\langle t \rangle}$ 求和。

最后，计算隐藏状态、记忆状态和输入的偏导数：

$$da_{prev} = W_f^T*d\Gamma_f^{\langle t \rangle} + W_u^T * d\Gamma_u^{\langle t \rangle}+ W_c^T * d\tilde c^{\langle t \rangle} + W_o^T * d\Gamma_o^{\langle t \rangle} \tag{9}$$ $$dc_{prev} = dc_{next}\Gamma_f^{\langle t \rangle} + \Gamma_o^{\langle t \rangle} * (1- \tanh(c_{next})^2)*\Gamma_f^{\langle t \rangle}*da_{next} \tag{10}$$ $$dx^{\langle t \rangle} = W_f^T*d\Gamma_f^{\langle t \rangle} + W_u^T * d\Gamma_u^{\langle t \rangle}+ W_c^T * d\tilde c_t + W_o^T * d\Gamma_o^{\langle t \rangle}\tag{11}$$

GRU的优点是这是个更加简单的模型，所以更容易创建一个更大的网络，而且它只有两个门，在计算性上也运行得更快，然后它可以扩大模型的规模。但是LSTM更加强大和灵活，因为它有三个门而不是两个。

双向循环神经网络

动机：不能仅仅通句子前面的成分就决定后续的单词。

假如输入只有4个，从$x^{<1>}$到$x^{<4>}$。从这里开始的这个网络会有一个前向的循环单元叫做${\overrightarrow{a}}^{<1>}$，${\overrightarrow{a}}^{<2>}$，${\overrightarrow{a}}^{<3>}$还有${\overrightarrow{a}}^{<4>}$，这4个循环单元都有一个当前输入$x$输入进去，得到预测的$\hat y^{<1>}$，$\hat y^{<2>}$，$\hat y^{<3>}$和$\hat y^{<4>}$。然后再增加反向的循环单元${\overleftarrow{a}}^{<1>}$、${\overleftarrow{a}}^{<2>}$、${\overleftarrow{a}}^{<3>}$、${\overleftarrow{a}}^{<4>}$构成一个无环图，为了预测结果$\hat y^{<t>} =g(W_{g}\left\lbrack {\overrightarrow{a}}^{< t >},{\overleftarrow{a}}^{< t >} \right\rbrack +b_{y})$。参数$W_{a}^{\left\lbrack 2 \right\rbrack}$和$b_{a}^{\left\lbrack 2 \right\rbrack}$在这一层的计算里都一样，相对应地第一层也有自己的参数$W_{a}^{\left\lbrack 1 \right\rbrack}$和$b_{a}^{\left\lbrack 1 \right\rbrack}$。

深层循环神经网络

这是一个有三个隐层（纵向来看）的新的网络，$a^{\lbrack l\rbrack }$来表示第l层的激活值，这个\表示第$t$个时间点，具体的激活值计算例子：$a^{\lbrack 2\rbrack < 3 >} = g(W_{a}^{\left\lbrack 2 \right\rbrack}\left\lbrack a^{\left\lbrack 2 \right\rbrack < 2 >},a^{\left\lbrack 1 \right\rbrack < 3 >} \right\rbrack + b_{a}^{\left\lbrack 2 \right\rbrack})$。

自然语言处理与词嵌入

词嵌入

概念

词嵌入（word embeddings）：对于相近的概念（apple, orange），学到的特征也比较类似，在对这些概念可视化的时候，这些概念就比较相似，最终把它们映射为相似的特征向量。

作用

做迁移学习

词嵌入做迁移学习的步骤：

• 第一步，先从大量的文本集中学习词嵌入。
• 第二步，用这些词嵌入模型把它迁移到新的只有少量标注训练集的任务中。这样做的一个好处就是可以用更低维度的特征向量代替原来的高维的one-hot向量。
• 第三步，在新的任务上训练模型时，在命名实体识别任务上，只有少量的标记数据集上，可以选择要不要继续微调，用新的数据调整词嵌入。

帮助类比推理

词嵌入还有一个特性就是帮助实现类比推理。假如我提出一个问题，man如果对应woman，那么king应该对应什么？你们应该都能猜到king应该对应queen。能否有一种算法来自动推导出这种关系，下面就是实现的方法。

为了得出这样的类比推理，计算当man对于woman，那么king对于什么，要做的就是找到单词w来使得，$e_{\text{man}}-e_{\text{woman}}≈ e_{\text{king}} - e_{w}$这个等式成立，目标就是找到单词w来最大化$e_{w}$与$e_{\text{king}} - e_{\text{man}} + e_{\text{woman}}$的相似度，即$Find\ word\ w:argmax \ Sim(e_{w},e_{\text{king}} - e_{\text{man}} + e_{\text{woman}})$

为了测量两个词的相似程度，我们需要一种方法来测量两个词的两个嵌入向量之间的相似程度。 给定两个向量$u$和$v$，余弦相似度定义如下：

$${CosineSimilarity(u, v)} = \frac {u . v} {||u||_2 ||v||_2} = cos(\theta) \tag{1}$$

其中 $u.v$ 是两个向量的点积（或内积），$||u||_2$是向量$u$的范数（或长度），并且 $\theta$ 是向量$u$和$v$之间的角度。这种相似性取决于角度在向量$u$和$v$之间。如果向量$u$和$v$非常相似，它们的余弦相似性将接近1; 如果它们不相似，则余弦相似性将取较小的值。

嵌入矩阵

令$EO_{j}=e_j$，其中$E$是嵌入矩阵，$O_j$(10000x1)就是只有第$j$个位置是1的one-hot向量，$e_j$(300x1)是字典中单词$j$的嵌入向量。目标是学习一个嵌入矩阵$E$(300x10000)。

学习词嵌入

构建神经网络语言模型

构造嵌入矩阵$E$，并对输入词进行one-hot编码，然后计算出嵌入向量$e_j$，经过神经网络隐藏层以后再通过softmax层，这个softmax也有自己的参数，然后这个softmax分类器会在10,000个可能的输出中预测结尾这个单词。这个例子中有6个词，所以用6×300，所以这个输入会是一个1800维的向量，这是通过将这6个嵌入向量堆在一起得到的。

另外还有一个固定的历史窗口，比如这里的4是算法的超参数。如果使用一个4个词的历史窗口，这就意味着神经网络会输入一个1200维的特征变量到这个层中（上图编号4所示），然后再通过softmax来预测输出，选择有很多种，用一个固定的历史窗口就意味着你可以处理任意长度的句子，因为输入的维度总是固定的。

如果目标不是学习语言模型本身的话，那么也可以选择其他的上下文。

Word2Vec模型

word2vec模型是自然语言处理NLP中一个经典的模型，其将离散的词语映射到连续空间，同时能编码得出词语的上下文语义信息。一般而言，在机器学习算法中使用one-hot编码将一个离散型的词语编码为一条数值型的变量。在此基础上，word2vec采用神经网络中自动编码机Auto-Encoder的方法，包含 CBOW（Continuous Bag-Of-Words，即连续的词袋模型）和 Skip-Gram两种模型，将词语映像到同一坐标系，得出数值向量。

CBOW是从原始语句推测目标字词；而Skip-Gram正好相反，是从目标字词推测出原始语句。CBOW对小型数据库比较合适，而Skip-Gram在大型语料中表现更好。 （下图左边为CBOW，右边为Skip-Gram）

在Skip-Gram模型中，我们要做的是抽取上下文和目标词配对，来构造一个监督学习问题。上下文不一定总是目标单词之前离得最近的$n$个单词。我们要的做的是随机选一个词作为上下文词然后我们要做的是随机在一定词距内选另一个词。于是我们将构造一个监督学习问题，它给定上下文词，要求你预测在这个词正负$n$个词距内随机选择的某个目标词。显然，这不是个非常简单的学习问题，因为在单词的正负$n$个词距之间，可能会有很多不同的单词。但是构造这个监督学习问题的目标并不是想要解决这个监督学习问题本身，而是想要使用这个学习问题来学到一个好的词嵌入模型。

模型细节和上述一样，输入one-hot向量$O_{c}$，嵌入矩阵$E$乘以向量$O_{c}$，然后得到了输入的上下文词的嵌入向量$e_{c}=EO_{c}$。通过softmax模型来预测不同词的概率：

$$Softmax:p\left( t \middle| c \right) = \frac{e^{\theta_{t}^{T}e_{c}}}{\sum_{j = 1}^{10,000}e^{\theta_{j}^{T}e_{c}}}$$

这里$\theta_{t}$是一个与输出$t$有关的参数，即某个词$t$和标签相符的概率是多少。最终softmax的损失函数就会像之前一样，用$y$表示目标词，这里用的$y$和$\hat y$都是用one-hot表示的，于是损失函数就会是：

$$L\left( \hat y,y \right) = - \sum_{i = 1}^{10,000}{y_{i}\log \hat y_{i}}$$

总结一下，这大体上就是一个可以找到词嵌入的简化模型和神经网络（上图编号2所示），其实就是个softmax单元。矩阵$E$将会有很多参数，所以矩阵$E$有对应所有嵌入向量$e_{c}$的参数（上图编号6所示），softmax单元也有$\theta_{t}$的参数（上图编号3所示）。如果优化这个关于所有这些参数的损失函数，你就会得到一个较好的嵌入向量集，这个就叫做Skip-Gram模型。

该模型存在的问题就是softmax层的计算速度很慢，解决方法主要有分级（hierarchical）的softmax分类器和负采样（Negative Sampling）

hierarchical softmax

hierarchical softmax的核心内容是哈夫曼树（Huffman Tree），树的核心概念是 出现概率越高的符号使用较短的编码（层次越浅），出现概率低的符号则使用较长的编码（层次越深）。

负采样

假设orange juice是一个正样本，然后需要做的是给定$K$次，我们将用相同的上下文词，再从字典中选取随机的词，king、book、the、of等，从词典中任意选取的词，并标记0，这些就会成为负样本。

接下来我们将构造一个监督学习问题，其中学习算法输入$x$，输入这对词，要去预测目标的标签，即预测输出$y$。

为了定义模型，我们将使用记号$c$表示上下文词，记号$t$表示可能的目标词，我再用$y$表示0和1，表示是否是一对上下文-目标词。我们要做的就是定义一个逻辑回归模型，给定输入的$c$，$t$对的条件下，$y=1$的概率，即：

$$P\left( y = 1 \middle| c,t \right) = \sigma(\theta_{t}^{T}e_{c})$$

这个模型基于逻辑回归模型，但不同的是我们将一个sigmoid函数作用于$\theta_{t}^{T}e_{c}$，参数和之前一样，你对每一个可能的目标词有一个参数向量$\theta_{t}$和另一个参数向量$e_{c}$，即每一个可能上下文词的的嵌入向量，我们将用这个公式估计$y=1$的概率。

这个算法有一个重要的细节就是如何选取负样本，一个办法是对中间的这些词进行采样，即候选的目标词，可以根据其在语料中的经验频率进行采样，就是通过词出现的频率对其进行采样。但问题是这会导致在like、the、of、and诸如此类的词上有很高的频率。另一个极端就是用1除以词汇表总词数，即$\frac{1}{\left|v\right|}$，均匀且随机地抽取负样本，这对于英文单词的分布是非常没有代表性的。所以论文的作者Mikolov等人根据经验，他们发现这个经验值的效果最好，它位于这两个极端的采样方法之间，既不用经验频率，也就是实际观察到的英文文本的分布，也不用均匀分布，他们采用以下方式：

$$P\left( w_{i} \right) = \frac{f\left( w_{i} \right)^{\frac{3}{4}}}{\sum_{j = 1}^{10,000}{f\left( w_{j} \right)^{\frac{3}{4}}}}$$

进行采样，所以如果$f(w_{i})$是观测到的在语料库中的某个英文词的词频，通过$\frac{3}{4}$次方的计算，使其处于完全独立的分布和训练集的观测分布两个极端之间。

GloVe 词向量（GloVe Word Vectors）

GloVe代表用词表示的全局变量（global vectors for word representation）。假定$X_{ij}$是单词$i$在单词$j$上下文中出现的次数，那么这里$i$和$j$就和$t$和$c$的功能一样，所以可以认为$X_{ij}$等同于$X_{tc}$，$X_{ij}$是一个能够获取单词$i$和单词$j$出现位置相近时或是彼此接近的频率的计数器。GloVe模型做的就是进行优化，将他们之间的差距进行最小化处理：

$$\text{mini}\text{mize}\sum_{i = 1}^{10,000}{\sum_{j = 1}^{10,000}{f\left( X_{ij} \right)\left( \theta_{i}^{T}e_{j} + b_{i} + b_{j}^{'} - logX_{ij} \right)^{2}}}$$

加权项$f\left(X_{ij}\right)$用于如果$X_{ij}$等于0的话，则$f\left(X_{ij}\right)=0$，同时我们会用一个约定，即$0log0= 0$。其另一个作用是对于不频繁的词，也能给与有意义的运算；对于出现频繁的词更大但不至于过分的权重

应用

情感分类

将词嵌入与RNN进行结合。

词嵌入除偏

根据训练模型所使用的文本，词嵌入能够反映出性别、种族、年龄、性取向等其他方面的偏见。

处理词嵌入的偏见主要有三个步骤：

• 平均步骤，对于偏见词汇作差取平均。
• 中和步骤，对于那些定义不确切的词可以将其处理一下，避免偏见。
• 均衡步骤，假如有这样的词对，grandmother和grandfather，或者是girl和boy，对于这些词嵌入，你只希望性别是其区别。

序列模型和注意力机制

基础模型

首先，建立一个网络，这个网络叫做编码网络（encoder network）（上图编号1所示），它是一个RNN的结构， RNN的单元可以是GRU 也可以是LSTM。每次只向该网络中输入一个法语单词，将输入序列接收完毕后，这个RNN网络会输出一个向量来代表这个输入序列。之后建立一个解码网络（上图编号2所示），它以编码网络的输出作为输入，编码网络是左边的黑色部分（上图编号1所示），之后它可以被训练为每次输出一个翻译后的单词，一直到它输出序列的结尾或者句子结尾标记，这个解码网络的工作就结束了。和往常一样把每次生成的标记都传递到下一个单元中来进行预测，就像之前用语言模型合成文本时一样。

机器翻译相当于是建立一个条件语言模型，最上方是一个循环神经网络模型，这个模型能够估计句子的可能性，这就是语言模型所做的事情。机器翻译模型其实和语言模型非常相似，不同在于语言模型总是以零向量开始，而encoder网络会计算出一系列向量来表示输入的句子。

机器翻译是建立一个条件语言模型，所以当使用这个模型来进行机器翻译时，并不是从得到的分布中进行随机取样，而是要找到一个英语句子$y$，使得条件概率最大化。所以在开发机器翻译系统时，需要做的一件事就是想出一个算法，用来找出合适的$y$值，使得该项最大化。

集束搜索（Beam Search）

Beam Search（集束搜索）是一种启发式图搜索算法，通常用在图的解空间比较大的情况下，为了减少搜索所占用的空间和时间，在每一步深度扩展的时候，剪掉一些质量比较差的结点，保留下一些质量较高的结点。这样减少了空间消耗，并提高了时间效率。

算法的工作流程如下：

使用广度优先策略建立搜索树，在树的每一层，按照启发代价对节点进行排序，然后仅留下预先确定的个数（Beam Width-集束宽度）的节点，仅这些节点在下一层次继续扩展，其他节点就被剪掉了。

• 将初始节点插入到list中
• 将给节点出堆，如果该节点是目标节点，则算法结束
• 否则扩展该节点，取集束宽度的节点入堆。然后到第二步继续循环
• 算法结束的条件是找到最优解或者堆为空。

集束搜索第一步就是挑选出英文翻译句子中的第一个单词。过程是先将整个待翻译的句子输入到绿色的编码网络中，然后使用紫色的解码网络进行解码，结果是一个10000维的向量，用来表示第一个英文单词的概率，选择概率最大的3个（集束宽）单词存储在内存中。$P(Y^{<1>|x})$，其中$x$表示输入的法语句子，$y^{<1>}$表示输出的第一个英语单词。

对于第二个单词，是要在第一个单词确定的情况下进行搜索。假设第一个单词被设置为in或jane或September，将第一个单词in作为解码器的第一个节点的输出，并且将其作为第二个节点的输入。这样这个网络就能评估第二个词的概率了$P(y^{<2>}|x,"in")$，接下来要关注的是第一个和第二个单词的联合概率，即$P(y^{<1>}, y^{<2>}|x)=P(y^{<1>}|x)P(y^{<2>}|x,y^{<1>})$，同样对第一个翻译结果的其他候选词也进行如上操作，由于使用的集束宽为3，并且词汇表中单词的数量为10000，所以最终会有30000个可能的结果，再从这30000个结果中挑选出3个概率最大的结果。 集束搜索通过这种方法每次找到一个词，最终得到希望的结果。

改进

1. 防止数值下溢（多个小于1的数相乘），取log值。
2. 对于目标函数，因为多个小于1的数相乘，会导致模型倾向于选择更短的翻译结果。为了解决这个问题，可以对目标函数进行归一化，即通过除以翻译结果的单词数量，来减少对输出长的结果的惩罚。在实践中，有个探索性的方法，相比于直接除$T{y}$，也就是输出句子的单词总数，我们有时会用一个更柔和的方法（a softer approach），在$T{y}$上加上指数$a$，$a$可以等于0.7。如果$a$等于1，就相当于完全用长度来归一化，如果$a$等于0，$T_{y}$的0次幂就是1，就相当于完全没有归一化，这就是在完全归一化和没有归一化之间。$a$就是算法另一个超参数（hyper parameter），需要调整大小来得到最好的结果。另外集束宽的选择也是一个在准确率和计算速度之间trade-off的超参数。

误差分析

RNN的功能是计算$P(y|x)$,所以可以通过比较 $P(y^*|x)$和$P(\hat y|x)$的值的大小来判断RNN和束搜索方法的好坏。

Bleu得分

BLEU代表bilingual evaluation understudy (双语评估替补)

定义$n$元词组精确度$P_n$，如果机器翻译输出与参考1或是参考2完全一致的话，那么所有的这些$P_1$、$P_2$等等的值，都会等于1.0。

将所有$n$元组组合一下来构成最终的BLEU得分，按照惯例BLEU得分被定义为，$exp (\frac{1}{4}\sum\limits_{n=1}^{4}{P_n})$，对这个线性运算进行乘方运算，乘方是严格单调递增的运算，实际上会用额外的一个叫做BP 的惩罚因子（the BP penalty）来调整这项。BP的意思是“简短惩罚”（ brevity penalty）。

注意力模型

假定有一个输入句子，并使用双向的RNN，在双向RNN已经计算了前向的特征值和后向的特征值，用$a^{}$来一起表示这些联系。所以$a^{}$就是时间步$t$上的特征向量。为了保持记号的一致性，用$t’$来索引法语里的词。$\alpha^{}$就是$y^{}$应该在$t'$时，花在$a$上注意力的数量，$t$时间的上下文是特征向量的注意力加权求和$c^{}=\sum_{t}\alpha^{<t,t>}a^{t`}$。

下一步需要做的是定义注意力权重$\alpha^{<t,t’>}$的计算：

$s^{}$是时间步的隐藏状态，$e^{<t,t`>}$是一个通过神经网络学习的关于$s^{}$和$a^{}$的结果。

应用

语音识别

触发字检测