code: 
  
  import inspect
  import unittest
  import warnings
  from typing import List
  
  from transformers import EfficientFormerConfig
  from transformers.models.auto import get_values
  from transformers.testing_utils import require_torch, require_vision, slow, torch_device
  from transformers.utils import cached_property, is_torch_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
  			import torch
  
  			from transformers import (
  			    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
  			    MODEL_MAPPING,
  			    EfficientFormerForImageClassification,
  			    EfficientFormerForImageClassificationWithTeacher,
  			    EfficientFormerModel,
  			)
  			from transformers.models.efficientformer.modeling_efficientformer import (
  			    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
  			)
  
  
  if is_vision_available():
  			from PIL import Image
  
  			from transformers import EfficientFormerImageProcessor
  
  
  
  
  
  
  class     lowerCamelCase_			:
  
  
  
  
  	def __init__(    self	:    Optional[int]				,			__A	:    str				,			__A	:    int = 13				,			__A	:    int = 64				,			__A	:    int = 2				,			__A	:    int = 3				,			__A	:    int = 3				,			__A	:    bool = True				,			__A	:    bool = True				,			__A	:    int = 128				,			__A	:    Union[str, Any]=[16, 32, 64, 128]				,			__A	:    int = 7				,			__A	:    int = 4				,			__A	:    int = 37				,			__A	:    str = "gelu"				,			__A	:    float = 0.1				,			__A	:    float = 0.1				,			__A	:    int = 10				,			__A	:    float = 0.0_2				,			__A	:    int = 2				,			__A	:    int = 1				,			__A	:    int = 128				,			__A	:    List[int] = [2, 2, 2, 2]				,			__A	:    int = 2				,			__A	:    int = 2				,			):
  		__A   : Dict								= parent
  		__A   : Dict								= batch_size
  		__A   : List[str]								= image_size
  		__A   : Tuple								= patch_size
  		__A   : List[Any]								= num_channels
  		__A   : List[str]								= is_training
  		__A   : Any								= use_labels
  		__A   : List[Any]								= hidden_size
  		__A   : Tuple								= num_hidden_layers
  		__A   : Optional[Any]								= num_attention_heads
  		__A   : Optional[Any]								= intermediate_size
  		__A   : Optional[int]								= hidden_act
  		__A   : Tuple								= hidden_dropout_prob
  		__A   : str								= attention_probs_dropout_prob
  		__A   : Optional[int]								= type_sequence_label_size
  		__A   : int								= initializer_range
  		__A   : List[Any]								= encoder_stride
  		__A   : Any								= num_attention_outputs
  		__A   : List[Any]								= embed_dim
  		__A   : int								= embed_dim + 1
  		__A   : int								= resolution
  		__A   : Optional[int]								= depths
  		__A   : List[Any]								= hidden_sizes
  		__A   : Union[str, Any]								= dim
  		__A   : Optional[int]								= mlp_expansion_ratio
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Optional[Any]       ):
  		__A   : Dict								= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )
  
  		__A   : Optional[Any]								= None
  		if self.use_labels:
  			__A   : str								= ids_tensor([self.batch_size]				,			self.type_sequence_label_size       )
  
  		__A   : Any								= self.get_config()
  		return config, pixel_values, labels
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		return EfficientFormerConfig(
  		    image_size=self.image_size				,			patch_size=self.patch_size				,			num_channels=self.num_channels				,			hidden_size=self.hidden_size				,			num_hidden_layers=self.num_hidden_layers				,			num_attention_heads=self.num_attention_heads				,			intermediate_size=self.intermediate_size				,			hidden_act=self.hidden_act				,			hidden_dropout_prob=self.hidden_dropout_prob				,			attention_probs_dropout_prob=self.attention_probs_dropout_prob				,			is_decoder=__A				,			initializer_range=self.initializer_range				,			encoder_stride=self.encoder_stride				,			resolution=self.resolution				,			depths=self.depths				,			hidden_sizes=self.hidden_sizes				,			dim=self.dim				,			mlp_expansion_ratio=self.mlp_expansion_ratio				,			)
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    int				,			__A	:    Tuple				,			__A	:    Union[str, Any]				,			__A	:    str       ):
  		__A   : List[str]								= EfficientFormerModel(config=__A       )
  		model.to(__A       )
  		model.eval()
  		__A   : Any								= model(__A       )
  		self.parent.assertEqual(result.last_hidden_state.shape				,			(self.batch_size, self.seq_length, self.hidden_size)       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict				,			__A	:    Dict				,			__A	:    Optional[Any]				,			__A	:    List[Any]       ):
  		__A   : List[str]								= self.type_sequence_label_size
  		__A   : List[str]								= EfficientFormerForImageClassification(__A       )
  		model.to(__A       )
  		model.eval()
  		__A   : int								= model(__A				,			labels=__A       )
  		self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.type_sequence_label_size)       )
  
  		# test greyscale images
  		__A   : int								= 1
  		__A   : int								= EfficientFormerForImageClassification(__A       )
  		model.to(__A       )
  		model.eval()
  
  		__A   : Tuple								= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
  		__A   : List[Any]								= model(__A       )
  		self.parent.assertEqual(result.logits.shape				,			(self.batch_size, self.type_sequence_label_size)       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict       ):
  		__A   : Dict								= self.prepare_config_and_inputs()
  		(
  		    (
  		    __A
  		)						,							(
  		    __A
  		)						,							(
  		    __A
  		)						,							
  		)   : Optional[int]								= config_and_inputs
  		__A   : List[Any]								= {"""pixel_values""": pixel_values}
  		return config, inputs_dict
  
  
  
  
  
  
  @require_torch
  class     lowerCamelCase_			(  _lowercase	,			_lowercase	,			unittest.TestCase  ):
  	_lowercase		:      List[str]    				=							(
  	    (
  	        EfficientFormerModel,
  	        EfficientFormerForImageClassificationWithTeacher,
  	        EfficientFormerForImageClassification,
  	    )
  	    if is_torch_available()
  	    else ()
  	)
  	_lowercase		:      Union[str, Any]    				=							(
  	    {
  	        '''feature-extraction''': EfficientFormerModel,
  	        '''image-classification''': (
  	            EfficientFormerForImageClassification,
  	            EfficientFormerForImageClassificationWithTeacher,
  	        ),
  	    }
  	    if is_torch_available()
  	    else {}
  	)
  	_lowercase		:      str    				=							False
  
  	_lowercase		:      Tuple    				=							False
  	_lowercase		:      Optional[int]    				=							False
  	_lowercase		:      Optional[Any]    				=							False
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    str       ):
  		__A   : str								= EfficientFormerModelTester(self       )
  		__A   : List[str]								= ConfigTester(
  		    self				,			config_class=__A				,			has_text_modality=__A				,			hidden_size=37       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[Any]       ):
  		self.config_tester.run_common_tests()
  
  
  
  
  	@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""       )
  	def 					lowerCAmelCase_					(    self	:    List[Any]       ):
  		pass
  
  
  
  
  	@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""       )
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		pass
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		__A						,							__A   : List[Any]								= self.model_tester.prepare_config_and_inputs_for_common()
  
  		for model_class in self.all_model_classes:
  			__A   : str								= model_class(__A       )
  			__A   : List[str]								= inspect.signature(model.forward       )
  			# signature.parameters is an OrderedDict => so arg_names order is deterministic
  			__A   : Tuple								= [*signature.parameters.keys()]
  
  			__A   : str								= ["""pixel_values"""]
  			self.assertListEqual(arg_names[:1]				,			__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Optional[Any]       ):
  		def check_hidden_states_output(__A	:    Optional[int]				,			__A	:    str				,			__A	:    Any       ):
  			__A   : Tuple								= model_class(__A       )
  			model.to(__A       )
  			model.eval()
  
  			with torch.no_grad():
  				__A   : List[Any]								= model(**self._prepare_for_class(__A				,			__A       )       )
  
  			__A   : Any								= outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
  			__A   : Union[str, Any]								= getattr(
  			    self.model_tester				,			"""expected_num_hidden_layers"""				,			self.model_tester.num_hidden_layers + 1       )
  			self.assertEqual(len(__A       )				,			__A       )
  
  			if hasattr(self.model_tester				,			"""encoder_seq_length"""       ):
  				__A   : Tuple								= self.model_tester.encoder_seq_length
  				if hasattr(self.model_tester				,			"""chunk_length"""       ) and self.model_tester.chunk_length > 1:
  					__A   : Union[str, Any]								= seq_length * self.model_tester.chunk_length
  			else:
  				__A   : Tuple								= self.model_tester.seq_length
  
  			self.assertListEqual(
  			    list(hidden_states[-1].shape[-2:]       )				,			[seq_length, self.model_tester.hidden_size]				,			)
  
  			if config.is_encoder_decoder:
  				__A   : Dict								= outputs.decoder_hidden_states
  
  				self.assertIsInstance(__A				,			(list, tuple)       )
  				self.assertEqual(len(__A       )				,			__A       )
  				__A   : Dict								= getattr(self.model_tester				,			"""seq_length"""				,			__A       )
  				__A   : Optional[Any]								= getattr(self.model_tester				,			"""decoder_seq_length"""				,			__A       )
  
  				self.assertListEqual(
  				    list(hidden_states[-1].shape[-2:]       )				,			[decoder_seq_length, self.model_tester.hidden_size]				,			)
  
  		__A						,							__A   : List[str]								= self.model_tester.prepare_config_and_inputs_for_common()
  
  		for model_class in self.all_model_classes:
  			__A   : Union[str, Any]								= True
  			check_hidden_states_output(__A				,			__A				,			__A       )
  
  			# check that output_hidden_states also work using config
  			del inputs_dict["output_hidden_states"]
  			__A   : List[Any]								= True
  
  			check_hidden_states_output(__A				,			__A				,			__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]				,			__A	:    Union[str, Any]				,			__A	:    Union[str, Any]				,			__A	:    List[Any]=False       ):
  		__A   : List[str]								= super()._prepare_for_class(__A				,			__A				,			return_labels=__A       )
  
  		if return_labels:
  			if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
  				del inputs_dict["labels"]
  
  		return inputs_dict
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A   : int								= self.model_tester.prepare_config_and_inputs()
  		self.model_tester.create_and_check_model(*__A       )
  
  
  
  
  	@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""       )
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		__A   : Any								= self.model_tester.prepare_config_and_inputs()
  		self.model_tester.create_and_check_for_masked_image_modeling(*__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Optional[Any]       ):
  		__A   : Dict								= self.model_tester.prepare_config_and_inputs()
  		self.model_tester.create_and_check_for_image_classification(*__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		if not self.model_tester.is_training:
  			return
  
  		__A						,							__A   : Union[str, Any]								= self.model_tester.prepare_config_and_inputs_for_common()
  		__A   : int								= True
  
  		for model_class in self.all_model_classes:
  			# EfficientFormerForImageClassificationWithTeacher supports inference-only
  			if (
  			    model_class in get_values(__A       )
  			    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
  			):
  				continue
  			__A   : Tuple								= model_class(__A       )
  			model.to(__A       )
  			model.train()
  			__A   : List[Any]								= self._prepare_for_class(__A				,			__A				,			return_labels=__A       )
  			__A   : Any								= model(**__A       ).loss
  			loss.backward()
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict       ):
  		__A						,							__A   : Optional[int]								= self.model_tester.prepare_config_and_inputs_for_common()
  
  		__A   : List[str]								= [
  		    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
  		    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
  		    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
  		]
  
  		for model_class in self.all_model_classes:
  			if (
  			    model_class
  			    not in [
  			        *get_values(__A       ),
  			    ]
  			    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
  			):
  				continue
  
  			for problem_type in problem_types:
  				with self.subTest(msg=F"""Testing {model_class} with {problem_type["title"]}"""       ):
  					__A   : int								= problem_type["""title"""]
  					__A   : Union[str, Any]								= problem_type["""num_labels"""]
  
  					__A   : List[str]								= model_class(__A       )
  					model.to(__A       )
  					model.train()
  
  					__A   : Dict								= self._prepare_for_class(__A				,			__A				,			return_labels=__A       )
  
  					if problem_type["num_labels"] > 1:
  						__A   : Union[str, Any]								= inputs["""labels"""].unsqueeze(1       ).repeat(1				,			problem_type["""num_labels"""]       )
  
  					__A   : List[Any]								= inputs["""labels"""].to(problem_type["""dtype"""]       )
  
  					# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
  					# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
  					# they have the same size." which is a symptom something in wrong for the regression problem.
  					# See https://github.com/huggingface/transformers/issues/11780
  					with warnings.catch_warnings(record=__A       ) as warning_list:
  						__A   : Any								= model(**__A       ).loss
  					for w in warning_list:
  						if "Using a target size that is different to the input size" in str(w.message       ):
  							raise ValueError(
  							    F"""Something is going wrong in the regression problem: intercepted {w.message}"""       )
  
  					loss.backward()
  
  
  
  
  	@slow
  	def 					lowerCAmelCase_					(    self	:    List[Any]       ):
  		for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  			__A   : List[Any]								= EfficientFormerModel.from_pretrained(__A       )
  			self.assertIsNotNone(__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict       ):
  		__A						,							__A   : Optional[int]								= self.model_tester.prepare_config_and_inputs_for_common()
  		__A   : Optional[Any]								= True
  
  		__A   : str								= getattr(self.model_tester				,			"""seq_length"""				,			__A       )
  		__A   : Optional[int]								= getattr(self.model_tester				,			"""encoder_seq_length"""				,			__A       )
  		__A   : Optional[Any]								= getattr(self.model_tester				,			"""key_length"""				,			__A       )
  		__A   : Union[str, Any]								= getattr(self.model_tester				,			"""chunk_length"""				,			__A       )
  
  		if chunk_length is not None and hasattr(self.model_tester				,			"""num_hashes"""       ):
  			__A   : Optional[int]								= encoder_seq_length * self.model_tester.num_hashes
  
  		for model_class in self.all_model_classes:
  			__A   : Optional[Any]								= True
  			__A   : Any								= False
  			__A   : Optional[int]								= True
  			__A   : str								= model_class(__A       )
  			model.to(__A       )
  			model.eval()
  			with torch.no_grad():
  				__A   : Optional[Any]								= model(**self._prepare_for_class(__A				,			__A       )       )
  			__A   : Optional[int]								= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
  			self.assertEqual(len(__A       )				,			self.model_tester.num_attention_outputs       )
  
  			# check that output_attentions also work using config
  			del inputs_dict["output_attentions"]
  			__A   : int								= True
  			__A   : str								= model_class(__A       )
  			model.to(__A       )
  			model.eval()
  			with torch.no_grad():
  				__A   : Tuple								= model(**self._prepare_for_class(__A				,			__A       )       )
  			__A   : Union[str, Any]								= outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
  			self.assertEqual(len(__A       )				,			self.model_tester.num_attention_outputs       )
  
  			if chunk_length is not None:
  				self.assertListEqual(
  				    list(attentions[0].shape[-4:]       )				,			[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]				,			)
  			else:
  				self.assertListEqual(
  				    list(attentions[0].shape[-3:]       )				,			[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]				,			)
  
  
  
  
  
  
  def        __SCREAMING_SNAKE_CASE    (      )				->							int:
  	__A   : Dict								= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
  	return image
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class     lowerCamelCase_			(  unittest.TestCase  ):
  
  
  
  
  	@cached_property
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		return (
  		    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""       )
  		    if is_vision_available()
  		    else None
  		)
  
  
  
  
  	@slow
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		__A   : Dict								= EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""       ).to(
  		    __A       )
  
  		__A   : int								= self.default_image_processor
  		__A   : List[Any]								= prepare_img()
  		__A   : Optional[Any]								= image_processor(images=__A				,			return_tensors="""pt"""       ).to(__A       )
  
  		# forward pass
  		with torch.no_grad():
  			__A   : Any								= model(**__A       )
  
  		# verify the logits
  		__A   : Optional[Any]								= (1, 1000)
  		self.assertEqual(outputs.logits.shape				,			__A       )
  
  		__A   : Optional[int]								= torch.tensor([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]       ).to(__A       )
  		self.assertTrue(torch.allclose(outputs.logits[0][:3]				,			__A				,			atol=1e-4       )       )
  
  
  
  
  	@slow
  	def 					lowerCAmelCase_					(    self	:    int       ):
  		__A   : Union[str, Any]								= EfficientFormerForImageClassificationWithTeacher.from_pretrained(
  		    """snap-research/efficientformer-l1-300"""       ).to(__A       )
  
  		__A   : List[str]								= self.default_image_processor
  		__A   : List[str]								= prepare_img()
  		__A   : str								= image_processor(images=__A				,			return_tensors="""pt"""       ).to(__A       )
  
  		# forward pass
  		with torch.no_grad():
  			__A   : Optional[Any]								= model(**__A       )
  
  		# verify the logits
  		__A   : Dict								= (1, 1000)
  		self.assertEqual(outputs.logits.shape				,			__A       )
  
  		__A   : Dict								= torch.tensor([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]       ).to(__A       )
  		self.assertTrue(torch.allclose(outputs.logits[0][:3]				,			__A				,			atol=1e-4       )       )
  
  
  
  
  
  
style_context: 
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfigWithPast
  from ...utils import logging
  
  
  UpperCAmelCase_       :				int		   =      logging.get_logger(__name__)
  
  UpperCAmelCase_       :				Any		   =      {
      '''uclanlp/plbart-base''': '''https://huggingface.co/uclanlp/plbart-base/resolve/main/config.json''',
      # See all PLBART models at https://huggingface.co/models?filter=plbart
  }
  
  
  
  
  
  
  class     lowerCamelCase_			(  _lowercase  ):
  	_lowercase		:      str    				=							'''plbart'''
  	_lowercase		:      str    				=							['''past_key_values''']
  	_lowercase		:      Any    				=							{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
  
  
  
  
  	def __init__(    self	:    List[Any]				,			__A	:    str=5_0005				,			__A	:    Union[str, Any]=1024				,			__A	:    int=6				,			__A	:    Dict=3072				,			__A	:    Union[str, Any]=12				,			__A	:    Tuple=6				,			__A	:    Tuple=3072				,			__A	:    Optional[int]=12				,			__A	:    int=0.0				,			__A	:    List[Any]=0.0				,			__A	:    Union[str, Any]=True				,			__A	:    Any=True				,			__A	:    Optional[int]="gelu"				,			__A	:    Optional[int]=768				,			__A	:    Any=0.1				,			__A	:    Union[str, Any]=0.1				,			__A	:    Union[str, Any]=0.0				,			__A	:    int=0.0_2				,			__A	:    Union[str, Any]=0.0				,			__A	:    Tuple=True				,			__A	:    List[str]=1				,			__A	:    str=0				,			__A	:    List[Any]=2				,			__A	:    Any=2				,			**__A	:    Union[str, Any]				,			):
  		__A   : List[Any]								= vocab_size
  		__A   : str								= max_position_embeddings
  		__A   : Union[str, Any]								= d_model
  		__A   : List[str]								= encoder_ffn_dim
  		__A   : Optional[Any]								= encoder_layers
  		__A   : Tuple								= encoder_attention_heads
  		__A   : List[Any]								= decoder_ffn_dim
  		__A   : Optional[int]								= decoder_layers
  		__A   : Any								= decoder_attention_heads
  		__A   : Optional[int]								= dropout
  		__A   : Any								= attention_dropout
  		__A   : Tuple								= activation_dropout
  		__A   : List[Any]								= activation_function
  		__A   : Tuple								= init_std
  		__A   : List[Any]								= encoder_layerdrop
  		__A   : str								= decoder_layerdrop
  		__A   : Union[str, Any]								= classifier_dropout
  		__A   : Optional[Any]								= use_cache
  		__A   : List[str]								= encoder_layers
  		__A   : Optional[int]								= 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				,			forced_eos_token_id=__A				,			**__A				,			)
  
  
  
  
  
  
  class     lowerCamelCase_			(  _lowercase  ):
  
  
  
  
  	@property
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		return OrderedDict(
  		    [
  		        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
  		        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
  		    ]       )
  
  
  
  
  	@property
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		if self.use_past:
  			return OrderedDict(
  			    [
  			        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			        ("""past_keys""", {0: """batch""", 2: """sequence"""}),
  			        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			    ]       )
  		else:
  			return OrderedDict(
  			    [
  			        ("""last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			        ("""encoder_last_hidden_state""", {0: """batch""", 1: """sequence"""}),
  			    ]       )
  
  
  
  
  
  