class_docstr: The ``PointCloudObjectDetector`` is a :class:`~flash.core.classification.ClassificationTask` that classifies
  pointcloud data.
  
  Args:
      num_classes: The number of classes (outputs) for this :class:`~flash.core.model.Task`.
      backbone: The backbone name (or a tuple of ``nn.Module``, output size) to use.
      backbone_kwargs: Any additional kwargs to pass to the backbone constructor.
      loss_fn: The loss function to use. If ``None``, a default will be selected by the
          :class:`~flash.core.classification.ClassificationTask` depending on the ``multi_label`` argument.
      optimizer: Optimizer to use for training.
      lr_scheduler: The LR scheduler to use during training.
      metrics: Any metrics to use with this :class:`~flash.core.model.Task`. If ``None``, a default will be selected
          by the :class:`~flash.core.classification.ClassificationTask` depending on the ``multi_label`` argument.
      learning_rate: The learning rate for the optimizer.
      lambda_loss_cls: The value to scale the loss classification.
      lambda_loss_bbox: The value to scale the bounding boxes loss.
      lambda_loss_dir: The value to scale the bounding boxes direction loss.
code: def __init__(
      self,
      num_classes: int,
      backbone: Union[
          str, Tuple[nn.Module, int]
      ] = "pointpillars_kitti",
      backbone_kwargs: Optional[Dict] = None,
      loss_fn: LOSS_FN_TYPE = None,
      optimizer: OPTIMIZER_TYPE = "Adam",
      lr_scheduler: LR_SCHEDULER_TYPE = None,
      metrics: METRICS_TYPE = None,
      learning_rate: Optional[float] = None,
      lambda_loss_cls: float = 1.0,
      lambda_loss_bbox: float = 1.0,
      lambda_loss_dir: float = 1.0,
  ):
      super().__init__(
          model=None,
          loss_fn=loss_fn,
          optimizer=optimizer,
          lr_scheduler=lr_scheduler,
          metrics=metrics,
          learning_rate=learning_rate,
      )
  
      self.save_hyperparameters()
  
      if backbone_kwargs is None:
          backbone_kwargs = {}
  
      if isinstance(backbone, tuple):
          self.backbone, out_features = backbone
      else:
          self.model, out_features, collate_fn = self.backbones.get(
              backbone
          )(**backbone_kwargs)
          self.collate_fn = wrap_collate(collate_fn)
          self.backbone = self.model.backbone
          self.neck = self.model.neck
          self.loss_fn = get_callable_dict(self.model.loss)
  
      if __FILE_EXAMPLE__ not in sys.argv[0]:
          self.model.bbox_head.conv_cls = self.head = nn.Conv2d(
              out_features,
              num_classes,
              kernel_size=(1, 1),
              stride=(1, 1),
          )
  
imports: import sys
  from typing import Any, Dict, Optional, Tuple, Union
  from torch import Tensor, nn
  from torch.utils.data import DataLoader, Sampler
  import flash
  from flash.core.data.io.input import DataKeys, InputBase
  from flash.core.data.io.input_transform import InputTransform
  from flash.core.data.utilities.collate import wrap_collate
  from flash.core.model import Task
  from flash.core.registry import FlashRegistry
  from flash.core.utilities.apply_func import get_callable_dict
  from flash.core.utilities.stability import beta
  from flash.core.utilities.types import LOSS_FN_TYPE, LR_SCHEDULER_TYPE, METRICS_TYPE, OPTIMIZER_TYPE
  from flash.pointcloud.detection.backbones import POINTCLOUD_OBJECT_DETECTION_BACKBONES
label_desc: Use image node_id 1 to create a new PointCloudObjectDetector object from inherited base classes: Task with example: obj = PointCloudObjectDetector(num_classes, backbone, backbone_kwargs, loss_fn, optimizer, lr_scheduler, metrics, learning_rate, lambda_loss_cls, lambda_loss_bbox, lambda_loss_dir)