






'''simple docstring'''





import timeit
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_auto import MODEL_MAPPING, MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_torch_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_torch_available():
						import torch

						from .benchmark_args import PyTorchBenchmarkArguments


if is_pyanvml_available():
						import pyanvml.pyanvml as nvml


_UpperCamelCase		:		str								=			logging.get_logger(__name__)


class 				snake_case__     (			UpperCamelCase):
					a_       =			42
					a_       =			42
					a_       =			"PyTorch"




					@property
					def 						A     (       self       :						str     )  ->    Any:
								return torch.__version__




					def 						A     (       self       :						List[Any]							,				_A       :						str							,				_A       :						int							,				_A       :						int     )  ->    float:
								UpperCAmelCase_     :   int       =   self._prepare_inference_func(_A							,				_A							,				_A     )
								return self._measure_speed(_inference     )




					def 						A     (       self       :						Dict							,				_A       :						str							,				_A       :						int							,				_A       :						int     )  ->    [Memory, Optional[MemorySummary]]:
								UpperCAmelCase_     :   str       =   self._prepare_inference_func(_A							,				_A							,				_A     )
								return self._measure_memory(_inference     )




					def 						A     (       self       :						List[str]							,				_A       :						str							,				_A       :						int							,				_A       :						int     )  ->    float:
								UpperCAmelCase_     :   Tuple       =   self._prepare_train_func(_A							,				_A							,				_A     )
								return self._measure_speed(_train     )




					def 						A     (       self       :						Union[str, Any]							,				_A       :						str							,				_A       :						int							,				_A       :						int     )  ->    [Memory, Optional[MemorySummary]]:
								UpperCAmelCase_     :   Any       =   self._prepare_train_func(_A							,				_A							,				_A     )
								return self._measure_memory(_train     )




					def 						A     (       self       :						List[Any]							,				_A       :						str							,				_A       :						int							,				_A       :						int     )  ->    Callable[[], None]:
								UpperCAmelCase_     :   Any       =   self.config_dict[model_name]

								if self.args.torchscript:
											UpperCAmelCase_     :   Dict       =   True

								UpperCAmelCase_     :   Optional[Any]       =   (
								    hasattr(_A							,				'''architectures'''     )
								    and isinstance(config.architectures							,				_A     )
								    and len(config.architectures     ) > 0
								)
								if not self.args.only_pretrain_model and has_model_class_in_config:
											try:
														UpperCAmelCase_     :   Tuple       =   config.architectures[0]
														UpperCAmelCase_     :   List[Any]       =   __import__('''transformers'''							,				fromlist=[model_class]     )
														UpperCAmelCase_     :   Any       =   getattr(_A							,				_A     )
														UpperCAmelCase_     :   Optional[Any]       =   model_cls(_A     )
											except ImportError:
														raise ImportError(
														    F"{model_class} does not exist. If you just want to test the pretrained model, you might want to"
														    ''' set `--only_pretrain_model` or `args.only_pretrain_model=True`.'''     )
								else:
											UpperCAmelCase_     :   str       =   MODEL_MAPPING[config.__class__](_A     )

								model.eval()
								model.to(self.args.device     )

								# encoder-decoder has vocab size saved differently
								UpperCAmelCase_     :   Tuple       =   config.vocab_size if hasattr(_A							,				'''vocab_size'''     ) else config.encoder.vocab_size
								UpperCAmelCase_     :   Optional[int]       =   torch.randint(_A							,				(batch_size, sequence_length)							,				dtype=torch.long							,				device=self.args.device     )

								if self.args.fpaa:
											logger.info('''Running training in Mixed Precision...'''     )
											if not self.args.is_gpu:
														raise ValueError('''Mixed precision is possible only for GPU.'''     )
											# amp seems to have memory leaks so that memory usage
											# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
											model.half()

								if self.args.torchscript:
											with torch.no_grad():
														UpperCAmelCase_     :   Optional[int]       =   torch.jit.trace(_A							,				_A     )
								else:
											UpperCAmelCase_     :   str       =   model

								def encoder_decoder_forward():
											with torch.no_grad():
														UpperCAmelCase_     :   int       =   inference_model(_A							,				decoder_input_ids=_A     )
											return outputs

								def encoder_forward():
											with torch.no_grad():
														UpperCAmelCase_     :   Optional[Any]       =   inference_model(_A     )
											return outputs

								UpperCAmelCase_     :   Tuple       =   encoder_decoder_forward if config.is_encoder_decoder else encoder_forward
								return _forward




					def 						A     (       self       :						List[Any]							,				_A       :						str							,				_A       :						int							,				_A       :						int     )  ->    Callable[[], None]:
								UpperCAmelCase_     :   str       =   self.config_dict[model_name]

								UpperCAmelCase_     :   Optional[int]       =   (
								    hasattr(_A							,				'''architectures'''     )
								    and isinstance(config.architectures							,				_A     )
								    and len(config.architectures     ) > 0
								)
								if not self.args.only_pretrain_model and has_model_class_in_config:
											try:
														UpperCAmelCase_     :   int       =   config.architectures[0]
														UpperCAmelCase_     :   Dict       =   __import__('''transformers'''							,				fromlist=[model_class]     )
														UpperCAmelCase_     :   List[Any]       =   getattr(_A							,				_A     )
														UpperCAmelCase_     :   Dict       =   model_cls(_A     )
											except ImportError:
														raise ImportError(
														    F"{model_class} does not exist. If you just want to test the pretrained model, you might want to"
														    ''' set `--only_pretrain_model` or `args.only_pretrain_model=True`.'''     )
								else:
											UpperCAmelCase_     :   Optional[int]       =   MODEL_WITH_LM_HEAD_MAPPING[config.__class__](_A     )

								if self.args.torchscript:
											raise NotImplementedError('''Training for torchscript is currently not implemented'''     )
								else:
											UpperCAmelCase_     :   Dict       =   model

								model.train()
								model.to(self.args.device     )

								# encoder-decoder has vocab size saved differently
								UpperCAmelCase_     :   List[Any]       =   config.vocab_size if hasattr(_A							,				'''vocab_size'''     ) else config.encoder.vocab_size
								UpperCAmelCase_     :   List[Any]       =   torch.randint(_A							,				(batch_size, sequence_length)							,				dtype=torch.long							,				device=self.args.device     )

								if self.args.fpaa:
											logger.info('''Running training in Mixed Precision...'''     )
											if not self.args.is_gpu:
														raise ValueError('''Mixed precision is possible only for GPU.'''     )

											# amp seems to have memory leaks so that memory usage
											# is measured using .half() for now https://github.com/NVIDIA/apex/issues/439
											model.half()

								def compute_loss_and_backprob_encoder():
											UpperCAmelCase_     :   Any       =   train_model(_A							,				labels=_A     )[0]
											loss.backward()
											return loss

								def compute_loss_and_backprob_encoder_decoder():
											UpperCAmelCase_     :   Union[str, Any]       =   train_model(_A							,				decoder_input_ids=_A							,				labels=_A     )[0]
											loss.backward()
											return loss

								UpperCAmelCase_     :   str       =   (
								    compute_loss_and_backprob_encoder_decoder
								    if config.is_encoder_decoder
								    else compute_loss_and_backprob_encoder
								)
								return _train




					def 						A     (       self       :						List[Any]							,				_A       :						List[str]     )  ->    float:
								try:
											if self.args.is_tpu or self.args.torchscript:
														# run additional 10 times to stabilize compilation for tpu and torchscript
														logger.info('''Do inference on TPU or torchscript. Running model 5 times to stabilize compilation'''     )
														timeit.repeat(
														    _A							,				repeat=1							,				number=5							,				)

											# as written in https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat, min should be taken rather than the average
											UpperCAmelCase_     :   Union[str, Any]       =   timeit.repeat(
											    _A							,				repeat=self.args.repeat							,				number=10							,				)

											if self.args.is_tpu and self.args.torch_xla_tpu_print_metrics:
														import torch_xla.debug.metrics as met

														self.print_fn(met.metrics_report()     )

											return min(_A     ) / 10.0
								except RuntimeError as e:
											self.print_fn(F"Doesn't fit on GPU. {e}"     )
											return "N/A"





					def 						A     (       self       :						List[str]							,				_A       :						Callable[[], None]     )  ->    [Memory, MemorySummary]:
								try:
											if self.args.trace_memory_line_by_line:
														UpperCAmelCase_     :   Tuple       =   start_memory_tracing('''transformers'''     )

											if self.args.is_tpu:
														# tpu
														raise NotImplementedError(
														    '''Memory Benchmarking is currently not implemented for TPU. Please disable memory benchmarking with'''
														    ''' `--no-memory` or `args.memory=False`'''     )
											elif self.args.is_gpu:
														if not is_pyanvml_available():
																	logger.warning(
																	    '''py3nvml not installed, we won\'t log GPU memory usage. '''
																	    '''Install py3nvml (pip install py3nvml) to log information about GPU.'''     )
																	UpperCAmelCase_     :   str       =   '''N/A'''
														else:
																	logger.info(
																	    '''Measuring total GPU usage on GPU device. Make sure to not have additional processes running'''
																	    ''' on the same GPU.'''     )
																	# init nvml
																	nvml.nvmlInit()
																	func()
																	UpperCAmelCase_     :   Dict       =   nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx     )
																	UpperCAmelCase_     :   List[Any]       =   nvml.nvmlDeviceGetMemoryInfo(_A     )
																	UpperCAmelCase_     :   Tuple       =   meminfo.used
																	UpperCAmelCase_     :   Dict       =   Memory(_A     )
																	# shutdown nvml
																	nvml.nvmlShutdown()
											else:
														# cpu
														UpperCAmelCase_     :   Any       =   measure_peak_memory_cpu(_A     )
														UpperCAmelCase_     :   Optional[int]       =   Memory(_A     ) if isinstance(_A							,				_A     ) else memory_bytes

											if self.args.trace_memory_line_by_line:
														UpperCAmelCase_     :   List[Any]       =   stop_memory_tracing(_A     )
											else:
														UpperCAmelCase_     :   Optional[int]       =   None

											return memory, summary
								except RuntimeError as e:
											self.print_fn(F"Doesn't fit on GPU. {e}"     )
											return "N/A", None










'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available


_UpperCamelCase		:		str								=			{}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_UpperCamelCase		:		List[Any]								=			['MBart50Tokenizer']

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_UpperCamelCase		:		List[str]								=			['MBart50TokenizerFast']


if TYPE_CHECKING:
						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mbartaa import MBartaaTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mbartaa_fast import MBartaaTokenizerFast

else:
						import sys

						_UpperCamelCase		:		Optional[int]								=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


