从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

深度学习与自然语言处理(5)_斯坦福cs224d 大作业测验2与解答_斯坦福大学自然语言处理作业

作者：从前慢现在也慢 | 2024-05-27 03:47:46

踩

斯坦福大学自然语言处理作业

作业内容翻译：@胡杨(superhy199148@hotmail.com) && @面包君 && Fantzy同学
校正与调整：寒小阳 && 龙心尘
时间：2016年7月
出处：http://blog.csdn.net/han_xiaoyang/article/details/51815683
http://blog.csdn.net/longxinchen_ml/article/details/51814343

说明：本文为斯坦福大学CS224d课程的中文版内容笔记，已得到斯坦福大学课程@Richard Socher教授的授权翻译

0. 前言

原本打算把作业和答案做个编排，一起发出来给大家看，无奈代码量有点大，贴上来以后文章篇幅过长，于是乎题目的代码解答放到了百度云盘，欢迎自行下载和运行或者调整。

1. Tensorflow 与 softmax（20分）

在本题中，我们会执行一个线性分类器，并会用到下面的交叉熵损失函数：

J_{s o f t m a x - C E} (W) = C E (y, s o f t m a x (x W))

$J_{softmax-CE}(W)=CE(y,softmax(xW))$
（请注意，这里行

x

$x$ 的是行特征向量)。我们会通过Tensorflow 的自动微分功能来训练数据。

a.（4分）
在脚本q1_softmax.py中，通过TensorFlow来构造softmax 函数。softmax的公式如下：

s o f t m a x (x)_{i} = \frac{e^{x_{i}}}{\sum_{j} e^{x_{j}}}

$softmax{(x)_i}=\frac{e^{x_i}}{\sum_je^{x_j}}$

请注意，你不能使用Tensorflow内建的tf.nn.softmax函数或者其他相关内建函数。这道题目做好的标准是你能够通过运行python q1_softmax.py命令将这个函数跑起来（需要跑通一个测试用例。当然，不要求完全详尽的测试。）

b. （4分）
在脚本q1_softmax.py中，通过TensorFlow来构造交叉熵损失函数（Cross Entropy Loss）。交叉熵损失函数的公式长这个样子：

C E (y, \hat{y}) = - \sum_{i = 1}^{N_{c}} y_{i} l o g ({\hat{y}}_{i})

$CE(y,\hat{y})=-\sum_{i=1}^{N_c}{y_ilog(\hat{y}_i)}$

在这里 $y\in\mathbb{R}^5$ 是一个one-hot标签向量， $N_c$ 是所有类目的数量。请注意，你不能使用Tensorflow内建的cross-entropy函数或者其他相关内建函数。这道题目做好的标准是你能够通过运行Python q1_softmax.py脚本将这个函数跑起来（需要写一个测试用例。当然，这同样不要求完全详尽的测试。）

c. （4分）
请仔细学习model.py脚本中的model类。并简要解释一下其中占位符变量 (place holder vaiables)和填充字典（feed dictionaries）函数的目的. 在q1_classifier.py中填充好add_palceholders和creat_feed_dict这两个函数.
提示: 请注意配置变量（configuration variables）在config类中已经储存好了，而在代码中你会用到它们。
答案：在Tensorflow 计算图中，占位符变量是作为其输入节点而存在的。而填充字典函数说明了在计算的时候怎么给这些占位符（或者其他）变量赋值。

d. （4分）
在脚本ql_classifier.py中的add_model函数里完成一个用softmax进行分类的基本流程。并在同一个脚本中的函数add_loss_op中补充好交叉熵损失函数。请注意，使用本题之前提供的函数，而不是 Tensorflow 内建函数。

e. （4分）
在脚本ql_classifier.py中填充完成add_training_op 函数。并解释为什么Tensorflow 的自动微分功能能省去我们直接求梯度的工作。你可以在我们提供的数据上顺利运行python ql_classifier.py命令，并且确保能够跑通测试用例。这样你才能保证你的模型是合适的。
提示：请一定要使用在config类中定义的学习率.
答案：只要正确定义好了计算图，Tensorflow就能自动应用反向传播算法来计算梯度。

2. 神经网络在命名实体识别中的应用（35分）

这一节中，我们会练习反向传播算法和训练深度神经网络，通过它们来实现命名实体识别。命名实体识别是指识别文本中具有特定意义的实体，主要包括人名、地名、机构名、专有名词等。
这其实就是一个5类分类问题（5选1的单选题）。这5类包括上面这4类和1个非实体类——也就是不代表任何实体的类(大部词语都属于这类)。
这个模型是一个单隐藏层神经网络，它有一个类似我们在word2vec中看到的表示层。这里我们不需要求平均值或者抽样，而是明确地将上下文定义为一个“窗口”，这个“窗口”包含目标词和它左右紧邻的词，是一个3d维度的行向量:

x^{(t)} = [x_{t - 1} L, x_{t} L, x_{t + 1} L] \in R^{3 d}

$x^{(t)}=[x_{t-1}L,x_{t}L,x_{t+1}L] \in{R^{3d}}$
这里的

x_{t - 1}, x_{t}, x_{t + 1}

$x_{t-1},x_t,x_{t+1}$ 是one-hot行向量（|V|维），而

L \in R^{| V | \times d}

$L\in\mathbb{R}^{|V|\times{d}}$ 是嵌入矩阵，它的每一行

L_{i}

$L_i$ 其实就代表一个特定的词

i

$i$ 。我们然后做如下预测：

h = t a n h (x^{(t)} W + b_{1})

$h=tanh(x^{(t)}W+b_1)$

\hat{y} = s o f t m a x (h U + b_{2})

$\hat{y}=softmax(hU+b_2)$
之后通过交叉熵损失函数来评估误差：

J (θ) = C E (y, \hat{y}) = - \sum_{i = 1}^{5} y_{i} l o g ({\hat{y}}_{i})

$J(\theta)=CE(y,\hat{y})=-\sum_{i=1}^{5}y_ilog(\hat{y}_i)$
为了计算整个训练集的损失，我们在对每个训练样本计算

J (θ)

$J(\theta)$ 之后将其求和（或者求平均值）。
对于本题，令

d = 50

$d=50$ 作为词向量的长度。3个向量组成了一个宽度为

3 \times 50 = 150

$3×50=150$ 的窗口。隐藏层有100个神经元,输出层有5个神经元.

(part a)
（5分）请计算损失函数 $J(\theta)$ 在下列模型各个参数上的梯度

\frac{\partial J}{\partial U}

$\frac {\partial J}{\partial U}$

\frac{\partial J}{\partial b_{2}}

$\frac {\partial J}{\partial {b_2}}$

\frac{\partial J}{\partial W}

$\frac {\partial J}{\partial W}$

\frac{\partial J}{\partial b_{1}}

$\frac {\partial J}{\partial {b_1}}$

\frac{\partial J}{\partial L_{i}}

$\frac {\partial J}{\partial {L_i}}$
，这里矩阵的维度分别是

U \in R^{100 \times 5}

$U\in{R^{100\times5}}$

b_{2} \in R^{5}

$b_2\in{R^5}$

W \in R^{150 \times 100}

$W\in{R^{150\times100}}$

b_{1} \in R^{100}

$b_1\in{R^{100}}$

L_{i} \in R^{50}

$L_i\in{R^{50}}$
提示：为了能够清晰的表示反向传播的过程，我们给您推荐两个小trick：

使用激活函数的值来代替激活函数的微分。就像作业1中的 $sigmoid$ 函数一样，下面这个函数也可以起到相同的作用。
$t a n h (z) = 2 s i g m o i d (2 z) - 1$ $tanh(z)=2sigmoid(2z)-1$
使用“残差向量”的形式来表示某一层的梯度。这意味着我们的链式法则，现在可以写成用括号括起来的向量(矩阵)乘法的形式，这将使您的分析过程大大简化。

值得注意的是，损失函数在模型各参数上的梯度应该化简到可以使用矩阵运算的形式。（通过作业1，相信您已经掌握的很熟练了:)）

答案：
由提示公式可得：

t a n h^{'} (z) = 4 s i g m o i d (2 z) (1 - s i g m o i d (2 z))

$tanh'(z) = 4sigmoid(2z)(1-sigmoid(2z))$
可得偏微分如下：

\frac{\partial J}{\partial U} = h^{T} (y - \hat{y})

$\frac {\partial J}{\partial U}=h^T(y-\hat{y})$

\frac{\partial J}{\partial b_{2}} = y - \hat{y}

$\frac {\partial J}{\partial {b_2}}=y-\hat{y}$

\frac{\partial J}{\partial h} = (y - \hat{y}) U^{T}

$\frac {\partial J}{\partial h}=(y-\hat{y})U^T$

\frac{\partial J}{\partial W} = (x^{(t)})^{T} (\frac{\partial J}{\partial h} ⨀ t a n h^{'} (2 (x^{(t)} W + b_{1})))

$\frac {\partial J}{\partial W}=(x^{(t)})^T\left(\frac {\partial J}{\partial h}\bigodot tanh'(2(x^{(t)}W+b_1))\right)$

\frac{\partial J}{\partial b_{1}} = (\frac{\partial J}{\partial h} ⨀ t a n h^{'} (2 (x^{(t)} W + b_{1})))

$\frac {\partial J}{\partial {b_1}}=\left(\frac {\partial J}{\partial h}\bigodot tanh'(2(x^{(t)}W+b_1))\right)$

\frac{\partial J}{\partial x (t)} = (\frac{\partial J}{\partial h} ⨀ t a n h^{'} (2 (x^{(t)} W + b_{1}))) W^{T}

$\frac {\partial J}{\partial {x{(t)}}}=\left(\frac {\partial J}{\partial h}\bigodot tanh'(2(x^{(t)}W+b_1))\right)W^T$
我们令

i = x_{t}, j = x_{t - 1}, k = x_{t + 1}

$i=x_t, j=x_{t-1}, k=x_{t+1}$ ，可得：

\frac{\partial J}{\partial x (t)} = [\frac{\partial J}{\partial L_{i}}, \frac{\partial J}{\partial L_{j}}, \frac{\partial J}{\partial L_{k}}]

$\frac {\partial J}{\partial {x{(t)}}}=\left[\frac {\partial J}{\partial {L_i}},\frac {\partial J}{\partial {L_j}},\frac{\partial J}{\partial {L_k}}\right]$

(part b)（5分）
神经网络的训练过程往往不是一帆风顺的，许多小问题都会影响模型的性能，例如神经网络中参数过多会导致训练太慢，神经元之间相关性太强会导致模型陷入局部最优。为了避免上述两种情况的发生，我们在(part a)损失函数的基础上增加一个高斯先验。可别小看这个高斯先验，它能使我们的模型参数/权重不会有那么夸张的幅度(更向0值靠拢)，同时又能保证大部分参数都有取值（不会对起作用的特征产生太大影响），从而保证了模型在实际场景中的可用性（泛化能力强一些）。混合后的损失函数就长这样。

J_{f u l l} (θ) = J (θ) + J_{r e g} (θ)

$J_{full}(\theta)=J(\theta)+J_{reg}(\theta)$
有了混合损失函数，下面就可以开始将似然函数求最大化了（就像上面我们对交叉熵求最大化那样），高斯先验在这个过程中就会变成一个平方项的形式（

L 2

$L2$ 正则化项）。

J_{r e g} (θ) = \frac{λ}{2} [\sum_{i, j} W_{i j}^{2} + \sum_{i^{'}, j^{'}} W_{i^{'} j^{'}}^{2}]

$J_{reg}(\theta)=\frac {\lambda}2\left[\sum_{i,j}W_{ij}^2+\sum_{i',j'}W_{i'j'}^2\right]$
要对似然函数求极大，我们所采用的方法是梯度上升，所以本题的任务还是请您来求一下梯度。与(part a)中不同的是，我们这里的损失函数多了一个由高斯先验得来的正则化项。所以，聪明的你，给我个答案吧。
答案：

\partial J_{f u l l} = \partial J + \partial J_{r e g}

$\partial J_{full}=\partial J+\partial J_{reg}$

\frac{\partial J_{r e g}}{\partial W} = λ W

$\frac{\partial J_{reg}}{\partial W}=\lambda W$

\frac{\partial J_{r e g}}{\partial U} = λ U

$\frac{\partial J_{reg}}{\partial U}=\lambda U$
将

W

$W$ 和

V

$V$ 的梯度代入即可。

(part c)（5分）
在part b中我们了解到，如果神经元之间的相关性太强，模型就容易陷入局部最优，从而降低了模型的泛化能力。对此，我们的解决方法是使用L2正则化项对模型参数加以限制。在本题中，我们提供另外一种方法，叫做“参数随机初始化”。在众多参数随机初始化的方法中，我们使用最多的是Xavier方法。
Xavier方法的原理是这样的：给定一个 $m\times n$ 的矩阵 $A$ 和一个区间[ $-\epsilon, \epsilon$ ]，从该范围中进行均匀采样作为 $A_{ij}$ ，其中

ϵ = \frac{\sqrt{6}}{\sqrt{m + n}}

$\epsilon=\frac{\sqrt 6}{\sqrt{m+n}}$
好了，根据算法原理，请你在 q2_initialization.py的 xavier_weight_init中，用代码来实现一下吧。

(part d)（20分）
在q2_NER.py中，我们实现了一个命名实体窗口(NER Window)模型。模型的输入是sections（小编注：sections在特定情况下可以看作是一句查询，每个section由一些tokens组成，即分词），输出就是命名实体的标签。您可以看一下代码，您刚刚推导的反向传播过程在代码中已经被实现了，是不是很神奇！？
以下工作需要您来完成：

您需要在q2_NER.py中实现命名实体窗口模型部分的代码，我们会根据算法正确性和程序是否可执行来进行打分。
您需要说明模型最佳的参数的值，主要有正则化项、特征维度、学习速率和SGD批量的大小等。您还需要说明模型在交叉验证集上的误差，本课程要求模型在交叉验证集上的误差不高于0.2。
您需要将测试集的预测结果保存在q2_test.predicted文件中，格式为一行一个label，我们会根据真实结果来评估您模型的泛化能力。
提示1：在debug模式中，请将参数max_epchs设为1，并且将load_data中debug参数设为True。
提示2：请注意程序的时间复杂度，保证在GPU上不超过15分钟，CPU上不超过1小时。

3.递归神经网络：语言建模(45分)

在这一节，你将首次实现一个用于建立语言模型的递归神经网络。

语言模型的建立是NLP技术的核心部分，语言模型被广泛使用于语音识别，机器翻译以及其他各类系统。给出一串连续的词 $x_1,\ldots,x_t$ ,关于预测其后面紧跟的词 $x_{t+1}$ 的建模方式是：

P (x_{t + 1} = υ_{j} | x_{t}, \dots, x_{1})

$P(x_{t+1}=\upsilon_j|x_t,\ldots,x_1)$
其中，

υ_{j}

$\upsilon_j$ 是词库中的某个词。

你的任务是实现一个递归神经网络，此网络利用隐层中的反馈信息对“历史记录” $x_t,x_{t-1},\ldots,x_1$ 进行建模。关于 $t=1,\ldots,n-1$ 形式化的表示如文献^[3]所描述:

\begin{matrix} (10) & e^{(t)} = x^{(t)} L \end{matrix}

$e^{(t)}=x^{(t)}L\tag{10}$

\begin{matrix} (11) & h^{(t)} = s i g m o i d (h^{(t - 1)} H + e^{t} I + b_{1}) \end{matrix}

$h^{(t)}=\mathrm{sigmoid}(h^{(t-1)}H+e^{t}I+b_1)\tag{11}$

\begin{matrix} (12) & {\hat{y}}^{(t)} = s i g m o i d (h^{(t)} U + b_{2}) \end{matrix}

${\hat{y}}^{(t)}=\mathrm{sigmoid}(h^{(t)}U+b_2)\tag{12}$

\begin{matrix} (13) & \bar{P} (x_{t + 1} = υ_{j} | x_{t}, \dots, x_{1}) = {\hat{y_{j}}}^{(t)} \end{matrix}

$\bar{P}(x_{t+1}=\upsilon_j|x_t,\ldots,x_1)={\hat{y_j}}^{(t)}\tag{13}$
其中，

h^{(0)} = h_{0} \in R^{D_{h}}

$h^{(0)}=h_0\in{\mathbb{R}^{D_h}}$ 是隐藏层的初始化向量，

x^{(t)} L

$x^{(t)}L$ 是以

x^{(t)}

$x^{(t)}$ 为one-hot行向量与嵌入矩阵

L

$L$ 的乘积，这个one-hot行向量就是当前处理词汇的索引。具体的一些参数设置如下：

\begin{matrix} (14) & L \in R^{| V | \times d} H \in R^{D_{h} \times D_{h}} I \in R^{d \times D_{h}} b_{1} \in R^{D_{h}} U \in R^{D_{h} \times | V |} b_{2} \in R^{| V |} \end{matrix}

$L\in\mathbb{R}^{|V|\times{d}}\quad H\in\mathbb{R}^{D_h\times{D_h}}\quad I\in\mathbb{R}^{d\times{D_h}}\quad b_1\in\mathbb{R}^{D_h}\quad U\in\mathbb{R}^{D_h\times{|V|}}\quad b_2\in\mathbb{R}^{|V|}\tag{14}$
其中，

L

$L$ 是词嵌入矩阵，

I

$I$ 是输入词表征矩阵，

H

$H$ 是隐藏转化矩阵，还有

U

$U$ 是输出词表征矩阵。

b_{1}, b_{2}

$b_1,b_2$ 是偏置值。

d

$d$ 是词嵌入的维数，

| V |

$|V|$ 代表词库的规模，然后

D_{h}

$D_h$ 是隐层的维数。

输出向量 $\hat{y}^{(t)}\in\mathbb{R}^{|V|}$ 是面向整个词库的概率分布，我们需要最优化交叉熵（非正则化的）的损失率：

\begin{matrix} (15) & J^{(t)} (θ) = C E (y^{(t)}, {\hat{y}}^{(t)}) = - \sum_{i = 1}^{| V |} y_{i}^{(t)} \log {\hat{y}}^{(t)} \end{matrix}

$J^{(t)}(\theta)=CE(y^{(t)},\hat{y}^{(t)})=-\sum_{i=1}^{|V|}y_i^{(t)}\log{\hat{y}^{(t)}}\tag{15}$
其中，

y^{(t)}

$y^{(t)}$ 是与目标词（这里表示为

x_{t + 1}

$x_{t+1}$ ）对应的one-hot向量。正如注释[2]所描述的，它是一个对于单个样本点的损失率，然后我们对序列中全部样例的交叉熵损失值做求和（或求平均）计算，对数据集中的全部序列 ^[4]均采取上述操作以衡量模型的性能。

(a) (5分)
通常地，我们使用困惑度来评估语言模型的性能，其定义形式如下：

\begin{matrix} (16) & {P P}^{(t)} (y^{(t)}, {\hat{y}}^{(t)}) = \frac{1}{\bar{P} (x_{t + 1}^{p r e d} = x_{t + 1} | x_{t}, \dots, x_{1})} = \frac{1}{\sum_{j = 1}^{| V |} y_{j}^{(t)} \cdot {\hat{y}}^{(t)}} \end{matrix}

${PP}^{(t)}\left(y^{(t)},\hat{y}^{(t)}\right)=\frac{1}{\bar{P}(x_{t+1}^\mathrm{pred}=x_{t+1}|x_t,\ldots,x_1)}=\frac{1}{\sideset{}{_{j=1}^{|V|}} \sum{y_j^{(t)}}\cdot\hat{y}^{(t)}}\tag{16}$
即通过模型分布

\bar{P}

$\bar{P}$ 得到词预测正确的逆概率。给出你是如何从交叉熵的损失率中得到困惑度的（ 提示：不要忘了向量 $y^{(t)}$ 是one-hot形式的！），因此如果要进行最小化操作（从算术上）意味着（从几何上讲）交叉熵损失率将被最小化，就得到了在训练集上的困惑度。 在这一部分要处理的是一个非常短小的问题-所以并不需要过大的困惑度！
对于一个词库

| V |

$|V|$ 中的词汇，如果你的模型做出的预测是完全随机的，你将如何预测你的困惑度呢？计算词库规模为

| V | = 2000

$|V|=2000$ 和

| V | = 10000

$|V|=10000$ 时对应的交叉熵损失率，并且将其作为基准牢记于心。

解答：使用的样例 $y^{(t)}$ 为one-hot模型，且假定 $y_i^{(t)}$ 是 $y^{(t)}$ 中唯一的非零元素。于是，记：

C E (y^{(t)}, {\hat{y}}^{(t)}) = - \log {\hat{y}}_{i}^{(t)} = \log \frac{1}{{\hat{y}}^{(t)}}

$CE(y^{(t)},\hat{y}^{(t)})=-\log\hat{y}_i^{(t)}=\log\frac{1}{\hat{y}^{(t)}}$

P P^{(t)} (y^{(t)}, {\hat{y}}^{(t)}) = \frac{1}{{\hat{y}}_{i}^{(t)}}

$PP^{(t)}(y^{(t)},\hat{y}^{(t)})=\frac{1}{\hat{y}_i^{(t)}}$
因此，上式可以被联立为如下形状：

C E (y^{(t)}, {\hat{y}}^{(t)}) = \log P P^{(t)} (y^{(t)}, {\hat{y}}^{(t)})

$CE(y^{(t)},\hat{y}^{(t)})=\log PP^{(t)}(y^{(t)},\hat{y}^{(t)})$
这条公式展示了交叉熵在数学意义上的最小化目标，同时表达了困惑度在几何意义上的最小值。当模型的预测值完全随机化时，会有

E [{\hat{y}}_{i}^{(t)}] = \frac{1}{| V |}

$E[\hat{y}_i^{(t)}]=\frac{1}{|V|}$ 。所给的向量

y^{(t)}

$y^{(t)}$ 是one-hot模型，所对应困惑度的期望值是

| V |

$|V|$ 。由于困惑度的对数即为交叉熵，那么交叉熵的期望值在面对上述两个词库规模时分别应为

\log 2000 \approx 7.6

$\log2000\approx7.6$ 和

\log 10000 \approx 9.21

$\log10000\approx9.21$ 。

(b) (5分)
正如注释[2]所描述的操作，在时刻 $t$ 关于单点全部模型参数的梯度计算如下：

\frac{\partial J^{(t)}}{\partial U} \frac{\partial J^{(t)}}{\partial b_{2}} \frac{\partial J^{(t)}}{\partial L_{x^{(t)}}} {\frac{\partial J^{(t)}}{\partial I} |}_{(t)} {\frac{\partial J^{(t)}}{\partial H} |}_{(t)} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t)}

$\frac{\partial{J^{(t)}}}{\partial{U}}\quad \frac{\partial{J^{(t)}}}{\partial{b_2}}\quad \frac{\partial{J^{(t)}}}{\partial{L_{x^{(t)}}}}\quad \left.\frac{\partial{J^{(t)}}}{\partial{I}}\right|_{(t)}\quad \left.\frac{\partial{J^{(t)}}}{\partial{H}}\right|_{(t)}\quad \left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t)}$
其中，

L_{x^{(t)}}

$L_{x^{(t)}}$ 是词嵌入矩阵

L

$L$ 中对应到当前处理词汇

x^{(t)}

$x^{(t)}$ 的列，符号

|_{(t)}

$|_{(t)}$ 表示时刻

t

$t$ 该参数的显式梯度。（同样地，

h^{(t - 1)}

$h^{(t-1)}$ 的取值是固定的，而且你现在也不需要在早先的迭代时刻中实现反向传播算法——这是c小节的任务）。

此外，还要计算代表前趋隐层权值的导数：

\frac{\partial J^{(t)}}{\partial h^{(t - 1)}}

$\frac{\partial{J^{(t)}}}{\partial{h^{(t-1)}}}$

解答：调用函数 $\frac{d}{dz}\mathrm{sigmoid}(z)=\mathrm{sigmoid}(z)(1-\mathrm{sigmoid}(z))$ 。

\frac{\partial J^{(t)}}{\partial U} = (h^{(t)})^{T} (y - \hat{y})

$\frac{\partial{J^{(t)}}}{\partial{U}}=(h^{(t)})^T(y-\hat{y})$

\frac{\partial J^{(t)}}{\partial h^{(t)}} = (y - \hat{y}) U^{T}

$\frac{\partial{J^{(t)}}}{\partial{h^{(t)}}}=(y-\hat{y})U^T$

\frac{\partial J^{(t)}}{\partial b_{2}} = (y - \hat{y})

$\frac{\partial{J^{(t)}}}{\partial{b_2}}=(y-\hat{y})$

{\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t)} = (\frac{\partial J^{(t)}}{\partial h^{(t)}} ⊙ {s i g m o i d}^{^{'}} (h^{(t - 1)} H + e^{(t)} I + b_{1}))

$\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t)}=\left(\frac{\partial{J^{(t)}}}{\partial{h^{(t)}}}\odot\mathrm{sigmoid}^{'}(h^{(t-1)}H+e^{(t)}I+b_1)\right)$

\frac{\partial J^{(t)}}{\partial L_{x^{(t)}}} = \frac{\partial J^{(t)}}{\partial e^{(t)}} = {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t)} I^{T}

$\frac{\partial{J^{(t)}}}{\partial{L_{x^{(t)}}}}=\frac{\partial{J^{(t)}}}{\partial{e^{(t)}}}=\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t)}I^T$

{\frac{\partial J^{(t)}}{\partial I} |}_{(t)} = (e^{(t)})^{T} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t)}

$\left.\frac{\partial{J^{(t)}}}{\partial{I}}\right|_{(t)}=(e^{(t)})^T\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t)}$

{\frac{\partial J^{(t)}}{\partial H} |}_{(t)} = (h^{(t - 1)})^{T} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t)}

$\left.\frac{\partial{J^{(t)}}}{\partial{H}}\right|_{(t)}=(h^{(t-1)})^T\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t)}$

\frac{\partial J^{(t)}}{\partial h^{(t - 1)}} = H^{T} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t)}

$\frac{\partial{J^{(t)}}}{\partial{h^{(t-1)}}}=H^T\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t)}$

(c) (5分)
下面为一步迭代的网络框图：

绘制下面三次迭代所“展开”的网络，并且计算迭代时后向传播的梯度：

\frac{\partial J^{(t)}}{\partial L_{x^{(t - 1)}}} {\frac{\partial J^{(t)}}{\partial H} |}_{(t - 1)} {\frac{\partial J^{(t)}}{\partial I} |}_{(t - 1)} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t - 1)}

$\frac{\partial{J^{(t)}}}{\partial{L_{x^{(t-1)}}}}\quad \left.\frac{\partial{J^{(t)}}}{\partial{H}}\right|_{(t-1)}\quad \left.\frac{\partial{J^{(t)}}}{\partial{I}}\right|_{(t-1)}\quad \left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t-1)}$
这里

|_{(t - 1)}

$|_{(t-1)}$ 代表模型参数在

(t - 1)

$(t-1)$ 时刻的显式梯度。由于这些参数在前馈计算中要被多次使用，我们需要在每次迭代时都计算一下它们的梯度。

最好参考讲义[5]所描述的后向传播原理去将这些梯度表达成残差的形式：

δ^{(t - 1)} = \frac{\partial J^{(t)}}{\partial h^{(t - 1)}}

$\delta^{(t-1)}=\frac{\partial{J^{(t)}}}{\partial{h^{(t-1)}}}$
（同样的表达方式在迭代时刻

t - 2, t - 3

$t-2,t-3$ 以及更多的时候都同样适用）。

注意一个训练样本的实际梯度是需要我们将直到 $t=0$ 时刻的整条后向路径都使用后向传播算法迭代完成后才能得到的。在练习中，我们通常只需截取固定数值 $\tau\approx3-5$ 的后向传播步骤即可。

解答：

还是延续前一节的条件

{\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t - 1)} = δ^{(t - 1)} ⊙ {s i g m o i d}^{^{'}} (h^{(t - 2)} H + e^{(t - 1)} I + b_{1})

$\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t-1)}=\delta^{(t-1)}\odot\mathrm{sigmoid}^{'}(h^{(t-2)}H+e^{(t-1)}I+b_1)$

\frac{\partial J^{(t)}}{\partial L_{x^{(t - 1)}}} = {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t - 1)} I^{T}

$\frac{\partial{J^{(t)}}}{\partial{L_{x^{(t-1)}}}}=\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t-1)}I^T$

{\frac{\partial J^{(t)}}{\partial I} |}_{(t - 1)} = (e^{(t - 1)})^{T} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t - 1)}

$\left.\frac{\partial{J^{(t)}}}{\partial{I}}\right|_{(t-1)}=(e^{(t-1)})^T\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t-1)}$

{\frac{\partial J^{(t)}}{\partial H} |}_{(t - 1)} = (h^{(t - 2)})^{T} {\frac{\partial J^{(t)}}{\partial b_{1}} |}_{(t - 1)}

$\left.\frac{\partial{J^{(t)}}}{\partial{H}}\right|_{(t-1)}=(h^{(t-2)})^T\left.\frac{\partial{J^{(t)}}}{\partial{b_1}}\right|_{(t-1)}$

(d) (3分)
对于给定的 $h^{(t-1)}$ ,执行一轮前向传播计算 $J^{(t)}(\theta)$ 需要多少操作？执行一轮后向传播又会如何呢？执行 $\tau$ 轮呢？对于维度参数组 $d,D_h$ 和 $|V|$ ,使用符号“大写-O”来表示你的答案（如公式14）。是否该慎重考虑这一步？

回忆各个参数的设置： $h^{(t-1)}$ 大小为 $D_h$ ， $e^{(t)}$ 大小为 $d$ ，还有 $\hat{y}^{(t)}$ 的大小为 $|V|$ 。计算 $e^{(t)}$ 花费的时间 $O(d)$ 视矩阵 $L$ 而定。计算 $h^{(t)}$ 花费的时间 $O(D_h^2+dD_h)$ ，计算 $\hat{y}^{(t)}$ 花费时间 $O(D_h|V|)$ 。后向传播和前向传播算法具有相同的时间复杂度，于是，计算 $\tau$ 轮的前向或后向传播复杂度仅通过 $\tau$ 与先前得到的复杂度值相乘即可。由于 $|V|$ 比较大的原因，计算 $\hat{y}^{(t)}$ 的“较慢的一步”计算需花费时长 $O(D_h|V|)$ 。

(e) (20分)
在代码q3_RNNLM.py中实现以上的模型。其中已经实现了数据加载器和其它的初始化功能代码。顺着已有代码的指引来补充缺失的代码。执行命令行python q3_RNNLM.py将运行该模型。注意，在运行过程中你不能用到tensorflow库的内置函数，如rnn_cell模块。

在ptb－train数据集中训练该模型，其中包含Penn Treebank中WSJ语料集的前20节语料。正如在Q 2部分中所说的，你应该最大限度地提高该模型在实际生产中数据集上的泛化性能（即最小化交叉熵损失率）。关于模型的性能，我们将通过未知但类似的句子集来进行评估。

撰写实验报告的一些要求：

在你实验报告中，应包括最优超参数（如训练框架、迭代次数、学习率、反馈频率）以及在ptb-dev数据集上的困惑度。正常情况应当保持困惑度值低于175。
在报告中还应当包含最优模型的相关参数；方便我们测试你的模型。
提示：在调试过程中把参数max_epochs的值设为1。在_init_方法中通过设置参数关键字debug=True来开启对load_data方法的调用。
提示：该模型代码在GPU上运行很快（低于30分钟），而在CPU上将耗时多达4小时。

(f) (7分)
作业1和该作业中的q2部分所示的神经网络是判别模型：他们接收数据之后，对其做出预测。前面你实现的RNNLM模型是一个生成式模型，因为它建模了数据序列 $x1,\dots,xn$ 的分布状况。这就意味着我们不仅能用它去评估句子生成概率，而且还能通过它生成概率最优的语句！

训练完成后，在代码q3 RNNLM.py 中实现函数generate_text()。该函数首先运行RNN前向算法，在起始标记<eos>处建立索引，然后从每轮迭代的 $\hat{y}^{(t)}$ 分布对新词 $x_{t+1}$ 进行采样。然后把该词作为下一步的输入，重复该操作直至该模型遇到一个结束标志（结束标志记为</eos>）。

撰写实验报告的一些要求：

在你的实验报告中至少包含2-3条的生成语句。看看你是否能产生一些妙趣横生的东西！

一些参考建议：
如果你想用语言模型继续实验，非常欢迎你上传自己的文档和对其训练成果——有时会是一个令人惊喜的实验结果！（可从网站http://kingjamesprogramming.tumblr.com/ 上获取以纪念版《圣经》和书籍《计算机程序设计与实现》为混合语料进行训练的伟大成果。）
[1]Optional (not graded): The interested reader should prove that this is indeed the maximum-likelihood objective when we let $W_{ij}\sim N(0,1/\lambda)$ for all $i,j$ .
[2]This is also referred to as Glorot initialization and was initially described in http://jmlr.org/proceedings/papers/v9/glorot10a/glorot10a.pdf
[3]这个模型可以参考Toma Mikolov的论文, 发表于2010年: http://www.fit.vutbr.cz/research/groups/speech/publi/2010/mikolov_interspeech2010_IS100722.pdf
[4]我们使用Tensorflow库函数计算此处的损失率。
[5]http://cs224d.stanford.edu/lectures/CS224d-Lecture5.pdf

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/629700