lstm中look_back的大小选择_PyTorch | LSTM理解

在 LSTM 中，look_back 的大小指的是用于预测当前时间步的输入序列的长度。在 PyTorch 中，可以通过设置输入数据的维度来指定 look_back 的大小。

通常情况下，选择 look_back 的大小需要根据具体的问题和数据集来确定。如果 look_back 太小，则可能会导致模型无法捕捉到时间序列中的长期依赖关系；如果 look_back 太大，则可能会导致模型过拟合，因为模型需要学习过多的信息。

一种常见的方法是通过交叉验证来选择最优的 look_back 大小。具体来说，可以将数据集分为训练集和验证集，然后在训练集上训练模型，并在验证集上评估模型的性能。通过尝试不同的 look_back 大小，并比较模型在验证集上的性能，可以选择最优的 look_back 大小。

相关问题

pytorch 建立lstm预测价格

以下是使用 PyTorch 建立 LSTM 模型预测价格的示例代码：

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

# 加载数据
data = pd.read_csv('data.csv', usecols=[1])
dataset = data.values
dataset = dataset.astype('float32')

# 划分训练集和测试集
train_size = int(len(dataset) * 0.67)
test_size = len(dataset) - train_size
train_data, test_data = dataset[0:train_size,:], dataset[train_size:len(dataset),:]

# 创建数据集函数，用于将时间序列数据转化为有监督学习数据
def create_dataset(dataset, look_back=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-1):
        a = dataset[i:(i+look_back), 0]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 0])
    return np.array(dataX), np.array(dataY)

# 定义超参数
look_back = 3
hidden_size = 4
learning_rate = 0.01
epochs = 1000

# 转化为有监督学习数据集
trainX, trainY = create_dataset(train_data, look_back)
testX, testY = create_dataset(test_data, look_back)

# 转化为张量
trainX = torch.from_numpy(trainX)
trainY = torch.from_numpy(trainY)
testX = torch.from_numpy(testX)
testY = torch.from_numpy(testY)

# 定义 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)
        self.linear = nn.Linear(hidden_size, output_size)
        
    def forward(self, input):
        lstm_out, _ = self.lstm(input.view(len(input), 1, -1))
        predictions = self.linear(lstm_out.view(len(input), -1))
        return predictions[-1]

# 实例化模型
input_size = 1
output_size = 1
lstm = LSTM(input_size, hidden_size, output_size)

# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(lstm.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(epochs):
    outputs = lstm(trainX.float())
    optimizer.zero_grad()
    loss = criterion(outputs, trainY.float())
    loss.backward()
    optimizer.step()
    if epoch % 100 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, epochs, loss.item()))

# 测试模型
lstm.eval()
train_predict = lstm(trainX.float())
test_predict = lstm(testX.float())

# 反归一化
train_predict = train_predict.detach().numpy()
test_predict = test_predict.detach().numpy()
trainY = trainY.numpy()
testY = testY.numpy()

train_predict = train_predict * 100
trainY = trainY * 100
test_predict = test_predict * 100
testY = testY * 100

# 绘制预测结果
plt.plot(trainY)
plt.plot(train_predict)
plt.plot(range(train_size,len(dataset)),testY)
plt.plot(range(train_size,len(dataset)),test_predict)
plt.show()

在上述代码中，我们首先加载数据并将其划分为训练集和测试集。然后，我们创建了一个函数，用于将时间序列数据转化为有监督学习数据。接着，我们定义了超参数，包括往前看的时间步数、LSTM 隐藏层大小、学习率和训练轮数。我们使用了 PyTorch 的 nn.Module 类创建 LSTM 模型，其中包含一个 LSTM 层和一个线性层。然后，我们定义了损失函数和优化器，并使用训练数据训练模型。最后，我们使用测试数据测试模型，并将预测结果可视化。

pytorch LSTM时间序列多变量多步预测

对于时间序列多变量多步预测，可以使用LSTM模型进行建模。LSTM模型是一种循环神经网络，能够处理序列数据，并且能够捕捉数据中的长期依赖性。

在使用LSTM进行多步预测时，需要注意以下几点：

1. 数据预处理：将原始数据进行归一化处理，并且将时间序列数据转换为监督学习问题。

2. 模型设计：设计LSTM模型，需要考虑输入数据的形状、LSTM层的数量和神经元的数量等因素。

3. 训练模型：使用训练数据对LSTM模型进行训练，并且使用验证数据对模型进行调优。

4. 多步预测：使用训练好的模型对测试数据进行多步预测，需要注意多步预测的方式和时间步长的选择。

下面是一个使用PyTorch实现LSTM进行时间序列多变量多步预测的示例代码：

import torch
import torch.nn as nn
import numpy as np

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

# 数据预处理
def create_dataset(dataset, look_back=1, look_forward=1):
    dataX, dataY = [], []
    for i in range(len(dataset)-look_back-look_forward+1):
        a = dataset[i:(i+look_back), :]
        dataX.append(a)
        dataY.append(dataset[i+look_back:i+look_back+look_forward, -1])
    return np.array(dataX), np.array(dataY)

# 定义超参数
input_size = 2
hidden_size = 64
output_size = 1
num_layers = 2
num_epochs = 100
batch_size = 64
learning_rate = 0.01
look_back = 24
look_forward = 12

# 准备数据
data = np.loadtxt('data.csv', delimiter=',')
data = (data - np.min(data, 0)) / (np.max(data, 0) - np.min(data, 0))
train_size = int(len(data) * 0.7)
train_data = data[:train_size, :]
test_data = data[train_size:, :]
trainX, trainY = create_dataset(train_data, look_back, look_forward)
testX, testY = create_dataset(test_data, look_back, look_forward)
trainX = torch.from_numpy(trainX).type(torch.Tensor).to(device)
trainY = torch.from_numpy(trainY).type(torch.Tensor).to(device)
testX = torch.from_numpy(testX).type(torch.Tensor).to(device)
testY = torch.from_numpy(testY).type(torch.Tensor).to(device)

# 定义模型和优化器
model = LSTM(input_size, hidden_size, output_size, num_layers).to(device)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# 训练模型
for epoch in range(num_epochs):
    for i in range(0, len(trainX), batch_size):
        inputs = trainX[i:i+batch_size]
        targets = trainY[i:i+batch_size]
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    if (epoch+1) % 10 == 0:
        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# 多步预测
model.eval()
with torch.no_grad():
    test_inputs = testX[0].unsqueeze(0)
    for i in range(len(testX)):
        output = model(test_inputs)
        test_inputs = torch.cat((test_inputs[:, look_forward:, :], output.unsqueeze(0)), dim=1)
        if i == 0:
            test_outputs = output
        else:
            test_outputs = torch.cat((test_outputs, output), dim=0)

# 可视化结果
import matplotlib.pyplot as plt
plt.plot(testY[:, -1], label='True')
plt.plot(test_outputs[:, -1], label='Predicted')
plt.legend()
plt.show()

在以上代码中，我们首先定义了一个LSTM模型，然后对数据进行了预处理，将其转换为监督学习问题。接着定义了超参数，并且准备好了训练数据和测试数据。

在训练模型时，我们使用了MSE作为损失函数，并且使用Adam优化器进行优化。最后，我们使用训练好的模型对测试数据进行了多步预测，并且将预测结果可视化出来。