code: def __init__(self, option, model_type, dataset, modules):
      BaseMS_SparseConv3d.__init__(
          self, option, model_type, dataset, modules
      )
      option_unet = option.option_unet
      self.grid_size = option_unet.grid_size
      self.unet = UnetMSparseConv3d(
          option_unet.backbone,
          input_nc=option_unet.input_nc,
          pointnet_nn=getattr(option_unet, "pointnet_nn", None),
          post_mlp_nn=getattr(option_unet, "post_mlp_nn", [64, 64, 32]),
          pre_mlp_nn=getattr(option_unet, "pre_mlp_nn", None),
          add_pos=getattr(option_unet, "add_pos", False),
          add_pre_x=getattr(option_unet, "add_pre_x", False),
          aggr=getattr(option_unet, "aggr", None),
          backend=option.backend,
      )
      assert option.mlp_cls is not None
      last_mlp_opt = option.mlp_cls
      self.FC_layer = Seq()
      for i in range(1, len(last_mlp_opt.nn)):
          self.FC_layer.append(
              Sequential(
                  *[
                      Linear(
                          last_mlp_opt.nn[i - 1],
                          last_mlp_opt.nn[i],
                          bias=False,
                      ),
                      FastBatchNorm1d(
                          last_mlp_opt.nn[i],
                          momentum=last_mlp_opt.bn_momentum,
                      ),
                      LeakyReLU(0.2),
                  ]
              )
          )
  
      # Intermediate loss
      if getattr(option, "intermediate_loss", None) is not None:
          int_loss_option = option.intermediate_loss
          (
              self.int_metric_loss,
              _,
          ) = FragmentBaseModel.get_metric_loss_and_miner(
              getattr(int_loss_option, "metric_loss", None),
              getattr(int_loss_option, "miner", None),
          )
          self.int_weights = int_loss_option.weights
          for i in range(len(int_loss_option.weights)):
              self.loss_names += ["loss_intermediate_loss_{}".format(i)]
      else:
          self.int_metric_loss = None
  
imports: import torch
  import torch.nn
  from torch.nn import LeakyReLU, Linear, Sequential
  from torch_geometric.nn.pool.consecutive import consecutive_cluster
  from torch_geometric.nn import voxel_grid
  from torch_geometric.data import Batch
  from torch_scatter import scatter_max, scatter_mean
  from torch_points3d.applications.sparseconv3d import SparseConv3d
  from torch_points3d.core.common_modules import FastBatchNorm1d, Seq
  from torch_points3d.core.common_modules import MLP
  from torch_points3d.models.registration.base import FragmentBaseModel
label_desc: Use image node_id 1 to create a new MS_SparseConv3d_Shared object from inherited base classes: BaseMS_SparseConv3d with example: obj = MS_SparseConv3d_Shared(option, model_type, dataset, modules)