




from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, 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 tensorflow as tf

							from transformers import (
							    TFDebertaVaForMaskedLM,
							    TFDebertaVaForQuestionAnswering,
							    TFDebertaVaForSequenceClassification,
							    TFDebertaVaForTokenClassification,
							    TFDebertaVaModel,
							)




class 		__A   :

						def __init__(		self :List[str]     ,			__snake_case :Optional[int]     ,			__snake_case :str=13     ,			__snake_case :int=7     ,			__snake_case :List[str]=True     ,			__snake_case :Tuple=True     ,			__snake_case :List[str]=True     ,			__snake_case :Optional[int]=True     ,			__snake_case :Tuple=99     ,			__snake_case :Tuple=32     ,			__snake_case :Optional[int]=2     ,			__snake_case :str=4     ,			__snake_case :List[Any]=37     ,			__snake_case :List[Any]="gelu"     ,			__snake_case :str=0.1     ,			__snake_case :List[str]=0.1     ,			__snake_case :Tuple=5_12     ,			__snake_case :List[Any]=16     ,			__snake_case :Union[str, Any]=2     ,			__snake_case :Tuple=0.02     ,			__snake_case :int=False     ,			__snake_case :Optional[Any]=True     ,			__snake_case :Union[str, Any]="None"     ,			__snake_case :str=3     ,			__snake_case :Any=4     ,			__snake_case :Dict=None     ,			):
										'''simple docstring'''

										__magic_name__						:						Optional[int]										=parent
										__magic_name__						:						int										=batch_size
										__magic_name__						:						str										=seq_length
										__magic_name__						:						Optional[int]										=is_training
										__magic_name__						:						Dict										=use_input_mask
										__magic_name__						:						Any										=use_token_type_ids
										__magic_name__						:						List[str]										=use_labels
										__magic_name__						:						List[str]										=vocab_size
										__magic_name__						:						Union[str, Any]										=hidden_size
										__magic_name__						:						str										=num_hidden_layers
										__magic_name__						:						Union[str, Any]										=num_attention_heads
										__magic_name__						:						int										=intermediate_size
										__magic_name__						:						List[Any]										=hidden_act
										__magic_name__						:						int										=hidden_dropout_prob
										__magic_name__						:						Dict										=attention_probs_dropout_prob
										__magic_name__						:						int										=max_position_embeddings
										__magic_name__						:						str										=type_vocab_size
										__magic_name__						:						List[Any]										=type_sequence_label_size
										__magic_name__						:						Union[str, Any]										=initializer_range
										__magic_name__						:						int										=num_labels
										__magic_name__						:						str										=num_choices
										__magic_name__						:						int										=relative_attention
										__magic_name__						:						int										=position_biased_input
										__magic_name__						:						Union[str, Any]										=pos_att_type
										__magic_name__						:						List[str]										=scope

						def      A__    (		self :Optional[int]			):
										'''simple docstring'''

										__magic_name__						:						Union[str, Any]										=ids_tensor([self.batch_size, self.seq_length]     ,			self.vocab_size			)

										__magic_name__						:						Any										=None
										if self.use_input_mask:
														__magic_name__						:						str										=random_attention_mask([self.batch_size, self.seq_length]			)

										__magic_name__						:						Union[str, Any]										=None
										if self.use_token_type_ids:
														__magic_name__						:						Any										=ids_tensor([self.batch_size, self.seq_length]     ,			self.type_vocab_size			)

										__magic_name__						:						str										=None
										__magic_name__						:						Optional[int]										=None
										__magic_name__						:						Tuple										=None
										if self.use_labels:
														__magic_name__						:						Optional[Any]										=ids_tensor([self.batch_size]     ,			self.type_sequence_label_size			)
														__magic_name__						:						Optional[int]										=ids_tensor([self.batch_size, self.seq_length]     ,			self.num_labels			)

										__magic_name__						:						str										=DebertaVaConfig(
										    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     ,			relative_attention=self.relative_attention     ,			position_biased_input=self.position_biased_input     ,			initializer_range=self.initializer_range     ,			return_dict=__snake_case     ,			)

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

						def      A__    (		self :int     ,			__snake_case :Any     ,			__snake_case :Union[str, Any]     ,			__snake_case :List[Any]     ,			__snake_case :Tuple     ,			__snake_case :Union[str, Any]     ,			__snake_case :List[str]     ,			__snake_case :List[str]			):
										'''simple docstring'''

										__magic_name__						:						Optional[Any]										=TFDebertaVaModel(config=__snake_case			)
										__magic_name__						:						Tuple										={"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

										__magic_name__						:						List[str]										=[input_ids, input_mask]
										__magic_name__						:						List[str]										=model(__snake_case			)

										__magic_name__						:						Union[str, Any]										=model(__snake_case			)

										self.parent.assertEqual(result.last_hidden_state.shape     ,			(self.batch_size, self.seq_length, self.hidden_size)			)

						def      A__    (		self :List[Any]     ,			__snake_case :List[str]     ,			__snake_case :List[str]     ,			__snake_case :Union[str, Any]     ,			__snake_case :List[str]     ,			__snake_case :Optional[Any]     ,			__snake_case :Optional[Any]     ,			__snake_case :Tuple			):
										'''simple docstring'''

										__magic_name__						:						List[str]										=TFDebertaVaForMaskedLM(config=__snake_case			)
										__magic_name__						:						Optional[int]										={
										    """input_ids""": input_ids,
										    """attention_mask""": input_mask,
										    """token_type_ids""": token_type_ids,
										}
										__magic_name__						:						int										=model(__snake_case			)
										self.parent.assertEqual(result.logits.shape     ,			(self.batch_size, self.seq_length, self.vocab_size)			)

						def      A__    (		self :Any     ,			__snake_case :Tuple     ,			__snake_case :List[str]     ,			__snake_case :int     ,			__snake_case :Any     ,			__snake_case :List[str]     ,			__snake_case :int     ,			__snake_case :Optional[Any]			):
										'''simple docstring'''

										__magic_name__						:						List[Any]										=self.num_labels
										__magic_name__						:						Union[str, Any]										=TFDebertaVaForSequenceClassification(config=__snake_case			)
										__magic_name__						:						Tuple										={
										    """input_ids""": input_ids,
										    """attention_mask""": input_mask,
										    """token_type_ids""": token_type_ids,
										}

										__magic_name__						:						int										=model(__snake_case			)
										self.parent.assertEqual(result.logits.shape     ,			(self.batch_size, self.num_labels)			)

						def      A__    (		self :Dict     ,			__snake_case :List[Any]     ,			__snake_case :Optional[int]     ,			__snake_case :str     ,			__snake_case :Dict     ,			__snake_case :int     ,			__snake_case :str     ,			__snake_case :Any			):
										'''simple docstring'''

										__magic_name__						:						Dict										=self.num_labels
										__magic_name__						:						Optional[Any]										=TFDebertaVaForTokenClassification(config=__snake_case			)
										__magic_name__						:						Optional[Any]										={
										    """input_ids""": input_ids,
										    """attention_mask""": input_mask,
										    """token_type_ids""": token_type_ids,
										}
										__magic_name__						:						int										=model(__snake_case			)
										self.parent.assertEqual(result.logits.shape     ,			(self.batch_size, self.seq_length, self.num_labels)			)

						def      A__    (		self :List[str]     ,			__snake_case :str     ,			__snake_case :Dict     ,			__snake_case :int     ,			__snake_case :Dict     ,			__snake_case :Dict     ,			__snake_case :Optional[int]     ,			__snake_case :str			):
										'''simple docstring'''

										__magic_name__						:						List[str]										=TFDebertaVaForQuestionAnswering(config=__snake_case			)
										__magic_name__						:						str										={
										    """input_ids""": input_ids,
										    """attention_mask""": input_mask,
										    """token_type_ids""": token_type_ids,
										}

										__magic_name__						:						List[Any]										=model(__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)			)


						def      A__    (		self :int			):
										'''simple docstring'''

										__magic_name__						:						Optional[int]										=self.prepare_config_and_inputs()
										(
										    (
										    __magic_name__
										)					,			(
										    __magic_name__
										)					,			(
										    __magic_name__
										)					,			(
										    __magic_name__
										)					,			(
										    __magic_name__
										)					,			(
										    __magic_name__
										)					,			(
										    __magic_name__
										)					,			
										)						:						Union[str, Any]										=config_and_inputs
										__magic_name__						:						List[Any]										={"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
										return config, inputs_dict




@require_tf
class 		__A   (      UpperCamelCase__       ,    UpperCamelCase__       ,    unittest.TestCase      ):
						UpperCamelCase      =       (
						    (
						        TFDebertaVaModel,
						        TFDebertaVaForMaskedLM,
						        TFDebertaVaForQuestionAnswering,
						        TFDebertaVaForSequenceClassification,
						        TFDebertaVaForTokenClassification,
						    )
						    if is_tf_available()
						    else ()
						)
						UpperCamelCase      =       (
						    {
						        """feature-extraction""": TFDebertaVaModel,
						        """fill-mask""": TFDebertaVaForMaskedLM,
						        """question-answering""": TFDebertaVaForQuestionAnswering,
						        """text-classification""": TFDebertaVaForSequenceClassification,
						        """token-classification""": TFDebertaVaForTokenClassification,
						        """zero-shot""": TFDebertaVaForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)

						UpperCamelCase      =       False
						UpperCamelCase      =       False

						def      A__    (		self :Optional[int]			):
										'''simple docstring'''

										__magic_name__						:						List[str]										=TFDebertaVaModelTester(self			)
										__magic_name__						:						Any										=ConfigTester(self     ,			config_class=__snake_case     ,			hidden_size=37			)

						def      A__    (		self :Union[str, Any]			):
										'''simple docstring'''

										self.config_tester.run_common_tests()

						def      A__    (		self :Tuple			):
										'''simple docstring'''

										__magic_name__						:						Any										=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*__snake_case			)

						def      A__    (		self :Union[str, Any]			):
										'''simple docstring'''

										__magic_name__						:						str										=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*__snake_case			)

						def      A__    (		self :str			):
										'''simple docstring'''

										__magic_name__						:						str										=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*__snake_case			)

						def      A__    (		self :int			):
										'''simple docstring'''

										__magic_name__						:						str										=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*__snake_case			)

						def      A__    (		self :Any			):
										'''simple docstring'''

										__magic_name__						:						List[str]										=self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*__snake_case			)


						@slow
						def      A__    (		self :Dict			):
										'''simple docstring'''

										__magic_name__						:						Any										=TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge"""			)
										self.assertIsNotNone(__snake_case			)




@require_tf
class 		__A   (      unittest.TestCase      ):

						@unittest.skip(reason="""Model not available yet"""			)
						def      A__    (		self :str			):
										'''simple docstring'''

										pass


						@slow
						def      A__    (		self :Optional[int]			):
										'''simple docstring'''

										__magic_name__						:						str										=TFDebertaVaModel.from_pretrained("""kamalkraj/deberta-v2-xlarge"""			)
										__magic_name__						:						str										=tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]			)
										__magic_name__						:						List[str]										=tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]			)
										__magic_name__						:						Tuple										=model(__snake_case     ,			attention_mask=__snake_case			)[0]

										__magic_name__						:						Any										=tf.constant(
										    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]			)
										tf.debugging.assert_near(output[:, 1:4, 1:4]     ,			__snake_case     ,			atol=1E-4			)









from __future__ import annotations

import unittest

import numpy as np

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

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


if is_tf_available():
							import tensorflow as tf

							from transformers import TFBlipTextModel
							from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST


class   __lowerCAmelCase  :
					"""simple docstring"""






					def __init__(  self       :							Dict					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Optional[Any]=12					,       _snake_case       :							Any=7					,       _snake_case       :							List[str]=True					,       _snake_case       :							int=True					,       _snake_case       :							int=True					,       _snake_case       :							Tuple=99					,       _snake_case       :							List[Any]=32					,       _snake_case       :							Optional[int]=32					,       _snake_case       :							List[str]=2					,       _snake_case       :							List[str]=4					,       _snake_case       :							List[Any]=37					,       _snake_case       :							Union[str, Any]=0.1					,       _snake_case       :							Tuple=0.1					,       _snake_case       :							Dict=5_12					,       _snake_case       :							Union[str, Any]=0.02					,       _snake_case       :							Any=0					,       _snake_case       :							Optional[Any]=None					,       ):






								"""simple docstring"""


								A__	  =     parent
								A__	  =     batch_size
								A__	  =     seq_length
								A__	  =     is_training
								A__	  =     use_input_mask
								A__	  =     use_labels
								A__	  =     vocab_size
								A__	  =     hidden_size
								A__	  =     projection_dim
								A__	  =     num_hidden_layers
								A__	  =     num_attention_heads
								A__	  =     intermediate_size
								A__	  =     dropout
								A__	  =     attention_dropout
								A__	  =     max_position_embeddings
								A__	  =     initializer_range
								A__	  =     scope
								A__	  =     bos_token_id



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     ids_tensor([self.batch_size, self.seq_length]					,       self.vocab_size       )

								A__	  =     None
								if self.use_input_mask:
											A__	  =     random_attention_mask([self.batch_size, self.seq_length]       )

								if input_mask is not None:
											A__	  =     input_mask.numpy()
											A__  ,			A__	  =     input_mask.shape
											A__	  =     np.random.randint(1					,       seq_length - 1					,       size=(batch_size,)       )
											for batch_idx, start_index in enumerate(_snake_case       ):
														A__	  =     1
														A__	  =     0

								A__	  =     self.get_config()

								return config, input_ids, tf.convert_to_tensor(_snake_case       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								return BlipTextConfig(
								    vocab_size=self.vocab_size					,       hidden_size=self.hidden_size					,       projection_dim=self.projection_dim					,       num_hidden_layers=self.num_hidden_layers					,       num_attention_heads=self.num_attention_heads					,       intermediate_size=self.intermediate_size					,       dropout=self.dropout					,       attention_dropout=self.attention_dropout					,       max_position_embeddings=self.max_position_embeddings					,       initializer_range=self.initializer_range					,       bos_token_id=self.bos_token_id					,       )



					def      _a				(  self       :							int					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Any					,       _snake_case       :							List[str]       ):






								"""simple docstring"""


								A__	  =     TFBlipTextModel(config=_snake_case       )
								A__	  =     model(_snake_case					,       attention_mask=_snake_case					,       training=_snake_case       )
								A__	  =     model(_snake_case					,       training=_snake_case       )
								self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, self.seq_length, self.hidden_size)       )
								self.parent.assertEqual(result.pooler_output.shape					,       (self.batch_size, self.hidden_size)       )



					def      _a				(  self       :							str       ):






								"""simple docstring"""


								A__	  =     self.prepare_config_and_inputs()
								A__  ,			A__  ,			A__	  =     config_and_inputs
								A__	  =     {'input_ids': input_ids, 'attention_mask': input_mask}
								return config, inputs_dict







@require_tf
class   __lowerCAmelCase  (		UpperCAmelCase_				,  unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Tuple      							=     (TFBlipTextModel,) if is_tf_available() else ()
					A__					:		Optional[int]      							=     False
					A__					:		Union[str, Any]      							=     False
					A__					:		Union[str, Any]      							=     False



					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     BlipTextModelTester(self       )
								A__	  =     ConfigTester(self					,       config_class=_snake_case					,       hidden_size=37       )



					def      _a				(  self       :							List[str]       ):






								"""simple docstring"""


								self.config_tester.run_common_tests()



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






								"""simple docstring"""


								A__	  =     self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case       )



					def      _a				(  self       :							Tuple       ):






								"""simple docstring"""


								pass



					def      _a				(  self       :							int       ):






								"""simple docstring"""


								pass



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






								"""simple docstring"""


								pass



					@unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'       )
					def      _a				(  self       :							str       ):






								"""simple docstring"""


								pass



					@unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'       )
					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								pass



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






								"""simple docstring"""


								for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											A__	  =     TFBlipTextModel.from_pretrained(_snake_case       )
											self.assertIsNotNone(_snake_case       )



					def      _a				(  self       :							int					,       _snake_case       :							int=True       ):






								"""simple docstring"""


								super().test_pt_tf_model_equivalence(allow_missing_keys=_snake_case       )




