Pytorch CNN:预计输入有1个频道，但得到了60000个频道

Question

在为Fashion MNIST数据集实现NN时，我收到以下错误：

RuntimeError: Given groups=1, weight of size [6, 1, 5, 5], expected input[1, 60000, 28, 28] to have 1 channels, but got 60000 channels instead

我推断60000是我整个数据集的长度，但不确定算法为什么会出现这个错误。有人能帮我修一下吗？

我的数据集：

(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()
train_data = []
test_data = []
train_data.append([X_train, y_train])
test_data.append([X_test, y_test])
trainloader = torch.utils.data.DataLoader(train_data, shuffle=True, batch_size=100)
testloader = torch.utils.data.DataLoader(test_data, shuffle=True, batch_size=100)

我得到的错误顺序如下(根据堆栈跟踪(：

8     #making predictions
----> 9     y_pred = model(images)
32     #first hidden layer
---> 33     x = self.conv1(x)

更新1

添加行：

images = images.transpose(0, 1)

如Ivan所指出的转置图像，但现在得到错误：

RuntimeError: expected scalar type Byte but found Float

Answer 1

您的输入形状是(1, 60000, 28, 28)，而它应该是(60000, 1, 28, 28)。你可以通过转换前两个轴来解决这个问题：

>>> x.transpose(0, 1)

Answer 2

从外观上看，您使用了TensorFlow的数据集。我用过torchvison的数据集，它能很好地进行

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision.datasets import FashionMNIST
from torchvision import transforms

class Network(nn.Module):
def __init__(self):
super(Network,self).__init__()
self.conv1 = nn.Conv2d(in_channels=1,out_channels=6,kernel_size=5)
self.conv2 = nn.Conv2d(in_channels=6,out_channels=12,kernel_size=5)
self.fc1 = nn.Linear(in_features=12*4*4,out_features=120)
self.fc2 = nn.Linear(in_features=120,out_features=60)
self.fc3 = nn.Linear(in_features=60,out_features=40)
self.out = nn.Linear(in_features=40,out_features=10)
def forward(self,x):
#input layer
x = x
#first hidden layer
x = self.conv1(x)
x = F.relu(x)
x = F.max_pool2d(x,kernel_size=2,stride=2)
#second hidden layer
x = self.conv2(x)
x = F.relu(x)
x = F.max_pool2d(x,kernel_size=2,stride=2)
#third hidden layer
x = x.reshape(-1,12*4*4)
x = self.fc1(x)
x = F.relu(x)
#fourth hidden layer
x = self.fc2(x)
x = F.relu(x)
#fifth hidden layer
x = self.fc3(x)
x = F.relu(x)
#output layer
x = self.out(x)
return x

batch_size = 1000
train_dataset = FashionMNIST(
'../data', train=True, download=True, 
transform=transforms.ToTensor())
trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dataset = FashionMNIST(
'../data', train=False, download=True, 
transform=transforms.ToTensor())
testloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
model = Network()
losses = []
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())
epochs = 10
for i in range(epochs):
batch_loss = []
for j, (data, targets) in enumerate(trainloader):
optimizer.zero_grad()
ypred = model(data)
loss = criterion(ypred, targets.reshape(-1))
loss.backward()
optimizer.step()
batch_loss.append(loss.item())
if i>10: 
optimizer.lr = 0.0005
losses .append(sum(batch_loss) / len(batch_loss))
print('Epoch {}:tloss {:.4f}'.format(i, losses [-1]))