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

《深度学习实战》第3集：循环神经网络（RNN）与序列建模

article 2025/2/26 21:07:46

第3集：循环神经网络（RNN）与序列建模

引言

在深度学习领域，处理序列数据（如文本、语音、时间序列等）是一个重要的研究方向。传统的全连接网络和卷积神经网络（CNN）难以直接捕捉序列中的时序依赖关系，而循环神经网络（Recurrent Neural Network, RNN）应运而生。它通过引入“记忆”机制，能够有效建模序列数据的动态特性。然而，随着任务复杂度的提升，RNN 的局限性也逐渐显现，这促使了 LSTM 和 GRU 等改进模型的诞生。本集将深入探讨 RNN 的基本原理及其改进版本，并结合实战项目展示其应用价值。最后，我们还将讨论 Transformer 如何逐步取代 RNN 成为序列建模的新宠。

1. RNN 的基本原理与局限性

1.1 什么是 RNN？

RNN（Recurrent Neural Network）是一类适合处理序列数据的神经网络。与传统的前馈神经网络不同，RNN具有循环结构，可以将前一个时刻的信息传递到当前时刻，从而记忆序列中的历史信息。

RNN的工作原理：

在每个时间步，RNN通过接收当前输入和上一时刻的隐藏状态，更新当前的隐藏状态，并计算当前的输出。
这种结构允许RNN处理具有时序依赖关系的数据，如语音、文本和时间序列。

基本原理
RNN 的核心思想是通过一个循环结构，将当前时刻的输入与上一时刻的隐藏状态结合起来，从而实现对序列信息的记忆。具体来说，RNN 的计算公式如下：

$h_t = \sigma(W_h h_{t-1} + W_x x_t + b)$

其中：

$h_t 是当前时刻的隐藏状态；$
$x_t 是当前时刻的输入；$
$W_h 和 W_x 是权重矩阵；$
$b 是偏置项；$
$\sigma 是激活函数（通常为 tanh 或 ReLU）。$

通过这种递归计算，RNN 能够捕捉序列中的时序依赖关系。

局限性
尽管 RNN 在理论上可以处理任意长度的序列，但在实际训练中存在以下问题：

梯度消失/爆炸问题：由于反向传播过程中梯度需要通过时间维度传递，长序列会导致梯度指数级缩小或放大。当序列较长时，RNN的梯度容易在反向传播过程中消失或爆炸，使得模型难以学习长期依赖关系
长期依赖问题：RNN 难以记住距离较远的信息，因为隐藏状态会随着时间被覆盖或遗忘。RNN在捕捉较长时间依赖时效果较差，尤其是在长序列中，它无法保持足够的信息。

这些问题限制了 RNN 在复杂任务中的表现。

1.2 LSTM 和 GRU 的改进

为了克服 RNN 的局限性，研究者提出了两种改进模型：LSTM（Long Short-Term Memory）长短期记忆网络和 GRU（Gated Recurrent Unit）门控循环单元。它们通过引入门控机制，增强了模型对长期依赖的建模能力。

LSTM（长短期记忆网络）

LSTM通过引入“记忆单元”和“门控机制”来控制信息流动，克服了传统RNN在长时间序列建模中的不足。LSTM的核心组件包括：

遗忘门：决定当前时间步的记忆单元中哪些信息需要遗忘。
输入门：控制当前时间步的输入信息如何更新到记忆单元中。
输出门：控制记忆单元的信息如何影响输出。

通过这些门控机制，LSTM能够有效地保持长期依赖信息，避免梯度消失问题。

GRU（门控循环单元）

GRU是LSTM的简化版本，它将LSTM中的遗忘门和输入门合并为一个更新门，减少了参数量，使得训练更加高效。GRU的结构较LSTM更为简单，但在很多任务上，GRU与LSTM的表现相差不大。

LSTM 公式解释
LSTM 引入了三个门（输入门、遗忘门、输出门）以及一个细胞状态（cell state），用于控制信息的流动。其核心公式如下：

遗忘门：决定哪些信息需要从细胞状态中丢弃。
$f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$
输入门：决定哪些新信息需要添加到细胞状态中。
$i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$
$\tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C)$
更新细胞状态：
$C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t$
输出门：决定当前时刻的隐藏状态。
$o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$
$h_t = o_t \odot \tanh(C_t)$

GRU公式解释
GRU 是 LSTM 的简化版本，将遗忘门和输入门合并为更新门，并移除了单独的细胞状态。其核心公式如下：

更新门：
$z_t = \sigma(W_z \cdot [h_{t-1}, x_t] + b_z)$
重置门：
$r_t = \sigma(W_r \cdot [h_{t-1}, x_t] + b_r)$
候选隐藏状态：
$\tilde{h}_t = \tanh(W \cdot [r_t \odot h_{t-1}, x_t] + b)$
最终隐藏状态：
$h_t = (1 - z_t) \odot h_{t-1} + z_t \odot \tilde{h}_t$

LSTM 和 GRU 的门控机制使得它们能够更好地捕捉长期依赖关系，同时缓解了梯度消失问题。

1.3 序列建模的应用场景

RNN 及其变体广泛应用于以下领域：

语言建模：语言建模是自然语言处理中的一个重要任务，目标是根据前文的单词预测下一个单词。RNN、LSTM和GRU在语言建模中表现优异，能够捕捉句子中各个单词之间的时序依赖关系，可预测下一个单词的概率分布，常用于机器翻译、文本生成等任务。
时间序列预测：时间序列预测是使用历史数据预测未来的一个典型应用场景。例如，在股票市场中，我们希望基于历史价格数据预测未来的股价趋势。RNN、LSTM和GRU被广泛应用于金融领域的时间序列预测任务，也常用于天气预测等领域。
语音识别：将音频信号转化为文本。
视频分析：捕捉视频帧之间的时序关系。

2. 实战项目：使用 LSTM 预测股票价格趋势

2.1 项目背景

我们将使用LSTM模型来预测股票价格趋势。数据来源于Yahoo Finance，我们将使用过去的股票数据来预测未来几天的股票价格变化。

2.2 数据准备

首先，安装所需的库：

pip install yfinance pandas numpy matplotlib tensorflow scikit-learn

接着，获取股票数据并进行预处理：

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler

# 获取股票数据
data = yf.download('AAPL', start='2010-01-01', end='2023-01-01', auto_adjust=True)

# 使用收盘价
closing_prices = data['Close'].values.reshape(-1, 1)

# 数据归一化
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(closing_prices)

# 创建训练数据（使用过去60天的数据预测下一天的价格）
def create_dataset(data, time_step=60):
    X, y = [], []
    for i in range(len(data)-time_step-1):
        X.append(data[i:(i+time_step), 0])
        y.append(data[i + time_step, 0])
    return np.array(X), np.array(y)

X, y = create_dataset(scaled_data)

# 重塑输入数据的形状为 [样本数, 时间步长, 特征数]
X = X.reshape(X.shape[0], X.shape[1], 1)

# 划分训练集和测试集
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

2.3 构建LSTM模型

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

# 构建LSTM模型
model = Sequential()
model.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)))
model.add(Dropout(0.2))
model.add(LSTM(units=50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(units=1))

# 编译模型
model.compile(optimizer='adam', loss='mean_squared_error')

# 训练模型
model.fit(X_train, y_train, epochs=10, batch_size=32)

2.4 预测与可视化

# 使用模型进行预测
predictions = model.predict(X_test)

# 反归一化预测结果
predictions = scaler.inverse_transform(predictions)
y_test = scaler.inverse_transform(y_test.reshape(-1, 1))

# 可视化结果
plt.figure(figsize=(12, 6))
plt.plot(y_test, color='blue', label='Actual Stock Price')
plt.plot(predictions, color='red', label='Predicted Stock Price')
plt.title('Stock Price Prediction using LSTM')
plt.xlabel('Time')
plt.ylabel('Stock Price')
plt.legend()
plt.show()

** 代码汇总：**

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler

# 获取股票数据
data = yf.download('AAPL', start='2010-01-01', end='2023-01-01', auto_adjust=True)


if data.empty:
    print("No data found, check the stock symbol or try again later.")
else:

    # 使用收盘价
    closing_prices = data['Close'].values.reshape(-1, 1)

    # 数据归一化
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_data = scaler.fit_transform(closing_prices)

    # 创建训练数据（使用过去60天的数据预测下一天的价格）
    def create_dataset(data, time_step=60):
        X, y = [], []
        for i in range(len(data)-time_step-1):
            X.append(data[i:(i+time_step), 0])
            y.append(data[i + time_step, 0])
        return np.array(X), np.array(y)

    X, y = create_dataset(scaled_data)

    # 重塑输入数据的形状为 [样本数, 时间步长, 特征数]
    X = X.reshape(X.shape[0], X.shape[1], 1)

    # 划分训练集和测试集
    train_size = int(len(X) * 0.8)
    X_train, X_test = X[:train_size], X[train_size:]
    y_train, y_test = y[:train_size], y[train_size:]


    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import LSTM, Dense, Dropout

    # 构建LSTM模型
    model = Sequential()
    model.add(LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)))
    model.add(Dropout(0.2))
    model.add(LSTM(units=50, return_sequences=False))
    model.add(Dropout(0.2))
    model.add(Dense(units=1))

    # 编译模型
    model.compile(optimizer='adam', loss='mean_squared_error')

    # 训练模型
    model.fit(X_train, y_train, epochs=10, batch_size=32)

    # 使用模型进行预测
    predictions = model.predict(X_test)

    # 反归一化预测结果
    predictions = scaler.inverse_transform(predictions)
    y_test = scaler.inverse_transform(y_test.reshape(-1, 1))

    # 可视化结果
    plt.figure(figsize=(12, 6))
    plt.plot(y_test, color='blue', label='Actual Stock Price')
    plt.plot(predictions, color='red', label='Predicted Stock Price')
    plt.title('Stock Price Prediction using LSTM')
    plt.xlabel('Time')
    plt.ylabel('Stock Price')
    plt.legend()
    plt.show()

代码输出结果：

[*********************100%***********************]  1 of 1 completed
2025-02-25 22:43:23.883004: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
2025-02-25 22:43:26.821365: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
2025-02-25 22:43:29.733373: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
D:\python_projects\lstm_demo\Lib\site-packages\keras\src\layers\rnn\rnn.py:200: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(**kwargs)
Epoch 1/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 4s 19ms/step - loss: 0.0037
Epoch 2/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 3.0320e-04
Epoch 3/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 2.5178e-04
Epoch 4/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 2.8054e-04
Epoch 5/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 2.1884e-04
Epoch 6/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 1.9784e-04
Epoch 7/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 1.7942e-04
Epoch 8/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 1.9470e-04
Epoch 9/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 1.5350e-04
Epoch 10/10
81/81 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - loss: 2.8230e-04
21/21 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step

输出预测对比图片：
在这里插入图片描述

2.5 图解RNN和LSTM

RNN 展开图
LSTM 单元结构
（ LSTM 单元结构图，标注输入门、遗忘门、输出门和细胞状态。）

3. 前沿关联：Transformer 在序列建模中的崛起

尽管LSTM和GRU在序列建模中取得了显著成果，但随着Transformer模型的出现，序列建模的格局发生了变化。Transformer模型通过自注意力机制能够并行处理序列数据，且在处理长距离依赖时更加高效。如今，Transformer模型已广泛应用于自然语言处理任务，如BERT和GPT系列模型。Transformer 模型凭借其自注意力机制（Self-Attention）彻底改变了序列建模领域。相比于 RNN，Transformer 具有以下优势：

并行化训练：无需按时间顺序处理序列，大幅提高了训练效率。
长程依赖建模：自注意力机制能够直接捕捉全局依赖关系。
广泛应用：Transformer 已成为 GPT、BERT 等大模型的核心架构。

尽管如此，RNN 仍然在某些特定任务（如实时序列处理）中具有不可替代的价值。理解 RNN 的原理及其改进版本，有助于我们更好地掌握现代深度学习技术的发展脉络。

总结

本集聚焦于循环神经网络（RNN）的基本原理及其改进模型 LSTM 和 GRU，并通过实战项目展示了它们在时间序列预测中的应用。同时，我们也探讨了 Transformer 的崛起如何推动序列建模进入新时代。下一集，我们将深入探讨 Transformer 的工作原理及其在自然语言处理中的革命性应用。敬请期待！

查看全文

http://www.kler.cn/a/562233.html