





"""simple docstring"""





import time
import warnings
from abc import ABC
from copy import deepcopy
from typing import Optional

import torch

from ..utils import add_start_docstrings, logging


lowerCAmelCase__   	=	logging.get_logger(__name__)


lowerCAmelCase__   	=	r'''
    Args:
        input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):
            Indices of input sequence tokens in the vocabulary.

            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
            [`PreTrainedTokenizer.__call__`] for details.

            [What are input IDs?](../glossary#input-ids)
        scores (`torch.FloatTensor` of shape `(batch_size, config.vocab_size)`):
            Prediction scores of a language modeling head. These can be scores for each vocabulary token before SoftMax
            or scores for each vocabulary token after SoftMax.
        kwargs (`Dict[str, Any]`, *optional*):
            Additional stopping criteria specific kwargs.

    Return:
        `bool`. `False` indicates we should continue, `True` indicates we should stop.

'''





class 				_lowerCamelCase					(				snake_case__       ):


						@add_start_docstrings(_A						)
						def __call__(self      ,							__a      ,							__a      ,							**__a						)       ->      List[Any]:
								raise NotImplementedError("StoppingCriteria needs to be subclassed"						)





class 				_lowerCamelCase					(				snake_case__       ):


						def __init__(self      ,							__a      ,							__a = None						)       ->      int:
								UpperCamelCase      =		max_length
								UpperCamelCase      =		max_position_embeddings




						@add_start_docstrings(_A						)
						def __call__(self      ,							__a      ,							__a      ,							**__a						)       ->      Dict:
								UpperCamelCase      =		input_ids.shape[-1]
								UpperCamelCase      =		cur_len >= self.max_length
								if self.max_position_embeddings is not None and not is_done and cur_len >= self.max_position_embeddings:
										logger.warning_once(
										    "This is a friendly reminder - the current text generation call will exceed the model's predefined "
										    F"maximum length ({self.max_position_embeddings}). Depending on the model, you may observe "
										    "exceptions, performance degradation, or nothing at all."						)
								return is_done





class 				_lowerCamelCase					(				snake_case__       ):


						def __init__(self      ,							__a      ,							__a						)       ->      Tuple:
								warnings.warn(
								    "The class `MaxNewTokensCriteria` is deprecated. "
								    F"Please use `MaxLengthCriteria(max_length={start_length + max_new_tokens})` "
								    "with `max_length = start_length + max_new_tokens` instead."      ,							_A      ,							)
								UpperCamelCase      =		start_length
								UpperCamelCase      =		max_new_tokens
								UpperCamelCase      =		start_length + max_new_tokens




						@add_start_docstrings(_A						)
						def __call__(self      ,							__a      ,							__a      ,							**__a						)       ->      List[str]:
								return input_ids.shape[-1] >= self.max_length





class 				_lowerCamelCase					(				snake_case__       ):


						def __init__(self      ,							__a      ,							__a = None						)       ->      List[str]:
								UpperCamelCase      =		max_time
								UpperCamelCase      =		time.time() if initial_timestamp is None else initial_timestamp




						@add_start_docstrings(_A						)
						def __call__(self      ,							__a      ,							__a      ,							**__a						)       ->      List[str]:
								return time.time() - self.initial_timestamp > self.max_time





class 				_lowerCamelCase					(				snake_case__       ):


						@add_start_docstrings(_A						)
						def __call__(self      ,							__a      ,							__a      ,							**__a						)       ->      Tuple:
								return any(criteria(_A      ,							_A						) for criteria in self						)




						@property
						def 			snake_case_      (self						)       ->      Any:



								for stopping_criterium in self:
										if isinstance(_A      ,							_A						):
												return stopping_criterium.max_length
										elif isinstance(_A      ,							_A						):
												return stopping_criterium.max_length
								return None



def 					a__    (    _SCREAMING_SNAKE_CASE     ,		_SCREAMING_SNAKE_CASE			):




		"""simple docstring"""


		UpperCamelCase      =		stopping_criteria.max_length
		UpperCamelCase      =		deepcopy(SCREAMING_SNAKE_CASE_			)
		if stopping_max_length is not None and stopping_max_length != max_length:
				warnings.warn("You set different `max_length` for stopping criteria and `max_length` parameter"     ,		SCREAMING_SNAKE_CASE_			)
		elif stopping_max_length is None:
				new_stopping_criteria.append(MaxLengthCriteria(max_length=SCREAMING_SNAKE_CASE_			)			)
		return new_stopping_criteria












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


UpperCamelCase__    			=			logging.get_logger(__name__)
@dataclass
class 			a__    (					snake_case__      ):
						_a							:    List[str]					=    [
						    """no_inference""",
						    """no_cuda""",
						    """no_tpu""",
						    """no_speed""",
						    """no_memory""",
						    """no_env_print""",
						    """no_multi_process""",
						]






						def __init__(   self		,			**_A			):




											"""simple docstring"""



											for deprecated_arg in self.deprecated_args:
																if deprecated_arg in kwargs:
																					__lowerCAmelCase				   =       deprecated_arg[3:]
																					__lowerCAmelCase				   =       not kwargs.pop(_A			)
																					logger.warning(
																					    f"""{deprecated_arg} is depreciated. Please use --no-{positive_arg} or"""
																					    f""" {positive_arg}={kwargs[positive_arg]}"""			)
											__lowerCAmelCase				   =       kwargs.pop("tpu_name"		,			self.tpu_name			)
											__lowerCAmelCase				   =       kwargs.pop("device_idx"		,			self.device_idx			)
											__lowerCAmelCase				   =       kwargs.pop("eager_mode"		,			self.eager_mode			)
											__lowerCAmelCase				   =       kwargs.pop("use_xla"		,			self.use_xla			)
											super().__init__(**_A			)

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






						@cached_property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											requires_backends(self		,			["tf"]			)
											__lowerCAmelCase				   =       None
											if self.tpu:
																try:
																					if self.tpu_name:
																										__lowerCAmelCase				   =       tf.distribute.cluster_resolver.TPUClusterResolver(self.tpu_name			)
																					else:
																										__lowerCAmelCase				   =       tf.distribute.cluster_resolver.TPUClusterResolver()
																except ValueError:
																					__lowerCAmelCase				   =       None
											return tpu






						@cached_property
						def 				__SCREAMING_SNAKE_CASE(   self			):




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

																__lowerCAmelCase				   =       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"			)
																					__lowerCAmelCase				   =       tf.distribute.OneDeviceStrategy(device=f"""/gpu:{self.device_idx}"""			)
																else:
																					tf.config.set_visible_devices([]		,			"GPU"			)  # disable GPU
																					__lowerCAmelCase				   =       tf.distribute.OneDeviceStrategy(device=f"""/cpu:{self.device_idx}"""			)

											return strategy






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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






						@property
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return self.n_gpu > 0




