



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







def 	lowerCamelCase_   (  _a    :		Dict					,						_a    :		Optional[Any]					,						_a    :		Tuple  ):



    '''simple docstring'''




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



    '''simple docstring'''




    logger.info(F'''Loading model based on config from {config_path}...'''  )
    UpperCAmelCase_			:    Dict   						= BertConfig.from_json_file(__lowerCAmelCase  )
    UpperCAmelCase_			:    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__":
      UpperCamelCase_										=					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_										=					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))

