






"""simple docstring"""



from dataclasses import dataclass, field
from typing import Tuple

from ..utils import cached_property, is_torch_available, is_torch_tpu_available, logging, requires_backends
from .benchmark_args_utils import BenchmarkArguments


if is_torch_available():
						import torch

if is_torch_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm


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





@dataclass
class 					_UpperCAmelCase       ( _A							):
					SCREAMING_SNAKE_CASE_		:				Any							    =   [
					    "no_inference",
					    "no_cuda",
					    "no_tpu",
					    "no_speed",
					    "no_memory",
					    "no_env_print",
					    "no_multi_process",
					]




					def __init__(				self     :						str    ,						**A     :						List[Any]   )  ->  Union[str, Any]:
							for deprecated_arg in self.deprecated_args:
									if deprecated_arg in kwargs:
											lowercase_ : List[str]							       =   deprecated_arg[3:]
											setattr(self    ,						A    ,						not kwargs.pop(A   )   )
											logger.warning(
											    F'''{deprecated_arg} is depreciated. Please use --no_{positive_arg} or'''
											    F''' {positive_arg}={kwargs[positive_arg]}'''   )

							lowercase_ : Optional[Any]							       =   kwargs.pop('''torchscript'''    ,						self.torchscript   )
							lowercase_ : Tuple							       =   kwargs.pop('''torch_xla_tpu_print_metrics'''    ,						self.torch_xla_tpu_print_metrics   )
							lowercase_ : Any							       =   kwargs.pop('''fp16_opt_level'''    ,						self.fpaa_opt_level   )
							super().__init__(**A   )

					SCREAMING_SNAKE_CASE_		:				bool							    =   field(default=_A   ,						metadata={"help": "Trace the models using torchscript"}							)
					SCREAMING_SNAKE_CASE_		:				bool							    =   field(default=_A   ,						metadata={"help": "Print Xla/PyTorch tpu metrics"}							)
					SCREAMING_SNAKE_CASE_		:				str							    =   field(
					    default="O1"   ,						metadata={
					        "help": (
					            "For fp16: Apex AMP optimization level selected in ['O0', 'O1', 'O2', and 'O3']. "
					            "See details at https://nvidia.github.io/apex/amp.html"
					        )
					    }   ,						)




					@cached_property
					def   A  (				self     :						Optional[Any]   )  ->  Tuple["torch.device", int]:
							requires_backends(self    ,						['''torch''']   )
							logger.info('''PyTorch: setting up devices'''   )
							if not self.cuda:
									lowercase_ : List[Any]							       =   torch.device('''cpu'''   )
									lowercase_ : Optional[int]							       =   0
							elif is_torch_tpu_available():
									lowercase_ : Optional[Any]							       =   xm.xla_device()
									lowercase_ : Union[str, Any]							       =   0
							else:
									lowercase_ : Tuple							       =   torch.device('''cuda''' if torch.cuda.is_available() else '''cpu'''   )
									lowercase_ : str							       =   torch.cuda.device_count()
							return device, n_gpu




					@property
					def   A  (				self     :						Any   )  ->  str:
							return is_torch_tpu_available() and self.tpu




					@property
					def   A  (				self     :						str   )  ->  int:
							requires_backends(self    ,						['''torch''']   )
							# TODO(PVP): currently only single GPU is supported
							return torch.cuda.current_device()




					@property
					def   A  (				self     :						int   )  ->  "torch.device":
							requires_backends(self    ,						['''torch''']   )
							return self._setup_devices[0]




					@property
					def   A  (				self     :						List[str]   )  ->  str:
							requires_backends(self    ,						['''torch''']   )
							return self._setup_devices[1]






					@property
					def   A  (				self     :						List[str]   )  ->  Optional[Any]:
							return self.n_gpu > 0








'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCAmelCase									=   {
    '''configuration_bigbird_pegasus''': [
        '''BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''BigBirdPegasusConfig''',
        '''BigBirdPegasusOnnxConfig''',
    ],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase									=   [
							    '''BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''BigBirdPegasusForCausalLM''',
							    '''BigBirdPegasusForConditionalGeneration''',
							    '''BigBirdPegasusForQuestionAnswering''',
							    '''BigBirdPegasusForSequenceClassification''',
							    '''BigBirdPegasusModel''',
							    '''BigBirdPegasusPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_bigbird_pegasus import (
							    BIGBIRD_PEGASUS_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    BigBirdPegasusConfig,
							    BigBirdPegasusOnnxConfig,
							)

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_bigbird_pegasus import (
														    BIGBIRD_PEGASUS_PRETRAINED_MODEL_ARCHIVE_LIST,
														    BigBirdPegasusForCausalLM,
														    BigBirdPegasusForConditionalGeneration,
														    BigBirdPegasusForQuestionAnswering,
														    BigBirdPegasusForSequenceClassification,
														    BigBirdPegasusModel,
														    BigBirdPegasusPreTrainedModel,
														)


else:
							import sys

							__lowerCAmelCase									=   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




