'''simple docstring'''





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





   """simple docstring"""




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



    """simple docstring"""



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



   def   lowerCAmelCase						(	self					:  Tuple							):



    """simple docstring"""



    _UpperCamelCase:     Any							= ids_tensor([self.batch_size, self.seq_length]		,  self.vocab_size							)

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

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

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

    _UpperCamelCase:     List[str]							= 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=_lowercase		,  )

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



   def   lowerCAmelCase						(	self					:  Optional[int]		,  _lowercase					:  List[str]		,  _lowercase					:  Optional[Any]		,  _lowercase					:  int		,  _lowercase					:  Tuple		,  _lowercase					:  int		,  _lowercase					:  List[str]		,  _lowercase					:  Union[str, Any]							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= TFRoFormerModel(config=_lowercase							)
    _UpperCamelCase:     Optional[int]							= {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

    _UpperCamelCase:     Any							= [input_ids, input_mask]
    _UpperCamelCase:     Optional[Any]							= model(_lowercase							)

    _UpperCamelCase:     str							= model(_lowercase							)

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



   def   lowerCAmelCase						(	self					:  Any		,  _lowercase					:  int		,  _lowercase					:  Optional[Any]		,  _lowercase					:  Dict		,  _lowercase					:  Optional[int]		,  _lowercase					:  List[Any]		,  _lowercase					:  Any		,  _lowercase					:  Optional[int]							):



    """simple docstring"""



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



   def   lowerCAmelCase						(	self					:  Union[str, Any]		,  _lowercase					:  Tuple		,  _lowercase					:  int		,  _lowercase					:  List[Any]		,  _lowercase					:  List[Any]		,  _lowercase					:  List[Any]		,  _lowercase					:  Any		,  _lowercase					:  Tuple							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= TFRoFormerForMaskedLM(config=_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= {
        '''input_ids''': input_ids,
        '''attention_mask''': input_mask,
        '''token_type_ids''': token_type_ids,
    }
    _UpperCamelCase:     str							= model(_lowercase							)
    self.parent.assertEqual(result.logits.shape		,  (self.batch_size, self.seq_length, self.vocab_size)							)



   def   lowerCAmelCase						(	self					:  str		,  _lowercase					:  str		,  _lowercase					:  List[Any]		,  _lowercase					:  Union[str, Any]		,  _lowercase					:  Optional[int]		,  _lowercase					:  str		,  _lowercase					:  List[Any]		,  _lowercase					:  Dict							):



    """simple docstring"""



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

    _UpperCamelCase:     List[str]							= model(_lowercase							)
    self.parent.assertEqual(result.logits.shape		,  (self.batch_size, self.num_labels)							)



   def   lowerCAmelCase						(	self					:  str		,  _lowercase					:  Tuple		,  _lowercase					:  Optional[int]		,  _lowercase					:  str		,  _lowercase					:  List[Any]		,  _lowercase					:  Optional[Any]		,  _lowercase					:  Tuple		,  _lowercase					:  Any							):



    """simple docstring"""



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



   def   lowerCAmelCase						(	self					:  List[str]		,  _lowercase					:  Dict		,  _lowercase					:  str		,  _lowercase					:  str		,  _lowercase					:  str		,  _lowercase					:  int		,  _lowercase					:  Optional[int]		,  _lowercase					:  Union[str, Any]							):



    """simple docstring"""



    _UpperCamelCase:     List[str]							= self.num_labels
    _UpperCamelCase:     Any							= TFRoFormerForTokenClassification(config=_lowercase							)
    _UpperCamelCase:     str							= {
        '''input_ids''': input_ids,
        '''attention_mask''': input_mask,
        '''token_type_ids''': token_type_ids,
    }
    _UpperCamelCase:     int							= model(_lowercase							)
    self.parent.assertEqual(result.logits.shape		,  (self.batch_size, self.seq_length, self.num_labels)							)



   def   lowerCAmelCase						(	self					:  Optional[Any]		,  _lowercase					:  Optional[Any]		,  _lowercase					:  List[str]		,  _lowercase					:  Optional[int]		,  _lowercase					:  List[str]		,  _lowercase					:  Union[str, Any]		,  _lowercase					:  Union[str, Any]		,  _lowercase					:  List[str]							):



    """simple docstring"""



    _UpperCamelCase:     Union[str, Any]							= TFRoFormerForQuestionAnswering(config=_lowercase							)
    _UpperCamelCase:     Tuple							= {
        '''input_ids''': input_ids,
        '''attention_mask''': input_mask,
        '''token_type_ids''': token_type_ids,
    }

    _UpperCamelCase:     Optional[Any]							= model(_lowercase							)
    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					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= self.prepare_config_and_inputs()
    (
        (
        _UpperCamelCase					
    )	,							(
        _UpperCamelCase					
    )	,							(
        _UpperCamelCase					
    )	,							(
        _UpperCamelCase					
    )	,							(
        _UpperCamelCase					
    )	,							(
        _UpperCamelCase					
    )	,							(
        _UpperCamelCase					
    )	,												
    ):     Optional[int]							= config_and_inputs
    _UpperCamelCase:     int							= {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
    return config, inputs_dict




@require_tf
class  __magic_name__  (		lowercase_      ,	lowercase_      ,	unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    Union[str, Any]  			=   (
       (
           TFRoFormerModel,
           TFRoFormerForCausalLM,
           TFRoFormerForMaskedLM,
           TFRoFormerForQuestionAnswering,
           TFRoFormerForSequenceClassification,
           TFRoFormerForTokenClassification,
           TFRoFormerForMultipleChoice,
       )
       if is_tf_available()
       else ()
   )
   lowerCAmelCase      :    List[Any]  			=   (
       {
           '''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 {}
   )

   lowerCAmelCase      :    Tuple  			=   False
   lowerCAmelCase      :    Union[str, Any]  			=   False



   def   lowerCAmelCase						(	self					:  int		,  _lowercase					:  Dict		,  _lowercase					:  List[str]		,  _lowercase					:  List[str]		,  _lowercase					:  Union[str, Any]		,  _lowercase					:  List[str]							):



    """simple docstring"""



    if pipeline_test_casse_name == "TextGenerationPipelineTests":
     return True

    return False



   def   lowerCAmelCase						(	self					:  Tuple							):



    """simple docstring"""



    _UpperCamelCase:     Optional[int]							= TFRoFormerModelTester(self							)
    _UpperCamelCase:     Any							= ConfigTester(self		,  config_class=_lowercase		,  hidden_size=37							)



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



    """simple docstring"""



    self.config_tester.run_common_tests()



   def   lowerCAmelCase						(	self					:  Tuple							):



    """simple docstring"""



    _UpperCamelCase:     Optional[int]							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*_lowercase							)



   def   lowerCAmelCase						(	self					:  str							):



    """simple docstring"""



    _UpperCamelCase:     List[str]							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_lm(*_lowercase							)



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    _UpperCamelCase:     List[str]							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_lm_head(*_lowercase							)



   def   lowerCAmelCase						(	self					:  Any							):



    """simple docstring"""



    _UpperCamelCase:     Tuple							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_multiple_choice(*_lowercase							)



   def   lowerCAmelCase						(	self					:  str							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_question_answering(*_lowercase							)



   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    _UpperCamelCase:     Union[str, Any]							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_sequence_classification(*_lowercase							)



   def   lowerCAmelCase						(	self					:  str							):



    """simple docstring"""



    _UpperCamelCase:     Any							= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_token_classification(*_lowercase							)



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



    """simple docstring"""



    _UpperCamelCase:     Union[str, Any]							= TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''							)
    self.assertIsNotNone(_lowercase							)




@require_tf
class  __magic_name__  (		unittest.TestCase    ):





   """simple docstring"""




   @slow
   def   lowerCAmelCase						(	self					:  Optional[int]							):



    """simple docstring"""



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

    # TODO Replace vocab size
    _UpperCamelCase:     str							= 50_000

    _UpperCamelCase:     Tuple							= [1, 6, vocab_size]
    self.assertEqual(output.shape		,  _lowercase							)

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

    # TODO Replace values below with what was printed above.
    _UpperCamelCase:     Union[str, Any]							= tf.constant(
        [
            [
                [-0.12053341, -1.0264901, 0.29221946],
                [-1.5133783, 0.197433, 0.15190607],
                [-5.0135403, -3.900256, -0.84038764],
            ]
        ]							)
    tf.debugging.assert_near(output[:, :3, :3]		,  _lowercase		,  atol=1E-4							)




@require_tf
class  __magic_name__  (		unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    Dict  			=   1e-4



   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= tf.constant([[4, 10]]							)
    _UpperCamelCase:     Any							= TFRoFormerSinusoidalPositionalEmbedding(num_positions=6		,  embedding_dim=6							)

    _UpperCamelCase:     Any							= emba(input_ids.shape							)
    _UpperCamelCase:     Dict							= 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(_lowercase		,  _lowercase		,  atol=self.tolerance							)



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



    """simple docstring"""



    _UpperCamelCase:     Dict							= 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],
        ]							)
    _UpperCamelCase:     Optional[Any]							= TFRoFormerSinusoidalPositionalEmbedding(num_positions=512		,  embedding_dim=512							)
    emba([2, 16, 512]							)
    _UpperCamelCase:     str							= emba.weight[:3, :5]

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




@require_tf
class  __magic_name__  (		unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    str  			=   1e-4



   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



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

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

    _UpperCamelCase:     Optional[Any]							= TFRoFormerSinusoidalPositionalEmbedding(num_positions=32		,  embedding_dim=64							)
    _UpperCamelCase:     int							= embed_positions([2, 16, 768]							)[None, None, :, :]

    _UpperCamelCase	,							_UpperCamelCase:     Any							= TFRoFormerSelfAttention.apply_rotary_position_embeddings(
        _lowercase		,  _lowercase		,  _lowercase							)

    _UpperCamelCase:     List[str]							= 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],
        ]							)
    _UpperCamelCase:     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]		,  _lowercase		,  atol=self.tolerance							)
    tf.debugging.assert_near(key_layer[0, 0, :6, :8]		,  _lowercase		,  atol=self.tolerance							)
from __future__ import annotations




def       lowerCAmelCase_     (		lowercase:							int = 4		)    ->				list[list[int]]:







 '''simple docstring'''
 _UpperCamelCase:     Dict							= abs(lowercase		) or 4
 return [[1 + x + y * row_size for x in range(lowercase		)] for y in range(lowercase		)]




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				list[list[int]]:







 '''simple docstring'''
 return reverse_row(transpose(lowercase		)		)
 # OR.. transpose(reverse_column(matrix))




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				list[list[int]]:







 '''simple docstring'''
 return reverse_row(reverse_column(lowercase		)		)
 # OR.. reverse_column(reverse_row(matrix))




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				list[list[int]]:







 '''simple docstring'''
 return reverse_column(transpose(lowercase		)		)
 # OR.. transpose(reverse_row(matrix))




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				list[list[int]]:







 '''simple docstring'''
 _UpperCamelCase:     int							= [list(lowercase		) for x in zip(*lowercase		)]
 return matrix




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				list[list[int]]:







 '''simple docstring'''
 _UpperCamelCase:     str							= matrix[::-1]
 return matrix




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				list[list[int]]:







 '''simple docstring'''
 _UpperCamelCase:     str							= [x[::-1] for x in matrix]
 return matrix




def       lowerCAmelCase_     (		lowercase:							list[list[int]]		)    ->				None:







 '''simple docstring'''
 for i in matrix:
  print(*lowercase		)


if __name__ == "__main__":
  UpperCAmelCase_			    =							make_matrix()
  print('''\norigin:\n''')
  print_matrix(matrix)
  print('''\nrotate 90 counterclockwise:\n''')
  print_matrix(rotate_aa(matrix))

  UpperCAmelCase_			    =							make_matrix()
  print('''\norigin:\n''')
  print_matrix(matrix)
  print('''\nrotate 180:\n''')
  print_matrix(rotate_aaa(matrix))

  UpperCAmelCase_			    =							make_matrix()
  print('''\norigin:\n''')
  print_matrix(matrix)
  print('''\nrotate 270 counterclockwise:\n''')
  print_matrix(rotate_aaa(matrix))