code: 
  """simple docstring"""
  import os
  import unittest
  
  from transformers import RealmTokenizerFast
  from transformers.models.bert.tokenization_bert import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      WordpieceTokenizer,
      _is_control,
      _is_punctuation,
      _is_whitespace,
  )
  from transformers.models.realm.tokenization_realm import RealmTokenizer
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
  
  
  @require_tokenizers
  class    _lowerCAmelCase						(						lowerCamelCase    ,       unittest.TestCase						):
  							lowercase_     :     str       =							RealmTokenizer
  							lowercase_     :     List[Any]       =							RealmTokenizerFast
  							lowercase_     :     int       =							True
  							lowercase_     :     Any       =							True
  							lowercase_     :     Union[str, Any]       =							filter_non_english
  
  
  
  							def       _a   (      self   )							->							Any:
  								super().setUp()
  
  								_UpperCAmelCase =						[
  								    "[UNK]",
  								    "[CLS]",
  								    "[SEP]",
  								    "[PAD]",
  								    "[MASK]",
  								    "want",
  								    "##want",
  								    "##ed",
  								    "wa",
  								    "un",
  								    "runn",
  								    "##ing",
  								    ",",
  								    "low",
  								    "lowest",
  								]
  								_UpperCAmelCase =						os.path.join(self.tmpdirname ,						VOCAB_FILES_NAMES["vocab_file"]   )
  								with open(self.vocab_file ,						"w" ,						encoding="utf-8"   ) as vocab_writer:
  									vocab_writer.write("".join([x + "\n" for x in vocab_tokens]   )   )
  
  
  
  							def       _a   (      self ,						a_   )							->							str:
  								_UpperCAmelCase =						"UNwant\u00E9d,running"
  								_UpperCAmelCase =						"unwanted, running"
  								return input_text, output_text
  
  
  
  							def       _a   (      self   )							->							Any:
  								_UpperCAmelCase =						self.tokenizer_class(self.vocab_file   )
  
  								_UpperCAmelCase =						tokenizer.tokenize("UNwant\u00E9d,running"   )
  								self.assertListEqual(a_ ,						["un", "##want", "##ed", ",", "runn", "##ing"]   )
  								self.assertListEqual(tokenizer.convert_tokens_to_ids(a_   ) ,						[9, 6, 7, 12, 10, 11]   )
  
  
  
  							def       _a   (      self   )							->							int:
  								if not self.test_rust_tokenizer:
  									return
  
  								_UpperCAmelCase =						self.get_tokenizer()
  								_UpperCAmelCase =						self.get_rust_tokenizer()
  
  								_UpperCAmelCase =						"UNwant\u00E9d,running"
  
  								_UpperCAmelCase =						tokenizer.tokenize(a_   )
  								_UpperCAmelCase =						rust_tokenizer.tokenize(a_   )
  								self.assertListEqual(a_ ,						a_   )
  
  								_UpperCAmelCase =						tokenizer.encode(a_ ,						add_special_tokens=a_   )
  								_UpperCAmelCase =						rust_tokenizer.encode(a_ ,						add_special_tokens=a_   )
  								self.assertListEqual(a_ ,						a_   )
  
  								_UpperCAmelCase =						self.get_rust_tokenizer()
  								_UpperCAmelCase =						tokenizer.encode(a_   )
  								_UpperCAmelCase =						rust_tokenizer.encode(a_   )
  								self.assertListEqual(a_ ,						a_   )
  
  								# With lower casing
  								_UpperCAmelCase =						self.get_tokenizer(do_lower_case=a_   )
  								_UpperCAmelCase =						self.get_rust_tokenizer(do_lower_case=a_   )
  
  								_UpperCAmelCase =						"UNwant\u00E9d,running"
  
  								_UpperCAmelCase =						tokenizer.tokenize(a_   )
  								_UpperCAmelCase =						rust_tokenizer.tokenize(a_   )
  								self.assertListEqual(a_ ,						a_   )
  
  								_UpperCAmelCase =						tokenizer.encode(a_ ,						add_special_tokens=a_   )
  								_UpperCAmelCase =						rust_tokenizer.encode(a_ ,						add_special_tokens=a_   )
  								self.assertListEqual(a_ ,						a_   )
  
  								_UpperCAmelCase =						self.get_rust_tokenizer()
  								_UpperCAmelCase =						tokenizer.encode(a_   )
  								_UpperCAmelCase =						rust_tokenizer.encode(a_   )
  								self.assertListEqual(a_ ,						a_   )
  
  
  
  							def       _a   (      self   )							->							int:
  								_UpperCAmelCase =						BasicTokenizer()
  
  								self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"   ) ,						["ah", "\u535A", "\u63A8", "zz"]   )
  
  
  
  							def       _a   (      self   )							->							Union[str, Any]:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "   ) ,						["hello", "!", "how", "are", "you", "?"]   )
  								self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   ) ,						["hello"]   )
  
  
  
  							def       _a   (      self   )							->							List[str]:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_ ,						strip_accents=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   ) ,						["hällo", "!", "how", "are", "you", "?"]   )
  								self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   ) ,						["h\u00E9llo"]   )
  
  
  
  							def       _a   (      self   )							->							Optional[Any]:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_ ,						strip_accents=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   ) ,						["hallo", "!", "how", "are", "you", "?"]   )
  								self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   ) ,						["hello"]   )
  
  
  
  							def       _a   (      self   )							->							str:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   ) ,						["hallo", "!", "how", "are", "you", "?"]   )
  								self.assertListEqual(tokenizer.tokenize("H\u00E9llo"   ) ,						["hello"]   )
  
  
  
  							def       _a   (      self   )							->							str:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "   ) ,						["HeLLo", "!", "how", "Are", "yoU", "?"]   )
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_ ,						strip_accents=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   ) ,						["HäLLo", "!", "how", "Are", "yoU", "?"]   )
  
  
  
  							def       _a   (      self   )							->							Dict:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_ ,						strip_accents=a_   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "   ) ,						["HaLLo", "!", "how", "Are", "yoU", "?"]   )
  
  
  
  							def       _a   (      self   )							->							Union[str, Any]:
  								_UpperCAmelCase =						BasicTokenizer(do_lower_case=a_ ,						never_split=["[UNK]"]   )
  
  								self.assertListEqual(
  								    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"   ) ,						["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]   )
  
  
  
  							def       _a   (      self   )							->							List[str]:
  								_UpperCAmelCase =						["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]
  
  								_UpperCAmelCase =						{}
  								for i, token in enumerate(a_   ):
  									_UpperCAmelCase =						i
  								_UpperCAmelCase =						WordpieceTokenizer(vocab=a_ ,						unk_token="[UNK]"   )
  
  								self.assertListEqual(tokenizer.tokenize(""   ) ,						[]   )
  
  								self.assertListEqual(tokenizer.tokenize("unwanted running"   ) ,						["un", "##want", "##ed", "runn", "##ing"]   )
  
  								self.assertListEqual(tokenizer.tokenize("unwantedX running"   ) ,						["[UNK]", "runn", "##ing"]   )
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								self.assertTrue(_is_whitespace(" "   )   )
  								self.assertTrue(_is_whitespace("\t"   )   )
  								self.assertTrue(_is_whitespace("\r"   )   )
  								self.assertTrue(_is_whitespace("\n"   )   )
  								self.assertTrue(_is_whitespace("\u00A0"   )   )
  
  								self.assertFalse(_is_whitespace("A"   )   )
  								self.assertFalse(_is_whitespace("-"   )   )
  
  
  
  							def       _a   (      self   )							->							List[str]:
  								self.assertTrue(_is_control("\u0005"   )   )
  
  								self.assertFalse(_is_control("A"   )   )
  								self.assertFalse(_is_control(" "   )   )
  								self.assertFalse(_is_control("\t"   )   )
  								self.assertFalse(_is_control("\r"   )   )
  
  
  
  							def       _a   (      self   )							->							Dict:
  								self.assertTrue(_is_punctuation("-"   )   )
  								self.assertTrue(_is_punctuation("$"   )   )
  								self.assertTrue(_is_punctuation("`"   )   )
  								self.assertTrue(_is_punctuation("."   )   )
  
  								self.assertFalse(_is_punctuation("A"   )   )
  								self.assertFalse(_is_punctuation(" "   )   )
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase =						self.get_tokenizer()
  
  								# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
  								self.assertListEqual([tokenizer.tokenize(a_   ) for t in ["Test", "\xad", "test"]] ,						[["[UNK]"], [], ["[UNK]"]]   )
  
  								if self.test_rust_tokenizer:
  									_UpperCAmelCase =						self.get_rust_tokenizer()
  									self.assertListEqual(
  									    [rust_tokenizer.tokenize(a_   ) for t in ["Test", "\xad", "test"]] ,						[["[UNK]"], [], ["[UNK]"]]   )
  
  
  
  							@slow
  							def       _a   (      self   )							->							List[Any]:
  								_UpperCAmelCase =						self.tokenizer_class.from_pretrained("bert-base-uncased"   )
  
  								_UpperCAmelCase =						tokenizer.encode("sequence builders" ,						add_special_tokens=a_   )
  								_UpperCAmelCase =						tokenizer.encode("multi-sequence build" ,						add_special_tokens=a_   )
  
  								_UpperCAmelCase =						tokenizer.build_inputs_with_special_tokens(a_   )
  								_UpperCAmelCase =						tokenizer.build_inputs_with_special_tokens(a_ ,						a_   )
  
  								assert encoded_sentence == [101] + text + [102]
  								assert encoded_pair == [101] + text + [102] + text_a + [102]
  
  
  
  							def       _a   (      self   )							->							Dict:
  								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  									with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
  										_UpperCAmelCase =						self.rust_tokenizer_class.from_pretrained(a_ ,						**a_   )
  
  										_UpperCAmelCase =						f"A, naïve {tokenizer_r.mask_token} AllenNLP sentence."
  										_UpperCAmelCase =						tokenizer_r.encode_plus(
  										    a_ ,						return_attention_mask=a_ ,						return_token_type_ids=a_ ,						return_offsets_mapping=a_ ,						add_special_tokens=a_ ,						)
  
  										_UpperCAmelCase =						tokenizer_r.do_lower_case if hasattr(a_ ,						"do_lower_case"   ) else False
  										_UpperCAmelCase =						(
  										    [
  										        ((0, 0), tokenizer_r.cls_token),
  										        ((0, 1), "A"),
  										        ((1, 2), ","),
  										        ((3, 5), "na"),
  										        ((5, 6), "##ï"),
  										        ((6, 8), "##ve"),
  										        ((9, 15), tokenizer_r.mask_token),
  										        ((16, 21), "Allen"),
  										        ((21, 23), "##NL"),
  										        ((23, 24), "##P"),
  										        ((25, 33), "sentence"),
  										        ((33, 34), "."),
  										        ((0, 0), tokenizer_r.sep_token),
  										    ]
  										    if not do_lower_case
  										    else [
  										        ((0, 0), tokenizer_r.cls_token),
  										        ((0, 1), "a"),
  										        ((1, 2), ","),
  										        ((3, 8), "naive"),
  										        ((9, 15), tokenizer_r.mask_token),
  										        ((16, 21), "allen"),
  										        ((21, 23), "##nl"),
  										        ((23, 24), "##p"),
  										        ((25, 33), "sentence"),
  										        ((33, 34), "."),
  										        ((0, 0), tokenizer_r.sep_token),
  										    ]
  										)
  
  										self.assertEqual(
  										    [e[1] for e in expected_results] ,						tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]   )   )
  										self.assertEqual([e[0] for e in expected_results] ,						tokens["offset_mapping"]   )
  
  
  
  							@slow
  							def       _a   (      self   )							->							Optional[int]:
  								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  									with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
  										_UpperCAmelCase =						self.rust_tokenizer_class.from_pretrained(a_ ,						**a_   )
  										_UpperCAmelCase =						self.tokenizer_class.from_pretrained(a_ ,						**a_   )
  										_UpperCAmelCase =						[["Hello world!", "Nice to meet you!"], ["The cute cat.", "The adorable dog."]]
  
  										_UpperCAmelCase =						tokenizer_r.batch_encode_candidates(a_ ,						max_length=10 ,						return_tensors="np"   )
  										_UpperCAmelCase =						tokenizer_p.batch_encode_candidates(a_ ,						max_length=10 ,						return_tensors="np"   )
  
  										_UpperCAmelCase =						(2, 2, 10)
  
  										self.assertEqual(encoded_sentence_r["input_ids"].shape ,						a_   )
  										self.assertEqual(encoded_sentence_r["attention_mask"].shape ,						a_   )
  										self.assertEqual(encoded_sentence_r["token_type_ids"].shape ,						a_   )
  
  										self.assertEqual(encoded_sentence_p["input_ids"].shape ,						a_   )
  										self.assertEqual(encoded_sentence_p["attention_mask"].shape ,						a_   )
  										self.assertEqual(encoded_sentence_p["token_type_ids"].shape ,						a_   )
  
  
  
  
  
style_context: 
  """simple docstring"""
  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 ,						a_ ,						a_ = 13 ,						a_ = 64 ,						a_ = 2 ,						a_ = 3 ,						a_ = 3 ,						a_ = True ,						a_ = True ,						a_ = 128 ,						a_=[16, 32, 64, 128] ,						a_ = 7 ,						a_ = 4 ,						a_ = 37 ,						a_ = "gelu" ,						a_ = 0.1 ,						a_ = 0.1 ,						a_ = 10 ,						a_ = 0.02 ,						a_ = 2 ,						a_ = 1 ,						a_ = 128 ,						a_ = [2, 2, 2, 2] ,						a_ = 2 ,						a_ = 2 ,						)							->							Tuple:
  								_UpperCAmelCase =						parent
  								_UpperCAmelCase =						batch_size
  								_UpperCAmelCase =						image_size
  								_UpperCAmelCase =						patch_size
  								_UpperCAmelCase =						num_channels
  								_UpperCAmelCase =						is_training
  								_UpperCAmelCase =						use_labels
  								_UpperCAmelCase =						hidden_size
  								_UpperCAmelCase =						num_hidden_layers
  								_UpperCAmelCase =						num_attention_heads
  								_UpperCAmelCase =						intermediate_size
  								_UpperCAmelCase =						hidden_act
  								_UpperCAmelCase =						hidden_dropout_prob
  								_UpperCAmelCase =						attention_probs_dropout_prob
  								_UpperCAmelCase =						type_sequence_label_size
  								_UpperCAmelCase =						initializer_range
  								_UpperCAmelCase =						encoder_stride
  								_UpperCAmelCase =						num_attention_outputs
  								_UpperCAmelCase =						embed_dim
  								_UpperCAmelCase =						embed_dim + 1
  								_UpperCAmelCase =						resolution
  								_UpperCAmelCase =						depths
  								_UpperCAmelCase =						hidden_sizes
  								_UpperCAmelCase =						dim
  								_UpperCAmelCase =						mlp_expansion_ratio
  
  
  
  							def       _a   (      self   )							->							Tuple:
  								_UpperCAmelCase =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )
  
  								_UpperCAmelCase =						None
  								if self.use_labels:
  									_UpperCAmelCase =						ids_tensor([self.batch_size] ,						self.type_sequence_label_size   )
  
  								_UpperCAmelCase =						self.get_config()
  								return config, pixel_values, labels
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								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       _a   (      self ,						a_ ,						a_ ,						a_   )							->							int:
  								_UpperCAmelCase =						EfficientFormerModel(config=a_   )
  								model.to(a_   )
  								model.eval()
  								_UpperCAmelCase =						model(a_   )
  								self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size)   )
  
  
  
  							def       _a   (      self ,						a_ ,						a_ ,						a_   )							->							str:
  								_UpperCAmelCase =						self.type_sequence_label_size
  								_UpperCAmelCase =						EfficientFormerForImageClassification(a_   )
  								model.to(a_   )
  								model.eval()
  								_UpperCAmelCase =						model(a_ ,						labels=a_   )
  								self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.type_sequence_label_size)   )
  
  								# test greyscale images
  								_UpperCAmelCase =						1
  								_UpperCAmelCase =						EfficientFormerForImageClassification(a_   )
  								model.to(a_   )
  								model.eval()
  
  								_UpperCAmelCase =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
  								_UpperCAmelCase =						model(a_   )
  								self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.type_sequence_label_size)   )
  
  
  
  							def       _a   (      self   )							->							Optional[int]:
  								_UpperCAmelCase =						self.prepare_config_and_inputs()
  								(
  								    (
  								    _UpperCAmelCase
  								) ,      (
  								    _UpperCAmelCase
  								) ,      (
  								    _UpperCAmelCase
  								) ,      
  								) =						config_and_inputs
  								_UpperCAmelCase =						{"pixel_values": pixel_values}
  								return config, inputs_dict
  
  
  
  
  
  @require_torch
  class    _lowerCAmelCase						(						lowerCamelCase    ,       lowerCamelCase    ,       unittest.TestCase						):
  							lowercase_     :     List[Any]       =							(
  							    (
  							        EfficientFormerModel,
  							        EfficientFormerForImageClassificationWithTeacher,
  							        EfficientFormerForImageClassification,
  							    )
  							    if is_torch_available()
  							    else ()
  							)
  							lowercase_     :     Optional[Any]       =							(
  							    {
  							        '''feature-extraction''': EfficientFormerModel,
  							        '''image-classification''': (
  							            EfficientFormerForImageClassification,
  							            EfficientFormerForImageClassificationWithTeacher,
  							        ),
  							    }
  							    if is_torch_available()
  							    else {}
  							)
  							lowercase_     :     List[str]       =							False
  
  							lowercase_     :     Dict       =							False
  							lowercase_     :     List[str]       =							False
  							lowercase_     :     List[str]       =							False
  
  
  
  							def       _a   (      self   )							->							Dict:
  								_UpperCAmelCase =						EfficientFormerModelTester(self   )
  								_UpperCAmelCase =						ConfigTester(
  								    self ,						config_class=a_ ,						has_text_modality=a_ ,						hidden_size=37   )
  
  
  
  							def       _a   (      self   )							->							List[Any]:
  								self.config_tester.run_common_tests()
  
  
  
  							@unittest.skip(reason="EfficientFormer does not use inputs_embeds"   )
  							def       _a   (      self   )							->							Tuple:
  								pass
  
  
  
  							@unittest.skip(reason="EfficientFormer does not support input and output embeddings"   )
  							def       _a   (      self   )							->							Optional[int]:
  								pass
  
  
  
  							def       _a   (      self   )							->							Optional[Any]:
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  									_UpperCAmelCase =						model_class(a_   )
  									_UpperCAmelCase =						inspect.signature(model.forward   )
  									# signature.parameters is an OrderedDict => so arg_names order is deterministic
  									_UpperCAmelCase =						[*signature.parameters.keys()]
  
  									_UpperCAmelCase =						["pixel_values"]
  									self.assertListEqual(arg_names[:1] ,						a_   )
  
  
  
  							def       _a   (      self   )							->							int:
  								def check_hidden_states_output(a_ ,						a_ ,						a_   ):
  									_UpperCAmelCase =						model_class(a_   )
  									model.to(a_   )
  									model.eval()
  
  									with torch.no_grad():
  										_UpperCAmelCase =						model(**self._prepare_for_class(a_ ,						a_   )   )
  
  									_UpperCAmelCase =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
  									_UpperCAmelCase =						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"   ):
  										_UpperCAmelCase =						self.model_tester.encoder_seq_length
  										if hasattr(self.model_tester ,						"chunk_length"   ) and self.model_tester.chunk_length > 1:
  											_UpperCAmelCase =						seq_length * self.model_tester.chunk_length
  									else:
  										_UpperCAmelCase =						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:
  										_UpperCAmelCase =						outputs.decoder_hidden_states
  
  										self.assertIsInstance(a_ ,						(list, tuple)   )
  										self.assertEqual(len(a_   ) ,						a_   )
  										_UpperCAmelCase =						getattr(self.model_tester ,						"seq_length" ,						a_   )
  										_UpperCAmelCase =						getattr(self.model_tester ,						"decoder_seq_length" ,						a_   )
  
  										self.assertListEqual(
  										    list(hidden_states[-1].shape[-2:]   ) ,						[decoder_seq_length, self.model_tester.hidden_size] ,						)
  
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  
  								for model_class in self.all_model_classes:
  									_UpperCAmelCase =						True
  									check_hidden_states_output(a_ ,						a_ ,						a_   )
  
  									# check that output_hidden_states also work using config
  									del inputs_dict["output_hidden_states"]
  									_UpperCAmelCase =						True
  
  									check_hidden_states_output(a_ ,						a_ ,						a_   )
  
  
  
  							def       _a   (      self ,						a_ ,						a_ ,						a_=False   )							->							Optional[Any]:
  								_UpperCAmelCase =						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       _a   (      self   )							->							int:
  								_UpperCAmelCase =						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       _a   (      self   )							->							int:
  								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_for_masked_image_modeling(*a_   )
  
  
  
  							def       _a   (      self   )							->							int:
  								_UpperCAmelCase =						self.model_tester.prepare_config_and_inputs()
  								self.model_tester.create_and_check_for_image_classification(*a_   )
  
  
  
  							def       _a   (      self   )							->							str:
  								if not self.model_tester.is_training:
  									return
  
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  								_UpperCAmelCase =						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
  									_UpperCAmelCase =						model_class(a_   )
  									model.to(a_   )
  									model.train()
  									_UpperCAmelCase =						self._prepare_for_class(a_ ,						a_ ,						return_labels=a_   )
  									_UpperCAmelCase =						model(**a_   ).loss
  									loss.backward()
  
  
  
  							def       _a   (      self   )							->							Tuple:
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  
  								_UpperCAmelCase =						[
  								    {"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']}"   ):
  											_UpperCAmelCase =						problem_type["title"]
  											_UpperCAmelCase =						problem_type["num_labels"]
  
  											_UpperCAmelCase =						model_class(a_   )
  											model.to(a_   )
  											model.train()
  
  											_UpperCAmelCase =						self._prepare_for_class(a_ ,						a_ ,						return_labels=a_   )
  
  											if problem_type["num_labels"] > 1:
  												_UpperCAmelCase =						inputs["labels"].unsqueeze(1   ).repeat(1 ,						problem_type["num_labels"]   )
  
  											_UpperCAmelCase =						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:
  												_UpperCAmelCase =						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       _a   (      self   )							->							Tuple:
  								for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  									_UpperCAmelCase =						EfficientFormerModel.from_pretrained(a_   )
  									self.assertIsNotNone(a_   )
  
  
  
  							def       _a   (      self   )							->							Union[str, Any]:
  								_UpperCAmelCase ,      _UpperCAmelCase =						self.model_tester.prepare_config_and_inputs_for_common()
  								_UpperCAmelCase =						True
  
  								_UpperCAmelCase =						getattr(self.model_tester ,						"seq_length" ,						a_   )
  								_UpperCAmelCase =						getattr(self.model_tester ,						"encoder_seq_length" ,						a_   )
  								_UpperCAmelCase =						getattr(self.model_tester ,						"key_length" ,						a_   )
  								_UpperCAmelCase =						getattr(self.model_tester ,						"chunk_length" ,						a_   )
  
  								if chunk_length is not None and hasattr(self.model_tester ,						"num_hashes"   ):
  									_UpperCAmelCase =						encoder_seq_length * self.model_tester.num_hashes
  
  								for model_class in self.all_model_classes:
  									_UpperCAmelCase =						True
  									_UpperCAmelCase =						False
  									_UpperCAmelCase =						True
  									_UpperCAmelCase =						model_class(a_   )
  									model.to(a_   )
  									model.eval()
  									with torch.no_grad():
  										_UpperCAmelCase =						model(**self._prepare_for_class(a_ ,						a_   )   )
  									_UpperCAmelCase =						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"]
  									_UpperCAmelCase =						True
  									_UpperCAmelCase =						model_class(a_   )
  									model.to(a_   )
  									model.eval()
  									with torch.no_grad():
  										_UpperCAmelCase =						model(**self._prepare_for_class(a_ ,						a_   )   )
  									_UpperCAmelCase =						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     __lowerCamelCase  (		):
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  	_UpperCAmelCase =						Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
  	return image
  
  
  
  @require_torch
  @require_vision
  class    _lowerCAmelCase						(						unittest.TestCase						):
  
  
  
  							@cached_property
  							def       _a   (      self   )							->							Optional[Any]:
  								return (
  								    EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"   )
  								    if is_vision_available()
  								    else None
  								)
  
  
  
  							@slow
  							def       _a   (      self   )							->							Tuple:
  								_UpperCAmelCase =						EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"   ).to(
  								    a_   )
  
  								_UpperCAmelCase =						self.default_image_processor
  								_UpperCAmelCase =						prepare_img()
  								_UpperCAmelCase =						image_processor(images=a_ ,						return_tensors="pt"   ).to(a_   )
  
  								# forward pass
  								with torch.no_grad():
  									_UpperCAmelCase =						model(**a_   )
  
  								# verify the logits
  								_UpperCAmelCase =						(1, 1000)
  								self.assertEqual(outputs.logits.shape ,						a_   )
  
  								_UpperCAmelCase =						torch.tensor([-0.0555, 0.4825, -0.0852]   ).to(a_   )
  								self.assertTrue(torch.allclose(outputs.logits[0][:3] ,						a_ ,						atol=1e-4   )   )
  
  
  
  							@slow
  							def       _a   (      self   )							->							Tuple:
  								_UpperCAmelCase =						EfficientFormerForImageClassificationWithTeacher.from_pretrained(
  								    "snap-research/efficientformer-l1-300"   ).to(a_   )
  
  								_UpperCAmelCase =						self.default_image_processor
  								_UpperCAmelCase =						prepare_img()
  								_UpperCAmelCase =						image_processor(images=a_ ,						return_tensors="pt"   ).to(a_   )
  
  								# forward pass
  								with torch.no_grad():
  									_UpperCAmelCase =						model(**a_   )
  
  								# verify the logits
  								_UpperCAmelCase =						(1, 1000)
  								self.assertEqual(outputs.logits.shape ,						a_   )
  
  								_UpperCAmelCase =						torch.tensor([-0.1312, 0.4353, -1.0499]   ).to(a_   )
  								self.assertTrue(torch.allclose(outputs.logits[0][:3] ,						a_ ,						atol=1e-4   )   )
  
  
  
  
  