


'''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 						UpperCamelCase__       :



     """simple docstring"""






     def __init__(			self   ,						snake_case__   ,						snake_case__=13   ,						snake_case__=7   ,						snake_case__=True   ,						snake_case__=True   ,						snake_case__=True   ,						snake_case__=True   ,						snake_case__=99   ,						snake_case__=32   ,						snake_case__=2   ,						snake_case__=4   ,						snake_case__=37   ,						snake_case__="gelu"   ,						snake_case__=0.1   ,						snake_case__=0.1   ,						snake_case__=512   ,						snake_case__=16   ,						snake_case__=2   ,						snake_case__=0.02   ,						snake_case__=3   ,						snake_case__=4   ,						snake_case__=None   ,						):

            '''simple docstring'''

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







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[str]       =							ids_tensor([self.batch_size, self.seq_length]   ,						self.vocab_size )

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

            _lowerCAmelCase     :				Union[str, Any]       =							None
            if self.use_token_type_ids:
                   _lowerCAmelCase     :				Optional[Any]       =							ids_tensor([self.batch_size, self.seq_length]   ,						self.type_vocab_size )

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

            _lowerCAmelCase     :				Union[str, 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=__UpperCamelCase   ,						)

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







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Tuple       =							TFRoFormerModel(config=__UpperCamelCase )
            _lowerCAmelCase     :				Tuple       =							{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

            _lowerCAmelCase     :				int       =							[input_ids, input_mask]
            _lowerCAmelCase     :				Optional[Any]       =							model(__UpperCamelCase )

            _lowerCAmelCase     :				Union[str, Any]       =							model(__UpperCamelCase )

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







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

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







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

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







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							self.num_labels
            _lowerCAmelCase     :				Optional[int]       =							TFRoFormerForSequenceClassification(config=__UpperCamelCase )
            _lowerCAmelCase     :				Optional[Any]       =							{
                'input_ids': input_ids,
                'attention_mask': input_mask,
                'token_type_ids': token_type_ids,
            }

            _lowerCAmelCase     :				Union[str, Any]       =							model(__UpperCamelCase )
            self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels) )







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

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







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Optional[Any]       =							self.num_labels
            _lowerCAmelCase     :				List[Any]       =							TFRoFormerForTokenClassification(config=__UpperCamelCase )
            _lowerCAmelCase     :				Tuple       =							{
                'input_ids': input_ids,
                'attention_mask': input_mask,
                'token_type_ids': token_type_ids,
            }
            _lowerCAmelCase     :				Any       =							model(__UpperCamelCase )
            self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length, self.num_labels) )







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            _lowerCAmelCase     :				Dict       =							TFRoFormerForQuestionAnswering(config=__UpperCamelCase )
            _lowerCAmelCase     :				Optional[Any]       =							{
                'input_ids': input_ids,
                'attention_mask': input_mask,
                'token_type_ids': token_type_ids,
            }

            _lowerCAmelCase     :				List[Any]       =							model(__UpperCamelCase )
            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 a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Dict       =							self.prepare_config_and_inputs()
            (
                (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  (
                _lowerCAmelCase
            )      ,  
            )     :				List[str]       =							config_and_inputs
            _lowerCAmelCase     :				Tuple       =							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
            return config, inputs_dict
@require_tf
class 						UpperCamelCase__       (			_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase						):



     """simple docstring"""






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

     __magic_name__           =     False
     __magic_name__           =     False







     def a						(			self   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__   ,						snake_case__ ):

            '''simple docstring'''

            if pipeline_test_casse_name == "TextGenerationPipelineTests":
                   return True

            return False







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Any       =							TFRoFormerModelTester(self )
            _lowerCAmelCase     :				Dict       =							ConfigTester(self   ,						config_class=__UpperCamelCase   ,						hidden_size=37 )







     def a						(			self ):

            '''simple docstring'''

            self.config_tester.run_common_tests()







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Any       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__UpperCamelCase )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Optional[int]       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Optional[int]       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_lm_head(*__UpperCamelCase )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[Any]       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*__UpperCamelCase )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				str       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Any       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[Any]       =							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase )







     @slow
     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				Union[str, Any]       =							TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base' )
            self.assertIsNotNone(__UpperCamelCase )
@require_tf
class 						UpperCamelCase__       (			unittest.TestCase						):



     """simple docstring"""






     @slow
     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base' )
            _lowerCAmelCase     :				Any       =							tf.constant([[0, 1, 2, 3, 4, 5]] )
            _lowerCAmelCase     :				List[Any]       =							model(__UpperCamelCase )[0]

            # TODO Replace vocab size
            _lowerCAmelCase     :				List[Any]       =							5_0000

            _lowerCAmelCase     :				List[Any]       =							[1, 6, vocab_size]
            self.assertEqual(output.shape   ,						__UpperCamelCase )

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

            # TODO Replace values below with what was printed above.
            _lowerCAmelCase     :				Dict       =							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]   ,						__UpperCamelCase   ,						atol=1E-4 )
@require_tf
class 						UpperCamelCase__       (			unittest.TestCase						):



     """simple docstring"""






     __magic_name__           =     1E-4







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				int       =							tf.constant([[4, 10]] )
            _lowerCAmelCase     :				Tuple       =							TFRoFormerSinusoidalPositionalEmbedding(num_positions=6   ,						embedding_dim=6 )

            _lowerCAmelCase     :				Union[str, Any]       =							emba(input_ids.shape )
            _lowerCAmelCase     :				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(__UpperCamelCase   ,						__UpperCamelCase   ,						atol=self.tolerance )







     def a						(			self ):

            '''simple docstring'''

            _lowerCAmelCase     :				List[str]       =							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=512   ,						embedding_dim=512 )
            emba([2, 16, 512] )
            _lowerCAmelCase     :				List[str]       =							emba.weight[:3, :5]

            tf.debugging.assert_near(__UpperCamelCase   ,						__UpperCamelCase   ,						atol=self.tolerance )
@require_tf
class 						UpperCamelCase__       (			unittest.TestCase						):



     """simple docstring"""






     __magic_name__           =     1E-4







     def a						(			self ):

            '''simple docstring'''

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

            _lowerCAmelCase     :				Optional[int]       =							-tf.reshape(tf.range(2 * 12 * 16 * 64   ,						dtype=tf.floataa )   ,						shape=(2, 12, 16, 64) ) / 100

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

            _lowerCAmelCase      ,  _lowerCAmelCase     :				Any       =							TFRoFormerSelfAttention.apply_rotary_position_embeddings(
                __UpperCamelCase   ,						__UpperCamelCase   ,						__UpperCamelCase )

            _lowerCAmelCase     :				Optional[int]       =							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     :				int       =							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]   ,						__UpperCamelCase   ,						atol=self.tolerance )
            tf.debugging.assert_near(key_layer[0, 0, :6, :8]   ,						__UpperCamelCase   ,						atol=self.tolerance )



"""simple docstring"""



import math
import unittest


def 			_UpperCamelCase						(    _A   )     ->	bool:





    """simple docstring"""

    assert isinstance(_A       ,   _A   ) and (
        number >= 0
    ), "'number' must been an int and positive"

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5       ,   int(math.sqrt(_A   ) + 1   )       ,   6   ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True




class 		a_    (			unittest.TestCase						):







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






        '''simple docstring'''






        self.assertTrue(is_prime(2  )  )
        self.assertTrue(is_prime(3  )  )
        self.assertTrue(is_prime(5  )  )
        self.assertTrue(is_prime(7  )  )
        self.assertTrue(is_prime(11  )  )
        self.assertTrue(is_prime(13  )  )
        self.assertTrue(is_prime(17  )  )
        self.assertTrue(is_prime(19  )  )
        self.assertTrue(is_prime(23  )  )
        self.assertTrue(is_prime(29  )  )







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






        '''simple docstring'''






        with self.assertRaises(__UpperCamelCase  ):
            is_prime(-19  )
        self.assertFalse(
            is_prime(0  )  ,       """Zero doesn't have any positive factors, primes must have exactly two."""  ,       )
        self.assertFalse(
            is_prime(1  )  ,       """One only has 1 positive factor, primes must have exactly two."""  ,       )
        self.assertFalse(is_prime(2 * 2  )  )
        self.assertFalse(is_prime(2 * 3  )  )
        self.assertFalse(is_prime(3 * 3  )  )
        self.assertFalse(is_prime(3 * 5  )  )
        self.assertFalse(is_prime(3 * 5 * 7  )  )


if __name__ == "__main__":
 unittest.main()