

'''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


A_      =							logging.get_logger(__name__)





class 							_snake_case	(    _a  ):
   def __init__(	self     : int       ,SCREAMING_SNAKE_CASE__     : Union["PreTrainedModel", nn.Module] = None       ,SCREAMING_SNAKE_CASE__     : "TrainingArguments" = None       ,SCREAMING_SNAKE_CASE__     : Optional["DataCollator"] = None       ,SCREAMING_SNAKE_CASE__     : Optional[Dataset] = None       ,SCREAMING_SNAKE_CASE__     : Optional[Union[Dataset, Dict[str, Dataset]]] = None       ,SCREAMING_SNAKE_CASE__     : Optional["PreTrainedTokenizerBase"] = None       ,SCREAMING_SNAKE_CASE__     : Optional[Callable[[], "PreTrainedModel"]] = None       ,SCREAMING_SNAKE_CASE__     : Optional[Callable[["EvalPrediction"], Dict]] = None       ,SCREAMING_SNAKE_CASE__     : Optional[List["TrainerCallback"]] = None       ,SCREAMING_SNAKE_CASE__     : Tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None)       ,SCREAMING_SNAKE_CASE__     : Optional[Callable[[torch.Tensor, torch.Tensor], torch.Tensor]] = None       ,):
     super().__init__(
         model=SCREAMING_SNAKE_CASE__       ,args=SCREAMING_SNAKE_CASE__       ,data_collator=SCREAMING_SNAKE_CASE__       ,train_dataset=SCREAMING_SNAKE_CASE__       ,eval_dataset=SCREAMING_SNAKE_CASE__       ,tokenizer=SCREAMING_SNAKE_CASE__       ,model_init=SCREAMING_SNAKE_CASE__       ,compute_metrics=SCREAMING_SNAKE_CASE__       ,callbacks=SCREAMING_SNAKE_CASE__       ,optimizers=SCREAMING_SNAKE_CASE__       ,preprocess_logits_for_metrics=SCREAMING_SNAKE_CASE__       ,)

     # 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:
       SCREAMING_SNAKE_CASE:List[Any]   =   self.load_generation_config(self.args.generation_config							)
       SCREAMING_SNAKE_CASE:str   =   gen_config
   @staticmethod
   def       __UpperCamelCase  (	SCREAMING_SNAKE_CASE__     : Union[str, GenerationConfig]							):

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

     # str or Path
     SCREAMING_SNAKE_CASE:Union[str, Any]   =   Path(SCREAMING_SNAKE_CASE__							) if isinstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__							) else gen_config_arg
     SCREAMING_SNAKE_CASE:Dict   =   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():
       SCREAMING_SNAKE_CASE:Optional[int]   =   pretrained_model_name.name
       SCREAMING_SNAKE_CASE:str   =   pretrained_model_name.parent
     # dir path
     elif pretrained_model_name.is_dir():
       pass
     # model id or URL
     else:
       SCREAMING_SNAKE_CASE:Optional[Any]   =   gen_config_arg

     SCREAMING_SNAKE_CASE:List[Any]   =   GenerationConfig.from_pretrained(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__							)
     return gen_config
   def       __UpperCamelCase  (	self     : Union[str, Any]       ,SCREAMING_SNAKE_CASE__     : Optional[Dataset] = None       ,SCREAMING_SNAKE_CASE__     : Optional[List[str]] = None       ,SCREAMING_SNAKE_CASE__     : str = "eval"       ,**SCREAMING_SNAKE_CASE__     : Optional[int]       ,):
     SCREAMING_SNAKE_CASE:Union[str, Any]   =   gen_kwargs.copy()
     if gen_kwargs.get("max_length"							) is None and gen_kwargs.get("max_new_tokens"							) is None:
       SCREAMING_SNAKE_CASE:int   =   self.args.generation_max_length
     SCREAMING_SNAKE_CASE:List[str]   =   (
         gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"							) is not None else self.args.generation_num_beams
     )
     SCREAMING_SNAKE_CASE:str   =   gen_kwargs

     return super().evaluate(SCREAMING_SNAKE_CASE__       ,ignore_keys=SCREAMING_SNAKE_CASE__       ,metric_key_prefix=SCREAMING_SNAKE_CASE__							)
   def       __UpperCamelCase  (	self     : Optional[int]       ,SCREAMING_SNAKE_CASE__     : Dataset       ,SCREAMING_SNAKE_CASE__     : Optional[List[str]] = None       ,SCREAMING_SNAKE_CASE__     : str = "test"       ,**SCREAMING_SNAKE_CASE__     : int       ,):
     SCREAMING_SNAKE_CASE:int   =   gen_kwargs.copy()
     if gen_kwargs.get("max_length"							) is None and gen_kwargs.get("max_new_tokens"							) is None:
       SCREAMING_SNAKE_CASE:str   =   self.args.generation_max_length
     SCREAMING_SNAKE_CASE:Optional[int]   =   (
         gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"							) is not None else self.args.generation_num_beams
     )
     SCREAMING_SNAKE_CASE:int   =   gen_kwargs

     return super().predict(SCREAMING_SNAKE_CASE__       ,ignore_keys=SCREAMING_SNAKE_CASE__       ,metric_key_prefix=SCREAMING_SNAKE_CASE__							)
   def       __UpperCamelCase  (	self     : int       ,SCREAMING_SNAKE_CASE__     : nn.Module       ,SCREAMING_SNAKE_CASE__     : Dict[str, Union[torch.Tensor, Any]]       ,SCREAMING_SNAKE_CASE__     : bool       ,SCREAMING_SNAKE_CASE__     : Optional[List[str]] = None       ,**SCREAMING_SNAKE_CASE__     : str       ,):

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

     SCREAMING_SNAKE_CASE:int   =   "labels" in inputs
     SCREAMING_SNAKE_CASE:Optional[int]   =   self._prepare_inputs(SCREAMING_SNAKE_CASE__							)

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

     if len(SCREAMING_SNAKE_CASE__							) == 0 and hasattr(self       ,"_gen_kwargs"							):
       SCREAMING_SNAKE_CASE:Union[str, Any]   =   self._gen_kwargs.copy()

     if gen_kwargs.get("max_length"							) is None and gen_kwargs.get("max_new_tokens"							) is None:
       SCREAMING_SNAKE_CASE:List[str]   =   self.model.config.max_length
     SCREAMING_SNAKE_CASE:List[Any]   =   (
         gen_kwargs["num_beams"] if gen_kwargs.get("num_beams"							) is not None else self.model.config.num_beams
     )
     SCREAMING_SNAKE_CASE:List[Any]   =   True if is_deepspeed_zeroa_enabled() else False
     SCREAMING_SNAKE_CASE:Union[str, Any]   =   (
         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
     ):
       SCREAMING_SNAKE_CASE:Optional[int]   =   {k: v for k, v in inputs.items() if k != "decoder_input_ids"}
     SCREAMING_SNAKE_CASE:Optional[int]   =   self.model.generate(**SCREAMING_SNAKE_CASE__       ,**SCREAMING_SNAKE_CASE__							)

     # 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:
       SCREAMING_SNAKE_CASE:Dict   =   False

     # Retrieves GenerationConfig from model.generation_config
     SCREAMING_SNAKE_CASE:Dict   =   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:
       SCREAMING_SNAKE_CASE:Optional[int]   =   self._pad_tensors_to_max_len(SCREAMING_SNAKE_CASE__       ,gen_config.max_length							)
     elif gen_config.max_new_tokens is not None and generated_tokens.shape[-1] < gen_config.max_new_tokens + 1:
       SCREAMING_SNAKE_CASE:List[str]   =   self._pad_tensors_to_max_len(SCREAMING_SNAKE_CASE__       ,gen_config.max_new_tokens + 1							)

     with torch.no_grad():
       if has_labels:
         with self.compute_loss_context_manager():
           SCREAMING_SNAKE_CASE:List[Any]   =   model(**SCREAMING_SNAKE_CASE__							)
         if self.label_smoother is not None:
           SCREAMING_SNAKE_CASE:Optional[int]   =   self.label_smoother(SCREAMING_SNAKE_CASE__       ,inputs["labels"]							).mean().detach()
         else:
           SCREAMING_SNAKE_CASE:Tuple   =   (outputs["loss"] if isinstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__							) else outputs[0]).mean().detach()
       else:
         SCREAMING_SNAKE_CASE:Union[str, Any]   =   None

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

     if has_labels:
       SCREAMING_SNAKE_CASE:List[Any]   =   inputs["labels"]
       if labels.shape[-1] < gen_config.max_length:
         SCREAMING_SNAKE_CASE:Tuple   =   self._pad_tensors_to_max_len(SCREAMING_SNAKE_CASE__       ,gen_config.max_length							)
       elif gen_config.max_new_tokens is not None and labels.shape[-1] < gen_config.max_new_tokens + 1:
         SCREAMING_SNAKE_CASE:Union[str, Any]   =   self._pad_tensors_to_max_len(SCREAMING_SNAKE_CASE__       ,gen_config.max_new_tokens + 1							)
     else:
       SCREAMING_SNAKE_CASE:Tuple   =   None

     return loss, generated_tokens, labels







   def       __UpperCamelCase  (	self     : Tuple       ,SCREAMING_SNAKE_CASE__     : List[Any]       ,SCREAMING_SNAKE_CASE__     : Optional[Any]							):
     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
       SCREAMING_SNAKE_CASE: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:
         SCREAMING_SNAKE_CASE:Dict   =   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"							)

     SCREAMING_SNAKE_CASE:int   =   pad_token_id * torch.ones(
         (tensor.shape[0], max_length)       ,dtype=tensor.dtype       ,device=tensor.device							)
     SCREAMING_SNAKE_CASE:Optional[Any]   =   tensor
     return padded_tensor









'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


A_      =							{"configuration_yoso": ["YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP", "YosoConfig"]}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    A_      =							[
        "YOSO_PRETRAINED_MODEL_ARCHIVE_LIST",
        "YosoForMaskedLM",
        "YosoForMultipleChoice",
        "YosoForQuestionAnswering",
        "YosoForSequenceClassification",
        "YosoForTokenClassification",
        "YosoLayer",
        "YosoModel",
        "YosoPreTrainedModel",
    ]


if TYPE_CHECKING:
    from .configuration_yoso import YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP, YosoConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_yoso import (
            YOSO_PRETRAINED_MODEL_ARCHIVE_LIST,
            YosoForMaskedLM,
            YosoForMultipleChoice,
            YosoForQuestionAnswering,
            YosoForSequenceClassification,
            YosoForTokenClassification,
            YosoLayer,
            YosoModel,
            YosoPreTrainedModel,
        )


else:
    import sys

    A_      =							_LazyModule(__name__, globals()["__file__"], _import_structure)






