

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

  def __init__(					self						,		_A						,		_A = 13						,		_A = 64						,		_A = 2						,		_A = 3						,		_A = 3						,		_A = True						,		_A = True						,		_A = 128						,		_A=[16, 32, 64, 128]						,		_A = 7						,		_A = 4						,		_A = 37						,		_A = "gelu"						,		_A = 0.1						,		_A = 0.1						,		_A = 10						,		_A = 0.0_2						,		_A = 2						,		_A = 1						,		_A = 128						,		_A = [2, 2, 2, 2]						,		_A = 2						,		_A = 2						,		):
      SCREAMING_SNAKE_CASE_									=						parent
      SCREAMING_SNAKE_CASE_									=						batch_size
      SCREAMING_SNAKE_CASE_									=						image_size
      SCREAMING_SNAKE_CASE_									=						patch_size
      SCREAMING_SNAKE_CASE_									=						num_channels
      SCREAMING_SNAKE_CASE_									=						is_training
      SCREAMING_SNAKE_CASE_									=						use_labels
      SCREAMING_SNAKE_CASE_									=						hidden_size
      SCREAMING_SNAKE_CASE_									=						num_hidden_layers
      SCREAMING_SNAKE_CASE_									=						num_attention_heads
      SCREAMING_SNAKE_CASE_									=						intermediate_size
      SCREAMING_SNAKE_CASE_									=						hidden_act
      SCREAMING_SNAKE_CASE_									=						hidden_dropout_prob
      SCREAMING_SNAKE_CASE_									=						attention_probs_dropout_prob
      SCREAMING_SNAKE_CASE_									=						type_sequence_label_size
      SCREAMING_SNAKE_CASE_									=						initializer_range
      SCREAMING_SNAKE_CASE_									=						encoder_stride
      SCREAMING_SNAKE_CASE_									=						num_attention_outputs
      SCREAMING_SNAKE_CASE_									=						embed_dim
      SCREAMING_SNAKE_CASE_									=						embed_dim + 1
      SCREAMING_SNAKE_CASE_									=						resolution
      SCREAMING_SNAKE_CASE_									=						depths
      SCREAMING_SNAKE_CASE_									=						hidden_sizes
      SCREAMING_SNAKE_CASE_									=						dim
      SCREAMING_SNAKE_CASE_									=						mlp_expansion_ratio

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

      SCREAMING_SNAKE_CASE_									=						self.get_config()

      return config, pixel_values, labels

  def 						lowerCAmelCase__     (					self):
      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=_A						,		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						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						TFEfficientFormerModel(config=_A)
      SCREAMING_SNAKE_CASE_									=						model(_A						,		training=_A)
      self.parent.assertEqual(result.last_hidden_state.shape						,		(self.batch_size, self.seq_length, self.hidden_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						self.type_sequence_label_size
      SCREAMING_SNAKE_CASE_									=						TFEfficientFormerForImageClassification(_A)
      SCREAMING_SNAKE_CASE_									=						model(_A						,		labels=_A						,		training=_A)
      self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.type_sequence_label_size))

      # test greyscale images
      SCREAMING_SNAKE_CASE_									=						1
      SCREAMING_SNAKE_CASE_									=						TFEfficientFormerForImageClassification(_A)

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


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






@require_tf
class       __snake_case  (    lowerCAmelCase__     , lowerCAmelCase__     , unittest.TestCase       ):
  __lowerCAmelCase     :	int						 =  (
      (
          TFEfficientFormerModel,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerForImageClassification,
      )
      if is_tf_available()
      else ()
  )
  __lowerCAmelCase     :	Any						 =  (
      {
          'feature-extraction': TFEfficientFormerModel,
          'image-classification': (
              TFEfficientFormerForImageClassification,
              TFEfficientFormerForImageClassificationWithTeacher,
          ),
      }
      if is_tf_available()
      else {}
  )

  __lowerCAmelCase     :	int						 =  False

  __lowerCAmelCase     :	int						 =  False
  __lowerCAmelCase     :	int						 =  False
  __lowerCAmelCase     :	Any						 =  False
  __lowerCAmelCase     :	Union[str, Any]						 =  False

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						TFEfficientFormerModelTester(self)
      SCREAMING_SNAKE_CASE_									=						ConfigTester(
          self						,		config_class=_A						,		has_text_modality=_A						,		hidden_size=37)

  def 						lowerCAmelCase__     (					self):
      self.config_tester.run_common_tests()

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

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

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

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

          SCREAMING_SNAKE_CASE_									=						['pixel_values']
          self.assertListEqual(arg_names[:1]						,		_A)

  def 						lowerCAmelCase__     (					self):
      def check_hidden_states_output(_A						,		_A						,		_A):
          SCREAMING_SNAKE_CASE_									=						model_class(_A)

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

          SCREAMING_SNAKE_CASE_									=						getattr(
              self.model_tester						,		'expected_num_hidden_layers'						,		self.model_tester.num_hidden_layers + 1)
          self.assertEqual(len(_A)						,		_A)

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

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

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

      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_									=						True
          check_hidden_states_output(_A						,		_A						,		_A)

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

          check_hidden_states_output(_A						,		_A						,		_A)

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A=False):
      SCREAMING_SNAKE_CASE_									=						super()._prepare_for_class(_A						,		_A						,		return_labels=_A)

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

      return inputs_dict

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A)

  @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet')
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_A)

  @slow
  def 						lowerCAmelCase__     (					self):
      for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          SCREAMING_SNAKE_CASE_									=						TFEfficientFormerModel.from_pretrained(_A)
          self.assertIsNotNone(_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE_									=						True

      SCREAMING_SNAKE_CASE_									=						getattr(self.model_tester						,		'seq_length'						,		_A)
      SCREAMING_SNAKE_CASE_									=						getattr(self.model_tester						,		'encoder_seq_length'						,		_A)
      SCREAMING_SNAKE_CASE_									=						getattr(self.model_tester						,		'key_length'						,		_A)
      SCREAMING_SNAKE_CASE_									=						getattr(self.model_tester						,		'chunk_length'						,		_A)

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

      for model_class in self.all_model_classes:
          SCREAMING_SNAKE_CASE_									=						True
          SCREAMING_SNAKE_CASE_									=						False
          SCREAMING_SNAKE_CASE_									=						True
          SCREAMING_SNAKE_CASE_									=						model_class(_A)

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

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

          SCREAMING_SNAKE_CASE_									=						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
          self.assertEqual(len(_A)						,		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):
      # 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
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          # Prepare our model
          SCREAMING_SNAKE_CASE_									=						model_class(_A)
          # These are maximally general inputs for the model, with multiple None dimensions
          # Hopefully this will catch any conditionals that fail for flexible shapes
          SCREAMING_SNAKE_CASE_									=						{
              key: tf.keras.Input(shape=val.shape[1:]						,		dtype=val.dtype						,		name=_A)
              for key, val in model.input_signature.items()
              if key in model.dummy_inputs
          }
          SCREAMING_SNAKE_CASE_									=						model(_A)
          self.assertTrue(outputs_dict is not None)






def 					_UpperCAmelCase       (  ):





    """simple docstring"""


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





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

  @cached_property
  def 						lowerCAmelCase__     (					self):
      return (
          EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300')
          if is_vision_available()
          else None
      )

  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300')
      SCREAMING_SNAKE_CASE_									=						self.default_image_processor
      SCREAMING_SNAKE_CASE_									=						prepare_img()
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='tf')
      # forward pass
      SCREAMING_SNAKE_CASE_									=						model(**_A						,		training=_A)
      # verify the logits
      SCREAMING_SNAKE_CASE_									=						tf.TensorShape((1, 1000))
      self.assertEqual(outputs.logits.shape						,		_A)
      SCREAMING_SNAKE_CASE_									=						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]						,		_A						,		atol=1E-4))


  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
          'snap-research/efficientformer-l1-300')
      SCREAMING_SNAKE_CASE_									=						self.default_image_processor
      SCREAMING_SNAKE_CASE_									=						prepare_img()
      SCREAMING_SNAKE_CASE_									=						image_processor(images=_A						,		return_tensors='tf')
      # forward pass
      SCREAMING_SNAKE_CASE_									=						model(**_A						,		training=_A)
      # verify the logits
      SCREAMING_SNAKE_CASE_									=						tf.TensorShape((1, 1000))
      self.assertEqual(outputs.logits.shape						,		_A)
      SCREAMING_SNAKE_CASE_									=						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]						,		_A						,		atol=1E-4))





from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase__  :      str			=    logging.get_logger(__name__)

UpperCamelCase__  :      Optional[int]			=    {
    "facebook/dpr-ctx_encoder-single-nq-base": (
        "https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-question_encoder-single-nq-base": (
        "https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-reader-single-nq-base": (
        "https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/config.json"
    ),
    "facebook/dpr-ctx_encoder-multiset-base": (
        "https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/config.json"
    ),
    "facebook/dpr-question_encoder-multiset-base": (
        "https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/config.json"
    ),
    "facebook/dpr-reader-multiset-base": (
        "https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/config.json"
    ),
}



class       __snake_case  (    lowerCAmelCase__       ):
  __lowerCAmelCase     :	Optional[int]						 =  'dpr'

  def __init__(					self						,		_A=30522						,		_A=768						,		_A=12						,		_A=12						,		_A=3072						,		_A="gelu"						,		_A=0.1						,		_A=0.1						,		_A=512						,		_A=2						,		_A=0.0_2						,		_A=1E-12						,		_A=0						,		_A="absolute"						,		_A = 0						,		**_A						,		):
      super().__init__(pad_token_id=_A						,		**_A)

      SCREAMING_SNAKE_CASE_									=						vocab_size
      SCREAMING_SNAKE_CASE_									=						hidden_size
      SCREAMING_SNAKE_CASE_									=						num_hidden_layers
      SCREAMING_SNAKE_CASE_									=						num_attention_heads
      SCREAMING_SNAKE_CASE_									=						hidden_act
      SCREAMING_SNAKE_CASE_									=						intermediate_size
      SCREAMING_SNAKE_CASE_									=						hidden_dropout_prob
      SCREAMING_SNAKE_CASE_									=						attention_probs_dropout_prob
      SCREAMING_SNAKE_CASE_									=						max_position_embeddings
      SCREAMING_SNAKE_CASE_									=						type_vocab_size
      SCREAMING_SNAKE_CASE_									=						initializer_range
      SCREAMING_SNAKE_CASE_									=						layer_norm_eps
      SCREAMING_SNAKE_CASE_									=						projection_dim
      SCREAMING_SNAKE_CASE_									=						position_embedding_type


