



"""simple docstring"""

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     lowerCAmelCase__						(	_lowerCamelCase ):


	'''simple docstring'''







	def __init__(      self				:       Tuple     ,       *_SCREAMING_SNAKE_CASE				:       Optional[int]     ,       _SCREAMING_SNAKE_CASE				:       Optional[int]=None     ,       _SCREAMING_SNAKE_CASE				:       Optional[int]=None     ,       **_SCREAMING_SNAKE_CASE				:       str    )						->	Optional[int]:





					"""simple docstring"""


					super().__init__(*_SCREAMING_SNAKE_CASE     ,       **_SCREAMING_SNAKE_CASE    )
					SCREAMING_SNAKE_CASE						:							int							=     eval_examples
					SCREAMING_SNAKE_CASE						:							Any							=     post_process_function





	def 			_lowerCAmelCase     (      self				:       Dict     ,       _SCREAMING_SNAKE_CASE				:       Optional[Dataset] = None     ,       _SCREAMING_SNAKE_CASE				:       Tuple=None     ,       _SCREAMING_SNAKE_CASE				:       Optional[List[str]] = None     ,       _SCREAMING_SNAKE_CASE				:       str = "eval"     ,       **_SCREAMING_SNAKE_CASE				:       Any     ,       )						->	Dict[str, float]:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Tuple							=     gen_kwargs.copy()
					SCREAMING_SNAKE_CASE						:							str							=     (
					    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						:							Dict							=     gen_kwargs

					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     self.eval_dataset if eval_dataset is None else eval_dataset
					SCREAMING_SNAKE_CASE						:							str							=     self.get_eval_dataloader(_SCREAMING_SNAKE_CASE    )
					SCREAMING_SNAKE_CASE						:							Optional[int]							=     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						:							Dict							=     self.compute_metrics
					SCREAMING_SNAKE_CASE						:							int							=     None
					SCREAMING_SNAKE_CASE						:							Any							=     time.time()
					SCREAMING_SNAKE_CASE						:							Any							=     self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
					try:
									SCREAMING_SNAKE_CASE						:							List[Any]							=     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:
									SCREAMING_SNAKE_CASE						:							Optional[Any]							=     compute_metrics
					SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     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
									SCREAMING_SNAKE_CASE						:							List[str]							=     self.post_process_function(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     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}_"""    ):
																	SCREAMING_SNAKE_CASE						:							Tuple							=     metrics.pop(_SCREAMING_SNAKE_CASE    )

									metrics.update(output.metrics    )
					else:
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     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()    )

					SCREAMING_SNAKE_CASE						:							str							=     self.callback_handler.on_evaluate(self.args     ,       self.state     ,       self.control     ,       _SCREAMING_SNAKE_CASE    )
					return metrics







	def 			_lowerCAmelCase     (      self				:       List[str]     ,       _SCREAMING_SNAKE_CASE				:       Tuple     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]     ,       _SCREAMING_SNAKE_CASE				:       Optional[Any]=None     ,       _SCREAMING_SNAKE_CASE				:       str = "test"     ,       **_SCREAMING_SNAKE_CASE				:       Optional[Any]    )						->	Any:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Tuple							=     gen_kwargs.copy()

					SCREAMING_SNAKE_CASE						:							str							=     self.get_test_dataloader(_SCREAMING_SNAKE_CASE    )

					# Temporarily disable metric computation, we will do it in the loop here.
					SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     self.compute_metrics
					SCREAMING_SNAKE_CASE						:							int							=     None
					SCREAMING_SNAKE_CASE						:							int							=     time.time()
					SCREAMING_SNAKE_CASE						:							Tuple							=     self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
					try:
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     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:
									SCREAMING_SNAKE_CASE						:							List[str]							=     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(
					        _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

					SCREAMING_SNAKE_CASE						:							Optional[Any]							=     self.post_process_function(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE     ,       'predict'    )
					SCREAMING_SNAKE_CASE						:							int							=     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}_"""    ):
													SCREAMING_SNAKE_CASE						:							Tuple							=     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_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
)


A_						:    Optional[int]				=      {
    'configuration_llama': ['LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LlamaConfig'],
}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    int				=      ['LlamaTokenizer']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    List[str]				=      ['LlamaTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A_						:    List[str]				=      [
							    'LlamaForCausalLM',
							    'LlamaModel',
							    'LlamaPreTrainedModel',
							    'LlamaForSequenceClassification',
							]


if TYPE_CHECKING:
							from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_llama import LlamaTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_llama_fast import LlamaTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
							import sys

							A_						:    str				=      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





