



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 					__lowerCAmelCase (     lowerCamelCase__       ):




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



									"""simple docstring"""





									super().__init__(*SCREAMING_SNAKE_CASE_						,				**SCREAMING_SNAKE_CASE_		)
									_lowerCAmelCase						=    eval_examples
									_lowerCAmelCase						=    post_process_function




				def 							snake_case   (							self						,				_snake_case=None						,				_snake_case=None						,				_snake_case=None						,				_snake_case = "eval"		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.eval_dataset if eval_dataset is None else eval_dataset
									_lowerCAmelCase						=    self.get_eval_dataloader(SCREAMING_SNAKE_CASE_		)
									_lowerCAmelCase						=    self.eval_examples if eval_examples is None else eval_examples

									# Temporarily disable metric computation, we will do it in the loop here.
									_lowerCAmelCase						=    self.compute_metrics
									_lowerCAmelCase						=    None
									_lowerCAmelCase						=    self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
									_lowerCAmelCase						=    time.time()
									try:
														_lowerCAmelCase						=    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:
														_lowerCAmelCase						=    compute_metrics
									_lowerCAmelCase						=    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
														_lowerCAmelCase						=    self.post_process_function(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				output.predictions		)
														_lowerCAmelCase						=    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}_'		):
																								_lowerCAmelCase						=    metrics.pop(SCREAMING_SNAKE_CASE_		)
														metrics.update(output.metrics		)
									else:
														_lowerCAmelCase						=    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()		)

									_lowerCAmelCase						=    self.callback_handler.on_evaluate(self.args						,				self.state						,				self.control						,				SCREAMING_SNAKE_CASE_		)
									return metrics




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case=None						,				_snake_case = "test"		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.get_test_dataloader(SCREAMING_SNAKE_CASE_		)

									# Temporarily disable metric computation, we will do it in the loop here.
									_lowerCAmelCase						=    self.compute_metrics
									_lowerCAmelCase						=    None
									_lowerCAmelCase						=    self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
									_lowerCAmelCase						=    time.time()
									try:
														_lowerCAmelCase						=    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:
														_lowerCAmelCase						=    compute_metrics
									_lowerCAmelCase						=    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

									_lowerCAmelCase						=    self.post_process_function(SCREAMING_SNAKE_CASE_						,				SCREAMING_SNAKE_CASE_						,				output.predictions						,				"""predict"""		)
									_lowerCAmelCase						=    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}_'		):
																			_lowerCAmelCase						=    metrics.pop(SCREAMING_SNAKE_CASE_		)
									metrics.update(output.metrics		)
									return PredictionOutput(predictions=predictions.predictions						,				label_ids=predictions.label_ids						,				metrics=SCREAMING_SNAKE_CASE_		)





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


__a  			=					{
    'configuration_trocr': ['TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TrOCRConfig'],
    'processing_trocr': ['TrOCRProcessor'],
}


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a  			=					[
						    'TROCR_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TrOCRForCausalLM',
						    'TrOCRPreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig
						from .processing_trocr import TrOCRProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel

else:
						import sys

						__a  			=					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




