如何在pytorch中处理LSTM模型中的多标签分类

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# 定义自定义的LSTM模型
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_labels):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.lstm = nn.LSTM(input_size, hidden_size)
        self.fc = nn.Linear(hidden_size, num_labels)
        self.sigmoid = nn.Sigmoid()

    def forward(self, input):
        output, _ = self.lstm(input)
        output = self.fc(output[:, -1, :])
        output = self.sigmoid(output)
        return output

# 定义自定义的数据集
class CustomDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        return self.data[index], self.labels[index]

# 准备数据
input_size = 10
hidden_size = 20
num_labels = 5

data = torch.randn(100, 20, input_size)
labels = torch.randint(0, 2, (100, num_labels))

dataset = CustomDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)

# 定义模型、损失函数和优化器
model = LSTMModel(input_size, hidden_size, num_labels)
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
for epoch in range(10):
    for inputs, targets in dataloader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets.float())
        loss.backward()
        optimizer.step()

# 模型评估
with torch.no_grad():
    val_data = torch.randn(20, 20, input_size)
    val_labels = torch.randint(0, 2, (20, num_labels))
    val_outputs = model(val_data)
    val_predictions = (val_outputs > 0.5).float()
    accuracy = (val_predictions == val_labels).float().mean()

print("Validation Accuracy:", accuracy.item())