code: def __init__(
      self,
      feat_in,
      feat_mid,
      feat_out,
      kernel_sizes=[],
      strides=[],
      dilations=[],
      has_biases=[],
      kernel_generators=[],
      kernel_size=3,
      stride=1,
      dilation=1,
      bias=False,
      kernel_generator=None,
      norm_layer=ME.MinkowskiBatchNorm,
      activation=ME.MinkowskiReLU,
      bn_momentum=0.1,
      dimension=-1,
      **kwargs,
  ):
      super(BaseResBlock, self).__init__()
      assert dimension > 0
  
      modules = []
  
      convolutions_dim = [
          [feat_in, feat_mid],
          [feat_mid, feat_mid],
          [feat_mid, feat_out],
      ]
  
      kernel_sizes = self.create_arguments_list(
          kernel_sizes, kernel_size
      )
      strides = self.create_arguments_list(strides, stride)
      dilations = self.create_arguments_list(dilations, dilation)
      has_biases = self.create_arguments_list(has_biases, bias)
      kernel_generators = self.create_arguments_list(
          kernel_generators, kernel_generator
      )
  
      for (
          conv_dim,
          kernel_size,
          stride,
          dilation,
          has_bias,
          kernel_generator,
      ) in zip(
          convolutions_dim,
          kernel_sizes,
          strides,
          dilations,
          has_biases,
          kernel_generators,
      ):
          modules.append(
              ME.MinkowskiConvolution(
                  conv_dim[0],
                  conv_dim[1],
                  kernel_size=kernel_size,
                  stride=stride,
                  dilation=dilation,
                  bias=has_bias,
                  kernel_generator=kernel_generator,
                  dimension=dimension,
              )
          )
  
          if norm_layer:
              modules.append(
                  norm_layer(conv_dim[1], momentum=bn_momentum)
              )
  
          if activation:
              modules.append(activation(inplace=True))
  
      self.conv = nn.Sequential(*modules)
  
imports: import torch.nn
  import MinkowskiEngine
  from .common import ConvType, NormType
  from torch_points3d.utils.config import is_list
label_desc: Use image node_id 1 to create a new BaseResBlock object from inherited base classes: nn with example: obj = BaseResBlock(feat_in, feat_mid, feat_out, kernel_sizes, strides, dilations, has_biases, kernel_generators, kernel_size, stride, dilation, bias, kernel_generator, norm_layer, activation, bn_momentum, dimension)