






'''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()
UpperCAmelCase__						:Optional[Any]          =			logging.get_logger(__name__)
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     Optional[int]:


					"""simple docstring"""
					__lowerCamelCase						:       Optional[int]				   =				os.path.abspath(_lowercase     )
					logger.info(f"Converting TensorFlow checkpoint from {tf_path}"     )
					# Load weights from TF model
					__lowerCamelCase						:       str				   =				tf.train.list_variables(_lowercase     )
					__lowerCamelCase						:       int				   =				[]
					__lowerCamelCase						:       Optional[int]				   =				[]
					__lowerCamelCase						:       str				   =				[]
					for full_name, shape in init_vars:
										# logger.info(f"Loading TF weight {name} with shape {shape}")
										__lowerCamelCase						:       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						:       int				   =				name[1:]
										# figure out how many levels deep the name is
										__lowerCamelCase						:       int				   =				0
										for _name in name:
															if _name.startswith("""layer_with_weights"""     ):
																				depth += 1
															else:
																				break
										layer_depth.append(_lowercase     )
										# read data
										__lowerCamelCase						:       Optional[Any]				   =				tf.train.load_variable(_lowercase,						_lowercase     )
										names.append("""/""".join(_lowercase     )     )
										arrays.append(_lowercase     )
					logger.info(f"Read a total of {len(_lowercase     ):,} layers"     )

					# Sanity check
					if len(set(_lowercase     )     ) != 1:
										raise ValueError(f"Found layer names with different depths (layer depth {list(set(_lowercase     )     )})"     )
					__lowerCamelCase						:       Union[str, Any]				   =				list(set(_lowercase     )     )[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(_lowercase,						_lowercase     ):
										__lowerCamelCase						:       int				   =				full_name.split("""/"""     )
										__lowerCamelCase						:       Tuple				   =				model
										__lowerCamelCase						:       Union[str, Any]				   =				[]
										for i, m_name in enumerate(_lowercase     ):
															if m_name == ".ATTRIBUTES":
																				# variable names end with .ATTRIBUTES/VARIABLE_VALUE
																				break
															if m_name.startswith("""layer_with_weights"""     ):
																				__lowerCamelCase						:       Optional[int]				   =				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(_lowercase,						"""embeddings"""     )
																									__lowerCamelCase						:       Dict				   =				getattr(_lowercase,						"""LayerNorm"""     )
																				elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
																									# encoder layers
																									trace.extend(["""encoder""", """layer""", str(layer_num - 4     )]     )
																									__lowerCamelCase						:       Optional[Any]				   =				getattr(_lowercase,						"""encoder"""     )
																									__lowerCamelCase						:       Any				   =				getattr(_lowercase,						"""layer"""     )
																									__lowerCamelCase						:       List[str]				   =				pointer[layer_num - 4]
																				elif layer_num == config.num_hidden_layers + 4:
																									# pooler layer
																									trace.extend(["""pooler""", """dense"""]     )
																									__lowerCamelCase						:       Any				   =				getattr(_lowercase,						"""pooler"""     )
																									__lowerCamelCase						:       List[Any]				   =				getattr(_lowercase,						"""dense"""     )
															elif m_name == "embeddings":
																				trace.append("""embeddings"""     )
																				__lowerCamelCase						:       Tuple				   =				getattr(_lowercase,						"""embeddings"""     )
																				if layer_num == 0:
																									trace.append("""word_embeddings"""     )
																									__lowerCamelCase						:       Optional[int]				   =				getattr(_lowercase,						"""word_embeddings"""     )
																				elif layer_num == 1:
																									trace.append("""position_embeddings"""     )
																									__lowerCamelCase						:       Optional[int]				   =				getattr(_lowercase,						"""position_embeddings"""     )
																				elif layer_num == 2:
																									trace.append("""token_type_embeddings"""     )
																									__lowerCamelCase						:       str				   =				getattr(_lowercase,						"""token_type_embeddings"""     )
																				else:
																									raise ValueError(f"Unknown embedding layer with name {full_name}"     )
																				trace.append("""weight"""     )
																				__lowerCamelCase						:       List[str]				   =				getattr(_lowercase,						"""weight"""     )
															elif m_name == "_attention_layer":
																				# self-attention layer
																				trace.extend(["""attention""", """self"""]     )
																				__lowerCamelCase						:       Optional[Any]				   =				getattr(_lowercase,						"""attention"""     )
																				__lowerCamelCase						:       List[Any]				   =				getattr(_lowercase,						"""self"""     )
															elif m_name == "_attention_layer_norm":
																				# output attention norm
																				trace.extend(["""attention""", """output""", """LayerNorm"""]     )
																				__lowerCamelCase						:       Union[str, Any]				   =				getattr(_lowercase,						"""attention"""     )
																				__lowerCamelCase						:       List[str]				   =				getattr(_lowercase,						"""output"""     )
																				__lowerCamelCase						:       Union[str, Any]				   =				getattr(_lowercase,						"""LayerNorm"""     )
															elif m_name == "_attention_output_dense":
																				# output attention dense
																				trace.extend(["""attention""", """output""", """dense"""]     )
																				__lowerCamelCase						:       int				   =				getattr(_lowercase,						"""attention"""     )
																				__lowerCamelCase						:       str				   =				getattr(_lowercase,						"""output"""     )
																				__lowerCamelCase						:       int				   =				getattr(_lowercase,						"""dense"""     )
															elif m_name == "_output_dense":
																				# output dense
																				trace.extend(["""output""", """dense"""]     )
																				__lowerCamelCase						:       str				   =				getattr(_lowercase,						"""output"""     )
																				__lowerCamelCase						:       Dict				   =				getattr(_lowercase,						"""dense"""     )
															elif m_name == "_output_layer_norm":
																				# output dense
																				trace.extend(["""output""", """LayerNorm"""]     )
																				__lowerCamelCase						:       Optional[Any]				   =				getattr(_lowercase,						"""output"""     )
																				__lowerCamelCase						:       Any				   =				getattr(_lowercase,						"""LayerNorm"""     )
															elif m_name == "_key_dense":
																				# attention key
																				trace.append("""key"""     )
																				__lowerCamelCase						:       List[str]				   =				getattr(_lowercase,						"""key"""     )
															elif m_name == "_query_dense":
																				# attention query
																				trace.append("""query"""     )
																				__lowerCamelCase						:       Optional[int]				   =				getattr(_lowercase,						"""query"""     )
															elif m_name == "_value_dense":
																				# attention value
																				trace.append("""value"""     )
																				__lowerCamelCase						:       Union[str, Any]				   =				getattr(_lowercase,						"""value"""     )
															elif m_name == "_intermediate_dense":
																				# attention intermediate dense
																				trace.extend(["""intermediate""", """dense"""]     )
																				__lowerCamelCase						:       List[Any]				   =				getattr(_lowercase,						"""intermediate"""     )
																				__lowerCamelCase						:       Any				   =				getattr(_lowercase,						"""dense"""     )
															elif m_name == "_output_layer_norm":
																				# output layer norm
																				trace.append("""output"""     )
																				__lowerCamelCase						:       Any				   =				getattr(_lowercase,						"""output"""     )
															# weights & biases
															elif m_name in ["bias", "beta"]:
																				trace.append("""bias"""     )
																				__lowerCamelCase						:       int				   =				getattr(_lowercase,						"""bias"""     )
															elif m_name in ["kernel", "gamma"]:
																				trace.append("""weight"""     )
																				__lowerCamelCase						:       int				   =				getattr(_lowercase,						"""weight"""     )
															else:
																				logger.warning(f"Ignored {m_name}"     )
        # for certain layers reshape is necessary
										__lowerCamelCase						:       Tuple				   =				""".""".join(_lowercase     )
										if re.match(R"""(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)""",						_lowercase     ) or re.match(
										    R"""(\S+)\.attention\.output\.dense\.weight""",						_lowercase     ):
															__lowerCamelCase						:       List[Any]				   =				array.reshape(pointer.data.shape     )
										if "kernel" in full_name:
															__lowerCamelCase						:       List[Any]				   =				array.transpose()
										if pointer.shape == array.shape:
															__lowerCamelCase						:       Any				   =				torch.from_numpy(_lowercase     )
										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     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     Union[str, Any]:


					"""simple docstring"""
					logger.info(f"Loading model based on config from {config_path}..."     )
					__lowerCamelCase						:       str				   =				BertConfig.from_json_file(_lowercase     )
					__lowerCamelCase						:       str				   =				BertModel(_lowercase     )

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

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


if __name__ == "__main__":
			UpperCAmelCase__						:Tuple          =			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).""",
			)
			UpperCAmelCase__						:Optional[int]          =			parser.parse_args()
			convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)











'''simple docstring'''

def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # bit count represents no. of bits in the gray code
     if bit_count < 0:
          raise ValueError("""The given input must be positive"""     )

     # get the generated string sequence
     __lowerCamelCase						:       Optional[Any]				   =				gray_code_sequence_string(_lowercase     )
     #
     # convert them to integers
     for i in range(len(_lowercase     )     ):
          __lowerCamelCase						:       List[str]				   =				int(sequence[i],						2     )

     return sequence
def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # The approach is a recursive one
     # Base case achieved when either n = 0 or n=1
     if bit_count == 0:
          return ["0"]

     if bit_count == 1:
          return ["0", "1"]

     __lowerCamelCase						:       str				   =				1 << bit_count  # defines the length of the sequence
     # 1<< n is equivalent to 2^n

     # recursive answer will generate answer for n-1 bits
     __lowerCamelCase						:       Union[str, Any]				   =				gray_code_sequence_string(bit_count - 1     )

     __lowerCamelCase						:       Optional[int]				   =				[]

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2     ):
          __lowerCamelCase						:       Union[str, Any]				   =				"""0""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     # append 1 to second half ... start from the end of the list
     for i in reversed(range(seq_len // 2     )     ):
          __lowerCamelCase						:       Optional[Any]				   =				"""1""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     return sequence


if __name__ == "__main__":
   import doctest

   doctest.testmod()



