class_docstr: A transformer decoder block consists of an autoregressive attention block, encoder attention,
  and a feed-forward layer with pre/post process blocks in between.
code: def forward(
      self,
      target: pt.Tensor,
      target_mask: Optional[pt.Tensor],
      source: pt.Tensor,
      source_mask: Optional[pt.Tensor],
      autoregr_states: Optional[pt.Tensor],
      enc_att_kv: Optional[pt.Tensor] = None,
  ) -> Tuple[pt.Tensor, pt.Tensor]:
      target_autoregr, *new_autoregr_states = self.autoregr_layer(
          inputs=self.pre_autoregr_layer(target),
          previous_states=autoregr_states,
          mask=target_mask,
      )
  
      target = self.post_autoregr_layer(target_autoregr, target)
  
      # encoder attention
      target_enc_att = self.enc_attention(
          queries=self.pre_enc_attention(target),
          key_values=source,
          mask=source_mask,
          projected_memory_kv=enc_att_kv,
      )
  
      target = self.post_enc_attention(target_enc_att, target)
  
      # feed-forward
      target_ff = self.ff(self.pre_ff(target))
      target = self.post_ff(target_ff, target)
  
      if self.lhuc:
          target = self.lhuc(target)
  
      return target, new_autoregr_states
  
imports: from dataclasses import dataclass
  from typing import Optional, Tuple
  import torch
  import sockeye.layers
  from sockeye import constants
  from .None import config
label_desc: Use image node_id 6 for calling the TransformerDecoderBlock obj's underlying member method code with example usage: obj.forward(target, target_mask, source, source_mask, autoregr_states, enc_att_kv) and returns: target,  new_autoregr_states