code: def __init__(
      self,
      ch_in,
      ch_out,
      filter_size,
      stride=1,
      groups=1,
      norm_type=None,
      norm_groups=32,
      norm_decay=0.0,
      freeze_norm=False,
      act=None,
  ):
      super(ConvNormLayer, self).__init__()
      self.act = act
      norm_lr = 0.0 if freeze_norm else 1.0
      if norm_type is not None:
          assert norm_type in [
              "bn",
              "sync_bn",
              "gn",
          ], "norm_type should be one of ['bn', 'sync_bn', 'gn'], but got {}".format(
              norm_type
          )
          param_attr = ParamAttr(
              initializer=Constant(1.0),
              learning_rate=norm_lr,
              regularizer=L2Decay(norm_decay),
          )
          bias_attr = ParamAttr(
              learning_rate=norm_lr, regularizer=L2Decay(norm_decay)
          )
          global_stats = True if freeze_norm else None
          if norm_type in ["bn", "sync_bn"]:
              self.norm = nn.BatchNorm2D(
                  ch_out,
                  weight_attr=param_attr,
                  bias_attr=bias_attr,
                  use_global_stats=global_stats,
              )
          elif norm_type == "gn":
              self.norm = nn.GroupNorm(
                  num_groups=norm_groups,
                  num_channels=ch_out,
                  weight_attr=param_attr,
                  bias_attr=bias_attr,
              )
          norm_params = self.norm.parameters()
          if freeze_norm:
              for param in norm_params:
                  param.stop_gradient = True
          conv_bias_attr = False
      else:
          conv_bias_attr = True
          self.norm = None
  
      self.conv = nn.Conv2D(
          in_channels=ch_in,
          out_channels=ch_out,
          kernel_size=filter_size,
          stride=stride,
          padding=(filter_size - 1) // 2,
          groups=groups,
          weight_attr=ParamAttr(
              initializer=Normal(mean=0.0, std=0.001)
          ),
          bias_attr=conv_bias_attr,
      )
  
imports: import paddle
  import paddle.nn
  import paddle.nn.functional
  from numbers import Integral
  from paddle import ParamAttr
  from paddle.regularizer import L2Decay
  from paddle.nn.initializer import Normal, Constant
  from ppdet.core.workspace import register
  from ppdet.modeling.shape_spec import ShapeSpec
  from ppdet.modeling.ops import channel_shuffle
  from ..None import layers
label_desc: Use image node_id 1 to create a new ConvNormLayer object from inherited base classes: nn with example: obj = ConvNormLayer(ch_in, ch_out, filter_size, stride, groups, norm_type, norm_groups, norm_decay, freeze_norm, act)