



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()
A__								=						logging.get_logger(__name__)



def 			_lowerCAmelCase       (					__lowerCAmelCase  ,  __lowerCAmelCase  ,  __lowerCAmelCase      )   ->					Optional[int]:


				"""simple docstring"""

				snake_case__	:      Optional[Any]     		=	os.path.abspath(__lowerCAmelCase      )
				logger.info(f"""Converting TensorFlow checkpoint from {tf_path}"""      )
				# Load weights from TF model
				snake_case__	:      Tuple     		=	tf.train.list_variables(__lowerCAmelCase      )
				snake_case__	:      List[Any]     		=	[]
				snake_case__	:      Union[str, Any]     		=	[]
				snake_case__	:      Dict     		=	[]
				for full_name, shape in init_vars:
								# logger.info(f"Loading TF weight {name} with shape {shape}")
								snake_case__	:      Union[str, 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'
												snake_case__	:      Optional[Any]     		=	name[1:]
								# figure out how many levels deep the name is
								snake_case__	:      Optional[int]     		=	0
								for _name in name:
												if _name.startswith('''layer_with_weights'''      ):
																depth += 1
												else:
																break
								layer_depth.append(__lowerCAmelCase      )
								# read data
								snake_case__	:      Any     		=	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      )      )})"""      )
				snake_case__	:      Optional[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      ):
								snake_case__	:      Union[str, Any]     		=	full_name.split('''/'''      )
								snake_case__	:      Optional[Any]     		=	model
								snake_case__	:      Optional[int]     		=	[]
								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'''      ):
																snake_case__	:      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''']      )
																				snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''embeddings'''      )
																				snake_case__	:      Dict     		=	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      )]      )
																				snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''encoder'''      )
																				snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''layer'''      )
																				snake_case__	:      List[Any]     		=	pointer[layer_num - 4]
																elif layer_num == config.num_hidden_layers + 4:
																				# pooler layer
																				trace.extend(['''pooler''', '''dense''']      )
																				snake_case__	:      str     		=	getattr(__lowerCAmelCase  ,  '''pooler'''      )
																				snake_case__	:      Dict     		=	getattr(__lowerCAmelCase  ,  '''dense'''      )
												elif m_name == "embeddings":
																trace.append('''embeddings'''      )
																snake_case__	:      Union[str, Any]     		=	getattr(__lowerCAmelCase  ,  '''embeddings'''      )
																if layer_num == 0:
																				trace.append('''word_embeddings'''      )
																				snake_case__	:      Dict     		=	getattr(__lowerCAmelCase  ,  '''word_embeddings'''      )
																elif layer_num == 1:
																				trace.append('''position_embeddings'''      )
																				snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''position_embeddings'''      )
																elif layer_num == 2:
																				trace.append('''token_type_embeddings'''      )
																				snake_case__	:      Any     		=	getattr(__lowerCAmelCase  ,  '''token_type_embeddings'''      )
																else:
																				raise ValueError(f"""Unknown embedding layer with name {full_name}"""      )
																trace.append('''weight'''      )
																snake_case__	:      List[Any]     		=	getattr(__lowerCAmelCase  ,  '''weight'''      )
												elif m_name == "_attention_layer":
																# self-attention layer
																trace.extend(['''attention''', '''self''']      )
																snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''attention'''      )
																snake_case__	:      str     		=	getattr(__lowerCAmelCase  ,  '''self'''      )
												elif m_name == "_attention_layer_norm":
																# output attention norm
																trace.extend(['''attention''', '''output''', '''LayerNorm''']      )
																snake_case__	:      List[Any]     		=	getattr(__lowerCAmelCase  ,  '''attention'''      )
																snake_case__	:      Any     		=	getattr(__lowerCAmelCase  ,  '''output'''      )
																snake_case__	:      List[str]     		=	getattr(__lowerCAmelCase  ,  '''LayerNorm'''      )
												elif m_name == "_attention_output_dense":
																# output attention dense
																trace.extend(['''attention''', '''output''', '''dense''']      )
																snake_case__	:      Tuple     		=	getattr(__lowerCAmelCase  ,  '''attention'''      )
																snake_case__	:      str     		=	getattr(__lowerCAmelCase  ,  '''output'''      )
																snake_case__	:      Optional[Any]     		=	getattr(__lowerCAmelCase  ,  '''dense'''      )
												elif m_name == "_output_dense":
																# output dense
																trace.extend(['''output''', '''dense''']      )
																snake_case__	:      Tuple     		=	getattr(__lowerCAmelCase  ,  '''output'''      )
																snake_case__	:      Optional[Any]     		=	getattr(__lowerCAmelCase  ,  '''dense'''      )
												elif m_name == "_output_layer_norm":
																# output dense
																trace.extend(['''output''', '''LayerNorm''']      )
																snake_case__	:      List[str]     		=	getattr(__lowerCAmelCase  ,  '''output'''      )
																snake_case__	:      str     		=	getattr(__lowerCAmelCase  ,  '''LayerNorm'''      )
												elif m_name == "_key_dense":
																# attention key
																trace.append('''key'''      )
																snake_case__	:      str     		=	getattr(__lowerCAmelCase  ,  '''key'''      )
												elif m_name == "_query_dense":
																# attention query
																trace.append('''query'''      )
																snake_case__	:      List[Any]     		=	getattr(__lowerCAmelCase  ,  '''query'''      )
												elif m_name == "_value_dense":
																# attention value
																trace.append('''value'''      )
																snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''value'''      )
												elif m_name == "_intermediate_dense":
																# attention intermediate dense
																trace.extend(['''intermediate''', '''dense''']      )
																snake_case__	:      Any     		=	getattr(__lowerCAmelCase  ,  '''intermediate'''      )
																snake_case__	:      str     		=	getattr(__lowerCAmelCase  ,  '''dense'''      )
												elif m_name == "_output_layer_norm":
																# output layer norm
																trace.append('''output'''      )
																snake_case__	:      Optional[Any]     		=	getattr(__lowerCAmelCase  ,  '''output'''      )
												# weights & biases
												elif m_name in ["bias", "beta"]:
																trace.append('''bias'''      )
																snake_case__	:      Optional[Any]     		=	getattr(__lowerCAmelCase  ,  '''bias'''      )
												elif m_name in ["kernel", "gamma"]:
																trace.append('''weight'''      )
																snake_case__	:      int     		=	getattr(__lowerCAmelCase  ,  '''weight'''      )
												else:
																logger.warning(f"""Ignored {m_name}"""      )
        # for certain layers reshape is necessary
								snake_case__	:      List[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      ):
												snake_case__	:      int     		=	array.reshape(pointer.data.shape      )
								if "kernel" in full_name:
												snake_case__	:      List[Any]     		=	array.transpose()
								if pointer.shape == array.shape:
												snake_case__	:      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 			_lowerCAmelCase       (					__lowerCAmelCase  ,  __lowerCAmelCase  ,  __lowerCAmelCase      )   ->					int:


				"""simple docstring"""

				logger.info(f"""Loading model based on config from {config_path}..."""      )
				snake_case__	:      Dict     		=	BertConfig.from_json_file(__lowerCAmelCase      )
				snake_case__	:      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__":
				A__								=						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).''',
				)
				A__								=						parser.parse_args()
				convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)






def 			_lowerCAmelCase       (					__lowerCAmelCase  ,  __lowerCAmelCase      )   ->					int:


				"""simple docstring"""

				return int((input_a, input_a).count(1      ) != 0      )



def 			_lowerCAmelCase       (					)   ->					None:


				"""simple docstring"""

				assert or_gate(0  ,  0      ) == 0
				assert or_gate(0  ,  1      ) == 1
				assert or_gate(1  ,  0      ) == 1
				assert or_gate(1  ,  1      ) == 1


if __name__ == "__main__":
				print(or_gate(0, 1))
				print(or_gate(1, 0))
				print(or_gate(0, 0))
				print(or_gate(1, 1))

