code: def _fuse_bn_tensor(self, branch, kernel_size=3):
      if branch is None:
          return 0, 0
  
      if isinstance(branch, nn.LayerList):
          fused_kernels = []
          fused_bias = []
          for block in branch:
              kernel = block.conv.weight
              running_mean = block.norm._mean
              running_var = block.norm._variance
              gamma = block.norm.weight
              beta = block.norm.bias
              eps = block.norm._epsilon
  
              std = (running_var + eps).sqrt()
              t = (gamma / std).reshape((-1, 1, 1, 1))
  
              fused_kernels.append(kernel * t)
              fused_bias.append(beta - running_mean * gamma / std)
  
          return sum(fused_kernels), sum(fused_bias)
  
      elif isinstance(branch, ConvNormLayer):
          kernel = branch.conv.weight
          running_mean = branch.norm._mean
          running_var = branch.norm._variance
          gamma = branch.norm.weight
          beta = branch.norm.bias
          eps = branch.norm._epsilon
      else:
          assert isinstance(branch, nn.BatchNorm2D)
          input_dim = self.ch_in if kernel_size == 1 else 1
          kernel_value = paddle.zeros(
              shape=[self.ch_in, input_dim, kernel_size, kernel_size],
              dtype="float32",
          )
          if kernel_size > 1:
              for i in range(self.ch_in):
                  kernel_value[
                      i,
                      i % input_dim,
                      (kernel_size - 1) // 2,
                      (kernel_size - 1) // 2,
                  ] = 1
          elif kernel_size == 1:
              for i in range(self.ch_in):
                  kernel_value[i, i % input_dim, 0, 0] = 1
          else:
              raise ValueError("Invalid kernel size recieved!")
          kernel = paddle.to_tensor(
              kernel_value, place=branch.weight.place
          )
          running_mean = branch._mean
          running_var = branch._variance
          gamma = branch.weight
          beta = branch.bias
          eps = branch._epsilon
  
      std = (running_var + eps).sqrt()
      t = (gamma / std).reshape((-1, 1, 1, 1))
  
      return kernel * t, beta - running_mean * gamma / std
  
file_path: PaddleDetection/ppdet/modeling/backbones/mobileone.py
imports: import paddle
  import paddle.nn
  from paddle import ParamAttr
  from paddle.regularizer import L2Decay
  from paddle.nn.initializer import Normal, Constant
  from ppdet.modeling.ops import get_act_fn
  from ppdet.modeling.layers import ConvNormLayer
label_desc: Use image node_id 6 for calling the MobileOneBlock obj's underlying member method code with example usage: obj._fuse_bn_tensor(branch, kernel_size) and returns: unknown,  unknown, int,  int, sum,  sum