
'''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 							UpperCAmelCase   :




	'''simple docstring'''





	def __init__( self      :				Any							,A      :				int							,A      :				int = 13							,A      :				Tuple = 64							,A      :				Any = 2							,A      :				str = 3							,A      :				List[str] = 3							,A      :				Dict = True							,A      :				Optional[int] = True							,A      :				Optional[int] = 1_28							,A      :				Dict=[16, 32, 64, 1_28]							,A      :				List[Any] = 7							,A      :				Union[str, Any] = 4							,A      :				Union[str, Any] = 37							,A      :				str = "gelu"							,A      :				Union[str, Any] = 0.1							,A      :				Optional[Any] = 0.1							,A      :				Optional[int] = 10							,A      :				Tuple = 0.02							,A      :				Optional[Any] = 2							,A      :				Tuple = 1							,A      :				Union[str, Any] = 1_28							,A      :				int = [2, 2, 2, 2]							,A      :				int = 2							,A      :				List[str] = 2							,):
					__A         =				parent
					__A         =				batch_size
					__A         =				image_size
					__A         =				patch_size
					__A         =				num_channels
					__A         =				is_training
					__A         =				use_labels
					__A         =				hidden_size
					__A         =				num_hidden_layers
					__A         =				num_attention_heads
					__A         =				intermediate_size
					__A         =				hidden_act
					__A         =				hidden_dropout_prob
					__A         =				attention_probs_dropout_prob
					__A         =				type_sequence_label_size
					__A         =				initializer_range
					__A         =				encoder_stride
					__A         =				num_attention_outputs
					__A         =				embed_dim
					__A         =				embed_dim + 1
					__A         =				resolution
					__A         =				depths
					__A         =				hidden_sizes
					__A         =				dim
					__A         =				mlp_expansion_ratio






	def        UpperCamelCase_						( self      :				Any				):
					__A         =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

					__A         =				None
					if self.use_labels:
									__A         =				ids_tensor([self.batch_size]							,self.type_sequence_label_size				)

					__A         =				self.get_config()
					return config, pixel_values, labels






	def        UpperCamelCase_						( self      :				Optional[Any]				):
					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=__SCREAMING_SNAKE_CASE							,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        UpperCamelCase_						( self      :				Any							,A      :				Union[str, Any]							,A      :				int							,A      :				Any				):
					__A         =				EfficientFormerModel(config=__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__A         =				model(__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.last_hidden_state.shape							,(self.batch_size, self.seq_length, self.hidden_size)				)






	def        UpperCamelCase_						( self      :				Union[str, Any]							,A      :				str							,A      :				int							,A      :				List[Any]				):
					__A         =				self.type_sequence_label_size
					__A         =				EfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()
					__A         =				model(__SCREAMING_SNAKE_CASE							,labels=__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.type_sequence_label_size)				)

					# test greyscale images
					__A         =				1
					__A         =				EfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE				)
					model.to(__SCREAMING_SNAKE_CASE				)
					model.eval()

					__A         =				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
					__A         =				model(__SCREAMING_SNAKE_CASE				)
					self.parent.assertEqual(result.logits.shape							,(self.batch_size, self.type_sequence_label_size)				)







	def        UpperCamelCase_						( self      :				Optional[Any]				):
					__A         =				self.prepare_config_and_inputs()
					(
					    (
					    __A 
					)    ,							(
					    __A 
					)    ,							(
					    __A 
					)    ,							 
					)         =				config_and_inputs
					__A         =				{"pixel_values": pixel_values}
					return config, inputs_dict





@require_torch
class 							UpperCAmelCase   (						lowerCAmelCase_    ,    lowerCAmelCase_    ,    unittest.TestCase						):




	'''simple docstring'''





	snake_case_      					=  (
	    (
	        EfficientFormerModel,
	        EfficientFormerForImageClassificationWithTeacher,
	        EfficientFormerForImageClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	snake_case_      					=  (
	    {
	        """feature-extraction""": EfficientFormerModel,
	        """image-classification""": (
	            EfficientFormerForImageClassification,
	            EfficientFormerForImageClassificationWithTeacher,
	        ),
	    }
	    if is_torch_available()
	    else {}
	)
	snake_case_      					=  False

	snake_case_      					=  False
	snake_case_      					=  False
	snake_case_      					=  False






	def        UpperCamelCase_						( self      :				Tuple				):
					__A         =				EfficientFormerModelTester(self				)
					__A         =				ConfigTester(
					    self							,config_class=__SCREAMING_SNAKE_CASE							,has_text_modality=__SCREAMING_SNAKE_CASE							,hidden_size=37				)






	def        UpperCamelCase_						( self      :				Any				):
					self.config_tester.run_common_tests()






	@unittest.skip(reason="EfficientFormer does not use inputs_embeds"				)
	def        UpperCamelCase_						( self      :				str				):
					pass






	@unittest.skip(reason="EfficientFormer does not support input and output embeddings"				)
	def        UpperCamelCase_						( self      :				List[str]				):
					pass






	def        UpperCamelCase_						( self      :				int				):
					__A    ,							__A         =				self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									__A         =				model_class(__SCREAMING_SNAKE_CASE				)
									__A         =				inspect.signature(model.forward				)
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									__A         =				[*signature.parameters.keys()]

									__A         =				["pixel_values"]
									self.assertListEqual(arg_names[:1]							,__SCREAMING_SNAKE_CASE				)






	def        UpperCamelCase_						( self      :				List[Any]				):

					def check_hidden_states_output(A      :				Dict							,A      :				Tuple							,A      :				Union[str, Any]				):
									__A         =				model_class(__SCREAMING_SNAKE_CASE				)
									model.to(__SCREAMING_SNAKE_CASE				)
									model.eval()

									with torch.no_grad():
													__A         =				model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE				)				)

									__A         =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

									__A         =				getattr(
									    self.model_tester							,"expected_num_hidden_layers"							,self.model_tester.num_hidden_layers + 1				)
									self.assertEqual(len(__SCREAMING_SNAKE_CASE				)							,__SCREAMING_SNAKE_CASE				)

									if hasattr(self.model_tester							,"encoder_seq_length"				):
													__A         =				self.model_tester.encoder_seq_length
													if hasattr(self.model_tester							,"chunk_length"				) and self.model_tester.chunk_length > 1:
																	__A         =				seq_length * self.model_tester.chunk_length
									else:
													__A         =				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         =				outputs.decoder_hidden_states

													self.assertIsInstance(__SCREAMING_SNAKE_CASE							,(list, tuple)				)
													self.assertEqual(len(__SCREAMING_SNAKE_CASE				)							,__SCREAMING_SNAKE_CASE				)
													__A         =				getattr(self.model_tester							,"seq_length"							,__SCREAMING_SNAKE_CASE				)
													__A         =				getattr(self.model_tester							,"decoder_seq_length"							,__SCREAMING_SNAKE_CASE				)

													self.assertListEqual(
													    list(hidden_states[-1].shape[-2:]				)							,[decoder_seq_length, self.model_tester.hidden_size]							,)

					__A    ,							__A         =				self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									__A         =				True
									check_hidden_states_output(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE				)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									__A         =				True

									check_hidden_states_output(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE				)






	def        UpperCamelCase_						( self      :				str							,A      :				Union[str, Any]							,A      :				Any							,A      :				Dict=False				):
					__A         =				super()._prepare_for_class(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE							,return_labels=__SCREAMING_SNAKE_CASE				)

					if return_labels:
									if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
													del inputs_dict["labels"]

					return inputs_dict






	def        UpperCamelCase_						( self      :				Optional[Any]				):
					__A         =				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE				)






	@unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"				)
	def        UpperCamelCase_						( self      :				Optional[int]				):
					__A         =				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE				)






	def        UpperCamelCase_						( self      :				str				):
					__A         =				self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE				)






	def        UpperCamelCase_						( self      :				str				):

					if not self.model_tester.is_training:
									return

					__A    ,							__A         =				self.model_tester.prepare_config_and_inputs_for_common()
					__A         =				True

					for model_class in self.all_model_classes:
									# EfficientFormerForImageClassificationWithTeacher supports inference-only
									if (
									    model_class in get_values(__SCREAMING_SNAKE_CASE				)
									    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
									):
													continue
									__A         =				model_class(__SCREAMING_SNAKE_CASE				)
									model.to(__SCREAMING_SNAKE_CASE				)
									model.train()
									__A         =				self._prepare_for_class(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE							,return_labels=__SCREAMING_SNAKE_CASE				)
									__A         =				model(**__SCREAMING_SNAKE_CASE				).loss
									loss.backward()






	def        UpperCamelCase_						( self      :				Tuple				):
					__A    ,							__A         =				self.model_tester.prepare_config_and_inputs_for_common()

					__A         =				[
					    {"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(__SCREAMING_SNAKE_CASE				),
									    ]
									    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         =				problem_type["title"]
																	__A         =				problem_type["num_labels"]

																	__A         =				model_class(__SCREAMING_SNAKE_CASE				)
																	model.to(__SCREAMING_SNAKE_CASE				)
																	model.train()

																	__A         =				self._prepare_for_class(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE							,return_labels=__SCREAMING_SNAKE_CASE				)

																	if problem_type["num_labels"] > 1:
																					__A         =				inputs["labels"].unsqueeze(1				).repeat(1							,problem_type["num_labels"]				)

																	__A         =				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=__SCREAMING_SNAKE_CASE				) as warning_list:
																					__A         =				model(**__SCREAMING_SNAKE_CASE				).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        UpperCamelCase_						( self      :				Optional[Any]				):

					for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A         =				EfficientFormerModel.from_pretrained(__SCREAMING_SNAKE_CASE				)
									self.assertIsNotNone(__SCREAMING_SNAKE_CASE				)







	def        UpperCamelCase_						( self      :				Optional[Any]				):
					__A    ,							__A         =				self.model_tester.prepare_config_and_inputs_for_common()
					__A         =				True

					__A         =				getattr(self.model_tester							,"seq_length"							,__SCREAMING_SNAKE_CASE				)
					__A         =				getattr(self.model_tester							,"encoder_seq_length"							,__SCREAMING_SNAKE_CASE				)
					__A         =				getattr(self.model_tester							,"key_length"							,__SCREAMING_SNAKE_CASE				)
					__A         =				getattr(self.model_tester							,"chunk_length"							,__SCREAMING_SNAKE_CASE				)

					if chunk_length is not None and hasattr(self.model_tester							,"num_hashes"				):
									__A         =				encoder_seq_length * self.model_tester.num_hashes

					for model_class in self.all_model_classes:
									__A         =				True
									__A         =				False
									__A         =				True
									__A         =				model_class(__SCREAMING_SNAKE_CASE				)
									model.to(__SCREAMING_SNAKE_CASE				)
									model.eval()
									with torch.no_grad():
													__A         =				model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE				)				)
									__A         =				outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
									self.assertEqual(len(__SCREAMING_SNAKE_CASE				)							,self.model_tester.num_attention_outputs				)

									# check that output_attentions also work using config
									del inputs_dict["output_attentions"]
									__A         =				True
									__A         =				model_class(__SCREAMING_SNAKE_CASE				)
									model.to(__SCREAMING_SNAKE_CASE				)
									model.eval()
									with torch.no_grad():
													__A         =				model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE							,__SCREAMING_SNAKE_CASE				)				)
									__A         =				outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
									self.assertEqual(len(__SCREAMING_SNAKE_CASE				)							,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 		UpperCAmelCase    (			)	->			List[str]:







				"""simple docstring"""



				__A         =				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
				return image





@require_torch
@require_vision
class 							UpperCAmelCase   (						unittest.TestCase						):




	'''simple docstring'''





	@cached_property
	def        UpperCamelCase_						( self      :				Optional[int]				):
					return (
					    EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"				)
					    if is_vision_available()
					    else None
					)






	@slow
	def        UpperCamelCase_						( self      :				Any				):
					__A         =				EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"				).to(
					    __SCREAMING_SNAKE_CASE				)

					__A         =				self.default_image_processor
					__A         =				prepare_img()
					__A         =				image_processor(images=__SCREAMING_SNAKE_CASE							,return_tensors="pt"				).to(__SCREAMING_SNAKE_CASE				)

					# forward pass
					with torch.no_grad():
									__A         =				model(**__SCREAMING_SNAKE_CASE				)

					# verify the logits
					__A         =				(1, 10_00)
					self.assertEqual(outputs.logits.shape							,__SCREAMING_SNAKE_CASE				)

					__A         =				torch.tensor([-0.05_55, 0.48_25, -0.08_52]				).to(__SCREAMING_SNAKE_CASE				)
					self.assertTrue(torch.allclose(outputs.logits[0][:3]							,__SCREAMING_SNAKE_CASE							,atol=1E-4				)				)







	@slow
	def        UpperCamelCase_						( self      :				Optional[Any]				):
					__A         =				EfficientFormerForImageClassificationWithTeacher.from_pretrained(
					    "snap-research/efficientformer-l1-300"				).to(__SCREAMING_SNAKE_CASE				)

					__A         =				self.default_image_processor
					__A         =				prepare_img()
					__A         =				image_processor(images=__SCREAMING_SNAKE_CASE							,return_tensors="pt"				).to(__SCREAMING_SNAKE_CASE				)

					# forward pass
					with torch.no_grad():
									__A         =				model(**__SCREAMING_SNAKE_CASE				)

					# verify the logits
					__A         =				(1, 10_00)
					self.assertEqual(outputs.logits.shape							,__SCREAMING_SNAKE_CASE				)

					__A         =				torch.tensor([-0.13_12, 0.43_53, -1.04_99]				).to(__SCREAMING_SNAKE_CASE				)
					self.assertTrue(torch.allclose(outputs.logits[0][:3]							,__SCREAMING_SNAKE_CASE							,atol=1E-4				)				)


import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig





class 							UpperCAmelCase   (						__SCREAMING_SNAKE_CASE						):




	'''simple docstring'''





	snake_case_      					=  CustomConfig






	def __init__( self      :				Optional[int]							,A      :				List[str]				):
					super().__init__(A				)
					__A         =				torch.nn.Linear(config.hidden_size							,config.hidden_size				)






	def        UpperCamelCase_						( self      :				Union[str, Any]							,A      :				Optional[int]				):
					return self.linear(A				)







	def        UpperCamelCase_						( self      :				Optional[int]							,A      :				int				):
					pass





class 							UpperCAmelCase   (						__SCREAMING_SNAKE_CASE						):




	'''simple docstring'''





	snake_case_      					=  NoSuperInitConfig






	def __init__( self      :				Optional[int]							,A      :				Union[str, Any]				):
					super().__init__(A				)
					__A         =				torch.nn.Linear(config.attribute							,config.attribute				)






	def        UpperCamelCase_						( self      :				str							,A      :				Any				):
					return self.linear(A				)







	def        UpperCamelCase_						( self      :				Tuple							,A      :				int				):
					pass
