class_docstr: This class will call the encoders from all the models in the ensemble.
  It will process the encoder output to prepare input for each decoder step
  input
code: def forward(
      self,
      src_tokens: Tensor,
      src_lengths: Tensor,
      dict_feat: Optional[Tuple[Tensor, Tensor, Tensor]] = None,
      contextual_token_embedding: Optional[Tensor] = None,
  ) -> List[Dict[str, Tensor]]:
      # (seq_length, batch_size) for compatibility with Caffe2
      src_tokens_seq_first = src_tokens.t()
  
      # Model level parallelism cannot be implemented because of lack of
      # support for future type. https://github.com/pytorch/pytorch/issues/26578
      futures = torch.jit.annotate(List[Dict[str, Tensor]], [])
  
      for model in self.models:
          embedding_input = [[src_tokens_seq_first]]
          if dict_feat is not None:
              embedding_input.append(list(dict_feat))
          if contextual_token_embedding is not None:
              embedding_input.append([contextual_token_embedding])
          embeddings = model.source_embeddings(embedding_input)
          futures.append(
              # torch.jit._fork(model.encoder, src_tokens_seq_first, src_lengths)
              model.encoder(
                  src_tokens_seq_first, embeddings, src_lengths
              )
          )
      return self.prepare_decoderstep_ip(futures)
  
file_path: pytext/pytext/torchscript/seq2seq/encoder.py
imports: from typing import Dict, List, Optional, Tuple
  import torch
  import torch.jit
  import torch.jit.quantized
  from torch import nn, Tensor
label_desc: Use image node_id 2 for calling the EncoderEnsemble obj's underlying member method code with example usage: obj.forward(src_tokens, src_lengths, dict_feat, contextual_token_embedding) and returns: self