code: def forward(
      self,
      prev_output_tokens,
      encoder_out,
      incremental_state=None,
      features_only=False,
      **kwargs,
  ):
      x, prev_output_tokens = self.forward_embedding(
          prev_output_tokens, incremental_state
      )
  
      if not self.use_torch_layer:
          self.output_projection.weight = self.embed_tokens.para[
              : self.embed_tokens.config.vocab_size
              * self.embed_tokens.config.embedding_dim
          ].reshape(
              self.embed_tokens.config.vocab_size,
              self.embed_tokens.config.embedding_dim,
          )
          if self.quant_mode:
              self.output_projection.clip_max[
                  1
              ] = self.embed_tokens.para[-1].data
  
      # x: [batch_size, seq_len, hidden_size]
      for _, layer in enumerate(self.layers):
          if incremental_state is None:
              self_attn_mask = self.buffered_future_mask(x)
          else:
              self_attn_mask = None
  
          x, _, _ = layer(
              x,
              encoder_out=encoder_out.encoder_out,
              encoder_padding_mask=encoder_out.encoder_padding_mask,
              self_attn_mask=self_attn_mask,
              incremental_state=incremental_state,
          )
  
      if self.layer_norm is not None:
          x = self.layer_norm(x)
  
      if not features_only:
          x = self.output_projection(x)
      return x, None
  
imports: import torch
  import torch.nn
  from fairseq import utils
  from fairseq.models import FairseqEncoder, FairseqEncoderDecoderModel, FairseqIncrementalDecoder, register_model, register_model_architecture
  from fairseq.models.fairseq_encoder import EncoderOut
  from fairseq.modules import LayerNorm
  from lightseq.training.ops.pytorch.layer_base import TransformerEmbeddingLayerBase
  from lightseq.training.ops.pytorch.quantization import QuantLinear, disable_quant, enable_quant, ptq_mode, qat_mode
label_desc: Use image node_id 4 for calling the LSTransformerDecoder obj's underlying member method code with example usage: obj.forward(prev_output_tokens, encoder_out, incremental_state, features_only) and returns: x,  None