






from __future__ import annotations

import re


def __A					(   __lowerCAmelCase			)->						List[Any]:





						"""simple docstring"""



						def alphanum_key(__lowerCAmelCase			):
												return [int(lowercase_			) if s.isdigit() else s.lower() for s in re.split('([0-9]+)'				,	lowercase_			)]

						return sorted(lowercase_				,	key=lowercase_			)


if __name__ == "__main__":
		import doctest

		doctest.testmod()








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				:





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase = 13 ,					UpperCAmelCase = 64 ,					UpperCAmelCase = 2 ,					UpperCAmelCase = 3 ,					UpperCAmelCase = 3 ,					UpperCAmelCase = True ,					UpperCAmelCase = True ,					UpperCAmelCase = 128 ,					UpperCAmelCase=[16, 32, 64, 128] ,					UpperCAmelCase = 7 ,					UpperCAmelCase = 4 ,					UpperCAmelCase = 37 ,					UpperCAmelCase = "gelu" ,					UpperCAmelCase = 0.1 ,					UpperCAmelCase = 0.1 ,					UpperCAmelCase = 10 ,					UpperCAmelCase = 0.02 ,					UpperCAmelCase = 2 ,					UpperCAmelCase = 1 ,					UpperCAmelCase = 128 ,					UpperCAmelCase = [2, 2, 2, 2] ,					UpperCAmelCase = 2 ,					UpperCAmelCase = 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					):
							"""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					):
							"""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=UpperCAmelCase ,					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 ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
							"""simple docstring"""







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

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

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

	def  UpperCamelCase					(							self					):
							"""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				(   snake_case__  , snake_case__  , unittest.TestCase):





	"""simple docstring"""






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

	UpperCamelCase__			=   False
	UpperCamelCase__			=   False
	UpperCamelCase__			=   False

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							self.config_tester.run_common_tests()

	@unittest.skip(reason='EfficientFormer does not use inputs_embeds'					)
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							pass

	@unittest.skip(reason='EfficientFormer does not support input and output embeddings'					)
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							pass

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase      ,				_UpperCAmelCase             =    self.model_tester.prepare_config_and_inputs_for_common()

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

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							def check_hidden_states_output(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					):
													_UpperCAmelCase             =    model_class(UpperCAmelCase					)
													model.to(UpperCAmelCase					)
													model.eval()

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

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

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

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

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

													check_hidden_states_output(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase					)

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase=False					):
							"""simple docstring"""







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

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

							return inputs_dict

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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

	@unittest.skip(reason='EfficientFormer does not implement masked image modeling yet'					)
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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

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

	def  UpperCamelCase					(							self					):
							"""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(UpperCAmelCase					),
													    ]
													    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(UpperCAmelCase					)
																									model.to(UpperCAmelCase					)
																									model.train()

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

																									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=UpperCAmelCase					) as warning_list:
																															_UpperCAmelCase             =    model(**UpperCAmelCase					).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					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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

							_UpperCAmelCase             =    getattr(self.model_tester ,					'seq_length' ,					UpperCAmelCase					)
							_UpperCAmelCase             =    getattr(self.model_tester ,					'encoder_seq_length' ,					UpperCAmelCase					)
							_UpperCAmelCase             =    getattr(self.model_tester ,					'key_length' ,					UpperCAmelCase					)
							_UpperCAmelCase             =    getattr(self.model_tester ,					'chunk_length' ,					UpperCAmelCase					)

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

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





						"""simple docstring"""



						_UpperCAmelCase             =    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
						return image





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





	"""simple docstring"""






	@cached_property
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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

	@slow
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    EfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'					).to(
							    UpperCAmelCase					)

							_UpperCAmelCase             =    self.default_image_processor
							_UpperCAmelCase             =    prepare_img()
							_UpperCAmelCase             =    image_processor(images=UpperCAmelCase ,					return_tensors='pt'					).to(UpperCAmelCase					)

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

							# verify the logits
							_UpperCAmelCase             =    (1, 1000)
							self.assertEqual(outputs.logits.shape ,					UpperCAmelCase					)

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

	@slow
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







							_UpperCAmelCase             =    EfficientFormerForImageClassificationWithTeacher.from_pretrained(
							    'snap-research/efficientformer-l1-300'					).to(UpperCAmelCase					)

							_UpperCAmelCase             =    self.default_image_processor
							_UpperCAmelCase             =    prepare_img()
							_UpperCAmelCase             =    image_processor(images=UpperCAmelCase ,					return_tensors='pt'					).to(UpperCAmelCase					)

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

							# verify the logits
							_UpperCAmelCase             =    (1, 1000)
							self.assertEqual(outputs.logits.shape ,					UpperCAmelCase					)

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