code: def fuse_conv_bn(
      wrapper, fused_modules, params_dict, *args, **kwargs
  ):
      q_param_dict = {
          k: v.target
          for k, v in wrapper.quantization_target_spaces.items()
          if v.type is TargetType.PARAMETER
      }
      params_dict = params_dict.copy()
      bn_module = fused_modules[1]
      conv_module = wrapper.module
  
      assert (
          bn_module.num_features == conv_module.out_channels
      ), "The output channel of Conv must match num_features of BatchNorm"
  
      if "weight" not in q_param_dict:
          raise ValueError(
              f"In the fusion process of conv_bn, the weight of {wrapper.name} needs to be quantized"
          )
  
      with torch.no_grad():
          # compute bias
          bias: Union[torch.Tensor, None] = get_bias(
              wrapper, params_dict
          )
          output = conv_forward(
              *args,
              **kwargs,
              conv_module=conv_module,
              weight=q_param_dict["weight"],
              bias=bias,
          )
          # statistics mean and var when track_running_stats = False
          if not bn_module.track_running_stats:
              sta_output = output.detach().clone()
              sta_output = torch.transpose(sta_output, 0, 1)
              sta_output = sta_output.contiguous().view(
                  conv_module.out_channels, -1
              )
              mean = sta_output.mean(1).detach()
              var = sta_output.var(1).detach()
              bn_rm = mean
              bn_var = var
          # if track == True
          else:
              _ = bn_module._nni_wrapper.module_forward(output)
              bn_rm = bn_module.running_mean
              bn_var = bn_module.running_var
  
      bn_eps = bn_module.eps
      # case: affine
      bn_w = (
          bn_module.weight
          if bn_module.affine
          else torch.ones_like(bn_rm)
      )
      bn_b = (
          bn_module.bias
          if bn_module.affine
          else torch.zeros_like(bn_rm)
      )
      # conv weight and bias
      conv_weight = q_param_dict["weight"]
      conv_bias = get_bias(wrapper, params_dict)
      if conv_bias is None:
          conv_bias = torch.zeros_like(bn_rm)
      # fuse weight and bias
      shape = [-1, 1] + [1] * (len(conv_weight.shape) - 2)
      bn_var_rsqrt = torch.rsqrt(bn_var + bn_eps)
      fused_conv_w = conv_weight * (bn_w * bn_var_rsqrt).reshape(shape)
      fused_conv_b = (conv_bias - bn_rm) * bn_var_rsqrt * bn_w + bn_b
      params_dict["weight"] = fused_conv_w
      params_dict["bias"] = set_bias(wrapper, fused_conv_b)
  
      return params_dict, []
  
imports: from typing import Dict, Union, Tuple, Callable, Optional
  from collections.abc import Iterable
  from itertools import repeat
  import torch
  import torch.nn
  import torch.nn.functional
  from torch import Tensor
  from .target_space import TargetType
label_desc: Use image node_id 8 for calling a global function with example usage: fuse_conv_bn(wrapper, fused_modules, params_dict) and returns: params_dict,  list