




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







							def __init__(    self			:    List[str]				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    int = 13				,     lowerCAmelCase_			:    int = 64				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 3				,     lowerCAmelCase_			:    int = 3				,     lowerCAmelCase_			:    bool = True				,     lowerCAmelCase_			:    bool = True				,     lowerCAmelCase_			:    int = 1_28				,     lowerCAmelCase_			:    Any=[16, 32, 64, 1_28]				,     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 = 1_28				,     lowerCAmelCase_			:    List[int] = [2, 2, 2, 2]				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 2				,     )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							parent
														_a      	=							batch_size
														_a      	=							image_size
														_a      	=							patch_size
														_a      	=							num_channels
														_a      	=							is_training
														_a      	=							use_labels
														_a      	=							hidden_size
														_a      	=							num_hidden_layers
														_a      	=							num_attention_heads
														_a      	=							intermediate_size
														_a      	=							hidden_act
														_a      	=							hidden_dropout_prob
														_a      	=							attention_probs_dropout_prob
														_a      	=							type_sequence_label_size
														_a      	=							initializer_range
														_a      	=							encoder_stride
														_a      	=							num_attention_outputs
														_a      	=							embed_dim
														_a      	=							embed_dim + 1
														_a      	=							resolution
														_a      	=							depths
														_a      	=							hidden_sizes
														_a      	=							dim
														_a      	=							mlp_expansion_ratio







							def   __lowerCAmelCase     (    self			:    str   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

														_a      	=							self.get_config()

														return config, pixel_values, labels







							def   __lowerCAmelCase     (    self			:    Tuple   )     ->				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   __lowerCAmelCase     (    self			:    Optional[Any]				,     lowerCAmelCase_			:    Union[str, Any]				,     lowerCAmelCase_			:    str				,     lowerCAmelCase_			:    Dict   )     ->				List[str]:


														"""simple docstring"""


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







							def   __lowerCAmelCase     (    self			:    Tuple				,     lowerCAmelCase_			:    Any				,     lowerCAmelCase_			:    Dict				,     lowerCAmelCase_			:    Dict   )     ->				Tuple:


														"""simple docstring"""


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

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

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







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Optional[Any]:


														"""simple docstring"""


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



@require_tf
class      A       (						_a	,_a	,unittest.TestCase       ):
							lowercase_							     =							(
							    (
							        TFEfficientFormerModel,
							        TFEfficientFormerForImageClassificationWithTeacher,
							        TFEfficientFormerForImageClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase_							     =							(
							    {
							        'feature-extraction': TFEfficientFormerModel,
							        'image-classification': (
							            TFEfficientFormerForImageClassification,
							            TFEfficientFormerForImageClassificationWithTeacher,
							        ),
							    }
							    if is_tf_available()
							    else {}
							)

							lowercase_							     =							False

							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False







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


														"""simple docstring"""


														_a      	=							TFEfficientFormerModelTester(self   )
														_a      	=							ConfigTester(
														    self				,     config_class=lowerCAmelCase_				,     has_text_modality=lowerCAmelCase_				,     hidden_size=37   )







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


														"""simple docstring"""


														self.config_tester.run_common_tests()







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


														"""simple docstring"""


														pass







							@unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''   )
							def   __lowerCAmelCase     (    self			:    Any   )     ->				int:


														"""simple docstring"""


														pass







							def   __lowerCAmelCase     (    self			:    int   )     ->				Optional[int]:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

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







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


														"""simple docstring"""


														def check_hidden_states_output(lowerCAmelCase_			:    List[str]				,     lowerCAmelCase_			:    Optional[Any]				,     lowerCAmelCase_			:    Optional[int]   ):
																					_a      	=							model_class(lowerCAmelCase_   )

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

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

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

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

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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

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

																					check_hidden_states_output(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    str				,     lowerCAmelCase_			:    Any				,     lowerCAmelCase_			:    Optional[int]				,     lowerCAmelCase_			:    Any=False   )     ->				Dict:


														"""simple docstring"""


														_a      	=							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   __lowerCAmelCase     (    self			:    Optional[int]   )     ->				int:


														"""simple docstring"""


														_a      	=							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   __lowerCAmelCase     (    self			:    List[Any]   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_   )







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


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_   )







							@slow
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				Optional[Any]:


														"""simple docstring"""


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







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


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()
														_a      	=							True

														_a      	=							getattr(self.model_tester				,     '''seq_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''encoder_seq_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''key_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''chunk_length'''				,     lowerCAmelCase_   )

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

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

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

																					_a      	=							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   __lowerCAmelCase     (    self			:    int   )     ->				Optional[int]:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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



def 						snake_case_       ():





							'''simple docstring'''


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

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







							@cached_property
							def   __lowerCAmelCase     (    self			:    str   )     ->				Optional[Any]:


														"""simple docstring"""


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







							@slow
							def   __lowerCAmelCase     (    self			:    Any   )     ->				Optional[int]:


														"""simple docstring"""


														_a      	=							TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''   )
														_a      	=							self.default_image_processor
														_a      	=							prepare_img()
														_a      	=							image_processor(images=lowerCAmelCase_				,     return_tensors='''tf'''   )
														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# verify the logits
														_a      	=							tf.TensorShape((1, 10_00)   )
														self.assertEqual(outputs.logits.shape				,     lowerCAmelCase_   )
														_a      	=							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   __lowerCAmelCase     (    self			:    List[str]   )     ->				Union[str, Any]:


														"""simple docstring"""


														_a      	=							TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
														    '''snap-research/efficientformer-l1-300'''   )
														_a      	=							self.default_image_processor
														_a      	=							prepare_img()
														_a      	=							image_processor(images=lowerCAmelCase_				,     return_tensors='''tf'''   )
														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# verify the logits
														_a      	=							tf.TensorShape((1, 10_00)   )
														self.assertEqual(outputs.logits.shape				,     lowerCAmelCase_   )
														_a      	=							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 unittest

from transformers import is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, require_torch, slow


if is_flax_available():
				import optax
				from flax.training.common_utils import onehot

				from transformers import AutoTokenizer, FlaxMTaForConditionalGeneration
				from transformers.models.ta.modeling_flax_ta import shift_tokens_right

@require_torch
@require_sentencepiece
@require_tokenizers
@require_flax
class      A       (						unittest.TestCase       ):







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


														"""simple docstring"""


														_a      	=							FlaxMTaForConditionalGeneration.from_pretrained('''google/mt5-small'''   )
														_a      	=							AutoTokenizer.from_pretrained('''google/mt5-small'''   )

														_a      	=							tokenizer('''Hello there'''				,     return_tensors='''np'''   ).input_ids
														_a      	=							tokenizer('''Hi I am'''				,     return_tensors='''np'''   ).input_ids

														_a      	=							shift_tokens_right(lowerCAmelCase_				,     model.config.pad_token_id				,     model.config.decoder_start_token_id   )

														_a      	=							model(lowerCAmelCase_				,     decoder_input_ids=lowerCAmelCase_   ).logits
														_a      	=							optax.softmax_cross_entropy(lowerCAmelCase_				,     onehot(lowerCAmelCase_				,     logits.shape[-1]   )   ).mean()

														_a      	=							-(labels.shape[-1] * loss.item())

														_a      	=							-8_4.9_1_2_7
														self.assertTrue(abs(mtf_score - EXPECTED_SCORE   ) < 1e-4   )

