LSTM 中的分类返回相同的分类值

Question

这是我第一次在堆栈溢出中发帖，如果我犯了任何错误，请原谅我。

我有 10000 个数据，每个数据都有一个 0 和 1 的标签。我想使用 LSTM 进行分类，因为这是时间序列数据。

input_dim = 1
hidden_dim = 32
num_layers = 2
output_dim = 1


# Here we define our model as a class
class LSTM(nn.Module):
  def __init__(self, input_dim, hidden_dim, num_layers, output_dim):
    super(LSTM, self).__init__()
    self.hidden_dim = hidden_dim
    self.num_layers = num_layers
    self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)
    self.fc = nn.Linear(hidden_dim, output_dim)

  def forward(self, x):
    #Initialize hidden layer and cell state
    h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()
    c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_()

    # We need to detach as we are doing truncated backpropagation through time (BPTT)
    # If we don't, we'll backprop all the way to the start even after going through another batch
    out, (hn, cn) = self.lstm(x, (h0.detach(), c0.detach()))


    # Index hidden state of last time step
    # out.size() --> 100, 32, 100
    # out[:, -1, :] --> 100, 100 --> just want last time step hidden states! 
    out = self.fc(out[:, -1, :])

    # For binomial Classification
    m = torch.sigmoid(out)

    return m

model = LSTM(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim, num_layers=num_layers)
loss = nn.BCELoss()

optimiser = torch.optim.Adam(model.parameters(), lr=0.00001, weight_decay=0.00006)

num_epochs = 100

# Number of steps to unroll
seq_dim =look_back-1  

for t in range(num_epochs):
    y_train_class = model(x_train)

    output = loss(y_train_class, y_train)

    # Zero out gradient, else they will accumulate between epochs
    optimiser.zero_grad(set_to_none=True)

    # Backward pass
    output.backward()

    # Update parameters
    optimiser.step()

This is an example of what the result looks like

此代码最初来自kaggle，我对其进行了编辑以进行分类。请问，你能告诉我我做错了什么吗？

编辑 1： 添加数据加载器 从 torch.utils.data 导入 DataLoader 从 torch.utils.data 导入 TensorDataset

x_train = torch.from_numpy(x_train).type(torch.Tensor)
y_train = torch.from_numpy(y_train).type(torch.Tensor)
x_test = torch.from_numpy(x_test).type(torch.Tensor)
y_test = torch.from_numpy(y_test).type(torch.Tensor)

train_dataloader = DataLoader(TensorDataset(x_train, y_train), batch_size=128, shuffle=True)
test_dataloader = DataLoader(TensorDataset(x_test, y_test), batch_size=128, shuffle=True)

我意识到在检查结果之前我忘记了逆转换。当我这样做时，我从分类中得到了不同的值，但是所有值都在 0.001-0.009 的范围内，所以当我对它们进行四舍五入时，结果是相同的。所有分类的标签为 0。

Answer 1

NN 训练中的一个常见现象是，它们最初会收敛到一个非常幼稚的解决方案来解决问题，在这种解决方案中，它们会输出一个恒定的预测，从而最大限度地减少训练数据上的误差。我的猜测是，在您的训练数据中，0 和1 类之间的比率接近0.5423。根据您的模型是否足够复杂，当给定更多学习步骤时，它可能会根据输入学习做出更具体的预测。

虽然增加 epoch 的数量可能会有所帮助，但您可以使用当前设置做一些更好的事情。目前，您每个 epoch 只执行一个优化器步骤。通常，您需要每批次一个步骤，并以（小）批次（例如 32 个输入）循环您的数据。为此，最好使用DataLoader，您可以在其中定义批量大小，并在您的纪元循环内循环数据加载器，类似于this example。