How to use the ptflops.get_model_complexity_info function in ptflops

def test_resnet50_ptflops():
   net = resnet50()
   flops, params = get_model_complexity_info(net, (3, 224, 224), as_strings=True, print_per_layer_stat=True)
   print('Flops:  ' + flops)
   print('Params: ' + params)

elif parser.depth == 152:
        model = retinanet.resnet152(num_classes=dataset_train.num_classes(), pretrained=True)
    elif parser.efficientdet:
        model = efficientdet.efficientdet(num_classes=dataset_train.num_classes(), pretrained=True, phi=parser.scaling_compound)
    else:
        raise ValueError('Unsupported model depth, must be one of 18, 34, 50, 101, 152, or specify ')        

    use_gpu = True

    if use_gpu:
        model = model.cuda()
    
    model = torch.nn.DataParallel(model).cuda()
    
    if parser.print_model_complexity:
        flops, params = get_model_complexity_info(model, (3, img_size, img_size), as_strings=True, print_per_layer_stat=True)
        print('{:<30}  {:<8}'.format('Computational complexity: ', flops))
        print('{:<30}  {:<8}'.format('Number of parameters: ', params))

    model.training = True

    optimizer = optim.SGD(model.parameters(), lr=4e-5)

    scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=3, verbose=True)

    loss_hist = collections.deque(maxlen=500)
    
    model.train()
    model.module.freeze_bn()

    print('Num training images: {}'.format(len(dataset_train)))

def main():
    args = parse_args()
    with torch.no_grad():
        model = init_detector(args.config)
        model.eval()
        input_res = model.cfg.data['test']['img_scale']
        flops, params = get_model_complexity_info(model, input_res,
                                                  as_strings=True,
                                                  print_per_layer_stat=True,
                                                  input_constructor=inp_fun)
        print('Computational complexity: ' + flops)
        print('Number of parameters: ', params)

return self.layer(x)


class View(nn.Module):
    def __init__(self, *shape):
        super(View, self).__init__()
        self.shape = shape

    def forward(self, x):
        return x.view(x.shape[0], *self.shape)


if __name__ == '__main__':
    from ptflops import get_model_complexity_info
    densenet_bc = DenseNetBC(depth=100, growth_rate=12, n_classes=100, efficient=False)
    flops, params = get_model_complexity_info(densenet_bc, (3, 32, 32), as_strings=False, print_per_layer_stat=False)
    print("flops: {}, params: {}".format(flops, params))

parser.add_argument('--model', choices=list(pt_models.keys()),
                        type=str, default='resnet18')
    parser.add_argument('--result', type=str, default=None)
    args = parser.parse_args()

    if args.result is None:
        ost = sys.stdout
    else:
        ost = open(args.result, 'w')

    net = pt_models[args.model]()

    if torch.cuda.is_available():
        net.cuda(device=args.device)

    flops, params = get_model_complexity_info(net, (3, 224, 224),
                                              as_strings=True,
                                              print_per_layer_stat=True,
                                              ost=ost)
    print('{:<30}  {:<8}'.format('Computational complexity: ', flops))
    print('{:<30}  {:<8}'.format('Number of parameters: ', params))