
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  _snake_case			(						snake_case__				:       Union[str, Any]       ):
	A  				=				importlib.util.find_spec(snake_case__       ) is not None
	if package_exists:
		try:
			A  				=				importlib.metadata.metadata(snake_case__       )
			return True
		except importlib.metadata.PackageNotFoundError:
			return False






def  _snake_case			(						):
	return _torch_distributed_available






def  _snake_case			(						):

	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  _snake_case			(						):
	return importlib.metadata.version('oneccl_bind_pt'       )






def  _snake_case			(						):
	return _is_package_available('transformer_engine'       )






@lru_cache
def  _snake_case			(						snake_case__				:       List[str]=True       ):

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






def  _snake_case			(						):
	return _is_package_available('deepspeed'       )






def  _snake_case			(						snake_case__				:       Any=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  _snake_case			(						):
	A  				=				_is_package_available('bitsandbytes'       )
	if package_exists:
		A  				=				version.parse(importlib.metadata.version('bitsandbytes'       )       )
		return compare_versions(snake_case__		, '>='		, '0.39.0'       )
	return False






def  _snake_case			(						):
	A  				=				_is_package_available('bitsandbytes'       )
	if package_exists:
		A  				=				version.parse(importlib.metadata.version('bitsandbytes'       )       )
		return compare_versions(snake_case__		, '>='		, '0.37.2'       )
	return False






def  _snake_case			(						):
	return _is_package_available('bitsandbytes'       )






def  _snake_case			(						):

	if strtobool(os.environ.get('ACCELERATE_USE_MEGATRON_LM'		, 'False'       )       ) == 1:
		A  				=				importlib.util.find_spec('megatron'       ) is not None
		if package_exists:
			try:
				A  				=				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  _snake_case			(						):
	return _is_package_available('safetensors'       )






def  _snake_case			(						):
	return _is_package_available('transformers'       )






def  _snake_case			(						):
	return _is_package_available('datasets'       )






def  _snake_case			(						):
	return _is_package_available('aim'       )






def  _snake_case			(						):
	return _is_package_available('tensorboard'       ) or _is_package_available('tensorboardX'       )






def  _snake_case			(						):
	return _is_package_available('wandb'       )






def  _snake_case			(						):
	return _is_package_available('comet_ml'       )






def  _snake_case			(						):
	return _is_package_available('boto3'       )






def  _snake_case			(						):

	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  _snake_case			(						):
	return _is_package_available('sagemaker'       )






def  _snake_case			(						):
	return _is_package_available('tqdm'       )






def  _snake_case			(						):
	return _is_package_available('mlflow'       )






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






def  _snake_case			(						):

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

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

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


_lowercase											=			logging.get_logger(__name__)

_lowercase											=			{
    '''microsoft/prophetnet-large-uncased''': (
        '''https://huggingface.co/microsoft/prophetnet-large-uncased/resolve/main/config.json'''
    ),
}







class 			lowerCAmelCase_			( _lowercase      ):



						'''simple docstring'''


						_lowerCamelCase:      int =      '''prophetnet'''
						_lowerCamelCase:      Optional[Any] =      ['''past_key_values''']
						_lowerCamelCase:      Dict =      {
						    '''num_attention_heads''': '''num_encoder_attention_heads''',
						}


						def __init__(	self       : Tuple					,A_       : Optional[float] = 0.1					,A_       : Optional[Union[str, Callable]] = "gelu"					,A_       : Optional[int] = 3_0522					,A_       : Optional[int] = 1024					,A_       : Optional[int] = 4096					,A_       : Optional[int] = 12					,A_       : Optional[int] = 16					,A_       : Optional[int] = 4096					,A_       : Optional[int] = 12					,A_       : Optional[int] = 16					,A_       : Optional[float] = 0.1					,A_       : Optional[float] = 0.1					,A_       : Optional[int] = 512					,A_       : Optional[float] = 0.02					,A_       : Optional[bool] = True					,A_       : Optional[bool] = True					,A_       : Optional[int] = 0					,A_       : Optional[int] = 2					,A_       : Optional[int] = 32					,A_       : Optional[int] = 128					,A_       : Optional[bool] = False					,A_       : Optional[float] = 0.0					,A_       : Optional[bool] = True					,A_       : Optional[int] = 0					,A_       : Optional[int] = 1					,A_       : Optional[int] = 2					,**A_       : Tuple					,)       ->				Any:
							A  				=				vocab_size
							A  				=				hidden_size
							A  				=				encoder_ffn_dim
							A  				=				num_encoder_layers
							A  				=				num_encoder_attention_heads
							A  				=				decoder_ffn_dim
							A  				=				num_decoder_layers
							A  				=				num_decoder_attention_heads
							A  				=				max_position_embeddings
							A  				=				init_std  # Normal(0, this parameter)
							A  				=				activation_function

							# parameters for prophetnet
							A  				=				ngram
							A  				=				num_buckets
							A  				=				relative_max_distance
							A  				=				disable_ngram_loss
							A  				=				eps

							# 3 Types of Dropout
							A  				=				attention_dropout
							A  				=				activation_dropout
							A  				=				dropout

							A  				=				use_cache

							super().__init__(
							    pad_token_id=A_					,bos_token_id=A_					,eos_token_id=A_					,is_encoder_decoder=A_					,add_cross_attention=A_					,decoder_start_token_id=A_					,**A_					,)


						@property
						def   _SCREAMING_SNAKE_CASE (	self       : List[Any] )       ->				int:
							return self.num_encoder_layers + self.num_decoder_layers




						@num_hidden_layers.setter
						def   _SCREAMING_SNAKE_CASE (	self       : int					,A_       : Any )       ->				int:
							raise NotImplementedError(
							    'This model does not support the setting of `num_hidden_layers`. Please set `num_encoder_layers` and'
							    ' `num_decoder_layers`.' )