
'''simple docstring'''
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					=			logging.get_logger(__name__)






def    __SCREAMING_SNAKE_CASE (    _SCREAMING_SNAKE_CASE				,   _SCREAMING_SNAKE_CASE ):
							def run_func(_SCREAMING_SNAKE_CASE ):
														@wraps(__snake_case )
														def run_in_eager_mode(*_SCREAMING_SNAKE_CASE				,   **_SCREAMING_SNAKE_CASE ):
																					return func(*__snake_case				,   **__snake_case )

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

														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    __SCREAMING_SNAKE_CASE (    _SCREAMING_SNAKE_CASE				,   _SCREAMING_SNAKE_CASE				,   _SCREAMING_SNAKE_CASE ):
							_snake_case  =    random.Random()
							_snake_case  =    [rng.randint(0				,   vocab_size - 1 ) for i in range(batch_size * sequence_length )]
							return tf.constant(__snake_case				,   shape=(batch_size, sequence_length)				,   dtype=tf.intaa )


class      _lowerCAmelCase       (       a_ ):







							'''simple docstring'''

							lowerCAmelCase_   		=		42
							lowerCAmelCase_   		=		42
							lowerCAmelCase_   		=		"TensorFlow"

							@property
							def 			lowercase				(self    )	->  List[Any]:
														return tf.__version__

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  float:
														# initialize GPU on separate process
														_snake_case  =    self.args.strategy
														if strategy is None:
																					raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )
														_snake_case  =    self._prepare_inference_func(__UpperCamelCase    ,    __UpperCamelCase    ,    __UpperCamelCase    )
														return self._measure_speed(_inference    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  float:
														_snake_case  =    self.args.strategy
														if strategy is None:
																					raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )
														_snake_case  =    self._prepare_train_func(__UpperCamelCase    ,    __UpperCamelCase    ,    __UpperCamelCase    )
														return self._measure_speed(_train    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  [Memory, Optional[MemorySummary]]:
														# initialize GPU on separate process
														if self.args.is_gpu:
																					tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]    ,    __UpperCamelCase    )
														_snake_case  =    self.args.strategy
														if strategy is None:
																					raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )
														_snake_case  =    self._prepare_inference_func(__UpperCamelCase    ,    __UpperCamelCase    ,    __UpperCamelCase    )
														return self._measure_memory(_inference    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  [Memory, Optional[MemorySummary]]:
														if self.args.is_gpu:
																					tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]    ,    __UpperCamelCase    )
														_snake_case  =    self.args.strategy
														if strategy is None:
																					raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )

														_snake_case  =    self._prepare_train_func(__UpperCamelCase    ,    __UpperCamelCase    ,    __UpperCamelCase    )
														return self._measure_memory(_train    )

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  Callable[[], None]:
														_snake_case  =    self.config_dict[model_name]

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

														_snake_case  =    (
														    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:
																												_snake_case  =    """TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
																												_snake_case  =    __import__("""transformers"""    ,    fromlist=[model_class]    )
																												_snake_case  =    getattr(__UpperCamelCase    ,    __UpperCamelCase    )
																												_snake_case  =    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:
																					_snake_case  =    TF_MODEL_MAPPING[config.__class__](__UpperCamelCase    )

														# encoder-decoder has vocab size saved differently
														_snake_case  =    config.vocab_size if hasattr(__UpperCamelCase    ,    """vocab_size"""    ) else config.encoder.vocab_size
														_snake_case  =    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    )

														_snake_case  =    encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

														return _inference

							def 			lowercase				(self    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    )	->  Callable[[], None]:
														_snake_case  =    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."""    )

														_snake_case  =    (
														    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:
																												_snake_case  =    """TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
																												_snake_case  =    __import__("""transformers"""    ,    fromlist=[model_class]    )
																												_snake_case  =    getattr(__UpperCamelCase    ,    __UpperCamelCase    )
																												_snake_case  =    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:
																					_snake_case  =    TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](__UpperCamelCase    )

														# encoder-decoder has vocab size saved differently
														_snake_case  =    config.vocab_size if hasattr(__UpperCamelCase    ,    """vocab_size"""    ) else config.encoder.vocab_size
														_snake_case  =    random_input_ids(__UpperCamelCase    ,    __UpperCamelCase    ,    __UpperCamelCase    )

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

														@run_with_tf_optimizations(self.args.eager_mode    ,    self.args.use_xla    )
														def encoder_train():
																					_snake_case  =    model(__UpperCamelCase    ,    labels=__UpperCamelCase    ,    training=__UpperCamelCase    )[0]
																					_snake_case  =    tf.gradients(__UpperCamelCase    ,    model.trainable_variables    )
																					return gradients

														_snake_case  =    encoder_decoder_train if config.is_encoder_decoder else encoder_train

														return _train

							def 			lowercase				(self    ,    UpperCAmelCase    )	->  float:
														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
																												_snake_case  =    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 			lowercase				(self    ,    UpperCAmelCase    )	->  [Memory, MemorySummary]:
														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."""    )
																																			_snake_case  =    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."""    )
																																										_snake_case  =    """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()
																																										_snake_case  =    nvml.nvmlDeviceGetHandleByIndex(self.args.device_idx    )
																																										_snake_case  =    nvml.nvmlDeviceGetMemoryInfo(__UpperCamelCase    )
																																										_snake_case  =    meminfo.used
																																										_snake_case  =    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."""    )
																																										_snake_case  =    None
																																			else:
																																										_snake_case  =    measure_peak_memory_cpu(__UpperCamelCase    )
																																										_snake_case  =    Memory(__UpperCamelCase    ) if isinstance(__UpperCamelCase    ,    __UpperCamelCase    ) else memory_bytes
																												if self.args.trace_memory_line_by_line:
																																			_snake_case  =    stop_memory_tracing(__UpperCamelCase    )
																																			if memory is None:
																																										_snake_case  =    summary.total
																												else:
																																			_snake_case  =    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 typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType



class 				_UpperCamelCase      (a_      ):
      snake_case_	=				["""image_processor""", """tokenizer"""]
      snake_case_	=				"""FlavaImageProcessor"""
      snake_case_	=				("""BertTokenizer""", """BertTokenizerFast""")


      def __init__(						self       ,    __UpperCamelCase=None       ,    __UpperCamelCase=None       ,    **__UpperCamelCase						)->						Tuple:
           __lowerCAmelCase             =       None
           if "feature_extractor" in kwargs:
                warnings.warn(
                    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
                    " instead."       ,    __UpperCamelCase       ,    )
                __lowerCAmelCase             =       kwargs.pop("feature_extractor"						)

           __lowerCAmelCase             =       image_processor if image_processor is not None else feature_extractor
           if image_processor is None:
                raise ValueError("You need to specify an `image_processor`."						)
           if tokenizer is None:
                raise ValueError("You need to specify a `tokenizer`."						)

           super().__init__(__UpperCamelCase       ,    __UpperCamelCase						)
           __lowerCAmelCase             =       self.image_processor


      def __call__(						self       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = True       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = None       ,    __UpperCamelCase = 0       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = None       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = False       ,    __UpperCamelCase = True       ,    __UpperCamelCase = None       ,    **__UpperCamelCase       ,    )->						int:

           if text is None and images is None:
                raise ValueError("You have to specify either text or images. Both cannot be none."						)

           if text is not None:
                __lowerCAmelCase             =       self.tokenizer(
                    text=__UpperCamelCase       ,    add_special_tokens=__UpperCamelCase       ,    padding=__UpperCamelCase       ,    truncation=__UpperCamelCase       ,    max_length=__UpperCamelCase       ,    stride=__UpperCamelCase       ,    pad_to_multiple_of=__UpperCamelCase       ,    return_token_type_ids=__UpperCamelCase       ,    return_attention_mask=__UpperCamelCase       ,    return_overflowing_tokens=__UpperCamelCase       ,    return_special_tokens_mask=__UpperCamelCase       ,    return_offsets_mapping=__UpperCamelCase       ,    return_length=__UpperCamelCase       ,    verbose=__UpperCamelCase       ,    return_tensors=__UpperCamelCase       ,    **__UpperCamelCase       ,    )
           if images is not None:
                __lowerCAmelCase             =       self.image_processor(
                    __UpperCamelCase       ,    return_image_mask=__UpperCamelCase       ,    return_codebook_pixels=__UpperCamelCase       ,    return_tensors=__UpperCamelCase       ,    **__UpperCamelCase       ,    )

           if text is not None and images is not None:
                encoding.update(__UpperCamelCase						)
                return encoding
           elif text is not None:
                return encoding
           else:
                return BatchEncoding(data=dict(**__UpperCamelCase						)       ,    tensor_type=__UpperCamelCase						)


      def 			__UpperCAmelCase		(						self       ,    *__UpperCamelCase       ,    **__UpperCamelCase						)->						int:
           return self.tokenizer.batch_decode(*__UpperCamelCase       ,    **__UpperCamelCase						)


      def 			__UpperCAmelCase		(						self       ,    *__UpperCamelCase       ,    **__UpperCamelCase						)->						Optional[int]:
           return self.tokenizer.decode(*__UpperCamelCase       ,    **__UpperCamelCase						)


      @property
      def 			__UpperCAmelCase		(						self						)->						Any:
           __lowerCAmelCase             =       self.tokenizer.model_input_names
           __lowerCAmelCase             =       self.image_processor.model_input_names
           return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names						)						)


      @property
      def 			__UpperCAmelCase		(						self						)->						Dict:
           warnings.warn(
               "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."       ,    __UpperCamelCase       ,    )
           return self.image_processor_class


      @property
      def 			__UpperCAmelCase		(						self						)->						Union[str, Any]:
           warnings.warn(
               "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."       ,    __UpperCamelCase       ,    )
           return self.image_processor






