code: def __init__(
      self,
      use_rgb_conv=True,
      with_aux_output=False,
      norm_radius=2,
      use_disks=False,
      cpu_dist_maps=False,
      clicks_groups=None,
      with_prev_mask=False,  # True
      use_leaky_relu=False,
      binary_prev_mask=False,
      conv_extend=False,
      norm_layer=nn.BatchNorm3D,
      norm_mean_std=(
          [
              0.00040428873,
          ],
          [
              0.00059983705,
          ],
      ),
  ):  #  image.std(): [0.00053328] image.mean() [0.00023692])
      super().__init__()
  
      self.with_aux_output = with_aux_output
      self.clicks_groups = clicks_groups
      self.with_prev_mask = with_prev_mask
      self.binary_prev_mask = binary_prev_mask
      self.normalization = BatchImageNormalize3D(
          norm_mean_std[0], norm_mean_std[1]
      )
  
      self.coord_feature_ch = 2
      if clicks_groups is not None:
          self.coord_feature_ch *= len(clicks_groups)
  
      if self.with_prev_mask:
          self.coord_feature_ch += 1  # 3
  
      if use_rgb_conv:
          rgb_conv_layers = [
              nn.Conv3D(
                  in_channels=1 + self.coord_feature_ch,
                  out_channels=6 + self.coord_feature_ch,
                  kernel_size=1,
              ),
              norm_layer(6 + self.coord_feature_ch),
              nn.LeakyReLU(negative_slope=0.2)
              if use_leaky_relu
              else nn.ReLU(),
              nn.Conv3D(
                  in_channels=6 + self.coord_feature_ch,
                  out_channels=1,
                  kernel_size=1,
              ),
          ]
          self.rgb_conv = nn.Sequential(*rgb_conv_layers)
  
      elif conv_extend:
          self.rgb_conv = None
          self.maps_transform = nn.Conv3D(
              in_channels=self.coord_feature_ch,
              out_channels=64,
              kernel_size=3,
              stride=2,
              padding=1,
          )
      else:
          self.rgb_conv = None
          mt_layers = [
              nn.Conv3D(
                  in_channels=self.coord_feature_ch,
                  out_channels=16,
                  kernel_size=1,
              ),
              nn.LeakyReLU(negative_slope=0.2)
              if use_leaky_relu
              else nn.ReLU(),
              nn.Conv3D(
                  in_channels=16,
                  out_channels=16,
                  kernel_size=3,
                  stride=1,
                  padding=1,
              ),
              ScaleLayer(init_value=0.05, lr_mult=1),
          ]
          self.maps_transform = nn.Sequential(*mt_layers)
      if self.clicks_groups is not None:
          self.dist_maps = nn.LayerList()
          for click_radius in self.clicks_groups:
              self.dist_maps.append(
                  DistMaps3D(
                      norm_radius=click_radius,
                      spatial_scale=1.0,
                      cpu_mode=cpu_dist_maps,
                      use_disks=use_disks,
                  )
              )
      else:
          self.dist_maps = DistMaps3D(
              norm_radius=norm_radius,
              spatial_scale=1.0,
              cpu_mode=cpu_dist_maps,
              use_disks=use_disks,
          )
  
imports: import os
  import sys
  import paddle
  import paddle.nn
  import numpy
  from inference.ops import DistMaps3D, ScaleLayer, BatchImageNormalize3D
  from paddleseg.utils import utils
label_desc: Use image node_id 1 to create a new ISModel3D object from inherited base classes: nn with example: obj = ISModel3D(use_rgb_conv, with_aux_output, norm_radius, use_disks, cpu_dist_maps, clicks_groups, with_prev_mask, use_leaky_relu, binary_prev_mask, conv_extend, norm_layer, norm_mean_std)