


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




 '''simple docstring'''


 def __init__(      self      ,      __lowercase      ,      __lowercase = 13      ,      __lowercase = 64      ,      __lowercase = 2      ,      __lowercase = 3      ,      __lowercase = 3      ,      __lowercase = True      ,      __lowercase = True      ,      __lowercase = 128      ,      __lowercase=[16, 32, 64, 128]      ,      __lowercase = 7      ,      __lowercase = 4      ,      __lowercase = 37      ,      __lowercase = "gelu"      ,      __lowercase = 0.1      ,      __lowercase = 0.1      ,      __lowercase = 10      ,      __lowercase = 0.0_2      ,      __lowercase = 2      ,      __lowercase = 1      ,      __lowercase = 128      ,      __lowercase = [2, 2, 2, 2]      ,      __lowercase = 2      ,      __lowercase = 2      ,      ):

  """simple docstring"""







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


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Optional[Any]       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

  __A  :		List[str]       =			None
  if self.use_labels:
   __A  :		Tuple       =			ids_tensor([self.batch_size]      ,      self.type_sequence_label_size						)

  __A  :		List[str]       =			self.get_config()

  return config, pixel_values, labels


 def  snake_case__   (      self						):

  """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  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase						):

  """simple docstring"""







  __A  :		Dict       =			TFEfficientFormerModel(config=__lowercase						)
  __A  :		List[Any]       =			model(__lowercase      ,      training=__lowercase						)
  self.parent.assertEqual(result.last_hidden_state.shape      ,      (self.batch_size, self.seq_length, self.hidden_size)						)


 def  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase						):

  """simple docstring"""







  __A  :		Any       =			self.type_sequence_label_size
  __A  :		str       =			TFEfficientFormerForImageClassification(__lowercase						)
  __A  :		Any       =			model(__lowercase      ,      labels=__lowercase      ,      training=__lowercase						)
  self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.type_sequence_label_size)						)

  # test greyscale images
  __A  :		List[str]       =			1
  __A  :		Any       =			TFEfficientFormerForImageClassification(__lowercase						)

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







 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		int       =			self.prepare_config_and_inputs()
  __A     ,__A     ,__A  :		Dict       =			config_and_inputs
  __A  :		Optional[Any]       =			{'pixel_values': pixel_values}
  return config, inputs_dict


@require_tf
class 						_lowerCamelCase					(    snake_case_    ,		snake_case_    ,		unittest.TestCase				):




 '''simple docstring'''
 __lowercase				:		int    							=						(
     (
         TFEfficientFormerModel,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerForImageClassification,
     )
     if is_tf_available()
     else ()
 )
 __lowercase				:		Optional[int]    							=						(
     {
         '''feature-extraction''': TFEfficientFormerModel,
         '''image-classification''': (
             TFEfficientFormerForImageClassification,
             TFEfficientFormerForImageClassificationWithTeacher,
         ),
     }
     if is_tf_available()
     else {}
 )

 __lowercase				:		Any    							=						False

 __lowercase				:		int    							=						False
 __lowercase				:		Dict    							=						False
 __lowercase				:		Dict    							=						False
 __lowercase				:		Optional[Any]    							=						False


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		str       =			TFEfficientFormerModelTester(self						)
  __A  :		Any       =			ConfigTester(
      self      ,      config_class=__lowercase      ,      has_text_modality=__lowercase      ,      hidden_size=37						)


 def  snake_case__   (      self						):

  """simple docstring"""







  self.config_tester.run_common_tests()


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

  """simple docstring"""







  pass


 @unittest.skip(reason='EfficientFormer does not support input and output embeddings'						)
 def  snake_case__   (      self						):

  """simple docstring"""







  pass


 def  snake_case__   (      self						):

  """simple docstring"""







  __A     ,__A  :		Tuple       =			self.model_tester.prepare_config_and_inputs_for_common()

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

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


 def  snake_case__   (      self						):

  """simple docstring"""







  def check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						):
   __A  :		List[Any]       =			model_class(__lowercase						)

   __A  :		Tuple       =			model(**self._prepare_for_class(__lowercase      ,      __lowercase						)      ,      training=__lowercase						)
   __A  :		Optional[Any]       =			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

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

    self.asseretIsInstance(__lowercase      ,      (list, tuple)						)
    self.assertEqual(len(__lowercase						)      ,      __lowercase						)
    __A  :		Dict       =			getattr(self.model_tester      ,      'seq_length'      ,      __lowercase						)
    __A  :		Dict       =			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     ,__A  :		str       =			self.model_tester.prepare_config_and_inputs_for_common()

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

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

   check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						)


 def  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase=False						):

  """simple docstring"""







  __A  :		List[str]       =			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  snake_case__   (      self						):

  """simple docstring"""







  __A  :		int       =			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  snake_case__   (      self						):

  """simple docstring"""







  __A  :		List[str]       =			self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_masked_image_modeling(*__lowercase						)


 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Tuple       =			self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_for_image_classification(*__lowercase						)


 @slow
 def  snake_case__   (      self						):

  """simple docstring"""







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


 def  snake_case__   (      self						):

  """simple docstring"""







  __A     ,__A  :		Union[str, Any]       =			self.model_tester.prepare_config_and_inputs_for_common()
  __A  :		List[Any]       =			True

  __A  :		Dict       =			getattr(self.model_tester      ,      'seq_length'      ,      __lowercase						)
  __A  :		Any       =			getattr(self.model_tester      ,      'encoder_seq_length'      ,      __lowercase						)
  __A  :		Union[str, Any]       =			getattr(self.model_tester      ,      'key_length'      ,      __lowercase						)
  __A  :		Optional[int]       =			getattr(self.model_tester      ,      'chunk_length'      ,      __lowercase						)

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

  for model_class in self.all_model_classes:
   __A  :		Any       =			True
   __A  :		Dict       =			False
   __A  :		int       =			True
   __A  :		Optional[Any]       =			model_class(__lowercase						)

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

   __A  :		Union[str, Any]       =			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  snake_case__   (      self						):

  """simple docstring"""







  __A     ,__A  :		Any       =			self.model_tester.prepare_config_and_inputs_for_common()

  for model_class in self.all_model_classes:
   # Prepare our model
   __A  :		Union[str, Any]       =			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  :		Any       =			{
       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  :		Dict       =			model(__lowercase						)
   self.assertTrue(outputs_dict is not None						)


def 			_lowercase       (				):
 __A  :		Optional[int]       =			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
 return image


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




 '''simple docstring'''


 @cached_property
 def  snake_case__   (      self						):

  """simple docstring"""







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


 @slow
 def  snake_case__   (      self						):

  """simple docstring"""







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







 @slow
 def  snake_case__   (      self						):

  """simple docstring"""







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










'''simple docstring'''
import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow

@is_pipeline_test
@require_torch
class 						_lowerCamelCase					(    unittest.TestCase				):




 '''simple docstring'''


 @require_torch
 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Optional[int]       =			pipeline(
      task='zero-shot-audio-classification'      ,      model='hf-internal-testing/tiny-clap-htsat-unfused'						)
  __A  :		str       =			load_dataset('ashraq/esc50'						)
  __A  :		Union[str, Any]       =			dataset['train']['audio'][-1]['array']
  __A  :		List[str]       =			audio_classifier(__lowercase      ,      candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']						)
  self.assertEqual(
      nested_simplify(__lowercase						)      ,      [{'score': 0.5_0_1, 'label': 'Sound of a dog'}, {'score': 0.4_9_9, 'label': 'Sound of vaccum cleaner'}]      ,      )


 @unittest.skip('No models are available in TF'						)
 def  snake_case__   (      self						):

  """simple docstring"""







  pass


 @slow
 @require_torch
 def  snake_case__   (      self						):

  """simple docstring"""







  __A  :		Dict       =			pipeline(
      task='zero-shot-audio-classification'      ,      model='laion/clap-htsat-unfused'      ,      )
  # This is an audio of a dog
  __A  :		Optional[Any]       =			load_dataset('ashraq/esc50'						)
  __A  :		List[str]       =			dataset['train']['audio'][-1]['array']
  __A  :		Union[str, Any]       =			audio_classifier(__lowercase      ,      candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']						)

  self.assertEqual(
      nested_simplify(__lowercase						)      ,      [
          {'score': 0.9_9_9, 'label': 'Sound of a dog'},
          {'score': 0.0_0_1, 'label': 'Sound of vaccum cleaner'},
      ]      ,      )

  __A  :		Any       =			audio_classifier([audio] * 5      ,      candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']						)
  self.assertEqual(
      nested_simplify(__lowercase						)      ,      [
          [
              {'score': 0.9_9_9, 'label': 'Sound of a dog'},
              {'score': 0.0_0_1, 'label': 'Sound of vaccum cleaner'},
          ],
      ]
      * 5      ,      )
  __A  :		str       =			audio_classifier(
      [audio] * 5      ,      candidate_labels=['Sound of a dog', 'Sound of vaccum cleaner']      ,      batch_size=5						)
  self.assertEqual(
      nested_simplify(__lowercase						)      ,      [
          [
              {'score': 0.9_9_9, 'label': 'Sound of a dog'},
              {'score': 0.0_0_1, 'label': 'Sound of vaccum cleaner'},
          ],
      ]
      * 5      ,      )







 @unittest.skip('No models are available in TF'						)
 def  snake_case__   (      self						):

  """simple docstring"""







  pass






