
"""simple docstring"""






import argparse
import os

import numpy as np
import tensorflow as tf
import torch

from transformers import BertModel






def 						_snake_case       (	lowercase__		:  List[Any]      ,     lowercase__		:  Optional[Any]      ,     lowercase__		:  Union[str, Any]		)  ->				List[str]:


			'''simple docstring'''





			lowerCAmelCase_    :str			     =  ("""dense.weight""", """attention.self.query""", """attention.self.key""", """attention.self.value""")

			lowerCAmelCase_    :Optional[int]			     =  (
			    ("""layer.""", """layer_"""),
			    ("""word_embeddings.weight""", """word_embeddings"""),
			    ("""position_embeddings.weight""", """position_embeddings"""),
			    ("""token_type_embeddings.weight""", """token_type_embeddings"""),
			    (""".""", """/"""),
			    ("""LayerNorm/weight""", """LayerNorm/gamma"""),
			    ("""LayerNorm/bias""", """LayerNorm/beta"""),
			    ("""weight""", """kernel"""),
			)

			if not os.path.isdir(_lowerCAmelCase		):
						os.makedirs(_lowerCAmelCase		)

			lowerCAmelCase_    :Any			     =  model.state_dict()

			def to_tf_var_name(lowercase__		:  List[Any]		):
						for patt, repl in iter(_lowerCAmelCase		):
									lowerCAmelCase_    :Any			     =  name.replace(_lowerCAmelCase      ,     _lowerCAmelCase		)
						return f"""bert/{name}"""

			def create_tf_var(lowercase__		:  Dict      ,     lowercase__		:  Optional[Any]      ,     lowercase__		:  Optional[int]		):
						lowerCAmelCase_    :List[Any]			     =  tf.dtypes.as_dtype(tensor.dtype		)
						lowerCAmelCase_    :Optional[int]			     =  tf.get_variable(dtype=_lowerCAmelCase      ,     shape=tensor.shape      ,     name=_lowerCAmelCase      ,     initializer=tf.zeros_initializer()		)
						session.run(tf.variables_initializer([tf_var]		)		)
						session.run(_lowerCAmelCase		)
						return tf_var

			tf.reset_default_graph()
			with tf.Session() as session:
						for var_name in state_dict:
									lowerCAmelCase_    :Tuple			     =  to_tf_var_name(_lowerCAmelCase		)
									lowerCAmelCase_    :str			     =  state_dict[var_name].numpy()
									if any(x in var_name for x in tensors_to_transpose		):
												lowerCAmelCase_    :Union[str, Any]			     =  torch_tensor.T
									lowerCAmelCase_    :Tuple			     =  create_tf_var(tensor=_lowerCAmelCase      ,     name=_lowerCAmelCase      ,     session=_lowerCAmelCase		)
									tf.keras.backend.set_value(_lowerCAmelCase      ,     _lowerCAmelCase		)
									lowerCAmelCase_    :int			     =  session.run(_lowerCAmelCase		)
									print(f"""Successfully created {tf_name}: {np.allclose(_lowerCAmelCase      ,     _lowerCAmelCase		)}"""		)

						lowerCAmelCase_    :Tuple			     =  tf.train.Saver(tf.trainable_variables()		)
						saver.save(_lowerCAmelCase      ,     os.path.join(_lowerCAmelCase      ,     model_name.replace("""-"""      ,     """_"""		) + """.ckpt"""		)		)






def 						_snake_case       (	lowercase__		:  str=None		)  ->				int:


			'''simple docstring'''





			lowerCAmelCase_    :Any			     =  argparse.ArgumentParser()
			parser.add_argument("""--model_name"""      ,     type=_lowerCAmelCase      ,     required=_lowerCAmelCase      ,     help="""model name e.g. bert-base-uncased"""		)
			parser.add_argument(
			    """--cache_dir"""      ,     type=_lowerCAmelCase      ,     default=_lowerCAmelCase      ,     required=_lowerCAmelCase      ,     help="""Directory containing pytorch model"""		)
			parser.add_argument("""--pytorch_model_path"""      ,     type=_lowerCAmelCase      ,     required=_lowerCAmelCase      ,     help="""/path/to/<pytorch-model-name>.bin"""		)
			parser.add_argument("""--tf_cache_dir"""      ,     type=_lowerCAmelCase      ,     required=_lowerCAmelCase      ,     help="""Directory in which to save tensorflow model"""		)
			lowerCAmelCase_    :Optional[int]			     =  parser.parse_args(_lowerCAmelCase		)

			lowerCAmelCase_    :int			     =  BertModel.from_pretrained(
			    pretrained_model_name_or_path=args.model_name      ,     state_dict=torch.load(args.pytorch_model_path		)      ,     cache_dir=args.cache_dir      ,     )

			convert_pytorch_checkpoint_to_tf(model=_lowerCAmelCase      ,     ckpt_dir=args.tf_cache_dir      ,     model_name=args.model_name		)


if __name__ == "__main__":
				main()











from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_:Any             =						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_:Dict             =						{
    """facebook/xmod-base""": """https://huggingface.co/facebook/xmod-base/resolve/main/config.json""",
    """facebook/xmod-large-prenorm""": """https://huggingface.co/facebook/xmod-large-prenorm/resolve/main/config.json""",
    """facebook/xmod-base-13-125k""": """https://huggingface.co/facebook/xmod-base-13-125k/resolve/main/config.json""",
    """facebook/xmod-base-30-125k""": """https://huggingface.co/facebook/xmod-base-30-125k/resolve/main/config.json""",
    """facebook/xmod-base-30-195k""": """https://huggingface.co/facebook/xmod-base-30-195k/resolve/main/config.json""",
    """facebook/xmod-base-60-125k""": """https://huggingface.co/facebook/xmod-base-60-125k/resolve/main/config.json""",
    """facebook/xmod-base-60-265k""": """https://huggingface.co/facebook/xmod-base-60-265k/resolve/main/config.json""",
    """facebook/xmod-base-75-125k""": """https://huggingface.co/facebook/xmod-base-75-125k/resolve/main/config.json""",
    """facebook/xmod-base-75-269k""": """https://huggingface.co/facebook/xmod-base-75-269k/resolve/main/config.json""",
}






class SCREAMING_SNAKE_CASE__     (		SCREAMING_SNAKE_CASE__    ):




    '''simple docstring'''






    __lowerCamelCase			: Dict					=      "xmod"






    def __init__(       self,		lowerCamelCase__=3_0522,		lowerCamelCase__=768,		lowerCamelCase__=12,		lowerCamelCase__=12,		lowerCamelCase__=3072,		lowerCamelCase__="gelu",		lowerCamelCase__=0.1,		lowerCamelCase__=0.1,		lowerCamelCase__=512,		lowerCamelCase__=2,		lowerCamelCase__=0.02,		lowerCamelCase__=1e-12,		lowerCamelCase__=1,		lowerCamelCase__=0,		lowerCamelCase__=2,		lowerCamelCase__="absolute",		lowerCamelCase__=True,		lowerCamelCase__=None,		lowerCamelCase__=False,		lowerCamelCase__=2,		lowerCamelCase__=False,		lowerCamelCase__=True,		lowerCamelCase__=True,		lowerCamelCase__=("en_XX",),		lowerCamelCase__=None,		**lowerCamelCase__,		):
        super().__init__(pad_token_id=lowerCamelCase__,		bos_token_id=lowerCamelCase__,		eos_token_id=lowerCamelCase__,		**lowerCamelCase__		)

        A :       int          =   vocab_size
        A :       int          =   hidden_size
        A :       str          =   num_hidden_layers
        A :       List[str]          =   num_attention_heads
        A :       List[str]          =   hidden_act
        A :       Dict          =   intermediate_size
        A :       Optional[int]          =   hidden_dropout_prob
        A :       Union[str, Any]          =   attention_probs_dropout_prob
        A :       int          =   max_position_embeddings
        A :       Tuple          =   type_vocab_size
        A :       List[Any]          =   initializer_range
        A :       str          =   layer_norm_eps
        A :       Union[str, Any]          =   position_embedding_type
        A :       Any          =   use_cache
        A :       int          =   classifier_dropout
        A :       int          =   pre_norm
        A :       List[str]          =   adapter_reduction_factor
        A :       Any          =   adapter_layer_norm
        A :       Any          =   adapter_reuse_layer_norm
        A :       str          =   ln_before_adapter
        A :       Dict          =   list(lowerCamelCase__		)
        A :       Union[str, Any]          =   default_language






class SCREAMING_SNAKE_CASE__     (		SCREAMING_SNAKE_CASE__    ):




    '''simple docstring'''






    @property
    def 			_lowerCAmelCase					(       self		):
        if self.task == "multiple-choice":
            A :       Any          =   {0: """batch""", 1: """choice""", 2: """sequence"""}
        else:
            A :       int          =   {0: """batch""", 1: """sequence"""}
        return OrderedDict(
            [
                ("""input_ids""", dynamic_axis),
                ("""attention_mask""", dynamic_axis),
            ]		)


