深度实战：使用 TensorFlow 和循环神经网络 (RNN) 进行时间序列预测

2026-02-16 02:28:49 0条评论 1次阅读 0人点赞

在数据科学和金融分析的领域中，时间序列预测一直是一个引人入胜且极具挑战性的课题。无论是预测股票市场的波动、电力负荷的需求，还是天气预报中的气温变化，我们都需要一种能够理解“时间”和“顺序”的模型。

虽然传统的统计模型（如 ARIMA）在很多场景下表现不错，但它们往往难以捕捉数据中的复杂非线性关系。这时，循环神经网络（RNN） 就派上用场了。RNN 及其变体（如 LSTM 和 GRU）在处理序列数据方面表现出色，因为它们拥有“记忆”能力，能够利用历史信息来预测未来。

在今天的这篇文章中，我们将深入探讨如何使用 TensorFlow 从零开始构建一个 RNN 模型，并将其应用于真实的股票价格预测。我们将一起走过数据获取、预处理、模型构建、训练以及评估的完整流程。这不仅是一次代码练习，更是一次深入了解深度学习如何应用于时间序列的实战探索。

什么是时间序列数据？

在开始写代码之前，让我们先统一一下认知。时间序列数据（Time Series Data）是一系列按时间顺序排列的数据点。与我们平时处理的独立同分布（I.I.D）数据不同，时间序列数据的核心特征在于依赖性——即当前的数据往往依赖于过去的数据。

时间序列通常包含以下几种成分，理解这些对于构建模型非常有帮助：

  • 趋势：数据在较长一段时间内的主要运动方向（上升或下降）。
  • 季节性：数据在固定的时间间隔内重复出现的周期性波动（例如，冰淇淋销量在夏季飙升）。
  • 噪声：数据中随机且不可预测的波动。

我们的目标是训练一个神经网络，让它学会从这些复杂的模式中区分出真正的趋势，从而预测下一个时间点的数值。

—

第一步：环境准备与库导入

工欲善其事，必先利其器。为了完成这个任务，我们需要借助 Python 生态系统中几个强大的库。我们将使用 INLINECODE4d3e09df 获取真实的市场数据，INLINECODEe40be8ad 和 INLINECODE3f7eed90 进行数据处理，INLINECODE25dfba18 进行可视化，最后使用 TensorFlow (keras) 来构建我们的深度学习模型。

请确保你的环境中已经安装了这些库。如果未安装，可以使用 pip install numpy pandas matplotlib yfinance scikit-learn tensorflow 进行安装。

让我们导入这些必要的工具：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import yfinance as yf

# 用于数据预处理的工具
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, mean_absolute_error

# TensorFlow 和 Keras 用于构建深度学习模型
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, SimpleRNN, Dropout

# 设置随机种子以保证实验的可复现性
np.random.seed(42)

实用见解：在金融时间序列中，数据通常是非平稳的，这意味着其统计特性（如均值和方差）会随时间变化。我们稍后介绍的“归一化”步骤就是为了解决这一问题，让模型更容易收敛。

—

第二步：获取真实世界的数据

没有什么比真实的数据更能让人兴奋了。我们将以苹果公司（AAPL）的股票为例，下载过去几年的历史收盘价。使用 yfinance 库，我们可以像专业的 quant 一样轻松拉取雅虎财经的数据。

在时间序列预测中，我们通常最关心的是收盘价（Close Price），因为它总结了该交易日的最终市场情绪。

# 定义股票代码和时间范围
ticker_symbol = ‘AAPL‘
start_date = ‘2018-01-01‘
end_date = ‘2024-01-01‘

print(f"正在下载 {ticker_symbol} 的数据...")
df = yf.download(ticker_symbol, start=start_date, end=end_date)

# 我们只关注 ‘Close‘ 列，并将其转换为 numpy 数组
# .values.reshape(-1, 1) 这一步非常关键，它将数据从一维向量转换为二维矩阵
# scikit-learn 的缩放器期望输入是 [样本数, 特征数] 的格式
data = df[[‘Close‘]].values.reshape(-1, 1)

print(f"数据形状: {data.shape}")
print("数据预览：")
print(df[[‘Close‘]].head())

代码工作原理深入讲解：

你可能会好奇为什么要做 INLINECODE359ccf28。在 Python 列表或 pandas Series 中，数据通常是一维的 INLINECODE8b06d734。但在机器学习中，我们需要明确区分“样本”和“特征”。虽然这里我们只有一个特征（收盘价），但模型仍需要二维数组 (N, 1) 来理解每一行是一个样本，每一列是一个特征。

—

第三步：数据归一化—— 让模型训练更稳定

这是一个绝对不能跳过的步骤。深度学习模型（特别是 RNN）对输入数据的数值范围非常敏感。如果股票价格在 100 到 200 之间波动，而我们的学习率设置不当，梯度更新可能会变得非常大，导致模型无法收敛（梯度爆炸）。

我们将使用 MinMaxScaler 将所有价格压缩到 0 和 1 之间。这保留了原始数据的分布形状，但消除了量纲的影响。

# 初始化缩放器，范围设定为 0 到 1
scaler = MinMaxScaler(feature_range=(0, 1))

# 计算缩放参数（最小值和最大值）并转换数据
scaled_data = scaler.fit_transform(data)

# 让我们看看缩放前后的对比（可选）
print("原始数据范围:", data.min(), "-", data.max())
print("缩放后数据范围:", scaled_data.min(), "-", scaled_data.max())

最佳实践：请注意，我们使用 fit_transform 在整个数据集上（或者仅训练集）来计算最小/最大值。在实际生产环境中，千万不要用测试集的数据来影响归一化过程，否则会导致“数据泄露”。这里为了简化流程，我们暂时对全量数据进行处理，但在构建训练集时会切分。

—

第四步：构建时间序列数据集（特征工程）

这是整个流程中最关键的一步。与普通的监督学习不同，我们不能直接把数据丢进模型。我们需要把一维的时间序列数据转换成“样本-标签”对。

我们的策略是使用滑动窗口：

  • 假设我们设定 time_step = 60。
  • 我们会用第 1 天到第 60 天的价格作为 输入 X。
  • 用第 61 天的价格作为 标签 y。

然后窗口向后滑动一步：用第 2 天到第 61 天预测第 62 天，以此类推。

def create_dataset(dataset, time_step=60):
    """
    将时间序列数据转换为 RNN 所需的样本格式。
    
    参数:
    dataset -- 归一化后的 numpy 数组
    time_step -- 用多少天的历史数据来预测下一天
    
    返回:
    X -- 输入特征集，形状
    y -- 目标标签集，形状
    """
    X, y = [], []
    for i in range(len(dataset) - time_step - 1):
        # 提取从 i 到 i+time_step 的数据作为特征
        X.append(dataset[i:(i + time_step), 0])
        # 提取 i+time_step 位置的数据作为目标
        y.append(dataset[i + time_step, 0])
    
    return np.array(X), np.array(y)

# 设定时间步长为 60 天
TIME_STEP = 60
X, y = create_dataset(scaled_data, TIME_STEP)

print(f"特征 X 的形状 (样本数, 时间步长): {X.shape}")
print(f"标签 y 的形状 (样本数,): {y.shape}")

深入理解输入形状：

对于 Keras 的 RNN 层（INLINECODEc5162296, INLINECODEd54d867c, INLINECODE0b43b52f），它期望的输入形状必须是 INLINECODE00af8df7。

  • samples：样本数量（我们有多少条训练数据）。
  • time_steps：每个样本包含的时间点数（这里是 60）。
  • features：每个时间点包含的特征数（这里只有收盘价 1 个）。

目前的 INLINECODE7c24692a 形状是 INLINECODEf7ff6ef2，我们需要手动给它增加一个维度来代表 features：

# 重塑 X 以适应 RNN 的输入要求 [样本数, 时间步长, 特征数]
X = X.reshape(X.shape[0], X.shape[1], 1)

print(f"重塑后 X 的形状: {X.shape}")

—

第五步：划分训练集与测试集

为了验证模型的好坏，我们需要留出一部分数据“藏”起来，不让模型在训练时看到。这部分就是测试集。我们将按照 80% 训练，20% 测试的比例进行切分。

# 计算分割点
train_size = int(len(X) * 0.8)
test_size = len(X) - train_size

# 切分数据
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

print(f"训练集大小: {X_train.shape[0]}")
print(f"测试集大小: {X_test.shape[0]}")

—

第六步：构建 RNN 模型

终于到了最激动人心的时刻——搭建神经网络！我们将使用 Keras 的 Sequential 模型，这是一种线性的层堆叠方式。

我们的架构设计如下：

  • SimpleRNN 层：这是核心。第一层有 50 个神经元。return_sequences=True 意味着该层会输出完整的序列到下一层（如果我们想堆叠多个 RNN 层，这必须是 True）。
  • SimpleRNN 层：第二层也有 50 个神经元。因为这是最后一层 RNN，我们设置 return_sequences=False，只输出最终的结果。
  • Dense 层：全连接层，输出 1 个数值（预测的股价）。
model = Sequential()

# 第一层 RNN
# input_shape=(TIME_STEP, 1) 对应 (60, 1)
model.add(SimpleRNN(units=50, return_sequences=True, input_shape=(TIME_STEP, 1)))

# 第二层 RNN
model.add(SimpleRNN(units=50, return_sequences=False))

# 输出层：预测一个值
model.add(Dense(units=1))

# 编译模型
# optimizer=‘adam‘ 是目前最流行的自适应优化器
# loss=‘mean_squared_error‘ (MSE) 是回归问题的标准损失函数
model.compile(optimizer=‘adam‘, loss=‘mean_squared_error‘)

# 打印模型结构概要
model.summary()

模型参数解析：

  • units=50：这意味着 RNN 内部的隐藏状态维度是 50。更多的单元意味着模型有更强的记忆力，但也更容易过拟合，且计算更慢。
  • inputshape：这里我们只需要指定单个样本的形状 INLINECODE0f940a90，Keras 会自动处理批次大小。

—

第七步：训练模型

现在，我们将数据喂给模型，让它开始学习。这个过程称为“拟合”。

# 设置训练轮数和批次大小
epochs = 20
batch_size = 32

print("开始训练模型...")
# 使用 fit 方法进行训练
# verbose=1 意味着会显示进度条
history = model.fit(X_train, y_train, 
                    validation_data=(X_test, y_test), 
                    epochs=epochs, 
                    batch_size=batch_size, 
                    verbose=1)
print("训练完成！")

性能优化建议：

  • 早停：如果你发现验证集的损失不再下降，甚至开始上升，这就是过拟合的迹象。可以使用 tf.keras.callbacks.EarlyStopping 来自动停止训练并保存最好的模型权重。
  • 批次大小：调整 batch_size 会影响训练速度和模型收敛质量。对于时间序列，较小的 batch size 有时能带来更好的泛化能力，因为时间序列数据往往非常嘈杂。

—

第八步：预测与结果可视化

训练完成后，我们需要看看模型到底学到了什么。我们将对测试集进行预测，然后将结果从归一化状态还原回真实价格（这一步叫 Inverse Transform），最后画图对比。

# 1. 对测试集进行预测
train_predict = model.predict(X_train)
test_predict = model.predict(X_test)

# 2. 反向归一化（还原成真实股价）
# 注意：scaler.inverse_transform 需要输入维度是 (n, 1)
train_predict = scaler.inverse_transform(train_predict)
test_predict = scaler.inverse_transform(test_predict)

# 对真实值 y_train 和 y_test 也要还原，以便对比
# 这里的 y 只是数组，需要先 reshape 成 (n, 1)
y_train_actual = scaler.inverse_transform(y_train.reshape(-1, 1))
y_test_actual = scaler.inverse_transform(y_test.reshape(-1, 1))

# 3. 计算评估指标 (RMSE - 均方根误差)
train_rmse = np.sqrt(mean_squared_error(y_train_actual, train_predict))
test_rmse = np.sqrt(mean_squared_error(y_test_actual, test_predict))

print(f"训练集 RMSE: {train_rmse:.2f}")
print(f"测试集 RMSE: {test_rmse:.2f}")

接下来是可视化部分。我们要画出预测曲线和真实曲线。

# 准备绘图数据
# 我们需要构建一个完整的数组来展示整个时间轴上的预测效果
# 对于训练部分，我们需要把前面 time_step 个空位补齐（用 NaN）
look_back = TIME_STEP

train_predict_plot = np.empty_like(data) # 创建一个和原始数据一样大小的空数组
train_predict_plot[:, :] = np.nan
# 将训练预测放入对应位置（从 time_step 开始，到 train_size + time_step 结束）
train_predict_plot[look_back:len(train_predict)+look_back, :] = train_predict

# 对于测试预测部分，从 train_predict_plot 的末尾开始
test_predict_plot = np.empty_like(data)
test_predict_plot[:, :] = np.nan
# 计算测试预测的起始索引
test_start_index = len(train_predict) + look_back
# 将测试预测放入位置
test_predict_plot[test_start_index:len(data)-1, :] = test_predict

# 绘图
plt.figure(figsize=(14, 7))
plt.plot(scaler.inverse_transform(scaled_data), color=‘blue‘, label=‘真实股价‘, alpha=0.5)
plt.plot(train_predict_plot, color=‘orange‘, label=‘训练集预测‘)
plt.plot(test_predict_plot, color=‘green‘, label=‘测试集预测‘)
plt.title(f‘{ticker_symbol} 股价预测
plt.xlabel(‘时间‘)
plt.ylabel(‘价格‘)
plt.legend(loc=‘upper left‘)
plt.grid(True)
plt.show()

常见错误与解决方案

在实践过程中，你可能会遇到以下问题，这里提供一些排查思路：

  • 预测结果是一条直线：这通常是因为模型没有学到特征，或者学习率太高导致模型陷入了局部最小值。尝试降低 INLINECODE06c1d840 或者增加模型的复杂度（增加 INLINECODE534856aa）。
  • 误差非常大：检查你是否忘记了对预测结果进行 inverse_transform。直接比较归一化后的数据和原始数据是没有意义的。另外，确认你的数据切分是否打乱了时间顺序——绝对不要 shuffle 时间序列数据！
  • 梯度爆炸/消失：简单的 RNN（INLINECODEf72d3286）在处理很长的序列时，很难记住很久之前的信息。如果你发现无论怎么训练效果都不好，建议将 INLINECODE3794443b 替换为 INLINECODE5734d83a 或 INLINECODE989498a8，它们专门设计用来解决长序列依赖问题。

总结与后续步骤

在这篇文章中，我们完整地走了一遍使用 TensorFlow 进行时间序列预测的流程。从理解什么是滑动窗口，到如何构建 3D 输入张量，再到训练 RNN 模型并可视化结果，你已经掌握了处理此类问题的核心技能。

你学到了什么：

  • 时间序列数据需要特殊的预处理（归一化、滑动窗口）。
  • RNN 的输入形状是 (samples, time_steps, features)。
  • 如何评估回归模型的性能（使用 RMSE 和可视化）。

下一步做什么？

虽然 INLINECODEb6810dde 是一个很好的起点，但在工业界应用中，我们通常会使用更高级的层，比如 LSTM (长短期记忆网络) 或 GRU。它们在处理长期依赖关系时表现更好。你可以尝试修改上面的代码，将 INLINECODE7d2d1a69 替换为 LSTM，看看模型性能是否有所提升。

此外，你还可以尝试加入更多特征（如开盘价、成交量），这就是所谓的多变量时间序列预测，这将使你的模型更加智能和全面。

希望这篇指南能帮助你在时间序列预测的旅程中迈出坚实的一步！继续尝试，不断优化，你会发现数据的模式其实有迹可循。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/52274.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年