





from typing import Any, Dict, List, Optional, Tuple, Union

import torch
from torch import nn
from torch.utils.data import DistributedSampler, RandomSampler

from transformers import PreTrainedModel, Trainer, logging
from transformers.integrations import is_fairscale_available
from transformers.models.fsmt.configuration_fsmt import FSMTConfig
from transformers.optimization import (
    Adafactor,
    AdamW,
    get_constant_schedule,
    get_constant_schedule_with_warmup,
    get_cosine_schedule_with_warmup,
    get_cosine_with_hard_restarts_schedule_with_warmup,
    get_linear_schedule_with_warmup,
    get_polynomial_decay_schedule_with_warmup,
)
from transformers.trainer_pt_utils import get_tpu_sampler
from transformers.training_args import ParallelMode
from transformers.utils import is_torch_tpu_available


if is_fairscale_available():
					from fairscale.optim import OSS


A    :					Tuple =      logging.get_logger(__name__)

A    :					Dict =      {
    '''linear''': get_linear_schedule_with_warmup,
    '''cosine''': get_cosine_schedule_with_warmup,
    '''cosine_w_restarts''': get_cosine_with_hard_restarts_schedule_with_warmup,
    '''polynomial''': get_polynomial_decay_schedule_with_warmup,
    '''constant''': get_constant_schedule,
    '''constant_w_warmup''': get_constant_schedule_with_warmup,
}


class   A			(SCREAMING_SNAKE_CASE    ):
			'''simple docstring'''




			def __init__(			self   :    str							,	__lowerCAmelCase   :    str=None							,	__lowerCAmelCase   :    str=None							,	*__lowerCAmelCase   :    List[str]							,	**__lowerCAmelCase   :    Optional[int]   )	->	Tuple:







					"""simple docstring"""






					super().__init__(*__lowerCAmelCase							,	**__lowerCAmelCase   )

					if config is None:
							assert isinstance(self.model							,	__lowerCAmelCase   ), (
							    "If no `config` is passed the model to be trained has to be of type `PreTrainedModel`, but is"
							    f' {self.model.__class__}'
							)
							A__        =   self.model.config
					else:
							A__        =   config

					A__        =   data_args
					A__        =   self.config.tgt_vocab_size if isinstance(self.config							,	__lowerCAmelCase   ) else self.config.vocab_size

					if self.args.label_smoothing != 0 or (self.data_args is not None and self.data_args.ignore_pad_token_for_loss):
							assert self.config.pad_token_id is not None, (
							    "Make sure that `config.pad_token_id` is correcly defined when ignoring `pad_token` for loss"
							    " calculation or doing label smoothing."
							)

					if self.config.pad_token_id is None and self.config.eos_token_id is not None:
							logger.warning(
							    f'The `config.pad_token_id` is `None`. Using `config.eos_token_id` = {self.config.eos_token_id} for'
							    """ padding.."""   )

					if self.args.label_smoothing == 0:
							A__        =   torch.nn.CrossEntropyLoss(ignore_index=self.config.pad_token_id   )
					else:
							# dynamically import label_smoothed_nll_loss
							from utils import label_smoothed_nll_loss

							A__        =   label_smoothed_nll_loss






			def    a_       (			self   :    Optional[int]							,	__lowerCAmelCase   :    int   )	->	List[Any]:







					"""simple docstring"""






					if self.optimizer is None:
							A__        =   ["""bias""", """LayerNorm.weight"""]
							A__        =   [
							    {
							        """params""": [p for n, p in self.model.named_parameters() if not any(nd in n for nd in no_decay   )],
							        """weight_decay""": self.args.weight_decay,
							    },
							    {
							        """params""": [p for n, p in self.model.named_parameters() if any(nd in n for nd in no_decay   )],
							        """weight_decay""": 0.0,
							    },
							]
							A__        =   Adafactor if self.args.adafactor else AdamW
							if self.args.adafactor:
									A__        =   Adafactor
									A__        =   {"""scale_parameter""": False, """relative_step""": False}
							else:
									A__        =   AdamW
									A__        =   {
									    """betas""": (self.args.adam_betaa, self.args.adam_betaa),
									    """eps""": self.args.adam_epsilon,
									}
							A__        =   self.args.learning_rate
							if self.sharded_ddp:
									A__        =   OSS(
									    params=__lowerCAmelCase							,	optim=__lowerCAmelCase							,	**__lowerCAmelCase							,	)
							else:
									A__        =   optimizer_cls(__lowerCAmelCase							,	**__lowerCAmelCase   )

					if self.lr_scheduler is None:
							A__        =   self._get_lr_scheduler(__lowerCAmelCase   )
					else:  # ignoring --lr_scheduler
							logger.warning("""scheduler is passed to `Seq2SeqTrainer`, `--lr_scheduler` arg is ignored."""   )






			def    a_       (			self   :    Dict							,	__lowerCAmelCase   :    str   )	->	Tuple:







					"""simple docstring"""






					A__        =   arg_to_scheduler[self.args.lr_scheduler]
					if self.args.lr_scheduler == "constant":
							A__        =   schedule_func(self.optimizer   )
					elif self.args.lr_scheduler == "constant_w_warmup":
							A__        =   schedule_func(self.optimizer							,	num_warmup_steps=self.args.warmup_steps   )
					else:
							A__        =   schedule_func(
							    self.optimizer							,	num_warmup_steps=self.args.warmup_steps							,	num_training_steps=__lowerCAmelCase   )
					return scheduler






			def    a_       (			self   :    int   )	->	Optional[torch.utils.data.Sampler]:







					"""simple docstring"""






					if isinstance(self.train_dataset							,	torch.utils.data.IterableDataset   ):
							return None
					elif is_torch_tpu_available():
							return get_tpu_sampler(self.train_dataset   )
					else:
							if self.args.sortish_sampler:
									self.train_dataset.make_sortish_sampler(
									    self.args.per_device_train_batch_size							,	distributed=(self.args.parallel_mode == ParallelMode.DISTRIBUTED)							,	)

							return (
							    RandomSampler(self.train_dataset   )
							    if self.args.local_rank == -1
							    else DistributedSampler(self.train_dataset   )
							)






			def    a_       (			self   :    Union[str, Any]							,	__lowerCAmelCase   :    List[Any]							,	__lowerCAmelCase   :    List[str]							,	__lowerCAmelCase   :    Optional[Any]   )	->	Optional[Any]:







					"""simple docstring"""






					if self.args.label_smoothing == 0:
							if self.data_args is not None and self.data_args.ignore_pad_token_for_loss:
									# force training to ignore pad token
									A__        =   model(**__lowerCAmelCase							,	use_cache=__lowerCAmelCase   )[0]
									A__        =   self.loss_fn(logits.view(-1							,	logits.shape[-1]   )							,	labels.view(-1   )   )
							else:
									# compute usual loss via models
									A__      ,			A__        =   model(**__lowerCAmelCase							,	labels=__lowerCAmelCase							,	use_cache=__lowerCAmelCase   )[:2]
					else:
							# compute label smoothed loss
							A__        =   model(**__lowerCAmelCase							,	use_cache=__lowerCAmelCase   )[0]
							A__        =   torch.nn.functional.log_softmax(__lowerCAmelCase							,	dim=-1   )
							A__      ,			A__        =   self.loss_fn(__lowerCAmelCase							,	__lowerCAmelCase							,	self.args.label_smoothing							,	ignore_index=self.config.pad_token_id   )
					return loss, logits






			def    a_       (			self   :    Tuple							,	__lowerCAmelCase   :    Union[str, Any]							,	__lowerCAmelCase   :    str   )	->	List[Any]:







					"""simple docstring"""






					A__        =   inputs.pop("""labels"""   )
					A__      ,			A__        =   self._compute_loss(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase   )
					return loss






			def    a_       (			self   :    int							,	__lowerCAmelCase   :    nn.Module							,	__lowerCAmelCase   :    Dict[str, Union[torch.Tensor, Any]]							,	__lowerCAmelCase   :    bool							,	__lowerCAmelCase   :    Optional[List[str]] = None							,	)	->	Tuple[Optional[float], Optional[torch.Tensor], Optional[torch.Tensor]]:







					"""simple docstring"""






					A__        =   self._prepare_inputs(__lowerCAmelCase   )

					A__        =   {
					    """max_length""": self.data_args.val_max_target_length
					    if self.data_args is not None
					    else self.config.max_length,
					    """num_beams""": self.data_args.eval_beams if self.data_args is not None else self.config.num_beams,
					}

					if self.args.predict_with_generate and not self.args.prediction_loss_only:
							A__        =   self.model.generate(
							    inputs["""input_ids"""]							,	attention_mask=inputs["""attention_mask"""]							,	**__lowerCAmelCase							,	)
							# in case the batch is shorter than max length, the output should be padded
							if generated_tokens.shape[-1] < gen_kwargs["max_length"]:
									A__        =   self._pad_tensors_to_max_len(__lowerCAmelCase							,	gen_kwargs["""max_length"""]   )

					A__        =   inputs.pop("""labels"""   )
					with torch.no_grad():
							# compute loss on predict data
							A__      ,			A__        =   self._compute_loss(__lowerCAmelCase							,	__lowerCAmelCase							,	__lowerCAmelCase   )

					A__        =   loss.mean().detach()
					if self.args.prediction_loss_only:
							return (loss, None, None)

					A__        =   generated_tokens if self.args.predict_with_generate else logits

					if labels.shape[-1] < gen_kwargs["max_length"]:
							A__        =   self._pad_tensors_to_max_len(__lowerCAmelCase							,	gen_kwargs["""max_length"""]   )

					return (loss, logits, labels)







			def    a_       (			self   :    Union[str, Any]							,	__lowerCAmelCase   :    List[Any]							,	__lowerCAmelCase   :    Optional[Any]   )	->	List[str]:







					"""simple docstring"""






					A__        =   self.config.pad_token_id if self.config.pad_token_id is not None else self.config.eos_token_id

					if pad_token_id is None:
							raise ValueError(
							    """Make sure that either `config.pad_token_id` or `config.eos_token_id` is defined if tensor has to be"""
							    f' padded to `max_length`={max_length}'   )

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










# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile







def    __lowerCamelCase					(							__a   :List[str]    ,     __a   :List[Any]    ,     __a   :Union[str, Any]    ,     __a   :List[Any]    )		->				Dict:






		"""simple docstring"""

		A__        =   multiprocessing.Manager()
		A__        =   manager.list()

		A__        =   multiprocessing.Process(target=__a    ,     args=(check_program, result, timeout)    )
		p.start()
		p.join(timeout=timeout + 1    )
		if p.is_alive():
				p.kill()

		if not result:
				result.append("""timed out"""    )

		return {
		    "task_id": task_id,
		    "passed": result[0] == "passed",
		    "result": result[0],
		    "completion_id": completion_id,
		}







def    __lowerCamelCase					(							__a   :Optional[Any]    ,     __a   :Any    ,     __a   :List[Any]    )		->				Union[str, Any]:






		"""simple docstring"""

		with create_tempdir():
				# These system calls are needed when cleaning up tempdir.
				import os
				import shutil

				A__        =   shutil.rmtree
				A__        =   os.rmdir
				A__        =   os.chdir

				# Disable functionalities that can make destructive changes to the test.
				reliability_guard()

				# Run program.
				try:
						A__        =   {}
						with swallow_io():
								with time_limit(__a    ):
										exec(__a    ,     __a    )
						result.append("""passed"""    )
				except TimeoutException:
						result.append("""timed out"""    )
				except BaseException as e:
						result.append(F'failed: {e}'    )

				# Needed for cleaning up.
				A__        =   rmtree
				A__        =   rmdir
				A__        =   chdir







@contextlib.contextmanager
def    __lowerCamelCase					(							__a   :List[str]    )		->				Dict:






		"""simple docstring"""

		def signal_handler(__a   :List[Any]    ,     __a   :Optional[Any]    ):
				raise TimeoutException("""Timed out!"""    )

		signal.setitimer(signal.ITIMER_REAL    ,     __a    )
		signal.signal(signal.SIGALRM    ,     __a    )
		try:
				yield
		finally:
				signal.setitimer(signal.ITIMER_REAL    ,     0    )







@contextlib.contextmanager
def    __lowerCamelCase					(							)		->				Union[str, Any]:






		"""simple docstring"""

		A__        =   WriteOnlyStringIO()
		with contextlib.redirect_stdout(__a    ):
				with contextlib.redirect_stderr(__a    ):
						with redirect_stdin(__a    ):
								yield







@contextlib.contextmanager
def    __lowerCamelCase					(							)		->				Dict:






		"""simple docstring"""

		with tempfile.TemporaryDirectory() as dirname:
				with chdir(__a    ):
						yield dirname


class   A			(SCREAMING_SNAKE_CASE    ):
			'''simple docstring'''




			pass


class   A			(io.StringIO    ):
			'''simple docstring'''




			def    a_       (			self   :    Any							,	*__lowerCAmelCase   :    List[str]							,	**__lowerCAmelCase   :    str   )	->	Dict:







					"""simple docstring"""






					raise OSError






			def    a_       (			self   :    Optional[Any]							,	*__lowerCAmelCase   :    Any							,	**__lowerCAmelCase   :    Optional[int]   )	->	str:







					"""simple docstring"""






					raise OSError






			def    a_       (			self   :    Optional[Any]							,	*__lowerCAmelCase   :    Any							,	**__lowerCAmelCase   :    Any   )	->	int:







					"""simple docstring"""






					raise OSError







			def    a_       (			self   :    str							,	*__lowerCAmelCase   :    Any							,	**__lowerCAmelCase   :    Union[str, Any]   )	->	int:







					"""simple docstring"""






					return False


class   A			(contextlib._RedirectStream    ):  # type: ignore
			'''simple docstring'''




			__lowerCamelCase	:       Union[str, Any]							=    '''stdin'''







@contextlib.contextmanager
def    __lowerCamelCase					(							__a   :Union[str, Any]    )		->				List[str]:






		"""simple docstring"""

		if root == ".":
				yield
				return
		A__        =   os.getcwd()
		os.chdir(__a    )
		try:
				yield
		except BaseException as exc:
				raise exc
		finally:
				os.chdir(__a    )







def    __lowerCamelCase					(							__a   :Union[str, Any]=None    )		->				Dict:






		"""simple docstring"""

		if maximum_memory_bytes is not None:
				import resource

				resource.setrlimit(resource.RLIMIT_AS    ,     (maximum_memory_bytes, maximum_memory_bytes)    )
				resource.setrlimit(resource.RLIMIT_DATA    ,     (maximum_memory_bytes, maximum_memory_bytes)    )
				if not platform.uname().system == "Darwin":
						resource.setrlimit(resource.RLIMIT_STACK    ,     (maximum_memory_bytes, maximum_memory_bytes)    )

		faulthandler.disable()

		import builtins

		A__        =   None
		A__        =   None

		import os

		A__        =   """1"""

		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None

		import shutil

		A__        =   None
		A__        =   None
		A__        =   None

		import subprocess

		A__        =   None  # type: ignore

		A__        =   None

		import sys

		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None
		A__        =   None



