





"""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__					:     Any							=				logging.get_logger(__name__)



class      lowercase_				(     _a							):

       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   ,					):






        '''simple docstring'''

        super().__init__(
            model=lowerCamelCase__   ,					args=lowerCamelCase__   ,					data_collator=lowerCamelCase__   ,					train_dataset=lowerCamelCase__   ,					eval_dataset=lowerCamelCase__   ,					tokenizer=lowerCamelCase__   ,					model_init=lowerCamelCase__   ,					compute_metrics=lowerCamelCase__   ,					callbacks=lowerCamelCase__   ,					optimizers=lowerCamelCase__   ,					preprocess_logits_for_metrics=lowerCamelCase__   ,					)

        # 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 		_SCREAMING_SNAKE_CASE(			__SCREAMING_SNAKE_CASE     ):






        '''simple docstring'''

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

        # str or Path
        snake_case__    							=				Path(lowerCamelCase__     ) if isinstance(lowerCamelCase__   ,					lowerCamelCase__     ) 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(lowerCamelCase__   ,					lowerCamelCase__     )
        return gen_config

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE = None   ,					__SCREAMING_SNAKE_CASE = None   ,					__SCREAMING_SNAKE_CASE = "eval"   ,					**__SCREAMING_SNAKE_CASE   ,					):






        '''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(lowerCamelCase__   ,					ignore_keys=lowerCamelCase__   ,					metric_key_prefix=lowerCamelCase__     )

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE = None   ,					__SCREAMING_SNAKE_CASE = "test"   ,					**__SCREAMING_SNAKE_CASE   ,					):






        '''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(lowerCamelCase__   ,					ignore_keys=lowerCamelCase__   ,					metric_key_prefix=lowerCamelCase__     )

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE = None   ,					**__SCREAMING_SNAKE_CASE   ,					):






        '''simple docstring'''

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

        snake_case__    							=				"labels" in inputs
        snake_case__    							=				self._prepare_inputs(lowerCamelCase__     )

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

        if len(lowerCamelCase__     ) == 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(**lowerCamelCase__   ,					**lowerCamelCase__     )

        # 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(lowerCamelCase__   ,					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(lowerCamelCase__   ,					gen_config.max_new_tokens + 1     )

        with torch.no_grad():
         if has_labels:
          with self.compute_loss_context_manager():
           snake_case__    							=				model(**lowerCamelCase__     )
          if self.label_smoother is not None:
           snake_case__    							=				self.label_smoother(lowerCamelCase__   ,					inputs["labels"]     ).mean().detach()
          else:
           snake_case__    							=				(outputs["loss"] if isinstance(lowerCamelCase__   ,					lowerCamelCase__     ) 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(lowerCamelCase__   ,					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(lowerCamelCase__   ,					gen_config.max_new_tokens + 1     )
        else:
         snake_case__    							=				None

        return loss, generated_tokens, labels

       def 		_SCREAMING_SNAKE_CASE(			self   ,					__SCREAMING_SNAKE_CASE   ,					__SCREAMING_SNAKE_CASE     ):






        '''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 math import sqrt





def 							a__			(  _UpperCAmelCase	)    ->  list[int]:

 '''simple docstring'''






 snake_case__    							=				[1]
 for i in range(2	,     int(sqrt(_UpperCAmelCase	)	) + 1	,     1	):
  if number % i == 0:
   values.append(_UpperCAmelCase	)
   if int(number // i	) != i:
    values.append(int(number // i	)	)
 return sorted(_UpperCAmelCase	)





def 							a__			(  _UpperCAmelCase	)    ->  bool:

 '''simple docstring'''






 return sum(factors(_UpperCAmelCase	)	) > n





def 							a__			(  _UpperCAmelCase	)    ->  bool:

 '''simple docstring'''






 snake_case__    							=				factors(_UpperCAmelCase	)
 snake_case__    							=				len(_UpperCAmelCase	)
 snake_case__    							=				[[0 for i in range(number + 1	)] for j in range(r + 1	)]
 for i in range(r + 1	):
  snake_case__    							=				True

 for i in range(1	,     number + 1	):
  snake_case__    							=				False

 for i in range(1	,     r + 1	):
  for j in range(1	,     number + 1	):
   if j < values[i - 1]:
    snake_case__    							=				subset[i - 1][j]
   else:
    snake_case__    							=				subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

 return subset[r][number] != 0





def 							a__			(  _UpperCAmelCase	)    ->  bool:

 '''simple docstring'''






 return abundant(_UpperCAmelCase	) and not semi_perfect(_UpperCAmelCase	)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   for number in (6_9, 7_0, 7_1):
      print(f'''{number} is {'' if weird(number) else 'not '}weird.''')

