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





			'''simple docstring'''



			def __init__(							self  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = (None, None)  ,  __UpperCAmelCase = None  ,  )				->  Optional[Any]:
				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:
					_lowerCAmelCase			=self.load_generation_config(self.args.generation_config						)
					_lowerCAmelCase			=gen_config



			@staticmethod
			def       _lowerCAmelCase	(							__UpperCAmelCase						)				->  GenerationConfig:



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

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

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



			def       _lowerCAmelCase	(							self  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = "eval"  ,  **__UpperCAmelCase  ,  )				->  Dict[str, float]:
				_lowerCAmelCase			=gen_kwargs.copy()
				if gen_kwargs.get("""max_length"""						) is None and gen_kwargs.get("""max_new_tokens"""						) is None:
					_lowerCAmelCase			=self.args.generation_max_length
				_lowerCAmelCase			=(
				    gen_kwargs["""num_beams"""] if gen_kwargs.get("""num_beams"""						) is not None else self.args.generation_num_beams
				)
				_lowerCAmelCase			=gen_kwargs

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



			def       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase = None  ,  __UpperCAmelCase = "test"  ,  **__UpperCAmelCase  ,  )				->  "PredictionOutput":
				_lowerCAmelCase			=gen_kwargs.copy()
				if gen_kwargs.get("""max_length"""						) is None and gen_kwargs.get("""max_new_tokens"""						) is None:
					_lowerCAmelCase			=self.args.generation_max_length
				_lowerCAmelCase			=(
				    gen_kwargs["""num_beams"""] if gen_kwargs.get("""num_beams"""						) is not None else self.args.generation_num_beams
				)
				_lowerCAmelCase			=gen_kwargs

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



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



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

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

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

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

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

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

				return loss, generated_tokens, labels



			def       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  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
					_lowerCAmelCase			=(
					    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:
						_lowerCAmelCase			=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"""						)

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





"""simple docstring"""


# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__A 		= {
    'configuration_convnextv2': [
        'CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'ConvNextV2Config',
    ]
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			__A 		= [
			    'CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST',
			    'ConvNextV2ForImageClassification',
			    'ConvNextV2Model',
			    'ConvNextV2PreTrainedModel',
			    'ConvNextV2Backbone',
			]


if TYPE_CHECKING:
			from .configuration_convnextva import (
			    CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    ConvNextVaConfig,
			)

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_convnextva import (
						    CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    ConvNextVaBackbone,
						    ConvNextVaForImageClassification,
						    ConvNextVaModel,
						    ConvNextVaPreTrainedModel,
						)

else:
			import sys

			__A 		= _LazyModule(__name__, globals()['__file__'], _import_structure)



