


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:


					def __init__(						self	:		Optional[Any]     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Dict = 1_3     ,    SCREAMING_SNAKE_CASE	:		int = 6_4     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any] = 2     ,    SCREAMING_SNAKE_CASE	:		Dict = 3     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any] = 3     ,    SCREAMING_SNAKE_CASE	:		Dict = True     ,    SCREAMING_SNAKE_CASE	:		Dict = True     ,    SCREAMING_SNAKE_CASE	:		Dict = 1_2_8     ,    SCREAMING_SNAKE_CASE	:		Optional[Any]=[1_6, 3_2, 6_4, 1_2_8]     ,    SCREAMING_SNAKE_CASE	:		Tuple = 7     ,    SCREAMING_SNAKE_CASE	:		Tuple = 4     ,    SCREAMING_SNAKE_CASE	:		List[str] = 3_7     ,    SCREAMING_SNAKE_CASE	:		str = "gelu"     ,    SCREAMING_SNAKE_CASE	:		Dict = 0.1     ,    SCREAMING_SNAKE_CASE	:		Any = 0.1     ,    SCREAMING_SNAKE_CASE	:		Dict = 1_0     ,    SCREAMING_SNAKE_CASE	:		Optional[int] = 0.02     ,    SCREAMING_SNAKE_CASE	:		Dict = 2     ,    SCREAMING_SNAKE_CASE	:		int = 1     ,    SCREAMING_SNAKE_CASE	:		Any = 1_2_8     ,    SCREAMING_SNAKE_CASE	:		Optional[Any] = [2, 2, 2, 2]     ,    SCREAMING_SNAKE_CASE	:		List[Any] = 2     ,    SCREAMING_SNAKE_CASE	:		Tuple = 2     ,    )			->	str:




											'''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 							SCREAMING_SNAKE_CASE_  (						self	:		Dict						)			->	Union[str, 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 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Optional[Any]:




											'''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=_lowercase     ,    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 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		Optional[int]     ,    SCREAMING_SNAKE_CASE	:		Any     ,    SCREAMING_SNAKE_CASE	:		Any						)			->	Dict:




											'''simple docstring'''

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		Any     ,    SCREAMING_SNAKE_CASE	:		Tuple						)			->	List[Any]:




											'''simple docstring'''

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

											# test greyscale images
											__snake_case				=		1
											__snake_case				=		TFEfficientFormerForImageClassification(_lowercase						)

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






					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]						)			->	List[str]:




											'''simple docstring'''

											__snake_case				=		self.prepare_config_and_inputs()
											__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   ):
					snake_case_		:				List[Any]										=	(
					    (
					        TFEfficientFormerModel,
					        TFEfficientFormerForImageClassificationWithTeacher,
					        TFEfficientFormerForImageClassification,
					    )
					    if is_tf_available()
					    else ()
					)
					snake_case_		:				Any										=	(
					    {
					        """feature-extraction""": TFEfficientFormerModel,
					        """image-classification""": (
					            TFEfficientFormerForImageClassification,
					            TFEfficientFormerForImageClassificationWithTeacher,
					        ),
					    }
					    if is_tf_available()
					    else {}
					)

					snake_case_		:				List[Any]										=	False

					snake_case_		:				Optional[int]										=	False
					snake_case_		:				Union[str, Any]										=	False
					snake_case_		:				Tuple										=	False
					snake_case_		:				Dict										=	False


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	Tuple:




											'''simple docstring'''

											__snake_case				=		TFEfficientFormerModelTester(self						)
											__snake_case				=		ConfigTester(
											    self     ,    config_class=_lowercase     ,    has_text_modality=_lowercase     ,    hidden_size=3_7						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Any						)			->	Dict:




											'''simple docstring'''

											self.config_tester.run_common_tests()


					@unittest.skip(reason="EfficientFormer does not use inputs_embeds"						)
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	int:




											'''simple docstring'''

											pass


					@unittest.skip(reason="EfficientFormer does not support input and output embeddings"						)
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	Optional[int]:




											'''simple docstring'''

											pass


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]						)			->	List[Any]:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	__snake_case				=		model_class(_lowercase						)
																	__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]     ,    _lowercase						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[Any]						)			->	str:




											'''simple docstring'''

											def check_hidden_states_output(SCREAMING_SNAKE_CASE	:		Tuple     ,    SCREAMING_SNAKE_CASE	:		List[str]     ,    SCREAMING_SNAKE_CASE	:		Tuple						):
																	__snake_case				=		model_class(_lowercase						)

																	__snake_case				=		model(**self._prepare_for_class(_lowercase     ,    _lowercase						)     ,    training=_lowercase						)
																	__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(_lowercase						)     ,    _lowercase						)

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

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

											__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(_lowercase     ,    _lowercase     ,    _lowercase						)

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

																	check_hidden_states_output(_lowercase     ,    _lowercase     ,    _lowercase						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int     ,    SCREAMING_SNAKE_CASE	:		Any     ,    SCREAMING_SNAKE_CASE	:		Union[str, Any]     ,    SCREAMING_SNAKE_CASE	:		int=False						)			->	Union[str, Any]:




											'''simple docstring'''

											__snake_case				=		super()._prepare_for_class(_lowercase     ,    _lowercase     ,    return_labels=_lowercase						)

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

											return inputs_dict


					def 							SCREAMING_SNAKE_CASE_  (						self	:		int						)			->	str:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_lowercase						)


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




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*_lowercase						)


					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]						)			->	Optional[Any]:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*_lowercase						)


					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Union[str, Any]						)			->	Optional[Any]:




											'''simple docstring'''

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


					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Dict:




											'''simple docstring'''

											__snake_case				=		self.model_tester.prepare_config_and_inputs_for_common()
											__snake_case				=		True

											__snake_case				=		getattr(self.model_tester     ,    "seq_length"     ,    _lowercase						)
											__snake_case				=		getattr(self.model_tester     ,    "encoder_seq_length"     ,    _lowercase						)
											__snake_case				=		getattr(self.model_tester     ,    "key_length"     ,    _lowercase						)
											__snake_case				=		getattr(self.model_tester     ,    "chunk_length"     ,    _lowercase						)

											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(_lowercase						)

																	__snake_case				=		model(**self._prepare_for_class(_lowercase     ,    _lowercase						)     ,    training=_lowercase						)
																	__snake_case				=		outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																	self.assertEqual(len(_lowercase						)     ,    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(_lowercase						)
																	__snake_case				=		model(**self._prepare_for_class(_lowercase     ,    _lowercase						)     ,    training=_lowercase						)

																	__snake_case				=		outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																	self.assertEqual(len(_lowercase						)     ,    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_  (						self	:		List[Any]						)			->	Any:




											'''simple docstring'''

											__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(_lowercase						)
																	# 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=_lowercase						)
																	    for key, val in model.input_signature.items()
																	    if key in model.dummy_inputs
																	}
																	__snake_case				=		model(_lowercase						)
																	self.assertTrue(outputs_dict is not None						)





def 	_lowerCAmelCase       (    )						->	int:


						'''simple docstring'''






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






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


					@cached_property
					def 							SCREAMING_SNAKE_CASE_  (						self	:		List[str]						)			->	Optional[int]:




											'''simple docstring'''

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


					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Optional[int]						)			->	Dict:




											'''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=_lowercase     ,    return_tensors="tf"						)
											# forward pass
											__snake_case				=		model(**_lowercase     ,    training=_lowercase						)
											# verify the logits
											__snake_case				=		tf.TensorShape((1, 1_0_0_0)						)
											self.assertEqual(outputs.logits.shape     ,    _lowercase						)
											__snake_case				=		tf.constant([-0.0555, 0.4825, -0.0852]						)
											self.assertTrue(np.allclose(outputs.logits[0, :3]     ,    _lowercase     ,    atol=1e-4						)						)






					@slow
					def 							SCREAMING_SNAKE_CASE_  (						self	:		Union[str, Any]						)			->	str:




											'''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=_lowercase     ,    return_tensors="tf"						)
											# forward pass
											__snake_case				=		model(**_lowercase     ,    training=_lowercase						)
											# verify the logits
											__snake_case				=		tf.TensorShape((1, 1_0_0_0)						)
											self.assertEqual(outputs.logits.shape     ,    _lowercase						)
											__snake_case				=		tf.constant([-0.1312, 0.4353, -1.0499]						)
											self.assertTrue(np.allclose(outputs.logits[0, :3]     ,    _lowercase     ,    atol=1e-4						)						)





import warnings

from ...utils import logging
from .image_processing_beit import BeitImageProcessor


A							:					Any     						=     logging.get_logger(__name__)






class     UpperCamelCase(  _a   ):


					def __init__(						self	:		Optional[int]     ,    *SCREAMING_SNAKE_CASE	:		Tuple     ,    **SCREAMING_SNAKE_CASE	:		List[Any]						)			->	None:




											'''simple docstring'''

											warnings.warn(
											    "The class BeitFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
											    " use BeitImageProcessor instead."     ,    SCREAMING_SNAKE_CASE     ,    )
											super().__init__(*SCREAMING_SNAKE_CASE     ,    **SCREAMING_SNAKE_CASE						)





