



"""simple docstring"""



from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand


def  _UpperCamelCase	(						_A      )    ->  Optional[Any]:





    """simple docstring"""

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


a					:	Any							=		"""
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
"""







class 		a_						( _UpperCAmelCase	):







    @staticmethod
    def      _snake_case					(			__UpperCamelCase			:       ArgumentParser     )		->Optional[Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   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=__UpperCamelCase     ,					required=__UpperCamelCase     ,					help="""Model\'s type."""     )
        train_parser.add_argument(
            """--tf_checkpoint"""     ,					type=__UpperCamelCase     ,					required=__UpperCamelCase     ,					help="""TensorFlow checkpoint path or folder."""     )
        train_parser.add_argument(
            """--pytorch_dump_output"""     ,					type=__UpperCamelCase     ,					required=__UpperCamelCase     ,					help="""Path to the PyTorch saved model output."""     )
        train_parser.add_argument("""--config"""     ,					type=__UpperCamelCase     ,					default=""""""     ,					help="""Configuration file path or folder."""     )
        train_parser.add_argument(
            """--finetuning_task_name"""     ,					type=__UpperCamelCase     ,					default=__UpperCamelCase     ,					help="""Optional fine-tuning task name if the TF model was a finetuned model."""     ,					)
        train_parser.set_defaults(func=__UpperCamelCase     )







    def __init__(			self			:       str     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       str     ,					*__UpperCamelCase			:       Optional[int]     ,					)		->Optional[int]:






        '''simple docstring'''






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

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







    def      _snake_case					(			self			:       Dict     )		->Union[str, Any]:






        '''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(__UpperCamelCase     )

            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(__UpperCamelCase     )

            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(__UpperCamelCase     )

            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(__UpperCamelCase     )

            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(__UpperCamelCase     )

            if "ckpt" in self._tf_checkpoint.lower():
                _UpperCAmelCase          =   self._tf_checkpoint
                _UpperCAmelCase          =   """"""
            else:
                _UpperCAmelCase          =   self._tf_checkpoint
                _UpperCAmelCase          =   """"""
            convert_transfo_xl_checkpoint_to_pytorch(
                __UpperCamelCase     ,					self._config     ,					self._pytorch_dump_output     ,					__UpperCamelCase     )
        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(__UpperCamelCase     )

            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(__UpperCamelCase     )

            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 argparse

import torch

from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert
from transformers.utils import logging


logging.set_verbosity_info()


def  _UpperCamelCase	(						_A					,      _A					,      _A      )    ->  List[Any]:





    """simple docstring"""

    _UpperCAmelCase          =   LxmertConfig.from_json_file(_A      )
    print(F"""Building PyTorch model from configuration: {config}"""      )
    _UpperCAmelCase          =   LxmertForPreTraining(_A      )

    # Load weights from tf checkpoint
    load_tf_weights_in_lxmert(_A					,      _A					,      _A      )

    # Save pytorch-model
    print(F"""Save PyTorch model to {pytorch_dump_path}"""      )
    torch.save(model.state_dict()					,      _A      )


if __name__ == "__main__":
 a					:	Dict							=		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 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					:	Union[str, Any]							=		parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)