在这个小节中，我们将深入讲解如何使用 PyTorch 实现一个时间序列预测项目。我们会构建一个简单的长短期记忆网络（LSTM），用于预测某种时间序列数据，如股票价格、气温等。
1. 环境准备
首先，确保你已在你的计算机上安装了 PyTorch。你可以通过以下命令安装：
1
| pip install torch torchvision
|
另外，为了处理数据，我们将使用 pandas 和可视化库 matplotlib：
1
| pip install pandas matplotlib
|
2. 数据加载
我们将使用一个常见的时间序列数据集，比如股票价格数据。下面的代码演示了如何加载数据并进行基本的预处理。
1
2
3
4
5
6
7
8
9
| import pandas as pd
data = pd.read_csv('path_to_your_data.csv')
data['Date'] = pd.to_datetime(data['Date'])
data.set_index('Date', inplace=True)
print(data.head())
|
3. 数据预处理
为了使用 LSTM 模型，我们需要将数据标准化并创建适合的输入输出对。
3.1 标准化
我们通常会使用 MinMaxScaler 来缩放数据至 [0, 1] 区间：
1
2
3
4
| from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
data_scaled = scaler.fit_transform(data.values)
|
3.2 创建时间序列数据集
我们将创建输入（X）和输出（y）数据集。假设我们希望用过去的 n_steps 天的股票价格来预测未来的一天的价格。
1
2
3
4
5
6
7
8
9
10
11
12
| import numpy as np
def create_dataset(data, time_steps=1):
X, y = [], []
for i in range(len(data) - time_steps - 1):
X.append(data[i:(i + time_steps), 0])
y.append(data[i + time_steps, 0])
return np.array(X), np.array(y)
n_steps = 10
X, y = create_dataset(data_scaled, n_steps)
X = X.reshape(X.shape[0], X.shape[1], 1)
|
4. 划分训练集和测试集
在进行模型训练之前，我们需要将数据划分为训练集和测试集：
1
2
3
| 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:]
|
5. 构建 LSTM 模型
我们将使用 PyTorch 来构建一个简单的 LSTM 网络：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| import torch
import torch.nn as nn
class LSTMModel(nn.Module):
def __init__(self, input_size=1, hidden_size=50, num_layers=1):
super(LSTMModel, self).__init__()
self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, 1)
def forward(self, x):
out, _ = self.lstm(x)
out = self.fc(out[:, -1, :])
return out
model = LSTMModel()
|
6. 定义损失函数与优化器
我们使用均方误差损失函数（MSE）和 Adam 优化器：
1
2
| criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
|
7. 模型训练
开始训练模型：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| num_epochs = 100
for epoch in range(num_epochs):
model.train()
optimizer.zero_grad()
inputs = torch.from_numpy(X_train).float()
targets = torch.from_numpy(y_train).float()
outputs = model(inputs)
loss = criterion(outputs, targets.view(-1, 1))
loss.backward()
optimizer.step()
if (epoch + 1) % 10 == 0:
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
|
8. 预测与可视化
训练完成后，我们可以在测试集上进行预测，并可视化结果：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| model.eval()
with torch.no_grad():
train_predict = model(torch.from_numpy(X_train).float())
test_predict = model(torch.from_numpy(X_test).float())
train_predict = scaler.inverse_transform(train_predict.numpy())
test_predict = scaler.inverse_transform(test_predict.numpy())
actual_prices = scaler.inverse_transform(data_scaled)
import matplotlib.pyplot as plt
plt.figure(figsize=(14,5))
plt.plot(data.index, actual_prices, label='Actual Prices', color='blue')
plt.plot(data.index[:train_size + n_steps], train_predict.flatten(), label='Train Predictions', color='orange')
plt.plot(data.index[train_size + n_steps:], test_predict.flatten(), label='Test Predictions', color='green')
plt.legend()
plt.show()
|
9. 结论
通过以上步骤，我们成功地使用 PyTorch 构建了一个 LSTM 模型来进行时间序列预测。这只是一个基本的实现，未来你可以尝试优化模型参数、增加特征、调整网络结构或尝试其他模型，以提高预测的准确性。
希望这个教程能对你学习 PyTorch 和时间序列预测的研究有所帮助！如有任何疑问，请随时提问。
