class_docstr: Point Cloud Transformer Segmentation Model.
code: def __call__(
      self,
      inputs,
      cls_label=None,
      train: bool = False,
      debug: bool = False,
  ):
      _, num_points, _ = inputs.shape
  
      # [B, N, D]
      if self.self_attention == "standard":
          pointwise_features = PointCloudTransformerEncoder(
              in_dim=self.in_dim,
              feature_dim=self.feature_dim,
              kernel_size=self.kernel_size,
              attention_fn_configs=self.attention_fn_configs,
              use_attention_masking=self.use_attention_masking,
              use_knn_mask=self.use_knn_mask,
              nearest_neighbour_count=self.nearest_neighbour_count,
              mask_function=self.mask_function,
          )(inputs, train=train, debug=debug)
  
      # Max Pooling
      max_features = jnp.max(pointwise_features, axis=1, keepdims=True)
      max_features = jnp.repeat(
          max_features, repeats=num_points, axis=1
      )
      # Mean Pooling
      mean_features = jnp.mean(
          pointwise_features, axis=1, keepdims=True
      )
      mean_features = jnp.repeat(
          mean_features, repeats=num_points, axis=1
      )
  
      # concatenate along feature dim
      global_features = jnp.concatenate(
          [pointwise_features, max_features, mean_features], axis=-1
      )
  
      if cls_label is not None:
          # class label features
          cls_label_feature = jnp.expand_dims(cls_label, axis=1)
          cls_label_feature = nn.Conv(
              self.feature_dim // 2,
              kernel_size=(self.kernel_size, self.kernel_size),
              use_bias=True,
          )(cls_label_feature)
          cls_label_feature = nn.BatchNorm(
              use_running_average=not train
          )(cls_label_feature)
          cls_label_feature = nn.leaky_relu(
              cls_label_feature, negative_slope=0.2
          )
          cls_label_feature = jnp.repeat(
              cls_label_feature, repeats=num_points, axis=1
          )
          global_features = jnp.concatenate(
              [global_features, cls_label_feature], axis=-1
          )
  
      # LBR Block 1
      output = nn.Conv(
          4 * self.feature_dim,
          kernel_size=(self.kernel_size, self.kernel_size),
          use_bias=True,
      )(global_features)
      output = nn.BatchNorm(use_running_average=not train)(output)
      output = nn.leaky_relu(output, negative_slope=0.2)
      output = nn.Dropout(
          rate=self.dropout_rate, deterministic=not train
      )(output)
      # LBR Block 2 w/o dropout
      output = nn.Conv(
          2 * self.feature_dim,
          kernel_size=(self.kernel_size, self.kernel_size),
          use_bias=True,
      )(output)
      output = nn.BatchNorm(use_running_average=not train)(output)
      output = nn.leaky_relu(output, negative_slope=0.2)
      # Classification head
      output = nn.Dense(self.num_class, use_bias=True)(output)
      return output
  
imports: import functools
  from typing import Any, Dict, Optional, Tuple
  import flax.linen
  from flax.training import common_utils
  from immutabledict import immutabledict
  import jax.numpy
  import ml_collections
  import numpy
  from scenic.model_lib.base_models import base_model
  from scenic.model_lib.base_models import model_utils
  from scenic.model_lib.base_models.segmentation_model import SegmentationModel
  from scenic.projects.pointcloud.models import PointCloudTransformerEncoder
label_desc: Use image node_id 1 for calling the PointCloudTransformerSegmentation obj's underlying member method code with example usage: obj.__call__(inputs, cls_label, train, debug) and returns: output