code: def __init__(self, option, model_type, dataset, modules):
      super(VoteNet2, self).__init__(option)
      self._dataset = dataset
      self._weight_classes = dataset.weight_classes
  
      # 1 - CREATE BACKBONE MODEL
      input_nc = dataset.feature_dimension
      backbone_option = option.backbone
      backbone_cls = getattr(models, backbone_option.model_type)
      backbone_extr_options = backbone_option.get("extra_options", {})
      self.backbone_model = backbone_cls(
          architecture="unet",
          input_nc=input_nc,
          num_layers=4,
          config=backbone_option.get("config"),
          **backbone_extr_options,
      )
      self._kpconv_backbone = backbone_cls.__name__ == "KPConv"
      self.is_dense_format = self.conv_type == "DENSE"
      dropout = option.get("dropout", None)
      if dropout is not None:
          self.dropout = torch.nn.Dropout(dropout)
      else:
          self.dropout = None
  
      # 2 - SEGMENTATION HEAD
      semantic_supervision = option.get("semantic_supervision", False)
      if semantic_supervision:
          self.Semantic = (
              Seq()
              .append(
                  MLP(
                      [
                          self.backbone_model.output_nc,
                          self.backbone_model.output_nc,
                      ],
                      bias=False,
                  )
              )
              .append(
                  torch.nn.Linear(
                      self.backbone_model.output_nc, dataset.num_classes
                  )
              )
              .append(torch.nn.LogSoftmax())
          )
      else:
          self.Semantic = None
  
      # 3 - CREATE VOTING MODEL
      voting_option = option.voting
      self._num_seeds = voting_option.num_points_to_sample
      voting_cls = getattr(votenet_module, voting_option.module_name)
      self.voting_module = voting_cls(
          vote_factor=voting_option.vote_factor,
          seed_feature_dim=self.backbone_model.output_nc,
      )
  
      # 4 - CREATE PROPOSAL MODULE
      proposal_option = option.proposal
      proposal_option.vote_aggregation.down_conv_nn = [
          [
              self.backbone_model.output_nc + 3,
              self.backbone_model.output_nc,
              self.backbone_model.output_nc,
          ]
      ]
      proposal_cls = getattr(
          votenet_module, proposal_option.module_name
      )
      self.proposal_cls_module = proposal_cls(
          num_class=proposal_option.num_class,
          vote_aggregation_config=proposal_option.vote_aggregation,
          num_heading_bin=proposal_option.num_heading_bin,
          mean_size_arr=dataset.mean_size_arr,
          num_proposal=proposal_option.num_proposal,
          sampling=proposal_option.sampling,
      )
  
      # Loss params
      self.loss_params = option.loss_params
      self.loss_params.num_heading_bin = proposal_option.num_heading_bin
      self.loss_params.mean_size_arr = dataset.mean_size_arr.tolist()
  
      self.losses_has_been_added = False
      self.loss_names = []
  
imports: import torch
  from torch_geometric.data import Data
  import os
  from torch_points3d.datasets.object_detection.box_data import BoxData
  from torch_points3d.datasets.segmentation import IGNORE_LABEL
  from torch_points3d.models.base_model import BaseModel
  from torch_points3d.applications import models
  import torch_points3d.modules.VoteNet
  from torch_points3d.core.common_modules import Seq, MLP, FastBatchNorm1d
  from torch_points3d.core.data_transform import AddOnes
  from torch_points3d.modules.VoteNet.dense_samplers import RandomSamplerToDense, FPSSamplerToDense
label_desc: Use image node_id 1 to create a new VoteNet2 object from inherited base classes: BaseModel with example: obj = VoteNet2(option, model_type, dataset, modules)