RuntimeError：给定输入大小：（512x1x1）。 计算出的 output 大小：(512x0x0)。 Output 尺寸太小

Question

I am working on Cardiac Ct images by implementing the 2DCNN model. I am trying to train vgg model. But every time I got this issue. I know this is related to layers as I am new in PyTorch I am not able to understand. If someone can guide me related to it

Here is the error and code. My torch.Size([2, 1, 65, 65])

Traceback (most recent call last):
  File "ct_pretrained.py", line 199, in <module>
    loss, metric = train(model, train_loader, optimizer)
  File "ct_pretrained.py", line 57, in train
    output = model(axial, sagittal, coronal, emr)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/modules/module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/data/heart_ct/torch/models/vgg.py", line 53, in forward
    sagittal_feature = self.sa_co_model(sagittal)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/modules/module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/root/miniconda/lib/python3.8/site-packages/torchvision/models/vgg.py", line 43, in forward
    x = self.features(x)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/modules/module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/modules/container.py", line 117, in forward
    input = module(input)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/modules/module.py", line 727, in _call_impl
    result = self.forward(*input, **kwargs)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/modules/pooling.py", line 153, in forward
    return F.max_pool2d(input, self.kernel_size, self.stride,
  File "/root/miniconda/lib/python3.8/site-packages/torch/_jit_internal.py", line 267, in fn
    return if_false(*args, **kwargs)
  File "/root/miniconda/lib/python3.8/site-packages/torch/nn/functional.py", line 585, in _max_pool2d
    return torch.max_pool2d(
RuntimeError: Given input size: (512x1x3). Calculated output size: (512x0x1). Output size is too small


import torch
import torch.nn as nn
from torchvision import models

__all__ = ['Vgg']

class Vgg(nn.Module):

    def __init__(self, is_emr=False, mode='sum'):
        super().__init__()
        self.is_emr = is_emr
        self.mode = mode
        in_dim = 45

        self.axial_model = models.vgg13(pretrained=True)
        out_channels = self.axial_model.features[0].out_channels
        self.axial_model.features[0] = nn.Conv2d(1, out_channels, kernel_size=7, stride=1, padding=0, bias=False)
        #self.axial_model.features[3] = nn.MaxPool2d(kernel_size=2, stride=2)
        self.axial_model.features[3] = nn.MaxPool2d(1)

        #self.axial_model.features[0] = nn.Conv2d(1, out_channels, kernel_size=3, stride =3, padding=0, bias=False)
        #self.axial_model.features[3] = nn.MaxPool2d(2)
        #self.axial_model.features[3] = nn.MaxPool2d(2, stride=3)
        #self.axial_model.features[3] = nn.Conv2d(1, out_channels, kernel_size=7, stride=1, padding=0, bias=False)

        num_ftrs = self.axial_model.classifier[6].in_features
        self.axial_model.classifier[6] = nn.Linear(num_ftrs, 15)

        self.sa_co_model = models.vgg13(pretrained=True)
        self.sa_co_model.features[0] = nn.Conv2d(1, out_channels, kernel_size=7, stride=1, padding=(3,0), bias=False)
        self.sa_co_model.features[3] = nn.MaxPool2d(1)
        #self.axial_model.features[3] = nn.MaxPool2d(kernel_size=2, stride=2)
        #self.sa_co_model.features[3] = nn.MaxPool2d(2, stride=(3,1))
        #self.sa_co_model.features[3] = nn.Conv2d(1, out_channels, kernel_size=7, stride=1, padding=(3,0), bias=False)

        self.sa_co_model.classifier[6] = nn.Linear(num_ftrs, 15)

        if self.is_emr:
            self.emr_model = EMRModel()
            if self.mode == 'concat': in_dim = 90

        self.classifier = Classifier(in_dim)

        #print(self.classifier)
  
    def forward(self, axial, sagittal, coronal, emr=None):
        #print(axial.shape)
        axial = axial[:,:,:-3,:-3]
        sagittal = sagittal[:,:,:,:-3]
        coronal = coronal[:,:,:,:-3]

        
        axial_feature = self.axial_model(axial)
        sagittal_feature = self.sa_co_model(sagittal)
        coronal_feature = self.sa_co_model(coronal)
        out = torch.cat([axial_feature, sagittal_feature, coronal_feature], dim=1)
        out = self.classifier(out)

        if self.is_emr:
            emr_feature = self.emr_model(emr)
            out += emr_feature

        return axial_feature 

class EMRModel(nn.Module):

    def __init__(self):
        super().__init__()

        self.layer = nn.Sequential(
            nn.Linear(7, 256),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(negative_slope=0.2),
            nn.Dropout(p=0.2, inplace=True),
            nn.Linear(256, 256),
            nn.BatchNorm1d(256),
            nn.LeakyReLU(negative_slope=0.2),
            nn.Dropout(p=0.2, inplace=True),
            nn.Linear(256, 5),
        )

    def forward(self, x):
        return self.layer(x)

class Classifier(nn.Module):

    def __init__(self, in_dim):
        super().__init__()

        self.layer = nn.Sequential(
            nn.Linear(in_dim, 5)
        )

    def forward(self, x):
        return self.layer(x)

class ConvBN(nn.Module):

    def __init__(self, in_dim, out_dim, **kwargs):
        super().__init__()

        self.layer = nn.Sequential(
            nn.Conv2d(in_dim, out_dim, bias=False, **kwargs),
            nn.BatchNorm2d(out_dim),
            nn.LeakyReLU(negative_slope=0.2))

    def forward(self, x):
        return self.layer(x) 

'''
if __name__ == "__main__":
     images = torch.randn(2,1,65,65)
     model = Vgg()
     out = model(images,images,images)

     model = models.vgg16(pretrained=True)
     for k, v in model.state_dict().items():
         print(k)
  '''

Answer 1

Your input image (size 65x65 pix) is too small for VGG model that usually expects input images of size 224x224 pix.