我该如何解决：ValueError：预期输入 batch_size (160) 以匹配目标 batch_size (10)

Question

---

ValueError Traceback（最后一次调用） 在 () ----> 1 model = train_model(model, train_loader, optimizer, loss_func, num_epochs, device)

3 帧 /usr/local/lib/python3.10/dist-packages/torch/nn/functional.py in cross_entropy（输入、目标、权重、size_average、ignore_index、reduce、reduction、label_smoothing） 3027 如果 size_average 不是 None 或 reduce 不是 None： 3028 减少 = _Reduction.legacy_get_string(size_average, reduce) -> 3029 返回 torch._C._nn.cross_entropy_loss（输入、目标、重量、_Reduction.get_enum（减少）、ignore_index、label_smoothing） 3030 3031

我制作了 AlexNet 风格的网络来对 CIFAR-100 进行分类。 我不知道我错在哪里。

`Network`
class AlexNet(nn.Module):
def __init__(self, num_classes=100):
super(AlexNet, self).__init__()
self.layers = nn.Sequential(
nn.Conv2d(in_channels=3, out_channels=96, kernel_size=4, stride=2),      
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),                                  

    nn.Conv2d(96, 256, kernel_size=3, stride=2, padding=2),                  
    nn.ReLU(),
    nn.MaxPool2d(kernel_size=2, stride=1),                                   

    nn.Conv2d(256, 384, 2, stride=1, padding=2),                             
    nn.ReLU(),

    nn.Conv2d(384, 384, 2, stride=1, padding=2),                            
    nn.ReLU(),

    nn.Conv2d(384, 256, 2, stride=1, padding=2),                             
    nn.ReLU(),
    nn.MaxPool2d(kernel_size=2, stride=1)                                    
)

self.classifier = nn.Sequential(
    nn.Dropout(p=0.5, inplace=True),
    nn.Linear(in_features=256*3*3, out_features=4096),    
    nn.ReLU(),

    nn.Dropout(p=0.5, inplace=True),
    nn.Linear(4096,4096),
    nn.ReLU(),
    nn.Linear(4096, num_classes)
)

def init_bias_weights(self):
for layer in self.net:
if isinstance(layer, nn.Conv2d):
nn.init.normal\_(layer.weight, mean=0, std=0.01)   
nn.init.constant\_(layer.bias, 0)   
nn.init.constant\_(self.net\[4\].bias, 1)
nn.init.constant\_(self.net\[10\].bias, 1)
nn.init.constant\_(self.net\[12\].bias, 1)
def forward(self, x):
x=self.layers(x)
x=x.view(-1, 256*3*3)
x=self.classifier(x)
return

`train model`
def train_model(model, data_loader, optimizer, loss_func, num_epochs, device):
model.train()

for epoch in range(num_epochs):
train_loss = 0.0
train_corr, train_n = 0, 0

for i, (x, y) in enumerate(data_loader):
  x = x.to(device)
  y = y.to(device)
  
  optimizer.zero_grad()   
  output = model(x)
  loss = loss_func(output, y)

  loss.backward()           
  optimizer.step()          

  _, pred = torch.max(output, 1)
  train_corr += torch.sum(pred == y).item()  
  train_n += y.size(0)                       

  train_loss += loss.item()                


print('Epoch: %d | Loss: %.4f | Train Acc: %.2f%%' \
      %(epoch, train_loss / i, train_corr / train_n * 100))

return model

model = train_model(model, train_loader, optimizer, loss_func, num_epochs, device)