






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		:







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







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  parent
									_SCREAMING_SNAKE_CASE	      =  13
									_SCREAMING_SNAKE_CASE	      =  7
									_SCREAMING_SNAKE_CASE	      =  True
									_SCREAMING_SNAKE_CASE	      =  True
									_SCREAMING_SNAKE_CASE	      =  True
									_SCREAMING_SNAKE_CASE	      =  True
									_SCREAMING_SNAKE_CASE	      =  99
									_SCREAMING_SNAKE_CASE	      =  32
									_SCREAMING_SNAKE_CASE	      =  2
									_SCREAMING_SNAKE_CASE	      =  4
									_SCREAMING_SNAKE_CASE	      =  37
									_SCREAMING_SNAKE_CASE	      =  """gelu"""
									_SCREAMING_SNAKE_CASE	      =  0.1
									_SCREAMING_SNAKE_CASE	      =  0.1
									_SCREAMING_SNAKE_CASE	      =  512
									_SCREAMING_SNAKE_CASE	      =  16
									_SCREAMING_SNAKE_CASE	      =  2
									_SCREAMING_SNAKE_CASE	      =  0.02
									_SCREAMING_SNAKE_CASE	      =  3
									_SCREAMING_SNAKE_CASE	      =  4
									_SCREAMING_SNAKE_CASE	      =  None







			def 							UpperCamelCase      (	self:  List[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  ids_tensor([self.batch_size, self.seq_length]      ,	self.vocab_size     )

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

									_SCREAMING_SNAKE_CASE	      =  None
									if self.use_token_type_ids:
															_SCREAMING_SNAKE_CASE	      =  ids_tensor([self.batch_size, self.seq_length]      ,	self.type_vocab_size     )

									_SCREAMING_SNAKE_CASE	      =  None
									_SCREAMING_SNAKE_CASE	      =  None
									_SCREAMING_SNAKE_CASE	      =  None
									if self.use_labels:
															_SCREAMING_SNAKE_CASE	      =  ids_tensor([self.batch_size]      ,	self.type_sequence_label_size     )
															_SCREAMING_SNAKE_CASE	      =  ids_tensor([self.batch_size, self.seq_length]      ,	self.num_labels     )
															_SCREAMING_SNAKE_CASE	      =  ids_tensor([self.batch_size]      ,	self.num_choices     )

									_SCREAMING_SNAKE_CASE	      =  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 							UpperCamelCase      (	self:  Union[str, Any]      ,	UpperCAmelCase_:  Union[str, Any]      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  Union[str, Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  TFRoFormerModel(config=__snake_case     )
									_SCREAMING_SNAKE_CASE	      =  {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}

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

									_SCREAMING_SNAKE_CASE	      =  model(__snake_case     )

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







			def 							UpperCamelCase      (	self:  Union[str, Any]      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  Optional[int]      ,	UpperCAmelCase_:  Any      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Optional[Any]     ):







									'''simple docstring'''




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







			def 							UpperCamelCase      (	self:  int      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  Optional[int]      ,	UpperCAmelCase_:  Optional[int]      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Any      ,	UpperCAmelCase_:  List[Any]     ):







									'''simple docstring'''




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







			def 							UpperCamelCase      (	self:  Tuple      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  Optional[int]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.num_labels
									_SCREAMING_SNAKE_CASE	      =  TFRoFormerForSequenceClassification(config=__snake_case     )
									_SCREAMING_SNAKE_CASE	      =  {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}

									_SCREAMING_SNAKE_CASE	      =  model(__snake_case     )
									self.parent.assertEqual(result.logits.shape      ,	(self.batch_size, self.num_labels)     )







			def 							UpperCamelCase      (	self:  Optional[Any]      ,	UpperCAmelCase_:  Any      ,	UpperCAmelCase_:  Optional[Any]      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Union[str, Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.num_choices
									_SCREAMING_SNAKE_CASE	      =  TFRoFormerForMultipleChoice(config=__snake_case     )
									_SCREAMING_SNAKE_CASE	      =  tf.tile(tf.expand_dims(__snake_case      ,	1     )      ,	(1, self.num_choices, 1)     )
									_SCREAMING_SNAKE_CASE	      =  tf.tile(tf.expand_dims(__snake_case      ,	1     )      ,	(1, self.num_choices, 1)     )
									_SCREAMING_SNAKE_CASE	      =  tf.tile(tf.expand_dims(__snake_case      ,	1     )      ,	(1, self.num_choices, 1)     )
									_SCREAMING_SNAKE_CASE	      =  {
									    """input_ids""": multiple_choice_inputs_ids,
									    """attention_mask""": multiple_choice_input_mask,
									    """token_type_ids""": multiple_choice_token_type_ids,
									}
									_SCREAMING_SNAKE_CASE	      =  model(__snake_case     )
									self.parent.assertEqual(result.logits.shape      ,	(self.batch_size, self.num_choices)     )







			def 							UpperCamelCase      (	self:  Optional[Any]      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  Any      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  Any      ,	UpperCAmelCase_:  List[str]     ):







									'''simple docstring'''




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







			def 							UpperCamelCase      (	self:  Optional[int]      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  Union[str, Any]      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  int      ,	UpperCAmelCase_:  str      ,	UpperCAmelCase_:  Dict     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  TFRoFormerForQuestionAnswering(config=__snake_case     )
									_SCREAMING_SNAKE_CASE	      =  {
									    """input_ids""": input_ids,
									    """attention_mask""": input_mask,
									    """token_type_ids""": token_type_ids,
									}

									_SCREAMING_SNAKE_CASE	      =  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 							UpperCamelCase      (	self:  int     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.prepare_config_and_inputs()
									(
									    (
									    _SCREAMING_SNAKE_CASE					
									)      ,     (
									    _SCREAMING_SNAKE_CASE					
									)      ,     (
									    _SCREAMING_SNAKE_CASE					
									)      ,     (
									    _SCREAMING_SNAKE_CASE					
									)      ,     (
									    _SCREAMING_SNAKE_CASE					
									)      ,     (
									    _SCREAMING_SNAKE_CASE					
									)      ,     (
									    _SCREAMING_SNAKE_CASE					
									)      ,     					
									)	      =  config_and_inputs
									_SCREAMING_SNAKE_CASE	      =  {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
									return config, inputs_dict



@require_tf
class       __UpperCAmelCase		(lowerCamelCase_       ,lowerCamelCase_       ,unittest.TestCase    ):
			__snake_case				:      Dict 						=							(
			    (
			        TFRoFormerModel,
			        TFRoFormerForCausalLM,
			        TFRoFormerForMaskedLM,
			        TFRoFormerForQuestionAnswering,
			        TFRoFormerForSequenceClassification,
			        TFRoFormerForTokenClassification,
			        TFRoFormerForMultipleChoice,
			    )
			    if is_tf_available()
			    else ()
			)
			__snake_case				:      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 {}
			)

			__snake_case				:      Optional[int] 						=							False
			__snake_case				:      Optional[Any] 						=							False







			def 							UpperCamelCase      (	self:  int      ,	UpperCAmelCase_:  List[Any]      ,	UpperCAmelCase_:  List[str]      ,	UpperCAmelCase_:  Tuple      ,	UpperCAmelCase_:  Dict      ,	UpperCAmelCase_:  Optional[int]     ):







									'''simple docstring'''




									if pipeline_test_casse_name == "TextGenerationPipelineTests":
															return True

									return False







			def 							UpperCamelCase      (	self:  Dict     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  TFRoFormerModelTester(self     )
									_SCREAMING_SNAKE_CASE	      =  ConfigTester(self      ,	config_class=__snake_case      ,	hidden_size=37     )







			def 							UpperCamelCase      (	self:  Any     ):







									'''simple docstring'''




									self.config_tester.run_common_tests()







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







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*__snake_case     )







			def 							UpperCamelCase      (	self:  Tuple     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_lm(*__snake_case     )







			def 							UpperCamelCase      (	self:  Optional[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_lm_head(*__snake_case     )







			def 							UpperCamelCase      (	self:  Tuple     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_multiple_choice(*__snake_case     )







			def 							UpperCamelCase      (	self:  str     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*__snake_case     )







			def 							UpperCamelCase      (	self:  List[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*__snake_case     )







			def 							UpperCamelCase      (	self:  Optional[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*__snake_case     )







			@slow
			def 							UpperCamelCase      (	self:  Any     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  TFRoFormerModel.from_pretrained("""junnyu/roformer_chinese_base"""     )
									self.assertIsNotNone(__snake_case     )



@require_tf
class       __UpperCAmelCase		(unittest.TestCase    ):







			@slow
			def 							UpperCamelCase      (	self:  Optional[Any]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  TFRoFormerForMaskedLM.from_pretrained("""junnyu/roformer_chinese_base"""     )
									_SCREAMING_SNAKE_CASE	      =  tf.constant([[0, 1, 2, 3, 4, 5]]     )
									_SCREAMING_SNAKE_CASE	      =  model(__snake_case     )[0]

									# TODO Replace vocab size
									_SCREAMING_SNAKE_CASE	      =  50_000

									_SCREAMING_SNAKE_CASE	      =  [1, 6, vocab_size]
									self.assertEqual(output.shape      ,	__snake_case     )

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

									# TODO Replace values below with what was printed above.
									_SCREAMING_SNAKE_CASE	      =  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       __UpperCAmelCase		(unittest.TestCase    ):
			__snake_case				:      Optional[Any] 						=							1E-4







			def 							UpperCamelCase      (	self:  Optional[int]     ):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE	      =  tf.constant([[4, 10]]     )
									_SCREAMING_SNAKE_CASE	      =  TFRoFormerSinusoidalPositionalEmbedding(num_positions=6      ,	embedding_dim=6     )

									_SCREAMING_SNAKE_CASE	      =  emba(input_ids.shape     )
									_SCREAMING_SNAKE_CASE	      =  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 							UpperCamelCase      (	self:  Any     ):







									'''simple docstring'''




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

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



@require_tf
class       __UpperCAmelCase		(unittest.TestCase    ):
			__snake_case				:      Dict 						=							1E-4







			def 							UpperCamelCase      (	self:  int     ):







									'''simple docstring'''




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

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

									_SCREAMING_SNAKE_CASE	      =  TFRoFormerSinusoidalPositionalEmbedding(num_positions=32      ,	embedding_dim=64     )
									_SCREAMING_SNAKE_CASE	      =  embed_positions([2, 16, 768]     )[None, None, :, :]

									_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE	      =  TFRoFormerSelfAttention.apply_rotary_position_embeddings(
									    __snake_case      ,	__snake_case      ,	__snake_case     )

									_SCREAMING_SNAKE_CASE	      =  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],
									    ]     )
									_SCREAMING_SNAKE_CASE	      =  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




