code: def KPConv(
      architecture: str = None,
      input_nc: int = None,
      num_layers: int = None,
      config: DictConfig = None,
      *args,
      **kwargs,
  ):
      """Create a KPConv backbone model based on the architecture proposed in
      https://arxiv.org/abs/1904.08889
  
      Parameters
      ----------
      architecture : str, optional
          Architecture of the model, choose from unet, encoder and decoder
      input_nc : int, optional
          Number of channels for the input
      output_nc : int, optional
          If specified, then we add a fully connected head at the end of the network to provide the requested dimension
      num_layers : int, optional
          Depth of the network
      in_grid_size : float, optional
          Size of the grid at the entry of the network. It is divided by two at each layer
      in_feat : int, optional
          Number of channels after the first convolution. Doubles at each layer
      config : DictConfig, optional
          Custom config, overrides the num_layers and architecture parameters
      """
      factory = KPConvFactory(
          architecture=architecture,
          num_layers=num_layers,
          input_nc=input_nc,
          config=config,
          **kwargs,
      )
      return factory.build()
  
imports: import os
  from omegaconf import DictConfig, OmegaConf
  import logging
  from torch_points3d.applications.modelfactory import ModelFactory
  from torch_points3d.core.common_modules import FastBatchNorm1d
  from torch_points3d.modules.KPConv import *
  from torch_points3d.core.base_conv.partial_dense import *
  from torch_points3d.models.base_architectures.unet import UnwrappedUnetBasedModel
  from torch_points3d.datasets.multiscale_data import MultiScaleBatch
  from torch_points3d.core.common_modules.base_modules import MLP
  from .utils import extract_output_nc
label_desc: Use image node_id 1 for calling a global function with example usage: KPConv(architecture, input_nc, num_layers, config) and returns: factory