code: def measure_layer(layer, x):
      global count_ops, count_params
      delta_ops = 0
      delta_params = 0
      multi_add = 1
      type_name = get_layer_info(layer)
  
      # ops_conv
      if type_name in ["Conv2d"]:
          out_h = int(
              (
                  x.size()[2]
                  + 2 * layer.padding[0]
                  - layer.kernel_size[0]
              )
              / layer.stride[0]
              + 1
          )
          out_w = int(
              (
                  x.size()[3]
                  + 2 * layer.padding[1]
                  - layer.kernel_size[1]
              )
              / layer.stride[1]
              + 1
          )
          delta_ops = (
              layer.in_channels
              * layer.out_channels
              * layer.kernel_size[0]
              * layer.kernel_size[1]
              * out_h
              * out_w
              / layer.groups
              * multi_add
          )
          delta_params = get_layer_param(layer)
  
      # ops_nonlinearity
      elif type_name in ["ReLU"]:
          delta_ops = x.numel() / x.size(0)
          delta_params = get_layer_param(layer)
  
      # ops_pooling
      elif type_name in ["AvgPool2d"]:
          in_w = x.size()[2]
          kernel_ops = layer.kernel_size * layer.kernel_size
          out_w = int(
              (in_w + 2 * layer.padding - layer.kernel_size)
              / layer.stride
              + 1
          )
          out_h = int(
              (in_w + 2 * layer.padding - layer.kernel_size)
              / layer.stride
              + 1
          )
          delta_ops = x.size()[1] * out_w * out_h * kernel_ops
          delta_params = get_layer_param(layer)
  
      elif type_name in ["AdaptiveAvgPool2d"]:
          delta_ops = x.size()[1] * x.size()[2] * x.size()[3]
          delta_params = get_layer_param(layer)
  
      # ops_linear
      elif type_name in ["Linear"]:
          weight_ops = layer.weight.numel() * multi_add
          bias_ops = layer.bias.numel()
          delta_ops = weight_ops + bias_ops
          delta_params = get_layer_param(layer)
  
      # ops_nothing
      elif type_name in [
          "BatchNorm2d",
          "Dropout2d",
          "DropChannel",
          "Dropout",
      ]:
          delta_params = get_layer_param(layer)
  
      # unknown layer type
      else:
          delta_params = get_layer_param(layer)
  
      count_ops += delta_ops
      count_params += delta_params
  
      return
  
imports: import torch
label_desc: Use image node_id 5 for calling a global function with example usage: measure_layer(layer, x) without return types