



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



       def __init__(		self							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=13					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=7					,		__SCREAMING_SNAKE_CASE							:					Tuple=True					,		__SCREAMING_SNAKE_CASE							:					Dict=True					,		__SCREAMING_SNAKE_CASE							:					List[str]=True					,		__SCREAMING_SNAKE_CASE							:					List[Any]=True					,		__SCREAMING_SNAKE_CASE							:					List[str]=99					,		__SCREAMING_SNAKE_CASE							:					str=32					,		__SCREAMING_SNAKE_CASE							:					List[str]=2					,		__SCREAMING_SNAKE_CASE							:					Tuple=4					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=37					,		__SCREAMING_SNAKE_CASE							:					List[str]="gelu"					,		__SCREAMING_SNAKE_CASE							:					str=0.1					,		__SCREAMING_SNAKE_CASE							:					int=0.1					,		__SCREAMING_SNAKE_CASE							:					Any=512					,		__SCREAMING_SNAKE_CASE							:					Any=16					,		__SCREAMING_SNAKE_CASE							:					Any=2					,		__SCREAMING_SNAKE_CASE							:					Dict=0.02					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]=3					,		__SCREAMING_SNAKE_CASE							:					Optional[int]=4					,		__SCREAMING_SNAKE_CASE							:					List[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.02
           __a							=    3
           __a							=    4
           __a							=    None



       def 		_lowerCamelCase      (		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])

           __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=__SCREAMING_SNAKE_CASE					,		)

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



       def 		_lowerCamelCase      (		self							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Tuple):


           '''simple docstring'''

           __a							=    TFRoFormerModel(config=__SCREAMING_SNAKE_CASE)
           __a							=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

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

           __a							=    model(__SCREAMING_SNAKE_CASE)

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



       def 		_lowerCamelCase      (		self							:					str					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Dict):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					str					,		__SCREAMING_SNAKE_CASE							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Any					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					str):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Tuple):


           '''simple docstring'''

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

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



       def 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Optional[Any]					,		__SCREAMING_SNAKE_CASE							:					Tuple					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					List[str]):


           '''simple docstring'''

           __a							=    self.num_choices
           __a							=    TFRoFormerForMultipleChoice(config=__SCREAMING_SNAKE_CASE)
           __a							=    tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE					,		1)					,		(1, self.num_choices, 1))
           __a							=    tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE					,		1)					,		(1, self.num_choices, 1))
           __a							=    tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE					,		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(__SCREAMING_SNAKE_CASE)
           self.parent.assertEqual(result.logits.shape					,		(self.batch_size, self.num_choices))



       def 		_lowerCamelCase      (		self							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					List[str]					,		__SCREAMING_SNAKE_CASE							:					Optional[int]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Any):


           '''simple docstring'''

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



       def 		_lowerCamelCase      (		self							:					int					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					List[Any]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					str					,		__SCREAMING_SNAKE_CASE							:					List[Any]):


           '''simple docstring'''

           __a							=    TFRoFormerForQuestionAnswering(config=__SCREAMING_SNAKE_CASE)
           __a							=    {
               '''input_ids''': input_ids,
               '''attention_mask''': input_mask,
               '''token_type_ids''': token_type_ids,
           }

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





       def 		_lowerCamelCase      (		self							:					Dict):


           '''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    _A	(     __UpperCAmelCase				,__UpperCAmelCase				,unittest.TestCase   ):
       UpperCamelCase__  :   int						 =						(
           (
               TFRoFormerModel,
               TFRoFormerForCausalLM,
               TFRoFormerForMaskedLM,
               TFRoFormerForQuestionAnswering,
               TFRoFormerForSequenceClassification,
               TFRoFormerForTokenClassification,
               TFRoFormerForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       UpperCamelCase__  :   str						 =						(
           {
               '''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 {}
       )

       UpperCamelCase__  :   int						 =						False
       UpperCamelCase__  :   Any						 =						False



       def 		_lowerCamelCase      (		self							:					str					,		__SCREAMING_SNAKE_CASE							:					Dict					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					Union[str, Any]					,		__SCREAMING_SNAKE_CASE							:					int					,		__SCREAMING_SNAKE_CASE							:					int):


           '''simple docstring'''

           if pipeline_test_casse_name == "TextGenerationPipelineTests":
               return True

           return False



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


           '''simple docstring'''

           __a							=    TFRoFormerModelTester(self)
           __a							=    ConfigTester(self					,		config_class=__SCREAMING_SNAKE_CASE					,		hidden_size=37)



       def 		_lowerCamelCase      (		self							:					Dict):


           '''simple docstring'''

           self.config_tester.run_common_tests()



       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Any):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_lm_head(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Tuple):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					Optional[int]):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE)



       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           __a							=    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE)





       @slow
       def 		_lowerCamelCase      (		self							:					str):


           '''simple docstring'''

           __a							=    TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base''')
           self.assertIsNotNone(__SCREAMING_SNAKE_CASE)


@require_tf
class    _A	(     unittest.TestCase   ):



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


           '''simple docstring'''

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

           # TODO Replace vocab size
           __a							=    50_000

           __a							=    [1, 6, vocab_size]
           self.assertEqual(output.shape					,		__SCREAMING_SNAKE_CASE)

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

           # TODO Replace values below with what was printed above.
           __a							=    tf.constant(
               [
                   [
                       [-0.12_05_33_41, -1.0_26_49_01, 0.29_22_19_46],
                       [-1.5_13_37_83, 0.19_74_33, 0.15_19_06_07],
                       [-5.0_13_54_03, -3.90_02_56, -0.84_03_87_64],
                   ]
               ])
           tf.debugging.assert_near(output[:, :3, :3]					,		__SCREAMING_SNAKE_CASE					,		atol=1E-4)


@require_tf
class    _A	(     unittest.TestCase   ):
       UpperCamelCase__  :   str						 =						1e-4



       def 		_lowerCamelCase      (		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.00_00, 0.00_00, 0.00_00, 1.00_00, 1.00_00, 1.00_00], [0.84_15, 0.04_64, 0.00_22, 0.54_03, 0.99_89, 1.00_00]])

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





       def 		_lowerCamelCase      (		self							:					Optional[Any]):


           '''simple docstring'''

           __a							=    tf.constant(
               [
                   [0.00_00, 0.00_00, 0.00_00, 0.00_00, 0.00_00],
                   [0.84_15, 0.82_19, 0.80_20, 0.78_19, 0.76_17],
                   [0.90_93, 0.93_64, 0.95_81, 0.97_49, 0.98_70],
               ])
           __a							=    TFRoFormerSinusoidalPositionalEmbedding(num_positions=512					,		embedding_dim=512)
           emba([2, 16, 512])
           __a							=    emba.weight[:3, :5]

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


@require_tf
class    _A	(     unittest.TestCase   ):
       UpperCamelCase__  :   Union[str, Any]						 =						1e-4



       def 		_lowerCamelCase      (		self							:					str):


           '''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(
               __SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE					,		__SCREAMING_SNAKE_CASE)

           __a							=    tf.constant(
               [
                   [0.00_00, 0.01_00, 0.02_00, 0.03_00, 0.04_00, 0.05_00, 0.06_00, 0.07_00],
                   [-0.20_12, 0.88_97, 0.02_63, 0.94_01, 0.20_74, 0.94_63, 0.34_81, 0.93_43],
                   [-1.70_57, 0.62_71, -1.21_45, 1.38_97, -0.63_03, 1.76_47, -0.11_73, 1.89_85],
                   [-2.17_31, -1.63_97, -2.73_58, 0.28_54, -2.18_40, 1.71_83, -1.30_18, 2.48_71],
                   [0.27_17, -3.61_73, -2.92_06, -2.19_88, -3.66_38, 0.38_58, -2.91_55, 2.29_80],
                   [3.98_59, -2.15_80, -0.79_84, -4.49_04, -4.11_81, -2.02_52, -4.47_82, 1.12_53],
               ])
           __a							=    tf.constant(
               [
                   [0.00_00, -0.01_00, -0.02_00, -0.03_00, -0.04_00, -0.05_00, -0.06_00, -0.07_00],
                   [0.20_12, -0.88_97, -0.02_63, -0.94_01, -0.20_74, -0.94_63, -0.34_81, -0.93_43],
                   [1.70_57, -0.62_71, 1.21_45, -1.38_97, 0.63_03, -1.76_47, 0.11_73, -1.89_85],
                   [2.17_31, 1.63_97, 2.73_58, -0.28_54, 2.18_40, -1.71_83, 1.30_18, -2.48_71],
                   [-0.27_17, 3.61_73, 2.92_06, 2.19_88, 3.66_38, -0.38_58, 2.91_55, -2.29_80],
                   [-3.98_59, 2.15_80, 0.79_84, 4.49_04, 4.11_81, 2.02_52, 4.47_82, -1.12_53],
               ])

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










def 					__snake_case     (      _UpperCAmelCase       ,			_UpperCAmelCase    ):
    return base * power(_UpperCAmelCase       ,			(exponent - 1)    ) if exponent else 1


if __name__ == "__main__":
 print('''Raise base to the power of exponent using recursion...''')
 __snake_case						:List[Any]						=					int(input('''Enter the base: ''').strip())
 __snake_case						:Dict						=					int(input('''Enter the exponent: ''').strip())
 __snake_case						:int						=					power(base, abs(exponent))
 if exponent < 0:  # power() does not properly deal w/ negative exponents
  __snake_case						:Optional[Any]						=					1 / result
 print(f'{base} to the power of {exponent} is {result}')





