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


_lowercase							 =							logging.get_logger(__name__)

class 				__a    (   UpperCamelCase_					):



							'''simple docstring'''







							def __init__(    self     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = (None, None)     ,						_lowerCamelCase = None     ,						) ->       Any:




													'''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:
																			__lowercase						      =					self.load_generation_config(self.args.generation_config					)
																			__lowercase						      =					gen_config
							@staticmethod
							def      SCREAMING_SNAKE_CASE	(    _lowerCamelCase					) ->       GenerationConfig:




													'''simple docstring'''

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

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

													__lowercase						      =					GenerationConfig.from_pretrained(__SCREAMING_SNAKE_CASE     ,						__SCREAMING_SNAKE_CASE					)
													return gen_config
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase = None     ,						_lowerCamelCase = None     ,						_lowerCamelCase = "eval"     ,						**_lowerCamelCase     ,						) ->       Dict[str, float]:




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

													return super().evaluate(__SCREAMING_SNAKE_CASE     ,						ignore_keys=__SCREAMING_SNAKE_CASE     ,						metric_key_prefix=__SCREAMING_SNAKE_CASE					)
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase = None     ,						_lowerCamelCase = "test"     ,						**_lowerCamelCase     ,						) ->       "PredictionOutput":




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

													return super().predict(__SCREAMING_SNAKE_CASE     ,						ignore_keys=__SCREAMING_SNAKE_CASE     ,						metric_key_prefix=__SCREAMING_SNAKE_CASE					)
							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase     ,						_lowerCamelCase = None     ,						**_lowerCamelCase     ,						) ->       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					)

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

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

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

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

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

													return loss, generated_tokens, labels





							def      SCREAMING_SNAKE_CASE	(    self     ,						_lowerCamelCase     ,						_lowerCamelCase					) ->       Optional[int]:




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

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







"""simple docstring"""






from scipy.constants import g



def     lowerCAmelCase__ (		__magic_name__ ,      __magic_name__			)	->float:
			if mass < 0:
						# handling of negative values of mass
						raise ValueError("The mass of a body cannot be negative"			)
			if height < 0:
						# handling of negative values of height
						raise ValueError("The height above the ground cannot be negative"			)
			return mass * g * height


if __name__ == "__main__":
					from doctest import testmod

					testmod(name='''potential_energy''')





