


"""simple docstring"""






from copy import deepcopy
from pathlib import Path
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union

import torch
from torch import nn
from torch.utils.data import Dataset

from .deepspeed import is_deepspeed_zeroa_enabled
from .generation.configuration_utils import GenerationConfig
from .trainer import Trainer
from .utils import logging


if TYPE_CHECKING:
 from .data.data_collator import DataCollator
 from .modeling_utils import PreTrainedModel
 from .tokenization_utils_base import PreTrainedTokenizerBase
 from .trainer_callback import TrainerCallback
 from .trainer_utils import EvalPrediction, PredictionOutput
 from .training_args import TrainingArguments


SCREAMING_SNAKE_CASE__				:  Union[str, Any]						= logging.get_logger(__name__)


class 	A_       (     _lowercase   ):





  """simple docstring"""

  def __init__(						self  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = (None, None)  ,					__UpperCAmelCase = None  ,					)				->					List[Any]:
     super().__init__(
         model=__a  ,					args=__a  ,					data_collator=__a  ,					train_dataset=__a  ,					eval_dataset=__a  ,					tokenizer=__a  ,					model_init=__a  ,					compute_metrics=__a  ,					callbacks=__a  ,					optimizers=__a  ,					preprocess_logits_for_metrics=__a  ,					)

     # Override self.model.generation_config if a GenerationConfig is specified in args.
     # Priority: args.generation_config > model.generation_config > default GenerationConfig.
     if self.args.generation_config is not None:
        a   :	Optional[Any]						=    self.load_generation_config(self.args.generation_config						)
        a   :	Tuple						=    gen_config
  @staticmethod
  def 							lowercase_     (						__UpperCAmelCase						)				->					GenerationConfig:

     # GenerationConfig provided, nothing to do
     if isinstance(__a  ,					__a						):
        return deepcopy(__a						)

     # str or Path
     a   :	Union[str, Any]						=    Path(__a						) if isinstance(__a  ,					__a						) else gen_config_arg
     a   :	int						=    None

     # Figuring if it is path pointing to a file, pointing to a directory or else a model id or URL
     # This step is required in order to determine config_file_name
     if pretrained_model_name.is_file():
        a   :	Tuple						=    pretrained_model_name.name
        a   :	Any						=    pretrained_model_name.parent
     # dir path
     elif pretrained_model_name.is_dir():
        pass
     # model id or URL
     else:
        a   :	List[str]						=    gen_config_arg

     a   :	Optional[int]						=    GenerationConfig.from_pretrained(__a  ,					__a						)
     return gen_config
  def 							lowercase_     (						self  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = "eval"  ,					**__UpperCAmelCase  ,					)				->					Dict[str, float]:
     a   :	str						=    gen_kwargs.copy()
     if gen_kwargs.get('max_length'						) is None and gen_kwargs.get('max_new_tokens'						) is None:
        a   :	Tuple						=    self.args.generation_max_length
     a   :	List[str]						=    (
         gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'						) is not None else self.args.generation_num_beams
     )
     a   :	Any						=    gen_kwargs

     return super().evaluate(__a  ,					ignore_keys=__a  ,					metric_key_prefix=__a						)
  def 							lowercase_     (						self  ,					__UpperCAmelCase  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = "test"  ,					**__UpperCAmelCase  ,					)				->					"PredictionOutput":
     a   :	Tuple						=    gen_kwargs.copy()
     if gen_kwargs.get('max_length'						) is None and gen_kwargs.get('max_new_tokens'						) is None:
        a   :	Optional[int]						=    self.args.generation_max_length
     a   :	str						=    (
         gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'						) is not None else self.args.generation_num_beams
     )
     a   :	List[str]						=    gen_kwargs

     return super().predict(__a  ,					ignore_keys=__a  ,					metric_key_prefix=__a						)
  def 							lowercase_     (						self  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase = None  ,					**__UpperCAmelCase  ,					)				->					Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:

     if not self.args.predict_with_generate or prediction_loss_only:
        return super().prediction_step(
            __a  ,					__a  ,					prediction_loss_only=__a  ,					ignore_keys=__a						)

     a   :	List[str]						=    'labels' in inputs
     a   :	Any						=    self._prepare_inputs(__a						)

     # XXX: adapt synced_gpus for fairscale as well
     # Priority (handled in generate):
     # gen_kwargs > model.generation_config > default GenerationConfig()

     if len(__a						) == 0 and hasattr(self  ,					'_gen_kwargs'						):
        a   :	List[str]						=    self._gen_kwargs.copy()

     if gen_kwargs.get('max_length'						) is None and gen_kwargs.get('max_new_tokens'						) is None:
        a   :	List[Any]						=    self.model.config.max_length
     a   :	int						=    (
         gen_kwargs['num_beams'] if gen_kwargs.get('num_beams'						) is not None else self.model.config.num_beams
     )
     a   :	Optional[Any]						=    True if is_deepspeed_zeroa_enabled() else False
     a   :	int						=    (
         gen_kwargs['synced_gpus'] if gen_kwargs.get('synced_gpus'						) is not None else default_synced_gpus
     )

     # If the `decoder_input_ids` was created from `labels`, evict the former, so that the model can freely generate
     # (otherwise, it would continue generating from the padded `decoder_input_ids`)
     if (
         "labels" in inputs
         and "decoder_input_ids" in inputs
         and inputs["labels"].shape == inputs["decoder_input_ids"].shape
     ):
        a   :	Optional[int]						=    {k: v for k, v in inputs.items() if k != 'decoder_input_ids'}
     a   :	List[str]						=    self.model.generate(**__a  ,					**__a						)

     # Temporary hack to ensure the generation config is not initialized for each iteration of the evaluation loop
     # TODO: remove this hack when the legacy code that initializes generation_config from a model config is
     # removed in https://github.com/huggingface/transformers/blob/98d88b23f54e5a23e741833f1e973fdf600cc2c5/src/transformers/generation/utils.py#L1183
     if self.model.generation_config._from_model_config:
        a   :	Any						=    False

     # Retrieves GenerationConfig from model.generation_config
     a   :	int						=    self.model.generation_config
     # in case the batch is shorter than max length, the output should be padded
     if generated_tokens.shape[-1] < gen_config.max_length:
        a   :	List[Any]						=    self._pad_tensors_to_max_len(__a  ,					gen_config.max_length						)
     elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
        a   :	Tuple						=    self._pad_tensors_to_max_len(__a  ,					gen_config.max_new_tokens + 1						)

     with torch.no_grad():
        if has_labels:
           with self.compute_loss_context_manager():
              a   :	Dict						=    model(**__a						)
           if self.label_smoother is not None:
              a   :	List[str]						=    self.label_smoother(__a  ,					inputs['labels']						).mean().detach()
           else:
              a   :	Optional[int]						=    (outputs['loss'] if isinstance(__a  ,					__a						) else outputs[0]).mean().detach()
        else:
           a   :	List[Any]						=    None

     if self.args.prediction_loss_only:
        return loss, None, None

     if has_labels:
        a   :	Optional[Any]						=    inputs['labels']
        if labels.shape[-1] < gen_config.max_length:
           a   :	str						=    self._pad_tensors_to_max_len(__a  ,					gen_config.max_length						)
        elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
           a   :	List[Any]						=    self._pad_tensors_to_max_len(__a  ,					gen_config.max_new_tokens + 1						)
     else:
        a   :	List[str]						=    None

     return loss, generated_tokens, labels






  def 							lowercase_     (						self  ,					__UpperCAmelCase  ,					__UpperCAmelCase						)				->					str:
     if self.tokenizer is not None and hasattr(self.tokenizer  ,					'pad_token_id'						):
        # If PAD token is not defined at least EOS token has to be defined
        a   :	List[str]						=    (
            self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else self.tokenizer.eos_token_id
        )
     else:
        if self.model.config.pad_token_id is not None:
           a   :	str						=    self.model.config.pad_token_id
        else:
           raise ValueError('Pad_token_id must be set in the configuration of the model, in order to pad tensors'						)

     a   :	Dict						=    pad_token_id * torch.ones(
         (tensor.shape[0], max_length)  ,					dtype=tensor.dtype  ,					device=tensor.device						)
     a   :	List[str]						=    tensor
     return padded_tensor












"""simple docstring"""





from ..utils import DummyObject, requires_backends





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Union[str, Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Any:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Union[str, Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[int]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Union[str, Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Any:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Any:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[str]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> str:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[int]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Union[str, Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Any:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[int]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[int]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Union[str, Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[int]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Tuple:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[str]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> str:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[Any]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> List[str]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Optional[int]:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> str:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> str:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> int:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)





class 							_lowerCamelCase   (							metaclass=_lowercase			):
						UpperCAmelCase_			=      ["tokenizers"]


						def __init__(self ,				*__a ,				**__a		)			-> Dict:
								requires_backends(self ,				["tokenizers"]		)






