



"""simple docstring"""






import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
_lowercase : List[str]      						=						logging.get_logger(__name__)






def      snake_case__   (		__lowerCamelCase				:    int							,		__lowerCamelCase				:    List[Any]							,		__lowerCamelCase				:    Tuple	):
			"""simple docstring"""
			lowerCamelCase__		:		Tuple			=os.path.abspath(__lowerCamelCase	)
			logger.info(f'''Converting TensorFlow checkpoint from {tf_path}'''	)
			# Load weights from TF model
			lowerCamelCase__		:		Union[str, Any]			=tf.train.list_variables(__lowerCamelCase	)
			lowerCamelCase__		:		Union[str, Any]			=[]
			lowerCamelCase__		:		Dict			=[]
			lowerCamelCase__		:		Optional[int]			=[]
			for full_name, shape in init_vars:
						# logger.info(f"Loading TF weight {name} with shape {shape}")
						lowerCamelCase__		:		Optional[Any]			=full_name.split('''/'''	)
						if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
									logger.info(f'''Skipping non-model layer {full_name}'''	)
									continue
						if "optimizer" in full_name:
									logger.info(f'''Skipping optimization layer {full_name}'''	)
									continue
						if name[0] == "model":
									# ignore initial 'model'
									lowerCamelCase__		:		Optional[int]			=name[1:]
						# figure out how many levels deep the name is
						lowerCamelCase__		:		Union[str, Any]			=0
						for _name in name:
									if _name.startswith('''layer_with_weights'''	):
												depth += 1
									else:
												break
						layer_depth.append(__lowerCamelCase	)
						# read data
						lowerCamelCase__		:		int			=tf.train.load_variable(__lowerCamelCase							,		__lowerCamelCase	)
						names.append('''/'''.join(__lowerCamelCase	)	)
						arrays.append(__lowerCamelCase	)
			logger.info(f'''Read a total of {len(__lowerCamelCase	):,} layers'''	)

			# Sanity check
			if len(set(__lowerCamelCase	)	) != 1:
						raise ValueError(f'''Found layer names with different depths (layer depth {list(set(__lowerCamelCase	)	)})'''	)
			lowerCamelCase__		:		List[Any]			=list(set(__lowerCamelCase	)	)[0]
			if layer_depth != 1:
						raise ValueError(
						    '''The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP'''
						    ''' heads.'''	)

			# convert layers
			logger.info('''Converting weights...'''	)
			for full_name, array in zip(__lowerCamelCase							,		__lowerCamelCase	):
						lowerCamelCase__		:		List[str]			=full_name.split('''/'''	)
						lowerCamelCase__		:		str			=model
						lowerCamelCase__		:		Optional[Any]			=[]
						for i, m_name in enumerate(__lowerCamelCase	):
									if m_name == ".ATTRIBUTES":
												# variable names end with .ATTRIBUTES/VARIABLE_VALUE
												break
									if m_name.startswith('''layer_with_weights'''	):
												lowerCamelCase__		:		Dict			=int(m_name.split('''-'''	)[-1]	)
												if layer_num <= 2:
															# embedding layers
															# layer_num 0: word_embeddings
															# layer_num 1: position_embeddings
															# layer_num 2: token_type_embeddings
															continue
												elif layer_num == 3:
															# embedding LayerNorm
															trace.extend(['''embeddings''', '''LayerNorm''']	)
															lowerCamelCase__		:		List[Any]			=getattr(__lowerCamelCase							,		'''embeddings'''	)
															lowerCamelCase__		:		Union[str, Any]			=getattr(__lowerCamelCase							,		'''LayerNorm'''	)
												elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
															# encoder layers
															trace.extend(['''encoder''', '''layer''', str(layer_num - 4	)]	)
															lowerCamelCase__		:		str			=getattr(__lowerCamelCase							,		'''encoder'''	)
															lowerCamelCase__		:		Union[str, Any]			=getattr(__lowerCamelCase							,		'''layer'''	)
															lowerCamelCase__		:		List[Any]			=pointer[layer_num - 4]
												elif layer_num == config.num_hidden_layers + 4:
															# pooler layer
															trace.extend(['''pooler''', '''dense''']	)
															lowerCamelCase__		:		Union[str, Any]			=getattr(__lowerCamelCase							,		'''pooler'''	)
															lowerCamelCase__		:		int			=getattr(__lowerCamelCase							,		'''dense'''	)
									elif m_name == "embeddings":
												trace.append('''embeddings'''	)
												lowerCamelCase__		:		List[Any]			=getattr(__lowerCamelCase							,		'''embeddings'''	)
												if layer_num == 0:
															trace.append('''word_embeddings'''	)
															lowerCamelCase__		:		Union[str, Any]			=getattr(__lowerCamelCase							,		'''word_embeddings'''	)
												elif layer_num == 1:
															trace.append('''position_embeddings'''	)
															lowerCamelCase__		:		int			=getattr(__lowerCamelCase							,		'''position_embeddings'''	)
												elif layer_num == 2:
															trace.append('''token_type_embeddings'''	)
															lowerCamelCase__		:		List[Any]			=getattr(__lowerCamelCase							,		'''token_type_embeddings'''	)
												else:
															raise ValueError(f'''Unknown embedding layer with name {full_name}'''	)
												trace.append('''weight'''	)
												lowerCamelCase__		:		Union[str, Any]			=getattr(__lowerCamelCase							,		'''weight'''	)
									elif m_name == "_attention_layer":
												# self-attention layer
												trace.extend(['''attention''', '''self''']	)
												lowerCamelCase__		:		int			=getattr(__lowerCamelCase							,		'''attention'''	)
												lowerCamelCase__		:		Optional[Any]			=getattr(__lowerCamelCase							,		'''self'''	)
									elif m_name == "_attention_layer_norm":
												# output attention norm
												trace.extend(['''attention''', '''output''', '''LayerNorm''']	)
												lowerCamelCase__		:		Tuple			=getattr(__lowerCamelCase							,		'''attention'''	)
												lowerCamelCase__		:		List[Any]			=getattr(__lowerCamelCase							,		'''output'''	)
												lowerCamelCase__		:		Optional[Any]			=getattr(__lowerCamelCase							,		'''LayerNorm'''	)
									elif m_name == "_attention_output_dense":
												# output attention dense
												trace.extend(['''attention''', '''output''', '''dense''']	)
												lowerCamelCase__		:		List[str]			=getattr(__lowerCamelCase							,		'''attention'''	)
												lowerCamelCase__		:		List[Any]			=getattr(__lowerCamelCase							,		'''output'''	)
												lowerCamelCase__		:		int			=getattr(__lowerCamelCase							,		'''dense'''	)
									elif m_name == "_output_dense":
												# output dense
												trace.extend(['''output''', '''dense''']	)
												lowerCamelCase__		:		Dict			=getattr(__lowerCamelCase							,		'''output'''	)
												lowerCamelCase__		:		Tuple			=getattr(__lowerCamelCase							,		'''dense'''	)
									elif m_name == "_output_layer_norm":
												# output dense
												trace.extend(['''output''', '''LayerNorm''']	)
												lowerCamelCase__		:		Optional[Any]			=getattr(__lowerCamelCase							,		'''output'''	)
												lowerCamelCase__		:		str			=getattr(__lowerCamelCase							,		'''LayerNorm'''	)
									elif m_name == "_key_dense":
												# attention key
												trace.append('''key'''	)
												lowerCamelCase__		:		Tuple			=getattr(__lowerCamelCase							,		'''key'''	)
									elif m_name == "_query_dense":
												# attention query
												trace.append('''query'''	)
												lowerCamelCase__		:		int			=getattr(__lowerCamelCase							,		'''query'''	)
									elif m_name == "_value_dense":
												# attention value
												trace.append('''value'''	)
												lowerCamelCase__		:		Optional[Any]			=getattr(__lowerCamelCase							,		'''value'''	)
									elif m_name == "_intermediate_dense":
												# attention intermediate dense
												trace.extend(['''intermediate''', '''dense''']	)
												lowerCamelCase__		:		Tuple			=getattr(__lowerCamelCase							,		'''intermediate'''	)
												lowerCamelCase__		:		List[str]			=getattr(__lowerCamelCase							,		'''dense'''	)
									elif m_name == "_output_layer_norm":
												# output layer norm
												trace.append('''output'''	)
												lowerCamelCase__		:		Any			=getattr(__lowerCamelCase							,		'''output'''	)
									# weights & biases
									elif m_name in ["bias", "beta"]:
												trace.append('''bias'''	)
												lowerCamelCase__		:		Optional[int]			=getattr(__lowerCamelCase							,		'''bias'''	)
									elif m_name in ["kernel", "gamma"]:
												trace.append('''weight'''	)
												lowerCamelCase__		:		int			=getattr(__lowerCamelCase							,		'''weight'''	)
									else:
												logger.warning(f'''Ignored {m_name}'''	)
        # for certain layers reshape is necessary
						lowerCamelCase__		:		Optional[Any]			='''.'''.join(__lowerCamelCase	)
						if re.match(R'''(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)'''							,		__lowerCamelCase	) or re.match(
						    R'''(\S+)\.attention\.output\.dense\.weight'''							,		__lowerCamelCase	):
									lowerCamelCase__		:		Tuple			=array.reshape(pointer.data.shape	)
						if "kernel" in full_name:
									lowerCamelCase__		:		Any			=array.transpose()
						if pointer.shape == array.shape:
									lowerCamelCase__		:		int			=torch.from_numpy(__lowerCamelCase	)
						else:
									raise ValueError(
									    f'''Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:'''
									    f''' {array.shape}'''	)
						logger.info(f'''Successfully set variable {full_name} to PyTorch layer {trace}'''	)
			return model






def      snake_case__   (		__lowerCamelCase				:    Any							,		__lowerCamelCase				:    Tuple							,		__lowerCamelCase				:    int	):
			"""simple docstring"""
			# Instantiate model
			logger.info(f'''Loading model based on config from {config_path}...'''	)
			lowerCamelCase__		:		int			=BertConfig.from_json_file(__lowerCamelCase	)
			lowerCamelCase__		:		Optional[Any]			=BertModel(__lowerCamelCase	)

			# Load weights from checkpoint
			logger.info(f'''Loading weights from checkpoint {tf_checkpoint_path}...'''	)
			load_tfa_weights_in_bert(__lowerCamelCase							,		__lowerCamelCase							,		__lowerCamelCase	)

			# Save pytorch-model
			logger.info(f'''Saving PyTorch model to {pytorch_dump_path}...'''	)
			torch.save(model.state_dict()							,		__lowerCamelCase	)


if __name__ == "__main__":
		_lowercase : str      						=						argparse.ArgumentParser()
		parser.add_argument(
		    "--tf_checkpoint_path", type=str, required=True, help="Path to the TensorFlow 2.x checkpoint path."
		)
		parser.add_argument(
		    "--bert_config_file",
		    type=str,
		    required=True,
		    help="The config json file corresponding to the BERT model. This specifies the model architecture.",
		)
		parser.add_argument(
		    "--pytorch_dump_path",
		    type=str,
		    required=True,
		    help="Path to the output PyTorch model (must include filename).",
		)
		_lowercase : Optional[Any]      						=						parser.parse_args()
		convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)









"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


_lowercase : List[Any]      						=						{
    "configuration_tapas": ["TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP", "TapasConfig"],
    "tokenization_tapas": ["TapasTokenizer"],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase : Optional[Any]      						=						[
		    "TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TapasForMaskedLM",
		    "TapasForQuestionAnswering",
		    "TapasForSequenceClassification",
		    "TapasModel",
		    "TapasPreTrainedModel",
		    "load_tf_weights_in_tapas",
		]
try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		_lowercase : str      						=						[
		    "TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "TFTapasForMaskedLM",
		    "TFTapasForQuestionAnswering",
		    "TFTapasForSequenceClassification",
		    "TFTapasModel",
		    "TFTapasPreTrainedModel",
		]


if TYPE_CHECKING:
		from .configuration_tapas import TAPAS_PRETRAINED_CONFIG_ARCHIVE_MAP, TapasConfig
		from .tokenization_tapas import TapasTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tapas import (
				    TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TapasForMaskedLM,
				    TapasForQuestionAnswering,
				    TapasForSequenceClassification,
				    TapasModel,
				    TapasPreTrainedModel,
				    load_tf_weights_in_tapas,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_tapas import (
				    TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFTapasForMaskedLM,
				    TFTapasForQuestionAnswering,
				    TFTapasForSequenceClassification,
				    TFTapasModel,
				    TFTapasPreTrainedModel,
				)


else:
		import sys

		_lowercase : List[str]      						=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)




