输入和输出在 CNN 中不匹配

Question

我基于这个数据构建 CNN：https://en.wikipedia.org/wiki/CIFAR-10，它由 10 个对象类组成，总共有 60000 个 32×32 RGB 图像（50000 个训练，10000 个测试).

在构建和训练 CNN 之后我想做的是将网络中过滤器（神经元）的总数更改为过度拟合和欠拟合的程度。 并找到测试错误最低的配置，并将其用于以下部分。

这是我的代码：

`
import torch
import torchvision
import torchvision.transforms as transforms
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim`

    `
    import torch
    import torchvision
     import torchvision.transforms as transforms

      transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])


      trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
     trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
       testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)`

` 将 torch.nn 导入为 nn 将 torch.nn.functional 导入为 F

  class Net(nn.Module):
      def __init__(self):
         super(Net, self).__init__()
         self.conv1 = nn.Conv2d(3, 6, 5)
         self.pool = nn.MaxPool2d(2, 2)
         self.conv2 = nn.Conv2d(6, 16, 5)
         self.fc1 = nn.Linear(16 * 5 * 5, 120)
         self.fc2 = nn.Linear(120, 84)
         self.fc3 = nn.Linear(84, 10)

      def forward(self, x):
         x = self.pool(F.relu(self.conv1(x)))
         x = self.pool(F.relu(self.conv2(x)))
         x = x.view(-1, 16 * 5 * 5)
         x = F.relu(self.fc1(x))
         x = F.dropout(x, p=0.5)
         x = F.relu(self.fc2(x))
         x = F.dropout(x, p=0.5)
         x = self.fc3(x)
         return x
   net = Net()
   

  criterion = nn.CrossEntropyLoss()
  optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data

        # zero the parameter gradients
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('Finished Training')

import matplotlib.pyplot as plt


def train_and_evaluate(net, trainloader, testloader, optimizer, criterion, num_epochs):
    train_losses = []
    test_losses = []
    best_test_loss = float('inf')
    best_net = None
    
    for epoch in range(num_epochs):
        running_loss = 0.0
        net.train()
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data
            optimizer.zero_grad()
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
        
        train_loss = running_loss / len(trainloader)
        train_losses.append(train_loss)
        
        net.eval()
        with torch.no_grad():
            running_loss = 0.0
            for i, data in enumerate(testloader, 0):
                inputs, labels = data
                outputs = net(inputs)
                loss = criterion(outputs, labels)
                running_loss += loss.item()
        
        test_loss = running_loss / len(testloader)
        test_losses.append(test_loss)
        
        if test_loss < best_test_loss:
            best_test_loss = test_loss
            #best_net = copy.deepcopy(net)
    
    return train_losses, test_losses



   

def plot_losses(train_losses, test_losses):
    plt.plot(train_losses, label='Train')
    plt.plot(test_losses, label='Test')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    plt.show()


net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
num_epochs = 10
train_losses, test_losses = train_and_evaluate(net, trainloader, testloader, optimizer, criterion, num_epochs)
plot_losses(train_losses, test_losses)
print(f'Total number of learnable parameters: {sum(p.numel() for p in net.parameters() if p.requires_grad)}')


num_filters_list = [8, 16, 32, 64, 128, 256, 512]
best_test_loss = float('inf')
best_num_filters = None
for num_filters in num_filters_list:
    net = Net()
    net.conv1 = nn.Conv2d(3, num_filters, 5)
    net.conv2 = nn.Conv2d(num_filters, num_filters*2, 5)
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
    num_epochs = 10
    train_losses, test_losses = train_and_evaluate(net, trainloader, testloader, optimizer, criterion, num_epochs)
    plot_losses(train_losses, test_losses)
    print(f'Total number of filters: {num_filters}, Total number of learnable parameters: {sum(p.numel() for p in net.parameters() if p.requires_grad)}')
    if test_losses[-1] < best_test_loss:
        best_test_loss = test_losses[-1]
        best_num_filters = num_filters
print("Best total number of filters:")
print(best_num_filters)
print("best test loss:")
print(best_test_loss)
#print(f'Best total number of filters: {best_num_filters}, Test Loss

不幸的是我收到以下错误：

ValueError                                Traceback (most recent call last)
<ipython-input-14-cb9b92f17413> in <module>
     72     optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
     73     num_epochs = 10
---> 74     train_losses, test_losses = train_and_evaluate(net, trainloader, testloader, optimizer, criterion, num_epochs)
     75     plot_losses(train_losses, test_losses)
     76     print(f'Total number of filters: {num_filters}, Total number of learnable parameters: {sum(p.numel() for p in net.parameters() if p.requires_grad)}')

3 frames
/usr/local/lib/python3.9/dist-packages/torch/nn/functional.py in cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction, label_smoothing)
   3024     if size_average is not None or reduce is not None:
   3025         reduction = _Reduction.legacy_get_string(size_average, reduce)
-> 3026     return torch._C._nn.cross_entropy_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index, label_smoothing)
   3027 
   3028 

ValueError: Expected input batch_size (8) to match target batch_size (4)

我猜问题出在尺寸上，但我似乎不明白在哪里？以及如何解决问题（如果是尺寸问题）。谢谢