class_docstr: Linear layer with column parallelism.
  
  The linear layer is defined as Y = XA + b. A is parallelized along
  its second dimension as A = [A_1, ..., A_p].
  
  .. note::
      Input is supposed to be three dimensional and each dimension
      is expected to be sequence, batch, and hidden feature, respectively.
  
  Arguments:
      input_size: first dimension of matrix A.
      output_size: second dimension of matrix A.
      bias: If true, add bias
      gather_output: If true, call all-gether on output and make Y avaiable
                     to all GPUs, otherwise, every GPU will have its output
                     which is Y_i = XA_i
      init_method: method to initialize weights. Note that bias is always set
                   to zero.
      stride: For the strided linear layers.
      keep_master_weight_for_test: This was added for testing and should be
                                   set to False. It returns the master weights
                                   used for initialization.
      skip_bias_add: This was added to enable performance optimations where bias
                     can be fused with other elementwise operations. we skip
                     adding bias but instead return it.
  
  Keyword Arguments:
      no_async_tensor_model_parallel_allreduce:
      params_dtype:
      use_cpu_initialization:
      gradient_accumulation_fusion:
      sequence_parallel_enabled:
      accumulation_in_fp16: Deprecated
docstr: Forward of ColumnParallelLinear
  
  Args:
      input_: 3D tensor whose order of dimension is [sequence, batch, hidden]
  
  Returns:
      - output
      - bias
docstr_tok: ["Forward","of","ColumnParallelLinear","Args",":","input_",":","3D","tensor","whose","order","of","dimension","is","[","sequence",",","batch",",","hidden","]","Returns",":","-","output","-","bias"]
code: def forward(
      self, input_: torch.Tensor
  ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
      """Forward of ColumnParallelLinear
  
      Args:
          input_: 3D tensor whose order of dimension is [sequence, batch, hidden]
  
      Returns:
          - output
          - bias
      """
      bias = self.bias if not self.skip_bias_add else None
  
      if (
          self.async_tensor_model_parallel_allreduce
          or self.sequence_parallel_enabled
      ):
          input_parallel = input_
      else:
          input_parallel = copy_to_tensor_model_parallel_region(input_)
  
      # Matrix multiply.
      output_parallel = self._forward_impl(
          input=input_parallel,
          weight=self.weight,
          bias=bias,
          gradient_accumulation_fusion=self.gradient_accumulation_fusion,
          async_grad_allreduce=self.async_tensor_model_parallel_allreduce,
          sequence_parallel_enabled=self.sequence_parallel_enabled,
      )
      if self.gather_output:
          # All-gather across the partitions.
          assert not self.sequence_parallel_enabled
          output = gather_from_tensor_model_parallel_region(
              output_parallel
          )
      else:
          output = output_parallel
      output_bias = self.bias if self.skip_bias_add else None
      return output, output_bias
  
imports: from typing import Optional, Dict, Tuple, List
  import warnings
  import torch
  import torch.nn.functional
  import torch.nn.init
  from torch.nn.parameter import Parameter
  from apex._autocast_utils import _cast_if_autocast_enabled
  from apex.transformer.parallel_state import get_tensor_model_parallel_group
  from apex.transformer.parallel_state import get_tensor_model_parallel_rank
  from apex.transformer.parallel_state import get_tensor_model_parallel_world_size
  from apex.transformer.utils import divide
  from apex.transformer.tensor_parallel.mappings import copy_to_tensor_model_parallel_region
  from apex.transformer.tensor_parallel.mappings import gather_from_tensor_model_parallel_region
  from apex.transformer.tensor_parallel.mappings import reduce_from_tensor_model_parallel_region
  from apex.transformer.tensor_parallel.mappings import scatter_to_tensor_model_parallel_region
  from apex.transformer.tensor_parallel.mappings import reduce_scatter_to_sequence_parallel_region
  from apex.transformer.tensor_parallel.random import get_cuda_rng_tracker
  from apex.transformer.tensor_parallel.utils import VocabUtility
  from apex.transformer.log_util import get_transformer_logger
label_desc: Use image node_id 2 for calling the ColumnParallelLinear obj's underlying member method code with example usage: obj.forward(input_) and returns: output,  output_bias