


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        lowerCamelCase      :


	def __init__(						self							,    lowercase__							,    lowercase__ = 1_3							,    lowercase__ = 6_4							,    lowercase__ = 2							,    lowercase__ = 3							,    lowercase__ = 3							,    lowercase__ = True							,    lowercase__ = True							,    lowercase__ = 1_2_8							,    lowercase__=[1_6, 3_2, 6_4, 1_2_8]							,    lowercase__ = 7							,    lowercase__ = 4							,    lowercase__ = 3_7							,    lowercase__ = "gelu"							,    lowercase__ = 0.1							,    lowercase__ = 0.1							,    lowercase__ = 1_0							,    lowercase__ = 0.0_2							,    lowercase__ = 2							,    lowercase__ = 1							,    lowercase__ = 1_2_8							,    lowercase__ = [2, 2, 2, 2]							,    lowercase__ = 2							,    lowercase__ = 2							,    ):
							__UpperCAmelCase :       Union[str, Any]  						=  parent
							__UpperCAmelCase :       Dict  						=  batch_size
							__UpperCAmelCase :       Union[str, Any]  						=  image_size
							__UpperCAmelCase :       int  						=  patch_size
							__UpperCAmelCase :       List[str]  						=  num_channels
							__UpperCAmelCase :       Tuple  						=  is_training
							__UpperCAmelCase :       List[str]  						=  use_labels
							__UpperCAmelCase :       Any  						=  hidden_size
							__UpperCAmelCase :       Optional[Any]  						=  num_hidden_layers
							__UpperCAmelCase :       List[Any]  						=  num_attention_heads
							__UpperCAmelCase :       Optional[Any]  						=  intermediate_size
							__UpperCAmelCase :       Union[str, Any]  						=  hidden_act
							__UpperCAmelCase :       List[str]  						=  hidden_dropout_prob
							__UpperCAmelCase :       Optional[int]  						=  attention_probs_dropout_prob
							__UpperCAmelCase :       Optional[int]  						=  type_sequence_label_size
							__UpperCAmelCase :       Any  						=  initializer_range
							__UpperCAmelCase :       List[Any]  						=  encoder_stride
							__UpperCAmelCase :       Optional[Any]  						=  num_attention_outputs
							__UpperCAmelCase :       Union[str, Any]  						=  embed_dim
							__UpperCAmelCase :       List[str]  						=  embed_dim + 1
							__UpperCAmelCase :       int  						=  resolution
							__UpperCAmelCase :       str  						=  depths
							__UpperCAmelCase :       Optional[Any]  						=  hidden_sizes
							__UpperCAmelCase :       Optional[Any]  						=  dim
							__UpperCAmelCase :       Any  						=  mlp_expansion_ratio


	def    A(						self):
							__UpperCAmelCase :       int  						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

							__UpperCAmelCase :       int  						=  None
							if self.use_labels:
													__UpperCAmelCase :       Optional[int]  						=  ids_tensor([self.batch_size]							,    self.type_sequence_label_size)

							__UpperCAmelCase :       Union[str, Any]  						=  self.get_config()

							return config, pixel_values, labels


	def    A(						self):
							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    A(						self							,    lowercase__							,    lowercase__							,    lowercase__):
							__UpperCAmelCase :       Tuple  						=  TFEfficientFormerModel(config=lowercase__)
							__UpperCAmelCase :       Dict  						=  model(lowercase__							,    training=lowercase__)
							self.parent.assertEqual(result.last_hidden_state.shape							,    (self.batch_size, self.seq_length, self.hidden_size))


	def    A(						self							,    lowercase__							,    lowercase__							,    lowercase__):
							__UpperCAmelCase :       int  						=  self.type_sequence_label_size
							__UpperCAmelCase :       Optional[int]  						=  TFEfficientFormerForImageClassification(lowercase__)
							__UpperCAmelCase :       Any  						=  model(lowercase__							,    labels=lowercase__							,    training=lowercase__)
							self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.type_sequence_label_size))

							# test greyscale images
							__UpperCAmelCase :       str  						=  1
							__UpperCAmelCase :       Any  						=  TFEfficientFormerForImageClassification(lowercase__)

							__UpperCAmelCase :       Optional[int]  						=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
							__UpperCAmelCase :       Any  						=  model(lowercase__							,    labels=lowercase__)
							self.parent.assertEqual(result.logits.shape							,    (self.batch_size, self.type_sequence_label_size))


	def    A(						self):
							__UpperCAmelCase :       Tuple  						=  self.prepare_config_and_inputs()
							__UpperCAmelCase						,			__UpperCAmelCase						,			__UpperCAmelCase :       Dict  						=  config_and_inputs
							__UpperCAmelCase :       List[Any]  						=  {'''pixel_values''': pixel_values}
							return config, inputs_dict






@require_tf
class        lowerCamelCase      (     _UpperCamelCase       ,	_UpperCamelCase       ,	unittest.TestCase   ):
	_lowerCAmelCase    :		Tuple        =	(
	    (
	        TFEfficientFormerModel,
	        TFEfficientFormerForImageClassificationWithTeacher,
	        TFEfficientFormerForImageClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	_lowerCAmelCase    :		Union[str, Any]        =	(
	    {
	        '''feature-extraction''': TFEfficientFormerModel,
	        '''image-classification''': (
	            TFEfficientFormerForImageClassification,
	            TFEfficientFormerForImageClassificationWithTeacher,
	        ),
	    }
	    if is_tf_available()
	    else {}
	)

	_lowerCAmelCase    :		Optional[Any]        =	False

	_lowerCAmelCase    :		Optional[int]        =	False
	_lowerCAmelCase    :		Optional[Any]        =	False
	_lowerCAmelCase    :		Tuple        =	False
	_lowerCAmelCase    :		List[str]        =	False


	def    A(						self):
							__UpperCAmelCase :       Tuple  						=  TFEfficientFormerModelTester(self)
							__UpperCAmelCase :       Tuple  						=  ConfigTester(
							    self							,    config_class=lowercase__							,    has_text_modality=lowercase__							,    hidden_size=3_7)


	def    A(						self):
							self.config_tester.run_common_tests()


	@unittest.skip(reason='''EfficientFormer does not use inputs_embeds''')
	def    A(						self):
							pass


	@unittest.skip(reason='''EfficientFormer does not support input and output embeddings''')
	def    A(						self):
							pass


	def    A(						self):
							__UpperCAmelCase						,			__UpperCAmelCase :       Optional[Any]  						=  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													__UpperCAmelCase :       List[Any]  						=  model_class(lowercase__)
													__UpperCAmelCase :       Any  						=  inspect.signature(model.call)
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													__UpperCAmelCase :       Union[str, Any]  						=  [*signature.parameters.keys()]

													__UpperCAmelCase :       Optional[Any]  						=  ['''pixel_values''']
													self.assertListEqual(arg_names[:1]							,    lowercase__)


	def    A(						self):
							def check_hidden_states_output(lowercase__							,    lowercase__							,    lowercase__):
													__UpperCAmelCase :       List[str]  						=  model_class(lowercase__)

													__UpperCAmelCase :       Dict  						=  model(**self._prepare_for_class(lowercase__							,    lowercase__)							,    training=lowercase__)
													__UpperCAmelCase :       Optional[Any]  						=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													__UpperCAmelCase :       Optional[int]  						=  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'''):
																			__UpperCAmelCase :       Optional[int]  						=  self.model_tester.encoder_seq_length
																			if hasattr(self.model_tester							,    '''chunk_length''') and self.model_tester.chunk_length > 1:
																									__UpperCAmelCase :       List[str]  						=  seq_length * self.model_tester.chunk_length
													else:
																			__UpperCAmelCase :       str  						=  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 :       Tuple  						=  outputs.decoder_hidden_states

																			self.asseretIsInstance(lowercase__							,    (list, tuple))
																			self.assertEqual(len(lowercase__)							,    lowercase__)
																			__UpperCAmelCase :       int  						=  getattr(self.model_tester							,    '''seq_length'''							,    lowercase__)
																			__UpperCAmelCase :       Union[str, Any]  						=  getattr(self.model_tester							,    '''decoder_seq_length'''							,    lowercase__)

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

							__UpperCAmelCase						,			__UpperCAmelCase :       Any  						=  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													__UpperCAmelCase :       Union[str, Any]  						=  True
													check_hidden_states_output(lowercase__							,    lowercase__							,    lowercase__)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													__UpperCAmelCase :       List[Any]  						=  True

													check_hidden_states_output(lowercase__							,    lowercase__							,    lowercase__)


	def    A(						self							,    lowercase__							,    lowercase__							,    lowercase__=False):
							__UpperCAmelCase :       Tuple  						=  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    A(						self):
							__UpperCAmelCase :       Dict  						=  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    A(						self):
							__UpperCAmelCase :       List[str]  						=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*lowercase__)


	def    A(						self):
							__UpperCAmelCase :       Optional[int]  						=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*lowercase__)


	@slow
	def    A(						self):
							for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__UpperCAmelCase :       str  						=  TFEfficientFormerModel.from_pretrained(lowercase__)
													self.assertIsNotNone(lowercase__)


	def    A(						self):
							__UpperCAmelCase						,			__UpperCAmelCase :       Optional[Any]  						=  self.model_tester.prepare_config_and_inputs_for_common()
							__UpperCAmelCase :       Any  						=  True

							__UpperCAmelCase :       int  						=  getattr(self.model_tester							,    '''seq_length'''							,    lowercase__)
							__UpperCAmelCase :       List[str]  						=  getattr(self.model_tester							,    '''encoder_seq_length'''							,    lowercase__)
							__UpperCAmelCase :       List[Any]  						=  getattr(self.model_tester							,    '''key_length'''							,    lowercase__)
							__UpperCAmelCase :       Any  						=  getattr(self.model_tester							,    '''chunk_length'''							,    lowercase__)

							if chunk_length is not None and hasattr(self.model_tester							,    '''num_hashes'''):
													__UpperCAmelCase :       List[Any]  						=  encoder_seq_length * self.model_tester.num_hashes

							for model_class in self.all_model_classes:
													__UpperCAmelCase :       List[str]  						=  True
													__UpperCAmelCase :       List[Any]  						=  False
													__UpperCAmelCase :       Any  						=  True
													__UpperCAmelCase :       List[str]  						=  model_class(lowercase__)

													__UpperCAmelCase :       Tuple  						=  model(**self._prepare_for_class(lowercase__							,    lowercase__)							,    training=lowercase__)
													__UpperCAmelCase :       Union[str, Any]  						=  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"]
													__UpperCAmelCase :       List[str]  						=  True
													__UpperCAmelCase :       Optional[int]  						=  model_class(lowercase__)
													__UpperCAmelCase :       Optional[int]  						=  model(**self._prepare_for_class(lowercase__							,    lowercase__)							,    training=lowercase__)

													__UpperCAmelCase :       Optional[Any]  						=  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    A(						self):
							# We use a simplified version of this test for EfficientFormer because it requires training=False
							# and Keras refuses to let us force that during functional construction
							__UpperCAmelCase						,			__UpperCAmelCase :       Optional[Any]  						=  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													# Prepare our model
													__UpperCAmelCase :       List[Any]  						=  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
													__UpperCAmelCase :       Optional[int]  						=  {
													    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
													}
													__UpperCAmelCase :       Union[str, Any]  						=  model(lowercase__)
													self.assertTrue(outputs_dict is not None)






def 						__SCREAMING_SNAKE_CASE       (					)		->    List[Any]:




						'''simple docstring'''







						__UpperCAmelCase :       List[Any]  						=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
						return image





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


	@cached_property
	def    A(						self):
							return (
							    EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300''')
							    if is_vision_available()
							    else None
							)


	@slow
	def    A(						self):
							__UpperCAmelCase :       List[str]  						=  TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300''')
							__UpperCAmelCase :       str  						=  self.default_image_processor
							__UpperCAmelCase :       str  						=  prepare_img()
							__UpperCAmelCase :       List[str]  						=  image_processor(images=lowercase__							,    return_tensors='''tf''')
							# forward pass
							__UpperCAmelCase :       Any  						=  model(**lowercase__							,    training=lowercase__)
							# verify the logits
							__UpperCAmelCase :       Optional[Any]  						=  tf.TensorShape((1, 1_0_0_0))
							self.assertEqual(outputs.logits.shape							,    lowercase__)
							__UpperCAmelCase :       List[str]  						=  tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2])
							self.assertTrue(np.allclose(outputs.logits[0, :3]							,    lowercase__							,    atol=1e-4))


	@slow
	def    A(						self):
							__UpperCAmelCase :       Union[str, Any]  						=  TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
							    '''snap-research/efficientformer-l1-300''')
							__UpperCAmelCase :       Optional[Any]  						=  self.default_image_processor
							__UpperCAmelCase :       Any  						=  prepare_img()
							__UpperCAmelCase :       List[Any]  						=  image_processor(images=lowercase__							,    return_tensors='''tf''')
							# forward pass
							__UpperCAmelCase :       Union[str, Any]  						=  model(**lowercase__							,    training=lowercase__)
							# verify the logits
							__UpperCAmelCase :       Union[str, Any]  						=  tf.TensorShape((1, 1_0_0_0))
							self.assertEqual(outputs.logits.shape							,    lowercase__)
							__UpperCAmelCase :       str  						=  tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9])
							self.assertTrue(np.allclose(outputs.logits[0, :3]							,    lowercase__							,    atol=1e-4))





from typing import TYPE_CHECKING

from ....utils import _LazyModule


lowerCAmelCase							=						{"""tokenization_tapex""": ["""TapexTokenizer"""]}


if TYPE_CHECKING:
				from .tokenization_tapex import TapexTokenizer


else:
				import sys

				lowerCAmelCase							=						_LazyModule(__name__, globals()["""__file__"""], _import_structure)

