




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







							def __init__(    self			:    List[str]				,     lowerCAmelCase_			:    int				,     lowerCAmelCase_			:    int = 13				,     lowerCAmelCase_			:    int = 64				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 3				,     lowerCAmelCase_			:    int = 3				,     lowerCAmelCase_			:    bool = True				,     lowerCAmelCase_			:    bool = True				,     lowerCAmelCase_			:    int = 1_28				,     lowerCAmelCase_			:    Any=[16, 32, 64, 1_28]				,     lowerCAmelCase_			:    int = 7				,     lowerCAmelCase_			:    int = 4				,     lowerCAmelCase_			:    int = 37				,     lowerCAmelCase_			:    str = "gelu"				,     lowerCAmelCase_			:    float = 0.1				,     lowerCAmelCase_			:    float = 0.1				,     lowerCAmelCase_			:    int = 10				,     lowerCAmelCase_			:    float = 0.0_2				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 1				,     lowerCAmelCase_			:    int = 1_28				,     lowerCAmelCase_			:    List[int] = [2, 2, 2, 2]				,     lowerCAmelCase_			:    int = 2				,     lowerCAmelCase_			:    int = 2				,     )     ->				Optional[Any]:


														"""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			:    str   )     ->				List[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			:    Tuple   )     ->				int:


														"""simple docstring"""


														return EfficientFormerConfig(
														    image_size=self.image_size				,     patch_size=self.patch_size				,     num_channels=self.num_channels				,     hidden_size=self.hidden_size				,     num_hidden_layers=self.num_hidden_layers				,     num_attention_heads=self.num_attention_heads				,     intermediate_size=self.intermediate_size				,     hidden_act=self.hidden_act				,     hidden_dropout_prob=self.hidden_dropout_prob				,     attention_probs_dropout_prob=self.attention_probs_dropout_prob				,     is_decoder=lowerCAmelCase_				,     initializer_range=self.initializer_range				,     encoder_stride=self.encoder_stride				,     resolution=self.resolution				,     depths=self.depths				,     hidden_sizes=self.hidden_sizes				,     dim=self.dim				,     mlp_expansion_ratio=self.mlp_expansion_ratio				,     )







							def   __lowerCAmelCase     (    self			:    Optional[Any]				,     lowerCAmelCase_			:    Union[str, Any]				,     lowerCAmelCase_			:    str				,     lowerCAmelCase_			:    Dict   )     ->				List[str]:


														"""simple docstring"""


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







							def   __lowerCAmelCase     (    self			:    Tuple				,     lowerCAmelCase_			:    Any				,     lowerCAmelCase_			:    Dict				,     lowerCAmelCase_			:    Dict   )     ->				Tuple:


														"""simple docstring"""


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

														# test greyscale images
														_a      	=							1
														_a      	=							TFEfficientFormerForImageClassification(lowerCAmelCase_   )

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







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				Optional[Any]:


														"""simple docstring"""


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



@require_tf
class      A       (						_a	,_a	,unittest.TestCase       ):
							lowercase_							     =							(
							    (
							        TFEfficientFormerModel,
							        TFEfficientFormerForImageClassificationWithTeacher,
							        TFEfficientFormerForImageClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase_							     =							(
							    {
							        'feature-extraction': TFEfficientFormerModel,
							        'image-classification': (
							            TFEfficientFormerForImageClassification,
							            TFEfficientFormerForImageClassificationWithTeacher,
							        ),
							    }
							    if is_tf_available()
							    else {}
							)

							lowercase_							     =							False

							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False
							lowercase_							     =							False







							def   __lowerCAmelCase     (    self			:    Union[str, Any]   )     ->				Optional[Any]:


														"""simple docstring"""


														_a      	=							TFEfficientFormerModelTester(self   )
														_a      	=							ConfigTester(
														    self				,     config_class=lowerCAmelCase_				,     has_text_modality=lowerCAmelCase_				,     hidden_size=37   )







							def   __lowerCAmelCase     (    self			:    str   )     ->				Union[str, Any]:


														"""simple docstring"""


														self.config_tester.run_common_tests()







							@unittest.skip(reason='''EfficientFormer does not use inputs_embeds'''   )
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				int:


														"""simple docstring"""


														pass







							@unittest.skip(reason='''EfficientFormer does not support input and output embeddings'''   )
							def   __lowerCAmelCase     (    self			:    Any   )     ->				int:


														"""simple docstring"""


														pass







							def   __lowerCAmelCase     (    self			:    int   )     ->				Optional[int]:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					_a      	=							model_class(lowerCAmelCase_   )
																					_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]				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				List[str]:


														"""simple docstring"""


														def check_hidden_states_output(lowerCAmelCase_			:    List[str]				,     lowerCAmelCase_			:    Optional[Any]				,     lowerCAmelCase_			:    Optional[int]   ):
																					_a      	=							model_class(lowerCAmelCase_   )

																					_a      	=							model(**self._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_   )				,     training=lowerCAmelCase_   )
																					_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(lowerCAmelCase_   )				,     lowerCAmelCase_   )

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

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

														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					_a      	=							True
																					check_hidden_states_output(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )

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

																					check_hidden_states_output(lowerCAmelCase_				,     lowerCAmelCase_				,     lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    str				,     lowerCAmelCase_			:    Any				,     lowerCAmelCase_			:    Optional[int]				,     lowerCAmelCase_			:    Any=False   )     ->				Dict:


														"""simple docstring"""


														_a      	=							super()._prepare_for_class(lowerCAmelCase_				,     lowerCAmelCase_				,     return_labels=lowerCAmelCase_   )

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

														return inputs_dict







							def   __lowerCAmelCase     (    self			:    Optional[int]   )     ->				int:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCAmelCase_   )







							@unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet'''   )
							def   __lowerCAmelCase     (    self			:    List[Any]   )     ->				List[Any]:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_masked_image_modeling(*lowerCAmelCase_   )







							def   __lowerCAmelCase     (    self			:    Any   )     ->				Union[str, Any]:


														"""simple docstring"""


														_a      	=							self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_   )







							@slow
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				Optional[Any]:


														"""simple docstring"""


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







							def   __lowerCAmelCase     (    self			:    Dict   )     ->				List[str]:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()
														_a      	=							True

														_a      	=							getattr(self.model_tester				,     '''seq_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''encoder_seq_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''key_length'''				,     lowerCAmelCase_   )
														_a      	=							getattr(self.model_tester				,     '''chunk_length'''				,     lowerCAmelCase_   )

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

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

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

																					_a      	=							outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																					self.assertEqual(len(lowerCAmelCase_   )				,     self.model_tester.num_attention_outputs   )

																					if chunk_length is not None:
																												self.assertListEqual(
																												    list(attentions[0].shape[-4:]   )				,     [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]				,     )
																					else:
																												self.assertListEqual(
																												    list(attentions[0].shape[-3:]   )				,     [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]				,     )







							def   __lowerCAmelCase     (    self			:    int   )     ->				Optional[int]:


														"""simple docstring"""


														_a	,				_a      	=							self.model_tester.prepare_config_and_inputs_for_common()

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



def 						snake_case_       ():





							'''simple docstring'''


							_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   )     ->				Optional[Any]:


														"""simple docstring"""


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







							@slow
							def   __lowerCAmelCase     (    self			:    Any   )     ->				Optional[int]:


														"""simple docstring"""


														_a      	=							TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300'''   )
														_a      	=							self.default_image_processor
														_a      	=							prepare_img()
														_a      	=							image_processor(images=lowerCAmelCase_				,     return_tensors='''tf'''   )
														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# verify the logits
														_a      	=							tf.TensorShape((1, 10_00)   )
														self.assertEqual(outputs.logits.shape				,     lowerCAmelCase_   )
														_a      	=							tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]   )
														self.assertTrue(np.allclose(outputs.logits[0, :3]				,     lowerCAmelCase_				,     atol=1e-4   )   )







							@slow
							def   __lowerCAmelCase     (    self			:    List[str]   )     ->				Union[str, Any]:


														"""simple docstring"""


														_a      	=							TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
														    '''snap-research/efficientformer-l1-300'''   )
														_a      	=							self.default_image_processor
														_a      	=							prepare_img()
														_a      	=							image_processor(images=lowerCAmelCase_				,     return_tensors='''tf'''   )
														# forward pass
														_a      	=							model(**lowerCAmelCase_				,     training=lowerCAmelCase_   )
														# verify the logits
														_a      	=							tf.TensorShape((1, 10_00)   )
														self.assertEqual(outputs.logits.shape				,     lowerCAmelCase_   )
														_a      	=							tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]   )
														self.assertTrue(np.allclose(outputs.logits[0, :3]				,     lowerCAmelCase_				,     atol=1e-4   )   )



"""simple docstring"""





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



		def __init__(   self							,						__a							,						__a=13							,						__a=7							,						__a=True							,						__a=True							,						__a=True							,						__a=True							,						__a=99							,						__a=32							,						__a=2							,						__a=4							,						__a=37							,						__a="gelu"							,						__a=0.1							,						__a=0.1							,						__a=5_12							,						__a=16							,						__a=2							,						__a=0.02							,						__a=3							,						__a=4							,						__a=None							,						__a=0							,						)			->			Any:






							'''simple docstring'''
							_UpperCamelCase									=    parent
							_UpperCamelCase									=    batch_size
							_UpperCamelCase									=    seq_length
							_UpperCamelCase									=    is_training
							_UpperCamelCase									=    use_input_mask
							_UpperCamelCase									=    use_token_type_ids
							_UpperCamelCase									=    use_labels
							_UpperCamelCase									=    vocab_size
							_UpperCamelCase									=    hidden_size
							_UpperCamelCase									=    num_hidden_layers
							_UpperCamelCase									=    num_attention_heads
							_UpperCamelCase									=    intermediate_size
							_UpperCamelCase									=    hidden_act
							_UpperCamelCase									=    hidden_dropout_prob
							_UpperCamelCase									=    attention_probs_dropout_prob
							_UpperCamelCase									=    max_position_embeddings
							_UpperCamelCase									=    type_vocab_size
							_UpperCamelCase									=    type_sequence_label_size
							_UpperCamelCase									=    initializer_range
							_UpperCamelCase									=    num_labels
							_UpperCamelCase									=    num_choices
							_UpperCamelCase									=    scope
							_UpperCamelCase									=    projection_dim



		def 		UpperCAmelCase				(   self)			->			List[Any]:






							'''simple docstring'''
							_UpperCamelCase									=    ids_tensor([self.batch_size, self.seq_length]							,						self.vocab_size)

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

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

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

							_UpperCamelCase									=    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=__a							,						initializer_range=self.initializer_range							,						)
							_UpperCamelCase									=    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 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a)			->			Optional[int]:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRContextEncoder(config=__a)
							_UpperCamelCase									=    model(__a							,						attention_mask=__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a)
							self.parent.assertEqual(result.pooler_output.shape							,						(self.batch_size, self.projection_dim or self.hidden_size))



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRQuestionEncoder(config=__a)
							_UpperCamelCase									=    model(__a							,						attention_mask=__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a							,						token_type_ids=__a)
							_UpperCamelCase									=    model(__a)
							self.parent.assertEqual(result.pooler_output.shape							,						(self.batch_size, self.projection_dim or self.hidden_size))



		def 		UpperCAmelCase				(   self							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a							,						__a)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRReader(config=__a)
							_UpperCamelCase									=    model(__a							,						attention_mask=__a)

							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 		UpperCAmelCase				(   self)			->			Any:






							'''simple docstring'''
							_UpperCamelCase									=    self.prepare_config_and_inputs()
							(
							    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    (
							    _UpperCamelCase
							)					,    
							)									=    config_and_inputs
							_UpperCamelCase									=    {'''input_ids''': input_ids}
							return config, inputs_dict






@require_tf
class        _UpperCAmelCase(       lowerCamelCase ,	lowerCamelCase ,	unittest.TestCase      ):
		lowercase__         = (
		    (
		        TFDPRContextEncoder,
		        TFDPRQuestionEncoder,
		        TFDPRReader,
		    )
		    if is_tf_available()
		    else ()
		)
		lowercase__         = {'feature-extraction': TFDPRQuestionEncoder} if is_tf_available() else {}

		lowercase__         = False
		lowercase__         = False
		lowercase__         = False
		lowercase__         = False
		lowercase__         = False



		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRModelTester(self)
							_UpperCamelCase									=    ConfigTester(self							,						config_class=__a							,						hidden_size=37)



		def 		UpperCAmelCase				(   self)			->			Optional[int]:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_context_encoder(*__a)



		def 		UpperCAmelCase				(   self)			->			Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_question_encoder(*__a)



		def 		UpperCAmelCase				(   self)			->			Dict:






							'''simple docstring'''
							_UpperCamelCase									=    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_dpr_reader(*__a)




		@slow
		def 		UpperCAmelCase				(   self)			->			str:






							'''simple docstring'''
							for model_name in TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase									=    TFDPRContextEncoder.from_pretrained(__a)
												self.assertIsNotNone(__a)

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

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

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






@require_tf
class        _UpperCAmelCase(       unittest.TestCase      ):



		@slow
		def 		UpperCAmelCase				(   self)			->			Tuple:






							'''simple docstring'''
							_UpperCamelCase									=    TFDPRQuestionEncoder.from_pretrained('''facebook/dpr-question_encoder-single-nq-base''')

							_UpperCamelCase									=    tf.constant(
							    [[1_01, 75_92, 10_10, 20_03, 20_26, 38_99, 1_01_40, 10_29, 1_02]])  # [CLS] hello, is my dog cute? [SEP]
							_UpperCamelCase									=    model(__a)[0]  # embedding shape = (1, 768)
							# compare the actual values for a slice.
							_UpperCamelCase									=    tf.constant(
							    [
							        [
							            0.0323_6253,
							            0.1275_3335,
							            0.1681_8509,
							            0.0027_9786,
							            0.389_6933,
							            0.2426_4945,
							            0.217_8971,
							            -0.0233_5227,
							            -0.0848_1959,
							            -0.1432_4117,
							        ]
							    ])
							self.assertTrue(numpy.allclose(output[:, :10].numpy()							,						expected_slice.numpy()							,						atol=1e-4))






