





# 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


lowercase      :       List[str]									=  """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 A_	(		)  ->		Optional[Any]:
       a__						:	Union[str, Any] =				_ask_options(
           'In which compute environment are you running?'		,      ['This machine', 'AWS (Amazon SageMaker)']		,      _convert_compute_environment		,      )
       if compute_environment == ComputeEnvironment.AMAZON_SAGEMAKER:
              a__						:	List[str] =				get_sagemaker_input()
       else:
              a__						:	Union[str, Any] =				get_cluster_input()
       return config



def A_	(		A__=None				)  ->		Optional[Any]:
       if subparsers is not None:
              a__						:	Tuple =				subparsers.add_parser('config'		,      description=A__				)
       else:
              a__						:	Optional[Any] =				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 A_	(		A__				)  ->		Union[str, Any]:
       a__						:	List[Any] =				get_user_input()
       if args.config_file is not None:
              a__						:	Any =				args.config_file
       else:
              if not os.path.isdir(A__				):
                     os.makedirs(A__				)
              a__						:	Optional[int] =				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 A_	(		)  ->		str:
       a__						:	str =				config_command_parser()
       a__						:	Optional[Any] =				parser.parse_args()
       config_command(A__				)


if __name__ == "__main__":
    main()







'''simple docstring'''





import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow






class        lowerCAmelCase_:
  '''simple docstring'''




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase      )    ->		Optional[Any]:
      return None







class        lowerCAmelCase_:
  '''simple docstring'''




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase      )    ->		Tuple:
      return None







class        lowerCAmelCase_(				unittest.TestCase     ):
  '''simple docstring'''




  __lowercase							:      Dict				=      [
      # (model_name, model_kwargs)
      ('''bert-base-cased''', {}),
      ('''gpt2''', {'''use_cache''': False}),  # We don't support exporting GPT2 past keys anymore
  ]




  @require_tf
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		int:
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
          self._test_export(__UpperCAmelCase  ,"""tf"""  ,12  ,**__UpperCAmelCase      )




  @require_torch
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		Union[str, Any]:
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
          self._test_export(__UpperCAmelCase  ,"""pt"""  ,12  ,**__UpperCAmelCase      )




  @require_torch
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		Any:
      from transformers import BertModel

      lowerCAmelCase__ :  Optional[int]							      =					["""[UNK]""", """[SEP]""", """[CLS]""", """[PAD]""", """[MASK]""", """some""", """other""", """words"""]
      with NamedTemporaryFile(mode="""w+t"""      ) as vocab_file:
          vocab_file.write("""\n""".join(__UpperCAmelCase      )      )
          vocab_file.flush()
          lowerCAmelCase__ :  Dict							      =					BertTokenizerFast(vocab_file.name      )

      with TemporaryDirectory() as bert_save_dir:
          lowerCAmelCase__ :  Tuple							      =					BertModel(BertConfig(vocab_size=len(__UpperCAmelCase      )      )      )
          model.save_pretrained(__UpperCAmelCase      )
          self._test_export(__UpperCAmelCase  ,"""pt"""  ,12  ,__UpperCAmelCase      )




  @require_tf
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		List[str]:
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
          lowerCAmelCase__ :  Dict							      =					self._test_export(__UpperCAmelCase  ,"""tf"""  ,12  ,**__UpperCAmelCase      )
          lowerCAmelCase__ :  List[str]							      =					quantize(Path(__UpperCAmelCase      )      )

          # Ensure the actual quantized model is not bigger than the original one
          if quantized_path.stat().st_size >= Path(__UpperCAmelCase      ).stat().st_size:
              self.fail("""Quantized model is bigger than initial ONNX model"""      )




  @require_torch
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		List[Any]:
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
          lowerCAmelCase__ :  Any							      =					self._test_export(__UpperCAmelCase  ,"""pt"""  ,12  ,**__UpperCAmelCase      )
          lowerCAmelCase__ :  Dict							      =					quantize(__UpperCAmelCase      )

          # Ensure the actual quantized model is not bigger than the original one
          if quantized_path.stat().st_size >= Path(__UpperCAmelCase      ).stat().st_size:
              self.fail("""Quantized model is bigger than initial ONNX model"""      )




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase=None  ,**__UpperCAmelCase      )    ->		Optional[Any]:
      try:
          # Compute path
          with TemporaryDirectory() as tempdir:
              lowerCAmelCase__ :  Optional[int]							      =					Path(__UpperCAmelCase      ).joinpath("""model.onnx"""      )

          # Remove folder if exists
          if path.parent.exists():
              path.parent.rmdir()

          # Export
          convert(__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,**__UpperCAmelCase      )

          return path
      except Exception as e:
          self.fail(__UpperCAmelCase      )




  @require_torch
  @require_tokenizers
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		Union[str, Any]:
      from transformers import BertModel

      lowerCAmelCase__ :  List[Any]							      =					BertModel(BertConfig.from_pretrained("""lysandre/tiny-bert-random"""      )      )
      lowerCAmelCase__ :  Union[str, Any]							      =					BertTokenizerFast.from_pretrained("""lysandre/tiny-bert-random"""      )
      self._test_infer_dynamic_axis(__UpperCAmelCase  ,__UpperCAmelCase  ,"""pt"""      )




  @require_tf
  @require_tokenizers
  @slow
  def 							UpperCAmelCase_	(    self      )    ->		Optional[int]:
      from transformers import TFBertModel

      lowerCAmelCase__ :  int							      =					TFBertModel(BertConfig.from_pretrained("""lysandre/tiny-bert-random"""      )      )
      lowerCAmelCase__ :  Optional[int]							      =					BertTokenizerFast.from_pretrained("""lysandre/tiny-bert-random"""      )
      self._test_infer_dynamic_axis(__UpperCAmelCase  ,__UpperCAmelCase  ,"""tf"""      )




  def 							UpperCAmelCase_	(    self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase      )    ->		Tuple:
      lowerCAmelCase__ :  Any							      =					FeatureExtractionPipeline(__UpperCAmelCase  ,__UpperCAmelCase      )

      lowerCAmelCase__ :  List[str]							      =					["""input_ids""", """token_type_ids""", """attention_mask""", """output_0""", """output_1"""]
      lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__ :  Union[str, Any]							      =					infer_shapes(__UpperCAmelCase  ,__UpperCAmelCase      )

      # Assert all variables are present
      self.assertEqual(len(__UpperCAmelCase      )  ,len(__UpperCAmelCase      )      )
      self.assertTrue(all(var_name in shapes for var_name in variable_names      )      )
      self.assertSequenceEqual(variable_names[:3]  ,__UpperCAmelCase      )
      self.assertSequenceEqual(variable_names[3:]  ,__UpperCAmelCase      )

      # Assert inputs are {0: batch, 1: sequence}
      for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
          self.assertDictEqual(shapes[var_name]  ,{0: """batch""", 1: """sequence"""}      )

      # Assert outputs are {0: batch, 1: sequence} and {0: batch}
      self.assertDictEqual(shapes["""output_0"""]  ,{0: """batch""", 1: """sequence"""}      )
      self.assertDictEqual(shapes["""output_1"""]  ,{0: """batch"""}      )




  def 							UpperCAmelCase_	(    self      )    ->		Optional[int]:
      lowerCAmelCase__ :  List[str]							      =					["""input_ids""", """attention_mask""", """token_type_ids"""]
      lowerCAmelCase__ :  Union[str, Any]							      =					{"""input_ids""": [1, 2, 3, 4], """attention_mask""": [0, 0, 0, 0], """token_type_ids""": [1, 1, 1, 1]}
      lowerCAmelCase__      ,   lowerCAmelCase__ :  List[Any]							      =					ensure_valid_input(FuncContiguousArgs()  ,__UpperCAmelCase  ,__UpperCAmelCase      )

      # Should have exactly the same number of args (all are valid)
      self.assertEqual(len(__UpperCAmelCase      )  ,3      )

      # Should have exactly the same input names
      self.assertEqual(set(__UpperCAmelCase      )  ,set(__UpperCAmelCase      )      )

      # Parameter should be reordered according to their respective place in the function:
      # (input_ids, token_type_ids, attention_mask)
      self.assertEqual(__UpperCAmelCase  ,(tokens["""input_ids"""], tokens["""token_type_ids"""], tokens["""attention_mask"""])      )

      # Generated args are interleaved with another args (for instance parameter "past" in GPT2)
      lowerCAmelCase__      ,   lowerCAmelCase__ :  int							      =					ensure_valid_input(FuncNonContiguousArgs()  ,__UpperCAmelCase  ,__UpperCAmelCase      )

      # Should have exactly the one arg (all before the one not provided "some_other_args")
      self.assertEqual(len(__UpperCAmelCase      )  ,1      )
      self.assertEqual(len(__UpperCAmelCase      )  ,1      )

      # Should have only "input_ids"
      self.assertEqual(inputs_args[0]  ,tokens["""input_ids"""]      )
      self.assertEqual(ordered_input_names[0]  ,"""input_ids"""      )






  def 							UpperCAmelCase_	(    self      )    ->		Tuple:
      lowerCAmelCase__ :  Dict							      =					generate_identified_filename(Path("""/home/something/my_fake_model.onnx"""      )  ,"""-test"""      )
      self.assertEqual("""/home/something/my_fake_model-test.onnx"""  ,generated.as_posix()      )


