
# 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 argparse
import os

from accelerate.utils import ComputeEnvironment

from .cluster import get_cluster_input
from .config_args import cache_dir, default_config_file, default_yaml_config_file, load_config_from_file  # noqa: F401
from .config_utils import _ask_field, _ask_options, _convert_compute_environment  # noqa: F401
from .sagemaker import get_sagemaker_input


_A   =			"Launches a series of prompts to create and save a `default_config.yaml` configuration file for your training system. Should always be ran first on your machine"



def 						lowercase_      (       )							->							str:
    """simple docstring"""

    snake_case								= _ask_options(
        "In which compute environment are you running?"			,		["This machine", "AWS (Amazon SageMaker)"]			,		_convert_compute_environment			,		)
    if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
        snake_case								= get_sagemaker_input()
    else:
        snake_case								= get_cluster_input()
    return config



def 						lowercase_      (       A__=None		)							->							Optional[int]:
    """simple docstring"""

    if subparsers is not None:
        snake_case								= subparsers.add_parser("config"			,		description=A__		)
    else:
        snake_case								= argparse.ArgumentParser("Accelerate config command"			,		description=A__		)

    parser.add_argument(
        "--config_file"			,		default=A__			,		help=(
            "The path to use to store the config file. Will default to a file named default_config.yaml in the cache "
            "location, which is the content of the environment `HF_HOME` suffixed with 'accelerate', or if you don't have "
            "such an environment variable, your cache directory ('~/.cache' or the content of `XDG_CACHE_HOME`) suffixed "
            "with 'huggingface'."
        )			,		)

    if subparsers is not None:
        parser.set_defaults(func=A__		)
    return parser



def 						lowercase_      (       A__		)							->							str:
    """simple docstring"""

    snake_case								= get_user_input()
    if args.config_file is not None:
        snake_case								= args.config_file
    else:
        if not os.path.isdir(A__		):
            os.makedirs(A__		)
        snake_case								= default_yaml_config_file

    if config_file.endswith(".json"		):
        config.to_json_file(A__		)
    else:
        config.to_yaml_file(A__		)
    print(F'accelerate configuration saved at {config_file}'		)



def 						lowercase_      (       )							->							int:
    """simple docstring"""

    snake_case								= config_command_parser()
    snake_case								= parser.parse_args()
    config_command(A__		)


if __name__ == "__main__":
   main()



import argparse

import torch
from huggingface_hub import hf_hub_download

from transformers import AutoTokenizer, RobertaPreLayerNormConfig, RobertaPreLayerNormForMaskedLM
from transformers.utils import logging


logging.set_verbosity_info()
_A   =			logging.get_logger(__name__)



def 						lowercase_      (       A__			,		A__		)							->							int:
    """simple docstring"""

    snake_case								= RobertaPreLayerNormConfig.from_pretrained(
        A__			,		architectures=["RobertaPreLayerNormForMaskedLM"]		)

    # convert state_dict
    snake_case								= torch.load(hf_hub_download(repo_id=A__			,		filename="pytorch_model.bin"		)		)
    snake_case								= {}
    for tensor_key, tensor_value in original_state_dict.items():
        # The transformer implementation gives the model a unique name, rather than overwiriting 'roberta'
        if tensor_key.startswith("roberta."		):
            snake_case								= "roberta_prelayernorm." + tensor_key[len("roberta."		) :]

        # The original implementation contains weights which are not used, remove them from the state_dict
        if tensor_key.endswith(".self.LayerNorm.weight"		) or tensor_key.endswith(".self.LayerNorm.bias"		):
            continue

        snake_case								= tensor_value

    snake_case								= RobertaPreLayerNormForMaskedLM.from_pretrained(
        pretrained_model_name_or_path=A__			,		config=A__			,		state_dict=A__		)
    model.save_pretrained(A__		)

    # convert tokenizer
    snake_case								= AutoTokenizer.from_pretrained(A__		)
    tokenizer.save_pretrained(A__		)


if __name__ == "__main__":
   _A   =			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--checkpoint-repo",
       default=None,
       type=str,
       required=True,
       help="Path the official PyTorch dump, e.g. 'andreasmadsen/efficient_mlm_m0.40'.",
   )
   parser.add_argument(
       "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
   )
   _A   =			parser.parse_args()
   convert_roberta_prelayernorm_checkpoint_to_pytorch(args.checkpoint_repo, args.pytorch_dump_folder_path)

