






from __future__ import annotations

import unittest

from transformers import RoFormerConfig, 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 (
	    TFRoFormerForCausalLM,
	    TFRoFormerForMaskedLM,
	    TFRoFormerForMultipleChoice,
	    TFRoFormerForQuestionAnswering,
	    TFRoFormerForSequenceClassification,
	    TFRoFormerForTokenClassification,
	    TFRoFormerModel,
	)
	from transformers.models.roformer.modeling_tf_roformer import (
	    TFRoFormerSelfAttention,
	    TFRoFormerSinusoidalPositionalEmbedding,
	)







class        _SCREAMING_SNAKE_CASE						:





							"""simple docstring"""





							def __init__(   self:     Any				,		__A:     str				,		__A:     Union[str, Any]=13				,		__A:     Tuple=7				,		__A:     Optional[int]=True				,		__A:     Any=True				,		__A:     Optional[Any]=True				,		__A:     Dict=True				,		__A:     List[Any]=99				,		__A:     Any=32				,		__A:     Union[str, Any]=2				,		__A:     Optional[Any]=4				,		__A:     Optional[Any]=37				,		__A:     Tuple="gelu"				,		__A:     Optional[Any]=0.1				,		__A:     Any=0.1				,		__A:     str=512				,		__A:     Union[str, Any]=16				,		__A:     Union[str, Any]=2				,		__A:     List[Any]=0.0_2				,		__A:     Any=3				,		__A:     Dict=4				,		__A:     Union[str, Any]=None				,		):

												'''simple docstring'''

												a__          =  parent
												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__          =  512
												a__          =  16
												a__          =  2
												a__          =  0.0_2
												a__          =  3
												a__          =  4
												a__          =  None




							def  lowercase		(   self:     int    ):

												'''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]    )

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

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

												a__          =  RoFormerConfig(
												    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				,		initializer_range=self.initializer_range				,		return_dict=__A				,		)

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




							def  lowercase		(   self:     int				,		__A:     Dict				,		__A:     Union[str, Any]				,		__A:     str				,		__A:     int				,		__A:     Any				,		__A:     List[Any]				,		__A:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  TFRoFormerModel(config=__A    )
												a__          =  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

												a__          =  [input_ids, input_mask]
												a__          =  model(__A    )

												a__          =  model(__A    )

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




							def  lowercase		(   self:     int				,		__A:     Optional[Any]				,		__A:     Any				,		__A:     List[str]				,		__A:     Optional[int]				,		__A:     int				,		__A:     Optional[int]				,		__A:     str    ):

												'''simple docstring'''

												a__          =  True
												a__          =  TFRoFormerForCausalLM(config=__A    )
												a__          =  {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}
												a__          =  model(__A    )['''logits''']
												self.parent.assertListEqual(
												    list(prediction_scores.numpy().shape    )				,		[self.batch_size, self.seq_length, self.vocab_size]    )




							def  lowercase		(   self:     Optional[int]				,		__A:     Tuple				,		__A:     int				,		__A:     int				,		__A:     Union[str, Any]				,		__A:     Tuple				,		__A:     Any				,		__A:     Any    ):

												'''simple docstring'''

												a__          =  TFRoFormerForMaskedLM(config=__A    )
												a__          =  {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}
												a__          =  model(__A    )
												self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.vocab_size)    )




							def  lowercase		(   self:     Any				,		__A:     List[str]				,		__A:     str				,		__A:     List[Any]				,		__A:     List[str]				,		__A:     Dict				,		__A:     Optional[Any]				,		__A:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  self.num_labels
												a__          =  TFRoFormerForSequenceClassification(config=__A    )
												a__          =  {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}

												a__          =  model(__A    )
												self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels)    )




							def  lowercase		(   self:     Tuple				,		__A:     Optional[int]				,		__A:     Any				,		__A:     str				,		__A:     int				,		__A:     Optional[int]				,		__A:     Any				,		__A:     Tuple    ):

												'''simple docstring'''

												a__          =  self.num_choices
												a__          =  TFRoFormerForMultipleChoice(config=__A    )
												a__          =  tf.tile(tf.expand_dims(__A				,		1    )				,		(1, self.num_choices, 1)    )
												a__          =  tf.tile(tf.expand_dims(__A				,		1    )				,		(1, self.num_choices, 1)    )
												a__          =  tf.tile(tf.expand_dims(__A				,		1    )				,		(1, self.num_choices, 1)    )
												a__          =  {
												    '''input_ids''': multiple_choice_inputs_ids,
												    '''attention_mask''': multiple_choice_input_mask,
												    '''token_type_ids''': multiple_choice_token_type_ids,
												}
												a__          =  model(__A    )
												self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_choices)    )




							def  lowercase		(   self:     List[Any]				,		__A:     Any				,		__A:     Dict				,		__A:     Any				,		__A:     Any				,		__A:     Optional[Any]				,		__A:     Optional[int]				,		__A:     Dict    ):

												'''simple docstring'''

												a__          =  self.num_labels
												a__          =  TFRoFormerForTokenClassification(config=__A    )
												a__          =  {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}
												a__          =  model(__A    )
												self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.seq_length, self.num_labels)    )




							def  lowercase		(   self:     List[Any]				,		__A:     Union[str, Any]				,		__A:     Dict				,		__A:     str				,		__A:     Tuple				,		__A:     Any				,		__A:     List[str]				,		__A:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  TFRoFormerForQuestionAnswering(config=__A    )
												a__          =  {
												    '''input_ids''': input_ids,
												    '''attention_mask''': input_mask,
												    '''token_type_ids''': token_type_ids,
												}

												a__          =  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  lowercase		(   self:     Tuple    ):

												'''simple docstring'''

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







@require_tf
class        _SCREAMING_SNAKE_CASE						(  __snake_case       , __snake_case       , unittest.TestCase							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =(
							    (
							        TFRoFormerModel,
							        TFRoFormerForCausalLM,
							        TFRoFormerForMaskedLM,
							        TFRoFormerForQuestionAnswering,
							        TFRoFormerForSequenceClassification,
							        TFRoFormerForTokenClassification,
							        TFRoFormerForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							_SCREAMING_SNAKE_CASE    =(
							    {
							        'feature-extraction': TFRoFormerModel,
							        'fill-mask': TFRoFormerForMaskedLM,
							        'question-answering': TFRoFormerForQuestionAnswering,
							        'text-classification': TFRoFormerForSequenceClassification,
							        'text-generation': TFRoFormerForCausalLM,
							        'token-classification': TFRoFormerForTokenClassification,
							        'zero-shot': TFRoFormerForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)

							_SCREAMING_SNAKE_CASE    =False
							_SCREAMING_SNAKE_CASE    =False




							def  lowercase		(   self:     Optional[int]				,		__A:     Dict				,		__A:     Dict				,		__A:     str				,		__A:     Tuple				,		__A:     Tuple    ):

												'''simple docstring'''

												if pipeline_test_casse_name == "TextGenerationPipelineTests":
																	return True

												return False




							def  lowercase		(   self:     Any    ):

												'''simple docstring'''

												a__          =  TFRoFormerModelTester(self    )
												a__          =  ConfigTester(self				,		config_class=__A				,		hidden_size=37    )




							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												self.config_tester.run_common_tests()




							def  lowercase		(   self:     str    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__A    )




							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*__A    )




							def  lowercase		(   self:     str    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_lm_head(*__A    )




							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_multiple_choice(*__A    )




							def  lowercase		(   self:     Any    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*__A    )




							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*__A    )




							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*__A    )





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

												'''simple docstring'''

												a__          =  TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''    )
												self.assertIsNotNone(__A    )







@require_tf
class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							@slow
							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''    )
												a__          =  tf.constant([[0, 1, 2, 3, 4, 5]]    )
												a__          =  model(__A    )[0]

												# TODO Replace vocab size
												a__          =  50000

												a__          =  [1, 6, vocab_size]
												self.assertEqual(output.shape				,		__A    )

												print(output[:, :3, :3]    )

												# TODO Replace values below with what was printed above.
												a__          =  tf.constant(
												    [
												        [
												            [-0.1_2_0_5_3_3_4_1, -1.0_2_6_4_9_0_1, 0.2_9_2_2_1_9_4_6],
												            [-1.5_1_3_3_7_8_3, 0.1_9_7_4_3_3, 0.1_5_1_9_0_6_0_7],
												            [-5.0_1_3_5_4_0_3, -3.9_0_0_2_5_6, -0.8_4_0_3_8_7_6_4],
												        ]
												    ]    )
												tf.debugging.assert_near(output[:, :3, :3]				,		__A				,		atol=1e-4    )







@require_tf
class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =1E-4




							def  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  tf.constant([[4, 10]]    )
												a__          =  TFRoFormerSinusoidalPositionalEmbedding(num_positions=6				,		embedding_dim=6    )

												a__          =  emba(input_ids.shape    )
												a__          =  tf.constant(
												    [[0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0], [0.8_4_1_5, 0.0_4_6_4, 0.0_0_2_2, 0.5_4_0_3, 0.9_9_8_9, 1.0_0_0_0]]    )

												tf.debugging.assert_near(__A				,		__A				,		atol=self.tolerance    )





							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

												a__          =  tf.constant(
												    [
												        [0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0],
												        [0.8_4_1_5, 0.8_2_1_9, 0.8_0_2_0, 0.7_8_1_9, 0.7_6_1_7],
												        [0.9_0_9_3, 0.9_3_6_4, 0.9_5_8_1, 0.9_7_4_9, 0.9_8_7_0],
												    ]    )
												a__          =  TFRoFormerSinusoidalPositionalEmbedding(num_positions=512				,		embedding_dim=512    )
												emba([2, 16, 512]    )
												a__          =  emba.weight[:3, :5]

												tf.debugging.assert_near(__A				,		__A				,		atol=self.tolerance    )







@require_tf
class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =1E-4




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

												'''simple docstring'''

												a__          =  tf.reshape(tf.range(2 * 12 * 16 * 64				,		dtype=tf.floataa    )				,		shape=(2, 12, 16, 64)    ) / 100

												a__          =  -tf.reshape(tf.range(2 * 12 * 16 * 64				,		dtype=tf.floataa    )				,		shape=(2, 12, 16, 64)    ) / 100

												a__          =  TFRoFormerSinusoidalPositionalEmbedding(num_positions=32				,		embedding_dim=64    )
												a__          =  embed_positions([2, 16, 768]    )[None, None, :, :]

												a__       ,a__          =  TFRoFormerSelfAttention.apply_rotary_position_embeddings(
												    __A				,		__A				,		__A    )

												a__          =  tf.constant(
												    [
												        [0.0_0_0_0, 0.0_1_0_0, 0.0_2_0_0, 0.0_3_0_0, 0.0_4_0_0, 0.0_5_0_0, 0.0_6_0_0, 0.0_7_0_0],
												        [-0.2_0_1_2, 0.8_8_9_7, 0.0_2_6_3, 0.9_4_0_1, 0.2_0_7_4, 0.9_4_6_3, 0.3_4_8_1, 0.9_3_4_3],
												        [-1.7_0_5_7, 0.6_2_7_1, -1.2_1_4_5, 1.3_8_9_7, -0.6_3_0_3, 1.7_6_4_7, -0.1_1_7_3, 1.8_9_8_5],
												        [-2.1_7_3_1, -1.6_3_9_7, -2.7_3_5_8, 0.2_8_5_4, -2.1_8_4_0, 1.7_1_8_3, -1.3_0_1_8, 2.4_8_7_1],
												        [0.2_7_1_7, -3.6_1_7_3, -2.9_2_0_6, -2.1_9_8_8, -3.6_6_3_8, 0.3_8_5_8, -2.9_1_5_5, 2.2_9_8_0],
												        [3.9_8_5_9, -2.1_5_8_0, -0.7_9_8_4, -4.4_9_0_4, -4.1_1_8_1, -2.0_2_5_2, -4.4_7_8_2, 1.1_2_5_3],
												    ]    )
												a__          =  tf.constant(
												    [
												        [0.0_0_0_0, -0.0_1_0_0, -0.0_2_0_0, -0.0_3_0_0, -0.0_4_0_0, -0.0_5_0_0, -0.0_6_0_0, -0.0_7_0_0],
												        [0.2_0_1_2, -0.8_8_9_7, -0.0_2_6_3, -0.9_4_0_1, -0.2_0_7_4, -0.9_4_6_3, -0.3_4_8_1, -0.9_3_4_3],
												        [1.7_0_5_7, -0.6_2_7_1, 1.2_1_4_5, -1.3_8_9_7, 0.6_3_0_3, -1.7_6_4_7, 0.1_1_7_3, -1.8_9_8_5],
												        [2.1_7_3_1, 1.6_3_9_7, 2.7_3_5_8, -0.2_8_5_4, 2.1_8_4_0, -1.7_1_8_3, 1.3_0_1_8, -2.4_8_7_1],
												        [-0.2_7_1_7, 3.6_1_7_3, 2.9_2_0_6, 2.1_9_8_8, 3.6_6_3_8, -0.3_8_5_8, 2.9_1_5_5, -2.2_9_8_0],
												        [-3.9_8_5_9, 2.1_5_8_0, 0.7_9_8_4, 4.4_9_0_4, 4.1_1_8_1, 2.0_2_5_2, 4.4_7_8_2, -1.1_2_5_3],
												    ]    )

												tf.debugging.assert_near(query_layer[0, 0, :6, :8]				,		__A				,		atol=self.tolerance    )
												tf.debugging.assert_near(key_layer[0, 0, :6, :8]				,		__A				,		atol=self.tolerance    )










"""simple docstring"""







def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					assert column_title.isupper()
					a__          =  0
					a__          =  len(lowerCamelCase_) - 1
					a__          =  0

					while index >= 0:
										a__          =  (ord(column_title[index]) - 64) * pow(26 ,     lowerCamelCase_)
										answer += value
										power += 1
										index -= 1

					return answer


if __name__ == "__main__":
	from doctest import testmod

	testmod()


