



import random
import timeit
from functools import wraps
from typing import Callable, Optional

from ..configuration_utils import PretrainedConfig
from ..models.auto.modeling_tf_auto import TF_MODEL_MAPPING, TF_MODEL_WITH_LM_HEAD_MAPPING
from ..utils import is_pyanvml_available, is_tf_available, logging
from .benchmark_utils import (
    Benchmark,
    Memory,
    MemorySummary,
    measure_peak_memory_cpu,
    start_memory_tracing,
    stop_memory_tracing,
)


if is_tf_available():
			import tensorflow as tf
			from tensorflow.python.framework.errors_impl import ResourceExhaustedError

			from .benchmark_args_tf import TensorFlowBenchmarkArguments

if is_pyanvml_available():
			import pyanvml.pyanvml as nvml

_lowerCamelCase    :		List[str]		      =    logging.get_logger(__name__)

def        __a			(   __lowerCAmelCase      ,	__lowerCAmelCase   )     ->     str:





					def run_func(__lowerCAmelCase   ):
										@wraps(A_   )
										def run_in_eager_mode(*__lowerCAmelCase      ,	**__lowerCAmelCase   ):
															return func(*A_      ,	**A_   )

										@wraps(A_   )
										@tf.function(experimental_compile=A_   )
										def run_in_graph_mode(*__lowerCAmelCase      ,	**__lowerCAmelCase   ):
															return func(*A_      ,	**A_   )

										if do_eager_mode is True:
															if use_xla is not False:
																				raise ValueError(
																				    'Cannot run model in XLA, if `args.eager_mode` is set to `True`. Please set `args.eager_mode=False`.'   )
															return run_in_eager_mode
										else:
															return run_in_graph_mode

					return run_func

def        __a			(   __lowerCAmelCase      ,	__lowerCAmelCase      ,	__lowerCAmelCase   )     ->     str:
					SCREAMING_SNAKE_CASE							:     Any						=				random.Random()
					SCREAMING_SNAKE_CASE							:     List[str]						=				[rng.randint(0      ,	vocab_size - 1   ) for i in range(batch_size * sequence_length   )]
					return tf.constant(A_      ,	shape=(batch_size, sequence_length)      ,	dtype=tf.intaa   )



class 						lowercase    (							_A):
						'''simple docstring'''


						UpperCAmelCase			:		int		=		42
						UpperCAmelCase			:		List[str]		=		42
						UpperCAmelCase			:		str		=		'TensorFlow'







						@property
						def       lowerCamelCase_				(  self    :				Optional[int]	):



											'''simple docstring'''


											return tf.__version__







						def       lowerCamelCase_				(  self    :				Union[str, Any]       ,	snake_case    :				str       ,	snake_case    :				int       ,	snake_case    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				self.args.strategy
											if strategy is None:
																raise ValueError('A device strategy has to be initialized before using TensorFlow.'	)
											SCREAMING_SNAKE_CASE							:     List[Any]						=				self._prepare_inference_func(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__	)
											return self._measure_speed(_inference	)







						def       lowerCamelCase_				(  self    :				Any       ,	snake_case    :				str       ,	snake_case    :				int       ,	snake_case    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Optional[int]						=				self.args.strategy
											if strategy is None:
																raise ValueError('A device strategy has to be initialized before using TensorFlow.'	)
											SCREAMING_SNAKE_CASE							:     Optional[Any]						=				self._prepare_train_func(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__	)
											return self._measure_speed(_train	)







						def       lowerCamelCase_				(  self    :				Union[str, Any]       ,	snake_case    :				str       ,	snake_case    :				int       ,	snake_case    :				int	):



											'''simple docstring'''


											if self.args.is_gpu:
																tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]       ,	UpperCamelCase__	)
											SCREAMING_SNAKE_CASE							:     Tuple						=				self.args.strategy
											if strategy is None:
																raise ValueError('A device strategy has to be initialized before using TensorFlow.'	)
											SCREAMING_SNAKE_CASE							:     List[str]						=				self._prepare_inference_func(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__	)
											return self._measure_memory(_inference	)







						def       lowerCamelCase_				(  self    :				str       ,	snake_case    :				str       ,	snake_case    :				int       ,	snake_case    :				int	):



											'''simple docstring'''


											if self.args.is_gpu:
																tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]       ,	UpperCamelCase__	)
											SCREAMING_SNAKE_CASE							:     Dict						=				self.args.strategy
											if strategy is None:
																raise ValueError('A device strategy has to be initialized before using TensorFlow.'	)

											SCREAMING_SNAKE_CASE							:     Optional[int]						=				self._prepare_train_func(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__	)
											return self._measure_memory(_train	)







						def       lowerCamelCase_				(  self    :				List[Any]       ,	snake_case    :				str       ,	snake_case    :				int       ,	snake_case    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     Dict						=				self.config_dict[model_name]

											if self.args.fpaa:
																raise NotImplementedError('Mixed precision is currently not supported.'	)

											SCREAMING_SNAKE_CASE							:     str						=				(
											    hasattr(UpperCamelCase__       ,	'architectures'	)
											    and isinstance(config.architectures       ,	UpperCamelCase__	)
											    and len(config.architectures	) > 0
											)
											if not self.args.only_pretrain_model and has_model_class_in_config:
																try:
																					SCREAMING_SNAKE_CASE							:     List[str]						=				'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
																					SCREAMING_SNAKE_CASE							:     List[Any]						=				__import__('transformers'       ,	fromlist=[model_class]	)
																					SCREAMING_SNAKE_CASE							:     Dict						=				getattr(UpperCamelCase__       ,	UpperCamelCase__	)
																					SCREAMING_SNAKE_CASE							:     Any						=				model_cls(UpperCamelCase__	)
																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:
																SCREAMING_SNAKE_CASE							:     int						=				TF_MODEL_MAPPING[config.__class__](UpperCamelCase__	)

											# encoder-decoder has vocab size saved differently
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				config.vocab_size if hasattr(UpperCamelCase__       ,	'vocab_size'	) else config.encoder.vocab_size
											SCREAMING_SNAKE_CASE							:     List[Any]						=				random_input_ids(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__	)

											@run_with_tf_optimizations(self.args.eager_mode       ,	self.args.use_xla	)
											def encoder_decoder_forward():
																return model(UpperCamelCase__       ,	decoder_input_ids=UpperCamelCase__       ,	training=UpperCamelCase__	)

											@run_with_tf_optimizations(self.args.eager_mode       ,	self.args.use_xla	)
											def encoder_forward():
																return model(UpperCamelCase__       ,	training=UpperCamelCase__	)

											SCREAMING_SNAKE_CASE							:     Tuple						=				encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

											return _inference







						def       lowerCamelCase_				(  self    :				Optional[Any]       ,	snake_case    :				str       ,	snake_case    :				int       ,	snake_case    :				int	):



											'''simple docstring'''


											SCREAMING_SNAKE_CASE							:     int						=				self.config_dict[model_name]

											if self.args.eager_mode is not False:
																raise ValueError('Training cannot be done in eager mode. Please make sure that `args.eager_mode = False`.'	)

											if self.args.fpaa:
																raise NotImplementedError('Mixed precision is currently not supported.'	)

											SCREAMING_SNAKE_CASE							:     List[Any]						=				(
											    hasattr(UpperCamelCase__       ,	'architectures'	)
											    and isinstance(config.architectures       ,	UpperCamelCase__	)
											    and len(config.architectures	) > 0
											)
											if not self.args.only_pretrain_model and has_model_class_in_config:
																try:
																					SCREAMING_SNAKE_CASE							:     Optional[int]						=				'TF' + config.architectures[0]  # prepend 'TF' for tensorflow model
																					SCREAMING_SNAKE_CASE							:     Optional[int]						=				__import__('transformers'       ,	fromlist=[model_class]	)
																					SCREAMING_SNAKE_CASE							:     Tuple						=				getattr(UpperCamelCase__       ,	UpperCamelCase__	)
																					SCREAMING_SNAKE_CASE							:     Optional[Any]						=				model_cls(UpperCamelCase__	)
																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:
																SCREAMING_SNAKE_CASE							:     List[str]						=				TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](UpperCamelCase__	)

											# encoder-decoder has vocab size saved differently
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				config.vocab_size if hasattr(UpperCamelCase__       ,	'vocab_size'	) else config.encoder.vocab_size
											SCREAMING_SNAKE_CASE							:     Optional[int]						=				random_input_ids(UpperCamelCase__       ,	UpperCamelCase__       ,	UpperCamelCase__	)

											@run_with_tf_optimizations(self.args.eager_mode       ,	self.args.use_xla	)
											def encoder_decoder_train():
																SCREAMING_SNAKE_CASE							:     Any						=				model(UpperCamelCase__       ,	decoder_input_ids=UpperCamelCase__       ,	labels=UpperCamelCase__       ,	training=UpperCamelCase__	)[0]
																SCREAMING_SNAKE_CASE							:     int						=				tf.gradients(UpperCamelCase__       ,	model.trainable_variables	)
																return gradients

											@run_with_tf_optimizations(self.args.eager_mode       ,	self.args.use_xla	)
											def encoder_train():
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				model(UpperCamelCase__       ,	labels=UpperCamelCase__       ,	training=UpperCamelCase__	)[0]
																SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				tf.gradients(UpperCamelCase__       ,	model.trainable_variables	)
																return gradients

											SCREAMING_SNAKE_CASE							:     List[Any]						=				encoder_decoder_train if config.is_encoder_decoder else encoder_train

											return _train







						def       lowerCamelCase_				(  self    :				int       ,	snake_case    :				str	):



											'''simple docstring'''


											with self.args.strategy.scope():
																try:
																					if self.args.is_tpu or self.args.use_xla:
																										# run additional 10 times to stabilize compilation for tpu
																										logger.info('Do inference on TPU. Running model 5 times to stabilize compilation'	)
																										timeit.repeat(UpperCamelCase__       ,	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
																					SCREAMING_SNAKE_CASE							:     Dict						=				timeit.repeat(
																					    UpperCamelCase__       ,	repeat=self.args.repeat       ,	number=10       ,	)

																					return min(UpperCamelCase__	) / 10.0
																except ResourceExhaustedError as e:
																					self.print_fn(f'''Doesn\'t fit on GPU. {e}'''	)







						def       lowerCamelCase_				(  self    :				int       ,	snake_case    :				Callable[[], None]	):



											'''simple docstring'''


											logger.info(
											    'Note that TensorFlow allocates more memory than '
											    'it might need to speed up computation. '
											    'The memory reported here corresponds to the memory '
											    'reported by `nvidia-smi`, which can vary depending '
											    'on total available memory on the GPU that is used.'	)
											with self.args.strategy.scope():
																try:
																					if self.args.trace_memory_line_by_line:
																										if not self.args.eager_mode:
																															raise ValueError(
																															    '`args.eager_mode` is set to `False`. Make sure to run model in eager mode to measure memory'
																															    ' consumption line by line.'	)
																										SCREAMING_SNAKE_CASE							:     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 `args.memory=False`'	)
																					elif self.args.is_gpu:
																										# 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.'	)
																															SCREAMING_SNAKE_CASE							:     int						=				'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()
																															SCREAMING_SNAKE_CASE							:     Optional[int]						=				nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx	)
																															SCREAMING_SNAKE_CASE							:     Optional[Any]						=				nvml.nvmlDeviceGetMemoryInfo(UpperCamelCase__	)
																															SCREAMING_SNAKE_CASE							:     int						=				meminfo.used
																															SCREAMING_SNAKE_CASE							:     Union[str, Any]						=				Memory(UpperCamelCase__	)
																															# shutdown nvml
																															nvml.nvmlShutdown()
																					else:
																										# cpu
																										if self.args.trace_memory_line_by_line:
																															logger.info(
																															    'When enabling line by line tracing, the max peak memory for CPU is inaccurate in'
																															    ' TensorFlow.'	)
																															SCREAMING_SNAKE_CASE							:     Any						=				None
																										else:
																															SCREAMING_SNAKE_CASE							:     List[Any]						=				measure_peak_memory_cpu(UpperCamelCase__	)
																															SCREAMING_SNAKE_CASE							:     Dict						=				Memory(UpperCamelCase__	) if isinstance(UpperCamelCase__       ,	UpperCamelCase__	) else memory_bytes
																					if self.args.trace_memory_line_by_line:
																										SCREAMING_SNAKE_CASE							:     Any						=				stop_memory_tracing(UpperCamelCase__	)
																										if memory is None:
																															SCREAMING_SNAKE_CASE							:     List[str]						=				summary.total
																					else:
																										SCREAMING_SNAKE_CASE							:     List[Any]						=				None

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

import warnings

from ...utils import logging
from .image_processing_beit import BeitImageProcessor


__lowerCAmelCase     :	int       			=  logging.get_logger(__name__)




class 			UpperCAmelCase_     (					_A	):


  '''simple docstring'''







  def __init__(					self     :					int     ,				*UpperCamelCase__     :					Optional[Any]     ,				**UpperCamelCase__     :					Optional[Any]       )     ->      None:







    """simple docstring"""






    warnings.warn(
        """The class BeitFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"""
        """ use BeitImageProcessor instead."""     ,				UpperCamelCase__     ,				)
    super().__init__(*UpperCamelCase__     ,				**UpperCamelCase__       )

