


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


							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      ,				):
									__lowercase=			parent
									__lowercase=			batch_size
									__lowercase=			image_size
									__lowercase=			patch_size
									__lowercase=			num_channels
									__lowercase=			is_training
									__lowercase=			use_labels
									__lowercase=			hidden_size
									__lowercase=			num_hidden_layers
									__lowercase=			num_attention_heads
									__lowercase=			intermediate_size
									__lowercase=			hidden_act
									__lowercase=			hidden_dropout_prob
									__lowercase=			attention_probs_dropout_prob
									__lowercase=			type_sequence_label_size
									__lowercase=			initializer_range
									__lowercase=			encoder_stride
									__lowercase=			num_attention_outputs
									__lowercase=			embed_dim
									__lowercase=			embed_dim + 1
									__lowercase=			resolution
									__lowercase=			depths
									__lowercase=			hidden_sizes
									__lowercase=			dim
									__lowercase=			mlp_expansion_ratio


							def 			_A       (self					):
									__lowercase=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

									__lowercase=			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=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 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			TFEfficientFormerModel(config=lowerCAmelCase					)
									__lowercase=			model(lowerCAmelCase      ,				training=lowerCAmelCase					)
									self.parent.assertEqual(result.last_hidden_state.shape      ,				(self.batch_size, self.seq_length, self.hidden_size)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.type_sequence_label_size
									__lowercase=			TFEfficientFormerForImageClassification(lowerCAmelCase					)
									__lowercase=			model(lowerCAmelCase      ,				labels=lowerCAmelCase      ,				training=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.type_sequence_label_size)					)

									# test greyscale images
									__lowercase=			1
									__lowercase=			TFEfficientFormerForImageClassification(lowerCAmelCase					)

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







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





@require_tf
class       A    (   A_					,				A_					,				unittest.TestCase ):
							UpperCamelCase_   :							Union[str, Any]       =(
							    (
							        TFEfficientFormerModel,
							        TFEfficientFormerForImageClassificationWithTeacher,
							        TFEfficientFormerForImageClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							UpperCamelCase_   :							Optional[int]       =(
							    {
							        '''feature-extraction''': TFEfficientFormerModel,
							        '''image-classification''': (
							            TFEfficientFormerForImageClassification,
							            TFEfficientFormerForImageClassificationWithTeacher,
							        ),
							    }
							    if is_tf_available()
							    else {}
							)

							UpperCamelCase_   :							Optional[Any]       =False

							UpperCamelCase_   :							Dict       =False
							UpperCamelCase_   :							Tuple       =False
							UpperCamelCase_   :							Union[str, Any]       =False
							UpperCamelCase_   :							Tuple       =False


							def 			_A       (self					):
									__lowercase=			TFEfficientFormerModelTester(self					)
									__lowercase=			ConfigTester(
									    self      ,				config_class=lowerCAmelCase      ,				has_text_modality=lowerCAmelCase      ,				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					):
									__lowercase,							__lowercase=			self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase=			['pixel_values']
											self.assertListEqual(arg_names[:1]      ,				lowerCAmelCase					)


							def 			_A       (self					):
									def check_hidden_states_output(lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
											__lowercase=			model_class(lowerCAmelCase					)

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

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

													self.asseretIsInstance(lowerCAmelCase      ,				(list, tuple)					)
													self.assertEqual(len(lowerCAmelCase					)      ,				lowerCAmelCase					)
													__lowercase=			getattr(self.model_tester      ,				'seq_length'      ,				lowerCAmelCase					)
													__lowercase=			getattr(self.model_tester      ,				'decoder_seq_length'      ,				lowerCAmelCase					)

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

									__lowercase,							__lowercase=			self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											__lowercase=			True
											check_hidden_states_output(lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					)

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

											check_hidden_states_output(lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase=False					):
									__lowercase=			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 			_A       (self					):
									__lowercase=			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 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase					)


							@slow
							def 			_A       (self					):
									for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase=			TFEfficientFormerModel.from_pretrained(lowerCAmelCase					)
											self.assertIsNotNone(lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase,							__lowercase=			self.model_tester.prepare_config_and_inputs_for_common()
									__lowercase=			True

									__lowercase=			getattr(self.model_tester      ,				'seq_length'      ,				lowerCAmelCase					)
									__lowercase=			getattr(self.model_tester      ,				'encoder_seq_length'      ,				lowerCAmelCase					)
									__lowercase=			getattr(self.model_tester      ,				'key_length'      ,				lowerCAmelCase					)
									__lowercase=			getattr(self.model_tester      ,				'chunk_length'      ,				lowerCAmelCase					)

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

									for model_class in self.all_model_classes:
											__lowercase=			True
											__lowercase=			False
											__lowercase=			True
											__lowercase=			model_class(lowerCAmelCase					)

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

											__lowercase=			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 			_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
									__lowercase,							__lowercase=			self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
											# Prepare our model
											__lowercase=			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
											__lowercase=			{
											    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
											}
											__lowercase=			model(lowerCAmelCase					)
											self.assertTrue(outputs_dict is not None					)







def        _lowerCamelCase(	)						->	Optional[int]:

		'''simple docstring'''







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





@require_tf
@require_vision
class       A    (   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					):
									__lowercase=			TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'					)
									__lowercase=			self.default_image_processor
									__lowercase=			prepare_img()
									__lowercase=			image_processor(images=lowerCAmelCase      ,				return_tensors='tf'					)
									# forward pass
									__lowercase=			model(**lowerCAmelCase      ,				training=lowerCAmelCase					)
									# verify the logits
									__lowercase=			tf.TensorShape((1, 1_0_0_0)					)
									self.assertEqual(outputs.logits.shape      ,				lowerCAmelCase					)
									__lowercase=			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 			_A       (self					):
									__lowercase=			TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    'snap-research/efficientformer-l1-300'					)
									__lowercase=			self.default_image_processor
									__lowercase=			prepare_img()
									__lowercase=			image_processor(images=lowerCAmelCase      ,				return_tensors='tf'					)
									# forward pass
									__lowercase=			model(**lowerCAmelCase      ,				training=lowerCAmelCase					)
									# verify the logits
									__lowercase=			tf.TensorShape((1, 1_0_0_0)					)
									self.assertEqual(outputs.logits.shape      ,				lowerCAmelCase					)
									__lowercase=			tf.constant([-0.13_12, 0.43_53, -1.04_99]					)
									self.assertTrue(np.allclose(outputs.logits[0, :3]      ,				lowerCAmelCase      ,				atol=1E-4					)					)










from __future__ import annotations







def        _lowerCamelCase(	lowercase__	)						->	list[int]:

		'''simple docstring'''







		__lowercase=			2
		__lowercase=			[]
		while i * i <= n:
				if n % i:
						i += 1
				else:
						n //= i
						factors.append(lowercase__	)
		if n > 1:
				factors.append(lowercase__	)
		return factors


if __name__ == "__main__":
	import doctest

	doctest.testmod()






