我该如何解决这个问题？ 输入必须有 3 个维度，得到 4 个

Question

下面是我传递给数据加载器的数据，

train_path='/content/drive/MyDrive/Dataset_manual_pytorch/train'
test_path='/content/drive/MyDrive/Dataset_manual_pytorch/test'

train = torchvision.datasets.ImageFolder(train_path,transform=transformations)
test = torchvision.datasets.ImageFolder(test_path,transform=transformations)

train_loader = torch.utils.data.DataLoader(train, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test, batch_size =32, shuffle=True)

这是我的循环神经网络模型，

hidden_size = 256
sequence_length = 28
num_classes = 2
num_layers = 2
input_size = 32
learning_rate = 0.001
num_epochs = 3

class RNN(nn.Module):
  def __init__(self, input_size, hidden_size, num_layers, num_classes):
      super(RNN, self).__init__()
      self.hidden_size = hidden_size
      self.num_layers = num_layers

      self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first = True)
      self.fc = nn.Linear(hidden_size*sequence_length, num_classes)
  
  def forward(self, x):
    h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device)

    #Forward Prop
    out,_ = self.rnn(x, h0)
    out = out.reshape(out.shape[0], -1)
    out = self.fc(out)
    return out

model_rnn = RNN(input_size, hidden_​​size, num_layers, num_classes).to(device)

当我针对特定时期和训练数据训练这个模型时，它给了我以下错误；

RuntimeError: input must have 3 dimensions, got 4

数据的形状为： torch.Size([64, 3, 32, 32])

我认为错误是因为我正在输入 4 维数据，其中我还传递了三个通道（RGB），为了解决这个问题，我需要重塑； torch.Size([64, 3, 32, 32]) --> torch.Size([64, 32, 32])) 但我无法做到这一点。

培训代码是；

@torch.no_grad()
def Validation_phase(model, val_loader):
    model.eval()
    for data, labels in val_loader:
      out = model(data)
      val_loss = F.cross_entropy(out, labels)
      val_acc = accuracy(out, labels)

    return val_loss.detach(), val_acc

def fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):
    history = []
    optimizer = opt_func(model.parameters(), lr)
    for epoch in range(epochs):
        # Training Phase 
        model.train()
        train_losses = []
        train_accuracy = []  
        for data, labels in train_loader:
            #forward

            print(data.shape)
            out = model(data)
            #loss calculate
            train_loss = F.cross_entropy(out, labels)

            #Accuracy
            train_acc = accuracy(out, labels)

            train_accuracy.append(train_acc)
            train_losses.append(train_loss.item())

            #back_propagate
            train_loss.backward()
            optimizer.step()
            optimizer.zero_grad()
    
        train_accuracy = np.mean(torch.stack(train_accuracy).numpy())
        train_losses = np.mean(train_losses)
        

        #Validation phase
        val_losses, val_accuracy = Validation_phase(model, val_loader)

        print("Epoch [{}], train_loss: {:.4f}, train_accuracy: {:.4f}, val_loss: {:.4f}, val_acc: {:.4f}".format(
            epoch, train_losses*100 , train_accuracy*100 , val_losses.item()*100, val_accuracy.item()*100))
        # history.append(result)
    # return history

fit(5, 0.001, model_rnn, train_loader, test_loader, torch.optim.Adam) 

Answer 1

您可以按照底部代码将 torch.Size([64, 3, 32, 32]) 的大小转换为 torch.size([64, 32, 32]) ：

x = torch.ones((64, 3, 32, 32))
x = x[:, 0, :, :]

#Check code: 
print(x.size())

Answer 2

您可以采用 RGB 通道的平均值来获得具有torch.mean的单个通道上的图像表示。 您可能需要保持平均尺寸，以便能够正确地提供您的模型：您可以使用keepdim选项来做到这keepdim ：

>>> x = torch.rand(64, 3, 32, 32)
>>> z = x.mean(1, keepdim=True)
>>> z.shape
(64, 1, 32, 32)

请记住，还有其他方法可以解决此问题（RGB 到灰度转换）。