


import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402


_SCREAMING_SNAKE_CASE     :					List[Any]      =       {
    "return_dict": False,
    "output_hidden_states": True,
    "output_attentions": True,
    "torchscript": True,
    "torch_dtype": "float16",
    "use_bfloat16": True,
    "tf_legacy_loss": True,
    "pruned_heads": {"a": 1},
    "tie_word_embeddings": False,
    "is_decoder": True,
    "cross_attention_hidden_size": 1_28,
    "add_cross_attention": True,
    "tie_encoder_decoder": True,
    "max_length": 50,
    "min_length": 3,
    "do_sample": True,
    "early_stopping": True,
    "num_beams": 3,
    "num_beam_groups": 3,
    "diversity_penalty": 0.5,
    "temperature": 2.0,
    "top_k": 10,
    "top_p": 0.7,
    "typical_p": 0.2,
    "repetition_penalty": 0.8,
    "length_penalty": 0.8,
    "no_repeat_ngram_size": 5,
    "encoder_no_repeat_ngram_size": 5,
    "bad_words_ids": [1, 2, 3],
    "num_return_sequences": 3,
    "chunk_size_feed_forward": 5,
    "output_scores": True,
    "return_dict_in_generate": True,
    "forced_bos_token_id": 2,
    "forced_eos_token_id": 3,
    "remove_invalid_values": True,
    "architectures": ["BertModel"],
    "finetuning_task": "translation",
    "id2label": {0: "label"},
    "label2id": {"label": "0"},
    "tokenizer_class": "BertTokenizerFast",
    "prefix": "prefix",
    "bos_token_id": 6,
    "pad_token_id": 7,
    "eos_token_id": 8,
    "sep_token_id": 9,
    "decoder_start_token_id": 10,
    "exponential_decay_length_penalty": (5, 1.01),
    "suppress_tokens": [0, 1],
    "begin_suppress_tokens": 2,
    "task_specific_params": {"translation": "some_params"},
    "problem_type": "regression",
}

@is_staging_test
class     A__   (       unittest.TestCase      ):







    """simple docstring"""

    @classmethod
    def 						a_     (			cls       ):
         snake_case											=							TOKEN
         HfFolder.save_token(__snake_case       )
    @classmethod
    def 						a_     (			cls       ):
         try:
              delete_repo(token=cls._token     ,   repo_id='''test-config'''       )
         except HTTPError:
              pass

         try:
              delete_repo(token=cls._token     ,   repo_id='''valid_org/test-config-org'''       )
         except HTTPError:
              pass

         try:
              delete_repo(token=cls._token     ,   repo_id='''test-dynamic-config'''       )
         except HTTPError:
              pass
    def 						a_     (			self       ):
         snake_case											=							BertConfig(
             vocab_size=9_9     ,   hidden_size=3_2     ,   num_hidden_layers=5     ,   num_attention_heads=4     ,   intermediate_size=3_7       )
         config.push_to_hub('''test-config'''     ,   use_auth_token=self._token       )

         snake_case											=							BertConfig.from_pretrained(F'''{USER}/test-config'''       )
         for k, v in config.to_dict().items():
              if k != "transformers_version":
                   self.assertEqual(__snake_case     ,   getattr(__snake_case     ,   __snake_case       )       )

        # Reset repo
         delete_repo(token=self._token     ,   repo_id='''test-config'''       )

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
              config.save_pretrained(__snake_case     ,   repo_id='''test-config'''     ,   push_to_hub=__snake_case     ,   use_auth_token=self._token       )

         snake_case											=							BertConfig.from_pretrained(F'''{USER}/test-config'''       )
         for k, v in config.to_dict().items():
              if k != "transformers_version":
                   self.assertEqual(__snake_case     ,   getattr(__snake_case     ,   __snake_case       )       )
    def 						a_     (			self       ):
         snake_case											=							BertConfig(
             vocab_size=9_9     ,   hidden_size=3_2     ,   num_hidden_layers=5     ,   num_attention_heads=4     ,   intermediate_size=3_7       )
         config.push_to_hub('''valid_org/test-config-org'''     ,   use_auth_token=self._token       )

         snake_case											=							BertConfig.from_pretrained('''valid_org/test-config-org'''       )
         for k, v in config.to_dict().items():
              if k != "transformers_version":
                   self.assertEqual(__snake_case     ,   getattr(__snake_case     ,   __snake_case       )       )

        # Reset repo
         delete_repo(token=self._token     ,   repo_id='''valid_org/test-config-org'''       )

         # Push to hub via save_pretrained
         with tempfile.TemporaryDirectory() as tmp_dir:
              config.save_pretrained(
                  __snake_case     ,   repo_id='''valid_org/test-config-org'''     ,   push_to_hub=__snake_case     ,   use_auth_token=self._token       )

         snake_case											=							BertConfig.from_pretrained('''valid_org/test-config-org'''       )
         for k, v in config.to_dict().items():
              if k != "transformers_version":
                   self.assertEqual(__snake_case     ,   getattr(__snake_case     ,   __snake_case       )       )




    def 						a_     (			self       ):
         CustomConfig.register_for_auto_class()
         snake_case											=							CustomConfig(attribute=4_2       )

         config.push_to_hub('''test-dynamic-config'''     ,   use_auth_token=self._token       )

         # This has added the proper auto_map field to the config
         self.assertDictEqual(config.auto_map     ,   {'''AutoConfig''': '''custom_configuration.CustomConfig'''}       )

         snake_case											=							AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''     ,   trust_remote_code=__snake_case       )
         # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
         self.assertEqual(new_config.__class__.__name__     ,   '''CustomConfig'''       )
         self.assertEqual(new_config.attribute     ,   4_2       )






class     A__   (       unittest.TestCase      ):







    """simple docstring"""

    def 						a_     (			self       ):
         snake_case											=							GPTaConfig()

         # attempt to modify each of int/float/bool/str config records and verify they were updated
         snake_case											=							c.n_embd + 1  # int
         snake_case											=							c.resid_pdrop + 1.0  # float
         snake_case											=							not c.scale_attn_weights  # bool
         snake_case											=							c.summary_type + '''foo'''  # str
         c.update_from_string(
             F'''n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'''       )
         self.assertEqual(__snake_case     ,   c.n_embd     ,   '''mismatch for key: n_embd'''       )
         self.assertEqual(__snake_case     ,   c.resid_pdrop     ,   '''mismatch for key: resid_pdrop'''       )
         self.assertEqual(__snake_case     ,   c.scale_attn_weights     ,   '''mismatch for key: scale_attn_weights'''       )
         self.assertEqual(__snake_case     ,   c.summary_type     ,   '''mismatch for key: summary_type'''       )
    def 						a_     (			self       ):
         snake_case											=							PretrainedConfig()
         snake_case											=							[key for key in base_config.__dict__ if key not in config_common_kwargs]
         # If this part of the test fails, you have arguments to addin config_common_kwargs above.
         self.assertListEqual(
             __snake_case     ,   ['''is_encoder_decoder''', '''_name_or_path''', '''_commit_hash''', '''transformers_version''']       )
         snake_case											=							[key for key, value in config_common_kwargs.items() if value == getattr(__snake_case     ,   __snake_case       )]
         if len(__snake_case       ) > 0:
              raise ValueError(
                  '''The following keys are set with the default values in'''
                  ''' `test_configuration_common.config_common_kwargs` pick another value for them:'''
                  F''' {", ".join(__snake_case       )}.'''       )
    def 						a_     (			self       ):
         with self.assertRaises(__snake_case       ):
              # config is in subfolder, the following should not work without specifying the subfolder
              snake_case											=							BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''       )

         snake_case											=							BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''     ,   subfolder='''bert'''       )

         self.assertIsNotNone(__snake_case       )
    def 						a_     (			self       ):
         # A mock response for an HTTP head request to emulate server down
         snake_case											=							mock.Mock()
         snake_case											=							5_0_0
         snake_case											=							{}
         snake_case											=							HTTPError
         snake_case											=							{}

         # Download this model to make sure it's in the cache.
         snake_case											=							BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''       )

         # Under the mock environment we get a 500 error when trying to reach the model.
         with mock.patch('''requests.Session.request'''     ,   return_value=__snake_case       ) as mock_head:
              snake_case											=							BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''       )
              # This check we did call the fake head request
              mock_head.assert_called()
    def 						a_     (			self       ):
         # This test is for deprecated behavior and can be removed in v5
         snake_case											=							BertConfig.from_pretrained(
             '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'''       )
    def 						a_     (			self       ):
         snake_case											=							AutoConfig.from_pretrained('''bert-base-cased'''       )
         snake_case											=							['''config.4.0.0.json''']

         with tempfile.TemporaryDirectory() as tmp_dir:
              configuration.save_pretrained(__snake_case       )
              snake_case											=							2
              json.dump(configuration.to_dict()     ,   open(os.path.join(__snake_case     ,   '''config.4.0.0.json'''       )     ,   '''w'''       )       )

              # This should pick the new configuration file as the version of Transformers is > 4.0.0
              snake_case											=							AutoConfig.from_pretrained(__snake_case       )
              self.assertEqual(new_configuration.hidden_size     ,   2       )

              # Will need to be adjusted if we reach v42 and this test is still here.
              # Should pick the old configuration file as the version of Transformers is < 4.42.0
              snake_case											=							['''config.42.0.0.json''']
              snake_case											=							7_6_8
              configuration.save_pretrained(__snake_case       )
              shutil.move(os.path.join(__snake_case     ,   '''config.4.0.0.json'''       )     ,   os.path.join(__snake_case     ,   '''config.42.0.0.json'''       )       )
              snake_case											=							AutoConfig.from_pretrained(__snake_case       )
              self.assertEqual(new_configuration.hidden_size     ,   7_6_8       )




    def 						a_     (			self       ):
         # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
         snake_case											=							'''hf-internal-testing/test-two-configs'''

         import transformers as new_transformers

         snake_case											=							'''v4.0.0'''
         snake_case					,    snake_case											=							new_transformers.models.auto.AutoConfig.from_pretrained(
             __snake_case     ,   return_unused_kwargs=__snake_case       )
         self.assertEqual(new_configuration.hidden_size     ,   2       )
         # This checks `_configuration_file` ia not kept in the kwargs by mistake.
         self.assertDictEqual(__snake_case     ,   {}       )

         # Testing an older version by monkey-patching the version in the module it's used.
         import transformers as old_transformers

         snake_case											=							'''v3.0.0'''
         snake_case											=							old_transformers.models.auto.AutoConfig.from_pretrained(__snake_case       )
         self.assertEqual(old_configuration.hidden_size     ,   7_6_8       )








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()
_SCREAMING_SNAKE_CASE     :					int      =       logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE     :					Any      =       "The Nymphenburg Palace is a beautiful palace in Munich!"
def      UpperCAmelCase__		(UpperCamelCase_				,UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							{
         '''attention_cell''': '''multi_head''',
         '''num_layers''': 4,
         '''units''': 10_24,
         '''hidden_size''': 7_68,
         '''max_length''': 5_12,
         '''num_heads''': 8,
         '''scaled''': True,
         '''dropout''': 0.1,
         '''use_residual''': True,
         '''embed_size''': 10_24,
         '''embed_dropout''': 0.1,
         '''word_embed''': None,
         '''layer_norm_eps''': 1e-5,
         '''token_type_vocab_size''': 2,
     }

     snake_case											=							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
     snake_case											=							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=UpperCamelCase_				,output_all_encodings=UpperCamelCase_				,use_residual=predefined_args['''use_residual''']				,activation=predefined_args.get('''activation'''				,'''gelu'''							)				,layer_norm_eps=predefined_args.get('''layer_norm_eps'''				,UpperCamelCase_							)				,)

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

     # Specify download folder to Gluonnlp's vocab
     snake_case											=							os.path.join(get_home_dir()				,'''models'''							)
     snake_case											=							_load_vocab(UpperCamelCase_				,UpperCamelCase_				,UpperCamelCase_				,cls=UpperCamelCase_							)

     snake_case											=							nlp.model.BERTModel(
         UpperCamelCase_				,len(UpperCamelCase_							)				,units=predefined_args['''units''']				,embed_size=predefined_args['''embed_size''']				,embed_dropout=predefined_args['''embed_dropout''']				,word_embed=predefined_args['''word_embed''']				,use_pooler=UpperCamelCase_				,use_token_type_embed=UpperCamelCase_				,token_type_vocab_size=predefined_args['''token_type_vocab_size''']				,use_classifier=UpperCamelCase_				,use_decoder=UpperCamelCase_				,)

     original_bort.load_parameters(UpperCamelCase_				,cast_dtype=UpperCamelCase_				,ignore_extra=UpperCamelCase_							)
     snake_case											=							original_bort._collect_params_with_prefix()

     # Build our config 🤗
     snake_case											=							{
         '''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(UpperCamelCase_							),
     }

     snake_case											=							BertConfig.from_dict(UpperCamelCase_							)
     snake_case											=							BertForMaskedLM(UpperCamelCase_							)
     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(UpperCamelCase_							) -> 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(UpperCamelCase_				,UpperCamelCase_							):
          snake_case											=							hf_param.shape

          snake_case											=							to_torch(params[gluon_param]							)
          snake_case											=							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

     snake_case											=							check_and_map_params(
         hf_bort_model.bert.embeddings.word_embeddings.weight				,'''word_embed.0.weight'''							)
     snake_case											=							check_and_map_params(
         hf_bort_model.bert.embeddings.position_embeddings.weight				,'''encoder.position_weight'''							)
     snake_case											=							check_and_map_params(
         hf_bort_model.bert.embeddings.LayerNorm.bias				,'''encoder.layer_norm.beta'''							)
     snake_case											=							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)
     snake_case											=							torch.zeros_like(
         hf_bort_model.bert.embeddings.token_type_embeddings.weight.data							)

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

          # self attention
          snake_case											=							layer.attention.self

          snake_case											=							check_and_map_params(
              self_attn.key.bias.data				,F'''encoder.transformer_cells.{i}.attention_cell.proj_key.bias'''							)

          snake_case											=							check_and_map_params(
              self_attn.key.weight.data				,F'''encoder.transformer_cells.{i}.attention_cell.proj_key.weight'''							)
          snake_case											=							check_and_map_params(
              self_attn.query.bias.data				,F'''encoder.transformer_cells.{i}.attention_cell.proj_query.bias'''							)
          snake_case											=							check_and_map_params(
              self_attn.query.weight.data				,F'''encoder.transformer_cells.{i}.attention_cell.proj_query.weight'''							)
          snake_case											=							check_and_map_params(
              self_attn.value.bias.data				,F'''encoder.transformer_cells.{i}.attention_cell.proj_value.bias'''							)
          snake_case											=							check_and_map_params(
              self_attn.value.weight.data				,F'''encoder.transformer_cells.{i}.attention_cell.proj_value.weight'''							)

          # self attention output
          snake_case											=							layer.attention.output

          snake_case											=							check_and_map_params(
              self_output.dense.bias				,F'''encoder.transformer_cells.{i}.proj.bias'''							)
          snake_case											=							check_and_map_params(
              self_output.dense.weight				,F'''encoder.transformer_cells.{i}.proj.weight'''							)
          snake_case											=							check_and_map_params(
              self_output.LayerNorm.bias				,F'''encoder.transformer_cells.{i}.layer_norm.beta'''							)
          snake_case											=							check_and_map_params(
              self_output.LayerNorm.weight				,F'''encoder.transformer_cells.{i}.layer_norm.gamma'''							)

          # intermediate
          snake_case											=							layer.intermediate

          snake_case											=							check_and_map_params(
              intermediate.dense.bias				,F'''encoder.transformer_cells.{i}.ffn.ffn_1.bias'''							)
          snake_case											=							check_and_map_params(
              intermediate.dense.weight				,F'''encoder.transformer_cells.{i}.ffn.ffn_1.weight'''							)

          # output
          snake_case											=							layer.output

          snake_case											=							check_and_map_params(
              bert_output.dense.bias				,F'''encoder.transformer_cells.{i}.ffn.ffn_2.bias'''							)
          snake_case											=							check_and_map_params(
              bert_output.dense.weight				,F'''encoder.transformer_cells.{i}.ffn.ffn_2.weight'''							)
          snake_case											=							check_and_map_params(
              bert_output.LayerNorm.bias				,F'''encoder.transformer_cells.{i}.ffn.layer_norm.beta'''							)
          snake_case											=							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
     snake_case											=							RobertaTokenizer.from_pretrained('''roberta-base'''							)

     snake_case											=							tokenizer.encode_plus(UpperCamelCase_							)['''input_ids''']

     # Get gluon output
     snake_case											=							mx.nd.array([input_ids]							)
     snake_case											=							original_bort(inputs=UpperCamelCase_				,token_types=[]							)

     # Get Transformer output (save and reload model again)
     hf_bort_model.save_pretrained(UpperCamelCase_							)
     snake_case											=							BertModel.from_pretrained(UpperCamelCase_							)
     hf_bort_model.eval()

     snake_case											=							tokenizer.encode_plus(UpperCamelCase_				,return_tensors='''pt'''							)
     snake_case											=							hf_bort_model(**UpperCamelCase_							)[0]

     snake_case											=							output_gluon[0].asnumpy()
     snake_case											=							output_hf[0].detach().numpy()

     snake_case											=							np.max(np.abs(hf_layer - gluon_layer							)							).item()
     snake_case											=							np.allclose(UpperCamelCase_				,UpperCamelCase_				,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:'''				,UpperCamelCase_							)


if __name__ == "__main__":
 _SCREAMING_SNAKE_CASE     :					List[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."
 )
 _SCREAMING_SNAKE_CASE     :					Optional[int]      =       parser.parse_args()
 convert_bort_checkpoint_to_pytorch(args.bort_checkpoint_path, args.pytorch_dump_folder_path)




