
"""simple docstring"""





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    _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=False    ,		__a=True    ,		__a="None"    ,		__a=3    ,		__a=4    ,		__a=None    ,		)	->	int:






							'''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										=  relative_attention
							__UpperCamelCase										=  position_biased_input
							__UpperCamelCase										=  pos_att_type
							__UpperCamelCase										=  scope



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






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

							__UpperCamelCase										=  None
							if self.use_input_mask:
												__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										=  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=__a    ,		)

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






							'''simple docstring'''
							__UpperCamelCase										=  TFDebertaVaModel(config=__a)
							__UpperCamelCase										=  {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

							__UpperCamelCase										=  [input_ids, input_mask]
							__UpperCamelCase										=  model(__a)

							__UpperCamelCase										=  model(__a)

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



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






							'''simple docstring'''
							__UpperCamelCase										=  TFDebertaVaForMaskedLM(config=__a)
							__UpperCamelCase										=  {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}
							__UpperCamelCase										=  model(__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.vocab_size))



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






							'''simple docstring'''
							__UpperCamelCase										=  self.num_labels
							__UpperCamelCase										=  TFDebertaVaForSequenceClassification(config=__a)
							__UpperCamelCase										=  {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}

							__UpperCamelCase										=  model(__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.num_labels))



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






							'''simple docstring'''
							__UpperCamelCase										=  self.num_labels
							__UpperCamelCase										=  TFDebertaVaForTokenClassification(config=__a)
							__UpperCamelCase										=  {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}
							__UpperCamelCase										=  model(__a)
							self.parent.assertEqual(result.logits.shape    ,		(self.batch_size, self.seq_length, self.num_labels))



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






							'''simple docstring'''
							__UpperCamelCase										=  TFDebertaVaForQuestionAnswering(config=__a)
							__UpperCamelCase										=  {
							    """input_ids""": input_ids,
							    """attention_mask""": input_mask,
							    """token_type_ids""": token_type_ids,
							}

							__UpperCamelCase										=  model(__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))




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






							'''simple docstring'''
							__UpperCamelCase										=  self.prepare_config_and_inputs()
							(
							    __UpperCamelCase							
							)										=  config_and_inputs
							__UpperCamelCase										=  {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
							return config, inputs_dict






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

		lowercase__      =				False
		lowercase__      =				False



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






							'''simple docstring'''
							__UpperCamelCase										=  TFDebertaVaModelTester(self)
							__UpperCamelCase										=  ConfigTester(self    ,		config_class=__a    ,		hidden_size=37)



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






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



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






							'''simple docstring'''
							__UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							__UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__a)



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






							'''simple docstring'''
							__UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__a)



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






							'''simple docstring'''
							__UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__a)



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							__UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__a)




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






							'''simple docstring'''
							__UpperCamelCase										=  TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge''')
							self.assertIsNotNone(__a)






@require_tf
class    _UpperCAmelCase(   unittest.TestCase     ):



		@unittest.skip(reason='''Model not available yet''')
		def 						UpperCAmelCase							( self)	->	Optional[int]:






							'''simple docstring'''
							pass




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






							'''simple docstring'''
							__UpperCamelCase										=  TFDebertaVaModel.from_pretrained('''kamalkraj/deberta-v2-xlarge''')
							__UpperCamelCase										=  tf.constant([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]])
							__UpperCamelCase										=  tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
							__UpperCamelCase										=  model(__a    ,		attention_mask=__a)[0]

							__UpperCamelCase										=  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]    ,		__a    ,		atol=1e-4)








"""simple docstring"""





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


_a														=		logging.get_logger(__name__)

_a														=		{
    """microsoft/biogpt""": """https://huggingface.co/microsoft/biogpt/resolve/main/config.json""",
    # See all BioGPT models at https://huggingface.co/models?filter=biogpt
}






class    _UpperCAmelCase(   lowerCamelCase     ):
		lowercase__      =				'biogpt'



		def __init__( self    ,		__a=4_23_84    ,		__a=10_24    ,		__a=24    ,		__a=16    ,		__a=40_96    ,		__a="gelu"    ,		__a=0.1    ,		__a=0.1    ,		__a=10_24    ,		__a=0.02    ,		__a=1e-12    ,		__a=True    ,		__a=True    ,		__a=0.0    ,		__a=0.0    ,		__a=1    ,		__a=0    ,		__a=2    ,		**__a    ,		)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  vocab_size
							_UpperCamelCase										=  max_position_embeddings
							_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										=  initializer_range
							_UpperCamelCase										=  layer_norm_eps
							_UpperCamelCase										=  scale_embedding
							_UpperCamelCase										=  use_cache
							_UpperCamelCase										=  layerdrop
							_UpperCamelCase										=  activation_dropout
							super().__init__(pad_token_id=__a    ,		bos_token_id=__a    ,		eos_token_id=__a    ,		**__a)






