


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

					lowercase  		=			True
except ImportError:
					lowercase  		=			False


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



def 			A__		(					_UpperCAmelCase    :      str	)							->	int:

	'''simple docstring'''


	snake_case__  :						List[Any]		=      importlib.util.find_spec(_UpperCAmelCase	) is not None
	if package_exists:
		try:
			snake_case__  :						Tuple		=      importlib.metadata.metadata(_UpperCAmelCase	)
			return True
		except importlib.metadata.PackageNotFoundError:
			return False



def 			A__		(					)							->	bool:

	'''simple docstring'''


	return _torch_distributed_available



def 			A__		(					)							->	Union[str, Any]:

	'''simple docstring'''


	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 			A__		(					)							->	str:

	'''simple docstring'''


	return importlib.metadata.version("oneccl_bind_pt"	)



def 			A__		(					)							->	Optional[Any]:

	'''simple docstring'''


	return _is_package_available("transformer_engine"	)



@lru_cache
def 			A__		(					_UpperCAmelCase    :      int=True	)							->	Optional[int]:

	'''simple docstring'''


	if torch.cuda.is_available():
		return False
	if _tpu_available and check_device:
		try:
			# Will raise a RuntimeError if no XLA configuration is found
			snake_case__  :						str		=      xm.xla_device()
			return True
		except RuntimeError:
			return False
	return _tpu_available



def 			A__		(					)							->	Union[str, Any]:

	'''simple docstring'''


	return _is_package_available("deepspeed"	)



def 			A__		(					_UpperCAmelCase    :      List[Any]=False	)							->	List[str]:

	'''simple docstring'''


	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 			A__		(					)							->	Tuple:

	'''simple docstring'''


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



def 			A__		(					)							->	Dict:

	'''simple docstring'''


	snake_case__  :						List[str]		=      _is_package_available("bitsandbytes"	)
	if package_exists:
		snake_case__  :						List[Any]		=      version.parse(importlib.metadata.version("bitsandbytes"	)	)
		return compare_versions(_UpperCAmelCase				,    ">="				,    "0.37.2"	)
	return False



def 			A__		(					)							->	List[str]:

	'''simple docstring'''


	return _is_package_available("bitsandbytes"	)



def 			A__		(					)							->	List[str]:

	'''simple docstring'''


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



def 			A__		(					)							->	int:

	'''simple docstring'''


	return _is_package_available("safetensors"	)



def 			A__		(					)							->	Optional[Any]:

	'''simple docstring'''


	return _is_package_available("transformers"	)



def 			A__		(					)							->	List[str]:

	'''simple docstring'''


	return _is_package_available("datasets"	)



def 			A__		(					)							->	Tuple:

	'''simple docstring'''


	return _is_package_available("aim"	)



def 			A__		(					)							->	Any:

	'''simple docstring'''


	return _is_package_available("tensorboard"	) or _is_package_available("tensorboardX"	)



def 			A__		(					)							->	Optional[int]:

	'''simple docstring'''


	return _is_package_available("wandb"	)



def 			A__		(					)							->	Optional[int]:

	'''simple docstring'''


	return _is_package_available("comet_ml"	)



def 			A__		(					)							->	Tuple:

	'''simple docstring'''


	return _is_package_available("boto3"	)



def 			A__		(					)							->	List[Any]:

	'''simple docstring'''


	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"				,    _UpperCAmelCase	)
		return parse_flag_from_env("ACCELERATE_ENABLE_RICH"				,    _UpperCAmelCase	)
	return False



def 			A__		(					)							->	Tuple:

	'''simple docstring'''


	return _is_package_available("sagemaker"	)



def 			A__		(					)							->	List[str]:

	'''simple docstring'''


	return _is_package_available("tqdm"	)



def 			A__		(					)							->	str:

	'''simple docstring'''


	return _is_package_available("mlflow"	)



def 			A__		(					)							->	Optional[int]:

	'''simple docstring'''


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



def 			A__		(					)							->	int:

	'''simple docstring'''


	def get_major_and_minor_from_version(_UpperCAmelCase    :      Any	):
		return str(version.parse(_UpperCAmelCase	).major	) + "." + str(version.parse(_UpperCAmelCase	).minor	)

	snake_case__  :						Any		=      importlib.metadata.version("torch"	)
	if importlib.util.find_spec("intel_extension_for_pytorch"	) is None:
		return False
	snake_case__  :						Any		=      "N/A"
	try:
		snake_case__  :						Tuple		=      importlib.metadata.version("intel_extension_for_pytorch"	)
	except importlib.metadata.PackageNotFoundError:
		return False
	snake_case__  :						List[Any]		=      get_major_and_minor_from_version(_torch_version	)
	snake_case__  :						Union[str, Any]		=      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 			A__		(					_UpperCAmelCase    :      Optional[Any]=False	)							->	List[str]:

	'''simple docstring'''


	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
			snake_case__  :						str		=      torch.npu.device_count()
			return torch.npu.is_available()
		except RuntimeError:
			return False
	return hasattr(_UpperCAmelCase				,    "npu"	) and torch.npu.is_available()



@lru_cache
def 			A__		(					_UpperCAmelCase    :      str=False	)							->	Union[str, Any]:

	'''simple docstring'''


	if not parse_flag_from_env("ACCELERATE_USE_XPU"				,    default=_UpperCAmelCase	):
		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
			snake_case__  :						int		=      torch.xpu.device_count()
			return torch.xpu.is_available()
		except RuntimeError:
			return False
	return hasattr(_UpperCAmelCase				,    "xpu"	) and torch.xpu.is_available()






"""simple docstring"""




from ...configuration_utils import PretrainedConfig
from ...utils import logging


__lowerCamelCase									=	logging.get_logger(__name__)

__lowerCamelCase									=	{
    "dandelin/vilt-b32-mlm": "https://huggingface.co/dandelin/vilt-b32-mlm/blob/main/config.json"
}
class      UpperCamelCase__(      __A			):
						lowerCAmelCase__	:    str    				=		'vilt'





						def __init__(							self		,__UpperCAmelCase=3_05_22		,__UpperCAmelCase=2		,__UpperCAmelCase=2		,__UpperCAmelCase=40		,__UpperCAmelCase=7_68		,__UpperCAmelCase=12		,__UpperCAmelCase=12		,__UpperCAmelCase=30_72		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.0		,__UpperCAmelCase=0.0		,__UpperCAmelCase=0.0_2		,__UpperCAmelCase=1e-12		,__UpperCAmelCase=3_84		,__UpperCAmelCase=32		,__UpperCAmelCase=3		,__UpperCAmelCase=True		,__UpperCAmelCase=-1		,__UpperCAmelCase=False		,__UpperCAmelCase=-1		,**__UpperCAmelCase		,)       ->					Tuple:
													super().__init__(tie_word_embeddings=__UpperCAmelCase		,**__UpperCAmelCase  )

													A__						  =				vocab_size
													A__						  =				type_vocab_size
													A__						  =				modality_type_vocab_size
													A__						  =				max_position_embeddings

													A__						  =				hidden_size
													A__						  =				num_hidden_layers
													A__						  =				num_attention_heads
													A__						  =				intermediate_size
													A__						  =				hidden_act
													A__						  =				hidden_dropout_prob
													A__						  =				attention_probs_dropout_prob
													A__						  =				initializer_range
													A__						  =				layer_norm_eps

													A__						  =				image_size
													A__						  =				patch_size
													A__						  =				num_channels
													A__						  =				qkv_bias
													A__						  =				max_image_length
													A__						  =				num_images





