class_docstr: siamese neural network using Kernel Point
  Convolution to learn descriptors on patch(for registration).
code: def compute_loss(self):
      self.loss = 0
  
      # Get regularization on weights
      if self.lambda_reg:
          self.loss_reg = self.get_regularization_loss(
              regularizer_type="l2", lambda_reg=self.lambda_reg
          )
          self.loss += self.loss_reg
  
      # Collect internal losses and set them with self and them to self for later tracking
      if self.lambda_internal_losses:
          self.loss += self.collect_internal_losses(
              lambda_weight=self.lambda_internal_losses
          )
  
      hard_pairs = None
      if self.miner_module is not None:
          hard_pairs = self.miner_module(self.output, self.labels)
      self.loss_reg = self.metric_loss_module(
          self.output, self.labels, hard_pairs
      )
  
      self.loss += self.loss_reg
  
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 6 for calling the PatchKPConv obj's underlying member method code with example usage: obj.compute_loss() without return types