当前位置：首页 > news >正文

通俗理解记忆网络（Memory Network）——从0到1彻底掌握End-to-End MemNN

news 2026/3/26 19:36:34

1. 为什么Memory Network如此重要？
2. Memory Networks vs 传统RNN/LSTM
3. 原始Memory Networks（2014，非端到端）
4. End-to-End Memory Networks（MemN2N）核心详解
- 4.1 单跳（Single Hop）完整架构
- 4.2 输入编码（Embedding + Position Encoding + Temporal Encoding）
- 4.3 Attention机制推导
- 4.4 多跳（Multi-Hop）推理过程
5. 数学公式完整推导
6. PyTorch完整可运行代码（单跳 + 3-Hop + PE + TE）
7. bAbI数据集实验复现与结果分析
8. 主流变体对比（DMN / Key-Value MemNN / Memformer）
9. 局限性、为什么被Transformer取代？RAG的继承
10. 总结 + 思考题

1. 为什么Memory Network如此重要？

2014-2015年，Facebook AI Research（FAIR）连续推出两篇革命性论文：

Memory Networks(Weston et al., ICLR 2015)
End-to-End Memory Networks(Sukhbaatar et al., NeurIPS 2015)

这是第一个真正可微分的外部记忆 + 多跳推理框架，奠定了现代Memory-Augmented Neural Networks和Retrieval-Augmented Generation (RAG)的理论基础。

它首次在bAbI数据集上实现了接近人类水平的多跳推理（3-hop以上），远超当时的LSTM。

2. Memory Network 与 RNN/LSTM 的本质区别

维度	LSTM/GRU	Memory Network (MemNN)
记忆方式	隐状态 h_t（固定维度）	外部显式Memory（N个向量）
推理方式	单步顺序	多跳（Multi-hop）注意力
长距离依赖	衰减严重	可通过多次跳跃直接访问
可解释性	差	高（可可视化attention）
外部知识注入	困难	天然支持

4. End-to-End Memory Networks 详解（最重要章节）

4.1 单跳架构图（经典原图）

核心流程（Single Hop）：

Story → 嵌入为 Memory M（N×d）
Question → 嵌入为 u（d维）
Attention：p_i = softmax(u^T m_i)
o = Σ p_i * c_i
最终预测：â = softmax(W (o + u))

4.2 输入模块（Input Module）进阶技巧

Bag-of-Words（最基础）
Position Encoding (PE)：强烈推荐！解决词序问题
P E i , j = ( 1 − i N ) ⋅ ( 1 − j d ) + i N ⋅ j d ( j 为维度 ) PE_{i,j} = (1 - \frac{i}{N}) \cdot (1 - \frac{j}{d}) + \frac{i}{N} \cdot \frac{j}{d} \quad (j \text{为维度})PEi,j=(1−Ni)⋅(1−dj)+Ni⋅dj(j为维度)
Temporal Encoding：给每个sentence加上时间向量 T_i（可学习）

4.3 多跳（Multi-Hop）机制（最强大之处）

多跳更新规则：
u k + 1 = u k + o k u^{k+1} = u^k + o^kuk+1=uk+ok
其中 o^k 是第k跳的输出向量

通常3-hop即可解决bAbI中绝大多数多跳任务。

5. 完整数学公式推导

设：

Story有N个sentence，每个sentence有T个词
Embedding维度 d = 50 或 100

嵌入矩阵：

A, B, C, W ∈ R^{V × d} （V为词表大小）

第k跳计算：
m i k = A k x i + T i A ( Input Memory ) m_i^k = A^k x_i + T_i^A \quad (\text{Input Memory})mik=Akxi+TiA(Input Memory)
c i k = C k x i + T i C ( Output Memory ) c_i^k = C^k x_i + T_i^C \quad (\text{Output Memory})cik=Ckxi+TiC(Output Memory)
p i k = softmax ( ( u k ) T m i k ) p_i^k = \text{softmax}( (u^k)^T m_i^k )pik=softmax((uk)Tmik)
o k = ∑ i = 1 N p i k c i k o^k = \sum_{i=1}^N p_i^k c_i^kok=i=1∑Npikcik
u k + 1 = u k + o k u^{k+1} = u^k + o^kuk+1=uk+ok

最终：
a ^ = softmax ( W ( u K + o K ) ) \hat{a} = \text{softmax}(W (u^K + o^K))a^=softmax(W(uK+oK))

6. PyTorch完整高质量实现（推荐收藏）

importtorchimporttorch.nnasnnimporttorch.nn.functionalasFclassEndToEndMemoryNetwork(nn.Module):def__init__(self,vocab_size,embed_dim=64,num_hops=3,max_sent=20):super().__init__()self.embed_dim=embed_dim self.num_hops=num_hops self.max_sent=max_sent# Embedding (A, B, C)self.A=nn.Embedding(vocab_size,embed_dim)self.B=nn.Embedding(vocab_size,embed_dim)self.C=nn.Embedding(vocab_size,embed_dim)# 可选：Position Encoding + Temporal Encodingself.position_encoding=self._generate_position_encoding(max_sent,embed_dim)self.temporal_A=nn.Parameter(torch.randn(max_sent,embed_dim))self.temporal_C=nn.Parameter(torch.randn(max_sent,embed_dim))self.W=nn.Linear(embed_dim,vocab_size)def_generate_position_encoding(self,max_sent,dim):# 经典Position Encoding from paperencoding=torch.zeros(max_sent,dim)foriinrange(max_sent):forjinrange(dim):ifj%2==0:encoding[i,j]=(1-i/max_sent)-(j/dim)*(i/max_sent)else:encoding[i,j]=(1-i/max_sent)+(j/dim)*(i/max_sent)returnnn.Parameter(encoding,requires_grad=False)defforward(self,story,question):# story: (batch, num_sent, num_word)batch_size,num_sent,num_word=story.shape# Input Memory mm=self.A(story)# (batch, sent, word, d)m=m.sum(dim=2)+self.position_encoding[:num_sent]+self.temporal_A[:num_sent]# Question embedding u0u=self.B(question).sum(dim=1)# (batch, d)forhopinrange(self.num_hops):# Attentionu_temp=u.unsqueeze(1)# (batch, 1, d)attn=torch.matmul(u_temp,m.transpose(1,2))# (batch, 1, sent)p=F.softmax(attn.squeeze(1),dim=-1)# (batch, sent)# Output Memory cc=self.C(story).sum(dim=2)+self.position_encoding[:num_sent]+self.temporal_C[:num_sent]o=torch.matmul(p.unsqueeze(1),c).squeeze(1)# (batch, d)u=u+o# Update query vector# Final predictionlogits=self.W(u)returnlogits