




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					:					Optional[int]       ,     SCREAMING_SNAKE_CASE__					:					Any       ,     SCREAMING_SNAKE_CASE__					:					int = 13       ,     SCREAMING_SNAKE_CASE__					:					int = 64       ,     SCREAMING_SNAKE_CASE__					:					int = 2       ,     SCREAMING_SNAKE_CASE__					:					int = 3       ,     SCREAMING_SNAKE_CASE__					:					int = 3       ,     SCREAMING_SNAKE_CASE__					:					bool = True       ,     SCREAMING_SNAKE_CASE__					:					bool = True       ,     SCREAMING_SNAKE_CASE__					:					int = 128       ,     SCREAMING_SNAKE_CASE__					:					List[str]=[16, 32, 64, 128]       ,     SCREAMING_SNAKE_CASE__					:					int = 7       ,     SCREAMING_SNAKE_CASE__					:					int = 4       ,     SCREAMING_SNAKE_CASE__					:					int = 37       ,     SCREAMING_SNAKE_CASE__					:					str = "gelu"       ,     SCREAMING_SNAKE_CASE__					:					float = 0.1       ,     SCREAMING_SNAKE_CASE__					:					float = 0.1       ,     SCREAMING_SNAKE_CASE__					:					int = 10       ,     SCREAMING_SNAKE_CASE__					:					float = 0.02       ,     SCREAMING_SNAKE_CASE__					:					int = 2       ,     SCREAMING_SNAKE_CASE__					:					int = 1       ,     SCREAMING_SNAKE_CASE__					:					int = 128       ,     SCREAMING_SNAKE_CASE__					:					List[int] = [2, 2, 2, 2]       ,     SCREAMING_SNAKE_CASE__					:					int = 2       ,     SCREAMING_SNAKE_CASE__					:					int = 2       ,     )				->	Optional[int]:
         lowerCAmelCase__          =			parent
         lowerCAmelCase__          =			batch_size
         lowerCAmelCase__          =			image_size
         lowerCAmelCase__          =			patch_size
         lowerCAmelCase__          =			num_channels
         lowerCAmelCase__          =			is_training
         lowerCAmelCase__          =			use_labels
         lowerCAmelCase__          =			hidden_size
         lowerCAmelCase__          =			num_hidden_layers
         lowerCAmelCase__          =			num_attention_heads
         lowerCAmelCase__          =			intermediate_size
         lowerCAmelCase__          =			hidden_act
         lowerCAmelCase__          =			hidden_dropout_prob
         lowerCAmelCase__          =			attention_probs_dropout_prob
         lowerCAmelCase__          =			type_sequence_label_size
         lowerCAmelCase__          =			initializer_range
         lowerCAmelCase__          =			encoder_stride
         lowerCAmelCase__          =			num_attention_outputs
         lowerCAmelCase__          =			embed_dim
         lowerCAmelCase__          =			embed_dim + 1
         lowerCAmelCase__          =			resolution
         lowerCAmelCase__          =			depths
         lowerCAmelCase__          =			hidden_sizes
         lowerCAmelCase__          =			dim
         lowerCAmelCase__          =			mlp_expansion_ratio


    def        a				(	self					:					Any       )				->	List[str]:
         lowerCAmelCase__          =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

         lowerCAmelCase__          =			self.get_config()

         return config, pixel_values, labels


    def        a				(	self					:					Optional[Any]       )				->	int:
         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=SCREAMING_SNAKE_CASE__       ,     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        a				(	self					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					List[str]       )				->	List[Any]:
         lowerCAmelCase__          =			TFEfficientFormerModel(config=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     training=SCREAMING_SNAKE_CASE__       )
         self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, self.seq_length, self.hidden_size)       )


    def        a				(	self					:					str       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       )				->	List[str]:
         lowerCAmelCase__          =			self.type_sequence_label_size
         lowerCAmelCase__          =			TFEfficientFormerForImageClassification(SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     labels=SCREAMING_SNAKE_CASE__       ,     training=SCREAMING_SNAKE_CASE__       )
         self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)       )

         # test greyscale images
         lowerCAmelCase__          =			1
         lowerCAmelCase__          =			TFEfficientFormerForImageClassification(SCREAMING_SNAKE_CASE__       )

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


    def        a				(	self					:					str       )				->	Dict:
         lowerCAmelCase__          =			self.prepare_config_and_inputs()
         lowerCAmelCase__     ,		lowerCAmelCase__     ,		lowerCAmelCase__          =			config_and_inputs
         lowerCAmelCase__          =			{"pixel_values": pixel_values}
         return config, inputs_dict






@require_tf
class 			__lowerCamelCase	(   UpperCamelCase__     ,    UpperCamelCase__     ,    unittest.TestCase   ):




    """simple docstring"""

    snake_case__ =				(
        (
            TFEfficientFormerModel,
            TFEfficientFormerForImageClassificationWithTeacher,
            TFEfficientFormerForImageClassification,
        )
        if is_tf_available()
        else ()
    )
    snake_case__ =				(
        {
            "feature-extraction": TFEfficientFormerModel,
            "image-classification": (
                TFEfficientFormerForImageClassification,
                TFEfficientFormerForImageClassificationWithTeacher,
            ),
        }
        if is_tf_available()
        else {}
    )

    snake_case__ =				False

    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False


    def        a				(	self					:					List[Any]       )				->	Tuple:
         lowerCAmelCase__          =			TFEfficientFormerModelTester(self       )
         lowerCAmelCase__          =			ConfigTester(
             self       ,     config_class=SCREAMING_SNAKE_CASE__       ,     has_text_modality=SCREAMING_SNAKE_CASE__       ,     hidden_size=37       )


    def        a				(	self					:					Union[str, Any]       )				->	str:
         self.config_tester.run_common_tests()


    @unittest.skip(reason="EfficientFormer does not use inputs_embeds"       )
    def        a				(	self					:					Optional[Any]       )				->	Any:
         pass


    @unittest.skip(reason="EfficientFormer does not support input and output embeddings"       )
    def        a				(	self					:					Optional[Any]       )				->	str:
         pass


    def        a				(	self					:					List[str]       )				->	int:
         lowerCAmelCase__     ,		lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs_for_common()

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

              lowerCAmelCase__          =			["pixel_values"]
              self.assertListEqual(arg_names[:1]       ,     SCREAMING_SNAKE_CASE__       )


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

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

              lowerCAmelCase__          =			getattr(
                  self.model_tester       ,     "expected_num_hidden_layers"       ,     self.model_tester.num_hidden_layers + 1       )
              self.assertEqual(len(SCREAMING_SNAKE_CASE__       )       ,     SCREAMING_SNAKE_CASE__       )

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

                   self.asseretIsInstance(SCREAMING_SNAKE_CASE__       ,     (list, tuple)       )
                   self.assertEqual(len(SCREAMING_SNAKE_CASE__       )       ,     SCREAMING_SNAKE_CASE__       )
                   lowerCAmelCase__          =			getattr(self.model_tester       ,     "seq_length"       ,     SCREAMING_SNAKE_CASE__       )
                   lowerCAmelCase__          =			getattr(self.model_tester       ,     "decoder_seq_length"       ,     SCREAMING_SNAKE_CASE__       )

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

         lowerCAmelCase__     ,		lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs_for_common()

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

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

              check_hidden_states_output(SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Optional[int]       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Any=False       )				->	List[Any]:
         lowerCAmelCase__          =			super()._prepare_for_class(SCREAMING_SNAKE_CASE__       ,     SCREAMING_SNAKE_CASE__       ,     return_labels=SCREAMING_SNAKE_CASE__       )

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

         return inputs_dict


    def        a				(	self					:					List[str]       )				->	Tuple:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__       )


    @unittest.skip(reason="EfficientFormer does not implement masked image modeling yet"       )
    def        a				(	self					:					Union[str, Any]       )				->	Union[str, Any]:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Tuple       )				->	int:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__       )


    @slow
    def        a				(	self					:					List[str]       )				->	List[Any]:
         for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__          =			TFEfficientFormerModel.from_pretrained(SCREAMING_SNAKE_CASE__       )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					str       )				->	Union[str, Any]:
         lowerCAmelCase__     ,		lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs_for_common()
         lowerCAmelCase__          =			True

         lowerCAmelCase__          =			getattr(self.model_tester       ,     "seq_length"       ,     SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			getattr(self.model_tester       ,     "encoder_seq_length"       ,     SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			getattr(self.model_tester       ,     "key_length"       ,     SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			getattr(self.model_tester       ,     "chunk_length"       ,     SCREAMING_SNAKE_CASE__       )

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

         for model_class in self.all_model_classes:
              lowerCAmelCase__          =			True
              lowerCAmelCase__          =			False
              lowerCAmelCase__          =			True
              lowerCAmelCase__          =			model_class(SCREAMING_SNAKE_CASE__       )

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

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

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

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






def 							_A       (						):
     """simple docstring"""

     lowerCAmelCase__          =			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
     return image






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




    """simple docstring"""

    @cached_property
    def        a				(	self					:					Union[str, Any]       )				->	Tuple:
         return (
             EfficientFormerImageProcessor.from_pretrained("snap-research/efficientformer-l1-300"       )
             if is_vision_available()
             else None
         )


    @slow
    def        a				(	self					:					Optional[int]       )				->	Any:
         lowerCAmelCase__          =			TFEfficientFormerForImageClassification.from_pretrained("snap-research/efficientformer-l1-300"       )
         lowerCAmelCase__          =			self.default_image_processor
         lowerCAmelCase__          =			prepare_img()
         lowerCAmelCase__          =			image_processor(images=SCREAMING_SNAKE_CASE__       ,     return_tensors="tf"       )
         # forward pass
         lowerCAmelCase__          =			model(**SCREAMING_SNAKE_CASE__       ,     training=SCREAMING_SNAKE_CASE__       )
         # verify the logits
         lowerCAmelCase__          =			tf.TensorShape((1, 1_000)       )
         self.assertEqual(outputs.logits.shape       ,     SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			tf.constant([-0.0_555, 0.4_825, -0.0_852]       )
         self.assertTrue(np.allclose(outputs.logits[0, :3]       ,     SCREAMING_SNAKE_CASE__       ,     atol=1e-4       )       )


    @slow
    def        a				(	self					:					Optional[Any]       )				->	Dict:
         lowerCAmelCase__          =			TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
             "snap-research/efficientformer-l1-300"       )
         lowerCAmelCase__          =			self.default_image_processor
         lowerCAmelCase__          =			prepare_img()
         lowerCAmelCase__          =			image_processor(images=SCREAMING_SNAKE_CASE__       ,     return_tensors="tf"       )
         # forward pass
         lowerCAmelCase__          =			model(**SCREAMING_SNAKE_CASE__       ,     training=SCREAMING_SNAKE_CASE__       )
         # verify the logits
         lowerCAmelCase__          =			tf.TensorShape((1, 1_000)       )
         self.assertEqual(outputs.logits.shape       ,     SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			tf.constant([-0.1_312, 0.4_353, -1.0_499]       )
         self.assertTrue(np.allclose(outputs.logits[0, :3]       ,     SCREAMING_SNAKE_CASE__       ,     atol=1e-4       )       )






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import numpy
     import tensorflow as tf

     from transformers import (
         TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
         TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
         TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
         BertConfig,
         DPRConfig,
         TFDPRContextEncoder,
         TFDPRQuestionEncoder,
         TFDPRReader,
     )





class 			__lowerCamelCase	:




    """simple docstring"""

    def __init__(	self					:					str       ,     SCREAMING_SNAKE_CASE__					:					List[str]       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=13       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=7       ,     SCREAMING_SNAKE_CASE__					:					str=True       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=True       ,     SCREAMING_SNAKE_CASE__					:					Dict=True       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=True       ,     SCREAMING_SNAKE_CASE__					:					int=99       ,     SCREAMING_SNAKE_CASE__					:					List[str]=32       ,     SCREAMING_SNAKE_CASE__					:					Tuple=2       ,     SCREAMING_SNAKE_CASE__					:					List[str]=4       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]=37       ,     SCREAMING_SNAKE_CASE__					:					List[Any]="gelu"       ,     SCREAMING_SNAKE_CASE__					:					int=0.1       ,     SCREAMING_SNAKE_CASE__					:					Dict=0.1       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=512       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=16       ,     SCREAMING_SNAKE_CASE__					:					List[str]=2       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=0.02       ,     SCREAMING_SNAKE_CASE__					:					Tuple=3       ,     SCREAMING_SNAKE_CASE__					:					int=4       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=None       ,     SCREAMING_SNAKE_CASE__					:					str=0       ,     )				->	List[Any]:
         lowerCAmelCase__          =			parent
         lowerCAmelCase__          =			batch_size
         lowerCAmelCase__          =			seq_length
         lowerCAmelCase__          =			is_training
         lowerCAmelCase__          =			use_input_mask
         lowerCAmelCase__          =			use_token_type_ids
         lowerCAmelCase__          =			use_labels
         lowerCAmelCase__          =			vocab_size
         lowerCAmelCase__          =			hidden_size
         lowerCAmelCase__          =			num_hidden_layers
         lowerCAmelCase__          =			num_attention_heads
         lowerCAmelCase__          =			intermediate_size
         lowerCAmelCase__          =			hidden_act
         lowerCAmelCase__          =			hidden_dropout_prob
         lowerCAmelCase__          =			attention_probs_dropout_prob
         lowerCAmelCase__          =			max_position_embeddings
         lowerCAmelCase__          =			type_vocab_size
         lowerCAmelCase__          =			type_sequence_label_size
         lowerCAmelCase__          =			initializer_range
         lowerCAmelCase__          =			num_labels
         lowerCAmelCase__          =			num_choices
         lowerCAmelCase__          =			scope
         lowerCAmelCase__          =			projection_dim


    def        a				(	self					:					Any       )				->	Any:
         lowerCAmelCase__          =			ids_tensor([self.batch_size, self.seq_length]       ,     self.vocab_size       )

         lowerCAmelCase__          =			None
         if self.use_input_mask:
              # follow test_modeling_tf_ctrl.py
              lowerCAmelCase__          =			random_attention_mask([self.batch_size, self.seq_length]       )

         lowerCAmelCase__          =			None
         if self.use_token_type_ids:
              lowerCAmelCase__          =			ids_tensor([self.batch_size, self.seq_length]       ,     self.type_vocab_size       )

         lowerCAmelCase__          =			None
         lowerCAmelCase__          =			None
         lowerCAmelCase__          =			None
         if self.use_labels:
              lowerCAmelCase__          =			ids_tensor([self.batch_size]       ,     self.type_sequence_label_size       )
              lowerCAmelCase__          =			ids_tensor([self.batch_size, self.seq_length]       ,     self.num_labels       )
              lowerCAmelCase__          =			ids_tensor([self.batch_size]       ,     self.num_choices       )

         lowerCAmelCase__          =			BertConfig(
             vocab_size=self.vocab_size       ,     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       ,     max_position_embeddings=self.max_position_embeddings       ,     type_vocab_size=self.type_vocab_size       ,     is_decoder=SCREAMING_SNAKE_CASE__       ,     initializer_range=self.initializer_range       ,     )
         lowerCAmelCase__          =			DPRConfig(projection_dim=self.projection_dim       ,     **config.to_dict()       )

         return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


    def        a				(	self					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Any       ,     SCREAMING_SNAKE_CASE__					:					Any       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       )				->	List[str]:
         lowerCAmelCase__          =			TFDPRContextEncoder(config=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     attention_mask=SCREAMING_SNAKE_CASE__       ,     token_type_ids=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     token_type_ids=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       )
         self.parent.assertEqual(result.pooler_output.shape       ,     (self.batch_size, self.projection_dim or self.hidden_size)       )


    def        a				(	self					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					Any       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					str       )				->	List[str]:
         lowerCAmelCase__          =			TFDPRQuestionEncoder(config=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     attention_mask=SCREAMING_SNAKE_CASE__       ,     token_type_ids=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     token_type_ids=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       )
         self.parent.assertEqual(result.pooler_output.shape       ,     (self.batch_size, self.projection_dim or self.hidden_size)       )


    def        a				(	self					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					str       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       )				->	List[Any]:
         lowerCAmelCase__          =			TFDPRReader(config=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     attention_mask=SCREAMING_SNAKE_CASE__       )

         self.parent.assertEqual(result.start_logits.shape       ,     (self.batch_size, self.seq_length)       )
         self.parent.assertEqual(result.end_logits.shape       ,     (self.batch_size, self.seq_length)       )
         self.parent.assertEqual(result.relevance_logits.shape       ,     (self.batch_size,)       )


    def        a				(	self					:					Optional[int]       )				->	Union[str, Any]:
         lowerCAmelCase__          =			self.prepare_config_and_inputs()
         (
             (
             lowerCAmelCase__
         )     ,		(
             lowerCAmelCase__
         )     ,		(
             lowerCAmelCase__
         )     ,		(
             lowerCAmelCase__
         )     ,		(
             lowerCAmelCase__
         )     ,		(
             lowerCAmelCase__
         )     ,		(
             lowerCAmelCase__
         )     ,		
         )          =			config_and_inputs
         lowerCAmelCase__          =			{"input_ids": input_ids}
         return config, inputs_dict






@require_tf
class 			__lowerCamelCase	(   UpperCamelCase__     ,    UpperCamelCase__     ,    unittest.TestCase   ):




    """simple docstring"""

    snake_case__ =				(
        (
            TFDPRContextEncoder,
            TFDPRQuestionEncoder,
            TFDPRReader,
        )
        if is_tf_available()
        else ()
    )
    snake_case__ =				{"feature-extraction": TFDPRQuestionEncoder} if is_tf_available() else {}

    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False
    snake_case__ =				False


    def        a				(	self					:					Dict       )				->	int:
         lowerCAmelCase__          =			TFDPRModelTester(self       )
         lowerCAmelCase__          =			ConfigTester(self       ,     config_class=SCREAMING_SNAKE_CASE__       ,     hidden_size=37       )


    def        a				(	self					:					List[Any]       )				->	List[Any]:
         self.config_tester.run_common_tests()


    def        a				(	self					:					Tuple       )				->	Dict:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_dpr_context_encoder(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Union[str, Any]       )				->	Optional[int]:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_dpr_question_encoder(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					List[Any]       )				->	Dict:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_dpr_reader(*SCREAMING_SNAKE_CASE__       )


    @slow
    def        a				(	self					:					List[str]       )				->	Union[str, Any]:
         for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__          =			TFDPRContextEncoder.from_pretrained(SCREAMING_SNAKE_CASE__       )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )

         for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__          =			TFDPRContextEncoder.from_pretrained(SCREAMING_SNAKE_CASE__       )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )

         for model_name in TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__          =			TFDPRQuestionEncoder.from_pretrained(SCREAMING_SNAKE_CASE__       )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )

         for model_name in TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__          =			TFDPRReader.from_pretrained(SCREAMING_SNAKE_CASE__       )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )






@require_tf
class 			__lowerCamelCase	(   unittest.TestCase   ):




    """simple docstring"""

    @slow
    def        a				(	self					:					Optional[Any]       )				->	List[str]:
         lowerCAmelCase__          =			TFDPRQuestionEncoder.from_pretrained("facebook/dpr-question_encoder-single-nq-base"       )

         lowerCAmelCase__          =			tf.constant(
             [[101, 7_592, 1_010, 2_003, 2_026, 3_899, 10_140, 1_029, 102]]       )  # [CLS] hello, is my dog cute? [SEP]
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       )[0]  # embedding shape = (1, 768)
         # compare the actual values for a slice.
         lowerCAmelCase__          =			tf.constant(
             [
                 [
                     0.03_236_253,
                     0.12_753_335,
                     0.16_818_509,
                     0.00_279_786,
                     0.3_896_933,
                     0.24_264_945,
                     0.2_178_971,
                     -0.02_335_227,
                     -0.08_481_959,
                     -0.14_324_117,
                 ]
             ]       )
         self.assertTrue(numpy.allclose(output[:, :10].numpy()       ,     expected_slice.numpy()       ,     atol=1e-4       )       )
