基于Python的机器学习系列（32）：PyTorch

基于Python的机器学习系列（32）：PyTorch - 循环神经网络（RNN）

news2024/9/20 0:42:15

在本篇文章中，我们将探索循环神经网络（RNN），这是一种特别适用于时间序列数据或文本数据的神经网络模型。在RNN中，当前的输出不仅取决于当前的输入，还受到前一步输出的影响，从而能够捕捉序列数据中的时间依赖性。

1. 循环神经网络（RNN）基础

RNN的基本单元可以通过以下公式表示：

2. 使用LSTM预测苹果股票价格

在这部分中，我们将使用LSTM（长短期记忆网络）来预测苹果股票的未来价格。LSTM是一种改进版的RNN，专门设计用来解决标准RNN在处理长时间序列时遇到的梯度消失或爆炸问题。

步骤概述

数据加载和预处理：我们将加载包含苹果股票历史数据的CSV文件，并进行必要的预处理，如归一化和时间序列拆分。
构建LSTM模型：定义一个LSTM模型来处理我们的时间序列数据，包括输入层、LSTM层和全连接层。
训练模型：使用过去的30天数据来训练模型，并进行预测。
评估和预测：使用模型对未来的价格进行预测，并评估模型性能。

示例代码

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 设置设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"使用的设备: {device}")

# 1. 加载数据
df = pd.read_csv("data/appl_1980_2014.csv")
df.Date = pd.to_datetime(df.Date)
df = df.set_index('Date')

# 数据归一化
data = df[['Close']].values
data = (data - np.min(data)) / (np.max(data) - np.min(data))

# 创建时间序列数据
def create_sequences(data, seq_length):
    sequences = []
    labels = []
    for i in range(len(data) - seq_length):
        sequences.append(data[i:i+seq_length])
        labels.append(data[i+seq_length])
    return np.array(sequences), np.array(labels)

seq_length = 30
X, y = create_sequences(data, seq_length)

# 划分训练集和测试集
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:]

# 转换为PyTorch张量
X_train = torch.FloatTensor(X_train).to(device)
y_train = torch.FloatTensor(y_train).to(device)
X_test = torch.FloatTensor(X_test).to(device)
y_test = torch.FloatTensor(y_test).to(device)

# 2. 定义LSTM模型
class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTM, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), self.hidden_size).to(device)
        c0 = torch.zeros(1, x.size(0), self.hidden_size).to(device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

input_size = 1
hidden_size = 64
output_size = 1

model = LSTM(input_size, hidden_size, output_size).to(device)

# 3. 训练模型
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    outputs = model(X_train)
    optimizer.zero_grad()
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 4. 评估模型
model.eval()
with torch.no_grad():
    predictions = model(X_test)
    plt.plot(y_test.cpu().numpy(), label='真实值')
    plt.plot(predictions.cpu().numpy(), label='预测值')
    plt.legend()
    plt.show()