Neural Turing Machines - 神经图灵机简单自学（论文阅读）

Neural Turing Machines - 神经图灵机

参考论文：Graves, A., Wayne, G., & Danihelka, I… (2014). Neural Turing Machines.

引言

一般的神经网络不具有记忆，LSTM可以利用之前的信息，但随着序列的加深，靠前的信息难以利用。

NTM

神经图灵机(NTM)通过利用在外部进行记忆的存储，读取与写入解决了这一问题。神经图灵机 (NTM) 架构包含两个基本组件：神经网络控制器和存储库。像大多数神经网络一样，控制器通过输入和输出向量与外部世界交互。与标准网络不同，它还使用选择性读写操作与内存矩阵进行交互。通过类比图灵机，将参数化这些操作的网络输出称为“头”。
下图是NTM的结构，在每个更新周期中，控制器网络从外部环境接收输入并发出输出作为响应。它还通过一组并行读写“头”读取和写入内存矩阵。虚线表示 NTM 与外界的划分。神经图灵机使所有的读写操作都可微分化，因此可以用神经网络误差后向传播的方式去训练模型。

读取记忆(Reading)

我们把记忆看作是一个$N\times M$的矩阵$M_t$，$t$表示当前时刻， 表示记忆会随着时间发生变化。我们的读过程就是生成一个定位权值向量$w_t$，长度为$N$，表示$N$个位置对应的记忆权值大小，将权重归一化：
$$\sum _i{w}_t(i)=1,0\le w_t(i)\le 1,\forall i.$$
最后读出的记忆向量r_t为:
$$r_t\leftarrow \sum _i{w}_t(i)M_t(i)$$
可以看到，读取操作实际上就是对$N$条记忆加权求和，相当于attention。

写入记忆(Writing)

NTM的写入部分从LSTM 中的输入和遗忘门中汲取灵感，将每个写入分解为两部分：擦除与添加。NTM通过擦除向量$e_t$ (erase vector) 和一个增加向量$a_t$ (add vector)，长度都为$N$，向量中每个元素的值大小范围从0到1，表示要增加或者删除的信息。对于写记忆过程，神经图灵机首先执行一个擦除操作，擦除程度的大小同样由向量$w_t$决定:
$${\hat{M}}_t=M_{t-1}(i)(1-w_t(i)e_t)$$
而添加过程如下：
$$M_t(i)={\hat{M}}_t(i)+w_t(i)a_t$$
其中擦除和添加向量都有$M$个独立成分，从而可以精细控制每个内存位置中的哪些元素被修改。

定位机制(Addressing Mechanisms)

NTM结合了基于内容的(content-based)和基于位置的(location-based)方法，提出一个定位机制用于生成定位向量$w_t$,下图是定位机制的流程图。

按内容聚焦(Focusing by Content)

NTM的相似性度量是余弦相似度：
$$K[u,v]=\frac{u\cdot v}{||u||\cdot ||u||}$$
首先控制器给出一个长度为M的$kt$向量作为查询的key，然后计算$k_t$与$M_t$中各个记忆向量的相似度$K[.,.]$，最后经过Softmax操作得到基于内容的定位向量$w_t^c$：
$$w_t^c(i)=\frac{exp({\beta }_{t}K[k_t,M_t(i)])}{{\sum }_{j}exp({\beta }_{t}K[k_t,M_t(j)}$$

按位置聚焦(Focusing by Location)

基于位置的寻址机制旨在促进内存位置的简单迭代和随机访问跳转，它通过实现权重的旋转移位来实现。如，如果当前权重完全集中在单个位置，旋转 1 会将焦点转移到下一个位置。

• 插值(interpolation)：
  在旋转之前，每个head都会在 (0, 1) 范围内生成一个标量插值门$g_t$，该值用于混合head在上一个时间步产生的权重$w_{t-1}$和当前步产生的权重$w_t^c$，产生门控权重$w_t^g$:
  $$w_t^g\leftarrow g_t{w}_t^c+(1-g_t)w_{t-1}$$
  如果门为零，则完全忽略内容权重，并使用前一时间步的权重。相反，如果门是一，则忽略前一次迭代的权重，系统应用基于内容的定位。
• 移位(shift)：
  在插值后实行移位操作，对于$w_t^g$中的每个位置元素$w_t^g(i)$，我们考虑它相邻的k个偏移元素，认为这k个元素与$w_t^g(i)$相关。例如，如果允许在-1和1之间移动，$s_t$包含对应于执行 -1、0 和 1 的移动的的3个权值。定义移位权重的最简单方法是使用附加到控制器的适当大小的 softmax 层进行多分类。
  除此之外，本文尝试了另外一种方法，在控制器中产生一个缩放因子，该因子为移位位置上均匀分布的下界。比如，如果该缩放因子值为6.7，那么$s_t(6)=0.3,s_t(7)=0.7，s_t$的其余分量为0（只取整数索引）。
  如果索引从0到N-1的N个内存位置，旋转可定义为循环卷积操作：
  $${\tilde{w}}_t(i)\leftarrow \sum _{j=0}^{N-1}{w}_t^g(j)s_t(i-j)$$
  由于卷积操作会使权值的分布趋于均匀化，这将导致本来集中于单个位置的焦点出现发散现象。为了解决这个问题，还需要对结果进行锐化操作。具体做法是Head产生一个因子${\gamma }_t\ge 1$，并通过如下操作来进行锐化：
  $$w_t(i)=\frac{{\tilde{w}}_t(i{)}^{{\gamma }_t}}{{\sum }_j{\tilde{w}}_t(j{)}^{{\gamma }_t}}$$
  矩阵形式：
  $${\text{S}}_t=\left[\begin{array}{ccccc}{s}_t(0)& s_t(N-1)& \cdots & s_t(2)& s_t(1)\\ s_t(1)& s_t(0)& s_t(N-1)& \cdots & s_t(2)\\ ⋮& s_t(1)& s_t(0)& \ddots & ⋮\\ s_t(3)& \ddots & \ddots & \ddots & s_t(N-1)\\ s_t(N-1)& s_t(N-2)& \cdots & s_t(1)& s_t(0)\end{array}\right]$$
  $${\tilde{\text{w}}}_t={\text{S}}_t{\text{w}}_t^g$$

锐化操作示例（参考Neural Turing Machines-NTM系列（一）简述）：

假设N=5，当前焦点为1，三个位置-1,0,1对应的权值为0.1,0.8,0.1，
${\text{w}}_t^g=\left[\begin{array}{c}0.06\\ 0.1\\ 0.65\\ 0.15\\ 0.04\end{array}\right]$，因此：
$${\text{S}}_t=\left[\begin{array}{ccccc}{s}_t(0)& s_t(4)& s_t(3)& s_t(2)& s_t(1)\\ s_t(1)& s_t(0)& s_t(4)& s_t(3)& s_t(2)\\ s_t(2)& s_t(1)& s_t(0)& s_t(4)& s_t(3)\\ s_t(3)& s_t(2)& s_t(1)& s_t(0)& s_t(4)\\ s_t(4)& s_t(3)& s_t(2)& s_t(1)& s_t(0)\end{array}\right]=\left[\begin{array}{ccccc}0.1& 0& 0& 0.1& 0.8\\ 0.8& 0.1& 0& 0& 0.1\\ 0.1& 0.8& 0.1& 0& 0\\ 0& 0.1& 0.8& 0.1& 0\\ 0& 0& 0.1& 0.8& 0.1\end{array}\right]$$
因此：
$${\tilde{\text{w}}}_t={\text{S}}_t{\text{w}}_t^g=\left[\begin{array}{ccccc}0.1& 0& 0& 0.1& 0.8\\ 0.8& 0.1& 0& 0& 0.1\\ 0.1& 0.8& 0.1& 0& 0\\ 0& 0.1& 0.8& 0.1& 0\\ 0& 0& 0.1& 0.8& 0.1\end{array}\right]\times \left[\begin{array}{c}0.06\\ 0.1\\ 0.65\\ 0.15\\ 0.04\end{array}\right]=\left[\begin{array}{c}0.053\\ 0.062\\ 0.151\\ 0.545\\ 0.189\end{array}\right]$$
取${\gamma }_t=2$，
$${\text{w}}_t=\frac{{\tilde{\text{w}}}_t^{{\gamma }_t}}{{\sum }_j{\tilde{w}}_t(j{)}^{{\gamma }_t}}=\left[\begin{array}{c}0.0078\\ 0.0106\\ 0.0630\\ 0.8201\\ 0.0986\end{array}\right]$$

最后得到最终的$w_t$用于读取和写入数据。
NTM的实现：

源码

https://github.com/loudinthecloud/pytorch-ntm

# 读过程
class NTMReadHead(NTMHeadBase):
    def __init__(self, memory, controller_size):
        super(NTMReadHead, self).__init__(memory, controller_size)

        # Corresponding to k, β, g, s, γ sizes from the paper
        self.read_lengths = [self.M, 1, 1, 3, 1]
        self.fc_read = nn.Linear(controller_size, sum(self.read_lengths))
        self.reset_parameters()

    def create_new_state(self, batch_size):
        # The state holds the previous time step address weightings
        return torch.zeros(batch_size, self.N)

    def reset_parameters(self):
        # Initialize the linear layers
        nn.init.xavier_uniform_(self.fc_read.weight, gain=1.4)
        nn.init.normal_(self.fc_read.bias, std=0.01)

    def is_read_head(self):
        return True

    def forward(self, embeddings, w_prev):
        """NTMReadHead前进函数。
        ：param embeddings：控制器的输入表示形式。
        ：param w_prev:上一步状态
        """
        o = self.fc_read(embeddings)
        k, β, g, s, γ = _split_cols(o, self.read_lengths)

        # Read from memory
        w = self._address_memory(k, β, g, s, γ, w_prev)
        r = self.memory.read(w)

        return r, w

# 写过程
class NTMWriteHead(NTMHeadBase):
    def __init__(self, memory, controller_size):
        super(NTMWriteHead, self).__init__(memory, controller_size)

        # Corresponding to k, β, g, s, γ, e, a sizes from the paper
        self.write_lengths = [self.M, 1, 1, 3, 1, self.M, self.M]
        self.fc_write = nn.Linear(controller_size, sum(self.write_lengths))
        self.reset_parameters()

    def create_new_state(self, batch_size):
        return torch.zeros(batch_size, self.N)

    def reset_parameters(self):
        # Initialize the linear layers
        nn.init.xavier_uniform_(self.fc_write.weight, gain=1.4)
        nn.init.normal_(self.fc_write.bias, std=0.01)

    def is_read_head(self):
        return False

    def forward(self, embeddings, w_prev):
        """NTMWriteHead前进函数。
        
        ：param embeddings：控制器的输入表示形式。
        ：param w_prev:上一步状态
        """
        o = self.fc_write(embeddings)
        k, β, g, s, γ, e, a = _split_cols(o, self.write_lengths)

        # e should be in [0, 1]
        e = F.sigmoid(e)

        # Write to memory
        w = self._address_memory(k, β, g, s, γ, w_prev)
        self.memory.write(w, e, a)

        return w