
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_)









"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCamelCase    : List[str]				 =						{'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase    : Union[str, Any]				 =						['''XGLMTokenizer''']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase    : str				 =						['''XGLMTokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase    : Optional[int]				 =						[
							    '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''XGLMForCausalLM''',
							    '''XGLMModel''',
							    '''XGLMPreTrainedModel''',
							]


try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase    : str				 =						[
							    '''FlaxXGLMForCausalLM''',
							    '''FlaxXGLMModel''',
							    '''FlaxXGLMPreTrainedModel''',
							]


try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__UpperCamelCase    : str				 =						[
							    '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFXGLMForCausalLM''',
							    '''TFXGLMModel''',
							    '''TFXGLMPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xglm import XGLMTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xglm_fast import XGLMTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_xglm import (
														    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFXGLMForCausalLM,
														    TFXGLMModel,
														    TFXGLMPreTrainedModel,
														)


else:
							import sys

							__UpperCamelCase    : Optional[int]				 =						_LazyModule(__name__, globals()['''__file__'''], _import_structure)




