





"""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

__magic_name__       :					Optional[Any]						=			logging.get_logger(__name__)

def      UpperCamelCase							(SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE     ):
						def run_func(SCREAMING_SNAKE_CASE     ):
												@wraps(SCREAMING_SNAKE_CASE     )
												def run_in_eager_mode(*SCREAMING_SNAKE_CASE							,     **SCREAMING_SNAKE_CASE     ):
																		return func(*SCREAMING_SNAKE_CASE							,     **SCREAMING_SNAKE_CASE     )

												@wraps(SCREAMING_SNAKE_CASE     )
												@tf.function(experimental_compile=SCREAMING_SNAKE_CASE     )
												def run_in_graph_mode(*SCREAMING_SNAKE_CASE							,     **SCREAMING_SNAKE_CASE     ):
																		return func(*SCREAMING_SNAKE_CASE							,     **SCREAMING_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      UpperCamelCase							(SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE     ):
						UpperCamelCase				:		Optional[int]				   =			random.Random()
						UpperCamelCase				:		Tuple				   =			[rng.randint(0							,     vocab_size - 1     ) for i in range(batch_size * sequence_length     )]
						return tf.constant(SCREAMING_SNAKE_CASE							,     shape=(batch_size, sequence_length)							,     dtype=tf.intaa     )






class 							lowercase__			(   __SCREAMING_SNAKE_CASE	):

			"""simple docstring"""
			__lowerCAmelCase     :				TensorFlowBenchmarkArguments
			__lowerCAmelCase     :				PretrainedConfig
			__lowerCAmelCase     :				str										=  "TensorFlow"







			@property
			def   _a      (      self    ):






									'''simple docstring'''







									return tf.__version__







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		Optional[Any]				   =			self.args.strategy
									if strategy is None:
															raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )
									UpperCamelCase				:		Optional[int]				   =			self._prepare_inference_func(_A						,   _A						,   _A    )
									return self._measure_speed(_inference    )







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		Dict				   =			self.args.strategy
									if strategy is None:
															raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )
									UpperCamelCase				:		str				   =			self._prepare_train_func(_A						,   _A						,   _A    )
									return self._measure_speed(_train    )







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									if self.args.is_gpu:
															tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]						,   _A    )
									UpperCamelCase				:		int				   =			self.args.strategy
									if strategy is None:
															raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )
									UpperCamelCase				:		Dict				   =			self._prepare_inference_func(_A						,   _A						,   _A    )
									return self._measure_memory(_inference    )







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									if self.args.is_gpu:
															tf.config.experimental.set_memory_growth(self.args.gpu_list[self.args.device_idx]						,   _A    )
									UpperCamelCase				:		List[str]				   =			self.args.strategy
									if strategy is None:
															raise ValueError("""A device strategy has to be initialized before using TensorFlow."""    )

									UpperCamelCase				:		Any				   =			self._prepare_train_func(_A						,   _A						,   _A    )
									return self._measure_memory(_train    )







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		List[str]				   =			self.config_dict[model_name]

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

									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				:		List[str]				   =			"""TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
																					UpperCamelCase				:		Optional[int]				   =			__import__("""transformers"""						,   fromlist=[model_class]    )
																					UpperCamelCase				:		str				   =			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]				   =			TF_MODEL_MAPPING[config.__class__](_A    )

									# encoder-decoder has vocab size saved differently
									UpperCamelCase				:		Optional[Any]				   =			config.vocab_size if hasattr(_A						,   """vocab_size"""    ) else config.encoder.vocab_size
									UpperCamelCase				:		Dict				   =			random_input_ids(_A						,   _A						,   _A    )

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

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

									UpperCamelCase				:		str				   =			encoder_decoder_forward if config.is_encoder_decoder else encoder_forward

									return _inference







			def   _a      (      self						,   _A						,   _A						,   _A    ):






									'''simple docstring'''







									UpperCamelCase				:		Tuple				   =			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."""    )

									UpperCamelCase				:		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				:		Optional[int]				   =			"""TF""" + config.architectures[0]  # prepend 'TF' for tensorflow model
																					UpperCamelCase				:		Any				   =			__import__("""transformers"""						,   fromlist=[model_class]    )
																					UpperCamelCase				:		Optional[int]				   =			getattr(_A						,   _A    )
																					UpperCamelCase				:		Union[str, 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				   =			TF_MODEL_WITH_LM_HEAD_MAPPING[config.__class__](_A    )

									# encoder-decoder has vocab size saved differently
									UpperCamelCase				:		str				   =			config.vocab_size if hasattr(_A						,   """vocab_size"""    ) else config.encoder.vocab_size
									UpperCamelCase				:		Union[str, Any]				   =			random_input_ids(_A						,   _A						,   _A    )

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

									@run_with_tf_optimizations(self.args.eager_mode						,   self.args.use_xla    )
									def encoder_train():
															UpperCamelCase				:		List[str]				   =			model(_A						,   labels=_A						,   training=_A    )[0]
															UpperCamelCase				:		int				   =			tf.gradients(_A						,   model.trainable_variables    )
															return gradients

									UpperCamelCase				:		Tuple				   =			encoder_decoder_train if config.is_encoder_decoder else encoder_train

									return _train







			def   _a      (      self						,   _A    ):






									'''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(_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				:		int				   =			timeit.repeat(
																					    _A						,   repeat=self.args.repeat						,   number=1_0						,   )

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







			def   _a      (      self						,   _A    ):






									'''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."""    )
																											UpperCamelCase				:		List[str]				   =			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."""    )
																																	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[str]				   =			nvml.nvmlDeviceGetMemoryInfo(_A    )
																																	UpperCamelCase				:		Union[str, Any]				   =			meminfo.used
																																	UpperCamelCase				:		Tuple				   =			Memory(_A    )
																																	# 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."""    )
																																	UpperCamelCase				:		Dict				   =			None
																											else:
																																	UpperCamelCase				:		List[Any]				   =			measure_peak_memory_cpu(_A    )
																																	UpperCamelCase				:		Dict				   =			Memory(_A    ) if isinstance(_A						,   _A    ) else memory_bytes
																					if self.args.trace_memory_line_by_line:
																											UpperCamelCase				:		List[str]				   =			stop_memory_tracing(_A    )
																											if memory is None:
																																	UpperCamelCase				:		str				   =			summary.total
																					else:
																											UpperCamelCase				:		Tuple				   =			None

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





"""simple docstring"""




import unittest

from transformers import is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
  from PIL import Image
else:


  class       __magic_name__							:
         @staticmethod
         def 				lowercase_				(  *A_			,					**A_							)  ->						Optional[int]:





           """simple docstring"""




           pass


@is_pipeline_test
@require_vision
class       __magic_name__							(							unittest.TestCase			):
       @require_torch
       def 				lowercase_				(  self							)  ->						int:





         """simple docstring"""




         _lowercase:      Optional[Any]   			=  pipeline(
             model='''hf-internal-testing/tiny-random-clip-zero-shot-image-classification'''			,					)
         _lowercase:      List[Any]   			=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
         _lowercase:      str   			=  image_classifier(A_			,					candidate_labels=['''a''', '''b''', '''c''']							)

         # The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
         # python and torch versions.
         self.assertIn(
             nested_simplify(A_							)			,					[
                 [{'''score''': 0.3_33, '''label''': '''a'''}, {'''score''': 0.3_33, '''label''': '''b'''}, {'''score''': 0.3_33, '''label''': '''c'''}],
                 [{'''score''': 0.3_33, '''label''': '''a'''}, {'''score''': 0.3_33, '''label''': '''c'''}, {'''score''': 0.3_33, '''label''': '''b'''}],
             ]			,					)

         _lowercase:      Any   			=  image_classifier([image] * 5			,					candidate_labels=['''A''', '''B''', '''C''']			,					batch_size=2							)
         self.assertEqual(
             nested_simplify(A_							)			,					[
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
             ]			,					)
       @require_tf
       def 				lowercase_				(  self							)  ->						int:





         """simple docstring"""




         _lowercase:      Union[str, Any]   			=  pipeline(
             model='''hf-internal-testing/tiny-random-clip-zero-shot-image-classification'''			,					framework='''tf'''							)
         _lowercase:      List[str]   			=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
         _lowercase:      Union[str, Any]   			=  image_classifier(A_			,					candidate_labels=['''a''', '''b''', '''c''']							)

         self.assertEqual(
             nested_simplify(A_							)			,					[{'''score''': 0.3_33, '''label''': '''a'''}, {'''score''': 0.3_33, '''label''': '''b'''}, {'''score''': 0.3_33, '''label''': '''c'''}]			,					)

         _lowercase:      List[str]   			=  image_classifier([image] * 5			,					candidate_labels=['''A''', '''B''', '''C''']			,					batch_size=2							)
         self.assertEqual(
             nested_simplify(A_							)			,					[
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
                 [
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                     {'''score''': 0.3_33, '''label''': ANY(A_							)},
                 ],
             ]			,					)
       @slow
       @require_torch
       def 				lowercase_				(  self							)  ->						Any:





         """simple docstring"""




         _lowercase:      Tuple   			=  pipeline(
             task='''zero-shot-image-classification'''			,					model='''openai/clip-vit-base-patch32'''			,					)
         # This is an image of 2 cats with remotes and no planes
         _lowercase:      str   			=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
         _lowercase:      Optional[Any]   			=  image_classifier(A_			,					candidate_labels=['''cat''', '''plane''', '''remote''']							)

         self.assertEqual(
             nested_simplify(A_							)			,					[
                 {'''score''': 0.5_11, '''label''': '''remote'''},
                 {'''score''': 0.4_85, '''label''': '''cat'''},
                 {'''score''': 0.0_04, '''label''': '''plane'''},
             ]			,					)

         _lowercase:      Optional[Any]   			=  image_classifier([image] * 5			,					candidate_labels=['''cat''', '''plane''', '''remote''']			,					batch_size=2							)
         self.assertEqual(
             nested_simplify(A_							)			,					[
                 [
                     {'''score''': 0.5_11, '''label''': '''remote'''},
                     {'''score''': 0.4_85, '''label''': '''cat'''},
                     {'''score''': 0.0_04, '''label''': '''plane'''},
                 ],
             ]
             * 5			,					)



       @slow
       @require_tf
       def 				lowercase_				(  self							)  ->						Optional[Any]:





         """simple docstring"""




         _lowercase:      Tuple   			=  pipeline(
             task='''zero-shot-image-classification'''			,					model='''openai/clip-vit-base-patch32'''			,					framework='''tf'''							)
         # This is an image of 2 cats with remotes and no planes
         _lowercase:      str   			=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
         _lowercase:      Optional[int]   			=  image_classifier(A_			,					candidate_labels=['''cat''', '''plane''', '''remote''']							)
         self.assertEqual(
             nested_simplify(A_							)			,					[
                 {'''score''': 0.5_11, '''label''': '''remote'''},
                 {'''score''': 0.4_85, '''label''': '''cat'''},
                 {'''score''': 0.0_04, '''label''': '''plane'''},
             ]			,					)

         _lowercase:      Optional[Any]   			=  image_classifier([image] * 5			,					candidate_labels=['''cat''', '''plane''', '''remote''']			,					batch_size=2							)
         self.assertEqual(
             nested_simplify(A_							)			,					[
                 [
                     {'''score''': 0.5_11, '''label''': '''remote'''},
                     {'''score''': 0.4_85, '''label''': '''cat'''},
                     {'''score''': 0.0_04, '''label''': '''plane'''},
                 ],
             ]
             * 5			,					)
