Neural Turing Machine - 神经图灵机
论文原文地址: http://arxiv.org/pdf/1410.5401.pdf
一般的神经网络不具有记忆功能,输出的结果只基于当前的输入;而LSTM网络的出现则让网络有了记忆:能够根据之前的输入给出当前的输出。但是,LSTM的记忆程度并不是那么理想,对于比较长的输入序列,LSTM的最终输出只与最后的几步输入有关,也就是long dependency问题,当然这个问题可以由注意力机制解决,然而却不能从根本上解决长期记忆的问题,原因是由于LSTM是假设在时间序列上的输入输出:由t-1时刻得到t时刻的输出,然后再循环输入t时刻的结果得到t+1时刻的输出,这样势必会使处于前面序列的输入被淹没,导致这部分记忆被“丢掉“。
神经图灵机通过引入外部记忆解决了这个问题。 举个简单的例子,我们人类在记忆一些事情的时候,除了用脑袋记,还会写在备忘录上,当我们想不起来的时候,就可以去翻阅备忘录,从而获得相关的记忆。神经图灵机模仿人类记忆的过程:其中的控制器(controller)相当于我们人类的大脑,用于把输入事物的特征提取出来;外部记忆(memory)相当于我们的备忘录,把事物的特征记录在上面,那么完整的过程就是:控制器将当前输入转化为特征,写入记忆,再读取与当前输入特征有关的记忆作为最后的输出。整个过程与图灵机的读写很像,只不过神经图灵机这里让所有的读写操作都可微分化,因此可以用神经网络误差后向传播的方式去训练模型。
那么问题就来了,当获得一个输入的特征后,我们如何确定在记忆中储存的位置,而且如何从记忆中获取与当前输入相关的信息呢?这就是接下来要分析的神经图灵机主要工作。
Neural Turning Machine
1. 读记忆 (Read Heads)
我们把记忆看作是一个$N × M$的矩阵$M_t$,t表示当前时刻, 表示记忆会随着时间发生变化。我们的读过程就是生成一个定位权值向量$w_t$,长度为$N$,表示N个位置对应的记忆权值大小,最后读出的记忆向量$r_t$为:
$$r_t= \displaystyle\sum^N_i{w_t(i)M_t(i)}$$
其中权值向量的和为1: $\sum_i{W_t(i)}=1$,本质上是一个对N条记忆进行一个加权求和的思想。
2. 写记忆(Write Heads)
神经图灵机的写过程参考了LSTM的门的概念:先用输入门决定增加的信息,再用遗忘门决定要丢弃的信息,最后用更新门加上增加的信息并减去丢弃的信息。具体来说,神经图灵机会生成一个擦除向量$e_t$ (erase vector) 和一个增加向量$a_t$ (add vector),长度都为$N$,向量中每个元素的值大小范围从0到1,表示要增加或者删除的信息。对于写记忆过程,神经图灵机首先执行一个擦除操作,擦除程度的大小同样由向量$w_t$决定:
$$M_t^′=M_{t-1}(i)(1-w_t(i)e_t(i))$$
这个操作表示从$t?1$时刻的记忆中丢弃了一些信息,若$w_t$和$e_t$同时为0,则表示记忆没有丢弃信息,当前记忆与$t?1$时刻保持不变。执行完擦除后,然后执行增加操作:
$$M_t(i)=M_t^,(i)+w_t(i)a_t(i)a$$
这步表示在丢弃一些信息后需要新增的信息,同样,若$w_t$和$a_t$都为0,表示当前记忆无新增,与擦除后的记忆保持一致。其中,$e_t$和$a_t$都是由控制器给出,而控制器基本上由神经网络实现,可以是LSTM,也可以是MLP。
由于整个过程都是都是矩阵的加减乘除,所有的读写操作都是可微分的,因此我们可以用梯度下降法训练整个参数模型。但是接下来,我们需要确定$w_t$定位向量,由于这个向量直接决定着当前输入与记忆的相关性,因此神经图灵机在生成$w_t$向量上做了很多工作。
3. 定位机制(Addressing Mechanism)
关于决定其相关性的方法有很多,主要分为两大类: 基于内容的(content-based)和基于位置的(location-based)。神经图灵机结合了这两个方法提出一个定位机制用于生成定位向量$w_t$,具体来说,先用基于内容的方法,再用基于位置的方法。
3.1 Content-based Addressing
基于内容的定位计算主要基于余弦相似度:首先控制器给出一个$k_t$向量作为查询的key,然后计算$k_t$与$M_t$中各个记忆向量的余弦相似度,最后经过一个softmax操作得到基于内容的定位向量$w_t^c$:
$$w_t^c(i)=\frac{exp(\beta_tK[k_t,M_t(i)])}{\sum_jexp(\beta_tK[k_t,M_t(j)}$$
其中$K[..,.]$是余弦相似度计算:
$$K[u,v]=\frac{u?v}{||u||?||u||}$$
3.2 Location-based Addressing
3.2.1. Interpolation(插值)
控制器生成一个阈值$g_t$对当前的内容定位向量$w_t^c$与$t-1$时刻的定位向量$w_{t-1}$进行一个插值操作,插值的结果即为输出值$w_t^g$:
$$w_t^g=g_tw_t^c+(1-g_t)w_{t-1}$$
这里的插值操作可以理解为LSTM的更新门,结合过去的$w$权值计算新的$w$
3.2.2. shift(偏移)
对于$w_t^g$中的每个位置元素$w_t^g(i)$ ,我们考虑它相邻的k个偏移元素,认为这k个元素与$w_t^g(i)$相关,如当k=3时,三个相邻元素分别是:$w_t^g(i)$本身和位置偏移为1的元素$w_t^g(i-1)$和$w_t^g(i+1)$,此时,我们希望新的位置为i的元素能包含这三个元素,因此用一个长度为3的偏移权值向量$s_t$来表示这三个元素的权重,然后权值求和得到输出值$w_t^′$:
$$w_t^′(i)=\displaystyle\sum_{j=-1}^{1}{w_t^g(i+j)s(j+1)}$$
这里的偏移操作在原文中用的是循环卷积(circular convolution)公式表示的,我们可以理解为把向量$w_t^g$首尾相连形成一个环状,然后在环中用$s_t$作为卷积核做一维卷积操作。本质上是假设当前元素与相邻的偏移元素相关。
3.2.3. Sharping(重塑)
当偏移操作中的权值比较平均的时候,上述的卷积操作会导致数据的分散(dispersion)和泄漏(leakage),就像把一个点的信息分散在三个点中,权值如果太平均会使三个点包含的值太模糊(个人理解),因此需要把权值大小的区别进行强化,也就是sharping。具体来说,控制器生成一个参数$\gamma_t>1$,然后对各个权值进行$\gamma_t$指数然后归一化:
$$w_t(i)=\frac{w_t^′(i)^{\gamma_t}}{\sum_jw^′_t(j)^{\gamma_t}}$$
最后我们得出了最终的$w_t$用于提取和储存记忆。
Pytorch实现
我将原代码中最重要的NTM模块单独取出,并增加了如何简单使用的代码,读者可以直接下载加入到自己的模型中使用,代码已经上传到我的Github,点击这里查看————》NTM代码
这里代码基于的是pytorch-ntm,代码写的相当工整,可读性很高,这里只分析一些重要的步骤:
读过程
读过程就是从控制器(LTSM)输出的值提取我们需要的k, beta, g, s, gama值,然后调用_address_memory获得当前的定位权值向量w, 再用矩阵乘法获得读过程的输出 :
def forward(self, embeddings, w_prev):
"""NTMReadHead forward function.
:param embeddings: input representation of the controller.
:param w_prev: previous step state
"""
o = self.fc_read(embeddings)
k, beta, g, s, gama = _split_cols(o, self.read_lengths)
# Read from memory
w = self._address_memory(k, beta, g, s, gama, w_prev)
r = self.memory.read(w)
return r, w
def read(self, w):
"""Read from memory (according to section 3.1)."""
return torch.matmul(w.unsqueeze(1), self.memory).squeeze(1)
写过程
写过程同样是获得定位机制需要的k,beta, g, s, gama以及需要擦除的向量e和增加的向量a,然后调用_address_memory获得定位向量w,然后根据e和a计算得出最后的写入向量 :
def forward(self, embeddings, w_prev):
"""NTMWriteHead forward function.
:param embeddings: input representation of the controller.
:param w_prev: previous step state
"""
o = self.fc_write(embeddings)
k, beta, g, s, gama, 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, beta, g, s, gama, w_prev)
self.memory.write(w, e, a)
return w
def write(self, w, e, a):
"""write to memory (according to section 3.2)."""
self.prev_mem = self.memory
self.memory = Variable(torch.Tensor(self.batch_size, self.N, self.M))
erase = torch.matmul(w.unsqueeze(-1), e.unsqueeze(1))
add = torch.matmul(w.unsqueeze(-1), a.unsqueeze(1))
self.memory = self.prev_mem * (1 - erase) + add
Addressing Mechanism
定位机制的计算非常直观,首先_similarity方法计算余弦相似读获得wc,然后调用_interpolate与过去的w_prev进行插值操作,接着_shift偏移操作,这里实际上调用的是_convolve循环卷积方法,最后进行_sharpen操作获得最终的w :
def address(self, k, beta, g, s, gama, w_prev):
# Content focus
wc = self._similarity(k, beta)
# Location focus
wg = self._interpolate(w_prev, wc, g)
w1 = self._shift(wg, s)
w = self._sharpen(w1, gama)
return w
def _similarity(self, k, beta):
k = k.view(self.batch_size, 1, -1)
w = F.softmax(beta * F.cosine_similarity(self.memory + 1e-16, k + 1e-16, dim=-1), dim=1)
return w
def _interpolate(self, w_prev, wc, g):
return g * wc + (1 - g) * w_prev
def _shift(self, wg, s):
result = Variable(torch.zeros(wg.size()))
for b in range(self.batch_size):
result[b] = _convolve(wg[b], s[b])
return result
def _sharpen(self, w1, gamma):
w = w1 ** gamma
w = torch.div(w, torch.sum(w, dim=1).view(-1, 1) + 1e-16)
return w
def _convolve(w, s):
"""Circular convolution implementation."""
assert s.size(0) == 3
t = torch.cat([w[-1:], w, w[:1]])
c = F.conv1d(t.view(1, 1, -1), s.view(1, 1, -1)).view(-1)
return c
训练过程
首先输入一系列的数据,每次输入一个样本,都先后进行读和写过程,然后在不给定输入的情况下,获得一系列输出值,每次获得一个输出值时,同样先后进行着读和写过程;只不过输出的时候控制器接受的是0向量,而输入数据的时候控制器接受的是样本x值。我们可以根据输出的值与样本label的差距计算loss,对于copy任务来说,输入样本和label都是样本本身,损失可以使用binary entropy loss,最后梯度下降法更新整合模型参数:
def train_batch(net, criterion, optimizer, X, Y):
"""Trains a single batch."""
optimizer.zero_grad()
inp_seq_len = X.size(0)
outp_seq_len, batch_size, _ = Y.size()
# New sequence
net.init_sequence(batch_size)
# Feed the sequence + delimiter
for i in range(inp_seq_len):
net(X[i])
# Read the output (no input given)
y_out = Variable(torch.zeros(Y.size()))
for i in range(outp_seq_len):
y_out[i], _ = net()
loss = criterion(y_out, Y)
loss.backward()
clip_grads(net)
optimizer.step()
y_out_binarized = y_out.clone().data
y_out_binarized.apply_(lambda x: 0 if x < 0.5 else 1)
# The cost is the number of error bits per sequence
cost = torch.sum(torch.abs(y_out_binarized - Y.data))
return loss.data[0], cost / batch_size
# 每次调用net(x)或者net()获得输出值的forward方法
def forward(self, x, prev_state):
"""NTM forward function.
:param x: input vector (batch_size x num_inputs)
:param prev_state: The previous state of the NTM
"""
# Unpack the previous state
prev_reads, prev_controller_state, prev_heads_states = prev_state
# Use the controller to get an embeddings
inp = torch.cat([x] + prev_reads, dim=1)
controller_outp, controller_state = self.controller(inp, prev_controller_state)
# Read/Write from the list of heads
reads = []
heads_states = []
for head, prev_head_state in zip(self.heads, prev_heads_states):
if head.is_read_head():
r, head_state = head(controller_outp, prev_head_state)
reads += [r]
else:
head_state = head(controller_outp, prev_head_state)
heads_states += [head_state]
# Generate Output
inp2 = torch.cat([controller_outp] + reads, dim=1)
o = F.sigmoid(self.fc(inp2))
# Pack the current state
state = (reads, controller_state, heads_states)
return o, state
关于训练结果,可以去github里看,目前只有copy和deepcopy两个任务,应该是分开训练,但是按照前面分析的,神经图灵机应该是可以先后训练多个任务,并且保持新的任务不会覆盖旧的任务,从理论上分析,如果让记忆矩阵非常大,那么就可以把每个任务储存到记忆中不同的块中,保持记忆矩阵的稀疏性,是可以做到任务间不互相干涉,因此让模型达到能学习多个任务的能力。谷歌16年在Nature中提出的DNC其实也就是神经图灵机,论文里介绍了一些现在神经图灵机可以完成的通用任务,想了解神经图灵机具体应用的可以去看看。下面放出论文地址和代码地址:
神经图灵机(NTM):https://arxiv.org/abs/1410.5401
————————————————
版权声明:本文为CSDN博主「ppp8300885」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/ppp8300885/article/details/80383246
原文地址:https://www.cnblogs.com/jinchengll/p/11766377.html