



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							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  str = 13  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any] = 64  ,	__SCREAMING_SNAKE_CASE							:  Dict = 2  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any] = 3  ,	__SCREAMING_SNAKE_CASE							:  int = 3  ,	__SCREAMING_SNAKE_CASE							:  int = True  ,	__SCREAMING_SNAKE_CASE							:  int = True  ,	__SCREAMING_SNAKE_CASE							:  Optional[int] = 128  ,	__SCREAMING_SNAKE_CASE							:  List[Any]=[16, 32, 64, 128]  ,	__SCREAMING_SNAKE_CASE							:  Tuple = 7  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any] = 4  ,	__SCREAMING_SNAKE_CASE							:  Dict = 37  ,	__SCREAMING_SNAKE_CASE							:  List[Any] = "gelu"  ,	__SCREAMING_SNAKE_CASE							:  str = 0.1  ,	__SCREAMING_SNAKE_CASE							:  int = 0.1  ,	__SCREAMING_SNAKE_CASE							:  Any = 10  ,	__SCREAMING_SNAKE_CASE							:  Optional[int] = 0.02  ,	__SCREAMING_SNAKE_CASE							:  Tuple = 2  ,	__SCREAMING_SNAKE_CASE							:  int = 1  ,	__SCREAMING_SNAKE_CASE							:  Dict = 128  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any] = [2, 2, 2, 2]  ,	__SCREAMING_SNAKE_CASE							:  Tuple = 2  ,	__SCREAMING_SNAKE_CASE							:  List[str] = 2  ,	):


         '''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							:  Optional[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							:  List[str]):


         '''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=_lowercase  ,	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							:  str  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any]):


         '''simple docstring'''

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



     def 	_lowerCamelCase    (	self							:  Tuple  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  List[Any]):


         '''simple docstring'''

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

         # test greyscale images
         __a		 =       1
         __a		 =       TFEfficientFormerForImageClassification(_lowercase)

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





     def 	_lowerCamelCase    (	self							:  Union[str, Any]):


         '''simple docstring'''

         __a		 =       self.prepare_config_and_inputs()
         __a		 =       config_and_inputs
         __a		 =       {"""pixel_values""": pixel_values}
         return config, inputs_dict


@require_tf
class 					_A (			__snake_case   ,__snake_case   ,unittest.TestCase					):
     UpperCamelCase__						:					Optional[Any]		      =		(
         (
             TFEfficientFormerModel,
             TFEfficientFormerForImageClassificationWithTeacher,
             TFEfficientFormerForImageClassification,
         )
         if is_tf_available()
         else ()
     )
     UpperCamelCase__						:					List[Any]		      =		(
         {
             '''feature-extraction''': TFEfficientFormerModel,
             '''image-classification''': (
                 TFEfficientFormerForImageClassification,
                 TFEfficientFormerForImageClassificationWithTeacher,
             ),
         }
         if is_tf_available()
         else {}
     )

     UpperCamelCase__						:					Any		      =		False

     UpperCamelCase__						:					Dict		      =		False
     UpperCamelCase__						:					List[Any]		      =		False
     UpperCamelCase__						:					Union[str, Any]		      =		False
     UpperCamelCase__						:					str		      =		False



     def 	_lowerCamelCase    (	self							:  Any):


         '''simple docstring'''

         __a		 =       TFEfficientFormerModelTester(self)
         __a		 =       ConfigTester(
             self  ,	config_class=_lowercase  ,	has_text_modality=_lowercase  ,	hidden_size=37)



     def 	_lowerCamelCase    (	self							:  Dict):


         '''simple docstring'''

         self.config_tester.run_common_tests()



     @unittest.skip(reason='''EfficientFormer does not use inputs_embeds''')
     def 	_lowerCamelCase    (	self							:  Any):


         '''simple docstring'''

         pass



     @unittest.skip(reason='''EfficientFormer does not support input and output embeddings''')
     def 	_lowerCamelCase    (	self							:  Optional[int]):


         '''simple docstring'''

         pass



     def 	_lowerCamelCase    (	self							:  List[str]):


         '''simple docstring'''

         __a		 =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __a		 =       model_class(_lowercase)
             __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]  ,	_lowercase)



     def 	_lowerCamelCase    (	self							:  int):


         '''simple docstring'''

         def check_hidden_states_output(__SCREAMING_SNAKE_CASE							:  Optional[int]  ,	__SCREAMING_SNAKE_CASE							:  Any  ,	__SCREAMING_SNAKE_CASE							:  str):
             __a		 =       model_class(_lowercase)

             __a		 =       model(**self._prepare_for_class(_lowercase  ,	_lowercase)  ,	training=_lowercase)
             __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(_lowercase)  ,	_lowercase)

             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(_lowercase  ,	(list, tuple))
                 self.assertEqual(len(_lowercase)  ,	_lowercase)
                 __a		 =       getattr(self.model_tester  ,	'''seq_length'''  ,	_lowercase)
                 __a		 =       getattr(self.model_tester  ,	'''decoder_seq_length'''  ,	_lowercase)

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

         __a		 =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __a		 =       True
             check_hidden_states_output(_lowercase  ,	_lowercase  ,	_lowercase)

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

             check_hidden_states_output(_lowercase  ,	_lowercase  ,	_lowercase)



     def 	_lowerCamelCase    (	self							:  List[str]  ,	__SCREAMING_SNAKE_CASE							:  Optional[Any]  ,	__SCREAMING_SNAKE_CASE							:  Union[str, Any]  ,	__SCREAMING_SNAKE_CASE							:  Optional[int]=False):


         '''simple docstring'''

         __a		 =       super()._prepare_for_class(_lowercase  ,	_lowercase  ,	return_labels=_lowercase)

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

         return inputs_dict



     def 	_lowerCamelCase    (	self							:  List[str]):


         '''simple docstring'''

         __a		 =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowercase)



     @unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet''')
     def 	_lowerCamelCase    (	self							:  List[str]):


         '''simple docstring'''

         __a		 =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*_lowercase)



     def 	_lowerCamelCase    (	self							:  Dict):


         '''simple docstring'''

         __a		 =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowercase)



     @slow
     def 	_lowerCamelCase    (	self							:  int):


         '''simple docstring'''

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



     def 	_lowerCamelCase    (	self							:  List[str]):


         '''simple docstring'''

         __a		 =       self.model_tester.prepare_config_and_inputs_for_common()
         __a		 =       True

         __a		 =       getattr(self.model_tester  ,	'''seq_length'''  ,	_lowercase)
         __a		 =       getattr(self.model_tester  ,	'''encoder_seq_length'''  ,	_lowercase)
         __a		 =       getattr(self.model_tester  ,	'''key_length'''  ,	_lowercase)
         __a		 =       getattr(self.model_tester  ,	'''chunk_length'''  ,	_lowercase)

         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(_lowercase)

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

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

             __a		 =       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
             self.assertEqual(len(_lowercase)  ,	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							:  Dict):


         '''simple docstring'''

         __a		 =       self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             # Prepare our model
             __a		 =       model_class(_lowercase)
             # 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=_lowercase)
                 for key, val in model.input_signature.items()
                 if key in model.dummy_inputs
             }
             __a		 =       model(_lowercase)
             self.assertTrue(outputs_dict is not None)





def   __snake_case			(    ):
    __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):


         '''simple docstring'''

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



     @slow
     def 	_lowerCamelCase    (	self							:  Union[str, Any]):


         '''simple docstring'''

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





     @slow
     def 	_lowerCamelCase    (	self							:  int):


         '''simple docstring'''

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










from typing import List

import jiwer
import jiwer.transforms as tr
from packaging import version

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('''3.8'''):
 import importlib_metadata
else:
 import importlib.metadata as importlib_metadata


__snake_case		:int   	=  ''''''


if version.parse(importlib_metadata.version('''jiwer''')) < version.parse('''2.3.0'''):

 class 					_A (			tr.AbstractTransform					):



        def __init__(	self							:  List[Any]  ,	__SCREAMING_SNAKE_CASE							:  str = " "):


            '''simple docstring'''

            __a		 =       sentence_delimiter



        def 	_lowerCamelCase    (	self							:  Dict  ,	__SCREAMING_SNAKE_CASE							:  str):


            '''simple docstring'''

            return list(__SCREAMING_SNAKE_CASE)





        def 	_lowerCamelCase    (	self							:  int  ,	__SCREAMING_SNAKE_CASE							:  List[str]):


            '''simple docstring'''

            __a		 =       []
            for sent_idx, sentence in enumerate(__SCREAMING_SNAKE_CASE):
                chars.extend(self.process_string(__SCREAMING_SNAKE_CASE))
                if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__SCREAMING_SNAKE_CASE) - 1:
                    chars.append(self.sentence_delimiter)
            return chars


 __snake_case		:Any   	=  tr.Compose(
     [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
 )
else:
 __snake_case		:Optional[int]   	=  tr.Compose(
     [
         tr.RemoveMultipleSpaces(),
         tr.Strip(),
         tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
         tr.ReduceToListOfListOfChars(),
     ]
 )


__snake_case		:Optional[int]   	=  '''\
@inproceedings{inproceedings,
    author = {Morris, Andrew and Maier, Viktoria and Green, Phil},
    year = {2004},
    month = {01},
    pages = {},
    title = {From WER and RIL to MER and WIL: improved evaluation measures for connected speech recognition.}
}
'''

__snake_case		:Tuple   	=  '''\
Character error rate (CER) is a common metric of the performance of an automatic speech recognition system.

CER is similar to Word Error Rate (WER), but operates on character instead of word. Please refer to docs of WER for further information.

Character error rate can be computed as:

CER = (S + D + I) / N = (S + D + I) / (S + D + C)

where

S is the number of substitutions,
D is the number of deletions,
I is the number of insertions,
C is the number of correct characters,
N is the number of characters in the reference (N=S+D+C).

CER\'s output is not always a number between 0 and 1, in particular when there is a high number of insertions. This value is often associated to the percentage of characters that were incorrectly predicted. The lower the value, the better the
performance of the ASR system with a CER of 0 being a perfect score.
'''

__snake_case		:Tuple   	=  '''
Computes CER score of transcribed segments against references.
Args:
    references: list of references for each speech input.
    predictions: list of transcribtions to score.
    concatenate_texts: Whether or not to concatenate sentences before evaluation, set to True for more accurate result.
Returns:
    (float): the character error rate

Examples:

    >>> predictions = ["this is the prediction", "there is an other sample"]
    >>> references = ["this is the reference", "there is another one"]
    >>> cer = datasets.load_metric("cer")
    >>> cer_score = cer.compute(predictions=predictions, references=references)
    >>> print(cer_score)
    0.34146341463414637
'''

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,_KWARGS_DESCRIPTION					)
class 					_A (			datasets.Metric					):



       def 	_lowerCamelCase    (	self							:  Optional[Any]):


           '''simple docstring'''

           return datasets.MetricInfo(
               description=_DESCRIPTION  ,	citation=_CITATION  ,	inputs_description=_KWARGS_DESCRIPTION  ,	features=datasets.Features(
                   {
                       '''predictions''': datasets.Value('''string'''  ,	id='''sequence'''),
                       '''references''': datasets.Value('''string'''  ,	id='''sequence'''),
                   })  ,	codebase_urls=['''https://github.com/jitsi/jiwer/''']  ,	reference_urls=[
                   '''https://en.wikipedia.org/wiki/Word_error_rate''',
                   '''https://sites.google.com/site/textdigitisation/qualitymeasures/computingerrorrates''',
               ]  ,	)





       def 	_lowerCamelCase    (	self							:  Optional[int]  ,	__SCREAMING_SNAKE_CASE							:  str  ,	__SCREAMING_SNAKE_CASE							:  List[Any]  ,	__SCREAMING_SNAKE_CASE							:  Dict=False):


           '''simple docstring'''

           if concatenate_texts:
               return jiwer.compute_measures(
                   __SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	truth_transform=__SCREAMING_SNAKE_CASE  ,	hypothesis_transform=__SCREAMING_SNAKE_CASE  ,	)["wer"]

           __a		 =       0
           __a		 =       0
           for prediction, reference in zip(__SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE):
               __a		 =       jiwer.compute_measures(
                   __SCREAMING_SNAKE_CASE  ,	__SCREAMING_SNAKE_CASE  ,	truth_transform=__SCREAMING_SNAKE_CASE  ,	hypothesis_transform=__SCREAMING_SNAKE_CASE  ,	)
               incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
               total += measures["substitutions"] + measures["deletions"] + measures["hits"]

           return incorrect / total





