code: def __init__(
      self,
      npoint=None,
      radii=None,
      nsample=None,
      down_conv_nn=None,
      channel_raising_nn=None,
      bn=True,
      bias=True,
      use_xyz=True,
      activation=nn.ReLU(),
      **kwargs,
  ):
      assert len(radii) == len(nsample)
      if len(radii) != len(down_conv_nn):
          log.warning(
              "The down_conv_nn has a different size as radii. Make sure of have SharedRSConv"
          )
      super(RSConvOriginalMSGDown, self).__init__(
          DenseFPSSampler(num_to_sample=npoint),
          DenseRadiusNeighbourFinder(radii, nsample),
          **kwargs,
      )
  
      self.use_xyz = use_xyz
      self.mlps = nn.ModuleList()
      self.mappings = nn.ModuleList()
  
      self._first_layer = True if len(down_conv_nn) == 2 else False
  
      if self._first_layer:
          C_in, C_intermediate, C_out = down_conv_nn[0]
          feat_in, f_out = down_conv_nn[-1]
          xyz_raising = nn.Conv2d(
              in_channels=feat_in,
              out_channels=f_out,
              kernel_size=(1, 1),
              stride=(1, 1),
              bias=bias,
          )
          nn.init.kaiming_normal_(xyz_raising.weight)
          if bias:
              nn.init.constant_(xyz_raising.bias, 0)
      else:
          C_in, C_intermediate, C_out = down_conv_nn
  
      mapping_func1 = nn.Conv2d(
          in_channels=C_in,
          out_channels=C_intermediate,
          kernel_size=(1, 1),
          stride=(1, 1),
          bias=bias,
      )
      mapping_func2 = nn.Conv2d(
          in_channels=C_intermediate,
          out_channels=C_out,
          kernel_size=(1, 1),
          stride=(1, 1),
          bias=bias,
      )
  
      nn.init.kaiming_normal_(mapping_func1.weight)
      nn.init.kaiming_normal_(mapping_func2.weight)
      if bias:
          nn.init.constant_(mapping_func1.bias, 0)
          nn.init.constant_(mapping_func2.bias, 0)
  
      # channel raising mapping
      cr_mapping = nn.Conv1d(
          in_channels=channel_raising_nn[0],
          out_channels=channel_raising_nn[1],
          kernel_size=1,
          stride=1,
          bias=bias,
      )
      nn.init.kaiming_normal_(cr_mapping.weight)
      nn.init.constant_(cr_mapping.bias, 0)
  
      if self._first_layer:
          mapping = [
              mapping_func1,
              mapping_func2,
              cr_mapping,
              xyz_raising,
          ]
      elif npoint is not None:
          mapping = [mapping_func1, mapping_func2, cr_mapping]
  
      for m in mapping:
          self.mappings.append(m)
  
      for radius in radii:
          self.mlps.append(
              OriginalRSConv(
                  mapping=mapping,
                  first_layer=self._first_layer,
                  radius=radius,
              )
          )
  
imports: import logging
  import torch
  from torch.nn import Sequential
  import torch.nn
  import torch.nn.functional
  from torch.nn import Conv1d
  import torch_points_kernels
  from torch_points3d.core.base_conv.dense import *
  from torch_points3d.core.common_modules.dense_modules import MLP2D
  from torch_points3d.core.spatial_ops import DenseFPSSampler, DenseRadiusNeighbourFinder
  from torch_points3d.utils.colors import COLORS
label_desc: Use image node_id 1 to create a new RSConvOriginalMSGDown object from inherited base classes: BaseDenseConvolutionDown with example: obj = RSConvOriginalMSGDown(npoint, radii, nsample, down_conv_nn, channel_raising_nn, bn, bias, use_xyz, activation)