



"""simple docstring"""







import argparse
import os

import gluonnlp as nlp
import mxnet as mx
import numpy as np
import torch
from gluonnlp.base import get_home_dir
from gluonnlp.model.bert import BERTEncoder
from gluonnlp.model.utils import _load_vocab
from gluonnlp.vocab import Vocab
from packaging import version
from torch import nn

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


if version.parse(nlp.__version__) != version.parse("""0.8.3"""):
     raise Exception("""requires gluonnlp == 0.8.3""")

if version.parse(mx.__version__) != version.parse("""1.5.0"""):
     raise Exception("""requires mxnet == 1.5.0""")

logging.set_verbosity_info()
lowercase__		:    int				   =     logging.get_logger(__name__)

lowercase__		:    Tuple				   =     """The Nymphenburg Palace is a beautiful palace in Munich!"""

def     UpperCamelCase_   (   lowerCAmelCase__				:    str   ,       lowerCAmelCase__				:    str						)						->       Optional[int]:

  """simple docstring"""




  lowerCAmelCase_       :    Dict								=			{
      """attention_cell""": """multi_head""",
      """num_layers""": 4,
      """units""": 1024,
      """hidden_size""": 768,
      """max_length""": 512,
      """num_heads""": 8,
      """scaled""": True,
      """dropout""": 0.1,
      """use_residual""": True,
      """embed_size""": 1024,
      """embed_dropout""": 0.1,
      """word_embed""": None,
      """layer_norm_eps""": 1e-5,
      """token_type_vocab_size""": 2,
  }

  lowerCAmelCase_       :    Union[str, Any]								=			bort_4_8_768_1024_hparams

  # Let's construct the original Bort model here
  # Taken from official BERT implementation, see:
  # https://github.com/alexa/bort/blob/master/bort/bort.py
  lowerCAmelCase_       :    List[Any]								=			BERTEncoder(
      attention_cell=predefined_args['attention_cell']   ,       num_layers=predefined_args['num_layers']   ,       units=predefined_args['units']   ,       hidden_size=predefined_args['hidden_size']   ,       max_length=predefined_args['max_length']   ,       num_heads=predefined_args['num_heads']   ,       scaled=predefined_args['scaled']   ,       dropout=predefined_args['dropout']   ,       output_attention=lowerCAmelCase__   ,       output_all_encodings=lowerCAmelCase__   ,       use_residual=predefined_args['use_residual']   ,       activation=predefined_args.get('activation'   ,       'gelu'						)   ,       layer_norm_eps=predefined_args.get('layer_norm_eps'   ,       lowerCAmelCase__						)   ,       )

  # Vocab information needs to be fetched first
  # It's the same as RoBERTa, so RobertaTokenizer can be used later
  lowerCAmelCase_       :    Any								=			"""openwebtext_ccnews_stories_books_cased"""

  # Specify download folder to Gluonnlp's vocab
  lowerCAmelCase_       :    List[str]								=			os.path.join(get_home_dir()   ,       'models'						)
  lowerCAmelCase_       :    Union[str, Any]								=			_load_vocab(lowerCAmelCase__   ,       lowerCAmelCase__   ,       lowerCAmelCase__   ,       cls=lowerCAmelCase__						)

  lowerCAmelCase_       :    List[str]								=			nlp.model.BERTModel(
      lowerCAmelCase__   ,       len(lowerCAmelCase__						)   ,       units=predefined_args['units']   ,       embed_size=predefined_args['embed_size']   ,       embed_dropout=predefined_args['embed_dropout']   ,       word_embed=predefined_args['word_embed']   ,       use_pooler=lowerCAmelCase__   ,       use_token_type_embed=lowerCAmelCase__   ,       token_type_vocab_size=predefined_args['token_type_vocab_size']   ,       use_classifier=lowerCAmelCase__   ,       use_decoder=lowerCAmelCase__   ,       )

  original_bort.load_parameters(lowerCAmelCase__   ,       cast_dtype=lowerCAmelCase__   ,       ignore_extra=lowerCAmelCase__						)
  lowerCAmelCase_       :    Union[str, Any]								=			original_bort._collect_params_with_prefix()

  # Build our config 🤗
  lowerCAmelCase_       :    str								=			{
      """architectures""": ["""BertForMaskedLM"""],
      """attention_probs_dropout_prob""": predefined_args["""dropout"""],
      """hidden_act""": """gelu""",
      """hidden_dropout_prob""": predefined_args["""dropout"""],
      """hidden_size""": predefined_args["""embed_size"""],
      """initializer_range""": 0.02,
      """intermediate_size""": predefined_args["""hidden_size"""],
      """layer_norm_eps""": predefined_args["""layer_norm_eps"""],
      """max_position_embeddings""": predefined_args["""max_length"""],
      """model_type""": """bort""",
      """num_attention_heads""": predefined_args["""num_heads"""],
      """num_hidden_layers""": predefined_args["""num_layers"""],
      """pad_token_id""": 1,  # 2 = BERT, 1 = RoBERTa
      """type_vocab_size""": 1,  # 2 = BERT, 1 = RoBERTa
      """vocab_size""": len(lowerCAmelCase__						),
  }

  lowerCAmelCase_       :    Tuple								=			BertConfig.from_dict(lowerCAmelCase__						)
  lowerCAmelCase_       :    str								=			BertForMaskedLM(lowerCAmelCase__						)
  hf_bort_model.eval()

  # Parameter mapping table (Gluonnlp to Transformers)
  # * denotes layer index
  #
  # | Gluon Parameter                                                | Transformers Parameter
  # | -------------------------------------------------------------- | ----------------------
  # | `encoder.layer_norm.beta`                                      | `bert.embeddings.LayerNorm.bias`
  # | `encoder.layer_norm.gamma`                                     | `bert.embeddings.LayerNorm.weight`
  # | `encoder.position_weight`                                      | `bert.embeddings.position_embeddings.weight`
  # | `word_embed.0.weight`                                          | `bert.embeddings.word_embeddings.weight`
  # | `encoder.transformer_cells.*.attention_cell.proj_key.bias`     | `bert.encoder.layer.*.attention.self.key.bias`
  # | `encoder.transformer_cells.*.attention_cell.proj_key.weight`   | `bert.encoder.layer.*.attention.self.key.weight`
  # | `encoder.transformer_cells.*.attention_cell.proj_query.bias`   | `bert.encoder.layer.*.attention.self.query.bias`
  # | `encoder.transformer_cells.*.attention_cell.proj_query.weight` | `bert.encoder.layer.*.attention.self.query.weight`
  # | `encoder.transformer_cells.*.attention_cell.proj_value.bias`   | `bert.encoder.layer.*.attention.self.value.bias`
  # | `encoder.transformer_cells.*.attention_cell.proj_value.weight` | `bert.encoder.layer.*.attention.self.value.weight`
  # | `encoder.transformer_cells.*.ffn.ffn_2.bias`                   | `bert.encoder.layer.*.attention.output.dense.bias`
  # | `encoder.transformer_cells.*.ffn.ffn_2.weight`                 | `bert.encoder.layer.*.attention.output.dense.weight`
  # | `encoder.transformer_cells.*.layer_norm.beta`                  | `bert.encoder.layer.*.attention.output.LayerNorm.bias`
  # | `encoder.transformer_cells.*.layer_norm.gamma`                 | `bert.encoder.layer.*.attention.output.LayerNorm.weight`
  # | `encoder.transformer_cells.*.ffn.ffn_1.bias`                   | `bert.encoder.layer.*.intermediate.dense.bias`
  # | `encoder.transformer_cells.*.ffn.ffn_1.weight`                 | `bert.encoder.layer.*.intermediate.dense.weight`
  # | `encoder.transformer_cells.*.ffn.layer_norm.beta`              | `bert.encoder.layer.*.output.LayerNorm.bias`
  # | `encoder.transformer_cells.*.ffn.layer_norm.gamma`             | `bert.encoder.layer.*.output.LayerNorm.weight`
  # | `encoder.transformer_cells.*.proj.bias`                        | `bert.encoder.layer.*.output.dense.bias`
  # | `encoder.transformer_cells.*.proj.weight`                      | `bert.encoder.layer.*.output.dense.weight`

  # Helper function to convert MXNET Arrays to PyTorch
  def to_torch(lowerCAmelCase__				:    List[str]						) -> nn.Parameter:
    return nn.Parameter(torch.FloatTensor(mx_array.data().asnumpy()						)						)

  # Check param shapes and map new HF param back
  def check_and_map_params(lowerCAmelCase__				:    str   ,       lowerCAmelCase__				:    Optional[int]						):
    lowerCAmelCase_       :    Union[str, Any]								=			hf_param.shape

    lowerCAmelCase_       :    Optional[int]								=			to_torch(params[gluon_param]						)
    lowerCAmelCase_       :    List[Any]								=			gluon_param.shape

    assert (
        shape_hf == shape_gluon
    ), f"The gluon parameter {gluon_param} has shape {shape_gluon}, but expects shape {shape_hf} for Transformers"

    return gluon_param

  lowerCAmelCase_       :    List[str]								=			check_and_map_params(
      hf_bort_model.bert.embeddings.word_embeddings.weight   ,       'word_embed.0.weight'						)
  lowerCAmelCase_       :    Any								=			check_and_map_params(
      hf_bort_model.bert.embeddings.position_embeddings.weight   ,       'encoder.position_weight'						)
  lowerCAmelCase_       :    List[str]								=			check_and_map_params(
      hf_bort_model.bert.embeddings.LayerNorm.bias   ,       'encoder.layer_norm.beta'						)
  lowerCAmelCase_       :    List[Any]								=			check_and_map_params(
      hf_bort_model.bert.embeddings.LayerNorm.weight   ,       'encoder.layer_norm.gamma'						)

  # Inspired by RoBERTa conversion script, we just zero them out (Bort does not use them)
  lowerCAmelCase_       :    List[Any]								=			torch.zeros_like(
      hf_bort_model.bert.embeddings.token_type_embeddings.weight.data						)

  for i in range(hf_bort_config.num_hidden_layers						):
    lowerCAmelCase_       :    BertLayer								=			hf_bort_model.bert.encoder.layer[i]

    # self attention
    lowerCAmelCase_       :    BertSelfAttention								=			layer.attention.self

    lowerCAmelCase_       :    Any								=			check_and_map_params(
        self_attn.key.bias.data   ,       f"encoder.transformer_cells.{i}.attention_cell.proj_key.bias"						)

    lowerCAmelCase_       :    Any								=			check_and_map_params(
        self_attn.key.weight.data   ,       f"encoder.transformer_cells.{i}.attention_cell.proj_key.weight"						)
    lowerCAmelCase_       :    Optional[int]								=			check_and_map_params(
        self_attn.query.bias.data   ,       f"encoder.transformer_cells.{i}.attention_cell.proj_query.bias"						)
    lowerCAmelCase_       :    Dict								=			check_and_map_params(
        self_attn.query.weight.data   ,       f"encoder.transformer_cells.{i}.attention_cell.proj_query.weight"						)
    lowerCAmelCase_       :    Optional[Any]								=			check_and_map_params(
        self_attn.value.bias.data   ,       f"encoder.transformer_cells.{i}.attention_cell.proj_value.bias"						)
    lowerCAmelCase_       :    List[Any]								=			check_and_map_params(
        self_attn.value.weight.data   ,       f"encoder.transformer_cells.{i}.attention_cell.proj_value.weight"						)

    # self attention output
    lowerCAmelCase_       :    BertSelfOutput								=			layer.attention.output

    lowerCAmelCase_       :    str								=			check_and_map_params(
        self_output.dense.bias   ,       f"encoder.transformer_cells.{i}.proj.bias"						)
    lowerCAmelCase_       :    List[str]								=			check_and_map_params(
        self_output.dense.weight   ,       f"encoder.transformer_cells.{i}.proj.weight"						)
    lowerCAmelCase_       :    Optional[int]								=			check_and_map_params(
        self_output.LayerNorm.bias   ,       f"encoder.transformer_cells.{i}.layer_norm.beta"						)
    lowerCAmelCase_       :    str								=			check_and_map_params(
        self_output.LayerNorm.weight   ,       f"encoder.transformer_cells.{i}.layer_norm.gamma"						)

    # intermediate
    lowerCAmelCase_       :    BertIntermediate								=			layer.intermediate

    lowerCAmelCase_       :    Union[str, Any]								=			check_and_map_params(
        intermediate.dense.bias   ,       f"encoder.transformer_cells.{i}.ffn.ffn_1.bias"						)
    lowerCAmelCase_       :    List[str]								=			check_and_map_params(
        intermediate.dense.weight   ,       f"encoder.transformer_cells.{i}.ffn.ffn_1.weight"						)

    # output
    lowerCAmelCase_       :    BertOutput								=			layer.output

    lowerCAmelCase_       :    List[Any]								=			check_and_map_params(
        bert_output.dense.bias   ,       f"encoder.transformer_cells.{i}.ffn.ffn_2.bias"						)
    lowerCAmelCase_       :    Any								=			check_and_map_params(
        bert_output.dense.weight   ,       f"encoder.transformer_cells.{i}.ffn.ffn_2.weight"						)
    lowerCAmelCase_       :    Tuple								=			check_and_map_params(
        bert_output.LayerNorm.bias   ,       f"encoder.transformer_cells.{i}.ffn.layer_norm.beta"						)
    lowerCAmelCase_       :    Tuple								=			check_and_map_params(
        bert_output.LayerNorm.weight   ,       f"encoder.transformer_cells.{i}.ffn.layer_norm.gamma"						)

  # Save space and energy 🎄
  hf_bort_model.half()

  # Compare output of both models
  lowerCAmelCase_       :    List[str]								=			RobertaTokenizer.from_pretrained('roberta-base'						)

  lowerCAmelCase_       :    Dict								=			tokenizer.encode_plus(lowerCAmelCase__						)["""input_ids"""]

  # Get gluon output
  lowerCAmelCase_       :    int								=			mx.nd.array([input_ids]						)
  lowerCAmelCase_       :    int								=			original_bort(inputs=lowerCAmelCase__   ,       token_types=[]						)

  # Get Transformer output (save and reload model again)
  hf_bort_model.save_pretrained(lowerCAmelCase__						)
  lowerCAmelCase_       :    Optional[Any]								=			BertModel.from_pretrained(lowerCAmelCase__						)
  hf_bort_model.eval()

  lowerCAmelCase_       :    Optional[int]								=			tokenizer.encode_plus(lowerCAmelCase__   ,       return_tensors='pt'						)
  lowerCAmelCase_       :    Dict								=			hf_bort_model(**lowerCAmelCase__						)[0]

  lowerCAmelCase_       :    int								=			output_gluon[0].asnumpy()
  lowerCAmelCase_       :    str								=			output_hf[0].detach().numpy()

  lowerCAmelCase_       :    Optional[Any]								=			np.max(np.abs(hf_layer - gluon_layer						)						).item()
  lowerCAmelCase_       :    Any								=			np.allclose(lowerCAmelCase__   ,       lowerCAmelCase__   ,       atol=1e-3						)

  if success:
    print('✔️ Both model do output the same tensors'						)
  else:
    print('❌ Both model do **NOT** output the same tensors'						)
    print('Absolute difference is:'   ,       lowerCAmelCase__						)


if __name__ == "__main__":
     lowercase__		:    Any				   =     argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         """--bort_checkpoint_path""", default=None, type=str, required=True, help="""Path the official Bort params file."""
     )
     parser.add_argument(
         """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
     )
     lowercase__		:    List[str]				   =     parser.parse_args()
     convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)










"""simple docstring"""







import re

def     UpperCamelCase_   (   lowerCAmelCase__				:    str						)						->       bool:

  """simple docstring"""




  lowerCAmelCase_       :    str								=			re.compile(
      R'^(?:0|94|\+94|0{2}94)' R'7(0|1|2|4|5|6|7|8)' R'(-| |)' R'\d{7}$'						)

  return bool(re.search(lowerCAmelCase__   ,       lowerCAmelCase__						)						)


if __name__ == "__main__":
     lowercase__		:    Optional[int]				   =     """0094702343221"""

     print(is_sri_lankan_phone_number(phone))





