



'''simple docstring'''


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand




def  UpperCAmelCase_       (		lowercase__       ):


     '''simple docstring'''







     return ConvertCommand(
         args.model_type       ,	args.tf_checkpoint       ,	args.pytorch_dump_output       ,	args.config       ,	args.finetuning_task_name       )


lowercase							       =			'''\ntransformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires\nTensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.\n'''







class 	UpperCAmelCase	(		__a):


 '''simple docstring'''




 @staticmethod
 def       lowercase_  (   lowerCAmelCase_) ->      Optional[int]:



      """simple docstring"""







      a_       		=parser.add_parser(
          "convert"							,  help="CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints."							,  )
      train_parser.add_argument("--model_type"							,  type=_SCREAMING_SNAKE_CASE							,  required=_SCREAMING_SNAKE_CASE							,  help="Model's type.")
      train_parser.add_argument(
          "--tf_checkpoint"							,  type=_SCREAMING_SNAKE_CASE							,  required=_SCREAMING_SNAKE_CASE							,  help="TensorFlow checkpoint path or folder.")
      train_parser.add_argument(
          "--pytorch_dump_output"							,  type=_SCREAMING_SNAKE_CASE							,  required=_SCREAMING_SNAKE_CASE							,  help="Path to the PyTorch saved model output.")
      train_parser.add_argument("--config"							,  type=_SCREAMING_SNAKE_CASE							,  default=""							,  help="Configuration file path or folder.")
      train_parser.add_argument(
          "--finetuning_task_name"							,  type=_SCREAMING_SNAKE_CASE							,  default=_SCREAMING_SNAKE_CASE							,  help="Optional fine-tuning task name if the TF model was a finetuned model."							,  )
      train_parser.set_defaults(func=_SCREAMING_SNAKE_CASE)




 def __init__(   self							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_							,  *lowerCAmelCase_							,  ) ->      Optional[Any]:



      """simple docstring"""







      a_       		=logging.get_logger("transformers-cli/converting")

      self._logger.info(f"""Loading model {model_type}""")
      a_       		=model_type
      a_       		=tf_checkpoint
      a_       		=pytorch_dump_output
      a_       		=config
      a_       		=finetuning_task_name




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      if self._model_type == "albert":
           try:
                from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
                    convert_tf_checkpoint_to_pytorch,
                )
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           convert_tf_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      elif self._model_type == "bert":
           try:
                from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
                    convert_tf_checkpoint_to_pytorch,
                )
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           convert_tf_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      elif self._model_type == "funnel":
           try:
                from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
                    convert_tf_checkpoint_to_pytorch,
                )
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           convert_tf_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      elif self._model_type == "t5":
           try:
                from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           convert_tf_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      elif self._model_type == "gpt":
           from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
               convert_openai_checkpoint_to_pytorch,
           )

           convert_openai_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      elif self._model_type == "transfo_xl":
           try:
                from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
                    convert_transfo_xl_checkpoint_to_pytorch,
                )
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           if "ckpt" in self._tf_checkpoint.lower():
                a_       		=self._tf_checkpoint
                a_       		=""
           else:
                a_       		=self._tf_checkpoint
                a_       		=""
           convert_transfo_xl_checkpoint_to_pytorch(
               _SCREAMING_SNAKE_CASE							,  self._config							,  self._pytorch_dump_output							,  _SCREAMING_SNAKE_CASE)
      elif self._model_type == "gpt2":
           try:
                from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
                    convert_gpta_checkpoint_to_pytorch,
                )
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      elif self._model_type == "xlnet":
           try:
                from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
                    convert_xlnet_checkpoint_to_pytorch,
                )
           except ImportError:
                raise ImportError(_SCREAMING_SNAKE_CASE)

           convert_xlnet_checkpoint_to_pytorch(
               self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output							,  self._finetuning_task_name)
      elif self._model_type == "xlm":
           from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
               convert_xlm_checkpoint_to_pytorch,
           )

           convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint							,  self._pytorch_dump_output)
      elif self._model_type == "lxmert":
           from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
               convert_lxmert_checkpoint_to_pytorch,
           )

           convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint							,  self._pytorch_dump_output)
      elif self._model_type == "rembert":
           from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
               convert_rembert_tf_checkpoint_to_pytorch,
           )

           convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint							,  self._config							,  self._pytorch_dump_output)
      else:
           raise ValueError(
               "--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]")







'''simple docstring'''


import os
from math import logaa






def  UpperCAmelCase_       (		lowercase__ = "base_exp.txt"       ):


     '''simple docstring'''







     a_       		=0
     a_       		=0
     for i, line in enumerate(open(os.path.join(os.path.dirname(lowercase__       )       ,	lowercase__       )       )       ):
          a_		,						a_       		=list(map(lowercase__       ,	line.split(","       )       )       )
          if x * logaa(lowercase__       ) > largest:
               a_       		=x * logaa(lowercase__       )
               a_       		=i + 1
     return result


if __name__ == "__main__":
  print(solution())


