如何用奇数示例大小批量训练神经网络？

Question

我是神经网络领域的新手，我正在使用 pytorch 进行一些训练。
我决定做一个简单的普通神经网络。
我使用了一个包含 2377 个数字特征和 6277 个示例的个人数据集。

我的第一次尝试是让神经网络预测每个示例，因此伪代码如下所示

for i in range(...):
    X = ... # features
    y = ... # outcome
    y_pred = model(X[i])
    loss = criterion(y_pred, y)

    y_pred.size # [1,1]
    y.size # [1,1]

每个 epoch 大约需要 10 秒，我决定使用小批量来改进它。

所以我在开始时定义了批量大小，Pytorch 中的神经网络是这样定义的

batch_size = 30
n_inputs = X.size[1] #2377

## 2 hidden layers
model = nn.Sequential(
    nn.Linear(n_inputs, 1024),
    nn.ReLU(),
    nn.Linear(1024, 512),
    nn.ReLU(),
    nn.Linear(512, 356),
    nn.ReLU(),
    nn.Linear(356, batch_size),
    nn.ReLU(),
)

然后我分批进行训练

for epoch in range(5):
    totalloss = 0  
    permutation = torch.randperm(X.size()[0])
    for i in range(0, X.size()[0], batch_size):
        optimizer.zero_grad()
        indices = permutation[i:i+batch_size]
        batch_x, batch_y = x[indices], y[indices]

        ypred = model(batch_x)
        loss = criterion(ypred, batch_y) 
        totalloss += loss.item()
        
        ## update the weights
        loss.backward()
        optimizer.step()

现在的问题是我的神经网络总是输出 100 个值但是最后的批量大小可能会有所不同。
事实上，如果我选择 100 作为批量大小，最后一批将由 77 个示例组成 (6277%100)。

我确信有办法解决这个问题，并且我的结构中有错误，但我看不到它。

你能帮助我概括批量训练以处理任意数量的示例和批量大小吗？

Answer 1

我建议您使用 Pytorch

DataLoader

来批量加载数据，而不是手动执行。在这方面，PyTorch 使用

drop_last

中的

DataLoader

参数为此提供了一个简单的解决方案。当设置为 True 时，它会删除最后一个不完整的批次，确保除最后一个批次之外的所有批次都具有指定的大小。

Dataloader

是火炬

Dataset

的包装，你可以在这里找到更多信息

import torch
import torch.nn as nn
from torch.utils.data import DataLoader

X = torch.Tensor(...)  # your features
y = torch.Tensor(...)  # your labels

dataset = 

# Create a DataLoader with drop_last=True
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, drop_last=True)

model = ...

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.MSELoss()

# Training loop
num_epochs = 5
for epoch in range(num_epochs):
    total_loss = 0
    for batch_x, batch_y in dataloader:
        optimizer.zero_grad()
        y_pred = model(batch_x)
        loss = criterion(y_pred, batch_y)
        total_loss += loss.item()
        loss.backward()
        optimizer.step()

    average_loss = total_loss / len(dataloader)
    print(f'Epoch {epoch + 1}/{num_epochs}, Average Loss: {average_loss}')