code: 
  
  
  
  '''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
  
   a__						:			Optional[Any]										=			True
  except ImportError:
   a__						:			Optional[int]										=			False
  
  
  # Cache this result has it's a C FFI call which can be pretty time-consuming
  a__						:			int										=			torch.distributed.is_available()
  
  
  
  
  
  
  
  def _lowercase   (  __A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  importlib.util.find_spec(__A       ) is not None
   if package_exists:
    try:
     __UpperCamelCase				      =  importlib.metadata.metadata(__A       )
     return True
    except importlib.metadata.PackageNotFoundError:
     return False
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _torch_distributed_available
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''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 _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return importlib.metadata.version("""oneccl_bind_pt"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""transformer_engine"""       )
  
  
  
  
  
  
  
  @lru_cache
  def _lowercase   (  __A=True       ):
  
  
  
   '''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
     __UpperCamelCase				      =  xm.xla_device()
     return True
    except RuntimeError:
     return False
   return _tpu_available
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""deepspeed"""       )
  
  
  
  
  
  
  
  def _lowercase   (  __A=False       ):
  
  
  
   '''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 _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  _is_package_available("""bitsandbytes"""       )
   if package_exists:
    __UpperCamelCase				      =  version.parse(importlib.metadata.version("""bitsandbytes"""       )       )
    return compare_versions(__A							,""">="""							,"""0.39.0"""       )
   return False
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  _is_package_available("""bitsandbytes"""       )
   if package_exists:
    __UpperCamelCase				      =  version.parse(importlib.metadata.version("""bitsandbytes"""       )       )
    return compare_versions(__A							,""">="""							,"""0.37.2"""       )
   return False
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""bitsandbytes"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   if strtobool(os.environ.get("""ACCELERATE_USE_MEGATRON_LM"""							,"""False"""       )       ) == 1:
    __UpperCamelCase				      =  importlib.util.find_spec("""megatron"""       ) is not None
    if package_exists:
     try:
      __UpperCamelCase				      =  parse(importlib.metadata.version("""megatron-lm"""       )       )
      return compare_versions(__A							,""">="""							,"""2.2.0"""       )
     except Exception as e:
      warnings.warn(f"Parse Megatron version failed. Exception:{e}"       )
      return False
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""safetensors"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""transformers"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""datasets"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""aim"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""tensorboard"""       ) or _is_package_available("""tensorboardX"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""wandb"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""comet_ml"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""boto3"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''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"""							,__A       )
    return parse_flag_from_env("""ACCELERATE_ENABLE_RICH"""							,__A       )
   return False
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""sagemaker"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""tqdm"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return _is_package_available("""mlflow"""       )
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   return is_torch_version(""">="""							,"""1.12"""       ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()
  
  
  
  
  
  
  
  def _lowercase   (  ):
  
  
  
   '''simple docstring'''
  
  
  
   def get_major_and_minor_from_version(__A       ):
    return str(version.parse(__A       ).major       ) + "." + str(version.parse(__A       ).minor       )
  
   __UpperCamelCase				      =  importlib.metadata.version("""torch"""       )
   if importlib.util.find_spec("""intel_extension_for_pytorch"""       ) is None:
    return False
   __UpperCamelCase				      =  """N/A"""
   try:
    __UpperCamelCase				      =  importlib.metadata.version("""intel_extension_for_pytorch"""       )
   except importlib.metadata.PackageNotFoundError:
    return False
   __UpperCamelCase				      =  get_major_and_minor_from_version(_torch_version       )
   __UpperCamelCase				      =  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 _lowercase   (  __A=False       ):
  
  
  
   '''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
     __UpperCamelCase				      =  torch.npu.device_count()
     return torch.npu.is_available()
    except RuntimeError:
     return False
   return hasattr(__A							,"""npu"""       ) and torch.npu.is_available()
  
  
  
  
  
  
  
  @lru_cache
  def _lowercase   (  __A=False       ):
  
  
  
   '''simple docstring'''
  
  
  
   if not parse_flag_from_env("""ACCELERATE_USE_XPU"""							,default=__A       ):
    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				      =  torch.xpu.device_count()
     return torch.xpu.is_available()
    except RuntimeError:
     return False
   return hasattr(__A							,"""xpu"""       ) and torch.xpu.is_available()
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  import argparse
  
  from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  
  
  
  
  
  
  def _lowercase   (  __A							,__A							,__A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  TaConfig.from_json_file(__A       )
   print(f"Building PyTorch model from configuration: {config}"       )
   __UpperCamelCase				      =  TaForConditionalGeneration(__A       )
  
   # Load weights from tf checkpoint
   load_tf_weights_in_ta(__A							,__A							,__A       )
  
   # Save pytorch-model
   print(f"Save PyTorch model to {pytorch_dump_path}"       )
   model.save_pretrained(__A       )
  
  
  if __name__ == "__main__":
   a__						:			int										=			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
   )
   parser.add_argument(
       '--config_file',
       default=None,
       type=str,
       required=True,
       help=(
           'The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture.'
       ),
   )
   parser.add_argument(
       '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
   )
   a__						:			Optional[Any]										=			parser.parse_args()
   convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
  
  
  
  
  
  