


'''simple docstring'''


import argparse

import tensorflow as tf
import torch

from transformers import BertConfig, BertForMaskedLM
from transformers.models.bert.modeling_bert import (
    BertIntermediate,
    BertLayer,
    BertOutput,
    BertPooler,
    BertSelfAttention,
    BertSelfOutput,
)
from transformers.utils import logging


logging.set_verbosity_info()







def 			snake_case_   (  SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





				def get_masked_lm_array(SCREAMING_SNAKE_CASE__     ):
								_SCREAMING_SNAKE_CASE :       Dict     		=      f"""masked_lm/{name}/.ATTRIBUTES/VARIABLE_VALUE"""
								_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      tf.train.load_variable(SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     )

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE :       Optional[int]     		=      array.transpose()

								return torch.from_numpy(SCREAMING_SNAKE_CASE__     )

				def get_encoder_array(SCREAMING_SNAKE_CASE__     ):
								_SCREAMING_SNAKE_CASE :       Tuple     		=      f"""encoder/{name}/.ATTRIBUTES/VARIABLE_VALUE"""
								_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      tf.train.load_variable(SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     )

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE :       List[Any]     		=      array.transpose()

								return torch.from_numpy(SCREAMING_SNAKE_CASE__     )

				def get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     ):
								_SCREAMING_SNAKE_CASE :       List[str]     		=      f"""encoder/_transformer_layers/{layer_index}/{name}/.ATTRIBUTES/VARIABLE_VALUE"""
								_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      tf.train.load_variable(SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     )

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE :       int     		=      array.transpose()

								return torch.from_numpy(SCREAMING_SNAKE_CASE__     )

				def get_encoder_attention_layer_array(SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     ):
								_SCREAMING_SNAKE_CASE :       str     		=      f"""encoder/_transformer_layers/{layer_index}/_attention_layer/{name}/.ATTRIBUTES/VARIABLE_VALUE"""
								_SCREAMING_SNAKE_CASE :       List[str]     		=      tf.train.load_variable(SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     )
								_SCREAMING_SNAKE_CASE :       Any     		=      array.reshape(SCREAMING_SNAKE_CASE__     )

								if "kernel" in name:
												_SCREAMING_SNAKE_CASE :       int     		=      array.transpose()

								return torch.from_numpy(SCREAMING_SNAKE_CASE__     )

				print(f"""Loading model based on config from {config_path}..."""     )
				_SCREAMING_SNAKE_CASE :       str     		=      BertConfig.from_json_file(SCREAMING_SNAKE_CASE__     )
				_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      BertForMaskedLM(SCREAMING_SNAKE_CASE__     )

				# Layers
				for layer_index in range(0							,      config.num_hidden_layers     ):
								_SCREAMING_SNAKE_CASE :       BertLayer     		=      model.bert.encoder.layer[layer_index]

								# Self-attention
								_SCREAMING_SNAKE_CASE :       BertSelfAttention     		=      layer.attention.self

								_SCREAMING_SNAKE_CASE :       List[str]     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_query_dense/kernel"""							,      self_attn.query.weight.data.shape     )
								_SCREAMING_SNAKE_CASE :       List[str]     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_query_dense/bias"""							,      self_attn.query.bias.data.shape     )
								_SCREAMING_SNAKE_CASE :       List[Any]     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_key_dense/kernel"""							,      self_attn.key.weight.data.shape     )
								_SCREAMING_SNAKE_CASE :       List[str]     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_key_dense/bias"""							,      self_attn.key.bias.data.shape     )
								_SCREAMING_SNAKE_CASE :       Tuple     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_value_dense/kernel"""							,      self_attn.value.weight.data.shape     )
								_SCREAMING_SNAKE_CASE :       Optional[int]     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_value_dense/bias"""							,      self_attn.value.bias.data.shape     )

								# Self-attention Output
								_SCREAMING_SNAKE_CASE :       BertSelfOutput     		=      layer.attention.output

								_SCREAMING_SNAKE_CASE :       int     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_output_dense/kernel"""							,      self_output.dense.weight.data.shape     )
								_SCREAMING_SNAKE_CASE :       Dict     		=      get_encoder_attention_layer_array(
								    SCREAMING_SNAKE_CASE__							,      """_output_dense/bias"""							,      self_output.dense.bias.data.shape     )

								_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_attention_layer_norm/gamma"""     )
								_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_attention_layer_norm/beta"""     )

								# Intermediate
								_SCREAMING_SNAKE_CASE :       BertIntermediate     		=      layer.intermediate

								_SCREAMING_SNAKE_CASE :       List[Any]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_intermediate_dense/kernel"""     )
								_SCREAMING_SNAKE_CASE :       List[str]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_intermediate_dense/bias"""     )

								# Output
								_SCREAMING_SNAKE_CASE :       BertOutput     		=      layer.output

								_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_output_dense/kernel"""     )
								_SCREAMING_SNAKE_CASE :       int     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_output_dense/bias"""     )

								_SCREAMING_SNAKE_CASE :       List[Any]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_output_layer_norm/gamma"""     )
								_SCREAMING_SNAKE_CASE :       Optional[int]     		=      get_encoder_layer_array(SCREAMING_SNAKE_CASE__							,      """_output_layer_norm/beta"""     )

				# Embeddings
				_SCREAMING_SNAKE_CASE :       Optional[int]     		=      get_encoder_array("""_position_embedding_layer/embeddings"""     )
				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      get_encoder_array("""_type_embedding_layer/embeddings"""     )
				_SCREAMING_SNAKE_CASE :       str     		=      get_encoder_array("""_embedding_norm_layer/gamma"""     )
				_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      get_encoder_array("""_embedding_norm_layer/beta"""     )

				# LM Head
				_SCREAMING_SNAKE_CASE :       Any     		=      model.cls.predictions.transform

				_SCREAMING_SNAKE_CASE :       str     		=      get_masked_lm_array("""dense/kernel"""     )
				_SCREAMING_SNAKE_CASE :       List[str]     		=      get_masked_lm_array("""dense/bias"""     )

				_SCREAMING_SNAKE_CASE :       Dict     		=      get_masked_lm_array("""layer_norm/gamma"""     )
				_SCREAMING_SNAKE_CASE :       Dict     		=      get_masked_lm_array("""layer_norm/beta"""     )

				_SCREAMING_SNAKE_CASE :       Optional[int]     		=      get_masked_lm_array("""embedding_table"""     )

				# Pooling
				_SCREAMING_SNAKE_CASE :       Dict     		=      BertPooler(config=SCREAMING_SNAKE_CASE__     )
				_SCREAMING_SNAKE_CASE :       BertPooler     		=      get_encoder_array("""_pooler_layer/kernel"""     )
				_SCREAMING_SNAKE_CASE :       BertPooler     		=      get_encoder_array("""_pooler_layer/bias"""     )

				# Export final model
				model.save_pretrained(SCREAMING_SNAKE_CASE__     )

				# Integration test - should load without any errors ;)
				_SCREAMING_SNAKE_CASE :       List[Any]     		=      BertForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE__     )
				print(new_model.eval()     )

				print("""Model conversion was done sucessfully!"""     )


if __name__ == "__main__":
				UpperCAmelCase_		:   Any							   =		argparse.ArgumentParser()
				parser.add_argument(
				    '--tf_checkpoint_path', type=str, required=True, help='Path to the TensorFlow Token Dropping 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.',
				)
				UpperCAmelCase_		:   Dict							   =		parser.parse_args()
				convert_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)








'''simple docstring'''


def 			snake_case_   (  SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     ):







				"""simple docstring"""





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







def 			snake_case_   (  ):







				"""simple docstring"""





				assert nand_gate(0							,      0     ) == 1
				assert nand_gate(0							,      1     ) == 1
				assert nand_gate(1							,      0     ) == 1
				assert nand_gate(1							,      1     ) == 0


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




