双向RNN与深层RNN

一句话概述

标准的单向RNN只能利用过去的信息预测当前——但在很多任务中，未来信息同样重要（如理解"bank"是"银行"还是"河岸"需要看后面的词）。双向RNN（Bidirectional RNN）通过同时运行正向和反向两个RNN，使每个时间步都能访问整个序列的上下文。深层RNN则将多个RNN层垂直堆叠，让网络学习层次化的时序特征——底层捕获短期模式，高层捕获长期语义。这两种扩展显著增强了RNN对序列数据的建模能力。

💡 核心要点：①双向RNN同时运行前向和后向两个RNN，拼接后同时利用过去和未来信息 ②双向RNN需要完整序列才能计算，不适合实时/流式场景 ③深层RNN将多层RNN垂直堆叠，下层输出作为上层输入 ④深层双向RNN是NLP任务中常用的基础架构（如ELMo中使用2层双向LSTM）

教学与演示

一、双向RNN：同时看过去和未来

是什么（定义）：双向RNN由两个独立的RNN组成：一个正向RNN按时间顺序处理序列（x_1→x_2→...→x_T），一个反向RNN按时间逆序处理序列（x_T→x_{T-1}→...→x_1）。每个时间步的输出是正反两个方向的隐藏状态的拼接（或求和）：h_t^bi = [h_t^forward; h_t^backward]。这使得每个时间步的输出都包含完整的上下文信息。

大白话 双向RNN就是"同时往前看和往后看"——读到一个词时，不仅参考前面读过的内容（前向RNN），还参考后面的内容（反向RNN）。就像做填空题：只看前半句 "I went to the ___" 不知道填什么，但看了后半句 "to deposit money" 就知道应该填 "bank"。

为什么（原理）：在自然语言中，一个词的含义往往需要同时看左边和右边的上下文才能确定。例如"Apple released a new iPhone"——"Apple"指公司，来自右侧"iPhone"的信息；"I ate an apple"——"apple"指水果，同样来自左右上下文。单向RNN在t时刻只能看到x_1...x_t的信息，双向RNN突破了这一限制。

怎么做（实现）：

import numpy as np

# ========================================
# 双向RNN —— 同时进行前向和反向处理
# 每个时间步的输出 = [正向h_t; 反向h_t]
# ========================================

class SimpleRNNCell:
    """简化RNN单元: h_t = tanh(W_xh·x_t + W_hh·h_{t-1} + b)"""
    def __init__(self, input_size, hidden_size):
        self.W_xh = np.random.randn(hidden_size, input_size) * 0.1
        self.W_hh = np.random.randn(hidden_size, hidden_size) * 0.1
        self.b = np.zeros(hidden_size)
    
    def forward_step(self, x_t, h_prev):
        return np.tanh(np.dot(self.W_xh, x_t) + np.dot(self.W_hh, h_prev) + self.b)


class BidirectionalRNN:
    """
    双向RNN
    正向RNN: 从 x_1 到 x_T
    反向RNN: 从 x_T 到 x_1
    输出: 拼接后的 [h_forward; h_backward]
    """
    def __init__(self, input_size, hidden_size):
        # 前向RNN
        self.forward_rnn = SimpleRNNCell(input_size, hidden_size)
        # 反向RNN（独立的参数）
        self.backward_rnn = SimpleRNNCell(input_size, hidden_size)
        self.hidden_size = hidden_size
    
    def forward(self, sequence):
        """
        参数:
            sequence: 输入序列，shape (seq_len, input_size)
        返回:
            outputs: 每个时间步的双向拼接输出，shape (seq_len, 2*hidden_size)
        """
        seq_len = len(sequence)
        
        # ---- 正向传播（从左到右）----
        h_forward_list = []
        h_f = np.zeros(self.hidden_size)  # 正向初始隐藏状态
        for t in range(seq_len):          # x_1 → x_2 → ... → x_T
            h_f = self.forward_rnn.forward_step(sequence[t], h_f)
            h_forward_list.append(h_f)
        
        # ---- 反向传播（从右到左）----
        h_backward_list = []
        h_b = np.zeros(self.hidden_size)  # 反向初始隐藏状态
        for t in range(seq_len - 1, -1, -1):  # x_T → x_{T-1} → ... → x_1
            h_b = self.backward_rnn.forward_step(sequence[t], h_b)
            h_backward_list.insert(0, h_b)  # 插到开头以保持时间顺序
        
        # ---- 拼接正反向输出 ----
        outputs = []
        for t in range(seq_len):
            bi_h = np.concatenate([h_forward_list[t], h_backward_list[t]])
            outputs.append(bi_h)
        
        return np.array(outputs)


# --- 演示 ---
np.random.seed(42)
print("双向RNN演示：")
print("=" * 60)

# 一句话: "The cat sat"
sentence = np.array([
    [1.0, 0.0, 0.0],  # "The"  (简化为3维向量)
    [0.0, 1.0, 0.0],  # "cat"
    [0.0, 0.0, 1.0],  # "sat"
])

bi_rnn = BidirectionalRNN(input_size=3, hidden_size=4)
outputs = bi_rnn.forward(sentence)

print(f"输入序列长度: {len(sentence)}, 隐藏维度: 4")
print(f"输出维度: {outputs.shape[1]} (前向4维 + 反向4维)")
print(f"\n各时间步的输出（前4维=前向, 后4维=反向）：")
for t, word in enumerate(["The", "cat", "sat"]):
    fwd = outputs[t, :4]
    bwd = outputs[t, 4:]
    print(f"  t={t} '{word}':")
    print(f"    前向: [{fwd[0]:.3f}, {fwd[1]:.3f}, ...] ← 只看 The/cat/sat 左边的词")
    print(f"    反向: [{bwd[0]:.3f}, {bwd[1]:.3f}, ...] ← 只看 The/cat/sat 右边的词")

# --- 对比单向RNN ---
print(f"\n单向RNN vs 双向RNN 对比：")
print(f"  单向RNN t=1 ('cat'): 只能看到 'The cat'")
print(f"  双向RNN t=1 ('cat'):  能看到 'The cat sat'（完整上下文！）")
print(f"  代价: 双向RNN需要整个序列才能计算，无法实时处理")

大白话 双向RNN = 两个人分别从左右两端读同一句话。正向的人从左读到右，在"cat"处知道前面是"The"；反向的人从右读到左，在"cat"处知道后面是"sat"。两个人的笔记拼起来，就有了"cat"在句中的完整上下文。

什么用（AI关联）：双向LSTM是许多NLP任务的标准架构：命名实体识别（NER）、词性标注、文本分类、关系抽取等。ELMo（2018年）使用2层双向LSTM在大规模语料上预训练，生成的上下文词向量显著提升了各种NLP任务的性能，是BERT出现前最成功的预训练方法之一。

哪些坑（缺点）：①需要完整序列才能计算——不适合实时/流式处理（如在线语音识别）。②双向RNN在推理时延迟是单向RNN的两倍。③在编码器-解码器架构中，双向RNN只能用于编码器，解码器仍需单向（因为生成时未来未知）。

二、深层RNN：层次化时序特征

是什么（定义）：深层RNN将多个RNN层垂直堆叠，第l层的输出序列作为第l+1层的输入序列。底层RNN捕获局部的、短期的时序模式；高层RNN在底层特征的基础上捕获更抽象的、长期的语义模式。这与CNN中浅层捕获边缘、深层捕获语义的层次化特征学习类似。

大白话 深层RNN就像"多层阅读理解"——第一层抓每个词的局部语法特征（名词还是动词），第二层在第一层的基础上抓短语结构（主语是谁），第三层再抓句子级别的语义（整句的情感）。每一层都在前一层的基础上建立更抽象的理解。

怎么做（实现）：

import numpy as np

# ========================================
# 深层RNN —— 多层RNN垂直堆叠
# 第l层的输出作为第l+1层的输入
# ========================================

class DeepRNN:
    """
    多层堆叠RNN
    结构: 输入 → RNN_layer1 → RNN_layer2 → ... → RNN_layerL → 输出
    
    参数独立: 每层有自己独立的权重矩阵
    """
    def __init__(self, input_size, hidden_sizes):
        """
        参数:
            input_size: 原始输入的维度
            hidden_sizes: 每层的隐藏维度列表，如 [64, 32] 表示2层
        """
        self.layers = []
        prev_size = input_size
        
        for h_size in hidden_sizes:
            # 每一层是一个独立的SimpleRNNCell
            layer = SimpleRNNCell(prev_size, h_size)
            self.layers.append(layer)
            prev_size = h_size  # 当前层的输出维度 = 下一层的输入维度
    
    def forward(self, sequence):
        """
        逐层前向传播
        参数:
            sequence: 输入序列，shape (seq_len, input_size)
        返回:
            outputs: 最后一层所有时间步的输出，shape (seq_len, last_hidden_size)
        """
        layer_input = sequence
        
        for layer_idx, layer in enumerate(self.layers):
            layer_output = []
            h = np.zeros(layer.W_hh.shape[0])  # 每层的初始隐藏状态
            
            # 在时间维度上展开
            for t in range(len(layer_input)):
                h = layer.forward_step(layer_input[t], h)
                layer_output.append(h)
            
            # 当前层的输出 = 下一层的输入
            layer_input = np.array(layer_output)
        
        return layer_input


# --- 演示 ---
np.random.seed(42)
print("深层RNN 演示：")
print("=" * 60)

deep_rnn = DeepRNN(input_size=3, hidden_sizes=[64, 32, 16])
print(f"网络结构: 3维输入 → [64] → [32] → [16] → 16维输出")

# 序列: The cat sat on the mat (6个词)
sentence = np.random.randn(6, 3)
output = deep_rnn.forward(sentence)

print(f"\n输入序列: 6个词 × 3维")
print(f"输出序列: {output.shape[0]}个时间步 × {output.shape[1]}维")
print(f"\n各层的作用:")
print(f"  第1层 (64维): 学习每个词的局部上下文特征")
print(f"  第2层 (32维): 在第1层基础上学习短语级别特征")
print(f"  第3层 (16维): 在第2层基础上学习句子级别语义")

# --- 参数统计 ---
print(f"\n参数数量统计:")
total_params = 0
for i, (layer, h_size) in enumerate(zip(deep_rnn.layers, [64, 32, 16])):
    in_size = 3 if i == 0 else [64, 32][i-1]
    params = h_size * in_size + h_size * h_size + h_size
    total_params += params
    print(f"  第{i+1}层: {in_size}→{h_size}, {params} 参数")
print(f"  总计: {total_params} 参数")

大白话 深层RNN = 堆叠的"阅读理解层"。第一层读词（"cat"是什么词性？），第二层读短语（"The cat"是主语），第三层读句子（整句话在说什么）……越高层越抽象，越接近"理解"而非"识别"。

什么用（AI关联）：2-4层堆叠RNN是NLP中的常见配置。ELMo使用2层双向LSTM，Sequence-to-Sequence模型通常使用2-4层编码器和解码器。一般来说，层数越多表达能力越强，但训练难度也越大（梯度消失/爆炸加剧）。残差连接和层归一化可以缓解深层RNN的训练问题。

哪些坑（缺点）：①训练时间随层数线性增长。②太多层（>4）容易过拟合，尤其在小数据集上。③深层RNN的梯度问题比浅层更严重——因为梯度既要通过时间步（BPTT）又要通过层（标准反向传播），双重衰减。

三、深层双向RNN：最强组合

是什么（定义）：深层双向RNN同时结合了双向（每层都包含前向和反向两个RNN）和深层（多层堆叠）两个特性。每层内部是双向的，层之间是堆叠的。ELMo使用2层深层双向LSTM，BERT之前的许多SOTA模型都使用这种架构。

大白话 深层双向RNN = "多角度多层次理解"。每一层都同时看左右上下文（双向），多层堆叠逐级抽象（深层）。就像一个专家团队：每个人都从正反两个角度看问题（双向），团队还分初级、中级、高级专家逐级提炼（深层）。

概念关系图谱

重点答疑

Q1: 双向RNN和Transformer的"双向"有什么区别？

双向RNN的"双向"是通过显式运行两个独立的RNN（前向和反向）实现的——计算上是两次独立的遍历。Transformer（如BERT）的"双向"是通过自注意力机制实现的——每个位置可以同时关注所有位置，不需要显式的前向/反向处理。Transformer的双向更加"并行"（所有位置同时计算），而双向RNN仍然是串行的（即使两个方向各自串行）。这也是Transformer训练速度远超双向RNN的原因之一。

Q2: 深层RNN通常用几层？太多层会发生什么？

实践中深层RNN通常使用2-4层。超过4层后收益递减，训练难度激增。太多层的问题：①梯度更容易消失/爆炸（双重衰减：层间+时间步）。②计算量线性增长。③在小数据集上严重过拟合。缓解方案包括残差连接、层归一化、Dropout。如果需要更强的序列建模能力，现代实践中通常转向Transformer而非更深的RNN。

Q3: 双向RNN在解码器（生成）中能用吗？

不能。解码器在生成时是自回归的——t时刻生成y_t后再将其反馈为输入来生成y_{t+1}。未来的输入（y_{t+1}, y_{t+2}, ...）还不存在，因此反向RNN无法运行。所以Seq2Seq模型中，编码器常用双向RNN（能看到整个源序列），解码器只能用单向RNN。这也是Transformer解码器使用因果掩码（causal masking）的原因。

章节单词汇总