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 paddleseg.cvlibs import manager
  from paddleseg import utils
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)