class_docstr: Tacotron2 decoder. We don't use Zoneout but Dropout between RNN layers.
  
  Args:
      in_channels (int): number of input channels.
      frame_channels (int): number of feature frame channels.
      r (int): number of outputs per time step (reduction rate).
      memory_size (int): size of the past window. if <= 0 memory_size = r
      attn_type (string): type of attention used in decoder.
      attn_win (bool): if true, define an attention window centered to maximum
          attention response. It provides more robust attention alignment especially
          at interence time.
      attn_norm (string): attention normalization function. 'sigmoid' or 'softmax'.
      prenet_type (string): 'original' or 'bn'.
      prenet_dropout (float): prenet dropout rate.
      forward_attn (bool): if true, use forward attention method. https://arxiv.org/abs/1807.06736
      trans_agent (bool): if true, use transition agent. https://arxiv.org/abs/1807.06736
      forward_attn_mask (bool): if true, mask attention values smaller than a threshold.
      location_attn (bool): if true, use location sensitive attention.
      attn_K (int): number of attention heads for GravesAttention.
      separate_stopnet (bool): if true, detach stopnet input to prevent gradient flow.
      max_decoder_steps (int): Maximum number of steps allowed for the decoder. Defaults to 10000.
docstr: Preserve decoder states for continuous inference
docstr_tok: ["Preserve","decoder","states","for","continuous","inference"]
code: def inference_truncated(self, inputs):
      """
      Preserve decoder states for continuous inference
      """
      if self.memory_truncated is None:
          self.memory_truncated = self.get_go_frame(inputs)
          self._init_states(inputs, mask=None, keep_states=False)
      else:
          self._init_states(inputs, mask=None, keep_states=True)
  
      self.attention.init_states(inputs)
      outputs, stop_tokens, alignments, t = [], [], [], 0
      while True:
          memory = self.prenet(self.memory_truncated)
          decoder_output, alignment, stop_token = self.decode(memory)
          stop_token = torch.sigmoid(stop_token.data)
          outputs += [decoder_output.squeeze(1)]
          stop_tokens += [stop_token]
          alignments += [alignment]
  
          if stop_token > 0.7:
              break
          if len(outputs) == self.max_decoder_steps:
              print("   | > Decoder stopped with 'max_decoder_steps")
              break
  
          self.memory_truncated = decoder_output
          t += 1
  
      outputs, stop_tokens, alignments = self._parse_outputs(
          outputs, stop_tokens, alignments
      )
  
      return outputs, alignments, stop_tokens
  
imports: import torch
  from torch import nn
  from torch.nn import functional
  from .attentions import init_attn
  from .common_layers import Linear, Prenet
label_desc: Use image node_id 11 for calling the Decoder obj's underlying member method code with example usage: obj.inference_truncated(inputs) and returns: outputs,  alignments,  stop_tokens