

"""simple docstring"""






import json
import os
from typing import List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


lowerCamelCase__			:					Optional[Any]							  =					logging.get_logger(__name__)

lowerCamelCase__			:					List[Any]							  =					{
    '''vocab_file''': '''vocab.json''',
    '''merges_file''': '''merges.txt''',
}

lowerCamelCase__			:					List[str]							  =					{
    '''vocab_file''': {
        '''microsoft/biogpt''': '''https://huggingface.co/microsoft/biogpt/resolve/main/vocab.json''',
    },
    '''merges_file''': {'''microsoft/biogpt''': '''https://huggingface.co/microsoft/biogpt/resolve/main/merges.txt'''},
}

lowerCamelCase__			:					List[str]							  =					{
    '''microsoft/biogpt''': 10_24,
}
def  UpperCamelCase   (     _lowerCAmelCase       :  Any	)			->     Union[str, Any]:
	_UpperCAmelCase      :							Tuple       =   set()
	_UpperCAmelCase      :							List[str]       =   word[0]
	for char in word[1:]:
		pairs.add((prev_char, char)	)
		_UpperCAmelCase      :							List[str]       =   char
	return pairs






class       _UpperCAmelCase     (						__a):
			__a	:    Tuple			   =							VOCAB_FILES_NAMES
			__a	:    int			   =							PRETRAINED_VOCAB_FILES_MAP
			__a	:    Any			   =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__a	:    Any			   =							["""input_ids""", """attention_mask"""]
			def __init__(						self ,						_A ,						_A ,						_A="<unk>" ,						_A="<s>" ,						_A="</s>" ,						_A="</s>" ,						_A="<pad>" ,						**_A ,						)      ->      Tuple:






				'''simple docstring'''







				super().__init__(
				    bos_token=_A ,						eos_token=_A ,						sep_token=_A ,						unk_token=_A ,						pad_token=_A ,						**_A ,						)

				try:
					import sacremoses
				except ImportError:
					raise ImportError(
					    """You need to install sacremoses to use BioGptTokenizer. """
					    """See https://pypi.org/project/sacremoses/ for installation."""       )

				_UpperCAmelCase      :							Dict       =   """en"""
				_UpperCAmelCase      :							Any       =   sacremoses
				# cache of sm.MosesTokenizer instance
				_UpperCAmelCase      :							List[Any]       =   {}
				_UpperCAmelCase      :							Tuple       =   {}
				with open(_A ,						encoding="""utf-8"""       ) as vocab_handle:
					_UpperCAmelCase      :							List[str]       =   json.load(_A       )
				_UpperCAmelCase      :							Optional[Any]       =   {v: k for k, v in self.encoder.items()}
				with open(_A ,						encoding="""utf-8"""       ) as merges_handle:
					_UpperCAmelCase      :							Any       =   merges_handle.read().split("""\n"""       )[:-1]
				_UpperCAmelCase      :							int       =   [tuple(merge.split()[:2]       ) for merge in merges]
				_UpperCAmelCase      :							Optional[int]       =   dict(zip(_A ,						range(len(_A       )       )       )       )
				_UpperCAmelCase      :							Optional[Any]       =   {}
			@property
			def 							__snake_case	(						self       )      ->      List[Any]:






				'''simple docstring'''







				return len(self.encoder       )
			def 							__snake_case	(						self       )      ->      int:






				'''simple docstring'''







				return dict(self.encoder ,						**self.added_tokens_encoder       )
			def 							__snake_case	(						self ,						_A ,						_A       )      ->      str:






				'''simple docstring'''







				if lang not in self.cache_moses_tokenizer:
					_UpperCAmelCase      :							Dict       =   self.sm.MosesTokenizer(lang=_A       )
					_UpperCAmelCase      :							Optional[int]       =   moses_tokenizer
				return self.cache_moses_tokenizer[lang].tokenize(
				    _A ,						aggressive_dash_splits=_A ,						return_str=_A ,						escape=_A       )
			def 							__snake_case	(						self ,						_A ,						_A       )      ->      Dict:






				'''simple docstring'''







				if lang not in self.cache_moses_detokenizer:
					_UpperCAmelCase      :							Dict       =   self.sm.MosesDetokenizer(lang=_A       )
					_UpperCAmelCase      :							Optional[int]       =   moses_detokenizer
				return self.cache_moses_detokenizer[lang].detokenize(_A       )
			def 							__snake_case	(						self ,						_A       )      ->      List[Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							List[Any]       =   tuple(token[:-1]       ) + (token[-1] + """</w>""",)
				if token in self.cache:
					return self.cache[token]
				_UpperCAmelCase      :							Union[str, Any]       =   get_pairs(_A       )

				if not pairs:
					return token + "</w>"

				while True:
					_UpperCAmelCase      :							Optional[Any]       =   min(_A ,						key=lambda _A       : self.bpe_ranks.get(_A ,						float("""inf"""       )       )       )
					if bigram not in self.bpe_ranks:
						break
					_UpperCAmelCase  ,				_UpperCAmelCase      :							Optional[int]       =   bigram
					_UpperCAmelCase      :							str       =   []
					_UpperCAmelCase      :							List[Any]       =   0
					while i < len(_A       ):
						try:
							_UpperCAmelCase      :							int       =   word.index(_A ,						_A       )
						except ValueError:
							new_word.extend(word[i:]       )
							break
						else:
							new_word.extend(word[i:j]       )
							_UpperCAmelCase      :							Optional[Any]       =   j

						if word[i] == first and i < len(_A       ) - 1 and word[i + 1] == second:
							new_word.append(first + second       )
							i += 2
						else:
							new_word.append(word[i]       )
							i += 1
					_UpperCAmelCase      :							int       =   tuple(_A       )
					_UpperCAmelCase      :							str       =   new_word
					if len(_A       ) == 1:
						break
					else:
						_UpperCAmelCase      :							List[str]       =   get_pairs(_A       )
				_UpperCAmelCase      :							int       =   """ """.join(_A       )
				if word == "\n  </w>":
					_UpperCAmelCase      :							Optional[int]       =   """\n</w>"""
				_UpperCAmelCase      :							str       =   word
				return word
			def 							__snake_case	(						self ,						_A ,						_A=False       )      ->      Union[str, Any]:






				'''simple docstring'''







				if bypass_tokenizer:
					_UpperCAmelCase      :							int       =   text.split()
				else:
					_UpperCAmelCase      :							int       =   self.moses_tokenize(_A ,						self.lang       )

				_UpperCAmelCase      :							str       =   []
				for token in text:
					if token:
						split_tokens.extend(list(self.bpe(_A       ).split(""" """       )       )       )

				return split_tokens
			def 							__snake_case	(						self ,						_A       )      ->      Dict:






				'''simple docstring'''







				return self.encoder.get(_A ,						self.encoder.get(self.unk_token       )       )
			def 							__snake_case	(						self ,						_A       )      ->      str:






				'''simple docstring'''







				return self.decoder.get(_A ,						self.unk_token       )
			def 							__snake_case	(						self ,						_A       )      ->      Optional[int]:






				'''simple docstring'''







				_UpperCAmelCase      :							Tuple       =   [t.replace(""" """ ,						""""""       ).replace("""</w>""" ,						""" """       ) for t in tokens]
				_UpperCAmelCase      :							Any       =   """""".join(_A       ).split()
				# detokenize
				_UpperCAmelCase      :							Optional[int]       =   self.moses_detokenize(_A ,						self.lang       )
				return text
			def 							__snake_case	(						self ,						_A ,						_A = None       )      ->      List[int]:






				'''simple docstring'''







				if token_ids_a is None:
					return [self.sep_token_id] + token_ids_a
				_UpperCAmelCase      :							int       =   [self.sep_token_id]
				return sep + token_ids_a + sep + token_ids_a
			def 							__snake_case	(						self ,						_A ,						_A = None ,						_A = False       )      ->      List[int]:






				'''simple docstring'''







				if already_has_special_tokens:
					return super().get_special_tokens_mask(
					    token_ids_a=_A ,						token_ids_a=_A ,						already_has_special_tokens=_A       )
				# no bos used in fairseq
				if token_ids_a is not None:
					return [1] + ([0] * len(_A       )) + [1] + ([0] * len(_A       ))
				return [1] + ([0] * len(_A       ))
			def 							__snake_case	(						self ,						_A ,						_A = None       )      ->      List[int]:






				'''simple docstring'''







				_UpperCAmelCase      :							Union[str, Any]       =   [self.sep_token_id]

				# no bos used in fairseq
				if token_ids_a is None:
					return len(token_ids_a + sep       ) * [0]
				return len(token_ids_a + sep       ) * [0] + len(token_ids_a + sep       ) * [1]
			def 							__snake_case	(						self ,						_A ,						_A = None       )      ->      Tuple[str]:






				'''simple docstring'''







				if not os.path.isdir(_A       ):
					logger.error(f'''Vocabulary path ({save_directory}) should be a directory'''       )
					return
				_UpperCAmelCase      :							Any       =   os.path.join(
				    _A ,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]       )
				_UpperCAmelCase      :							Dict       =   os.path.join(
				    _A ,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]       )

				with open(_A ,						"""w""" ,						encoding="""utf-8"""       ) as f:
					f.write(json.dumps(self.encoder ,						indent=2 ,						sort_keys=_A ,						ensure_ascii=_A       ) + """\n"""       )

				_UpperCAmelCase      :							int       =   0
				with open(_A ,						"""w""" ,						encoding="""utf-8"""       ) as writer:
					for bpe_tokens, token_index in sorted(self.bpe_ranks.items() ,						key=lambda _A       : kv[1]       ):
						if index != token_index:
							logger.warning(
							    f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
							    """ Please check that the tokenizer is not corrupted!"""       )
							_UpperCAmelCase      :							List[str]       =   token_index
						writer.write(""" """.join(_A       ) + """\n"""       )
						index += 1

				return vocab_file, merge_file
			def __getstate__(						self       )      ->      Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							List[str]       =   self.__dict__.copy()
				_UpperCAmelCase      :							List[str]       =   None
				return state
			def __setstate__(						self ,						_A       )      ->      Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Union[str, Any]       =   d

				try:
					import sacremoses
				except ImportError:
					raise ImportError(
					    """You need to install sacremoses to use XLMTokenizer. """
					    """See https://pypi.org/project/sacremoses/ for installation."""       )

				_UpperCAmelCase      :							Dict       =   sacremoses








"""simple docstring"""






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__			:					Dict							  =					logging.get_logger(__name__)

lowerCamelCase__			:					Optional[Any]							  =					{
    '''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       _UpperCAmelCase     (						__a):
			__a	:    Optional[int]			   =							"""blenderbot"""
			__a	:    Tuple			   =							["""past_key_values"""]
			__a	:    int			   =							{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}
			def __init__(						self ,						_A=80_08 ,						_A=1_28 ,						_A=2 ,						_A=1_02_40 ,						_A=32 ,						_A=24 ,						_A=1_02_40 ,						_A=32 ,						_A=0.0 ,						_A=0.0 ,						_A=True ,						_A=True ,						_A="gelu" ,						_A=25_60 ,						_A=0.1 ,						_A=0.0 ,						_A=0.0 ,						_A=0.02 ,						_A=1 ,						_A=False ,						_A=0 ,						_A=1 ,						_A=2 ,						_A=3 ,						_A=2 ,						**_A ,						)      ->      Union[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Any       =   vocab_size
				_UpperCAmelCase      :							Dict       =   max_position_embeddings
				_UpperCAmelCase      :							Optional[int]       =   d_model
				_UpperCAmelCase      :							Optional[Any]       =   encoder_ffn_dim
				_UpperCAmelCase      :							Optional[Any]       =   encoder_layers
				_UpperCAmelCase      :							List[Any]       =   encoder_attention_heads
				_UpperCAmelCase      :							str       =   decoder_ffn_dim
				_UpperCAmelCase      :							int       =   decoder_layers
				_UpperCAmelCase      :							List[str]       =   decoder_attention_heads
				_UpperCAmelCase      :							List[Any]       =   dropout
				_UpperCAmelCase      :							List[str]       =   attention_dropout
				_UpperCAmelCase      :							int       =   activation_dropout
				_UpperCAmelCase      :							Union[str, Any]       =   activation_function
				_UpperCAmelCase      :							List[str]       =   init_std
				_UpperCAmelCase      :							Dict       =   encoder_layerdrop
				_UpperCAmelCase      :							Union[str, Any]       =   decoder_layerdrop
				_UpperCAmelCase      :							str       =   use_cache
				_UpperCAmelCase      :							Optional[int]       =   encoder_layers
				_UpperCAmelCase      :							Union[str, Any]       =   scale_embedding  # scale factor will be sqrt(d_model) if True

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






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






				'''simple docstring'''







				if self.task in ["default", "seq2seq-lm"]:
					_UpperCAmelCase      :							Tuple       =   OrderedDict(
					    [
					        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
					        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
					    ]       )
					if self.use_past:
						_UpperCAmelCase      :							List[str]       =   {0: """batch"""}
						_UpperCAmelCase      :							List[str]       =   {0: """batch""", 1: """past_decoder_sequence + sequence"""}
					else:
						_UpperCAmelCase      :							Optional[int]       =   {0: """batch""", 1: """decoder_sequence"""}
						_UpperCAmelCase      :							int       =   {0: """batch""", 1: """decoder_sequence"""}
					if self.use_past:
						self.fill_with_past_key_values_(_A ,						direction="""inputs"""       )
				elif self.task == "causal-lm":
					_UpperCAmelCase      :							List[str]       =   OrderedDict(
					    [
					        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
					        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
					    ]       )
					if self.use_past:
						_UpperCAmelCase  ,				_UpperCAmelCase      :							Optional[Any]       =   self.num_layers
						for i in range(_A       ):
							_UpperCAmelCase      :							Any       =   {0: """batch""", 2: """past_sequence + sequence"""}
							_UpperCAmelCase      :							Dict       =   {0: """batch""", 2: """past_sequence + sequence"""}
				else:
					_UpperCAmelCase      :							List[Any]       =   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 							__snake_case	(						self       )      ->      Mapping[str, Mapping[int, str]]:






				'''simple docstring'''







				if self.task in ["default", "seq2seq-lm"]:
					_UpperCAmelCase      :							Optional[Any]       =   super().outputs
				else:
					_UpperCAmelCase      :							Optional[int]       =   super(_A ,						self       ).outputs
					if self.use_past:
						_UpperCAmelCase  ,				_UpperCAmelCase      :							int       =   self.num_layers
						for i in range(_A       ):
							_UpperCAmelCase      :							Tuple       =   {0: """batch""", 2: """past_sequence + sequence"""}
							_UpperCAmelCase      :							Optional[Any]       =   {0: """batch""", 2: """past_sequence + sequence"""}
				return common_outputs
			def 							__snake_case	(						self ,						_A ,						_A = -1 ,						_A = -1 ,						_A = False ,						_A = None ,						)      ->      Mapping[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Dict       =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
				    _A ,						_A ,						_A ,						_A ,						_A       )
				# Generate decoder inputs
				_UpperCAmelCase      :							Any       =   seq_length if not self.use_past else 1
				_UpperCAmelCase      :							List[str]       =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
				    _A ,						_A ,						_A ,						_A ,						_A       )
				_UpperCAmelCase      :							str       =   {f'''decoder_{name}''': tensor for name, tensor in decoder_inputs.items()}
				_UpperCAmelCase      :							Dict       =   dict(**_A ,						**_A       )

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

					for _ in range(_A       ):
						common_inputs["past_key_values"].append(
						    (
						        torch.zeros(_A       ),
						        torch.zeros(_A       ),
						        torch.zeros(_A       ),
						        torch.zeros(_A       ),
						    )       )
				return common_inputs
			def 							__snake_case	(						self ,						_A ,						_A = -1 ,						_A = -1 ,						_A = False ,						_A = None ,						)      ->      Mapping[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							Union[str, Any]       =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
				    _A ,						_A ,						_A ,						_A ,						_A       )

				if self.use_past:
					if not is_torch_available():
						raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""       )
					else:
						import torch
					_UpperCAmelCase  ,				_UpperCAmelCase      :							Any       =   common_inputs["""input_ids"""].shape
					_UpperCAmelCase      :							Union[str, Any]       =   seqlen
					_UpperCAmelCase  ,				_UpperCAmelCase      :							Optional[Any]       =   self.num_layers
					_UpperCAmelCase  ,				_UpperCAmelCase      :							Tuple       =   self.num_attention_heads
					_UpperCAmelCase      :							Optional[Any]       =   (
					    batch,
					    num_encoder_attention_heads,
					    past_key_values_length,
					    self._config.hidden_size // num_encoder_attention_heads,
					)
					_UpperCAmelCase      :							str       =   common_inputs["""attention_mask"""].dtype
					_UpperCAmelCase      :							Tuple       =   torch.cat(
					    [common_inputs["""attention_mask"""], torch.ones(_A ,						_A ,						dtype=_A       )] ,						dim=1       )
					_UpperCAmelCase      :							str       =   [
					    (torch.zeros(_A       ), torch.zeros(_A       )) for _ in range(_A       )
					]
				return common_inputs
			def 							__snake_case	(						self ,						_A ,						_A = -1 ,						_A = -1 ,						_A = False ,						_A = None ,						)      ->      Mapping[str, Any]:






				'''simple docstring'''







				_UpperCAmelCase      :							str       =   compute_effective_axis_dimension(
				    _A ,						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
				_UpperCAmelCase      :							List[str]       =   tokenizer.num_special_tokens_to_add(_A       )
				_UpperCAmelCase      :							Tuple       =   compute_effective_axis_dimension(
				    _A ,						fixed_dimension=OnnxConfig.default_fixed_sequence ,						num_token_to_add=_A       )

				# Generate dummy inputs according to compute batch and sequence
				_UpperCAmelCase      :							str       =   [""" """.join([tokenizer.unk_token]       ) * seq_length] * batch_size
				_UpperCAmelCase      :							str       =   dict(tokenizer(_A ,						return_tensors=_A       )       )
				return common_inputs
			def 							__snake_case	(						self ,						_A ,						_A = -1 ,						_A = -1 ,						_A = False ,						_A = None ,						)      ->      Mapping[str, Any]:






				'''simple docstring'''







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

				elif self.task == "causal-lm":
					_UpperCAmelCase      :							int       =   self._generate_dummy_inputs_for_causal_lm(
					    _A ,						batch_size=_A ,						seq_length=_A ,						is_pair=_A ,						framework=_A       )
				else:
					_UpperCAmelCase      :							Tuple       =   self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
					    _A ,						batch_size=_A ,						seq_length=_A ,						is_pair=_A ,						framework=_A       )

				return common_inputs
			def 							__snake_case	(						self ,						_A ,						_A ,						_A ,						_A       )      ->      Optional[int]:






				'''simple docstring'''







				if self.task in ["default", "seq2seq-lm"]:
					_UpperCAmelCase      :							Union[str, Any]       =   super()._flatten_past_key_values_(_A ,						_A ,						_A ,						_A       )
				else:
					_UpperCAmelCase      :							Tuple       =   super(_A ,						self       )._flatten_past_key_values_(
					    _A ,						_A ,						_A ,						_A       )
			def 							__snake_case	(						self ,						_A ,						_A       )      ->      Optional[Any]:






				'''simple docstring'''







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

				_UpperCAmelCase      :							Any       =   """past_key_values""" if direction == """inputs""" else """present"""
				_UpperCAmelCase  ,				_UpperCAmelCase      :							Any       =   self.num_layers

				_UpperCAmelCase      :							List[str]       =   """past_encoder_sequence"""
				_UpperCAmelCase      :							int       =   """past_decoder_sequence""" if direction == """inputs""" else """past_decoder_sequence + sequence"""

				for i in range(_A       ):
					_UpperCAmelCase      :							Union[str, Any]       =   {0: """batch""", 2: decoder_sequence}
					_UpperCAmelCase      :							Optional[int]       =   {0: """batch""", 2: decoder_sequence}
					_UpperCAmelCase      :							Tuple       =   {0: """batch""", 2: encoder_sequence}
					_UpperCAmelCase      :							Tuple       =   {0: """batch""", 2: encoder_sequence}





