




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


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





class       lowerCAmelCase				(	__lowerCAmelCase):


       def __init__(				self      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = (None, None)      ,					__SCREAMING_SNAKE_CASE = None      ,					) ->					Tuple:



            '''simple docstring'''




            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:
                 __snake_case         =					self.load_generation_config(self.args.generation_config					)
                 __snake_case         =					gen_config


       @staticmethod
       def  lowerCAmelCase (				__SCREAMING_SNAKE_CASE					) ->					GenerationConfig:



            '''simple docstring'''




            if isinstance(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					):
                 return deepcopy(__SCREAMING_SNAKE_CASE					)

            # str or Path
            __snake_case         =					Path(__SCREAMING_SNAKE_CASE					) if isinstance(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					) else gen_config_arg
            __snake_case         =					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():
                 __snake_case         =					pretrained_model_name.name
                 __snake_case         =					pretrained_model_name.parent
            # dir path
            elif pretrained_model_name.is_dir():
                 pass
            # model id or URL
            else:
                 __snake_case         =					gen_config_arg

            __snake_case         =					GenerationConfig.from_pretrained(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					)
            return gen_config


       def  lowerCAmelCase (				self      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = "eval"      ,					**__SCREAMING_SNAKE_CASE      ,					) ->					Dict[str, float]:



            '''simple docstring'''




            __snake_case         =					gen_kwargs.copy()
            if gen_kwargs.get('''max_length'''					) is None and gen_kwargs.get('''max_new_tokens'''					) is None:
                 __snake_case         =					self.args.generation_max_length
            __snake_case         =					(
                gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''					) is not None else self.args.generation_num_beams
            )
            __snake_case         =					gen_kwargs

            return super().evaluate(__SCREAMING_SNAKE_CASE      ,					ignore_keys=__SCREAMING_SNAKE_CASE      ,					metric_key_prefix=__SCREAMING_SNAKE_CASE					)


       def  lowerCAmelCase (				self      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE = None      ,					__SCREAMING_SNAKE_CASE = "test"      ,					**__SCREAMING_SNAKE_CASE      ,					) ->					"PredictionOutput":



            '''simple docstring'''




            __snake_case         =					gen_kwargs.copy()
            if gen_kwargs.get('''max_length'''					) is None and gen_kwargs.get('''max_new_tokens'''					) is None:
                 __snake_case         =					self.args.generation_max_length
            __snake_case         =					(
                gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''					) is not None else self.args.generation_num_beams
            )
            __snake_case         =					gen_kwargs

            return super().predict(__SCREAMING_SNAKE_CASE      ,					ignore_keys=__SCREAMING_SNAKE_CASE      ,					metric_key_prefix=__SCREAMING_SNAKE_CASE					)


       def  lowerCAmelCase (				self      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE = None      ,					**__SCREAMING_SNAKE_CASE      ,					) ->					Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:



            '''simple docstring'''




            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					)

            __snake_case         =					'''labels''' in inputs
            __snake_case         =					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'''					):
                 __snake_case         =					self._gen_kwargs.copy()

            if gen_kwargs.get('''max_length'''					) is None and gen_kwargs.get('''max_new_tokens'''					) is None:
                 __snake_case         =					self.model.config.max_length
            __snake_case         =					(
                gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''					) is not None else self.model.config.num_beams
            )
            __snake_case         =					True if is_deepspeed_zeroa_enabled() else False
            __snake_case         =					(
                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
            ):
                 __snake_case         =					{k: v for k, v in inputs.items() if k != '''decoder_input_ids'''}
            __snake_case         =					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:
                 __snake_case         =					False

            # Retrieves GenerationConfig from model.generation_config
            __snake_case         =					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:
                 __snake_case         =					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:
                 __snake_case         =					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():
                           __snake_case         =					model(**__SCREAMING_SNAKE_CASE					)
                      if self.label_smoother is not None:
                           __snake_case         =					self.label_smoother(__SCREAMING_SNAKE_CASE      ,					inputs['''labels''']					).mean().detach()
                      else:
                           __snake_case         =					(outputs['''loss'''] if isinstance(__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					) else outputs[0]).mean().detach()
                 else:
                      __snake_case         =					None

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

            if has_labels:
                 __snake_case         =					inputs['''labels''']
                 if labels.shape[-1] < gen_config.max_length:
                      __snake_case         =					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:
                      __snake_case         =					self._pad_tensors_to_max_len(__SCREAMING_SNAKE_CASE      ,					gen_config.max_new_tokens + 1					)
            else:
                 __snake_case         =					None

            return loss, generated_tokens, labels




       def  lowerCAmelCase (				self      ,					__SCREAMING_SNAKE_CASE      ,					__SCREAMING_SNAKE_CASE					) ->					Union[str, Any]:



            '''simple docstring'''




            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
                 __snake_case         =					(
                     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:
                      __snake_case         =					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'''					)

            __snake_case         =					pad_token_id * torch.ones(
                (tensor.shape[0], max_length)      ,					dtype=tensor.dtype      ,					device=tensor.device					)
            __snake_case         =					tensor
            return padded_tensor












'''simple docstring'''



from typing import TYPE_CHECKING

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


UpperCAmelCase_    :					Any					      =						{
    '''configuration_retribert''': ['''RETRIBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RetriBertConfig'''],
    '''tokenization_retribert''': ['''RetriBertTokenizer'''],
}

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_    :					str					      =						['''RetriBertTokenizerFast''']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCAmelCase_    :					Optional[int]					      =						[
         '''RETRIBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
         '''RetriBertModel''',
         '''RetriBertPreTrainedModel''',
     ]


if TYPE_CHECKING:
     from .configuration_retribert import RETRIBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RetriBertConfig
     from .tokenization_retribert import RetriBertTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_retribert_fast import RetriBertTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_retribert import (
              RETRIBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              RetriBertModel,
              RetriBertPreTrainedModel,
          )

else:
     import sys

     UpperCAmelCase_    :					Any					      =						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






