




import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers import (
		    TFEfficientFormerForImageClassification,
		    TFEfficientFormerForImageClassificationWithTeacher,
		    TFEfficientFormerModel,
		)
		from transformers.models.efficientformer.modeling_tf_efficientformer import (
		    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		)


if is_vision_available():
		from PIL import Image

		from transformers import EfficientFormerImageProcessor
class 						UpperCAmelCase  :







						'''simple docstring'''





						def __init__(		self				:	Union[str, Any]			,      __lowercase				:	List[str]			,      __lowercase				:	Any = 13			,      __lowercase				:	Optional[Any] = 64			,      __lowercase				:	Union[str, Any] = 2			,      __lowercase				:	Tuple = 3			,      __lowercase				:	int = 3			,      __lowercase				:	str = True			,      __lowercase				:	Dict = True			,      __lowercase				:	int = 1_28			,      __lowercase				:	List[Any]=[16, 32, 64, 1_28]			,      __lowercase				:	Optional[int] = 7			,      __lowercase				:	Optional[Any] = 4			,      __lowercase				:	Any = 37			,      __lowercase				:	Optional[Any] = "gelu"			,      __lowercase				:	Tuple = 0.1			,      __lowercase				:	str = 0.1			,      __lowercase				:	Optional[Any] = 10			,      __lowercase				:	Tuple = 0.02			,      __lowercase				:	Tuple = 2			,      __lowercase				:	Union[str, Any] = 1			,      __lowercase				:	str = 1_28			,      __lowercase				:	List[Any] = [2, 2, 2, 2]			,      __lowercase				:	Tuple = 2			,      __lowercase				:	Union[str, Any] = 2			,      ):






							"""simple docstring"""






							snake_case_						       =	parent
							snake_case_						       =	batch_size
							snake_case_						       =	image_size
							snake_case_						       =	patch_size
							snake_case_						       =	num_channels
							snake_case_						       =	is_training
							snake_case_						       =	use_labels
							snake_case_						       =	hidden_size
							snake_case_						       =	num_hidden_layers
							snake_case_						       =	num_attention_heads
							snake_case_						       =	intermediate_size
							snake_case_						       =	hidden_act
							snake_case_						       =	hidden_dropout_prob
							snake_case_						       =	attention_probs_dropout_prob
							snake_case_						       =	type_sequence_label_size
							snake_case_						       =	initializer_range
							snake_case_						       =	encoder_stride
							snake_case_						       =	num_attention_outputs
							snake_case_						       =	embed_dim
							snake_case_						       =	embed_dim + 1
							snake_case_						       =	resolution
							snake_case_						       =	depths
							snake_case_						       =	hidden_sizes
							snake_case_						       =	dim
							snake_case_						       =	mlp_expansion_ratio






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							snake_case_						       =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

							snake_case_						       =	self.get_config()

							return config, pixel_values, labels






						def 			snake_case__		(		self				:	Optional[int]		):






							"""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 			snake_case__		(		self				:	Dict			,      __lowercase				:	Dict			,      __lowercase				:	Tuple			,      __lowercase				:	Optional[Any]		):






							"""simple docstring"""






							snake_case_						       =	TFEfficientFormerModel(config=UpperCamelCase__		)
							snake_case_						       =	model(UpperCamelCase__			,      training=UpperCamelCase__		)
							self.parent.assertEqual(result.last_hidden_state.shape			,      (self.batch_size, self.seq_length, self.hidden_size)		)






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






							"""simple docstring"""






							snake_case_						       =	self.type_sequence_label_size
							snake_case_						       =	TFEfficientFormerForImageClassification(UpperCamelCase__		)
							snake_case_						       =	model(UpperCamelCase__			,      labels=UpperCamelCase__			,      training=UpperCamelCase__		)
							self.parent.assertEqual(result.logits.shape			,      (self.batch_size, self.type_sequence_label_size)		)

							# test greyscale images
							snake_case_						       =	1
							snake_case_						       =	TFEfficientFormerForImageClassification(UpperCamelCase__		)

							snake_case_						       =	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]		)
							snake_case_						       =	model(UpperCamelCase__			,      labels=UpperCamelCase__		)
							self.parent.assertEqual(result.logits.shape			,      (self.batch_size, self.type_sequence_label_size)		)






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






							"""simple docstring"""






							snake_case_						       =	self.prepare_config_and_inputs()
							snake_case_       , snake_case_       , snake_case_						       =	config_and_inputs
							snake_case_						       =	{"pixel_values": pixel_values}
							return config, inputs_dict







@require_tf
class 						UpperCAmelCase  (							_snake_case			,  _snake_case			,  unittest.TestCase     ):







						'''simple docstring'''





						lowerCAmelCase_							=  (
						    (
						        TFEfficientFormerModel,
						        TFEfficientFormerForImageClassificationWithTeacher,
						        TFEfficientFormerForImageClassification,
						    )
						    if is_tf_available()
						    else ()
						)
						lowerCAmelCase_							=  (
						    {
						        '''feature-extraction''': TFEfficientFormerModel,
						        '''image-classification''': (
						            TFEfficientFormerForImageClassification,
						            TFEfficientFormerForImageClassificationWithTeacher,
						        ),
						    }
						    if is_tf_available()
						    else {}
						)

						lowerCAmelCase_							=  False

						lowerCAmelCase_							=  False
						lowerCAmelCase_							=  False
						lowerCAmelCase_							=  False
						lowerCAmelCase_							=  False






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							snake_case_						       =	TFEfficientFormerModelTester(self		)
							snake_case_						       =	ConfigTester(
							    self			,      config_class=UpperCamelCase__			,      has_text_modality=UpperCamelCase__			,      hidden_size=37		)






						def 			snake_case__		(		self				:	Optional[int]		):






							"""simple docstring"""






							self.config_tester.run_common_tests()






						@unittest.skip(reason="EfficientFormer does not use inputs_embeds"		)
						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							pass






						@unittest.skip(reason="EfficientFormer does not support input and output embeddings"		)
						def 			snake_case__		(		self				:	Dict		):






							"""simple docstring"""






							pass






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()

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

								snake_case_						       =	["pixel_values"]
								self.assertListEqual(arg_names[:1]			,      UpperCamelCase__		)






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							def check_hidden_states_output(__lowercase				:	Tuple			,      __lowercase				:	Union[str, Any]			,      __lowercase				:	Union[str, Any]		):
								snake_case_						       =	model_class(UpperCamelCase__		)

								snake_case_						       =	model(**self._prepare_for_class(UpperCamelCase__			,      UpperCamelCase__		)			,      training=UpperCamelCase__		)
								snake_case_						       =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

									self.asseretIsInstance(UpperCamelCase__			,      (list, tuple)		)
									self.assertEqual(len(UpperCamelCase__		)			,      UpperCamelCase__		)
									snake_case_						       =	getattr(self.model_tester			,      "seq_length"			,      UpperCamelCase__		)
									snake_case_						       =	getattr(self.model_tester			,      "decoder_seq_length"			,      UpperCamelCase__		)

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

							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_						       =	True
								check_hidden_states_output(UpperCamelCase__			,      UpperCamelCase__			,      UpperCamelCase__		)

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

								check_hidden_states_output(UpperCamelCase__			,      UpperCamelCase__			,      UpperCamelCase__		)






						def 			snake_case__		(		self				:	Optional[Any]			,      __lowercase				:	Dict			,      __lowercase				:	int			,      __lowercase				:	str=False		):






							"""simple docstring"""






							snake_case_						       =	super()._prepare_for_class(UpperCamelCase__			,      UpperCamelCase__			,      return_labels=UpperCamelCase__		)

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

							return inputs_dict






						def 			snake_case__		(		self				:	Optional[int]		):






							"""simple docstring"""






							snake_case_						       =	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 			snake_case__		(		self				:	str		):






							"""simple docstring"""






							snake_case_						       =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase__		)






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							snake_case_						       =	self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__		)






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






							"""simple docstring"""






							for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								snake_case_						       =	TFEfficientFormerModel.from_pretrained(UpperCamelCase__		)
								self.assertIsNotNone(UpperCamelCase__		)






						def 			snake_case__		(		self				:	str		):






							"""simple docstring"""






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

							snake_case_						       =	getattr(self.model_tester			,      "seq_length"			,      UpperCamelCase__		)
							snake_case_						       =	getattr(self.model_tester			,      "encoder_seq_length"			,      UpperCamelCase__		)
							snake_case_						       =	getattr(self.model_tester			,      "key_length"			,      UpperCamelCase__		)
							snake_case_						       =	getattr(self.model_tester			,      "chunk_length"			,      UpperCamelCase__		)

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

							for model_class in self.all_model_classes:
								snake_case_						       =	True
								snake_case_						       =	False
								snake_case_						       =	True
								snake_case_						       =	model_class(UpperCamelCase__		)

								snake_case_						       =	model(**self._prepare_for_class(UpperCamelCase__			,      UpperCamelCase__		)			,      training=UpperCamelCase__		)
								snake_case_						       =	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"]
								snake_case_						       =	True
								snake_case_						       =	model_class(UpperCamelCase__		)
								snake_case_						       =	model(**self._prepare_for_class(UpperCamelCase__			,      UpperCamelCase__		)			,      training=UpperCamelCase__		)

								snake_case_						       =	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 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							snake_case_       , snake_case_						       =	self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								# Prepare our model
								snake_case_						       =	model_class(UpperCamelCase__		)
								# These are maximally general inputs for the model, with multiple None dimensions
								# Hopefully this will catch any conditionals that fail for flexible shapes
								snake_case_						       =	{
								    key: tf.keras.Input(shape=val.shape[1:]			,      dtype=val.dtype			,      name=UpperCamelCase__		)
								    for key, val in model.input_signature.items()
								    if key in model.dummy_inputs
								}
								snake_case_						       =	model(UpperCamelCase__		)
								self.assertTrue(outputs_dict is not None		)







def 		lowerCamelCase__       (						):







	'''simple docstring'''





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






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







						'''simple docstring'''





						@cached_property
						def 			snake_case__		(		self				:	Union[str, Any]		):






							"""simple docstring"""






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






						@slow
						def 			snake_case__		(		self				:	List[str]		):






							"""simple docstring"""






							snake_case_						       =	TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"		)
							snake_case_						       =	self.default_image_processor
							snake_case_						       =	prepare_img()
							snake_case_						       =	image_processor(images=UpperCamelCase__			,      return_tensors="tf"		)
							# forward pass
							snake_case_						       =	model(**UpperCamelCase__			,      training=UpperCamelCase__		)
							# verify the logits
							snake_case_						       =	tf.TensorShape((1, 10_00)		)
							self.assertEqual(outputs.logits.shape			,      UpperCamelCase__		)
							snake_case_						       =	tf.constant([-0.0555, 0.4825, -0.0852]		)
							self.assertTrue(np.allclose(outputs.logits[0, :3]			,      UpperCamelCase__			,      atol=1E-4		)		)






						@slow
						def 			snake_case__		(		self				:	Optional[int]		):






							"""simple docstring"""






							snake_case_						       =	TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
							    "snap-research/efficientformer-l1-300"		)
							snake_case_						       =	self.default_image_processor
							snake_case_						       =	prepare_img()
							snake_case_						       =	image_processor(images=UpperCamelCase__			,      return_tensors="tf"		)
							# forward pass
							snake_case_						       =	model(**UpperCamelCase__			,      training=UpperCamelCase__		)
							# verify the logits
							snake_case_						       =	tf.TensorShape((1, 10_00)		)
							self.assertEqual(outputs.logits.shape			,      UpperCamelCase__		)
							snake_case_						       =	tf.constant([-0.1312, 0.4353, -1.0499]		)
							self.assertTrue(np.allclose(outputs.logits[0, :3]			,      UpperCamelCase__			,      atol=1E-4		)		)



'''simple docstring'''







from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__lowerCamelCase									=     logging.get_logger(__name__)

__lowerCamelCase									=     {
    '''microsoft/resnet-50''': '''https://huggingface.co/microsoft/resnet-50/blob/main/config.json''',
}


class        A__   (   _snake_case    ,    _snake_case      ):
    lowercase						       =		"resnet"
    lowercase						       =		["basic", "bottleneck"]



    def __init__(       self		,					UpperCamelCase__=3		,					UpperCamelCase__=64		,					UpperCamelCase__=[256, 512, 1024, 2048]		,					UpperCamelCase__=[3, 4, 6, 3]		,					UpperCamelCase__="bottleneck"		,					UpperCamelCase__="relu"		,					UpperCamelCase__=False		,					UpperCamelCase__=None		,					UpperCamelCase__=None		,					**UpperCamelCase__		,					)    ->   List[str]:





           '''simple docstring'''
           super().__init__(**UpperCamelCase__							)
           if layer_type not in self.layer_types:
                  raise ValueError(f'''layer_type={layer_type} is not one of {",".join(self.layer_types							)}'''							)
           A_						       =   num_channels
           A_						       =   embedding_size
           A_						       =   hidden_sizes
           A_						       =   depths
           A_						       =   layer_type
           A_						       =   hidden_act
           A_						       =   downsample_in_first_stage
           A_						       =   ["""stem"""] + [f'''stage{idx}''' for idx in range(1		,					len(UpperCamelCase__							) + 1							)]
           A_       ,      A_						       =   get_aligned_output_features_output_indices(
               out_features=UpperCamelCase__		,					out_indices=UpperCamelCase__		,					stage_names=self.stage_names							)


class        A__   (   _snake_case      ):
    lowercase						       =		version.parse("1.11"      )



    @property
    def        snake_case_      (       self							)    ->   Mapping[str, Mapping[int, str]]:





           '''simple docstring'''
           return OrderedDict(
               [
                   ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
               ]							)







    @property
    def        snake_case_      (       self							)    ->   float:





           '''simple docstring'''
           return 1e-3
