






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


__A		:       List[str]  				=		{
    '''configuration_mobilenet_v2''': [
        '''MOBILENET_V2_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''MobileNetV2Config''',
        '''MobileNetV2OnnxConfig''',
    ],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__A		:       Dict  				=		['''MobileNetV2FeatureExtractor''']
						__A		:       Optional[int]  				=		['''MobileNetV2ImageProcessor''']


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__A		:       Optional[Any]  				=		[
						    '''MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''MobileNetV2ForImageClassification''',
						    '''MobileNetV2ForSemanticSegmentation''',
						    '''MobileNetV2Model''',
						    '''MobileNetV2PreTrainedModel''',
						    '''load_tf_weights_in_mobilenet_v2''',
						]


if TYPE_CHECKING:
						from .configuration_mobilenet_va import (
						    MOBILENET_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    MobileNetVaConfig,
						    MobileNetVaOnnxConfig,
						)

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_mobilenet_va import MobileNetVaFeatureExtractor
												from .image_processing_mobilenet_va import MobileNetVaImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mobilenet_va import (
												    MOBILENET_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
												    MobileNetVaForImageClassification,
												    MobileNetVaForSemanticSegmentation,
												    MobileNetVaModel,
												    MobileNetVaPreTrainedModel,
												    load_tf_weights_in_mobilenet_va,
												)


else:
						import sys

						__A		:       List[Any]  				=		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



