


from . import __version__

# Backward compatibility imports, to make sure all those objects can be found in file_utils
from .utils import (
    CLOUDFRONT_DISTRIB_PREFIX,
    CONFIG_NAME,
    DISABLE_TELEMETRY,
    DUMMY_INPUTS,
    DUMMY_MASK,
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    FEATURE_EXTRACTOR_NAME,
    FLAX_WEIGHTS_NAME,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    MODEL_CARD_NAME,
    MULTIPLE_CHOICE_DUMMY_INPUTS,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    SENTENCEPIECE_UNDERLINE,
    SPIECE_UNDERLINE,
    TF2_WEIGHTS_NAME,
    TF_WEIGHTS_NAME,
    TORCH_FX_REQUIRED_VERSION,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
    ContextManagers,
    DummyObject,
    EntryNotFoundError,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    TensorType,
    _LazyModule,
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    cached_property,
    copy_func,
    default_cache_path,
    define_sagemaker_information,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    get_torch_version,
    has_file,
    http_user_agent,
    is_apex_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_datasets_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_librosa_available,
    is_offline_mode,
    is_onnx_available,
    is_pandas_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_tensor,
    is_tensorflow_probability_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    replace_return_docstrings,
    requires_backends,
    to_numpy,
    to_py_obj,
    torch_only_method,
)







import math
import time
from typing import Dict, List, Optional

from torch.utils.data import Dataset

from transformers import SeqaSeqTrainer, 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 							__a							(  __A						):





		'''simple docstring'''



		def __init__(						self ,    *UpperCamelCase__ ,    UpperCamelCase__=None ,    UpperCamelCase__=None ,    **UpperCamelCase__       ):
						super().__init__(*UpperCamelCase__ ,    **UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_   :	Dict													=   eval_examples
						SCREAMING_SNAKE_CASE_   :	int													=   post_process_function


		def   __snake_case			(						self ,    UpperCamelCase__ = None ,    UpperCamelCase__=None ,    UpperCamelCase__ = None ,    UpperCamelCase__ = "eval" ,    **UpperCamelCase__ ,    ):
						SCREAMING_SNAKE_CASE_   :	int													=   gen_kwargs.copy()
						SCREAMING_SNAKE_CASE_   :	Tuple													=   (
						    gen_kwargs['max_length'] if gen_kwargs.get('max_length'       ) is not None else self.args.generation_max_length
						)
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   (
						    gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'       ) is not None else self.args.generation_num_beams
						)
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   gen_kwargs

						SCREAMING_SNAKE_CASE_   :	Tuple													=   self.eval_dataset if eval_dataset is None else eval_dataset
						SCREAMING_SNAKE_CASE_   :	int													=   self.get_eval_dataloader(UpperCamelCase__       )
						SCREAMING_SNAKE_CASE_   :	Any													=   self.eval_examples if eval_examples is None else eval_examples

						# Temporarily disable metric computation, we will do it in the loop here.
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   self.compute_metrics
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   None
						SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   time.time()
						SCREAMING_SNAKE_CASE_   :	int													=   self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
						try:
										SCREAMING_SNAKE_CASE_   :	List[Any]													=   eval_loop(
										    UpperCamelCase__ ,    description='Evaluation' ,    prediction_loss_only=True if compute_metrics is None else None ,    ignore_keys=UpperCamelCase__ ,    metric_key_prefix=UpperCamelCase__ ,    )
						finally:
										SCREAMING_SNAKE_CASE_   :	Optional[int]													=   compute_metrics
						SCREAMING_SNAKE_CASE_   :	Dict													=   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(
						        UpperCamelCase__ ,    UpperCamelCase__ ,    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
										SCREAMING_SNAKE_CASE_   :	List[str]													=   self.post_process_function(UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__       )
										SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   self.compute_metrics(UpperCamelCase__       )

										# Prefix all keys with metric_key_prefix + '_'
										for key in list(metrics.keys()       ):
														if not key.startswith(F'''{metric_key_prefix}_'''       ):
																		SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   metrics.pop(UpperCamelCase__       )

										metrics.update(output.metrics       )
						else:
										SCREAMING_SNAKE_CASE_   :	Tuple													=   output.metrics

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

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

						SCREAMING_SNAKE_CASE_   :	Dict													=   self.callback_handler.on_evaluate(self.args ,    self.state ,    self.control ,    UpperCamelCase__       )
						return metrics






		def   __snake_case			(						self ,    UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__=None ,    UpperCamelCase__ = "test" ,    **UpperCamelCase__       ):
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   gen_kwargs.copy()

						SCREAMING_SNAKE_CASE_   :	Any													=   self.get_test_dataloader(UpperCamelCase__       )

						# Temporarily disable metric computation, we will do it in the loop here.
						SCREAMING_SNAKE_CASE_   :	Tuple													=   self.compute_metrics
						SCREAMING_SNAKE_CASE_   :	str													=   None
						SCREAMING_SNAKE_CASE_   :	Optional[Any]													=   time.time()
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
						try:
										SCREAMING_SNAKE_CASE_   :	List[str]													=   eval_loop(
										    UpperCamelCase__ ,    description='Prediction' ,    prediction_loss_only=True if compute_metrics is None else None ,    ignore_keys=UpperCamelCase__ ,    metric_key_prefix=UpperCamelCase__ ,    )
						finally:
										SCREAMING_SNAKE_CASE_   :	Union[str, Any]													=   compute_metrics

						SCREAMING_SNAKE_CASE_   :	List[str]													=   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(
						        UpperCamelCase__ ,    UpperCamelCase__ ,    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

						SCREAMING_SNAKE_CASE_   :	Optional[int]													=   self.post_process_function(UpperCamelCase__ ,    UpperCamelCase__ ,    UpperCamelCase__ ,    'predict'       )
						SCREAMING_SNAKE_CASE_   :	List[Any]													=   self.compute_metrics(UpperCamelCase__       )

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