code: def __init__(self, option, model_type, dataset, modules):
      # Extract parameters from the dataset
      # Assemble encoder / decoder
      UnwrappedUnetBasedModel.__init__(
          self, option, model_type, dataset, modules
      )
  
      # Build final MLP
      last_mlp_opt = option.mlp_cls
  
      self.out_channels = option.out_channels
      in_feat = last_mlp_opt.nn[0]
      self.FC_layer = Seq()
      for i in range(1, len(last_mlp_opt.nn)):
          self.FC_layer.add_module(
              str(i),
              Seq(
                  *[
                      Lin(in_feat, last_mlp_opt.nn[i], bias=False),
                      FastBatchNorm1d(
                          last_mlp_opt.nn[i],
                          momentum=last_mlp_opt.bn_momentum,
                      ),
                      LeakyReLU(0.2),
                  ]
              ),
          )
          in_feat = last_mlp_opt.nn[i]
  
      if last_mlp_opt.dropout:
          self.FC_layer.add_module(
              "Dropout", Dropout(p=last_mlp_opt.dropout)
          )
  
      self.FC_layer.add_module(
          "Last", Lin(in_feat, self.out_channels, bias=False)
      )
      self.mode = option.loss_mode
      self.normalize_feature = option.normalize_feature
      self.loss_names = ["loss_reg", "loss"]
  
      self.lambda_reg = self.get_from_opt(
          option, ["loss_weights", "lambda_reg"]
      )
      if self.lambda_reg:
          self.loss_names += ["loss_regul"]
  
      self.lambda_internal_losses = self.get_from_opt(
          option, ["loss_weights", "lambda_internal_losses"]
      )
  
      self.visual_names = ["data_visual"]
  
imports: from typing import Any
  import torch
  import torch.nn.functional
  from torch.nn import Linear
  from torch.nn import Sequential
  from torch_geometric.data import Data
  from torch_geometric.nn import global_mean_pool
  import logging
  from torch_points3d.core.losses import *
  from torch_points3d.core.common_modules import MLP
  from torch_points3d.core.common_modules import FastBatchNorm1d
  from torch_points3d.core.base_conv.partial_dense import *
  from torch_points3d.models.registration.base import FragmentBaseModel
  from torch_points3d.models.base_architectures import BackboneBasedModel
  from torch_points3d.models.registration.base import create_batch_siamese
  from torch_points3d.models.base_model import BaseModel
  from torch_points3d.models.base_architectures.unet import UnwrappedUnetBasedModel
  from torch_points3d.modules.KPConv import *
  from torch_points3d.datasets.registration.pair import PairMultiScaleBatch
label_desc: Use image node_id 1 to create a new FragmentKPConv object from inherited base classes: FragmentBaseModel, UnwrappedUnetBasedModel with example: obj = FragmentKPConv(option, model_type, dataset, modules)