




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   :      Union[str, Any]   ,   snake_case__   :      str   ,   snake_case__   :      int = 13   ,   snake_case__   :      int = 64   ,   snake_case__   :      int = 2   ,   snake_case__   :      int = 3   ,   snake_case__   :      int = 3   ,   snake_case__   :      bool = True   ,   snake_case__   :      bool = True   ,   snake_case__   :      int = 128   ,   snake_case__   :      List[str]=[16, 32, 64, 128]   ,   snake_case__   :      int = 7   ,   snake_case__   :      int = 4   ,   snake_case__   :      int = 37   ,   snake_case__   :      str = "gelu"   ,   snake_case__   :      float = 0.1   ,   snake_case__   :      float = 0.1   ,   snake_case__   :      int = 10   ,   snake_case__   :      float = 0.02   ,   snake_case__   :      int = 2   ,   snake_case__   :      int = 1   ,   snake_case__   :      int = 128   ,   snake_case__   :      List[int] = [2, 2, 2, 2]   ,   snake_case__   :      int = 2   ,   snake_case__   :      int = 2   ,   ):




									"""simple docstring"""


									_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 UpperCamelCase      (	self   :      Union[str, Any]				):




									"""simple docstring"""


									_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 UpperCamelCase      (	self   :      str				):




									"""simple docstring"""


									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=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   :      Dict   ,   snake_case__   :      Optional[int]   ,   snake_case__   :      Dict   ,   snake_case__   :      Tuple				):




									"""simple docstring"""


									_UpperCAmelCase													=					EfficientFormerModel(config=snake_case__				)
									model.to(snake_case__				)
									model.eval()
									_UpperCAmelCase													=					model(snake_case__				)
									self.parent.assertEqual(result.last_hidden_state.shape   ,   (self.batch_size, self.seq_length, self.hidden_size)				)







			def UpperCamelCase      (	self   :      int   ,   snake_case__   :      Optional[int]   ,   snake_case__   :      int   ,   snake_case__   :      Optional[Any]				):




									"""simple docstring"""


									_UpperCAmelCase													=					self.type_sequence_label_size
									_UpperCAmelCase													=					EfficientFormerForImageClassification(snake_case__				)
									model.to(snake_case__				)
									model.eval()
									_UpperCAmelCase													=					model(snake_case__   ,   labels=snake_case__				)
									self.parent.assertEqual(result.logits.shape   ,   (self.batch_size, self.type_sequence_label_size)				)

									# test greyscale images
									_UpperCAmelCase													=					1
									_UpperCAmelCase													=					EfficientFormerForImageClassification(snake_case__				)
									model.to(snake_case__				)
									model.eval()

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







			def UpperCamelCase      (	self   :      Optional[Any]				):




									"""simple docstring"""


									_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			(	UpperCAmelCase__ ,		UpperCAmelCase__ ,		unittest.TestCase			):
			snake_case_				:			Dict								=					(
			    (
			        EfficientFormerModel,
			        EfficientFormerForImageClassificationWithTeacher,
			        EfficientFormerForImageClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			snake_case_				:			Tuple								=					(
			    {
			        "feature-extraction": EfficientFormerModel,
			        "image-classification": (
			            EfficientFormerForImageClassification,
			            EfficientFormerForImageClassificationWithTeacher,
			        ),
			    }
			    if is_torch_available()
			    else {}
			)
			snake_case_				:			Any								=					False

			snake_case_				:			List[Any]								=					False
			snake_case_				:			int								=					False
			snake_case_				:			Any								=					False







			def UpperCamelCase      (	self   :      str				):




									"""simple docstring"""


									_UpperCAmelCase													=					EfficientFormerModelTester(self				)
									_UpperCAmelCase													=					ConfigTester(
									    self   ,   config_class=snake_case__   ,   has_text_modality=snake_case__   ,   hidden_size=37				)







			def UpperCamelCase      (	self   :      Optional[Any]				):




									"""simple docstring"""


									self.config_tester.run_common_tests()







			@unittest.skip(reason="EfficientFormer does not use inputs_embeds"				)
			def UpperCamelCase      (	self   :      Union[str, Any]				):




									"""simple docstring"""


									pass







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




									"""simple docstring"""


									pass







			def UpperCamelCase      (	self   :      Optional[int]				):




									"""simple docstring"""


									_UpperCAmelCase							,			_UpperCAmelCase													=					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_UpperCAmelCase													=					model_class(snake_case__				)
															_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]   ,   snake_case__				)







			def UpperCamelCase      (	self   :      Optional[Any]				):




									"""simple docstring"""


									def check_hidden_states_output(snake_case__   :      Dict   ,   snake_case__   :      Optional[Any]   ,   snake_case__   :      Any				):
															_UpperCAmelCase													=					model_class(snake_case__				)
															model.to(snake_case__				)
															model.eval()

															with torch.no_grad():
																					_UpperCAmelCase													=					model(**self._prepare_for_class(snake_case__   ,   snake_case__				)				)

															_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(snake_case__				)   ,   snake_case__				)

															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(snake_case__   ,   (list, tuple)				)
																					self.assertEqual(len(snake_case__				)   ,   snake_case__				)
																					_UpperCAmelCase													=					getattr(self.model_tester   ,   "seq_length"   ,   snake_case__				)
																					_UpperCAmelCase													=					getattr(self.model_tester   ,   "decoder_seq_length"   ,   snake_case__				)

																					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(snake_case__   ,   snake_case__   ,   snake_case__				)

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

															check_hidden_states_output(snake_case__   ,   snake_case__   ,   snake_case__				)







			def UpperCamelCase      (	self   :      List[Any]   ,   snake_case__   :      Union[str, Any]   ,   snake_case__   :      Optional[Any]   ,   snake_case__   :      Optional[Any]=False				):




									"""simple docstring"""


									_UpperCAmelCase													=					super()._prepare_for_class(snake_case__   ,   snake_case__   ,   return_labels=snake_case__				)

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

									return inputs_dict







			def UpperCamelCase      (	self   :      int				):




									"""simple docstring"""


									_UpperCAmelCase													=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case__				)







			@unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"				)
			def UpperCamelCase      (	self   :      List[Any]				):




									"""simple docstring"""


									_UpperCAmelCase													=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*snake_case__				)







			def UpperCamelCase      (	self   :      Union[str, Any]				):




									"""simple docstring"""


									_UpperCAmelCase													=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*snake_case__				)







			def UpperCamelCase      (	self   :      Optional[int]				):




									"""simple docstring"""


									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(snake_case__				)
															    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
															):
																					continue
															_UpperCAmelCase													=					model_class(snake_case__				)
															model.to(snake_case__				)
															model.train()
															_UpperCAmelCase													=					self._prepare_for_class(snake_case__   ,   snake_case__   ,   return_labels=snake_case__				)
															_UpperCAmelCase													=					model(**snake_case__				).loss
															loss.backward()







			def UpperCamelCase      (	self   :      Optional[Any]				):




									"""simple docstring"""


									_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(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"]}"""				):
																											_UpperCAmelCase													=					problem_type["title"]
																											_UpperCAmelCase													=					problem_type["num_labels"]

																											_UpperCAmelCase													=					model_class(snake_case__				)
																											model.to(snake_case__				)
																											model.train()

																											_UpperCAmelCase													=					self._prepare_for_class(snake_case__   ,   snake_case__   ,   return_labels=snake_case__				)

																											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=snake_case__				) as warning_list:
																																	_UpperCAmelCase													=					model(**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   :      Union[str, Any]				):




									"""simple docstring"""


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







			def UpperCamelCase      (	self   :      str				):




									"""simple docstring"""


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

									_UpperCAmelCase													=					getattr(self.model_tester   ,   "seq_length"   ,   snake_case__				)
									_UpperCAmelCase													=					getattr(self.model_tester   ,   "encoder_seq_length"   ,   snake_case__				)
									_UpperCAmelCase													=					getattr(self.model_tester   ,   "key_length"   ,   snake_case__				)
									_UpperCAmelCase													=					getattr(self.model_tester   ,   "chunk_length"   ,   snake_case__				)

									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(snake_case__				)
															model.to(snake_case__				)
															model.eval()
															with torch.no_grad():
																					_UpperCAmelCase													=					model(**self._prepare_for_class(snake_case__   ,   snake_case__				)				)
															_UpperCAmelCase													=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
															self.assertEqual(len(snake_case__				)   ,   self.model_tester.num_attention_outputs				)

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

						'''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 UpperCamelCase      (	self   :      Any				):




									"""simple docstring"""


									return (
									    EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"				)
									    if is_vision_available()
									    else None
									)







			@slow
			def UpperCamelCase      (	self   :      str				):




									"""simple docstring"""


									_UpperCAmelCase													=					EfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"				).to(
									    snake_case__				)

									_UpperCAmelCase													=					self.default_image_processor
									_UpperCAmelCase													=					prepare_img()
									_UpperCAmelCase													=					image_processor(images=snake_case__   ,   return_tensors="pt"				).to(snake_case__				)

									# forward pass
									with torch.no_grad():
															_UpperCAmelCase													=					model(**snake_case__				)

									# verify the logits
									_UpperCAmelCase													=					(1, 1_000)
									self.assertEqual(outputs.logits.shape   ,   snake_case__				)

									_UpperCAmelCase													=					torch.tensor([-0.0_555, 0.4_825, -0.0_852]				).to(snake_case__				)
									self.assertTrue(torch.allclose(outputs.logits[0][:3]   ,   snake_case__   ,   atol=1e-4				)				)







			@slow
			def UpperCamelCase      (	self   :      Union[str, Any]				):




									"""simple docstring"""


									_UpperCAmelCase													=					EfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    "snap-research/efficientformer-l1-300"				).to(snake_case__				)

									_UpperCAmelCase													=					self.default_image_processor
									_UpperCAmelCase													=					prepare_img()
									_UpperCAmelCase													=					image_processor(images=snake_case__   ,   return_tensors="pt"				).to(snake_case__				)

									# forward pass
									with torch.no_grad():
															_UpperCAmelCase													=					model(**snake_case__				)

									# verify the logits
									_UpperCAmelCase													=					(1, 1_000)
									self.assertEqual(outputs.logits.shape   ,   snake_case__				)

									_UpperCAmelCase													=					torch.tensor([-0.1_312, 0.4_353, -1.0_499]				).to(snake_case__				)
									self.assertTrue(torch.allclose(outputs.logits[0][:3]   ,   snake_case__   ,   atol=1e-4				)				)










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowercase_     :    int      =			{
    'configuration_videomae': ['VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'VideoMAEConfig'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_     :    List[str]      =			[
				    'VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'VideoMAEForPreTraining',
				    'VideoMAEModel',
				    'VideoMAEPreTrainedModel',
				    'VideoMAEForVideoClassification',
				]

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				lowercase_     :    Any      =			['VideoMAEFeatureExtractor']
				lowercase_     :    Dict      =			['VideoMAEImageProcessor']

if TYPE_CHECKING:
				from .configuration_videomae import VIDEOMAE_PRETRAINED_CONFIG_ARCHIVE_MAP, VideoMAEConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_videomae import (
								    VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VideoMAEForPreTraining,
								    VideoMAEForVideoClassification,
								    VideoMAEModel,
								    VideoMAEPreTrainedModel,
								)

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_videomae import VideoMAEFeatureExtractor
								from .image_processing_videomae import VideoMAEImageProcessor

else:
				import sys

				lowercase_     :    int      =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




