




"""simple docstring"""







from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_tf_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_tf_available():
						import tensorflow as tf


SCREAMING_SNAKE_CASE									=						logging.get_logger(__name__)



@dataclass
class  _lowerCamelCase			(__lowerCamelCase     ):
				_snake_case     =  [
				    'no_inference',
				    'no_cuda',
				    'no_tpu',
				    'no_speed',
				    'no_memory',
				    'no_env_print',
				    'no_multi_process',
				]







				def __init__( self    :       Union[str, Any]			,					**lowerCamelCase_    :       Optional[int]						):

					"""simple docstring"""






					for deprecated_arg in self.deprecated_args:
						if deprecated_arg in kwargs:
							_lowercase :    List[str]							=							deprecated_arg[3:]
							_lowercase :    Union[str, Any]							=							not kwargs.pop(UpperCAmelCase__						)
							logger.warning(
							    F'''{deprecated_arg} is depreciated. Please use --no-{positive_arg} or'''
							    F''' {positive_arg}={kwargs[positive_arg]}'''						)
					_lowercase :    Optional[int]							=							kwargs.pop('tpu_name'			,					self.tpu_name						)
					_lowercase :    List[Any]							=							kwargs.pop('device_idx'			,					self.device_idx						)
					_lowercase :    str							=							kwargs.pop('eager_mode'			,					self.eager_mode						)
					_lowercase :    Optional[Any]							=							kwargs.pop('use_xla'			,					self.use_xla						)
					super().__init__(**UpperCAmelCase__						)

				_snake_case     =  field(
				    default=__lowerCamelCase						,							metadata={"help": "Name of TPU"}						,							)
				_snake_case     =  field(
				    default=0						,							metadata={"help": "CPU / GPU device index. Defaults to 0."}						,							)
				_snake_case     =  field(default=__lowerCamelCase						,							metadata={"help": "Benchmark models in eager model."}     )
				_snake_case     =  field(
				    default=__lowerCamelCase						,							metadata={
				        "help": "Benchmark models using XLA JIT compilation. Note that `eager_model` has to be set to `False`."
				    }						,							)







				@cached_property
				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					requires_backends(self			,					['tf']						)
					_lowercase :    List[Any]							=							None
					if self.tpu:
						try:
							if self.tpu_name:
								_lowercase :    Optional[int]							=							tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name						)
							else:
								_lowercase :    Optional[Any]							=							tf.distribute.cluster_resolver.TPUClusterResolver()
						except ValueError:
							_lowercase :    str							=							None
					return tpu







				@cached_property
				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					requires_backends(self			,					['tf']						)
					if self.is_tpu:
						tf.config.experimental_connect_to_cluster(self._setup_tpu						)
						tf.tpu.experimental.initialize_tpu_system(self._setup_tpu						)

						_lowercase :    Tuple							=							tf.distribute.TPUStrategy(self._setup_tpu						)
					else:
						# currently no multi gpu is allowed
						if self.is_gpu:
							# TODO: Currently only single GPU is supported
							tf.config.set_visible_devices(self.gpu_list[self.device_idx]			,					'GPU'						)
							_lowercase :    List[Any]							=							tf.distribute.OneDeviceStrategy(device=F'''/gpu:{self.device_idx}'''						)
						else:
							tf.config.set_visible_devices([]			,					'GPU'						)  # disable GPU
							_lowercase :    Union[str, Any]							=							tf.distribute.OneDeviceStrategy(device=F'''/cpu:{self.device_idx}'''						)

					return strategy







				@property
				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					requires_backends(self			,					['tf']						)
					return self._setup_tpu is not None







				@property
				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					requires_backends(self			,					['tf']						)
					return self._setup_strategy







				@property
				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					requires_backends(self			,					['tf']						)
					return tf.config.list_physical_devices('GPU'						)







				@property
				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					requires_backends(self			,					['tf']						)
					if self.cuda:
						return len(self.gpu_list						)
					return 0







				@property
				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					return self.n_gpu > 0




"""simple docstring"""







from typing import Any


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	if not input_list:
		return []
	_lowercase :    List[str]							=							[input_list.count(__UpperCAmelCase			) for value in input_list]
	_lowercase :    Optional[int]							=							max(__UpperCAmelCase			)  # Gets the maximum count in the input list.
	# Gets values of modes
	return sorted({input_list[i] for i, value in enumerate(__UpperCAmelCase			) if value == y}			)


if __name__ == "__main__":
						import doctest

						doctest.testmod()



