
"""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_   )






"""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   )   )




