Multivariate time series classification pytorch lstm

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from sklearn.model_selection import train_test_split

# 生成示例数据
np.random.seed(0)
n = 1000  # 样本数量
seq_len = 10  # 时间序列长度
n_features = 3  # 特征数量
n_classes = 2  # 类别数量

data = np.random.randn(n, seq_len, n_features)  # 生成随机时间序列数据
labels = np.random.randint(0, n_classes, size=n)  # 生成随机类别标签

print('data:', data)
print('data shape:', data.shape)
print('labels:', labels)

# 划分训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(data, labels, test_size=0.2, random_state=42)
print('y_train0:', y_train)
print('y_test0:', y_test)
# 转换为PyTorch张量
x_train, x_test = torch.from_numpy(x_train).float(), torch.from_numpy(x_test).float()
y_train, y_test = torch.from_numpy(y_train), torch.from_numpy(y_test)
print('x_train:', x_train)
print('shape:', x_train.shape)

print('y_train:', y_train)
print('y_test:', y_test)

# 将目标标签的数据类型转换为Long
y_train = y_train.long()
y_test = y_test.long()


# 定义LSTM模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super(LSTMModel, 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, num_classes)

    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(x.device)
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out


# 实例化模型
input_size = n_features
hidden_size = 64
num_layers = 2
num_classes = n_classes
model = LSTMModel(input_size, hidden_size, num_layers, num_classes)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    outputs = model(x_train)
    loss = criterion(outputs, y_train)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

# 模型评估
with torch.no_grad():
    outputs = model(x_test)
    print('outputs:', outputs)
    _, predicted = torch.max(outputs, 1)
    print('y_test:', y_test)
    print('predicted:', predicted)
    print('_:', _)
    accuracy = (predicted == y_test).sum().item() / y_test.size(0)
    print(f'Accuracy on test set: {100 * accuracy:.2f}%')