


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__ = 13    ,			lowerCAmelCase__ = 64    ,			lowerCAmelCase__ = 2    ,			lowerCAmelCase__ = 3    ,			lowerCAmelCase__ = 3    ,			lowerCAmelCase__ = True    ,			lowerCAmelCase__ = True    ,			lowerCAmelCase__ = 128    ,			lowerCAmelCase__=[16, 32, 64, 128]    ,			lowerCAmelCase__ = 7    ,			lowerCAmelCase__ = 4    ,			lowerCAmelCase__ = 37    ,			lowerCAmelCase__ = "gelu"    ,			lowerCAmelCase__ = 0.1    ,			lowerCAmelCase__ = 0.1    ,			lowerCAmelCase__ = 10    ,			lowerCAmelCase__ = 0.0_2    ,			lowerCAmelCase__ = 2    ,			lowerCAmelCase__ = 1    ,			lowerCAmelCase__ = 128    ,			lowerCAmelCase__ = [2, 2, 2, 2]    ,			lowerCAmelCase__ = 2    ,			lowerCAmelCase__ = 2    ,			) ->    Any:




        '''simple docstring'''
        lowercase__:       Any        =       parent
        lowercase__:       Optional[Any]        =       batch_size
        lowercase__:       Optional[Any]        =       image_size
        lowercase__:       Dict        =       patch_size
        lowercase__:       Tuple        =       num_channels
        lowercase__:       Any        =       is_training
        lowercase__:       List[Any]        =       use_labels
        lowercase__:       Optional[Any]        =       hidden_size
        lowercase__:       Any        =       num_hidden_layers
        lowercase__:       List[Any]        =       num_attention_heads
        lowercase__:       Any        =       intermediate_size
        lowercase__:       Optional[Any]        =       hidden_act
        lowercase__:       Union[str, Any]        =       hidden_dropout_prob
        lowercase__:       int        =       attention_probs_dropout_prob
        lowercase__:       Optional[Any]        =       type_sequence_label_size
        lowercase__:       List[str]        =       initializer_range
        lowercase__:       List[str]        =       encoder_stride
        lowercase__:       List[Any]        =       num_attention_outputs
        lowercase__:       str        =       embed_dim
        lowercase__:       Any        =       embed_dim + 1
        lowercase__:       List[str]        =       resolution
        lowercase__:       str        =       depths
        lowercase__:       Union[str, Any]        =       hidden_sizes
        lowercase__:       Any        =       dim
        lowercase__:       str        =       mlp_expansion_ratio
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       Tuple        =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

        lowercase__:       int        =       self.get_config()

        return config, pixel_values, labels
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''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 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    List[str]:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       TFEfficientFormerModel(config=lowerCAmelCase__			)
        lowercase__:       Tuple        =       model(lowerCAmelCase__    ,			training=lowerCAmelCase__			)
        self.parent.assertEqual(result.last_hidden_state.shape    ,			(self.batch_size, self.seq_length, self.hidden_size)			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__			) ->    str:




        '''simple docstring'''
        lowercase__:       Any        =       self.type_sequence_label_size
        lowercase__:       Tuple        =       TFEfficientFormerForImageClassification(lowerCAmelCase__			)
        lowercase__:       Tuple        =       model(lowerCAmelCase__    ,			labels=lowerCAmelCase__    ,			training=lowerCAmelCase__			)
        self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.type_sequence_label_size)			)

        # test greyscale images
        lowercase__:       str        =       1
        lowercase__:       int        =       TFEfficientFormerForImageClassification(lowerCAmelCase__			)

        lowercase__:       Tuple        =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]			)
        lowercase__:       Tuple        =       model(lowerCAmelCase__    ,			labels=lowerCAmelCase__			)
        self.parent.assertEqual(result.logits.shape    ,			(self.batch_size, self.type_sequence_label_size)			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        lowercase__:       Tuple        =       self.prepare_config_and_inputs()
        lowercase__      ,						lowercase__      ,						lowercase__:       Dict        =       config_and_inputs
        lowercase__:       str        =       {'pixel_values': pixel_values}
        return config, inputs_dict





@require_tf
class   __a      (   __UpperCamelCase	,	__UpperCamelCase	,	unittest.TestCase				):
 __lowercase			:							Any       					=			(
     (
         TFEfficientFormerModel,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerForImageClassification,
     )
     if is_tf_available()
     else ()
 )
 __lowercase			:							Dict       					=			(
     {
         'feature-extraction': TFEfficientFormerModel,
         'image-classification': (
             TFEfficientFormerForImageClassification,
             TFEfficientFormerForImageClassificationWithTeacher,
         ),
     }
     if is_tf_available()
     else {}
 )

 __lowercase			:							Optional[Any]       					=			False

 __lowercase			:							Tuple       					=			False
 __lowercase			:							str       					=			False
 __lowercase			:							List[Any]       					=			False
 __lowercase			:							Any       					=			False
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Dict:




        '''simple docstring'''
        lowercase__:       Tuple        =       TFEfficientFormerModelTester(self			)
        lowercase__:       Optional[int]        =       ConfigTester(
            self    ,			config_class=lowerCAmelCase__    ,			has_text_modality=lowerCAmelCase__    ,			hidden_size=37			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[Any]:




        '''simple docstring'''
        self.config_tester.run_common_tests()
 @unittest.skip(reason='EfficientFormer does not use inputs_embeds'			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        pass
 @unittest.skip(reason='EfficientFormer does not support input and output embeddings'			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[Any]:




        '''simple docstring'''
        pass
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[int]:




        '''simple docstring'''
        lowercase__      ,						lowercase__:       Union[str, Any]        =       self.model_tester.prepare_config_and_inputs_for_common()

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

               lowercase__:       Tuple        =       ['pixel_values']
               self.assertListEqual(arg_names[:1]    ,			lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[Any]:




        '''simple docstring'''
        def check_hidden_states_output(lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__			):
               lowercase__:       Optional[int]        =       model_class(lowerCAmelCase__			)

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

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

                      self.asseretIsInstance(lowerCAmelCase__    ,			(list, tuple)			)
                      self.assertEqual(len(lowerCAmelCase__			)    ,			lowerCAmelCase__			)
                      lowercase__:       Optional[Any]        =       getattr(self.model_tester    ,			'seq_length'    ,			lowerCAmelCase__			)
                      lowercase__:       Tuple        =       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__:       str        =       self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               lowercase__:       Dict        =       True
               check_hidden_states_output(lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__			)

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

               check_hidden_states_output(lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__=False			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       Optional[Any]        =       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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       str        =       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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Dict:




        '''simple docstring'''
        lowercase__:       str        =       self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__			)
 @slow
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Dict:




        '''simple docstring'''
        for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase__:       Tuple        =       TFEfficientFormerModel.from_pretrained(lowerCAmelCase__			)
               self.assertIsNotNone(lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    str:




        '''simple docstring'''
        lowercase__      ,						lowercase__:       str        =       self.model_tester.prepare_config_and_inputs_for_common()
        lowercase__:       int        =       True

        lowercase__:       Any        =       getattr(self.model_tester    ,			'seq_length'    ,			lowerCAmelCase__			)
        lowercase__:       Union[str, Any]        =       getattr(self.model_tester    ,			'encoder_seq_length'    ,			lowerCAmelCase__			)
        lowercase__:       Union[str, Any]        =       getattr(self.model_tester    ,			'key_length'    ,			lowerCAmelCase__			)
        lowercase__:       Dict        =       getattr(self.model_tester    ,			'chunk_length'    ,			lowerCAmelCase__			)

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

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

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

               lowercase__:       Dict        =       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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        # 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__:       Dict        =       self.model_tester.prepare_config_and_inputs_for_common()

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





def        snake_case_					(  )  ->    Tuple:
       lowercase__:       Dict        =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
       return image





@require_tf
@require_vision
class   __a      (   unittest.TestCase				):
 @cached_property
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''simple docstring'''
        return (
            EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300'			)
            if is_vision_available()
            else None
        )
 @slow
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        lowercase__:       str        =       TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'			)
        lowercase__:       Tuple        =       self.default_image_processor
        lowercase__:       str        =       prepare_img()
        lowercase__:       Union[str, Any]        =       image_processor(images=lowerCAmelCase__    ,			return_tensors='tf'			)
        # forward pass
        lowercase__:       List[str]        =       model(**lowerCAmelCase__    ,			training=lowerCAmelCase__			)
        # verify the logits
        lowercase__:       List[str]        =       tf.TensorShape((1, 1_000)			)
        self.assertEqual(outputs.logits.shape    ,			lowerCAmelCase__			)
        lowercase__:       Dict        =       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 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




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






def        snake_case_					(  snake_case					)  ->    list[int]:
       lowercase__:       Dict        =       [0 for i in range(len(snake_case					)					)]

       # initialize interval's left pointer and right pointer
       lowercase__      ,						lowercase__:       Union[str, Any]        =       0, 0

       for i in range(1      ,							len(snake_case					)					):
              # case when current index is inside the interval
              if i <= right_pointer:
                     lowercase__:       List[Any]        =       min(right_pointer - i + 1      ,							z_result[i - left_pointer]					)
                     lowercase__:       List[str]        =       min_edge

              while go_next(snake_case      ,							snake_case      ,							snake_case					):
                     z_result[i] += 1

              # if new index's result gives us more right interval,
              # we've to update left_pointer and right_pointer
              if i + z_result[i] - 1 > right_pointer:
                     lowercase__      ,						lowercase__:       List[Any]        =       i, i + z_result[i] - 1

       return z_result




def        snake_case_					(  snake_case      ,							snake_case      ,							snake_case					)  ->    bool:
       return i + z_result[i] < len(snake_case					) and s[z_result[i]] == s[i + z_result[i]]




def        snake_case_					(  snake_case      ,							snake_case					)  ->    int:
       lowercase__:       Tuple        =       0
       # concatenate 'pattern' and 'input_str' and call z_function
       # with concatenated string
       lowercase__:       Any        =       z_function(pattern + input_str					)

       for val in z_result:
              # if value is greater then length of the pattern string
              # that means this index is starting position of substring
              # which is equal to pattern string
              if val >= len(snake_case					):
                     answer += 1

       return answer


if __name__ == "__main__":
 import doctest

 doctest.testmod()


