




'''simple docstring'''






import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
				import torch_xla.core.xla_model as xm  # noqa: F401

				_lowerCAmelCase				     = True
except ImportError:
				_lowerCAmelCase				     = False


# Cache this result has it's a C FFI call which can be pretty time-consuming
_lowerCAmelCase				     = torch.distributed.is_available()

def       __lowerCAmelCase (   snake_case__						):
			# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
			__UpperCamelCase				:      str									=       importlib.util.find_spec(snake_case__						) is not None
			if package_exists:
						try:
									__UpperCamelCase				:      int									=       importlib.metadata.metadata(snake_case__						)
									return True
						except importlib.metadata.PackageNotFoundError:
									return False

def       __lowerCAmelCase (   ):
			return _torch_distributed_available

def       __lowerCAmelCase (   ):
			try:
						pass
			except ImportError:
						print(
						    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
						    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
						    " Bindings for PyTorch*."						)
			return (
			    importlib.util.find_spec("torch_ccl"						) is not None
			    or importlib.util.find_spec("oneccl_bindings_for_pytorch"						) is not None
			)

def       __lowerCAmelCase (   ):
			return importlib.metadata.version("oneccl_bind_pt"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("transformer_engine"						)

@lru_cache
def       __lowerCAmelCase (   snake_case__=True						):
			# Due to bugs on the amp series GPUs, we disable torch-xla on them
			if torch.cuda.is_available():
						return False
			if _tpu_available and check_device:
						try:
									# Will raise a RuntimeError if no XLA configuration is found
									__UpperCamelCase				:      List[Any]									=       xm.xla_device()
									return True
						except RuntimeError:
									return False
			return _tpu_available

def       __lowerCAmelCase (   ):
			return _is_package_available("deepspeed"						)

def       __lowerCAmelCase (   snake_case__=False						):
			if is_tpu_available():
						return not ignore_tpu
			if torch.cuda.is_available():
						return torch.cuda.is_bfaa_supported()
			if is_npu_available():
						return False
			return True

def       __lowerCAmelCase (   ):
			__UpperCamelCase				:      List[Any]									=       _is_package_available("bitsandbytes"						)
			if package_exists:
						__UpperCamelCase				:      Any									=       version.parse(importlib.metadata.version("bitsandbytes"						)						)
						return compare_versions(snake_case__ ,				">=" ,				"0.39.0"						)
			return False

def       __lowerCAmelCase (   ):
			__UpperCamelCase				:      Tuple									=       _is_package_available("bitsandbytes"						)
			if package_exists:
						__UpperCamelCase				:      Any									=       version.parse(importlib.metadata.version("bitsandbytes"						)						)
						return compare_versions(snake_case__ ,				">=" ,				"0.37.2"						)
			return False

def       __lowerCAmelCase (   ):
			return _is_package_available("bitsandbytes"						)

def       __lowerCAmelCase (   ):
			if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM" ,				"False"						)						) == 1:
						__UpperCamelCase				:      Optional[int]									=       importlib.util.find_spec("megatron"						) is not None
						if package_exists:
									try:
												__UpperCamelCase				:      Dict									=       parse(importlib.metadata.version("megatron-lm"						)						)
												return compare_versions(snake_case__ ,				">=" ,				"2.2.0"						)
									except Exception as e:
												warnings.warn(F"Parse Megatron version failed. Exception:{e}"						)
												return False

def       __lowerCAmelCase (   ):
			return _is_package_available("safetensors"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("transformers"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("datasets"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("aim"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("tensorboard"						) or _is_package_available("tensorboardX"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("wandb"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("comet_ml"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("boto3"						)

def       __lowerCAmelCase (   ):
			if _is_package_available("rich"						):
						if "ACCELERATE_DISABLE_RICH" in os.environ:
									warnings.warn(
									    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."						)
									return not parse_flag_from_env("ACCELERATE_DISABLE_RICH" ,				snake_case__						)
						return parse_flag_from_env("ACCELERATE_ENABLE_RICH" ,				snake_case__						)
			return False

def       __lowerCAmelCase (   ):
			return _is_package_available("sagemaker"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("tqdm"						)

def       __lowerCAmelCase (   ):
			return _is_package_available("mlflow"						)

def       __lowerCAmelCase (   ):
			return is_torch_version(">=" ,				"1.12"						) and torch.backends.mps.is_available() and torch.backends.mps.is_built()

def       __lowerCAmelCase (   ):
			def get_major_and_minor_from_version(snake_case__						):
						return str(version.parse(snake_case__						).major						) + "." + str(version.parse(snake_case__						).minor						)

			__UpperCamelCase				:      Union[str, Any]									=       importlib.metadata.version("torch"						)
			if importlib.util.find_spec("intel_extension_for_pytorch"						) is None:
						return False
			__UpperCamelCase				:      int									=       "N/A"
			try:
						__UpperCamelCase				:      Optional[Any]									=       importlib.metadata.version("intel_extension_for_pytorch"						)
			except importlib.metadata.PackageNotFoundError:
						return False
			__UpperCamelCase				:      int									=       get_major_and_minor_from_version(_torch_version						)
			__UpperCamelCase				:      str									=       get_major_and_minor_from_version(_ipex_version						)
			if torch_major_and_minor != ipex_major_and_minor:
						warnings.warn(
						    F"Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"
						    F" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."						)
						return False
			return True

@lru_cache
def       __lowerCAmelCase (   snake_case__=False						):
			if importlib.util.find_spec("torch"						) is None or importlib.util.find_spec("torch_npu"						) is None:
						return False

			import torch
			import torch_npu  # noqa: F401

			if check_device:
						try:
									# Will raise a RuntimeError if no NPU is found
									__UpperCamelCase				:      List[str]									=       torch.npu.device_count()
									return torch.npu.is_available()
						except RuntimeError:
									return False
			return hasattr(snake_case__ ,				"npu"						) and torch.npu.is_available()




@lru_cache
def       __lowerCAmelCase (   snake_case__=False						):
			if not parse_flag_from_env("ACCELERATE_USE_XPU" ,				default=snake_case__						):
						return False
			if is_ipex_available():
						import torch

						if is_torch_version("<=" ,				"1.12"						):
									return False
			else:
						return False

			import intel_extension_for_pytorch  # noqa: F401

			if check_device:
						try:
									# Will raise a RuntimeError if no XPU  is found
									__UpperCamelCase				:      Optional[Any]									=       torch.xpu.device_count()
									return torch.xpu.is_available()
						except RuntimeError:
									return False
			return hasattr(snake_case__ ,				"xpu"						) and torch.xpu.is_available()









'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowerCAmelCase				     = {'''configuration_visual_bert''': ['''VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''VisualBertConfig''']}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowerCAmelCase				     = [
				    '''VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
				    '''VisualBertForMultipleChoice''',
				    '''VisualBertForPreTraining''',
				    '''VisualBertForQuestionAnswering''',
				    '''VisualBertForRegionToPhraseAlignment''',
				    '''VisualBertForVisualReasoning''',
				    '''VisualBertLayer''',
				    '''VisualBertModel''',
				    '''VisualBertPreTrainedModel''',
				]


if TYPE_CHECKING:
				from .configuration_visual_bert import VISUAL_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, VisualBertConfig

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_visual_bert import (
								    VISUAL_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    VisualBertForMultipleChoice,
								    VisualBertForPreTraining,
								    VisualBertForQuestionAnswering,
								    VisualBertForRegionToPhraseAlignment,
								    VisualBertForVisualReasoning,
								    VisualBertLayer,
								    VisualBertModel,
								    VisualBertPreTrainedModel,
								)


else:
				import sys

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



