


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 							lowerCamelCase       (			__UpperCAmelCase ):


							"""simple docstring"""






							def __init__(						self :     Tuple		, lowerCamelCase_ :     List[str] = None		, lowerCamelCase_ :     List[Any] = None		, lowerCamelCase_ :     Optional[int] = None		, lowerCamelCase_ :     Optional[Any] = None		, lowerCamelCase_ :     int = None		, lowerCamelCase_ :     Union[str, Any] = None		, lowerCamelCase_ :     Optional[int] = None		, lowerCamelCase_ :     Optional[Any] = None		, lowerCamelCase_ :     Union[str, Any] = None		, lowerCamelCase_ :     List[str] = (None, None)		, lowerCamelCase_ :     Any = None		, ):
													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:
																			UpperCAmelCase__		=    self.load_generation_config(self.args.generation_config				)
																			UpperCAmelCase__		=    gen_config






							@staticmethod
							def 					lowerCAmelCase     (						lowerCamelCase_ :     List[Any]				):



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

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

													UpperCAmelCase__		=    GenerationConfig.from_pretrained(lowerCamelCase__		, lowerCamelCase__				)
													return gen_config






							def 					lowerCAmelCase     (						self :     Optional[Any]		, lowerCamelCase_ :     Optional[int] = None		, lowerCamelCase_ :     List[str] = None		, lowerCamelCase_ :     Any = "eval"		, **lowerCamelCase_ :     Any		, ):
													UpperCAmelCase__		=    gen_kwargs.copy()
													if gen_kwargs.get('''max_length'''				) is None and gen_kwargs.get('''max_new_tokens'''				) is None:
																			UpperCAmelCase__		=    self.args.generation_max_length
													UpperCAmelCase__		=    (
													    gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''				) is not None else self.args.generation_num_beams
													)
													UpperCAmelCase__		=    gen_kwargs

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






							def 					lowerCAmelCase     (						self :     List[str]		, lowerCamelCase_ :     Tuple		, lowerCamelCase_ :     Any = None		, lowerCamelCase_ :     str = "test"		, **lowerCamelCase_ :     Any		, ):
													UpperCAmelCase__		=    gen_kwargs.copy()
													if gen_kwargs.get('''max_length'''				) is None and gen_kwargs.get('''max_new_tokens'''				) is None:
																			UpperCAmelCase__		=    self.args.generation_max_length
													UpperCAmelCase__		=    (
													    gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''				) is not None else self.args.generation_num_beams
													)
													UpperCAmelCase__		=    gen_kwargs

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






							def 					lowerCAmelCase     (						self :     Tuple		, lowerCamelCase_ :     Optional[int]		, lowerCamelCase_ :     List[str]		, lowerCamelCase_ :     int		, lowerCamelCase_ :     Union[str, Any] = None		, **lowerCamelCase_ :     Any		, ):



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

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

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

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

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

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

													return loss, generated_tokens, labels






							def 					lowerCAmelCase     (						self :     Tuple		, lowerCamelCase_ :     Any		, lowerCamelCase_ :     Union[str, 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
																			UpperCAmelCase__		=    (
																			    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:
																									UpperCAmelCase__		=    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'''				)

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



"""simple docstring"""







from collections import defaultdict






def 					a__ (       _UpperCamelCase = 5 ):





						"""simple docstring"""

						UpperCAmelCase__		=    defaultdict(_UpperCamelCase )
						UpperCAmelCase__		=    0

						while True:
												UpperCAmelCase__		=    get_digits(_UpperCamelCase )
												freqs[digits].append(_UpperCamelCase )

												if len(freqs[digits] ) == max_base:
																		UpperCAmelCase__		=    freqs[digits][0] ** 3
																		return base

												num += 1






def 					a__ (       _UpperCamelCase ):





						"""simple docstring"""

						return "".join(sorted(str(num**3 ) ) )


if __name__ == "__main__":
						print(f'''{solution() = }''')