docstr: Forward pass of the network
  self.data:
      x -- Features [B, C, N]
      pos -- Features [B, N, 3]
docstr_tok: ["Forward","pass","of","the","network","self.data",":","x","--","Features","[","B",",","C",",","N","]","pos","--","Features","[","B",",","N",",","3","]"]
code: def forward(self, *args, **kwargs):
      r"""
      Forward pass of the network
      self.data:
          x -- Features [B, C, N]
          pos -- Features [B, N, 3]
      """
      stack_down = []
      queue_up = queue.Queue()
  
      data = self.input
      stack_down.append(data)
  
      for i in range(len(self.down_modules) - 1):
          data = self.down_modules[i](data)
          stack_down.append(data)
  
      data = self.down_modules[-1](data)
      queue_up.put(data)
  
      assert (
          len(self.inner_modules) == 2
      ), "For this segmentation model, we except 2 distinct inner"
      data_inner = self.inner_modules[0](data)
      data_inner_2 = self.inner_modules[1](stack_down[3])
  
      for i in range(len(self.up_modules) - 1):
          data = self.up_modules[i]((queue_up.get(), stack_down.pop()))
          queue_up.put(data)
  
      last_feature = torch.cat(
          [
              data.x,
              data_inner.x.repeat(1, 1, data.x.shape[-1]),
              data_inner_2.x.repeat(1, 1, data.x.shape[-1]),
          ],
          dim=1,
      )
  
      if self._use_category:
          cat_one_hot = (
              F.one_hot(self.category, self._num_categories)
              .float()
              .transpose(1, 2)
          )
          last_feature = torch.cat((last_feature, cat_one_hot), dim=1)
  
      self.output = (
          self.FC_layer(last_feature)
          .transpose(1, 2)
          .contiguous()
          .view((-1, self._num_classes))
      )
  
      # Compute loss
      if self._weight_classes is not None:
          self._weight_classes = self._weight_classes.to(
              self.output.device
          )
      if self.labels is not None:
          self.loss_seg = F.cross_entropy(
              self.output,
              self.labels,
              weight=self._weight_classes,
              ignore_index=IGNORE_LABEL,
          )
  
      self.data_visual = self.input
      self.data_visual.y = torch.reshape(
          self.labels, data.pos.shape[0:2]
      )
      self.data_visual.pred = torch.max(self.output, -1)[1].reshape(
          data.pos.shape[0:2]
      )
  
      return self.output
  
file_path: torch-points3d/torch_points3d/models/segmentation/rsconv.py
imports: import logging
  import copy
  import queue
  import torch
  import torch.nn.functional
  from torch_points3d.datasets.segmentation import IGNORE_LABEL
  from torch_points3d.models.base_architectures import UnwrappedUnetBasedModel
  from torch_points3d.modules.RSConv import *
  from torch_points3d.core.common_modules.dense_modules import Conv1D
  from torch_points3d.core.common_modules.base_modules import Seq
  from .base import Segmentation_MP
label_desc: Use image node_id 3 for calling the RSConvLogicModel obj's underlying member method code with example usage: obj.forward() and returns: self