Pytorch `***运行时错误：无论何时运行模型（图像），mat1 dim 1必须与mat2 dim 0`匹配

我如何处理这个错误？我认为错误在self.fc中，但我不能说如何修复它。

self.conv（x）的输出是形状

torch.Size（[32,64,2,2]）

：

32*64*2*2=8192

（这相当于（

self.conv\u out\u Size

）。完全连接层的输入需要一个一维向量，即，在传递到正向函数中的完全连接层之前，需要将其展平

i、 e

输出

class Network():
    ...
    def foward():
    ...
        conv_out = self.conv(x)
        print(conv_out.shape)
        conv_out = conv_out.view(-1, 32*64*2*2)
        print(conv_out.shape)
        x = self.fc(conv_out)
        return x

---

编辑：

我认为您使用的是self.\u get\u conv\u功能错误

应该是

torch.Size([32, 64, 2, 2])
torch.Size([1, 8192])

然后，在向前传球时，你可以使用

    def _get_conv_out(self, shape):
        output = self.conv(torch.zeros(1, *shape)) # not (32, *size)
        return int(numpy.prod(output.size()))

---

对于

（32，1，110，110）

的输入，输出应该是

火炬大小（[32，2]）

我有同样的问题，但是我已经解决了这个问题，我使用了一批32和张量大小为[3，32，32]的图像以及我的模型上的以下配置。我正在使用带有9个CNN的ResNet并寻找4个输出

        conv_out = self.conv(x)
        # flatten the output of conv layers
        conv_out = conv_out.view(conv_out.size(0), -1)
        x = self.fc(conv_out)

---

它在展平后应该可以正常工作，输入大小是多少（我假设它是32，1，110，110）？它在google colab（torch 1.7.0）上工作，我不知道为什么它不能在你的系统上工作。好的，我现在知道了！输入形状（32，1，110，110）是你传递给模型的张量，对吗？对应于（批量大小，通道，高度，宽度）我所做的编辑可以处理任何批量大小：1）使用

（conv\u out.size（0），-1）

更改\u get\u conv\u out函数和2）展平前进函数。

        conv_out = self.conv(x)
        # flatten the output of conv layers
        conv_out = conv_out.view(conv_out.size(0), -1)
        x = self.fc(conv_out)

transform = transforms.Compose([transforms.Resize((32, 32)), transforms.ToTensor()])

def conv_block(in_channels, out_channels, pool=False):
    layers = [nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), 
              nn.BatchNorm2d(out_channels), 
              nn.ReLU(inplace=True)]
    if pool: layers.append(nn.MaxPool2d(2))
    return nn.Sequential(*layers)
class ResNet9(ImageClassificationBase):
    def __init__(self, in_channels, num_classes):
        super().__init__()
        
        self.conv1 = conv_block(in_channels, 64)
        self.conv2 = conv_block(64, 128, pool=True)
        self.res1 = nn.Sequential(conv_block(128, 128), conv_block(128, 128))
        
        self.conv3 = conv_block(128, 256, pool=True)
        self.conv4 = conv_block(256, 512, pool=True)
        self.res2 = nn.Sequential(conv_block(512, 512), conv_block(512, 512))
        
        self.classifier = nn.Sequential(nn.MaxPool2d(4), 
                                        nn.Flatten(), 
                                        nn.Dropout(0.2),
                                        nn.Linear(512, num_classes))    
    def forward(self, xb):
        out = self.conv1(xb)
        out = self.conv2(out)
        out = self.res1(out) + out
        out = self.conv3(out)
        out = self.conv4(out)
        out = self.res2(out) + out
        out = self.classifier(out)
        return out