


'''simple docstring'''

import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
     import tensorflow as tf

     tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
     import torch

if is_datasets_available():
     from datasets import load_dataset


a_  :    Union[str, Any]      =			5e-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors





def __snake_case (				UpperCAmelCase_						:						List[Any]		):
 return PTtoTFCommand(
     args.model_name ,    args.local_dir ,    args.max_error ,    args.new_weights ,    args.no_pr ,    args.push ,    args.extra_commit_description ,    args.override_model_class ,    )







class 					snake_case   (   UpperCamelCase__      ):





  """simple docstring"""




  @staticmethod
  def   snake_case		(   UpperCamelCase					):







   """simple docstring"""
   lowerCamelCase_								=  parser.add_parser(
       "pt-to-tf"      ,  help=(
           "CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint."
           " Can also be used to validate existing weights without opening PRs, with --no-pr."
       )      ,  )
   train_parser.add_argument(
       "--model-name"      ,  type=__lowerCamelCase      ,  required=__lowerCamelCase      ,  help="The model name, including owner/organization, as seen on the hub."      ,  )
   train_parser.add_argument(
       "--local-dir"      ,  type=__lowerCamelCase      ,  default=""      ,  help="Optional local directory of the model repository. Defaults to /tmp/{model_name}"      ,  )
   train_parser.add_argument(
       "--max-error"      ,  type=__lowerCamelCase      ,  default=__lowerCamelCase      ,  help=(
           f'''Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'''
       )      ,  )
   train_parser.add_argument(
       "--new-weights"      ,  action="store_true"      ,  help="Optional flag to create new TensorFlow weights, even if they already exist."      ,  )
   train_parser.add_argument(
       "--no-pr"      ,  action="store_true"      ,  help="Optional flag to NOT open a PR with converted weights."					)
   train_parser.add_argument(
       "--push"      ,  action="store_true"      ,  help="Optional flag to push the weights directly to `main` (requires permissions)"      ,  )
   train_parser.add_argument(
       "--extra-commit-description"      ,  type=__lowerCamelCase      ,  default=""      ,  help="Optional additional commit description to use when opening a PR (e.g. to tag the owner)."      ,  )
   train_parser.add_argument(
       "--override-model-class"      ,  type=__lowerCamelCase      ,  default=__lowerCamelCase      ,  help="If you think you know better than the auto-detector, you can specify the model class here. "
       "Can be either an AutoModel class or a specific model class like BertForSequenceClassification."      ,  )
   train_parser.set_defaults(func=__lowerCamelCase					)






  @staticmethod
  def   snake_case		(   UpperCamelCase      ,  UpperCamelCase					):







   """simple docstring"""
   lowerCamelCase_								=  set(pt_outputs.keys()					)
   lowerCamelCase_								=  set(tf_outputs.keys()					)
   if pt_out_attrs != tf_out_attrs:
    raise ValueError(
        f'''The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'''
        f''' {tf_out_attrs})'''					)

   # 2. For each output attribute, computes the difference
   def _find_pt_tf_differences(UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase=""					):
    # If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
    # recursivelly, keeping the name of the attribute.
    if isinstance(__lowerCamelCase      ,  torch.Tensor					):
     lowerCamelCase_								=  np.max(np.abs(pt_out.numpy() - tf_out.numpy()					)					)
     lowerCamelCase_								=  tensor_difference
    else:
     lowerCamelCase_								=  attr_name
     for i, pt_item in enumerate(__lowerCamelCase					):
      # If it is a named attribute, we keep the name. Otherwise, just its index.
      if isinstance(__lowerCamelCase      ,  __lowerCamelCase					):
       lowerCamelCase_								=  root_name + pt_item
       lowerCamelCase_								=  tf_out[pt_item]
       lowerCamelCase_								=  pt_out[pt_item]
      else:
       lowerCamelCase_								=  root_name + f'''[{i}]'''
       lowerCamelCase_								=  tf_out[i]
      lowerCamelCase_								=  _find_pt_tf_differences(__lowerCamelCase      ,  __lowerCamelCase      ,  __lowerCamelCase      ,  __lowerCamelCase					)

    return differences

   return _find_pt_tf_differences(__lowerCamelCase      ,  __lowerCamelCase      ,  {}					)






  def __init__(   self      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase      ,  *UpperCamelCase      ,  ):







   """simple docstring"""
   lowerCamelCase_								=  logging.get_logger("transformers-cli/pt_to_tf"					)
   lowerCamelCase_								=  model_name
   lowerCamelCase_								=  local_dir if local_dir else os.path.join("/tmp"      ,  __lowerCamelCase					)
   lowerCamelCase_								=  max_error
   lowerCamelCase_								=  new_weights
   lowerCamelCase_								=  no_pr
   lowerCamelCase_								=  push
   lowerCamelCase_								=  extra_commit_description
   lowerCamelCase_								=  override_model_class






  def   snake_case		(   self      ,  UpperCamelCase      ,  UpperCamelCase      ,  UpperCamelCase					):







   """simple docstring"""


   def _get_audio_input():
    lowerCamelCase_								=  load_dataset("hf-internal-testing/librispeech_asr_dummy"      ,  "clean"      ,  split="validation"					)
    lowerCamelCase_								=  ds.sort("id"					).select(range(2					)					)[:2]["audio"]
    lowerCamelCase_								=  [x["array"] for x in speech_samples]
    return raw_samples

   lowerCamelCase_								=  type(pt_model.config					)
   if model_config_class in PROCESSOR_MAPPING:
    lowerCamelCase_								=  AutoProcessor.from_pretrained(self._local_dir					)
    if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
     lowerCamelCase_								=  processor.tokenizer.eos_token
   elif model_config_class in IMAGE_PROCESSOR_MAPPING:
    lowerCamelCase_								=  AutoImageProcessor.from_pretrained(self._local_dir					)
   elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
    lowerCamelCase_								=  AutoFeatureExtractor.from_pretrained(self._local_dir					)
   elif model_config_class in TOKENIZER_MAPPING:
    lowerCamelCase_								=  AutoTokenizer.from_pretrained(self._local_dir					)
    if processor.pad_token is None:
     lowerCamelCase_								=  processor.eos_token
   else:
    raise ValueError(f'''Unknown data processing type (model config type: {model_config_class})'''					)

   lowerCamelCase_								=  set(inspect.signature(pt_model.forward					).parameters.keys()					)
   lowerCamelCase_								=  {}
   if "input_ids" in model_forward_signature:
    processor_inputs.update(
        {
            "text": ["Hi there!", "I am a batch with more than one row and different input lengths."],
            "padding": True,
            "truncation": True,
        }					)
   if "pixel_values" in model_forward_signature:
    lowerCamelCase_								=  load_dataset("cifar10"      ,  "plain_text"      ,  split="test"					)[:2]["img"]
    processor_inputs.update({"images": sample_images}					)
   if "input_features" in model_forward_signature:
    lowerCamelCase_								=  inspect.signature(processor.feature_extractor					).parameters
    # Pad to the largest input length by default but take feature extractor default
    # padding value if it exists e.g. "max_length" and is not False or None
    if "padding" in feature_extractor_signature:
     lowerCamelCase_								=  feature_extractor_signature["padding"].default
     if default_strategy is not False and default_strategy is not None:
      lowerCamelCase_								=  default_strategy
     else:
      lowerCamelCase_								=  True
    else:
     lowerCamelCase_								=  True
    processor_inputs.update({"audio": _get_audio_input(), "padding": padding_strategy}					)
   if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
    processor_inputs.update({"audio": _get_audio_input(), "padding": True}					)
   lowerCamelCase_								=  processor(**__lowerCamelCase      ,  return_tensors="pt"					)
   lowerCamelCase_								=  processor(**__lowerCamelCase      ,  return_tensors="tf"					)

   # Extra input requirements, in addition to the input modality
   if (
       config.is_encoder_decoder
       or (hasattr(__lowerCamelCase      ,  "encoder"					) and hasattr(__lowerCamelCase      ,  "decoder"					))
       or "decoder_input_ids" in tf_dummy_inputs
   ):
    lowerCamelCase_								=  np.asarray([[1], [1]]      ,  dtype=__lowerCamelCase					) * (pt_model.config.decoder_start_token_id or 0)
    pt_input.update({"decoder_input_ids": torch.tensor(__lowerCamelCase					)}					)
    tf_input.update({"decoder_input_ids": tf.convert_to_tensor(__lowerCamelCase					)}					)

   return pt_input, tf_input







  def   snake_case		(   self					):







   """simple docstring"""


   if version.parse(huggingface_hub.__version__					) < version.parse("0.9.0"					):
    raise ImportError(
        "The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub"
        " installation."					)
   else:
    from huggingface_hub import Repository, create_commit
    from huggingface_hub._commit_api import CommitOperationAdd

   # Fetch remote data
   lowerCamelCase_								=  Repository(local_dir=self._local_dir      ,  clone_from=self._model_name					)

   # Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
   lowerCamelCase_								=  AutoConfig.from_pretrained(self._local_dir					)
   lowerCamelCase_								=  config.architectures
   if self._override_model_class is not None:
    if self._override_model_class.startswith("TF"					):
     lowerCamelCase_								=  [self._override_model_class[2:]]
    else:
     lowerCamelCase_								=  [self._override_model_class]
    try:
     lowerCamelCase_								=  getattr(import_module("transformers"					)      ,  architectures[0]					)
    except AttributeError:
     raise ValueError(f'''Model class {self._override_model_class} not found in transformers.'''					)
    try:
     lowerCamelCase_								=  getattr(import_module("transformers"					)      ,  "TF" + architectures[0]					)
    except AttributeError:
     raise ValueError(f'''TF model class TF{self._override_model_class} not found in transformers.'''					)
   elif architectures is None:  # No architecture defined -- use auto classes
    lowerCamelCase_								=  getattr(import_module("transformers"					)      ,  "AutoModel"					)
    lowerCamelCase_								=  getattr(import_module("transformers"					)      ,  "TFAutoModel"					)
    self._logger.warning("No detected architecture, using AutoModel/TFAutoModel"					)
   else:  # Architecture defined -- use it
    if len(__lowerCamelCase					) > 1:
     raise ValueError(f'''More than one architecture was found, aborting. (architectures = {architectures})'''					)
    self._logger.warning(f'''Detected architecture: {architectures[0]}'''					)
    lowerCamelCase_								=  getattr(import_module("transformers"					)      ,  architectures[0]					)
    try:
     lowerCamelCase_								=  getattr(import_module("transformers"					)      ,  "TF" + architectures[0]					)
    except AttributeError:
     raise AttributeError(f'''The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'''					)

        # Check the TF dummy inputs to see what keys we need in the forward pass
   lowerCamelCase_								=  tf_class.from_config(__lowerCamelCase					)
   lowerCamelCase_								=  tf_from_pt_model.dummy_inputs

   del tf_from_pt_model  # Try to keep only one model in memory at a time

   # Load the model and get some basic inputs
   lowerCamelCase_								=  pt_class.from_pretrained(self._local_dir					)
   pt_model.eval()

   lowerCamelCase_								=  self.get_inputs(__lowerCamelCase      ,  __lowerCamelCase      ,  __lowerCamelCase					)

   with torch.no_grad():
    lowerCamelCase_								=  pt_model(**__lowerCamelCase      ,  output_hidden_states=__lowerCamelCase					)
   del pt_model  # will no longer be used, and may have a large memory footprint

   lowerCamelCase_								=  tf_class.from_pretrained(self._local_dir      ,  from_pt=__lowerCamelCase					)
   lowerCamelCase_								=  tf_from_pt_model(**__lowerCamelCase      ,  output_hidden_states=__lowerCamelCase      ,  training=__lowerCamelCase					)

   # Confirms that cross loading PT weights into TF worked.
   lowerCamelCase_								=  self.find_pt_tf_differences(__lowerCamelCase      ,  __lowerCamelCase					)
   lowerCamelCase_								=  {k: v for k, v in crossload_differences.items() if "hidden" not in k}
   lowerCamelCase_								=  {k: v for k, v in crossload_differences.items() if "hidden" in k}
   if len(__lowerCamelCase					) == 0 and architectures is not None:
    raise ValueError(
        f'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
        " output was found. All outputs start with 'hidden'"					)
   lowerCamelCase_								=  max(output_differences.values()					) if output_differences else 0.0
   lowerCamelCase_								=  max(hidden_differences.values()					)
   if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
    raise ValueError(
        "The cross-loaded TensorFlow model has different outputs, something went wrong!\n"
        + f'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
        + "\n".join([f'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]					)
        + f'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
        + "\n".join([f'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]					)					)

   # Save the weights in a TF format (if needed) and confirms that the results are still good
   lowerCamelCase_								=  os.path.join(self._local_dir      ,  __lowerCamelCase					)
   lowerCamelCase_								=  os.path.join(self._local_dir      ,  __lowerCamelCase					)
   if (not os.path.exists(__lowerCamelCase					) and not os.path.exists(__lowerCamelCase					)) or self._new_weights:
    tf_from_pt_model.save_pretrained(self._local_dir					)
   del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

   lowerCamelCase_								=  tf_class.from_pretrained(self._local_dir					)
   lowerCamelCase_								=  tf_model(**__lowerCamelCase      ,  output_hidden_states=__lowerCamelCase					)

   lowerCamelCase_								=  self.find_pt_tf_differences(__lowerCamelCase      ,  __lowerCamelCase					)
   lowerCamelCase_								=  {k: v for k, v in conversion_differences.items() if "hidden" not in k}
   lowerCamelCase_								=  {k: v for k, v in conversion_differences.items() if "hidden" in k}
   if len(__lowerCamelCase					) == 0 and architectures is not None:
    raise ValueError(
        f'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
        " output was found. All outputs start with 'hidden'"					)
   lowerCamelCase_								=  max(output_differences.values()					) if output_differences else 0.0
   lowerCamelCase_								=  max(hidden_differences.values()					)
   if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
    raise ValueError(
        "The converted TensorFlow model has different outputs, something went wrong!\n"
        + f'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
        + "\n".join([f'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]					)
        + f'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
        + "\n".join([f'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]					)					)

   lowerCamelCase_								=  "Update TF weights" if self._new_weights else "Add TF weights"
   if self._push:
    repo.git_add(auto_lfs_track=__lowerCamelCase					)
    repo.git_commit(__lowerCamelCase					)
    repo.git_push(blocking=__lowerCamelCase					)  # this prints a progress bar with the upload
    self._logger.warning(f'''TF weights pushed into {self._model_name}'''					)
   elif not self._no_pr:
    self._logger.warning("Uploading the weights into a new PR..."					)
    lowerCamelCase_								=  (
        "Model converted by the [`transformers`' `pt_to_tf`"
        " CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). "
        "All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n"
        f'''Maximum crossload output difference={max_crossload_output_diff:.3e}; '''
        f'''Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'''
        f'''Maximum conversion output difference={max_conversion_output_diff:.3e}; '''
        f'''Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'''
    )
    if self._max_error > MAX_ERROR:
     commit_descrition += (
         f'''\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'''
     )
    if self._extra_commit_description:
     commit_descrition += "\n\n" + self._extra_commit_description

    # sharded model -> adds all related files (index and .h5 shards)
    if os.path.exists(__lowerCamelCase					):
     lowerCamelCase_								=  [
         CommitOperationAdd(path_in_repo=__lowerCamelCase      ,  path_or_fileobj=__lowerCamelCase					)
     ]
     for shard_path in tf.io.gfile.glob(self._local_dir + "/tf_model-*.h5"					):
      operations += [
          CommitOperationAdd(path_in_repo=os.path.basename(__lowerCamelCase					)      ,  path_or_fileobj=__lowerCamelCase					)
      ]
    else:
     lowerCamelCase_								=  [CommitOperationAdd(path_in_repo=__lowerCamelCase      ,  path_or_fileobj=__lowerCamelCase					)]

    lowerCamelCase_								=  create_commit(
        repo_id=self._model_name      ,  operations=__lowerCamelCase      ,  commit_message=__lowerCamelCase      ,  commit_description=__lowerCamelCase      ,  repo_type="model"      ,  create_pr=__lowerCamelCase      ,  ).pr_url
    self._logger.warning(f'''PR open in {hub_pr_url}'''					)






'''simple docstring'''

# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import json
import os
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import yaml

from ...utils import ComputeEnvironment, DistributedType, SageMakerDistributedType
from ...utils.constants import SAGEMAKER_PYTHON_VERSION, SAGEMAKER_PYTORCH_VERSION, SAGEMAKER_TRANSFORMERS_VERSION


a_  :    Dict      =			os.path.expanduser(
    os.getenv("""HF_HOME""", os.path.join(os.getenv("""XDG_CACHE_HOME""", """~/.cache"""), """huggingface"""))
)
a_  :    Dict      =			os.path.join(hf_cache_home, """accelerate""")
a_  :    Optional[int]      =			os.path.join(cache_dir, """default_config.yaml""")
a_  :    int      =			os.path.join(cache_dir, """default_config.yaml""")

# For backward compatibility: the default config is the json one if it's the only existing file.
if os.path.isfile(default_yaml_config_file) or not os.path.isfile(default_json_config_file):
     a_  :    str      =			default_yaml_config_file
else:
     a_  :    str      =			default_json_config_file





def __snake_case (				UpperCAmelCase_						:						Optional[Any]		):
 if config_file is not None:
  if not os.path.isfile(UpperCAmelCase_		):
   raise FileNotFoundError(
       F'''The passed configuration file `{config_file}` does not exist. '''
       "Please pass an existing file to `accelerate launch`, or use the the default one "
       "created through `accelerate config` and run `accelerate launch` "
       "without the `--config_file` argument."		)
 else:
  lowerCamelCase_								=  default_config_file
 with open(UpperCAmelCase_ ,    "r" ,    encoding="utf-8"		) as f:
  if config_file.endswith(".json"		):
   if (
       json.load(UpperCAmelCase_		).get("compute_environment" ,    ComputeEnvironment.LOCAL_MACHINE		)
       == ComputeEnvironment.LOCAL_MACHINE
   ):
    lowerCamelCase_								=  ClusterConfig
   else:
    lowerCamelCase_								=  SageMakerConfig
   return config_class.from_json_file(json_file=UpperCAmelCase_		)
  else:
   if (
       yaml.safe_load(UpperCAmelCase_		).get("compute_environment" ,    ComputeEnvironment.LOCAL_MACHINE		)
       == ComputeEnvironment.LOCAL_MACHINE
   ):
    lowerCamelCase_								=  ClusterConfig
   else:
    lowerCamelCase_								=  SageMakerConfig
   return config_class.from_yaml_file(yaml_file=UpperCAmelCase_		)





@dataclass
class 					snake_case   :





  """simple docstring"""




  _lowerCamelCase		   =  42
  _lowerCamelCase		   =  42
  _lowerCamelCase		   =  42
  _lowerCamelCase		   =  42






  def   snake_case		(   self					):







   """simple docstring"""
   lowerCamelCase_								=  self.__dict__
   # For serialization, it's best to convert Enums to strings (or their underlying value type).
   for key, value in result.items():
    if isinstance(UpperCamelCase      ,  UpperCamelCase					):
     lowerCamelCase_								=  value.value
    if isinstance(UpperCamelCase      ,  UpperCamelCase					) and not bool(UpperCamelCase					):
     lowerCamelCase_								=  None
   lowerCamelCase_								=  {k: v for k, v in result.items() if v is not None}
   return result






  @classmethod
  def   snake_case		(   cls      ,  UpperCamelCase=None					):







   """simple docstring"""
   lowerCamelCase_								=  default_json_config_file if json_file is None else json_file
   with open(UpperCamelCase      ,  "r"      ,  encoding="utf-8"					) as f:
    lowerCamelCase_								=  json.load(UpperCamelCase					)
   if "compute_environment" not in config_dict:
    lowerCamelCase_								=  ComputeEnvironment.LOCAL_MACHINE
   if "mixed_precision" not in config_dict:
    lowerCamelCase_								=  "fp16" if ("fp16" in config_dict and config_dict["fp16"]) else None
   if "fp16" in config_dict:  # Convert the config to the new format.
    del config_dict["fp16"]
   if "dynamo_backend" in config_dict:  # Convert the config to the new format.
    lowerCamelCase_								=  config_dict.pop("dynamo_backend"					)
    lowerCamelCase_								=  {} if dynamo_backend == "NO" else {"dynamo_backend": dynamo_backend}
   if "use_cpu" not in config_dict:
    lowerCamelCase_								=  False
   return cls(**UpperCamelCase					)






  def   snake_case		(   self      ,  UpperCamelCase					):







   """simple docstring"""
   with open(UpperCamelCase      ,  "w"      ,  encoding="utf-8"					) as f:
    lowerCamelCase_								=  json.dumps(self.to_dict()      ,  indent=2      ,  sort_keys=UpperCamelCase					) + "\n"
    f.write(UpperCamelCase					)






  @classmethod
  def   snake_case		(   cls      ,  UpperCamelCase=None					):







   """simple docstring"""
   lowerCamelCase_								=  default_yaml_config_file if yaml_file is None else yaml_file
   with open(UpperCamelCase      ,  "r"      ,  encoding="utf-8"					) as f:
    lowerCamelCase_								=  yaml.safe_load(UpperCamelCase					)
   if "compute_environment" not in config_dict:
    lowerCamelCase_								=  ComputeEnvironment.LOCAL_MACHINE

   if "mixed_precision" not in config_dict:
    lowerCamelCase_								=  "fp16" if ("fp16" in config_dict and config_dict["fp16"]) else None
   if isinstance(config_dict["mixed_precision"]      ,  UpperCamelCase					) and not config_dict["mixed_precision"]:
    lowerCamelCase_								=  "no"
   if "fp16" in config_dict:  # Convert the config to the new format.
    del config_dict["fp16"]
   if "dynamo_backend" in config_dict:  # Convert the config to the new format.
    lowerCamelCase_								=  config_dict.pop("dynamo_backend"					)
    lowerCamelCase_								=  {} if dynamo_backend == "NO" else {"dynamo_backend": dynamo_backend}
   if "use_cpu" not in config_dict:
    lowerCamelCase_								=  False
   return cls(**UpperCamelCase					)






  def   snake_case		(   self      ,  UpperCamelCase					):







   """simple docstring"""
   with open(UpperCamelCase      ,  "w"      ,  encoding="utf-8"					) as f:
    yaml.safe_dump(self.to_dict()      ,  UpperCamelCase					)







  def   snake_case		(   self					):







   """simple docstring"""
   if isinstance(self.compute_environment      ,  UpperCamelCase					):
    lowerCamelCase_								=  ComputeEnvironment(self.compute_environment					)
   if isinstance(self.distributed_type      ,  UpperCamelCase					):
    if self.compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
     lowerCamelCase_								=  SageMakerDistributedType(self.distributed_type					)
    else:
     lowerCamelCase_								=  DistributedType(self.distributed_type					)
   if self.dynamo_config is None:
    lowerCamelCase_								=  {}





@dataclass
class 					snake_case   (   lowercase      ):





  """simple docstring"""




  _lowerCamelCase		   =  42
  _lowerCamelCase		   =  0
  _lowerCamelCase		   =  1
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  "static"
  _lowerCamelCase		   =  False
  _lowerCamelCase		   =  "main"

  # args for deepspeed_plugin
  _lowerCamelCase		   =  None
  # args for fsdp
  _lowerCamelCase		   =  None
  # args for megatron_lm
  _lowerCamelCase		   =  None
  # args for ipex
  _lowerCamelCase		   =  None
  # args for TPU
  _lowerCamelCase		   =  False

  # args for TPU pods
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  False
  _lowerCamelCase		   =  False
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None

  # args for dynamo
  _lowerCamelCase		   =  None






  def   snake_case		(   self					):







   """simple docstring"""
   if self.deepspeed_config is None:
    lowerCamelCase_								=  {}
   if self.fsdp_config is None:
    lowerCamelCase_								=  {}
   if self.megatron_lm_config is None:
    lowerCamelCase_								=  {}
   if self.ipex_config is None:
    lowerCamelCase_								=  {}
   return super().__post_init__()





@dataclass
class 					snake_case   (   lowercase      ):





  """simple docstring"""




  _lowerCamelCase		   =  42
  _lowerCamelCase		   =  42
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  "us-east-1"
  _lowerCamelCase		   =  1
  _lowerCamelCase		   =  "all"
  _lowerCamelCase		   =  F"accelerate-sagemaker-{num_machines}"
  _lowerCamelCase		   =  SAGEMAKER_PYTORCH_VERSION
  _lowerCamelCase		   =  SAGEMAKER_TRANSFORMERS_VERSION
  _lowerCamelCase		   =  SAGEMAKER_PYTHON_VERSION
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None
  _lowerCamelCase		   =  None



