第26课：TensorFlow｜循环神经网络RNN原理【时序数据处理、序列依赖关系讲解】

1. 课前导读

1.1 本节课学习目标

• 理解序列数据的特点（长度可变、前后依赖）及传统全连接网络无法有效建模的原因。
• 掌握RNN的循环结构：隐藏状态在时间步间传递，共享权重参数。
• 理解RNN的数学表达：( h_t = \tanh(W_{xh}x_t + W_{hh}h_{t-1} + b_h) )，输出 ( y_t = W_{hy}h_t + b_y )。
• 掌握通过时间反向传播（BPTT）的基本思想及梯度消失/爆炸的成因。
• 学会使用TensorFlow 2.x的SimpleRNN、SimpleRNNCell搭建RNN模型。
• 能够应用RNN进行简单的时间序列预测和文本情感分类。

1.2 知识重难点

1.3 学习前置条件

• 已完成前馈神经网络和CNN的学习（第11-15课）。
• 熟悉TensorFlow基本操作和模型训练（第12、17课）。
• 了解矩阵乘法和链式法则（第7课）。

1.4 学完可掌握能力

• 独立搭建RNN处理任意序列数据（文本、时间序列）。
• 理解RNN训练中的梯度问题，并能应用简单缓解策略。
• 可视化RNN的隐藏状态变化，理解模型的记忆行为。

1.5 行业应用场景

• 自然语言处理：情感分析、文本生成、机器翻译。
• 时间序列预测：股票价格、电力负荷、天气预测。
• 语音识别：将声学特征序列映射为音素。
• 手写体识别：在线手写轨迹识别。

2. 核心理论精讲

2.1 序列数据与建模挑战

序列数据是元素按时间或逻辑顺序排列的数据，例如文本（单词序列）、语音（帧序列）、股票价格（每日值）。其关键特性是前后依赖，即当前时刻的值与过去时刻的值相关。

传统前馈网络（全连接、CNN）假设输入独立同分布，无法捕捉时间依赖。若将序列展平后输入，则模型参数量随序列长度线性增长，且无法处理可变长度序列。循环神经网络通过在隐层引入循环连接，使信息能够持续传递。

2.2 RNN的循环结构与数学形式

RNN在每个时间步 ( t ) 更新隐藏状态 ( h_t )，它基于当前输入 ( x_t ) 和上一时刻隐藏状态 ( h_{t-1} )：

[
h_t = \tanh(W_{xh} x_t + W_{hh} h_{t-1} + b_h)
]

其中：

• ( W_{xh} )：输入到隐藏的权重矩阵（维度：隐藏单元数 × 输入特征数）
• ( W_{hh} )：隐藏到隐藏的权重矩阵（循环矩阵）
• ( b_h )：偏置

输出通常由隐藏状态通过全连接得到：

[
y_t = W_{hy} h_t + b_y
]

对于分类任务，可在最后一个时间步输出，或每个时间步输出。

参数共享：所有时间步使用相同的 ( W_{xh}, W_{hh}, W_{hy} )，这使RNN能够处理变长序列，且参数数量不随序列长度增加。

2.3 通过时间反向传播（BPTT）

RNN的训练使用BPTT：将循环网络按时间展开为深层前馈网络（每层对应一个时间步），然后计算损失对各个参数的梯度。总损失为各时间步损失之和（或平均）。

BPTT的梯度公式中，隐藏状态的梯度会反复乘以 ( W_{hh}^\top )。对于长序列，这导致梯度消失或爆炸：

• 若 ( W_{hh} ) 的最大奇异值 < 1，梯度指数级衰减 → 难以捕捉长期依赖。
• 若 > 1，梯度指数级增长 → 训练不稳定。

缓解措施：

• 梯度裁剪（第7课）。
• 使用更复杂的单元（LSTM、GRU，下节课）。
• 初始化 ( W_{hh} ) 为单位矩阵（正交初始化）。
• 使用梯度截断BPTT（truncated BPTT），限制反向传播的时间步数。

2.4 RNN的输入输出模式

• 多对一：输入序列，输出单个值（情感分类、序列分类）。
• 多对多（等长）：每个时间步都有输出（词性标注）。
• 多对多（不等长）：编码器-解码器结构（机器翻译）。

在Keras中，SimpleRNN层通过参数return_sequences控制是返回最后一个时间步的输出（False，默认）还是全部时间步的输出（True）。return_state可以额外返回最后一个隐藏状态。

2.5 RNN的局限性

• 短期记忆：由于梯度消失，基本RNN只能捕捉短距离依赖（约10步）。
• 串行计算：不能像CNN那样并行处理，训练较慢。
• 梯度爆炸：即使初始化得当，长序列仍可能爆炸，需梯度裁剪。

LSTM和GRU通过门控机制解决了长期依赖问题，但理解RNN是学习它们的基础。

3. 环境搭建与工具配置

沿用第25课环境。无需额外安装。

conda activate tf213
python

导入模块：

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras import layers, models, datasets, callbacks

4. 代码实战教学

4.1 手动实现SimpleRNN前向传播（NumPy）

为了理解底层计算，先用NumPy实现单层RNN的单个时间步和序列前向传播。

def simple_rnn_step(x, h_prev, W_xh, W_hh, b):
    h_next = np.tanh(np.dot(W_xh, x) + np.dot(W_hh, h_prev) + b)
    return h_next

# 参数设置
input_dim = 3
hidden_dim = 5
W_xh = np.random.randn(hidden_dim, input_dim)
W_hh = np.random.randn(hidden_dim, hidden_dim)
b = np.random.randn(hidden_dim)

# 初始隐藏状态
h = np.zeros(hidden_dim)
# 模拟输入序列：3个时间步，每个步输入维度3
x_seq = [np.random.randn(input_dim) for _ in range(3)]
outputs = []
for x in x_seq:
    h = simple_rnn_step(x, h, W_xh, W_hh, b)
    outputs.append(h.copy())
print(f"Final hidden state shape: {h.shape}")

4.2 使用Keras SimpleRNN层

# 随机生成序列数据：1000个样本，每个样本10个时间步，每个时间步特征5维
batch_size = 32
timesteps = 10
features = 5
X = np.random.randn(1000, timesteps, features).astype(np.float32)
y = np.random.randint(0, 2, size=(1000,))  # 二分类标签

model = models.Sequential([
    layers.SimpleRNN(64, input_shape=(timesteps, features), activation='tanh'),
    layers.Dense(1, activation='sigmoid')
])
model.summary()
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=5, batch_size=batch_size, validation_split=0.2, verbose=1)

4.3 理解return_sequences与堆叠RNN

# 堆叠两层RNN，第一层需要返回全部时间步输出
stacked_rnn = models.Sequential([
    layers.SimpleRNN(32, return_sequences=True, input_shape=(timesteps, features)),
    layers.SimpleRNN(16),
    layers.Dense(1, activation='sigmoid')
])
stacked_rnn.summary()

4.4 使用RNNCell自定义循环

# 使用SimpleRNNCell手动循环，适合需要自定义处理的场景
cell = layers.SimpleRNNCell(64)
rnn_layer = layers.RNN(cell, return_sequences=True)
# 或者直接使用RNN + cell
model_cell = models.Sequential([
    layers.RNN(layers.SimpleRNNCell(64), input_shape=(timesteps, features)),
    layers.Dense(1, activation='sigmoid')
])

4.5 梯度裁剪与优化

# 在优化器中设置梯度裁剪
optimizer = tf.keras.optimizers.Adam(clipnorm=1.0)  # 全局范数裁剪
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])

5. 案例实操演练

5.1 案例一：正弦波预测（多对一回归）

使用RNN根据前N个点预测下一个点的值。

# 生成正弦波序列
def generate_sine_sequence(seq_length=100, num_seq=1000):
    X_data = []
    y_data = []
    for _ in range(num_seq):
        start = np.random.uniform(0, 2*np.pi)
        t = np.linspace(start, start + seq_length/10, seq_length+1)
        wave = np.sin(t)
        X_data.append(wave[:-1].reshape(-1, 1))  # (seq_length, 1)
        y_data.append(wave[-1])                  # scalar
    return np.array(X_data, dtype=np.float32), np.array(y_data, dtype=np.float32)

seq_len = 20
X_sine, y_sine = generate_sine_sequence(seq_len, 2000)
# 划分训练/测试
split = 1800
X_train, X_test = X_sine[:split], X_sine[split:]
y_train, y_test = y_sine[:split], y_sine[split:]

# 构建RNN回归模型
rnn_reg = models.Sequential([
    layers.SimpleRNN(32, input_shape=(seq_len, 1), activation='tanh'),
    layers.Dense(1)
])
rnn_reg.compile(optimizer='adam', loss='mse')
history = rnn_reg.fit(X_train, y_train, epochs=30, batch_size=32, validation_split=0.1, verbose=1)

# 预测并绘图
preds = rnn_reg.predict(X_test)
plt.figure(figsize=(10,5))
plt.plot(y_test[:100], label='True')
plt.plot(preds[:100], label='Predicted')
plt.legend()
plt.title('Sine Wave Prediction')
plt.show()

5.2 案例二：IMDb情感分类（多对一分类）

使用RNN对电影评论进行情感分类（二分类）。

# 加载IMDb数据集，只保留最常用的10000个词
max_features = 10000
maxlen = 200
(x_train, y_train), (x_test, y_test) = datasets.imdb.load_data(num_words=max_features)

# 序列填充/截断到相同长度
x_train = tf.keras.preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = tf.keras.preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen)

# 构建RNN模型
rnn_imdb = models.Sequential([
    layers.Embedding(max_features, 64, input_length=maxlen),
    layers.SimpleRNN(64, dropout=0.2, recurrent_dropout=0.2),
    layers.Dense(1, activation='sigmoid')
])
rnn_imdb.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
rnn_imdb.summary()

# 训练（使用部分数据加速）
history_imdb = rnn_imdb.fit(x_train[:2000], y_train[:2000], batch_size=64, epochs=10,
                             validation_data=(x_test[:500], y_test[:500]), verbose=1)

# 评估
test_loss, test_acc = rnn_imdb.evaluate(x_test, y_test, verbose=0)
print(f"Test accuracy: {test_acc:.4f}")

5.3 可视化隐藏状态

对于单个评论，提取RNN各时间步的隐藏状态，观察其变化。

# 构建一个输出中间状态的模型
rnn_layer = layers.SimpleRNN(64, return_sequences=True, input_shape=(maxlen, 64))  # 注意输入需匹配Embedding输出
# 更直接的方式：创建子模型
embed_layer = layers.Embedding(max_features, 64)
rnn_cell = layers.SimpleRNN(64, return_sequences=True)

inputs = tf.keras.Input(shape=(maxlen,))
x = embed_layer(inputs)
x = rnn_cell(x)
model_state = tf.keras.Model(inputs, x)

# 取一个样本
sample = x_train[0:1]  # shape (1, maxlen)
states = model_state.predict(sample)  # (1, maxlen, 64)
states = states[0]  # (maxlen, 64)

# 可视化第1个隐藏单元的激活值序列
plt.plot(states[:, 0])
plt.title('Hidden state (dim 0) over time')
plt.xlabel('Time step')
plt.ylabel('Activation')
plt.show()

6. 常见坑点与排错总结

6.1 输入形状错误

• 坑1：SimpleRNN要求输入形状(batch, timesteps, features)，但直接传入2D数据(batch, features)。

  • 解决：确保数据是3D的，可使用np.expand_dims或reshape增加时间步维度。

• 坑2：堆叠RNN时，第一层return_sequences=False（默认），导致第二层接收不到序列。

  • 解决：堆叠时中间层必须设置return_sequences=True。

6.2 梯度问题

• 坑3：长序列训练损失不下降或变为NaN，可能是梯度爆炸。

  • 解决：添加梯度裁剪（clipnorm或clipvalue），减小学习率，使用tanh激活（其输出范围有限）。

• 坑4：模型无法捕捉长期依赖，可能是梯度消失。

  • 解决：使用LSTM或GRU（下一课），或缩短序列长度（截断）。

6.3 数据预处理

• 坑5：文本数据未进行填充/截断，导致批次内长度不一致。

  • 解决：使用pad_sequences统一长度。

• 坑6：时间序列回归中未对目标值进行归一化，导致MSE过大。

  • 建议：对输入和目标均做标准化。

6.4 性能与过拟合

• 坑7：RNN在小数据集上容易过拟合，因为参数量相对大。

  • 解决：减少RNN单元数，添加Dropout（dropout和recurrent_dropout），使用正则化。

• 坑8：训练速度慢，因RNN无法并行。

  • 解决：减少序列长度，使用CuDNN优化的LSTM（在GPU上自动加速）。

7. 知识点总结 + 课后作业

7.1 核心知识点梳理

• RNN循环结构：隐藏状态在时间步间传递，参数共享，可处理变长序列。
• BPTT：按时间展开后反向传播，梯度消失/爆炸由循环权重矩阵的特征值决定。
• Keras实现：SimpleRNN层，return_sequences控制输出模式，return_state获取最终状态。
• 输入输出模式：多对一（序列分类）、多对多（序列标注）、多对多不等长（编码器-解码器）。
• 梯度问题缓解：梯度裁剪、初始化、LSTM/GRU。

7.2 基础作业

1. 使用NumPy手动实现RNN的前向传播，计算给定输入序列和随机权重的隐藏状态序列。
2. 在正弦波预测案例中，改变序列长度（例如从20改为50），观察预测误差的变化，分析原因。
3. 使用SimpleRNN在IMDb情感分类上训练完整数据（25000条），报告测试准确率（约85%左右可达）。

7.3 进阶实操作业

任务：实现Truncated BPTT

由于标准BPTT在长序列上梯度消失，Truncated BPTT将长序列分段，每次只反向传播有限步数。使用TensorFlow的tf.GradientTape和tf.while_loop或手动分段训练一个RNN模型，对比与标准BPTT的训练效率和最终性能。提示：可以使用循环内创建tape，每个片段独立更新。

7.4 思考拓展题

1. 为什么RNN的循环权重矩阵 W_hh 的初始化为单位矩阵或正交矩阵有助于缓解梯度消失？

2. 在情感分类任务中，如果我们将评论的单词顺序完全打乱，RNN的性能会下降多少？为什么？

3. 除了梯度裁剪，还有哪些方法可以防止梯度爆炸？它们在RNN中如何实现？

下一课预告：LSTM与GRU核心结构——我们将学习长短期记忆网络和门控循环单元，它们通过门控机制有效解决了长期依赖问题，成为RNN的实际标准。

🔗《TensorFlow2.x: 深度学习入门到高阶实战教程》系列课程导航

去订阅

第一部分：基础入门（1-10 课）
第二部分：神经网络核心（11-25 课）
第三部分：进阶网络与框架高阶（26-40 课）
第四部分：企业实战与项目落地（41-50 课）

🌟 感谢您耐心阅读到这里！
💡 如果本文对您有所启发欢迎：
👍 点赞📌 收藏 📤 分享给更多需要的伙伴。
🗣️ 期待在评论区看到您的想法, 共同进步。
🔔 关注我，持续获取更多干货内容～
🤗 我们下篇文章见～