


"""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 collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


__lowercase:		int    						=  logging.get_logger(__name__)

__lowercase:		Tuple    						=  {
    "facebook/mbart-large-cc25": "https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json",
    # See all MBART models at https://huggingface.co/models?filter=mbart
}







class 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__):
 _lowerCamelCase			:       List[str]            =       'mbart'
 _lowerCamelCase			:       str            =       ['past_key_values']
 _lowerCamelCase			:       List[str]            =       {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}

 def __init__(			self			:						Tuple,       a_			:						Union[str, Any]=5_0265,       a_			:						Union[str, Any]=1024,       a_			:						Optional[int]=12,       a_			:						str=4096,       a_			:						Optional[Any]=16,       a_			:						str=12,       a_			:						Union[str, Any]=4096,       a_			:						List[Any]=16,       a_			:						Optional[Any]=0.0,       a_			:						int=0.0,       a_			:						Any=True,       a_			:						Optional[Any]=True,       a_			:						Any="gelu",       a_			:						int=1024,       a_			:						Any=0.1,       a_			:						Optional[int]=0.0,       a_			:						Tuple=0.0,       a_			:						Optional[Any]=0.02,       a_			:						Any=0.0,       a_			:						Optional[Any]=False,       a_			:						Any=1,       a_			:						Optional[Any]=0,       a_			:						List[str]=2,       a_			:						Any=2,       **a_			:						int,       ):





    """simple docstring"""



    UpperCamelCase__			    =    vocab_size
    UpperCamelCase__			    =    max_position_embeddings
    UpperCamelCase__			    =    d_model
    UpperCamelCase__			    =    encoder_ffn_dim
    UpperCamelCase__			    =    encoder_layers
    UpperCamelCase__			    =    encoder_attention_heads
    UpperCamelCase__			    =    decoder_ffn_dim
    UpperCamelCase__			    =    decoder_layers
    UpperCamelCase__			    =    decoder_attention_heads
    UpperCamelCase__			    =    dropout
    UpperCamelCase__			    =    attention_dropout
    UpperCamelCase__			    =    activation_dropout
    UpperCamelCase__			    =    activation_function
    UpperCamelCase__			    =    init_std
    UpperCamelCase__			    =    encoder_layerdrop
    UpperCamelCase__			    =    decoder_layerdrop
    UpperCamelCase__			    =    classifier_dropout
    UpperCamelCase__			    =    use_cache
    UpperCamelCase__			    =    encoder_layers
    UpperCamelCase__			    =    scale_embedding  # scale factor will be sqrt(d_model) if True
    super().__init__(
        pad_token_id=a_,       bos_token_id=a_,       eos_token_id=a_,       is_encoder_decoder=a_,       forced_eos_token_id=a_,       **a_,       )







class 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__):

 @property
 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    OrderedDict(
           [
               ("input_ids", {0: "batch", 1: "encoder_sequence"}),
               ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
           ]       )

       if self.use_past:
          UpperCamelCase__			    =    {0: "batch"}
          UpperCamelCase__			    =    {0: "batch", 1: "past_decoder_sequence + sequence"}
       else:
          UpperCamelCase__			    =    {0: "batch", 1: "decoder_sequence"}
          UpperCamelCase__			    =    {0: "batch", 1: "decoder_sequence"}

       if self.use_past:
          self.fill_with_past_key_values_(a_,       direction="inputs"       )
    elif self.task == "causal-lm":
       # TODO: figure this case out.
       UpperCamelCase__			    =    OrderedDict(
           [
               ("input_ids", {0: "batch", 1: "encoder_sequence"}),
               ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
           ]       )
       if self.use_past:
          UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
          for i in range(a_       ):
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
    else:
       UpperCamelCase__			    =    OrderedDict(
           [
               ("input_ids", {0: "batch", 1: "encoder_sequence"}),
               ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
               ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
               ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
           ]       )

    return common_inputs

 @property
 def 		lowercase_    (			self			:						Any       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    super().outputs
    else:
       UpperCamelCase__			    =    super(a_,       self       ).outputs
       if self.use_past:
          UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
          for i in range(a_       ):
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
             UpperCamelCase__			    =    {0: "batch", 2: "past_sequence + sequence"}
    return common_outputs

 def 		lowercase_    (			self			:						str,       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        a_,       a_,       a_,       a_,       a_       )

    # Generate decoder inputs
    UpperCamelCase__			    =    seq_length if not self.use_past else 1
    UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        a_,       a_,       a_,       a_,       a_       )
    UpperCamelCase__			    =    {f'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
    UpperCamelCase__			    =    dict(**a_,       **a_       )

    if self.use_past:
       if not is_torch_available():
          raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."       )
       else:
          import torch
       UpperCamelCase__    ,		UpperCamelCase__			    =    common_inputs["input_ids"].shape
       UpperCamelCase__			    =    common_inputs["decoder_input_ids"].shape[1]
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_attention_heads
       UpperCamelCase__			    =    (
           batch,
           num_encoder_attention_heads,
           encoder_seq_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )
       UpperCamelCase__			    =    decoder_seq_length + 3
       UpperCamelCase__			    =    (
           batch,
           num_decoder_attention_heads,
           decoder_past_length,
           self._config.hidden_size // num_decoder_attention_heads,
       )

       UpperCamelCase__			    =    torch.cat(
           [common_inputs["decoder_attention_mask"], torch.ones(a_,       a_       )],       dim=1       )

       UpperCamelCase__			    =    []
       # If the number of encoder and decoder layers are present in the model configuration, both are considered
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
       UpperCamelCase__			    =    min(a_,       a_       )
       UpperCamelCase__			    =    max(a_,       a_       ) - min_num_layers
       UpperCamelCase__			    =    "encoder" if num_encoder_layers > num_decoder_layers else "decoder"

       for _ in range(a_       ):
          common_inputs["past_key_values"].append(
              (
                  torch.zeros(a_       ),
                  torch.zeros(a_       ),
                  torch.zeros(a_       ),
                  torch.zeros(a_       ),
              )       )
       # TODO: test this.
       UpperCamelCase__			    =    encoder_shape if remaining_side_name == "encoder" else decoder_shape
       for _ in range(a_,       a_       ):
          common_inputs["past_key_values"].append((torch.zeros(a_       ), torch.zeros(a_       ))       )
    return common_inputs

 def 		lowercase_    (			self			:						Optional[int],       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        a_,       a_,       a_,       a_,       a_       )

    if self.use_past:
       if not is_torch_available():
          raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."       )
       else:
          import torch
       UpperCamelCase__    ,		UpperCamelCase__			    =    common_inputs["input_ids"].shape
       # Not using the same length for past_key_values
       UpperCamelCase__			    =    seqlen + 2
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_layers
       UpperCamelCase__    ,		UpperCamelCase__			    =    self.num_attention_heads
       UpperCamelCase__			    =    (
           batch,
           num_encoder_attention_heads,
           past_key_values_length,
           self._config.hidden_size // num_encoder_attention_heads,
       )

       UpperCamelCase__			    =    common_inputs["attention_mask"].dtype
       UpperCamelCase__			    =    torch.cat(
           [common_inputs["attention_mask"], torch.ones(a_,       a_,       dtype=a_       )],       dim=1       )
       UpperCamelCase__			    =    [
           (torch.zeros(a_       ), torch.zeros(a_       )) for _ in range(a_       )
       ]
    return common_inputs

 def 		lowercase_    (			self			:						List[Any],       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    UpperCamelCase__			    =    compute_effective_axis_dimension(
        a_,       fixed_dimension=OnnxConfig.default_fixed_batch,       num_token_to_add=0       )

    # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
    UpperCamelCase__			    =    tokenizer.num_special_tokens_to_add(a_       )
    UpperCamelCase__			    =    compute_effective_axis_dimension(
        a_,       fixed_dimension=OnnxConfig.default_fixed_sequence,       num_token_to_add=a_       )

    # Generate dummy inputs according to compute batch and sequence
    UpperCamelCase__			    =    [" ".join([tokenizer.unk_token]       ) * seq_length] * batch_size
    UpperCamelCase__			    =    dict(tokenizer(a_,       return_tensors=a_       )       )
    return common_inputs

 def 		lowercase_    (			self			:						Union[str, Any],       a_			:						PreTrainedTokenizer,       a_			:						int = -1,       a_			:						int = -1,       a_			:						bool = False,       a_			:						Optional[TensorType] = None,       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    self._generate_dummy_inputs_for_default_and_seqaseq_lm(
           a_,       batch_size=a_,       seq_length=a_,       is_pair=a_,       framework=a_       )

    elif self.task == "causal-lm":
       UpperCamelCase__			    =    self._generate_dummy_inputs_for_causal_lm(
           a_,       batch_size=a_,       seq_length=a_,       is_pair=a_,       framework=a_       )
    else:
       UpperCamelCase__			    =    self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
           a_,       batch_size=a_,       seq_length=a_,       is_pair=a_,       framework=a_       )

    return common_inputs

 def 		lowercase_    (			self			:						Dict,       a_			:						int,       a_			:						str,       a_			:						List[Any],       a_			:						int       ):





    """simple docstring"""



    if self.task in ["default", "seq2seq-lm"]:
       UpperCamelCase__			    =    super()._flatten_past_key_values_(a_,       a_,       a_,       a_       )
    else:
       UpperCamelCase__			    =    super(a_,       self       )._flatten_past_key_values_(
           a_,       a_,       a_,       a_       )