




from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
					import tensorflow as tf


__A        =    logging.get_logger(__name__)







@dataclass
class     __lowerCAmelCase (       __magic_name__ ):

			"""simple docstring"""







			snake_case_   		=       [
			    '''no_inference''',
			    '''no_cuda''',
			    '''no_tpu''',
			    '''no_speed''',
			    '''no_memory''',
			    '''no_env_print''',
			    '''no_multi_process''',
			]


			def __init__(      self			,						**lowerCamelCase__							)    ->      int:



							'''simple docstring'''
							for deprecated_arg in self.deprecated_args:
											if deprecated_arg in kwargs:
															__lowerCamelCase		       =    deprecated_arg[3:]
															__lowerCamelCase		       =    not kwargs.pop(lowerCamelCase__							)
															logger.warning(
															    f"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
															    f""" {positive_arg}={kwargs[positive_arg]}"""							)
							__lowerCamelCase		       =    kwargs.pop('tpu_name'			,						self.tpu_name							)
							__lowerCamelCase		       =    kwargs.pop('device_idx'			,						self.device_idx							)
							__lowerCamelCase		       =    kwargs.pop('eager_mode'			,						self.eager_mode							)
							__lowerCamelCase		       =    kwargs.pop('use_xla'			,						self.use_xla							)
							super().__init__(**lowerCamelCase__							)

			snake_case_   		=       field(
			    default=__magic_name__			,				metadata={'''help''': '''Name of TPU'''}			,				)
			snake_case_   		=       field(
			    default=0			,				metadata={'''help''': '''CPU / GPU device index. Defaults to 0.'''}			,				)
			snake_case_   		=       field(default=__magic_name__			,				metadata={'''help''': '''Benchmark models in eager model.'''} )
			snake_case_   		=       field(
			    default=__magic_name__			,				metadata={
			        '''help''': '''Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`.'''
			    }			,				)


			@cached_property
			def       lowercase_    (      self							)    ->      Tuple["tf.distribute.cluster_resolver.TPUClusterResolver"]:



							'''simple docstring'''
							requires_backends(self			,						['tf']							)
							__lowerCamelCase		       =    None
							if self.tpu:
											try:
															if self.tpu_name:
																			__lowerCamelCase		       =    tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name							)
															else:
																			__lowerCamelCase		       =    tf.distribute.cluster_resolver.TPUClusterResolver()
											except ValueError:
															__lowerCamelCase		       =    None
							return tpu


			@cached_property
			def       lowercase_    (      self							)    ->      Tuple["tf.distribute.Strategy", "tf.distribute.cluster_resolver.TPUClusterResolver"]:



							'''simple docstring'''
							requires_backends(self			,						['tf']							)
							if self.is_tpu:
											tf.config.experimental_connect_to_cluster(self._setup_tpu							)
											tf.tpu.experimental.initialize_tpu_system(self._setup_tpu							)

											__lowerCamelCase		       =    tf.distribute.TPUStrategy(self._setup_tpu							)
							else:
											# currently no multi gpu is allowed
											if self.is_gpu:
															# TODO: Currently only single GPU is supported
															tf.config.set_visible_devices(self.gpu_list[self.device_idx]			,						'GPU'							)
															__lowerCamelCase		       =    tf.distribute.OneDeviceStrategy(device=f"""/gpu:{self.device_idx}"""							)
											else:
															tf.config.set_visible_devices([]			,						'GPU'							)  # disable GPU
															__lowerCamelCase		       =    tf.distribute.OneDeviceStrategy(device=f"""/cpu:{self.device_idx}"""							)

							return strategy


			@property
			def       lowercase_    (      self							)    ->      bool:



							'''simple docstring'''
							requires_backends(self			,						['tf']							)
							return self._setup_tpu is not None


			@property
			def       lowercase_    (      self							)    ->      "tf.distribute.Strategy":



							'''simple docstring'''
							requires_backends(self			,						['tf']							)
							return self._setup_strategy


			@property
			def       lowercase_    (      self							)    ->      Any:



							'''simple docstring'''
							requires_backends(self			,						['tf']							)
							return tf.config.list_physical_devices('GPU'							)


			@property
			def       lowercase_    (      self							)    ->      int:



							'''simple docstring'''
							requires_backends(self			,						['tf']							)
							if self.cuda:
											return len(self.gpu_list							)
							return 0






			@property
			def       lowercase_    (      self							)    ->      bool:



							'''simple docstring'''
							return self.n_gpu > 0








from __future__ import annotations

from typing import Dict

from ...configuration_utils import PretrainedConfig


_UpperCAmelCase		:  Tuple	=   {
    "susnato/ernie-m-base_pytorch": "https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/config.json",
    "susnato/ernie-m-large_pytorch": "https://huggingface.co/susnato/ernie-m-large_pytorch/blob/main/config.json",
}




class       __lowerCAmelCase				(							lowerCAmelCase):
       _a           =  '''ernie_m'''
       _a           =  {"dropout": "classifier_dropout", "num_classes": "num_labels"}






       def __init__(      self:    List[Any]				,    _lowerCAmelCase:    int = 25_00_02				,    _lowerCAmelCase:    int = 7_68				,    _lowerCAmelCase:    int = 12				,    _lowerCAmelCase:    int = 12				,    _lowerCAmelCase:    int = 30_72				,    _lowerCAmelCase:    str = "gelu"				,    _lowerCAmelCase:    float = 0.1				,    _lowerCAmelCase:    float = 0.1				,    _lowerCAmelCase:    int = 5_14				,    _lowerCAmelCase:    float = 0.02				,    _lowerCAmelCase:    int = 1				,    _lowerCAmelCase:    float = 1e-0_5				,    _lowerCAmelCase:    Dict=None				,    _lowerCAmelCase:    Optional[int]=False				,    _lowerCAmelCase:    List[str]=0.0				,    **_lowerCAmelCase:    Tuple				,    ):
         super().__init__(pad_token_id=_lowerCAmelCase				,    **_lowerCAmelCase )
         lowercase			:Tuple							=  vocab_size
         lowercase			:List[str]							=  hidden_size
         lowercase			:Optional[int]							=  num_hidden_layers
         lowercase			:Optional[Any]							=  num_attention_heads
         lowercase			:Optional[Any]							=  intermediate_size
         lowercase			:Optional[Any]							=  hidden_act
         lowercase			:Any							=  hidden_dropout_prob
         lowercase			:int							=  attention_probs_dropout_prob
         lowercase			:Dict							=  max_position_embeddings
         lowercase			:Optional[Any]							=  initializer_range
         lowercase			:Any							=  layer_norm_eps
         lowercase			:Union[str, Any]							=  classifier_dropout
         lowercase			:int							=  is_decoder
         lowercase			:List[str]							=  act_dropout



