


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        snake_case_   :
					def __init__(      self   :int			,__snake_case   :Tuple			,__snake_case   :Dict=13			,__snake_case   :Dict=7			,__snake_case   :Any=True			,__snake_case   :int=True			,__snake_case   :Optional[Any]=True			,__snake_case   :int=True			,__snake_case   :Optional[Any]=99			,__snake_case   :Any=32			,__snake_case   :List[Any]=2			,__snake_case   :int=4			,__snake_case   :Optional[Any]=37			,__snake_case   :Tuple="gelu"			,__snake_case   :List[Any]=0.1			,__snake_case   :Optional[int]=0.1			,__snake_case   :Optional[Any]=5_12			,__snake_case   :List[Any]=16			,__snake_case   :Dict=2			,__snake_case   :Optional[int]=0.02			,__snake_case   :Union[str, Any]=3			,__snake_case   :Optional[int]=4			,__snake_case   :Optional[Any]=None			,)					->    List[Any]:
												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__             =     5_12
												a__             =     16
												a__             =     2
												a__             =     0.02
												a__             =     3
												a__             =     4
												a__             =     None
					def  lowerCamelCase__(      self   :List[Any]      )					->    Optional[Any]:
												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=__snake_case			,)

												return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
					def  lowerCamelCase__(      self   :Union[str, Any]			,__snake_case   :Union[str, Any]			,__snake_case   :Dict			,__snake_case   :Tuple			,__snake_case   :Tuple			,__snake_case   :List[str]			,__snake_case   :int			,__snake_case   :Union[str, Any]      )					->    str:
												a__             =     TFRoFormerModel(config=__snake_case      )
												a__             =     {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

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

												a__             =     model(__snake_case      )

												self.parent.assertEqual(result.last_hidden_state.shape			,(self.batch_size, self.seq_length, self.hidden_size)      )
					def  lowerCamelCase__(      self   :Union[str, Any]			,__snake_case   :Optional[Any]			,__snake_case   :Optional[int]			,__snake_case   :Any			,__snake_case   :Optional[Any]			,__snake_case   :Dict			,__snake_case   :Dict			,__snake_case   :Optional[Any]      )					->    Optional[Any]:
												a__             =     True
												a__             =     TFRoFormerForCausalLM(config=__snake_case      )
												a__             =     {
												    'input_ids': input_ids,
												    'attention_mask': input_mask,
												    'token_type_ids': token_type_ids,
												}
												a__             =     model(__snake_case      )['logits']
												self.parent.assertListEqual(
												    list(prediction_scores.numpy().shape      )			,[self.batch_size, self.seq_length, self.vocab_size]      )
					def  lowerCamelCase__(      self   :int			,__snake_case   :Optional[Any]			,__snake_case   :Optional[Any]			,__snake_case   :Optional[int]			,__snake_case   :Optional[int]			,__snake_case   :Dict			,__snake_case   :Any			,__snake_case   :List[Any]      )					->    Dict:
												a__             =     TFRoFormerForMaskedLM(config=__snake_case      )
												a__             =     {
												    'input_ids': input_ids,
												    'attention_mask': input_mask,
												    'token_type_ids': token_type_ids,
												}
												a__             =     model(__snake_case      )
												self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.seq_length, self.vocab_size)      )
					def  lowerCamelCase__(      self   :Tuple			,__snake_case   :str			,__snake_case   :Tuple			,__snake_case   :Tuple			,__snake_case   :List[Any]			,__snake_case   :List[str]			,__snake_case   :int			,__snake_case   :Optional[int]      )					->    Optional[int]:
												a__             =     self.num_labels
												a__             =     TFRoFormerForSequenceClassification(config=__snake_case      )
												a__             =     {
												    'input_ids': input_ids,
												    'attention_mask': input_mask,
												    'token_type_ids': token_type_ids,
												}

												a__             =     model(__snake_case      )
												self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.num_labels)      )
					def  lowerCamelCase__(      self   :Optional[Any]			,__snake_case   :Any			,__snake_case   :Optional[Any]			,__snake_case   :Dict			,__snake_case   :Dict			,__snake_case   :str			,__snake_case   :Dict			,__snake_case   :Union[str, Any]      )					->    Union[str, Any]:
												a__             =     self.num_choices
												a__             =     TFRoFormerForMultipleChoice(config=__snake_case      )
												a__             =     tf.tile(tf.expand_dims(__snake_case			,1      )			,(1, self.num_choices, 1)      )
												a__             =     tf.tile(tf.expand_dims(__snake_case			,1      )			,(1, self.num_choices, 1)      )
												a__             =     tf.tile(tf.expand_dims(__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(__snake_case      )
												self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.num_choices)      )
					def  lowerCamelCase__(      self   :Optional[Any]			,__snake_case   :str			,__snake_case   :int			,__snake_case   :List[Any]			,__snake_case   :Any			,__snake_case   :List[Any]			,__snake_case   :Any			,__snake_case   :List[str]      )					->    int:
												a__             =     self.num_labels
												a__             =     TFRoFormerForTokenClassification(config=__snake_case      )
												a__             =     {
												    'input_ids': input_ids,
												    'attention_mask': input_mask,
												    'token_type_ids': token_type_ids,
												}
												a__             =     model(__snake_case      )
												self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.seq_length, self.num_labels)      )
					def  lowerCamelCase__(      self   :Optional[int]			,__snake_case   :List[Any]			,__snake_case   :Tuple			,__snake_case   :Union[str, Any]			,__snake_case   :Tuple			,__snake_case   :int			,__snake_case   :str			,__snake_case   :Dict      )					->    List[Any]:
												a__             =     TFRoFormerForQuestionAnswering(config=__snake_case      )
												a__             =     {
												    'input_ids': input_ids,
												    'attention_mask': input_mask,
												    'token_type_ids': token_type_ids,
												}

												a__             =     model(__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   :int      )					->    Optional[Any]:
												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        snake_case_   (lowerCamelCase_	,						lowerCamelCase_	,						unittest.TestCase      ):
					UpperCAmelCase__					:    Dict          =			(
					    (
					        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__					:    Optional[int]          =			False
					UpperCAmelCase__					:    Optional[Any]          =			False
					def  lowerCamelCase__(      self   :int			,__snake_case   :List[Any]			,__snake_case   :List[str]			,__snake_case   :Tuple			,__snake_case   :Dict			,__snake_case   :Optional[int]      )					->    Union[str, Any]:
												if pipeline_test_casse_name == "TextGenerationPipelineTests":
																			return True

												return False
					def  lowerCamelCase__(      self   :Dict      )					->    Optional[int]:
												a__             =     TFRoFormerModelTester(self      )
												a__             =     ConfigTester(self			,config_class=__snake_case			,hidden_size=37      )
					def  lowerCamelCase__(      self   :Any      )					->    Optional[int]:
												self.config_tester.run_common_tests()
					def  lowerCamelCase__(      self   :Union[str, Any]      )					->    str:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__snake_case      )
					def  lowerCamelCase__(      self   :Tuple      )					->    str:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*__snake_case      )
					def  lowerCamelCase__(      self   :Optional[Any]      )					->    Dict:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_lm_head(*__snake_case      )
					def  lowerCamelCase__(      self   :Tuple      )					->    Optional[int]:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_multiple_choice(*__snake_case      )
					def  lowerCamelCase__(      self   :str      )					->    List[str]:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*__snake_case      )
					def  lowerCamelCase__(      self   :List[Any]      )					->    int:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*__snake_case      )
					def  lowerCamelCase__(      self   :Optional[Any]      )					->    List[str]:
												a__             =     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*__snake_case      )



					@slow
					def  lowerCamelCase__(      self   :Any      )					->    Any:
												a__             =     TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base'      )
												self.assertIsNotNone(__snake_case      )







@require_tf
class        snake_case_   (unittest.TestCase      ):
					@slow
					def  lowerCamelCase__(      self   :Optional[Any]      )					->    str:
												a__             =     TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base'      )
												a__             =     tf.constant([[0, 1, 2, 3, 4, 5]]      )
												a__             =     model(__snake_case      )[0]

												# TODO Replace vocab size
												a__             =     5_00_00

												a__             =     [1, 6, vocab_size]
												self.assertEqual(output.shape			,__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]			,__snake_case			,atol=1E-4      )







@require_tf
class        snake_case_   (unittest.TestCase      ):
					UpperCAmelCase__					:    Optional[Any]          =			1E-4
					def  lowerCamelCase__(      self   :Optional[int]      )					->    List[Any]:
												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(__snake_case			,__snake_case			,atol=self.tolerance      )



					def  lowerCamelCase__(      self   :Any      )					->    Tuple:
												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=5_12			,embedding_dim=5_12      )
												emba([2, 16, 5_12]      )
												a__             =     emba.weight[:3, :5]

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







@require_tf
class        snake_case_   (unittest.TestCase      ):
					UpperCAmelCase__					:    Dict          =			1E-4
					def  lowerCamelCase__(      self   :int      )					->    str:
												# 2,12,16,64
												a__             =     tf.reshape(tf.range(2 * 12 * 16 * 64			,dtype=tf.floataa      )			,shape=(2, 12, 16, 64)      ) / 1_00

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

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

												a__      ,					a__             =     TFRoFormerSelfAttention.apply_rotary_position_embeddings(
												    __snake_case			,__snake_case			,__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]			,__snake_case			,atol=self.tolerance      )
												tf.debugging.assert_near(key_layer[0, 0, :6, :8]			,__snake_case			,atol=self.tolerance      )








from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


snake_case							:       Union[str, Any]     			=      logging.get_logger(__name__)

snake_case							:       str     			=      {
    '''google/mobilenet_v2_1.4_224''': '''https://huggingface.co/google/mobilenet_v2_1.4_224/resolve/main/config.json''',
    '''google/mobilenet_v2_1.0_224''': '''https://huggingface.co/google/mobilenet_v2_1.0_224/resolve/main/config.json''',
    '''google/mobilenet_v2_0.75_160''': '''https://huggingface.co/google/mobilenet_v2_0.75_160/resolve/main/config.json''',
    '''google/mobilenet_v2_0.35_96''': '''https://huggingface.co/google/mobilenet_v2_0.35_96/resolve/main/config.json''',
    # See all MobileNetV2 models at https://huggingface.co/models?filter=mobilenet_v2
}







class        snake_case_   (lowerCamelCase_      ):
					UpperCAmelCase__					:    str          =			'''mobilenet_v2'''
					def __init__(      self   :Optional[Any]			,__snake_case   :List[Any]=3			,__snake_case   :Any=2_24			,__snake_case   :Dict=1.0			,__snake_case   :str=8			,__snake_case   :Union[str, Any]=8			,__snake_case   :Optional[Any]=6			,__snake_case   :str=32			,__snake_case   :Tuple=True			,__snake_case   :Union[str, Any]=True			,__snake_case   :Any="relu6"			,__snake_case   :List[str]=True			,__snake_case   :Dict=0.8			,__snake_case   :Optional[int]=0.02			,__snake_case   :Tuple=0.0_01			,__snake_case   :Dict=2_55			,**__snake_case   :Dict			,)					->    Any:
												super().__init__(**__snake_case      )

												if depth_multiplier <= 0:
																			raise ValueError('depth_multiplier must be greater than zero.'      )

												a__             =     num_channels
												a__             =     image_size
												a__             =     depth_multiplier
												a__             =     depth_divisible_by
												a__             =     min_depth
												a__             =     expand_ratio
												a__             =     output_stride
												a__             =     first_layer_is_expansion
												a__             =     finegrained_output
												a__             =     hidden_act
												a__             =     tf_padding
												a__             =     classifier_dropout_prob
												a__             =     initializer_range
												a__             =     layer_norm_eps
												a__             =     semantic_loss_ignore_index







class        snake_case_   (lowerCamelCase_      ):
					UpperCAmelCase__					:    Tuple          =			version.parse('''1.11'''      )
					@property
					def  lowerCamelCase__(      self   :Any      )					->    Mapping[str, Mapping[int, str]]:
												return OrderedDict([('pixel_values', {0: 'batch'})]      )
					@property
					def  lowerCamelCase__(      self   :List[str]      )					->    Mapping[str, Mapping[int, str]]:
												if self.task == "image-classification":
																			return OrderedDict([('logits', {0: 'batch'})]      )
												else:
																			return OrderedDict([('last_hidden_state', {0: 'batch'}), ('pooler_output', {0: 'batch'})]      )



					@property
					def  lowerCamelCase__(      self   :Any      )					->    float:
												return 1E-4




