code: def __init__(
      self,
      in_channels=3,
      out_channels=32,
      bn_momentum=0.01,
      normalize_feature=True,
      conv1_kernel_size=5,
      D=3,
  ):
      ME.MinkowskiNetwork.__init__(self, D)
      NORM_TYPE = self.NORM_TYPE
      BLOCK_NORM_TYPE = self.BLOCK_NORM_TYPE
      CHANNELS = self.CHANNELS
      TR_CHANNELS = self.TR_CHANNELS
      # print(D, in_channels, out_channels, conv1_kernel_size)
      self.normalize_feature = normalize_feature
      self.conv1 = ME.MinkowskiConvolution(
          in_channels=in_channels,
          out_channels=CHANNELS[1],
          kernel_size=conv1_kernel_size,
          stride=1,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm1 = get_norm(
          NORM_TYPE, CHANNELS[1], bn_momentum=bn_momentum, D=D
      )
  
      self.block1 = get_block(
          BLOCK_NORM_TYPE,
          CHANNELS[1],
          CHANNELS[1],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv2 = ME.MinkowskiConvolution(
          in_channels=CHANNELS[1],
          out_channels=CHANNELS[2],
          kernel_size=3,
          stride=2,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm2 = get_norm(
          NORM_TYPE, CHANNELS[2], bn_momentum=bn_momentum, D=D
      )
  
      self.block2 = get_block(
          BLOCK_NORM_TYPE,
          CHANNELS[2],
          CHANNELS[2],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv3 = ME.MinkowskiConvolution(
          in_channels=CHANNELS[2],
          out_channels=CHANNELS[3],
          kernel_size=3,
          stride=2,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm3 = get_norm(
          NORM_TYPE, CHANNELS[3], bn_momentum=bn_momentum, D=D
      )
  
      self.block3 = get_block(
          BLOCK_NORM_TYPE,
          CHANNELS[3],
          CHANNELS[3],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv4 = ME.MinkowskiConvolution(
          in_channels=CHANNELS[3],
          out_channels=CHANNELS[4],
          kernel_size=3,
          stride=2,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm4 = get_norm(
          NORM_TYPE, CHANNELS[4], bn_momentum=bn_momentum, D=D
      )
  
      self.block4 = get_block(
          BLOCK_NORM_TYPE,
          CHANNELS[4],
          CHANNELS[4],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv4_tr = ME.MinkowskiConvolutionTranspose(
          in_channels=CHANNELS[4],
          out_channels=TR_CHANNELS[4],
          kernel_size=3,
          stride=2,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm4_tr = get_norm(
          NORM_TYPE, TR_CHANNELS[4], bn_momentum=bn_momentum, D=D
      )
  
      self.block4_tr = get_block(
          BLOCK_NORM_TYPE,
          TR_CHANNELS[4],
          TR_CHANNELS[4],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv3_tr = ME.MinkowskiConvolutionTranspose(
          in_channels=CHANNELS[3] + TR_CHANNELS[4],
          out_channels=TR_CHANNELS[3],
          kernel_size=3,
          stride=2,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm3_tr = get_norm(
          NORM_TYPE, TR_CHANNELS[3], bn_momentum=bn_momentum, D=D
      )
  
      self.block3_tr = get_block(
          BLOCK_NORM_TYPE,
          TR_CHANNELS[3],
          TR_CHANNELS[3],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv2_tr = ME.MinkowskiConvolutionTranspose(
          in_channels=CHANNELS[2] + TR_CHANNELS[3],
          out_channels=TR_CHANNELS[2],
          kernel_size=3,
          stride=2,
          dilation=1,
          bias=False,
          dimension=D,
      )
      self.norm2_tr = get_norm(
          NORM_TYPE, TR_CHANNELS[2], bn_momentum=bn_momentum, D=D
      )
  
      self.block2_tr = get_block(
          BLOCK_NORM_TYPE,
          TR_CHANNELS[2],
          TR_CHANNELS[2],
          bn_momentum=bn_momentum,
          D=D,
      )
  
      self.conv1_tr = ME.MinkowskiConvolution(
          in_channels=CHANNELS[1] + TR_CHANNELS[2],
          out_channels=TR_CHANNELS[1],
          kernel_size=1,
          stride=1,
          dilation=1,
          bias=False,
          dimension=D,
      )
  
      # self.block1_tr = BasicBlockBN(TR_CHANNELS[1], TR_CHANNELS[1], bn_momentum=bn_momentum, D=D)
  
      self.final = ME.MinkowskiConvolution(
          in_channels=TR_CHANNELS[1],
          out_channels=out_channels,
          kernel_size=1,
          stride=1,
          dilation=1,
          bias=True,
          dimension=D,
      )
  
imports: import torch
  import MinkowskiEngine
  import MinkowskiEngine.MinkowskiFunctional
  from .common import get_norm
  from .res16unet import get_block
  from .common import NormType
label_desc: Use image node_id 1 to create a new ResUNet2 object from inherited base classes: ME with example: obj = ResUNet2(in_channels, out_channels, bn_momentum, normalize_feature, conv1_kernel_size, D)