



'''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       :						Optional[int]						=True
except ImportError:
				_lowercase       :						Union[str, Any]						=False


# Cache this result has it's a C FFI call which can be pretty time-consuming
_lowercase       :						Union[str, Any]						=torch.distributed.is_available()


def 							__UpperCAmelCase				(				UpperCamelCase__				:Tuple			)		->						int:
				# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
				snake_case__      :   Union[str, Any]      =    importlib.util.find_spec(UpperCamelCase__			) is not None
				if package_exists:
								try:
												snake_case__      :   List[Any]      =    importlib.metadata.metadata(UpperCamelCase__			)
												return True
								except importlib.metadata.PackageNotFoundError:
												return False


def 							__UpperCAmelCase				(				)		->						bool:
				return _torch_distributed_available


def 							__UpperCAmelCase				(				)		->						Optional[Any]:
				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 							__UpperCAmelCase				(				)		->						Tuple:
				return importlib.metadata.version('''oneccl_bind_pt'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''transformer_engine'''			)


@lru_cache
def 							__UpperCAmelCase				(				UpperCamelCase__				:Union[str, Any]=True			)		->						Optional[Any]:
				# 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
												snake_case__      :   Dict      =    xm.xla_device()
												return True
								except RuntimeError:
												return False
				return _tpu_available


def 							__UpperCAmelCase				(				)		->						Optional[Any]:
				return _is_package_available('''deepspeed'''			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:Any=False			)		->						List[str]:
				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 							__UpperCAmelCase				(				)		->						Union[str, Any]:
				snake_case__      :   Tuple      =    _is_package_available('''bitsandbytes'''			)
				if package_exists:
								snake_case__      :   List[str]      =    version.parse(importlib.metadata.version('''bitsandbytes'''			)			)
								return compare_versions(UpperCamelCase__   ,				'''>='''   ,				'''0.39.0'''			)
				return False


def 							__UpperCAmelCase				(				)		->						str:
				snake_case__      :   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 							__UpperCAmelCase				(				)		->						Tuple:
				return _is_package_available('''bitsandbytes'''			)


def 							__UpperCAmelCase				(				)		->						Optional[int]:
				if strtobool(os.environ.get('''ACCELERATE_USE_MEGATRON_LM'''   ,				'''False'''			)			) == 1:
								snake_case__      :   Any      =    importlib.util.find_spec('''megatron'''			) is not None
								if package_exists:
												try:
																snake_case__      :   List[Any]      =    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 							__UpperCAmelCase				(				)		->						Optional[int]:
				return _is_package_available('''safetensors'''			)


def 							__UpperCAmelCase				(				)		->						List[Any]:
				return _is_package_available('''transformers'''			)


def 							__UpperCAmelCase				(				)		->						Tuple:
				return _is_package_available('''datasets'''			)


def 							__UpperCAmelCase				(				)		->						str:
				return _is_package_available('''aim'''			)


def 							__UpperCAmelCase				(				)		->						Any:
				return _is_package_available('''tensorboard'''			) or _is_package_available('''tensorboardX'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''wandb'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''comet_ml'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''boto3'''			)


def 							__UpperCAmelCase				(				)		->						Union[str, Any]:
				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 							__UpperCAmelCase				(				)		->						int:
				return _is_package_available('''sagemaker'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return _is_package_available('''tqdm'''			)


def 							__UpperCAmelCase				(				)		->						List[Any]:
				return _is_package_available('''mlflow'''			)


def 							__UpperCAmelCase				(				)		->						Dict:
				return is_torch_version('''>='''   ,				'''1.12'''			) and torch.backends.mps.is_available() and torch.backends.mps.is_built()


def 							__UpperCAmelCase				(				)		->						List[Any]:
				def get_major_and_minor_from_version(UpperCamelCase__				:List[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__      :   List[str]      =    '''N/A'''
				try:
								snake_case__      :   Optional[Any]      =    importlib.metadata.version('''intel_extension_for_pytorch'''			)
				except importlib.metadata.PackageNotFoundError:
								return False
				snake_case__      :   Optional[Any]      =    get_major_and_minor_from_version(_torch_version			)
				snake_case__      :   Optional[int]      =    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 							__UpperCAmelCase				(				UpperCamelCase__				:Tuple=False			)		->						Tuple:
				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__      :   Union[str, Any]      =    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 							__UpperCAmelCase				(				UpperCamelCase__				:Tuple=False			)		->						Optional[Any]:
				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__      :   Tuple      =    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





