





'''simple docstring'''






import re
import string

import numpy as np

import datasets


A__    :       Dict              ='''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

A__    :       Tuple              ='''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

A__    :       int              ='''
'''




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,		_KWARGS_DESCRIPTION       )
class 			UpperCAmelCase					(      datasets.Metric       ):




      def     lowercase__   (      self      :			Any  )    ->				Dict:
            return datasets.MetricInfo(
                description=_DESCRIPTION      ,      citation=_CITATION      ,      inputs_description=_KWARGS_DESCRIPTION      ,      features=datasets.Features(
                    {
                        """predictions""": datasets.Value("""string"""      ,      id="""sequence"""  ),
                        """references""": datasets.Value("""string"""      ,      id="""sequence"""  ),
                    }  )      ,      reference_urls=[]      ,      )




      def     lowercase__   (      self      :			str      ,      __snake_case      :			Tuple      ,      __snake_case      :			int      ,      __snake_case      :			Dict=None      ,      __snake_case      :			List[Any]=False      ,      __snake_case      :			Any=False      ,      __snake_case      :			Optional[Any]=False      ,      )    ->				Any:
            if regexes_to_ignore is not None:
                  for s in regexes_to_ignore:
                        _lowerCAmelCase												=							np.array([re.sub(__snake_case      ,      """"""      ,      __snake_case  ) for x in predictions]  )
                        _lowerCAmelCase												=							np.array([re.sub(__snake_case      ,      """"""      ,      __snake_case  ) for x in references]  )
            else:
                  _lowerCAmelCase												=							np.asarray(__snake_case  )
                  _lowerCAmelCase												=							np.asarray(__snake_case  )

            if ignore_case:
                  _lowerCAmelCase												=							np.char.lower(__snake_case  )
                  _lowerCAmelCase												=							np.char.lower(__snake_case  )

            if ignore_punctuation:
                  _lowerCAmelCase												=							string.punctuation.maketrans(""""""      ,      """"""      ,      string.punctuation  )
                  _lowerCAmelCase												=							np.char.translate(__snake_case      ,      table=__snake_case  )
                  _lowerCAmelCase												=							np.char.translate(__snake_case      ,      table=__snake_case  )

            if ignore_numbers:
                  _lowerCAmelCase												=							string.digits.maketrans(""""""      ,      """"""      ,      string.digits  )
                  _lowerCAmelCase												=							np.char.translate(__snake_case      ,      table=__snake_case  )
                  _lowerCAmelCase												=							np.char.translate(__snake_case      ,      table=__snake_case  )

            _lowerCAmelCase												=							predictions == references

            return {"exact_match": np.mean(__snake_case  ) * 1_00}













'''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        UpperCamelCase__				(		lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase  ):





      """simple docstring"""


      def get_masked_lm_array(lowerCAmelCase  ):
            _lowerCAmelCase												=							f"masked_lm/{name}/.ATTRIBUTES/VARIABLE_VALUE"
            _lowerCAmelCase												=							tf.train.load_variable(lowerCAmelCase							,     lowerCAmelCase  )

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

            return torch.from_numpy(lowerCAmelCase  )

      def get_encoder_array(lowerCAmelCase  ):
            _lowerCAmelCase												=							f"encoder/{name}/.ATTRIBUTES/VARIABLE_VALUE"
            _lowerCAmelCase												=							tf.train.load_variable(lowerCAmelCase							,     lowerCAmelCase  )

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

            return torch.from_numpy(lowerCAmelCase  )

      def get_encoder_layer_array(lowerCAmelCase							,     lowerCAmelCase  ):
            _lowerCAmelCase												=							f"encoder/_transformer_layers/{layer_index}/{name}/.ATTRIBUTES/VARIABLE_VALUE"
            _lowerCAmelCase												=							tf.train.load_variable(lowerCAmelCase							,     lowerCAmelCase  )

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

            return torch.from_numpy(lowerCAmelCase  )

      def get_encoder_attention_layer_array(lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase  ):
            _lowerCAmelCase												=							f"encoder/_transformer_layers/{layer_index}/_attention_layer/{name}/.ATTRIBUTES/VARIABLE_VALUE"
            _lowerCAmelCase												=							tf.train.load_variable(lowerCAmelCase							,     lowerCAmelCase  )
            _lowerCAmelCase												=							array.reshape(lowerCAmelCase  )

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

            return torch.from_numpy(lowerCAmelCase  )

      print(f"Loading model based on config from {config_path}..."  )
      _lowerCAmelCase												=							BertConfig.from_json_file(lowerCAmelCase  )
      _lowerCAmelCase												=							BertForMaskedLM(lowerCAmelCase  )

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

            # Self-attention
            _lowerCAmelCase												=							layer.attention.self

            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_query_dense/kernel"""							,     self_attn.query.weight.data.shape  )
            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_query_dense/bias"""							,     self_attn.query.bias.data.shape  )
            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_key_dense/kernel"""							,     self_attn.key.weight.data.shape  )
            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_key_dense/bias"""							,     self_attn.key.bias.data.shape  )
            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_value_dense/kernel"""							,     self_attn.value.weight.data.shape  )
            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_value_dense/bias"""							,     self_attn.value.bias.data.shape  )

            # Self-attention Output
            _lowerCAmelCase												=							layer.attention.output

            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_output_dense/kernel"""							,     self_output.dense.weight.data.shape  )
            _lowerCAmelCase												=							get_encoder_attention_layer_array(
                lowerCAmelCase							,     """_output_dense/bias"""							,     self_output.dense.bias.data.shape  )

            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_attention_layer_norm/gamma"""  )
            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_attention_layer_norm/beta"""  )

            # Intermediate
            _lowerCAmelCase												=							layer.intermediate

            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_intermediate_dense/kernel"""  )
            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_intermediate_dense/bias"""  )

            # Output
            _lowerCAmelCase												=							layer.output

            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_output_dense/kernel"""  )
            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_output_dense/bias"""  )

            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_output_layer_norm/gamma"""  )
            _lowerCAmelCase												=							get_encoder_layer_array(lowerCAmelCase							,     """_output_layer_norm/beta"""  )

      # Embeddings
      _lowerCAmelCase												=							get_encoder_array("""_position_embedding_layer/embeddings"""  )
      _lowerCAmelCase												=							get_encoder_array("""_type_embedding_layer/embeddings"""  )
      _lowerCAmelCase												=							get_encoder_array("""_embedding_norm_layer/gamma"""  )
      _lowerCAmelCase												=							get_encoder_array("""_embedding_norm_layer/beta"""  )

      # LM Head
      _lowerCAmelCase												=							model.cls.predictions.transform

      _lowerCAmelCase												=							get_masked_lm_array("""dense/kernel"""  )
      _lowerCAmelCase												=							get_masked_lm_array("""dense/bias"""  )

      _lowerCAmelCase												=							get_masked_lm_array("""layer_norm/gamma"""  )
      _lowerCAmelCase												=							get_masked_lm_array("""layer_norm/beta"""  )

      _lowerCAmelCase												=							get_masked_lm_array("""embedding_table"""  )

      # Pooling
      _lowerCAmelCase												=							BertPooler(config=lowerCAmelCase  )
      _lowerCAmelCase												=							get_encoder_array("""_pooler_layer/kernel"""  )
      _lowerCAmelCase												=							get_encoder_array("""_pooler_layer/bias"""  )

      # Export final model
      model.save_pretrained(lowerCAmelCase  )

      # Integration test - should load without any errors ;)
      _lowerCAmelCase												=							BertForMaskedLM.from_pretrained(lowerCAmelCase  )
      print(new_model.eval()  )

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


if __name__ == "__main__":
      A__    :       str              =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.''',
      )
      A__    :       Dict              =parser.parse_args()
      convert_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)






