@ptrblck
I am running a deep neural network which takes input as two images of size 3X160X160.I am running model.summary() and in input size i am getting 22.5 gb as input size.I also provided the code used for calculating the input size in model.summary github account also.
code used for model creation
from torchsummary import summary
import torch
import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
    """
    Base network that defines helper functions, summary and mapping to device
    """
    def conv2d(self, in_channels, out_channels, kernel_size=(3,3), dilation=1, groups=1, padding=1, bias=False, padding_mode="zeros"):
      return [nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, groups=groups, dilation=dilation, padding=padding, bias=bias, padding_mode=padding_mode)]

    def separable_conv2d(self, in_channels, out_channels, kernel_size=(3,3), dilation=1, padding=1, bias=False, padding_mode="zeros"):
      return [nn.Conv2d(in_channels=in_channels, out_channels=in_channels, kernel_size=kernel_size, groups=in_channels, dilation=dilation, padding=padding, bias=bias, padding_mode=padding_mode),
              nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(1,1), bias=bias)]

    def activate(self, l, out_channels, bn=True, dropout=0, relu=True,max_pooling=0):
      if(max_pooling>0):
        l.append(nn.MaxPool2d(2,2))
      if bn:
        l.append(nn.BatchNorm2d(out_channels))
      if dropout>0:
        l.append(nn.Dropout(dropout))
      if relu:
        l.append(nn.ReLU())

      return nn.Sequential(*l)

    def create_conv2d(self, in_channels, out_channels, kernel_size=(3,3), dilation=1, groups=1, padding=1, bias=False, bn=True, dropout=0, relu=True, padding_mode="zeros",max_pooling=0):
      return self.activate(self.conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, groups=groups, dilation=dilation, padding=padding, bias=bias, padding_mode=padding_mode), out_channels, bn, dropout, relu,max_pooling)

    def create_depthwise_conv2d(self, in_channels, out_channels, kernel_size=(3,3), dilation=1, padding=1, bias=False, bn=True, dropout=0, relu=True, padding_mode="zeros"):
      return self.activate(self.separable_conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, dilation=dilation, padding=padding, bias=bias, padding_mode=padding_mode),
                 out_channels, bn, dropout, relu)

    def __init__(self, name="Model"):
        super(Net, self).__init__()
        self.trainer = None
        self.name = name

    def summary(self, input_size,input_size1): #input_size=(1, 28, 28)
      summary(self, input_size=[input_size,input_size1])

    def gotrain(self, optimizer, train_loader, test_loader, epochs, statspath,criterion,scheduler=None, batch_scheduler=False, L1lambda=0,use_amp=True):
      self.trainer = ModelTrainer(self, optimizer, train_loader, test_loader, statspath, scheduler, batch_scheduler, L1lambda,criterion,use_amp)
      #print("hello")
      self.trainer.run(epochs)

    def stats(self):
      return self.trainer.stats if self.trainer else None

class depth_model(Net):
  def __init__(self,name="Model",dropout_value=0.0):
    super(depth_model,self).__init__(name)
    #first part of architecture of solving the mask image
    self.conv1=self.create_conv2d(3,32)
    self.conv2=self.create_conv2d(32,64)
    self.conv3=self.create_conv2d(64,128)
    self.conv4=self.create_conv2d(128,128)
    self.conv5=self.create_conv2d(128,1,(1,1),padding=0,relu=False,bn=False)
    #second part of architecture for solving the depth image 
    self.conv7=self.create_conv2d(3,32)
    self.conv8=self.create_conv2d(32,64)
    self.conv9=self.create_conv2d(64,128)
    self.conv10=self.create_conv2d(128,128)
    self.conv11=self.create_conv2d(256,256)
    self.conv12=self.create_conv2d(256,1,(1,1),padding=0,relu=False,bn=False)

  def forward(self,x1,x2):
    #first part for finding mask
    x1=self.conv1(x1)
    x1=self.conv2(x1)
    x1=self.conv3(x1)
    x1=self.conv4(x1)
    self.value=x1
    x1=self.conv5(x1) #first output for mask
    #second part for finding depth 
    x2=self.conv7(x2)
    x2=self.conv8(x2)
    x2=self.conv9(x2)    
    x2=self.conv10(x2)
    #x2=self.upsample(x2)
    #print(x.shape)
    x2=torch.cat((x2,self.value),1)
    #print(x.shape)
    x2=self.conv11(x2)
    x2=self.conv12(x2)
    return x1,x2

calling model

import torch
model = depth_model(name="depth_model") #use load_state_dict if there is a saved model
#model.load_state_dict(torch.load("/content/gdrive/My Drive/depth_model.pt"))
use_cuda = torch.cuda.is_available()
model.device = torch.device("cuda" if use_cuda else "cpu")
model.to(model.device)
model.summary((3,160,160),(3,160,160))



output of model summary

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 32, 160, 160]             864
       BatchNorm2d-2         [-1, 32, 160, 160]              64
              ReLU-3         [-1, 32, 160, 160]               0
            Conv2d-4         [-1, 64, 160, 160]          18,432
       BatchNorm2d-5         [-1, 64, 160, 160]             128
              ReLU-6         [-1, 64, 160, 160]               0
            Conv2d-7        [-1, 128, 160, 160]          73,728
       BatchNorm2d-8        [-1, 128, 160, 160]             256
              ReLU-9        [-1, 128, 160, 160]               0
           Conv2d-10        [-1, 128, 160, 160]         147,456
      BatchNorm2d-11        [-1, 128, 160, 160]             256
             ReLU-12        [-1, 128, 160, 160]               0
           Conv2d-13          [-1, 1, 160, 160]             128
           Conv2d-14         [-1, 32, 160, 160]             864
      BatchNorm2d-15         [-1, 32, 160, 160]              64
             ReLU-16         [-1, 32, 160, 160]               0
           Conv2d-17         [-1, 64, 160, 160]          18,432
      BatchNorm2d-18         [-1, 64, 160, 160]             128
             ReLU-19         [-1, 64, 160, 160]               0
           Conv2d-20        [-1, 128, 160, 160]          73,728
      BatchNorm2d-21        [-1, 128, 160, 160]             256
             ReLU-22        [-1, 128, 160, 160]               0
           Conv2d-23        [-1, 128, 160, 160]         147,456
      BatchNorm2d-24        [-1, 128, 160, 160]             256
             ReLU-25        [-1, 128, 160, 160]               0
           Conv2d-26        [-1, 256, 160, 160]         589,824
      BatchNorm2d-27        [-1, 256, 160, 160]             512
             ReLU-28        [-1, 256, 160, 160]               0
           Conv2d-29          [-1, 1, 160, 160]             256
================================================================
Total params: 1,073,088
Trainable params: 1,073,088
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 22500.00
Forward/backward pass size (MB): 562.89
Params size (MB): 4.09
Estimated Total Size (MB): 23066.98
----------------------------------------------------------------


CODE USED IN MODEL.SUMMARY() DOCUMENTATION FOR CALCULATION OF INPUT SIZE
total_input_size = abs(np.prod(sum(input_size, ()))
                           * batch_size * 4. / (1024 ** 2.))


So how do i this model get 22500 GB input size.Thank you for reading it.