class_docstr: Conv-BN fusion implemented with explicit folding. Useful
  to verify numerical equivalency with non-folded version.
class_docstr_tok: ["Conv-BN","fusion","implemented","with","explicit","folding",".","Useful","to","verify","numerical","equivalency","with","non-folded","version","."]
code: def __init__(
      self,
      # ConvNd args
      in_channels,
      out_channels,
      kernel_size,
      stride,
      padding,
      dilation,
      transposed,
      output_padding,
      groups,
      bias,
      padding_mode,
      # BatchNormNd args
      # num_features: out_channels
      eps=1e-05,
      momentum=0.1,
      # affine: True
      # track_running_stats: True
      # Args for this module
      freeze_bn=False,
      qconfig=None,
  ):
      nn.modules.conv._ConvNd.__init__(
          self,
          in_channels,
          out_channels,
          kernel_size,
          stride,
          padding,
          dilation,
          transposed,
          output_padding,
          groups,
          False,
          padding_mode,
      )
      assert qconfig, "qconfig must be provided for QAT module"
      self.qconfig = qconfig
      self.eps = eps
      self.momentum = momentum
      self.freeze_bn = freeze_bn if self.training else True
      self.num_features = out_channels
      self.gamma = nn.Parameter(torch.empty(out_channels))
      self.beta = nn.Parameter(torch.empty(out_channels))
      self.affine = True
      self.track_running_stats = True
      self.register_buffer("running_mean", torch.zeros(out_channels))
      self.register_buffer("running_var", torch.ones(out_channels))
      self.register_buffer(
          "num_batches_tracked", torch.tensor(0, dtype=torch.long)
      )
      self.activation_post_process = self.qconfig.activation()
      self.weight_fake_quant = self.qconfig.weight()
      if bias:
          self.bias = nn.Parameter(torch.empty(out_channels))
      else:
          self.register_parameter("bias", None)
      self.reset_bn_parameters()
  
imports: import copy
  import math
  import torch
  import torch.nn
  import torch.backends.mkldnn
  from torch.nn import Conv2d, BatchNorm2d, ReLU, init
  from torch.ao.nn.intrinsic.qat import ConvBn2d, ConvBnReLU2d
  from torch.nn.modules.utils import _pair
  import torch.ao.nn.quantized
  import torch.ao.nn.quantized.dynamic
  import torch.ao.nn.qat
  import torch.ao.nn.intrinsic.qat
  import torch.ao.nn.qat.dynamic
  from torch.ao.quantization import prepare, convert, prepare_qat, quantize_qat, QuantStub, DeQuantStub, default_qconfig, default_qat_qconfig, default_embedding_qat_qconfig, default_symmetric_qnnpack_qat_qconfig, get_default_qat_qconfig, FixedQParamsFakeQuantize, FusedMovingAvgObsFakeQuantize, get_embedding_qat_module_mappings, get_embedding_static_quant_module_mappings, NoopObserver
  from torch.ao.quantization.qconfig import qconfig_equals
  from torch.testing._internal.common_quantization import DeFusedEmbeddingBagLinear, QuantizationTestCase, QuantStubModel, ManualLinearQATModel, ManualDropoutQATModel, ManualLinearDynamicQATModel, ManualConvLinearQATModel, ManualConvLinearSymmQATModel, ManualEmbeddingBagLinear, TwoLayerLinearModel, test_only_eval_fn, test_only_train_fn
  from torch.testing._internal.common_quantized import override_quantized_engine, supported_qengines, override_qengines
  from torch.testing._internal.common_utils import skipIfNoXNNPACK
  from hypothesis import given
  from hypothesis import strategies
  import torch.testing._internal.hypothesis_utils
  from functools import reduce
label_desc: Use image node_id 1 to create a new _ReferenceConvBnNd object from inherited base classes: torch.nn, torch.nn.modules.conv with example: obj = _ReferenceConvBnNd(in_channels, out_channels, kernel_size, stride, padding, dilation, transposed, output_padding, groups, bias, padding_mode, eps, momentum, freeze_bn, qconfig)