序列建模与RNN基本结构

一句话概述

序列数据（文本、语音、时间序列等）中，每个元素不仅依赖自身特征，还依赖前后元素的上下文关系。循环神经网络（RNN）通过引入隐藏状态（Hidden State）在不同时间步之间传递信息，使网络具有"记忆"能力。尽管标准RNN因梯度消失问题在实际应用中已被LSTM和GRU取代，但RNN的基本结构——隐藏状态循环更新——是整个序列建模领域的理论基石。

💡 核心要点：①序列数据的特点是元素之间存在时序依赖关系，普通前馈网络无法建模 ②RNN通过隐藏状态h_t在时间步间传递，实现"记忆" ③RNN在所有时间步共享权重参数（W_hh, W_xh, W_hy），参数数量与序列长度无关 ④标准RNN通过BPTT（时间反向传播）训练，但面临梯度消失/爆炸问题

教学与演示

一、序列数据与前馈网络的局限

是什么（定义）：序列数据是指元素之间存在顺序依赖关系的数据，如文本（词序列）、语音（采样点序列）、视频（帧序列）、股票价格（时间序列）等。序列数据的核心特征是：第t个元素的含义依赖于前面（或后面）的元素。

大白话 序列数据就是"前后有关联"的数据——"我吃饭"和"饭吃我"用同样的字但意思完全不同，因为顺序决定了含义。普通的神经网络把所有输入一次性塞进去，看不到顺序，就像把句子里的词打乱了还给AI看，它当然看不懂。

为什么（原理）：前馈网络（MLP、CNN）处理序列数据时有两个根本性缺陷：①假设输入是固定长度的——但序列长度可变（句子可长可短）。②假设输入之间独立——但序列元素之间存在依赖关系。RNN通过引入随时间步传递的隐藏状态来解决这两个问题。

二、RNN的基本结构

是什么（定义）：RNN在每个时间步t接收输入x_t和上一时间步的隐藏状态h_{t-1}，计算当前隐藏状态h_t = f(W_xh·x_t + W_hh·h_{t-1} + b_h)，再基于h_t生成输出y_t。关键设计是：所有时间步共享同一组权重参数（W_xh, W_hh, W_hy），使得RNN可以处理任意长度的序列。

大白话 RNN就像一个"边读边记笔记"的人——每读一个新词，就结合"之前记的笔记"（隐藏状态h_{t-1}）和"当前看到的内容"（x_t），更新笔记（h_t），然后基于最新笔记给出判断（y_t）。笔记在一句话中不断更新，读完最后一个词时，笔记里就包含了整句话的信息。

怎么做（实现）：

import numpy as np

# ========================================
# 标准 RNN —— 序列建模的基本单元
# 隐藏状态在时间步之间传递信息
# ========================================

class SimpleRNN:
    """
    简单RNN单元
    数学形式: h_t = tanh(W_xh·x_t + W_hh·h_{t-1} + b_h)
             y_t = W_hy·h_t + b_y
    """
    def __init__(self, input_size, hidden_size, output_size):
        """
        初始化RNN参数
        参数:
            input_size:  输入 x_t 的维度
            hidden_size: 隐藏状态 h_t 的维度
            output_size: 输出 y_t 的维度
        """
        # 输入到隐藏的权重: W_xh ∈ R^(hidden_size × input_size)
        self.W_xh = np.random.randn(hidden_size, input_size) * 0.01
        # 隐藏到隐藏的权重: W_hh ∈ R^(hidden_size × hidden_size)
        self.W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
        # 隐藏层偏置: b_h ∈ R^hidden_size
        self.b_h = np.zeros(hidden_size)
        
        # 隐藏到输出的权重: W_hy ∈ R^(output_size × hidden_size)
        self.W_hy = np.random.randn(output_size, hidden_size) * 0.01
        # 输出层偏置: b_y ∈ R^output_size
        self.b_y = np.zeros(output_size)
    
    def forward(self, x_sequence, h0=None):
        """
        前向传播：处理整个序列
        参数:
            x_sequence: 输入序列，shape (seq_len, input_size)
            h0: 初始隐藏状态，shape (hidden_size,)，默认全零
        返回:
            outputs: 每个时间步的输出，shape (seq_len, output_size)
            h_final: 最后一个时间步的隐藏状态
        """
        seq_len = len(x_sequence)
        hidden_size = self.b_h.shape[0]
        
        # 初始化隐藏状态
        if h0 is None:
            h = np.zeros(hidden_size)  # 初始隐藏状态为全零
        
        # 存储所有时间步的输出和隐藏状态
        outputs = []
        hidden_states = [h]
        
        for t in range(seq_len):
            x_t = x_sequence[t]  # 当前时间步的输入
            
            # ---- RNN核心公式 ----
            # h_t = tanh(W_xh·x_t + W_hh·h_{t-1} + b_h)
            h = np.tanh(
                np.dot(self.W_xh, x_t) +      # 输入贡献
                np.dot(self.W_hh, h) +         # 历史贡献（循环连接）
                self.b_h                        # 偏置
            )
            
            # y_t = W_hy·h_t + b_y（如分类任务，后续加softmax）
            y_t = np.dot(self.W_hy, h) + self.b_y
            
            outputs.append(y_t)
            hidden_states.append(h)
        
        return np.array(outputs), h


# --- 演示1: 字符级RNN预测下一个字符 ---
np.random.seed(42)
# 简化：用3维向量表示字符（实际中会用one-hot或embedding）
# 假设序列: "A"→"B"→"A"→"B"
chars = {'A': np.array([1.0, 0.0, 0.0]),
         'B': np.array([0.0, 1.0, 0.0])}

# 创建RNN
rnn = SimpleRNN(input_size=3, hidden_size=8, output_size=3)

# 输入序列: A, B, A, B
seq = np.array([chars['A'], chars['B'], chars['A'], chars['B']])
outputs, h_final = rnn.forward(seq)

print("字符级RNN前向传播：")
print("=" * 50)
for t, (ch, out) in enumerate(zip(['A', 'B', 'A', 'B'], outputs)):
    # 用softmax得到概率分布
    out_exp = np.exp(out - np.max(out))
    probs = out_exp / np.sum(out_exp)
    print(f"  t={t}: 输入='{ch}' → 输出概率: A={probs[0]:.3f}, B={probs[1]:.3f}, 其他={probs[2]:.3f}")

print(f"\n  最终隐藏状态 h_4: [{h_final[0]:.3f}, {h_final[1]:.3f}, ...]")
print(f"  → 隐藏状态包含了整句话的信息")


# --- 演示2: 权重共享验证 ---
print(f"\n权重共享验证：")
print(f"  W_xh 参数数: {rnn.W_xh.size} (8×3=24)")
print(f"  W_hh 参数数: {rnn.W_hh.size} (8×8=64)")
print(f"  W_hy 参数数: {rnn.W_hy.size} (3×8=24)")
print(f"  总参数: {rnn.W_xh.size + rnn.W_hh.size + rnn.W_hy.size + rnn.b_h.size + rnn.b_y.size}")
print(f"  → 无论序列多长，参数数量固定！")
print(f"  → 如果序列长度=100，前馈网络需要 100× 的参数")

大白话 RNN的公式可以拆成两半：前半部分是"更新记忆"——结合当前输入x_t和之前的记忆h_{t-1}，经过tanh压缩到(-1,1)之间，形成新的记忆h_t。后半部分是"输出答案"——基于当前记忆h_t，生成当前时刻的输出y_t。

什么用（AI关联）：RNN是序列建模的基础架构，广泛应用于文本分类、情感分析、机器翻译、语音识别、时间序列预测等。虽然标准RNN已被LSTM/GRU取代，但理解RNN是理解LSTM/GRU和注意力机制的前提。

哪些坑（缺点）：①梯度消失——长序列中早期时间步的梯度近乎为零，无法学习长期依赖。②梯度爆炸——循环权重矩阵特征值>1时梯度指数增长。③串行计算——每个时间步依赖前一步，无法并行化，训练速度慢。

三、BPTT：时间反向传播

是什么（定义）：BPTT（Backpropagation Through Time）是训练RNN的反向传播算法。它将RNN在时间维度上展开为"深层网络"（每个时间步相当于一层），然后应用标准的反向传播。由于参数在所有时间步共享，最终梯度是所有时间步梯度的累加。

大白话 BPTT就是把RNN在时间上"摊开"——一个处理4个词的RNN，摊开后就像一个4层的"假前馈网络"（每层其实是同一套参数）。然后在这个摊开的网络上做反向传播，每个参数的梯度是它在所有时间步上梯度的总和。

怎么做（实现）：

import numpy as np

# ========================================
# BPTT 模拟 —— 梯度在时间维度上的传播
# 演示梯度消失如何在长序列中发生
# ========================================

def simulate_bptt(seq_len, hidden_size=10):
    """
    模拟BPTT中梯度在时间上的传播
    关键因素: W_hh 的特征值决定梯度是消失还是爆炸
    """
    np.random.seed(42)
    # 模拟一个循环权重矩阵 W_hh
    W_hh = np.random.randn(hidden_size, hidden_size) * 0.5
    
    # 计算 W_hh 的最大特征值（粗略估计用谱范数）
    spectral_radius = np.max(np.abs(np.linalg.eigvals(W_hh)))
    
    # 模拟梯度从最后一个时间步反向传播
    grad = np.random.randn(hidden_size)
    grad_norms = [np.linalg.norm(grad)]
    
    for t in range(seq_len - 1, 0, -1):
        # 梯度传播: ∂L/∂h_{t} = ∂L/∂h_{t+1} · ∂h_{t+1}/∂h_t
        # ∂h_{t+1}/∂h_t = diag(1-tanh²) · W_hh^T
        # 简化：忽略tanh导数，仅考虑W_hh的缩放效应
        grad = np.dot(W_hh.T, grad) * 0.8  # 0.8模拟tanh导数的平均衰减
        grad_norms.append(np.linalg.norm(grad))
    
    return grad_norms, spectral_radius


print("BPTT 梯度传播模拟：")
print("=" * 60)
seq_lengths = [10, 20, 50]
for seq_len in seq_lengths:
    norms, sr = simulate_bptt(seq_len)
    print(f"\n  序列长度={seq_len}, W_hh 谱半径≈{sr:.3f}:")
    print(f"    第1步梯度范数: {norms[0]:.4f}")
    print(f"    第{seq_len}步梯度范数: {norms[-1]:.4f}")
    decay = norms[-1] / norms[0]
    print(f"    衰减比: {decay:.2e}")
    if decay < 1e-6:
        print(f"    → 梯度几乎消失，早期的输入无法影响参数更新！")

print(f"\n  解决方向: LSTM/GRU 通过门控机制控制梯度流")

大白话 BPTT的梯度传播像是"过去对现在的影响追溯"——最后一个时刻的损失，要追溯到第一个时刻，中间要经过几十次tanh和W_hh的连乘。如果每次连乘让梯度缩小一点点，几十次后梯度就没了。这就是RNN记不住长序列的原因。

四、RNN的变体与应用模式

是什么（定义）：根据输入输出序列的对应关系，RNN有四种经典应用模式：①多对一（Many-to-One）——序列输入、单个输出，如情感分析；②一对多（One-to-Many）——单个输入、序列输出，如图像描述生成；③多对多（同步）——序列输入、等长序列输出，如词性标注；④多对多（异步）——序列输入、不等长序列输出，如机器翻译（Encoder-Decoder架构）。

大白话 RNN的四种模式就像四种对话方式：多对一=读完一篇文章给一个评分（情感分析）；一对多=看一张图说一段话（图像描述）；多对多同步=逐字翻译标签（词性标注）；多对多异步=中文句子翻译成英文句子（机器翻译）。

概念关系图谱

重点答疑

Q1: RNN和普通前馈网络在参数数量上有什么本质区别？

前馈网络处理序列时，需要为每个时间步设置独立的权重，参数数量随序列长度线性增长。RNN通过参数共享，无论序列多长，参数数量都是固定的（仅取决于input_size×hidden_size×3）。这使得RNN可以泛化到训练时未见过的序列长度。例如，一个处理100个词的句子分类任务，前馈网络可能需要100×input_size×hidden_size的参数，而RNN只需input_size×hidden_size×3。

Q2: 为什么RNN的隐藏状态用tanh而不是ReLU？

RNN的隐藏状态会反复乘以自己的权重矩阵W_hh。如果使用ReLU（输出无上界），隐藏状态的值可能在多次循环后爆炸（因为正数不断累加）。tanh将输出限制在(-1,1)之间，为循环连接提供了天然的稳定机制。不过，IndRNN（Independent RNN）等变体通过特定设计成功使用了ReLU。

Q3: 既然标准RNN有这么多问题，为什么还要学它？

标准RNN是整个序列建模领域的理论起点。LSTM和GRU是对RNN的改进——它们在RNN的基础上增加了门控机制。理解RNN如何工作、为什么梯度会消失，才能真正理解LSTM/GRU的"遗忘门""输入门"为什么那样设计、以及它们如何巧妙地解决了梯度消失问题。此外，RNN的简单结构在一些短序列任务中仍然有效。

章节单词汇总