

import itertools
import os
import subprocess
from os.path import dirname

from parameterized import parameterized

from tests.trainer.test_trainer import TrainerIntegrationCommon  # noqa
from transformers import is_torch_available
from transformers.testing_utils import (
    TestCasePlus,
    execute_subprocess_async,
    get_gpu_count,
    get_tests_dir,
    require_deepspeed,
    require_torch_gpu,
    slow,
)
from transformers.trainer_utils import set_seed


if is_torch_available():
       from tests.trainer.test_trainer import (  # noqa
           RegressionModelConfig,
           RegressionPreTrainedModel,
           get_regression_trainer,
       )


set_seed(42)

lowerCamelCase									= get_tests_dir('''fixtures''')
lowerCamelCase									= os.path.join(dirname(get_tests_dir()))
lowerCamelCase									= dirname(os.path.abspath(__file__))

# default torch.distributed port
lowerCamelCase									= '''10999'''

lowerCamelCase									= '''t5-small'''

# *** Working Models ***
lowerCamelCase									= '''hf-internal-testing/tiny-albert'''
lowerCamelCase									= '''sshleifer/bart-tiny-random'''
lowerCamelCase									= '''hf-internal-testing/tiny-bert'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-bigbird_pegasus'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-big_bird'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-blenderbot'''
lowerCamelCase									= '''bigscience/bigscience-small-testing'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-deberta'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-deberta-v2'''
lowerCamelCase									= '''sshleifer/tiny-distilbert-base-cased'''
lowerCamelCase									= '''hf-internal-testing/tiny-electra'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-flaubert'''
lowerCamelCase									= '''stas/tiny-wmt19-en-de'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-funnel'''
lowerCamelCase									= '''sshleifer/tiny-gpt2'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-gptj'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-gpt_neo'''
lowerCamelCase									= '''hf-internal-testing/tiny-layoutlm'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-led'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-longformer'''
lowerCamelCase									= '''stas/tiny-m2m_100'''  # hf tiny model is unsuitable
lowerCamelCase									= '''sshleifer/tiny-marian-en-de'''
lowerCamelCase									= '''sshleifer/tiny-mbart'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-mobilebert'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-mpnet'''
lowerCamelCase									= '''stas/pegasus-cnn_dailymail-tiny-random'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-prophetnet'''
lowerCamelCase									= '''sshleifer/tiny-distilroberta-base'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-squeezebert'''
lowerCamelCase									= '''patrickvonplaten/t5-tiny-random'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-t5-v1.1'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-vit'''
lowerCamelCase									= '''hf-internal-testing/tiny-xlm-roberta'''
lowerCamelCase									= '''sshleifer/tiny-xlnet-base-cased'''


# *** To Fix ***


# *** tiny model issues ***
# missing model files:
lowerCamelCase									= '''hf-internal-testing/tiny-random-mt5'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-camembert'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-openai-gpt'''

# missing tokenizer files
lowerCamelCase									= '''hf-internal-testing/tiny-random-convbert'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-layoutlmv2'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-hubert'''

# issues with tokenizer
lowerCamelCase									= '''hf-internal-testing/tiny-random-ctrl'''
lowerCamelCase									= '''hf-internal-testing/tiny-random-transfo-xl'''  # same as ctrl

# other issues with tiny models
lowerCamelCase									= '''hf-internal-testing/tiny-random-ibert'''  # multiple issues with either mlm/qa/clas
lowerCamelCase									= '''hf-internal-testing/tiny-random-reformer'''  # multiple issues with either mlm/qa/clas

# *** Lacking official examples to test with ***
# or not working with examples
lowerCamelCase									= '''hf-internal-testing/tiny-random-dpr'''
# - "dpr"  examples/research_projects/rag-end2end-retriever/
lowerCamelCase									= '''hf-internal-testing/tiny-random-rag'''
# - "rag" research_projects
lowerCamelCase									= ''''''
# - "luke" Entities classes - no plan to make such example
lowerCamelCase									= '''hf-internal-testing/tiny-random-lxmert'''
# - "lxmert" doesn't work with run_qa.py
lowerCamelCase									= '''hf-internal-testing/tiny-random-clip'''
# - "clip" nothing under pytorch examples - XXX: Suraj is working on adding some - check by end of Sep
lowerCamelCase									= '''hf-internal-testing/tiny-random-speech_to_text'''
# - "speech_to_text", nothing under pytorch examples


# *** Reactive mode ***
# models with low usage, unstable API, things about to change - do nothing about the following until someone runs into a problem
lowerCamelCase									= '''hf-internal-testing/tiny-random-tapas'''




def       UpperCAmelCase__    (      _A				:			Any=False							):





  '''simple docstring'''







  a__  =min(2     ,				get_gpu_count()							) if distributed else 1
  a__  =os.environ.get('''DS_TEST_PORT'''     ,				_A							)
  return F"""deepspeed --num_nodes 1 --num_gpus {num_gpus} --master_port {master_port}""".split()




def       UpperCAmelCase__    (      ):





  '''simple docstring'''







  a__  =F"""{FIXTURE_DIRECTORY}/tests_samples"""
  a__  =F"""{data_dir_samples}/wmt_en_ro"""
  a__  =F"""{data_dir_samples}/xsum"""
  a__  ='''
        --do_train
        --max_train_samples 4
        --per_device_train_batch_size 2
        --num_train_epochs 1
        --fp16
        --report_to none
        --overwrite_output_dir
        '''.split()

  # try to cover as many models as possible once (it's enough to run on one task per model)
  # but need a tiny model for each
  #
  # should have "{model_type.upper()}_TINY" corresponding vars defined, e.g., T5_TINY, etc.
  a__  ={
      '''trans''': [
          '''bart''',
          '''fsmt''',
          '''m2m_100''',
          '''marian''',
          '''mbart''',
          '''t5''',
          '''t5_v1''',
          # "mt5", missing model files
      ],
      '''sum''': [
          '''pegasus''',
      ],
      '''clm''': [
          '''big_bird''',
          '''bigbird_pegasus''',
          '''blenderbot''',
          '''bloom''',
          '''gpt2''',
          '''gpt_neo''',
          '''gptj''',
          '''xlm-roberta''',
          '''prophetnet''',
          # "camembert", missing model files
      ],
      '''mlm''': [
          '''albert''',
          '''deberta''',
          '''deberta-v2''',
          '''distilbert''',
          '''electra''',
          '''flaubert''',
          '''funnel''',
          '''layoutlm''',
          # "reformer", # multiple issues with either mlm/qa/clas
      ],
      '''qa''': [
          '''led''',
          '''longformer''',
          '''mobilebert''',
          '''mpnet''',
          '''roberta''',
          '''squeezebert''',
          # "convbert", # missing tokenizer files
          # "layoutlmv2", missing model files
      ],
      '''clas''': [
          '''bert''',
          '''xlnet''',
          # "hubert", # missing tokenizer files
          # "ibert", # multiple issues with either mlm/qa/clas
          # "transfo-xl", # tokenizer issues as ctrl
          # "ctrl", # tokenizer issues
          # "openai-gpt", missing model files
          # "tapas", multiple issues
      ],
      '''img_clas''': [
          '''vit''',
      ],
  }

  a__  =F"""{ROOT_DIRECTORY}/examples/pytorch"""

  a__  ={
      '''trans''': F"""
        {scripts_dir}/translation/run_translation.py
        --train_file {data_dir_wmt}/train.json
        --source_lang en
        --target_lang ro
        """,
      '''sum''': F"""
        {scripts_dir}/summarization/run_summarization.py
        --train_file {data_dir_xsum}/sample.json
        --max_source_length 12
        --max_target_length 12
        --lang en
        """,
      '''clm''': F"""
        {scripts_dir}/language-modeling/run_clm.py
        --train_file {FIXTURE_DIRECTORY}/sample_text.txt
        --block_size 8
        """,
      '''mlm''': F"""
        {scripts_dir}/language-modeling/run_mlm.py
        --train_file {FIXTURE_DIRECTORY}/sample_text.txt
        """,
      '''qa''': F"""
        {scripts_dir}/question-answering/run_qa.py
        --train_file {data_dir_samples}/SQUAD/sample.json
        """,
      '''clas''': F"""
        {scripts_dir}/text-classification/run_glue.py
        --train_file {data_dir_samples}/MRPC/train.csv
        --max_seq_length 12
        --task_name MRPC
        """,
      '''img_clas''': F"""
        {scripts_dir}/image-classification/run_image_classification.py
            --dataset_name hf-internal-testing/cats_vs_dogs_sample
            --remove_unused_columns False
            --max_steps 10
            --image_processor_name {DS_TESTS_DIRECTORY}/vit_feature_extractor.json
        """,
  }

  a__  =get_launcher(distributed=_A							)

  a__  ={}
  for task, args in tasks.items():
    a__  =args.split()
    for model in tasksamodels[task]:
      a__  =globals()[F"""{model.upper().replace("-"     ,				"_"							)}_TINY"""]
      a__  =F"""--model_name_or_path {model_name}""".split()
      a__  =launcher + args + args_model + args_main

      # # generation special case
      # if task == "gen":
      #     launcher = f"deepspeed --num_nodes 1 --num_gpus 1".split()
      #     args_model += f"--model_type {model}".split()
      #     cmds[f"{task}_{model}"] = launcher + args + args_model
      # else:

  return cmds


lowerCamelCase									= make_task_cmds()

lowerCamelCase									= '''zero2'''
lowerCamelCase									= '''zero3'''

lowerCamelCase									= [ZEROa, ZEROa]




def       UpperCAmelCase__    (      _A				:			List[str]     ,				_A				:			List[str]     ,				_A				:			List[Any]							):





  '''simple docstring'''







  a__  =parameterized.to_safe_name('''_'''.join(str(_A							) for x in param.args							)							)
  return F"""{func.__name__}_{param_based_name}"""


# Cartesian-product of zero stages with models to test
lowerCamelCase									= list(itertools.product(stages, task_cmds.keys()))







@slow
@require_deepspeed
@require_torch_gpu
class 						__magic_name__      (							lowerCamelCase__							):

   '''simple docstring'''




   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_	)							->   List[Any]:






     """simple docstring"""






     if task not in task_cmds:
       raise ValueError(F"""don't know of task {task}, have {task_cmds.keys()}"""	)

     a__  =task_cmds[task]
     a__  =F"""--deepspeed {self.test_file_dir_str}/ds_config_{stage}.json""".split()

     a__  =self.get_auto_remove_tmp_dir()
     a__  =F"""--output_dir {output_dir}""".split()

     cmd += args_ds + args_out

     return cmd, output_dir



   @parameterized.expand(lowercase_,   name_func=lowercase_	)
   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_	)							->   Dict:






     """simple docstring"""






     a__,				a__  =self.get_task_cmd(lowercase_,   lowercase_	)

     # 1. generate the checkpoint
     cmd += "--save_steps 1".split()
     # keep for quick debug
     # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] + cmd)); die
     execute_subprocess_async(lowercase_,   env=self.get_env()	)

     # 2. test that the fp32 weights get reconsolidated
     a__  =F"""{output_dir}/checkpoint-1"""
     a__  =F"""{chkpt_dir}/out.bin"""
     a__  =F"""{chkpt_dir}/zero_to_fp32.py {chkpt_dir} {recovered_model_path}"""
     # keep for quick debug
     # print(" ".join([f"\nPYTHONPATH={self.src_dir_str}"] +cmd)); die
     subprocess.check_call(lowercase_,   shell=lowercase_	)
     assert os.path.exists(lowercase_	), F"""{recovered_model_path} was not found"""

     # possibly could also test that the resulting saved model is usable but given that we use
     # random models we won't know if it's any good



from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


lowerCamelCase									= logging.get_logger(__name__)

lowerCamelCase									= {
    '''facebook/blenderbot-3B''': '''https://huggingface.co/facebook/blenderbot-3B/resolve/main/config.json''',
    # See all Blenderbot models at https://huggingface.co/models?filter=blenderbot
}







class 						__magic_name__      (							lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__			:     List[Any]    =       'blenderbot'
   lowerCamelCase__			:     int    =       ['past_key_values']
   lowerCamelCase__			:     Optional[Any]    =       {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}



   def __init__(    self,   lowercase_=8008,   lowercase_=128,   lowercase_=2,   lowercase_=10240,   lowercase_=32,   lowercase_=24,   lowercase_=10240,   lowercase_=32,   lowercase_=0.0,   lowercase_=0.0,   lowercase_=True,   lowercase_=True,   lowercase_="gelu",   lowercase_=2560,   lowercase_=0.1,   lowercase_=0.0,   lowercase_=0.0,   lowercase_=0.02,   lowercase_=1,   lowercase_=False,   lowercase_=0,   lowercase_=1,   lowercase_=2,   lowercase_=3,   lowercase_=2,   **lowercase_,   )							->   Any:






     """simple docstring"""






     a__  =vocab_size
     a__  =max_position_embeddings
     a__  =d_model
     a__  =encoder_ffn_dim
     a__  =encoder_layers
     a__  =encoder_attention_heads
     a__  =decoder_ffn_dim
     a__  =decoder_layers
     a__  =decoder_attention_heads
     a__  =dropout
     a__  =attention_dropout
     a__  =activation_dropout
     a__  =activation_function
     a__  =init_std
     a__  =encoder_layerdrop
     a__  =decoder_layerdrop
     a__  =use_cache
     a__  =encoder_layers
     a__  =scale_embedding  # scale factor will be sqrt(d_model) if True

     super().__init__(
         pad_token_id=lowercase_,   bos_token_id=lowercase_,   eos_token_id=lowercase_,   is_encoder_decoder=lowercase_,   decoder_start_token_id=lowercase_,   encoder_no_repeat_ngram_size=lowercase_,   forced_eos_token_id=lowercase_,   **lowercase_,   )







class 						__magic_name__      (							lowerCamelCase__							):

   '''simple docstring'''




   @property
   def 			_UpperCAmelCase			(    self	)							->   Mapping[str, Mapping[int, str]]:






     """simple docstring"""






     if self.task in ["default", "seq2seq-lm"]:
       a__  =OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ]	)
       if self.use_past:
         a__  ={0: '''batch'''}
         a__  ={0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
       else:
         a__  ={0: '''batch''', 1: '''decoder_sequence'''}
         a__  ={0: '''batch''', 1: '''decoder_sequence'''}
       if self.use_past:
         self.fill_with_past_key_values_(lowercase_,   direction='''inputs'''	)
     elif self.task == "causal-lm":
       a__  =OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
           ]	)
       if self.use_past:
         a__,				a__  =self.num_layers
         for i in range(lowercase_	):
           a__  ={0: '''batch''', 2: '''past_sequence + sequence'''}
           a__  ={0: '''batch''', 2: '''past_sequence + sequence'''}
     else:
       a__  =OrderedDict(
           [
               ('''input_ids''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''attention_mask''', {0: '''batch''', 1: '''encoder_sequence'''}),
               ('''decoder_input_ids''', {0: '''batch''', 1: '''decoder_sequence'''}),
               ('''decoder_attention_mask''', {0: '''batch''', 1: '''decoder_sequence'''}),
           ]	)

     return common_inputs



   @property
   # Copied from transformers.models.bart.configuration_bart.BartOnnxConfig.outputs
   def 			_UpperCAmelCase			(    self	)							->   Mapping[str, Mapping[int, str]]:






     """simple docstring"""






     if self.task in ["default", "seq2seq-lm"]:
       a__  =super().outputs
     else:
       a__  =super(lowercase_,   self	).outputs
       if self.use_past:
         a__,				a__  =self.num_layers
         for i in range(lowercase_	):
           a__  ={0: '''batch''', 2: '''past_sequence + sequence'''}
           a__  ={0: '''batch''', 2: '''past_sequence + sequence'''}
     return common_outputs



   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_ = -1,   lowercase_ = -1,   lowercase_ = False,   lowercase_ = None,   )							->   Mapping[str, Any]:






     """simple docstring"""






     a__  =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_,   lowercase_,   lowercase_,   lowercase_,   lowercase_	)
     # Generate decoder inputs
     a__  =seq_length if not self.use_past else 1
     a__  =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_,   lowercase_,   lowercase_,   lowercase_,   lowercase_	)
     a__  ={F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
     a__  =dict(**lowercase_,   **lowercase_	)

     if self.use_past:
       if not is_torch_available():
         raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''	)
       else:
         import torch
       a__,				a__  =common_inputs['''input_ids'''].shape
       a__  =common_inputs['''decoder_input_ids'''].shape[1]
       a__,				a__  =self.num_attention_heads
       a__  =(
           batch,
           num_encoder_attention_heads,
           encoder_seq_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )
       a__  =decoder_seq_length
       a__  =(
           batch,
           num_decoder_attention_heads,
           decoder_past_length,
           self._config.hidden_size // num_decoder_attention_heads,
       )
       a__  =torch.cat(
           [common_inputs['''decoder_attention_mask'''], torch.ones(lowercase_,   lowercase_	)],   dim=1	)
       a__  =[]
       a__,				a__  =self.num_layers

       for _ in range(lowercase_	):
         common_inputs["past_key_values"].append(
             (
                 torch.zeros(lowercase_	),
                 torch.zeros(lowercase_	),
                 torch.zeros(lowercase_	),
                 torch.zeros(lowercase_	),
             )	)
     return common_inputs



   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_ = -1,   lowercase_ = -1,   lowercase_ = False,   lowercase_ = None,   )							->   Mapping[str, Any]:






     """simple docstring"""






     a__  =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         lowercase_,   lowercase_,   lowercase_,   lowercase_,   lowercase_	)

     if self.use_past:
       if not is_torch_available():
         raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''	)
       else:
         import torch
       a__,				a__  =common_inputs['''input_ids'''].shape
       a__  =seqlen
       a__,				a__  =self.num_layers
       a__,				a__  =self.num_attention_heads
       a__  =(
           batch,
           num_encoder_attention_heads,
           past_key_values_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )
       a__  =common_inputs['''attention_mask'''].dtype
       a__  =torch.cat(
           [common_inputs['''attention_mask'''], torch.ones(lowercase_,   lowercase_,   dtype=lowercase_	)],   dim=1	)
       a__  =[
           (torch.zeros(lowercase_	), torch.zeros(lowercase_	)) for _ in range(lowercase_	)
       ]
     return common_inputs



   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_ = -1,   lowercase_ = -1,   lowercase_ = False,   lowercase_ = None,   )							->   Mapping[str, Any]:






     """simple docstring"""






     a__  =compute_effective_axis_dimension(
         lowercase_,   fixed_dimension=OnnxConfig.default_fixed_batch,   num_token_to_add=0	)

     # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
     a__  =tokenizer.num_special_tokens_to_add(lowercase_	)
     a__  =compute_effective_axis_dimension(
         lowercase_,   fixed_dimension=OnnxConfig.default_fixed_sequence,   num_token_to_add=lowercase_	)

     # Generate dummy inputs according to compute batch and sequence
     a__  =[''' '''.join([tokenizer.unk_token]	) * seq_length] * batch_size
     a__  =dict(tokenizer(lowercase_,   return_tensors=lowercase_	)	)
     return common_inputs



   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_ = -1,   lowercase_ = -1,   lowercase_ = False,   lowercase_ = None,   )							->   Mapping[str, Any]:






     """simple docstring"""






     if self.task in ["default", "seq2seq-lm"]:
       a__  =self._generate_dummy_inputs_for_default_and_seqaseq_lm(
           lowercase_,   batch_size=lowercase_,   seq_length=lowercase_,   is_pair=lowercase_,   framework=lowercase_	)

     elif self.task == "causal-lm":
       a__  =self._generate_dummy_inputs_for_causal_lm(
           lowercase_,   batch_size=lowercase_,   seq_length=lowercase_,   is_pair=lowercase_,   framework=lowercase_	)
     else:
       a__  =self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           lowercase_,   batch_size=lowercase_,   seq_length=lowercase_,   is_pair=lowercase_,   framework=lowercase_	)

     return common_inputs



   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_,   lowercase_,   lowercase_	)							->   Optional[int]:






     """simple docstring"""






     if self.task in ["default", "seq2seq-lm"]:
       a__  =super()._flatten_past_key_values_(lowercase_,   lowercase_,   lowercase_,   lowercase_	)
     else:
       a__  =super(lowercase_,   self	)._flatten_past_key_values_(
           lowercase_,   lowercase_,   lowercase_,   lowercase_	)



   def 			_UpperCAmelCase			(    self,   lowercase_,   lowercase_	)							->   Tuple:






     """simple docstring"""






     if direction not in ["inputs", "outputs"]:
       raise ValueError(F"""direction must either be \"inputs\" or \"outputs\", but {direction} was given"""	)

     a__  ='''past_key_values''' if direction == '''inputs''' else '''present'''
     a__,				a__  =self.num_layers

     a__  ='''past_encoder_sequence'''
     a__  ='''past_decoder_sequence''' if direction == '''inputs''' else '''past_decoder_sequence + sequence'''

     for i in range(lowercase_	):
       a__  ={0: '''batch''', 2: decoder_sequence}
       a__  ={0: '''batch''', 2: decoder_sequence}
       a__  ={0: '''batch''', 2: encoder_sequence}
       a__  ={0: '''batch''', 2: encoder_sequence}
