



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




		'''simple docstring'''



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

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  parent
						lowerCAmelCase__  :       Optional[Any]				=  13
						lowerCAmelCase__  :       List[str]				=  7
						lowerCAmelCase__  :       Optional[Any]				=  True
						lowerCAmelCase__  :       List[Any]				=  True
						lowerCAmelCase__  :       str				=  True
						lowerCAmelCase__  :       Union[str, Any]				=  True
						lowerCAmelCase__  :       Optional[Any]				=  99
						lowerCAmelCase__  :       int				=  32
						lowerCAmelCase__  :       List[str]				=  2
						lowerCAmelCase__  :       Any				=  4
						lowerCAmelCase__  :       Union[str, Any]				=  37
						lowerCAmelCase__  :       Optional[int]				=  '''gelu'''
						lowerCAmelCase__  :       Optional[int]				=  0.1
						lowerCAmelCase__  :       List[str]				=  0.1
						lowerCAmelCase__  :       Union[str, Any]				=  5_12
						lowerCAmelCase__  :       int				=  16
						lowerCAmelCase__  :       Union[str, Any]				=  2
						lowerCAmelCase__  :       Union[str, Any]				=  0.02
						lowerCAmelCase__  :       Dict				=  3
						lowerCAmelCase__  :       Optional[Any]				=  4
						lowerCAmelCase__  :       Optional[Any]				=  None



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

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  ids_tensor([self.batch_size, self.seq_length]	,self.vocab_size				)

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

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

						lowerCAmelCase__  :       Dict				=  None
						lowerCAmelCase__  :       List[str]				=  None
						lowerCAmelCase__  :       List[Any]				=  None
						if self.use_labels:
										lowerCAmelCase__  :       Any				=  ids_tensor([self.batch_size]	,self.type_sequence_label_size				)
										lowerCAmelCase__  :       List[Any]				=  ids_tensor([self.batch_size, self.seq_length]	,self.num_labels				)
										lowerCAmelCase__  :       List[str]				=  ids_tensor([self.batch_size]	,self.num_choices				)

						lowerCAmelCase__  :       Optional[Any]				=  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=__lowerCamelCase	,)

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



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Optional[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  TFRoFormerModel(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[Any]				=  {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

						lowerCAmelCase__  :       int				=  [input_ids, input_mask]
						lowerCAmelCase__  :       Dict				=  model(__lowerCamelCase				)

						lowerCAmelCase__  :       Optional[Any]				=  model(__lowerCamelCase				)

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



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  True
						lowerCAmelCase__  :       Any				=  TFRoFormerForCausalLM(config=__lowerCamelCase				)
						lowerCAmelCase__  :       str				=  {
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						lowerCAmelCase__  :       Union[str, Any]				=  model(__lowerCamelCase				)['''logits''']
						self.parent.assertListEqual(
						    list(prediction_scores.numpy().shape				)	,[self.batch_size, self.seq_length, self.vocab_size]				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  TFRoFormerForMaskedLM(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[int]				=  {
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						lowerCAmelCase__  :       List[Any]				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.vocab_size)				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  self.num_labels
						lowerCAmelCase__  :       List[str]				=  TFRoFormerForSequenceClassification(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[int]				=  {
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}

						lowerCAmelCase__  :       str				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels)				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  self.num_choices
						lowerCAmelCase__  :       str				=  TFRoFormerForMultipleChoice(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Union[str, Any]				=  tf.tile(tf.expand_dims(__lowerCamelCase	,1				)	,(1, self.num_choices, 1)				)
						lowerCAmelCase__  :       str				=  tf.tile(tf.expand_dims(__lowerCamelCase	,1				)	,(1, self.num_choices, 1)				)
						lowerCAmelCase__  :       Optional[Any]				=  tf.tile(tf.expand_dims(__lowerCamelCase	,1				)	,(1, self.num_choices, 1)				)
						lowerCAmelCase__  :       List[Any]				=  {
						    '''input_ids''': multiple_choice_inputs_ids,
						    '''attention_mask''': multiple_choice_input_mask,
						    '''token_type_ids''': multiple_choice_token_type_ids,
						}
						lowerCAmelCase__  :       int				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_choices)				)



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

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  self.num_labels
						lowerCAmelCase__  :       int				=  TFRoFormerForTokenClassification(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Dict				=  {
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}
						lowerCAmelCase__  :       Any				=  model(__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.seq_length, self.num_labels)				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  TFRoFormerForQuestionAnswering(config=__lowerCamelCase				)
						lowerCAmelCase__  :       Optional[int]				=  {
						    '''input_ids''': input_ids,
						    '''attention_mask''': input_mask,
						    '''token_type_ids''': token_type_ids,
						}

						lowerCAmelCase__  :       Optional[int]				=  model(__lowerCamelCase				)
						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				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.prepare_config_and_inputs()
						(
						    (
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	(
						    lowerCAmelCase__
						)		,	
						)  :       Any				=  config_and_inputs
						lowerCAmelCase__  :       Dict				=  {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
						return config, inputs_dict



@require_tf
class  lowerCamelCase__    (							lowerCamelCase__   ,       lowerCamelCase__   ,       unittest.TestCase):




		'''simple docstring'''



		snake_case_			=(
		    (
		        TFRoFormerModel,
		        TFRoFormerForCausalLM,
		        TFRoFormerForMaskedLM,
		        TFRoFormerForQuestionAnswering,
		        TFRoFormerForSequenceClassification,
		        TFRoFormerForTokenClassification,
		        TFRoFormerForMultipleChoice,
		    )
		    if is_tf_available()
		    else ()
		)
		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 {}
		)

		snake_case_			=False
		snake_case_			=False



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    str:

						"""simple docstring"""






						if pipeline_test_casse_name == "TextGenerationPipelineTests":
										return True

						return False



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  TFRoFormerModelTester(self				)
						lowerCAmelCase__  :       List[Any]				=  ConfigTester(self	,config_class=__lowerCamelCase	,hidden_size=37				)



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

						"""simple docstring"""






						self.config_tester.run_common_tests()



		def 	lowerCAmelCase__   (self				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_lm_head(*__lowerCamelCase				)



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

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase				)



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

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase				)



		@slow
		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''				)
						self.assertIsNotNone(__lowerCamelCase				)



@require_tf
class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''				)
						lowerCAmelCase__  :       Union[str, Any]				=  tf.constant([[0, 1, 2, 3, 4, 5]]				)
						lowerCAmelCase__  :       Tuple				=  model(__lowerCamelCase				)[0]

						# TODO Replace vocab size
						lowerCAmelCase__  :       List[Any]				=  5_00_00

						lowerCAmelCase__  :       Dict				=  [1, 6, vocab_size]
						self.assertEqual(output.shape	,__lowerCamelCase				)

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

						# TODO Replace values below with what was printed above.
						lowerCAmelCase__  :       Optional[Any]				=  tf.constant(
						    [
						        [
						            [-0.1205_3341, -1.026_4901, 0.2922_1946],
						            [-1.513_3783, 0.19_7433, 0.1519_0607],
						            [-5.013_5403, -3.90_0256, -0.8403_8764],
						        ]
						    ]				)
						tf.debugging.assert_near(output[:, :3, :3]	,__lowerCamelCase	,atol=1e-4				)



@require_tf
class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		snake_case_			=1e-4



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

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  tf.constant([[4, 10]]				)
						lowerCAmelCase__  :       Union[str, Any]				=  TFRoFormerSinusoidalPositionalEmbedding(num_positions=6	,embedding_dim=6				)

						lowerCAmelCase__  :       List[Any]				=  emba(input_ids.shape				)
						lowerCAmelCase__  :       List[str]				=  tf.constant(
						    [[0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 1.0000], [0.8415, 0.0464, 0.0022, 0.5403, 0.9989, 1.0000]]				)

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



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

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  tf.constant(
						    [
						        [0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
						        [0.8415, 0.8219, 0.8020, 0.7819, 0.7617],
						        [0.9093, 0.9364, 0.9581, 0.9749, 0.9870],
						    ]				)
						lowerCAmelCase__  :       Optional[int]				=  TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_12	,embedding_dim=5_12				)
						emba([2, 16, 5_12]				)
						lowerCAmelCase__  :       List[str]				=  emba.weight[:3, :5]

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



@require_tf
class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		snake_case_			=1e-4



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

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  tf.reshape(tf.range(2 * 12 * 16 * 64	,dtype=tf.floataa				)	,shape=(2, 12, 16, 64)				) / 1_00

						lowerCAmelCase__  :       List[Any]				=  -tf.reshape(tf.range(2 * 12 * 16 * 64	,dtype=tf.floataa				)	,shape=(2, 12, 16, 64)				) / 1_00

						lowerCAmelCase__  :       Optional[int]				=  TFRoFormerSinusoidalPositionalEmbedding(num_positions=32	,embedding_dim=64				)
						lowerCAmelCase__  :       str				=  embed_positions([2, 16, 7_68]				)[None, None, :, :]

						lowerCAmelCase__		,	lowerCAmelCase__  :       Any				=  TFRoFormerSelfAttention.apply_rotary_position_embeddings(
						    __lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)

						lowerCAmelCase__  :       Any				=  tf.constant(
						    [
						        [0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700],
						        [-0.2012, 0.8897, 0.0263, 0.9401, 0.2074, 0.9463, 0.3481, 0.9343],
						        [-1.7057, 0.6271, -1.2145, 1.3897, -0.6303, 1.7647, -0.1173, 1.8985],
						        [-2.1731, -1.6397, -2.7358, 0.2854, -2.1840, 1.7183, -1.3018, 2.4871],
						        [0.2717, -3.6173, -2.9206, -2.1988, -3.6638, 0.3858, -2.9155, 2.2980],
						        [3.9859, -2.1580, -0.7984, -4.4904, -4.1181, -2.0252, -4.4782, 1.1253],
						    ]				)
						lowerCAmelCase__  :       Optional[Any]				=  tf.constant(
						    [
						        [0.0000, -0.0100, -0.0200, -0.0300, -0.0400, -0.0500, -0.0600, -0.0700],
						        [0.2012, -0.8897, -0.0263, -0.9401, -0.2074, -0.9463, -0.3481, -0.9343],
						        [1.7057, -0.6271, 1.2145, -1.3897, 0.6303, -1.7647, 0.1173, -1.8985],
						        [2.1731, 1.6397, 2.7358, -0.2854, 2.1840, -1.7183, 1.3018, -2.4871],
						        [-0.2717, 3.6173, 2.9206, 2.1988, 3.6638, -0.3858, 2.9155, -2.2980],
						        [-3.9859, 2.1580, 0.7984, 4.4904, 4.1181, 2.0252, 4.4782, -1.1253],
						    ]				)

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






from __future__ import annotations






def 			lowerCAmelCase__	(					lowerCamelCase_	:	int):





				'''simple docstring'''

				lowerCAmelCase__  :       Optional[int]				=  str(lowerCamelCase_)
				return len(lowerCamelCase_) == 9 and set(lowerCamelCase_) == set('''123456789''')






def 			lowerCAmelCase__	(					):





				'''simple docstring'''

				for base_num in range(9999 ,4999 ,-1):
								lowerCAmelCase__  :       Union[str, Any]				=  100002 * base_num
								if is_9_pandigital(lowerCamelCase_):
												return candidate

				for base_num in range(333 ,99 ,-1):
								lowerCAmelCase__  :       Any				=  1002003 * base_num
								if is_9_pandigital(lowerCamelCase_):
												return candidate

				return None


if __name__ == "__main__":
							print(f"""{solution() = }""")

