
import math
import time

from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput, speed_metrics


if is_torch_tpu_available(check_device=False):
     import torch_xla.core.xla_model as xm
     import torch_xla.debug.metrics as met



class    _snake_case (						UpperCAmelCase_				):


 def __init__(       self       ,	*SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_=None       ,	**SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   super().__init__(*SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_)
   lowercase__	: Optional[Any]     		=   eval_examples
   lowercase__	: Any     		=   post_process_function


 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_ = "eval"):


   '''simple docstring'''




   lowercase__	: List[str]     		=   self.eval_dataset if eval_dataset is None else eval_dataset
   lowercase__	: Union[str, Any]     		=   self.get_eval_dataloader(SCREAMING_SNAKE_CASE_)
   lowercase__	: Tuple     		=   self.eval_examples if eval_examples is None else eval_examples

   # Temporarily disable metric computation, we will do it in the loop here.
   lowercase__	: Optional[Any]     		=   self.compute_metrics
   lowercase__	: Dict     		=   None
   lowercase__	: List[Any]     		=   self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
   lowercase__	: Tuple     		=   time.time()
   try:
     lowercase__	: str     		=   eval_loop(
         SCREAMING_SNAKE_CASE_       ,	description="""Evaluation"""       ,	prediction_loss_only=True if compute_metrics is None else None       ,	ignore_keys=SCREAMING_SNAKE_CASE_       ,	metric_key_prefix=SCREAMING_SNAKE_CASE_       ,	)
   finally:
     lowercase__	: Optional[Any]     		=   compute_metrics
   lowercase__	: Tuple     		=   self.args.eval_batch_size * self.args.world_size
   if f'{metric_key_prefix}_jit_compilation_time' in output.metrics:
     start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time']
   output.metrics.update(
       speed_metrics(
           SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_       ,	num_samples=output.num_samples       ,	num_steps=math.ceil(output.num_samples / total_batch_size)       ,	))
   if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save:
     # Only the main node write the results by default
     lowercase__	: int     		=   self.post_process_function(SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_       ,	output.predictions)
     lowercase__	: List[str]     		=   self.compute_metrics(SCREAMING_SNAKE_CASE_)

     # Prefix all keys with metric_key_prefix + '_'
     for key in list(metrics.keys()):
       if not key.startswith(f'{metric_key_prefix}_'):
         lowercase__	: List[str]     		=   metrics.pop(SCREAMING_SNAKE_CASE_)
     metrics.update(output.metrics)
   else:
     lowercase__	: Tuple     		=   output.metrics

   if self.args.should_log:
     # Only the main node log the results by default
     self.log(SCREAMING_SNAKE_CASE_)

   if self.args.tpu_metrics_debug or self.args.debug:
     # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
     xm.master_print(met.metrics_report())

   lowercase__	: Tuple     		=   self.callback_handler.on_evaluate(self.args       ,	self.state       ,	self.control       ,	SCREAMING_SNAKE_CASE_)
   return metrics



 def   lowercase__  (       self       ,	SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_=None       ,	SCREAMING_SNAKE_CASE_ = "test"):


   '''simple docstring'''




   lowercase__	: List[Any]     		=   self.get_test_dataloader(SCREAMING_SNAKE_CASE_)

   # Temporarily disable metric computation, we will do it in the loop here.
   lowercase__	: List[str]     		=   self.compute_metrics
   lowercase__	: Any     		=   None
   lowercase__	: str     		=   self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
   lowercase__	: List[str]     		=   time.time()
   try:
     lowercase__	: Optional[Any]     		=   eval_loop(
         SCREAMING_SNAKE_CASE_       ,	description="""Prediction"""       ,	prediction_loss_only=True if compute_metrics is None else None       ,	ignore_keys=SCREAMING_SNAKE_CASE_       ,	metric_key_prefix=SCREAMING_SNAKE_CASE_       ,	)
   finally:
     lowercase__	: Optional[int]     		=   compute_metrics
   lowercase__	: Tuple     		=   self.args.eval_batch_size * self.args.world_size
   if f'{metric_key_prefix}_jit_compilation_time' in output.metrics:
     start_time += output.metrics[f'{metric_key_prefix}_jit_compilation_time']
   output.metrics.update(
       speed_metrics(
           SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_       ,	num_samples=output.num_samples       ,	num_steps=math.ceil(output.num_samples / total_batch_size)       ,	))

   if self.post_process_function is None or self.compute_metrics is None:
     return output

   lowercase__	: Dict     		=   self.post_process_function(SCREAMING_SNAKE_CASE_       ,	SCREAMING_SNAKE_CASE_       ,	output.predictions       ,	"""predict""")
   lowercase__	: Any     		=   self.compute_metrics(SCREAMING_SNAKE_CASE_)

   # Prefix all keys with metric_key_prefix + '_'
   for key in list(metrics.keys()):
     if not key.startswith(f'{metric_key_prefix}_'):
       lowercase__	: List[str]     		=   metrics.pop(SCREAMING_SNAKE_CASE_)
   metrics.update(output.metrics)
   return PredictionOutput(predictions=predictions.predictions       ,	label_ids=predictions.label_ids       ,	metrics=SCREAMING_SNAKE_CASE_)








from collections import OrderedDict
from typing import Mapping

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


lowerCamelCase__     :		List[Any]        = logging.get_logger(__name__)

lowerCamelCase__     :		Union[str, Any]        = {
    """YituTech/conv-bert-base""": """https://huggingface.co/YituTech/conv-bert-base/resolve/main/config.json""",
    """YituTech/conv-bert-medium-small""": (
        """https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/config.json"""
    ),
    """YituTech/conv-bert-small""": """https://huggingface.co/YituTech/conv-bert-small/resolve/main/config.json""",
    # See all ConvBERT models at https://huggingface.co/models?filter=convbert
}



class    _snake_case (						UpperCAmelCase_				):
 __lowerCAmelCase	:  Union[str, Any]	   =      'convbert'


 def __init__(       self       ,	SCREAMING_SNAKE_CASE_=3_05_22       ,	SCREAMING_SNAKE_CASE_=7_68       ,	SCREAMING_SNAKE_CASE_=12       ,	SCREAMING_SNAKE_CASE_=12       ,	SCREAMING_SNAKE_CASE_=30_72       ,	SCREAMING_SNAKE_CASE_="gelu"       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=0.1       ,	SCREAMING_SNAKE_CASE_=5_12       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=0.0_2       ,	SCREAMING_SNAKE_CASE_=1E-12       ,	SCREAMING_SNAKE_CASE_=1       ,	SCREAMING_SNAKE_CASE_=0       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=7_68       ,	SCREAMING_SNAKE_CASE_=2       ,	SCREAMING_SNAKE_CASE_=9       ,	SCREAMING_SNAKE_CASE_=1       ,	SCREAMING_SNAKE_CASE_=None       ,	**SCREAMING_SNAKE_CASE_       ,	):


   '''simple docstring'''




   super().__init__(
       pad_token_id=SCREAMING_SNAKE_CASE_       ,	bos_token_id=SCREAMING_SNAKE_CASE_       ,	eos_token_id=SCREAMING_SNAKE_CASE_       ,	**SCREAMING_SNAKE_CASE_       ,	)

   lowercase__	: Dict     		=   vocab_size
   lowercase__	: List[Any]     		=   hidden_size
   lowercase__	: Optional[Any]     		=   num_hidden_layers
   lowercase__	: Union[str, Any]     		=   num_attention_heads
   lowercase__	: List[str]     		=   intermediate_size
   lowercase__	: Optional[int]     		=   hidden_act
   lowercase__	: Tuple     		=   hidden_dropout_prob
   lowercase__	: List[str]     		=   attention_probs_dropout_prob
   lowercase__	: Tuple     		=   max_position_embeddings
   lowercase__	: Dict     		=   type_vocab_size
   lowercase__	: Union[str, Any]     		=   initializer_range
   lowercase__	: Dict     		=   layer_norm_eps
   lowercase__	: Tuple     		=   embedding_size
   lowercase__	: List[str]     		=   head_ratio
   lowercase__	: Dict     		=   conv_kernel_size
   lowercase__	: Dict     		=   num_groups
   lowercase__	: int     		=   classifier_dropout



class    _snake_case (						UpperCAmelCase_				):


 @property
 def   lowercase__  (       self):


   '''simple docstring'''




   if self.task == "multiple-choice":
     lowercase__	: Union[str, Any]     		=   {0: """batch""", 1: """choice""", 2: """sequence"""}
   else:
     lowercase__	: str     		=   {0: """batch""", 1: """sequence"""}
   return OrderedDict(
       [
           ("""input_ids""", dynamic_axis),
           ("""attention_mask""", dynamic_axis),
           ("""token_type_ids""", dynamic_axis),
       ])






