循环层 #
循环神经网络原理 #
循环神经网络（RNN）通过隐藏状态在时间步之间传递信息，适合处理序列数据。
text
┌─────────────────────────────────────────────────────────────┐
│ RNN 结构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 展开视图: │
│ │
│ t=1 t=2 t=3 │
│ ┌───┐ ┌───┐ ┌───┐ │
│ x1 ──│ │───►│ │───►│ │──► h3 (输出) │
│ │RNN│ │RNN│ │RNN│ │
│ └───┘ └───┘ └───┘ │
│ │ │ │ │
│ h1 h2 h3 │
│ (隐藏状态在每个时间步传递) │
│ │
│ 公式: │
│ h_t = tanh(W_h × h_{t-1} + W_x × x_t + b) │
│ │
└─────────────────────────────────────────────────────────────┘
SimpleRNN 层 #
基本用法 #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 32, input_length=100),
keras.layers.SimpleRNN(64),
keras.layers.Dense(1, activation='sigmoid')
])
参数详解 #
python
keras.layers.SimpleRNN(
units=64,
activation='tanh',
use_bias=True,
return_sequences=False,
return_state=False,
go_backwards=False,
dropout=0.0,
recurrent_dropout=0.0
)
text
┌─────────────────────────────────────────────────────────────┐
│ RNN 参数说明 │
├─────────────────────────────────────────────────────────────┤
│ │
│ units: 隐藏状态维度 │
│ │
│ return_sequences: │
│ ├── False: 只返回最后时间步的输出 │
│ └── True: 返回所有时间步的输出 │
│ │
│ return_state: 是否返回最终状态 │
│ │
│ go_backwards: 是否反向处理序列 │
│ │
│ dropout: 输入的 dropout 比例 │
│ │
│ recurrent_dropout: 循环连接的 dropout 比例 │
│ │
└─────────────────────────────────────────────────────────────┘
返回序列 #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 32, input_length=100),
keras.layers.SimpleRNN(64, return_sequences=True),
keras.layers.SimpleRNN(32),
keras.layers.Dense(1, activation='sigmoid')
])
LSTM 层 #
LSTM 通过门控机制解决长期依赖问题。
text
┌─────────────────────────────────────────────────────────────┐
│ LSTM 结构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ 遗忘门 f │ │
│ │ 决定丢弃什么 │ │
│ └────────┬────────┘ │
│ │ │
│ ┌──────────┐ ┌──────────┴──────────┐ │
│ │ 输入门 i │ │ 单元状态 │ │
│ │ 决定存储 │───►│ C_t (长期记忆) │ │
│ │ 什么信息 │ └──────────┬──────────┘ │
│ └──────────┘ │ │
│ │ │
│ ┌────────┴────────┐ │
│ │ 输出门 o │ │
│ │ 决定输出什么 │ │
│ └─────────────────┘ │
│ │ │
│ ┌────────┴────────┐ │
│ │ 隐藏状态 h_t │ │
│ │ (短期记忆) │ │
│ └─────────────────┘ │
│ │
│ 门控公式: │
│ f_t = σ(W_f × [h_{t-1}, x_t] + b_f) │
│ i_t = σ(W_i × [h_{t-1}, x_t] + b_i) │
│ o_t = σ(W_o × [h_{t-1}, x_t] + b_o) │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 128, input_length=100),
keras.layers.LSTM(64, dropout=0.2, recurrent_dropout=0.2),
keras.layers.Dense(1, activation='sigmoid')
])
双向 LSTM #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 128, input_length=100),
keras.layers.Bidirectional(keras.layers.LSTM(64)),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dense(1, activation='sigmoid')
])
text
┌─────────────────────────────────────────────────────────────┐
│ 双向 LSTM │
├─────────────────────────────────────────────────────────────┤
│ │
│ 前向: x1 ──► x2 ──► x3 ──► h_forward │
│ │
│ 后向: x1 ◄── x2 ◄── x3 ◄── h_backward │
│ │
│ 输出: [h_forward, h_backward] │
│ │
│ 优点: │
│ ├── 同时考虑过去和未来的上下文 │
│ └── 在 NLP 任务中效果更好 │
│ │
└─────────────────────────────────────────────────────────────┘
堆叠 LSTM #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 128, input_length=100),
keras.layers.LSTM(64, return_sequences=True),
keras.layers.LSTM(32),
keras.layers.Dense(1, activation='sigmoid')
])
返回状态 #
python
import keras
inputs = keras.Input(shape=(100, 32))
lstm, state_h, state_c = keras.layers.LSTM(64, return_state=True)(inputs)
model = keras.Model(inputs, [lstm, state_h, state_c])
GRU 层 #
GRU 是 LSTM 的简化版本，参数更少。
text
┌─────────────────────────────────────────────────────────────┐
│ GRU 结构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ GRU 只有两个门: │
│ │
│ ┌──────────────┐ │
│ │ 重置门 r │ ──► 控制如何使用过去信息 │
│ └──────────────┘ │
│ │
│ ┌──────────────┐ │
│ │ 更新门 z │ ──► 控制新旧信息混合比例 │
│ └──────────────┘ │
│ │
│ 公式: │
│ r_t = σ(W_r × [h_{t-1}, x_t]) │
│ z_t = σ(W_z × [h_{t-1}, x_t]) │
│ h̃_t = tanh(W × [r_t * h_{t-1}, x_t]) │
│ h_t = (1 - z_t) * h_{t-1} + z_t * h̃_t │
│ │
│ 优点: │
│ ├── 参数少，训练快 │
│ └── 在很多任务上效果接近 LSTM │
│ │
└─────────────────────────────────────────────────────────────┘
基本用法 #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 128, input_length=100),
keras.layers.GRU(64, dropout=0.2, recurrent_dropout=0.2),
keras.layers.Dense(1, activation='sigmoid')
])
双向 GRU #
python
import keras
model = keras.Sequential([
keras.layers.Embedding(10000, 128, input_length=100),
keras.layers.Bidirectional(keras.layers.GRU(64)),
keras.layers.Dense(1, activation='sigmoid')
])
ConvLSTM2D 层 #
ConvLSTM 结合了卷积和 LSTM，用于处理视频数据。
python
import keras
model = keras.Sequential([
keras.layers.ConvLSTM2D(
filters=32,
kernel_size=3,
padding='same',
return_sequences=False,
input_shape=(10, 64, 64, 1)
),
keras.layers.BatchNormalization(),
keras.layers.Conv2D(1, 3, padding='same', activation='sigmoid')
])
时间序列预测示例 #
python
import keras
import numpy as np
def create_dataset(data, look_back=10):
X, y = [], []
for i in range(len(data) - look_back):
X.append(data[i:i+look_back])
y.append(data[i+look_back])
return np.array(X), np.array(y)
data = np.sin(np.arange(0, 100, 0.1))
X, y = create_dataset(data, look_back=20)
X = X.reshape(X.shape[0], X.shape[1], 1)
model = keras.Sequential([
keras.layers.LSTM(50, activation='relu', input_shape=(20, 1)),
keras.layers.Dense(1)
])
model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=50, batch_size=32, validation_split=0.2)
文本分类示例 #
python
import keras
max_features = 10000
maxlen = 200
(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=max_features)
x_train = keras.preprocessing.sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = keras.preprocessing.sequence.pad_sequences(x_test, maxlen=maxlen)
model = keras.Sequential([
keras.layers.Embedding(max_features, 128, input_length=maxlen),
keras.layers.Bidirectional(keras.layers.LSTM(64, return_sequences=True)),
keras.layers.Bidirectional(keras.layers.LSTM(32)),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dropout(0.5),
keras.layers.Dense(1, activation='sigmoid')
])
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy']
)
history = model.fit(
x_train, y_train,
epochs=10,
batch_size=32,
validation_split=0.2
)
下一步 #
现在你已经掌握了循环层，接下来学习 正则化层，防止模型过拟合！
最后更新：2026-04-04