






'''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    A_	:
							"""simple docstring"""




							def __init__(		self			:str       ,							lowerCAmelCase__			:Dict       ,							lowerCAmelCase__			:int = 13       ,							lowerCAmelCase__			:int = 64       ,							lowerCAmelCase__			:int = 2       ,							lowerCAmelCase__			:int = 3       ,							lowerCAmelCase__			:int = 3       ,							lowerCAmelCase__			:bool = True       ,							lowerCAmelCase__			:bool = True       ,							lowerCAmelCase__			:int = 128       ,							lowerCAmelCase__			:List[str]=[16, 32, 64, 128]       ,							lowerCAmelCase__			:int = 7       ,							lowerCAmelCase__			:int = 4       ,							lowerCAmelCase__			:int = 37       ,							lowerCAmelCase__			:str = "gelu"       ,							lowerCAmelCase__			:float = 0.1       ,							lowerCAmelCase__			:float = 0.1       ,							lowerCAmelCase__			:int = 10       ,							lowerCAmelCase__			:float = 0.0_2       ,							lowerCAmelCase__			:int = 2       ,							lowerCAmelCase__			:int = 1       ,							lowerCAmelCase__			:int = 128       ,							lowerCAmelCase__			:List[int] = [2, 2, 2, 2]       ,							lowerCAmelCase__			:int = 2       ,							lowerCAmelCase__			:int = 2       ,							)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Union[str, Any]   =       parent
										snake_case_				:					Dict   =       batch_size
										snake_case_				:					Dict   =       image_size
										snake_case_				:					List[str]   =       patch_size
										snake_case_				:					Tuple   =       num_channels
										snake_case_				:					List[Any]   =       is_training
										snake_case_				:					Union[str, Any]   =       use_labels
										snake_case_				:					Tuple   =       hidden_size
										snake_case_				:					Tuple   =       num_hidden_layers
										snake_case_				:					Optional[int]   =       num_attention_heads
										snake_case_				:					Tuple   =       intermediate_size
										snake_case_				:					Tuple   =       hidden_act
										snake_case_				:					Union[str, Any]   =       hidden_dropout_prob
										snake_case_				:					int   =       attention_probs_dropout_prob
										snake_case_				:					Union[str, Any]   =       type_sequence_label_size
										snake_case_				:					Optional[int]   =       initializer_range
										snake_case_				:					int   =       encoder_stride
										snake_case_				:					Dict   =       num_attention_outputs
										snake_case_				:					Union[str, Any]   =       embed_dim
										snake_case_				:					str   =       embed_dim + 1
										snake_case_				:					Optional[int]   =       resolution
										snake_case_				:					List[Any]   =       depths
										snake_case_				:					Union[str, Any]   =       hidden_sizes
										snake_case_				:					List[str]   =       dim
										snake_case_				:					int   =       mlp_expansion_ratio

							def 							_A	(		self			:Optional[int]				)				->  Union[str, Any]:


										'''simple docstring'''




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

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

										snake_case_				:					Tuple   =       self.get_config()

										return config, pixel_values, labels

							def 							_A	(		self			:int				)				->  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=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			:Tuple       ,							lowerCAmelCase__			:Optional[int]       ,							lowerCAmelCase__			:List[str]       ,							lowerCAmelCase__			:int				)				->  Any:


										'''simple docstring'''




										snake_case_				:					List[Any]   =       TFEfficientFormerModel(config=lowerCAmelCase__				)
										snake_case_				:					Tuple   =       model(lowerCAmelCase__       ,							training=lowerCAmelCase__				)
										self.parent.assertEqual(result.last_hidden_state.shape       ,							(self.batch_size, self.seq_length, self.hidden_size)				)

							def 							_A	(		self			:str       ,							lowerCAmelCase__			:int       ,							lowerCAmelCase__			:str       ,							lowerCAmelCase__			:Union[str, Any]				)				->  List[str]:


										'''simple docstring'''




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

										# test greyscale images
										snake_case_				:					str   =       1
										snake_case_				:					Tuple   =       TFEfficientFormerForImageClassification(lowerCAmelCase__				)

										snake_case_				:					Union[str, Any]   =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
										snake_case_				:					Dict   =       model(lowerCAmelCase__       ,							labels=lowerCAmelCase__				)
										self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.type_sequence_label_size)				)






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


										'''simple docstring'''




										snake_case_				:					Any   =       self.prepare_config_and_inputs()
										snake_case_				:					Union[str, Any]   =       config_and_inputs
										snake_case_				:					Any   =       {"pixel_values": pixel_values}
										return config, inputs_dict







@require_tf
class    A_	(a_						,					a_						,					unittest.TestCase							):
							"""simple docstring"""




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

							a__   		=	False

							a__   		=	False
							a__   		=	False
							a__   		=	False
							a__   		=	False

							def 							_A	(		self			:Optional[Any]				)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Dict   =       TFEfficientFormerModelTester(self				)
										snake_case_				:					Union[str, Any]   =       ConfigTester(
										    self       ,							config_class=lowerCAmelCase__       ,							has_text_modality=lowerCAmelCase__       ,							hidden_size=37				)

							def 							_A	(		self			:List[Any]				)				->  Dict:


										'''simple docstring'''




										self.config_tester.run_common_tests()

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


										'''simple docstring'''




										pass

							@unittest.skip(reason="EfficientFormer does not support input and output embeddings"				)
							def 							_A	(		self			:Union[str, Any]				)				->  Union[str, Any]:


										'''simple docstring'''




										pass

							def 							_A	(		self			:List[Any]				)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Dict   =       self.model_tester.prepare_config_and_inputs_for_common()

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

													snake_case_				:					Optional[int]   =       ["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,							lowerCAmelCase__				)

							def 							_A	(		self			:Dict				)				->  Any:


										'''simple docstring'''




										def check_hidden_states_output(lowerCAmelCase__			:Any       ,							lowerCAmelCase__			:List[str]       ,							lowerCAmelCase__			:List[str]				):
													snake_case_				:					Dict   =       model_class(lowerCAmelCase__				)

													snake_case_				:					Union[str, Any]   =       model(**self._prepare_for_class(lowerCAmelCase__       ,							lowerCAmelCase__				)       ,							training=lowerCAmelCase__				)
													snake_case_				:					List[str]   =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

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

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

										snake_case_				:					Union[str, Any]   =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													snake_case_				:					Optional[Any]   =       True
													check_hidden_states_output(lowerCAmelCase__       ,							lowerCAmelCase__       ,							lowerCAmelCase__				)

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

													check_hidden_states_output(lowerCAmelCase__       ,							lowerCAmelCase__       ,							lowerCAmelCase__				)

							def 							_A	(		self			:Union[str, Any]       ,							lowerCAmelCase__			:int       ,							lowerCAmelCase__			:Any       ,							lowerCAmelCase__			:str=False				)				->  Dict:


										'''simple docstring'''




										snake_case_				:					int   =       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			:Union[str, Any]				)				->  Optional[int]:


										'''simple docstring'''




										snake_case_				:					Dict   =       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			:Optional[int]				)				->  List[str]:


										'''simple docstring'''




										snake_case_				:					Dict   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase__				)

							def 							_A	(		self			:Dict				)				->  int:


										'''simple docstring'''




										snake_case_				:					Tuple   =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__				)

							@slow
							def 							_A	(		self			:Optional[int]				)				->  List[str]:


										'''simple docstring'''




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

							def 							_A	(		self			:Union[str, Any]				)				->  str:


										'''simple docstring'''




										snake_case_				:					Tuple   =       self.model_tester.prepare_config_and_inputs_for_common()
										snake_case_				:					Union[str, Any]   =       True

										snake_case_				:					Tuple   =       getattr(self.model_tester       ,							"seq_length"       ,							lowerCAmelCase__				)
										snake_case_				:					Tuple   =       getattr(self.model_tester       ,							"encoder_seq_length"       ,							lowerCAmelCase__				)
										snake_case_				:					List[str]   =       getattr(self.model_tester       ,							"key_length"       ,							lowerCAmelCase__				)
										snake_case_				:					Optional[Any]   =       getattr(self.model_tester       ,							"chunk_length"       ,							lowerCAmelCase__				)

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

										for model_class in self.all_model_classes:
													snake_case_				:					Optional[int]   =       True
													snake_case_				:					List[Any]   =       False
													snake_case_				:					Tuple   =       True
													snake_case_				:					Any   =       model_class(lowerCAmelCase__				)

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

													snake_case_				:					List[str]   =       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			:Tuple				)				->  List[str]:


										'''simple docstring'''




										snake_case_				:					Tuple   =       self.model_tester.prepare_config_and_inputs_for_common()

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

def 	__UpperCAmelCase       ( )->    Tuple:



			"""simple docstring"""



			snake_case_				:					List[str]   =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
			return image







@require_tf
@require_vision
class    A_	(unittest.TestCase							):
							"""simple docstring"""




							@cached_property
							def 							_A	(		self			:List[Any]				)				->  Optional[int]:


										'''simple docstring'''




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

							@slow
							def 							_A	(		self			:Optional[Any]				)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Any   =       TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"				)
										snake_case_				:					Dict   =       self.default_image_processor
										snake_case_				:					Optional[Any]   =       prepare_img()
										snake_case_				:					Any   =       image_processor(images=lowerCAmelCase__       ,							return_tensors="tf"				)
										# forward pass
										snake_case_				:					int   =       model(**lowerCAmelCase__       ,							training=lowerCAmelCase__				)
										# verify the logits
										snake_case_				:					int   =       tf.TensorShape((1, 1_000)				)
										self.assertEqual(outputs.logits.shape       ,							lowerCAmelCase__				)
										snake_case_				:					Union[str, Any]   =       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]       ,							lowerCAmelCase__       ,							atol=1E-4				)				)






							@slow
							def 							_A	(		self			:Tuple				)				->  Dict:


										'''simple docstring'''




										snake_case_				:					Optional[int]   =       TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
										    "snap-research/efficientformer-l1-300"				)
										snake_case_				:					Optional[int]   =       self.default_image_processor
										snake_case_				:					str   =       prepare_img()
										snake_case_				:					Union[str, Any]   =       image_processor(images=lowerCAmelCase__       ,							return_tensors="tf"				)
										# forward pass
										snake_case_				:					List[Any]   =       model(**lowerCAmelCase__       ,							training=lowerCAmelCase__				)
										# verify the logits
										snake_case_				:					Optional[int]   =       tf.TensorShape((1, 1_000)				)
										self.assertEqual(outputs.logits.shape       ,							lowerCAmelCase__				)
										snake_case_				:					Any   =       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]       ,							lowerCAmelCase__       ,							atol=1E-4				)				)












'''simple docstring'''




import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu







@require_cpu
class    A_	(unittest.TestCase							):
							"""simple docstring"""




							def 							_A	(		self			:str				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_				:					Union[str, Any]   =       torch.nn.Linear(10       ,							10				)
										snake_case_				:					Dict   =       torch.optim.SGD(model.parameters()       ,							0.1				)
										snake_case_				:					Tuple   =       Accelerator()
										snake_case_				:					Optional[Any]   =       accelerator.prepare(lowerCAmelCase__				)
										try:
													pickle.loads(pickle.dumps(lowerCAmelCase__				)				)
										except Exception as e:
													self.fail(F'''Accelerated optimizer pickling failed with {e}'''				)
										AcceleratorState._reset_state()




