class_docstr: PointNet2 with multi-scale grouping
  descriptors network for registration that uses feature propogation layers
  
  Parameters
  ----------
  num_classes: int
      Number of semantics classes to predict over -- size of softmax classifier that run for each point
  input_channels: int = 6
      Number of input channels in the feature descriptor for each point.  If the point cloud is Nx9, this
      value should be 6 as in an Nx9 point cloud, 3 of the channels are xyz, and 6 are feature descriptors
  use_xyz: bool = True
      Whether or not to use the xyz position of a point as a feature
code: def __init__(self, option, model_type, dataset, modules):
      # call the initialization method of UnetBasedModel
      UnetBasedModel.__init__(
          self, option, model_type, dataset, modules
      )
      # Last MLP
      self.mode = option.loss_mode
      self.normalize_feature = option.get("normalize_feature", False)
      self.out_channels = option.get("out_channels")
      self.loss_names = ["loss_reg", "loss"]
      (
          self.metric_loss_module,
          self.miner_module,
      ) = UnetBasedModel.get_metric_loss_and_miner(
          getattr(option, "metric_loss", None),
          getattr(option, "miner", None),
      )
      last_mlp_opt = option.mlp_cls
  
      self.FC_layer = Seq()
      last_mlp_opt.nn[0]
      for i in range(1, len(last_mlp_opt.nn)):
          self.FC_layer.append(
              Conv1D(
                  last_mlp_opt.nn[i - 1],
                  last_mlp_opt.nn[i],
                  bn=True,
                  bias=False,
              )
          )
      if last_mlp_opt.dropout:
          self.FC_layer.append(torch.nn.Dropout(p=last_mlp_opt.dropout))
  
      self.FC_layer.append(
          Conv1D(
              last_mlp_opt.nn[-1],
              self.out_channels,
              activation=None,
              bias=True,
              bn=False,
          )
      )
  
imports: import torch
  import torch.nn.functional
  from torch.nn import Linear
  from torch.nn import Sequential
  from torch_geometric.data import Data
  import logging
  from torch_points3d.core.losses import *
  from torch_points3d.modules.pointnet2 import *
  from torch_points3d.core.common_modules import MLP
  from torch_points3d.models.base_architectures import BackboneBasedModel
  from torch_points3d.models.base_architectures import UnetBasedModel
  from torch_points3d.core.common_modules.dense_modules import Conv1D
  from torch_points3d.core.common_modules.base_modules import Seq
  from torch_points3d.models.registration.base import FragmentBaseModel
label_desc: Use image node_id 1 to create a new FragmentPointNet2_D object from inherited base classes: UnetBasedModel, FragmentBaseModel with example: obj = FragmentPointNet2_D(option, model_type, dataset, modules)