LSTM python 实现理解

LSTM理解

本文是对Nico’s blog Simple LSTM 翻译.

​ 几个星期前，我在Github上发布了一些LSTM代码，以帮助人们了解LSTM在实现层面的工作方式。 前向传递在其他地方都有很好的解释并且很容易理解[可参考wangduo对LSTM翻译]，但是我自己导出了backprop方程，并且backprop代码没有任何解释。 这篇文章的目的是在LSTM的背景下解释所谓的反向传播。

​ 注意：本文假设您了解LSTM网络的正向传递，因为这部分相对简单。 如果您对此不熟悉，请阅读这篇精彩的介绍文章，因为它包含了一个非常好的LSTM介绍。 我遵循与本文相同的表示法，因此我建议阅读本教程时,在单独的浏览器选项卡中打开论文，以便在阅读本文时方便参考。

介绍:

​ LSTM节点的正向传递定义如下：
$$\begin{array}{rl}g(t)& =\varphi \left(W_{gx}x(t)+W_{gh}h(t-1)+b_g\right)\\ i(t)& =\sigma \left(W_{ix}x(t)+W_{ih}h(t-1)+b_i\right)\\ f(t)& =\sigma \left(W_{fx}x(t)+W_{fh}h(t-1)+b_f\right)\\ o(t)& =\sigma \left(W_{ox}x(t)+W_{oh}h(t-1)+b_o\right)\\ s(t)& =g(t)\ast i(t)+s(t-1)\ast f(t)\\ h(t)& =s(t)\ast o(t)\end{array}$$
​ 上面公式表示图示为:

​ 将$x(t)$和h(t-1)组合成为一个向量如下:
$$x_c(t)=[x(t),h(t-1)]$$
​ 我们可以重写上面的部分内容如下：
$$\begin{array}{rl}g(t)& =\varphi \left(W_g{x}_c(t)+b_g\right)\\ i(t)& =\sigma \left(W_i{x}_c(t)+b_i\right)\\ f(t)& =\sigma \left(W_f{x}_c(t)+b_f\right)\\ o(t)& =\sigma \left(W_o{x}_c(t)+b_o\right)\end{array}$$
​ 假设我们希望在每个时间步t处最小化的损失$l(t)$取决于通过隐藏层h和当前时刻的标签y得到的损失函数$f$：
$$l(t)=f(h(t),y(t))$$
​ 其中$f$可以是任何可微分损失函数，例如欧几里德损失：
$$l(t)=f(h(t),y(t))=\Vert h(t)-y(t){\Vert }^2$$
​ 在这种情况下，我们的最终目标是使用梯度下降最小化整个时间长度$T$的损失L：
$$L=\sum _{t=1}^{T}l(t)$$
​ 让我们通过计算损失函数的梯度：
$$\frac{dL}{dw}$$
​ 其中$w$是模型的标量参数（例如，它可以是矩阵$W_{gx}$）。 由于损失函数$l(t)=f(h(t),y(t))$仅取决于隐藏层$h(t)$和标签$y(t)$的值，由于标签是常量,根据链式求导法则得到：
$$\frac{dL}{dw}=\sum _{t=1}^T\sum _{i=1}^M\frac{dL}{d{h}_i(t)}\frac{d{h}_i(t)}{dw}$$
​ 其中,$h_i(t)$对应于第$i$个存储器单元的隐藏输出的标量,$M$是每个存储器单元的总数,由于网络在时间上向前传播信息,因此$h_i(t)$对时间t之前的损失没有影响,因此,如下:
$$\frac{dL}{d{h}_i(t)}=\sum _{s=1}^T\frac{dl(s)}{d{h}_i(t)}=\sum _{s=t}^T\frac{dl(s)}{d{h}_i(t)}$$
​ 为方便起见，我们引入变量$L(t)$，表示从步骤t开始的累积损失：
$$L(t)=\sum _{s=t}^{s=T}l(s)$$
​ 这样$L(1)$就是整个序列的损失,这允许我们将上面的等式重写为：
$$\frac{dL}{d{h}_i(t)}=\sum _{s=t}^T\frac{dl(s)}{d{h}_i(t)}=\frac{dL(t)}{d{h}_i(t)}$$
​ 考虑到这一点，我们可以重新编写梯度计算公式：
$$\frac{dL}{dw}=\sum _{t=1}^T\sum _{i=1}^M\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{dw}$$
​ 确保你理解这最后的等式.$\frac{d{h}_i(t)}{dw}$ 的计算直接遵循前面给出的前向传播方程。 我们现在展示如何计算$\frac{dL(t)}{d{h}_i(t)}$，这是所谓的反向传播随着时间发挥作用的地方。

随时间的反向传播

​ 这个变量$L(t)$允许我们表达以下递归：
$$L(t)=\{\begin{array}{ll}l(t)+L(t+1)& \text{ if }t<T\\ l(t)& \text{ if }t=T\end{array}$$
​ 因此，给定LSTM节点在时间t的激活$h(t)$，我们就有了:
$$\frac{dL(t)}{dh(t)}=\frac{dl(t)}{dh(t)}+\frac{dL(t+1)}{dh(t)}$$
​ 现在,我们知道右边的第一项$\frac{dl(t)}{dh(t)}$来自何处:它是损失函数$l(t)$相对于时刻t的激活$h(t)$的导数.第二项$\frac{dL(t+1)}{dh(t)}$是LSTM迭代性质的表现,表明我们需要下一个节点的导数信息,以便计算出当前节点的导数信息,因此我们需要计算$t=1,...,T$的$\frac{dL(t)}{dh(t)}$值,首先开始计算:
$$\frac{dL(T)}{dh(T)}=\frac{dl(T)}{dh(T)}$$
​ 并通过网络向后工作。 因此，反向传播随着时间的推移。 有了这些基础，我们可以跳进代码。

代码

​ 我们现在提供在1≤t≤T时执行backprop传递通过单个节点的代码。

​ 代码输入：

• top_diff_h=$\frac{dL(t)}{dh(t)}=\frac{dl(t)}{dh(t)}+\frac{dL(t+1)}{dh(t)}$

• top_diff_h=$\frac{dL(t+1)}{ds(t)}$

  计算输出:

  • self.state.bottom_diff_s=$\frac{dL(t)}{ds(t)}$
  • self.state.bottom_diff_h=$\frac{dL(t)}{dh(t-1)}$

  其值需要及时向后传播,该代码还添加了衍生物：

  • self.param.wi_diff=$\frac{dL}{d{W}_i}$
  • …
  • self.param.bi_diff=$\frac{dL}{d{b}_i}$
  • …

  自反向计算以来，我们必须总结每个时间步的衍生物：
  $$\frac{dL}{dw}=\sum _{t=1}^T\sum _{i=1}^M\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{dw}$$
  另外，请注意我们使用：

  • $\text{dxc}=\frac{dL}{d{x}_c(t)}$

  其中,$x_c(t)=[x(t),h(t-1)]$

  代码如下:

  def top_diff_is(self, top_diff_h, top_diff_s):
          # notice that top_diff_s is carried along the constant error carousel
          ds = self.state.o * top_diff_h + top_diff_s
          do = self.state.s * top_diff_h
          di = self.state.g * ds
          dg = self.state.i * ds
          df = self.s_prev * ds
  
          # diffs w.r.t. vector inside sigma / tanh function
          di_input = sigmoid_derivative(self.state.i) * di 
          df_input = sigmoid_derivative(self.state.f) * df 
          do_input = sigmoid_derivative(self.state.o) * do 
          dg_input = tanh_derivative(self.state.g) * dg
  
          # diffs w.r.t. inputs
          self.param.wi_diff += np.outer(di_input, self.xc)
          self.param.wf_diff += np.outer(df_input, self.xc)
          self.param.wo_diff += np.outer(do_input, self.xc)
          self.param.wg_diff += np.outer(dg_input, self.xc)
          self.param.bi_diff += di_input
          self.param.bf_diff += df_input       
          self.param.bo_diff += do_input
          self.param.bg_diff += dg_input       
  
          # compute bottom diff
          dxc = np.zeros_like(self.xc)
          dxc += np.dot(self.param.wi.T, di_input)
          dxc += np.dot(self.param.wf.T, df_input)
          dxc += np.dot(self.param.wo.T, do_input)
          dxc += np.dot(self.param.wg.T, dg_input)
  
          # save bottom diffs
          self.state.bottom_diff_s = ds * self.state.f
          self.state.bottom_diff_h = dxc[self.param.x_dim:]
  

  细节

  前向传播公式表明,$s(t)$的值通过改变$h(t)$或者$h(t+1)$来影响损失函数$L(t)$,对$s(t)$的求导法则:
  $$\begin{array}{rl}\frac{dL(t)}{d{s}_i(t)}& =\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{d{s}_i(t)}+\frac{dL(t)}{d{h}_i(t+1)}\frac{d{h}_i(t+1)}{d{s}_i(t)}\\ & =\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{d{s}_i(t)}+\frac{dL(t+1)}{d{h}_i(t+1)}\frac{d{h}_i(t+1)}{d{s}_i(t)}\\ & =\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{d{s}_i(t)}+\frac{dL(t+1)}{d{s}_i(t)}\\ & =\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{d{s}_i(t)}+{\left[top\_diff\_s\right]}_i\end{array}$$
  由于前向传播方程为:
  $$h(t)=s(t)\ast o(t)$$
  可得:
  $$\frac{dL(t)}{d{h}_i(t)}\frac{d{h}_i(t)}{d{s}_i(t)}=o_i(t)\ast [top\_diff\_h]$$
  将上述结果放在一起:

  ds = self.state.o * top_diff_h + top_diff_s