深度学习~

前向传播和反向传播：优化学习参数(w,b)：计算代价函数和梯度
def propagate(w, b, X, Y):
    
    m = X.shape[1]

    A = sigmoid(np.dot(w.T,X) + b)         
    cost = np.sum(((- np.log(A))*Y + (-np.log(1-A))*(1-Y)))/m 

    dw = (np.dot(X,(A-Y).T))/m
    db = (np.sum(A-Y))/m

    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    cost = np.squeeze(cost)
    assert(cost.shape == ())
    
    grads = {"dw": dw,
             "db": db}
    
    return grads, cost

神经网络中的梯度下降

反向传播得到da、dz、dw 、db

做两步，一个隐藏层，一个输出层

向量化

随机初始化

在逻辑回归中，把权重参数初始化为0可以，但在神经网络中，把权重参数初始化为0 ，并使用梯度下降，将无法获得预期效果

深度神经网络向量化检查矩阵的维度可以减少错误

参数和超参数

参数：w,b

超参数：学习率、迭代次数、隐藏层数、隐藏层单元数、激活函数

训练开发测试集 train/dev/test

如果训练集很大，也可以使开发集和测试集远小于10%或20%。一个比较小的数字就可以

确保开发集和测试集的数据分布相同（来源）

另一个常用的正则化技巧- dropout正则化（随机失活）

应用视觉领域比较多

先遍历网络的每一层，并且为丢弃网络中的某个节点设置一个概率值，清除哪些准备抛弃的的结点上的所有运算，得到一个小的多的，被简化的网络

在每次迭代中，你以1−𝑘𝑒𝑒𝑝_𝑝𝑟𝑜𝑏的概率关闭(=设为0)一层的每个神经元或者保持它的概率𝑘𝑒𝑒𝑝_𝑝𝑟𝑜𝑏(50%)。在迭代的前向和后向传播中，丢失的神经元对训练都没有贡献。

我们不会对输入层或输出层应用dropout。假设对第三层使用：

d3是一个与a3相同的矩阵，d3中的元素都有𝑘𝑒𝑒𝑝_𝑝𝑟𝑜𝑏的概率取值为1，1−𝑘𝑒𝑒𝑝_𝑝𝑟𝑜𝑏的概率取值为1；a3为层3的激活矩阵：a3 与d3逐元素相乘（清除对应位置为0 的）

反向随机失活技术

最后，放大a3：/𝑘𝑒𝑒𝑝_𝑝𝑟𝑜𝑏，为了不减少z4的期望值。（确保a3的期望值不变）这一步也简化了神经网络的测试部分，因为它减少了可能引入的缩放问题（确保如果测试过程没有针对随机失活算法进行缩放，那么激活函数的期望输出也不会改变）

我们想生成一个有1和0的向量，其中80%是1,20%是0。X = (X < keep_prob).astype(int) ，用于多维数组，结果输出保留输入数组的维度。等同于：

for i,v in enumerate(x):
    if v < keep_prob:
        x[i] = 1
    else: # v >= keep_prob
        x[i] = 0

当你关闭一些神经元时，你实际上是在修改你的模型。drop-out背后的想法是，在每次迭代中，你只训练一个不同的模型，它只使用你的神经元的一个子集。有了dropout，你的神经元因此对另一个特定神经元的激活变得不那么敏感，因为另一个神经元可能随时被关闭。

最后，在测试阶段，不使用随机失活算法

存留率：标示一层中一个神经元不失活的概率，可以对每一层设置不同的存留率，对于神经单元多的、权值大的、可能发生过拟合的层，设置小一点的存留率

归一化输入

第一步：减去均值：x- $\mu$ （将训练集平移，直到均值变为0）

第二步：将方差进行归一化：每个样本都除以方差 $\sigma ^{2}$

得到的X1、X2两个特征的方差都等于1

进行此数据缩放，务必对测试集和训练集使用相同的 $\mu$ 、 $\sigma ^{2}$

如果输入的特征尺寸非常不同，那么归一化就会带来比较好的效果

梯度的消失和爆炸（ vanishing /exploding gradients）

当训练一个很深的神经网络时，损失函数的导数（斜率）有时会变的非常大或者非常小。

谨慎选择随机初始值的权重，来显著减少这种问题的发生

深度网络权值初始化

𝑤 [𝑙] = 𝑛𝑝. 𝑟𝑎𝑛𝑑𝑜𝑚. 𝑟𝑎𝑛𝑑𝑛(shape) ∗ np. sqrt( 𝑛 [𝑙 1 −1] ) ， 𝑛 [𝑙−1] 就是我喂给第 𝑙 层神

经单元的数量（即第 𝑙 − 1 层神经元数量）

梯度的数值近似

当你实现梯度逆传播时，有一个测试叫做梯度检验，它的作用是确保 backprop 正确实施。

使用双边误差来判断别人给你的函数 𝑔(𝜃)，是否正确实现了函数 𝑓 的偏导

梯度检验（Gradient checking）

利用它来调试或检验 backprop 的实施是否正确。

把所有参数转换成一个巨大的向量数据，你要做的就是把矩阵𝑊转换成一个向量，把所有𝑊矩阵转换成向量之后，做连接运算，得到一个巨型向量𝜃，该向量表示为参数𝜃，代价函数𝐽是所有𝑊和 𝑏 的函数，现在你得到了一个𝜃的代价函数𝐽（即𝐽(𝜃)）。

为了实施梯度检验，你要做的就是循环执行，从而对每个𝑖也就是对每个𝜃组成元素计算𝑑𝜃 approx [𝑖] 的值，我使用双边误差，也就是：

（𝑑𝜃approx[𝑖]）应该逼近𝑑𝜃[𝑖]= 𝜕 𝜕𝐽 𝜃𝑖 ， 𝑑𝜃[𝑖] 是代价函数的偏导数，然后你需要对𝑖的每个值都执行这个运算，最后得到两个向量，得到𝑑𝜃的逼近值 𝑑𝜃approx ，它与 𝑑𝜃具有相同维度，它们两个与𝜃具有相同维度，你要做的就是验证这些向量是否彼此接近。

怎么定义两个向量是大致相等的呢：计算两个向量的欧几里得范数

值为10^−7或更小，这就很好，这就意味着导数逼近很有可能是正确的，它的值非常小。

如果比10−3大很多,这时应该仔细检查所有 𝜃项，看是否有一个具体的𝑖值，使得 𝑑𝜃approx[𝑖]与

𝑑𝜃[𝑖]大不相同，并用它来追踪一些求导计算是否正确

优化算法 (Optimization algorithms)

小批量梯度下降（mini-batch granduent descent）

在对整个训练集执行梯度下降法时，你要做的是，你必须处理整个训练集，然后才能进行一步梯度下降法，然而当数据量很大时，处理速度仍然缓慢。所以如果你在处理完整个 500 万个样本的训练集之前，先让梯度下降法处理一部分，你的算法速度会更快。

你可以把训练集分割为小一点的子集训练，这些子集被取名为 mini -batch把𝑥 (1)到𝑥 (1000)称为𝑋 ^{1}

mini -batch大小的选择：

首先，如果训练集较小，直接使用 batch 梯度下降法，样本集较小就没必要使用 mini

batch 梯度下降法，你可以快速处理整个训练集，所以使用 batch 梯度下降法也很好，这里

的少是说小于 2000 个样本，这样比较适合使用 batch 梯度下降法。不然，样本数目较大的

话，一般的 mini-batch 大小为 64 到 512

动量梯度下降法（Gradient descent with Momentum）

计算梯度的指数加权平均数，并利用该梯度更新你的权重

在每次迭代中，确切来说在第𝑡次迭代的过程中，你会计算微分𝑑𝑊，𝑑𝑏 ，用现有的 mini -batch 计算𝑑𝑊，db

计算 𝑣 𝑑𝑊 = 𝛽𝑣𝑑𝑊 +(1 − 𝛽)𝑑W，相似(𝑣 =𝛽𝑣 + (1 − 𝛽)𝜃𝑡)，𝑑𝑊是移动平均数

𝑣𝑑𝑏 = 𝛽𝑣 𝑑𝑏 + (1 − 𝛽)𝑑b

然后重新赋值权重，𝑊: = 𝑊 − 𝑎𝑣𝑑𝑊 ，同样 𝑏: = 𝑏 − 𝑎𝑣𝑑𝑏 ，这样就可以减缓梯度下降的幅度。

有两个超参数，学习率𝑎以及参数 𝛽 ， 𝛽 控制着指数加权平均数。𝛽最常用的值是 0.9

最终纵轴方向的摆动变小了，横轴方向运动更快，因此你的算法走了一条更加直接的路径，在抵达最小值的路上减少了摆动。

RMSprop 算法均方根传递（root mean square prop）

加速梯度下降

𝑆 𝑑𝑊 = 𝛽𝑆𝑑𝑊 + (1 − 𝛽)𝑑𝑊^2

𝑆 𝑑𝑏 = 𝛽𝑆 𝑑𝑏 + (1 − 𝛽)𝑑𝑏^ 2

平方:操作时逐元素（elementwise）的平方操作 (𝑑𝑊)^ 2，

Adam(Adaptive Moment estimation)算法

Adam 优化算法基本上就是将 Momentum 和 RMSprop 结合在一起

𝛽 1 ， 𝛽 2 和 𝜀 ，我总是选定其分别为 0.9，0.999 和 10^ −8

局部最优的问题(The problem of local optima)

通常梯度为零的点并不是这个图中的局部最优点，实际上成本函数的零梯度点，通常是鞍点(Saddle point)

真正会降低学习速度的，实际上是停滞区（Plateaus）：平稳段会减缓学习，平稳段是一块区

域，其中导数长时间接近于 0 ，如果你在此处，梯度会从曲面从从上向下下降，因为梯度等

于或接近 0 ，曲面很平坦，你得花上很长时间慢慢抵达平稳段的这个点，然后再向下离开。

超参数调试

随机选择点，接着，用这些随机取的点试验超参数的效果

用由粗糙到精细的策略

批量归一化（Batch normalization）

归一化隐藏单元激活函数以加速学习的方法

可以让超参数的搜索变的简单，神经网络变的更加健壮

将隐藏层归一化如：𝑎[2]，以更快的速度训练𝑤[3]，𝑏 [3]。

实际应用中，对z[2]归一化要多

单隐藏层：

𝛾 和𝛽控制𝑧 (𝑖)的值：隐藏单元值的均值和方差标准化，即𝑧 (𝑖)有固定的均值和方差，均值和方差可以是 0 和 1，也可以是其它值，它是由𝛾 和 𝛽 两参数控制的。

应用在神经网络：

因为 Batch 归一化算法使各层的𝑧 [𝑙]均值为0，所以𝑏[𝑙]这个参数没有意义，可以=0

Softmax 回归（Softmax regression）

逻辑回归算法，在识别多种分类的类别时做出预测

输入输出都是向量

深度学习框架

TensorFlow

w是需要优化的参数，所以把w定义为变量

使用梯度胶带记录计算计算代价函数所需的操作顺序

卷积神经网络（CNN）

多应用于图像

边缘检测示例

如何在图像中检测这些边缘？

卷积运算提供了一个方便的方法去弄清楚如何在图像中找到这些垂直边缘（明暗分界）

右边的被称为过滤器

垂直边缘检测：以下这个例子，输出中间的明亮区域，只是用图像的方式，来表示有一个强垂直边缘，在图像的中间。

卷积只是提供了一种方法，使你在图像中找到这些垂直边缘（具体想找什么，还是和过滤器的选取有关）

convolution 卷积计算

过滤器对应元素，相乘再相加

python：conv_forward 函数。

tensorflow ： tf.nn.conv2d 函数

Keras : Conv2D

卷积的基本操作

填充 Padding

输出的维度就是(𝑛 − 𝑓 + 1) × (𝑛 − 𝑓 + 1)

两个缺点：输出图像越来越小、边缘信息被使用较少

解决方法：在卷积操作前填充图片（用一个额外的边缘填充图片）

Same convolutions

使得输出大小等于填充前的大 𝑝 = (𝑓 − 1)/2 , 填充p圈就能实现（f是奇数）

带步长的卷积 Strided Convolutions

公式

三维卷积

同样使用三维过滤器 27个数相乘相加

可以使用两个不同目的的过滤器

单层卷积神经网络

上图显示经过一层神经网络的传播，a[0]到a[1]的过程：卷积计算--添加偏差--放入激活函数（ReLU）

参数

𝑛𝑐 [𝑙−1] 是上一层的通道数目（和输入的通道数目相同），𝑛𝑐 [𝑙]：这一层的通道数目 = 过滤器的数量，权重也就是所有过滤器的集合再乘以过滤器的总数量

卷积网络的例子

39×39×3 的输入图像就处理完毕了，为图片提取了 7×7×40 个特征，计算出来就是 1960 个特征。然后对该卷积进行处理，可以将其平滑或展开成 1960 个单元，扁平化成一个向量，然后将其输入到一个logistic 回归单元或 softmax回归单元（根据最终目的）

卷积层

池化层

除了卷积层，卷积网络也经常使用池化层来缩减模型的大小，提高计算速度，同时提高所提取特征的鲁棒性。

Max Pooling

如果在过滤器中提取到某个特征，那么保留其最大值。如果没有提取到这个特征，可能在右上象限中不存在这个特征，那么其中的最大值也还是很小，这就是最大池化的直观理解。

以前的公式同样可用于计算 max pooling 的输出大小

它有一组超参数(f=2,s=2)，但并没有参数需要学习.

CNN示例

使用6个过滤器，通过增加了偏差，应用了非线性函数，最后输出 CONV1 的结果。然后应用池化层，使用最大池化，将该输出标记为 POOL1

池化层没有权重，所以被并为第一层

5×5×16 矩阵包含 400 个元素，现在将 POOL2 平整化为一个大小为 400 的一维向量。我

们可以把平整化结果想象成这样的一个神经元集合，然后利用这 400 个单元构建下一层。下

一层含有 120 个单元，这就是我们第一个全连接层，标记为 FC3 。400个输入的每一个单元都和120输出的每一个单元相连，这就是 全连接层 。它的权重矩阵为 𝑊 [3] ，维度为 120×400 。

在神经网络之中，使用卷积和只用全连接层相比，卷积层的两个主要优势在于参数共享和稀疏连接

残差网络（ResNet）

对训练很深的网络有很大帮助

残差块：在深度神经网络中的一个子网络，由多个层组成，其中包含了跳跃连接（skip connection）来绕过一些层，使得网络可以更好地学习和优化。通过堆叠多个残差块来构建深度残差网络。

我们将𝑎 [𝑙]直接向后，拷贝到神经网络的深层，在 ReLU 非线性激活函数前加上𝑎 [𝑙] ，这是一条捷径。𝑎 [𝑙]的信息直接到达神经网络的深层，不再沿着主路径传递

1×1卷积

可以缩小通道数、降低计算成本

计算左图中 32 个数字和过滤器中 32 个数字的元素积之和，然后应用 ReLU 非线性函数。

降低计算成本

inception 模块

使用各种类型的过滤器，然后组合到一起

MobileNet

深度可分离卷积（Depthwise Seqarable Convolution）

对比普通卷积分成了两步：(降低了计算成本)

深度卷积（Depthwise convolution）

红色对应红色，一层一层的计算

逐点卷积（Pointwise Convolution）

数据增强（Data augmentation）

大部分的计算机视觉任务使用很多的数据，所以数据增强是经常使用的一种技巧来提高

计算机视觉系统的表现。

垂直镜像、随机裁剪

色彩变换

目标检测

滑动窗口检测（效果不好、太慢或者步长小检测窗口太多）

滑动窗口目标检测器可以用卷积的形式来更高效的实现

卷积实现滑动窗口

如何将神经网络中的全连接层转化成卷积层

使用400个 5×5×16的过滤器

用卷积的形式来实现滑动窗口目标识别

（上方是检测窗口，下方是实际图片）

让检测过程中这4次卷积神经网络的向前运算，共享计算过程：

结果的蓝色1×1×4的子域，就是对左上14×14的图像做（原来的）卷积运算的结果。

右上1×1×4黄色，对应输入的右上的卷积结果

精准输出边界框

YOLO算法（You Only Look Once）

YOLO 算法做的就是，取两个对象的中点，然后将这个对象分配给包含对象中点的网格元中

它显式地输出边界框坐标，所以这能让神经网络输出边界框，可以具有任意宽高比，并且能

输出更精确的坐标，不会受到滑动窗口分类器的步长大小限制

𝑏 𝑥 、 𝑏 𝑦 、 𝑏 ℎ 和 𝑏 𝑤 单位是相对于格子尺寸的比例，所以𝑏 𝑥 和 𝑏 𝑦 必须在 0 和 1 之间

交并比（IOU）

评价对象检测算法好坏

非极大值抑制（Non-max suppression）

运用图像分类和定位的算法，可能有很多网格识别出对象。

非极大值抑制：先根据PC概率找出最高的网格，然后去掉（抑制）和它有着高IOU值的网格

输出有最大可能性的分类判断，而抑制那些非最大可能性的临近方框

当然，首先丢弃的是pc<0.6的网格

锚框（Anchor Boxes ）

一个网格要检测多个目标：

预先定义两个不同形状的 anchor box，或者 anchor box 形状，你要做的是把预测结果和这两个 anchor box 关联起来。（通常锚框可以有多个）

通过查看IOU值，被检测物体不仅会被分配给网格，还会分配给（格子、锚框）这个组合。

YOLO目标检测算法（You Only Look Once）

最后你要运行一下这个非极大值抑制，如果你有三个对象检测类别，你希望检测行人，汽车和摩托车，那么你要做的是，对于每个类别单独运行非极大值抑制，处理预测结果所属类别的边界框

R-CNN （伴随区域(region)的CNN）

这个算法尝试选出一些区域，在这些区域上运行卷积网络分类器是有意义的，所以这里不再

针对每个滑动窗运行检测算法，而是只选择一些窗口，在少数窗口上运行卷积网络分类器

选出候选区域的方法是运行图像分割算法

用u-net进行语义分割

通过语义分割，算法尝试标记每个像素，检测到对象周围的仔细轮廓

转置卷积

转置卷积是单元架构的关键部分，他可以放大输入

在转置卷积中，不是将过滤器放在输入上，而是在输出上放置一个过滤器

p=1，填充到输出上

在红色和绿色框重叠的部分，将两个值相加

u-net结构

为了做出预测，需要两种信息：一是从前一层获得的高层次的上下文信息。（但是红色圆圈部分具有较低的空间分辨率）。一是跳过连接所提供的、低层次的的高分辨率、低级别的特征。

人脸识别

需要解决：

单样本学习问题（one-shot learning）

学习一个 相似性（Similarity）函数：

使用神经网络学习这样一个用𝑑 表示的函数， 𝑑(𝑖𝑚𝑔1,𝑖𝑚𝑔2) = 𝑑𝑒𝑔𝑟𝑒𝑒 𝑜𝑓 𝑑𝑖𝑓𝑓𝑒𝑟𝑒𝑛𝑐𝑒 𝑏𝑒𝑡𝑤𝑒𝑒𝑛 𝑖𝑚𝑎𝑔𝑒𝑠，它以两张图片作为输入，然后输出这两张图片的差异值。

如果这两张图片的差异值小于某个阈值𝜏，它是一个超参数，那么这时就能预测这两张图片是同一个人

孪生神经网络（Siamese network）

实现上述功能的一个方式就是用 Siamese 网络

你可以把𝑓(𝑥 (1) ) 看作是输入图像 𝑥 (1) 的编码

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

网络架构

三元组损失（Triplet Loss）

要想通过学习神经网络的参数来得到优质的人脸图片编码，方法之一就是定义三元组损

失函数然后应用梯度下降

它代表你通常会同时看三张图片，你需要看 Anchor 图片、Postive 图片，还有 Negative 图片，我要把 Anchor 图片、 Positive 图片和 Negative 图片简写成𝐴 、 𝑃 、 𝑁 。

这个𝑚𝑎𝑥 函数的作用就是，只要这个 ||𝑓(𝐴) − 𝑓(𝑃)|| 2 − ||𝑓(𝐴) − 𝑓(𝑁)|| 2 + 𝑎 ≤ 0 ，那么

损失函数就是 0 。

对这种代价函数用梯度下降，这个代价函数就是定义在从训练集中抽取图片上的三元组。

人脸验证与二分类

可以把人脸识别当做一个二元分类问题的基于Siamese网络架构的方法，也适用于通过 Triplet Loss函数来学习编码

神经风格迁移算法

定义一个生成图像G的代价函数J，来衡量生成图像的质量有多好。通过使用梯度下降法去最小化𝐽(𝐺) ，以便于生成想要的图像。

神经风格转换算法的全局代价函数：

内容代价函数

风格代价函数

我们要做的就是将图片的风格定义为 𝑙 层中各个通道之间激活项的相关系数。

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

𝑎 𝑖, 𝑗, 𝑘 [𝑙](𝑆)和 𝑎 𝑖 [ , 𝑙 𝑗 ] , ( 𝑘 𝐺) 中的上标 (𝑆) 和 (𝐺) 分别表示在风格图像 S 中的激活项和在生成图像 𝐺 的激活项。

将𝑘 和 𝑘′ 通道中对应位置的激活项都进行相乘，这就是 𝐺 𝑘𝑘 [𝑙] ′ 的定义。通过对 𝑘和 𝑘′ 通道中所有的数值进行计算就得到了 𝐺 矩阵，也就是风格矩阵。

风格代价函数

循环神经网络（RNN）

多应用于序列化数据（如：音频（时序组成的）、语言）

门控循环单元（Gated Recurrent Unit（GRU单元））

能够更好地捕获非常长距离的依赖，使得RNN更有效

长短期记忆单元（LSTM（long short term memory））

LSTM 是一个比 GRU 更加强大和通用的版本

更新门 𝛤 𝑢 （ the update gate ）、相关门𝛤 𝑟 （ the relevance gate ）

GRU更新只用一个门

在LSTM中：用 𝑎 <𝑡−1> ， 𝑥 <𝑡> 一起来计算遗忘门𝛤 𝑓 ，还有更新门 𝛤 𝑢 以及输出门𝛤o的值

双向RNN

对于大量有自然语言处理问题的文本，有 LSTM 单元的双向 RNN 模型是用的最多的。

双向 RNN 模型需要获取完整的语言表达，才能将预测包含：前向和反向的传播信息以及未来的信

息。

深度RNN（深层循环神经网络）

把这里的输出去掉（上图编号 1 所示），然后换成一些深的层，这些层并不水平

连接，只是一个深层的网络，然后用来预测 𝑦 <1> 。

在NLP中运用（自然语言处理（Natural Language Processing））

词嵌入

可以让算法自动的理解一些类似的词，通过词嵌入的概念就可以构建 NLP 应用。

词嵌入能够达到这种效果，其中一个原因就是学习词嵌入的算法会考察非常大的文本集，

当你的任务的训练集相对较小时，词嵌入的作用最明显，所以它广泛用于 NLP 领域

学习词嵌入则是有一个固定的词汇表，比如 10000 个单词，我们学习向量 𝑒 1 到 𝑒 10000 ，

学习一个固定的编码，每一个词汇表的单词的固定嵌入。

t-SNE 算法

过用 t-SNE 算法来将单词可视化。 t-SNE 算法所做的就是把这些 300 维的数据用一种非线

性的方式映射到 2 维平面上

嵌入矩阵（Embedding Matrix）

因为我们要乘以一大堆的 0 。所以在实践中你会使用一个专门的函数来单独查找矩阵𝐸的某列，而不是用通常的矩阵乘法来做

词嵌入学习算法

如何用更简单的上下文和更简单的算法来建立从上下文到目标词的映射

词转化成向量形式（Word2Vec）

构造一个监督学习问题，它给定上下文词，要求你预测在这个词正负 10 词距或者正负 5 个词距内随机选择的某个目标词，想要使用这个学习问题来学到一个好的词嵌入模型

但我们要解决的基本的监督学习问题是学习一种映射关系，从上下文 c，比如单词 orange ，到某个目标词，记为 t

这是常用的 softmax 损失函数， 𝑦 就是只有一个1 其他都是 0 的 one-hot 向量，类似的 𝑦^ 是一个从softmax 单元输出的 10,000 维的向量，这个向量是所有可能目标词的概率。

如果优化这个关于所有这些参数的损失函数，你就会得到一个较好的嵌入向量集，这个就叫做 Skip-Gram模型。

基础模型

集束搜索（ Beam Search ）算法

集束搜索算法首先做的就是挑选要输出的英语翻译中的第一个单词，绿色是编码部分，紫色是解码部分，来评估第一个单词的概率值，给定输入序列𝑥 ，即法语作为输入，第一个输出 𝑦 的概率值是多少。

集束搜索则会考虑多个选择，集束搜索算法会有一个参数 B，叫做集束宽（beam width ）。在这个例子中我把这个集束宽设成 3，这样就意味着集束搜索不会只考虑一个可能结果，而是一次会考虑 3 个, 然后集束搜索算法会把结果存到计算机内存里以便后面尝试用这三个词

第二步：针对每个第一个单词考虑第二个单词是什么

为了评估第二个词的概率值，我们用这个神经网络的部分，绿色是编码部分，而对于解码部分，当决定单词 in 后面是什么，别忘了解码器的第一个输出𝑦 <1> ，我把𝑦 <1> 设为单词 in （，然后把它喂回来，这里就是单词 in ，因为它的目的是努力找出第一个单词是 in 的情况下，第二个单词是什么。这个输出就是𝑦 <2>

在第二步里我们更关心的是要找到最可能的第一个和第二个单词对，所以要得到的是两个概率相乘