
"""simple docstring"""





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




		"""simple docstring"""





		def __init__(	self				,    lowerCAmelCase__				,    lowerCAmelCase__ = 1_3				,    lowerCAmelCase__ = 6_4				,    lowerCAmelCase__ = 2				,    lowerCAmelCase__ = 3				,    lowerCAmelCase__ = 3				,    lowerCAmelCase__ = True				,    lowerCAmelCase__ = True				,    lowerCAmelCase__ = 1_2_8				,    lowerCAmelCase__=[1_6, 3_2, 6_4, 1_2_8]				,    lowerCAmelCase__ = 7				,    lowerCAmelCase__ = 4				,    lowerCAmelCase__ = 3_7				,    lowerCAmelCase__ = "gelu"				,    lowerCAmelCase__ = 0.1				,    lowerCAmelCase__ = 0.1				,    lowerCAmelCase__ = 1_0				,    lowerCAmelCase__ = 0.02				,    lowerCAmelCase__ = 2				,    lowerCAmelCase__ = 1				,    lowerCAmelCase__ = 1_2_8				,    lowerCAmelCase__ = [2, 2, 2, 2]				,    lowerCAmelCase__ = 2				,    lowerCAmelCase__ = 2				,    ):
				__SCREAMING_SNAKE_CASE				=					parent
				__SCREAMING_SNAKE_CASE				=					batch_size
				__SCREAMING_SNAKE_CASE				=					image_size
				__SCREAMING_SNAKE_CASE				=					patch_size
				__SCREAMING_SNAKE_CASE				=					num_channels
				__SCREAMING_SNAKE_CASE				=					is_training
				__SCREAMING_SNAKE_CASE				=					use_labels
				__SCREAMING_SNAKE_CASE				=					hidden_size
				__SCREAMING_SNAKE_CASE				=					num_hidden_layers
				__SCREAMING_SNAKE_CASE				=					num_attention_heads
				__SCREAMING_SNAKE_CASE				=					intermediate_size
				__SCREAMING_SNAKE_CASE				=					hidden_act
				__SCREAMING_SNAKE_CASE				=					hidden_dropout_prob
				__SCREAMING_SNAKE_CASE				=					attention_probs_dropout_prob
				__SCREAMING_SNAKE_CASE				=					type_sequence_label_size
				__SCREAMING_SNAKE_CASE				=					initializer_range
				__SCREAMING_SNAKE_CASE				=					encoder_stride
				__SCREAMING_SNAKE_CASE				=					num_attention_outputs
				__SCREAMING_SNAKE_CASE				=					embed_dim
				__SCREAMING_SNAKE_CASE				=					embed_dim + 1
				__SCREAMING_SNAKE_CASE				=					resolution
				__SCREAMING_SNAKE_CASE				=					depths
				__SCREAMING_SNAKE_CASE				=					hidden_sizes
				__SCREAMING_SNAKE_CASE				=					dim
				__SCREAMING_SNAKE_CASE				=					mlp_expansion_ratio




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

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

				__SCREAMING_SNAKE_CASE				=					self.get_config()

				return config, pixel_values, labels




		def       snake_case_	(	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=lowerCAmelCase_				,    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				,    lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE				=					TFEfficientFormerModel(config=lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					model(lowerCAmelCase_				,    training=lowerCAmelCase_)
				self.parent.assertEqual(result.last_hidden_state.shape				,    (self.batch_size, self.seq_length, self.hidden_size))




		def       snake_case_	(	self				,    lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE				=					self.type_sequence_label_size
				__SCREAMING_SNAKE_CASE				=					TFEfficientFormerForImageClassification(lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					model(lowerCAmelCase_				,    labels=lowerCAmelCase_				,    training=lowerCAmelCase_)
				self.parent.assertEqual(result.logits.shape				,    (self.batch_size, self.type_sequence_label_size))

				# test greyscale images
				__SCREAMING_SNAKE_CASE				=					1
				__SCREAMING_SNAKE_CASE				=					TFEfficientFormerForImageClassification(lowerCAmelCase_)

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




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



@require_tf
class 		SCREAMING_SNAKE_CASE_					(		__UpperCAmelCase	,							__UpperCAmelCase	,							unittest.TestCase					):




		"""simple docstring"""





		__lowercase				:    List[str]		  =						(
		    (
		        TFEfficientFormerModel,
		        TFEfficientFormerForImageClassificationWithTeacher,
		        TFEfficientFormerForImageClassification,
		    )
		    if is_tf_available()
		    else ()
		)
		__lowercase				:    List[str]		  =						(
		    {
		        'feature-extraction': TFEfficientFormerModel,
		        'image-classification': (
		            TFEfficientFormerForImageClassification,
		            TFEfficientFormerForImageClassificationWithTeacher,
		        ),
		    }
		    if is_tf_available()
		    else {}
		)

		__lowercase				:    List[Any]		  =						False

		__lowercase				:    Optional[Any]		  =						False
		__lowercase				:    List[str]		  =						False
		__lowercase				:    Optional[Any]		  =						False
		__lowercase				:    str		  =						False




		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					TFEfficientFormerModelTester(self)
				__SCREAMING_SNAKE_CASE				=					ConfigTester(
				    self				,    config_class=lowerCAmelCase_				,    has_text_modality=lowerCAmelCase_				,    hidden_size=3_7)




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




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




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




		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs_for_common()

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

						__SCREAMING_SNAKE_CASE				=					['pixel_values']
						self.assertListEqual(arg_names[:1]				,    lowerCAmelCase_)




		def       snake_case_	(	self):
				def check_hidden_states_output(lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE				=					model_class(lowerCAmelCase_)

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

						__SCREAMING_SNAKE_CASE				=					getattr(
						    self.model_tester				,    """expected_num_hidden_layers"""				,    self.model_tester.num_hidden_layers + 1)
						self.assertEqual(len(lowerCAmelCase_)				,    lowerCAmelCase_)

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

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

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

				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						__SCREAMING_SNAKE_CASE				=					True
						check_hidden_states_output(lowerCAmelCase_				,    lowerCAmelCase_				,    lowerCAmelCase_)

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

						check_hidden_states_output(lowerCAmelCase_				,    lowerCAmelCase_				,    lowerCAmelCase_)




		def       snake_case_	(	self				,    lowerCAmelCase__				,    lowerCAmelCase__				,    lowerCAmelCase__=False):
				__SCREAMING_SNAKE_CASE				=					super()._prepare_for_class(lowerCAmelCase_				,    lowerCAmelCase_				,    return_labels=lowerCAmelCase_)

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

				return inputs_dict




		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCAmelCase_)




		@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet""")
		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_)




		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_)




		@slow
		def       snake_case_	(	self):
				for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						__SCREAMING_SNAKE_CASE				=					TFEfficientFormerModel.from_pretrained(lowerCAmelCase_)
						self.assertIsNotNone(lowerCAmelCase_)




		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs_for_common()
				__SCREAMING_SNAKE_CASE				=					True

				__SCREAMING_SNAKE_CASE				=					getattr(self.model_tester				,    """seq_length"""				,    lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					getattr(self.model_tester				,    """encoder_seq_length"""				,    lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					getattr(self.model_tester				,    """key_length"""				,    lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					getattr(self.model_tester				,    """chunk_length"""				,    lowerCAmelCase_)

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

				for model_class in self.all_model_classes:
						__SCREAMING_SNAKE_CASE				=					True
						__SCREAMING_SNAKE_CASE				=					False
						__SCREAMING_SNAKE_CASE				=					True
						__SCREAMING_SNAKE_CASE				=					model_class(lowerCAmelCase_)

						__SCREAMING_SNAKE_CASE				=					model(**self._prepare_for_class(lowerCAmelCase_				,    lowerCAmelCase_)				,    training=lowerCAmelCase_)
						__SCREAMING_SNAKE_CASE				=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
						self.assertEqual(len(lowerCAmelCase_)				,    self.model_tester.num_attention_outputs)

						# check that output_attentions also work using config
						del inputs_dict["output_attentions"]
						__SCREAMING_SNAKE_CASE				=					True
						__SCREAMING_SNAKE_CASE				=					model_class(lowerCAmelCase_)
						__SCREAMING_SNAKE_CASE				=					model(**self._prepare_for_class(lowerCAmelCase_				,    lowerCAmelCase_)				,    training=lowerCAmelCase_)

						__SCREAMING_SNAKE_CASE				=					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
						self.assertEqual(len(lowerCAmelCase_)				,    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):
				# 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
				__SCREAMING_SNAKE_CASE				=					self.model_tester.prepare_config_and_inputs_for_common()

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



def 		_lowerCAmelCase							(							):
		__SCREAMING_SNAKE_CASE				=					Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""							)
		return image
@require_tf
@require_vision
class 		SCREAMING_SNAKE_CASE_					(		unittest.TestCase					):




		"""simple docstring"""





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




		@slow
		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					TFEfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300""")
				__SCREAMING_SNAKE_CASE				=					self.default_image_processor
				__SCREAMING_SNAKE_CASE				=					prepare_img()
				__SCREAMING_SNAKE_CASE				=					image_processor(images=lowerCAmelCase_				,    return_tensors="""tf""")
				# forward pass
				__SCREAMING_SNAKE_CASE				=					model(**lowerCAmelCase_				,    training=lowerCAmelCase_)
				# verify the logits
				__SCREAMING_SNAKE_CASE				=					tf.TensorShape((1, 1_0_0_0))
				self.assertEqual(outputs.logits.shape				,    lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					tf.constant([-0.05_55, 0.48_25, -0.08_52])
				self.assertTrue(np.allclose(outputs.logits[0, :3]				,    lowerCAmelCase_				,    atol=1E-4))




		@slow
		def       snake_case_	(	self):
				__SCREAMING_SNAKE_CASE				=					TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
				    """snap-research/efficientformer-l1-300""")
				__SCREAMING_SNAKE_CASE				=					self.default_image_processor
				__SCREAMING_SNAKE_CASE				=					prepare_img()
				__SCREAMING_SNAKE_CASE				=					image_processor(images=lowerCAmelCase_				,    return_tensors="""tf""")
				# forward pass
				__SCREAMING_SNAKE_CASE				=					model(**lowerCAmelCase_				,    training=lowerCAmelCase_)
				# verify the logits
				__SCREAMING_SNAKE_CASE				=					tf.TensorShape((1, 1_0_0_0))
				self.assertEqual(outputs.logits.shape				,    lowerCAmelCase_)
				__SCREAMING_SNAKE_CASE				=					tf.constant([-0.13_12, 0.43_53, -1.04_99])
				self.assertTrue(np.allclose(outputs.logits[0, :3]				,    lowerCAmelCase_				,    atol=1E-4))












"""simple docstring"""
class _lowerCAmelCase						:







						def __init__(    self   ,				lowerCAmelCase_							)		->							None:
										_SCREAMING_SNAKE_CASE   :		Dict       		=    size
										_SCREAMING_SNAKE_CASE   :		str       		=    [0] * size
										_SCREAMING_SNAKE_CASE   :		Any       		=    [0] * size







						@staticmethod
						def 			A      (    lowerCAmelCase_							)		->							int:
										return index | (index + 1)







						@staticmethod
						def 			A      (    lowerCAmelCase_							)		->							int:
										return (index & (index + 1)) - 1







						def 			A      (    self   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)		->							None:
										_SCREAMING_SNAKE_CASE   :		str       		=    value
										while index < self.size:
														_SCREAMING_SNAKE_CASE   :		List[str]       		=    self.get_prev(lowerCAmelCase_							) + 1
														if current_left_border == index:
																		_SCREAMING_SNAKE_CASE   :		List[str]       		=    value
														else:
																		_SCREAMING_SNAKE_CASE   :		Optional[Any]       		=    max(lowerCAmelCase_   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)
														_SCREAMING_SNAKE_CASE   :		str       		=    self.get_next(lowerCAmelCase_							)







						def 			A      (    self   ,				lowerCAmelCase_   ,				lowerCAmelCase_							)		->							int:
										right -= 1  # Because of right is exclusive
										_SCREAMING_SNAKE_CASE   :		List[Any]       		=    0
										while left <= right:
														_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    self.get_prev(lowerCAmelCase_							)
														if left <= current_left:
																		_SCREAMING_SNAKE_CASE   :		Union[str, Any]       		=    max(lowerCAmelCase_   ,				self.tree[right]							)
																		_SCREAMING_SNAKE_CASE   :		List[Any]       		=    current_left
														else:
																		_SCREAMING_SNAKE_CASE   :		List[str]       		=    max(lowerCAmelCase_   ,				self.arr[right]							)
																		right -= 1
										return result


if __name__ == "__main__":
			import doctest

			doctest.testmod()

